pyerualjetwork 4.5__py3-none-any.whl → 4.5.2__py3-none-any.whl

pyerualjetwork/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "4.5"
+__version__ = "4.5.2"
 __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

pyerualjetwork/data_operations.py

@@ -17,9 +17,6 @@ def encode_one_hot(y_train, y_test=None, summary=False):
         tuple: One-hot encoded y_train and (if given) y_test.
     """
     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)
@@ -34,11 +31,14 @@ def encode_one_hot(y_train, y_test=None, summary=False):
     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
+    y_train_encoded = optimize_labels(y_train_encoded, one_hot_encoded=True, cuda=False)
 
     if y_test is not None:
         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
+        y_test_encoded = optimize_labels(y_test_encoded, one_hot_encoded=True, cuda=False)
+
         return y_train_encoded, y_test_encoded
 
     return y_train_encoded
@@ -77,11 +77,7 @@ 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.
     """
-    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]
 
     if isinstance(test_size, float):
@@ -114,17 +110,23 @@ def manuel_balancer(x_train, y_train, target_samples_per_class, dtype=np.float32
     """
     Generates synthetic examples to balance classes to the specified number of examples per class.
 
-    Arguments:
-    x_train -- Input dataset (examples) - NumPy array format
-    y_train -- Class labels (one-hot encoded) - NumPy array format
-    target_samples_per_class -- Desired number of samples per class
-    dtype (numpy.dtype): Data type for the arrays. np.float32 by default. Example: np.float64 or np.float16. [fp32 for balanced devices, fp64 for strong devices, fp16 for weak devices: not reccomended!]
+    Args:
+
+        x_train: numpy array format
+
+        y_train (one-hot encoded): numpy array format
+
+        target_samples_per_class (int): Desired number of samples per class
+
+        dtype (numpy.dtype): Data type for the arrays. np.float32 by default. Example: np.float64 or np.float16.
+
+        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 (NumPy array format)
-    y_balanced -- Balanced class labels (one-hot encoded, NumPy array format)
+        x_balanced -- Balanced input dataset (numpy array format)
+        y_balanced -- Balanced class labels (one-hot encoded, numpy array format)
     """
-    from .ui import loading_bars
+    from .ui import loading_bars, get_loading_bar_style
     from .memory_operations import transfer_to_cpu
     
     x_train = transfer_to_cpu(x_train, dtype=dtype)
@@ -136,7 +138,7 @@ def manuel_balancer(x_train, y_train, target_samples_per_class, dtype=np.float32
     x_balanced = []
     y_balanced = []
 
-    for class_label in tqdm(range(class_count),leave=False, ascii="▱▰",
+    for class_label in tqdm(range(class_count),leave=False, ascii=get_loading_bar_style(),
             bar_format=bar_format,desc='Augmenting Data',ncols= 52):
         class_indices = np.where(np.argmax(y_train, axis=1) == class_label)[0]
         num_samples = len(class_indices)
@@ -185,17 +187,21 @@ def manuel_balancer(x_train, y_train, target_samples_per_class, dtype=np.float32
 def auto_balancer(x_train, y_train, dtype=np.float32):
 
     """
-   Function to balance the training data across different classes.
+    Function to balance (to min) the training data across different classes.
 
-   Arguments:
-   x_train (list): Input data for training.
-   y_train (list): Labels corresponding to the input data. one-hot encoded.
-   dtype (numpy.dtype): Data type for the arrays. np.float32 by default. Example: np.float64 or np.float16. [fp32 for balanced devices, fp64 for strong devices, fp16 for weak devices: not reccomended!]
+    Args:
+        x_train (list): Input data for training.
+        
+        y_train (list): Labels corresponding to the input data. (one-hot encoded)
+        
+        dtype (numpy.dtype): Data type for the arrays. np.float32 by default. Example: np.float64 or np.float16.
 
-   Returns:
-   tuple: A tuple containing balanced input data and labels.
+        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
+    from .ui import loading_bars, get_loading_bar_style
     from .memory_operations import transfer_to_cpu
     
     x_train = transfer_to_cpu(x_train, dtype=dtype)
@@ -216,7 +222,7 @@ def auto_balancer(x_train, y_train, dtype=np.float32):
         MinCount = min(classes)
 
         BalancedIndices = []
-        for i in tqdm(range(class_count),leave=False, ascii="▱▰",
+        for i in tqdm(range(class_count),leave=False, ascii=get_loading_bar_style(),
             bar_format= bar_format, desc='Balancing Data',ncols=70):
             if len(ClassIndices[i]) > MinCount:
                 SelectedIndices = np.random.choice(
@@ -248,18 +254,20 @@ def auto_balancer(x_train, y_train, dtype=np.float32):
 
 def synthetic_augmentation(x, y, dtype=np.float32):
     """
-    Generates synthetic examples to balance classes with fewer examples.
+    Generates synthetic examples to balance classes with fewer examples using numpy.
+    Args:
+        x_train: numpy array format
 
-    Arguments:
-    x -- Input dataset (examples) - array format
-    y -- Class labels (one-hot encoded) - array format
-    dtype (numpy.dtype): Data type for the arrays. np.float32 by default. Example: np.float64 or np.float16. [fp32 for balanced devices, fp64 for strong devices, fp16 for weak devices: not reccomended!]
+        y_train: numpy array format
+        
+        dtype (numpy.dtype): Data type for the arrays. cp.float32 by default. Example: cp.float64 or cp.float16.
+        
+        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_balanced -- Balanced input dataset (array format)
-    y_balanced -- Balanced class labels (one-hot encoded, array format)
+        x_train_balanced, y_train_balanced (numpy array format)
     """
-    from .ui import loading_bars
+    from .ui import loading_bars, get_loading_bar_style
     from .memory_operations import transfer_to_cpu
     
     x = transfer_to_cpu(x, dtype=dtype)
@@ -278,7 +286,7 @@ def synthetic_augmentation(x, y, dtype=np.float32):
     y_balanced = list(y)
 
 
-    for class_label in tqdm(range(class_count), leave=False, ascii="▱▰",
+    for class_label in tqdm(range(class_count), leave=False, ascii=get_loading_bar_style(),
             bar_format=bar_format,desc='Augmenting Data',ncols= 52):
         class_indices = [i for i, label in enumerate(
             y) if np.argmax(label) == class_label]
@@ -313,19 +321,16 @@ def standard_scaler(x_train=None, x_test=None, scaler_params=None, dtype=np.floa
     Standardizes training and test datasets. x_test may be None.
 
     Args:
-        x_train: numpy.ndarray
+        x_train (numpy.ndarray): 
         
-        x_test: numpy.ndarray (optional)
+        x_test (numpy.ndarray): (optional)
         
-        scaler_params (optional for using model)
+        scaler_params (tuple): (optional for using model)
         
-        dtype (numpy.dtype): Data type for the arrays. np.float32 by default. Example: np.float64 or np.float16. [fp32 for balanced devices, fp64 for strong devices, fp16 for weak devices: not reccomended!]
+        dtype (numpy.dtype): Data type for the arrays. np.float32 by default. Example: np.float64 or np.float16.
 
     Returns:
-        list:
-        Scaler parameters: mean and std
-        tuple
-        Standardized training and test datasets
+        Scaler parameters, Standardized training (and if test given) datasets. (tuple)
     """
     if x_train is not None and scaler_params is None and x_test is not None:
         x_train = x_train.astype(dtype, copy=False)
@@ -381,12 +386,12 @@ def non_neg_normalization(
     Normalizes the input data [0-1] range.
 
     Args:
-        Input (cupy): Input data to be normalized.
+        Input (numpy): Input data to be normalized.
 
-        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)
+        dtype (numpy.dtype): Data type for the arrays. cp.float32 by default. Example: cp.float64 or cp.float16.
 
     Returns:
-        (cupy) Scaled input data after normalization.
+        (numpy) Scaled input data after normalization.
     """
 
     MaxAbs = np.max(np.abs(Input.astype(dtype, copy=False)))

pyerualjetwork/data_operations_cuda.py

@@ -14,14 +14,11 @@ def encode_one_hot(y_train, y_test=None, summary=False):
         summary (bool): If True, prints the class-to-index mapping. Default: False
    
     Returns:
-        tuple: One-hot encoded y_train and (if given) y_test.
+        tuple: One-hot encoded y_train and (if given: y_test).
     """
 
     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 = transfer_to_cpu(y_train,dtype=y_train.dtype)
     y_test = transfer_to_cpu(y_test,dtype=y_test.dtype)
 
@@ -38,14 +35,17 @@ def encode_one_hot(y_train, y_test=None, summary=False):
     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
+    y_train_encoded = optimize_labels(y_train_encoded, one_hot_encoded=True, cuda=True)
 
     if y_test is not None:
         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, dtype=y_train.dtype), cp.array(y_test_encoded, dtype=y_test.dtype)
+        y_test_encoded = optimize_labels(y_test_encoded, one_hot_encoded=True, cuda=True)
+
+        return y_train_encoded, y_test_encoded
 
-    return cp.array(y_train_encoded, dtype=y_train.dtype)
+    return y_train_encoded
 
 
 def decode_one_hot(encoded_data):
@@ -77,7 +77,7 @@ def split(X, y, test_size, random_state=42, dtype=cp.float32, shuffle_in_cpu=Fal
         
         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)
+        dtype (cupy.dtype): Data type for the arrays. np.float32 by default. Example: cp.float64 or cp.float16.
         
         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:
@@ -126,23 +126,23 @@ def manuel_balancer(x_train, y_train, target_samples_per_class, dtype=cp.float32
     """
     Generates synthetic examples to balance classes to the specified number of examples per class.
 
-    Arguments:
+    Args:
 
-    x_train -- Input dataset (examples) - cupy array format
+        x_train: cupy array format
 
-    y_train -- Class labels (one-hot encoded) - cupy array format
+        y_train (one-hot encoded): cupy array format
 
-    target_samples_per_class -- Desired number of samples per class
+        target_samples_per_class (int): Desired number of samples per class
 
-    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)
+        dtype (cupy.dtype): Data type for the arrays. cp.float32 by default. Example: cp.float64 or cp.float16.
 
-    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.)
+        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)
+        x_balanced -- Balanced input dataset (cupy array format)
+        y_balanced -- Balanced class labels (one-hot encoded, cupy array format)
     """
-    from .ui import loading_bars
+    from .ui import loading_bars, get_loading_bar_style
     from .memory_operations import transfer_to_gpu
     
     bar_format = loading_bars()[0]
@@ -155,7 +155,7 @@ def manuel_balancer(x_train, y_train, target_samples_per_class, dtype=cp.float32
     x_balanced = []
     y_balanced = []
 
-    for class_label in tqdm(range(class_count),leave=False, ascii="▱▰",
+    for class_label in tqdm(range(class_count),leave=False, ascii=get_loading_bar_style(),
             bar_format=bar_format,desc='Augmenting Data',ncols= 52):
         class_indices = cp.where(cp.argmax(y_train, axis=1) == class_label)[0]
         num_samples = len(class_indices)
@@ -216,20 +216,22 @@ def manuel_balancer(x_train, y_train, target_samples_per_class, dtype=cp.float32
 def auto_balancer(x_train, y_train, dtype=cp.float32, shuffle_in_cpu=False):
 
     """
-   Function to balance the training data across different classes.
+   Function to balance (to min) the training data across different classes.
 
-   Arguments:
-   x_train (list): Input data for training.
-   
-   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)
+   Args:
+    x_train (list): Input data for training.
+    
+    y_train (list): Labels corresponding to the input data. (one-hot encoded)
+    
+    dtype (cupy.dtype): Data type for the arrays. cp.float32 by default. Example: cp.float64 or cp.float16.
+
+    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.)
 
-   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.
+    tuple: A tuple containing balanced input data and labels.
     """
-    from .ui import loading_bars
+
+    from .ui import loading_bars, get_loading_bar_style
     from .memory_operations import transfer_to_gpu
     
     x_train = transfer_to_gpu(x_train, dtype=dtype)
@@ -252,7 +254,7 @@ def auto_balancer(x_train, y_train, dtype=cp.float32, shuffle_in_cpu=False):
     MinCount = min(classes)
 
     BalancedIndices = []
-    for i in tqdm(range(class_count),leave=False, ascii="▱▰",
+    for i in tqdm(range(class_count),leave=False, ascii=get_loading_bar_style(),
         bar_format= bar_format, desc='Balancing Data',ncols=70):
         if len(ClassIndices[i]) > MinCount:
             if shuffle_in_cpu:
@@ -287,21 +289,19 @@ def auto_balancer(x_train, y_train, dtype=cp.float32, shuffle_in_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:
-    
-    x_train -- Input dataset (examples) - cupy array format
-    
-    y_train -- Class labels (one-hot encoded) - cupy array format
-    
-    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)
-    
-    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.)
+    Args:
+        x_train: cupy array format
+
+        y_train: cupy array format
+        
+        dtype (cupy.dtype): Data type for the arrays. cp.float32 by default. Example: cp.float64 or cp.float16.
+        
+        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)
+        x_train_balanced, y_train_balanced (cupy array format)
     """
-    from .ui import loading_bars
+    from .ui import loading_bars, get_loading_bar_style
     from .memory_operations import transfer_to_gpu
     
     x = transfer_to_gpu(x_train, dtype=dtype)
@@ -320,7 +320,7 @@ def synthetic_augmentation(x_train, y_train, dtype=cp.float32, shuffle_in_cpu=Fa
     x_balanced = list(x)
     y_balanced = list(y)
     
-    for class_label in tqdm(range(class_count), leave=False, ascii="▱▰",
+    for class_label in tqdm(range(class_count), leave=False, ascii=get_loading_bar_style(),
             bar_format=bar_format, desc='Augmenting Data', ncols=52):
         class_indices = [i for i, label in enumerate(y) if cp.argmax(label) == class_label]
         num_samples = len(class_indices)
@@ -360,19 +360,16 @@ def standard_scaler(x_train=None, x_test=None, scaler_params=None, dtype=cp.floa
     Standardizes training and test datasets. x_test may be None.
 
     Args:
-        x_train: cupy.ndarray
+        x_train (cupy.ndarray): 
         
-        x_test: cupy.ndarray (optional)
+        x_test (cupy.ndarray): (optional)
         
-        scaler_params (optional for using model)
+        scaler_params (tuple): (optional for using model)
         
-        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)
+        dtype (cupy.dtype): Data type for the arrays. cp.float32 by default. Example: cp.float64 or cp.float16.
 
     Returns:
-        list:
-        Scaler parameters: mean and std
-        tuple
-        Standardized training and test datasets
+        Scaler parameters, Standardized training (and if test given) datasets. (tuple)
     """
     if x_train is not None and scaler_params is None and x_test is not None:
         x_train = x_train.astype(dtype, copy=False)
@@ -412,7 +409,7 @@ def normalization(
     Args:
         Input (num): Input data to be normalized.
 
-        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)
+        dtype (cupy.dtype): Data type for the arrays. cp.float32 by default. Example: cp.float64 or cp.float16.
 
     Returns:
         (num) Scaled input data after normalization.
@@ -432,7 +429,7 @@ def non_neg_normalization(
     Args:
         Input (cupy): Input data to be normalized.
 
-        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)
+        dtype (cupy.dtype): Data type for the arrays. cp.float32 by default. Example: cp.float64 or cp.float16.
 
     Returns:
         (cupy) Scaled input data after normalization.

pyerualjetwork/fitness_functions.py

@@ -5,14 +5,9 @@ def wals(acc, loss, acc_impact, loss_impact):
     The WALS(weighted accuracy-loss score) function calculates a weighted sum of accuracy and loss based on their respective impacts.
     
     :param acc: The `acc` parameter represents the accuracy of a model or system
-    :param loss: The `loss` parameter in the `wals` function represents the amount of loss incurred. It
-    is used in the calculation to determine the overall impact based on the accuracy and loss impacts
-    provided
-    :param acc_impact: The `acc_impact` parameter represents the impact of accuracy on the overall score
-    calculation in the `wals` function. It is a multiplier that determines how much the accuracy
-    contributes to the final result
-    :param loss_impact: The `loss_impact` parameter in the `wals` function represents the weight of loss value when calculating the overall impact. It is used to determine how
-     much the loss affects the final result compared to the accuracy impact
+    :param loss: The `loss` parameter in the `wals` function represents the amount of loss incurred. It is used in the calculation to determine the overall impact based on the accuracy and loss impacts provided
+    :param acc_impact: The `acc_impact` parameter represents the impact of accuracy on the overall score calculation in the `wals` function. It is a multiplier that determines how much the accuracy contributes to the final result
+    :param loss_impact: The `loss_impact` parameter in the `wals` function represents the weight of loss value when calculating the overall impact. It is used to determine how much the loss affects the final result compared to the accuracy impact
     :return: the weighted sum of accuracy and loss based on their respective impacts.
     """
     loss += np.finfo(float).eps

pyerualjetwork/memory_operations.py

@@ -34,11 +34,11 @@ 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 x: Input data to transfer to CPU (CuPy array)
     
-    param dtype: Target NumPy dtype for the output array (default: np.float32)
+    :param dtype: Target NumPy dtype for the output array (default: np.float32)
     
-    return: NumPy array with the specified dtype
+    :return: NumPy array with the specified dtype
     """
     from .ui import loading_bars, initialize_loading_bar
     try:
@@ -125,11 +125,8 @@ 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.
+    :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]
@@ -246,21 +243,10 @@ 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
+    :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