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

konfai/__init__.py

@@ -12,5 +12,5 @@ CONFIG_FILE = lambda : os.environ["KONFAI_CONFIG_FILE"]
 KONFAI_STATE = lambda : os.environ["KONFAI_STATE"]
 KONFAI_ROOT = lambda : os.environ["KONFAI_ROOT"]
 CUDA_VISIBLE_DEVICES = lambda : os.environ["CUDA_VISIBLE_DEVICES"]
-
+KONFAI_NB_CORES = lambda : os.environ["KONFAI_NB_CORES"]
 DATE = lambda : datetime.datetime.now().strftime("%Y_%m_%d_%H_%M_%S")

konfai/data/data_manager.py

@@ -62,12 +62,25 @@ class GroupTransform:
         for transform in self.post_transforms:
             transform.setDevice(device)
 
+class GroupTransformMetric(GroupTransform):
+
+    @config()
+    def __init__(self,  pre_transforms : Union[dict[str, TransformLoader], list[Transform]] = {"default:Normalize:Standardize:Unsqueeze:TensorCast:ResampleIsotropic:ResampleResize": TransformLoader()},
+                        post_transforms : Union[dict[str, TransformLoader], list[Transform]] = {"default:Normalize:Standardize:Unsqueeze:TensorCast:ResampleIsotropic:ResampleResize": TransformLoader()}):
+        super().__init__(pre_transforms, post_transforms)
+
 class Group(dict[str, GroupTransform]):
 
     @config()
     def __init__(self, groups_dest: dict[str, GroupTransform] = {"default:group_dest": GroupTransform()}):
         super().__init__(groups_dest)
 
+class GroupMetric(dict[str, GroupTransformMetric]):
+
+    @config()
+    def __init__(self, groups_dest: dict[str, GroupTransformMetric] = {"default:group_dest": GroupTransformMetric()}):
+        super().__init__(groups_dest)
+
 class CustomSampler(Sampler[int]):
 
     def __init__(self, size: int, shuffle: bool = False) -> None:
@@ -109,32 +122,33 @@ class DatasetIter(data.Dataset):
     def getDatasetFromIndex(self, group_dest: str, index: int) -> DatasetManager:
         return self.data[group_dest][index]
     
-    def resetAugmentation(self):
-        if self.inlineAugmentations:
+    def resetAugmentation(self, label):
+        if self.inlineAugmentations and len(self.dataAugmentationsList) > 0:
             for index in range(self.nb_dataset):
-                self._unloadData(index)
                 for group_src in self.groups_src:
                     for group_dest in self.groups_src[group_src]:
+                        self.data[group_dest][index].unloadAugmentation()
                         self.data[group_dest][index].resetAugmentation()
+        self.load(label + " Augmentation")
 
-    def load(self):
+    def load(self, label: str):
         if self.use_cache:
             memory_init = getMemory()
 
-            indexs = [index for index in range(self.nb_dataset) if index not in self._index_cache]
+            indexs = [index for index in range(self.nb_dataset)]
             if len(indexs) > 0:
                 memory_lock = threading.Lock()
+                desc = lambda : "Caching "+ label +": {} | {} | {}".format(memoryInfo(), memoryForecast(memory_init, 0, self.nb_dataset), cpuInfo())
                 pbar = tqdm.tqdm(
                     total=len(indexs),
-                    desc="Caching : init | {} | {}".format(memoryForecast(memory_init, 0, self.nb_dataset), cpuInfo()),
-                    leave=False,
-                    disable=self.rank != 0 and "KONFAI_CLUSTER" not in os.environ
+                    desc=desc(),
+                    leave=False
                 )
 
                 def process(index):
                     self._loadData(index)
                     with memory_lock:
-                        pbar.set_description("Caching : {} | {} | {}".format(memoryInfo(), memoryForecast(memory_init, index, self.nb_dataset), cpuInfo()))
+                        pbar.set_description(desc())
                         pbar.update(1)
                 with ThreadPoolExecutor(max_workers=os.cpu_count()//(device_count() if device_count() > 0 else 1)) as executor:
                     futures = [executor.submit(process, index) for index in indexs]
@@ -257,10 +271,10 @@ class Data(ABC):
                         groups_src : dict[str, Group],
                         patch : Union[DatasetPatch, None],
                         use_cache : bool,
-                        subset : Union[Subset, dict[str, Subset]],
+                        subset : Subset,
                         num_workers : int,
                         batch_size : int,
-                        validation: Union[float, str, list[int], list[str]] = 1,
+                        validation: Union[float, str, list[int], list[str], None] = None,
                         inlineAugmentations: bool = False,
                         dataAugmentationsList: dict[str, DataAugmentationsList]= {}) -> None:
         self.dataset_filenames = dataset_filenames
@@ -343,7 +357,7 @@ class Data(ABC):
                 append = flag == "a"
 
             if format not in SUPPORTED_EXTENSIONS:
-                    raise DatasetManagerError(f"Unsupported file format '{format}'.",
+                raise DatasetManagerError(f"Unsupported file format '{format}'.",
                         f"Supported extensions are: {', '.join(SUPPORTED_EXTENSIONS)}")
             
             dataset = Dataset(filename, format)
@@ -362,7 +376,7 @@ class Data(ABC):
                 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()))}",
+                    "Available groups across all datasets: {}".format(["{} {}".format(f, d.getGroup()) for f, d in self.datasets.items()]),
                     f"Please check that an entry in the dataset with the name '{group_src}.{format}' exists."
                 )
            
@@ -382,28 +396,38 @@ class Data(ABC):
         dataset_name : dict[str, dict[str, list[str]]] = {}
         dataset_info : dict[str, dict[str, dict[str, Attribute]]] = {}
         for group in self.groups_src:
+            namesByGroup = set()
             if group not in dataset_name:
                 dataset_name[group] = {}
                 dataset_info[group] = {}
             for filename, _ in datasets[group]:
-                names.update(self.datasets[filename].getNames(group))
+                namesByGroup.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]}
+            if len(names) == 0:
+                names.update(namesByGroup)
+            else: 
+                names = names.intersection(namesByGroup)
+        if len(names) == 0:
+           raise DatasetManagerError(
+                f"No data was found for groups {list(self.groups_src.keys())}: although each group contains data from a dataset, there are no common dataset names shared across all groups, the intersection is empty."
+            )   
+                    
         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]))
