pyerualjetwork 2.1.6__py3-none-any.whl → 2.1.8__py3-none-any.whl

plan_bi/plan_bi.py

@@ -1144,7 +1144,7 @@ def split(X, y, test_size, random_state):
     Returns:
         tuple: x_train, x_test, y_train, y_test as ordered training and testing data subsets.
     """
-    # Size of the dataset
+   
     num_samples = X.shape[0]
 
     if isinstance(test_size, float):
@@ -1249,48 +1249,67 @@ def decode_one_hot(encoded_data):
 
 def roc_curve(y_true, y_score):
     """
-    Computes ROC curve.
+    Compute Receiver Operating Characteristic (ROC) curve.
 
-    Args:
-        y_true (numpy.ndarray): True class labels (binary: 0 or 1).
-        y_score (numpy.ndarray): Predicted probabilities for positive class.
+    Parameters:
+    y_true : array, shape = [n_samples]
+        True binary labels in range {0, 1} or {-1, 1}.
+    y_score : array, shape = [n_samples]
+        Target scores, can either be probability estimates of the positive class,
+        confidence values, or non-thresholded measure of decisions (as returned
+        by decision_function on some classifiers).
 
     Returns:
-        tuple: FPR (False Positive Rate), TPR (True Positive Rate), thresholds.
+    fpr : array, shape = [n]
+        Increasing false positive rates such that element i is the false positive rate
+        of predictions with score >= thresholds[i].
+    tpr : array, shape = [n]
+        Increasing true positive rates such that element i is the true positive rate
+        of predictions with score >= thresholds[i].
+    thresholds : array, shape = [n]
+        Decreasing thresholds on the decision function used to compute fpr and tpr.
     """
+    
+    y_true = np.asarray(y_true)
+    y_score = np.asarray(y_score)
 
-    idx = np.argsort(y_score)[::-1]
-    y_score_sorted = y_score[idx]
-    y_true_sorted = y_true[idx]
+    if len(np.unique(y_true)) != 2:
+        raise ValueError("Only binary classification is supported.")
 
-    tpr = []
-    fpr = []
-    thresholds = np.linspace(0, 1, 100)
+    
+    desc_score_indices = np.argsort(y_score, kind="mergesort")[::-1]
+    y_score = y_score[desc_score_indices]
+    y_true = y_true[desc_score_indices]
 
-    for threshold in thresholds:
-        y_pred_binary = np.where(y_score_sorted >= threshold, 1, 0)
 
-        tp = np.sum((y_true_sorted == 1) & (y_pred_binary == 1))
-        fn = np.sum((y_true_sorted == 1) & (y_pred_binary == 0))
-        tn = np.sum((y_true_sorted == 0) & (y_pred_binary == 0))
-        fp = np.sum((y_true_sorted == 0) & (y_pred_binary == 1))
+    fpr = []
+    tpr = []
+    thresholds = []
+    n_pos = np.sum(y_true)
+    n_neg = len(y_true) - n_pos
 
-        # Check for division by zero
-        if (tp + fn) == 0:
-            tpr_value = 0.0
-        else:
-            tpr_value = tp / (tp + fn)
+    tp = 0
+    fp = 0
+    prev_score = None
 
-        if (fp + tn) == 0:
-            fpr_value = 0.0
-        else:
-            fpr_value = fp / (fp + tn)
+    
+    for i, score in enumerate(y_score):
+        if score != prev_score:
+            fpr.append(fp / n_neg)
+            tpr.append(tp / n_pos)
+            thresholds.append(score)
+            prev_score = score
 
-        tpr.append(tpr_value)
-        fpr.append(fpr_value)
+        if y_true[i] == 1:
+            tp += 1
+        else:
+            fp += 1
 
-    return fpr, tpr, thresholds
+    fpr.append(fp / n_neg)
+    tpr.append(tp / n_pos)
+    thresholds.append(score)
 
+    return np.array(fpr), np.array(tpr), np.array(thresholds)
 
 def confusion_matrix(y_true, y_pred, class_count=None):
     """
@@ -1313,7 +1332,7 @@ def confusion_matrix(y_true, y_pred, class_count=None):
         true_label = y_true[i]
         pred_label = y_pred[i]
         
