pyerualjetwork 5.1__py3-none-any.whl → 5.5__py3-none-any.whl

pyerualjetwork/{neu_cpu.py → nn.py}

@@ -2,9 +2,9 @@
 """ 
 
 
-NEU (Neural Networks) on CPU
+NN (Neural Networks)
 ============================
-This module hosts functions for training and evaluating artificial neural networks on CPU for labeled classification tasks (for now).
+This module hosts functions for training and evaluating artificial neural networks for labeled classification tasks.
 
 Currently, 3 types of models can be trained:
 
@@ -40,7 +40,7 @@ Examples: https://github.com/HCB06/PyerualJetwork/tree/main/Welcome_to_PyerualJe
 
 PyerualJetwork document: https://github.com/HCB06/PyerualJetwork/blob/main/Welcome_to_PyerualJetwork/PYERUALJETWORK_USER_MANUEL_AND_LEGAL_INFORMATION(EN).pdf
 
-- Author: Hasan Can Beydili
+- Creator: Hasan Can Beydili
 - YouTube: https://www.youtube.com/@HasanCanBeydili
 - Linkedin: https://www.linkedin.com/in/hasan-can-beydili-77a1b9270/
 - Instagram: https://www.instagram.com/canbeydilj
@@ -48,24 +48,16 @@ PyerualJetwork document: https://github.com/HCB06/PyerualJetwork/blob/main/Welco
 """
 
 import numpy as np
+import cupy as cp
 import copy
 import random
 
 ### LIBRARY IMPORTS ###
 from .ui import loading_bars, initialize_loading_bar
-from .data_operations_cpu import normalization, batcher
-from .activation_functions_cpu import apply_activation, all_activations
-from .model_operations_cpu import get_acc, get_preds_softmax
-from .memory_operations import optimize_labels
-from .loss_functions_cpu import categorical_crossentropy, binary_crossentropy
+from .cpu.activation_functions import all_activations
+from .model_ops import get_acc, get_preds_softmax, get_preds
+from .memory_ops import optimize_labels, transfer_to_gpu
 from .fitness_functions import wals
-from .visualizations_cpu import (
-    draw_neural_web,
-    display_visualizations_for_learner,
-    update_history_plots_for_learner,
-    initialize_visualization_for_learner,
-    update_neuron_history_for_learner
-)
 
 ### GLOBAL VARIABLES ###
 bar_format_normal = loading_bars()[0]
@@ -79,48 +71,61 @@ def plan_fit(
     activations=['linear'],
     W=None,
     auto_normalization=False,
+    cuda=False,
     dtype=np.float32
 ):
     """
     Creates a PLAN model to fitting data.
     
     Args:
-        x_train (aray-like[num]): List or numarray of input data.
+        x_train (aray-like[num or cup]): List or numarray of input data.
 
-        y_train (aray-like[num]): List or numarray of target labels. (one hot encoded)
+        y_train (aray-like[num or cup]): List or numarray of target labels. (one hot encoded)
 
         activations (list): For deeper PLAN networks, activation function parameters. For more information please run this code: neu.activations_list() default: [None] (optional)
 
-        W (numpy.ndarray): If you want to re-continue or update model
+        W (numpy.ndarray or cupy.ndarray): If you want to re-continue or update model
 
         auto_normalization (bool, optional): Normalization may solves overflow problem. Default: False
 
+        cuda (bool, optional): CUDA GPU acceleration ? Default = False.
+        
         dtype (numpy.dtype): Data type for the arrays. np.float32 by default. Example: np.float64 or np.float16.
 
     Returns:
         numpyarray: (Weight matrix).
     """
+    
+    from .cpu.data_ops import normalization
+    if not cuda:
+        from cpu.activation_functions import apply_activation
+        array_type = np
 
+    else:
+        from .cuda.activation_functions import apply_activation
+        array_type = cp
+        
+        
     # Pre-check
 
     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
+    weight = array_type.zeros((len(y_train[0]), len(x_train[0].ravel()))).astype(dtype, copy=False) if W is None else W
 
     if auto_normalization is True: x_train = normalization(apply_activation(x_train, activations))
     elif auto_normalization is False: x_train = apply_activation(x_train, activations)
     else: raise ValueError('normalization parameter only be True or False')
