Updating Torchmetrics dependency (#142)

* [skip actions] updated history

* updated torchmetrics

Author: manujosephv

docs/history.md

@@ -43,3 +43,31 @@
 - Made the temp folder pytorch tabular specific to avoid conflicts with other tmp folders.
 - Some bug fixes
 - Edited an error out of Advanced Tutorial in docs
+
+## 1.0.0 (2023-01-18)
+
+- Added a new task - Self Supervised Learning (SSL) and a separate training API for it.
+- Added new SOTA model - Gated Additive Tree Ensembles (GATE).
+- Added one SSL model - Denoising AutoEncoder.
+- Added lots of new tutorials and updated entire documentation.
+- Improved code documentation and type hints.
+- Separated a Model into separate Embedding, Backbone, and Head.
+- Refactored all models to separate Backbone as native PyTorch Model(nn.Module).
+- Refactored commonly used modules (layers, activations etc. to a common module).
+- Changed MixedDensityNetworks completely (breaking change). Now MDN is a head you can use with any model.
+- Enabled a low level api for training model.
+- Enabled saving and loading of datamodule.
+- Added trainer_kwargs to pass any trainer argument PyTorch Lightning supports.
+- Added Early Stopping and Model Checkpoint kwargs to use all the arguments in PyTorch Lightining.
+- Enabled prediction using GPUs in predict method.
+- Added `reset_model` to reset model weights to random.
+- Added many save and load functions including ONNX(experimental).
+- Added random seed as a parameter.
+- Switched over completely to Rich progressbars from tqdm.
+- Fixed class-balancing / mu propagation and set default to 1.0.
+- Added PyTorch Profiler for debugging performance issues.
+- Fixed bugs with FTTransformer and TabTransformer.
+- Updated MixedDensityNetworks fixing a bug with lambda_pi.
+- Many CI/CD improvements including complete integration with GitHub Actions.
+- Upgraded all dependencies, including PyTorch Lightning, pandas, to latest versions and added dependabot to manage it going forward.
+- Added pre-commit to ensure code integrity and standardization.

examples/__only_for_dev__/to_test_dae.py

@@ -140,7 +140,7 @@ def print_metrics(y_true, y_pred, tag):
 from pytorch_tabular.models import CategoryEmbeddingModelConfig  # noqa: E402
 from pytorch_tabular.ssl_models.dae import DenoisingAutoEncoderConfig  # noqa: E402
 
-max_epochs = 5
+max_epochs = 1
 batch_size = 1024
 lr = 1e-3
 
@@ -159,7 +159,7 @@ def print_metrics(y_true, y_pred, tag):
     auto_lr_find=False,  # Runs the LRFinder to automatically derive a learning rate
     batch_size=batch_size,
     max_epochs=max_epochs,
-    fast_dev_run=False,
+    fast_dev_run=True,
 )
 optimizer_config = OptimizerConfig()
 encoder_config = CategoryEmbeddingModelConfig(

requirements.txt

@@ -5,7 +5,7 @@ pandas>=1.1.5
 scikit-learn>=1.0.0
 pytorch-lightning==1.8.*
 omegaconf>=2.0.1
-torchmetrics==0.10.*
+torchmetrics==0.11.*
 tensorboard>=2.2.0, !=2.5.0
 protobuf<=3.20.*
 pytorch-tabnet==4.0

src/pytorch_tabular/config/config.py

@@ -193,6 +193,9 @@ class InferredConfig:
 
         embedding_dims (Optional[List]): The dimensions of the embedding for each categorical column as a
                 list of tuples (cardinality, embedding_dim).
+
+        embedded_cat_dim (int): The number of features or dimensions of the embedded categorical features
+
     """
 
     categorical_dim: int = field(

src/pytorch_tabular/models/base_model.py

@@ -4,6 +4,7 @@
 """Base Model"""
 import warnings
 from abc import ABCMeta, abstractmethod
+from functools import partial
 from typing import Any, Callable, Dict, List, Optional, Tuple, Union
 
 import pytorch_lightning as pl
@@ -86,8 +87,27 @@ def __init__(
         if self.custom_loss is not None:
             config.loss = str(self.custom_loss)
         if self.custom_metrics is not None:
-            config.metrics = [str(m) for m in self.custom_metrics]
-            config.metrics_params = [vars(m) for m in self.custom_metrics]
+            # Adding metrics to config for hparams logging and tracking
+            config.metrics = []
+            config.metrics_params = []
+            for metric in self.custom_metrics:
+                if isinstance(metric, partial):
+                    # extracting func names from partial functions
+                    config.metrics.append(metric.func.__name__)
+                    config.metrics_params.append(metric.keywords)
+                else:
+                    config.metrics.append(metric.__name__)
+                    config.metrics_params.append(vars(metric))
+        else:  # Updating default metrics in config
+            if config.task == "classification":
+                # Adding metric_params to config for classification task
+                for i, metric_params in enumerate(config.metrics_params):
+                    if "task" not in metric_params:
+                        # For classification task, output_dim == number of classses
+                        config.metrics_params[i]["task"] = "binary" if inferred_config.output_dim == 2 else "multiclass"
+                    if "num_classes" not in metric_params:
+                        config.metrics_params[i]["num_classes"] = inferred_config.output_dim
+
         if self.custom_optimizer is not None:
             config.optimizer = str(self.custom_optimizer.__class__.__name__)
         if len(self.custom_optimizer_params) > 0:
@@ -167,7 +187,6 @@ def _setup_metrics(self):
                     raise e
         else:
             self.metrics = self.custom_metrics
-            self.hparams.metrics = [m.__name__ for m in self.custom_metrics]
 
     def calculate_loss(self, output: Dict, y: torch.Tensor, tag: str) -> torch.Tensor:
         """Calculates the loss for the model
@@ -241,7 +260,11 @@ def calculate_metrics(self, y: torch.Tensor, y_hat: torch.Tensor, tag: str) -> L
             if self.hparams.task == "regression":
                 _metrics = []
                 for i in range(self.hparams.output_dim):
-                    if metric.__name__ == torchmetrics.functional.mean_squared_log_error.__name__:
+                    if isinstance(metric, partial):
+                        name = metric.func.__name__
+                    else:
+                        name = metric.__name__
+                    if name == torchmetrics.functional.mean_squared_log_error.__name__:
                         # MSLE should only be used in strictly positive targets. It is undefined otherwise
                         _metric = metric(
                             torch.clamp(y_hat[:, i], min=0),

src/pytorch_tabular/models/ft_transformer/config.py

@@ -181,7 +181,7 @@ class FTTransformerConfig(ModelConfig):
         default=4,
         metadata={"help": "Multiple by which the Positionwise FF layer scales the input. Defaults to 4"},
     )
-    # TODO improve documentation
+
     transformer_activation: str = field(
         default="GEGLU",
         metadata={

src/pytorch_tabular/models/tab_transformer/config.py

@@ -172,7 +172,6 @@ class TabTransformerConfig(ModelConfig):
         default=4,
         metadata={"help": "Multiple by which the Positionwise FF layer scales the input. Defaults to 4"},
     )
-    # TODO improve documentation
     transformer_activation: str = field(
         default="GEGLU",
         metadata={

src/pytorch_tabular/tabular_model.py

@@ -7,6 +7,7 @@
 import os
 import warnings
 from collections import defaultdict
+from functools import partial
 from pathlib import Path
 from typing import Callable, Dict, Iterable, List, Optional, Tuple, Union
 
@@ -370,7 +371,7 @@ def load_model(cls, dir: str, map_location=None, strict=True):
             model_args["loss"] = "MSELoss"  # For compatibility. Not Used
         if custom_params.get("custom_metrics") is not None:
             model_args["metrics"] = ["mean_squared_error"]  # For compatibility. Not Used
-            model_args["metric_params"] = [{}]  # For compatibility. Not Used
+            model_args["metrics_params"] = [{}]  # For compatibility. Not Used
         if custom_params.get("custom_optimizer") is not None:
             model_args["optimizer"] = "Adam"  # For compatibility. Not Used
         if custom_params.get("custom_optimizer_params") is not None:
@@ -815,6 +816,14 @@ def create_finetune_model(
         datamodule.target = config.target
         datamodule.batch_size = config.batch_size
         datamodule.seed = config.seed
+        model_callable = _GenericModel
+        inferred_config = self.datamodule.update_config(config)
+        inferred_config = OmegaConf.structured(inferred_config)
+        # Adding dummy attributes for compatibility. Not used because custom metrics are provided
+        if not hasattr(config, "metrics"):
+            config.metrics = "dummy"
+        if not hasattr(config, "metrics_params"):
+            config.metrics_params = {}
         if metrics is not None:
             assert len(metrics) == len(metrics_params), "Number of metrics and metrics_params should be same"
             metrics = [getattr(torchmetrics.functional, m) if isinstance(m, str) else m for m in metrics]
@@ -827,11 +836,21 @@ def create_finetune_model(
             loss = loss if loss is not None else torch.nn.CrossEntropyLoss()
             if metrics is None:
                 metrics = [torchmetrics.functional.accuracy]
-                metrics_params = [{}]
-
-        model_callable = _GenericModel
-        inferred_config = self.datamodule.update_config(config)
-        inferred_config = OmegaConf.structured(inferred_config)
+                metrics_params = [
+                    {
+                        "task": "binary" if inferred_config.output_dim == 2 else "multiclass",
+                        "num_classes": inferred_config.output_dim,
+                    }
+                ]
+            else:
+                for i, mp in enumerate(metrics_params):
+                    if "task" not in mp:
+                        # For classification task, output_dim == number of classses
+                        metrics_params[i]["task"] = "binary" if inferred_config.output_dim == 2 else "multiclass"
+                    if "num_classes" not in mp:
+                        metrics_params[i]["num_classes"] = inferred_config.output_dim
+        # Forming partial callables using metrics and metric params
+        metrics = [partial(m, **mp) for m, mp in zip(metrics, metrics_params)]
         self.model.mode = "finetune"
         if learning_rate is not None:
             config.learning_rate = learning_rate