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

Moral88/utils.py

@@ -1,116 +1,71 @@
 import numpy as np
-import warnings
-from typing import Union, List, Tuple
-from scipy import sparse
+import pandas as pd
 
 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()
+    def __init__(self, raise_warning=True):
+        """Initialize the DataValidator class"""
+        self.raise_warning = raise_warning
+
+    def check_data_type(self, y_true, y_pred):
+        """Check if input data types are valid"""
+        valid_types = (np.ndarray, pd.Series, pd.DataFrame, list)
+        if not isinstance(y_true, valid_types) or not isinstance(y_pred, valid_types):
+            raise TypeError("y_true and y_pred must be numpy array, pandas series, or list")
+
+    def check_missing_values(self, y_true, y_pred):
+        """Check for missing values"""
+        if np.any(pd.isnull(y_true)) or np.any(pd.isnull(y_pred)):
+            raise ValueError("Missing values (NaN) detected in data")
+
+    def check_inf_values(self, y_true, y_pred):
+        """Check for infinite values"""
+        if np.any(np.isinf(y_true)) or np.any(np.isinf(y_pred)):
+            raise ValueError("Infinite values (inf) detected in data")
+
+    def check_lengths(self, y_true, y_pred):
+        """Check if y_true and y_pred have the same length"""
+        if len(y_true) != len(y_pred):
+            raise ValueError("y_true and y_pred must have the same length")
+
+    def check_numeric_values(self, y_true, y_pred):
+        """Check if values are numeric"""
+        if not np.issubdtype(np.array(y_true).dtype, np.number) or not np.issubdtype(np.array(y_pred).dtype, np.number):
+            raise TypeError("y_true and y_pred must contain numeric values")
+
+    def check_variance(self, y_true, y_pred):
+        """Check if variance of y_true is zero (can cause issues in R-squared calculation)"""
+        if np.var(y_true) == 0:
+            raise ValueError("Variance of y_true is zero. R-squared may not be meaningful")
+
+    def check_non_negative(self, y_true, y_pred):
+        """Check that values are non-negative for Logarithmic Mean Squared Error"""
+        if np.any(y_true < -1) or np.any(y_pred < -1):
+            raise ValueError("y_true and y_pred must be greater than or equal to -1 for log-based metrics")
+
+    def check_multicollinearity(self, X, threshold=0.9):
+        """Check for multicollinearity in input features"""
+        if isinstance(X, pd.DataFrame):
+            corr_matrix = X.corr().abs()
+            high_corr = (corr_matrix > threshold).sum().sum() - len(X.columns)
+            if high_corr > 0:
+                raise ValueError("High multicollinearity detected in input features")
         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
+            if self.raise_warning:
+                print("Warning: Multicollinearity check requires a pandas DataFrame")
+
+    def validate_all(self, y_true, y_pred, log_based=False, mape_based=False):
+        """Run all validation checks"""
+        self.check_data_type(y_true, y_pred)
+        self.check_missing_values(y_true, y_pred)
+        self.check_inf_values(y_true, y_pred)
+        self.check_lengths(y_true, y_pred)
+        self.check_numeric_values(y_true, y_pred)
+        self.check_variance(y_true, y_pred)
+        if log_based or mape_based:
+            self.check_non_negative(y_true, y_pred)  # Ensure non-negative values for log-based functions and MAPE
+        return True  # Return True if all checks pass
+
+
+# Example usage
+if __name__ == "__main__":
+  pass

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

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

Moral88-0.13.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+Moral88/__init__.py,sha256=Z7iEZUqslxRyJU2to6iX6a5Ak1XBZxU3VT4RvOCjsEU,196
+Moral88/classification.py,sha256=eVm3kvLw0G4mx5oAX9rxlv2itn6-2mNbDIcMk8-dMfY,4916
+Moral88/clustering.py,sha256=vMHkv1Z8hvN4CGiEyOBGrgatAlm3itosL2IK6-wGBw8,7139
+Moral88/regression.py,sha256=evdfwAA2KCQz-S6MeAKath_Lkv5jKqXZGypnf0xSOHw,10207
+Moral88/utils.py,sha256=rjDCHXoqCO_X32xXBupQWKXKC9jeU9lhkIilzMG31yE,3327
+Test/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+Test/test_classification.py,sha256=9JSL5xZvFHMAQdD4PBYJvryFeT8eetzMS0_7SWdZcS0,2747
+Test/test_clustering.py,sha256=NBcM7UnofKGGE8zMrXIAhOz4b1x4S5kudlbEXvXId9Y,2011
+Test/test_regression.py,sha256=rzAk5Pja01QigunfaCyd1XCI3Xs6B3CLIvINmCpTQQA,4896
+Moral88-0.13.0.dist-info/LICENSE,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+Moral88-0.13.0.dist-info/METADATA,sha256=lOabRubXWAz3uQUwah1JcaeL0nwUJZ2BYIg9h-x6XCg,408
+Moral88-0.13.0.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
+Moral88-0.13.0.dist-info/top_level.txt,sha256=-fC4somdxhr26-qFmeG9jny3GcRXqXlcJz9fy2fxGQs,13
+Moral88-0.13.0.dist-info/RECORD,,

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

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

