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

pyerualjetwork/__init__.py

@@ -48,7 +48,7 @@ for package_name in package_names:
 
 print(f"PyerualJetwork is ready to use with {err} errors")
 
-__version__ = "4.1.6"
+__version__ = "4.1.8"
 __update__ = "* Changes: https://github.com/HCB06/PyerualJetwork/blob/main/CHANGES\n* PyerualJetwork document: https://github.com/HCB06/PyerualJetwork/blob/main/Welcome_to_PyerualJetwork/PYERUALJETWORK_USER_MANUEL_AND_LEGAL_INFORMATION(EN).pdf\n* YouTube tutorials: https://www.youtube.com/@HasanCanBeydili"
 
 def print_version(__version__):
@@ -58,15 +58,4 @@ def print_update_notes(__update__):
     print(f"Update Notes:\n{__update__}")
 
 print_version(__version__)
-print_update_notes(__update__)
-
-from .plan import *
-from .planeat import *
-from .activation_functions import *
-from .data_operations import *
-from .loss_functions import *
-from .metrics import *
-from .model_operations import *
-from .ui import *
-from .visualizations import *
-from .help import *
+print_update_notes(__update__)

pyerualjetwork/data_operations_cuda.py

@@ -64,17 +64,22 @@ def decode_one_hot(encoded_data):
 
 
 
-def split(X, y, test_size, random_state=42, dtype=cp.float32, use_cpu=False):
+def split(X, y, test_size, random_state=42, dtype=cp.float32, shuffle_in_cpu=False):
     """
     Splits the given X (features) and y (labels) data into training and testing subsets.
 
     Args:
         X (cupy.ndarray): Features data.
+        
         y (cupy.ndarray): Labels data.
+        
         test_size (float or int): Proportion or number of samples for the test subset.
+        
         random_state (int or None): Seed for random state. Default: 42.
+        
         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)
-        use_cpu (bool): If True, output will be same cpu's split function. Default: False.
+        
+        shuffle_in_cpu (bool): If True, output will be same cpu's split function. Default: False. (Use this for direct comparison of cpu training.)
     Returns:
         tuple: x_train, x_test, y_train, y_test as ordered training and testing data subsets.
     """
@@ -94,7 +99,7 @@ def split(X, y, test_size, random_state=42, dtype=cp.float32, use_cpu=False):
     else:
         raise ValueError("test_size should be float or int.")
 
-    if use_cpu:
+    if shuffle_in_cpu:
         indices = np.arange(num_samples)
         np.random.seed(random_state)
         np.random.shuffle(indices)
@@ -117,7 +122,7 @@ def split(X, y, test_size, random_state=42, dtype=cp.float32, use_cpu=False):
     return x_train, x_test, y_train, y_test
 
 
-def manuel_balancer(x_train, y_train, target_samples_per_class, dtype=cp.float32, use_cpu=False):
+def manuel_balancer(x_train, y_train, target_samples_per_class, dtype=cp.float32, shuffle_in_cpu=False):
     """
     Generates synthetic examples to balance classes to the specified number of examples per class.
 
@@ -131,7 +136,7 @@ def manuel_balancer(x_train, y_train, target_samples_per_class, dtype=cp.float32
 
     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)
 
-    use_cpu (bool): If True, output will be same cpu's manuel_balancer function. Default: False.
+    shuffle_in_cpu (bool): If True, output will be same cpu's manuel_balancer function. Default: False. (Use this for direct comparison of cpu training.)
 
     Returns:
     x_balanced -- Balanced input dataset (cupy array format)
@@ -157,7 +162,7 @@ def manuel_balancer(x_train, y_train, target_samples_per_class, dtype=cp.float32
         
         if num_samples > target_samples_per_class:
             
-            if use_cpu:
+            if shuffle_in_cpu:
                 selected_indices = np.random.choice(
                     class_indices.get(), target_samples_per_class, replace=False)
             else:
@@ -179,7 +184,7 @@ def manuel_balancer(x_train, y_train, target_samples_per_class, dtype=cp.float32
                 
                 for i in range(samples_to_add):
                     
-                    if use_cpu:
+                    if shuffle_in_cpu:
                         random_indices = np.random.choice(class_indices.get(), 2, replace=False)
                     else:
                         random_indices = cp.random.choice(class_indices, 2, replace=False)
@@ -187,7 +192,7 @@ def manuel_balancer(x_train, y_train, target_samples_per_class, dtype=cp.float32
                     sample1 = x_train[random_indices[0]]
                     sample2 = x_train[random_indices[1]]
 
-                    if use_cpu:
+                    if shuffle_in_cpu:
                         synthetic_sample = sample1 + (sample2 - sample1) * np.random.rand()
                     else:
                         synthetic_sample = sample1 + (sample2 - sample1) * cp.random.rand()
@@ -208,7 +213,7 @@ def manuel_balancer(x_train, y_train, target_samples_per_class, dtype=cp.float32
     return x_balanced, y_balanced
 
 
-def auto_balancer(x_train, y_train, dtype=cp.float32, use_cpu=False):
+def auto_balancer(x_train, y_train, dtype=cp.float32, shuffle_in_cpu=False):
 
     """
    Function to balance the training data across different classes.
