pyerualjetwork 4.4__py3-none-any.whl → 4.5.1__py3-none-any.whl

pyerualjetwork/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "4.4"
+__version__ = "4.5.1"
 __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,15 +110,21 @@ 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 .memory_operations import transfer_to_cpu
@@ -185,15 +187,19 @@ 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.
+
+        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.
+    Returns:
+        tuple: A tuple containing balanced input data and labels.
     """
     from .ui import loading_bars
     from .memory_operations import transfer_to_cpu
@@ -248,16 +254,18 @@ 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 .memory_operations import transfer_to_cpu
@@ -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)
@@ -373,6 +378,26 @@ dtype=np.float32):
     return (Input / MaxAbs)
 
 
+def non_neg_normalization(
+    Input, 
+    dtype=np.float32
+):
+    """
+    Normalizes the input data [0-1] range.
+
+    Args:
+        Input (numpy): Input data to be normalized.
+
+        dtype (numpy.dtype): Data type for the arrays. cp.float32 by default. Example: cp.float64 or cp.float16.
+
+    Returns:
+        (numpy) Scaled input data after normalization.
+    """
+
+    MaxAbs = np.max(np.abs(Input.astype(dtype, copy=False)))
+    return (Input + MaxAbs) / (2 * MaxAbs)
+
+
 def find_closest_factors(a):
 
     root = int(math.sqrt(a))

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,21 +126,21 @@ 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 .memory_operations import transfer_to_gpu
@@ -216,19 +216,21 @@ 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 .memory_operations import transfer_to_gpu
     
@@ -287,19 +289,17 @@ 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 .memory_operations import transfer_to_gpu
@@ -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.
@@ -421,6 +418,27 @@ def normalization(
     MaxAbs = cp.max(cp.abs(Input.astype(dtype, copy=False)))
     return (Input / MaxAbs)
 
+
+def non_neg_normalization(
+    Input, 
+    dtype=cp.float32
+):
+    """
+    Normalizes the input data [0-1] range.
+
+    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.
+
+    Returns:
+        (cupy) Scaled input data after normalization.
+    """
+
+    MaxAbs = cp.max(cp.abs(Input.astype(dtype, copy=False)))
+    return (Input + MaxAbs) / (2 * MaxAbs)
+
+
 def find_closest_factors(a):
 
     root = int(math.sqrt(a))

pyerualjetwork/fitness_functions.py

@@ -1,16 +1,16 @@
+import numpy as np
+
 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.
     """
-    return (acc * acc_impact) + (-loss * loss_impact)
+    loss += np.finfo(float).eps
+    loss_impact += np.finfo(float).eps
+    
+    return (acc * acc_impact) + ((loss_impact / loss) * loss_impact)

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

pyerualjetwork/model_operations.py

