konfai 1.0.9__py3-none-any.whl → 1.1.1__py3-none-any.whl

konfai/data/augmentation.py

@@ -8,7 +8,7 @@ from typing import Union
 import os
 from konfai import KONFAI_ROOT
 from konfai.utils.config import config
-from konfai.utils.utils import _getModule
+from konfai.utils.utils import _getModule, AugmentationError
 from konfai.utils.dataset import Attribute, data_to_image
 
 
@@ -222,7 +222,7 @@ class ColorTransform(DataAugmentation):
                 matrix = matrix[:, :3, :].mean(dim=1, keepdims=True).to(input.device)
                 result = result.float() * matrix[:, :, :3].sum(dim=2, keepdims=True) + matrix[:, :, 3:]
             else:
-                raise ValueError('Image must be RGB (3 channels) or L (1 channel)')
+                raise AugmentationError('Image must be RGB (3 channels) or L (1 channel)')
             results.append(result.reshape(input.shape))
         return results
     

konfai/data/data_manager.py

@@ -11,11 +11,12 @@ from typing import Union, Iterator
 from concurrent.futures import ThreadPoolExecutor, as_completed
 import threading
 from torch.cuda import device_count
+import SimpleITK as sitk
 
 from konfai import KONFAI_STATE, KONFAI_ROOT
 from konfai.data.patching import DatasetPatch, DatasetManager
 from konfai.utils.config import config
-from konfai.utils.utils import memoryInfo, cpuInfo, memoryForecast, getMemory, State
+from konfai.utils.utils import memoryInfo, cpuInfo, memoryForecast, getMemory, State, SUPPORTED_EXTENSIONS, DatasetManagerError
 from konfai.utils.dataset import Dataset, Attribute
 from konfai.data.transform import TransformLoader, Transform
 from konfai.data.augmentation import DataAugmentationsList
@@ -236,6 +237,8 @@ class Subset():
             index = random.sample(index, len(index))
         return set([names_filtred[i] for i in index])
     
+    def __str__(self):
+        return "Subset : " + str(self.subset) + " shuffle : "+ str(self.shuffle) + " filter : "+ str(self.filter)
 class TrainSubset(Subset):
 
     @config()
@@ -257,14 +260,14 @@ class Data(ABC):
                         subset : Union[Subset, dict[str, Subset]],
                         num_workers : int,
                         batch_size : int,
-                        train_size: Union[float, str, list[int], list[str]] = 1,
+                        validation: Union[float, str, list[int], list[str]] = 1,
                         inlineAugmentations: bool = False,
                         dataAugmentationsList: dict[str, DataAugmentationsList]= {}) -> None:
         self.dataset_filenames = dataset_filenames
         self.subset = subset
         self.groups_src = groups_src
         self.patch = patch
-        self.train_size = train_size
+        self.validation = validation
         self.dataAugmentationsList = dataAugmentationsList
         self.batch_size = batch_size
         self.dataSet_args = dict(groups_src=self.groups_src, inlineAugmentations=inlineAugmentations, dataAugmentationsList = list(self.dataAugmentationsList.values()), use_cache = use_cache, buffer_size=batch_size+1, patch_size=self.patch.patch_size if self.patch is not None else None, overlap=self.patch.overlap if self.patch is not None else None)
@@ -290,6 +293,13 @@ class Data(ABC):
                     map.append((x, y, z))
         return data, map
 
+    def getGroupsDest(self):
+        groupsDest = []
+        for group_src in self.groups_src:
+            for group_dest in self.groups_src[group_src]:
+                groupsDest.append(group_dest)
+        return groupsDest
+    
     def _split(map: list[tuple[int, int, int]], world_size: int) -> list[list[tuple[int, int, int]]]:
         if len(map) == 0:
             return [[] for _ in range(world_size)]
@@ -313,7 +323,14 @@ class Data(ABC):
     
     def getData(self, world_size: int) -> list[list[DataLoader]]:
         datasets: dict[str, list[(str, bool)]] = {}
+        if self.dataset_filenames is None or len(self.dataset_filenames) == 0:
+            raise DatasetManagerError("No dataset filenames were provided")
         for dataset_filename in self.dataset_filenames:
+            if dataset_filename is None:
+                raise DatasetManagerError("Invalid dataset entry: 'None' received.",
+                    "Each dataset must be a valid path string (e.g., './Dataset/', './Dataset/:mha, './Dataset/:a:mha', './Dataset/:i:mha').",
+                    "Please check your 'dataset_filenames' list for missing or null entries."
+                )
             if len(dataset_filename.split(":")) == 1:
                 filename = dataset_filename
                 format = "mha"
@@ -324,9 +341,13 @@ class Data(ABC):
             else:
                 filename, flag, format = dataset_filename.split(":")
                 append = flag == "a"
-                
-            dataset = Dataset(filename, format) 
+
+            if format not in SUPPORTED_EXTENSIONS:
+                    raise DatasetManagerError(f"Unsupported file format '{format}'.",
+                        f"Supported extensions are: {', '.join(SUPPORTED_EXTENSIONS)}")
             
+            dataset = Dataset(filename, format)
+
             self.datasets[filename] = dataset
             for group in self.groups_src:
                 if dataset.isGroupExist(group):
@@ -334,16 +355,30 @@ class Data(ABC):
                         datasets[group].append((filename, append)) 
                     else:
                         datasets[group] = [(filename, append)]
+        modelHaveInput = False
         for group_src in self.groups_src:
             if group_src not in datasets:
-                raise ValueError("[DatasetManager] Error: group source {} not found. Available groups: {}".format(group_src, list(datasets.keys())))
                 
+                raise DatasetManagerError(
+                    f"Group source '{group_src}' not found in any dataset.",
+                    f"Dataset filenames provided: {self.dataset_filenames}",
+                    f"Available groups across all datasets: {sorted(list(datasets.keys()))}",
+                    f"Please check that an entry in the dataset with the name '{group_src}.{format}' exists."
+                )
+           
             for group_dest in self.groups_src[group_src]:
                 self.groups_src[group_src][group_dest].load(group_src, group_dest, [self.datasets[filename] for filename, _ in datasets[group_src]])
+                modelHaveInput |= self.groups_src[group_src][group_dest].isInput
+
+        if not modelHaveInput:
+            raise DatasetManagerError(
+                "At least one group must be defined with 'isInput: true' to provide input to the network."
+            )
+
         for key, dataAugmentations in self.dataAugmentationsList.items():
             dataAugmentations.load(key)
 
-        names : list[list[str]] = []
+        names = set()
         dataset_name : dict[str, dict[str, list[str]]] = {}
         dataset_info : dict[str, dict[str, dict[str, Attribute]]] = {}
         for group in self.groups_src:
@@ -351,10 +386,11 @@ class Data(ABC):
                 dataset_name[group] = {}
                 dataset_info[group] = {}
             for filename, _ in datasets[group]:
