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

pyerualjetwork/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "4.3.9b7"
+__version__ = "4.3.9dev1"
 __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,67 @@
+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
+    
+    distances = pdist(population, metric='euclidean')
+
+    avg_distance = np.mean(distances)
+    
+    max_possible_distance = np.sqrt(population.shape[1])
+    diversity = avg_distance / max_possible_distance
+    
+    return diversity
+
+
+def hybrid_accuracy_confidence(y_true, y_pred, diversity_score, accuracy, alpha=2, beta=1.5, lambda_div=0.05):
+    """
+    The function calculates a fitness score based on accuracy, margin loss, and diversity score using
+    specified parameters.
+    
+    @param y_true The `y_true` parameter represents the true labels of the data points. It is an array
+    or list containing the actual labels of the data points.
+    @param y_pred The `y_pred` parameter in the `hybrid_accuracy_confidence` function represents the
+    predicted values for a given dataset. It is a NumPy array containing the predicted values for each
+    sample in the dataset.
+    @param diversity_score The `diversity_score` parameter in the `hybrid_accuracy_confidence` function
+    represents a measure of diversity in the predictions. It is used as a factor in calculating the
+    fitness of the model. The function combines accuracy, margin loss, and diversity score to evaluate
+    the overall performance of the model
+    @param accuracy Accuracy is a measure of the correct predictions made by a model. It is typically
+    calculated as the number of correct predictions divided by the total number of predictions. In the
+    context of the `hybrid_accuracy_confidence` function, the accuracy parameter represents the accuracy
+    of the model's predictions.
+    @param alpha Alpha is a parameter that controls the impact of accuracy on the overall fitness score
+    in the hybrid_accuracy_confidence function. It is used as an exponent to raise the accuracy value
+    to, influencing its contribution to the fitness calculation.
+    @param beta The `beta` parameter in the `hybrid_accuracy_confidence` function is used as an exponent
+    in the fitness calculation formula. It controls the impact of the margin loss term on the overall
+    fitness value. A higher value of `beta` will amplify the effect of the margin loss term, making it
+    @param lambda_div The `lambda_div` parameter in the `hybrid_accuracy_confidence` function represents
+    the weight given to the diversity score in calculating the fitness value. It is a hyperparameter
+    that controls the impact of diversity score on the overall fitness calculation. A higher value of
+    `lambda_div` will increase the importance
+    @return The function `hybrid_accuracy_confidence` returns the fitness value calculated based on the
+    input parameters `y_true`, `y_pred`, `diversity_score`, `accuracy`, and optional parameters `alpha`,
+    `beta`, and `lambda_div`. The fitness value is computed using a formula that combines accuracy,
+    margin loss, and diversity score with specified weights and coefficients.
+    """
+    incorrect = y_true != y_pred
+    margin_loss = np.abs(y_true[incorrect] - y_pred[incorrect]).mean() if np.any(incorrect) else 0
+
+    fitness = (accuracy ** alpha) * ((1 - margin_loss) ** beta) * (1 + lambda_div * diversity_score)
+    
+    return fitness

pyerualjetwork/plan.py

