pyerualjetwork 4.1.4__py3-none-any.whl → 4.1.6__py3-none-any.whl

pyerualjetwork/plan_cuda.py

@@ -15,6 +15,7 @@ ANAPLAN document: https://github.com/HCB06/Anaplan/blob/main/Welcome_to_Anaplan/
 
 import cupy as cp
 from colorama import Fore
+import math
 
 ### LIBRARY IMPORTS ###
 from .ui import loading_bars, initialize_loading_bar
@@ -25,8 +26,9 @@ from .metrics_cuda import metrics
 from .model_operations_cuda import get_acc, get_preds, get_preds_softmax
 from .visualizations_cuda import (
     draw_neural_web,
+    update_neural_web_for_fit,
     plot_evaluate,
-    neuron_history,
+    update_neuron_history,
     initialize_visualization_for_fit,
     update_weight_visualization_for_fit,
     update_decision_boundary_for_fit,
@@ -34,7 +36,9 @@ from .visualizations_cuda import (
     display_visualization_for_fit,
     display_visualizations_for_learner,
     update_history_plots_for_learner,
-    initialize_visualization_for_learner
+    initialize_visualization_for_learner,
+    update_neuron_history_for_learner,
+    show
 )
 
 ### GLOBAL VARIABLES ###
@@ -58,7 +62,8 @@ def fit(
     train_bar=True,
     auto_normalization=True,
     neurons_history=False,
-    dtype=cp.float32
+    dtype=cp.float32,
+    memory='gpu'
 ):
     """
     Creates a model to fitting data.
@@ -95,23 +100,15 @@ def fit(
 
         dtype (cupy.dtype): Data type for the arrays. np.float32 by default. Example: cp.float64 or cp.float16. [fp32 for balanced devices, fp64 for strong devices, fp16 for weak devices: not reccomended!] (optional)
 
+        memory (str): The memory parameter determines whether the dataset to be processed on the GPU will be stored in the CPU's RAM or the GPU's RAM. Options:  'gpu', 'cpu'. Default: 'gpu'.
+
     Returns:
         numpyarray([num]): (Weight matrix).
     """
     # Pre-checks
 
-    x_train = cp.array(x_train, copy=False).astype(dtype, copy=False)
-
-    if len(y_train[0]) < 256:
-        if y_train.dtype != cp.uint8:
-            y_train = cp.array(y_train, copy=False).astype(cp.uint8, copy=False)
-    elif len(y_train[0]) <= 32767:
-        if y_train.dtype != cp.uint16:
-            y_train = cp.array(y_train, copy=False).astype(cp.uint16, copy=False)
-    else:
-        if y_train.dtype != cp.uint32:
-            y_train = cp.array(y_train, copy=False).astype(cp.uint32, copy=False)
-
+    from memory_operations import transfer_to_gpu, transfer_to_cpu
+    
     if train_bar and val:
         train_progress = initialize_loading_bar(total=len(x_train), ncols=71, desc='Fitting', bar_format=bar_format_normal)
     elif train_bar and val == False:
@@ -123,6 +120,25 @@ def fit(
     if val and (x_val is None or y_val is None):
         x_val, y_val = x_train, y_train
 
+    if memory == 'gpu':
+        x_train = transfer_to_gpu(x_train, dtype=dtype)
+        y_train = transfer_to_gpu(y_train, dtype=y_train.dtype)
+
+        if val:
+            x_val = transfer_to_gpu(x_val, dtype=dtype)
+            y_val = transfer_to_gpu(y_val, dtype=y_train.dtype)
+
+    elif memory == 'cpu':
+        x_train = transfer_to_cpu(x_train, dtype=dtype)
+        y_train = transfer_to_cpu(y_train, dtype=y_train.dtype)
+
+        if val:
+            x_val = transfer_to_cpu(x_val, dtype=dtype)
+            y_val = transfer_to_cpu(y_val, dtype=y_train.dtype)
+
+    else:
+        raise ValueError("memory parameter must be 'cpu' or 'gpu'.")
+
     val_list = [] if val else None
     val_count = val_count or 10
     # Defining weights
@@ -130,29 +146,44 @@ def fit(
     LTPW = cp.zeros((len(y_train[0]), len(x_train[0].ravel()))).astype(dtype, copy=False)  # LTPW = LONG TERM POTENTIATION WEIGHT
     # Initialize visualization
     vis_objects = initialize_visualization_for_fit(val, show_training, neurons_history, x_train, y_train)
-
+   
     # Training process
     for index, inp in enumerate(x_train):
-        inp = cp.array(inp, copy=False).ravel()
-        y_decoded = decode_one_hot(y_train)
+        inp = transfer_to_gpu(inp, dtype=dtype).ravel()
+        y_decoded = decode_one_hot(cp.array(y_train[index], copy=False, dtype=y_train.dtype))
         # Weight updates
-        STPW = feed_forward(inp, STPW, is_training=True, Class=y_decoded[index], activation_potentiation=activation_potentiation, LTD=LTD)
+        STPW = feed_forward(inp, STPW, is_training=True, Class=y_decoded, activation_potentiation=activation_potentiation, LTD=LTD)
         LTPW += normalization(STPW, dtype=dtype) if auto_normalization else STPW
 
-        # Visualization updates
-        if show_training:
-            update_weight_visualization_for_fit(vis_objects['ax'][0, 0], LTPW, vis_objects['artist2'])
-            if decision_boundary_status:
-                update_decision_boundary_for_fit(vis_objects['ax'][0, 1], x_val, y_val, activation_potentiation, LTPW, vis_objects['artist1'])
-            update_validation_history_for_fit(vis_objects['ax'][1, 1], val_list, vis_objects['artist3'])
+        if val and index != 0:
+            if index % math.ceil((val_count / len(x_train)) * 100) == 0:
+                val_acc = evaluate(x_val, y_val, loading_bar_status=False, activation_potentiation=activation_potentiation, W=LTPW, memory=memory)[get_acc()]
+                val_list.append(val_acc)
+
+                # Visualization updates
+                if show_training:
+                    update_weight_visualization_for_fit(vis_objects['ax'][0, 0], LTPW, vis_objects['artist2'])
+                    if decision_boundary_status:
+                        update_decision_boundary_for_fit(vis_objects['ax'][0, 1], x_val, y_val, activation_potentiation, LTPW, vis_objects['artist1'])
+                    update_validation_history_for_fit(vis_objects['ax'][1, 1], val_list, vis_objects['artist3'])
+                    update_neural_web_for_fit(W=LTPW, G=vis_objects['G'], ax=vis_objects['ax'][1, 0], artist=vis_objects['artist4'])
+                if neurons_history:
+                    update_neuron_history(LTPW, row=vis_objects['row'], col=vis_objects['col'], class_count=len(y_train[0]), fig1=vis_objects['fig1'], ax1=vis_objects['ax1'], artist5=vis_objects['artist5'], acc=val_acc)
         if train_bar:
              train_progress.update(1)
 
         STPW = cp.ones((len(y_train[0]), len(x_train[0].ravel()))).astype(dtype, copy=False)
 
-    # Finalize visualization
     if show_training:
-        display_visualization_for_fit(vis_objects['fig'], vis_objects['artist1'], interval)
+        ani1 = display_visualization_for_fit(vis_objects['fig'], vis_objects['artist1'], interval)
+        ani2 = display_visualization_for_fit(vis_objects['fig'], vis_objects['artist2'], interval)
+        ani3 = display_visualization_for_fit(vis_objects['fig'], vis_objects['artist3'], interval)
+        ani4 = display_visualization_for_fit(vis_objects['fig'], vis_objects['artist4'], interval)
+        show()
+    
+    if neurons_history:
+        ani5 = display_visualization_for_fit(vis_objects['fig1'], vis_objects['artist5'], interval)
+        show()
 
     return normalization(LTPW, dtype=dtype)
 
@@ -162,7 +193,7 @@ def learner(x_train, y_train, x_test=None, y_test=None, strategy='accuracy', bat
            neurons_history=False, patience=None, depth=None, early_shifting=False,
            early_stop=False, loss='categorical_crossentropy', show_history=False,
            interval=33.33, target_acc=None, target_loss=None, except_this=None,
-           only_this=None, start_this=None, dtype=cp.float32):
+           only_this=None, start_this=None, dtype=cp.float32, memory='gpu'):
     """
     Optimizes the activation functions for a neural network by leveraging train data to find 
     the most accurate combination of activation potentiation for the given dataset.
@@ -215,11 +246,15 @@ def learner(x_train, y_train, x_test=None, y_test=None, strategy='accuracy', bat
 
         dtype (cupy.dtype): Data type for the arrays. np.float32 by default. Example: cp.float64 or cp.float16. [fp32 for balanced devices, fp64 for strong devices, fp16 for weak devices: not reccomended!] (optional)
 
+        memory (str): The memory parameter determines whether the dataset to be processed on the GPU will be stored in the CPU's RAM or the GPU's RAM. Options:  'gpu', 'cpu'. Default: 'gpu'.
+
     Returns:
         tuple: A list for model parameters: [Weight matrix, Preds, Accuracy, [Activations functions]]. You can acces this parameters in model_operations module. For example: model_operations.get_weights() for Weight matrix.
     
     """
-    print(Fore.WHITE + "\nRemember, optimization on large datasets can be very time-consuming and computationally expensive. Therefore, if you are working with such a dataset, our recommendation is to include activation function: ['circular', 'spiral'] in the 'except_this' parameter unless absolutely necessary, as they can significantly prolong the process. from: learner\n" + Fore.RESET)
+    from memory_operations import transfer_to_gpu, transfer_to_cpu
+
+    print(Fore.WHITE + "\nRemember, optimization on large datasets can be very time-consuming and computationally expensive. Therefore, if you are working with such a dataset, our recommendation is to include activation function: ['circular'] in the 'except_this' parameter unless absolutely necessary, as they can significantly prolong the process. from: learner\n" + Fore.RESET)
 
     activation_potentiation = all_activations()
 
@@ -230,29 +265,27 @@ def learner(x_train, y_train, x_test=None, y_test=None, strategy='accuracy', bat
     else:
         data = 'Test'
         
-    x_train = cp.array(x_train, copy=False)
-
-    if len(y_train[0]) < 256:
-        if y_train.dtype != cp.uint8:
-            y_train = cp.array(y_train, copy=False).astype(cp.uint8, copy=False)
-    elif len(y_train[0]) <= 32767:
-        if y_train.dtype != cp.uint16:
-            y_train = cp.array(y_train, copy=False).astype(cp.uint16, copy=False)
-    else:
-        if y_train.dtype != cp.uint32:
-            y_train = cp.array(y_train, copy=False).astype(cp.uint32, copy=False)
+    if memory == 'gpu':
+        x_train = transfer_to_gpu(x_train, dtype=dtype)
+        y_train = transfer_to_gpu(y_train, dtype=y_train.dtype)
+
+        x_test = transfer_to_gpu(x_test, dtype=dtype)
+        y_test = transfer_to_gpu(y_test, dtype=y_train.dtype)
+
+        from data_operations_cuda import batcher
+
+    elif memory == 'cpu':
+        x_train = transfer_to_cpu(x_train, dtype=dtype)
+        y_train = transfer_to_cpu(y_train, dtype=y_train.dtype)
 
-    x_test = cp.array(x_test, copy=False)
+        x_test = transfer_to_cpu(x_test, dtype=dtype)
+        y_test = transfer_to_cpu(y_test, dtype=y_train.dtype)
+
+        from data_operations import batcher
 
-    if len(y_test[0]) < 256:
-        if y_test.dtype != cp.uint8:
-            y_test = cp.array(y_test, copy=False).astype(cp.uint8, copy=False)
-    elif len(y_test[0]) <= 32767:
-        if y_test.dtype != cp.uint16:
-            y_test = cp.array(y_test, copy=False).astype(cp.uint16, copy=False)
     else:
-        if y_test.dtype != cp.uint32:
-            y_test = cp.array(y_test, copy=False).astype(cp.uint32, copy=False)
+        raise ValueError("memory parameter must be 'cpu' or 'gpu'.")
+
 
     if early_shifting != False:
         shift_patience = early_shifting
@@ -297,13 +330,13 @@ def learner(x_train, y_train, x_test=None, y_test=None, strategy='accuracy', bat
     else:
         best_activations = start_this
         x_test_batch, y_test_batch = batcher(x_test, y_test, batch_size=batch_size)
-        W = fit(x_train, y_train, activation_potentiation=best_activations, train_bar=False, auto_normalization=auto_normalization, dtype=dtype)
-        model = evaluate(x_test_batch, y_test_batch, W=W, loading_bar_status=False, activation_potentiation=activations, dtype=dtype)
-        
+        W = fit(x_train, y_train, activation_potentiation=best_activations, train_bar=False, auto_normalization=auto_normalization, dtype=dtype, memory=memory)
+        model = evaluate(x_test_batch, y_test_batch, W=W, loading_bar_status=False, activation_potentiation=activations, dtype=dtype, memory=memory)
+
         if loss == 'categorical_crossentropy':
-            test_loss = categorical_crossentropy(y_true_batch=y_test_batch, y_pred_batch=model[get_preds_softmax()])
+            test_loss = categorical_crossentropy(y_true_batch=transfer_to_gpu(y_test_batch, dtype=y_test_batch.dtype), y_pred_batch=model[get_preds_softmax()])
         else:
-            test_loss = binary_crossentropy(y_true_batch=y_test_batch, y_pred_batch=model[get_preds_softmax()])
+            test_loss = binary_crossentropy(y_true_batch=transfer_to_gpu(y_test_batch, dtype=y_test_batch.dtype), y_pred_batch=model[get_preds_softmax()])
 
         best_acc = model[get_acc()]
         best_loss = test_loss
@@ -327,22 +360,22 @@ def learner(x_train, y_train, x_test=None, y_test=None, strategy='accuracy', bat
             activations.append(activation_potentiation[j])
 
             x_test_batch, y_test_batch = batcher(x_test, y_test, batch_size=batch_size)
-            W = fit(x_train, y_train, activation_potentiation=activations, train_bar=False, auto_normalization=auto_normalization, dtype=dtype)
-            model = evaluate(x_test_batch, y_test_batch, W=W, loading_bar_status=False, activation_potentiation=activations, dtype=dtype)
+            W = fit(x_train, y_train, activation_potentiation=activations, train_bar=False, auto_normalization=auto_normalization, dtype=dtype, memory=memory)
+            model = evaluate(x_test_batch, y_test_batch, W=W, loading_bar_status=False, activation_potentiation=activations, dtype=dtype, memory=memory)
 
             acc = model[get_acc()]
 
             if strategy == 'loss' or strategy == 'all':
                 if loss == 'categorical_crossentropy':
-                    test_loss = categorical_crossentropy(y_true_batch=y_test_batch, y_pred_batch=model[get_preds_softmax()])
+                    test_loss = categorical_crossentropy(y_true_batch=transfer_to_gpu(y_test_batch, dtype=y_test_batch.dtype), y_pred_batch=model[get_preds_softmax()])
                 else:
-                    test_loss = binary_crossentropy(y_true_batch=y_test_batch, y_pred_batch=model[get_preds_softmax()])
+                    test_loss = binary_crossentropy(y_true_batch=transfer_to_gpu(y_test_batch, dtype=y_test_batch.dtype), y_pred_batch=model[get_preds_softmax()])
 
                 if i == 0 and j == 0 and start_this is None:
                     best_loss = test_loss
 
             if strategy == 'f1' or strategy == 'precision' or strategy == 'recall' or strategy == 'all':
-                precision_score, recall_score, f1_score = metrics(y_test_batch, model[get_preds()])
+                precision_score, recall_score, f1_score = metrics(transfer_to_gpu(y_test_batch, dtype=y_test_batch.dtype), model[get_preds()])
 
                 if strategy == 'precision' or strategy == 'all':
                     if i == 0 and j == 0:
@@ -391,9 +424,9 @@ def learner(x_train, y_train, x_test=None, y_test=None, strategy='accuracy', bat
 
                 if strategy != 'loss':
                     if loss == 'categorical_crossentropy':
-                        test_loss = categorical_crossentropy(y_true_batch=y_test_batch, y_pred_batch=model[get_preds_softmax()])
+                        test_loss = categorical_crossentropy(y_true_batch=transfer_to_gpu(y_test_batch, dtype=y_test_batch.dtype), y_pred_batch=model[get_preds_softmax()])
                     else:
-                        test_loss = binary_crossentropy(y_true_batch=y_test_batch, y_pred_batch=model[get_preds_softmax()])
+                        test_loss = binary_crossentropy(y_true_batch=transfer_to_gpu(y_test_batch, dtype=y_test_batch.dtype), y_pred_batch=model[get_preds_softmax()])
 
                 if batch_size == 1:
                     postfix_dict[f"{data} Loss"] = test_loss
@@ -411,7 +444,7 @@ def learner(x_train, y_train, x_test=None, y_test=None, strategy='accuracy', bat
 
                 if neurons_history:
                     viz_objects['neurons']['artists'] = (
-                        neuron_history(cp.copy(best_weights), viz_objects['neurons']['ax'],
+                        update_neuron_history_for_learner(cp.copy(best_weights), 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'],
@@ -593,7 +626,8 @@ def evaluate(
     activation_potentiation=['linear'],
     loading_bar_status=True,
     show_metrics=False,
-    dtype=cp.float32
+    dtype=cp.float32,
+    memory='gpu'
 ) -> tuple:
     """
     Evaluates the neural network model using the given test data.
@@ -613,45 +647,43 @@ def evaluate(
 
         dtype (cupy.dtype): Data type for the arrays. cp.float32 by default. Example: cp.float64 or cp.float16. [fp32 for balanced devices, fp64 for strong devices, fp16 for weak devices: not reccomended!] (optional)
 
+        memory (str): The memory parameter determines whether the dataset to be processed on the GPU will be stored in the CPU's RAM or the GPU's RAM. Options:  'gpu', 'cpu'. Default: 'gpu'.
+
     Returns:
         tuple: Model (list).
     """
+    from memory_operations import transfer_to_cpu, transfer_to_gpu
 
-    x_test = cp.array(x_test, copy=False).astype(dtype, copy=False)
+    if memory == 'gpu':
+        x_test = transfer_to_gpu(x_test, dtype=dtype)
+        y_test = transfer_to_gpu(y_test, dtype=y_test.dtype)
 
-    if len(y_test[0]) < 256:
-        y_type = cp.uint8
-        if y_test.dtype != cp.uint8:
-            y_test = cp.array(y_test, copy=False).astype(cp.uint8, copy=False)
-    elif len(y_test[0]) <= 32767:
-        y_type = cp.uint16
-        if y_test.dtype != cp.uint16:
-            y_test = cp.array(y_test, copy=False).astype(cp.uint16, copy=False)
-    else:
-        y_type = cp.uint32
-        if y_test.dtype != cp.uint32:
-            y_test = cp.array(y_test, copy=False).astype(cp.uint32, copy=False)
+    elif memory == 'cpu':
+        x_test = transfer_to_cpu(x_test, dtype=dtype)
+        y_test = transfer_to_cpu(y_test, dtype=y_test.dtype)
 
+    else:
+        raise ValueError("memory parameter must be 'cpu' or 'gpu'.")
 
     predict_probabilitys = cp.empty((len(x_test), W.shape[0]), dtype=dtype)
-    real_classes = cp.empty(len(x_test), dtype=y_type)   
-    predict_classes = cp.empty(len(x_test), dtype=y_type)      
+    real_classes = cp.empty(len(x_test), dtype=y_test.dtype)   
+    predict_classes = cp.empty(len(x_test), dtype=y_test.dtype)
 
     true_predict = 0
-    acc_list = cp.empty(len(x_test), dtype=dtype)       
+    acc_list = cp.empty(len(x_test), dtype=dtype)
 
     if loading_bar_status:
         loading_bar = initialize_loading_bar(total=len(x_test), ncols=64, desc='Testing', bar_format=bar_format_normal)
 
     for inpIndex in range(len(x_test)):
-        Input = x_test[inpIndex].ravel()
+        Input = transfer_to_gpu(x_test[inpIndex], dtype=dtype).ravel()
         neural_layer = Input
 
         neural_layer = feed_forward(neural_layer, cp.copy(W), is_training=False, Class='?', activation_potentiation=activation_potentiation)
 
         predict_probabilitys[inpIndex] = Softmax(neural_layer)
 
-        RealOutput = cp.argmax(y_test[inpIndex])
+        RealOutput = decode_one_hot(transfer_to_gpu(y_test[inpIndex], dtype=y_test[inpIndex].dtype))
         real_classes[inpIndex] = RealOutput
         PredictedOutput = cp.argmax(neural_layer)
         predict_classes[inpIndex] = PredictedOutput