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

pyerualjetwork/planeat.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
@@ -12,7 +14,7 @@ ANAPLAN document: https://github.com/HCB06/Anaplan/blob/main/Welcome_to_Anaplan/
 
 import numpy as np
 import random
-from tqdm import tqdm
+import math
 
 ### LIBRARY IMPORTS ###
 from .plan import feed_forward
@@ -69,155 +71,199 @@ def define_genomes(input_shape, output_shape, population_size, dtype=np.float32)
    return np.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=np.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=np.float32):
    """
-Applies the evolving process of a population of genomes using selection, crossover, mutation, and activation function potentiation.
-The function modifies the population's weights and activation functions based on a specified policy, mutation probabilities, and strategy.
+   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 (numpy.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 (numpy.ndarray): A 1D array containing the fitness values of each genome. 
-        The array is used to rank the genomes based on their performance. PLANEAT maximizes or minimizes this fitness for looking 'target' hyperparameter.
-    
-    show_info (bool, optional): If True, prints information about the current generation and the 
-        maximum reward obtained. Also shows the current configuration. Default is False.
-    
-    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'     
-   
-    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.
+   Args:
+      weights (numpy.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 (numpy.ndarray): A 1D array containing the fitness values of each genome. 
+         The array is used to rank the genomes based on their performance. PLANEAT maximizes or minimizes this fitness 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
 
-    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 (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)
-
-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.
+      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.
 
-Example:
-    ```python
-    weights, activation_potentiations = planeat.evolve(weights, activation_potentiations, 1, fitness, show_info=True, strategy='cross_over', policy='normal_selective')
-    ```
+            - '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.
+
+            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`.
+
+      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 (numpy.dtype): Data type for the arrays. Default: np.float32. 
+         Example: np.float64 or np.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.
+   """
 
-    - 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'")
-   
+      raise ValueError("strategy 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):
+   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 fitness_bias < 0 or fitness_bias > 1: raise ValueError("fitness_bias value 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 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 = np.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 np.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)
-            
-            if mutations is True:
-
-               mutation_prob = random.uniform(0, 1)
-
-               if mutation_prob > bad_genoms_mutation_prob:
-                  if (save_best_genom == True and not np.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))
+      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 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])
-            
-            if mutations is True:
-
-               mutation_prob = random.uniform(0, 1)
-
-               if mutation_prob > bad_genoms_mutation_prob:
-                  if (save_best_genom == True and not np.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 = np.vstack((bad_weights, best_weights))
-   activation_potentiations = bad_activations + best_activations
+   weights = np.vstack((bad_weights, good_weights))
+   activation_potentiations = bad_activations + good_activations
 
    ### INFO PRINTING CONSOLE
    
@@ -334,22 +380,21 @@ 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("  BAD GENOMES SELECTION PROB: ", str(bad_genomes_selection_prob))
       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 ***")
@@ -377,7 +422,7 @@ def evaluate(x_population, weights, activation_potentiations, rl_mode=False, dty
         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.
 
         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)                         
@@ -402,7 +447,7 @@ def evaluate(x_population, weights, activation_potentiations, rl_mode=False, dty
         outputs = evaluate(x_population, weights, activation_potentiations, rl_mode=False)
         ```
 
-    - The function returns a list of outputs after processing the population, where each element corresponds to 
+    - The function returns a list of outputs after processing the population, where each element corresponds to
       the output for each genome in `x_population`.
    """
    
@@ -435,39 +480,82 @@ 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 (numpy.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=np.finfo.eps
+        )
         ```
     """
    
@@ -475,8 +563,29 @@ def cross_over(best_weight, good_weight, best_activations, good_activations, cro
    
    start = 0
    
-   row_end = best_weight.shape[0]
-   col_end = best_weight.shape[1]
+   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 = np.copy(first_parent_W)
+      dominant_parent_act = first_parent_act
+
+      undominant_parent_W = np.copy(second_parent_W)
+      undominant_parent_act = second_parent_act
+      succes = second_parent_fitness + epsilon
+
+   elif decision == 'second_parent':
+      dominant_parent_W = np.copy(second_parent_W)
+      dominant_parent_act = second_parent_act
+
+      undominant_parent_W = np.copy(first_parent_W)
+      undominant_parent_act = first_parent_act
+      succes = first_parent_fitness + epsilon
 
    while True:
 
@@ -486,48 +595,46 @@ 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 = np.copy(best_weight)
-   best_w2 = np.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 + epsilon))
+         row_cut_end = math.ceil(row_cut_end * (succes + epsilon))
 
-   if isinstance(best_activations, str):
-      best = [best_activations]
+         col_cut_start = math.floor(col_cut_start * (succes + epsilon))
+         col_cut_end = math.ceil(col_cut_end * (succes + epsilon))
 
-   if isinstance(good_activations, str):
-      good = [good_activations]
+   child_W = dominant_parent_W
 
-   if isinstance(best_activations, list):
-      best = best_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(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
          
@@ -538,69 +645,37 @@ 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
-
-def potentiate(best_weight, good_weight, best_activations, good_activations, dtype=np.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 (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 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=np.float32):
+   return child_W, child_act
+
+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.
@@ -608,14 +683,24 @@ def mutation(weight, activations, activation_mutate_prob, activation_add_prob, a
 
     Args:
         weight (numpy.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 (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)
+        
+        genome_fitness (float): Fitness value of genome
+    
+        epsilon (float): Small epsilon constant
 
     Returns:
         tuple: A tuple containing:
@@ -634,8 +719,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)
@@ -645,6 +729,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:
@@ -659,8 +745,7 @@ def mutation(weight, activations, activation_mutate_prob, activation_add_prob, a
             pass
          
          else:
-            break 
-   
+            break
    
    activation_mutate_prob = 1 - activation_mutate_prob
    potential_activation_mutation = random.uniform(0, 1)
@@ -684,13 +769,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
@@ -699,26 +778,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 = np.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))
@@ -726,18 +791,28 @@ def mutation(weight, activations, activation_mutate_prob, activation_add_prob, a
 
          activations[random_index_genom_act] = all_acts[random_index_all_act]
 
-         wc = np.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))
 
-         weight = normalization(weight, dtype=dtype)
+   if selection_prob > bad_genomes_selection_prob:
+      second_selected_W = good_weights[random_index]
+      second_selected_act = good_activations[random_index]
 
-         for i in range(weight.shape[0]):
+   else:
+      second_selected_W = bad_weights[random_index]
+      second_selected_act = bad_activations[random_index]
+
+   return second_selected_W, second_selected_act, random_index
+      
+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