pyerualjetwork 4.3.0__py3-none-any.whl → 4.3.0.2__py3-none-any.whl

{pyerualjetwork-4.3.0.dist-info → pyerualjetwork-4.3.0.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyerualjetwork
-Version: 4.3.0
+Version: 4.3.0.2
 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
@@ -24,7 +24,7 @@ GitHub Page: https://github.com/HCB06/PyerualJetwork
 
 
       pip install pyerualjetwork
-      pip install pyerualjetwork==x.x.x-jetstorm
+      pip install pyerualjetwork==x.x.x.x-jetstorm (last x shows it is a jetstorm package)
       
       from pyerualjetwork import plan
       from pyerualjetwork import planeat

pyerualjetwork-4.3.0.2.dist-info/RECORD

@@ -0,0 +1,24 @@
+pyerualjetwork-jetstorm/__init__.py,sha256=XYaTEM5PIQBeTV_cF75PSwKCW35tclp7ZywN65JjEm8,650
+pyerualjetwork-jetstorm/activation_functions.py,sha256=2bv7o4EPEFr8cSKq7KI04HhMUyxgBpe8soGvN98Mazg,7740
+pyerualjetwork-jetstorm/activation_functions_cuda.py,sha256=Ua606lsj9LQahfLi6oZMkSyzyPT7ySrvC6qfACNCbL8,7781
+pyerualjetwork-jetstorm/data_operations.py,sha256=Flteouu6rfSo2uHMqBHuzO02dXmbNa-I5qWmUpGTZ5Y,14760
+pyerualjetwork-jetstorm/data_operations_cuda.py,sha256=UpoJoFhIwTU4xg9dVuLAxLAT4CkRaGsxvtJG9j1xrNo,17629
+pyerualjetwork-jetstorm/help.py,sha256=nQ_YbYA2RtuafhuvkreNpX0WWL1I_nzlelwCtvei0_Y,775
+pyerualjetwork-jetstorm/loss_functions.py,sha256=6PyBI232SQRGuFnG3LDGvnv_PUdWzT2_2mUODJiejGI,618
+pyerualjetwork-jetstorm/loss_functions_cuda.py,sha256=C93IZJcrOpT6HMK9x1O4AHJWXYTkN5WZiqdssPbvAPk,617
+pyerualjetwork-jetstorm/memory_operations.py,sha256=I7QiZ--xSyRkFF0wcckPwZV7K9emEvyx5aJ3DiRHZFI,13468
+pyerualjetwork-jetstorm/metrics.py,sha256=q7MkhnZDRbCjFBDDfUgrl8lBYnUT_1ro1LxeBq105pI,6077
+pyerualjetwork-jetstorm/metrics_cuda.py,sha256=73h9GC7XwmnFCVzFEEiPQfF8CwHIz2wsCbxpZrJtYgw,5061
+pyerualjetwork-jetstorm/model_operations.py,sha256=MCSCNYiiICRVZITobtS3ZIWmH5Q9gjyELuH32sAdgg4,12649
+pyerualjetwork-jetstorm/model_operations_cuda.py,sha256=NT01BK5nrDYE7H1x3KnSI8gmx0QTGGB0mP_LqEb1uuU,13157
+pyerualjetwork-jetstorm/plan.py,sha256=Gxv8ii4brTYMzzFZBP-X6kkwc6w6vtTPiMmqVOAqoq8,21972
+pyerualjetwork-jetstorm/plan_cuda.py,sha256=usyL-rWfczko8MQ-tmgMyt7UrKoH7IG3FX3edBiq-vc,22716
+pyerualjetwork-jetstorm/planeat.py,sha256=Lq5R0aMS4UIdZdbUKsKDv5g0WLwYryomR3IQYb8vAa4,37573
+pyerualjetwork-jetstorm/planeat_cuda.py,sha256=dZdKrrhdnoTjcF8Uv23Y4UvlOfizazNyx9v6QsdpIoo,37621
+pyerualjetwork-jetstorm/ui.py,sha256=wu2BhU1k-w3Kcho5Jtq4SEKe68ftaUeRGneUOSCVDjU,575
+pyerualjetwork-jetstorm/visualizations.py,sha256=1SKMZaJ80OD2qHUyMxW1IOv8zwmxzMPxclfbeq1Xr4g,28772
+pyerualjetwork-jetstorm/visualizations_cuda.py,sha256=KbMhfsLlxujy_i3QrwCf734Q-k6d7Zn_7CEbm3gzK9w,29186
+pyerualjetwork-4.3.0.2.dist-info/METADATA,sha256=zB9fu5uTLIt_AkOVe0iBDRL5jfrDhETVj-YpH07W9v0,7546
+pyerualjetwork-4.3.0.2.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
+pyerualjetwork-4.3.0.2.dist-info/top_level.txt,sha256=LZ-gnOoO1Riaytpmz1-hjJJ-jNG8zzq1iwNVTJwa3Ek,24
+pyerualjetwork-4.3.0.2.dist-info/RECORD,,

pyerualjetwork-4.3.0.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+pyerualjetwork-jetstorm

{pyerualjetwork → pyerualjetwork-jetstorm}/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "4.3.0"
+__version__ = "4.3.0.2-jetstorm"
 __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-jetstorm/activation_functions.py

@@ -0,0 +1,291 @@
+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_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
+        
+    except Exception as e:
+        warnings.warn(f"Error in activation processing: {str(e)}", RuntimeWarning)
+        return Input

pyerualjetwork-jetstorm/activation_functions_cuda.py

@@ -0,0 +1,290 @@
+import cupy as cp
+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 = cp.sqrt(cp.sum(x**2))
+    
+    theta = cp.arctan2(x[1:], x[:-1])
+
+    spiral_x = r * cp.cos(theta + r)
+    spiral_y = r * cp.sin(theta + r)
+
+
+    spiral_output = cp.concatenate([cp.array([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 cp.array(softmax(x.get()))
+
+
+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 cp.maximum(0, x)
+
+
+def tanh(x):
+    return cp.tanh(x)
+
+def swish(x):
+    return x * (1 / (1 + cp.exp(-x)))
+
+def sin_plus(x):
+    return (cp.sin(x) + 1) / 2
+
+def modular_circular_activation(x, period=2*cp.pi):
+    return cp.mod(x, period) / period
+
+def tanh_circular_activation(x):
+    return (cp.tanh(x) + 1) / 2
+
+def leaky_relu(x, alpha=0.01):
+    return cp.where(x > 0, x, alpha * x)
+
+def softplus(x):
+    return cp.log(1 + cp.exp(x))
+
+def elu(x, alpha=1.0):
+    return cp.where(x > 0, x, alpha * (cp.exp(x) - 1))
+
+def gelu(x):
+    return 0.5 * x * (1 + cp.tanh(cp.sqrt(2 / cp.pi) * (x + 0.044715 * cp.power(x, 3))))
+
+def selu(x, lambda_=1.0507, alpha=1.6733):
+    return lambda_ * cp.where(x > 0, x, alpha * (cp.exp(x) - 1))
+
+def sinakt(x):
+    return cp.sin(x) + cp.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 cp.array(softmax(alpha * x.get())) * x
+
+# 4. Double Leaky ReLU (DLReLU)
+def dlrelu(x):
+    return cp.maximum(0.01 * x, x) + cp.minimum(0.01 * x, 0.1 * x)
+
+# 5. Exponential Sigmoid (ExSig)
+def exsig(x):
+    return 1 / (1 + cp.exp(-x**2))
+
+# 6. Adaptive Cosine Activation (ACos)
+def acos(x, alpha=1.0, beta=0.0):
+    return cp.cos(alpha * x + beta)
+
+# 7. Gaussian-like Activation (GLA)
+def gla(x, alpha=1.0, mu=0.0):
+    return cp.exp(-alpha * (x - mu)**2)
+
+# 8. Swish ReLU (SReLU)
+def srelu(x):
+    return x * (1 / (1 + cp.exp(-x))) + cp.maximum(0, x)
+
+# 9. Quadratic Exponential Linear Unit (QELU)
+def qelu(x):
+    return x**2 * cp.exp(x) - 1
+
+# 10. Inverse Square Root Activation (ISRA)
+def isra(x):
+    return x / cp.sqrt(cp.abs(x) + 1)
+
+def waveakt(x, alpha=1.0, beta=2.0, gamma=3.0):
+    return cp.sin(alpha * x) * cp.cos(beta * x) * cp.sin(gamma * x)
+
+def arctan(x):
+    return cp.arctan(x)
+
+def bent_identity(x):
+    return (cp.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 = cp.zeros_like(x)
+    
+    for i in range(n_features):
+        
+        r = cp.sqrt(cp.sum(x**2))
+        theta = 2 * cp.pi * (i / n_features) + shift
+        
+        circular_x = r * cp.cos(theta + frequency * r) * scale
+        circular_y = r * cp.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 / (cp.exp(x) + cp.exp(-x))
+
+def softsign(x):
+    return x / (1 + cp.abs(x))
+
+def pwl(x, alpha=0.5, beta=1.5):
+    return cp.where(x <= 0, alpha * x, beta * x)
+
+def cubic(x):
+    return x**3
+
+def gaussian(x, alpha=1.0, mu=0.0):
+    return cp.exp(-alpha * (x - mu)**2)
+                
+def sine(x, alpha=1.0):
+    return cp.sin(alpha * x)
+
+def tanh_square(x):
+    return cp.tanh(x)**2
+
+def mod_sigmoid(x, alpha=1.0, beta=0.0):
+    return 1 / (1 + cp.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 cp.exp(x**3)
+
+def sine_square(x):
+    return cp.sin(x)**2
+
+def logarithmic(x):
+    return cp.log(x**2 + 1)
+
+def scaled_cubic(x, alpha=1.0):
+    return alpha * x**3
+
+def sine_offset(x, beta=0.0):
+    return cp.sin(x + beta)
+
+    
+def apply_activation(Input, activation_list):
+    """
+    Applies activation functions for inputs
+    
+    Args:
+        Input (cupy.ndarray):
+        activation_list (list):
+    """
+    origin_input = cp.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_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])
+
+        result = Input + cp.sum(activation_outputs, axis=0)
+        
+        return result
+        
+    except Exception as e:
+        warnings.warn(f"Error in activation processing: {str(e)}", RuntimeWarning)
+        return Input

{pyerualjetwork → pyerualjetwork-jetstorm}/model_operations.py

@@ -258,7 +258,7 @@ def predict_model_ssd(Input, model_name, model_path='', dtype=np.float32):
     ndarray: Output from the model.
     """
     
-    from .plan import feed_forward
+    from .activation_functions import apply_activation
     from .data_operations import standard_scaler
     
     model = load_model(model_name, model_path)
@@ -269,12 +269,12 @@ def predict_model_ssd(Input, model_name, model_path='', dtype=np.float32):
 
     Input = standard_scaler(None, Input, scaler_params, dtype=dtype)
 
-    neural_layer = Input
-    neural_layer = np.array(neural_layer, copy=False)
-    neural_layer = neural_layer.ravel()
+    Input = np.array(Input, dtype=dtype, copy=False)
+    Input = Input.ravel()
 
     try:
-        neural_layer = feed_forward(neural_layer, np.copy(W.astype(dtype, copy=False)), is_training=False, Class='?', activation_potentiation=activation_potentiation)
+        Input = apply_activation(Input, activation_potentiation)
+        neural_layer = Input @ W.T
         return neural_layer
     except:
         print(Fore.RED + "ERROR: Unexpected Output or wrong model parameters from: predict_model_ssd." + Style.RESET_ALL)
@@ -304,7 +304,7 @@ def reverse_predict_model_ssd(output, model_name, model_path='', dtype=np.float3
     W = model[get_weights()]
 
     try:
-        Input = np.dot(output.astype(dtype, copy=False), np.copy(W.astype(dtype, copy=False)))
+        Input = W.T @ output
         return Input
     except:
         print(Fore.RED + "ERROR: Unexpected Output or wrong model parameters from: reverse_predict_model_ssd." + Style.RESET_ALL)
@@ -334,18 +334,18 @@ def predict_model_ram(Input, W, scaler_params=None, activation_potentiation=['li
     ndarray: Output from the model.
     """
 
-    from data_operations import standard_scaler
-    from plan import feed_forward
+    from .data_operations import standard_scaler
+    from .activation_functions import apply_activation
 
     Input = standard_scaler(None, Input, scaler_params, dtype=dtype)
     
+    Input = np.array(Input, dtype=dtype, copy=False)
+    Input = Input.ravel()
+
     try:
         
-        neural_layer = Input
-        neural_layer = np.array(neural_layer, copy=False)
-        neural_layer = neural_layer.ravel()
-
-        neural_layer = feed_forward(neural_layer, np.copy(W.astype(dtype, copy=False)), is_training=False, Class='?', activation_potentiation=activation_potentiation)
+        Input = apply_activation(Input, activation_potentiation)
+        neural_layer = Input @ W.T
 
         return neural_layer
     
@@ -371,7 +371,7 @@ def reverse_predict_model_ram(output, W, dtype=np.float32):
     """
 
     try:
-        Input = np.dot(output.astype(dtype, copy=False), np.copy(W.astype(dtype, copy=False)))
+        Input = W.T @ output
         return Input
     
     except: