autogluon.timeseries 1.3.2b20250708__py3-none-any.whl → 1.3.2b20250710__py3-none-any.whl

autogluon/timeseries/models/__init__.py

@@ -1,4 +1,4 @@
-from .autogluon_tabular import DirectTabularModel, RecursiveTabularModel
+from .autogluon_tabular import DirectTabularModel, PerStepTabularModel, RecursiveTabularModel
 from .chronos import ChronosModel
 from .gluonts import (
     DeepARModel,
@@ -46,6 +46,7 @@ __all__ = [
     "NPTSModel",
     "NaiveModel",
     "PatchTSTModel",
+    "PerStepTabularModel",
     "RecursiveTabularModel",
     "SeasonalAverageModel",
     "SeasonalNaiveModel",

autogluon/timeseries/models/autogluon_tabular/__init__.py

@@ -1,6 +1,8 @@
 from .mlforecast import DirectTabularModel, RecursiveTabularModel
+from .per_step import PerStepTabularModel
 
 __all__ = [
     "DirectTabularModel",
     "RecursiveTabularModel",
+    "PerStepTabularModel",
 ]

autogluon/timeseries/models/autogluon_tabular/mlforecast.py

@@ -22,7 +22,7 @@ from autogluon.timeseries.utils.datetime import (
     get_seasonality,
     get_time_features_for_frequency,
 )
-from autogluon.timeseries.utils.warning_filters import warning_filter
+from autogluon.timeseries.utils.warning_filters import set_loggers_level, warning_filter
 
 from .utils import MLF_ITEMID, MLF_TARGET, MLF_TIMESTAMP
 
@@ -346,16 +346,17 @@ class AbstractMLForecastModel(AbstractTimeSeriesModel):
             max_num_samples=model_params["max_num_samples"],
         )
 
-        tabular_model = self._create_tabular_model(
-            model_name=model_params["model_name"], model_hyperparameters=model_params["model_hyperparameters"]
-        )
-        tabular_model.fit(
-            X=train_df.drop(columns=[MLF_TARGET, MLF_ITEMID]),
-            y=train_df[MLF_TARGET],
-            X_val=val_df.drop(columns=[MLF_TARGET, MLF_ITEMID]),
-            y_val=val_df[MLF_TARGET],
-            time_limit=(None if time_limit is None else time_limit - (time.time() - fit_start_time)),
-        )
+        with set_loggers_level(regex=r"^autogluon.tabular.*", level=logging.ERROR):
+            tabular_model = self._create_tabular_model(
+                model_name=model_params["model_name"], model_hyperparameters=model_params["model_hyperparameters"]
+            )
+            tabular_model.fit(
+                X=train_df.drop(columns=[MLF_TARGET, MLF_ITEMID]),
+                y=train_df[MLF_TARGET],
+                X_val=val_df.drop(columns=[MLF_TARGET, MLF_ITEMID]),
+                y_val=val_df[MLF_TARGET],
+                time_limit=(None if time_limit is None else time_limit - (time.time() - fit_start_time)),
+            )
 
         # We directly insert the trained model into models_ since calling _mlf.fit_models does not support X_val, y_val
         self._mlf.models_ = {"mean": tabular_model}
@@ -466,9 +467,9 @@ class AbstractMLForecastModel(AbstractTimeSeriesModel):
 
 
 class DirectTabularModel(AbstractMLForecastModel):
-    """Predict all future time series values simultaneously using TabularPredictor from AutoGluon-Tabular.
+    """Predict all future time series values simultaneously using tabular regression models.
 
-    A single TabularPredictor is used to forecast all future time series values using the following features:
+    A single tabular model is used to forecast all future time series values using the following features:
 
     - lag features (observed time series values) based on ``freq`` of the data
     - time features (e.g., day of the week) based on the timestamp of the measurement
@@ -477,8 +478,8 @@ class DirectTabularModel(AbstractMLForecastModel):
 
     Features not known during the forecast horizon (e.g., future target values) are replaced by NaNs.
 
-    If ``eval_metric.needs_quantile``, the TabularPredictor will be trained with ``"quantile"`` problem type.
-    Otherwise, TabularPredictor will be trained with ``"regression"`` problem type, and dummy quantiles will be
+    If ``eval_metric.needs_quantile``, the tabular regression model will be trained with ``"quantile"`` problem type.
+    Otherwise, the model will be trained with ``"regression"`` problem type, and dummy quantiles will be
     obtained by assuming that the residuals follow zero-mean normal distribution.
 
     Based on the `mlforecast <https://github.com/Nixtla/mlforecast>`_ library.
@@ -635,6 +636,8 @@ class DirectTabularModel(AbstractMLForecastModel):
         return TabularModel(
             model_class=model_class,
             model_kwargs={
+                "path": "",
+                "name": model_class.__name__,
                 "hyperparameters": model_hyperparameters,
                 "problem_type": problem_type,
                 "eval_metric": eval_metric,
@@ -746,6 +749,8 @@ class RecursiveTabularModel(AbstractMLForecastModel):
         return TabularModel(
             model_class=model_class,
             model_kwargs={
+                "path": "",
+                "name": model_class.__name__,
                 "hyperparameters": model_hyperparameters,
                 "problem_type": ag.constants.REGRESSION,
                 "eval_metric": self.eval_metric.equivalent_tabular_regression_metric or "mean_absolute_error",

autogluon/timeseries/models/autogluon_tabular/per_step.py

@@ -0,0 +1,453 @@
+import logging
+import math
+import os
+import time
+from typing import Any, Callable, Dict, List, Optional, Type
+
+import numpy as np
+import pandas as pd
+from joblib import Parallel, cpu_count, delayed
+
+from autogluon.common.utils.pandas_utils import get_approximate_df_mem_usage
+from autogluon.common.utils.resource_utils import ResourceManager
+from autogluon.core.constants import QUANTILE
+from autogluon.tabular.models import AbstractModel as AbstractTabularModel
+from autogluon.tabular.registry import ag_model_registry
+from autogluon.timeseries import TimeSeriesDataFrame
+from autogluon.timeseries.dataset.ts_dataframe import ITEMID, TIMESTAMP
+from autogluon.timeseries.models.abstract import AbstractTimeSeriesModel
+from autogluon.timeseries.utils.datetime import get_lags_for_frequency, get_time_features_for_frequency
+from autogluon.timeseries.utils.warning_filters import set_loggers_level
+
+from .utils import MLF_ITEMID, MLF_TARGET, MLF_TIMESTAMP
+
+logger = logging.getLogger(__name__)
+
+DUMMY_FREQ = "D"
+
+
+class PerStepTabularModel(AbstractTimeSeriesModel):
+    """Fit a separate tabular regression model for each time step in the forecast horizon.
+
+    Each model has access to the following features:
+
+    - lag features (observed time series values) based on ``freq`` of the data
+    - time features (e.g., day of the week) based on the timestamp of the measurement
+    - known covariates (if available)
+    - static features of each item (if available)
+
+    This model is typically much slower to fit compared to other tabular forecasting models.
+
+    This model uses `mlforecast <https://github.com/Nixtla/mlforecast>`_ under the hood for efficient preprocessing,
+    but the implementation of the per-step forecasting strategy is different from the `max_horizon` in `mlforecast`.
+
+
+    Other Parameters
+    ----------------
+    trailing_lags : List[int], default = None
+        Trailing window lags of the target that will be used as features for predictions.
+        Trailing lags are shifted per forecast step: model for step `h` uses `[lag+h for lag in trailing_lags]`.
+        If None, defaults to [1, 2, ..., 12].
+    seasonal_lags: List[int], default = None
+        Seasonal lags of the target used as features. Unlike trailing lags, seasonal lags are not shifted
+        but filtered by availability: model for step `h` uses `[lag for lag in seasonal_lags if lag > h]`.
+        If None, determined automatically based on data frequency.
+    date_features : List[Union[str, Callable]], default = None
+        Features computed from the dates. Can be pandas date attributes or functions that will take the dates as input.
+        If None, will be determined automatically based on the frequency of the data.
+    target_scaler : {"standard", "mean_abs", "min_max", "robust", None}, default = "mean_abs"
+        Scaling applied to each time series.
+    model_name : str, default = "CAT"
+        Name of the tabular regression model. See `autogluon.tabular.registry.ag_model_registry` or
+        `the documentation <https://auto.gluon.ai/stable/api/autogluon.tabular.models.html>`_ for the list of available
+        tabular models.
+    model_hyperparameters : Dict[str, Any], optional
+        Hyperparameters passed to the tabular regression model.
+    max_num_items : int or None, default = 20_000
+        If not None, the model will randomly select this many time series for training and validation.
+    max_num_samples : int or None, default = 1_000_000
+        If not None, training dataset passed to TabularPredictor will contain at most this many rows (starting from the
+        end of each time series).
+    n_jobs : int or None, default = None
+        Number of parallel jobs for fitting models across forecast horizons.
+        If None, automatically determined based on available memory to prevent OOM errors.
+    """
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        # We save the relative paths to per-step models. Each worker process independently saves/loads the model.
+        # This is much more efficient than passing around model objects that can get really large
+        self._relative_paths_to_models: list[str]
+        self._trailing_lags: list[int]
+        self._seasonal_lags: list[int]
+        self._date_features: list[Callable]
+        self._model_cls: Type[AbstractTabularModel]
+        self._n_jobs: int
+        self._non_boolean_real_covariates: List[str] = []
+        self._max_ts_length: Optional[int] = None
+
+    @property
+    def allowed_hyperparameters(self) -> List[str]:
+        # TODO: Differencing is currently not supported because it greatly complicates the preprocessing logic
+        return super().allowed_hyperparameters + [
+            "trailing_lags",
+            "seasonal_lags",
+            "date_features",
+            # "differences",
+            "validation_fraction",
+            "model_name",
+            "model_hyperparameters",
+            "max_num_items",
+            "max_num_samples",
+            "n_jobs",
+        ]
+
+    @property
+    def _ag_to_nixtla(self) -> dict:
+        return {self.target: MLF_TARGET, ITEMID: MLF_ITEMID, TIMESTAMP: MLF_TIMESTAMP}
+
+    def _get_default_hyperparameters(self):
+        return {
+            "model_name": "CAT",
+            "model_hyperparameters": {},
+            "target_scaler": "mean_abs",
+            "validation_fraction": 0.1,
+            "max_num_samples": 1_000_000,
+            "max_num_items": 20_000,
+        }
+
+    @staticmethod
+    def _fit_single_model(
+        train_df: pd.DataFrame,
+        path_root: str,
+        step: int,
+        model_cls: Type[AbstractTabularModel],
+        model_hyperparameters: dict,
+        validation_fraction: Optional[float],
+        quantile_levels: list[float],
+        lags: list[int],
+        date_features: list[Callable],
+        time_limit: Optional[float],
+        num_cpus: int,
+        verbosity: int,
+    ) -> str:
+        from mlforecast import MLForecast
+
+        start_time = time.monotonic()
+
+        mlf = MLForecast(models=[], freq=DUMMY_FREQ, lags=lags, date_features=date_features)
+
+        features_df = mlf.preprocess(train_df, static_features=[], dropna=False)
+        del train_df
+        del mlf
+        # Sort chronologically for efficient train/test split
+        features_df = features_df.sort_values(by=MLF_TIMESTAMP)
+        X = features_df.drop(columns=[MLF_ITEMID, MLF_TIMESTAMP, MLF_TARGET])
+        y = features_df[MLF_TARGET]
+        del features_df
+
+        y_is_valid = np.isfinite(y)
+        X, y = X[y_is_valid], y[y_is_valid]
+        X = X.replace(float("inf"), float("nan"))
+        if validation_fraction is None or validation_fraction == 0.0:
+            X_val = None
+            y_val = None
+        else:
+            assert 0 < validation_fraction < 1, "validation_fraction must be between 0.0 and 1.0"
+            num_val = math.ceil(len(X) * validation_fraction)
+            X_val, y_val = X.iloc[-num_val:], y.iloc[-num_val:]
+            X, y = X.iloc[:-num_val], y.iloc[:-num_val]
+        if len(y) == 0:
+            raise ValueError("Not enough valid target values to fit model")
+
+        elapsed = time.monotonic() - start_time
+        time_left = time_limit - elapsed if time_limit is not None else None
+        try:
+            with set_loggers_level(regex=r"^autogluon.tabular.*", level=logging.ERROR):
+                model = model_cls(
+                    path=os.path.join(path_root, f"step_{step}"),
+                    name=model_cls.__name__,  # explicitly provide name to avoid warnings
+                    problem_type=QUANTILE,
+                    eval_metric="pinball_loss",
+                    hyperparameters={**model_hyperparameters, "ag.quantile_levels": quantile_levels},
+                )
+                model.fit(
+                    X=X,
+                    y=y,
+                    X_val=X_val,
+                    y_val=y_val,
+                    time_limit=time_left,
+                    num_cpus=num_cpus,
+                    num_gpus=0,  # num_cpus is only used if num_gpus is set as well
+                    verbosity=verbosity,
+                )
+        except Exception as e:
+            raise RuntimeError(f"Failed when fitting model for {step=}") from e
+        model.save()
+        relative_path = os.path.relpath(path=model.path, start=path_root)
+        return relative_path
+
+    @staticmethod
+    def _get_n_jobs(
+        train_df: pd.DataFrame,
+        num_extra_dynamic_features: int,
+        model_cls: Type[AbstractTabularModel],
+        model_hyperparameters: dict,
+        overhead_factor: float = 2.0,
+    ) -> int:
+        """Estimate the maximum number of jobs that can be run in parallel without encountering OOM errors."""
+        mem_usage_per_column = get_approximate_df_mem_usage(train_df)
+        num_columns = len(train_df.columns)
+        mem_usage_per_job = mem_usage_per_column.sum()
+        try:
+            mem_usage_per_job += model_cls.estimate_memory_usage_static(
+                X=train_df, hyperparameters=model_hyperparameters, problem_type="regression"
+            )
+        except NotImplementedError:
+            mem_usage_per_job *= 2
+        # Extra scaling factor because the preprocessed DF will have more columns for lags + date features
+        mem_usage_per_job *= overhead_factor + (num_extra_dynamic_features + num_columns) / num_columns
+        max_jobs_by_memory = int(ResourceManager.get_available_virtual_mem() / mem_usage_per_job)
+        return max(1, max_jobs_by_memory)
+
+    def preprocess(
+        self,
+        data: TimeSeriesDataFrame,
+        known_covariates: Optional[TimeSeriesDataFrame] = None,
+        is_train: bool = False,
+        **kwargs,
+    ):
+        # TODO: Make this toggleable with a hyperparameter
+        # We add a scaled version of non-boolean known real covariates, same as in MLForecast models
+        if is_train:
+            for col in self.covariate_metadata.known_covariates_real:
+                if not set(data[col].unique()) == set([0, 1]):
+                    self._non_boolean_real_covariates.append(col)
+
+        if len(self._non_boolean_real_covariates) > 0:
+            item_ids = data.index.get_level_values(level=ITEMID)
+            scale_per_column: dict[str, pd.Series] = {}
+            columns_grouped = data[self._non_boolean_real_covariates].abs().groupby(item_ids)
+            for col in self._non_boolean_real_covariates:
+                scale_per_column[col] = columns_grouped[col].mean()
+            data = data.assign(**{f"__scaled_{col}": data[col] / scale for col, scale in scale_per_column.items()})
+            if known_covariates is not None:
+                known_covariates = known_covariates.assign(
+                    **{f"__scaled_{col}": known_covariates[col] / scale for col, scale in scale_per_column.items()}
+                )
+        data = data.astype({self.target: "float32"})
+        return data, known_covariates
+
+    def _get_train_df(
+        self, train_data: TimeSeriesDataFrame, max_num_items: Optional[int], max_num_samples: Optional[int]
+    ) -> pd.DataFrame:
+        if max_num_items is not None and train_data.num_items > max_num_items:
+            items_to_keep = train_data.item_ids.to_series().sample(n=int(max_num_items))  # noqa: F841
+            train_data = train_data.query("item_id in @items_to_keep")
+
+        if max_num_samples is not None and len(train_data) > max_num_samples:
+            max_samples_per_ts = max(200, math.ceil(max_num_samples / train_data.num_items))
+            self._max_ts_length = max_samples_per_ts + self.prediction_length
+            train_data = train_data.slice_by_timestep(-self._max_ts_length, None)
+
+        if len(self.covariate_metadata.past_covariates) > 0:
+            train_data = train_data.drop(columns=self.covariate_metadata.past_covariates)
+
+        train_df = train_data.to_data_frame().reset_index()
+        if train_data.static_features is not None:
+            train_df = pd.merge(
+                left=train_df, right=train_data.static_features, left_on=ITEMID, right_index=True, how="left"
+            )
+        train_df = train_df.rename(columns=self._ag_to_nixtla)
+        train_df = train_df.assign(**{MLF_TARGET: train_df[MLF_TARGET].fillna(float("inf"))})
+        return train_df
+
+    @staticmethod
+    def _get_lags_for_step(
+        trailing_lags: List[int],
+        seasonal_lags: List[int],
+        step: int,
+    ) -> List[int]:
+        """Get the list of lags that can be used by the model for the given step."""
+        shifted_trailing_lags = [lag + step for lag in trailing_lags]
+        # Only keep lags that are available for model predicting `step` values ahead at prediction time
+        valid_lags = [lag for lag in shifted_trailing_lags + seasonal_lags if lag > step]
+        return sorted(set(valid_lags))
+
+    def _fit(
+        self,
+        train_data: TimeSeriesDataFrame,
+        val_data: Optional[TimeSeriesDataFrame] = None,
+        time_limit: Optional[float] = None,
+        verbosity: int = 2,
+        **kwargs,
+    ) -> None:
+        self._check_fit_params()
+        self._log_unused_hyperparameters()
+        model_params = self.get_hyperparameters()
+
+        train_df = self._get_train_df(
+            train_data,
+            max_num_items=model_params["max_num_items"],
+            max_num_samples=model_params["max_num_samples"],
+        )
+
+        # Initialize MLForecast arguments
+        assert self.freq is not None
+        trailing_lags = model_params.get("trailing_lags")
+        if trailing_lags is None:
+            trailing_lags = list(range(1, 13))
+        # Ensure that lags have type list[int] and not, e.g., np.ndarray
+        self._trailing_lags = [int(lag) for lag in trailing_lags]
+        assert all(lag >= 1 for lag in self._trailing_lags), "trailing_lags must be >= 1"
+
+        seasonal_lags = model_params.get("seasonal_lags")
+        if seasonal_lags is None:
+            median_ts_length = int(train_df[MLF_ITEMID].value_counts(sort=False).median())
+            seasonal_lags = get_lags_for_frequency(self.freq, num_default_lags=0, lag_ub=median_ts_length)
+        self._seasonal_lags = [int(lag) for lag in seasonal_lags]
+        assert all(lag >= 1 for lag in self._seasonal_lags), "seasonal_lags must be >= 1"
+
+        date_features = model_params.get("date_features")
+        if date_features is None:
+            date_features = get_time_features_for_frequency(self.freq)
+        self._date_features = date_features
+
+        self._model_cls = ag_model_registry.key_to_cls(model_params["model_name"])
+        supported_problem_types = self._model_cls.supported_problem_types()
+        if supported_problem_types is not None and QUANTILE not in supported_problem_types:
+            raise ValueError(
+                f"Chosen model_name='{model_params['model_name']}' cannot be used by {self.name} because it does not "
+                f"support problem_type='quantile' ({supported_problem_types=})"
+            )
+        model_hyperparameters = model_params["model_hyperparameters"]
+        # User-provided n_jobs takes priority over the automatic estimate
+        if model_params.get("n_jobs") is not None:
+            self._n_jobs = model_params["n_jobs"]
+        else:
+            self._n_jobs = self._get_n_jobs(
+                train_df,
+                num_extra_dynamic_features=len(set(self._seasonal_lags + self._trailing_lags))
+                + len(self._date_features),
+                model_cls=self._model_cls,
+                model_hyperparameters=model_hyperparameters,
+            )
+        n_jobs = min(self._n_jobs, self.prediction_length, cpu_count(only_physical_cores=True))
+
+        num_cpus_per_model = max(cpu_count(only_physical_cores=True) // n_jobs, 1)
+        if time_limit is not None:
+            time_limit_per_model = time_limit / math.ceil(self.prediction_length / n_jobs)
+        else:
+            time_limit_per_model = None
+        model_fit_kwargs = dict(
+            train_df=train_df,
+            path_root=self.path,
+            model_cls=self._model_cls,
+            quantile_levels=self.quantile_levels,
+            validation_fraction=model_params["validation_fraction"],
+            date_features=self._date_features,
+            time_limit=time_limit_per_model,
+            num_cpus=num_cpus_per_model,
+            model_hyperparameters=model_hyperparameters.copy(),
+            verbosity=verbosity - 1,
+        )
+        logger.debug(f"Fitting models in parallel with {n_jobs=}, {num_cpus_per_model=}, {time_limit_per_model=}")
+        self._relative_paths_to_models = Parallel(n_jobs=n_jobs)(  # type: ignore
+            delayed(self._fit_single_model)(
+                step=step,
+                lags=self._get_lags_for_step(
+                    seasonal_lags=self._seasonal_lags, trailing_lags=self._trailing_lags, step=step
+                ),
+                **model_fit_kwargs,
+            )
+            for step in range(self.prediction_length)
+        )
+
+    @staticmethod
+    def _predict_with_single_model(
+        full_df: pd.DataFrame,
+        path_to_model: str,
+        model_cls: Type[AbstractTabularModel],
+        step: int,
+        prediction_length: int,
+        lags: list[int],
+        date_features: list[Callable],
+    ) -> np.ndarray:
+        """Make predictions with the model for the given step.
+
+        Returns
+        -------
+        predictions :
+            Predictions of the model for the given step. Shape: (num_items, len(quantile_levels)).
+        """
+        from mlforecast import MLForecast
+
+        mlf = MLForecast(models=[], freq=DUMMY_FREQ, lags=lags, date_features=date_features)
+
+        features_df = mlf.preprocess(full_df, static_features=[], dropna=False)
+        del mlf
+
+        end_idx_per_item = np.cumsum(features_df[MLF_ITEMID].value_counts(sort=False).to_numpy(dtype="int32"))
+        features_for_step = features_df.iloc[end_idx_per_item - (prediction_length - step)]
+        try:
+            model: AbstractTabularModel = model_cls.load(path_to_model)  # type: ignore
+        except:
+            logger.error(f"Could not load model for {step=} from {path_to_model}")
+            raise
+        predictions = model.predict(features_for_step)
+        return predictions
+
+    def _predict(
+        self,
+        data: TimeSeriesDataFrame,
+        known_covariates: TimeSeriesDataFrame | None = None,
+        **kwargs,
+    ) -> TimeSeriesDataFrame:
+        if known_covariates is not None:
+            X_df = known_covariates
+        else:
+            X_df = TimeSeriesDataFrame(
+                pd.DataFrame(float("inf"), index=self.get_forecast_horizon_index(data), columns=[self.target])
+            )
+        full_df = pd.concat([data, X_df])
+        if self._max_ts_length is not None:
+            full_df = full_df.slice_by_timestep(-(self._max_ts_length + self.prediction_length), None)
+        full_df = full_df.to_data_frame().reset_index()
+        if data.static_features is not None:
+            full_df = pd.merge(full_df, data.static_features, left_on=ITEMID, right_index=True, how="left")
+
+        full_df = (
+            full_df.rename(columns=self._ag_to_nixtla)
+            .sort_values(by=[MLF_ITEMID, MLF_TIMESTAMP])
+            .reset_index(drop=True)
+        )
+        full_df = full_df.assign(**{MLF_TARGET: full_df[MLF_TARGET].fillna(float("inf"))})
+
+        model_predict_kwargs = dict(
+            full_df=full_df,
+            prediction_length=self.prediction_length,
+            model_cls=self._model_cls,
+            date_features=self._date_features,
+        )
+        n_jobs = min(self._n_jobs, self.prediction_length, cpu_count(only_physical_cores=True))
+        predictions_per_step = Parallel(n_jobs=n_jobs)(
+            delayed(self._predict_with_single_model)(
+                step=step,
+                lags=self._get_lags_for_step(
+                    seasonal_lags=self._seasonal_lags, trailing_lags=self._trailing_lags, step=step
+                ),
+                path_to_model=os.path.join(self.path, suffix),
+                **model_predict_kwargs,
+            )
+            for step, suffix in enumerate(self._relative_paths_to_models)
+        )
+        predictions = pd.DataFrame(
+            np.stack(predictions_per_step, axis=1).reshape([-1, len(self.quantile_levels)]),
+            columns=[str(q) for q in self.quantile_levels],
+            index=self.get_forecast_horizon_index(data),
+        )
+        predictions["mean"] = predictions["0.5"]
+        return TimeSeriesDataFrame(predictions)
+
+    def _more_tags(self) -> Dict[str, Any]:
+        return {"allow_nan": True, "can_refit_full": True}

autogluon/timeseries/models/chronos/model.py

@@ -3,7 +3,7 @@ import os
 import shutil
 import warnings
 from pathlib import Path
-from typing import Any, Dict, Literal, Optional, Union
+from typing import Any, Dict, Optional, Union
 
 import numpy as np
 import pandas as pd
@@ -295,8 +295,6 @@ class ChronosModel(AbstractTimeSeriesModel):
         pipeline = BaseChronosPipeline.from_pretrained(
             self.model_path,
             device_map=device,
-            # optimization cannot be used during fine-tuning
-            optimization_strategy=None if is_training else self.optimization_strategy,
             torch_dtype=self.torch_dtype,
         )
 
@@ -332,7 +330,6 @@ class ChronosModel(AbstractTimeSeriesModel):
             "torch_dtype": self.default_torch_dtype,
             "data_loader_num_workers": 0,
             "context_length": None,
-            "optimization_strategy": None,
             "fine_tune": False,
             "keep_transformers_logs": False,
             "fine_tune_lr": 1e-5,
@@ -406,17 +403,6 @@ class ChronosModel(AbstractTimeSeriesModel):
         self.device = model_params["device"]
         self.torch_dtype = model_params["torch_dtype"]
         self.data_loader_num_workers = model_params["data_loader_num_workers"]
-        self.optimization_strategy: Optional[Literal["onnx", "openvino"]] = model_params["optimization_strategy"]
-
-        if self.optimization_strategy is not None:
-            warnings.warn(
-                (
-                    "optimization_strategy is deprecated and will be removed in a future release. "
-                    "We recommend using Chronos-Bolt models for fast inference on the CPU."
-                ),
-                category=FutureWarning,
-                stacklevel=3,
-            )
         self.context_length = model_params["context_length"]
 
         if self.context_length is not None and self.context_length > self.maximum_context_length:

autogluon/timeseries/models/chronos/pipeline/chronos.py

@@ -13,8 +13,6 @@ import torch
 import torch.nn as nn
 from transformers import AutoConfig, AutoModelForSeq2SeqLM, GenerationConfig, PreTrainedModel
 
-from autogluon.timeseries.utils.warning_filters import set_loggers_level
-
 from .base import BaseChronosPipeline, ForecastType
 
 logger = logging.getLogger("autogluon.timeseries.models.chronos")
@@ -529,7 +527,6 @@ class ChronosPipeline(BaseChronosPipeline):
         """
         kwargs = kwargs.copy()
 
-        optimization_strategy = kwargs.pop("optimization_strategy", None)
         context_length = kwargs.pop("context_length", None)
 
         config = AutoConfig.from_pretrained(*args, **kwargs)
@@ -540,45 +537,7 @@ class ChronosPipeline(BaseChronosPipeline):
         chronos_config = ChronosConfig(**config.chronos_config)
 
         assert chronos_config.model_type == "seq2seq"
-        if optimization_strategy is None:
-            inner_model = AutoModelForSeq2SeqLM.from_pretrained(*args, **kwargs)
-        else:
-            assert optimization_strategy in [
-                "onnx",
-                "openvino",
-            ], "optimization_strategy not recognized. Please provide one of `onnx` or `openvino`"
-            kwargs.pop("resume_download", None)  # Optimized pipeline does not support 'resume_download' kwargs
-            torch_dtype = kwargs.pop("torch_dtype", "auto")
-            if torch_dtype != "auto":
-                logger.warning(f"\t`torch_dtype` will be ignored for optimization_strategy {optimization_strategy}")
-
-            if optimization_strategy == "onnx":
-                try:
-                    from optimum.onnxruntime import ORTModelForSeq2SeqLM
-                except ImportError:
-                    raise ImportError(
-                        "Huggingface Optimum library must be installed with ONNX for using the `onnx` strategy. "
-                        "Please try running `pip install optimum[onnxruntime]` or use Chronos-Bolt models for "
-                        "faster performance on the CPU."
-                    )
-
-                assert kwargs.pop("device_map", "cpu") in ["cpu", "auto"], "ONNX mode only available on the CPU"
-                with set_loggers_level(regex=r"^optimum.*", level=logging.ERROR):
-                    inner_model = ORTModelForSeq2SeqLM.from_pretrained(*args, **{**kwargs, "export": True})
-            elif optimization_strategy == "openvino":
-                try:
-                    from optimum.intel import OVModelForSeq2SeqLM
-                except ImportError:
-                    raise ImportError(
-                        "Huggingface Optimum library must be installed with OpenVINO for using the `openvino` strategy. "
-                        "Please try running `pip install optimum-intel[openvino,nncf] optimum[openvino,nncf]` or use "
-                        "Chronos-Bolt models for faster performance on the CPU."
-                    )
-                with set_loggers_level(regex=r"^optimum.*", level=logging.ERROR):
-                    inner_model = OVModelForSeq2SeqLM.from_pretrained(
-                        *args, **{**kwargs, "device_map": "cpu", "export": True}
-                    )
-
+        inner_model = AutoModelForSeq2SeqLM.from_pretrained(*args, **kwargs)
         return cls(
             tokenizer=chronos_config.create_tokenizer(),
             model=ChronosPretrainedModel(config=chronos_config, model=inner_model),

autogluon/timeseries/models/chronos/pipeline/chronos_bolt.py

@@ -510,9 +510,6 @@ class ChronosBoltPipeline(BaseChronosPipeline):
         Supports the same arguments as ``AutoConfig`` and ``AutoModel``
         from ``transformers``.
         """
-        # if optimization_strategy is provided, pop this as it won't be used
-        kwargs.pop("optimization_strategy", None)
-
         config = AutoConfig.from_pretrained(*args, **kwargs)
         assert hasattr(config, "chronos_config"), "Not a Chronos config file"
 

autogluon/timeseries/models/local/abstract_local_model.py

@@ -1,11 +1,11 @@
 import logging
 import time
-from multiprocessing import TimeoutError, cpu_count
+from multiprocessing import TimeoutError
 from typing import Any, Callable, Dict, List, Optional, Tuple, Union
 
 import numpy as np
 import pandas as pd
-from joblib import Parallel, delayed
+from joblib import Parallel, cpu_count, delayed
 from scipy.stats import norm
 
 from autogluon.core.utils.exceptions import TimeLimitExceeded
@@ -19,7 +19,7 @@ logger = logging.getLogger(__name__)
 
 
 # We use the same default n_jobs across AG-TS to ensure that Joblib reuses the process pool
-AG_DEFAULT_N_JOBS = max(int(cpu_count() * 0.5), 1)
+AG_DEFAULT_N_JOBS = max(cpu_count(only_physical_cores=True), 1)
 
 
 class AbstractLocalModel(AbstractTimeSeriesModel):

autogluon/timeseries/models/local/naive.py

@@ -17,7 +17,7 @@ class NaiveModel(AbstractLocalModel):
 
     Other Parameters
     ----------------
-    n_jobs : int or float, default = 0.5
+    n_jobs : int or float, default = joblib.cpu_count(only_physical_cores=True)
         Number of CPU cores used to fit the models in parallel.
         When set to a float between 0.0 and 1.0, that fraction of available CPU cores is used.
         When set to a positive integer, that many cores are used.
@@ -59,7 +59,7 @@ class SeasonalNaiveModel(AbstractLocalModel):
         specified manually by providing an integer > 1.
         If seasonal_period (inferred or provided) is equal to 1, will fall back to Naive forecast.
         Seasonality will also be disabled, if the length of the time series is < seasonal_period.
-    n_jobs : int or float, default = 0.5
+    n_jobs : int or float, default = joblib.cpu_count(only_physical_cores=True)
         Number of CPU cores used to fit the models in parallel.
         When set to a float between 0.0 and 1.0, that fraction of available CPU cores is used.
         When set to a positive integer, that many cores are used.
@@ -89,7 +89,7 @@ class AverageModel(AbstractLocalModel):
 
     Other Parameters
     ----------------
-    n_jobs : int or float, default = 0.5
+    n_jobs : int or float, default = joblib.cpu_count(only_physical_cores=True)
         Number of CPU cores used to fit the models in parallel.
         When set to a float between 0.0 and 1.0, that fraction of available CPU cores is used.
         When set to a positive integer, that many cores are used.
@@ -128,7 +128,7 @@ class SeasonalAverageModel(AbstractLocalModel):
         specified manually by providing an integer > 1.
         If seasonal_period (inferred or provided) is equal to 1, will fall back to Naive forecast.
         Seasonality will also be disabled, if the length of the time series is < seasonal_period.
-    n_jobs : int or float, default = 0.5
+    n_jobs : int or float, default = joblib.cpu_count(only_physical_cores=True)
         Number of CPU cores used to fit the models in parallel.
         When set to a float between 0.0 and 1.0, that fraction of available CPU cores is used.
         When set to a positive integer, that many cores are used.

autogluon/timeseries/models/local/npts.py

@@ -26,7 +26,7 @@ class NPTSModel(AbstractLocalModel):
         Number of samples generated by the forecast.
     num_default_time_features : int, default = 1
         Number of time features used by seasonal model.
-    n_jobs : int or float, default = 0.5
+    n_jobs : int or float, default = joblib.cpu_count(only_physical_cores=True)
         Number of CPU cores used to fit the models in parallel.
         When set to a float between 0.0 and 1.0, that fraction of available CPU cores is used.
         When set to a positive integer, that many cores are used.

autogluon/timeseries/models/local/statsforecast.py

@@ -123,7 +123,7 @@ class AutoARIMAModel(AbstractProbabilisticStatsForecastModel):
         When set to None, seasonal_period will be inferred from the frequency of the training data. Can also be
         specified manually by providing an integer > 1.
         If seasonal_period (inferred or provided) is equal to 1, seasonality will be disabled.
-    n_jobs : int or float, default = 0.5
+    n_jobs : int or float, default = joblib.cpu_count(only_physical_cores=True)
         Number of CPU cores used to fit the models in parallel.
         When set to a float between 0.0 and 1.0, that fraction of available CPU cores is used.
         When set to a positive integer, that many cores are used.
@@ -201,7 +201,7 @@ class ARIMAModel(AbstractProbabilisticStatsForecastModel):
         When set to None, seasonal_period will be inferred from the frequency of the training data. Can also be
         specified manually by providing an integer > 1.
         If seasonal_period (inferred or provided) is equal to 1, seasonality will be disabled.
-    n_jobs : int or float, default = 0.5
+    n_jobs : int or float, default = joblib.cpu_count(only_physical_cores=True)
         Number of CPU cores used to fit the models in parallel.
         When set to a float between 0.0 and 1.0, that fraction of available CPU cores is used.
         When set to a positive integer, that many cores are used.
@@ -257,7 +257,7 @@ class AutoETSModel(AbstractProbabilisticStatsForecastModel):
         If seasonal_period (inferred or provided) is equal to 1, seasonality will be disabled.
     damped : bool, default = False
         Whether to dampen the trend.
-    n_jobs : int or float, default = 0.5
+    n_jobs : int or float, default = joblib.cpu_count(only_physical_cores=True)
         Number of CPU cores used to fit the models in parallel.
         When set to a float between 0.0 and 1.0, that fraction of available CPU cores is used.
         When set to a positive integer, that many cores are used.
@@ -320,7 +320,7 @@ class ETSModel(AutoETSModel):
         If seasonal_period (inferred or provided) is equal to 1, seasonality will be disabled.
     damped : bool, default = False
         Whether to dampen the trend.
-    n_jobs : int or float, default = 0.5
+    n_jobs : int or float, default = joblib.cpu_count(only_physical_cores=True)
         Number of CPU cores used to fit the models in parallel.
         When set to a float between 0.0 and 1.0, that fraction of available CPU cores is used.
         When set to a positive integer, that many cores are used.
@@ -359,7 +359,7 @@ class DynamicOptimizedThetaModel(AbstractProbabilisticStatsForecastModel):
         When set to None, seasonal_period will be inferred from the frequency of the training data. Can also be
         specified manually by providing an integer > 1.
         If seasonal_period (inferred or provided) is equal to 1, seasonality will be disabled.
-    n_jobs : int or float, default = 0.5
+    n_jobs : int or float, default = joblib.cpu_count(only_physical_cores=True)
         Number of CPU cores used to fit the models in parallel.
         When set to a float between 0.0 and 1.0, that fraction of available CPU cores is used.
         When set to a positive integer, that many cores are used.
@@ -403,7 +403,7 @@ class ThetaModel(AbstractProbabilisticStatsForecastModel):
         When set to None, seasonal_period will be inferred from the frequency of the training data. Can also be
         specified manually by providing an integer > 1.
         If seasonal_period (inferred or provided) is equal to 1, seasonality will be disabled.
-    n_jobs : int or float, default = 0.5
+    n_jobs : int or float, default = joblib.cpu_count(only_physical_cores=True)
         Number of CPU cores used to fit the models in parallel.
         When set to a float between 0.0 and 1.0, that fraction of available CPU cores is used.
         When set to a positive integer, that many cores are used.
@@ -523,7 +523,7 @@ class AutoCESModel(AbstractProbabilisticStatsForecastModel):
         When set to None, seasonal_period will be inferred from the frequency of the training data. Can also be
         specified manually by providing an integer > 1.
         If seasonal_period (inferred or provided) is equal to 1, seasonality will be disabled.
-    n_jobs : int or float, default = 0.5
+    n_jobs : int or float, default = joblib.cpu_count(only_physical_cores=True)
         Number of CPU cores used to fit the models in parallel.
         When set to a float between 0.0 and 1.0, that fraction of available CPU cores is used.
         When set to a positive integer, that many cores are used.
@@ -590,7 +590,7 @@ class ADIDAModel(AbstractStatsForecastIntermittentDemandModel):
 
     Other Parameters
     ----------------
-    n_jobs : int or float, default = 0.5
+    n_jobs : int or float, default = joblib.cpu_count(only_physical_cores=True)
         Number of CPU cores used to fit the models in parallel.
         When set to a float between 0.0 and 1.0, that fraction of available CPU cores is used.
         When set to a positive integer, that many cores are used.
@@ -626,7 +626,7 @@ class CrostonModel(AbstractStatsForecastIntermittentDemandModel):
         - `"SBA"` - variant of the Croston method based on Syntetos-Boylan Approximation (based on `statsforecast.models.CrostonSBA <https://nixtla.mintlify.app/statsforecast/docs/models/crostonsba.html>`_)
         - `"optimized"` - variant of the Croston method where the smoothing parameter is optimized (based on `statsforecast.models.CrostonOptimized <https://nixtla.mintlify.app/statsforecast/docs/models/crostonoptimized.html>`_)
 
-    n_jobs : int or float, default = 0.5
+    n_jobs : int or float, default = joblib.cpu_count(only_physical_cores=True)
         Number of CPU cores used to fit the models in parallel.
         When set to a float between 0.0 and 1.0, that fraction of available CPU cores is used.
         When set to a positive integer, that many cores are used.
@@ -678,7 +678,7 @@ class IMAPAModel(AbstractStatsForecastIntermittentDemandModel):
 
     Other Parameters
     ----------------
-    n_jobs : int or float, default = 0.5
+    n_jobs : int or float, default = joblib.cpu_count(only_physical_cores=True)
         Number of CPU cores used to fit the models in parallel.
         When set to a float between 0.0 and 1.0, that fraction of available CPU cores is used.
         When set to a positive integer, that many cores are used.
@@ -700,7 +700,7 @@ class ZeroModel(AbstractStatsForecastIntermittentDemandModel):
 
     Other Parameters
     ----------------
-    n_jobs : int or float, default = 0.5
+    n_jobs : int or float, default = joblib.cpu_count(only_physical_cores=True)
         Number of CPU cores used to fit the models in parallel.
         When set to a float between 0.0 and 1.0, that fraction of available CPU cores is used.
         When set to a positive integer, that many cores are used.

autogluon/timeseries/models/presets.py

@@ -27,6 +27,7 @@ from . import (
     NaiveModel,
     NPTSModel,
     PatchTSTModel,
+    PerStepTabularModel,
     RecursiveTabularModel,
     SeasonalAverageModel,
     SeasonalNaiveModel,
@@ -55,6 +56,7 @@ MODEL_TYPES = dict(
     WaveNet=WaveNetModel,
     RecursiveTabular=RecursiveTabularModel,
     DirectTabular=DirectTabularModel,
+    PerStepTabular=PerStepTabularModel,
     Average=AverageModel,
     SeasonalAverage=SeasonalAverageModel,
     Naive=NaiveModel,
@@ -84,6 +86,7 @@ DEFAULT_MODEL_PRIORITY = dict(
     Zero=100,
     RecursiveTabular=90,
     DirectTabular=85,
+    PerStepTabular=70,  # TODO: Update priority
     # All local models are grouped together to make sure that joblib parallel pool is reused
     NPTS=80,
     ETS=80,

autogluon/timeseries/utils/datetime/lags.py

@@ -164,7 +164,7 @@ def get_lags_for_frequency(
         raise Exception(f"Cannot get lags for unsupported frequency {freq}")
 
     # flatten lags list and filter
-    lags = [int(lag) for sub_list in lags for lag in sub_list if 7 < lag <= lag_ub]
+    lags = [int(lag) for sub_list in lags for lag in sub_list if num_default_lags < lag <= lag_ub]
     lags = list(range(1, num_default_lags + 1)) + sorted(list(set(lags)))
 
     return sorted(set(lags))[:num_lags]

autogluon/timeseries/version.py

@@ -1,4 +1,4 @@
 """This is the autogluon version file."""
 
-__version__ = "1.3.2b20250708"
+__version__ = "1.3.2b20250710"
 __lite__ = False

{autogluon.timeseries-1.3.2b20250708.dist-info → autogluon.timeseries-1.3.2b20250710.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: autogluon.timeseries
-Version: 1.3.2b20250708
+Version: 1.3.2b20250710
 Summary: Fast and Accurate ML in 3 Lines of Code
 Home-page: https://github.com/autogluon/autogluon
 Author: AutoGluon Community
@@ -37,9 +37,9 @@ Description-Content-Type: text/markdown
 License-File: ../LICENSE
 License-File: ../NOTICE
 Requires-Dist: joblib<2,>=1.1
-Requires-Dist: numpy<2.3.0,>=1.25.0
-Requires-Dist: scipy<1.16,>=1.5.4
-Requires-Dist: pandas<2.3.0,>=2.0.0
+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.2
 Requires-Dist: lightning<2.8,>=2.2
 Requires-Dist: pytorch-lightning
@@ -55,16 +55,11 @@ Requires-Dist: fugue>=0.9.0
 Requires-Dist: tqdm<5,>=4.38
 Requires-Dist: orjson~=3.9
 Requires-Dist: tensorboard<3,>=2.9
-Requires-Dist: autogluon.core[raytune]==1.3.2b20250708
-Requires-Dist: autogluon.common==1.3.2b20250708
-Requires-Dist: autogluon.features==1.3.2b20250708
-Requires-Dist: autogluon.tabular[catboost,lightgbm,xgboost]==1.3.2b20250708
+Requires-Dist: autogluon.core[raytune]==1.3.2b20250710
+Requires-Dist: autogluon.common==1.3.2b20250710
+Requires-Dist: autogluon.features==1.3.2b20250710
+Requires-Dist: autogluon.tabular[catboost,lightgbm,xgboost]==1.3.2b20250710
 Provides-Extra: all
-Provides-Extra: chronos-onnx
-Requires-Dist: optimum[onnxruntime]<1.23,>=1.17; extra == "chronos-onnx"
-Provides-Extra: chronos-openvino
-Requires-Dist: optimum-intel[nncf,openvino]<1.23,>=1.15; extra == "chronos-openvino"
-Requires-Dist: optimum[nncf,openvino]<1.23,>=1.17; extra == "chronos-openvino"
 Provides-Extra: tests
 Requires-Dist: pytest; extra == "tests"
 Requires-Dist: ruff>=0.0.285; extra == "tests"

{autogluon.timeseries-1.3.2b20250708.dist-info → autogluon.timeseries-1.3.2b20250710.dist-info}/RECORD

@@ -1,4 +1,4 @@
-autogluon.timeseries-1.3.2b20250708-py3.9-nspkg.pth,sha256=cQGwpuGPqg1GXscIwt-7PmME1OnSpD-7ixkikJ31WAY,554
+autogluon.timeseries-1.3.2b20250710-py3.9-nspkg.pth,sha256=cQGwpuGPqg1GXscIwt-7PmME1OnSpD-7ixkikJ31WAY,554
 autogluon/timeseries/__init__.py,sha256=_CrLLc1fkjen7UzWoO0Os8WZoHOgvZbHKy46I8v_4k4,304
 autogluon/timeseries/evaluator.py,sha256=l642tYfTHsl8WVIq_vV6qhgAFVFr9UuZD7gLra3A_Kc,250
 autogluon/timeseries/learner.py,sha256=pIn4YSOk0aqCWyBpIlwnAsFnG4h7PLXk8guFH3wFS-w,13923
@@ -6,7 +6,7 @@ autogluon/timeseries/predictor.py,sha256=u4d7-xMs669g5xxqIYuvEyGQ0P6Y8IoToiyg9zU
 autogluon/timeseries/regressor.py,sha256=oeShL68b50cX7WASj7YRiYaJ012QudUUTyZFBpMZMqU,11958
 autogluon/timeseries/splitter.py,sha256=yzPca9p2bWV-_VJAptUyyzQsxu-uixAdpMoGQtDzMD4,3205
 autogluon/timeseries/trainer.py,sha256=-xdGZ4v8OTA3AzMjBJ4CwGYhmKBRsY0Q-dm6YioFOmc,57977
-autogluon/timeseries/version.py,sha256=bPNi8NovxQNyeJ5w4M2ZZ9xSntQLdXtKF3qiO1H2k2A,91
+autogluon/timeseries/version.py,sha256=7DTsh87cIM0xS67uB9g3eKGKiM6QqP2Gr5W3n-lwcfU,91
 autogluon/timeseries/configs/__init__.py,sha256=BTtHIPCYeGjqgOcvqb8qPD4VNX-ICKOg6wnkew1cPOE,98
 autogluon/timeseries/configs/presets_configs.py,sha256=cLat8ecLlWrI-SC5KLBDCX2SbVXaucemy2pjxJAtSY0,2543
 autogluon/timeseries/dataset/__init__.py,sha256=UvnhAN5tjgxXTHoZMQDy64YMDj4Xxa68yY7NP4vAw0o,81
@@ -16,22 +16,23 @@ autogluon/timeseries/metrics/abstract.py,sha256=BpHVmzkzM6EN63NQrDRkApIeAyrpT6Y9
 autogluon/timeseries/metrics/point.py,sha256=xllyGh11otbmUVHyIaceROPR3qyllWPQ9xlSmIGI3EI,18306
 autogluon/timeseries/metrics/quantile.py,sha256=vhmETtjPsIfVlvtILNAT6F2PtIDNPrOroy-U1FQbgw8,4632
 autogluon/timeseries/metrics/utils.py,sha256=HuDe1BNe8yJU4f_DKM913nNrUueoRaw6zhxm1-S20s0,910
-autogluon/timeseries/models/__init__.py,sha256=MYD9JJ-wUDE5B6jW6E6LU2eXQ6vflfQBvqQJkdzJa3A,1189
-autogluon/timeseries/models/presets.py,sha256=HEACiRpnY6dcff7W44gnM0x1KRgr2bNf5D6zcaHgHxo,12201
+autogluon/timeseries/models/__init__.py,sha256=nx61eXLCxWIb-eJXpYgCw3C7naNklh_FAaKImb8EdvI,1237
+autogluon/timeseries/models/presets.py,sha256=ejVCs1Uv6EwVn55uKYyb4ju0kFuuwlOaO0yVmwYbMgI,12314
 autogluon/timeseries/models/abstract/__init__.py,sha256=Htfkjjc3vo92RvyM8rIlQ0PLWt3jcrCKZES07UvCMV0,146
 autogluon/timeseries/models/abstract/abstract_timeseries_model.py,sha256=apt1AsGQF9lKrdSShIG3KsqNsZ7oEwUGd9mjhMN9S0M,33108
 autogluon/timeseries/models/abstract/model_trial.py,sha256=ENPg_7nsdxIvaNM0o0UShZ3x8jFlRmwRc5m0fGPC0TM,3720
 autogluon/timeseries/models/abstract/tunable.py,sha256=SFl4vjkb6BfFFaRPVdftnnLYlIyCThutLHxiiAlV6tY,7168
-autogluon/timeseries/models/autogluon_tabular/__init__.py,sha256=r9i6jWcyeLHYClkcMSKRVsfrkBUMxpDrTATNTBc_qgQ,136
-autogluon/timeseries/models/autogluon_tabular/mlforecast.py,sha256=awkQ-L-9kmeHBSJmXJdQGvuPI3mJWJXLGL5AMUG4Rsg,36820
+autogluon/timeseries/models/autogluon_tabular/__init__.py,sha256=E5fZsdFPgVdyCVyj5bGmn_lQFlCMn2NvuRLBMcCFvhM,205
+autogluon/timeseries/models/autogluon_tabular/mlforecast.py,sha256=3yaPAqnqTv5kxkYg_JmQR7Q5yiaAAGKdaMFtN_GC-Yk,37095
+autogluon/timeseries/models/autogluon_tabular/per_step.py,sha256=qCC8ed4pqm6yoW743WJ2z1Nh6WV8-Z8EVqRwX9Lz6eE,20580
 autogluon/timeseries/models/autogluon_tabular/transforms.py,sha256=aI1QJLJaOB5Xy2WA0jo6Jh25MRVyyZ8ONrqlV96kpw0,2735
 autogluon/timeseries/models/autogluon_tabular/utils.py,sha256=Fn3Vu_Q0PCtEUbtNgLp1xIblg7dOdpFlF3W5kLHgruI,63
 autogluon/timeseries/models/chronos/__init__.py,sha256=wT77HzTtmQxW3sw2k0mA5Ot6PSHivX-Uvn5fjM05EU4,60
-autogluon/timeseries/models/chronos/model.py,sha256=B5NJsn5SiDtKpS0DjKgFFQwafF94mhLP2GMwzTYRUQA,33021
+autogluon/timeseries/models/chronos/model.py,sha256=zs8tbK4CMd-MvHrN_RZJ4sPcJiiLYiGDKtwgSLl9SZY,32315
 autogluon/timeseries/models/chronos/pipeline/__init__.py,sha256=bkTR0LSKIxAaKFOr9A0HSkCtnRdikDPUPp810WOKgxE,247
 autogluon/timeseries/models/chronos/pipeline/base.py,sha256=14OAKHmio6LmO4mVom2mPGB0CvIrOjMGJzb-MVSAq-s,5596
-autogluon/timeseries/models/chronos/pipeline/chronos.py,sha256=uFJLsSb2WQiSrmDZ0g2mO-lhTFUlq7vplGRBXZ9_VBk,22591
-autogluon/timeseries/models/chronos/pipeline/chronos_bolt.py,sha256=hUZ5Qxgaj4LgUl_P6ENI_-xaJUZc_kUn_wIOIdPjOo0,21538
+autogluon/timeseries/models/chronos/pipeline/chronos.py,sha256=C44HGXa_eW80gnnsTgTdsD18aVH-pe-DqkxUYcQx7K4,20216
+autogluon/timeseries/models/chronos/pipeline/chronos_bolt.py,sha256=BGov6fKr3hip_b0vVQEGAjvRFyc-bucmFPq0s8OoIwU,21410
 autogluon/timeseries/models/chronos/pipeline/utils.py,sha256=rWqT3DB9upZb7GFVMOxc-ww2EhH8bD7TmEZNi_xTAbE,13033
 autogluon/timeseries/models/ensemble/__init__.py,sha256=x2Y6dWk15XugTEWNUKq8U5z6nIjelo3UjpI-TfS13OE,159
 autogluon/timeseries/models/ensemble/abstract.py,sha256=ie-BKD4JIkQQoKqtf6sYI5Aix7dSgywFsSdeGPxoElk,5821
@@ -42,10 +43,10 @@ autogluon/timeseries/models/gluonts/abstract.py,sha256=ae-VGN2KY6W8RtzZH3wxhjUP-
 autogluon/timeseries/models/gluonts/dataset.py,sha256=I_4Rq2CXiLiiSf99WYYaRfT7NXEUmlkW1JIZnWjAdLY,5121
 autogluon/timeseries/models/gluonts/models.py,sha256=Pi_zCRkslt2-LXkZpE56aRx9J4gRCOVabqYltPtI9tE,25718
 autogluon/timeseries/models/local/__init__.py,sha256=e2UImoJhmj70E148IIObv90C_bHxgyLNk6YsS4p7pfs,701
-autogluon/timeseries/models/local/abstract_local_model.py,sha256=YTCRWTwx1thH-wRVjcLKBVozy3OVfGkmJxN9mOb6VwI,11522
-autogluon/timeseries/models/local/naive.py,sha256=SMdA2Tu-o7gfOLhOoh5m1oe85F3LXn9ulTzRXFhLH20,7252
-autogluon/timeseries/models/local/npts.py,sha256=Bp74doKnfpGE8ywP4FWOCI_RwRMsmgocYDfGtq764DA,4143
-autogluon/timeseries/models/local/statsforecast.py,sha256=s3Byp7WAUy0Rnfl1qYMSIm44MKD9t8E732xuNLk_aao,32615
+autogluon/timeseries/models/local/abstract_local_model.py,sha256=BVCMC0wNMwrrDfZy_SQJeEajPmYBAyUlMu4qrTkWJBQ,11535
+autogluon/timeseries/models/local/naive.py,sha256=TAiQLt3fGCQoZKjBzmlhosV2XVEZ1urtPHDhM7Mf2i8,7408
+autogluon/timeseries/models/local/npts.py,sha256=I3y5g-718TVVhAbotfJ74wvLfLQ6HfLwA_ivrEWY7Qc,4182
+autogluon/timeseries/models/local/statsforecast.py,sha256=h2ra9yWEY8DTUSPzgwS8nBKdk7dThwPjY1Os-ewRId4,33044
 autogluon/timeseries/models/multi_window/__init__.py,sha256=Bq7AT2Jxdd4WNqmjTdzeqgNiwn1NCyWp4tBIWaM-zfI,60
 autogluon/timeseries/models/multi_window/multi_window_model.py,sha256=xW55TMg7kgta-TmBpVZGcDQlBdBN_eW1z1lVNjZGhpo,11833
 autogluon/timeseries/transforms/__init__.py,sha256=fKlT4pkJ_8Gl7IUTc3uSDzt2Xow5iH5w6fPB3ePNrTg,127
@@ -57,14 +58,14 @@ autogluon/timeseries/utils/forecast.py,sha256=yK1_eNtRUPYGs0R-VWMO4c81LrTGF57ih3
 autogluon/timeseries/utils/warning_filters.py,sha256=tHvhj9y7c3MP6JrjAedc7UiFFw0_mKYziDQupw8NhiQ,2538
 autogluon/timeseries/utils/datetime/__init__.py,sha256=bTMR8jLh1LW55vHjbOr1zvWRMF_PqbvxpS-cUcNIDWI,173
 autogluon/timeseries/utils/datetime/base.py,sha256=3NdsH3NDq4cVAOSoy3XpaNixyNlbjy4DJ_YYOGuu9x4,1341
-autogluon/timeseries/utils/datetime/lags.py,sha256=gQDk5_zmsY5DUWDUpSaCKYkQ9nHKKY-LsywJQRAoYSk,5988
+autogluon/timeseries/utils/datetime/lags.py,sha256=dpndFOV-d-AqCTwKeQ5Dz-AfCJTeI27bxDC13QzY4y8,6003
 autogluon/timeseries/utils/datetime/seasonality.py,sha256=YK_2k8hvYIMW-sJPnjGWRtCnvIOthwA2hATB3nwVoD4,834
 autogluon/timeseries/utils/datetime/time_features.py,sha256=MjLi3zQ00uWWJtXH9oGX2GJkTbvjdSiuabSa4kcVuxE,2672
-autogluon.timeseries-1.3.2b20250708.dist-info/LICENSE,sha256=CeipvOyAZxBGUsFoaFqwkx54aPnIKEtm9a5u2uXxEws,10142
-autogluon.timeseries-1.3.2b20250708.dist-info/METADATA,sha256=Atzr1D5lNtb89ne-YooLjW5xNO1fzXGVlCEKCNfag8Y,12742
-autogluon.timeseries-1.3.2b20250708.dist-info/NOTICE,sha256=7nPQuj8Kp-uXsU0S5so3-2dNU5EctS5hDXvvzzehd7E,114
-autogluon.timeseries-1.3.2b20250708.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-autogluon.timeseries-1.3.2b20250708.dist-info/namespace_packages.txt,sha256=giERA4R78OkJf2ijn5slgjURlhRPzfLr7waIcGkzYAo,10
-autogluon.timeseries-1.3.2b20250708.dist-info/top_level.txt,sha256=giERA4R78OkJf2ijn5slgjURlhRPzfLr7waIcGkzYAo,10
-autogluon.timeseries-1.3.2b20250708.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-autogluon.timeseries-1.3.2b20250708.dist-info/RECORD,,
+autogluon.timeseries-1.3.2b20250710.dist-info/LICENSE,sha256=CeipvOyAZxBGUsFoaFqwkx54aPnIKEtm9a5u2uXxEws,10142
+autogluon.timeseries-1.3.2b20250710.dist-info/METADATA,sha256=Y3kzbY2t9xUR5bnvnlZ2go5LioftRxA8mrmhuUFfdU4,12443
+autogluon.timeseries-1.3.2b20250710.dist-info/NOTICE,sha256=7nPQuj8Kp-uXsU0S5so3-2dNU5EctS5hDXvvzzehd7E,114
+autogluon.timeseries-1.3.2b20250710.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+autogluon.timeseries-1.3.2b20250710.dist-info/namespace_packages.txt,sha256=giERA4R78OkJf2ijn5slgjURlhRPzfLr7waIcGkzYAo,10
+autogluon.timeseries-1.3.2b20250710.dist-info/top_level.txt,sha256=giERA4R78OkJf2ijn5slgjURlhRPzfLr7waIcGkzYAo,10
+autogluon.timeseries-1.3.2b20250710.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+autogluon.timeseries-1.3.2b20250710.dist-info/RECORD,,