pyerualjetwork 2.3.0__tar.gz → 2.5.9__tar.gz

{pyerualjetwork-2.3.0 → pyerualjetwork-2.5.9}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.1
 Name: pyerualjetwork
-Version: 2.3.0
-Summary: Weights now noramlized, new function: manuel_balancer. And scaler_params added for scaled models.
+Version: 2.5.9
+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.9/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.0/plan_di/plan_di.py → pyerualjetwork-2.5.9/plan/plan.py

@@ -1,4 +1,24 @@
 
+# -*- 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
 
@@ -20,8 +40,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]],
+    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_potential=None # (float): Input activation potential (optional)
 ) -> str:
 
     infoPLAN = """
@@ -29,19 +55,50 @@ def fit(
     
     Args:
         x_train (list[num]): List of input data.
-        y_train (list[num]): List of y_train. (one hot encoded)
-        activation_potential (float): Input activation potential 
-    
+        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, 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
+        val_count_copy = val_count
+
+    if val == True:
+        
+        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:
+        
+        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))
@@ -52,6 +109,7 @@ 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()
@@ -64,7 +122,11 @@ def fit(
     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()
@@ -81,11 +143,93 @@ def fit(
             neural_layer = normalization(neural_layer)
 
             if Layer == 'fex':
-                W[Lindex] = fex(neural_layer, W[Lindex], True, y[index])
+                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 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()
+
+                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)
 
@@ -105,6 +249,27 @@ def fit(
 
         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)
@@ -122,20 +287,65 @@ def fit(
     
     layers.append('cat')
     trained_W.append(np.eye(len(class_count)))
-    
-    for i in range(len(class_count)):
-    
-        for j in range(len(layers)):
-        
-            if layers[j] == 'fex':
-            
-                trained_W[j][i,:] = normalization(trained_W[j][i,:])
                 
-
+                
     return trained_W
 
 # 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
+) -> str:
+    """
+    Row(Neuron) based normalization. For unbalanced models.
+
+    Args:
+            W (list(num)): Trained weight matrix list.
+            class_count (int): Class count of model.
+
+    Returns:
+        list([numpy_arrays],[...]): posttrained weight matices of the model. .
+    """
+
+    for i in range(class_count):
+        
+            W[0][i,:] = normalization(W[0][i,:])
+    
+    return W
 
 def weight_identification(
     layer_count,      # int: Number of layers in the neural network.
@@ -170,7 +380,8 @@ 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_potential # float or None: Input activation potential (optional)
 ) -> tuple:
     """
     Applies feature extraction process to the input data using synaptic pruning.
@@ -180,22 +391,42 @@ 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): 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 is_training == True:
-
+    if is_training == True and activation_potential == None:
+        
         w[Class, :] = Input
 
         return w
 
-    else:
-
-        neural_layer = np.dot(w, Input)
-
-        return neural_layer
+    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)
+     
+            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
 
 
 
@@ -272,7 +503,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_potential=None # activation_potential (float or None): Threshold value for comparison. (optional)
 ) -> tuple:
     infoTestModel = """
     Tests the neural network model with the given test data.
@@ -282,6 +514,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_potential (float or None): Threshold value for comparison. (optional)
 
     Returns:
         tuple: A tuple containing the predicted labels and the accuracy of the model.
@@ -312,7 +545,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_potential)
                 elif Layer == 'cat':
                     neural_layer = np.dot(W[index], neural_layer)
     
@@ -387,7 +620,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_potential=None # (float or None): Threshold value for comparison. (optional)
 ) -> tuple:
     infoTestModel = """
     Tests the neural network model with the given test data.
@@ -434,7 +668,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_potential)
                     elif Layer == 'cat':
                         neural_layer = np.dot(W[index], neural_layer)
 
