Moral88 0.10.0__tar.gz → 0.13.0__tar.gz

Moral88-0.13.0/Moral88/classification.py

@@ -0,0 +1,123 @@
+import numpy as np
+import pandas as pd
+from Moral88.utils import DataValidator
+
+validator = DataValidator()
+def accuracy(y_true, y_pred):
+    """Compute Accuracy"""
+    validator.validate_all(y_true, y_pred)
+    return np.sum(y_true == y_pred) / len(y_true)
+
+def auc_roc(y_true, y_scores, average='macro'):
+    """Compute AUC-ROC Score"""
+    validator.validate_all(y_true, np.round(y_scores))
+    unique_classes = np.unique(y_true)
+    aucs = []
+    
+    for cls in unique_classes:
+        y_binary = (y_true == cls).astype(int)
+        sorted_indices = np.argsort(y_scores[:, cls])[::-1]
+        y_sorted = y_binary[sorted_indices]
+        cum_true = np.cumsum(y_sorted)
+        cum_false = np.cumsum(1 - y_sorted)
+        auc = np.sum(cum_true * (1 - y_sorted)) / (cum_true[-1] * cum_false[-1]) if (cum_true[-1] > 0 and cum_false[-1] > 0) else 0
+        aucs.append(auc)
+    
+    if average == 'macro':
+        return np.mean(aucs)
+    elif average == 'weighted':
+        class_counts = np.bincount(y_true)
+        return np.sum([aucs[i] * class_counts[i] for i in range(len(unique_classes))]) / len(y_true)
+    return aucs
+
+def precision(y_true, y_pred, average='binary'):
+    """Compute Precision Score"""
+    validator.validate_all(y_true, y_pred)
+    unique_classes = np.unique(y_true)
+    precisions = []
+    
+    for cls in unique_classes:
+        tp = np.sum((y_true == cls) & (y_pred == cls))
+        fp = np.sum((y_true != cls) & (y_pred == cls))
+        precisions.append(tp / (tp + fp) if (tp + fp) > 0 else 0)
+    
+    if average == 'macro':
+        return np.mean(precisions)
+    elif average == 'micro':
+        tp_total = np.sum(y_true == y_pred)
+        fp_total = np.sum(y_true != y_pred)
+        return tp_total / (tp_total + fp_total) if (tp_total + fp_total) > 0 else 0
+    elif average == 'weighted':
+        class_counts = np.bincount(y_true)
+        return np.sum([precisions[i] * class_counts[i] for i in range(len(unique_classes))]) / len(y_true)
+    return precisions
+
+def recall(y_true, y_pred, average='binary'):
+    """Compute Recall Score"""
+    validator.validate_all(y_true, y_pred)
+    unique_classes = np.unique(y_true)
+    recalls = []
+    
+    for cls in unique_classes:
+        tp = np.sum((y_true == cls) & (y_pred == cls))
+        fn = np.sum((y_true == cls) & (y_pred != cls))
+        recalls.append(tp / (tp + fn) if (tp + fn) > 0 else 0)
+    
+    if average == 'macro':
+        return np.mean(recalls)
+    elif average == 'micro':
+        tp_total = np.sum(y_true == y_pred)
+        fn_total = np.sum(y_true != y_pred)
+        return tp_total / (tp_total + fn_total) if (tp_total + fn_total) > 0 else 0
+    elif average == 'weighted':
+        class_counts = np.bincount(y_true)
+        return np.sum([recalls[i] * class_counts[i] for i in range(len(unique_classes))]) / len(y_true)
+    return recalls
+def balanced_accuracy(y_true, y_pred):
+    """Compute Balanced Accuracy"""
+    validator.validate_all(y_true, y_pred)
+    unique_classes = np.unique(y_true)
+    recalls = []
+    
+    for cls in unique_classes:
+        tp = np.sum((y_true == cls) & (y_pred == cls))
+        fn = np.sum((y_true == cls) & (y_pred != cls))
+        recalls.append(tp / (tp + fn) if (tp + fn) > 0 else 0)
+    
+    return np.mean(recalls)
+
+def matthews_correlation_coefficient(y_true, y_pred):
+    """Compute Matthews Correlation Coefficient (MCC)"""
+    validator.validate_all(y_true, y_pred)
+    unique_classes = np.unique(y_true)
+    confusion_mat = np.zeros((len(unique_classes), len(unique_classes)), dtype=int)
+    
+    for i, cls_true in enumerate(unique_classes):
+        for j, cls_pred in enumerate(unique_classes):
+            confusion_mat[i, j] = np.sum((y_true == cls_true) & (y_pred == cls_pred))
+    
+    tp = np.diag(confusion_mat)
+    fp = np.sum(confusion_mat, axis=0) - tp
+    fn = np.sum(confusion_mat, axis=1) - tp
+    tn = np.sum(confusion_mat) - (tp + fp + fn)
+    
+    numerator = (tp * tn) - (fp * fn)
+    denominator = np.sqrt((tp + fp) * (tp + fn) * (tn + fp) * (tn + fn))
+    mcc = np.mean(numerator / denominator) if np.all(denominator > 0) else 0
+    return mcc
+
+def cohens_kappa(y_true, y_pred):
+    """Compute Cohen’s Kappa Score"""
+    validator.validate_all(y_true, y_pred)
+    unique_classes = np.unique(y_true)
+    confusion_mat = np.zeros((len(unique_classes), len(unique_classes)), dtype=int)
+    
+    for i, cls_true in enumerate(unique_classes):
+        for j, cls_pred in enumerate(unique_classes):
+            confusion_mat[i, j] = np.sum((y_true == cls_true) & (y_pred == cls_pred))
+    
+    total = np.sum(confusion_mat)
+    po = np.sum(np.diag(confusion_mat)) / total
+    pe = np.sum(np.sum(confusion_mat, axis=0) * np.sum(confusion_mat, axis=1)) / (total ** 2)
+    
+    return (po - pe) / (1 - pe) if (1 - pe) > 0 else 0

