pyerualjetwork 4.3.9b7__py3-none-any.whl → 4.3.9b8__py3-none-any.whl

pyerualjetwork/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "4.3.9b7"
+__version__ = "4.3.9b8"
 __update__ = "* Changes: https://github.com/HCB06/PyerualJetwork/blob/main/CHANGES\n* PyerualJetwork Homepage: https://github.com/HCB06/PyerualJetwork/tree/main\n* PyerualJetwork document: https://github.com/HCB06/PyerualJetwork/blob/main/Welcome_to_PyerualJetwork/PYERUALJETWORK_USER_MANUEL_AND_LEGAL_INFORMATION(EN).pdf\n* YouTube tutorials: https://www.youtube.com/@HasanCanBeydili"
 
 def print_version(__version__):

pyerualjetwork/fitness_functions.py

@@ -0,0 +1,72 @@
+import numpy as np
+from scipy.spatial.distance import pdist
+
+def diversity_score(population):
+    """
+    Calculates the diversity score of a population based on the
+    Euclidean distances between individuals in the population.
+    
+    :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.
+    """
+    if len(population) < 2:
+        return 0
+        
+    population = np.nan_to_num(population, nan=0.0)
+    
+    distances = pdist(population, metric='euclidean')
+    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])
+    max_possible_distance = max(max_possible_distance, 1e-10)
+    
+    diversity = avg_distance / max_possible_distance
+    return diversity
+
+def multi_head_fitness(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 `multi_head_fitness` 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 `multi_head_fitness` 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 `multi_head_fitness` 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 multi_head_fitness 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 `multi_head_fitness` 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 `multi_head_fitness` 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 `multi_head_fitness` 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
+
+    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)
+    return fitness

pyerualjetwork/fitness_functions_cuda.py

@@ -0,0 +1,72 @@
+import cupy as cp
+from scipy.spatial.distance import pdist
+
+def diversity_score(population):
+    """
+    Calculates the diversity score of a population based on the
+    Euclidean distances between individuals in the population.
+    
+    :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.
+    """
+    if len(population) < 2:
+        return 0
+        
+    population = cp.nan_to_num(population, nan=0.0)
+    
+    distances = pdist(population, metric='euclidean')
+    distances = cp.maximum(distances, 1e-10)
+    
+    avg_distance = cp.mean(distances)
+    if population.shape[1] == 0:
+        return 0
+        
+    max_possible_distance = cp.sqrt(population.shape[1])
+    max_possible_distance = max(max_possible_distance, 1e-10)
+    
+    diversity = avg_distance / max_possible_distance
+    return diversity
+
+def multi_head_fitness(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 `multi_head_fitness` 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 `multi_head_fitness` 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 `multi_head_fitness` 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 multi_head_fitness 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 `multi_head_fitness` 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 `multi_head_fitness` 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 `multi_head_fitness` returns the fitness value calculated based on the
+    icput 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 = cp.abs(y_true[incorrect] - y_pred[incorrect]).mean() if cp.any(incorrect) else 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)
+    return fitness

pyerualjetwork/plan.py

@@ -20,9 +20,7 @@ import numpy as np
 ### LIBRARY IMPORTS ###
 from .ui import loading_bars, initialize_loading_bar
 from .data_operations import normalization, batcher
-from .loss_functions import binary_crossentropy, categorical_crossentropy
 from .activation_functions import apply_activation, all_activations