-        else:
-             for group in dataset_name:
-                for filename, append in datasets[group]:
-                    if append:
-                        subset_names.update(self.subset([dataset_name[group][filename]], [dataset_info[group][filename]]))
+        for group in dataset_name:
+            subset_names_bygroup = set()
+            for filename, append in datasets[group]:
+                if append:
+                    subset_names_bygroup.update(self.subset([dataset_name[group][filename]], [dataset_info[group][filename]]))
+                else:
+                    if len(subset_names_bygroup) == 0:
+                        subset_names_bygroup.update(self.subset([dataset_name[group][filename]], [dataset_info[group][filename]])) 
                     else:
-                        if len(subset_names) == 0:
-                            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]]))
+                        subset_names_bygroup = subset_names_bygroup.intersection(self.subset([dataset_name[group][filename]], [dataset_info[group][filename]]))
+            if len(subset_names) == 0:
+                subset_names.update(subset_names_bygroup)
+            else: 
+                subset_names = subset_names.intersection(subset_names_bygroup)
         if len(subset_names) == 0:
             raise DatasetManagerError("All data entries were excluded by the subset filter.",
                 f"Dataset entries found: {', '.join(names)}",
@@ -424,7 +448,7 @@ class Data(ABC):
         validate_map = []
         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")
+                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):
@@ -527,20 +551,19 @@ class DataPrediction(Data):
                         groups_src : dict[str, Group] = {"default" : Group()},
                         augmentations : Union[dict[str, DataAugmentationsList], None] = {"DataAugmentation_0" : DataAugmentationsList()},
                         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, dataAugmentationsList=augmentations if augmentations else {})
+        super().__init__(dataset_filenames, groups_src, patch, False, subset, num_workers, batch_size, dataAugmentationsList=augmentations if augmentations else {})
 
 class DataMetric(Data):
 
     @config("Dataset")
     def __init__(self,  dataset_filenames : list[str] = ["default:./Dataset"], 
-                        groups_src : dict[str, Group] = {"default" : Group()},
+                        groups_src : dict[str, GroupMetric] = {"default" : GroupMetric()},
                         subset : Union[PredictionSubset, dict[str, PredictionSubset]] = PredictionSubset(),
                         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, validation=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=validation)

konfai/data/patching.py

@@ -15,7 +15,6 @@ from konfai.utils.dataset import Dataset, Attribute
 from konfai.data.transform import Transform, Save
 from konfai.data.augmentation import DataAugmentationsList
 
-
 class PathCombine(ABC):
 
     def __init__(self) -> None:
@@ -240,6 +239,7 @@ class DatasetManager():
         self.index = index
         self.dataset = dataset
         self.loaded = False
+        self.augmentationLoaded = False
         self.cache_attributes: list[Attribute] = []
         _shape, cache_attribute =  self.dataset.getInfos(self.group_src, name)
         self.cache_attributes.append(cache_attribute)
@@ -258,6 +258,7 @@ class DatasetManager():
         self.cache_attributes_bak = copy.deepcopy(self.cache_attributes)
     
     def resetAugmentation(self):
+        self.cache_attributes[:] = self.cache_attributes[:1]
         i = 1
         for dataAugmentations in self.dataAugmentationsList:
             shape = []
@@ -272,15 +273,24 @@ class DatasetManager():
                 self.cache_attributes.append(caches_attribute[it])
                 self.patch.load(s, i)
                 i+=1
-
+    
     def load(self, pre_transform : list[Transform], dataAugmentationsList : list[DataAugmentationsList], device: torch.device) -> None:
-        if self.loaded:
-            return
+        if not self.loaded:
+            self._load(pre_transform)
+        if not self.augmentationLoaded:
+            self._loadAugmentation(dataAugmentationsList, device)
+            
+    def _load(self, pre_transform : list[Transform]):
+        self.cache_attributes = copy.deepcopy(self.cache_attributes_bak)
         i = len(pre_transform)
         data = None
         for transformFunction in reversed(pre_transform):
             if isinstance(transformFunction, Save):
-                filename, format = transformFunction.save.split(":")
+                if len(transformFunction.dataset.split(":")) > 1:
+                    filename, format = transformFunction.dataset.split(":")
+                else:
+                    filename = transformFunction.dataset.split(":")
+                    format = "mha"
                 dataset = Dataset(filename, format)
                 if dataset.isDatasetExist(self.group_dest, self.name):
                     data, attrib = dataset.readData(self.group_dest, self.name)
@@ -298,27 +308,40 @@ class DatasetManager():
             for transformFunction in pre_transform[i:]:
                 data = transformFunction(self.name, data, self.cache_attributes[0])
                 if isinstance(transformFunction, Save):
-                    filename, format = transformFunction.save.split(":")
+                    if len(transformFunction.dataset.split(":")) > 1:
+                        filename, format = transformFunction.dataset.split(":")
+                    else:
+                        filename = transformFunction.dataset.split(":")
+                        format = "mha"
                     dataset = Dataset(filename, format)
                     dataset.write(self.group_dest, self.name, data.numpy(), self.cache_attributes[0])
         self.data : list[torch.Tensor] = list()
         self.data.append(data)
 
+        for i in range(len(self.cache_attributes)-1):
+            self.cache_attributes[i+1].update(self.cache_attributes[0])
+        self.loaded = True
+    
+    def _loadAugmentation(self, dataAugmentationsList : list[DataAugmentationsList], device: torch.device) -> None:
         for dataAugmentations in dataAugmentationsList:
-            a_data = [data.clone() for _ in range(dataAugmentations.nb)]
+            a_data = [self.data[0].clone() for _ in range(dataAugmentations.nb)]
             for dataAugmentation in dataAugmentations.dataAugmentations:
                 a_data = dataAugmentation(self.index, a_data, device)
             
             for d in a_data:
                 self.data.append(d)
-        self.loaded = True
+        self.augmentationLoaded = True
 
     def unload(self) -> None:
-        if hasattr(self, "data"):
-            del self.data
-        self.cache_attributes = copy.deepcopy(self.cache_attributes_bak)
+        self.data.clear()
         self.loaded = False
-    
+        self.augmentationLoaded = False
+        
+    def unloadAugmentation(self) -> None:
+        self.data[:] = self.data[:1]
+        self.augmentationLoaded = False
+
+
     def getData(self, index : int, a : int, post_transforms : list[Transform], isInput: bool) -> torch.Tensor:
         data = self.patch.getData(self.data[a], index, a, isInput)
         for transformFunction in post_transforms:

konfai/data/transform.py

@@ -6,7 +6,7 @@ from abc import ABC, abstractmethod
 import torch.nn.functional as F
 from typing import Any, Union
 
-from konfai.utils.utils import _getModule, NeedDevice, _resample_affine, _affine_matrix
+from konfai.utils.utils import _getModule, NeedDevice, _resample_affine, _affine_matrix, TransformError
 from konfai.utils.dataset import Dataset, Attribute, data_to_image, image_to_data
 from konfai.utils.config import config
 
@@ -211,39 +211,67 @@ class Resample(Transform, ABC):
         _ = cache_attribute.pop_np_array("Spacing")
         return self._resample(input, [int(size) for size in size_1])
 
-class ResampleIsotropic(Resample):
+class ResampleToResolution(Resample):
+
+    def __init__(self, spacing : list[Union[float, None]] = [1., 1., 1.]) -> None:
+        self.spacing = torch.tensor([0 if s < 0 else s for s in spacing])
 
-    def __init__(self, spacing : list[float] = [1., 1., 1.]) -> None:
-        self.spacing = torch.tensor(spacing, dtype=torch.float64)
-        
     def transformShape(self, shape: list[int], cache_attribute: Attribute) -> list[int]:
-        assert "Spacing" in cache_attribute, "Error no spacing"
-        resize_factor = self.spacing/cache_attribute.get_tensor("Spacing").flip(0)
-        return  [int(x) for x in (torch.tensor(shape) * 1/resize_factor)]
+        if "Spacing" not in cache_attribute:
+            TransformError("Missing 'Spacing' in cache attributes, the data is likely not a valid image.",
+                        "Make sure your input is a image (e.g., .nii, .mha) with proper metadata.")
+        if len(shape) != len(self.spacing):
+            TransformError("Shape and spacing dimensions do not match: shape={shape}, spacing={self.spacing}")
+        image_spacing = cache_attribute.get_tensor("Spacing").flip(0)
+        spacing = self.spacing
+        
+        for i, s in enumerate(self.spacing):
+            if s == 0:
+                spacing[i] = image_spacing[i]
+        resize_factor = spacing/cache_attribute.get_tensor("Spacing").flip(0)
+        return [int(x) for x in (torch.tensor(shape) * 1/resize_factor)]
 
     def __call__(self, name: str, input : torch.Tensor, cache_attribute: Attribute) -> torch.Tensor:
-        assert "Spacing" in cache_attribute, "Error no spacing"
-        resize_factor = self.spacing/cache_attribute.get_tensor("Spacing").flip(0)
-        cache_attribute["Spacing"] = self.spacing.flip(0)
+        image_spacing = cache_attribute.get_tensor("Spacing").flip(0)
+        spacing = self.spacing
+        for i, s in enumerate(self.spacing):
+            if s == 0:
+                spacing[i] = image_spacing[i]
+        resize_factor = spacing/cache_attribute.get_tensor("Spacing").flip(0)
+        cache_attribute["Spacing"] = spacing.flip(0)
         cache_attribute["Size"] = np.asarray([int(x) for x in torch.tensor(input.shape[1:])])
         size = [int(x) for x in (torch.tensor(input.shape[1:]) * 1/resize_factor)]
         cache_attribute["Size"] = np.asarray(size)
         return self._resample(input, size)
 
-class ResampleResize(Resample):
+class ResampleToSize(Resample):
 
     def __init__(self, size : list[int] = [100,512,512]) -> None:
         self.size = size
 
     def transformShape(self, shape: list[int], cache_attribute: Attribute) -> list[int]:
-        return self.size
+        if "Spacing" not in cache_attribute:
+            TransformError("Missing 'Spacing' in cache attributes, the data is likely not a valid image.",
+                        "Make sure your input is a image (e.g., .nii, .mha) with proper metadata.")
+        if len(shape) != len(self.size):
+            TransformError("Shape and spacing dimensions do not match: shape={shape}, spacing={self.spacing}")
+        size = self.size
+        for i, s in enumerate(self.size):
+            if s == -1:
+                size[i] = shape[i]
+        return size
     
     def __call__(self, name: str, input: torch.Tensor, cache_attribute: Attribute) -> torch.Tensor:
+        size = self.size
+        image_size =  np.asarray([int(x) for x in torch.tensor(input.shape[1:])])
+        for i, s in enumerate(self.size):
+            if s is None:
+                size[i] = image_size[i]
         if "Spacing" in cache_attribute:
-            cache_attribute["Spacing"] = torch.flip(torch.tensor(list(input.shape[1:]))/torch.tensor(self.size)*torch.flip(cache_attribute.get_tensor("Spacing"), dims=[0]), dims=[0])
-        cache_attribute["Size"] = np.asarray([int(x) for x in torch.tensor(input.shape[1:])])
-        cache_attribute["Size"] = self.size
-        return self._resample(input, self.size)
+            cache_attribute["Spacing"] = torch.flip(torch.tensor(image_size)/torch.tensor(size)*torch.flip(cache_attribute.get_tensor("Spacing"), dims=[0]), dims=[0])
+        cache_attribute["Size"] = image_size
+        cache_attribute["Size"] = size
+        return self._resample(input, size)
 
 class ResampleTransform(Transform):
 
@@ -412,8 +440,8 @@ class FlatLabel(Transform):
 
 class Save(Transform):
 
-    def __init__(self, save: str) -> None:
-        self.save = save
+    def __init__(self, dataset: str) -> None:
+        self.dataset = dataset
     
     def __call__(self, name: str, input : torch.Tensor, cache_attribute: Attribute) -> torch.Tensor:
         return input
@@ -528,7 +556,7 @@ class OneHot(Transform):
         self.num_classes = num_classes
 
     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)
+        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(0)
         return result
     
     def inverse(self, name: str, input: torch.Tensor, cache_attribute: Attribute) -> torch.Tensor:

konfai/evaluator.py

@@ -9,7 +9,7 @@ import builtins
 import importlib
 from konfai import EVALUATIONS_DIRECTORY, PREDICTIONS_DIRECTORY, KONFAI_ROOT, CONFIG_FILE
 from konfai.utils.config import config
-from konfai.utils.utils import _getModule, DistributedObject, synchronize_data
+from konfai.utils.utils import _getModule, DistributedObject, synchronize_data, EvaluatorError
 from konfai.data.data_manager import DataMetric
 
 class CriterionsAttr():
