konfai 1.2.4__tar.gz → 1.2.6__tar.gz

{konfai-1.2.4 → konfai-1.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: konfai
-Version: 1.2.4
+Version: 1.2.6
 Summary: Modular and configurable Deep Learning framework with YAML and PyTorch
 Author-email: Valentin Boussot <boussot.v@gmail.com>
 License-Expression: Apache-2.0
@@ -21,6 +21,7 @@ Requires-Dist: SimpleITK
 Requires-Dist: lxml
 Requires-Dist: h5py
 Requires-Dist: pynvml
+Requires-Dist: requests
 Provides-Extra: vtk
 Requires-Dist: vtk; extra == "vtk"
 Provides-Extra: lpips

{konfai-1.2.4 → konfai-1.2.6}/konfai/data/augmentation.py

@@ -218,7 +218,7 @@ class DataAugmentation(NeedDevice, ABC):
     @abstractmethod
     def _inverse(self, index: int, a: int, tensor: torch.Tensor) -> torch.Tensor:
         pass
-
+    
 
 class EulerTransform(DataAugmentation):
 

{konfai-1.2.4 → konfai-1.2.6}/konfai/data/data_manager.py

@@ -515,7 +515,7 @@ class Data(ABC):
                 self.groups_src[group_src][group_dest].load(
                     group_src,
                     group_dest,
-                    [self.datasets[filename] for filename, _ in datasets[group_src]],
+                    list(self.datasets.values()),
                 )
                 model_have_input |= self.groups_src[group_src][group_dest].is_input
         if self.patch is not None:

{konfai-1.2.4 → konfai-1.2.6}/konfai/data/transform.py

@@ -28,6 +28,12 @@ class Transform(NeedDevice, ABC):
     def __call__(self, name: str, tensor: torch.Tensor, cache_attribute: Attribute) -> torch.Tensor:
         pass
 
+class TransformInverse(Transform, ABC):
+
+    def __init__(self, inverse: bool) -> None:
+        super().__init__()
+        self.apply_inverse = inverse
+        
     @abstractmethod
     def inverse(self, name: str, tensor: torch.Tensor, cache_attribute: Attribute) -> torch.Tensor:
         pass
@@ -48,12 +54,14 @@ class Clip(Transform):
 
     def __init__(
         self,
-        min_value: float = -1024,
-        max_value: float = 1024,
+        min_value: float | str = -1024,
+        max_value: float | str = 1024,
         save_clip_min: bool = False,
         save_clip_max: bool = False,
+        mask: str | None = None,
     ) -> None:
-        if max_value <= min_value:
+        super().__init__()
+        if isinstance(min_value, float) and isinstance(max_value, float) and max_value <= min_value:
             raise ValueError(
                 f"[Clip] Invalid clipping range: max_value ({max_value}) must be greater than min_value ({min_value})"
             )
@@ -61,21 +69,69 @@ class Clip(Transform):
         self.max_value = max_value
         self.save_clip_min = save_clip_min
         self.save_clip_max = save_clip_max
+        self.mask = mask
 
     def __call__(self, name: str, tensor: torch.Tensor, cache_attribute: Attribute) -> torch.Tensor:
-        tensor[torch.where(tensor < self.min_value)] = self.min_value
-        tensor[torch.where(tensor > self.max_value)] = self.max_value
+        mask = None
+        if self.mask is not None:
+            for dataset in self.datasets:
+                if dataset.is_dataset_exist(self.mask, name):
+                    mask, _ = dataset.read_data(self.mask, name)
+                    break
+        if mask is None and self.mask is not None:
+            raise ValueError(
+                f"Requested mask '{self.mask}' is not present in any dataset. "
+                "Check your dataset group names or configuration."
+            )
+        if mask is None:
+            tensor_masked = tensor
+        else:
+            tensor_masked = tensor[mask == 1]
+
+        if isinstance(self.min_value, str):
+            if self.min_value == "min":
+                min_value = torch.min(tensor_masked)
+            elif self.min_value.startswith("percentile:"):
+                try:
+                    percentile = float(self.min_value.split(":")[1])
+                    min_value = np.percentile(tensor_masked, percentile)
+                except (IndexError, ValueError):
+                    raise ValueError(f"Invalid format for min_value: '{self.min_value}'. Expected 'percentile:<float>'")
+            else:
+                raise TypeError(
+                    f"Unsupported string for min_value: '{self.min_value}'."
+                    "Must be a float, 'min', or 'percentile:<float>'."
+                )
+        else:
+            min_value = self.min_value
+
+        if isinstance(self.max_value, str):
+            if self.max_value == "max":
+                max_value = torch.max(tensor_masked)
+            elif self.max_value.startswith("percentile:"):
+                try:
+                    percentile = float(self.max_value.split(":")[1])
+                    max_value = np.percentile(tensor_masked, percentile)
+                except (IndexError, ValueError):
+                    raise ValueError(f"Invalid format for max_value: '{self.max_value}'. Expected 'percentile:<float>'")
+            else:
+                raise TypeError(
+                    f"Unsupported string for max_value: '{self.max_value}'."
+                    " Must be a float, 'max', or 'percentile:<float>'."
+                )
+        else:
+            max_value = self.max_value
+
+        tensor[torch.where(tensor < min_value)] = min_value
+        tensor[torch.where(tensor > max_value)] = max_value
         if self.save_clip_min:
-            cache_attribute["Min"] = self.min_value
+            cache_attribute["Min"] = min_value
         if self.save_clip_max:
-            cache_attribute["Max"] = self.max_value
+            cache_attribute["Max"] = max_value
         return tensor
 
-    def inverse(self, name: str, tensor: torch.Tensor, cache_attribute: Attribute) -> torch.Tensor:
-        return tensor
 
-
-class Normalize(Transform):
+class Normalize(TransformInverse):
 
     def __init__(
         self,
@@ -83,7 +139,9 @@ class Normalize(Transform):
         channels: list[int] | None = None,
         min_value: float = -1,
         max_value: float = 1,
+        inverse: bool = True
     ) -> None:
+        super().__init__(inverse)
         if max_value <= min_value:
             raise ValueError(
                 f"[Normalize] Invalid range: max_value ({max_value}) must be greater than min_value ({min_value})"
@@ -136,43 +194,57 @@ class Normalize(Transform):
             return (tensor - self.min_value) * (input_max - input_min) / (self.max_value - self.min_value) + input_min
 
 
-class Standardize(Transform):
+class Standardize(TransformInverse):
 
     def __init__(
         self,
         lazy: bool = False,
         mean: list[float] | None = None,
         std: list[float] | None = None,
+        mask: str | None = None,
+        inverse: bool = True
     ) -> None:
+        super().__init__(inverse)
         self.lazy = lazy
         self.mean = mean
         self.std = std
+        self.mask = mask
 
     def __call__(self, name: str, tensor: torch.Tensor, cache_attribute: Attribute) -> torch.Tensor:
+        mask = None
+        if self.mask is not None:
+            for dataset in self.datasets:
+                if dataset.is_dataset_exist(self.mask, name):
+                    mask, _ = dataset.read_data(self.mask, name)
+                    break
+        if mask is None and self.mask is not None:
+            raise ValueError(
+                f"Requested mask '{self.mask}' is not present in any dataset."
+                " Check your dataset group names or configuration."
+            )
+        if mask is None:
+            tensor_masked = tensor
+        else:
+            tensor_masked = tensor[mask == 1]
+
         if "Mean" not in cache_attribute:
             cache_attribute["Mean"] = (
-                torch.mean(
-                    tensor.type(torch.float32),
-                    dim=[i + 1 for i in range(len(tensor.shape) - 1)],
-                )
+                torch.tensor([torch.mean(tensor_masked.type(torch.float32))])
                 if self.mean is None
                 else torch.tensor([self.mean])
             )
+
         if "Std" not in cache_attribute:
             cache_attribute["Std"] = (
-                torch.std(
-                    tensor.type(torch.float32),
-                    dim=[i + 1 for i in range(len(tensor.shape) - 1)],
-                )
+                torch.tensor([torch.std(tensor_masked.type(torch.float32))])
                 if self.std is None
                 else torch.tensor([self.std])
             )
-
         if self.lazy:
             return tensor
         else:
-            mean = cache_attribute.get_tensor("Mean").view(-1, *[1 for _ in range(len(tensor.shape) - 1)])
-            std = cache_attribute.get_tensor("Std").view(-1, *[1 for _ in range(len(tensor.shape) - 1)])
+            mean = cache_attribute.get_tensor("Mean")
+            std = cache_attribute.get_tensor("Std")
             return (tensor - mean) / std
 
     def inverse(self, name: str, tensor: torch.Tensor, cache_attribute: Attribute) -> torch.Tensor:
@@ -184,9 +256,10 @@ class Standardize(Transform):
             return tensor * std + mean
 
 
-class TensorCast(Transform):
+class TensorCast(TransformInverse):
 
-    def __init__(self, dtype: str = "float32") -> None:
+    def __init__(self, dtype: str = "float32", inverse: bool = True) -> None:
+        super().__init__(inverse)
         self.dtype: torch.dtype = getattr(torch, dtype)
 
     def __call__(self, name: str, tensor: torch.Tensor, cache_attribute: Attribute) -> torch.Tensor:
@@ -204,9 +277,10 @@ class TensorCast(Transform):
         return tensor.to(TensorCast.safe_dtype_cast(cache_attribute.pop("dtype")))
 
 
-class Padding(Transform):
+class Padding(TransformInverse):
 
-    def __init__(self, padding: list[int] = [0, 0, 0, 0, 0, 0], mode: str = "constant") -> None:
+    def __init__(self, padding: list[int] = [0, 0, 0, 0, 0, 0], mode: str = "constant", inverse: bool = True) -> None:
+        super().__init__(inverse)
         self.padding = padding
         self.mode = mode
 
@@ -241,9 +315,10 @@ class Padding(Transform):
         return result
 
 
-class Squeeze(Transform):
+class Squeeze(TransformInverse):
 
-    def __init__(self, dim: int) -> None:
+    def __init__(self, dim: int, inverse: bool = True) -> None:
+        super().__init__(inverse)
         self.dim = dim
 
     def __call__(self, name: str, tensor: torch.Tensor, cache_attribute: Attribute) -> torch.Tensor:
@@ -253,10 +328,10 @@ class Squeeze(Transform):
         return tensor.unsqueeze(self.dim)
 
 
-class Resample(Transform, ABC):
+class Resample(TransformInverse, ABC):
 
-    def __init__(self) -> None:
-        pass
+    def __init__(self, inverse: bool) -> None:
+        super().__init__(inverse)
 
     def _resample(self, tensor: torch.Tensor, size: list[int]) -> torch.Tensor:
         if tensor.dtype == torch.uint8:
@@ -289,7 +364,8 @@ class Resample(Transform, ABC):
 
 class ResampleToResolution(Resample):
 
-    def __init__(self, spacing: list[float] = [1.0, 1.0, 1.0]) -> None:
+    def __init__(self, spacing: list[float] = [1.0, 1.0, 1.0], inverse: bool = True) -> None:
+        super().__init__(inverse)
         self.spacing = torch.tensor([0 if s < 0 else s for s in spacing])
 
     def transform_shape(self, shape: list[int], cache_attribute: Attribute) -> list[int]:
@@ -325,7 +401,8 @@ class ResampleToResolution(Resample):
 
 class ResampleToShape(Resample):
 
-    def __init__(self, shape: list[float] = [100, 256, 256]) -> None:
+    def __init__(self, shape: list[float] = [100, 256, 256], inverse: bool = True) -> None:
+        super().__init__(inverse)
         self.shape = torch.tensor([0 if s < 0 else s for s in shape])
 
     def transform_shape(self, shape: list[int], cache_attribute: Attribute) -> list[int]:
@@ -358,9 +435,10 @@ class ResampleToShape(Resample):
         return self._resample(tensor, shape)
 
 
-class ResampleTransform(Transform):
+class ResampleTransform(TransformInverse):
 
-    def __init__(self, transforms: dict[str, bool]) -> None:
+    def __init__(self, transforms: dict[str, bool], inverse: bool = True) -> None:
+        super().__init__(inverse)
         self.transforms = transforms
 
     def transform_shape(self, shape: list[int], cache_attribute: Attribute) -> list[int]:
@@ -436,6 +514,7 @@ class ResampleTransform(Transform):
 class Mask(Transform):
 
     def __init__(self, path: str = "./default.mha", value_outside: int = 0) -> None:
+        super().__init__()
         self.path = path
         self.value_outside = value_outside
 
@@ -452,13 +531,11 @@ class Mask(Transform):
                 raise NameError(f"Mask : {self.path}/{name} not found")
         return torch.where(torch.tensor(mask) > 0, tensor, self.value_outside)
 
-    def inverse(self, name: str, tensor: torch.Tensor, cache_attribute: Attribute) -> torch.Tensor:
-        return tensor
-
 
 class Gradient(Transform):
 
     def __init__(self, per_dim: bool = False):
+        super().__init__()
         self.per_dim = per_dim
 
     @staticmethod
@@ -492,25 +569,21 @@ class Gradient(Transform):
 
         return result
 
-    def inverse(self, name: str, tensor: torch.Tensor, cache_attribute: Attribute) -> torch.Tensor:
-        return tensor
-
-
 class Argmax(Transform):
 
     def __init__(self, dim: int = 0) -> None:
+        super().__init__()
         self.dim = dim
 
     def __call__(self, name: str, tensor: torch.Tensor, cache_attribute: Attribute) -> torch.Tensor:
         return torch.argmax(tensor, dim=self.dim).unsqueeze(self.dim)
 
-    def inverse(self, name: str, tensor: torch.Tensor, cache_attribute: Attribute) -> torch.Tensor:
-        return tensor
 
 
 class FlatLabel(Transform):
 
     def __init__(self, labels: list[int] | None = None) -> None:
+        super().__init__()
         self.labels = labels
 
     def __call__(self, name: str, tensor: torch.Tensor, cache_attribute: Attribute) -> torch.Tensor:
@@ -522,21 +595,16 @@ class FlatLabel(Transform):
             data[torch.where(tensor > 0)] = 1
         return data
 
-    def inverse(self, name: str, tensor: torch.Tensor, cache_attribute: Attribute) -> torch.Tensor:
-        return tensor
-
 
 class Save(Transform):
 
     def __init__(self, dataset: str) -> None:
+        super().__init__()
         self.dataset = dataset
 
     def __call__(self, name: str, tensor: torch.Tensor, cache_attribute: Attribute) -> torch.Tensor:
         return tensor
 
-    def inverse(self, name: str, tensor: torch.Tensor, cache_attribute: Attribute) -> torch.Tensor:
-        return tensor
-
 
 class Flatten(Transform):
 
@@ -549,14 +617,11 @@ class Flatten(Transform):
     def __call__(self, name: str, tensor: torch.Tensor, cache_attribute: Attribute) -> torch.Tensor:
         return tensor.flatten()
 
-    def inverse(self, name: str, tensor: torch.Tensor, cache_attribute: Attribute) -> torch.Tensor:
-        return tensor
 
+class Permute(TransformInverse):
 
-class Permute(Transform):
-
-    def __init__(self, dims: str = "1|0|2") -> None:
-        super().__init__()
+    def __init__(self, dims: str = "1|0|2", inverse: bool = True) -> None:
+        super().__init__(inverse)
         self.dims = [0] + [int(d) + 1 for d in dims.split("|")]
 
     def transform_shape(self, shape: list[int], cache_attribute: Attribute) -> list[int]:
@@ -569,10 +634,10 @@ class Permute(Transform):
         return tensor.permute(tuple(np.argsort(self.dims)))
 
 
-class Flip(Transform):
+class Flip(TransformInverse):
 
-    def __init__(self, dims: str = "1|0|2") -> None:
-        super().__init__()
+    def __init__(self, dims: str = "1|0|2", inverse: bool = True) -> None:
+        super().__init__(inverse)
 
         self.dims = [int(d) + 1 for d in str(dims).split("|")]
 
@@ -583,9 +648,10 @@ class Flip(Transform):
         return tensor.flip(tuple(self.dims))
 
 
-class Canonical(Transform):
+class Canonical(TransformInverse):
 
-    def __init__(self) -> None:
+    def __init__(self, inverse: bool = True) -> None:
+        super().__init__(inverse)
         self.canonical_direction = torch.diag(torch.tensor([-1, -1, 1])).to(torch.double)
 
     def __call__(self, name: str, tensor: torch.Tensor, cache_attribute: Attribute) -> torch.Tensor:
@@ -618,6 +684,7 @@ class Canonical(Transform):
 class HistogramMatching(Transform):
 
     def __init__(self, reference_group: str) -> None:
+        super().__init__()
         self.reference_group = reference_group
 
     def __call__(self, name: str, tensor: torch.Tensor, cache_attribute: Attribute) -> torch.Tensor:
@@ -635,13 +702,11 @@ class HistogramMatching(Transform):
         result, _ = image_to_data(matcher.Execute(image, image_ref))
         return torch.tensor(result)
 
-    def inverse(self, name: str, tensor: torch.Tensor, cache_attribute: Attribute) -> torch.Tensor:
-        return tensor
-
 
 class SelectLabel(Transform):
 
     def __init__(self, labels: list[str]) -> None:
+        super().__init__()
         self.labels = [label[1:-1].split(",") for label in labels]
 
     def __call__(self, name: str, tensor: torch.Tensor, cache_attribute: Attribute) -> torch.Tensor:
@@ -650,14 +715,11 @@ class SelectLabel(Transform):
             data[tensor == int(old_label)] = int(new_label)
         return data
 
-    def inverse(self, name: str, tensor: torch.Tensor, cache_attribute: Attribute) -> torch.Tensor:
-        return tensor
 
+class OneHot(TransformInverse):
 
-class OneHot(Transform):
-
-    def __init__(self, num_classes: int) -> None:
-        super().__init__()
+    def __init__(self, num_classes: int, inverse: bool = True) -> None:
+        super().__init__(inverse)
         self.num_classes = num_classes
 
     def __call__(self, name: str, tensor: torch.Tensor, cache_attribute: Attribute) -> torch.Tensor:
@@ -690,7 +752,4 @@ class TotalSegmentator(Transform):
             torch.from_numpy(np.array(np.asanyarray(seg.dataobj), copy=True).astype(np.uint8, copy=False))
             .permute(2, 1, 0)
             .unsqueeze(0)
-        )
-
-    def inverse(self, name: str, tensor: torch.Tensor, cache_attribute: Attribute) -> torch.Tensor:
-        return tensor
+        )

