pyerualjetwork 4.2.0b0__py3-none-any.whl → 4.2.0b1__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
@@ -69,148 +71,193 @@ def define_genomes(input_shape, output_shape, population_size, dtype=np.float32)
    return np.array(population_weights, dtype=dtype), population_activations
 
 
-def evolver(weights, activation_potentiations, what_gen, fitness, show_info=False, strategy='cross_over', bad_genomes_selection_prob=None, bar_status=True, policy='normal_selective', target_fitness='max', mutations=True, bad_genomes_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='aggresive', 
+            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_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 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_genomes_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_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.
+      policy (str, optional): The selection policy that governs how genomes are selected for reproduction. Options:
+            
+            - 'aggresive': 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: 'aggresive'.
+      
+      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 ('aggresive', '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='aggresive')
+      ```
+
+      - 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_genomes_mutation_prob is None: bad_genomes_mutation_prob = 0.7
-      if bad_genomes_selection_prob is None: bad_genomes_selection_prob = 0.25
+   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_genomes_mutation_prob is None: bad_genomes_mutation_prob = 0.85
-      if bad_genomes_selection_prob is None: bad_genomes_selection_prob = 0.1
+   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_genomes_mutation_prob is None: bad_genomes_mutation_prob = 0.6
-      if bad_genomes_selection_prob is None: bad_genomes_selection_prob = 0.5
+   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 ((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 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:
@@ -253,42 +300,47 @@ Example:
    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)
-   normalized_fitness = normalization(fitness, dtype=dtype)
+   normalized_fitness = abs(normalization(fitness, dtype=dtype))
 
    best_fitness = normalized_fitness[-1]
 
+   child_W = np.copy(bad_weights)
+   child_act = bad_activations.copy()
+
    for i in range(len(bad_weights)):
       second_parent_W, second_parent_act, s_i = second_parent_selection(good_weights, bad_weights, good_activations, bad_activations, bad_genomes_selection_prob)
 
-      if policy == 'normal_selective' or policy == 'less_selective':
-         if strategy == 'cross_over':
-            bad_weights[i], bad_activations[i] = cross_over(good_weights[i],
-                                                            second_parent_W,
-                                                            good_activations[i],
-                                                            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,
-                                                            first_parent_fitness=normalized_fitness[i],
-                                                            second_parent_fitness=normalized_fitness[s_i]
-                                                            )
-               
-      
-      if policy == 'more_selective':
-            if strategy == 'cross_over':
-               bad_weights[i], bad_activations[i] = cross_over(best_weights,
-                                                               second_parent_W, 
-                                                               best_activations,
-                                                               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, 
-                                                               first_parent_fitness=best_fitness,
-                                                               second_parent_fitness=normalized_fitness[s_i]
-                                                               )
+      if policy == 'aggresive':
+         child_W[i], child_act[i] = cross_over(best_weights,
+                                                         second_parent_W,
+                                                         best_activations,
+                                                         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]
+                                                         )
+      elif policy == 'explorer':
+         child_W[i], child_act[i] = cross_over(good_weights[i],
+                                                         second_parent_W, 
+                                                         good_activations[i],
+                                                         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=normalized_fitness[i],
+                                                         fitness_bias=fitness_bias,
+                                                         second_parent_fitness=normalized_fitness[s_i]
+                                                         )
           
+      else: raise ValueError("policy parameter must be: 'aggresive' or 'explorer'")
+
       if mutations is True:
          mutation_prob = random.uniform(0, 1)
 
@@ -297,28 +349,30 @@ Example:
                good_weights[i], good_activations[i] = mutation(good_weights[i], 
                                                                good_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, 
+                                                               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, 
-                                                               dtype=dtype)
+                                                               threshold=weight_mutate_rate,
+                                                               genome_fitness=normalized_fitness[i]
+                                                               )
             
          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_add_prob, 
-                                                            activation_delete_prob=activation_delete_prob, 
-                                                            activation_change_prob=activation_change_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, 
-                                                            dtype=dtype)
+                                                            genome_fitness=normalized_fitness[i]
+                                                            )
             
       if bar_status: progress.update(1)
 
-   weights = np.vstack((bad_weights, good_weights))
-   activation_potentiations = bad_activations + good_activations
+   weights = np.vstack((child_W, good_weights))
+   activation_potentiations = child_act + good_activations
 
    ### INFO PRINTING CONSOLE
    
@@ -327,22 +381,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_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 ***")
@@ -370,7 +423,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)                         
@@ -395,7 +448,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`.
    """
    
@@ -438,9 +491,10 @@ def cross_over(first_parent_W,
                activation_selection_rate,
                bad_genomes_selection_prob,
                first_parent_fitness,
-               second_parent_fitness):
+               second_parent_fitness,
+               fitness_bias):
    """
-    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.
 
@@ -450,23 +504,44 @@ def cross_over(first_parent_W,
         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.
+            - '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.
+
     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.
-        - 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
+        )
         ```
     """
    
@@ -488,7 +563,7 @@ def cross_over(first_parent_W,
 
       undominant_parent_W = np.copy(second_parent_W)
       undominant_parent_act = second_parent_act
-      succes = abs(second_parent_fitness)
+      succes = second_parent_fitness
 
    elif decision == 'second_parent':
       dominant_parent_W = np.copy(second_parent_W)
@@ -496,7 +571,7 @@ def cross_over(first_parent_W,
 
       undominant_parent_W = np.copy(first_parent_W)
       undominant_parent_act = first_parent_act
-      succes = abs(first_parent_fitness)
+      succes = first_parent_fitness
 
    while True:
 
@@ -511,11 +586,14 @@ def cross_over(first_parent_W,
          (((row_cut_end + 1) - (row_cut_start + 1) * 2) + ((col_cut_end + 1) - (col_cut_start + 1) * 2) <= half_of_gene)):
          break
       
-      row_cut_start = math.floor(row_cut_start * succes)
-      row_cut_end = math.ceil(row_cut_end * succes)
+      selection_bias = random.uniform(0, 1)
+
+      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)
+         col_cut_start = math.floor(col_cut_start * succes)
+         col_cut_end = math.ceil(col_cut_end * succes)
 
    child_W = dominant_parent_W
 
@@ -575,7 +653,15 @@ def cross_over(first_parent_W,
 
    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, dtype=np.float32):
+def mutation(weight, 
+             activations, 
+             activation_mutate_prob, 
+             activation_add_prob, 
+             activation_delete_prob, 
+             activation_change_prob, 
+             weight_mutate_prob, 
+             threshold, 
+             genome_fitness):
    """
     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.
@@ -590,8 +676,7 @@ def mutation(weight, activations, activation_mutate_prob, activation_add_prob, a
         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
     Returns:
         tuple: A tuple containing:
             - mutated_weight (numpy.ndarray): The weight matrix after mutation.
@@ -609,8 +694,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)
@@ -620,6 +704,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
       new_threshold = threshold
       
       while True:
@@ -658,13 +744,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
@@ -673,24 +753,10 @@ 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:
@@ -700,36 +766,22 @@ 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]):
-
-            wc[i,:] = apply_activation(wc[i,:], activations[random_index_genom_act])
-            weight[i,:] -= wc[i,:]
-
-         weight = normalization(weight, dtype=dtype)
-
-         for i in range(weight.shape[0]):
-
-            weight[i,:] = apply_activation(weight[i,:], activations[random_index_genom_act])
-
-         weight = normalization(weight, dtype=dtype)
-
    return weight, activations
 
-def second_parent_selection(best_weights, bad_weights, best_activations, bad_activations, bad_genomes_selection_prob):
+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(best_weights) - 1))
+   random_index = int(random.uniform(0, len(good_weights) - 1))
 
    if selection_prob > bad_genomes_selection_prob:
-      second_selected_W = best_weights[random_index]
-      second_selected_act = best_activations[random_index]
+      second_selected_W = good_weights[random_index]
+      second_selected_act = good_activations[random_index]
 
    else:
       second_selected_W = bad_weights[random_index]
       second_selected_act = bad_activations[random_index]
 
-      return second_selected_W, second_selected_act, random_index
+   return second_selected_W, second_selected_act, random_index
       
 def dominant_parent_selection(bad_genomes_selection_prob):