@@ -54,7 +54,8 @@ class Statistics():
             if name_dataset not in self.measures:
                 self.measures[name_dataset] = {}
             self.measures[name_dataset][name] = value
-            
+    
+    @staticmethod   
     def getStatistic(values: list[float]) -> dict[str, float]:
         return {"max": np.max(values), "min": np.min(values), "std": np.std(values), "25pc": np.percentile(values, 25), "50pc": np.percentile(values, 50), "75pc": np.percentile(values, 75), "mean": np.mean(values), "count": len(values)}
     
@@ -91,7 +92,6 @@ class Evaluator(DistributedObject):
             exit(0)
         super().__init__(train_name)
         self.metric_path = EVALUATIONS_DIRECTORY()+self.name+"/"
-        self.predict_path = PREDICTIONS_DIRECTORY()+self.name+"/"
         self.metricsLoader = metrics
         self.dataset = dataset
         self.metrics = {k: v.getTargetsCriterions(k) for k, v in self.metricsLoader.items()}
@@ -102,10 +102,10 @@ class Evaluator(DistributedObject):
         result = {}
         for output_group in self.metrics:
             for target_group in self.metrics[output_group]:
-                targets = [data_dict[group][0] for group in target_group.split("/") if group in data_dict]
+                targets = [data_dict[group][0].to(0) if torch.cuda.is_available() else data_dict[group][0] for group in target_group.split("/") if group in data_dict]
                 name = data_dict[output_group][1][0]
                 for metric in self.metrics[output_group][target_group]:
-                    result["{}:{}:{}".format(output_group, target_group, metric.__class__.__name__)] = metric(data_dict[output_group][0], *targets).item()
+                    result["{}:{}:{}".format(output_group, target_group, metric.__class__.__name__)] = metric(data_dict[output_group][0].to(0) if torch.cuda.is_available() else data_dict[output_group][0], *targets).item()
         statistics.add(result, name)
         return result
     
@@ -126,9 +126,26 @@ class Evaluator(DistributedObject):
 
         self.dataloader = self.dataset.getData(world_size)
 
+        groupsDest = [group for groups in self.dataset.groups_src.values() for group in groups]
+
+        missing_outputs = set(self.metrics.keys()) - set(groupsDest)
+        if missing_outputs:
+            raise EvaluatorError(
+                f"The following metric output groups are missing from 'groupsDest': {sorted(missing_outputs)}. ",
+                f"Available groups: {sorted(groupsDest)}"
+            )
+
+        target_groups = {target for targets in self.metrics.values() for target in targets}
+        missing_targets = target_groups - set(groupsDest)
+        if missing_targets:
+            raise EvaluatorError(
+                f"The following metric target groups are missing from 'groupsDest': {sorted(missing_targets)}. ",
+                f"Available groups: {sorted(groupsDest)}"
+            )
+
     def run_process(self, world_size: int, global_rank: int, gpu: int, dataloaders: list[DataLoader]):
         description = lambda measure : "Metric TRAIN : {} ".format(" | ".join("{}: {:.2f}".format(k, v) for k, v in measure.items()) if measure is not None else "")
-        with tqdm.tqdm(iterable = enumerate(dataloaders[0]), leave=False, desc = description(None), total=len(dataloaders[0])) as batch_iter:
+        with tqdm.tqdm(iterable = enumerate(dataloaders[0]), leave=True, desc = description(None), total=len(dataloaders[0]), ncols=0) as batch_iter:
             for _, data_dict in batch_iter:
                 batch_iter.set_description(description(self.update({k: (v[0], v[4]) for k,v in data_dict.items()}, self.statistics_train)))
         outputs = synchronize_data(world_size, gpu, self.statistics_train.measures)
@@ -136,7 +153,7 @@ class Evaluator(DistributedObject):
             self.statistics_train.write(outputs)
         if len(dataloaders) == 2:
             description = lambda measure : "Metric VALIDATION : {} ".format(" | ".join("{}: {:.2f}".format(k, v) for k, v in measure.items()) if measure is not None else "")
-            with tqdm.tqdm(iterable = enumerate(dataloaders[1]), leave=False, desc = description(None), total=len(dataloaders[1])) as batch_iter:
+            with tqdm.tqdm(iterable = enumerate(dataloaders[1]), leave=True, desc = description(None), total=len(dataloaders[1]), ncols=0) as batch_iter:
                 for _, data_dict in batch_iter:
                     batch_iter.set_description(description(self.update({k: (v[0], v[4]) for k,v in data_dict.items()}, self.statistics_validation)))
             outputs = synchronize_data(world_size, gpu, self.statistics_validation.measures)

konfai/main.py

@@ -3,6 +3,7 @@ import os
 from torch.cuda import device_count
 import torch.multiprocessing as mp
 from konfai.utils.utils import setup, TensorBoard, Log
+from konfai import KONFAI_NB_CORES
 
 import sys
 sys.path.insert(0, os.getcwd())
@@ -11,10 +12,10 @@ def main():
     parser = argparse.ArgumentParser(description="KonfAI", formatter_class=argparse.ArgumentDefaultsHelpFormatter)
     try:
         with setup(parser) as distributedObject:
-            with Log(distributedObject.name):
+            with Log(distributedObject.name, 0):
                 world_size = device_count()
                 if world_size == 0:
-                    world_size = 1
+                    world_size = int(KONFAI_NB_CORES())
                 distributedObject.setup(world_size)
                 with TensorBoard(distributedObject.name):
                     mp.spawn(distributedObject, nprocs=world_size)

konfai/network/network.py

@@ -39,7 +39,6 @@ class OptimizerLoader():
         self.name = name
     
     def getOptimizer(self, key: str, parameter: Iterator[torch.nn.parameter.Parameter]) -> torch.optim.Optimizer:
-        torch.optim.AdamW
         return config("{}.Model.{}.Optimizer".format(KONFAI_ROOT(), key))(getattr(importlib.import_module('torch.optim'), self.name))(parameter, config = None)
         
 class SchedulerStep():

konfai/predictor.py

@@ -94,10 +94,10 @@ class OutDataset(Dataset, NeedDevice, ABC):
 class OutSameAsGroupDataset(OutDataset):
 
     @config("OutDataset")