{konfai-1.2.4 → konfai-1.2.6}/konfai/network/network.py

@@ -6,8 +6,7 @@ from collections import OrderedDict
 from collections.abc import Callable, Iterable, Iterator, Sequence
 from enum import Enum
 from functools import partial
-from typing import Any
-from typing_extensions import Self
+from typing import Any, Self
 
 import numpy as np
 import torch

{konfai-1.2.4 → konfai-1.2.6}/konfai/predictor.py

@@ -16,7 +16,7 @@ from torch.utils.tensorboard.writer import SummaryWriter
 from konfai import config_file, konfai_root, models_directory, path_to_models, predictions_directory
 from konfai.data.data_manager import DataPrediction, DatasetIter
 from konfai.data.patching import Accumulator, PathCombine
-from konfai.data.transform import Transform, TransformLoader
+from konfai.data.transform import Transform, TransformInverse, TransformLoader
 from konfai.network.network import CPUModel, ModelLoader, NetState, Network
 from konfai.utils.config import config
 from konfai.utils.dataset import Attribute, Dataset
@@ -226,11 +226,12 @@ class OutSameAsGroupDataset(OutputDataset):
 
         if self.inverse_transform:
             for transform in reversed(dataset.groups_src[self.group_src][self.group_dest].patch_transforms):
