autogluon.timeseries 1.4.1b20251115__py3-none-any.whl → 1.4.1b20251218__py3-none-any.whl

autogluon/timeseries/trainer/utils.py

@@ -1,13 +1,12 @@
 import logging
-from typing import Optional
 
 logger = logging.getLogger("autogluon.timeseries.trainer")
 
 
 def log_scores_and_times(
-    val_score: Optional[float],
-    fit_time: Optional[float],
-    predict_time: Optional[float],
+    val_score: float | None,
+    fit_time: float | None,
+    predict_time: float | None,
     eval_metric_name: str,
 ):
     if val_score is not None:

autogluon/timeseries/transforms/covariate_scaler.py

@@ -1,5 +1,5 @@
 import logging
-from typing import Literal, Optional, Protocol, overload, runtime_checkable
+from typing import Literal, Protocol, overload, runtime_checkable
 
 import numpy as np
 import pandas as pd
@@ -25,8 +25,8 @@ class CovariateScaler(Protocol):
     def transform(self, data: TimeSeriesDataFrame) -> TimeSeriesDataFrame: ...
 
     def transform_known_covariates(
-        self, known_covariates: Optional[TimeSeriesDataFrame] = None
-    ) -> Optional[TimeSeriesDataFrame]: ...
+        self, known_covariates: TimeSeriesDataFrame | None = None
+    ) -> TimeSeriesDataFrame | None: ...
 
 
 class GlobalCovariateScaler(CovariateScaler):
@@ -53,7 +53,7 @@ class GlobalCovariateScaler(CovariateScaler):
         self.use_past_covariates = use_past_covariates
         self.use_static_features = use_static_features
         self.skew_threshold = skew_threshold
-        self._column_transformers: Optional[dict[Literal["known", "past", "static"], ColumnTransformer]] = None
+        self._column_transformers: dict[Literal["known", "past", "static"], ColumnTransformer] | None = None
 
     def is_fit(self) -> bool:
         return self._column_transformers is not None
@@ -105,8 +105,8 @@ class GlobalCovariateScaler(CovariateScaler):
         return data
 
     def transform_known_covariates(
-        self, known_covariates: Optional[TimeSeriesDataFrame] = None
-    ) -> Optional[TimeSeriesDataFrame]:
+        self, known_covariates: TimeSeriesDataFrame | None = None
+    ) -> TimeSeriesDataFrame | None:
         assert self._column_transformers is not None, "CovariateScaler must be fit before transform can be called"
 
         if "known" in self._column_transformers:
@@ -154,7 +154,7 @@ AVAILABLE_COVARIATE_SCALERS = {
 def get_covariate_scaler(name: None, **scaler_kwargs) -> None: ...
 @overload
 def get_covariate_scaler(name: Literal["global"], **scaler_kwargs) -> GlobalCovariateScaler: ...
-def get_covariate_scaler(name: Optional[Literal["global"]] = None, **scaler_kwargs) -> Optional[CovariateScaler]:
+def get_covariate_scaler(name: Literal["global"] | None = None, **scaler_kwargs) -> CovariateScaler | None:
     if name is None:
         return None
     if name not in AVAILABLE_COVARIATE_SCALERS:

autogluon/timeseries/transforms/target_scaler.py

@@ -1,4 +1,4 @@
-from typing import Literal, Optional, Protocol, Union, overload
+from typing import Literal, Protocol, overload
 
 import numpy as np
 import pandas as pd
@@ -27,10 +27,10 @@ class LocalTargetScaler(TargetScaler):
     ):
         self.target = target
         self.min_scale = min_scale
-        self.loc: Optional[pd.Series] = None
-        self.scale: Optional[pd.Series] = None
+        self.loc: pd.Series | None = None
+        self.scale: pd.Series | None = None
 
-    def _compute_loc_scale(self, target_series: pd.Series) -> tuple[Optional[pd.Series], Optional[pd.Series]]:
+    def _compute_loc_scale(self, target_series: pd.Series) -> tuple[pd.Series | None, pd.Series | None]:
         raise NotImplementedError
 
     def fit_transform(self, data: TimeSeriesDataFrame) -> TimeSeriesDataFrame:
