dragon-ml-toolbox 5.0.0__tar.gz → 5.2.0__tar.gz

{dragon_ml_toolbox-5.0.0/dragon_ml_toolbox.egg-info → dragon_ml_toolbox-5.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dragon-ml-toolbox
-Version: 5.0.0
+Version: 5.2.0
 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
@@ -268,5 +269,5 @@ After installation, import modules like this:
 
 ```python
 from ml_tools.utilities import serialize_object, deserialize_object
-from ml_tools.custom_logger import custom_logger
+from ml_tools import custom_logger
 ```

{dragon_ml_toolbox-5.0.0 → dragon_ml_toolbox-5.2.0}/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
@@ -187,5 +188,5 @@ After installation, import modules like this:
 
 ```python
 from ml_tools.utilities import serialize_object, deserialize_object
-from ml_tools.custom_logger import custom_logger
+from ml_tools import custom_logger
 ```

{dragon_ml_toolbox-5.0.0 → dragon_ml_toolbox-5.2.0/dragon_ml_toolbox.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dragon-ml-toolbox
-Version: 5.0.0
+Version: 5.2.0
 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
@@ -268,5 +269,5 @@ After installation, import modules like this:
 
 ```python
 from ml_tools.utilities import serialize_object, deserialize_object
-from ml_tools.custom_logger import custom_logger
+from ml_tools import custom_logger
 ```

{dragon_ml_toolbox-5.0.0 → dragon_ml_toolbox-5.2.0}/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.0.0 → dragon_ml_toolbox-5.2.0}/ml_tools/ML_datasetmaster.py

@@ -21,6 +21,7 @@ from ._script_info import _script_info
 # --- public-facing API ---
 __all__ = [
     "DatasetMaker",
+    "SimpleDatasetMaker",
     "VisionDatasetMaker",
     "SequenceMaker",
     "ResizeAspectFill",
@@ -328,7 +329,7 @@ class DatasetMaker(_BaseMaker):
 
         return self.scaler.inverse_transform(data_np)
 
-    def get_datasets(self) -> Tuple[_PytorchDataset, _PytorchDataset]:
+    def get_datasets(self) -> Tuple[Dataset, Dataset]:
         """Primary method to get the final PyTorch Datasets."""
         if not self._is_split:
             raise RuntimeError("Data has not been split yet. Call .split_data() or .process() first.")
@@ -370,6 +371,95 @@ class DatasetMaker(_BaseMaker):
         return pandas.DataFrame(full_tensor.numpy(), columns=new_columns, index=cat_df.index)
 
 
+# Streamlined DatasetMaker version
+class SimpleDatasetMaker:
+    """
+    A simplified dataset maker for pre-processed, numerical pandas DataFrames.
+
+    This class takes a DataFrame, automatically splits it into training and
+    testing sets, and converts them into PyTorch Datasets. It assumes the
+    target variable is the last column.
+
+    Args:
+        pandas_df (pandas.DataFrame): The pre-processed input DataFrame with numerical data.
+        test_size (float): The proportion of the dataset to allocate to the
+                           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):
+        """          
+        Attributes:
+            `train_dataset` -> PyTorch Dataset
+            `test_dataset`  -> PyTorch Dataset
+            `feature_names` -> list[str]
+            `target_name`   -> str
+            `id` -> str | None
+        """
+        
+        if not isinstance(pandas_df, pandas.DataFrame):
+            raise TypeError("Input must be a pandas.DataFrame.")
+        
+        #set id
+        self._id = id
+
+        # 1. Identify features and target
+        features = pandas_df.iloc[:, :-1]
+        target = pandas_df.iloc[:, -1]
+
+        self._feature_names = features.columns.tolist()
+        self._target_name = target.name
+
+        # 2. Split the data
+        X_train, X_test, y_train, y_test = train_test_split(
+            features, target, test_size=test_size, random_state=random_state
+        )
+
+        self._X_train_shape = X_train.shape
+        self._X_test_shape = X_test.shape
+        self._y_train_shape = y_train.shape
+        self._y_test_shape = y_test.shape
+
+        # 3. Convert to PyTorch Datasets
+        self._train_ds = _PytorchDataset(X_train.values, y_train.values)
+        self._test_ds = _PytorchDataset(X_test.values, y_test.values)
+
+    @property
+    def train_dataset(self) -> Dataset:
+        """Returns the training PyTorch dataset."""
+        return self._train_ds
+
+    @property
+    def test_dataset(self) -> Dataset:
+        """Returns the testing PyTorch dataset."""
+        return self._test_ds
+
+    @property
+    def feature_names(self) -> list[str]:
+        """Returns the list of feature column names."""
+        return self._feature_names
+
+    @property
+    def target_name(self) -> str:
+        """Returns the name of the target column."""
+        return str(self._target_name)
+    
+    @property
+    def id(self) -> Optional[str]:
+        """Returns the object identifier if any."""
+        return self._id
+
+    def dataframes_info(self) -> None:
+        """Prints the shape information of the split pandas DataFrames."""
+        print("--- Original DataFrame Shapes After Split ---")
+        print(f"  X_train shape: {self._X_train_shape}")
+        print(f"  y_train shape: {self._y_train_shape}\n")
+        print(f"  X_test shape:  {self._X_test_shape}")
+        print(f"  y_test shape:  {self._y_test_shape}")
+        print("-------------------------------------------")
+
+
 # --- VisionDatasetMaker ---
 class VisionDatasetMaker(_BaseMaker):
     """

dragon_ml_toolbox-5.2.0/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.0.0 → dragon_ml_toolbox-5.2.0}/pyproject.toml

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

dragon_ml_toolbox-5.0.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__)