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

Moral88/__init__.py

@@ -0,0 +1 @@
+from .regression import mean_absolute_error, mean_squared_error, r2_score, mean_bias_deviation, adjusted_r2_score, root_mean_squared_error, mean_absolute_percentage_error, explained_variance_score

Moral88/regression.py

@@ -1,112 +1,13 @@
 import numpy as np
-import warnings
-from typing import Union, List, Tuple
-from scipy import sparse
-
-class DataValidator:
-    def __init__(self):
-        pass
-
-    def check_device_cpu(self, device):
-        if device not in {"cpu", None}:
-            raise ValueError(f"Unsupported device: {device!r}. Only 'cpu' is supported.")
-
-    def is_1d_array(self, array: Union[np.ndarray, list], warn: bool = False) -> np.ndarray:
-        """
-        Ensures input is a 1D array. Raises an error if it's not 1D or convertible to 1D.
-        """
-        array = np.asarray(array)
-        shape = array.shape
-
-        if len(shape) == 1:
-            return array
-        elif len(shape) == 2 and shape[1] == 1:
-            if warn:
-                warnings.warn("Input is 2D but will be converted to 1D.", UserWarning)
-            return array.ravel()
-        else:
-            raise ValueError(f"Input must be 1D. Found shape {shape}.")
-
-    def check_samples(self, array: Union[np.ndarray, list]) -> int:
-        """
-        Returns the number of samples in the array.
-        """
-        array = np.asarray(array)
-        if hasattr(array, 'shape') and len(array.shape) > 0:
-            return array.shape[0]
-        else:
-            raise TypeError("Input must be an array-like object with at least one dimension.")
-
-    def check_consistent_length(self, *arrays: Union[np.ndarray, list]):
-        """
-        Ensures all input arrays have the same length.
-        """
-        lengths = [self.check_samples(arr) for arr in arrays]
-        if len(set(lengths)) > 1:
-            raise ValueError(f"Inconsistent lengths: {lengths}")
-
-    def validate_regression_targets(self, y_true, y_pred, dtype=np.float64):
-        """
-        Ensures regression target values are consistent and converted to the specified dtype.
-        """
-        y_true = np.asarray(y_true, dtype=dtype)
-        y_pred = np.asarray(y_pred, dtype=dtype)
-
-        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.")
-
-        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.
-        """
-        array = np.asarray(array, dtype=dtype)
-
-        if ensure_2d and array.ndim == 1:
-            array = array.reshape(-1, 1)
-
-        if not allow_nan and np.isnan(array).any():
-            raise ValueError("Input contains NaN values, which are not allowed.")
-
-        return array
-
-    def check_sparse(self, array, accept_sparse: Tuple[str] = ('csr', 'csc')):
-        """
-        Validates sparse matrices and converts to an acceptable format.
-        """
-        if sparse.issparse(array):
-            if array.format not in accept_sparse:
-                return array.asformat(accept_sparse[0])
-            return array
-        else:
-            raise ValueError("Input is not a sparse matrix.")
-
-    def validate_r2_score_inputs(self, y_true, y_pred, sample_weight=None):
-        """
-        Ensures inputs for R2 score computation are valid.
-        """
-        y_true, y_pred = self.validate_regression_targets(y_true, y_pred)
-        if sample_weight is not None:
-            sample_weight = self.is_1d_array(sample_weight)
-        return y_true, y_pred, sample_weight
-
-    def validate_mae_mse_inputs(self, y_true, y_pred, library=None):
-        """
-        Ensures inputs for MAE and MSE computation are valid.
-        """
-        y_true, y_pred = self.validate_regression_targets(y_true, y_pred)
-        if library not in {None, 'sklearn', 'torch', 'tensorflow', 'Moral88'}:
-            raise ValueError(f"Invalid library: {library}. Choose from {{'Moral88', 'sklearn', 'torch', 'tensorflow'}}.")
-        return y_true, y_pred
-
+from Moral88.utils import DataValidator
 
+validator = DataValidator()
 
-def mean_bias_deviation(self, y_true, y_pred, library=None, flatten=True):
+def mean_bias_deviation( y_true, y_pred, library=None, flatten=True):
     """
     Computes Mean Bias Deviation (MBD).
     """
-    y_true, y_pred = self.validator.validate_mae_mse_inputs(y_true, y_pred, library)
+    y_true, y_pred = validator.validate_mae_mse_inputs(y_true, y_pred, library)
 
     if flatten and y_true.ndim > 1:
         y_true = y_true.flatten()
@@ -132,14 +33,12 @@ def mean_bias_deviation(self, y_true, y_pred, library=None, flatten=True):
 
     # Default implementation
     return np.mean(y_pred - y_true)
-def __init__(self):
-    self.validator = DataValidator()
 
-def r2_score(self, y_true, y_pred, sample_weight=None, library=None, flatten=True):
+def r2_score( y_true, y_pred, sample_weight=None, library=None, flatten=True):
     """
     Computes R2 score.
     """
-    y_true, y_pred, sample_weight = self.validator.validate_r2_score_inputs(y_true, y_pred, sample_weight)
+    y_true, y_pred, sample_weight = validator.validate_r2_score_inputs(y_true, y_pred, sample_weight)
 
     if flatten and y_true.ndim > 1:
         y_true = y_true.flatten()
@@ -161,11 +60,11 @@ def r2_score(self, y_true, y_pred, sample_weight=None, library=None, flatten=Tru
         return 0.0
     return 1 - (numerator / denominator)
 
-def mean_absolute_error(self, y_true, y_pred, normalize=True, threshold=None, method='mean', library='Moral88', flatten=True):
+def mean_absolute_error( y_true, y_pred, normalize=True, threshold=None, method='mean', library='Moral88', flatten=True):
     """
     Computes Mean Absolute Error (MAE).
     """
-    y_true, y_pred = self.validator.validate_mae_mse_inputs(y_true, y_pred, library)
+    y_true, y_pred = validator.validate_mae_mse_inputs(y_true, y_pred, library)
 
     if flatten:
         y_true = y_true.ravel()
@@ -211,11 +110,11 @@ def mean_absolute_error(self, y_true, y_pred, normalize=True, threshold=None, me
         y_pred_tensor = tf.convert_to_tensor(y_pred, dtype=tf.float32)
         return tf.reduce_mean(tf.abs(y_true_tensor - y_pred_tensor)).numpy()
 
-def mean_squared_error(self, y_true, y_pred, normalize=True, threshold=None, method='mean', library='Moral88', flatten=True):
+def mean_squared_error(y_true, y_pred, normalize=True, threshold=None, method='mean', library='Moral88', flatten=True):
     """
     Computes Mean Squared Error (MSE).
     """
-    y_true, y_pred = self.validator.validate_mae_mse_inputs(y_true, y_pred, library)
+    y_true, y_pred = validator.validate_mae_mse_inputs(y_true, y_pred, library)
 
     if flatten:
         y_true = y_true.ravel()
@@ -239,10 +138,6 @@ def mean_squared_error(self, y_true, y_pred, normalize=True, threshold=None, met
         else:
             raise ValueError("Invalid method. Choose from {'mean', 'sum', 'none'}.")
 
-        # if normalize and method != 'none':
-        #     range_y = np.ptp(y_true)
-        #     result = result / max(abs(range_y), 1)
-
         return result
 
     elif library == 'sklearn':
@@ -261,11 +156,11 @@ def mean_squared_error(self, y_true, y_pred, normalize=True, threshold=None, met
         y_pred_tensor = tf.convert_to_tensor(y_pred, dtype=tf.float32)
         return tf.reduce_mean(tf.square(y_true_tensor - y_pred_tensor)).numpy()
 
-def root_mean_squared_error(self, y_true, y_pred, library=None):
+def root_mean_squared_error(y_true, y_pred, library=None):
     """
     Computes Root Mean Squared Error (RMSE).
     """
-    y_true, y_pred = self.validator.validate_mae_mse_inputs(y_true, y_pred, library)
+    y_true, y_pred = validator.validate_mae_mse_inputs(y_true, y_pred, library)
 
     if library == 'sklearn':
         from sklearn.metrics import mean_squared_error as sklearn_mse
@@ -283,15 +178,15 @@ def root_mean_squared_error(self, y_true, y_pred, library=None):
         y_pred_tensor = tf.convert_to_tensor(y_pred, dtype=tf.float32)
         return tf.sqrt(tf.reduce_mean(tf.square(y_true_tensor - y_pred_tensor))).numpy()
 
-    mse = self.mean_squared_error(y_true, y_pred)
+    mse = mean_squared_error(y_true, y_pred)
     return np.sqrt(mse)
 
-def mean_absolute_percentage_error(self, y_true, y_pred, library=None):
+def mean_absolute_percentage_error(y_true, y_pred, library=None):
     """
     Computes Mean Absolute Percentage Error (MAPE).
     """
-    y_true, y_pred = self.validator.validate_regression_targets(y_true, y_pred)
-    y_true, y_pred = self.validator.validate_mae_mse_inputs(y_true, y_pred, library)
+    y_true, y_pred = validator.validate_regression_targets(y_true, y_pred)
+    y_true, y_pred = validator.validate_mae_mse_inputs(y_true, y_pred, library)
     y_true = np.clip(y_true, 1e-8, None) 
 
     if library == 'sklearn':
@@ -312,11 +207,11 @@ def mean_absolute_percentage_error(self, y_true, y_pred, library=None):
 
     return np.mean(np.abs((y_true - y_pred) / np.clip(np.abs(y_true), 1e-8, None))) * 100
 
-def explained_variance_score(self, y_true, y_pred, library=None, flatten=True):
+def explained_variance_score(y_true, y_pred, library=None, flatten=True):
     """
     Computes Explained Variance Score.
     """
-    y_true, y_pred = self.validator.validate_mae_mse_inputs(y_true, y_pred, library)
+    y_true, y_pred = validator.validate_mae_mse_inputs(y_true, y_pred, library)
 
     if library == 'sklearn':
         from sklearn.metrics import explained_variance_score as sklearn_evs
@@ -342,7 +237,7 @@ def explained_variance_score(self, y_true, y_pred, library=None, flatten=True):
     denominator = np.var(y_true)
     return 1 - numerator / denominator if denominator != 0 else 0
 
-def adjusted_r2_score(self, y_true, y_pred, n_features, library=None, flatten=True):
+def adjusted_r2_score(y_true, y_pred, n_features, library=None, flatten=True):
     """
     Computes Adjusted R-Squared Score.
     
