pyerualjetwork 4.4__py3-none-any.whl → 4.5.1__py3-none-any.whl

pyerualjetwork/model_operations_cuda.py

@@ -23,34 +23,24 @@ def save_model(model_name,
                ):
 
     """
-    Function to save a potentiation learning artificial neural network model.
-
-    Arguments:
-
-    model_name (str): Name of the model.
-
-    model_type (str): Type of the model. default: 'PLAN'
-
-    test_acc (float): Test accuracy of the model. default: None
-
-    weights_type (str): Type of weights to save (options: 'txt', 'pkl', 'npy', 'mat'). default: 'npy'
-
-    WeightFormat (str): Format of the weights (options: 'f', 'raw'). default: 'raw'
-
-    model_path (str): Path where the model will be saved. For example: C:/Users/beydili/Desktop/denemePLAN/ default: ''
 
-    scaler_params (list[num, num]): standard scaler params list: mean,std. If not used standard scaler then be: None.
-
-    W: Weights of the model.
-
-    activation_potentiation (list): For deeper PLAN networks, activation function parameters. For more information please run this code: plan.activations_list() default: ['linear']
-
-    show_architecture (bool): It draws model architecture. True or False. Default: False
+    Function to save a potentiation learning artificial neural network model.
+    Args:
+        model_name: (str): Name of the model.
+        W: Weights of the model.
+        scaler_params: (list[num, num]): standard scaler params list: mean,std. If not used standard scaler then be: None.
+        model_type: (str): Type of the model. default: 'PLAN'
+        test_acc: (float): Test accuracy of the model. default: None
+        model_path: (str): Path where the model will be saved. For example: C:/Users/beydili/Desktop/denemePLAN/ default: ''
+        activation_potentiation: (list): For deeper PLAN networks, activation function parameters. For more information please run this code: plan.activations_list() default: ['linear']
+        weights_type: (str): Type of weights to save (options: 'txt', 'pkl', 'npy', 'mat'). default: 'npy'
+        weights_format: (str): Format of the weights (options: 'f', 'raw'). default: 'raw'
+        show_architecture: (bool): It draws model architecture. True or False. Default: False
+        show_info: (bool): Prints model details into console. default: True
 
-    show_info (bool): Prints model details into console. default: True
 
     Returns:
-    No return.
+        No return.
     """
     
     from .visualizations_cuda import draw_model_architecture
@@ -185,14 +175,14 @@ def load_model(model_name,
     """
    Function to load a potentiation learning model.
 
-   Arguments:
+   Args:
 
-   model_name (str): Name of the model.
+    model_name (str): Name of the model.
 
-   model_path (str): Path where the model is saved.
+    model_path (str): Path where the model is saved.
 
    Returns:
-   lists: W(list[num]), activation_potentiation, DataFrame of the model
+    lists: W(list[num]), activation_potentiation, DataFrame of the model
     """
     try:
 
@@ -250,18 +240,18 @@ def predict_model_ssd(Input, model_name, model_path='', dtype=cp.float32):
     Function to make a prediction using a potentiation learning artificial neural network (PLAN).
     from storage
 
-    Arguments:
+    Args:
 
-    Input (list or ndarray): Input data for the model (single vector or single matrix).
+        Input (list or ndarray): Input data for the model (single vector or single matrix).
 
-    model_name (str): Name of the model.
+        model_name (str): Name of the model.
 
-    model_path (str): Path of the model. Default: ''
+        model_path (str): Path of the model. Default: ''
 
-    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)
+        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:
-    ndarray: Output from the model.
+        cparray: Output from the model.
     """
     
     Input = cp.array(Input, dtype=dtype, copy=False)
@@ -294,18 +284,18 @@ def reverse_predict_model_ssd(output, model_name, model_path='', dtype=cp.float3
 
     """
     reverse prediction function from storage
-    Arguments:
+    Args:
 
-    output (list or ndarray): output layer for the model (single probability vector, output layer of trained model).
+        output (list or ndarray): output layer for the model (single probability vector, output layer of trained model).
 
-    model_name (str): Name of the model.
+        model_name (str): Name of the model.
 
-    model_path (str): Path of the model. Default: ''
+        model_path (str): Path of the model. Default: ''
 
