quadra 2.3.0a2__py3-none-any.whl → 2.3.1__py3-none-any.whl

quadra/datamodules/segmentation.py

@@ -187,7 +187,7 @@ class SegmentationDataModule(BaseDataModule):
             samples_test, targets_test, masks_test = self._read_split(self.test_split_file)
             if not self.train_split_file:
                 samples_train, targets_train, masks_train = [], [], []
-                for sample, target, mask in zip(all_samples, all_targets, all_masks):
+                for sample, target, mask in zip(all_samples, all_targets, all_masks, strict=False):
                     if sample not in samples_test:
                         samples_train.append(sample)
                         targets_train.append(target)
@@ -197,7 +197,7 @@ class SegmentationDataModule(BaseDataModule):
             samples_train, targets_train, masks_train = self._read_split(self.train_split_file)
             if not self.test_split_file:
                 samples_test, targets_test, masks_test = [], [], []
-                for sample, target, mask in zip(all_samples, all_targets, all_masks):
+                for sample, target, mask in zip(all_samples, all_targets, all_masks, strict=False):
                     if sample not in samples_train:
                         samples_test.append(sample)
                         targets_test.append(target)
@@ -549,7 +549,7 @@ class SegmentationMulticlassDataModule(BaseDataModule):
                 samples_and_masks_test,
                 targets_test,
             ) = iterative_train_test_split(
-                np.expand_dims(np.array(list(zip(all_samples, all_masks))), 1),
+                np.expand_dims(np.array(list(zip(all_samples, all_masks, strict=False))), 1),
                 np.array(all_targets),
                 test_size=self.test_size,
             )
@@ -561,7 +561,7 @@ class SegmentationMulticlassDataModule(BaseDataModule):
             samples_test, targets_test, masks_test = self._read_split(self.test_split_file)
             if not self.train_split_file:
                 samples_train, targets_train, masks_train = [], [], []
-                for sample, target, mask in zip(all_samples, all_targets, all_masks):
+                for sample, target, mask in zip(all_samples, all_targets, all_masks, strict=False):
                     if sample not in samples_test:
                         samples_train.append(sample)
                         targets_train.append(target)
@@ -571,7 +571,7 @@ class SegmentationMulticlassDataModule(BaseDataModule):
             samples_train, targets_train, masks_train = self._read_split(self.train_split_file)
             if not self.test_split_file:
                 samples_test, targets_test, masks_test = [], [], []
-                for sample, target, mask in zip(all_samples, all_targets, all_masks):
+                for sample, target, mask in zip(all_samples, all_targets, all_masks, strict=False):
                     if sample not in samples_train:
                         samples_test.append(sample)
                         targets_test.append(target)
@@ -583,7 +583,7 @@ class SegmentationMulticlassDataModule(BaseDataModule):
                 raise ValueError("Validation split file is specified but no train or test split file is specified.")
         else:
             samples_and_masks_train, targets_train, samples_and_masks_val, targets_val = iterative_train_test_split(
-                np.expand_dims(np.array(list(zip(samples_train, masks_train))), 1),
+                np.expand_dims(np.array(list(zip(samples_train, masks_train, strict=False))), 1),
                 np.array(targets_train),
                 test_size=self.val_size,
             )

quadra/datasets/anomaly.py

@@ -220,7 +220,7 @@ class AnomalyDataset(Dataset):
             if not os.path.exists(valid_area_mask):
                 raise RuntimeError(f"Valid area mask {valid_area_mask} does not exist.")
 
-            self.valid_area_mask = cv2.imread(valid_area_mask, 0) > 0  # type: ignore[operator]
+            self.valid_area_mask = cv2.imread(valid_area_mask, 0) > 0
 
     def __len__(self) -> int:
         """Get length of the dataset."""
@@ -265,7 +265,7 @@ class AnomalyDataset(Dataset):
                 if label_index == 0:
                     mask = np.zeros(shape=original_image_shape[:2])
                 elif os.path.isfile(mask_path):
