pyerualjetwork 2.3.8__tar.gz → 2.6.3__tar.gz

pyerualjetwork-2.6.3/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.1
+Name: pyerualjetwork
+Version: 2.6.3
+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.6.3/plan/__init__.py

@@ -0,0 +1,5 @@
+# pyerualjetwork/PLAN/__init__.py
+
+# Bu dosya, plan modülünün ana giriş noktasıdır.
+
+from .plan import auto_balancer, normalization, Softmax, Sigmoid, Relu, weight_identification, fex, fit, evaluate, save_model, load_model, predict_model_ssd, predict_model_ram, get_weights, get_df, get_preds, get_acc, synthetic_augmentation, standard_scaler, multiple_evaluate, encode_one_hot, split, metrics, decode_one_hot, roc_curve, confusion_matrix, plot_evaluate, manuel_balancer, weight_normalization

pyerualjetwork-2.3.8/plan_di/plan_di.py → pyerualjetwork-2.6.3/plan/plan.py

@@ -1,8 +1,9 @@
 
+# -*- coding: utf-8 -*-
 """
-Created on Thu Jun 12 00:00:00 2024
+Created on Tue Jun 18 23:32:16 2024
 
-@author: hasan can beydili
+@author: hasan
 """
 
 import pandas as pd
@@ -20,9 +21,14 @@ import seaborn as sns
 
 def fit(
     x_train: List[Union[int, float]],
-    # At least two.. and one hot encoded
-    y_train: List[Union[int, float, str]], # At least two.. and one hot encoded
-    show_training
+    y_train: List[Union[int, float]], # At least two.. and one hot encoded
+    show_training,
+    show_count= None,
+    val= None,
+    val_count= None,
+    x_val= None,
+    y_val= None,
+    activation_potentiation=None # (float): Input activation_potentiation (optional)
 ) -> str:
 
     infoPLAN = """
@@ -30,19 +36,49 @@ def fit(
     
     Args:
         x_train (list[num]): List of input data.
-        y_train (list[num]): List of y_train. (one hot encoded)
-        show_training (bool, str): True, None or 'final'
-    
+        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 (None or True): validation in training process ? None or True Default: None
+        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_potentiation (float): Input activation potentiation (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)
         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
+
+    if val == True and val_count != None:
+        
+        val_count = int(len(x_train) * val_count)
+        val_count_copy = val_count
 
+    if show_count == None:
+        
+        show_count = 10
+
+    if show_training == True or show_training == 'final':
+
+        row, col = shape_control(x_train)
+    
     class_count = set()
+
     for sublist in y_train:
 
         class_count.add(tuple(sublist))
@@ -53,20 +89,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 = pdi.weight_identification(
+    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 = pdi.decode_one_hot(y_train)
+    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()
@@ -80,40 +120,104 @@ def fit(
 
         for Lindex, Layer in enumerate(layers):
 
-            neural_layer = pdi.normalization(neural_layer)
+            neural_layer = normalization(neural_layer)
 
             if Layer == 'fex':
-                W[Lindex] = pdi.fex(neural_layer, W[Lindex], True, y[index])
+                W[Lindex] = fex(neural_layer, W[Lindex], True, y[index], activation_potentiation)
 
         for i, w in enumerate(W):
                 trained_W[i] = trained_W[i] + w
 
+            
+        if val == True:
+
+            if index == val_count:
+                
                 if show_training == True:
-                                       
-                    fig, ax = plt.subplots(1, 10, figsize=(18, 14))
-                    
                     try:
-                        row = x_train[1].shape[0]
-                        col = x_train[1].shape[1]
+                        plt.close(fig)
+
                     except:
-                        print(Fore.RED + 'ERROR: You try train showing but inputs is raveled. x_train inputs to must be reshape for training_show.', infoPLAN + Style.RESET_ALL)
-                        return 'e'
-                        
-                    for j in range(10):
-             
-                        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')
-               
-               
-                    plt.show()
+                        pass
+
+                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)
                                             
-        W = pdi.weight_identification(
+                layers.pop()
+                trained_W.pop()
+
+                val_acc = validation_model[get_acc()]
+
+                val_list.append(val_acc)
+
+                
+                plt.plot(val_list, linestyle='-',
+                color='r')
+                
+                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:
+                
+                    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'
+                    
+                
+            
+
+            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()
@@ -133,29 +237,25 @@ def fit(
         print('\rTraining: ', index, "/", len(x_train), "\n", end="")
 
     if show_training == 'final':
-        
-        fig, ax = plt.subplots(1, 10, figsize=(18, 14))
-        
-        try:
-            row = x_train[1].shape[0]
-            col = x_train[1].shape[1]
-        except:
-            print(Fore.RED + 'ERROR: You try train showing but inputs is raveled. x_train inputs to must be reshape for training_show.', infoPLAN  + Style.RESET_ALL)
-            return 'e'
             
-        for j in range(10):
-            
-            mat = trained_W[0][j,:].reshape(row, col)
+            fig, ax = plt.subplots(1, len(class_count), figsize=(18, 14))
 
-            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')  
-            
+            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)
 
-        plt.show()
 
     EndTime = time.time()
 
@@ -180,6 +280,39 @@ def fit(
 
 # FUNCTIONS -----
 
+def shape_control(x_train):
+
+    try:
+        row = x_train[1].shape[0]
+        col = x_train[1].shape[1]
+        
+    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)
+        
+        try:
+            row, col = find_numbers(len(x_train[0]))
+            
+        except:
+        
+            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]
+        
+    return row, col
+
+def find_numbers(n):
+    if n <= 1:
+        raise ValueError("Parameter 'n' must be greater than 1.")
+
+    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
+
+    return None
+
 def weight_normalization(
     W,
     class_count
@@ -234,32 +367,53 @@ def fex(
     Input,               # list[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: Which class is, if training.
+    Class,               # int: Which class is, if training.
+    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_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:
-
+    if is_training == True and activation_potentiation == None:
+        
         w[Class, :] = Input
 
         return w
 
-    else:
-
-        neural_layer = np.dot(w, Input)
-
-        return neural_layer
+    elif is_training == True and activation_potentiation != None:
+   
+            
+            Input[Input < activation_potentiation] = 0
+            Input[Input > activation_potentiation] = 1
+            
+            w[Class,:] = Input
+        
+            return w
+           
+    elif is_training == False and activation_potentiation == None:
+        
+            neural_layer = np.dot(w, Input)
+     
+            return neural_layer
+        
+    elif is_training == False and activation_potentiation != None:
+        
+            Input[Input < activation_potentiation] = 0
+            Input[Input > activation_potentiation] = 1
+        
+            neural_layer = np.dot(w, Input)
+        
+            return neural_layer
 
 
 
@@ -336,7 +490,8 @@ 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.
+    W,               # list[num]: Weight matrix list of the neural network.
+    activation_potentiation=None # activation_potentiation (float or None): Threshold value for comparison. (optional)
 ) -> tuple:
     infoTestModel = """
     Tests the neural network model with the given test data.