-    def __init__(self, dataset_filename: str = "./Dataset:mha", group: str = "default", sameAsGroup: str = "default", pre_transforms : dict[str, TransformLoader] = {"default:Normalize": TransformLoader()}, post_transforms : dict[str, TransformLoader] = {"default:Normalize": TransformLoader()}, final_transforms : dict[str, TransformLoader] = {"default:Normalize": TransformLoader()}, patchCombine: Union[str, None] = None, redution: str = "mean", inverse_transform: bool = True) -> None:
+    def __init__(self, dataset_filename: str = "./Dataset:mha", group: str = "default", sameAsGroup: str = "default", pre_transforms : dict[str, TransformLoader] = {"default:Normalize": TransformLoader()}, post_transforms : dict[str, TransformLoader] = {"default:Normalize": TransformLoader()}, final_transforms : dict[str, TransformLoader] = {"default:Normalize": TransformLoader()}, patchCombine: Union[str, None] = None, reduction: str = "mean", inverse_transform: bool = True) -> None:
         super().__init__(dataset_filename, group, pre_transforms, post_transforms, final_transforms, patchCombine)
         self.group_src, self.group_dest = sameAsGroup.split(":")
-        self.redution = redution
+        self.reduction = reduction
         self.inverse_transform = inverse_transform
 
     def addLayer(self, index_dataset: int, index_augmentation: int, index_patch: int, layer: torch.Tensor, dataset: DatasetIter):
@@ -151,9 +151,9 @@ class OutSameAsGroupDataset(OutDataset):
         self.output_layer_accumulator.pop(index)
         dtype = result.dtype
 
-        if self.redution == "mean":
+        if self.reduction == "mean":
             result = torch.mean(result.float(), dim=0).to(dtype)
-        elif self.redution == "median":
+        elif self.reduction == "median":
             result, _ = torch.median(result.float(), dim=0)
         else:
             raise NameError("Reduction method does not exist (mean, median)")
@@ -201,7 +201,7 @@ class OutDatasetLoader():
 
 class _Predictor():
 
-    def __init__(self, world_size: int, global_rank: int, local_rank: int, predict_path: str, data_log: Union[list[str], None], outsDataset: dict[str, OutDataset], modelComposite: DDP, dataloader_prediction: DataLoader) -> None:
+    def __init__(self, world_size: int, global_rank: int, local_rank: int, autocast: bool, predict_path: str, data_log: Union[list[str], None], outsDataset: dict[str, OutDataset], modelComposite: DDP, dataloader_prediction: DataLoader) -> None:
         self.world_size = world_size        
         self.global_rank = global_rank
         self.local_rank = local_rank
@@ -209,7 +209,7 @@ class _Predictor():
         self.modelComposite = modelComposite
         self.dataloader_prediction = dataloader_prediction
         self.outsDataset = outsDataset
-
+        self.autocast = autocast
         
         self.it = 0
 
@@ -239,21 +239,22 @@ class _Predictor():
         self.modelComposite.eval()  
         self.modelComposite.module.setState(NetState.PREDICTION)
         desc = lambda : "Prediction : {}".format(description(self.modelComposite))
-        self.dataloader_prediction.dataset.load()
-        with tqdm.tqdm(iterable = enumerate(self.dataloader_prediction), leave=False, desc = desc(), total=len(self.dataloader_prediction), disable=self.global_rank != 0 and "KONFAI_CLUSTER" not in os.environ) as batch_iter:
+        self.dataloader_prediction.dataset.load("Prediction")
+        with tqdm.tqdm(iterable = enumerate(self.dataloader_prediction), leave=True, desc = desc(), total=len(self.dataloader_prediction), ncols=0) as batch_iter:
             dist.barrier()
             for it, data_dict in batch_iter:
-                input = self.getInput(data_dict)
-                for name, output in self.modelComposite(input, list(self.outsDataset.keys())):
-                    self._predict_log(data_dict)
-                    outDataset = self.outsDataset[name]
-                    for i, (index, patch_augmentation, patch_index) in enumerate([(int(index), int(patch_augmentation), int(patch_index)) for index, patch_augmentation, patch_index in zip(list(data_dict.values())[0][1], list(data_dict.values())[0][2], list(data_dict.values())[0][3])]):
-                        outDataset.addLayer(index, patch_augmentation, patch_index, output[i].cpu(), self.dataset)
-                        if outDataset.isDone(index):
-                            outDataset.write(index, self.dataset.getDatasetFromIndex(list(data_dict.keys())[0], index).name.split("/")[-1], outDataset.getOutput(index, self.dataset))
-
-                batch_iter.set_description(desc())
-                self.it += 1
+                with torch.amp.autocast('cuda', enabled=self.autocast):
+                    input = self.getInput(data_dict)
+                    for name, output in self.modelComposite(input, list(self.outsDataset.keys())):
+                        self._predict_log(data_dict)
+                        outDataset = self.outsDataset[name]
+                        for i, (index, patch_augmentation, patch_index) in enumerate([(int(index), int(patch_augmentation), int(patch_index)) for index, patch_augmentation, patch_index in zip(list(data_dict.values())[0][1], list(data_dict.values())[0][2], list(data_dict.values())[0][3])]):
+                            outDataset.addLayer(index, patch_augmentation, patch_index, output[i].cpu(), self.dataset)
+                            if outDataset.isDone(index):
+                                outDataset.write(index, self.dataset.getDatasetFromIndex(list(data_dict.keys())[0], index).name.split("/")[-1], outDataset.getOutput(index, self.dataset))
+
+                    batch_iter.set_description(desc())
+                    self.it += 1
 
     def _predict_log(self, data_dict : dict[str, tuple[torch.Tensor, int, int, int]]):
         measures = DistributedObject.getMeasure(self.world_size, self.global_rank, self.local_rank, {"" : self.modelComposite.module}, 1)
@@ -320,6 +321,7 @@ class Predictor(DistributedObject):
                     train_name: str = "name",
                     manual_seed : Union[int, None] = None,
                     gpu_checkpoints: Union[list[str], None] = None,
+                    autocast : bool = False,
                     outsDataset: Union[dict[str, OutDatasetLoader], None] = {"default:Default" : OutDatasetLoader()},
                     images_log: list[str] = []) -> None:
         if os.environ["KONFAI_CONFIG_MODE"] != "Done":
@@ -328,6 +330,7 @@ class Predictor(DistributedObject):
         self.manual_seed = manual_seed
         self.dataset = dataset
         self.combine = combine
+        self.autocast = autocast
 
         self.model = model.getModel(train=False)
         self.it = 0
