pyerualjetwork 4.3.10b0__py3-none-any.whl → 4.3.10b2__py3-none-any.whl

pyerualjetwork/__init__.py

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

pyerualjetwork/fitness_functions.py

@@ -1,72 +1,78 @@
 import numpy as np
-from scipy.spatial.distance import pdist
+
+def pairwise_distances(X):
+    """
+    Pairwise Euclidean distances using NumPy.
+    :param X: A (n_samples, n_features) NumPy array.
+    :return: A 2D NumPy array of distances (n_samples, n_samples).
+    """
+    X = X.reshape(X.shape[0], -1)
+    r = np.sum(X**2, axis=1, keepdims=True)
+
+    distances = np.maximum(r - 2 * np.dot(X, X.T) + r.T, 0.0)
+
+    return np.sqrt(distances)
 
 def diversity_score(population):
     """
     Calculates the diversity score of a population based on the
     Euclidean distances between individuals in the population.
-    
-    :param population: That calculates the diversity score of a population based on the Euclidean distances between
-    individuals in the population
-    :return: The function returns the diversity score,
-    which is a measure of how spread out or diverse the population is in terms of their characteristics.
+
+    :param population: A NumPy array of shape (n_samples, n_features),
+                       where each element is an individual weight matrix (flattened).
+    :return: A NumPy array of diversity scores for each weight matrix.
     """
     if len(population) < 2:
-        return 0
-        
+        return np.zeros(len(population))
+    
     population = np.nan_to_num(population, nan=0.0)
     
-    distances = pdist(population, metric='euclidean')
+    distances = pairwise_distances(population)
     distances = np.maximum(distances, 1e-10)
+
+    n_samples = len(population)
+
+    mask = np.ones((n_samples, n_samples), dtype=bool)
+    np.fill_diagonal(mask, 0)
+    
+    avg_distances = np.sum(distances * mask, axis=1) / (n_samples - 1)
     
-    avg_distance = np.mean(distances)
     if population.shape[1] == 0:
-        return 0
+        return np.zeros(len(population))
         
     max_possible_distance = np.sqrt(population.shape[1])
-    max_possible_distance = max(max_possible_distance, 1e-10)
+    max_possible_distance = float(max(max_possible_distance, 1e-10))
+    
+    diversity_scores = avg_distances / max_possible_distance
     
-    diversity = avg_distance / max_possible_distance
-    return diversity
+    return diversity_scores
+
+
 
 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.
+    Computes a fitness score based on accuracy, margin loss, and diversity score.
     
