pyerualjetwork 4.3.10b2__py3-none-any.whl → 4.3.11__py3-none-any.whl

pyerualjetwork/__init__.py

@@ -1,11 +1,33 @@
-__version__ = "4.3.10b2"
-__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.11"
+__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/activation_functions.py

@@ -203,9 +203,6 @@ def square_quartic(x):
 def cubic_quadratic(x):
     return x**3 * (x**2)
 
-def exp_cubic(x):
-    return np.exp(x**3)
-
 def sine_square(x):
     return np.sin(x)**2
 
@@ -267,7 +264,6 @@ def apply_activation(Input, activation_list):
         'quartic': quartic,
         'square_quartic': square_quartic,
         'cubic_quadratic': cubic_quadratic,
-        'exp_cubic': exp_cubic,
         'sine_square': sine_square,
         'logarithmic': logarithmic,
         'scaled_cubic': lambda x: scaled_cubic(x, 1.0),

pyerualjetwork/fitness_functions.py

@@ -1,78 +1,16 @@
-import numpy as np
-
-def pairwise_distances(X):
+def wals(acc, loss, acc_impact, loss_impact):
     """
-    Pairwise Euclidean distances using NumPy.
-    :param X: A (n_samples, n_features) NumPy array.
-    :return: A 2D NumPy array of distances (n_samples, n_samples).
+    The WALS(weighted accuracy-loss score) function calculates a weighted sum of accuracy and loss based on their respective impacts.
+    
+    :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.
     """
-    X = X.reshape(X.shape[0], -1)
-    r = np.sum(X**2, axis=1, keepdims=True)
-
-    distances = np.maximum(r - 2 * np.dot(X, X.T) + r.T, 0.0)
-
-    return np.sqrt(distances)
-
-def diversity_score(population):
-    """
-    Calculates the diversity score of a population based on the
-    Euclidean distances between individuals in the population.
-
-    :param population: A NumPy array of shape (n_samples, n_features),
-                       where each element is an individual weight matrix (flattened).
-    :return: A NumPy array of diversity scores for each weight matrix.
-    """
-    if len(population) < 2:
-        return np.zeros(len(population))
-    
-    population = np.nan_to_num(population, nan=0.0)
-    
-    distances = pairwise_distances(population)
-    distances = np.maximum(distances, 1e-10)
-
-    n_samples = len(population)
-
-    mask = np.ones((n_samples, n_samples), dtype=bool)
-    np.fill_diagonal(mask, 0)
-    
-    avg_distances = np.sum(distances * mask, axis=1) / (n_samples - 1)
-    
-    if population.shape[1] == 0:
-        return np.zeros(len(population))
-        
-    max_possible_distance = np.sqrt(population.shape[1])
-    max_possible_distance = float(max(max_possible_distance, 1e-10))
-    
-    diversity_scores = avg_distances / max_possible_distance
-    
-    return diversity_scores
-
-
-
-def multi_head_fitness(y_true, y_pred, diversity_score, accuracy, alpha=2, beta=1.5, lambda_div=0.05):
-    """
-    Computes a fitness score based on accuracy, margin loss, and diversity score.
-    
-    :param y_true: Ground truth labels (NumPy array).
-    :param y_pred: Predicted labels (NumPy array).
-    :param diversity_score: Diversity score for a single weight matrix.
-    :param accuracy: Model accuracy.
-    :param alpha: Exponent for accuracy impact.
-    :param beta: Exponent for margin loss impact.
-    :param lambda_div: Weight for diversity score influence.
-    :return: Computed fitness value.
-    """
-    incorrect = y_true != y_pred
-    
-    if np.any(incorrect):
-        margin_loss = np.abs(y_true[incorrect] - y_pred[incorrect]).mean()
-    else:
-        margin_loss = 0.0
-
-    margin_loss = np.nan_to_num(margin_loss, nan=0.0)
-    accuracy = max(accuracy, 1e-10)
-
-    fitness = (accuracy ** alpha) * ((1 - margin_loss) ** beta) * (1 + lambda_div * diversity_score)
-    fitness = np.nan_to_num(fitness, nan=0.0, posinf=1e10, neginf=-1e10)
-    
-    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/loss_functions_cuda.py

