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

plan/plan.py

@@ -1,4 +1,3 @@
-
 # -*- coding: utf-8 -*-
 """
 Created on Tue Jun 18 23:32:16 2024
@@ -6,34 +5,15 @@ 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 typing import List, Union
-import math
 from scipy.special import expit, softmax
 import matplotlib.pyplot as plt
 import seaborn as sns
+from tqdm import tqdm
 
 # BUILD -----
 
@@ -41,13 +21,13 @@ import seaborn as sns
 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,
+    val_count = None,
+    activation_potentiation=None, # (float): Input activation_potentiation (optional)
     x_val= None,
     y_val= None,
-    activation_potential=None # (float): Input activation potential (optional)
+    show_training = None,
+    show_count= None
 ) -> str:
 
     infoPLAN = """
@@ -56,40 +36,55 @@ def fit(
     Args:
         x_train (list[num]): List of input data.
         y_train (list[num]): List of target labels. (one hot encoded)
+        val (None, True or 'final'): validation in training process ? None, True or 'final' Default: None (optional)
+        val_count (None, int): After how many examples learned will an accuracy test be performed? Default: 0.1 (%10) (optional)
+        activation_potentiation (float): Input activation potentiation (for binary injection) (optional) in range: -1, 1
+        x_val (list[num]): List of validation data. (optional) Default: 1% of x_train (auto_balanced) it means every %1 of train progress starts validation
+        y_val (list[num]): (list[num]): List of target labels. (one hot encoded) (optional) Default: 1% of y_train (auto_balanced) it means every %1 of train progress starts validation
         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, train_predictions list, Train_acc).
         error handled ?: Process status ('e')
 """
-   
 
     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)
+        print(Fore.RED + "ERROR301: x_train list and y_train list must be same length. from: fit", infoPLAN + Style.RESET_ALL)
         return 'e'
-    
-    if x_val == None and y_val == None:
 
-        x_val = x_train
-        y_val = y_train
+    if val == True or val == 'final':
+
+        try:
 
-    if val == True and val_count == None:
+            if x_val == None and y_val == None:
 
-        val_count =  0.1
-        val_count_copy = val_count
+                x_train, x_val, y_train, y_val = split(x_train, y_train, test_size=0.1, random_state=42)
+
+                x_train, y_train = auto_balancer(x_train, y_train)
+                x_val, y_val = auto_balancer(x_val, y_val)
 
-    if val == True:
+        except:
+                pass
+
+        if val == True:
+
+            if val_count == None:
+
+                val_count = 0.01
+
+            v_iter = 0
+
+        if val == 'final':
+
+            val_count = 0.99
         
         val_count = int(len(x_train) * val_count)
-
         val_count_copy = val_count
+        val_bar = tqdm(total=1, desc="Validating Accuracy", ncols=120)
+        val_list = [] * val_count
 
-    if show_training == True or show_training == 'final' and show_count == None:
+    if show_count == None:
         
         show_count = 10
 
@@ -109,25 +104,24 @@ def fit(
 
     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)
+    STPW = weight_identification(
+        len(layers) - 1, len(class_count), neurons, x_train_size) # STPW = SHORT TIME POTENTIATION WEIGHT
+
+    LTPW = [0] * len(STPW) # LTPW = LONG TIME POTENTIATION WEIGHT
 
-    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)
 
+    train_progress = tqdm(total=len(x_train),leave=False, desc="Training",ncols= 120)
+    
     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()
         
@@ -140,44 +134,35 @@ def fit(
 
         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)
+                STPW[Lindex] = fex(neural_layer, STPW[Lindex], True, y[index], activation_potentiation)
 
-        for i, w in enumerate(W):
-                trained_W[i] = trained_W[i] + w
+        for i, w in enumerate(STPW):
+                LTPW[i] = LTPW[i] + w
 
             
-        if val == True:
-
-            if index == val_count:
-                
-                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()
+        if val == True and index == val_count:
+            
 
-                val_acc = validation_model[get_acc()]
+            val_count += val_count_copy
 
-                val_list.append(val_acc)
+            validation_model = evaluate(x_val, y_val, LTPW, activation_potentiation, None)
+            
+            val_acc = validation_model[get_acc()]
 
+            val_list.append(val_acc)
+            
+            if v_iter == 0:
                 
-                plt.plot(val_list, linestyle='-',
-                color='r')
+                val_bar.update(val_acc)
                 
-                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 v_iter != 0:
+                
+                val_acc = val_acc - val_list[v_iter - 1]
+                val_bar.update(val_acc)
+               
+            v_iter += 1
 
         if show_training == True:
 
@@ -200,11 +185,11 @@ def fit(
               
                 if row != 0:
               
-                    mat = trained_W[0][j,:].reshape(row, col)
+                    mat = LTPW[0][j,:].reshape(row, col)
                     suptitle_info = 'Neurons Learning Progress: % '
                     title_info = f'{j+1}. Neuron'
                     
-                    mat = trained_W[0][j,:].reshape(row, col)
+                    mat = LTPW[0][j,:].reshape(row, col)
 
                     ax[j].imshow(mat, interpolation='sinc', cmap='viridis')
 
@@ -216,38 +201,24 @@ def fit(
 
                 else:
                     
-                    mat = trained_W[0]
+                    mat = LTPW[0]
                     ax.imshow(mat, interpolation='sinc', cmap='viridis')
                     suptitle_info = 'Weight Learning Progress: % '
                     title_info = 'Weight Matrix Of Fex Layer'
                     
-                    
-               
+                
+        
 
-                progress_status = f"{progress:.1f}"
-                fig.suptitle(suptitle_info + progress_status)
-                plt.draw()
-                plt.pause(0.1)
-                  
-                  
-        W = weight_identification(
+            progress_status = f"{progress:.1f}"
+            fig.suptitle(suptitle_info + progress_status)
+            plt.draw()
+            plt.pause(0.1)
+            
+              
+        STPW = 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="")
+        train_progress.update(1)
 
     if show_training == 'final':
             
@@ -255,7 +226,7 @@ def fit(
 
             for j in range(len(class_count)):
 
-                mat = trained_W[0][j,:].reshape(row, col)
+                mat = LTPW[0][j,:].reshape(row, col)
 
                 ax[j].imshow(mat, interpolation='sinc', cmap='viridis')
                 ax[j].set_aspect('equal')
@@ -270,26 +241,19 @@ def fit(
             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)
+    if val == 'final':
+   
+        validation_model = evaluate(x_val, y_val, LTPW, activation_potentiation, bar_status=None, show_metrices=None)
+        
+        val_acc = validation_model[get_acc()]
     
-    layers.append('cat')
-    trained_W.append(np.eye(len(class_count)))
-                
-                
-    return trained_W
+        val_list.append(val_acc)
+        
+        val_bar.update(val_acc)
+        
+    LTPW = normalization(LTPW)
+
+    return LTPW
 
 # FUNCTIONS -----
 
@@ -381,48 +345,48 @@ def fex(
     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)
+    activation_potentiation # float or None: Input activation potentiation (optional)
 ) -> tuple:
     """
