konfai 1.1.5__py3-none-any.whl → 1.1.6__py3-none-any.whl

konfai/data/augmentation.py

@@ -57,7 +57,7 @@ class DataAugmentationsList():
 
     def load(self, key: str, datasets: list[Dataset]):
         for augmentation, prob in self.dataAugmentationsLoader.items():
-            module, name = _getModule(augmentation, "data.augmentation")
+            module, name = _getModule(augmentation, "konfai.data.augmentation")
             dataAugmentation: DataAugmentation = config("{}.Dataset.augmentations.{}.dataAugmentations.{}".format(KONFAI_ROOT(), key, augmentation))(getattr(importlib.import_module(module), name))(config = None)
             dataAugmentation.load(prob.prob)
             dataAugmentation.setDatasets(datasets)

konfai/data/data_manager.py

@@ -184,7 +184,7 @@ class DatasetIter(data.Dataset):
         data = {}
         x, a, p = self.map[index]
         if x not in self._index_cache:
-            if x not in self._index_cache and len(self._index_cache) >= self.buffer_size and not self.use_cache:
+            if len(self._index_cache) >= self.buffer_size and not self.use_cache:
                 self._unloadData(self._index_cache[0])
             self._loadData(x)
 

konfai/data/transform.py

@@ -36,7 +36,7 @@ class TransformLoader:
         pass
     
     def getTransform(self, classpath : str, DL_args : str) -> Transform:
-        module, name = _getModule(classpath, "data.transform")
+        module, name = _getModule(classpath, "konfai.data.transform")
         return config("{}.{}".format(DL_args, classpath))(getattr(importlib.import_module(module), name))(config = None)
 
 class Clip(Transform):
@@ -213,7 +213,7 @@ class Resample(Transform, ABC):
 
 class ResampleToResolution(Resample):
 
-    def __init__(self, spacing : list[Union[float, None]] = [1., 1., 1.]) -> None:
+    def __init__(self, spacing : list[float] = [1., 1., 1.]) -> None:
         self.spacing = torch.tensor([0 if s < 0 else s for s in spacing])
 
     def transformShape(self, shape: list[int], cache_attribute: Attribute) -> list[int]:
@@ -244,34 +244,35 @@ class ResampleToResolution(Resample):
         cache_attribute["Size"] = np.asarray(size)
         return self._resample(input, size)
 
-class ResampleToSize(Resample):
+class ResampleToShape(Resample):
 
-    def __init__(self, size : list[int] = [100,512,512]) -> None:
-        self.size = size
+    def __init__(self, shape : list[float] = [100,256,256]) -> None:
+        self.shape = torch.tensor([0 if s < 0 else s for s in shape])
 
     def transformShape(self, shape: list[int], cache_attribute: Attribute) -> list[int]:
         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):
+        if len(shape) != len(self.shape):
             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
+        new_shape = self.shape
+        for i, s in enumerate(self.shape):
+            if s == 0:
+                new_shape[i] = shape[i]
+        print(new_shape)
+        return new_shape
     
     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]
+        shape = self.shape
+        image_shape =  torch.tensor([int(x) for x in torch.tensor(input.shape[1:])])
+        for i, s in enumerate(self.shape):
+            if s == 0:
+                shape[i] = image_shape[i]
         if "Spacing" in cache_attribute:
-            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)
+            cache_attribute["Spacing"] = torch.flip(image_shape/shape*torch.flip(cache_attribute.get_tensor("Spacing"), dims=[0]), dims=[0])
+        cache_attribute["Size"] = image_shape
+        cache_attribute["Size"] = shape
+        return self._resample(input, shape)
 
 class ResampleTransform(Transform):
 

konfai/evaluator.py

@@ -27,7 +27,7 @@ class CriterionsLoader():
     def getCriterions(self, output_group : str, target_group : str) -> dict[torch.nn.Module, CriterionsAttr]:
         criterions = {}
         for module_classpath, criterionsAttr in self.criterionsLoader.items():
-            module, name = _getModule(module_classpath, "metric.measure")
+            module, name = _getModule(module_classpath, "konfai.metric.measure")
             criterions[config("{}.metrics.{}.targetsCriterions.{}.criterionsLoader.{}".format(KONFAI_ROOT(), output_group, target_group, module_classpath))(getattr(importlib.import_module(module), name))(config = None)] = criterionsAttr
         return criterions
 

konfai/main.py

@@ -9,8 +9,6 @@ import sys
 sys.path.insert(0, os.getcwd())
 
 def main():
-    import tracemalloc
-
     parser = argparse.ArgumentParser(description="KonfAI", formatter_class=argparse.ArgumentDefaultsHelpFormatter)
     try:
         with setup(parser) as distributedObject:

konfai/metric/measure.py

@@ -250,7 +250,7 @@ class PerceptualLoss(Criterion):
         def getLoss(self) -> dict[torch.nn.Module, float]:
             result: dict[torch.nn.Module, float] = {}
             for loss, l in self.losses.items():
-                module, name = _getModule(loss, "metric.measure")
+                module, name = _getModule(loss, "konfai.metric.measure")
                 result[config(self.DL_args)(getattr(importlib.import_module(module), name))(config=None)] = l   
             return result
         
@@ -458,13 +458,11 @@ class FID(Criterion):
         return features
 
     def calculate_fid(real_features: np.ndarray, generated_features: np.ndarray) -> float:
-        # Calculate mean and covariance statistics
         mu1 = np.mean(real_features, axis=0)
         sigma1 = np.cov(real_features, rowvar=False)
         mu2 = np.mean(generated_features, axis=0)
         sigma2 = np.cov(generated_features, rowvar=False)
 
-        # Calculate FID score
         diff = mu1 - mu2
         covmean, _ = linalg.sqrtm(sigma1.dot(sigma2), disp=False)
         if np.iscomplexobj(covmean):
@@ -480,7 +478,6 @@ class FID(Criterion):
         generated_features = FID.get_features(generated_images, self.inception_model)
 
         return FID.calculate_fid(real_features, generated_features)
