pyerualjetwork 3.3.4__py3-none-any.whl → 4.1.9__py3-none-any.whl

pyerualjetwork/planeat.py

@@ -17,10 +17,10 @@ from tqdm import tqdm
 ### LIBRARY IMPORTS ###
 from .plan import feed_forward
 from .data_operations import normalization
-from .ui import loading_bars
+from .ui import loading_bars, initialize_loading_bar
 from .activation_functions import apply_activation, all_activations
 
-def define_genomes(input_shape, output_shape, population_size):
+def define_genomes(input_shape, output_shape, population_size, dtype=np.float32):
    """
    Initializes a population of genomes, where each genome is represented by a set of weights 
    and an associated activation function. Each genome is created with random weights and activation 
@@ -34,6 +34,8 @@ def define_genomes(input_shape, output_shape, population_size):
       
       population_size (int): The number of genomes (individuals) in the population.
 
+      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:
          - population_weights (numpy.ndarray): A 2D numpy array of shape (population_size, output_shape, input_shape) representing the 
@@ -54,7 +56,7 @@ def define_genomes(input_shape, output_shape, population_size):
 
    for i in range(len(population_weights)):
 
-      population_weights[i] = np.random.uniform(-1, 1, (output_shape, input_shape))
+      population_weights[i] = np.random.uniform(-1, 1, (output_shape, input_shape)).astype(dtype)
       population_activations[i] = activations[int(random.uniform(0, len(activations)-1))]
 
       # ACTIVATIONS APPLYING IN WEIGHTS SPECIFIC OUTPUT CONNECTIONS (MORE PLAN LIKE FEATURES(FOR NON-LINEARITY)):
@@ -62,12 +64,12 @@ def define_genomes(input_shape, output_shape, population_size):
       for j in range(population_weights[i].shape[0]):
 
          population_weights[i][j,:] = apply_activation(population_weights[i][j,:], population_activations[i])
-         population_weights[i][j,:] = normalization(population_weights[i][j,:])
+         population_weights[i][j,:] = normalization(population_weights[i][j,:], dtype=dtype)
 
-   return np.array(population_weights), population_activations
+   return np.array(population_weights, dtype=dtype), population_activations
 
 
-def evolve(weights, activation_potentiations, what_gen, y_reward, show_info=False, strategy='cross_over', policy='normal_selective', 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.5, activation_selection_change_prob=0.5, activation_selection_rate=2):
+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):
    """
 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.
@@ -81,8 +83,8 @@ Args:
     
     what_gen (int): The current generation number, used for informational purposes or logging.
     
-    y_reward (numpy.ndarray): A 1D array containing the fitness or reward values of each genome. 
-        The array is used to rank the genomes based on their performance. PLANEAT maximizes the reward.
+    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.
@@ -94,12 +96,16 @@ Args:
           (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
+
     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.
     
@@ -137,13 +143,15 @@ Args:
         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 cross over.
-        from the genome. Must be in the range [0, 1]. Default is 0.5.
+        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').
@@ -159,7 +167,7 @@ Returns:
 
 Notes:
     - **Selection Process**: 
-        - The genomes are sorted by their fitness (based on `y_reward`), and then split into "best" and "bad" halves. 
+        - 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**:
@@ -171,13 +179,13 @@ Notes:
         - `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 `y_reward` has an odd length, an error is raised.
+    - **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 = learner(weights, activation_potentiations, 1, y_reward, info=True, strategy='cross_over', policy='normal_selective')
+    weights, activation_potentiations = planeat.evolve(weights, activation_potentiations, 1, fitness, show_info=True, strategy='cross_over', policy='normal_selective')
     ```
 
     - The function returns the updated weights and activations after processing based on the chosen strategy, policy, and mutation parameters.
@@ -215,17 +223,19 @@ Example:
       if not isinstance(activation_mutate_prob, float) or activation_mutate_prob < 0 or activation_mutate_prob > 1:
          raise ValueError("activation_mutate_prob parameter must be float and 0-1 range")
       
-   if len(y_reward) % 2 == 0:
-      slice_center = int(len(y_reward) / 2)
+   if len(fitness) % 2 == 0:
+      slice_center = int(len(fitness) / 2)
 
    else:
-      raise ValueError("genom population size must be even number. for example: not 99, make 100 or 98.")
+      raise ValueError("genome population size must be even number. for example: not 99, make 100 or 98.")
 
-   sort_indices = np.argsort(y_reward)
+   
+### FITNESS IS SORTED IN ASCENDING (OR DESCENDING) ORDER, AND THE WEIGHT AND ACTIVATIONS OF EACH GENOME ARE SORTED ACCORDING TO THIS ORDER:
 
-### REWARD LIST IS SORTED IN ASCENDING ORDER, AND THE WEIGHT AND ACTIVATIONS OF EACH GENOME ARE SORTED ACCORDING TO THIS ORDER:
+   if target_fitness == 'max': sort_indices = np.argsort(fitness)
+   elif target_fitness == 'min': sort_indices = np.argsort(-fitness)
 
-   y_reward = y_reward[sort_indices]
+   fitness = fitness[sort_indices]
    weights = weights[sort_indices]
 
    activation_potentiations = [activation_potentiations[i] for i in sort_indices]
@@ -245,7 +255,9 @@ Example:
    
    bar_format = loading_bars()[0]
    
-   for i in tqdm(range(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)):
 
       if policy == 'normal_selective':
             
@@ -254,7 +266,7 @@ Example:
 
 
          elif strategy == 'potentiate':
-            bad_weights[i], bad_activations[i] = potentiate(best_weight, best_weights[i], best_activations=best_activation, good_activations=best_activations[i])
+            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:
@@ -263,10 +275,10 @@ Example:
 
             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)
