pyerualjetwork 4.5.3__py3-none-any.whl → 4.6b0__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,68 @@ 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)):
 
-   except_this = ['spiral', 'circular']
-   activations = [item for item in all_activations() if item not in except_this] # SPIRAL AND CIRCULAR ACTIVATION DISCARDED
+            for j in range(population_weights[i][l].shape[0]):
 
-   for i in range(len(population_weights)):
+               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)
+
+   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
 
-      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))]
+      for i in range(len(population_weights)):
 
-      # ACTIVATIONS APPLYING IN WEIGHTS SPECIFIC OUTPUT CONNECTIONS (MORE PLAN LIKE FEATURES(FOR NON-LINEARITY)):
+         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))]
 
-      for j in range(population_weights[i].shape[0]):
+         # ACTIVATIONS APPLYING IN WEIGHTS SPECIFIC OUTPUT CONNECTIONS (MORE PLAN LIKE FEATURES(FOR NON-LINEARITY)):
 
-         population_weights[i][j,:] = apply_activation(population_weights[i][j,:], population_activations[i])
-         population_weights[i][j,:] = normalization(population_weights[i][j,:], dtype=dtype)
+         for j in range(population_weights[i].shape[0]):
 
-   return np.array(population_weights, dtype=dtype), population_activations
+            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 population_weights, population_activations
 
 
 def evolver(weights, 
-            activation_potentiations, 
+            activation_potentiations,
             what_gen, 
             fitness,
             weight_evolve=True,
@@ -93,6 +131,7 @@ def evolver(weights,
             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 +144,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.
       
@@ -179,6 +218,8 @@ def evolver(weights,
       
       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 +307,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,7 +477,7 @@ def evolver(weights,
    return weights, activation_potentiations
 
 
-def evaluate(Input, 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.
@@ -421,6 +490,8 @@ def evaluate(Input, weights, activation_potentiations):
         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.
@@ -432,19 +503,88 @@ def 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 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]
 
-   Input = apply_activation(Input, activation_potentiations)
-   result = Input @ 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
+
+   else:
 
-   return result
+      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,
@@ -747,7 +887,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)
 
 
@@ -784,7 +924,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]

pyerualjetwork/planeat_cuda.py

@@ -19,11 +19,11 @@ import math
 
 
 ### LIBRARY IMPORTS ###
-from .data_operations_cuda import normalization, non_neg_normalization
+from .data_operations_cuda import normalization, non_neg_normalization, split_nested_arrays, reconstruct_nested_arrays
 from .ui import loading_bars, initialize_loading_bar
 from .activation_functions_cuda import apply_activation, all_activations
 
-def define_genomes(input_shape, output_shape, population_size, dtype=cp.float32):
+def define_genomes(input_shape, output_shape, population_size, hidden=0, neurons=None, activation_functions=None, dtype=cp.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 
@@ -36,6 +36,12 @@ def define_genomes(input_shape, output_shape, population_size, dtype=cp.float32)
       output_shape (int): The number of output features for the neural network.
       
       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 (cupy.dtype): Data type for the arrays. np.float32 by default. Example: cp.float64 or cp.float16.
 
@@ -51,25 +57,57 @@ def define_genomes(input_shape, output_shape, population_size, dtype=cp.float32)
       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] = cp.random.uniform(-1, 1, (neurons[l], input_shape)).astype(dtype)
+
+            elif l == hidden:
+               population_weights[i][l] = cp.random.uniform(-1, 1, (output_shape, neurons[l-1])).astype(dtype)
+            
+            else:
+               population_weights[i][l] = cp.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)
+
+   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] = cp.random.uniform(-1, 1, (output_shape, input_shape)).astype(dtype, copy=False)
-      population_activations[i] = activations[int(random.uniform(0, len(activations)-1))]
+         population_weights[i] = cp.random.uniform(-1, 1, (output_shape, input_shape)).astype(dtype, copy=False)
+         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 cp.array(population_weights, dtype=dtype), population_activations
+   return population_weights, population_activations
 
 
 def evolver(weights, 
@@ -94,7 +132,8 @@ def evolver(weights,
             activation_mutate_prob=1,
             activation_mutate_threshold=20,
             weight_mutate_threshold=16,
-            weight_mutate_prob=1, 
+            weight_mutate_prob=1,
+            is_mlp=False,
             dtype=cp.float32):
    """
    Applies the evolving process of a population of genomes using selection, crossover, mutation, and activation function potentiation.
@@ -107,8 +146,8 @@ def evolver(weights,
       weights (cupy.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.
       
@@ -181,6 +220,8 @@ def evolver(weights,
       
       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 (cupy.dtype): Data type for the arrays. Default: cp.float32. 
          Example: cp.float64 or cp.float16 [fp32 for balanced devices, fp64 for strong devices, fp16 for weak devices: not recommended!].
 
@@ -267,6 +308,34 @@ def evolver(weights,
 
    if weight_evolve is False: origin_weights = cp.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 = cp.array(weights, dtype=dtype)
+
 ### FITNESS LIST IS SORTED IN ASCENDING ORDER, AND THE WEIGHT AND ACTIVATIONS OF EACH GENOME ARE SORTED ACCORDING TO THIS ORDER:
 
    sort_indices = cp.argsort(fitness)
@@ -408,7 +477,7 @@ def evolver(weights,
    return weights, activation_potentiations
 
 
-def evaluate(Input, 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.
@@ -423,6 +492,8 @@ def evaluate(Input, weights, activation_potentiations):
         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.
@@ -442,11 +513,80 @@ def evaluate(Input, weights, activation_potentiations):
    else:
     activation_potentiations = [item if isinstance(item, list) else [item] for item in activation_potentiations]
 
-   Input = apply_activation(Input, activation_potentiations)
-   result = Input @ 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
+
+   else:
 
-   return result
+      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,
@@ -603,7 +743,7 @@ def cross_over(first_parent_W,
       
       while True:
          
-         random_index = int(random.uniform(0, len(undominant_parent_act)-1))
+         random_index = int(random.uniform(0, len(undominant_parent_act)))
          random_undominant_activation = undominant_parent_act[random_index]
 
          child_act.append(random_undominant_activation)
@@ -625,8 +765,8 @@ def cross_over(first_parent_W,
       
       while True:
          
-         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_index_undominant = int(random.uniform(0, len(undominant_parent_act)))
+         random_index_dominant = int(random.uniform(0, len(dominant_parent_act)))
          random_undominant_activation = undominant_parent_act[random_index_undominant]
 
          child_act[random_index_dominant] = random_undominant_activation
@@ -749,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))
             activations.pop(random_index)
             
 
@@ -757,7 +897,7 @@ def mutation(weight,
 
             try:
                
-               random_index_all_act = int(random.uniform(0, len(all_acts)-1))
+               random_index_all_act = int(random.uniform(0, len(all_acts)))
                activations.append(all_acts[random_index_all_act])
 
             except:
@@ -766,12 +906,12 @@ def mutation(weight,
                activations = []
 
                activations.append(activation)
-               activations.append(all_acts[int(random.uniform(0, len(all_acts)-1))])
+               activations.append(all_acts[int(random.uniform(0, len(all_acts)))])
             
          if potential_activation_change_prob > activation_change_prob:
             
-            random_index_all_act = int(random.uniform(0, len(all_acts)-1))
-            random_index_genom_act = int(random.uniform(0, len(activations)-1))
+            random_index_all_act = int(random.uniform(0, len(all_acts)))
+            random_index_genom_act = int(random.uniform(0, len(activations)))
 
             activations[random_index_genom_act] = all_acts[random_index_all_act]
 
@@ -786,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)))
 
    if selection_prob > bad_genomes_selection_prob:
       second_selected_W = good_weights[random_index]

{pyerualjetwork-4.5.3.dist-info → pyerualjetwork-4.6b0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyerualjetwork
-Version: 4.5.3
+Version: 4.6b0
 Summary: PyerualJetwork is a machine learning library supported with GPU(CUDA) acceleration written in Python for professionals and researchers including with PLAN algorithm, PLANEAT algorithm (genetic optimization). Also includes data pre-process and memory manegament
 Author: Hasan Can Beydili
 Author-email: tchasancan@gmail.com

{pyerualjetwork-4.5.3.dist-info → pyerualjetwork-4.6b0.dist-info}/RECORD

@@ -1,8 +1,8 @@
-pyerualjetwork/__init__.py,sha256=TdzilnzcR7WrAFk69ujThtXkM5baDMO-tPM2D_ZwTeM,1279
+pyerualjetwork/__init__.py,sha256=KLgnJmN6LoSApf-e8QKuNBxyBM3QqRZOSsUEVy5jL58,1279
 pyerualjetwork/activation_functions.py,sha256=Ms0AGBqkJuCA42ht64MSQnO54Td_1eDGquedpoBDVbc,7642
 pyerualjetwork/activation_functions_cuda.py,sha256=5y1Ti3GDfDteQDCUmODwe7tAyDAUlDTKmIikChQ8d6g,7772
-pyerualjetwork/data_operations.py,sha256=Y_RdxkjLEszFgeo4VDWIX1keF2syP-88KesLXA5sRyY,15280
-pyerualjetwork/data_operations_cuda.py,sha256=9tyD3Bbv5__stuUampgh3_GbMhb_kmTTJmZi7BJsvuA,17381
+pyerualjetwork/data_operations.py,sha256=TxfpwHWUpJ2E7IVF2uSmigrwpVL_JxrvGPOrMg2lNuI,15981
+pyerualjetwork/data_operations_cuda.py,sha256=5e8EO-XRplSmmXcZJxxEISdxO3297ShsAKHswTh3kGQ,18084
 pyerualjetwork/fitness_functions.py,sha256=urRdeMvUhNgWxD4ZGHCRdQlIf9cTWYMvF3_aVBojRqY,1235
 pyerualjetwork/help.py,sha256=nQ_YbYA2RtuafhuvkreNpX0WWL1I_nzlelwCtvei0_Y,775
 pyerualjetwork/loss_functions.py,sha256=6PyBI232SQRGuFnG3LDGvnv_PUdWzT2_2mUODJiejGI,618
@@ -10,16 +10,16 @@ pyerualjetwork/loss_functions_cuda.py,sha256=C93IZJcrOpT6HMK9x1O4AHJWXYTkN5WZiqd
 pyerualjetwork/memory_operations.py,sha256=0yCOHcgiNyF4ccMcRlL1Q9F_byG4nzjhmkbpXE_yU6E,13401
 pyerualjetwork/metrics.py,sha256=q7MkhnZDRbCjFBDDfUgrl8lBYnUT_1ro1LxeBq105pI,6077
 pyerualjetwork/metrics_cuda.py,sha256=73h9GC7XwmnFCVzFEEiPQfF8CwHIz2wsCbxpZrJtYgw,5061
-pyerualjetwork/model_operations.py,sha256=BLRL_5s_KSs8iCiLsEwWvhRcGiWCP_TD9lsjYWM7Zek,12746
-pyerualjetwork/model_operations_cuda.py,sha256=b3Bkobbrhq28AmYZ0vGxf2Hf8V2LPvoiM0xaPAApqec,13254
+pyerualjetwork/model_operations.py,sha256=aARz97TFaVX5lkdKSV-4cp3OT0KSiRUYO7ktpfCmr44,14854
+pyerualjetwork/model_operations_cuda.py,sha256=ZpnqaJYNb8Wyc5htEY0qXcZA4N9LLPDiHEBjrIqvGCI,15745
 pyerualjetwork/plan.py,sha256=UyIvPmvHCHwczlc9KHolE4y6CPEeBfhnRN5yznSbnoM,23028
 pyerualjetwork/plan_cuda.py,sha256=iteqgv7x9Z2Pj4vGOZs6HXS3r0bNaF_smr7ZXaOdRnw,23990
-pyerualjetwork/planeat.py,sha256=mOAdmoXQI8APNrpq9OlebkXDme5uu-Q4kFBhkiDZcbA,38632
-pyerualjetwork/planeat_cuda.py,sha256=unBeaaSN6rLcbjbRn97vG2yz8pZkcRX8pU8LTBY57ao,38676
+pyerualjetwork/planeat.py,sha256=RjTB2GN1Dp6Qbm6w5iDCEIR056KzQc4vyJ06Gce0iWQ,45193
+pyerualjetwork/planeat_cuda.py,sha256=cIkrjT9rjeyKhcrv3x_YXYqr2yeKe8yC1VblFqULg88,45241
 pyerualjetwork/ui.py,sha256=JBTFYz5R24XwNKhA3GSW-oYAoiIBxAE3kFGXkvm5gqw,656
 pyerualjetwork/visualizations.py,sha256=utnX9zQhzmtvBJLOLNGm2jecVVk4zHXABQdjb0XzJac,28352
 pyerualjetwork/visualizations_cuda.py,sha256=gnoaaazZ-nc9E1ImqXrZBRgQ4Rnpi2qh2yGJ2eLKMlE,28807
-pyerualjetwork-4.5.3.dist-info/METADATA,sha256=lZGj9ylqsyFAi3iUiWCRxDkrHLlCPubLterHaMm3QGk,7505
-pyerualjetwork-4.5.3.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
-pyerualjetwork-4.5.3.dist-info/top_level.txt,sha256=BRyt62U_r3ZmJpj-wXNOoA345Bzamrj6RbaWsyW4tRg,15
-pyerualjetwork-4.5.3.dist-info/RECORD,,
+pyerualjetwork-4.6b0.dist-info/METADATA,sha256=xS9cCvZpXLGKrVHK0VSQP49HnPKeN5PoyDSscUXzDDo,7505
+pyerualjetwork-4.6b0.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
+pyerualjetwork-4.6b0.dist-info/top_level.txt,sha256=BRyt62U_r3ZmJpj-wXNOoA345Bzamrj6RbaWsyW4tRg,15
+pyerualjetwork-4.6b0.dist-info/RECORD,,