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

pyerualjetwork/__init__.py

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

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

@@ -1,4 +1,4 @@
-pyerualjetwork/__init__.py,sha256=TigQhP6yP1luXiX5fdCVYqBZQTjPRdboBfy_KU5-g_4,643
+pyerualjetwork/__init__.py,sha256=tTsCaO21gpTHXANBa1BxXVjtXNtwRBZbEgajdSreUyc,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=W9d7H3PMu6MRcdGYPHpUa0q9Kx7-ogu5xLq1g928y64,655
+pyerualjetwork_afterburner/__init__.py,sha256=Pw-QCXxnDb7n0onhtNr3b3rW1p44D68garrl-OJdouQ,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
@@ -31,14 +31,14 @@ pyerualjetwork_afterburner/metrics.py,sha256=q7MkhnZDRbCjFBDDfUgrl8lBYnUT_1ro1Lx
 pyerualjetwork_afterburner/metrics_cuda.py,sha256=73h9GC7XwmnFCVzFEEiPQfF8CwHIz2wsCbxpZrJtYgw,5061
 pyerualjetwork_afterburner/model_operations.py,sha256=MCSCNYiiICRVZITobtS3ZIWmH5Q9gjyELuH32sAdgg4,12649
 pyerualjetwork_afterburner/model_operations_cuda.py,sha256=NT01BK5nrDYE7H1x3KnSI8gmx0QTGGB0mP_LqEb1uuU,13157
-pyerualjetwork_afterburner/plan.py,sha256=Gxv8ii4brTYMzzFZBP-X6kkwc6w6vtTPiMmqVOAqoq8,21972
+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=SG7Oq1F2m3lJBbG9cgmu7q_ApmwSn2SvTpcbtEVAoDE,37630
+pyerualjetwork_afterburner/planeat_cuda.py,sha256=VbeaoKlqquKDLcRaQHdoERvoxzO75Day0RgJtOSU9wk,38898
 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.dev3.dist-info/METADATA,sha256=VFNiB4kXQ8sU6wa_9uGjkHi_s-b-rzCY_wIJOLbnALM,8384
-pyerualjetwork-4.3.8.dev3.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
-pyerualjetwork-4.3.8.dev3.dist-info/top_level.txt,sha256=uK64ge08QQoPuXM3aiRVPgiQQtl8Fxm2-HieIut5Lwo,42
-pyerualjetwork-4.3.8.dev3.dist-info/RECORD,,
+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_afterburner/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "4.3.8dev3-afterburner"
+__version__ = "4.3.8dev4-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/plan.py

