pyerualjetwork 5.37__py3-none-any.whl → 5.40a0__py3-none-any.whl

pyerualjetwork/{cpu/nn.py → nn.py}

@@ -2,9 +2,9 @@
 """ 
 
 
-NN (Neural Networks) on CPU
+NN (Neural Networks)
 ============================
-This module hosts functions for training and evaluating artificial neural networks on CPU for labeled classification tasks.
+This module hosts functions for training and evaluating artificial neural networks for labeled classification tasks.
 
 Currently, 3 types of models can be trained:
 
@@ -48,24 +48,16 @@ PyerualJetwork document: https://github.com/HCB06/PyerualJetwork/blob/main/Welco
 """
 
 import numpy as np
+import cupy as cp
 import copy
 import random
 
 ### LIBRARY IMPORTS ###
-from ..ui import loading_bars, initialize_loading_bar
-from .data_ops import normalization, batcher
-from .activation_functions import apply_activation, all_activations
-from .model_ops import get_acc, get_preds_softmax
-from ..memory_ops import optimize_labels
-from .loss_functions import categorical_crossentropy, binary_crossentropy
-from ..fitness_functions import wals
-from .visualizations import (
-    draw_neural_web,
-    display_visualizations_for_learner,
-    update_history_plots_for_learner,
-    initialize_visualization_for_learner,
-    update_neuron_history_for_learner
-)
+from .ui import loading_bars, initialize_loading_bar
+from .cpu.activation_functions import all_activations
+from .model_ops import get_acc, get_preds_softmax, get_preds
+from .memory_ops import optimize_labels, transfer_to_gpu
+from .fitness_functions import wals
 
 ### GLOBAL VARIABLES ###
 bar_format_normal = loading_bars()[0]
@@ -79,48 +71,62 @@ def plan_fit(
     activations=['linear'],
     W=None,
     auto_normalization=False,
+    cuda=False,
     dtype=np.float32
 ):
     """
     Creates a PLAN model to fitting data.
     
     Args:
-        x_train (aray-like[num]): List or numarray of input data.
+        x_train (aray-like[num or cup]): List or numarray of input data.
 
-        y_train (aray-like[num]): List or numarray of target labels. (one hot encoded)
+        y_train (aray-like[num or cup]): List or numarray of target labels. (one hot encoded)
 
         activations (list): For deeper PLAN networks, activation function parameters. For more information please run this code: neu.activations_list() default: [None] (optional)
 
-        W (numpy.ndarray): If you want to re-continue or update model
+        W (numpy.ndarray or cupy.ndarray): If you want to re-continue or update model
 
         auto_normalization (bool, optional): Normalization may solves overflow problem. Default: False
 
+        cuda (bool, optional): CUDA GPU acceleration ? Default = False.
+        
         dtype (numpy.dtype): Data type for the arrays. np.float32 by default. Example: np.float64 or np.float16.
 
     Returns:
         numpyarray: (Weight matrix).
     """
 
+    if not cuda:
+        from .cpu.data_ops import normalization
+        from .cpu.activation_functions import apply_activation
+        array_type = np
+
+    else:
+        from cuda.data_ops import normalization
+        from cuda.activation_functions import apply_activation
+        array_type = cp
+        
+        
     # Pre-check
 
     if len(x_train) != len(y_train): raise ValueError("x_train and y_train must have the same length.")
 
-    weight = np.zeros((len(y_train[0]), len(x_train[0].ravel()))).astype(dtype, copy=False) if W is None else W
+    weight = array_type.zeros((len(y_train[0]), len(x_train[0].ravel()))).astype(dtype, copy=False) if W is None else W
 
     if auto_normalization is True: x_train = normalization(apply_activation(x_train, activations))
     elif auto_normalization is False: x_train = apply_activation(x_train, activations)
     else: raise ValueError('normalization parameter only be True or False')
-    
-    weight += y_train.T @ x_train
+
+    weight += y_train.T @ x_train if not cuda else cp.array(y_train).T @ cp.array(x_train)
 
     return normalization(weight, dtype=dtype)
 
 
