pyerualjetwork 4.1.5__py3-none-any.whl → 4.1.7__py3-none-any.whl

pyerualjetwork/__init__.py

@@ -14,7 +14,8 @@ package_names = [
     'numpy==1.26.4',
     'matplotlib==3.9.0',
     'colorama==0.4.6',
-    'psutil==6.1.1'
+    'psutil==6.1.1',
+    'cupy-cuda12x==13.3.0'
 ]
 
 installed_packages = pkg_resources.working_set
@@ -47,8 +48,8 @@ for package_name in package_names:
 
 print(f"PyerualJetwork is ready to use with {err} errors")
 
-__version__ = "4.1.5"
-__update__ = "* Note: CUDA modules need cupy. Enter this command in your terminal: 'pip install cupy-cuda12x' or your cuda version.\n* Changes: https://github.com/HCB06/PyerualJetwork/blob/main/CHANGES\n* PyerualJetwork document: https://github.com/HCB06/Anaplan/blob/main/Welcome_to_PyerualJetwork/PYERUALJETWORK_USER_MANUEL_AND_LEGAL_INFORMATION(EN).pdf\n* YouTube tutorials: https://www.youtube.com/@HasanCanBeydili"
+__version__ = "4.1.7"
+__update__ = "* Changes: https://github.com/HCB06/PyerualJetwork/blob/main/CHANGES\n* PyerualJetwork document: https://github.com/HCB06/PyerualJetwork/blob/main/Welcome_to_PyerualJetwork/PYERUALJETWORK_USER_MANUEL_AND_LEGAL_INFORMATION(EN).pdf\n* YouTube tutorials: https://www.youtube.com/@HasanCanBeydili"
 
 def print_version(__version__):
     print(f"PyerualJetwork Version {__version__}" + '\n')

pyerualjetwork/activation_functions_cuda.py

@@ -37,7 +37,7 @@ def Softmax(
     Returns:
        (num): Transformed data after applying softmax function.
     """
-
+    
     return cp.array(softmax(x.get()))
 
 

pyerualjetwork/data_operations.py

@@ -16,26 +16,10 @@ def encode_one_hot(y_train, y_test=None, summary=False):
     Returns:
         tuple: One-hot encoded y_train and (if given) y_test.
     """
-    if len(y_train) < 256:
-        if y_train.dtype != np.uint8:
-            y_train = np.array(y_train, copy=False).astype(np.uint8, copy=False)
-    elif len(y_train) <= 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 y_test is not None:
-        if len(y_test) < 256:
-            if y_test.dtype != np.uint8:
-                y_test = np.array(y_test, copy=False).astype(np.uint8, copy=False)
-        elif len(y_test) <= 32767:
-            if y_test.dtype != np.uint16:
-                y_test = np.array(y_test, copy=False).astype(np.uint16, copy=False)
-        else:
-            if y_test.dtype != np.uint32:
-                y_test = np.array(y_test, copy=False).astype(np.uint32, copy=False)
+    from .memory_operations import optimize_labels
+    
+    y_train = optimize_labels(y_train, one_hot_encoded=False, cuda=False)
+    y_test = optimize_labels(y_test, one_hot_encoded=False, cuda=False)
 
     classes = np.unique(y_train)
     class_count = len(classes)
@@ -47,12 +31,12 @@ def encode_one_hot(y_train, y_test=None, summary=False):
         for cls, idx in class_to_index.items():
             print(f"  {idx}: {cls}")
 
-    y_train_encoded = np.zeros((y_train.shape[0], class_count))
+    y_train_encoded = np.zeros((y_train.shape[0], class_count), dtype=y_train.dtype)
     for i, label in enumerate(y_train):
         y_train_encoded[i, class_to_index[label]] = 1
 
     if y_test is not None:
-        y_test_encoded = np.zeros((y_test.shape[0], class_count))
+        y_test_encoded = np.zeros((y_test.shape[0], class_count), dtype=y_test.dtype)
         for i, label in enumerate(y_test):
             y_test_encoded[i, class_to_index[label]] = 1
         return y_train_encoded, y_test_encoded
@@ -90,16 +74,10 @@ def split(X, y, test_size, random_state=42, dtype=np.float32):
     Returns:
         tuple: x_train, x_test, y_train, y_test as ordered training and testing data subsets.
     """
-    X = X.astype(dtype)
-    if len(y) < 256:
-        if y.dtype != np.uint8:
-            y = np.array(y, copy=False).astype(np.uint8, copy=False)
-    elif len(y) <= 32767:
-        if y.dtype != np.uint16:
-            y = np.array(y, copy=False).astype(np.uint16, copy=False)
-    else:
-        if y.dtype != np.uint32:
-            y = np.array(y, copy=False).astype(np.uint32, copy=False)
+    from .memory_operations import transfer_to_cpu, optimize_labels
+    
+    X = transfer_to_cpu(X, dtype=dtype)
+    y = optimize_labels(y, one_hot_encoded=False, cuda=False)
 
     num_samples = X.shape[0]
 
@@ -124,6 +102,8 @@ def split(X, y, test_size, random_state=42, dtype=np.float32):
     x_train, x_test = X[train_indices], X[test_indices]
     y_train, y_test = y[train_indices], y[test_indices]
 
+    del X, y
+
     return x_train, x_test, y_train, y_test
 
 
@@ -142,20 +122,11 @@ def manuel_balancer(x_train, y_train, target_samples_per_class, dtype=np.float32
     y_balanced -- Balanced class labels (one-hot encoded, NumPy array format)
     """
     from .ui import loading_bars
-
-    bar_format = loading_bars()[0]
+    from .memory_operations import transfer_to_cpu
     
-    x_train = np.array(x_train, copy=False).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)
+    x_train = transfer_to_cpu(x_train, dtype=dtype)
 
