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

pyerualjetwork/memory_operations.py

@@ -0,0 +1,303 @@
+import psutil
+import numpy as np
+import cupy as cp
+import logging
+
+def get_available_cpu_memory():
+    """
+    The function `get_available_memory` returns the amount of available memory in the system using the
+    `psutil` library.
+    :return: The function `get_available_memory()` returns the amount of available memory in bytes on
+    the system.
+    """
+    return psutil.virtual_memory().available
+
+def get_optimal_batch_size_for_cpu(x, data_size_bytes, available_memory):
+    """
+    The function calculates the optimal batch size for a given data size and available memory based on
+    the size of each element.
+    
+    :param x: `x` is a NumPy array representing the input data for which we want to determine the
+    optimal batch size for processing on the CPU
+    :param data_size_bytes: The `data_size_bytes` parameter represents the size of the data in bytes
+    that you want to process in batches
+    :param available_memory: The `available_memory` parameter represents the total memory available on
+    the CPU in bytes. This function calculates the optimal batch size for processing data based on the
+    provided parameters. Let me know if you need any further assistance or explanation!
+    :return: the optimal batch size for a given array `x` based on the available memory and the size of
+    each element in bytes.
+    """
+    safe_memory = available_memory * 0.25
+    element_size = data_size_bytes / x.size
+    return int(safe_memory / (element_size * 2))
+
+def transfer_to_cpu(x, dtype=np.float32):
+    """
+    The `transfer_to_cpu` function converts data to a specified data type on the CPU, handling memory constraints
+    by batching the conversion process and ensuring complete GPU memory cleanup.
+   
+    :param x: Input data to transfer to CPU (CuPy array)
+    :param dtype: Target NumPy dtype for the output array (default: np.float32)
+    :return: NumPy array with the specified dtype
+    """
+    from .ui import loading_bars, initialize_loading_bar
+    try:
+        if isinstance(x, np.ndarray):
+            return x.astype(dtype) if x.dtype != dtype else x
+
+        x = x.astype(dtype=dtype, copy=False)
+        
+        data_size = x.nbytes
+        available_memory = get_available_cpu_memory()
+        logging.debug(f"Data size: {data_size/1e6:.2f}MB, Available memory: {available_memory/1e6:.2f}MB")
+        
+        pool = cp.get_default_memory_pool()
+        pinned_mempool = cp.cuda.PinnedMemoryPool()
+        
+        if data_size <= available_memory * 0.25:
+            try:
+                final_result = np.array(x.get(), dtype=dtype, copy=False)
+            finally:
+                del x
+                pool.free_all_blocks()
+                pinned_mempool.free_all_blocks()
+                cp.cuda.runtime.deviceSynchronize()
+            return final_result
+        
+        batch_size = max(get_optimal_batch_size_for_cpu(x, data_size, available_memory), 1)
+        total_batches = (len(x) + batch_size - 1) // batch_size
+        loading_bar = initialize_loading_bar(
+            total=total_batches,
+            desc='Transfering to CPU mem',
+            ncols=70,
+            bar_format=loading_bars()[0],
+            leave=False
+        )
+        logging.debug(f"Using batch size: {batch_size}")
+        
+        try:
+            sample_chunk = x[0:1]
+            sample_array = np.array(sample_chunk.get(), dtype=dtype)
+            chunk_shape = sample_array.shape[1:] if len(sample_array.shape) > 1 else ()
+            total_shape = (len(x),) + chunk_shape
+        finally:
+            del sample_array
+            del sample_chunk
+            pool.free_all_blocks()
+            pinned_mempool.free_all_blocks()
+        
+        chunks = np.empty(total_shape, dtype=dtype)
+        
+        try:
+            for i in range(0, len(x), batch_size):
+                try:
+                    end_idx = min(i + batch_size, len(x))
+                    chunk = x[i:end_idx]
+                    chunks[i:end_idx] = chunk.get().astype(dtype=dtype)
+                finally:
+                    del chunk
+                    pool.free_all_blocks()
+                    pinned_mempool.free_all_blocks()
+                    cp.cuda.runtime.deviceSynchronize()
+                
+                loading_bar.update(1)
+        finally:
+            del x
+            pool.free_all_blocks()
+            pinned_mempool.free_all_blocks()
+            cp.cuda.runtime.deviceSynchronize()
+        
+        return chunks
+        
+    except Exception as e:
+        logging.error(f"Error in transfer_to_cpu: {str(e)}")
+        if 'x' in locals():
+            del x
+        if 'pool' in locals():
+            pool.free_all_blocks()
+        if 'pinned_mempool' in locals():
+            pinned_mempool.free_all_blocks()
+        cp.cuda.runtime.deviceSynchronize()
+        raise
+
+def get_optimal_batch_size_for_gpu(x, data_size_bytes):
+    """
+    The function calculates the optimal batch size for a GPU based on available memory and data size.
+    
+    :param x: A list or array containing the data elements that will be processed on the GPU
+    :param data_size_bytes: The `data_size_bytes` parameter represents the total size of the data in
+    bytes that you want to process on the GPU. This could be the size of a single batch of data or the
+    total size of the dataset, depending on how you are structuring your computations
+    :return: the optimal batch size that can be used for processing the given data on the GPU, based on
+    the available free memory on the GPU and the size of the data elements.
+    """
+    free_memory = cp.get_default_memory_pool().free_bytes()
+    device_memory = cp.cuda.runtime.memGetInfo()[0]
+    safe_memory = min(free_memory, device_memory) * 0.25
+    
+    element_size = data_size_bytes / len(x)
+    return int(safe_memory / (element_size * 2))
+
+
+def transfer_to_gpu(x, dtype=cp.float32):
+    """
+    The `transfer_to_gpu` function in Python converts input data to GPU arrays, optimizing memory usage by
+    batching and handling out-of-memory errors.
+    
+    :param x: The `x` parameter in the `transfer_to_gpu` function is the input data that you want to transfer to
+    the GPU for processing. It can be either a NumPy array or a CuPy array. If it's a NumPy array, the
+    function will convert it to a CuPy array and
+    :param dtype: The `dtype` parameter in the `transfer_to_gpu` function specifies the data type to which the
+    input array `x` should be converted when moving it to the GPU. By default, it is set to
+    `cp.float32`, which is a 32-bit floating-point data type provided by the Cu
+    :return: The `transfer_to_gpu` function returns the input data `x` converted to a GPU array of type `dtype`
+    (default is `cp.float32`). If the input `x` is already a GPU array with the same dtype, it returns
+    `x` as is. If the data size of `x` exceeds 25% of the free GPU memory, it processes the data in
+    batches to
+    """
+    from .ui import loading_bars, initialize_loading_bar
+    try:
+        if isinstance(x, cp.ndarray):
+            return x.astype(dtype) if x.dtype != dtype else x
+            
+        x = x.astype(dtype=dtype, copy=False)
+        data_size = x.nbytes
+        pinned_mempool = cp.cuda.PinnedMemoryPool()
+        free_gpu_memory = cp.cuda.runtime.memGetInfo()[0]
+        logging.debug(f"Data size: {data_size/1e6:.2f}MB, Free GPU memory: {free_gpu_memory/1e6:.2f}MB")
+
+        if data_size <= free_gpu_memory * 0.25:
+            new_x = cp.array(x, dtype=dtype, copy=False)
+            return new_x
+            
+        batch_size = get_optimal_batch_size_for_gpu(x, data_size)
+        if batch_size == 0: batch_size = 1
+
+        loading_bar = initialize_loading_bar(total=len(x)/batch_size, desc='Transfering to GPU mem', ncols=70, bar_format=loading_bars()[0], leave=False)
+        
+        logging.debug(f"Using batch size: {batch_size}")
+        current_threshold = 0.75
+        total_batches = (len(x) + batch_size - 1) // batch_size
+
+        sample_chunk = x[0:1]
+        sample_array = cp.array(sample_chunk, dtype=dtype)
+        chunk_shape = sample_array.shape[1:] if len(sample_array.shape) > 1 else ()
+        del sample_array
+        del sample_chunk
+        if chunk_shape:
+            total_shape = (len(x),) + chunk_shape
+        else:
+            total_shape = (len(x),)
+        
+        del chunk_shape
+        chunks = cp.empty(total_shape, dtype=dtype)
+        del total_shape
+
+        for i in range(0, len(x), batch_size):
+            try:
+                chunk = x[i:i + batch_size]
+                chunk = cp.array(chunk, dtype=dtype)
+                chunks[i // batch_size] = chunk
+                del chunk
+                pinned_mempool.free_all_blocks()
+
+                if i > 0 and i % (batch_size * 5) == 0:
+                    pool = cp.get_default_memory_pool()
+                    current_threshold = adjust_gpu_memory_threshold(pool, free_gpu_memory, current_threshold)
+                    if pool.used_bytes() > cp.cuda.runtime.memGetInfo()[0] * current_threshold:
+                        pool.free_all_blocks()
+                    
+                    
+                loading_bar.update(1)
+                    
+            except cp.cuda.memory.OutOfMemoryError:
+                logging.error(f"GPU out of memory at batch {i//batch_size + 1}/{total_batches}")
+                cp.get_default_memory_pool().free_all_blocks()
+                batch_size = max(batch_size // 2, 1)
+                continue
+                
+            except Exception as e:
+                logging.error(f"Error processing batch {i//batch_size + 1}/{total_batches}: {str(e)}")
+                raise
+                
+        try:
+            del x
+            cp.get_default_memory_pool().free_all_blocks()
+            pinned_mempool.free_all_blocks()
+            return chunks
+            
+        except Exception as e:
+            logging.error(f"Error concatenating results: {str(e)}")
+            raise
+            
+    except Exception as e:
+        logging.error(f"Error in transfer_to_gpu: {str(e)}")
+        raise
+
+def adjust_gpu_memory_threshold(pool, free_gpu_memory, current_threshold=0.75, min_threshold=0.5, max_threshold=0.9):
+    used_memory = pool.used_bytes()
+    usage_ratio = used_memory / free_gpu_memory
+    
+    if usage_ratio > current_threshold:
+        current_threshold = max(min_threshold, current_threshold - 0.05)
+    elif usage_ratio < current_threshold * 0.8:
+        current_threshold = min(max_threshold, current_threshold + 0.05)
+
+    return current_threshold
+
+
+def optimize_labels(y, one_hot_encoded=True, cuda=False):
+    """
+    The function `optimize_labels` optimizes the data type of labels based on their length and encoding
+    format.
+    
+    :param y: The `optimize_labels` function is designed to optimize the data type of the input labels
+    `y` based on certain conditions. The function checks if the labels are in one-hot encoded format or
+    not, and then based on the length of the labels and the specified data types (`uint8`, `uint
+    :param one_hot_encoded: The `one_hot_encoded` parameter in the `optimize_labels` function indicates
+    whether the labels are in one-hot encoded format or not. If `one_hot_encoded` is set to `True`, it
+    means that the labels are in one-hot encoded format, and the function will check the length of the,
+    defaults to True (optional)
+    :param cuda: The `cuda` parameter in the `optimize_labels` function is a boolean flag that indicates
+    whether to use CUDA for computations. If `cuda` is set to `True`, the function will use the CuPy
+    library for array operations, which can leverage GPU acceleration. If `cuda` is `False, defaults to
+    False (optional)
+    :return: The function `optimize_labels` returns the input array `y` after optimizing its data type
+    based on the specified conditions. If `one_hot_encoded` is True, it checks the length of the
+    elements in `y` and converts the data type to uint8, uint16, or uint32 accordingly. If
+    `one_hot_encoded` is False, it checks the length of `y` itself and
+    """
+
+    if cuda: array_type = cp
+    else: array_type = np
+
+    dtype_uint8 = array_type.uint8
+    dtype_uint16 = array_type.uint16
+    dtype_uint32 = array_type.uint32
+
+    if one_hot_encoded:
+        if len(y[0]) < 256:
+            if y.dtype != dtype_uint8:
+                y = array_type.array(y, copy=False).astype(dtype_uint8, copy=False)
+        elif len(y[0]) <= 32767:
+            if y.dtype != dtype_uint16:
+                y = array_type.array(y, copy=False).astype(dtype_uint16, copy=False)
+        else:
+            if y.dtype != dtype_uint32:
+                y = array_type.array(y, copy=False).astype(dtype_uint32, copy=False)
+
+        return y
+
+    else:
+
+        if len(y) < 256:
+            if y.dtype != dtype_uint8:
+                y = array_type.array(y, copy=False).astype(dtype_uint8, copy=False)
+        elif len(y) <= 32767:
+            if y.dtype != dtype_uint16:
+                y = array_type.array(y, copy=False).astype(dtype_uint16, copy=False)
+        else:
+            if y.dtype != dtype_uint32:
+                y = array_type.array(y, copy=False).astype(dtype_uint32, copy=False)
+
+        return y

pyerualjetwork/metrics_cuda.py

@@ -80,7 +80,7 @@ def roc_curve(y_true, y_score):
         raise ValueError("Only binary classification is supported.")
 
     
-    desc_score_indices = cp.argsort(y_score, kind="mergesort")[::-1]
+    desc_score_indices = cp.argsort(y_score, kind="stable")[::-1]
     y_score = y_score[desc_score_indices]
     y_true = y_true[desc_score_indices]
 
@@ -93,11 +93,10 @@ def roc_curve(y_true, y_score):
 
     tp = 0
     fp = 0
-    prev_score = None
+    prev_score = 0
 
-    
     for i, score in enumerate(y_score):
-        if score != prev_score:
+        if score is not prev_score:
             fpr.append(fp / n_neg)
             tpr.append(tp / n_pos)
             thresholds.append(score)

pyerualjetwork/model_operations.py

@@ -17,7 +17,7 @@ def save_model(model_name,
                activation_potentiation=['linear'],
                weights_type='npy',
                weights_format='raw',
-               show_architecture=None,
+               show_architecture=False,
                show_info=True
                ):
 
@@ -44,7 +44,7 @@ def save_model(model_name,
 
     activation_potentiation (list): For deeper PLAN networks, activation function parameters. For more information please run this code: plan.activations_list() default: ['linear']
 
-    show_architecture (str): It draws model architecture. Takes 2 value='basic' or 'detailed'. Default: None(not drawing)
+    show_architecture (bool): It draws model architecture. True or False. Default: False
 
     show_info (bool): Prints model details into console. default: True
 
@@ -170,8 +170,8 @@ def save_model(model_name,
         
         print(message)
 
-    if show_architecture is not None:
-        draw_model_architecture(model_name=model_name, model_path=model_path, style=show_architecture)
+    if show_architecture:
+        draw_model_architecture(model_name=model_name, model_path=model_path)
 
 
 
@@ -190,7 +190,6 @@ def load_model(model_name,
    Returns:
    lists: W(list[num]), activation_potentiation, DataFrame of the model
     """
-    np.set_printoptions(threshold=np.Infinity)
 
     try:
 

pyerualjetwork/model_operations_cuda.py

@@ -1,4 +1,5 @@
 import cupy as cp
+import numpy as np
 from colorama import Fore, Style
 import sys
 from datetime import datetime
@@ -44,7 +45,7 @@ def save_model(model_name,
 
     activation_potentiation (list): For deeper PLAN networks, activation function parameters. For more information please run this code: plan.activations_list() default: ['linear']
 
-    show_architecture (str): It draws model architecture. Takes 2 value='basic' or 'detailed'. Default: None(not drawing)
+    show_architecture (bool): It draws model architecture. True or False. Default: False
 
     show_info (bool): Prints model details into console. default: True
 
@@ -173,8 +174,8 @@ def save_model(model_name,
         
         print(message)
 
-    if show_architecture is not None:
-        draw_model_architecture(model_name=model_name, model_path=model_path, style=show_architecture)
+    if show_architecture:
+        draw_model_architecture(model_name=model_name, model_path=model_path)
 
 
 
@@ -213,12 +214,12 @@ def load_model(model_name,
         if scaler_params_cpu[0] == None: # model not scaled
             scaler_params = scaler_params_cpu[0]
 
-    except:
+    except: # model scaled
+        scaler_params_cpu = [item for item in scaler_params_cpu if isinstance(item, np.ndarray)]
         scaler_params = cp.array(scaler_params_cpu)
+
         del scaler_params_cpu
         gc.collect()
-        scaler_params = [item for item in scaler_params if isinstance(item, cp.ndarray)] # model scaled
-
      
     model_name = str(df['MODEL NAME'].iloc[0])
     WeightType = str(df['WEIGHTS TYPE'].iloc[0])

pyerualjetwork/plan.py

@@ -15,6 +15,7 @@ ANAPLAN document: https://github.com/HCB06/Anaplan/blob/main/Welcome_to_Anaplan/
 
 import numpy as np
 from colorama import Fore
+import math
 
 ### LIBRARY IMPORTS ###
 from .ui import loading_bars, initialize_loading_bar
@@ -25,8 +26,9 @@ from .metrics import metrics
 from .model_operations import get_acc, get_preds, get_preds_softmax
 from .visualizations 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 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 ###
@@ -98,20 +102,13 @@ def fit(
     Returns:
         numpyarray([num]): (Weight matrix).
     """
+    
+    from model_operations import get_acc
+
     # Pre-checks
 
     x_train = x_train.astype(dtype, copy=False)
 
-    if len(y_train[0]) < 256:
-        if y_train.dtype != np.uint8:
-            y_train = np.array(y_train, copy=False).astype(np.uint8, copy=False)
-    elif len(y_train[0]) <= 32767:
-        if y_train.dtype != np.uint16:
-            y_train = np.array(y_train, copy=False).astype(np.uint16, copy=False)
-    else:
-        if y_train.dtype != np.uint32:
-            y_train = np.array(y_train, copy=False).astype(np.uint32, copy=False)
-
     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:
@@ -137,18 +134,25 @@ def fit(
 
     # Training process
     for index, inp in enumerate(x_train):
-        inp = np.array(inp, copy=False, dtype=dtype).ravel()
+        inp = np.array(inp, copy=False).ravel()
         y_decoded = decode_one_hot(y_train)
         # Weight updates
         STPW = feed_forward(inp, STPW, is_training=True, Class=y_decoded[index], 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)[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)
 
@@ -156,7 +160,15 @@ def fit(
 
     # 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)
 
@@ -223,7 +235,7 @@ def learner(x_train, y_train, x_test=None, y_test=None, strategy='accuracy', bat
         tuple: A list for model parameters: [Weight matrix, Test loss, Test Accuracy, [Activations functions]].
     
     """
-    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)
+    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()
 
@@ -420,7 +432,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(np.copy(best_weights), viz_objects['neurons']['ax'],
+                        update_neuron_history_for_learner(np.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'],