-from .metrics import metrics
 from .model_operations import get_acc, get_preds, get_preds_softmax
 from .memory_operations import optimize_labels
 from .visualizations import (
@@ -83,10 +81,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,
+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, loss='categorical_crossentropy', show_history=False,
-           interval=33.33, target_acc=None, target_loss=None,
+           neurons_history=False, early_stop=False, show_history=False,
+           interval=33.33, target_acc=None,
            start_this_act=None, start_this_W=None, dtype=np.float32):
     """
     Optimizes the activation functions for a neural network by leveraging train data to find 
@@ -104,14 +102,15 @@ 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 (and) optimizer = lambda *args, **kwargs: planeat.evolve(*args, 'here give your neat hyperparameters for example:  activation_add_prob=0.85', **kwargs) Example:
         ```python
-        genetic_optimizer = lambda *args, **kwargs: planeat.evolver(*args,
-                                                                    activation_add_prob=0.85,
-                                                                    strategy='aggressive',
-                                                                    **kwargs)
+        optimizer = lambda *args, **kwargs: planeat.evolver(*args,
+                                                            activation_add_prob=0.85,
+                                                            strategy='aggressive',
+                                                            **kwargs)
 
         model = plan.learner(x_train,
                              y_train,
-                             optimizer=genetic_optimizer,
+                             optimizer,
+                             fitness,
                              fit_start=True,
                              strategy='accuracy',
                              show_history=True,
@@ -120,9 +119,23 @@ def learner(x_train, y_train, optimizer, fit_start=True, strategy='accuracy', ge
                              interval=16.67)
         ```
 
-        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
+        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)
 
-        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'.
+        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)
+        ```
+        
+        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
 
         gen (int, optional): The generation count for genetic optimization.
 
@@ -138,14 +151,10 @@ def learner(x_train, y_train, optimizer, fit_start=True, strategy='accuracy', ge
 
         auto_normalization (bool, optional): Normalization may solves overflow problem. Default: 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'.
-
         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
 
         start_this_W (numpy.array, 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 weight matrix of this genome. Default is None
@@ -161,6 +170,7 @@ def learner(x_train, y_train, optimizer, fit_start=True, strategy='accuracy', ge
     
     """
 
+    from .fitness_functions import diversity_score
     from .planeat import define_genomes
 
     data = 'Train'
@@ -181,7 +191,6 @@ def learner(x_train, y_train, optimizer, fit_start=True, strategy='accuracy', ge
     if gen is None:
         gen = activation_potentiation_len
 
-    if strategy != 'accuracy' and strategy != 'f1' and strategy != 'recall' and strategy != 'precision': raise ValueError("Strategy parameter only be 'accuracy' or 'f1' or 'recall' or 'precision'.")
     if target_acc is not None and (target_acc < 0 or target_acc > 1): raise ValueError('target_acc must be in range 0 and 1')
     if fit_start is not True and fit_start is not False: raise ValueError('fit_start parameter only be True or False. Please read doc-string')
 
@@ -190,12 +199,10 @@ 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_fit = 0
     best_acc_per_gen_list = []
     postfix_dict = {}
-    loss_list = []
+    fit_list = []
     target_pop = []
 
     progress = initialize_loading_bar(total=activation_potentiation_len, desc="", ncols=78, bar_format=bar_format_learner)
@@ -234,36 +241,16 @@ def learner(x_train, y_train, optimizer, fit_start=True, strategy='accuracy', ge
             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
+            div_score = diversity_score(weight_pop[j])
+            fit_score = fitness(y_train_batch, model[get_preds_softmax()], div_score, acc)
 
-                if strategy == 'recall':
-                    target_pop.append(recall_score)
+            target_pop.append(fit_score)
 
-                    if i == 0 and j == 0:
-                        best_recall = recall_score
-
-                if strategy == 'f1':
-                    target_pop.append(f1_score)
-
-                    if i == 0 and j == 0:
-                        best_f1 = f1_score
-
-            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 fit_score >= best_fit:
 
                 best_acc = acc
-                best_weights = np.copy(weight_pop[j])
+                best_fit = fit_score
+                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
@@ -277,33 +264,28 @@ def learner(x_train, y_train, optimizer, fit_start=True, strategy='accuracy', ge
                 if show_current_activations:
                     print(f", Current Activations={final_activations}", end='')
 
-                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 batch_size == 1:
-                    postfix_dict[f"{data} Loss"] = np.round(train_loss, 4)
+                    postfix_dict[f"{data} Fitness"] = np.round(fit_score, 4)
                     progress.set_postfix(postfix_dict)
-                best_loss = train_loss
+                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, loss_list + [train_loss], 
+                    update_history_plots_for_learner(viz_objects, gen_list, fit_list + [fit_score], 
                                       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=train_loss)
+                                     acc=best_acc, loss=fit_score)
                     )
 
                 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)