-        
 
 class MutualInformationLoss(torch.nn.Module):
     def __init__(self, num_bins: int = 23, sigma_ratio: float = 0.5, smooth_nr: float = 1e-7, smooth_dr: float = 1e-7) -> None:
@@ -498,7 +495,6 @@ class MutualInformationLoss(torch.nn.Module):
         target_weight, target_probability = self.parzen_windowing_gaussian(target)
         return pred_weight, pred_probability, target_weight, target_probability
 
-
     def parzen_windowing_gaussian(self, img: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:
         img = torch.clamp(img, 0, 1)
         img = img.reshape(img.shape[0], -1, 1)  # (batch, num_sample, 1)

konfai/metric/schedulers.py

@@ -2,6 +2,7 @@ import torch
 import numpy as np
 from abc import abstractmethod
 from konfai.utils.config import config
+from functools import partial
 
 class Scheduler():
 
@@ -46,4 +47,12 @@ class CosineAnnealing(Scheduler):
         self.T_max = T_max
 
     def get_value(self):
-        return self.eta_min + (self.baseValue - self.eta_min) *(1 + np.cos(self.it * torch.pi / self.T_max)) / 2
+        return self.eta_min + (self.baseValue - self.eta_min) *(1 + np.cos(self.it * torch.pi / self.T_max)) / 2
+
+class Warmup(torch.optim.lr_scheduler.LambdaLR):
+    
+    def warmup(warmup_steps: int, step: int) -> float:
+        return min(1.0, step / warmup_steps)
+
+    def __init__(self, optimizer: torch.optim.Optimizer, warmup_steps: int = 10, last_epoch=-1, verbose="deprecated"):
+        super().__init__(optimizer, partial(Warmup.warmup, warmup_steps), last_epoch, verbose)

konfai/models/segmentation/NestedUNet.py

@@ -3,23 +3,23 @@ from typing import Union
 import torch
 from konfai.data.patching import ModelPatch
 
-     
-class NestedUNetBlock(network.ModuleArgsDict):
+class NestedUNet(network.Network):
 
-    def __init__(self, channels: list[int], nb_conv_per_stage: int, blockConfig: blocks.BlockConfig, downSampleMode: blocks.DownSampleMode, upSampleMode: blocks.UpSampleMode, attention : bool, block: type, dim: int, i : int = 0) -> None:
-        super().__init__()
-        if i > 0:
-            self.add_module(downSampleMode.name, blocks.downSample(in_channels=channels[0], out_channels=channels[1], downSampleMode=downSampleMode, dim=dim))
-        
-        self.add_module("X_{}_{}".format(i, 0), block(in_channels=channels[1 if downSampleMode == blocks.DownSampleMode.CONV_STRIDE and i > 0 else 0], out_channels=channels[1], blockConfigs=[blockConfig]*nb_conv_per_stage, dim=dim), out_branch=["X_{}_{}".format(i, 0)])
-        if len(channels) > 2:
-            self.add_module("UNetBlock_{}".format(i+1), NestedUNetBlock(channels[1:], nb_conv_per_stage, blockConfig, downSampleMode, upSampleMode, attention, block, dim, i+1), in_branch=["X_{}_{}".format(i, 0)], out_branch=["X_{}_{}".format(i+1, j) for j in range(len(channels)-2)])
-            for j in range(len(channels)-2):
-                self.add_module("X_{}_{}_{}".format(i, j+1, upSampleMode.name), blocks.upSample(in_channels=channels[2], out_channels=channels[1], upSampleMode=upSampleMode, dim=dim), in_branch=["X_{}_{}".format(i+1, j)], out_branch=["X_{}_{}".format(i+1, j)])
-                self.add_module("SkipConnection_{}_{}".format(i, j+1), blocks.Concat(), in_branch=["X_{}_{}".format(i+1, j)]+["X_{}_{}".format(i, r) for r in range(j+1)], out_branch=["X_{}_{}".format(i, j+1)])
-                self.add_module("X_{}_{}".format(i, j+1), block(in_channels=(channels[1]*(j+1)+channels[2]) if upSampleMode != blocks.UpSampleMode.CONV_TRANSPOSE else channels[1]*(j+2), out_channels=channels[1], blockConfigs=[blockConfig]*nb_conv_per_stage, dim=dim), in_branch=["X_{}_{}".format(i, j+1)], out_branch=["X_{}_{}".format(i, j+1)])
+    class NestedUNetBlock(network.ModuleArgsDict):
+
+        def __init__(self, channels: list[int], nb_conv_per_stage: int, blockConfig: blocks.BlockConfig, downSampleMode: blocks.DownSampleMode, upSampleMode: blocks.UpSampleMode, attention : bool, block: type, dim: int, i : int = 0) -> None:
+            super().__init__()
+            if i > 0:
+                self.add_module(downSampleMode.name, blocks.downSample(in_channels=channels[0], out_channels=channels[1], downSampleMode=downSampleMode, dim=dim))
+            
+            self.add_module("X_{}_{}".format(i, 0), block(in_channels=channels[1 if downSampleMode == blocks.DownSampleMode.CONV_STRIDE and i > 0 else 0], out_channels=channels[1], blockConfigs=[blockConfig]*nb_conv_per_stage, dim=dim), out_branch=["X_{}_{}".format(i, 0)])
+            if len(channels) > 2:
+                self.add_module("UNetBlock_{}".format(i+1), NestedUNet.NestedUNetBlock(channels[1:], nb_conv_per_stage, blockConfig, downSampleMode, upSampleMode, attention, block, dim, i+1), in_branch=["X_{}_{}".format(i, 0)], out_branch=["X_{}_{}".format(i+1, j) for j in range(len(channels)-2)])
+                for j in range(len(channels)-2):
+                    self.add_module("X_{}_{}_{}".format(i, j+1, upSampleMode.name), blocks.upSample(in_channels=channels[2], out_channels=channels[1], upSampleMode=upSampleMode, dim=dim), in_branch=["X_{}_{}".format(i+1, j)], out_branch=["X_{}_{}".format(i+1, j)])
+                    self.add_module("SkipConnection_{}_{}".format(i, j+1), blocks.Concat(), in_branch=["X_{}_{}".format(i+1, j)]+["X_{}_{}".format(i, r) for r in range(j+1)], out_branch=["X_{}_{}".format(i, j+1)])
+                    self.add_module("X_{}_{}".format(i, j+1), block(in_channels=(channels[1]*(j+1)+channels[2]) if upSampleMode != blocks.UpSampleMode.CONV_TRANSPOSE else channels[1]*(j+2), out_channels=channels[1], blockConfigs=[blockConfig]*nb_conv_per_stage, dim=dim), in_branch=["X_{}_{}".format(i, j+1)], out_branch=["X_{}_{}".format(i, j+1)])
 
-class NestedUNet(network.Network):
 
     class NestedUNetHead(network.ModuleArgsDict):
 
@@ -49,58 +49,55 @@ class NestedUNet(network.Network):
                     activation: str = "Softmax") -> None:
         super().__init__(in_channels = channels[0], optimizer = optimizer, schedulers = schedulers, outputsCriterions = outputsCriterions, patch=patch, dim = dim)
                 
