pyerualjetwork 4.0.3__py3-none-any.whl → 4.0.4__py3-none-any.whl

pyerualjetwork/__init__.py

@@ -46,7 +46,7 @@ for package_name in package_names:
 
 print(f"PyerualJetwork is ready to use with {err} errors")
 
-__version__ = "4.0.3"
+__version__ = "4.0.4"
 __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_cuda.py

@@ -1,5 +1,4 @@
 import cupy as cp
-from scipy.special import expit, softmax
 
 # ACTIVATION FUNCTIONS ----
 
@@ -10,210 +9,207 @@ 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]) 
 
-    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(([spiral_x[0]], spiral_y))
-    
-    return spiral_output
+        spiral_x = r * cp.cos(theta + r) 
+        spiral_y = r * cp.sin(theta + r) 
 
+        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]) 
 
-def Softmax(
-    x  # num: Input data to be transformed using softmax function.
-):
-    """
-    Applies the softmax function to the input data.
+        spiral_x = r * cp.cos(theta + r) 
+        spiral_y = r * cp.sin(theta + r) 
 
-    Args:
-        (num): Input data to be transformed using softmax function.
-
-    Returns:
-       (num): Transformed data after applying softmax function.
-    """
-
-    return cp.array(softmax(x.get()))
+        spiral_output = cp.stack((spiral_x, spiral_y), axis=-1)
 
-
-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)
+    return spiral_output
 
 
-def Relu(
-    x  # num: Input data to be transformed using ReLU function.
-):
-    """
-    Applies the Rectified Linear Unit (ReLU) function to the input data.
+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))
 
-    Args:
-        (num): Input data to be transformed using ReLU function.
-
-    Returns:
-        (num): Transformed data after applying ReLU function.
-    """
+def Sigmoid(x):
+    """Optimized Sigmoid function"""
+    return 1 / (1 + cp.exp(-x))
 
+def Relu(x):
+    """Optimized ReLU function"""
     return cp.maximum(0, x)
 
-
 def tanh(x):
+    """Optimized Tanh function"""
     return cp.tanh(x)
 
 def swish(x):
-    return x * (1 / (1 + cp.exp(-x)))
+    """Optimized Swish function"""
+    return x * Sigmoid(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):
-    return cp.log(1 + cp.exp(x))
+    """Optimized Softplus function"""
+    return cp.log1p(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):
-    return cp.array(softmax(alpha * x.get())) * x
+    """Optimized SGU function"""
+    return cp.array(cp.exp(alpha * x)) * 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):    
-    
+def circular_activation(x, scale=2.0, frequency=1.0, shift=0.0):
+    """Optimized Circular Activation function"""
     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
         
-        if i % 2 == 0:
-            circular_output[i] = circular_x
-        else:
-            circular_output[i] = circular_y
+        circular_output[i] = circular_x if i % 2 == 0 else 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):
@@ -221,7 +217,7 @@ def apply_activation(Input, activation_list):
     Applies a sequence of activation functions to the input.
     
     Args:
-        Input (array-like): The input to apply activations to.
+        Input (numpy.ndarray): The input to apply activations to.
         activation_list (list): A list of activation function names to apply.
     
     Returns:

pyerualjetwork/metrics_cuda.py

@@ -1,79 +1,54 @@
 import cupy as cp
+from .data_operations_cuda import decode_one_hot
 
 def metrics(y_ts, test_preds, average='weighted'):
-    """
-    Calculates precision, recall and F1 score for a classification task.
-    
-    Args:
-        y_ts (list or numpy.ndarray): True labels.
-        test_preds (list or numpy.ndarray): Predicted labels.
-        average (str): Type of averaging ('micro', 'macro', 'weighted').
-
-    Returns:
-        tuple: Precision, recall, F1 score.
-    """
-    
-    from .data_operations_cuda import decode_one_hot
-    
-    y_test_d = decode_one_hot(y_ts)
-    y_test_d = cp.array(y_test_d)
+    y_test_d = cp.array(decode_one_hot(y_ts))
     y_pred = cp.array(test_preds)
 
     if y_test_d.ndim > 1:
-        y_test_d = y_test_d.reshape(-1)
+        y_test_d = y_test_d.ravel()
     if y_pred.ndim > 1:
-        y_pred = y_pred.reshape(-1)
-
-    tp = {}
-    fp = {}
-    fn = {}
+        y_pred = y_pred.ravel()
 
     classes = cp.unique(cp.concatenate((y_test_d, y_pred)))
+    tp = cp.zeros(len(classes), dtype=cp.int32)
+    fp = cp.zeros(len(classes), dtype=cp.int32)
+    fn = cp.zeros(len(classes), dtype=cp.int32)
 
-    for c in classes:
-        tp[c] = 0
-        fp[c] = 0
-        fn[c] = 0
-
-    for c in classes:
-        for true, pred in zip(y_test_d, y_pred):
-            if true == c and pred == c:
-                tp[c] += 1
-            elif true != c and pred == c:
-                fp[c] += 1
-            elif true == c and pred != c:
-                fn[c] += 1
-
-    precision = {}
-    recall = {}
-    f1 = {}
-
-    for c in classes:
-        precision[c] = tp[c] / (tp[c] + fp[c]) if (tp[c] + fp[c]) > 0 else 0
-        recall[c] = tp[c] / (tp[c] + fn[c]) if (tp[c] + fn[c]) > 0 else 0
-        f1[c] = 2 * (precision[c] * recall[c]) / (precision[c] + recall[c]) if (precision[c] + recall[c]) > 0 else 0
+    for i, c in enumerate(classes):
+        tp[i] = cp.sum((y_test_d == c) & (y_pred == c))
+        fp[i] = cp.sum((y_test_d != c) & (y_pred == c))
+        fn[i] = cp.sum((y_test_d == c) & (y_pred != c))
+
+    precision = tp / (tp + fp + 1e-10)
+    recall = tp / (tp + fn + 1e-10)
+    f1 = 2 * (precision * recall) / (precision + recall + 1e-10)
 
     if average == 'micro':
-        precision_val = cp.sum(list(tp.values())) / (cp.sum(list(tp.values())) + cp.sum(list(fp.values()))) if (cp.sum(list(tp.values())) + cp.sum(list(fp.values()))) > 0 else 0
-        recall_val = cp.sum(list(tp.values())) / (cp.sum(list(tp.values())) + cp.sum(list(fn.values()))) if (cp.sum(list(tp.values())) + cp.sum(list(fn.values()))) > 0 else 0
-        f1_val = 2 * (precision_val * recall_val) / (precision_val + recall_val) if (precision_val + recall_val) > 0 else 0
+        tp_sum = cp.sum(tp)
+        fp_sum = cp.sum(fp)
+        fn_sum = cp.sum(fn)
+        precision_val = tp_sum / (tp_sum + fp_sum + 1e-10)
+        recall_val = tp_sum / (tp_sum + fn_sum + 1e-10)
+        f1_val = 2 * (precision_val * recall_val) / (precision_val + recall_val + 1e-10)
 
     elif average == 'macro':
-        precision_val = cp.mean(list(precision.values()))
-        recall_val = cp.mean(list(recall.values()))
-        f1_val = cp.mean(list(f1.values()))
+        precision_val = cp.mean(precision)
+        recall_val = cp.mean(recall)
+        f1_val = cp.mean(f1)
 
     elif average == 'weighted':
         weights = cp.array([cp.sum(y_test_d == c) for c in classes])
         weights = weights / cp.sum(weights)
-        precision_val = cp.sum([weights[i] * precision[classes[i]] for i in range(len(classes))])
-        recall_val = cp.sum([weights[i] * recall[classes[i]] for i in range(len(classes))])
-        f1_val = cp.sum([weights[i] * f1[classes[i]] for i in range(len(classes))])
+        precision_val = cp.sum(weights * precision)
+        recall_val = cp.sum(weights * recall)
+        f1_val = cp.sum(weights * f1)
 
     else:
         raise ValueError("Invalid value for 'average'. Choose from 'micro', 'macro', 'weighted'.")
 
-    return precision_val, recall_val, f1_val
+    return precision_val.item(), recall_val.item(), f1_val.item()
+
 
 
 def roc_curve(y_true, y_score):

{pyerualjetwork-4.0.3.dist-info → pyerualjetwork-4.0.4.dist-info}/METADATA

@@ -1,13 +1,13 @@
 Metadata-Version: 2.1
 Name: pyerualjetwork
-Version: 4.0.3
+Version: 4.0.4
 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/anaplan/2.5.0?artifact_id=tar-gz)](https://socket.dev/pypi/package/anaplan/overview/2.5.0/tar-gz) [![CodeFactor](https://www.codefactor.io/repository/github/hcb06/anaplan/badge)](https://www.codefactor.io/repository/github/hcb06/anaplan) [![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/anaplan/month)](https://pepy.tech/projects/anaplan) [![PyPI Downloads](https://static.pepy.tech/badge/anaplan/week)](https://pepy.tech/projects/anaplan) [![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.4?artifact_id=tar-gz)](https://socket.dev/pypi/package/pyerualjetwork/overview/4.0.4/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/anaplan/month)](https://pepy.tech/projects/anaplan) [![PyPI Downloads](https://static.pepy.tech/badge/anaplan/week)](https://pepy.tech/projects/anaplan) [![PyPI version](https://img.shields.io/pypi/v/pyerualjetwork.svg)](https://pypi.org/project/pyerualjetwork/)
 
 Note: anaplan old name of pyerualjetwork
 

{pyerualjetwork-4.0.3.dist-info → pyerualjetwork-4.0.4.dist-info}/RECORD

@@ -1,13 +1,13 @@
-pyerualjetwork/__init__.py,sha256=5oEPDEkbkCzfpVIefoFlRzsBsnwNxnlXqveqEij-DXs,2477
+pyerualjetwork/__init__.py,sha256=fRW4zgPaGddL4vn1jz7QKAPi9tUzaOiEmKGTYuvvG8k,2477
 pyerualjetwork/activation_functions.py,sha256=iJpdsX8FqZ3lB3x-YG7d9-em8xHD0y1ciJLNWmI7Y6A,9941
-pyerualjetwork/activation_functions_cuda.py,sha256=7p-_qZuuj-BZ9A7ds8PgU7hSQ_EGI16XLh4J_6ySkD8,9968
+pyerualjetwork/activation_functions_cuda.py,sha256=8wV31USrS-9BGI388Ntya10HCucNkV-zm5EH0YL2iRw,10896
 pyerualjetwork/data_operations.py,sha256=mph66_qGQHxhg_gQtTuOzP2PjTwJsxTGzmRmvrzlQn4,12747
 pyerualjetwork/data_operations_cuda.py,sha256=Iy4i5tCZidsnSbyRSX8IuzUMLTDrlz8Gc9nji_RRak0,13642
 pyerualjetwork/help.py,sha256=pZs7hIhgFkovGLle97d9Qu9m5zKhMh7-OAIphIoSxBg,830
 pyerualjetwork/loss_functions.py,sha256=6PyBI232SQRGuFnG3LDGvnv_PUdWzT2_2mUODJiejGI,618
 pyerualjetwork/loss_functions_cuda.py,sha256=C93IZJcrOpT6HMK9x1O4AHJWXYTkN5WZiqdssPbvAPk,617
 pyerualjetwork/metrics.py,sha256=q7MkhnZDRbCjFBDDfUgrl8lBYnUT_1ro1LxeBq105pI,6077
-pyerualjetwork/metrics_cuda.py,sha256=1KKIJunalYfj7OC7AJDXmK4wANrMnyJe_bvbUmhgl_Q,6081
+pyerualjetwork/metrics_cuda.py,sha256=TCwn5Z_4jQjqPCURX_xtcz9cjsYVzlahgKDA-qCgpU4,5072
 pyerualjetwork/model_operations.py,sha256=d1cOuKBYiVMXKrWLJ6zy6rkfVCadzQGNw6OjqwWtBhA,11932
 pyerualjetwork/model_operations_cuda.py,sha256=CAnHj8EQuz2p2oFYcqaa9Z-yJX70rLnFrBkh2sQwrYY,12168
 pyerualjetwork/plan.py,sha256=vfN_HIwU8NepZuB_UKY6nPickOBYWKXd_uymhaTLEoI,31525
@@ -17,7 +17,7 @@ pyerualjetwork/planeat_cuda.py,sha256=zkXkvdHSYgzV2BSwtpUuUXB6_WbYb_EPL06OfBmRk9
 pyerualjetwork/ui.py,sha256=wu2BhU1k-w3Kcho5Jtq4SEKe68ftaUeRGneUOSCVDjU,575
 pyerualjetwork/visualizations.py,sha256=DvbiQGlvlKNAgBJ3O3ukAi6uxSheha9SRFh5YX7ZxIA,26678
 pyerualjetwork/visualizations_cuda.py,sha256=dA0u85ZIyKqjtoSJ6p3EbEpJs4V4vS5W5ftR6eif8yg,26713
-pyerualjetwork-4.0.3.dist-info/METADATA,sha256=3LkeCrAArMy4RKRjVfpVFpxunDxvEwKdtY1Q0dueiAI,6301
-pyerualjetwork-4.0.3.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
-pyerualjetwork-4.0.3.dist-info/top_level.txt,sha256=BRyt62U_r3ZmJpj-wXNOoA345Bzamrj6RbaWsyW4tRg,15
-pyerualjetwork-4.0.3.dist-info/RECORD,,
+pyerualjetwork-4.0.4.dist-info/METADATA,sha256=51txpwSwgc_rPSW1p_XGCi_ntMCt0MyRcwGO5ICRv_Q,6329
+pyerualjetwork-4.0.4.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
+pyerualjetwork-4.0.4.dist-info/top_level.txt,sha256=BRyt62U_r3ZmJpj-wXNOoA345Bzamrj6RbaWsyW4tRg,15
+pyerualjetwork-4.0.4.dist-info/RECORD,,