openmlcore 1.2.0__tar.gz → 2.0.1__tar.gz

{openmlcore-1.2.0 → openmlcore-2.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openmlcore
-Version: 1.2.0
+Version: 2.0.1
 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.2.0 → openmlcore-2.0.1}/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.2.0 → openmlcore-2.0.1}/pyproject.toml

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

openmlcore-2.0.1/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.2.0 → openmlcore-2.0.1}/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,9 +26,9 @@ class BaseLoss(nn.Module):
             print(f"[-] {e}")
 
     
-#############################
-#   Class Loss Functions    #
-#############################
+################################################
+#   Class Loss Functions for 2d Segmentation   #
+################################################
 
 class BCEWithLogitsLoss(BaseLoss):
     def __init__(self, weights=None):
@@ -189,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.1/src/openmlcore/loss/loss3d.py

@@ -0,0 +1,95 @@
+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
+
+        if targets.min() < -1 or targets.max() > C:
+            raise ValueError("target at -1")
+
+        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.1/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

openmlcore-2.0.1/src/openmlcore/models/lib/tnet.py

@@ -0,0 +1,43 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+class Tnet(nn.Module):
+    def __init__(self, input_dim, output_dim):
+        super(Tnet, self).__init__()
+
+        self.input_dim = input_dim
+        self.output_dim = output_dim
+
+        # Shared MLP layer = con1d
+        self.conv1 = nn.Conv1d(self.input_dim, 64, 1)
+        self.conv2 = nn.Conv1d(64, 128, 1)
+        self.conv3 = nn.Conv1d(128, 256, 1)
+
+        self.batch_norm1 = nn.BatchNorm1d(64)
+        self.batch_norm2 = nn.BatchNorm1d(128)
+        self.batch_norm3 = nn.BatchNorm1d(256)
+        self.batch_norm4 = nn.BatchNorm1d(128)
+        self.batch_norm5 = nn.BatchNorm1d(64)
+
+        self.fc1 = nn.Linear(256, 128)
+        self.fc2 = nn.Linear(128, 64)
+        self.fc3 = nn.Linear(64, self.output_dim * self.output_dim)
+        
+    def forward(self, x):
+        batch_size = x.shape[0]
+
+        x = F.relu(self.batch_norm1(self.conv1(x)))
+        x = F.relu(self.batch_norm2(self.conv2(x)))
+        x = F.relu(self.batch_norm3(self.conv3(x)))
+
+        x = torch.max(x, dim=2)[0]
+        x = x.view(-1, 256)
+
+        x = F.relu(self.batch_norm4(self.fc1(x)))
+        x = F.relu(self.batch_norm5(self.fc2(x)))
+        x = self.fc3(x)
+
+        identity_matrix = torch.eye(self.output_dim, device=x.device).unsqueeze(0).repeat(batch_size, 1, 1) # (B, output_dim, output_dim)
+        x = x.view(-1, self.output_dim, self.output_dim) + identity_matrix
+        return x

openmlcore-2.0.1/src/openmlcore/models/pointNetPP.py

