pyerualjetwork 4.1.9b1__py3-none-any.whl → 4.2.0__py3-none-any.whl

pyerualjetwork/planeat_cuda.py

@@ -1,6 +1,8 @@
 """ 
 MAIN MODULE FOR PLANEAT
 
+Examples: https://github.com/HCB06/PyerualJetwork/tree/main/Welcome_to_PyerualJetwork/ExampleCodes
+
 ANAPLAN document: https://github.com/HCB06/Anaplan/blob/main/Welcome_to_Anaplan/ANAPLAN_USER_MANUEL_AND_LEGAL_INFORMATION(EN).pdf
 
 @author: Hasan Can Beydili
@@ -13,6 +15,7 @@ ANAPLAN document: https://github.com/HCB06/Anaplan/blob/main/Welcome_to_Anaplan/
 import cupy as cp
 import numpy as np
 import random
+import math
 
 
 ### LIBRARY IMPORTS ###
@@ -70,155 +73,198 @@ def define_genomes(input_shape, output_shape, population_size, dtype=cp.float32)
    return cp.array(population_weights, dtype=dtype), population_activations
 
 
-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=cp.float32):
+def evolver(weights, 
+            activation_potentiations, 
+            what_gen, 
+            fitness, 
+            show_info=False, 
+            policy='aggressive', 
+            bad_genomes_selection_prob=None, 
+            bar_status=True, 
+            strategy='normal_selective', 
+            target_fitness='max', 
+            mutations=True, 
+            bad_genomes_mutation_prob=None, 
+            activation_mutate_prob=0.5, 
+            save_best_genom=True, 
+            fitness_bias=None, 
+            cross_over_mode='tpm',
+            activation_mutate_add_prob=0.5, 
+            activation_mutate_delete_prob=0.5, 
+            activation_mutate_change_prob=0.5, 
+            weight_mutate_prob=1, 
+            weight_mutate_rate=32, 
+            activation_selection_add_prob=0.6, 
+            activation_selection_change_prob=0.4, 
+            activation_selection_rate=2, 
+            dtype=cp.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.
+  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.
 
-Args:
-    weights (cupy.ndarray): Array of weights for each genome. 
-        (first returned value of define_genomes function)
-    
-    activation_potentiations (list): A list of activation functions for each genome. 
-        (second returned value of define_genomes function)
-    
-    what_gen (int): The current generation number, used for informational purposes or logging.
-    
-    fitness (cupy.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.
-    
-    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.
-    
-    strategy (str, optional): The strategy for combining the best and bad genomes. Options:
-        - 'cross_over': Perform crossover between the best genomes and replace bad genomes. 
-          (Classic NEAT crossover)
-        - 'potentiate': Cumulate the weight of the best genomes and replace bad genomes. 
-          (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
+   'selection' args effects cross-over.
+   'mutate' args effects mutation.
 
-    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'
+   Args:
+      weights (cupy.ndarray): Array of weights for each genome. 
+         (first returned value of define_genomes function)
+      
+      activation_potentiations (list): A list of activation functions for each genome. 
+         (second returned value of define_genomes function)
+      
+      what_gen (int): The current generation number, used for informational purposes or logging.
+      
+      fitness (cupy.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 based on the `target_fitness` parameter.
+      
+      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.
+      
+      strategy (str, optional): The strategy for combining the best and bad genomes. Options:
+         - 'normal_selective': Normal selection based on reward, where a portion of the bad genes are discarded.
+         - 'more_selective': A more selective strategy, where fewer bad genes survive.
+         - 'less_selective': A less selective strategy, where more bad genes survive.
+         Default is 'normal_selective'.
+      
+      bar_status (bool, optional): Loading bar status during evolving process of genomes. True or False. Default: True
 
-    mutations (bool, optional): If True, mutations are applied to the bad genomes and potentially 
-        to the best genomes as well. Default is True.
-    
-    bad_genoms_mutation_prob (float, optional): The probability of applying mutation to the bad genomes. 
-        Must be in the range [0, 1]. Also affects the mutation probability of the best genomes inversely. 
-        For example, a value of 0.7 for bad genomes implies 0.3 for best genomes. Default is None, 
-        which means it is determined by the `policy` argument.
-    
-    activation_mutate_prob (float, optional): The probability of applying mutation to the activation functions. 
-        Must be in the range [0, 1]. Default is 0.5 (50%).
-    
-    save_best_genom (bool, optional): If True, ensures that the best genomes are saved and not mutated 
-        or altered during reproduction. Default is True.
-    
-    cross_over_mode (str, optional): Specifies the crossover method to use. Options:
-        - 'tpm': Two-Point Matrix Crossover
-        - 'plantic': plantic Crossover
-        Default is 'tpm'.
-    
-    activation_add_prob (float, optional): The probability of adding a new activation function to the genome for mutation. 
-        Must be in the range [0, 1]. Default is 0.5.
-    
-    activation_delete_prob (float, optional): The probability of deleting an existing activation function 
-        from the genome for mutation. Must be in the range [0, 1]. Default is 0.5.
-    
-    activation_change_prob (float, optional): The probability of changing an activation function in the genome for mutation. 
-        Must be in the range [0, 1]. Default is 0.5.
-    
-    weight_mutate_prob (float, optional): The probability of mutating a weight in the genome. 
-        Must be in the range [0, 1]. Default is 1.
-    
-    weight_mutate_rate (int, optional): If the value you enter here is equal to the result of input layer * output layer, 
-        only a single weight will be mutated during each mutation process. If the value you enter here is half 
-        of the result of input layer * output layer, two weights in the weight matrix will be mutated. 
-        WARNING: if you don't understand do NOT change this value. Default is 32.
+      policy (str, optional): The selection policy that governs how genomes are selected for reproduction. Options:
+            
+            - 'aggressive': Aggressive policy using very aggressive selection policy. 
+                  Advantages: fast training. 
+                  Disadvantages: may lead to fitness stuck in a local maximum or minimum.
 
-    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.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.
-    
-    activation_selection_rate (int, optional): If the activation list of a good genome is smaller than the value entered here, only one activation will undergo a crossover operation. In other words, this parameter controls the model complexity. Default is 2.
-
-    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)
-
-Raises:
-    ValueError: 
-        - If `policy` is not one of the specified values ('normal_selective', 'more_selective', 'less_selective').
-        - If `cross_over_mode` is not one of the specified values ('tpm', 'plantic').
-        - If `bad_genoms_mutation_prob`, `activation_mutate_prob`, or other probability parameters are not in the range [0, 1].
-        - If the population size is odd (ensuring an even number of genomes is required for proper selection).
-
-Returns:
-    tuple: A tuple containing:
-        - weights (numpy.ndarray): The updated weights for the population after selection, crossover, and mutation. 
-                                  The shape is (population_size, output_shape, input_shape).
-        - activation_potentiations (list): The updated list of activation functions for the population.
-
-Notes:
-    - **Selection Process**: 
-        - 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**:
-        - The **'cross_over'** strategy performs crossover, where parts of the best genomes' weights are combined with the other good genomes to create new weight matrices.
-        - The **'potentiate'** strategy strengthens the best genomes by potentiating their weights towards the other good genomes.
-        
-    - **Mutation**:
-        - Mutation is applied to both the best and bad genomes, depending on the mutation probability and the `policy`.
-        - `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 `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.
+            - 'explorer': Explorer policy increases population diversity.
+                  Advantages: fitness does not get stuck at local maximum or minimum.
+                  Disadvantages: slow training.
+                  
+                  Suggestions: Use hybrid and dynamic policy. When fitness appears stuck, switch to the 'explorer' policy.
 
-Example:
-    ```python
-    weights, activation_potentiations = planeat.evolve(weights, activation_potentiations, 1, fitness, show_info=True, strategy='cross_over', policy='normal_selective')
-    ```
+            Default: 'aggressive'.
+      
+      target_fitness (str, optional): Target fitness strategy for PLANEAT optimization. ('max' maximizes fitness, 'min' minimizes fitness.) Default: 'max'.
+      
+      fitness_bias (float, optional): Fitness bias must be a probability value between 0 and 1 that determines the effect of fitness on the crossover process. Default: Determined by the `strategy`.
 
-    - The function returns the updated weights and activations after processing based on the chosen strategy, policy, and mutation parameters.
+      mutations (bool, optional): If True, mutations are applied to the bad genomes and potentially 
+         to the best genomes as well. Default is True.
+      
+      bad_genomes_mutation_prob (float, optional): The probability of applying mutation to the bad genomes. 
+         Must be in the range [0, 1]. Also affects the mutation probability of the best genomes inversely. 
+         For example, a value of 0.7 for bad genomes implies 0.3 for best genomes. Default: Determined by `policy`.
+      
+      activation_mutate_prob (float, optional): The probability of applying mutation to the activation functions. 
+         Must be in the range [0, 1]. Default is 0.5 (50%).
+      
+      save_best_genom (bool, optional): If True, ensures that the best genomes are saved and not mutated 
+         or altered during reproduction. Default is True.
+      
+      cross_over_mode (str, optional): Specifies the crossover method to use. Options:
+         - 'tpm': Two-Point Matrix Crossover.
+         Default is 'tpm'.
+      
+      activation_mutate_add_prob (float, optional): The probability of adding a new activation function to the genome for mutation. 
+         Must be in the range [0, 1]. Default is 0.5.
+      
+      activation_mutate_delete_prob (float, optional): The probability of deleting an existing activation function 
+         from the genome for mutation. Must be in the range [0, 1]. Default is 0.5.
+      
+      activation_mutate_change_prob (float, optional): The probability of changing an activation function in the genome for mutation. 
+         Must be in the range [0, 1]. Default is 0.5.
+      
+      weight_mutate_prob (float, optional): The probability of mutating a weight in the genome. 
+         Must be in the range [0, 1]. Default is 1.
+      
+      weight_mutate_rate (int, optional): If the value entered here equals the result of input_layer * output_layer, 
+         only a single weight will be mutated during each mutation process. If the value is half of the result, 
+         two weights will be mutated. 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 crossover.
+         Must be in the range [0, 1]. Default is 0.6. (WARNING! Higher values increase complexity. For faster training, increase this value.)
+      
+      activation_selection_change_prob (float, optional): The probability of changing an activation function in the genome for crossover. 
+         Must be in the range [0, 1]. Default is 0.4.
+      
+      activation_selection_rate (int, optional): If the activation list of a good genome is smaller than this value, only one activation will undergo crossover. This parameter controls model complexity. Default is 2.
+
+      dtype (cupy.dtype): Data type for the arrays. Default: cp.float32. 
+         Example: cp.float64 or cp.float16 [fp32 for balanced devices, fp64 for strong devices, fp16 for weak devices: not recommended!].
+
+   Raises:
+      ValueError: 
+         - If `policy` is not one of the specified values ('aggressive', 'explorer').
+         - If 'strategy' is not one of the specified values ('less_selective', 'normal_selective', 'more_selective')
+         - If `cross_over_mode` is not one of the specified values ('tpm').
+         - If `bad_genomes_mutation_prob`, `activation_mutate_prob`, or other probability parameters are not in the range 0 and 1.
+         - If the population size is odd (ensuring an even number of genomes is required for proper selection).
+         - If 'fitness_bias' value is not in range 0 and 1.
+
+   Returns:
+      tuple: A tuple containing:
+         - weights (numpy.ndarray): The updated weights for the population after selection, crossover, and mutation. 
+                                    The shape is (population_size, output_shape, input_shape).
+         - activation_potentiations (list): The updated list of activation functions for the population.
+
+   Notes:
+      - **Selection Process**: 
+         - 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 Strategies**:
+         - The **'cross_over'** strategy performs crossover, where parts of the best genomes' weights are combined with other good genomes to create new weight matrices.
+         
+      - **Mutation**:
+         - Mutation is applied to both the best and bad genomes, depending on the mutation probability and the `policy`.
+         - `bad_genomes_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 `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 = planeat.evolver(weights, activation_potentiations, 1, fitness, show_info=True, strategy='normal_selective', policy='aggressive')
+      ```
+
+      - The function returns the updated weights and activations after processing based on the chosen strategy, policy, and mutation parameters.
 """
     
 ### ERROR AND CONFIGURATION CHECKS:
-
-   if policy == 'normal_selective':
-      if bad_genoms_mutation_prob == None:
-         bad_genoms_mutation_prob = 0.7
+   if strategy == 'normal_selective':
+      if bad_genomes_mutation_prob is None: bad_genomes_mutation_prob = 0.7 # EFFECTS MUTATION
+      if bad_genomes_selection_prob is None: bad_genomes_selection_prob = 0.25 # EFFECTS CROSS-OVER
+      if fitness_bias is None: fitness_bias = 0.5 # The pressure applied by FITNESS to the CROSS-OVER
       
-   elif policy == 'more_selective':
-      if bad_genoms_mutation_prob == None:
-         bad_genoms_mutation_prob = 0.85
+   elif strategy == 'more_selective':
+      if bad_genomes_mutation_prob is None: bad_genomes_mutation_prob = 0.85 # EFFECTS MUTATION
+      if bad_genomes_selection_prob is None: bad_genomes_selection_prob = 0.1 # EFFECTS CROSS-OVER
+      if fitness_bias is None: fitness_bias = 0.7 # The pressure applied by FITNESS to the CROSS-OVER
 
-   elif policy == 'less_selective':
-      if bad_genoms_mutation_prob == None:
-         bad_genoms_mutation_prob = 0.6
+   elif strategy == 'less_selective':
+      if bad_genomes_mutation_prob is None: bad_genomes_mutation_prob = 0.6 # EFFECTS MUTATION
+      if bad_genomes_selection_prob is None: bad_genomes_selection_prob = 0.5 # EFFECTS CROSS-OVER
+      if fitness_bias is None: fitness_bias = 0.3 # The pressure applied by FITNESS to the CROSS-OVER
 
    else:
-      raise ValueError("policy parameter must be: 'normal_selective' or 'more_selective' or 'less_selective'")
-   
-   
-   if (activation_add_prob < 0 or activation_add_prob > 1) or (activation_change_prob < 0 or activation_change_prob > 1) or (activation_delete_prob < 0 or activation_delete_prob > 1) or (weight_mutate_prob < 0 or weight_mutate_prob > 1) or (activation_selection_add_prob < 0 or activation_selection_add_prob > 1) or (activation_selection_change_prob < 0 or activation_selection_change_prob > 1):
+      raise ValueError("strategy parameter must be: 'normal_selective' or 'more_selective' or 'less_selective'")
+    
+   if policy =='explorer': fitness_bias = 0
+
+   if ((activation_mutate_add_prob < 0 or activation_mutate_add_prob > 1) or 
+      (activation_mutate_change_prob < 0 or activation_mutate_change_prob > 1) or 
+      (activation_mutate_delete_prob < 0 or activation_mutate_delete_prob > 1) or 
+      (weight_mutate_prob < 0 or weight_mutate_prob > 1) or 
+      (activation_selection_add_prob < 0 or activation_selection_add_prob > 1) or (
+      activation_selection_change_prob < 0 or activation_selection_change_prob > 1)):
+      
       raise ValueError("All hyperparameters ending with 'prob' must be a number between 0 and 1.")
 
-   if cross_over_mode != 'tpm' and cross_over_mode != 'plantic':
-      raise ValueError("cross_over_mode parameter must be 'tpm' or 'plantic'")
+   if fitness_bias < 0 or fitness_bias > 1: raise ValueError("fitness_bias value must be a number between 0 and 1.")
 
-   if bad_genoms_mutation_prob is not None:
-      if not isinstance(bad_genoms_mutation_prob, float) or bad_genoms_mutation_prob < 0 or bad_genoms_mutation_prob > 1:
-         raise ValueError("bad_genoms_mutation_prob parameter must be float and 0-1 range")
+   if bad_genomes_mutation_prob is not None:
+      if not isinstance(bad_genomes_mutation_prob, float) or bad_genomes_mutation_prob < 0 or bad_genomes_mutation_prob > 1:
+         raise ValueError("bad_genomes_mutation_prob parameter must be float and 0-1 range")
       
    if activation_mutate_prob is not None:
       if not isinstance(activation_mutate_prob, float) or activation_mutate_prob < 0 or activation_mutate_prob > 1:
@@ -242,90 +288,90 @@ Example:
 
 ### GENOMES ARE DIVIDED INTO TWO GROUPS: GOOD GENOMES AND BAD GENOMES:
 
-   best_weights = weights[slice_center:]
+   good_weights = weights[slice_center:]
    bad_weights = weights[:slice_center]
-   best_weight = best_weights[len(best_weights)-1]
+   best_weight = good_weights[-1]
 
-   best_activations = list(activation_potentiations[slice_center:])
+   good_activations = list(activation_potentiations[slice_center:])
    bad_activations = list(activation_potentiations[:slice_center])
