dragon-ml-toolbox 5.1.0__tar.gz → 5.2.1__tar.gz

{dragon_ml_toolbox-5.1.0/dragon_ml_toolbox.egg-info → dragon_ml_toolbox-5.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dragon-ml-toolbox
-Version: 5.1.0
+Version: 5.2.1
 Summary: A collection of tools for data science and machine learning projects.
 Author-email: Karl Loza <luigiloza@gmail.com>
 License-Expression: MIT
@@ -141,10 +141,11 @@ pip install "dragon-ml-toolbox[pytorch]"
 ```bash
 custom_logger
 data_exploration
-datasetmaster
 ensemble_learning
 ensemble_inference
 ETL_engineering
+ML_datasetmaster
+ML_models
 ML_callbacks
 ML_evaluation
 ML_trainer

{dragon_ml_toolbox-5.1.0 → dragon_ml_toolbox-5.2.1}/README.md

@@ -60,10 +60,11 @@ pip install "dragon-ml-toolbox[pytorch]"
 ```bash
 custom_logger
 data_exploration
-datasetmaster
 ensemble_learning
 ensemble_inference
 ETL_engineering
+ML_datasetmaster
+ML_models
 ML_callbacks
 ML_evaluation
 ML_trainer

{dragon_ml_toolbox-5.1.0 → dragon_ml_toolbox-5.2.1/dragon_ml_toolbox.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dragon-ml-toolbox
-Version: 5.1.0
+Version: 5.2.1
 Summary: A collection of tools for data science and machine learning projects.
 Author-email: Karl Loza <luigiloza@gmail.com>
 License-Expression: MIT
@@ -141,10 +141,11 @@ pip install "dragon-ml-toolbox[pytorch]"
 ```bash
 custom_logger
 data_exploration
-datasetmaster
 ensemble_learning
 ensemble_inference
 ETL_engineering
+ML_datasetmaster
+ML_models
 ML_callbacks
 ML_evaluation
 ML_trainer

{dragon_ml_toolbox-5.1.0 → dragon_ml_toolbox-5.2.1}/dragon_ml_toolbox.egg-info/SOURCES.txt

@@ -14,6 +14,7 @@ ml_tools/ML_callbacks.py
 ml_tools/ML_datasetmaster.py
 ml_tools/ML_evaluation.py
 ml_tools/ML_inference.py
+ml_tools/ML_models.py
 ml_tools/ML_optimization.py
 ml_tools/ML_trainer.py
 ml_tools/PSO_optimization.py
@@ -22,7 +23,6 @@ ml_tools/SQL.py
 ml_tools/VIF_factor.py
 ml_tools/__init__.py
 ml_tools/_logger.py
-ml_tools/_pytorch_models.py
 ml_tools/_script_info.py
 ml_tools/custom_logger.py
 ml_tools/data_exploration.py

{dragon_ml_toolbox-5.1.0 → dragon_ml_toolbox-5.2.1}/ml_tools/ML_callbacks.py

@@ -6,6 +6,8 @@ from .keys import LogKeys
 from ._logger import _LOGGER
 from typing import Optional
 from ._script_info import _script_info
+from typing import Union, Literal
+from pathlib import Path
 
 
 __all__ = [
@@ -122,7 +124,7 @@ class EarlyStopping(Callback):
                     inferred from the name of the monitored quantity.
         verbose (int): Verbosity mode.
     """
-    def __init__(self, monitor: str=LogKeys.VAL_LOSS, min_delta=0.0, patience=3, mode='auto', verbose=1):
+    def __init__(self, monitor: str=LogKeys.VAL_LOSS, min_delta=0.0, patience=3, mode: Literal['auto', 'min', 'max']='auto', verbose: int=1):
         super().__init__()
         self.monitor = monitor
         self.patience = patience
@@ -146,13 +148,13 @@ class EarlyStopping(Callback):
             else: # Default to min mode for loss or other metrics
                 self.monitor_op = np.less
         
-        self.best = np.Inf if self.monitor_op == np.less else -np.Inf
+        self.best = np.Inf if self.monitor_op == np.less else -np.Inf # type: ignore
 
     def on_train_begin(self, logs=None):
         # Reset state at the beginning of training
         self.wait = 0
         self.stopped_epoch = 0
-        self.best = np.Inf if self.monitor_op == np.less else -np.Inf
+        self.best = np.Inf if self.monitor_op == np.less else -np.Inf # type: ignore
                     
     def on_epoch_end(self, epoch, logs=None):
         current = logs.get(self.monitor) # type: ignore
@@ -199,10 +201,10 @@ class ModelCheckpoint(Callback):
         mode (str): One of {'auto', 'min', 'max'}.
         verbose (int): Verbosity mode.
     """
-    def __init__(self, save_dir: str, monitor: str = LogKeys.VAL_LOSS,
-                 save_best_only: bool = False, mode: str = 'auto', verbose: int = 1):
+    def __init__(self, save_dir: Union[str,Path], monitor: str = LogKeys.VAL_LOSS,
+                 save_best_only: bool = False, mode: Literal['auto', 'min', 'max']= 'auto', verbose: int = 1):
         super().__init__()
-        self.save_dir = make_fullpath(save_dir, make=True)
+        self.save_dir = make_fullpath(save_dir, make=True, enforce="directory")
         if not self.save_dir.is_dir():
             _LOGGER.error(f"{save_dir} is not a valid directory.")
             raise IOError()
@@ -226,17 +228,16 @@ class ModelCheckpoint(Callback):
         else:
             self.monitor_op = np.less if 'loss' in self.monitor else np.greater
         
-        self.best = np.Inf if self.monitor_op == np.less else -np.Inf
+        self.best = np.Inf if self.monitor_op == np.less else -np.Inf # type: ignore
 
     def on_train_begin(self, logs=None):
         """Reset state when training starts."""
-        self.best = np.Inf if self.monitor_op == np.less else -np.Inf
+        self.best = np.Inf if self.monitor_op == np.less else -np.Inf # type: ignore
         self.saved_checkpoints = []
         self.last_best_filepath = None
 
     def on_epoch_end(self, epoch, logs=None):
         logs = logs or {}
-        self.save_dir.mkdir(parents=True, exist_ok=True)
 
         if self.save_best_only:
             self._save_best_model(epoch, logs)
@@ -250,7 +251,7 @@ class ModelCheckpoint(Callback):
             return
 
         if self.monitor_op(current, self.best):
-            old_best_str = f"{self.best:.4f}" if self.best not in [np.Inf, -np.Inf] else "inf"
+            old_best_str = f"{self.best:.4f}" if self.best not in [np.Inf, -np.Inf] else "inf" # type: ignore
             
             # Create a descriptive filename
             filename = f"epoch_{epoch}-{self.monitor}_{current:.4f}.pth"

{dragon_ml_toolbox-5.1.0 → dragon_ml_toolbox-5.2.1}/ml_tools/ML_datasetmaster.py

@@ -386,23 +386,21 @@ class SimpleDatasetMaker:
                            test split.
         random_state (int): The seed for the random number generator for
                             reproducibility.
-        id (str | None): An optional object identifier.
     """
-    def __init__(self, pandas_df: pandas.DataFrame, test_size: float = 0.2, random_state: int = 42, id: Optional[str]=None):
-        """          
+    def __init__(self, pandas_df: pandas.DataFrame, test_size: float = 0.2, random_state: int = 42):
+        """
         Attributes:
             `train_dataset` -> PyTorch Dataset
             `test_dataset`  -> PyTorch Dataset
             `feature_names` -> list[str]
             `target_name`   -> str
             `id` -> str | None
+            
+        The ID can be manually set to any string if needed, it is `None` by default.
         """
         
         if not isinstance(pandas_df, pandas.DataFrame):
-            raise TypeError("Input must be a pandas.DataFrame.")
-        
-        #set id
-        self._id = id
+            raise TypeError("Input must be a pandas.DataFrame.")        
 
         # 1. Identify features and target
         features = pandas_df.iloc[:, :-1]
@@ -410,6 +408,9 @@ class SimpleDatasetMaker:
 
         self._feature_names = features.columns.tolist()
         self._target_name = target.name
+        
+        #set id
+        self._id: Optional[str] = None
 
         # 2. Split the data
         X_train, X_test, y_train, y_test = train_test_split(
@@ -447,8 +448,15 @@ class SimpleDatasetMaker:
     
     @property
     def id(self) -> Optional[str]:
-        """Returns teh object identifier if any."""
+        """Returns the object identifier if any."""
         return self._id
+    
+    @id.setter
+    def id(self, dataset_id: str):
+        """Sets the ID value"""
+        if not isinstance(dataset_id, str):
+            raise ValueError(f"Dataset ID '{type(dataset_id)}' is not a string.")
+        self._id = dataset_id
 
     def dataframes_info(self) -> None:
         """Prints the shape information of the split pandas DataFrames."""

dragon_ml_toolbox-5.2.1/ml_tools/ML_models.py

@@ -0,0 +1,134 @@
+import torch
+from torch import nn
+from ._script_info import _script_info
+from typing import List
+
+
+__all__ = [
+    "MultilayerPerceptron",
+    "SequencePredictorLSTM"
+]
+
+
+class MultilayerPerceptron(nn.Module):
+    """
+    Creates a versatile Multilayer Perceptron (MLP) for regression or classification tasks.
+
+    This model generates raw output values (logits) suitable for use with loss
+    functions like `nn.CrossEntropyLoss` (for classification) or `nn.MSELoss`
+    (for regression).
+
+    Args:
+        in_features (int): The number of input features (e.g., columns in your data).
+        out_targets (int): The number of output targets. For regression, this is
+            typically 1. For classification, it's the number of classes.
+        hidden_layers (list[int]): A list where each integer represents the
+            number of neurons in a hidden layer. Defaults to [40, 80, 40].
+        drop_out (float): The dropout probability for neurons in each hidden
+            layer. Must be between 0.0 and 1.0. Defaults to 0.2.
+            
+    ### Rules of thumb:
+    - Choose a number of hidden neurons between the size of the input layer and the size of the output layer. 
+    - The number of hidden neurons should be 2/3 the size of the input layer, plus the size of the output layer. 
+    - The number of hidden neurons should be less than twice the size of the input layer.
+    """
+    def __init__(self, in_features: int, out_targets: int,
+                 hidden_layers: List[int] = [40, 80, 40], drop_out: float = 0.2) -> None:
+        super().__init__()
+
+        # --- Validation ---
+        if not isinstance(in_features, int) or in_features < 1:
+            raise ValueError("in_features must be a positive integer.")
+        if not isinstance(out_targets, int) or out_targets < 1:
+            raise ValueError("out_targets must be a positive integer.")
+        if not isinstance(hidden_layers, list) or not all(isinstance(n, int) for n in hidden_layers):
+            raise TypeError("hidden_layers must be a list of integers.")
+        if not (0.0 <= drop_out < 1.0):
+            raise ValueError("drop_out must be a float between 0.0 and 1.0.")
+
+        # --- Build network layers ---
+        layers = []
+        current_features = in_features
+        for neurons in hidden_layers:
+            layers.extend([
+                nn.Linear(current_features, neurons),
+                nn.BatchNorm1d(neurons),
+                nn.ReLU(),
+                nn.Dropout(p=drop_out)
+            ])
+            current_features = neurons
+
+        # Add the final output layer
+        layers.append(nn.Linear(current_features, out_targets))
+
+        self._layers = nn.Sequential(*layers)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        """Defines the forward pass of the model."""
+        return self._layers(x)
+
+
+class SequencePredictorLSTM(nn.Module):
+    """
+    A simple LSTM-based network for sequence-to-sequence prediction tasks.
+
+    This model is designed for datasets where each input sequence maps to an
+    output sequence of the same length. It's suitable for forecasting problems
+    prepared by the `SequenceMaker` class.
+
+    The expected input shape is `(batch_size, sequence_length, features)`.
+
+    Args:
+        features (int): The number of features in the input sequence. Defaults to 1.
+        hidden_size (int): The number of features in the LSTM's hidden state.
+                           Defaults to 100.
+        recurrent_layers (int): The number of recurrent LSTM layers. Defaults to 1.
+        dropout (float): The dropout probability for all but the last LSTM layer.
+                         Defaults to 0.
+    """
+    def __init__(self, features: int = 1, hidden_size: int = 100,
+                 recurrent_layers: int = 1, dropout: float = 0):
+        super().__init__()
+
+        # --- Validation ---
+        if not isinstance(features, int) or features < 1:
+            raise ValueError("features must be a positive integer.")
+        if not isinstance(hidden_size, int) or hidden_size < 1:
+            raise ValueError("hidden_size must be a positive integer.")
+        if not isinstance(recurrent_layers, int) or recurrent_layers < 1:
+            raise ValueError("recurrent_layers must be a positive integer.")
+        if not (0.0 <= dropout < 1.0):
+            raise ValueError("dropout must be a float between 0.0 and 1.0.")
+
+        self.lstm = nn.LSTM(
+            input_size=features,
+            hidden_size=hidden_size,
+            num_layers=recurrent_layers,
+            dropout=dropout,
+            batch_first=True  # This is crucial for (batch, seq, feature) input
+        )
+        self.linear = nn.Linear(in_features=hidden_size, out_features=features)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        """
+        Defines the forward pass.
+
+        Args:
+            x (torch.Tensor): The input tensor with shape
+                              (batch_size, sequence_length, features).
+
+        Returns:
+            torch.Tensor: The output tensor with shape
+                          (batch_size, sequence_length, features).
+        """
+        # The LSTM returns the full output sequence and the final hidden/cell states
+        lstm_out, _ = self.lstm(x)
+        
+        # Pass the LSTM's output sequence to the linear layer
+        predictions = self.linear(lstm_out)
+        
+        return predictions
+
+
+def info():
+    _script_info(__all__)

{dragon_ml_toolbox-5.1.0 → dragon_ml_toolbox-5.2.1}/ml_tools/ML_optimization.py

@@ -1,5 +1,5 @@
 import torch
-import numpy
+import numpy    #handling torch to numpy
 import evotorch
 from evotorch.algorithms import CMAES, SteadyStateGA
 from evotorch.logging import StdOutLogger
@@ -32,7 +32,7 @@ def create_pytorch_problem(
     algorithm: Literal["CMAES", "GA"] = "CMAES",
     verbose: bool = False,
     **searcher_kwargs
-) -> Tuple[evotorch.Problem, evotorch.Searcher]:
+) -> Tuple[evotorch.Problem, evotorch.Searcher]: # type: ignore
     """
     Creates and configures an EvoTorch Problem and Searcher for a PyTorch model.
 
@@ -62,22 +62,11 @@ def create_pytorch_problem(
     device = handler.device
 
     # Define the fitness function that EvoTorch will call.
-    @evotorch.decorators.to_tensor
+    @evotorch.decorators.to_tensor # type: ignore
     @evotorch.decorators.on_aux_device(device)
     def fitness_func(solution_tensor: torch.Tensor) -> torch.Tensor:
-        # Make a mutable copy of the solutions from the optimizer
-        processed_tensor = solution_tensor.clone()
-
-        # Apply thresholding if binary features are present
-        if binary_features > 0:
-            # Isolate the binary part of the tensor (the last n columns)
-            binary_part = processed_tensor[:, -binary_features:]
-            
-            # Apply rounding to snap values to 0.0 or 1.0
-            processed_tensor[:, -binary_features:] = torch.round(binary_part)
-
-        # Use the processed tensor (with thresholded values) for prediction
-        predictions = handler.predict_batch(processed_tensor)[PyTorchInferenceKeys.PREDICTIONS]
+        # Directly use the continuous-valued tensor from the optimizer for prediction
+        predictions = handler.predict_batch(solution_tensor)[PyTorchInferenceKeys.PREDICTIONS]
         return predictions.flatten()
 
     # Create the Problem instance.
@@ -107,7 +96,7 @@ def create_pytorch_problem(
 
 def run_optimization(
     problem: evotorch.Problem,
-    searcher: evotorch.Searcher,
+    searcher: evotorch.Searcher, # type: ignore
     num_generations: int,
     target_name: str,
     binary_features: int,
@@ -168,7 +157,7 @@ def run_optimization(
     
     # preprocess feature names
     if feature_names is None:
-        feature_names = [f"feature_{i}" for i in range(problem.solution_length)]
+        feature_names = [f"feature_{i}" for i in range(problem.solution_length)] # type: ignore
     
     # --- SINGLE RUN LOGIC ---
     if repetitions <= 1:

{dragon_ml_toolbox-5.1.0 → dragon_ml_toolbox-5.2.1}/ml_tools/ML_trainer.py

@@ -108,6 +108,8 @@ class MyTrainer:
     def fit(self, epochs: int = 10, batch_size: int = 10, shuffle: bool = True):
         """
         Starts the training-validation process of the model.
+        
+        Returns the "History" callback dictionary.
 
         Args:
             epochs (int): The total number of epochs to train for.

{dragon_ml_toolbox-5.1.0 → dragon_ml_toolbox-5.2.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "dragon-ml-toolbox"
-version = "5.1.0"
+version = "5.2.1"
 description = "A collection of tools for data science and machine learning projects."
 authors = [
     { name = "Karl Loza", email = "luigiloza@gmail.com" }

dragon_ml_toolbox-5.1.0/ml_tools/_pytorch_models.py

@@ -1,239 +0,0 @@
-import torch
-from torch import nn
-from ._script_info import _script_info
-
-
-__all__ = [
-    "MyNeuralNetwork",
-    "MyLSTMNetwork"
-]
-
-
-class MyNeuralNetwork(nn.Module):
-    def __init__(self, in_features: int, out_targets: int, hidden_layers: list[int]=[40,80,40], drop_out: float=0.2) -> None:
-        """
-        Creates a basic Neural Network.
-        
-        * For Regression the last layer is Linear. 
-        * For Classification the last layer is Logarithmic Softmax.
-        
-        `out_targets` Is the number of expected output classes for classification; or `1` for regression.
-        
-        `hidden_layers` takes a list of integers. Each position represents a hidden layer and its number of neurons. 
-        
-        * One rule of thumb is to choose a number of hidden neurons between the size of the input layer and the size of the output layer. 
-        * Another rule suggests that the number of hidden neurons should be 2/3 the size of the input layer, plus the size of the output layer. 
-        * Another rule suggests that the number of hidden neurons should be less than twice the size of the input layer.
-        
-        `drop_out` represents the probability of neurons to be set to '0' during the training process of each layer. Range [0.0, 1.0).
-        """
-        super().__init__()
-        
-        # Validate inputs and outputs
-        if isinstance(in_features, int) and isinstance(out_targets, int):
-            if in_features < 1 or out_targets < 1:
-                raise ValueError("Inputs or Outputs must be an integer value.")
-        else:
-            raise TypeError("Inputs or Outputs must be an integer value.")
-        
-        # Validate layers
-        if isinstance(hidden_layers, list):
-            for number in hidden_layers:
-                if not isinstance(number, int):
-                    raise TypeError("Number of neurons per hidden layer must be an integer value.")
-        else:
-            raise TypeError("hidden_layers must be a list of integer values.")
-        
-        # Validate dropout
-        if isinstance(drop_out, float):
-            if 1.0 > drop_out >= 0.0:
-                pass
-            else:
-                raise TypeError("drop_out must be a float value greater than or equal to 0 and less than 1.")
-        elif drop_out == 0:
-            pass
-        else:
-            raise TypeError("drop_out must be a float value greater than or equal to 0 and less than 1.")
-        
-        # Create layers        
-        layers = list()
-        for neurons in hidden_layers:
-            layers.append(nn.Linear(in_features=in_features, out_features=neurons))
-            layers.append(nn.BatchNorm1d(num_features=neurons))
-            layers.append(nn.ReLU())
-            layers.append(nn.Dropout(p=drop_out))
-            in_features = neurons    
-        # Append output layer
-        layers.append(nn.Linear(in_features=in_features, out_features=out_targets))
-        
-        # Check for classification or regression output
-        if out_targets > 1:
-            # layers.append(nn.Sigmoid())
-            layers.append(nn.LogSoftmax(dim=1))
-        
-        # Create a container for layers
-        self._layers = nn.Sequential(*layers)
-    
-    # Override forward()
-    def forward(self, X: torch.Tensor) -> torch.Tensor:
-        X = self._layers(X)
-        return X
-
-
-class _MyConvolutionalNetwork(nn.Module):
-    def __init__(self, outputs: int, color_channels: int=3, img_size: int=256, drop_out: float=0.2):
-        """
-        - EDUCATIONAL PURPOSES ONLY, not optimized and requires lots of memory.
-        
-        Create a basic Convolutional Neural Network with two convolution layers with a pooling layer after each convolution.
-
-        Args:
-            `outputs`: Number of output classes (1 for regression).
-            
-            `color_channels`: Color channels. Default is 3 (RGB).
-            
-            `img_size`: Width and Height of image samples, must be square images. Default is 200.
-            
-            `drop_out`: Neuron drop out probability. Default is 20%.
-        """
-        super().__init__()
-        
-        # Validate outputs number
-        integer_error = " must be an integer greater than 0."
-        if isinstance(outputs, int):
-            if outputs < 1:
-                raise ValueError("Outputs" + integer_error)
-        else:
-            raise TypeError("Outputs" + integer_error)
-        # Validate color channels
-        if isinstance(color_channels, int):
-            if color_channels < 1:
-                raise ValueError("Color Channels" + integer_error)
-        else:
-            raise TypeError("Color Channels" + integer_error)
-        # Validate image size
-        if isinstance(img_size, int):
-            if img_size < 1:
-                raise ValueError("Image size" + integer_error)
-        else:
-            raise TypeError("Image size" + integer_error)        
-        # Validate drop out
-        if isinstance(drop_out, float):
-            if 1.0 > drop_out >= 0.0:
-                pass
-            else:
-                raise TypeError("Drop out must be a float value greater than or equal to 0 and less than 1.")
-        elif drop_out == 0:
-            pass
-        else:
-            raise TypeError("Drop out must be a float value greater than or equal to 0 and less than 1.")
-        
-        # 2 convolutions, 2 pooling layers
-        self._cnn_layers = nn.Sequential(
-            nn.Conv2d(in_channels=color_channels, out_channels=(color_channels * 2), kernel_size=5, stride=1, padding=1),
-            nn.MaxPool2d(kernel_size=4, stride=(4,4)),
-            nn.Conv2d(in_channels=(color_channels * 2), out_channels=(color_channels * 3), kernel_size=3, stride=1, padding=0),
-            nn.AvgPool2d(kernel_size=2, stride=(2,2))
-        )
-        # Calculate output features
-        flat_features = int(int((int((img_size + 2 - (5-1))//4) - (3-1))//2)**2) * (color_channels * 3)
-        
-        # Make a standard ANN
-        ann = MyNeuralNetwork(in_features=flat_features, hidden_layers=[int(flat_features*0.5), int(flat_features*0.2), int(flat_features*0.005)], 
-                              out_targets=outputs, drop_out=drop_out)
-        self._ann_layers = ann._layers
-        
-        # Join CNN and ANN
-        self._structure = nn.Sequential(self._cnn_layers, nn.Flatten(), self._ann_layers)
-        
-        # Send to CUDA if available
-        # if torch.cuda.is_available():
-        #     self.to('cuda')
-        
-    # Override forward()
-    def forward(self, X: torch.Tensor) -> torch.Tensor:
-        X = self._structure(X)
-        return X
-
-
-class MyLSTMNetwork(nn.Module):
-    def __init__(self, features: int=1, hidden_size: int=100, recurrent_layers: int=1, dropout: float=0, reset_memory: bool=False, **kwargs):
-        """
-        Create a simple Recurrent Neural Network to predict 1 time step into the future of sequential data.
-        
-        The sequence should be a 2D tensor with shape (sequence_length, number_of_features).
-
-        Args:
-            * `features`: Number of features representing the sequence. Defaults to 1.
-            * `hidden_size`: Hidden size of the LSTM model. Defaults to 100.
-            * `recurrent_layers`: Number of recurrent layers to use. Defaults to 1.
-            * `dropout`: Probability of dropping out neurons in each recurrent layer, except the last layer. Defaults to 0.
-            * `reset_memory`: Reset the initial hidden state and cell state for the recurrent layers at every epoch. Defaults to False.
-            * `kwargs`: Create custom attributes for the model.
-            
-        Custom forward() parameters:
-            * `batch_size=1` (int): batch size for the LSTM net.
-            * `return_last_timestamp=False` (bool): Return only the value at `output[-1]`
-        """
-        # validate input size
-        if not isinstance(features, int):
-            raise TypeError("Input size must be an integer value.")
-        # validate hidden size
-        if not isinstance(hidden_size, int):
-            raise TypeError("Hidden size must be an integer value.")
-        # validate layers
-        if not isinstance(recurrent_layers, int):
-            raise TypeError("Number of recurrent layers must be an integer value.")
-        # validate dropout
-        if isinstance(dropout, (float, int)):
-            if 0 <= dropout < 1:
-                pass
-            else:
-                raise ValueError("Dropout must be a float in range [0.0, 1.0)")
-        else:
-            raise TypeError("Dropout must be a float in range [0.0, 1.0)")
-        
-        super().__init__()
-        
-        # Initialize memory
-        self._reset = reset_memory
-        self._memory = None
-        
-        # hidden size and features shape
-        self._hidden = hidden_size
-        self._features = features
-        
-        # RNN
-        self._lstm = nn.LSTM(input_size=features, hidden_size=self._hidden, num_layers=recurrent_layers, dropout=dropout)
-        
-        # Fully connected layer
-        self._ann = nn.Linear(in_features=self._hidden, out_features=features)
-        
-        # Parse extra parameters
-        for key, value in kwargs.items():
-            setattr(self, key, value)
-            
-        
-    def forward(self, seq: torch.Tensor, batch_size: int=1, return_last_timestamp: bool=False) -> torch.Tensor:
-        # reset memory
-        if self._reset:
-            self._memory = None
-        # reshape sequence to feed RNN
-        seq = seq.view(-1, batch_size, self._features)
-        # Pass sequence through RNN
-        seq, self._memory = self._lstm(seq, self._memory)
-        # Detach hidden state and cell state to prevent backpropagation error
-        self._memory = tuple(m.detach() for m in self._memory)
-        # Reshape outputs
-        seq = seq.view(-1, self._hidden)
-        # Pass sequence through fully connected layer
-        output = self._ann(seq)
-        # Return prediction of 1 time step in the future
-        if return_last_timestamp:
-            return output[-1].view(1,-1) #last item as a tensor.
-        else:
-            return output
-
-
-def info():
-    _script_info(__all__)