-                names.append(self.datasets[filename].getNames(group))
+                names.update(self.datasets[filename].getNames(group))
                 dataset_name[group][filename] = self.datasets[filename].getNames(group)
                 dataset_info[group][filename] = {name: self.datasets[filename].getInfos(group, name) for name in dataset_name[group][filename]}
         subset_names = set()
+
         if isinstance(self.subset, dict):
             for filename, subset in self.subset.items():
                 subset_names.update(subset([dataset_name[group][filename] for group in dataset_name], [dataset_info[group][filename] for group in dataset_name]))
@@ -368,41 +404,86 @@ class Data(ABC):
                             subset_names.update(self.subset([dataset_name[group][filename]], [dataset_info[group][filename]])) 
                         else:
                             subset_names.intersection(self.subset([dataset_name[group][filename]], [dataset_info[group][filename]]))
+        if len(subset_names) == 0:
+            raise DatasetManagerError("All data entries were excluded by the subset filter.",
+                f"Dataset entries found: {', '.join(names)}",
+                f"Subset object applied: {self.subset}",
+                f"Subset requested : {', '.join(subset_names)}",
+                "None of the dataset entries matched the given subset.",
+                "Please check your 'subset' configuration — it may be too restrictive or incorrectly formatted.",
+                "Examples of valid subset formats:",
+                "\tsubset: [0, 1]            # explicit indices",
+                "\tsubset: 0:10              # slice notation",
+                "\tsubset: ./Validation.txt  # external file",
+                "\tsubset: None              # to disable filtering"
+            )
+                                        
         data, map = self._getDatasets(list(subset_names), dataset_name)
-    
+
         train_map = map
         validate_map = []
-        if isinstance(self.train_size, float):
-            if self.train_size < 1.0 and int(math.floor(len(map)*(1-self.train_size))) > 0:
-                train_map, validate_map = map[:int(math.floor(len(map)*self.train_size))], map[int(math.floor(len(map)*self.train_size)):]
-        elif isinstance(self.train_size, str):
-            if ":" in self.train_size:
+        if isinstance(self.validation, float) or isinstance(self.validation, int):
+            if self.validation <= 0 or self.validation >= 1:
+                raise DatasetManagerError("validation must be a float between 0 and 1.", f"→ Received: {self.validation}", "→ Example: validation = 0.2  # for a 20% validation split")
+            
+            train_map, validate_map = map[:int(math.floor(len(map)*(1-self.validation)))], map[int(math.floor(len(map)*(1-self.validation))):]
+        elif isinstance(self.validation, str):
+            if ":" in self.validation:
                 index = list(range(int(self.subset.split(":")[0]), int(self.subset.split(":")[1])))
                 train_map = [m for m in map if m[0] not in index]
                 validate_map = [m for m in map if m[0] in index]
-            elif os.path.exists(self.train_size):
+            elif os.path.exists(self.validation):
                 validation_names = []
-                with open(self.train_size, "r") as f:
+                with open(self.validation, "r") as f:
                     for name in f:
                         validation_names.append(name.strip())
                 index = [i for i, n in enumerate(subset_names) if n in validation_names]
                 train_map = [m for m in map if m[0] not in index]
                 validate_map = [m for m in map if m[0] in index]
             else:
-                validate_map = train_map
-        elif isinstance(self.train_size, list):
-            if len(self.train_size) > 0:
-                if isinstance(self.train_size[0], int):
-                    train_map = [m for m in map if m[0] not in self.train_size]
-                    validate_map = [m for m in map if m[0] in self.train_size]
-                elif isinstance(self.train_size[0], str):
-                    index = [i for i, n in enumerate(subset_names) if n in self.train_size]
+                raise DatasetManagerError(
+                    f"Invalid string value for 'validation': '{self.validation}'",
+                    "Expected one of the following formats:",
+                    "\t• A slice string like '0:10'",
+                    "\t• A path to a text file listing validation sample names (e.g., './val.txt')",
+                    "\t• A float between 0 and 1 (e.g., 0.2)",
+                    "\t• A list of sample names or indices",
+                    "The provided value is neither a valid slice nor a readable file.",
+                    "Please fix your 'validation' setting in the configuration."
+                    )
+            
+        elif isinstance(self.validation, list):
+            if len(self.validation) > 0:
+                if isinstance(self.validation[0], int):
+                    train_map = [m for m in map if m[0] not in self.validation]
+                    validate_map = [m for m in map if m[0] in self.validation]
+                elif isinstance(self.validation[0], str):
+                    index = [i for i, n in enumerate(subset_names) if n in self.validation]
                     train_map = [m for m in map if m[0] not in index]
                     validate_map = [m for m in map if m[0] in index]
-
+                else:
+                    raise DatasetManagerError(f"Invalid list type for 'validation': elements of type '{type(self.validation[0]).__name__}' are not supported.",
+                            "Supported list element types are:",
+                            "\t• int  → list of indices (e.g., [0, 1, 2])",
+                            "\t• str  → list of sample names (e.g., ['patient01', 'patient02'])",
+                            f"Received list: {self.validation}"
+                        )
+        if len(train_map) == 0:
+            raise DatasetManagerError("No data left for training after applying the validation split.",
+                f"Dataset size: {len(map)}",
+                f"Validation setting: {self.validation}",
+                "Please reduce the validation size, increase the dataset, or disable validation."
+            )
+
+        if self.validation is not None and len(validate_map) == 0:
+            raise DatasetManagerError("No data left for validation after applying the validation split.",
+                f"Dataset size: {len(map)}",
+                f"Validation setting: {self.validation}",
+                "Please increase the validation size, increase the dataset, or disable validation."
+            )
         train_maps = Data._split(train_map, world_size)
         validate_maps = Data._split(validate_map, world_size)
-
+        
         for i, (train_map, validate_map) in enumerate(zip(train_maps, validate_maps)):
             maps = [train_map]
             if len(validate_map):
@@ -436,8 +517,8 @@ class DataTrain(Data):
                         subset : Union[TrainSubset, dict[str, TrainSubset]] = TrainSubset(),
                         num_workers : int = 4,
                         batch_size : int = 1,
-                        train_size : Union[float, str, list[int], list[str]] = 0.8) -> None:
-        super().__init__(dataset_filenames, groups_src, patch, use_cache, subset, num_workers, batch_size, train_size, inlineAugmentations, augmentations if augmentations else {})
+                        validation : Union[float, str, list[int], list[str]] = 0.2) -> None:
+        super().__init__(dataset_filenames, groups_src, patch, use_cache, subset, num_workers, batch_size, validation, inlineAugmentations, augmentations if augmentations else {})
 
 class DataPrediction(Data):
 
