pyerualjetwork 4.1.9b2__py3-none-any.whl → 4.2.0b0__py3-none-any.whl

pyerualjetwork/__init__.py

@@ -48,7 +48,7 @@ for package_name in package_names:
 
 print(f"PyerualJetwork is ready to use with {err} errors")
 
-__version__ = "4.1.9b2"
+__version__ = "4.2.0b0"
 __update__ = "* Changes: https://github.com/HCB06/PyerualJetwork/blob/main/CHANGES\n* PyerualJetwork document: https://github.com/HCB06/PyerualJetwork/blob/main/Welcome_to_PyerualJetwork/PYERUALJETWORK_USER_MANUEL_AND_LEGAL_INFORMATION(EN).pdf\n* YouTube tutorials: https://www.youtube.com/@HasanCanBeydili"
 
 def print_version(__version__):

pyerualjetwork/data_operations.py

@@ -11,7 +11,7 @@ def encode_one_hot(y_train, y_test=None, summary=False):
     Args:
         y_train (numpy.ndarray): Train label data.
         y_test (numpy.ndarray): Test label data one-hot encoded. (optional).
-        summary (bool): If True, prints the class-to-index mapping. Default: False
+        summary (bool, optional): If True, prints the class-to-index mapping. Default: False
     
     Returns:
         tuple: One-hot encoded y_train and (if given) y_test.

pyerualjetwork/plan.py

@@ -177,7 +177,7 @@ def learner(x_train, y_train, optimizer, x_test=None, y_test=None, strategy='acc
            neural_web_history=False, show_current_activations=False, auto_normalization=True,
            neurons_history=False, early_stop=False, loss='categorical_crossentropy', show_history=False,
            interval=33.33, target_acc=None, target_loss=None, except_this=None,
-           only_this=None, start_this_act=None, start_this_W=None, target_fitness='max', pop_size=None, dtype=np.float32):
+           only_this=None, start_this_act=None, start_this_W=None, target_fitness='max', dtype=np.float32):
     """
     Optimizes the activation functions for a neural network by leveraging train data to find 
     the most accurate combination of activation potentiation for the given dataset using genetic algorithm NEAT (Neuroevolution of Augmenting Topologies). But modifided for PLAN version. Created by me: PLANEAT. 
@@ -282,15 +282,6 @@ def learner(x_train, y_train, optimizer, x_test=None, y_test=None, strategy='acc
     if gen is None:
         gen = len(activation_potentiation)
 
-    default_act_list_length = len(activation_potentiation)
-
-    if pop_size is not None and pop_size > len(activation_potentiation):
-        for i in range(pop_size - default_act_list_length):
-            rand_index = random.randint(0, default_act_list_length-1)
-            activation_potentiation.append(all_activations()[rand_index])
-
-    elif pop_size is not None and pop_size < len(activation_potentiation): raise ValueError(f"'pop_size' must be greater then activation_potentiation list length. But your act pot list length: {len(activation_potentiation)}")
-
     if strategy != 'accuracy' and strategy != 'f1' and strategy != 'recall' and strategy != 'precision': raise ValueError("Strategy parameter only be 'accuracy' or 'f1' or 'recall' or 'precision'.")
 
     if start_this_act is None and len(activation_potentiation) % 2 != 0: raise ValueError("Activation length must be even number. Please use 'except_this' parameter and except some activation. For example: except_this=['linear']")

pyerualjetwork/planeat.py

@@ -12,7 +12,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,7 +69,7 @@ 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, 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):
    """
 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.
@@ -109,7 +109,7 @@ Args:
     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. 
+    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.
@@ -156,7 +156,7 @@ 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 `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:
@@ -176,7 +176,7 @@ Notes:
         
     - **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.
+        - `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.
@@ -194,16 +194,16 @@ Example:
 ### ERROR AND CONFIGURATION CHECKS:
 
    if policy == 'normal_selective':
-      if bad_genoms_mutation_prob == None:
-         bad_genoms_mutation_prob = 0.7
+      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
       
    elif policy == 'more_selective':