+                  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)
+               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':
                
@@ -274,7 +286,7 @@ Example:
                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])
+               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:
 
@@ -282,10 +294,10 @@ Example:
 
                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)
+                     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)
+                  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)
 
 
 
@@ -305,11 +317,12 @@ Example:
 
                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)
+                     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)
-
+                  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
@@ -340,18 +353,18 @@ Example:
       print("  ACTIVATION SELECTION RATE (THRESHOLD VALUE FOR SINGLE CROSS OVER):", str(activation_selection_rate) + '\n')
 
       print("*** Performance ***")
-      print("  MAX REWARD: ", str(round(max(y_reward), 2)))
-      print("  MEAN REWARD: ", str(round(np.mean(y_reward), 2)))
-      print("  MIN REWARD: ", str(round(min(y_reward), 2)) + '\n')
+      print("  MAX FITNESS: ", str(round(max(fitness), 2)))
+      print("  MEAN FITNESS: ", str(round(np.mean(fitness), 2)))
+      print("  MIN FITNESS: ", str(round(min(fitness), 2)) + '\n')
 
       print("  BEST GENOME INDEX: ", str(len(weights)-1))
       print("  NOTE: Genomes are always sorted from the least successful to the most successful according to their performance ranking. Therefore, the genome at the last index is the king of the previous generation. " + '\n')
       
 
-   return np.array(weights), activation_potentiations
+   return weights, activation_potentiations
 
 
-def evaluate(x_population, weights, activation_potentiations, rl_mode=False):
+def evaluate(x_population, weights, activation_potentiations, rl_mode=False, dtype=np.float32):
    """
     Evaluates the performance of a population of genomes, applying different activation functions 
     and weights depending on whether reinforcement learning mode is enabled or not.
@@ -367,6 +380,8 @@ def evaluate(x_population, weights, activation_potentiations, rl_mode=False):
         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.)
                                   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)                         
+         
     Returns:
         list: A list of outputs corresponding to each genome in the population after applying the respective 
               activation function and weights.
@@ -397,7 +412,7 @@ def evaluate(x_population, weights, activation_potentiations, rl_mode=False):
    ### THE OUTPUTS ARE RETURNED AS A PYTHON LIST, WHERE EACH GENOME'S OUTPUT MATCHES ITS INDEX:
    
    if rl_mode == True:
-      Input = np.array(x_population)
+      Input = np.array(x_population, copy=False, dtype=dtype)
       Input = Input.ravel()
       
       if isinstance(activation_potentiations, str):
@@ -409,7 +424,7 @@ def evaluate(x_population, weights, activation_potentiations, rl_mode=False):
       outputs = [0] * len(x_population)
       for i, genome in enumerate(x_population):
 
-         Input = np.array(genome)
+         Input = np.array(genome, copy=False)
          Input = Input.ravel()
 
          if isinstance(activation_potentiations[i], str):
@@ -543,7 +558,7 @@ def cross_over(best_weight, good_weight, best_activations, good_activations, cro
 
    return new_weight, new_activations
 
-def potentiate(best_weight, good_weight, best_activations, good_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.)
@@ -553,6 +568,7 @@ def potentiate(best_weight, good_weight, best_activations, good_activations):
         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:
@@ -566,7 +582,7 @@ def potentiate(best_weight, good_weight, best_activations, good_activations):
    """
     
    new_weight = best_weight + good_weight
-   new_weight = normalization(new_weight)
+   new_weight = normalization(new_weight, dtype=dtype)
    
    if isinstance(best_activations, str):
       best = [best_activations]
@@ -584,7 +600,7 @@ def potentiate(best_weight, good_weight, best_activations, good_activations):
    
    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):
+def mutation(weight, activations, activation_mutate_prob, activation_add_prob, activation_delete_prob, activation_change_prob, weight_mutate_prob, threshold, dtype=np.float32):
    """
     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.
@@ -599,6 +615,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)
 
     Returns:
         tuple: A tuple containing:
@@ -672,7 +689,7 @@ def mutation(weight, activations, activation_mutate_prob, activation_add_prob, a
 
                weight[i,:] = apply_activation(weight[i,:], activations[-1])
 
-            weight = normalization(weight)
+            weight = normalization(weight, dtype=dtype)
             
          except:
 
@@ -686,7 +703,7 @@ def mutation(weight, activations, activation_mutate_prob, activation_add_prob, a
 
                weight[i,:] = apply_activation(weight[i,:], activations[-1])
 
-            weight = normalization(weight)
+            weight = normalization(weight, dtype=dtype)
             
       if potential_activation_delete_prob > activation_delete_prob and len(activations) > 1:
          
@@ -699,7 +716,7 @@ def mutation(weight, activations, activation_mutate_prob, activation_add_prob, a
             weight[i,:] -= wc[i,:]
 
          activations.pop(random_index)
-         weight = normalization(weight)
+         weight = normalization(weight, dtype=dtype)
          
             
       if potential_activation_change_prob > activation_change_prob:
@@ -715,12 +732,12 @@ def mutation(weight, activations, activation_mutate_prob, activation_add_prob, a
             wc[i,:] = apply_activation(wc[i,:], activations[random_index_genom_act])
             weight[i,:] -= wc[i,:]
 
-         weight = normalization(weight)
+         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)
+         weight = normalization(weight, dtype=dtype)
 
    return weight, activations