Moral88 0.2.0__py3-none-any.whl → 0.4.0__py3-none-any.whl

Moral88/__init__.py

@@ -0,0 +1 @@
+from .regression import mean_absolute_error, mean_squared_error, r_squared

Moral88/regression.py

@@ -1,36 +1,51 @@
-def mean_absolute_error(y_true, y_pred, normalize=True, threshold=None, method='mean', library='Moral88'):
+import numpy as np
+
+def validate_inputs(y_true, y_pred):
+    """
+    Validate the inputs for type and length.
+    """
+    if not isinstance(y_true, (list, tuple, np.ndarray)) or not isinstance(y_pred, (list, tuple, np.ndarray)):
+        raise TypeError("Both y_true and y_pred must be lists, tuples, or numpy arrays.")
+
+    y_true = np.array(y_true)
+    y_pred = np.array(y_pred)
+
+    if y_true.shape != y_pred.shape:
+        raise ValueError("Shapes of y_true and y_pred must be the same.")
+
+    if not np.issubdtype(y_true.dtype, np.number) or not np.issubdtype(y_pred.dtype, np.number):
+        raise TypeError("All elements in y_true and y_pred must be numeric.")
+
+def mean_absolute_error(y_true, y_pred, normalize=True, threshold=None, method='mean', library='Moral88', flatten=True):
     """
-    Calculate Mean Absolute Error (MAE) or variants based on method and library.
-
-    Parameters:
-    - y_true (list or array): True values (required)
-    - y_pred (list or array): Predicted values (required)
-    - normalize (bool): If True, normalize the result (default: True)
-    - threshold (tuple, optional): Apply a threshold to the predictions (default: None)
-    - method (str): Method of calculation. Options: {'mean', 'sum', 'none'}. Default: 'mean'
-    - library (str): Library to use for calculations. Options: {'Moral88', 'sklearn', 'torch', 'tensor', 'statsmodel', 'Dask-ML', 'MLlib'}. Default: 'Moral88'.
-
-    Returns:
-    - float or list: Calculated error based on selected method and library.
+    Calculate Mean Absolute Error (MAE) for single or multi-dimensional data.
     """
+    validate_inputs(y_true, y_pred)
+
+    # y_true = np.array(y_true)
+    # y_pred = np.array(y_pred)
+
+    if flatten:
+        y_true = y_true.ravel()
+        y_pred = y_pred.ravel()
+
     if library == 'Moral88':
-        # Original implementation
         if threshold is not None:
-            y_pred = [min(max(pred, threshold[0]), threshold[1]) for pred in y_pred]
+            y_pred = np.clip(y_pred, threshold[0], threshold[1])
 
-        absolute_errors = [abs(y_t - y_p) for y_t, y_p in zip(y_true, y_pred)]
+        absolute_errors = np.abs(y_true - y_pred)
 
         if method == 'mean':
-            result = sum(absolute_errors) / len(y_true)
+            result = np.mean(absolute_errors)
         elif method == 'sum':
-            result = sum(absolute_errors)
+            result = np.sum(absolute_errors)
         elif method == 'none':
             result = absolute_errors
         else:
             raise ValueError("Invalid method. Choose from {'mean', 'sum', 'none'}.")
 
         if normalize and method != 'none':
-            range_y = max(y_true) - min(y_true)
+            range_y = np.ptp(y_true)
             result = result / max(abs(range_y), 1)
 
         return result
