pyerualjetwork 4.3.9.dev2__py3-none-any.whl → 4.3.10__py3-none-any.whl

pyerualjetwork/__init__.py

@@ -1,11 +1,33 @@
-__version__ = "4.3.9dev2"
-__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"
+__version__ = "4.3.10"
+__update__ = """* Changes: https://github.com/HCB06/PyerualJetwork/blob/main/CHANGES
+* PyerualJetwork Homepage: https://github.com/HCB06/PyerualJetwork/tree/main
+* PyerualJetwork document: https://github.com/HCB06/PyerualJetwork/blob/main/Welcome_to_PyerualJetwork/PYERUALJETWORK_USER_MANUEL_AND_LEGAL_INFORMATION(EN).pdf
+* YouTube tutorials: https://www.youtube.com/@HasanCanBeydili"""
 
-def print_version(__version__):
-    print(f"PyerualJetwork Version {__version__}" + '\n')
+def print_version(version):
+    print(f"PyerualJetwork Version {version}\n")
 
-def print_update_notes(__update__):
-    print(f"Notes:\n{__update__}")
+def print_update_notes(update):
+    print(f"Notes:\n{update}")
 
 print_version(__version__)
-print_update_notes(__update__)
+print_update_notes(__update__)
+
+required_modules = ["scipy", "tqdm", "pandas", "numpy", "colorama", "cupy", "psutil"]
+
+missing_modules = []
+for module in required_modules:
+    try:
+        __import__(module)
+    except ModuleNotFoundError:
+        missing_modules.append(module)
+
+if missing_modules:
+    raise ImportError(
+    f"Missing modules detected: {', '.join(missing_modules)}\n"
+    "Please run the following command to install the missing packages:\n\n"
+    f"    pip install {' '.join(missing_modules)}\n\n"
+    "For more information, visit the PyerualJetwork GitHub README.md file:\n"
+    "https://github.com/HCB06/PyerualJetwork/blob/main/README.md"
+
+    )

pyerualjetwork/fitness_functions.py

@@ -1,75 +1,16 @@
-import numpy as np
-from scipy.spatial.distance import pdist
-
-def diversity_score(population):
+def wals(acc, loss, acc_impact, loss_impact):
     """
-    Calculates the diversity score of a population based on the
-    Euclidean distances between individuals in the population.
+    The WALS(weighted accuracy-loss score) function calculates a weighted sum of accuracy and loss based on their respective impacts.
     
-    :param population: That calculates the diversity score of a population based on the Euclidean distances between
-    individuals in the population
-    :return: The function returns the diversity score,
-    which is a measure of how spread out or diverse the population is in terms of their characteristics.
+    :param acc: The `acc` parameter represents the accuracy of a model or system
+    :param loss: The `loss` parameter in the `wals` function represents the amount of loss incurred. It
+    is used in the calculation to determine the overall impact based on the accuracy and loss impacts
+    provided
+    :param acc_impact: The `acc_impact` parameter represents the impact of accuracy on the overall score
+    calculation in the `wals` function. It is a multiplier that determines how much the accuracy
+    contributes to the final result
+    :param loss_impact: The `loss_impact` parameter in the `wals` function represents the weight of loss value when calculating the overall impact. It is used to determine how
+     much the loss affects the final result compared to the accuracy impact
+    :return: the weighted sum of accuracy and loss based on their respective impacts.
     """
-    if len(population) < 2:
-        return 0
-
-    distances = pdist(population, metric='euclidean')
-
-    if np.isnan(distances).any() or np.any(distances == 0):
-        distances = np.maximum(distances, 1e-10)
-    avg_distance = np.mean(distances)
-
-    if population.shape[1] == 0:
-        return 0
-
-    max_possible_distance = np.sqrt(population.shape[1])
-
-    if max_possible_distance == 0:
-        max_possible_distance = 1e-10
-
-    diversity = avg_distance / max_possible_distance
-    
-    return diversity
-
-
-
-def hybrid_accuracy_confidence(y_true, y_pred, diversity_score, accuracy, alpha=2, beta=1.5, lambda_div=0.05):
-    """
-    The function calculates a fitness score based on accuracy, margin loss, and diversity score using
-    specified parameters.
-    
-    @param y_true The `y_true` parameter represents the true labels of the data points. It is an array
-    or list containing the actual labels of the data points.
-    @param y_pred The `y_pred` parameter in the `hybrid_accuracy_confidence` function represents the
-    predicted values for a given dataset. It is a NumPy array containing the predicted values for each
-    sample in the dataset.
-    @param diversity_score The `diversity_score` parameter in the `hybrid_accuracy_confidence` function
-    represents a measure of diversity in the predictions. It is used as a factor in calculating the
-    fitness of the model. The function combines accuracy, margin loss, and diversity score to evaluate
-    the overall performance of the model
-    @param accuracy Accuracy is a measure of the correct predictions made by a model. It is typically
-    calculated as the number of correct predictions divided by the total number of predictions. In the
-    context of the `hybrid_accuracy_confidence` function, the accuracy parameter represents the accuracy
-    of the model's predictions.
-    @param alpha Alpha is a parameter that controls the impact of accuracy on the overall fitness score
-    in the hybrid_accuracy_confidence function. It is used as an exponent to raise the accuracy value
-    to, influencing its contribution to the fitness calculation.
-    @param beta The `beta` parameter in the `hybrid_accuracy_confidence` function is used as an exponent
-    in the fitness calculation formula. It controls the impact of the margin loss term on the overall
-    fitness value. A higher value of `beta` will amplify the effect of the margin loss term, making it
-    @param lambda_div The `lambda_div` parameter in the `hybrid_accuracy_confidence` function represents
-    the weight given to the diversity score in calculating the fitness value. It is a hyperparameter
-    that controls the impact of diversity score on the overall fitness calculation. A higher value of
-    `lambda_div` will increase the importance
-    @return The function `hybrid_accuracy_confidence` returns the fitness value calculated based on the
-    input parameters `y_true`, `y_pred`, `diversity_score`, `accuracy`, and optional parameters `alpha`,
-    `beta`, and `lambda_div`. The fitness value is computed using a formula that combines accuracy,
-    margin loss, and diversity score with specified weights and coefficients.
-    """
-    incorrect = y_true != y_pred
-    margin_loss = np.abs(y_true[incorrect] - y_pred[incorrect]).mean() if np.any(incorrect) else 0
-
-    fitness = (accuracy ** alpha) * ((1 - margin_loss) ** beta) * (1 + lambda_div * diversity_score)
-    
-    return fitness
+    return (acc * acc_impact) + (-loss * loss_impact)

pyerualjetwork/loss_functions.py