-                    mask = cv2.imread(mask_path, flags=0) / 255.0  # type: ignore[operator]
+                    mask = cv2.imread(mask_path, flags=0) / 255.0
                 else:
                     # We need ones in the mask to compute correctly at least image level f1 score
                     mask = np.ones(shape=original_image_shape[:2])

quadra/datasets/classification.py

@@ -50,9 +50,9 @@ class ImageClassificationListDataset(Dataset):
         allow_missing_label: bool | None = False,
     ):
         super().__init__()
-        assert len(samples) == len(
-            targets
-        ), f"Samples ({len(samples)}) and targets ({len(targets)}) must have the same length"
+        assert len(samples) == len(targets), (
+            f"Samples ({len(samples)}) and targets ({len(targets)}) must have the same length"
+        )
         # Setting the ROI
         self.roi = roi
 
@@ -201,9 +201,9 @@ class MultilabelClassificationDataset(torch.utils.data.Dataset):
         rgb: bool = True,
     ):
         super().__init__()
-        assert len(samples) == len(
-            targets
-        ), f"Samples ({len(samples)}) and targets ({len(targets)}) must have the same length"
+        assert len(samples) == len(targets), (
+            f"Samples ({len(samples)}) and targets ({len(targets)}) must have the same length"
+        )
 
         # Data
         self.x = samples
@@ -215,7 +215,7 @@ class MultilabelClassificationDataset(torch.utils.data.Dataset):
             class_to_idx = {c: i for i, c in enumerate(range(unique_targets))}
         self.class_to_idx = class_to_idx
         self.idx_to_class = {v: k for k, v in class_to_idx.items()}
-        self.samples = list(zip(self.x, self.y))
+        self.samples = list(zip(self.x, self.y, strict=False))
         self.rgb = rgb
         self.transform = transform
 

quadra/datasets/patch.py

@@ -58,7 +58,7 @@ class PatchSklearnClassificationTrainDataset(Dataset):
 
             cls, counts = np.unique(targets_array, return_counts=True)
             max_count = np.max(counts)
-            for cl, count in zip(cls, counts):
+            for cl, count in zip(cls, counts, strict=False):
                 idx_to_pick = list(np.where(targets_array == cl)[0])
 
                 if count < max_count:

quadra/datasets/ssl.py

@@ -75,9 +75,9 @@ class TwoSetAugmentationDataset(Dataset):
             return the original image.
 
     Example:
-        >>> images[0] = global_transform[0](original_image)
-        >>> images[1] = global_transform[1](original_image)
-        >>> images[2:] = local_transform(s)(original_image)
+        >>> `images[0] = global_transform[0](original_image)`
+        >>> `images[1] = global_transform[1](original_image)`
+        >>> `images[2:] = local_transform(s)(original_image)`
     """
 
     def __init__(

quadra/metrics/segmentation.py

@@ -171,7 +171,7 @@ def segmentation_props(
         # Add dummy Dices so LSA is unique and i can compute FP and FN
         dice_mat = _pad_to_shape(dice_mat, (max_dim, max_dim), 1)
         lsa = linear_sum_assignment(dice_mat, maximize=False)
-        for row, col in zip(lsa[0], lsa[1]):
+        for row, col in zip(lsa[0], lsa[1], strict=False):
             # More preds than GTs --> False Positive
             if row < n_labels_pred and col >= n_labels_mask:
                 min_row = pred_bbox[row][0]

quadra/models/base.py

@@ -76,7 +76,7 @@ class ModelSignatureWrapper(nn.Module):
 
         if isinstance(self.instance.forward, torch.ScriptMethod):
             # Handle torchscript backbones
-            for i, argument in enumerate(self.instance.forward.schema.arguments):
+            for i, argument in enumerate(self.instance.forward.schema.arguments):  # type: ignore[attr-defined]
                 if i < (len(args) + 1):  # +1 for self
                     continue
 

quadra/models/evaluation.py

@@ -209,7 +209,7 @@ class ONNXEvaluationModel(BaseEvaluationModel):
 
         onnx_inputs: dict[str, np.ndarray | torch.Tensor] = {}
 
-        for onnx_input, current_input in zip(self.model.get_inputs(), inputs):
+        for onnx_input, current_input in zip(self.model.get_inputs(), inputs, strict=False):
             if isinstance(current_input, torch.Tensor):
                 onnx_inputs[onnx_input.name] = current_input
                 use_pytorch = True

quadra/modules/base.py

@@ -7,6 +7,7 @@ import pytorch_lightning as pl
 import sklearn
 import torch
 import torchmetrics
+from pytorch_lightning.utilities.types import OptimizerLRScheduler
 from sklearn.linear_model import LogisticRegression
 from torch import nn
 from torch.optim import Optimizer
@@ -48,7 +49,7 @@ class BaseLightningModule(pl.LightningModule):
         """
         return self.model(x)
 