-      if bad_genoms_mutation_prob == None:
-         bad_genoms_mutation_prob = 0.85
+      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 policy == 'less_selective':
-      if bad_genoms_mutation_prob == None:
-         bad_genoms_mutation_prob = 0.6
+      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
 
    else:
       raise ValueError("policy parameter must be: 'normal_selective' or 'more_selective' or 'less_selective'")
@@ -212,12 +212,9 @@ Example:
    if (activation_add_prob < 0 or activation_add_prob > 1) or (activation_change_prob < 0 or activation_change_prob > 1) or (activation_delete_prob < 0 or activation_delete_prob > 1) or (weight_mutate_prob < 0 or weight_mutate_prob > 1) or (activation_selection_add_prob < 0 or activation_selection_add_prob > 1) or (activation_selection_change_prob < 0 or activation_selection_change_prob > 1):
       raise ValueError("All hyperparameters ending with 'prob' must be a number between 0 and 1.")
 
-   if cross_over_mode != 'tpm' and cross_over_mode != 'plantic':
-      raise ValueError("cross_over_mode parameter must be 'tpm' or 'plantic'")
-
-   if 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 +239,86 @@ 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_weights = 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 = normalization(fitness, dtype=dtype)
+
+   best_fitness = normalized_fitness[-1]
 
    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':
-            
+      if policy == 'normal_selective' or policy == 'less_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)
+            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]
+                                                            )
                
-            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)
+            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 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_weights)) 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_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 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)
+         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, 
+                                                            weight_mutate_prob=weight_mutate_prob, 
+                                                            threshold=weight_mutate_rate, 
+                                                            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))
-            
-            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 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
    
@@ -340,8 +333,8 @@ Example:
 
       print("  POLICY: ", policy)
       print("  MUTATIONS: ", str(mutations))
-      print("  BAD GENOMES MUTATION PROB: ", str(bad_genoms_mutation_prob))
-      print("  GOOD GENOMES MUTATION PROB: ", str(round(1 - bad_genoms_mutation_prob, 2)))
+      print("  BAD GENOMES MUTATION PROB: ", str(bad_genomes_mutation_prob))
+      print("  GOOD GENOMES MUTATION PROB: ", str(round(1 - bad_genomes_mutation_prob, 2)))
       print("  WEIGHT MUTATE PROB: ", str(weight_mutate_prob))
       print("  WEIGHT MUTATE RATE (THRESHOLD VALUE FOR SINGLE MUTATION): ", str(weight_mutate_rate))
       print("  ACTIVATION MUTATE PROB: ", str(activation_mutate_prob))
@@ -435,23 +428,30 @@ 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):
    """
     Performs a selected 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'.
-
     Returns:
         tuple: A tuple containing:
             - new_weight (numpy.ndarray): The weight matrix of the new individual created by crossover.
@@ -460,7 +460,6 @@ def cross_over(best_weight, good_weight, best_activations, good_activations, cro
     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.
@@ -475,8 +474,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 = abs(second_parent_fitness)
+
+   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 = abs(first_parent_fitness)
 
    while True:
 
@@ -486,48 +506,44 @@ 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
+      
+      row_cut_start = math.floor(row_cut_start * succes)
+      row_cut_end = math.ceil(row_cut_end * succes)
 
-   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,:]
-
+      col_cut_start = math.floor(col_cut_start * succes)
+      col_cut_end = math.ceil(col_cut_end * succes)
 
-   if isinstance(best_activations, str):
-      best = [best_activations]
+   child_W = dominant_parent_W
 
-   if isinstance(good_activations, str):
-      good = [good_activations]
+   if cross_over_mode == 'tpm':
+      child_W[row_cut_start:row_cut_end, col_cut_start:col_cut_end] = undominant_parent_W[row_cut_start:row_cut_end, col_cut_start:col_cut_end]
 
-   if isinstance(best_activations, list):
-      best = best_activations
 
-   if isinstance(good_activations, list):
-      good = good_activations
+   if isinstance(dominant_parent_act, str): dominant_parent_act = [dominant_parent_act]
+   if isinstance(undominant_parent_act, str): undominant_parent_act = [undominant_parent_act]
 
-   new_activations = list(np.copy(best))
+   child_act = list(np.copy(dominant_parent_act))
 
    activation_selection_add_prob = 1 - activation_selection_add_prob # if prob 0.8 (%80) then 1 - 0.8. Because 0-1 random number probably greater than 0.2
    potential_activation_selection_add = random.uniform(0, 1)
 
    if potential_activation_selection_add > activation_selection_add_prob:
       
+      activation_selection_rate = activation_selection_rate / succes
       new_threshold = activation_selection_rate
       
       while True:
          
-         random_index_good = int(random.uniform(0, len(good)-1))
-         random_good_activation = good[random_index_good]
+         random_index = int(random.uniform(0, len(undominant_parent_act)-1))
+         random_undominant_activation = undominant_parent_act[random_index]
 
-         new_activations.append(random_good_activation)
+         child_act.append(random_undominant_activation)
 
-         if len(best) > new_threshold:
+         if len(dominant_parent_act) > new_threshold:
             new_threshold += activation_selection_rate
             pass
          
@@ -538,67 +554,26 @@ 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
+   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):
    """