@@ -0,0 +1,21 @@
+
+import numpy as np
+
+def categorical_crossentropy(y_true_batch, y_pred_batch):
+    epsilon = 1e-7
+    y_pred_batch = np.clip(y_pred_batch, epsilon, 1. - epsilon)
+    
+    losses = -np.sum(y_true_batch * np.log(y_pred_batch), axis=1)
+
+    mean_loss = np.mean(losses)
+    return mean_loss
+
+
+def binary_crossentropy(y_true_batch, y_pred_batch):
+    epsilon = 1e-7
+    y_pred_batch = np.clip(y_pred_batch, epsilon, 1. - epsilon)
+    
+    losses = -np.mean(y_true_batch * np.log(y_pred_batch) + (1 - y_true_batch) * np.log(1 - y_pred_batch), axis=1)
+
+    mean_loss = np.mean(losses)
+    return mean_loss

pyerualjetwork/plan.py

@@ -6,7 +6,7 @@ MAIN MODULE FOR PLAN
 Examples: https://github.com/HCB06/PyerualJetwork/tree/main/Welcome_to_PyerualJetwork/ExampleCodes
 
 PLAN document: https://github.com/HCB06/PyerualJetwork/blob/main/Welcome_to_PLAN/PLAN.pdf
-PYERUALJETWORK document: https://github.com/HCB06/PyerualJetwork/blob/main/Welcome_to_PyerualJetwork/PYERUALJETWORK_USER_MANUEL_AND_LEGAL_INFORMATION(EN).pdf
+PyerualJetwork document: https://github.com/HCB06/PyerualJetwork/blob/main/Welcome_to_PyerualJetwork/PYERUALJETWORK_USER_MANUEL_AND_LEGAL_INFORMATION(EN).pdf
 
 @author: Hasan Can Beydili
 @YouTube: https://www.youtube.com/@HasanCanBeydili
@@ -21,9 +21,10 @@ import numpy as np
 from .ui import loading_bars, initialize_loading_bar
 from .data_operations import normalization, batcher
 from .activation_functions import apply_activation, all_activations
-from .metrics import metrics
-from .model_operations import get_acc, get_preds, get_preds_softmax
+from .model_operations import get_acc, get_preds_softmax
 from .memory_operations import optimize_labels