Moral88-0.13.0/Moral88/clustering.py

@@ -0,0 +1,129 @@
+import numpy as np
+from Moral88.utils import DataValidator
+
+validator = DataValidator()
+
+
+def adjusted_rand_index(labels_true, labels_pred):
+    """Compute Adjusted Rand Index (ARI)"""
+    validator.validate_all(labels_true, labels_pred)
+    n = len(labels_true)
+    contingency_matrix = np.zeros((len(set(labels_true)), len(set(labels_pred))))
+    
+    for i in range(n):
+        contingency_matrix[labels_true[i], labels_pred[i]] += 1
+    
+    sum_comb_c = np.sum([np.sum(row) * (np.sum(row) - 1) for row in contingency_matrix]) / 2
+    sum_comb_k = np.sum([np.sum(col) * (np.sum(col) - 1) for col in contingency_matrix.T]) / 2
+    sum_comb = np.sum(contingency_matrix * (contingency_matrix - 1)) / 2
+    
+    expected_index = (sum_comb_c * sum_comb_k) / (n * (n - 1) / 2)
+    max_index = (sum_comb_c + sum_comb_k) / 2
+    
+    return (sum_comb - expected_index) / (max_index - expected_index) if max_index != expected_index else 1
+
+def normalized_mutual_info(labels_true, labels_pred, epsilon=1e-10):
+    """Compute Normalized Mutual Information (NMI) avoid devided by zero"""
+    validator.validate_all(labels_true, labels_pred)
+    unique_true, counts_true = np.unique(labels_true, return_counts=True)
+    unique_pred, counts_pred = np.unique(labels_pred, return_counts=True)
+    
+    contingency_matrix = np.zeros((len(unique_true), len(unique_pred)))
+    for i in range(len(labels_true)):
+        contingency_matrix[labels_true[i], labels_pred[i]] += 1
+    
+    h_true = -np.sum((counts_true / len(labels_true)) * np.log2(np.where(counts_true > 0, counts_true / len(labels_true), epsilon)))
+    h_pred = -np.sum((counts_pred / len(labels_pred)) * np.log2(np.where(counts_pred > 0, counts_pred / len(labels_pred), epsilon)))
+    
+    joint_prob = contingency_matrix / len(labels_true)
+    mutual_info = np.sum(joint_prob * np.log2(np.where(joint_prob > 0, joint_prob / ((counts_true[:, None] / len(labels_true)) * (counts_pred[None, :] / len(labels_pred))), epsilon)))
+    
+    return mutual_info / np.sqrt(h_true * h_pred) if h_true * h_pred > 0 else 0
+
+def silhouette_score(X, labels):
+    """Compute Silhouette Score"""
+    validator.validate_all(labels, labels)
+    unique_labels = np.unique(labels)
+    a = np.zeros(len(X))
+    b = np.zeros(len(X))
+    
+    for i, label in enumerate(labels):
+        same_cluster = X[labels == label]
+        other_clusters = [X[labels == other_label] for other_label in unique_labels if other_label != label]
+        
+        a[i] = np.mean(np.linalg.norm(same_cluster - X[i], axis=1)) if len(same_cluster) > 1 else 0
+        b[i] = np.min([np.mean(np.linalg.norm(other_cluster - X[i], axis=1)) for other_cluster in other_clusters]) if other_clusters else 0
+    
+    silhouette_values = (b - a) / np.maximum(a, b)
+    return np.mean(silhouette_values)
+
+def calinski_harabasz_index(X, labels):
+    """Compute Calinski-Harabasz Index"""
+    validator.validate_all(labels, labels)
+    n_clusters = len(np.unique(labels))
+    n_samples = len(X)
+    cluster_means = np.array([np.mean(X[labels == label], axis=0) for label in np.unique(labels)])
+    overall_mean = np.mean(X, axis=0)
+    
+    between_group_dispersion = np.sum([len(X[labels == label]) * np.linalg.norm(cluster_mean - overall_mean)**2 for label, cluster_mean in zip(np.unique(labels), cluster_means)])
+    within_group_dispersion = np.sum([np.sum((X[labels == label] - cluster_mean) ** 2) for label, cluster_mean in zip(np.unique(labels), cluster_means)])
+    
+    return (between_group_dispersion / within_group_dispersion) * ((n_samples - n_clusters) / (n_clusters - 1))
+
+def dunn_index(X, labels):
+    """Compute Dunn Index"""
+    validator.validate_all(labels, labels)
+    unique_labels = np.unique(labels)
+    cluster_means = [np.mean(X[labels == label], axis=0) for label in unique_labels]
+    intra_distances = [np.max(np.linalg.norm(X[labels == label] - cluster_mean, axis=1)) for label, cluster_mean in zip(unique_labels, cluster_means)]
+    inter_distances = [np.linalg.norm(cluster_means[i] - cluster_means[j]) for i in range(len(unique_labels)) for j in range(i + 1, len(unique_labels))]
+    return np.min(inter_distances) / np.max(intra_distances)
+
+def inertia(X, labels):
+    """Compute Inertia (Sum of Squared Distances to Centroids)"""
+    validator.validate_all(labels, labels)
+    unique_labels = np.unique(labels)
+    cluster_means = [np.mean(X[labels == label], axis=0) for label in unique_labels]
+    return np.sum([np.sum((X[labels == label] - cluster_means[i]) ** 2) for i, label in enumerate(unique_labels)])
+
+def homogeneity_score(labels_true, labels_pred, epsilon=1e-10):
+    """Compute Homogeneity Score avoid devided by zero"""
+    validator.validate_all(labels_true, labels_pred)
+    unique_true, counts_true = np.unique(labels_true, return_counts=True)
+    unique_pred, counts_pred = np.unique(labels_pred, return_counts=True)
+    contingency_matrix = np.zeros((len(unique_true), len(unique_pred)))
+    
+    for i in range(len(labels_true)):
+        contingency_matrix[labels_true[i], labels_pred[i]] += 1
+    
+    entropy_true = -np.sum((counts_true / len(labels_true)) * np.log2(np.where(counts_true > 0, counts_true / len(labels_true), epsilon)))
+    mutual_info = np.sum(contingency_matrix * np.log2(np.where(contingency_matrix > 0, contingency_matrix / ((counts_true[:, None] / len(labels_true)) * (counts_pred[None, :] / len(labels_pred))), epsilon)))
+    
+    return mutual_info / entropy_true if entropy_true > 0 else 0
+
+
+def completeness_score(labels_true, labels_pred, epsilon=1e-10):
+    """Compute Completeness Score avoid divided by zero"""
+    validator.validate_all(labels_true, labels_pred)
+    unique_true, counts_true = np.unique(labels_true, return_counts=True)
+    unique_pred, counts_pred = np.unique(labels_pred, return_counts=True)
+    contingency_matrix = np.zeros((len(unique_true), len(unique_pred)))
+    
+    for i in range(len(labels_true)):
+        contingency_matrix[labels_true[i], labels_pred[i]] += 1
+    
+    entropy_pred = -np.sum((counts_pred / len(labels_pred)) * np.log2(np.where(counts_pred > 0, counts_pred / len(labels_pred), epsilon)))
+    mutual_info = np.sum(contingency_matrix * np.log2(np.where(contingency_matrix > 0, contingency_matrix / ((counts_true[:, None] / len(labels_true)) * (counts_pred[None, :] / len(labels_pred))), epsilon)))
+    
+    return mutual_info / entropy_pred if entropy_pred > 0 else 0
+
+def davies_bouldin_index(X, labels):
+    """Compute Davies-Bouldin Index"""
+    validator.validate_all(labels, labels)
+    n_clusters = len(np.unique(labels))
+    cluster_means = np.array([np.mean(X[labels == label], axis=0) for label in np.unique(labels)])
+    
+    dispersions = np.array([np.mean(np.linalg.norm(X[labels == label] - cluster_means[i], axis=1)) for i, label in enumerate(np.unique(labels))])
+    db_index = np.mean([max([(dispersions[i] + dispersions[j]) / np.linalg.norm(cluster_means[i] - cluster_means[j]) for j in range(n_clusters) if i != j]) for i in range(n_clusters)])
+    
+    return db_index

