pyerualjetwork 4.5.2b0__py3-none-any.whl → 4.6__py3-none-any.whl

pyerualjetwork/planeat.py

@@ -17,11 +17,11 @@ import random
 import math
 
 ### LIBRARY IMPORTS ###
-from .data_operations import normalization, non_neg_normalization
+from .data_operations import normalization, non_neg_normalization, split_nested_arrays, reconstruct_nested_arrays
 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, dtype=np.float32):
+def define_genomes(input_shape, output_shape, population_size, hidden=0, neurons=None, activation_functions=None, 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 
@@ -35,6 +35,12 @@ def define_genomes(input_shape, output_shape, population_size, dtype=np.float32)
       
       population_size (int): The number of genomes (individuals) in the population.
 
+      hidden (int, optional): If you dont want train PLAN model this parameter represents a hidden layer count for MLP model. Default: 0 (PLAN)
+
+      neurons (list[int], optional): If you dont want train PLAN model this parameter represents neuron count of each hidden layer for MLP. Default: None (PLAN)
+
+      activation_functions (list[str], optional): If you dont want train PLAN model this parameter represents activation function of each hidden layer for MLP. Default: None (PLAN) NOTE: THIS EFFECTS HIDDEN LAYERS OUTPUT. NOT OUTPUT LAYER!
+
       dtype (numpy.dtype): Data type for the arrays. np.float32 by default. Example: np.float64 or np.float16.
 
    Returns:
@@ -42,36 +48,70 @@ def define_genomes(input_shape, output_shape, population_size, dtype=np.float32)
          - population_weights (numpy.ndarray): A 2D numpy array of shape (population_size, output_shape, input_shape) representing the 
             weight matrices for each genome.
          - population_activations (list): A list of activation functions applied to each genome.
-            
+   
    Notes:
       The weights are initialized randomly within the range [-1, 1]. 
       Activation functions are selected randomly from a predefined list `all_activations()`.
       The weights for each genome are then modified by applying the corresponding activation function 
       and normalized using the `normalization()` function. (Max abs normalization.)
    """
-   population_weights = [0] * population_size
-   population_activations = [0] * population_size
+   if hidden > 0:
+      population_weights = [[0] * (hidden + 1) for _ in range(population_size)]
+      population_activations = [[0] * (hidden) for _ in range(population_size)]
+   
+      if len(neurons) != hidden:
+         raise ValueError('hidden parameter and neurons list length must be equal.')
+   
+
+      for i in range(len(population_weights)):
+
+         for l in range(hidden + 1):
+            
+            if l == 0:
+               population_weights[i][l] = np.random.uniform(-1, 1, (neurons[l], input_shape)).astype(dtype)
+
+            elif l == hidden:
+               population_weights[i][l] = np.random.uniform(-1, 1, (output_shape, neurons[l-1])).astype(dtype)
+            
+            else:
+               population_weights[i][l] = np.random.uniform(-1, 1, (neurons[l], neurons[l-1])).astype(dtype)
+            
+            if l != hidden:
+               population_activations[i][l] = activation_functions[l]
+
+            # ACTIVATIONS APPLYING IN WEIGHTS SPECIFIC OUTPUT CONNECTIONS (MORE PLAN LIKE FEATURES(FOR NON-LINEARITY)):
+
+            for j in range(population_weights[i][l].shape[0]):
+
+               population_weights[i][l][j,:] = apply_activation(population_weights[i][l][j,:], population_activations[i])
+               population_weights[i][l][j,:] = normalization(population_weights[i][l][j,:], dtype=dtype)
+
+      return population_weights, population_activations
+   
+   else:
+      population_weights = [0] * population_size
+      population_activations = [0] * population_size
 
-   except_this = ['spiral', 'circular']
-   activations = [item for item in all_activations() if item not in except_this] # SPIRAL AND CIRCULAR ACTIVATION DISCARDED
+      except_this = ['spiral', 'circular']
+      activations = [item for item in all_activations() if item not in except_this] # SPIRAL AND CIRCULAR ACTIVATION DISCARDED
 
-   for i in range(len(population_weights)):
+      for i in range(len(population_weights)):
 
-      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))]
+         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)):
+         # ACTIVATIONS APPLYING IN WEIGHTS SPECIFIC OUTPUT CONNECTIONS (MORE PLAN LIKE FEATURES(FOR NON-LINEARITY)):
 
-      for j in range(population_weights[i].shape[0]):
+         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,:], dtype=dtype)
+            population_weights[i][j,:] = apply_activation(population_weights[i][j,:], population_activations[i])
+            population_weights[i][j,:] = normalization(population_weights[i][j,:], dtype=dtype)
 
-   return np.array(population_weights, dtype=dtype), population_activations
+      return np.array(population_weights, dtype=dtype), population_activations
 
 
 def evolver(weights, 
-            activation_potentiations, 
+            activation_potentiations,
             what_gen, 
             fitness,
             weight_evolve=True,
@@ -88,11 +128,12 @@ def evolver(weights,
             activation_mutate_change_prob=0.5,  
             activation_selection_add_prob=0.5,
             activation_selection_change_prob=0.5, 
-            activation_selection_threshold=2,
+            activation_selection_threshold=20,
             activation_mutate_prob=1,
-            activation_mutate_threshold=2,
+            activation_mutate_threshold=20,
             weight_mutate_threshold=16,
             weight_mutate_prob=1,
+            is_mlp=False,
             dtype=np.float32):
    """
    Applies the evolving process of a population of genomes using selection, crossover, mutation, and activation function potentiation.
@@ -105,8 +146,8 @@ def evolver(weights,
       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)
+      activation_potentiations (list[str]): A list of activation functions for each genome. 
+         (second returned value of define_genomes function) NOTE!: 'activation potentiations' for PLAN 'activation functions' for MLP.
       
       what_gen (int): The current generation number, used for informational purposes or logging.
       
@@ -175,10 +216,12 @@ def evolver(weights,
       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.5.
       
-      activation_mutate_threshold (int, optional): Determines max how much activation mutaiton operation applying. (Function automaticly determines to min) Default: 2
+      activation_mutate_threshold (int, optional): Determines max how much activation mutaiton operation applying. (Function automaticly determines to min) Default: 20
       
-      activation_selection_threshold (int, optional): Determines max how much activaton transferable to child from undominant parent. (Function automaticly determines to min) Default: 2
+      activation_selection_threshold (int, optional): Determines max how much activaton transferable to child from undominant parent. (Function automaticly determines to min) Default: 20
 
+      is_mlp (bool, optional): Evolve PLAN model or MLP model ? Default: False (PLAN)
+      
       dtype (numpy.dtype, optional): 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!].
 
@@ -266,6 +309,34 @@ def evolver(weights,
 
    if weight_evolve is False: origin_weights = np.copy(weights)
 
+   if is_mlp: ### IF EACH GENOME HAVE MORE THEN 1 WEIGHT MATRIX IT IS NOT PLAN MODEL. IT IS MLP MODEL.
+
+      activations = activation_potentiations.copy()
+
+      return mlp_evolver(weights,
+               activations,
+               what_gen,
+               dtype,
+               fitness,
+               policy, 
+               bad_genomes_selection_prob, 
+               bar_status, 
+               strategy,
+               bad_genomes_mutation_prob,
+               fitness_bias, 
+               cross_over_mode,
+               activation_mutate_change_prob,  
+               activation_selection_change_prob, 
+               activation_selection_threshold,
+               activation_mutate_prob,
+               activation_mutate_threshold,
+               weight_mutate_threshold,
+               show_info,
+               weight_mutate_prob,
+            )
+   
+   if isinstance(weights, list): weights = np.array(weights, dtype=dtype)
+
 ### FITNESS IS SORTED IN ASCENDING ORDER, AND THE WEIGHT AND ACTIVATIONS OF EACH GENOME ARE SORTED ACCORDING TO THIS ORDER:
 
    sort_indices = np.argsort(fitness)
@@ -408,44 +479,114 @@ def evolver(weights,
    return weights, activation_potentiations
 
 
-def evaluate(x_population, weights, activation_potentiations):
+def evaluate(Input, weights, activation_potentiations, is_mlp=False):
    """
     Evaluates the performance of a population of genomes, applying different activation functions 
     and weights depending on whether reinforcement learning mode is enabled or not.
 
     Args:
-        x_population (list or numpy.ndarray): A list or 2D numpy array where each element represents
-                                               a genome (A list of input features for each genome, or a single set of input features for one genome (only in rl_mode)).
+        Input (list or numpy.ndarray): A list or 2D numpy array where each element represents
+                                               a genome (A list of input features for each genome, or a single set of input features for one genome).
         weights (list or numpy.ndarray): A list or 2D numpy array of weights corresponding to each genome 
                                          in `x_population`. This determines the strength of connections.
         activation_potentiations (list or str): A list where each entry represents an activation function 
                                                 or a potentiation strategy applied to each genome. If only one 
                                                 activation function is used, this can be a single string.
+        is_mlp (bool, optional): Evaluate PLAN model or MLP model ? Default: False (PLAN)
+
     Returns:
         list: A list of outputs corresponding to each genome in the population after applying the respective 
               activation function and weights.
 
     Example:
         ```python
-        outputs = evaluate(x_population, weights, activation_potentiations)
+        outputs = evaluate(Input, weights, activation_potentiations)
         ```
 
     - The function returns a list of outputs after processing the population, where each element corresponds to
-      the output for each genome in `x_population`.
-   """   
+      the output for each genome in population.
+   """
    ### THE OUTPUTS ARE RETURNED, WHERE EACH GENOME'S OUTPUT MATCHES ITS INDEX:
-   
+
 
    if isinstance(activation_potentiations, str):
     activation_potentiations = [activation_potentiations]
    else:
     activation_potentiations = [item if isinstance(item, list) else [item] for item in activation_potentiations]
 
-   x_population = apply_activation(x_population, activation_potentiations)
-   result = x_population @ weights.T
+   if is_mlp:
+      layer = Input
+      for i in range(len(weights)):
+         if i != len(weights) - 1: layer = apply_activation(layer, activation_potentiations[i])
+         layer = layer @ weights[i].T
+      
+      return layer
 
-   return result
+   else:
 
+      Input = apply_activation(Input, activation_potentiations)
+      result = Input @ weights.T
+
+      return result
+
+def mlp_evolver(weights,
+               activations,
+               generation,
+               dtype,
+               fitness,
+               policy, 
+               bad_genomes_selection_prob, 
+               bar_status, 
+               strategy,
+               bad_genomes_mutation_prob,
+               fitness_bias, 
+               cross_over_mode,
+               activation_mutate_change_prob,  
+               activation_selection_change_prob, 
+               activation_selection_threshold,
+               activation_mutate_prob,
+               activation_mutate_threshold,
+               weight_mutate_threshold,
+               show_info,
+               weight_mutate_prob,
+            ):
+   
+   weights = split_nested_arrays(weights)
+
+   for layer in range(len(weights)):
+      if show_info == True:
+         if layer == len(weights) - 1:
+            show = True
+         else:
+            show = False
+      else:
+         show = False
+      
+      weights[layer], activations = evolver(weights[layer], activations,
+                                                   fitness=fitness,
+                                                   what_gen=generation,
+                                                   show_info=show,
+                                                   policy=policy,
+                                                   bad_genomes_selection_prob=bad_genomes_selection_prob, 
+                                                   bar_status=bar_status, 
+                                                   strategy=strategy,
+                                                   bad_genomes_mutation_prob=bad_genomes_mutation_prob,
+                                                   fitness_bias=fitness_bias, 
+                                                   cross_over_mode=cross_over_mode,
+                                                   activation_mutate_add_prob=0, 
+                                                   activation_mutate_delete_prob=0,
+                                                   activation_mutate_change_prob=activation_mutate_change_prob,  
+                                                   activation_selection_add_prob=0,
+                                                   activation_selection_change_prob=activation_selection_change_prob, 
+                                                   activation_selection_threshold=activation_selection_threshold,
+                                                   activation_mutate_prob=activation_mutate_prob,
+                                                   activation_mutate_threshold=activation_mutate_threshold,
+                                                   weight_mutate_threshold=weight_mutate_threshold,
+                                                   weight_mutate_prob=weight_mutate_prob,
+                                                   dtype=dtype
+      )
+
+   return reconstruct_nested_arrays(weights), activations
 
 def cross_over(first_parent_W,
                second_parent_W,
@@ -748,7 +889,7 @@ def mutation(weight,
 
          if potential_activation_delete_prob > activation_delete_prob and len(activations) > 1:
             
-            random_index = random.randint(0, len(activations) - 1)
+            random_index = random.randint(0, len(activations)-1)
             activations.pop(random_index)
 
 
@@ -785,7 +926,7 @@ def mutation(weight,
 def second_parent_selection(good_weights, bad_weights, good_activations, bad_activations, bad_genomes_selection_prob):
    
    selection_prob = random.uniform(0, 1)
-   random_index = int(random.uniform(0, len(good_weights) - 1))
+   random_index = int(random.uniform(0, len(good_weights)-1))
 
    if selection_prob > bad_genomes_selection_prob:
       second_selected_W = good_weights[random_index]