@@ -445,14 +526,13 @@ class DataPrediction(Data):
     def __init__(self,  dataset_filenames : list[str] = ["default:./Dataset"], 
                         groups_src : dict[str, Group] = {"default" : Group()},
                         augmentations : Union[dict[str, DataAugmentationsList], None] = {"DataAugmentation_0" : DataAugmentationsList()},
-                        inlineAugmentations: bool = False,
                         patch : Union[DatasetPatch, None] = DatasetPatch(),
                         use_cache : bool = True,
                         subset : Union[PredictionSubset, dict[str, PredictionSubset]] = PredictionSubset(),
                         num_workers : int = 4,
                         batch_size : int = 1) -> None:
 
-        super().__init__(dataset_filenames, groups_src, patch, use_cache, subset, num_workers, batch_size, inlineAugmentations=inlineAugmentations, dataAugmentationsList=augmentations if augmentations else {})
+        super().__init__(dataset_filenames, groups_src, patch, use_cache, subset, num_workers, batch_size, dataAugmentationsList=augmentations if augmentations else {})
 
 class DataMetric(Data):
 
@@ -463,4 +543,4 @@ class DataMetric(Data):
                         validation: Union[str, None] = None,
                         num_workers : int = 4) -> None:
 
-        super().__init__(dataset_filenames=dataset_filenames, groups_src=groups_src, patch=None, use_cache=False, subset=subset, num_workers=num_workers, batch_size=1, train_size=1 if validation is None else validation)
+        super().__init__(dataset_filenames=dataset_filenames, groups_src=groups_src, patch=None, use_cache=False, subset=subset, num_workers=num_workers, batch_size=1, validation=1 if validation is None else validation)

konfai/data/patching.py

@@ -150,7 +150,10 @@ class Patch(ABC):
 
     def __init__(self, patch_size: list[int], overlap: Union[int, None], path_mask: Union[str, None] = None, padValue: float = 0, extend_slice: int = 0) -> None:
         self.patch_size = patch_size
-        self.overlap = overlap
+        self.overlap = overlap 
+        if isinstance(self.overlap, int):
+             if self.overlap < 0:
+                 self.overlap = None
         self._patch_slices : dict[int, list[tuple[slice]]] = {}
         self._nb_patch_per_dim: dict[int, list[tuple[int, bool]]] = {}
         self.path_mask = path_mask
@@ -188,7 +191,7 @@ class Patch(ABC):
             pad_bottom = 0
             pad_top = 0
             if self._patch_slices[a][index][0].start-bottom < 0:
-                pad_bottom = bottom-s.start
+                pad_bottom = bottom-self._patch_slices[a][index][0].start
             if self._patch_slices[a][index][0].stop+top > data.shape[len(slices_pre)]:
                 pad_top = self._patch_slices[a][index][0].stop+top-data.shape[len(slices_pre)]
             data_sliced = F.pad(data_sliced, [0 for _ in range((len(slices)-1)*2)]+[pad_bottom, pad_top], 'reflect')

konfai/data/transform.py

@@ -529,7 +529,6 @@ class OneHot(Transform):
 
     def __call__(self, name: str, input: torch.Tensor, cache_attribute: Attribute) -> torch.Tensor:
         result =  F.one_hot(input.type(torch.int64), num_classes=self.num_classes).permute(0, len(input.shape), *[i+1 for i in range(len(input.shape)-1)]).float().squeeze(2)
-        print(result.shape)
         return result
     
     def inverse(self, name: str, input: torch.Tensor, cache_attribute: Attribute) -> torch.Tensor:

konfai/main.py

@@ -18,9 +18,8 @@ def main():
                 distributedObject.setup(world_size)
                 with TensorBoard(distributedObject.name):
                     mp.spawn(distributedObject, nprocs=world_size)
-    except Exception as e:
-        print(e)
-        exit(1)
+    except KeyboardInterrupt:
+        print("\n[KonfAI] Manual interruption (Ctrl+C)")
 
 
 def cluster():
