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

pyerualjetwork/cuda/visualizations.py

@@ -2,7 +2,6 @@ import networkx as nx
 import matplotlib.pyplot as plt
 import cupy as cp
 from scipy.spatial import ConvexHull
-import seaborn as sns
 from matplotlib.animation import ArtistAnimation
 
 def draw_neural_web(W, ax, G, return_objs=False):
@@ -87,13 +86,13 @@ def draw_model_architecture(model_name, model_path=''):
     Visualizes the architecture of a neural network model with multiple inputs based on activation functions.
     """
     
-    from .model_ops import load_model, get_scaler, get_act, get_weights
+    from ..model_ops import load_model
     
     model = load_model(model_name=model_name, model_path=model_path)
     
-    W = model[get_weights()]
-    activations = model[get_act()]
-    scaler_params = model[get_scaler()]
+    W = model.weights
+    activations = model.activations
+    scaler_params = model.scaler_params
     
     # Calculate dimensions based on number of activation functions
     num_activations = len(activations)
@@ -188,9 +187,6 @@ def draw_activations(x_train, activation):
     if activation == 'sigmoid':
         result = af.Sigmoid(x_train)
 
-    elif activation == 'swish':
-        result = af.swish(x_train)
-
     elif activation == 'circular':
         result = af.circular_activation(x_train)
 
@@ -206,18 +202,6 @@ def draw_activations(x_train, activation):
     elif activation == 'relu':
         result = af.Relu(x_train)
 
-    elif activation == 'softplus':
-        result = af.softplus(x_train)
-
-    elif activation == 'elu':
-        result = af.elu(x_train)
-
-    elif activation == 'gelu':
-        result = af.gelu(x_train)
-
-    elif activation == 'selu':
-        result = af.selu(x_train)
-
     elif activation == 'softmax':
         result = af.Softmax(x_train)
 
@@ -236,24 +220,12 @@ def draw_activations(x_train, activation):
     elif activation == 'dlrelu':
         result = af.dlrelu(x_train)
 
-    elif activation == 'exsig':
-        result = af.exsig(x_train)
-
     elif activation == 'sin_plus':
         result = af.sin_plus(x_train)
 
     elif activation == 'acos':
         result = af.acos(x_train, alpha=1.0, beta=0.0)
 
-    elif activation == 'gla':
-        result = af.gla(x_train, alpha=1.0, mu=0.0)
-
-    elif activation == 'srelu':
-        result = af.srelu(x_train)
-
-    elif activation == 'qelu':
-        result = af.qelu(x_train)
-
     elif activation == 'isra':
         result = af.isra(x_train)
 
@@ -266,54 +238,27 @@ def draw_activations(x_train, activation):
     elif activation == 'bent_identity':
         result = af.bent_identity(x_train)
 
-    elif activation == 'sech':
-        result = af.sech(x_train)
-
     elif activation == 'softsign':
         result = af.softsign(x_train)
 
     elif activation == 'pwl':
         result = af.pwl(x_train)
 
-    elif activation == 'cubic':
-        result = af.cubic(x_train)
-
-    elif activation == 'gaussian':
-        result = af.gaussian(x_train)
-
     elif activation == 'sine':
         result = af.sine(x_train)
 
     elif activation == 'tanh_square':
         result = af.tanh_square(x_train)
 
-    elif activation == 'mod_sigmoid':
-        result = af.mod_sigmoid(x_train)
-
     elif activation == 'linear':
         result = x_train
 
-    elif activation == 'quartic':
-        result = af.quartic(x_train)
-
-    elif activation == 'square_quartic':
-        result = af.square_quartic(x_train)
-
-    elif activation == 'cubic_quadratic':
-        result = af.cubic_quadratic(x_train)
-
-    elif activation == 'exp_cubic':
-        result = af.exp_cubic(x_train)
-
     elif activation == 'sine_square':
         result = af.sine_square(x_train)
 
     elif activation == 'logarithmic':
         result = af.logarithmic(x_train)
 
-    elif activation == 'scaled_cubic':
-        result = af.scaled_cubic(x_train, 1.0)
-
     elif activation == 'sine_offset':
         result = af.sine_offset(x_train, 1.0)
 
@@ -325,187 +270,6 @@ def draw_activations(x_train, activation):
         print('\rWARNING: error in drawing some activation.', end='')
         return x_train
 
-
-def plot_evaluate(x_test, y_test, y_preds, acc_list, W, activations):
-    
-    from .metrics import metrics, confusion_matrix, roc_curve
-    from ..ui import loading_bars, initialize_loading_bar
-    from .data_ops import decode_one_hot
-    from .model_ops import predict_model_ram
-    
-    bar_format_normal = loading_bars()[0]
-    
-    acc = acc_list[len(acc_list) - 1]
-    y_true = decode_one_hot(y_test)
-
-    y_true = cp.array(y_true, copy=True)
-    y_preds = cp.array(y_preds, copy=True)
-    Class = cp.unique(decode_one_hot(y_test))
-
-    precision, recall, f1 = metrics(y_test, y_preds)
-    
-    
-    cm = confusion_matrix(y_true, y_preds, len(Class))
-    fig, axs = plt.subplots(2, 2, figsize=(16, 12))
-
-    sns.heatmap(cm.get(), annot=True, fmt='d', ax=axs[0, 0])
-    axs[0, 0].set_title("Confusion Matrix")
-    axs[0, 0].set_xlabel("Predicted Class")
-    axs[0, 0].set_ylabel("Actual Class")
-    
-    if len(Class) == 2:
-        fpr, tpr, thresholds = roc_curve(y_true, y_preds)
-   
-        roc_auc = cp.trapz(tpr, fpr)
-        axs[1, 0].plot(fpr.get(), tpr.get(), color='darkorange', lw=2, label=f'ROC curve (area = {roc_auc:.2f})')
-        axs[1, 0].plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--')
-        axs[1, 0].set_xlim([0.0, 1.0])
-        axs[1, 0].set_ylim([0.0, 1.05])
-        axs[1, 0].set_xlabel('False Positive Rate')
-        axs[1, 0].set_ylabel('True Positive Rate')
-        axs[1, 0].set_title('Receiver Operating Characteristic (ROC) Curve')
-        axs[1, 0].legend(loc="lower right")
-        axs[1, 0].legend(loc="lower right")
-    else:
-
-        for i in range(len(Class)):
-            
-            y_true_copy = cp.copy(y_true)
-            y_preds_copy = cp.copy(y_preds)
-        
-            y_true_copy[y_true_copy == i] = 0
-            y_true_copy[y_true_copy != 0] = 1
-            
-            y_preds_copy[y_preds_copy == i] = 0
-            y_preds_copy[y_preds_copy != 0] = 1
-            
-
-            fpr, tpr, thresholds = roc_curve(y_true_copy, y_preds_copy)
-            
-            roc_auc = cp.trapz(tpr, fpr)
-            axs[1, 0].plot(fpr.get(), tpr.get(), color='darkorange', lw=2, label=f'ROC curve (area = {roc_auc:.2f})')
-            axs[1, 0].plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--')
-            axs[1, 0].set_xlim([0.0, 1.0])
-            axs[1, 0].set_ylim([0.0, 1.05])
-            axs[1, 0].set_xlabel('False Positive Rate')
-            axs[1, 0].set_ylabel('True Positive Rate')
-            axs[1, 0].set_title('Receiver Operating Characteristic (ROC) Curve')
-            axs[1, 0].legend(loc="lower right")
-            axs[1, 0].legend(loc="lower right")
-    
-
-    metric = ['Precision', 'Recall', 'F1 Score', 'Accuracy']
-    values = [precision, recall, f1, acc.get()]
-    colors = ['#1f77b4', '#ff7f0e', '#2ca02c', '#d62728']
-    
-    
-    bars = axs[0, 1].bar(metric, values, color=colors)
-    
-    
-    for bar, value in zip(bars, values):
-        axs[0, 1].text(bar.get_x() + bar.get_width() / 2, bar.get_height() - 0.05, f'{value:.2f}',
-                       ha='center', va='bottom', fontsize=12, color='white', weight='bold')
-    
-    axs[0, 1].set_ylim(0, 1) 
-    axs[0, 1].set_xlabel('Metrics')
-    axs[0, 1].set_ylabel('Score')
-    axs[0, 1].set_title('Precision, Recall, F1 Score, and Accuracy (Weighted)')
-    axs[0, 1].grid(True, axis='y', linestyle='--', alpha=0.7)
-    
-    feature_indices=[0, 1]
-
-    h = .02
-    x_min, x_max = x_test[:, feature_indices[0]].min() - 1, x_test[:, feature_indices[0]].max() + 1
-    y_min, y_max = x_test[:, feature_indices[1]].min() - 1, x_test[:, feature_indices[1]].max() + 1
-    xx, yy = cp.meshgrid(cp.arange(x_min, x_max, h),
-                         cp.arange(y_min, y_max, h))
-    
-    grid = cp.c_[xx.ravel(), yy.ravel()]
-
-    grid_full = cp.zeros((grid.shape[0], x_test.shape[1]), dtype=cp.float32)
-    grid_full[:, feature_indices] = grid
-    
-    Z = [None] * len(grid_full)
-
-    predict_progress = initialize_loading_bar(total=len(grid_full),leave=False,
-        bar_format=bar_format_normal ,desc="Predicts For Decision Boundary",ncols= 65)
-
-    for i in range(len(grid_full)):
-
-        Z[i] = cp.argmax(predict_model_ram(grid_full[i], W=W, activations=activations))
-        predict_progress.update(1)
-
-    predict_progress.close()
-
-    Z = cp.array(Z)
-    Z = Z.reshape(xx.shape)
-
-    axs[1,1].contourf(xx.get(), yy.get(), Z.get(), alpha=0.8)
-    axs[1,1].scatter(x_test[:, feature_indices[0]].get(), x_test[:, feature_indices[1]].get(), c=decode_one_hot(y_test).get(), edgecolors='k', marker='o', s=20, alpha=0.9)
-    axs[1,1].set_xlabel(f'Feature {0 + 1}')
-    axs[1,1].set_ylabel(f'Feature {1 + 1}')
-    axs[1,1].set_title('Decision Boundary')
-
-    plt.show()
-
-    
-def plot_decision_boundary(x, y, activations, W, artist=None, ax=None):
-    
-    from .model_ops import predict_model_ram
-    from .data_ops import decode_one_hot
-    
-    feature_indices = [0, 1]
-
-    h = .02
-    x_min, x_max = x[:, feature_indices[0]].min() - 1, x[:, feature_indices[0]].max() + 1
-    y_min, y_max = x[:, feature_indices[1]].min() - 1, x[:, feature_indices[1]].max() + 1
-    xx, yy = cp.meshgrid(cp.arange(x_min, x_max, h),
-                         cp.arange(y_min, y_max, h))
-    
-    grid = cp.c_[xx.ravel(), yy.ravel()]
-    grid_full = cp.zeros((grid.shape[0], x.shape[1]))
-    grid_full[:, feature_indices] = grid
-    
-    Z = [None] * len(grid_full)
-
-    for i in range(len(grid_full)):
-        Z[i] = cp.argmax(predict_model_ram(grid_full[i], W=W, activations=activations))
-
-    Z = cp.array(Z, dtype=cp.int32)
-    Z = Z.reshape(xx.shape)
-
-    if ax is None:
-
-        plt.contourf(xx.get(), yy.get(), Z.get(), alpha=0.8)
-        plt.scatter(x[:, feature_indices[0]].get(), x[:, feature_indices[1]].get(), c=decode_one_hot(y).get(), edgecolors='k', marker='o', s=20, alpha=0.9)
-        plt.xlabel(f'Feature {0 + 1}')
-        plt.ylabel(f'Feature {1 + 1}')
-        plt.title('Decision Boundary')
-
-        plt.show()
-
-    else:
-
-        try:
-            art1_1 = ax[1, 0].contourf(xx.get(), yy.get(), Z.get(), alpha=0.8)
-            art1_2 = ax[1, 0].scatter(x[:, feature_indices[0]].get(), x[:, feature_indices[1]].get(), c=decode_one_hot(y).get(), edgecolors='k', marker='o', s=20, alpha=0.9)
-            ax[1, 0].set_xlabel(f'Feature {0 + 1}')
-            ax[1, 0].set_ylabel(f'Feature {1 + 1}')
-            ax[1, 0].set_title('Decision Boundary')
-
-            return art1_1, art1_2
-        
-        except:
-
-            art1_1 = ax.contourf(xx.get(), yy.get(), Z.get(), alpha=0.8)
-            art1_2 = ax.scatter(x[:, feature_indices[0]].get(), x[:, feature_indices[1]].get(), c=decode_one_hot(y).get(), edgecolors='k', marker='o', s=20, alpha=0.9)
-            ax.set_xlabel(f'Feature {0 + 1}')
-            ax.set_ylabel(f'Feature {1 + 1}')
-            ax.set_title('Decision Boundary')
-
-
-            return art1_1, art1_2
-  
         
 def plot_decision_space(x, y, y_preds=None, s=100, color='tab20'):
     

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

@@ -1,17 +1,16 @@
 """ 
 
 
