pyerualjetwork 2.1.1__tar.gz → 2.1.2__tar.gz

{pyerualjetwork-2.1.1 → pyerualjetwork-2.1.2}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.1
 Name: pyerualjetwork
-Version: 2.1.1
-Summary:  Code improvements (Documentation in desc. Examples in GİTHUB: https://github.com/HCB06/PyerualJetwork)
+Version: 2.1.2
+Summary:  new 'multiple_evaluate' function added. And Code improvements (Documentation in desc. Examples in GİTHUB: https://github.com/HCB06/PyerualJetwork)
 Author: Hasan Can Beydili
 Author-email: tchasancan@gmail.com
 Keywords: model evaluation,classifcation,pruning learning artficial neural networks

{pyerualjetwork-2.1.1 → pyerualjetwork-2.1.2}/plan_bi/__init__.py

@@ -2,4 +2,4 @@
 
 # Bu dosya, plan modülünün ana giriş noktasıdır.
 
-from .plan_bi import auto_balancer, normalization, Softmax, Sigmoid, Relu, synaptic_pruning, synaptic_dividing, weight_identification, fex, cat, fit, evaluate, save_model, load_model, predict_model_ssd, predict_model_ram, get_weights, get_df, get_preds, get_acc, synthetic_augmentation, standard_scaler
+from .plan_bi import auto_balancer, normalization, Softmax, Sigmoid, Relu, synaptic_pruning, synaptic_dividing, weight_identification, fex, cat, 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

{pyerualjetwork-2.1.1 → pyerualjetwork-2.1.2}/plan_bi/plan_bi.py

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

{pyerualjetwork-2.1.1 → pyerualjetwork-2.1.2}/plan_di/__init__.py

@@ -2,4 +2,4 @@
 
 # Bu dosya, plan modülünün ana giriş noktasıdır.
 
-from .plan_di import auto_balancer, normalization, Softmax, Sigmoid, Relu, synaptic_pruning, synaptic_dividing, weight_identification, fex, cat, fit, evaluate, save_model, load_model, predict_model_ssd, predict_model_ram, get_weights, get_df, get_preds, get_acc, synthetic_augmentation, standard_scaler
+from .plan_di import auto_balancer, normalization, Softmax, Sigmoid, Relu, synaptic_pruning, synaptic_dividing, weight_identification, fex, cat, 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

{pyerualjetwork-2.1.1 → pyerualjetwork-2.1.2}/plan_di/plan_di.py

@@ -55,9 +55,7 @@ def fit(
     W = weight_identification(len(layers) - 1,len(class_count),neurons,x_train_size)
     Divides, Piece = synaptic_dividing(len(class_count),W)
     trained_W = [1] * len(W)
-    print(Fore.GREEN + "Train Started with 0 ERROR" + Style.RESET_ALL,)
-    train_predictions = [None] * len(y_train)
-    true = 0
+    print(Fore.GREEN + "Train Started with 0 ERROR" + Style.RESET_ALL)
     start_time = time.time()
     for index, inp in enumerate(x_train):
         uni_start_time = time.time()
@@ -80,7 +78,7 @@ def fit(
                     cs = Divides[int(k)][Windex][0]
 
        
-                    W[Windex] = synaptic_pruning(w, cs, 'row', int(k),len(class_count),Piece[Windex],1)
+                    W[Windex] = synaptic_pruning(w, cs, 'row', int(k), len(class_count), Piece[Windex], True)
 
         neural_layer = inp
         
@@ -89,24 +87,15 @@ def fit(
             
             neural_layer = normalization(neural_layer)
             
-
+            y = np.argmax(y_train[index])
             if Layer == 'fex':
-                y = np.argmax(y_train[index])
-
-                neural_layer,W[Lindex] = fex(neural_layer, W[Lindex], y , 1)
+                W[Lindex] = fex(neural_layer, W[Lindex], True, y)
             elif Layer == 'cat':
-                neural_layer,W[Lindex] = cat(neural_layer, W[Lindex], 1, Piece[Windex])
+                W[Lindex] = cat(neural_layer, W[Lindex], True, y)
                 
-        RealOutput = np.argmax(y_train[index])
-        PredictedOutput = np.argmax(neural_layer)
-        if RealOutput == PredictedOutput:
-            true += 1
-        acc = true / len(y_train)
-        train_predictions[index] = PredictedOutput
         
         for i, w in enumerate(W):
             trained_W[i] = trained_W[i] + w
-
          
         W = weight_identification(len(layers) - 1, len(class_count), neurons, x_train_size)
          
@@ -117,44 +106,32 @@ def fit(
         
         if calculating_est < 60:
             print('\rest......(sec):',calculating_est,'\n',end= "")
-            print('\rTrain accuracy: ' ,acc ,"\n", end="")
-        
+            
         elif calculating_est > 60 and calculating_est < 3600:
             print('\rest......(min):',calculating_est/60,'\n',end= "")
-            print('\rTrain accuracy: ' ,acc ,"\n", end="")
-        
+            
         elif calculating_est > 3600:
             print('\rest......(h):',calculating_est/3600,'\n',end= "")
-            print('\rTrain accuracy: ' ,acc ,"\n", end="")
+            
+        print('\rTraining: ' , index, "/", len(x_train),"\n", end="")
         
     EndTime = time.time()
-    
+
     calculating_est = round(EndTime - start_time,2)
-    
-    print(Fore.GREEN + " \nTrain Finished with 0 ERROR\n")
-    
+
+    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 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)
+     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)
     
 
-    return trained_W,train_predictions,acc
+    return trained_W
         
 # FUNCTIONS -----
 
@@ -194,7 +171,7 @@ def synaptic_pruning(
     Class,        # int: Class label for the current training instance.
     class_count, # int: Total number of classes in the dataset.
     piece, #  int: Which set of neurons will information be transferred to?
-    is_training # int: 1 or 0
+    is_training  # bool: Flag indicating if the function is called during training (True or False).
     
 ) -> str:
     infoPruning = """
@@ -207,7 +184,7 @@ def synaptic_pruning(
         Class (int): Class label for the current training instance.
         class_count (int): Total number of classes in the dataset.
         piece (int): Which set of neurons will information be transferred to?
-        is_training (int): 1 or 0
+        is_training (bool): Flag indicating if the function is called during training (True or False).
 
     Returns:
         numpy array: Weight matrix.
@@ -222,7 +199,7 @@ def synaptic_pruning(
                
         ce = cs / Class # ce(cut_end) = cs(cut_start) / current_class
         
-        if is_training == 1:
+        if is_training == True:
         
             p = piece
                 
@@ -295,9 +272,9 @@ def synaptic_dividing(
 
 def fex(
     Input,               # list[num]: Input data.
-    w,                   # num: Weight matrix of the neural network.,
-    Class,               # int: Which class is, if training. 
-    is_training # int: 1 or 0
+    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. 
 ) -> tuple:
     """
     Applies feature extraction process to the input data using synaptic pruning.
@@ -305,50 +282,56 @@ def fex(
     Args:
         Input (num): Input data.
         w (num): Weight matrix of the neural network.
-        Class (int): Which class is, if training.
-        is_training (int): Flag indicating if the function is called during training (1 for training, 0 otherwise).
+        is_training (bool): Flag indicating if the function is called during training (True or False).
+        Class (int): if is during training then which class(label) ? is isnt then put None.
 
     Returns:
         tuple: A tuple (vector) containing the neural layer result and the updated weight matrix.
     """
     
-    if is_training == 1:
+    if is_training == True:
         
         w[Class,:] = Input
 
-    neural_layer = np.dot(w, Input)
+        return w
     
-    return neural_layer,w
+    else:
+        
+        neural_layer = np.dot(w, Input)
+        
+        return neural_layer
 
 def cat(
     Input,               # list[num]: Input data.
     w,                   # list[num]: Weight matrix of the neural network.
-    is_training, # int: Flag indicating if the function is called during training (1 for training, 0 otherwise).
-    piece              # int Which set of neurons will information be transferred to?
+    is_training, # (bool): Flag indicating if the function is called during training (True or False).
+    Class
 ) -> tuple:
     """
     Applies categorization process to the input data using synaptic pruning if specified.
 
     Args:
         Input (list[num]): Input data.
-        w (num): Weight matrix of the neural network.
-        is_training (int): Flag indicating if the function is called during training (1 for training, 0 otherwise).
-        piece (int): Which set of neurons will information be transferred to?
-) -> tuple:
+        w (list[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.
     Returns:
         tuple: A tuple containing the neural layer (vector) result and the possibly updated weight matrix.
     """
    
-    PruneIndex = np.where(Input == 0)
     
-    if is_training == 1:
-     
-        w = synaptic_pruning(w, PruneIndex, 'col', 0, 0, piece, is_training)
-     
     
-    neural_layer = np.dot(w, Input)
+    if is_training == True:
+     
+        w[Class,Class] += 1
+        
+        return w
+        
+    else:
+        
+        neural_layer = np.dot(w, Input)
     
-    return neural_layer,w
+        return neural_layer
 
 
 def normalization(
@@ -467,10 +450,10 @@ def evaluate(
             
             neural_layer = normalization(neural_layer)
 
-            if layers[index] == 'fex':
-                neural_layer = fex(neural_layer, W[index], 0, 0)[0]
-            if layers[index] == 'cat':
-                neural_layer = cat(neural_layer, W[index], 0, 0)[0]
+            if Layer == 'fex':
+                neural_layer = fex(neural_layer, W[index], False, None)
+            elif Layer == 'cat':
+                neural_layer = cat(neural_layer, W[index], False, None)
                 
         for i, w in enumerate(Wc):
             W[i] = np.copy(w)
@@ -552,6 +535,144 @@ def evaluate(
    
   return W,TestPredictions,acc
 
+def multiple_evaluate(
+    x_test,         # list[num]: Test input data.
+    y_test,         # list[num]: Test labels.
+    visualize,         # str: visualize Testing procces or not visualize ('y' or 'n')
+    MW                  # list[list[num]]: Weight matrix of the neural network.
+) -> tuple:
+    infoTestModel =  """
+    Tests the neural network model with the given test data.
+
+    Args:
+        x_test (list[num]): Test input data.
+        y_test (list[num]): Test labels.
+        activation_potential (float): Input activation potential
+        visualize (str): Visualize test progress ? ('y' or 'n')
+        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:               
+        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
+                
+                TestPredictions = [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)
+                    elif Layer == 'cat':
+                        neural_layer = cat(neural_layer, W[index], False, None)
+                    
+                output_layer += neural_layer
+            
+                for i, w in enumerate(Wc):
+                    W[i] = np.copy(w)
+            for i, w in enumerate(Wc):
+                W[i] = np.copy(w)
+            RealOutput = np.argmax(y_test[inpIndex])
+            PredictedOutput = np.argmax(output_layer)
+            if RealOutput == PredictedOutput:
+                true += 1
+            acc = true / len(y_test)
+            TestPredictions[inpIndex] = PredictedOutput
+            
+            if visualize == 'y':
+            
+                y_testVisual = np.copy(y_test) 
+                y_testVisual = np.argmax(y_testVisual, axis=1)
+                
+                plt.figure(figsize=(12, 6))
+                sns.kdeplot(y_testVisual, label='Real Outputs', fill=True)
+                sns.kdeplot(TestPredictions, label='Predictions', fill=True)
+                plt.legend()
+                plt.xlabel('Class')
+                plt.ylabel('Data size')
+                plt.title('Predictions and Real Outputs for Testing KDE Plot')
+                plt.show()
+                
+                if inpIndex + 1 != len(x_test):
+                
+                    plt.close('all')
+            
+            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="")
+            
+        EndTime = time.time()
+        for i, w in enumerate(Wc):
+            W[i] = np.copy(w)
+    
+        calculating_est = round(EndTime - start_time,2)
+        
+        print(Fore.GREEN + "\nTest Finished with 0 ERROR\n")
+        
+        if calculating_est < 60:
+            print('Total testing time(sec): ',calculating_est)
+            
+        elif calculating_est > 60 and calculating_est < 3600:
+            print('Total testing time(min): ',calculating_est/60)
+            
+        elif calculating_est > 3600:
+            print('Total testing time(h): ',calculating_est/3600)
+            
+        if acc >= 0.8:
+            print(Fore.GREEN + '\nTotal Test accuracy: ' ,acc, '\n' + Style.RESET_ALL)
+        
+        elif acc < 0.8 and acc > 0.6:
+            print(Fore.MAGENTA + '\nTotal Test accuracy: ' ,acc, '\n' + Style.RESET_ALL)
+        
+        elif acc <= 0.6:
+            print(Fore.RED+ '\nTotal Test accuracy: ' ,acc, '\n' + Style.RESET_ALL)  
+        
+        
+
+    except:
+        
+            print(Fore.RED + "ERROR: Testing model parameters like 'activation_potential' must be same as trained model. Check parameters. Are you sure weights are loaded ? from: evaluate" + infoTestModel + Style.RESET_ALL)
+            return 'e'
+   
+
+   
+    return W,TestPredictions,acc
+
 def save_model(model_name,
              model_type,
              class_count,
@@ -787,10 +908,10 @@ def predict_model_ssd(Input,model_name,model_path):
 
             neural_layer = normalization(neural_layer)
                                 
-            if layers[index] == 'fex':
-                neural_layer = fex(neural_layer, W[index],0, 0)[0]
-            if layers[index] == 'cat':
-                neural_layer = cat(neural_layer, W[index], 0, 0)[0]
+            if Layer == 'fex':
+                neural_layer = fex(neural_layer, W[index], False, None)
+            elif Layer == 'cat':
+                neural_layer = cat(neural_layer, W[index], False, None)
     except:
        print(Fore.RED + "ERROR: The input was probably entered incorrectly. from: predict_model_ssd"  + infopredict_model_ssd + Style.RESET_ALL)
        return 'e'
@@ -827,10 +948,10 @@ def predict_model_ram(Input,W):
 
             neural_layer = normalization(neural_layer)
                                   
-            if layers[index] == 'fex':
-                neural_layer = fex(neural_layer, W[index],0, 0)[0]
-            if layers[index] == 'cat':
-                neural_layer = cat(neural_layer, W[index], 0, 0)[0]
+            if Layer == 'fex':
+                neural_layer = fex(neural_layer, W[index], False, None)
+            elif Layer == 'cat':
+                neural_layer = cat(neural_layer, W[index], False, None)
                 
     except:
         print(Fore.RED + "ERROR: Unexpected input or wrong model parameters from: predict_model_ram."  + infopredict_model_ram + Style.RESET_ALL)
@@ -966,8 +1087,4 @@ def get_preds():
     
 def get_acc():
         
-    return 2
-
-def get_pot():
-    
-    return 1
+    return 2

{pyerualjetwork-2.1.1 → pyerualjetwork-2.1.2}/pyerualjetwork.egg-info/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.1
 Name: pyerualjetwork
-Version: 2.1.1
-Summary:  Code improvements (Documentation in desc. Examples in GİTHUB: https://github.com/HCB06/PyerualJetwork)
+Version: 2.1.2
+Summary:  new 'multiple_evaluate' function added. And Code improvements (Documentation in desc. Examples in GİTHUB: https://github.com/HCB06/PyerualJetwork)
 Author: Hasan Can Beydili
 Author-email: tchasancan@gmail.com
 Keywords: model evaluation,classifcation,pruning learning artficial neural networks

{pyerualjetwork-2.1.1 → pyerualjetwork-2.1.2}/setup.py

@@ -5,10 +5,10 @@ from setuptools import setup, find_packages
 setup(
       
       name = "pyerualjetwork",
-      version = "2.1.1",
+      version = "2.1.2",
       author = "Hasan Can Beydili",
       author_email = "tchasancan@gmail.com",
-      description= " Code improvements (Documentation in desc. Examples in GİTHUB: https://github.com/HCB06/PyerualJetwork)",
+      description= " new 'multiple_evaluate' function added. And Code improvements (Documentation in desc. Examples in GİTHUB: https://github.com/HCB06/PyerualJetwork)",
       packages = find_packages(),
       keywords = ["model evaluation", "classifcation", 'pruning learning artficial neural networks'],