pyerualjetwork 4.6.3__py3-none-any.whl → 4.6.4__py3-none-any.whl

pyerualjetwork/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "4.6.3"
+__version__ = "4.6.4"
 __update__ = """* Changes: https://github.com/HCB06/PyerualJetwork/blob/main/CHANGES
 * PyerualJetwork Homepage: https://github.com/HCB06/PyerualJetwork/tree/main
 * PyerualJetwork document: https://github.com/HCB06/PyerualJetwork/blob/main/Welcome_to_PyerualJetwork/PYERUALJETWORK_USER_MANUEL_AND_LEGAL_INFORMATION(EN).pdf

pyerualjetwork/data_operations.py

@@ -428,33 +428,4 @@ def batcher(x_test, y_test, batch_size=1):
         sampled_x.append(x_test[sampled_indices])
         sampled_y.append(y_test[sampled_indices])
 
-    return np.concatenate(sampled_x), np.concatenate(sampled_y)
-
-def split_nested_arrays(data, dtype):
-
-    n_samples = len(data)
-    if n_samples == 0:
-        return []
-    
-    n_components = len(data[0])
-    
-    result = []
-        
-    for i in range(n_components):
-        component_array = np.array([item[i] for item in data], dtype=dtype)
-        result.append(component_array)
-    
-    return result
-
-
-def reconstruct_nested_arrays(component_arrays):
-
-    n_components = len(component_arrays)
-    n_samples = len(component_arrays[0])
-    
-    reconstructed_data = []
-    for i in range(n_samples):
-        sample = [component_arrays[j][i] for j in range(n_components)]
-        reconstructed_data.append(sample)
-    
-    return reconstructed_data
+    return np.concatenate(sampled_x), np.concatenate(sampled_y)

pyerualjetwork/data_operations_cuda.py

@@ -476,34 +476,4 @@ def batcher(x_test, y_test, batch_size=1):
 
         offset += num_samples
     
-    return sampled_x, sampled_y
-
-
-def split_nested_arrays(data, dtype):
-
-    n_samples = len(data)
-    if n_samples == 0:
-        return []
-    
-    n_components = len(data[0])
-    
-    result = []
-        
-    for i in range(n_components):
-        component_array = cp.array([item[i] for item in data], dtype=dtype)
-        result.append(component_array)
-    
-    return result
-
-
-def reconstruct_nested_arrays(component_arrays):
-
-    n_components = len(component_arrays)
-    n_samples = len(component_arrays[0])
-    
-    reconstructed_data = []
-    for i in range(n_samples):
-        sample = [component_arrays[j][i] for j in range(n_components)]
-        reconstructed_data.append(sample)
-    
-    return reconstructed_data
+    return sampled_x, sampled_y

pyerualjetwork/planeat.py

@@ -17,9 +17,9 @@ import random
 import math
 
 ### LIBRARY IMPORTS ###
-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
+from data_operations import normalization, non_neg_normalization
+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, hidden=0, neurons=None, activation_functions=None, dtype=np.float32):
    """