@@ -0,0 +1,209 @@
+# PointNet++
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from .base_model import BaseModel
+
+def furthest_point_sample(xyz, npoint):
+    device = xyz.device
+    B, N, C = xyz.shape
+
+    centroids = torch.zeros(B, npoint, dtype=torch.long, device=device)
+    distance = torch.ones(B, N, device=device) * 1e10
+    farthest = torch.randint(0, N, (B,), dtype=torch.long, device=device)
+    batch_indices = torch.arange(B, dtype=torch.long, device=device)
+
+    for i in range(npoint):
+        centroids[:, i] = farthest
+        centroid = xyz[batch_indices, farthest, :].view(B, 1, 3)
+        dist = torch.sum((xyz - centroid) ** 2, dim=-1)
+        mask = dist < distance
+        distance = torch.where(mask, dist, distance)
+        farthest = torch.max(distance, dim=-1)[1]
+
+    return centroids
+
+def query_ball_points(radius, nsample, xyz, new_xyz):
+    device  = xyz.device
+    B, N, C = xyz.shape
+    _, S, _ = new_xyz.shape
+    group_idx = torch.arange(N, dtype=torch.long, device=device).view(1, 1, N).repeat([B, S, 1])
+    
+    sqrdists = square_distance(new_xyz, xyz) 
+    mask = sqrdists > radius ** 2
+    group_idx = torch.where(mask, torch.tensor(N, device=device, dtype=torch.long), group_idx)
+
+    group_idx = group_idx.sort(dim=-1)[0][:, :, :nsample]
+    
+    group_first = group_idx[:, :, 0].view(B, S, 1).repeat([1, 1, nsample])
+    mask = group_idx == N
+    group_idx = torch.where(mask, group_first, group_idx)
+    
+    return group_idx
+
+def square_distance(src, dst):
+    B, N, _ = src.shape
+    _, M, _ = dst.shape
+
+    dist = -2 * torch.matmul(src, dst.permute(0, 2, 1))
+    head = torch.sum(src ** 2, dim= -1, keepdim=True)
+    tail = torch.sum(dst ** 2, dim=-1, keepdim=True).permute(0, 2, 1)
+
+    return dist + head + tail
+
+def index_points(points, idx):
+    device = points.device
+    B = points.shape[0]
+
+    view_shape = list(idx.shape)
+    view_shape[1:] = [1] * (len(view_shape) - 1)
+    repeat_shape = list(idx.shape)
+    repeat_shape[0] = 1
+
+    batch_indices = torch.arange(B, dtype=torch.long, device=device).view(view_shape).repeat(repeat_shape)
+    new_points = points[batch_indices, idx, :]  
+    return new_points
+
+class SetAbstraction(nn.Module):
+    def __init__(self, npoints, radius, nsample, in_channel, mlp ):
+        super().__init__()
+        self.npoints = npoints
+        self.radius = radius
+        self.nsample = nsample
+        self.inchannel = in_channel
+
+        self.mlp_convs = nn.ModuleList()
+        self.mlp_bns = nn.ModuleList()
+        last_channel = 3 if in_channel == 3 else in_channel + 3
+
+        for out_channel in mlp:
+            self.mlp_convs.append(nn.Conv2d(last_channel, out_channel, 1))
+            self.mlp_bns.append(nn.BatchNorm2d(out_channel))
+            last_channel = out_channel
+
+    def forward(self, xyz, points):
+        centroid_idx = furthest_point_sample(xyz, self.npoints)
+        new_xyz = index_points(xyz, centroid_idx)
+
+        group_idx = query_ball_points(self.radius, self.nsample, xyz, new_xyz)
+        grouped_xyz = index_points(xyz, group_idx)
+        grouped_xyz_norm = grouped_xyz - new_xyz.unsqueeze(2)
+
+        if points is not None:
+            grouped_points = index_points(points, group_idx)
+            new_points = torch.cat([grouped_xyz_norm, grouped_points], dim=-1)
+        else:
+            new_points = grouped_xyz_norm
+
+        new_points = new_points.permute(0, 3, 1, 2)
+        for conv, bn in zip(self.mlp_convs, self.mlp_bns):
+            new_points = F.relu(bn(conv(new_points)))
+
+        new_points = torch.max(new_points, dim=-1)[0]
+        new_points = new_points.permute(0, 2, 1)
+        return new_xyz, new_points
+
+class FeaturePropagation(nn.Module):
+    def __init__(self, in_channel, mlp):
+        super().__init__()
+        self.mlp_convs = nn.ModuleList()
+        self.mlp_bns = nn.ModuleList()
+
+        last_channel = in_channel
+        for out_channel in mlp:
+            self.mlp_convs.append(nn.Conv1d(last_channel, out_channel, 1))
+            self.mlp_bns.append(nn.BatchNorm1d(out_channel))
+            last_channel = out_channel
+
+    def forward(self, xyz1, xyz2, points1, points2):
+        # xyz2 has the less points/ low resolution
+        # xyz1 has a higher resolution
+        # points1: skip connection
+        # points2: features of the previous layers, shape = B, S, C2
+
+        B, N, C = xyz1.shape
+        _, S, _ = xyz2.shape
+
+        if S == 1:
+            interpolated_points = points2.repeat(1, N, 1) 
+        else:
+            # Search for the 3 closers points in xyz2
+            dists = square_distance(xyz1, xyz2) # (B, N, S)
+            dists, idx = torch.topk(dists, 3, dim=-1, largest=False, sorted=True)
+
+            weights = 1.0 / (dists + 1e-8)
+            weight = weights / torch.sum(weights, dim=-1, keepdim=True) #(B, N, 3)
+
+            interpolated_points = torch.sum(index_points(points2, idx) * weight.view(B, N, 3, 1), dim=2)
+            if points1 is not None:
+                new_points = torch.cat([points1, interpolated_points], dim=-1)
+            else:
+                new_points = interpolated_points
+
+            new_points = new_points.permute(0, 2, 1)
+            for conv, bn in zip(self.mlp_convs, self.mlp_bns):
+                new_points = F.relu(bn(conv(new_points)))
+            
+            return new_points.permute(0, 2, 1)
+
+
+class PointNetPPSemSegTorch(nn.Module):
+    def __init__(self, num_classes):
+        super().__init__()
+        
+        # --- ENCODER (Set Abstraction ) ---
+        self.sa1 = SetAbstraction(npoints=1024, radius=0.1, nsample=32, in_channel=3, mlp=[32, 32, 64])
+        self.sa2 = SetAbstraction(npoints=256, radius=0.2, nsample=32, in_channel=64, mlp=[64, 64, 128])
+        self.sa3 = SetAbstraction(npoints=64, radius=0.4, nsample=32, in_channel=128, mlp=[128, 128, 256])
+        self.sa4 = SetAbstraction(npoints=16, radius=0.8, nsample=32, in_channel= 256, mlp=[256, 256, 512]) # Version sans features initiales directes (in_channel implicite)
+        
+        # --- DECODER (Feature Propagation) ---
+        # Remonte progressivement de 16 -> 64 -> 256 -> 1024 -> N points d'origine
+        self.fp4 = FeaturePropagation(in_channel=512 + 256, mlp=[256, 256])
+        self.fp3 = FeaturePropagation(in_channel=256 + 128, mlp=[256, 256])
+        self.fp2 = FeaturePropagation(in_channel=256 + 64, mlp=[256, 128])
+        self.fp1 = FeaturePropagation(in_channel=128 + 3, mlp=[128, 128, 128])
+        
+        # --- TÊTE DE CLASSIFICATION PAR POINT ---
+        self.conv1 = nn.Conv1d(128, 128, 1)
+        self.bn1 = nn.BatchNorm1d(128)
+        self.drop = nn.Dropout(0.5)
+        self.conv2 = nn.Conv1d(128, num_classes, 1)
+
+    def forward(self, xyz):
+        if xyz.shape[1] == 3:
+            xyz = xyz.permute(0, 2, 1)
+
+        l0_xyz = xyz
+        l0_points = None
+        
+        # 1. Encoder
+        l1_xyz, l1_points = self.sa1(l0_xyz, l0_points)
+        l2_xyz, l2_points = self.sa2(l1_xyz, l1_points)
+        l3_xyz, l3_points = self.sa3(l2_xyz, l2_points)
+        l4_xyz, l4_points = self.sa4(l3_xyz, l3_points)
+        
+        # 2. Décoder (Propagation of features + Skip Connections)
+        l3_points = self.fp4(l3_xyz, l4_xyz, l3_points, l4_points)
+        l2_points = self.fp3(l2_xyz, l3_xyz, l2_points, l3_points)
+        l1_points = self.fp2(l1_xyz, l2_xyz, l1_points, l2_points)
+        l0_points = self.fp1(l0_xyz, l1_xyz, l0_xyz, l1_points) # Skip to the origin cloud l0_xyz
+        
+        # 3. Final classification
+        net = l0_points.permute(0, 2, 1) # (B, C, N) for Conv1d
+        net = F.relu(self.bn1(self.conv1(net)))
+        net = self.drop(net)
+        logits = self.conv2(net) # (B, num_classes, N)
+        
+        return logits #.permute(0, 2, 1) # return (B, N, num_classes)
+
+
+class PointNetPP(BaseModel):
+    def __init__(self, output_channels=1, **kwargs):
+        super().__init__(name="PointNet++", **kwargs)
+        self.output_channels = output_channels
+
+    def create_model(self):
+        self.model = PointNetPPSemSegTorch( num_classes= self.output_channels )
+        return self.model

