pyerualjetwork 4.2.0b6__py3-none-any.whl → 4.2.2__py3-none-any.whl

pyerualjetwork/__init__.py

@@ -1,61 +1,11 @@
-
-import subprocess
-subprocess.check_call(["pip", "install", 'setuptools==75.6.0'])
-import pkg_resources
-
-print("Auto checking and installation dependencies for PyerualJetwork")
-
-package_names = [
-    'scipy==1.13.1',
-    'tqdm==4.66.4',
-    'seaborn==0.13.2',
-    'pandas==2.2.2',
-    'networkx==3.3',
-    'numpy==1.26.4',
-    'matplotlib==3.9.0',
-    'colorama==0.4.6',
-    'psutil==6.1.1',
-    'cupy-cuda12x==13.3.0'
-]
-
-installed_packages = pkg_resources.working_set
-installed = {pkg.key: pkg.version for pkg in installed_packages}
-err = 0
-
-for package_name in package_names:
-    package_name_only, required_version = package_name.split('==')
-    
-    if package_name_only not in installed:
-
-        try:
-            print(f"{package_name} Installing...")
-            subprocess.check_call(["pip", "install", package_name])
-        except Exception as e:
-            err += 1
-            print(f"Error installing {package_name} library, installation continues: {e}")
-    else:
-
-        installed_version = installed[package_name_only]
-        if installed_version != required_version:
-            print(f"Updating {package_name_only} from version {installed_version} to {required_version}...")
-            try:
-                subprocess.check_call(["pip", "install", package_name])
-            except Exception as e:
-                err += 1
-                print(f"Error updating {package_name} library, installation continues: {e}")
-        else:
-            print(f"{package_name} ready.")
-
-print(f"PyerualJetwork is ready to use with {err} errors")
-
-__version__ = "4.2.0b6"
-__update__ = "* Changes: https://github.com/HCB06/PyerualJetwork/blob/main/CHANGES\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"
+__version__ = "4.2.2"
+__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__):
     print(f"PyerualJetwork Version {__version__}" + '\n')
 
 def print_update_notes(__update__):
-    print(f"Update Notes:\n{__update__}")
+    print(f"Notes:\n{__update__}")
 
 print_version(__version__)
 print_update_notes(__update__)

pyerualjetwork/data_operations.py

@@ -66,9 +66,13 @@ def split(X, y, test_size, random_state=42, dtype=np.float32):
 
     Args:
         X (numpy.ndarray): Features data.
+        
         y (numpy.ndarray): Labels data.
+        
         test_size (float or int): Proportion or number of samples for the test subset.
+        
         random_state (int or None): Seed for random state. Default: 42.
+        
         dtype (numpy.dtype): Data type for the arrays. np.float32 by default. Example: np.float64 or np.float16. [fp32 for balanced devices, fp64 for strong devices, fp16 for weak devices: not reccomended!]
 
     Returns:

pyerualjetwork/help.py

@@ -1,4 +1,5 @@
-from .activation_functions import all_activations
+from activation_functions import all_activations
+
 
 def activation_potentiation():
 

pyerualjetwork/memory_operations.py

@@ -34,13 +34,13 @@ def transfer_to_cpu(x, dtype=np.float32):
     The `transfer_to_cpu` function converts data to a specified data type on the CPU, handling memory constraints
     by batching the conversion process and ensuring complete GPU memory cleanup.
    
-    :param x: Input data to transfer to CPU (CuPy array)
+    param x: Input data to transfer to CPU (CuPy array)
     
-    :param dtype: Target NumPy dtype for the output array (default: np.float32)
+    param dtype: Target NumPy dtype for the output array (default: np.float32)
     
-    :return: NumPy array with the specified dtype
+    return: NumPy array with the specified dtype
     """
-    from ui import loading_bars, initialize_loading_bar
+    from .ui import loading_bars, initialize_loading_bar
     try:
         if isinstance(x, np.ndarray):
             return x.astype(dtype) if x.dtype != dtype else x

pyerualjetwork/model_operations.py

@@ -334,8 +334,8 @@ def predict_model_ram(Input, W, scaler_params=None, activation_potentiation=['li
     ndarray: Output from the model.
     """
 
-    from .data_operations import standard_scaler
-    from .plan import feed_forward
+    from data_operations import standard_scaler
+    from plan import feed_forward
 
     Input = standard_scaler(None, Input, scaler_params, dtype=dtype)
     

pyerualjetwork/plan.py

@@ -16,7 +16,6 @@ PYERUALJETWORK document: https://github.com/HCB06/PyerualJetwork/blob/main/Welco
 """
 
 import numpy as np
-from colorama import Fore
 import math
 
 ### LIBRARY IMPORTS ###
@@ -174,11 +173,11 @@ def fit(
     return normalization(LTPW, dtype=dtype)
 
 
-def learner(x_train, y_train, optimizer, x_test=None, y_test=None, strategy='accuracy', gen=None, batch_size=1,
+def learner(x_train, y_train, optimizer, fit_start, strategy='accuracy', gen=None, batch_size=1,
            neural_web_history=False, show_current_activations=False, auto_normalization=True,
            neurons_history=False, early_stop=False, loss='categorical_crossentropy', show_history=False,
-           interval=33.33, target_acc=None, target_loss=None, except_this=None,
-           only_this=None, start_this_act=None, start_this_W=None, target_fitness='max', dtype=np.float32):
+           interval=33.33, target_acc=None, target_loss=None,
+           start_this_act=None, start_this_W=None, dtype=np.float32):
     """
     Optimizes the activation functions for a neural network by leveraging train data to find 
     the most accurate combination of activation potentiation for the given dataset using genetic algorithm NEAT (Neuroevolution of Augmenting Topologies). But modifided for PLAN version. Created by me: PLANEAT. 
@@ -195,34 +194,34 @@ def learner(x_train, y_train, optimizer, x_test=None, y_test=None, strategy='acc
 
         optimizer (function): PLAN optimization technique with hyperparameters. (PLAN using NEAT(PLANEAT) for optimization.) Please use this: from pyerualjetwork import planeat (and) optimizer = lambda *args, **kwargs: planeat.evolve(*args, 'here give your neat hyperparameters for example:  activation_add_prob=0.85', **kwargs) Example:
         ```python
-        genetic_optimizer = lambda *args, **kwargs: planeat.evolve(*args,
+        genetic_optimizer = lambda *args, **kwargs: planeat.evolver(*args,
                                                                     activation_add_prob=0.85,
-                                                                    mutations=False,
-                                                                    strategy='cross_over',
+                                                                    mutations=True,
+                                                                    strategy='aggressive',
                                                                     **kwargs)
 
         model = plan.learner(x_train,
                              y_train,
                              optimizer=genetic_optimizer,
+                             fit_start=True,
                              strategy='accuracy',
                              show_history=True,
-                             target_acc=0.94,
+                             gen=15,
+                             batch_size=0.05,
                              interval=16.67)
         ```
 
-        x_test (array-like, optional): Test input data (for improve next gen generilization). If test data is not given then train feedback learning active
-
-        y_test (array-like, optional): Test Labels (for improve next gen generilization). If test data is not given then train feedback learning active
+        fit_start (bool): 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. The fit_start parameter is MANDATORY and must be provided.
 
         strategy (str, optional): Learning strategy. (options: 'accuracy', 'f1', 'precision', 'recall'): 'accuracy', Maximizes train (or test if given) accuracy during learning. 'f1', Maximizes train (or test if given) f1 score during learning. 'precision', Maximizes train (or test if given) precision score during learning. 'recall', Maximizes train (or test if given) recall during learning. Default is 'accuracy'.
 
         gen (int, optional): The generation count for genetic optimization.
 
-        batch_size (float, optional): Batch size is used in the prediction process to receive test 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 test batch represents 8% of the test set. Default is 1. (%100 of test)
+        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)
 
-        auto_normalization (bool, optional): If auto normalization=False this makes more faster training times and much better accuracy performance for some datasets. Default is True.
+        early_stop (bool, optional): If True, implements early stopping during training.(If accuracy not improves in two gen stops learning.) Default is False.
 
