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

pyerualjetwork/__init__.py

@@ -9,23 +9,23 @@ The library includes functions for data pre-processing, visualizations, model sa
 training, and both detailed and simplified memory management.
 
 
-Library (CPU) Main Modules:
+PyerualJetwork Main Modules:
+----------------------------
+- nn
+- ene
+- model_ops
+
+CPU Main Modules:
 ---------------------------
-- cpu.nn
-- cpu.ene
 - cpu.data_ops
-- cpu.model_ops
 
-Library (GPU) Main Modules:
+GPU Main Modules:
 ---------------------------
-- cuda.nn
-- cuda.ene
 - cuda.data_ops
-- cuda.model_ops
 
 Memory Module:
 --------------
-- memory_operations
+- memory_ops
 
 Issue Solver Module:
 --------------
@@ -42,7 +42,7 @@ PyerualJetwork document: https://github.com/HCB06/PyerualJetwork/blob/main/Welco
 - Contact: tchasancan@gmail.com
 """
 
-__version__ = "5.37"
+__version__ = "5.40a1"
 __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
@@ -57,7 +57,7 @@ def print_update_notes(update):
 print_version(__version__)
 print_update_notes(__update__)
 
-required_modules = ["scipy", "tqdm", "pandas", "numpy", "colorama", "cupy", "psutil"]
+required_modules = ["scipy", "tqdm", "pandas", "networkx", "seaborn", "numpy", "matplotlib", "colorama", "cupy-cuda12x", "psutil"]
 
 missing_modules = []
 for module in required_modules:
@@ -71,6 +71,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"
     "For more information, visit the PyerualJetwork GitHub README.md file:\n"
     "https://github.com/HCB06/PyerualJetwork/blob/main/README.md"
 

pyerualjetwork/cpu/__init__.py

@@ -6,12 +6,9 @@ The modules contained in this folder and their functions compute data on the cen
 Modules in the folder:
 ----------------------
 - activation_functions
-- data_operations
-- ene
+- data_ops
 - loss_functions
 - metrics
-- model_operations
-- nn
 - visualizations
 
 Examples: https://github.com/HCB06/PyerualJetwork/tree/main/Welcome_to_PyerualJetwork/ExampleCodes

pyerualjetwork/cpu/metrics.py

@@ -19,6 +19,7 @@ def metrics(y_ts, test_preds, average='weighted'):
     y_test_d = np.array(y_test_d)
     y_pred = np.array(test_preds)
 
+  
     if y_test_d.ndim > 1:
         y_test_d = y_test_d.reshape(-1)
     if y_pred.ndim > 1:
@@ -158,6 +159,7 @@ def confusion_matrix(y_true, y_pred, class_count):
     for i in range(len(y_true)):
         true_label = y_true[i]
         pred_label = y_pred[i]
+
         confusion[true_label, pred_label] += 1
 
     return confusion

pyerualjetwork/cpu/visualizations.py

@@ -1,6 +1,7 @@
 import networkx as nx
 import matplotlib.pyplot as plt
 import numpy as np
+import cupy as cp
 from scipy.spatial import ConvexHull
 import seaborn as sns
 from matplotlib.animation import ArtistAnimation
@@ -86,7 +87,7 @@ 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, get_scaler, get_act, get_weights
     
     model = load_model(model_name=model_name, model_path=model_path)
     
@@ -187,9 +188,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)
 
@@ -205,18 +203,9 @@ 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)
 
@@ -235,24 +224,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)
 
@@ -265,54 +242,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,35 +275,39 @@ def draw_activations(x_train, activation):
         return x_train
 
 
-def plot_evaluate(x_test, y_test, y_preds, acc_list, W, activations):
+def plot_evaluate(x_test, y_test, y_preds, model, cuda=False):
     
-    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
+    if not cuda:
+        from .metrics import metrics, confusion_matrix, roc_curve
+        from .data_ops import decode_one_hot
+    else:
+        from cuda.metrics import metrics, confusion_matrix, roc_curve
+        from cuda.data_ops import decode_one_hot
     
-    bar_format_normal = loading_bars()[0]
     
-    acc = acc_list[len(acc_list) - 1]
-    y_true = decode_one_hot(y_test)
+    from ..model_ops import predict_from_memory
+
+    acc = model.accuracy
 
-    y_true = np.array(y_true)
-    y_preds = np.array(y_preds)
+    y_true = decode_one_hot(y_test)
+    y_preds = decode_one_hot(y_preds)
+    
     Class = np.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))
+    fig.suptitle("Evaluation Report")
 
-    sns.heatmap(cm, annot=True, fmt='d', ax=axs[0, 0])
+    sns.heatmap(cm.get() if cuda else cm, 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)
+        if cuda: fpr, tpr = fpr.get(), tpr.get()
    
         roc_auc = np.trapz(tpr, fpr)
         axs[1, 0].plot(fpr, tpr, color='darkorange', lw=2, label=f'ROC curve (area = {roc_auc:.2f})')
@@ -380,7 +334,8 @@ def plot_evaluate(x_test, y_test, y_preds, acc_list, W, activations):
             
 
             fpr, tpr, thresholds = roc_curve(y_true_copy, y_preds_copy)
-            
+            if cuda: fpr, tpr = fpr.get(), tpr.get()
+
             roc_auc = np.trapz(tpr, fpr)
             axs[1, 0].plot(fpr, tpr, 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='--')
@@ -394,7 +349,7 @@ def plot_evaluate(x_test, y_test, y_preds, acc_list, W, activations):
     
 
     metric = ['Precision', 'Recall', 'F1 Score', 'Accuracy']
-    values = [precision, recall, f1, acc]
+    values = [precision, recall, f1, acc if not cuda else acc.get()]
     colors = ['#1f77b4', '#ff7f0e', '#2ca02c', '#d62728']
     
     
@@ -405,7 +360,7 @@ def plot_evaluate(x_test, y_test, y_preds, acc_list, W, activations):
         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_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)')
@@ -414,101 +369,102 @@ def plot_evaluate(x_test, y_test, y_preds, acc_list, W, activations):
     feature_indices=[0, 1]
 
     h = .02
+
+    array_type = np if not cuda else cp
     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 = np.meshgrid(np.arange(x_min, x_max, h),
-                         np.arange(y_min, y_max, h))
-    
-    grid = np.c_[xx.ravel(), yy.ravel()]
+    xx, yy = array_type.meshgrid(array_type.arange(x_min, x_max, h),
+                         array_type.arange(y_min, y_max, h))
 
-    try:
 
-        grid_full = np.zeros((grid.shape[0], x_test.shape[1]))
-        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)
+    grid = array_type.c_[xx.ravel(), yy.ravel()]
+    grid_full = array_type.zeros((grid.shape[0], x_test.shape[1]), dtype=array_type.float32)
+    grid_full[:, feature_indices] = grid
 
-        for i in range(len(grid_full)):
+    Z = array_type.argmax(predict_from_memory(grid_full, model=model, cuda=cuda), axis=1)
 
-            Z[i] = np.argmax(predict_model_ram(grid_full[i], W=W, activations=activations))
-            predict_progress.update(1)
+    Z = Z.reshape(xx.shape)
 
-        predict_progress.close()
+    if cuda:
+        xx = xx.get()
+        yy = yy.get()
+        Z = Z.get()
+        x_test = x_test.get()
+        y_test_decoded = decode_one_hot(y_test).get()
 
-        Z = np.array(Z)
-        Z = Z.reshape(xx.shape)
+    else:
+        y_test_decoded = decode_one_hot(y_test)
 
-        axs[1,1].contourf(xx, yy, Z, alpha=0.8)
-        axs[1,1].scatter(x_test[:, feature_indices[0]], x_test[:, feature_indices[1]], c=decode_one_hot(y_test), 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')
+    axs[1,1].contourf(xx, yy, Z, alpha=0.8)
+    axs[1,1].scatter(x_test[:, feature_indices[0]], x_test[:, feature_indices[1]], c=y_test_decoded, 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')
 
-    except Exception as e:
-        print(f"Error: {e}")
 
     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
+def plot_decision_boundary(x, y, ax, activations, W, artist, model_type, activation_potentiation=False, cuda=False):
     
+    from model_ops import get_model_template, predict_from_memory
+
+    if not cuda:
+        from .data_ops import decode_one_hot
+
+    else:
+        from cuda.data_ops import decode_one_hot
+
     feature_indices = [0, 1]
 
+    template_model = get_model_template()
+
+    template_model = template_model(
+                    W,
+                    None,
+                    None,
+                    activations,
+                    None,
+                    None,
+                    model_type,
+                    None,
+                    None,
+                    None,
+                    None,
+                    activation_potentiation)
     h = .02
+    array_type = np if not cuda else cp
     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 = np.meshgrid(np.arange(x_min, x_max, h),
-                         np.arange(y_min, y_max, h))
-    
-    grid = np.c_[xx.ravel(), yy.ravel()]
-    grid_full = np.zeros((grid.shape[0], x.shape[1]), dtype=np.float32)
+    xx, yy = array_type.meshgrid(array_type.arange(x_min, x_max, h),
+                         array_type.arange(y_min, y_max, h))
+
+    grid = array_type.c_[xx.ravel(), yy.ravel()]
+    grid_full = array_type.zeros((grid.shape[0], x.shape[1]), dtype=array_type.float32)
     grid_full[:, feature_indices] = grid
-    
-    Z = [None] * len(grid_full)
 
-    for i in range(len(grid_full)):
-        Z[i] = np.argmax(predict_model_ram(grid_full[i], W=W, activations=activations))
+    Z = array_type.argmax(predict_from_memory(grid_full, model=template_model, cuda=cuda), axis=1)
 
-    Z = np.array(Z, dtype=np.int32)
     Z = Z.reshape(xx.shape)
 
-    if ax is None:
-
-        plt.contourf(xx, yy, Z, alpha=0.8)
-        plt.scatter(x[:, feature_indices[0]], x[:, feature_indices[1]], c=decode_one_hot(y), 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()
+    if cuda:
+        xx = xx.get()
+        yy = yy.get()
+        Z = Z.get()
+        x = x.get()
+        y_test_decoded = decode_one_hot(y).get()
 
     else:
+        y_test_decoded = decode_one_hot(y)
 
-        try:
-            art1_1 = ax[1, 0].contourf(xx, yy, Z, alpha=0.8)
-            art1_2 = ax[1, 0].scatter(x[:, feature_indices[0]], x[:, feature_indices[1]], c=decode_one_hot(y), 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, yy, Z, alpha=0.8)
+    art1_2 = ax.scatter(x[:, feature_indices[0]], x[:, feature_indices[1]], c=y_test_decoded, 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')
+    artist.append([*art1_1.collections, art1_2])
 
-            art1_1 = ax.contourf(xx, yy, Z, alpha=0.8)
-            art1_2 = ax.scatter(x[:, feature_indices[0]], x[:, feature_indices[1]], c=decode_one_hot(y), 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
+    return artist
   
         
 def plot_decision_space(x, y, y_preds=None, s=100, color='tab20'):
@@ -823,4 +779,16 @@ def display_visualizations_for_learner(viz_objects, best_weights, data, best_acc
         
         ani5 = ArtistAnimation(web['fig'], web['artists'], interval=interval, blit=True)
         plt.tight_layout()
-        plt.show()
+        plt.show()
+
+
+def display_decision_boundary_history(fig, artist, interval):
+    
+    ani1 = ArtistAnimation(fig, artist, interval=interval, blit=True)
+    plt.tight_layout()
+    plt.show()
+
+
+def create_decision_boundary_hist():
+    fig, ax = plt.subplots()
+    return fig, ax

pyerualjetwork/cuda/__init__.py

@@ -6,12 +6,9 @@ The modules contained in this folder and their functions compute data on a graph
 Modules in the folder:
 ----------------------
 - activation_functions
-- data_operations
-- ene
+- data_ops
 - loss_functions
 - metrics
-- model_operations
-- nn
 - visualizations
 
 Examples: https://github.com/HCB06/PyerualJetwork/tree/main/Welcome_to_PyerualJetwork/ExampleCodes

pyerualjetwork/cuda/activation_functions.py

@@ -121,6 +121,9 @@ def sin_plus(x):
 def modular_circular_activation(x, period=2*cp.pi):
     return cp.mod(x, period) / period
 
+def gelu(x):
+    return 0.5 * x * (1 + cp.tanh(cp.sqrt(2 / cp.pi) * (x + 0.044715 * cp.power(x, 3))))
+
 def tanh_circular_activation(x):
     return (cp.tanh(x) + 1) / 2
 

pyerualjetwork/cuda/data_ops.py

@@ -113,7 +113,7 @@ def split(X, y, test_size, random_state=42, dtype=cp.float32, shuffle_in_cpu=Fal
     Returns:
         tuple: x_train, x_test, y_train, y_test as ordered training and testing data subsets.
     """
-    from ..memory_ops import transfer_to_gpu, optimize_labels
+    from memory_ops import transfer_to_gpu, optimize_labels
     
     X = transfer_to_gpu(X, dtype=dtype)
     y = optimize_labels(y, one_hot_encoded=False, cuda=True)