@@ -78,7 +78,7 @@ def fit(
     return normalization(LTPW, dtype=dtype)
 
 
-def learner(x_train, y_train, optimizer, fit_start, strategy='accuracy', gen=None, batch_size=1,
+def learner(x_train, y_train, optimizer, fit_start, strategy='accuracy', gen=None, batch_size=1, pop_size=None,
            neural_web_history=False, show_current_activations=False,
            neurons_history=False, early_stop=False, loss='categorical_crossentropy', show_history=False,
            interval=33.33, target_acc=None, target_loss=None,
@@ -123,6 +123,8 @@ def learner(x_train, y_train, optimizer, fit_start, strategy='accuracy', gen=Non
 
         batch_size (float, optional): Batch size is used in the prediction process to receive train feedback by dividing the test 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)
 
+        pop_size (int, optional): Population size of each generation. Default: count of activation functions
+
         early_stop (bool, optional): If True, implements early stopping during training.(If accuracy not improves in two gen stops learning.) Default is False.
 
         show_current_activations (bool, optional): Should it display the activations selected according to the current strategies during learning, or not? (True or False) This can be very useful if you want to cancel the learning process and resume from where you left off later. After canceling, you will need to view the live training activations in order to choose the activations to be given to the 'start_this' parameter. Default is False
@@ -156,14 +158,19 @@ def learner(x_train, y_train, optimizer, fit_start, strategy='accuracy', gen=Non
 
     data = 'Train'
 
-    activation_potentiation = all_activations()
+    except_this = ['spiral', 'circular']
+    activation_potentiation = [item for item in all_activations() if item not in except_this]
     activation_potentiation_len = len(activation_potentiation)
    
     # Pre-checks
 
+    if pop_size is None: pop_size = activation_potentiation_len
+
     x_train = x_train.astype(dtype, copy=False)
     y_train = optimize_labels(y_train, cuda=False)
 
+    if pop_size < activation_potentiation_len: raise ValueError(f"pop_size must be higher or equal to {activation_potentiation_len}")
+
     if gen is None:
         gen = activation_potentiation_len
 
@@ -192,16 +199,16 @@ def learner(x_train, y_train, optimizer, fit_start, strategy='accuracy', gen=Non
 
     progress = initialize_loading_bar(total=activation_potentiation_len, desc="", ncols=ncols, bar_format=bar_format_learner)
 
-    if fit_start is False:
-        weight_pop, act_pop = define_genomes(input_shape=len(x_train[0]), output_shape=len(y_train[0]), population_size=activation_potentiation_len, dtype=dtype)
+    if fit_start is False or pop_size > activation_potentiation_len:
+        weight_pop, act_pop = define_genomes(input_shape=len(x_train[0]), output_shape=len(y_train[0]), population_size=pop_size, dtype=dtype)
     
         if start_this_act is not None and start_this_W is not None:
             weight_pop[0] = start_this_W
             act_pop[0] = start_this_act
 
     else:
-        weight_pop = []
-        act_pop = []
+        weight_pop = [0] * pop_size
+        act_pop = [0] * pop_size
 
     for i in range(gen):
         postfix_dict["Gen"] = str(i+1) + '/' + str(gen)
@@ -211,14 +218,14 @@ def learner(x_train, y_train, optimizer, fit_start, strategy='accuracy', gen=Non
         progress.last_print_n = 0
         progress.update(0)
 
-        for j in range(activation_potentiation_len):
+        for j in range(pop_size):
 
             x_train_batch, y_train_batch = batcher(x_train, y_train, batch_size=batch_size)
             
-            if fit_start is True and i == 0:
-                act_pop.append(activation_potentiation[j])
+            if fit_start is True and i == 0 and j < activation_potentiation_len:
+                act_pop[j] = activation_potentiation[j]
                 W = fit(x_train_batch, y_train_batch, activation_potentiation=act_pop[-1], dtype=dtype)
-                weight_pop.append(W)
+                weight_pop[j] = W
             
             model = evaluate(x_train_batch, y_train_batch, W=weight_pop[j], activation_potentiation=act_pop[j])
             acc = model[get_acc()]

pyerualjetwork_afterburner/planeat_cuda.py

@@ -16,6 +16,9 @@ import cupy as cp
 import numpy as np
 import random
 import math
+from numba import cuda
+import concurrent.futures
+from functools import partial
 
 
 ### LIBRARY IMPORTS ###
@@ -438,20 +441,20 @@ def evaluate(x_population, weights, activation_potentiations):
    return result
 
 
-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):
-   """
+@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):
+    """    
     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.
@@ -513,131 +516,128 @@ def cross_over(first_parent_W,
             fitness_bias=0.6,
             epsilon=cp.finfo(float).eps
         )
-        ```
-    """
-   
-  ### 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:
+        ```"""
+    
+    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)):
             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
 
-   activation_selection_change_prob = 1 - activation_selection_change_prob
-   potential_activation_selection_change_prob = random.uniform(0, 1)
-
-   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]
+        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))
 
-         child_act[random_index_dominant] = random_undominant_activation
-         new_threshold += threshold
+        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 len(dominant_parent_act) > new_threshold:
-            pass
-         
-         else:
-            break
+    return child_W, child_act
 
-   return child_W, child_act
 
+@cuda.jit
+def weight_mutation_kernel(weight, rows, cols, num_mutations, rng_states):
+    idx = cuda.grid(1)
+    if idx < num_mutations:
 
-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.
+        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.
     - 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,97 +679,81 @@ def mutation(weight,
               `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 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:
+          """
+    
+    if isinstance(activations, str):
+        activations = [activations]
 
-      start = 0
-      row_end = weight.shape[0]
-      col_end = weight.shape[1]
+    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))
       
-      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)
-
+        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 potential_activation_delete_prob > activation_delete_prob and len(activations) > 1:
-               
-               random_index = random.randint(0, len(activations) - 1)
-               activations.pop(random_index)
-               
-
-            if potential_activation_add_prob > activation_add_prob:
-
-               try:
-                  
-                  random_index_all_act = int(random.uniform(0, len(all_acts)-1))
-                  activations.append(all_acts[random_index_all_act])
-
-               except:
-
-                  activation = activations
-                  activations = []
-
-                  activations.append(activation)
-                  activations.append(all_acts[int(random.uniform(0, len(all_acts)-1))])
-               
-            if potential_activation_change_prob > activation_change_prob:
-               
-               random_index_all_act = int(random.uniform(0, len(all_acts)-1))
-               random_index_genom_act = int(random.uniform(0, len(activations)-1))
-
-               activations[random_index_genom_act] = all_acts[random_index_all_act]
-
-            new_threshold += threshold
-
-            if max_threshold > new_threshold: pass
-            else: break
+            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)
+            
+            future_results = list(executor.map(process_func, range(num_iterations)))
 
-   return weight, activations
+            if future_results:
+                activations = future_results[-1]
+    
+    return weight, activations
 
 
 def second_parent_selection(good_weights, bad_weights, good_activations, bad_activations, bad_genomes_selection_prob):