pyerualjetwork 1.1.7__py3-none-any.whl → 2.5.8__py3-none-any.whl

plan/plan.py

@@ -1,1054 +1,1698 @@
+
+# -*- coding: utf-8 -*-
+"""
+Created on Tue Jun 18 23:32:16 2024
+
+@author: hasan
+"""
+
+# optic
+
+# -*- coding: utf-8 -*-
+"""
+Created on Fri Jun 21 05:21:35 2024
+
+@author: hasan
+"""
+
+# -*- coding: utf-8 -*-
+
+
+
+"""
+Created on Thu Jun 12 00:00:00 2024
+
+@author: hasan can beydili
+"""
+
+import pandas as pd
 import numpy as np
 import time
-from colorama import Fore,Style
+from colorama import Fore, Style
 from typing import List, Union
 import math
+from scipy.special import expit, softmax
+import matplotlib.pyplot as plt
+import seaborn as sns
+
 # BUILD -----
-def TrainPLAN(
-    Inputs: List[Union[int, float]], 
-    Labels: List[Union[int, float, str]], # At least two.. and one hot encoded
-    ClassCount: int,
-    Layers: List[str],
-    Neurons: List[Union[int, float]],
-    ThresholdSigns: List[str],
-    ThresholdValues: List[Union[int, float]],
-    Normalizations: List[str],
-    Activations: List[str]
+
+
+def fit(
+    x_train: List[Union[int, float]],
+    y_train: List[Union[int, float]], # At least two.. and one hot encoded
+    show_training,
+    show_count= None,
+    val_count= None,
+    val= None,
+    x_val= None,
+    y_val= None,
+    activation_potential=None # (float): Input activation potential (optional)
 ) -> str:
-        
+
     infoPLAN = """
     Creates and configures a PLAN model.
     
     Args:
-        Inputs (list[num]): List of input data.
-        Labels (list[num]): List of labels. (one hot encoded)
-        ClassCount (int): Number of classes.
-        Layers (list[str]): List of layer names. (options: 'fex' (Feature Extraction), 'cat' (Catalyser))
-        Neurons (list[num]): List of neuron counts for each layer.
-        ThresholdSigns (list[str]): List of threshold signs.
-        ThresholdValues (list[num]): List of threshold values.
-        Normalizations (List[str]): Whether normalization will be performed at indexed layers ("y" or "n").
-        Activations (list[str]): List of activation functions.
-    
+        x_train (list[num]): List of input data.
+        y_train (list[num]): List of target labels. (one hot encoded)
+        show_training (bool, str): True, None or'final'
+        show_count (None, int): How many learning steps in total will be displayed in a single figure? (Adjust according to your hardware) Default: 10 (optional)
+        val_count (None, int): After how many examples learned will an accuracy test be performed? Default: 0.1 (%10) (optional)
+        x_val (list[num]): List of validation data. (optional) Default: x_train
+        y_val (list[num]): (list[num]): List of target labels. (one hot encoded) (optional) Default: y_train
+        activation_potential (float): Input activation potential (for binary injection) (optional) in range: -1, 1
     Returns:
-        list([num]): (Weight matrices list, TrainPredictions list.).
+        list([num]): (Weight matrices list, train_predictions list, Train_acc).
         error handled ?: Process status ('e')
 """
-        
-    LastNeuron = Neurons[-1:][0]
-    if LastNeuron != ClassCount:
-            print(Fore.RED + "ERROR108: Last layer of neuron count must be equal class count. from: TrainPLAN",infoPLAN)
-            return 'e'
-    
-    if len(Normalizations) != len(ThresholdValues):
-        
-            print(Fore.RED + "ERROR307: Normalization list length must be equal to length of ThresholdSigns List,ThresholdValues List,Layers List,Neurons List. from: TrainPLAN",infoPLAN)
-            return 'e'
-    
-    if len(Inputs) != len(Labels):
-        print(Fore.RED + "ERROR301: Inputs list and Labels list must be same length.",infoPLAN)
-        return 'e'
-    
-    for i, Value in enumerate(ThresholdValues):
-        
-        if Normalizations[i] != 'y' and Normalizations[i] != 'n':
-                print(Fore.RED + "ERROR105: Normalization list must be 'y' or 'n'.",infoPLAN)
-                return 'e'
-            
-        if ThresholdSigns[i] == 'none':
-            print(Fore.MAGENTA + "WARNING102: We are advise to do not put 'none' Threshold sign. But some cases improves performance of the model from: TrainPLAN",infoPLAN  + Style.RESET_ALL)
-            time.sleep(3)
-            
-        if isinstance(Value, str):
-            print(Fore.RED + "ERROR201: Threshold values must be numeric. from: TrainPLAN")
-            return 'e'
-        
-        if isinstance(Neurons[i], str):
-            print(Fore.RED + "ERROR202: Neurons list must be numeric.")
-            return 'e'
-    
-    if len(ThresholdSigns) != len(ThresholdValues):
-        print(Fore.RED + "ERROR302: Threshold signs list and Threshold Values list must be same length. from: TrainPLAN",infoPLAN)
-        return 'e'
-    
-    if len(Layers) != len(Neurons):
-        print(Fore.RED + "ERROR303: Layers list and Neurons list must same length. from: TrainPLAN",infoPLAN)
-        return 'e'
-    
-    if len(ThresholdValues) != len(Layers) or len(ThresholdSigns) != len(Layers):
-        print(Fore.RED + "ERROR306: Threshold Values and Threshold Signs lists length must be same Layers list length. from: TrainPLAN",infoPLAN)
-        return 'e'
-    
-    
-    for Activation in Activations:
-        if Activation != 'softmax' and Activation != 'sigmoid' and Activation != 'relu' and Activation != 'none':
-            print(Fore.RED + "ERROR108: Activations list must be 'sigmoid' or 'softmax' or 'relu' or 'none' from: TrainPLAN",infoPLAN)
-            return 'e'
-    
+   
 
-    for index, Neuron in enumerate(Neurons):
-        if Neuron < 1:
-            print(Fore.RED + "ERROR101: Neurons list must be positive non zero integer. from: TrainPLAN",infoPLAN)
-            return 'e'
-        
-        if index + 1 != len(Neurons) and Neuron % 2 != 0:
-            print(Fore.MAGENTA + "WARNING101: We strongly advise to do Neuron counts be should even numbers. from: TrainPLAN",infoPLAN)
-            time.sleep(3)
-            
-        if Neuron < ClassCount:
-            print(Fore.RED + "ERROR102: Neuron count must be greater than class count(For PLAN). from: TrainPLAN")
-            return 'e'
-        
-        if Layers[index] != 'fex' and Layers[index] != 'cat':
-            print(Fore.RED + "ERROR107: Layers list must be 'fex'(Feature Extraction Layer) or 'cat' (Catalyser Layer). from: TrainPLAN",infoPLAN)
-            return 'e'
-    
-    if len(ThresholdSigns) != len(ThresholdValues):
-        print(Fore.RED + "ERROR305: Threshold signs list and Threshold values list must be same length. from: TrainPLAN",infoPLAN)
+    if len(x_train) != len(y_train):
+
+        print(Fore.RED + "ERROR301: x_train list and y_train list must be same length. from: fit", infoPLAN)
         return 'e'
     
-    
-    for i, Sign in enumerate(ThresholdSigns):
-        if Sign != '>' and Sign != '<' and Sign != '==' and Sign != '!=' and Sign != 'none':
-            print(Fore.RED + "ERROR104: Threshold signs must be '>' or '<' or '==' or '!='. or 'none' from: TrainPLAN",infoPLAN)
-            return 'e'
+    if x_val == None and y_val == None:
+
+        x_val = x_train
+        y_val = y_train
+
+    if val == True and val_count == None:
+
+        val_count =  0.1
+        val_count_copy = val_count
+
+    if val == True:
         
-        if Layers[i] == 'fex' and Sign == 'none':
-            print(Fore.RED + "ERROR109: at layer type 'fex', pairing with 'none' Threshold is not acceptlable. if you want to 'none' put '==' and make threshold value '0'. from: TrainPLAN ",infoPLAN)
-            return 'e'
+        val_count = int(len(x_train) * val_count)
+
+        val_count_copy = val_count
+
+    if show_training == True or show_training == 'final' and show_count == None:
         
-    UniqueLabels = set()
-    for sublist in Labels:
-      
-        UniqueLabels.add(tuple(sublist))
-    
-    
-    UniqueLabels = list(UniqueLabels)
-    
-    Labels = [tuple(sublist) for sublist in Labels]
-    
-    
-    if len(UniqueLabels) != ClassCount:
-        print(Fore.RED + "ERROR106: Label variety length must be same Class Count. from: TrainPLAN",infoPLAN)
-        return 'e'
-    
-    Inputs[0] = np.array(Inputs[0])
-    Inputs[0] = Inputs[0].ravel()
-    InputSize = len(Inputs[0])
+        show_count = 10
+
+    if show_training == True or show_training == 'final':
+
+        row, col = shape_control(x_train)
     
-    W = WeightIdentification(len(Layers) - 1,ClassCount,Neurons,InputSize)
-    Divides = SynapticDividing(ClassCount,W)
-    TrainedWs = [1] * len(W)
-    print(Fore.GREEN + "Train Started with 0 ERROR" + Style.RESET_ALL,)
-    TrainPredictions = [1] * len(Labels)
-    true = 0
-    Inputs, Labels = AutoBalancer(Inputs, Labels, ClassCount)
-    StartTime = time.time()
-    for index, inp in enumerate(Inputs):
-        UniStartTime = time.time()
+    class_count = set()
+
+    for sublist in y_train:
+
+        class_count.add(tuple(sublist))
+
+    class_count = list(class_count)
+
+    y_train = [tuple(sublist) for sublist in y_train]
+
+    neurons = [len(class_count), len(class_count)]
+    layers = ['fex']
+    val_list = [None]
+
+    x_train[0] = np.array(x_train[0])
+    x_train[0] = x_train[0].ravel()
+    x_train_size = len(x_train[0])
+
+    W = weight_identification(
+        len(layers) - 1, len(class_count), neurons, x_train_size)
+
+    trained_W = [1] * len(W)
+    print(Fore.GREEN + "Train Started with 0 ERROR" + Style.RESET_ALL)
+    start_time = time.time()
+    y = decode_one_hot(y_train)
+
+    for index, inp in enumerate(x_train):
+
+        progress = index / len(x_train) * 100
+
+        uni_start_time = time.time()
         inp = np.array(inp)
         inp = inp.ravel()
         
-        if InputSize != len(inp):
-            print(Fore.RED +"ERROR304: All input matrices or vectors in inputs list, must be same size. from: TrainPLAN",infoPLAN + Style.RESET_ALL)
+        if x_train_size != len(inp):
+            print(Fore.RED + "ERROR304: All input matrices or vectors in x_train list, must be same size. from: fit",
+                  infoPLAN + Style.RESET_ALL)
             return 'e'
-        
-        
-        for Ulindex, Ul in enumerate(UniqueLabels):
-            
-            if Ul == Labels[index]:
-                for Windex, w in enumerate(W):
-                    for i, ul in enumerate(Ul):
-                        if ul == 1.0:
-                            k = i
-                    Cs = Divides[int(k)][Windex][0]
-       
-                    W[Windex] = SynapticPruning(w, Cs, 'row', int(k),ClassCount)
-
-        NeuralLayer = inp
-        
-        for Lindex, Layer in enumerate(Layers):
+
+        neural_layer = inp
+
+        for Lindex, Layer in enumerate(layers):
+
+            neural_layer = normalization(neural_layer)
+
+            if Layer == 'fex':
+                W[Lindex] = fex(neural_layer, W[Lindex], True, y[index], activation_potential)
+
+        for i, w in enumerate(W):
+                trained_W[i] = trained_W[i] + w
+
             
-            if Normalizations[Lindex] == 'y':
-                NeuralLayer = Normalization(NeuralLayer)
+        if val == True:
+
+            if index == val_count:
                 
-            if Activations[Lindex] == 'relu':
-                NeuralLayer = Relu(NeuralLayer)
-            elif Activations[Lindex] == 'sigmoid':
-                NeuralLayer = Sigmoid(NeuralLayer)
-            elif Activations[Lindex] == 'softmax':
-                NeuralLayer = Softmax(NeuralLayer)
+                val_count += val_count_copy
+
+                layers.append('cat')
+                trained_W.append(np.eye(len(class_count)))
+
+                validation_model = evaluate(x_val, y_val, None, trained_W)
+                                            
+                layers.pop()
+                trained_W.pop()
+
+                val_acc = validation_model[get_acc()]
+
+                val_list.append(val_acc)
+
                 
-            if Layer == 'fex':
-                NeuralLayer,W[Lindex] = Fex(NeuralLayer, W[Lindex], ThresholdSigns[Lindex], ThresholdValues[Lindex])
-            elif Layer == 'cat':
-                NeuralLayer,W[Lindex] = Cat(NeuralLayer, W[Lindex], ThresholdSigns[Lindex], ThresholdValues[Lindex],1)
+                plt.plot(val_list, linestyle='-',
+                color='r')
                 
-        RealOutput = np.argmax(Labels[index])
-        PredictedOutput = np.argmax(NeuralLayer)
-        if RealOutput == PredictedOutput:
-            true += 1
-        Acc = true / len(Labels)
-        TrainPredictions[index] = PredictedOutput+1
-        
-        if index == 0:
-            for i, w in enumerate(W):
-                TrainedWs[i] = w
-                     
-        else:
-            for i, w in enumerate(W):
-                TrainedWs[i] = TrainedWs[i] + w
-            
+                progress_status = f"{progress:.1f}"
+                plt.title('Validation accuracy graph. Amount of data learned by the model: % ' + progress_status)
+                plt.xlabel('Learning Progress')
+                plt.ylabel('Accuracy')
+                plt.ylim(0, 1)
+                plt.draw()
+                plt.pause(0.1)
+
+        if show_training == True:
+
+            if index %show_count == 0:
+                  
+
+                  if index != 0:
+                    plt.close(fig)
+
+                  if row != 0:
+                  
+                    fig, ax = plt.subplots(1, len(class_count), figsize=(18, 14))
+                        
+                  else:
                 
-        W = WeightIdentification(len(Layers) - 1,ClassCount,Neurons,InputSize)
-         
+                    fig, ax = plt.subplots(1, 1, figsize=(18, 14))
+                    
+            for j in range(len(class_count)):
+
+              
+                if row != 0:
+              
+                    mat = trained_W[0][j,:].reshape(row, col)
+                    suptitle_info = 'Neurons Learning Progress: % '
+                    title_info = f'{j+1}. Neuron'
+                    
+                    mat = trained_W[0][j,:].reshape(row, col)
+
+                    ax[j].imshow(mat, interpolation='sinc', cmap='viridis')
+
+                    ax[j].set_aspect('equal')
+                    
+                    ax[j].set_xticks([])
+                    ax[j].set_yticks([])
+                    ax[j].set_title(title_info)
+
+                else:
+                    
+                    mat = trained_W[0]
+                    ax.imshow(mat, interpolation='sinc', cmap='viridis')
+                    suptitle_info = 'Weight Learning Progress: % '
+                    title_info = 'Weight Matrix Of Fex Layer'
+                    
+                    
                
-        UniEndTime = time.time()
-        
-        CalculatingEst = round((UniEndTime - UniStartTime) * (len(Inputs) - index),3)
-        
-        if CalculatingEst < 60:
-            print('\rest......(sec):',CalculatingEst,'\n',end= "")
-            print('\rTrain Accuracy: ' ,Acc ,"\n", end="")
-        
-        elif CalculatingEst > 60 and CalculatingEst < 3600:
-            print('\rest......(min):',CalculatingEst/60,'\n',end= "")
-            print('\rTrain Accuracy: ' ,Acc ,"\n", end="")
-        
-        elif CalculatingEst > 3600:
-            print('\rest......(h):',CalculatingEst/3600,'\n',end= "")
-            print('\rTrain Accuracy: ' ,Acc ,"\n", end="")
-        
+
+                progress_status = f"{progress:.1f}"
+                fig.suptitle(suptitle_info + progress_status)
+                plt.draw()
+                plt.pause(0.1)
+                  
+                  
+        W = weight_identification(
+            len(layers) - 1, len(class_count), neurons, x_train_size)
+
+        uni_end_time = time.time()
+
+        calculating_est = round(
+            (uni_end_time - uni_start_time) * (len(x_train) - index), 3)
+
+        if calculating_est < 60:
+            print('\rest......(sec):', calculating_est, '\n', end="")
+
+        elif calculating_est > 60 and calculating_est < 3600:
+            print('\rest......(min):', calculating_est/60, '\n', end="")
+
+        elif calculating_est > 3600:
+            print('\rest......(h):', calculating_est/3600, '\n', end="")
+
+        print('\rTraining: ', index, "/", len(x_train), "\n", end="")
+
+    if show_training == 'final':
+            
+            fig, ax = plt.subplots(1, len(class_count), figsize=(18, 14))
+
+            for j in range(len(class_count)):
+
+                mat = trained_W[0][j,:].reshape(row, col)
+
+                ax[j].imshow(mat, interpolation='sinc', cmap='viridis')
+                ax[j].set_aspect('equal')
+                
+                ax[j].set_xticks([])
+                ax[j].set_yticks([])
+                ax[j].set_title(f'{j+1}. Neuron')
+
+            progress_status = f"{progress:.1f}"
+            fig.suptitle('Neurons Learning Progress: % ' + progress_status)
+            plt.draw()
+            plt.pause(0.1)
+
+
     EndTime = time.time()
+
+    calculating_est = round(EndTime - start_time, 2)
+
+    print(Fore.GREEN + " \nTrain Finished with 0 ERROR\n" + Style.RESET_ALL)
+
+    if calculating_est < 60:
+        print('Total training time(sec): ', calculating_est)
+
+    elif calculating_est > 60 and calculating_est < 3600:
+        print('Total training time(min): ', calculating_est/60)
+
+    elif calculating_est > 3600:
+        print('Total training time(h): ', calculating_est/3600)
     
-    CalculatingEst = round(EndTime - StartTime,2)
-    
-    print(Fore.GREEN + " \nTrain Finished with 0 ERROR\n")
-    
-    if CalculatingEst < 60:
-        print('Total training time(sec): ',CalculatingEst)
+    layers.append('cat')
+    trained_W.append(np.eye(len(class_count)))
+                
+                
+    return trained_W
+
+# FUNCTIONS -----
+
+def shape_control(x_train):
+
+    try:
+        row = x_train[1].shape[0]
+        col = x_train[1].shape[1]
         
-    elif CalculatingEst > 60 and CalculatingEst < 3600:
-        print('Total training time(min): ',CalculatingEst/60)
+    except:
+
+        print(Fore.MAGENTA + 'WARNING: You trying show_training but inputs is raveled. x_train inputs should be reshaped for show_training.' + Style.RESET_ALL)
         
-    elif CalculatingEst > 3600:
-        print('Total training time(h): ',CalculatingEst/3600)
+        try:
+            row, col = find_numbers(len(x_train[0]))
+            
+        except:
         
-    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 TrainedWs,TrainPredictions
+            print(Fore.MAGENTA + 'WARNING: Input length cannot be reshaped. Neurons learning progression cannot be draw, weight learning progress drwaing started.' + Style.RESET_ALL)
+            return [0, 0]
         
-# FUNCTIONS -----
-
-def WeightIdentification(
-    LayerCount,      # int: Number of layers in the neural network.
-    ClassCount,      # int: Number of classes in the classification task.
-    Neurons,         # list[num]: List of neuron counts for each layer.
-    InputSize        # int: Size of the input data.
-) -> str:
-    """
-    Identifies the weights for a neural network model.
+    return row, col
 
-    Args:
-        LayerCount (int): Number of layers in the neural network.
-        ClassCount (int): Number of classes in the classification task.
-        Neurons (list[num]): List of neuron counts for each layer.
-        InputSize (int): Size of the input data.
+def find_numbers(n):
+    if n <= 1:
+        raise ValueError("Parameter 'n' must be greater than 1.")
 
-    Returns:
-        list([numpy_arrays],[...]): Weight matices of the model. .
-    """
+    for i in range(2, int(n**0.5) + 1):
+        if n % i == 0:
+            factor1 = i
+            factor2 = n // i
+            if factor1 == factor2:
+                return factor1, factor2
 
-    
-    Wlen = LayerCount + 1
-    W = [None] * Wlen
-    W[0] = np.ones((Neurons[0],InputSize))
-    ws = LayerCount - 1
-    for w in range(ws):
-        W[w + 1] = np.ones((Neurons[w + 1],Neurons[w]))
-    W[LayerCount] = np.ones((ClassCount,Neurons[LayerCount - 1]))
-    return W
+    return None
 
-def SynapticPruning(
-    w,            # list[list[num]]: Weight matrix of the neural network.
-    Cs,           # list[list[num]]: Synaptic connections between neurons.
-    Key,          # int: Key for identifying synaptic connections.
-    Class,        # int: Class label for the current training instance.
-    ClassCount   # int: Total number of classes in the dataset.
-    
+def weight_normalization(
+    W,
+    class_count
 ) -> str:
-    infoPruning = """
-    Performs synaptic pruning in a neural network model.
+    """
+    Row(Neuron) based normalization. For unbalanced models.
 
     Args:
-        w (list[list[num]]): Weight matrix of the neural network.
-        Cs (list[list[num]]): Synaptic connections between neurons.
-        Key (str): Key for identifying synaptic row or col connections.
-        Class (int): Class label for the current training instance.
-        ClassCount (int): Total number of classes in the dataset.
+            W (list(num)): Trained weight matrix list.
+            class_count (int): Class count of model.
 
     Returns:
-        numpy array: Weight matrix.
+        list([numpy_arrays],[...]): posttrained weight matices of the model. .
     """
 
-    
-    Class += 1 # because index start 0
-    
-    if Class != ClassCount and Class != 1:
-            
-            Ce = Cs / Class
-     
-            w[int(Ce)-1::-1,:] = 0
-          
-            w[Cs:,:] = 0
-    
-
-    else:
+    for i in range(class_count):
         
-        if Class == 1:
-            if Key == 'row':
-    
-                w[Cs:,:] = 0
-    
-            elif Key == 'col':
-    
-                w[:,Cs] = 0
+            W[0][i,:] = normalization(W[0][i,:])
     
-            else:
-                print(Fore.RED + "ERROR103: SynapticPruning func's Key parameter must be 'row' or 'col' from: SynapticPruning" + infoPruning)
-                return 'e'
-        else:
-            if Key == 'row':
-    
-                w[Cs:,:] = 0
-    
-                Ce = int(round(w.shape[0] - Cs / ClassCount))
-                w[Ce-1::-1,:] = 0
-    
-            elif Key == 'col':
-    
-                w[:,Cs] = 0
-    
-            else:
-                print(Fore.RED + "ERROR103: SynapticPruning func's Key parameter must be 'row' or 'col' from: SynapticPruning" + infoPruning + Style.RESET_ALL)
-                return 'e'
-    return w
+    return W
 
-def SynapticDividing(
-    ClassCount,    # int: Total number of classes in the dataset.
-    W              # list[list[num]]: Weight matrix of the neural network.
+def weight_identification(
+    layer_count,      # int: Number of layers in the neural network.
+    class_count,      # int: Number of classes in the classification task.
+    neurons,         # list[num]: List of neuron counts for each layer.
+    x_train_size        # int: Size of the input data.
 ) -> str:
     """
-    Divides the synaptic weights of a neural network model based on class count.
+    Identifies the weights for a neural network model.
 
     Args:
-        ClassCount (int): Total number of classes in the dataset.
-        W (list[list[num]]): Weight matrix of the neural network.
+        layer_count (int): Number of layers in the neural network.
+        class_count (int): Number of classes in the classification task.
+        neurons (list[num]): List of neuron counts for each layer.
+        x_train_size (int): Size of the input data.
 
     Returns:
-        list: a 3D list holds informations of divided net.
+        list([numpy_arrays],[...]): pretrained weight matices of the model. .
     """
 
-    
-    Piece = [1] * len(W)
-    #print('Piece:' + Piece)
-    #input()
-    # Boş bir üç boyutlu liste oluşturma
-    Divides = [[[0] for _ in range(len(W))] for _ in range(ClassCount)]
-    
-    for i in range(len(W)):
-            
-
-            Piece[i] = int(math.floor(W[i].shape[0] / ClassCount))
-
-    Cs = 0
-    # j = Classes, i = Weights, [0] = CutStart.
+    Wlen = layer_count + 1
+    W = [None] * Wlen
+    W[0] = np.ones((neurons[0], x_train_size))
+    ws = layer_count - 1
+    for w in range(ws):
+        W[w + 1] = np.ones((neurons[w + 1], neurons[w]))
+   
+    return W
 
-    for i in range(len(W)):
-        for j in range(ClassCount):
-            Cs = Cs + Piece[i]
-            Divides[j][i][0] = Cs
-            #print('Divides: ' + j + i + ' = ' + Divides[j][i][0])
-            #input()
-        
-        j = 0
-        Cs = 0
-        
-    return Divides
-        
 
-def Fex(
+def fex(
     Input,               # list[num]: Input data.
-    w,                   # list[list[num]]: Weight matrix of the neural network.
-    ThresholdsSign,      # str: Sign for threshold comparison ('<', '>', '==', '!=').
-    ThresholdValue       # num: Threshold value for comparison.
+    w,                   # num: Weight matrix of the neural network.
+    is_training,        # bool: Flag indicating if the function is called during training (True or False).
+    Class,               # int: Which class is, if training.
+    activation_potential # float or None: Input activation potential (optional)
 ) -> tuple:
     """
     Applies feature extraction process to the input data using synaptic pruning.
 
     Args:
-        Input (list[num]): Input data.
-        w (list[list[num]]): Weight matrix of the neural network.
-        ThresholdsSign (str): Sign for threshold comparison ('<', '>', '==', '!=').
-        ThresholdValue (num): Threshold value for comparison.
+        Input (num): Input data.
+        w (num): Weight matrix of the neural network.
+        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.
+        activation_potential (float or None): Threshold value for comparison. (optional)
 
     Returns:
         tuple: A tuple (vector) containing the neural layer result and the updated weight matrix.
     """
 
-    if ThresholdsSign == '<':
-        PruneIndex = np.where(Input < ThresholdValue)
-    elif ThresholdsSign == '>': 
-        PruneIndex = np.where(Input > ThresholdValue)
-    elif ThresholdsSign == '==':
-        PruneIndex = np.where(Input == ThresholdValue)
-    elif ThresholdsSign == '!=':
-        PruneIndex = np.where(Input != ThresholdValue)
-
-    w = SynapticPruning(w, PruneIndex, 'col', 0, 0)
-
-    NeuralLayer = np.dot(w, Input)
-    return NeuralLayer,w
-
-def Cat(
-    Input,               # list[num]: Input data.
-    w,                   # list[list[num]]: Weight matrix of the neural network.
-    ThresholdsSign,      # str: Sign for threshold comparison ('<', '>', '==', '!=').
-    ThresholdValue,      # num: Threshold value for comparison.
-    isTrain              # int: Flag indicating if the function is called during training (1 for training, 0 otherwise).
-) -> tuple:
-    """
-    Applies categorization process to the input data using synaptic pruning if specified.
-
-    Args:
-        Input (list[num]): Input data.
-        w (list[list[num]]): Weight matrix of the neural network.
-        ThresholdsSign (str): Sign for threshold comparison ('<', '>', '==', '!=').
-        ThresholdValue (num): Threshold value for comparison.
-        isTrain (int): Flag indicating if the function is called during training (1 for training, 0 otherwise).
+    if is_training == True and activation_potential == None:
+        
+        w[Class, :] = Input
 
-    Returns:
-        tuple: A tuple containing the neural layer (vector) result and the possibly updated weight matrix.
-    """
+        return w
 
-    if ThresholdsSign == '<':     
-        PruneIndex = np.where(Input < ThresholdValue)
-    elif ThresholdsSign == '>':     
-        PruneIndex = np.where(Input > ThresholdValue)
-    elif ThresholdsSign == '==':
-        PruneIndex = np.where(Input == ThresholdValue)
-    elif ThresholdsSign == '!=':     
-        PruneIndex = np.where(Input != ThresholdValue)
-    if isTrain == 1 and ThresholdsSign != 'none':
-     
-            w = SynapticPruning(w, PruneIndex, 'col', 0, 0)
+    elif is_training == True and activation_potential != None:
+   
+            
+            Input[Input < activation_potential] = 0
+            Input[Input > activation_potential] = 1
+            
+            w[Class,:] = Input
+        
+            return w
+           
+    elif is_training == False and activation_potential == None:
+        
+            neural_layer = np.dot(w, Input)
      
-    
-    NeuralLayer = np.dot(w, Input)
-    return NeuralLayer,w
+            return neural_layer
+        
+    elif is_training == False and activation_potential != None:
+        
+            Input[Input < activation_potential] = 0
+            Input[Input > activation_potential] = 1
+        
+            neural_layer = np.dot(w, Input)
+        
+            return neural_layer
+
 
 
-def Normalization(
-    Input  # list[num]: Input data to be normalized.
+def normalization(
+    Input  # num: Input data to be normalized.
 ):
     """
     Normalizes the input data using maximum absolute scaling.
 
     Args:
-        Input (list[num]): Input data to be normalized.
+        Input (num): Input data to be normalized.
 
     Returns:
-        list[num]: Scaled input data after normalization.
+        (num) Scaled input data after normalization.
     """
 
-   
     AbsVector = np.abs(Input)
-    
+
     MaxAbs = np.max(AbsVector)
-    
+
     ScaledInput = Input / MaxAbs
-    
+
     return ScaledInput
 
 
 def Softmax(
-    x  # list[num]: Input data to be transformed using softmax function.
+    x  # num: Input data to be transformed using softmax function.
 ):
     """
     Applies the softmax function to the input data.
 
     Args:
-        x (list[num]): Input data to be transformed using softmax function.
+        (num): Input data to be transformed using softmax function.
 
     Returns:
-        list[num]: Transformed data after applying softmax function.
+       (num): Transformed data after applying softmax function.
     """
 
-
-    MaxX = np.max(x)
-    
-    x -= MaxX
-    
-    ExpX = np.exp(x)
-    
-    SumExpX = np.sum(ExpX)
-    
-    SoftmaxX = ExpX / SumExpX
-    
-    return SoftmaxX
+    return softmax(x)
 
 
 def Sigmoid(
-    x  # list[num]: Input data to be transformed using sigmoid function.
+    x  # num: Input data to be transformed using sigmoid function.
 ):
     """
     Applies the sigmoid function to the input data.
 
     Args:
-        x (list[num]): Input data to be transformed using sigmoid function.
+        (num): Input data to be transformed using sigmoid function.
 
     Returns:
-        list[num]: Transformed data after applying sigmoid function.
+        (num): Transformed data after applying sigmoid function.
     """
-
-    PositiveMask = x >= 0
-    NegativeMask = ~PositiveMask
-   
-    ExpXPositive = np.exp(-np.clip(x[PositiveMask], -709, None))
-    ExpXNegative = np.exp(np.clip(x[NegativeMask], None, 709))
-
-    SigmoidX = np.zeros_like(x, dtype=float)
-    SigmoidX[PositiveMask] = 1 / (1 + ExpXPositive)
-    SigmoidX[NegativeMask] = ExpXNegative / (1 + ExpXNegative)
-   
-    return SigmoidX
+    return expit(x)
 
 
 def Relu(
-    x  # list[num]: Input data to be transformed using ReLU function.
+    x  # num: Input data to be transformed using ReLU function.
 ):
     """
     Applies the Rectified Linear Unit (ReLU) function to the input data.
 
     Args:
-        x (list[num]): Input data to be transformed using ReLU function.
+        (num): Input data to be transformed using ReLU function.
 
     Returns:
-        list[num]: Transformed data after applying ReLU function.
+        (num): Transformed data after applying ReLU function.
     """
 
-    
     return np.maximum(0, x)
 
 
-def TestPLAN(
-    TestInputs,         # list[list[num]]: Test input data.
-    TestLabels,         # list[num]: Test labels.
-    Layers,             # list[str]: List of layer names.
-    ThresholdSigns,     # list[str]: List of threshold signs for each layer.
-    ThresholdValues,    # list[num]: List of threshold values for each layer.
-    Normalizations,    # str: Whether normalization will be performed ("y" or "n").
-    Activation,         # str: Activation function list for the neural network.
-    W                  # list[list[num]]: Weight matrix of the neural network.
+def evaluate(
+    x_test,         # list[num]: Test input data.
+    y_test,         # list[num]: Test labels.
+    show_metrices,      # show_metrices (bool): (True or False)
+    W,               # list[num]: Weight matrix list of the neural network.
+    activation_potential=None # activation_potential (float or None): Threshold value for comparison. (optional)
 ) -> tuple:
-    infoTestModel =  """
+    infoTestModel = """
     Tests the neural network model with the given test data.
 
     Args:
-        TestInputs (list[list[num]]): Test input data.
-        TestLabels (list[num]): Test labels.
-        Layers (list[str]): List of layer names.
-        ThresholdSigns (list[str]): List of threshold signs for each layer.
-        ThresholdValues (list[num]): List of threshold values for each layer.
-        Normalizatios list([str]): Whether normalization will be performed ("yes" or "no").
-        Activation (str): Activation function for the neural network.
-        W (list[list[num]]): Weight matrix of the neural network.
+        x_test (list[num]): Test input data.
+        y_test (list[num]): Test labels.
+        show_metrices (bool): (True or False)
+        W (list[num]): Weight matrix list of the neural network.
+        activation_potential (float or None): Threshold value for comparison. (optional)
 
     Returns:
         tuple: A tuple containing the predicted labels and the accuracy of the model.
     """
 
+    layers = ['fex', 'cat']
 
     try:
-        Wc = [0] * len(W)
+        Wc = [0] * len(W)  # Wc = Weight copy
         true = 0
-        TestPredictions = [1] * len(TestLabels)
+        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 = "")
-                
+            print('\rCopying weights.....', i+1, '/', len(W), end="")
+    
         print(Fore.GREEN + "\n\nTest Started with 0 ERROR\n" + Style.RESET_ALL)
-        StartTime = time.time()
-        for inpIndex,Input in enumerate(TestInputs):
+        start_time = time.time()
+        for inpIndex, Input in enumerate(x_test):
             Input = np.array(Input)
             Input = Input.ravel()
-            UniStartTime = time.time()
-            NeuralLayer = Input
-            
-            for index, Layer in enumerate(Layers):
-                if Normalizations[index] == 'y':
-                    NeuralLayer = Normalization(NeuralLayer)
-                if Activation[index] == 'relu':
-                        NeuralLayer = Relu(NeuralLayer)
-                elif Activation[index] == 'sigmoid':
-                        NeuralLayer = Sigmoid(NeuralLayer)
-                elif Activation[index] == 'softmax':
-                        NeuralLayer = Softmax(NeuralLayer)
-                        
-                if Layers[index] == 'fex':
-                    NeuralLayer,useless = Fex(NeuralLayer, W[index], ThresholdSigns[index], ThresholdValues[index])
-                if Layers[index] == 'cat':
-                    NeuralLayer,useless = Cat(NeuralLayer, W[index], ThresholdSigns[index], ThresholdValues[index],0)
-            for i, w in enumerate(Wc):
-                W[i] = np.copy(w)
-            RealOutput = np.argmax(TestLabels[inpIndex])
-            PredictedOutput = np.argmax(NeuralLayer)
-            if RealOutput == PredictedOutput:
+            uni_start_time = time.time()
+            neural_layer = Input
+    
+            for index, Layer in enumerate(layers):
+    
+                neural_layer = normalization(neural_layer)
+    
+                if Layer == 'fex':
+                    neural_layer = fex(neural_layer, W[index], False, None, activation_potential)
+                elif Layer == 'cat':
+                    neural_layer = np.dot(W[index], neural_layer)
+    
+            for i, w in enumerate(Wc):
+                W[i] = np.copy(w)
+            RealOutput = np.argmax(y_test[inpIndex])
+            PredictedOutput = np.argmax(neural_layer)
+            if RealOutput == PredictedOutput:
                 true += 1
-            Acc = true / len(TestLabels)
-            TestPredictions[inpIndex] = PredictedOutput+1
-            UniEndTime = time.time()
-                
-            CalculatingEst = round((UniEndTime - UniStartTime) * (len(TestInputs) - inpIndex),3)
-                
-            if CalculatingEst < 60:
-                print('\rest......(sec):',CalculatingEst,'\n',end= "")
-                print('\rTest Accuracy: ' ,Acc ,"\n", end="")
-            
-            elif CalculatingEst > 60 and CalculatingEst < 3600:
-                print('\rest......(min):',CalculatingEst/60,'\n',end= "")
-                print('\rTest Accuracy: ' ,Acc ,"\n", end="")
-            
-            elif CalculatingEst > 3600:
-                print('\rest......(h):',CalculatingEst/3600,'\n',end= "")
-                print('\rTest Accuracy: ' ,Acc ,"\n", end="")
-                
+            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)
-
-        CalculatingEst = round(EndTime - StartTime,2)
-        
+    
+        calculating_est = round(EndTime - start_time, 2)
+    
         print(Fore.GREEN + "\nTest Finished with 0 ERROR\n")