@@ -518,7 +752,8 @@ def save_model(model_name,
                weights_format,
                model_path,
                scaler_params,
-               W
+               W,
+               activation_potential=None
                ):
 
     infosave_model = """
@@ -534,6 +769,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)
     
     Returns:
     str: Message indicating if the model was saved successfully or encountered an error.
@@ -582,7 +818,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 POTENTIAL': activation_potential
             }
     try:
 
@@ -723,17 +960,34 @@ def predict_model_ssd(Input, model_name, model_path):
     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_potential = str(df['ACTIVATION POTENTIAL'].iloc[0])
 
-    scaler_params = str(df['STANDARD SCALER'].iloc[0])
+    if activation_potential != 'nan':
 
-    if scaler_params != None:
+        activation_potential = float(activation_potential)
+        
+    else:
+    
+        activation_potential = None
+    
+    try:
+        
+        scaler_params = df['STANDARD SCALER'].tolist()
+                
+             
+        scaler_params = [np.fromstring(arr.strip('[]'), sep=' ') for arr in scaler_params]
 
-        Input = standard_scaler(Input, None, scaler_params)
+        Input = standard_scaler(None, Input, scaler_params)
+        
+    except:
+    
+        non_scaled = True
+        
 
     layers = ['fex', 'cat']
 
@@ -749,7 +1003,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_potential)
             elif Layer == 'cat':
                 neural_layer = np.dot(W[index], neural_layer)
     except:
@@ -761,7 +1015,7 @@ 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_potential=None):
 
     infopredict_model_ram = """
     Function to make a prediction using a divided pruning learning artificial neural network (PLAN).
@@ -771,14 +1025,15 @@ def predict_model_ram(Input, scaler_params, W):
     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)
 
     Returns:
     ndarray: Output from the model.
     """
-
+    
     if scaler_params != None:
 
-        Input = standard_scaler(Input, None, scaler_params)
+        Input = standard_scaler(None, Input, scaler_params)
 
     layers = ['fex', 'cat']
 
@@ -794,7 +1049,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_potential)
             elif Layer == 'cat':
                 neural_layer = np.dot(W[index], neural_layer)
 
@@ -921,26 +1176,40 @@ def standard_scaler(x_train, x_test, scaler_params=None):
     tuple
       Standardized training and test datasets
   """
-        try:
+    try:
             
-            if scaler_params == None:
-                mean = np.mean(x_train, axis=0)
-                std = np.std(x_train, axis=0)
-                scaler_params = [mean, std]
-
-            if x_test == None:
-
-                train_data_scaled = (x_train - mean) / std
-                return scaler_params, train_data_scaled
-
-            elif scaler_params == None:
-                train_data_scaled = (x_train - mean) / std
-                test_data_scaled = (x_test - mean) / std
-                return scaler_params, train_data_scaled, test_data_scaled
-                
-            elif scaler_params != None:
-                test_data_scaled = (x_test - scaler_params[0]) / scaler_params[1]
-                return 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
+            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(
@@ -1293,7 +1562,7 @@ def plot_evaluate(y_test, y_preds, acc_list):
     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 (Wighted)')
+    axs[0, 1].set_title('Precision, Recall, F1 Score, and Accuracy (Weighted)')
     axs[0, 1].grid(True, axis='y', linestyle='--', alpha=0.7)
     
                # Accuracy
@@ -1426,4 +1695,4 @@ def get_preds():
 
 def get_acc():
 
-    return 2
+    return 2

{pyerualjetwork-2.3.0 → pyerualjetwork-2.5.9}/pyerualjetwork.egg-info/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.1
 Name: pyerualjetwork
-Version: 2.3.0
-Summary: Weights now noramlized, new function: manuel_balancer. And scaler_params added for scaled models.
+Version: 2.5.9
+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.0 → pyerualjetwork-2.5.9}/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.5.9/pyerualjetwork.egg-info/top_level.txt

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

{pyerualjetwork-2.3.0 → pyerualjetwork-2.5.9}/setup.py

@@ -5,10 +5,10 @@ from setuptools import setup, find_packages
 setup(
       
       name = "pyerualjetwork",
-      version = "2.3.0",
+      version = "2.5.9",
       author = "Hasan Can Beydili",
       author_email = "tchasancan@gmail.com",
-      description= "Weights now noramlized, new function: manuel_balancer. And scaler_params added for scaled models.",
+      description= "New optional parameters added for fit function, x_val, y_val show_count, val_count, val. For more information please read user document",
       packages = find_packages(),
       keywords = ["model evaluation", "classifcation", 'pruning learning artficial neural networks'],
 

pyerualjetwork-2.3.0/plan_bi/__init__.py

@@ -1,5 +0,0 @@
-# pyerualjetwork/PLAN/__init__.py
-
-# Bu dosya, plan modülünün ana giriş noktasıdır.
-
-from .plan_bi 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, get_pot, synthetic_augmentation, standard_scaler, multiple_evaluate, encode_one_hot, split, metrics, decode_one_hot, roc_curve, confusion_matrix, plot_evaluate, manuel_balancer