-def learn(x_train, y_train, optimizer, gen, pop_size, fit_start=True, batch_size=1,
+def learn(x_train, y_train, optimizer, template_model, gen, pop_size, fit_start=True, batch_size=1,
            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=[], dtype=np.float32):
+           start_this_act=None, start_this_W=None, neurons=[], activation_functions=[], 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.
@@ -135,18 +141,18 @@ def learn(x_train, y_train, optimizer, gen, pop_size, fit_start=True, batch_size
     Examples:
     
         This creates a PLAN model: 
-            - ```learn(x_train, y_train, optimizer, pop_size=100, gen=100, fit_start=True) ```
+            - ```model = learn(x_train, y_train, optimizer, template_model, pop_size=100, gen=100, fit_start=True) ```
 
         This creates a MLP model(with 2 hidden layer): 
-            - ```learn(x_train, y_train, optimizer, pop_size=100, gen=100, fit_start=False, neurons=[64, 64], activation_functions=['tanh', 'tanh']) ```
+            - ```model = learn(x_train, y_train, optimizer, template_model, pop_size=100, gen=100, fit_start=False, neurons=[64, 64], activation_functions=['tanh', 'tanh']) ```
         
         This creates a PTNN model(with 2 hidden layer & 1 aggregation layer(comes with PLAN)): 
-           -  ```learn(x_train, y_train, optimizer, pop_size=100, gen=[10, 100], fit_start=True, neurons=[64, 64], activation_functions=['tanh', 'tanh']) ```
+           -  ```model = learn(x_train, y_train, optimizer, template_model, pop_size=100, gen=[10, 100], fit_start=True, neurons=[64, 64], activation_functions=['tanh', 'tanh']) ```
     
     :Args:
     :param x_train: (array-like): Training input data.
     :param y_train: (array-like): Labels for training data. one-hot encoded.
-    :param optimizer: (function): Optimization technique with hyperparameters. (PLAN, MLP & PTNN (all) using ENE for optimization. Gradient based technique's will added in the future.) Please use this: from pyerualjetwork.cpu.ene import evolver (and) optimizer = lambda *args, **kwargs: evolver(*args, 'here give your hyperparameters for example:  activation_add_prob=0.85', **kwargs) Example:
+    :param optimizer: (function): Optimization technique with hyperparameters. (PLAN, MLP & PTNN (all) using ENE for optimization. Gradient based technique's will added in the future.) Please use this: from pyerualjetwork.ene import evolver (and) optimizer = lambda *args, **kwargs: evolver(*args, 'here give your hyperparameters for example:  activation_add_prob=0.85', **kwargs) Example:
     ```python
              optimizer = lambda *args, **kwargs: ene.evolver(*args,
                                                             activation_add_prob=0.05,
@@ -163,6 +169,7 @@ def learn(x_train, y_train, optimizer, gen, pop_size, fit_start=True, batch_size
                             batch_size=0.05,
                             interval=16.67)
     ```
+    :param template_model: (tuple): Use --> get_model_template() function in the model_ops module.
     :param fit_start: (bool, optional): If the fit_start parameter is set to True, the initial generation population undergoes a simple short training process using the PLAN algorithm. This allows for a very robust starting point, especially for large and complex datasets. However, for small or relatively simple datasets, it may result in unnecessary computational overhead. When fit_start is True, completing the first generation may take slightly longer (this increase in computational cost applies only to the first generation and does not affect subsequent generations). If fit_start is set to False, the initial population will be entirely random. Additonaly if you want to train PTNN model you must be give True. Options: True or False. Default: True
     :param gen: (int or list): The generation count for genetic optimization. If you want to train PTNN model you must give a list of two number. First number for PLAN model training second number for MLP.
     :param batch_size: (float, optional): Batch size is used in the prediction process to receive train feedback by dividing the train data into chunks and selecting activations based on randomly chosen partitions. This process reduces computational cost and time while still covering the entire train set due to random selection, so it doesn't significantly impact accuracy. For example, a batch size of 0.08 means each train batch represents %8 of the train set. Default is 1. (%100 of train)
@@ -183,29 +190,56 @@ def learn(x_train, y_train, optimizer, gen, pop_size, fit_start=True, batch_size
     :param start_this_act: (list, optional): To resume a previously canceled or interrupted training from where it left off, or to continue from that point with a different strategy, provide the list of activation functions selected up to the learned portion to this parameter. Default is None
     :param start_this_W: (numpy.array, optional): To resume a previously canceled or interrupted training from where it left off, or to continue from that point with a different strategy, provide the weight matrix of this genome. Default is None
     :param neurons: (list[int], optional): If you dont want train PLAN model this parameter represents neuron count of each hidden layer for MLP or PTNN. Number of elements --> Layer count. Default: [] (No hidden layer) --> architecture setted to PLAN, if not --> architecture setted to MLP.
+    :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 cuda: (bool, optional): CUDA GPU acceleration ? Default = False.
 
     Returns:
         tuple: A list for model parameters: [Weight matrix, Train Preds, Train Accuracy, [Activations functions]].
     """
 
     from .ene import define_genomes
-
+    from .cpu.visualizations import display_decision_boundary_history, create_decision_boundary_hist, plot_decision_boundary
+
+    if cuda is False: 
+        from .cpu.data_ops import batcher 
+        from .cpu.loss_functions import categorical_crossentropy, binary_crossentropy
+        from .cpu.visualizations import (
+        draw_neural_web,
+        display_visualizations_for_learner,
+        update_history_plots_for_learner,
+        initialize_visualization_for_learner,
+        update_neuron_history_for_learner)
+    
+    else: 
+        from cuda.data_ops import batcher
+        from cuda.loss_functions import categorical_crossentropy, binary_crossentropy
+        from cuda.visualizations import (
+        draw_neural_web,
+        display_visualizations_for_learner,
+        update_history_plots_for_learner,
+        initialize_visualization_for_learner,
+        update_neuron_history_for_learner)
+        
     data = 'Train'
 
     except_this = ['spiral', 'circular']
     activations = [item for item in all_activations() if item not in except_this]
     activations_len = len(activations)
-    
+
     # Pre-checks
 
+    if cuda: 
+        x_train = transfer_to_gpu(x_train, dtype=dtype)
+        y_train = transfer_to_gpu(y_train, dtype=dtype)
+        
     if pop_size > activations_len and fit_start is True:
         for _ in range(pop_size - len(activations)):
             random_index_all_act = random.randint(0, len(activations)-1)
             activations.append(activations[random_index_all_act])
 
-    y_train = optimize_labels(y_train, cuda=False)
+    y_train = optimize_labels(y_train, cuda=cuda)
 
     if pop_size < activations_len: raise ValueError(f"pop_size must be higher or equal to {activations_len}")
 
@@ -328,15 +362,15 @@ def learn(x_train, y_train, optimizer, gen, pop_size, fit_start=True, batch_size
                 else:
            
                     act_pop[j] = activations[j]
-                    W = plan_fit(x_train_batch, y_train_batch, activations=act_pop[j], auto_normalization=auto_normalization, dtype=dtype)
+                    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], auto_normalization=auto_normalization, dtype=dtype)
+                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, model_type=model_type)
+            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':
@@ -347,8 +381,8 @@ def learn(x_train, y_train, optimizer, gen, pop_size, fit_start=True, batch_size
                                             y_pred_batch=model[get_preds_softmax()])
 
             fitness = wals(acc, train_loss, acc_impact, loss_impact)
-            target_pop.append(fitness)
-
+            target_pop.append(fitness if not cuda else fitness.get())
+            
             if fitness >= best_fitness:
 
                 best_fitness = fitness
@@ -399,7 +433,7 @@ def learn(x_train, y_train, optimizer, gen, pop_size, fit_start=True, batch_size
                 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, model_type=model_type)
+                                        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()])
@@ -413,15 +447,32 @@ def learn(x_train, y_train, optimizer, gen, pop_size, fit_start=True, batch_size
                     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)
-                    return best_weight, best_model[get_preds_softmax()], best_acc, final_activations, None, None, model_type, None, None, None, None, activation_potentiation
+                    model = template_model(
+                    best_weight,
+                    best_model[get_preds()],
+                    best_acc,
+                    final_activations,
+                    None,
+                    best_model[get_preds_softmax()],
+                    model_type,
+                    None,
+                    None,
+                    None,
+                    None,
+                    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, model_type=model_type)
+                                        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, 
@@ -436,16 +487,39 @@ def learn(x_train, y_train, optimizer, gen, pop_size, fit_start=True, batch_size
                     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)
-                    return best_weight, best_model[get_preds_softmax()], best_acc, final_activations, None, None, model_type, None, None, None, None, activation_potentiation
+                    model = template_model(
+                    best_weight,
+                    best_model[get_preds()],
+                    best_acc,
+                    final_activations,
+                    None,
+                    best_model[get_preds_softmax()],
+                    model_type,
+                    None,
+                    None,
+                    None,
+                    None,
+                    activation_potentiation
+                    )
+                    
+                    return model
 
             
             progress.update(1)
 
+        if decision_boundary_history:
+            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)
+
         if batch_size != 1:
-            train_model = evaluate(x_train, y_train, W=best_weight, activations=final_activations, activation_potentiations=activation_potentiation, auto_normalization=auto_normalization, model_type=model_type)
+            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, 
@@ -476,7 +550,7 @@ def learn(x_train, y_train, optimizer, gen, pop_size, fit_start=True, batch_size
             if best_acc_per_gen_list[i] == best_acc_per_gen_list[i-1]:
                 progress.close()
                 train_model = evaluate(x_train, y_train, W=best_weight, 
-                                    activations=final_activations, activation_potentiations=activation_potentiation, auto_normalization=auto_normalization, model_type=model_type)
+                                    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, 
@@ -491,16 +565,33 @@ def learn(x_train, y_train, optimizer, gen, pop_size, fit_start=True, batch_size
             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)
-            return best_weight, best_model[get_preds_softmax()], best_acc, final_activations, None, None, model_type, None, None, None, None, activation_potentiation
+            model = template_model(
+            best_weight,
+            best_model[get_preds()],
+            best_acc,
+            final_activations,
+            None,
+            best_model[get_preds_softmax()],
+            model_type,
+            None,
+            None,
+            None,
+            None,
+            activation_potentiation
+            )
+
+            return model
 
     # Final evaluation
     progress.close()
 
     train_model = evaluate(x_train, y_train, W=best_weight,
-                        activations=final_activations, activation_potentiations=activation_potentiation, auto_normalization=auto_normalization, model_type=model_type)
+                        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, 
@@ -509,25 +600,47 @@ def learn(x_train, y_train, optimizer, gen, pop_size, fit_start=True, batch_size
         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)
-    return best_weight, best_model[get_preds_softmax()], best_acc, final_activations, None, None, model_type, None, None, None, None, activation_potentiation
+    
+    model = template_model(
+    best_weight,
+    best_model[get_preds()],
+    best_acc,
+    final_activations,
+    None,
+    best_model[get_preds_softmax()],
+    model_type,
+    None,
+    None,
+    None,
+    None,
+    activation_potentiation
+    )
+
+    return model
 
 
 def evaluate(
     x_test,
     y_test,
-    model_type,
-    W,
+    model_type=None,
+    W=None,
+    model=None,
     activations=['linear'],
     activation_potentiations=[],
-    auto_normalization=False
+    auto_normalization=False,
+    show_report=False,
+    cuda=False
 ) -> tuple:
     """
     Evaluates the neural network model using the given test data.
@@ -537,61 +650,73 @@ def evaluate(
 
         y_test (np.ndarray): Test labels (one-hot encoded).
 
-        model_type: (str): Type of the model. Options: 'PLAN', 'MLP', 'PTNN'.
+        model_type: (str, optional): Type of the model. Options: 'PLAN', 'MLP', 'PTNN'.
 
-        W (np.ndarray): Neural net weight matrix.
+        W (array-like, optional): Neural net weight matrix.
         
+        model (tuple, optional): Trained model.
+
         activations (list, optional): Activation list for PLAN or MLP models (MLP layers activations if it PTNN model). Default = ['linear'].
 
         activation_potentiations (list, optional): Extra activation potentiation list (PLAN layers activations) for PTNN models. Default = [].
 
         auto_normalization (bool, optional): Normalization for x_test ? Default = False.
 
+        show_report (bool, optional): show test report. Default = False
+
+        cuda (bool, optional): CUDA GPU acceleration ? Default = False.
+
     Returns:
         tuple: Model (list).
     """
 
-    if auto_normalization: x_test = normalization(x_test, dtype=x_test.dtype)
+    from .cpu.visualizations import plot_evaluate
+    from .model_ops import predict_from_memory
 
-    if isinstance(activations, str):
-        activations = [activations]
-    elif isinstance(activations, list):
-        activations = [item if isinstance(item, list) or isinstance(item, str) else [item] for item in activations]
-
-    if model_type == 'MLP':
-        layer = x_test
-        for i in range(len(W)):
-            if i != len(W) - 1 and i != 0: layer = apply_activation(layer, activations[i])
-
-            layer = layer @ W[i].T
-
-        result = layer
-
-    if model_type == 'PLAN':
+    if not cuda:
+        from .cpu.data_ops import normalization
+        
+        if model:
+            sample_acc = model.accuracy
+            if hasattr(sample_acc, "get"): model = model._replace(accuracy=sample_acc.get())
 
-        x_test = apply_activation(x_test, activations)
-        result = x_test @ W.T
+    else:
+        from cuda.data_ops import normalization
+        x_test = cp.array(x_test)
+        y_test = cp.array(y_test)
+
+        if model:
+            sample_acc = model.accuracy
+            if isinstance(sample_acc, np.number): model = model._replace(accuracy=cp.array(sample_acc))
+
+    if model is None:
+        from .model_ops import get_model_template
+        template_model = get_model_template()
+        model = template_model(
+                    W,
+                    None,
+                    None,
+                    activations,
+                    None,
+                    None,
+                    model_type,
+                    None,
+                    None,
+                    None,
+                    None,
+                    activation_potentiations)
     
-    if model_type == 'PTNN':
+    result = predict_from_memory(x_test, model, cuda=cuda)
 
-        if isinstance(activation_potentiations, str):
-            activation_potentiations = [activation_potentiations]
-        elif isinstance(activation_potentiations, list):
-            activation_potentiations = [item if isinstance(item, list) or isinstance(item, str) else [item] for item in activation_potentiations]
-
-        x_test = apply_activation(x_test, activation_potentiations)
-        layer = x_test @ W[0].T
+    if auto_normalization: x_test = normalization(x_test, dtype=x_test.dtype)
 
-        for i in range(1, len(W)):
-            if i != len(W) - 1: layer = apply_activation(layer, activations[i])
+    array_type = cp if cuda else np
 
-            layer = layer @ W[i].T
+    max_vals = array_type.max(result, axis=1, keepdims=True)
+    
+    softmax_preds = array_type.exp(result - max_vals) / array_type.sum(array_type.exp(result - max_vals), axis=1, keepdims=True)
+    accuracy = (array_type.argmax(softmax_preds, axis=1) == array_type.argmax(y_test, axis=1)).mean()
 
-        result = layer
+    if show_report: plot_evaluate(x_test, y_test, result, model=model, cuda=cuda)
 
-    max_vals = np.max(result, axis=1, keepdims=True)
-    
-    softmax_preds = np.exp(result - max_vals) / np.sum(np.exp(result - max_vals), axis=1, keepdims=True)
-    accuracy = (np.argmax(softmax_preds, axis=1) == np.argmax(y_test, axis=1)).mean()
-    
     return W, result, accuracy, None, None, softmax_preds

pyerualjetwork/{cuda/model_ops.py → old_cuda_model_ops.py}

@@ -327,7 +327,7 @@ def load_model(model_name,
     lists: Weights, None, test_accuracy, activations, scaler_params, None, model_type, weight_type, weight_format, device_version, (list[df_elements])=Pandas DataFrame of the model
     """
 
-    from .. import __version__
+    from . import __version__
     
     try:
 

{pyerualjetwork-5.37.dist-info → pyerualjetwork-5.40a0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyerualjetwork
-Version: 5.37
+Version: 5.40a0
 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
@@ -28,8 +28,9 @@ YouTube Tutorials: https://www.youtube.com/watch?v=6wMQstZ00is&list=PLNgNWpM7Hbs
 	'pip install pyerualjetwork'
 	
 	package modules:
-	'from pyerualjetwork.cpu import nn, ene, data_ops, model_ops, memory_ops'
-	'from pyerualjetwork.cuda import nn, ene, data_ops, model_ops, memory_ops'
+	'from pyerualjetwork import nn, ene, model_ops, memory_ops'
+	'from pyerualjetwork.cpu data_ops'
+	'from pyerualjetwork.cuda data_ops'
 
 	please read docstrings.
 	
@@ -94,13 +95,13 @@ You can create artificial intelligence models that perform natural language proc
 
 ![PLAN VISION](https://github.com/HCB06/PyerualJetwork/blob/main/Media/NLP.gif)
 
-PLANEAT:<br>
+ENE:<br>
 
 You can create artificial intelligence models that perform reinforcement learning tasks and genetic optimization tasks using the ene module:
 
-![PLANEAT](https://github.com/HCB06/PyerualJetwork/blob/main/Media/PLANEAT_1.gif)<br>
-![PLANEAT](https://github.com/HCB06/PyerualJetwork/blob/main/Media/PLANEAT_2.gif)<br>
-![PLANEAT](https://github.com/HCB06/PyerualJetwork/blob/main/Media/mario.gif)<br><br>
+![ENE](https://github.com/HCB06/PyerualJetwork/blob/main/Media/PLANEAT_1.gif)<br>
+![ENE](https://github.com/HCB06/PyerualJetwork/blob/main/Media/PLANEAT_2.gif)<br>
+![ENE](https://github.com/HCB06/PyerualJetwork/blob/main/Media/mario.gif)<br><br>
 
 YOU CAN CREATE DYNAMIC ANIMATIONS OF YOUR MODELS
 

pyerualjetwork-5.40a0.dist-info/RECORD

@@ -0,0 +1,27 @@
+pyerualjetwork/__init__.py,sha256=rfo3H-CvlOk1oZmfsHKvg3DXIz6xUvH74WzM2_F9wmE,2798
+pyerualjetwork/ene.py,sha256=8g2XEPRm3NLqSaN7xihIj1xXdIjSrl8Q69zqWTIXPI4,42142
+pyerualjetwork/fitness_functions.py,sha256=D9JVCr9DFid_xXgBD4uCKxdW2k10MVDE5HZRSOK4Igg,1237
+pyerualjetwork/help.py,sha256=sn9jBzXkQsTZvdgsUXUpSs_BbYYIgY3whofg6dj8peI,848
+pyerualjetwork/issue_solver.py,sha256=W7DIetvWD535bjJ4JueTUmWRFceqr5B_U1tFjv0S7f0,4100
+pyerualjetwork/memory_ops.py,sha256=TUFh9SYWCKL6N-vNdWId_EwU313TuZomQCHOrltrD-4,14280
+pyerualjetwork/model_ops.py,sha256=sGPvgWFwLI5dVV4cRVqeA7Zc0NTiz8F-3v55UbiV9_k,22547
+pyerualjetwork/nn.py,sha256=GXTAoFjPxxiS2r0rMcr5DEb7t2aJXTYW8KXvDYaoltY,36277
+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
+pyerualjetwork/cpu/__init__.py,sha256=9apRbPqvGKLJwyI3Md6R5a478YbZ7kIq0dRRa_lqgrY,789
+pyerualjetwork/cpu/activation_functions.py,sha256=zZSoOQ452Ykp_RsHVxklxesJmmFgufyIB4F3WQjudEQ,6689
+pyerualjetwork/cpu/data_ops.py,sha256=SPsIcjU0JPHfsnEmGjD8q-yTlpgYk-KPOPJ44dfp-nU,16143
+pyerualjetwork/cpu/loss_functions.py,sha256=6PyBI232SQRGuFnG3LDGvnv_PUdWzT2_2mUODJiejGI,618
+pyerualjetwork/cpu/metrics.py,sha256=NF8FARAqtuGlf4omVkQT4pOQZy7uePqzuHZGX9Y_Pn4,6076
+pyerualjetwork/cpu/visualizations.py,sha256=vaXhRlmxmr-R75UhgaoRgaYiMJPZ8prU229l3z3RF7I,27146
+pyerualjetwork/cuda/__init__.py,sha256=Kja6OmNaJ0giOhRNYw9hgGkh5N4F1EUS2v94E_rmp2k,839
+pyerualjetwork/cuda/activation_functions.py,sha256=Gj-qalU0GoAWoZzbFFHsD-R0c0KzHwOK1wwUQneBE44,6872
+pyerualjetwork/cuda/data_ops.py,sha256=k7NX-ckZ6-NwvioigACUHrekG7L5lO4bzTtQbBwH1Fc,18508
+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.40a0.dist-info/METADATA,sha256=_SsE18Nu7P9uRMOU8L3coDcJA-ltYDexmb0z_ugZuR8,7990
+pyerualjetwork-5.40a0.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
+pyerualjetwork-5.40a0.dist-info/top_level.txt,sha256=BRyt62U_r3ZmJpj-wXNOoA345Bzamrj6RbaWsyW4tRg,15
+pyerualjetwork-5.40a0.dist-info/RECORD,,