@@ -220,7 +225,7 @@ def auto_balancer(x_train, y_train, dtype=cp.float32, use_cpu=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)
 
-   use_cpu (bool): If True, output will be same cpu's auto_balancer function. Default: False.
+   shuffle_in_cpu (bool): If True, output will be same cpu's auto_balancer function. Default: False. (Use this for direct comparison of cpu training.)
    Returns:
    tuple: A tuple containing balanced input data and labels.
     """
@@ -250,7 +255,7 @@ def auto_balancer(x_train, y_train, dtype=cp.float32, use_cpu=False):
     for i in tqdm(range(class_count),leave=False, ascii="▱▰",
         bar_format= bar_format, desc='Balancing Data',ncols=70):
         if len(ClassIndices[i]) > MinCount:
-            if use_cpu:
+            if shuffle_in_cpu:
                 SelectedIndices = np.random.choice(
                     ClassIndices[i].get(), MinCount, replace=False)
             else:
@@ -263,7 +268,7 @@ def auto_balancer(x_train, y_train, dtype=cp.float32, use_cpu=False):
     BalancedInputs = [x_train[idx] for idx in BalancedIndices]
     BalancedLabels = [y_train[idx] for idx in BalancedIndices]
 
-    if use_cpu:
+    if shuffle_in_cpu:
         permutation = np.random.permutation(len(BalancedInputs))
     else:
         permutation = cp.random.permutation(len(BalancedInputs))
@@ -279,7 +284,7 @@ def auto_balancer(x_train, y_train, dtype=cp.float32, use_cpu=False):
     return BalancedInputs, BalancedLabels
 
 
-def synthetic_augmentation(x_train, y_train, dtype=cp.float32, use_cpu=False):
+def synthetic_augmentation(x_train, y_train, dtype=cp.float32, shuffle_in_cpu=False):
     """
     Generates synthetic examples to balance classes with fewer examples using CuPy.
     Arguments:
@@ -290,7 +295,7 @@ def synthetic_augmentation(x_train, y_train, dtype=cp.float32, use_cpu=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)
     
-    use_cpu (bool): If True, output will be same cpu's synthetic_augmentation function. Default: False.
+    shuffle_in_cpu (bool): If True, output will be same cpu's synthetic_augmentation function. Default: False. (Use this for direct comparison of cpu training.)
 
     Returns:
     x_train_balanced -- Balanced input dataset (cupy array format)
@@ -322,7 +327,7 @@ def synthetic_augmentation(x_train, y_train, dtype=cp.float32, use_cpu=False):
         
         if num_samples < max_class_count:
             while num_samples < max_class_count:
-                if use_cpu:
+                if shuffle_in_cpu:
                     random_indices = np.random.choice(
                         class_indices, 2, replace=False)
                 else:
@@ -331,7 +336,7 @@ def synthetic_augmentation(x_train, y_train, dtype=cp.float32, use_cpu=False):
                 sample1 = x[random_indices[0]]
                 sample2 = x[random_indices[1]]
                 
-                if use_cpu:
+                if shuffle_in_cpu:
                     synthetic_sample = sample1 + \
                         (sample2 - sample1) * np.random.rand()
                 else:

pyerualjetwork/memory_operations.py

@@ -17,15 +17,13 @@ def get_optimal_batch_size_for_cpu(x, data_size_bytes, available_memory):
     The function calculates the optimal batch size for a given data size and available memory based on
     the size of each element.
     
-    :param x: `x` is a NumPy array representing the input data for which we want to determine the
-    optimal batch size for processing on the CPU
-    :param data_size_bytes: The `data_size_bytes` parameter represents the size of the data in bytes
-    that you want to process in batches
-    :param available_memory: The `available_memory` parameter represents the total memory available on
-    the CPU in bytes. This function calculates the optimal batch size for processing data based on the
-    provided parameters. Let me know if you need any further assistance or explanation!
-    :return: the optimal batch size for a given array `x` based on the available memory and the size of
-    each element in bytes.
+    :param x: `x` is a NumPy array representing the input data for which we want to determine the optimal batch size for processing on the CPU
+    
+    :param data_size_bytes: The `data_size_bytes` parameter represents the size of the data in bytes that you want to process in batches
+    
+    :param available_memory: The `available_memory` parameter represents the total memory available on the CPU in bytes. This function calculates the optimal batch size for processing data based on the provided parameters. Let me know if you need any further assistance or explanation!
+    
+    :return: the optimal batch size for a given array `x` based on the available memory and the size of each element in bytes.
     """
     safe_memory = available_memory * 0.25
     element_size = data_size_bytes / x.size
@@ -37,10 +35,12 @@ def transfer_to_cpu(x, dtype=np.float32):
     by batching the conversion process and ensuring complete GPU memory cleanup.
    
     :param x: Input data to transfer to CPU (CuPy array)
+    
     :param dtype: Target NumPy dtype for the output array (default: np.float32)
+    
     :return: NumPy array with the specified dtype
     """
-    from .ui import loading_bars, initialize_loading_bar
+    from ui import loading_bars, initialize_loading_bar
     try:
         if isinstance(x, np.ndarray):
             return x.astype(dtype) if x.dtype != dtype else x
@@ -144,16 +144,11 @@ def transfer_to_gpu(x, dtype=cp.float32):
     The `transfer_to_gpu` function in Python converts input data to GPU arrays, optimizing memory usage by
     batching and handling out-of-memory errors.
     
-    :param x: The `x` parameter in the `transfer_to_gpu` function is the input data that you want to transfer to
-    the GPU for processing. It can be either a NumPy array or a CuPy array. If it's a NumPy array, the
-    function will convert it to a CuPy array and
-    :param dtype: The `dtype` parameter in the `transfer_to_gpu` function specifies the data type to which the
-    input array `x` should be converted when moving it to the GPU. By default, it is set to
-    `cp.float32`, which is a 32-bit floating-point data type provided by the Cu
-    :return: The `transfer_to_gpu` function returns the input data `x` converted to a GPU array of type `dtype`
-    (default is `cp.float32`). If the input `x` is already a GPU array with the same dtype, it returns
-    `x` as is. If the data size of `x` exceeds 25% of the free GPU memory, it processes the data in
-    batches to
+    :param x: The `x` parameter in the `transfer_to_gpu` function is the input data that you want to transfer to the GPU for processing. It can be either a NumPy array or a CuPy array. If it's a NumPy array, the function will convert it to a CuPy array and
+    
+    :param dtype: The `dtype` parameter in the `transfer_to_gpu` function specifies the data type to which the input array `x` should be converted when moving it to the GPU. By default, it is set to `cp.float32`, which is a 32-bit floating-point data type provided by the CuPy
+    
+    :return: The `transfer_to_gpu` function returns the input data `x` converted to a GPU array of type `dtype` (default is `cp.float32`). If the input `x` is already a GPU array with the same dtype, it returns `x` as is. If the data size of `x` exceeds 25% of the free GPU memory, it processes the data in batches to
     """
     from .ui import loading_bars, initialize_loading_bar
     try:

pyerualjetwork/plan.py

@@ -3,8 +3,8 @@
 
 MAIN MODULE FOR PLAN
 
-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
@@ -24,6 +24,7 @@ from .loss_functions import binary_crossentropy, categorical_crossentropy
 from .activation_functions import apply_activation, Softmax, all_activations
 from .metrics import metrics
 from .model_operations import get_acc, get_preds, get_preds_softmax
+from .memory_operations import optimize_labels
 from .visualizations import (
     draw_neural_web,
     update_neural_web_for_fit,
@@ -102,8 +103,6 @@ def fit(
     Returns:
         numpyarray([num]): (Weight matrix).
     """
