autogluon.timeseries 1.0.1b20240324__py3-none-any.whl → 1.0.1b20240326__py3-none-any.whl

autogluon/timeseries/configs/presets_configs.py

@@ -1,5 +1,7 @@
 """Preset configurations for autogluon.timeseries Predictors"""
 
+from autogluon.timeseries.models.presets import get_default_hps
+
 # TODO: change default HPO settings when other HPO strategies (e.g., Ray tune) are available
 # TODO: add refit_full arguments once refitting is available
 
@@ -8,4 +10,52 @@ TIMESERIES_PRESETS_CONFIGS = dict(
     high_quality={"hyperparameters": "default"},
     medium_quality={"hyperparameters": "light"},
     fast_training={"hyperparameters": "very_light"},
+    chronos_tiny={
+        "hyperparameters": {"Chronos": {"model_path": "tiny"}},
+        "skip_model_selection": True,
+    },
+    chronos_mini={
+        "hyperparameters": {"Chronos": {"model_path": "mini"}},
+        "skip_model_selection": True,
+    },
+    chronos_small={
+        "hyperparameters": {"Chronos": {"model_path": "small"}},
+        "skip_model_selection": True,
+    },
+    chronos_base={
+        "hyperparameters": {"Chronos": {"model_path": "base"}},
+        "skip_model_selection": True,
+    },
+    chronos_large={
+        "hyperparameters": {"Chronos": {"model_path": "large", "batch_size": 8}},
+        "skip_model_selection": True,
+    },
+    chronos_ensemble={
+        "hyperparameters": {
+            "Chronos": {"model_path": "small"},
+            **get_default_hps("default"),
+        }
+    },
+    chronos_large_ensemble={
+        "hyperparameters": {
+            "Chronos": {"model_path": "large", "batch_size": 8},
+            **get_default_hps("default"),
+        }
+    },
+)
+
+TIMESERIES_PRESETS_ALIASES = dict(
+    chronos="chronos_small",
+    best="best_quality",
+    high="high_quality",
+    medium="medium_quality",
+    bq="best_quality",
+    hq="high_quality",
+    mq="medium_quality",
 )
+
+# update with aliases
+TIMESERIES_PRESETS_CONFIGS = {
+    **TIMESERIES_PRESETS_CONFIGS,
+    **{k: TIMESERIES_PRESETS_CONFIGS[v].copy() for k, v in TIMESERIES_PRESETS_ALIASES.items()},
+}

autogluon/timeseries/learner.py

@@ -97,6 +97,7 @@ class TimeSeriesLearner(AbstractLearner):
                 target=self.target,
                 quantile_levels=self.quantile_levels,
                 verbosity=kwargs.get("verbosity", 2),
+                skip_model_selection=kwargs.get("skip_model_selection", False),
                 enable_ensemble=kwargs.get("enable_ensemble", True),
                 metadata=self.feature_generator.covariate_metadata,
                 val_splitter=val_splitter,

autogluon/timeseries/models/__init__.py

@@ -1,4 +1,5 @@
 from .autogluon_tabular import DirectTabularModel, RecursiveTabularModel