+    bar_format = loading_bars()[0]
     classes = np.arange(y_train.shape[1])
     class_count = len(classes)
     
@@ -181,8 +152,8 @@ def manuel_balancer(x_train, y_train, target_samples_per_class, dtype=np.float32
             if num_samples < target_samples_per_class:
                 
                 samples_to_add = target_samples_per_class - num_samples
-                additional_samples = np.zeros((samples_to_add, x_train.shape[1]))
-                additional_labels = np.zeros((samples_to_add, y_train.shape[1]))
+                additional_samples = np.zeros((samples_to_add, x_train.shape[1]), dtype=x_train.dtype)
+                additional_labels = np.zeros((samples_to_add, y_train.shape[1]), dtype=y_train.dtype)
                 
                 for i in range(samples_to_add):
 
@@ -200,10 +171,12 @@ def manuel_balancer(x_train, y_train, target_samples_per_class, dtype=np.float32
                 x_balanced.append(additional_samples)
                 y_balanced.append(additional_labels)
     
-    x_balanced = np.vstack(x_balanced)
-    y_balanced = np.vstack(y_balanced)
+    x_balanced = np.vstack(x_balanced, dtype=x_train.dtype)
+    y_balanced = np.vstack(y_balanced, dtype=y_train.dtype)
+
+    del x_train, y_train
 
-    return x_balanced.astype(dtype), y_balanced.astype(dtype)
+    return x_balanced, y_balanced
 
 
 def auto_balancer(x_train, y_train, dtype=np.float32):
@@ -220,20 +193,11 @@ def auto_balancer(x_train, y_train, dtype=np.float32):
    tuple: A tuple containing balanced input data and labels.
     """
     from .ui import loading_bars
-
-    bar_format = loading_bars()[0]
+    from .memory_operations import transfer_to_cpu
     
-    x_train = np.array(x_train, copy=False).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)
+    x_train = transfer_to_cpu(x_train, dtype=dtype)
 
+    bar_format = loading_bars()[0]
     classes = np.arange(y_train.shape[1])
     class_count = len(classes)
     
@@ -271,10 +235,15 @@ def auto_balancer(x_train, y_train, dtype=np.float32):
         print(Fore.RED + "ERROR: Inputs and labels must be same length check parameters")
         sys.exit()
 
-    return BalancedInputs.astype(dtype, copy=False), BalancedLabels.astype(dtype, copy=False)
+    BalancedInputs = BalancedInputs.astype(dtype, copy=False)
+    BalancedLabels = BalancedLabels.astype(dtype=y_train.dtype, copy=False)
 
+    del x_train, y_train
 
-def synthetic_augmentation(x_train, y_train, dtype=np.float32):
+    return BalancedInputs, BalancedLabels
+
+
+def synthetic_augmentation(x, y, dtype=np.float32):
     """
     Generates synthetic examples to balance classes with fewer examples.
 
@@ -288,24 +257,12 @@ def synthetic_augmentation(x_train, y_train, dtype=np.float32):
     y_balanced -- Balanced class labels (one-hot encoded, array format)
     """
     from .ui import loading_bars
-
-    bar_format = loading_bars()[0]
+    from .memory_operations import transfer_to_cpu
     
-    x_train = x_train.astype(dtype)
-    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)
-
-    x = x_train
-    y = y_train
+    x = transfer_to_cpu(x, dtype=dtype)
 
-    classes = np.arange(y_train.shape[1])
+    bar_format = loading_bars()[0]
+    classes = np.arange(y.shape[1])
     class_count = len(classes)
 
     class_distribution = {i: 0 for i in range(class_count)}
@@ -340,8 +297,12 @@ def synthetic_augmentation(x_train, y_train, dtype=np.float32):
 
                 num_samples += 1
 
+    x_balanced = np.array(x_balanced).astype(dtype, copy=False)
+    y_balanced = np.array(y_balanced).astype(dtype=y.dtype, copy=False)
+    
+    del x, y
 
-    return np.array(x_balanced).astype(dtype, copy=False), np.array(y_balanced).astype(dtype, copy=False)
+    return x_balanced, y_balanced
 
 
 def standard_scaler(x_train=None, x_test=None, scaler_params=None, dtype=np.float32):

pyerualjetwork/data_operations_cuda.py

@@ -17,29 +17,13 @@ def encode_one_hot(y_train, y_test=None, summary=False):
         tuple: One-hot encoded y_train and (if given) y_test.
     """
 
-    if len(y_train) < 256:
-        if y_train.dtype != cp.uint8:
-            y_train = cp.array(y_train, copy=False).astype(cp.uint8, copy=False)
-    elif len(y_train) <= 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 y_test is not None:
-        if len(y_test) < 256:
-            if y_test.dtype != cp.uint8:
-                y_test = cp.array(y_test, copy=False).astype(cp.uint8, copy=False)
-        elif len(y_test) <= 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)
+    from .memory_operations import optimize_labels, transfer_to_cpu
+    
+    y_train = optimize_labels(y_train, one_hot_encoded=False, cuda=True)
+    y_test = optimize_labels(y_test, one_hot_encoded=False, cuda=True)
 
-    y_train = y_train.get()
-    y_test = y_test.get()
+    y_train = transfer_to_cpu(y_train,dtype=y_train.dtype)
+    y_test = transfer_to_cpu(y_test,dtype=y_test.dtype)
 
     classes = np.unique(y_train)
     class_count = len(classes)
@@ -51,17 +35,17 @@ def encode_one_hot(y_train, y_test=None, summary=False):
         for cls, idx in class_to_index.items():
             print(f"  {idx}: {cls}")
 
-    y_train_encoded = np.zeros((y_train.shape[0], class_count))
+    y_train_encoded = np.zeros((y_train.shape[0], class_count), dtype=y_train.dtype)
     for i, label in enumerate(y_train):
         y_train_encoded[i, class_to_index[label]] = 1
 
     if y_test is not None:
-        y_test_encoded = np.zeros((y_test.shape[0], class_count))
+        y_test_encoded = np.zeros((y_test.shape[0], class_count), dtype=y_test.dtype)
         for i, label in enumerate(y_test):
             y_test_encoded[i, class_to_index[label]] = 1
-        return cp.array(y_train_encoded), cp.array(y_test_encoded)
+        return cp.array(y_train_encoded, dtype=y_train.dtype), cp.array(y_test_encoded, dtype=y_test.dtype)
 
-    return cp.array(y_train_encoded)
+    return cp.array(y_train_encoded, dtype=y_train.dtype)
 
 
 def decode_one_hot(encoded_data):
@@ -75,36 +59,34 @@ def decode_one_hot(encoded_data):
         cupy.ndarray: Decoded categorical labels with shape (n_samples,).
     """
 
-    decoded_labels = cp.argmax(encoded_data, axis=1)
+    if encoded_data.ndim == 1: return cp.argmax(encoded_data)
+    else: return cp.argmax(encoded_data, axis=1)
 
-    return decoded_labels
 
 
-def split(X, y, test_size, random_state=42, dtype=cp.float32, use_cpu=False):
+def split(X, y, test_size, random_state=42, dtype=cp.float32, shuffle_in_cpu=False):
     """
     Splits the given X (features) and y (labels) data into training and testing subsets.
 
     Args:
         X (cupy.ndarray): Features data.
+        
         y (cupy.ndarray): Labels data.
+        
         test_size (float or int): Proportion or number of samples for the test subset.
+        
         random_state (int or None): Seed for random state. Default: 42.
+        
         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)
