pyerualjetwork 4.2.9b7__py3-none-any.whl → 4.3.0.1__py3-none-any.whl

{pyerualjetwork → pyerualjetwork-jetstorm}/plan_cuda.py

@@ -16,31 +16,21 @@ PYERUALJETWORK document: https://github.com/HCB06/PyerualJetwork/blob/main/Welco
 """
 
 import cupy as cp
-import math
 
 ### LIBRARY IMPORTS ###
 from .ui import loading_bars, initialize_loading_bar
-from .data_operations_cuda import normalization, decode_one_hot, batcher
+from .data_operations_cuda import normalization
 from .loss_functions_cuda import binary_crossentropy, categorical_crossentropy
-from .activation_functions_cuda import apply_activation, Softmax, all_activations
+from .activation_functions_cuda import apply_activation, all_activations
 from .metrics_cuda import metrics
 from .model_operations_cuda import get_acc, get_preds, get_preds_softmax
 from .memory_operations import transfer_to_gpu, transfer_to_cpu, optimize_labels
 from .visualizations_cuda import (
     draw_neural_web,
-    update_neural_web_for_fit,
-    plot_evaluate,
-    update_neuron_history,
-    initialize_visualization_for_fit,
-    update_weight_visualization_for_fit,
-    update_decision_boundary_for_fit,
-    update_validation_history_for_fit,
-    display_visualization_for_fit,
     display_visualizations_for_learner,
     update_history_plots_for_learner,
     initialize_visualization_for_learner,
-    update_neuron_history_for_learner,
-    show
+    update_neuron_history_for_learner
 )
 
 ### GLOBAL VARIABLES ###
@@ -52,144 +42,42 @@ bar_format_learner = loading_bars()[1]
 def fit(
     x_train,
     y_train,
-    val=False,
-    val_count=None,
     activation_potentiation=['linear'],
-    x_val=None,
-    y_val=None,
-    show_training=None,
-    interval=100,
-    LTD=0,
-    decision_boundary_status=True,
-    train_bar=True,
-    auto_normalization=True,
-    neurons_history=False,
-    dtype=cp.float32,
-    memory='gpu'
+    W=None,
+    dtype=cp.float32
 ):
     """
-    Creates a model to fitting data.
+    Creates a model to fitting data.,
     
     fit Args:
 
-        x_train (list[num]): List or numarray of input data.
+        x_train (aray-like[cupy]): List or cupy array of input data.
 
-        y_train (list[num]): List or numarray of target labels. (one hot encoded)
-
-        val (None or True): validation in training process ? None or True default: None (optional)
-
-        val_count (None or int): After how many examples learned will an accuracy test be performed? default: 10=(%10) it means every approximately 10 step (optional)
+        y_train (aray-like[cupy]): List or cupy array of target labels. (one hot encoded)
 
         activation_potentiation (list): For deeper PLAN networks, activation function parameters. For more information please run this code: plan.activations_list() default: [None] (optional)
 
-        x_val (list[num]): List of validation data. default: x_train (optional)
-
-        y_val (list[num]): (list[num]): List of target labels. (one hot encoded) default: y_train (optional)
-
-        show_training (bool, str): True or None default: None (optional)
-
-        LTD (int): Long Term Depression Hyperparameter for train PLAN neural network default: 0 (optional)
-
-        interval (float, int): frame delay (milisecond) parameter for Training Report (show_training=True) This parameter effects to your Training Report performance. Lower value is more diffucult for Low end PC's (33.33 = 30 FPS, 16.67 = 60 FPS) default: 100 (optional)
-
-        decision_boundary_status (bool): If the visualization of validation and training history is enabled during training, should the decision boundaries also be visualized? True or False. Default is True. (optional)
-
-        train_bar (bool): Training loading bar? True or False. Default is True. (optional)
-
-        auto_normalization(bool): Normalization process during training. May effect training time and model quality. True or False. Default is True. (optional)
-
-        neurons_history (bool, optional): Shows the history of changes that neurons undergo during the CL (Cumulative Learning) stages. True or False. Default is False. (optional)
-
-        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)
-
-        memory (str): The memory parameter determines whether the dataset to be processed on the GPU will be stored in the CPU's RAM or the GPU's RAM. Options:  'gpu', 'cpu'. Default: 'gpu'.
+        W (cupy.ndarray): 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)
 
     Returns:
-        numpyarray([num]): (Weight matrix).
+        cupyarray: (Weight matrix).
     """
-    # Pre-checks
+    # Pre-check
     
-    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:
-        train_progress = initialize_loading_bar(total=len(x_train), ncols=44, desc='Fitting', bar_format=bar_format_normal)
+    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.")
-
-    if val and (x_val is None or y_val is None):
-        x_val, y_val = x_train, y_train
-
-    if memory == 'gpu':
-        x_train = transfer_to_gpu(x_train, dtype=dtype)
-        y_train = transfer_to_gpu(y_train, dtype=y_train.dtype)
+    LTPW = cp.zeros((len(y_train[0]), len(x_train[0].ravel()))).astype(dtype, copy=False) if W is None else W
 
-        if val:
-            x_val = transfer_to_gpu(x_val, dtype=dtype)
-            y_val = transfer_to_gpu(y_val, dtype=y_train.dtype)
-
-    elif memory == 'cpu':
-        x_train = transfer_to_cpu(x_train, dtype=dtype)
-        y_train = transfer_to_cpu(y_train, dtype=y_train.dtype)
-
-        if val:
-            x_val = transfer_to_cpu(x_val, dtype=dtype)
-            y_val = transfer_to_cpu(y_val, dtype=y_train.dtype)
-
-    else:
-        raise ValueError("memory parameter must be 'cpu' or 'gpu'.")
-
-    val_list = [] if val else None
-    val_count = val_count or 10
-    # Defining weights
-    STPW = cp.ones((len(y_train[0]), len(x_train[0].ravel()))).astype(dtype, copy=False)  # STPW = SHORT TERM POTENTIATION WEIGHT
-    LTPW = cp.zeros((len(y_train[0]), len(x_train[0].ravel()))).astype(dtype, copy=False)  # LTPW = LONG TERM POTENTIATION WEIGHT
-    # Initialize visualization
-    vis_objects = initialize_visualization_for_fit(val, show_training, neurons_history, x_train, y_train)
-   
-    # Training process
-    for index, inp in enumerate(x_train):
-        inp = transfer_to_gpu(inp, dtype=dtype).ravel()
-        y_decoded = decode_one_hot(cp.array(y_train[index], copy=False, dtype=y_train.dtype))
-        # Weight updates
-        STPW = feed_forward(inp, STPW, is_training=True, Class=y_decoded, activation_potentiation=activation_potentiation, LTD=LTD)
-        LTPW += normalization(STPW, dtype=dtype) if auto_normalization else STPW
-
-        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, memory=memory)[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)
-
-        STPW = cp.ones((len(y_train[0]), len(x_train[0].ravel()))).astype(dtype, copy=False)
-
-    if show_training:
-        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()
+    x_train = apply_activation(x_train, activation_potentiation)
+    LTPW += cp.array(y_train, dtype=optimize_labels(y_train, cuda=True).dtype).T @ x_train
 
     return normalization(LTPW, dtype=dtype)
 
 
 def learner(x_train, y_train, optimizer, fit_start, strategy='accuracy', gen=None, batch_size=1,
-           neural_web_history=False, show_current_activations=False, auto_normalization=True,
+           neural_web_history=False, show_current_activations=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'):
@@ -234,8 +122,6 @@ def learner(x_train, y_train, optimizer, fit_start, strategy='accuracy', gen=Non
 
         early_stop (bool, optional): If True, implements early stopping during training.(If train accuracy not improves in two gen stops learning.) Default is False.
 
-        auto_normalization (bool, optional): IMPORTANT: auto_nomralization parameter works only if fit_start is True. Do not change this value if fit_start is False, because it doesnt matter.) If auto normalization=False this makes more faster training times and much better accuracy performance for some datasets. Default is True.
-
         show_current_activations (bool, optional): Should it display the activations selected according to the current strategies during learning, or not? (True or False) This can be very useful if you want to cancel the learning process and resume from where you left off later. After canceling, you will need to view the live training activations in order to choose the activations to be given to the 'start_this' parameter. Default is False
 
         show_history (bool, optional): If True, displays the training history after optimization. Default is False.
@@ -339,10 +225,10 @@ def learner(x_train, y_train, optimizer, fit_start, strategy='accuracy', gen=Non
  
             if fit_start is True and i == 0:
                 act_pop.append(activation_potentiation[j])
-                W = fit(x_train_batch, y_train_batch, activation_potentiation=act_pop[-1], train_bar=False, auto_normalization=auto_normalization, dtype=dtype)
+                W = fit(x_train_batch, y_train_batch, activation_potentiation=act_pop[-1], dtype=dtype)
                 weight_pop.append(W)
             
-            model = evaluate(x_train_batch, y_train_batch, W=weight_pop[j], loading_bar_status=False, activation_potentiation=act_pop[j], dtype=dtype, memory=memory)
+            model = evaluate(x_train_batch, y_train_batch, W=weight_pop[j])
             acc = model[get_acc()]
             
             if strategy == 'accuracy': target_pop.append(acc)
@@ -374,8 +260,9 @@ def learner(x_train, y_train, optimizer, fit_start, strategy='accuracy', gen=Non
                 (strategy == 'recall' and recall_score >= best_recall)):
 
                 best_acc = acc
-                best_weights = weight_pop[j]
-                final_activations = act_pop[j]
+                best_weights = cp.copy(weight_pop[j])
+                final_activations = act_pop[j].copy() if isinstance(act_pop[j], list) else act_pop[j]
+
                 best_model = model
 
                 final_activations = [final_activations[0]] if len(set(final_activations)) == 1 else final_activations # removing if all same
@@ -427,7 +314,7 @@ def learner(x_train, y_train, optimizer, fit_start, strategy='accuracy', gen=Non
                 if target_acc is not None and best_acc >= target_acc:
                     progress.close()
                     train_model = evaluate(x_train, y_train, W=best_weights, loading_bar_status=False, 
-                                        activation_potentiation=final_activations, dtype=dtype)
+                                        activation_potentiation=final_activations)
 
                     if loss == 'categorical_crossentropy':
                         train_loss = categorical_crossentropy(y_true_batch=y_train, 
@@ -437,8 +324,8 @@ def learner(x_train, y_train, optimizer, fit_start, strategy='accuracy', gen=Non
                                                        y_pred_batch=train_model[get_preds_softmax()])
 
                     print('\nActivations: ', final_activations)
-                    print(f'Train Accuracy (%{batch_size * 100} of train samples):', train_model[get_acc()])
-                    print(f'Train Loss (%{batch_size * 100} of train samples): ', train_loss, '\n')
+                    print(f'Train Accuracy:', train_model[get_acc()])
+                    print(f'Train Loss: ', train_loss, '\n')
                 
                     # Display final visualizations
                     display_visualizations_for_learner(viz_objects, best_weights, data, best_acc, 
@@ -448,8 +335,8 @@ def learner(x_train, y_train, optimizer, fit_start, strategy='accuracy', gen=Non
                 # Check target loss
                 if target_loss is not None and best_loss <= target_loss:
                     progress.close()
-                    train_model = evaluate(x_train, y_train, W=best_weights, loading_bar_status=False, 
-                                        activation_potentiation=final_activations, dtype=dtype)
+                    train_model = evaluate(x_train, y_train, W=best_weights, 
+                                        activation_potentiation=final_activations)
 
                     if loss == 'categorical_crossentropy':
                         train_loss = categorical_crossentropy(y_true_batch=y_train, 
@@ -459,8 +346,8 @@ def learner(x_train, y_train, optimizer, fit_start, strategy='accuracy', gen=Non
                                                        y_pred_batch=train_model[get_preds_softmax()])
 
                     print('\nActivations: ', final_activations)
-                    print(f'Train Accuracy (%{batch_size * 100} of train samples):', train_model[get_acc()])
-                    print(f'Train Loss (%{batch_size * 100} of train samples): ', train_loss, '\n')
+                    print(f'Train Accuracy: ', train_model[get_acc()])
+                    print(f'Train Loss: ', train_loss, '\n')
 
                     # Display final visualizations
                     display_visualizations_for_learner(viz_objects, best_weights, data, best_acc, 
@@ -479,8 +366,8 @@ def learner(x_train, y_train, optimizer, fit_start, strategy='accuracy', gen=Non
         if early_stop == True and i > 0:
             if best_acc_per_gen_list[i] == best_acc_per_gen_list[i-1]:
                 progress.close()
-                train_model = evaluate(x_train, y_train, W=best_weights, loading_bar_status=False, 
-                                    activation_potentiation=final_activations, dtype=dtype, memory=memory)
+                train_model = evaluate(x_train, y_train, W=best_weights,
+                                    activation_potentiation=final_activations)
 
                 if loss == 'categorical_crossentropy':
                     train_loss = categorical_crossentropy(y_true_batch=y_train, 
@@ -490,8 +377,8 @@ def learner(x_train, y_train, optimizer, fit_start, strategy='accuracy', gen=Non
                                                    y_pred_batch=train_model[get_preds_softmax()])
 
                 print('\nActivations: ', final_activations)
-                print(f'Train Accuracy (%{batch_size * 100} of train samples):', train_model[get_acc()])
-                print(f'Train Loss (%{batch_size * 100} of train samples): ', train_loss, '\n')
+                print(f'Train Accuracy:', train_model[get_acc()])
+                print(f'Train Loss: ', train_loss, '\n')
 
                 # Display final visualizations
                 display_visualizations_for_learner(viz_objects, best_weights, data, best_acc, 
@@ -500,8 +387,8 @@ def learner(x_train, y_train, optimizer, fit_start, strategy='accuracy', gen=Non
 
     # Final evaluation
     progress.close()
-    train_model = evaluate(x_train, y_train, W=best_weights, loading_bar_status=False, 
-                        activation_potentiation=final_activations, dtype=dtype, memory=memory)
+    train_model = evaluate(x_train, y_train, W=best_weights,
+                        activation_potentiation=final_activations)
 
     if loss == 'categorical_crossentropy':
         train_loss = categorical_crossentropy(y_true_batch=y_train, y_pred_batch=train_model[get_preds_softmax()])
@@ -509,70 +396,18 @@ def learner(x_train, y_train, optimizer, fit_start, strategy='accuracy', gen=Non
         train_loss = binary_crossentropy(y_true_batch=y_train, y_pred_batch=train_model[get_preds_softmax()])
 
     print('\nActivations: ', final_activations)
-    print(f'Train Accuracy (%{batch_size * 100} of train samples):', train_model[get_acc()])
-    print(f'Train Loss (%{batch_size * 100} of train samples): ', train_loss, '\n')
+    print(f'Train Accuracy: ', train_model[get_acc()])
+    print(f'Train Loss : ', train_loss, '\n')
 
     # Display final visualizations
     display_visualizations_for_learner(viz_objects, best_weights, data, best_acc, train_loss, y_train, interval)
     return best_weights, best_model[get_preds()], best_acc, final_activations
 
-
-
-def feed_forward(
-    Input,               # list[num]: Input data.
-    w,                   # num: Weight matrix of the neural network.
-    is_training,        # bool: Flag indicating if the function is called during training (True or False).
-    activation_potentiation,
-    Class='?',               # int: Which class is, if training. # (list): Activation potentiation list for deep PLAN. (optional)
-    LTD=0
-) -> tuple:
-    """
-    Applies feature extraction process to the input data using synaptic potentiation.
-
-    Args:
-        Input (num): Input data.
-        w (num): Weight matrix of the neural network.
-        is_training (bool): Flag indicating if the function is called during training (True or False).
-        Class (int): if is during training then which class(label) ? is isnt then put None.
-        # activation_potentiation (list): ac list for deep PLAN. default: [None] ('linear') (optional)
-
-    Returns:
-        tuple: A tuple (vector) containing the neural layer result and the updated weight matrix.
-        or
-        num: neural network output
-    """
-    
-    Output = apply_activation(Input, activation_potentiation)
-
-    Input = Output
-
-    if is_training == True:
-        
-        for _ in range(LTD):        
-
-            depression_vector = cp.random.rand(*Input.shape)
-
-            Input -= depression_vector
-
-        w[Class, :] = Input
-        return w
-
-    else:
-
-        neural_layer = cp.dot(w, Input)
-
-        return neural_layer
-   
-
 def evaluate(
     x_test,
     y_test,
     W,
-    activation_potentiation=['linear'],
-    loading_bar_status=True,
-    show_metrics=False,
-    dtype=cp.float32,
-    memory='gpu'
+    activation_potentiation=['linear']
 ) -> tuple:
     """
     Evaluates the neural network model using the given test data.