-    def configure_optimizers(self) -> tuple[list[Any], list[dict[str, Any]]]:
+    def configure_optimizers(self) -> OptimizerLRScheduler:
         """Get default optimizer if not passed a value.
 
         Returns:
@@ -68,7 +69,7 @@ class BaseLightningModule(pl.LightningModule):
             "monitor": "val_loss",
             "strict": False,
         }
-        return [self.optimizer], [lr_scheduler_conf]
+        return [self.optimizer], [lr_scheduler_conf]  # type: ignore[return-value]
 
     # pylint: disable=unused-argument
     def optimizer_zero_grad(self, epoch, batch_idx, optimizer, optimizer_idx: int = 0):

quadra/modules/ssl/byol.py

@@ -110,6 +110,7 @@ class BYOL(SSLModule):
             for student_ps, teacher_ps in zip(
                 list(self.model.parameters()) + list(self.student_projection_mlp.parameters()),
                 list(self.teacher.parameters()) + list(self.teacher_projection_mlp.parameters()),
+                strict=False,
             ):
                 teacher_ps.data = teacher_ps.data * teacher_momentum + (1 - teacher_momentum) * student_ps.data
 

quadra/tasks/anomaly.py

@@ -161,7 +161,7 @@ class AnomalibDetection(Generic[AnomalyDataModuleT], LightningTask[AnomalyDataMo
         all_output_flatten: dict[str, torch.Tensor | list] = {}
 
         for key in all_output[0]:
-            if type(all_output[0][key]) == torch.Tensor:
+            if isinstance(all_output[0][key], torch.Tensor):
                 tensor_gatherer = torch.cat([x[key] for x in all_output])
                 all_output_flatten[key] = tensor_gatherer
             else:
@@ -205,13 +205,15 @@ class AnomalibDetection(Generic[AnomalyDataModuleT], LightningTask[AnomalyDataMo
             class_to_idx.pop("false_defect")
 
         anomaly_scores = all_output_flatten["pred_scores"]
+
+        exportable_anomaly_scores: list[Any] | np.ndarray
         if isinstance(anomaly_scores, torch.Tensor):
             exportable_anomaly_scores = anomaly_scores.cpu().numpy()
         else:
             exportable_anomaly_scores = anomaly_scores
 
         # Zip the lists together to create rows for the CSV file
-        rows = zip(image_paths, pred_labels, gt_labels, exportable_anomaly_scores)
+        rows = zip(image_paths, pred_labels, gt_labels, exportable_anomaly_scores, strict=False)
         # Specify the CSV file name
         csv_file = "test_predictions.csv"
         # Write the data to the CSV file
@@ -483,7 +485,7 @@ class AnomalibEvaluation(Evaluation[AnomalyDataModule]):
 
         if hasattr(self.datamodule, "valid_area_mask") and self.datamodule.valid_area_mask is not None:
             mask_area = cv2.imread(self.datamodule.valid_area_mask, 0)
-            mask_area = (mask_area > 0).astype(np.uint8)  # type: ignore[operator]
+            mask_area = (mask_area > 0).astype(np.uint8)
 
         if hasattr(self.datamodule, "crop_area") and self.datamodule.crop_area is not None:
             crop_area = self.datamodule.crop_area
@@ -499,12 +501,13 @@ class AnomalibEvaluation(Evaluation[AnomalyDataModule]):
                 self.metadata["image_labels"],
                 anomaly_scores,
                 anomaly_maps,
+                strict=False,
             ),
             total=len(self.metadata["image_paths"]),
         ):
             img = cv2.imread(img_path, 0)
             if mask_area is not None:
-                img = img * mask_area  # type: ignore[operator]
+                img = img * mask_area
 
             if crop_area is not None:
                 img = img[crop_area[1] : crop_area[3], crop_area[0] : crop_area[2]]

quadra/tasks/base.py

@@ -382,15 +382,19 @@ class Evaluation(Generic[DataModuleT], Task[DataModuleT]):
             # We assume that each input size has the same height and width
             if input_size[1] != self.config.transforms.input_height:
                 log.warning(
-                    f"Input height of the model ({input_size[1]}) is different from the one specified "
-                    + f"in the config ({self.config.transforms.input_height}). Fixing the config."
+                    "Input height of the model (%s) is different from the one specified "
+                    + "in the config (%s). Fixing the config.",
+                    input_size[1],
+                    self.config.transforms.input_height,
                 )
                 self.config.transforms.input_height = input_size[1]
 
             if input_size[2] != self.config.transforms.input_width:
                 log.warning(
-                    f"Input width of the model ({input_size[2]}) is different from the one specified "
-                    + f"in the config ({self.config.transforms.input_width}). Fixing the config."
+                    "Input width of the model (%s) is different from the one specified "
+                    + "in the config (%s). Fixing the config.",
+                    input_size[2],
+                    self.config.transforms.input_width,
                 )
                 self.config.transforms.input_width = input_size[2]
 

quadra/tasks/classification.py

@@ -623,7 +623,9 @@ class SklearnClassification(Generic[SklearnClassificationDataModuleT], Task[Skle
             all_labels = all_labels[sorted_indices]
 
         # cycle over all train/test split
-        for train_dataloader, test_dataloader in zip(self.train_dataloader_list, self.test_dataloader_list):
+        for train_dataloader, test_dataloader in zip(
+            self.train_dataloader_list, self.test_dataloader_list, strict=False
+        ):
             # Reinit classifier
             self.model = self.config.model
             self.trainer.change_classifier(self.model)
@@ -685,7 +687,7 @@ class SklearnClassification(Generic[SklearnClassificationDataModuleT], Task[Skle
             dl: PyTorch dataloader
             feature_extractor: PyTorch backbone
         """