+from .chronos import ChronosModel
 from .gluonts import (
     DeepARModel,
     DLinearModel,
@@ -44,6 +45,7 @@ __all__ = [
     "DynamicOptimizedThetaModel",
     "ETSModel",
     "IMAPAModel",
+    "ChronosModel",
     "NPTSModel",
     "NaiveModel",
     "PatchTSTModel",

autogluon/timeseries/models/chronos/__init__.py

@@ -0,0 +1,3 @@
+from .model import ChronosModel
+
+__all__ = ["ChronosModel"]

autogluon/timeseries/models/chronos/chronos.py

@@ -0,0 +1,487 @@
+# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+# Original Source: https://github.com/amazon-science/chronos-forecasting
+# Author: Lorenzo Stella <stellalo@amazon.com>
+
+import logging
+import warnings
+from dataclasses import dataclass
+from typing import Any, Dict, List, Literal, Optional, Tuple, Union
+
+import torch
+import torch.nn as nn
+from transformers import AutoConfig, AutoModelForCausalLM, AutoModelForSeq2SeqLM, GenerationConfig, PreTrainedModel
+
+from autogluon.timeseries.utils.warning_filters import set_loggers_level
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class ChronosConfig:
+    """
+    This class holds all the configuration parameters to be used
+    by ``ChronosTokenizer`` and ``ChronosPretrainedModel``.
+    """
+
+    tokenizer_class: str
+    tokenizer_kwargs: Dict[str, Any]
+    n_tokens: int
+    n_special_tokens: int
+    pad_token_id: int
+    eos_token_id: int
+    use_eos_token: bool
+    model_type: Literal["causal", "seq2seq"]
+    context_length: int
+    prediction_length: int
+    num_samples: int
+    temperature: float
+    top_k: int
+    top_p: float
+
+    def __post_init__(self):
+        assert (
+            self.pad_token_id < self.n_special_tokens and self.eos_token_id < self.n_special_tokens
+        ), f"Special token id's must be smaller than {self.n_special_tokens=}"
+
+    def create_tokenizer(self) -> "ChronosTokenizer":
+        if self.tokenizer_class == "MeanScaleUniformBins":
+            return MeanScaleUniformBins(**self.tokenizer_kwargs, config=self)
+        raise ValueError
+
+
+class ChronosTokenizer:
+    """
+    A ``ChronosTokenizer`` defines how time series are mapped into token IDs
+    and back.
+
+    For details, see the ``input_transform`` and ``output_transform`` methods,
+    which concrete classes must implement.
+    """
+
+    def input_transform(self, context: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor, Any]:
+        """
+        Turn a batch of time series into token IDs, attention map, and scale.
+
+        Parameters
+        ----------
+        context
+            A tensor shaped (batch_size, time_length), containing the
+            timeseries to forecast. Use left-padding with ``torch.nan``
+            to align time series of different lengths.
+
+        Returns
+        -------
+        token_ids
+            A tensor of integers, shaped (batch_size, time_length + 1)
+            if ``config.use_eos_token`` and (batch_size, time_length)
+            otherwise, containing token IDs for the input series.
+        attention_mask
+            A boolean tensor, same shape as ``token_ids``, indicating
+            which input observations are not ``torch.nan`` (i.e. not
+            missing nor padding).
+        decoding_context
+            An object that will be passed to ``output_transform``.
+            Contains the relevant context to decode output samples into
+            real values, such as location and scale parameters.
+        """
+        raise NotImplementedError()
+
+    def output_transform(self, samples: torch.Tensor, decoding_context: Any) -> torch.Tensor:
+        """
+        Turn a batch of sample token IDs into real values.
+
+        Parameters
+        ----------
+        samples
+            A tensor of integers, shaped (batch_size, num_samples, time_length),
+            containing token IDs of sample trajectories.
+        decoding_context
+            An object returned by ``input_transform`` containing
+            relevant context to decode samples, such as location and scale.
+            The nature of this depends on the specific tokenizer.
+
+        Returns
+        -------
+        forecasts
+            A real tensor, shaped (batch_size, num_samples, time_length),
+            containing forecasted sample paths.
+        """
+        raise NotImplementedError()
+
+
+class MeanScaleUniformBins(ChronosTokenizer):
+    def __init__(self, low_limit: float, high_limit: float, config: ChronosConfig) -> None:
+        self.config = config
+        self.centers = torch.linspace(
+            low_limit,
+            high_limit,
+            config.n_tokens - config.n_special_tokens - 1,
+        )
+        self.boundaries = torch.concat(
+            (
+                torch.tensor([-1e20], device=self.centers.device),
+                (self.centers[1:] + self.centers[:-1]) / 2,
+                torch.tensor([1e20], device=self.centers.device),
+            )
+        )
+
+    def input_transform(self, context: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+        batch_size, length = context.shape
+
+        if length > self.config.context_length:
+            context = context[..., -self.config.context_length :]
+        elif length < self.config.context_length:
+            padding_size = (
+                *context.shape[:-1],
+                self.config.context_length - length,
+            )
+            padding = torch.full(size=padding_size, fill_value=torch.nan)
+            context = torch.concat((padding, context), dim=-1)
+
+        attention_mask = ~torch.isnan(context)
+        scale = torch.nansum(torch.abs(context) * attention_mask, dim=-1) / torch.nansum(attention_mask, dim=-1)
+        scale[~(scale > 0)] = 1.0
+        scaled_context = context / scale.unsqueeze(dim=-1)
+        token_ids = (
+            torch.bucketize(
+                input=scaled_context,
+                boundaries=self.boundaries,
+                # buckets are open to the right, see:
+                # https://pytorch.org/docs/2.1/generated/torch.bucketize.html#torch-bucketize
+                right=True,
+            )
+            + self.config.n_special_tokens
+        )
+        token_ids[~attention_mask] = self.config.pad_token_id
+
+        if self.config.use_eos_token:
+            eos_tokens = torch.full((batch_size, 1), fill_value=self.config.eos_token_id)
+            token_ids = torch.concat((token_ids, eos_tokens), dim=1)
+            eos_mask = torch.full((batch_size, 1), fill_value=True)
+            attention_mask = torch.concat((attention_mask, eos_mask), dim=1)
+
+        return token_ids, attention_mask, scale
+
+    def output_transform(self, samples: torch.Tensor, scale: torch.Tensor) -> torch.Tensor:
+        scale_unsqueezed = scale.unsqueeze(-1).unsqueeze(-1)
+        indices = torch.clamp(
+            samples - self.config.n_special_tokens,
+            min=0,
+            max=len(self.centers) - 1,
+        )
+        return self.centers[indices] * scale_unsqueezed
+
+
+class ChronosPretrainedModel(nn.Module):
+    """
+    A ``ChronosPretrainedModel`` wraps a ``PreTrainedModel`` object from ``transformers``
+    and uses it to predict sample paths for time series tokens.
+
+    Parameters
+    ----------
+    config
+        The configuration to use.
+    model
+        The pre-trained model to use.
+    """
+
+    def __init__(self, config: ChronosConfig, model: PreTrainedModel) -> None:
+        super().__init__()
+        self.config = config
+        self.model = model
+        self.device = model.device
+
+    def forward(
+        self,
+        input_ids: torch.Tensor,
+        attention_mask: torch.Tensor,
+        prediction_length: Optional[int] = None,
+        num_samples: Optional[int] = None,
+        temperature: Optional[float] = None,
+        top_k: Optional[int] = None,
+        top_p: Optional[float] = None,
+    ) -> torch.Tensor:
+        """
+        Predict future sample tokens for the given token sequences.
+
+        Arguments ``prediction_length``, ``num_samples``, ``temperature``,
+        ``top_k``, ``top_p`` can be used to customize the model inference,
+        and default to the corresponding attributes in ``self.config`` if
+        not provided.
+
+        Returns
+        -------
+        samples
+            A tensor of integers, shaped (batch_size, num_samples, time_length),
+            containing forecasted sample paths.
+        """
+        if prediction_length is None:
+            prediction_length = self.config.prediction_length
+        if num_samples is None:
+            num_samples = self.config.num_samples
+        if temperature is None:
+            temperature = self.config.temperature
+        if top_k is None:
+            top_k = self.config.top_k
+        if top_p is None:
+            top_p = self.config.top_p
+
+        preds = self.model.generate(
+            input_ids=input_ids,
+            attention_mask=attention_mask.long(),  # int64 (long) type conversion needed for ONNX
+            generation_config=GenerationConfig(
+                min_new_tokens=prediction_length,
+                max_new_tokens=prediction_length,
+                do_sample=True,
+                num_return_sequences=num_samples,
+                eos_token_id=self.config.eos_token_id,
+                pad_token_id=self.config.pad_token_id,
+                temperature=temperature,
+                top_k=top_k,
+                top_p=top_p,
+            ),
+        )
+
+        if self.config.model_type == "seq2seq":
+            preds = preds[..., 1:]  # remove the decoder start token
+        else:
+            assert self.config.model_type == "causal"
+            assert preds.size(-1) == input_ids.size(-1) + prediction_length
+            preds = preds[..., -prediction_length:]
+
+        return preds.reshape(input_ids.size(0), num_samples, -1)
+
+
+def left_pad_and_stack_1D(tensors: List[torch.Tensor]):
+    max_len = max(len(c) for c in tensors)
+    padded = []
+    for c in tensors:
+        assert isinstance(c, torch.Tensor)
+        assert c.ndim == 1
+        padding = torch.full(size=(max_len - len(c),), fill_value=torch.nan, device=c.device)
+        padded.append(torch.concat((padding, c), dim=-1))
+    return torch.stack(padded)
+
+
+class ChronosPipeline:
+    """
+    A ``ChronosPipeline`` uses the given tokenizer and model to forecast
+    input time series.
+
+    Use the ``from_pretrained`` class method to load serialized models.
+    Use the ``predict`` method to get forecasts.
+
+    Parameters
+    ----------
+    tokenizer
+        The tokenizer object to use.
+    model
+        The model to use.
+    """
+
+    tokenizer: ChronosTokenizer
+    model: ChronosPretrainedModel
+
+    def __init__(self, tokenizer, model):
+        self.tokenizer = tokenizer
+        self.model = model
+
+    def predict(
+        self,
+        context: Union[torch.Tensor, List[torch.Tensor]],
+        prediction_length: Optional[int] = None,
+        num_samples: Optional[int] = None,
+        temperature: Optional[float] = None,
+        top_k: Optional[int] = None,
+        top_p: Optional[float] = None,
+        limit_prediction_length: bool = True,
+    ) -> torch.Tensor:
+        """
+        Get forecasts for the given time series.
+
+        Parameters
+        ----------
+        context
+            Input series. This is either a 1D tensor, or a list
+            of 1D tensors, or a 2D tensor whose first dimension
+            is batch. In the latter case, use left-padding with
+            ``torch.nan`` to align series of different lengths.
+        prediction_length
+            Time steps to predict. Defaults to what specified
+            in ``self.model.config``.
+        num_samples
+            Number of sample paths to predict. Defaults to what
+            specified in ``self.model.config``.
+        temperature
+            Temperature to use for generating sample tokens.
+            Defaults to what specified in ``self.model.config``.
+        top_k
+            Top-k parameter to use for generating sample tokens.
+            Defaults to what specified in ``self.model.config``.
+        top_p
+            Top-p parameter to use for generating sample tokens.
+            Defaults to what specified in ``self.model.config``.
+        limit_prediction_length
+            Force prediction length smaller or equal than the
+            built-in prediction length from the model. True by
+            default. When true, fail loudly if longer predictions
+            are requested, otherwise longer predictions are allowed.
+
+        Returns
+        -------
+        samples
+            Tensor of sample forecasts, of shape
+            (batch_size, num_samples, prediction_length).
+        """
+        if isinstance(context, list):
+            context = left_pad_and_stack_1D(context)
+        assert isinstance(context, torch.Tensor)
+        if context.ndim == 1:
+            context = context.unsqueeze(0)
+        assert context.ndim == 2
+
+        if prediction_length is None:
+            prediction_length = self.model.config.prediction_length
+
+        if prediction_length > self.model.config.prediction_length:
+            msg = (
+                f"We recommend keeping prediction length <= {self.model.config.prediction_length}. "
+                f"The quality of longer predictions may degrade since the model is not optimized for it. "
+            )
+            if limit_prediction_length:
+                msg += "You can turn off this check by setting `limit_prediction_length=False`."
+                raise ValueError(msg)
+            warnings.warn(msg, stacklevel=2)
+
+        predictions = []
+        remaining = prediction_length
+
+        while remaining > 0:
+            token_ids, attention_mask, scale = self.tokenizer.input_transform(context)
+            samples = self.model(
+                token_ids.to(self.model.device),
+                attention_mask.to(self.model.device),
+                min(remaining, self.model.config.prediction_length),
+                num_samples,
+                temperature,
+                top_k,
+                top_p,
+            )
+            prediction = self.tokenizer.output_transform(samples.to(scale.device), scale)
+
+            predictions.append(prediction)
+            remaining -= prediction.shape[-1]
+
+            if remaining <= 0:
+                break
+
+            context = torch.cat([context, prediction.median(dim=1).values], dim=-1)
+
+        return torch.cat(predictions, dim=-1)
+
+    @classmethod
+    def from_pretrained(cls, *args, **kwargs):
+        """
+        Load the model, either from a local path or from the HuggingFace Hub.
+        Supports the same arguments as ``AutoConfig`` and ``AutoModel``
+        from ``transformers``.
+        """
+
+        config = AutoConfig.from_pretrained(*args, **kwargs)
+
+        assert hasattr(config, "chronos_config"), "Not a Chronos config file"
+
+        chronos_config = ChronosConfig(**config.chronos_config)
+
+        if chronos_config.model_type == "seq2seq":
+            inner_model = AutoModelForSeq2SeqLM.from_pretrained(*args, **kwargs)
+        else:
+            assert config.model_type == "causal"
+            inner_model = AutoModelForCausalLM.from_pretrained(*args, **kwargs)
+
+        return cls(
+            tokenizer=chronos_config.create_tokenizer(),
+            model=ChronosPretrainedModel(config=chronos_config, model=inner_model),
+        )
+
+
+class OptimizedChronosPipeline(ChronosPipeline):
+    """A wrapper around the ChronosPipeline object for CPU-optimized model classes from
+    HuggingFace optimum.
+    """
+
+    dtypes = {
+        "bfloat16": torch.bfloat16,
+        "float32": torch.float32,
+        "float64": torch.float64,
+    }
+
+    @classmethod
+    def from_pretrained(cls, *args, **kwargs):
+        """
+        Load the model, either from a local path or from the HuggingFace Hub.
+        Supports the same arguments as ``AutoConfig`` and ``AutoModel``
+        from ``transformers``.
+        """
+        kwargs = kwargs.copy()
+
+        optimization_strategy = kwargs.pop("optimization_strategy", None)
+        context_length = kwargs.pop("context_length", None)
+
+        config = AutoConfig.from_pretrained(*args, **kwargs)
+        assert hasattr(config, "chronos_config"), "Not a Chronos config file"
+
+        if context_length is not None:
+            config.chronos_config["context_length"] = context_length
+        chronos_config = ChronosConfig(**config.chronos_config)
+
+        torch_dtype = kwargs.get("torch_dtype", "auto")
+        if torch_dtype != "auto" and isinstance(torch_dtype, str):
+            kwargs["torch_dtype"] = cls.dtypes[torch_dtype]
+
+        if 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`"
+                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"
+                        )
+
+                    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"
+                        )
+                    with set_loggers_level(regex=r"^optimum.*", level=logging.ERROR):
+                        inner_model = OVModelForSeq2SeqLM.from_pretrained(
+                            *args, **{**kwargs, "device_map": "cpu", "export": True}
+                        )
+        else:
+            assert config.model_type == "causal"
+            inner_model = AutoModelForCausalLM.from_pretrained(*args, **kwargs)
+
+        return cls(
+            tokenizer=chronos_config.create_tokenizer(),
+            model=ChronosPretrainedModel(config=chronos_config, model=inner_model),
+        )

autogluon/timeseries/models/chronos/model.py

@@ -0,0 +1,319 @@
+import logging
+import os
+from typing import Any, Dict, Literal, Optional, Union
+
+import numpy as np
+import pandas as pd
+
+from autogluon.common.loaders import load_pkl
+from autogluon.timeseries.dataset.ts_dataframe import TimeSeriesDataFrame
+from autogluon.timeseries.models.abstract import AbstractTimeSeriesModel
+from autogluon.timeseries.utils.forecast import get_forecast_horizon_index_ts_dataframe
+from autogluon.timeseries.utils.warning_filters import warning_filter
+
+logger = logging.getLogger(__name__)
+
+
+# allowed HuggingFace model paths with custom parameter definitions
+MODEL_CONFIGS = {
+    "amazon/chronos-t5-tiny": {
+        "num_gpus": 0,  # minimum number of required GPUs
+    },
+    "amazon/chronos-t5-mini": {"num_gpus": 0},
+    "amazon/chronos-t5-small": {"num_gpus": 1},
+    "amazon/chronos-t5-base": {"num_gpus": 1},
+    "amazon/chronos-t5-large": {"num_gpus": 1},
+}
+
+
+MODEL_ALIASES = {
+    "tiny": "amazon/chronos-t5-tiny",
+    "mini": "amazon/chronos-t5-mini",
+    "small": "amazon/chronos-t5-small",
+    "base": "amazon/chronos-t5-base",
+    "large": "amazon/chronos-t5-large",
+}
+
+
+class ChronosInferenceDataset:
+    """A container for time series datasets that implements the ``torch.utils.data.Dataset`` interface"""
+
+    def __init__(
+        self,
+        target_df: TimeSeriesDataFrame,
+        context_length: int,
+        target_column: str = "target",
+    ):
+        assert context_length > 0
+        self.context_length = context_length
+        self.target_array = target_df[target_column].to_numpy(dtype=np.float32)
+        self.freq = target_df.freq
+
+        # store pointer to start:end of each time series
+        cum_sizes = target_df.num_timesteps_per_item().values.cumsum()
+        self.indptr = np.append(0, cum_sizes).astype(np.int32)
+
+    def __len__(self):
+        return len(self.indptr) - 1  # noqa
+
+    def _get_context(self, a: np.ndarray, pad_value=np.nan):
+        a = a[-self.context_length :]
+        pad_size = self.context_length - len(a)
+        if pad_size > 0:
+            pad = np.full(shape=(pad_size,), fill_value=pad_value)
+            a = np.concatenate((pad, a))
+        return a
+
+    def __getitem__(self, idx) -> np.ndarray:
+        start_idx = self.indptr[idx]
+        end_idx = self.indptr[idx + 1]
+
+        return self._get_context(self.target_array[start_idx:end_idx])
+
+
+class ChronosModel(AbstractTimeSeriesModel):
+    """Chronos pretrained time series forecasting models, based on the original
+    `ChronosModel <https://github.com/amazon-science/chronos-forecasting>`_ implementation.
+
+    Chronos is family of pretrained models, based on the T5 family, with number of parameters ranging between 8M and 710M.
+    The full collection of Chronos models is available on
+    `Hugging Face <https://huggingface.co/collections/amazon/chronos-models-65f1791d630a8d57cb718444>`_. For Chronos small,
+    base, and large variants a GPU is required to perform inference efficiently.
+
+    Chronos takes a minimalistic approach to pretraining time series models, by discretizing time series data directly into bins
+    which are treated as tokens, effectively performing regression by classification. This results in a simple and flexible framework
+    for using any language model in the context of time series forecasting. See [Ansari2024]_ for more information.
+
+    References
+    ----------
+    .. [Ansari2024] Ansari, Abdul Fatir, Stella, Lorenzo et al.
+        "Chronos: Learning the Language of Time Series."
+        http://arxiv.org/abs/2403.07815
+
+
+    Other Parameters
+    ----------------
+    model_path: str, default = "amazon/chronos-t5-small"
+        Model path used for the model, i.e., a HuggingFace transformers ``name_or_path``. Can be a
+        compatible model name on HuggingFace Hub or a local path to a model directory. Original
+        Chronos models (i.e., ``amazon/chronos-t5-{model_size}``) can be specified with aliases
+        ``tiny``, ``mini`` , ``small``, ``base``, and ``large``.
+    batch_size : int, default = 16
+        Size of batches used during inference
+    num_samples : int, default = 20
+        Number of samples used during inference
+    device : str, default = None
+        Device to use for inference. If None, model will use the GPU if available. For larger model sizes
+        `small`, `base`, and `large`; inference will fail if no GPU is available.
+    context_length : int or None, default = None
+        The context length to use in the model. Shorter context lengths will decrease model accuracy, but result
+        in faster inference. If None, the model will infer context length from the data set length at inference
+        time, but set it to a maximum of 512.
+    optimization_strategy : {None, "onnx", "openvino"}, default = None
+        Optimization strategy to use for inference on CPUs. If None, the model will use the default implementation.
+        If `onnx`, the model will be converted to ONNX and the inference will be performed using ONNX. If ``openvino``,
+        inference will be performed with the model compiled to OpenVINO.
+    torch_dtype : torch.dtype or {"auto", "bfloat16", "float32", "float64"}, default = "auto"
+        Torch data type for model weights, provided to ``from_pretrained`` method of Hugging Face AutoModels. If
+        original Chronos models are specified and the model size is ``small``, ``base``, or ``large``, the
+        ``torch_dtype`` will be set to ``bfloat16`` to enable inference on GPUs.
+    data_loader_num_workers : int, default = 0
+        Number of worker processes to be used in the data loader. See documentation on ``torch.utils.data.DataLoader``
+        for more information.
+    """
+
+    # default number of samples for prediction
+    default_num_samples: int = 20
+    default_batch_size: int = 16
+    default_model_path = "amazon/chronos-t5-small"
+    maximum_context_length = 512
+
+    def __init__(
+        self,
+        freq: Optional[str] = None,
+        prediction_length: int = 1,
+        path: Optional[str] = None,
+        name: Optional[str] = None,
+        eval_metric: str = None,
+        hyperparameters: Dict[str, Any] = None,
+        **kwargs,  # noqa
+    ):
+        hyperparameters = hyperparameters if hyperparameters is not None else {}
+
+        model_path_input = hyperparameters.get("model_path", self.default_model_path)
+        self.model_path = MODEL_ALIASES.get(model_path_input, model_path_input)
+
+        # TODO: automatically determine batch size based on GPU / memory availability
+        self.batch_size = hyperparameters.get("batch_size", self.default_batch_size)
+        self.num_samples = hyperparameters.get("num_samples", self.default_num_samples)
+        self.device = hyperparameters.get("device")
+
+        # if the model requires a GPU, set the torch dtype to bfloat16
+        self.torch_dtype = hyperparameters.get("torch_dtype", "auto" if self.min_num_gpus == 0 else "bfloat16")
+
+        self.data_loader_num_workers = hyperparameters.get("data_loader_num_workers", 0)
+        self.optimization_strategy: Optional[Literal["onnx", "openvino"]] = hyperparameters.get(
+            "optimization_strategy", None
+        )
+        self.context_length = hyperparameters.get("context_length")
+
+        if self.context_length is not None and self.context_length > self.maximum_context_length:
+            logger.warning(
+                f"\tContext length {self.context_length} exceeds maximum context length {self.maximum_context_length}."
+                f"Context length will be set to {self.maximum_context_length}."
+            )
+            self.context_length = self.maximum_context_length
+
+        model_path_safe = str.replace(model_path_input, "/", "__")
+        name = (name if name is not None else "Chronos") + f"[{model_path_safe}]"
+
+        super().__init__(
+            path=path,
+            freq=freq,
+            prediction_length=prediction_length,
+            name=name,
+            eval_metric=eval_metric,
+            hyperparameters=hyperparameters,
+            **kwargs,
+        )
+
+        self.model_pipeline: Optional[Any] = None  # of type OptimizedChronosPipeline
+
+    def save(self, path: str = None, verbose: bool = True) -> str:
+        pipeline = self.model_pipeline
+        self.model_pipeline = None
+        path = super().save(path=path, verbose=verbose)
+        self.model_pipeline = pipeline
+
+        return str(path)
+
+    @classmethod
+    def load(cls, path: str, reset_paths: bool = True, verbose: bool = True) -> "ChronosModel":
+        model = load_pkl.load(path=os.path.join(path, cls.model_file_name), verbose=verbose)
+        if reset_paths:
+            model.set_contexts(path)
+        return model
+
+    def _is_gpu_available(self) -> bool:
+        import torch.cuda
+
+        return torch.cuda.is_available()
+
+    @property
+    def min_num_gpus(self):
+        return MODEL_CONFIGS.get(self.model_path, {}).get("num_gpus", 0)
+
+    def get_minimum_resources(self, is_gpu_available: bool = False) -> Dict[str, Union[int, float]]:
+        minimum_resources = {"num_cpus": 1}
+        # if GPU is available, we train with 1 GPU per trial
+        if is_gpu_available:
+            minimum_resources["num_gpus"] = self.min_num_gpus
+        return minimum_resources
+
+    def load_model_pipeline(self, context_length: Optional[int] = None):
+        from .chronos import OptimizedChronosPipeline
+
+        gpu_available = self._is_gpu_available()
+
+        if not gpu_available and self.min_num_gpus > 0:
+            raise RuntimeError(
+                f"{self.name} requires a GPU to run, but no GPU was detected. "
+                "Please make sure that you are using a computer with a CUDA-compatible GPU and "
+                "`import torch; torch.cuda.is_available()` returns `True`."
+            )
+
+        device = self.device or ("cuda" if gpu_available else "auto")
+
+        pipeline = OptimizedChronosPipeline.from_pretrained(
+            self.model_path,
+            device_map=device,
+            optimization_strategy=self.optimization_strategy,
+            torch_dtype=self.torch_dtype,
+            context_length=context_length or self.context_length,
+        )
+
+        self.model_pipeline = pipeline
+
+    def _fit(
+        self,
+        train_data: TimeSeriesDataFrame,
+        val_data: Optional[TimeSeriesDataFrame] = None,
+        time_limit: int = None,
+        **kwargs,
+    ) -> None:
+        self._check_fit_params()
+
+    def _get_inference_data_loader(
+        self,
+        data: TimeSeriesDataFrame,
+        context_length: int,
+        num_workers: int = 0,
+    ):
+        import torch
+
+        chronos_dataset = ChronosInferenceDataset(
+            target_df=data,
+            target_column=self.target,
+            context_length=context_length,
+        )
+
+        return torch.utils.data.DataLoader(
+            chronos_dataset,
+            batch_size=self.batch_size,
+            shuffle=False,
+            num_workers=num_workers,
+        )
+
+    def _predict(
+        self,
+        data: TimeSeriesDataFrame,
+        known_covariates: Optional[TimeSeriesDataFrame] = None,
+        **kwargs,
+    ) -> TimeSeriesDataFrame:
+        # We defer initialization of the model pipeline. i.e., the model is only loaded to device memory
+        # during inference. We also infer the maximum length of the time series in the inference data set
+        # and use that to determine the context length of the model. If the context length is specified
+        # during initialization, this is always used. If not, the context length is set to the longest
+        # item length. The context length is always capped by self.maximum_context_length.
+        context_length = self.context_length or min(
+            data.num_timesteps_per_item().max(),
+            self.maximum_context_length,
+        )
+
+        with warning_filter(all_warnings=True):
+            import torch
+
+            # load model pipeline to device memory
+            self.load_model_pipeline(context_length=context_length)
+
+            self.model_pipeline.model.eval()
+            with torch.inference_mode():
+                prediction_samples = [
+                    self.model_pipeline.predict(
+                        batch,
+                        prediction_length=self.prediction_length,
+                        num_samples=self.num_samples,
+                        limit_prediction_length=False,
+                    )
+                    .detach()
+                    .cpu()
+                    .numpy()
+                    for batch in self._get_inference_data_loader(
+                        data=data,
+                        num_workers=self.data_loader_num_workers,
+                        context_length=context_length,
+                    )
+                ]
+
+        samples = np.concatenate(prediction_samples, axis=0).swapaxes(1, 2).reshape(-1, self.num_samples)
+
+        mean = samples.mean(axis=-1, keepdims=True)
+        quantiles = np.quantile(samples, self.quantile_levels, axis=-1).T
+
+        df = pd.DataFrame(
+            np.concatenate([mean, quantiles], axis=1),
+            columns=["mean"] + [str(q) for q in self.quantile_levels],
+            index=get_forecast_horizon_index_ts_dataframe(data, self.prediction_length),
+        )
+
+        return TimeSeriesDataFrame(df)

autogluon/timeseries/models/presets.py

@@ -14,6 +14,7 @@ from . import (
     AutoCESModel,
     AutoETSModel,
     AverageModel,
+    ChronosModel,
     CrostonSBAModel,
     DeepARModel,
     DirectTabularModel,
@@ -68,6 +69,7 @@ MODEL_TYPES = dict(
     ADIDA=ADIDAModel,
     CrostonSBA=CrostonSBAModel,
     IMAPA=IMAPAModel,
+    Chronos=ChronosModel,
 )
 
 DEFAULT_MODEL_NAMES = {v: k for k, v in MODEL_TYPES.items()}
@@ -85,6 +87,7 @@ DEFAULT_MODEL_PRIORITY = dict(
     AutoETS=80,
     AutoARIMA=70,
     RecursiveTabular=60,
+    Chronos=50,
     DirectTabular=50,
     DeepAR=40,
     TemporalFusionTransformer=30,

autogluon/timeseries/predictor.py

@@ -425,6 +425,7 @@ class TimeSeriesPredictor(TimeSeriesPredictorDeprecatedMixin):
         refit_every_n_windows: int = 1,
         refit_full: bool = False,
         enable_ensemble: bool = True,
+        skip_model_selection: bool = False,
         random_seed: Optional[int] = 123,
         verbosity: Optional[int] = None,
     ) -> "TimeSeriesPredictor":
@@ -496,11 +497,23 @@ class TimeSeriesPredictor(TimeSeriesPredictorDeprecatedMixin):
 
             Available presets:
 
-            - ``"fast_training"``: fit simple statistical models (``ETS``, ``Theta``, ``Naive``, ``SeasonalNaive``) + fast tree-based models ``RecursiveTabular`` and ``DirectTabular``. These models are fast to train but may not be very accurate.
-            - ``"medium_quality"``: all models mentioned above + deep learning model ``TemporalFusionTransformer``. Default setting that produces good forecasts with reasonable training time.
-            - ``"high_quality"``: All ML models available in AutoGluon + additional statistical models (``NPTS``, ``AutoETS``, ``AutoARIMA``, ``CrostonSBA``, ``DynamicOptimizedTheta``). Much more accurate than ``medium_quality``, but takes longer to train.
+            - ``"fast_training"``: fit simple statistical models (``ETS``, ``Theta``, ``Naive``, ``SeasonalNaive``) + fast tree-based models ``RecursiveTabular``
+              and ``DirectTabular``. These models are fast to train but may not be very accurate.
+            - ``"medium_quality"``: all models mentioned above + deep learning model ``TemporalFusionTransformer``. Default setting that produces good forecasts
+              with reasonable training time.
+            - ``"high_quality"``: All ML models available in AutoGluon + additional statistical models (``NPTS``, ``AutoETS``, ``AutoARIMA``, ``CrostonSBA``,
+              ``DynamicOptimizedTheta``). Much more accurate than ``medium_quality``, but takes longer to train.
             - ``"best_quality"``: Same models as in ``"high_quality"`, but performs validation with multiple backtests. Usually better than ``high_quality``, but takes even longer to train.
 
+            Available presets with the `Chronos <https://github.com/amazon-science/chronos-forecasting>`_ model:
+
+            - ``"chronos_{model_size}"``: where model size is one of ``tiny,mini,small,base,large``. Uses the Chronos pretrained model for zero-shot forecasting.
+              See the documentation for ``ChronosModel`` or see `Hugging Face <https://huggingface.co/collections/amazon/chronos-models-65f1791d630a8d57cb718444>`_ for more information.
+              Note that a GPU is required for model sizes ``small``, ``base`` and ``large``.
+            - ``"chronos"``: alias for ``"chronos_small"``.
+            - ``"chronos_ensemble"``: builds an ensemble of the models specified in ``"high_quality"`` and ``"chronos_small"``.
+            - ``"chronos_large_ensemble"``: builds an ensemble of the models specified in ``"high_quality"`` and ``"chronos_large"``.
+
             Details for these presets can be found in ``autogluon/timeseries/configs/presets_configs.py``. If not
             provided, user-provided values for ``hyperparameters`` and ``hyperparameter_tune_kwargs`` will be used
             (defaulting to their default values specified below).
@@ -630,6 +643,10 @@ class TimeSeriesPredictor(TimeSeriesPredictorDeprecatedMixin):
         enable_ensemble : bool, default = True
             If True, the ``TimeSeriesPredictor`` will fit a simple weighted ensemble on top of the models specified via
             ``hyperparameters``.
+        skip_model_selection : bool, default = False
+            If True, predictor will not compute the validation score. For example, this argument is useful if we want
+            to use the predictor as a wrapper for a single pre-trained model. If set to True, then the ``hyperparameters``
+            dict must contain exactly one model without hyperparameter search spaces or an exception will be raised.
         random_seed : int or None, default = 123
             If provided, fixes the seed of the random number generator for all models. This guarantees reproducible
             results for most models (except those trained on GPU because of the non-determinism of GPU operations).
@@ -669,6 +686,7 @@ class TimeSeriesPredictor(TimeSeriesPredictorDeprecatedMixin):
             val_step_size=val_step_size,
             refit_every_n_windows=refit_every_n_windows,
             refit_full=refit_full,
+            skip_model_selection=skip_model_selection,
             enable_ensemble=enable_ensemble,
             random_seed=random_seed,
             verbosity=verbosity,
@@ -703,9 +721,10 @@ class TimeSeriesPredictor(TimeSeriesPredictorDeprecatedMixin):
         if num_val_windows == 0 and tuning_data is None:
             raise ValueError("Please set num_val_windows >= 1 or provide custom tuning_data")
 
-        train_data = self._filter_short_series(
-            train_data, num_val_windows=num_val_windows, val_step_size=val_step_size
-        )
+        if not skip_model_selection:
+            train_data = self._filter_short_series(
+                train_data, num_val_windows=num_val_windows, val_step_size=val_step_size
+            )
 
         val_splitter = ExpandingWindowSplitter(
             prediction_length=self.prediction_length, num_val_windows=num_val_windows, val_step_size=val_step_size
@@ -722,6 +741,7 @@ class TimeSeriesPredictor(TimeSeriesPredictorDeprecatedMixin):
             verbosity=verbosity,
             val_splitter=val_splitter,
             refit_every_n_windows=refit_every_n_windows,
+            skip_model_selection=skip_model_selection,
             enable_ensemble=enable_ensemble,
             random_seed=random_seed,
         )

autogluon/timeseries/trainer/abstract_trainer.py

@@ -76,6 +76,8 @@ class SimpleAbstractTrainer:
         models = self.get_model_names()
         if not models:
             raise ValueError("Trainer has no fit models that can predict.")
+        if len(models) == 1:
+            return models[0]
         model_performances = self.get_models_attribute_dict(attribute="val_score")
         performances_list = [(m, model_performances[m]) for m in models if model_performances[m] is not None]
 
@@ -256,6 +258,7 @@ class AbstractTimeSeriesTrainer(SimpleAbstractTrainer):
         eval_metric: Union[str, TimeSeriesScorer, None] = None,
         eval_metric_seasonal_period: Optional[int] = None,
         save_data: bool = True,
+        skip_model_selection: bool = False,
         enable_ensemble: bool = True,
         verbosity: int = 2,
         val_splitter: Optional[AbstractWindowSplitter] = None,
@@ -270,7 +273,9 @@ class AbstractTimeSeriesTrainer(SimpleAbstractTrainer):
         self.target = kwargs.get("target", "target")
         self.metadata = kwargs.get("metadata", CovariateMetadata())
         self.is_data_saved = False
-        self.enable_ensemble = enable_ensemble
+        self.skip_model_selection = skip_model_selection
+        # Ensemble cannot be fit if val_scores are not computed
+        self.enable_ensemble = enable_ensemble and not skip_model_selection
         self.ensemble_model_type = TimeSeriesGreedyEnsemble
 
         self.verbosity = verbosity
@@ -487,7 +492,7 @@ class AbstractTimeSeriesTrainer(SimpleAbstractTrainer):
             fit_end_time = time.time()
             model.fit_time = model.fit_time or (fit_end_time - fit_start_time)
 
-            if val_data is not None:
+            if val_data is not None and not self.skip_model_selection:
                 model.score_and_cache_oof(val_data, store_val_score=True, store_predict_time=True)
 
             self._log_scores_and_times(model.val_score, model.fit_time, model.predict_time)
@@ -557,6 +562,17 @@ class AbstractTimeSeriesTrainer(SimpleAbstractTrainer):
 
         logger.info(f"Models that will be trained: {list(m.name for m in models)}")
 
+        if self.skip_model_selection:
+            if len(models) > 1:
+                raise ValueError(
+                    "When `skip_model_selection=True`, only a single model must be provided via `hyperparameters` "
+                    f"but {len(models)} models were given"
+                )
+            if contains_searchspace(models[0].get_user_params()):
+                raise ValueError(
+                    "When `skip_model_selection=True`, model configuration should contain no search spaces."
+                )
+
         num_base_models = len(models)
         model_names_trained = []
         for i, model in enumerate(models):
@@ -646,7 +662,8 @@ class AbstractTimeSeriesTrainer(SimpleAbstractTrainer):
         try:
             best_model = self.get_model_best()
             logger.info(f"Best model: {best_model}")
-            logger.info(f"Best model score: {self.get_model_attribute(best_model, 'val_score'):.4f}")
+            if not self.skip_model_selection:
+                logger.info(f"Best model score: {self.get_model_attribute(best_model, 'val_score'):.4f}")
         except ValueError as e:
             logger.error(str(e))
 

autogluon/timeseries/trainer/auto_trainer.py

@@ -27,7 +27,8 @@ class AutoTimeSeriesTrainer(AbstractTimeSeriesTrainer):
             target=self.target,
             metadata=self.metadata,
             excluded_model_types=kwargs.get("excluded_model_types"),
-            multi_window=multi_window,
+            # if skip_model_selection = True, we skip backtesting
+            multi_window=multi_window and not self.skip_model_selection,
         )
 
     def fit(

autogluon/timeseries/utils/warning_filters.py

@@ -3,6 +3,7 @@ import functools
 import io
 import logging
 import os
+import re
 import sys
 import warnings
 
@@ -12,10 +13,13 @@ __all__ = ["warning_filter", "disable_root_logger", "disable_tqdm"]
 
 
 @contextlib.contextmanager
-def warning_filter():
+def warning_filter(all_warnings: bool = False):
+    categories = [RuntimeWarning, UserWarning, ConvergenceWarning, ValueWarning, FutureWarning]
+    if all_warnings:
+        categories.append(Warning)
     with warnings.catch_warnings():
         env_py_warnings = os.environ.get("PYTHONWARNINGS", "")
-        for warning_category in [RuntimeWarning, UserWarning, ConvergenceWarning, ValueWarning, FutureWarning]:
+        for warning_category in categories:
             warnings.simplefilter("ignore", category=warning_category)
         try:
             os.environ["PYTHONWARNINGS"] = "ignore"
@@ -25,14 +29,28 @@ def warning_filter():
 
 
 @contextlib.contextmanager
-def disable_root_logger():
+def disable_root_logger(root_log_level=logging.ERROR):
     try:
-        logging.getLogger().setLevel(logging.ERROR)
+        logging.getLogger().setLevel(root_log_level)
         yield
     finally:
         logging.getLogger().setLevel(logging.INFO)
 
 
+@contextlib.contextmanager
+def set_loggers_level(regex: str, level=logging.ERROR):
+    log_levels = {}
+    try:
+        for logger_name in logging.root.manager.loggerDict:
+            if re.match(regex, logger_name):
+                log_levels[logger_name] = logging.getLogger(logger_name).level
+                logging.getLogger(logger_name).setLevel(level)
+        yield
+    finally:
+        for logger_name, level in log_levels.items():
+            logging.getLogger(logger_name).setLevel(level)
+
+
 @contextlib.contextmanager
 def disable_tqdm():
     """monkey-patch tqdm to disable it within context"""

autogluon/timeseries/version.py

@@ -1,3 +1,3 @@
 """This is the autogluon version file."""
-__version__ = '1.0.1b20240324'
+__version__ = '1.0.1b20240326'
 __lite__ = False

{autogluon.timeseries-1.0.1b20240324.dist-info → autogluon.timeseries-1.0.1b20240326.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: autogluon.timeseries
-Version: 1.0.1b20240324
+Version: 1.0.1b20240326
 Summary: AutoML for Image, Text, and Tabular Data
 Home-page: https://github.com/autogluon/autogluon
 Author: AutoGluon Community
@@ -52,13 +52,16 @@ Requires-Dist: utilsforecast <0.0.11,>=0.0.10
 Requires-Dist: tqdm <5,>=4.38
 Requires-Dist: orjson ~=3.9
 Requires-Dist: tensorboard <3,>=2.9
-Requires-Dist: autogluon.core[raytune] ==1.0.1b20240324
-Requires-Dist: autogluon.common ==1.0.1b20240324
-Requires-Dist: autogluon.tabular[catboost,lightgbm,xgboost] ==1.0.1b20240324
+Requires-Dist: autogluon.core[raytune] ==1.0.1b20240326
+Requires-Dist: autogluon.common ==1.0.1b20240326
+Requires-Dist: autogluon.tabular[catboost,lightgbm,xgboost] ==1.0.1b20240326
 Provides-Extra: all
-Requires-Dist: optimum[nncf,onnxruntime,openvino] <1.18,>=1.17 ; extra == 'all'
-Provides-Extra: chronos-cpu
-Requires-Dist: optimum[nncf,onnxruntime,openvino] <1.18,>=1.17 ; extra == 'chronos-cpu'
+Requires-Dist: optimum[onnxruntime] <1.18,>=1.17 ; extra == 'all'
+Requires-Dist: optimum[nncf,openvino] <1.18,>=1.17 ; extra == 'all'
+Provides-Extra: chronos-onnx
+Requires-Dist: optimum[onnxruntime] <1.18,>=1.17 ; extra == 'chronos-onnx'
+Provides-Extra: chronos-openvino
+Requires-Dist: optimum[nncf,openvino] <1.18,>=1.17 ; extra == 'chronos-openvino'
 Provides-Extra: tests
 Requires-Dist: pytest ; extra == 'tests'
 Requires-Dist: ruff >=0.0.285 ; extra == 'tests'

{autogluon.timeseries-1.0.1b20240324.dist-info → autogluon.timeseries-1.0.1b20240326.dist-info}/RECORD

@@ -1,12 +1,12 @@
-autogluon.timeseries-1.0.1b20240324-py3.8-nspkg.pth,sha256=cQGwpuGPqg1GXscIwt-7PmME1OnSpD-7ixkikJ31WAY,554
+autogluon.timeseries-1.0.1b20240326-py3.8-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=VGBFTuNebD5xF2RfimornX86DOw5dxqpPtXlrUpNSHo,9814
-autogluon/timeseries/predictor.py,sha256=1av7AUaguUJ-utilO3Oqgb7j3KubzjB7Jc-89OsbYSc,67899
+autogluon/timeseries/learner.py,sha256=aEZOChDQT0wM7G6AJKwawNj-6FcRoIWxVgYbTRSV8mk,9894
+autogluon/timeseries/predictor.py,sha256=I2zjOae49a6baqfOw6gcSjVBnRtGhrIoIcxXbV2MgM4,69433
 autogluon/timeseries/splitter.py,sha256=eghGwAAN2_cxGk5aJBILgjGWtLzjxJcytMy49gg_q18,3061
-autogluon/timeseries/version.py,sha256=9678kXw_5jvRt1GO0v1yPFBaFfSk6ljKqRkSXZtBt-c,90
+autogluon/timeseries/version.py,sha256=6RXbsa2vd0fwA6_vqw_OMhjX6eSVdI8UZpdpqrf1Ifo,90
 autogluon/timeseries/configs/__init__.py,sha256=BTtHIPCYeGjqgOcvqb8qPD4VNX-ICKOg6wnkew1cPOE,98
-autogluon/timeseries/configs/presets_configs.py,sha256=1u6tbOKJdIRULYDu41dlJwXRNswWsjBDF0aR2YhyMQs,479
+autogluon/timeseries/configs/presets_configs.py,sha256=ZVV8BsnGnnHPgjBtJBqF-H35MYUdzRBQ8FP7zA3_11g,1949
 autogluon/timeseries/dataset/__init__.py,sha256=UvnhAN5tjgxXTHoZMQDy64YMDj4Xxa68yY7NP4vAw0o,81
 autogluon/timeseries/dataset/ts_dataframe.py,sha256=HpErcKAP3-h9GCJanjsjnTQxS72mk4GXIGsEFmrTApc,45318
 autogluon/timeseries/metrics/__init__.py,sha256=KzgXNj5or7RB_uadjgC8p5gxyV26zjj2hT58OmvnfmA,1875
@@ -14,14 +14,17 @@ autogluon/timeseries/metrics/abstract.py,sha256=9xCFQ3NaR1C0hn01M7oBd72a_CiNV-w6
 autogluon/timeseries/metrics/point.py,sha256=xy8sKrBbuxZ7yTW21TDPayKnEj2FBj1AEseJxUdneqE,13399
 autogluon/timeseries/metrics/quantile.py,sha256=owMbOAJYwVyzdRkrJpuCGUXk937GU843QndCZyp5n9Y,3967
 autogluon/timeseries/metrics/utils.py,sha256=eJ63TCR-UwbeJ1c2Qm7B2q-8B3sFthPgiooEccrf2Kc,912
-autogluon/timeseries/models/__init__.py,sha256=4UJYnjeBCP6-NV738KF852Fa3qw5ygS4SBuOFAUmwoA,1217
-autogluon/timeseries/models/presets.py,sha256=xmuqxmHrnpFih0GNrkvOP-Sgs2STfLAv5cSPl6Bf4y8,11183
+autogluon/timeseries/models/__init__.py,sha256=HFjDOYKQWaGlgQWiLlOvfwE2dH0uDmeKJFC8GDL987c,1271
+autogluon/timeseries/models/presets.py,sha256=p36ROcuOnixgGsI1zBdr9VM-MH2pKCiJCS2Ofb4xT8o,11243
 autogluon/timeseries/models/abstract/__init__.py,sha256=wvDsQAZIV0N3AwBeMaGItoQ82trEfnT-nol2AAOIxBg,102
 autogluon/timeseries/models/abstract/abstract_timeseries_model.py,sha256=LSIc6rIwFs870MHpKUC24naMIcczFGY_--Ov-wyAq2w,21431
 autogluon/timeseries/models/abstract/model_trial.py,sha256=_5Nrk4CrG3u35tTd3elekfdnQI2Pn3P9AGS5CE6nuyg,3749
 autogluon/timeseries/models/autogluon_tabular/__init__.py,sha256=r9i6jWcyeLHYClkcMSKRVsfrkBUMxpDrTATNTBc_qgQ,136
 autogluon/timeseries/models/autogluon_tabular/mlforecast.py,sha256=uydOXTIy74Exy3jQ90YoCF1L4rP7A0jtUcOreAqdn5Q,29598
 autogluon/timeseries/models/autogluon_tabular/utils.py,sha256=4-gTrBtizxeMVQlsuscugPqw9unaXWXhS1TVVssfzYY,2125
+autogluon/timeseries/models/chronos/__init__.py,sha256=wT77HzTtmQxW3sw2k0mA5Ot6PSHivX-Uvn5fjM05EU4,60
+autogluon/timeseries/models/chronos/chronos.py,sha256=kCqOzOQEDRUAMeRasKWUcGJgAtDKHEbrmJ2pTQpFV5k,18350
+autogluon/timeseries/models/chronos/model.py,sha256=2LZ-8xRB0ljudzAox1TX4EVFERFN4oumeJFxfJDsu08,13224
 autogluon/timeseries/models/ensemble/__init__.py,sha256=kFr11Gmt7lQJu9Rr8HuIPphQN5l1TsoorfbJm_O3a_s,128
 autogluon/timeseries/models/ensemble/abstract_timeseries_ensemble.py,sha256=tifETwmiEGt-YtQ9eNK7ojJ3fBvtFMUJvisbfkIJ7gw,3393
 autogluon/timeseries/models/ensemble/greedy_ensemble.py,sha256=5HvZuW5osgsZg3V69k82nKEOy_YgeH1JTfQa7F3cU7s,7220
@@ -37,22 +40,22 @@ autogluon/timeseries/models/local/statsforecast.py,sha256=-FvY5aWLq-EE_oJuYXUEXX
 autogluon/timeseries/models/multi_window/__init__.py,sha256=Bq7AT2Jxdd4WNqmjTdzeqgNiwn1NCyWp4tBIWaM-zfI,60
 autogluon/timeseries/models/multi_window/multi_window_model.py,sha256=ZpuWkZfEJcM2NoVxxOkIPQt5izKCpWmU0kjpqfenHPU,10737
 autogluon/timeseries/trainer/__init__.py,sha256=lxiOT-Gc6BEnr_yWQqra85kEngeM_wtH2SCaRbmC_qE,170
-autogluon/timeseries/trainer/abstract_trainer.py,sha256=d8Qt3euZyKUGt_R-_f0sPlGZhZgLkG8tV8qsq48zZj0,49335
-autogluon/timeseries/trainer/auto_trainer.py,sha256=ftjGd27V6dsfw3t7GY1YcoyKfj9Pl_UrU77T9u-kCQ0,3244
+autogluon/timeseries/trainer/abstract_trainer.py,sha256=ACPfRn0UD10PG6Ig5gdMmdxPhrQQKZrrKKwKwKBYbKM,50196
+autogluon/timeseries/trainer/auto_trainer.py,sha256=psJFZBwWWPlLjNwAgvO4OUJXsRW1sTN2YS9a4pdoeoE,3344
 autogluon/timeseries/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 autogluon/timeseries/utils/features.py,sha256=Liq_Vn_BH43AqwjfuHGbiaEzCjRcWMQUy24taL5Upc0,10937
 autogluon/timeseries/utils/forecast.py,sha256=Thjt6yTPSe3V4s5cQ9UbW3ysTJb1lkqxtZiCqgBSt3w,1776
-autogluon/timeseries/utils/warning_filters.py,sha256=VoyTzHovxDFFbeSQXttjzmifZxKJShpKIAfCHGQGoUU,1426
+autogluon/timeseries/utils/warning_filters.py,sha256=ngjmfv21zIwTG-7VNZT-NkaSR7ssnoNtUwcXCXANZ4A,2076
 autogluon/timeseries/utils/datetime/__init__.py,sha256=bTMR8jLh1LW55vHjbOr1zvWRMF_PqbvxpS-cUcNIDWI,173
 autogluon/timeseries/utils/datetime/base.py,sha256=MsqIHY14m3QMjSwwtE7Uo1oNwepWUby_nxlWm4DlqKU,848
 autogluon/timeseries/utils/datetime/lags.py,sha256=kcU4liKbHj7KP2ajNU-KLZ8OYSU35EgT4kJjZNSw0Zg,5875
 autogluon/timeseries/utils/datetime/seasonality.py,sha256=kgK_ukw2wCviEB7CZXRVC5HZpBJZu9IsRrvCJ9E_rOE,755
 autogluon/timeseries/utils/datetime/time_features.py,sha256=pROkYyxETQ8rHKfPGhf2paB73C7rWJ2Ui0cCswLqbBg,2562
-autogluon.timeseries-1.0.1b20240324.dist-info/LICENSE,sha256=CeipvOyAZxBGUsFoaFqwkx54aPnIKEtm9a5u2uXxEws,10142
-autogluon.timeseries-1.0.1b20240324.dist-info/METADATA,sha256=E1pxnMlAlicsTP1wi1e1kNkF1UlDf77faOwkbyzMikA,12376
-autogluon.timeseries-1.0.1b20240324.dist-info/NOTICE,sha256=7nPQuj8Kp-uXsU0S5so3-2dNU5EctS5hDXvvzzehd7E,114
-autogluon.timeseries-1.0.1b20240324.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-autogluon.timeseries-1.0.1b20240324.dist-info/namespace_packages.txt,sha256=giERA4R78OkJf2ijn5slgjURlhRPzfLr7waIcGkzYAo,10
-autogluon.timeseries-1.0.1b20240324.dist-info/top_level.txt,sha256=giERA4R78OkJf2ijn5slgjURlhRPzfLr7waIcGkzYAo,10
-autogluon.timeseries-1.0.1b20240324.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-autogluon.timeseries-1.0.1b20240324.dist-info/RECORD,,
+autogluon.timeseries-1.0.1b20240326.dist-info/LICENSE,sha256=CeipvOyAZxBGUsFoaFqwkx54aPnIKEtm9a5u2uXxEws,10142
+autogluon.timeseries-1.0.1b20240326.dist-info/METADATA,sha256=5d0jDJ4dHJl9-nx_8O2dkqTak2S5AKl_sFYF1uV9NbU,12532
+autogluon.timeseries-1.0.1b20240326.dist-info/NOTICE,sha256=7nPQuj8Kp-uXsU0S5so3-2dNU5EctS5hDXvvzzehd7E,114
+autogluon.timeseries-1.0.1b20240326.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+autogluon.timeseries-1.0.1b20240326.dist-info/namespace_packages.txt,sha256=giERA4R78OkJf2ijn5slgjURlhRPzfLr7waIcGkzYAo,10
+autogluon.timeseries-1.0.1b20240326.dist-info/top_level.txt,sha256=giERA4R78OkJf2ijn5slgjURlhRPzfLr7waIcGkzYAo,10
+autogluon.timeseries-1.0.1b20240326.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+autogluon.timeseries-1.0.1b20240326.dist-info/RECORD,,