@@ -0,0 +1,21 @@
+
+import cupy as cp
+
+def categorical_crossentropy(y_true_batch, y_pred_batch):
+    epsilon = 1e-7
+    y_pred_batch = cp.clip(y_pred_batch, epsilon, 1. - epsilon)
+    
+    losses = -cp.sum(y_true_batch * cp.log(y_pred_batch), axis=1)
+
+    mean_loss = cp.mean(losses)
+    return mean_loss
+
+
+def binary_crossentropy(y_true_batch, y_pred_batch):
+    epsilon = 1e-7
+    y_pred_batch = cp.clip(y_pred_batch, epsilon, 1. - epsilon)
+    
+    losses = -cp.mean(y_true_batch * cp.log(y_pred_batch) + (1 - y_true_batch) * cp.log(1 - y_pred_batch), axis=1)
+
+    mean_loss = cp.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,8 +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 .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,
@@ -81,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 
@@ -103,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
 
@@ -170,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'
@@ -188,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')
@@ -199,26 +188,27 @@ 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=74, 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)
-        div_score = diversity_score(weight_pop)
 
     else:
-        weight_pop = [np.random.uniform(-1, 1, (len(y_train[0]), x_train[0].shape[0])) for _ in range(pop_size)]
+        weight_pop = [0] * pop_size
         act_pop = [0] * pop_size
 
     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
 
+    # LEARNING STARTED
     for i in range(gen):
         postfix_dict["Gen"] = str(i+1) + '/' + str(gen)
         progress.set_postfix(postfix_dict)