-        self.add_module("UNetBlock_0", NestedUNetBlock(channels, nb_conv_per_stage, blockConfig, downSampleMode=blocks.DownSampleMode._member_map_[downSampleMode], upSampleMode=blocks.UpSampleMode._member_map_[upSampleMode], attention=attention, block = blocks.ConvBlock if blockType == "Conv" else blocks.ResBlock, dim=dim), out_branch=["X_0_{}".format(j+1) for j in range(len(channels)-2)])    
+        self.add_module("UNetBlock_0", NestedUNet.NestedUNetBlock(channels, nb_conv_per_stage, blockConfig, downSampleMode=blocks.DownSampleMode._member_map_[downSampleMode], upSampleMode=blocks.UpSampleMode._member_map_[upSampleMode], attention=attention, block = blocks.ConvBlock if blockType == "Conv" else blocks.ResBlock, dim=dim), out_branch=["X_0_{}".format(j+1) for j in range(len(channels)-2)])    
         for j in range(len(channels)-2):
             self.add_module("Head_{}".format(j), NestedUNet.NestedUNetHead(in_channels=channels[1], nb_class=nb_class, activation=activation, dim=dim), in_branch=["X_0_{}".format(j+1)], out_branch=[-1])
 
 
+class UNetpp(network.Network):
 
-        
-class ResNetEncoderLayer(network.ModuleArgsDict):
-
-    def __init__(self, in_channel: int, out_channel: int, nb_block: int, dim: int, downSampleMode : blocks.DownSampleMode):
-        super().__init__()
-        for i in range(nb_block):
-            if downSampleMode == blocks.DownSampleMode.MAXPOOL and i == 0:
-                self.add_module("DownSample", blocks.getTorchModule("MaxPool", dim)(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False))
-            self.add_module("ResBlock_{}".format(i), blocks.ResBlock(in_channel, out_channel, [blocks.BlockConfig(3, 2 if downSampleMode == blocks.DownSampleMode.CONV_STRIDE and i == 0 else 1, 1, False, "ReLU;True", blocks.NormMode.BATCH), blocks.BlockConfig(3, 1, 1, False, None, blocks.NormMode.BATCH)], dim=dim))
-            in_channel = out_channel
-        
-def resNetEncoder(channels: list[int], layers: list[int], dim: int) -> list[torch.nn.Module]:
-    modules = []
-    modules.append(blocks.ConvBlock(channels[0], channels[1], [blocks.BlockConfig(7, 2, 3, False, "ReLU", blocks.NormMode.BATCH)], dim=dim))
-    for i, (in_channel, out_channel, layer) in enumerate(zip(channels[1:], channels[2:], layers)):
-        modules.append(ResNetEncoderLayer(in_channel, out_channel, layer, dim, blocks.DownSampleMode.MAXPOOL if i==0 else blocks.DownSampleMode.CONV_STRIDE))
-    return modules
-
-class NestedUNetBlock(network.ModuleArgsDict):
+    class ResNetEncoderLayer(network.ModuleArgsDict):
 
