pyerualjetwork 3.3.4__py3-none-any.whl → 4.1.9__py3-none-any.whl

pyerualjetwork/data_operations.py

@@ -10,12 +10,17 @@ def encode_one_hot(y_train, y_test=None, summary=False):
 
     Args:
         y_train (numpy.ndarray): Train label data.
-        y_test (numpy.ndarray): Test label data. (optional).
-        summary (bool): If True, prints the class-to-index mapping. Default: False
-
+        y_test (numpy.ndarray): Test label data one-hot encoded. (optional).
+        summary (bool, optional): If True, prints the class-to-index mapping. Default: False
+    
     Returns:
-        tuple: One-hot encoded y_train ve (eğer varsa) y_test verileri.
+        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)
 
@@ -26,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
@@ -55,7 +60,7 @@ def decode_one_hot(encoded_data):
     return decoded_labels
 
 
-def split(X, y, test_size, random_state):
+def split(X, y, test_size, random_state=42, dtype=np.float32):
     """
     Splits the given X (features) and y (labels) data into training and testing subsets.
 
@@ -63,11 +68,16 @@ def split(X, y, test_size, random_state):
         X (numpy.ndarray): Features data.
         y (numpy.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.
+        random_state (int or None): Seed for random state. Default: 42.
+        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!]
 
     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]
 
@@ -92,10 +102,12 @@ def split(X, y, test_size, random_state):
     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
 
 
-def manuel_balancer(x_train, y_train, target_samples_per_class):
+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.
 
@@ -103,21 +115,18 @@ def manuel_balancer(x_train, y_train, target_samples_per_class):
     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!]
 
     Returns:
     x_balanced -- Balanced input dataset (NumPy array format)
     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
     
-    try:
-        x_train = np.array(x_train)
-        y_train = np.array(y_train)
-    except:
-        pass
+    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)
     
@@ -143,8 +152,8 @@ def manuel_balancer(x_train, y_train, target_samples_per_class):
             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):
 
@@ -162,33 +171,38 @@ def manuel_balancer(x_train, y_train, target_samples_per_class):
                 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, y_balanced
 
 
-def auto_balancer(x_train, y_train):
+def auto_balancer(x_train, y_train, dtype=np.float32):
 
     """
    Function to balance the training data across different classes.
 
    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 (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!]
 
    Returns:
    tuple: A tuple containing balanced input data and labels.
     """
     from .ui import loading_bars
+    from .memory_operations import transfer_to_cpu
+    
+    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)
     
     try:
-        ClassIndices = {i: np.where(np.array(y_train)[:, i] == 1)[
+        ClassIndices = {i: np.where(y_train[:, i] == 1)[
             0] for i in range(class_count)}
         classes = [len(ClassIndices[i]) for i in range(class_count)]
 
@@ -221,28 +235,34 @@ def auto_balancer(x_train, y_train):
         print(Fore.RED + "ERROR: Inputs and labels must be same length check parameters")
         sys.exit()
 
-    return np.array(BalancedInputs), np.array(BalancedLabels)
+    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):
+    return BalancedInputs, BalancedLabels
+
+
+def synthetic_augmentation(x, y, dtype=np.float32):
     """
     Generates synthetic examples to balance classes with fewer examples.
 
     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!]
 
     Returns:
     x_balanced -- Balanced input dataset (array format)
     y_balanced -- Balanced class labels (one-hot encoded, array format)
     """
     from .ui import loading_bars
+    from .memory_operations import transfer_to_cpu
+    
+    x = transfer_to_cpu(x, dtype=dtype)
 
     bar_format = loading_bars()[0]
-    
-    x = x_train
-    y = y_train
-    classes = np.arange(y_train.shape[1])
+    classes = np.arange(y.shape[1])
     class_count = len(classes)
 
     class_distribution = {i: 0 for i in range(class_count)}
@@ -277,18 +297,26 @@ def synthetic_augmentation(x_train, y_train):
 
                 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), np.array(y_balanced)
+    return x_balanced, y_balanced
 
 
-def standard_scaler(x_train=None, x_test=None, scaler_params=None):
+def standard_scaler(x_train=None, x_test=None, scaler_params=None, dtype=np.float32):
     """
     Standardizes training and test datasets. x_test may be None.
 
     Args:
-        train_data: numpy.ndarray
-        test_data: numpy.ndarray (optional)
+        x_train: numpy.ndarray
+        
+        x_test: numpy.ndarray (optional)
+        
         scaler_params (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!]
 
     Returns:
         list:
@@ -296,17 +324,9 @@ def standard_scaler(x_train=None, x_test=None, scaler_params=None):
         tuple
         Standardized training and test datasets
     """
-
-    try:
-
-        x_train = x_train.tolist()
-        x_test = x_test.tolist()
-
-    except:
-
-        pass
-
-    if x_train != None and scaler_params == None and x_test != None:
+    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)
+        x_test = x_test.astype(dtype, copy=False)
 
         mean = np.mean(x_train, axis=0)
         std = np.std(x_train, axis=0)
@@ -321,53 +341,32 @@ def standard_scaler(x_train=None, x_test=None, scaler_params=None):
 
         return scaler_params, train_data_scaled, test_data_scaled
     
-    try:
-        if scaler_params == None and x_train == None and x_test != None:
-            
-            mean = np.mean(x_train, axis=0)
-            std = np.std(x_train, axis=0)
-            train_data_scaled = (x_train - mean) / std
+    if scaler_params is None and x_train is None and x_test is not None:
+        return x_test.astype(dtype, copy=False)  # sample data not scaled
             
-            train_data_scaled = np.nan_to_num(train_data_scaled, nan=0)
-            
-            scaler_params = [mean, std]
-            
-            return scaler_params, train_data_scaled
-    except:
-
-        # this model is not scaled
-
-        return x_test
-                
-    if scaler_params != None:
+    if scaler_params is not None:
+        x_test = x_test.astype(dtype, copy=False)
+        scaled_data = (x_test - scaler_params[0]) / scaler_params[1]
+        scaled_data = np.nan_to_num(scaled_data, nan=0)
 
-        try:
-
-            test_data_scaled = (x_test - scaler_params[0]) / scaler_params[1]
-            test_data_scaled = np.nan_to_num(test_data_scaled, nan=0)
-
-        except:
-
-            test_data_scaled = (x_test - scaler_params[0]) / scaler_params[1]
-            test_data_scaled = np.nan_to_num(test_data_scaled, nan=0)
-        
-        return test_data_scaled
+        return scaled_data  # sample data scaled
     
     
 def normalization(
-    Input  # num: Input data to be normalized.
-):
+    Input,  # num: Input data to be normalized.
+dtype=np.float32):
     """
     Normalizes the input data using maximum absolute scaling.
 
     Args:
         Input (num): Input data to be normalized.
+        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!]
 
     Returns:
         (num) Scaled input data after normalization.
     """
 
-    MaxAbs = np.max(np.abs(Input))
+    MaxAbs = np.max(np.abs(Input.astype(dtype, copy=False)))
     return (Input / MaxAbs)
 
 
@@ -383,6 +382,9 @@ def find_closest_factors(a):
 
 def batcher(x_test, y_test, batch_size=1):
 
+    if batch_size == 1:
+        return x_test, y_test
+    
     y_labels = np.argmax(y_test, axis=1)
 
     sampled_x, sampled_y = [], []