pyerualjetwork 4.3.8.dev15__tar.gz → 4.3.9b1__tar.gz

{pyerualjetwork-4.3.8.dev15 → pyerualjetwork-4.3.9b1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyerualjetwork
-Version: 4.3.8.dev15
+Version: 4.3.9b1
 Summary: PyerualJetwork is a machine learning library supported with GPU(CUDA) acceleration written in Python for professionals and researchers including with PLAN algorithm, PLANEAT algorithm (genetic optimization). Also includes data pre-process and memory manegament
 Author: Hasan Can Beydili
 Author-email: tchasancan@gmail.com
@@ -25,8 +25,6 @@ GitHub Page: https://github.com/HCB06/PyerualJetwork
 YouTube Tutorials: https://www.youtube.com/watch?v=6wMQstZ00is&list=PLNgNWpM7HbsBpCx2VTJ4SK9wcPyse-EHw
 
 	pip install pyerualjetwork
- 
-	'use this if your data small or memory management is a problem :'
 	
 	from pyerualjetwork import plan
 	from pyerualjetwork import planeat
@@ -38,26 +36,11 @@ YouTube Tutorials: https://www.youtube.com/watch?v=6wMQstZ00is&list=PLNgNWpM7Hbs
 	from pyerualjetwork import data_operations_cuda
 	from pyerualjetwork import model_operations_cuda
 	
-	'use this if your data large or memory management is not a problem : _afterburner package (afterburner package comes with powerful paralellism,
-	afterburner with cuda modules offers super-fast training but some memory managemant features and visualization features discarded.
-	Specially designed for LLM training and other massive model training)'
-	
-	from pyerualjetwork_afterburner import plan
-	from pyerualjetwork_afterburner import planeat
-	from pyerualjetwork_afterburner import data_operations
-	from pyerualjetwork_afterburner import model_operations
-	
-	from pyerualjetwork_afterburner import plan_cuda
-	from pyerualjetwork_afterburner import planeat_cuda
-	from pyerualjetwork_afterburner import data_operations_cuda
-	from pyerualjetwork_afterburner import model_operations_cuda
-
       Optimized for Visual Studio Code
       
       requires=[
  	    'scipy==1.13.1',
 	    'tqdm==4.66.4',
-	    'seaborn==0.13.2',
 	    'pandas==2.2.2',
 	    'networkx==3.3',
 	    'numpy==1.26.4',
@@ -67,7 +50,7 @@ YouTube Tutorials: https://www.youtube.com/watch?v=6wMQstZ00is&list=PLNgNWpM7Hbs
 	    'psutil==6.1.1'
         ]
 
-     matplotlib, seaborn, networkx (optional).
+     matplotlib, networkx (optional).
           
 ##############################
 

{pyerualjetwork-4.3.8.dev15 → pyerualjetwork-4.3.9b1}/README.md

@@ -16,8 +16,6 @@ GitHub Page: https://github.com/HCB06/PyerualJetwork
 YouTube Tutorials: https://www.youtube.com/watch?v=6wMQstZ00is&list=PLNgNWpM7HbsBpCx2VTJ4SK9wcPyse-EHw
 
 	pip install pyerualjetwork
- 
-	'use this if your data small or memory management is a problem :'
 	
 	from pyerualjetwork import plan
 	from pyerualjetwork import planeat
@@ -29,26 +27,11 @@ YouTube Tutorials: https://www.youtube.com/watch?v=6wMQstZ00is&list=PLNgNWpM7Hbs
 	from pyerualjetwork import data_operations_cuda
 	from pyerualjetwork import model_operations_cuda
 	
