pyerualjetwork 5.52__py3-none-any.whl → 5.54__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.54"
 __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,12 +127,13 @@ 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=False, 
+           thread_count=cpu_count(), 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.
 
-    Why genetic optimization ENE(Eugenic NeuroEvolution) and not backpropagation?
+    Why genetic optimization FBN(Fitness Biased NeuroEvolution) and not backpropagation?
     Because PLAN is different from other neural network architectures. In PLAN, the learnable parameters are not the weights; instead, the learnable parameters are the activation functions.
     Since activation functions are not differentiable, we cannot use gradient descent or backpropagation. However, I developed a more powerful genetic optimization algorithm: ENE.
 
@@ -191,7 +194,11 @@ 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 ? Default = False. 
+        - Recommended for large populations (pop_size) to significantly speed up training.
+    :param thread_count: (int, optional): If parallel_training is True you can give max thread number for parallel training. Default: (automaticly selects maximum thread count of your system).
     :param cuda: (bool, optional): CUDA GPU acceleration ? Default = False.
+        - Recommended for large neural net architectures or big datasets to significantly speed up training.
 
     Returns:
         tuple: A list for model parameters: [Weight matrix, Train Preds, Train Accuracy, [Activations functions]].
@@ -359,156 +366,240 @@ 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
+            eval_params = []
+            fit_params = []
 
+            with Pool(processes=thread_count) as pool:
 
-            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)
+                batches = pool.starmap(batcher, [(x_train, y_train)] * pop_size)
 
+                eval_params = [
+                    (
+                        x_b, y_b, None, model_type, weight_pop[j], act_pop[j],
+                        activation_potentiations[j], auto_normalization, None, cuda
+                    )
+                    for j, (x_b, y_b) in enumerate(batches)
+                ]
 
-            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()])
+                if (model_type == 'PLAN' and weight_evolve is False) or (model_type == 'PLAN' and fit_start is True and i == 0):
+                    fit_params = [
+                        (x_b, y_b, act_pop[j], weight_pop[j], auto_normalization, cuda, dtype)
+                        for j, (x_b, y_b) in enumerate(batches)
+                    ]
 
-            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 start_this_act is not None and i == 0:
+                        w_copy = copy.deepcopy(weight_pop[0])
 
-                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)
+                    W = pool.starmap(plan_fit, fit_params)
+                    new_weights = W
 
-                    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)
+                    eval_params = [
+                        (*ep[:4], w, *ep[5:])
+                        for ep, w in zip(eval_params, new_weights)
+                    ]
                     
-                    return model
+                    if start_this_act is not None and i == 0:
+                        eval_params[0] = (
+                            eval_params[0][0], eval_params[0][1], eval_params[0][2], eval_params[0][3],
+                            w_copy, eval_params[0][5], eval_params[0][6], eval_params[0][7],
+                            eval_params[0][8], eval_params[0][9]
+                        )
+
+                models = pool.starmap(evaluate, eval_params)
+
+                y_preds = [model[get_preds_softmax()] for model in models]
+                loss_params = [(eval_params[f][1], y_preds[f]) for f in range(pop_size)]
+                loss_func = categorical_crossentropy if loss == 'categorical_crossentropy' else binary_crossentropy
+                losses = pool.starmap(loss_func, loss_params)
+                fitness_params = [(models[f][get_acc()], losses[f], acc_impact, loss_impact) for f in range(pop_size)]
+                target_pop = pool.starmap(wals, fitness_params)
+
+                if cuda:
+                    target_pop = [fit.get() for fit in target_pop]
             
-                # 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()])
+            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 = eval_params[best_idx][0]
+            y_train_batch = eval_params[best_idx][1]
+
+            if isinstance(eval_params[best_idx][5], list) and model_type == 'PLAN':
+                final_activations = eval_params[best_idx][5].copy()
+            elif isinstance(eval_params[best_idx][5], str):
+                final_activations = eval_params[best_idx][5]
+            else:
+                final_activations = copy.deepcopy(eval_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
 
-                    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 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)
 
-                    if decision_boundary_history: display_decision_boundary_history(fig, artist, interval=interval)
+            if show_current_activations:
+                print(f", Current Activations={final_activations}", end='')
 
-                    # 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)
 
+        else:
+
+            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='')
+
+                    # 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)
+
+        # 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)
+
 
         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)
@@ -517,7 +608,7 @@ def learn(x_train, y_train, optimizer, gen, pop_size, fit_start=True, batch_size
             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, 
+                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, 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyerualjetwork
-Version: 5.52
+Version: 5.54
 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.54.dist-info}/RECORD

@@ -1,11 +1,11 @@
-pyerualjetwork/__init__.py,sha256=93JmJyIRyPAJBuagvrhiQ_h1HA33WUreKf1yODb71ro,3020
+pyerualjetwork/__init__.py,sha256=ZiTcxYl47_8ru1CJcJTjK9izr4zpY-u4bSMVnuEZTwY,3087
 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=WSolklnr3Rx4WadCDqo59IPFOpjdmZVjF9zHlgv-SXg,41405
 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.54.dist-info/METADATA,sha256=HI6CKiT5d1urRW8Y_hIt2G4EajdUTq_6AaTaB1B4Z3A,7988
+pyerualjetwork-5.54.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
+pyerualjetwork-5.54.dist-info/top_level.txt,sha256=BRyt62U_r3ZmJpj-wXNOoA345Bzamrj6RbaWsyW4tRg,15
+pyerualjetwork-5.54.dist-info/RECORD,,