pyerualjetwork 4.3.9b5__py3-none-any.whl → 4.3.9b6__py3-none-any.whl

pyerualjetwork/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "4.3.9b5"
+__version__ = "4.3.9b6"
 __update__ = "* Changes: https://github.com/HCB06/PyerualJetwork/blob/main/CHANGES\n* PyerualJetwork Homepage: https://github.com/HCB06/PyerualJetwork/tree/main\n* PyerualJetwork document: https://github.com/HCB06/PyerualJetwork/blob/main/Welcome_to_PyerualJetwork/PYERUALJETWORK_USER_MANUEL_AND_LEGAL_INFORMATION(EN).pdf\n* YouTube tutorials: https://www.youtube.com/@HasanCanBeydili"
 
 def print_version(__version__):

pyerualjetwork/plan.py

@@ -83,7 +83,7 @@ def fit(
     return normalization(weight, dtype=dtype)
 
 
-def learner(x_train, y_train, optimizer, fit_start, strategy='accuracy', gen=None, batch_size=1, pop_size=None,
+def learner(x_train, y_train, optimizer, fit_start=True, strategy='accuracy', gen=None, batch_size=1, pop_size=None,
            neural_web_history=False, show_current_activations=False, auto_normalization=False,
            neurons_history=False, early_stop=False, loss='categorical_crossentropy', show_history=False,
            interval=33.33, target_acc=None, target_loss=None,
@@ -120,7 +120,7 @@ def learner(x_train, y_train, optimizer, fit_start, strategy='accuracy', gen=Non
                              interval=16.67)
         ```
 
-        fit_start (bool): If the fit_start parameter is set to True, the initial generation population undergoes a simple short training process using the PLAN algorithm. This allows for a very robust starting point, especially for large and complex datasets. However, for small or relatively simple datasets, it may result in unnecessary computational overhead. When fit_start is True, completing the first generation may take slightly longer (this increase in computational cost applies only to the first generation and does not affect subsequent generations). If fit_start is set to False, the initial population will be entirely random. Options: True or False. The fit_start parameter is MANDATORY and must be provided.
+        fit_start (bool, optional): If the fit_start parameter is set to True, the initial generation population undergoes a simple short training process using the PLAN algorithm. This allows for a very robust starting point, especially for large and complex datasets. However, for small or relatively simple datasets, it may result in unnecessary computational overhead. When fit_start is True, completing the first generation may take slightly longer (this increase in computational cost applies only to the first generation and does not affect subsequent generations). If fit_start is set to False, the initial population will be entirely random. Options: True or False. Default: True
 
         strategy (str, optional): Learning strategy. (options: 'accuracy', 'f1', 'precision', 'recall'): 'accuracy', Maximizes train (or test if given) accuracy during learning. 'f1', Maximizes train (or test if given) f1 score during learning. 'precision', Maximizes train (or test if given) precision score during learning. 'recall', Maximizes train (or test if given) recall during learning. Default is 'accuracy'.
 
@@ -202,15 +202,15 @@ def learner(x_train, y_train, optimizer, fit_start, strategy='accuracy', gen=Non
 
     if fit_start is False or pop_size > activation_potentiation_len:
         weight_pop, act_pop = define_genomes(input_shape=len(x_train[0]), output_shape=len(y_train[0]), population_size=pop_size, dtype=dtype)
-    
-        if start_this_act is not None and start_this_W is not None:
-            weight_pop[0] = start_this_W
-            act_pop[0] = start_this_act
 
     else:
         weight_pop = [0] * pop_size
         act_pop = [0] * pop_size
 
+    if start_this_act is not None and start_this_W is not None:
+        weight_pop[0] = start_this_W
+        act_pop[0] = start_this_act
+
     for i in range(gen):
         postfix_dict["Gen"] = str(i+1) + '/' + str(gen)
         progress.set_postfix(postfix_dict)
@@ -224,9 +224,12 @@ def learner(x_train, y_train, optimizer, fit_start, strategy='accuracy', gen=Non
             x_train_batch, y_train_batch = batcher(x_train, y_train, batch_size=batch_size)
             
             if fit_start is True and i == 0 and j < activation_potentiation_len:
-                act_pop[j] = activation_potentiation[j]
-                W = fit(x_train_batch, y_train_batch, activation_potentiation=act_pop[j], auto_normalization=auto_normalization, dtype=dtype)
-                weight_pop[j] = W
+                if start_this_act is not None and j == 0:
+                    pass
+                else:
+                    act_pop[j] = activation_potentiation[j]
+                    W = fit(x_train_batch, y_train_batch, activation_potentiation=act_pop[j], auto_normalization=auto_normalization, dtype=dtype)
+                    weight_pop[j] = W
             
             model = evaluate(x_train_batch, y_train_batch, W=weight_pop[j], activation_potentiation=act_pop[j])
             acc = model[get_acc()]
@@ -309,7 +312,7 @@ def learner(x_train, y_train, optimizer, fit_start, strategy='accuracy', gen=Non
                 if target_acc is not None and best_acc >= target_acc:
                     progress.close()
                     train_model = evaluate(x_train, y_train, W=best_weights, 
-                                        activation_potentiation=final_activations, dtype=dtype)
+                                        activation_potentiation=final_activations)
 
                     if loss == 'categorical_crossentropy':
                         train_loss = categorical_crossentropy(y_true_batch=y_train, 
@@ -331,7 +334,7 @@ def learner(x_train, y_train, optimizer, fit_start, strategy='accuracy', gen=Non
                 if target_loss is not None and best_loss <= target_loss:
                     progress.close()
                     train_model = evaluate(x_train, y_train, W=best_weights,
-                                        activation_potentiation=final_activations, dtype=dtype)
+                                        activation_potentiation=final_activations)
 
                     if loss == 'categorical_crossentropy':
                         train_loss = categorical_crossentropy(y_true_batch=y_train, 
@@ -380,7 +383,7 @@ def learner(x_train, y_train, optimizer, fit_start, strategy='accuracy', gen=Non
             if best_acc_per_gen_list[i] == best_acc_per_gen_list[i-1]:
                 progress.close()
                 train_model = evaluate(x_train, y_train, W=best_weights, 
-                                    activation_potentiation=final_activations, dtype=dtype)
+                                    activation_potentiation=final_activations)
 
                 if loss == 'categorical_crossentropy':
                     train_loss = categorical_crossentropy(y_true_batch=y_train, 
@@ -401,7 +404,7 @@ def learner(x_train, y_train, optimizer, fit_start, strategy='accuracy', gen=Non
     # Final evaluation
     progress.close()
     train_model = evaluate(x_train, y_train, W=best_weights, 
-                        activation_potentiation=final_activations, dtype=dtype)
+                        activation_potentiation=final_activations)
 
     if loss == 'categorical_crossentropy':
         train_loss = categorical_crossentropy(y_true_batch=y_train, y_pred_batch=train_model[get_preds_softmax()])

pyerualjetwork/plan_cuda.py

@@ -82,7 +82,7 @@ def fit(
     return normalization(weight, dtype=dtype)
 
 
-def learner(x_train, y_train, optimizer, fit_start, strategy='accuracy', gen=None, batch_size=1, pop_size=None,
+def learner(x_train, y_train, optimizer, fit_start=True, strategy='accuracy', gen=None, batch_size=1, pop_size=None,
            neural_web_history=False, show_current_activations=False, auto_normalization=False,
            neurons_history=False, early_stop=False, loss='categorical_crossentropy', show_history=False,
            interval=33.33, target_acc=None, target_loss=None,
@@ -118,7 +118,7 @@ def learner(x_train, y_train, optimizer, fit_start, strategy='accuracy', gen=Non
                                 batch_size=0.05,
                                 interval=16.67)
         ```
-        fit_start (bool): If the fit_start parameter is set to True, the initial generation population undergoes a simple short training process using the PLAN algorithm. This allows for a very robust starting point, especially for large and complex datasets. However, for small or relatively simple datasets, it may result in unnecessary computational overhead. When fit_start is True, completing the first generation may take slightly longer (this increase in computational cost applies only to the first generation and does not affect subsequent generations). If fit_start is set to False, the initial population will be entirely random. Options: True or False. The fit_start parameter is MANDATORY and must be provided.
+        fit_start (bool, optional): If the fit_start parameter is set to True, the initial generation population undergoes a simple short training process using the PLAN algorithm. This allows for a very robust starting point, especially for large and complex datasets. However, for small or relatively simple datasets, it may result in unnecessary computational overhead. When fit_start is True, completing the first generation may take slightly longer (this increase in computational cost applies only to the first generation and does not affect subsequent generations). If fit_start is set to False, the initial population will be entirely random. Options: True or False. Default: True
         
         strategy (str, optional): Learning strategy. (options: 'accuracy', 'f1', 'precision', 'recall'): 'accuracy', Maximizes train (or test if given) accuracy during learning. 'f1', Maximizes train (or test if given) f1 score during learning. 'precision', Maximizes train (or test if given) precision score during learning. 'recall', Maximizes train (or test if given) recall during learning. Default is 'accuracy'.
 
@@ -210,15 +210,15 @@ def learner(x_train, y_train, optimizer, fit_start, strategy='accuracy', gen=Non
 
     if fit_start is False or pop_size > activation_potentiation_len:
         weight_pop, act_pop = define_genomes(input_shape=len(x_train[0]), output_shape=len(y_train[0]), population_size=pop_size, dtype=dtype)
-    
-        if start_this_act is not None and start_this_W is not None:
-            weight_pop[0] = start_this_W
-            act_pop[0] = start_this_act
 
     else:
         weight_pop = [0] * pop_size
         act_pop = [0] * pop_size
 
+    if start_this_act is not None and start_this_W is not None:
+        weight_pop[0] = start_this_W
+        act_pop[0] = start_this_act
+
     for i in range(gen):
         postfix_dict["Gen"] = str(i+1) + '/' + str(gen)
         progress.set_postfix(postfix_dict)
@@ -235,9 +235,12 @@ def learner(x_train, y_train, optimizer, fit_start, strategy='accuracy', gen=Non
             y_train_batch = cp.array(y_train_batch, dtype=dtype, copy=False)
 
             if fit_start is True and i == 0 and j < activation_potentiation_len:
-                act_pop[j] = activation_potentiation[j]
-                W = fit(x_train_batch, y_train_batch, activation_potentiation=act_pop[j], auto_normalization=auto_normalization, dtype=dtype)
-                weight_pop[j] = W
+                if start_this_act is not None and j == 0:
+                    pass
+                else:
+                    act_pop[j] = activation_potentiation[j]
+                    W = fit(x_train_batch, y_train_batch, activation_potentiation=act_pop[j], auto_normalization=auto_normalization, dtype=dtype)
+                    weight_pop[j] = W
     
             model = evaluate(x_train_batch, y_train_batch, W=weight_pop[j], activation_potentiation=act_pop[j])
             acc = model[get_acc()]
@@ -319,7 +322,7 @@ def learner(x_train, y_train, optimizer, fit_start, strategy='accuracy', gen=Non
                 # Check target accuracy
                 if target_acc is not None and best_acc >= target_acc:
                     progress.close()
-                    train_model = evaluate(x_train, y_train, W=best_weights, loading_bar_status=False, 
+                    train_model = evaluate(x_train, y_train, W=best_weights, 
                                         activation_potentiation=final_activations)
 
                     if loss == 'categorical_crossentropy':

pyerualjetwork/planeat.py

@@ -17,9 +17,10 @@ import random
 import math
 
 ### LIBRARY IMPORTS ###
+from .plan import feed_forward
 from .data_operations import normalization
 from .ui import loading_bars, initialize_loading_bar
-from .activation_functions import apply_activation, all_activations
+from. activation_functions import apply_activation, all_activations
 
 def define_genomes(input_shape, output_shape, population_size, dtype=np.float32):
    """
@@ -296,7 +297,6 @@ def evolver(weights,
    mutated_W = np.copy(bad_weights)
    mutated_act = bad_activations.copy()
 
-
    for i in range(len(bad_weights)):
       
       if policy == 'aggressive':
@@ -399,7 +399,7 @@ def evolver(weights,
    return weights, activation_potentiations
 
 
-def evaluate(x_population, weights, activation_potentiations):
+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.
@@ -412,30 +412,62 @@ def evaluate(x_population, 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.
+        rl_mode (bool, optional): If True, reinforcement learning mode is activated, this accepts x_population is a single genome. (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.
 
+    Notes:
+        - If `rl_mode` is True:
+            - Accepts x_population is a single genom
+            - The inputs are flattened, and the activation function is applied across the single genom.
+        
+        - If `rl_mode` is False:
+            - Accepts x_population is a list of genomes
+            - Each genome is processed individually, and the results are stored in the `outputs` list.
+        
+        - `feed_forward()` function is the core function that processes the input with the given weights and activation function.
+    
     Example:
         ```python
-        outputs = evaluate(x_population, weights, activation_potentiations)
+        outputs = evaluate(x_population, weights, activation_potentiations, rl_mode=False)
         ```
 
     - The function returns a list of outputs after processing the population, where each element corresponds to
       the output for each genome in `x_population`.
-   """   
+   """
+   
+   ### IF RL_MODE IS TRUE, A SINGLE GENOME IS ASSUMED AS INPUT, A FEEDFORWARD PREDICTION IS MADE, AND THE OUTPUT(NPARRAY) IS RETURNED:
+   
+   ### IF RL_MODE IS FALSE, PREDICTIONS ARE MADE FOR ALL GENOMES IN THE GROUP USING THEIR CORRESPONDING INDEXED INPUTS AND DATA.
    ### THE OUTPUTS ARE RETURNED AS A PYTHON LIST, WHERE EACH GENOME'S OUTPUT MATCHES ITS INDEX:
    
-
-   if isinstance(activation_potentiations, str):
-    activation_potentiations = [activation_potentiations]
+   if rl_mode == True:
+      Input = np.array(x_population, copy=False, dtype=dtype)
+      Input = Input.ravel()
+      
+      if isinstance(activation_potentiations, str):
+         activation_potentiations = [activation_potentiations]
+      
+      outputs = feed_forward(Input=Input, is_training=False, activation_potentiation=activation_potentiations, w=weights)
+      
    else:
-    activation_potentiations = [item if isinstance(item, list) else [item] for item in activation_potentiations]
+      outputs = [0] * len(x_population)
+      for i, genome in enumerate(x_population):
 
-   x_population = apply_activation(x_population, activation_potentiations)
-   result = x_population @ weights.T
+         Input = np.array(genome, copy=False)
+         Input = Input.ravel()
 
-   return result
+         if isinstance(activation_potentiations[i], str):
+            activation_potentiations[i] = [activation_potentiations[i]]
+
+         outputs[i] = feed_forward(Input=Input, is_training=False, activation_potentiation=activation_potentiations[i], w=weights[i])
+
+   return outputs
 
 
 def cross_over(first_parent_W,
@@ -582,11 +614,20 @@ def cross_over(first_parent_W,
    if potential_activation_selection_add > activation_selection_add_prob:
       
       threshold = abs(activation_selection_threshold / succes)
-      num_elements = int(len(dominant_parent_act) / threshold)
+      new_threshold = threshold
+      
+      while True:
+         
+         random_index = int(random.uniform(0, len(undominant_parent_act)-1))
+         random_undominant_activation = undominant_parent_act[random_index]
 
-      random_indices = [int(random.uniform(0, len(undominant_parent_act)-1)) for _ in range(num_elements)]
+         child_act.append(random_undominant_activation)
 
-      child_act.extend([undominant_parent_act[i] for i in random_indices])
+         if len(dominant_parent_act) > new_threshold:
+            new_threshold += threshold
+         
+         else:
+            break
 
    activation_selection_change_prob = 1 - activation_selection_change_prob
    potential_activation_selection_change_prob = random.uniform(0, 1)
@@ -594,12 +635,21 @@ def cross_over(first_parent_W,
    if potential_activation_selection_change_prob > activation_selection_change_prob:
       
       threshold = abs(activation_selection_threshold / succes)
-      num_elements = min(len(dominant_parent_act), int(threshold))
-
-      random_indices = random.choices(range(len(undominant_parent_act)), k=num_elements)
+      new_threshold = threshold
+      
+      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_undominant_activation = undominant_parent_act[random_index_undominant]
 
-      child_act.extend(undominant_parent_act[i] for i in random_indices)
+         child_act[random_index_dominant] = random_undominant_activation
 
+         if len(dominant_parent_act) > new_threshold:
+            new_threshold += threshold
+         
+         else:
+            break
 
    return child_W, child_act
 
@@ -673,50 +723,80 @@ def mutation(weight,
       max_threshold = row_end * col_end
 
       threshold = weight_mutate_threshold * genome_fitness
-      num_mutations = int(max_threshold / threshold)
-
-      selected_rows = np.random.randint(start, row_end, size=num_mutations)
-      selected_cols = np.random.randint(start, col_end, size=num_mutations)
-      new_values = np.random.uniform(-1, 1, size=num_mutations)
+      new_threshold = threshold
       
-      weight[selected_rows, selected_cols] = new_values
+      for _ in range(max_threshold):
+         
+         selected_row = int(random.uniform(start, row_end))
+         selected_col = int(random.uniform(start, col_end))
 
-   activation_mutate_prob = 1 - activation_mutate_prob
-   potential_activation_mutation = random.uniform(0, 1)
+         weight[selected_row, selected_col] = random.uniform(-1, 1)
+         new_threshold += threshold
 
-   if potential_activation_mutation > activation_mutate_prob:
+         if max_threshold > new_threshold:
+            pass
          
-      genome_fitness += epsilon
-      threshold = abs(activation_mutate_threshold / genome_fitness)
-      max_threshold = len(activations)
+         else:
+            break
 
-      new_threshold = threshold
+      activation_mutate_prob = 1 - activation_mutate_prob
+      potential_activation_mutation = random.uniform(0, 1)
 
-      except_this = ['spiral', 'circular']
-      all_acts = [item for item in all_activations() if item not in except_this] # SPIRAL AND CIRCULAR ACTIVATION DISCARDED
-      
-      activation_add_prob = 1 - activation_add_prob
-      activation_delete_prob = 1 - activation_delete_prob
-      activation_change_prob = 1 - activation_change_prob
+      if potential_activation_mutation > activation_mutate_prob:
+            
+         genome_fitness += epsilon
+         threshold = abs(activation_mutate_threshold / genome_fitness)
+         max_threshold = len(activations)
 
-      probabilities = [random.uniform(0, 1) for _ in range(max_threshold)]
-      new_threshold = threshold
+         new_threshold = threshold
 
-      for p_add, p_delete, p_change in zip(
-         probabilities, random.sample(probabilities, len(probabilities)), random.sample(probabilities, len(probabilities))
-      ):
-         if p_delete > activation_delete_prob and len(activations) > 1:
-            activations.pop(random.randint(0, len(activations) - 1))
+         except_this = ['spiral', 'circular']
+         all_acts = [item for item in all_activations() if item not in except_this] # SPIRAL AND CIRCULAR ACTIVATION DISCARDED
+         
+         activation_add_prob = 1 - activation_add_prob
+         activation_delete_prob = 1 - activation_delete_prob
+         activation_change_prob = 1 - activation_change_prob
 
-         if p_add > activation_add_prob:
-            activations.append(random.choice(all_acts))
+         for _ in range(max_threshold):
 
-         if p_change > activation_change_prob:
-            activations[random.randint(0, len(activations) - 1)] = random.choice(all_acts)
+            potential_activation_add_prob = random.uniform(0, 1)
+            potential_activation_delete_prob = random.uniform(0, 1)
+            potential_activation_change_prob = random.uniform(0, 1)
 
-         new_threshold += threshold
-         if max_threshold <= new_threshold:
-            break
+
+            if potential_activation_delete_prob > activation_delete_prob and len(activations) > 1:
+               
+               random_index = random.randint(0, len(activations) - 1)
+               activations.pop(random_index)
+
+
+            if potential_activation_add_prob > activation_add_prob:
+
+               try:
+                  
+                  random_index_all_act = int(random.uniform(0, len(all_acts)-1))
+                  activations.append(all_acts[random_index_all_act])
+
+               except:
+
+                  activation = activations
+                  activations = []
+
+                  activations.append(activation)
+                  activations.append(all_acts[int(random.uniform(0, len(all_acts)-1))])
+               
+               
+            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))
+
+               activations[random_index_genom_act] = all_acts[random_index_all_act]
+
+            new_threshold += threshold
+
+            if max_threshold > new_threshold: pass
+            else: break
 
    return weight, activations
 

pyerualjetwork/planeat_cuda.py

@@ -583,11 +583,21 @@ def cross_over(first_parent_W,
    if potential_activation_selection_add > activation_selection_add_prob:
       
       threshold = abs(activation_selection_threshold / succes)
-      num_elements = int(len(dominant_parent_act) / threshold)
+      new_threshold = threshold
+      
+      while True:
+         
+         random_index = int(random.uniform(0, len(undominant_parent_act)-1))
+         random_undominant_activation = undominant_parent_act[random_index]
 
-      random_indices = [int(random.uniform(0, len(undominant_parent_act)-1)) for _ in range(num_elements)]
+         child_act.append(random_undominant_activation)
+         new_threshold += threshold
 
-      child_act.extend([undominant_parent_act[i] for i in random_indices])
+         if len(dominant_parent_act) > new_threshold:
+            pass
+         
+         else:
+            break
 
    activation_selection_change_prob = 1 - activation_selection_change_prob
    potential_activation_selection_change_prob = random.uniform(0, 1)
@@ -595,12 +605,22 @@ def cross_over(first_parent_W,
    if potential_activation_selection_change_prob > activation_selection_change_prob:
       
       threshold = abs(activation_selection_threshold / succes)
-      num_elements = min(len(dominant_parent_act), int(threshold))
-
-      random_indices = random.choices(range(len(undominant_parent_act)), k=num_elements)
+      new_threshold = threshold
+      
+      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_undominant_activation = undominant_parent_act[random_index_undominant]
 
-      child_act.extend(undominant_parent_act[i] for i in random_indices)
+         child_act[random_index_dominant] = random_undominant_activation
+         new_threshold += threshold
 
+         if len(dominant_parent_act) > new_threshold:
+            pass
+         
+         else:
+            break
 
    return child_W, child_act
 
@@ -675,50 +695,79 @@ def mutation(weight,
       max_threshold = row_end * col_end
 
       threshold = weight_mutate_threshold * genome_fitness
-      num_mutations = int(max_threshold / threshold)
+      new_threshold = threshold
 
-      selected_rows = cp.random.randint(start, row_end, size=num_mutations)
-      selected_cols = cp.random.randint(start, col_end, size=num_mutations)
-      new_values = cp.random.uniform(-1, 1, size=num_mutations)
-      
-      weight[selected_rows, selected_cols] = new_values
+      for _ in range(max_threshold):
+         
+         selected_row = int(random.uniform(start, row_end))
+         selected_col = int(random.uniform(start, col_end))
 
-   activation_mutate_prob = 1 - activation_mutate_prob
-   potential_activation_mutation = random.uniform(0, 1)
+         weight[selected_row, selected_col] = random.uniform(-1, 1)
+         new_threshold += threshold
 
-   if potential_activation_mutation > activation_mutate_prob:
-      
-      genome_fitness += epsilon
-      threshold = abs(activation_mutate_threshold / genome_fitness)
-      max_threshold = len(activations)
+         if max_threshold > new_threshold:
+            pass
+         
+         else:
+            break
 
-      new_threshold = threshold
-      
-      except_this = ['spiral', 'circular']
-      all_acts = [item for item in all_activations() if item not in except_this] # SPIRAL AND CIRCULAR ACTIVATION DISCARDED
-      
-      activation_add_prob = 1 - activation_add_prob
-      activation_delete_prob = 1 - activation_delete_prob
-      activation_change_prob = 1 - activation_change_prob
+      activation_mutate_prob = 1 - activation_mutate_prob
+      potential_activation_mutation = random.uniform(0, 1)
 
-      probabilities = [random.uniform(0, 1) for _ in range(max_threshold)]
-      new_threshold = threshold
+      if potential_activation_mutation > activation_mutate_prob:
+         
+         genome_fitness += epsilon
+         threshold = abs(activation_mutate_threshold / genome_fitness)
+         max_threshold = len(activations)
 
-      for p_add, p_delete, p_change in zip(
-         probabilities, random.sample(probabilities, len(probabilities)), random.sample(probabilities, len(probabilities))
-      ):
-         if p_delete > activation_delete_prob and len(activations) > 1:
-            activations.pop(random.randint(0, len(activations) - 1))
+         new_threshold = threshold
+         
+         except_this = ['spiral', 'circular']
+         all_acts = [item for item in all_activations() if item not in except_this] # SPIRAL AND CIRCULAR ACTIVATION DISCARDED
+         
+         activation_add_prob = 1 - activation_add_prob
+         activation_delete_prob = 1 - activation_delete_prob
+         activation_change_prob = 1 - activation_change_prob
 
-         if p_add > activation_add_prob:
-            activations.append(random.choice(all_acts))
+         for _ in range(max_threshold):
 
-         if p_change > activation_change_prob:
-            activations[random.randint(0, len(activations) - 1)] = random.choice(all_acts)
+            potential_activation_add_prob = random.uniform(0, 1)
+            potential_activation_delete_prob = random.uniform(0, 1)
+            potential_activation_change_prob = random.uniform(0, 1)
 
-         new_threshold += threshold
-         if max_threshold <= new_threshold:
-            break
+            
+            if potential_activation_delete_prob > activation_delete_prob and len(activations) > 1:
+               
+               random_index = random.randint(0, len(activations) - 1)
+               activations.pop(random_index)
+               
+
+            if potential_activation_add_prob > activation_add_prob:
+
+               try:
+                  
+                  random_index_all_act = int(random.uniform(0, len(all_acts)-1))
+                  activations.append(all_acts[random_index_all_act])
+
+               except:
+
+                  activation = activations
+                  activations = []
+
+                  activations.append(activation)
+                  activations.append(all_acts[int(random.uniform(0, len(all_acts)-1))])
+               
+            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))
+
+               activations[random_index_genom_act] = all_acts[random_index_all_act]
+
+            new_threshold += threshold
+
+            if max_threshold > new_threshold: pass
+            else: break
 
    return weight, activations
 

{pyerualjetwork-4.3.9b5.dist-info → pyerualjetwork-4.3.9b6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyerualjetwork
-Version: 4.3.9b5
+Version: 4.3.9b6
 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.3.9b5.dist-info → pyerualjetwork-4.3.9b6.dist-info}/RECORD

@@ -1,4 +1,4 @@
-pyerualjetwork/__init__.py,sha256=TnfMF6gtFWhR_THUVWop8fLHqEWcVy-Y5orYzXPO7XQ,641
+pyerualjetwork/__init__.py,sha256=koxM5MI-uTn5QAa9WgTtktH9ZJMJeFvU-lqLBGDbHt8,641
 pyerualjetwork/activation_functions.py,sha256=bKf00lsuuLJNO-4vVp4OqBi4zJ-qZ8L3v-vl52notkY,7721
 pyerualjetwork/activation_functions_cuda.py,sha256=5y1Ti3GDfDteQDCUmODwe7tAyDAUlDTKmIikChQ8d6g,7772
 pyerualjetwork/data_operations.py,sha256=Flteouu6rfSo2uHMqBHuzO02dXmbNa-I5qWmUpGTZ5Y,14760
@@ -11,14 +11,14 @@ pyerualjetwork/metrics.py,sha256=q7MkhnZDRbCjFBDDfUgrl8lBYnUT_1ro1LxeBq105pI,607
 pyerualjetwork/metrics_cuda.py,sha256=73h9GC7XwmnFCVzFEEiPQfF8CwHIz2wsCbxpZrJtYgw,5061
 pyerualjetwork/model_operations.py,sha256=MCSCNYiiICRVZITobtS3ZIWmH5Q9gjyELuH32sAdgg4,12649
 pyerualjetwork/model_operations_cuda.py,sha256=NT01BK5nrDYE7H1x3KnSI8gmx0QTGGB0mP_LqEb1uuU,13157
-pyerualjetwork/plan.py,sha256=uK-7GRXqH0ETIajOW6_B6pSyktKmHg1NE4COD7z1f7E,23536
-pyerualjetwork/plan_cuda.py,sha256=tNez_xvK6yuUiwotopqtERAJUCc7RiLx7W8VEG7RoQY,24392
-pyerualjetwork/planeat.py,sha256=SeCbFebOlThMNTMX-acgVZswuztF22m_G2E4MRCSDs0,36231
-pyerualjetwork/planeat_cuda.py,sha256=XIDJwZAuQyzrBvFyQtbnfTUWRWDPGFmM3SfUXBa8foA,36233
+pyerualjetwork/plan.py,sha256=mcVxwBus_GwfYjWLMwx8KDc25uJT8l773l-mHCfa0Xk,23558
+pyerualjetwork/plan_cuda.py,sha256=8uEyYdQQX122Hcc-XfFoPSiCeLADt-y-cGX3AuRYPt0,24440
+pyerualjetwork/planeat.py,sha256=uRX-hDywGOai6hHhbYrmcRodNZOg4WCQeJWZbdMlZs8,39470
+pyerualjetwork/planeat_cuda.py,sha256=aTdBmhJeIKC58pssODtqVsdOtJP7W6TRmVyGHp7k_CM,37612
 pyerualjetwork/ui.py,sha256=wu2BhU1k-w3Kcho5Jtq4SEKe68ftaUeRGneUOSCVDjU,575
 pyerualjetwork/visualizations.py,sha256=08O5uEewuYiovZRX1uHWEHjn19LcnhndWYvqVN74xs0,28290
 pyerualjetwork/visualizations_cuda.py,sha256=PYRqj4QYUbuYMYcNwO8yaTPB-jK7E6kZHhTrAi0lwPU,28749
-pyerualjetwork-4.3.9b5.dist-info/METADATA,sha256=uOQkxMNenLMBcte5_XCjm8H-Q6Bo4Hm-L2k-XNq7jXc,7476
-pyerualjetwork-4.3.9b5.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
-pyerualjetwork-4.3.9b5.dist-info/top_level.txt,sha256=BRyt62U_r3ZmJpj-wXNOoA345Bzamrj6RbaWsyW4tRg,15
-pyerualjetwork-4.3.9b5.dist-info/RECORD,,
+pyerualjetwork-4.3.9b6.dist-info/METADATA,sha256=G5E_5NHaNjMFmJH2KbZ4MK8DFR0Dc6YFDjJhRHVGvBc,7476
+pyerualjetwork-4.3.9b6.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
+pyerualjetwork-4.3.9b6.dist-info/top_level.txt,sha256=BRyt62U_r3ZmJpj-wXNOoA345Bzamrj6RbaWsyW4tRg,15
+pyerualjetwork-4.3.9b6.dist-info/RECORD,,