-ENE (Eugenic NeuroEvolution) on CPU
+ENE (Eugenic NeuroEvolution)
 ===================================
 
-This module contains all the functions necessary for implementing and testing the ENE (Eugenic NeuroEvolution) algorithm on CPU.
+This module contains all the functions necessary for implementing and testing the ENE (Eugenic NeuroEvolution).
 For more information about the ENE algorithm: https://github.com/HCB06/PyerualJetwork/blob/main/Welcome_to_PLAN/PLAN.pdf
 
 Module functions:
 -----------------
 - evolver()
 - define_genomes()
-- evaluate()
 - cross_over() 
 - mutation()
 - dominant_parent_selection()
@@ -34,9 +33,9 @@ import math
 import copy
 
 ### LIBRARY IMPORTS ###
-from .data_ops import non_neg_normalization
-from ..ui import loading_bars, initialize_loading_bar
-from .activation_functions import apply_activation, all_activations
+from .cpu.data_ops import non_neg_normalization
+from .ui import loading_bars, initialize_loading_bar
+from .cpu.activation_functions import all_activations
 
 def define_genomes(input_shape, output_shape, population_size, neurons=[], activation_functions=[], dtype=np.float32):
    """
@@ -518,57 +517,6 @@ def evolver(weights,
    return weights, activations
 
 
-def evaluate(Input, weights, activations, is_mlp=False):
-   """
-    Evaluates the performance of a population of genomes, applying different activation functions 
-    and weights depending on whether reinforcement learning mode is enabled or not.
-
-    Args:
-        Input (list or numpy.ndarray): A list or 2D numpy array where each element represents
-                                               a genome (A list of input features for each genome, or a single set of input features for one genome).
-        weights (list or numpy.ndarray): A list or 2D numpy array of weights corresponding to each genome 
-                                         in `x_population`. This determines the strength of connections.
-        activations (list or str): A list where each entry represents an activation function 
-                                                or a potentiation strategy applied to each genome. If only one 
-                                                activation function is used, this can be a single string.
-        is_mlp (bool, optional): Evaluate PLAN model or MLP model ? Default: False (PLAN)
-
-    Returns:
-        list: A list of outputs corresponding to each genome in the population after applying the respective 
-              activation function and weights.
-
-    Example:
-        ```python
-        outputs = evaluate(Input, weights, activations)
-        ```
-
-    - The function returns a list of outputs after processing the population, where each element corresponds to
-      the output for each genome in population.
-   """
-   ### THE OUTPUTS ARE RETURNED, WHERE EACH GENOME'S OUTPUT MATCHES ITS INDEX:
-   
-   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 is_mlp:
-      layer = Input
-      for i in range(len(weights)):
-         if i != len(weights) - 1 and i != 0: layer = apply_activation(layer, activations[i])
-
-         layer = layer @ weights[i].T
-      
-      return layer
-
-   else:
-
-      Input = apply_activation(Input, activations)
-      result = Input @ weights.T
-
-      return result
-
 def cross_over(first_parent_W,
                second_parent_W,
                first_parent_act,

pyerualjetwork/help.py

@@ -1,4 +1,4 @@
-from pyerualjetwork.cuda.nn import all_activations
+from pyerualjetwork.cpu.activation_functions import all_activations
 
 
 def activation_potentiation():

pyerualjetwork/issue_solver.py

@@ -22,10 +22,10 @@ PyerualJetwork document: https://github.com/HCB06/PyerualJetwork/blob/main/Welco
 - Contact: tchasancan@gmail.com
 """
 
