pyerualjetwork 4.1.6__py3-none-any.whl → 4.1.8__py3-none-any.whl

pyerualjetwork/plan_cuda.py

@@ -1,10 +1,10 @@
 # -*- coding: utf-8 -*-
 """
 
-MAIN MODULE FOR PLAN
+MAIN MODULE FOR PLAN_CUDA
 
-PLAN document: https://github.com/HCB06/Anaplan/blob/main/Welcome_to_PLAN/PLAN.pdf
-ANAPLAN document: https://github.com/HCB06/Anaplan/blob/main/Welcome_to_Anaplan/ANAPLAN_USER_MANUEL_AND_LEGAL_INFORMATION(EN).pdf
+PLAN document: https://github.com/HCB06/PyerualJetwork/blob/main/Welcome_to_PLAN/PLAN.pdf
+PYERUALJETWORK document: https://github.com/HCB06/PyerualJetwork/blob/main/Welcome_to_PyerualJetwork/PYERUALJETWORK_USER_MANUEL_AND_LEGAL_INFORMATION(EN).pdf
 
 @author: Hasan Can Beydili
 @YouTube: https://www.youtube.com/@HasanCanBeydili
@@ -14,6 +14,7 @@ ANAPLAN document: https://github.com/HCB06/Anaplan/blob/main/Welcome_to_Anaplan/
 """
 
 import cupy as cp
+import numpy as np
 from colorama import Fore
 import math
 
@@ -24,6 +25,7 @@ from .loss_functions_cuda import binary_crossentropy, categorical_crossentropy
 from .activation_functions_cuda import apply_activation, Softmax, all_activations
 from .metrics_cuda import metrics
 from .model_operations_cuda import get_acc, get_preds, get_preds_softmax