-    
-    weight += y_train.T @ x_train
 
-    return normalization(weight, dtype=dtype)
+    weight += y_train.T @ x_train if not cuda else cp.array(y_train).T @ cp.array(x_train)
 
+    return normalization(weight.get() if cuda else weight,dtype=dtype)
 
-def learn(x_train, y_train, optimizer, gen, pop_size, fit_start=True, batch_size=1,
+
+def learn(x_train, y_train, optimizer, template_model, gen, pop_size, fit_start=True, batch_size=1,
            weight_evolve=True, neural_web_history=False, show_current_activations=False, auto_normalization=False,
            neurons_history=False, early_stop=False, show_history=False, target_loss=None,
            interval=33.33, target_acc=None, loss='categorical_crossentropy', acc_impact=0.9, loss_impact=0.1,
-           start_this_act=None, start_this_W=None, neurons=[], activation_functions=[], dtype=np.float32):
+           start_this_act=None, start_this_W=None, neurons=[], activation_functions=[], decision_boundary_history=False, cuda=False, dtype=np.float32):
     """
     Optimizes the activation functions for a neural network by leveraging train data to find 
     the most accurate combination of activation potentiation(or activation function) & weight values for the labeled classificaiton dataset.
@@ -132,18 +137,29 @@ def learn(x_train, y_train, optimizer, gen, pop_size, fit_start=True, batch_size
     * This function also able to train classic MLP model architectures.
     * And my newest innovative architecture: PTNN (Potentiation Transfer Neural Network).
 
+    Examples:
+    
+        This creates a PLAN model: 
+            - ```model = learn(x_train, y_train, optimizer, template_model, pop_size=100, gen=100, fit_start=True) ```
+
+        This creates a MLP model(with 2 hidden layer): 
+            - ```model = learn(x_train, y_train, optimizer, template_model, pop_size=100, gen=100, fit_start=False, neurons=[64, 64], activation_functions=['tanh', 'tanh']) ```
+        
+        This creates a PTNN model(with 2 hidden layer & 1 aggregation layer(comes with PLAN)): 
+           -  ```model = learn(x_train, y_train, optimizer, template_model, pop_size=100, gen=[10, 100], fit_start=True, neurons=[64, 64], activation_functions=['tanh', 'tanh']) ```
+    
     :Args:
     :param x_train: (array-like): Training input data.
     :param y_train: (array-like): Labels for training data. one-hot encoded.
-    :param optimizer: (function): Optimization technique with hyperparameters. (PLAN, MLP & PTNN (all) using ENE for optimization. Gradient based technique's will added in the future.) Please use this: from pyerualjetwork.ene_cpu import evolver (and) optimizer = lambda *args, **kwargs: evolver(*args, 'here give your neat hyperparameters for example:  activation_add_prob=0.85', **kwargs) Example:
+    :param optimizer: (function): Optimization technique with hyperparameters. (PLAN, MLP & PTNN (all) using ENE for optimization. Gradient based technique's will added in the future.) Please use this: from pyerualjetwork.ene import evolver (and) optimizer = lambda *args, **kwargs: evolver(*args, 'here give your hyperparameters for example:  activation_add_prob=0.85', **kwargs) Example:
     ```python
-             optimizer = lambda *args, **kwargs: ene_cpu.evolver(*args,
+             optimizer = lambda *args, **kwargs: ene.evolver(*args,
                                                             activation_add_prob=0.05,
                                                             strategy='aggressive',
                                                             policy='more_selective',
                                                             **kwargs)
 
-             model = neu_cpu.learn(x_train,
+             model = nn.learn(x_train,
                             y_train,
                             optimizer,
                             fit_start=True,
@@ -152,6 +168,7 @@ def learn(x_train, y_train, optimizer, gen, pop_size, fit_start=True, batch_size
                             batch_size=0.05,
                             interval=16.67)
     ```
+    :param template_model: (tuple): Use --> get_model_template() function in the model_ops module.
     :param fit_start: (bool, optional): If the fit_start parameter is set to True, the initial generation population undergoes a simple short training process using the PLAN algorithm. This allows for a very robust starting point, especially for large and complex datasets. However, for small or relatively simple datasets, it may result in unnecessary computational overhead. When fit_start is True, completing the first generation may take slightly longer (this increase in computational cost applies only to the first generation and does not affect subsequent generations). If fit_start is set to False, the initial population will be entirely random. Additonaly if you want to train PTNN model you must be give True. Options: True or False. Default: True
     :param gen: (int or list): The generation count for genetic optimization. If you want to train PTNN model you must give a list of two number. First number for PLAN model training second number for MLP.
     :param batch_size: (float, optional): Batch size is used in the prediction process to receive train feedback by dividing the train data into chunks and selecting activations based on randomly chosen partitions. This process reduces computational cost and time while still covering the entire train 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)
@@ -172,29 +189,56 @@ def learn(x_train, y_train, optimizer, gen, pop_size, fit_start=True, batch_size
     :param start_this_act: (list, optional): To resume a previously canceled or interrupted training from where it left off, or to continue from that point with a different strategy, provide the list of activation functions selected up to the learned portion to this parameter. Default is None
     :param start_this_W: (numpy.array, optional): To resume a previously canceled or interrupted training from where it left off, or to continue from that point with a different strategy, provide the weight matrix of this genome. Default is None
     :param neurons: (list[int], optional): If you dont want train PLAN model this parameter represents neuron count of each hidden layer for MLP or PTNN. Number of elements --> Layer count. Default: [] (No hidden layer) --> architecture setted to PLAN, if not --> architecture setted to MLP.
+    :param decision_boundary_history: (bool, optional): At the end of the training, the decision boundary history is shown in animation form. Note: If you are sure of your memory, set it to True. Default: False
     :param activation_functions: (list[str], optional): If you dont want train PLAN model this parameter represents activation function of each hidden layer for MLP or PTNN. if neurons is not [] --> uses default: ['linear'] * len(neurons). if neurons is [] --> uses [].
     :param dtype: (numpy.dtype): Data type for the Weight matrices. np.float32 by default. Example: np.float64 or np.float16.
+    :param cuda: (bool, optional): CUDA GPU acceleration ? Default = False.
 
     Returns:
         tuple: A list for model parameters: [Weight matrix, Train Preds, Train Accuracy, [Activations functions]].
     """
 
