attempt to fix coverage

Author: fira7s

tests/datamodules/classification/test_cifar100.py

@@ -254,3 +254,73 @@ def _fake_get_ood(**_):
         assert idx["near_oods"] == [3]
         assert idx["far_oods"] == [4]
         assert idx["shift"] == []
+
+    def test_assigns_dataset_name_when_missing(self, monkeypatch):
+        """If OOD datasets lack `dataset_name`, setup() should assign class-name.lower()."""
+        dm = CIFAR100DataModule(
+            root="./data/",
+            batch_size=16,
+            train_transform=nn.Identity(),
+            test_transform=nn.Identity(),
+            eval_ood=True,
+        )
+        dm.dataset = DummyClassificationDataset
+        dm.shift_dataset = DummyClassificationDataset
+
+        class _NoNameDS:
+            def __init__(
+                self, root="./data/", train=False, download=False, transform=None, num_images=3
+            ):
+                self.data = list(range(num_images))
+                self.transform = transform
+
+            def __len__(self):
+                return len(self.data)
+
+            def __getitem__(self, i):
+                x = self.data[i]
+                return (x if self.transform is None else self.transform(x)), 0
+
+        def _mock_get_ood(**_):
+            test_ood = _NoNameDS(num_images=3)
+            val_ood = _NoNameDS(num_images=4)
+            near_default = {"nearA": _NoNameDS(num_images=5)}
+            far_default = {"farB": _NoNameDS(num_images=6)}
+            return test_ood, val_ood, near_default, far_default
+
+        monkeypatch.setattr(
+            "torch_uncertainty.datamodules.classification.cifar100.get_ood_datasets",
+            _mock_get_ood,
+        )
+
+        dm.setup("test")
+
+        assert hasattr(dm.val_ood, "dataset_name")
+        assert dm.val_ood.dataset_name == "_nonameds"
+        for ds in dm.near_oods + dm.far_oods:
+            assert hasattr(ds, "dataset_name")
+            assert ds.dataset_name == "_nonameds"
+
+        assert dm.near_ood_names == [ds.dataset_name for ds in dm.near_oods]
+        assert dm.far_ood_names == [ds.dataset_name for ds in dm.far_oods]
+
+    def test_get_indices_empty_when_eval_ood_false(self):
+        dm = CIFAR100DataModule(
+            root="./data/",
+            batch_size=16,
+            train_transform=nn.Identity(),
+            test_transform=nn.Identity(),
+            eval_ood=False,
+            eval_shift=False,
+        )
+        dm.dataset = DummyClassificationDataset
+        dm.shift_dataset = DummyClassificationDataset
+        dm.setup("test")
+
+        idx = dm.get_indices()
+        assert idx["test"] == [0]
+        assert idx["test_ood"] == []
+        assert idx["val_ood"] == []
+        assert idx["near_oods"] == []
+        assert idx["far_oods"] == []
+        assert idx["shift"] == []

tests/routines/test_classification.py

@@ -655,3 +655,31 @@ def test_shift_ens_update_path(self):
             )
         )
         routine.test_step((x, y), batch_idx=0, dataloader_idx=7)
+
+    def test_logs_when_eval_flags_mismatch_datamodule(self, caplog):
+        model = dummy_ood_model(in_channels=3, feat_dim=64, num_classes=3)
+        routine = ClassificationRoutine(
+            model=model, loss=None, num_classes=3, eval_ood=False, eval_shift=False
+        )
+        routine.ood_criterion = MaxSoftmaxCriterion()
+
+        class _DM:
+            def get_indices(self):
+                return {"val_ood": 9, "near_oods": [2], "far_oods": [3], "shift": [4]}
+
+        routine._trainer = types.SimpleNamespace(barebones=True, datamodule=_DM())
+
+        x = torch.rand(2, 3, 8, 8)
+        y = torch.tensor([0, 1])
+
+        with caplog.at_level(logging.INFO):
+            routine.test_step((x, y), batch_idx=0, dataloader_idx=0)
+
+        assert any(
+            "`eval_ood` to `True` in the datamodule and not in the routine" in r.message
+            for r in caplog.records
+        )
+        assert any(
+            "`eval_shift` to `True` in the datamodule and not in the routine" in r.message
+            for r in caplog.records
+        )

torch_uncertainty/routines/classification.py

@@ -440,35 +440,21 @@ def _hyperparam_search_ood(self):
                 # ID val
                 for x, _ in id_val:
                     x = x.to(self.device)
-                    logits = self.model(x)
-
-                    if crit.input_type == OODCriterionInputType.LOGIT:
-                        s = crit(logits).cpu().numpy()
-                    elif crit.input_type == OODCriterionInputType.PROB:
-                        probs = F.softmax(logits, dim=-1)
-                        s = crit(probs).cpu().numpy()
-                    else:  # DATASET
-                        with torch.inference_mode(False), torch.enable_grad():
-                            x_input = x.detach().clone().requires_grad_(True)
-                            s = crit(self.model, x_input).cpu().numpy()
+
+                    with torch.inference_mode(False), torch.enable_grad():
+                        x_input = x.detach().clone().requires_grad_(True)
+                        s = crit(self.model, x_input).cpu().numpy()
 
                     all_scores.append(s)
                     all_labels.append(np.zeros_like(s))
 
                 # OODval splits
                 for x, _ in ood_val:
                     x = x.to(self.device)
-                    logits = self.model(x)
-
-                    if crit.input_type == OODCriterionInputType.LOGIT:
-                        s = crit(logits).cpu().numpy()
-                    elif crit.input_type == OODCriterionInputType.PROB:
-                        probs = F.softmax(logits, dim=-1)
-                        s = crit(probs).cpu().numpy()
-                    else:  # DATASET
-                        with torch.inference_mode(False), torch.enable_grad():
-                            x_input = x.detach().clone().requires_grad_(True)
-                            s = crit(self.model, x_input).cpu().numpy()
+
+                    with torch.inference_mode(False), torch.enable_grad():
+                        x_input = x.detach().clone().requires_grad_(True)
+                        s = crit(self.model, x_input).cpu().numpy()
 
                     all_scores.append(s)
                     all_labels.append(np.ones_like(s))