+from .loss_functions import categorical_crossentropy, binary_crossentropy
+from .fitness_functions import wals
 from .visualizations import (
     draw_neural_web,
     display_visualizations_for_learner,
@@ -82,10 +83,10 @@ def fit(
     return normalization(weight, dtype=dtype)
 
 
-def learner(x_train, y_train, optimizer, fitness, fit_start=True, gen=None, batch_size=1, pop_size=None,
+def learner(x_train, y_train, optimizer, fit_start=True, gen=None, batch_size=1, pop_size=None,
            neural_web_history=False, show_current_activations=False, auto_normalization=False,
-           neurons_history=False, early_stop=False, show_history=False,
-           interval=33.33, target_acc=None,
+           neurons_history=False, early_stop=False, show_history=False, target_loss=None,
+           interval=33.33, target_acc=None, loss='categorical_crossentropy', acc_impact=0.9, loss_impact=0.1,
            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 
@@ -104,37 +105,26 @@ def learner(x_train, y_train, optimizer, fitness, fit_start=True, gen=None, batc
         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
         optimizer = lambda *args, **kwargs: planeat.evolver(*args,
-                                                            activation_add_prob=0.85,
+                                                            activation_add_prob=0.05,
                                                             strategy='aggressive',
+                                                            policy='more_selective',
                                                             **kwargs)
 
         model = plan.learner(x_train,
                              y_train,
                              optimizer,
-                             fitness,
                              fit_start=True,
-                             strategy='accuracy',
                              show_history=True,
                              gen=15,
                              batch_size=0.05,
                              interval=16.67)
         ```
 
-        fitness (function): Fitness function. We have 'hybrid_accuracy_confidence' function in the fitness_functions module. Use this: from pyerualjetwork import fitness_functions (and) fitness_function = lambda *args, **kwargs: fitness_functions.hybrid_accuracy_confidence(*args, 'here give your fitness function hyperparameters for example: alpha=2, beta=1.5, lambda_div=0.05', **kwargs) Example:
-        ```python
-        fitness = lambda *args, **kwargs: fitness_functions.hybrid_accuracy_confidence(*args, alpha=2, beta=1.5, lambda_div=0.05, **kwargs)
+        loss (str, optional): For visualizing and monitoring. PLAN neural networks doesn't need any loss function in training. options: ('categorical_crossentropy' or 'binary_crossentropy') Default is 'categorical_crossentropy'.
 
-        model = plan.learner(x_train,
-                             y_train,
-                             optimizer,
-                             fitness
-                             fit_start=True,
-                             strategy='accuracy',
-                             show_history=True,
-                             gen=15,
-                             batch_size=0.05,
-                             interval=16.67)
-        ```
+        target_acc (float, 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.
         
         fit_start (bool, optional): 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. Default: True
 
@@ -171,7 +161,6 @@ def learner(x_train, y_train, optimizer, fitness, fit_start=True, gen=None, batc
     
     """
 
-    from .fitness_functions import diversity_score
     from .planeat import define_genomes
 
     data = 'Train'
@@ -189,8 +178,7 @@ def learner(x_train, y_train, optimizer, fitness, fit_start=True, gen=None, batc
 
     if pop_size < activation_potentiation_len: raise ValueError(f"pop_size must be higher or equal to {activation_potentiation_len}")
 
-    if gen is None:
-        gen = activation_potentiation_len
+    if gen is None: gen = activation_potentiation_len
 
     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')
@@ -200,13 +188,14 @@ def learner(x_train, y_train, optimizer, fitness, fit_start=True, gen=None, batc
 
     # Initialize variables
     best_acc = 0
-    best_fit = 0
+    best_loss = float('inf')
+    best_fitness = float('-inf')
     best_acc_per_gen_list = []
     postfix_dict = {}
-    fit_list = []
+    loss_list = []
     target_pop = []
 
-    progress = initialize_loading_bar(total=activation_potentiation_len, desc="", ncols=78, bar_format=bar_format_learner)
+    progress = initialize_loading_bar(total=activation_potentiation_len, desc="", ncols=77, bar_format=bar_format_learner)
 
     if fit_start is False or pop_size > activation_potentiation_len:
         weight_pop, act_pop = define_genomes(input_shape=len(x_train[0]), output_shape=len(y_train[0]), population_size=pop_size, dtype=dtype)
@@ -219,6 +208,7 @@ def learner(x_train, y_train, optimizer, fitness, fit_start=True, gen=None, batc
         weight_pop[0] = start_this_W
         act_pop[0] = start_this_act
 
+    # LEARNING STARTED
     for i in range(gen):
         postfix_dict["Gen"] = str(i+1) + '/' + str(gen)
         progress.set_postfix(postfix_dict)
@@ -242,51 +232,52 @@ def learner(x_train, y_train, optimizer, fitness, fit_start=True, gen=None, batc
             model = evaluate(x_train_batch, y_train_batch, W=weight_pop[j], activation_potentiation=act_pop[j])
             acc = model[get_acc()]
             
-            div_score = diversity_score(W)
-            fit_score = fitness(y_train_batch, model[get_preds_softmax()], div_score, acc)
+            if loss == 'categorical_crossentropy':
+                train_loss = categorical_crossentropy(y_true_batch=y_train_batch, 
+                                                           y_pred_batch=model[get_preds_softmax()])
+            else:
+                train_loss = binary_crossentropy(y_true_batch=y_train_batch, 
+                                            y_pred_batch=model[get_preds_softmax()])
 
-            target_pop.append(fit_score)
+            fitness  = wals(acc, train_loss, acc_impact, loss_impact)
+            target_pop.append(fitness)
 
-            if fit_score >= best_fit:
+            if fitness >= best_fitness:
 
+                best_fitness = fitness
                 best_acc = acc
-                best_fit = fit_score
-                best_weights = np.copy(weight_pop[j])
-                final_activations = act_pop[j].copy() if isinstance(act_pop[j], list) else act_pop[j]
-
+                best_loss = train_loss
+                best_weight = np.copy(weight_pop[j])
                 best_model = model
 
+                final_activations = act_pop[j].copy() if isinstance(act_pop[j], list) else act_pop[j]
                 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"] = np.round(best_acc, 4)
+                    postfix_dict[f"{data} Loss"] = np.round(train_loss, 4)
                     progress.set_postfix(postfix_dict)
 
                 if show_current_activations:
                     print(f", Current Activations={final_activations}", end='')
 
-                if batch_size == 1:
-                    postfix_dict[f"{data} Fitness"] = np.round(fit_score, 4)
-                    progress.set_postfix(postfix_dict)
-                best_fit = fit_score
-
                 # 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, fit_list + [fit_score], 
+                    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:
                     viz_objects['neurons']['artists'] = (
-                        update_neuron_history_for_learner(np.copy(best_weights), viz_objects['neurons']['ax'],
+                        update_neuron_history_for_learner(np.copy(best_weight), viz_objects['neurons']['ax'],
                                      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=fit_score)
+                                     acc=best_acc, loss=train_loss)
                     )
 
                 if neural_web_history:
-                    art5_1, art5_2, art5_3 = draw_neural_web(W=best_weights, ax=viz_objects['web']['ax'],
+                    art5_1, art5_2, art5_3 = draw_neural_web(W=best_weight, ax=viz_objects['web']['ax'],
                                                             G=viz_objects['web']['G'], return_objs=True)
                     art5_list = [art5_1] + [art5_2] + list(art5_3.values())
                     viz_objects['web']['artists'].append(art5_list)
@@ -294,46 +285,68 @@ def learner(x_train, y_train, optimizer, fitness, fit_start=True, gen=None, batc
                 # Check target accuracy
                 if target_acc is not None and best_acc >= target_acc:
                     progress.close()
-                    train_model = evaluate(x_train, y_train, W=best_weights, 
+                    train_model = evaluate(x_train, y_train, W=best_weight, 
                                         activation_potentiation=final_activations)
-
-                    div_score = diversity_score(W)
-                    fit_score = fitness(y_train, train_model[get_preds_softmax()], div_score, train_model[get_acc()])
+                    if loss == 'categorical_crossentropy':
+                        train_loss = categorical_crossentropy(y_true_batch=y_train, 
+                                                           y_pred_batch=train_model[get_preds_softmax()])
+                    else:
+                        train_loss = binary_crossentropy(y_true_batch=y_train, 
+                                                       y_pred_batch=train_model[get_preds_softmax()])
 
                     print('\nActivations: ', final_activations)
                     print(f'Train Accuracy:', train_model[get_acc()])
-                    print(f'Fitness Value: ', fit_score, '\n')
-                                
-                    postfix_dict[f"{data} Accuracy"] = np.round(train_model[get_acc()], 4)
-                    postfix_dict[f"{data} Fitness"] = np.round(best_fit, 4)
-                    progress.set_postfix(postfix_dict)
+                    print(f'Train Loss: ', train_loss, '\n')
+                    
+                    display_visualizations_for_learner(viz_objects, best_weight, data, best_acc, 
+                                              best_loss, y_train, interval)
+                    return best_weight, best_model[get_preds_softmax()], best_acc, final_activations
+            
+                # Check target loss
+                if target_loss is not None and best_loss <= target_loss:
+                    progress.close()
+                    train_model = evaluate(x_train, y_train, W=best_weight,
+                                        activation_potentiation=final_activations)
+
+                    if loss == 'categorical_crossentropy':
+                        train_loss = categorical_crossentropy(y_true_batch=y_train, 
+                                                           y_pred_batch=train_model[get_preds_softmax()])
+                    else:
+                        train_loss = binary_crossentropy(y_true_batch=y_train, 
+                                                       y_pred_batch=train_model[get_preds_softmax()])
+
+                    print('\nActivations: ', final_activations)
+                    print(f'Train Accuracy :', train_model[get_acc()])
+                    print(f'Train Loss : ', train_loss, '\n')
+
                     # Display final visualizations
-                    display_visualizations_for_learner(viz_objects, best_weights, data, best_acc, 
-                                              fit_score, y_train, interval)
-                    return best_weights, best_model[get_preds()], best_acc, final_activations
+                    display_visualizations_for_learner(viz_objects, best_weight, data, best_acc, 
+                                              train_loss, y_train, interval)
+                    return best_weight, best_model[get_preds_softmax()], best_acc, final_activations
 
+            
             progress.update(1)
 
         if batch_size != 1:
-            train_model = evaluate(x_train, y_train, best_weights, final_activations)
+            train_model = evaluate(x_train, y_train, best_weight, final_activations)
+    
+            if loss == 'categorical_crossentropy':
+                train_loss = categorical_crossentropy(y_true_batch=y_train, 
+                                                    y_pred_batch=train_model[get_preds_softmax()])
+            else:
+                train_loss = binary_crossentropy(y_true_batch=y_train, 
+                                                y_pred_batch=train_model[get_preds_softmax()])
             
-            div_score = diversity_score(W)
-            fit_score = fitness(y_train, train_model[get_preds_softmax()], div_score, train_model[get_acc()])
-
-            print('\nActivations: ', final_activations)
-            print(f'Train Accuracy:', train_model[get_acc()])
-            print(f'Fitness Value: ', fit_score, '\n')
-                        
             postfix_dict[f"{data} Accuracy"] = np.round(train_model[get_acc()], 4)
-            postfix_dict[f"{data} Fitness"] = np.round(best_fit, 4)
+            postfix_dict[f"{data} Loss"] = np.round(train_loss, 4)
             progress.set_postfix(postfix_dict)
             
             best_acc_per_gen_list.append(train_model[get_acc()])
-            fit_list.append(fit_score)
+            loss_list.append(train_loss)
 
         else:
             best_acc_per_gen_list.append(best_acc)
-            fit_list.append(best_fit)
+            loss_list.append(best_loss)
 
         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 = []
@@ -342,36 +355,44 @@ def learner(x_train, y_train, optimizer, fitness, fit_start=True, gen=None, batc
         if early_stop == True and i > 0:
             if best_acc_per_gen_list[i] == best_acc_per_gen_list[i-1]:
                 progress.close()
-                train_model = evaluate(x_train, y_train, W=best_weights, 
+                train_model = evaluate(x_train, y_train, W=best_weight, 
                                     activation_potentiation=final_activations)
+                
+            if loss == 'categorical_crossentropy':
+                train_loss = categorical_crossentropy(y_true_batch=y_train, 
+                                                    y_pred_batch=train_model[get_preds_softmax()])
+            else:
+                train_loss = binary_crossentropy(y_true_batch=y_train, 
+                                                y_pred_batch=train_model[get_preds_softmax()])
 
-                div_score = diversity_score(W)
-                fit_score = fitness(y_train, train_model[get_preds_softmax()], div_score, train_model[get_acc()])
-
-                print('\nActivations: ', final_activations)
-                print(f'Train Accuracy:', train_model[get_acc()])
-                print(f'Fitness Value: ', fit_score, '\n')
+            print('\nActivations: ', final_activations)
+            print(f'Train Accuracy:', train_model[get_acc()])
+            print(f'Train Loss: ', train_loss, '\n')
 
-                # Display final visualizations
-                display_visualizations_for_learner(viz_objects, best_weights, data, best_acc, 
-                                          fit_score, y_train, interval)
-                return best_weights, best_model[get_preds()], best_acc, final_activations
+            # Display final visualizations
+            display_visualizations_for_learner(viz_objects, best_weight, data, best_acc, 
+                                        train_loss, y_train, interval)
+            return best_weight, best_model[get_preds_softmax()], best_acc, final_activations
 
     # Final evaluation
     progress.close()
-    train_model = evaluate(x_train, y_train, W=best_weights, 
+    train_model = evaluate(x_train, y_train, W=best_weight,
                         activation_potentiation=final_activations)
 
-    div_score = diversity_score(W)
-    fit_score = fitness(y_train, train_model[get_preds_softmax()], div_score, train_model[get_acc()])
-
+    if loss == 'categorical_crossentropy':
+        train_loss = categorical_crossentropy(y_true_batch=y_train, 
+                                            y_pred_batch=train_model[get_preds_softmax()])
+    else:
+        train_loss = binary_crossentropy(y_true_batch=y_train, 
+                                        y_pred_batch=train_model[get_preds_softmax()])
+        
     print('\nActivations: ', final_activations)
     print(f'Train Accuracy:', train_model[get_acc()])
-    print(f'Fitness Value: ', fit_score, '\n')
+    print(f'Train Loss: ', train_loss, '\n')
 
     # Display final visualizations
-    display_visualizations_for_learner(viz_objects, best_weights, data, best_acc, fit_score, y_train, interval)
-    return best_weights, best_model[get_preds()], best_acc, final_activations
+    display_visualizations_for_learner(viz_objects, best_weight, data, best_acc, train_loss, y_train, interval)
+    return best_weight, best_model[get_preds_softmax()], best_acc, final_activations
 
 
 def evaluate(
@@ -397,9 +418,12 @@ def evaluate(
     """
 
     x_test = apply_activation(x_test, activation_potentiation)
+    
     result = x_test @ W.T
-    epsilon = 1e-10
-    accuracy = (np.argmax(result, axis=1) == np.argmax(y_test, axis=1)).mean()
-    softmax_preds = np.exp(result) / (np.sum(np.exp(result), axis=1, keepdims=True) + epsilon)
-
-    return W, None, accuracy, None, None, softmax_preds
+    
+    max_vals = np.max(result, axis=1, keepdims=True)
+    
+    softmax_preds = np.exp(result - max_vals) / np.sum(np.exp(result - max_vals), axis=1, keepdims=True)
+    accuracy = (np.argmax(softmax_preds, axis=1) == np.argmax(y_test, axis=1)).mean()
+    
+    return W, result, accuracy, None, None, softmax_preds

pyerualjetwork/plan_cuda.py

@@ -6,7 +6,7 @@ MAIN MODULE FOR PLAN_CUDA
 Examples: https://github.com/HCB06/PyerualJetwork/tree/main/Welcome_to_PyerualJetwork/ExampleCodes
 
 PLAN document: https://github.com/HCB06/PyerualJetwork/blob/main/Welcome_to_PLAN/PLAN.pdf
-PYERUALJETWORK document: https://github.com/HCB06/PyerualJetwork/blob/main/Welcome_to_PyerualJetwork/PYERUALJETWORK_USER_MANUEL_AND_LEGAL_INFORMATION(EN).pdf
+PyerualJetwork document: https://github.com/HCB06/PyerualJetwork/blob/main/Welcome_to_PyerualJetwork/PYERUALJETWORK_USER_MANUEL_AND_LEGAL_INFORMATION(EN).pdf
 
 @author: Hasan Can Beydili
 @YouTube: https://www.youtube.com/@HasanCanBeydili
@@ -20,11 +20,11 @@ import cupy as cp
 ### LIBRARY IMPORTS ###
 from .ui import loading_bars, initialize_loading_bar
 from .data_operations_cuda import normalization
-from .loss_functions_cuda import binary_crossentropy, categorical_crossentropy
 from .activation_functions_cuda import apply_activation, all_activations
-from .metrics_cuda import metrics
-from .model_operations_cuda import get_acc, get_preds, get_preds_softmax
+from .model_operations_cuda import get_acc, get_preds_softmax
 from .memory_operations import transfer_to_gpu, transfer_to_cpu, optimize_labels
+from .loss_functions_cuda import categorical_crossentropy, binary_crossentropy
+from .fitness_functions import wals
 from .visualizations_cuda import (
     draw_neural_web,
     display_visualizations_for_learner,
@@ -82,10 +82,10 @@ def fit(
     return normalization(weight, dtype=dtype)
 
 
-def learner(x_train, y_train, optimizer, fit_start=True, strategy='accuracy', gen=None, batch_size=1, pop_size=None,
-           neural_web_history=False, show_current_activations=False, auto_normalization=False,
-           neurons_history=False, early_stop=False, loss='categorical_crossentropy', show_history=False,
-           interval=33.33, target_acc=None, target_loss=None,
+def learner(x_train, y_train, optimizer, fit_start=True, gen=None, batch_size=1, pop_size=None,
+           neural_web_history=False, show_current_activations=False, auto_normalization=False, target_acc=None,
+           neurons_history=False, early_stop=False, show_history=False, loss='categorical_crossentropy',
+           interval=33.33, target_loss=None, loss_impact=0.1, acc_impact=0.9,
            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 
@@ -103,29 +103,37 @@ def learner(x_train, y_train, optimizer, fit_start=True, strategy='accuracy', ge
 
         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.evolver(*args,
-                                                                    activation_add_prob=0.85,
+        optimizer = lambda *args, **kwargs: planeat_cuda.evolver(*args,
+                                                                    activation_add_prob=0.05,
                                                                     strategy='aggressive',
+                                                                    policy='more_selective',
                                                                     **kwargs)
 
         model = plan_cuda.learner(x_train,
                                 y_train,
-                                optimizer=genetic_optimizer,
+                                optimizer,
                                 fit_start=True,
-                                strategy='accuracy',
                                 show_history=True,
                                 gen=15,
                                 batch_size=0.05,
                                 interval=16.67)
         ```
+        loss (str, optional): For visualizing and monitoring. PLAN neural networks doesn't need any loss function in training. options: ('categorical_crossentropy' or 'binary_crossentropy') Default is 'categorical_crossentropy'.
+
+        target_acc (float, 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.
+
         fit_start (bool, optional): 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. Default: True
         
-        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 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)
 
+        loss_impact (float, optional): Impact of loss during evolve. [0-1] Default: 0.1
+
+        acc_impact (float, optional): Impact of accuracy during evolve. [0-1] Default: 0.9
+        
         pop_size (int, optional): Population size of each generation. Default: count of activation functions
 
         early_stop (bool, optional): If True, implements early stopping during training.(If train accuracy not improves in two gen stops learning.) Default is False.
@@ -134,15 +142,11 @@ def learner(x_train, y_train, optimizer, fit_start=True, strategy='accuracy', ge
 
         show_history (bool, optional): If True, displays the training history after optimization. Default is False.
 
-        loss (str, optional): For visualizing and monitoring. PLAN neural networks doesn't need any loss function in training. options: ('categorical_crossentropy' or 'binary_crossentropy') Default is 'categorical_crossentropy'.
-
         auto_normalization (bool, optional): Normalization may solves overflow problem. Default: False
         
         interval (int, optional): The interval at which evaluations are conducted during training. (33.33 = 30 FPS, 16.67 = 60 FPS) Default is 100.
     
         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.
         
         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
 
@@ -174,6 +178,8 @@ def learner(x_train, y_train, optimizer, fit_start=True, strategy='accuracy', ge
 
     if pop_size < activation_potentiation_len: raise ValueError(f"pop_size must be higher or equal to {activation_potentiation_len}")
 
+    if gen is None: gen = activation_potentiation_len
+
     if memory == 'gpu':
         x_train = transfer_to_gpu(x_train, dtype=dtype)
         y_train = transfer_to_gpu(y_train, dtype=y_train.dtype)
@@ -189,7 +195,6 @@ def learner(x_train, y_train, optimizer, fit_start=True, strategy='accuracy', ge
     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')
 
@@ -198,19 +203,18 @@ def learner(x_train, y_train, optimizer, fit_start=True, strategy='accuracy', ge
 
     # Initialize variables
     best_acc = 0
-    best_f1 = 0
-    best_recall = 0
-    best_precision = 0 
+    best_loss = float('inf')
+    best_fitness = float('-inf')
     best_acc_per_gen_list = []
     postfix_dict = {}
     loss_list = []
     target_pop = []
 
-    progress = initialize_loading_bar(total=activation_potentiation_len, desc="", ncols=78, bar_format=bar_format_learner)
+    progress = initialize_loading_bar(total=activation_potentiation_len, desc="", ncols=79, bar_format=bar_format_learner)
 
     if fit_start is False or pop_size > activation_potentiation_len:
         weight_pop, act_pop = define_genomes(input_shape=len(x_train[0]), output_shape=len(y_train[0]), population_size=pop_size, dtype=dtype)
-
+        
     else:
         weight_pop = [0] * pop_size
         act_pop = [0] * pop_size
@@ -219,6 +223,7 @@ def learner(x_train, y_train, optimizer, fit_start=True, strategy='accuracy', ge
         weight_pop[0] = start_this_W
         act_pop[0] = start_this_act
 
+    # LEARNING STARTED
     for i in range(gen):
         postfix_dict["Gen"] = str(i+1) + '/' + str(gen)
         progress.set_postfix(postfix_dict)
@@ -232,7 +237,7 @@ def learner(x_train, y_train, optimizer, fit_start=True, strategy='accuracy', ge
             x_train_batch, y_train_batch = batcher(x_train, y_train, batch_size=batch_size)
 
             x_train_batch = cp.array(x_train_batch, dtype=dtype, copy=False)
-            y_train_batch = cp.array(y_train_batch, dtype=dtype, copy=False)
+            y_train_batch = cp.array(y_train_batch, dtype=y_train.dtype)
 
             if fit_start is True and i == 0 and j < activation_potentiation_len:
                 if start_this_act is not None and j == 0:
@@ -241,62 +246,39 @@ def learner(x_train, y_train, optimizer, fit_start=True, strategy='accuracy', ge
                     act_pop[j] = activation_potentiation[j]
                     W = fit(x_train_batch, y_train_batch, activation_potentiation=act_pop[j], auto_normalization=auto_normalization, dtype=dtype)
                     weight_pop[j] = W
-    
+                    
             model = evaluate(x_train_batch, y_train_batch, W=weight_pop[j], activation_potentiation=act_pop[j])
             acc = model[get_acc()]
-            
-            if strategy == 'accuracy': target_pop.append(acc)
-
-            elif strategy == 'f1' or strategy == 'precision' or strategy == 'recall':
-                precision_score, recall_score, f1_score = metrics(y_train_batch, model[get_preds()])
-
-                if strategy == 'precision':
-                    target_pop.append(precision_score)
-
-                    if i == 0 and j == 0:
-                        best_precision = precision_score
-
-                if strategy == 'recall':
-                    target_pop.append(recall_score)
-
-                    if i == 0 and j == 0:
-                        best_recall = recall_score
+ 
+            if loss == 'categorical_crossentropy':
+                train_loss = categorical_crossentropy(y_true_batch=y_train_batch, 
+                                                           y_pred_batch=model[get_preds_softmax()])
+            else:
+                train_loss = binary_crossentropy(y_true_batch=y_train_batch, 
+                                            y_pred_batch=model[get_preds_softmax()])
 
-                if strategy == 'f1':
-                    target_pop.append(f1_score)
 
-                    if i == 0 and j == 0:
-                        best_f1 = f1_score
+            fitness  = wals(acc, train_loss, acc_impact, loss_impact)
+            target_pop.append(fitness)
 
-            if ((strategy == 'accuracy' and acc >= best_acc) or 
-                (strategy == 'f1' and f1_score >= best_f1) or 
-                (strategy == 'precision' and precision_score >= best_precision) or 
-                (strategy == 'recall' and recall_score >= best_recall)):
+            if fitness >= best_fitness:
 
+                best_fitness = fitness
                 best_acc = acc
-                best_weights = cp.copy(weight_pop[j])
-                final_activations = act_pop[j].copy() if isinstance(act_pop[j], list) else act_pop[j]
-
+                best_loss = train_loss
+                best_weight = cp.copy(weight_pop[j])
                 best_model = model
 
+                final_activations = act_pop[j].copy() if isinstance(act_pop[j], list) else act_pop[j]
                 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"] = cp.round(best_acc, 4)
+                    postfix_dict[f"{data} Loss"] = cp.round(train_loss, 4)
                     progress.set_postfix(postfix_dict)
 
                 if show_current_activations:
                     print(f", Current Activations={final_activations}", end='')
-            
-                if loss == 'categorical_crossentropy':
-                    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:
-                    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"] = cp.round(train_loss, 4)
-                    best_loss = train_loss
-                    progress.set_postfix(postfix_dict)
 
                 # Update visualizations during training
                 if show_history:
@@ -306,7 +288,7 @@ def learner(x_train, y_train, optimizer, fit_start=True, strategy='accuracy', ge
 
                 if neurons_history:
                     viz_objects['neurons']['artists'] = (
-                        update_neuron_history_for_learner(cp.copy(best_weights), viz_objects['neurons']['ax'],
+                        update_neuron_history_for_learner(cp.copy(best_weight), viz_objects['neurons']['ax'],
                                      viz_objects['neurons']['row'], viz_objects['neurons']['col'],
                                      y_train[0], viz_objects['neurons']['artists'],
                                      data=data, fig1=viz_objects['neurons']['fig'],
@@ -314,7 +296,7 @@ def learner(x_train, y_train, optimizer, fit_start=True, strategy='accuracy', ge
                     )
 
                 if neural_web_history:
-                    art5_1, art5_2, art5_3 = draw_neural_web(W=best_weights, ax=viz_objects['web']['ax'],
+                    art5_1, art5_2, art5_3 = draw_neural_web(W=best_weight, ax=viz_objects['web']['ax'],
                                                             G=viz_objects['web']['G'], return_objs=True)
                     art5_list = [art5_1] + [art5_2] + list(art5_3.values())
                     viz_objects['web']['artists'].append(art5_list)
@@ -322,9 +304,8 @@ def learner(x_train, y_train, optimizer, fit_start=True, strategy='accuracy', ge
                 # Check target accuracy
                 if target_acc is not None and best_acc >= target_acc:
                     progress.close()
-                    train_model = evaluate(x_train, y_train, W=best_weights, 
+                    train_model = evaluate(x_train, y_train, W=best_weight, 
                                         activation_potentiation=final_activations)
-
                     if loss == 'categorical_crossentropy':
                         train_loss = categorical_crossentropy(y_true_batch=y_train, 
                                                            y_pred_batch=train_model[get_preds_softmax()])
@@ -335,16 +316,15 @@ def learner(x_train, y_train, optimizer, fit_start=True, strategy='accuracy', ge
                     print('\nActivations: ', final_activations)
                     print(f'Train Accuracy:', train_model[get_acc()])
                     print(f'Train Loss: ', train_loss, '\n')
-                
-                    # Display final visualizations
-                    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
+                    
+                    display_visualizations_for_learner(viz_objects, best_weight, data, best_acc, 
+                                              best_loss, y_train, interval)
+                    return best_weight, best_model[get_preds_softmax()], best_acc, final_activations
 
                 # Check target loss
                 if target_loss is not None and best_loss <= target_loss:
                     progress.close()
-                    train_model = evaluate(x_train, y_train, W=best_weights, 
+                    train_model = evaluate(x_train, y_train, W=best_weight,
                                         activation_potentiation=final_activations)
 
                     if loss == 'categorical_crossentropy':
@@ -355,28 +335,31 @@ def learner(x_train, y_train, optimizer, fit_start=True, strategy='accuracy', ge
                                                        y_pred_batch=train_model[get_preds_softmax()])
 
                     print('\nActivations: ', final_activations)
-                    print(f'Train Accuracy: ', train_model[get_acc()])
-                    print(f'Train Loss: ', train_loss, '\n')
+                    print(f'Train Accuracy :', train_model[get_acc()])
+                    print(f'Train Loss : ', train_loss, '\n')
 
                     # Display final visualizations
-                    display_visualizations_for_learner(viz_objects, best_weights, data, best_acc, 
+                    display_visualizations_for_learner(viz_objects, best_weight, data, best_acc, 
                                               train_loss, y_train, interval)
-                    return best_weights, best_model[get_preds()], best_acc, final_activations
+                    return best_weight, best_model[get_preds_softmax()], best_acc, final_activations
+
 
             progress.update(1)
         
         if batch_size != 1:
-            train_model = evaluate(x_train, y_train, best_weights, final_activations)
-            
+            train_model = evaluate(x_train, y_train, best_weight, final_activations)
+    
             if loss == 'categorical_crossentropy':
-                train_loss = categorical_crossentropy(y_true_batch=transfer_to_gpu(y_train, dtype=y_train.dtype), y_pred_batch=train_model[get_preds_softmax()])
+                train_loss = categorical_crossentropy(y_true_batch=y_train, 
+                                                    y_pred_batch=train_model[get_preds_softmax()])
             else:
-                train_loss = binary_crossentropy(y_true_batch=transfer_to_gpu(y_train, dtype=y_train.dtype), y_pred_batch=train_model[get_preds_softmax()])
-
+                train_loss = binary_crossentropy(y_true_batch=y_train, 
+                                                y_pred_batch=train_model[get_preds_softmax()])
+            
             postfix_dict[f"{data} Accuracy"] = cp.round(train_model[get_acc()], 4)
             postfix_dict[f"{data} Loss"] = cp.round(train_loss, 4)
             progress.set_postfix(postfix_dict)
-
+            
             best_acc_per_gen_list.append(train_model[get_acc()])
             loss_list.append(train_loss)
 
@@ -391,42 +374,44 @@ def learner(x_train, y_train, optimizer, fit_start=True, strategy='accuracy', ge
         if early_stop == True and i > 0:
             if best_acc_per_gen_list[i] == best_acc_per_gen_list[i-1]:
                 progress.close()
-                train_model = evaluate(x_train, y_train, W=best_weights,
+                train_model = evaluate(x_train, y_train, W=best_weight, 
                                     activation_potentiation=final_activations)
+                
+            if loss == 'categorical_crossentropy':
+                train_loss = categorical_crossentropy(y_true_batch=y_train, 
+                                                    y_pred_batch=train_model[get_preds_softmax()])
+            else:
+                train_loss = binary_crossentropy(y_true_batch=y_train, 
+                                                y_pred_batch=train_model[get_preds_softmax()])
 
-                if loss == 'categorical_crossentropy':
-                    train_loss = categorical_crossentropy(y_true_batch=y_train, 
-                                                       y_pred_batch=train_model[get_preds_softmax()])
-                else:
-                    train_loss = binary_crossentropy(y_true_batch=y_train, 
-                                                   y_pred_batch=train_model[get_preds_softmax()])
-
-                print('\nActivations: ', final_activations)
-                print(f'Train Accuracy:', train_model[get_acc()])
-                print(f'Train Loss: ', train_loss, '\n')
+            print('\nActivations: ', final_activations)
+            print(f'Train Accuracy:', train_model[get_acc()])
+            print(f'Train Loss: ', train_loss, '\n')
 
-                # Display final visualizations
-                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
+            # Display final visualizations
+            display_visualizations_for_learner(viz_objects, best_weight, data, best_acc, 
+                                        train_loss, y_train, interval)
+            return best_weight, best_model[get_preds_softmax()], best_acc, final_activations
 
     # Final evaluation
     progress.close()
-    train_model = evaluate(x_train, y_train, W=best_weights,
+    train_model = evaluate(x_train, y_train, W=best_weight,
                         activation_potentiation=final_activations)
 
     if loss == 'categorical_crossentropy':
-        train_loss = categorical_crossentropy(y_true_batch=y_train, y_pred_batch=train_model[get_preds_softmax()])
+        train_loss = categorical_crossentropy(y_true_batch=y_train, 
+                                            y_pred_batch=train_model[get_preds_softmax()])
     else:
-        train_loss = binary_crossentropy(y_true_batch=y_train, y_pred_batch=train_model[get_preds_softmax()])
-
+        train_loss = binary_crossentropy(y_true_batch=y_train, 
+                                        y_pred_batch=train_model[get_preds_softmax()])
+        
     print('\nActivations: ', final_activations)
-    print(f'Train Accuracy: ', train_model[get_acc()])
-    print(f'Train Loss : ', train_loss, '\n')
+    print(f'Train Accuracy:', train_model[get_acc()])
+    print(f'Train Loss: ', train_loss, '\n')
 
     # Display final visualizations
-    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
+    display_visualizations_for_learner(viz_objects, best_weight, data, best_acc, train_loss, y_train, interval)
+    return best_weight, best_model[get_preds_softmax()], best_acc, final_activations
 
 def evaluate(
     x_test,
@@ -439,9 +424,9 @@ def evaluate(
 
     Args:
         x_test (cp.ndarray): Test data.
-
+        
         y_test (cp.ndarray): Test labels (one-hot encoded).
-
+        
         W (cp.ndarray): Neural net weight matrix.
         
         activation_potentiation (list): Activation list. Default = ['linear'].
@@ -451,9 +436,12 @@ def evaluate(
     """
 
     x_test = apply_activation(x_test, activation_potentiation)
+    
     result = x_test @ W.T
-    epsilon = 1e-10
-    accuracy = (cp.argmax(result, axis=1) == cp.argmax(y_test, axis=1)).mean()
-    softmax_preds = cp.exp(result) / (cp.sum(cp.exp(result), axis=1, keepdims=True) + epsilon)
 
-    return W, None, accuracy, None, None, softmax_preds
+    max_vals = cp.max(result, axis=1, keepdims=True)
+
+    softmax_preds = cp.exp(result - max_vals) / cp.sum(cp.exp(result - max_vals), axis=1, keepdims=True)
+    accuracy = (cp.argmax(softmax_preds, axis=1) == cp.argmax(y_test, axis=1)).mean()
+
+    return W, result, accuracy, None, None, softmax_preds

pyerualjetwork/planeat.py

@@ -3,12 +3,12 @@ MAIN MODULE FOR PLANEAT
 
 Examples: https://github.com/HCB06/PyerualJetwork/tree/main/Welcome_to_PyerualJetwork/ExampleCodes
 
-ANAPLAN document: https://github.com/HCB06/Anaplan/blob/main/Welcome_to_Anaplan/ANAPLAN_USER_MANUEL_AND_LEGAL_INFORMATION(EN).pdf
+PyerualJetwork document: https://github.com/HCB06/Anaplan/blob/main/Welcome_to_Anaplan/ANAPLAN_USER_MANUEL_AND_LEGAL_INFORMATION(EN).pdf
 
 @author: Hasan Can Beydili
 @YouTube: https://www.youtube.com/@HasanCanBeydili
 @Linkedin: https://www.linkedin.com/in/hasan-can-beydili-77a1b9270/
-@Instagram: https://www.instagram.com/canbeydili.06/
+@Instagram: https://www.instagram.com/canbeydilj
 @contact: tchasancan@gmail.com
 """
 
@@ -560,11 +560,11 @@ def cross_over(first_parent_W,
       selection_bias = random.uniform(0, 1)
 
       if fitness_bias > selection_bias:
-         row_cut_start = math.floor(row_cut_start * (succes + epsilon))
-         row_cut_end = math.ceil(row_cut_end * (succes + epsilon))
+         row_cut_start = math.floor(row_cut_start * succes)
+         row_cut_end = math.ceil(row_cut_end * succes)
 
-         col_cut_start = math.floor(col_cut_start * (succes + epsilon))
-         col_cut_end = math.ceil(col_cut_end * (succes + epsilon))
+         col_cut_start = math.floor(col_cut_start * succes)
+         col_cut_end = math.ceil(col_cut_end * succes)
 
    child_W = dominant_parent_W
 
@@ -590,9 +590,10 @@ def cross_over(first_parent_W,
          random_undominant_activation = undominant_parent_act[random_index]
 
          child_act.append(random_undominant_activation)
-
+         new_threshold += threshold
+         
          if len(dominant_parent_act) > new_threshold:
-            new_threshold += threshold
+            pass
          
          else:
             break
@@ -612,9 +613,10 @@ def cross_over(first_parent_W,
          random_undominant_activation = undominant_parent_act[random_index_undominant]
 
          child_act[random_index_dominant] = random_undominant_activation
-
+         new_threshold += threshold
+         
          if len(dominant_parent_act) > new_threshold:
-            new_threshold += threshold
+            pass
          
          else:
             break
@@ -690,7 +692,7 @@ def mutation(weight,
 
       max_threshold = row_end * col_end
 
-      threshold = weight_mutate_threshold * genome_fitness
+      threshold = weight_mutate_threshold * (genome_fitness + epsilon)
       new_threshold = threshold
       
       for _ in range(max_threshold):

pyerualjetwork/planeat_cuda.py

@@ -3,12 +3,12 @@ MAIN MODULE FOR PLANEAT
 
 Examples: https://github.com/HCB06/PyerualJetwork/tree/main/Welcome_to_PyerualJetwork/ExampleCodes
 
-ANAPLAN document: https://github.com/HCB06/Anaplan/blob/main/Welcome_to_Anaplan/ANAPLAN_USER_MANUEL_AND_LEGAL_INFORMATION(EN).pdf
+PyerualJetwork document: https://github.com/HCB06/Anaplan/blob/main/Welcome_to_Anaplan/ANAPLAN_USER_MANUEL_AND_LEGAL_INFORMATION(EN).pdf
 
 @author: Hasan Can Beydili
 @YouTube: https://www.youtube.com/@HasanCanBeydili
 @Linkedin: https://www.linkedin.com/in/hasan-can-beydili-77a1b9270/
-@Instagram: https://www.instagram.com/canbeydili.06/
+@Instagram: https://www.instagram.com/canbeydilj
 @contact: tchasancan@gmail.com
 """
 
@@ -694,7 +694,7 @@ def mutation(weight,
       
       max_threshold = row_end * col_end
 
-      threshold = weight_mutate_threshold * genome_fitness
+      threshold = weight_mutate_threshold * (genome_fitness + epsilon)
       new_threshold = threshold
 
       for _ in range(max_threshold):

pyerualjetwork/visualizations.py

@@ -771,7 +771,7 @@ def update_history_plots_for_learner(viz_objects, depth_list, loss_list, best_ac
         translated_x_train += draw_activations(x, activation)
     
     art3 = hist['ax'][2].plot(x, translated_x_train, color='b', markersize=6, linewidth=2)
-    hist['ax'][2].set_title('Potentiation Shape Over Gen')
+    hist['ax'][2].set_title('Activation Shape Over Gen')
     hist['artist3'].append(art3)
 
 def display_visualizations_for_learner(viz_objects, best_weights, data, best_acc, test_loss, y_train, interval):

{pyerualjetwork-4.3.9.dev2.dist-info → pyerualjetwork-4.3.10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyerualjetwork
-Version: 4.3.9.dev2
+Version: 4.3.10
 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
@@ -43,6 +43,7 @@ YouTube Tutorials: https://www.youtube.com/watch?v=6wMQstZ00is&list=PLNgNWpM7Hbs
 	    'tqdm==4.66.4',
 	    'pandas==2.2.2',
 	    'networkx==3.3',
+		'seaborn==0.13.2',
 	    'numpy==1.26.4',
 	    'matplotlib==3.9.0',
 	    'colorama==0.4.6',
@@ -50,7 +51,7 @@ YouTube Tutorials: https://www.youtube.com/watch?v=6wMQstZ00is&list=PLNgNWpM7Hbs
 	    'psutil==6.1.1'
         ]
 
-     matplotlib, networkx (optional).
+     matplotlib, networkx, seaborn (optional).
           
 ##############################
 

{pyerualjetwork-4.3.9.dev2.dist-info → pyerualjetwork-4.3.10.dist-info}/RECORD

@@ -1,24 +1,25 @@
-pyerualjetwork/__init__.py,sha256=9eOTCzpFVUX9DY_9CL8Cw_Z88H6-tD0Jnw8a-gKKiWg,643
+pyerualjetwork/__init__.py,sha256=hic_KmaifwtlpUkR05uf02m0h2bZVKUYUvTa4cWuP2U,1280
 pyerualjetwork/activation_functions.py,sha256=bKf00lsuuLJNO-4vVp4OqBi4zJ-qZ8L3v-vl52notkY,7721
 pyerualjetwork/activation_functions_cuda.py,sha256=5y1Ti3GDfDteQDCUmODwe7tAyDAUlDTKmIikChQ8d6g,7772
 pyerualjetwork/data_operations.py,sha256=Flteouu6rfSo2uHMqBHuzO02dXmbNa-I5qWmUpGTZ5Y,14760
 pyerualjetwork/data_operations_cuda.py,sha256=ZcjmLXE1-HVwedextYdJZ1rgrns1OfSekzFpr1a9m6o,17625
-pyerualjetwork/fitness_functions.py,sha256=0tj1Ri8x8PXR9cuZF_PaUF3mjgsys0IRAEKklipKxZA,4064
+pyerualjetwork/fitness_functions.py,sha256=9ZtCasBVjk3qQldi2pIzV6c5hTBJJyGCU0eVhJsoxPo,1145
 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=MCSCNYiiICRVZITobtS3ZIWmH5Q9gjyELuH32sAdgg4,12649
 pyerualjetwork/model_operations_cuda.py,sha256=NT01BK5nrDYE7H1x3KnSI8gmx0QTGGB0mP_LqEb1uuU,13157
-pyerualjetwork/plan.py,sha256=vps6EHyHoFWBlp3g5BF3ygD4vIkFvvRsmB7xS0IJ70E,20452
-pyerualjetwork/plan_cuda.py,sha256=DCKWStOZhBq-NYKA2BQTKe3YgvDYuGtujtIr56ZBjiw,24477
-pyerualjetwork/planeat.py,sha256=OxwSjfSFPwh7kVrhnuAkr8Lrk73GB-Wk2ajUFIfZcbQ,37556
-pyerualjetwork/planeat_cuda.py,sha256=aTdBmhJeIKC58pssODtqVsdOtJP7W6TRmVyGHp7k_CM,37612
+pyerualjetwork/plan.py,sha256=M8KVSXUjmSkf4bK7FnizLZjWQfI_3suHIJ-XminM2SM,22291
+pyerualjetwork/plan_cuda.py,sha256=hRPPw4YsiVpfoXkNN1le1zaVHJuSySvihiFBt2eHT7c,23388
+pyerualjetwork/planeat.py,sha256=FBoYirDE8R0zGtB-EFsHdQ50RijC7rnZHqDIiXx67rs,37571
+pyerualjetwork/planeat_cuda.py,sha256=5suVlOfHcThhGbPlHbxAqbp5-rpbw4E2H6trvDvrmg4,37627
 pyerualjetwork/ui.py,sha256=wu2BhU1k-w3Kcho5Jtq4SEKe68ftaUeRGneUOSCVDjU,575
-pyerualjetwork/visualizations.py,sha256=08O5uEewuYiovZRX1uHWEHjn19LcnhndWYvqVN74xs0,28290
+pyerualjetwork/visualizations.py,sha256=t1BqnFUH5jKiPdFMI2kWjFg6-amrBV0wvW05aD77NQs,28288
 pyerualjetwork/visualizations_cuda.py,sha256=PYRqj4QYUbuYMYcNwO8yaTPB-jK7E6kZHhTrAi0lwPU,28749
-pyerualjetwork-4.3.9.dev2.dist-info/METADATA,sha256=Z0nThYRtlJKsScG6ZRZYdPcBPU_GfIcxtE8oz1nFVRI,7479
-pyerualjetwork-4.3.9.dev2.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
-pyerualjetwork-4.3.9.dev2.dist-info/top_level.txt,sha256=BRyt62U_r3ZmJpj-wXNOoA345Bzamrj6RbaWsyW4tRg,15
-pyerualjetwork-4.3.9.dev2.dist-info/RECORD,,
+pyerualjetwork-4.3.10.dist-info/METADATA,sha256=rmH-W0wUOGbJUEZEp_CrCukqz3VT2pSbxl0xxCKJcO8,7506
+pyerualjetwork-4.3.10.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
+pyerualjetwork-4.3.10.dist-info/top_level.txt,sha256=BRyt62U_r3ZmJpj-wXNOoA345Bzamrj6RbaWsyW4tRg,15
+pyerualjetwork-4.3.10.dist-info/RECORD,,