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

pyerualjetwork/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "4.3.11"
+__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,13 +119,19 @@ def learner(x_train, y_train, optimizer, fit_start=True, gen=None, batch_size=1,
                              batch_size=0.05,
                              interval=16.67)
         ```
-
-        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'.
+        
+        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.
 
         target_loss (float, optional): The target loss to stop training early when achieved. Default is None.
         
+        acc_impact (float, optional): Impact of accuracy for optimization [0-1]. Default: 0.9
+
+        loss_impact (float, optional): Impact of loss for optimization [0-1]. Default: 0.1
+        
         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
 
         gen (int, optional): The generation count for genetic optimization.
@@ -229,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()]
             
@@ -348,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.
@@ -130,9 +133,9 @@ def learner(x_train, y_train, optimizer, fit_start=True, gen=None, batch_size=1,
 
         batch_size (float, optional): Batch size is used in the prediction process to receive train feedback by dividing the train data into chunks and selecting activations based on randomly chosen partitions. This process reduces computational cost and time while still covering the entire test set due to random selection, so it doesn't significantly impact accuracy. For example, a batch size of 0.08 means each train batch represents 8% of the train set. Default is 1. (%100 of train)
 
-        loss_impact (float, optional): Impact of loss during evolve. [0-1] Default: 0.1
+        acc_impact (float, optional): Impact of accuracy for optimization [0-1]. Default: 0.9
 
-        acc_impact (float, optional): Impact of accuracy during evolve. [0-1] Default: 0.9
+        loss_impact (float, optional): Impact of loss for optimization [0-1]. Default: 0.1
         
         pop_size (int, optional): Population size of each generation. Default: count of activation functions
 
@@ -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,11 +113,13 @@ 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.
       
       strategy (str, optional): The strategy for combining the best and bad genomes. Options:
-         - 'normal_selective': Normal selection based on reward, where a portion of the bad genes are discarded.
+         - 'normal_selective': Normal selection based on fitness, where a portion of the bad genes are discarded.
          - 'more_selective': A more selective strategy, where fewer bad genes survive.
          - 'less_selective': A less selective strategy, where more bad genes survive.
          Default is 'normal_selective'.
@@ -143,6 +146,8 @@ def evolver(weights,
          Must be in the range [0, 1]. Also affects the mutation probability of the best genomes inversely. 
          For example, a value of 0.7 for bad genomes implies 0.3 for best genomes. Default: Determined by `policy`.
       
+      bad_genomes_selection_prob (float, optional): The probability of crossover parents are bad genomes ? [0-1] Default: Determined by `policy`.
+
       activation_mutate_prob (float, optional): The probability of applying mutation to the activation functions. 
          Must be in the range [0, 1]. Default is 1 (%100).
       
@@ -259,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)
@@ -323,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
                                              )
 
@@ -350,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
                                              )
 
@@ -395,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
 
@@ -450,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.
@@ -484,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:
@@ -511,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
         )
         ```
@@ -544,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]
 
@@ -633,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.
@@ -660,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:
@@ -681,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))
+         max_threshold = row_end * col_end
 
-         weight[selected_row, selected_col] = random.uniform(-1, 1)
-         new_threshold += threshold
-
-         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
-
-         for _ in range(max_threshold):
+      genome_fitness += epsilon
+      threshold = abs(activation_mutate_threshold / genome_fitness)
+      max_threshold = len(activations)
 
-            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.
       
@@ -145,6 +148,8 @@ def evolver(weights,
          Must be in the range [0, 1]. Also affects the mutation probability of the best genomes inversely. 
          For example, a value of 0.7 for bad genomes implies 0.3 for best genomes. Default: Determined by `policy`.
       
+      bad_genomes_selection_prob (float, optional): The probability of crossover parents are bad genomes ? [0-1] Default: Determined by `policy`.
+
       activation_mutate_prob (float, optional): The probability of applying mutation to the activation functions. 
          Must be in the range [0, 1]. Default is 0.5 (50%).
       
@@ -260,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)
@@ -323,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
                                              )
   
@@ -350,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
                                              )
             
@@ -394,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
 
@@ -450,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.
@@ -484,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:
@@ -511,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
         )
         ```
@@ -544,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]
@@ -635,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.
@@ -662,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:
@@ -683,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 potential_weight_mutation > weight_mutate_prob:
-
-      start = 0
-      row_end = weight.shape[0]
-      col_end = weight.shape[1]
-      
-      max_threshold = row_end * col_end
+   if weight_evolve is True:
 
-      threshold = weight_mutate_threshold * (genome_fitness + epsilon)
-      new_threshold = threshold
+      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)
 
-      for _ in range(max_threshold):
-         
-         selected_row = int(random.uniform(start, row_end))
-         selected_col = int(random.uniform(start, col_end))
+      if potential_weight_mutation > weight_mutate_prob:
 
-         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.11.dist-info → pyerualjetwork-4.3.13.dist-info}/METADATA

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

@@ -1,4 +1,4 @@
-pyerualjetwork/__init__.py,sha256=5snQTX8efGK_JdtgdrZU57alCIlsFlcYror1R3HFFDQ,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=M8KVSXUjmSkf4bK7FnizLZjWQfI_3suHIJ-XminM2SM,22291
-pyerualjetwork/plan_cuda.py,sha256=hRPPw4YsiVpfoXkNN1le1zaVHJuSySvihiFBt2eHT7c,23388
-pyerualjetwork/planeat.py,sha256=FBoYirDE8R0zGtB-EFsHdQ50RijC7rnZHqDIiXx67rs,37571
-pyerualjetwork/planeat_cuda.py,sha256=5suVlOfHcThhGbPlHbxAqbp5-rpbw4E2H6trvDvrmg4,37627
+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.11.dist-info/METADATA,sha256=6P6WgEt2RMPwvhAVg1cswZvq_fNB875egS_dEiabzlo,7506
-pyerualjetwork-4.3.11.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
-pyerualjetwork-4.3.11.dist-info/top_level.txt,sha256=BRyt62U_r3ZmJpj-wXNOoA345Bzamrj6RbaWsyW4tRg,15
-pyerualjetwork-4.3.11.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,,