-   best_activation = best_activations[len(best_activations) - 1]
+   best_activations = good_activations[-1]
 
    
-### NEAT IS APPLIED ACCORDING TO THE SPECIFIED POLICY, STRATEGY, AND PROBABILITY CONFIGURATION:
+### PLANEAT IS APPLIED ACCORDING TO THE SPECIFIED POLICY, STRATEGY, AND PROBABILITY CONFIGURATION:
    
    bar_format = loading_bars()[0]
    
-   if bar_status: progress = initialize_loading_bar(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)
+   normalized_fitness = abs(normalization(fitness, dtype=dtype))
 
-   for i in range(len(bad_weights)):
+   best_fitness = normalized_fitness[-1]
+   epsilon = cp.finfo(float).eps
 
-      if policy == 'normal_selective':
-            
-         if strategy == 'cross_over':
-            bad_weights[i], bad_activations[i] = cross_over(best_weight, best_weights[i], best_activations=best_activation, good_activations=best_activations[i], cross_over_mode=cross_over_mode, activation_selection_add_prob=activation_selection_add_prob, activation_selection_change_prob=activation_selection_change_prob, activation_selection_rate=activation_selection_rate)
+   for i in range(len(bad_weights)):
+      
+      if policy == 'aggressive':
+         first_parent_W = best_weight
+         first_parent_act = best_activations
 
+      elif policy == 'explorer':
+         first_parent_W = good_weights[i]
+         first_parent_act = good_activations[i]
 
-         elif strategy == 'potentiate':
-            bad_weights[i], bad_activations[i] = potentiate(best_weight, best_weights[i], best_activations=best_activation, good_activations=best_activations[i], dtype=dtype)
-            
+      else: raise ValueError("policy parameter must be: 'aggressive' or 'explorer'")
          
-         if mutations is True:
-            
-            mutation_prob = random.uniform(0, 1)
-
-            if mutation_prob > bad_genoms_mutation_prob:
-               if (save_best_genom == True and not cp.array_equal(best_weights[i], best_weight)) or save_best_genom == False:
-                  best_weights[i], best_activations[i] = mutation(best_weights[i], best_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)
-               
-            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 policy == 'more_selective':
-               
-            if strategy == 'cross_over':            
-               bad_weights[i], bad_activations[i] = cross_over(best_weight, best_weights[i], best_activations=best_activation, good_activations=best_activations[i], cross_over_mode=cross_over_mode, activation_selection_add_prob=activation_selection_add_prob, activation_selection_change_prob=activation_selection_change_prob, activation_selection_rate=activation_selection_rate)
-            
-            elif strategy == 'potentiate':
-               bad_weights[i], bad_activations[i] = potentiate(best_weight, best_weights[i], best_activations=best_activation, good_activations=best_activations[i], dtype=dtype)
+      second_parent_W, second_parent_act, s_i = second_parent_selection(good_weights, bad_weights, good_activations, bad_activations, bad_genomes_selection_prob)
+
+      bad_weights[i], bad_activations[i] = cross_over(first_parent_W,
+                                             second_parent_W,
+                                             first_parent_act,
+                                             second_parent_act,
+                                             cross_over_mode=cross_over_mode,
+                                             activation_selection_add_prob=activation_selection_add_prob,
+                                             activation_selection_change_prob=activation_selection_change_prob,
+                                             activation_selection_rate=activation_selection_rate,
+                                             bad_genomes_selection_prob=bad_genomes_selection_prob,
+                                             first_parent_fitness=best_fitness,
+                                             fitness_bias=fitness_bias,
+                                             second_parent_fitness=normalized_fitness[s_i],
+                                             epsilon=epsilon
+                                             )
+  
+
+      if mutations is True:
+         mutation_prob = random.uniform(0, 1)
+
+         if mutation_prob > bad_genomes_mutation_prob:
+            if (save_best_genom == True and not np.array_equal(good_weights[i], best_weight)) or save_best_genom == False:
+
+               good_weights[i], good_activations[i] = mutation(good_weights[i], 
+                                                               good_activations[i],
+                                                               activation_mutate_prob=activation_mutate_prob,
+                                                               activation_add_prob=activation_mutate_add_prob, 
+                                                               activation_delete_prob=activation_mutate_delete_prob, 
+                                                               activation_change_prob=activation_mutate_change_prob, 
+                                                               weight_mutate_prob=weight_mutate_prob, 
+                                                               threshold=weight_mutate_rate,
+                                                               genome_fitness=normalized_fitness[i],
+                                                               epsilon=epsilon
+                                                               )
             
-            if mutations is True:
-
-               mutation_prob = random.uniform(0, 1)
-
-               if mutation_prob > bad_genoms_mutation_prob:
-                  if (save_best_genom == True and not cp.array_equal(best_weights[i], best_weight)) or save_best_genom == False:
-                     best_weights[i], best_activations[i] = mutation(best_weights[i], best_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)
-                  
-               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 policy == 'less_selective':
-
-            random_index = int(random.uniform(0, len(best_weights) - 1))
-            
-            if strategy == 'cross_over': 
-               bad_weights[i], bad_activations[i] = cross_over(best_weights[random_index], best_weights[i], best_activations=best_activations[random_index], good_activations=best_activations[i], cross_over_mode=cross_over_mode, activation_selection_add_prob=activation_selection_add_prob, activation_selection_change_prob=activation_selection_change_prob, activation_selection_rate=activation_selection_rate)
+         elif mutation_prob < bad_genomes_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_mutate_add_prob, 
+                                                            activation_delete_prob=activation_mutate_delete_prob, 
+                                                            activation_change_prob=activation_mutate_change_prob, 
+                                                            weight_mutate_prob=weight_mutate_prob, 
+                                                            threshold=weight_mutate_rate, 
+                                                            genome_fitness=normalized_fitness[i],
+                                                            epsilon=epsilon
+                                                            )
             
