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

pyerualjetwork/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "4.3.9dev2"
+__version__ = "4.3.10b0"
 __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

@@ -13,56 +13,51 @@ def diversity_score(population):
     """
     if len(population) < 2:
         return 0
-
+        
+    population = np.nan_to_num(population, nan=0.0)
+    
     distances = pdist(population, metric='euclidean')
-
-    if np.isnan(distances).any() or np.any(distances == 0):
-        distances = np.maximum(distances, 1e-10)
+    distances = np.maximum(distances, 1e-10)
+    
     avg_distance = np.mean(distances)
-
     if population.shape[1] == 0:
         return 0
-
+        
     max_possible_distance = np.sqrt(population.shape[1])
-
-    if max_possible_distance == 0:
-        max_possible_distance = 1e-10
-
-    diversity = avg_distance / max_possible_distance
+    max_possible_distance = max(max_possible_distance, 1e-10)
     
+    diversity = avg_distance / max_possible_distance
     return diversity
 
-
-
-def hybrid_accuracy_confidence(y_true, y_pred, diversity_score, accuracy, alpha=2, beta=1.5, lambda_div=0.05):
+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 `hybrid_accuracy_confidence` function represents the
+    @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 `hybrid_accuracy_confidence` function
+    @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 `hybrid_accuracy_confidence` function, the accuracy parameter represents the accuracy
+    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 hybrid_accuracy_confidence function. It is used as an exponent to raise the accuracy value
+    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 `hybrid_accuracy_confidence` function is used as an exponent
+    @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 `hybrid_accuracy_confidence` function represents
+    @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 `hybrid_accuracy_confidence` returns the fitness value calculated based on the
+    @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.
@@ -70,6 +65,8 @@ def hybrid_accuracy_confidence(y_true, y_pred, diversity_score, accuracy, alpha=
     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)
+    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,85 @@
+import cupy as cp
+
+def cupy_pairwise_distances(X):
+    """
+    Pairwise Euclidean distances
+    """
+    r = cp.sum(X * X, 1)
+    r = r.reshape(-1, 1)
+
+    distances = cp.maximum(r - 2 * cp.dot(X, X.T) + r.T, 0.0)
+
+    triu_indices = cp.triu_indices(distances.shape[0], k=1)
+    return cp.sqrt(distances[triu_indices])
+
+
+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 = cupy_pairwise_distances(population)
+    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 = float(max(max_possible_distance, 1e-10))
+    
+    diversity = float(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

@@ -21,7 +21,6 @@ import numpy as np
 from .ui import loading_bars, initialize_loading_bar
 from .data_operations import normalization, batcher
 from .activation_functions import apply_activation, all_activations
-from .metrics import metrics
 from .model_operations import get_acc, get_preds, get_preds_softmax
 from .memory_operations import optimize_labels
 from .visualizations import (
@@ -171,8 +170,8 @@ 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
+    from fitness_functions import diversity_score
+    from planeat import define_genomes
 
     data = 'Train'
 
@@ -206,10 +205,11 @@ def learner(x_train, y_train, optimizer, fitness, fit_start=True, gen=None, batc
     fit_list = []
     target_pop = []
 
-    progress = initialize_loading_bar(total=activation_potentiation_len, desc="", ncols=78, bar_format=bar_format_learner)
+    progress = initialize_loading_bar(total=activation_potentiation_len, desc="", ncols=74, 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 = [0] * pop_size
@@ -238,12 +238,12 @@ 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()]
             
-            div_score = diversity_score(W)
-            fit_score = fitness(y_train_batch, model[get_preds_softmax()], div_score, acc)
+            fit_score = fitness(y_train_batch, model[get_preds()], div_score[j], acc)
 
             target_pop.append(fit_score)
 
@@ -251,7 +251,8 @@ def learner(x_train, y_train, optimizer, fitness, fit_start=True, gen=None, batc
 
                 best_acc = acc
                 best_fit = fit_score
-                best_weights = np.copy(weight_pop[j])
+                best_div_score = div_score[j]
+                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
@@ -266,7 +267,7 @@ def learner(x_train, y_train, optimizer, fitness, fit_start=True, gen=None, batc
                     print(f", Current Activations={final_activations}", end='')
 
                 if batch_size == 1:
-                    postfix_dict[f"{data} Fitness"] = np.round(fit_score, 4)
+                    postfix_dict["Fitness"] = np.round(fit_score, 4)
                     progress.set_postfix(postfix_dict)
                 best_fit = fit_score
 
@@ -278,7 +279,7 @@ def learner(x_train, y_train, optimizer, fitness, fit_start=True, gen=None, batc
 
                 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'],
@@ -286,7 +287,7 @@ def learner(x_train, y_train, optimizer, fitness, fit_start=True, gen=None, batc
                     )
 
                 if neural_web_history:
-                    art5_1, art5_2, art5_3 = draw_neural_web(W=best_weights, ax=viz_objects['web']['ax'],
+                    art5_1, art5_2, art5_3 = draw_neural_web(W=best_weight, ax=viz_objects['web']['ax'],
                                                             G=viz_objects['web']['G'], return_objs=True)
                     art5_list = [art5_1] + [art5_2] + list(art5_3.values())
                     viz_objects['web']['artists'].append(art5_list)
@@ -294,38 +295,36 @@ def learner(x_train, y_train, optimizer, fitness, fit_start=True, gen=None, batc
                 # Check target accuracy
                 if target_acc is not None and best_acc >= target_acc:
                     progress.close()
-                    train_model = evaluate(x_train, y_train, W=best_weights, 
+                    train_model = evaluate(x_train, y_train, W=best_weight, 
                                         activation_potentiation=final_activations)
 
-                    div_score = diversity_score(W)
-                    fit_score = fitness(y_train, train_model[get_preds_softmax()], div_score, train_model[get_acc()])
+                    fit_score = fitness(y_train, train_model[get_preds()], 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')
                                 
                     postfix_dict[f"{data} Accuracy"] = np.round(train_model[get_acc()], 4)
-                    postfix_dict[f"{data} Fitness"] = np.round(best_fit, 4)
+                    postfix_dict["Fitness"] = np.round(best_fit, 4)
                     progress.set_postfix(postfix_dict)
                     # Display final visualizations
-                    display_visualizations_for_learner(viz_objects, best_weights, data, best_acc, 
+                    display_visualizations_for_learner(viz_objects, best_weight, data, best_acc, 
                                               fit_score, y_train, interval)
-                    return best_weights, best_model[get_preds()], best_acc, final_activations
+                    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)
-            
-            div_score = diversity_score(W)
-            fit_score = fitness(y_train, train_model[get_preds_softmax()], div_score, train_model[get_acc()])
+            train_model = evaluate(x_train, y_train, best_weight, final_activations)
+ 
+            fit_score = fitness(y_train, train_model[get_preds()], 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')
-                        
+            
             postfix_dict[f"{data} Accuracy"] = np.round(train_model[get_acc()], 4)
-            postfix_dict[f"{data} Fitness"] = np.round(best_fit, 4)
+            postfix_dict["Fitness"] = np.round(best_fit, 4)
             progress.set_postfix(postfix_dict)
             
             best_acc_per_gen_list.append(train_model[get_acc()])
@@ -336,42 +335,41 @@ def learner(x_train, y_train, optimizer, fitness, fit_start=True, gen=None, batc
             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)
+        div_score = diversity_score(weight_pop)
         target_pop = []
 
         # Early stopping check
         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)
-
-                div_score = diversity_score(W)
-                fit_score = fitness(y_train, train_model[get_preds_softmax()], div_score, train_model[get_acc()])
+                
+                fit_score = fitness(y_train, train_model[get_preds()], 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')
 
                 # Display final visualizations
-                display_visualizations_for_learner(viz_objects, best_weights, data, best_acc, 
+                display_visualizations_for_learner(viz_objects, best_weight, data, best_acc, 
                                           fit_score, y_train, interval)
-                return best_weights, best_model[get_preds()], best_acc, final_activations
+                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)
 
-    div_score = diversity_score(W)
-    fit_score = fitness(y_train, train_model[get_preds_softmax()], div_score, train_model[get_acc()])
+    fit_score = fitness(y_train, train_model[get_preds()], 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')
 
     # Display final visualizations
-    display_visualizations_for_learner(viz_objects, best_weights, data, best_acc, fit_score, y_train, interval)
-    return best_weights, best_model[get_preds()], best_acc, final_activations
+    display_visualizations_for_learner(viz_objects, best_weight, data, best_acc, fit_score, y_train, interval)
+    return best_weight, best_model[get_preds()], best_acc, final_activations
 
 
 def evaluate(

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,18 +207,17 @@ 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)
+    progress = initialize_loading_bar(total=activation_potentiation_len, desc="", ncols=76, 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 = [0] * pop_size
@@ -241,40 +249,21 @@ def learner(x_train, y_train, optimizer, fit_start=True, strategy='accuracy', ge
                     act_pop[j] = activation_potentiation[j]
                     W = fit(x_train_batch, y_train_batch, activation_potentiation=act_pop[j], auto_normalization=auto_normalization, dtype=dtype)
                     weight_pop[j] = W
-    
+                    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()]
-            
-            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
+ 
+            fit_score = fitness(y_train_batch, model[get_preds()], div_score[j], 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_weights = cp.copy(weight_pop[j])
+                best_fit = fit_score
+                best_div_score = div_score[j]
+                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 +276,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["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,111 +306,77 @@ 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()])
+                    fit_score = fitness(y_train, train_model[get_preds()], best_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)
-            
-            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()])
+            train_model = evaluate(x_train, y_train, best_weight, final_activations)
 
+            fit_score = fitness(y_train, train_model[get_preds()], 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')
+                        
             postfix_dict[f"{data} Accuracy"] = cp.round(train_model[get_acc()], 4)
-            postfix_dict[f"{data} Loss"] = cp.round(train_loss, 4)
+            postfix_dict["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)
+        div_score = diversity_score(weight_pop)
         target_pop = []
 
         # Early stopping check
         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()])
+                fit_score = fitness(y_train, train_model[get_preds()], best_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()])
+    fit_score = fitness(y_train, train_model[get_preds()], best_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,
@@ -456,4 +406,4 @@ def evaluate(
     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
+    return W, result, accuracy, None, None, softmax_preds

pyerualjetwork/planeat.py

@@ -560,11 +560,11 @@ def cross_over(first_parent_W,
       selection_bias = random.uniform(0, 1)
 
       if fitness_bias > selection_bias:
-         row_cut_start = math.floor(row_cut_start * (succes + epsilon))
-         row_cut_end = math.ceil(row_cut_end * (succes + epsilon))
+         row_cut_start = math.floor(row_cut_start * succes)
+         row_cut_end = math.ceil(row_cut_end * succes)
 
-         col_cut_start = math.floor(col_cut_start * (succes + epsilon))
-         col_cut_end = math.ceil(col_cut_end * (succes + epsilon))
+         col_cut_start = math.floor(col_cut_start * succes)
+         col_cut_end = math.ceil(col_cut_end * succes)
 
    child_W = dominant_parent_W
 
@@ -590,9 +590,10 @@ def cross_over(first_parent_W,
          random_undominant_activation = undominant_parent_act[random_index]
 
          child_act.append(random_undominant_activation)
-
+         new_threshold += threshold
+         
          if len(dominant_parent_act) > new_threshold:
-            new_threshold += threshold
+            pass
          
          else:
             break
@@ -612,9 +613,10 @@ def cross_over(first_parent_W,
          random_undominant_activation = undominant_parent_act[random_index_undominant]
 
          child_act[random_index_dominant] = random_undominant_activation
-
+         new_threshold += threshold
+         
          if len(dominant_parent_act) > new_threshold:
-            new_threshold += threshold
+            pass
          
          else:
             break
@@ -690,7 +692,7 @@ def mutation(weight,
 
       max_threshold = row_end * col_end
 
-      threshold = weight_mutate_threshold * genome_fitness
+      threshold = weight_mutate_threshold * (genome_fitness + epsilon)
       new_threshold = threshold
       
       for _ in range(max_threshold):

pyerualjetwork/planeat_cuda.py

@@ -694,7 +694,7 @@ def mutation(weight,
       
       max_threshold = row_end * col_end
 
-      threshold = weight_mutate_threshold * genome_fitness
+      threshold = weight_mutate_threshold * (genome_fitness + epsilon)
       new_threshold = threshold
 
       for _ in range(max_threshold):

pyerualjetwork/visualizations.py

@@ -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.9.dev2.dist-info → pyerualjetwork-4.3.10b0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyerualjetwork
-Version: 4.3.9.dev2
+Version: 4.3.10b0
 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.10b0.dist-info/RECORD

@@ -0,0 +1,24 @@
+pyerualjetwork/__init__.py,sha256=PeTvh1FsdWQz17kIzq4JB4kuMWgHJ4NpNKMHQcOwPAk,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=kewx8yMtQFUO-9rjCD3n5z26X2vLeDsb0HPTIdizFF0,4084
+pyerualjetwork/fitness_functions_cuda.py,sha256=ouUh8hhEvEcATBuKg2gOBuqEOyJoygHORC851OUZrO8,4360
+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=DWWrvE9sLxx0xBQ2JbmFmetWuPRC92hmxI0OL6aIEuA,20341
+pyerualjetwork/plan_cuda.py,sha256=mF6ukdUc7uSdAHEiNQAQIEMebFRR7tUXtePq3IqeEpw,20858
+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.10b0.dist-info/METADATA,sha256=HBNJhe_U2XRfN7QJhiznxsj1Wargl3hQcz4aTkzUC1k,7499
+pyerualjetwork-4.3.10b0.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
+pyerualjetwork-4.3.10b0.dist-info/top_level.txt,sha256=BRyt62U_r3ZmJpj-wXNOoA345Bzamrj6RbaWsyW4tRg,15
+pyerualjetwork-4.3.10b0.dist-info/RECORD,,

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

pyerualjetwork-4.3.9.dev2.dist-info/RECORD

@@ -1,24 +0,0 @@
-pyerualjetwork/__init__.py,sha256=9eOTCzpFVUX9DY_9CL8Cw_Z88H6-tD0Jnw8a-gKKiWg,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=0tj1Ri8x8PXR9cuZF_PaUF3mjgsys0IRAEKklipKxZA,4064
-pyerualjetwork/help.py,sha256=nQ_YbYA2RtuafhuvkreNpX0WWL1I_nzlelwCtvei0_Y,775
-pyerualjetwork/loss_functions_cuda.py,sha256=C93IZJcrOpT6HMK9x1O4AHJWXYTkN5WZiqdssPbvAPk,617
-pyerualjetwork/memory_operations.py,sha256=I7QiZ--xSyRkFF0wcckPwZV7K9emEvyx5aJ3DiRHZFI,13468
-pyerualjetwork/metrics.py,sha256=q7MkhnZDRbCjFBDDfUgrl8lBYnUT_1ro1LxeBq105pI,6077
-pyerualjetwork/metrics_cuda.py,sha256=73h9GC7XwmnFCVzFEEiPQfF8CwHIz2wsCbxpZrJtYgw,5061
-pyerualjetwork/model_operations.py,sha256=MCSCNYiiICRVZITobtS3ZIWmH5Q9gjyELuH32sAdgg4,12649
-pyerualjetwork/model_operations_cuda.py,sha256=NT01BK5nrDYE7H1x3KnSI8gmx0QTGGB0mP_LqEb1uuU,13157
-pyerualjetwork/plan.py,sha256=vps6EHyHoFWBlp3g5BF3ygD4vIkFvvRsmB7xS0IJ70E,20452
-pyerualjetwork/plan_cuda.py,sha256=DCKWStOZhBq-NYKA2BQTKe3YgvDYuGtujtIr56ZBjiw,24477
-pyerualjetwork/planeat.py,sha256=OxwSjfSFPwh7kVrhnuAkr8Lrk73GB-Wk2ajUFIfZcbQ,37556
-pyerualjetwork/planeat_cuda.py,sha256=aTdBmhJeIKC58pssODtqVsdOtJP7W6TRmVyGHp7k_CM,37612
-pyerualjetwork/ui.py,sha256=wu2BhU1k-w3Kcho5Jtq4SEKe68ftaUeRGneUOSCVDjU,575
-pyerualjetwork/visualizations.py,sha256=08O5uEewuYiovZRX1uHWEHjn19LcnhndWYvqVN74xs0,28290
-pyerualjetwork/visualizations_cuda.py,sha256=PYRqj4QYUbuYMYcNwO8yaTPB-jK7E6kZHhTrAi0lwPU,28749
-pyerualjetwork-4.3.9.dev2.dist-info/METADATA,sha256=Z0nThYRtlJKsScG6ZRZYdPcBPU_GfIcxtE8oz1nFVRI,7479
-pyerualjetwork-4.3.9.dev2.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
-pyerualjetwork-4.3.9.dev2.dist-info/top_level.txt,sha256=BRyt62U_r3ZmJpj-wXNOoA345Bzamrj6RbaWsyW4tRg,15
-pyerualjetwork-4.3.9.dev2.dist-info/RECORD,,