-    def __init__(self, encoder_channels: list[int], decoder_channels: list[int], encoders: list[torch.nn.Module], upSampleMode: blocks.UpSampleMode, dim: int, i : int = 0) -> None:
-        super().__init__()
-        self.add_module("X_{}_{}".format(i, 0), encoders[0], out_branch=["X_{}_{}".format(i, 0)])
-        if len(encoder_channels) > 2:
-            self.add_module("UNetBlock_{}".format(i+1), NestedUNetBlock(encoder_channels[1:], decoder_channels[1:], encoders[1:], upSampleMode, dim, i+1), in_branch=["X_{}_{}".format(i, 0)], out_branch=["X_{}_{}".format(i+1, j) for j in range(len(encoder_channels)-2)])
-            for j in range(len(encoder_channels)-2):
-                self.add_module("X_{}_{}_{}".format(i, j+1, upSampleMode.name), blocks.upSample(in_channels=encoder_channels[2], out_channels=decoder_channels[2] if j == len(encoder_channels)-3 else encoder_channels[1], upSampleMode=upSampleMode, dim=dim), in_branch=["X_{}_{}".format(i+1, j)], out_branch=["X_{}_{}".format(i+1, j)])
-                self.add_module("SkipConnection_{}_{}".format(i, j+1), blocks.Concat(), in_branch=["X_{}_{}".format(i+1, j)]+["X_{}_{}".format(i, r) for r in range(j+1)], out_branch=["X_{}_{}".format(i, j+1)])
-                self.add_module("X_{}_{}".format(i, j+1), blocks.ConvBlock(in_channels=encoder_channels[1]*j+((encoder_channels[1]+encoder_channels[2]) if upSampleMode != blocks.UpSampleMode.CONV_TRANSPOSE else (decoder_channels[1]+decoder_channels[2] if j == len(encoder_channels)-3 else encoder_channels[1]+encoder_channels[1])), out_channels=decoder_channels[2] if j == len(encoder_channels)-3 else encoder_channels[1], blockConfigs=[blocks.BlockConfig(3,1,1,False, "ReLU;True", blocks.NormMode.BATCH)]*2, dim=dim), in_branch=["X_{}_{}".format(i, j+1)], out_branch=["X_{}_{}".format(i, j+1)])
+        def __init__(self, in_channel: int, out_channel: int, nb_block: int, dim: int, downSampleMode : blocks.DownSampleMode):
+            super().__init__()
+            for i in range(nb_block):
+                if downSampleMode == blocks.DownSampleMode.MAXPOOL and i == 0:
+                    self.add_module("DownSample", blocks.getTorchModule("MaxPool", dim)(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False))
+                self.add_module("ResBlock_{}".format(i), blocks.ResBlock(in_channel, out_channel, [blocks.BlockConfig(3, 2 if downSampleMode == blocks.DownSampleMode.CONV_STRIDE and i == 0 else 1, 1, False, "ReLU;True", blocks.NormMode.BATCH), blocks.BlockConfig(3, 1, 1, False, None, blocks.NormMode.BATCH)], dim=dim))
+                in_channel = out_channel
+            
+    def resNetEncoder(channels: list[int], layers: list[int], dim: int) -> list[torch.nn.Module]:
+        modules = []
+        modules.append(blocks.ConvBlock(channels[0], channels[1], [blocks.BlockConfig(7, 2, 3, False, "ReLU", blocks.NormMode.BATCH)], dim=dim))
+        for i, (in_channel, out_channel, layer) in enumerate(zip(channels[1:], channels[2:], layers)):
+            modules.append(UNetpp.ResNetEncoderLayer(in_channel, out_channel, layer, dim, blocks.DownSampleMode.MAXPOOL if i==0 else blocks.DownSampleMode.CONV_STRIDE))
+        return modules
 
-class NestedUNetHead(network.ModuleArgsDict):
+    class UNetPPBlock(network.ModuleArgsDict):
 
-    def __init__(self, in_channels: int, out_channels: int, nb_class: int, dim: int) -> None:
-        super().__init__()
-        self.add_module("Upsample", blocks.upSample(in_channels=in_channels, out_channels=out_channels, upSampleMode=blocks.UpSampleMode.UPSAMPLE_BILINEAR, dim=dim))
-        self.add_module("ConvBlock", blocks.ConvBlock(in_channels=in_channels, out_channels=out_channels, blockConfigs=[blocks.BlockConfig(3,1,1,False, "ReLU;True", blocks.NormMode.BATCH)]*2, dim=dim))
-        self.add_module("Conv", blocks.getTorchModule("Conv", dim)(in_channels = out_channels, out_channels = nb_class, kernel_size = 3, stride = 1, padding = 1))
-        if nb_class > 1:
-            self.add_module("Softmax", torch.nn.Softmax(dim=1))
-            self.add_module("Argmax", blocks.ArgMax(dim=1))
-        else:
-            self.add_module("Tanh", torch.nn.Tanh())
-        
-class UNetpp(network.Network):
+        def __init__(self, encoder_channels: list[int], decoder_channels: list[int], encoders: list[torch.nn.Module], upSampleMode: blocks.UpSampleMode, dim: int, i : int = 0) -> None:
+            super().__init__()
+            self.add_module("X_{}_{}".format(i, 0), encoders[0], out_branch=["X_{}_{}".format(i, 0)])
+            if len(encoder_channels) > 2:
+                self.add_module("UNetBlock_{}".format(i+1), UNetpp.UNetPPBlock(encoder_channels[1:], decoder_channels[1:], encoders[1:], upSampleMode, dim, i+1), in_branch=["X_{}_{}".format(i, 0)], out_branch=["X_{}_{}".format(i+1, j) for j in range(len(encoder_channels)-2)])
+                for j in range(len(encoder_channels)-2):
+                    self.add_module("X_{}_{}_{}".format(i, j+1, upSampleMode.name), blocks.upSample(in_channels=encoder_channels[2], out_channels=decoder_channels[2] if j == len(encoder_channels)-3 else encoder_channels[1], upSampleMode=upSampleMode, dim=dim), in_branch=["X_{}_{}".format(i+1, j)], out_branch=["X_{}_{}".format(i+1, j)])
+                    self.add_module("SkipConnection_{}_{}".format(i, j+1), blocks.Concat(), in_branch=["X_{}_{}".format(i+1, j)]+["X_{}_{}".format(i, r) for r in range(j+1)], out_branch=["X_{}_{}".format(i, j+1)])
+                    self.add_module("X_{}_{}".format(i, j+1), blocks.ConvBlock(in_channels=encoder_channels[1]*j+((encoder_channels[1]+encoder_channels[2]) if upSampleMode != blocks.UpSampleMode.CONV_TRANSPOSE else (decoder_channels[1]+decoder_channels[2] if j == len(encoder_channels)-3 else encoder_channels[1]+encoder_channels[1])), out_channels=decoder_channels[2] if j == len(encoder_channels)-3 else encoder_channels[1], blockConfigs=[blocks.BlockConfig(3,1,1,False, "ReLU;True", blocks.NormMode.BATCH)]*2, dim=dim), in_branch=["X_{}_{}".format(i, j+1)], out_branch=["X_{}_{}".format(i, j+1)])
 
+    class UNetPPHead(network.ModuleArgsDict):
 