@@ -51,52 +66,39 @@ def mean_absolute_error(y_true, y_pred, normalize=True, threshold=None, method='
         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()
 
-    # elif library == 'statsmodel':
-    #     raise NotImplementedError("Statsmodel does not have a built-in MAE implementation.")
-
-    # elif library == 'Dask-ML':
-    #     raise NotImplementedError("Dask-ML support is not implemented yet.")
-
-    # elif library == 'MLlib':
-    #     raise NotImplementedError("MLlib support is not implemented yet.")
-
     else:
         raise ValueError(f"Invalid library: {library}. Choose from {'Moral88', 'sklearn', 'torch', 'tensorflow'}.")
 
-
-def mean_squared_error(y_true, y_pred, normalize=True, threshold=None, method='mean', library='Moral88'):
+def mean_squared_error(y_true, y_pred, normalize=True, threshold=None, method='mean', library='Moral88', flatten=True):
     """
-    Calculate Mean Squared Error (MSE) or variants based on method and library.
-
-    Parameters:
-    - y_true (list or array): True values (required)
-    - y_pred (list or array): Predicted values (required)
-    - normalize (bool): If True, normalize the result (default: True)
-    - threshold (tuple, optional): Apply a threshold to the predictions (default: None)
-    - method (str): Method of calculation. Options: {'mean', 'sum', 'none'}. Default: 'mean'
-    - library (str): Library to use for calculations. Options: {'Moral88', 'sklearn', 'torch', 'tensor', 'statsmodel', 'Dask-ML', 'MLlib'}. Default: 'Moral88'.
-
-    Returns:
-    - float or list: Calculated error based on selected method and library.
+    Calculate Mean Squared Error (MSE) for single or multi-dimensional data.
     """
+    validate_inputs(y_true, y_pred)
+
+    # y_true = np.array(y_true)
+    # y_pred = np.array(y_pred)
+
+    if flatten:
+        y_true = y_true.ravel()
+        y_pred = y_pred.ravel()
+
     if library == 'Moral88':
-        # Original implementation
         if threshold is not None:
-            y_pred = [min(max(pred, threshold[0]), threshold[1]) for pred in y_pred]
+            y_pred = np.clip(y_pred, threshold[0], threshold[1])
 
-        squared_errors = [(y_t - y_p) ** 2 for y_t, y_p in zip(y_true, y_pred)]
+        squared_errors = (y_true - y_pred) ** 2
 
         if method == 'mean':
-            result = sum(squared_errors) / len(y_true)
+            result = np.mean(squared_errors)
         elif method == 'sum':
-            result = sum(squared_errors)
+            result = np.sum(squared_errors)
         elif method == 'none':
             result = squared_errors
         else:
             raise ValueError("Invalid method. Choose from {'mean', 'sum', 'none'}.")
 
         if normalize and method != 'none':
-            range_y = max(y_true) - min(y_true)
+            range_y = np.ptp(y_true)
             result = result / max(abs(range_y), 1)
 
         return result
@@ -117,23 +119,148 @@ def mean_squared_error(y_true, y_pred, normalize=True, threshold=None, method='m
         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()
 
-    # elif library == 'statsmodel':
-    #     raise NotImplementedError("Statsmodel does not have a built-in MSE implementation.")
-
-    # elif library == 'Dask-ML':
-    #     raise NotImplementedError("Dask-ML support is not implemented yet.")
-
-    # elif library == 'MLlib':
-    #     raise NotImplementedError("MLlib support is not implemented yet.")
-
     else:
         raise ValueError(f"Invalid library: {library}. Choose from {'Moral88', 'sklearn', 'torch', 'tensorflow'}.")
-def r_squared(y_true, y_pred):
+
+def r_squared(y_true, y_pred, flatten=True):
     """
-    Compute R-Squared
+    Compute R-Squared for single or multi-dimensional data.
     """
-    import numpy as np
-    y_true, y_pred = np.array(y_true), np.array(y_pred)
+    validate_inputs(y_true, y_pred)
+
+    y_true = np.array(y_true)
+    y_pred = np.array(y_pred)
+
+    if flatten:
+        y_true = y_true.ravel()
+        y_pred = y_pred.ravel()
+
     ss_total = np.sum((y_true - np.mean(y_true)) ** 2)
     ss_residual = np.sum((y_true - y_pred) ** 2)
-    return 1 - (ss_residual / ss_total)
+    return 1 - (ss_residual / ss_total)
+
+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.
+        """
+        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
+
+
+class Metrics:
+    def __init__(self):
+        self.validator = DataValidator()
+
+    def r2_score(self, y_true, y_pred, sample_weight=None):
+        """
+        Computes R2 score.
+        """
+        y_true, y_pred, sample_weight = self.validator.validate_r2_score_inputs(y_true, y_pred, sample_weight)
+
+        numerator = np.sum((y_true - y_pred) ** 2)
+        denominator = np.sum((y_true - np.mean(y_true)) ** 2)
+
+        if denominator == 0:
+            return 0.0
+        return 1 - (numerator / denominator)
+
+
+if __name__ == '__main__':
+    # Example usage
+    validator = DataValidator()
+    metrics = Metrics()
+
+    # Test validation
+    arr = [[1], [2], [3]]
+    print("1D array:", validator.is_1d_array(arr))
+    print("Samples:", validator.check_samples(arr))
+
+    # Test R2 score
+    y_true = [3, -0.5, 2, 7]
+    y_pred = [2.5, 0.0, 2, 8]
+    print("R2 Score:", metrics.r2_score(y_true, y_pred))

Moral88/segmentation.py

@@ -0,0 +1,38 @@
+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

{Moral88-0.2.0.dist-info → Moral88-0.4.0.dist-info}/METADATA

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

Moral88-0.4.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+Moral88/__init__.py,sha256=vb-aPc9ZbnYNSy9qq2fVESI63E10pYsCrDpnV8OHWkg,74
+Moral88/regression.py,sha256=kfWQcdtdZVlHW_iIRbS9_rNrKJOYNiT9RaeYpVIvl7I,9355
+Moral88/segmentation.py,sha256=v0yqxdrKbM9LM7wVKLjJ4HrhrSrilNNeWS6-oK_27Ag,1363
+Moral88-0.4.0.dist-info/LICENSE,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+Moral88-0.4.0.dist-info/METADATA,sha256=TITXx4rc91SXkAwwDXu2mW-FbV1xQukBXEFiVfgRXMY,407
+Moral88-0.4.0.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
+Moral88-0.4.0.dist-info/top_level.txt,sha256=-dyn5iTprnSUHbtMpvRO-prJsIoaRxao7wlfCHLSsv4,8
+Moral88-0.4.0.dist-info/RECORD,,

Moral88-0.2.0.dist-info/RECORD

@@ -1,7 +0,0 @@
-Moral88/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-Moral88/regression.py,sha256=W_galfrJHIbyP8S1YL0_GMBCKVKfbI2uJfI1PRsAaOk,5939
-Moral88-0.2.0.dist-info/LICENSE,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-Moral88-0.2.0.dist-info/METADATA,sha256=L3o3beMiux_cQtS6PE8sWQbC6Q2K4RuId_n6X7-tEtg,407
-Moral88-0.2.0.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
-Moral88-0.2.0.dist-info/top_level.txt,sha256=-dyn5iTprnSUHbtMpvRO-prJsIoaRxao7wlfCHLSsv4,8
-Moral88-0.2.0.dist-info/RECORD,,