@@ -45,7 +45,7 @@ class LocalTargetScaler(TargetScaler):
             self.scale = self.scale.clip(lower=self.min_scale).replace([np.inf, -np.inf], np.nan).fillna(1.0)
         return self
 
-    def _reindex_loc_scale(self, item_index: pd.Index) -> tuple[Union[np.ndarray, float], Union[np.ndarray, float]]:
+    def _reindex_loc_scale(self, item_index: pd.Index) -> tuple[np.ndarray | float, np.ndarray | float]:
         """Reindex loc and scale parameters for the given item_ids and convert them to an array-like."""
         if self.loc is not None:
             loc = self.loc.reindex(item_index).to_numpy()
@@ -82,7 +82,7 @@ class LocalStandardScaler(LocalTargetScaler):
 class LocalMeanAbsScaler(LocalTargetScaler):
     """Applies mean absolute scaling to each time series in the dataset."""
 
-    def _compute_loc_scale(self, target_series: pd.Series) -> tuple[Optional[pd.Series], pd.Series]:
+    def _compute_loc_scale(self, target_series: pd.Series) -> tuple[pd.Series | None, pd.Series]:
         scale = target_series.abs().groupby(level=TimeSeriesDataFrame.ITEMID, sort=False).agg("mean")
         return None, scale
 
@@ -139,8 +139,8 @@ def get_target_scaler(name: None, **scaler_kwargs) -> None: ...
 @overload
 def get_target_scaler(name: Literal["standard", "mean_abs", "min_max", "robust"], **scaler_kwargs) -> TargetScaler: ...
 def get_target_scaler(
-    name: Optional[Literal["standard", "mean_abs", "min_max", "robust"]], **scaler_kwargs
-) -> Optional[TargetScaler]:
+    name: Literal["standard", "mean_abs", "min_max", "robust"] | None, **scaler_kwargs
+) -> TargetScaler | None:
     """Get LocalTargetScaler object from a string."""
     if name is None:
         return None

autogluon/timeseries/utils/constants.py

@@ -0,0 +1,10 @@
+import joblib.externals.loky
+from joblib import cpu_count
+
+# By default, joblib w/ loky backend kills processes that take >300MB of RAM assuming that this is caused by a memory
+# leak. This leads to problems for some memory-hungry models like AutoARIMA/Theta.
+# This monkey patch removes this undesired behavior
+joblib.externals.loky.process_executor._MAX_MEMORY_LEAK_SIZE = int(3e10)
+
+# We use the same default n_jobs across AG-TS to ensure that Joblib reuses the process pool
+AG_DEFAULT_N_JOBS = max(cpu_count(only_physical_cores=True), 1)

autogluon/timeseries/utils/datetime/lags.py

@@ -2,8 +2,6 @@
 Generate lag indices based on frequency string. Adapted from gluonts.time_feature.lag.
 """
 
-from typing import Optional
-
 import numpy as np
 import pandas as pd
 
@@ -70,7 +68,7 @@ def _make_lags_for_semi_month(multiple, num_cycles=3):
 def get_lags_for_frequency(
     freq: str,
     lag_ub: int = 1200,
-    num_lags: Optional[int] = None,
+    num_lags: int | None = None,
     num_default_lags: int = 7,
 ) -> list[int]:
     """

autogluon/timeseries/utils/datetime/seasonality.py

@@ -1,5 +1,3 @@
-from typing import Union
-
 import pandas as pd
 
 from .base import norm_freq_str
@@ -22,7 +20,7 @@ DEFAULT_SEASONALITIES = {
 }
 
 
-def get_seasonality(freq: Union[str, None]) -> int:
+def get_seasonality(freq: str | None) -> int:
     """Return the seasonality of a given frequency. Adapted from ``gluonts.time_feature.seasonality``."""
     if freq is None:
         return 1

autogluon/timeseries/utils/features.py

@@ -2,7 +2,7 @@ import logging
 import reprlib
 import time
 from dataclasses import asdict, dataclass, field
-from typing import Any, Literal, Optional
+from typing import Any, Literal
 
 import numpy as np
 import pandas as pd