-    
-    from model_operations import get_acc
 
     # Pre-checks
 
@@ -173,45 +172,61 @@ 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=np.float32):
+           only_this=None, start_this_act=None, start_this_W=None, target_fitness='max', dtype=np.float32):
     """
     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.
+    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
+        genetic_optimizer = lambda *args, **kwargs: planeat.evolve(*args,
+                                                                    activation_add_prob=0.85,
+                                                                    mutations=False,
+                                                                    strategy='cross_over',
+                                                                    **kwargs)
+
+        model = plan.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'.
-
-        patience ((int, float), optional): patience value for adaptive strategies. For 'adaptive_accuracy' Default value: 5. For 'adaptive_loss' Default value: 0.150.
+        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'.
 
-        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.
 
@@ -223,81 +238,54 @@ 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 (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.
 
+        target_fitness (str, optional): Target fitness strategy for PLANEAT optimization. ('max' for machine learning, 'min' for machine unlearning.) Default: 'max'
+        
         dtype (numpy.dtype): Data type for the arrays. np.float32 by default. Example: np.float64 or np.float16. [fp32 for balanced devices, fp64 for strong devices, fp16 for weak devices: not reccomended!] (optional)
 
     Returns:
         tuple: A list for model parameters: [Weight matrix, Test loss, Test Accuracy, [Activations functions]].
     
     """
-    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()
 
     # Pre-checks
 
     x_train = x_train.astype(dtype, copy=False)
-
-    if len(y_train[0]) < 256:
-        if y_train.dtype != np.uint8:
-            y_train = np.array(y_train, copy=False).astype(np.uint8, copy=False)
-    elif len(y_train[0]) <= 32767:
-        if y_train.dtype != np.uint16:
-            y_train = np.array(y_train, copy=False).astype(np.uint16, copy=False)
-    else:
-        if y_train.dtype != np.uint32:
-            y_train = np.array(y_train, copy=False).astype(np.uint32, copy=False)
-
-    if x_test is not None:
-        x_test = x_test.astype(dtype, copy=False)
-
-        if len(y_test[0]) < 256:
-            if y_test.dtype != np.uint8:
-                y_test = np.array(y_test, copy=False).astype(np.uint8, copy=False)
-        elif len(y_test[0]) <= 32767:
-            if y_test.dtype != np.uint16:
-                y_test = np.array(y_test, copy=False).astype(np.uint16, copy=False)
-        else:
-            if y_test.dtype != np.uint32:
-                y_test = np.array(y_test, copy=False).astype(np.uint32, copy=False)
+    y_train = optimize_labels(y_train, cuda=False)
 
     if x_test is None and y_test is None:
         x_test = x_train
         y_test = y_train
         data = 'Train'
     else:
+        x_test = x_test.astype(dtype, copy=False)
+        y_test = optimize_labels(y_test, cuda=False)
         data = 'Test'
 