-        
-        if CalculatingEst < 60:
-            print('Total testing time(sec): ',CalculatingEst)
-            
-        elif CalculatingEst > 60 and CalculatingEst < 3600:
-            print('Total testing time(min): ',CalculatingEst/60)
-            
-        elif CalculatingEst > 3600:
-            print('Total testing time(h): ',CalculatingEst/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)   
     
+        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: Are you sure weights are loaded ? from: evaluate" +
+              infoTestModel + Style.RESET_ALL)
+        return 'e'
+
+    return W, y_preds, acc
+
+
+def multiple_evaluate(
+    x_test,         # list[num]: Test input data.
+    y_test,         # list[num]: Test labels.
+    show_metrices,      # show_metrices (bool): Visualize test progress ? (True or False)
+    MW,                  # list[list[num]]: Weight matrix of the neural network.
+    activation_potential=None # (float or None): Threshold value for comparison. (optional)
+) -> 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.
+        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:
+        y_preds = [-1] * len(y_test)
+        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 Layer == 'fex':
+                        neural_layer = fex(neural_layer, W[index], False, None, activation_potential)
+                    elif Layer == 'cat':
+                        neural_layer = np.dot(W[index], neural_layer)
+
+                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)
         
-        print(Fore.RED + "ERROR: Testing model parameters like 'Layers' 'ThresholdCounts' must be same as trained model. Check parameters. Are you sure weights are loaded ? from: TestPLAN" + infoTestModel + Style.RESET_ALL)
+        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 TestPredictions,Acc
-
-def SavePLAN(ModelName,
-             ModelType,
-             Layers,
-             ClassCount,
-             ThresholdSigns,
-             ThresholdValues,
-             Normalizations,
-             Activations,
-             TestAcc,
-             LogType,
-             WeightsType,
-             WeightFormat,
-             SavePath,
-             W
- ):
-    
-    infoSavePLAN = """
-    Function to save a deep learning model.
+
+    return W, y_preds, acc
+
+
+def save_model(model_name,
+               model_type,
+               class_count,
+               test_acc,
+               weights_type,
+               weights_format,
+               model_path,
+               scaler_params,
+               W,
+               activation_potential=None
+               ):
+
+    infosave_model = """
+    Function to save a pruning learning model.
 
     Arguments:
-    ModelName (str): Name of the model.
-    ModelType (str): Type of the model.(options: PLAN)
-    Layers (list): List containing 'fex' and 'cat' layers.
-    ClassCount (int): Number of classes.
-    ThresholdSigns (list): List containing threshold signs.
-    ThresholdValues (list): List containing threshold values.
-    DoNormalization (str): is that normalized data ? 'y' or 'n'.
-    Activations (list): List containing activation functions for each layer.
-    TestAcc (float): Test accuracy of the model.
-    LogType (str): Type of log to save (options: 'csv', 'txt', 'hdf5').
-    WeightsType (str): Type of weights to save (options: 'txt', 'npy', 'mat').
+    model_name (str): Name of the model.
+    model_type (str): Type of the model.(options: PLAN)
+    class_count (int): Number of classes.
+    test_acc (float): Test accuracy of the model.
+    weights_type (str): Type of weights to save (options: 'txt', 'npy', 'mat').
     WeightFormat (str): Format of the weights (options: 'd', 'f', 'raw').
-    SavePath (str): Path where the model will be saved. For example: C:/Users/beydili/Desktop/denemePLAN/
+    model_path (str): Path where the model will be saved. For example: C:/Users/beydili/Desktop/denemePLAN/
+    scaler_params (int, float): standard scaler params list: mean,std. If not used standard scaler then be: None.
     W: Weights of the model.