@@ -56,7 +56,7 @@ def define_genomes(input_shape, output_shape, population_size, hidden=0, neurons
       and normalized using the `normalization()` function. (Max abs normalization.)
    """
    if hidden > 0:
-      population_weights = [[0] * (hidden + 1) for _ in range(population_size)]
+      population_weights = np.empty((population_size, hidden + 1), dtype=object)
       population_activations = [[0] * (hidden) for _ in range(population_size)]
    
       if len(neurons) != hidden:
@@ -87,7 +87,7 @@ def define_genomes(input_shape, output_shape, population_size, hidden=0, neurons
                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
@@ -309,33 +309,10 @@ 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)
+   if is_mlp:
+      activation_mutate_add_prob = 0
+      activation_selection_add_prob = 0
+      activation_mutate_delete_prob = 0
 
 ### FITNESS IS SORTED IN ASCENDING ORDER, AND THE WEIGHT AND ACTIVATIONS OF EACH GENOME ARE SORTED ACCORDING TO THIS ORDER:
 
@@ -366,7 +343,7 @@ def evolver(weights,
 
    best_fitness = normalized_fitness[-1]
    epsilon = np.finfo(float).eps
-
+   
    child_W = np.copy(bad_weights)
    child_act = bad_activations.copy()
 
@@ -379,38 +356,63 @@ def evolver(weights,
       if policy == 'aggressive':
          first_parent_W = best_weight
          first_parent_act = best_activations
+         first_parent_fitness = best_fitness
 
       elif policy == 'explorer':
          first_parent_W = good_weights[i]
          first_parent_act = good_activations[i]
+         first_parent_fitness = normalized_fitness[len(good_weights) + i]
 
       else: raise ValueError("policy parameter must be: 'aggressive' or 'explorer'")
          
       second_parent_W, second_parent_act, s_i = second_parent_selection(good_weights, bad_weights, good_activations, bad_activations, bad_genomes_selection_prob)
 
-      child_W[i], child_act[i] = cross_over(first_parent_W,
-                                             second_parent_W,
-                                             first_parent_act,
-                                             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_threshold=activation_selection_threshold,
-                                             bad_genomes_selection_prob=bad_genomes_selection_prob,
-                                             first_parent_fitness=best_fitness,
-                                             fitness_bias=fitness_bias,
-                                             second_parent_fitness=normalized_fitness[s_i],
-                                             weight_evolve=weight_evolve,
-                                             epsilon=epsilon
-                                             )
+      if is_mlp:
+         for l in range(len(first_parent_W)):
+            
+            if l == 0:
+               act_l = 0
+            else:
+               act_l = l - 1
 
+            child_W[i][l], child_act[i][act_l] = cross_over(first_parent_W[l],
+                                                   second_parent_W[l],
+                                                   first_parent_act[act_l],
+                                                   second_parent_act[act_l],
+                                                   cross_over_mode=cross_over_mode,
+                                                   activation_selection_add_prob=activation_selection_add_prob,
+                                                   activation_selection_change_prob=activation_selection_change_prob,
+                                                   activation_selection_threshold=activation_selection_threshold,
+                                                   bad_genomes_selection_prob=bad_genomes_selection_prob,
+                                                   first_parent_fitness=first_parent_fitness,
+                                                   fitness_bias=fitness_bias,
+                                                   second_parent_fitness=normalized_fitness[s_i],
+                                                   weight_evolve=weight_evolve,
+                                                   epsilon=epsilon
+                                                   )
+      else:
+            child_W[i], child_act[i] = cross_over(first_parent_W,
+                                                   second_parent_W,
+                                                   first_parent_act,
+                                                   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_threshold=activation_selection_threshold,
+                                                   bad_genomes_selection_prob=bad_genomes_selection_prob,
+                                                   first_parent_fitness=first_parent_fitness,
+                                                   fitness_bias=fitness_bias,
+                                                   second_parent_fitness=normalized_fitness[s_i],
+                                                   weight_evolve=weight_evolve,
+                                                   epsilon=epsilon
+                                                   )
       mutation_prob = random.uniform(0, 1)
 
       if mutation_prob > bad_genomes_mutation_prob:
             genome_W = good_weights[i]
             genome_act = good_activations[i]
 
-            fitness_index = int(len(bad_weights) / 2 + i)
+            fitness_index = int(len(good_weights) + i)
 
       else:
             genome_W = bad_weights[i]
@@ -418,28 +420,55 @@ def evolver(weights,
 
             fitness_index = i
 
-      mutated_W[i], mutated_act[i] = mutation(genome_W, 
-                                             genome_act,
-                                             activation_mutate_prob=activation_mutate_prob,
-                                             activation_add_prob=activation_mutate_add_prob,
-                                             activation_delete_prob=activation_mutate_delete_prob, 
-                                             activation_change_prob=activation_mutate_change_prob, 
-                                             weight_mutate_prob=weight_mutate_prob, 
-                                             weight_mutate_threshold=weight_mutate_threshold,
-                                             genome_fitness=normalized_fitness[fitness_index],
-                                             activation_mutate_threshold=activation_mutate_threshold,
-                                             weight_evolve=weight_evolve,
-                                             epsilon=epsilon
-                                             )
+      if is_mlp:
+         for l in range(len(genome_W)):
 
-      if bar_status: progress.update(1)
+            if l == 0:
+               act_l = 0
+            else:
+               act_l = l - 1
 
+            mutated_W[i][l], mutated_act[i][act_l] = mutation(genome_W[l], 
+                                                   genome_act[act_l],
+                                                   activation_mutate_prob=activation_mutate_prob,
+                                                   activation_add_prob=activation_mutate_add_prob,
+                                                   activation_delete_prob=activation_mutate_delete_prob, 
+                                                   activation_change_prob=activation_mutate_change_prob, 
+                                                   weight_mutate_prob=weight_mutate_prob, 
+                                                   weight_mutate_threshold=weight_mutate_threshold,
+                                                   genome_fitness=normalized_fitness[fitness_index],
+                                                   activation_mutate_threshold=activation_mutate_threshold,
+                                                   weight_evolve=weight_evolve,
+                                                   epsilon=epsilon
+                                                   )
+      else:
+         mutated_W[i], mutated_act[i] = mutation(genome_W, 
+                                                genome_act,
+                                                activation_mutate_prob=activation_mutate_prob,
+                                                activation_add_prob=activation_mutate_add_prob,
+                                                activation_delete_prob=activation_mutate_delete_prob, 
+                                                activation_change_prob=activation_mutate_change_prob, 
+                                                weight_mutate_prob=weight_mutate_prob, 
+                                                weight_mutate_threshold=weight_mutate_threshold,
+                                                genome_fitness=normalized_fitness[fitness_index],
+                                                activation_mutate_threshold=activation_mutate_threshold,
+                                                weight_evolve=weight_evolve,
+                                                epsilon=epsilon
+                                                )
+
+      if bar_status: progress.update(1)
+   
    child_W[0] = best_weight
    child_act[0] = best_activations
 
-   weights = np.vstack((child_W, mutated_W), dtype=dtype)
+   if is_mlp:
+      weights = np.vstack((child_W, mutated_W), dtype=object)
+   else:
+      weights = np.vstack((child_W, mutated_W), dtype=dtype)
+   
    activation_potentiations = child_act + mutated_act
 
+
    ### INFO PRINTING CONSOLE
    
    if show_info == True:
@@ -529,65 +558,6 @@ def evaluate(Input, weights, activation_potentiations, is_mlp=False):
 
       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, dtype)
-
-   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,
                first_parent_act,

pyerualjetwork/planeat_cuda.py

@@ -19,9 +19,9 @@ import math
 
 
 ### LIBRARY IMPORTS ###
-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
+from data_operations_cuda import normalization, non_neg_normalization
+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, hidden=0, neurons=None, activation_functions=None, dtype=cp.float32):
    """
@@ -47,7 +47,7 @@ def define_genomes(input_shape, output_shape, population_size, hidden=0, neurons
 
    Returns:
       tuple: A tuple containing:
-         - population_weights (numpy.ndarray): A 2D numpy array of shape (population_size, output_shape, input_shape) representing the 
+         - population_weights (cupy.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.
             
@@ -58,7 +58,7 @@ def define_genomes(input_shape, output_shape, population_size, hidden=0, neurons
       and normalized using the `normalization()` function. (Max abs normalization.)
    """
    if hidden > 0:
-      population_weights = [[0] * (hidden + 1) for _ in range(population_size)]
+      population_weights = cp.empty((population_size, hidden + 1), dtype=object)
       population_activations = [[0] * (hidden) for _ in range(population_size)]
    
       if len(neurons) != hidden:
@@ -88,8 +88,6 @@ def define_genomes(input_shape, output_shape, population_size, hidden=0, neurons
                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
@@ -109,7 +107,7 @@ def define_genomes(input_shape, output_shape, population_size, hidden=0, neurons
             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, 
@@ -310,33 +308,10 @@ 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)
+   if is_mlp:
+      activation_mutate_add_prob = 0
+      activation_selection_add_prob = 0
+      activation_mutate_delete_prob = 0
 
 ### FITNESS LIST IS SORTED IN ASCENDING ORDER, AND THE WEIGHT AND ACTIVATIONS OF EACH GENOME ARE SORTED ACCORDING TO THIS ORDER:
 
@@ -380,30 +355,56 @@ def evolver(weights,
       if policy == 'aggressive':
          first_parent_W = best_weight
          first_parent_act = best_activations
+         first_parent_fitness = best_fitness
 
       elif policy == 'explorer':
          first_parent_W = good_weights[i]
          first_parent_act = good_activations[i]
+         first_parent_fitness = normalized_fitness[len(good_weights) + i]
 
       else: raise ValueError("policy parameter must be: 'aggressive' or 'explorer'")
          
       second_parent_W, second_parent_act, s_i = second_parent_selection(good_weights, bad_weights, good_activations, bad_activations, bad_genomes_selection_prob)
 
-      child_W[i], child_act[i] = cross_over(first_parent_W,
-                                             second_parent_W,
-                                             first_parent_act,
-                                             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_threshold=activation_selection_threshold,
-                                             bad_genomes_selection_prob=bad_genomes_selection_prob,
-                                             first_parent_fitness=best_fitness,
-                                             fitness_bias=fitness_bias,
-                                             second_parent_fitness=normalized_fitness[s_i],
-                                             weight_evolve=weight_evolve,
-                                             epsilon=epsilon
-                                             )
+      if is_mlp:
+            for l in range(len(first_parent_W)):
+               
+               if l == 0:
+                  act_l = 0
+               else:
+                  act_l = l - 1
+
+               child_W[i][l], child_act[i][act_l] = cross_over(first_parent_W[l],
+                                                      second_parent_W[l],
+                                                      first_parent_act[act_l],
+                                                      second_parent_act[act_l],
+                                                      cross_over_mode=cross_over_mode,
+                                                      activation_selection_add_prob=activation_selection_add_prob,
+                                                      activation_selection_change_prob=activation_selection_change_prob,
+                                                      activation_selection_threshold=activation_selection_threshold,
+                                                      bad_genomes_selection_prob=bad_genomes_selection_prob,
+                                                      first_parent_fitness=first_parent_fitness,
+                                                      fitness_bias=fitness_bias,
+                                                      second_parent_fitness=normalized_fitness[s_i],
+                                                      weight_evolve=weight_evolve,
+                                                      epsilon=epsilon
+                                                      )
+      else:
+            child_W[i], child_act[i] = cross_over(first_parent_W,
+                                                   second_parent_W,
+                                                   first_parent_act,
+                                                   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_threshold=activation_selection_threshold,
+                                                   bad_genomes_selection_prob=bad_genomes_selection_prob,
+                                                   first_parent_fitness=first_parent_fitness,
+                                                   fitness_bias=fitness_bias,
+                                                   second_parent_fitness=normalized_fitness[s_i],
+                                                   weight_evolve=weight_evolve,
+                                                   epsilon=epsilon
+                                                   )
   
       mutation_prob = random.uniform(0, 1)
 
@@ -411,7 +412,7 @@ def evolver(weights,
             genome_W = good_weights[i]
             genome_act = good_activations[i]
 
-            fitness_index = int(len(bad_weights) / 2 + i)
+            fitness_index = int(len(good_weights) + i)
 
       else:
             genome_W = bad_weights[i]
@@ -419,26 +420,52 @@ def evolver(weights,
 
             fitness_index = i
 
-      mutated_W[i], mutated_act[i] = mutation(genome_W, 
-                                             genome_act,
-                                             activation_mutate_prob=activation_mutate_prob,
-                                             activation_add_prob=activation_mutate_add_prob,
-                                             activation_delete_prob=activation_mutate_delete_prob, 
-                                             activation_change_prob=activation_mutate_change_prob, 
-                                             weight_mutate_prob=weight_mutate_prob, 
-                                             weight_mutate_threshold=weight_mutate_threshold,
-                                             genome_fitness=normalized_fitness[fitness_index],
-                                             activation_mutate_threshold=activation_mutate_threshold,
-                                             weight_evolve=weight_evolve,
-                                             epsilon=epsilon
-                                             )
+      if is_mlp:
+         for l in range(len(genome_W)):
+
+            if l == 0:
+               act_l = 0
+            else:
+               act_l = l - 1
+
+            mutated_W[i][l], mutated_act[i][act_l] = mutation(genome_W[l], 
+                                                   genome_act[act_l],
+                                                   activation_mutate_prob=activation_mutate_prob,
+                                                   activation_add_prob=activation_mutate_add_prob,
+                                                   activation_delete_prob=activation_mutate_delete_prob, 
+                                                   activation_change_prob=activation_mutate_change_prob, 
+                                                   weight_mutate_prob=weight_mutate_prob, 
+                                                   weight_mutate_threshold=weight_mutate_threshold,
+                                                   genome_fitness=normalized_fitness[fitness_index],
+                                                   activation_mutate_threshold=activation_mutate_threshold,
+                                                   weight_evolve=weight_evolve,
+                                                   epsilon=epsilon
+                                                   )
+      else:
+         mutated_W[i], mutated_act[i] = mutation(genome_W, 
+                                                genome_act,
+                                                activation_mutate_prob=activation_mutate_prob,
+                                                activation_add_prob=activation_mutate_add_prob,
+                                                activation_delete_prob=activation_mutate_delete_prob, 
+                                                activation_change_prob=activation_mutate_change_prob, 
+                                                weight_mutate_prob=weight_mutate_prob, 
+                                                weight_mutate_threshold=weight_mutate_threshold,
+                                                genome_fitness=normalized_fitness[fitness_index],
+                                                activation_mutate_threshold=activation_mutate_threshold,
+                                                weight_evolve=weight_evolve,
+                                                epsilon=epsilon
+                                                )
             
       if bar_status: progress.update(1)
 
    child_W[0] = best_weight
    child_act[0] = best_activations
 
-   weights = cp.vstack((child_W, mutated_W), dtype=dtype)
+   if is_mlp:
+      weights = cp.vstack((child_W, mutated_W), dtype=object)
+   else:
+      weights = cp.vstack((child_W, mutated_W), dtype=dtype)
+
    activation_potentiations = child_act + mutated_act
 
    ### INFO PRINTING CONSOLE
@@ -519,7 +546,7 @@ def evaluate(Input, weights, activation_potentiations, is_mlp=False):
       
       layer = Input
       for i in range(len(weights)):
-         if i != len(weights) - 1 and i != 0: layer = apply_activation(layer, activation_potentiations[i])
+         if i != len(weights) - 1: layer = apply_activation(layer, activation_potentiations[i])
          layer = layer @ weights[i].T
       
       return layer
@@ -531,65 +558,6 @@ def evaluate(Input, weights, activation_potentiations, is_mlp=False):
 
       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, dtype)
-
-   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,
                first_parent_act,

{pyerualjetwork-4.6.3.dist-info → pyerualjetwork-4.6.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyerualjetwork
-Version: 4.6.3
+Version: 4.6.4
 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.6.3.dist-info → pyerualjetwork-4.6.4.dist-info}/RECORD

@@ -1,8 +1,8 @@
-pyerualjetwork/__init__.py,sha256=VwT_tzGQ_j-4Ou_OSz3X2NqF9XQ3NkhjYzUFo6K_WeI,1279
+pyerualjetwork/__init__.py,sha256=YUTYZKlP8YA8lCrb_TkI86g7do3X5ju4SpOohnsqEBg,1279
 pyerualjetwork/activation_functions.py,sha256=Ms0AGBqkJuCA42ht64MSQnO54Td_1eDGquedpoBDVbc,7642
 pyerualjetwork/activation_functions_cuda.py,sha256=5y1Ti3GDfDteQDCUmODwe7tAyDAUlDTKmIikChQ8d6g,7772
-pyerualjetwork/data_operations.py,sha256=_7rS4Addogv25mpMUf0mjBDqTYFzrBp4rGA1ji08VkI,16001
-pyerualjetwork/data_operations_cuda.py,sha256=0TaTjrG85rdqQjM4IfQbrXqle4Wc-nkykPtd_aM0ItA,18104
+pyerualjetwork/data_operations.py,sha256=Y_RdxkjLEszFgeo4VDWIX1keF2syP-88KesLXA5sRyY,15280
+pyerualjetwork/data_operations_cuda.py,sha256=9tyD3Bbv5__stuUampgh3_GbMhb_kmTTJmZi7BJsvuA,17381
 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
@@ -14,12 +14,12 @@ pyerualjetwork/model_operations.py,sha256=fr64XCwgl1YRh5nP3sEkvQORKHb-2lF_a4Kjcl
 pyerualjetwork/model_operations_cuda.py,sha256=-Kv8fYqHSU0L9FalOsQ7EWCwCEwjgUySObyueOqCH_o,16134
 pyerualjetwork/plan.py,sha256=UyIvPmvHCHwczlc9KHolE4y6CPEeBfhnRN5yznSbnoM,23028
 pyerualjetwork/plan_cuda.py,sha256=iteqgv7x9Z2Pj4vGOZs6HXS3r0bNaF_smr7ZXaOdRnw,23990
-pyerualjetwork/planeat.py,sha256=KgI1RCNvYxGfw2wQ7dWFLLZrPE6ys9agS4bjodq2W9U,45312
-pyerualjetwork/planeat_cuda.py,sha256=K0YWrH2POXsD9xiUq9zqPulan57uspeIa16XjknsNwk,45357
+pyerualjetwork/planeat.py,sha256=JTS8a3SCqqh-Ct5XIQ02FcHGqShdBTAtY2d_C7nyawI,44640
+pyerualjetwork/planeat_cuda.py,sha256=0xLYM3YmMCB61G8nKOVq5DcvZPiBzkzqhW4fPjVWL3g,44645
 pyerualjetwork/ui.py,sha256=JBTFYz5R24XwNKhA3GSW-oYAoiIBxAE3kFGXkvm5gqw,656
 pyerualjetwork/visualizations.py,sha256=utnX9zQhzmtvBJLOLNGm2jecVVk4zHXABQdjb0XzJac,28352
 pyerualjetwork/visualizations_cuda.py,sha256=gnoaaazZ-nc9E1ImqXrZBRgQ4Rnpi2qh2yGJ2eLKMlE,28807
-pyerualjetwork-4.6.3.dist-info/METADATA,sha256=b6-XwpCnTnMIO5YVBJ3wA378PWyD9zde598dI_1_Gqg,7505
-pyerualjetwork-4.6.3.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
-pyerualjetwork-4.6.3.dist-info/top_level.txt,sha256=BRyt62U_r3ZmJpj-wXNOoA345Bzamrj6RbaWsyW4tRg,15
-pyerualjetwork-4.6.3.dist-info/RECORD,,
+pyerualjetwork-4.6.4.dist-info/METADATA,sha256=b0nf9JEqKAAoWbRHTuVRm-rHEmG2XklkOI3cdqATpxc,7505
+pyerualjetwork-4.6.4.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
+pyerualjetwork-4.6.4.dist-info/top_level.txt,sha256=BRyt62U_r3ZmJpj-wXNOoA345Bzamrj6RbaWsyW4tRg,15
+pyerualjetwork-4.6.4.dist-info/RECORD,,