-                layer = transform.inverse(
-                    self.names[index_dataset],
-                    layer,
-                    self.attributes[index_dataset][index_augmentation][index_patch],
-                )
+                if isinstance(transform, TransformInverse) and transform.apply_inverse:
+                    layer = transform.inverse(
+                        self.names[index_dataset],
+                        layer,
+                        self.attributes[index_dataset][index_augmentation][index_patch],
+                    )
         self.output_layer_accumulator[index_dataset][index_augmentation].add_layer(index_patch, layer)
 
     def load(self, name_layer: str, datasets: list[Dataset], groups: dict[str, str]):
@@ -277,7 +278,8 @@ class OutSameAsGroupDataset(OutputDataset):
 
         if self.inverse_transform:
             for transform in reversed(dataset.groups_src[self.group_src][self.group_dest].transforms):
-                result = transform.inverse(self.names[index], result, self.attributes[index][0][0])
+                if isinstance(transform, TransformInverse) and transform.apply_inverse:
+                    result = transform.inverse(self.names[index], result, self.attributes[index][0][0])
 
         for transform in self.final_transforms:
             result = transform(self.names[index], result, self.attributes[index][0][0])
@@ -715,7 +717,9 @@ class Predictor(DistributedObject):
                         path = models_directory() + self.name + "/StateDict/"
                         name = sorted(os.listdir(path))[-1]
                 if os.path.exists(path + name):