-    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)
+        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:
-    ndarray: Input from the model.
+        cparray: Input from the model.
     """
     
     output = cp.array(output, dtype=dtype, copy=False)
@@ -328,20 +318,20 @@ def predict_model_ram(Input, W, scaler_params=None, activation_potentiation=['li
     Function to make a prediction using a potentiation learning artificial neural network (PLAN).
     from memory.
 
-    Arguments:
+    Args:
 
-    Input (list or ndarray): Input data for the model (single vector or single matrix).
+        Input (list or ndarray): Input data for the model (single vector or single matrix).
 
-    W (list of ndarrays): Weights of the model.
+        W (list of ndarrays): Weights of the model.
 
-    scaler_params (list): standard scaler params list: mean,std. (optional) Default: None.
-    
-    activation_potentiation (list): ac list for deep PLAN. default: [None] ('linear') (optional)
+        scaler_params (list): standard scaler params list: mean,std. (optional) Default: None.
+        
+        activation_potentiation (list): ac list for deep PLAN. default: [None] ('linear') (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)
+        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:
-    ndarray: Output from the model.
+        cparray: Output from the model.
     """
 
     from .data_operations_cuda import standard_scaler
@@ -368,16 +358,16 @@ def reverse_predict_model_ram(output, W, dtype=cp.float32):
     """
     reverse prediction function from memory
 
-    Arguments:
+    Args:
 
-    output (list or ndarray): output layer for the model (single probability vector, output layer of trained model).
+        output (list or ndarray): output layer for the model (single probability vector, output layer of trained model).
 
-    W (list of ndarrays): Weights of the model.
+        W (list of ndarrays): Weights of the model.
 
-    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)
+        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:
-    ndarray: Input from the model.
+        cparray: Input from the model.
     """
 
     output = cp.array(output, dtype=dtype, copy=False)

pyerualjetwork/plan.py