@@ -384,7 +387,7 @@ class Predictor(DistributedObject):
 
         shutil.copyfile(CONFIG_FILE(), self.predict_path+"Prediction.yml")
 
-        self.model.init(autocast=False, state = State.PREDICTION)
+        self.model.init(self.autocast, State.PREDICTION, self.dataset.getGroupsDest())
         self.model.init_outputsGroup()
         self.model._compute_channels_trace(self.model, self.model.in_channels, None, self.gpu_checkpoints)
         self.modelComposite = ModelComposite(self.model, len(MODEL().split(":")), self.combine)
@@ -402,7 +405,7 @@ class Predictor(DistributedObject):
     def run_process(self, world_size: int, global_rank: int, local_rank: int, dataloaders: list[DataLoader]):
         modelComposite = Network.to(self.modelComposite, local_rank*self.size)
         modelComposite = DDP(modelComposite, static_graph=True) if torch.cuda.is_available() else CPU_Model(modelComposite)
-        with _Predictor(world_size, global_rank, local_rank, self.predict_path, self.images_log, self.outsDataset, modelComposite, *dataloaders) as p:
+        with _Predictor(world_size, global_rank, local_rank, self.autocast, self.predict_path, self.images_log, self.outsDataset, modelComposite, *dataloaders) as p:
             p.run()
 
         

konfai/trainer.py

@@ -17,7 +17,6 @@ from konfai.utils.config import config
 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):
@@ -99,7 +98,7 @@ class _Trainer():
         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)
@@ -118,13 +117,14 @@ class _Trainer():
             self.tb.close()
 
     def run(self) -> None:
-        with tqdm.tqdm(iterable = range(self.epoch, self.epochs), leave=False, total=self.epochs, initial=self.epoch, desc="Progress", disable=self.global_rank != 0) as epoch_tqdm:
+        self.dataloader_training.dataset.load("Train")
+        self.dataloader_validation.dataset.load("Validation")
+        with tqdm.tqdm(iterable = range(self.epoch, self.epochs), leave=False, total=self.epochs, initial=self.epoch, desc="Progress") as epoch_tqdm:
             for self.epoch in epoch_tqdm:
-                self.dataloader_training.dataset.load()
                 self.train()
                 if self.early_stopping.isStopped():
                     break
-                self.dataloader_training.dataset.resetAugmentation()
+                self.dataloader_training.dataset.resetAugmentation("Train")
                 
     def getInput(self, data_dict : dict[str, tuple[torch.Tensor, int, int, int, str, bool]]) -> dict[tuple[str, bool], torch.Tensor]:
         return {(k, v[5][0].item()) : v[0] for k, v in data_dict.items()}
@@ -137,7 +137,8 @@ class _Trainer():
             self.modelEMA.module.setState(NetState.TRAIN)
 
         desc = lambda : "Training : {}".format(description(self.model, self.modelEMA))
-        with tqdm.tqdm(iterable = enumerate(self.dataloader_training), desc = desc(), total=len(self.dataloader_training), leave=False, disable=self.global_rank != 0 and "KONFAI_CLUSTER" not in os.environ) as batch_iter:
+
+        with tqdm.tqdm(iterable = enumerate(self.dataloader_training), desc = desc(), total=len(self.dataloader_training), leave=False, ncols=0) as batch_iter:
             for _, data_dict in batch_iter:
                 with torch.amp.autocast('cuda', enabled=self.autocast):
                     input = self.getInput(data_dict)
@@ -171,8 +172,7 @@ class _Trainer():
 
         desc = lambda : "Validation : {}".format(description(self.model, self.modelEMA))
         data_dict = None
-        self.dataloader_validation.dataset.load()
-        with tqdm.tqdm(iterable = enumerate(self.dataloader_validation), desc = desc(), total=len(self.dataloader_validation), leave=False, disable=self.global_rank != 0 and "KONFAI_CLUSTER" not in os.environ) as batch_iter:
+        with tqdm.tqdm(iterable = enumerate(self.dataloader_validation), desc = desc(), total=len(self.dataloader_validation), leave=False, ncols=0) as batch_iter:
             for _, data_dict in batch_iter:
                 input = self.getInput(data_dict)
                 self.model(input)
@@ -180,7 +180,7 @@ class _Trainer():
                     self.modelEMA.module(input)
 
                 batch_iter.set_description(desc())
-        self.dataloader_validation.dataset.resetAugmentation()
+        self.dataloader_validation.dataset.resetAugmentation("Validation")
         dist.barrier()
         self.model.train()
         self.model.module.setState(NetState.TRAIN)
@@ -360,7 +360,7 @@ class Trainer(DistributedObject):
                     os.makedirs(dir)
 
             for name in sorted(os.listdir(path_checkpoint)):
-                checkpoint = torch.load(path_checkpoint+name, weights_only=False)
+                checkpoint = torch.load(path_checkpoint+name, weights_only=False, map_location='cpu')
                 self.model.load(checkpoint, init=False, ema=False)
 
                 torch.save(self.model, "{}Serialized/{}".format(path_model, name))

konfai/utils/dataset.py

@@ -348,6 +348,10 @@ class Dataset():
         @abstractmethod
         def getNames(self, group: str) -> list[str]:
             pass
+        
+        @abstractmethod
+        def getGroup(self) -> list[str]:
+            pass
 
         @abstractmethod
         def isExist(self, group: str, name: Union[str, None] = None) -> bool:
@@ -458,6 +462,9 @@ class Dataset():
                     names.extend(self.getNames("/".join(groups.split("/")[1:]), h5_group[group]))
             return names
         
+        def getGroup(self):
+            return self.h5.keys()
+        
         def _getDataset(self, groups: str, name: str, h5_group: h5py.Group = None) -> h5py.Dataset:
             if h5_group is None:
                 h5_group = self.h5
@@ -613,7 +620,10 @@ class Dataset():
         
         def getNames(self, group: str) -> list[str]:
             raise NotImplementedError()
-
+        
+        def getGroup(self):
+            raise NotImplementedError()
+        
         def getInfos(self, group: str, name: str) -> tuple[list[int], Attribute]:
             attributes = Attribute()
             if os.path.exists("{}{}{}.{}".format(self.filename, group if group is not None else "", name, self.format)):
@@ -736,7 +746,7 @@ class Dataset():
                 subDirectories.extend(self._getSubDirectories("/".join(groups.split("/")[1:]), subDirectory))
         return subDirectories
 
