Moral88 0.10.0__py3-none-any.whl → 0.11.0__py3-none-any.whl

Moral88/segmentation.py

@@ -0,0 +1,166 @@
+import numpy as np
+from Moral88.utils import DataValidator
+from scipy.spatial.distance import directed_hausdorff
+from sklearn.metrics import f1_score as sklearn_f1_score
+
+validator = DataValidator()
+
+def intersection_over_union(y_true, y_pred, num_classes, library=None, flatten=True):
+    """
+    Computes Intersection over Union (IoU).
+    """
+    y_true, y_pred = validator.validate_segmentation_inputs(y_true, y_pred)
+    validator.validate_classes(y_true, num_classes)
+    validator.validate_classes(y_pred, num_classes)
+
+    if flatten:
+        y_true = y_true.ravel()
+        y_pred = y_pred.ravel()
+
+    if library == 'Moral88' or library is None:
+        iou_per_class = []
+        for cls in range(num_classes):
+            intersection = np.logical_and(y_true == cls, y_pred == cls).sum()
+            union = np.logical_or(y_true == cls, y_pred == cls).sum()
+            iou = intersection / union if union > 0 else 0
+            iou_per_class.append(iou)
+
+        mean_iou = np.mean(iou_per_class)
+        return iou_per_class, mean_iou
+
+    elif library == 'torch':
+        import torch
+        y_true_tensor = torch.tensor(y_true, dtype=torch.float32)
+        y_pred_tensor = torch.tensor(y_pred, dtype=torch.float32)
+        iou = torch.mean((y_true_tensor * y_pred_tensor).sum(dim=1) / (y_true_tensor + y_pred_tensor - y_true_tensor * y_pred_tensor).sum(dim=1))
+        return iou.item()
+
+    elif library == 'tensorflow':
+        import tensorflow as tf
+        intersection = tf.reduce_sum(tf.cast(y_true == y_pred, tf.float32))
+        union = tf.reduce_sum(tf.cast(y_true | y_pred, tf.float32))
+        iou = intersection / union if union > 0 else 0
+        return iou.numpy()
+
+    raise ValueError("Unsupported library for IoU.")
+
+def dice_coefficient(y_true, y_pred, num_classes, library=None, flatten=True):
+    """
+    Computes Dice Coefficient.
+    """
+    y_true, y_pred = validator.validate_segmentation_inputs(y_true, y_pred)
+    validator.validate_classes(y_true, num_classes)
+    validator.validate_classes(y_pred, num_classes)
+
+    if flatten:
+        y_true = y_true.ravel()
+        y_pred = y_pred.ravel()
+
+    if library == 'Moral88' or library is None:
+        dice_per_class = []
+        for cls in range(num_classes):
+            intersection = np.logical_and(y_true == cls, y_pred == cls).sum()
+            total = (y_true == cls).sum() + (y_pred == cls).sum()
+            dice = (2 * intersection) / total if total > 0 else 0
+            dice_per_class.append(dice)
+
+        mean_dice = np.mean(dice_per_class)
+        return dice_per_class, mean_dice
+
+    elif library == 'torch':
+        import torch
+        y_true_tensor = torch.tensor(y_true, dtype=torch.float32)
+        y_pred_tensor = torch.tensor(y_pred, dtype=torch.float32)
+        intersection = torch.sum(y_true_tensor * y_pred_tensor)
+        total = torch.sum(y_true_tensor) + torch.sum(y_pred_tensor)
+        dice = (2 * intersection) / total if total > 0 else 0
+        return dice.item()
+
+    elif library == 'tensorflow':
+        import tensorflow as tf
+        y_true_tensor = tf.convert_to_tensor(y_true, dtype=tf.float32)
+        y_pred_tensor = tf.convert_to_tensor(y_pred, dtype=tf.float32)
+        intersection = tf.reduce_sum(y_true_tensor * y_pred_tensor)
+        total = tf.reduce_sum(y_true_tensor) + tf.reduce_sum(y_pred_tensor)
+        dice = (2 * intersection) / total if total > 0 else 0
+        return dice.numpy()
+
+    raise ValueError("Unsupported library for Dice Coefficient.")
+
+def pixel_accuracy(y_true, y_pred, library=None):
+    """
+    Computes Pixel Accuracy.
+    """
+    y_true, y_pred = validator.validate_segmentation_inputs(y_true, y_pred)
+
+    if library == 'Moral88' or library is None:
+        correct = (y_true == y_pred).sum()
+        total = y_true.size
+        accuracy = correct / total
+        return accuracy
+
+    elif library == 'torch':
+        import torch
+        y_true_tensor = torch.tensor(y_true, dtype=torch.float32)
+        y_pred_tensor = torch.tensor(y_pred, dtype=torch.float32)
+        correct = torch.sum(y_true_tensor == y_pred_tensor)
+        total = torch.numel(y_true_tensor)
+        accuracy = correct / total
+        return accuracy.item()
+
+    elif library == 'tensorflow':
+        import tensorflow as tf
+        y_true_tensor = tf.convert_to_tensor(y_true, dtype=tf.float32)
+        y_pred_tensor = tf.convert_to_tensor(y_pred, dtype=tf.float32)
+        correct = tf.reduce_sum(tf.cast(y_true_tensor == y_pred_tensor, tf.float32))
+        total = tf.size(y_true_tensor, out_type=tf.float32)
+        accuracy = correct / total
+        return accuracy.numpy()
+
+    raise ValueError("Unsupported library for Pixel Accuracy.")
+
+def hausdorff_distance(y_true, y_pred, library=None):
+    """
+    Computes Hausdorff Distance.
+    """
+    y_true, y_pred = validator.validate_segmentation_inputs(y_true, y_pred)
+
+    if library == 'Moral88' or library is None:
+        y_true_points = np.argwhere(y_true > 0)
+        y_pred_points = np.argwhere(y_pred > 0)
+
+        distance = max(directed_hausdorff(y_true_points, y_pred_points)[0],
+                       directed_hausdorff(y_pred_points, y_true_points)[0])
+        return distance
+
+    raise ValueError("Unsupported library for Hausdorff Distance.")
+
+def f1_score(y_true, y_pred, num_classes, library=None, flatten=True):
+    """
+    Computes F1 Score.
+    """
+    y_true, y_pred = validator.validate_segmentation_inputs(y_true, y_pred)
+    validator.validate_classes(y_true, num_classes)
+    validator.validate_classes(y_pred, num_classes)
+
+    if flatten:
+        y_true = y_true.ravel()
+        y_pred = y_pred.ravel()
+
+    if library == 'sklearn':
+        return sklearn_f1_score(y_true, y_pred, average='macro')
+
+    if library == 'Moral88' or library is None:
+        f1_per_class = []
+        for cls in range(num_classes):
+            tp = np.logical_and(y_pred == cls, y_true == cls).sum()
+            fp = np.logical_and(y_pred == cls, y_true != cls).sum()
+            fn = np.logical_and(y_pred != cls, y_true == cls).sum()
+
+            f1 = (2 * tp) / (2 * tp + fp + fn) if (2 * tp + fp + fn) > 0 else 0
+            f1_per_class.append(f1)
+
+        mean_f1 = np.mean(f1_per_class)
+        return f1_per_class, mean_f1
+
+    raise ValueError("Unsupported library for F1 Score.")

