pyerualjetwork 4.3.8.dev15__py3-none-any.whl → 4.3.9b1__py3-none-any.whl

pyerualjetwork/plan.py

@@ -16,31 +16,21 @@ PYERUALJETWORK document: https://github.com/HCB06/PyerualJetwork/blob/main/Welco
 """
 
 import numpy as np
-import math
 
 ### LIBRARY IMPORTS ###
 from .ui import loading_bars, initialize_loading_bar
-from .data_operations import normalization, decode_one_hot, batcher
+from .data_operations import normalization, batcher
 from .loss_functions import binary_crossentropy, categorical_crossentropy
-from .activation_functions import apply_activation, Softmax, all_activations
+from .activation_functions import apply_activation, all_activations
 from .metrics import metrics
 from .model_operations import get_acc, get_preds, get_preds_softmax
 from .memory_operations import optimize_labels
 from .visualizations 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,18 +42,9 @@ 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,
+    W=None,
+    normalization=False,
     dtype=np.float32
 ):
     """
@@ -71,110 +52,39 @@ def fit(
     
     fit Args:
 
-        x_train (list[num]): List or numarray of input data.
+        x_train (aray-like[num]): List or numarray 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[num]): List or numarray 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)
+        W (numpy.ndarray): If you want to re-continue or update model
 