-    Applies feature extraction process to the input data using synaptic pruning.
+    Applies feature extraction process to the input data using synaptic potentiation.
 
     Args:
         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)
+        activation_potentiation (float or None): Threshold value for comparison. (optional)
 
     Returns:
         tuple: A tuple (vector) containing the neural layer result and the updated weight matrix.
     """
 
-    if is_training == True and activation_potential == None:
+    if is_training == True and activation_potentiation == None:
         
         w[Class, :] = Input
 
         return w
 
-    elif is_training == True and activation_potential != None:
+    elif is_training == True and activation_potentiation != None:
    
             
-            Input[Input < activation_potential] = 0
-            Input[Input > activation_potential] = 1
+            Input[Input < activation_potentiation] = 0
+            Input[Input > activation_potentiation] = 1
             
             w[Class,:] = Input
         
             return w
            
-    elif is_training == False and activation_potential == None:
+    elif is_training == False and activation_potentiation == None:
         
             neural_layer = np.dot(w, Input)
      
             return neural_layer
         
-    elif is_training == False and activation_potential != None:
+    elif is_training == False and activation_potentiation != None:
         
-            Input[Input < activation_potential] = 0
-            Input[Input > activation_potential] = 1
+            Input[Input < activation_potentiation] = 0
+            Input[Input > activation_potentiation] = 1
         
             neural_layer = np.dot(w, Input)
         
@@ -502,9 +466,10 @@ def Relu(
 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)
+    activation_potentiation=None, # activation_potentiation (float or None): Threshold value for comparison. (optional) Default: None
+    bar_status=True,  # bar_status (bool): Loading bar for accuracy (True or None) (optional) Default: True
+    show_metrices=None     # show_metrices (bool): (True or None) (optional) Default: None
 ) -> tuple:
     infoTestModel = """
     Tests the neural network model with the given test data.