@@ -30,6 +30,14 @@ class CovariateMetadata:
     known_covariates_cat: list[str] = field(default_factory=list)
     past_covariates_real: list[str] = field(default_factory=list)
     past_covariates_cat: list[str] = field(default_factory=list)
+    static_cat_cardinality: dict[str, int] = field(default_factory=dict)
+    known_cat_cardinality: dict[str, int] = field(default_factory=dict)
+    past_cat_cardinality: dict[str, int] = field(default_factory=dict)
+
+    def __post_init__(self):
+        assert list(self.static_cat_cardinality.keys()) == self.static_features_cat
+        assert list(self.known_cat_cardinality.keys()) == self.known_covariates_cat
+        assert list(self.past_cat_cardinality.keys()) == self.past_covariates_cat
 
     @property
     def static_features(self) -> list[str]:
@@ -136,7 +144,7 @@ class TimeSeriesFeatureGenerator:
         target: str,
         known_covariates_names: list[str],
         float_dtype: str = "float32",
-        num_samples: Optional[int] = 20_000,
+        num_samples: int | None = 20_000,
     ):
         self.target = target
         self.float_dtype = float_dtype
@@ -149,9 +157,9 @@ class TimeSeriesFeatureGenerator:
         self.past_covariates_pipeline = ContinuousAndCategoricalFeatureGenerator()
         # Cat features with cat_count=1 are fine in static_features since they are repeated for all time steps in a TS
         self.static_feature_pipeline = ContinuousAndCategoricalFeatureGenerator(minimum_cat_count=1)
-        self._covariate_metadata: Optional[CovariateMetadata] = None  # type ignore
-        self._train_covariates_real_median: Optional[pd.Series] = None
-        self._train_static_real_median: Optional[pd.Series] = None
+        self._covariate_metadata: CovariateMetadata | None = None  # type ignore
+        self._train_covariates_real_median: pd.Series | None = None
+        self._train_static_real_median: pd.Series | None = None
 
     @property
     def required_column_names(self) -> list[str]:
@@ -221,11 +229,13 @@ class TimeSeriesFeatureGenerator:
             static_features_cat, static_features_real = self._detect_and_log_column_types(static_features_df)
             ignored_static_features = data.static_features.columns.difference(self.static_feature_pipeline.features_in)
             self._train_static_real_median = data.static_features[static_features_real].median()
+            static_cat_cardinality = static_features_df[static_features_cat].nunique().to_dict()
         else:
             static_features_cat = []
             static_features_real = []
             ignored_static_features = []
             static_features_df = None
+            static_cat_cardinality = {}
 
         if len(ignored_covariates) > 0 or len(ignored_static_features) > 0:
             logger.info("\nAutoGluon will ignore following non-numeric/non-informative columns:")
@@ -246,6 +256,9 @@ class TimeSeriesFeatureGenerator:
             past_covariates_real=past_covariates_real,
             static_features_cat=static_features_cat,
             static_features_real=static_features_real,
+            static_cat_cardinality=static_cat_cardinality,
+            known_cat_cardinality=df[known_covariates_cat].nunique().to_dict(),
+            past_cat_cardinality=df[past_covariates_cat].nunique().to_dict(),
         )
 
         # Median of real-valued covariates will be used for missing value imputation
@@ -279,7 +292,7 @@ class TimeSeriesFeatureGenerator:
             ts_df[column_names] = covariates_real
         return ts_df
 
-    def _impute_static_features(self, static_df: Optional[pd.DataFrame]) -> Optional[pd.DataFrame]:
+    def _impute_static_features(self, static_df: pd.DataFrame | None) -> pd.DataFrame | None:
         """Impute missing values in static features using the median."""
         static_real_names = self.covariate_metadata.static_features_real
         if static_df is not None and static_real_names:
@@ -328,8 +341,8 @@ class TimeSeriesFeatureGenerator:
         return self._impute_covariates(ts_df, column_names=self.covariate_metadata.covariates_real)
 
     def transform_future_known_covariates(
-        self, known_covariates: Optional[TimeSeriesDataFrame]
-    ) -> Optional[TimeSeriesDataFrame]:
+        self, known_covariates: TimeSeriesDataFrame | None
+    ) -> TimeSeriesDataFrame | None:
         assert self._is_fit, f"{self.__class__.__name__} has not been fit yet"
         if len(self.known_covariates_names) > 0:
             assert known_covariates is not None, "known_covariates must be provided at prediction time"
