pyerualjetwork 4.3.3__tar.gz → 4.3.4__tar.gz

{pyerualjetwork-4.3.3 → pyerualjetwork-4.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyerualjetwork
-Version: 4.3.3
+Version: 4.3.4
 Summary: PyerualJetwork is a machine learning library supported with GPU(CUDA) acceleration written in Python for professionals and researchers including with PLAN algorithm, PLANEAT algorithm (genetic optimization). Also includes data pre-process and memory manegament
 Author: Hasan Can Beydili
 Author-email: tchasancan@gmail.com
@@ -23,31 +23,33 @@ PyPi Page: https://pypi.org/project/pyerualjetwork/
 GitHub Page: https://github.com/HCB06/PyerualJetwork
 
 
-      pip install pyerualjetwork
-      
-      'use if your data small, medium or large:'
+pip install pyerualjetwork
 
-      from pyerualjetwork import plan
-      from pyerualjetwork import planeat
-      from pyerualjetwork import data_operations
-      from pyerualjetwork import model_operations
-      
-      from pyerualjetwork import plan_cuda
-      from pyerualjetwork import planeat_cuda
-      from pyerualjetwork import data_operations_cuda
-      from pyerualjetwork import model_operations_cuda
-
-      'use if your data huge: _afterburner package (afterburner package comes with powerful paralellism, afterburner with cuda modules offers super-fast training but some memory managemant features and visualization features discarded. Specially designed for LLM training and other massive model training)'
-
-      from pyerualjetwork_afterburner import plan
-      from pyerualjetwork_afterburner import planeat
-      from pyerualjetwork_afterburner import data_operations
-      from pyerualjetwork_afterburner import model_operations
-
-      from pyerualjetwork_afterburner import plan_cuda
-      from pyerualjetwork_afterburner import planeat_cuda
-      from pyerualjetwork_afterburner import data_operations_cuda
-      from pyerualjetwork_afterburner import model_operations_cuda
+'use this if your data small or memory management is a problem :'
+
+from pyerualjetwork import plan
+from pyerualjetwork import planeat
+from pyerualjetwork import data_operations
+from pyerualjetwork import model_operations
+
+from pyerualjetwork import plan_cuda
+from pyerualjetwork import planeat_cuda
+from pyerualjetwork import data_operations_cuda
+from pyerualjetwork import model_operations_cuda
+
+'use this if your data large or memory management is not a problem : _afterburner package (afterburner package comes with powerful paralellism,
+afterburner with cuda modules offers super-fast training but some memory managemant features and visualization features discarded.
+Specially designed for LLM training and other massive model training)'
+
+from pyerualjetwork_afterburner import plan
+from pyerualjetwork_afterburner import planeat
+from pyerualjetwork_afterburner import data_operations
+from pyerualjetwork_afterburner import model_operations
+
+from pyerualjetwork_afterburner import plan_cuda
+from pyerualjetwork_afterburner import planeat_cuda
+from pyerualjetwork_afterburner import data_operations_cuda
+from pyerualjetwork_afterburner import model_operations_cuda
 
       Optimized for Visual Studio Code
       

{pyerualjetwork-4.3.3 → pyerualjetwork-4.3.4}/README.md

@@ -14,31 +14,33 @@ PyPi Page: https://pypi.org/project/pyerualjetwork/
 GitHub Page: https://github.com/HCB06/PyerualJetwork
 
 
-      pip install pyerualjetwork
-      
-      'use if your data small, medium or large:'
+pip install pyerualjetwork
 
-      from pyerualjetwork import plan
-      from pyerualjetwork import planeat
-      from pyerualjetwork import data_operations
-      from pyerualjetwork import model_operations
-      
-      from pyerualjetwork import plan_cuda
-      from pyerualjetwork import planeat_cuda
-      from pyerualjetwork import data_operations_cuda
-      from pyerualjetwork import model_operations_cuda
-
-      'use if your data huge: _afterburner package (afterburner package comes with powerful paralellism, afterburner with cuda modules offers super-fast training but some memory managemant features and visualization features discarded. Specially designed for LLM training and other massive model training)'
-
-      from pyerualjetwork_afterburner import plan
-      from pyerualjetwork_afterburner import planeat
-      from pyerualjetwork_afterburner import data_operations
-      from pyerualjetwork_afterburner import model_operations
-
-      from pyerualjetwork_afterburner import plan_cuda
-      from pyerualjetwork_afterburner import planeat_cuda
-      from pyerualjetwork_afterburner import data_operations_cuda
-      from pyerualjetwork_afterburner import model_operations_cuda
+'use this if your data small or memory management is a problem :'
+
+from pyerualjetwork import plan
+from pyerualjetwork import planeat
+from pyerualjetwork import data_operations
+from pyerualjetwork import model_operations
+
+from pyerualjetwork import plan_cuda
+from pyerualjetwork import planeat_cuda
+from pyerualjetwork import data_operations_cuda
+from pyerualjetwork import model_operations_cuda
+
+'use this if your data large or memory management is not a problem : _afterburner package (afterburner package comes with powerful paralellism,
+afterburner with cuda modules offers super-fast training but some memory managemant features and visualization features discarded.
+Specially designed for LLM training and other massive model training)'
+
+from pyerualjetwork_afterburner import plan
+from pyerualjetwork_afterburner import planeat
+from pyerualjetwork_afterburner import data_operations
+from pyerualjetwork_afterburner import model_operations
+
+from pyerualjetwork_afterburner import plan_cuda
+from pyerualjetwork_afterburner import planeat_cuda
+from pyerualjetwork_afterburner import data_operations_cuda
+from pyerualjetwork_afterburner import model_operations_cuda
 
       Optimized for Visual Studio Code
       