@@ -582,70 +417,16 @@ def evaluate(
 
         y_test (cp.ndarray): Test labels (one-hot encoded).
 
-        W (list[cp.ndarray]): Neural net weight matrix.
+        W (cp.ndarray): Neural net weight matrix.
         
         activation_potentiation (list): Activation list. Default = ['linear'].
         
-        loading_bar_status (bool): Loading bar (optional). Default = True.
-
-        show_metrics (bool): Visualize metrics ? (optional). Default = False.
-
-        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)
-
-        memory (str): The memory parameter determines whether the dataset to be processed on the GPU will be stored in the CPU's RAM or the GPU's RAM. Options:  'gpu', 'cpu'. Default: 'gpu'.
-
     Returns:
         tuple: Model (list).
     """
 
-    if memory == 'gpu':
-        x_test = transfer_to_gpu(x_test, dtype=dtype)
-        y_test = transfer_to_gpu(y_test, dtype=y_test.dtype)
-
-    elif memory == 'cpu':
-        x_test = transfer_to_cpu(x_test, dtype=dtype)
-        y_test = transfer_to_cpu(y_test, dtype=y_test.dtype)
-
-    else:
-        raise ValueError("memory parameter must be 'cpu' or 'gpu'.")
-
-    predict_probabilitys = cp.empty((len(x_test), W.shape[0]), dtype=dtype)
-    real_classes = cp.empty(len(x_test), dtype=y_test.dtype)   
-    predict_classes = cp.empty(len(x_test), dtype=y_test.dtype)
-
-    true_predict = 0
-    acc_list = cp.empty(len(x_test), dtype=dtype)
-
-    if loading_bar_status:
-        loading_bar = initialize_loading_bar(total=len(x_test), ncols=64, desc='Testing', bar_format=bar_format_normal)
-
-    for inpIndex in range(len(x_test)):
-        Input = transfer_to_gpu(x_test[inpIndex], dtype=dtype).ravel()
-        neural_layer = Input
-
-        neural_layer = feed_forward(neural_layer, cp.copy(W), is_training=False, Class='?', activation_potentiation=activation_potentiation)
-
-        predict_probabilitys[inpIndex] = Softmax(neural_layer)
-
-        RealOutput = decode_one_hot(transfer_to_gpu(y_test[inpIndex], dtype=y_test[inpIndex].dtype))
-        real_classes[inpIndex] = RealOutput
-        PredictedOutput = cp.argmax(neural_layer)
-        predict_classes[inpIndex] = PredictedOutput
-
-        if RealOutput == PredictedOutput:
-            true_predict += 1
-        
-        acc = true_predict / (inpIndex + 1)
-        acc_list[inpIndex] = acc
-
-        if loading_bar_status:
-            loading_bar.update(1)
-            loading_bar.set_postfix({"Test Accuracy": acc})
-
-    if loading_bar_status:
-        loading_bar.close()
-
-    if show_metrics:
-        plot_evaluate(x_test, y_test, predict_classes, acc_list, W=cp.copy(W), activation_potentiation=activation_potentiation)
+    x_test = apply_activation(x_test, activation_potentiation)
+    result = x_test @ W.T
+    softmax_preds = cp.exp(result) / cp.sum(cp.exp(result), axis=1, keepdims=True); accuracy = (cp.argmax(result, axis=1) == cp.argmax(y_test, axis=1)).mean()
 
-    return W, predict_classes, acc_list[-1], None, None, predict_probabilitys
+    return W, None, accuracy, None, None, softmax_preds

{pyerualjetwork → pyerualjetwork-jetstorm}/planeat.py

@@ -15,10 +15,8 @@ ANAPLAN document: https://github.com/HCB06/Anaplan/blob/main/Welcome_to_Anaplan/
 import numpy as np
 import random
 import math
-import copy
 
 ### LIBRARY IMPORTS ###
-from .plan import feed_forward
 from .data_operations import normalization
 from .ui import loading_bars, initialize_loading_bar
 from .activation_functions import apply_activation, all_activations
@@ -279,7 +277,7 @@ def evolver(weights,
 
    good_activations = list(activation_potentiations[slice_center:])
    bad_activations = list(activation_potentiations[:slice_center])
-   best_activations =  copy.deepcopy(good_activations[-1])
+   best_activations = good_activations[-1].copy() if isinstance(good_activations[-1], list) else good_activations[-1]
 
    
 ### PLANEAT IS APPLIED ACCORDING TO THE SPECIFIED POLICY, STRATEGY, AND PROBABILITY CONFIGURATION:
@@ -293,10 +291,11 @@ def evolver(weights,
    epsilon = np.finfo(float).eps
 
    child_W = np.copy(bad_weights)
-   child_act = copy.deepcopy(bad_activations)
+   child_act = bad_activations.copy()
 
    mutated_W = np.copy(bad_weights)
-   mutated_act = copy.deepcopy(bad_activations)
+   mutated_act = bad_activations.copy()
+
 
    for i in range(len(bad_weights)):
       
@@ -400,7 +399,7 @@ def evolver(weights,
    return weights, activation_potentiations
 
 
-def evaluate(x_population, weights, activation_potentiations, rl_mode=False, dtype=np.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.
@@ -413,62 +412,30 @@ 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 (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:
         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 = np.array(x_population, copy=False, dtype=dtype)
-      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)
-      
-   else:
-      outputs = [0] * len(x_population)
-      for i, genome in enumerate(x_population):
-
-         Input = np.array(genome, copy=False)
-         Input = Input.ravel()
 
-         if isinstance(activation_potentiations[i], str):
-            activation_potentiations[i] = [activation_potentiations[i]]
+   if isinstance(activation_potentiations, str):
+    activation_potentiations = [activation_potentiations]
+   else:
+    activation_potentiations = [item if isinstance(item, list) else [item] for item in activation_potentiations]
 
-         outputs[i] = feed_forward(Input=Input, is_training=False, activation_potentiation=activation_potentiations[i], w=weights[i])
+   x_population = apply_activation(x_population, activation_potentiations)
+   result = x_population @ weights.T
 
-   return outputs
+   return result
 
 
 def cross_over(first_parent_W,