pyerualjetwork 2.1.2__py3-none-any.whl → 2.1.4__py3-none-any.whl

plan_bi/plan_bi.py

@@ -426,8 +426,8 @@ def Relu(
 def evaluate(
     x_test,         # list[num]: Test input data.
     y_test,         # list[num]: Test labels.
-    activation_potential,    # float: Threshold value for comparison.
-    visualize,         # str: visualize Testing procces or not visualize ('y' or 'n')
+    activation_potential,    # float: Input activation potential 
+    show_metrices, # (bool): (True or False)
     W                  # list[num]: Weight matrix of the neural network.
 ) -> tuple:
   infoTestModel =  """
@@ -437,7 +437,7 @@ def evaluate(
         x_test (list[num]): Test input data.
         y_test (list[num]): Test labels.
         activation_potential (float): Input activation potential 
-        visualize (str): Visualize test progress ? ('y' or 'n')
+        show_metrices (bool): (True or False)
         W (list[num]): Weight matrix list of the neural network.
 
     Returns:
@@ -450,7 +450,8 @@ def evaluate(
   try:
     Wc = [0] * len(W) # Wc = weight copy
     true = 0
-    TestPredictions = [None] * len(y_test)
+    y_preds = [-1] * len(y_test)
+    acc_list = []
     for i, w in enumerate(W):
         Wc[i] = np.copy(w)
         print('\rCopying weights.....',i+1,'/',len(W),end = "")
@@ -479,25 +480,9 @@ def evaluate(
         if RealOutput == PredictedOutput:
             true += 1
         acc = true / len(y_test)
-        TestPredictions[inpIndex] = PredictedOutput
-        
-        if visualize == 'y':
-        
-            y_testVisual = np.copy(y_test) 
-            y_testVisual = np.argmax(y_testVisual, axis=1)
-            
-            plt.figure(figsize=(12, 6))
-            sns.kdeplot(y_testVisual, label='Real Outputs', fill=True)
-            sns.kdeplot(TestPredictions, label='Predictions', fill=True)
-            plt.legend()
-            plt.xlabel('Class')
-            plt.ylabel('Data size')
-            plt.title('Predictions and Real Outputs for Testing KDE Plot')
-            plt.show()
-            
-            if inpIndex + 1 != len(x_test):
-            
-                plt.close('all')
+        if show_metrices == True:
+            acc_list.append(acc)
+        y_preds[inpIndex] = PredictedOutput
         
         uni_end_time = time.time()
             
@@ -514,7 +499,9 @@ def evaluate(
         elif calculating_est > 3600:
             print('\rest......(h):',calculating_est/3600,'\n',end= "")
             print('\rTest accuracy: ' ,acc ,"\n", end="")
-            
+    if show_metrices == True:
+        plot_evaluate(y_test, y_preds, acc_list)        
+    
     EndTime = time.time()
     for i, w in enumerate(Wc):
         W[i] = np.copy(w)
@@ -550,14 +537,14 @@ def evaluate(
    
 
    
-  return W,TestPredictions,acc
+  return W,y_preds,acc
 
 
 def multiple_evaluate(
     x_test,         # list[num]: Test input data.
     y_test,         # list[num]: Test labels.
-    activation_potentials,    # float: Threshold value for comparison.
-    visualize,         # str: visualize Testing procces or not visualize ('y' or 'n')
+    activation_potentials,    # float: Input activation potential 
+    show_metrices, # (bool): (True or False)
     MW                  # list[list[num]]: Weight matrix of the neural network.
 ) -> tuple:
     infoTestModel =  """
@@ -567,7 +554,7 @@ def multiple_evaluate(
         x_test (list[num]): Test input data.
         y_test (list[num]): Test labels.
         activation_potential (float): Input activation potential
-        visualize (str): Visualize test progress ? ('y' or 'n')
+        show_metrices (bool): (True or False)
         MW (list(list[num])): Multiple Weight matrix list of the neural network. (Multiple model testing)
 
     Returns:
@@ -576,7 +563,8 @@ def multiple_evaluate(
     
     layers = ['fex','cat']
   
-    try:               
+    try:
+        acc_list = []            
         print(Fore.GREEN + "\n\nTest Started with 0 ERROR\n" + Style.RESET_ALL)
         start_time = time.time()
         true = 0
@@ -590,7 +578,7 @@ def multiple_evaluate(
             
                 Wc = [0] * len(W) # Wc = weight copy
                 
-                TestPredictions = [None] * len(y_test)
+                y_preds = [None] * len(y_test)
                 for i, w in enumerate(W):
                     Wc[i] = np.copy(w)
                     
@@ -619,25 +607,11 @@ def multiple_evaluate(
             if RealOutput == PredictedOutput:
                 true += 1
             acc = true / len(y_test)
-            TestPredictions[inpIndex] = PredictedOutput
-            
-            if visualize == 'y':
-            
-                y_testVisual = np.copy(y_test) 
-                y_testVisual = np.argmax(y_testVisual, axis=1)
-                
-                plt.figure(figsize=(12, 6))
-                sns.kdeplot(y_testVisual, label='Real Outputs', fill=True)
-                sns.kdeplot(TestPredictions, label='Predictions', fill=True)
-                plt.legend()
-                plt.xlabel('Class')
-                plt.ylabel('Data size')
-                plt.title('Predictions and Real Outputs for Testing KDE Plot')
-                plt.show()
+            if show_metrices == True:
                 
-                if inpIndex + 1 != len(x_test):
+                acc_list.append(acc)
                 
-                    plt.close('all')
+            y_preds[inpIndex] = PredictedOutput
             
             uni_end_time = time.time()
                 
@@ -654,6 +628,10 @@ def multiple_evaluate(
             elif calculating_est > 3600:
                 print('\rest......(h):',calculating_est/3600,'\n',end= "")
                 print('\rTest accuracy: ' ,acc ,"\n", end="")
+                
+        if show_metrices == True:
+            
+            plot_evaluate(y_test, y_preds, acc_list)
             
         EndTime = time.time()
         for i, w in enumerate(Wc):
@@ -690,7 +668,7 @@ def multiple_evaluate(
    
 
    
-    return W,TestPredictions,acc
+    return W,y_preds,acc
 
 def save_model(model_name,
              model_type,
@@ -700,6 +678,7 @@ def save_model(model_name,
              weights_type,
              weights_format,
              model_path,
+             scaler,
              W
  ):
     
@@ -715,6 +694,7 @@ def save_model(model_name,
     weights_type (str): Type of weights to save (options: 'txt', 'npy', 'mat').
     WeightFormat (str): Format of the weights (options: 'd', 'f', 'raw').
     model_path (str): Path where the model will be saved. For example: C:/Users/beydili/Desktop/denemePLAN/
+    scaler (bool): trained data it used standard_scaler ? (True or False)
     W: Weights list of the model.
     
     Returns:
@@ -724,7 +704,7 @@ def save_model(model_name,
     # Operations to be performed by the function will be written here
     pass
 
-    layers = ['fex','cat']    
+    layers = ['fex','cat']
 
     if weights_type != 'txt' and  weights_type != 'npy' and weights_type != 'mat':
         print(Fore.RED + "ERROR110: Save Weight type (File Extension) Type must be 'txt' or 'npy' or 'mat' from: save_model" + infosave_model + Style.RESET_ALL)
@@ -761,7 +741,8 @@ def save_model(model_name,
             'SAVE DATE': datetime.now(),
             'WEIGHTS TYPE': weights_type,
             'WEIGHTS FORMAT': weights_format,
-            'MODEL PATH': model_path
+            'MODEL PATH': model_path,
+            'STANDARD SCALER': scaler
             }
     try:
         
@@ -875,17 +856,11 @@ def load_model(model_name,
        print(Fore.RED + "ERROR: Model Path error. accaptable form: 'C:/Users/hasancanbeydili/Desktop/denemePLAN/' from: load_model" + infoload_model + Style.RESET_ALL)
 
    model_name = str(df['MODEL NAME'].iloc[0])
-   layers = df['LAYERS'].tolist()
    layer_count = int(df['LAYER COUNT'].iloc[0])
-   class_count = int(df['CLASS COUNT'].iloc[0])
    activation_potential = int(df['ACTIVATION POTENTIAL'].iloc[0])
-   NeuronCount = int(df['NEURON COUNT'].iloc[0])
-   SynapseCount = int(df['SYNAPSE COUNT'].iloc[0])
-   test_acc = int(df['TEST ACCURACY'].iloc[0])
-   model_type = str(df['MODEL TYPE'].iloc[0])
    WeightType = str(df['WEIGHTS TYPE'].iloc[0])
-   WeightFormat = str(df['WEIGHTS FORMAT'].iloc[0])
    model_path = str(df['MODEL PATH'].iloc[0])
+   
 
    W = [0] * layer_count
    
@@ -901,9 +876,9 @@ def load_model(model_name,
    else:
         raise ValueError(Fore.RED + "Incorrect weight type value. Value must be 'txt', 'npy' or 'mat' from: load_model."  + infoload_model + Style.RESET_ALL)
    print(Fore.GREEN + "Model loaded succesfully" + Style.RESET_ALL)     
-   return W,activation_potential,df
+   return W, activation_potential, df
 
-def predict_model_ssd(Input,model_name,model_path):
+def predict_model_ssd(Input, model_name, model_path):
     
     infopredict_model_ssd = """
     Function to make a prediction using a divided pruning learning artificial neural network (PLAN).
@@ -915,7 +890,13 @@ def predict_model_ssd(Input,model_name,model_path):
     Returns:
     ndarray: Output from the model.
     """
-    W,activation_potential = load_model(model_name,model_path)[0:2]
+    W, activation_potential, df = load_model(model_name,model_path)
+    
+    scaler = str(df['STANDARD SCALER'].iloc[0])
+
+    if scaler == 'True':
+
+        Input = standard_scaler(Input, None)
     
     layers = ['fex','cat']
     
@@ -942,7 +923,7 @@ def predict_model_ssd(Input,model_name,model_path):
     return neural_layer
 
 
-def predict_model_ram(Input,activation_potential,W):
+def predict_model_ram(Input, activation_potential, scaler, W):
     
     infopredict_model_ram = """
     Function to make a prediction using a divided pruning learning artificial neural network (PLAN).
@@ -951,11 +932,15 @@ def predict_model_ram(Input,activation_potential,W):
     Arguments:
     Input (list or ndarray): Input data for the model (single vector or single matrix).
     activation_potential (float): Activation potential.
+    scaler (bool): trained data it used standard_scaler ? (True or False)
     W (list of ndarrays): Weights of the model.
 
     Returns:
     ndarray: Output from the model.
     """
+    if scaler == True:
+
+       Input = standard_scaler(Input, None)
     
     layers = ['fex','cat']
     
@@ -983,117 +968,419 @@ def predict_model_ram(Input,activation_potential,W):
     return neural_layer
     
 
-def auto_balancer(x_train, y_train, class_count):
-    
-   infoauto_balancer = """
+
+def auto_balancer(x_train, y_train):
+
+    infoauto_balancer = """
    Function to balance the training data across different classes.
 
    Arguments:
    x_train (list): Input data for training.
    y_train (list): Labels corresponding to the input data.
-   class_count (int): Number of classes.
 
    Returns:
    tuple: A tuple containing balanced input data and labels.
    """
-   try:
-        ClassIndices = {i: np.where(np.array(y_train)[:, i] == 1)[0] for i in range(class_count)}
+    classes = np.arange(y_train.shape[1])
+    class_count = len(classes)
+
+    try:
+        ClassIndices = {i: np.where(np.array(y_train)[:, i] == 1)[
+            0] for i in range(class_count)}
         classes = [len(ClassIndices[i]) for i in range(class_count)]
-        
+
         if len(set(classes)) == 1:
-            print(Fore.WHITE + "INFO: All training data have already balanced. from: auto_balancer"  + Style.RESET_ALL)
+            print(Fore.WHITE + "INFO: All training data have already balanced. from: auto_balancer" + Style.RESET_ALL)
             return x_train, y_train
-        
+
         MinCount = min(classes)
-        
+
         BalancedIndices = []
         for i in range(class_count):
             if len(ClassIndices[i]) > MinCount:
-                SelectedIndices = np.random.choice(ClassIndices[i], MinCount, replace=False)
+                SelectedIndices = np.random.choice(
+                    ClassIndices[i], MinCount, replace=False)
             else:
                 SelectedIndices = ClassIndices[i]
             BalancedIndices.extend(SelectedIndices)
-        
+
         BalancedInputs = [x_train[idx] for idx in BalancedIndices]
         BalancedLabels = [y_train[idx] for idx in BalancedIndices]
-        
-        print(Fore.GREEN + "All Training Data Succesfully Balanced from: " + str(len(x_train)) + " to: " + str(len(BalancedInputs)) + ". from: auto_balancer " + Style.RESET_ALL)
-   except:
+
+        print(Fore.GREEN + "All Training Data Succesfully Balanced from: " + str(len(x_train)
+                                                                                 ) + " to: " + str(len(BalancedInputs)) + ". from: auto_balancer " + Style.RESET_ALL)
+    except:
         print(Fore.RED + "ERROR: Inputs and labels must be same length check parameters" + infoauto_balancer)
         return 'e'
-        
-   return BalancedInputs, BalancedLabels
-   
-def synthetic_augmentation(x, y, class_count):
+
+    return BalancedInputs, BalancedLabels
+
+
+def synthetic_augmentation(x_train, y_train):
     """
     Generates synthetic examples to balance classes with fewer examples.
-    
+
     Arguments:
     x -- Input dataset (examples) - list format
     y -- Class labels (one-hot encoded) - list format
-    class_count -- Number of classes
-    
+
     Returns:
     x_balanced -- Balanced input dataset (list format)
     y_balanced -- Balanced class labels (one-hot encoded, list format)
     """
+    x = x_train
+    y = y_train
+    classes = np.arange(y_train.shape[1])
+    class_count = len(classes)
+
     # Calculate class distribution
     class_distribution = {i: 0 for i in range(class_count)}
     for label in y:
         class_distribution[np.argmax(label)] += 1
-    
+
     max_class_count = max(class_distribution.values())
-    
+
     x_balanced = list(x)
     y_balanced = list(y)
-    
+
     for class_label in range(class_count):
-        class_indices = [i for i, label in enumerate(y) if np.argmax(label) == class_label]
+        class_indices = [i for i, label in enumerate(
+            y) if np.argmax(label) == class_label]
         num_samples = len(class_indices)
-        
+
         if num_samples < max_class_count:
             while num_samples < max_class_count:
-                # Select two random examples
-                random_indices = np.random.choice(class_indices, 2, replace=False)
+
+                random_indices = np.random.choice(
+                    class_indices, 2, replace=False)
                 sample1 = x[random_indices[0]]
                 sample2 = x[random_indices[1]]
-                
-                # Generate a new synthetic example between the two selected examples
-                synthetic_sample = sample1 + (np.array(sample2) - np.array(sample1)) * np.random.rand()
-                
+
+                synthetic_sample = sample1 + \
+                    (np.array(sample2) - np.array(sample1)) * np.random.rand()
+
                 x_balanced.append(synthetic_sample.tolist())
-                y_balanced.append(y[class_indices[0]])  # The new example has the same class label
-                
+                y_balanced.append(y[class_indices[0]])
+
                 num_samples += 1
-    
+
     return np.array(x_balanced), np.array(y_balanced)
 
+
 def standard_scaler(x_train, x_test):
-  info_standard_scaler = """
-  Standardizes training and test datasets.
+    info_standard_scaler = """
+  Standardizes training and test datasets. x_test may be None.
 
   Args:
     train_data: numpy.ndarray
-      Training data (n_samples, n_features)
+      Training data
     test_data: numpy.ndarray
-      Test data (n_samples, n_features)
+      Test data
 
   Returns:
     tuple
       Standardized training and test datasets
   """
-  try:
-    mean = np.mean(x_train, axis=0)
-    std = np.std(x_train, axis=0)
+    try:
+
+        mean = np.mean(x_train, axis=0)
+        std = np.std(x_train, axis=0)
+
+        if x_test == None:
+
+            train_data_scaled = (x_train - mean) / std
+            return train_data_scaled
+
+        else:
+            train_data_scaled = (x_train - mean) / std
+            test_data_scaled = (x_test - mean) / std
+            return train_data_scaled, test_data_scaled
+
+    except:
+        print(
+            Fore.RED + "ERROR: x_train and x_test must be list[numpyarray] from standard_scaler" + info_standard_scaler)
+
+
+def encode_one_hot(y_train, y_test):
+    info_one_hot_encode = """
+    Performs one-hot encoding on y_train and y_test data..
+
+    Args:
+        y_train (numpy.ndarray): Eğitim etiketi verisi.
+        y_test (numpy.ndarray): Test etiketi verisi.
+
+    Returns:
+        tuple: One-hot encoded y_train ve y_test verileri.
+    """
+    try:
+        classes = np.unique(y_train)
+        class_count = len(classes)
+
+        class_to_index = {cls: idx for idx, cls in enumerate(classes)}
+
+        y_train_encoded = np.zeros((y_train.shape[0], class_count))
+        for i, label in enumerate(y_train):
+            y_train_encoded[i, class_to_index[label]] = 1
+
+        y_test_encoded = np.zeros((y_test.shape[0], class_count))
+        for i, label in enumerate(y_test):
+            y_test_encoded[i, class_to_index[label]] = 1
+    except:
+        print(Fore.RED + 'ERROR: y_train and y_test must be numpy array. from: one_hot_encode' + info_one_hot_encode)
+
+    return y_train_encoded, y_test_encoded
+
+
+def split(X, y, test_size, random_state):
+    """
+    Splits the given X (features) and y (labels) data into training and testing subsets.
+
+    Args:
+        X (numpy.ndarray): Features data.
+        y (numpy.ndarray): Labels data.
+        test_size (float or int): Proportion or number of samples for the test subset.
+        random_state (int or None): Seed for 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):
+        test_size = int(test_size * num_samples)
+    elif isinstance(test_size, int):
+        if test_size > num_samples:
+            raise ValueError(
+                "test_size cannot be larger than the number of samples.")
+    else:
+        raise ValueError("test_size should be float or int.")
+
+    if random_state is not None:
+        np.random.seed(random_state)
+
+    indices = np.arange(num_samples)
+    np.random.shuffle(indices)
+
+    test_indices = indices[:test_size]
+    train_indices = indices[test_size:]
+
+    x_train, x_test = X[train_indices], X[test_indices]
+    y_train, y_test = y[train_indices], y[test_indices]
+
+    return x_train, x_test, y_train, y_test
+
+
+def metrics(y_ts, test_preds):
+    """
+    Calculates precision, recall and F1 score for a classification task.
+
+    Args:
+        y_test (list or numpy.ndarray): True labels.
+        test_preds (list or numpy.ndarray): Predicted labels.
+
+    Returns:
+        tuple: Precision, recall, F1 score.
+    """
+    y_test_d = decode_one_hot(y_ts)
+    y_test_d = np.array(y_test_d)
+    y_pred = np.array(test_preds)
+
+    if y_test_d.ndim > 1:
+        y_test_d = y_test_d.reshape(-1)
+    if y_pred.ndim > 1:
+        y_pred = y_pred.reshape(-1)
+
+    tp = {}
+    fp = {}
+    fn = {}
+
+    classes = np.unique(np.concatenate((y_test_d, y_pred)))
+
+    for c in classes:
+        tp[c] = 0
+        fp[c] = 0
+        fn[c] = 0
+
+    for c in classes:
+        for true, pred in zip(y_test_d, y_pred):
+            if true == c and pred == c:
+                tp[c] += 1
+            elif true != c and pred == c:
+                fp[c] += 1
+            elif true == c and pred != c:
+                fn[c] += 1
+
+    precision = {}
+    recall = {}
+    f1 = {}
+
+    for c in classes:
+        precision[c] = tp[c] / (tp[c] + fp[c]) if (tp[c] + fp[c]) > 0 else 0
+        recall[c] = tp[c] / (tp[c] + fn[c]) if (tp[c] + fn[c]) > 0 else 0
+        f1[c] = 2 * (precision[c] * recall[c]) / (precision[c] +
+                                                  recall[c]) if (precision[c] + recall[c]) > 0 else 0
+
+    micro_precision = np.sum(list(tp.values())) / (np.sum(list(tp.values())) + np.sum(
+        list(fp.values()))) if (np.sum(list(tp.values())) + np.sum(list(fp.values()))) > 0 else 0
+    micro_recall = np.sum(list(tp.values())) / (np.sum(list(tp.values())) + np.sum(list(
+        fn.values()))) if (np.sum(list(tp.values())) + np.sum(list(fn.values()))) > 0 else 0
+    micro_f1 = 2 * (micro_precision * micro_recall) / (micro_precision +
+                                                       micro_recall) if (micro_precision + micro_recall) > 0 else 0
+
+    return micro_precision, micro_recall, micro_f1
+
+
+def decode_one_hot(encoded_data):
+    """
+    Decodes one-hot encoded data to original categorical labels.
+
+    Args:
+        encoded_data (numpy.ndarray): One-hot encoded data with shape (n_samples, n_classes).
+
+    Returns:
+        numpy.ndarray: Decoded categorical labels with shape (n_samples,).
+    """
+
+    decoded_labels = np.argmax(encoded_data, axis=1)
+
+    return decoded_labels
+
+
+def roc_curve(y_true, y_score):
+    """
+    Computes ROC curve.
+
+    Args:
+        y_true (numpy.ndarray): True class labels (binary: 0 or 1).
+        y_score (numpy.ndarray): Predicted probabilities for positive class.
+
+    Returns:
+        tuple: FPR (False Positive Rate), TPR (True Positive Rate), thresholds.
+    """
+
+    idx = np.argsort(y_score)[::-1]
+    y_score_sorted = y_score[idx]
+    y_true_sorted = y_true[idx]
+
+    tpr = []
+    fpr = []
+    thresholds = np.linspace(0, 1, 100)
+
+    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))
+
+        # Check for division by zero
+        if (tp + fn) == 0:
+            tpr_value = 0.0
+        else:
+            tpr_value = tp / (tp + fn)
+
+        if (fp + tn) == 0:
+            fpr_value = 0.0
+        else:
+            fpr_value = fp / (fp + tn)
+
+        tpr.append(tpr_value)
+        fpr.append(fpr_value)
+
+    return fpr, tpr, thresholds
+
+
+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).
+        num_classes (int): Number of classes.
+
+    Returns:
+        numpy.ndarray: Confusion matrix of shape (num_classes, num_classes).
+    """
+    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]
+        confusion[true_label, pred_label] += 1
+
+    return confusion
+
+
+def plot_evaluate(y_test, y_preds, acc_list):
+    
+    acc = acc_list[len(acc_list) - 1]
+    y_true = decode_one_hot(y_test)
+
+    y_true = np.array(y_true)
+    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)
+    
+   
+    cm = confusion_matrix(y_true, y_preds, len(Class))
+    
+    fig, axs = plt.subplots(2, 2, figsize=(16, 12))
+    
+    # Confusion Matrix
+    sns.heatmap(cm, annot=True, fmt='d', ax=axs[0, 0])
+    axs[0, 0].set_title("Confusion Matrix")
+    axs[0, 0].set_xlabel("Predicted Class")
+    axs[0, 0].set_ylabel("Actual Class")
+    
+    # ROC Curve
+    axs[1, 0].plot(fpr, tpr, color='darkorange', lw=2, label='ROC curve')
+    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])
+    axs[1, 0].set_xlabel('False Positive Rate')
+    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")
     
+    # Precision, Recall, F1 Score, Accuracy
+    metric = ['Precision', 'Recall', 'F1 Score', 'Accuracy']
+    values = [precision, recall, f1, acc]
+    colors = ['#1f77b4', '#ff7f0e', '#2ca02c', '#d62728']
+    
+    
+    bars = axs[0, 1].bar(metric, values, color=colors)
+    
+   
+    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')
+    
+    axs[0, 1].set_ylim(0, 1) 
+    axs[0, 1].set_xlabel('Metrics')
+    axs[0, 1].set_ylabel('Score')
+    axs[0, 1].set_title('Precision, Recall, F1 Score, and Accuracy')
+    axs[0, 1].grid(True, axis='y', linestyle='--', alpha=0.7)
+    
+          
+    plt.plot(acc_list, marker='o', linestyle='-',
+             color='r', label='Accuracy')
     
-    train_data_scaled = (x_train - mean) / std
-    test_data_scaled = (x_test - mean) / std
 
-  except:
-      print(Fore.RED + "ERROR: x_train and x_test must be numpy array from standard_scaler" + info_standard_scaler)
+    plt.axhline(y=1, color='g', linestyle='--', label='Maximum Accuracy')
     
-  return train_data_scaled, test_data_scaled
+
+    plt.xlabel('Samples')
+    plt.ylabel('Accuracy')
+    plt.title('Accuracy History')
+    plt.legend()
+    
+
+    plt.tight_layout()
+    plt.show()
    
 def get_weights():