-def update_model_to_v5(model_name, model_path, is_cuda):
+def update_model_to_v5_4(model_name, model_path, is_cuda):
 
     """
-    update_model_to_v5 function helps users for update models from older versions to newer versions.
+    update_model_to_v5_4 function helps users for update models from older versions to newer versions.
    
     :param str model_name: Name of saved model.
     
@@ -36,28 +36,34 @@ def update_model_to_v5(model_name, model_path, is_cuda):
     :return: prints terminal if succes.
     """
 
+    from .model_ops import save_model
+
     if is_cuda:
 
-        from pyerualjetwork.cuda.model_ops import (get_act, 
+        from .old_cuda_model_ops import (get_act, 
                                             get_weights,
                                             get_scaler, 
                                             get_acc, 
                                             get_model_type,
                                             get_weights_type, 
                                             get_weights_format,
-                                            load_model,
-                                            save_model)
+                                            get_model_df,
+                                            get_act_pot,
+                                            get_model_version,
+                                            load_model)
     else:
 
-        from pyerualjetwork.cpu.model_ops import (get_act,
+        from .old_cpu_model_ops import (get_act,
                                             get_weights,
                                             get_scaler, 
                                             get_acc, 
                                             get_model_type, 
                                             get_weights_type,
                                             get_weights_format,
-                                            load_model,
-                                            save_model)
+                                            get_model_df,
+                                            get_act_pot,
+                                            get_model_version,
+                                            load_model)
 
     model = load_model(model_name, model_path)
 