-        use_cpu (bool): If True, output will be same cpu's split function. Default: False.
+        
+        shuffle_in_cpu (bool): If True, output will be same cpu's split function. Default: False. (Use this for direct comparison of cpu training.)
     Returns:
         tuple: x_train, x_test, y_train, y_test as ordered training and testing data subsets.
     """
-    X = cp.array(X, copy=False).astype(dtype, copy=False)
-    if len(y) < 256:
-        if y.dtype != cp.uint8:
-            y = cp.array(y, copy=False).astype(cp.uint8, copy=False)
-    elif len(y) <= 32767:
-        if y.dtype != cp.uint16:
-            y = cp.array(y, copy=False).astype(cp.uint16, copy=False)
-    else:
-        if y.dtype != cp.uint32:
-            y = cp.array(y, copy=False).astype(cp.uint32, copy=False)
-
+    from .memory_operations import transfer_to_gpu, optimize_labels
+    
+    X = transfer_to_gpu(X, dtype=dtype)
+    y = optimize_labels(y, one_hot_encoded=False, cuda=True)
     
     num_samples = X.shape[0]
 
@@ -117,7 +99,7 @@ def split(X, y, test_size, random_state=42, dtype=cp.float32, use_cpu=False):
     else:
         raise ValueError("test_size should be float or int.")
 
-    if use_cpu:
+    if shuffle_in_cpu:
         indices = np.arange(num_samples)
         np.random.seed(random_state)
         np.random.shuffle(indices)
@@ -134,15 +116,13 @@ def split(X, y, test_size, random_state=42, dtype=cp.float32, use_cpu=False):
 
     x_train, x_test = X[train_indices], X[test_indices]
     y_train, y_test = y[train_indices], y[test_indices]
-
     del X
     del y
-    cp.get_default_memory_pool.free_all_blocks()
-
+    cp.cuda.MemoryPool().free_all_blocks()
     return x_train, x_test, y_train, y_test
 
 
-def manuel_balancer(x_train, y_train, target_samples_per_class, dtype=cp.float32, use_cpu=False):
+def manuel_balancer(x_train, y_train, target_samples_per_class, dtype=cp.float32, shuffle_in_cpu=False):
     """
     Generates synthetic examples to balance classes to the specified number of examples per class.
 
