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

pyerualjetwork/__init__.py

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

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

@@ -1,4 +1,4 @@
-pyerualjetwork/__init__.py,sha256=TigQhP6yP1luXiX5fdCVYqBZQTjPRdboBfy_KU5-g_4,643
+pyerualjetwork/__init__.py,sha256=aQiVtvIoAkk7-Wrr-xNhNQPwVZB-2cSoKH8xytXVVqM,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=kmFJeX5myisl9iSpmRGJPH4v51_2kcI0ZaauXjLkRCw,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=Hh-prPlPToiJIyR3Xsp_b22cFIwEP09T77UJyZKnLLo,38722
 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.dev5.dist-info/METADATA,sha256=4tAsoW5zkw92w30B6KZimXpYC1GIun2NWTbTenshDbs,8384
+pyerualjetwork-4.3.8.dev5.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
+pyerualjetwork-4.3.8.dev5.dist-info/top_level.txt,sha256=uK64ge08QQoPuXM3aiRVPgiQQtl8Fxm2-HieIut5Lwo,42
+pyerualjetwork-4.3.8.dev5.dist-info/RECORD,,

pyerualjetwork_afterburner/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "4.3.8dev3-afterburner"
+__version__ = "4.3.8dev5-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,8 @@ import cupy as cp
 import numpy as np
 import random
 import math
+import multiprocessing as mp
+from functools import partial
 
 
 ### LIBRARY IMPORTS ###
@@ -296,64 +298,31 @@ 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, 
+                         progress=progress, bar_status=bar_status,
+                         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
@@ -398,6 +367,40 @@ 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, progress, bar_status, 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
+                                         )
+
 def evaluate(x_population, weights, activation_potentiations):
    """
     Evaluates the performance of a population of genomes, applying different activation functions