{pyerualjetwork-4.3.3 → pyerualjetwork-4.3.4}/pyerualjetwork/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "4.3.3"
+__version__ = "4.3.4"
 __update__ = "* Changes: https://github.com/HCB06/PyerualJetwork/blob/main/CHANGES\n* PyerualJetwork Homepage: https://github.com/HCB06/PyerualJetwork/tree/main\n* PyerualJetwork document: https://github.com/HCB06/PyerualJetwork/blob/main/Welcome_to_PyerualJetwork/PYERUALJETWORK_USER_MANUEL_AND_LEGAL_INFORMATION(EN).pdf\n* YouTube tutorials: https://www.youtube.com/@HasanCanBeydili"
 
 def print_version(__version__):

{pyerualjetwork-4.3.3/pyerualjetwork_afterburner → pyerualjetwork-4.3.4/pyerualjetwork}/activation_functions.py

@@ -217,8 +217,8 @@ def scaled_cubic(x, alpha=1.0):
 
 def sine_offset(x, beta=0.0):
     return np.sin(x + beta)
-
-
+    
+    
 def apply_activation(Input, activation_list):
     """
     Applies activation functions for inputs
@@ -277,15 +277,14 @@ def apply_activation(Input, activation_list):
     }
     
     try:
-        valid_activations = [act for act in activation_list if act in activation_functions]
-        
-        activation_outputs = np.stack([activation_functions[act](origin_input) 
-                                     for act in valid_activations])
 
-        result = Input + np.sum(activation_outputs, axis=0)
-        
-        return result
+        valid_mask = np.array([act in activation_functions for act in activation_list])
+        valid_activations = np.array(activation_list)[valid_mask]
+
+        activation_outputs = np.array([activation_functions[act](origin_input) for act in valid_activations])
+
+        return Input + np.sum(activation_outputs, axis=0)
         
     except Exception as e:
         warnings.warn(f"Error in activation processing: {str(e)}", RuntimeWarning)
-        return Input
+        return Input

{pyerualjetwork-4.3.3 → pyerualjetwork-4.3.4}/pyerualjetwork/plan.py

@@ -249,7 +249,7 @@ def learner(x_train, y_train, optimizer, fit_start, strategy='accuracy', gen=Non
     
     """
 
-    from .planeat import define_genomes
+    from planeat import define_genomes
 
     data = 'Train'
 

{pyerualjetwork-4.3.3 → pyerualjetwork-4.3.4}/pyerualjetwork/plan_cuda.py

@@ -48,7 +48,6 @@ bar_format_normal = loading_bars()[0]
 bar_format_learner = loading_bars()[1]
 
 # BUILD -----