@@ -156,28 +136,18 @@ def manuel_balancer(x_train, y_train, target_samples_per_class, dtype=cp.float32
 
     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)
 
-    use_cpu (bool): If True, output will be same cpu's manuel_balancer function. Default: False.
+    shuffle_in_cpu (bool): If True, output will be same cpu's manuel_balancer function. Default: False. (Use this for direct comparison of cpu training.)
 
     Returns:
     x_balanced -- Balanced input dataset (cupy array format)
     y_balanced -- Balanced class labels (one-hot encoded, cupy array format)
     """
     from .ui import loading_bars
-
-    bar_format = loading_bars()[0]
+    from .memory_operations import transfer_to_gpu
     
-    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)
-
+    bar_format = loading_bars()[0]
+    x_train = transfer_to_gpu(x_train, dtype=dtype)
+    y_train = transfer_to_gpu(y_train, dtype=y_train.dtype)
 
     classes = cp.arange(y_train.shape[1])
     class_count = len(classes)
@@ -192,7 +162,7 @@ def manuel_balancer(x_train, y_train, target_samples_per_class, dtype=cp.float32
         
         if num_samples > target_samples_per_class:
             
-            if use_cpu:
+            if shuffle_in_cpu:
                 selected_indices = np.random.choice(
                     class_indices.get(), target_samples_per_class, replace=False)
             else:
@@ -209,12 +179,12 @@ def manuel_balancer(x_train, y_train, target_samples_per_class, dtype=cp.float32
             if num_samples < target_samples_per_class:
                 
                 samples_to_add = target_samples_per_class - num_samples
-                additional_samples = cp.zeros((samples_to_add, x_train.shape[1]))
-                additional_labels = cp.zeros((samples_to_add, y_train.shape[1]))
+                additional_samples = cp.zeros((samples_to_add, x_train.shape[1]), dtype=x_train.dtype)
+                additional_labels = cp.zeros((samples_to_add, y_train.shape[1]), dtype=y_train.dtype)
                 
                 for i in range(samples_to_add):
                     
-                    if use_cpu:
+                    if shuffle_in_cpu:
                         random_indices = np.random.choice(class_indices.get(), 2, replace=False)
                     else:
                         random_indices = cp.random.choice(class_indices, 2, replace=False)
@@ -222,7 +192,7 @@ def manuel_balancer(x_train, y_train, target_samples_per_class, dtype=cp.float32
                     sample1 = x_train[random_indices[0]]
                     sample2 = x_train[random_indices[1]]
 
-                    if use_cpu:
+                    if shuffle_in_cpu:
                         synthetic_sample = sample1 + (sample2 - sample1) * np.random.rand()
                     else:
                         synthetic_sample = sample1 + (sample2 - sample1) * cp.random.rand()
@@ -234,13 +204,16 @@ def manuel_balancer(x_train, y_train, target_samples_per_class, dtype=cp.float32
                 x_balanced.append(additional_samples)
                 y_balanced.append(additional_labels)
     
-    x_balanced = cp.vstack(x_balanced)
-    y_balanced = cp.vstack(y_balanced)
+    x_balanced = cp.vstack(x_balanced, dtype=x_train.dtype)
+    y_balanced = cp.vstack(y_balanced, dtype=y_train.dtype)
+
+    del x_train, y_train
+    cp.cuda.MemoryPool().free_all_blocks()
 
     return x_balanced, y_balanced
 
 
-def auto_balancer(x_train, y_train, dtype=cp.float32, use_cpu=False):
+def auto_balancer(x_train, y_train, dtype=cp.float32, shuffle_in_cpu=False):
 
     """
    Function to balance the training data across different classes.