Moral88/utils.py

@@ -57,6 +57,21 @@ class DataValidator:
 
         return y_true, y_pred
 
+    def validate_segmentation_inputs(self, y_true, y_pred):
+        """
+        Ensures segmentation inputs are valid, checking dimensions and consistency.
+        """
+        y_true = np.asarray(y_true, dtype=np.int32)
+        y_pred = np.asarray(y_pred, dtype=np.int32)
+
+        if y_true.shape != y_pred.shape:
+            raise ValueError(f"Shapes of y_true {y_true.shape} and y_pred {y_pred.shape} do not match.")
+
+        if y_true.ndim < 2 or y_pred.ndim < 2:
+            raise ValueError("Segmentation inputs must have at least two dimensions.")
+
+        return y_true, y_pred
+
     def check_array(self, array, ensure_2d: bool = True, dtype=np.float64, allow_nan: bool = False):
         """
         Validates input array and converts it to specified dtype.

{Moral88-0.10.0.dist-info → Moral88-0.11.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: Moral88
-Version: 0.10.0
+Version: 0.11.0
 Summary: A library for regression evaluation metrics.
 Author: Morteza Alizadeh
 Author-email: alizadeh.c2m@gmail.com

Moral88-0.11.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+Moral88/__init__.py,sha256=Z7iEZUqslxRyJU2to6iX6a5Ak1XBZxU3VT4RvOCjsEU,196
+Moral88/regression.py,sha256=WjNMpX0t99KGTrUKMBFg6LccnPvlnWKnjimu65BLrkc,12061
+Moral88/segmentation.py,sha256=N6Pg-220JfTxV01Bwjir8kOFMW3nfI0L_MM9zGrvDvg,6470
+Moral88/utils.py,sha256=4dZ165tRtwCEyz-wESp26-cZp-5Pz8HkSrmNPrKEH38,4534
+tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/test_regression.py,sha256=j-XG9j5D24OaJBJT3ROnlvrMDrSR2sH4182U5L3PA5k,3124
+Moral88-0.11.0.dist-info/LICENSE,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+Moral88-0.11.0.dist-info/METADATA,sha256=I9J_QFmYuvB-Q5YufPayenl5E4-WvCQznIMtoQlNC24,408
+Moral88-0.11.0.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
+Moral88-0.11.0.dist-info/top_level.txt,sha256=gg4pKIcQal4JhJAb77H5W6SHC77e-BeLTy4hxfXwmfw,14
+Moral88-0.11.0.dist-info/RECORD,,

tests/test_regression.py

@@ -97,3 +97,4 @@ def test_adjusted_r2_score():
     n_features = 2
     result = adjusted_r2_score(y_true, y_pred, n_features)
     assert result == pytest.approx(0.8458, rel=1e-2)
+

Moral88-0.10.0.dist-info/RECORD

@@ -1,10 +0,0 @@
-Moral88/__init__.py,sha256=Z7iEZUqslxRyJU2to6iX6a5Ak1XBZxU3VT4RvOCjsEU,196
-Moral88/regression.py,sha256=WjNMpX0t99KGTrUKMBFg6LccnPvlnWKnjimu65BLrkc,12061
-Moral88/utils.py,sha256=ggiiY5Vp6A6MbGtghftkM0MJM0R9hhR2avUbpV43_yk,3933
-tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/test_regression.py,sha256=w5A6eGTmVuh-eN0nTACPoQzzrX2wI5McyQuMyCvf07M,3122
-Moral88-0.10.0.dist-info/LICENSE,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-Moral88-0.10.0.dist-info/METADATA,sha256=6YVHD8ZRgbJ-4lTVmQnJS7caxgRvHGirWgNLHDtSNPw,408
-Moral88-0.10.0.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
-Moral88-0.10.0.dist-info/top_level.txt,sha256=gg4pKIcQal4JhJAb77H5W6SHC77e-BeLTy4hxfXwmfw,14
-Moral88-0.10.0.dist-info/RECORD,,