-    def getNames(self, groups: str, index: Union[list[int], None] = None, subDirectory: str = "") -> list[str]:
+    def getNames(self, groups: str, index: Union[list[int], None] = None) -> list[str]:
         names = []
         if self.is_directory:
             for subDirectory in self._getSubDirectories(groups):
@@ -752,6 +762,21 @@ class Dataset():
                 names = file.getNames(groups)
         return [name for i, name in enumerate(sorted(names)) if index is None or i in index]
     
+    def getGroup(self):
+        if self.is_directory:
+            groups = set()
+            for root, _, files in os.walk(self.filename):
+                for file in files:
+                    path = os.path.relpath(os.path.join(root, file.split(".")[0]), self.filename)
+                    parts = path.split("/")
+                    if len(parts) >= 2:
+                        del parts[-2]
+                    groups.add("/".join(parts))
+        else:
+            with Dataset.File(self.filename, True, self.format) as file:
+                groups = file.getGroup()
+        return list(groups)
+    
     def getInfos(self, groups: str, name: str) -> tuple[list[int], Attribute]:
         if self.is_directory:
             for subDirectory in self._getSubDirectories(groups):

konfai/utils/utils.py

@@ -18,13 +18,15 @@ import random
 from torch.utils.data import DataLoader
 import torch.nn.functional as F
 import sys
+import re
+
 
 def description(model, modelEMA = None, showMemory: bool = True) -> str:
     values_desc = lambda weights, values: " ".join(["{}({:.2f}) : {:.6f}".format(name.split(":")[-1], weight, value) for (name, value), weight in zip(values.items(), weights.values())])
     model_desc = lambda model : "("+" ".join(["{}({:.6f}) : {}".format(name, network.optimizer.param_groups[0]['lr'] if network.optimizer is not None else 0, values_desc(network.measure.getLastWeights(), network.measure.getLastValues())) for name, network in model.module.getNetworks().items() if network.measure is not None])+")"
     result = "Loss {}".format(model_desc(model))
     if modelEMA is not None:
-        result += "Loss EMA {}".format(model_desc(modelEMA))
+        result += " Loss EMA {}".format(model_desc(modelEMA))
     result += " "+gpuInfo()
     if showMemory:
         result +=" | {}".format(memoryInfo())
@@ -237,7 +239,7 @@ class DataLog(Enum):
     AUDIO   = lambda tb, name, layer, it : tb.add_audio(name, _logImageFormat(layer), it)
 
 class Log:
-    def __init__(self, name: str) -> None:
+    def __init__(self, name: str, rank: int) -> None:
         if KONFAI_STATE() == "PREDICTION":
             path = PREDICTIONS_DIRECTORY()
         elif KONFAI_STATE() == "EVALUATION":
@@ -248,11 +250,12 @@ class Log:
         self.verbose = os.environ.get("KONFAI_VERBOSE", "True") == "True"
         self.log_path = os.path.join(path, name)
         os.makedirs(self.log_path, exist_ok=True)
-        
-        self.file = open(os.path.join(self.log_path, "log.txt"), "w", buffering=1) 
+        self.rank = rank
+        self.file = open(os.path.join(self.log_path, "log_{}.txt".format(rank)), "w", buffering=1) 
         self.stdout_bak = sys.stdout
         self.stderr_bak = sys.stderr
-
+        self._buffered_line = ""
+    
     def __enter__(self):
         self.file.__enter__()
         sys.stdout = self
@@ -264,12 +267,26 @@ class Log:
         sys.stdout = self.stdout_bak
         sys.stderr = self.stderr_bak
 
-    def write(self, msg):
+    def write(self, msg: str):
         if not msg:
             return
-        self.file.write(msg)
-        self.file.flush()
-        if self.verbose:
+        
+        
+        ANSI_ESCAPE = re.compile(r'\x1b\[[0-9;]*[a-zA-Z]')
+        CARRIAGE_RETURN = re.compile(r'(?:\r|\x1b\[A).*')
+        msg_clean = ANSI_ESCAPE.sub('', msg)
+        if '\r' in msg_clean or '' in msg:
+            # On garde seulement le contenu après le dernier retour chariot
+            msg_clean = msg_clean.split('\r')[-1].strip()
+            self._buffered_line = msg_clean
+        else:
+            self._buffered_line = msg_clean.strip()
+
+        if self._buffered_line:
+            # Écrit dans le fichier
+            self.file.write(self._buffered_line + "\n")
+            self.file.flush()
+        if self.verbose and (self.rank == 0 or "KONFAI_CLUSTER" in os.environ):
             sys.__stdout__.write(msg)
             sys.__stdout__.flush()
 
@@ -352,7 +369,7 @@ class DistributedObject():
         return result
 
     def __call__(self, rank: Union[int, None] = None) -> None:
-        with Log(self.name):
+        with Log(self.name, rank):
             world_size = len(self.dataloader)
             global_rank, local_rank = setupGPU(world_size, self.port, rank)
             if global_rank is None:
@@ -385,6 +402,7 @@ def setup(parser: argparse.ArgumentParser) -> DistributedObject:
     KONFAI_args.add_argument('-tb', action='store_true', help='Start TensorBoard')
     KONFAI_args.add_argument("-c", "--config", type=str, default="None", help="Configuration file location")
     KONFAI_args.add_argument("-g", "--gpu", type=str, default=os.environ["CUDA_VISIBLE_DEVICES"] if "CUDA_VISIBLE_DEVICES" in os.environ else "", help="List of GPU")
+    KONFAI_args.add_argument("-cpu", "--cpu", type=str, default="1" , help="List of GPU")
     KONFAI_args.add_argument('--num-workers', '--num_workers', default=4, type=int, help='No. of workers per DataLoader & GPU')
     KONFAI_args.add_argument("-models_dir", "--MODELS_DIRECTORY", type=str, default="./Models/", help="Models location")
     KONFAI_args.add_argument("-checkpoints_dir", "--CHECKPOINTS_DIRECTORY", type=str, default="./Checkpoints/", help="Checkpoints location")
@@ -401,6 +419,7 @@ def setup(parser: argparse.ArgumentParser) -> DistributedObject:
     config = vars(args)
 
     os.environ["CUDA_VISIBLE_DEVICES"] = config["gpu"]