@@ -68,10 +74,32 @@ def update_model_to_v5(model_name, model_path, is_cuda):
     model_type = model[get_model_type()]
     weights_type = model[get_weights_type()]
     weights_format = model[get_weights_format()]
+    model_df = model[get_model_df()]
+    act_pot = model[get_act_pot()]
+    version = model[get_model_version()]
+
+    from .model_ops import get_model_template
+
+    template_model = get_model_template()
+
+    model = template_model(weights,
+                            None,
+                            test_acc,
+                            activations,
+                            scaler_params,
+                            None,
+                            model_type,
+                            weights_type,
+                            weights_format,
+                            device_version,
+                            model_df,
+                            act_pot
+                            )
+    
 
     from .__init__ import __version__
     device_version = __version__
 
-    save_model("updated_" + model_name, weights, model_type, scaler_params, test_acc, model_path, activations, weights_type, weights_format)
+    save_model(model, "updated_" + model_name, model_path)
 
-    print(f"\nModel succesfully updated to {device_version}. NOTE: This operation just for compatibility. You may still have perfomance issues in this situation please install model's version of pyerualjetwork.")
+    print(f"\nModel succesfully updated from {version} to {device_version}. In this location: {model_path}\nNOTE: This operation just for compatibility. You may still have perfomance issues in this situation please install model's version of pyerualjetwork.")