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

plan/plan.py

@@ -18,43 +18,49 @@ from scipy.spatial import ConvexHull
 from datetime import datetime
 from scipy import io
 import scipy.io as sio
+from matplotlib.animation import ArtistAnimation
+import networkx as nx
 
 # BUILD -----
 
 
 def fit(
     x_train: List[Union[int, float]],
-    y_train: List[Union[int, float]], # At least two.. and one hot encoded
+    y_train: List[Union[int, float]], # One hot encoded
     val= None,
     val_count = None,
-    activation_potentiation=[None], # (float): Input activation_potentiation (optional)
+    activation_potentiation=[None], # activation_potentiation (list): ac list for deep PLAN. default: [None] ('linear') (optional)
     x_val= None,
     y_val= None,
     show_training = None,
-    show_count= None, # [DISABLED]
-    visible_layer=None # For future [DISABLED]
+    visible_layer=None, # For the future [DISABLED]
+    interval=100,
+    LTD = 0 # LONG TERM DEPRESSION
 ) -> str:
 
     infoPLAN = """
     Creates and configures a PLAN model.
     
     Args:
-        x_train (list[num]): List of input data.
-        y_train (list[num]): List of target labels. (one hot encoded)
-        val (None, True or 'final'): validation in training process ? None, True or 'final' Default: None (optional)
-        val_count (None, int): After how many examples learned will an accuracy test be performed? Default: 0.1 (%10) (optional)
-        activation_potentiation (float): Input activation potentiation (for binary injection) (optional) in range: -1, 1
-        x_val (list[num]): List of validation data. (optional) Default: %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) [DISABLED]
-        visible_layer: For future [DISABLED]
+        x_train (list[num]): List or numarray of input data.
+        y_train (list[num]): List or numarray of target labels. (one hot encoded)
+        val (None or True): validation in training process ? None or True default: None (optional)
+        val_count (None or int): After how many examples learned will an accuracy test be performed? default: 10=(%10) it means every approximately 10 step (optional)
+        activation_potentiation (list): For deeper PLAN networks, activation function parameters. For more information please run this code: help(plan.activation_functions_list) default: [None] (optional)
+        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 default: x_train (optional)
+        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 default: y_train (optional)
+        show_training (bool, str): True or None default: None (optional)
+        visible_layer: For the future [DISABLED]
+        LTD (int): Long Term Depression Hyperparameter for train PLAN neural network (optional)
+        interval (float, int): frame delay (milisecond) parameter for Training Report (show_training=True) This parameter effects to your Training Report performance. Lower value is more diffucult for Low end PC's (33.33 = 30 FPS, 16.67 = 60 FPS) default: 100 (optional)
 
     Returns:
-        list([num]): (Weight matrices list, train_predictions list, Train_acc).
+        list([num]): (Weight matrix).
         error handled ?: Process status ('e')
 """
 
+    fit.__doc__ = infoPLAN
+    
     visible_layer = None
 
     if len(x_train) != len(y_train):