Test/test_classification.py

@@ -0,0 +1,88 @@
+import pytest
+import numpy as np
+from Moral88.classification import *
+import warnings
+from Moral88.utils import DataValidator
+validator = DataValidator()
+
+
+def test_check_data_type():
+    y_true = [1, 2, 3]
+    y_pred = [1, 2, 3]
+    assert validator.check_data_type(y_true, y_pred) is None
+    with pytest.raises(TypeError):
+        validator.check_data_type(123, y_pred)
+
+def test_check_inf_values():
+    y_true = np.array([1, 2, np.inf])
+    y_pred = np.array([1, 2, 3])
+    with pytest.raises(ValueError):
+        validator.check_inf_values(y_true, y_pred)
+
+def test_check_missing_values():
+    y_true = np.array([1, 2, np.nan])
+    y_pred = np.array([1, 2, 3])
+    with pytest.raises(ValueError):
+        validator.check_missing_values(y_true, y_pred)
+
+def test_check_lengths():
+    y_true = [1, 2, 3]
+    y_pred = [1, 2]
+    with pytest.raises(ValueError):
+        validator.check_lengths(y_true, y_pred)
+
+def test_validate_all():
+    y_true = [1, 2, 3]
+    y_pred = [1, 2, 3]
+    assert validator.validate_all(y_true, y_pred) is True
+    with pytest.raises(TypeError):
+        validator.validate_all(123, y_pred)
+    with pytest.raises(ValueError):
+        validator.validate_all([1, 2, np.nan], [1, 2, 3])
+    with pytest.raises(ValueError):
+        validator.validate_all([1, 2, 3], [1, 2])
+
+def test_accuracy():
+    y_true = [0, 1, 1, 0, 1]
+    y_pred = [0, 1, 0, 0, 1]
+    result = accuracy(y_true, y_pred)
+    assert result == pytest.approx(0.8, rel=1e-2)
+
+def test_auc_roc():
+    y_true = [0, 1, 1, 0, 1]
+    y_probs = [0.1, 0.8, 0.4, 0.3, 0.9]
+    result = auc_roc(y_true, y_probs, average='macro')
+    assert result == pytest.approx(0.75, rel=1e-2)
+
+def test_precision():
+    y_true = [0, 1, 1, 0, 1]
+    y_pred = [0, 1, 0, 0, 1]
+    result = precision(y_true, y_pred, average='macro')
+    assert result == pytest.approx(0.75, rel=1e-2)
+
+def test_recall():
+    y_true = [0, 1, 1, 0, 1]
+    y_pred = [0, 1, 0, 0, 1]
+    result = recall(y_true, y_pred, average='macro')
+    assert result == pytest.approx(0.75, rel=1e-2)
+
+def test_balanced_accuracy():
+    y_true = [0, 1, 1, 0, 1]
+    y_pred = [0, 1, 0, 0, 1]
+    result = balanced_accuracy(y_true, y_pred)
+    assert result == pytest.approx(0.75, rel=1e-2)
+
+def test_matthews_correlation_coefficient():
+    y_true = [0, 1, 1, 0, 1]
+    y_pred = [0, 1, 0, 0, 1]
+    result = matthews_correlation_coefficient(y_true, y_pred)
+    assert result == pytest.approx(0.632, rel=1e-2)
+
+def test_cohens_kappa():
+    y_true = [0, 1, 1, 0, 1]
+    y_pred = [0, 1, 0, 0, 1]
+    result = cohens_kappa(y_true, y_pred)
+    assert result == pytest.approx(0.5, rel=1e-2)
+
+if __name__ == "__main__":
+    pytest.main()

Test/test_clustering.py

@@ -0,0 +1,63 @@
+import pytest
+import numpy as np
+from Moral88.clustering import *
+import warnings
+from Moral88.utils import DataValidator
+
+
+def test_adjusted_rand_index():
+    labels_true = [0, 0, 1, 1, 2, 2]
+    labels_pred = [0, 1, 1, 1, 2, 2]
+    result = adjusted_rand_index(labels_true, labels_pred)
+    assert result == pytest.approx(0.444, rel=1e-2)
+
+def test_normalized_mutual_info():
+    labels_true = [0, 0, 1, 1, 2, 2]
+    labels_pred = [0, 1, 1, 1, 2, 2]
+    result = normalized_mutual_info(labels_true, labels_pred)
+    assert result == pytest.approx(0.557, rel=1e-2)
+
+def test_silhouette_score():
+    X = np.random.rand(6, 2)
+    labels_pred = np.array([0, 1, 1, 1, 2, 2])
+    result = silhouette_score(X, labels_pred)
+    assert isinstance(result, float)
+
+def test_calinski_harabasz_index():
+    X = np.random.rand(6, 2)
+    labels_pred = np.array([0, 1, 1, 1, 2, 2])
+    result = calinski_harabasz_index(X, labels_pred)
+    assert isinstance(result, float)
+
+def test_dunn_index():
+    X = np.random.rand(6, 2)
+    labels_pred = np.array([0, 1, 1, 1, 2, 2])
+    result = dunn_index(X, labels_pred)
+    assert isinstance(result, float)
+
+def test_inertia():
+    X = np.random.rand(6, 2)
+    labels_pred = np.array([0, 1, 1, 1, 2, 2])
+    result = inertia(X, labels_pred)
+    assert isinstance(result, float)
+
+def test_homogeneity_score():
+    labels_true = [0, 0, 1, 1, 2, 2]
+    labels_pred = [0, 1, 1, 1, 2, 2]
+    result = homogeneity_score(labels_true, labels_pred)
+    assert isinstance(result, float)
+
+def test_completeness_score():
+    labels_true = [0, 0, 1, 1, 2, 2]
+    labels_pred = [0, 1, 1, 1, 2, 2]
+    result = completeness_score(labels_true, labels_pred)
+    assert isinstance(result, float)
+
+def test_davies_bouldin_index():
+    X = np.random.rand(6, 2)
+    labels_pred = np.array([0, 1, 1, 1, 2, 2])
+    result = davies_bouldin_index(X, labels_pred)
+    assert isinstance(result, float)
+
+if __name__ == "__main__":
+    pytest.main()