@@ -512,17 +477,17 @@ def evaluate(
     Args:
         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)
+        activation_potentiation (float or None): Threshold value for comparison. (optional) Default: None
+        bar_status (bool): Loading bar for accuracy (True or None) (optional) Default: True
+        show_metrices (bool): (True or None) (optional) Default: None
 
     Returns:
         tuple: A tuple containing the predicted labels and the accuracy of the model.
     """
-
-    layers = ['fex', 'cat']
-
     try:
+        layers = ['fex']
+
         Wc = [0] * len(W)  # Wc = Weight copy
         true = 0
         y_preds = [-1] * len(y_test)
@@ -530,25 +495,25 @@ def evaluate(
         
         for i, w in enumerate(W):
             Wc[i] = np.copy(w)
-            print('\rCopying weights.....', i+1, '/', len(W), end="")
-    
-        print(Fore.GREEN + "\n\nTest Started with 0 ERROR\n" + Style.RESET_ALL)
-        start_time = time.time()
+            
+            
+        if bar_status == True:
+
+            test_progress = tqdm(total=len(x_test),leave=False, desc='Testing',ncols=120)
+            acc_bar = tqdm(total=1, desc="Test Accuracy", ncols=120)
+            
+        
         for inpIndex, Input in enumerate(x_test):
             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)
-    
+                    neural_layer = fex(neural_layer, W[index], False, None, activation_potentiation)
+
+
             for i, w in enumerate(Wc):
                 W[i] = np.copy(w)
             RealOutput = np.argmax(y_test[inpIndex])
@@ -556,62 +521,30 @@ def evaluate(
             if RealOutput == PredictedOutput:
                 true += 1
             acc = true / len(y_test)
-            if show_metrices == True:
-                acc_list.append(acc)
+
+
+            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:   
+            
+            if bar_status == True:
+                test_progress.update(1)
+                if inpIndex == 0:
+                    acc_bar.update(acc)
+                    
+                else:
+                    acc = acc - acc_list[inpIndex - 1]
+                    acc_bar.update(acc)
+
+        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: Are you sure weights are loaded ? from: evaluate" +
-              infoTestModel + Style.RESET_ALL)
-        return 'e'
+    
+        print(Fore.RED + 'ERROR:' + infoTestModel + Style.RESET_ALL)
 
     return W, y_preds, acc
 
@@ -621,7 +554,7 @@ def multiple_evaluate(
     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)
+    activation_potentiation=None # (float or None): Threshold value for comparison. (optional)
 ) -> tuple:
     infoTestModel = """
     Tests the neural network model with the given test data.
@@ -668,9 +601,7 @@ def multiple_evaluate(
                     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)
+                        neural_layer = fex(neural_layer, W[index], False, None, activation_potentiation)
 
                 output_layer += neural_layer
 
@@ -738,7 +669,7 @@ def multiple_evaluate(
 
     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)
