pyerualjetwork 2.8.4__py3-none-any.whl → 3.1__py3-none-any.whl

plan/__init__.py

@@ -2,4 +2,4 @@
 
 # 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, plot_decision_boundry
+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, plot_decision_space, plot_decision_boundary 

plan/plan.py

@@ -15,6 +15,9 @@ import matplotlib.pyplot as plt
 import seaborn as sns
 from tqdm import tqdm
 from scipy.spatial import ConvexHull
+from datetime import datetime
+from scipy import io
+import scipy.io as sio
 
 # BUILD -----
 
@@ -24,11 +27,12 @@ def fit(
     y_train: List[Union[int, float]], # At least two.. and one hot encoded
     val= None,
     val_count = None,
-    activation_potentiation=None, # (float): Input activation_potentiation (optional)
+    activation_potentiation=[None], # (float): Input activation_potentiation (optional)
     x_val= None,
     y_val= None,
     show_training = None,
-    show_count= None
+    show_count= None, # [DISABLED]
+    visible_layer=None # For future [DISABLED]
 ) -> str:
 
     infoPLAN = """
@@ -40,15 +44,19 @@ def fit(
         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
+        x_val (list[num]): List of validation data. (optional) Default: %10 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: %10 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)
+        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) [DISABLED]
+        visible_layer: For future [DISABLED]
+
     Returns:
         list([num]): (Weight matrices list, train_predictions list, Train_acc).
         error handled ?: Process status ('e')
 """
 
+    visible_layer = None
+
     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 + Style.RESET_ALL)