-        # Ensure that true_label and pred_label are within the correct range
+        
         if 0 <= true_label < class_count and 0 <= pred_label < class_count:
             confusion[true_label, pred_label] += 1
         else:
@@ -1331,7 +1350,7 @@ def plot_evaluate(y_test, y_preds, acc_list):
     y_preds = np.array(y_preds)
     fpr, tpr, thresholds = roc_curve(y_true, y_preds)
     precision, recall, f1 = metrics(y_test, y_preds)
-    Class = np.unique(y_test)
+    Class = np.unique(decode_one_hot(y_test))
     
    
     cm = confusion_matrix(y_true, y_preds, len(Class))
@@ -1345,7 +1364,8 @@ def plot_evaluate(y_test, y_preds, acc_list):
     axs[0, 0].set_ylabel("Actual Class")
     
     # ROC Curve
-    axs[1, 0].plot(fpr, tpr, color='darkorange', lw=2, label='ROC curve')
+    roc_auc = np.trapz(tpr, fpr)
+    axs[1, 0].plot(fpr, tpr, color='darkorange', lw=2, label=f'ROC curve (area = {roc_auc:.2f})')
     axs[1, 0].plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--')
     axs[1, 0].set_xlim([0.0, 1.0])
     axs[1, 0].set_ylim([0.0, 1.05])
@@ -1353,6 +1373,7 @@ def plot_evaluate(y_test, y_preds, acc_list):
     axs[1, 0].set_ylabel('True Positive Rate')
     axs[1, 0].set_title('Receiver Operating Characteristic (ROC) Curve')
     axs[1, 0].legend(loc="lower right")
+    axs[1, 0].legend(loc="lower right")
     
     # Precision, Recall, F1 Score, Accuracy
     metric = ['Precision', 'Recall', 'F1 Score', 'Accuracy']
@@ -1409,4 +1430,3 @@ def get_acc():
 def get_pot():
     
     return 1
-

plan_di/plan_di.py

@@ -1223,75 +1223,87 @@ def decode_one_hot(encoded_data):
 
 def roc_curve(y_true, y_score):
     """
-    Computes ROC curve.
+    Compute Receiver Operating Characteristic (ROC) curve.
 
-    Args:
-        y_true (numpy.ndarray): True class labels (binary: 0 or 1).
-        y_score (numpy.ndarray): Predicted probabilities for positive class.
+    Parameters:
+    y_true : array, shape = [n_samples]
+        True binary labels in range {0, 1} or {-1, 1}.
+    y_score : array, shape = [n_samples]
+        Target scores, can either be probability estimates of the positive class,
+        confidence values, or non-thresholded measure of decisions (as returned
+        by decision_function on some classifiers).
 
     Returns:
-        tuple: FPR (False Positive Rate), TPR (True Positive Rate), thresholds.
+    fpr : array, shape = [n]
+        Increasing false positive rates such that element i is the false positive rate
+        of predictions with score >= thresholds[i].
+    tpr : array, shape = [n]
+        Increasing true positive rates such that element i is the true positive rate
+        of predictions with score >= thresholds[i].
+    thresholds : array, shape = [n]
+        Decreasing thresholds on the decision function used to compute fpr and tpr.
     """
+    
+    y_true = np.asarray(y_true)
+    y_score = np.asarray(y_score)
 
-    idx = np.argsort(y_score)[::-1]
-    y_score_sorted = y_score[idx]
-    y_true_sorted = y_true[idx]
+    if len(np.unique(y_true)) != 2:
+        raise ValueError("Only binary classification is supported.")
 
-    tpr = []
-    fpr = []
-    thresholds = np.linspace(0, 1, 100)
+    
+    desc_score_indices = np.argsort(y_score, kind="mergesort")[::-1]
+    y_score = y_score[desc_score_indices]
+    y_true = y_true[desc_score_indices]
 
-    for threshold in thresholds:
-        y_pred_binary = np.where(y_score_sorted >= threshold, 1, 0)
 
-        tp = np.sum((y_true_sorted == 1) & (y_pred_binary == 1))
-        fn = np.sum((y_true_sorted == 1) & (y_pred_binary == 0))
-        tn = np.sum((y_true_sorted == 0) & (y_pred_binary == 0))
-        fp = np.sum((y_true_sorted == 0) & (y_pred_binary == 1))
+    fpr = []
+    tpr = []
+    thresholds = []
+    n_pos = np.sum(y_true)
+    n_neg = len(y_true) - n_pos
 