+        def __init__(self, in_channels: int, out_channels: int, nb_class: int, dim: int) -> None:
+            super().__init__()
+            self.add_module("Upsample", blocks.upSample(in_channels=in_channels, out_channels=out_channels, upSampleMode=blocks.UpSampleMode.UPSAMPLE_BILINEAR, dim=dim))
+            self.add_module("ConvBlock", blocks.ConvBlock(in_channels=in_channels, out_channels=out_channels, blockConfigs=[blocks.BlockConfig(3,1,1,False, "ReLU;True", blocks.NormMode.BATCH)]*2, dim=dim))
+            self.add_module("Conv", blocks.getTorchModule("Conv", dim)(in_channels = out_channels, out_channels = nb_class, kernel_size = 3, stride = 1, padding = 1))
+            if nb_class > 1:
+                self.add_module("Softmax", torch.nn.Softmax(dim=1))
+                self.add_module("Argmax", blocks.ArgMax(dim=1))
+            else:
+                self.add_module("Tanh", torch.nn.Tanh())
+                
     def __init__(   self,
                     optimizer : network.OptimizerLoader = network.OptimizerLoader(),
                     schedulers : network.LRSchedulersLoader = network.LRSchedulersLoader(),
@@ -111,5 +108,6 @@ class UNetpp(network.Network):
                     layers: list[int] = [3,4,6,3],
                     dim : int = 2) -> None:
         super().__init__(in_channels = encoder_channels[0], optimizer = optimizer, schedulers = schedulers, outputsCriterions = outputsCriterions, patch=patch, dim = dim)
-        self.add_module("Block_0", NestedUNetBlock(encoder_channels, decoder_channels[::-1], resNetEncoder(encoder_channels, layers, dim), blocks.UpSampleMode.UPSAMPLE_BILINEAR, dim=dim), out_branch=["X_0_{}".format(j+1) for j in range(len(encoder_channels)-2)])    
-        self.add_module("Head", NestedUNetHead(in_channels=decoder_channels[-3], out_channels=decoder_channels[-2], nb_class=decoder_channels[-1], dim=dim), in_branch=["X_0_{}".format(len(encoder_channels)-2)], out_branch=[-1])
+        self.add_module("Block_0", UNetpp.UNetPPBlock(encoder_channels, decoder_channels[::-1], UNetpp.resNetEncoder(encoder_channels, layers, dim), blocks.UpSampleMode.UPSAMPLE_BILINEAR, dim=dim), out_branch=["X_0_{}".format(j+1) for j in range(len(encoder_channels)-2)])    
+        self.add_module("Head", UNetpp.UNetPPHead(in_channels=decoder_channels[-3], out_channels=decoder_channels[-2], nb_class=decoder_channels[-1], dim=dim), in_branch=["X_0_{}".format(len(encoder_channels)-2)], out_branch=[-1])
+

konfai/models/segmentation/UNet.py

@@ -12,7 +12,6 @@ class UNetHead(network.ModuleArgsDict):
         self.add_module("Conv", blocks.getTorchModule("Conv", dim)(in_channels = in_channels, out_channels = nb_class, kernel_size = 1, stride = 1, padding = 0))
         self.add_module("Softmax", torch.nn.Softmax(dim=1))
         self.add_module("Argmax", blocks.ArgMax(dim=1))
-        
 
 class UNetBlock(network.ModuleArgsDict):
 

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, MeasureError
+from konfai.utils.utils import State, _getModule, getDevice, getGPUMemory, MeasureError, TrainerError
 from konfai.data.patching import Accumulator, ModelPatch
 
 class NetState(Enum):
@@ -55,9 +55,16 @@ class LRSchedulersLoader():
 
     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:
-                schedulers[config("Trainer.Model.{}.Schedulers.{}".format(key, name))(getattr(importlib.import_module('torch.optim.lr_scheduler'), name))(optimizer, config = None)] = step.nb_step
+        for nameTmp, step in self.params.items():
+            if nameTmp:
+                ok = False
+                for m in ["torch.optim.lr_scheduler", "konfai.metric.schedulers"]:
+                    module, name = _getModule(nameTmp, m)
+                    if hasattr(importlib.import_module(module), name):
+                        schedulers[config("{}.Model.{}.Schedulers.{}".format(KONFAI_ROOT(), key, name))(getattr(importlib.import_module(module), name))(optimizer, config = None)] = step.nb_step        
+                        ok = True
+                if not ok:
+                    raise TrainerError("Unknown scheduler {}, tried importing from: 'torch.optim.lr_scheduler' and 'konfai.metric.schedulers', but no valid match was found. Check your YAML config or scheduler name spelling.".format(nameTmp))
         return schedulers
 
 class SchedulersLoader():
@@ -95,7 +102,7 @@ class CriterionsLoader():
     def getCriterions(self, model_classname : str, output_group : str, target_group : str) -> dict[torch.nn.Module, CriterionsAttr]:
         criterions = {}
         for module_classpath, criterionsAttr in self.criterionsLoader.items():
-            module, name = _getModule(module_classpath, "metric.measure")
+            module, name = _getModule(module_classpath, "konfai.metric.measure")
             criterionsAttr.isTorchCriterion = module.startswith("torch")
             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
@@ -561,6 +568,7 @@ class Network(ModuleArgsDict, ABC):
         self.init_gain  = init_gain
         self.dim = dim
         self._it = 0
+        self._nb_lr_update = 0
         self.outputsGroup : list[OutputsGroup]= []
 
     @_function_network()
@@ -655,9 +663,15 @@ class Network(ModuleArgsDict, ABC):
                 else:
                     model_state_dict[alias] = model_state_dict_tmp[alias]
             self.load_state_dict(model_state_dict)