-    @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.
+    :param y_true: Ground truth labels (NumPy array).
+    :param y_pred: Predicted labels (NumPy array).
+    :param diversity_score: Diversity score for a single weight matrix.
+    :param accuracy: Model accuracy.
+    :param alpha: Exponent for accuracy impact.
+    :param beta: Exponent for margin loss impact.
+    :param lambda_div: Weight for diversity score influence.
+    :return: Computed fitness value.
     """
     incorrect = y_true != y_pred
-    margin_loss = np.abs(y_true[incorrect] - y_pred[incorrect]).mean() if np.any(incorrect) else 0
+    
+    if np.any(incorrect):
+        margin_loss = np.abs(y_true[incorrect] - y_pred[incorrect]).mean()
+    else:
+        margin_loss = 0.0
 
     margin_loss = np.nan_to_num(margin_loss, nan=0.0)
     accuracy = max(accuracy, 1e-10)
-    
+
     fitness = (accuracy ** alpha) * ((1 - margin_loss) ** beta) * (1 + lambda_div * diversity_score)
+    fitness = np.nan_to_num(fitness, nan=0.0, posinf=1e10, neginf=-1e10)
+    
     return fitness

pyerualjetwork/fitness_functions_cuda.py

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

pyerualjetwork/plan.py

@@ -170,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'
 
@@ -212,7 +212,7 @@ def learner(x_train, y_train, optimizer, fitness, fit_start=True, gen=None, batc
         div_score = diversity_score(weight_pop)
 
     else:
-        weight_pop = [0] * pop_size
+        weight_pop = [np.random.uniform(-1, 1, (len(y_train[0]), x_train[0].shape[0])) for _ in range(pop_size)]
         act_pop = [0] * pop_size
 
     if start_this_act is not None and start_this_W is not None:
@@ -243,7 +243,7 @@ def learner(x_train, y_train, optimizer, fitness, fit_start=True, gen=None, batc
             model = evaluate(x_train_batch, y_train_batch, W=weight_pop[j], activation_potentiation=act_pop[j])
             acc = model[get_acc()]
             
-            fit_score = fitness(y_train_batch, model[get_preds()], div_score[j], acc)
+            fit_score = fitness(y_train_batch, model[get_preds_softmax()], div_score[j], acc)
 
             target_pop.append(fit_score)
 
@@ -298,7 +298,7 @@ def learner(x_train, y_train, optimizer, fitness, fit_start=True, gen=None, batc
                     train_model = evaluate(x_train, y_train, W=best_weight, 
                                         activation_potentiation=final_activations)
 
-                    fit_score = fitness(y_train, train_model[get_preds()], best_div_score, train_model[get_acc()])
+                    fit_score = fitness(y_train, train_model[get_preds_softmax()], best_div_score, train_model[get_acc()])
 
                     print('\nActivations: ', final_activations)
                     print(f'Train Accuracy:', train_model[get_acc()])
@@ -310,14 +310,14 @@ def learner(x_train, y_train, optimizer, fitness, fit_start=True, gen=None, batc
                     # Display final visualizations
                     display_visualizations_for_learner(viz_objects, best_weight, data, best_acc, 
                                               fit_score, y_train, interval)
-                    return best_weight, best_model[get_preds()], best_acc, final_activations
+                    return best_weight, best_model[get_preds_softmax()], best_acc, final_activations
 
             progress.update(1)
 
         if batch_size != 1:
             train_model = evaluate(x_train, y_train, best_weight, final_activations)
  
-            fit_score = fitness(y_train, train_model[get_preds()], best_div_score, train_model[get_acc()])
+            fit_score = fitness(y_train, train_model[get_preds_softmax()], best_div_score, train_model[get_acc()])
 
             print('\nActivations: ', final_activations)
             print(f'Train Accuracy:', train_model[get_acc()])
@@ -345,7 +345,7 @@ def learner(x_train, y_train, optimizer, fitness, fit_start=True, gen=None, batc
                 train_model = evaluate(x_train, y_train, W=best_weight, 
                                     activation_potentiation=final_activations)
                 
-                fit_score = fitness(y_train, train_model[get_preds()], best_div_score, train_model[get_acc()])
+                fit_score = fitness(y_train, train_model[get_preds_softmax()], best_div_score, train_model[get_acc()])
 
                 print('\nActivations: ', final_activations)
                 print(f'Train Accuracy:', train_model[get_acc()])
@@ -354,14 +354,14 @@ def learner(x_train, y_train, optimizer, fitness, fit_start=True, gen=None, batc
                 # Display final visualizations
                 display_visualizations_for_learner(viz_objects, best_weight, data, best_acc, 
                                           fit_score, y_train, interval)
-                return best_weight, best_model[get_preds()], best_acc, final_activations
+                return best_weight, best_model[get_preds_softmax()], best_acc, final_activations
 
     # Final evaluation
     progress.close()
     train_model = evaluate(x_train, y_train, W=best_weight, 
                         activation_potentiation=final_activations)
 
-    fit_score = fitness(y_train, train_model[get_preds()], best_div_score, train_model[get_acc()])
+    fit_score = fitness(y_train, train_model[get_preds_softmax()], best_div_score, train_model[get_acc()])
 
     print('\nActivations: ', final_activations)
     print(f'Train Accuracy:', train_model[get_acc()])
@@ -369,7 +369,7 @@ def learner(x_train, y_train, optimizer, fitness, fit_start=True, gen=None, batc
 
     # Display final visualizations
     display_visualizations_for_learner(viz_objects, best_weight, data, best_acc, fit_score, y_train, interval)
-    return best_weight, best_model[get_preds()], best_acc, final_activations
+    return best_weight, best_model[get_preds_softmax()], best_acc, final_activations
 
 
 def evaluate(
@@ -400,4 +400,4 @@ def evaluate(
     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
+    return W, result, accuracy, None, None, softmax_preds

pyerualjetwork/plan_cuda.py

@@ -220,7 +220,7 @@ def learner(x_train, y_train, optimizer, fitness, fit_start=True, gen=None, batc
         div_score = diversity_score(weight_pop)
 
     else:
-        weight_pop = [0] * pop_size
+        weight_pop = [cp.random.uniform(-1, 1, (len(y_train[0]), x_train[0].shape[0])) for _ in range(pop_size)]
         act_pop = [0] * pop_size
 
     if start_this_act is not None and start_this_W is not None:
@@ -254,8 +254,8 @@ def learner(x_train, y_train, optimizer, fitness, fit_start=True, gen=None, batc
             model = evaluate(x_train_batch, y_train_batch, W=weight_pop[j], activation_potentiation=act_pop[j])
             acc = model[get_acc()]
  
-            fit_score = fitness(y_train_batch, model[get_preds()], div_score[j], acc)
-
+            fit_score = fitness(y_train_batch, model[get_preds_softmax()], div_score[j], acc)
+            
             target_pop.append(fit_score)
 
             if fit_score >= best_fit:
@@ -309,7 +309,7 @@ def learner(x_train, y_train, optimizer, fitness, fit_start=True, gen=None, batc
                     train_model = evaluate(x_train, y_train, W=best_weight, 
                                         activation_potentiation=final_activations)
 
-                    fit_score = fitness(y_train, train_model[get_preds()], best_div_score, train_model[get_acc()])
+                    fit_score = fitness(y_train, train_model[get_preds_softmax()], best_div_score, train_model[get_acc()])
 
                     print('\nActivations: ', final_activations)
                     print(f'Train Accuracy:', train_model[get_acc()])
@@ -317,14 +317,14 @@ def learner(x_train, y_train, optimizer, fitness, fit_start=True, gen=None, batc
                     
                     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
+                    return best_weight, best_model[get_preds_softmax()], best_acc, final_activations
 
             progress.update(1)
         
         if batch_size != 1:
             train_model = evaluate(x_train, y_train, best_weight, final_activations)
 
-            fit_score = fitness(y_train, train_model[get_preds()], best_div_score, train_model[get_acc()])
+            fit_score = fitness(y_train, train_model[get_preds_softmax()], best_div_score, train_model[get_acc()])
 
             print('\nActivations: ', final_activations)
             print(f'Train Accuracy:', train_model[get_acc()])
@@ -352,7 +352,7 @@ def learner(x_train, y_train, optimizer, fitness, fit_start=True, gen=None, batc
                 train_model = evaluate(x_train, y_train, W=best_weight, 
                                     activation_potentiation=final_activations)
 
-                fit_score = fitness(y_train, train_model[get_preds()], best_div_score, train_model[get_acc()])
+                fit_score = fitness(y_train, train_model[get_preds_softmax()], best_div_score, train_model[get_acc()])
 
                 print('\nActivations: ', final_activations)
                 print(f'Train Accuracy:', train_model[get_acc()])
@@ -361,14 +361,14 @@ def learner(x_train, y_train, optimizer, fitness, fit_start=True, gen=None, batc
                 # Display final visualizations
                 display_visualizations_for_learner(viz_objects, best_weight, data, best_acc, 
                                           fit_score, y_train, interval)
-                return best_weight, best_model[get_preds()], best_acc, final_activations
+                return best_weight, best_model[get_preds_softmax()], best_acc, final_activations
 
     # Final evaluation
     progress.close()
     train_model = evaluate(x_train, y_train, W=best_weight,
                         activation_potentiation=final_activations)
 
-    fit_score = fitness(y_train, train_model[get_preds()], best_div_score, train_model[get_acc()])
+    fit_score = fitness(y_train, train_model[get_preds_softmax()], best_div_score, train_model[get_acc()])
 
     print('\nActivations: ', final_activations)
     print(f'Train Accuracy:', train_model[get_acc()])
@@ -376,7 +376,7 @@ def learner(x_train, y_train, optimizer, fitness, fit_start=True, gen=None, batc
 
     # Display final visualizations
     display_visualizations_for_learner(viz_objects, best_weight, data, best_acc, fit_score, y_train, interval)
-    return best_weight, best_model[get_preds()], best_acc, final_activations
+    return best_weight, best_model[get_preds_softmax()], best_acc, final_activations
 
 def evaluate(
     x_test,

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

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

@@ -1,24 +1,24 @@
-pyerualjetwork/__init__.py,sha256=PeTvh1FsdWQz17kIzq4JB4kuMWgHJ4NpNKMHQcOwPAk,642
+pyerualjetwork/__init__.py,sha256=DRF05WRIM4ITdnKZ98dzqV5ZrU9gDodseJHR7XZRSVk,642
 pyerualjetwork/activation_functions.py,sha256=bKf00lsuuLJNO-4vVp4OqBi4zJ-qZ8L3v-vl52notkY,7721
 pyerualjetwork/activation_functions_cuda.py,sha256=5y1Ti3GDfDteQDCUmODwe7tAyDAUlDTKmIikChQ8d6g,7772
 pyerualjetwork/data_operations.py,sha256=Flteouu6rfSo2uHMqBHuzO02dXmbNa-I5qWmUpGTZ5Y,14760
 pyerualjetwork/data_operations_cuda.py,sha256=ZcjmLXE1-HVwedextYdJZ1rgrns1OfSekzFpr1a9m6o,17625
-pyerualjetwork/fitness_functions.py,sha256=kewx8yMtQFUO-9rjCD3n5z26X2vLeDsb0HPTIdizFF0,4084
-pyerualjetwork/fitness_functions_cuda.py,sha256=ouUh8hhEvEcATBuKg2gOBuqEOyJoygHORC851OUZrO8,4360
+pyerualjetwork/fitness_functions.py,sha256=h-eigMH1n7vw2C53PAUGJFvUxtC_sVrFkGYH1zMcEmw,2698
+pyerualjetwork/fitness_functions_cuda.py,sha256=nncxtoTjF-_UBmACeiohUot5x-sUpsZpTuobFz6Jd4s,2640
 pyerualjetwork/help.py,sha256=nQ_YbYA2RtuafhuvkreNpX0WWL1I_nzlelwCtvei0_Y,775
 pyerualjetwork/memory_operations.py,sha256=I7QiZ--xSyRkFF0wcckPwZV7K9emEvyx5aJ3DiRHZFI,13468
 pyerualjetwork/metrics.py,sha256=q7MkhnZDRbCjFBDDfUgrl8lBYnUT_1ro1LxeBq105pI,6077
 pyerualjetwork/metrics_cuda.py,sha256=73h9GC7XwmnFCVzFEEiPQfF8CwHIz2wsCbxpZrJtYgw,5061
 pyerualjetwork/model_operations.py,sha256=MCSCNYiiICRVZITobtS3ZIWmH5Q9gjyELuH32sAdgg4,12649
 pyerualjetwork/model_operations_cuda.py,sha256=NT01BK5nrDYE7H1x3KnSI8gmx0QTGGB0mP_LqEb1uuU,13157
-pyerualjetwork/plan.py,sha256=DWWrvE9sLxx0xBQ2JbmFmetWuPRC92hmxI0OL6aIEuA,20341
-pyerualjetwork/plan_cuda.py,sha256=mF6ukdUc7uSdAHEiNQAQIEMebFRR7tUXtePq3IqeEpw,20858
+pyerualjetwork/plan.py,sha256=Bxx4EYlVxVzsdtDCBoy_f_IE0LhrP7GILqyesRQ6x48,20486
+pyerualjetwork/plan_cuda.py,sha256=K46cayXRowNFuLv_qkmcZIipT-nWn4yZ-UOinODD1iY,21011
 pyerualjetwork/planeat.py,sha256=QyfPW5k0rvVnowtymI3LXLKp39y69M5DIyNBAeKIhRQ,37568
 pyerualjetwork/planeat_cuda.py,sha256=zzsEu612Ren5K8YyvIn00RjYBG9Z6AOikiReGAPrBbg,37624
 pyerualjetwork/ui.py,sha256=wu2BhU1k-w3Kcho5Jtq4SEKe68ftaUeRGneUOSCVDjU,575
 pyerualjetwork/visualizations.py,sha256=6uY9U4qGOlG4aIhGdAFcTm2Z5m9Hxww4tAAG61_Vqb8,28294
 pyerualjetwork/visualizations_cuda.py,sha256=o6MyZUVz040lmdI2kGlOEU2IoxvyWJPhSOKe9vkLMvY,28753
-pyerualjetwork-4.3.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-4.3.10b2.dist-info/METADATA,sha256=Fv7c0vWkKDf6rzg4rK30PaUmT1B2MOvJZrpdqGHc5lA,7499
+pyerualjetwork-4.3.10b2.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
+pyerualjetwork-4.3.10b2.dist-info/top_level.txt,sha256=BRyt62U_r3ZmJpj-wXNOoA345Bzamrj6RbaWsyW4tRg,15
+pyerualjetwork-4.3.10b2.dist-info/RECORD,,