Moral88-0.13.0/Moral88/regression.py

@@ -0,0 +1,271 @@
+import numpy as np
+from Moral88.utils import DataValidator
+
+validator = DataValidator()
+
+
+def mean_absolute_error(y_true, y_pred, sample_weights=None, normalize=False, method='mean'):
+    """Compute Mean Absolute Error (MAE)"""
+    validator.validate_all(y_true, y_pred)
+    errors = np.abs(y_true - y_pred)
+
+    if sample_weights is not None:
+        sample_weights = np.array(sample_weights)
+        if len(sample_weights) != len(y_true):
+            raise ValueError("sample_weights must have the same length as y_true and y_pred")
+        errors *= sample_weights
+
+    if normalize:
+        errors /= np.mean(y_true)
+
+    if method == 'mean':
+        return np.mean(errors)
+    elif method == 'sum':
+        return np.sum(errors)
+    elif method == 'none':
+        return errors
+    else:
+        raise ValueError("Invalid method. Choose from 'mean', 'sum', or 'none'")
+
+def mean_squared_error(y_true, y_pred, sample_weights=None, squared=True, method='mean'):
+    """Compute Mean Squared Error (MSE) or Root Mean Squared Error (RMSE)"""
+    validator.validate_all(y_true, y_pred)
+    errors = (y_true - y_pred) ** 2
+
+    if sample_weights is not None:
+        sample_weights = np.array(sample_weights)
+        if len(sample_weights) != len(y_true):
+            raise ValueError("sample_weights must have the same length as y_true and y_pred")
+        errors *= sample_weights
+
+    if method == 'mean':
+        result = np.mean(errors)
+    elif method == 'sum':
+        result = np.sum(errors)
+    elif method == 'none':
+        return errors
+    else:
+        raise ValueError("Invalid method. Choose from 'mean', 'sum', or 'none'")
+
+    return result if squared else np.sqrt(result)
+
+def root_mean_squared_error(y_true, y_pred, sample_weights=None, method='mean'):
+    """Compute Root Mean Squared Error (RMSE)"""
+    validator.validate_all(y_true, y_pred)
+    errors = (y_true - y_pred) ** 2
+
+    if sample_weights is not None:
+        sample_weights = np.array(sample_weights)
+        if len(sample_weights) != len(y_true):
+            raise ValueError("sample_weights must have the same length as y_true and y_pred")
+        errors *= sample_weights
+
+    if method == 'mean':
+        result = np.mean(errors)
+    elif method == 'sum':
+        result = np.sum(errors)
+    elif method == 'none':
+        return np.sqrt(errors)
+    else:
+        raise ValueError("Invalid method. Choose from 'mean', 'sum', or 'none'")
+
+    return np.sqrt(result)
+
+def mean_bias_deviation(y_true, y_pred, sample_weights=None, method='mean'):
+    """Compute Mean Bias Deviation (MBD)"""
+    validator.validate_all(y_true, y_pred)
+    errors = y_true - y_pred
+
+    if sample_weights is not None:
+        sample_weights = np.array(sample_weights)
+        if len(sample_weights) != len(y_true):
+            raise ValueError("sample_weights must have the same length as y_true and y_pred")
+        errors *= sample_weights
+
+    if method == 'mean':
+        return np.mean(errors)
+    elif method == 'sum':
+        return np.sum(errors)
+    elif method == 'none':
+        return errors
+    else:
+        raise ValueError("Invalid method. Choose from 'mean', 'sum', or 'none'")
+
+def r_squared(y_true, y_pred, adjusted=False, n_features=None):
+    """Compute R-squared (R²) and Adjusted R-squared if needed"""
+    validator.validate_all(y_true, y_pred)
+    ss_total = np.sum((y_true - np.mean(y_true)) ** 2)
+    ss_residual = np.sum((y_true - y_pred) ** 2)
+    r2 = 1 - (ss_residual / ss_total)
+
+    if adjusted:
+        if n_features is None:
+            raise ValueError("n_features must be provided for adjusted R² calculation")
+        n = len(y_true)
+        return 1 - ((1 - r2) * (n - 1) / (n - n_features - 1))
+
+    return r2
+
+def adjusted_r_squared(y_true, y_pred, n_features):
+    """Compute Adjusted R-squared (R² Adjusted)"""
+    validator.validate_all(y_true, y_pred)
+
+    n = len(y_true)
+    if n_features >= n:
+        raise ValueError("Number of features must be less than number of samples")
+
+    ss_total = np.sum((y_true - np.mean(y_true)) ** 2)
+    ss_residual = np.sum((y_true - y_pred) ** 2)
+    r2 = 1 - (ss_residual / ss_total)
+
+    return 1 - ((1 - r2) * (n - 1) / (n - n_features - 1))
+
+def mean_absolute_percentage_error(y_true, y_pred, sample_weights=None, method='mean'):
+    """Compute Mean Absolute Percentage Error (MAPE)"""
+    validator.validate_all(y_true, y_pred, mape_based=True)
+    errors = np.abs((y_true - y_pred) / y_true) * 100
+
+    if sample_weights is not None:
+        sample_weights = np.array(sample_weights)
+        if len(sample_weights) != len(y_true):
+            raise ValueError("sample_weights must have the same length as y_true and y_pred")
+        errors *= sample_weights
+
+    if method == 'mean':
+        return np.mean(errors)
+    elif method == 'sum':
+        return np.sum(errors)
+    elif method == 'none':
+        return errors
+    else:
+        raise ValueError("Invalid method. Choose from 'mean', 'sum', or 'none'")
+
+def symmetric_mean_absolute_percentage_error(y_true, y_pred, sample_weights=None, method='mean'):
+    """Compute Symmetric Mean Absolute Percentage Error (sMAPE)"""
+    validator.validate_all(y_true, y_pred, mape_based=True)
+    errors = 200 * np.abs(y_true - y_pred) / (np.abs(y_true) + np.abs(y_pred))
+
+    if sample_weights is not None:
+        sample_weights = np.array(sample_weights)
+        if len(sample_weights) != len(y_true):
+            raise ValueError("sample_weights must have the same length as y_true and y_pred")
+        errors *= sample_weights
+
+    if method == 'mean':
+        return np.mean(errors)
+    elif method == 'sum':
+        return np.sum(errors)
+    elif method == 'none':
+        return errors
+    else:
+        raise ValueError("Invalid method. Choose from 'mean', 'sum', or 'none'")
+
+def huber_loss(y_true, y_pred, delta=1.0, sample_weights=None, method='mean'):
+    """Compute Huber Loss"""
+    validator.validate_all(y_true, y_pred)
+    error = y_true - y_pred
+
+    loss = np.where(np.abs(error) <= delta, 0.5 * error ** 2, delta * (np.abs(error) - 0.5 * delta))
+
+    if sample_weights is not None:
+        sample_weights = np.array(sample_weights)
+        if len(sample_weights) != len(y_true):
+            raise ValueError("sample_weights must have the same length as y_true and y_pred")
+        loss *= sample_weights
+
+    if method == 'mean':
+        return np.mean(loss)
+    elif method == 'sum':
+        return np.sum(loss)
+    elif method == 'none':
+        return loss
+    else:
+        raise ValueError("Invalid method. Choose from 'mean', 'sum', or 'none'")
+
+def relative_squared_error(y_true, y_pred):
+    """Compute Relative Squared Error (RSE)"""
+    validator.validate_all(y_true, y_pred)
+    return np.sum((y_true - y_pred) ** 2) / np.sum((y_true - np.mean(y_true)) ** 2)
+
+def mean_squared_log_error(y_true, y_pred, sample_weights=None, method='mean', squared=True):
+    """Compute Logarithmic Mean Squared Error (MSLE) or Root Mean Squared Log Error (RMSLE)"""
+    validator.validate_all(y_true, y_pred, log_based=True)
+    errors = (np.log1p(y_true) - np.log1p(y_pred)) ** 2
+
+    if sample_weights is not None:
+        sample_weights = np.array(sample_weights)
+        if len(sample_weights) != len(y_true):
+            raise ValueError("sample_weights must have the same length as y_true and y_pred")
+        errors *= sample_weights
+
+    if method == 'mean':
+        result = np.mean(errors)
+    elif method == 'sum':
+        result = np.sum(errors)
+    elif method == 'none':
+        return errors
+    else:
+        raise ValueError("Invalid method. Choose from 'mean', 'sum', or 'none'")
+
+    return result if squared else np.sqrt(result)
+
+def root_mean_squared_log_error(y_true, y_pred, sample_weights=None, method='mean'):
+    """Compute Root Mean Squared Logarithmic Error (RMSLE)"""
+    validator.validate_all(y_true, y_pred, log_based=True)
+    errors = (np.log1p(y_true) - np.log1p(y_pred)) ** 2
+
+    if sample_weights is not None:
+        sample_weights = np.array(sample_weights)
+        if len(sample_weights) != len(y_true):
+            raise ValueError("sample_weights must have the same length as y_true and y_pred")
+        errors *= sample_weights
+
+    if method == 'mean':
+        return np.sqrt(np.mean(errors))
+    elif method == 'sum':
+        return np.sqrt(np.sum(errors))
+    elif method == 'none':
+        return np.sqrt(errors)
+    else:
+        raise ValueError("Invalid method. Choose from 'mean', 'sum', or 'none'")
+
+def log_cosh_loss(y_true, y_pred, sample_weights=None, method='mean'):
+    """Compute Log-Cosh Loss"""
+    validator.validate_all(y_true, y_pred)
+    errors = np.log(np.cosh(y_pred - y_true))
+
+    if sample_weights is not None:
+        sample_weights = np.array(sample_weights)
+        if len(sample_weights) != len(y_true):
+            raise ValueError("sample_weights must have the same length as y_true and y_pred")
+        errors *= sample_weights
+
+    if method == 'mean':
+        return np.mean(errors)
+    elif method == 'sum':
+        return np.sum(errors)
+    elif method == 'none':
+        return errors
+    else:
+        raise ValueError("Invalid method. Choose from 'mean', 'sum', or 'none'")
+
+def explained_variance(y_true, y_pred):
+    """Compute Explained Variance Score"""
+    validator.validate_all(y_true, y_pred)
+    variance_y_true = np.var(y_true)
+    return 1 - (np.var(y_true - y_pred) / variance_y_true) if variance_y_true != 0 else 0
+
+def median_absolute_error(y_true, y_pred, sample_weights=None):
+    """Compute Median Absolute Error"""
+    validator = DataValidator()
+    validator.validate_all(y_true, y_pred)
+    errors = np.abs(y_true - y_pred)
+
+    if sample_weights is not None:
+        sample_weights = np.array(sample_weights)
+        if len(sample_weights) != len(y_true):
+            raise ValueError("sample_weights must have the same length as y_true and y_pred")
+        errors *= sample_weights
+
+    return np.median(errors)
+