@@ -47,6 +46,8 @@ def cluster():
             executor.update_parameters(name=config["name"], mem_gb=config["memory"], gpus_per_node=n_gpu, tasks_per_node=n_gpu//distributedObject.size, cpus_per_task=config["num_workers"], nodes=config["num_nodes"], timeout_min=config["time_limit"])
             with TensorBoard(distributedObject.name):
                 executor.submit(distributedObject)
+    except KeyboardInterrupt:
+        print("\n[KonfAI] Manual interruption (Ctrl+C)")
     except Exception as e:
         print(e)
         exit(1)

konfai/metric/measure.py

@@ -147,7 +147,7 @@ class Dice(Criterion):
     def forward(self, output: torch.Tensor, *targets : list[torch.Tensor]) -> torch.Tensor:
         target = targets[0]
         if output.shape[1] == 1:
-            output = F.one_hot(output.type(torch.int64), num_classes=torch.max(output).item()+1).permute(0, len(target.shape), *[i+1 for i in range(len(target.shape)-1)]).float()
+            output = F.one_hot(output.type(torch.int64), num_classes=int(torch.max(output).item()+1)).permute(0, len(target.shape), *[i+1 for i in range(len(target.shape)-1)]).float()
         target = F.one_hot(target.type(torch.int64), num_classes=output.shape[1]).permute(0, len(target.shape), *[i+1 for i in range(len(target.shape)-1)]).float().squeeze(2)
         return 1-torch.mean(self.dice_per_channel(output, target))
 

konfai/models/registration/registration.py

@@ -94,7 +94,6 @@ class SpatialTransformer(torch.nn.Module):
             new_locs[:, 1,1] = 1
             new_locs[:, 0,2] = flow[:, 0]
             new_locs[:, 1,2] = flow[:, 1]
-            print(new_locs)
             return F.grid_sample(src, F.affine_grid(new_locs, src.size()), align_corners=True, mode="bilinear")
         else:
             new_locs = self.grid + flow

konfai/network/blocks.py

@@ -176,7 +176,6 @@ class Print(torch.nn.Module):
         super().__init__()
     
     def forward(self, input: torch.Tensor) -> torch.Tensor:
-        print(input.shape)
         return input
 
 class Write(torch.nn.Module):

konfai/network/network.py

@@ -16,7 +16,7 @@ from enum import Enum
 from konfai import KONFAI_ROOT
 from konfai.metric.schedulers import Scheduler
 from konfai.utils.config import config
-from konfai.utils.utils import State, _getModule, getDevice, getGPUMemory
+from konfai.utils.utils import State, _getModule, getDevice, getGPUMemory, MeasureError
 from konfai.data.patching import Accumulator, ModelPatch
 
 class NetState(Enum):
@@ -54,12 +54,12 @@ class LRSchedulersLoader():
     def __init__(self, params: dict[str, SchedulerStep] = {"default:ReduceLROnPlateau" : SchedulerStep(0)}) -> None:
         self.params = params
 
-    def getShedulers(self, key: str, optimizer: torch.optim.Optimizer) -> dict[torch.optim.lr_scheduler._LRScheduler, int]:
-        shedulers : dict[torch.optim.lr_scheduler._LRScheduler, int] = {}
+    def getschedulers(self, key: str, optimizer: torch.optim.Optimizer) -> dict[torch.optim.lr_scheduler._LRScheduler, int]:
+        schedulers : dict[torch.optim.lr_scheduler._LRScheduler, int] = {}
         for name, step in self.params.items():
             if name:
-                shedulers[config("Trainer.Model.{}.Schedulers.{}".format(key, name))(getattr(importlib.import_module('torch.optim.lr_scheduler'), name))(optimizer, config = None)] = step.nb_step
-        return shedulers
+                schedulers[config("Trainer.Model.{}.Schedulers.{}".format(key, name))(getattr(importlib.import_module('torch.optim.lr_scheduler'), name))(optimizer, config = None)] = step.nb_step
+        return schedulers
 
 class SchedulersLoader():
         
@@ -67,12 +67,12 @@ class SchedulersLoader():
     def __init__(self, params: dict[str, SchedulerStep] = {"default:Constant" : SchedulerStep(0)}) -> None:
         self.params = params
 
-    def getShedulers(self, key: str) -> dict[torch.optim.lr_scheduler._LRScheduler, int]:
-        shedulers : dict[Scheduler, int] = {}
+    def getschedulers(self, key: str) -> dict[torch.optim.lr_scheduler._LRScheduler, int]:
+        schedulers : dict[Scheduler, int] = {}
         for name, step in self.params.items():
             if name:    
-                shedulers[getattr(importlib.import_module("konfai.metric.schedulers"), name)(config = None, DL_args = key)] = step.nb_step
-        return shedulers
+                schedulers[getattr(importlib.import_module("konfai.metric.schedulers"), name)(config = None, DL_args = key)] = step.nb_step
+        return schedulers
     
 class CriterionsAttr():
     
@@ -98,7 +98,7 @@ class CriterionsLoader():
         for module_classpath, criterionsAttr in self.criterionsLoader.items():
             module, name = _getModule(module_classpath, "metric.measure")
             criterionsAttr.isTorchCriterion = module.startswith("torch")
-            criterionsAttr.sheduler = criterionsAttr.l.getShedulers("{}.Model.{}.outputsCriterions.{}.targetsCriterions.{}.criterionsLoader.{}".format(KONFAI_ROOT(), model_classname, output_group, target_group, module_classpath))
+            criterionsAttr.sheduler = criterionsAttr.l.getschedulers("{}.Model.{}.outputsCriterions.{}.targetsCriterions.{}.criterionsLoader.{}".format(KONFAI_ROOT(), model_classname, output_group, target_group, module_classpath))
             criterions[config("{}.Model.{}.outputsCriterions.{}.targetsCriterions.{}.criterionsLoader.{}".format(KONFAI_ROOT(), model_classname, output_group, target_group, module_classpath))(getattr(importlib.import_module(module), name))(config = None)] = criterionsAttr
         return criterions
 
@@ -154,10 +154,25 @@ class Measure():
             self.outputsCriterions[output_group.replace(":", ".")] = targetCriterionsLoader.getTargetsCriterions(output_group, model_classname)
         self._loss : dict[int, dict[str, Measure.Loss]] = {}
 
-    def init(self, model : torch.nn.Module) -> None:
+    def init(self, model : torch.nn.Module, group_dest: list[str]) -> None:
         outputs_group_rename = {}
+        
+        modules = []
+        for i,_ in model.named_modules():
+            modules.append(i)
+
         for output_group in self.outputsCriterions.keys():
+            if output_group not in modules:
+                  raise MeasureError(f"The output group '{output_group}' defined in 'outputsCriterions' does not correspond to any module in the model.",
+                    f"Available modules: {modules}",
+                    "Please check that the name matches exactly a submodule or output of your model architecture."
+                )
             for target_group in self.outputsCriterions[output_group]:
+                if target_group not in group_dest:
+                    raise MeasureError(
+                        f"The target_group '{target_group}' defined in 'outputsCriterions.{output_group}.targetsCriterions' was not found in the available destination groups.",
+                        "This target_group is expected for loss or metric computation, but was not loaded in 'group_dest'.",
+                        f"Please make sure that the group '{target_group}' is defined in 'Dataset:groups_src:...:groups_dest:'{target_group}'' and correctly loaded from the dataset.")
                 for criterion in self.outputsCriterions[output_group][target_group]:
                     if not self.outputsCriterions[output_group][target_group][criterion].isTorchCriterion:
                         outputs_group_rename[output_group] = criterion.init(model, output_group, target_group)
@@ -703,10 +718,10 @@ class Network(ModuleArgsDict, ABC):
         return in_channels, in_is_channel, out_channels, out_is_channel
 
     @_function_network()
-    def init(self, autocast : bool, state : State, key: str) -> None: 
+    def init(self, autocast : bool, state : State, group_dest: list[str], key: str) -> None: 
         if self.outputsCriterionsLoader:
             self.measure = Measure(key, self.outputsCriterionsLoader)
-            self.measure.init(self)
+            self.measure.init(self, group_dest)
         if state != State.PREDICTION:
             self.scaler = torch.amp.GradScaler("cuda", enabled=autocast)
             if self.optimizerLoader:
@@ -714,7 +729,7 @@ class Network(ModuleArgsDict, ABC):
                 self.optimizer.zero_grad()
 
             if self.LRSchedulersLoader and self.optimizer:
-                self.schedulers = self.LRSchedulersLoader.getShedulers(key, self.optimizer)
+                self.schedulers = self.LRSchedulersLoader.getschedulers(key, self.optimizer)
     
     def initialized(self):
         pass
@@ -880,7 +895,6 @@ class Network(ModuleArgsDict, ABC):
         if scheduler:
             if scheduler.__class__.__name__ == 'ReduceLROnPlateau':
                 if self.measure:
-                    print(sum(self.measure.getLastValues(0).values()))
                     scheduler.step(sum(self.measure.getLastValues(0).values()))
             else:
                 scheduler.step()     

konfai/trainer.py

@@ -1,5 +1,4 @@
 import torch
-import torch.optim.adamw
 from torch.utils.data import DataLoader
 import tqdm
 import numpy as np
@@ -15,13 +14,76 @@ import torch.distributed as dist
 from konfai import MODELS_DIRECTORY, CHECKPOINTS_DIRECTORY, STATISTICS_DIRECTORY, SETUPS_DIRECTORY, CONFIG_FILE, MODEL, DATE, KONFAI_STATE
 from konfai.data.data_manager import DataTrain
 from konfai.utils.config import config
-from konfai.utils.utils import State, DataLog, DistributedObject, description
+from konfai.utils.utils import State, DataLog, DistributedObject, description, TrainerError
 from konfai.network.network import Network, ModelLoader, NetState, CPU_Model
 
 
+class EarlyStoppingBase:
+
+    def __init__(self):
+        pass
+
+    def isStopped(self) -> bool:
+        return False
+
+    def getScore(self, values: dict[str, float]):
+        return sum([i for i in values.values()])
+        
+    def __call__(self, current_score: float) -> bool:
+        return False
+
+class EarlyStopping(EarlyStoppingBase):
+
+    @config("EarlyStopping")
+    def __init__(self, monitor: Union[list[str], None] = [], patience=10, min_delta=0.0, mode="min"):
+        super().__init__()
+        self.monitor = [] if monitor is None else monitor
+        self.patience = patience
+        self.min_delta = min_delta
+        self.mode = mode
+        self.counter = 0
+        self.best_score = None
+        self.early_stop = False
+
+    def isStopped(self) -> bool:
+        return self.early_stop
+
+    def getScore(self, values: dict[str, float]):
+        if len(self.monitor) == 0:
+            return super().getScore(values)
+        for v in self.monitor:
+            if v not in values.keys():
+                raise TrainerError(
+                    "Metric '{}' specified in EarlyStopping.monitor not found in logged values. ",
+                    "Available keys: {}. Please check your configuration.".format(v, list(values.keys())))
+        return sum([i for v, i in values.items() if v in self.monitor])
+        
+    def __call__(self, current_score: float) -> bool:
+        if self.best_score is None:
+            self.best_score = current_score
+            return False
+
+        if self.mode == "min":
+            improvement = self.best_score - current_score
+        elif self.mode == "max":
+            improvement = current_score - self.best_score
+        else:
+            raise TrainerError("Mode must be 'min' or 'max'.")
+
+        if improvement > self.min_delta:
+            self.best_score = current_score
+            self.counter = 0
+        else:
+            self.counter += 1
+
+        if self.counter >= self.patience:
+            self.early_stop = True
+
+        return self.early_stop
+
 class _Trainer():
 
-    def __init__(self, world_size: int, global_rank: int, local_rank: int, size: int, train_name: str, data_log: Union[list[str], None] , save_checkpoint_mode: str, epochs: int, epoch: int, autocast: bool, it_validation: Union[int, None], it: int, model: Union[DDP, CPU_Model], modelEMA: AveragedModel, dataloader_training: DataLoader, dataloader_validation: Union[DataLoader, None] = None) -> None:
+    def __init__(self, world_size: int, global_rank: int, local_rank: int, size: int, train_name: str, early_stopping: EarlyStopping, data_log: Union[list[str], None] , save_checkpoint_mode: str, epochs: int, epoch: int, autocast: bool, it_validation: Union[int, None], it: int, model: Union[DDP, CPU_Model], modelEMA: AveragedModel, dataloader_training: DataLoader, dataloader_validation: Union[DataLoader, None] = None) -> None:
         self.world_size = world_size        
         self.global_rank = global_rank
         self.local_rank = local_rank
@@ -36,7 +98,8 @@ class _Trainer():
         self.dataloader_validation = dataloader_validation
         self.autocast = autocast
         self.modelEMA = modelEMA
-        
+        self.early_stopping = EarlyStoppingBase() if early_stopping is None else early_stopping 
+
         self.it_validation = it_validation
         if self.it_validation is None:
             self.it_validation = len(dataloader_training)
@@ -59,6 +122,8 @@ class _Trainer():
             for self.epoch in epoch_tqdm:
                 self.dataloader_training.dataset.load()
                 self.train()
+                if self.early_stopping.isStopped():
+                    break
                 self.dataloader_training.dataset.resetAugmentation()
                 
     def getInput(self, data_dict : dict[str, tuple[torch.Tensor, int, int, int, str, bool]]) -> dict[tuple[str, bool], torch.Tensor]:
@@ -88,7 +153,11 @@ class _Trainer():
                         if self.dataloader_validation is not None:
                             loss = self._validate()
                         self.model.module.update_lr()
-                        self.checkpoint_save(loss)
+                        score = self.early_stopping.getScore(loss)
+                        self.checkpoint_save(score)
+                        if self.early_stopping(score):
+                            break
+                        
 
                 batch_iter.set_description(desc()) 
             
@@ -120,41 +189,53 @@ class _Trainer():
         return self._validation_log(data_dict)
 
     def checkpoint_save(self, loss: float) -> None:
-        if self.global_rank == 0:
-            path = CHECKPOINTS_DIRECTORY()+self.train_name+"/"
-            last_loss = None
-            if os.path.exists(path) and os.listdir(path):
-                name = sorted(os.listdir(path))[-1]
-                state_dict = torch.load(path+name, weights_only=False)
-                last_loss = state_dict["loss"]
-                if self.save_checkpoint_mode == "BEST":
-                    if last_loss >= loss:
-                        os.remove(path+name)
-
-            if self.save_checkpoint_mode != "BEST" or (last_loss is None or last_loss >= loss):
-                name = DATE()+".pt"
-                if not os.path.exists(path):
-                    os.makedirs(path)
-                
-                save_dict = {
-                    "epoch": self.epoch,
-                    "it": self.it,
-                    "loss": loss,
-                    "Model": self.model.module.state_dict()}
+        if self.global_rank != 0:
+            return
 
-                if self.modelEMA is not None:
-                    save_dict.update({"Model_EMA" : self.modelEMA.module.state_dict()})
+        path = CHECKPOINTS_DIRECTORY()+self.train_name+"/"
+        os.makedirs(path, exist_ok=True)
+
+        name = DATE() + ".pt"
+        save_path = os.path.join(path, name)
 
-                save_dict.update({'{}_optimizer_state_dict'.format(name): network.optimizer.state_dict() for name, network in self.model.module.getNetworks().items() if network.optimizer is not None})
-                torch.save(save_dict, path+name)
+        save_dict = {
+        "epoch": self.epoch,
+        "it": self.it,
+        "loss": loss,
+        "Model": self.model.module.state_dict()
+        }
+
+        if self.modelEMA is not None:
+            save_dict["Model_EMA"] = self.modelEMA.module.state_dict()
+        
+        save_dict.update({'{}_optimizer_state_dict'.format(name): network.optimizer.state_dict() for name, network in self.model.module.getNetworks().items() if network.optimizer is not None})
+        torch.save(save_dict, save_path)
+
+        if self.save_checkpoint_mode == "BEST":
+            all_checkpoints = sorted([
+                os.path.join(path, f)
+                for f in os.listdir(path) if f.endswith(".pt")
+            ])
+            best_ckpt = None
+            best_loss = float('inf')
+
+            for f in all_checkpoints:
+                d = torch.load(f, weights_only=False)
+                if d.get("loss", float("inf")) < best_loss:
+                    best_loss = d["loss"]
+                    best_ckpt = f
+
+            for f in all_checkpoints:
+                if f != best_ckpt and f != save_path:
+                    os.remove(f)
 
     @torch.no_grad()
-    def _log(self, type_log: str, data_dict : dict[str, tuple[torch.Tensor, int, int, int]]) -> float:
+    def _log(self, type_log: str, data_dict : dict[str, tuple[torch.Tensor, int, int, int]]) -> dict[str, float]:
         models: dict[str, Network] = {"" : self.model.module}
         if self.modelEMA is not None:
             models["_EMA"] = self.modelEMA.module
         
-        measures = DistributedObject.getMeasure(self.world_size, self.global_rank, self.local_rank*self.size+self.size-1, models, self.it_validation if type_log == "Trainning" else len(self.dataloader_validation))
+        measures = DistributedObject.getMeasure(self.world_size, self.global_rank, self.local_rank*self.size+self.size-1, models, self.it_validation if type_log == "Training" else len(self.dataloader_validation))
         
         if self.global_rank == 0:
             images_log = []
@@ -178,27 +259,29 @@ class _Trainer():
                         for name, layer, _ in model.get_layers([v.to(0) for k, v in self.getInput(data_dict).items() if k[1]], images_log):
                             self.data_log[name][0](self.tb, "{}/{}{}".format(type_log, name, label), layer[:self.data_log[name][1]].detach().cpu().numpy(), self.it)
                         
-            if type_log == "Trainning":
+            if type_log == "Training":
                 for name, network in self.model.module.getNetworks().items():
                     if network.optimizer is not None:
                         self.tb.add_scalar("{}/{}/Learning Rate".format(type_log, name), network.optimizer.param_groups[0]['lr'], self.it)
         
         if self.global_rank == 0:
-            loss = []
+            loss = {}
             for name, network in self.model.module.getNetworks().items():
                 if network.measure is not None:
-                    loss.append(sum([v[1] for v in measures["{}".format(name)][0].values()]))
-            return np.mean(loss)
+                    loss.update({k : v[1] for k, v in measures["{}{}".format(name, label)][0].items()})
+                    loss.update({k : v[1] for k, v in measures["{}{}".format(name, label)][1].items()})
+            return loss
         return None
     
     @torch.no_grad()
-    def _train_log(self, data_dict : dict[str, tuple[torch.Tensor, int, int, int]]) -> float:
-        return self._log("Trainning", data_dict)
+    def _train_log(self, data_dict : dict[str, tuple[torch.Tensor, int, int, int]]) -> dict[str, float]:
+        return self._log("Training", data_dict)
 
     @torch.no_grad()
-    def _validation_log(self, data_dict : dict[str, tuple[torch.Tensor, int, int, int]]) -> float:
+    def _validation_log(self, data_dict : dict[str, tuple[torch.Tensor, int, int, int]]) -> dict[str, float]:
         return self._log("Validation", data_dict)
 
+    
 class Trainer(DistributedObject):
 
     @config("Trainer")
@@ -214,6 +297,7 @@ class Trainer(DistributedObject):
                     gpu_checkpoints: Union[list[str], None] = None,
                     ema_decay : float = 0,
                     data_log: Union[list[str], None] = None,
+                    early_stopping: Union[EarlyStopping, None] = None,
                     save_checkpoint_mode: str= "BEST") -> None:
         if os.environ["KONFAI_CONFIG_MODE"] != "Done":
             exit(0)
