pyerualjetwork 4.2.1__py3-none-any.whl → 4.2.2b1__py3-none-any.whl

pyerualjetwork/__init__.py

@@ -1,11 +1,11 @@
-__version__ = "4.2.1"
+__version__ = "4.2.2b1"
 __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/deneme.py

@@ -0,0 +1,171 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Thu Jun 20 03:55:15 2024
+
+@author: hasan
+"""
+
+import numpy as np
+from colorama import Fore
+from pyerualjetwork import plan, planeat, data_operations, model_operations
+from sklearn.linear_model import LogisticRegression
+from sklearn.ensemble import RandomForestClassifier
+import xgboost as xgb
+import tensorflow as tf
+from tensorflow.keras.models import Sequential
+from tensorflow.keras.layers import Dense
+from tensorflow.keras.optimizers import RMSprop
+from sklearn.metrics import classification_report, accuracy_score
+from sklearn.datasets import make_blobs
+from matplotlib import pyplot as plt
+
+fig, ax = plt.subplots(2, 3)  # Create a new figure and axe
+
+# Karar sınırı çizimi
+def plot_decision_boundary(x, y, model, feature_indices=[0, 1], h=0.02, model_name='str', ax=None, which_ax1=None, which_ax2=None, W=None, activation_potentiation=None):
+    """
+    Plot decision boundary by focusing on specific feature indices.
+    
+    Parameters:
+    - x: Input data
+    - y: Target labels
+    - model: Trained model
+    - feature_indices: Indices of the features to plot (default: [0, 1])
+    - h: Step size for the mesh grid
+    """
+    x_min, x_max = x[:, feature_indices[0]].min() - 1, x[:, feature_indices[0]].max() + 1
+    y_min, y_max = x[:, feature_indices[1]].min() - 1, x[:, feature_indices[1]].max() + 1
+    xx, yy = np.meshgrid(np.arange(x_min, x_max, h),
+                         np.arange(y_min, y_max, h))
+
+    grid = np.c_[xx.ravel(), yy.ravel()]
+    
+    # Create a full grid with zeros for non-selected features
+    grid_full = np.zeros((grid.shape[0], x.shape[1]))
+    grid_full[:, feature_indices] = grid
+    
+    if model == 'PLAN':
+        
+        Z = [None] * len(grid_full)
+
+        for i in range(len(grid_full)):
+            Z[i] = np.argmax(model_operations.predict_model_ram(grid_full[i], W=W, activation_potentiation=activation_potentiation))
+
+        Z = np.array(Z)
+        Z = Z.reshape(xx.shape)
+
+    else:
+
+        # Predict on the grid
+        #for i in range(len(grid_full)): grid_full[i] = activation_functions.apply_activation(grid_full[i], ['tanh', 'relu', 'elu', 'selu'])
+        Z = model.predict(grid_full)
+
+        if model_name == 'Deep Learning':
+            Z = np.argmax(Z, axis=1)  # Get class predictions
+
+        Z = Z.reshape(xx.shape)
+
+    # Plot decision boundary
+    ax[which_ax1, which_ax2].contourf(xx, yy, Z, alpha=0.8)
+    ax[which_ax1, which_ax2].scatter(x[:, feature_indices[0]], x[:, feature_indices[1]], c=np.argmax(y, axis=1), edgecolors='k', marker='o', s=20, alpha=0.9)
+    ax[which_ax1, which_ax2].set_xlabel(f'Feature {feature_indices[0] + 1}')
+    ax[which_ax1, which_ax2].set_ylabel(f'Feature {feature_indices[1] + 1}')
+    ax[which_ax1, which_ax2].set_title(model_name)
+
+
+X, y = make_blobs(n_samples=1000, centers=5, random_state=42)
+
+# Eğitim, test ve doğrulama verilerini ayırma
+x_train, x_test, y_train, y_test = data_operations.split(X, y, test_size=0.4, random_state=42) # For less train data use this: (X, y, test_size=0.9, random_state=42)
+
+# One-hot encoding işlemi
+y_train, y_test = data_operations.encode_one_hot(y_train, y_test)
+
+
+# Veri dengesizliği durumunu otomatik dengeleme
+x_train, y_train = data_operations.auto_balancer(x_train, y_train)
+scaler_params, x_train, x_test = data_operations.standard_scaler(x_train, x_test)
+
+# Lojistik Regresyon Modeli
+print(Fore.YELLOW + "------Lojistik Regresyon Sonuçları------" + Fore.RESET)
+lr_model = LogisticRegression(max_iter=1000, random_state=42)
+y_train_decoded = data_operations.decode_one_hot(y_train)
+lr_model.fit(x_train, y_train_decoded)
+
+y_test_decoded = plan.decode_one_hot(y_test)
+y_pred_lr = lr_model.predict(x_test)
+test_acc_lr = accuracy_score(y_test_decoded, y_pred_lr)
+print(f"Lojistik Regresyon Test Accuracy: {test_acc_lr:.4f}")
+print(classification_report(y_test_decoded, y_pred_lr))
+# Karar sınırını görselleştir
+plot_decision_boundary(x_test, y_test, lr_model, feature_indices=[0, 1], model_name='Logistic Regression', ax=ax, which_ax1=0, which_ax2=0)
+
+# Random Forest Modeli
+print(Fore.CYAN + "------Random Forest Sonuçları------" + Fore.RESET)
+rf_model = RandomForestClassifier(n_estimators=100, random_state=42)
+rf_model.fit(x_train, y_train_decoded)
+y_pred_rf = rf_model.predict(x_test)
+test_acc_rf = accuracy_score(y_test_decoded, y_pred_rf)
+print(f"Random Forest Test Accuracy: {test_acc_rf:.4f}")
+print(classification_report(y_test_decoded, y_pred_rf))
+# Karar sınırını görselleştir
+plot_decision_boundary(x_test, y_test, rf_model, feature_indices=[0, 1], model_name='Random Forest', ax=ax, which_ax1=0, which_ax2=1)
+
+# XGBoost Modeli
+print(Fore.MAGENTA + "------XGBoost Sonuçları------" + Fore.RESET)
+xgb_model = xgb.XGBClassifier(use_label_encoder=False, eval_metric='mlogloss', random_state=42)
+xgb_model.fit(x_train, y_train_decoded)
+y_pred_xgb = xgb_model.predict(x_test)
+test_acc_xgb = accuracy_score(y_test_decoded, y_pred_xgb)
+print(f"XGBoost Test Accuracy: {test_acc_xgb:.4f}")
+print(classification_report(y_test_decoded, y_pred_xgb))
+# Karar sınırını görselleştir
+plot_decision_boundary(x_test, y_test, xgb_model, feature_indices=[0, 1], model_name='XGBoost', ax=ax, which_ax1=0, which_ax2=2)
+
+# Derin Öğrenme Modeli (Yapay Sinir Ağı)
+
+input_dim = x_train.shape[1]  # Giriş boyutu
+
+
+model = Sequential()
+model.add(Dense(32, activation='relu', input_dim=input_dim))
+model.add(Dense(64, activation='tanh'))
+model.add(Dense(32, activation='relu'))
+model.add(Dense(64, activation='tanh'))
+model.add(Dense(y_train.shape[1], activation='softmax'))
+
+# Model derlemesi
+model.compile(optimizer=RMSprop(), loss='binary_crossentropy', metrics=['accuracy'])
+
+# Model eğitimi (early stopping ile)
+early_stop = tf.keras.callbacks.EarlyStopping(monitor='loss', patience=10, restore_best_weights=True)
+model.fit(x_train, y_train, epochs=5, batch_size=32, callbacks=[early_stop], verbose=1)
+
+# Test verileri üzerinde modelin performansını değerlendirme
+y_pred_dl = model.predict(x_test)
+y_pred_dl_classes = np.argmax(y_pred_dl, axis=1)  # Tahmin edilen sınıflar
+y_test_decoded_dl = plan.decode_one_hot(y_test)
+print(Fore.BLUE + "------Derin Öğrenme (ANN) Sonuçları------" + Fore.RESET)
+test_acc_dl = accuracy_score(y_test_decoded_dl, y_pred_dl_classes)
+print(f"Derin Öğrenme Test Accuracy: {test_acc_dl:.4f}")
+print(classification_report(y_test_decoded_dl, y_pred_dl_classes))
+# Karar sınırını görselleştir
+plot_decision_boundary(x_test, y_test, model=model, feature_indices=[0, 1], model_name='Deep Learning', ax=ax, which_ax1=1, which_ax2=0)
+
+# PLAN Modeli
+# Configuring optimizer
+genetic_optimizer = lambda *args, **kwargs: planeat.evolver(*args, **kwargs)
+
+model = plan.learner(x_train, y_train, genetic_optimizer, batch_size=0.05, gen=15) # learner function = TFL(Test Feedback Learning). If test parameters not given then uses Train Feedback. More information: https://github.com/HCB06/pyerualjetwork/blob/main/Welcome_to_PLAN/PLAN.pdf
+
+W = model[model_operations.get_weights()]
+activation_potentiation = model[model_operations.get_act_pot()]
+
+test_model = plan.evaluate(x_test, y_test, W=W, activation_potentiation=activation_potentiation)
+test_acc_plan = test_model[model_operations.get_acc()]
+print(Fore.GREEN + "------PLAN Modeli Sonuçları------" + Fore.RESET)
+print(f"PLAN Test Accuracy: {test_acc_plan:.4f}")
+print(classification_report(plan.decode_one_hot(y_test), test_model[model_operations.get_preds()]))
+# Karar sınırını görselleştir
+plot_decision_boundary(x_test, y_test, model='PLAN', feature_indices=[0, 1], model_name='PLAN', ax=ax, which_ax1=1, which_ax2=1, W=W, activation_potentiation=activation_potentiation)
+plt.show()

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,
-           neural_web_history=False, show_current_activations=False, auto_normalization=True,
+def learner(x_train, y_train, optimizer, strategy='accuracy', gen=None, batch_size=1,
+           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, 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. 
@@ -206,23 +205,18 @@ def learner(x_train, y_train, optimizer, x_test=None, y_test=None, strategy='acc
                              optimizer=genetic_optimizer,
                              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
-
         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)
-
-        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.
+        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)
 
-        early_stop (bool, optional): If True, implements early stopping during training.(If test accuracy not improves in two gen stops learning.) Default is False.
+        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
 
@@ -235,10 +229,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 +237,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 +245,23 @@ 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
+
+    data = 'Train'
 
-    activation_potentiation = all_activations()
+    activation_potentiation_len = len(all_activations())
 
     # 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 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)
 
@@ -300,31 +274,23 @@ def learner(x_train, y_train, optimizer, x_test=None, y_test=None, strategy='acc
     # 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)
+
+    weight_pop, act_pop = define_genomes(input_shape=len(x_train[0]), output_shape=len(y_train[0]), population_size=activation_potentiation_len)
+    
+    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
 
     for i in range(gen):
         postfix_dict["Gen"] = str(i+1) + '/' + str(gen)
@@ -334,22 +300,16 @@ 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)):
-
-            x_test_batch, y_test_batch = batcher(x_test, y_test, batch_size=batch_size)
-            
-            if 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)
-                weight_pop.append(W)
+        for j in range(activation_potentiation_len):
 
-            model = evaluate(x_test_batch, y_test_batch, W=weight_pop[j], loading_bar_status=False, activation_potentiation=act_pop[j], dtype=dtype)
+            x_train_batch, y_train_batch = batcher(x_train, y_train, batch_size=batch_size)
+            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 +351,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 +375,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 +400,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 +422,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 +433,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(weight_pop, act_pop, i, np.array(target_pop, dtype=dtype, copy=False), bar_status=False)
         target_pop = []
 
         # Early stopping check
@@ -499,13 +453,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 +469,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
 
 

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,
-           neural_web_history=False, show_current_activations=False, auto_normalization=True,
+def learner(x_train, y_train, optimizer, strategy='accuracy', gen=None, batch_size=1,
+           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, 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.
@@ -217,29 +216,22 @@ def learner(x_train, y_train, optimizer, x_test=None, y_test=None, strategy='acc
                                                                     **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,
+                                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
-
         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 test accuracy not improves in two gen stops learning.) Default is False.
+        early_stop (bool, optional): If True, implements early stopping during training.(If train 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
 
@@ -252,10 +244,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,20 +262,14 @@ 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
 
-    activation_potentiation = all_activations()
+    data = 'Train'
+
+    activation_potentiation_len = len(all_activations())
 
     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)
@@ -310,17 +292,7 @@ def learner(x_train, y_train, optimizer, x_test=None, y_test=None, strategy='acc
         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'.")
-
-    # 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']")
+    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')
     
     # Initialize visualization components
     viz_objects = initialize_visualization_for_learner(show_history, neurons_history, neural_web_history, x_train, y_train)
@@ -335,29 +307,22 @@ def learner(x_train, y_train, optimizer, x_test=None, y_test=None, strategy='acc
     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)
+
+    weight_pop, act_pop = define_genomes(input_shape=len(x_train[0]), output_shape=len(y_train[0]), population_size=activation_potentiation_len)
+    
+    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
 
     for i in range(gen):
         postfix_dict["Gen"] = str(i+1) + '/' + str(gen)
@@ -367,22 +332,16 @@ 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)):
-
-            x_test_batch, y_test_batch = batcher(x_test, y_test, batch_size=batch_size)
-            
-            if 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)
-                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)
+        for j in range(activation_potentiation_len):
 
+            x_train_batch, y_train_batch = batcher(x_train, y_train, batch_size=batch_size)
+            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)
@@ -424,22 +383,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=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"] = 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:
@@ -448,7 +407,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 +432,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 +454,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 +465,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(weight_pop, act_pop, i, cp.array(target_pop, dtype=dtype, copy=False), bar_status=False)
         target_pop = []
 
         # Early stopping check
@@ -532,13 +485,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 +504,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

@@ -17,10 +17,10 @@ import random
 import math
 
 ### LIBRARY IMPORTS ###
-from .plan import feed_forward
-from .data_operations import normalization
-from .ui import loading_bars, initialize_loading_bar
-from .activation_functions import apply_activation, all_activations
+from plan import feed_forward
+from data_operations import normalization
+from ui import loading_bars, initialize_loading_bar
+from activation_functions import apply_activation, all_activations
 
 def define_genomes(input_shape, output_shape, population_size, dtype=np.float32):
    """