@@ -311,69 +293,43 @@ 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, 
-                                        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, 
-                                              train_loss, y_train, interval)
-                    return best_weights, best_model[get_preds()], 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':
-                        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(best_weight)
+                    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'Train Loss: ', train_loss, '\n')
-
+                    print(f'Fitness Value: ', fit_score, '\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, 
+                                              fit_score, y_train, interval)
+                    return best_weight, best_model[get_preds()], 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(best_weight)
+            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} Loss"] = np.round(train_loss, 4)
+            postfix_dict[f"{data} Fitness"] = np.round(best_fit, 4)
             progress.set_postfix(postfix_dict)
             
             best_acc_per_gen_list.append(train_model[get_acc()])
-            loss_list.append(train_loss)
+            fit_list.append(fit_score)
 
         else:
             best_acc_per_gen_list.append(best_acc)
-            loss_list.append(best_loss)
+            fit_list.append(best_fit)
 
         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 = []
@@ -382,42 +338,36 @@ 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()])
+                div_score = diversity_score(best_weight)
+                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'Train Loss: ', train_loss, '\n')
+                print(f'Fitness Value: ', fit_score, '\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, 
+                                          fit_score, y_train, interval)
+                return best_weight, best_model[get_preds()], 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()])
-    else:
-        train_loss = binary_crossentropy(y_true_batch=y_train, y_pred_batch=train_model[get_preds_softmax()])
+    div_score = diversity_score(best_weight)
+    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'Train Loss: ', train_loss, '\n')
+    print(f'Fitness Value: ', fit_score, '\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, fit_score, y_train, interval)
+    return best_weight, best_model[get_preds()], best_acc, final_activations
 
 
 def evaluate(
@@ -444,6 +394,8 @@ def evaluate(
 
     x_test = apply_activation(x_test, activation_potentiation)
     result = x_test @ W.T
-    softmax_preds = np.exp(result) / np.sum(np.exp(result), axis=1, keepdims=True); accuracy = (np.argmax(result, axis=1) == np.argmax(y_test, axis=1)).mean()
+    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

pyerualjetwork/plan_cuda.py

@@ -20,9 +20,7 @@ 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 .memory_operations import transfer_to_gpu, transfer_to_cpu, optimize_labels
 from .visualizations_cuda import (
@@ -82,10 +80,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,
+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, loss='categorical_crossentropy', show_history=False,
-           interval=33.33, target_acc=None, target_loss=None,
+           neurons_history=False, early_stop=False, show_history=False,
+           interval=33.33, target_acc=None,
            start_this_act=None, start_this_W=None, dtype=cp.float32, memory='gpu'):
     """
     Optimizes the activation functions for a neural network by leveraging train data to find 
@@ -118,10 +116,25 @@ def learner(x_train, y_train, optimizer, fit_start=True, strategy='accuracy', ge
                                 batch_size=0.05,
                                 interval=16.67)
         ```
-        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'.
+        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)
+        ```
 
+        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
+        
         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)
@@ -134,15 +147,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
 
@@ -161,6 +170,7 @@ def learner(x_train, y_train, optimizer, fit_start=True, strategy='accuracy', ge
     
     """
 
+    from .fitness_functions_cuda import diversity_score
     from .planeat_cuda import define_genomes
 
     data = 'Train'
@@ -189,7 +199,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,12 +207,10 @@ 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_fit = 0
     best_acc_per_gen_list = []
     postfix_dict = {}
-    loss_list = []
+    fit_list = []
     target_pop = []
 
     progress = initialize_loading_bar(total=activation_potentiation_len, desc="", ncols=78, bar_format=bar_format_learner)
@@ -245,36 +252,16 @@ def learner(x_train, y_train, optimizer, fit_start=True, strategy='accuracy', ge
             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 strategy == 'f1':
-                    target_pop.append(f1_score)
+            div_score = diversity_score(weight_pop[j])
+            fit_score = fitness(y_train_batch, model[get_preds_softmax()], div_score, acc)
 
-                    if i == 0 and j == 0:
-                        best_f1 = f1_score
+            target_pop.append(fit_score)
 
-            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 fit_score >= best_fit:
 
                 best_acc = acc
-                best_weights = cp.copy(weight_pop[j])
+                best_fit = fit_score
+                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
@@ -287,34 +274,29 @@ def learner(x_train, y_train, optimizer, fit_start=True, strategy='accuracy', ge
 
                 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
+                    postfix_dict[f"{data} 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, loss_list + [train_loss], 
+                    update_history_plots_for_learner(viz_objects, gen_list, fit_list + [fit_score], 
                                       best_acc_per_gen_list + [best_acc], x_train, final_activations)
 
                 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'],
-                                     acc=best_acc, loss=train_loss)
+                                     acc=best_acc, loss=fit_score)
                     )
 
                 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,67 +304,42 @@ 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()])
-                    else:
-                        train_loss = binary_crossentropy(y_true_batch=y_train, 
-                                                       y_pred_batch=train_model[get_preds_softmax()])
+                    div_score = diversity_score(best_weight)
+                    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'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
-
-                # 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, 
-                                        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, 
-                                              train_loss, y_train, interval)
-                    return best_weights, best_model[get_preds()], best_acc, final_activations
+                    print(f'Fitness Value: ', fit_score, '\n')
+                    
+                    display_visualizations_for_learner(viz_objects, best_weight, data, best_acc, 
+                                              fit_score, y_train, interval)
+                    return best_weight, best_model[get_preds()], 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()])
-            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()])
+            div_score = diversity_score(best_weight)
+            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"] = cp.round(train_model[get_acc()], 4)
-            postfix_dict[f"{data} Loss"] = cp.round(train_loss, 4)
+            postfix_dict[f"{data} Fitness"] = cp.round(best_fit, 4)
             progress.set_postfix(postfix_dict)