-	'use this if your data large or memory management is not a problem : _afterburner package (afterburner package comes with powerful paralellism,
-	afterburner with cuda modules offers super-fast training but some memory managemant features and visualization features discarded.
-	Specially designed for LLM training and other massive model training)'
-	
-	from pyerualjetwork_afterburner import plan
-	from pyerualjetwork_afterburner import planeat
-	from pyerualjetwork_afterburner import data_operations
-	from pyerualjetwork_afterburner import model_operations
-	
-	from pyerualjetwork_afterburner import plan_cuda
-	from pyerualjetwork_afterburner import planeat_cuda
-	from pyerualjetwork_afterburner import data_operations_cuda
-	from pyerualjetwork_afterburner import model_operations_cuda
-
       Optimized for Visual Studio Code
       
       requires=[
  	    'scipy==1.13.1',
 	    'tqdm==4.66.4',
-	    'seaborn==0.13.2',
 	    'pandas==2.2.2',
 	    'networkx==3.3',
 	    'numpy==1.26.4',
@@ -58,7 +41,7 @@ YouTube Tutorials: https://www.youtube.com/watch?v=6wMQstZ00is&list=PLNgNWpM7Hbs
 	    'psutil==6.1.1'
         ]
 
-     matplotlib, seaborn, networkx (optional).
+     matplotlib, networkx (optional).
           
 ##############################
 

{pyerualjetwork-4.3.8.dev15 → pyerualjetwork-4.3.9b1}/pyerualjetwork/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "4.3.8dev15"
+__version__ = "4.3.9b1"
 __update__ = "* Changes: https://github.com/HCB06/PyerualJetwork/blob/main/CHANGES\n* PyerualJetwork Homepage: https://github.com/HCB06/PyerualJetwork/tree/main\n* PyerualJetwork document: https://github.com/HCB06/PyerualJetwork/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-4.3.8.dev15/pyerualjetwork_afterburner → pyerualjetwork-4.3.9b1/pyerualjetwork}/plan.py