-                    state_dicts.append(torch.load(path + name, map_location=torch.device('cpu'), weights_only=False))
+                    state_dicts.append(
+                        torch.load(path + name, map_location=torch.device("cpu"), weights_only=False)  # nosec B614
+                    )  # nosec B614
                 else:
                     raise Exception(f"Model : {path + name} does not exist !")
         return state_dicts

{konfai-1.2.4 → konfai-1.2.6}/konfai.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: konfai
-Version: 1.2.4
+Version: 1.2.6
 Summary: Modular and configurable Deep Learning framework with YAML and PyTorch
 Author-email: Valentin Boussot <boussot.v@gmail.com>
 License-Expression: Apache-2.0
@@ -21,6 +21,7 @@ Requires-Dist: SimpleITK
 Requires-Dist: lxml
 Requires-Dist: h5py
 Requires-Dist: pynvml
+Requires-Dist: requests
 Provides-Extra: vtk
 Requires-Dist: vtk; extra == "vtk"
 Provides-Extra: lpips

{konfai-1.2.4 → konfai-1.2.6}/konfai.egg-info/requires.txt

@@ -8,6 +8,7 @@ SimpleITK
 lxml
 h5py
 pynvml
+requests
 
 [cluster]
 submitit

{konfai-1.2.4 → konfai-1.2.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "konfai"
-version = "1.2.4"
+version = "1.2.6"
 description = "Modular and configurable Deep Learning framework with YAML and PyTorch"
 readme = "README.md"
 requires-python = ">=3.8"
@@ -24,7 +24,8 @@ dependencies = [
   "SimpleITK",
   "lxml",
   "h5py",
-  "pynvml"
+  "pynvml",
+  "requests"
 ]
 
 [project.urls]