@@ -62,45 +68,46 @@ def fit(
         print(Fore.RED + "ERROR301: x_train list and y_train list must be same length. from: fit", infoPLAN + Style.RESET_ALL)
         return 'e'
 
-    if val == True or val == 'final':
+    if val == True:
 
         try:
 
             if x_val == None and y_val == None:
 
-                x_train, x_val, y_train, y_val = split(x_train, y_train, test_size=0.1, random_state=42)
+                x_val = x_train
+                y_val = y_train
+                
+        except:
 
-                x_train, y_train = auto_balancer(x_train, y_train)
-                x_val, y_val = auto_balancer(x_val, y_val)
+            pass
 
-        except:
-                pass
+        if val_count == None:
 
-        if val == True:
+            val_count = 10
+    
+        val_bar = tqdm(total=1, desc="Validating Accuracy", ncols=120)
+        v_iter = 0
+        val_list = [] * val_count
 
-            if val_count == None:
+    if show_training == True:
 
-                val_count = 0.01
+        G = nx.Graph()
 
-            v_iter = 0
+        fig, ax = plt.subplots(2, 2)
+        fig.suptitle('Train Report')
 
-        if val == 'final':
+        artist1 = []
+        artist2 = []
+        artist3 = []
+        artist4 = []
 
-            val_count = 0.99
-        
-        val_count = int(len(x_train) * val_count)
-        val_count_copy = val_count
-        val_bar = tqdm(total=1, desc="Validating Accuracy", ncols=120)
-        val_list = [] * val_count
+        if val != True:
 
-    if show_count == None:
-        
-        show_count = 10
+            print(Fore.RED + "ERROR115: For showing training, val parameter must be True. from: fit",
+                  infoPLAN + Style.RESET_ALL)
+            return 'e'
 
-    if show_training == True or show_training == 'final':
 
-        row, col = shape_control(x_train)
-    
     class_count = set()
 
     for sublist in y_train:
@@ -123,10 +130,12 @@ def fit(
     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:
@@ -135,6 +144,7 @@ def fit(
         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]
@@ -167,7 +177,7 @@ def fit(
         for Lindex, Layer in enumerate(STPW):
 
             
-            STPW[Lindex] = fex(neural_layer, STPW[Lindex], True, y[index], activation_potentiation, index=Lindex, max_w=max_w)
+            STPW[Lindex] = fex(neural_layer, STPW[Lindex], True, y[index], activation_potentiation, index=Lindex, max_w=max_w, LTD=LTD)
                 
         
         for i in range(len(STPW)):
@@ -175,27 +185,68 @@ def fit(
         
         for i, w in enumerate(STPW):
                 LTPW[i] = LTPW[i] + w
-
             
         if val == True:
 
-            try:
-
-                if round(progress) % 10 == 1:
-
+                if int(progress) % val_count == 1:
 
                     validation_model = evaluate(x_val, y_val, LTPW ,bar_status=False, activation_potentiation=activation_potentiation, show_metrices=None)
-
                     val_acc = validation_model[get_acc()]
-                    
-                    plot_decision_boundary(x_val, y_val, activation_potentiation, LTPW)
 
-                    plt.pause(0.0001)
-
-                    plt.clf()
-                    
                     val_list.append(val_acc)
                     
+                    if show_training == True:
+
+                        
+                        mat = LTPW[0]
+                        art2 = ax[0, 0].imshow(mat, interpolation='sinc', cmap='viridis')
+                        suptitle_info = 'Weight Learning Progress'
+                        
+                        ax[0, 0].set_title(suptitle_info)
+
+                        artist2.append([art2])
+                        
+                        artist1 = plot_decision_boundary(ax, x_val, y_val, activation_potentiation, LTPW, artist=artist1)
+
+                        period = list(range(1, len(val_list) + 1))
+
+                        art3 = ax[1, 1].plot(
+                        period, 
+                        val_list, 
+                        linestyle='--',   
+                        color='g',       
+                        marker='o',      
+                        markersize=6,
+                        linewidth=2,      
+                        label='Validation Accuracy'
+                    )
+
+                        ax[1, 1].set_title('Validation History')
+                        ax[1, 1].set_xlabel('Time')
+                        ax[1, 1].set_ylabel('Validation Accuracy')
+                        ax[1, 1].set_ylim([0, 1])
+
+                        artist3.append(art3)
+
+                        for i in range(LTPW[0].shape[0]):
+                            for j in range(LTPW[0].shape[1]):
+                                if LTPW[0][i, j] != 0:
+                                    G.add_edge(f'Motor Neuron{i}', f'Sensory Neuron{j}', ltpw=LTPW[0][i, j])
+
+                        edges = G.edges(data=True)
+                        weights = [edata['ltpw'] for _, _, edata in edges]
+                        pos = generate_fixed_positions(G, layout_type='circular')
+
+                        art4_1 = nx.draw_networkx_nodes(G, pos, ax=ax[0, 1], node_size=1000, node_color='lightblue')
+                        art4_2 = nx.draw_networkx_edges(G, pos, ax=ax[0, 1], edge_color=weights, edge_cmap=plt.cm.Blues)
+                        art4_3 = nx.draw_networkx_labels(G, pos, ax=ax[0, 1], font_size=10, font_weight='bold')
+                        ax[0, 1].set_title('Neural Web')
+                        
+                        art4_list = [art4_1] + [art4_2] + list(art4_3.values())
+
+                        artist4.append(art4_list)
+            
+
                     if v_iter == 0:
                         
                         val_bar.update(val_acc)
@@ -206,131 +257,92 @@ def fit(
                         val_bar.update(val_acc)
                     
                     v_iter += 1
-            except:
-                pass
-
-        if show_training == True:
-            if index == 0:
-                if row != 0:
-                
-                    ax = plt.subplots(1, len(class_count), figsize=(18, 14))
-                    
-            if round(progress) % 2 == 1:
-                
-                  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'
-                        
-                        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
 
         else:      
             STPW = weight_identification(
-                len(layers), len(class_count), fex_neurons, cat_neurons, x_train_size) 
+                len(layers), len(class_count), fex_neurons, cat_neurons, x_train_size)
 
         train_progress.update(1)
 
-    if show_training == 'final':
-            
-            fig, ax = plt.subplots(1, len(class_count), figsize=(18, 14))
+    if show_training == True:
 
-            for j in range(len(class_count)):
+        mat = LTPW[0]
 
-                mat = LTPW[0][j,:].reshape(row, col)
+        for i in range(30):
 
-                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')
+            art2 = ax[0, 0].imshow(mat, interpolation='sinc', cmap='viridis')
+            suptitle_info = 'Weight Learning Progress:'
 
-            progress_status = f"{progress:.1f}"
-            fig.suptitle('Neurons Learning Progress: % ' + progress_status)
-            plt.draw()
-            plt.pause(0.0001)
+            ax[0, 0].set_title(suptitle_info)
 
-    if val == 'final':
-   
-        validation_model = evaluate(x_val, y_val, LTPW,bar_status=False, activation_potentiation=activation_potentiation, show_metrices=None)
+            artist2.append([art2])
+
+            art3 = ax[1, 1].plot(
+            period, 
+            val_list, 
+            linestyle='--', 
+            color='g',        
+            marker='o',      
+            markersize=6,     
+            linewidth=2,     
+            label='Validation Accuracy'
+            )
             
-        val_acc = validation_model[get_acc()]
-        
-        plot_decision_boundary(x_val, y_val, activation_potentiation, LTPW)
+            ax[1, 1].set_title('Validation History')
+            ax[1, 1].set_xlabel('Time')
+            ax[1, 1].set_ylabel('Validation Accuracy')
+            ax[1, 1].set_ylim([0, 1])
 
-        val_list.append(val_acc)
-        
-        val_bar.update(val_acc)
-               
-    for i in range(len(LTPW)):
-            LTPW[i] = normalization(LTPW[i])
+            artist3.append(art3)
 
-    return LTPW
+        for i in range(28):
 
-# FUNCTIONS -----
+            art4_1 = nx.draw_networkx_nodes(G, pos, ax=ax[0, 1], node_size=1000, node_color='lightblue')
+            art4_2 = nx.draw_networkx_edges(G, pos, ax=ax[0, 1], edge_color=weights, edge_cmap=plt.cm.Blues)
+            art4_3 = nx.draw_networkx_labels(G, pos, ax=ax[0, 1], font_size=10, font_weight='bold')
+            ax[0, 1].set_title('Neural Web')
+            
+            art4_list = [art4_1] + [art4_2] + list(art4_3.values())
 
-def shape_control(x_train):
+            artist4.append(art4_list)
 
-    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
+        artist1 = plot_decision_boundary(ax, x_val, y_val, activation_potentiation, LTPW, artist=artist1, draw_is_finished=True)
+
+        ani1 = ArtistAnimation(fig, artist1, interval=interval, blit=True)
+        ani2 = ArtistAnimation(fig, artist2, interval=interval, blit=True)
+        ani3 = ArtistAnimation(fig, artist3, interval=interval, blit=True)
+        ani4 = ArtistAnimation(fig, artist4, interval=interval, blit=True)
 
-def find_numbers(n):
-    if n <= 1:
-        raise ValueError("Parameter 'n' must be greater than 1.")
+        plt.show()
 
-    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
+    LTPW = normalization(LTPW)
 
-    return None
+    return LTPW
+
+# FUNCTIONS -----
+
+def generate_fixed_positions(G, layout_type='circular'):
+    pos = {}
+    num_nodes = len(G.nodes())
+    
+    if layout_type == 'circular':
+        angles = np.linspace(0, 2 * np.pi, num_nodes, endpoint=False)
+        radius = 10
+        for i, node in enumerate(G.nodes()):
+            pos[node] = (radius * np.cos(angles[i]), radius * np.sin(angles[i]))
+    elif layout_type == 'grid':
+        grid_size = int(np.ceil(np.sqrt(num_nodes)))
+        for i, node in enumerate(G.nodes()):
+            pos[node] = (i % grid_size, i // grid_size)
+    else:
+        raise ValueError("Unsupported layout_type. Use 'circular' or 'grid'.")
+    
+    return pos
 
 def weight_normalization(
     W,
@@ -384,37 +396,6 @@ def weight_identification(
 
 # ACTIVATION FUNCTIONS -----
 
-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 modular_circular_activation(x, period=2*np.pi):
-    return np.mod(x, period) / period
-
-def tanh_circular_activation(x):
-    return (np.tanh(x) + 1) / 2
-
-def leaky_relu(x, alpha=0.01):
-    return np.where(x > 0, x, alpha * x)
-
-def softplus(x):
-    return np.log(1 + np.exp(x))
-
-def elu(x, alpha=1.0):
-    return np.where(x > 0, x, alpha * (np.exp(x) - 1))
-
-def gelu(x):
-    return 0.5 * x * (1 + np.tanh(np.sqrt(2 / np.pi) * (x + 0.044715 * np.power(x, 3))))
-
-def selu(x, lambda_=1.0507, alpha=1.6733):
-    return lambda_ * np.where(x > 0, x, alpha * (np.exp(x) - 1))
-
-
 def Softmax(
     x  # num: Input data to be transformed using softmax function.
 ):
@@ -461,15 +442,145 @@ def Relu(
 
     return np.maximum(0, x)
 
+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 modular_circular_activation(x, period=2*np.pi):
+    return np.mod(x, period) / period
+
+def tanh_circular_activation(x):
+    return (np.tanh(x) + 1) / 2
+
+def leaky_relu(x, alpha=0.01):
+    return np.where(x > 0, x, alpha * x)
+
+def softplus(x):
+    return np.log(1 + np.exp(x))
+
+def elu(x, alpha=1.0):
+    return np.where(x > 0, x, alpha * (np.exp(x) - 1))
+
+def gelu(x):
+    return 0.5 * x * (1 + np.tanh(np.sqrt(2 / np.pi) * (x + 0.044715 * np.power(x, 3))))
+
+def selu(x, lambda_=1.0507, alpha=1.6733):
+    return lambda_ * np.where(x > 0, x, alpha * (np.exp(x) - 1))
+
+# 1. Sinusoids Activation (SinAkt)
+def sinakt(x):
+    return np.sin(x) + np.cos(x)
+
+# 2. Parametric Squared Activation (P-Squared)
+def p_squared(x, alpha=1.0, beta=0.0):
+    return alpha * x**2 + beta * x
+
+def sglu(x, alpha=1.0):
+    return softmax(alpha * x) * x
+
+# 4. Double Leaky ReLU (DLReLU)
+def dlrelu(x):
+    return np.maximum(0.01 * x, x) + np.minimum(0.01 * x, 0.1 * x)
+
+# 5. Exponential Sigmoid (ExSig)
+def exsig(x):
+    return 1 / (1 + np.exp(-x**2))
+
+# 6. Adaptive Cosine Activation (ACos)
+def acos(x, alpha=1.0, beta=0.0):
+    return np.cos(alpha * x + beta)
+
+# 7. Gaussian-like Activation (GLA)
+def gla(x, alpha=1.0, mu=0.0):
+    return np.exp(-alpha * (x - mu)**2)
+
+# 8. Swish ReLU (SReLU)
+def srelu(x):
+    return x * (1 / (1 + np.exp(-x))) + np.maximum(0, x)
+
+# 9. Quadratic Exponential Linear Unit (QELU)
+def qelu(x):
+    return x**2 * np.exp(x) - 1
+
+# 10. Inverse Square Root Activation (ISRA)
+def isra(x):
+    return x / np.sqrt(np.abs(x) + 1)
+
+def waveakt(x, alpha=1.0, beta=2.0, gamma=3.0):
+    return np.sin(alpha * x) * np.cos(beta * x) * np.sin(gamma * x)
+
+def arctan(x):
+    return np.arctan(x)
+
+def bent_identity(x):
+    return (np.sqrt(x**2 + 1) - 1) / 2 + x
+
+def sech(x):
+    return 2 / (np.exp(x) + np.exp(-x))
+
+def softsign(x):
+    return x / (1 + np.abs(x))
+
+def pwl(x, alpha=0.5, beta=1.5):
+    return np.where(x <= 0, alpha * x, beta * x)
+
+def cubic(x):
+    return x**3
+
+def gaussian(x, alpha=1.0, mu=0.0):
+    return np.exp(-alpha * (x - mu)**2)
+                
+def sine(x, alpha=1.0):
+    return np.sin(alpha * x)
+
+def tanh_square(x):
+    return np.tanh(x)**2
+
+def mod_sigmoid(x, alpha=1.0, beta=0.0):
+    return 1 / (1 + np.exp(-alpha * x + beta))
+
+def quartic(x):
+    return x**4
+
+def square_quartic(x):
+    return (x**2)**2
+
+def cubic_quadratic(x):
+    return x**3 * (x**2)
+
+def exp_cubic(x):
+    return np.exp(x**3)
+
+def sine_square(x):
+    return np.sin(x)**2
+
+def logarithmic(x):
+    return np.log(x**2 + 1)
+
+def power(x, p):
+    return x**p
+
+def scaled_cubic(x, alpha=1.0):
+    return alpha * x**3
+
+def sine_offset(x, beta=0.0):
+    return np.sin(x + beta)
+
 
 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,
+    activation_potentiation, # (list): Activation potentiation list for deep PLAN. (optional)
     index,
-    max_w # float or None: Input activation potentiation (optional)
+    max_w,
+    LTD=0
 ) -> tuple:
     """
     Applies feature extraction process to the input data using synaptic potentiation.
@@ -479,10 +590,12 @@ 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_potentiation (float or None): Threshold value for comparison. (optional)
+        # activation_potentiation (list): ac list for deep PLAN. default: [None] ('linear') (optional)
 
     Returns:
         tuple: A tuple (vector) containing the neural layer result and the updated weight matrix.
+        or
+        num: neural network output
     """
 
     Output = np.zeros(len(Input))
@@ -528,13 +641,108 @@ def fex(
         if activation == 'tanh':
             Output += tanh(Input)
 
-        if activation == None:
+        if activation == 'sinakt':
+            Output += sinakt(Input)
+
+        if activation == 'p_squared':
+            Output += p_squared(Input)
+
+        if activation == 'sglu':
+            Output += sglu(Input, alpha=1.0)
+
+        if activation == 'dlrelu':
+            Output += dlrelu(Input)
+
+        if activation == 'exsig':
+            Output += exsig(Input)
+
+        if activation == 'acos':
+            Output += acos(Input, alpha=1.0, beta=0.0)
+
+        if activation == 'gla':
+            Output += gla(Input, alpha=1.0, mu=0.0)
+
+        if activation == 'srelu':
+            Output += srelu(Input)
+
+        if activation == 'qelu':
+            Output += qelu(Input)
+
+        if activation == 'isra':
+            Output += isra(Input)
+
+        if activation == 'waveakt':
+            Output += waveakt(Input) 
+
+        if activation == 'arctan':
+            Output += arctan(Input) 
+        
+        if activation == 'bent_identity':
+            Output += bent_identity(Input)
+
+        if activation == 'sech':
+            Output += sech(Input)
+
+        if activation == 'softsign':
+            Output += softsign(Input)
+
+        if activation == 'pwl':
+            Output += pwl(Input)
+
+        if activation == 'cubic':
+            Output += cubic(Input)
+
+        if activation == 'gaussian':
+            Output += gaussian(Input)
+
+        if activation == 'sine':
+            Output += sine(Input)
+
+        if activation == 'tanh_square':
+            Output += tanh_square(Input)
+
+        if activation == 'mod_sigmoid':
+            Output += mod_sigmoid(Input)
+
+        if activation == None or activation == 'linear':
             Output += Input
 
+        if activation == 'quartic':
+            Output += quartic(Input)
+
+        if activation == 'square_quartic':
+            Output += square_quartic(Input)
+
+        if activation == 'cubic_quadratic':
+            Output += cubic_quadratic(Input)
+
+        if activation == 'exp_cubic':
+            Output += exp_cubic(Input)
+
+        if activation == 'sine_square':
+            Output += sine_square(Input)
+
+        if activation == 'logarithmic':
+            Output += logarithmic(Input)
+
+        if activation == 'scaled_cubic':
+            Output += scaled_cubic(Input, 1.0)
+
+        if activation == 'sine_offset':
+            Output += sine_offset(Input, 1.0)
+
+
     Input = Output
 
+
     if is_training == True:
         
+        for i in range(LTD):        
+
+            depression_vector = np.random.rand(*Input.shape)
+
+            Input -= depression_vector
+
         w[Class, :] = Input
 
         return w
@@ -593,7 +801,7 @@ 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], # (list): Activation potentiation list for deep PLAN. (optional)
     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:
@@ -604,14 +812,15 @@ 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 (float or None): Threshold value for comparison. (optional) Default: None
+        activation_potentiation (list): For deeper PLAN networks, activation function parameters. For more information please run this code: help(plan.activation_functions_list) default: [None]
         bar_status (bool): Loading bar for accuracy (True or None) (optional) Default: True
         show_metrices (bool): (True or None) (optional) Default: None
 
     Returns:
         tuple: A tuple containing the predicted labels and the accuracy of the model.
     """
-    
+    evaluate.__doc__ = infoTestModel
+
     predict_probabilitys = []
     real_classes = []
     predict_classes = []
@@ -838,21 +1047,21 @@ def save_model(model_name,
     Arguments:
     model_name (str): Name of the model.
     model_type (str): Type of the model.(options: PLAN)
-    class_count (int): Number of classes.
     test_acc (float): Test accuracy of the model.
     weights_type (str): Type of weights to save (options: 'txt', 'npy', 'mat').
     WeightFormat (str): Format of the weights (options: 'd', 'f', 'raw').
     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.
+    scaler_params (list[num, num]): standard scaler params list: mean,std. If not used standard scaler then be: None.
     W: Weights of the model.
-    activation_potentiation (float or None): Threshold value for comparison. (optional)
+    activation_potentiation (list): For deeper PLAN networks, activation function parameters. For more information please run this code: help(plan.activation_functions_list) default: [None]
     
     Returns:
     str: Message indicating if the model was saved successfully or encountered an error.
     """
 
-    # Operations to be performed by the function will be written here
-    pass
+    save_model.__doc__ = infosave_model
+
+    class_count = W[0].shape[0]
 
     layers = ['fex']
 
@@ -872,7 +1081,7 @@ def save_model(model_name,
 
     try:
         for w in W:
-            NeuronCount += np.shape(w)[0]
+            NeuronCount += np.shape(w)[0] + np.shape(w)[1]
             SynapseCount += np.shape(w)[0] * np.shape(w)[1]
     except:
 
@@ -898,7 +1107,7 @@ def save_model(model_name,
             'CLASS COUNT': class_count,
             'NEURON COUNT': NeuronCount,
             'SYNAPSE COUNT': SynapseCount,
-            'TEST ACCURACY': test_acc,
+            'TEST ACCURACY': float(test_acc),
             'SAVE DATE': datetime.now(),
             'WEIGHTS TYPE': weights_type,
             'WEIGHTS FORMAT': weights_format,
@@ -999,7 +1208,8 @@ def load_model(model_name,
    Returns:
    lists: W(list[num]), activation_potentiation, DataFrame of the model
     """
-    pass
+
+    load_model.__doc__ = infoload_model
 
     try:
 
@@ -1043,6 +1253,9 @@ def predict_model_ssd(Input, model_name, model_path):
     Returns:
     ndarray: Output from the model.
     """
+
+    predict_model_ram.__doc__ = infopredict_model_ssd
+
     W, df = load_model(model_name, model_path)
     
     activation_potentiation = list(df['ACTIVATION POTENTIATION'])
@@ -1093,12 +1306,15 @@ def predict_model_ram(Input, W, scaler_params=None, activation_potentiation=[Non
     Arguments:
     Input (list or ndarray): Input data for the model (single vector or single matrix).
     W (list of ndarrays): Weights of the model.
-    scaler_params (int, float): standard scaler params list: mean,std. (optional) Default: None.
-    activation_potentiation (float or None): Threshold value for comparison. (optional) Default: None
+    scaler_params (list): standard scaler params list: mean,std. (optional) Default: None.
+    activation_potentiation (list): ac list for deep PLAN. default: [None] ('linear') (optional)
 
     Returns:
     ndarray: Output from the model.
     """
+
+    predict_model_ram.__doc__ = infopredict_model_ram
+
     try:
         if scaler_params != None:
 
@@ -1144,6 +1360,9 @@ def auto_balancer(x_train, y_train):
    Returns:
    tuple: A tuple containing balanced input data and labels.
    """
+    
+    auto_balancer.__doc__ = infoauto_balancer
+
     classes = np.arange(y_train.shape[1])
     class_count = len(classes)
 
@@ -1153,7 +1372,7 @@ def auto_balancer(x_train, y_train):
         classes = [len(ClassIndices[i]) for i in range(class_count)]
 
         if len(set(classes)) == 1:
-            print(Fore.WHITE + "INFO: All training data have already balanced. from: auto_balancer" + Style.RESET_ALL)
+            print(Fore.WHITE + "INFO: Data have already balanced. from: auto_balancer" + Style.RESET_ALL)
             return x_train, y_train
 
         MinCount = min(classes)
@@ -1170,7 +1389,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 Data Succesfully Balanced from: " + str(len(x_train)
+        print(Fore.GREEN + "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)
@@ -1245,6 +1464,9 @@ def standard_scaler(x_train, x_test=None, scaler_params=None):
     tuple
       Standardized training and test datasets
   """
+    
+    standard_scaler.__doc__ = info_standard_scaler
+
     try:
 
         x_train = x_train.tolist()
@@ -1305,7 +1527,7 @@ def standard_scaler(x_train, x_test=None, scaler_params=None):
         return('e')
 
 def encode_one_hot(y_train, y_test):
-    info_one_hot_encode = """
+    """
     Performs one-hot encoding on y_train and y_test data..
 
     Args:
@@ -1679,11 +1901,11 @@ def plot_evaluate(x_test, y_test, y_preds, acc_list, W, activation_potentiation)
 
     plt.show()
 
-def plot_decision_boundary(x, y, activation_potentiation, W):
 
-    feature_indices=[0, 1]
+def plot_decision_boundary(ax, x, y, activation_potentiation, W, artist, draw_is_finished=False):
+    feature_indices = [0, 1]
 
-    h = .02  # mesh grid adımı
+    h = .02
     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),
@@ -1696,26 +1918,39 @@ def plot_decision_boundary(x, y, activation_potentiation, W):
     Z = [None] * len(grid_full)
 
     for i in range(len(grid_full)):
-
         Z[i] = np.argmax(predict_model_ram(grid_full[i], W=W, activation_potentiation=activation_potentiation))
 
     Z = np.array(Z)
     Z = Z.reshape(xx.shape)
+    
+    if draw_is_finished == False:
 
-    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()
+        art1_1 = ax[1, 0].contourf(xx, yy, Z, alpha=0.8)
+        art1_2 = ax[1, 0].scatter(x[:, feature_indices[0]], x[:, feature_indices[1]], c=decode_one_hot(y), edgecolors='k', marker='o', s=20, alpha=0.9)
+        ax[1, 0].set_xlabel(f'Feature {0 + 1}')
+        ax[1, 0].set_ylabel(f'Feature {1 + 1}')
+        ax[1, 0].set_title('Decision Boundary')
+        artist.append([*art1_1.collections, art1_2])
+
+    else:
+
+        for i in range(30):
+
+            art1_1 = ax[1, 0].contourf(xx, yy, Z, alpha=0.8)
+            art1_2 = ax[1, 0].scatter(x[:, feature_indices[0]], x[:, feature_indices[1]], c=decode_one_hot(y), edgecolors='k', marker='o', s=20, alpha=0.9)
+            ax[1, 0].set_xlabel(f'Feature {0 + 1}')
+            ax[1, 0].set_ylabel(f'Feature {1 + 1}')
+            ax[1, 0].set_title('Decision Boundary')
+            artist.append([*art1_1.collections, art1_2])
+
+    return artist
 
 def pca(X, n_components):
     """
-    PCA algoritmasını uygulayan fonksiyon.
     
     Parameters:
-    X (numpy array): Giriş verisi (n_samples, n_features)
-    n_components (int): Saklanacak ana bileşen sayısı
+    X (numpy array): (n_samples, n_features)
+    n_components (int):
     
     Returns:
     X_reduced (numpy array): (n_samples, n_components)
@@ -1729,7 +1964,6 @@ def pca(X, n_components):
     
     sorted_index = np.argsort(eigenvalues)[::-1]
     sorted_eigenvectors = eigenvectors[:, sorted_index]
-    sorted_eigenvalues = eigenvalues[sorted_index]
     
     eigenvectors_subset = sorted_eigenvectors[:, :n_components]
     
@@ -1757,7 +1991,7 @@ def plot_decision_space(x, y, y_preds=None, s=100, color='tab20'):
     norm = plt.Normalize(vmin=0, vmax=num_classes - 1)
     
 
-    scatter = plt.scatter(X_pca[:, 0], X_pca[:, 1], c=y, edgecolor='k', s=50, cmap=cmap, norm=norm)
+    plt.scatter(X_pca[:, 0], X_pca[:, 1], c=y, edgecolor='k', s=50, cmap=cmap, norm=norm)
     
 
     for cls in range(num_classes):
@@ -1780,7 +2014,7 @@ def plot_decision_space(x, y, y_preds=None, s=100, color='tab20'):
             
             plt.fill(hull_points[:, 0], hull_points[:, 1], color=cmap(norm(cls)), alpha=0.3, edgecolor='k', label=f'Class {cls} Hull')
 
-    plt.title("Decision Boundry")
+    plt.title("Decision Space (Data Distribution)")
 
     plt.draw()
     

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

@@ -1,7 +1,7 @@
 Metadata-Version: 2.1
 Name: pyerualjetwork
-Version: 3.1
-Summary: Deep PLAN Integreted. Version 3 document coming
+Version: 3.3.0
+Summary: fit function changes: LTD parameter included for Deep PLAN and professional visualizing for training. in the fit funciton, show_training=True
 Author: Hasan Can Beydili
 Author-email: tchasancan@gmail.com
 Keywords: model evaluation,classifcation,potentiation learning artficial neural networks

pyerualjetwork-3.3.0.dist-info/RECORD

@@ -0,0 +1,6 @@
+plan/__init__.py,sha256=LuFcY0nqAzpjTDWAZn7L7-wipwMpnREqVghPiva0Xjg,548
+plan/plan.py,sha256=2ccjNjnPWMlC1uatIdXpexBpTgdYlBQdd6Hua9cDrb0,67575
+pyerualjetwork-3.3.0.dist-info/METADATA,sha256=oaNPz8e5fpUVSBNugzKQskDpDYW41Fotoy_WVl-H5ao,368
+pyerualjetwork-3.3.0.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
+pyerualjetwork-3.3.0.dist-info/top_level.txt,sha256=G0Al3HuNJ88434XneyDtRKAIUaLCizOFYFYNhd7e2OM,5
+pyerualjetwork-3.3.0.dist-info/RECORD,,

pyerualjetwork-3.1.dist-info/RECORD

@@ -1,6 +0,0 @@
-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,,