@@ -50,8 +50,7 @@ def fit(
     """
     Creates a model to fitting data.
     
-    fit Args:
-
+    Args:
         x_train (aray-like[num]): List or numarray of input data.
 
         y_train (aray-like[num]): List or numarray of target labels. (one hot encoded)
@@ -62,7 +61,7 @@ def fit(
 
         auto_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)
+        dtype (numpy.dtype): Data type for the arrays. np.float32 by default. Example: np.float64 or np.float16.
 
     Returns:
         numpyarray: (Weight matrix).
@@ -91,80 +90,54 @@ def learner(x_train, y_train, optimizer, fit_start=True, gen=None, batch_size=1,
     """
     Optimizes the activation functions for a neural network by leveraging train data to find 
     the most accurate combination of activation potentiation for the given dataset using genetic algorithm NEAT (Neuroevolution of Augmenting Topologies). But modifided for PLAN version. Created by me: PLANEAT. 
-    
+
     Why genetic optimization and not backpropagation?
     Because PLAN is different from other neural network architectures. In PLAN, the learnable parameters are not the weights; instead, the learnable parameters are the activation functions.
     Since activation functions are not differentiable, we cannot use gradient descent or backpropagation. However, I developed a more powerful genetic optimization algorithm: PLANEAT.
 
-    Args:
-
-        x_train (array-like): Training input data.
-
-        y_train (array-like): Labels for training data. one-hot encoded.
-
-        optimizer (function): PLAN optimization technique with hyperparameters. (PLAN using NEAT(PLANEAT) for optimization.) Please use this: from pyerualjetwork import planeat (and) optimizer = lambda *args, **kwargs: planeat.evolve(*args, 'here give your neat hyperparameters for example:  activation_add_prob=0.85', **kwargs) Example:
-        ```python
-        optimizer = lambda *args, **kwargs: planeat.evolver(*args,
+    :Args:
+    :param x_train: (array-like): Training input data.
+    :param y_train: (array-like): Labels for training data. one-hot encoded.
+    :param optimizer: (function): PLAN optimization technique with hyperparameters. (PLAN using NEAT(PLANEAT) for optimization.) Please use this: from pyerualjetwork import planeat (and) optimizer = lambda *args, **kwargs: planeat.evolve(*args, 'here give your neat hyperparameters for example:  activation_add_prob=0.85', **kwargs) Example:
+    ```python
+    optimizer = lambda *args, **kwargs: planeat.evolver(*args,
                                                             activation_add_prob=0.05,
                                                             strategy='aggressive',
                                                             policy='more_selective',
                                                             **kwargs)
 
-        model = plan.learner(x_train,
-                             y_train,
-                             optimizer,
-                             fit_start=True,
-                             show_history=True,
-                             gen=15,
-                             batch_size=0.05,
-                             interval=16.67)
-        ```
-        
-        weight_evolve (bool, optional): Activation combinations already optimizes by PLANEAT genetic search algorithm. Should the weight parameters also evolve or should the weights be determined according to the aggregating learning principle of the PLAN algorithm? Default: True (Evolves Weights)
-        
-        loss (str, optional): options: ('categorical_crossentropy' or 'binary_crossentropy') Default is 'categorical_crossentropy'.
-
-        target_acc (float, optional): The target accuracy to stop training early when achieved. Default is None.
-
-        target_loss (float, optional): The target loss to stop training early when achieved. Default is None.
-        
-        acc_impact (float, optional): Impact of accuracy for optimization [0-1]. Default: 0.9
-
-        loss_impact (float, optional): Impact of loss for optimization [0-1]. Default: 0.1
-        
-        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. Options: True or False. Default: True
-
-        gen (int, optional): The generation count for genetic optimization.
-
-        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)
-
-        pop_size (int, optional): Population size of each generation. Default: count of activation functions
-
-        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.
-
-        auto_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.
-
-        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
-
-        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
-
-        neurons_history (bool, optional): Shows the history of changes that neurons undergo during the TFL (Test or Train Feedback Learning) stages. True or False. Default is False.
-
-        neural_web_history (bool, optional): Draws history of neural web. 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)
+    model = plan.learner(x_train,
+                            y_train,
+                            optimizer,
+                            fit_start=True,
+                            show_history=True,
+                            gen=15,
+                            batch_size=0.05,
+                            interval=16.67)
+    ```
+    :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. Options: True or False. Default: True
+    :param gen: (int, optional): The generation count for genetic optimization.
+    :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)
+    :param pop_size: (int, optional): Population size of each generation. Default: count of activation functions
+    :param weight_evolve: (bool, optional): Activation combinations already optimizes by PLANEAT genetic search algorithm. Should the weight parameters also evolve or should the weights be determined according to the aggregating learning principle of the PLAN algorithm? Default: True (Evolves Weights)
+    :param neural_web_history: (bool, optional): Draws history of neural web. Default is False.
+    :param 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
+    :param auto_normalization: (bool, optional): Normalization may solves overflow problem. Default: False
+    :param neurons_history: (bool, optional): Shows the history of changes that neurons undergo during the TFL (Test or Train Feedback Learning) stages. True or False. Default is False.
+    :param early_stop: (bool, optional): If True, implements early stopping during training.(If accuracy not improves in two gen stops learning.) Default is False.
+    :param show_history: (bool, optional): If True, displays the training history after optimization. Default is False.
+    :param target_loss: (float, optional): The target loss to stop training early when achieved. Default is None.
+    :param interval: (int, optional): The interval at which evaluations are conducted during training. (33.33 = 30 FPS, 16.67 = 60 FPS) Default is 100.
+    :param target_acc: (float, optional): The target accuracy to stop training early when achieved. Default is None.
+    :param loss: (str, optional): options: ('categorical_crossentropy' or 'binary_crossentropy') Default is 'categorical_crossentropy'.
+    :param acc_impact: (float, optional): Impact of accuracy for optimization [0-1]. Default: 0.9
+    :param loss_impact: (float, optional): Impact of loss for optimization [0-1]. Default: 0.1
+    :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 dtype: (numpy.dtype): Data type for the arrays. np.float32 by default. Example: np.float64 or np.float16.
 
     Returns:
         tuple: A list for model parameters: [Weight matrix, Test loss, Test Accuracy, [Activations functions]].