@@ -659,8 +634,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)
@@ -718,7 +692,7 @@ def mutation(weight, activations, activation_mutate_prob, activation_add_prob, a
          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))
@@ -740,4 +714,28 @@ def mutation(weight, activations, activation_mutate_prob, activation_add_prob, a
 
          weight = normalization(weight, dtype=dtype)
 
-   return weight, activations
+   return weight, activations
+
+def second_parent_selection(best_weights, bad_weights, best_activations, bad_activations, bad_genomes_selection_prob):
+   
+   selection_prob = random.uniform(0, 1)
+   random_index = int(random.uniform(0, len(best_weights) - 1))
+
+   if selection_prob > bad_genomes_selection_prob:
+      second_selected_W = best_weights[random_index]
+      second_selected_act = best_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
+      
+def dominant_parent_selection(bad_genomes_selection_prob):
+
+   selection_prob = random.uniform(0, 1)
+
+   if selection_prob > bad_genomes_selection_prob: decision = 'first_parent'
+   else: decision = 'second_parent'
+
+   return decision

pyerualjetwork/planeat_cuda.py

@@ -255,7 +255,7 @@ 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, ascii="▱▰")
+   if bar_status: progress = initialize_loading_bar(len(bad_weights), desc="GENERATION: " + str(what_gen), bar_format=bar_format, ncols=50)
 
    for i in range(len(bad_weights)):
 