-    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
-
     # 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 strategy != 'accuracy' and strategy != 'f1' and strategy != 'recall' and strategy != 'precision': raise ValueError("Strategy parameter only be 'accuracy' or 'f1' or 'recall' or 'precision'.")
 
+    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)
 
@@ -306,19 +294,20 @@ def learner(x_train, y_train, x_test=None, y_test=None, strategy='accuracy', bat
         ncols = 76
     else:
         ncols = 89
-    progress = initialize_loading_bar(total=len(activation_potentiation), desc="", ncols=ncols, bar_format=bar_format_learner)
 
     # 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)
-        model = evaluate(x_test_batch, y_test_batch, W=W, loading_bar_status=False, activation_potentiation=activations, dtype=dtype)
+        model = evaluate(x_test_batch, y_test_batch, W=start_this_W, loading_bar_status=False, activation_potentiation=act_pop, dtype=dtype)
 
         if loss == 'categorical_crossentropy':
             test_loss = categorical_crossentropy(y_true_batch=y_test_batch, y_pred_batch=model[get_preds_softmax()])
@@ -328,12 +317,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
@@ -341,80 +333,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)
+            
+            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)
 
-            W = fit(x_train, y_train, activation_potentiation=activations, train_bar=False, auto_normalization=auto_normalization, dtype=dtype)
-            model = evaluate(x_test_batch, y_test_batch, W=W, loading_bar_status=False, activation_potentiation=activations, dtype=dtype)
-
+            model = evaluate(x_test_batch, y_test_batch, W=weight_pop[j], loading_bar_status=False, activation_potentiation=act_pop[j], dtype=dtype)
             acc = model[get_acc()]
+            
+            if strategy == 'accuracy': target_pop.append(acc)
 
-            if strategy == 'loss' or strategy == 'all':
-                if loss == 'categorical_crossentropy':
-                    test_loss = categorical_crossentropy(y_true_batch=y_test_batch, y_pred_batch=model[get_preds_softmax()])
-                else:
-                    test_loss = binary_crossentropy(y_true_batch=y_test_batch, y_pred_batch=model[get_preds_softmax()])
-
-                if i == 0 and j == 0 and start_this is None:
-                    best_loss = test_loss
-
-            if strategy == 'f1' or strategy == 'precision' or strategy == 'recall' or strategy == 'all':
+            elif strategy == 'f1' or strategy == 'precision' or strategy == 'recall':
                 precision_score, recall_score, f1_score = metrics(y_test_batch, model[get_preds()])
 
-                if strategy == 'precision' or strategy == 'all':
+                if strategy == 'precision':
+                    target_pop.append(precision_score)
+
                     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 == 'precision' and precision_score >= best_precision) or
+                (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=y_test_batch, y_pred_batch=model[get_preds_softmax()])
-                    else:
-                        test_loss = binary_crossentropy(y_true_batch=y_test_batch, y_pred_batch=model[get_preds_softmax()])
+                if loss == 'categorical_crossentropy':
+                    test_loss = categorical_crossentropy(y_true_batch=y_test_batch, y_pred_batch=model[get_preds_softmax()])
+                else:
+                    test_loss = binary_crossentropy(y_true_batch=y_test_batch, y_pred_batch=model[get_preds_softmax()])
 
                 if batch_size == 1:
                     postfix_dict[f"{data} Loss"] = test_loss
@@ -426,9 +403,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'] = (
@@ -496,25 +473,16 @@ 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(np.array(weight_pop, dtype=dtype), act_pop, i, np.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)
@@ -548,7 +516,7 @@ def learner(x_train, y_train, x_test=None, y_test=None, strategy='accuracy', bat
     else:
         train_loss = binary_crossentropy(y_true_batch=y_train, y_pred_batch=train_model[get_preds_softmax()])
 
-    print('\nActivations: ', final_activations)
+    print('\nActivations: ', act_pop[-1])
     print(f'Train Accuracy (%{batch_size * 100} of train samples):', train_model[get_acc()])
     print(f'Train Loss (%{batch_size * 100} of train samples): ', train_loss, '\n')
     if data == 'Test':