openmlcore 1.0.0__tar.gz → 1.2.0__tar.gz

{openmlcore-1.0.0/src/openmlcore.egg-info → openmlcore-1.2.0}/PKG-INFO

@@ -1,43 +1,20 @@
 Metadata-Version: 2.4
 Name: openmlcore
-Version: 1.0.0
+Version: 1.2.0
 Summary: OpenMLCore is an open source framework (wrapper which simplify the use of PyTorch)
 Author-email: Doyez Sébastien <doyez.sebastien34090@gmail.com>
-License: MIT License
-        
-        Copyright (c) 2026 Votre Nom
-        
-        Permission is hereby granted, free of charge, to any person obtaining a copy
-        of this software and associated documentation files (the "Software"), to deal
-        in the Software without restriction, including without limitation the rights
-        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-        copies of the Software, and to permit persons to whom the Software is
-        furnished to do so, subject to the following conditions:
-        
-        The above copyright notice and this permission notice shall be included in all
-        copies or substantial portions of the Software.
-        
-        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-        SOFTWARE.
 Project-URL: Homepage, https://sebastien-doyez2812.github.io/openMLCore.github.io/
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Requires-Python: >=3.10.0
 Description-Content-Type: text/markdown
-License-File: LICENSE
 Requires-Dist: torch
 Requires-Dist: tqdm
 Requires-Dist: onnx
 Requires-Dist: onnxscript
 Requires-Dist: torchinfo
 Requires-Dist: datasets
-Dynamic: license-file
 
 # OpenML-core, Open source Package for Machine learning
 