openmlcore-2.0.1/src/openmlcore/models/pointnet.py

@@ -0,0 +1,62 @@
+from .lib.tnet import Tnet
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from .base_model import BaseModel
+
+class PointNetTorch(nn.Module):
+    def __init__(self, input_dims= 3, output_dims=13):
+        super().__init__()
+        self.input_dims = input_dims
+        self.output_dims = output_dims
+        self.tnet1 = Tnet(3, 3)
+        self.tnet2 = Tnet(64, 64)
+
+        self.conv1 = nn.Conv1d(3, 64, kernel_size=1)
+        self.conv2 = nn.Conv1d(64, 1024, kernel_size=1)
+        self.conv3 = nn.Conv1d(1088, 128, kernel_size=1) # 1024 (global) + 64 (local)
+        self.conv4 = nn.Conv1d(128, self.output_dims, kernel_size=1)
+
+        self.bn1 = nn.BatchNorm1d(64)
+        self.bn2 = nn.BatchNorm1d(1024)
+        self.bn3 = nn.BatchNorm1d(128)
+
+    def forward(self, x):
+        batch_size, _, num_pts = x.shape
+
+        trans1 = self.tnet1(x)                                    # (B, 3, 3)
+        skipped_x1 = x.transpose(2, 1)                            # (B, N, 3) 
+        x = torch.bmm(skipped_x1, trans1)                         # (B, N, 3) x (B, 3, 3) = (B, N, 3)
+        x = x.transpose(2, 1)                                     # (B, 3, N)
+        x = F.relu(self.bn1(self.conv1(x)))                       # (B, 64, N)
+                  
+        local_feat = x                                            # (B, 64, N)  
+        trans2 = self.tnet2(x)                                    # (B, 64, 64)
+        skipped_x2 = x.transpose(2, 1)                            # (B, N, 64)
+                      
+        x = torch.bmm(skipped_x2, trans2)                         # (B, N, 64) x (B, 64, 64) = (B, N, 64) 
+        x = x.transpose(2, 1)                                     # (B, 64, N)
+        x = F.relu(self.bn2(self.conv2(x)))                       # (B, 1064, N)
+
+        # Max pool:
+        global_feat = torch.max(x, dim=2, keepdim=True) [0]       # (B, 1024, 1)
+        global_feat = global_feat.repeat(1, 1, num_pts)           # (B, 1024, N)
+        x = torch.cat([global_feat, local_feat], dim=1)           # (B, 1088, N)
+        x = F.relu(self.bn3(self.conv3(x)))                       # (B, 128, N)
+        x = self.conv4(x)                                         # (B, output_dims, N)
+        return x
+
+
+
+class PointNet(BaseModel):
+    def __init__(self, input_channels=1, output_channels=1, **kwargs):
+        super().__init__(name="UNet", **kwargs)
+        self.input_channels = input_channels
+        self.output_channels = output_channels
+
+    def create_model(self):
+        self.model = PointNetTorch(
+            input_dims = self.input_channels,
+            output_dims= self.output_channels
+        )
+        return self.model

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openmlcore
-Version: 1.2.0
+Version: 2.0.1
 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.2.0 → openmlcore-2.0.1}/src/openmlcore.egg-info/SOURCES.txt

@@ -7,16 +7,22 @@ src/openmlcore.egg-info/dependency_links.txt
 src/openmlcore.egg-info/requires.txt
 src/openmlcore.egg-info/top_level.txt
 src/openmlcore/base/data.py
+src/openmlcore/base/data3d.py
 src/openmlcore/loss/loss.py
+src/openmlcore/loss/loss3d.py
 src/openmlcore/metrics/metrics.py
+src/openmlcore/metrics/metrics3d.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/pointNetPP.py
+src/openmlcore/models/pointnet.py
 src/openmlcore/models/segformer.py
 src/openmlcore/models/unetpp.py
 src/openmlcore/models/lib/attention.py
 src/openmlcore/models/lib/convolutions.py
+src/openmlcore/models/lib/tnet.py
 tests/test_base_model.py
 tests/test_loss.py
 tests/test_main.py