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

Moral88/utils.py

@@ -1,101 +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()
-        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]
+    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 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
+            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.10.0.dist-info → Moral88-0.13.0.dist-info}/METADATA

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

tests/test_regression.py

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