@@ -223,6 +307,7 @@ class Trainer(DistributedObject):
         self.autocast = autocast
         self.epochs = epochs
         self.epoch = 0
+        self.early_stopping = early_stopping
         self.it = 0
         self.it_validation = it_validation
         self.model = model.getModel(train=True)
@@ -306,7 +391,7 @@ class Trainer(DistributedObject):
         if state != State.TRAIN:
             state_dict = self._load()
 
-        self.model.init(self.autocast, state)
+        self.model.init(self.autocast, state, self.dataset.getGroupsDest())
         self.model.init_outputsGroup()
         self.model._compute_channels_trace(self.model, self.model.in_channels, self.gradient_checkpoints, self.gpu_checkpoints)
         self.model.load(state_dict, init=True, ema=False)
@@ -326,5 +411,5 @@ class Trainer(DistributedObject):
         model = DDP(model, static_graph=True) if torch.cuda.is_available() else CPU_Model(model)
         if self.modelEMA is not None:
             self.modelEMA.module = Network.to(self.modelEMA.module, local_rank)
-        with _Trainer(world_size, global_rank, local_rank, self.size, self.name, self.data_log, self.save_checkpoint_mode, self.epochs, self.epoch, self.autocast, self.it_validation, self.it, model, self.modelEMA, *dataloaders) as t:
+        with _Trainer(world_size, global_rank, local_rank, self.size, self.name, self.early_stopping, self.data_log, self.save_checkpoint_mode, self.epochs, self.epoch, self.autocast, self.it_validation, self.it, model, self.modelEMA, *dataloaders) as t:
             t.run()

