pyerualjetwork 5.52__py3-none-any.whl → 5.54a0__py3-none-any.whl

pyerualjetwork/__init__.py

@@ -42,7 +42,7 @@ PyerualJetwork document: https://github.com/HCB06/PyerualJetwork/blob/main/Welco
 - Contact: tchasancan@gmail.com
 """
 
-__version__ = "5.52"
+__version__ = "5.54a0"
 __update__ = """* Changes: https://github.com/HCB06/PyerualJetwork/blob/main/CHANGES
 * PyerualJetwork Homepage: https://github.com/HCB06/PyerualJetwork/tree/main
 * PyerualJetwork document: https://github.com/HCB06/PyerualJetwork/blob/main/Welcome_to_PyerualJetwork/PYERUALJETWORK_USER_MANUEL_AND_LEGAL_INFORMATION(EN).pdf
@@ -54,8 +54,11 @@ def print_version(version):
 def print_update_notes(update):
     print(f"Notes:\n{update}")
 
-print_version(__version__)
-print_update_notes(__update__)
+#print_version(__version__)
+#print_update_notes(__update__)
+
+import warnings
+warnings.filterwarnings('ignore')
 
 required_modules = ["scipy", "tqdm", "pandas", "networkx", "seaborn", "numpy", "matplotlib", "colorama", "cupy", "psutil"]
 
@@ -71,7 +74,7 @@ if missing_modules:
     f"Missing modules detected: {', '.join(missing_modules)}\n"
     "Please run the following command to install the missing packages:\n\n"
     f"    pip install {' '.join(missing_modules)}\n\n"
-    "NOTE: needed numpy version --> numpy==1.26.4 and if you have cuda toolkit version 12 you need to install with pip --> pip install cupy-cuda12x. If you have not cuda gpu or toolkit and you want a CPU training doesnt matter. You need to install random cupy version. This is NECESSARY module."
+    "NOTE: needed numpy version --> numpy==1.26.4 and if you have cuda toolkit version 12 you need to install with pip --> pip install cupy-cuda12x. If you have not cuda gpu or toolkit and you want to use a CPU for training doesnt matter. You need to install random cupy version. This is NECESSARY module."
     "For more information, visit the PyerualJetwork GitHub README.md file:\n"
     "https://github.com/HCB06/PyerualJetwork/blob/main/README.md"
 

pyerualjetwork/nn.py

@@ -51,6 +51,8 @@ import numpy as np
 import cupy as cp
 import copy
 import random
+import multiprocessing
+from multiprocessing import Pool, cpu_count
 
 ### LIBRARY IMPORTS ###
 from .ui import loading_bars, initialize_loading_bar