+    activation_potential (float or None): Threshold value for comparison. (optional)
     
     Returns:
     str: Message indicating if the model was saved successfully or encountered an error.
     """
-    
+
     # Operations to be performed by the function will be written here
     pass
 
-    if LogType != 'csv' and  LogType != 'txt' and LogType != 'hdf5':
-        print(Fore.RED + "ERROR109: Save Log Type (File Extension) must be 'csv' or 'txt' or 'hdf5' from: SavePLAN" + infoSavePLAN + Style.RESET_ALL)
-        return 'e'
-    
-    if WeightsType != 'txt' and  WeightsType != 'npy' and WeightsType != 'mat':
-        print(Fore.RED + "ERROR110: Save Weight type (File Extension) Type must be 'txt' or 'npy' or 'mat' from: SavePLAN" + infoSavePLAN + Style.RESET_ALL)
+    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)
         return 'e'
-    
-    if WeightFormat != 'd' and  WeightFormat != 'f' and WeightFormat != 'raw':
-        print(Fore.RED + "ERROR111: Weight Format Type must be 'd' or 'f' or 'raw' from: SavePLAN" + infoSavePLAN + Style.RESET_ALL)
+
+    if weights_format != 'd' and weights_format != 'f' and weights_format != 'raw':
+        print(Fore.RED + "ERROR111: Weight Format Type must be 'd' or 'f' or 'raw' from: save_model" +
+              infosave_model + Style.RESET_ALL)
         return 'e'
-    
+
     NeuronCount = 0
     SynapseCount = 0
+
     try:
         for w in W:
             NeuronCount += np.shape(w)[0]
             SynapseCount += np.shape(w)[0] * np.shape(w)[1]
     except:
-        
-        print(Fore.RED + "ERROR: Weight matrices has a problem from: SavePLAN" + infoSavePLAN + Style.RESET_ALL)
+
+        print(Fore.RED + "ERROR: Weight matrices has a problem from: save_model" +
+              infosave_model + Style.RESET_ALL)
         return 'e'
     import pandas as pd
     from datetime import datetime
     from scipy import io
-    
-    data = {'MODEL NAME': ModelName,
-            'MODEL TYPE': ModelType,
-            'LAYERS': Layers,
-            'LAYER COUNT': len(Layers),
-            'CLASS COUNT': ClassCount,
-            'THRESHOLD SIGNS': ThresholdSigns,
-            'THRESHOLD VALUES': ThresholdValues,
-            'NORMALIZATION': Normalizations,
-            'ACTIVATIONS': Activations,
+
+    data = {'MODEL NAME': model_name,
+            'MODEL TYPE': model_type,
+            'LAYERS': layers,
+            'LAYER COUNT': len(layers),
+            'CLASS COUNT': class_count,
             'NEURON COUNT': NeuronCount,
             'SYNAPSE COUNT': SynapseCount,
-            'TEST ACCURACY': TestAcc,
+            'TEST ACCURACY': test_acc,
             'SAVE DATE': datetime.now(),
-            'WEIGHTS TYPE': WeightsType,
-            'WEIGHTS FORMAT': WeightFormat,
-            'SAVE PATH': SavePath
+            'WEIGHTS TYPE': weights_type,
+            'WEIGHTS FORMAT': weights_format,
+            'MODEL PATH': model_path,
+            'STANDARD SCALER': scaler_params,
+            'ACTIVATION POTENTIAL': activation_potential
             }
     try:
-        
+
         df = pd.DataFrame(data)
-        
-        if  LogType == 'csv':
-        
-            df.to_csv(SavePath + ModelName + '.csv', sep='\t', index=False)
-            
-        elif LogType == 'txt':
-            
-            df.to_csv(SavePath + ModelName + '.txt', sep='\t', index=False)
-            
-        elif LogType == 'hdf5':
-            
-            df.to_hdf(SavePath + ModelName + '.h5', key='data', mode='w')
-            
+
+        df.to_csv(model_path + model_name + '.txt', sep='\t', index=False)
+
     except:
-        
-        print(Fore.RED + "ERROR: Model log not saved. Check the log parameters from: SavePLAN" + infoSavePLAN + Style.RESET_ALL)
+
+        print(Fore.RED + "ERROR: Model log not saved probably model_path incorrect. Check the log parameters from: save_model" +
+              infosave_model + Style.RESET_ALL)
         return 'e'
     try:
-        
-        if WeightsType == 'txt' and WeightFormat == 'd':
-            
+
+        if weights_type == 'txt' and weights_format == 'd':
+
             for i, w in enumerate(W):
-                np.savetxt(SavePath + ModelName +  str(i+1) + 'w.txt' ,  w, fmt='%d')
-                
-        if WeightsType == 'txt' and WeightFormat == 'f':
-             
+                np.savetxt(model_path + model_name +
+                           str(i+1) + 'w.txt',  w, fmt='%d')
+
+        if weights_type == 'txt' and weights_format == 'f':
+
             for i, w in enumerate(W):
-                 np.savetxt(SavePath + ModelName +  str(i+1) + 'w.txt' ,  w, fmt='%f')
-        
-        if WeightsType == 'txt' and WeightFormat == 'raw':
-            
+                np.savetxt(model_path + model_name +
+                           str(i+1) + 'w.txt',  w, fmt='%f')
+
+        if weights_type == 'txt' and weights_format == 'raw':
+
             for i, w in enumerate(W):
-                np.savetxt(SavePath + ModelName +  str(i+1) + 'w.txt' ,  w)
-            
-                
+                np.savetxt(model_path + model_name + str(i+1) + 'w.txt',  w)
+
         ###
-        
-        
-        if WeightsType == 'npy' and WeightFormat == 'd':
-            
+
+        if weights_type == 'npy' and weights_format == 'd':
+
             for i, w in enumerate(W):
-                np.save(SavePath + ModelName + str(i+1) + 'w.npy', w.astype(int))
-        
-        if WeightsType == 'npy' and WeightFormat == 'f':
-             
+                np.save(model_path + model_name +
+                        str(i+1) + 'w.npy', w.astype(int))
+
+        if weights_type == 'npy' and weights_format == 'f':
+
             for i, w in enumerate(W):
-                 np.save(SavePath + ModelName +  str(i+1) + 'w.npy' ,  w, w.astype(float))
-        
-        if WeightsType == 'npy' and WeightFormat == 'raw':
-            
+                np.save(model_path + model_name + str(i+1) +
+                        'w.npy',  w, w.astype(float))
+
+        if weights_type == 'npy' and weights_format == 'raw':
+
             for i, w in enumerate(W):
-                np.save(SavePath + ModelName +  str(i+1) + 'w.npy' ,  w)
-                
-           
+                np.save(model_path + model_name + str(i+1) + 'w.npy',  w)
+
         ###
-        
-         
-        if WeightsType == 'mat' and WeightFormat == 'd':
-            
+
+        if weights_type == 'mat' and weights_format == 'd':
+
             for i, w in enumerate(W):
                 w = {'w': w.astype(int)}
-                io.savemat(SavePath + ModelName + str(i+1) + 'w.mat', w)
-    
-        if WeightsType == 'mat' and WeightFormat == 'f':
-             
+                io.savemat(model_path + model_name + str(i+1) + 'w.mat', w)
+
+        if weights_type == 'mat' and weights_format == 'f':
+
             for i, w in enumerate(W):
                 w = {'w': w.astype(float)}
-                io.savemat(SavePath + ModelName + str(i+1) + 'w.mat', w)
-        
-        if WeightsType == 'mat' and WeightFormat == 'raw':
-            
+                io.savemat(model_path + model_name + str(i+1) + 'w.mat', w)
+
+        if weights_type == 'mat' and weights_format == 'raw':
+
             for i, w in enumerate(W):
                 w = {'w': w}
-                io.savemat(SavePath + ModelName + str(i+1) + 'w.mat', w)
-            
+                io.savemat(model_path + model_name + str(i+1) + 'w.mat', w)
+
     except:
-        
-        print(Fore.RED + "ERROR: Model Weights not saved. Check the Weight parameters. SaveFilePath expl: 'C:/Users/hasancanbeydili/Desktop/denemePLAN/' from: SavePLAN" + infoSavePLAN + Style.RESET_ALL)
+
+        print(Fore.RED + "ERROR: Model Weights not saved. Check the Weight parameters. SaveFilePath expl: 'C:/Users/hasancanbeydili/Desktop/denemePLAN/' from: save_model" + infosave_model + Style.RESET_ALL)
         return 'e'
     print(df)
     message = (
         Fore.GREEN + "Model Saved Successfully\n" +
-        Fore.MAGENTA + "Don't forget, if you want to load model: model log file and weight files must be in the same directory." + 
+        Fore.MAGENTA + "Don't forget, if you want to load model: model log file and weight files must be in the same directory." +
         Style.RESET_ALL
-        )
-    
+    )
+
     return print(message)
 
 
-def LoadPLAN(ModelName,
-             LoadPath,
-             LogType,
-):
-   infoLoadPLAN = """
-   Function to load a deep learning model.
+def load_model(model_name,
+               model_path,
+               ):
+    infoload_model = """
+   Function to load a pruning learning model.
 
    Arguments:
-   ModelName (str): Name of the model.
-   LoadPath (str): Path where the model is saved.
-   LogType (str): Type of log to load (options: 'csv', 'txt', 'hdf5').
+   model_name (str): Name of the model.
+   model_path (str): Path where the model is saved.
 
    Returns:
-   lists: W(list[num]), Layers, ThresholdSigns, ThresholdValues, Normalization,Activations
+   lists: W(list[num]), activation_potential, DataFrame of the model
     """