@@ -363,7 +258,7 @@ def adjusted_r2_score(self, y_true, y_pred, n_features, library=None, flatten=Tr
         If True, flattens multidimensional arrays before computation.
     """
     # Validate inputs
-    y_true, y_pred, _ = self.validator.validate_r2_score_inputs(y_true, y_pred)
+    y_true, y_pred, _ = validator.validate_r2_score_inputs(y_true, y_pred)
 
     # Ensure inputs are 1D arrays
     if y_true.ndim == 0 or y_pred.ndim == 0:
@@ -395,9 +290,9 @@ def adjusted_r2_score(self, y_true, y_pred, n_features, library=None, flatten=Tr
     return adjusted_r2
 
 if __name__ == '__main__':
-    # Example usage
+# Example usage
     validator = DataValidator()
-    metrics = Metrics()
+
 
     # Test validation
     arr = [[1], [2], [3]]
@@ -408,12 +303,12 @@ if __name__ == '__main__':
     y_true = [3, -0.5, 2, 7]
     y_pred = [2.5, 0.0, 2, 8]
 
-    print("Mean Absolute Error:", metrics.mean_absolute_error(y_true, y_pred))
-    print("Mean Squared Error:", metrics.mean_squared_error(y_true, y_pred))
-    print("R2 Score:", metrics.r2_score(y_true, y_pred))
-    print("Mean Bias Deviation: ", metrics.mean_bias_deviation(y_true, y_pred))
-    print("Explained Variance Score: ", metrics.explained_variance_score(y_true, y_pred))
-    print("Mean Absolute Percentage Error: ", metrics.mean_absolute_percentage_error(y_true, y_pred))
-    print("Root Mean Squared Error: ", metrics.root_mean_squared_error(y_true, y_pred))
-    print("adjusted_r2_score: ", metrics.adjusted_r2_score(y_true, y_pred, 2))
+    print("Mean Absolute Error:", mean_absolute_error(y_true, y_pred))
+    print("Mean Squared Error:", mean_squared_error(y_true, y_pred))
+    print("R2 Score:", r2_score(y_true, y_pred))
+    print("Mean Bias Deviation: ", mean_bias_deviation(y_true, y_pred))
+    print("Explained Variance Score: ", explained_variance_score(y_true, y_pred))
+    print("Mean Absolute Percentage Error: ", mean_absolute_percentage_error(y_true, y_pred))
+    print("Root Mean Squared Error: ", root_mean_squared_error(y_true, y_pred))
+    print("adjusted_r2_score: ", adjusted_r2_score(y_true, y_pred, 2))
 

Moral88/segmentation.py

@@ -1,38 +1,166 @@
-def validate_segmentation_inputs(y_true, y_pred):
-    """
-    Validate the inputs for type and shape.
-    """
-    if not isinstance(y_true, (list, tuple)) or not isinstance(y_pred, (list, tuple)):
-        raise TypeError("Both y_true and y_pred must be lists or tuples.")
-
-    if len(y_true) != len(y_pred):
-        raise ValueError("Length of y_true and y_pred must be the same.")
-
-    if not all(isinstance(x, (int, float)) for x in y_true + y_pred):
-        raise TypeError("All elements in y_true and y_pred must be numeric.")
-
-def dice_score(y_true, y_pred, threshold=0.5):
-    """
-    Compute the Dice Score.
-    
-    Args:
-        y_true (list or tuple): Ground truth binary values.
-        y_pred (list or tuple): Predicted values (probabilities or binary).
-        threshold (float): Threshold to binarize y_pred if necessary.
-        
-    Returns:
-        float: Dice Score.
-    """
-    validate_segmentation_inputs(y_true, y_pred)
-    
-    # Binarize predictions based on threshold
-    y_pred = [1 if p >= threshold else 0 for p in y_pred]
-    
-    # Calculate intersection and union
-    intersection = sum(yt * yp for yt, yp in zip(y_true, y_pred))
-    total = sum(y_true) + sum(y_pred)
-    
-    if total == 0:
-        return 1.0  # Perfect match if both are completely empty
-
-    return 2 * intersection / total
+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

@@ -0,0 +1,116 @@
+import numpy as np
+import warnings
+from typing import Union, List, Tuple
+from scipy import sparse
+
+class DataValidator:
+    def __init__(self):
+        pass
+
+    def check_device_cpu(self, device):
+        if device not in {"cpu", None}:
+            raise ValueError(f"Unsupported device: {device!r}. Only 'cpu' is supported.")
+
+    def is_1d_array(self, array: Union[np.ndarray, list], warn: bool = False) -> np.ndarray:
+        """
+        Ensures input is a 1D array. Raises an error if it's not 1D or convertible to 1D.
+        """
+        array = np.asarray(array)
+        shape = array.shape
+
+        if len(shape) == 1:
+            return array
+        elif len(shape) == 2 and shape[1] == 1:
+            if warn:
+                warnings.warn("Input is 2D but will be converted to 1D.", UserWarning)
+            return array.ravel()
+        else:
+            raise ValueError(f"Input must be 1D. Found shape {shape}.")
+
+    def check_samples(self, array: Union[np.ndarray, list]) -> int:
+        """
+        Returns the number of samples in the array.
+        """
+        array = np.asarray(array)
+        if hasattr(array, 'shape') and len(array.shape) > 0:
+            return array.shape[0]
+        else:
+            raise TypeError("Input must be an array-like object with at least one dimension.")
+
+    def check_consistent_length(self, *arrays: Union[np.ndarray, list]):
+        """
+        Ensures all input arrays have the same length.
+        """
+        lengths = [self.check_samples(arr) for arr in arrays]
+        if len(set(lengths)) > 1:
+            raise ValueError(f"Inconsistent lengths: {lengths}")
+
+    def validate_regression_targets(self, y_true, y_pred, dtype=np.float64):
+        """
+        Ensures regression target values are consistent and converted to the specified dtype.
+        """
+        y_true = np.asarray(y_true, dtype=dtype)
+        y_pred = np.asarray(y_pred, dtype=dtype)
+
+        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.")
+
+        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.
+        """
+        array = np.asarray(array, dtype=dtype)
+
+        if ensure_2d and array.ndim == 1:
+            array = array.reshape(-1, 1)
+
+        if not allow_nan and np.isnan(array).any():
+            raise ValueError("Input contains NaN values, which are not allowed.")
+
+        return array
+
+    def check_sparse(self, array, accept_sparse: Tuple[str] = ('csr', 'csc')):
+        """
+        Validates sparse matrices and converts to an acceptable format.
+        """
+        if sparse.issparse(array):
+            if array.format not in accept_sparse:
+                return array.asformat(accept_sparse[0])
+            return array
+        else:
+            raise ValueError("Input is not a sparse matrix.")
+
+    def validate_r2_score_inputs(self, y_true, y_pred, sample_weight=None):
+        """
+        Ensures inputs for R2 score computation are valid.
+        """
+        y_true, y_pred = self.validate_regression_targets(y_true, y_pred)
+        if sample_weight is not None:
+            sample_weight = self.is_1d_array(sample_weight)
+        return y_true, y_pred, sample_weight
+
+    def validate_mae_mse_inputs(self, y_true, y_pred, library=None):
+        """
+        Ensures inputs for MAE and MSE computation are valid.
+        """
+        y_true, y_pred = self.validate_regression_targets(y_true, y_pred)
+        if library not in {None, 'sklearn', 'torch', 'tensorflow', 'Moral88'}:
+            raise ValueError(f"Invalid library: {library}. Choose from {{'Moral88', 'sklearn', 'torch', 'tensorflow'}}.")
+        return y_true, y_pred

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: Moral88
-Version: 0.9.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,,

{Moral88-0.9.0.dist-info → Moral88-0.11.0.dist-info}/top_level.txt

@@ -1 +1,2 @@
 Moral88
+tests

tests/test_regression.py

@@ -0,0 +1,100 @@
+import pytest
+import numpy as np
+from Moral88.regression import (
+                                mean_absolute_error,
+                                mean_absolute_error,
+                                mean_squared_error,
+                                r2_score,
+                                mean_bias_deviation,
+                                adjusted_r2_score,
+                                root_mean_squared_error,
+                                mean_absolute_percentage_error,
+                                explained_variance_score
+)
+import warnings
+from Moral88.utils import DataValidator
+
+validator = DataValidator()
+
+def test_is_1d_array():
+    validator = DataValidator()
+    array = [[1], [2], [3]]
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore", UserWarning)
+        result = validator.is_1d_array(array, warn=True)
+    assert result.ndim == 1
+    assert np.array_equal(result, np.array([1, 2, 3]))
+
+def test_check_samples():
+    validator = DataValidator()
+    array = [[1, 2], [3, 4], [5, 6]]
+    result = validator.check_samples(array)
+    assert result == 3
+
+def test_check_consistent_length():
+    validator = DataValidator()
+    array1 = [1, 2, 3]
+    array2 = [4, 5, 6]
+    validator.check_consistent_length(array1, array2)  # Should not raise an error
+
+    array3 = [7, 8]
+    with pytest.raises(ValueError):
+        validator.check_consistent_length(array1, array3)
+
+def test_mean_absolute_error():
+
+    y_true = [3, -0.5, 2, 7]
+    y_pred = [2.5, 0.0, 2, 8]
+    result = mean_absolute_error(y_true, y_pred)
+    assert result == pytest.approx(0.5, rel=1e-2)
+
+def test_mean_squared_error():
+
+    y_true = [3, -0.5, 2, 7]
+    y_pred = [2.5, 0.0, 2, 8]
+    result = mean_squared_error(y_true, y_pred)
+    assert result == pytest.approx(0.375, rel=1e-2)
+
+def test_r2_score():
+
+    y_true = [3, -0.5, 2, 7]
+    y_pred = [2.5, 0.0, 2, 8]
+    result = r2_score(y_true, y_pred)
+    assert result == pytest.approx(0.948, rel=1e-2)
+
+def test_mean_bias_deviation():
+
+    y_true = [3, -0.5, 2, 7]
+    y_pred = [2.5, 0.0, 2, 8]
+    result = mean_bias_deviation(y_true, y_pred)
+    assert result == pytest.approx(0.25, rel=1e-2)
+
+def test_explained_variance_score():
+
+    y_true = [3, -0.5, 2, 7]
+    y_pred = [2.5, 0.0, 2, 8]
+    result = explained_variance_score(y_true, y_pred)
+    assert result == pytest.approx(0.957, rel=1e-2)
+
+def test_mean_absolute_percentage_error():
+ 
+    y_true = [3, -0.5, 2, 7]
+    y_pred = [2.5, 0.0, 2, 8]
+    result = mean_absolute_percentage_error(y_true, y_pred)
+    assert result == pytest.approx(32.738095, rel=1e-2)
+
+def test_root_mean_squared_error():
+
+    y_true = [3, -0.5, 2, 7]
+    y_pred = [2.5, 0.0, 2, 8]
+    result = root_mean_squared_error(y_true, y_pred)
+    assert result == pytest.approx(0.612, rel=1e-2)
+
+def test_adjusted_r2_score():
+
+    y_true = [3, -0.5, 2, 7]
+    y_pred = [2.5, 0.0, 2, 8]
+    n_features = 2
+    result = adjusted_r2_score(y_true, y_pred, n_features)
+    assert result == pytest.approx(0.8458, rel=1e-2)
+

Moral88-0.9.0.dist-info/RECORD

@@ -1,8 +0,0 @@
-Moral88/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-Moral88/regression.py,sha256=vxkrbEvGW9Lys7TKVsM1SNqRtqBfCQjfUcm_hmyyGjU,16293
-Moral88/segmentation.py,sha256=v0yqxdrKbM9LM7wVKLjJ4HrhrSrilNNeWS6-oK_27Ag,1363
-Moral88-0.9.0.dist-info/LICENSE,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-Moral88-0.9.0.dist-info/METADATA,sha256=RM87uHl8gYyDJmAre7sS49ZEAbkgYdmWcgwtNprcdEY,407
-Moral88-0.9.0.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
-Moral88-0.9.0.dist-info/top_level.txt,sha256=-dyn5iTprnSUHbtMpvRO-prJsIoaRxao7wlfCHLSsv4,8
-Moral88-0.9.0.dist-info/RECORD,,