-        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)
+        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:
-        numpyarray([num]): (Weight matrix).
+        numpyarray: (Weight matrix).
     """
 
-    # Pre-checks
+    # Pre-check
+    
+    if len(x_train) != len(y_train): raise ValueError("x_train and y_train must have the same length.")
 
-    x_train = x_train.astype(dtype, copy=False)
+    weight = np.zeros((len(y_train[0]), len(x_train[0].ravel()))).astype(dtype, copy=False) if W is None else W
 
-    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 val and (x_val is None and y_val is None):
-        x_val, y_val = x_train, y_train
-
-    elif val and (x_val is not None and y_val is not None):
-        x_val = x_val.astype(dtype, copy=False)
-        y_val = y_val.astype(dtype, copy=False)
-
-    val_list = [] if val else None
-    val_count = val_count or 10
-    # Defining weights
-    STPW = np.ones((len(y_train[0]), len(x_train[0].ravel()))).astype(dtype, copy=False)  # STPW = SHORT TIME POTENTIATION WEIGHT
-    LTPW = np.zeros((len(y_train[0]), len(x_train[0].ravel()))).astype(dtype, copy=False)  # LTPW = LONG TIME 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 = np.array(inp, copy=False).ravel()
-        y_decoded = decode_one_hot(y_train[index])
-        # 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)[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 = np.ones((len(y_train[0]), len(x_train[0].ravel()))).astype(dtype, copy=False)
-
-    # Finalize visualization
-    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 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')
     
-    if neurons_history:
-        ani5 = display_visualization_for_fit(vis_objects['fig1'], vis_objects['artist5'], interval)
-        show()
+    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,
-           neural_web_history=False, show_current_activations=False, auto_normalization=True,
+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, 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):
@@ -218,14 +128,16 @@ def learner(x_train, y_train, optimizer, fit_start, strategy='accuracy', gen=Non
 
         batch_size (float, optional): Batch size is used in the prediction process to receive train feedback by dividing the test data into chunks and selecting activations based on randomly chosen partitions. This process reduces computational cost and time while still covering the entire test set due to random selection, so it doesn't significantly impact accuracy. For example, a batch size of 0.08 means each train batch represents 8% of the train set. Default is 1. (%100 of train)
 
-        early_stop (bool, optional): If True, implements early stopping during training.(If accuracy not improves in two gen stops learning.) Default is False.
+        pop_size (int, optional): Population size of each generation. Default: count of activation functions
 
-        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.
+        early_stop (bool, optional): If True, implements early stopping during training.(If accuracy not improves in two gen stops learning.) Default is False.
 
         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.
 
+        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.
@@ -253,14 +165,19 @@ def learner(x_train, y_train, optimizer, fit_start, strategy='accuracy', gen=Non
 
     data = 'Train'
 
-    activation_potentiation = all_activations()
+    except_this = ['spiral', 'circular']
+    activation_potentiation = [item for item in all_activations() if item not in except_this]
     activation_potentiation_len = len(activation_potentiation)
    
     # Pre-checks
 
+    if pop_size is None: pop_size = activation_potentiation_len
+
     x_train = x_train.astype(dtype, copy=False)
     y_train = optimize_labels(y_train, cuda=False)
 
+    if pop_size < activation_potentiation_len: raise ValueError(f"pop_size must be higher or equal to {activation_potentiation_len}")
+
     if gen is None:
         gen = activation_potentiation_len
 
@@ -273,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
@@ -289,16 +206,16 @@ def learner(x_train, y_train, optimizer, fit_start, strategy='accuracy', gen=Non
 
     progress = initialize_loading_bar(total=activation_potentiation_len, desc="", ncols=ncols, bar_format=bar_format_learner)
 
-    if fit_start is False:
-        weight_pop, act_pop = define_genomes(input_shape=len(x_train[0]), output_shape=len(y_train[0]), population_size=activation_potentiation_len, dtype=dtype)
+    if fit_start is False or pop_size > activation_potentiation_len:
+        weight_pop, act_pop = define_genomes(input_shape=len(x_train[0]), output_shape=len(y_train[0]), population_size=pop_size, dtype=dtype)
     
         if start_this_act is not None and start_this_W is not None:
             weight_pop[0] = start_this_W
             act_pop[0] = start_this_act
 
     else:
-        weight_pop = []
-        act_pop = []
+        weight_pop = [0] * pop_size
+        act_pop = [0] * pop_size
 
     for i in range(gen):
         postfix_dict["Gen"] = str(i+1) + '/' + str(gen)
@@ -308,16 +225,16 @@ def learner(x_train, y_train, optimizer, fit_start, strategy='accuracy', gen=Non
         progress.last_print_n = 0
         progress.update(0)
 
-        for j in range(activation_potentiation_len):
+        for j in range(pop_size):
 
             x_train_batch, y_train_batch = batcher(x_train, y_train, batch_size=batch_size)
             
-            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)
-                weight_pop.append(W)
+            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[j], normalization=normalization, dtype=dtype)
+                weight_pop[j] = W
             
-            model = evaluate(x_train_batch, y_train_batch, W=weight_pop[j], loading_bar_status=False, activation_potentiation=act_pop[j], dtype=dtype)
+            model = evaluate(x_train_batch, y_train_batch, W=weight_pop[j], activation_potentiation=act_pop[j])
             acc = model[get_acc()]
             
             if strategy == 'accuracy': target_pop.append(acc)
@@ -351,15 +268,14 @@ def learner(x_train, y_train, optimizer, fit_start, strategy='accuracy', gen=Non
                 best_acc = acc
                 best_weights = np.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
 
                 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='')
@@ -370,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
@@ -401,7 +314,7 @@ def learner(x_train, y_train, optimizer, fit_start, strategy='accuracy', gen=Non
                 # Check target accuracy
                 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, 
+                    train_model = evaluate(x_train, y_train, W=best_weights, 
                                         activation_potentiation=final_activations, dtype=dtype)
 
                     if loss == 'categorical_crossentropy':
@@ -412,8 +325,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 :', train_model[get_acc()])
-                    print(f'Train Loss : ', 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, 
@@ -423,7 +336,7 @@ 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, 
+                    train_model = evaluate(x_train, y_train, W=best_weights,
                                         activation_potentiation=final_activations, dtype=dtype)
 
                     if loss == 'categorical_crossentropy':
@@ -434,8 +347,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 :', train_model[get_acc()])
-                    print(f'Train Loss : ', 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, 
@@ -447,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 = []
 
@@ -454,7 +381,7 @@ 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, 
+                train_model = evaluate(x_train, y_train, W=best_weights, 
                                     activation_potentiation=final_activations, dtype=dtype)
 
                 if loss == 'categorical_crossentropy':
@@ -465,8 +392,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 :', train_model[get_acc()])
-                print(f'Train Loss : ', 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, 
@@ -475,7 +402,7 @@ 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, 
+    train_model = evaluate(x_train, y_train, W=best_weights, 
                         activation_potentiation=final_activations, dtype=dtype)
 
     if loss == 'categorical_crossentropy':
@@ -484,144 +411,38 @@ 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 :', train_model[get_acc()])
-    print(f'Train Loss : ', 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 = np.random.rand(*Input.shape)
-
-            Input -= depression_vector
-
-        w[Class, :] = Input
-        return w
-
-    else:
-
-        neural_layer = np.dot(w, Input)
-
-        return neural_layer
-
-
 def evaluate(
-    x_test,         # NumPy array: Test input data.
-    y_test,         # NumPy array: Test labels.
-    W,              # List of NumPy arrays: Neural network weight matrices.
-    activation_potentiation=['linear'], # List of activation functions.
-    loading_bar_status=True,  # Optionally show loading bar.
-    show_metrics=None,        # Optionally show metrics.
-    dtype=np.float32
+    x_test,
+    y_test,
+    W,
+    activation_potentiation=['linear']
 ) -> tuple:
     """
     Evaluates the neural network model using the given test data.
 
     Args:
-        x_test (np.ndarray): Test input data.
-        
-        y_test (np.ndarray): Test labels. one-hot encoded.
-        
-        W (list[np.ndarray]): List of neural network weight matrices.
-        
-        activation_potentiation (list): List of activation functions.
-        
-        loading_bar_status (bool): Option to show a loading bar (optional).
-        
-        show_metrics (bool): Option to show metrics (optional).
+        x_test (np.ndarray): Test data.
 
-        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!]
+        y_test (np.ndarray): Test labels (one-hot encoded).
 
+        W (np.ndarray): Neural net weight matrix.
+        
+        activation_potentiation (list): Activation list. Default = ['linear'].
+        
     Returns:
-        tuple: Predicted labels, model accuracy, and other evaluation metrics.
+        tuple: Model (list).
     """
-    # Pre-checks
-
-    x_test = x_test.astype(dtype, copy=False)
-
-    if len(y_test[0]) < 256:
-        if y_test.dtype != np.uint8:
-            y_test = np.array(y_test, copy=False).astype(np.uint8, copy=False)
-    elif len(y_test[0]) <= 32767:
-        if y_test.dtype != np.uint16:
-            y_test = np.array(y_test, copy=False).astype(np.uint16, copy=False)
-    else:
-        if y_test.dtype != np.uint32:
-            y_test = np.array(y_test, copy=False).astype(np.uint32, copy=False)
-
-    predict_probabilitys = np.empty((len(x_test), W.shape[0]), dtype=dtype)
-    real_classes = np.empty(len(x_test), dtype=y_test.dtype)     
-    predict_classes = np.empty(len(x_test), dtype=y_test.dtype)   
-
-    true_predict = 0
-    acc_list = np.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 = x_test[inpIndex].ravel() 
-
-        neural_layer = Input
-
-        neural_layer = feed_forward(neural_layer, np.copy(W), is_training=False, Class='?', activation_potentiation=activation_potentiation)
-
-        predict_probabilitys[inpIndex] = Softmax(neural_layer)
-
-        RealOutput = np.argmax(y_test[inpIndex])
-        real_classes[inpIndex] = RealOutput
-        PredictedOutput = np.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 the evaluation metrics
-        plot_evaluate(x_test, y_test, predict_classes, acc_list, W=np.copy(W), activation_potentiation=activation_potentiation)
+    x_test = apply_activation(x_test, activation_potentiation)
+    result = x_test @ W.T
+    softmax_preds = np.exp(result) / np.sum(np.exp(result), axis=1, keepdims=True); accuracy = (np.argmax(result, axis=1) == np.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