@@ -346,6 +501,7 @@ def evaluate(
         y_test (list[num]): Test labels.
         show_metrices (bool): (True or False)
         W (list[num]): Weight matrix list of the neural network.
+        activation_potentiation (float or None): Threshold value for comparison. (optional)
 
     Returns:
         tuple: A tuple containing the predicted labels and the accuracy of the model.
@@ -376,7 +532,7 @@ def evaluate(
                 neural_layer = normalization(neural_layer)
     
                 if Layer == 'fex':
-                    neural_layer = fex(neural_layer, W[index], False, None)
+                    neural_layer = fex(neural_layer, W[index], False, None, activation_potentiation)
                 elif Layer == 'cat':
                     neural_layer = np.dot(W[index], neural_layer)
     
@@ -451,7 +607,8 @@ 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.
+    MW,                  # list[list[num]]: Weight matrix of the neural network.
+    activation_potentiation=None # (float or None): Threshold value for comparison. (optional)
 ) -> tuple:
     infoTestModel = """
     Tests the neural network model with the given test data.
@@ -498,7 +655,7 @@ def multiple_evaluate(
                     neural_layer = normalization(neural_layer)
 
                     if Layer == 'fex':
-                        neural_layer = fex(neural_layer, W[index], False, None)
+                        neural_layer = fex(neural_layer, W[index], False, None, activation_potentiation)
                     elif Layer == 'cat':
                         neural_layer = np.dot(W[index], neural_layer)
 
@@ -568,7 +725,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
@@ -582,11 +739,12 @@ def save_model(model_name,
                weights_format,
                model_path,
                scaler_params,
-               W
+               W,
+               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.
@@ -598,6 +756,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_potentiation (float or None): Threshold value for comparison. (optional)
     
     Returns:
     str: Message indicating if the model was saved successfully or encountered an error.
@@ -646,7 +805,8 @@ def save_model(model_name,
             'WEIGHTS TYPE': weights_type,
             'WEIGHTS FORMAT': weights_format,
             'MODEL PATH': model_path,
-            'STANDARD SCALER': scaler_params
+            'STANDARD SCALER': scaler_params,
+            'ACTIVATION POTENTIATION': activation_potentiation
             }
     try:
 
@@ -735,14 +895,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
 
@@ -782,22 +942,39 @@ 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).
     model_name (str): Name of the model.
-    model_path (str): Path where the model is saved.
     Returns:
     ndarray: Output from the model.
     """
     W, df = load_model(model_name, model_path)
+    
+    activation_potentiation = str(df['ACTIVATION POTENTIATION'].iloc[0])
 
-    scaler_params = str(df['STANDARD SCALER'].iloc[0])
+    if activation_potentiation != 'nan':
 
-    if scaler_params != None:
+        activation_potentiation = float(activation_potentiation)
+        
+    else:
+    
+        activation_potentiation = None
+    
+    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:
+    
+        non_scaled = True
+        
 
     layers = ['fex', 'cat']
 
@@ -813,7 +990,7 @@ def predict_model_ssd(Input, model_name, model_path):
             neural_layer = normalization(neural_layer)
 
             if Layer == 'fex':
-                neural_layer = fex(neural_layer, W[index], False, None)
+                neural_layer = fex(neural_layer, W[index], False, None, activation_potentiation)
             elif Layer == 'cat':
                 neural_layer = np.dot(W[index], neural_layer)
     except:
@@ -825,21 +1002,22 @@ def predict_model_ssd(Input, model_name, model_path):
     return neural_layer
 
 
-def predict_model_ram(Input, scaler_params, W):
+def predict_model_ram(Input, scaler_params, W, 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_potentiation (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)
@@ -858,7 +1036,7 @@ def predict_model_ram(Input, scaler_params, W):
             neural_layer = normalization(neural_layer)
 
             if Layer == 'fex':
-                neural_layer = fex(neural_layer, W[index], False, None)
+                neural_layer = fex(neural_layer, W[index], False, None, activation_potentiation)
             elif Layer == 'cat':
                 neural_layer = np.dot(W[index], neural_layer)
 
@@ -987,35 +1165,44 @@ def standard_scaler(x_train, x_test, scaler_params=None):
   """
     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
-                
-                scaler_params = [mean, std]
-                
-                return scaler_params, train_data_scaled, test_data_scaled
+        if scaler_params == None and x_test != None:
             
-            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
-                
-                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]
-                return test_data_scaled
+            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
+        
+        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..

pyerualjetwork-2.6.3/pyerualjetwork.egg-info/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.1
+Name: pyerualjetwork
+Version: 2.6.3
+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.3.8 → pyerualjetwork-2.6.3}/pyerualjetwork.egg-info/SOURCES.txt

@@ -1,8 +1,6 @@
 setup.py
-plan_bi/__init__.py
-plan_bi/plan_bi.py
-plan_di/__init__.py
-plan_di/plan_di.py
+plan/__init__.py
+plan/plan.py
 pyerualjetwork.egg-info/PKG-INFO
 pyerualjetwork.egg-info/SOURCES.txt
 pyerualjetwork.egg-info/dependency_links.txt

pyerualjetwork-2.6.3/pyerualjetwork.egg-info/top_level.txt

@@ -0,0 +1 @@
+plan