+        print(Fore.RED + "ERROR: Testing model parameters like 'activation_potentiation' 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
@@ -753,11 +684,11 @@ def save_model(model_name,
                model_path,
                scaler_params,
                W,
-               activation_potential=None
+               activation_potentiation=None
                ):
 
     infosave_model = """
-    Function to save a pruning learning model.
+    Function to save a potentiation learning model.
 
     Arguments:
     model_name (str): Name of the model.
@@ -769,7 +700,7 @@ def save_model(model_name,
     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)
+    activation_potentiation (float or None): Threshold value for comparison. (optional)
     
     Returns:
     str: Message indicating if the model was saved successfully or encountered an error.
@@ -778,7 +709,7 @@ def save_model(model_name,
     # Operations to be performed by the function will be written here
     pass
 
-    layers = ['fex', 'cat']
+    layers = ['fex']
 
     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" +
@@ -819,7 +750,7 @@ def save_model(model_name,
             'WEIGHTS FORMAT': weights_format,
             'MODEL PATH': model_path,
             'STANDARD SCALER': scaler_params,
-            'ACTIVATION POTENTIAL': activation_potential
+            'ACTIVATION POTENTIATION': activation_potentiation
             }
     try:
 
@@ -908,14 +839,14 @@ def load_model(model_name,
                model_path,
                ):
     infoload_model = """
-   Function to load a pruning learning model.
+   Function to load a potentiation learning model.
 
    Arguments:
    model_name (str): Name of the model.
    model_path (str): Path where the model is saved.
 
    Returns:
-   lists: W(list[num]), activation_potential, DataFrame of the model
+   lists: W(list[num]), activation_potentiation, DataFrame of the model
     """
     pass
 
@@ -955,7 +886,7 @@ def load_model(model_name,
 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).
+    Function to make a prediction using a divided potentiation learning artificial neural network (PLAN).
 
     Arguments:
     Input (list or ndarray): Input data for the model (single vector or single matrix).
@@ -965,15 +896,15 @@ def predict_model_ssd(Input, model_name, model_path):
     """
     W, df = load_model(model_name, model_path)
     
-    activation_potential = str(df['ACTIVATION POTENTIAL'].iloc[0])
+    activation_potentiation = str(df['ACTIVATION POTENTIATION'].iloc[0])
 
-    if activation_potential != 'nan':
+    if activation_potentiation != 'nan':
 
-        activation_potential = float(activation_potential)
+        activation_potentiation = float(activation_potentiation)
         
     else:
     
-        activation_potential = None
+        activation_potentiation = None
     
     try:
         
@@ -986,10 +917,10 @@ def predict_model_ssd(Input, model_name, model_path):
         
     except:
     
-        non_scaled = True
+        pass
         
 
-    layers = ['fex', 'cat']
+    layers = ['fex']
 
     Wc = [0] * len(W)
     for i, w in enumerate(W):
@@ -999,11 +930,9 @@ def predict_model_ssd(Input, model_name, model_path):
         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)
+                neural_layer = fex(neural_layer, W[index], False, None, activation_potentiation)
             elif Layer == 'cat':
                 neural_layer = np.dot(W[index], neural_layer)
     except:
@@ -1015,27 +944,29 @@ def predict_model_ssd(Input, model_name, model_path):
     return neural_layer
 
 
-def predict_model_ram(Input, scaler_params, W, activation_potential=None):
+def predict_model_ram(Input, W, scaler_params=None, activation_potentiation=None):
 
     infopredict_model_ram = """
-    Function to make a prediction using a divided pruning learning artificial neural network (PLAN).
+    Function to make a prediction using a divided potentiation 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).
-    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)
+    scaler_params (int, float): standard scaler params list: mean,std. (optional) Default: None.
+    activation_potentiation (float or None): Threshold value for comparison. (optional) Default: None
 
     Returns:
     ndarray: Output from the model.
     """
-    
-    if scaler_params != None:
+    try:
+        if scaler_params != None:
 
-        Input = standard_scaler(None, Input, scaler_params)
+            Input = standard_scaler(None, Input, scaler_params)
+    except:
+            Input = standard_scaler(None, Input, scaler_params)
 