Test/test_regression.py

@@ -0,0 +1,141 @@
+import pytest
+import numpy as np
+from Moral88.regression import (
+                                mean_absolute_error,
+                                mean_squared_error,
+                                root_mean_squared_error,
+                                mean_bias_deviation,
+                                r_squared,
+                                adjusted_r_squared,
+                                mean_absolute_percentage_error,
+                                symmetric_mean_absolute_percentage_error,
+                                huber_loss,
+                                relative_squared_error,
+                                mean_squared_log_error,
+                                root_mean_squared_log_error,
+                                log_cosh_loss,
+                                explained_variance,
+                                median_absolute_error
+)
+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_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_mean_bias_deviation():
+    y_true = [3, 5, 2, 7]
+    y_pred = [2.5, 5.5, 2, 8]
+    result = mean_bias_deviation(y_true, y_pred)
+    assert result == pytest.approx(-0.25, rel=1e-2)
+
+def test_r_squared():
+    y_true = [3, -0.5, 2, 7]
+    y_pred = [2.5, 0.0, 2, 8]
+    result = r_squared(y_true, y_pred)
+    assert result == pytest.approx(0.948, rel=1e-2)
+
+def test_adjusted_r_squared():
+    y_true = [3, -0.5, 2, 7]
+    y_pred = [2.5, 0.0, 2, 8]
+    result = adjusted_r_squared(y_true, y_pred, n_features=2)
+    assert result == pytest.approx(0.896, 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(27.77, rel=1e-2)
+
+def test_symmetric_mean_absolute_percentage_error():
+    y_true = [3, -0.5, 2, 7]
+    y_pred = [2.5, 0.0, 2, 8]
+    result = symmetric_mean_absolute_percentage_error(y_true, y_pred)
+    assert result == pytest.approx(28.99, rel=1e-2)
+
+def test_huber_loss():
+    y_true = [3, -0.5, 2, 7]
+    y_pred = [2.5, 0.0, 2, 8]
+    result = huber_loss(y_true, y_pred)
+    assert result == pytest.approx(0.3125, rel=1e-2)
+
+def test_relative_squared_error():
+    y_true = [3, -0.5, 2, 7]
+    y_pred = [2.5, 0.0, 2, 8]
+    result = relative_squared_error(y_true, y_pred)
+    assert result == pytest.approx(0.052, rel=1e-2)
+
+def test_mean_squared_log_error():
+    y_true = [3, 5, 2, 7]
+    y_pred = [2.5, 4.5, 2, 6.5]
+    result = mean_squared_log_error(y_true, y_pred)
+    assert result == pytest.approx(0.004, rel=1e-2)
+
+def test_root_mean_squared_log_error():
+    y_true = [3, 5, 2, 7]
+    y_pred = [2.5, 4.5, 2, 6.5]
+    result = root_mean_squared_log_error(y_true, y_pred)
+    assert result == pytest.approx(0.063, rel=1e-2)
+
+def test_log_cosh_loss():
+    y_true = [3, -0.5, 2, 7]
+    y_pred = [2.5, 0.0, 2, 8]
+    result = log_cosh_loss(y_true, y_pred)
+    assert result == pytest.approx(0.216, rel=1e-2)
+
+def test_explained_variance():
+    y_true = [3, -0.5, 2, 7]
+    y_pred = [2.5, 0.0, 2, 8]
+    result = explained_variance(y_true, y_pred)
+    assert result == pytest.approx(0.95, rel=1e-2)
+
+def test_median_absolute_error():
+    y_true = [3, -0.5, 2, 7]
+    y_pred = [2.5, 0.0, 2, 8]
+    result = median_absolute_error(y_true, y_pred)
+    assert result == pytest.approx(0.5, rel=1e-2)
+
+if __name__ == "__main__":
+    pytest.main()

Moral88/segmentation.py

@@ -1,166 +0,0 @@
-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.")