Moral88-0.13.0/Moral88/utils.py

@@ -0,0 +1,71 @@
+import numpy as np
+import pandas as pd
+
+class DataValidator:
+    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:
+            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 → Moral88-0.13.0/Moral88.egg-info}/PKG-INFO

@@ -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.10.0 → Moral88-0.13.0}/Moral88.egg-info/SOURCES.txt

@@ -2,6 +2,8 @@ LICENSE
 README.md
 setup.py
 Moral88/__init__.py
+Moral88/classification.py
+Moral88/clustering.py
 Moral88/regression.py
 Moral88/utils.py
 Moral88.egg-info/PKG-INFO
@@ -9,5 +11,10 @@ Moral88.egg-info/SOURCES.txt
 Moral88.egg-info/dependency_links.txt
 Moral88.egg-info/requires.txt
 Moral88.egg-info/top_level.txt
-tests/__init__.py
-tests/test_regression.py
+Test/__init__.py
+Test/test_classification.py
+Test/test_clustering.py
+Test/test_regression.py
+test/test_classification.py
+test/test_clustering.py
+test/test_regression.py

{Moral88-0.10.0 → Moral88-0.13.0}/Moral88.egg-info/top_level.txt

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

{Moral88-0.10.0/Moral88.egg-info → Moral88-0.13.0}/PKG-INFO

@@ -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