-
+            
             best_acc_per_gen_list.append(train_model[get_acc()])
-            loss_list.append(train_loss)
+            fit_list.append(fit_score)
 
         else:
             best_acc_per_gen_list.append(best_acc)
-            loss_list.append(best_loss)
+            fit_list.append(best_fit)
 
         weight_pop, act_pop = optimizer(cp.array(weight_pop, copy=False, dtype=dtype), act_pop, i, cp.array(target_pop, dtype=dtype, copy=False), bar_status=False)
         target_pop = []
@@ -391,42 +348,36 @@ 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()])
+                div_score = diversity_score(best_weight)
+                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'Train Loss: ', train_loss, '\n')
+                print(f'Fitness Value: ', fit_score, '\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, 
+                                          fit_score, y_train, interval)
+                return best_weight, best_model[get_preds()], 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()])
-    else:
-        train_loss = binary_crossentropy(y_true_batch=y_train, y_pred_batch=train_model[get_preds_softmax()])
+    div_score = diversity_score(best_weight)
+    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'Train Loss : ', train_loss, '\n')
+    print(f'Train Accuracy:', train_model[get_acc()])
+    print(f'Fitness Value: ', fit_score, '\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, fit_score, y_train, interval)
+    return best_weight, best_model[get_preds()], best_acc, final_activations
 
 def evaluate(
     x_test,
@@ -452,6 +403,8 @@ def evaluate(
 
     x_test = apply_activation(x_test, activation_potentiation)
     result = x_test @ W.T
-    softmax_preds = cp.exp(result) / cp.sum(cp.exp(result), axis=1, keepdims=True); accuracy = (cp.argmax(result, axis=1) == cp.argmax(y_test, axis=1)).mean()
+    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

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']
     
-    # 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')
+    # 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')
     hist['artist1'].append(art1)
     
     # Accuracy plot
@@ -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/visualizations_cuda.py

@@ -748,13 +748,12 @@ 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()
 
-    # 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')
+    # 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')
     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.9b7.dist-info → pyerualjetwork-4.3.9b8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyerualjetwork
-Version: 4.3.9b7
+Version: 4.3.9b8
 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',

{pyerualjetwork-4.3.9b7.dist-info → pyerualjetwork-4.3.9b8.dist-info}/RECORD

@@ -1,24 +1,24 @@
-pyerualjetwork/__init__.py,sha256=9pV3ZfPPqMatL9LwixrmgVVhQ_rTYeIyrTAAutNbiuw,641
+pyerualjetwork/__init__.py,sha256=yxGVyGpN6O4nRZG7ZavFC1-XIbG1hPZB3-R9cbAgHbY,641
 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=kewx8yMtQFUO-9rjCD3n5z26X2vLeDsb0HPTIdizFF0,4084
+pyerualjetwork/fitness_functions_cuda.py,sha256=cait3Cb0kn4SC9wZr-SKurnvTw1KuOrvigvbPm4jNiM,4083
 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=mcVxwBus_GwfYjWLMwx8KDc25uJT8l773l-mHCfa0Xk,23558
-pyerualjetwork/plan_cuda.py,sha256=8uEyYdQQX122Hcc-XfFoPSiCeLADt-y-cGX3AuRYPt0,24440
+pyerualjetwork/plan.py,sha256=dE63JQs8-8mOLbz3g6xjrM9AIpqx3bGF5wI3LyFOT2w,20200
+pyerualjetwork/plan_cuda.py,sha256=HlpJ8eWFNqQEBVaxLk2rtsusjV5mFSFUlK54DSyVzcA,20986
 pyerualjetwork/planeat.py,sha256=OxwSjfSFPwh7kVrhnuAkr8Lrk73GB-Wk2ajUFIfZcbQ,37556
 pyerualjetwork/planeat_cuda.py,sha256=aTdBmhJeIKC58pssODtqVsdOtJP7W6TRmVyGHp7k_CM,37612
 pyerualjetwork/ui.py,sha256=wu2BhU1k-w3Kcho5Jtq4SEKe68ftaUeRGneUOSCVDjU,575
-pyerualjetwork/visualizations.py,sha256=08O5uEewuYiovZRX1uHWEHjn19LcnhndWYvqVN74xs0,28290
-pyerualjetwork/visualizations_cuda.py,sha256=PYRqj4QYUbuYMYcNwO8yaTPB-jK7E6kZHhTrAi0lwPU,28749
-pyerualjetwork-4.3.9b7.dist-info/METADATA,sha256=LaPTIsNcmnCw7sl_Q5PrEizpPa6aX236xs62-xnBOYw,7476
-pyerualjetwork-4.3.9b7.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
-pyerualjetwork-4.3.9b7.dist-info/top_level.txt,sha256=BRyt62U_r3ZmJpj-wXNOoA345Bzamrj6RbaWsyW4tRg,15
-pyerualjetwork-4.3.9b7.dist-info/RECORD,,
+pyerualjetwork/visualizations.py,sha256=6uY9U4qGOlG4aIhGdAFcTm2Z5m9Hxww4tAAG61_Vqb8,28294
+pyerualjetwork/visualizations_cuda.py,sha256=o6MyZUVz040lmdI2kGlOEU2IoxvyWJPhSOKe9vkLMvY,28753
+pyerualjetwork-4.3.9b8.dist-info/METADATA,sha256=3mzAM10ATqA5dIf6rNAM1dgw8NlsLx1uAr3-EFBqmLk,7498
+pyerualjetwork-4.3.9b8.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
+pyerualjetwork-4.3.9b8.dist-info/top_level.txt,sha256=BRyt62U_r3ZmJpj-wXNOoA345Bzamrj6RbaWsyW4tRg,15
+pyerualjetwork-4.3.9b8.dist-info/RECORD,,

pyerualjetwork/loss_functions.py

@@ -1,21 +0,0 @@
-
-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

@@ -1,21 +0,0 @@
-
-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