@@ -20,7 +20,6 @@ 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
@@ -83,10 +82,10 @@ def fit(
     return normalization(weight, dtype=dtype)
 
 
-def learner(x_train, y_train, optimizer, fit_start=True, strategy='accuracy', gen=None, batch_size=1, pop_size=None,
+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 +103,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 +120,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 '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)
 
-        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 +152,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 +171,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 +192,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 +200,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,35 +242,15 @@ 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
+            div_score = diversity_score(W)
+            fit_score = fitness(y_train_batch, model[get_preds_softmax()], div_score, acc)
 
-                if strategy == 'f1':
-                    target_pop.append(f1_score)
+            target_pop.append(fit_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_fit = fit_score
                 best_weights = np.copy(weight_pop[j])
                 final_activations = act_pop[j].copy() if isinstance(act_pop[j], list) else act_pop[j]
 
@@ -277,20 +265,15 @@ 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"] = fit_score
                     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:
@@ -299,7 +282,7 @@ def learner(x_train, y_train, optimizer, fit_start=True, strategy='accuracy', ge
                                      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:
@@ -314,42 +297,19 @@ def learner(x_train, y_train, optimizer, fit_start=True, strategy='accuracy', ge
                     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()])
+                    div_score = diversity_score(W)
+                    fit_score = fitness(y_train, train_model[get_preds_softmax()], div_score, train_model[get_acc()])
 
                     print('\nActivations: ', final_activations)
                     print(f'Train Accuracy:', train_model[get_acc()])
-                    print(f'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')
-
+                    print(f'Fitness Value: ', fit_score, '\n')
+                                
+                    postfix_dict[f"{data} Accuracy"] = np.round(train_model[get_acc()], 4)
+                    postfix_dict[f"{data} Fitness"] = best_fit
+                    progress.set_postfix(postfix_dict)
                     # Display final visualizations
                     display_visualizations_for_learner(viz_objects, best_weights, data, best_acc, 
-                                              train_loss, y_train, interval)
+                                              fit_score, y_train, interval)
                     return best_weights, best_model[get_preds()], best_acc, final_activations
 
             progress.update(1)
@@ -357,23 +317,23 @@ def learner(x_train, y_train, optimizer, fit_start=True, strategy='accuracy', ge
         if batch_size != 1:
             train_model = evaluate(x_train, y_train, best_weights, final_activations)
             
-            if loss == 'categorical_crossentropy':
-                train_loss = categorical_crossentropy(y_true_batch=y_train, 
-                                                    y_pred_batch=train_model[get_preds_softmax()])
-            else:
-                train_loss = binary_crossentropy(y_true_batch=y_train, 
-                                                y_pred_batch=train_model[get_preds_softmax()])
+            div_score = diversity_score(W)
+            fit_score = fitness(y_train, train_model[get_preds_softmax()], div_score, train_model[get_acc()])
+
+            print('\nActivations: ', final_activations)
+            print(f'Train Accuracy:', train_model[get_acc()])
+            print(f'Fitness Value: ', fit_score, '\n')
                         
             postfix_dict[f"{data} Accuracy"] = np.round(train_model[get_acc()], 4)
-            postfix_dict[f"{data} Loss"] = np.round(train_loss, 4)
+            postfix_dict[f"{data} Fitness"] = best_fit
             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 = []
@@ -385,20 +345,16 @@ def learner(x_train, y_train, optimizer, fit_start=True, strategy='accuracy', ge
                 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()])
+                div_score = diversity_score(W)
+                fit_score = fitness(y_train, train_model[get_preds_softmax()], div_score, train_model[get_acc()])
 
                 print('\nActivations: ', final_activations)
                 print(f'Train Accuracy:', train_model[get_acc()])
-                print(f'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)
+                                          fit_score, y_train, interval)
                 return best_weights, best_model[get_preds()], best_acc, final_activations
 
     # Final evaluation
@@ -406,17 +362,15 @@ def learner(x_train, y_train, optimizer, fit_start=True, strategy='accuracy', ge
     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()])
+    div_score = diversity_score(W)
+    fit_score = fitness(y_train, train_model[get_preds_softmax()], div_score, train_model[get_acc()])
 
     print('\nActivations: ', final_activations)
     print(f'Train Accuracy:', train_model[get_acc()])
-    print(f'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)
+    display_visualizations_for_learner(viz_objects, best_weights, data, best_acc, fit_score, y_train, interval)
     return best_weights, best_model[get_preds()], best_acc, final_activations
 
 
@@ -444,6 +398,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

@@ -452,6 +452,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-4.3.9b7.dist-info → pyerualjetwork-4.3.9.dev1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyerualjetwork
-Version: 4.3.9b7
+Version: 4.3.9.dev1
 Summary: PyerualJetwork is a machine learning library supported with GPU(CUDA) acceleration written in Python for professionals and researchers including with PLAN algorithm, PLANEAT algorithm (genetic optimization). Also includes data pre-process and memory manegament
 Author: Hasan Can Beydili
 Author-email: tchasancan@gmail.com

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

@@ -1,24 +1,24 @@
-pyerualjetwork/__init__.py,sha256=9pV3ZfPPqMatL9LwixrmgVVhQ_rTYeIyrTAAutNbiuw,641
+pyerualjetwork/__init__.py,sha256=TkG_18QqarnCsZ99v_XYRuWoDYGIh2dQErq5tUwJtNU,643
 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=EkBCRWr70Y1yG0bc4styDUDkVxLwJ0wjirLKPh74-9U,3835
 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=p8OX4Qo3vxtKU74eO68I61ZHrKBju1p8sk4Pv6x8e2w,20413
+pyerualjetwork/plan_cuda.py,sha256=DCKWStOZhBq-NYKA2BQTKe3YgvDYuGtujtIr56ZBjiw,24477
 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-4.3.9.dev1.dist-info/METADATA,sha256=q2sjP-KKIkuv4idsaFXFY1MUu041vHy2jpvIoFmoLI0,7479
+pyerualjetwork-4.3.9.dev1.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
+pyerualjetwork-4.3.9.dev1.dist-info/top_level.txt,sha256=BRyt62U_r3ZmJpj-wXNOoA345Bzamrj6RbaWsyW4tRg,15
+pyerualjetwork-4.3.9.dev1.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