-    layers = ['fex', 'cat']
+    layers = ['fex']
 
     Wc = [0] * len(W)
     for i, w in enumerate(W):
@@ -1046,10 +977,8 @@ def predict_model_ram(Input, scaler_params, W, activation_potential=None):
         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)
+                neural_layer = fex(neural_layer, W[index], False, None, activation_potentiation)
             elif Layer == 'cat':
                 neural_layer = np.dot(W[index], neural_layer)
 
@@ -1089,7 +1018,7 @@ def auto_balancer(x_train, y_train):
         MinCount = min(classes)
 
         BalancedIndices = []
-        for i in range(class_count):
+        for i in tqdm(range(class_count),leave=False,desc='Balancing Data',ncols=120):
             if len(ClassIndices[i]) > MinCount:
                 SelectedIndices = np.random.choice(
                     ClassIndices[i], MinCount, replace=False)
@@ -1106,7 +1035,7 @@ def auto_balancer(x_train, y_train):
         print(Fore.RED + "ERROR: Inputs and labels must be same length check parameters" + infoauto_balancer)
         return 'e'
 
-    return BalancedInputs, BalancedLabels
+    return np.array(BalancedInputs), np.array(BalancedLabels)
 
 
 def synthetic_augmentation(x_train, y_train):
@@ -1136,7 +1065,7 @@ def synthetic_augmentation(x_train, y_train):
     x_balanced = list(x)
     y_balanced = list(y)
 
-    for class_label in range(class_count):
+    for class_label in tqdm(range(class_count), leave=False, desc='Augmenting Data',ncols= 120):
         class_indices = [i for i, label in enumerate(
             y) if np.argmax(label) == class_label]
         num_samples = len(class_indices)
@@ -1160,7 +1089,7 @@ def synthetic_augmentation(x_train, y_train):
     return np.array(x_balanced), np.array(y_balanced)
 
 
-def standard_scaler(x_train, x_test, scaler_params=None):
+def standard_scaler(x_train, x_test=None, scaler_params=None):
     info_standard_scaler = """
   Standardizes training and test datasets. x_test may be None.
 
@@ -1168,7 +1097,7 @@ def standard_scaler(x_train, x_test, scaler_params=None):
     train_data: numpy.ndarray
       Training data
     test_data: numpy.ndarray
-      Test data
+      Test data (optional)
 
   Returns:
     list:
@@ -1176,6 +1105,15 @@ def standard_scaler(x_train, x_test, scaler_params=None):
     tuple
       Standardized training and test datasets
   """
+    try:
+
+        x_train = x_train.tolist()
+        x_test = x_test.tolist()
+
+    except:
+
+        pass
+
     try:
             
         if scaler_params == None and x_test != None:
@@ -1213,7 +1151,7 @@ def standard_scaler(x_train, x_test, scaler_params=None):
 
     except:
         print(
-            Fore.RED + "ERROR: x_train and x_test must be list[numpyarray] from standard_scaler" + info_standard_scaler)
+            Fore.RED + "ERROR: x_train and x_test must be list[numpyarray] from standard_scaler" + info_standard_scaler + Style.RESET_ALL)
 
 
 def encode_one_hot(y_train, y_test):
@@ -1227,21 +1165,18 @@ def encode_one_hot(y_train, y_test):
     Returns:
         tuple: One-hot encoded y_train ve y_test verileri.
     """
-    try:
-        classes = np.unique(y_train)
-        class_count = len(classes)
+    classes = np.unique(y_train)
+    class_count = len(classes)
 
-        class_to_index = {cls: idx for idx, cls in enumerate(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_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)
+    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
 
     return y_train_encoded, y_test_encoded
 
@@ -1259,7 +1194,6 @@ def split(X, y, test_size, random_state):
     Returns:
         tuple: x_train, x_test, y_train, y_test as ordered training and testing data subsets.
     """
-    # Size of the dataset
     num_samples = X.shape[0]
 
     if isinstance(test_size, float):
@@ -1476,7 +1410,6 @@ def plot_evaluate(y_test, y_preds, acc_list):
     
     # 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
