openmlcore 1.1.0__tar.gz → 2.0.0__tar.gz

{openmlcore-1.1.0 → openmlcore-2.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openmlcore
-Version: 1.1.0
+Version: 2.0.0
 Summary: OpenMLCore is an open source framework (wrapper which simplify the use of PyTorch)
 Author-email: Doyez Sébastien <doyez.sebastien34090@gmail.com>
 Project-URL: Homepage, https://sebastien-doyez2812.github.io/openMLCore.github.io/
@@ -25,23 +25,21 @@ Today's computer vision ecosystem is heavily fragmented. If you want YOLO, Ultra
 OpenML bridges this gap by bringing a clean, Hugging Face-inspired Developer Experience (DX) to advanced computer vision tasks—from classical models to SOTA transformers and parameter-efficient fine-tuning.
 ## Supported Architectures:
 
-- Classic & Deep Segmentation: U-Net, Attention U-Net, UNet++, Mask R-CNN
+- Classic & Deep Segmentation: U-Net, Attention U-Net, UNet++
 
-- Advanced Transformers: Swin Transformer, TransUNet, MobileUNetR
+- Advanced Transformers: MobileUnetR, SegFormer
 
-- SOTA & Edge: Vision Transformers, SAM 2 adaptations via efficient Low-Rank Adaptation (LoRA)
+- SOTA & Edge: Vision Transformers, SAM 2 adaptations via efficient Low-Rank Adaptation (LoRA) (Coming soon)
 ## Key features:
 
 Unified Object-Oriented API: Every model inherits from a clean ModelBase class supporting standard .train(), .eval(), and .help() workflows.
 
-Native LoRA Wrappers: Fine-tune massive vision models and transformers on modest hardware (like a single RTX 3070) without blowing up your VRAM.
+Native LoRA Wrappers: Fine-tune massive vision models and transformers on modest hardware (like a single RTX 3070) without blowing up your VRAM. (Coming soonn)
 
-Hugging Face Hub Integration: Push and pull checkpoints effortlessly using native .safetensors formatting.
+Hugging Face pretrained weights availablle
 
 MLflow Tracking Out-of-the-Box: Keep tabs on your losses, metrics, and hyperparameter logs without writing boilerplate monitoring code.
 
-Interactive Help System: Running model.help() directly opens up the exact architectural documentation page on the web.
-
 ## Contributions:
 
 Contributions, feature requests, and bug reports are welcome! Feel free to open an Issue or submit a Pull Request on GitHub.

{openmlcore-1.1.0 → openmlcore-2.0.0}/README.md

@@ -7,23 +7,21 @@ Today's computer vision ecosystem is heavily fragmented. If you want YOLO, Ultra
 OpenML bridges this gap by bringing a clean, Hugging Face-inspired Developer Experience (DX) to advanced computer vision tasks—from classical models to SOTA transformers and parameter-efficient fine-tuning.
 ## Supported Architectures:
 
-- Classic & Deep Segmentation: U-Net, Attention U-Net, UNet++, Mask R-CNN
+- Classic & Deep Segmentation: U-Net, Attention U-Net, UNet++
 
-- Advanced Transformers: Swin Transformer, TransUNet, MobileUNetR
+- Advanced Transformers: MobileUnetR, SegFormer
 
-- SOTA & Edge: Vision Transformers, SAM 2 adaptations via efficient Low-Rank Adaptation (LoRA)
+- SOTA & Edge: Vision Transformers, SAM 2 adaptations via efficient Low-Rank Adaptation (LoRA) (Coming soon)
 ## Key features:
 
 Unified Object-Oriented API: Every model inherits from a clean ModelBase class supporting standard .train(), .eval(), and .help() workflows.
 
-Native LoRA Wrappers: Fine-tune massive vision models and transformers on modest hardware (like a single RTX 3070) without blowing up your VRAM.
+Native LoRA Wrappers: Fine-tune massive vision models and transformers on modest hardware (like a single RTX 3070) without blowing up your VRAM. (Coming soonn)
 
-Hugging Face Hub Integration: Push and pull checkpoints effortlessly using native .safetensors formatting.
+Hugging Face pretrained weights availablle
 
 MLflow Tracking Out-of-the-Box: Keep tabs on your losses, metrics, and hyperparameter logs without writing boilerplate monitoring code.
 
-Interactive Help System: Running model.help() directly opens up the exact architectural documentation page on the web.
-
 ## Contributions:
 
 Contributions, feature requests, and bug reports are welcome! Feel free to open an Issue or submit a Pull Request on GitHub.

{openmlcore-1.1.0 → openmlcore-2.0.0}/pyproject.toml

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

openmlcore-2.0.0/src/openmlcore/base/data3d.py

@@ -0,0 +1,174 @@
+"""
+Author: Seb Doyez
+
+3D dataset should be a folder, where inside we can find subfolder corresponding to a scene
+1 scene = 1 subfolder
+Inside a subfolder, there qre .pcd and ..._label.txt
+
+"""
+
+import torch
+import torch.nn as nn
+from torch.utils.data import Dataset
+import numpy as np
+import os
+
+class Segmentation3dDataset(Dataset):
+    def __init__(self, dataset_path, num_points = 2048, split="train"):
+        super().__init__()
+        self.num_points = num_points     
+        self.dataset_path = dataset_path
+
+        self.scene_dirs = self._get_object_paths(self.dataset_path) # Only treat the airplane!
+        total_data = len(self.scene_dirs)
+        split_idx = int(total_data * 0.8)
+        if split.lower() == "train":
+            self.scene_dirs = self.scene_dirs[:split_idx]
+        else: 
+            self.scene_dirs = self.scene_dirs[split_idx:]
+
+    def _get_object_paths(self, dataset_path):
+        # Dataset should be like:
+        # subfolders, and inside, you will find a .pcd and the _label.txt 
+        # .pcd is the point cloud and _label.txt is the label
+        # Label goes from 1 to n ( number of classes)
+                
+        object_paths = []
+        for dirpath, dirnames, filenames in os.walk(dataset_path):
+            for file in filenames:
+                if file.endswith(".pcd"):
+                    base_path = os.path.join(dirpath, file.replace(".pcd", ""))
+                    if os.path.exists(base_path +"_label.txt"):
+                        object_paths.append(base_path)
+        return object_paths
+                    
+
+    def _load_scene_data(self, scene_base_path):
+        label_path = scene_base_path + "_label.txt"
+        pcd_path   = scene_base_path + ".pcd"
+
+        if not os.path.exists(label_path):
+            raise FileNotFoundError(f"No labels found for {label_path}")    
+
+        
+        if not os.path.exists(pcd_path):
+            raise FileNotFoundError(f"No PCD found for {pcd_path}")
+
+        with open(pcd_path, 'rb') as f:
+            header = []
+            data_type = 'ascii'
+            num_pts = 0
+            fields = []
+            sizes = []
+            types = []
+                
+            # Skip the header
+            while True:
+                line_bytes = f.readline()
+                if not line_bytes:
+                    break
+                line = line_bytes.decode('latin-1')
+                header.append(line)
+                if line.startswith("DATA"):
+                    parts = line.strip().split()
+                    if len(parts) > 1:
+                        data_type = parts[1]
+                    break
+            
+            for line in header:
+                if line.startswith("POINTS"):
+                    num_pts = int(line.strip().split()[1])
+                elif line.startswith("WIDTH") and num_pts == 0:
+                    num_pts = int(line.strip().split()[1])
+                elif line.startswith("FIELDS"):
+                    fields = line.strip().split()[1:]
+                elif line.startswith("SIZE"):
+                    sizes = [int(s) for s in line.strip().split()[1:]]
+                elif line.startswith("TYPE"):
+                    types = line.strip().split()[1:]
+
+            # Loading the data:
+            if data_type.lower() == 'ascii':
+                points_data = np.loadtxt(f, encoding="latin-1")
+                points = points_data[:, :3]
+            else:
+                binary_data = f.read()
+                try:
+                    dt_list = []
+                    for field, size, t in zip(fields, sizes, types):
+                        if t == 'F':
+                            np_t = np.float32 if size == 4 else np.float64
+                        elif t in ['I', 'U']:
+                            np_t = np.int32 if size == 4 else (np.int16 if size == 2 else np.int8)
+                        else:
+                            np_t = np.float32
+                        dt_list.append((field, np_t))
+                        
+                    dt = np.dtype(dt_list)
+                    data = np.frombuffer(binary_data, dtype=dt, count=num_pts)
+                    points = np.stack([data['x'], data['y'], data['z']], axis=-1)
+                except Exception:
+                    raw_data = np.frombuffer(binary_data, dtype=np.float32)
+                    stride = len(raw_data) // num_pts
+                    points = raw_data.reshape(num_pts, stride)[:, :3]
+
+        # Loading the labels
+        labels = np.loadtxt(label_path, dtype=np.int64, encoding="latin-1")
+        
+        assert len(points) == len(labels), f"[-] Error, number of points mismatch: {len(points)} pts vs {len(labels)} labels."
+
+        return points, labels
+
+    def _normalize_point_cloud(self, points):
+        centroid = np.mean(points, axis=0)
+        points_centered = points - centroid
+
+        max_dist = np.max(np.sqrt(np.sum(points_centered ** 2, axis=1)))
+
+        if max_dist > 0:
+            points_normalized = points_centered / max_dist
+        else:
+            points_normalized = points_centered
+
+        return points_normalized
+
+    def __len__(self):
+        return len(self.scene_dirs)
+
+    def __getitem__(self, idx):
+        scene_path = self.scene_dirs[idx]
+        points, labels = self._load_scene_data(scene_path)
+
+        totals_pts = points.shape[0] 
+        if totals_pts >= self.num_points:
+            # Block_sampling:
+            center_idx = np.random.choice(points.shape[0])
+            center = points[center_idx]
+
+            radius = 1.5
+            distances = np.sqrt(np.sum((points - center) ** 2, axis = 1))
+
+            mask = distances < radius
+            block_points = points[mask]
+            block_labels = labels[mask]
+
+            total_pts = block_points.shape[0]
+            if total_pts >= self.num_points:
+                choice = np.random.choice(total_pts, self.num_points, replace=False)
+            else:
+                choice = np.random.choice(total_pts, self.num_points, replace=True)
+
+            points_sampled = block_points[choice]
+            labels_sampled = block_labels[choice]
+
+        else:
+            choice = np.random.choice(totals_pts, self.num_points, replace=True)
+            points_sampled = points[choice]
+            labels_sampled = labels[choice]
+                    
+        points_normalized =  self._normalize_point_cloud(points_sampled)
+        points_tensor = torch.tensor(points_normalized, dtype=torch.float32).transpose(1, 0)
+        labels_tensor = torch.tensor(labels_sampled - 1, dtype=torch.long)
+
+        return points_tensor, labels_tensor
+           

{openmlcore-1.1.0 → openmlcore-2.0.0}/src/openmlcore/loss/loss.py

@@ -7,12 +7,16 @@ class BaseLoss(nn.Module):
     def __init__(self, name: str = "BaseLoss", doc_url: str = ""):
         super().__init__()
         self.name = name
+        self.type = "segmetation2d"
         self.smooth = 1e-6
         self.doc_url = doc_url
 
     def forward(self, outputs: torch.Tensor, targets: torch.Tensor) -> torch.Tensor:
         raise NotImplementedError("Subclasses should implement this method.")
 
+    def get_type(self):
+        return self.type
+        
     def documentation(self) -> str:
         print(f"Documentation for {self.name} is available here:\n{self.doc_url}")
         try:
@@ -22,13 +26,16 @@ class BaseLoss(nn.Module):
             print(f"[-] {e}")
 
     
-#############################
-#   Class Loss Functions    #
-#############################
+################################################
+#   Class Loss Functions for 2d Segmentation   #
+################################################
 
 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 +55,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 +81,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 +149,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     #
 ####################################
@@ -207,4 +193,10 @@ class CustomLoss(BaseLoss):
         for loss_fn, coef in zip(self.loss_fcns, self.coefficients):
             total_loss += coef * loss_fn(outputs, targets)
         return total_loss
-    
+
+
+
+
+################################################
+#   Class Loss Functions for 3d Segmentation   #
+################################################

openmlcore-2.0.0/src/openmlcore/loss/loss3d.py

@@ -0,0 +1,92 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+class Base3dLoss(nn.Module):
+    def __init__(self, name: str= "BaseLoss3d", doc_url:str= ""):
+        super().__init__()
+        self.name = name
+        self.type = "segmentation3d"
+        self.smooth = 1e-6
+        self.doc_url = doc_url
+
+    def get_type(self):
+        return self.type
+
+    def forward(self, outputs: torch.Tensor, targets: torch.Tensor):
+        raise NotImplementedError("Subclasses should implement this method.")
+
+    def documentation(self) -> str:
+        print(f"Documentation available here:{self.doc_url}")
+        try:
+            import webbrowser
+            webbrowser.open(self.doc_url)
+        except Exception as e:
+            print(f"[-] {e}")
+
+
+class CustomLoss3d(Base3dLoss):
+    def __init__(self, loss_fcns: list[Base3dLoss], name: str, coefficients: list[float]):
+        assert len(loss_fcns) == len(coefficients), "The number of loss functions must match the number of coefficients."
+        super().__init__(name=name, doc_url=None)
+        self.loss_fcns = nn.ModuleList(loss_fcns)
+        self.coefficients = coefficients
+
+    def forward(self, outputs: torch.Tensor, targets: torch.Tensor) -> torch.Tensor:
+        total_loss = 0.0
+        for loss_fn, coef in zip(self.loss_fcns, self.coefficients):
+            total_loss += coef * loss_fn(outputs, targets)
+        return total_loss
+
+
+
+
+class CrossEntropyLoss(Base3dLoss):
+    def __init__(self, name = "CrossEntropy", weights = None, doc_url = ""):
+        super().__init__(name, doc_url)
+        self.weights = weights
+
+        device = "cuda" if torch.cuda.is_available() else "cpu"
+    
+        pos_weights = None
+        if weights is not None:
+            if not isinstance(weights, torch.Tensor):
+                pos_weights = torch.tensor(weights, device=device, dtype=torch.float32)
+            else:
+                pos_weights = weights.to(device)
+
+        self.loss_fn = nn.CrossEntropyLoss(weight=pos_weights)
+        
+    def forward(self, outputs: torch.Tensor, targets: torch.Tensor):
+        return self.loss_fn(outputs, targets.long())
+
+class DiceLoss3d(Base3dLoss):
+    def __init__(self, weights = None):
+        super().__init__(name="DiceLoss3d")
+        if weights is None:
+            raise ValueError("weights need to be set!")
+
+        device = "cuda" if torch.cuda.is_available() else "cpu"
+
+        if not isinstance(weights, torch.Tensor):
+            self.weights = torch.tensor(weights, device=device, dtype=torch.float32)
+        else:
+            self.weights = weights.to(device)
+
+    def forward(self, outputs, targets):
+        probs = F.softmax(outputs, dim=1)
+        B, C, N = probs.shape
+
+        targets_one_hot = F.one_hot(targets.long(), num_classes=C)
+        targets_one_hot = targets_one_hot.permute(0, 2, 1).float()
+
+        intersection = torch.sum(probs * targets_one_hot, dim=(0, 2))
+        union = torch.sum(probs + targets_one_hot, dim=(0, 2))
+
+        dice_score = (2.0 * intersection) / (self.smooth + union)
+
+        dice_loss = 0
+        for idx_class, weight in enumerate(self.weights):
+            dice_loss += weight * (1 - dice_score[idx_class])
+
+        return dice_loss

openmlcore-2.0.0/src/openmlcore/metrics/metrics3d.py

@@ -0,0 +1,119 @@
+import numpy as np
+import torch 
+
+def iou3d(preds, targets):
+    num_batches = preds.shape[0]
+    num_classes = preds.shape[1]  
+
+    metric_to_return = [0.0] * num_classes
+    valid_batches_per_class = [0] * num_classes 
+
+    for idx_current_batch in range(num_batches):
+        for idx_class in range(num_classes):
+            pred = preds[idx_current_batch, idx_class]
+            gt = targets[idx_current_batch, idx_class]
+
+            pred_mask = (pred > 0.5)
+            gt_mask = (gt > 0.5)
+
+            intersection = torch.logical_and(pred_mask, gt_mask).sum().item()
+            union = torch.logical_or(pred_mask, gt_mask).sum().item()
+
+            if union > 0:
+                iou = intersection / union
+                metric_to_return[idx_class] += iou
+                valid_batches_per_class[idx_class] += 1
+
+    final_metric = []
+    for i in range(num_classes):
+        if valid_batches_per_class[i] > 0:
+            final_metric.append(metric_to_return[i] / valid_batches_per_class[i])
+        else:
+            final_metric.append(float('nan')) 
+
+    return final_metric
+
+def accuracy3d(preds, targets):
+    num_batches = preds.shape[0]
+    num_classes = preds.shape[1]  
+
+    metrics_to_return = [0.0] * num_classes
+    valid_batches_per_class = [0] * num_classes 
+
+    for idx_current_batch in range(num_batches):
+        pred_batch = preds[idx_current_batch] 
+        
+        if targets.ndim == preds.ndim:
+            target_batch = targets[idx_current_batch] # Shape: (C, ...)
+        else:
+            target_indices = targets[idx_current_batch] # Shape: (...)
+
+        for idx_class in range(num_classes):
+            pred = pred_batch[idx_class]
+            pred_mask = (pred > 0.5) 
+
+            if targets.ndim == preds.ndim:
+                gt_mask = (target_batch[idx_class] > 0.5)
+            else:
+                gt_mask = (target_indices == idx_class)
+
+            correct = torch.sum(pred_mask == gt_mask).item()
+            total = gt_mask.numel()
+            
+            if total > 0:
+                current_acc = correct / total
+                metrics_to_return[idx_class] += current_acc
+                valid_batches_per_class[idx_class] += 1
+
+    final_metric = []
+    for i in range(num_classes):
+        if valid_batches_per_class[i] > 0:
+            final_metric.append(metrics_to_return[i] / valid_batches_per_class[i])
+        else:
+            final_metric.append(float('nan')) 
+
+    return final_metric
+
+def Precision3d(preds, labels, nb_classes):
+    pred_flatten = preds.flatten()
+    label_flatten = labels.flatten()
+
+    precision_tab = []
+    for idx_class in range(1, nb_classes+1):
+        TP = np.sum((pred_flatten == idx_class) & (label_flatten == idx_class))
+        FP = np.sum((pred_flatten == idx_class) & (label_flatten != idx_class))
+        if (TP + FP) == 0:
+            precision_tab.append(0.0)
+        else:
+            precision_tab.append(TP/(TP+FP))
+
+    return precision_tab
+
+def Recall3d(preds, labels, nb_classes):
+    pred_flatten = preds.flatten()
+    label_flatten = labels.flatten()
+
+    precision_tab = []
+    for idx_class in range(1, nb_classes+1):
+        TP = np.sum((pred_flatten == idx_class) & (label_flatten == idx_class))
+        FN = np.sum((pred_flatten != idx_class) & (label_flatten == idx_class))
+        if (TP + FN) == 0:
+            precision_tab.append(0.0)
+        else:
+            precision_tab.append(TP/(TP+FN))
+
+    return precision_tab
+
+
+def F13d(preds, labels, nb_classes):
+    current_prec = Precision3d(preds, labels, nb_classes)
+    current_recall = Recall3d(preds, labels, nb_classes)
+
+    f1_scores = []
+    for idx_class in range(nb_classes):
+        if current_prec[idx_class] + current_recall[idx_class] == 0:
+            f1_scores.append(0.0)
+        else:
+            f1_scores.appennd(2* (current_prec[idx_class] * current_recall[idx_class])/ (current_prec[idx_class] + current_recall[idx_class]))
+
+    return f1_scores