@@ -102,16 +110,37 @@ def fit(
     class_count = list(class_count)
 
     y_train = [tuple(sublist) for sublist in y_train]
+    
+    if visible_layer == None:
 
-    neurons = [len(class_count), len(class_count)]
-    layers = ['fex']
+        layers = ['fex']
+    else:
+
+        layers = ['fex'] * visible_layer
 
     x_train[0] = np.array(x_train[0])
     x_train[0] = x_train[0].ravel()
     x_train_size = len(x_train[0])
+    
+    if visible_layer == None:
+        STPW = [None]
+        STPW[0] = np.ones((len(class_count), x_train_size)) # STPW = SHORT TIME POTENTIATION WEIGHT
+
+    else:
+        if visible_layer == 1:
+            fex_count = visible_layer
+        else:
+            fex_count = visible_layer - 1
 
-    STPW = weight_identification(
-        len(layers) - 1, len(class_count), neurons, x_train_size) # STPW = SHORT TIME POTENTIATION WEIGHT
+        fex_neurons = [None] * fex_count
+
+        for i in range(fex_count):
+            fex_neurons[i] = [x_train_size]
+        
+        cat_neurons = [len(class_count), x_train_size]
+
+        STPW = weight_identification(
+            len(layers), len(class_count), fex_neurons, cat_neurons, x_train_size) # STPW = SHORT TIME POTENTIATION WEIGHT
 
     LTPW = [0] * len(STPW) # LTPW = LONG TIME POTENTIATION WEIGHT
 
@@ -119,6 +148,8 @@ def fit(
 
     train_progress = tqdm(total=len(x_train),leave=False, desc="Training",ncols= 120)
     
+    max_w = len(STPW) - 1
+
     for index, inp in enumerate(x_train):
 
         progress = index / len(x_train) * 100
@@ -133,12 +164,14 @@ def fit(
 
         neural_layer = inp
 
-        for Lindex, Layer in enumerate(layers):
+        for Lindex, Layer in enumerate(STPW):
 
-            if Layer == 'fex':
-                STPW[Lindex] = fex(neural_layer, STPW[Lindex], True, y[index], activation_potentiation)
-
-        STPW = normalization(STPW)
+            
+            STPW[Lindex] = fex(neural_layer, STPW[Lindex], True, y[index], activation_potentiation, index=Lindex, max_w=max_w)
+                
+        
+        for i in range(len(STPW)):
+            STPW[i] = normalization(STPW[i])
         
         for i, w in enumerate(STPW):
                 LTPW[i] = LTPW[i] + w
@@ -146,85 +179,84 @@ def fit(
             
         if val == True:
 
-            validation_model = evaluate(x_val, y_val, LTPW,bar_status=False, activation_potentiation=activation_potentiation, show_metrices=None)
-            
-            val_acc = validation_model[get_acc()]
-            val_preds = validation_model[get_preds()]
-            
-            plt.clf()
-            
-            plot_decision_boundry(x_val, y_val, y_preds=val_preds, s=100, color='tab20')
+            try:
 
+                if round(progress) % 10 == 1:
 
-            plt.pause(0.0001)
-            
-            val_list.append(val_acc)
-            
-            if v_iter == 0:
-                
-                val_bar.update(val_acc)
-                pass
-            
-            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:
+                    validation_model = evaluate(x_val, y_val, LTPW ,bar_status=False, activation_potentiation=activation_potentiation, show_metrices=None)
 
-            if index %show_count == 0:
-                  
+                    val_acc = validation_model[get_acc()]
+                    
+                    plot_decision_boundary(x_val, y_val, activation_potentiation, LTPW)
 
-                  if index != 0:
-                    plt.close(fig)
+                    plt.pause(0.0001)
 
-                  if row != 0:
-                  
-                    fig, ax = plt.subplots(1, len(class_count), figsize=(18, 14))
+                    plt.clf()
+                    
+                    val_list.append(val_acc)
+                    
+                    if v_iter == 0:
                         
-                  else:
-                
-                    fig, ax = plt.subplots(1, 1, figsize=(18, 14))
+                        val_bar.update(val_acc)
                     
-            for j in range(len(class_count)):
-
-              
-                if row != 0:
-              
-                    mat = LTPW[0][j,:].reshape(row, col)
-                    suptitle_info = 'Neurons Learning Progress: % '
-                    title_info = f'{j+1}. Neuron'
+                    if v_iter != 0:
+                        
+                        val_acc = val_acc - val_list[v_iter - 1]
+                        val_bar.update(val_acc)
                     
-                    mat = LTPW[0][j,:].reshape(row, col)
-
-                    ax[j].imshow(mat, interpolation='sinc', cmap='viridis')
+                    v_iter += 1
+            except:
+                pass
 
-                    ax[j].set_aspect('equal')
+        if show_training == True:
+            if index == 0:
+                if row != 0:
+                
+                    ax = plt.subplots(1, len(class_count), figsize=(18, 14))
                     
-                    ax[j].set_xticks([])
-                    ax[j].set_yticks([])
-                    ax[j].set_title(title_info)
+            if round(progress) % 2 == 1:
+                
+                  for j in range(len(class_count)):
 
-                else:
-                    
-                    mat = LTPW[0]
-                    ax.imshow(mat, interpolation='sinc', cmap='viridis')
-                    suptitle_info = 'Weight Learning Progress: % '
-                    title_info = 'Weight Matrix Of Fex Layer'
                     
+                    if row != 0:
                 
+                        mat = LTPW[0][j,:].reshape(row, col)
+                        suptitle_info = 'Neurons Learning Progress: % '
+                        title_info = f'{j+1}. Neuron'
+                        
+                        mat = LTPW[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 = LTPW[0]
+                        plt.imshow(mat, interpolation='sinc', cmap='viridis')
+                        suptitle_info = 'Weight Learning Progress: % '
+                        title_info = 'Weight Matrix Of Fex Layer'
+
+                  progress_status = f"{progress:.1f}"
+                  plt.title(suptitle_info + progress_status)
+                  plt.draw()
+                  plt.pause(0.0001)
+                  plt.clf()
         
+        if visible_layer == None:
+            STPW = [None]
+            STPW[0] = np.ones((len(class_count), x_train_size)) # STPW = SHORT TIME POTENTIATION WEIGHT
 
-            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)
+        else:      
+            STPW = weight_identification(
+                len(layers), len(class_count), fex_neurons, cat_neurons, x_train_size) 
 
         train_progress.update(1)
 
@@ -246,26 +278,23 @@ def fit(
             progress_status = f"{progress:.1f}"
             fig.suptitle('Neurons Learning Progress: % ' + progress_status)
             plt.draw()
-            plt.pause(0.1)
-
+            plt.pause(0.0001)
 
     if val == 'final':
    
         validation_model = evaluate(x_val, y_val, LTPW,bar_status=False, activation_potentiation=activation_potentiation, show_metrices=None)
             
         val_acc = validation_model[get_acc()]
-        val_preds = validation_model[get_preds()]
-        
         
-        plot_decision_boundry(x_val, y_val, y_preds=val_preds, s=100, color='tab20')
+        plot_decision_boundary(x_val, y_val, activation_potentiation, LTPW)
 
         val_list.append(val_acc)
         
         val_bar.update(val_acc)
                
-               
-    LTPW = normalization(LTPW)
-    
+    for i in range(len(LTPW)):
+            LTPW[i] = normalization(LTPW[i])
+
     return LTPW
 
 # FUNCTIONS -----
@@ -327,7 +356,8 @@ def weight_normalization(
 def weight_identification(
     layer_count,      # int: Number of layers in the neural network.
     class_count,      # int: Number of classes in the classification task.
-    neurons,         # list[num]: List of neuron counts for each layer.
+    fex_neurons,
+    cat_neurons,         # list[num]: List of neuron counts for each layer.
     x_train_size        # int: Size of the input data.
 ) -> str:
     """
@@ -343,90 +373,46 @@ def weight_identification(
         list([numpy_arrays],[...]): pretrained weight matices of the model. .
     """
 
-    Wlen = layer_count + 1
-    W = [None] * Wlen
-    W[0] = np.ones((neurons[0], x_train_size))
-    ws = layer_count - 1
-    for w in range(ws):
-        W[w + 1] = np.ones((neurons[w + 1], neurons[w]))
-   
-    return W
-
-
-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.
-    activation_potentiation # float or None: Input activation potentiation (optional)
-) -> tuple:
-    """
-    Applies feature extraction process to the input data using synaptic potentiation.
+    W = [None] * (len(fex_neurons) + 1)
 
-    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)
+    for i in range(len(fex_neurons)):
+        W[i] = np.ones((fex_neurons[i]))
 
-    Returns:
-        tuple: A tuple (vector) containing the neural layer result and the updated weight matrix.
-    """
+    W[i + 1] = np.ones((cat_neurons[0], cat_neurons[1]))
 
-    if is_training == True and activation_potentiation == None:
-        
-        w[Class, :] = Input
+    return W
 
-        return w
+# ACTIVATION FUNCTIONS -----
 
-    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
+def tanh(x):
+    return np.tanh(x)
 
+def swish(x):
+    return x * (1 / (1 + np.exp(-x)))
 
+def circular_activation(x):
+    return (np.sin(x) + 1) / 2
 
-def normalization(
-    Input  # num: Input data to be normalized.
-):
-    """
-    Normalizes the input data using maximum absolute scaling.
+def modular_circular_activation(x, period=2*np.pi):
+    return np.mod(x, period) / period
 
-    Args:
-        Input (num): Input data to be normalized.
+def tanh_circular_activation(x):
+    return (np.tanh(x) + 1) / 2
 
-    Returns:
-        (num) Scaled input data after normalization.
-    """
+def leaky_relu(x, alpha=0.01):
+    return np.where(x > 0, x, alpha * x)
 
-    AbsVector = np.abs(Input)
+def softplus(x):
+    return np.log(1 + np.exp(x))
 
-    MaxAbs = np.max(AbsVector)
+def elu(x, alpha=1.0):
+    return np.where(x > 0, x, alpha * (np.exp(x) - 1))
 
-    ScaledInput = Input / MaxAbs
+def gelu(x):
+    return 0.5 * x * (1 + np.tanh(np.sqrt(2 / np.pi) * (x + 0.044715 * np.power(x, 3))))
 
-    return ScaledInput
+def selu(x, lambda_=1.0507, alpha=1.6733):
+    return lambda_ * np.where(x > 0, x, alpha * (np.exp(x) - 1))
 
 
 def Softmax(
@@ -476,11 +462,138 @@ def Relu(
     return np.maximum(0, x)
 
 
+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.
+    activation_potentiation,
+    index,
+    max_w # float or None: Input activation potentiation (optional)
+) -> tuple:
+    """
+    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.
+    """
+
+    Output = np.zeros(len(Input))
+    
+    for activation in activation_potentiation:
+
+        if activation == 'sigmoid':
+            Output += Sigmoid(Input)
+
+        if activation == 'swish':
+            Output += swish(Input)
+
+        if activation == 'circular':
+            Output += circular_activation(Input)
+
+        if activation == 'mod_circular':
+            Output += modular_circular_activation(Input)
+
+        if activation == 'tanh_circular':
+            Output += tanh_circular_activation(Input)
+
+        if activation == 'leaky_relu':
+            Output += leaky_relu(Input)
+
+        if activation == 'relu':
+            Output += Relu(Input)
+        
+        if activation == 'softplus':
+            Output += softplus(Input)
+
+        if activation == 'elu':
+            Output += elu(Input)
+
+        if activation == 'gelu':
+            Output += gelu(Input)
+
+        if activation == 'selu':
+            Output += selu(Input)    
+
+        if activation == 'softmax':
+            Output += Softmax(Input)
+
+        if activation == 'tanh':
+            Output += tanh(Input)
+
+        if activation == None:
+            Output += Input
+
+    Input = Output
+
+    if is_training == True:
+        
+        w[Class, :] = Input
+
+        return w
+
+           
+    elif is_training == False:
+        
+        neural_layer = np.dot(w, Input)
+    
+        return neural_layer
+    
+    elif is_training == False and max_w != 0:
+
+
+        if index == max_w:
+
+            neural_layer = np.dot(w, Input)
+            return neural_layer
+
+        else:
+
+            neural_layer = [None] * len(w)
+
+            for i in range(len(w)):
+
+                neural_layer[i] = Input[i] * w[i]
+
+            neural_layer = np.array(neural_layer)
+
+            return neural_layer
+
+
+def normalization(
+    Input  # num: Input data to be normalized.
+):
+    """
+    Normalizes the input data using maximum absolute scaling.
+
+    Args:
+        Input (num): Input data to be normalized.
+
+    Returns:
+        (num) Scaled input data after normalization.
+    """
+
+    AbsVector = np.abs(Input)
+
+    MaxAbs = np.max(AbsVector)
+
+    ScaledInput = Input / MaxAbs
+
+    return ScaledInput
+
+
 def evaluate(
     x_test,         # list[num]: Test input data.
     y_test,         # list[num]: Test labels.
     W,               # list[num]: Weight matrix list of the neural network.
-    activation_potentiation=None, # activation_potentiation (float or None): Threshold value for comparison. (optional) Default: None
+    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:
@@ -503,14 +616,17 @@ def evaluate(
     real_classes = []
     predict_classes = []
     
+    layer_count = len(W)
+
     try:
-        layers = ['fex']
+        layers = ['fex'] * layer_count
 
         Wc = [0] * len(W)  # Wc = Weight copy
         true = 0
         y_preds = []
         acc_list = []
-        
+        max_w = len(W) - 1
+
         for i, w in enumerate(W):
             Wc[i] = np.copy(w)
             
@@ -520,22 +636,23 @@ def evaluate(
             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()
             neural_layer = Input
 
-            for index, Layer in enumerate(layers):
+            for index, Layer in enumerate(W):
 
-                if Layer == 'fex':
-                    neural_layer = fex(neural_layer, W[index], False, None, activation_potentiation)
+                
+                neural_layer = fex(neural_layer, W[index], False, None, activation_potentiation, index=index, max_w=max_w)
 
 
             for i, w in enumerate(Wc):
                 W[i] = np.copy(w)
                 
             neural_layer = Softmax(neural_layer)
+
             max_value = max(neural_layer)
 
             predict_probabilitys.append(max_value)
@@ -564,12 +681,12 @@ def evaluate(
                     acc_bar.update(acc)
             
         if show_metrices == True:
-            plot_evaluate(x_test, y_test, y_preds, acc_list)
+            plot_evaluate(x_test, y_test, y_preds, acc_list, W=W, activation_potentiation=activation_potentiation)
         
         
         for i, w in enumerate(Wc):
             W[i] = np.copy(w)
-        
+    
     except:
 
         print(Fore.RED + 'ERROR:' + infoTestModel + Style.RESET_ALL)
@@ -712,7 +829,7 @@ def save_model(model_name,
                model_path,
                W,
                scaler_params=None,
-               activation_potentiation=None
+               activation_potentiation=[None]
                ):
 
     infosave_model = """
@@ -752,6 +869,7 @@ def save_model(model_name,
     NeuronCount = 0
     SynapseCount = 0
 
+
     try:
         for w in W:
             NeuronCount += np.shape(w)[0]
@@ -761,13 +879,21 @@ def save_model(model_name,
         print(Fore.RED + "ERROR: Weight matrices has a problem from: save_model" +
               infosave_model + Style.RESET_ALL)
         return 'e'
-    import pandas as pd
-    from datetime import datetime
-    from scipy import io
+
+    if scaler_params != None:
+
+        if len(scaler_params) > len(activation_potentiation):
+
+            activation_potentiation += ['']
+
+        elif len(activation_potentiation) > len(scaler_params):
+
+            for i in range(len(activation_potentiation) - len(scaler_params)):
+
+                scaler_params.append(' ')
 
     data = {'MODEL NAME': model_name,
             'MODEL TYPE': model_type,
-            'LAYERS': layers,
             'LAYER COUNT': len(layers),
             'CLASS COUNT': class_count,
             'NEURON COUNT': NeuronCount,
@@ -789,45 +915,42 @@ def save_model(model_name,
     except:
 
         print(Fore.RED + "ERROR: Model log not saved probably model_path incorrect. Check the log parameters from: save_model" +
-              infosave_model + Style.RESET_ALL)
+                    infosave_model + Style.RESET_ALL)
         return 'e'
+
     try:
 
         if weights_type == 'txt' and weights_format == 'd':
 
             for i, w in enumerate(W):
-                np.savetxt(model_path + model_name +
-                           str(i+1) + 'w.txt',  w, fmt='%d')
+                np.savetxt(model_path + model_name + '_weights.txt',  w, fmt='%d')
 
         if weights_type == 'txt' and weights_format == 'f':
 
             for i, w in enumerate(W):
-                np.savetxt(model_path + model_name +
-                           str(i+1) + 'w.txt',  w, fmt='%f')
+                np.savetxt(model_path + model_name + '_weights.txt',  w, fmt='%f')
 
         if weights_type == 'txt' and weights_format == 'raw':
 
             for i, w in enumerate(W):
-                np.savetxt(model_path + model_name + str(i+1) + 'w.txt',  w)
+                np.savetxt(model_path + model_name + '_weights.txt',  w)
 
         ###
 
         if weights_type == 'npy' and weights_format == 'd':
 
             for i, w in enumerate(W):
-                np.save(model_path + model_name +
-                        str(i+1) + 'w.npy', w.astype(int))
+                np.save(model_path + model_name + '_weights.npy', w.astype(int))
 
         if weights_type == 'npy' and weights_format == 'f':
 
             for i, w in enumerate(W):
-                np.save(model_path + model_name + str(i+1) +
-                        'w.npy',  w, w.astype(float))
+                np.save(model_path + model_name + '_weights.npy',  w, w.astype(float))
 
         if weights_type == 'npy' and weights_format == 'raw':
 
             for i, w in enumerate(W):
-                np.save(model_path + model_name + str(i+1) + 'w.npy',  w)
+                np.save(model_path + model_name + '_weights.npy',  w)
 
         ###
 
@@ -835,19 +958,19 @@ def save_model(model_name,
 
             for i, w in enumerate(W):
                 w = {'w': w.astype(int)}
-                io.savemat(model_path + model_name + str(i+1) + 'w.mat', w)
+                io.savemat(model_path + model_name + '_weights.mat', w)
 
         if weights_type == 'mat' and weights_format == 'f':
 
             for i, w in enumerate(W):
                 w = {'w': w.astype(float)}
-                io.savemat(model_path + model_name + str(i+1) + 'w.mat', w)
+                io.savemat(model_path + model_name + '_weights.mat', w)
 
         if weights_type == 'mat' and weights_format == 'raw':
 
             for i, w in enumerate(W):
                 w = {'w': w}
-                io.savemat(model_path + model_name + str(i+1) + 'w.mat', w)
+                io.savemat(model_path + model_name + '_weights.mat', w)
 
     except:
 
@@ -878,8 +1001,6 @@ def load_model(model_name,
     """
     pass
 
-    import scipy.io as sio
-
     try:
 
         df = pd.read_csv(model_path + model_name + '.' + 'txt', delimiter='\t')
@@ -897,13 +1018,13 @@ def load_model(model_name,
 
     if WeightType == 'txt':
         for i in range(layer_count):
-            W[i] = np.loadtxt(model_path + model_name + str(i+1) + 'w.txt')
+            W[i] = np.loadtxt(model_path + model_name + '_weights.txt')
     elif WeightType == 'npy':
         for i in range(layer_count):
-            W[i] = np.load(model_path + model_name + str(i+1) + 'w.npy')
+            W[i] = np.load(model_path + model_name + '_weights.npy')
     elif WeightType == 'mat':
         for i in range(layer_count):
-            W[i] = sio.loadmat(model_path + model_name + str(i+1) + 'w.mat')
+            W[i] = sio.loadmat(model_path + model_name + '_weights.mat')
     else:
         raise ValueError(
             Fore.RED + "Incorrect weight type value. Value must be 'txt', 'npy' or 'mat' from: load_model." + infoload_model + Style.RESET_ALL)
@@ -924,29 +1045,21 @@ def predict_model_ssd(Input, model_name, model_path):
     """
     W, df = load_model(model_name, model_path)
     
-    activation_potentiation = str(df['ACTIVATION POTENTIATION'].iloc[0])
+    activation_potentiation = list(df['ACTIVATION POTENTIATION'])
 
-    if activation_potentiation != 'nan':
+    scaler_params = df['STANDARD SCALER'].tolist()
+
+    scaler_params = [item for item in scaler_params if item != ' ']
 
-        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:
     
         pass
-        
 
     layers = ['fex']
 
@@ -957,12 +1070,11 @@ def predict_model_ssd(Input, model_name, model_path):
         neural_layer = Input
         neural_layer = np.array(neural_layer)
         neural_layer = neural_layer.ravel()
-        for index, Layer in enumerate(layers):
+        max_w = len(W) - 1
+        for index, Layer in enumerate(W):
         
-            if Layer == 'fex':
-                neural_layer = fex(neural_layer, W[index], False, None, activation_potentiation)
-            elif Layer == 'cat':
-                neural_layer = np.dot(W[index], neural_layer)
+            neural_layer = fex(neural_layer, W[index], False, None, activation_potentiation, index=index, max_w=max_w)
+
     except:
         print(Fore.RED + "ERROR: The input was probably entered incorrectly. from: predict_model_ssd" +
               infopredict_model_ssd + Style.RESET_ALL)
@@ -972,7 +1084,7 @@ def predict_model_ssd(Input, model_name, model_path):
     return neural_layer
 
 
-def predict_model_ram(Input, W, scaler_params=None, activation_potentiation=None):
+def predict_model_ram(Input, W, scaler_params=None, activation_potentiation=[None]):
 
     infopredict_model_ram = """
     Function to make a prediction using a divided potentiation learning artificial neural network (PLAN).
@@ -999,25 +1111,26 @@ def predict_model_ram(Input, W, scaler_params=None, activation_potentiation=None
     Wc = [0] * len(W)
     for i, w in enumerate(W):
         Wc[i] = np.copy(w)
-    #try:
-    neural_layer = Input
-    neural_layer = np.array(neural_layer)
-    neural_layer = neural_layer.ravel()
-    for index, Layer in enumerate(layers):
-
-        if Layer == 'fex':
-            neural_layer = fex(neural_layer, W[index], False, None, activation_potentiation)
-        elif Layer == 'cat':
-            neural_layer = np.dot(W[index], neural_layer)
-
-        """    except:
-    print(Fore.RED + "ERROR: Unexpected input or wrong model parameters from: predict_model_ram." +
-            infopredict_model_ram + Style.RESET_ALL)
-    return 'e'"""
-    for i, w in enumerate(Wc):
-        W[i] = np.copy(w)
-    return neural_layer
+    try:
+        neural_layer = Input
+        neural_layer = np.array(neural_layer)
+        neural_layer = neural_layer.ravel()
 
+        max_w = len(W) - 1
+
+        for index, Layer in enumerate(W):
+
+
+            neural_layer = fex(neural_layer, W[index], False, None, activation_potentiation, index=index, max_w=max_w)
+
+        for i, w in enumerate(Wc):
+            W[i] = np.copy(w)
+        return neural_layer
+
+    except:
+        print(Fore.RED + "ERROR: Unexpected input or wrong model parameters from: predict_model_ram." +
+            infopredict_model_ram + Style.RESET_ALL)
+    return 'e'
 
 def auto_balancer(x_train, y_train):
 
@@ -1057,7 +1170,7 @@ def auto_balancer(x_train, y_train):
         BalancedInputs = [x_train[idx] for idx in BalancedIndices]
         BalancedLabels = [y_train[idx] for idx in BalancedIndices]
 
-        print(Fore.GREEN + "All Training Data Succesfully Balanced from: " + str(len(x_train)
+        print(Fore.GREEN + "All Data Succesfully Balanced from: " + str(len(x_train)
                                                                                  ) + " to: " + str(len(BalancedInputs)) + ". from: auto_balancer " + Style.RESET_ALL)
     except:
         print(Fore.RED + "ERROR: Inputs and labels must be same length check parameters" + infoauto_balancer)
@@ -1147,6 +1260,7 @@ def standard_scaler(x_train, x_test=None, scaler_params=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
             
@@ -1154,7 +1268,7 @@ def standard_scaler(x_train, x_test=None, scaler_params=None):
             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:
@@ -1170,16 +1284,25 @@ def standard_scaler(x_train, x_test=None, scaler_params=None):
             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)
+
+            try:
+
+                test_data_scaled = (x_test - scaler_params[0]) / scaler_params[1]
+                test_data_scaled = np.nan_to_num(test_data_scaled, nan=0)
+
+            except:
+
+                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 + Style.RESET_ALL)
-
+        Fore.RED + "ERROR: x_train and x_test must be list[numpyarray] from standard_scaler" + info_standard_scaler + Style.RESET_ALL)
+    
+        return('e')
 
 def encode_one_hot(y_train, y_test):
     info_one_hot_encode = """
@@ -1423,7 +1546,7 @@ def confusion_matrix(y_true, y_pred, class_count):
     return confusion
 
 
-def plot_evaluate(x_test, y_test, y_preds, acc_list):
+def plot_evaluate(x_test, y_test, y_preds, acc_list, W, activation_potentiation):
     
     
     acc = acc_list[len(acc_list) - 1]
@@ -1524,51 +1647,67 @@ def plot_evaluate(x_test, y_test, y_preds, acc_list):
     axs[0, 1].set_title('Precision, Recall, F1 Score, and Accuracy (Weighted)')
     axs[0, 1].grid(True, axis='y', linestyle='--', alpha=0.7)
     
-    
-    if x_test.shape[1] > 2:
+    feature_indices=[0, 1]
 
-            X_pca = pca(x_test, n_components=2)
-    else:
-            X_pca = x_test
-
-    y_test = decode_one_hot(y_test)
-    num_classes = len(np.unique(y_test))
+    h = .02
+    x_min, x_max = x_test[:, feature_indices[0]].min() - 1, x_test[:, feature_indices[0]].max() + 1
+    y_min, y_max = x_test[:, feature_indices[1]].min() - 1, x_test[:, feature_indices[1]].max() + 1
+    xx, yy = np.meshgrid(np.arange(x_min, x_max, h),
+                         np.arange(y_min, y_max, h))
+    
+    grid = np.c_[xx.ravel(), yy.ravel()]
+    grid_full = np.zeros((grid.shape[0], x_test.shape[1]))
+    grid_full[:, feature_indices] = grid
     
+    Z = [None] * len(grid_full)
 
-    cmap = plt.get_cmap('tab20')
+    predict_progress = tqdm(total=len(grid_full),leave=False, desc="Predicts For Desicion Boundary",ncols= 120)
 
+    for i in range(len(grid_full)):
 
+        Z[i] = np.argmax(predict_model_ram(grid_full[i], W=W, activation_potentiation=activation_potentiation))
+        predict_progress.update(1)
 
-    norm = plt.Normalize(vmin=0, vmax=num_classes - 1)
-    
+    Z = np.array(Z)
+    Z = Z.reshape(xx.shape)
 
-    scatter = axs[1, 1].scatter(X_pca[:, 0], X_pca[:, 1], c=y_test, edgecolor='k', s=50, cmap=cmap, norm=norm)
-    
+    axs[1,1].contourf(xx, yy, Z, alpha=0.8)
+    axs[1,1].scatter(x_test[:, feature_indices[0]], x_test[:, feature_indices[1]], c=decode_one_hot(y_test), edgecolors='k', marker='o', s=20, alpha=0.9)
+    axs[1,1].set_xlabel(f'Feature {0 + 1}')
+    axs[1,1].set_ylabel(f'Feature {1 + 1}')
+    axs[1,1].set_title('Decision Boundary')
 
-    for cls in range(num_classes):
-        class_points = []
+    plt.show()
 
-  
-        for i in range(len(y_test)):
-            if y_preds[i] == cls:
-                class_points.append(X_pca[i])
-        
-        class_points = np.array(class_points)
+def plot_decision_boundary(x, y, activation_potentiation, W):
 
-        if len(class_points) > 2: 
-            hull = ConvexHull(class_points)
-            hull_points = class_points[hull.vertices]
-            
+    feature_indices=[0, 1]
 
-            hull_points = np.vstack([hull_points, hull_points[0]])
-            
+    h = .02  # mesh grid adımı
+    x_min, x_max = x[:, feature_indices[0]].min() - 1, x[:, feature_indices[0]].max() + 1
+    y_min, y_max = x[:, feature_indices[1]].min() - 1, x[:, feature_indices[1]].max() + 1
+    xx, yy = np.meshgrid(np.arange(x_min, x_max, h),
+                         np.arange(y_min, y_max, h))
+    
+    grid = np.c_[xx.ravel(), yy.ravel()]
+    grid_full = np.zeros((grid.shape[0], x.shape[1]))
+    grid_full[:, feature_indices] = grid
+    
+    Z = [None] * len(grid_full)
 
-            axs[1, 1].fill(hull_points[:, 0], hull_points[:, 1], color=cmap(norm(cls)), alpha=0.3, edgecolor='k', label=f'Class {cls} Hull')
+    for i in range(len(grid_full)):
 
+        Z[i] = np.argmax(predict_model_ram(grid_full[i], W=W, activation_potentiation=activation_potentiation))
 
-    axs[1, 1].set_title("Decision Boundry")
+    Z = np.array(Z)
+    Z = Z.reshape(xx.shape)
 
-    plt.show()
+    plt.contourf(xx, yy, Z, alpha=0.8)
+    plt.scatter(x[:, feature_indices[0]], x[:, feature_indices[1]], c=decode_one_hot(y), edgecolors='k', marker='o', s=20, alpha=0.9)
+    plt.xlabel(f'Feature {0 + 1}')
+    plt.ylabel(f'Feature {1 + 1}')
+    plt.title('Decision Boundary')
+    plt.draw()
 
 def pca(X, n_components):
     """
@@ -1598,7 +1737,7 @@ def pca(X, n_components):
     
     return X_reduced
 
-def plot_decision_boundry(x, y, y_preds=None, s=100, color='tab20'):
+def plot_decision_space(x, y, y_preds=None, s=100, color='tab20'):
     
     if x.shape[1] > 2:
 

{pyerualjetwork-2.8.4.dist-info → pyerualjetwork-3.1.dist-info}/METADATA

@@ -1,13 +1,8 @@
 Metadata-Version: 2.1
 Name: pyerualjetwork
-Version: 2.8.4
-Summary: plot_decision_boundry function added
-Home-page: UNKNOWN
+Version: 3.1
+Summary: Deep PLAN Integreted. Version 3 document coming
 Author: Hasan Can Beydili
 Author-email: tchasancan@gmail.com
-License: UNKNOWN
 Keywords: model evaluation,classifcation,potentiation learning artficial neural networks
-Platform: UNKNOWN
-
-UNKNOWN
 

pyerualjetwork-3.1.dist-info/RECORD

@@ -0,0 +1,6 @@
+plan/__init__.py,sha256=LuFcY0nqAzpjTDWAZn7L7-wipwMpnREqVghPiva0Xjg,548
+plan/plan.py,sha256=Q7W2o5T4fLpme5ZG0kRPL0EA5SXA1Ccui3UfHWxkBHI,60472
+pyerualjetwork-3.1.dist-info/METADATA,sha256=bqwcxFGQBi8b-0l8bAzDfIdrtUbZV-pIP-1yiwhETOo,272
+pyerualjetwork-3.1.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
+pyerualjetwork-3.1.dist-info/top_level.txt,sha256=G0Al3HuNJ88434XneyDtRKAIUaLCizOFYFYNhd7e2OM,5
+pyerualjetwork-3.1.dist-info/RECORD,,

{pyerualjetwork-2.8.4.dist-info → pyerualjetwork-3.1.dist-info}/WHEEL

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

pyerualjetwork-2.8.4.dist-info/RECORD

@@ -1,6 +0,0 @@
-plan/__init__.py,sha256=SLgk4uuvhVr3CjscpcqN2TQMGyAd4Pe8YBiXfl3brd8,525
-plan/plan.py,sha256=YzmhHtaEyH51NcnfZLsAtUDBClag_TFCjy67554ouQM,56261
-pyerualjetwork-2.8.4.dist-info/METADATA,sha256=K9L9_hqmgaEIWjPRmTmihY6Kllp1L5mOwiGtT9fU9o0,331
-pyerualjetwork-2.8.4.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-pyerualjetwork-2.8.4.dist-info/top_level.txt,sha256=G0Al3HuNJ88434XneyDtRKAIUaLCizOFYFYNhd7e2OM,5
-pyerualjetwork-2.8.4.dist-info/RECORD,,