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

plan/plan.py

@@ -27,7 +27,7 @@ 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], # activation_potentiation (list): ac list for deep PLAN. default: [None] ('linear') (optional)
     x_val= None,
     y_val= None,
     show_training = None,
@@ -42,7 +42,7 @@ def fit(
         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)
+        val_count (None, int): After how many examples learned will an accuracy test be performed? Default: 10 (%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
@@ -80,16 +80,14 @@ def fit(
 
             if val_count == None:
 
-                val_count = 0.01
+                val_count = 10
 
             v_iter = 0
 
         if val == 'final':
 
-            val_count = 0.99
-        
-        val_count = int(len(x_train) * val_count)
-        val_count_copy = val_count
+            val_count = 100
+    
         val_bar = tqdm(total=1, desc="Validating Accuracy", ncols=120)
         val_list = [] * val_count
 
@@ -181,7 +179,7 @@ def fit(
 
             try:
 
-                if round(progress) % 10 == 1:
+                if round(progress) % val_count == 1:
 
 
                     validation_model = evaluate(x_val, y_val, LTPW ,bar_status=False, activation_potentiation=activation_potentiation, show_metrices=None)
@@ -288,6 +286,8 @@ def fit(
         
         plot_decision_boundary(x_val, y_val, activation_potentiation, LTPW)
 
+        plt.show()
+
         val_list.append(val_acc)
         
         val_bar.update(val_acc)
@@ -384,37 +384,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 +430,144 @@ 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 
 ) -> tuple:
     """
     Applies feature extraction process to the input data using synaptic potentiation.
@@ -479,10 +577,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,11 +628,100 @@ 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:
         
         w[Class, :] = Input
@@ -593,7 +782,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,7 +793,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 (float or None): Threshold value for comparison. (optional) Default: None
+        activation_potentiation (list): ac list for deep PLAN. default: [None] ('linear') (optional)
         bar_status (bool): Loading bar for accuracy (True or None) (optional) Default: True
         show_metrices (bool): (True or None) (optional) Default: None
 
@@ -845,7 +1034,7 @@ def save_model(model_name,
     model_path (str): Path where the model will be saved. For example: C:/Users/beydili/Desktop/denemePLAN/
     scaler_params (int, float): standard scaler params list: mean,std. If not used standard scaler then be: None.
     W: Weights of the model.
-    activation_potentiation (float or None): Threshold value for comparison. (optional)
+    activation_potentiation (list): ac list for deep PLAN. default: [None] ('linear') (optional)
     
     Returns:
     str: Message indicating if the model was saved successfully or encountered an error.
@@ -898,7 +1087,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,
@@ -1093,8 +1282,8 @@ 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.
@@ -1780,7 +1969,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.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyerualjetwork
-Version: 3.1
+Version: 3.2.0
 Summary: Deep PLAN Integreted. Version 3 document coming
 Author: Hasan Can Beydili
 Author-email: tchasancan@gmail.com

pyerualjetwork-3.2.0.dist-info/RECORD

@@ -0,0 +1,6 @@
+plan/__init__.py,sha256=LuFcY0nqAzpjTDWAZn7L7-wipwMpnREqVghPiva0Xjg,548
+plan/plan.py,sha256=ASQIHk-atzX48iH7RfyqSRo4rO2YyDKqLudo3l_9d78,65066
+pyerualjetwork-3.2.0.dist-info/METADATA,sha256=HhmOci9_X7tjMcPKFw4ZMKOj3-BM70RQNNg569CJBtU,274
+pyerualjetwork-3.2.0.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
+pyerualjetwork-3.2.0.dist-info/top_level.txt,sha256=G0Al3HuNJ88434XneyDtRKAIUaLCizOFYFYNhd7e2OM,5
+pyerualjetwork-3.2.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,,