-            
-        if "{}_optimizer_state_dict".format(name) in state_dict and self.optimizer:
-            self.optimizer.load_state_dict(state_dict['{}_optimizer_state_dict'.format(name)])
+        if "{}_optimizer_state_dict".format(self.getName()) in state_dict and self.optimizer:
+            self.optimizer.load_state_dict(state_dict['{}_optimizer_state_dict'.format(self.getName())])
+        if "{}_it".format(self.getName()) in state_dict:
+            self._it = int(state_dict["{}_it".format(self.getName())])
+        if "{}_nb_lr_update".format(self.getName()) in state_dict:
+            self._nb_lr_update = int(state_dict["{}_nb_lr_update".format(self.getName())])
+        if self.schedulers:
+            for scheduler in self.schedulers:
+                scheduler.last_epoch = self._nb_lr_update
         self.initialized()
 
     def _compute_channels_trace(self, module : ModuleArgsDict, in_channels : int, gradient_checkpoints: Union[list[str], None], gpu_checkpoints: Union[list[str], None], name: Union[str, None] = None, in_is_channel = True, out_channels : Union[int, None] = None, out_is_channel = True) -> tuple[int, bool, int, bool]:
@@ -886,11 +900,12 @@ class Network(ModuleArgsDict, ABC):
 
     @_function_network()
     def update_lr(self):
+        self._nb_lr_update+=1 
         step = 0
         scheduler = None
         if self.schedulers:
             for scheduler, value in self.schedulers.items():
-                if value is None or (self._it >= step  and self._it < step+value):
+                if value is None or (self._nb_lr_update >= step and self._nb_lr_update < step+value):
                     break
                 step += value
         if scheduler:
@@ -898,7 +913,7 @@ class Network(ModuleArgsDict, ABC):
                 if self.measure:
                     scheduler.step(sum(self.measure.getLastValues(0).values()))
             else:
-                scheduler.step()     
+                scheduler.step()
 
     @_function_network()
     def getNetworks(self) -> Self:
@@ -916,6 +931,12 @@ class Network(ModuleArgsDict, ABC):
                     v = Network.to(v, int(os.environ["device"]))
                 else:
                     v = v.to(getDevice(int(os.environ["device"])))
+        if isinstance(module, Network):
+            if module.optimizer is not None:
+                for state in module.optimizer.state.values():
+                    for k, v in state.items():
+                        if isinstance(v, torch.Tensor):
+                            state[k] = v.to(getDevice(int(os.environ["device"])))
         return module
                 
     def getName(self) -> str:
@@ -944,7 +965,7 @@ class ModelLoader():
 
     @config("Model")
     def __init__(self, classpath : str = "default:segmentation.UNet.UNet") -> None:
-        self.module, self.name = _getModule(classpath, "models")
+        self.module, self.name = _getModule(classpath, "konfai.models")
         
     def getModel(self, train : bool = True, DL_args: Union[str, None] = None, DL_without=["optimizer", "schedulers", "nb_batch_per_step", "init_type", "init_gain"]) -> Network:
         if not DL_args:

konfai/predictor.py

@@ -57,7 +57,7 @@ class OutDataset(Dataset, NeedDevice, ABC):
                     transform_type.append(transform)
 
         if self._patchCombine is not None:
-            module, name = _getModule(self._patchCombine, "data.patching")
+            module, name = _getModule(self._patchCombine, "konfai.data.patching")
             self.patchCombine = getattr(importlib.import_module(module), name)(config = None, DL_args =  "{}.outsDataset.{}.OutDataset".format(KONFAI_ROOT(), name_layer))
     
     def setPatchConfig(self, patchSize: Union[list[int], None], overlap: Union[int, None], nb_data_augmentation: int) -> None:
@@ -96,17 +96,21 @@ class Reduction():
     def __init__(self):
         pass
 
-class ReductionMean():
+class Mean(Reduction):
 
     def __init__(self):
         pass
-    
-class ReductionMedian():
+
+    def __call__(self, result: torch.Tensor) -> torch.Tensor:
+        return torch.mean(result.float(), dim=0)
+        
+class Median(Reduction):
 
     def __init__(self):
         pass
     
-    
+    def __call__(self, result: torch.Tensor) -> torch.Tensor:
+        return torch.median(result.float(), dim=0).values
 
 class OutSameAsGroupDataset(OutDataset):
 