@@ -44,6 +44,7 @@ def fit(
     y_train,
     activation_potentiation=['linear'],
     W=None,
+    normalization=False,
     dtype=np.float32
 ):
     """
@@ -59,6 +60,8 @@ def fit(
 
         W (numpy.ndarray): If you want to re-continue or update model
 
+        normalization (bool, optional): Normalization may solves overflow problem. Default: False
+
         dtype (numpy.dtype): Data type for the arrays. np.float32 by default. Example: np.float64 or np.float16. [fp32 for balanced devices, fp64 for strong devices, fp16 for weak devices: not reccomended!] (optional)
 
     Returns:
@@ -67,19 +70,21 @@ def fit(
 
     # Pre-check
     
-    if len(x_train) != len(y_train):
-        raise ValueError("x_train and y_train must have the same length.")
+    if len(x_train) != len(y_train): raise ValueError("x_train and y_train must have the same length.")
+
+    weight = np.zeros((len(y_train[0]), len(x_train[0].ravel()))).astype(dtype, copy=False) if W is None else W
 
-    LTPW = np.zeros((len(y_train[0]), len(x_train[0].ravel()))).astype(dtype, copy=False) if W is None else W
+    if normalization is True: x_train = normalization(apply_activation(x_train, activation_potentiation))
+    elif normalization is False: x_train = apply_activation(x_train, activation_potentiation)
+    else: raise ValueError('normalization parameter only be True or False')
     
-    x_train = apply_activation(x_train, activation_potentiation)
-    LTPW += np.array(y_train, dtype=optimize_labels(y_train, cuda=False).dtype).T @ x_train
+    weight += y_train.T @ x_train
 
-    return normalization(LTPW, dtype=dtype)
+    return normalization(weight, dtype=dtype)
 
 
 def learner(x_train, y_train, optimizer, fit_start, strategy='accuracy', gen=None, batch_size=1, pop_size=None,
-           neural_web_history=False, show_current_activations=False,
+           neural_web_history=False, show_current_activations=False, normalization=False,
            neurons_history=False, early_stop=False, loss='categorical_crossentropy', show_history=False,
            interval=33.33, target_acc=None, target_loss=None,
            start_this_act=None, start_this_W=None, dtype=np.float32):
@@ -131,6 +136,8 @@ def learner(x_train, y_train, optimizer, fit_start, strategy='accuracy', gen=Non
 
         show_history (bool, optional): If True, displays the training history after optimization. Default is False.
 
+        normalization (bool, optional): Normalization may solves overflow problem. Default: False
+
         loss (str, optional): For visualizing and monitoring. PLAN neural networks doesn't need any loss function in training. options: ('categorical_crossentropy' or 'binary_crossentropy') Default is 'categorical_crossentropy'.
 
         interval (int, optional): The interval at which evaluations are conducted during training. (33.33 = 30 FPS, 16.67 = 60 FPS) Default is 100.
@@ -183,9 +190,9 @@ def learner(x_train, y_train, optimizer, fit_start, strategy='accuracy', gen=Non
 
     # Initialize progress bar
     if batch_size == 1:
-        ncols = 76
+        ncols = 78
     else:
-        ncols = 89
+        ncols = 49
 
     # Initialize variables
     best_acc = 0
@@ -224,7 +231,7 @@ def learner(x_train, y_train, optimizer, fit_start, strategy='accuracy', gen=Non
             
             if fit_start is True and i == 0 and j < activation_potentiation_len:
                 act_pop[j] = activation_potentiation[j]
-                W = fit(x_train_batch, y_train_batch, activation_potentiation=act_pop[-1], dtype=dtype)
+                W = fit(x_train_batch, y_train_batch, activation_potentiation=act_pop[j], normalization=normalization, dtype=dtype)
                 weight_pop[j] = W
             
             model = evaluate(x_train_batch, y_train_batch, W=weight_pop[j], activation_potentiation=act_pop[j])
@@ -267,10 +274,8 @@ def learner(x_train, y_train, optimizer, fit_start, strategy='accuracy', gen=Non
                 final_activations = [final_activations[0]] if len(set(final_activations)) == 1 else final_activations # removing if all same
 
                 if batch_size == 1:
-                    postfix_dict[f"{data} Accuracy"] = best_acc
-                else:
-                    postfix_dict[f"{data} Batch Accuracy"] = acc
-                progress.set_postfix(postfix_dict)
+                    postfix_dict[f"{data} Accuracy"] = np.round(best_acc, 4)
+                    progress.set_postfix(postfix_dict)
 
                 if show_current_activations:
                     print(f", Current Activations={final_activations}", end='')
@@ -281,11 +286,8 @@ def learner(x_train, y_train, optimizer, fit_start, strategy='accuracy', gen=Non
                     train_loss = binary_crossentropy(y_true_batch=y_train_batch, y_pred_batch=model[get_preds_softmax()])
 
                 if batch_size == 1:
-                    postfix_dict[f"{data} Loss"] = train_loss
-                    best_loss = train_loss
-                else:
-                    postfix_dict[f"{data} Batch Loss"] = train_loss
-                progress.set_postfix(postfix_dict)
+                    postfix_dict[f"{data} Loss"] = np.round(train_loss, 4)
+                    progress.set_postfix(postfix_dict)
                 best_loss = train_loss
 
                 # Update visualizations during training
@@ -358,6 +360,20 @@ def learner(x_train, y_train, optimizer, fit_start, strategy='accuracy', gen=Non
         best_acc_per_gen_list.append(best_acc)
         loss_list.append(best_loss)
 
+        if batch_size != 1:
+            train_model = evaluate(x_train, y_train, best_weights, final_activations)
+            
+            if loss == 'categorical_crossentropy':
+                train_loss = categorical_crossentropy(y_true_batch=y_train, 
+                                                    y_pred_batch=train_model[get_preds_softmax()])
+            else:
+                train_loss = binary_crossentropy(y_true_batch=y_train, 
+                                                y_pred_batch=train_model[get_preds_softmax()])
+                        
+            postfix_dict[f"{data} Accuracy"] = np.round(train_model[get_acc()], 4)
+            postfix_dict[f"{data} Loss"] = np.round(train_loss, 4)
+            progress.set_postfix(postfix_dict)
+
         weight_pop, act_pop = optimizer(np.array(weight_pop, copy=False, dtype=dtype), act_pop, i, np.array(target_pop, dtype=dtype, copy=False), bar_status=False)
         target_pop = []
 

{pyerualjetwork-4.3.8.dev15/pyerualjetwork_afterburner → pyerualjetwork-4.3.9b1/pyerualjetwork}/plan_cuda.py

@@ -44,6 +44,7 @@ def fit(
     y_train,
     activation_potentiation=['linear'],
     W=None,
+    normalization=False,
     dtype=cp.float32
 ):
     """