-    
     """
 
     from .planeat import define_genomes
@@ -238,7 +211,7 @@ def learner(x_train, y_train, optimizer, fit_start=True, gen=None, batch_size=1,
             if weight_evolve is False:
                 weight_pop[j] = fit(x_train_batch, y_train_batch, activation_potentiation=act_pop[j], auto_normalization=auto_normalization, dtype=dtype)
                 
-            model = evaluate(x_train_batch, y_train_batch, W=weight_pop[j], activation_potentiation=act_pop[j])
+            model = evaluate(x_train_batch, y_train_batch, W=weight_pop[j], activation_potentiation=act_pop[j], auto_normalization=auto_normalization)
             acc = model[get_acc()]
             
             if loss == 'categorical_crossentropy':
@@ -295,7 +268,7 @@ def learner(x_train, y_train, optimizer, fit_start=True, gen=None, batch_size=1,
                 if target_acc is not None and best_acc >= target_acc:
                     progress.close()
                     train_model = evaluate(x_train, y_train, W=best_weight, 
-                                        activation_potentiation=final_activations)
+                                        activation_potentiation=final_activations, auto_normalization=auto_normalization)
                     if loss == 'categorical_crossentropy':
                         train_loss = categorical_crossentropy(y_true_batch=y_train, 
                                                            y_pred_batch=train_model[get_preds_softmax()])
@@ -315,7 +288,7 @@ def learner(x_train, y_train, optimizer, fit_start=True, gen=None, batch_size=1,
                 if target_loss is not None and best_loss <= target_loss:
                     progress.close()
                     train_model = evaluate(x_train, y_train, W=best_weight,
-                                        activation_potentiation=final_activations)
+                                        activation_potentiation=final_activations, auto_normalization=auto_normalization)
 
                     if loss == 'categorical_crossentropy':
                         train_loss = categorical_crossentropy(y_true_batch=y_train, 
@@ -365,7 +338,7 @@ def learner(x_train, y_train, optimizer, fit_start=True, gen=None, batch_size=1,
             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, 
-                                    activation_potentiation=final_activations)
+                                    activation_potentiation=final_activations, auto_normalization=auto_normalization)
                 
             if loss == 'categorical_crossentropy':
                 train_loss = categorical_crossentropy(y_true_batch=y_train, 
@@ -386,7 +359,7 @@ def learner(x_train, y_train, optimizer, fit_start=True, gen=None, batch_size=1,
     # Final evaluation
     progress.close()
     train_model = evaluate(x_train, y_train, W=best_weight,
-                        activation_potentiation=final_activations)
+                        activation_potentiation=final_activations, auto_normalization=auto_normalization)
 
     if loss == 'categorical_crossentropy':
         train_loss = categorical_crossentropy(y_true_batch=y_train, 
@@ -408,7 +381,8 @@ def evaluate(
     x_test,
     y_test,
     W,
-    activation_potentiation=['linear']
+    activation_potentiation=['linear'],
+    auto_normalization=False
 ) -> tuple:
     """
     Evaluates the neural network model using the given test data.