-    from .ene_cpu import define_genomes
-
+    from .ene import define_genomes
+    from .cpu.visualizations import display_decision_boundary_history, create_decision_boundary_hist, plot_decision_boundary
+
+    if cuda is False: 
+        from .cpu.data_ops import batcher 
+        from .cpu.loss_functions import categorical_crossentropy, binary_crossentropy
+        from .cpu.visualizations import (
+        draw_neural_web,
+        display_visualizations_for_learner,
+        update_history_plots_for_learner,
+        initialize_visualization_for_learner,
+        update_neuron_history_for_learner)
+    
+    else:
+        from .cuda.data_ops import batcher
+        from .cuda.loss_functions import categorical_crossentropy, binary_crossentropy
+        from .cuda.visualizations import (
+        draw_neural_web,
+        display_visualizations_for_learner,
+        update_history_plots_for_learner,
+        initialize_visualization_for_learner,
+        update_neuron_history_for_learner)
+        
     data = 'Train'
 
     except_this = ['spiral', 'circular']
     activations = [item for item in all_activations() if item not in except_this]
     activations_len = len(activations)
-    
+
     # Pre-checks
 
+    if cuda: 
+        x_train = transfer_to_gpu(x_train, dtype=dtype)
+        y_train = transfer_to_gpu(y_train, dtype=dtype)
+        
     if pop_size > activations_len and fit_start is True:
         for _ in range(pop_size - len(activations)):
             random_index_all_act = random.randint(0, len(activations)-1)
             activations.append(activations[random_index_all_act])
 