+from .memory_operations import transfer_to_gpu, transfer_to_cpu, optimize_labels
 from .visualizations_cuda import (
     draw_neural_web,
     update_neural_web_for_fit,
@@ -106,8 +108,6 @@ def fit(
         numpyarray([num]): (Weight matrix).
     """
     # Pre-checks
-
-    from memory_operations import transfer_to_gpu, transfer_to_cpu
     
     if train_bar and val:
         train_progress = initialize_loading_bar(total=len(x_train), ncols=71, desc='Fitting', bar_format=bar_format_normal)
@@ -188,45 +188,63 @@ def fit(
     return normalization(LTPW, dtype=dtype)
 
 
-def learner(x_train, y_train, x_test=None, y_test=None, strategy='accuracy', batch_size=1,
+def learner(x_train, y_train, optimizer, x_test=None, y_test=None, strategy='accuracy', gen=None, batch_size=1,
            neural_web_history=False, show_current_activations=False, auto_normalization=True,
-           neurons_history=False, patience=None, depth=None, early_shifting=False,
-           early_stop=False, loss='categorical_crossentropy', show_history=False,
+           neurons_history=False, early_stop=False, loss='categorical_crossentropy', show_history=False,
            interval=33.33, target_acc=None, target_loss=None, except_this=None,
-           only_this=None, start_this=None, dtype=cp.float32, memory='gpu'):
+           only_this=None, start_this_act=None, start_this_W=None, target_fitness='max', dtype=cp.float32, memory='gpu'):
     """
     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
+        genetic_optimizer = lambda *args, **kwargs: planeat_cuda.evolve(*args,
+                                                                    activation_add_prob=0.85,
+                                                                    mutations=False,
+                                                                    strategy='cross_over',
+                                                                    **kwargs)
+
+        model = plan_cuda.learner(x_train,
+                             y_train,
+                             optimizer=genetic_optimizer,
+                             strategy='accuracy',
+                             show_history=True,
+                             target_acc=0.94,
+                             interval=16.67)
+        ```
+
         x_test (array-like, optional): Test input data (for improve next gen generilization). If test data is not given then train feedback learning active
 
         y_test (array-like, optional): Test Labels (for improve next gen generilization). If test data is not given then train feedback learning active
 
-        strategy (str, optional): Learning strategy. (options: 'accuracy', 'loss', 'f1', 'precision', 'recall', 'adaptive_accuracy', 'adaptive_loss', 'all'): 'accuracy', Maximizes test accuracy during learning. 'f1', Maximizes test f1 score during learning. 'precision', Maximizes test preciison score during learning. 'recall', Maximizes test recall during learning. loss', Minimizes test loss during learning. 'adaptive_accuracy', The model compares the current accuracy with the accuracy from the past based on the number specified by the patience value. If no improvement is observed it adapts to the condition by switching to the 'loss' strategy quickly starts minimizing loss and continues learning. 'adaptive_loss',The model adopts the 'loss' strategy until the loss reaches or falls below the value specified by the patience parameter. However, when the patience threshold is reached, it automatically switches to the 'accuracy' strategy and begins to maximize accuracy. 'all', Maximizes all test scores and minimizes test loss, 'all' strategy most strong and most robust strategy. Default is 'accuracy'.
+        strategy (str, optional): Learning strategy. (options: 'accuracy', 'f1', 'precision', 'recall'): 'accuracy', Maximizes train (or test if given) accuracy during learning. 'f1', Maximizes train (or test if given) f1 score during learning. 'precision', Maximizes train (or test if given) precision score during learning. 'recall', Maximizes train (or test if given) recall during learning. Default is 'accuracy'.
 
         patience ((int, float), optional): patience value for adaptive strategies. For 'adaptive_accuracy' Default value: 5. For 'adaptive_loss' Default value: 0.150.
 
-        depth (int, optional): The depth of the PLAN neural networks Aggreagation layers.
+        gen (int, optional): The generation count for genetic optimization.
 
         batch_size (float, optional): Batch size is used in the prediction process to receive test 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 test batch represents 8% of the test set. Default is 1. (%100 of test)
 
         auto_normalization (bool, optional): If auto normalization=False this makes more faster training times and much better accuracy performance for some datasets. Default is True.
 
-        early_shifting (int, optional): Early shifting checks if the test accuracy improves after a given number of activation attempts while inside a depth. If there's no improvement, it automatically shifts to the next depth. Basically, if no progress, it’s like, “Alright, let’s move on!”  Default is False
-
-        early_stop (bool, optional): If True, implements early stopping during training.(If test accuracy not improves in two depth stops learning.) Default is False.
+        early_stop (bool, optional): If True, implements early stopping during training.(If test 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.
 
-        loss (str, optional): For visualizing and monitoring. PLAN neural networks doesn't need any loss function in training(if strategy not 'loss'). options: ('categorical_crossentropy' or 'binary_crossentropy') Default is 'categorical_crossentropy'.
+        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.
 
@@ -238,8 +256,10 @@ def learner(x_train, y_train, x_test=None, y_test=None, strategy='accuracy', bat
 
         only_this (list, optional): A list of activations to focus on during optimization. Default is None. (For avaliable activation functions, run this code: plan.activations_list())
         
-        start_this (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_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.
@@ -252,18 +272,20 @@ def learner(x_train, y_train, x_test=None, y_test=None, strategy='accuracy', bat
         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 memory_operations import transfer_to_gpu, transfer_to_cpu
 
-    print(Fore.WHITE + "\nRemember, optimization on large datasets can be very time-consuming and computationally expensive. Therefore, if you are working with such a dataset, our recommendation is to include activation function: ['circular'] in the 'except_this' parameter unless absolutely necessary, as they can significantly prolong the process. from: learner\n" + Fore.RESET)
+    print(Fore.WHITE + "\nRemember, optimization on large datasets can be very time-consuming and computationally expensive. Therefore, if you are working with such a dataset, our recommendation is to include activation function: ['circular', 'spiral'] in the 'except_this' parameter unless absolutely necessary, as they can significantly prolong the process. from: learner\n" + Fore.RESET)
 
     activation_potentiation = all_activations()
 
+    y_train = optimize_labels(y_train, cuda=True)
+
     if x_test is None and y_test is None:
         x_test = x_train
         y_test = y_train
         data = 'Train'
     else:
         data = 'Test'
+        y_test = optimize_labels(y_test, cuda=True)
         
     if memory == 'gpu':
         x_train = transfer_to_gpu(x_train, dtype=dtype)
@@ -272,7 +294,7 @@ def learner(x_train, y_train, x_test=None, y_test=None, strategy='accuracy', bat
         x_test = transfer_to_gpu(x_test, dtype=dtype)
         y_test = transfer_to_gpu(y_test, dtype=y_train.dtype)
 
-        from data_operations_cuda import batcher
+        from .data_operations_cuda import batcher
 
     elif memory == 'cpu':
         x_train = transfer_to_cpu(x_train, dtype=dtype)
@@ -281,57 +303,45 @@ def learner(x_train, y_train, x_test=None, y_test=None, strategy='accuracy', bat
         x_test = transfer_to_cpu(x_test, dtype=dtype)
         y_test = transfer_to_cpu(y_test, dtype=y_train.dtype)
 
-        from data_operations import batcher
+        from .data_operations import batcher
 
     else:
         raise ValueError("memory parameter must be 'cpu' or 'gpu'.")
 
-
-    if early_shifting != False:
-        shift_patience = early_shifting
-
-    # Strategy initialization
-    if strategy == 'adaptive_accuracy':
-        strategy = 'accuracy'
-        adaptive = True
-        if patience == None:
-            patience = 5
-    elif strategy == 'adaptive_loss':
-        strategy = 'loss'
-        adaptive = True
-        if patience == None:
-            patience = 0.150
-    else:
-        adaptive = False
+    if strategy != 'accuracy' and strategy != 'f1' and strategy != 'recall' and strategy != 'precision': raise ValueError("Strategy parameter only be 'accuracy' or 'f1' or 'recall' or 'precision'.")
 
     # Filter activation functions
-    if only_this != None:
+    if only_this is not None:
         activation_potentiation = only_this
-    if except_this != None:
+    if except_this is not None:
         activation_potentiation = [item for item in activation_potentiation if item not in except_this]
-    if depth is None:
-        depth = len(activation_potentiation)
+    if gen is None:
+        gen = len(activation_potentiation)
 
+    if start_this_act is None and len(activation_potentiation) % 2 != 0: raise ValueError("Activation length must be even number. Please use 'except_this' parameter and except some activation. For example: except_this=['linear']")
+    if start_this_act is not None and len(activation_potentiation) + 1 % 2 != 0: raise ValueError("You are using start_this parameter, activation length still must be even number. Please use 'except_this' parameter and except some activation. For example: except_this=['linear']")
+    
     # Initialize visualization components
     viz_objects = initialize_visualization_for_learner(show_history, neurons_history, neural_web_history, x_train, y_train)
 
     # Initialize progress bar
     if batch_size == 1:
-        ncols = 100
+        ncols = 86
     else:
-        ncols = 140
-    progress = initialize_loading_bar(total=len(activation_potentiation), desc="", ncols=ncols, bar_format=bar_format_learner)
+        ncols = 99
 
     # Initialize variables
-    activations = []
-    if start_this is None:
-        best_activations = []
+    act_pop = []
+    weight_pop = []
+    
+    if start_this_act is None and start_this_W is None:
         best_acc = 0
     else:
-        best_activations = start_this
+        act_pop.append(start_this_act)
+        weight_pop.append(start_this_W)
+        
         x_test_batch, y_test_batch = batcher(x_test, y_test, batch_size=batch_size)
-        W = fit(x_train, y_train, activation_potentiation=best_activations, train_bar=False, auto_normalization=auto_normalization, dtype=dtype, memory=memory)
-        model = evaluate(x_test_batch, y_test_batch, W=W, loading_bar_status=False, activation_potentiation=activations, dtype=dtype, memory=memory)
+        model = evaluate(x_test_batch, y_test_batch, W=start_this_W, loading_bar_status=False, activation_potentiation=act_pop, dtype=dtype, memory=memory)
 
         if loss == 'categorical_crossentropy':
             test_loss = categorical_crossentropy(y_true_batch=transfer_to_gpu(y_test_batch, dtype=y_test_batch.dtype), y_pred_batch=model[get_preds_softmax()])
@@ -341,12 +351,15 @@ def learner(x_train, y_train, x_test=None, y_test=None, strategy='accuracy', bat
         best_acc = model[get_acc()]
         best_loss = test_loss
 
-    best_acc_per_depth_list = []
+    best_acc_per_gen_list = []
     postfix_dict = {}
     loss_list = []
-    
-    for i in range(depth):
-        postfix_dict["Depth"] = str(i+1) + '/' + str(depth)
+    target_pop = []
+
+    progress = initialize_loading_bar(total=len(activation_potentiation), desc="", ncols=ncols, bar_format=bar_format_learner)
+
+    for i in range(gen):
+        postfix_dict["Gen"] = str(i+1) + '/' + str(gen)
         progress.set_postfix(postfix_dict)
 
         progress.n = 0
@@ -354,79 +367,65 @@ def learner(x_train, y_train, x_test=None, y_test=None, strategy='accuracy', bat
         progress.update(0)
 
         for j in range(len(activation_potentiation)):
-            for k in range(len(best_activations)):
-                activations.append(best_activations[k])
-
-            activations.append(activation_potentiation[j])
 
             x_test_batch, y_test_batch = batcher(x_test, y_test, batch_size=batch_size)
-            W = fit(x_train, y_train, activation_potentiation=activations, train_bar=False, auto_normalization=auto_normalization, dtype=dtype, memory=memory)
-            model = evaluate(x_test_batch, y_test_batch, W=W, loading_bar_status=False, activation_potentiation=activations, dtype=dtype, memory=memory)
+            
+            if i == 0:
+                act_pop.append(activation_potentiation[j])
+                W = fit(x_train, y_train, activation_potentiation=act_pop[-1], train_bar=False, auto_normalization=auto_normalization, dtype=dtype)
+                weight_pop.append(W)
 
-            acc = model[get_acc()]
+            model = evaluate(x_test_batch, y_test_batch, W=weight_pop[j], loading_bar_status=False, activation_potentiation=act_pop[j], dtype=dtype, memory=memory)
 
-            if strategy == 'loss' or strategy == 'all':
-                if loss == 'categorical_crossentropy':
-                    test_loss = categorical_crossentropy(y_true_batch=transfer_to_gpu(y_test_batch, dtype=y_test_batch.dtype), y_pred_batch=model[get_preds_softmax()])
-                else:
-                    test_loss = binary_crossentropy(y_true_batch=transfer_to_gpu(y_test_batch, dtype=y_test_batch.dtype), y_pred_batch=model[get_preds_softmax()])
+            acc = model[get_acc()]
+            if strategy == 'accuracy': target_pop.append(acc)
 
-                if i == 0 and j == 0 and start_this is None:
-                    best_loss = test_loss
+            elif strategy == 'f1' or strategy == 'precision' or strategy == 'recall':
+                precision_score, recall_score, f1_score = metrics(y_test_batch, model[get_preds()])
 
-            if strategy == 'f1' or strategy == 'precision' or strategy == 'recall' or strategy == 'all':
-                precision_score, recall_score, f1_score = metrics(transfer_to_gpu(y_test_batch, dtype=y_test_batch.dtype), model[get_preds()])
+                if strategy == 'precision':
+                    target_pop.append(precision_score)
 
-                if strategy == 'precision' or strategy == 'all':
                     if i == 0 and j == 0:
                         best_precision = precision_score
 
-                if strategy == 'recall' or strategy == 'all':
+                if strategy == 'recall':
+                    target_pop.append(recall_score)
+
                     if i == 0 and j == 0:
                         best_recall = recall_score
 
-                if strategy == 'f1' or strategy == 'all':
+                if strategy == 'f1':
+                    target_pop.append(f1_score)
+
                     if i == 0 and j == 0:
                         best_f1 = f1_score
 
-            if early_shifting != False:
-                if acc <= best_acc:
-                    early_shifting -= 1
-                    if early_shifting == 0:
-                        early_shifting = shift_patience
-                        break
-
             if ((strategy == 'accuracy' and acc >= best_acc) or 
-                (strategy == 'loss' and test_loss <= best_loss) or 
                 (strategy == 'f1' and f1_score >= best_f1) or 
                 (strategy == 'precision' and precision_score >= best_precision) or 
-                (strategy == 'recall' and recall_score >= best_recall) or 
-                (strategy == 'all' and f1_score >= best_f1 and acc >= best_acc and 
-                 test_loss <= best_loss and precision_score >= best_precision and 
-                 recall_score >= best_recall)):
+                (strategy == 'recall' and recall_score >= best_recall)):
 
-                current_best_activation = activation_potentiation[j]
                 best_acc = acc
-                
+                best_weights = weight_pop[j]
+                final_activations = 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)
-                
-                final_activations = activations
 
                 if show_current_activations:
                     print(f", Current Activations={final_activations}", end='')
-
-                best_weights = W
-                best_model = model
-
-                if strategy != 'loss':
-                    if loss == 'categorical_crossentropy':
-                        test_loss = categorical_crossentropy(y_true_batch=transfer_to_gpu(y_test_batch, dtype=y_test_batch.dtype), y_pred_batch=model[get_preds_softmax()])
-                    else:
-                        test_loss = binary_crossentropy(y_true_batch=transfer_to_gpu(y_test_batch, dtype=y_test_batch.dtype), y_pred_batch=model[get_preds_softmax()])
+            
+                if loss == 'categorical_crossentropy':
+                    test_loss = categorical_crossentropy(y_true_batch=transfer_to_gpu(y_test_batch, dtype=y_test_batch.dtype), y_pred_batch=model[get_preds_softmax()])
+                else:
+                    test_loss = binary_crossentropy(y_true_batch=transfer_to_gpu(y_test_batch, dtype=y_test_batch.dtype), y_pred_batch=model[get_preds_softmax()])
 
                 if batch_size == 1:
                     postfix_dict[f"{data} Loss"] = test_loss
@@ -438,9 +437,9 @@ def learner(x_train, y_train, x_test=None, y_test=None, strategy='accuracy', bat
 
                 # Update visualizations during training
                 if show_history:
-                    depth_list = range(1, len(best_acc_per_depth_list) + 2)
-                    update_history_plots_for_learner(viz_objects, depth_list, loss_list + [test_loss], 
-                                      best_acc_per_depth_list + [best_acc], x_train, final_activations)
+                    gen_list = range(1, len(best_acc_per_gen_list) + 2)
+                    update_history_plots_for_learner(viz_objects, gen_list, loss_list + [test_loss], 
+                                      best_acc_per_gen_list + [best_acc], x_train, final_activations)
 
                 if neurons_history:
                     viz_objects['neurons']['artists'] = (
@@ -508,28 +507,19 @@ def learner(x_train, y_train, x_test=None, y_test=None, strategy='accuracy', bat
                     return best_weights, best_model[get_preds()], best_acc, final_activations
 
             progress.update(1)
-            activations = []
 
-        best_activations.append(current_best_activation)
-        best_acc_per_depth_list.append(best_acc)
+        best_acc_per_gen_list.append(best_acc)
         loss_list.append(best_loss)
-
-        # Check adaptive strategy conditions
-        if adaptive == True and strategy == 'accuracy' and i + 1 >= patience:
-            check = best_acc_per_depth_list[-patience:]
-            if all(x == check[0] for x in check):
-                strategy = 'loss'
-                adaptive = False
-        elif adaptive == True and strategy == 'loss' and best_loss <= patience:
-            strategy = 'accuracy'
-            adaptive = False
+        
+        weight_pop, act_pop = optimizer(cp.array(weight_pop, dtype=dtype), act_pop, i, cp.array(target_pop, dtype=dtype, copy=False), target_fitness=target_fitness, bar_status=False)
+        target_pop = []
 
         # Early stopping check
         if early_stop == True and i > 0:
-            if best_acc_per_depth_list[i] == best_acc_per_depth_list[i-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_weights, loading_bar_status=False, 
-                                    activation_potentiation=final_activations, dtype=dtype)
+                                    activation_potentiation=final_activations, dtype=dtype, memory=memory)
 
                 if loss == 'categorical_crossentropy':
                     train_loss = categorical_crossentropy(y_true_batch=y_train, 
@@ -553,7 +543,7 @@ def learner(x_train, y_train, x_test=None, y_test=None, strategy='accuracy', bat
     # Final evaluation
     progress.close()
     train_model = evaluate(x_train, y_train, W=best_weights, loading_bar_status=False, 
-                        activation_potentiation=final_activations, dtype=dtype)
+                        activation_potentiation=final_activations, dtype=dtype, memory=memory)
 
     if loss == 'categorical_crossentropy':
         train_loss = categorical_crossentropy(y_true_batch=y_train, y_pred_batch=train_model[get_preds_softmax()])
@@ -652,7 +642,6 @@ def evaluate(
     Returns:
         tuple: Model (list).
     """
-    from memory_operations import transfer_to_cpu, transfer_to_gpu
 
     if memory == 'gpu':
         x_test = transfer_to_gpu(x_test, dtype=dtype)

pyerualjetwork/planeat.py

@@ -17,7 +17,7 @@ from tqdm import tqdm
 ### LIBRARY IMPORTS ###
 from .plan import feed_forward
 from .data_operations import normalization
-from .ui import loading_bars
+from .ui import loading_bars, initialize_loading_bar
 from .activation_functions import apply_activation, all_activations
 
 def define_genomes(input_shape, output_shape, population_size, dtype=np.float32):
@@ -66,10 +66,10 @@ def define_genomes(input_shape, output_shape, population_size, dtype=np.float32)
          population_weights[i][j,:] = apply_activation(population_weights[i][j,:], population_activations[i])
          population_weights[i][j,:] = normalization(population_weights[i][j,:], dtype=dtype)
 
-   return np.array(population_weights), population_activations
+   return np.array(population_weights, dtype=dtype), population_activations
 
 
-def evolve(weights, activation_potentiations, what_gen, y_reward, show_info=False, strategy='cross_over', policy='normal_selective', mutations=True, bad_genoms_mutation_prob=None, activation_mutate_prob=0.5, save_best_genom=True, cross_over_mode='tpm', activation_add_prob=0.5, activation_delete_prob=0.5, activation_change_prob=0.5, weight_mutate_prob=1, weight_mutate_rate=32, activation_selection_add_prob=0.5, activation_selection_change_prob=0.5, activation_selection_rate=2, dtype=np.float32):
+def evolve(weights, activation_potentiations, what_gen, fitness, show_info=False, strategy='cross_over', bar_status=True, policy='normal_selective', target_fitness='max', mutations=True, bad_genoms_mutation_prob=None, activation_mutate_prob=0.5, save_best_genom=True, cross_over_mode='tpm', activation_add_prob=0.5, activation_delete_prob=0.5, activation_change_prob=0.5, weight_mutate_prob=1, weight_mutate_rate=32, activation_selection_add_prob=0.7, activation_selection_change_prob=0.5, activation_selection_rate=2, dtype=np.float32):
    """
 Applies the evolving process of a population of genomes using selection, crossover, mutation, and activation function potentiation.
 The function modifies the population's weights and activation functions based on a specified policy, mutation probabilities, and strategy.
@@ -83,8 +83,8 @@ Args:
     
     what_gen (int): The current generation number, used for informational purposes or logging.
     
-    y_reward (numpy.ndarray): A 1D array containing the fitness or reward values of each genome. 
-        The array is used to rank the genomes based on their performance. PLANEAT maximizes the reward.
+    fitness (numpy.ndarray): A 1D array containing the fitness values of each genome. 
+        The array is used to rank the genomes based on their performance. PLANEAT maximizes or minimizes this fitness for looking 'target' hyperparameter.
     
     show_info (bool, optional): If True, prints information about the current generation and the 
         maximum reward obtained. Also shows the current configuration. Default is False.
@@ -96,12 +96,16 @@ Args:
           (PLAN feature, similar to arithmetic crossover but different.)
         Default is 'cross_over'.
     
+    bar_status (bool, optional): Loading bar status during evolving process of genomes. True or False. Default: True
+
     policy (str, optional): The selection policy that governs how genomes are selected for reproduction. Options:
         - 'normal_selective': Normal selection based on reward, where a portion of the bad genes are discarded.
         - 'more_selective': A more selective policy, where fewer bad genes survive.
         - 'less_selective': A less selective policy, where more bad genes survive.
         Default is 'normal_selective'.
     
+    target_fitness (str, optional): Target fitness strategy for PLANEAT optimization. ('max' for machine learning, 'min' for machine unlearning.) Default: 'max'     
+   
     mutations (bool, optional): If True, mutations are applied to the bad genomes and potentially 
         to the best genomes as well. Default is True.
     
@@ -139,7 +143,7 @@ Args:
         WARNING: if you don't understand do NOT change this value. Default is 32.
 
     activation_selection_add_prob (float, optional): The probability of adding an existing activation function for cross over.
-        from the genome. Must be in the range [0, 1]. Default is 0.5.
+        from the genome. Must be in the range [0, 1]. Default is 0.7. (WARNING! More higher values make models more complex. For fast training rise this value.)
     
     activation_selection_change_prob (float, optional): The probability of changing an activation function in the genome for cross over. 
         Must be in the range [0, 1]. Default is 0.5.
@@ -163,7 +167,7 @@ Returns:
 
 Notes:
     - **Selection Process**: 
-        - The genomes are sorted by their fitness (based on `y_reward`), and then split into "best" and "bad" halves. 
+        - The genomes are sorted by their fitness (based on `fitness`), and then split into "best" and "bad" halves. 
         - The best genomes are retained, and the bad genomes are modified based on the selected strategy.
         
     - **Crossover and Potentiation Strategies**:
@@ -175,13 +179,13 @@ Notes:
         - `bad_genoms_mutation_prob` determines the probability of applying mutations to the bad genomes.
         - If `activation_mutate_prob` is provided, activation function mutations are applied to the genomes based on this probability.
         
-    - **Population Size**: The population size must be an even number to properly split the best and bad genomes. If `y_reward` has an odd length, an error is raised.
+    - **Population Size**: The population size must be an even number to properly split the best and bad genomes. If `fitness` has an odd length, an error is raised.
     
     - **Logging**: If `show_info=True`, the current generation and the maximum reward from the population are printed for tracking the learning progress.
 
 Example:
     ```python
-    weights, activation_potentiations = learner(weights, activation_potentiations, 1, y_reward, info=True, strategy='cross_over', policy='normal_selective')
+    weights, activation_potentiations = planeat.evolve(weights, activation_potentiations, 1, fitness, show_info=True, strategy='cross_over', policy='normal_selective')
     ```
 
     - The function returns the updated weights and activations after processing based on the chosen strategy, policy, and mutation parameters.
@@ -219,17 +223,19 @@ Example:
       if not isinstance(activation_mutate_prob, float) or activation_mutate_prob < 0 or activation_mutate_prob > 1:
          raise ValueError("activation_mutate_prob parameter must be float and 0-1 range")
       
-   if len(y_reward) % 2 == 0:
-      slice_center = int(len(y_reward) / 2)
+   if len(fitness) % 2 == 0:
+      slice_center = int(len(fitness) / 2)
 
    else:
       raise ValueError("genome population size must be even number. for example: not 99, make 100 or 98.")
 
-   sort_indices = np.argsort(y_reward)
+   
+### FITNESS IS SORTED IN ASCENDING (OR DESCENDING) ORDER, AND THE WEIGHT AND ACTIVATIONS OF EACH GENOME ARE SORTED ACCORDING TO THIS ORDER:
 
-### REWARD LIST IS SORTED IN ASCENDING ORDER, AND THE WEIGHT AND ACTIVATIONS OF EACH GENOME ARE SORTED ACCORDING TO THIS ORDER:
+   if target_fitness == 'max': sort_indices = np.argsort(fitness)
+   elif target_fitness == 'min': sort_indices = np.argsort(-fitness)
 
-   y_reward = y_reward[sort_indices]
+   fitness = fitness[sort_indices]
    weights = weights[sort_indices]
 
    activation_potentiations = [activation_potentiations[i] for i in sort_indices]
@@ -249,7 +255,9 @@ Example:
    
    bar_format = loading_bars()[0]
    
-   for i in tqdm(range(len(bad_weights)), desc="GENERATION: " + str(what_gen), bar_format=bar_format, ncols=50, ascii="▱▰"):
+   if bar_status: progress = initialize_loading_bar(len(bad_weights), desc="GENERATION: " + str(what_gen), bar_format=bar_format, ncols=50, ascii="▱▰")
+
+   for i in range(len(bad_weights)):
 
       if policy == 'normal_selective':
             
@@ -313,7 +321,8 @@ Example:
                   
                elif mutation_prob < bad_genoms_mutation_prob:
                   bad_weights[i], bad_activations[i] = mutation(bad_weights[i], bad_activations[i], activation_mutate_prob=activation_mutate_prob, activation_add_prob=activation_add_prob, activation_delete_prob=activation_delete_prob, activation_change_prob=activation_change_prob, weight_mutate_prob=weight_mutate_prob, threshold=weight_mutate_rate, dtype=dtype)
-
+      
+      if bar_status: progress.update(1)
 
    weights = np.vstack((bad_weights, best_weights))
    activation_potentiations = bad_activations + best_activations
@@ -344,9 +353,9 @@ Example:
       print("  ACTIVATION SELECTION RATE (THRESHOLD VALUE FOR SINGLE CROSS OVER):", str(activation_selection_rate) + '\n')
 
       print("*** Performance ***")
-      print("  MAX REWARD: ", str(round(max(y_reward), 2)))
-      print("  MEAN REWARD: ", str(round(np.mean(y_reward), 2)))
-      print("  MIN REWARD: ", str(round(min(y_reward), 2)) + '\n')
+      print("  MAX FITNESS: ", str(round(max(fitness), 2)))
+      print("  MEAN FITNESS: ", str(round(np.mean(fitness), 2)))
+      print("  MIN FITNESS: ", str(round(min(fitness), 2)) + '\n')
 
       print("  BEST GENOME INDEX: ", str(len(weights)-1))
       print("  NOTE: Genomes are always sorted from the least successful to the most successful according to their performance ranking. Therefore, the genome at the last index is the king of the previous generation. " + '\n')