-        if isinstance(feature_extractor, (TorchEvaluationModel, TorchscriptEvaluationModel)):
+        if isinstance(feature_extractor, TorchEvaluationModel | TorchscriptEvaluationModel):
             # TODO: I'm not sure torchinfo supports torchscript models
             # If we are working with torch based evaluation models we need to extract the model
             feature_extractor = feature_extractor.model
@@ -1202,6 +1204,8 @@ class ClassificationEvaluation(Evaluation[ClassificationDataModuleT]):
         probabilities = [max(item) for sublist in probabilities for item in sublist]
         if self.datamodule.class_to_idx is not None:
             idx_to_class = {v: k for k, v in self.datamodule.class_to_idx.items()}
+        else:
+            idx_to_class = None
 
         _, pd_cm, test_accuracy = get_results(
             test_labels=image_labels,

quadra/tasks/patch.py

@@ -301,7 +301,7 @@ class PatchSklearnTestClassification(Evaluation[PatchSklearnClassificationDataMo
             "test_results": None,
             "test_labels": None,
         }
-        self.class_to_skip: list[str] = []
+        self.class_to_skip: list[str] | None = []
         self.reconstruction_results: dict[str, Any]
         self.return_polygon: bool = True
 

quadra/tasks/segmentation.py

@@ -92,8 +92,10 @@ class Segmentation(Generic[SegmentationDataModuleT], LightningTask[SegmentationD
             len(self.datamodule.idx_to_class) + 1
         ):
             log.warning(
-                f"Number of classes in the model ({module_config.model.num_classes}) does not match the number of "
-                + f"classes in the datamodule ({len(self.datamodule.idx_to_class)}). Updating the model..."
+                "Number of classes in the model (%s) does not match the number of "
+                + "classes in the datamodule (%d). Updating the model...",
+                module_config.model.num_classes,
+                len(self.datamodule.idx_to_class),
             )
             module_config.model.num_classes = len(self.datamodule.idx_to_class) + 1
 
@@ -341,7 +343,7 @@ class SegmentationAnalysisEvaluation(SegmentationEvaluation):
         if self.datamodule.test_dataset_available:
             stages.append("test")
             dataloaders.append(self.datamodule.test_dataloader())
-        for stage, dataloader in zip(stages, dataloaders):
+        for stage, dataloader in zip(stages, dataloaders, strict=False):
             log.info("Running inference on %s set with batch size: %d", stage, dataloader.batch_size)
             image_list, mask_list, mask_pred_list, label_list = [], [], [], []
             for batch in dataloader:
@@ -369,10 +371,10 @@ class SegmentationAnalysisEvaluation(SegmentationEvaluation):
 
         for stage, output in self.test_output.items():
             image_mean = OmegaConf.to_container(self.config.transforms.mean)
-            if not isinstance(image_mean, list) or any(not isinstance(x, (int, float)) for x in image_mean):
+            if not isinstance(image_mean, list) or any(not isinstance(x, int | float) for x in image_mean):
                 raise ValueError("Image mean is not a list of float or integer values, please check your config")
             image_std = OmegaConf.to_container(self.config.transforms.std)
-            if not isinstance(image_std, list) or any(not isinstance(x, (int, float)) for x in image_std):
+            if not isinstance(image_std, list) or any(not isinstance(x, int | float) for x in image_std):
                 raise ValueError("Image std is not a list of float or integer values, please check your config")
             reports = create_mask_report(
                 stage=stage,

quadra/tasks/ssl.py

@@ -468,8 +468,7 @@ class EmbeddingVisualization(Task):
         self.report_folder = report_folder
         if self.model_path is None:
             raise ValueError(
-                "Model path cannot be found!, please specify it in the config or pass it as an argument for"
-                " evaluation"
+                "Model path cannot be found!, please specify it in the config or pass it as an argument for evaluation"
             )
         self.embeddings_path = os.path.join(self.model_path, self.report_folder)
         if not os.path.exists(self.embeddings_path):
@@ -547,7 +546,7 @@ class EmbeddingVisualization(Task):
                 im = interpolate(im, self.embedding_image_size)
 
             images.append(im.cpu())
-            metadata.extend(zip(targets, class_names, file_paths))
+            metadata.extend(zip(targets, class_names, file_paths, strict=False))
             counter += len(im)
         images = torch.cat(images, dim=0)
         embeddings = torch.cat(embeddings, dim=0)

quadra/utils/classification.py

@@ -46,12 +46,10 @@ def get_file_condition(
         if any(fil in root for fil in exclude_filter):
             return False
 
-    if include_filter is not None and (
-        not any(fil in file_name for fil in include_filter) and not any(fil in root for fil in include_filter)
-    ):
-        return False
-
-    return True
+    return not (
+        include_filter is not None
+        and (not any(fil in file_name for fil in include_filter) and not any(fil in root for fil in include_filter))
+    )
 
 
 def natural_key(string_):
@@ -130,7 +128,7 @@ def find_images_and_targets(
         sorted_labels = sorted(unique_labels, key=natural_key)
         class_to_idx = {str(c): idx for idx, c in enumerate(sorted_labels)}
 
-    images_and_targets = [(f, l) for f, l in zip(filenames, labels) if l in class_to_idx]
+    images_and_targets = [(f, l) for f, l in zip(filenames, labels, strict=False) if l in class_to_idx]
 
     if sort:
         images_and_targets = sorted(images_and_targets, key=lambda k: natural_key(k[0]))
@@ -210,7 +208,7 @@ def find_test_image(
             file_samples.append(sample_path)
 
         test_split = [os.path.join(folder, sample.strip()) for sample in file_samples]
-        labels = [t for s, t in zip(filenames, labels) if s in file_samples]
+        labels = [t for s, t in zip(filenames, labels, strict=False) if s in file_samples]
         filenames = [s for s in filenames if s in file_samples]
         log.info("Selected %d images using test_split_file for the test", len(filenames))
         if len(filenames) != len(file_samples):
@@ -353,7 +351,7 @@ def get_split(
 
     cl, counts = np.unique(targets, return_counts=True)
 
-    for num, _cl in zip(counts, cl):
+    for num, _cl in zip(counts, cl, strict=False):
         if num == 1:
             to_remove = np.where(np.array(targets) == _cl)[0][0]
             samples = np.delete(np.array(samples), to_remove)
@@ -378,7 +376,7 @@ def get_split(
             file_samples.append(sample_path)
 
         train_split = [os.path.join(image_dir, sample.strip()) for sample in file_samples]
-        targets = np.array([t for s, t in zip(samples, targets) if s in file_samples])
+        targets = np.array([t for s, t in zip(samples, targets, strict=False) if s in file_samples])
         samples = np.array([s for s in samples if s in file_samples])
 
     if limit_training_data is not None:

quadra/utils/evaluation.py

@@ -4,6 +4,7 @@ import os
 from ast import literal_eval
 from collections.abc import Callable
 from functools import wraps
+from typing import Any
 
 import matplotlib.pyplot as plt
 import numpy as np
@@ -123,7 +124,7 @@ def calculate_mask_based_metrics(
     th_thresh_preds = (th_preds > threshold).float().cpu()
     thresh_preds = th_thresh_preds.squeeze(0).numpy()
     dice_scores = metric(th_thresh_preds, th_masks, reduction=None).numpy()
-    result = {}
+    result: dict[str, Any] = {}
     if multilabel:
         if n_classes is None:
             raise ValueError("n_classes arg shouldn't be None when multilabel is True")
@@ -167,7 +168,7 @@ def calculate_mask_based_metrics(
         "Accuracy": [],
     }
     for idx, (image, pred, mask, thresh_pred, dice_score) in enumerate(
-        zip(images, preds, masks, thresh_preds, dice_scores)
+        zip(images, preds, masks, thresh_preds, dice_scores, strict=False)
     ):
         if np.sum(mask) == 0:
             good_dice.append(dice_score)
@@ -261,6 +262,7 @@ def create_mask_report(
     th_labels = output["label"]
     n_classes = th_preds.shape[1]
     # TODO: Apply sigmoid is a wrong name now
+    # TODO: Apply sigmoid false is untested
     if apply_sigmoid:
         if n_classes == 1:
             th_preds = torch.nn.Sigmoid()(th_preds)
@@ -271,6 +273,13 @@ def create_mask_report(
             # Compute labels from the given masks since by default they are all 0
             th_labels = th_masks.max(dim=2)[0].max(dim=2)[0].squeeze(dim=1)
             show_orj_predictions = False
+    elif n_classes == 1:
+        th_thresh_preds = (th_preds > threshold).float()
+    else:
+        th_thresh_preds = torch.argmax(th_preds, dim=1).float().unsqueeze(1)
+        # Compute labels from the given masks since by default they are all 0
+        th_labels = th_masks.max(dim=2)[0].max(dim=2)[0].squeeze(dim=1)
+        show_orj_predictions = False
 
     mean = np.asarray(mean)
     std = np.asarray(std)
@@ -303,7 +312,7 @@ def create_mask_report(
     non_zero_score_idx = sorted_idx[~binary_labels]
     zero_score_idx = sorted_idx[binary_labels]
     file_paths = []
-    for name, current_score_idx in zip(["good", "bad"], [zero_score_idx, non_zero_score_idx]):
+    for name, current_score_idx in zip(["good", "bad"], [zero_score_idx, non_zero_score_idx], strict=False):
         if len(current_score_idx) == 0:
             continue