pyerualjetwork 2.1.1__py3-none-any.whl → 2.1.3__py3-none-any.whl

plan_bi/plan_bi.py

@@ -62,8 +62,6 @@ def fit(
     Divides, Piece = synaptic_dividing(len(class_count),W)
     trained_W = [1] * len(W)
     print(Fore.GREEN + "Train Started with 0 ERROR" + Style.RESET_ALL,)
-    train_predictions = [None] * len(y_train)
-    true = 0
     start_time = time.time()
     for index, inp in enumerate(x_train):
         uni_start_time = time.time()
@@ -86,27 +84,20 @@ def fit(
                     cs = Divides[int(k)][Windex][0]
 
        
-                    W[Windex] = synaptic_pruning(w, cs, 'row', int(k),len(class_count),Piece[Windex],1)
+                    W[Windex] = synaptic_pruning(w, cs, 'row', int(k), len(class_count), Piece[Windex], True)
 
         neural_layer = inp
         
         for Lindex, Layer in enumerate(layers):
             
-            
+            y = np.argmax(y_train[index])
             neural_layer = normalization(neural_layer)
-            
 
             if Layer == 'fex':
-                neural_layer,W[Lindex] = fex(neural_layer, W[Lindex], activation_potential, Piece[Windex], 1)
+                W[Lindex] = fex(neural_layer, W[Lindex], activation_potential, Piece[Windex], True, y)
             elif Layer == 'cat':
-                neural_layer,W[Lindex] = cat(neural_layer, W[Lindex], activation_potential, 1, Piece[Windex])
+                W[Lindex] = cat(neural_layer, W[Lindex], True, y)
                 
-        RealOutput = np.argmax(y_train[index])
-        PredictedOutput = np.argmax(neural_layer)
-        if RealOutput == PredictedOutput:
-            true += 1
-        acc = true / len(y_train)
-        train_predictions[index] = PredictedOutput
         
         for i, w in enumerate(W):
             trained_W[i] = trained_W[i] + w
@@ -121,15 +112,16 @@ def fit(
         
         if calculating_est < 60:
             print('\rest......(sec):',calculating_est,'\n',end= "")
-            print('\rTrain accuracy: ' ,acc ,"\n", end="")
-        
+            
         elif calculating_est > 60 and calculating_est < 3600:
             print('\rest......(min):',calculating_est/60,'\n',end= "")
-            print('\rTrain accuracy: ' ,acc ,"\n", end="")
-        
+            
         elif calculating_est > 3600:
             print('\rest......(h):',calculating_est/3600,'\n',end= "")
-            print('\rTrain accuracy: ' ,acc ,"\n", end="")
+            
+        print('\rTraining: ' , index, "/", len(x_train),"\n", end="")
+        
+
         
     EndTime = time.time()
     
@@ -145,20 +137,11 @@ def fit(
         
     elif calculating_est > 3600:
         print('Total training time(h): ',calculating_est/3600)
-        
-    if acc > 0.8:
-        print(Fore.GREEN + '\nTotal Train accuracy: ' ,acc, '\n',Style.RESET_ALL)
-    
-    elif acc < 0.8 and acc > 0.6:
-        print(Fore.MAGENTA + '\nTotal Train accuracy: ' ,acc, '\n',Style.RESET_ALL)
-    
-    elif acc < 0.6:
-        print(Fore.RED+ '\nTotal Train accuracy: ' ,acc, '\n',Style.RESET_ALL)
     
     
     
 
-    return trained_W,train_predictions,acc
+    return trained_W
         
 # FUNCTIONS -----
 
@@ -198,7 +181,7 @@ def synaptic_pruning(
     Class,        # int: Class label for the current training instance.
     class_count, # int: Total number of classes in the dataset.
     piece, #  int: Which set of neurons will information be transferred to?
-    is_training # int: 1 or 0
+    is_training # bool: Flag indicating if the function is called during training (True or False).
     
 ) -> str:
     infoPruning = """
@@ -210,6 +193,8 @@ def synaptic_pruning(
         key (str): key for identifying synaptic row or col connections.
         Class (int): Class label for the current training instance.
         class_count (int): Total number of classes in the dataset.
+        piece (int): Which set of neurons will information be transferred to?
+        is_training (bool): Flag indicating if the function is called during training (True or False).
 
     Returns:
         numpy array: Weight matrix.
@@ -222,7 +207,7 @@ def synaptic_pruning(
               
         ce = cs / Class # ce(cut_end) = cs(cut_start) / current_class
         
-        if is_training == 1:
+        if is_training == True:
         
             p = piece
                 
@@ -293,10 +278,11 @@ def synaptic_dividing(
 
 def fex(
     Input,               # list[num]: Input data.
-    w,                   # list[num]: Weight matrix of the neural network.,
+    w,                   # list[num]: Weight matrix of the neural network.
     activation_potential, # float: Threshold value for comparison.
     piece, # int: Which set of neurons will information be transferred to?
-    is_training # int: 1 or 0
+    is_training, # bool: Flag indicating if the function is called during training (True or False).
+    Class # if is during training then which class(label) ? is isnt then put None.
 ) -> tuple:
     """
     Applies feature extraction process to the input data using synaptic pruning.
@@ -306,24 +292,36 @@ def fex(
         w (list[num]): Weight matrix of the neural network.
         activation_potential (float): Threshold value for comparison.
         piece (int): Which set of neurons will information be transferred to?
+        is_training (bool): Flag indicating if the function is called during training (True or False).
+        Class (int): if is during training then which class(label) ? is isnt then put None.
     Returns:
         tuple: A tuple (vector) containing the neural layer result and the updated weight matrix.
     """
 
-
-    PruneIndex = np.where(Input < activation_potential)
-    w = synaptic_pruning(w, PruneIndex, 'col', 0, 0, piece, is_training)
-
-    neural_layer = np.dot(w, Input)
+    if is_training == True:
+    
+        PruneIndex = np.where(Input < activation_potential)
+        w = synaptic_pruning(w, PruneIndex, 'col', 0, 0, piece, is_training)
+        
+        input_features_index = np.where(w[Class,:] == 1)
+        w[Class,input_features_index] = Input[input_features_index]
+        
+        return w
     
-    return neural_layer,w
+    else:
+        
+        PruneIndex = np.where(Input < activation_potential)
+        w = synaptic_pruning(w, PruneIndex, 'col', 0, 0, piece, is_training)
+        
+        neural_layer = np.dot(w, Input)
+        
+        return neural_layer
 
 def cat(
     Input,               # list[num]: Input data.
     w,                   # list[num]: Weight matrix of the neural network.
-    activation_potential,      # (float): Threshold value for comparison.
-    is_training, # (int): Flag indicating if the function is called during training (1 for training, 0 otherwise).
-    piece              # (int) Which set of neurons will information be transferred to?
+    is_training, # (bool): Flag indicating if the function is called during training (True or False).
+    Class # (int): if is during training then which class(label) ? is isnt then put None.
 ) -> tuple:
     """
     Applies categorization process to the input data using synaptic pruning if specified.
@@ -331,23 +329,25 @@ def cat(
     Args:
         Input (list[num]): Input data.
         w (list[num]): Weight matrix of the neural network.
-        activation_potential (float): Threshold value for comparison.
-        is_training (int): Flag indicating if the function is called during training (1 for training, 0 otherwise).
-        piece (int): Which set of neurons will information be transferred to?
+        is_training (bool): Flag indicating if the function is called during training (True or False).
+        Class (int): if is during training then which class(label) ? is isnt then put None.
     Returns:
         tuple: A tuple containing the neural layer (vector) result and the possibly updated weight matrix.
     """
    
-    PruneIndex = np.where(Input == 0)
     
-    if is_training == 1:
-     
-        w = synaptic_pruning(w, PruneIndex, 'col', 0, 0, piece, is_training)
-     
     
-    neural_layer = np.dot(w, Input)
+    if is_training == True:
+     
+        w[Class,Class] += 1
+        
+        return w
+        
+    else:
+        
+        neural_layer = np.dot(w, Input)
     
-    return neural_layer,w
+        return neural_layer
 
 
 def normalization(
@@ -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 = "")
@@ -468,9 +469,9 @@ def evaluate(
             neural_layer = normalization(neural_layer)
 
             if layers[index] == 'fex':
-                neural_layer = fex(neural_layer, W[index],  activation_potential, 0, 0)[0]
+                neural_layer = fex(neural_layer, W[index],  activation_potential, None, False, None)
             if layers[index] == 'cat':
-                neural_layer = cat(neural_layer, W[index],  activation_potential, 0, 0)[0]
+                neural_layer = cat(neural_layer, W[index], False, None)
                 
         for i, w in enumerate(Wc):
             W[i] = np.copy(w)
@@ -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,7 +537,138 @@ 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: Input activation potential 
+    show_metrices, # (bool): (True or False)
+    MW                  # list[list[num]]: Weight matrix of the neural network.
+) -> tuple:
+    infoTestModel =  """
+    Tests the neural network model with the given test data.
+
+    Args:
+        x_test (list[num]): Test input data.
+        y_test (list[num]): Test labels.
+        activation_potential (float): Input activation potential
+        show_metrices (bool): (True or False)
+        MW (list(list[num])): Multiple Weight matrix list of the neural network. (Multiple model testing)
+
+    Returns:
+        tuple: A tuple containing the predicted labels and the accuracy of the model.
+    """
+    
+    layers = ['fex','cat']
+  
+    try:
+        acc_list = []            
+        print(Fore.GREEN + "\n\nTest Started with 0 ERROR\n" + Style.RESET_ALL)
+        start_time = time.time()
+        true = 0
+        for inpIndex,Input in enumerate(x_test):
+            
+            output_layer = 0
+            
+            for m, Model in enumerate(MW):
+                
+                W = Model
+            
+                Wc = [0] * len(W) # Wc = weight copy
+                
+                y_preds = [None] * len(y_test)
+                for i, w in enumerate(W):
+                    Wc[i] = np.copy(w)
+                    
+                Input = np.array(Input)
+                Input = Input.ravel()
+                uni_start_time = time.time()
+                neural_layer = Input
+                
+                for index, Layer in enumerate(layers):
+                    
+                    neural_layer = normalization(neural_layer)
+        
+                    if layers[index] == 'fex':
+                        neural_layer = fex(neural_layer, W[index],  activation_potentials[m], None, False, None)
+                    if layers[index] == 'cat':
+                        neural_layer = cat(neural_layer, W[index], False, None)
+                    
+                output_layer += neural_layer
+            
+                for i, w in enumerate(Wc):
+                    W[i] = np.copy(w)
+            for i, w in enumerate(Wc):
+                W[i] = np.copy(w)
+            RealOutput = np.argmax(y_test[inpIndex])
+            PredictedOutput = np.argmax(output_layer)
+            if RealOutput == PredictedOutput:
+                true += 1
+            acc = true / len(y_test)
+            if show_metrices == True:
+                
+                acc_list.append(acc)
+                
+            y_preds[inpIndex] = PredictedOutput
+            
+            uni_end_time = time.time()
+                
+            calculating_est = round((uni_end_time - uni_start_time) * (len(x_test) - inpIndex),3)
+                
+            if calculating_est < 60:
+                print('\rest......(sec):',calculating_est,'\n',end= "")
+                print('\rTest accuracy: ' ,acc ,"\n", end="")
+            
+            elif calculating_est > 60 and calculating_est < 3600:
+                print('\rest......(min):',calculating_est/60,'\n',end= "")
+                print('\rTest accuracy: ' ,acc ,"\n", end="")
+            
+            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)
+    
+        calculating_est = round(EndTime - start_time,2)
+        
+        print(Fore.GREEN + "\nTest Finished with 0 ERROR\n")
+        
+        if calculating_est < 60:
+            print('Total testing time(sec): ',calculating_est)
+            
+        elif calculating_est > 60 and calculating_est < 3600:
+            print('Total testing time(min): ',calculating_est/60)
+            
+        elif calculating_est > 3600:
+            print('Total testing time(h): ',calculating_est/3600)
+            
+        if acc >= 0.8:
+            print(Fore.GREEN + '\nTotal Test accuracy: ' ,acc, '\n' + Style.RESET_ALL)
+        
+        elif acc < 0.8 and acc > 0.6:
+            print(Fore.MAGENTA + '\nTotal Test accuracy: ' ,acc, '\n' + Style.RESET_ALL)
+        
+        elif acc <= 0.6:
+            print(Fore.RED+ '\nTotal Test accuracy: ' ,acc, '\n' + Style.RESET_ALL)  
+        
+        
+
+    except:
+        
+            print(Fore.RED + "ERROR: Testing model parameters like 'activation_potential' must be same as trained model. Check parameters. Are you sure weights are loaded ? from: evaluate" + infoTestModel + Style.RESET_ALL)
+            return 'e'
+   
+
+   
+    return W,y_preds,acc
 
 def save_model(model_name,
              model_type,
@@ -560,6 +678,7 @@ def save_model(model_name,
              weights_type,
              weights_format,
              model_path,
+             scaler,
              W
  ):
     
@@ -575,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:
@@ -584,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)
@@ -621,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:
         
@@ -735,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
    
@@ -761,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).
@@ -775,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']
     
@@ -791,9 +912,9 @@ def predict_model_ssd(Input,model_name,model_path):
             neural_layer = normalization(neural_layer)
                                 
             if layers[index] == 'fex':
-                neural_layer = fex(neural_layer, W[index], activation_potential,0, 0)[0]
+                neural_layer = fex(neural_layer, W[index],  activation_potential, None, False, None)
             if layers[index] == 'cat':
-                neural_layer = cat(neural_layer, W[index], activation_potential, 0, 0)[0]
+                neural_layer = cat(neural_layer, W[index], False, None)
     except:
        print(Fore.RED + "ERROR: The input was probably entered incorrectly. from: predict_model_ssd"  + infopredict_model_ssd + Style.RESET_ALL)
        return 'e'
@@ -802,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).
@@ -811,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']
     
@@ -831,9 +956,9 @@ def predict_model_ram(Input,activation_potential,W):
             neural_layer = normalization(neural_layer)
                                   
             if layers[index] == 'fex':
-                neural_layer = fex(neural_layer, W[index], activation_potential,0, 0)[0]
+                neural_layer = fex(neural_layer, W[index],  activation_potential, None, False, None)
             if layers[index] == 'cat':
-                neural_layer = cat(neural_layer, W[index], activation_potential, 0, 0)[0]
+                neural_layer = cat(neural_layer, W[index], False, None)
                 
     except:
         print(Fore.RED + "ERROR: Unexpected input or wrong model parameters from: predict_model_ram."  + infopredict_model_ram + Style.RESET_ALL)
@@ -843,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=0.2, random_state=None):
+    """
+    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')
+    
+
+    plt.xlabel('Samples')
+    plt.ylabel('Accuracy')
+    plt.title('Accuracy History')
+    plt.legend()
     
-  return train_data_scaled, test_data_scaled
+
+    plt.tight_layout()
+    plt.show()
    
 def get_weights():
         
@@ -973,4 +1400,5 @@ def get_acc():
 
 def get_pot():
     
-    return 1
+    return 1
+