{pyerualjetwork-4.1.9b2.dist-info → pyerualjetwork-4.2.0b0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyerualjetwork
-Version: 4.1.9b2
+Version: 4.2.0b0
 Summary: PyerualJetwork is a machine learning library written in Python for professionals, incorporating advanced, unique, new, and modern techniques.
 Author: Hasan Can Beydili
 Author-email: tchasancan@gmail.com

{pyerualjetwork-4.1.9b2.dist-info → pyerualjetwork-4.2.0b0.dist-info}/RECORD

@@ -1,7 +1,7 @@
-pyerualjetwork/__init__.py,sha256=4B7YdD5mpsSYBiWU4ONIe4ZLxdJmQ9YX2dq4VlCNrNQ,2177
+pyerualjetwork/__init__.py,sha256=Zu-KnB701xy5cpP7oARUTk8PhAwyDNzWRNcpeZSqno4,2177
 pyerualjetwork/activation_functions.py,sha256=WWOdMd5pI6ZKe-ieKCIsKAYPQODHuXYxx7tzhA5xjes,11767
 pyerualjetwork/activation_functions_cuda.py,sha256=KmXJ5Cdig46XAMYakXFPEOlxSxtFJjD21-i3nGtxPjE,11807
-pyerualjetwork/data_operations.py,sha256=ZM24BuPsIAtI0a_Exr4HgCjmlb285wEeO8juFY9sJr0,14680
+pyerualjetwork/data_operations.py,sha256=HjyW2QE18age6J8iG0jpbwqGOylL_nM-vE2CLbP9Wes,14690
 pyerualjetwork/data_operations_cuda.py,sha256=UpoJoFhIwTU4xg9dVuLAxLAT4CkRaGsxvtJG9j1xrNo,17629
 pyerualjetwork/help.py,sha256=OZghUy7GZTgEX_i3NYtgcpzUgCDOi6r2vVUF1ROkFiI,774
 pyerualjetwork/loss_functions.py,sha256=6PyBI232SQRGuFnG3LDGvnv_PUdWzT2_2mUODJiejGI,618
@@ -11,14 +11,14 @@ pyerualjetwork/metrics.py,sha256=q7MkhnZDRbCjFBDDfUgrl8lBYnUT_1ro1LxeBq105pI,607
 pyerualjetwork/metrics_cuda.py,sha256=73h9GC7XwmnFCVzFEEiPQfF8CwHIz2wsCbxpZrJtYgw,5061
 pyerualjetwork/model_operations.py,sha256=hnhR8dtoICNJWIwGgJ65-LN3GYN_DYH4LMe6YpZVbnI,12967
 pyerualjetwork/model_operations_cuda.py,sha256=XnKKq54ZLaqCm-NaJ6d8IToACKcKg2Ttq6moowVRRWo,13365
-pyerualjetwork/plan.py,sha256=cx4cqmW6P2WiYvcI02cL4qFyy4UieXlsiucsnMSM41k,34924
+pyerualjetwork/plan.py,sha256=QwF7kAzEGSTbYaBHHjaPcqYsMfb2I9FGDykSouBhxmk,34335
 pyerualjetwork/plan_cuda.py,sha256=KoKjsoWTLM-q07G1Gy0-LYXGlp15Fno6JqHz-Jzi_yE,35983
-pyerualjetwork/planeat.py,sha256=VtWtWndbKoFNYTWd1EsyKBV4Vp5U6cc7uWDgQ4WjHqo,40248
-pyerualjetwork/planeat_cuda.py,sha256=fSn28ZbxctPvBjpKgtv_uGwwUdTEXkBizy76mMlZYJ0,40237
+pyerualjetwork/planeat.py,sha256=AkiZSK3fxsNBZircylV8JNmA5987qyiinjRcuLZyXL0,39166
+pyerualjetwork/planeat_cuda.py,sha256=mxh5DzJvSwNJ_nc4b_SNMDDIoyBistjK5IjjpOJR3hM,40221
 pyerualjetwork/ui.py,sha256=wu2BhU1k-w3Kcho5Jtq4SEKe68ftaUeRGneUOSCVDjU,575
 pyerualjetwork/visualizations.py,sha256=QaYSIyVkJZ8NqpBKArQKkI1y37nCQo_KIM98IMssnRc,28766
 pyerualjetwork/visualizations_cuda.py,sha256=F60vQ92AXlMgBka3InXnOtGoM25vQJAlBIU2AlYTwks,29200
-pyerualjetwork-4.1.9b2.dist-info/METADATA,sha256=-fJ8qkuP47X2VtOJwExKcPqLoDj3b1USKn9hbUQ_VpY,7795
-pyerualjetwork-4.1.9b2.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
-pyerualjetwork-4.1.9b2.dist-info/top_level.txt,sha256=BRyt62U_r3ZmJpj-wXNOoA345Bzamrj6RbaWsyW4tRg,15
-pyerualjetwork-4.1.9b2.dist-info/RECORD,,
+pyerualjetwork-4.2.0b0.dist-info/METADATA,sha256=aC9Bzvxyc8bhOawSkrf2Y9eBJHLf2VgnwiuTOCROwZE,7795
+pyerualjetwork-4.2.0b0.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
+pyerualjetwork-4.2.0b0.dist-info/top_level.txt,sha256=BRyt62U_r3ZmJpj-wXNOoA345Bzamrj6RbaWsyW4tRg,15
+pyerualjetwork-4.2.0b0.dist-info/RECORD,,