@@ -23,33 +23,21 @@ def save_model(model_name,
 
     """
     Function to save a potentiation learning artificial neural network model.
-
-    Arguments:
-
-    model_name (str): Name of the model.
-
-    model_type (str): Type of the model. default: 'PLAN'
-
-    test_acc (float): Test accuracy of the model. default: None
-
-    weights_type (str): Type of weights to save (options: 'txt', 'pkl', 'npy', 'mat'). default: 'npy'
-
-    WeightFormat (str): Format of the weights (options: 'f', 'raw'). default: 'raw'
-
-    model_path (str): Path where the model will be saved. For example: C:/Users/beydili/Desktop/denemePLAN/ default: ''
-
-    scaler_params (list[num, num]): standard scaler params list: mean,std. If not used standard scaler then be: None.
-
-    W: Weights of the model.
-
-    activation_potentiation (list): For deeper PLAN networks, activation function parameters. For more information please run this code: plan.activations_list() default: ['linear']
-
-    show_architecture (bool): It draws model architecture. True or False. Default: False
-
-    show_info (bool): Prints model details into console. default: True
+    Args:
+        model_name: (str): Name of the model.
+        W: Weights of the model.
+        scaler_params: (list[num, num]): standard scaler params list: mean,std. If not used standard scaler then be: None.
+        model_type: (str): Type of the model. default: 'PLAN'
+        test_acc: (float): Test accuracy of the model. default: None
+        model_path: (str): Path where the model will be saved. For example: C:/Users/beydili/Desktop/denemePLAN/ default: ''
+        activation_potentiation: (list): For deeper PLAN networks, activation function parameters. For more information please run this code: plan.activations_list() default: ['linear']
+        weights_type: (str): Type of weights to save (options: 'txt', 'pkl', 'npy', 'mat'). default: 'npy'
+        weights_format: (str): Format of the weights (options: 'f', 'raw'). default: 'raw'
+        show_architecture: (bool): It draws model architecture. True or False. Default: False
+        show_info: (bool): Prints model details into console. default: True
 
     Returns:
-    No return.
+        No return.
     """
     
     from .visualizations import draw_model_architecture
@@ -181,14 +169,14 @@ def load_model(model_name,
     """
    Function to load a potentiation learning model.
 
-   Arguments:
+   Args:
 
-   model_name (str): Name of the model.
+    model_name (str): Name of the model.
 
-   model_path (str): Path where the model is saved.
+    model_path (str): Path where the model is saved.
 
    Returns:
-   lists: W(list[num]), activation_potentiation, DataFrame of the model
+    lists: W(list[num]), activation_potentiation, DataFrame of the model
     """
 
     try:
@@ -244,18 +232,18 @@ def predict_model_ssd(Input, model_name, model_path='', dtype=np.float32):
     Function to make a prediction using a potentiation learning artificial neural network (PLAN).
     from storage
 
-    Arguments:
+    Args:
 
-    Input (list or ndarray): Input data for the model (single vector or single matrix).
+        Input (list or ndarray): Input data for the model (single vector or single matrix).
 
-    model_name (str): Name of the model.
+        model_name (str): Name of the model.
 
-    model_path (str): Path of the model. Default: ''
+        model_path (str): Path of the model. Default: ''
 
-    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. [fp32 for balanced devices, fp64 for strong devices, fp16 for weak devices: not reccomended!]
 
     Returns:
-    ndarray: Output from the model.
+        ndarray: Output from the model.
     """
     
     from .activation_functions import apply_activation
@@ -285,18 +273,18 @@ def reverse_predict_model_ssd(output, model_name, model_path='', dtype=np.float3
 
     """
     reverse prediction function from storage
-    Arguments:
+    Args:
 
-    output (list or ndarray): output layer for the model (single probability vector, output layer of trained model).
+        output (list or ndarray): output layer for the model (single probability vector, output layer of trained model).
 
-    model_name (str): Name of the model.
+        model_name (str): Name of the model.
 
-    model_path (str): Path of the model. Default: ''
+        model_path (str): Path of the model. Default: ''
 
-    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. [fp32 for balanced devices, fp64 for strong devices, fp16 for weak devices: not reccomended!]
+        
     Returns:
-    ndarray: Input from the model.
+        ndarray: Input from the model.
     """
     
     model = load_model(model_name, model_path)
@@ -318,20 +306,20 @@ def predict_model_ram(Input, W, scaler_params=None, activation_potentiation=['li
     Function to make a prediction using a potentiation learning artificial neural network (PLAN).
     from memory.
 
-    Arguments:
+    Args:
 
-    Input (list or ndarray): Input data for the model (single vector or single matrix).
+        Input (list or ndarray): Input data for the model (single vector or single matrix).
 
-    W (list of ndarrays): Weights of the model.
+        W (list of ndarrays): Weights of the model.
 
-    scaler_params (list): standard scaler params list: mean,std. (optional) Default: None.
-    
-    activation_potentiation (list): ac list for deep PLAN. default: [None] ('linear') (optional)
+        scaler_params (list): standard scaler params list: mean,std. (optional) Default: None.
+        
+        activation_potentiation (list): ac list for deep PLAN. default: [None] ('linear') (optional)
 
-    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. [fp32 for balanced devices, fp64 for strong devices, fp16 for weak devices: not reccomended!]
 
     Returns:
-    ndarray: Output from the model.
+        ndarray: Output from the model.
     """
 
     from .data_operations import standard_scaler
@@ -358,16 +346,16 @@ def reverse_predict_model_ram(output, W, dtype=np.float32):
     """
     reverse prediction function from memory
 
-    Arguments:
+    Args:
 
-    output (list or ndarray): output layer for the model (single probability vector, output layer of trained model).
+        output (list or ndarray): output layer for the model (single probability vector, output layer of trained model).
 
-    W (list of ndarrays): Weights of the model.
+        W (list of ndarrays): Weights of the 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. [fp32 for balanced devices, fp64 for strong devices, fp16 for weak devices: not reccomended!]
 
     Returns:
-    ndarray: Input from the model.
+        ndarray: Input from the model.
     """
 
     try: