pyerualjetwork 4.1.5__py3-none-any.whl → 4.1.7__py3-none-any.whl

pyerualjetwork/memory_operations.py

@@ -1,33 +1,29 @@
 import psutil
 import numpy as np
 import cupy as cp
-import gc
 import logging
 
-def get_available_memory():
+def get_available_cpu_memory():
     """
     The function `get_available_memory` returns the amount of available memory in the system using the
     `psutil` library.
     :return: The function `get_available_memory()` returns the amount of available memory in bytes on
     the system.
     """
-    memory = psutil.virtual_memory().available
-    return memory
+    return psutil.virtual_memory().available
 
 def get_optimal_batch_size_for_cpu(x, data_size_bytes, available_memory):
     """
     The function calculates the optimal batch size for a given data size and available memory based on
     the size of each element.
     
-    :param x: `x` is a NumPy array representing the input data for which we want to determine the
-    optimal batch size for processing on the CPU
-    :param data_size_bytes: The `data_size_bytes` parameter represents the size of the data in bytes
-    that you want to process in batches
-    :param available_memory: The `available_memory` parameter represents the total memory available on
-    the CPU in bytes. This function calculates the optimal batch size for processing data based on the
-    provided parameters. Let me know if you need any further assistance or explanation!
-    :return: the optimal batch size for a given array `x` based on the available memory and the size of
-    each element in bytes.
+    :param x: `x` is a NumPy array representing the input data for which we want to determine the optimal batch size for processing on the CPU
+    
+    :param data_size_bytes: The `data_size_bytes` parameter represents the size of the data in bytes that you want to process in batches
+    
+    :param available_memory: The `available_memory` parameter represents the total memory available on the CPU in bytes. This function calculates the optimal batch size for processing data based on the provided parameters. Let me know if you need any further assistance or explanation!
+    
+    :return: the optimal batch size for a given array `x` based on the available memory and the size of each element in bytes.
     """
     safe_memory = available_memory * 0.25
     element_size = data_size_bytes / x.size
@@ -36,62 +32,92 @@ def get_optimal_batch_size_for_cpu(x, data_size_bytes, available_memory):
 def transfer_to_cpu(x, dtype=np.float32):
     """
     The `transfer_to_cpu` function converts data to a specified data type on the CPU, handling memory constraints
-    by batching the conversion process.
+    by batching the conversion process and ensuring complete GPU memory cleanup.
+   
+    :param x: Input data to transfer to CPU (CuPy array)
+    
+    :param dtype: Target NumPy dtype for the output array (default: np.float32)
     
-    :param x: The `x` parameter in the `transfer_to_cpu` function is the input data that you want to transfer to
-    the CPU. It can be either a NumPy array or any other data structure that supports the `get` method
-    for retrieving the data
-    :param dtype: The `dtype` parameter in the `transfer_to_cpu` function specifies the data type to which the
-    input array `x` should be converted before moving it to the CPU. By default, it is set to
-    `np.float32`, which is a 32-bit floating-point number data type in NumPy
-    :return: The `transfer_to_cpu` function returns the processed data in NumPy array format with the specified
-    data type (`dtype`). If the input `x` is already a NumPy array with the same data type as specified,
-    it returns `x` as is. Otherwise, it converts the input data to the specified data type and returns
-    the processed NumPy array.
+    :return: NumPy array with the specified dtype
     """
+    from .ui import loading_bars, initialize_loading_bar
     try:
         if isinstance(x, np.ndarray):
             return x.astype(dtype) if x.dtype != dtype else x
-            
-        data_size = x.nbytes
-        available_memory = get_available_memory()
+
+        x = x.astype(dtype=dtype, copy=False)
         
+        data_size = x.nbytes
+        available_memory = get_available_cpu_memory()
         logging.debug(f"Data size: {data_size/1e6:.2f}MB, Available memory: {available_memory/1e6:.2f}MB")
         
+        pool = cp.get_default_memory_pool()
+        pinned_mempool = cp.cuda.PinnedMemoryPool()
+        
         if data_size <= available_memory * 0.25:
-            final_result = np.array(x.get(), dtype=dtype, copy=False)
-            del x
-            cp.get_default_memory_pool().free_all_blocks()
+            try:
+                final_result = np.array(x.get(), dtype=dtype, copy=False)
+            finally:
+                del x
+                pool.free_all_blocks()
+                pinned_mempool.free_all_blocks()
+                cp.cuda.runtime.deviceSynchronize()
             return final_result
-            
-        batch_size = get_optimal_batch_size_for_cpu(x, data_size, available_memory)
+        
+        batch_size = max(get_optimal_batch_size_for_cpu(x, data_size, available_memory), 1)
+        total_batches = (len(x) + batch_size - 1) // batch_size
+        loading_bar = initialize_loading_bar(
+            total=total_batches,
+            desc='Transfering to CPU mem',
+            ncols=70,
+            bar_format=loading_bars()[0],
+            leave=False
+        )
         logging.debug(f"Using batch size: {batch_size}")
         
-        result = []
-        total_batches = (x.size + batch_size - 1) // batch_size
+        try:
+            sample_chunk = x[0:1]
+            sample_array = np.array(sample_chunk.get(), dtype=dtype)
+            chunk_shape = sample_array.shape[1:] if len(sample_array.shape) > 1 else ()
+            total_shape = (len(x),) + chunk_shape
+        finally:
+            del sample_array
+            del sample_chunk
+            pool.free_all_blocks()
+            pinned_mempool.free_all_blocks()
         
-        for i in range(0, x.size, batch_size):
-            try:
-                chunk = x[i:i + batch_size]
-                result.append(np.array(chunk.get(), dtype=dtype))
-                del chunk
-                
-                if i > 0 and i % (batch_size * 10) == 0:
-                    cp.get_default_memory_pool().free_all_blocks()
-                    gc.collect()
-                    
-            except Exception as e:
-                logging.error(f"Error processing batch {i//batch_size + 1}/{total_batches}: {str(e)}")
-                raise
+        chunks = np.empty(total_shape, dtype=dtype)
+        
+        try:
+            for i in range(0, len(x), batch_size):
+                try:
+                    end_idx = min(i + batch_size, len(x))
+                    chunk = x[i:end_idx]
+                    chunks[i:end_idx] = chunk.get().astype(dtype=dtype)
+                finally:
+                    del chunk
+                    pool.free_all_blocks()
+                    pinned_mempool.free_all_blocks()
+                    cp.cuda.runtime.deviceSynchronize()
                 
-        final_result = np.concatenate(result)
-        del x
-        cp.get_default_memory_pool().free_all_blocks()
-        gc.collect()
-        return final_result
+                loading_bar.update(1)
+        finally:
+            del x
+            pool.free_all_blocks()
+            pinned_mempool.free_all_blocks()
+            cp.cuda.runtime.deviceSynchronize()
+        
+        return chunks
         
     except Exception as e:
         logging.error(f"Error in transfer_to_cpu: {str(e)}")
+        if 'x' in locals():
+            del x
+        if 'pool' in locals():
+            pool.free_all_blocks()
+        if 'pinned_mempool' in locals():
+            pinned_mempool.free_all_blocks()
+        cp.cuda.runtime.deviceSynchronize()
         raise
 
 def get_optimal_batch_size_for_gpu(x, data_size_bytes):
@@ -118,52 +144,66 @@ def transfer_to_gpu(x, dtype=cp.float32):
     The `transfer_to_gpu` function in Python converts input data to GPU arrays, optimizing memory usage by
     batching and handling out-of-memory errors.
     
-    :param x: The `x` parameter in the `transfer_to_gpu` function is the input data that you want to transfer to
-    the GPU for processing. It can be either a NumPy array or a CuPy array. If it's a NumPy array, the
-    function will convert it to a CuPy array and
-    :param dtype: The `dtype` parameter in the `transfer_to_gpu` function specifies the data type to which the
-    input array `x` should be converted when moving it to the GPU. By default, it is set to
-    `cp.float32`, which is a 32-bit floating-point data type provided by the Cu
-    :return: The `transfer_to_gpu` function returns the input data `x` converted to a GPU array of type `dtype`
-    (default is `cp.float32`). If the input `x` is already a GPU array with the same dtype, it returns
-    `x` as is. If the data size of `x` exceeds 25% of the free GPU memory, it processes the data in
-    batches to
-    """
+    :param x: The `x` parameter in the `transfer_to_gpu` function is the input data that you want to transfer to the GPU for processing. It can be either a NumPy array or a CuPy array. If it's a NumPy array, the function will convert it to a CuPy array and
     
+    :param dtype: The `dtype` parameter in the `transfer_to_gpu` function specifies the data type to which the input array `x` should be converted when moving it to the GPU. By default, it is set to `cp.float32`, which is a 32-bit floating-point data type provided by the CuPy
+    
+    :return: The `transfer_to_gpu` function returns the input data `x` converted to a GPU array of type `dtype` (default is `cp.float32`). If the input `x` is already a GPU array with the same dtype, it returns `x` as is. If the data size of `x` exceeds 25% of the free GPU memory, it processes the data in batches to
+    """
+    from .ui import loading_bars, initialize_loading_bar
     try:
         if isinstance(x, cp.ndarray):
             return x.astype(dtype) if x.dtype != dtype else x
             
+        x = x.astype(dtype=dtype, copy=False)
         data_size = x.nbytes
+        pinned_mempool = cp.cuda.PinnedMemoryPool()
         free_gpu_memory = cp.cuda.runtime.memGetInfo()[0]
-        
         logging.debug(f"Data size: {data_size/1e6:.2f}MB, Free GPU memory: {free_gpu_memory/1e6:.2f}MB")
-        
+
         if data_size <= free_gpu_memory * 0.25:
             new_x = cp.array(x, dtype=dtype, copy=False)
-            del x
-            gc.collect()
             return new_x
             
         batch_size = get_optimal_batch_size_for_gpu(x, data_size)
-        logging.debug(f"Using batch size: {batch_size}")
+        if batch_size == 0: batch_size = 1
+
+        loading_bar = initialize_loading_bar(total=len(x)/batch_size, desc='Transfering to GPU mem', ncols=70, bar_format=loading_bars()[0], leave=False)
         
-        result = []
+        logging.debug(f"Using batch size: {batch_size}")
+        current_threshold = 0.75
         total_batches = (len(x) + batch_size - 1) // batch_size
+
+        sample_chunk = x[0:1]
+        sample_array = cp.array(sample_chunk, dtype=dtype)
+        chunk_shape = sample_array.shape[1:] if len(sample_array.shape) > 1 else ()
+        del sample_array
+        del sample_chunk
+        if chunk_shape:
+            total_shape = (len(x),) + chunk_shape
+        else:
+            total_shape = (len(x),)
         
+        del chunk_shape
+        chunks = cp.empty(total_shape, dtype=dtype)
+        del total_shape
+
         for i in range(0, len(x), batch_size):
             try:
                 chunk = x[i:i + batch_size]
-                gpu_chunk = cp.array(chunk, dtype=dtype)
-                result.append(gpu_chunk)
-                
+                chunk = cp.array(chunk, dtype=dtype)
+                chunks[i // batch_size] = chunk
                 del chunk
+                pinned_mempool.free_all_blocks()
 
                 if i > 0 and i % (batch_size * 5) == 0:
                     pool = cp.get_default_memory_pool()
-                    if pool.used_bytes() > free_gpu_memory * 0.75:
+                    current_threshold = adjust_gpu_memory_threshold(pool, free_gpu_memory, current_threshold)
+                    if pool.used_bytes() > cp.cuda.runtime.memGetInfo()[0] * current_threshold:
                         pool.free_all_blocks()
-                    gc.collect()
+                    
+                    
+                loading_bar.update(1)
                     
             except cp.cuda.memory.OutOfMemoryError:
                 logging.error(f"GPU out of memory at batch {i//batch_size + 1}/{total_batches}")
@@ -176,12 +216,10 @@ def transfer_to_gpu(x, dtype=cp.float32):
                 raise
                 
         try:
-            final_result = cp.concatenate(result)
-            del result
             del x
-            gc.collect()
             cp.get_default_memory_pool().free_all_blocks()
-            return final_result
+            pinned_mempool.free_all_blocks()
+            return chunks
             
         except Exception as e:
             logging.error(f"Error concatenating results: {str(e)}")
@@ -190,3 +228,71 @@ def transfer_to_gpu(x, dtype=cp.float32):
     except Exception as e:
         logging.error(f"Error in transfer_to_gpu: {str(e)}")
         raise
+
+def adjust_gpu_memory_threshold(pool, free_gpu_memory, current_threshold=0.75, min_threshold=0.5, max_threshold=0.9):
+    used_memory = pool.used_bytes()
+    usage_ratio = used_memory / free_gpu_memory
+    
+    if usage_ratio > current_threshold:
+        current_threshold = max(min_threshold, current_threshold - 0.05)
+    elif usage_ratio < current_threshold * 0.8:
+        current_threshold = min(max_threshold, current_threshold + 0.05)
+
+    return current_threshold
+
+
+def optimize_labels(y, one_hot_encoded=True, cuda=False):
+    """
+    The function `optimize_labels` optimizes the data type of labels based on their length and encoding
+    format.
+    
+    :param y: The `optimize_labels` function is designed to optimize the data type of the input labels
+    `y` based on certain conditions. The function checks if the labels are in one-hot encoded format or
+    not, and then based on the length of the labels and the specified data types (`uint8`, `uint
+    :param one_hot_encoded: The `one_hot_encoded` parameter in the `optimize_labels` function indicates
+    whether the labels are in one-hot encoded format or not. If `one_hot_encoded` is set to `True`, it
+    means that the labels are in one-hot encoded format, and the function will check the length of the,
+    defaults to True (optional)
+    :param cuda: The `cuda` parameter in the `optimize_labels` function is a boolean flag that indicates
+    whether to use CUDA for computations. If `cuda` is set to `True`, the function will use the CuPy
+    library for array operations, which can leverage GPU acceleration. If `cuda` is `False, defaults to
+    False (optional)
+    :return: The function `optimize_labels` returns the input array `y` after optimizing its data type
+    based on the specified conditions. If `one_hot_encoded` is True, it checks the length of the
+    elements in `y` and converts the data type to uint8, uint16, or uint32 accordingly. If
+    `one_hot_encoded` is False, it checks the length of `y` itself and
+    """
+
+    if cuda: array_type = cp
+    else: array_type = np
+
+    dtype_uint8 = array_type.uint8
+    dtype_uint16 = array_type.uint16
+    dtype_uint32 = array_type.uint32
+
+    if one_hot_encoded:
+        if len(y[0]) < 256:
+            if y.dtype != dtype_uint8:
+                y = array_type.array(y, copy=False).astype(dtype_uint8, copy=False)
+        elif len(y[0]) <= 32767:
+            if y.dtype != dtype_uint16:
+                y = array_type.array(y, copy=False).astype(dtype_uint16, copy=False)
+        else:
+            if y.dtype != dtype_uint32:
+                y = array_type.array(y, copy=False).astype(dtype_uint32, copy=False)
+
+        return y
+
+    else:
+
+        if len(y) < 256:
+            if y.dtype != dtype_uint8:
+                y = array_type.array(y, copy=False).astype(dtype_uint8, copy=False)
+        elif len(y) <= 32767:
+            if y.dtype != dtype_uint16:
+                y = array_type.array(y, copy=False).astype(dtype_uint16, copy=False)
+        else:
+            if y.dtype != dtype_uint32:
+                y = array_type.array(y, copy=False).astype(dtype_uint32, copy=False)
+
+        return y

pyerualjetwork/metrics_cuda.py

@@ -80,7 +80,7 @@ def roc_curve(y_true, y_score):
         raise ValueError("Only binary classification is supported.")
 
     
-    desc_score_indices = cp.argsort(y_score, kind="mergesort")[::-1]
+    desc_score_indices = cp.argsort(y_score, kind="stable")[::-1]
     y_score = y_score[desc_score_indices]
     y_true = y_true[desc_score_indices]
 
@@ -93,11 +93,10 @@ def roc_curve(y_true, y_score):
 
     tp = 0
     fp = 0
-    prev_score = None
+    prev_score = 0
 
-    
     for i, score in enumerate(y_score):
-        if score != prev_score:
+        if score is not prev_score:
             fpr.append(fp / n_neg)
             tpr.append(tp / n_pos)
             thresholds.append(score)

pyerualjetwork/model_operations.py

@@ -17,7 +17,7 @@ def save_model(model_name,
                activation_potentiation=['linear'],
                weights_type='npy',
                weights_format='raw',
-               show_architecture=None,
+               show_architecture=False,
                show_info=True
                ):
 
@@ -44,7 +44,7 @@ def save_model(model_name,
 
     activation_potentiation (list): For deeper PLAN networks, activation function parameters. For more information please run this code: plan.activations_list() default: ['linear']
 
-    show_architecture (str): It draws model architecture. Takes 2 value='basic' or 'detailed'. Default: None(not drawing)
+    show_architecture (bool): It draws model architecture. True or False. Default: False
 
     show_info (bool): Prints model details into console. default: True
 
@@ -170,8 +170,8 @@ def save_model(model_name,
         
         print(message)
 
-    if show_architecture is not None:
-        draw_model_architecture(model_name=model_name, model_path=model_path, style=show_architecture)
+    if show_architecture:
+        draw_model_architecture(model_name=model_name, model_path=model_path)
 
 
 
@@ -190,7 +190,6 @@ def load_model(model_name,
    Returns:
    lists: W(list[num]), activation_potentiation, DataFrame of the model
     """
-    np.set_printoptions(threshold=np.Infinity)
 
     try:
 

pyerualjetwork/model_operations_cuda.py

@@ -1,4 +1,5 @@
 import cupy as cp
+import numpy as np
 from colorama import Fore, Style
 import sys
 from datetime import datetime
@@ -44,7 +45,7 @@ def save_model(model_name,
 
     activation_potentiation (list): For deeper PLAN networks, activation function parameters. For more information please run this code: plan.activations_list() default: ['linear']
 
-    show_architecture (str): It draws model architecture. Takes 2 value='basic' or 'detailed'. Default: None(not drawing)
+    show_architecture (bool): It draws model architecture. True or False. Default: False
 
     show_info (bool): Prints model details into console. default: True
 
@@ -173,8 +174,8 @@ def save_model(model_name,
         
         print(message)
 
-    if show_architecture is not None:
-        draw_model_architecture(model_name=model_name, model_path=model_path, style=show_architecture)
+    if show_architecture:
+        draw_model_architecture(model_name=model_name, model_path=model_path)
 
 
 
@@ -213,12 +214,12 @@ def load_model(model_name,
         if scaler_params_cpu[0] == None: # model not scaled
             scaler_params = scaler_params_cpu[0]
 
-    except:
+    except: # model scaled
+        scaler_params_cpu = [item for item in scaler_params_cpu if isinstance(item, np.ndarray)]
         scaler_params = cp.array(scaler_params_cpu)
+
         del scaler_params_cpu
         gc.collect()
-        scaler_params = [item for item in scaler_params if isinstance(item, cp.ndarray)] # model scaled
-
      
     model_name = str(df['MODEL NAME'].iloc[0])
     WeightType = str(df['WEIGHTS TYPE'].iloc[0])

pyerualjetwork/plan.py

@@ -15,6 +15,7 @@ ANAPLAN document: https://github.com/HCB06/Anaplan/blob/main/Welcome_to_Anaplan/
 
 import numpy as np
 from colorama import Fore
+import math
 
 ### LIBRARY IMPORTS ###
 from .ui import loading_bars, initialize_loading_bar
@@ -25,8 +26,9 @@ from .metrics import metrics
 from .model_operations import get_acc, get_preds, get_preds_softmax
 from .visualizations import (
     draw_neural_web,
+    update_neural_web_for_fit,
     plot_evaluate,
-    neuron_history,
+    update_neuron_history,
     initialize_visualization_for_fit,
     update_weight_visualization_for_fit,
     update_decision_boundary_for_fit,
@@ -34,7 +36,9 @@ from .visualizations import (
     display_visualization_for_fit,
     display_visualizations_for_learner,
     update_history_plots_for_learner,
-    initialize_visualization_for_learner
+    initialize_visualization_for_learner,
+    update_neuron_history_for_learner,
+    show
 )
 
 ### GLOBAL VARIABLES ###
@@ -98,20 +102,13 @@ def fit(
     Returns:
         numpyarray([num]): (Weight matrix).
     """
+    
+    from model_operations import get_acc
+
     # Pre-checks
 
     x_train = x_train.astype(dtype, copy=False)
 
-    if len(y_train[0]) < 256:
-        if y_train.dtype != np.uint8:
-            y_train = np.array(y_train, copy=False).astype(np.uint8, copy=False)
-    elif len(y_train[0]) <= 32767:
-        if y_train.dtype != np.uint16:
-            y_train = np.array(y_train, copy=False).astype(np.uint16, copy=False)
-    else:
-        if y_train.dtype != np.uint32:
-            y_train = np.array(y_train, copy=False).astype(np.uint32, copy=False)
-
     if train_bar and val:
         train_progress = initialize_loading_bar(total=len(x_train), ncols=71, desc='Fitting', bar_format=bar_format_normal)
     elif train_bar and val == False:
@@ -137,18 +134,25 @@ def fit(
 
     # Training process
     for index, inp in enumerate(x_train):
-        inp = np.array(inp, copy=False, dtype=dtype).ravel()
+        inp = np.array(inp, copy=False).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)
         LTPW += normalization(STPW, dtype=dtype) if auto_normalization else STPW
-
-        # Visualization updates
-        if show_training:
-            update_weight_visualization_for_fit(vis_objects['ax'][0, 0], LTPW, vis_objects['artist2'])
-            if decision_boundary_status:
-                update_decision_boundary_for_fit(vis_objects['ax'][0, 1], x_val, y_val, activation_potentiation, LTPW, vis_objects['artist1'])
-            update_validation_history_for_fit(vis_objects['ax'][1, 1], val_list, vis_objects['artist3'])
+        if val and index != 0:
+            if index % math.ceil((val_count / len(x_train)) * 100) == 0:
+                val_acc = evaluate(x_val, y_val, loading_bar_status=False, activation_potentiation=activation_potentiation, W=LTPW)[get_acc()]
+                val_list.append(val_acc)
+
+                # Visualization updates
+                if show_training:
+                    update_weight_visualization_for_fit(vis_objects['ax'][0, 0], LTPW, vis_objects['artist2'])
+                    if decision_boundary_status:
+                        update_decision_boundary_for_fit(vis_objects['ax'][0, 1], x_val, y_val, activation_potentiation, LTPW, vis_objects['artist1'])
+                    update_validation_history_for_fit(vis_objects['ax'][1, 1], val_list, vis_objects['artist3'])
+                    update_neural_web_for_fit(W=LTPW, G=vis_objects['G'], ax=vis_objects['ax'][1, 0], artist=vis_objects['artist4'])
+                if neurons_history:
+                    update_neuron_history(LTPW, row=vis_objects['row'], col=vis_objects['col'], class_count=len(y_train[0]), fig1=vis_objects['fig1'], ax1=vis_objects['ax1'], artist5=vis_objects['artist5'], acc=val_acc)
         if train_bar:
              train_progress.update(1)
 
@@ -156,7 +160,15 @@ def fit(
 
     # Finalize visualization
     if show_training:
-        display_visualization_for_fit(vis_objects['fig'], vis_objects['artist1'], interval)
+        ani1 = display_visualization_for_fit(vis_objects['fig'], vis_objects['artist1'], interval)
+        ani2 = display_visualization_for_fit(vis_objects['fig'], vis_objects['artist2'], interval)
+        ani3 = display_visualization_for_fit(vis_objects['fig'], vis_objects['artist3'], interval)
+        ani4 = display_visualization_for_fit(vis_objects['fig'], vis_objects['artist4'], interval)
+        show()
+    
+    if neurons_history:
+        ani5 = display_visualization_for_fit(vis_objects['fig1'], vis_objects['artist5'], interval)
+        show()
 
     return normalization(LTPW, dtype=dtype)
 
@@ -223,7 +235,7 @@ def learner(x_train, y_train, x_test=None, y_test=None, strategy='accuracy', bat
         tuple: A list for model parameters: [Weight matrix, Test loss, Test Accuracy, [Activations functions]].
     
     """
-    print(Fore.WHITE + "\nRemember, optimization on large datasets can be very time-consuming and computationally expensive. Therefore, if you are working with such a dataset, our recommendation is to include activation function: ['circular', 'spiral'] in the 'except_this' parameter unless absolutely necessary, as they can significantly prolong the process. from: learner\n" + Fore.RESET)
+    print(Fore.WHITE + "\nRemember, optimization on large datasets can be very time-consuming and computationally expensive. Therefore, if you are working with such a dataset, our recommendation is to include activation function: ['circular'] in the 'except_this' parameter unless absolutely necessary, as they can significantly prolong the process. from: learner\n" + Fore.RESET)
 
     activation_potentiation = all_activations()
 
@@ -420,7 +432,7 @@ def learner(x_train, y_train, x_test=None, y_test=None, strategy='accuracy', bat
 
                 if neurons_history:
                     viz_objects['neurons']['artists'] = (
-                        neuron_history(np.copy(best_weights), viz_objects['neurons']['ax'],
+                        update_neuron_history_for_learner(np.copy(best_weights), viz_objects['neurons']['ax'],
                                      viz_objects['neurons']['row'], viz_objects['neurons']['col'],
                                      y_train[0], viz_objects['neurons']['artists'],
                                      data=data, fig1=viz_objects['neurons']['fig'],