-            elif strategy == 'potentiate':
-               bad_weights[i], bad_activations[i] = potentiate(best_weights[random_index], best_weights[i], best_activations=best_activations[random_index], good_activations=best_activations[i], dtype=dtype)
-            
-            if mutations is True:
-
-               mutation_prob = random.uniform(0, 1)
-
-               if mutation_prob > bad_genoms_mutation_prob:
-                  if (save_best_genom == True and not cp.array_equal(best_weights[i], best_weight)) or save_best_genom == False:
-                     best_weights[i], best_activations[i] = mutation(best_weights[i], best_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)
-                  
-               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 = cp.vstack((bad_weights, best_weights))
-   activation_potentiations = bad_activations + best_activations
+   weights = cp.vstack((bad_weights, good_weights))
+   activation_potentiations = bad_activations + good_activations
 
    ### INFO PRINTING CONSOLE
    
@@ -334,26 +380,24 @@ Example:
       print("*** Configuration Settings ***")
       print("  POPULATION SIZE: ", str(len(weights)))
       print("  STRATEGY: ", strategy)
-
-      if strategy == 'cross_over':
-         print("  CROSS OVER MODE: ", cross_over_mode)
-
+      print("  CROSS OVER MODE: ", cross_over_mode)
       print("  POLICY: ", policy)
       print("  MUTATIONS: ", str(mutations))
-      print("  BAD GENOMES MUTATION PROB: ", str(bad_genoms_mutation_prob))
-      print("  GOOD GENOMES MUTATION PROB: ", str(round(1 - bad_genoms_mutation_prob, 2)))
+      print("  BAD GENOMES MUTATION PROB: ", str(bad_genomes_mutation_prob))
+      print("  GOOD GENOMES MUTATION PROB: ", str(round(1 - bad_genomes_mutation_prob, 2)))
       print("  WEIGHT MUTATE PROB: ", str(weight_mutate_prob))
       print("  WEIGHT MUTATE RATE (THRESHOLD VALUE FOR SINGLE MUTATION): ", str(weight_mutate_rate))
       print("  ACTIVATION MUTATE PROB: ", str(activation_mutate_prob))
-      print("  ACTIVATION ADD PROB: ", str(activation_add_prob))
-      print("  ACTIVATION DELETE PROB: ", str(activation_delete_prob))
-      print("  ACTIVATION CHANGE PROB: ", str(activation_change_prob))
+      print("  ACTIVATION MUTATE ADD PROB: ", str(activation_mutate_add_prob))
+      print("  ACTIVATION MUTATE DELETE PROB: ", str(activation_mutate_delete_prob))
+      print("  ACTIVATION MUTATE CHANGE PROB: ", str(activation_mutate_change_prob))
       print("  ACTIVATION SELECTION ADD PROB: ", str(activation_selection_add_prob))
       print("  ACTIVATION SELECTION CHANGE PROB: ", str(activation_selection_change_prob))
+      print("  FITNESS BIAS: ", str(fitness_bias))
       print("  ACTIVATION SELECTION RATE (THRESHOLD VALUE FOR SINGLE CROSS OVER):", str(activation_selection_rate) + '\n')
-
+      
       print("*** Performance ***")
-      print(" MAX REWARD: ", str(cp.round(max(fitness), 2)))
+      print("  MAX REWARD: ", str(cp.round(max(fitness), 2)))
       print("  MEAN REWARD: ", str(cp.round(cp.mean(fitness), 2)))
       print("  MIN REWARD: ", str(cp.round(min(fitness), 2)) + '\n')
 
@@ -361,7 +405,7 @@ Example:
       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')
       
 
-   return cp.array(weights), activation_potentiations
+   return weights, activation_potentiations
 
 
 def evaluate(x_population, weights, activation_potentiations, rl_mode=False, dtype=cp.float32):