@@ -248,35 +221,27 @@ def auto_balancer(x_train, y_train, dtype=cp.float32, use_cpu=False):
    Arguments:
    x_train (list): Input data for training.
    
-   y_train (list): Labels corresponding to the input data.
+   y_train (list): Labels corresponding to the input data. (one-hot encoded)
    
    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)
 
-   use_cpu (bool): If True, output will be same cpu's auto_balancer function. Default: False.
+   shuffle_in_cpu (bool): If True, output will be same cpu's auto_balancer function. Default: False. (Use this for direct comparison of cpu training.)
    Returns:
    tuple: A tuple containing balanced input data and labels.
     """
     from .ui import loading_bars
-
-    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
+    
+    x_train = transfer_to_gpu(x_train, dtype=dtype)
+    y_train = transfer_to_gpu(y_train, dtype=y_train.dtype)
 
     bar_format = loading_bars()[0]
     
-    classes = cp.arange(y_train.shape[1])
+    classes = cp.arange(y_train.shape[1], dtype=y_train.dtype)
     class_count = len(classes)
     
    
-    ClassIndices = {i: cp.where(cp.array(y_train)[:, i] == 1)[
+    ClassIndices = {i: cp.where(y_train[:, i] == 1)[
         0] for i in range(class_count)}
     classes = [len(ClassIndices[i]) for i in range(class_count)]
 
@@ -290,7 +255,7 @@ def auto_balancer(x_train, y_train, dtype=cp.float32, use_cpu=False):
     for i in tqdm(range(class_count),leave=False, ascii="▱▰",
         bar_format= bar_format, desc='Balancing Data',ncols=70):
         if len(ClassIndices[i]) > MinCount:
-            if use_cpu:
+            if shuffle_in_cpu:
                 SelectedIndices = np.random.choice(
                     ClassIndices[i].get(), MinCount, replace=False)
             else:
@@ -303,7 +268,7 @@ def auto_balancer(x_train, y_train, dtype=cp.float32, use_cpu=False):
     BalancedInputs = [x_train[idx] for idx in BalancedIndices]
     BalancedLabels = [y_train[idx] for idx in BalancedIndices]
 
-    if use_cpu:
+    if shuffle_in_cpu:
         permutation = np.random.permutation(len(BalancedInputs))
     else:
         permutation = cp.random.permutation(len(BalancedInputs))
@@ -313,12 +278,13 @@ def auto_balancer(x_train, y_train, dtype=cp.float32, use_cpu=False):
 
     print(Fore.GREEN + "Data Succesfully Balanced from: " + str(len(x_train)
                                                                                 ) + " to: " + str(len(BalancedInputs)) + ". from: auto_balancer " + Style.RESET_ALL)
+    del x_train, y_train
+    cp.cuda.MemoryPool().free_all_blocks()
 
-        
     return BalancedInputs, BalancedLabels
 
 
-def synthetic_augmentation(x_train, y_train, dtype=cp.float32, use_cpu=False):
+def synthetic_augmentation(x_train, y_train, dtype=cp.float32, shuffle_in_cpu=False):
     """
     Generates synthetic examples to balance classes with fewer examples using CuPy.
     Arguments:
@@ -329,30 +295,20 @@ def synthetic_augmentation(x_train, y_train, dtype=cp.float32, use_cpu=False):
     
     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)
     
-    use_cpu (bool): If True, output will be same cpu's synthetic_augmentation function. Default: False.
+    shuffle_in_cpu (bool): If True, output will be same cpu's synthetic_augmentation function. Default: False. (Use this for direct comparison of cpu training.)
 
     Returns:
     x_train_balanced -- Balanced input dataset (cupy array format)
     y_train_balanced -- Balanced class labels (one-hot encoded, cupy array format)
     """
     from .ui import loading_bars
-
+    from .memory_operations import transfer_to_gpu
+    
+    x = transfer_to_gpu(x_train, dtype=dtype)
+    y = transfer_to_gpu(y_train, dtype=y_train.dtype)
+    
     bar_format = loading_bars()[0]
     
-    x = x_train.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)
-
-    y = y_train
-
     classes = cp.arange(y_train.shape[1])
     class_count = len(classes)
     class_distribution = {i: 0 for i in range(class_count)}
@@ -371,7 +327,7 @@ def synthetic_augmentation(x_train, y_train, dtype=cp.float32, use_cpu=False):
         
         if num_samples < max_class_count:
             while num_samples < max_class_count:
-                if use_cpu:
+                if shuffle_in_cpu:
                     random_indices = np.random.choice(
                         class_indices, 2, replace=False)
                 else:
@@ -380,7 +336,7 @@ def synthetic_augmentation(x_train, y_train, dtype=cp.float32, use_cpu=False):
                 sample1 = x[random_indices[0]]
                 sample2 = x[random_indices[1]]
                 
-                if use_cpu:
+                if shuffle_in_cpu:
                     synthetic_sample = sample1 + \
                         (sample2 - sample1) * np.random.rand()
                 else:
@@ -394,6 +350,9 @@ def synthetic_augmentation(x_train, y_train, dtype=cp.float32, use_cpu=False):
     x_balanced = cp.array(x_balanced)
     y_balanced = cp.array(y_balanced)
     
+    del x_train, y_train, x, y
+    cp.cuda.MemoryPool().free_all_blocks()
+
     return x_balanced, y_balanced
 
 def standard_scaler(x_train=None, x_test=None, scaler_params=None, dtype=cp.float32):
@@ -462,7 +421,6 @@ def normalization(
     MaxAbs = cp.max(cp.abs(Input.astype(dtype, copy=False)))
     return (Input / MaxAbs)
 
-
 def find_closest_factors(a):
 
     root = int(math.sqrt(a))