pyerualjetwork 5.54a3__py3-none-any.whl → 5.55__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.54a3"
+__version__ = "5.55"
 __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

pyerualjetwork/nn.py

@@ -23,7 +23,7 @@ Currently, 3 types of models can be trained:
     PTNN (Potentiation Transfer Neural Network) -- With non-bias
         * Training Time for Small Projects: fast
         * Training Time for Big Projects: fast
-        * Explainability: low
+        * Explainability: medium
         * Learning Capacity: high
 
 Read learn function docstring for know how to use of these model architectures.
@@ -100,7 +100,7 @@ def plan_fit(
     
     from .cpu.data_ops import normalization
     if not cuda:
-        from cpu.activation_functions import apply_activation
+        from .cpu.activation_functions import apply_activation
         array_type = np
 
     else:
@@ -127,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=[], parallel_training=True, 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.
 
@@ -193,8 +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 ? (automaticly selects maximum thread count of your system) Default = True.
+    :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]].
@@ -364,30 +368,56 @@ def learn(x_train, y_train, optimizer, gen, pop_size, fit_start=True, batch_size
 
         if parallel_training:
 
-            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)
-            ]
+            eval_params = []
+            fit_params = []
 
-            with Pool(processes=cpu_count()) as pool:
-                models = pool.starmap(evaluate, params)
+            with Pool(processes=thread_count) as pool:
 
-            target_pop = []
-            losses = []
+                batches = pool.starmap(batcher, [(x_train, y_train)] * pop_size)
 
-            for f in range(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)
+                ]
 
-                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)
+                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(models[f][get_acc()], train_loss, acc_impact, loss_impact)
-                target_pop.append(fitness if not cuda else fitness.get())
+                    if start_this_act is not None and i == 0:
+                        w_copy = copy.deepcopy(weight_pop[0])
+
+                    W = pool.starmap(plan_fit, fit_params)
+                    new_weights = W
+
+                    eval_params = [
+                        (*ep[:4], w, *ep[5:])
+                        for ep, w in zip(eval_params, new_weights)
+                    ]
+                    
+                    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]
             
             best_idx = np.argmax(target_pop)
             best_fitness = target_pop[best_idx]
@@ -395,25 +425,26 @@ def learn(x_train, y_train, optimizer, gen, pop_size, fit_start=True, batch_size
             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]
+            x_train_batch = eval_params[best_idx][0]
+            y_train_batch = eval_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]
+            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(params[best_idx][5])
+                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
 
-            losses = []
-
             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 show_current_activations:
+                print(f", Current Activations={final_activations}", end='')
+
             progress.update(1)
 
         else:
@@ -474,27 +505,6 @@ def learn(x_train, y_train, optimizer, gen, pop_size, fit_start=True, batch_size
                     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()
@@ -563,9 +573,31 @@ def learn(x_train, y_train, optimizer, gen, pop_size, fit_start=True, batch_size
                         
                         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:
                 fig, ax = create_decision_boundary_hist()
@@ -576,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.54a3.dist-info → pyerualjetwork-5.55.dist-info}/METADATA

@@ -1,7 +1,7 @@
 Metadata-Version: 2.1
 Name: pyerualjetwork
-Version: 5.54a3
-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.
+Version: 5.55
+Summary: PyereualJetwork is a GPU-accelerated + Parallel Threading Supported 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
 Keywords: model evaluation,classification,potentiation learning artificial neural networks,NEAT,genetic algorithms,reinforcement learning,neural networks
@@ -61,7 +61,7 @@ YouTube Tutorials: https://www.youtube.com/watch?v=6wMQstZ00is&list=PLNgNWpM7Hbs
 
 ABOUT PYERUALJETWORK:
 
-PyereualJetwork is a large wide GPU-accelerated machine learning library in Python designed for professionals and researchers.
+PyereualJetwork is a large wide GPU-accelerated + Parallel Threading Supported machine learning library in Python designed for professionals and researchers.
 It features PLAN, MLP Deep Learning and PTNN training, as well as ENE (Eugenic NeuroEvolution) for genetic optimization, 
 which can also be applied to genetic algorithms or Reinforcement Learning (RL) problems. 
 The library includes functions for data pre-processing, visualizations, model saving and loading, prediction and evaluation, 

{pyerualjetwork-5.54a3.dist-info → pyerualjetwork-5.55.dist-info}/RECORD

@@ -1,11 +1,11 @@
-pyerualjetwork/__init__.py,sha256=Gv-8lneUjDVXHkLdr_smpUGKZm1XSJ0EhtW0wP2pEt0,3089
+pyerualjetwork/__init__.py,sha256=j2PJ8ap2XNId9eE4qknm8J4A7HrmCfw_r499HGMYSI4,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=CYo-OSguY6dL0sLVqIgjttPvsy55lbevkXVm7Ob_QJQ,39850
+pyerualjetwork/nn.py,sha256=nA26datlq7QMPm9BgpneivLlV2xHKzAMK4toYZeBChA,41409
 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.54a3.dist-info/METADATA,sha256=bHZcQy38LNOHavcBVwtmFkJLQ8DgMirHtmVlguBOTFI,7990
-pyerualjetwork-5.54a3.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
-pyerualjetwork-5.54a3.dist-info/top_level.txt,sha256=BRyt62U_r3ZmJpj-wXNOoA345Bzamrj6RbaWsyW4tRg,15
-pyerualjetwork-5.54a3.dist-info/RECORD,,
+pyerualjetwork-5.55.dist-info/METADATA,sha256=Y_ya6IN7QEh2EAPa34LalZccl-Gsiesh2JK-p3V28WE,8050
+pyerualjetwork-5.55.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
+pyerualjetwork-5.55.dist-info/top_level.txt,sha256=BRyt62U_r3ZmJpj-wXNOoA345Bzamrj6RbaWsyW4tRg,15
+pyerualjetwork-5.55.dist-info/RECORD,,