@@ -370,14 +414,17 @@ def evaluate(x_population, weights, activation_potentiations, rl_mode=False, dty
     and weights depending on whether reinforcement learning mode is enabled or not.
 
     Args:
-        x_population (list or numpy.ndarray): A list or 2D numpy array where each element represents
+        x_population (list or cupy.ndarray): A list or 2D numpy or cupy array where each element represents
                                                a genome (A list of input features for each genome, or a single set of input features for one genome (only in rl_mode)).
-        weights (list or numpy.ndarray): A list or 2D numpy array of weights corresponding to each genome 
+        
+        weights (list or cupy.ndarray): A list or 2D numpy array of weights corresponding to each genome 
                                          in `x_population`. This determines the strength of connections.
+        
         activation_potentiations (list or str): A list where each entry represents an activation function 
                                                 or a potentiation strategy applied to each genome. If only one 
                                                 activation function is used, this can be a single string.
-        rl_mode (bool, optional): If True, reinforcement learning mode is activated, this accepts x_population is a single genom. (Also weights and activation_potentations a single genomes part.)
+        
+        rl_mode (bool, optional): If True, reinforcement learning mode is activated, this accepts x_population is a single genome. (Also weights and activation_potentations a single genomes part.)
                                   Default is False.
 
                                   
@@ -436,48 +483,112 @@ def evaluate(x_population, weights, activation_potentiations, rl_mode=False, dty
    return outputs
 
 
-def cross_over(best_weight, good_weight, best_activations, good_activations, cross_over_mode, activation_selection_add_prob, activation_selection_change_prob, activation_selection_rate):
+def cross_over(first_parent_W,
+               second_parent_W,
+               first_parent_act,
+               second_parent_act,
+               cross_over_mode,
+               activation_selection_add_prob,
+               activation_selection_change_prob,
+               activation_selection_rate,
+               bad_genomes_selection_prob,
+               first_parent_fitness,
+               second_parent_fitness,
+               fitness_bias,
+               epsilon):
    """
-    Performs a selected Crossover operation on two sets of weights and activation functions.
+    Performs a crossover operation on two sets of weights and activation functions.
     This function combines two individuals (represented by their weights and activation functions) 
     to create a new individual by exchanging parts of their weight matrices and activation functions.
 
     Args:
-        best_weight (numpy.ndarray): The weight matrix of the first individual (parent).
-        good_weight (numpy.ndarray): The weight matrix of the second individual (parent).
-        best_activations (str or list): The activation function(s) of the first individual.
-        good_activations (str or list): The activation function(s) of the second individual.
+        first_parent_W (cupy.ndarray): The weight matrix of the first individual (parent).
+        
+        second_parent_W (numpy.ndarray): The weight matrix of the second individual (parent).
+        
+        first_parent_act (str or list): The activation function(s) of the first individual.
+        
+        second_parent_act (str or list): The activation function(s) of the second individual.
+        
         cross_over_mode (str): Determines the crossover method to be used. Options:
-                                         - 'tpm': Two-Point Matrix Crossover, where sub-matrices of weights 
-                                           are swapped between parents.
-                                         - 'plan': Output Connections Crossover, where specific connections 
-                                           in the weight matrix are crossed over. Default is 'tpm'.
+            - 'tpm': Two-Point Matrix Crossover, where sub-matrices of weights are swapped between parents.
+        
+        activation_selection_add_prob (float): Probability of adding new activation functions 
+            from the second parent to the child genome.
+        
+        activation_selection_change_prob (float): Probability of replacing an activation function in the child genome 
+            with one from the second parent.
+        
+        activation_selection_rate (float): Determines how quickly activation functions are added or replaced 
+            during the crossover process.
+        
+        bad_genomes_selection_prob (float): Probability of selecting a "bad" genome for replacement with the offspring.
+        
+        first_parent_fitness (float): Fitness score of the first parent.
+        
+        second_parent_fitness (float): Fitness score of the second parent.
+        
+        fitness_bias (float): A bias factor used to favor fitter parents during crossover operations.
+
+        epsilon (float): Small epsilon constant
 
     Returns:
         tuple: A tuple containing:
-            - new_weight (numpy.ndarray): The weight matrix of the new individual created by crossover.
-            - new_activations (list): The list of activation functions of the new individual created by crossover.
+            - child_W (numpy.ndarray): The weight matrix of the new individual created by crossover.
+            - child_act (list): The list of activation functions of the new individual created by crossover.
 
     Notes:
         - The crossover is performed based on the selected `cross_over_mode`.
-            - In 'tpm', random sub-matrices from the parent weight matrices are swapped.
-            - In 'plantic', specific connections in the weight matrix are swapped between parents.
-        - The crossover operation combines the activation functions of both parents:
-            - If the activation functions are passed as strings, they are converted to lists for uniform handling.
-            - The resulting activation functions depend on the crossover method and the parent's configuration.
+        - In 'tpm' mode, random sub-matrices from the parent weight matrices are swapped.
+        - Activation functions from both parents are combined using the probabilities and rates provided.
 
     Example:
         ```python
-        new_weights, new_activations = cross_over(best_weight, good_weight, best_activations, good_activations, cross_over_mode='tpm')
+        new_weights, new_activations = cross_over(
+            first_parent_W=parent1_weights, 
+            second_parent_W=parent2_weights, 
+            first_parent_act=parent1_activations, 
+            second_parent_act=parent2_activations, 
+            cross_over_mode='tpm',
+            activation_selection_add_prob=0.8,
+            activation_selection_change_prob=0.5,
+            activation_selection_rate=0.1,
+            bad_genomes_selection_prob=0.7,
+            first_parent_fitness=0.9,
+            second_parent_fitness=0.85,
+            fitness_bias=0.6,
+            epsilon=cp.finfo.eps
+        )
         ```
     """
    
-   ### THE GIVEN GENOMES' WEIGHTS ARE RANDOMLY SELECTED AND COMBINED OVER A RANDOM RANGE. SIMILARLY, THEIR ACTIVATIONS ARE COMBINED. A NEW GENOME IS RETURNED WITH THE COMBINED WEIGHTS FIRST, FOLLOWED BY THE ACTIVATIONS:
+  ### THE GIVEN GENOMES' WEIGHTS ARE RANDOMLY SELECTED AND COMBINED OVER A RANDOM RANGE. SIMILARLY, THEIR ACTIVATIONS ARE COMBINED. A NEW GENOME IS RETURNED WITH THE COMBINED WEIGHTS FIRST, FOLLOWED BY THE ACTIVATIONS:
    
    start = 0
+   
+   row_end = first_parent_W.shape[0]
+   col_end = first_parent_W.shape[1]
+
+   total_gene = row_end * col_end
+   half_of_gene = int(total_gene / 2)
+
+   decision = dominant_parent_selection(bad_genomes_selection_prob)
+
+   if decision == 'first_parent':
+      dominant_parent_W = cp.copy(first_parent_W)
+      dominant_parent_act = first_parent_act
 
-   row_end = best_weight.shape[0]
-   col_end = best_weight.shape[1]
+      undominant_parent_W = cp.copy(second_parent_W)
+      undominant_parent_act = second_parent_act
+      succes = second_parent_fitness + epsilon
+
+   elif decision == 'second_parent':
+      dominant_parent_W = cp.copy(second_parent_W)
+      dominant_parent_act = second_parent_act
+
+      undominant_parent_W = cp.copy(first_parent_W)
+      undominant_parent_act = first_parent_act
+      succes = first_parent_fitness + epsilon
 
    while True:
 
@@ -487,48 +598,47 @@ def cross_over(best_weight, good_weight, best_activations, good_activations, cro
       row_cut_end = int(random.uniform(start, row_end))
       col_cut_end = int(random.uniform(start, col_end))
 
-      if (row_cut_end > row_cut_start) and (col_cut_end > col_cut_start):
+      if ((row_cut_end > row_cut_start) and
+         (col_cut_end > col_cut_start) and
+         (((row_cut_end + 1) - (row_cut_start + 1) * 2) + ((col_cut_end + 1) - (col_cut_start + 1) * 2) <= half_of_gene)):
          break
+      
+      selection_bias = random.uniform(0, 1)
 
-   new_weight = cp.copy(best_weight)
-   best_w2 = cp.copy(good_weight)
-   
-   if cross_over_mode == 'tpm':
-      new_weight[row_cut_start:row_cut_end, col_cut_start:col_cut_end] = best_w2[row_cut_start:row_cut_end, col_cut_start:col_cut_end]
-
-   elif cross_over_mode == 'plantic':
-      new_weight[row_cut_start:row_cut_end,:] = best_w2[row_cut_start:row_cut_end,:]
+      if fitness_bias > selection_bias:
+         row_cut_start = math.floor(row_cut_start * succes)
+         row_cut_end = math.ceil(row_cut_end * succes)
 
+         col_cut_start = math.floor(col_cut_start * succes)
+         col_cut_end = math.ceil(col_cut_end * succes)
 
-   if isinstance(best_activations, str):
-      best = [best_activations]
+   child_W = dominant_parent_W
 
-   if isinstance(good_activations, str):
-      good = [good_activations]
+   if cross_over_mode == 'tpm':
+      child_W[row_cut_start:row_cut_end, col_cut_start:col_cut_end] = undominant_parent_W[row_cut_start:row_cut_end, col_cut_start:col_cut_end]
 
-   if isinstance(best_activations, list):
-      best = best_activations
 
-   if isinstance(good_activations, list):
-      good = good_activations
+   if isinstance(dominant_parent_act, str): dominant_parent_act = [dominant_parent_act]
+   if isinstance(undominant_parent_act, str): undominant_parent_act = [undominant_parent_act]
 
-   new_activations = list(np.copy(best))
+   child_act = list(np.copy(dominant_parent_act))
 
    activation_selection_add_prob = 1 - activation_selection_add_prob # if prob 0.8 (%80) then 1 - 0.8. Because 0-1 random number probably greater than 0.2
    potential_activation_selection_add = random.uniform(0, 1)
 
    if potential_activation_selection_add > activation_selection_add_prob:
       
+      activation_selection_rate = activation_selection_rate / succes
       new_threshold = activation_selection_rate
       
       while True:
          
-         random_index_good = int(random.uniform(0, len(good)-1))
-         random_good_activation = good[random_index_good]
+         random_index = int(random.uniform(0, len(undominant_parent_act)-1))
+         random_undominant_activation = undominant_parent_act[random_index]
 
-         new_activations.append(random_good_activation)
+         child_act.append(random_undominant_activation)
 
-         if len(best) > new_threshold:
+         if len(dominant_parent_act) > new_threshold:
             new_threshold += activation_selection_rate
             pass
          
@@ -539,85 +649,64 @@ def cross_over(best_weight, good_weight, best_activations, good_activations, cro
    potential_activation_selection_change_prob = random.uniform(0, 1)
 
    if potential_activation_selection_change_prob > activation_selection_change_prob:
-
+      
+      activation_selection_rate = activation_selection_rate / succes
       new_threshold = activation_selection_rate
       
       while True:
          
-         random_index_good = int(random.uniform(0, len(good)-1))
-         random_index_best = int(random.uniform(0, len(best)-1))
-         random_good_activation = good[random_index_good]
+         random_index_undominant = int(random.uniform(0, len(undominant_parent_act)-1))
+         random_index_dominant = int(random.uniform(0, len(dominant_parent_act)-1))
+         random_undominant_activation = undominant_parent_act[random_index_undominant]
 
-         new_activations[random_index_best] = good[random_index_good]
+         child_act[random_index_dominant] = random_undominant_activation
 
-         if len(best) > new_threshold:
+         if len(dominant_parent_act) > new_threshold:
             new_threshold += activation_selection_rate
             pass
          
          else:
             break
 
-   return new_weight, new_activations
+   return child_W, child_act
 
-def potentiate(best_weight, good_weight, best_activations, good_activations, dtype=cp.float32):
-   """
-    Combines two sets of weights and activation functions by adding the weight matrices and 
-    concatenating the activation functions. The resulting weight matrix is normalized. (Max abs normalization.)
-    
-    Args:
-        best_weight (numpy.ndarray): The weight matrix of the first individual (parent).
-        good_weight (numpy.ndarray): The weight matrix of the second individual (parent).
-        best_activations (str or list): The activation function(s) of the first individual.
-        good_activations (str or list): The activation function(s) of the second individual.
-        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:
-        tuple: A tuple containing:
-            - new_weight (numpy.ndarray): The new weight matrix after potentiation and normalization. (Max abs normalization.)
-            - new_activations (list): The new activation functions after concatenation.
-    
-    Notes:
-        - The weight matrices are element-wise added and then normalized using the `normalization` function. (Max abs normalization.)
-        - The activation functions from both parents are concatenated to form the new activation functions list.
-        - If the activation functions are passed as strings, they are converted to lists for uniform handling.
-   """
-    
-   new_weight = best_weight + good_weight
-   new_weight = normalization(new_weight, dtype=dtype)
-   
-   if isinstance(best_activations, str):
-      best = [best_activations]
-
-   if isinstance(good_activations, str):
-      good = [good_activations]
-
-   if isinstance(best_activations, list):
-      best = best_activations
-
-   if isinstance(good_activations, list):
-      good = good_activations
-   
-   new_activations = best + good
-   
-   return new_weight, new_activations
 
-def mutation(weight, activations, activation_mutate_prob, activation_add_prob, activation_delete_prob, activation_change_prob, weight_mutate_prob, threshold, dtype=cp.float32):
+def mutation(weight, 
+             activations, 
+             activation_mutate_prob, 
+             activation_add_prob, 
+             activation_delete_prob, 
+             activation_change_prob, 
+             weight_mutate_prob, 
+             threshold, 
+             genome_fitness,
+             epsilon):
    """
     Performs mutation on the given weight matrix and activation functions.
     - The weight matrix is mutated by randomly changing its values based on the mutation probability.
     - The activation functions are mutated by adding, removing, or replacing them with predefined probabilities.
 
     Args:
-        weight (numpy.ndarray): The weight matrix to mutate.
+        weight (cupy.ndarray): The weight matrix to mutate.
+        
         activations (list): The list of activation functions to mutate.
+        
         activation_mutate_prob (float): The overall probability of mutating activation functions.
+        
         activation_add_prob (float): Probability of adding a new activation function.
+        
         activation_delete_prob (float): Probability of removing an existing activation function.
+        
         activation_change_prob (float): Probability of replacing an existing activation function with a new one.
+        
         weight_mutate_prob (float): The probability of mutating weight matrix.
+        
         threshold (float): If the value you enter here is equal to the result of input layer * output layer, only a single weight will be mutated during each mutation process. If the value you enter here is half of the result of input layer * output layer, two weights in the weight matrix will be mutated.
-        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)
         
+        genome_fitness (float): Fitness value of genome
+    
+        epsilon (float): Small epsilon constant
+
     Returns:
         tuple: A tuple containing:
             - mutated_weight (numpy.ndarray): The weight matrix after mutation.
@@ -635,8 +724,7 @@ def mutation(weight, activations, activation_mutate_prob, activation_add_prob, a
           the optimization process.
    """
 
-   if isinstance(activations, str):
-      activations = [activations]
+   if isinstance(activations, str): activations = [activations]
 
    weight_mutate_prob = 1 - weight_mutate_prob # if prob 0.8 (%80) then 1 - 0.8. Because 0-1 random number probably greater than 0.2
    potential_weight_mutation = random.uniform(0, 1)
@@ -646,6 +734,8 @@ def mutation(weight, activations, activation_mutate_prob, activation_add_prob, a
       start = 0
       row_end = weight.shape[0]
       col_end = weight.shape[1]
+      
+      threshold = threshold * (genome_fitness + epsilon)
       new_threshold = threshold
       
       while True:
@@ -662,7 +752,6 @@ def mutation(weight, activations, activation_mutate_prob, activation_add_prob, a
          else:
             break
    
-   
    activation_mutate_prob = 1 - activation_mutate_prob
    potential_activation_mutation = random.uniform(0, 1)
 
@@ -685,13 +774,7 @@ def mutation(weight, activations, activation_mutate_prob, activation_add_prob, a
             
             random_index_all_act = int(random.uniform(0, len(all_acts)-1))
             activations.append(all_acts[random_index_all_act])
-            
-            for i in range(weight.shape[0]):
-
-               weight[i,:] = apply_activation(weight[i,:], activations[-1])
 
-            weight = normalization(weight, dtype=dtype)
-            
          except:
 
             activation = activations
@@ -700,26 +783,12 @@ def mutation(weight, activations, activation_mutate_prob, activation_add_prob, a
             activations.append(activation)
             activations.append(all_acts[int(random.uniform(0, len(all_acts)-1))])
             
-            for i in range(weight.shape[0]):
-
-               weight[i,:] = apply_activation(weight[i,:], activations[-1])
-
-            weight = normalization(weight, dtype=dtype)
-            
       if potential_activation_delete_prob > activation_delete_prob and len(activations) > 1:
          
          random_index = random.randint(0, len(activations) - 1)
-         
-         wc = cp.copy(weight)
-         for i in range(weight.shape[0]):
-
-            wc[i,:] = apply_activation(wc[i,:], activations[random_index])
-            weight[i,:] -= wc[i,:]
-
          activations.pop(random_index)
-         weight = normalization(weight, dtype=dtype)
          
-            
+         
       if potential_activation_change_prob > activation_change_prob:
          
          random_index_all_act = int(random.uniform(0, len(all_acts)-1))
@@ -727,18 +796,30 @@ def mutation(weight, activations, activation_mutate_prob, activation_add_prob, a
 
          activations[random_index_genom_act] = all_acts[random_index_all_act]
 
-         wc = cp.copy(weight)
-         for i in range(weight.shape[0]):
+   return weight, activations
+
 
-            wc[i,:] = apply_activation(wc[i,:], activations[random_index_genom_act])
-            weight[i,:] -= wc[i,:]
+def second_parent_selection(good_weights, bad_weights, good_activations, bad_activations, bad_genomes_selection_prob):
+   
+   selection_prob = random.uniform(0, 1)
+   random_index = int(random.uniform(0, len(good_weights) - 1))
+
+   if selection_prob > bad_genomes_selection_prob:
+      second_selected_W = good_weights[random_index]
+      second_selected_act = good_activations[random_index]
 
-         weight = normalization(weight, dtype=dtype)
+   else:
+      second_selected_W = bad_weights[random_index]
+      second_selected_act = bad_activations[random_index]
+
+   return second_selected_W, second_selected_act, random_index
+      
 
-         for i in range(weight.shape[0]):
+def dominant_parent_selection(bad_genomes_selection_prob):
 
-            weight[i,:] = apply_activation(weight[i,:], activations[random_index_genom_act])
+   selection_prob = random.uniform(0, 1)
 
-         weight = normalization(weight, dtype=dtype)
+   if selection_prob > bad_genomes_selection_prob: decision = 'first_parent'
+   else: decision = 'second_parent'
 
-   return weight, activations
+   return decision