@@ -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,7 +547,7 @@ 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,
@@ -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,7 +549,7 @@ 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,
@@ -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.1.dist-info → pyerualjetwork-4.2.2b1.dist-info}/METADATA

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

@@ -1,24 +1,25 @@
-pyerualjetwork/__init__.py,sha256=VhaX5FzNtwSCXlCCWPHIdrSCTimD14fwAnfZQcDjTqQ,646
+pyerualjetwork/__init__.py,sha256=S17EvWZTRS5-syTAdq8gQNAfuzqHEMStWH5I6fI5KnQ,641
 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/deneme.py,sha256=6b_g1ZyJRhPtqH5D5yUGeOKO6eHMwklUQenccs4G060,7869
 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=hnhR8dtoICNJWIwGgJ65-LN3GYN_DYH4LMe6YpZVbnI,12967
+pyerualjetwork/model_operations.py,sha256=RKqnh7-MByFosxqme4q4jC1lOndX26O-OVXYV6ZxoEE,12965
 pyerualjetwork/model_operations_cuda.py,sha256=XnKKq54ZLaqCm-NaJ6d8IToACKcKg2Ttq6moowVRRWo,13365
-pyerualjetwork/plan.py,sha256=hvgRaJgz_31ixI6XDy_lkucQwbAN0iIqAj4aTc0oFiw,34422
-pyerualjetwork/plan_cuda.py,sha256=ZTScc7VlqBLKUh6OtweJeGh-gf244nlPHTOeYrNaIyg,36065
-pyerualjetwork/planeat.py,sha256=hofSkdFHoGXP52GUpTOQ-QwhPF2Vf6zwEdoesfpmWxU,41006
-pyerualjetwork/planeat_cuda.py,sha256=0DOU1cL-JeifSAF9Q_bBpEeAJp9zxB7_oS_GyNepixo,40970
+pyerualjetwork/plan.py,sha256=mACNJnHlPkeqsHDYw0BVDXp8PCOlwWsF-1KD4a2Bk7U,30431
+pyerualjetwork/plan_cuda.py,sha256=aSzXyIZtq38nszW9f9JibvqoEHBCYXvVLaXMVigUUKI,32016
+pyerualjetwork/planeat.py,sha256=yLPQXO754lBv48f1MXdGodP93KstryeRG3HuUaRwj6g,40753
+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.1.dist-info/METADATA,sha256=1kq1oOOpZna0dDry5QSj3L8odHpHG73rf6KRbBHpE4o,7912
-pyerualjetwork-4.2.1.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
-pyerualjetwork-4.2.1.dist-info/top_level.txt,sha256=BRyt62U_r3ZmJpj-wXNOoA345Bzamrj6RbaWsyW4tRg,15
-pyerualjetwork-4.2.1.dist-info/RECORD,,
+pyerualjetwork-4.2.2b1.dist-info/METADATA,sha256=XBf-qok9_lB70pHC8EgwyPGxmCC9l-Penu0MiYc9Wvo,7914
+pyerualjetwork-4.2.2b1.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
+pyerualjetwork-4.2.2b1.dist-info/top_level.txt,sha256=BRyt62U_r3ZmJpj-wXNOoA345Bzamrj6RbaWsyW4tRg,15
+pyerualjetwork-4.2.2b1.dist-info/RECORD,,