-
 def fit(
     x_train,
     y_train,
@@ -265,7 +264,7 @@ def learner(x_train, y_train, optimizer, fit_start, strategy='accuracy', gen=Non
     
     """
 
-    from .planeat_cuda import define_genomes
+    from planeat_cuda import define_genomes
 
     data = 'Train'
 
@@ -278,13 +277,13 @@ def learner(x_train, y_train, optimizer, fit_start, strategy='accuracy', gen=Non
         x_train = transfer_to_gpu(x_train, dtype=dtype)
         y_train = transfer_to_gpu(y_train, dtype=y_train.dtype)
 
-        from .data_operations_cuda import batcher
+        from data_operations_cuda import batcher
 
     elif memory == 'cpu':
         x_train = transfer_to_cpu(x_train, dtype=dtype)
         y_train = transfer_to_cpu(y_train, dtype=y_train.dtype)
 
-        from .data_operations import batcher
+        from data_operations import batcher
 
     else:
         raise ValueError("memory parameter must be 'cpu' or 'gpu'.")
@@ -336,13 +335,12 @@ def learner(x_train, y_train, optimizer, fit_start, strategy='accuracy', gen=Non
         for j in range(activation_potentiation_len):
 
             x_train_batch, y_train_batch = batcher(x_train, y_train, batch_size=batch_size)
- 
             if fit_start is True and i == 0:
                 act_pop.append(activation_potentiation[j])
-                W = fit(x_train_batch, y_train_batch, activation_potentiation=act_pop[-1], train_bar=False, auto_normalization=auto_normalization, dtype=dtype)
+                W = fit(x_train_batch, y_train_batch, activation_potentiation=act_pop[-1], auto_normalization=auto_normalization, train_bar=False, dtype=dtype, memory=memory)
                 weight_pop.append(W)
             
-            model = evaluate(x_train_batch, y_train_batch, W=weight_pop[j], loading_bar_status=False, activation_potentiation=act_pop[j], dtype=dtype, memory=memory)
+            model = evaluate(x_train_batch, y_train_batch, weight_pop[j], act_pop[j], loading_bar_status=False, dtype=dtype, memory=memory)
             acc = model[get_acc()]
             
             if strategy == 'accuracy': target_pop.append(acc)
@@ -562,7 +560,6 @@ def feed_forward(
         neural_layer = cp.dot(w, Input)
 
         return neural_layer
-   
 
 def evaluate(
     x_test,

{pyerualjetwork-4.3.3 → pyerualjetwork-4.3.4}/pyerualjetwork/planeat.py

@@ -20,7 +20,7 @@ import math
 from .plan import feed_forward
 from .data_operations import normalization
 from .ui import loading_bars, initialize_loading_bar
-from .activation_functions import apply_activation, all_activations
+from. activation_functions import apply_activation, all_activations
 
 def define_genomes(input_shape, output_shape, population_size, dtype=np.float32):
    """

{pyerualjetwork-4.3.3/pyerualjetwork_afterburner → pyerualjetwork-4.3.4/pyerualjetwork}/visualizations.py

@@ -617,7 +617,7 @@ def update_neuron_history(LTPW, ax1, row, col, class_count, artist5, fig1, acc=F
 
 def initialize_visualization_for_fit(val, show_training, neurons_history, x_train, y_train):
     """Initializes the visualization setup based on the parameters."""
-    from .data_operations import find_closest_factors
+    from data_operations import find_closest_factors
     visualization_objects = {}
 
     if show_training or neurons_history:
@@ -704,7 +704,7 @@ def show():
 
 def initialize_visualization_for_learner(show_history, neurons_history, neural_web_history, x_train, y_train):
     """Initialize all visualization components"""
-    from .data_operations import find_closest_factors
+    from data_operations import find_closest_factors
     viz_objects = {}
     
     if show_history:

{pyerualjetwork-4.3.3 → pyerualjetwork-4.3.4}/pyerualjetwork.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyerualjetwork
-Version: 4.3.3
+Version: 4.3.4
 Summary: PyerualJetwork is a machine learning library supported with GPU(CUDA) acceleration written in Python for professionals and researchers including with PLAN algorithm, PLANEAT algorithm (genetic optimization). Also includes data pre-process and memory manegament
 Author: Hasan Can Beydili
 Author-email: tchasancan@gmail.com
@@ -23,31 +23,33 @@ PyPi Page: https://pypi.org/project/pyerualjetwork/
 GitHub Page: https://github.com/HCB06/PyerualJetwork
 
 
-      pip install pyerualjetwork
-      
-      'use if your data small, medium or large:'
+pip install pyerualjetwork
 
-      from pyerualjetwork import plan
-      from pyerualjetwork import planeat
-      from pyerualjetwork import data_operations
-      from pyerualjetwork import model_operations
-      
-      from pyerualjetwork import plan_cuda
-      from pyerualjetwork import planeat_cuda
-      from pyerualjetwork import data_operations_cuda
-      from pyerualjetwork import model_operations_cuda
-
-      'use if your data huge: _afterburner package (afterburner package comes with powerful paralellism, afterburner with cuda modules offers super-fast training but some memory managemant features and visualization features discarded. Specially designed for LLM training and other massive model training)'
-
-      from pyerualjetwork_afterburner import plan
-      from pyerualjetwork_afterburner import planeat
-      from pyerualjetwork_afterburner import data_operations
-      from pyerualjetwork_afterburner import model_operations
-
-      from pyerualjetwork_afterburner import plan_cuda
-      from pyerualjetwork_afterburner import planeat_cuda
-      from pyerualjetwork_afterburner import data_operations_cuda
-      from pyerualjetwork_afterburner import model_operations_cuda
+'use this if your data small or memory management is a problem :'
+
+from pyerualjetwork import plan
+from pyerualjetwork import planeat
+from pyerualjetwork import data_operations
+from pyerualjetwork import model_operations
+
+from pyerualjetwork import plan_cuda
+from pyerualjetwork import planeat_cuda
+from pyerualjetwork import data_operations_cuda
+from pyerualjetwork import model_operations_cuda
+
+'use this if your data large or memory management is not a problem : _afterburner package (afterburner package comes with powerful paralellism,
+afterburner with cuda modules offers super-fast training but some memory managemant features and visualization features discarded.
+Specially designed for LLM training and other massive model training)'
+
+from pyerualjetwork_afterburner import plan
+from pyerualjetwork_afterburner import planeat
+from pyerualjetwork_afterburner import data_operations
+from pyerualjetwork_afterburner import model_operations
+
+from pyerualjetwork_afterburner import plan_cuda
+from pyerualjetwork_afterburner import planeat_cuda
+from pyerualjetwork_afterburner import data_operations_cuda
+from pyerualjetwork_afterburner import model_operations_cuda
 
       Optimized for Visual Studio Code
       

{pyerualjetwork-4.3.3 → pyerualjetwork-4.3.4}/pyerualjetwork.egg-info/SOURCES.txt

@@ -1,4 +1,5 @@
 README.md
+setup.cfg
 setup.py
 pyerualjetwork/__init__.py
 pyerualjetwork/activation_functions.py

{pyerualjetwork-4.3.3 → pyerualjetwork-4.3.4}/pyerualjetwork_afterburner/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "4.3.2.2b0-afterburner"
+__version__ = "4.3.4-afterburner"
 __update__ = "* Changes: https://github.com/HCB06/PyerualJetwork/blob/main/CHANGES\n* PyerualJetwork Homepage: https://github.com/HCB06/PyerualJetwork/tree/main\n* PyerualJetwork document: https://github.com/HCB06/PyerualJetwork/blob/main/Welcome_to_PyerualJetwork/PYERUALJETWORK_USER_MANUEL_AND_LEGAL_INFORMATION(EN).pdf\n* YouTube tutorials: https://www.youtube.com/@HasanCanBeydili"
 
 def print_version(__version__):

pyerualjetwork-4.3.4/pyerualjetwork_afterburner/activation_functions.py

@@ -0,0 +1,290 @@
+import numpy as np
+from scipy.special import expit, softmax
+import warnings
+
+
+# ACTIVATION FUNCTIONS -----
+
+def all_activations():
+    
+    activations_list = ['linear', 'sigmoid', 'relu', 'tanh', 'circular', 'spiral', 'swish', 'sin_plus', 'mod_circular', 'tanh_circular', 'leaky_relu', 'softplus', 'elu', 'gelu', 'selu', 'sinakt', 'p_squared', 'sglu', 'dlrelu', 'exsig', 'acos', 'gla', 'srelu', 'qelu', 'isra', 'waveakt', 'arctan', 'bent_identity', 'sech', 'softsign', 'pwl', 'cubic', 'gaussian', 'sine', 'tanh_square', 'mod_sigmoid', 'quartic', 'square_quartic', 'cubic_quadratic', 'exp_cubic', 'sine_square', 'logarithmic', 'scaled_cubic', 'sine_offset']
+    
+    return activations_list
+
+def spiral_activation(x):
+
+    r = np.sqrt(np.sum(x**2))
+    
+    theta = np.arctan2(x[1:], x[:-1])
+
+    spiral_x = r * np.cos(theta + r)
+    spiral_y = r * np.sin(theta + r)
+    
+
+    spiral_output = np.concatenate(([spiral_x[0]], spiral_y))
+    
+    return spiral_output
+
+
+def Softmax(
+    x  # num: Input data to be transformed using softmax function.
+):
+    """
+    Applies the softmax function to the input data.
+
+    Args:
+        (num): Input data to be transformed using softmax function.
+
+    Returns:
+       (num): Transformed data after applying softmax function.
+    """
+
+    return softmax(x)
+
+
+def Sigmoid(
+    x  # num: Input data to be transformed using sigmoid function.
+):
+    """
+    Applies the sigmoid function to the input data.
+
+    Args:
+        (num): Input data to be transformed using sigmoid function.
+
+    Returns:
+        (num): Transformed data after applying sigmoid function.
+    """
+    return expit(x)
+
+
+def Relu(
+    x  # num: Input data to be transformed using ReLU function.
+):
+    """
+    Applies the Rectified Linear Unit (ReLU) function to the input data.
+
+    Args:
+        (num): Input data to be transformed using ReLU function.
+
+    Returns:
+        (num): Transformed data after applying ReLU function.
+    """
+
+    return np.maximum(0, x)
+
+
+def tanh(x):
+    return np.tanh(x)
+
+def swish(x):
+    return x * (1 / (1 + np.exp(-x)))
+
+def sin_plus(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 sinakt(x):
+    return np.sin(x) + np.cos(x)
+
+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 circular_activation(x, scale=2.0, frequency=1.0, shift=0.0):    
+    
+    n_features = x.shape[0]
+    
+    circular_output = np.zeros_like(x)
+    
+    for i in range(n_features):
+        
+        r = np.sqrt(np.sum(x**2))
+        theta = 2 * np.pi * (i / n_features) + shift
+        
+        circular_x = r * np.cos(theta + frequency * r) * scale
+        circular_y = r * np.sin(theta + frequency * r) * scale
+        
+        if i % 2 == 0:
+            circular_output[i] = circular_x
+        else:
+            circular_output[i] = circular_y
+    
+    return circular_output
+
+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 scaled_cubic(x, alpha=1.0):
+    return alpha * x**3
+
+def sine_offset(x, beta=0.0):
+    return np.sin(x + beta)
+
+
+def apply_activation(Input, activation_list):
+    """
+    Applies activation functions for inputs
+    
+    Args:
+        Input (numpy.ndarray):
+        activation_list (list):
+    """
+    origin_input = np.copy(Input)
+    
+    activation_functions = {
+        'sigmoid': Sigmoid,
+        'swish': swish,
+        'mod_circular': modular_circular_activation,
+        'tanh_circular': tanh_circular_activation,
+        'leaky_relu': leaky_relu,
+        'relu': Relu,
+        'softplus': softplus,
+        'elu': elu,
+        'gelu': gelu,
+        'selu': selu,
+        'tanh': tanh,
+        'sinakt': sinakt,
+        'p_squared': p_squared,
+        'sglu': lambda x: sglu(x, alpha=1.0),
+        'dlrelu': dlrelu,
+        'exsig': exsig,
+        'sin_plus': sin_plus,
+        'acos': lambda x: acos(x, alpha=1.0, beta=0.0),
+        'gla': lambda x: gla(x, alpha=1.0, mu=0.0),
+        'srelu': srelu,
+        'qelu': qelu,
+        'isra': isra,
+        'waveakt': waveakt,
+        'arctan': arctan,
+        'bent_identity': bent_identity,
+        'sech': sech,
+        'softsign': softsign,
+        'pwl': pwl,
+        'cubic': cubic,
+        'gaussian': gaussian,
+        'sine': sine,
+        'tanh_square': tanh_square,
+        'mod_sigmoid': mod_sigmoid,
+        'linear': lambda x: x,
+        'quartic': quartic,
+        'square_quartic': square_quartic,
+        'cubic_quadratic': cubic_quadratic,
+        'exp_cubic': exp_cubic,
+        'sine_square': sine_square,
+        'logarithmic': logarithmic,
+        'scaled_cubic': lambda x: scaled_cubic(x, 1.0),
+        'sine_offset': lambda x: sine_offset(x, 1.0),
+        'spiral': spiral_activation,
+        'circular': circular_activation
+    }
+    
+    try:
+
+        valid_mask = np.array([act in activation_functions for act in activation_list])
+        valid_activations = np.array(activation_list)[valid_mask]
+
+        activation_outputs = np.array([activation_functions[act](origin_input) for act in valid_activations])
+
+        return Input + np.sum(activation_outputs, axis=0)
+        
+    except Exception as e:
+        warnings.warn(f"Error in activation processing: {str(e)}", RuntimeWarning)
+        return Input

{pyerualjetwork-4.3.3 → pyerualjetwork-4.3.4}/pyerualjetwork_afterburner/activation_functions_cuda.py

@@ -276,14 +276,13 @@ def apply_activation(Input, activation_list):
     }
     
     try:
-        valid_activations = [act for act in activation_list if act in activation_functions]
         
-        activation_outputs = cp.stack([activation_functions[act](origin_input) 
-                                     for act in valid_activations])
+        valid_mask = cp.array([act in activation_functions for act in activation_list])
+        valid_activations = cp.array(activation_list)[valid_mask]
 
-        result = Input + cp.sum(activation_outputs, axis=0)
-        
-        return result
+        activation_outputs = cp.array([activation_functions[act](origin_input) for act in valid_activations])
+
+        return Input + cp.sum(activation_outputs, axis=0)
         
     except Exception as e:
         warnings.warn(f"Error in activation processing: {str(e)}", RuntimeWarning)

{pyerualjetwork-4.3.3 → pyerualjetwork-4.3.4}/pyerualjetwork_afterburner/data_operations_cuda.py

@@ -17,7 +17,7 @@ def encode_one_hot(y_train, y_test=None, summary=False):
         tuple: One-hot encoded y_train and (if given) y_test.
     """
 
-    from .memory_operations import optimize_labels, transfer_to_cpu
+    from memory_operations import optimize_labels, transfer_to_cpu
     
     y_train = optimize_labels(y_train, one_hot_encoded=False, cuda=True)
     y_test = optimize_labels(y_test, one_hot_encoded=False, cuda=True)
@@ -401,7 +401,7 @@ def standard_scaler(x_train=None, x_test=None, scaler_params=None, dtype=cp.floa
 
         return scaled_data  # sample data scaled
     
-    
+
 def normalization(
     Input,  # num: Input data to be normalized.
     dtype=cp.float32

{pyerualjetwork-4.3.3 → pyerualjetwork-4.3.4}/pyerualjetwork_afterburner/plan_cuda.py

@@ -23,7 +23,7 @@ from .data_operations_cuda import normalization
 from .loss_functions_cuda import binary_crossentropy, categorical_crossentropy
 from .activation_functions_cuda import apply_activation, all_activations
 from .metrics_cuda import metrics
-from .model_operations_cuda import get_acc, get_preds, get_preds_softmax
+from model_operations_cuda import get_acc, get_preds, get_preds_softmax
 from .memory_operations import transfer_to_gpu, transfer_to_cpu, optimize_labels
 from .visualizations_cuda import (
     draw_neural_web,
@@ -151,11 +151,12 @@ def learner(x_train, y_train, optimizer, fit_start, strategy='accuracy', gen=Non
     
     """
 
-    from .planeat_cuda import define_genomes
+    from planeat_cuda import define_genomes
 
     data = 'Train'
 
-    activation_potentiation = all_activations()
+    activation_potentiation = all_activations() 
+
     activation_potentiation_len = len(activation_potentiation)
 
     y_train = optimize_labels(y_train, cuda=True)
@@ -164,13 +165,13 @@ def learner(x_train, y_train, optimizer, fit_start, strategy='accuracy', gen=Non
         x_train = transfer_to_gpu(x_train, dtype=dtype)
         y_train = transfer_to_gpu(y_train, dtype=y_train.dtype)
 
-        from .data_operations_cuda import batcher
+        from data_operations_cuda import batcher
 
     elif memory == 'cpu':
         x_train = transfer_to_cpu(x_train, dtype=dtype)
         y_train = transfer_to_cpu(y_train, dtype=y_train.dtype)
 
-        from .data_operations import batcher
+        from data_operations import batcher
 
     else:
         raise ValueError("memory parameter must be 'cpu' or 'gpu'.")
@@ -228,7 +229,7 @@ def learner(x_train, y_train, optimizer, fit_start, strategy='accuracy', gen=Non
                 W = fit(x_train_batch, y_train_batch, activation_potentiation=act_pop[-1], dtype=dtype)
                 weight_pop.append(W)
             
-            model = evaluate(x_train_batch, y_train_batch, W=weight_pop[j])
+            model = evaluate(x_train_batch, y_train_batch, W=weight_pop[j], activation_potentiation=act_pop[j])
             acc = model[get_acc()]
             
             if strategy == 'accuracy': target_pop.append(acc)

{pyerualjetwork-4.3.3 → pyerualjetwork-4.3.4}/pyerualjetwork_afterburner/planeat_cuda.py

@@ -721,9 +721,8 @@ def mutation(weight,
          max_threshold = len(activations)
 
          new_threshold = threshold
-
-         except_this = ['spiral', 'circular']
-         all_acts = [item for item in all_activations() if item not in except_this] # SPIRAL AND CIRCULAR ACTIVATION DISCARDED
+         
+         all_acts = all_activations()
          
          activation_add_prob = 1 - activation_add_prob
          activation_delete_prob = 1 - activation_delete_prob

{pyerualjetwork-4.3.3 → pyerualjetwork-4.3.4}/setup.py

@@ -6,7 +6,7 @@ with open("README.md", "r", encoding="utf-8") as fh:
 # Setting Up
 setup(
     name="pyerualjetwork",
-    version="4.3.3",
+    version="4.3.4",
     author="Hasan Can Beydili",
     author_email="tchasancan@gmail.com",
     description=(

pyerualjetwork-4.3.3/pyerualjetwork/activation_functions.py

@@ -1,343 +0,0 @@
-import numpy as np
-from scipy.special import expit, softmax
-import warnings
-
-
-# ACTIVATION FUNCTIONS -----
-
-def all_activations():
-    
-    activations_list = ['linear', 'sigmoid', 'relu', 'tanh', 'circular', 'spiral', 'swish', 'sin_plus', 'mod_circular', 'tanh_circular', 'leaky_relu', 'softplus', 'elu', 'gelu', 'selu', 'sinakt', 'p_squared', 'sglu', 'dlrelu', 'exsig', 'acos', 'gla', 'srelu', 'qelu', 'isra', 'waveakt', 'arctan', 'bent_identity', 'sech', 'softsign', 'pwl', 'cubic', 'gaussian', 'sine', 'tanh_square', 'mod_sigmoid', 'quartic', 'square_quartic', 'cubic_quadratic', 'exp_cubic', 'sine_square', 'logarithmic', 'scaled_cubic', 'sine_offset']
-    
-    return activations_list
-
-def spiral_activation(x):
-
-    r = np.sqrt(np.sum(x**2))
-    
-    theta = np.arctan2(x[1:], x[:-1])
-
-    spiral_x = r * np.cos(theta + r)
-    spiral_y = r * np.sin(theta + r)
-    
-
-    spiral_output = np.concatenate(([spiral_x[0]], spiral_y))
-    
-    return spiral_output
-
-
-def Softmax(
-    x  # num: Input data to be transformed using softmax function.
-):
-    """
-    Applies the softmax function to the input data.
-
-    Args:
-        (num): Input data to be transformed using softmax function.
-
-    Returns:
-       (num): Transformed data after applying softmax function.
-    """
-
-    return softmax(x)
-
-
-def Sigmoid(
-    x  # num: Input data to be transformed using sigmoid function.
-):
-    """
-    Applies the sigmoid function to the input data.
-
-    Args:
-        (num): Input data to be transformed using sigmoid function.
-
-    Returns:
-        (num): Transformed data after applying sigmoid function.
-    """
-    return expit(x)
-
-
-def Relu(
-    x  # num: Input data to be transformed using ReLU function.
-):
-    """
-    Applies the Rectified Linear Unit (ReLU) function to the input data.
-
-    Args:
-        (num): Input data to be transformed using ReLU function.
-
-    Returns:
-        (num): Transformed data after applying ReLU function.
-    """
-
-    return np.maximum(0, x)
-
-
-def tanh(x):
-    return np.tanh(x)
-
-def swish(x):
-    return x * (1 / (1 + np.exp(-x)))
-
-def sin_plus(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 sinakt(x):
-    return np.sin(x) + np.cos(x)
-
-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 circular_activation(x, scale=2.0, frequency=1.0, shift=0.0):    
-    
-    n_features = x.shape[0]
-    
-    circular_output = np.zeros_like(x)
-    
-    for i in range(n_features):
-        
-        r = np.sqrt(np.sum(x**2))
-        theta = 2 * np.pi * (i / n_features) + shift
-        
-        circular_x = r * np.cos(theta + frequency * r) * scale
-        circular_y = r * np.sin(theta + frequency * r) * scale
-        
-        if i % 2 == 0:
-            circular_output[i] = circular_x
-        else:
-            circular_output[i] = circular_y
-    
-    return circular_output
-
-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 scaled_cubic(x, alpha=1.0):
-    return alpha * x**3
-
-def sine_offset(x, beta=0.0):
-    return np.sin(x + beta)
-
-
-def safe_add(current_sum, new_value):
-        try:
-            return current_sum + new_value
-        except OverflowError:
-            return np.array(current_sum) + np.array(new_value)
-    
-    
-def apply_activation(Input, activation_list):
-    """
-        Applies a sequence of activation functions to the input.
-        
-        Args:
-            Input (numpy.ndarray): The input to apply activations to.
-            activation_list (list): A list of activation function names to apply.
-        
-        Returns:
-            numpy.ndarray: The input after all activations have been applied.
-    """
-    
-    origin_input = np.copy(Input)
-
-    for i in range(len(activation_list)):
-        try:
-            if activation_list[i] == 'sigmoid':
-                Input = safe_add(Input, Sigmoid(origin_input))
-            elif activation_list[i] == 'swish':
-                Input = safe_add(Input, swish(origin_input))
-            elif activation_list[i] == 'mod_circular':
-                Input = safe_add(Input, modular_circular_activation(origin_input))
-            elif activation_list[i] == 'tanh_circular':
-                Input = safe_add(Input, tanh_circular_activation(origin_input))
-            elif activation_list[i] == 'leaky_relu':
-                Input = safe_add(Input, leaky_relu(origin_input))
-            elif activation_list[i] == 'relu':
-                Input = safe_add(Input, Relu(origin_input))
-            elif activation_list[i] == 'softplus':
-                Input = safe_add(Input, softplus(origin_input))
-            elif activation_list[i] == 'elu':
-                Input = safe_add(Input, elu(origin_input))
-            elif activation_list[i] == 'gelu':
-                Input = safe_add(Input, gelu(origin_input))
-            elif activation_list[i] == 'selu':
-                Input = safe_add(Input, selu(origin_input))
-            elif activation_list[i] == 'tanh':
-                Input = safe_add(Input, tanh(origin_input))
-            elif activation_list[i] == 'sinakt':
-                Input = safe_add(Input, sinakt(origin_input))
-            elif activation_list[i] == 'p_squared':
-                Input = safe_add(Input, p_squared(origin_input))
-            elif activation_list[i] == 'sglu':
-                Input = safe_add(Input, sglu(origin_input, alpha=1.0))
-            elif activation_list[i] == 'dlrelu':
-                Input = safe_add(Input, dlrelu(origin_input))
-            elif activation_list[i] == 'exsig':
-                Input = safe_add(Input, exsig(origin_input))
-            elif activation_list[i] == 'sin_plus':
-                Input = safe_add(Input, sin_plus(origin_input))
-            elif activation_list[i] == 'acos':
-                Input = safe_add(Input, acos(origin_input, alpha=1.0, beta=0.0))
-            elif activation_list[i] == 'gla':
-                Input = safe_add(Input, gla(origin_input, alpha=1.0, mu=0.0))
-            elif activation_list[i] == 'srelu':
-                Input = safe_add(Input, srelu(origin_input))
-            elif activation_list[i] == 'qelu':
-                Input = safe_add(Input, qelu(origin_input))
-            elif activation_list[i] == 'isra':
-                Input = safe_add(Input, isra(origin_input))
-            elif activation_list[i] == 'waveakt':
-                Input = safe_add(Input, waveakt(origin_input))
-            elif activation_list[i] == 'arctan':
-                Input = safe_add(Input, arctan(origin_input))
-            elif activation_list[i] == 'bent_identity':
-                Input = safe_add(Input, bent_identity(origin_input))
-            elif activation_list[i] == 'sech':
-                Input = safe_add(Input, sech(origin_input))
-            elif activation_list[i] == 'softsign':
-                Input = safe_add(Input, softsign(origin_input))
-            elif activation_list[i] == 'pwl':
-                Input = safe_add(Input, pwl(origin_input))
-            elif activation_list[i] == 'cubic':
-                Input = safe_add(Input, cubic(origin_input))
-            elif activation_list[i] == 'gaussian':
-                Input = safe_add(Input, gaussian(origin_input))
-            elif activation_list[i] == 'sine':
-                Input = safe_add(Input, sine(origin_input))
-            elif activation_list[i] == 'tanh_square':
-                Input = safe_add(Input, tanh_square(origin_input))
-            elif activation_list[i] == 'mod_sigmoid':
-                Input = safe_add(Input, mod_sigmoid(origin_input))
-            elif activation_list[i] == 'linear':
-                Input = safe_add(Input, origin_input)
-            elif activation_list[i] == 'quartic':
-                Input = safe_add(Input, quartic(origin_input))
-            elif activation_list[i] == 'square_quartic':
-                Input = safe_add(Input, square_quartic(origin_input))
-            elif activation_list[i] == 'cubic_quadratic':
-                Input = safe_add(Input, cubic_quadratic(origin_input))
-            elif activation_list[i] == 'exp_cubic':
-                Input = safe_add(Input, exp_cubic(origin_input))
-            elif activation_list[i] == 'sine_square':
-                Input = safe_add(Input, sine_square(origin_input))
-            elif activation_list[i] == 'logarithmic':
-                Input = safe_add(Input, logarithmic(origin_input))
-            elif activation_list[i] == 'scaled_cubic':
-                Input = safe_add(Input, scaled_cubic(origin_input, 1.0))
-            elif activation_list[i] == 'sine_offset':
-                Input = safe_add(Input, sine_offset(origin_input, 1.0))
-            elif activation_list[i] == 'spiral':
-                Input = safe_add(Input, spiral_activation(origin_input))
-            elif activation_list[i] == 'circular':
-                Input = safe_add(Input, circular_activation(origin_input))
-
-        
-        except Exception as e:
-            warnings.warn(f"Error in activation {activation_list[i]}: {str(e)}", RuntimeWarning)
-            if not isinstance(Input, np.ndarray):
-                Input = np.array(Input)
-            if not isinstance(origin_input, np.ndarray):
-                origin_input = np.array(origin_input)
-            continue
- 
-    return Input