pyerualjetwork 4.3.8.dev4__py3-none-any.whl → 4.3.8.dev6__py3-none-any.whl

pyerualjetwork/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "4.3.8dev4"
+__version__ = "4.3.8dev6"
 __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-4.3.8.dev4.dist-info → pyerualjetwork-4.3.8.dev6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyerualjetwork
-Version: 4.3.8.dev4
+Version: 4.3.8.dev6
 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.8.dev4.dist-info → pyerualjetwork-4.3.8.dev6.dist-info}/RECORD

@@ -1,4 +1,4 @@
-pyerualjetwork/__init__.py,sha256=tTsCaO21gpTHXANBa1BxXVjtXNtwRBZbEgajdSreUyc,643
+pyerualjetwork/__init__.py,sha256=olCEbcpfxR8QpQvxMzMKJtKcpSevTnsDX7lI96-QHyY,643
 pyerualjetwork/activation_functions.py,sha256=AR91fQV2W2rc-Qb4Yp7b8ucYpGjwyQUewO-M-lyEMs8,7729
 pyerualjetwork/activation_functions_cuda.py,sha256=ztIw6rMR4t1289_TPIGYwE6qarl_YbSOGj5Ep3rUMqs,11803
 pyerualjetwork/data_operations.py,sha256=Flteouu6rfSo2uHMqBHuzO02dXmbNa-I5qWmUpGTZ5Y,14760
@@ -18,7 +18,7 @@ pyerualjetwork/planeat_cuda.py,sha256=QNHCQLkR0MNFqyN2iHAtC7cbf8qZiD3p_54YH3lnMF
 pyerualjetwork/ui.py,sha256=wu2BhU1k-w3Kcho5Jtq4SEKe68ftaUeRGneUOSCVDjU,575
 pyerualjetwork/visualizations.py,sha256=VL00sX2DZz83F__PyEJH9s1LizuXpOBzWjnoSjMJIJ0,28770
 pyerualjetwork/visualizations_cuda.py,sha256=KbMhfsLlxujy_i3QrwCf734Q-k6d7Zn_7CEbm3gzK9w,29186
-pyerualjetwork_afterburner/__init__.py,sha256=Pw-QCXxnDb7n0onhtNr3b3rW1p44D68garrl-OJdouQ,655
+pyerualjetwork_afterburner/__init__.py,sha256=ziEOwTxIO9tl2N63bre_zkIPjmpQ-3iCuRNkFJO0YS4,655
 pyerualjetwork_afterburner/activation_functions.py,sha256=bKf00lsuuLJNO-4vVp4OqBi4zJ-qZ8L3v-vl52notkY,7721
 pyerualjetwork_afterburner/activation_functions_cuda.py,sha256=5y1Ti3GDfDteQDCUmODwe7tAyDAUlDTKmIikChQ8d6g,7772
 pyerualjetwork_afterburner/data_operations.py,sha256=Flteouu6rfSo2uHMqBHuzO02dXmbNa-I5qWmUpGTZ5Y,14760
@@ -34,11 +34,11 @@ pyerualjetwork_afterburner/model_operations_cuda.py,sha256=NT01BK5nrDYE7H1x3KnSI
 pyerualjetwork_afterburner/plan.py,sha256=EOXngujG7DQRf3cooFigKB7heQsEoK96JtrcKivT_pE,22449
 pyerualjetwork_afterburner/plan_cuda.py,sha256=fg5YunEuBE7sK6q9paP_yAGONr9x0e19oF0J0DucejM,23380
 pyerualjetwork_afterburner/planeat.py,sha256=Lq5R0aMS4UIdZdbUKsKDv5g0WLwYryomR3IQYb8vAa4,37573