@@ -114,7 +118,7 @@ class OutSameAsGroupDataset(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, 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.reduction = reduction
+        self.reduction_classpath = reduction
         self.inverse_transform = inverse_transform
 
     def addLayer(self, index_dataset: int, index_augmentation: int, index_patch: int, layer: torch.Tensor, dataset: DatasetIter):
@@ -142,7 +146,9 @@ class OutSameAsGroupDataset(OutDataset):
 
     def load(self, name_layer: str, datasets: list[Dataset], groups: dict[str, str]):
         super().load(name_layer, datasets, groups)
-
+        module, name = _getModule(self.reduction_classpath, "konfai.predictor")
+        self.reduction = config("{}.outsDataset.{}.OutDataset.{}".format(KONFAI_ROOT(), name_layer, self.reduction_classpath))(getattr(importlib.import_module(module), name))(config = None)
+       
         if self.group_src not in groups.keys():
             raise PredictorError(
                 f"Source group '{self.group_src}' not found. Available groups: {list(groups.keys())}."
@@ -179,14 +185,8 @@ class OutSameAsGroupDataset(OutDataset):
         result = torch.cat([self._getOutput(index, index_augmentation, dataset).unsqueeze(0) for index_augmentation in self.output_layer_accumulator[index].keys()], dim=0)
         name = self.names[index]
         self.output_layer_accumulator.pop(index)
-        dtype = result.dtype
+        result = self.reduction(result.float()).to(result.dtype)
 
-        if self.reduction == "mean":
-            result = torch.mean(result.float(), dim=0).to(dtype)
-        elif self.reduction == "median":
-            result, _ = torch.median(result.float(), dim=0)
-        else:
-            raise NameError("Reduction method does not exist (mean, median)")
         for transform in self.final_transforms:
             result = transform(name, result, self.attributes[index][0][0])
         return result
@@ -307,9 +307,9 @@ class _Predictor():
 
 class ModelComposite(Network):
 
-    def __init__(self, model: Network, nb_models: int, method: str):
+    def __init__(self, model: Network, nb_models: int, combine: Reduction):
         super().__init__(model.in_channels, model.optimizer, model.schedulers, model.outputsCriterionsLoader, model.patch, model.nb_batch_per_step, model.init_type, model.init_gain, model.dim)
-        self.method = method
+        self.combine = combine
         for i in range(nb_models):
             self.add_module("Model_{}".format(i), copy.deepcopy(model), in_branch=[0], out_branch=["output_{}".format(i)])
 
@@ -330,12 +330,7 @@ class ModelComposite(Network):
 
         final_outputs = []
         for key, tensors in aggregated.items():
-            stacked = torch.stack(tensors, dim=0)
-            if self.method == 'mean':
-                agg = torch.mean(stacked, dim=0)
-            elif self.method == 'median':
-                agg = torch.median(stacked, dim=0).values
-            final_outputs.append((key, agg))
+            final_outputs.append((key, self.combine(torch.stack(tensors, dim=0))))
 
         return final_outputs
     
@@ -358,7 +353,7 @@ class Predictor(DistributedObject):
         super().__init__(train_name)
         self.manual_seed = manual_seed
         self.dataset = dataset
-        self.combine = combine
+        self.combine_classpath = combine
         self.autocast = autocast
 
         self.model = model.getModel(train=False)
@@ -430,7 +425,10 @@ class Predictor(DistributedObject):
                     "Available modules: {}".format(modules),
                     "Please check that the name matches exactly a submodule or output of your model architecture."
                 )
-        self.modelComposite = ModelComposite(self.model, len(MODEL().split(":")), self.combine)
+        module, name = _getModule(self.combine_classpath, "konfai.predictor")
+        combine = config("{}.{}".format(KONFAI_ROOT(), self.combine_classpath))(getattr(importlib.import_module(module), name))(config = None)
+       
+        self.modelComposite = ModelComposite(self.model, len(MODEL().split(":")), combine)
         self.modelComposite.load(self._load())
 
         if len(list(self.outsDataset.keys())) == 0 and len([network for network in self.modelComposite.getNetworks().values() if network.measure is not None]) == 0:

konfai/trainer.py

@@ -108,9 +108,7 @@ class _Trainer():
         if data_log is not None:
             for data in data_log:
                 self.data_log[data.split("/")[0].replace(":", ".")] = (DataLog.__getitem__(data.split("/")[1]).value[0], int(data.split("/")[2]))
-        
-       
-        
+ 
     def __enter__(self):
         return self
     
@@ -212,6 +210,9 @@ class _Trainer():
             save_dict["Model_EMA"] = self.modelEMA.module.state_dict()
         
         save_dict.update({'{}_optimizer_state_dict'.format(name): network.optimizer.state_dict() for name, network in self.model.module.getNetworks().items() if network.optimizer is not None})
+        save_dict.update({'{}_it'.format(name): network._it for name, network in self.model.module.getNetworks().items() if network.optimizer is not None})
+        save_dict.update({'{}_nb_lr_update'.format(name): network._nb_lr_update for name, network in self.model.module.getNetworks().items() if network.optimizer is not None})
+        
         torch.save(save_dict, save_path)
 
         if self.save_checkpoint_mode == "BEST":
@@ -356,7 +357,7 @@ class Trainer(DistributedObject):
                     name = sorted(os.listdir(path))[-1]
             
             if os.path.exists(path+name):
-                state_dict = torch.load(path+name, weights_only=False)
+                state_dict = torch.load(path+name, weights_only=False, map_location="cpu")
             else:
                 raise Exception("Model : {} does not exist !".format(self.name))
             

konfai/utils/utils.py

@@ -37,7 +37,7 @@ def _getModule(classpath : str, type : str) -> tuple[str, str]:
         module = ".".join(classpath.split(":")[:-1])
         name = classpath.split(":")[-1] 
     else:
-        module = "konfai."+type+("." if len(classpath.split(".")) > 2 else "")+".".join(classpath.split(".")[:-1])
+        module = type+("." if len(classpath.split(".")) > 2 else "")+".".join(classpath.split(".")[:-1])
         name = classpath.split(".")[-1]
     return module, name
 

{konfai-1.1.5.dist-info → konfai-1.1.6.dist-info}/METADATA

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

{konfai-1.1.5.dist-info → konfai-1.1.6.dist-info}/RECORD

@@ -1,16 +1,16 @@
 konfai/__init__.py,sha256=YXG-wpSEXWs6Jt3BDI77V4r89gEUNX-6lxW9btj5VYI,851
-konfai/evaluator.py,sha256=G8tXI-g8yTxBZXmESpRW7B5UEI4SMXq47fsGksU0G0M,8394
-konfai/main.py,sha256=xhCIs3VKXxNCgyyN616K-VANEFCsZZRR-l8LIMHlmPw,2597
-konfai/predictor.py,sha256=bNkNBa_9pvbAKt8xrmAdfUnnPIerG0_NC1zOCCvSdGk,23973
-konfai/trainer.py,sha256=mxzBDHMQR7bvpoW8WHpfAzzqFnxIApkDx5raf7GwTxw,20295
+konfai/evaluator.py,sha256=WM78NGydV0iqKElahr-WpOCZLEJXHjjPq-LS-gi23rk,8401
+konfai/main.py,sha256=kr7Iie_f67NF6G3dAAj9G6Z9dhn9RzbdLYpzy2WvIh8,2573
+konfai/predictor.py,sha256=kqAF3P4BAOZvjHtBAfv2M4-yonqAOcnIV7APgxdRsww,24283
+konfai/trainer.py,sha256=Edi8l8OOfCewYM-Cd5C5rCqCaprvlfxzohd4iLkK5u0,20632
 konfai/data/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-konfai/data/augmentation.py,sha256=ruvS7ykFveOZBe2Mv_TOU5a8AzUgH7gfTipwqYgRM7k,32293
-konfai/data/data_manager.py,sha256=8Te3R39K64ucy3_mWH7AbIurNrmFRwRUkUBY0OBsss4,30107
+konfai/data/augmentation.py,sha256=SD8m0uLz5aQYtjAjns0H04WgrDWSN6nd7lWlNnT2fi8,32300
+konfai/data/data_manager.py,sha256=eYgFJjHr9HEpRLTtLabUZLPH4c82OQCiGuYQ84ktWCE,30076
 konfai/data/patching.py,sha256=zs3T4yTV8_iCFrqO21bo6GhwTywoTxIL31IAi-jiJDQ,15478
-konfai/data/transform.py,sha256=ZZoxft0V8t-DaKjF3OsIFezz41B8_xwPqBvYCYwF0dk,26471
+konfai/data/transform.py,sha256=LfdsNUE5_6mIGrVzI6B2N2WO-jaNzFmuMxhP1Y0Fbwk,26538
 konfai/metric/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-konfai/metric/measure.py,sha256=PwNbR9Jb07gNmTtvL93MhM57LzUWrrZ-78bhCWcGSP0,22881
-konfai/metric/schedulers.py,sha256=UoSr1TW_hrus3DhvOEbDefxCSUGz7lJS_8vbz0GEye8,1370
+konfai/metric/measure.py,sha256=j-rEsNgVMPjYFWtahYEaiMSDnyD5Dv8edx5KEt2Rj2U,22797
+konfai/metric/schedulers.py,sha256=eZIlJMOQH8AV48F5hiRFbmONmoY4hHMujvS3qgFYXbw,1771
 konfai/models/classification/convNeXt.py,sha256=Phj1hO8TCItVhBXoFXQcIkA85DZxurGLyHIPWBfXJ0Y,9243
 konfai/models/classification/resnet.py,sha256=t8KJEgGudWBpGJM9YS1lH_5eX0-wGbK7ZW5uZW214eM,7958
 konfai/models/generation/cStyleGan.py,sha256=PwaVQX9h5u_8YbbxA7sz7inzIEoMadinuo0kFFNqIn0,8042
@@ -20,20 +20,20 @@ konfai/models/generation/gan.py,sha256=-GoKxHm3W9NdD4U77UcJrG5TfOZ3NWFUZG663kt2X
 konfai/models/generation/vae.py,sha256=_3JYVT2ojZ0P98tYcD2ny7a-gWVUmnByLDhY7i-n_4g,4719
 konfai/models/registration/registration.py,sha256=18EiWt4RJIXLyFtqU-kHjV1sMnQRm9mxAA6_-2B1YqI,6313
 konfai/models/representation/representation.py,sha256=RwQYoxtdph440-t_ZLelykl0hkUAD1zdspQaLkgxb-0,2677
-konfai/models/segmentation/NestedUNet.py,sha256=kF8uXmWdg4MOLTwzY4Zqq1FgWdwzT1I8mLAqi-XnuH8,9958
-konfai/models/segmentation/UNet.py,sha256=Uei51-_0Le24ZJs9tbuL6hQn66kigkfbaLSMlH38els,4045
+konfai/models/segmentation/NestedUNet.py,sha256=D2qChm5SSYqV7FayCe9eT260vxckxRfBOCS1US6xcnw,10184
+konfai/models/segmentation/UNet.py,sha256=TKPmhHEnlOYfnUF2Qof3VSETl5nEIh9h0SkblBRdbbg,4036
 konfai/network/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 konfai/network/blocks.py,sha256=P7mEuuE1B0HRSgXRCeLxZvzYGKLskHD33hskpdkjIPs,14370
-konfai/network/network.py,sha256=6DBxTehY6McTaEHl6QzVfIZf2pe69KFqktYkefe3sj8,47521
+konfai/network/network.py,sha256=zszV7z6tyZpZtWb9SHXqH1pJlvdy9YB4yrf7Muv_HiM,48936
 konfai/utils/ITK.py,sha256=OxTieDNNYHGkn7zxJsAG-6ecRG1VYMvn1dlBbBe1DOs,13955
 konfai/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 konfai/utils/config.py,sha256=f7o83ix5_oNbr2pki-Czqr-yHi-8n92ZL64nlo0XGwA,12514
 konfai/utils/dataset.py,sha256=6ZzevdhJ7e5zlXATAVwSh9O6acKXM7gYNxkMAa5DrmM,36351
 konfai/utils/registration.py,sha256=v1srEBOcgDnHrx0YtsK6bcj0yCMH7wNeaQ3wC7gEvOw,8898
-konfai/utils/utils.py,sha256=EVikQCUnZy7Va-53E4plX9gY9aFancOoHd2NkT4Uy1k,23585
-konfai-1.1.5.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-konfai-1.1.5.dist-info/METADATA,sha256=DmiQixYnw4ZAb6J1A9C_itL76GGLH3GNeQAa7XqjcGY,2515
-konfai-1.1.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-konfai-1.1.5.dist-info/entry_points.txt,sha256=fG82HRN5-g39ACSOCtij_I3N6EHxfYnMR0D7TI_8pW8,81
-konfai-1.1.5.dist-info/top_level.txt,sha256=xF470dkIlFoFqTZEOlRehKJr4WU_8OKGXrJqYm9vWKs,7
-konfai-1.1.5.dist-info/RECORD,,
+konfai/utils/utils.py,sha256=1M46MYSZuPrbH5ihu8WZHaQNfqmvfeVsH-mAk0ED5TI,23575
+konfai-1.1.6.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+konfai-1.1.6.dist-info/METADATA,sha256=wU8CbR5KO85P9dY3asD_ylG5rMCFIAQmNL0ifTDXA8g,2515
+konfai-1.1.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+konfai-1.1.6.dist-info/entry_points.txt,sha256=fG82HRN5-g39ACSOCtij_I3N6EHxfYnMR0D7TI_8pW8,81
+konfai-1.1.6.dist-info/top_level.txt,sha256=xF470dkIlFoFqTZEOlRehKJr4WU_8OKGXrJqYm9vWKs,7
+konfai-1.1.6.dist-info/RECORD,,