pyerualjetwork 4.0.5__py3-none-any.whl → 4.0.7__py3-none-any.whl

pyerualjetwork/__init__.py

@@ -47,7 +47,7 @@ for package_name in package_names:
 
 print(f"PyerualJetwork is ready to use with {err} errors")
 
-__version__ = "4.0.5"
+__version__ = "4.0.7"
 __update__ = "* Note: CUDA modules need cupy. Enter this command in your terminal: 'pip install cupy-cuda12x' or your cuda version.\n* Changes: https://github.com/HCB06/PyerualJetwork/blob/main/CHANGES\n* PyerualJetwork document: https://github.com/HCB06/Anaplan/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/activation_functions.py

@@ -1,5 +1,7 @@
 import numpy as np
 from scipy.special import expit, softmax
+import warnings
+
 
 # ACTIVATION FUNCTIONS -----
 
@@ -216,152 +218,127 @@ 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 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)):
-
-      if activation_list[i] == 'sigmoid':
-         Input += Sigmoid(origin_input)
-
-      elif activation_list[i] == 'swish':
-         Input += swish(origin_input)
-
-      elif activation_list[i] == 'mod_circular':
-         Input += modular_circular_activation(origin_input)
-
-      elif activation_list[i] == 'tanh_circular':
-         Input += tanh_circular_activation(origin_input)
-
-      elif activation_list[i] == 'leaky_relu':
-         Input += leaky_relu(origin_input)
-
-      elif activation_list[i] == 'relu':
-         Input += Relu(origin_input)
-
-      elif activation_list[i] == 'softplus':
-         Input += softplus(origin_input)
-
-      elif activation_list[i] == 'elu':
-         Input += elu(origin_input)
-
-      elif activation_list[i] == 'gelu':
-         Input += gelu(origin_input)
-
-      elif activation_list[i] == 'selu':
-         Input += selu(origin_input)
-
-      elif activation_list[i] == 'tanh':
-         Input += tanh(origin_input)
-
-      elif activation_list[i] == 'sinakt':
-         Input += sinakt(origin_input)
-
-      elif activation_list[i] == 'p_squared':
-         Input += p_squared(origin_input)
-
-      elif activation_list[i] == 'sglu':
-         Input += sglu(origin_input, alpha=1.0)
-
-      elif activation_list[i] == 'dlrelu':
-         Input += dlrelu(origin_input)
-
-      elif activation_list[i] == 'exsig':
-         Input += exsig(origin_input)
-
-      elif activation_list[i] == 'sin_plus':
-         Input += sin_plus(origin_input)
-
-      elif activation_list[i] == 'acos':
-         Input += acos(origin_input, alpha=1.0, beta=0.0)
-
-      elif activation_list[i] == 'gla':
-         Input += gla(origin_input, alpha=1.0, mu=0.0)
-
-      elif activation_list[i] == 'srelu':
-         Input += srelu(origin_input)
-
-      elif activation_list[i] == 'qelu':
-         Input += qelu(origin_input)
 
-      elif activation_list[i] == 'isra':
-         Input += isra(origin_input)
 
-      elif activation_list[i] == 'waveakt':
-         Input += waveakt(origin_input)
-
-      elif activation_list[i] == 'arctan':
-         Input += arctan(origin_input)
-
-      elif activation_list[i] == 'bent_identity':
-         Input += bent_identity(origin_input)
-
-      elif activation_list[i] == 'sech':
-         Input += sech(origin_input)
-
-      elif activation_list[i] == 'softsign':
-         Input += softsign(origin_input)
-
-      elif activation_list[i] == 'pwl':
-         Input += pwl(origin_input)
-
-      elif activation_list[i] == 'cubic':
-         Input += cubic(origin_input)
-
-      elif activation_list[i] == 'gaussian':
-         Input += gaussian(origin_input)
-
-      elif activation_list[i] == 'sine':
-         Input += sine(origin_input)
-
-      elif activation_list[i] == 'tanh_square':
-         Input += tanh_square(origin_input)
-
-      elif activation_list[i] == 'mod_sigmoid':
-         Input += mod_sigmoid(origin_input)
-
-      elif activation_list[i] == 'linear':
-         Input += origin_input
-
-      elif activation_list[i] == 'quartic':
-         Input += quartic(origin_input)
-
-      elif activation_list[i] == 'square_quartic':
-         Input += square_quartic(origin_input)
-
-      elif activation_list[i] == 'cubic_quadratic':
-         Input += cubic_quadratic(origin_input)
-
-      elif activation_list[i] == 'exp_cubic':
-         Input += exp_cubic(origin_input)
-
-      elif activation_list[i] == 'sine_square':
-         Input += sine_square(origin_input)
-
-      elif activation_list[i] == 'logarithmic':
-         Input += logarithmic(origin_input)
-
-      elif activation_list[i] == 'scaled_cubic':
-         Input += scaled_cubic(origin_input, 1.0)
-
-      elif activation_list[i] == 'sine_offset':
-         Input += sine_offset(origin_input, 1.0)
-
-      elif activation_list[i] == 'spiral':
-         Input += spiral_activation(origin_input)
+def safe_aggregate(current_sum, new_value):
+        try:
+            return current_sum + new_value
+        except OverflowError:
+            return np.array(current_sum) + np.array(new_value)
+    
 
-      elif activation_list[i] == 'circular':
-         Input += circular_activation(origin_input)
+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_aggregate(Input, Sigmoid(origin_input))
+            elif activation_list[i] == 'swish':
+                Input = safe_aggregate(Input, swish(origin_input))
+            elif activation_list[i] == 'mod_circular':
+                Input = safe_aggregate(Input, modular_circular_activation(origin_input))
+            elif activation_list[i] == 'tanh_circular':
+                Input = safe_aggregate(Input, tanh_circular_activation(origin_input))
+            elif activation_list[i] == 'leaky_relu':
+                Input = safe_aggregate(Input, leaky_relu(origin_input))
+            elif activation_list[i] == 'relu':
+                Input = safe_aggregate(Input, Relu(origin_input))
+            elif activation_list[i] == 'softplus':
+                Input = safe_aggregate(Input, softplus(origin_input))
+            elif activation_list[i] == 'elu':
+                Input = safe_aggregate(Input, elu(origin_input))
+            elif activation_list[i] == 'gelu':
+                Input = safe_aggregate(Input, gelu(origin_input))
+            elif activation_list[i] == 'selu':
+                Input = safe_aggregate(Input, selu(origin_input))
+            elif activation_list[i] == 'tanh':
+                Input = safe_aggregate(Input, tanh(origin_input))
+            elif activation_list[i] == 'sinakt':
+                Input = safe_aggregate(Input, sinakt(origin_input))
+            elif activation_list[i] == 'p_squared':
+                Input = safe_aggregate(Input, p_squared(origin_input))
+            elif activation_list[i] == 'sglu':
+                Input = safe_aggregate(Input, sglu(origin_input, alpha=1.0))
+            elif activation_list[i] == 'dlrelu':
+                Input = safe_aggregate(Input, dlrelu(origin_input))
+            elif activation_list[i] == 'exsig':
+                Input = safe_aggregate(Input, exsig(origin_input))
+            elif activation_list[i] == 'sin_plus':
+                Input = safe_aggregate(Input, sin_plus(origin_input))
+            elif activation_list[i] == 'acos':
+                Input = safe_aggregate(Input, acos(origin_input, alpha=1.0, beta=0.0))
+            elif activation_list[i] == 'gla':
+                Input = safe_aggregate(Input, gla(origin_input, alpha=1.0, mu=0.0))
+            elif activation_list[i] == 'srelu':
+                Input = safe_aggregate(Input, srelu(origin_input))
+            elif activation_list[i] == 'qelu':
+                Input = safe_aggregate(Input, qelu(origin_input))
+            elif activation_list[i] == 'isra':
+                Input = safe_aggregate(Input, isra(origin_input))
+            elif activation_list[i] == 'waveakt':
+                Input = safe_aggregate(Input, waveakt(origin_input))
+            elif activation_list[i] == 'arctan':
+                Input = safe_aggregate(Input, arctan(origin_input))
+            elif activation_list[i] == 'bent_identity':
+                Input = safe_aggregate(Input, bent_identity(origin_input))
+            elif activation_list[i] == 'sech':
+                Input = safe_aggregate(Input, sech(origin_input))
+            elif activation_list[i] == 'softsign':
+                Input = safe_aggregate(Input, softsign(origin_input))
+            elif activation_list[i] == 'pwl':
+                Input = safe_aggregate(Input, pwl(origin_input))
+            elif activation_list[i] == 'cubic':
+                Input = safe_aggregate(Input, cubic(origin_input))
+            elif activation_list[i] == 'gaussian':
+                Input = safe_aggregate(Input, gaussian(origin_input))
+            elif activation_list[i] == 'sine':
+                Input = safe_aggregate(Input, sine(origin_input))
+            elif activation_list[i] == 'tanh_square':
+                Input = safe_aggregate(Input, tanh_square(origin_input))
+            elif activation_list[i] == 'mod_sigmoid':
+                Input = safe_aggregate(Input, mod_sigmoid(origin_input))
+            elif activation_list[i] == 'linear':
+                Input = safe_aggregate(Input, origin_input)
+            elif activation_list[i] == 'quartic':
+                Input = safe_aggregate(Input, quartic(origin_input))
+            elif activation_list[i] == 'square_quartic':
+                Input = safe_aggregate(Input, square_quartic(origin_input))
+            elif activation_list[i] == 'cubic_quadratic':
+                Input = safe_aggregate(Input, cubic_quadratic(origin_input))
+            elif activation_list[i] == 'exp_cubic':
+                Input = safe_aggregate(Input, exp_cubic(origin_input))
+            elif activation_list[i] == 'sine_square':
+                Input = safe_aggregate(Input, sine_square(origin_input))
+            elif activation_list[i] == 'logarithmic':
+                Input = safe_aggregate(Input, logarithmic(origin_input))
+            elif activation_list[i] == 'scaled_cubic':
+                Input = safe_aggregate(Input, scaled_cubic(origin_input, 1.0))
+            elif activation_list[i] == 'sine_offset':
+                Input = safe_aggregate(Input, sine_offset(origin_input, 1.0))
+            elif activation_list[i] == 'spiral':
+                Input = safe_aggregate(Input, spiral_activation(origin_input))
+            elif activation_list[i] == 'circular':
+                Input = safe_aggregate(Input, circular_activation(origin_input))
 
-   return 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

pyerualjetwork/activation_functions_cuda.py

@@ -1,4 +1,6 @@
 import cupy as cp
+from scipy.special import expit, softmax
+import warnings
 
 # ACTIVATION FUNCTIONS ----
 
@@ -9,355 +11,332 @@ def all_activations():
     return activations_list
 
 def spiral_activation(x):
-    if x.ndim == 1:
-        r = cp.sqrt(cp.sum(x**2)) 
-        theta = cp.arctan2(x[1], x[0]) 
 
-        spiral_x = r * cp.cos(theta + r) 
-        spiral_y = r * cp.sin(theta + r) 
+    r = cp.sqrt(cp.sum(x**2))
+    
+    theta = cp.arctan2(x[1:], x[:-1])
 
-        spiral_output = cp.array([spiral_x, spiral_y])
-    else:
-        r = cp.sqrt(cp.sum(x**2, axis=-1))
-        theta = cp.arctan2(x[:, 1], x[:, 0]) 
+    spiral_x = r * cp.cos(theta + r)
+    spiral_y = r * cp.sin(theta + r)
+    
 
-        spiral_x = r * cp.cos(theta + r) 
-        spiral_y = r * cp.sin(theta + r) 
+    spiral_output = cp.concatenate(([spiral_x[0]], spiral_y))
+    
+    return spiral_output
 
-        spiral_output = cp.stack((spiral_x, spiral_y), axis=-1)
 
-    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.
+    """
 
-def Softmax(x):
-    """Optimized Softmax function"""
-    return cp.array(cp.exp(x - cp.max(x, axis=-1, keepdims=True)) / cp.sum(cp.exp(x - cp.max(x, axis=-1, keepdims=True)), axis=-1, keepdims=True))
+    return cp.array(softmax(x.get()))
 
-def Sigmoid(x):
-    """Optimized Sigmoid function"""
-    return 1 / (1 + cp.exp(-x))
 
-def Relu(x):
-    """Optimized ReLU function"""
+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):
-    """Optimized Tanh function"""
     return cp.tanh(x)
 
 def swish(x):
-    """Optimized Swish function"""
-    return x * Sigmoid(x)
+    return x * (1 / (1 + cp.exp(-x)))
 
 def sin_plus(x):
-    """Optimized SinPlus function"""
     return (cp.sin(x) + 1) / 2
 
 def modular_circular_activation(x, period=2*cp.pi):
-    """Optimized Modular Circular Activation function"""
     return cp.mod(x, period) / period
 
 def tanh_circular_activation(x):
-    """Optimized Tanh Circular Activation function"""
     return (cp.tanh(x) + 1) / 2
 
 def leaky_relu(x, alpha=0.01):
-    """Optimized Leaky ReLU function"""
     return cp.where(x > 0, x, alpha * x)
 
 def softplus(x):
-    """Optimized Softplus function"""
-    return cp.log1p(cp.exp(x))
+    return cp.log(1 + cp.exp(x))
 
 def elu(x, alpha=1.0):
-    """Optimized ELU function"""
     return cp.where(x > 0, x, alpha * (cp.exp(x) - 1))
 
 def gelu(x):
-    """Optimized GELU function"""
     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):
-    """Optimized SELU function"""
     return lambda_ * cp.where(x > 0, x, alpha * (cp.exp(x) - 1))
 
 def sinakt(x):
-    """Optimized SinAkt function"""
     return cp.sin(x) + cp.cos(x)
 
 def p_squared(x, alpha=1.0, beta=0.0):
-    """Optimized P-squared function"""
     return alpha * x**2 + beta * x
 
 def sglu(x, alpha=1.0):
-    """Optimized SGU function"""
-    return cp.array(cp.exp(alpha * x)) * x
+    return cp.array(softmax(alpha * x.get())) * x
 
+# 4. Double Leaky ReLU (DLReLU)
 def dlrelu(x):
-    """Optimized Double Leaky ReLU (DLReLU) function"""
     return cp.maximum(0.01 * x, x) + cp.minimum(0.01 * x, 0.1 * x)
 
+# 5. Exponential Sigmoid (ExSig)
 def exsig(x):
-    """Optimized Exponential Sigmoid (ExSig) function"""
     return 1 / (1 + cp.exp(-x**2))
 
+# 6. Adaptive Cosine Activation (ACos)
 def acos(x, alpha=1.0, beta=0.0):
-    """Optimized Adaptive Cosine Activation (ACos) function"""
     return cp.cos(alpha * x + beta)
 
+# 7. Gaussian-like Activation (GLA)
 def gla(x, alpha=1.0, mu=0.0):
-    """Optimized Gaussian-like Activation (GLA) function"""
     return cp.exp(-alpha * (x - mu)**2)
 
+# 8. Swish ReLU (SReLU)
 def srelu(x):
-    """Optimized Swish ReLU (SReLU) function"""
     return x * (1 / (1 + cp.exp(-x))) + cp.maximum(0, x)
 
+# 9. Quadratic Exponential Linear Unit (QELU)
 def qelu(x):
-    """Optimized Quadratic Exponential Linear Unit (QELU) function"""
     return x**2 * cp.exp(x) - 1
 
+# 10. Inverse Square Root Activation (ISRA)
 def isra(x):
-    """Optimized Inverse Square Root Activation (ISRA) function"""
     return x / cp.sqrt(cp.abs(x) + 1)
 
 def waveakt(x, alpha=1.0, beta=2.0, gamma=3.0):
-    """Optimized Wave Activation function"""
     return cp.sin(alpha * x) * cp.cos(beta * x) * cp.sin(gamma * x)
 
 def arctan(x):
-    """Optimized Arctan function"""
     return cp.arctan(x)
 
 def bent_identity(x):
-    """Optimized Bent Identity function"""
     return (cp.sqrt(x**2 + 1) - 1) / 2 + x
 
-def circular_activation(x, scale=2.0, frequency=1.0, shift=0.0):
-    """Optimized Circular Activation function"""
+def circular_activation(x, scale=2.0, frequency=1.0, shift=0.0):    
+    
     n_features = x.shape[0]
+    
     circular_output = cp.zeros_like(x)
     
-    r = cp.sqrt(cp.sum(x**2))
     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
         
-        circular_output[i] = circular_x if i % 2 == 0 else circular_y
+        if i % 2 == 0:
+            circular_output[i] = circular_x
+        else:
+            circular_output[i] = circular_y
     
     return circular_output
 
 def sech(x):
-    """Optimized Sech function"""
     return 2 / (cp.exp(x) + cp.exp(-x))
 
 def softsign(x):
-    """Optimized Softsign function"""
     return x / (1 + cp.abs(x))
 
 def pwl(x, alpha=0.5, beta=1.5):
-    """Optimized Piecewise Linear function (PWL)"""
     return cp.where(x <= 0, alpha * x, beta * x)
 
 def cubic(x):
-    """Optimized Cubic function"""
     return x**3
 
 def gaussian(x, alpha=1.0, mu=0.0):
-    """Optimized Gaussian function"""
     return cp.exp(-alpha * (x - mu)**2)
-
+                
 def sine(x, alpha=1.0):
-    """Optimized Sine function"""
     return cp.sin(alpha * x)
 
 def tanh_square(x):
-    """Optimized Tanh Square function"""
     return cp.tanh(x)**2
 
 def mod_sigmoid(x, alpha=1.0, beta=0.0):
-    """Optimized Modified Sigmoid function"""
     return 1 / (1 + cp.exp(-alpha * x + beta))
 
 def quartic(x):
-    """Optimized Quartic function"""
     return x**4
 
 def square_quartic(x):
-    """Optimized Square Quartic function"""
     return (x**2)**2
 
 def cubic_quadratic(x):
-    """Optimized Cubic Quadratic function"""
     return x**3 * (x**2)
 
 def exp_cubic(x):
-    """Optimized Exponential Cubic function"""
     return cp.exp(x**3)
 
 def sine_square(x):
-    """Optimized Sine Square function"""
     return cp.sin(x)**2
 
 def logarithmic(x):
-    """Optimized Logarithmic function"""
     return cp.log(x**2 + 1)
 
 def scaled_cubic(x, alpha=1.0):
-    """Optimized Scaled Cubic function"""
     return alpha * x**3
 
 def sine_offset(x, beta=0.0):
-    """Optimized Sine Offset function"""
     return cp.sin(x + beta)
 
-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 = cp.copy(Input)
-
-   for i in range(len(activation_list)):
-
-      if activation_list[i] == 'sigmoid':
-         Input += Sigmoid(origin_input)
-
-      elif activation_list[i] == 'swish':
-         Input += swish(origin_input)
-
-      elif activation_list[i] == 'mod_circular':
-         Input += modular_circular_activation(origin_input)
-
-      elif activation_list[i] == 'tanh_circular':
-         Input += tanh_circular_activation(origin_input)
-
-      elif activation_list[i] == 'leaky_relu':
-         Input += leaky_relu(origin_input)
-
-      elif activation_list[i] == 'relu':
-         Input += Relu(origin_input)
-
-      elif activation_list[i] == 'softplus':
-         Input += softplus(origin_input)
 
-      elif activation_list[i] == 'elu':
-         Input += elu(origin_input)
 
-      elif activation_list[i] == 'gelu':
-         Input += gelu(origin_input)
-
-      elif activation_list[i] == 'selu':
-         Input += selu(origin_input)
-
-      elif activation_list[i] == 'tanh':
-         Input += tanh(origin_input)
-
-      elif activation_list[i] == 'sinakt':
-         Input += sinakt(origin_input)
-
-      elif activation_list[i] == 'p_squared':
-         Input += p_squared(origin_input)
-
-      elif activation_list[i] == 'sglu':
-         Input += sglu(origin_input, alpha=1.0)
-
-      elif activation_list[i] == 'dlrelu':
-         Input += dlrelu(origin_input)
-
-      elif activation_list[i] == 'exsig':
-         Input += exsig(origin_input)
-
-      elif activation_list[i] == 'sin_plus':
-         Input += sin_plus(origin_input)
-
-      elif activation_list[i] == 'acos':
-         Input += acos(origin_input, alpha=1.0, beta=0.0)
-
-      elif activation_list[i] == 'gla':
-         Input += gla(origin_input, alpha=1.0, mu=0.0)
-
-      elif activation_list[i] == 'srelu':
-         Input += srelu(origin_input)
-
-      elif activation_list[i] == 'qelu':
-         Input += qelu(origin_input)
-
-      elif activation_list[i] == 'isra':
-         Input += isra(origin_input)
-
-      elif activation_list[i] == 'waveakt':
-         Input += waveakt(origin_input)
-
-      elif activation_list[i] == 'arctan':
-         Input += arctan(origin_input)
-
-      elif activation_list[i] == 'bent_identity':
-         Input += bent_identity(origin_input)
-
-      elif activation_list[i] == 'sech':
-         Input += sech(origin_input)
-
-      elif activation_list[i] == 'softsign':
-         Input += softsign(origin_input)
-
-      elif activation_list[i] == 'pwl':
-         Input += pwl(origin_input)
-
-      elif activation_list[i] == 'cubic':
-         Input += cubic(origin_input)
-
-      elif activation_list[i] == 'gaussian':
-         Input += gaussian(origin_input)
-
-      elif activation_list[i] == 'sine':
-         Input += sine(origin_input)
-
-      elif activation_list[i] == 'tanh_square':
-         Input += tanh_square(origin_input)
-
-      elif activation_list[i] == 'mod_sigmoid':
-         Input += mod_sigmoid(origin_input)
-
-      elif activation_list[i] == 'linear':
-         Input += origin_input
-
-      elif activation_list[i] == 'quartic':
-         Input += quartic(origin_input)
-
-      elif activation_list[i] == 'square_quartic':
-         Input += square_quartic(origin_input)
-
-      elif activation_list[i] == 'cubic_quadratic':
-         Input += cubic_quadratic(origin_input)
-
-      elif activation_list[i] == 'exp_cubic':
-         Input += exp_cubic(origin_input)
-
-      elif activation_list[i] == 'sine_square':
-         Input += sine_square(origin_input)
-
-      elif activation_list[i] == 'logarithmic':
-         Input += logarithmic(origin_input)
-
-      elif activation_list[i] == 'scaled_cubic':
-         Input += scaled_cubic(origin_input, 1.0)
-
-      elif activation_list[i] == 'sine_offset':
-         Input += sine_offset(origin_input, 1.0)
-
-      elif activation_list[i] == 'spiral':
-         Input += spiral_activation(origin_input)
-
-      elif activation_list[i] == 'circular':
-         Input += circular_activation(origin_input)
+def safe_aggregate(current_sum, new_value):
+        try:
+            return current_sum + new_value
+        except OverflowError:
+            return cp.array(current_sum) + cp.array(new_value)
+    
 
-   return Input
+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 = cp.copy(Input)
+
+    for i in range(len(activation_list)):
+        try:
+            if activation_list[i] == 'sigmoid':
+                Input = safe_aggregate(Input, Sigmoid(origin_input))
+            elif activation_list[i] == 'swish':
+                Input = safe_aggregate(Input, swish(origin_input))
+            elif activation_list[i] == 'mod_circular':
+                Input = safe_aggregate(Input, modular_circular_activation(origin_input))
+            elif activation_list[i] == 'tanh_circular':
+                Input = safe_aggregate(Input, tanh_circular_activation(origin_input))
+            elif activation_list[i] == 'leaky_relu':
+                Input = safe_aggregate(Input, leaky_relu(origin_input))
+            elif activation_list[i] == 'relu':
+                Input = safe_aggregate(Input, Relu(origin_input))
+            elif activation_list[i] == 'softplus':
+                Input = safe_aggregate(Input, softplus(origin_input))
+            elif activation_list[i] == 'elu':
+                Input = safe_aggregate(Input, elu(origin_input))
+            elif activation_list[i] == 'gelu':
+                Input = safe_aggregate(Input, gelu(origin_input))
+            elif activation_list[i] == 'selu':
+                Input = safe_aggregate(Input, selu(origin_input))
+            elif activation_list[i] == 'tanh':
+                Input = safe_aggregate(Input, tanh(origin_input))
+            elif activation_list[i] == 'sinakt':
+                Input = safe_aggregate(Input, sinakt(origin_input))
+            elif activation_list[i] == 'p_squared':
+                Input = safe_aggregate(Input, p_squared(origin_input))
+            elif activation_list[i] == 'sglu':
+                Input = safe_aggregate(Input, sglu(origin_input, alpha=1.0))
+            elif activation_list[i] == 'dlrelu':
+                Input = safe_aggregate(Input, dlrelu(origin_input))
+            elif activation_list[i] == 'exsig':
+                Input = safe_aggregate(Input, exsig(origin_input))
+            elif activation_list[i] == 'sin_plus':
+                Input = safe_aggregate(Input, sin_plus(origin_input))
+            elif activation_list[i] == 'acos':
+                Input = safe_aggregate(Input, acos(origin_input, alpha=1.0, beta=0.0))
+            elif activation_list[i] == 'gla':
+                Input = safe_aggregate(Input, gla(origin_input, alpha=1.0, mu=0.0))
+            elif activation_list[i] == 'srelu':
+                Input = safe_aggregate(Input, srelu(origin_input))
+            elif activation_list[i] == 'qelu':
+                Input = safe_aggregate(Input, qelu(origin_input))
+            elif activation_list[i] == 'isra':
+                Input = safe_aggregate(Input, isra(origin_input))
+            elif activation_list[i] == 'waveakt':
+                Input = safe_aggregate(Input, waveakt(origin_input))
+            elif activation_list[i] == 'arctan':
+                Input = safe_aggregate(Input, arctan(origin_input))
+            elif activation_list[i] == 'bent_identity':
+                Input = safe_aggregate(Input, bent_identity(origin_input))
+            elif activation_list[i] == 'sech':
+                Input = safe_aggregate(Input, sech(origin_input))
+            elif activation_list[i] == 'softsign':
+                Input = safe_aggregate(Input, softsign(origin_input))
+            elif activation_list[i] == 'pwl':
+                Input = safe_aggregate(Input, pwl(origin_input))
+            elif activation_list[i] == 'cubic':
+                Input = safe_aggregate(Input, cubic(origin_input))
+            elif activation_list[i] == 'gaussian':
+                Input = safe_aggregate(Input, gaussian(origin_input))
+            elif activation_list[i] == 'sine':
+                Input = safe_aggregate(Input, sine(origin_input))
+            elif activation_list[i] == 'tanh_square':
+                Input = safe_aggregate(Input, tanh_square(origin_input))
+            elif activation_list[i] == 'mod_sigmoid':
+                Input = safe_aggregate(Input, mod_sigmoid(origin_input))
+            elif activation_list[i] == 'linear':
+                Input = safe_aggregate(Input, origin_input)
+            elif activation_list[i] == 'quartic':
+                Input = safe_aggregate(Input, quartic(origin_input))
+            elif activation_list[i] == 'square_quartic':
+                Input = safe_aggregate(Input, square_quartic(origin_input))
+            elif activation_list[i] == 'cubic_quadratic':
+                Input = safe_aggregate(Input, cubic_quadratic(origin_input))
+            elif activation_list[i] == 'exp_cubic':
+                Input = safe_aggregate(Input, exp_cubic(origin_input))
+            elif activation_list[i] == 'sine_square':
+                Input = safe_aggregate(Input, sine_square(origin_input))
+            elif activation_list[i] == 'logarithmic':
+                Input = safe_aggregate(Input, logarithmic(origin_input))
+            elif activation_list[i] == 'scaled_cubic':
+                Input = safe_aggregate(Input, scaled_cubic(origin_input, 1.0))
+            elif activation_list[i] == 'sine_offset':
+                Input = safe_aggregate(Input, sine_offset(origin_input, 1.0))
+            elif activation_list[i] == 'spiral':
+                Input = safe_aggregate(Input, spiral_activation(origin_input))
+            elif activation_list[i] == 'circular':
+                Input = safe_aggregate(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, cp.ndarray):
+                Input = cp.array(Input)
+            if not isinstance(origin_input, cp.ndarray):
+                origin_input = cp.array(origin_input)
+            continue
+ 
+    return Input

pyerualjetwork/data_operations.py

@@ -421,6 +421,9 @@ def find_closest_factors(a):
 
 def batcher(x_test, y_test, batch_size=1):
 
+    if batch_size == 1:
+        return x_test, y_test
+    
     y_labels = np.argmax(y_test, axis=1)
 
     sampled_x, sampled_y = [], []

pyerualjetwork/data_operations_cuda.py

@@ -430,11 +430,14 @@ def find_closest_factors(a):
             j = a // i
             return i, j
         
-
 def batcher(x_test, y_test, batch_size=1):
-    y_labels = cp.argmax(y_test, axis=1)  # Sınıf etiketlerini belirle
+
+    if batch_size == 1:
+        return x_test, y_test
+
+    y_labels = cp.argmax(y_test, axis=1)
     
-    unique_labels = cp.unique(y_labels)  # Tüm sınıfları bul
+    unique_labels = cp.unique(y_labels)
     total_samples = sum(
         int(cp.sum(y_labels == class_label) * batch_size) for class_label in unique_labels
     )
@@ -444,20 +447,15 @@ def batcher(x_test, y_test, batch_size=1):
     
     offset = 0
     for class_label in unique_labels:
-        # Sınıfa ait indeksleri bulun
         class_indices = cp.where(y_labels == class_label)[0]
         
-        # Örnek sayısını belirle
         num_samples = int(len(class_indices) * batch_size)
         
-        # Rastgele örnek seç
         sampled_indices = cp.random.choice(class_indices, num_samples, replace=False)
         
-        # Veriyi sampled dizilerine yaz
         sampled_x[offset:offset + num_samples] = x_test[sampled_indices]
         sampled_y[offset:offset + num_samples] = y_test[sampled_indices]
-        
-        # Kaydırmayı güncelle
+
         offset += num_samples
     
     return sampled_x, sampled_y

pyerualjetwork/plan.py

@@ -125,7 +125,15 @@ def fit(
 
     elif val and (x_val is not None and y_val is not None):
         x_val = x_val.astype(dtype, copy=False)
-        y_val = y_val.astype(dtype, copy=False)
+        if len(y_val[0]) < 256:
+            if y_val.dtype != np.uint8:
+                y_val = np.array(y_val, copy=False).astype(np.uint8, copy=False)
+        elif len(y_val[0]) <= 32767:
+            if y_val.dtype != np.uint16:
+                y_val = np.array(y_val, copy=False).astype(np.uint16, copy=False)
+        else:
+            if y_val.dtype != np.uint32:
+                y_val = np.array(y_val, copy=False).astype(np.uint32, copy=False)
 
     val_list = [] if val else None
     val_count = val_count or 10
@@ -137,7 +145,7 @@ def fit(
 
     # Training process
     for index, inp in enumerate(x_train):
-        inp = np.array(inp, copy=False).ravel()
+        inp = np.array(inp, copy=False, dtype=dtype).ravel()
         y_decoded = decode_one_hot(y_train)
         # Weight updates
         STPW = feed_forward(inp, STPW, is_training=True, Class=y_decoded[index], activation_potentiation=activation_potentiation, LTD=LTD)
@@ -244,15 +252,15 @@ def learner(x_train, y_train, x_test=None, y_test=None, strategy='accuracy', bat
     if x_test is not None:
         x_test = x_test.astype(dtype, copy=False)
 
-    if len(y_test[0]) < 256:
-        if y_test.dtype != np.uint8:
-            y_test = np.array(y_test, copy=False).astype(np.uint8, copy=False)
-    elif len(y_test[0]) <= 32767:
-        if y_test.dtype != np.uint16:
-            y_test = np.array(y_test, copy=False).astype(np.uint16, copy=False)
-    else:
-        if y_test.dtype != np.uint32:
-            y_test = np.array(y_test, copy=False).astype(np.uint32, copy=False)
+        if len(y_test[0]) < 256:
+            if y_test.dtype != np.uint8:
+                y_test = np.array(y_test, copy=False).astype(np.uint8, copy=False)
+        elif len(y_test[0]) <= 32767:
+            if y_test.dtype != np.uint16:
+                y_test = np.array(y_test, copy=False).astype(np.uint16, copy=False)
+        else:
+            if y_test.dtype != np.uint32:
+                y_test = np.array(y_test, copy=False).astype(np.uint32, copy=False)
 
     if x_test is None and y_test is None:
         x_test = x_train
@@ -304,8 +312,9 @@ def learner(x_train, y_train, x_test=None, y_test=None, strategy='accuracy', bat
     else:
         best_activations = start_this
         x_test_batch, y_test_batch = batcher(x_test, y_test, batch_size=batch_size)
-        W = fit(x_train, y_train, activation_potentiation=best_activations, train_bar=False, auto_normalization=auto_normalization)
-        model = evaluate(x_test_batch, y_test_batch, W=W, loading_bar_status=False, activation_potentiation=activations)
+
+        W = fit(x_train, y_train, activation_potentiation=best_activations, train_bar=False, auto_normalization=auto_normalization, dtype=dtype)
+        model = evaluate(x_test_batch, y_test_batch, W=W, loading_bar_status=False, activation_potentiation=activations, dtype=dtype)
 
         if loss == 'categorical_crossentropy':
             test_loss = categorical_crossentropy(y_true_batch=y_test_batch, y_pred_batch=model[get_preds_softmax()])
@@ -334,6 +343,7 @@ def learner(x_train, y_train, x_test=None, y_test=None, strategy='accuracy', bat
             activations.append(activation_potentiation[j])
 
             x_test_batch, y_test_batch = batcher(x_test, y_test, batch_size=batch_size)
+
             W = fit(x_train, y_train, activation_potentiation=activations, train_bar=False, auto_normalization=auto_normalization, dtype=dtype)
             model = evaluate(x_test_batch, y_test_batch, W=W, loading_bar_status=False, activation_potentiation=activations, dtype=dtype)
 
@@ -435,7 +445,7 @@ def learner(x_train, y_train, x_test=None, y_test=None, strategy='accuracy', bat
                 if target_acc is not None and best_acc >= target_acc:
                     progress.close()
                     train_model = evaluate(x_train, y_train, W=best_weights, loading_bar_status=False, 
-                                        activation_potentiation=final_activations)
+                                        activation_potentiation=final_activations, dtype=dtype)
 
                     if loss == 'categorical_crossentropy':
                         train_loss = categorical_crossentropy(y_true_batch=y_train, 
@@ -460,7 +470,7 @@ def learner(x_train, y_train, x_test=None, y_test=None, strategy='accuracy', bat
                 if target_loss is not None and best_loss <= target_loss:
                     progress.close()
                     train_model = evaluate(x_train, y_train, W=best_weights, loading_bar_status=False, 
-                                        activation_potentiation=final_activations)
+                                        activation_potentiation=final_activations, dtype=dtype)
 
                     if loss == 'categorical_crossentropy':
                         train_loss = categorical_crossentropy(y_true_batch=y_train, 
@@ -503,7 +513,7 @@ def learner(x_train, y_train, x_test=None, y_test=None, strategy='accuracy', bat
             if best_acc_per_depth_list[i] == best_acc_per_depth_list[i-1]:
                 progress.close()
                 train_model = evaluate(x_train, y_train, W=best_weights, loading_bar_status=False, 
-                                    activation_potentiation=final_activations)
+                                    activation_potentiation=final_activations, dtype=dtype)
 
                 if loss == 'categorical_crossentropy':
                     train_loss = categorical_crossentropy(y_true_batch=y_train, 
@@ -527,7 +537,7 @@ def learner(x_train, y_train, x_test=None, y_test=None, strategy='accuracy', bat
     # Final evaluation
     progress.close()
     train_model = evaluate(x_train, y_train, W=best_weights, loading_bar_status=False, 
-                        activation_potentiation=final_activations)
+                        activation_potentiation=final_activations, dtype=dtype)
 
     if loss == 'categorical_crossentropy':
         train_loss = categorical_crossentropy(y_true_batch=y_train, y_pred_batch=train_model[get_preds_softmax()])

pyerualjetwork/plan_cuda.py

@@ -428,7 +428,7 @@ def learner(x_train, y_train, x_test=None, y_test=None, strategy='accuracy', bat
                 if target_acc is not None and best_acc >= target_acc:
                     progress.close()
                     train_model = evaluate(x_train, y_train, W=best_weights, loading_bar_status=False, 
-                                        activation_potentiation=final_activations)
+                                        activation_potentiation=final_activations, dtype=dtype)
 
                     if loss == 'categorical_crossentropy':
                         train_loss = categorical_crossentropy(y_true_batch=y_train, 
@@ -453,7 +453,7 @@ def learner(x_train, y_train, x_test=None, y_test=None, strategy='accuracy', bat
                 if target_loss is not None and best_loss <= target_loss:
                     progress.close()
                     train_model = evaluate(x_train, y_train, W=best_weights, loading_bar_status=False, 
-                                        activation_potentiation=final_activations)
+                                        activation_potentiation=final_activations, dtype=dtype)
 
                     if loss == 'categorical_crossentropy':
                         train_loss = categorical_crossentropy(y_true_batch=y_train, 
@@ -496,7 +496,7 @@ def learner(x_train, y_train, x_test=None, y_test=None, strategy='accuracy', bat
             if best_acc_per_depth_list[i] == best_acc_per_depth_list[i-1]:
                 progress.close()
                 train_model = evaluate(x_train, y_train, W=best_weights, loading_bar_status=False, 
-                                    activation_potentiation=final_activations)
+                                    activation_potentiation=final_activations, dtype=dtype)
 
                 if loss == 'categorical_crossentropy':
                     train_loss = categorical_crossentropy(y_true_batch=y_train, 
@@ -520,7 +520,7 @@ def learner(x_train, y_train, x_test=None, y_test=None, strategy='accuracy', bat
     # Final evaluation
     progress.close()
     train_model = evaluate(x_train, y_train, W=best_weights, loading_bar_status=False, 
-                        activation_potentiation=final_activations)
+                        activation_potentiation=final_activations, dtype=dtype)
 
     if loss == 'categorical_crossentropy':
         train_loss = categorical_crossentropy(y_true_batch=y_train, y_pred_batch=train_model[get_preds_softmax()])
@@ -609,9 +609,9 @@ def evaluate(
         
         loading_bar_status (bool): Loading bar (optional). Default = True.
 
-        show_metrics (bool): Metrikleri gösterme seçeneği (isteğe bağlı). Default = False.
+        show_metrics (bool): Visualize metrics ? (optional). Default = False.
 
-        dtype (cupy.dtype): Data type for the arrays. np.float32 by default. Example: cp.float64 or cp.float16. [fp32 for balanced devices, fp64 for strong devices, fp16 for weak devices: not reccomended!] (optional)
+        dtype (cupy.dtype): Data type for the arrays. cp.float32 by default. Example: cp.float64 or cp.float16. [fp32 for balanced devices, fp64 for strong devices, fp16 for weak devices: not reccomended!] (optional)
 
     Returns:
         tuple: Model (list).
@@ -647,10 +647,8 @@ def evaluate(
         Input = x_test[inpIndex].ravel()
         neural_layer = Input
 
-        # Feedforward işlemi
         neural_layer = feed_forward(neural_layer, cp.copy(W), is_training=False, Class='?', activation_potentiation=activation_potentiation)
 
-        # Olasılıkları ve tahminleri hesapla
         predict_probabilitys[inpIndex] = Softmax(neural_layer)
 
         RealOutput = cp.argmax(y_test[inpIndex])
@@ -674,4 +672,4 @@ def evaluate(
     if show_metrics:
         plot_evaluate(x_test, y_test, predict_classes, acc_list, W=cp.copy(W), activation_potentiation=activation_potentiation)
 
-    return W, predict_classes, acc_list[-1], None, None, predict_probabilitys
+    return W, predict_classes, acc_list[-1], None, None, predict_probabilitys

{pyerualjetwork-4.0.5.dist-info → pyerualjetwork-4.0.7.dist-info}/METADATA

@@ -1,13 +1,13 @@
 Metadata-Version: 2.1
 Name: pyerualjetwork
-Version: 4.0.5
+Version: 4.0.7
 Summary: PyerualJetwork is a machine learning library written in Python for professionals, incorporating advanced, unique, new, and modern techniques.
 Author: Hasan Can Beydili
 Author-email: tchasancan@gmail.com
 Keywords: model evaluation,classification,potentiation learning artificial neural networks,NEAT,genetic algorithms,reinforcement learning,neural networks
 Description-Content-Type: text/markdown
 
-# PyerualJetwork [![Socket Badge](https://socket.dev/api/badge/pypi/package/pyerualjetwork/4.0.5?artifact_id=tar-gz)](https://socket.dev/pypi/package/pyerualjetwork/overview/4.0.5/tar-gz) [![CodeFactor](https://www.codefactor.io/repository/github/hcb06/pyerualjetwork/badge)](https://www.codefactor.io/repository/github/hcb06/pyerualjetwork) [![PyPI Downloads](https://static.pepy.tech/badge/anaplan)](https://pepy.tech/projects/anaplan) + [![PyPI Downloads](https://static.pepy.tech/badge/pyerualjetwork)](https://pepy.tech/projects/pyerualjetwork) [![PyPI Downloads](https://static.pepy.tech/badge/pyerualjetwork/month)](https://pepy.tech/projects/pyerualjetwork) [![PyPI Downloads](https://static.pepy.tech/badge/pyerualjetwork/week)](https://pepy.tech/projects/pyerualjetwork) [![PyPI version](https://img.shields.io/pypi/v/pyerualjetwork.svg)](https://pypi.org/project/pyerualjetwork/)
+# PyerualJetwork [![Socket Badge](https://socket.dev/api/badge/pypi/package/pyerualjetwork/4.0.6?artifact_id=tar-gz)](https://socket.dev/pypi/package/pyerualjetwork/overview/4.0.6/tar-gz) [![CodeFactor](https://www.codefactor.io/repository/github/hcb06/pyerualjetwork/badge)](https://www.codefactor.io/repository/github/hcb06/pyerualjetwork) [![PyPI Downloads](https://static.pepy.tech/badge/anaplan)](https://pepy.tech/projects/anaplan) + [![PyPI Downloads](https://static.pepy.tech/badge/pyerualjetwork)](https://pepy.tech/projects/pyerualjetwork) [![PyPI Downloads](https://static.pepy.tech/badge/pyerualjetwork/month)](https://pepy.tech/projects/pyerualjetwork) [![PyPI Downloads](https://static.pepy.tech/badge/pyerualjetwork/week)](https://pepy.tech/projects/pyerualjetwork) [![PyPI version](https://img.shields.io/pypi/v/pyerualjetwork.svg)](https://pypi.org/project/pyerualjetwork/)
 
 Note: anaplan old name of pyerualjetwork
 

{pyerualjetwork-4.0.5.dist-info → pyerualjetwork-4.0.7.dist-info}/RECORD

@@ -1,8 +1,8 @@
-pyerualjetwork/__init__.py,sha256=mBpIQOG8jn_kVBG6FrXWWqZ39nSivP_ibUikmVmT2Ik,2542
-pyerualjetwork/activation_functions.py,sha256=iJpdsX8FqZ3lB3x-YG7d9-em8xHD0y1ciJLNWmI7Y6A,9941
-pyerualjetwork/activation_functions_cuda.py,sha256=8wV31USrS-9BGI388Ntya10HCucNkV-zm5EH0YL2iRw,10896
-pyerualjetwork/data_operations.py,sha256=ncg9AXy3_NdDcJ6W4U-VC_Ku0mvyLl11RUKffkQ8sxY,16474
-pyerualjetwork/data_operations_cuda.py,sha256=Ekme6MnVNCqYMjKaO3nGhFYMnvWlELW9__QQWr2LXk4,17368
+pyerualjetwork/__init__.py,sha256=i_pt-vpEDdNMFEVgM_LjkJ-_bmhTswIYaZTUC-LsRps,2542
+pyerualjetwork/activation_functions.py,sha256=UeuuagJWcSoFfmwikDU7O8ph--oySnWDJNqKbEh4SlE,12043
+pyerualjetwork/activation_functions_cuda.py,sha256=5F49gKkiRngo0hAaS1KfarxQ7wEyub13WAX_apxf8j8,12069
+pyerualjetwork/data_operations.py,sha256=rnOYLLK3YnRdWpEsEQABU0RE950lQQI7971eBLBpqOQ,16536
+pyerualjetwork/data_operations_cuda.py,sha256=hh51PQORfQicWruu9Bo-HAJW56lQkoG2QZOBoTjFGkw,17175
 pyerualjetwork/help.py,sha256=pZs7hIhgFkovGLle97d9Qu9m5zKhMh7-OAIphIoSxBg,830
 pyerualjetwork/loss_functions.py,sha256=6PyBI232SQRGuFnG3LDGvnv_PUdWzT2_2mUODJiejGI,618
 pyerualjetwork/loss_functions_cuda.py,sha256=C93IZJcrOpT6HMK9x1O4AHJWXYTkN5WZiqdssPbvAPk,617
@@ -10,14 +10,14 @@ pyerualjetwork/metrics.py,sha256=q7MkhnZDRbCjFBDDfUgrl8lBYnUT_1ro1LxeBq105pI,607
 pyerualjetwork/metrics_cuda.py,sha256=TCwn5Z_4jQjqPCURX_xtcz9cjsYVzlahgKDA-qCgpU4,5072
 pyerualjetwork/model_operations.py,sha256=k_53BJladPm9fBWdlVpS6Uf5IQzpNlJWLH746DXGq_M,13036
 pyerualjetwork/model_operations_cuda.py,sha256=Guo0lFaaLiAXwKmnOi8Fz_bL_p38qR46CIhGOg_V1Sw,13138
-pyerualjetwork/plan.py,sha256=kGZucs_GOoSNH25vsvfPgWKttPdFHvjCek8EICj-W1s,34205
-pyerualjetwork/plan_cuda.py,sha256=4APaOl0_HGmp2i9EubFptajpfRQSoNU0LQHF1LDiQrg,33969
+pyerualjetwork/plan.py,sha256=iF0zIaO2KrPYF8G__-Q2wMYbgQEIdRWap3BBMRZ1Fpo,34746
+pyerualjetwork/plan_cuda.py,sha256=JF2LK5BgDZAQb3LuPDCyz8G7ICEvEg8BWezeZdw8X-4,33920
 pyerualjetwork/planeat.py,sha256=8cwWboJtXgFTKq6nFl1T9McbLDmBquKUr12y168PmcM,39513
 pyerualjetwork/planeat_cuda.py,sha256=boN-HFwm_D9cT1z0eAR8zgkiD_XOg-J2T2jNFvZweG4,39570
 pyerualjetwork/ui.py,sha256=wu2BhU1k-w3Kcho5Jtq4SEKe68ftaUeRGneUOSCVDjU,575
 pyerualjetwork/visualizations.py,sha256=DvbiQGlvlKNAgBJ3O3ukAi6uxSheha9SRFh5YX7ZxIA,26678
 pyerualjetwork/visualizations_cuda.py,sha256=dA0u85ZIyKqjtoSJ6p3EbEpJs4V4vS5W5ftR6eif8yg,26713
-pyerualjetwork-4.0.5.dist-info/METADATA,sha256=EXQuW_wIKq9Y7tVYikjrKyJAp-nSc9iEkb-Xxx19954,6357
-pyerualjetwork-4.0.5.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
-pyerualjetwork-4.0.5.dist-info/top_level.txt,sha256=BRyt62U_r3ZmJpj-wXNOoA345Bzamrj6RbaWsyW4tRg,15
-pyerualjetwork-4.0.5.dist-info/RECORD,,
+pyerualjetwork-4.0.7.dist-info/METADATA,sha256=BWCx6dmY3FC-ud-gC_8ukAcE6-4o-wrU1xIItVeadDw,6357
+pyerualjetwork-4.0.7.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
+pyerualjetwork-4.0.7.dist-info/top_level.txt,sha256=BRyt62U_r3ZmJpj-wXNOoA345Bzamrj6RbaWsyW4tRg,15
+pyerualjetwork-4.0.7.dist-info/RECORD,,