-   pass
+    pass
+
+    import scipy.io as sio
 
+    try:
+
+        df = pd.read_csv(model_path + model_name + '.' + 'txt', delimiter='\t')
+
+    except:
+
+        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])
+    layer_count = int(df['LAYER COUNT'].iloc[0])
+    WeightType = str(df['WEIGHTS TYPE'].iloc[0])
+
+    W = [0] * layer_count
+
+    if WeightType == 'txt':
+        for i in range(layer_count):
+            W[i] = np.loadtxt(model_path + model_name + str(i+1) + 'w.txt')
+    elif WeightType == 'npy':
+        for i in range(layer_count):
+            W[i] = np.load(model_path + model_name + str(i+1) + 'w.npy')
+    elif WeightType == 'mat':
+        for i in range(layer_count):
+            W[i] = sio.loadmat(model_path + model_name + str(i+1) + 'w.mat')
+    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, df
+
+
+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).
+
+    Arguments:
+    Input (list or ndarray): Input data for the model (single vector or single matrix).
+    model_name (str): Name of the model.
+    Returns:
+    ndarray: Output from the model.
+    """
+    W, df = load_model(model_name, model_path)
     
-   import pandas as pd
-   import scipy.io as sio
-   
-   try:
-   
-       if LogType == 'csv':
-           df = pd.read_csv(LoadPath + ModelName + '.' + LogType)
+    activation_potential = str(df['ACTIVATION POTENTIAL'].iloc[0])
+
+    if activation_potential != 'nan':
+
+        activation_potential = float(activation_potential)
         
+    else:
+    
+        activation_potential = None
     
-       if LogType == 'txt':
-           df = pd.read_csv(LoadPath + ModelName + '.' + LogType, delimiter='\t')
+    try:
+        
+        scaler_params = df['STANDARD SCALER'].tolist()
+                
+             
+        scaler_params = [np.fromstring(arr.strip('[]'), sep=' ') for arr in scaler_params]
+
+        Input = standard_scaler(None, Input, scaler_params)
         
+    except:
     
-       if LogType == 'hdf5':
-           df = pd.read_hdf(LoadPath + ModelName + '.' + LogType)
-   except:
-       print(Fore.RED + "ERROR: Model Path error. Accaptable form: 'C:/Users/hasancanbeydili/Desktop/denemePLAN/' from: LoadPLAN" + infoLoadPLAN + Style.RESET_ALL)
-
-   ModelName = str(df['MODEL NAME'].iloc[0])
-   Layers = df['LAYERS'].tolist()
-   LayerCount = int(df['LAYER COUNT'].iloc[0])
-   ClassCount = int(df['CLASS COUNT'].iloc[0])
-   ThresholdSigns = df['THRESHOLD SIGNS'].tolist()
-   ThresholdValues = df['THRESHOLD VALUES'].tolist()
-   Normalization = df['NORMALIZATION'].tolist()
-   Activations = df['ACTIVATIONS'].tolist()
-   NeuronCount = int(df['NEURON COUNT'].iloc[0])
-   SynapseCount = int(df['SYNAPSE COUNT'].iloc[0])
-   TestAcc = int(df['TEST ACCURACY'].iloc[0])
-   ModelType = str(df['MODEL TYPE'].iloc[0])
-   WeightType = str(df['WEIGHTS TYPE'].iloc[0])
-   WeightFormat = str(df['WEIGHTS FORMAT'].iloc[0])
-   SavePath = str(df['SAVE PATH'].iloc[0])
-
-   W = [0] * LayerCount
-   
-   if WeightType == 'txt':
-       for i in range(LayerCount):    
-           W[i] = np.loadtxt(LoadPath + ModelName + str(i+1) + 'w.txt')
-   elif WeightType == 'npy':
-       for i in range(LayerCount):    
-           W[i] = np.load(LoadPath + ModelName + str(i+1) + 'w.npy')
-   elif WeightType == 'mat':
-       for i in range(LayerCount):  
-           W[i] = sio.loadmat(LoadPath + ModelName + str(i+1) + 'w.mat')
-   else:
-        raise ValueError(Fore.RED + "Incorrect weight type value. Value must be 'txt', 'npy' or 'mat' from: LoadPLAN."  + infoLoadPLAN + Style.RESET_ALL)
-   print(Fore.GREEN + "Model loaded succesfully" + Style.RESET_ALL)     
-   return W,Layers,ThresholdSigns,ThresholdValues,Normalization,Activations,df
-
-def PredictFromDiscPLAN(Input,ModelName,ModelPath,LogType):
-    infoPredictFromDİscPLAN = """
-    Function to make a prediction using a divided pruning deep learning neural network (PLAN).
+        non_scaled = True
+        
 
-    Arguments:
-    Input (list or ndarray): Input data for the model (single vector or single matrix).
-    ModelName (str): Name of the model.
-    ModelPath (str): Path where the model is saved.
-    LogType (str): Type of log to load (options: 'csv', 'txt', 'hdf5').
+    layers = ['fex', 'cat']
 
-    Returns:
-    ndarray: Output from the model.
-    """
-    W,Layers,ThresholdSigns,ThresholdValues,Normalization,Activations = LoadPLAN(ModelName,ModelPath,
-                                                                                  LogType)[0:6]
     Wc = [0] * len(W)
     for i, w in enumerate(W):
         Wc[i] = np.copy(w)
     try:
-        NeuralLayer = Input
-        NeuralLayer = np.array(NeuralLayer)
-        NeuralLayer = NeuralLayer.ravel()
-        for index, Layer in enumerate(Layers):                                                                          
-            if Normalization == 'y':
-                NeuralLayer = Normalization(NeuralLayer)
-            if Activations[index] == 'relu':
-                NeuralLayer = Relu(NeuralLayer)
-            elif Activations[index] == 'sigmoid':
-                NeuralLayer = Sigmoid(NeuralLayer)
-            elif Activations[index] == 'softmax':
-                NeuralLayer = Softmax(NeuralLayer)
-                                
-            if Layers[index] == 'fex':
-                NeuralLayer,useless = Fex(NeuralLayer, W[index],
-                                          ThresholdSigns[index],
-                                          ThresholdValues[index])
-            if Layers[index] == 'cat':
-                NeuralLayer,useless = Cat(NeuralLayer, W[index],
-                                          ThresholdSigns[index],
-                                          ThresholdValues[index],
-                                          0)
+        neural_layer = Input
+        neural_layer = np.array(neural_layer)
+        neural_layer = neural_layer.ravel()
+        for index, Layer in enumerate(layers):
+
+            neural_layer = normalization(neural_layer)
+
+            if Layer == 'fex':
+                neural_layer = fex(neural_layer, W[index], False, None, activation_potential)
+            elif Layer == 'cat':
+                neural_layer = np.dot(W[index], neural_layer)
     except:
-       print(Fore.RED + "ERROR: The input was probably entered incorrectly. from: PredictFromDiscPLAN"  + infoPredictFromDİscPLAN + Style.RESET_ALL)
-       return 'e'
+        print(Fore.RED + "ERROR: The input was probably entered incorrectly. from: predict_model_ssd" +
+              infopredict_model_ssd + Style.RESET_ALL)
+        return 'e'
     for i, w in enumerate(Wc):
         W[i] = np.copy(w)
-    return NeuralLayer
+    return neural_layer
 
 
-def PredictFromRamPLAN(Input,Layers,ThresholdSigns,ThresholdValues,Normalizations,Activations,W):
-    infoPredictFromRamPLAN = """
-    Function to make a prediction using a pruning learning artificial neural network (PLAN)
+def predict_model_ram(Input, scaler_params, W, activation_potential=None):
+
+    infopredict_model_ram = """
+    Function to make a prediction using a divided pruning learning artificial neural network (PLAN).
     from weights and parameters stored in memory.
 
     Arguments:
     Input (list or ndarray): Input data for the model (single vector or single matrix).
-    Layers (list): Number and types of layers.
-    ThresholdSigns (list): Threshold signs.
-    ThresholdValues (list): Threshold values.
-    DoNormalization (str): Whether to normalize ('y' or 'n').
-    Activations (list): Activation functions for each layer.
+    scaler_params (int, float): standard scaler params list: mean,std. If not used standard scaler then be: None.
     W (list of ndarrays): Weights of the model.
+    activation_potential (float or None): Threshold value for comparison. (optional)
 
     Returns:
     ndarray: Output from the model.
     """
     