-        # Check for division by zero
-        if (tp + fn) == 0:
-            tpr_value = 0.0
-        else:
-            tpr_value = tp / (tp + fn)
+    tp = 0
+    fp = 0
+    prev_score = None
 
-        if (fp + tn) == 0:
-            fpr_value = 0.0
+    
+    for i, score in enumerate(y_score):
+        if score != prev_score:
+            fpr.append(fp / n_neg)
+            tpr.append(tp / n_pos)
+            thresholds.append(score)
+            prev_score = score
+
+        if y_true[i] == 1:
+            tp += 1
         else:
-            fpr_value = fp / (fp + tn)
+            fp += 1
 
-        tpr.append(tpr_value)
-        fpr.append(fpr_value)
+    fpr.append(fp / n_neg)
+    tpr.append(tp / n_pos)
+    thresholds.append(score)
 
-    return fpr, tpr, thresholds
+    return np.array(fpr), np.array(tpr), np.array(thresholds)
 
 
-def confusion_matrix(y_true, y_pred, class_count=None):
+def confusion_matrix(y_true, y_pred, class_count):
     """
     Computes confusion matrix.
 
     Args:
         y_true (numpy.ndarray): True class labels (1D array).
         y_pred (numpy.ndarray): Predicted class labels (1D array).
-        class_count (int, optional): Number of classes. If None, inferred from data.
+        num_classes (int): Number of classes.
 
     Returns:
         numpy.ndarray: Confusion matrix of shape (num_classes, num_classes).
     """
-    if class_count is None:
-        class_count = len(np.unique(np.concatenate((y_true, y_pred))))
-
     confusion = np.zeros((class_count, class_count), dtype=int)
 
     for i in range(len(y_true)):
         true_label = y_true[i]
         pred_label = y_pred[i]
-        
-        # Ensure that true_label and pred_label are within the correct range
-        if 0 <= true_label < class_count and 0 <= pred_label < class_count:
-            confusion[true_label, pred_label] += 1
-        else:
-            print(f"Warning: Ignoring out of range label - True: {true_label}, Predicted: {pred_label}")
+        confusion[true_label, pred_label] += 1
 
     return confusion
 
@@ -1305,7 +1317,7 @@ def plot_evaluate(y_test, y_preds, acc_list):
     y_preds = np.array(y_preds)
     fpr, tpr, thresholds = roc_curve(y_true, y_preds)
     precision, recall, f1 = metrics(y_test, y_preds)
-    Class = np.unique(y_test)
+    Class = np.unique(decode_one_hot(y_test))
     
     # Confusion matrix
     cm = confusion_matrix(y_true, y_preds, len(Class))
@@ -1319,7 +1331,8 @@ def plot_evaluate(y_test, y_preds, acc_list):
     axs[0, 0].set_ylabel("Actual Class")
     
     # ROC Curve
-    axs[1, 0].plot(fpr, tpr, color='darkorange', lw=2, label='ROC curve')
+    roc_auc = np.trapz(tpr, fpr)
+    axs[1, 0].plot(fpr, tpr, color='darkorange', lw=2, label=f'ROC curve (area = {roc_auc:.2f})')
     axs[1, 0].plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--')
     axs[1, 0].set_xlim([0.0, 1.0])
     axs[1, 0].set_ylim([0.0, 1.05])
@@ -1327,16 +1340,17 @@ def plot_evaluate(y_test, y_preds, acc_list):
     axs[1, 0].set_ylabel('True Positive Rate')
     axs[1, 0].set_title('Receiver Operating Characteristic (ROC) Curve')
     axs[1, 0].legend(loc="lower right")
+    axs[1, 0].legend(loc="lower right")
     
-    # Precision, Recall, F1 Score ve Accuracy bar grafiği
+    # Precision, Recall, F1 Score, Accuracy
     metric = ['Precision', 'Recall', 'F1 Score', 'Accuracy']
     values = [precision, recall, f1, acc]
     colors = ['#1f77b4', '#ff7f0e', '#2ca02c', '#d62728']
     