-    y_train = optimize_labels(y_train, cuda=False)
+    y_train = optimize_labels(y_train, cuda=cuda)
 
     if pop_size < activations_len: raise ValueError(f"pop_size must be higher or equal to {activations_len}")
 
@@ -250,7 +294,7 @@ def learn(x_train, y_train, optimizer, gen, pop_size, fit_start=True, batch_size
     loss_list = []
     target_pop = []
 
-    progress = initialize_loading_bar(total=activations_len, desc="", ncols=77, bar_format=bar_format_learner)
+    progress = initialize_loading_bar(total=pop_size, desc="", ncols=77, 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]), neurons=neurons, activation_functions=activations, population_size=pop_size, dtype=dtype)
@@ -266,10 +310,10 @@ def learn(x_train, y_train, optimizer, gen, pop_size, fit_start=True, batch_size
     # LEARNING STARTED
     for i in range(gen):
 
-        # TRANSFORMATION PLAN TO MLP FOR PTNN (in later generations)
+      # TRANSFORMATION PLAN TO MLP FOR PTNN (in later generations)
         if model_type == 'PLAN' and transfer_learning:
             if i == gen_copy[0]:
-
+                
                 model_type = 'PTNN'
                 neurons = neurons_copy
 
@@ -308,24 +352,24 @@ def learn(x_train, y_train, optimizer, gen, pop_size, fit_start=True, batch_size
         progress.update(0)
 
         for j in range(pop_size):
-
-            x_train_batch, y_train_batch = batcher(x_train, y_train, batch_size=batch_size)
             
+            x_train_batch, y_train_batch = batcher(x_train, y_train, batch_size=batch_size)
+
             if fit_start is True and i == 0:
                 if start_this_act is not None and j == 0:
                     pass
                 else:
            
                     act_pop[j] = activations[j]
-                    W = plan_fit(x_train_batch, y_train_batch, activations=act_pop[j], auto_normalization=auto_normalization, dtype=dtype)
+                    W = plan_fit(x_train_batch, y_train_batch, activations=act_pop[j], cuda=cuda, auto_normalization=auto_normalization, dtype=dtype)
                     weight_pop[j] = W
 
 
             if weight_evolve is False:
-                weight_pop[j] = plan_fit(x_train_batch, y_train_batch, activations=act_pop[j], auto_normalization=auto_normalization, dtype=dtype)
+                weight_pop[j] = plan_fit(x_train_batch, y_train_batch, activations=act_pop[j], cuda=cuda, auto_normalization=auto_normalization, dtype=dtype)
 
 
-            model = evaluate(x_train_batch, y_train_batch, W=weight_pop[j], activations=act_pop[j], activation_potentiations=activation_potentiations[j], auto_normalization=auto_normalization, model_type=model_type)
+            model = evaluate(x_train_batch, y_train_batch, W=weight_pop[j], activations=act_pop[j], activation_potentiations=activation_potentiations[j], auto_normalization=auto_normalization, cuda=cuda, model_type=model_type)
             acc = model[get_acc()]
             
             if loss == 'categorical_crossentropy':
@@ -336,8 +380,8 @@ def learn(x_train, y_train, optimizer, gen, pop_size, fit_start=True, batch_size
                                             y_pred_batch=model[get_preds_softmax()])
 
             fitness = wals(acc, train_loss, acc_impact, loss_impact)
-            target_pop.append(fitness)
-
+            target_pop.append(fitness if not cuda else fitness.get())
+            
             if fitness >= best_fitness:
 
                 best_fitness = fitness
@@ -346,7 +390,13 @@ def learn(x_train, y_train, optimizer, gen, pop_size, fit_start=True, batch_size
                 best_weight = np.copy(weight_pop[j]) if model_type == 'PLAN' else copy.deepcopy(weight_pop[j])
                 best_model = model
 
-                final_activations = act_pop[j].copy() if isinstance(act_pop[j], list) else act_pop[j]
+                if isinstance(act_pop[j], list) and model_type == 'PLAN':
+                    final_activations = act_pop[j].copy()
+                elif isinstance(act_pop[j], str):
+                    final_activations = act_pop[j]
+                else:
+                    final_activations = copy.deepcopy(act_pop[j])
+                    
                 if model_type == 'PLAN': final_activations = [final_activations[0]] if len(set(final_activations)) == 1 else final_activations # removing if all same
 
                 if batch_size == 1:
@@ -382,7 +432,7 @@ def learn(x_train, y_train, optimizer, gen, pop_size, fit_start=True, batch_size
                 if target_acc is not None and best_acc >= target_acc:
                     progress.close()
                     train_model = evaluate(x_train, y_train, W=best_weight, 
-                                        activations=final_activations, activation_potentiations=activation_potentiation, auto_normalization=auto_normalization, model_type=model_type)
+                                        activations=final_activations, activation_potentiations=activation_potentiation, auto_normalization=auto_normalization, cuda=cuda, model_type=model_type)
                     if loss == 'categorical_crossentropy':
                         train_loss = categorical_crossentropy(y_true_batch=y_train, 
                                                            y_pred_batch=train_model[get_preds_softmax()])
@@ -396,15 +446,26 @@ def learn(x_train, y_train, optimizer, gen, pop_size, fit_start=True, batch_size
                     print('Train Loss: ', train_loss, '\n')
                     print('Model Type:', model_type)
                     
+                    if decision_boundary_history: display_decision_boundary_history(fig, artist, interval=interval)
+
                     display_visualizations_for_learner(viz_objects, best_weight, data, best_acc, 
                                               best_loss, y_train, interval)
-                    return best_weight, best_model[get_preds_softmax()], best_acc, final_activations, None, None, None, None, None, None, None, activation_potentiation
+                    
+                    model = template_model._replace(weights=best_weight,
+                                           predictions=best_model[get_preds()],
+                                           accuracy=best_acc,
+                                           activations=final_activations,
+                                           softmax_predictions=best_model[get_preds_softmax()],
+                                           model_type=model_type,
+                                           activation_potentiation=activation_potentiation)
+                    
+                    return model
             
                 # 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_weight,
-                                        activations=final_activations, activation_potentiations=activation_potentiation, auto_normalization=auto_normalization, model_type=model_type)
+                                        activations=final_activations, activation_potentiations=activation_potentiation, auto_normalization=auto_normalization, cuda=cuda, model_type=model_type)
 
                     if loss == 'categorical_crossentropy':
                         train_loss = categorical_crossentropy(y_true_batch=y_train, 
@@ -419,16 +480,33 @@ def learn(x_train, y_train, optimizer, gen, pop_size, fit_start=True, batch_size
                     print('Train Loss: ', train_loss, '\n')
                     print('Model Type:', model_type)
 
+                    if decision_boundary_history: display_decision_boundary_history(fig, artist, interval=interval)
+
                     # Display final visualizations
                     display_visualizations_for_learner(viz_objects, best_weight, data, best_acc, 
                                               train_loss, y_train, interval)
-                    return best_weight, best_model[get_preds_softmax()], best_acc, final_activations, None, None, None, None, None, None, None, activation_potentiation
+                    
+                    model = template_model._replace(weights=best_weight,
+                                           predictions=best_model[get_preds()],
+                                           accuracy=best_acc,
+                                           activations=final_activations,
+                                           softmax_predictions=best_model[get_preds_softmax()],
+                                           model_type=model_type,
+                                           activation_potentiation=activation_potentiation)
+                    
+                    return model
 
             
             progress.update(1)
 
+        if decision_boundary_history:
+            if i == 0: 
+                fig, ax = create_decision_boundary_hist()
+                artist = []
+            artist = plot_decision_boundary(x_train_batch, y_train_batch, activations=act_pop[np.argmax(target_pop)], W=weight_pop[np.argmax(target_pop)], cuda=cuda, model_type=model_type, ax=ax, artist=artist)
+
         if batch_size != 1:
-            train_model = evaluate(x_train, y_train, W=best_weight, activations=final_activations, activation_potentiations=activation_potentiation, auto_normalization=auto_normalization, model_type=model_type)
+            train_model = evaluate(x_train, y_train, W=best_weight, activations=final_activations, activation_potentiations=activation_potentiation, auto_normalization=auto_normalization, cuda=cuda, model_type=model_type)
     
             if loss == 'categorical_crossentropy':
                 train_loss = categorical_crossentropy(y_true_batch=y_train, 
@@ -459,7 +537,7 @@ def learn(x_train, y_train, optimizer, gen, pop_size, fit_start=True, batch_size
             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_weight, 
-                                    activations=final_activations, activation_potentiations=activation_potentiation, auto_normalization=auto_normalization, model_type=model_type)
+                                    activations=final_activations, activation_potentiations=activation_potentiation, auto_normalization=auto_normalization, cuda=cuda, model_type=model_type)
                 
             if loss == 'categorical_crossentropy':
                 train_loss = categorical_crossentropy(y_true_batch=y_train, 
@@ -474,16 +552,27 @@ def learn(x_train, y_train, optimizer, gen, pop_size, fit_start=True, batch_size
             print('Train Loss: ', train_loss, '\n')
             print('Model Type:', model_type)
 
+            if decision_boundary_history: display_decision_boundary_history(fig, artist, interval=interval)
+
             # Display final visualizations
             display_visualizations_for_learner(viz_objects, best_weight, data, best_acc, 
                                         train_loss, y_train, interval)
-            return best_weight, best_model[get_preds_softmax()], best_acc, final_activations, None, None, None, None, None, None, None, activation_potentiation
+            
+            model = template_model._replace(weights=best_weight,
+                                    predictions=best_model[get_preds()],
+                                    accuracy=best_acc,
+                                    activations=final_activations,
+                                    softmax_predictions=best_model[get_preds_softmax()],
+                                    model_type=model_type,
+                                    activation_potentiation=activation_potentiation)
+
+            return model
 
     # Final evaluation
     progress.close()
 
     train_model = evaluate(x_train, y_train, W=best_weight,
-                        activations=final_activations, activation_potentiations=activation_potentiation, auto_normalization=auto_normalization, model_type=model_type)
+                        activations=final_activations, activation_potentiations=activation_potentiation, auto_normalization=auto_normalization, cuda=cuda, model_type=model_type)
 
     if loss == 'categorical_crossentropy':
         train_loss = categorical_crossentropy(y_true_batch=y_train, 
@@ -492,25 +581,40 @@ def learn(x_train, y_train, optimizer, gen, pop_size, fit_start=True, batch_size
         train_loss = binary_crossentropy(y_true_batch=y_train, 
                                         y_pred_batch=train_model[get_preds_softmax()])
         
+
     print('\nActivations: ', final_activations)
     print('Activation Potentiation: ', activation_potentiation)
     print('Train Accuracy:', train_model[get_acc()])
     print('Train Loss: ', train_loss, '\n')
     print('Model Type:', model_type)
 
+    if decision_boundary_history: display_decision_boundary_history(fig, artist, interval=interval)
+
     # Display final visualizations
     display_visualizations_for_learner(viz_objects, best_weight, data, best_acc, train_loss, y_train, interval)
-    return best_weight, best_model[get_preds_softmax()], best_acc, final_activations, None, None, None, None, None, None, None, activation_potentiation
+    
+    model = template_model._replace(weights=best_weight,
+                            predictions=best_model[get_preds()],
+                            accuracy=best_acc,
+                            activations=final_activations,
+                            softmax_predictions=best_model[get_preds_softmax()],
+                            model_type=model_type,
+                            activation_potentiation=activation_potentiation)
+
+    return model
 
 
 def evaluate(
     x_test,
     y_test,
-    model_type,
-    W,
+    model=None,
+    model_type=None,
+    W=None,
     activations=['linear'],
     activation_potentiations=[],
-    auto_normalization=False
+    auto_normalization=False,
+    show_report=False,
+    cuda=False
 ) -> tuple:
     """
     Evaluates the neural network model using the given test data.
@@ -520,61 +624,65 @@ def evaluate(
 
         y_test (np.ndarray): Test labels (one-hot encoded).
 
-        model_type: (str): Type of the model. Options: 'PLAN', 'MLP', 'PTNN'.
+        model (tuple, optional): Trained model.
+
+        model_type: (str, optional): Type of the model. Options: 'PLAN', 'MLP', 'PTNN'.
+
+        W (array-like, optional): Neural net weight matrix.
 
-        W (np.ndarray): Neural net weight matrix.
-        
         activations (list, optional): Activation list for PLAN or MLP models (MLP layers activations if it PTNN model). Default = ['linear'].
 
         activation_potentiations (list, optional): Extra activation potentiation list (PLAN layers activations) for PTNN models. Default = [].
 
         auto_normalization (bool, optional): Normalization for x_test ? Default = False.
 
-    Returns:
-        tuple: Model (list).
-    """
+        show_report (bool, optional): show test report. Default = False
 
-    if auto_normalization: x_test = normalization(x_test, dtype=x_test.dtype)
+        cuda (bool, optional): CUDA GPU acceleration ? Default = False.
 
-    if isinstance(activations, str):
-        activations = [activations]
-    elif isinstance(activations, list):
-        activations = [item if isinstance(item, list) or isinstance(item, str) else [item] for item in activations]
+    Returns:
+        tuple: W, preds, accuracy, None, None, softmax_preds
+    """
 
-    if model_type == 'MLP':
-        layer = x_test
-        for i in range(len(W)):
-            if i != len(W) - 1 and i != 0: layer = apply_activation(layer, activations[i])
+    from .cpu.visualizations import plot_evaluate
+    from .model_ops import predict_from_memory
 
-            layer = layer @ W[i].T
+    if not cuda:
+        from .cpu.data_ops import normalization
+        
+        if model:
+            sample_acc = model.accuracy
+            if hasattr(sample_acc, "get"): model = model._replace(accuracy=sample_acc.get())
 
-        result = layer
+    else:
+        from .cuda.data_ops import normalization
+        x_test = cp.array(x_test)
+        y_test = cp.array(y_test)
 
-    if model_type == 'PLAN':
+        if model:
+            sample_acc = model.accuracy
+            if isinstance(sample_acc, np.number): model = model._replace(accuracy=cp.array(sample_acc))
 
-        x_test = apply_activation(x_test, activations)
-        result = x_test @ W.T
+    if model is None:
+        from .model_ops import get_model_template
+        template_model = get_model_template()
+        
+        model = template_model._replace(weights=W,
+                        activations=activations,
+                        model_type=model_type,
+                        activation_potentiation=activation_potentiations)
     
-    if model_type == 'PTNN':
+    result = predict_from_memory(x_test, model, cuda=cuda)
 
-        if isinstance(activation_potentiations, str):
-            activation_potentiations = [activation_potentiations]
-        elif isinstance(activation_potentiations, list):
-            activation_potentiations = [item if isinstance(item, list) or isinstance(item, str) else [item] for item in activation_potentiations]
-
-        x_test = apply_activation(x_test, activation_potentiations)
-        layer = x_test @ W[0].T
+    if auto_normalization: x_test = normalization(x_test, dtype=x_test.dtype)
 
-        for i in range(1, len(W)):
-            if i != len(W) - 1: layer = apply_activation(layer, activations[i])
+    array_type = cp if cuda else np
 
-            layer = layer @ W[i].T
+    max_vals = array_type.max(result, axis=1, keepdims=True)
+    
+    softmax_preds = array_type.exp(result - max_vals) / array_type.sum(array_type.exp(result - max_vals), axis=1, keepdims=True)
+    accuracy = (array_type.argmax(softmax_preds, axis=1) == array_type.argmax(y_test, axis=1)).mean()
 
-        result = layer
+    if show_report: plot_evaluate(x_test, y_test, result, acc=accuracy, model=model, cuda=cuda)
 
-    max_vals = np.max(result, axis=1, keepdims=True)
-    
-    softmax_preds = np.exp(result - max_vals) / np.sum(np.exp(result - max_vals), axis=1, keepdims=True)
-    accuracy = (np.argmax(softmax_preds, axis=1) == np.argmax(y_test, axis=1)).mean()
-    
     return W, result, accuracy, None, None, softmax_preds