@@ -125,7 +127,7 @@ def learn(x_train, y_train, optimizer, gen, pop_size, fit_start=True, batch_size
            weight_evolve=True, neural_web_history=False, show_current_activations=False, auto_normalization=False,
            neurons_history=False, early_stop=False, show_history=False, target_loss=None,
            interval=33.33, target_acc=None, loss='categorical_crossentropy', acc_impact=0.9, loss_impact=0.1,
-           start_this_act=None, start_this_W=None, neurons=[], activation_functions=[], decision_boundary_history=False, cuda=False, dtype=np.float32):
+           start_this_act=None, start_this_W=None, neurons=[], activation_functions=[], parallel_training=True, decision_boundary_history=False, cuda=False, dtype=np.float32):
     """
     Optimizes the activation functions for a neural network by leveraging train data to find 
     the most accurate combination of activation potentiation(or activation function) & weight values for the labeled classificaiton dataset.
@@ -191,6 +193,7 @@ def learn(x_train, y_train, optimizer, gen, pop_size, fit_start=True, batch_size
     :param decision_boundary_history: (bool, optional): At the end of the training, the decision boundary history is shown in animation form. Note: If you are sure of your memory, set it to True. Default: False
     :param activation_functions: (list[str], optional): If you dont want train PLAN model this parameter represents activation function of each hidden layer for MLP or PTNN. if neurons is not [] --> uses default: ['linear'] * len(neurons). if neurons is [] --> uses [].
     :param dtype: (numpy.dtype): Data type for the Weight matrices. np.float32 by default. Example: np.float64 or np.float16.
+    :param parallel_training: (bool, optional): Parallel training process ? (automaticly selects maximum thread count of your system) Default = True.
     :param cuda: (bool, optional): CUDA GPU acceleration ? Default = False.
 
     Returns:
@@ -221,6 +224,9 @@ def learn(x_train, y_train, optimizer, gen, pop_size, fit_start=True, batch_size
         initialize_visualization_for_learner,
         update_neuron_history_for_learner)
         
+
+    if parallel_training: multiprocessing.set_start_method('spawn', force=True)
+
     data = 'Train'
 
     template_model = get_model_template()
@@ -359,156 +365,212 @@ def learn(x_train, y_train, optimizer, gen, pop_size, fit_start=True, batch_size
         progress.last_print_n = 0
         progress.update(0)
 
-        for j in range(pop_size):
-            
-            x_train_batch, y_train_batch = batcher(x_train, y_train, batch_size=batch_size)
+        if parallel_training:
 
-            if fit_start is True and i == 0:
-                if start_this_act is not None and j == 0:
-                    pass
-                else:
-           
-                    act_pop[j] = activations[j]
-                    W = plan_fit(x_train_batch, y_train_batch, activations=act_pop[j], cuda=cuda, auto_normalization=auto_normalization, dtype=dtype)
-                    weight_pop[j] = W
+            params = [
+            (*batcher(x_train, y_train), None, model_type, weight_pop[j], act_pop[j], activation_potentiations[j], auto_normalization, None, cuda)
+            for j in range(pop_size)
+            ]
+
+            with Pool(processes=cpu_count()) as pool:
+                models = pool.map(evaluate, params)
 
+            target_pop = []
+            losses = []
 
-            if weight_evolve is False:
-                weight_pop[j] = plan_fit(x_train_batch, y_train_batch, activations=act_pop[j], cuda=cuda, auto_normalization=auto_normalization, dtype=dtype)
+            for f in range(pop_size):
 
+                if loss == 'categorical_crossentropy':
+                    train_loss = categorical_crossentropy(y_true_batch=params[f][1], 
+                                                            y_pred_batch=models[f][get_preds_softmax()])
+                else:
+                    train_loss = binary_crossentropy(y_true_batch=params[f][1], 
+                                                            y_pred_batch=models[f][get_preds_softmax()])
+                
+                losses.append(train_loss)
 
-            model = evaluate(x_train_batch, y_train_batch, W=weight_pop[j], activations=act_pop[j], activation_potentiations=activation_potentiations[j], auto_normalization=auto_normalization, cuda=cuda, model_type=model_type)
-            acc = model[get_acc()]
+                fitness = wals(models[f][get_acc()], train_loss, acc_impact, loss_impact)
+                target_pop.append(fitness if not cuda else fitness.get())
             
-            if loss == 'categorical_crossentropy':
-                train_loss = categorical_crossentropy(y_true_batch=y_train_batch, 
-                                                           y_pred_batch=model[get_preds_softmax()])
+            best_idx = np.argmax(target_pop)
+            best_fitness = target_pop[best_idx]
+            best_weight = models[best_idx][0]
+            best_loss = losses[best_idx]
+            best_acc = models[best_idx][get_acc()]
+
+            x_train_batch = params[best_idx][0]
+            y_train_batch = params[best_idx][1]
+
+            if isinstance(params[best_idx][5], list) and model_type == 'PLAN':
+                final_activations = params[best_idx][5].copy()
+            elif isinstance(params[best_idx][5], str):
+                final_activations = params[best_idx][5]
             else:
-                train_loss = binary_crossentropy(y_true_batch=y_train_batch, 
-                                            y_pred_batch=model[get_preds_softmax()])
+                final_activations = copy.deepcopy(params[best_idx][5])
+                
+            if model_type == 'PLAN': final_activations = [final_activations[0]] if len(set(final_activations)) == 1 else final_activations # removing if all same
 
-            fitness = wals(acc, train_loss, acc_impact, loss_impact)
-            target_pop.append(fitness if not cuda else fitness.get())
-            
-            if fitness >= best_fitness:
-
-                best_fitness = fitness
-                best_acc = acc
-                best_loss = train_loss
-                best_weight = np.copy(weight_pop[j]) if model_type == 'PLAN' else copy.deepcopy(weight_pop[j])
-                best_model = model
-
-                if isinstance(act_pop[j], list) and model_type == 'PLAN':
-                    final_activations = act_pop[j].copy()
-                elif isinstance(act_pop[j], str):
-                    final_activations = act_pop[j]
-                else:
-                    final_activations = copy.deepcopy(act_pop[j])
-                    
-                if model_type == 'PLAN': final_activations = [final_activations[0]] if len(set(final_activations)) == 1 else final_activations # removing if all same
-
-                if batch_size == 1:
-                    postfix_dict[f"{data} Accuracy"] = format_number(best_acc)
-                    postfix_dict[f"{data} Loss"] = format_number(train_loss)
-                    progress.set_postfix(postfix_dict)
-
-                if show_current_activations:
-                    print(f", Current Activations={final_activations}", end='')
-
-                # 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], 
-                                      best_acc_per_gen_list + [best_acc], x_train, final_activations)
-
-                if neurons_history:
-                    viz_objects['neurons']['artists'] = (
-                        update_neuron_history_for_learner(np.copy(best_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)
-                    )
-
-                if neural_web_history:
-                    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)
-
-                # 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_weight, 
-                                        activations=final_activations, activation_potentiations=activation_potentiation, auto_normalization=auto_normalization, cuda=cuda, model_type=model_type)
-                    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('Activation Potentiation: ', activation_potentiation)
-                    print('Train Accuracy:', train_model[get_acc()])
-                    print('Train Loss: ', train_loss, '\n')
-                    print('Model Type:', model_type)
-                    
-                    if decision_boundary_history: display_decision_boundary_history(fig, artist, interval=interval)
+            losses = []
 
-                    display_visualizations_for_learner(viz_objects, best_weight, data, best_acc, 
-                                              best_loss, y_train, interval)
-                    
-                    model = template_model._replace(weights=best_weight,
-                                           predictions=best_model[get_preds()],
-                                           accuracy=best_acc,
-                                           activations=final_activations,
-                                           softmax_predictions=best_model[get_preds_softmax()],
-                                           model_type=model_type,
-                                           activation_potentiation=activation_potentiation)
-                    
-                    return model
-            
-                # Check target loss
-                if target_loss is not None and best_loss <= target_loss:
-                    progress.close()
-                    train_model = evaluate(x_train, y_train, W=best_weight,
-                                        activations=final_activations, activation_potentiations=activation_potentiation, auto_normalization=auto_normalization, cuda=cuda, model_type=model_type)
-
-                    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()])
+            if batch_size == 1:
+                postfix_dict[f"{data} Accuracy"] = format_number(best_acc)
+                postfix_dict[f"{data} Loss"] = format_number(best_loss)
+                progress.set_postfix(postfix_dict)
 
-                    print('\nActivations: ', final_activations)
-                    print('Activation Potentiation: ', activation_potentiation)
-                    print('Train Accuracy:', train_model[get_acc()])
-                    print('Train Loss: ', train_loss, '\n')
-                    print('Model Type:', model_type)
+            progress.update(1)
 
-                    if decision_boundary_history: display_decision_boundary_history(fig, artist, interval=interval)
+        else:
 
-                    # Display final visualizations
-                    display_visualizations_for_learner(viz_objects, best_weight, data, best_acc, 
-                                              train_loss, y_train, interval)
-                    
-                    model = template_model._replace(weights=best_weight,
-                                           predictions=best_model[get_preds()],
-                                           accuracy=best_acc,
-                                           activations=final_activations,
-                                           softmax_predictions=best_model[get_preds_softmax()],
-                                           model_type=model_type,
-                                           activation_potentiation=activation_potentiation)
-                    
-                    return model
+            for j in range(pop_size):
+                
+                x_train_batch, y_train_batch = batcher(x_train, y_train, batch_size=batch_size)
 
+                if fit_start is True and i == 0:
+                    if start_this_act is not None and j == 0:
+                        pass
+                    else:
             
-            progress.update(1)
+                        act_pop[j] = activations[j]
+                        W = plan_fit(x_train_batch, y_train_batch, activations=act_pop[j], cuda=cuda, auto_normalization=auto_normalization, dtype=dtype)
+                        weight_pop[j] = W
+
+
+                if weight_evolve is False:
+                    weight_pop[j] = plan_fit(x_train_batch, y_train_batch, activations=act_pop[j], cuda=cuda, auto_normalization=auto_normalization, dtype=dtype)
+
+
+                model = evaluate(x_train_batch, y_train_batch, W=weight_pop[j], activations=act_pop[j], activation_potentiations=activation_potentiations[j], auto_normalization=auto_normalization, cuda=cuda, model_type=model_type)
+                acc = model[get_acc()]
+                
+                if loss == 'categorical_crossentropy':
+                    train_loss = categorical_crossentropy(y_true_batch=y_train_batch, 
+                                                            y_pred_batch=model[get_preds_softmax()])
+                else:
+                    train_loss = binary_crossentropy(y_true_batch=y_train_batch, 
+                                                y_pred_batch=model[get_preds_softmax()])
+
+                fitness = wals(acc, train_loss, acc_impact, loss_impact)
+                target_pop.append(fitness if not cuda else fitness.get())
+                
+                if fitness >= best_fitness:
+
+                    best_fitness = fitness
+                    best_acc = acc
+                    best_loss = train_loss
+                    best_weight = np.copy(weight_pop[j]) if model_type == 'PLAN' else copy.deepcopy(weight_pop[j])
+                    best_model = model
+
+                    if isinstance(act_pop[j], list) and model_type == 'PLAN':
+                        final_activations = act_pop[j].copy()
+                    elif isinstance(act_pop[j], str):
+                        final_activations = act_pop[j]
+                    else:
+                        final_activations = copy.deepcopy(act_pop[j])
+                        
+                    if model_type == 'PLAN': final_activations = [final_activations[0]] if len(set(final_activations)) == 1 else final_activations # removing if all same
+
+                    if batch_size == 1:
+                        postfix_dict[f"{data} Accuracy"] = format_number(best_acc)
+                        postfix_dict[f"{data} Loss"] = format_number(train_loss)
+                        progress.set_postfix(postfix_dict)
+
+                    if show_current_activations:
+                        print(f", Current Activations={final_activations}", end='')
+
+                    # 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], 
+                                        best_acc_per_gen_list + [best_acc], x_train, final_activations)
+
+                    if neurons_history:
+                        viz_objects['neurons']['artists'] = (
+                            update_neuron_history_for_learner(np.copy(best_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)
+                        )
+
+                    if neural_web_history:
+                        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)
+
+                    # 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_weight, 
+                                            activations=final_activations, activation_potentiations=activation_potentiation, auto_normalization=auto_normalization, cuda=cuda, model_type=model_type)
+                        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('Activation Potentiation: ', activation_potentiation)
+                        print('Train Accuracy:', train_model[get_acc()])
+                        print('Train Loss: ', train_loss, '\n')
+                        print('Model Type:', model_type)
+                        
+                        if decision_boundary_history: display_decision_boundary_history(fig, artist, interval=interval)
+
+                        display_visualizations_for_learner(viz_objects, best_weight, data, best_acc, 
+                                                best_loss, y_train, interval)
+                        
+                        model = template_model._replace(weights=best_weight,
+                                            predictions=best_model[get_preds()],
+                                            accuracy=best_acc,
+                                            activations=final_activations,
+                                            softmax_predictions=best_model[get_preds_softmax()],
+                                            model_type=model_type,
+                                            activation_potentiation=activation_potentiation)
+                        
+                        return model
+                
+                    # Check target loss
+                    if target_loss is not None and best_loss <= target_loss:
+                        progress.close()
+                        train_model = evaluate(x_train, y_train, W=best_weight,
+                                            activations=final_activations, activation_potentiations=activation_potentiation, auto_normalization=auto_normalization, cuda=cuda, model_type=model_type)
+
+                        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('Activation Potentiation: ', activation_potentiation)
+                        print('Train Accuracy:', train_model[get_acc()])
+                        print('Train Loss: ', train_loss, '\n')
+                        print('Model Type:', model_type)
+
+                        if decision_boundary_history: display_decision_boundary_history(fig, artist, interval=interval)
+
+                        # Display final visualizations
+                        display_visualizations_for_learner(viz_objects, best_weight, data, best_acc, 
+                                                train_loss, y_train, interval)
+                        
+                        model = template_model._replace(weights=best_weight,
+                                            predictions=best_model[get_preds()],
+                                            accuracy=best_acc,
+                                            activations=final_activations,
+                                            softmax_predictions=best_model[get_preds_softmax()],
+                                            model_type=model_type,
+                                            activation_potentiation=activation_potentiation)
+                        
+                        return model
+
+                
+                progress.update(1)
 
         if decision_boundary_history:
-            if i == 0: 
+            if i == 0:
                 fig, ax = create_decision_boundary_hist()
                 artist = []
             artist = plot_decision_boundary(x_train_batch, y_train_batch, activations=act_pop[np.argmax(target_pop)], W=weight_pop[np.argmax(target_pop)], cuda=cuda, model_type=model_type, ax=ax, artist=artist)

{pyerualjetwork-5.52.dist-info → pyerualjetwork-5.54a0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyerualjetwork
-Version: 5.52
+Version: 5.54a0
 Summary: PyereualJetwork is a GPU-accelerated machine learning library in Python for professionals and researchers. It features PLAN, MLP, Deep Learning training, and ENE (Eugenic NeuroEvolution) for genetic optimization, applicable to genetic algorithms or Reinforcement Learning (RL). The library includes data pre-processing, visualizations, model saving/loading, prediction, evaluation, training, and detailed or simplified memory management.
 Author: Hasan Can Beydili
 Author-email: tchasancan@gmail.com

{pyerualjetwork-5.52.dist-info → pyerualjetwork-5.54a0.dist-info}/RECORD

@@ -1,11 +1,11 @@
-pyerualjetwork/__init__.py,sha256=93JmJyIRyPAJBuagvrhiQ_h1HA33WUreKf1yODb71ro,3020
+pyerualjetwork/__init__.py,sha256=N_cbeybjGF-Rkt59eqjxcWNz4Rc7RSSFpkW8UbEcUDk,3089
 pyerualjetwork/ene.py,sha256=luTvspHRTose6s3uRas40pNXyKoxU9siaHiMBNI5yoc,42136
 pyerualjetwork/fitness_functions.py,sha256=D9JVCr9DFid_xXgBD4uCKxdW2k10MVDE5HZRSOK4Igg,1237
 pyerualjetwork/help.py,sha256=sn9jBzXkQsTZvdgsUXUpSs_BbYYIgY3whofg6dj8peI,848
 pyerualjetwork/issue_solver.py,sha256=uay_9XK6xWnLmK2P_BeyDQlyNXzg_zYffnXYd228wZk,4102
 pyerualjetwork/memory_ops.py,sha256=TUFh9SYWCKL6N-vNdWId_EwU313TuZomQCHOrltrD-4,14280
 pyerualjetwork/model_ops.py,sha256=WaP1XwKqXMfZl4Yop8a1Bg0xtmLYgap9JFOWHaLr7S4,25143
-pyerualjetwork/nn.py,sha256=nKOgAE0k9sFKB-r69V1cMwW6-4Yv8z98o9Ys1Cvhpdo,36810
+pyerualjetwork/nn.py,sha256=6MyHMIN5wNBISfGSpQtR1tt-DU_eYK0Iz5M2dWqzgWg,39931
 pyerualjetwork/old_cpu_model_ops.py,sha256=1KNgjUeYCO_TsA5RtbNiuIiBJzq8-rL2dE6jxKqCBU0,21481
 pyerualjetwork/old_cuda_model_ops.py,sha256=KAscAd8e_I8Vqdd9BJaHd6-IG6fhxFglAFxys0sqmEo,23079
 pyerualjetwork/ui.py,sha256=JBTFYz5R24XwNKhA3GSW-oYAoiIBxAE3kFGXkvm5gqw,656
@@ -21,7 +21,7 @@ pyerualjetwork/cuda/data_ops.py,sha256=BEXh4M7BWXaTpYlVS9D2i3CGgOmL5131vy7FZyuTQ
 pyerualjetwork/cuda/loss_functions.py,sha256=C93IZJcrOpT6HMK9x1O4AHJWXYTkN5WZiqdssPbvAPk,617
 pyerualjetwork/cuda/metrics.py,sha256=PjDBoRvr6va8vRvDIJJGBO4-I4uumrk3NCM1Vz4NJTo,5054
 pyerualjetwork/cuda/visualizations.py,sha256=2mHE7iqqsN3K6xtCnemS4o_YWGS0bIV2IxF4cG6Ur9k,20090
-pyerualjetwork-5.52.dist-info/METADATA,sha256=hqIRHmExMs8Umnw2hmYQp-Te87cxJV0IjCHOHcqln6Y,7988
-pyerualjetwork-5.52.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
-pyerualjetwork-5.52.dist-info/top_level.txt,sha256=BRyt62U_r3ZmJpj-wXNOoA345Bzamrj6RbaWsyW4tRg,15
-pyerualjetwork-5.52.dist-info/RECORD,,
+pyerualjetwork-5.54a0.dist-info/METADATA,sha256=LnHR2Ocf8ZSM2mmZj2lbia7tQvPM4bpzafxe5M-Kw10,7990
+pyerualjetwork-5.54a0.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
+pyerualjetwork-5.54a0.dist-info/top_level.txt,sha256=BRyt62U_r3ZmJpj-wXNOoA345Bzamrj6RbaWsyW4tRg,15
+pyerualjetwork-5.54a0.dist-info/RECORD,,