@@ -441,7 +454,7 @@ class PermutationFeatureImportanceTransform(AbstractFeatureImportanceTransform):
         self,
         covariate_metadata: CovariateMetadata,
         prediction_length: int,
-        random_seed: Optional[int] = None,
+        random_seed: int | None = None,
         shuffle_type: Literal["itemwise", "naive"] = "itemwise",
         **kwargs,
     ):

autogluon/timeseries/utils/forecast.py

@@ -1,5 +1,4 @@
 import warnings
-from typing import Optional
 
 import numpy as np
 import pandas as pd
@@ -29,7 +28,7 @@ def get_forecast_horizon_index_ts_dataframe(*args, **kwargs) -> pd.MultiIndex:
 def make_future_data_frame(
     ts_dataframe: TimeSeriesDataFrame,
     prediction_length: int,
-    freq: Optional[str] = None,
+    freq: str | None = None,
 ) -> pd.DataFrame:
     """For each item in the dataframe, get timestamps for the next `prediction_length` time steps into the future.
 

autogluon/timeseries/utils/timer.py

@@ -0,0 +1,173 @@
+import time
+
+from typing_extensions import Self
+
+
+class Timer:
+    """A timer class that tracks a start time, and computes the time elapsed and
+    time remaining, used for handling ``time_limit`` parameters in AutoGluon.
+
+    Parameters
+    ----------
+    time_limit
+        The time limit to set. If None, then ``time_remaining`` will return None, and
+        ``timed_out`` will return False.
+
+    Examples
+    --------
+    Basic usage with time limit:
+
+    >>> timer = Timer(time_limit=10.0).start()
+    >>> # Do some work...
+    >>> if timer.timed_out():
+    ...     print("Time limit exceeded!")
+    >>> print(f"Time remaining: {timer.time_remaining():.2f}s")
+
+    Using as a stopwatch (no time limit):
+
+    >>> timer = Timer(time_limit=None).start()
+    >>> # Do some work...
+    >>> print(f"Elapsed time: {timer.time_elapsed():.2f}s")
+
+    Checking time in a loop:
+
+    >>> timer = Timer(time_limit=5.0).start()
+    >>> for i in range(100):
+    ...     if timer.timed_out():
+    ...         break
+    ...     # Do work for iteration i
+    """
+
+    def __init__(
+        self,
+        time_limit: float | None,
+    ):
+        self.time_limit = time_limit
+
+        self.start_time = None
+
+    def start(self) -> Self:
+        """Start or reset the timer."""
+        self.start_time = time.monotonic()
+        return self
+
+    def time_elapsed(self) -> float:
+        """Total time elapsed since the timer was started. This method can also be used
+        when ``time_limit`` is set to None to count time forward (i.e., as opposed to
+        a countdown timer which other methods imply).
+        """
+        if self.start_time is None:
+            raise RuntimeError("Timer has not been started")
+        return time.monotonic() - self.start_time
+
+    def time_remaining(self) -> float | None:
+        """Total time remaining on the timer. If ``time_limit`` is None,
+        this method also returns None.
+        """
+        if self.start_time is None:
+            raise RuntimeError("Timer has not been started")
+        if self.time_limit is None:
+            return None
+        return self.time_limit - (time.monotonic() - self.start_time)
+
+    def timed_out(self) -> bool:
+        """Whether the timer has timed out. If ``time_limit`` is None, this method
+        always returns False.
+        """
+        if self.start_time is None:
+            raise RuntimeError("Timer has not been started")
+        if self.time_limit is None:
+            return False
+        return self.time_elapsed() >= self.time_limit
+
+
+class SplitTimer(Timer):
+    """A timer that splits remaining time across multiple rounds.
+
+    Extends Timer to divide the total time limit across a specified number of rounds,
+    useful for allocating time budgets to sequential operations. At each call of
+    ``next_round``, the timer re-distributes the remaining time evenly among
+    the remaining rounds.
+
+    Parameters
+    ----------
+    time_limit
+        Total time limit to split across all rounds. If None, ``round_time_remaining``
+        returns None.
+    rounds
+        Number of rounds to split the time across. Default is 1.
+
+    Examples
+    --------
+    Split time across 3 rounds:
+
+    >>> timer = SplitTimer(time_limit=10.0, rounds=3).start()
+    >>> time_round_1 = timer.round_time_remaining()  # Returns ~3.33
+    >>> # Do work for round 1
+    >>> timer.next_round()
+    >>> time_round_2 = timer.round_time_remaining()  # Returns remaining time divided by 2
+    >>> # Do work for round 2
+    >>> timer.next_round()
+    >>> time_round_3 = timer.round_time_remaining()  # Returns all remaining time
+    """
+
+    def __init__(
+        self,
+        time_limit: float | None,
+        rounds: int = 1,
+    ):
+        super().__init__(time_limit)
+        self.rounds = rounds
+
+        self.round_index: int
+        self.round_start_time: float
+
+    def start(self) -> Self:
+        """Reset and start the timer."""
+        super().start()
+        self.round_index = 0
+        self.round_start_time = time.monotonic()
+        return self
+
+    def round_time_remaining(self) -> float | None:
+        """Get the time budget for the current round.
+
+        Calculates the time allocation by dividing the remaining time equally among
+        the remaining rounds. This means if a previous round used less time than
+        allocated, subsequent rounds get more time, and vice versa.
+
+        Returns time budget for the current round in seconds. Returns None if
+        ``time_limit`` is None. Returns 0.0 if all rounds have been exhausted.
+        """
+        if self.time_limit is None:
+            return None
+        if self.start_time is None:
+            raise RuntimeError("Timer has not been started")
+
+        remaining_rounds = self.rounds - self.round_index
+        if remaining_rounds <= 0:
+            return 0.0
+
+        elapsed_time_at_round_start = self.round_start_time - self.start_time
+        remaining_time_at_round_start = self.time_limit - elapsed_time_at_round_start
+        round_time_budget = remaining_time_at_round_start / remaining_rounds
+
+        return round_time_budget - self.round_time_elapsed()
+
+    def round_time_elapsed(self) -> float:
+        """Total time elapsed since the start of this round."""
+        if self.start_time is None:
+            raise RuntimeError("Timer has not been started")
+        return time.monotonic() - self.round_start_time
+
+    def next_round(self) -> Self:
+        """Advance timer to the next round.
+
+        Increments the round counter, which affects the time allocation returned
+        by subsequent ``round_time_remaining`` calls.
+        """
+        if self.start_time is None:
+            raise RuntimeError("Timer has not been started")
+        self.round_index += 1
+        self.round_start_time = time.monotonic()
+        return self

autogluon/timeseries/version.py

@@ -1,4 +1,4 @@
 """This is the autogluon version file."""
 
-__version__ = "1.4.1b20251115"
+__version__ = "1.4.1b20251218"
 __lite__ = False

{autogluon_timeseries-1.4.1b20251115.dist-info → autogluon_timeseries-1.4.1b20251218.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: autogluon.timeseries
-Version: 1.4.1b20251115
+Version: 1.4.1b20251218
 Summary: Fast and Accurate ML in 3 Lines of Code
 Home-page: https://github.com/autogluon/autogluon
 Author: AutoGluon Community
@@ -23,15 +23,15 @@ 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: Programming Language :: Python :: 3.13
 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
+Requires-Python: >=3.10, <3.14
 Description-Content-Type: text/markdown
 License-File: LICENSE
 License-File: NOTICE
@@ -39,10 +39,9 @@ Requires-Dist: joblib<1.7,>=1.2
 Requires-Dist: numpy<2.4.0,>=1.25.0
 Requires-Dist: scipy<1.17,>=1.5.4
 Requires-Dist: pandas<2.4.0,>=2.0.0
-Requires-Dist: torch<2.8,>=2.6
-Requires-Dist: lightning<2.8,>=2.5.1
-Requires-Dist: pytorch_lightning
-Requires-Dist: transformers[sentencepiece]<4.50,>=4.38.0
+Requires-Dist: torch<2.10,>=2.6
+Requires-Dist: lightning<2.6,>=2.5.1
+Requires-Dist: transformers[sentencepiece]<4.58,>=4.51.0
 Requires-Dist: accelerate<2.0,>=0.34.0
 Requires-Dist: gluonts<0.17,>=0.15.0
 Requires-Dist: networkx<4,>=3.0
@@ -53,23 +52,23 @@ Requires-Dist: coreforecast<0.0.17,>=0.0.12
 Requires-Dist: fugue>=0.9.0
 Requires-Dist: tqdm<5,>=4.38
 Requires-Dist: orjson~=3.9
-Requires-Dist: chronos-forecasting<3,>=2.0.1
+Requires-Dist: einops<1,>=0.7
+Requires-Dist: chronos-forecasting<2.4,>=2.2.2
+Requires-Dist: peft<0.18,>=0.13.0
 Requires-Dist: tensorboard<3,>=2.9
-Requires-Dist: autogluon.core[raytune]==1.4.1b20251115
-Requires-Dist: autogluon.common==1.4.1b20251115
-Requires-Dist: autogluon.features==1.4.1b20251115
-Requires-Dist: autogluon.tabular[catboost,lightgbm,xgboost]==1.4.1b20251115
+Requires-Dist: autogluon.core==1.4.1b20251218
+Requires-Dist: autogluon.common==1.4.1b20251218
+Requires-Dist: autogluon.features==1.4.1b20251218
+Requires-Dist: autogluon.tabular[catboost,lightgbm,xgboost]==1.4.1b20251218
 Provides-Extra: tests
 Requires-Dist: pytest; extra == "tests"
 Requires-Dist: ruff>=0.0.285; extra == "tests"
 Requires-Dist: flaky<4,>=3.7; extra == "tests"
 Requires-Dist: pytest-timeout<3,>=2.1; extra == "tests"
-Provides-Extra: toto
-Requires-Dist: einops<1,>=0.7; extra == "toto"
-Requires-Dist: rotary-embedding-torch<1,>=0.8; extra == "toto"
+Provides-Extra: ray
+Requires-Dist: autogluon.core[raytune]==1.4.1b20251218; extra == "ray"
 Provides-Extra: all
-Requires-Dist: rotary-embedding-torch<1,>=0.8; extra == "all"
-Requires-Dist: einops<1,>=0.7; extra == "all"
+Requires-Dist: autogluon.core[raytune]==1.4.1b20251218; extra == "all"
 Dynamic: author
 Dynamic: classifier
 Dynamic: description
@@ -92,7 +91,7 @@ Dynamic: summary
 
 [![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/)
+[![Python Versions](https://img.shields.io/badge/python-3.10%20%7C%203.11%20%7C%203.12%20%7C%203.13-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)
@@ -109,7 +108,7 @@ AutoGluon, developed by AWS AI, automates machine learning tasks enabling you to
 
 ## 💾 Installation
 
-AutoGluon is supported on Python 3.9 - 3.12 and is available on Linux, MacOS, and Windows.
+AutoGluon is supported on Python 3.10 - 3.13 and is available on Linux, MacOS, and Windows.
 
 You can install AutoGluon with:
 
@@ -132,8 +131,8 @@ 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) |
+| 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) |
 
 ## :mag: Resources
 
@@ -156,7 +155,10 @@ Below is a curated list of recent tutorials and talks on AutoGluon. A comprehens
 - [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)
+- [TabRepo: A Large Scale Repository of Tabular Model Evaluations and its AutoML Applications](https://arxiv.org/pdf/2311.02971.pdf) (*AutoML Conf*, 2024)
+- [AutoGluon-Multimodal (AutoMM): Supercharging Multimodal AutoML with Foundation Models](https://arxiv.org/pdf/2404.16233) (*AutoML Conf*, 2024) ([BibTeX](CITING.md#autogluonmultimodal))
+- [Multi-layer Stack Ensembles for Time Series Forecasting](https://arxiv.org/abs/2511.15350) (*AutoML Conf*, 2025) ([BibTeX](CITING.md#autogluontimeseries))
+- [Chronos-2: From Univariate to Universal Forecasting](https://arxiv.org/abs/2510.15821) (*Arxiv*, 2025) ([BibTeX](CITING.md#autogluontimeseries))
 
 ### 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)