-        early_stop (bool, optional): If True, implements early stopping during training.(If test accuracy not improves in two gen stops learning.) Default is False.
+        auto_normalization (bool, optional): IMPORTANT: auto_nomralization parameter works only if fit_start is True. Do not change this value if fit_start is False, because it doesnt matter.) If auto normalization=False this makes more faster training times and much better accuracy performance for some datasets. Default is True.
 
         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
 
@@ -235,10 +234,6 @@ def learner(x_train, y_train, optimizer, x_test=None, y_test=None, strategy='acc
         target_acc (int, 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.
-
-        except_this (list, optional): A list of activations to exclude from optimization. Default is None. (For avaliable activation functions, run this code: plan.activations_list())
-
-        only_this (list, optional): A list of activations to focus on during optimization. Default is None. (For avaliable activation functions, run this code: plan.activations_list())
         
         start_this_act (list, optional): To resume a previously canceled or interrupted training from where it left off, or to continue from that point with a different strategy, provide the list of activation functions selected up to the learned portion to this parameter. Default is None
 
@@ -247,8 +242,6 @@ def learner(x_train, y_train, optimizer, x_test=None, y_test=None, strategy='acc
         neurons_history (bool, optional): Shows the history of changes that neurons undergo during the TFL (Test or Train Feedback Learning) stages. True or False. Default is False.
 
         neural_web_history (bool, optional): Draws history of neural web. Default is False.
-
-        target_fitness (str, optional): Target fitness strategy for PLANEAT optimization. ('max' for machine learning, 'min' for machine unlearning.) Default: 'max'
         
         dtype (numpy.dtype): Data type for the arrays. np.float32 by default. Example: np.float64 or np.float16. [fp32 for balanced devices, fp64 for strong devices, fp16 for weak devices: not reccomended!] (optional)
 
@@ -257,37 +250,25 @@ def learner(x_train, y_train, optimizer, x_test=None, y_test=None, strategy='acc
     
     """
 
-    print(Fore.WHITE + "\nRemember, optimization on large datasets can be very time-consuming and computationally expensive. Therefore, if you are working with such a dataset, our recommendation is to include activation function: ['circular', 'spiral'] in the 'except_this' parameter unless absolutely necessary, as they can significantly prolong the process. from: learner\n" + Fore.RESET)
+    from .planeat import define_genomes
 
-    activation_potentiation = all_activations()
+    data = 'Train'
 
+    activation_potentiation = all_activations()
+    activation_potentiation_len = len(activation_potentiation)
+   
     # Pre-checks
 
     x_train = x_train.astype(dtype, copy=False)
     y_train = optimize_labels(y_train, cuda=False)
 
-    if x_test is None and y_test is None:
-        x_test = x_train
-        y_test = y_train
-        data = 'Train'
-    else:
-        x_test = x_test.astype(dtype, copy=False)
-        y_test = optimize_labels(y_test, cuda=False)
-        data = 'Test'
-
-    # Filter activation functions
-    if only_this is not None:
-        activation_potentiation = only_this
-    if except_this is not None:
-        activation_potentiation = [item for item in activation_potentiation if item not in except_this]
     if gen is None:
-        gen = len(activation_potentiation)
+        gen = activation_potentiation_len
 
     if strategy != 'accuracy' and strategy != 'f1' and strategy != 'recall' and strategy != 'precision': raise ValueError("Strategy parameter only be 'accuracy' or 'f1' or 'recall' or 'precision'.")
+    if target_acc is not None and (target_acc < 0 or target_acc > 1): raise ValueError('target_acc must be in range 0 and 1')
+    if fit_start is not True and fit_start is not False: raise ValueError('fit_start parameter only be True or False. Please read doc-string')
 
-    if start_this_act is None and len(activation_potentiation) % 2 != 0: raise ValueError("Activation length must be even number. Please use 'except_this' parameter and except some activation. For example: except_this=['linear']")
-    if start_this_act is not None and len(activation_potentiation) + 1 % 2 != 0: raise ValueError("You are using start_this parameter, activation length still must be even number. Please use 'except_this' parameter and except some activation. For example: except_this=['linear']")
-    
     # Initialize visualization components
     viz_objects = initialize_visualization_for_learner(show_history, neurons_history, neural_web_history, x_train, y_train)
 
@@ -298,33 +279,27 @@ def learner(x_train, y_train, optimizer, x_test=None, y_test=None, strategy='acc
         ncols = 89
 
     # Initialize variables
-    act_pop = []
-    weight_pop = []
-    
-    if start_this_act is None and start_this_W is None:
-        best_acc = 0
-    else:
-        act_pop.append(start_this_act)
-        weight_pop.append(start_this_W)
-        
-        x_test_batch, y_test_batch = batcher(x_test, y_test, batch_size=batch_size)
-
-        model = evaluate(x_test_batch, y_test_batch, W=start_this_W, loading_bar_status=False, activation_potentiation=act_pop, dtype=dtype)
-
-        if loss == 'categorical_crossentropy':
-            test_loss = categorical_crossentropy(y_true_batch=y_test_batch, y_pred_batch=model[get_preds_softmax()])
-        else:
-            test_loss = binary_crossentropy(y_true_batch=y_test_batch, y_pred_batch=model[get_preds_softmax()])
-
-        best_acc = model[get_acc()]
-        best_loss = test_loss
-
+    best_acc = 0
+    best_f1 = 0
+    best_recall = 0
+    best_precision = 0 
     best_acc_per_gen_list = []
     postfix_dict = {}
     loss_list = []
     target_pop = []
 
-    progress = initialize_loading_bar(total=len(activation_potentiation), desc="", ncols=ncols, bar_format=bar_format_learner)
+    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 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 = []
 
     for i in range(gen):
         postfix_dict["Gen"] = str(i+1) + '/' + str(gen)
@@ -334,22 +309,22 @@ def learner(x_train, y_train, optimizer, x_test=None, y_test=None, strategy='acc
         progress.last_print_n = 0
         progress.update(0)
 
-        for j in range(len(activation_potentiation)):
+        for j in range(activation_potentiation_len):
 
-            x_test_batch, y_test_batch = batcher(x_test, y_test, batch_size=batch_size)
+            x_train_batch, y_train_batch = batcher(x_train, y_train, batch_size=batch_size)
             
-            if i == 0:
+            if fit_start is True and i == 0:
                 act_pop.append(activation_potentiation[j])
-                W = fit(x_train, y_train, activation_potentiation=act_pop[-1], train_bar=False, auto_normalization=auto_normalization, dtype=dtype)
+                W = fit(x_train_batch, y_train_batch, activation_potentiation=act_pop[-1], train_bar=False, auto_normalization=auto_normalization, dtype=dtype)
                 weight_pop.append(W)
-
-            model = evaluate(x_test_batch, y_test_batch, W=weight_pop[j], loading_bar_status=False, activation_potentiation=act_pop[j], dtype=dtype)
+            
+            model = evaluate(x_train_batch, y_train_batch, W=weight_pop[j], loading_bar_status=False, activation_potentiation=act_pop[j], dtype=dtype)
             acc = model[get_acc()]
             
             if strategy == 'accuracy': target_pop.append(acc)
 
             elif strategy == 'f1' or strategy == 'precision' or strategy == 'recall':
-                precision_score, recall_score, f1_score = metrics(y_test_batch, model[get_preds()])
+                precision_score, recall_score, f1_score = metrics(y_train_batch, model[get_preds()])
 
                 if strategy == 'precision':
                     target_pop.append(precision_score)
@@ -391,22 +366,22 @@ def learner(x_train, y_train, optimizer, x_test=None, y_test=None, strategy='acc
                     print(f", Current Activations={final_activations}", end='')
 
                 if loss == 'categorical_crossentropy':
-                    test_loss = categorical_crossentropy(y_true_batch=y_test_batch, y_pred_batch=model[get_preds_softmax()])
+                    train_loss = categorical_crossentropy(y_true_batch=y_train_batch, y_pred_batch=model[get_preds_softmax()])
                 else:
-                    test_loss = binary_crossentropy(y_true_batch=y_test_batch, y_pred_batch=model[get_preds_softmax()])
+                    train_loss = binary_crossentropy(y_true_batch=y_train_batch, y_pred_batch=model[get_preds_softmax()])
 
                 if batch_size == 1:
-                    postfix_dict[f"{data} Loss"] = test_loss
-                    best_loss = test_loss
+                    postfix_dict[f"{data} Loss"] = train_loss
+                    best_loss = train_loss
                 else:
-                    postfix_dict[f"{data} Batch Loss"] = test_loss
+                    postfix_dict[f"{data} Batch Loss"] = train_loss
                 progress.set_postfix(postfix_dict)
-                best_loss = test_loss
+                best_loss = train_loss
 
                 # Update visualizations during training
                 if show_history:
                     gen_list = range(1, len(best_acc_per_gen_list) + 2)
-                    update_history_plots_for_learner(viz_objects, gen_list, loss_list + [test_loss], 
+                    update_history_plots_for_learner(viz_objects, gen_list, loss_list + [train_loss], 
                                       best_acc_per_gen_list + [best_acc], x_train, final_activations)
 
                 if neurons_history:
@@ -415,7 +390,7 @@ def learner(x_train, y_train, optimizer, x_test=None, y_test=None, strategy='acc
                                      viz_objects['neurons']['row'], viz_objects['neurons']['col'],
                                      y_train[0], viz_objects['neurons']['artists'],
                                      data=data, fig1=viz_objects['neurons']['fig'],
-                                     acc=best_acc, loss=test_loss)
+                                     acc=best_acc, loss=train_loss)
                     )
 
                 if neural_web_history:
@@ -440,13 +415,10 @@ def learner(x_train, y_train, optimizer, x_test=None, y_test=None, strategy='acc
                     print('\nActivations: ', final_activations)
                     print(f'Train Accuracy (%{batch_size * 100} of train samples):', train_model[get_acc()])
                     print(f'Train Loss (%{batch_size * 100} of train samples): ', train_loss, '\n')
-                    if data == 'Test':
-                        print(f'Test Accuracy (%{batch_size * 100} of test samples): ', best_acc)
-                        print(f'Test Loss (%{batch_size * 100} of test samples): ', best_loss, '\n')
 
                     # Display final visualizations
                     display_visualizations_for_learner(viz_objects, best_weights, data, best_acc, 
-                                              test_loss, y_train, interval)
+                                              train_loss, y_train, interval)
                     return best_weights, best_model[get_preds()], best_acc, final_activations
 
                 # Check target loss
@@ -465,13 +437,10 @@ def learner(x_train, y_train, optimizer, x_test=None, y_test=None, strategy='acc
                     print('\nActivations: ', final_activations)
                     print(f'Train Accuracy (%{batch_size * 100} of train samples):', train_model[get_acc()])
                     print(f'Train Loss (%{batch_size * 100} of train samples): ', train_loss, '\n')
-                    if data == 'Test':
-                        print(f'Test Accuracy (%{batch_size * 100} of test samples): ', best_acc)
-                        print(f'Test Loss (%{batch_size * 100} of test samples): ', best_loss, '\n')
 
                     # Display final visualizations
                     display_visualizations_for_learner(viz_objects, best_weights, data, best_acc, 
-                                              test_loss, y_train, interval)
+                                              train_loss, y_train, interval)
                     return best_weights, best_model[get_preds()], best_acc, final_activations
 
             progress.update(1)
@@ -479,7 +448,7 @@ def learner(x_train, y_train, optimizer, x_test=None, y_test=None, strategy='acc
         best_acc_per_gen_list.append(best_acc)
         loss_list.append(best_loss)
 
-        weight_pop, act_pop = optimizer(np.array(weight_pop, dtype=dtype), act_pop, i, np.array(target_pop, dtype=dtype, copy=False), target_fitness=target_fitness, 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), bar_status=False)
         target_pop = []
 
         # Early stopping check
@@ -499,13 +468,10 @@ def learner(x_train, y_train, optimizer, x_test=None, y_test=None, strategy='acc
                 print('\nActivations: ', final_activations)
                 print(f'Train Accuracy (%{batch_size * 100} of train samples):', train_model[get_acc()])
                 print(f'Train Loss (%{batch_size * 100} of train samples): ', train_loss, '\n')
-                if data == 'Test':
-                    print(f'Test Accuracy (%{batch_size * 100} of test samples): ', best_acc)
-                    print(f'Test Loss (%{batch_size * 100} of test samples): ', best_loss, '\n')
 
                 # Display final visualizations
                 display_visualizations_for_learner(viz_objects, best_weights, data, best_acc, 
-                                          test_loss, y_train, interval)
+                                          train_loss, y_train, interval)
                 return best_weights, best_model[get_preds()], best_acc, final_activations
 
     # Final evaluation
@@ -518,15 +484,12 @@ def learner(x_train, y_train, optimizer, x_test=None, y_test=None, strategy='acc
     else:
         train_loss = binary_crossentropy(y_true_batch=y_train, y_pred_batch=train_model[get_preds_softmax()])
 
-    print('\nActivations: ', act_pop[-1])
+    print('\nActivations: ', final_activations)
     print(f'Train Accuracy (%{batch_size * 100} of train samples):', train_model[get_acc()])
     print(f'Train Loss (%{batch_size * 100} of train samples): ', train_loss, '\n')
-    if data == 'Test':
-        print(f'Test Accuracy (%{batch_size * 100} of test samples): ', best_acc)
-        print(f'Test Loss (%{batch_size * 100} of test samples): ', best_loss, '\n')
 
     # Display final visualizations
-    display_visualizations_for_learner(viz_objects, best_weights, data, best_acc, test_loss, y_train, interval)
+    display_visualizations_for_learner(viz_objects, best_weights, data, best_acc, train_loss, y_train, interval)
     return best_weights, best_model[get_preds()], best_acc, final_activations
 
 
@@ -621,12 +584,12 @@ def evaluate(
         if y_test.dtype != np.uint32:
             y_test = np.array(y_test, copy=False).astype(np.uint32, copy=False)
 
-    predict_probabilitys = np.empty((len(x_test), W.shape[0]), dtype=np.float32)
-    real_classes = np.empty(len(x_test), dtype=np.int32)     
-    predict_classes = np.empty(len(x_test), dtype=np.int32)   
+    predict_probabilitys = np.empty((len(x_test), W.shape[0]), dtype=dtype)
+    real_classes = np.empty(len(x_test), dtype=y_test.dtype)     
+    predict_classes = np.empty(len(x_test), dtype=y_test.dtype)   
 
     true_predict = 0
-    acc_list = np.empty(len(x_test), dtype=np.float32)    
+    acc_list = np.empty(len(x_test), dtype=dtype)    
 
     if loading_bar_status:
         loading_bar = initialize_loading_bar(total=len(x_test), ncols=64, desc='Testing', bar_format=bar_format_normal)

pyerualjetwork/plan_cuda.py

@@ -16,7 +16,6 @@ PYERUALJETWORK document: https://github.com/HCB06/PyerualJetwork/blob/main/Welco
 """
 
 import cupy as cp
-from colorama import Fore
 import math
 
 ### LIBRARY IMPORTS ###
@@ -189,11 +188,11 @@ def fit(
     return normalization(LTPW, dtype=dtype)
 
 
-def learner(x_train, y_train, optimizer, x_test=None, y_test=None, strategy='accuracy', gen=None, batch_size=1,
+def learner(x_train, y_train, optimizer, fit_start, strategy='accuracy', gen=None, batch_size=1,
            neural_web_history=False, show_current_activations=False, auto_normalization=True,
            neurons_history=False, early_stop=False, loss='categorical_crossentropy', show_history=False,
-           interval=33.33, target_acc=None, target_loss=None, except_this=None,
-           only_this=None, start_this_act=None, start_this_W=None, target_fitness='max', dtype=cp.float32, memory='gpu'):
+           interval=33.33, target_acc=None, target_loss=None,
+           start_this_act=None, start_this_W=None, dtype=cp.float32, memory='gpu'):
     """
     Optimizes the activation functions for a neural network by leveraging train data to find 
     the most accurate combination of activation potentiation for the given dataset.
@@ -210,36 +209,33 @@ def learner(x_train, y_train, optimizer, x_test=None, y_test=None, strategy='acc
 
         optimizer (function): PLAN optimization technique with hyperparameters. (PLAN using NEAT(PLANEAT) for optimization.) Please use this: from pyerualjetwork import planeat_cuda (and) optimizer = lambda *args, **kwargs: planeat_cuda.evolve(*args, 'here give your neat hyperparameters for example:  activation_add_prob=0.85', **kwargs) Example:
         ```python
-        genetic_optimizer = lambda *args, **kwargs: planeat_cuda.evolve(*args,
+        genetic_optimizer = lambda *args, **kwargs: planeat_cuda.evolver(*args,
                                                                     activation_add_prob=0.85,
-                                                                    mutations=False,
-                                                                    strategy='cross_over',
+                                                                    mutations=True,
+                                                                    strategy='aggressive',
                                                                     **kwargs)
 
         model = plan_cuda.learner(x_train,
-                             y_train,
-                             optimizer=genetic_optimizer,
-                             strategy='accuracy',
-                             show_history=True,
-                             target_acc=0.94,
-                             interval=16.67)
+                                y_train,
+                                optimizer=genetic_optimizer,
+                                fit_start=True,
+                                strategy='accuracy',
+                                show_history=True,
+                                gen=15,
+                                batch_size=0.05,
+                                interval=16.67)
         ```
-
-        x_test (array-like, optional): Test input data (for improve next gen generilization). If test data is not given then train feedback learning active
-
-        y_test (array-like, optional): Test Labels (for improve next gen generilization). If test data is not given then train feedback learning active
-
+        fit_start (bool): 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. The fit_start parameter is MANDATORY and must be provided.
+        
         strategy (str, optional): Learning strategy. (options: 'accuracy', 'f1', 'precision', 'recall'): 'accuracy', Maximizes train (or test if given) accuracy during learning. 'f1', Maximizes train (or test if given) f1 score during learning. 'precision', Maximizes train (or test if given) precision score during learning. 'recall', Maximizes train (or test if given) recall during learning. Default is 'accuracy'.
 
-        patience ((int, float), optional): patience value for adaptive strategies. For 'adaptive_accuracy' Default value: 5. For 'adaptive_loss' Default value: 0.150.
-
         gen (int, optional): The generation count for genetic optimization.
 
-        batch_size (float, optional): Batch size is used in the prediction process to receive test 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 test batch represents 8% of the test set. Default is 1. (%100 of test)
+        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)
 
-        auto_normalization (bool, optional): If auto normalization=False this makes more faster training times and much better accuracy performance for some datasets. Default is True.
+        early_stop (bool, optional): If True, implements early stopping during training.(If train accuracy not improves in two gen stops learning.) Default is False.
 
-        early_stop (bool, optional): If True, implements early stopping during training.(If test accuracy not improves in two gen stops learning.) Default is False.
+        auto_normalization (bool, optional): IMPORTANT: auto_nomralization parameter works only if fit_start is True. Do not change this value if fit_start is False, because it doesnt matter.) If auto normalization=False this makes more faster training times and much better accuracy performance for some datasets. Default is True.
 
         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
 
@@ -252,10 +248,6 @@ def learner(x_train, y_train, optimizer, x_test=None, y_test=None, strategy='acc
         target_acc (int, 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.
-
-        except_this (list, optional): A list of activations to exclude from optimization. Default is None. (For avaliable activation functions, run this code: plan.activations_list())
-
-        only_this (list, optional): A list of activations to focus on during optimization. Default is None. (For avaliable activation functions, run this code: plan.activations_list())
         
         start_this_act (list, optional): To resume a previously canceled or interrupted training from where it left off, or to continue from that point with a different strategy, provide the list of activation functions selected up to the learned portion to this parameter. Default is None
 
@@ -274,90 +266,65 @@ def learner(x_train, y_train, optimizer, x_test=None, y_test=None, strategy='acc
     
     """
 
-    print(Fore.WHITE + "\nRemember, optimization on large datasets can be very time-consuming and computationally expensive. Therefore, if you are working with such a dataset, our recommendation is to include activation function: ['circular', 'spiral'] in the 'except_this' parameter unless absolutely necessary, as they can significantly prolong the process. from: learner\n" + Fore.RESET)
+    from .planeat_cuda import define_genomes
+
+    data = 'Train'
 
     activation_potentiation = all_activations()
+    activation_potentiation_len = len(activation_potentiation)
 
     y_train = optimize_labels(y_train, cuda=True)
 
-    if x_test is None and y_test is None:
-        x_test = x_train
-        y_test = y_train
-        data = 'Train'
-    else:
-        data = 'Test'
-        y_test = optimize_labels(y_test, cuda=True)
-        
     if memory == 'gpu':
         x_train = transfer_to_gpu(x_train, dtype=dtype)
         y_train = transfer_to_gpu(y_train, dtype=y_train.dtype)
 
-        x_test = transfer_to_gpu(x_test, dtype=dtype)
-        y_test = transfer_to_gpu(y_test, dtype=y_train.dtype)
-
         from .data_operations_cuda import batcher
 
     elif memory == 'cpu':
         x_train = transfer_to_cpu(x_train, dtype=dtype)
         y_train = transfer_to_cpu(y_train, dtype=y_train.dtype)
 
-        x_test = transfer_to_cpu(x_test, dtype=dtype)
-        y_test = transfer_to_cpu(y_test, dtype=y_train.dtype)
-
         from .data_operations import batcher
 
     else:
         raise ValueError("memory parameter must be 'cpu' or 'gpu'.")
 
     if strategy != 'accuracy' and strategy != 'f1' and strategy != 'recall' and strategy != 'precision': raise ValueError("Strategy parameter only be 'accuracy' or 'f1' or 'recall' or 'precision'.")
+    if target_acc is not None and (target_acc < 0 or target_acc > 1): raise ValueError('target_acc must be in range 0 and 1')
+    if fit_start is not True and fit_start is not False: raise ValueError('fit_start parameter only be True or False. Please read doc-string')
 
-    # Filter activation functions
-    if only_this is not None:
-        activation_potentiation = only_this
-    if except_this is not None:
-        activation_potentiation = [item for item in activation_potentiation if item not in except_this]
-    if gen is None:
-        gen = len(activation_potentiation)
-
-    if start_this_act is None and len(activation_potentiation) % 2 != 0: raise ValueError("Activation length must be even number. Please use 'except_this' parameter and except some activation. For example: except_this=['linear']")
-    if start_this_act is not None and len(activation_potentiation) + 1 % 2 != 0: raise ValueError("You are using start_this parameter, activation length still must be even number. Please use 'except_this' parameter and except some activation. For example: except_this=['linear']")
-    
     # Initialize visualization components
     viz_objects = initialize_visualization_for_learner(show_history, neurons_history, neural_web_history, x_train, y_train)
 
     # Initialize progress bar
     if batch_size == 1:
-        ncols = 86
+        ncols = 76
     else:
-        ncols = 99
+        ncols = 89
 
     # Initialize variables
-    act_pop = []
-    weight_pop = []
-    
-    if start_this_act is None and start_this_W is None:
-        best_acc = 0
-    else:
-        act_pop.append(start_this_act)
-        weight_pop.append(start_this_W)
-        
-        x_test_batch, y_test_batch = batcher(x_test, y_test, batch_size=batch_size)
-        model = evaluate(x_test_batch, y_test_batch, W=start_this_W, loading_bar_status=False, activation_potentiation=act_pop, dtype=dtype, memory=memory)
-
-        if loss == 'categorical_crossentropy':
-            test_loss = categorical_crossentropy(y_true_batch=transfer_to_gpu(y_test_batch, dtype=y_test_batch.dtype), y_pred_batch=model[get_preds_softmax()])
-        else:
-            test_loss = binary_crossentropy(y_true_batch=transfer_to_gpu(y_test_batch, dtype=y_test_batch.dtype), y_pred_batch=model[get_preds_softmax()])
-
-        best_acc = model[get_acc()]
-        best_loss = test_loss
-
+    best_acc = 0
+    best_f1 = 0
+    best_recall = 0
+    best_precision = 0 
     best_acc_per_gen_list = []
     postfix_dict = {}
     loss_list = []
     target_pop = []
 
-    progress = initialize_loading_bar(total=len(activation_potentiation), desc="", ncols=ncols, bar_format=bar_format_learner)
+    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 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 = []
 
     for i in range(gen):
         postfix_dict["Gen"] = str(i+1) + '/' + str(gen)
@@ -367,22 +334,22 @@ def learner(x_train, y_train, optimizer, x_test=None, y_test=None, strategy='acc
         progress.last_print_n = 0
         progress.update(0)
 
-        for j in range(len(activation_potentiation)):
+        for j in range(activation_potentiation_len):
 
-            x_test_batch, y_test_batch = batcher(x_test, y_test, batch_size=batch_size)
-            
-            if i == 0:
+            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])
-                W = fit(x_train, y_train, activation_potentiation=act_pop[-1], train_bar=False, auto_normalization=auto_normalization, dtype=dtype)
+                W = fit(x_train_batch, y_train_batch, activation_potentiation=act_pop[-1], train_bar=False, auto_normalization=auto_normalization, dtype=dtype)
                 weight_pop.append(W)
-
-            model = evaluate(x_test_batch, y_test_batch, W=weight_pop[j], loading_bar_status=False, activation_potentiation=act_pop[j], dtype=dtype, memory=memory)
-
+            
+            model = evaluate(x_train_batch, y_train_batch, W=weight_pop[j], loading_bar_status=False, activation_potentiation=act_pop[j], dtype=dtype, memory=memory)
             acc = model[get_acc()]
+            
             if strategy == 'accuracy': target_pop.append(acc)
 
             elif strategy == 'f1' or strategy == 'precision' or strategy == 'recall':
-                precision_score, recall_score, f1_score = metrics(y_test_batch, model[get_preds()])
+                precision_score, recall_score, f1_score = metrics(y_train_batch, model[get_preds()])
 
                 if strategy == 'precision':
                     target_pop.append(precision_score)
@@ -415,31 +382,31 @@ def learner(x_train, y_train, optimizer, x_test=None, y_test=None, strategy='acc
                 final_activations = [final_activations[0]] if len(set(final_activations)) == 1 else final_activations # removing if all same
 
                 if batch_size == 1:
-                    postfix_dict[f"{data} Accuracy"] = best_acc
+                    postfix_dict[f"{data} Accuracy"] = cp.round(best_acc, 3)
                 else:
-                    postfix_dict[f"{data} Batch Accuracy"] = acc
+                    postfix_dict[f"{data} Batch Accuracy"] = cp.round(best_acc, 3)
                 progress.set_postfix(postfix_dict)
 
                 if show_current_activations:
                     print(f", Current Activations={final_activations}", end='')
             
                 if loss == 'categorical_crossentropy':
-                    test_loss = categorical_crossentropy(y_true_batch=transfer_to_gpu(y_test_batch, dtype=y_test_batch.dtype), y_pred_batch=model[get_preds_softmax()])
+                    train_loss = categorical_crossentropy(y_true_batch=transfer_to_gpu(y_train_batch, dtype=y_train_batch.dtype), y_pred_batch=model[get_preds_softmax()])
                 else:
-                    test_loss = binary_crossentropy(y_true_batch=transfer_to_gpu(y_test_batch, dtype=y_test_batch.dtype), y_pred_batch=model[get_preds_softmax()])
+                    train_loss = binary_crossentropy(y_true_batch=transfer_to_gpu(y_train_batch, dtype=y_train_batch.dtype), y_pred_batch=model[get_preds_softmax()])
 
                 if batch_size == 1:
-                    postfix_dict[f"{data} Loss"] = test_loss
-                    best_loss = test_loss
+                    postfix_dict[f"{data} Loss"] = cp.round(train_loss, 3)
+                    best_loss = train_loss
                 else:
-                    postfix_dict[f"{data} Batch Loss"] = test_loss
+                    postfix_dict[f"{data} Batch Loss"] = cp.round(train_loss, 3)
                 progress.set_postfix(postfix_dict)
-                best_loss = test_loss
+                best_loss = train_loss
 
                 # Update visualizations during training
                 if show_history:
                     gen_list = range(1, len(best_acc_per_gen_list) + 2)
-                    update_history_plots_for_learner(viz_objects, gen_list, loss_list + [test_loss], 
+                    update_history_plots_for_learner(viz_objects, gen_list, loss_list + [train_loss], 
                                       best_acc_per_gen_list + [best_acc], x_train, final_activations)
 
                 if neurons_history:
@@ -448,7 +415,7 @@ def learner(x_train, y_train, optimizer, x_test=None, y_test=None, strategy='acc
                                      viz_objects['neurons']['row'], viz_objects['neurons']['col'],
                                      y_train[0], viz_objects['neurons']['artists'],
                                      data=data, fig1=viz_objects['neurons']['fig'],
-                                     acc=best_acc, loss=test_loss)
+                                     acc=best_acc, loss=train_loss)
                     )
 
                 if neural_web_history:
@@ -473,13 +440,10 @@ def learner(x_train, y_train, optimizer, x_test=None, y_test=None, strategy='acc
                     print('\nActivations: ', final_activations)
                     print(f'Train Accuracy (%{batch_size * 100} of train samples):', train_model[get_acc()])
                     print(f'Train Loss (%{batch_size * 100} of train samples): ', train_loss, '\n')
-                    if data == 'Test':
-                        print(f'Test Accuracy (%{batch_size * 100} of test samples): ', best_acc)
-                        print(f'Test Loss (%{batch_size * 100} of test samples): ', best_loss, '\n')
-
+                
                     # Display final visualizations
                     display_visualizations_for_learner(viz_objects, best_weights, data, best_acc, 
-                                              test_loss, y_train, interval)
+                                              train_loss, y_train, interval)
                     return best_weights, best_model[get_preds()], best_acc, final_activations
 
                 # Check target loss
@@ -498,13 +462,10 @@ def learner(x_train, y_train, optimizer, x_test=None, y_test=None, strategy='acc
                     print('\nActivations: ', final_activations)
                     print(f'Train Accuracy (%{batch_size * 100} of train samples):', train_model[get_acc()])
                     print(f'Train Loss (%{batch_size * 100} of train samples): ', train_loss, '\n')
-                    if data == 'Test':
-                        print(f'Test Accuracy (%{batch_size * 100} of test samples): ', best_acc)
-                        print(f'Test Loss (%{batch_size * 100} of test samples): ', best_loss, '\n')
 
                     # Display final visualizations
                     display_visualizations_for_learner(viz_objects, best_weights, data, best_acc, 
-                                              test_loss, y_train, interval)
+                                              train_loss, y_train, interval)
                     return best_weights, best_model[get_preds()], best_acc, final_activations
 
             progress.update(1)
@@ -512,7 +473,7 @@ def learner(x_train, y_train, optimizer, x_test=None, y_test=None, strategy='acc
         best_acc_per_gen_list.append(best_acc)
         loss_list.append(best_loss)
         
-        weight_pop, act_pop = optimizer(cp.array(weight_pop, dtype=dtype), act_pop, i, cp.array(target_pop, dtype=dtype, copy=False), target_fitness=target_fitness, 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), bar_status=False)
         target_pop = []
 
         # Early stopping check
@@ -532,13 +493,10 @@ def learner(x_train, y_train, optimizer, x_test=None, y_test=None, strategy='acc
                 print('\nActivations: ', final_activations)
                 print(f'Train Accuracy (%{batch_size * 100} of train samples):', train_model[get_acc()])
                 print(f'Train Loss (%{batch_size * 100} of train samples): ', train_loss, '\n')
-                if data == 'Test':
-                    print(f'Test Accuracy (%{batch_size * 100} of test samples): ', best_acc)
-                    print(f'Test Loss (%{batch_size * 100} of test samples): ', best_loss, '\n')
 
                 # Display final visualizations
                 display_visualizations_for_learner(viz_objects, best_weights, data, best_acc, 
-                                          test_loss, y_train, interval)
+                                          train_loss, y_train, interval)
                 return best_weights, best_model[get_preds()], best_acc, final_activations
 
     # Final evaluation
@@ -554,12 +512,9 @@ def learner(x_train, y_train, optimizer, x_test=None, y_test=None, strategy='acc
     print('\nActivations: ', final_activations)
     print(f'Train Accuracy (%{batch_size * 100} of train samples):', train_model[get_acc()])
     print(f'Train Loss (%{batch_size * 100} of train samples): ', train_loss, '\n')
-    if data == 'Test':
-        print(f'Test Accuracy (%{batch_size * 100} of test samples): ', best_acc)
-        print(f'Test Loss (%{batch_size * 100} of test samples): ', best_loss, '\n')
 
     # Display final visualizations
-    display_visualizations_for_learner(viz_objects, best_weights, data, best_acc, test_loss, y_train, interval)
+    display_visualizations_for_learner(viz_objects, best_weights, data, best_acc, train_loss, y_train, interval)
     return best_weights, best_model[get_preds()], best_acc, final_activations
 
 

pyerualjetwork/planeat.py

@@ -190,7 +190,7 @@ def evolver(weights,
 
    Raises:
       ValueError: 
-         - If `policy` is not one of the specified values ('aggresive', 'explorer').
+         - If `policy` is not one of the specified values ('aggressive', 'explorer').
          - If 'strategy' is not one of the specified values ('less_selective', 'normal_selective', 'more_selective')
          - If `cross_over_mode` is not one of the specified values ('tpm').
          - If `bad_genomes_mutation_prob`, `activation_mutate_prob`, or other probability parameters are not in the range 0 and 1.
@@ -222,7 +222,7 @@ def evolver(weights,
 
    Example:
       ```python
-      weights, activation_potentiations = planeat.evolver(weights, activation_potentiations, 1, fitness, show_info=True, strategy='normal_selective', policy='aggresive')
+      weights, activation_potentiations = planeat.evolver(weights, activation_potentiations, 1, fitness, show_info=True, strategy='normal_selective', policy='aggressive')
       ```
 
       - The function returns the updated weights and activations after processing based on the chosen strategy, policy, and mutation parameters.
@@ -247,8 +247,6 @@ def evolver(weights,
 
    else:
       raise ValueError("strategy parameter must be: 'normal_selective' or 'more_selective' or 'less_selective'")
-   
-   if policy == 'explorer': fitness_bias = 0
 
    if ((activation_mutate_add_prob < 0 or activation_mutate_add_prob > 1) or 
       (activation_mutate_change_prob < 0 or activation_mutate_change_prob > 1) or 
@@ -328,7 +326,7 @@ def evolver(weights,
                                              cross_over_mode=cross_over_mode,
                                              activation_selection_add_prob=activation_selection_add_prob,
                                              activation_selection_change_prob=activation_selection_change_prob,
-                                             activation_selection_rate=activation_selection_rate,
+                                             threshold=activation_selection_rate,
                                              bad_genomes_selection_prob=bad_genomes_selection_prob,
                                              first_parent_fitness=best_fitness,
                                              fitness_bias=fitness_bias,
@@ -351,8 +349,7 @@ def evolver(weights,
                                                                activation_change_prob=activation_mutate_change_prob, 
                                                                weight_mutate_prob=weight_mutate_prob, 
                                                                threshold=weight_mutate_rate,
-                                                               genome_fitness=normalized_fitness[i],
-                                                               epsilon=epsilon
+                                                               genome_fitness=normalized_fitness[i]
                                                                )
             
          elif mutation_prob < bad_genomes_mutation_prob:
@@ -364,10 +361,9 @@ def evolver(weights,
                                                             activation_change_prob=activation_mutate_change_prob, 
                                                             weight_mutate_prob=weight_mutate_prob, 
                                                             threshold=weight_mutate_rate, 
-                                                            genome_fitness=normalized_fitness[i],
-                                                            epsilon=epsilon
+                                                            genome_fitness=normalized_fitness[i]
                                                             )
-            
+
       if bar_status: progress.update(1)
 
    weights = np.vstack((bad_weights, good_weights))
@@ -397,11 +393,13 @@ def evolver(weights,
       print("  FITNESS BIAS: ", str(fitness_bias))
       print("  ACTIVATION SELECTION RATE (THRESHOLD VALUE FOR SINGLE CROSS OVER):", str(activation_selection_rate) + '\n')
 
+
       print("*** Performance ***")
       print("  MAX FITNESS: ", str(round(max(fitness), 2)))
       print("  MEAN FITNESS: ", str(round(np.mean(fitness), 2)))
       print("  MIN FITNESS: ", str(round(min(fitness), 2)) + '\n')
 
+      print("  BEST GENOME ACTIVATION LENGTH: ", str(len(activation_potentiations[-1])))
       print("  BEST GENOME INDEX: ", str(len(weights)-1))
       print("  NOTE: Genomes are always sorted from the least successful to the most successful according to their performance ranking. Therefore, the genome at the last index is the king of the previous generation. " + '\n')
       
@@ -487,7 +485,7 @@ def cross_over(first_parent_W,
                cross_over_mode,
                activation_selection_add_prob,
                activation_selection_change_prob,
-               activation_selection_rate,
+               threshold,
                bad_genomes_selection_prob,
                first_parent_fitness,
                second_parent_fitness,
@@ -516,7 +514,7 @@ def cross_over(first_parent_W,
         activation_selection_change_prob (float): Probability of replacing an activation function in the child genome 
             with one from the second parent.
         
-        activation_selection_rate (float): Determines how quickly activation functions are added or replaced 
+        threshold (float): Determines how quickly activation functions are added or replaced 
             during the crossover process.
         
         bad_genomes_selection_prob (float): Probability of selecting a "bad" genome for replacement with the offspring.
@@ -549,12 +547,12 @@ def cross_over(first_parent_W,
             cross_over_mode='tpm',
             activation_selection_add_prob=0.8,
             activation_selection_change_prob=0.5,
-            activation_selection_rate=0.1,
+            threshold=2,
             bad_genomes_selection_prob=0.7,
             first_parent_fitness=0.9,
             second_parent_fitness=0.85,
             fitness_bias=0.6,
-            epsilon=np.finfo.eps
+            epsilon=np.finfo(float).eps
         )
         ```
     """
@@ -624,8 +622,8 @@ def cross_over(first_parent_W,
 
    if potential_activation_selection_add > activation_selection_add_prob:
       
-      activation_selection_rate = activation_selection_rate / succes
-      new_threshold = activation_selection_rate
+      threshold = threshold / succes
+      new_threshold = threshold
       
       while True:
          
@@ -635,7 +633,7 @@ def cross_over(first_parent_W,
          child_act.append(random_undominant_activation)
 
          if len(dominant_parent_act) > new_threshold:
-            new_threshold += activation_selection_rate
+            new_threshold += threshold
             pass
          
          else:
@@ -646,8 +644,8 @@ def cross_over(first_parent_W,
 
    if potential_activation_selection_change_prob > activation_selection_change_prob:
       
-      activation_selection_rate = activation_selection_rate / succes
-      new_threshold = activation_selection_rate
+      threshold = threshold / succes
+      new_threshold = threshold
       
       while True:
          
@@ -658,7 +656,7 @@ def cross_over(first_parent_W,
          child_act[random_index_dominant] = random_undominant_activation
 
          if len(dominant_parent_act) > new_threshold:
-            new_threshold += activation_selection_rate
+            new_threshold += threshold
             pass
          
          else:
@@ -674,8 +672,8 @@ def mutation(weight,
              activation_change_prob, 
              weight_mutate_prob, 
              threshold, 
-             genome_fitness,
-             epsilon):
+             genome_fitness
+             ):
    """
     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.
@@ -699,8 +697,6 @@ def mutation(weight,
         threshold (float): If the value you enter here is equal to the result of input layer * output layer, only a single weight will be mutated during each mutation process. If the value you enter here is half of the result of input layer * output layer, two weights in the weight matrix will be mutated.
         
         genome_fitness (float): Fitness value of genome
-    
-        epsilon (float): Small epsilon constant
 
     Returns:
         tuple: A tuple containing:
@@ -730,7 +726,8 @@ def mutation(weight,
       row_end = weight.shape[0]
       col_end = weight.shape[1]
 
-      threshold = threshold * (genome_fitness + epsilon)
+      threshold = threshold * genome_fitness
+      performance_control = 0
       new_threshold = threshold
       
       while True:
@@ -742,10 +739,14 @@ def mutation(weight,
 
          if int(row_end * col_end) > new_threshold:
             new_threshold += threshold
+            performance_control += 1
             pass
          
          else:
             break
+
+         if performance_control >= int(row_end * col_end):
+            break
    
    activation_mutate_prob = 1 - activation_mutate_prob
    potential_activation_mutation = random.uniform(0, 1)

pyerualjetwork/planeat_cuda.py

@@ -248,8 +248,6 @@ def evolver(weights,
 
    else:
       raise ValueError("strategy parameter must be: 'normal_selective' or 'more_selective' or 'less_selective'")
-    
-   if policy =='explorer': fitness_bias = 0
 
    if ((activation_mutate_add_prob < 0 or activation_mutate_add_prob > 1) or 
       (activation_mutate_change_prob < 0 or activation_mutate_change_prob > 1) or 
@@ -328,7 +326,7 @@ def evolver(weights,
                                              cross_over_mode=cross_over_mode,
                                              activation_selection_add_prob=activation_selection_add_prob,
                                              activation_selection_change_prob=activation_selection_change_prob,
-                                             activation_selection_rate=activation_selection_rate,
+                                             threshold=activation_selection_rate,
                                              bad_genomes_selection_prob=bad_genomes_selection_prob,
                                              first_parent_fitness=best_fitness,
                                              fitness_bias=fitness_bias,
@@ -351,8 +349,7 @@ def evolver(weights,
                                                                activation_change_prob=activation_mutate_change_prob, 
                                                                weight_mutate_prob=weight_mutate_prob, 
                                                                threshold=weight_mutate_rate,
-                                                               genome_fitness=normalized_fitness[i],
-                                                               epsilon=epsilon
+                                                               genome_fitness=normalized_fitness[i]
                                                                )
             
          elif mutation_prob < bad_genomes_mutation_prob:
@@ -364,8 +361,7 @@ def evolver(weights,
                                                             activation_change_prob=activation_mutate_change_prob, 
                                                             weight_mutate_prob=weight_mutate_prob, 
                                                             threshold=weight_mutate_rate, 
-                                                            genome_fitness=normalized_fitness[i],
-                                                            epsilon=epsilon
+                                                            genome_fitness=normalized_fitness[i]
                                                             )
             
       if bar_status: progress.update(1)
@@ -401,6 +397,7 @@ def evolver(weights,
       print("  MEAN REWARD: ", str(cp.round(cp.mean(fitness), 2)))
       print("  MIN REWARD: ", str(cp.round(min(fitness), 2)) + '\n')
 
+      print("  BEST GENOME ACTIVATION LENGTH: ", str(len(activation_potentiations)))
       print("  BEST GENOME INDEX: ", str(len(weights)-1))
       print("  NOTE: Genomes are always sorted from the least successful to the most successful according to their performance ranking. Therefore, the genome at the last index is the king of the previous generation. " + '\n')
       
@@ -490,7 +487,7 @@ def cross_over(first_parent_W,
                cross_over_mode,
                activation_selection_add_prob,
                activation_selection_change_prob,
-               activation_selection_rate,
+               threshold,
                bad_genomes_selection_prob,
                first_parent_fitness,
                second_parent_fitness,
@@ -519,7 +516,7 @@ def cross_over(first_parent_W,
         activation_selection_change_prob (float): Probability of replacing an activation function in the child genome 
             with one from the second parent.
         
-        activation_selection_rate (float): Determines how quickly activation functions are added or replaced 
+        threshold (float): Determines how quickly activation functions are added or replaced 
             during the crossover process.
         
         bad_genomes_selection_prob (float): Probability of selecting a "bad" genome for replacement with the offspring.
@@ -552,12 +549,12 @@ def cross_over(first_parent_W,
             cross_over_mode='tpm',
             activation_selection_add_prob=0.8,
             activation_selection_change_prob=0.5,
-            activation_selection_rate=0.1,
+            threshold=2,
             bad_genomes_selection_prob=0.7,
             first_parent_fitness=0.9,
             second_parent_fitness=0.85,
             fitness_bias=0.6,
-            epsilon=cp.finfo.eps
+            epsilon=cp.finfo(float).eps
         )
         ```
     """
@@ -628,8 +625,8 @@ def cross_over(first_parent_W,
 
    if potential_activation_selection_add > activation_selection_add_prob:
       
-      activation_selection_rate = activation_selection_rate / succes
-      new_threshold = activation_selection_rate
+      threshold = threshold / succes
+      new_threshold = threshold
       
       while True:
          
@@ -639,7 +636,7 @@ def cross_over(first_parent_W,
          child_act.append(random_undominant_activation)
 
          if len(dominant_parent_act) > new_threshold:
-            new_threshold += activation_selection_rate
+            new_threshold += threshold
             pass
          
          else:
@@ -650,8 +647,8 @@ def cross_over(first_parent_W,
 
    if potential_activation_selection_change_prob > activation_selection_change_prob:
       
-      activation_selection_rate = activation_selection_rate / succes
-      new_threshold = activation_selection_rate
+      threshold = threshold / succes
+      new_threshold = threshold
       
       while True:
          
@@ -662,7 +659,7 @@ def cross_over(first_parent_W,
          child_act[random_index_dominant] = random_undominant_activation
 
          if len(dominant_parent_act) > new_threshold:
-            new_threshold += activation_selection_rate
+            new_threshold += threshold
             pass
          
          else:
@@ -679,8 +676,7 @@ def mutation(weight,
              activation_change_prob, 
              weight_mutate_prob, 
              threshold, 
-             genome_fitness,
-             epsilon):
+             genome_fitness):
    """
     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.
@@ -705,7 +701,6 @@ def mutation(weight,
         
         genome_fitness (float): Fitness value of genome
     
-        epsilon (float): Small epsilon constant
 
     Returns:
         tuple: A tuple containing:
@@ -735,9 +730,10 @@ def mutation(weight,
       row_end = weight.shape[0]
       col_end = weight.shape[1]
       
-      threshold = threshold * (genome_fitness + epsilon)
+      threshold = threshold * genome_fitness
       new_threshold = threshold
-      
+      performance_control = 0
+
       while True:
          
          selected_row = int(random.uniform(start, row_end))
@@ -747,10 +743,14 @@ def mutation(weight,
 
          if int(row_end * col_end) > new_threshold:
             new_threshold += threshold
+            performance_control += 1
             pass
          
          else:
             break
+
+         if performance_control >= int(row_end * col_end):
+            break
    
    activation_mutate_prob = 1 - activation_mutate_prob
    potential_activation_mutation = random.uniform(0, 1)

{pyerualjetwork-4.2.0b6.dist-info → pyerualjetwork-4.2.2.dist-info}/METADATA

@@ -1,7 +1,7 @@
 Metadata-Version: 2.1
 Name: pyerualjetwork
-Version: 4.2.0b6
-Summary: PyerualJetwork is a machine learning library written in Python for professionals, incorporating advanced, unique, new, and modern techniques.
+Version: 4.2.2
+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
 Keywords: model evaluation,classification,potentiation learning artificial neural networks,NEAT,genetic algorithms,reinforcement learning,neural networks

pyerualjetwork-4.2.2.dist-info/RECORD

@@ -0,0 +1,24 @@
+pyerualjetwork/__init__.py,sha256=UMtN3yCygX5xQf18GGEkRF7UerSr7DM54nxBu7kvc7U,639
+pyerualjetwork/activation_functions.py,sha256=WWOdMd5pI6ZKe-ieKCIsKAYPQODHuXYxx7tzhA5xjes,11767
+pyerualjetwork/activation_functions_cuda.py,sha256=KmXJ5Cdig46XAMYakXFPEOlxSxtFJjD21-i3nGtxPjE,11807
+pyerualjetwork/data_operations.py,sha256=pb5CqJ0Th6fCjTNMCtqQMiwH3KezTxAijacglsKUxmY,14730
+pyerualjetwork/data_operations_cuda.py,sha256=UpoJoFhIwTU4xg9dVuLAxLAT4CkRaGsxvtJG9j1xrNo,17629
+pyerualjetwork/help.py,sha256=nQ_YbYA2RtuafhuvkreNpX0WWL1I_nzlelwCtvei0_Y,775
+pyerualjetwork/loss_functions.py,sha256=6PyBI232SQRGuFnG3LDGvnv_PUdWzT2_2mUODJiejGI,618
+pyerualjetwork/loss_functions_cuda.py,sha256=C93IZJcrOpT6HMK9x1O4AHJWXYTkN5WZiqdssPbvAPk,617
+pyerualjetwork/memory_operations.py,sha256=I7QiZ--xSyRkFF0wcckPwZV7K9emEvyx5aJ3DiRHZFI,13468
+pyerualjetwork/metrics.py,sha256=q7MkhnZDRbCjFBDDfUgrl8lBYnUT_1ro1LxeBq105pI,6077
+pyerualjetwork/metrics_cuda.py,sha256=73h9GC7XwmnFCVzFEEiPQfF8CwHIz2wsCbxpZrJtYgw,5061
+pyerualjetwork/model_operations.py,sha256=RKqnh7-MByFosxqme4q4jC1lOndX26O-OVXYV6ZxoEE,12965
+pyerualjetwork/model_operations_cuda.py,sha256=XnKKq54ZLaqCm-NaJ6d8IToACKcKg2Ttq6moowVRRWo,13365
+pyerualjetwork/plan.py,sha256=YOBF2CqGu400Zk6xuraP0X8WzMNyejpZc5tdVV4dEvE,32219
+pyerualjetwork/plan_cuda.py,sha256=OKK0pmJYLQd5-dJ1aLiyWiZRBmoUp1zBkFxRcxnWBVI,33610
+pyerualjetwork/planeat.py,sha256=hMSyrSPipOxKgOqyoAiZtniVgxPQxc4rRsvEEMOS2Ng,40757
+pyerualjetwork/planeat_cuda.py,sha256=9uopmM-gTZpSb0EOExrOZPT8FF5BqDdEfCX0zYQb9QU,40712
+pyerualjetwork/ui.py,sha256=wu2BhU1k-w3Kcho5Jtq4SEKe68ftaUeRGneUOSCVDjU,575
+pyerualjetwork/visualizations.py,sha256=QaYSIyVkJZ8NqpBKArQKkI1y37nCQo_KIM98IMssnRc,28766
+pyerualjetwork/visualizations_cuda.py,sha256=F60vQ92AXlMgBka3InXnOtGoM25vQJAlBIU2AlYTwks,29200
+pyerualjetwork-4.2.2.dist-info/METADATA,sha256=cUOm0ZcV8oZqpFZ7RuUWnt8nRcBFhSIFH1GNfFDPF4c,7912
+pyerualjetwork-4.2.2.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
+pyerualjetwork-4.2.2.dist-info/top_level.txt,sha256=BRyt62U_r3ZmJpj-wXNOoA345Bzamrj6RbaWsyW4tRg,15
+pyerualjetwork-4.2.2.dist-info/RECORD,,

pyerualjetwork-4.2.0b6.dist-info/RECORD

@@ -1,24 +0,0 @@
-pyerualjetwork/__init__.py,sha256=Kw8tdzAvdhcMyujbsOF0VTVKE5wB-uqKBZ4AH8iNlcQ,2177
-pyerualjetwork/activation_functions.py,sha256=WWOdMd5pI6ZKe-ieKCIsKAYPQODHuXYxx7tzhA5xjes,11767
-pyerualjetwork/activation_functions_cuda.py,sha256=KmXJ5Cdig46XAMYakXFPEOlxSxtFJjD21-i3nGtxPjE,11807
-pyerualjetwork/data_operations.py,sha256=HjyW2QE18age6J8iG0jpbwqGOylL_nM-vE2CLbP9Wes,14690
-pyerualjetwork/data_operations_cuda.py,sha256=UpoJoFhIwTU4xg9dVuLAxLAT4CkRaGsxvtJG9j1xrNo,17629
-pyerualjetwork/help.py,sha256=OZghUy7GZTgEX_i3NYtgcpzUgCDOi6r2vVUF1ROkFiI,774
-pyerualjetwork/loss_functions.py,sha256=6PyBI232SQRGuFnG3LDGvnv_PUdWzT2_2mUODJiejGI,618
-pyerualjetwork/loss_functions_cuda.py,sha256=C93IZJcrOpT6HMK9x1O4AHJWXYTkN5WZiqdssPbvAPk,617
-pyerualjetwork/memory_operations.py,sha256=_Wu9FJc6ozQTPOC2tXfXWPCwUIvPRuDjmLw_McntVSI,13470
-pyerualjetwork/metrics.py,sha256=q7MkhnZDRbCjFBDDfUgrl8lBYnUT_1ro1LxeBq105pI,6077
-pyerualjetwork/metrics_cuda.py,sha256=73h9GC7XwmnFCVzFEEiPQfF8CwHIz2wsCbxpZrJtYgw,5061
-pyerualjetwork/model_operations.py,sha256=hnhR8dtoICNJWIwGgJ65-LN3GYN_DYH4LMe6YpZVbnI,12967
-pyerualjetwork/model_operations_cuda.py,sha256=XnKKq54ZLaqCm-NaJ6d8IToACKcKg2Ttq6moowVRRWo,13365
-pyerualjetwork/plan.py,sha256=EobwajGSIgbOujkzDKb-Kea0LGRHqpK3Xy1Le8VBAe8,34422
-pyerualjetwork/plan_cuda.py,sha256=iCcAHLzVw_VyjhkFHXzBWiedwbnpI1MCXNJgSDgZxWw,36065
-pyerualjetwork/planeat.py,sha256=EtmOUCRmkXGuSj35fU5Y-gvBsRodVlMsEgvbrXIzY2A,40997
-pyerualjetwork/planeat_cuda.py,sha256=XkFbQF7pmPRWCQTacbmIab8yWkq-6S3dM-N1ehxzSvk,40963
-pyerualjetwork/ui.py,sha256=wu2BhU1k-w3Kcho5Jtq4SEKe68ftaUeRGneUOSCVDjU,575
-pyerualjetwork/visualizations.py,sha256=QaYSIyVkJZ8NqpBKArQKkI1y37nCQo_KIM98IMssnRc,28766
-pyerualjetwork/visualizations_cuda.py,sha256=F60vQ92AXlMgBka3InXnOtGoM25vQJAlBIU2AlYTwks,29200
-pyerualjetwork-4.2.0b6.dist-info/METADATA,sha256=-m0uyY5sgobRog9idkhbeSHS5l9h_qDoKywhbG2sAes,7795
-pyerualjetwork-4.2.0b6.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
-pyerualjetwork-4.2.0b6.dist-info/top_level.txt,sha256=BRyt62U_r3ZmJpj-wXNOoA345Bzamrj6RbaWsyW4tRg,15
-pyerualjetwork-4.2.0b6.dist-info/RECORD,,