pyerualjetwork 5.1__py3-none-any.whl → 5.5__py3-none-any.whl

pyerualjetwork/{visualizations_cpu.py → cpu/visualizations.py}

@@ -1,6 +1,7 @@
 import networkx as nx
 import matplotlib.pyplot as plt
 import numpy as np
+import cupy as cp
 from scipy.spatial import ConvexHull
 import seaborn as sns
 from matplotlib.animation import ArtistAnimation
@@ -86,7 +87,7 @@ def draw_model_architecture(model_name, model_path=''):
     Visualizes the architecture of a neural network model with multiple inputs based on activation functions.
     """
     
-    from .model_operations_cpu import load_model, get_scaler, get_act, get_weights
+    from ..model_ops import load_model, get_scaler, get_act, get_weights
     
     model = load_model(model_name=model_name, model_path=model_path)
     
@@ -182,14 +183,11 @@ def draw_model_architecture(model_name, model_path=''):
     
 def draw_activations(x_train, activation):
 
-    from . import activation_functions_cpu as af
+    from . import activation_functions as af
 
     if activation == 'sigmoid':
         result = af.Sigmoid(x_train)
 
-    elif activation == 'swish':
-        result = af.swish(x_train)
-
     elif activation == 'circular':
         result = af.circular_activation(x_train)
 
@@ -205,18 +203,9 @@ def draw_activations(x_train, activation):
     elif activation == 'relu':
         result = af.Relu(x_train)
 
-    elif activation == 'softplus':
-        result = af.softplus(x_train)
-
-    elif activation == 'elu':
-        result = af.elu(x_train)
-
     elif activation == 'gelu':
         result = af.gelu(x_train)
 
-    elif activation == 'selu':
-        result = af.selu(x_train)
-
     elif activation == 'softmax':
         result = af.Softmax(x_train)
 
@@ -235,24 +224,12 @@ def draw_activations(x_train, activation):
     elif activation == 'dlrelu':
         result = af.dlrelu(x_train)
 
-    elif activation == 'exsig':
-        result = af.exsig(x_train)
-
     elif activation == 'sin_plus':
         result = af.sin_plus(x_train)
 
     elif activation == 'acos':
         result = af.acos(x_train, alpha=1.0, beta=0.0)
 
-    elif activation == 'gla':
-        result = af.gla(x_train, alpha=1.0, mu=0.0)
-
-    elif activation == 'srelu':
-        result = af.srelu(x_train)
-
-    elif activation == 'qelu':
-        result = af.qelu(x_train)
-
     elif activation == 'isra':
         result = af.isra(x_train)
 
@@ -265,54 +242,27 @@ def draw_activations(x_train, activation):
     elif activation == 'bent_identity':
         result = af.bent_identity(x_train)
 
-    elif activation == 'sech':
-        result = af.sech(x_train)
-
     elif activation == 'softsign':
         result = af.softsign(x_train)
 
     elif activation == 'pwl':
         result = af.pwl(x_train)
 
-    elif activation == 'cubic':
-        result = af.cubic(x_train)
-
-    elif activation == 'gaussian':
-        result = af.gaussian(x_train)
-
     elif activation == 'sine':
         result = af.sine(x_train)
 
     elif activation == 'tanh_square':
         result = af.tanh_square(x_train)
 
-    elif activation == 'mod_sigmoid':
-        result = af.mod_sigmoid(x_train)
-
     elif activation == 'linear':
         result = x_train
 
-    elif activation == 'quartic':
-        result = af.quartic(x_train)
-
-    elif activation == 'square_quartic':
-        result = af.square_quartic(x_train)
-
-    elif activation == 'cubic_quadratic':
-        result = af.cubic_quadratic(x_train)
-    
-    #elif activation == 'exp_cubic':
-        #result = af.exp_cubic(x_train)
-
     elif activation == 'sine_square':
         result = af.sine_square(x_train)
 
     elif activation == 'logarithmic':
         result = af.logarithmic(x_train)
 
-    elif activation == 'scaled_cubic':
-        result = af.scaled_cubic(x_train, 1.0)
-
     elif activation == 'sine_offset':
         result = af.sine_offset(x_train, 1.0)
 
@@ -325,35 +275,37 @@ def draw_activations(x_train, activation):
         return x_train
 
 
-def plot_evaluate(x_test, y_test, y_preds, acc_list, W, activations):
+def plot_evaluate(x_test, y_test, y_preds, model, acc, cuda=False):
     
-    from .metrics_cpu import metrics, confusion_matrix, roc_curve
-    from .ui import loading_bars, initialize_loading_bar
-    from .data_operations_cpu import decode_one_hot
-    from .model_operations_cpu import predict_model_ram
+    if not cuda:
+        from .metrics import metrics, confusion_matrix, roc_curve
+        from .data_ops import decode_one_hot
+    else:
+        from ..cuda.metrics import metrics, confusion_matrix, roc_curve
+        from ..cuda.data_ops import decode_one_hot
     
-    bar_format_normal = loading_bars()[0]
     
-    acc = acc_list[len(acc_list) - 1]
-    y_true = decode_one_hot(y_test)
+    from ..model_ops import predict_from_memory
 
-    y_true = np.array(y_true)
-    y_preds = np.array(y_preds)
+    y_true = decode_one_hot(y_test)
+    y_preds = decode_one_hot(y_preds)
+    
     Class = np.unique(decode_one_hot(y_test))
 
     precision, recall, f1 = metrics(y_test, y_preds)
     
-    
     cm = confusion_matrix(y_true, y_preds, len(Class))
     fig, axs = plt.subplots(2, 2, figsize=(16, 12))
+    fig.suptitle("Evaluation Report")
 
-    sns.heatmap(cm, annot=True, fmt='d', ax=axs[0, 0])
+    sns.heatmap(cm.get() if cuda else cm, annot=True, fmt='d', ax=axs[0, 0])
     axs[0, 0].set_title("Confusion Matrix")
     axs[0, 0].set_xlabel("Predicted Class")
     axs[0, 0].set_ylabel("Actual Class")
     
     if len(Class) == 2:
         fpr, tpr, thresholds = roc_curve(y_true, y_preds)
+        if cuda: fpr, tpr = fpr.get(), tpr.get()
    
         roc_auc = np.trapz(tpr, fpr)
         axs[1, 0].plot(fpr, tpr, color='darkorange', lw=2, label=f'ROC curve (area = {roc_auc:.2f})')
@@ -380,7 +332,8 @@ def plot_evaluate(x_test, y_test, y_preds, acc_list, W, activations):
             
 
             fpr, tpr, thresholds = roc_curve(y_true_copy, y_preds_copy)
-            
+            if cuda: fpr, tpr = fpr.get(), tpr.get()
+
             roc_auc = np.trapz(tpr, fpr)
             axs[1, 0].plot(fpr, tpr, color='darkorange', lw=2, label=f'ROC curve (area = {roc_auc:.2f})')
             axs[1, 0].plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--')
@@ -394,7 +347,7 @@ def plot_evaluate(x_test, y_test, y_preds, acc_list, W, activations):
     
 
     metric = ['Precision', 'Recall', 'F1 Score', 'Accuracy']
-    values = [precision, recall, f1, acc]
+    values = [precision, recall, f1, acc if not cuda else acc.get()]
     colors = ['#1f77b4', '#ff7f0e', '#2ca02c', '#d62728']
     
     
@@ -405,7 +358,7 @@ def plot_evaluate(x_test, y_test, y_preds, acc_list, W, activations):
         axs[0, 1].text(bar.get_x() + bar.get_width() / 2, bar.get_height() - 0.05, f'{value:.2f}',
                        ha='center', va='bottom', fontsize=12, color='white', weight='bold')
     
-    axs[0, 1].set_ylim(0, 1) 
+    axs[0, 1].set_ylim(0, 1)
     axs[0, 1].set_xlabel('Metrics')
     axs[0, 1].set_ylabel('Score')
     axs[0, 1].set_title('Precision, Recall, F1 Score, and Accuracy (Weighted)')
@@ -414,107 +367,99 @@ def plot_evaluate(x_test, y_test, y_preds, acc_list, W, activations):
     feature_indices=[0, 1]
 
     h = .02
+
+    array_type = np if not cuda else cp
     x_min, x_max = x_test[:, feature_indices[0]].min() - 1, x_test[:, feature_indices[0]].max() + 1
     y_min, y_max = x_test[:, feature_indices[1]].min() - 1, x_test[:, feature_indices[1]].max() + 1
-    xx, yy = np.meshgrid(np.arange(x_min, x_max, h),
-                         np.arange(y_min, y_max, h))
-    
-    grid = np.c_[xx.ravel(), yy.ravel()]
+    xx, yy = array_type.meshgrid(array_type.arange(x_min, x_max, h),
+                         array_type.arange(y_min, y_max, h))
 
-    try:
 
-        grid_full = np.zeros((grid.shape[0], x_test.shape[1]))
-        grid_full[:, feature_indices] = grid
-        
-        Z = [None] * len(grid_full)
-
-        predict_progress = initialize_loading_bar(total=len(grid_full),leave=False,
-            bar_format=bar_format_normal ,desc="Predicts For Decision Boundary",ncols= 65)
+    grid = array_type.c_[xx.ravel(), yy.ravel()]
+    grid_full = array_type.zeros((grid.shape[0], x_test.shape[1]), dtype=array_type.float32)
+    grid_full[:, feature_indices] = grid
 
-        for i in range(len(grid_full)):
+    Z = array_type.argmax(predict_from_memory(grid_full, model=model, cuda=cuda), axis=1)
 
-            Z[i] = np.argmax(predict_model_ram(grid_full[i], W=W, activations=activations))
-            predict_progress.update(1)
+    Z = Z.reshape(xx.shape)
 
-        predict_progress.close()
+    if cuda:
+        xx = xx.get()
+        yy = yy.get()
+        Z = Z.get()
+        x_test = x_test.get()
+        y_test_decoded = decode_one_hot(y_test).get()
 
-        Z = np.array(Z)
-        Z = Z.reshape(xx.shape)
+    else:
+        y_test_decoded = decode_one_hot(y_test)
 
-        axs[1,1].contourf(xx, yy, Z, alpha=0.8)
-        axs[1,1].scatter(x_test[:, feature_indices[0]], x_test[:, feature_indices[1]], c=decode_one_hot(y_test), edgecolors='k', marker='o', s=20, alpha=0.9)
-        axs[1,1].set_xlabel(f'Feature {0 + 1}')
-        axs[1,1].set_ylabel(f'Feature {1 + 1}')
-        axs[1,1].set_title('Decision Boundary')
+    axs[1,1].contourf(xx, yy, Z, alpha=0.8)
+    axs[1,1].scatter(x_test[:, feature_indices[0]], x_test[:, feature_indices[1]], c=y_test_decoded, edgecolors='k', marker='o', s=20, alpha=0.9)
+    axs[1,1].set_xlabel(f'Feature {0 + 1}')
+    axs[1,1].set_ylabel(f'Feature {1 + 1}')
+    axs[1,1].set_title('Decision Boundary')
 
-    except Exception as e:
-        print(f"Error: {e}")
 
     plt.show()
 
 
-def plot_decision_boundary(x, y, activations, W, artist=None, ax=None):
-    
-    from .model_operations_cpu import predict_model_ram
-    from .data_operations_cpu import decode_one_hot
+def plot_decision_boundary(x, y, ax, activations, W, artist, model_type, activation_potentiation=False, cuda=False):
     
+    from ..model_ops import get_model_template, predict_from_memory
+
+    if not cuda:
+        from .data_ops import decode_one_hot
+
+    else:
+        from ..cuda.data_ops import decode_one_hot
+
     feature_indices = [0, 1]
 
+    template_model = get_model_template()
+    
+    model = template_model._replace(weights=W,
+                activations=activations,
+                model_type=model_type,
+                activation_potentiation=activation_potentiation)
     h = .02
+    array_type = np if not cuda else cp
     x_min, x_max = x[:, feature_indices[0]].min() - 1, x[:, feature_indices[0]].max() + 1
     y_min, y_max = x[:, feature_indices[1]].min() - 1, x[:, feature_indices[1]].max() + 1
-    xx, yy = np.meshgrid(np.arange(x_min, x_max, h),
-                         np.arange(y_min, y_max, h))
-    
-    grid = np.c_[xx.ravel(), yy.ravel()]
-    grid_full = np.zeros((grid.shape[0], x.shape[1]), dtype=np.float32)
+    xx, yy = array_type.meshgrid(array_type.arange(x_min, x_max, h),
+                         array_type.arange(y_min, y_max, h))
+
+    grid = array_type.c_[xx.ravel(), yy.ravel()]
+    grid_full = array_type.zeros((grid.shape[0], x.shape[1]), dtype=array_type.float32)
     grid_full[:, feature_indices] = grid
-    
-    Z = [None] * len(grid_full)
 
-    for i in range(len(grid_full)):
-        Z[i] = np.argmax(predict_model_ram(grid_full[i], W=W, activations=activations))
+    Z = array_type.argmax(predict_from_memory(grid_full, model=model, cuda=cuda), axis=1)
 
-    Z = np.array(Z, dtype=np.int32)
     Z = Z.reshape(xx.shape)
 
-    if ax is None:
-
-        plt.contourf(xx, yy, Z, alpha=0.8)
-        plt.scatter(x[:, feature_indices[0]], x[:, feature_indices[1]], c=decode_one_hot(y), edgecolors='k', marker='o', s=20, alpha=0.9)
-        plt.xlabel(f'Feature {0 + 1}')
-        plt.ylabel(f'Feature {1 + 1}')
-        plt.title('Decision Boundary')
-
-        plt.show()
+    if cuda:
+        xx = xx.get()
+        yy = yy.get()
+        Z = Z.get()
+        x = x.get()
+        y_test_decoded = decode_one_hot(y).get()
 
     else:
+        y_test_decoded = decode_one_hot(y)
 
-        try:
-            art1_1 = ax[1, 0].contourf(xx, yy, Z, alpha=0.8)
-            art1_2 = ax[1, 0].scatter(x[:, feature_indices[0]], x[:, feature_indices[1]], c=decode_one_hot(y), edgecolors='k', marker='o', s=20, alpha=0.9)
-            ax[1, 0].set_xlabel(f'Feature {0 + 1}')
-            ax[1, 0].set_ylabel(f'Feature {1 + 1}')
-            ax[1, 0].set_title('Decision Boundary')
+    art1_1 = ax.contourf(xx, yy, Z, alpha=0.8)
+    art1_2 = ax.scatter(x[:, feature_indices[0]], x[:, feature_indices[1]], c=y_test_decoded, edgecolors='k', marker='o', s=20, alpha=0.9)
+    ax.set_xlabel(f'Feature {0 + 1}')
+    ax.set_ylabel(f'Feature {1 + 1}')
+    ax.set_title('Decision Boundary')
+    artist.append([*art1_1.collections, art1_2])
 
-            return art1_1, art1_2
-        
-        except:
-
-            art1_1 = ax.contourf(xx, yy, Z, alpha=0.8)
-            art1_2 = ax.scatter(x[:, feature_indices[0]], x[:, feature_indices[1]], c=decode_one_hot(y), edgecolors='k', marker='o', s=20, alpha=0.9)
-            ax.set_xlabel(f'Feature {0 + 1}')
-            ax.set_ylabel(f'Feature {1 + 1}')
-            ax.set_title('Decision Boundary')
-
-
-            return art1_1, art1_2
+    return artist
   
-        
+
 def plot_decision_space(x, y, y_preds=None, s=100, color='tab20'):
     
-    from .metrics_cpu import pca
-    from .data_operations_cpu import decode_one_hot
+    from .metrics import pca
+    from .data_ops import decode_one_hot
     
     if x.shape[1] > 2:
 
@@ -707,7 +652,7 @@ def show():
 
 def initialize_visualization_for_learner(show_history, neurons_history, neural_web_history, x_train, y_train):
 
-    from .data_operations_cpu import find_closest_factors
+    from .data_ops import find_closest_factors
     viz_objects = {}
     
     if show_history:
@@ -823,4 +768,16 @@ def display_visualizations_for_learner(viz_objects, best_weights, data, best_acc
         
         ani5 = ArtistAnimation(web['fig'], web['artists'], interval=interval, blit=True)
         plt.tight_layout()
-        plt.show()
+        plt.show()
+
+
+def display_decision_boundary_history(fig, artist, interval):
+    
+    ani1 = ArtistAnimation(fig, artist, interval=interval, blit=True)
+    plt.tight_layout()
+    plt.show()
+
+
+def create_decision_boundary_hist():
+    fig, ax = plt.subplots()
+    return fig, ax

pyerualjetwork/cuda/__init__.py

@@ -0,0 +1,24 @@
+"""
+CUDA
+====
+The modules contained in this folder and their functions compute data on a graphics processing unit with CUDA technology and a installed CUDA toolkit, storing it in the GPU's VRAM.
+
+Modules in the folder:
+----------------------
+- activation_functions
+- data_ops
+- loss_functions
+- metrics
+- visualizations
+
+Examples: https://github.com/HCB06/PyerualJetwork/tree/main/Welcome_to_PyerualJetwork/ExampleCodes
+
+PyerualJetwork document: https://github.com/HCB06/PyerualJetwork/blob/main/Welcome_to_PyerualJetwork/PYERUALJETWORK_USER_MANUEL_AND_LEGAL_INFORMATION(EN).pdf
+
+- Creator: Hasan Can Beydili
+- YouTube: https://www.youtube.com/@HasanCanBeydili
+- Linkedin: https://www.linkedin.com/in/hasan-can-beydili-77a1b9270/
+- Instagram: https://www.instagram.com/canbeydilj
+- Contact: tchasancan@gmail.com
+
+"""

pyerualjetwork/{activation_functions_cuda.py → cuda/activation_functions.py}

@@ -1,4 +1,44 @@
+"""
+
+Activation Functions on CUDA
+============================
+This module contains activation functions that run on the CUDA GPU.
+
+
+Module functions:
+-----------------
+- 'sigmoid': Sigmoid,
+- 'mod_circular': modular_circular_activation,
+- 'tanh_circular': tanh_circular_activation,
+- 'leaky_relu': leaky_relu,
+- 'relu': Relu,
+- 'gelu': gelu,
+- 'tanh': tanh,
+- 'sinakt': sinakt,
+- 'p_squared': p_squared,
+- 'sglu': lambda x: sglu(x, alpha=1.0),
+- 'dlrelu': dlrelu,
+- 'sin_plus': sin_plus,
+- 'acos': lambda x: acos(x, alpha=1.0, beta=0.0),
+- 'isra': isra,
+- 'waveakt': waveakt,
+- 'arctan': arctan,
+- 'bent_identity': bent_identity,
+- 'softsign': softsign,
+- 'pwl': pwl,
+- 'sine': sine,
+- 'tanh_square': tanh_square,
+- 'linear':,
+- 'sine_square': sine_square,
+- 'logarithmic': logarithmic,
+- 'sine_offset': lambda x: sine_offset(x, 1.0),
+- 'spiral': spiral_activation,
+- 'circular': circular_activation
+- Softmax()
+"""
+
 import cupy as cp
+import numpy as np
 from scipy.special import expit, softmax
 import warnings
 
@@ -81,6 +121,9 @@ def sin_plus(x):
 def modular_circular_activation(x, period=2*cp.pi):
     return cp.mod(x, period) / period
 
+def gelu(x):
+    return 0.5 * x * (1 + cp.tanh(cp.sqrt(2 / cp.pi) * (x + 0.044715 * cp.power(x, 3))))
+
 def tanh_circular_activation(x):
     return (cp.tanh(x) + 1) / 2
 
@@ -201,13 +244,19 @@ def apply_activation(Input, activation_list):
     
     try:
         
-        valid_mask = cp.array([act in activation_functions for act in activation_list])
-        valid_activations = cp.array(activation_list)[valid_mask]
+        if isinstance(activation_list, str):
+            activation_list = [activation_list]
 
-        activation_outputs = cp.array([activation_functions[act](origin_input) for act in valid_activations])
+        activation_list = [str(act).lower() for act in activation_list]
 
-        return cp.sum(activation_outputs, axis=0)
-        
+        valid_activations = [act for act in activation_list if act in activation_functions]
+
+        result = origin_input
+        for act in valid_activations:
+            result = activation_functions[act](result)
+            
+        return result
+                
     except Exception as e:
         warnings.warn(f"Error in activation processing: {str(e)}", RuntimeWarning)
         return Input

pyerualjetwork/{data_operations_cuda.py → cuda/data_ops.py}

@@ -21,7 +21,7 @@ Examples: https://github.com/HCB06/PyerualJetwork/tree/main/Welcome_to_PyerualJe
 
 PyerualJetwork document: https://github.com/HCB06/Anaplan/blob/main/Welcome_to_Anaplan/ANAPLAN_USER_MANUEL_AND_LEGAL_INFORMATION(EN).pdf
 
-- Author: Hasan Can Beydili
+- Creator: Hasan Can Beydili
 - YouTube: https://www.youtube.com/@HasanCanBeydili
 - Linkedin: https://www.linkedin.com/in/hasan-can-beydili-77a1b9270/
 - Instagram: https://www.instagram.com/canbeydilj
@@ -47,7 +47,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_ops import optimize_labels, transfer_to_cpu
     
     y_train = transfer_to_cpu(y_train,dtype=y_train.dtype)
     y_test = transfer_to_cpu(y_test,dtype=y_test.dtype)
@@ -113,7 +113,7 @@ def split(X, y, test_size, random_state=42, dtype=cp.float32, shuffle_in_cpu=Fal
     Returns:
         tuple: x_train, x_test, y_train, y_test as ordered training and testing data subsets.
     """
-    from .memory_operations import transfer_to_gpu, optimize_labels
+    from memory_ops import transfer_to_gpu, optimize_labels
     
     X = transfer_to_gpu(X, dtype=dtype)
     y = optimize_labels(y, one_hot_encoded=False, cuda=True)
@@ -172,8 +172,8 @@ def manuel_balancer(x_train, y_train, target_samples_per_class, dtype=cp.float32
         x_balanced -- Balanced input dataset (cupy array format)
         y_balanced -- Balanced class labels (one-hot encoded, cupy array format)
     """
-    from .ui import loading_bars, get_loading_bar_style
-    from .memory_operations import transfer_to_gpu
+    from ..ui import loading_bars, get_loading_bar_style
+    from ..memory_ops import transfer_to_gpu
     
     bar_format = loading_bars()[0]
     x_train = transfer_to_gpu(x_train, dtype=dtype)
@@ -261,8 +261,8 @@ def auto_balancer(x_train, y_train, dtype=cp.float32, shuffle_in_cpu=False):
     tuple: A tuple containing balanced input data and labels.
     """
 
-    from .ui import loading_bars, get_loading_bar_style
-    from .memory_operations import transfer_to_gpu
+    from ..ui import loading_bars, get_loading_bar_style
+    from ..memory_ops import transfer_to_gpu
     
     x_train = transfer_to_gpu(x_train, dtype=dtype)
     y_train = transfer_to_gpu(y_train, dtype=y_train.dtype)
@@ -331,8 +331,8 @@ def synthetic_augmentation(x_train, y_train, dtype=cp.float32, shuffle_in_cpu=Fa
     Returns:
         x_train_balanced, y_train_balanced (cupy array format)
     """
-    from .ui import loading_bars, get_loading_bar_style
-    from .memory_operations import transfer_to_gpu
+    from ..ui import loading_bars, get_loading_bar_style
+    from ..memory_ops import transfer_to_gpu
     
     x = transfer_to_gpu(x_train, dtype=dtype)
     y = transfer_to_gpu(y_train, dtype=y_train.dtype)
@@ -484,20 +484,20 @@ def find_closest_factors(a):
             j = a // i
             return i, j
         
-def batcher(x_test, y_test, batch_size=1):
+def batcher(x, y, batch_size=1):
 
     if batch_size == 1:
-        return x_test, y_test
+        return x, y
 
-    y_labels = cp.argmax(y_test, axis=1)
+    y_labels = cp.argmax(y, axis=1)
     
     unique_labels = cp.unique(y_labels)
     total_samples = sum(
         int(cp.sum(y_labels == class_label) * batch_size) for class_label in unique_labels
     )
     
-    sampled_x = cp.empty((total_samples, x_test.shape[1]), dtype=x_test.dtype)
-    sampled_y = cp.empty((total_samples, y_test.shape[1]), dtype=y_test.dtype)
+    sampled_x = cp.empty((total_samples, x.shape[1]), dtype=x.dtype)
+    sampled_y = cp.empty((total_samples, y.shape[1]), dtype=y.dtype)
     
     offset = 0
     for class_label in unique_labels:
@@ -507,8 +507,8 @@ def batcher(x_test, y_test, batch_size=1):
         
         sampled_indices = cp.random.choice(class_indices, num_samples, replace=False)
         
-        sampled_x[offset:offset + num_samples] = x_test[sampled_indices]
-        sampled_y[offset:offset + num_samples] = y_test[sampled_indices]
+        sampled_x[offset:offset + num_samples] = x[sampled_indices]
+        sampled_y[offset:offset + num_samples] = y[sampled_indices]
 
         offset += num_samples
     

pyerualjetwork/{metrics_cuda.py → cuda/metrics.py}

@@ -1,7 +1,7 @@
 import cupy as cp
 
 def metrics(y_ts, test_preds, average='weighted'):
-    from .data_operations_cpu import decode_one_hot
+    from .data_ops import decode_one_hot
     y_test_d = cp.array(decode_one_hot(y_ts))
     y_pred = cp.array(test_preds)