@@ -57,9 +58,11 @@ def fit(
 
         activation_potentiation (list): For deeper PLAN networks, activation function parameters. For more information please run this code: plan.activations_list() default: [None] (optional)
 
-        W (cupy.ndarray): If you want to re-continue or update model
+        W (cupy.ndarray, optional): If you want to re-continue or update model
         
-        dtype (cupy.dtype): Data type for the arrays. cp.float32 by default. Example: cp.float64 or cp.float16. [fp32 for balanced devices, fp64 for strong devices, fp16 for weak devices: not reccomended!] (optional)
+        normalization (bool, optional): Normalization may solves overflow problem. Default: False
+
+        dtype (cupy.dtype, optional): Data type for the arrays. cp.float32 by default. Example: cp.float64 or cp.float16. [fp32 for balanced devices, fp64 for strong devices, fp16 for weak devices: not reccomended!] (optional)
 
     Returns:
         cupyarray: (Weight matrix).
@@ -68,16 +71,19 @@ def fit(
     
     if len(x_train) != len(y_train): raise ValueError("x_train and y_train must have the same length.")
 
-    LTPW = cp.zeros((len(y_train[0]), len(x_train[0].ravel()))).astype(dtype, copy=False) if W is None else W
+    weight = cp.zeros((len(y_train[0]), len(x_train[0].ravel()))).astype(dtype, copy=False) if W is None else W
 
-    x_train = apply_activation(x_train, activation_potentiation)
-    LTPW += cp.array(y_train, dtype=optimize_labels(y_train, cuda=True).dtype).T @ x_train
+    if normalization is True: x_train = normalization(apply_activation(x_train, activation_potentiation))
+    elif normalization is False: x_train = apply_activation(x_train, activation_potentiation)
+    else: raise ValueError('normalization parameter only be True or False')
+    
+    weight += y_train.T @ x_train
 
-    return normalization(LTPW, dtype=dtype)
+    return normalization(weight, dtype=dtype)
 
 
 def learner(x_train, y_train, optimizer, fit_start, strategy='accuracy', gen=None, batch_size=1, pop_size=None,
-           neural_web_history=False, show_current_activations=False,
+           neural_web_history=False, show_current_activations=False, normalization=False,
            neurons_history=False, early_stop=False, loss='categorical_crossentropy', show_history=False,
            interval=33.33, target_acc=None, target_loss=None,
            start_this_act=None, start_this_W=None, dtype=cp.float32, memory='gpu'):
@@ -130,6 +136,8 @@ def learner(x_train, y_train, optimizer, fit_start, strategy='accuracy', gen=Non
 
         loss (str, optional): For visualizing and monitoring. PLAN neural networks doesn't need any loss function in training. options: ('categorical_crossentropy' or 'binary_crossentropy') Default is 'categorical_crossentropy'.
 
+        normalization (bool, optional): Normalization may solves overflow problem. Default: False
+        
         interval (int, optional): The interval at which evaluations are conducted during training. (33.33 = 30 FPS, 16.67 = 60 FPS) Default is 100.
     
         target_acc (int, optional): The target accuracy to stop training early when achieved. Default is None.
@@ -192,7 +200,7 @@ def learner(x_train, y_train, optimizer, fit_start, strategy='accuracy', gen=Non
     if batch_size == 1:
         ncols = 76
     else:
-        ncols = 89
+        ncols = 49
 
     # Initialize variables
     best_acc = 0
@@ -234,7 +242,7 @@ def learner(x_train, y_train, optimizer, fit_start, strategy='accuracy', gen=Non
 
             if fit_start is True and i == 0 and j < activation_potentiation_len:
                 act_pop[j] = activation_potentiation[j]
-                W = fit(x_train_batch, y_train_batch, activation_potentiation=act_pop[-1], dtype=dtype)
+                W = fit(x_train_batch, y_train_batch, activation_potentiation=act_pop[j], normalization=normalization, dtype=dtype)
                 weight_pop[j] = W
     
             model = evaluate(x_train_batch, y_train_batch, W=weight_pop[j], activation_potentiation=act_pop[j])
@@ -277,10 +285,8 @@ def learner(x_train, y_train, optimizer, fit_start, strategy='accuracy', gen=Non
                 final_activations = [final_activations[0]] if len(set(final_activations)) == 1 else final_activations # removing if all same
 
                 if batch_size == 1:
-                    postfix_dict[f"{data} Accuracy"] = cp.round(best_acc, 3)
-                else:
-                    postfix_dict[f"{data} Batch Accuracy"] = cp.round(best_acc, 3)
-                progress.set_postfix(postfix_dict)
+                    postfix_dict[f"{data} Accuracy"] = cp.round(best_acc, 4)
+                    progress.set_postfix(postfix_dict)
 
                 if show_current_activations:
                     print(f", Current Activations={final_activations}", end='')
@@ -291,12 +297,9 @@ def learner(x_train, y_train, optimizer, fit_start, strategy='accuracy', gen=Non
                     train_loss = binary_crossentropy(y_true_batch=transfer_to_gpu(y_train_batch, dtype=y_train_batch.dtype), y_pred_batch=model[get_preds_softmax()])
 
                 if batch_size == 1:
-                    postfix_dict[f"{data} Loss"] = cp.round(train_loss, 3)
+                    postfix_dict[f"{data} Loss"] = cp.round(train_loss, 4)
                     best_loss = train_loss
-                else:
-                    postfix_dict[f"{data} Batch Loss"] = cp.round(train_loss, 3)
-                progress.set_postfix(postfix_dict)
-                best_loss = train_loss
+                    progress.set_postfix(postfix_dict)
 
                 # Update visualizations during training
                 if show_history:
@@ -368,6 +371,18 @@ def learner(x_train, y_train, optimizer, fit_start, strategy='accuracy', gen=Non
         best_acc_per_gen_list.append(best_acc)
         loss_list.append(best_loss)
         
+        if batch_size != 1:
+            train_model = evaluate(x_train, y_train, best_weights, final_activations)
+            
+            if loss == 'categorical_crossentropy':
+                train_loss = categorical_crossentropy(y_true_batch=transfer_to_gpu(y_train_batch, dtype=y_train_batch.dtype), y_pred_batch=train_model[get_preds_softmax()])
+            else:
+                train_loss = binary_crossentropy(y_true_batch=transfer_to_gpu(y_train_batch, dtype=y_train_batch.dtype), y_pred_batch=train_model[get_preds_softmax()])
+
+            postfix_dict[f"{data} Accuracy"] = cp.round(train_model[get_acc()], 4)
+            postfix_dict[f"{data} Loss"] = cp.round(train_loss, 4)
+            progress.set_postfix(postfix_dict)
+
         weight_pop, act_pop = optimizer(cp.array(weight_pop, copy=False, dtype=dtype), act_pop, i, cp.array(target_pop, dtype=dtype, copy=False), bar_status=False)
         target_pop = []
 

{pyerualjetwork-4.3.8.dev15 → pyerualjetwork-4.3.9b1}/pyerualjetwork/planeat_cuda.py

@@ -19,7 +19,6 @@ import math
 
 
 ### LIBRARY IMPORTS ###
-from .plan_cuda import feed_forward
 from .data_operations_cuda import normalization
 from .ui import loading_bars, initialize_loading_bar
 from .activation_functions_cuda import apply_activation, all_activations
@@ -399,7 +398,7 @@ def evolver(weights,
    return weights, activation_potentiations
 
 
-def evaluate(x_population, weights, activation_potentiations, rl_mode=False, dtype=cp.float32):
+def evaluate(x_population, weights, activation_potentiations):
    """
     Evaluates the performance of a population of genomes, applying different activation functions 
     and weights depending on whether reinforcement learning mode is enabled or not.
@@ -414,64 +413,29 @@ def evaluate(x_population, weights, activation_potentiations, rl_mode=False, dty
         activation_potentiations (list or str): A list where each entry represents an activation function 
                                                 or a potentiation strategy applied to each genome. If only one 
                                                 activation function is used, this can be a single string.
-        
-        rl_mode (bool, optional): If True, reinforcement learning mode is activated, this accepts x_population is a single genome. (Also weights and activation_potentations a single genomes part.)
-                                  Default is False.
-
-                                  
-        dtype (cupy.dtype): Data type for the arrays. np.float32 by default. Example: cp.float64 or cp.float16. [fp32 for balanced devices, fp64 for strong devices, fp16 for weak devices: not reccomended!] (optional)
-
     Returns:
         list: A list of outputs corresponding to each genome in the population after applying the respective 
               activation function and weights.
 
-    Notes:
-        - If `rl_mode` is True:
-            - Accepts x_population is a single genom
-            - The inputs are flattened, and the activation function is applied across the single genom.
-        
-        - If `rl_mode` is False:
-            - Accepts x_population is a list of genomes
-            - Each genome is processed individually, and the results are stored in the `outputs` list.
-        
-        - `feed_forward()` function is the core function that processes the input with the given weights and activation function.
-    
     Example:
         ```python
-        outputs = evaluate(x_population, weights, activation_potentiations, rl_mode=False)
+        outputs = evaluate(x_population, weights, activation_potentiations)
         ```
 
     - The function returns a list of outputs after processing the population, where each element corresponds to 
       the output for each genome in `x_population`.
    """
-   
-   ### IF RL_MODE IS TRUE, A SINGLE GENOME IS ASSUMED AS INPUT, A FEEDFORWARD PREDICTION IS MADE, AND THE OUTPUT(NPARRAY) IS RETURNED:
-   
-   ### IF RL_MODE IS FALSE, PREDICTIONS ARE MADE FOR ALL GENOMES IN THE GROUP USING THEIR CORRESPONDING INDEXED INPUTS AND DATA.
    ### THE OUTPUTS ARE RETURNED AS A PYTHON LIST, WHERE EACH GENOME'S OUTPUT MATCHES ITS INDEX:
    
-   if rl_mode == True:
-      Input = cp.array(x_population, dtype=dtype, copy=False)
-      Input = Input.ravel()
-      
-      if isinstance(activation_potentiations, str):
-         activation_potentiations = [activation_potentiations]
-      
-      outputs = feed_forward(Input=Input, is_training=False, activation_potentiation=activation_potentiations, w=weights)
-      
+   if isinstance(activation_potentiations, str):
+    activation_potentiations = [activation_potentiations]
    else:
-      outputs = [0] * len(x_population)
-      for i, genome in enumerate(x_population):
+    activation_potentiations = [item if isinstance(item, list) else [item] for item in activation_potentiations]
 
-         Input = cp.array(genome)
-         Input = Input.ravel()
+   x_population = apply_activation(x_population, activation_potentiations)
+   result = x_population @ weights.T
 
-         if isinstance(activation_potentiations[i], str):
-            activation_potentiations[i] = [activation_potentiations[i]]
-
-         outputs[i] = feed_forward(Input=Input, is_training=False, activation_potentiation=activation_potentiations[i], w=weights[i])
-
-   return outputs
+   return result
 
 
 def cross_over(first_parent_W,
@@ -757,7 +721,7 @@ def mutation(weight,
          max_threshold = len(activations)
 
          new_threshold = threshold
-
+         
          except_this = ['spiral', 'circular']
          all_acts = [item for item in all_activations() if item not in except_this] # SPIRAL AND CIRCULAR ACTIVATION DISCARDED
          

{pyerualjetwork-4.3.8.dev15/pyerualjetwork_afterburner → pyerualjetwork-4.3.9b1/pyerualjetwork}/visualizations.py

@@ -323,7 +323,8 @@ def draw_activations(x_train, activation):
     except:
         print('\rWARNING: error in drawing some activation.', end='')
         return x_train
- 
+
+
 def plot_evaluate(x_test, y_test, y_preds, acc_list, W, activation_potentiation):
     
     from .metrics import metrics, confusion_matrix, roc_curve
@@ -447,8 +448,7 @@ def plot_evaluate(x_test, y_test, y_preds, acc_list, W, activation_potentiation)
         axs[1,1].set_title('Decision Boundary')
 
     except Exception as e:
-        # Hata meydana geldiğinde yapılacak işlemler
-        print(f"Hata oluştu: {e}")
+        print(f"Error: {e}")
 
     plt.show()
 
@@ -614,9 +614,9 @@ def update_neuron_history(LTPW, ax1, row, col, class_count, artist5, fig1, acc=F
 
     fig1.suptitle(suptitle_info, fontsize=16)
 
-
+""" DISABLED
 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
     visualization_objects = {}
 
@@ -649,32 +649,33 @@ def initialize_visualization_for_fit(val, show_training, neurons_history, x_trai
         })
 
     return visualization_objects
-
+"""
         
-
+""" DISABLED
 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)
-
-
+"""
+    
+""" DISABLED
 def update_weight_visualization_for_fit(ax, LTPW, artist2):
-    """Updates the weight visualization plot."""
+
     art2 = ax.imshow(LTPW, interpolation='sinc', cmap='viridis')
     artist2.append([art2])
+"""
 
-
+""" DISABLED
 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)
     artist1.append([*art1_1.collections, art1_2])
+"""
 
-
+""" DISABLED
 def update_validation_history_for_fit(ax, val_list, artist3):
-    """Updates the validation accuracy history plot."""
+
     period = list(range(1, len(val_list) + 1))
     art3 = ax.plot(
         period, 
@@ -691,19 +692,21 @@ def update_validation_history_for_fit(ax, val_list, artist3):
     ax.set_ylabel('Validation Accuracy')
     ax.set_ylim([0, 1])
     artist3.append(art3)
-
-
+"""
+    
+""" DISABLED
 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)
     return ani
-
+"""
+    
 def show():
     plt.tight_layout()
     plt.show()
 
 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
     viz_objects = {}
     
@@ -745,7 +748,7 @@ def initialize_visualization_for_learner(show_history, neurons_history, neural_w
     return viz_objects
 
 def update_history_plots_for_learner(viz_objects, depth_list, loss_list, best_acc_per_depth_list, x_train, final_activations):
-    """Update history visualization plots"""
+
     if 'history' not in viz_objects:
         return
     
@@ -772,7 +775,7 @@ def update_history_plots_for_learner(viz_objects, depth_list, loss_list, best_ac
     hist['artist3'].append(art3)
 
 def display_visualizations_for_learner(viz_objects, best_weights, data, best_acc, test_loss, y_train, interval):
-    """Display all final visualizations"""
+
     if 'history' in viz_objects:
         hist = viz_objects['history']
         for _ in range(30):