pyerualjetwork 4.3.12__py3-none-any.whl → 4.3.13__py3-none-any.whl

pyerualjetwork/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "4.3.12"
+__version__ = "4.3.13"
 __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/plan.py

@@ -84,7 +84,7 @@ def fit(
 
 
 def learner(x_train, y_train, optimizer, fit_start=True, gen=None, batch_size=1, pop_size=None,
-           neural_web_history=False, show_current_activations=False, auto_normalization=False,
+           weight_evolve=False, neural_web_history=False, show_current_activations=False, auto_normalization=False,
            neurons_history=False, early_stop=False, show_history=False, target_loss=None,
            interval=33.33, target_acc=None, loss='categorical_crossentropy', acc_impact=0.9, loss_impact=0.1,
            start_this_act=None, start_this_W=None, dtype=np.float32):
@@ -119,6 +119,9 @@ def learner(x_train, y_train, optimizer, fit_start=True, gen=None, batch_size=1,
                              batch_size=0.05,
                              interval=16.67)
         ```
+        
+        weight_evolve (bool, optional): Activation combinations already optimizes by PLANEAT genetic search algorithm. Should the weight parameters also evolve or should the weights be determined according to the aggregating learning principle of the PLAN algorithm? Default: True (Evolves Weights)
+        
         loss (str, optional): options: ('categorical_crossentropy' or 'binary_crossentropy') Default is 'categorical_crossentropy'.
 
         target_acc (float, optional): The target accuracy to stop training early when achieved. Default is None.
@@ -232,6 +235,9 @@ def learner(x_train, y_train, optimizer, fit_start=True, gen=None, batch_size=1,
                     W = fit(x_train_batch, y_train_batch, activation_potentiation=act_pop[j], auto_normalization=auto_normalization, dtype=dtype)
                     weight_pop[j] = W
             
+            if weight_evolve is False:
+                weight_pop[j] = fit(x_train_batch, y_train_batch, activation_potentiation=act_pop[j], auto_normalization=auto_normalization, dtype=dtype)
+                
             model = evaluate(x_train_batch, y_train_batch, W=weight_pop[j], activation_potentiation=act_pop[j])
             acc = model[get_acc()]
             
@@ -351,7 +357,7 @@ def learner(x_train, y_train, optimizer, fit_start=True, gen=None, batch_size=1,
             best_acc_per_gen_list.append(best_acc)
             loss_list.append(best_loss)
 
-        weight_pop, act_pop = optimizer(np.array(weight_pop, copy=False, dtype=dtype), act_pop, i, np.array(target_pop, dtype=dtype, copy=False), bar_status=False)
+        weight_pop, act_pop = optimizer(np.array(weight_pop, copy=False, dtype=dtype), act_pop, i, np.array(target_pop, dtype=dtype, copy=False), weight_evolve=weight_evolve, bar_status=False)
         target_pop = []
 
         # Early stopping check

pyerualjetwork/plan_cuda.py

@@ -83,7 +83,7 @@ def fit(
 
 
 def learner(x_train, y_train, optimizer, fit_start=True, gen=None, batch_size=1, pop_size=None,
-           neural_web_history=False, show_current_activations=False, auto_normalization=False, target_acc=None,
+           weight_evolve=False, neural_web_history=False, show_current_activations=False, auto_normalization=False, target_acc=None,
            neurons_history=False, early_stop=False, show_history=False, loss='categorical_crossentropy',
            interval=33.33, target_loss=None, loss_impact=0.1, acc_impact=0.9,
            start_this_act=None, start_this_W=None, dtype=cp.float32, memory='gpu'):
@@ -118,6 +118,9 @@ def learner(x_train, y_train, optimizer, fit_start=True, gen=None, batch_size=1,
                                 batch_size=0.05,
                                 interval=16.67)
         ```
+        
+        weight_evolve (bool, optional): Activation combinations already optimizes by PLANEAT genetic search algorithm. Should the weight parameters also evolve or should the weights be determined according to the aggregating learning principle of the PLAN algorithm? Default: True (Evolves Weights)
+
         loss (str, optional): For visualizing and monitoring. PLAN neural networks doesn't need any loss function in training. options: ('categorical_crossentropy' or 'binary_crossentropy') Default is 'categorical_crossentropy'.
 
         target_acc (float, optional): The target accuracy to stop training early when achieved. Default is None.
@@ -247,6 +250,9 @@ def learner(x_train, y_train, optimizer, fit_start=True, gen=None, batch_size=1,
                     W = fit(x_train_batch, y_train_batch, activation_potentiation=act_pop[j], auto_normalization=auto_normalization, dtype=dtype)
                     weight_pop[j] = W
                     
+            if weight_evolve is False:
+                weight_pop[j] = fit(x_train_batch, y_train_batch, activation_potentiation=act_pop[j], auto_normalization=auto_normalization, dtype=dtype) 
+            
             model = evaluate(x_train_batch, y_train_batch, W=weight_pop[j], activation_potentiation=act_pop[j])
             acc = model[get_acc()]
  
@@ -367,7 +373,7 @@ def learner(x_train, y_train, optimizer, fit_start=True, gen=None, batch_size=1,
             best_acc_per_gen_list.append(best_acc)
             loss_list.append(best_loss)
 
-        weight_pop, act_pop = optimizer(cp.array(weight_pop, copy=False, dtype=dtype), act_pop, i, cp.array(target_pop, dtype=dtype, copy=False), bar_status=False)
+        weight_pop, act_pop = optimizer(cp.array(weight_pop, copy=False, dtype=dtype), act_pop, i, cp.array(target_pop, dtype=dtype, copy=False), weight_evolve=weight_evolve, bar_status=False)
         target_pop = []
 
         # Early stopping check

pyerualjetwork/planeat.py

@@ -73,7 +73,8 @@ def define_genomes(input_shape, output_shape, population_size, dtype=np.float32)
 def evolver(weights, 
             activation_potentiations, 
             what_gen, 
-            fitness, 
+            fitness,
+            weight_evolve=True,
             show_info=False, 
             policy='aggressive', 
             bad_genomes_selection_prob=None, 
@@ -112,6 +113,8 @@ def evolver(weights,
       fitness (numpy.ndarray): A 1D array containing the fitness values of each genome. 
          The array is used to rank the genomes based on their performance. PLANEAT maximizes or minimizes this fitness based on the `target_fitness` parameter.
       
+      weight_evolve (bool, optional): Are weights to be evolves or just activation combinations Default: True. Note: Regardless of whether this parameter is True or False, you must give the evolver function a list of weights equal to the number of activation potentiations. You can create completely random weights if you want. If this parameter is False, the weights entering the evolver function and the resulting weights will be exactly the same.
+      
       show_info (bool, optional): If True, prints information about the current generation and the 
          maximum reward obtained. Also shows the current configuration. Default is False.
       
@@ -261,7 +264,8 @@ def evolver(weights,
    else:
       raise ValueError("genome population size must be even number. for example: not 99, make 100 or 98.")
 
-   
+   if weight_evolve is False: origin_weights = np.copy(weights)
+
 ### 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)
@@ -325,6 +329,7 @@ def evolver(weights,
                                              first_parent_fitness=best_fitness,
                                              fitness_bias=fitness_bias,
                                              second_parent_fitness=normalized_fitness[s_i],
+                                             weight_evolve=weight_evolve,
                                              epsilon=epsilon
                                              )
 
@@ -352,6 +357,7 @@ def evolver(weights,
                                              weight_mutate_threshold=weight_mutate_threshold,
                                              genome_fitness=normalized_fitness[fitness_index],
                                              activation_mutate_threshold=activation_mutate_threshold,
+                                             weight_evolve=weight_evolve,
                                              epsilon=epsilon
                                              )
 
@@ -397,6 +403,7 @@ def evolver(weights,
       print("  BEST GENOME INDEX: ", str(0))
       print("  NOTE: The returned genome at the first index is the best of the previous generation." + '\n')
       
+   if weight_evolve is False: weights = origin_weights
 
    return weights, activation_potentiations
 
@@ -452,6 +459,7 @@ def cross_over(first_parent_W,
                first_parent_fitness,
                second_parent_fitness,
                fitness_bias,
+               weight_evolve,
                epsilon):
    """
     Performs a crossover operation on two sets of weights and activation functions.
@@ -486,6 +494,8 @@ def cross_over(first_parent_W,
         
         fitness_bias (float): A bias factor used to favor fitter parents during crossover operations.
 
+        weight_evolve (bool, optional): Are weights to be evolves or just activation combinations.
+
         epsilon (float): Small epsilon constant
 
     Returns:
@@ -513,6 +523,7 @@ def cross_over(first_parent_W,
             first_parent_fitness=0.9,
             second_parent_fitness=0.85,
             fitness_bias=0.6,
+            weight_evolve=True,
             epsilon=np.finfo(float).eps
         )
         ```
@@ -546,33 +557,37 @@ def cross_over(first_parent_W,
       undominant_parent_act = first_parent_act
       succes = first_parent_fitness + epsilon
 
-   while True:
+   if weight_evolve is True:
 
-      row_cut_start = int(random.uniform(start, row_end))
-      col_cut_start = int(random.uniform(start, col_end))
+      while True:
 
-      row_cut_end = int(random.uniform(start, row_end))
-      col_cut_end = int(random.uniform(start, col_end))
+         row_cut_start = int(random.uniform(start, row_end))
+         col_cut_start = int(random.uniform(start, col_end))
 
-      if ((row_cut_end > row_cut_start) and
-         (col_cut_end > col_cut_start) and
-         (((row_cut_end + 1) - (row_cut_start + 1) * 2) + ((col_cut_end + 1) - (col_cut_start + 1) * 2) <= half_of_gene)):
-         break
-      
-      selection_bias = random.uniform(0, 1)
+         row_cut_end = int(random.uniform(start, row_end))
+         col_cut_end = int(random.uniform(start, col_end))
 
-      if fitness_bias > selection_bias:
-         row_cut_start = math.floor(row_cut_start * succes)
-         row_cut_end = math.ceil(row_cut_end * succes)
+         if ((row_cut_end > row_cut_start) and
+            (col_cut_end > col_cut_start) and
+            (((row_cut_end + 1) - (row_cut_start + 1) * 2) + ((col_cut_end + 1) - (col_cut_start + 1) * 2) <= half_of_gene)):
+            break
+         
+         selection_bias = random.uniform(0, 1)
 
-         col_cut_start = math.floor(col_cut_start * succes)
-         col_cut_end = math.ceil(col_cut_end * succes)
+         if fitness_bias > selection_bias:
+            row_cut_start = math.floor(row_cut_start * succes)
+            row_cut_end = math.ceil(row_cut_end * succes)
 
-   child_W = dominant_parent_W
+            col_cut_start = math.floor(col_cut_start * succes)
+            col_cut_end = math.ceil(col_cut_end * succes)
 
-   if cross_over_mode == 'tpm':
-      child_W[row_cut_start:row_cut_end, col_cut_start:col_cut_end] = undominant_parent_W[row_cut_start:row_cut_end, col_cut_start:col_cut_end]
+      child_W = dominant_parent_W
 
+      if cross_over_mode == 'tpm':
+         child_W[row_cut_start:row_cut_end, col_cut_start:col_cut_end] = undominant_parent_W[row_cut_start:row_cut_end, col_cut_start:col_cut_end]
+   
+   else: child_W = dominant_parent_W
+   
    if isinstance(dominant_parent_act, str): dominant_parent_act = [dominant_parent_act]
    if isinstance(undominant_parent_act, str): undominant_parent_act = [undominant_parent_act]
 
@@ -635,6 +650,7 @@ def mutation(weight,
              weight_mutate_threshold, 
              genome_fitness,
              activation_mutate_threshold,
+             weight_evolve,
              epsilon):
    """
     Performs mutation on the given weight matrix and activation functions.
@@ -662,6 +678,8 @@ def mutation(weight,
 
         activation_mutate_threshold (float): Determines max how much activation mutaiton operation applying. (Function automaticly determines to min) 
 
+        weight_evolve (bool, optional): Are weights to be mutates or just activation combinations.
+        
         epsilon (float): Small epsilon constant
 
     Returns:
@@ -683,92 +701,94 @@ def mutation(weight,
 
    if isinstance(activations, str): activations = [activations]
 
-   weight_mutate_prob = 1 - weight_mutate_prob # if prob 0.8 (%80) then 1 - 0.8. Because 0-1 random number probably greater than 0.2
-   potential_weight_mutation = random.uniform(0, 1)
+   if weight_evolve is True:
 
-   if potential_weight_mutation > weight_mutate_prob:
+      weight_mutate_prob = 1 - weight_mutate_prob # if prob 0.8 (%80) then 1 - 0.8. Because 0-1 random number probably greater than 0.2
+      potential_weight_mutation = random.uniform(0, 1)
 
-      start = 0
-      row_end = weight.shape[0]
-      col_end = weight.shape[1]
+      if potential_weight_mutation > weight_mutate_prob:
 
-      max_threshold = row_end * col_end
+         start = 0
+         row_end = weight.shape[0]
+         col_end = weight.shape[1]
 
-      threshold = weight_mutate_threshold * (genome_fitness + epsilon)
-      new_threshold = threshold
-      
-      for _ in range(max_threshold):
-         
-         selected_row = int(random.uniform(start, row_end))
-         selected_col = int(random.uniform(start, col_end))
-
-         weight[selected_row, selected_col] = random.uniform(-1, 1)
-         new_threshold += threshold
+         max_threshold = row_end * col_end
 
-         if max_threshold > new_threshold:
-            pass
+         threshold = weight_mutate_threshold * (genome_fitness + epsilon)
+         new_threshold = threshold
          
-         else:
-            break
+         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
+   if potential_activation_mutation > activation_mutate_prob:
          
-         activation_add_prob = 1 - activation_add_prob
-         activation_delete_prob = 1 - activation_delete_prob
-         activation_change_prob = 1 - activation_change_prob
+      genome_fitness += epsilon
+      threshold = abs(activation_mutate_threshold / genome_fitness)
+      max_threshold = len(activations)
 
-         for _ in range(max_threshold):
-
-            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
 
+      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_delete_prob > activation_delete_prob and len(activations) > 1:
-               
-               random_index = random.randint(0, len(activations) - 1)
-               activations.pop(random_index)
+      for _ in range(max_threshold):
 
+         potential_activation_add_prob = random.uniform(0, 1)
+         potential_activation_delete_prob = random.uniform(0, 1)
+         potential_activation_change_prob = random.uniform(0, 1)
 
-            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])
+         if potential_activation_delete_prob > activation_delete_prob and len(activations) > 1:
+            
+            random_index = random.randint(0, len(activations) - 1)
+            activations.pop(random_index)
 
-               except:
 
-                  activation = activations
-                  activations = []
+         if potential_activation_add_prob > activation_add_prob:
 
-                  activations.append(activation)
-                  activations.append(all_acts[int(random.uniform(0, len(all_acts)-1))])
-               
-               
-            if potential_activation_change_prob > activation_change_prob:
+            try:
                
                random_index_all_act = int(random.uniform(0, len(all_acts)-1))
-               random_index_genom_act = int(random.uniform(0, len(activations)-1))
+               activations.append(all_acts[random_index_all_act])
 
-               activations[random_index_genom_act] = all_acts[random_index_all_act]
+            except:
 
-            new_threshold += threshold
+               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
+         if max_threshold > new_threshold: pass
+         else: break
 
    return weight, activations
 

pyerualjetwork/planeat_cuda.py

@@ -75,7 +75,8 @@ def define_genomes(input_shape, output_shape, population_size, dtype=cp.float32)
 def evolver(weights, 
             activation_potentiations, 
             what_gen, 
-            fitness, 
+            fitness,
+            weight_evolve=True,
             show_info=False, 
             policy='aggressive', 
             bad_genomes_selection_prob=None, 
@@ -114,6 +115,8 @@ def evolver(weights,
       fitness (cupy.ndarray): A 1D array containing the fitness values of each genome. 
          The array is used to rank the genomes based on their performance. PLANEAT maximizes or minimizes this fitness based on the `target_fitness` parameter.
       
+      weight_evolve (bool, optional): Are weights to be evolves or just activation combinations Default: True. Note: Regardless of whether this parameter is True or False, you must give the evolver function a list of weights equal to the number of activation potentiations. You can create completely random weights if you want. If this parameter is False, the weights entering the evolver function and the resulting weights will be exactly the same.
+
       show_info (bool, optional): If True, prints information about the current generation and the 
          maximum reward obtained. Also shows the current configuration. Default is False.
       
@@ -262,6 +265,8 @@ def evolver(weights,
    else:
       raise ValueError("genome population size must be even number. for example: not 99, make 100 or 98.")
 
+   if weight_evolve is False: origin_weights = cp.copy(weights)
+
 ### 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)
@@ -325,6 +330,7 @@ def evolver(weights,
                                              first_parent_fitness=best_fitness,
                                              fitness_bias=fitness_bias,
                                              second_parent_fitness=normalized_fitness[s_i],
+                                             weight_evolve=weight_evolve,
                                              epsilon=epsilon
                                              )
   
@@ -352,6 +358,7 @@ def evolver(weights,
                                              weight_mutate_threshold=weight_mutate_threshold,
                                              genome_fitness=normalized_fitness[fitness_index],
                                              activation_mutate_threshold=activation_mutate_threshold,
+                                             weight_evolve=weight_evolve,
                                              epsilon=epsilon
                                              )
             
@@ -396,6 +403,7 @@ def evolver(weights,
       print("  BEST GENOME INDEX: ", str(0))
       print("  NOTE: The returned genome at the first index is the best of the previous generation." + '\n')
       
+   if weight_evolve is False: weights = origin_weights
 
    return weights, activation_potentiations
 
@@ -452,6 +460,7 @@ def cross_over(first_parent_W,
                first_parent_fitness,
                second_parent_fitness,
                fitness_bias,
+               weight_evolve,
                epsilon):
    """
     Performs a crossover operation on two sets of weights and activation functions.
@@ -486,6 +495,8 @@ def cross_over(first_parent_W,
         
         fitness_bias (float): A bias factor used to favor fitter parents during crossover operations.
 
+        weight_evolve (bool, optional): Are weights to be evolves or just activation combinations.
+
         epsilon (float): Small epsilon constant
 
     Returns:
@@ -513,6 +524,7 @@ def cross_over(first_parent_W,
             first_parent_fitness=0.9,
             second_parent_fitness=0.85,
             fitness_bias=0.6,
+            weight_evolve=True,
             epsilon=cp.finfo(float).eps
         )
         ```
@@ -546,33 +558,35 @@ def cross_over(first_parent_W,
       undominant_parent_act = first_parent_act
       succes = first_parent_fitness + epsilon
 
-   while True:
-
-      row_cut_start = int(random.uniform(start, row_end))
-      col_cut_start = int(random.uniform(start, col_end))
+   if weight_evolve is True:
+      while True:
 
-      row_cut_end = int(random.uniform(start, row_end))
-      col_cut_end = int(random.uniform(start, col_end))
+         row_cut_start = int(random.uniform(start, row_end))
+         col_cut_start = int(random.uniform(start, col_end))
 
-      if ((row_cut_end > row_cut_start) and
-         (col_cut_end > col_cut_start) and
-         (((row_cut_end + 1) - (row_cut_start + 1) * 2) + ((col_cut_end + 1) - (col_cut_start + 1) * 2) <= half_of_gene)):
-         break
-      
-      selection_bias = random.uniform(0, 1)
+         row_cut_end = int(random.uniform(start, row_end))
+         col_cut_end = int(random.uniform(start, col_end))
 
-      if fitness_bias > selection_bias:
-         row_cut_start = math.floor(row_cut_start * succes)
-         row_cut_end = math.ceil(row_cut_end * succes)
+         if ((row_cut_end > row_cut_start) and
+            (col_cut_end > col_cut_start) and
+            (((row_cut_end + 1) - (row_cut_start + 1) * 2) + ((col_cut_end + 1) - (col_cut_start + 1) * 2) <= half_of_gene)):
+            break
+         
+         selection_bias = random.uniform(0, 1)
 
-         col_cut_start = math.floor(col_cut_start * succes)
-         col_cut_end = math.ceil(col_cut_end * succes)
+         if fitness_bias > selection_bias:
+            row_cut_start = math.floor(row_cut_start * succes)
+            row_cut_end = math.ceil(row_cut_end * succes)
 
-   child_W = dominant_parent_W
+            col_cut_start = math.floor(col_cut_start * succes)
+            col_cut_end = math.ceil(col_cut_end * succes)
 
-   if cross_over_mode == 'tpm':
-      child_W[row_cut_start:row_cut_end, col_cut_start:col_cut_end] = undominant_parent_W[row_cut_start:row_cut_end, col_cut_start:col_cut_end]
+      child_W = dominant_parent_W
 
+      if cross_over_mode == 'tpm':
+         child_W[row_cut_start:row_cut_end, col_cut_start:col_cut_end] = undominant_parent_W[row_cut_start:row_cut_end, col_cut_start:col_cut_end]
+   
+   else: child_W = dominant_parent_W
 
    if isinstance(dominant_parent_act, str): dominant_parent_act = [dominant_parent_act]
    if isinstance(undominant_parent_act, str): undominant_parent_act = [undominant_parent_act]
@@ -637,6 +651,7 @@ def mutation(weight,
              weight_mutate_threshold, 
              genome_fitness,
              activation_mutate_threshold,
+             weight_evolve,
              epsilon):
    """
     Performs mutation on the given weight matrix and activation functions.
@@ -664,6 +679,8 @@ def mutation(weight,
     
         activation_mutate_threshold (float): Determines max how much activation mutaiton operation applying. (Function automaticly determines to min) 
 
+        weight_evolve (bool, optional): Are weights to be mutates or just activation combinations.
+
         epsilon (float): Small epsilon constant
 
     Returns:
@@ -685,91 +702,93 @@ def mutation(weight,
 
    if isinstance(activations, str): activations = [activations]
 
-   weight_mutate_prob = 1 - weight_mutate_prob # if prob 0.8 (%80) then 1 - 0.8. Because 0-1 random number probably greater than 0.2
-   potential_weight_mutation = random.uniform(0, 1)
+   if weight_evolve is True:
 
-   if potential_weight_mutation > weight_mutate_prob:
+      weight_mutate_prob = 1 - weight_mutate_prob # if prob 0.8 (%80) then 1 - 0.8. Because 0-1 random number probably greater than 0.2
+      potential_weight_mutation = random.uniform(0, 1)
 
-      start = 0
-      row_end = weight.shape[0]
-      col_end = weight.shape[1]
-      
-      max_threshold = row_end * col_end
-
-      threshold = weight_mutate_threshold * (genome_fitness + epsilon)
-      new_threshold = threshold
+      if potential_weight_mutation > weight_mutate_prob:
 
-      for _ in range(max_threshold):
-         
-         selected_row = int(random.uniform(start, row_end))
-         selected_col = int(random.uniform(start, col_end))
-
-         weight[selected_row, selected_col] = random.uniform(-1, 1)
-         new_threshold += threshold
-
-         if max_threshold > new_threshold:
-            pass
+         start = 0
+         row_end = weight.shape[0]
+         col_end = weight.shape[1]
          
-         else:
-            break
-
-      activation_mutate_prob = 1 - activation_mutate_prob
-      potential_activation_mutation = random.uniform(0, 1)
-
-      if potential_activation_mutation > activation_mutate_prob:
-         
-         genome_fitness += epsilon
-         threshold = abs(activation_mutate_threshold / genome_fitness)
-         max_threshold = len(activations)
+         max_threshold = row_end * col_end
 
+         threshold = weight_mutate_threshold * (genome_fitness + epsilon)
          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
 
          for _ in range(max_threshold):
+            
+            selected_row = int(random.uniform(start, row_end))
+            selected_col = int(random.uniform(start, col_end))
 
-            potential_activation_add_prob = random.uniform(0, 1)
-            potential_activation_delete_prob = random.uniform(0, 1)
-            potential_activation_change_prob = random.uniform(0, 1)
+            weight[selected_row, selected_col] = random.uniform(-1, 1)
+            new_threshold += threshold
 
+            if max_threshold > new_threshold:
+               pass
             
-            if potential_activation_delete_prob > activation_delete_prob and len(activations) > 1:
-               
-               random_index = random.randint(0, len(activations) - 1)
-               activations.pop(random_index)
-               
+            else:
+               break
 
-            if potential_activation_add_prob > activation_add_prob:
+   activation_mutate_prob = 1 - activation_mutate_prob
+   potential_activation_mutation = random.uniform(0, 1)
 
-               try:
-                  
-                  random_index_all_act = int(random.uniform(0, len(all_acts)-1))
-                  activations.append(all_acts[random_index_all_act])
+   if potential_activation_mutation > activation_mutate_prob:
+      
+      genome_fitness += epsilon
+      threshold = abs(activation_mutate_threshold / genome_fitness)
+      max_threshold = len(activations)
 
-               except:
+      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 = activations
-                  activations = []
+      for _ in range(max_threshold):
 
-                  activations.append(activation)
-                  activations.append(all_acts[int(random.uniform(0, len(all_acts)-1))])
-               
-            if potential_activation_change_prob > activation_change_prob:
+         potential_activation_add_prob = random.uniform(0, 1)
+         potential_activation_delete_prob = random.uniform(0, 1)
+         potential_activation_change_prob = random.uniform(0, 1)
+
+         
+         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))
-               random_index_genom_act = int(random.uniform(0, len(activations)-1))
+               activations.append(all_acts[random_index_all_act])
 
-               activations[random_index_genom_act] = all_acts[random_index_all_act]
+            except:
 
-            new_threshold += threshold
+               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
+         if max_threshold > new_threshold: pass
+         else: break
 
    return weight, activations
 

pyerualjetwork/visualizations.py

@@ -300,9 +300,9 @@ def draw_activations(x_train, activation):
 
     elif activation == 'cubic_quadratic':
         result = af.cubic_quadratic(x_train)
-
-    elif activation == 'exp_cubic':
-        result = af.exp_cubic(x_train)
+    
+    #elif activation == 'exp_cubic':
+        #result = af.exp_cubic(x_train)
 
     elif activation == 'sine_square':
         result = af.sine_square(x_train)

{pyerualjetwork-4.3.12.dist-info → pyerualjetwork-4.3.13.dist-info}/METADATA

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

@@ -1,4 +1,4 @@
-pyerualjetwork/__init__.py,sha256=fJItQArSdhwY3VlHiV7LjyWy21XGRdOUPNaHZIyWFow,1280
+pyerualjetwork/__init__.py,sha256=8QxVhLrF9q38cHUgWG-XtQMIkD9w6SgPTgnyjl5PiG8,1280
 pyerualjetwork/activation_functions.py,sha256=Ms0AGBqkJuCA42ht64MSQnO54Td_1eDGquedpoBDVbc,7642
 pyerualjetwork/activation_functions_cuda.py,sha256=5y1Ti3GDfDteQDCUmODwe7tAyDAUlDTKmIikChQ8d6g,7772
 pyerualjetwork/data_operations.py,sha256=Flteouu6rfSo2uHMqBHuzO02dXmbNa-I5qWmUpGTZ5Y,14760
@@ -12,14 +12,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=36ZkwcE8HVkx_WIFbfGe4xAjUPwL0KrJQmI-3_NuryQ,22391
-pyerualjetwork/plan_cuda.py,sha256=qVhAG2ZS1zudygegILPQD5gEWWCm8-JhMvNtFtoxuds,23394
-pyerualjetwork/planeat.py,sha256=4BVC7km2O93hB5qK3q6-GB4sO-2WHwio9E780_e49Cs,37721
-pyerualjetwork/planeat_cuda.py,sha256=8ftHNWD3DXKHXF9JHjmoRhM7ylcVLWmYCMSyIcVpSjg,37776
+pyerualjetwork/plan.py,sha256=X2mzc9s36xCzUy0SzKeimbeVVlvajhOpXDaME8x83yQ,22974
+pyerualjetwork/plan_cuda.py,sha256=l-2xK2vu-SM64EEOOA8GXsfbXTUNcSL6Sc3ora5Ze3k,23966
+pyerualjetwork/planeat.py,sha256=oAu0a2rs6BQ2HUpLjKFR4m7xDbhUVOzLstop75u35Tg,38889
+pyerualjetwork/planeat_cuda.py,sha256=E_pJEsNKfiF97FvGZGSsxmdqzLAJub05enmneymozcg,38922
 pyerualjetwork/ui.py,sha256=wu2BhU1k-w3Kcho5Jtq4SEKe68ftaUeRGneUOSCVDjU,575
-pyerualjetwork/visualizations.py,sha256=t1BqnFUH5jKiPdFMI2kWjFg6-amrBV0wvW05aD77NQs,28288
+pyerualjetwork/visualizations.py,sha256=1QSisYAaGnO5kug6qo1qOssTkQM-MgR7L8h4c3sczzU,28294
 pyerualjetwork/visualizations_cuda.py,sha256=PYRqj4QYUbuYMYcNwO8yaTPB-jK7E6kZHhTrAi0lwPU,28749
-pyerualjetwork-4.3.12.dist-info/METADATA,sha256=9SFZMDzualijFQdFP8B5qs_DKIi0xX8Vfj8lWCJxpPk,7506
-pyerualjetwork-4.3.12.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
-pyerualjetwork-4.3.12.dist-info/top_level.txt,sha256=BRyt62U_r3ZmJpj-wXNOoA345Bzamrj6RbaWsyW4tRg,15
-pyerualjetwork-4.3.12.dist-info/RECORD,,
+pyerualjetwork-4.3.13.dist-info/METADATA,sha256=yGTaFrahQ_b369UOVc11vEtUGG3My1ykykLcJ7e3Jmg,7506
+pyerualjetwork-4.3.13.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
+pyerualjetwork-4.3.13.dist-info/top_level.txt,sha256=BRyt62U_r3ZmJpj-wXNOoA345Bzamrj6RbaWsyW4tRg,15
+pyerualjetwork-4.3.13.dist-info/RECORD,,