-    # Bar grafiği oluşturma
+    #
     bars = axs[0, 1].bar(metric, values, color=colors)
     
-    # Bar grafiği üzerine değer ekleme
+    
     for bar, value in zip(bars, values):
         axs[0, 1].text(bar.get_x() + bar.get_width() / 2, bar.get_height() - 0.05, f'{value:.2f}', 
                        ha='center', va='bottom', fontsize=12, color='white', weight='bold')
@@ -1351,16 +1365,16 @@ def plot_evaluate(y_test, y_preds, acc_list):
     plt.plot(acc_list, marker='o', linestyle='-',
              color='r', label='Accuracy')
     
-    # Sabit yüksek değer için yatay çizgi
+    
     plt.axhline(y=1, color='g', linestyle='--', label='Maximum Accuracy')
     
-    # Eksen ve başlık ayarları
+    
     plt.xlabel('Samples')
     plt.ylabel('Accuracy')
     plt.title('Accuracy History')
     plt.legend()
     
-    # Subplot düzenleme
+    
     plt.tight_layout()
     plt.show()
 
@@ -1381,4 +1395,4 @@ def get_preds():
 
 def get_acc():
 
-    return 2
+    return 2

{pyerualjetwork-2.1.6.dist-info → pyerualjetwork-2.1.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyerualjetwork
-Version: 2.1.6
+Version: 2.1.8
 Summary: 8 new functions: multiple_evaluate , encode_one_hot, split, metrics, decode_one_hot, roc_curve, confusion_matrix, plot_evaluate And Code improvements (Documentation in desc. Examples in GİTHUB: https://github.com/HCB06/PyerualJetwork)
 Author: Hasan Can Beydili
 Author-email: tchasancan@gmail.com

pyerualjetwork-2.1.8.dist-info/RECORD

@@ -0,0 +1,8 @@
+plan_bi/__init__.py,sha256=82q8bWRYqzwMrFuViQzBg7P19i6EqdV7VYBVxuQ-LV0,517
+plan_bi/plan_bi.py,sha256=X07a6h4lsujU6ZOr5jvYJ8SHnqF-pZv0rC1NdqDIn2g,47912
+plan_di/__init__.py,sha256=Eut7tVtvQaczEejYyqfQ4eqF71j69josJcY91WN_dkk,508
+plan_di/plan_di.py,sha256=nnxUtyl2IZsriO0XPG15zFFsKnrMt0idQ9aGX4wCZ0M,44779
+pyerualjetwork-2.1.8.dist-info/METADATA,sha256=m7n0aG1mKt7J9QFBIc7A8zoTZytqVVY3aqEZuO_0Z4c,457
+pyerualjetwork-2.1.8.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
+pyerualjetwork-2.1.8.dist-info/top_level.txt,sha256=aaXSOcnD62fbXG1x7tw4nV50Qxx9g9zDNLK7OD4BdPE,16
+pyerualjetwork-2.1.8.dist-info/RECORD,,

pyerualjetwork-2.1.6.dist-info/RECORD

@@ -1,8 +0,0 @@
-plan_bi/__init__.py,sha256=82q8bWRYqzwMrFuViQzBg7P19i6EqdV7VYBVxuQ-LV0,517
-plan_bi/plan_bi.py,sha256=mfBNSNqoTtXKvPZNCZuNYkVJnkOmg1JpM2FsLhE0nak,47203
-plan_di/__init__.py,sha256=Eut7tVtvQaczEejYyqfQ4eqF71j69josJcY91WN_dkk,508
-plan_di/plan_di.py,sha256=fiaYet8F6N1ad3xIvzLwgUZwridxuc-i03cZifoyJfc,44581
-pyerualjetwork-2.1.6.dist-info/METADATA,sha256=T2M8jWa5LYTkdXcTrzmoHOKVeGdVdgrf_1UXaomsOw4,457
-pyerualjetwork-2.1.6.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
-pyerualjetwork-2.1.6.dist-info/top_level.txt,sha256=aaXSOcnD62fbXG1x7tw4nV50Qxx9g9zDNLK7OD4BdPE,16
-pyerualjetwork-2.1.6.dist-info/RECORD,,