+    os.environ["KONFAI_NB_CORES"] = config["cpu"]
     os.environ["KONFAI_MODELS_DIRECTORY"] = config["MODELS_DIRECTORY"]
     os.environ["KONFAI_CHECKPOINTS_DIRECTORY"] = config["CHECKPOINTS_DIRECTORY"]
     os.environ["KONFAI_PREDICTIONS_DIRECTORY"] = config["PREDICTIONS_DIRECTORY"]
@@ -465,6 +484,14 @@ def setupGPU(world_size: int, port: int, rank: Union[int, None] = None) -> tuple
     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)
+    else:
+        if not dist.is_initialized():
+            dist.init_process_group(
+                backend="gloo",
+                init_method=f"tcp://{host_name}:{port}",
+                rank=global_rank,
+                world_size=world_size
+            )
     return global_rank, local_rank
 
 import socket
@@ -524,8 +551,8 @@ SUPPORTED_EXTENSIONS = [
 
 class KonfAIError(Exception):
 
-    def __init__(self, typeError: str, message: list[str]) -> None:
-        super().__init__("\n[{}] {}".format(typeError, message[0])+"\n→\t".join(message[1:]))
+    def __init__(self, typeError: str, messages: list[str]) -> None:
+        super().__init__("\n[{}] {}".format(typeError, messages[0])+("\n" if len(messages) > 0 else "")+"\n→\t".join(messages[1:]))
 
 
 class ConfigError(KonfAIError):
@@ -553,3 +580,13 @@ class AugmentationError(KonfAIError):
 
     def __init__(self, *message) -> None:
         super().__init__("Augmentation", message)
+
+class EvaluatorError(KonfAIError):
+
+    def __init__(self, *message) -> None:
+        super().__init__("Evaluator", message)
+
+class TransformError(KonfAIError):
+
+    def __init__(self, *message) -> None:
+        super().__init__("Transform", message)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: konfai
-Version: 1.1.1
+Version: 1.1.2
 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.1.1.dist-info → konfai-1.1.2.dist-info}/RECORD

@@ -1,13 +1,13 @@
-konfai/__init__.py,sha256=fZM9EjrMcdJZE-jQAsNu3ZcWfa9Ylbly2q4l9STfpBI,795
-konfai/evaluator.py,sha256=TsHQNN4DhP33Sal9-exbOouZAHe7gNEk7RsBaasgkEQ,7373
-konfai/main.py,sha256=OPAUWees1j6NNmggyI7lM2abZctCqk1OsvQuc9FpePY,2515
-konfai/predictor.py,sha256=FGn6_Nt4PCdxNFoIOt8nbBjrAMTwc55uZqy6OFXUjhY,22320
-konfai/trainer.py,sha256=22IKMiPeHNJMGcJdVq9BH-Hsopp6xF4QSYyPabz4LGs,19604
+konfai/__init__.py,sha256=YXG-wpSEXWs6Jt3BDI77V4r89gEUNX-6lxW9btj5VYI,851
+konfai/evaluator.py,sha256=rAhfdRemMjzC3VoaqyQKJR0SBekuLDiLT1nhblH8RQk,8293
+konfai/main.py,sha256=rTTJl-biaX4CkLNxPtqwwsrybXSDxjWlU39TE2ImU5o,2574
+konfai/predictor.py,sha256=e5V7awlIRDE1NkLTR_D6fUuDg93ZFGaGLTDR71KeqM8,22549
+konfai/trainer.py,sha256=NQDzp4hUKYAcDdKmeBcAE9QNFW9KGW2qV-7q_PXeWi8,19509
 konfai/data/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 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/data/data_manager.py,sha256=9VpF4CTTAnqS1Hq0csbTE-XAocRwziFssITg-SZhA4A,29603
+konfai/data/patching.py,sha256=OtGNs99jKQSYmuj8B3MNGcbupKOcX5PUpMCIe0pKnX0,15636
+konfai/data/transform.py,sha256=dTZh2CgfxNitHW-HEkO0jQ9GG26-Wf-YlI-qoI2mqC0,26472
 konfai/metric/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 konfai/metric/measure.py,sha256=K7s15wNJm1_Iaav9y7Oe_UhSnbLUiybhLTVumHZ8ZaY,22001
 konfai/metric/schedulers.py,sha256=UoSr1TW_hrus3DhvOEbDefxCSUGz7lJS_8vbz0GEye8,1370
@@ -24,16 +24,16 @@ konfai/models/segmentation/NestedUNet.py,sha256=6XGizAIc4bDL8vx4AHW8BBFjUvovRYcj
 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=RaTI0Lrvq1V-GIFei-WTUB6wlg4LydZksAyJ8DMk40M,13502
-konfai/network/network.py,sha256=DTROmwwPJZQllJx32GwAixfy1E23F1mtYy1bpF23TjU,46538
+konfai/network/network.py,sha256=SnwQUKFTZZU8zuix5sm0vW8s0G3h6Fa8pHoIcwC984Q,46512
 konfai/utils/ITK.py,sha256=OxTieDNNYHGkn7zxJsAG-6ecRG1VYMvn1dlBbBe1DOs,13955
 konfai/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 konfai/utils/config.py,sha256=OsCUqgNaPX56nD_MpJ2WRpiQ7xxqHonfPYaS9VGtsl8,12413
-konfai/utils/dataset.py,sha256=RNULLVauhYiyeQkpVhOVq4VRwI4KRyoQA2VCmOh8VbE,35525
+konfai/utils/dataset.py,sha256=6ZzevdhJ7e5zlXATAVwSh9O6acKXM7gYNxkMAa5DrmM,36351
 konfai/utils/registration.py,sha256=v1srEBOcgDnHrx0YtsK6bcj0yCMH7wNeaQ3wC7gEvOw,8898
-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,,
+konfai/utils/utils.py,sha256=Laq8bGc5mGKFZlJIkHxa-BrC9uR2F7MTRuL4YFAIxQY,23439
+konfai-1.1.2.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+konfai-1.1.2.dist-info/METADATA,sha256=Usg7hzW1xmlHswHZb3fC2Hgl2V1Jkq43J0T5j5TDEIw,2515
+konfai-1.1.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+konfai-1.1.2.dist-info/entry_points.txt,sha256=fG82HRN5-g39ACSOCtij_I3N6EHxfYnMR0D7TI_8pW8,81
+konfai-1.1.2.dist-info/top_level.txt,sha256=xF470dkIlFoFqTZEOlRehKJr4WU_8OKGXrJqYm9vWKs,7
+konfai-1.1.2.dist-info/RECORD,,