@@ -420,12 +394,16 @@ def evaluate(
 
         W (np.ndarray): Neural net weight matrix.
         
-        activation_potentiation (list): Activation list. Default = ['linear'].
+        activation_potentiation (list, optional): Activation list. Default = ['linear'].
+
+        auto_normalization (bool, optional): Normalization for x_test ? Default = False.
         
     Returns:
         tuple: Model (list).
     """
 
+    if auto_normalization: x_test = normalization(x_test, dtype=x_test.dtype)
+
     x_test = apply_activation(x_test, activation_potentiation)
     
     result = x_test @ W.T

pyerualjetwork/plan_cuda.py

@@ -51,18 +51,12 @@ def fit(
     Creates a model to fitting data.,
     
     fit Args:
-
-        x_train (aray-like[cupy]): List or cupy array of input data.
-
-        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)
-
+        :param (aray-like[cupy]) x_train: (aray-like[cupy]): List or cupy array of input data.
+        :param (aray-like[cupy]) y_train: List or cupy array of target labels. (one hot encoded)
+        :param (list) activation_potentiation: For deeper PLAN networks, activation function parameters. For more information please run this code: plan.activations_list() default: [None] (optional)
         W (cupy.ndarray, optional): If you want to re-continue or update model
-        
         auto_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)
+        dtype (cupy.dtype, optional): Data type for the arrays. cp.float32 by default. Example: cp.float64 or cp.float16.
 
     Returns:
         cupyarray: (Weight matrix).
@@ -90,82 +84,55 @@ def learner(x_train, y_train, optimizer, fit_start=True, gen=None, batch_size=1,
     """
     Optimizes the activation functions for a neural network by leveraging train data to find 
     the most accurate combination of activation potentiation for the given dataset.
-    
+
     Why genetic optimization and not backpropagation?
     Because PLAN is different from other neural network architectures. In PLAN, the learnable parameters are not the weights; instead, the learnable parameters are the activation functions.
     Since activation functions are not differentiable, we cannot use gradient descent or backpropagation. However, I developed a more powerful genetic optimization algorithm: PLANEAT.
 
-    Args:
-
-        x_train (array-like): Training input data.
-
-        y_train (array-like): Labels for training data.
-
-        optimizer (function): PLAN optimization technique with hyperparameters. (PLAN using NEAT(PLANEAT) for optimization.) Please use this: from pyerualjetwork import planeat_cuda (and) optimizer = lambda *args, **kwargs: planeat_cuda.evolve(*args, 'here give your neat hyperparameters for example:  activation_add_prob=0.85', **kwargs) Example:
-        ```python
-        optimizer = lambda *args, **kwargs: planeat_cuda.evolver(*args,
-                                                                    activation_add_prob=0.05,
-                                                                    strategy='aggressive',
-                                                                    policy='more_selective',
-                                                                    **kwargs)
-
-        model = plan_cuda.learner(x_train,
-                                y_train,
-                                optimizer,
-                                fit_start=True,
-                                show_history=True,
-                                gen=15,
-                                batch_size=0.05,
-                                interval=16.67)
-        ```
-        
-        weight_evolve (bool, optional): Activation combinations already optimizes by PLANEAT genetic search algorithm. Should the weight parameters also evolve or should the weights be determined according to the aggregating learning principle of the PLAN algorithm? Default: True (Evolves Weights)
-
-        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'.
-
-        target_acc (float, optional): The target accuracy to stop training early when achieved. Default is None.
-
-        target_loss (float, optional): The target loss to stop training early when achieved. Default is None.
-
-        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. Options: True or False. Default: True
-        
-        gen (int, optional): The generation count for genetic optimization.
-
-        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 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)
-
-        acc_impact (float, optional): Impact of accuracy for optimization [0-1]. Default: 0.9
-
-        loss_impact (float, optional): Impact of loss for optimization [0-1]. Default: 0.1
-        
-        pop_size (int, optional): Population size of each generation. Default: count of activation functions
-
-        early_stop (bool, optional): If True, implements early stopping during training.(If train 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.
-
-        auto_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.
-        
-        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
-
-        start_this_W (cupy.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
-        
-        neurons_history (bool, optional): Shows the history of changes that neurons undergo during the TFL (Test or Train Feedback Learning) stages. True or False. Default is False.
-
-        neural_web_history (bool, optional): Draws history of neural web. 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)
-
-        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'.
+    :Args:
+    :param x_train: (array-like): Training input data.
+    :param y_train: (array-like): Labels for training data.
+    :param optimizer: (function): PLAN optimization technique with hyperparameters. (PLAN using NEAT(PLANEAT) for optimization.) Please use this: from pyerualjetwork import planeat_cuda (and) optimizer = lambda *args, **kwargs: planeat_cuda.evolve(*args, 'here give your neat hyperparameters for example:  activation_add_prob=0.85', **kwargs) Example:
+    ```python
+    optimizer = lambda *args, **kwargs: planeat_cuda.evolver(*args,
+                                                                activation_add_prob=0.05,
+                                                                strategy='aggressive',
+                                                                policy='more_selective',
+                                                                **kwargs)
+
+    model = plan_cuda.learner(x_train,
+                            y_train,
+                            optimizer,
+                            fit_start=True,
+                            show_history=True,
+                            gen=15,
+                            batch_size=0.05,
+                            interval=16.67)
+    ```
+    :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. Options: True or False. Default: True
+    :param gen: (int, optional): The generation count for genetic optimization.
+    :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)
+    :param pop_size: (int, optional): Population size of each generation. Default: count of activation functions
+    :param weight_evolve: (bool, optional): Activation combinations already optimizes by PLANEAT genetic search algorithm. Should the weight parameters also evolve or should the weights be determined according to the aggregating learning principle of the PLAN algorithm? Default: True (Evolves Weights)
+    :param neural_web_history: (bool, optional): Draws history of neural web. Default is False.
+    :param 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
+    :param auto_normalization: (bool, optional): Normalization may solves overflow problem. Default: False
+    :param target_acc: (float, optional): The target accuracy to stop training early when achieved. Default is None.
+    :param neurons_history: (bool, optional): Shows the history of changes that neurons undergo during the TFL (Test or Train Feedback Learning) stages. True or False. Default is False.
+    :param early_stop: (bool, optional): If True, implements early stopping during training.(If train accuracy not improves in two gen stops learning.) Default is False.
+    :param show_history: (bool, optional): If True, displays the training history after optimization. Default is False.
+    :param 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'.
+    :param interval: (int, optional): The interval at which evaluations are conducted during training. (33.33 = 30 FPS, 16.67 = 60 FPS) Default is 33.33.
+    :param target_loss: (float, optional): The target loss to stop training early when achieved. Default is None.
+    :param loss_impact: (float, optional): Impact of loss for optimization [0-1]. Default: 0.1
+    :param acc_impact: (float, optional): Impact of accuracy for optimization [0-1]. Default: 0.9
+    :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: (cupy.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 dtype: (cupy.dtype): Data type for the arrays. np.float32 by default. Example: cp.float64 or cp.float16.
+    :param 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: A list for model parameters: [Weight matrix, Preds, Accuracy, [Activations functions]]. You can acces this parameters in model_operations module. For example: model_operations.get_weights() for Weight matrix.
-    
     """
 
     from .planeat_cuda import define_genomes
@@ -253,7 +220,7 @@ def learner(x_train, y_train, optimizer, fit_start=True, gen=None, batch_size=1,
             if weight_evolve is False:
                 weight_pop[j] = fit(x_train_batch, y_train_batch, activation_potentiation=act_pop[j], auto_normalization=auto_normalization, dtype=dtype) 
             
-            model = evaluate(x_train_batch, y_train_batch, W=weight_pop[j], activation_potentiation=act_pop[j])
+            model = evaluate(x_train_batch, y_train_batch, W=weight_pop[j], activation_potentiation=act_pop[j], auto_normalization=auto_normalization)
             acc = model[get_acc()]
  
             if loss == 'categorical_crossentropy':
@@ -311,7 +278,7 @@ def learner(x_train, y_train, optimizer, fit_start=True, gen=None, batch_size=1,
                 if target_acc is not None and best_acc >= target_acc:
                     progress.close()
                     train_model = evaluate(x_train, y_train, W=best_weight, 
-                                        activation_potentiation=final_activations)
+                                        activation_potentiation=final_activations, auto_normalization=auto_normalization)
                     if loss == 'categorical_crossentropy':
                         train_loss = categorical_crossentropy(y_true_batch=y_train, 
                                                            y_pred_batch=train_model[get_preds_softmax()])
@@ -331,7 +298,7 @@ def learner(x_train, y_train, optimizer, fit_start=True, gen=None, batch_size=1,
                 if target_loss is not None and best_loss <= target_loss:
                     progress.close()
                     train_model = evaluate(x_train, y_train, W=best_weight,
-                                        activation_potentiation=final_activations)
+                                        activation_potentiation=final_activations, auto_normalization=auto_normalization)
 
                     if loss == 'categorical_crossentropy':
                         train_loss = categorical_crossentropy(y_true_batch=y_train, 
@@ -381,7 +348,7 @@ def learner(x_train, y_train, optimizer, fit_start=True, gen=None, batch_size=1,
             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, 
-                                    activation_potentiation=final_activations)
+                                    activation_potentiation=final_activations, auto_normalization=auto_normalization)
                 
             if loss == 'categorical_crossentropy':
                 train_loss = categorical_crossentropy(y_true_batch=y_train, 
@@ -402,7 +369,7 @@ def learner(x_train, y_train, optimizer, fit_start=True, gen=None, batch_size=1,
     # Final evaluation
     progress.close()
     train_model = evaluate(x_train, y_train, W=best_weight,
-                        activation_potentiation=final_activations)
+                        activation_potentiation=final_activations, auto_normalization=auto_normalization)
 
     if loss == 'categorical_crossentropy':
         train_loss = categorical_crossentropy(y_true_batch=y_train, 
@@ -423,7 +390,8 @@ def evaluate(
     x_test,
     y_test,
     W,
-    activation_potentiation=['linear']
+    activation_potentiation=['linear'],
+    auto_normalization=False
 ) -> tuple:
     """
     Evaluates the neural network model using the given test data.
@@ -436,11 +404,15 @@ def evaluate(
         W (cp.ndarray): Neural net weight matrix.
         
         activation_potentiation (list): Activation list. Default = ['linear'].
+
+        auto_normalization (bool, optional): Normalization for x_test ? Default = False.
         
     Returns:
         tuple: Model (list).
     """
 
+    if auto_normalization: x_test = normalization(x_test, dtype=x_test.dtype)
+
     x_test = apply_activation(x_test, activation_potentiation)
     
     result = x_test @ W.T