@@ -238,43 +228,43 @@ def learner(x_train, y_train, optimizer, fitness, fit_start=True, gen=None, batc
                     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
-                    div_score = diversity_score(weight_pop)
             
             model = evaluate(x_train_batch, y_train_batch, W=weight_pop[j], activation_potentiation=act_pop[j])
             acc = model[get_acc()]
             
-            fit_score = fitness(y_train_batch, model[get_preds_softmax()], div_score[j], 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_div_score = div_score[j]
+                best_loss = train_loss
                 best_weight = np.copy(weight_pop[j])
-                final_activations = act_pop[j].copy() if isinstance(act_pop[j], list) else act_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["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:
@@ -283,7 +273,7 @@ def learner(x_train, y_train, optimizer, fitness, fit_start=True, gen=None, batc
                                      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:
@@ -297,45 +287,68 @@ def learner(x_train, y_train, optimizer, fitness, fit_start=True, gen=None, batc
                     progress.close()
                     train_model = evaluate(x_train, y_train, W=best_weight, 
                                         activation_potentiation=final_activations)
-
-                    fit_score = fitness(y_train, train_model[get_preds_softmax()], best_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["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_weight, data, best_acc, 
-                                              fit_score, y_train, interval)
+                                              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_weight, final_activations)
- 
-            fit_score = fitness(y_train, train_model[get_preds_softmax()], best_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')
+    
+            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()])
             
             postfix_dict[f"{data} Accuracy"] = np.round(train_model[get_acc()], 4)
-            postfix_dict["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)
-        div_score = diversity_score(weight_pop)
         target_pop = []
 
         # Early stopping check
@@ -345,30 +358,40 @@ def learner(x_train, y_train, optimizer, fitness, fit_start=True, gen=None, batc
                 train_model = evaluate(x_train, y_train, W=best_weight, 
                                     activation_potentiation=final_activations)
                 
-                fit_score = fitness(y_train, train_model[get_preds_softmax()], best_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('\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_weight, data, best_acc, 
-                                          fit_score, y_train, interval)
-                return best_weight, best_model[get_preds_softmax()], 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_weight, 
+    train_model = evaluate(x_train, y_train, W=best_weight,
                         activation_potentiation=final_activations)
 
-    fit_score = fitness(y_train, train_model[get_preds_softmax()], best_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_weight, data, best_acc, fit_score, y_train, interval)
+    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
 
 
@@ -395,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)
-
+    
+    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
@@ -21,8 +21,10 @@ import cupy as cp
 from .ui import loading_bars, initialize_loading_bar
 from .data_operations_cuda import normalization
 from .activation_functions_cuda import apply_activation, all_activations
-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,
@@ -80,10 +82,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,
-           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,
+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 
@@ -101,37 +103,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_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)
         ```
-        
-        fitness (function): Fitness function. We have 'multi_head_fitness' function in the fitness_functions module. Use this: from pyerualjetwork import fitness_functions (and) fitness_function = lambda *args, **kwargs: fitness_functions.multi_head_fitness(*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.multi_head_fitness(*args, alpha=2, beta=1.5, lambda_div=0.05, **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)
-        ```
+        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
         
@@ -139,6 +130,10 @@ def learner(x_train, y_train, optimizer, fitness, fit_start=True, gen=None, batc
 
         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.
@@ -170,7 +165,6 @@ def learner(x_train, y_train, optimizer, fitness, fit_start=True, gen=None, batc
     
     """
 
-    from .fitness_functions_cuda import diversity_score
     from .planeat_cuda import define_genomes
 
     data = 'Train'
@@ -184,6 +178,8 @@ 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 memory == 'gpu':
         x_train = transfer_to_gpu(x_train, dtype=dtype)
         y_train = transfer_to_gpu(y_train, dtype=y_train.dtype)
@@ -207,26 +203,27 @@ 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=76, 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)
-        div_score = diversity_score(weight_pop)
-
+        
     else:
-        weight_pop = [cp.random.uniform(-1, 1, (len(y_train[0]), x_train[0].shape[0])) for _ in range(pop_size)]
+        weight_pop = [0] * pop_size
         act_pop = [0] * pop_size
 
     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
 
+    # LEARNING STARTED
     for i in range(gen):
         postfix_dict["Gen"] = str(i+1) + '/' + str(gen)
         progress.set_postfix(postfix_dict)
@@ -240,7 +237,7 @@ def learner(x_train, y_train, optimizer, fitness, fit_start=True, gen=None, batc
             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:
@@ -249,43 +246,44 @@ def learner(x_train, y_train, optimizer, fitness, fit_start=True, gen=None, batc
                     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
-                    div_score = diversity_score(weight_pop)
-
+                    
             model = evaluate(x_train_batch, y_train_batch, W=weight_pop[j], activation_potentiation=act_pop[j])
             acc = model[get_acc()]
  
-            fit_score = fitness(y_train_batch, model[get_preds_softmax()], div_score[j], acc)
-            
-            target_pop.append(fit_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 fit_score >= best_fit:
 
+            fitness  = wals(acc, train_loss, acc_impact, loss_impact)
+            target_pop.append(fitness)
+
+            if fitness >= best_fitness:
+
+                best_fitness = fitness
                 best_acc = acc
-                best_fit = fit_score
-                best_div_score = div_score[j]
+                best_loss = train_loss
                 best_weight = cp.copy(weight_pop[j])
-                final_activations = act_pop[j].copy() if isinstance(act_pop[j], list) else act_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 batch_size == 1:
-                    postfix_dict["Fitness"] = cp.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:
@@ -294,7 +292,7 @@ def learner(x_train, y_train, optimizer, fitness, fit_start=True, gen=None, batc
                                      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:
@@ -308,41 +306,68 @@ def learner(x_train, y_train, optimizer, fitness, fit_start=True, gen=None, batc
                     progress.close()
                     train_model = evaluate(x_train, y_train, W=best_weight, 
                                         activation_potentiation=final_activations)
-
-                    fit_score = fitness(y_train, train_model[get_preds_softmax()], best_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_visualizations_for_learner(viz_objects, best_weight, data, best_acc, 
-                                              fit_score, y_train, interval)
+                                              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_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_weight, final_activations)
-
-            fit_score = fitness(y_train, train_model[get_preds_softmax()], best_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')
-                        
+    
+            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()])
+            
             postfix_dict[f"{data} Accuracy"] = cp.round(train_model[get_acc()], 4)
-            postfix_dict["Fitness"] = cp.round(best_fit, 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()])
-            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(cp.array(weight_pop, copy=False, dtype=dtype), act_pop, i, cp.array(target_pop, dtype=dtype, copy=False), bar_status=False)
-        div_score = diversity_score(weight_pop)
         target_pop = []
 
         # Early stopping check
@@ -351,31 +376,41 @@ def learner(x_train, y_train, optimizer, fitness, fit_start=True, gen=None, batc
                 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()])
 
-                fit_score = fitness(y_train, train_model[get_preds_softmax()], best_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_weight, data, best_acc, 
-                                          fit_score, y_train, interval)
-                return best_weight, best_model[get_preds_softmax()], 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_weight,
                         activation_potentiation=final_activations)
 
-    fit_score = fitness(y_train, train_model[get_preds_softmax()], best_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_weight, data, best_acc, fit_score, y_train, interval)
+    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(
@@ -389,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'].
@@ -401,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)
+
+    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
 """
 

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
 """
 

pyerualjetwork/visualizations.py

@@ -754,9 +754,9 @@ def update_history_plots_for_learner(viz_objects, depth_list, loss_list, best_ac
     
     hist = viz_objects['history']
     
-    # Fitness plot
-    art1 = hist['ax'][0].plot(depth_list, loss_list, color='m', markersize=6, linewidth=2)
-    hist['ax'][0].set_title('Fitness Score Over Gen')
+    # Loss plot
+    art1 = hist['ax'][0].plot(depth_list, loss_list, color='r', markersize=6, linewidth=2)
+    hist['ax'][0].set_title('Train Loss Over Gen')
     hist['artist1'].append(art1)
     
     # Accuracy plot

pyerualjetwork/visualizations_cuda.py

@@ -748,12 +748,13 @@ def update_history_plots_for_learner(viz_objects, depth_list, loss_list, best_ac
     for i in range(len(loss_list)):
         loss_list[i] = loss_list[i].get()
 
-    # Fitness plot
-    art1 = hist['ax'][0].plot(depth_list, loss_list, color='m', markersize=6, linewidth=2)
-    hist['ax'][0].set_title('Fitness Score Over Gen')
+    # Loss plot
+    art1 = hist['ax'][0].plot(depth_list, loss_list, color='r', markersize=6, linewidth=2)
+    hist['ax'][0].set_title('Train Loss Over Gen')
     hist['artist1'].append(art1)
     
     # Accuracy plot
+
     for i in range(len(best_acc_per_depth_list)):
         best_acc_per_depth_list[i] = best_acc_per_depth_list[i].get()
 

{pyerualjetwork-4.3.10b2.dist-info → pyerualjetwork-4.3.11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyerualjetwork
-Version: 4.3.10b2
+Version: 4.3.11
 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
@@ -51,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.11.dist-info/RECORD

@@ -0,0 +1,25 @@
+pyerualjetwork/__init__.py,sha256=5snQTX8efGK_JdtgdrZU57alCIlsFlcYror1R3HFFDQ,1280
+pyerualjetwork/activation_functions.py,sha256=Ms0AGBqkJuCA42ht64MSQnO54Td_1eDGquedpoBDVbc,7642
+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=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=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=t1BqnFUH5jKiPdFMI2kWjFg6-amrBV0wvW05aD77NQs,28288
+pyerualjetwork/visualizations_cuda.py,sha256=PYRqj4QYUbuYMYcNwO8yaTPB-jK7E6kZHhTrAi0lwPU,28749
+pyerualjetwork-4.3.11.dist-info/METADATA,sha256=6P6WgEt2RMPwvhAVg1cswZvq_fNB875egS_dEiabzlo,7506
+pyerualjetwork-4.3.11.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
+pyerualjetwork-4.3.11.dist-info/top_level.txt,sha256=BRyt62U_r3ZmJpj-wXNOoA345Bzamrj6RbaWsyW4tRg,15
+pyerualjetwork-4.3.11.dist-info/RECORD,,

pyerualjetwork/fitness_functions_cuda.py

@@ -1,76 +0,0 @@
-import cupy as cp
-
-def pairwise_distances(X):
-    """
-    Pairwise Euclidean distances using CuPy.
-    :param X: A (n_samples, n_features) CuPy array.
-    :return: A 2D CuPy array of distances (n_samples, n_samples).
-    """
-    X = X.reshape(X.shape[0], -1)
-    r = cp.sum(X**2, axis=1, keepdims=True)
-
-    distances = cp.maximum(r - 2 * cp.dot(X, X.T) + r.T, 0.0)
-
-    return cp.sqrt(distances)
-
-def diversity_score(population):
-    """
-    Calculates the diversity score of a population based on the
-    Euclidean distances between individuals in the population.
-   
-    :param population: A CuPy array of shape (n_samples, n_features).
-    :return: The function returns a CuPy array of diversity scores for each matrix in the population.
-    """
-    if len(population) < 2:
-        return cp.zeros(len(population))
-    
-    population = cp.nan_to_num(population, nan=0.0)
-    
-    distances = pairwise_distances(population)
-    distances = cp.maximum(distances, 1e-10)
-    
-    n_samples = len(population)
-    
-    mask = cp.ones((n_samples, n_samples), dtype=bool)
-    cp.fill_diagonal(mask, 0) 
-
-    avg_distances = cp.sum(distances * mask, axis=1) / (n_samples - 1)
-
-    if population.shape[1] == 0:
-        return cp.zeros(len(population))
-        
-    max_possible_distance = cp.sqrt(population.shape[1])
-    max_possible_distance = float(max(max_possible_distance, 1e-10))
-    
-    diversity_scores = avg_distances / max_possible_distance
-    
-    return diversity_scores
-
-
-def multi_head_fitness(y_true, y_pred, diversity_score, accuracy, alpha=2, beta=1.5, lambda_div=0.05):
-    """
-    Computes a fitness score based on accuracy, margin loss, and diversity score.
-    
-    :param y_true: Ground truth labels (CupPy array).
-    :param y_pred: Predicted labels (CupPy array).
-    :param diversity_score: Diversity score for a single weight matrix.
-    :param accuracy: Model accuracy.
-    :param alpha: Exponent for accuracy impact.
-    :param beta: Exponent for margin loss impact.
-    :param lambda_div: Weight for diversity score influence.
-    :return: Computed fitness value.
-    """
-    incorrect = y_true != y_pred
-    
-    if cp.any(incorrect):
-        margin_loss = cp.abs(y_true[incorrect] - y_pred[incorrect]).mean()
-    else:
-        margin_loss = 0.0
-
-    margin_loss = cp.nan_to_num(margin_loss, nan=0.0)
-    accuracy = max(accuracy, 1e-10) 
-
-    fitness = (accuracy ** alpha) * ((1 - margin_loss) ** beta) * (1 + lambda_div * diversity_score)
-    fitness = cp.nan_to_num(fitness, nan=0.0, posinf=1e10, neginf=-1e10)
-    
-    return fitness

pyerualjetwork-4.3.10b2.dist-info/RECORD

@@ -1,24 +0,0 @@
-pyerualjetwork/__init__.py,sha256=DRF05WRIM4ITdnKZ98dzqV5ZrU9gDodseJHR7XZRSVk,642
-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=h-eigMH1n7vw2C53PAUGJFvUxtC_sVrFkGYH1zMcEmw,2698
-pyerualjetwork/fitness_functions_cuda.py,sha256=nncxtoTjF-_UBmACeiohUot5x-sUpsZpTuobFz6Jd4s,2640
-pyerualjetwork/help.py,sha256=nQ_YbYA2RtuafhuvkreNpX0WWL1I_nzlelwCtvei0_Y,775
-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=Bxx4EYlVxVzsdtDCBoy_f_IE0LhrP7GILqyesRQ6x48,20486
-pyerualjetwork/plan_cuda.py,sha256=K46cayXRowNFuLv_qkmcZIipT-nWn4yZ-UOinODD1iY,21011
-pyerualjetwork/planeat.py,sha256=QyfPW5k0rvVnowtymI3LXLKp39y69M5DIyNBAeKIhRQ,37568
-pyerualjetwork/planeat_cuda.py,sha256=zzsEu612Ren5K8YyvIn00RjYBG9Z6AOikiReGAPrBbg,37624
-pyerualjetwork/ui.py,sha256=wu2BhU1k-w3Kcho5Jtq4SEKe68ftaUeRGneUOSCVDjU,575
-pyerualjetwork/visualizations.py,sha256=6uY9U4qGOlG4aIhGdAFcTm2Z5m9Hxww4tAAG61_Vqb8,28294
-pyerualjetwork/visualizations_cuda.py,sha256=o6MyZUVz040lmdI2kGlOEU2IoxvyWJPhSOKe9vkLMvY,28753
-pyerualjetwork-4.3.10b2.dist-info/METADATA,sha256=Fv7c0vWkKDf6rzg4rK30PaUmT1B2MOvJZrpdqGHc5lA,7499
-pyerualjetwork-4.3.10b2.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
-pyerualjetwork-4.3.10b2.dist-info/top_level.txt,sha256=BRyt62U_r3ZmJpj-wXNOoA345Bzamrj6RbaWsyW4tRg,15
-pyerualjetwork-4.3.10b2.dist-info/RECORD,,