-pyerualjetwork_afterburner/planeat_cuda.py,sha256=VbeaoKlqquKDLcRaQHdoERvoxzO75Day0RgJtOSU9wk,38898
+pyerualjetwork_afterburner/planeat_cuda.py,sha256=XS-latsokCvxvUbbGRALen35w3JJQJoIWIeFFtTl_7w,39942
 pyerualjetwork_afterburner/ui.py,sha256=wu2BhU1k-w3Kcho5Jtq4SEKe68ftaUeRGneUOSCVDjU,575
 pyerualjetwork_afterburner/visualizations.py,sha256=1SKMZaJ80OD2qHUyMxW1IOv8zwmxzMPxclfbeq1Xr4g,28772
 pyerualjetwork_afterburner/visualizations_cuda.py,sha256=KbMhfsLlxujy_i3QrwCf734Q-k6d7Zn_7CEbm3gzK9w,29186
-pyerualjetwork-4.3.8.dev4.dist-info/METADATA,sha256=4Gq7RqhoiGuEirXF6ZFFgs2fyZnZm46lQxj5IMsO9JU,8384
-pyerualjetwork-4.3.8.dev4.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
-pyerualjetwork-4.3.8.dev4.dist-info/top_level.txt,sha256=uK64ge08QQoPuXM3aiRVPgiQQtl8Fxm2-HieIut5Lwo,42
-pyerualjetwork-4.3.8.dev4.dist-info/RECORD,,
+pyerualjetwork-4.3.8.dev6.dist-info/METADATA,sha256=Kg8zdJAToUWOeWr9cBYG_wDFzLykd6BTn_diSLmgaQc,8384
+pyerualjetwork-4.3.8.dev6.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
+pyerualjetwork-4.3.8.dev6.dist-info/top_level.txt,sha256=uK64ge08QQoPuXM3aiRVPgiQQtl8Fxm2-HieIut5Lwo,42
+pyerualjetwork-4.3.8.dev6.dist-info/RECORD,,

pyerualjetwork_afterburner/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "4.3.8dev4-afterburner"
+__version__ = "4.3.8dev6-afterburner"
 __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_afterburner/planeat_cuda.py

@@ -16,8 +16,7 @@ import cupy as cp
 import numpy as np
 import random
 import math
-from numba import cuda
-import concurrent.futures
+import multiprocessing as mp
 from functools import partial
 
 
