autogluon.tabular 1.2.1b20250115__tar.gz → 1.2.1b20250130__tar.gz

autogluon.tabular-1.2.1b20250130/PKG-INFO

@@ -0,0 +1,151 @@
+Metadata-Version: 2.1
+Name: autogluon.tabular
+Version: 1.2.1b20250130
+Summary: Fast and Accurate ML in 3 Lines of Code
+Home-page: https://github.com/autogluon/autogluon
+Author: AutoGluon Community
+License: Apache-2.0
+Project-URL: Documentation, https://auto.gluon.ai
+Project-URL: Bug Reports, https://github.com/autogluon/autogluon/issues
+Project-URL: Source, https://github.com/autogluon/autogluon/
+Project-URL: Contribute!, https://github.com/autogluon/autogluon/blob/master/CONTRIBUTING.md
+Platform: UNKNOWN
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Customer Service
+Classifier: Intended Audience :: Financial and Insurance Industry
+Classifier: Intended Audience :: Healthcare Industry
+Classifier: Intended Audience :: Telecommunications Industry
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: Unix
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Classifier: Topic :: Scientific/Engineering :: Image Recognition
+Requires-Python: >=3.9, <3.13
+Description-Content-Type: text/markdown
+Provides-Extra: lightgbm
+Provides-Extra: catboost
+Provides-Extra: xgboost
+Provides-Extra: fastai
+Provides-Extra: tabpfn
+Provides-Extra: tabpfnmix
+Provides-Extra: ray
+Provides-Extra: skex
+Provides-Extra: imodels
+Provides-Extra: vowpalwabbit
+Provides-Extra: skl2onnx
+Provides-Extra: all
+Provides-Extra: tests
+License-File: ../LICENSE
+License-File: ../NOTICE
+
+
+
+<div align="center">
+<img src="https://user-images.githubusercontent.com/16392542/77208906-224aa500-6aba-11ea-96bd-e81806074030.png" width="350">
+
+## Fast and Accurate ML in 3 Lines of Code
+
+[![Latest Release](https://img.shields.io/github/v/release/autogluon/autogluon)](https://github.com/autogluon/autogluon/releases)
+[![Conda Forge](https://img.shields.io/conda/vn/conda-forge/autogluon.svg)](https://anaconda.org/conda-forge/autogluon)
+[![Python Versions](https://img.shields.io/badge/python-3.9%20%7C%203.10%20%7C%203.11%20%7C%203.12-blue)](https://pypi.org/project/autogluon/)
+[![Downloads](https://pepy.tech/badge/autogluon/month)](https://pepy.tech/project/autogluon)
+[![GitHub license](https://img.shields.io/badge/License-Apache_2.0-blue.svg)](./LICENSE)
+[![Discord](https://img.shields.io/discord/1043248669505368144?color=7289da&label=Discord&logo=discord&logoColor=ffffff)](https://discord.gg/wjUmjqAc2N)
+[![Twitter](https://img.shields.io/twitter/follow/autogluon?style=social)](https://twitter.com/autogluon)
+[![Continuous Integration](https://github.com/autogluon/autogluon/actions/workflows/continuous_integration.yml/badge.svg)](https://github.com/autogluon/autogluon/actions/workflows/continuous_integration.yml)
+[![Platform Tests](https://github.com/autogluon/autogluon/actions/workflows/platform_tests-command.yml/badge.svg?event=schedule)](https://github.com/autogluon/autogluon/actions/workflows/platform_tests-command.yml)
+
+[Installation](https://auto.gluon.ai/stable/install.html) | [Documentation](https://auto.gluon.ai/stable/index.html) | [Release Notes](https://auto.gluon.ai/stable/whats_new/index.html)
+
+AutoGluon automates machine learning tasks enabling you to easily achieve strong predictive performance in your applications.  With just a few lines of code, you can train and deploy high-accuracy machine learning and deep learning models on image, text, time series, and tabular data.
+</div>
+
+## 💾 Installation
+
+AutoGluon is supported on Python 3.9 - 3.12 and is available on Linux, MacOS, and Windows.
+
+You can install AutoGluon with:
+
+```python
+pip install autogluon
+```
+
+Visit our [Installation Guide](https://auto.gluon.ai/stable/install.html) for detailed instructions, including GPU support, Conda installs, and optional dependencies.
+
+## :zap: Quickstart
+
+Build accurate end-to-end ML models in just 3 lines of code!
+
+```python
+from autogluon.tabular import TabularPredictor
+predictor = TabularPredictor(label="class").fit("train.csv")
+predictions = predictor.predict("test.csv")
+```
+
+| AutoGluon Task      |                                                                                Quickstart                                                                                |                                                                                API                                                                                |
+|:--------------------|:------------------------------------------------------------------------------------------------------------------------------------------------------------------------:|:-----------------------------------------------------------------------------------------------------------------------------------------------------------------:|
+| TabularPredictor    | [![Quick Start](https://img.shields.io/static/v1?label=&message=tutorial&color=grey)](https://auto.gluon.ai/stable/tutorials/tabular/tabular-quick-start.html) |                 [![API](https://img.shields.io/badge/api-reference-blue.svg)](https://auto.gluon.ai/stable/api/autogluon.tabular.TabularPredictor.html)                 |
+| MultiModalPredictor | [![Quick Start](https://img.shields.io/static/v1?label=&message=tutorial&color=grey)](https://auto.gluon.ai/stable/tutorials/multimodal/multimodal_prediction/multimodal-quick-start.html)            | [![API](https://img.shields.io/badge/api-reference-blue.svg)](https://auto.gluon.ai/stable/api/autogluon.multimodal.MultiModalPredictor.html) |
+| TimeSeriesPredictor | [![Quick Start](https://img.shields.io/static/v1?label=&message=tutorial&color=grey)](https://auto.gluon.ai/stable/tutorials/timeseries/forecasting-quick-start.html)            | [![API](https://img.shields.io/badge/api-reference-blue.svg)](https://auto.gluon.ai/stable/api/autogluon.timeseries.TimeSeriesPredictor.html) |
+
+## :mag: Resources
+
+### Hands-on Tutorials / Talks
+
+Below is a curated list of recent tutorials and talks on AutoGluon. A comprehensive list is available [here](AWESOME.md#videos--tutorials).
+
+| Title                                                                                                                    | Format   | Location                                                                         | Date       |
+|--------------------------------------------------------------------------------------------------------------------------|----------|----------------------------------------------------------------------------------|------------|
+| :tv: [AutoGluon: Towards No-Code Automated Machine Learning](https://www.youtube.com/watch?v=SwPq9qjaN2Q)                | Tutorial | [AutoML 2024](https://2024.automl.cc/)                                           | 2024/09/09 |
+| :tv: [AutoGluon 1.0: Shattering the AutoML Ceiling with Zero Lines of Code](https://www.youtube.com/watch?v=5tvp_Ihgnuk) | Tutorial | [AutoML 2023](https://2023.automl.cc/)                                           | 2023/09/12 |
+| :sound: [AutoGluon: The Story](https://automlpodcast.com/episode/autogluon-the-story)                                    | Podcast  | [The AutoML Podcast](https://automlpodcast.com/)                                 | 2023/09/05 |
+| :tv: [AutoGluon: AutoML for Tabular, Multimodal, and Time Series Data](https://youtu.be/Lwu15m5mmbs?si=jSaFJDqkTU27C0fa) | Tutorial | PyData Berlin                                                                    | 2023/06/20 | 
+| :tv: [Solving Complex ML Problems in a few Lines of Code with AutoGluon](https://www.youtube.com/watch?v=J1UQUCPB88I)    | Tutorial | PyData Seattle                                                                   | 2023/06/20 | 
+| :tv: [The AutoML Revolution](https://www.youtube.com/watch?v=VAAITEds-28)                                                | Tutorial | [Fall AutoML School 2022](https://sites.google.com/view/automl-fall-school-2022) | 2022/10/18 |
+
+### Scientific Publications
+- [AutoGluon-Tabular: Robust and Accurate AutoML for Structured Data](https://arxiv.org/pdf/2003.06505.pdf) (*Arxiv*, 2020) ([BibTeX](CITING.md#general-usage--autogluontabular))
+- [Fast, Accurate, and Simple Models for Tabular Data via Augmented Distillation](https://proceedings.neurips.cc/paper/2020/hash/62d75fb2e3075506e8837d8f55021ab1-Abstract.html) (*NeurIPS*, 2020) ([BibTeX](CITING.md#tabular-distillation))
+- [Benchmarking Multimodal AutoML for Tabular Data with Text Fields](https://datasets-benchmarks-proceedings.neurips.cc/paper/2021/file/9bf31c7ff062936a96d3c8bd1f8f2ff3-Paper-round2.pdf) (*NeurIPS*, 2021) ([BibTeX](CITING.md#autogluonmultimodal))
+- [XTab: Cross-table Pretraining for Tabular Transformers](https://proceedings.mlr.press/v202/zhu23k/zhu23k.pdf) (*ICML*, 2023)
+- [AutoGluon-TimeSeries: AutoML for Probabilistic Time Series Forecasting](https://arxiv.org/abs/2308.05566) (*AutoML Conf*, 2023) ([BibTeX](CITING.md#autogluontimeseries))
+- [TabRepo: A Large Scale Repository of Tabular Model Evaluations and its AutoML Applications](https://arxiv.org/pdf/2311.02971.pdf) (*Under Review*, 2024)
+
+### Articles
+- [AutoGluon-TimeSeries: Every Time Series Forecasting Model In One Library](https://towardsdatascience.com/autogluon-timeseries-every-time-series-forecasting-model-in-one-library-29a3bf6879db) (*Towards Data Science*, Jan 2024)
+- [AutoGluon for tabular data: 3 lines of code to achieve top 1% in Kaggle competitions](https://aws.amazon.com/blogs/opensource/machine-learning-with-autogluon-an-open-source-automl-library/) (*AWS Open Source Blog*, Mar 2020)
+- [AutoGluon overview & example applications](https://towardsdatascience.com/autogluon-deep-learning-automl-5cdb4e2388ec?source=friends_link&sk=e3d17d06880ac714e47f07f39178fdf2) (*Towards Data Science*, Dec 2019)
+
+### Train/Deploy AutoGluon in the Cloud
+- [AutoGluon Cloud](https://auto.gluon.ai/cloud/stable/index.html) (Recommended)
+- [AutoGluon on SageMaker AutoPilot](https://auto.gluon.ai/stable/tutorials/cloud_fit_deploy/autopilot-autogluon.html)
+- [AutoGluon on Amazon SageMaker](https://auto.gluon.ai/stable/tutorials/cloud_fit_deploy/cloud-aws-sagemaker-train-deploy.html)
+- [AutoGluon Deep Learning Containers](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#autogluon-training-containers) (Security certified & maintained by the AutoGluon developers)
+- [AutoGluon Official Docker Container](https://hub.docker.com/r/autogluon/autogluon)
+- [AutoGluon-Tabular on AWS Marketplace](https://aws.amazon.com/marketplace/pp/prodview-n4zf5pmjt7ism) (Not maintained by us)
+
+## :pencil: Citing AutoGluon
+
+If you use AutoGluon in a scientific publication, please refer to our [citation guide](CITING.md).
+
+## :wave: How to get involved
+
+We are actively accepting code contributions to the AutoGluon project. If you are interested in contributing to AutoGluon, please read the [Contributing Guide](https://github.com/autogluon/autogluon/blob/master/CONTRIBUTING.md) to get started.
+
+## :classical_building: License
+
+This library is licensed under the Apache 2.0 License.
+
+

{autogluon.tabular-1.2.1b20250115 → autogluon.tabular-1.2.1b20250130}/src/autogluon/tabular/experimental/_tabular_classifier.py

@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-from typing import List
-
 import pandas as pd
 from sklearn.base import BaseEstimator, ClassifierMixin
 from sklearn.utils.multiclass import unique_labels
@@ -18,7 +16,7 @@ class TabularClassifier(BaseEstimator, ClassifierMixin, ScikitMixin):
         self,
         eval_metric: str | Scorer = None,
         time_limit: float = None,
-        presets: List[str] | str = None,
+        presets: list[str] | str = None,
         hyperparameters: dict | str = None,
         path: str = None,
         verbosity: int = 2,

{autogluon.tabular-1.2.1b20250115 → autogluon.tabular-1.2.1b20250130}/src/autogluon/tabular/experimental/_tabular_regressor.py

@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-from typing import List
-
 import pandas as pd
 from sklearn.base import BaseEstimator, RegressorMixin
 from sklearn.utils.validation import check_array, check_is_fitted, check_X_y
@@ -17,7 +15,7 @@ class TabularRegressor(BaseEstimator, RegressorMixin, ScikitMixin):
         self,
         eval_metric: str | Scorer = None,
         time_limit: float = None,
-        presets: List[str] | str = None,
+        presets: list[str] | str = None,
         hyperparameters: dict | str = None,
         path: str = None,
         verbosity: int = 2,

{autogluon.tabular-1.2.1b20250115 → autogluon.tabular-1.2.1b20250130}/src/autogluon/tabular/models/_utils/rapids_utils.py

@@ -4,7 +4,7 @@ from autogluon.common.utils.resource_utils import ResourceManager
 
 
 class RapidsModelMixin:
-    """Mixin class for methods re-used across RAPIDS models"""
+    """Mixin class for methods reused across RAPIDS models"""
 
     # FIXME: Efficient OOF doesn't work in RAPIDS
     @classmethod

{autogluon.tabular-1.2.1b20250115 → autogluon.tabular-1.2.1b20250130}/src/autogluon/tabular/models/catboost/callbacks.py

@@ -39,37 +39,65 @@ class MemoryCheckCallback:
                 return False
         return True
 
-    def memory_check(self, iter) -> bool:
-        """Checks if memory usage is unsafe. If so, then returns True to signal the model to stop training early."""
+    def memory_check(self, iter: int) -> bool:
+        """
+        Checks if memory usage is unsafe. If so, signals the model to stop training early.
+
+        Parameters
+        ----------
+        iter: int
+            The current training iteration.
+
+        Returns
+        -------
+        bool: True if training should stop due to memory constraints, False otherwise.
+        """
         available_bytes = ResourceManager.get_available_virtual_mem()
         cur_rss = ResourceManager.get_memory_rss()
 
+        # Update initial memory usage if current usage is lower
         if cur_rss < self.init_mem_rss:
             self.init_mem_rss = cur_rss
-        estimated_model_size_mb = (cur_rss - self.init_mem_rss) >> 20
-        available_mb = available_bytes >> 20
-        model_size_memory_ratio = estimated_model_size_mb / available_mb
 
+        # Convert memory values to MB
+        estimated_model_size_mb = (cur_rss - self.init_mem_rss) / (1024 ** 2)
+        available_mb = available_bytes / (1024 ** 2)
+
+        model_size_memory_ratio = estimated_model_size_mb / available_mb
         early_stop = False
+
         if model_size_memory_ratio > 1.0:
-            logger.warning(f"Warning: Large model size may cause OOM error if training continues")
+            logger.warning(
+                f"Iteration {iter}: Model size exceeds available memory. "
+                f"Available memory: {available_mb:.2f} MB, "
+                f"Estimated model size: {estimated_model_size_mb:.2f} MB."
+            )
             early_stop = True
 
-        if available_mb < 512:  # Less than 500 MB
-            logger.warning(f"Warning: Low available memory may cause OOM error if training continues")
+        if available_mb < 512:  # Less than 512 MB
+            logger.warning(
+                f"Iteration {iter}: Low available memory (<512 MB). "
+                f"Available memory: {available_mb:.2f} MB, "
+                f"Estimated model size: {estimated_model_size_mb:.2f} MB."
+            )
             early_stop = True
 
         if early_stop:
             logger.warning(
-                "Warning: Early stopped model prior to optimal result to avoid OOM error. " "Please increase available memory to avoid subpar model quality."
+                "Early stopping model prior to optimal result to avoid OOM error. "
+                "Please increase available memory to avoid subpar model quality."
             )
-            logger.warning(f"Available Memory: {available_mb} MB, Estimated Model size: {estimated_model_size_mb} MB")
             return True
-        elif self.verbose or (model_size_memory_ratio > 0.25):
-            logging.debug(f"Available Memory: {available_mb} MB, Estimated Model size: {estimated_model_size_mb} MB")
+        elif self.verbose or model_size_memory_ratio > 0.25:
+            logger.debug(
+                f"Iteration {iter}: "
+                f"Available memory: {available_mb:.2f} MB, "
+                f"Estimated model size: {estimated_model_size_mb:.2f} MB."
+            )
 
+        # Adjust memory check frequency based on model size
         if model_size_memory_ratio > 0.5:
-            self._cur_period = 1  # Increase rate of memory check if model gets large enough to cause OOM potentially
+            self._cur_period = 1  # Increase frequency of memory checks
         elif iter > self.period:
             self._cur_period = self.period
 

{autogluon.tabular-1.2.1b20250115 → autogluon.tabular-1.2.1b20250130}/src/autogluon/tabular/models/fastainn/tabular_nn_fastai.py

@@ -8,7 +8,7 @@ import warnings
 from builtins import classmethod
 from functools import partial
 from pathlib import Path
-from typing import Dict, Union
+from typing import Union
 
 import numpy as np
 import pandas as pd
@@ -628,7 +628,7 @@ class NNFastAiTabularModel(AbstractModel):
         """Choose which backend(Ray or Custom) to use for hpo"""
         return RAY_BACKEND
 
-    def _get_maximum_resources(self) -> Dict[str, Union[int, float]]:
+    def _get_maximum_resources(self) -> dict[str, Union[int, float]]:
         # fastai model trains slower when utilizing virtual cores and this issue scale up when the number of cpu cores increases
         return {"num_cpus": ResourceManager.get_cpu_count_psutil(logical=False)}
 

{autogluon.tabular-1.2.1b20250115 → autogluon.tabular-1.2.1b20250130}/src/autogluon/tabular/models/lgb/lgb_utils.py

@@ -1,7 +1,7 @@
 import copy
 import os
 import time
-from typing import List, Optional
+from typing import Optional
 
 import numpy as np
 from pandas import DataFrame, Series
@@ -137,7 +137,7 @@ def train_lgb_model(early_stopping_callback_kwargs=None, **train_params):
 class QuantileBooster:
     """Wrapper that trains a separate LGBM Booster for each quantile level."""
 
-    def __init__(self, quantile_levels: List[float], early_stopping_callback_kwargs: Optional[dict] = None):
+    def __init__(self, quantile_levels: list[float], early_stopping_callback_kwargs: Optional[dict] = None):
         if quantile_levels is None:
             raise AssertionError
         if not all(0 < q < 1 for q in quantile_levels):

{autogluon.tabular-1.2.1b20250115 → autogluon.tabular-1.2.1b20250130}/src/autogluon/tabular/models/tab_transformer/modified_transformer.py

@@ -6,7 +6,7 @@ The modification allows the option of fixing the attention map
 """
 
 import math
-from typing import Optional, Tuple
+from typing import Optional
 
 import torch
 import torch.nn.functional as F
@@ -54,7 +54,7 @@ def multi_head_attention_forward(
     static_k=None,  # type: Optional[Tensor]
     static_v=None,  # type: Optional[Tensor]
 ):
-    # type: (...) -> Tuple[Tensor, Optional[Tensor]]
+    # type: (...) -> tuple[Tensor, Optional[Tensor]]
     """
     Args:
         query, key, value: map a query and a set of key-value pairs to an output.
@@ -288,7 +288,7 @@ class MultiheadAttention(Module):
         super().__setstate__(state)
 
     def forward(self, query, key, value, key_padding_mask=None, need_weights=True, attn_mask=None):
-        # type: (Tensor, Tensor, Tensor, Optional[Tensor], bool, Optional[Tensor]) -> Tuple[Tensor, Optional[Tensor]]
+        # type: (Tensor, Tensor, Tensor, Optional[Tensor], bool, Optional[Tensor]) -> tuple[Tensor, Optional[Tensor]]
         """
         Args:
             query, key, value: map a query and a set of key-value pairs to an output.

{autogluon.tabular-1.2.1b20250115 → autogluon.tabular-1.2.1b20250130}/src/autogluon/tabular/models/tab_transformer/pretexts.py

@@ -111,8 +111,8 @@ class BERTPretext(nn.Module):
             assert torch.all(cat_feats[extra_replace] == orig_cat_feats[extra_replace]).item() is True
             extra_plus1 = cat_feats[extra_replace] + 1
             extra_minus1 = cat_feats[extra_replace] - 1
-            extra_zero_padd_idx = extra_minus1 == 0
-            extra_minus1[extra_zero_padd_idx] = extra_plus1[extra_zero_padd_idx]
+            extra_zero_pad_idx = extra_minus1 == 0
+            extra_minus1[extra_zero_pad_idx] = extra_plus1[extra_zero_pad_idx]
 
             cat_feats[extra_replace] = extra_minus1
             assert torch.all(~(cat_feats[extra_replace] == orig_cat_feats[extra_replace])).item() is True
@@ -135,8 +135,8 @@ class BERTPretext(nn.Module):
             assert torch.all(cat_feats[extra_replace] == orig_cat_feats[extra_replace]).item() is True
             extra_plus1 = cat_feats[extra_replace] + 1
             extra_minus1 = cat_feats[extra_replace] - 1
-            extra_zero_padd_idx = extra_minus1 == 0
-            extra_minus1[extra_zero_padd_idx] = extra_plus1[extra_zero_padd_idx]
+            extra_zero_pad_idx = extra_minus1 == 0
+            extra_minus1[extra_zero_pad_idx] = extra_plus1[extra_zero_pad_idx]
 
             cat_feats[extra_replace] = extra_minus1
             assert torch.all(~(cat_feats[extra_replace] == orig_cat_feats[extra_replace])).item() is True

{autogluon.tabular-1.2.1b20250115 → autogluon.tabular-1.2.1b20250130}/src/autogluon/tabular/models/tab_transformer/tab_transformer_encoder.py

@@ -7,7 +7,7 @@ import re
 from collections import Counter
 from datetime import date, datetime
 from functools import partial
-from typing import Iterable, List, Union
+from typing import Iterable, Union
 
 import numpy as np
 import pandas as pd
@@ -514,7 +514,7 @@ class EmbeddingInitializer(nn.Module):
         :param drop_whole_embeddings:
             If True, dropout pretends the embedding was a missing value. If false, dropout sets embed features to 0
         :param one_hot:
-            If True, one-hot encode variables whose cardinality is < max_emb_dim. Also, set reqiures_grad = False
+            If True, one-hot encode variables whose cardinality is < max_emb_dim. Also, set requires_grad = False
         :param out_dim:
             If None, return the embedding straight from self.embed.  If another dimension, put the embedding through a
             Linear layer to make it size (batch x out_dim).
@@ -624,7 +624,7 @@ def add_datepart(df: DataFrame, field_name: str, prefix: str = None, drop: bool
     return df
 
 
-def cyclic_dt_feat_names(time: bool = True, add_linear: bool = False) -> List[str]:
+def cyclic_dt_feat_names(time: bool = True, add_linear: bool = False) -> list[str]:
     "Return feature names of date/time cycles as produced by `cyclic_dt_features`."
     fs = ["cos", "sin"]
     attr = [f"{r}_{f}" for r in "weekday day_month month_year day_year".split() for f in fs]
@@ -635,7 +635,7 @@ def cyclic_dt_feat_names(time: bool = True, add_linear: bool = False) -> List[st
     return attr
 
 
-def cyclic_dt_features(d: Union[date, datetime], time: bool = True, add_linear: bool = False) -> List[float]:
+def cyclic_dt_features(d: Union[date, datetime], time: bool = True, add_linear: bool = False) -> list[float]:
     "Calculate the cos and sin of date/time cycles."
     tt, fs = d.timetuple(), [np.cos, np.sin]
     day_year, days_month = tt.tm_yday, calendar.monthrange(d.year, d.month)[1]

{autogluon.tabular-1.2.1b20250115 → autogluon.tabular-1.2.1b20250130}/src/autogluon/tabular/models/tabular_nn/torch/tabular_torch_dataset.py

@@ -136,7 +136,7 @@ class TabularTorchDataset(torch.utils.data.IterableDataset):
         load the dataset.
 
         Returns a tuple containing (vector_features, embed_features, label).
-        The length of the tuple depends on `has_vector_features` and `has_embed_feautures` attribute.
+        The length of the tuple depends on `has_vector_features` and `has_embed_features` attribute.
         """
         idxarray = np.arange(self.num_examples)
         if self.shuffle:
@@ -154,7 +154,7 @@ class TabularTorchDataset(torch.utils.data.IterableDataset):
                 idx = idxarray[idx]
 
             # Generate a tuple that contains (vector_features, embed_features, label).
-            # The length of the tuple depends on `has_vector_features`, `has_embed_feautures`, and
+            # The length of the tuple depends on `has_vector_features`, `has_embed_features`, and
             # whether the label has been provided.
             output_list = []
             if self.has_vector_features:

{autogluon.tabular-1.2.1b20250115 → autogluon.tabular-1.2.1b20250130}/src/autogluon/tabular/predictor/_deprecated_methods.py

@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-from typing import Dict, List
-
 import numpy as np
 import pandas as pd
 
@@ -12,17 +10,17 @@ class TabularPredictorDeprecatedMixin:
     """Contains deprecated methods from TabularPredictor that shouldn't show up in API documentation."""
 
     @Deprecated(min_version_to_warn="0.8.3", min_version_to_error="1.2", version_to_remove="1.2", new="persist")
-    def persist_models(self, *args, **kwargs) -> List[str]:
+    def persist_models(self, *args, **kwargs) -> list[str]:
         """Deprecated method. Use `persist` instead."""
         return self.persist(*args, **kwargs)
 
     @Deprecated(min_version_to_warn="0.8.3", min_version_to_error="1.2", version_to_remove="1.2", new="unpersist")
-    def unpersist_models(self, *args, **kwargs) -> List[str]:
+    def unpersist_models(self, *args, **kwargs) -> list[str]:
         """Deprecated method. Use `unpersist` instead."""
         return self.unpersist(*args, **kwargs)
 
     @Deprecated(min_version_to_warn="0.8.3", min_version_to_error="1.2", version_to_remove="1.2", new="model_names")
-    def get_model_names(self, *args, **kwargs) -> List[str]:
+    def get_model_names(self, *args, **kwargs) -> list[str]:
         """Deprecated method. Use `model_names` instead."""
         return self.model_names(*args, **kwargs)
 
@@ -37,7 +35,7 @@ class TabularPredictorDeprecatedMixin:
         return self.predict_from_proba(*args, **kwargs)
 
     @Deprecated(min_version_to_warn="0.8.3", min_version_to_error="1.2", version_to_remove="1.2", new="model_refit_map")
-    def get_model_full_dict(self, *args, **kwargs) -> Dict[str, str]:
+    def get_model_full_dict(self, *args, **kwargs) -> dict[str, str]:
         """Deprecated method. Use `model_refit_map` instead."""
         return self.model_refit_map(*args, **kwargs)
 
@@ -62,6 +60,6 @@ class TabularPredictorDeprecatedMixin:
         return self.disk_usage()
 
     @Deprecated(min_version_to_warn="0.8.3", min_version_to_error="1.2", version_to_remove="1.2", new="model_names(persisted=True)")
-    def get_model_names_persisted(self) -> List[str]:
+    def get_model_names_persisted(self) -> list[str]:
         """Deprecated method. Use `model_names(persisted=True)` instead."""
         return self.model_names(persisted=True)