konfai/utils/config.py

@@ -6,14 +6,10 @@ from copy import deepcopy
 from typing import Union, Literal, get_origin, get_args
 import torch
 from konfai import CONFIG_FILE
+from konfai.utils.utils import ConfigError
 
 yaml = ruamel.yaml.YAML()
 
-class ConfigError(Exception):
-
-    def __init__(self, message : str = "The config only supports types : config(Object), int, str, bool, float, list[int], list[str], list[bool], list[float], dict[str, Object]") -> None:
-        self.message = message
-        super().__init__(self.message)
 
 class Config():
 
@@ -187,9 +183,8 @@ def config(key : Union[str, None] = None):
                             default_value = param.default if param.default != inspect._empty else allowed_values[0]
                             value = config.getValue(param.name, f"default:{default_value}")
                             if value not in allowed_values:
-                                raise ValueError(
-                                    f"[Config] Invalid value '{value}' for parameter '{param.name}'. "
-                                    f"Expected one of: {allowed_values}."
+                                raise ConfigError(
+                                    f"Invalid value '{value}' for parameter '{param.name} expected one of: {allowed_values}."
                                 )
                             kwargs[param.name] = value
                             continue
@@ -222,21 +217,26 @@ def config(key : Union[str, None] = None):
                                         values = config.getValue(param.name, param.default)
                                         kwargs[param.name] = values
                                     else:
-                                        raise ConfigError()
+                                        raise ConfigError("Config: The config only supports types : config(Object), int, str, bool, float, list[int], list[str], list[bool], list[float], dict[str, Object]")
                                 elif str(annotation).startswith("dict"):
                                     if annotation.__args__[0] == str:
                                         values = config.getValue(param.name, param.default)
                                         if values is not None and annotation.__args__[1] not in [int, str, bool, float]:
-                                            kwargs[param.name] = {value : annotation.__args__[1](config = filename, DL_args = key_tmp+"."+param.name+"."+value) for value in values}
+                                            try:
+                                                kwargs[param.name] = {value : annotation.__args__[1](config = filename, DL_args = key_tmp+"."+param.name+"."+value) for value in values}
+                                            except ValueError as e:
+                                                raise ValueError(e)
+                                            except Exception as e:
+                                                raise ConfigError("{} {}".format(values, e))
                                         else:
                                             kwargs[param.name] = values
                                     else: 
-                                        raise ConfigError()
+                                        raise ConfigError("Config: The config only supports types : config(Object), int, str, bool, float, list[int], list[str], list[bool], list[float], dict[str, Object]")
                                 else:
                                     try:
                                         kwargs[param.name] = annotation(config = filename, DL_args = key_tmp)
                                     except Exception as e:
-                                        raise ValueError("[Config] Failed to instantiate {} with type {}".format(param.name, annotation.__name__))
+                                        raise ConfigError("Failed to instantiate {} with type {}, error {} ".format(param.name, annotation.__name__, e))
                                     
                                     if os.environ['KONFAI_CONFIG_VARIABLE'] == "True":
                                         os.environ['KONFAI_CONFIG_VARIABLE'] = "False"

konfai/utils/utils.py

@@ -145,8 +145,12 @@ def get_patch_slices_from_nb_patch_per_dim(patch_size_tmp: list[int], nb_patch_p
 
 def get_patch_slices_from_shape(patch_size: list[int], shape : list[int], overlap: Union[int, None]) -> tuple[list[tuple[slice]], list[tuple[int, bool]]]:
     if len(shape) != len(patch_size):
-        return [tuple([slice(0, s) for s in shape])], [(1, True)]*len(shape)
-    
+         raise DatasetManagerError(
+                f"Dimension mismatch: 'patch_size' has {len(patch_size)} dimensions, but 'shape' has {len(shape)}.",
+                f"patch_size: {patch_size}",
+                f"shape: {shape}",
+                "Both must have the same number of dimensions (e.g., 3D patch for 3D volume)."
+            )
     patch_slices = []
     nb_patch_per_dim = []
     slices : list[list[slice]] = []
@@ -192,12 +196,8 @@ def _logImageFormat(input : np.ndarray):
 
     if len(input.shape) == 3 and input.shape[0] != 1:
         input = np.expand_dims(input, axis=0)
-
     if len(input.shape) == 4:
         input = input[:, input.shape[1]//2]
-    
-    if input.dtype == np.uint8:
-        return input
         
     input = input.astype(float)
     b = -np.min(input)
@@ -325,7 +325,7 @@ class DistributedObject():
         return self
 
     def __exit__(self, type, value, traceback):
-        pass
+        cleanup()
 
     @abstractmethod
     def run_process(self, world_size: int, global_rank: int, local_rank: int, dataloaders: list[DataLoader]):
@@ -370,11 +370,12 @@ class DistributedObject():
             dataloaders = self.dataloader[global_rank]
             if torch.cuda.is_available():    
                 torch.cuda.set_device(local_rank)
-                
-            self.run_process(world_size, global_rank, local_rank, dataloaders)
-            if torch.cuda.is_available():
-                pynvml.nvmlShutdown()
-            cleanup()
+            try:
+                self.run_process(world_size, global_rank, local_rank, dataloaders)
+            finally:
+                cleanup()
+                if torch.cuda.is_available():
+                    pynvml.nvmlShutdown()
 
 def setup(parser: argparse.ArgumentParser) -> DistributedObject:
     # KONFAI arguments
@@ -460,7 +461,7 @@ def setupGPU(world_size: int, port: int, rank: Union[int, None] = None) -> tuple
         local_rank = rank
     if global_rank >= world_size:
         return None, None
-    print("tcp://{}:{}".format(host_name, port))
+    #print("tcp://{}:{}".format(host_name, port))
     if torch.cuda.is_available():
         torch.cuda.empty_cache()
         dist.init_process_group("nccl", rank=global_rank, init_method="tcp://{}:{}".format(host_name, port), world_size=world_size)
@@ -476,7 +477,7 @@ def find_free_port():
         return s.getsockname()[1]
     
 def cleanup():
-    if torch.cuda.is_available():
+    if dist.is_initialized():
         dist.destroy_process_group()
 
 def synchronize_data(world_size: int, gpu: int, data: any) -> list[Any]:
@@ -506,3 +507,49 @@ def _resample_affine(data: torch.Tensor, matrix: torch.Tensor):
     else:
         mode = "bilinear"
     return F.grid_sample(data.unsqueeze(0).type(torch.float32), F.affine_grid(matrix[:, :-1,...].type(torch.float32), [1]+list(data.shape), align_corners=True), align_corners=True, mode=mode, padding_mode="reflection").squeeze(0).type(data.dtype)
+
+
+SUPPORTED_EXTENSIONS = [
+    "mha", "mhd",         # MetaImage
+    "nii", "nii.gz",      # NIfTI
+    "nrrd", "nrrd.gz",    # NRRD
+    "gipl", "gipl.gz",    # GIPL
+    "hdr", "img",         # Analyze
+    "dcm",                 # DICOM (si GDCM activé)
+    "tif", "tiff",        # TIFF
+    "png", "jpg", "jpeg", "bmp",  # 2D formats
+    "h5", "itk.txt", ".fcsv", ".xml", ".vtk", ".npy"
+
+]
+
+class KonfAIError(Exception):
+
+    def __init__(self, typeError: str, message: list[str]) -> None:
+        super().__init__("\n[{}] {}".format(typeError, message[0])+"\n→\t".join(message[1:]))
+
+
+class ConfigError(KonfAIError):
+
+    def __init__(self, *message) -> None:
+        super().__init__("Config", message)
+
+
+class DatasetManagerError(KonfAIError):
+
+    def __init__(self, *message) -> None:
+        super().__init__("DatasetManager", message)
+
+class MeasureError(KonfAIError):
+
+    def __init__(self, *message) -> None:
+        super().__init__("Measure", message)
+
+class TrainerError(KonfAIError):
+
+    def __init__(self, *message) -> None:
+        super().__init__("Trainer", message)
+
+class AugmentationError(KonfAIError):
+
+    def __init__(self, *message) -> None:
+        super().__init__("Augmentation", message)

{konfai-1.0.9.dist-info → konfai-1.1.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: konfai
-Version: 1.0.9
+Version: 1.1.1
 Summary: Modular and configurable Deep Learning framework with YAML and PyTorch
 Author-email: Valentin Boussot <boussot.v@gmail.com>
 License-Expression: Apache-2.0

{konfai-1.0.9.dist-info → konfai-1.1.1.dist-info}/RECORD

@@ -1,15 +1,15 @@
 konfai/__init__.py,sha256=fZM9EjrMcdJZE-jQAsNu3ZcWfa9Ylbly2q4l9STfpBI,795
 konfai/evaluator.py,sha256=TsHQNN4DhP33Sal9-exbOouZAHe7gNEk7RsBaasgkEQ,7373
-konfai/main.py,sha256=g-6TQ2fbRyD6ZJSJ0KwutGNmLTMgjF8eMKdzWA4gHYM,2401
+konfai/main.py,sha256=OPAUWees1j6NNmggyI7lM2abZctCqk1OsvQuc9FpePY,2515
 konfai/predictor.py,sha256=FGn6_Nt4PCdxNFoIOt8nbBjrAMTwc55uZqy6OFXUjhY,22320
-konfai/trainer.py,sha256=RQhR1vtnzZ53jPAS5LkoBZOVeWTv3fQQ19uprzeoznw,16866
+konfai/trainer.py,sha256=22IKMiPeHNJMGcJdVq9BH-Hsopp6xF4QSYyPabz4LGs,19604
 konfai/data/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-konfai/data/augmentation.py,sha256=QNwwl02PDozhrBvg5nZgYpOcj41H_Nyee6qz27nQca0,31692
-konfai/data/data_manager.py,sha256=knkR6hfZSeZlAobAGfWqxHKhx-TfAr-L1ZDjJLVXOg8,23802
-konfai/data/patching.py,sha256=MuhOmauFEy8jarZyskGY0GuxCSY9QByKMNolGKF-gqo,14355
-konfai/data/transform.py,sha256=rOIFrVnNwxmltqKNI3y_u868MBPdGe1lMJPVqugqQXI,25092
+konfai/data/augmentation.py,sha256=ASmKWBpykLBHDB_YeTgoBTlqvJ06v5OUG7n7ugPN6NU,31718
+konfai/data/data_manager.py,sha256=AfZpQaHEd4QmA8Sxd6SK2LK3Nv658wlZVbivETq4Y4k,28439
+konfai/data/patching.py,sha256=JFgb4qgS_gqlcnFV_Rm0JvCzKQleXNZyOWxqqM8H01M,14499
+konfai/data/transform.py,sha256=ttALCEvvqIcwcYJTp4KCnf87e2hzvkXlwrtksfpWRUU,25064
 konfai/metric/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-konfai/metric/measure.py,sha256=qDFlytlMoRo-K3l-0ot7dCmGf-y7GpoT29rid5mxOvk,21996
+konfai/metric/measure.py,sha256=K7s15wNJm1_Iaav9y7Oe_UhSnbLUiybhLTVumHZ8ZaY,22001
 konfai/metric/schedulers.py,sha256=UoSr1TW_hrus3DhvOEbDefxCSUGz7lJS_8vbz0GEye8,1370
 konfai/models/classification/convNeXt.py,sha256=Phj1hO8TCItVhBXoFXQcIkA85DZxurGLyHIPWBfXJ0Y,9243
 konfai/models/classification/resnet.py,sha256=t8KJEgGudWBpGJM9YS1lH_5eX0-wGbK7ZW5uZW214eM,7958
@@ -18,22 +18,22 @@ konfai/models/generation/ddpm.py,sha256=awvuRo-vk8M80N93NWF4i0-WWfaycBxSOmdYJNJv
 konfai/models/generation/diffusionGan.py,sha256=KnJyV-tx4CiE_ag-5IXwiYLCuC2yFHX16k2CtASdecg,33199
 konfai/models/generation/gan.py,sha256=-GoKxHm3W9NdD4U77UcJrG5TfOZ3NWFUZG663kt2XPo,7854
 konfai/models/generation/vae.py,sha256=_3JYVT2ojZ0P98tYcD2ny7a-gWVUmnByLDhY7i-n_4g,4719
-konfai/models/registration/registration.py,sha256=CymMfHlkE2pYa5Kfv5lNtp_lAK9OHq6GXA-tR-eHBM8,6341
+konfai/models/registration/registration.py,sha256=18EiWt4RJIXLyFtqU-kHjV1sMnQRm9mxAA6_-2B1YqI,6313
 konfai/models/representation/representation.py,sha256=RwQYoxtdph440-t_ZLelykl0hkUAD1zdspQaLkgxb-0,2677
 konfai/models/segmentation/NestedUNet.py,sha256=6XGizAIc4bDL8vx4AHW8BBFjUvovRYcjdMBHsN4ViNo,4301
 konfai/models/segmentation/UNet.py,sha256=9-g63oNqaxSlGmrD1-IVzJ-kac9QphmM7i-3rEsH23I,4218
 konfai/network/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-konfai/network/blocks.py,sha256=EN1JN929zzV0FfecgFnVvv8u-WwENFRxloOpfCBkqeU,13529
-konfai/network/network.py,sha256=psDlOiAAaBgCOgwB8ld38YzMnw80DlGJorJoOn7yslM,45463
+konfai/network/blocks.py,sha256=RaTI0Lrvq1V-GIFei-WTUB6wlg4LydZksAyJ8DMk40M,13502
+konfai/network/network.py,sha256=DTROmwwPJZQllJx32GwAixfy1E23F1mtYy1bpF23TjU,46538
 konfai/utils/ITK.py,sha256=OxTieDNNYHGkn7zxJsAG-6ecRG1VYMvn1dlBbBe1DOs,13955
 konfai/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-konfai/utils/config.py,sha256=8b6gCo6lh4ckdQI1aXReOtBjA3elAm4XfcsO545ssjE,12062
+konfai/utils/config.py,sha256=OsCUqgNaPX56nD_MpJ2WRpiQ7xxqHonfPYaS9VGtsl8,12413
 konfai/utils/dataset.py,sha256=RNULLVauhYiyeQkpVhOVq4VRwI4KRyoQA2VCmOh8VbE,35525
 konfai/utils/registration.py,sha256=v1srEBOcgDnHrx0YtsK6bcj0yCMH7wNeaQ3wC7gEvOw,8898
-konfai/utils/utils.py,sha256=lirj-04jCNTIpZieCFSalK-iVsKQacvddOjF9sIf-Do,20558
-konfai-1.0.9.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-konfai-1.0.9.dist-info/METADATA,sha256=_nzxf8r20-oXYHIIuyzvn1FyIlL07DNuSc_mnZlV34g,2515
-konfai-1.0.9.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-konfai-1.0.9.dist-info/entry_points.txt,sha256=fG82HRN5-g39ACSOCtij_I3N6EHxfYnMR0D7TI_8pW8,81
-konfai-1.0.9.dist-info/top_level.txt,sha256=xF470dkIlFoFqTZEOlRehKJr4WU_8OKGXrJqYm9vWKs,7
-konfai-1.0.9.dist-info/RECORD,,
+konfai/utils/utils.py,sha256=GPzQQ7kBmraHytsUdPOqwW0Qu-kAHGA-wwMd4obdVLE,22018
+konfai-1.1.1.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+konfai-1.1.1.dist-info/METADATA,sha256=mMT6fvoAbwoMkChW6G_Y2vDhrtiMss86xezEnylzLrE,2515
+konfai-1.1.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+konfai-1.1.1.dist-info/entry_points.txt,sha256=fG82HRN5-g39ACSOCtij_I3N6EHxfYnMR0D7TI_8pW8,81
+konfai-1.1.1.dist-info/top_level.txt,sha256=xF470dkIlFoFqTZEOlRehKJr4WU_8OKGXrJqYm9vWKs,7
+konfai-1.1.1.dist-info/RECORD,,