@@ -299,64 +298,30 @@ def evolver(weights,
    mutated_W = cp.copy(bad_weights)
    mutated_act = bad_activations.copy()
 
-
-   for i in range(len(bad_weights)):
-      
-      if policy == 'aggressive':
-         first_parent_W = best_weight
-         first_parent_act = best_activations
-
-      elif policy == 'explorer':
-         first_parent_W = good_weights[i]
-         first_parent_act = good_activations[i]
-
-      else: raise ValueError("policy parameter must be: 'aggressive' or 'explorer'")
-         
-      second_parent_W, second_parent_act, s_i = second_parent_selection(good_weights, bad_weights, good_activations, bad_activations, bad_genomes_selection_prob)
-
-      child_W[i], child_act[i] = cross_over(first_parent_W,
-                                             second_parent_W,
-                                             first_parent_act,
-                                             second_parent_act,
-                                             cross_over_mode=cross_over_mode,
-                                             activation_selection_add_prob=activation_selection_add_prob,
-                                             activation_selection_change_prob=activation_selection_change_prob,
-                                             activation_selection_threshold=activation_selection_threshold,
-                                             bad_genomes_selection_prob=bad_genomes_selection_prob,
-                                             first_parent_fitness=best_fitness,
-                                             fitness_bias=fitness_bias,
-                                             second_parent_fitness=normalized_fitness[s_i],
-                                             epsilon=epsilon
-                                             )
-  
-      mutation_prob = random.uniform(0, 1)
-
-      if mutation_prob > bad_genomes_mutation_prob:
-            genome_W = good_weights[i]
-            genome_act = good_activations[i]
-
-            fitness_index = int(len(bad_weights) / 2 + i)
-
-      else:
-            genome_W = bad_weights[i]
-            genome_act = bad_activations[i]
-
-            fitness_index = i
-
-      mutated_W[i], mutated_act[i] = mutation(genome_W, 
-                                             genome_act,
-                                             activation_mutate_prob=activation_mutate_prob,
-                                             activation_add_prob=activation_mutate_add_prob,
-                                             activation_delete_prob=activation_mutate_delete_prob, 
-                                             activation_change_prob=activation_mutate_change_prob, 
-                                             weight_mutate_prob=weight_mutate_prob, 
-                                             weight_mutate_threshold=weight_mutate_threshold,
-                                             genome_fitness=normalized_fitness[fitness_index],
-                                             activation_mutate_threshold=activation_mutate_threshold,
-                                             epsilon=epsilon
-                                             )
-            
-      if bar_status: progress.update(1)
+   with mp.Pool() as pool:
+    process_func = partial(process_single, policy=policy, best_weight=best_weight, 
+                         best_activations=best_activations, good_weights=good_weights, 
+                         good_activations=good_activations, bad_weights=bad_weights, 
+                         bad_activations=bad_activations, best_fitness=best_fitness, 
+                         normalized_fitness=normalized_fitness, child_W=child_W, 
+                         child_act=child_act, mutated_W=mutated_W, mutated_act=mutated_act,
+                         cross_over_mode=cross_over_mode,
+                         activation_selection_add_prob=activation_selection_add_prob,
+                         activation_selection_change_prob=activation_selection_change_prob,
+                         activation_selection_threshold=activation_selection_threshold,
+                         bad_genomes_selection_prob=bad_genomes_selection_prob,
+                         fitness_bias=fitness_bias,
+                         epsilon=epsilon,
+                         bad_genomes_mutation_prob=bad_genomes_mutation_prob,
+                         activation_mutate_prob=activation_mutate_prob,
+                         activation_mutate_add_prob=activation_mutate_add_prob,
+                         activation_mutate_delete_prob=activation_mutate_delete_prob,
+                         activation_mutate_change_prob=activation_mutate_change_prob,
+                         weight_mutate_prob=weight_mutate_prob,
+                         weight_mutate_threshold=weight_mutate_threshold,
+                         activation_mutate_threshold=activation_mutate_threshold)
+    
+    pool.map(process_func, range(len(bad_weights)))
 
    child_W[0] = best_weight
    child_act[0] = best_activations
@@ -401,6 +366,63 @@ def evolver(weights,
    return weights, activation_potentiations
 
 
+def process_single(i, policy, best_weight, best_activations, good_weights, good_activations, 
+                  bad_weights, bad_activations, best_fitness, normalized_fitness, child_W, child_act,
+                  mutated_W, mutated_act, cross_over_mode, 
+                  activation_selection_add_prob, activation_selection_change_prob,
+                  activation_selection_threshold, bad_genomes_selection_prob, fitness_bias,
+                  epsilon, bad_genomes_mutation_prob, activation_mutate_prob,
+                  activation_mutate_add_prob, activation_mutate_delete_prob,
+                  activation_mutate_change_prob, weight_mutate_prob, weight_mutate_threshold,
+                  activation_mutate_threshold):
+    if policy == 'aggressive':
+        first_parent_W = best_weight
+        first_parent_act = best_activations
+    elif policy == 'explorer':
+        first_parent_W = good_weights[i]
+        first_parent_act = good_activations[i]
+    else: 
+        raise ValueError("policy parameter must be: 'aggressive' or 'explorer'")
+        
+    second_parent_W, second_parent_act, s_i = second_parent_selection(good_weights, bad_weights, good_activations, bad_activations, bad_genomes_selection_prob)
+    child_W[i], child_act[i] = cross_over(first_parent_W,
+                                         second_parent_W,
+                                         first_parent_act,
+                                         second_parent_act,
+                                         cross_over_mode=cross_over_mode,
+                                         activation_selection_add_prob=activation_selection_add_prob,
+                                         activation_selection_change_prob=activation_selection_change_prob,
+                                         activation_selection_threshold=activation_selection_threshold,
+                                         bad_genomes_selection_prob=bad_genomes_selection_prob,
+                                         first_parent_fitness=best_fitness,
+                                         fitness_bias=fitness_bias,
+                                         second_parent_fitness=normalized_fitness[s_i],
+                                         epsilon=epsilon
+                                         )
+
+    mutation_prob = random.uniform(0, 1)
+    if mutation_prob > bad_genomes_mutation_prob:
+        genome_W = good_weights[i]
+        genome_act = good_activations[i]
+        fitness_index = int(len(bad_weights) / 2 + i)
+    else:
+        genome_W = bad_weights[i]
+        genome_act = bad_activations[i]
+        fitness_index = i
+
+    mutated_W[i], mutated_act[i] = mutation(genome_W,
+                                           genome_act,
+                                           activation_mutate_prob=activation_mutate_prob,
+                                           activation_add_prob=activation_mutate_add_prob,
+                                           activation_delete_prob=activation_mutate_delete_prob,
+                                           activation_change_prob=activation_mutate_change_prob,
+                                           weight_mutate_prob=weight_mutate_prob,
+                                           weight_mutate_threshold=weight_mutate_threshold,
+                                           genome_fitness=normalized_fitness[fitness_index],
+                                           activation_mutate_threshold=activation_mutate_threshold,
+                                           epsilon=epsilon
+                                           )
+
 def evaluate(x_population, weights, activation_potentiations):
    """
     Evaluates the performance of a population of genomes, applying different activation functions 
@@ -441,20 +463,20 @@ def evaluate(x_population, weights, activation_potentiations):
    return result
 
 
-@cuda.jit
-def crossover_kernel(undominant_W, child_W, row_start, row_end, col_start, col_end):
-    idx = cuda.grid(1)
-    if idx < (row_end - row_start) * (col_end - col_start):
-        row = row_start + (idx // (col_end - col_start))
-        col = col_start + (idx % (col_end - col_start))
-        if row < row_end and col < col_end:
-            child_W[row, col] = undominant_W[row, col]
-
-def cross_over(first_parent_W, second_parent_W, first_parent_act, second_parent_act,
-                      first_parent_fitness, second_parent_fitness, bad_genomes_selection_prob,
-                      fitness_bias, cross_over_mode, activation_selection_add_prob,
-                      activation_selection_change_prob, activation_selection_threshold, epsilon=1e-10):
-    """    
+def cross_over(first_parent_W,
+               second_parent_W,
+               first_parent_act,
+               second_parent_act,
+               cross_over_mode,
+               activation_selection_add_prob,
+               activation_selection_change_prob,
+               activation_selection_threshold,
+               bad_genomes_selection_prob,
+               first_parent_fitness,
+               second_parent_fitness,
+               fitness_bias,
+               epsilon):
+   """
     Performs a crossover operation on two sets of weights and activation functions.
     This function combines two individuals (represented by their weights and activation functions) 
     to create a new individual by exchanging parts of their weight matrices and activation functions.
@@ -516,128 +538,131 @@ def cross_over(first_parent_W, second_parent_W, first_parent_act, second_parent_
             fitness_bias=0.6,
             epsilon=cp.finfo(float).eps
         )
-        ```"""
-    
-    d_first_parent_W = cp.copy(first_parent_W)
-    d_second_parent_W = cp.copy(second_parent_W)
-    
-    row_end = first_parent_W.shape[0]
-    col_end = first_parent_W.shape[1]
-    total_gene = row_end * col_end
-    half_of_gene = int(total_gene / 2)
-     
-    decision = dominant_parent_selection(bad_genomes_selection_prob)
-    if decision == 'first_parent':
-        dominant_parent_W = cp.copy(d_first_parent_W)
-        dominant_parent_act = first_parent_act
-        undominant_parent_W = cp.copy(d_second_parent_W)
-        undominant_parent_act = second_parent_act
-        succes = second_parent_fitness + epsilon
-    else:
-        dominant_parent_W = cp.copy(d_second_parent_W)
-        dominant_parent_act = second_parent_act
-        undominant_parent_W = cp.copy(d_first_parent_W)
-        undominant_parent_act = first_parent_act
-        succes = first_parent_fitness + epsilon
-
-    while True:
-        row_cut_start = int(random.uniform(0, row_end))
-        col_cut_start = int(random.uniform(0, col_end))
-        row_cut_end = int(random.uniform(0, row_end))
-        col_cut_end = int(random.uniform(0, 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)):
+        ```
+    """
+   
+  ### THE GIVEN GENOMES' WEIGHTS ARE RANDOMLY SELECTED AND COMBINED OVER A RANDOM RANGE. SIMILARLY, THEIR ACTIVATIONS ARE COMBINED. A NEW GENOME IS RETURNED WITH THE COMBINED WEIGHTS FIRST, FOLLOWED BY THE ACTIVATIONS:
+   
+   start = 0
+   
+   row_end = first_parent_W.shape[0]
+   col_end = first_parent_W.shape[1]
+
+   total_gene = row_end * col_end
+   half_of_gene = int(total_gene / 2)
+
+   decision = dominant_parent_selection(bad_genomes_selection_prob)
+
+   if decision == 'first_parent':
+      dominant_parent_W = cp.copy(first_parent_W)
+      dominant_parent_act = first_parent_act
+
+      undominant_parent_W = cp.copy(second_parent_W)
+      undominant_parent_act = second_parent_act
+      succes = second_parent_fitness + epsilon
+
+   elif decision == 'second_parent':
+      dominant_parent_W = cp.copy(second_parent_W)
+      dominant_parent_act = second_parent_act
+
+      undominant_parent_W = cp.copy(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))
+
+      row_cut_end = int(random.uniform(start, row_end))
+      col_cut_end = 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)
+
+      if fitness_bias > selection_bias:
+         row_cut_start = math.floor(row_cut_start * succes)
+         row_cut_end = math.ceil(row_cut_end * succes)
+
+         col_cut_start = math.floor(col_cut_start * succes)
+         col_cut_end = math.ceil(col_cut_end * succes)
+
+   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]
+
+
+   if isinstance(dominant_parent_act, str): dominant_parent_act = [dominant_parent_act]
+   if isinstance(undominant_parent_act, str): undominant_parent_act = [undominant_parent_act]
+
+   child_act = list(np.copy(dominant_parent_act))
+
+   activation_selection_add_prob = 1 - activation_selection_add_prob # if prob 0.8 (%80) then 1 - 0.8. Because 0-1 random number probably greater than 0.2
+   potential_activation_selection_add = random.uniform(0, 1)
+
+   if potential_activation_selection_add > activation_selection_add_prob:
+      
+      threshold = abs(activation_selection_threshold / succes)
+      new_threshold = threshold
+      
+      while True:
+         
+         random_index = int(random.uniform(0, len(undominant_parent_act)-1))
+         random_undominant_activation = undominant_parent_act[random_index]
+
+         child_act.append(random_undominant_activation)
+         new_threshold += threshold
+
+         if len(dominant_parent_act) > new_threshold:
+            pass
+         
+         else:
             break
-    
-        selection_bias = random.uniform(0, 1)
-        if fitness_bias > selection_bias:
-            row_cut_start = math.floor(row_cut_start * succes)
-            row_cut_end = math.ceil(row_cut_end * succes)
-            col_cut_start = math.floor(col_cut_start * succes)
-            col_cut_end = math.ceil(col_cut_end * succes)
-
-    child_W = cp.copy(dominant_parent_W)
-    
-    if cross_over_mode == 'tpm':
-        threadsperblock = 256
-        blockspergrid = (total_gene + (threadsperblock - 1)) // threadsperblock
 
-        crossover_kernel[blockspergrid, threadsperblock](undominant_parent_W, child_W,
-            row_cut_start, row_cut_end, col_cut_start, col_cut_end
-        )
-    
-    with concurrent.futures.ThreadPoolExecutor() as executor:
-        if isinstance(dominant_parent_act, str): 
-            dominant_parent_act = [dominant_parent_act]
-        if isinstance(undominant_parent_act, str): 
-            undominant_parent_act = [undominant_parent_act]
-        
-        child_act = list(np.copy(dominant_parent_act))
+   activation_selection_change_prob = 1 - activation_selection_change_prob
+   potential_activation_selection_change_prob = random.uniform(0, 1)
 
-        if random.uniform(0, 1) > (1 - activation_selection_add_prob):
-            threshold = abs(activation_selection_threshold / succes)
-            new_threshold = threshold
-            
-            futures = []
-            while len(dominant_parent_act) > new_threshold:
-                random_index = int(random.uniform(0, len(undominant_parent_act)-1))
-                futures.append(
-                    executor.submit(
-                        lambda idx: undominant_parent_act[idx],
-                        random_index
-                    )
-                )
-                new_threshold += threshold
-            
-            for future in concurrent.futures.as_completed(futures):
-                child_act.append(future.result())
-        
-        if random.uniform(0, 1) > (1 - activation_selection_change_prob):
-            threshold = abs(activation_selection_threshold / succes)
-            new_threshold = threshold
-            
-            futures = []
-            while len(dominant_parent_act) > new_threshold:
-                random_index_undominant = int(random.uniform(0, len(undominant_parent_act)-1))
-                random_index_dominant = int(random.uniform(0, len(dominant_parent_act)-1))
-                futures.append(
-                    executor.submit(
-                        lambda u_idx, d_idx: (d_idx, undominant_parent_act[u_idx]),
-                        random_index_undominant,
-                        random_index_dominant
-                    )
-                )
-                new_threshold += threshold
-            
-            for future in concurrent.futures.as_completed(futures):
-                idx, val = future.result()
-                child_act[idx] = val
+   if potential_activation_selection_change_prob > activation_selection_change_prob:
+      
+      threshold = abs(activation_selection_threshold / succes)
+      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]
 
-    return child_W, child_act
+         child_act[random_index_dominant] = random_undominant_activation
+         new_threshold += threshold
 
+         if len(dominant_parent_act) > new_threshold:
+            pass
+         
+         else:
+            break
 
-@cuda.jit
-def weight_mutation_kernel(weight, rows, cols, num_mutations, rng_states):
-    idx = cuda.grid(1)
-    if idx < num_mutations:
+   return child_W, child_act
 
-        row = int(cuda.random.xoroshiro128p_uniform_float32(rng_states, idx) * rows)
-        col = int(cuda.random.xoroshiro128p_uniform_float32(rng_states, idx) * cols)
-        mutation_value = -1.0 + 2.0 * cuda.random.xoroshiro128p_uniform_float32(rng_states, idx)
-        
-        if row < rows and col < cols:
-            weight[row, col] = mutation_value
-
-def mutation(weight, activations, genome_fitness, weight_mutate_prob, 
-                     weight_mutate_threshold, activation_mutate_prob,
-                     activation_mutate_threshold, activation_add_prob,
-                     activation_delete_prob, activation_change_prob,
-                     epsilon=1e-10):
-    """    
-      Performs mutation on the given weight matrix and activation functions.
+
+def mutation(weight, 
+             activations, 
+             activation_mutate_prob, 
+             activation_add_prob, 
+             activation_delete_prob, 
+             activation_change_prob, 
+             weight_mutate_prob, 
+             weight_mutate_threshold, 
+             genome_fitness,
+             activation_mutate_threshold,
+             epsilon):
+   """
+    Performs mutation on the given weight matrix and activation functions.
     - The weight matrix is mutated by randomly changing its values based on the mutation probability.
     - The activation functions are mutated by adding, removing, or replacing them with predefined probabilities.
 
@@ -679,81 +704,97 @@ def mutation(weight, activations, genome_fitness, weight_mutate_prob,
               `activation_change_prob`).
         - The mutation probabilities should be chosen carefully to balance exploration and exploitation during 
           the optimization process.
-          """
-    
-    if isinstance(activations, str):
-        activations = [activations]
+   """
 
-    weight_mutate_prob = 1 - weight_mutate_prob
-    if random.uniform(0, 1) > weight_mutate_prob:
-        # GPU'ya veri transferi
-        d_weight = cp.copy(weight)
-        
-        row_end = weight.shape[0]
-        col_end = weight.shape[1]
-        max_threshold = row_end * col_end
-        threshold = weight_mutate_threshold * genome_fitness
-        num_mutations = int(min(max_threshold, threshold))
-
-        threadsperblock = 256
-        blockspergrid = (num_mutations + (threadsperblock - 1)) // threadsperblock
-        
-        rng_states = cuda.random.create_xoroshiro128p_states(threadsperblock * blockspergrid, seed=random.randint(0, 1000))
+   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]
       
-        weight_mutation_kernel[blockspergrid, threadsperblock](
-            d_weight, row_end, col_end, num_mutations, rng_states
-        )
-        
-    activation_mutate_prob = 1 - activation_mutate_prob
-    if random.uniform(0, 1) > activation_mutate_prob:
-        genome_fitness += epsilon
-        threshold = abs(activation_mutate_threshold / genome_fitness)
-        max_threshold = len(activations)
-        
-        except_this = ['spiral', 'circular']
-        all_acts = [item for item in all_activations() if item not in except_this]
-        
-        activation_add_prob = 1 - activation_add_prob
-        activation_delete_prob = 1 - activation_delete_prob
-        activation_change_prob = 1 - activation_change_prob
-        
-        def process_mutation(_, activations, all_acts, probs):
-            """Tek bir mutasyon işlemi için yardımcı fonksiyon"""
-            add_prob, delete_prob, change_prob = probs
-            local_activations = activations.copy()
-            
-            if random.uniform(0, 1) > delete_prob and len(local_activations) > 1:
-                random_index = random.randint(0, len(local_activations) - 1)
-                local_activations.pop(random_index)
-                
-            if random.uniform(0, 1) > add_prob:
-                try:
-                    random_index_all_act = int(random.uniform(0, len(all_acts)-1))
-                    local_activations.append(all_acts[random_index_all_act])
-                except:
-                    activation = local_activations[0]
-                    local_activations = [activation]
-                    local_activations.append(all_acts[int(random.uniform(0, len(all_acts)-1))])
-                    
-            if random.uniform(0, 1) > change_prob:
-                random_index_all_act = int(random.uniform(0, len(all_acts)-1))
-                random_index_genom_act = int(random.uniform(0, len(local_activations)-1))
-                local_activations[random_index_genom_act] = all_acts[random_index_all_act]
-                
-            return local_activations
-        
-        num_iterations = int(min(max_threshold, threshold))
-        with concurrent.futures.ThreadPoolExecutor() as executor:
-            probs = (activation_add_prob, activation_delete_prob, activation_change_prob)
-            process_func = partial(process_mutation, activations=activations, 
-                                all_acts=all_acts, probs=probs)
+      max_threshold = row_end * col_end
+
+      threshold = weight_mutate_threshold * genome_fitness
+      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
+
+         if max_threshold > new_threshold:
+            pass
+         
+         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)
+
+         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):
+
+            potential_activation_add_prob = random.uniform(0, 1)
+            potential_activation_delete_prob = random.uniform(0, 1)
+            potential_activation_change_prob = random.uniform(0, 1)
+
             
-            future_results = list(executor.map(process_func, range(num_iterations)))
+            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 future_results:
-                activations = future_results[-1]
-    
-    return weight, activations
+            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
 
 
 def second_parent_selection(good_weights, bad_weights, good_activations, bad_activations, bad_genomes_selection_prob):