{openmlcore-1.0.0 → openmlcore-1.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "openmlcore"               
-version = "1.0.0"                 
+version = "1.2.0"                 
 authors = [
   { name="Doyez Sébastien", email="doyez.sebastien34090@gmail.com" },
 ]

{openmlcore-1.0.0 → openmlcore-1.2.0}/src/openmlcore/loss/loss.py

@@ -29,6 +29,9 @@ class BaseLoss(nn.Module):
 class BCEWithLogitsLoss(BaseLoss):
     def __init__(self, weights=None):
         super().__init__(name="BCEWithLogitsLoss", doc_url="https://pytorch.org/docs/stable/generated/torch.nn.CrossEntropyLoss.html")
+        if weights is None:
+            raise ValueError("weights need to be set!")
+                        
         device = "cuda" if torch.cuda.is_available() else "cpu"
 
         pos_weights = None
@@ -48,6 +51,9 @@ class BCEWithLogitsLoss(BaseLoss):
 class DiceLoss(BaseLoss):
     def __init__(self, weights = None):
         super().__init__(name="DiceLoss", doc_url="https://arxiv.org/abs/1606.04797")
+        if weights is None:
+            raise ValueError("weights need to be set!")
+                        
         self.weights = weights
 
     def forward(self, outputs: torch.Tensor, targets: torch.Tensor) -> torch.Tensor:
@@ -71,76 +77,67 @@ class DiceLoss(BaseLoss):
 
             return dice_loss.sum(dim=1).mean()
         return dice_loss.mean()
-    
-# TODO:
-# 1 Hot encoding loss
-# 
-
 
 class MeanSquaredErrorLoss(BaseLoss):
-    def __init__(self, index_ignore=255):
+    def __init__(self, weights = None):
         super().__init__(name="MeanSquaredErrorLoss", doc_url="https://pytorch.org/docs/stable/generated/torch.nn.MSELoss.html")
-        self.index_ignore = index_ignore
+        if weights is None:
+            raise ValueError("weights need to be set!")
+                             
+        self.weights = weights
 
     def forward(self, outputs: torch.Tensor, targets: torch.Tensor) -> torch.Tensor:
-        num_classes = outputs.shape[1]
-        probs = F.softmax(outputs, dim=1)
-        targets_one_hot, valid_mask = self._to_one_hot_clean(targets, num_classes, self.index_ignore)
-        
-        mse = (probs - targets_one_hot) ** 2
-        mse = mse * valid_mask
-        
-        num_valids = valid_mask.sum() * num_classes
-        return mse.sum() / torch.clamp(num_valids, min=1.0)
+        probs = torch.sigmoid(outputs)
+        probs   = probs.view  (probs.size(0)  , probs.size(1), -1)
+        targets = targets.view(probs.size(0), probs.size(1), -1)
 
+        mse = (probs - targets) ** 2
+        weighted_mse = 0
+        for idx, weight in enumerate(self.weights):
+            weighted_mse+= weight * mse[:, idx, :]
 
+        return weighted_mse.mean()
 
 class FocalLoss(BaseLoss):
-    def __init__(self, alpha=0.25, gamma=2.0, index_ignore=255):
+    def __init__(self, alpha=0.25, gamma=2.0, weights = None):
         super().__init__(name="FocalLoss", doc_url="https://arxiv.org/abs/1708.02002")
+        if weights is None:
+            raise ValueError("weights need to be set!")
+                        
         self.alpha = alpha
         self.gamma = gamma
-        self.index_ignore = index_ignore
+        self.weights = weights
 
     def forward(self, outputs: torch.Tensor, targets: torch.Tensor) -> torch.Tensor:
-        num_classes = outputs.shape[1]
-        targets_one_hot, valid_mask = self._to_one_hot_clean(targets, num_classes, self.index_ignore)
-        
-        bce_loss = F.binary_cross_entropy_with_logits(outputs, targets_one_hot, reduction='none')
+        probs   = outputs.view(outputs.size(0)  , outputs.size(1), -1)
+        targets = targets.view(outputs.size(0), outputs.size(1), -1)
+
+        bce_loss = F.binary_cross_entropy_with_logits(probs, targets, reduction='none') # Apply a sigmoid inside...
         pt = torch.exp(-bce_loss)
         focal_loss = self.alpha * ((1 - pt) ** self.gamma) * bce_loss
-        focal_loss = focal_loss * valid_mask
-        num_valids = valid_mask.sum() * num_classes
-        return focal_loss.sum() / torch.clamp(num_valids, min=1.0)
-    
-class MeanSquaredErrorLoss(BaseLoss):
-    def __init__(self, index_ignore=255):
-        super().__init__(name="MeanSquaredErrorLoss", doc_url="https://pytorch.org/docs/stable/generated/torch.nn.MSELoss.html")
-        self.index_ignore = index_ignore
-
-    def forward(self, outputs: torch.Tensor, targets: torch.Tensor) -> torch.Tensor:
-        num_classes = outputs.shape[1]
-        probs = F.softmax(outputs, dim=1)
-        targets_one_hot, valid_mask = self._to_one_hot_clean(targets, num_classes, self.index_ignore)
-        
-        mse = (probs - targets_one_hot) ** 2
-        mse = mse * valid_mask
-        
-        num_valids = valid_mask.sum() * num_classes
-        return mse.sum() / torch.clamp(num_valids, min=1.0)
 
+        final_loss = 0
+        for idx, weight in enumerate(self.weights):
+            final_loss += weight * focal_loss[:, idx, :]
+        return final_loss.mean()
+    
 class HuberLoss(BaseLoss):
-    def __init__(self, delta=1.0, index_ignore=255):
+    def __init__(self, delta=1.0, weights = None):
         super().__init__(name="HuberLoss", doc_url="https://pytorch.org/docs/stable/generated/torch.nn.HuberLoss.html")
+        if weights is None:
+            raise ValueError("weights need to be set!")
+        self.weights = weights
         self.delta = delta
-        self.index_ignore = index_ignore
 
     def forward(self, outputs: torch.Tensor, targets: torch.Tensor) -> torch.Tensor:
-        num_classes = outputs.shape[1]
-        probs = F.softmax(outputs, dim=1)
-        targets_one_hot, valid_mask = self._to_one_hot_clean(targets, num_classes, self.index_ignore)
-        
-        error = probs - targets_one_hot
+        # num_classes = outputs.shape[1]
+        # probs = F.softmax(outputs, dim=1)
+
+        probs = torch.sigmoid(outputs)
+        probs   = probs.view  (probs.size(0)  , probs.size(1), -1)
+        targets = targets.view(probs.size(0), probs.size(1), -1)
+
+        error = probs - targets
         abs_error = torch.abs(error)
         
         huber = torch.where(
@@ -148,30 +145,15 @@ class HuberLoss(BaseLoss):
             0.5 * (error ** 2),
             self.delta * (abs_error - 0.5 * self.delta)
         )
-        huber = huber * valid_mask
-        
-        num_valids = valid_mask.sum() * num_classes
-        return huber.sum() / torch.clamp(num_valids, min=1.0)
-    
-class KLDivergenceLoss(BaseLoss):
-    def __init__(self, index_ignore=255):
-        super().__init__(name="KLDivergenceLoss", doc_url="https://pytorch.org/docs/stable/generated/torch.nn.KLDivLoss.html")
-        self.eps = 1e-8
-        self.index_ignore = index_ignore
-
-    def forward(self, outputs: torch.Tensor, targets: torch.Tensor) -> torch.Tensor:
-        num_classes = outputs.shape[1]
-        log_probs = F.log_softmax(outputs, dim=1)
-        targets_one_hot, valid_mask = self._to_one_hot_clean(targets, num_classes, self.index_ignore)
-        
-        # KL-Div = p(x) * (log(p(x)) - log(q(x)))
-        # Pour une distribution One-Hot, cela se réduit à : - log(q(x)) sur la classe vraie
-        kl = F.kl_div(log_probs, targets_one_hot, reduction='none')
-        kl = kl * valid_mask
-        
-        num_valids = valid_mask.sum() * num_classes
-        return kl.sum() / torch.clamp(num_valids, min=1.0)
 
+        if not isinstance(self.weights, torch.Tensor):
+            weights_tensor = torch.tensor(self.weights, device=outputs.device, dtype=outputs.dtype)
+        else:
+            weights_tensor = self.weights.to(outputs.device)
+        huber = huber * weights_tensor.view(1, -1, 1)
+            
+        return huber.mean()
+    
 ####################################
 #   Custom Loss implementation     #
 ####################################

{openmlcore-1.0.0 → openmlcore-1.2.0}/src/openmlcore/metrics/metrics.py

@@ -34,8 +34,9 @@ def accuracy(y_pred, y_true):
         final_metric[idx] = metric / num_batches 
     return final_metric
     
-def iou(y_pred, y_true,smooth = 1e-6):
-    preds = (y_pred > 0.0).float()
+def iou(y_pred, y_true, threshold = 0.5, smooth = 1e-6):
+    preds = (y_pred > threshold).float()
+
     preds = preds.view(preds.size(0), preds.size(1), -1)
     y_true = y_true.view(y_true.size(0), y_true.size(1), -1)
 

openmlcore-1.2.0/src/openmlcore/models/MobileUnetR.py

@@ -0,0 +1,329 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import timm
+from .base_model import BaseModel
+
+class MobileNetBlockv2(nn.Module):
+    def __init__(self, in_channels, out_channels, stride=1, expand_ratio=4, **kwargs):
+        super().__init__(**kwargs)
+        self.stride = stride
+        self.use_residual = (self.stride == 1 and in_channels == out_channels)
+        
+        hidden_dim = in_channels * expand_ratio
+        self.layers = nn.ModuleList()
+
+        if expand_ratio != 1:
+            self.layers.append(nn.Conv2d(in_channels, hidden_dim, kernel_size=1, bias=False))
+            self.layers.append(nn.BatchNorm2d(hidden_dim))
+            self.layers.append(nn.ReLU6(inplace=True)) # ReLU6 est souvent préféré pour MobileNet
+        else:
+            hidden_dim = in_channels
+
+        self.layers.append(nn.Conv2d(hidden_dim, hidden_dim, kernel_size=3, stride=self.stride, padding=1, groups=hidden_dim, bias=False))
+        self.layers.append(nn.BatchNorm2d(hidden_dim))
+        self.layers.append(nn.ReLU6(inplace=True))
+
+        self.layers.append(nn.Conv2d(hidden_dim, out_channels, kernel_size=1, bias=False))
+        self.layers.append(nn.BatchNorm2d(out_channels))
+
+    def forward(self, X):
+        inputX = X if self.use_residual else None
+        
+        for layer in self.layers:
+            X = layer(X)
+
+        if inputX is not None:
+            return inputX + X
+        return X
+    
+class STEM(nn.Module):
+    def __init__(self, in_channels=3, **kwargs):
+        super().__init__(**kwargs)
+        
+        self.conv2D = nn.Conv2d(in_channels=in_channels, out_channels=32, kernel_size=3, stride=2, padding=1, bias=False)
+        self.batchNorm = nn.BatchNorm2d(32)
+        self.relu = nn.ReLU6(inplace=True)
+        
+        self.mobile_block1  = MobileNetBlockv2(in_channels=32, out_channels=16, stride=1, expand_ratio=1)
+        self.mobile_block2a = MobileNetBlockv2(in_channels=16, out_channels=24, stride=2, expand_ratio=6)
+        self.mobile_block2b = MobileNetBlockv2(in_channels=24, out_channels=24, stride=1, expand_ratio=6)
+        self.mobile_block3  = MobileNetBlockv2(in_channels=24, out_channels=24, stride=1, expand_ratio=6)
+
+    def forward(self, X):
+        X = self.relu(self.batchNorm(self.conv2D(X)))
+        X = self.mobile_block1(X)
+        X = self.mobile_block2a(X)
+        X = self.mobile_block2b(X)
+        X = self.mobile_block3(X)
+        return X
+
+class MobileViTBlock(nn.Module):
+    def __init__(self, in_channels, out_channels, patch_size=2, l=2, dim=64, **kwargs):
+        super().__init__(**kwargs)
+        self.patchsize = patch_size
+        self.dim = dim
+        self.out_channels = out_channels
+        self.L = l
+        
+        self.conv3x3_1 = nn.Conv2d(in_channels=in_channels, out_channels=in_channels, kernel_size=3, padding=1, bias=False)
+        self.conv1x1_1 = nn.Conv2d(in_channels=in_channels, out_channels=dim, kernel_size=1, padding=0, bias=False)
+        
+        self.conv3x3_2 = nn.Conv2d(in_channels=in_channels, out_channels=out_channels, kernel_size=3, padding=1, bias=False)
+        self.conv1x1_2 = nn.Conv2d(in_channels=dim, out_channels=in_channels, kernel_size=1, padding=0, bias=False)
+        
+        self.transformers = nn.ModuleList([ViTransformer(dim=self.patchsize * self.patchsize * dim) for _ in range(self.L)])
+        
+        self.unfold = nn.Unfold(
+            kernel_size=patch_size,
+            stride=patch_size,
+            padding=0
+        )
+
+    def forward(self, X):
+        skip_connection = X
+
+        X = self.conv3x3_1(X)
+        X = self.conv1x1_1(X)
+
+        B, C, H, W = X.shape
+        pH, pW = H // self.patchsize, W // self.patchsize
+        
+        X = self.unfold(X)
+        X = X.reshape(B, C * self.patchsize * self.patchsize, pH * pW)
+        X = X.permute(0, 2, 1)
+
+        for transformer in self.transformers:
+            X = transformer(X)
+
+        X = X.permute(0, 2, 1)
+        X = X.reshape(B, C, self.patchsize, self.patchsize, pH, pW)
+        X = X.permute(0, 1, 4, 2, 5, 3)
+        X = X.reshape(B, C, pH * self.patchsize, pW * self.patchsize)
+
+        X = self.conv1x1_2(X)
+        X = X + skip_connection
+        X = self.conv3x3_2(X)
+        
+        return X
+    
+class ViTransformer(nn.Module):
+    def __init__(self, dim, num_heads=8, ffn_ratio=4, dropout=0.0, **kwargs):
+        super().__init__(**kwargs)
+        self.dim = dim
+        self.num_heads = num_heads
+        self.ffn_ratio = ffn_ratio
+        self.dropout_rate = dropout
+
+        self.norm1 = nn.LayerNorm(dim, eps=1e-6)
+        self.attn = nn.MultiheadAttention(embed_dim=dim, num_heads=num_heads, batch_first=True, dropout=dropout)
+        self.drop1 = nn.Dropout(dropout)
+
+        self.norm2 = nn.LayerNorm(dim, eps=1e-6)
+        self.ffn_1 = nn.Linear(in_features=dim, out_features=dim * ffn_ratio)
+        self.gelu = nn.GELU()
+        self.ffn_2 = nn.Linear(in_features=dim * ffn_ratio, out_features=dim)
+        self.drop2 = nn.Dropout(dropout)
+    
+    def forward(self, X):
+        input_tensor = X
+        X = self.norm1(X)
+        X, _ = self.attn(X, X, X)
+        X = self.drop1(X)
+        X = X + input_tensor
+
+        res = X
+        X = self.norm2(X)
+        X = self.ffn_1(X)
+        X = self.gelu(X)
+        X = self.drop2(X)
+        X = self.ffn_2(X)
+        X = self.drop2(X)
+        return X + res
+    
+class HybridEncoderBlock(nn.Module):
+    def __init__(self, input_channels, out_channels, stride=2, **kwargs):
+        super().__init__(**kwargs)
+        self.Conv1x1 = nn.Conv2d(in_channels=input_channels, out_channels=out_channels, kernel_size=1, stride=1, padding=0, bias=False)
+        self.Conv3x3 = nn.Conv2d(in_channels=out_channels, out_channels=out_channels, kernel_size=3, stride=stride, padding=1, bias=False)
+        self.mobileViT_block = MobileViTBlock(in_channels=out_channels, out_channels=out_channels)
+
+    def forward(self, X):
+        X = self.Conv1x1(X)
+        X = self.Conv3x3(X)
+        X = self.mobileViT_block(X)
+        return X
+
+class HybridDecoderBlock(nn.Module):
+    def __init__(self, in_channels, skip_channels, out_channels, **kwargs):
+        super().__init__(**kwargs)
+        self.transpose_conv = nn.ConvTranspose2d(
+            in_channels=in_channels, 
+            out_channels=out_channels, 
+            kernel_size=2, 
+            stride=2
+        )
+        
+        concat_channels = out_channels + skip_channels
+        
+        self.conv1x1 = nn.Conv2d(
+            in_channels=concat_channels, 
+            out_channels=out_channels, 
+            kernel_size=1, 
+            stride=1, 
+            bias=False
+        )
+        self.silu1 = nn.SiLU()
+        
+        self.conv_depth_wise = nn.Conv2d(
+            in_channels=out_channels, 
+            out_channels=out_channels, 
+            kernel_size=3, 
+            stride=1, 
+            padding=1, 
+            groups=out_channels, 
+            bias=False
+        )
+        self.silu2 = nn.SiLU()
+        
+        self.conv1x1_2 = nn.Conv2d(
+            in_channels=out_channels, 
+            out_channels=out_channels, 
+            kernel_size=1, 
+            stride=1, 
+            bias=False
+        )
+        self.silu3 = nn.SiLU()
+        
+        self.mobileViTBlock = MobileViTBlock(
+            in_channels=out_channels, 
+            out_channels=out_channels
+        )
+
+    def forward(self, decoder_in, skip_in):
+        x = self.transpose_conv(decoder_in)
+        
+        if x.shape[2:] != skip_in.shape[2:]:
+            x = F.interpolate(x, size=skip_in.shape[2:], mode='bilinear', align_corners=False)
+            
+        x = torch.cat([x, skip_in], dim=1)
+        x = self.silu1(self.conv1x1(x))
+        x = self.silu2(self.conv_depth_wise(x))
+        x = self.silu3(self.conv1x1_2(x))
+        return self.mobileViTBlock(x)
+
+class MobileUnetRTorch(nn.Module):
+    def __init__(self, input_channels, output_channels):
+        super().__init__()
+        self.STEM = STEM(in_channels=input_channels) #should be 3, because RGB = 3 channels
+        # HEB = Hybrid Encoder Block
+        self.HEB_1 = HybridEncoderBlock(input_channels=24, out_channels=64,  stride=2)          # H/8
+        self.HEB_2 = HybridEncoderBlock(input_channels=64, out_channels=128,  stride=2)          # H/16
+        self.HEB_3 = HybridEncoderBlock(input_channels=128, out_channels=256,  stride=2)          # H/32
+        self.HEB_4 = HybridEncoderBlock(input_channels=256, out_channels=512,  stride=2)          # H/64
+
+        # HDB = Hybrid Decoder Block
+        self.HDB_1 = HybridDecoderBlock(in_channels= 512, skip_channels=256, out_channels=256) #H/32
+        self.HDB_2 = HybridDecoderBlock(in_channels= 256, skip_channels=128, out_channels=128) #H/16
+        self.HDB_3 = HybridDecoderBlock(in_channels= 128, skip_channels=64, out_channels=64)   #H/8
+
+        self.final_conv = nn.ConvTranspose2d(in_channels=64, out_channels=output_channels, kernel_size=4, stride=4, padding=0)
+        self.sigmoid = nn.Sigmoid()
+
+
+    def forward(self, X):
+        input_size = X.shape[2:]
+        skip_connection = []
+        
+        X = self.STEM(X) # Embedding
+        skip_connection.append(X)
+        X = self.HEB_1(X)
+        skip_connection.append(X)
+
+        X = self.HEB_2(X)
+        skip_connection.append(X)
+
+        X = self.HEB_3(X)
+        skip_connection.append(X)
+
+        X = self.HEB_4(X)
+
+        X = self.HDB_1(X, skip_connection.pop())
+        X = self.HDB_2(X, skip_connection.pop())
+        X = self.HDB_3(X, skip_connection.pop())
+
+        X = self.final_conv(X)
+        
+        if X.shape[2:] != input_size:
+            X = F.interpolate(X, size=input_size, mode='bilinear', align_corners=False)
+        return X  
+        # return self.sigmoid(X)           
+
+class MobileUnetRTorch_v2(nn.Module):
+    def __init__(self, input_channels, output_channels):
+        super().__init__()
+        
+        self.encoder = timm.create_model(
+            "mobilevit_s.cvnets_in1k", 
+            pretrained=True, 
+            features_only=True, 
+            out_indices=(1, 2, 3, 4)
+        )
+        for param in self.encoder.parameters():
+            param.requires_grad = True
+        
+        # features[3] (bottleneck) = 640 channels
+        # features[2] (skip3)      = 128 channels
+        # features[1] (skip2)      = 96 channels
+        # features[0] (skip1)      = 64 channels
+        
+        self.HDB_1 = HybridDecoderBlock(in_channels=640, skip_channels=128, out_channels=256)
+        self.HDB_2 = HybridDecoderBlock(in_channels=256, skip_channels=96,  out_channels=128)
+        self.HDB_3 = HybridDecoderBlock(in_channels=128, skip_channels=64,  out_channels=64)
+
+        self.final_conv = nn.ConvTranspose2d(in_channels=64, out_channels=output_channels, kernel_size=4, stride=4, padding=0)
+        self.sigmoid = nn.Sigmoid()
+
+    def forward(self, X):
+        input_size = X.shape[2:]
+        
+        features = self.encoder(X)
+        skip1, skip2, skip3, bottleneck = features[0], features[1], features[2], features[3]
+
+        X = self.HDB_1(bottleneck, skip3)
+        X = self.HDB_2(X, skip2)
+        X = self.HDB_3(X, skip1)
+
+        X = self.final_conv(X)
+        
+        if X.shape[2:] != input_size:
+            X = F.interpolate(X, size=input_size, mode='bilinear', align_corners=False)
+
+        return X  
+        # return self.sigmoid(X)
+
+class MobileUnetR(BaseModel):
+    def __init__(self, input_channels=1, output_channels=1, **kwargs):
+        super().__init__(name="MobileUnetR", **kwargs)
+        self.input_channels = input_channels
+        self.output_channels = output_channels
+
+    def create_model(self):
+        self.model = MobileUnetRTorch(
+            input_channels=self.input_channels,
+            output_channels=self.output_channels
+        )
+        return self.model
+
+class MobileUnetR_v2(BaseModel):
+    def __init__(self, input_channels=1, output_channels=1, **kwargs):
+        super().__init__(name="MobileUnetR_apple_version", **kwargs)
+        self.input_channels = input_channels
+        self.output_channels = output_channels
+
+    def create_model(self):
+        self.model = MobileUnetRTorch_v2(
+            input_channels=self.input_channels,
+            output_channels=self.output_channels
+        )
+        return self.model

{openmlcore-1.0.0 → openmlcore-1.2.0}/src/openmlcore/models/base_model.py

@@ -1,4 +1,6 @@
 import torch
+import csv
+import mlflow
 import torch.nn as nn
 from torchinfo import summary
 from torch.utils.data import DataLoader
@@ -6,7 +8,7 @@ from tqdm.auto import tqdm
 import numpy as np
 
 class BaseModel(nn.Module):
-    def __init__(self, name: str = "BaseModel", model = None, metrics = None, loss_fn = None, optimizer = None, device = None):
+    def __init__(self, name: str = "BaseModel", model = None, metrics = None, loss_fn = None, optimizer = None, device = None, write_result_in_CSV = True, csv_path= None, use_mlflow = True):
         super().__init__()
         self.name = name
         self.model = model
@@ -14,6 +16,13 @@ class BaseModel(nn.Module):
         self.loss_fn = loss_fn
         self.optimizer = optimizer
         self.device = device or ("cuda" if torch.cuda.is_available() else "cpu")
+        
+        self.use_mlflow = use_mlflow
+        self.write_result_in_CSV = write_result_in_CSV
+        if csv_path is None:
+            self.csv_path = f"{self.name}.csv"
+        else:
+            self.csv_path = csv_path
 
     def help(self):
         raise NotImplementedError("Subclasses should implement this method.")
@@ -32,6 +41,27 @@ class BaseModel(nn.Module):
             raise ValueError("Optimizer has not been set. Please set an optimizer before training.")
 
         self.model.to(self.device)
+
+        # MLFlow:
+        if self.use_mlflow:
+            lr = self.optimizer.param_groups[0]['lr'] if self.optimizer and len(self.optimizer.param_groups) > 0 else None
+            mlflow.log_params({
+                "model_name": self.name,
+                "epochs": epochs,
+                "learning_rate": lr,
+                "device": str(self.device)
+            })
+
+        # CSV Logger:
+        if self.write_result_in_CSV:
+            csv_fields = ["epoch", "train_loss"]
+            for name_metric in self.metrics.keys():
+                csv_fields.append(f"val_{name_metric}")
+
+            with open(self.csv_path, 'w', newline='', encoding='utf-8') as file:
+                writer = csv.DictWriter(file, fieldnames=csv_fields, extrasaction='ignore')
+                writer.writeheader()   
+
         for current_epoch in range(epochs):
             # For each loop: a first phase of training and then validation.
             # Training:
@@ -63,6 +93,11 @@ class BaseModel(nn.Module):
             avg_loss = total_loss / len(train_loader)
             tqdm.write(f"Epoch {current_epoch + 1}/{epochs} — average loss: {avg_loss:.4f}")
 
+
+            # Create a dictionnary for the csv:
+            epoch_metrics = {"epoch": current_epoch,
+                             "train_loss" : avg_loss}
+            
             # Validation:
             if val_loader:
                 self.model.eval()
@@ -130,13 +165,27 @@ class BaseModel(nn.Module):
 
                         class_details = ", ".join([f"C{i}:{v:.3f}" for i, v in enumerate(avg_list)])
                         metrics_summary_str.append(f"{name_metric}_Mean: {mean_all_classes:.4f} ({class_details})")
+                        epoch_metrics[f"val_{name_metric}"] = mean_all_classes
+                        for idx, value in enumerate(avg_list):
+                            epoch_metrics[f"val_{name_metric}"] = value
+                    
                     else:
                         avg_val = val_sum / num_batchs
                         metrics_summary_str.append(f"{name_metric}: {avg_val:.4f}")
+                        epoch_metrics[f"val_{name_metric}"] = avg_val
+
 
                 formatted_metrics = " | ".join(metrics_summary_str)
                 tqdm.write(f"Epoch {current_epoch + 1}/{epochs} — Validation: {formatted_metrics}")
-            
+
+                if self.use_mlflow:
+                    mlflow.log_metrics(epoch_metrics, step=current_epoch + 1)
+                
+                if self.write_result_in_CSV:
+                    with open(self.csv_path, 'a', newline='', encoding='utf-8') as file:
+                        writer = csv.DictWriter(file, fieldnames=csv_fields, extrasaction='ignore')
+                        writer.writerow(epoch_metrics)
+                
             if save_checkpoint:
                 self.save_model(f"checkpoint_{self.name}.pt")
 
@@ -190,11 +239,11 @@ class BaseModel(nn.Module):
             num_batches = len(eval_loader)
             final_metrics = {}
 
-            for name_metrics, val_sum in dict_metrics_sum.items():
+            for current_metrics, val_sum in dict_metrics_sum.items():
                 if isinstance(val_sum, list):
-                    final_metrics[name_metric] = [v / num_batches for v in val_sum]
+                    final_metrics[current_metrics] = [v / num_batches for v in val_sum]
                 else:
-                    final_metrics[name_metric] = val_sum / num_batches
+                    final_metrics[current_metrics] = val_sum / num_batches
 
         return final_metrics
 

openmlcore-1.2.0/src/openmlcore/models/segformer.py

@@ -0,0 +1,322 @@
+import torch
+from huggingface_hub import hf_hub_download
+import torch.nn as nn
+import torch.nn.functional as F
+from .base_model import BaseModel
+from .lib.convolutions import DoubleConv
+import math
+
+class EfficientSelfAttention(nn.Module):
+    def __init__(self, dim, num_heads = 8, reduction_ratio = 1, dropout_p = 0.1):
+        super().__init__()
+        self.dim = dim # = C in the article
+        self.num_heads = num_heads
+        self.head_dim = dim // num_heads
+        self.scale = 1.0 / math.sqrt(self.head_dim)
+        self.reduction_ratio = reduction_ratio
+
+        self.W_q = nn.Linear(dim, dim)
+        if reduction_ratio > 1:
+            self.sr = nn.Conv2d(dim, dim, kernel_size=reduction_ratio, stride=reduction_ratio)
+            self.norm = nn.LayerNorm(dim)
+        else:
+            self.sr = None
+            self.norm = None
+
+        self.W_k  = nn.Linear(dim, dim)
+        self.W_v  = nn.Linear(dim, dim)
+        self.proj = nn.Linear(dim, dim)
+
+        self.attn_drop = nn.Dropout(dropout_p)
+        self.proj_drop = nn.Dropout(dropout_p)
+
+    def forward(self, X, H, W):
+        B, N, C = X.shape # N = h * W
+        # (B, N, C) -> (B, N, heads, head_dim) -> (B, heads, N, head_dim)
+        q = self.W_q(X).reshape(B, N, self.num_heads, self.head_dim).permute(0, 2, 1, 3)
+        if self.sr is not None:
+            x_spatial = X.permute(0, 2, 1). reshape(B, C, H, W)
+            x_spatial = self.sr(x_spatial)
+            x_spatial = x_spatial.flatten(2) # B, C, H*W
+            x_spatial = x_spatial.permute(0, 2, 1)
+            x_spatial = self.norm(x_spatial)
+
+            k = self.W_k(x_spatial).reshape(B, -1, self.num_heads, self.head_dim).permute(0, 2, 1, 3)
+            v = self.W_v(x_spatial).reshape(B, -1, self.num_heads, self.head_dim).permute(0, 2, 1, 3)
+        else:
+            # Classical Attention
+            k = self.W_k(X).reshape(B, -1, self.num_heads, self.head_dim).permute(0, 2, 1, 3)
+            v = self.W_v(X).reshape(B, -1, self.num_heads, self.head_dim).permute(0, 2, 1, 3)
+
+        attn_value = (q @ k.transpose(-2, -1)) * self.scale
+        attn_value = attn_value.softmax(dim=-1)
+        attn_value = self.attn_drop(attn_value)
+
+        # (B, heads, N, N_reduced) @ v: (B, heads, N_reduced, head_dim) -> (B, heads, N, head_dim)
+        X_out = attn_value @ v
+        X_out = X_out.permute(0, 2, 1, 3). reshape(B, N, C)
+        proj = self.proj(X_out)
+        proj = self.proj_drop(proj)
+        return proj
+
+class OverlapPatchMerging(nn.Module):
+    def __init__(self, in_channels, out_channels, kernel_size=3, stride=2, padding=1):
+        super().__init__()
+        self.conv = nn.Conv2d(in_channels=in_channels,
+            out_channels=out_channels,
+            kernel_size=kernel_size,
+            stride=stride,
+            padding=padding
+        )
+        self.norm = nn.LayerNorm(out_channels)
+    def forward(self, X):
+        # B, C, H, W
+        X = self.conv(X)
+        B, C, H_new, W_new = X.shape
+
+        X = X.flatten(2). transpose(2, 1) # B, N, C
+        X = self.norm(X)
+        return X, H_new, W_new
+
+
+class TransformerSegFormer(nn.Module):
+    def __init__(self, N, C_in, C_out, num_heads, reduction_ratio = 1, intermediate_channel = 256, H = 256, W = 256, patch_kernel = 3, stride = 2, padding = 1):
+        super().__init__()
+
+        self.efficient_self_attns = nn.ModuleList()
+        self.mix_FFNs = nn.ModuleList()
+        self.N = N
+
+        for i in range(N):
+            self.efficient_self_attns.append(EfficientSelfAttention(dim = C_out, num_heads= num_heads, reduction_ratio= reduction_ratio))
+            target_H = H // stride
+            target_W = W // stride
+            self.mix_FFNs.append(MixFFN(C_out, intermediate_channel))
+
+        self.overlap_patch_merging = OverlapPatchMerging(C_in, C_out,patch_kernel, stride = stride, padding = padding)
+
+    def forward(self, X):
+        X, H_new, W_new = self.overlap_patch_merging(X)
+
+        for idx in range(self.N):
+            X = self.efficient_self_attns[idx](X, H_new, W_new) + X
+            X = self.mix_FFNs[idx](X, H_new, W_new)
+
+        return X, H_new, W_new
+
+class MixFFN(nn.Module):
+    def __init__(self, in_channels, intermediate_channels, dropout_p = 0.1):
+        super().__init__()
+        self.MLP1 = nn.Linear(in_features=in_channels, out_features=intermediate_channels)
+        self.gelu = nn.GELU()
+        self.conv33 = nn.Conv2d(in_channels=intermediate_channels, out_channels=intermediate_channels, kernel_size=3, padding=1, groups=intermediate_channels) # Note: Conv 3x3 depthwise dans l'original
+        self.MLP2 = nn.Linear(in_features=intermediate_channels, out_features=in_channels)
+        self.dropout = nn.Dropout(dropout_p)
+    def forward(self, X, H, W):
+        skipped_X = X
+        B, N, C = X.shape
+
+        X = self.MLP1(X)
+        X = self.gelu(X)
+        X = self.dropout(X)
+
+        # Spatial reshape dynamique avec H et W passés en paramètre
+        X = X.transpose(1, 2).view(B, -1, H, W)
+        X = self.conv33(X)
+        X = X.flatten(2).transpose(1, 2)
+
+        X = self.MLP2(X)
+        X = self.dropout(X)
+        return X + skipped_X
+
+
+
+
+class MLPLayers(nn.Module):
+    def __init__(self, i, input_channels, embbeding_channels, dropout = 0.1, H = 256, W = 256):
+        super().__init__()
+        # Keep the same dimension but project on the number of channels:
+        self.linear_project = nn.Conv2d(in_channels= input_channels, out_channels= embbeding_channels, kernel_size=1)
+        
+        self.dropout = nn.Dropout(dropout)
+        self.current_H = H // (2**(i + 2))
+        self.current_W = W // (2**(i + 2))
+        self.target_H = H // 4
+        self.target_W = W // 4
+
+        self.linear_spatial = nn.Linear((self.current_H * self.current_W), self.target_H * self.target_W)
+
+    def forward(self, X):
+        # B, Ci, H/2**(i+1), W/2**(i+1)
+        B, _, _, _ = X.shape
+
+        # Projection on C:
+        #  B, C, H/2**(i+1), W/2**(i+1)
+        # C is embbeding channels:
+        X = self.linear_project(X) 
+
+        #  B, C, H/2**(i+1)* W/2**(i+1)
+        X = X.flatten(2)
+
+        #  B, C, H/4* W/4
+        X = self.linear_spatial(X)
+
+        X = self.dropout(X)
+        #  B, C, H/4, W/4
+        X = X.view(B, -1, self.target_H, self.target_W)
+        return X
+
+    
+class SegFormerTorch(nn.Module):
+    def __init__(self, depth = 4, input_channels=1, output_channels=1, initial_filters=64, dropout_p = 0.1, H=256, W= 256):
+        super().__init__()
+        self.depth = depth
+        self.channels = [32, 64, 160, 256]
+        # self.channels = [initial_filters*2**i for i in range(self.depth)]
+        self.num_heads = [1, 2, 5, 8]
+        reduction_ratios = [8, 4, 2, 1]
+        
+        self.transformers = nn.ModuleList()
+        current_in_channels = input_channels
+        
+        current_H, current_W = H, W
+
+        for i in range(self.depth):
+            patch_kernel = 7 if i == 0 else 3
+            patch_stride = 4 if i == 0 else 2
+            patch_padding = 3 if i == 0 else 1
+
+
+            self.transformers.append(TransformerSegFormer(
+                                        N=2, # Nombre de blocs Attention+MixFFN par niveau
+                                        C_in=current_in_channels,
+                                        C_out=self.channels[i],
+                                        num_heads=self.num_heads[i],
+                                        reduction_ratio=reduction_ratios[i],
+                                        intermediate_channel=self.channels[i] * 4,
+                                        H=current_H,
+                                        W=current_W,
+                                        patch_kernel=patch_kernel,
+                                        stride=patch_stride,
+                                        padding=patch_padding
+                                        )
+                                    )
+            current_in_channels = self.channels[i]
+            current_H //= patch_stride
+            current_W //= patch_stride
+        self.embedding_dim = 256
+
+        self.mlp_layers = nn.ModuleList()
+        for i in range(self.depth):
+            self.mlp_layers.append(
+                MLPLayers(i=i, input_channels=self.channels[i], embbeding_channels=self.embedding_dim, H=H, W=W)
+            )
+        self.linear_fuse = nn.Conv2d(self.embedding_dim * self.depth, self.embedding_dim, kernel_size=1)
+        self.linear_pred = nn.Conv2d(self.embedding_dim, output_channels, kernel_size=1)
+
+        self.dropout = nn.Dropout(dropout_p)
+
+    def forward(self, X):
+        orig_H, orig_W = X.shape[-2], X.shape[-1]
+        features = []
+        for idx in range(self.depth):
+            X, H_new, W_new = self.transformers[idx](X)
+            X_spatial = X.transpose(1, 2).view(X.shape[0], -1, H_new, W_new).contiguous()
+            features.append(X_spatial)
+            X = X_spatial
+
+        decoder_output = []
+        for idx in range(self.depth):
+            decoder_output.append(self.mlp_layers[idx](features[idx]))
+
+        out = torch.cat(decoder_output, dim = 1)
+        out = self.linear_fuse(out)
+        out = F.gelu(out)
+        out = self.dropout(out)
+        out = self.linear_pred(out)
+        # To get the same dimension as the input:
+        out = F.interpolate(out, size=(orig_H, orig_W), mode='bilinear', align_corners=False)
+        
+        return out
+
+
+
+class SegFormer(BaseModel):
+    def __init__(self, input_channels=1, output_channels=1, H = 256, W = 256,depth=4, initial_filters=64, **kwargs):
+        super().__init__(name="SegFormer", **kwargs)
+        self.input_channels = input_channels
+        self.output_channels = output_channels
+        self.depth = depth
+        self.initial_filters = initial_filters
+        self.H = H
+        self.W = W
+
+    def create_model(self):
+        self.model = SegFormerTorch(
+            input_channels=self.input_channels,
+            output_channels=self.output_channels,
+            depth=self.depth,
+            initial_filters=self.initial_filters,
+            H = self.H,
+            W = self.W
+        )
+        return self.model
+
+
+    def load_nvidia_weights_into_custom_model(self, model_name="nvidia/mit-b0"):
+        if self.model is None:
+            raise ValueError("Please create_model first!")
+                
+        try:
+            weights_path = hf_hub_download(repo_id=model_name, filename="pytorch_model.bin")
+            official_dict = torch.load(weights_path, map_location="cpu")
+        except Exception:
+            from safetensors.torch import load_file
+            weights_path = hf_hub_download(repo_id=model_name, filename="model.safetensors")
+            official_dict = load_file(weights_path)
+        
+        custom_dict = self.model.state_dict()
+        new_state_dict = {}
+
+        for stage_idx in range(4):
+            src_prefix = f"segformer.encoder.patch_embeddings.{stage_idx}"
+            dst_prefix = f"transformers.{stage_idx}.overlap_patch_merging"
+            
+            if f"{src_prefix}.proj.weight" in official_dict:
+                new_state_dict[f"{dst_prefix}.conv.weight"] = official_dict[f"{src_prefix}.proj.weight"]
+                new_state_dict[f"{dst_prefix}.conv.bias"] = official_dict[f"{src_prefix}.proj.bias"]
+                new_state_dict[f"{dst_prefix}.norm.weight"] = official_dict[f"{src_prefix}.layer_norm.weight"]
+                new_state_dict[f"{dst_prefix}.norm.bias"] = official_dict[f"{src_prefix}.layer_norm.bias"]
+            for block_idx in range(2):
+                src_block = f"segformer.encoder.block.{stage_idx}.{block_idx}"
+                
+                # Efficient Self-Attention
+                dst_attn = f"transformers.{stage_idx}.efficient_self_attns.{block_idx}"
+                new_state_dict[f"{dst_attn}.W_q.weight"] = official_dict[f"{src_block}.attention.self.query.weight"]
+                new_state_dict[f"{dst_attn}.W_q.bias"] = official_dict[f"{src_block}.attention.self.query.bias"]
+                new_state_dict[f"{dst_attn}.W_k.weight"] = official_dict[f"{src_block}.attention.self.key.weight"]
+                new_state_dict[f"{dst_attn}.W_k.bias"] = official_dict[f"{src_block}.attention.self.key.bias"]
+                new_state_dict[f"{dst_attn}.W_v.weight"] = official_dict[f"{src_block}.attention.self.value.weight"]
+                new_state_dict[f"{dst_attn}.W_v.bias"] = official_dict[f"{src_block}.attention.self.value.bias"]
+                new_state_dict[f"{dst_attn}.proj.weight"] = official_dict[f"{src_block}.attention.output.dense.weight"]
+                new_state_dict[f"{dst_attn}.proj.bias"] = official_dict[f"{src_block}.attention.output.dense.bias"]
+
+                # Spatial Reduction (SR)
+                if f"{src_block}.attention.self.sr.weight" in official_dict:
+                    new_state_dict[f"{dst_attn}.sr.weight"] = official_dict[f"{src_block}.attention.self.sr.weight"]
+                    new_state_dict[f"{dst_attn}.sr.bias"] = official_dict[f"{src_block}.attention.self.sr.bias"]
+                    new_state_dict[f"{dst_attn}.norm.weight"] = official_dict[f"{src_block}.attention.self.layer_norm.weight"]
+                    new_state_dict[f"{dst_attn}.norm.bias"] = official_dict[f"{src_block}.attention.self.layer_norm.bias"]
+
+                # MixFFN
+                dst_ffn = f"transformers.{stage_idx}.mix_FFNs.{block_idx}"
+                new_state_dict[f"{dst_ffn}.MLP1.weight"] = official_dict[f"{src_block}.mlp.dense1.weight"]
+                new_state_dict[f"{dst_ffn}.MLP1.bias"] = official_dict[f"{src_block}.mlp.dense1.bias"]
+                new_state_dict[f"{dst_ffn}.conv33.weight"] = official_dict[f"{src_block}.mlp.dwconv.dwconv.weight"]
+                new_state_dict[f"{dst_ffn}.conv33.bias"] = official_dict[f"{src_block}.mlp.dwconv.dwconv.bias"]
+                new_state_dict[f"{dst_ffn}.MLP2.weight"] = official_dict[f"{src_block}.mlp.dense2.weight"]
+                new_state_dict[f"{dst_ffn}.MLP2.bias"] = official_dict[f"{src_block}.mlp.dense2.bias"]
+
+        missing, unexpected = self.model.load_state_dict(new_state_dict, strict=False)
+        print(f"Loading successful ! Missing keys : {len(missing)}, Weird keys : {len(unexpected)}")
+        return self.model

{openmlcore-1.0.0 → openmlcore-1.2.0}/src/openmlcore/models/unetpp.py

@@ -7,7 +7,7 @@ from .lib.convolutions import DoubleConv
 class UnetPPTorch(nn.Module):
     def __init__(self, input_channels=1, output_channels=1, depth=4, initial_filters=64,
                  kernel_size=3, padding=1):
-        super(UnetPPTorch, self).__init__()
+        super(UnetPPTorch, self).__init__(name= "Unet++")
         self.depth = depth
         self.downs      = nn.ModuleList()
         self.inter_down = nn.ModuleList()

{openmlcore-1.0.0 → openmlcore-1.2.0/src/openmlcore.egg-info}/PKG-INFO

@@ -1,43 +1,20 @@
 Metadata-Version: 2.4
 Name: openmlcore
-Version: 1.0.0
+Version: 1.2.0
 Summary: OpenMLCore is an open source framework (wrapper which simplify the use of PyTorch)
 Author-email: Doyez Sébastien <doyez.sebastien34090@gmail.com>
-License: MIT License
-        
-        Copyright (c) 2026 Votre Nom
-        
-        Permission is hereby granted, free of charge, to any person obtaining a copy
-        of this software and associated documentation files (the "Software"), to deal
-        in the Software without restriction, including without limitation the rights
-        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-        copies of the Software, and to permit persons to whom the Software is
-        furnished to do so, subject to the following conditions:
-        
-        The above copyright notice and this permission notice shall be included in all
-        copies or substantial portions of the Software.
-        
-        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-        SOFTWARE.
 Project-URL: Homepage, https://sebastien-doyez2812.github.io/openMLCore.github.io/
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Requires-Python: >=3.10.0
 Description-Content-Type: text/markdown
-License-File: LICENSE
 Requires-Dist: torch
 Requires-Dist: tqdm
 Requires-Dist: onnx
 Requires-Dist: onnxscript
 Requires-Dist: torchinfo
 Requires-Dist: datasets
-Dynamic: license-file
 
 # OpenML-core, Open source Package for Machine learning
 

{openmlcore-1.0.0 → openmlcore-1.2.0}/src/openmlcore.egg-info/SOURCES.txt

@@ -1,4 +1,3 @@
-LICENSE
 README.md
 pyproject.toml
 src/openmlcore/__init__.py
@@ -10,9 +9,11 @@ src/openmlcore.egg-info/top_level.txt
 src/openmlcore/base/data.py
 src/openmlcore/loss/loss.py
 src/openmlcore/metrics/metrics.py
+src/openmlcore/models/MobileUnetR.py
 src/openmlcore/models/UNets.py
 src/openmlcore/models/attUnets.py
 src/openmlcore/models/base_model.py
+src/openmlcore/models/segformer.py
 src/openmlcore/models/unetpp.py
 src/openmlcore/models/lib/attention.py
 src/openmlcore/models/lib/convolutions.py

{openmlcore-1.0.0 → openmlcore-1.2.0}/tests/test_base_model.py

@@ -1,11 +1,17 @@
+import sys
 import pytest
 import torch
 import torch.nn as nn
 from torch.utils.data import DataLoader
 from torchgen import model
 from torchgen import model
-from openmlcore.models.base_model import *
-from openmlcore.metrics.metrics import *
+
+from pathlib import Path
+root_dir = Path(__file__).resolve().parent.parent
+sys.path.append(str(root_dir))
+
+from src.openmlcore.models.base_model import *
+from src.openmlcore.metrics.metrics import *
 
 # class DummyModel(BaseModel):
 #     def __init__(self):

openmlcore-1.2.0/tests/test_loss.py

@@ -0,0 +1,26 @@
+import sys
+from pathlib import Path
+root_dir = Path(__file__).resolve().parent.parent
+sys.path.append(str(root_dir))
+
+from src.openmlcore.loss.loss import *
+
+def test_BCEWithLogits_loss():
+    loss = BCEWithLogitsLoss(weights = [1.0])
+    assert loss is not None
+
+def test_mean_squared_error_loss():
+    loss = MeanSquaredErrorLoss(weights = [1.0])
+    assert loss is not None
+
+def test_dice_loss():
+    loss = DiceLoss(weights = [1.0])
+    assert loss is not None
+
+def test_focal_loss():
+    loss = FocalLoss(weights = [1.0])
+    assert loss is not None
+
+def test_huber_loss():
+    loss = HuberLoss(weights = [1.0])
+    assert loss is not None    

openmlcore-1.0.0/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2026 Votre Nom
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

openmlcore-1.0.0/tests/test_loss.py

@@ -1,27 +0,0 @@
-from openmlcore.loss.loss import *
-
-def test_BCEWithLogits_loss():
-    loss = BCEWithLogitsLoss()
-    assert loss is not None
-
-def test_mean_squared_error_loss():
-    loss = MeanSquaredErrorLoss()
-    assert loss is not None
-
-def test_dice_loss():
-    loss = DiceLoss()
-    assert loss is not None
-
-def test_focal_loss():
-    loss = FocalLoss()
-    assert loss is not None
-
-def test_huber_loss():
-    loss = HuberLoss()
-    assert loss is not None
-
-def test_kl_divergence_loss():
-    loss = KLDivergenceLoss()
-    assert loss is not None
-
-