@@ -1595,16 +1528,19 @@ def manuel_balancer(x_train, y_train, target_samples_per_class):
     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)
+    try:
+        x_train = np.array(x_train)
+        y_train = np.array(y_train)
+    except:
+        print(Fore.GREEN + "x_tarin and y_train already numpyarray." + Style.RESET_ALL)
+        pass
     classes = np.arange(y_train.shape[1])
     class_count = len(classes)
     
     x_balanced = []
     y_balanced = []
 
-    for class_label in range(class_count):
+    for class_label in tqdm(range(class_count),leave=False, desc='Augmenting Data',ncols= 120):
         class_indices = np.where(np.argmax(y_train, axis=1) == class_label)[0]
         num_samples = len(class_indices)
         
@@ -1626,8 +1562,7 @@ def manuel_balancer(x_train, y_train, target_samples_per_class):
                 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]]
@@ -1638,41 +1573,10 @@ def manuel_balancer(x_train, y_train, target_samples_per_class):
                     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)
 
@@ -1695,4 +1599,4 @@ def get_preds():
 
 def get_acc():
 
-    return 2
+    return 2

pyerualjetwork-2.7.8.dist-info/METADATA

@@ -0,0 +1,8 @@
+Metadata-Version: 2.1
+Name: pyerualjetwork
+Version: 2.7.8
+Summary: Code improvements
+Author: Hasan Can Beydili
+Author-email: tchasancan@gmail.com
+Keywords: model evaluation,classifcation,potentiation learning artficial neural networks
+

pyerualjetwork-2.7.8.dist-info/RECORD

@@ -0,0 +1,6 @@
+plan/__init__.py,sha256=gmaz8lnQfl18MbOQwabBUPmShajK5S99jfyY-hQe8tc,502
+plan/plan.py,sha256=h1u6hk_wTjbCGkKhnAz6jidxTogmMTM2AEm7nxE9WQQ,52805
+pyerualjetwork-2.7.8.dist-info/METADATA,sha256=921fYXjv_44__3jjG8aZWt_iHE3I6rbNdHEar_vIDOw,244
+pyerualjetwork-2.7.8.dist-info/WHEEL,sha256=yQN5g4mg4AybRjkgi-9yy4iQEFibGQmlz78Pik5Or-A,92
+pyerualjetwork-2.7.8.dist-info/top_level.txt,sha256=G0Al3HuNJ88434XneyDtRKAIUaLCizOFYFYNhd7e2OM,5
+pyerualjetwork-2.7.8.dist-info/RECORD,,

{pyerualjetwork-2.5.8.dist-info → pyerualjetwork-2.7.8.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.38.4)
+Generator: bdist_wheel (0.41.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

pyerualjetwork-2.5.8.dist-info/METADATA

@@ -1,8 +0,0 @@
-Metadata-Version: 2.1
-Name: pyerualjetwork
-Version: 2.5.8
-Summary: New optional parameters added for fit function, x_val, y_val show_count, val_count, val. For more information please read user document
-Author: Hasan Can Beydili
-Author-email: tchasancan@gmail.com
-Keywords: model evaluation,classifcation,pruning learning artficial neural networks
-

pyerualjetwork-2.5.8.dist-info/RECORD

@@ -1,6 +0,0 @@
-plan/__init__.py,sha256=gmaz8lnQfl18MbOQwabBUPmShajK5S99jfyY-hQe8tc,502
-plan/plan.py,sha256=3jSj2QXjLhinm_5BH0-pVhHP6mHyrXzLKm4m5GaV6Yw,56167
-pyerualjetwork-2.5.8.dist-info/METADATA,sha256=ILdOu0T__HUunUBsrZcnxEjeyAzP_jl122hO-OVPR38,357
-pyerualjetwork-2.5.8.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
-pyerualjetwork-2.5.8.dist-info/top_level.txt,sha256=G0Al3HuNJ88434XneyDtRKAIUaLCizOFYFYNhd7e2OM,5
-pyerualjetwork-2.5.8.dist-info/RECORD,,