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

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