+    if scaler_params != None:
+
+        Input = standard_scaler(None, Input, scaler_params)
+
+    layers = ['fex', 'cat']
+
     Wc = [0] * len(W)
     for i, w in enumerate(W):
         Wc[i] = np.copy(w)
     try:
-        NeuralLayer = Input
-        NeuralLayer = np.array(NeuralLayer)
-        NeuralLayer = NeuralLayer.ravel()
-        for index, Layer in enumerate(Layers):                                                                          
-            if Normalizations[index] == 'y':
-                NeuralLayer = Normalization(NeuralLayer)
-            if Activations[index] == 'relu':
-                NeuralLayer = Relu(NeuralLayer)
-            elif Activations[index] == 'sigmoid':
-                NeuralLayer = Sigmoid(NeuralLayer)
-            elif Activations[index] == 'softmax':
-                NeuralLayer = Softmax(NeuralLayer)
-                                
-            if Layers[index] == 'fex':
-                NeuralLayer,useless = Fex(NeuralLayer, W[index],
-                                          ThresholdSigns[index],
-                                          ThresholdValues[index])
-            if Layers[index] == 'cat':
-                NeuralLayer,useless = Cat(NeuralLayer, W[index],
-                                          ThresholdSigns[index],
-                                          ThresholdValues[index],0)
+        neural_layer = Input
+        neural_layer = np.array(neural_layer)
+        neural_layer = neural_layer.ravel()
+        for index, Layer in enumerate(layers):
+
+            neural_layer = normalization(neural_layer)
+
+            if Layer == 'fex':
+                neural_layer = fex(neural_layer, W[index], False, None, activation_potential)
+            elif Layer == 'cat':
+                neural_layer = np.dot(W[index], neural_layer)
+
     except:
-        print(Fore.RED + "ERROR: Unexpected input or wrong model parameters from: PredictFromRamPLAN."  + infoPredictFromRamPLAN + Style.RESET_ALL)
+        print(Fore.RED + "ERROR: Unexpected input or wrong model parameters from: predict_model_ram." +
+              infopredict_model_ram + Style.RESET_ALL)
         return 'e'
     for i, w in enumerate(Wc):
         W[i] = np.copy(w)
-    return NeuralLayer
-    
+    return neural_layer
+
+
+def auto_balancer(x_train, y_train):
 
-def AutoBalancer(TrainInputs, TrainLabels, ClassCount):
-   infoAutoBalancer = """
+    infoauto_balancer = """
    Function to balance the training data across different classes.
 
    Arguments:
-   TrainInputs (list): Input data for training.
-   TrainLabels (list): Labels corresponding to the input data.
-   ClassCount (int): Number of classes.
+   x_train (list): Input data for training.
+   y_train (list): Labels corresponding to the input data.
 
    Returns:
    tuple: A tuple containing balanced input data and labels.
    """
-   try:
-        ClassIndices = {i: np.where(np.array(TrainLabels)[:, i] == 1)[0] for i in range(ClassCount)}
-        ClassCounts = [len(ClassIndices[i]) for i in range(ClassCount)]
-        
-        if len(set(ClassCounts)) == 1:
-            print(Fore.WHITE + "INFO: All training data have already balanced. from: AutoBalancer"  + Style.RESET_ALL)
-            time.sleep(1.5)
-            return TrainInputs, TrainLabels
-        
-        MinCount = min(ClassCounts)
-        
+    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)
+            return x_train, y_train
+
+        MinCount = min(classes)
+
         BalancedIndices = []
-        for i in range(ClassCount):
+        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.RED + "ERROR: Inputs and labels must be same length check parameters" + infoauto_balancer)
+        return 'e'
+
+    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
+
+    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]
+        num_samples = len(class_indices)
+
+        if num_samples < max_class_count:
+            while num_samples < max_class_count:
+
+                random_indices = np.random.choice(
+                    class_indices, 2, replace=False)
+                sample1 = x[random_indices[0]]
+                sample2 = x[random_indices[1]]
+
+                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]])
+
+                num_samples += 1
+
+    return np.array(x_balanced), np.array(y_balanced)
+
+
+def standard_scaler(x_train, x_test, scaler_params=None):
+    info_standard_scaler = """
+  Standardizes training and test datasets. x_test may be None.
+
+  Args:
+    train_data: numpy.ndarray
+      Training data
+    test_data: numpy.ndarray
+      Test data
+
+  Returns:
+    list:
+    Scaler parameters: mean and std
+    tuple
+      Standardized training and test datasets
+  """
+    try:
+            
+        if scaler_params == None and x_test != None:
+            
+            mean = np.mean(x_train, axis=0)
+            std = np.std(x_train, axis=0)
+            train_data_scaled = (x_train - mean) / std
+            test_data_scaled = (x_test - mean) / std
+            
+            train_data_scaled = np.nan_to_num(train_data_scaled, nan=0)
+            test_data_scaled = np.nan_to_num(test_data_scaled, nan=0)
+            
+            scaler_params = [mean, std]
+            
+            return scaler_params, train_data_scaled, test_data_scaled
         
-        BalancedInputs = [TrainInputs[idx] for idx in BalancedIndices]
-        BalancedLabels = [TrainLabels[idx] for idx in BalancedIndices]
+        if scaler_params == None and x_test == None:
+            
+            mean = np.mean(x_train, axis=0)
+            std = np.std(x_train, axis=0)
+            train_data_scaled = (x_train - mean) / std
+            
+            train_data_scaled = np.nan_to_num(train_data_scaled, nan=0)
+            
+            scaler_params = [mean, std]
+            
+            return scaler_params, train_data_scaled
+            
+        if scaler_params != None:
+            
+            test_data_scaled = (x_test - scaler_params[0]) / scaler_params[1]
+            test_data_scaled = np.nan_to_num(test_data_scaled, nan=0)
+            
+            return 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, average='weighted'):
+    """
+    Calculates precision, recall and F1 score for a classification task.
+    
+    Args:
+        y_ts (list or numpy.ndarray): True labels.
+        test_preds (list or numpy.ndarray): Predicted labels.
+        average (str): Type of averaging ('micro', 'macro', 'weighted').
+
+    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
+
+    if average == 'micro':
+        precision_val = 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
+        recall_val = 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
+        f1_val = 2 * (precision_val * recall_val) / (precision_val + recall_val) if (precision_val + recall_val) > 0 else 0
+
+    elif average == 'macro':
+        precision_val = np.mean(list(precision.values()))
+        recall_val = np.mean(list(recall.values()))
+        f1_val = np.mean(list(f1.values()))
+
+    elif average == 'weighted':
+        weights = np.array([np.sum(y_test_d == c) for c in classes])
+        weights = weights / np.sum(weights)
+        precision_val = np.sum([weights[i] * precision[classes[i]] for i in range(len(classes))])
+        recall_val = np.sum([weights[i] * recall[classes[i]] for i in range(len(classes))])
+        f1_val = np.sum([weights[i] * f1[classes[i]] for i in range(len(classes))])
+
+    else:
+        raise ValueError("Invalid value for 'average'. Choose from 'micro', 'macro', 'weighted'.")
+
+    return precision_val, recall_val, f1_val
+
+
+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):
+    """
+    Compute Receiver Operating Characteristic (ROC) curve.
+
+    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:
+    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)
+
+    if len(np.unique(y_true)) != 2:
+        raise ValueError("Only binary classification is supported.")
+
+    
+    desc_score_indices = np.argsort(y_score, kind="mergesort")[::-1]
+    y_score = y_score[desc_score_indices]
+    y_true = y_true[desc_score_indices]
+
+
+    fpr = []
+    tpr = []
+    thresholds = []
+    n_pos = np.sum(y_true)
+    n_neg = len(y_true) - n_pos
+
+    tp = 0
+    fp = 0
+    prev_score = None
+
+    
+    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:
+            fp += 1
+
+    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):
+    """
+    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)
+    Class = np.unique(decode_one_hot(y_test))
+
+    precision, recall, f1 = metrics(y_test, y_preds)
+    
+    
+    # Confusion matrix
+    cm = confusion_matrix(y_true, y_preds, len(Class))
+    # Subplot içinde düzenleme
+    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")
+    
+    if len(Class) == 2:
+        fpr, tpr, thresholds = roc_curve(y_true, y_preds)
+        # 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])
+        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")
+        axs[1, 0].legend(loc="lower right")
+    else:
+
+        for i in range(len(Class)):
+            
+            y_true_copy = np.copy(y_true)
+            y_preds_copy = np.copy(y_preds)
+        
+            y_true_copy[y_true_copy == i] = 0
+            y_true_copy[y_true_copy != 0] = 1
+            
+            y_preds_copy[y_preds_copy == i] = 0
+            y_preds_copy[y_preds_copy != 0] = 1
+            
+
+            fpr, tpr, thresholds = roc_curve(y_true_copy, y_preds_copy)
+            
+            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])
+            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")
+            axs[1, 0].legend(loc="lower right")
         
-        print(Fore.GREEN + "All Training Data Succesfully Balanced from: " + str(len(TrainInputs)) + " to: " + str(len(BalancedInputs)) + ". from: AutoBalancer " + Style.RESET_ALL)
-        time.sleep(1.5)
-   except:
-        print(Fore.RED + "ERROR: Inputs and labels must be same length check parameters" + infoAutoBalancer)
-        return 'e'
         
-   return BalancedInputs, BalancedLabels
+        """
+            accuracy_per_class = []
+        
+            for cls in Class:
+                correct = np.sum((y_true == cls) & (y_preds == cls))
+                total = np.sum(y_true == cls)
+                accuracy_cls = correct / total if total > 0 else 0.0
+                accuracy_per_class.append(accuracy_cls)
+        
+            axs[2, 0].bar(Class, accuracy_per_class, color='b', alpha=0.7)
+            axs[2, 0].set_xlabel('Class')
+            axs[2, 0].set_ylabel('Accuracy')
+            axs[2, 0].set_title('Class-wise Accuracy')
+            axs[2, 0].set_xticks(Class)
+            axs[2, 0].grid(True)
+"""
+
+
+
+    
+    # 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)  # Y eksenini 0 ile 1 arasında sınırla
+    axs[0, 1].set_xlabel('Metrics')
+    axs[0, 1].set_ylabel('Score')
+    axs[0, 1].set_title('Precision, Recall, F1 Score, and Accuracy (Weighted)')
+    axs[0, 1].grid(True, axis='y', linestyle='--', alpha=0.7)
+    
+               # Accuracy
+    plt.plot(acc_list, marker='o', linestyle='-',
+             color='r', label='Accuracy')
+    
+    
+    plt.axhline(y=1, color='g', linestyle='--', label='Maximum Accuracy')
+    
+    
+    plt.xlabel('Samples')
+    plt.ylabel('Accuracy')
+    plt.title('Accuracy History')
+    plt.legend()
+    
+    
+    plt.tight_layout()
+    plt.show()
+
+def manuel_balancer(x_train, y_train, target_samples_per_class):
+    """
+    Generates synthetic examples to balance classes to the specified number of examples per class.
+
+    Arguments:
+    x_train -- Input dataset (examples) - NumPy array format
+    y_train -- Class labels (one-hot encoded) - NumPy array format
+    target_samples_per_class -- Desired number of samples per class
+
+    Returns:
+    x_balanced -- Balanced input dataset (NumPy array format)
+    y_balanced -- Balanced class labels (one-hot encoded, NumPy array format)
+    """
+    start_time = time.time()
+    x_train = np.array(x_train)
+    y_train = np.array(y_train)
+    classes = np.arange(y_train.shape[1])
+    class_count = len(classes)
+    
+    x_balanced = []
+    y_balanced = []
+
+    for class_label in range(class_count):
+        class_indices = np.where(np.argmax(y_train, axis=1) == class_label)[0]
+        num_samples = len(class_indices)
+        
+        if num_samples > target_samples_per_class:
+      
+            selected_indices = np.random.choice(class_indices, target_samples_per_class, replace=False)
+            x_balanced.append(x_train[selected_indices])
+            y_balanced.append(y_train[selected_indices])
+            
+        else:
+            
+            x_balanced.append(x_train[class_indices])
+            y_balanced.append(y_train[class_indices])
+
+            if num_samples < target_samples_per_class:
+                
+                samples_to_add = target_samples_per_class - num_samples
+                additional_samples = np.zeros((samples_to_add, x_train.shape[1]))
+                additional_labels = np.zeros((samples_to_add, y_train.shape[1]))
+                
+                for i in range(samples_to_add):
+                    uni_start_time = time.time()
+                    
+                    random_indices = np.random.choice(class_indices, 2, replace=False)
+                    sample1 = x_train[random_indices[0]]
+                    sample2 = x_train[random_indices[1]]
+
+                    
+                    synthetic_sample = sample1 + (sample2 - sample1) * np.random.rand()
+
+                    additional_samples[i] = synthetic_sample
+                    additional_labels[i] = y_train[class_indices[0]]
+                    
+                    uni_end_time = time.time()
+                    calculating_est = round(
+               (uni_end_time - uni_start_time) * (samples_to_add - i), 3)
+    
+                    if calculating_est < 60:
+                        print('\rest......(sec):', calculating_est, '\n', end="")
+             
+                    elif calculating_est > 60 and calculating_est < 3600:
+                        print('\rest......(min):', calculating_est/60, '\n', end="")
+             
+                    elif calculating_est > 3600:
+                        print('\rest......(h):', calculating_est/3600, '\n', end="")
+             
+                    print('Augmenting: ', class_label, '/', class_count, '...', i, "/", samples_to_add, "\n", end="")
+
+                x_balanced.append(additional_samples)
+                y_balanced.append(additional_labels)
+                   
+
+    EndTime = time.time()
+
+    calculating_est = round(EndTime - start_time, 2)
+ 
+    print(Fore.GREEN + " \nBalancing Finished with 0 ERROR\n" + Style.RESET_ALL)
+ 
+    if calculating_est < 60:
+        print('Total balancing time(sec): ', calculating_est)
+ 
+    elif calculating_est > 60 and calculating_est < 3600:
+        print('Total balancing time(min): ', calculating_est/60)
+ 
+    elif calculating_est > 3600:
+        print('Total balancing time(h): ', calculating_est/3600)
+    
+    # Stack the balanced arrays
+    x_balanced = np.vstack(x_balanced)
+    y_balanced = np.vstack(y_balanced)
+
+    return x_balanced, y_balanced
+
+def get_weights():
+
+    return 0
+
+
+def get_df():
+
+    return 2
+
+
+def get_preds():
+
+    return 1
+
+
+def get_acc():
+
+    return 2