konfai 1.1.0__tar.gz → 1.1.1__tar.gz

{konfai-1.1.0 → konfai-1.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: konfai
-Version: 1.1.0
+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.1.0 → konfai-1.1.1}/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-1.1.0 → konfai-1.1.1}/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()
@@ -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,13 +404,29 @@ 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.validation, float):
-            if self.validation < 1.0 and int(math.floor(len(map)*(1-self.validation))) > 0:
-                train_map, validate_map = map[:int(math.floor(len(map)*self.validation))], map[int(math.floor(len(map)*self.validation)):]
+        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])))
@@ -389,7 +441,17 @@ class Data(ABC):
                 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
+                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):
@@ -399,10 +461,29 @@ class Data(ABC):
                     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,7 +517,7 @@ class DataTrain(Data):
                         subset : Union[TrainSubset, dict[str, TrainSubset]] = TrainSubset(),
                         num_workers : int = 4,
                         batch_size : int = 1,
-                        validation : Union[float, str, list[int], list[str]] = 0.8) -> None:
+                        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):
 

{konfai-1.1.0 → konfai-1.1.1}/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

{konfai-1.1.0 → konfai-1.1.1}/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-1.1.0 → konfai-1.1.1}/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-1.1.0 → konfai-1.1.1}/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-1.1.0 → konfai-1.1.1}/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-1.1.0 → konfai-1.1.1}/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-1.1.0 → konfai-1.1.1}/konfai/trainer.py

@@ -14,7 +14,7 @@ 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
 
 
@@ -53,8 +53,8 @@ class EarlyStopping(EarlyStoppingBase):
             return super().getScore(values)
         for v in self.monitor:
             if v not in values.keys():
-                raise ValueError(
-                    "[EarlyStopping] Metric '{}' specified in `monitor` not found in logged values. "
+                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])
         
@@ -68,7 +68,7 @@ class EarlyStopping(EarlyStoppingBase):
         elif self.mode == "max":
             improvement = current_score - self.best_score
         else:
-            raise ValueError("Mode must be 'min' or 'max'.")
+            raise TrainerError("Mode must be 'min' or 'max'.")
 
         if improvement > self.min_delta:
             self.best_score = current_score
@@ -391,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)

{konfai-1.1.0 → konfai-1.1.1}/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 {}, error {} ".format(param.name, annotation.__name__, e))
+                                        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-1.1.0 → konfai-1.1.1}/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.1.0 → konfai-1.1.1}/konfai.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: konfai
-Version: 1.1.0
+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.1.0 → konfai-1.1.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "konfai"
-version = "1.1.0"
+version = "1.1.1"
 description = "Modular and configurable Deep Learning framework with YAML and PyTorch"
 readme = "README.md"
 requires-python = ">=3.8"

konfai-1.1.1/tests/test_config.py

@@ -0,0 +1,110 @@
+import pytest
+from pathlib import Path
+from konfai.utils.config import config
+
+# ---- Classe enfant pour les objets imbriqués ----
+class SubObject:
+
+    @config("SubObject")
+    def __init__(self, z: float = 0.5):
+        self.z = z
+
+# ---- Classe principale testant tous les types pris en charge ----
+class DummyAllTypes:
+    @config("MainTest")
+    def __init__(
+        self,
+        a: int = 1,
+        b: str = "hello",
+        c: bool = True,
+        d: float = 3.14,
+        e: list[int] = [1, 2, 3],
+        f: list[str] = ["a", "b"],
+        g: list[bool] = [True, False],
+        h: list[float] = [1.0, 2.0],
+        i: dict[str, int] = {"x": 1},
+        j: SubObject = None,
+        l: dict[str, SubObject] = {"A" : SubObject(), "B" : SubObject()}
+    ):
+        self.a = a
+        self.b = b
+        self.c = c
+        self.d = d
+        self.e = e
+        self.f = f
+        self.g = g
+        self.h = h
+        self.i = i
+        self.j = j
+        self.l = l
+
+@pytest.fixture
+def dummy_config_file(tmp_path: Path):
+    yaml_path = tmp_path / "config.yml"
+    yaml_content = """
+MainTest:
+  a: 42
+  b: test
+  c: false
+  d: 2.718
+  e: [10, 20]
+  f: [x, y]
+  g: [true, false, true]
+  h: [0.1, 0.2]
+  i: {"foo": 9}
+  j:
+    z: 9.99
+  l:
+    key1:
+      z: 7.7
+    key2:
+      z: 8.8
+"""
+    yaml_path.write_text(yaml_content)
+    return yaml_path
+
+def test_config_instantiation(monkeypatch):
+    dummy_config_file = "./tests/dummy_data/dummy_config.yml"
+    monkeypatch.setenv("KONFAI_CONFIG_FILE", str(dummy_config_file))
+    monkeypatch.setenv("KONFAI_CONFIG_MODE", "Done")
+
+    obj = DummyAllTypes(config=str(dummy_config_file))
+
+    assert obj.a == 42
+    assert obj.b == "test"
+    assert obj.c is False
+    assert abs(obj.d - 2.718) < 1e-6
+    assert obj.e == [10, 20]
+    assert obj.f == ["x", "y"]
+    assert obj.g == [True, False, True]
+    assert obj.h == [0.1, 0.2]
+    assert obj.i == {"foo": 9}
+    assert isinstance(obj.j, SubObject)
+    assert obj.j.z == 9.99
+    assert isinstance(obj.l, dict)
+    assert set(obj.l.keys()) == {"key1", "key2"}
+    assert obj.l["key1"].z == 7.7
+    assert obj.l["key2"].z == 8.8
+  
+def test_config_create(monkeypatch):
+    dummy_config_file = "./tests/dummy_data/dummy_default_config.yml"
+    monkeypatch.setenv("KONFAI_CONFIG_FILE", str(dummy_config_file))
+    monkeypatch.setenv("KONFAI_CONFIG_MODE", "Done")
+
+    obj = DummyAllTypes(config=str(dummy_config_file))
+
+    assert obj.a == 1
+    assert obj.b == "hello"
+    assert obj.c is True
+    assert abs(obj.d - 3.14) < 1e-6
+    assert obj.e == [1,2,3]
+    assert obj.f == ["a", "b"]
+    assert obj.g == [True, False]
+    assert obj.h == [1, 2]
+    assert obj.i == {}
+    assert isinstance(obj.j, SubObject)
+    assert obj.j.z == 0.5
+    assert isinstance(obj.l, dict)
+    assert set(obj.l.keys()) == {"A", "B"}
+    assert obj.l["A"].z == 0.5
+    assert obj.l["B"].z == 0.5

konfai-1.1.0/tests/test_config.py

@@ -1,18 +0,0 @@
-import pytest
-from konfai.utils.config import config
-
-class Dummy:
-
-    @config("Test")
-    def __init__(self, a: int = 1, b: str = "ok"):
-        self.a = a
-        self.b = b
-
-def test_config_instantiation(monkeypatch):
-    import os
-    os.environ['KONFAI_CONFIG_FILE'] = "./tests/dummy_data/dummy_config.yml"
-    os.environ['KONFAI_CONFIG_PATH'] = "Test"
-
-    dummy = Dummy()
-    assert dummy.a == 42
-    assert dummy.b == "hello"