pyerualjetwork 4.1.4__py3-none-any.whl → 4.1.6__py3-none-any.whl

pyerualjetwork/visualizations_cuda.py

@@ -1,6 +1,7 @@
 import networkx as nx
 import matplotlib.pyplot as plt
 import cupy as cp
+import numpy as np
 from scipy.spatial import ConvexHull
 import seaborn as sns
 from matplotlib.animation import ArtistAnimation
@@ -31,7 +32,7 @@ def draw_neural_web(W, ax, G, return_objs=False):
     art1, art2, art3 = draw_neural_web(W, ax, G, return_objs=True)
     plt.show()
     """
-
+    W = W.get()
     for i in range(W.shape[0]):
         for j in range(W.shape[1]):
             if W[i, j] != 0:
@@ -40,6 +41,7 @@ def draw_neural_web(W, ax, G, return_objs=False):
     edges = G.edges(data=True)
     weights = [edata['ltpw'] for _, _, edata in edges]
     pos = {}
+
     num_motor_neurons = W.shape[0]
     num_sensory_neurons = W.shape[1]
 
@@ -68,128 +70,114 @@ def draw_neural_web(W, ax, G, return_objs=False):
         return art1, art2, art3
 
 
-def draw_model_architecture(model_name, model_path='', style='basic'):
+def draw_model_architecture(model_name, model_path=''):
     """
-    Visualizes the architecture of a neural network model.
-
-    Parameters
-    ----------
-    model_name : str
-        The name of the model to be visualized, which will be displayed in the title or label.
-    
-    model_path : str
-        The file path to the model, from which the architecture is loaded. Default is ''
-    
-    style : str, optional
-        The style of the visualization. 
-        Options:
-            - 'basic': Displays a simplified view of the model architecture.
-            - 'detailed': Shows a more comprehensive view, including layer details and parameters.
-        Default is 'basic'.
-    
-    Returns
-    -------
-    None
-        Draws and displays the architecture of the specified model.
-
-        
-    Examples
-    --------
-    >>> draw_model_architecture("MyModel", "path/to/model", style='detailed')
+    The `draw_model_architecture` function visualizes the architecture of a neural network model with
+    multiple inputs based on activation functions.
+    
+    :param model_name: The `model_name` parameter in the `draw_model_architecture` function is used to
+    specify the name of the neural network model whose architecture you want to visualize. This function
+    visualizes the architecture of a neural network model with multiple inputs based on activation
+    functions
+    :param model_path: The `model_path` parameter in the `draw_model_architecture` function is used to
+    specify the path where the neural network model is saved. If the model is saved in a specific
+    directory or file location, you can provide that path as a string when calling the function. If the
+    model is saved
+    """
+    """
+    Visualizes the architecture of a neural network model with multiple inputs based on activation functions.
     """
-    from .plan_cuda import get_scaler, get_act_pot, get_weights
-    from .model_operations_cuda import load_model
+    
+    from .model_operations_cuda import load_model, get_scaler, get_act_pot, get_weights
     
     model = load_model(model_name=model_name, model_path=model_path)
     
     W = model[get_weights()]
     activation_potentiation = model[get_act_pot()]
     scaler_params = model[get_scaler()]
-
-    text_1 = f"Input Shape:\n{W.shape[1]}"
-    text_2 = f"Output Shape:\n{W.shape[0]}"
-
-    if scaler_params is None:
-        bottom_left_text = 'Standard Scaler=No'
-    else:
-        bottom_left_text = 'Standard Scaler=Yes'
-
-    if len(activation_potentiation) != 1 or (len(activation_potentiation) == 1 and activation_potentiation[0] != 'linear'):
-
-        bottom_left_text_1 = f'Aggregation Layers(Aggregates All Conversions)={len(activation_potentiation)}'
-
-    else:
-
-        bottom_left_text_1 = 'Aggregation Layers(Aggregates All Conversions)=0'
-
-    bottom_left_text_2 = 'Potentiation Layer(Fully Connected)=1'
-
-    if scaler_params is None:
-        bottom_left_text = 'Standard Scaler=No'
-    else:
-        bottom_left_text = 'Standard Scaler=Yes'
-
-    num_middle_axes = len(activation_potentiation)
-
-    if style == 'detailed':
-
-        col = 1
-
-    elif style == 'basic':
     
-        col = 2
-
-    fig, axes = plt.subplots(1, num_middle_axes + col, figsize=(5 * (num_middle_axes + 2), 5))
-
-    fig.suptitle("Model Architecture", fontsize=16, fontweight='bold')
-
-    for i, activation in enumerate(activation_potentiation):
-        x = cp.linspace(-100, 100, 100)
-        translated_x_train = draw_activations(x, activation)
-        y = translated_x_train
+    # Calculate dimensions based on number of activation functions
+    num_activations = len(activation_potentiation)
+    input_groups = num_activations  # Number of input groups equals number of activations
+    num_inputs = W.shape[1]
 
-        axes[i].plot(x, y, color='b', markersize=6, linewidth=2, label='Activations Over Depth')
-        axes[i].set_title(activation_potentiation[i])
-
-        axes[i].spines['top'].set_visible(False)
-        axes[i].spines['right'].set_visible(False)
-        axes[i].spines['left'].set_visible(False)
-        axes[i].spines['bottom'].set_visible(False)
-        axes[i].get_xaxis().set_visible(False)
-        axes[i].get_yaxis().set_visible(False)
+    # Create figure
+    fig = plt.figure(figsize=(15, 10))
+    
+    # Calculate positions for nodes
+    def get_node_positions():
+        positions = {}
         
-
-        if i < num_middle_axes - 1:
-            axes[i].annotate('', xy=(1.05, 0.5), xytext=(0.95, 0.5), 
-                            xycoords='axes fraction', textcoords='axes fraction',
-                            arrowprops=dict(arrowstyle="->", color='black', lw=1.5))
+        # Input layer positions
+        total_height = 0.8  # Maksimum dikey alan
+        group_height = total_height / input_groups  # Her grup için ayrılan dikey alan
+        input_spacing = min(group_height / (num_inputs + 1), 0.1)  # Her girdi arasındaki mesafe
+        
+        for group in range(input_groups):
+            group_start_y = 0.9 - (group * group_height)  # Grubun başlangıç y koordinatı
+            for i in range(num_inputs):
+                y_pos = group_start_y - ((i + 1) * input_spacing)
+                positions[f'input_{group}_{i}'] = (0.2, y_pos)
+        
+        # Aggregation layer positions
+        agg_spacing = total_height / (num_inputs + 1)
+        for i in range(num_inputs):
+            positions[f'summed_{i}'] = (0.5, 0.9 - ((i + 1) * agg_spacing))
+        
+        # Output layer positions
+        output_spacing = total_height / (W.shape[0] + 1)
+        for i in range(W.shape[0]):
+            positions[f'output_{i}'] = (0.8, 0.9 - ((i + 1) * output_spacing))
+        
+        return positions
+    
+    # Draw the network
+    pos = get_node_positions()
+    
+    # Draw nodes
+    for group in range(input_groups):
+        # Draw input nodes
+        for i in range(num_inputs):
+            plt.plot(*pos[f'input_{group}_{i}'], 'o', color='lightgreen', markersize=20)
+            plt.text(pos[f'input_{group}_{i}'][0] - 0.05, pos[f'input_{group}_{i}'][1], 
+                    f'Input #{i+1} ({activation_potentiation[group]})', ha='right', va='center')
+            
+            # Draw connections from input to summed input directly
+            plt.plot([pos[f'input_{group}_{i}'][0], pos[f'summed_{i}'][0]],
+                    [pos[f'input_{group}_{i}'][1], pos[f'summed_{i}'][1]], 'k-')
+            # Draw aggregation nodes
+            if group == 0:
+                plt.plot(*pos[f'summed_{i}'], 'o', color='lightgreen', markersize=20)
+                plt.text(pos[f'summed_{i}'][0], pos[f'summed_{i}'][1] + 0.02,
+                        f'Summed\nInput #{i+1}', ha='center', va='bottom')
+    
+    # Draw output nodes and connections
+    for i in range(W.shape[0]):
+        plt.plot(*pos[f'output_{i}'], 'o', color='gold', markersize=20)
+        plt.text(pos[f'output_{i}'][0] + 0.05, pos[f'output_{i}'][1],
+                f'Output #{i+1}', ha='left', va='center', color='purple')
+        
+        # Connect all aggregation nodes to each output
+        for group in range(num_inputs):
+            plt.plot([pos[f'summed_{group}'][0], pos[f'output_{i}'][0]],
+                    [pos[f'summed_{group}'][1], pos[f'output_{i}'][1]], 'k-')
     
-    if style == 'detailed':
+    # Add labels and annotations
+    plt.text(0.2, 0.95, 'Input Layer', ha='center', va='bottom', fontsize=12)
+    plt.text(0.5, 0.95, 'Aggregation\nLayer', ha='center', va='bottom', fontsize=12)
+    plt.text(0.8, 0.95, 'Output Layer', ha='center', va='bottom', fontsize=12)
     
-        G = nx.Graph()
-        draw_neural_web(W=W, ax=axes[num_middle_axes], G=G)
-
-    elif style == 'basic':
-    
-        circle1 = plt.Circle((0.5, 0.5), 0.4, color='skyblue', ec='black', lw=1.5)
-        axes[num_middle_axes].add_patch(circle1)
-        axes[num_middle_axes].text(0.5, 0.5, text_1, ha='center', va='center', fontsize=12)
-        axes[num_middle_axes].set_xlim(0, 1)
-        axes[num_middle_axes].set_ylim(0, 1)
-        axes[num_middle_axes].axis('off') 
-
-        circle2 = plt.Circle((0.5, 0.5), 0.4, color='lightcoral', ec='black', lw=1.5)
-        axes[-1].add_patch(circle2)
-        axes[-1].text(0.5, 0.5, text_2, ha='center', va='center', fontsize=12)
-        axes[-1].set_xlim(0, 1)
-        axes[-1].set_ylim(0, 1)
-        axes[-1].axis('off') 
-  
-     
-    fig.text(0.01, 0, bottom_left_text, ha='left', va='bottom', fontsize=10)
-    fig.text(0.01, 0.04, bottom_left_text_1, ha='left', va='bottom', fontsize=10)
-    fig.text(0.01, 0.08, bottom_left_text_2, ha='left', va='bottom', fontsize=10)
+    # Remove axes
+    plt.axis('off')
+    
+    # Add model information
+    if scaler_params is None:
+        plt.text(0.95, 0.05, 'Standard Scaler=No', fontsize=10, ha='right', va='bottom')
+    else:
+        plt.text(0.95, 0.05, 'Standard Scaler=Yes', fontsize=10, ha='right', va='bottom')
 
+    # Add model architecture title
+    plt.text(0.95, 0.1, f"PLAN Model Architecture: {model_name}", fontsize=12, ha='right', va='bottom', fontweight='bold')
     plt.tight_layout()
     plt.show()
     
@@ -348,8 +336,8 @@ def plot_evaluate(x_test, y_test, y_preds, acc_list, W, activation_potentiation)
     acc = acc_list[len(acc_list) - 1]
     y_true = decode_one_hot(y_test)
 
-    y_true = cp.array(y_true)
-    y_preds = cp.array(y_preds)
+    y_true = cp.array(y_true, copy=True)
+    y_preds = cp.array(y_preds, copy=True)
     Class = cp.unique(decode_one_hot(y_test))
 
     precision, recall, f1 = metrics(y_test, y_preds)
@@ -358,7 +346,7 @@ def plot_evaluate(x_test, y_test, y_preds, acc_list, W, activation_potentiation)
     cm = confusion_matrix(y_true, y_preds, len(Class))
     fig, axs = plt.subplots(2, 2, figsize=(16, 12))
 
-    sns.heatmap(cm, annot=True, fmt='d', ax=axs[0, 0])
+    sns.heatmap(cm.get(), 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")
@@ -393,7 +381,7 @@ def plot_evaluate(x_test, y_test, y_preds, acc_list, W, activation_potentiation)
             fpr, tpr, thresholds = roc_curve(y_true_copy, y_preds_copy)
             
             roc_auc = cp.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(fpr.get(), tpr.get(), 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='--')
             axs[1, 0].set_xlim([0.0, 1.0])
             axs[1, 0].set_ylim([0.0, 1.05])
@@ -405,7 +393,7 @@ def plot_evaluate(x_test, y_test, y_preds, acc_list, W, activation_potentiation)
     
 
     metric = ['Precision', 'Recall', 'F1 Score', 'Accuracy']
-    values = [precision, recall, f1, acc]
+    values = [precision, recall, f1, acc.get()]
     colors = ['#1f77b4', '#ff7f0e', '#2ca02c', '#d62728']
     
     
@@ -432,35 +420,29 @@ def plot_evaluate(x_test, y_test, y_preds, acc_list, W, activation_potentiation)
     
     grid = cp.c_[xx.ravel(), yy.ravel()]
 
-    try:
-
-        grid_full = cp.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_full = cp.zeros((grid.shape[0], x_test.shape[1]), dtype=cp.float32)
+    grid_full[:, feature_indices] = grid
+    
+    Z = [None] * len(grid_full)
 
-        for i in range(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)
 
-            Z[i] = cp.argmax(predict_model_ram(grid_full[i], W=W, activation_potentiation=activation_potentiation))
-            predict_progress.update(1)
+    for i in range(len(grid_full)):
 
-        predict_progress.close()
+        Z[i] = cp.argmax(predict_model_ram(grid_full[i], W=W, activation_potentiation=activation_potentiation))
+        predict_progress.update(1)
 
-        Z = cp.array(Z)
-        Z = Z.reshape(xx.shape)
+    predict_progress.close()
 
-        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')
+    Z = cp.array(Z)
+    Z = Z.reshape(xx.shape)
 
-    except Exception as e:
-        # Hata meydana geldiğinde yapılacak işlemler
-        print(f"Hata oluştu: {e}")
+    axs[1,1].contourf(xx.get(), yy.get(), Z.get(), alpha=0.8)
+    axs[1,1].scatter(x_test[:, feature_indices[0]].get(), x_test[:, feature_indices[1]].get(), c=decode_one_hot(y_test).get(), 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')
 
     plt.show()
 
@@ -487,13 +469,13 @@ def plot_decision_boundary(x, y, activation_potentiation, W, artist=None, ax=Non
     for i in range(len(grid_full)):
         Z[i] = cp.argmax(predict_model_ram(grid_full[i], W=W, activation_potentiation=activation_potentiation))
 
-    Z = cp.array(Z)
+    Z = cp.array(Z, dtype=cp.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.contourf(xx.get(), yy.get(), Z.get(), alpha=0.8)
+        plt.scatter(x[:, feature_indices[0]].get(), x[:, feature_indices[1]].get(), c=decode_one_hot(y).get(), 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')
@@ -503,8 +485,8 @@ def plot_decision_boundary(x, y, activation_potentiation, W, artist=None, ax=Non
     else:
 
         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)
+            art1_1 = ax[1, 0].contourf(xx.get(), yy.get(), Z.get(), alpha=0.8)
+            art1_2 = ax[1, 0].scatter(x[:, feature_indices[0]].get(), x[:, feature_indices[1]].get(), c=decode_one_hot(y).get(), 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')
@@ -513,11 +495,11 @@ def plot_decision_boundary(x, y, activation_potentiation, W, artist=None, ax=Non
         
         except:
 
-            art1_1 = ax[0].contourf(xx, yy, Z, alpha=0.8)
-            art1_2 = ax[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[0].set_xlabel(f'Feature {0 + 1}')
-            ax[0].set_ylabel(f'Feature {1 + 1}')
-            ax[0].set_title('Decision Boundary')
+            art1_1 = ax.contourf(xx.get(), yy.get(), Z.get(), alpha=0.8)
+            art1_2 = ax.scatter(x[:, feature_indices[0]].get(), x[:, feature_indices[1]].get(), c=decode_one_hot(y).get(), 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
@@ -558,7 +540,7 @@ def plot_decision_space(x, y, y_preds=None, s=100, color='tab20'):
             if y_preds[i] == cls:
                 class_points.append(X_pca[i])
         
-        class_points = cp.array(class_points)
+        class_points = cp.array(class_points, dtype=y.dtype)
         
 
         if len(class_points) > 2:
@@ -574,20 +556,20 @@ def plot_decision_space(x, y, y_preds=None, s=100, color='tab20'):
     plt.draw()
     
         
-def neuron_history(LTPW, ax1, row, col, class_count, artist5, data, fig1, acc=False, loss=False):
+def update_neuron_history(LTPW, ax1, row, col, class_count, artist5, fig1, acc=False, loss=False):
 
-    for j in range(len(class_count)):
+    for j in range(class_count):
         
             if acc != False and loss != False:
-                suptitle_info = data + ' Accuracy:' + str(acc) + '\n' + data + ' Loss:' + str(loss) + '\nNeurons Memory:'
+                suptitle_info = ' Accuracy:' + str(acc) + '\n' + '\nNeurons Memory:'
             else:
                 suptitle_info = 'Neurons Memory:'
 
-            mat = LTPW[j,:].reshape(row, col)
+            mat = LTPW[j,:].reshape(row, col).get()
 
             title_info = f'{j+1}. Neuron'
             
-            art5 = ax1[j].imshow(mat.get(), interpolation='sinc', cmap='viridis')
+            art5 = ax1[j].imshow(mat, interpolation='sinc', cmap='viridis')
 
             ax1[j].set_aspect('equal')
             ax1[j].set_xticks([])
@@ -599,17 +581,15 @@ def neuron_history(LTPW, ax1, row, col, class_count, artist5, data, fig1, acc=Fa
 
     fig1.suptitle(suptitle_info, fontsize=16)
 
-    return artist5
-
 
 def initialize_visualization_for_fit(val, show_training, neurons_history, x_train, y_train):
     """Initializes the visualization setup based on the parameters."""
-    from .data_operations import find_closest_factors
+    from .data_operations_cuda import find_closest_factors
     visualization_objects = {}
 
-    if show_training:
+    if show_training or neurons_history:
         if not val:
-            raise ValueError("For showing training, 'val' parameter must be True.")
+            raise ValueError("For showing training or neurons history, 'val' parameter must be True.")
 
         G = nx.Graph()
         fig, ax = plt.subplots(2, 2)
@@ -626,7 +606,7 @@ def initialize_visualization_for_fit(val, show_training, neurons_history, x_trai
 
     if neurons_history:
         row, col = find_closest_factors(len(x_train[0]))
-        fig1, ax1 = plt.subplots(1, len(set(y_train)), figsize=(18, 14))
+        fig1, ax1 = plt.subplots(1, len(y_train[0]), figsize=(18, 14))
         visualization_objects.update({
             'fig1': fig1,
             'ax1': ax1,
@@ -640,10 +620,21 @@ def initialize_visualization_for_fit(val, show_training, neurons_history, x_trai
 
 def update_weight_visualization_for_fit(ax, LTPW, artist2):
     """Updates the weight visualization plot."""
-    art2 = ax.imshow(LTPW, interpolation='sinc', cmap='viridis')
+    art2 = ax.imshow(LTPW.get(), interpolation='sinc', cmap='viridis')
     artist2.append([art2])
 
+def show():
+    plt.tight_layout()
+    plt.show()
 
+def update_neural_web_for_fit(W, ax, G, artist):
+    """
+    The function `update_neural_web_for_fit` updates a neural web visualization for fitting.
+    """
+    art5_1, art5_2, art5_3 = draw_neural_web(W=W, ax=ax, G=G, return_objs=True)
+    art5_list = [art5_1] + [art5_2] + list(art5_3.values())
+    artist.append(art5_list)
+    
 def update_decision_boundary_for_fit(ax, x_val, y_val, activation_potentiation, LTPW, artist1):
     """Updates the decision boundary visualization."""
     art1_1, art1_2 = plot_decision_boundary(x_val, y_val, activation_potentiation, LTPW, artist=artist1, ax=ax)
@@ -652,10 +643,13 @@ def update_decision_boundary_for_fit(ax, x_val, y_val, activation_potentiation,
 
 def update_validation_history_for_fit(ax, val_list, artist3):
     """Updates the validation accuracy history plot."""
-    period = list(range(1, len(val_list) + 1))
+    val_list_cpu = []
+    for i in range(len(val_list)):
+        val_list_cpu.append(val_list[i].get())
+    period = list(range(1, len(val_list_cpu) + 1))
     art3 = ax.plot(
         period, 
-        val_list, 
+        val_list_cpu, 
         linestyle='--', 
         color='g', 
         marker='o', 
@@ -673,14 +667,38 @@ def update_validation_history_for_fit(ax, val_list, artist3):
 def display_visualization_for_fit(fig, artist_list, interval):
     """Displays the animation for the given artist list."""
     ani = ArtistAnimation(fig, artist_list, interval=interval, blit=True)
-    plt.tight_layout()
-    plt.show()
+    return ani
 
+def update_neuron_history_for_learner(LTPW, ax1, row, col, class_count, artist5, data, fig1, acc=False, loss=False):
 
+    for j in range(len(class_count)):
+        
+            if acc != False and loss != False:
+                suptitle_info = data + ' Accuracy:' + str(acc) + '\n' + data + ' Loss:' + str(loss) + '\nNeurons Memory:'
+            else:
+                suptitle_info = 'Neurons Memory:'
+
+            mat = LTPW[j,:].reshape(row, col)
+
+            title_info = f'{j+1}. Neuron'
+            
+            art5 = ax1[j].imshow(mat.get(), interpolation='sinc', cmap='viridis')
+
+            ax1[j].set_aspect('equal')
+            ax1[j].set_xticks([])
+            ax1[j].set_yticks([])
+            ax1[j].set_title(title_info)
+
+           
+            artist5.append([art5])
+
+    fig1.suptitle(suptitle_info, fontsize=16)
+
+    return artist5
 
 def initialize_visualization_for_learner(show_history, neurons_history, neural_web_history, x_train, y_train):
     """Initialize all visualization components"""
-    from .data_operations import find_closest_factors
+    from .data_operations_cuda import find_closest_factors
     viz_objects = {}
     
     if show_history:
@@ -726,13 +744,19 @@ def update_history_plots_for_learner(viz_objects, depth_list, loss_list, best_ac
         return
     
     hist = viz_objects['history']
-    
+    for i in range(len(loss_list)):
+        loss_list[i] = loss_list[i].get()
+
     # Loss plot
     art1 = hist['ax'][0].plot(depth_list, loss_list, color='r', markersize=6, linewidth=2)
     hist['ax'][0].set_title('Test Loss Over Depth')
     hist['artist1'].append(art1)
     
     # Accuracy plot
+
+    for i in range(len(best_acc_per_depth_list)):
+        best_acc_per_depth_list[i] = best_acc_per_depth_list[i].get()
+
     art2 = hist['ax'][1].plot(depth_list, best_acc_per_depth_list, color='g', markersize=6, linewidth=2)
     hist['ax'][1].set_title('Test Accuracy Over Depth')
     hist['artist2'].append(art2)
@@ -743,7 +767,7 @@ def update_history_plots_for_learner(viz_objects, depth_list, loss_list, best_ac
     for activation in final_activations:
         translated_x_train += draw_activations(x, activation)
     
-    art3 = hist['ax'][2].plot(x, translated_x_train, color='b', markersize=6, linewidth=2)
+    art3 = hist['ax'][2].plot(x.get(), translated_x_train.get(), color='b', markersize=6, linewidth=2)
     hist['ax'][2].set_title('Potentiation Shape Over Depth')
     hist['artist3'].append(art3)
 
@@ -765,8 +789,8 @@ def display_visualizations_for_learner(viz_objects, best_weights, data, best_acc
     if 'neurons' in viz_objects:
         neurons = viz_objects['neurons']
         for _ in range(10):
-            neurons['artists'] = neuron_history(
-                cp.copy(best_weights), 
+            neurons['artists'] = update_neuron_history_for_learner(
+                cp.copy(best_weights),
                 neurons['ax'],
                 neurons['row'],
                 neurons['col'],