autogluon.timeseries 1.1.2b20241113__py3-none-any.whl → 1.1.2b20241115__py3-none-any.whl

autogluon/timeseries/dataset/ts_dataframe.py

@@ -1067,3 +1067,7 @@ class TimeSeriesDataFrame(pd.DataFrame, TimeSeriesDataFrameDeprecatedMixin):
         # This hides method from IPython autocomplete, but not VSCode autocomplete
         deprecated = ["get_reindexed_view", "to_regular_index"]
         return [d for d in super().__dir__() if d not in deprecated]
+
+    def to_data_frame(self) -> pd.DataFrame:
+        """Convert `TimeSeriesDataFrame` to a `pandas.DataFrame`"""
+        return pd.DataFrame(self)

autogluon/timeseries/models/chronos/model.py

@@ -1,5 +1,8 @@
 import logging
 import os
+import shutil
+import time
+from pathlib import Path
 from typing import Any, Dict, Literal, Optional, Union
 
 import numpy as np
@@ -72,9 +75,10 @@ MODEL_ALIASES = {
 
 
 class ChronosModel(AbstractTimeSeriesModel):
-    """Chronos pretrained time series forecasting models. Models can be based on the original
+    """Chronos [Ansari2024]_ pretrained time series forecasting models which can be used for zero-shot forecasting or fine-tuned
+    in a task-specific manner. Models can be based on the original
     `ChronosModel <https://github.com/amazon-science/chronos-forecasting/blob/main/src/chronos/chronos.py>`_ implementation,
-    as well as a newer family of Chronos-Bolt models which are capable of much faster inference.
+    as well as a newer family of Chronos-Bolt models capable of much faster inference.
 
     The original Chronos is a 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
@@ -88,6 +92,9 @@ class ChronosModel(AbstractTimeSeriesModel):
     time series is then fed into a T5 model for forecasting. The Chronos-Bolt variants are capable of much faster inference,
     and can all run on CPUs. Chronos-Bolt models are also available on Hugging Face <https://huggingface.co/autogluon/>`_.
 
+    Both Chronos and Chronos-Bolt variants can be fine-tuned by setting ``fine_tune=True`` and selecting appropriate
+    fine-tuning parameters such as the learning rate (``fine_tune_lr``) and max steps (``fine_tune_steps``).
+
     References
     ----------
     .. [Ansari2024] Ansari, Abdul Fatir, Stella, Lorenzo et al.
@@ -108,8 +115,8 @@ class ChronosModel(AbstractTimeSeriesModel):
     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.
+        Device to use for inference (and fine-tuning, if enabled). 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
@@ -129,12 +136,34 @@ class ChronosModel(AbstractTimeSeriesModel):
     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.
+    fine_tune : bool, default = False
+        If True, the pretrained model will be fine-tuned
+    fine_tune_lr: float, default = 0.0001
+        The learning rate used for fine-tuning
+    fine_tune_steps : int, default = 5000
+        The number of gradient update steps to fine-tune for
+    fine_tune_batch_size : int, default = 16
+        The batch size to use for fine-tuning
+    fine_tune_shuffle_buffer_size : int, default = 10000
+        The size of the shuffle buffer to shuffle the data during fine-tuning. If None, shuffling will
+        be turned off.
+    eval_during_fine_tune : bool, default = False
+        If True, validation will be performed during fine-tuning to select the best checkpoint.
+        Setting this argument to True may result in slower fine-tuning.
+    fine_tune_eval_max_items : int, default = 256
+        The maximum number of randomly-sampled time series to use from the validation set for evaluation
+        during fine-tuning. If None, the entire validation dataset will be used.
+    fine_tune_trainer_kwargs : dict, optional
+        Extra keyword arguments passed to ``transformers.TrainingArguments``
+    keep_transformers_logs: bool, default = False
+        If True, the logs generated by transformers will NOT be removed after fine-tuning
     """
 
     # default number of samples for prediction
     default_num_samples: int = 20
     default_model_path = "autogluon/chronos-t5-small"
     maximum_context_length = 2048
+    fine_tuned_ckpt_name: str = "fine-tuned-ckpt"
 
     def __init__(
         self,
@@ -202,6 +231,12 @@ class ChronosModel(AbstractTimeSeriesModel):
         model = load_pkl.load(path=os.path.join(path, cls.model_file_name), verbose=verbose)
         if reset_paths:
             model.set_contexts(path)
+
+        fine_tune_ckpt_path = Path(model.path) / cls.fine_tuned_ckpt_name
+        if fine_tune_ckpt_path.exists():
+            logger.debug(f"Fine-tuned checkpoint exists, setting model_path to {fine_tune_ckpt_path}")
+            model.model_path = fine_tune_ckpt_path
+
         return model
 
     def _is_gpu_available(self) -> bool:
@@ -245,7 +280,7 @@ class ChronosModel(AbstractTimeSeriesModel):
             minimum_resources["num_gpus"] = self.min_num_gpus
         return minimum_resources
 
-    def load_model_pipeline(self):
+    def load_model_pipeline(self, is_training: bool = False):
         from .pipeline import BaseChronosPipeline
 
         gpu_available = self._is_gpu_available()
@@ -262,8 +297,9 @@ 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,
-            optimization_strategy=self.optimization_strategy,
         )
 
         self.model_pipeline = pipeline
@@ -272,6 +308,59 @@ class ChronosModel(AbstractTimeSeriesModel):
         self.load_model_pipeline()
         return self
 
+    def _has_tf32(self):
+        import torch.cuda
+
+        return torch.cuda.is_available() and torch.cuda.get_device_capability()[0] >= 8
+
+    def _get_model_params(self) -> dict:
+        """Gets params that are passed to the inner model."""
+        init_args = super()._get_model_params().copy()
+
+        init_args.setdefault("fine_tune", False)
+        init_args.setdefault("keep_transformers_logs", False)
+        init_args.setdefault("fine_tune_lr", 1e-4)
+        init_args.setdefault("fine_tune_steps", 5000)
+        init_args.setdefault("fine_tune_batch_size", self.default_batch_size)
+        init_args.setdefault("eval_during_fine_tune", False)
+        init_args.setdefault("fine_tune_eval_max_items", 256)
+        init_args.setdefault("fine_tune_shuffle_buffer_size", 10_000)
+
+        eval_during_fine_tune = init_args["eval_during_fine_tune"]
+        output_dir = Path(self.path) / "transformers_logs"
+        fine_tune_trainer_kwargs = dict(
+            output_dir=str(output_dir),
+            per_device_train_batch_size=init_args["fine_tune_batch_size"],
+            per_device_eval_batch_size=init_args["fine_tune_batch_size"],
+            learning_rate=init_args["fine_tune_lr"],
+            lr_scheduler_type="linear",
+            warmup_ratio=0.0,
+            optim="adamw_torch_fused",
+            logging_dir=str(output_dir),
+            logging_strategy="steps",
+            logging_steps=100,
+            report_to="none",
+            max_steps=init_args["fine_tune_steps"],
+            gradient_accumulation_steps=1,
+            dataloader_num_workers=self.data_loader_num_workers,
+            tf32=self._has_tf32(),
+            save_only_model=True,
+            prediction_loss_only=True,
+            save_total_limit=1,
+            save_strategy="steps" if eval_during_fine_tune else "no",
+            save_steps=100 if eval_during_fine_tune else None,
+            evaluation_strategy="steps" if eval_during_fine_tune else "no",
+            eval_steps=100 if eval_during_fine_tune else None,
+            load_best_model_at_end=True if eval_during_fine_tune else False,
+            metric_for_best_model="eval_loss" if eval_during_fine_tune else None,
+        )
+        user_fine_tune_trainer_kwargs = init_args.get("fine_tune_trainer_kwargs", {})
+        fine_tune_trainer_kwargs.update(user_fine_tune_trainer_kwargs)
+
+        init_args["fine_tune_trainer_kwargs"] = fine_tune_trainer_kwargs
+
+        return init_args
+
     def _fit(
         self,
         train_data: TimeSeriesDataFrame,
@@ -279,8 +368,177 @@ class ChronosModel(AbstractTimeSeriesModel):
         time_limit: int = None,
         **kwargs,
     ) -> None:
+        from transformers.trainer import PrinterCallback, Trainer, TrainingArguments
+
+        from .pipeline import ChronosBoltPipeline, ChronosPipeline
+        from .pipeline.utils import (
+            ChronosFineTuningDataset,
+            EvaluateAndSaveFinalStepCallback,
+            LoggerCallback,
+            TimeLimitCallback,
+        )
+
+        # TODO: Add support for fine-tuning models with context_length longer than the pretrained model
+
+        # verbosity < 3: all logs and warnings from transformers will be suppressed
+        # verbosity >= 3: progress bar and loss logs will be logged
+        # verbosity 4: everything will be logged
+        verbosity = kwargs.get("verbosity", 2)
+        for logger_name in logging.root.manager.loggerDict:
+            if "transformers" in logger_name:
+                transformers_logger = logging.getLogger(logger_name)
+                transformers_logger.setLevel(logging.ERROR if verbosity <= 3 else logging.INFO)
+
         self._check_fit_params()
-        self.time_limit = time_limit
+
+        fine_tune_args = self._get_model_params()
+        do_fine_tune = fine_tune_args["fine_tune"]
+
+        if do_fine_tune:
+            assert train_data is not None, "train_data cannot be None when fine_tune=True"
+
+        eval_during_fine_tune = val_data is not None and fine_tune_args["eval_during_fine_tune"]
+
+        start_time = time.monotonic()
+        if do_fine_tune:
+            context_length = self._get_context_length(train_data)
+            # load model pipeline to device memory
+            self.load_model_pipeline(is_training=True)
+
+            fine_tune_prediction_length = self.prediction_length
+            model_prediction_length = self.model_pipeline.inner_model.config.chronos_config["prediction_length"]
+
+            if isinstance(self.model_pipeline, ChronosPipeline):
+                pipeline_specific_trainer_kwargs = {}
+
+                # Update prediction_length of the model
+                # NOTE: We only do this for ChronosPipeline because the prediction length of ChronosBolt models
+                # is fixed due to direct multistep forecasting setup
+                self.model_pipeline.model.config.prediction_length = fine_tune_prediction_length
+                self.model_pipeline.inner_model.config.chronos_config["prediction_length"] = (
+                    fine_tune_prediction_length
+                )
+
+            elif isinstance(self.model_pipeline, ChronosBoltPipeline):
+                # custom label_names is needed for validation to work with ChronosBolt models
+                pipeline_specific_trainer_kwargs = dict(label_names=["target"])
+
+                # truncate prediction_length if it goes beyond ChronosBolt's prediction_length
+                fine_tune_prediction_length = min(model_prediction_length, self.prediction_length)
+
+                if self.prediction_length != fine_tune_prediction_length:
+                    logger.debug(
+                        f"ChronosBolt models can only be fine-tuned with a maximum prediction_length of {model_prediction_length}. "
+                        f"Fine-tuning prediction_length has been changed to {fine_tune_prediction_length}."
+                    )
+
+            fine_tune_trainer_kwargs = fine_tune_args["fine_tune_trainer_kwargs"]
+            fine_tune_trainer_kwargs["disable_tqdm"] = fine_tune_trainer_kwargs.get("disable_tqdm", (verbosity < 3))
+            fine_tune_trainer_kwargs["use_cpu"] = str(self.model_pipeline.inner_model.device) == "cpu"
+
+            # TODO: adamw_torch_fused is not supported on CPU in torch <= 2.3. When torch 2.4 becomes the lower bound
+            # this if block can be removed because torch >= 2.4 supports AdamW optimizer with fused=True on CPU
+            if fine_tune_trainer_kwargs["use_cpu"] and fine_tune_trainer_kwargs["optim"] == "adamw_torch_fused":
+                fine_tune_trainer_kwargs["optim"] = "adamw_torch"
+
+            output_dir = Path(fine_tune_trainer_kwargs["output_dir"])
+
+            if not eval_during_fine_tune:
+                # turn off eval-related trainer args
+                fine_tune_trainer_kwargs["evaluation_strategy"] = "no"
+                fine_tune_trainer_kwargs["eval_steps"] = None
+                fine_tune_trainer_kwargs["load_best_model_at_end"] = False
+                fine_tune_trainer_kwargs["metric_for_best_model"] = None
+
+            training_args = TrainingArguments(**fine_tune_trainer_kwargs, **pipeline_specific_trainer_kwargs)
+            tokenizer_train_dataset = ChronosFineTuningDataset(
+                target_df=train_data,
+                target_column=self.target,
+                context_length=context_length,
+                prediction_length=fine_tune_prediction_length,
+                # if tokenizer exists, then the data is returned in the HF-style format accepted by
+                # the original Chronos models otherwise the data is returned in ChronosBolt's format
+                tokenizer=getattr(self.model_pipeline, "tokenizer", None),
+                mode="training",
+            ).shuffle(fine_tune_args["fine_tune_shuffle_buffer_size"])
+
+            callbacks = []
+            if time_limit is not None:
+                callbacks.append(TimeLimitCallback(time_limit=time_limit))
+
+            if val_data is not None:
+                callbacks.append(EvaluateAndSaveFinalStepCallback())
+                # evaluate on a randomly-sampled subset
+                fine_tune_eval_max_items = (
+                    min(val_data.num_items, fine_tune_args["fine_tune_eval_max_items"])
+                    if fine_tune_args["fine_tune_eval_max_items"] is not None
+                    else val_data.num_items
+                )
+
+                if fine_tune_eval_max_items < val_data.num_items:
+                    eval_items = np.random.choice(
+                        val_data.item_ids.values, size=fine_tune_eval_max_items, replace=False
+                    )
+                    val_data = val_data.loc[eval_items]
+
+                tokenizer_val_dataset = ChronosFineTuningDataset(
+                    target_df=val_data,
+                    target_column=self.target,
+                    context_length=context_length,
+                    prediction_length=fine_tune_prediction_length,
+                    tokenizer=getattr(self.model_pipeline, "tokenizer", None),
+                    mode="validation",
+                )
+
+            trainer = Trainer(
+                model=self.model_pipeline.inner_model,
+                args=training_args,
+                train_dataset=tokenizer_train_dataset,
+                eval_dataset=tokenizer_val_dataset if val_data is not None else None,
+                callbacks=callbacks,
+            )
+
+            # remove PrinterCallback from callbacks which logs to the console via a print() call,
+            # so it cannot be handled by setting the log level
+            trainer.pop_callback(PrinterCallback)
+
+            if verbosity >= 3:
+                logger.warning(
+                    "Transformers logging is turned on during fine-tuning. Note that losses reported by transformers "
+                    "may not correspond to those specified via `eval_metric`."
+                )
+                trainer.add_callback(LoggerCallback())
+
+            if val_data is not None:
+                # evaluate once before training
+                zero_shot_eval_loss = trainer.evaluate()["eval_loss"]
+
+            trainer.train()
+
+            if eval_during_fine_tune:
+                # get the best eval_loss logged during fine-tuning
+                log_history_df = pd.DataFrame(trainer.state.log_history)
+                best_train_eval_loss = log_history_df["eval_loss"].min()
+            elif val_data is not None:
+                # evaluate at the end of fine-tuning
+                best_train_eval_loss = trainer.evaluate()["eval_loss"]
+
+            if val_data is None or best_train_eval_loss <= zero_shot_eval_loss:
+                fine_tuned_ckpt_path = Path(self.path) / self.fine_tuned_ckpt_name
+                logger.info(f"Saving fine-tuned model to {fine_tuned_ckpt_path}")
+                self.model_pipeline.inner_model.save_pretrained(Path(self.path) / self.fine_tuned_ckpt_name)
+            else:
+                # Reset the model to its pretrained state
+                logger.info("Validation loss worsened after fine-tuning. Reverting to the pretrained model.")
+                self.model_pipeline = None
+                self.load_model_pipeline(is_training=False)
+
+            if not fine_tune_args["keep_transformers_logs"]:
+                logger.debug(f"Removing transformers_logs directory {output_dir}")
+                shutil.rmtree(output_dir)
+
+        if time_limit is not None:
+            self.time_limit = time_limit - (time.monotonic() - start_time)  # inference time budget
 
     def _get_inference_data_loader(
         self,
@@ -305,6 +563,13 @@ class ChronosModel(AbstractTimeSeriesModel):
             on_batch=timeout_callback(seconds=time_limit),
         )
 
+    def _get_context_length(self, data: TimeSeriesDataFrame) -> int:
+        context_length = self.context_length or min(
+            data.num_timesteps_per_item().max(),
+            self.maximum_context_length,
+        )
+        return context_length
+
     def _predict(
         self,
         data: TimeSeriesDataFrame,
@@ -319,15 +584,13 @@ class ChronosModel(AbstractTimeSeriesModel):
         # Note that this is independent of the model's own context length set in the model's config file.
         # For example, if the context_length is set to 2048 here but the model expects context length
         # (according to its config.json file) of 512, it will further truncate the series during inference.
-        context_length = self.context_length or min(
-            data.num_timesteps_per_item().max(),
-            self.maximum_context_length,
-        )
+        context_length = self._get_context_length(data)
 
         with warning_filter(all_warnings=True):
             import torch
 
             if self.model_pipeline is None:
+                # FIXME: optimization_strategy is ignored when model is fine-tuned
                 # load model pipeline to device memory
                 self.load_model_pipeline()
 
@@ -366,7 +629,7 @@ class ChronosModel(AbstractTimeSeriesModel):
         return TimeSeriesDataFrame(df)
 
     def _more_tags(self) -> Dict:
-        return {"allow_nan": True}
+        return {"allow_nan": True, "can_use_val_data": self._get_model_params()["fine_tune"]}
 
     def score_and_cache_oof(
         self,

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

@@ -2,12 +2,15 @@
 
 from enum import Enum
 from pathlib import Path
-from typing import Dict, List, Optional, Tuple, Union
+from typing import TYPE_CHECKING, Dict, List, Optional, Tuple, Union
 
 import torch
 
 from .utils import left_pad_and_stack_1D
 
+if TYPE_CHECKING:
+    from transformers import PreTrainedModel
+
 
 class ForecastType(Enum):
     SAMPLES = "samples"
@@ -36,6 +39,16 @@ class BaseChronosPipeline(metaclass=PipelineRegistry):
         "float64": torch.float64,
     }
 
+    def __init__(self, inner_model: "PreTrainedModel"):
+        """
+        Parameters
+        ----------
+        inner_model : PreTrainedModel
+            A hugging-face transformers PreTrainedModel, e.g., T5ForConditionalGeneration
+        """
+        # for easy access to the inner HF-style model
+        self.inner_model = inner_model
+
     def _prepare_and_validate_context(self, context: Union[torch.Tensor, List[torch.Tensor]]):
         if isinstance(context, list):
             context = left_pad_and_stack_1D(context)

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

@@ -65,9 +65,12 @@ class ChronosTokenizer:
     which concrete classes must implement.
     """
 
-    def input_transform(self, context: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor, Any]:
+    def context_input_transform(
+        self,
+        context: torch.Tensor,
+    ) -> Tuple:
         """
-        Turn a batch of time series into token IDs, attention map, and scale.
+        Turn a batch of time series into token IDs, attention mask, and tokenizer_state.
 
         Parameters
         ----------
@@ -87,9 +90,40 @@ class ChronosTokenizer:
             which input observations are not ``torch.nan`` (i.e. not
             missing nor padding).
         tokenizer_state
-            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.
+            An object that can be passed to ``label_input_transform``
+            and ``output_transform``. Contains the relevant information
+            to decode output samples into real values,
+            such as location and scale parameters.
+        """
+        raise NotImplementedError()
+
+    def label_input_transform(self, label: torch.Tensor, tokenizer_state: Any) -> Tuple:
+        """
+        Turn a batch of label slices of time series into token IDs and attention mask
+        using the ``tokenizer_state`` provided by ``context_input_transform``.
+
+        Parameters
+        ----------
+        label
+            A tensor shaped (batch_size, time_length), containing the
+            timeseries label, i.e., the ground-truth future values.
+        tokenizer_state
+            An object returned by ``context_input_transform`` containing
+            relevant information to preprocess data, such as location and
+            scale. The nature of this depends on the specific tokenizer.
+            This is used for tokenizing the label, in order to use the same
+            scaling used to tokenize the context.
+
+        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).
         """
         raise NotImplementedError()
 
@@ -117,6 +151,11 @@ class ChronosTokenizer:
 
 
 class MeanScaleUniformBins(ChronosTokenizer):
+    """
+    A tokenizer that performs mean scaling and then quantizes the scaled time series into
+    uniformly-spaced bins between some bounds on the real line.
+    """
+
     def __init__(self, low_limit: float, high_limit: float, config: ChronosConfig) -> None:
         self.config = config
         self.centers = torch.linspace(
@@ -132,15 +171,15 @@ class MeanScaleUniformBins(ChronosTokenizer):
             )
         )
 
-    def input_transform(self, context: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
-        batch_size, length = context.shape
+    def _input_transform(
+        self, context: torch.Tensor, scale: Optional[torch.Tensor] = None
+    ) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+        attention_mask = ~torch.isnan(context)
 
-        if length > self.config.context_length:
-            context = context[..., -self.config.context_length :]
+        if scale is None:
+            scale = torch.nansum(torch.abs(context) * attention_mask, dim=-1) / torch.nansum(attention_mask, dim=-1)
+            scale[~(scale > 0)] = 1.0
 
-        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(
@@ -153,15 +192,42 @@ class MeanScaleUniformBins(ChronosTokenizer):
             + self.config.n_special_tokens
         )
         token_ids[~attention_mask] = self.config.pad_token_id
+        token_ids.clamp_(0, self.config.n_tokens - 1)
 
-        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 _append_eos_token(
+        self, token_ids: torch.Tensor, attention_mask: torch.Tensor
+    ) -> Tuple[torch.Tensor, torch.Tensor]:
+        batch_size = token_ids.shape[0]
+        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
+
+    def context_input_transform(self, context: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+        length = context.shape[-1]
+
+        if length > self.config.context_length:
+            context = context[..., -self.config.context_length :]
+
+        token_ids, attention_mask, scale = self._input_transform(context=context)
+
+        if self.config.use_eos_token and self.config.model_type == "seq2seq":
+            token_ids, attention_mask = self._append_eos_token(token_ids=token_ids, attention_mask=attention_mask)
 
         return token_ids, attention_mask, scale
 
+    def label_input_transform(self, label: torch.Tensor, scale: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:
+        token_ids, attention_mask, _ = self._input_transform(context=label, scale=scale)
+
+        if self.config.use_eos_token:
+            token_ids, attention_mask = self._append_eos_token(token_ids=token_ids, attention_mask=attention_mask)
+
+        return token_ids, attention_mask
+
     def output_transform(self, samples: torch.Tensor, scale: torch.Tensor) -> torch.Tensor:
         scale_unsqueezed = scale.unsqueeze(-1).unsqueeze(-1)
         indices = torch.clamp(
@@ -302,6 +368,7 @@ class ChronosPipeline(BaseChronosPipeline):
     forecast_type: ForecastType = ForecastType.SAMPLES
 
     def __init__(self, tokenizer, model):
+        super().__init__(inner_model=model.model)
         self.tokenizer = tokenizer
         self.model = model
 
@@ -330,7 +397,7 @@ class ChronosPipeline(BaseChronosPipeline):
             provided, and the extra 1 is for EOS.
         """
         context = self._prepare_and_validate_context(context=context)
-        token_ids, attention_mask, tokenizer_state = self.tokenizer.input_transform(context)
+        token_ids, attention_mask, tokenizer_state = self.tokenizer.context_input_transform(context)
         embeddings = self.model.encode(
             input_ids=token_ids.to(self.model.device),
             attention_mask=attention_mask.to(self.model.device),
@@ -402,7 +469,7 @@ class ChronosPipeline(BaseChronosPipeline):
         remaining = prediction_length
 
         while remaining > 0:
-            token_ids, attention_mask, scale = self.tokenizer.input_transform(context)
+            token_ids, attention_mask, scale = self.tokenizer.context_input_transform(context)
             samples = self.model(
                 token_ids.to(self.model.device),
                 attention_mask.to(self.model.device),

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

@@ -289,7 +289,7 @@ class ChronosBoltModelForForecasting(T5PreTrainedModel):
             # normalize target
             target, _ = self.instance_norm(target, loc_scale)
             target = target.unsqueeze(1)  # type: ignore
-            assert self.chronos_config.prediction_length == target.shape[-1]
+            assert self.chronos_config.prediction_length >= target.shape[-1]
 
             target = target.to(quantile_preds.device)
             target_mask = (
@@ -297,6 +297,12 @@ class ChronosBoltModelForForecasting(T5PreTrainedModel):
             )
             target[~target_mask] = 0.0
 
+            # pad target and target_mask if they are shorter than model's prediction_length
+            if self.chronos_config.prediction_length > target.shape[-1]:
+                padding_shape = (*target.shape[:-1], self.chronos_config.prediction_length - target.shape[-1])
+                target = torch.cat([target, torch.zeros(padding_shape).to(target)], dim=-1)
+                target_mask = torch.cat([target_mask, torch.zeros(padding_shape).to(target_mask)], dim=-1)
+
             loss = (
                 2
                 * torch.abs(
@@ -373,6 +379,7 @@ class ChronosBoltPipeline(BaseChronosPipeline):
     _aliases = ["PatchedT5Pipeline"]
 
     def __init__(self, model: ChronosBoltModelForForecasting):
+        super().__init__(inner_model=model)
         self.model = model
 
     @property

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

@@ -1,15 +1,212 @@
+import logging
 import os
 import re
 import time
+from itertools import chain, cycle
 from pathlib import Path
-from typing import Callable, List, Optional
+from typing import TYPE_CHECKING, Callable, Iterable, Iterator, List, Literal, Optional
 
 import numpy as np
 import torch
+from gluonts.dataset.field_names import FieldName
+from gluonts.transform import ExpectedNumInstanceSampler, InstanceSplitter, ValidationSplitSampler
+from torch.utils.data import IterableDataset
+from transformers import TrainerCallback
 
 from autogluon.common.loaders.load_s3 import download, list_bucket_prefix_suffix_contains_s3
 from autogluon.core.utils.exceptions import TimeLimitExceeded
 from autogluon.timeseries.dataset.ts_dataframe import TimeSeriesDataFrame
+from autogluon.timeseries.models.gluonts.abstract_gluonts import SimpleGluonTSDataset
+
+if TYPE_CHECKING:
+    # TODO: fix the underlying reason for this circular import, the pipeline should handle tokenization
+    from autogluon.timeseries.models.chronos.pipeline.chronos import ChronosTokenizer
+
+
+logger = logging.getLogger("autogluon.timeseries.models.chronos")
+
+
+class PseudoShuffledIterableDataset(IterableDataset):
+    """
+    Shuffle entries from an iterable by temporarily accumulating them
+    in an intermediate buffer.
+
+    Parameters
+    ----------
+    base_dataset
+        The original iterable object, representing the dataset.
+    shuffle_buffer_size
+        Size of the buffer use to shuffle entries from the base dataset.
+    """
+
+    def __init__(self, base_dataset, shuffle_buffer_size: int = 100) -> None:
+        super().__init__()
+        assert shuffle_buffer_size > 0
+        self.base_dataset = base_dataset
+        self.shuffle_buffer_size = shuffle_buffer_size
+        self.generator = torch.Generator()
+
+    def __iter__(self):
+        shuffle_buffer = []
+
+        for element in self.base_dataset:
+            shuffle_buffer.append(element)
+            if len(shuffle_buffer) >= self.shuffle_buffer_size:
+                idx = torch.randint(len(shuffle_buffer), size=(), generator=self.generator)
+                yield shuffle_buffer.pop(idx)
+
+        while shuffle_buffer:
+            idx = torch.randint(len(shuffle_buffer), size=(), generator=self.generator)
+            yield shuffle_buffer.pop(idx)
+
+
+class ChronosFineTuningDataset(IterableDataset):
+    """
+    Dataset wrapper to convert a ``TimeSeriesDataFrame`` into an iterable dataset
+    compatible with Chronos models.
+
+    When a ``tokenizer`` is provided, data is converted into HuggingFace-compatible set of
+    ``input_ids``, ``attention_mask`` and ``labels``, used by the original Chronos models.
+
+    When the ``tokenizer`` is omitted, data is converted into the format compatible with
+    ChronosBolt models, i.e., ``context`` and ``target``.
+
+    Parameters
+    ----------
+    target_df : TimeSeriesDataFrame
+        The ``TimeSeriesDataFrame`` to be converted
+    target_column : str, default = "target"
+        The name of the column which contains the target time series, by default "target"
+    context_length : int, default = 512
+        The length of the historical context
+    prediction_length : int, default = 64
+        The prediction_length, i.e., length of label or target
+    tokenizer : ``ChronosTokenizer``, default = None
+        When a ``ChronosTokenizer`` object is provided, data will be converted into the
+        HuggingFace format accepted by the original Chronos models using this ``ChronosTokenizer``.
+        If None, data will be converted into the format accepted by ChronosBolt models.
+    mode : Literal["training", "validation"], default = "training"
+        When ``training``, random slices from the time series will be returned for training purposes.
+        If ``validation``, the last slice of each time series returned in the original order.
+    """
+
+    def __init__(
+        self,
+        target_df: TimeSeriesDataFrame,
+        target_column: str = "target",
+        context_length: int = 512,
+        prediction_length: int = 64,
+        tokenizer: Optional["ChronosTokenizer"] = None,
+        mode: Literal["training", "validation"] = "training",
+    ) -> None:
+        super().__init__()
+
+        assert mode in ("training", "validation")
+
+        # A dummy hourly freq is used because the model doesn't actually need the freq
+        self.gluonts_dataset = SimpleGluonTSDataset(target_df=target_df, freq="h", target_column=target_column)
+        self.tokenizer = tokenizer
+        self.context_length = context_length
+        self.prediction_length = prediction_length
+        self.mode = mode
+
+    def _create_instance_splitter(self, mode: str):
+        instance_sampler = {
+            "training": ExpectedNumInstanceSampler(
+                num_instances=1.0, min_future=self.prediction_length, min_instances=1
+            ),
+            "validation": ValidationSplitSampler(min_future=self.prediction_length),
+        }[mode]
+
+        return InstanceSplitter(
+            target_field=FieldName.TARGET,
+            is_pad_field=FieldName.IS_PAD,
+            start_field=FieldName.START,
+            forecast_start_field=FieldName.FORECAST_START,
+            instance_sampler=instance_sampler,
+            past_length=self.context_length,
+            future_length=self.prediction_length,
+            dummy_value=np.nan,
+        )
+
+    def _create_training_data(self, data: Iterable[dict]):
+        data = chain.from_iterable(cycle([data]))
+        split_transform = self._create_instance_splitter("training")
+        data = split_transform.apply(data, is_train=True)
+        return data
+
+    def _create_validation_data(self, data: Iterable[dict]):
+        data = self._create_instance_splitter("validation").apply(data, is_train=False)
+        return data
+
+    def to_chronos_format(self, entry: dict) -> dict:
+        """Converts an entry from GluonTS data format with past and future targets
+        to the HuggingFace format accepted by the original Chronos models using the ChronosTokenizer.
+
+        Parameters
+        ----------
+        entry : dict
+            time series data entry in GluonTS format with ``past_target`` and ``future_target`` keys
+
+        Returns
+        -------
+        dict
+            time series data entry in HuggingFace format with ``input_ids``, ``attention_mask``, and ``labels``
+        """
+        assert self.tokenizer is not None, "A ChronosTokenizer is required to convert data into the Chronos format"
+        past_target = torch.tensor(entry[f"past_{FieldName.TARGET}"]).unsqueeze(0)
+        input_ids, attention_mask, scale = self.tokenizer.context_input_transform(past_target)
+        future_target = torch.tensor(entry[f"future_{FieldName.TARGET}"]).unsqueeze(0)
+        labels, labels_mask = self.tokenizer.label_input_transform(future_target, scale)
+        labels[labels_mask == 0] = -100
+
+        return {
+            "input_ids": input_ids.squeeze(0),
+            "attention_mask": attention_mask.squeeze(0),
+            "labels": labels.squeeze(0),
+        }
+
+    def to_chronos_bolt_format(self, entry: dict) -> dict:
+        """Converts an entry from GluonTS data format with past and future targets
+        to the format accepted by the ChronosBolt models.
+
+        Parameters
+        ----------
+        entry : dict
+            time series data entry in GluonTS format with ``past_target`` and ``future_target`` keys
+
+        Returns
+        -------
+        dict
+            time series data entry in ChronosBolt format with ``context`` and ``target``
+        """
+        past_target = torch.tensor(entry[f"past_{FieldName.TARGET}"])
+        future_target = torch.tensor(entry[f"future_{FieldName.TARGET}"])
+
+        return {"context": past_target, "target": future_target}
+
+    def __iter__(self) -> Iterator:
+        if self.mode == "training":
+            iterable = self._create_training_data(self.gluonts_dataset)
+        elif self.mode == "validation":
+            iterable = self._create_validation_data(self.gluonts_dataset)
+
+        format_transform_fn = self.to_chronos_format if self.tokenizer is not None else self.to_chronos_bolt_format
+        for entry in iterable:
+            yield format_transform_fn(entry)
+
+    def shuffle(self, shuffle_buffer_size: Optional[int] = None):
+        """Returns a (pseudo) shuffled version of this iterable dataset.
+
+        Parameters
+        ----------
+        shuffle_buffer_size : int, optional, default = None
+            The shuffle buffer size used for pseudo shuffling
+        """
+        assert shuffle_buffer_size is None or shuffle_buffer_size >= 0
+        if not shuffle_buffer_size:
+            return self
+        return PseudoShuffledIterableDataset(self, shuffle_buffer_size)
 
 
 def left_pad_and_stack_1D(tensors: List[torch.Tensor]) -> torch.Tensor:
@@ -91,12 +288,51 @@ class ChronosInferenceDataLoader(torch.utils.data.DataLoader):
             self.callback()
 
 
+class EvaluateAndSaveFinalStepCallback(TrainerCallback):
+    """Callback to evaluate and save the model at last training step."""
+
+    def on_step_end(self, args, state, control, **kwargs):
+        if state.global_step >= state.max_steps:
+            control.should_log = True
+            control.should_evaluate = True
+            control.should_save = True
+
+
+class TimeLimitCallback(TrainerCallback):
+    def __init__(self, time_limit: int):
+        """
+        Callback to stop training once a specified time has elapsed.
+
+        Parameters
+        ----------
+        time_limit: int
+            maximum time allowed for training in seconds.
+        """
+        self.time_limit = time_limit
+        self.start_time = None
+
+    def on_train_begin(self, args, state, control, **kwargs):
+        self.start_time = time.monotonic()
+
+    def on_step_end(self, args, state, control, **kwargs):
+        elapsed_time = time.monotonic() - self.start_time
+        if elapsed_time > self.time_limit:
+            raise TimeLimitExceeded
+
+
+class LoggerCallback(TrainerCallback):
+    def on_log(self, args, state, control, logs=None, **kwargs):
+        logs.pop("total_flos", None)
+        if state.is_local_process_zero:
+            logger.info(logs)
+
+
 def timeout_callback(seconds: Optional[float]) -> Callable:
     """Return a callback object that raises an exception if time limit is exceeded."""
-    start_time = time.time()
+    start_time = time.monotonic()
 
     def callback() -> None:
-        if seconds is not None and time.time() - start_time > seconds:
+        if seconds is not None and time.monotonic() - start_time > seconds:
             raise TimeLimitExceeded
 
     return callback

autogluon/timeseries/models/gluonts/abstract_gluonts.py

@@ -286,10 +286,6 @@ class AbstractGluonTSModel(AbstractTimeSeriesModel):
 
         self.negative_data = (dataset[self.target] < 0).any()
 
-    @property
-    def default_context_length(self) -> int:
-        return min(512, max(10, 2 * self.prediction_length))
-
     def preprocess(self, data: TimeSeriesDataFrame, is_train: bool = False, **kwargs) -> TimeSeriesDataFrame:
         # Copy data to avoid SettingWithCopyWarning from pandas
         data = data.copy()
@@ -357,25 +353,40 @@ class AbstractGluonTSModel(AbstractTimeSeriesModel):
             known_covariates[columns] = self._real_column_transformers["known"].transform(known_covariates[columns])
         return known_covariates
 
+    def _get_default_params(self):
+        """Gets default parameters for GluonTS estimator initialization that are available after
+        AbstractTimeSeriesModel initialization (i.e., before deferred initialization). Models may
+        override this method to update default parameters.
+        """
+        return {
+            "batch_size": 64,
+            "context_length": min(512, max(10, 2 * self.prediction_length)),
+            "predict_batch_size": 500,
+            "early_stopping_patience": 20,
+            "max_epochs": 100,
+            "lr": 1e-3,
+            "freq": self._dummy_gluonts_freq,
+            "prediction_length": self.prediction_length,
+            "quantiles": self.quantile_levels,
+        }
+
     def _get_model_params(self) -> dict:
         """Gets params that are passed to the inner model."""
-        init_args = super()._get_model_params().copy()
-        init_args.setdefault("batch_size", 64)
-        init_args.setdefault("context_length", self.default_context_length)
-        init_args.setdefault("predict_batch_size", 500)
-        init_args.setdefault("early_stopping_patience", 20)
-        init_args.update(
-            dict(
-                freq=self._dummy_gluonts_freq,
-                prediction_length=self.prediction_length,
-                quantiles=self.quantile_levels,
-                callbacks=self.callbacks,
-            )
-        )
-        # Support MXNet kwarg names for backwards compatibility
-        init_args.setdefault("lr", init_args.get("learning_rate", 1e-3))
-        init_args.setdefault("max_epochs", init_args.get("epochs", 100))
-        return init_args
+        # for backward compatibility with the old GluonTS MXNet API
+        parameter_name_aliases = {
+            "epochs": "max_epochs",
+            "learning_rate": "lr",
+        }
+
+        init_args = super()._get_model_params()
+        for alias, actual in parameter_name_aliases.items():
+            if alias in init_args:
+                if actual in init_args:
+                    raise ValueError(f"Parameter '{alias}' cannot be specified when '{actual}' is also specified.")
+                else:
+                    init_args[actual] = init_args.pop(alias)
+
+        return self._get_default_params() | init_args
 
     def _get_estimator_init_args(self) -> Dict[str, Any]:
         """Get GluonTS specific constructor arguments for estimator objects, an alias to `self._get_model_params`
@@ -395,7 +406,7 @@ class AbstractGluonTSModel(AbstractTimeSeriesModel):
         default_trainer_kwargs = {
             "limit_val_batches": 3,
             "max_epochs": init_args["max_epochs"],
-            "callbacks": init_args["callbacks"],
+            "callbacks": self.callbacks,
             "enable_progress_bar": False,
             "default_root_dir": self.path,
         }

autogluon/timeseries/models/gluonts/torch/models.py

@@ -209,15 +209,16 @@ class TemporalFusionTransformerModel(AbstractGluonTSModel):
     supports_cat_covariates = True
     supports_static_features = True
 
-    @property
-    def default_context_length(self) -> int:
-        return min(512, max(64, 2 * self.prediction_length))
-
     def _get_estimator_class(self) -> Type[GluonTSEstimator]:
         from gluonts.torch.model.tft import TemporalFusionTransformerEstimator
 
         return TemporalFusionTransformerEstimator
 
+    def _get_default_params(self):
+        return super()._get_default_params() | {
+            "context_length": min(512, max(64, 2 * self.prediction_length)),
+        }
+
     def _get_estimator_init_args(self) -> Dict[str, Any]:
         init_kwargs = super()._get_estimator_init_args()
         if self.num_feat_dynamic_real > 0:
@@ -282,9 +283,10 @@ class DLinearModel(AbstractGluonTSModel):
         If True, ``lightning_logs`` directory will NOT be removed after the model finished training.
     """
 
-    @property
-    def default_context_length(self) -> int:
-        return 96
+    def _get_default_params(self):
+        return super()._get_default_params() | {
+            "context_length": 96,
+        }
 
     def _get_estimator_class(self) -> Type[GluonTSEstimator]:
         from gluonts.torch.model.d_linear import DLinearEstimator
@@ -341,18 +343,16 @@ class PatchTSTModel(AbstractGluonTSModel):
 
     supports_known_covariates = True
 
-    @property
-    def default_context_length(self) -> int:
-        return 96
-
     def _get_estimator_class(self) -> Type[GluonTSEstimator]:
         from gluonts.torch.model.patch_tst import PatchTSTEstimator
 
         return PatchTSTEstimator
 
+    def _get_default_params(self):
+        return super()._get_default_params() | {"context_length": 96, "patch_len": 16}
+
     def _get_estimator_init_args(self) -> Dict[str, Any]:
         init_kwargs = super()._get_estimator_init_args()
-        init_kwargs.setdefault("patch_len", 16)
         init_kwargs["num_feat_dynamic_real"] = self.num_feat_dynamic_real
         return init_kwargs
 
@@ -467,27 +467,27 @@ class TiDEModel(AbstractGluonTSModel):
         If False, past covariates will be used by the model if they are present in the dataset.
     feat_proj_hidden_dim : int, default = 4
         Size of the feature projection layer.
-    encoder_hidden_dim : int, default = 4
+    encoder_hidden_dim : int, default = 64
         Size of the dense encoder layer.
-    decoder_hidden_dim : int, default = 4
+    decoder_hidden_dim : int, default = 64
         Size of the dense decoder layer.
-    temporal_hidden_dim : int, default = 4
+    temporal_hidden_dim : int, default = 64
         Size of the temporal decoder layer.
-    distr_hidden_dim : int, default = 4
+    distr_hidden_dim : int, default = 64
         Size of the distribution projection layer.
-    num_layers_encoder : int, default = 1
+    num_layers_encoder : int, default = 2
         Number of layers in dense encoder.
-    num_layers_decoder : int, default = 1
+    num_layers_decoder : int, default = 2
         Number of layers in dense decoder.
-    decoder_output_dim : int, default = 4
+    decoder_output_dim : int, default = 16
         Output size of the dense decoder.
-    dropout_rate : float, default = 0.3
+    dropout_rate : float, default = 0.2
         Dropout regularization parameter.
     num_feat_dynamic_proj : int, default = 2
         Output size of feature projection layer.
     embedding_dimension : int, default = [16] * num_feat_static_cat
         Dimension of the embeddings for categorical features
-    layer_norm : bool, default = False
+    layer_norm : bool, default = True
         Should layer normalization be enabled?
     scaling : {"mean", "std", None}, default = "mean"
         Scaling applied to each *context window* during training & prediction.
@@ -496,13 +496,13 @@ class TiDEModel(AbstractGluonTSModel):
         Note that this is different from the `target_scaler` that is applied to the *entire time series*.
     max_epochs : int, default = 100
         Number of epochs the model will be trained for
-    batch_size : int, default = 64
+    batch_size : int, default = 256
         Size of batches used during training
     predict_batch_size : int, default = 500
         Size of batches used during prediction.
     num_batches_per_epoch : int, default = 50
         Number of batches processed every epoch
-    lr : float, default = 1e-3,
+    lr : float, default = 1e-4,
         Learning rate used during training
     trainer_kwargs : dict, optional
         Optional keyword arguments passed to ``lightning.Trainer``.
@@ -515,15 +515,27 @@ class TiDEModel(AbstractGluonTSModel):
     supports_known_covariates = True
     supports_static_features = True
 
-    @property
-    def default_context_length(self) -> int:
-        return min(512, max(64, 2 * self.prediction_length))
-
     def _get_estimator_class(self) -> Type[GluonTSEstimator]:
         from gluonts.torch.model.tide import TiDEEstimator
 
         return TiDEEstimator
 
+    def _get_default_params(self):
+        return super()._get_default_params() | {
+            "context_length": min(512, max(64, 2 * self.prediction_length)),
+            "encoder_hidden_dim": 64,
+            "decoder_hidden_dim": 64,
+            "temporal_hidden_dim": 64,
+            "distr_hidden_dim": 64,
+            "num_layers_encoder": 2,
+            "num_layers_decoder": 2,
+            "decoder_output_dim": 16,
+            "dropout_rate": 0.2,
+            "layer_norm": True,
+            "lr": 1e-4,
+            "batch_size": 256,
+        }
+
     def _get_estimator_init_args(self) -> Dict[str, Any]:
         init_kwargs = super()._get_estimator_init_args()
         init_kwargs["num_feat_static_cat"] = self.num_feat_static_cat

autogluon/timeseries/version.py

@@ -1,3 +1,3 @@
 """This is the autogluon version file."""
-__version__ = '1.1.2b20241113'
+__version__ = '1.1.2b20241115'
 __lite__ = False

{autogluon.timeseries-1.1.2b20241113.dist-info → autogluon.timeseries-1.1.2b20241115.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: autogluon.timeseries
-Version: 1.1.2b20241113
+Version: 1.1.2b20241115
 Summary: Fast and Accurate ML in 3 Lines of Code
 Home-page: https://github.com/autogluon/autogluon
 Author: AutoGluon Community
@@ -53,9 +53,9 @@ 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.1.2b20241113
-Requires-Dist: autogluon.common==1.1.2b20241113
-Requires-Dist: autogluon.tabular[catboost,lightgbm,xgboost]==1.1.2b20241113
+Requires-Dist: autogluon.core[raytune]==1.1.2b20241115
+Requires-Dist: autogluon.common==1.1.2b20241115
+Requires-Dist: autogluon.tabular[catboost,lightgbm,xgboost]==1.1.2b20241115
 Provides-Extra: all
 Requires-Dist: optimum[onnxruntime]<1.20,>=1.17; extra == "all"
 Provides-Extra: chronos-onnx

{autogluon.timeseries-1.1.2b20241113.dist-info → autogluon.timeseries-1.1.2b20241115.dist-info}/RECORD

@@ -1,15 +1,15 @@
-autogluon.timeseries-1.1.2b20241113-py3.8-nspkg.pth,sha256=cQGwpuGPqg1GXscIwt-7PmME1OnSpD-7ixkikJ31WAY,554
+autogluon.timeseries-1.1.2b20241115-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=3dUxI-U6TGfNtRQUzWTvBIo1GKeXYOhxIX_q7Fed9eA,14013
 autogluon/timeseries/predictor.py,sha256=R9m-TYmlA4WoJbdYEL_AnEM26EhRIclynOfSmpO7mBk,84926
 autogluon/timeseries/regressor.py,sha256=wcYbvE7kFopdscubfhIfeLI3ovxKe_fUVtt0b1zWdV0,6823
 autogluon/timeseries/splitter.py,sha256=eghGwAAN2_cxGk5aJBILgjGWtLzjxJcytMy49gg_q18,3061
-autogluon/timeseries/version.py,sha256=OGArr6c4pNSqH_iw-M1qDHQMDvnxMN7HervCqm8kQw8,90
+autogluon/timeseries/version.py,sha256=k5yEeIHMAa7wwNFT6Xs3BeQ8qrgzCQ6ICoNHeZ7GR9g,90
 autogluon/timeseries/configs/__init__.py,sha256=BTtHIPCYeGjqgOcvqb8qPD4VNX-ICKOg6wnkew1cPOE,98
 autogluon/timeseries/configs/presets_configs.py,sha256=94-yL9teDHKs2irWjP3kpewI7FE1ChYCgEgz9XHJ6gc,1965
 autogluon/timeseries/dataset/__init__.py,sha256=UvnhAN5tjgxXTHoZMQDy64YMDj4Xxa68yY7NP4vAw0o,81
-autogluon/timeseries/dataset/ts_dataframe.py,sha256=UQ-iT2dGVJF57hlGkivbSEaBwf-5NP0Amohp4DccLUA,48492
+autogluon/timeseries/dataset/ts_dataframe.py,sha256=9bJQeg3HkPeVnyxzwqAJiTJGYXths7vxUV_3-OsJ6pk,48640
 autogluon/timeseries/metrics/__init__.py,sha256=LLGmYaexsx7CregV-QaHc5exjZbsJfBSVOtxHRGC0ho,2139
 autogluon/timeseries/metrics/abstract.py,sha256=9xCFQ3NaR1C0hn01M7oBd72a_CiNV-w6QFcRjwUbKYI,8183
 autogluon/timeseries/metrics/point.py,sha256=z366XJz3n4MFl4JkXOD6ZxL69F_j7Y-jbrwb7J3yDqk,15513
@@ -25,19 +25,19 @@ autogluon/timeseries/models/autogluon_tabular/mlforecast.py,sha256=C1WVcuNlTcqo_
 autogluon/timeseries/models/autogluon_tabular/transforms.py,sha256=FozTzwcp1QjevEhrMLXsJHy8fymOcq1146oX4Al60wg,2517
 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=ULH7XCBcl93CQ4aKtY-RzhxlXyfb1bTfOmnAJWe2zLU,16589
+autogluon/timeseries/models/chronos/model.py,sha256=Z3CtfRux7W2x7mghbq8YLGFLu9kTAsozid43AN1lH_s,30151
 autogluon/timeseries/models/chronos/pipeline/__init__.py,sha256=N-YZH9BGBoi99r5cznJe1zEEjwjIg7cOYIHZkKuJq44,247
-autogluon/timeseries/models/chronos/pipeline/base.py,sha256=sVhADJ9fkJBL6p6UYw9zRb07Z1rGGHog95uOMrcs7dA,5044
-autogluon/timeseries/models/chronos/pipeline/chronos.py,sha256=cbDS7_9Z8Sn1NZdwr2DqqCqxm_zWejDxKHHRLCvLDNE,19284
-autogluon/timeseries/models/chronos/pipeline/chronos_bolt.py,sha256=vKXyz8lfIyOhobFp4kLkCQ61CWhm3BTXeluOq1EZaqU,19563
-autogluon/timeseries/models/chronos/pipeline/utils.py,sha256=C8S-1gr_PMxLYes7SP7Ep0hOrA5k9jRjM4wJAcSNuCE,3519
+autogluon/timeseries/models/chronos/pipeline/base.py,sha256=aAXCKy7Jmip4BI2UdPMoPe2gdDMbJHKxEolcTx_5SYQ,5463
+autogluon/timeseries/models/chronos/pipeline/chronos.py,sha256=iHKyw3Juml247jl7bEbGlabtMyp3ibYEoA7rHiUC9f8,22048
+autogluon/timeseries/models/chronos/pipeline/chronos_bolt.py,sha256=2MJuik-YFgONZ3X2DciAph5So6ABys5ppQhBC81gLyk,20083
+autogluon/timeseries/models/chronos/pipeline/utils.py,sha256=_P_9m9Wl4FC2QyoKLluT4l7FLmZU2xw6G4xNcUpZE4k,13043
 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
 autogluon/timeseries/models/gluonts/__init__.py,sha256=asC1PTj4j9xMbilvk1IT1julnpeoKbv5ZNuAR6-DFgA,361
-autogluon/timeseries/models/gluonts/abstract_gluonts.py,sha256=tViaFXFOVjGQi2S6cUIW-ak0Evv7rKUm2QWsmpKDMEk,34076
+autogluon/timeseries/models/gluonts/abstract_gluonts.py,sha256=4_YPUjT0oIzELHn34C0a7n21zkhjc1Yijgz9egxxPdw,34501
 autogluon/timeseries/models/gluonts/torch/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-autogluon/timeseries/models/gluonts/torch/models.py,sha256=ASTMabSAzBRJ_s5Iqjp-9fZvt4aKN892Uz35kzqGMWM,25018
+autogluon/timeseries/models/gluonts/torch/models.py,sha256=Pu7f43jr1C5S3k_bVqRB8ENuBHNEWT4ssUTdZoA1J58,25556
 autogluon/timeseries/models/local/__init__.py,sha256=e2UImoJhmj70E148IIObv90C_bHxgyLNk6YsS4p7pfs,701
 autogluon/timeseries/models/local/abstract_local_model.py,sha256=OxEkqzfAd5diQDUYStw2nI-X2lo3H8GcMLDJ6-1XL_Y,12417
 autogluon/timeseries/models/local/naive.py,sha256=iwRcFMFmJKPWPbD9TWaIUS51oav69F_VAp6-jb_5SUE,7249
@@ -59,11 +59,11 @@ autogluon/timeseries/utils/datetime/base.py,sha256=3NdsH3NDq4cVAOSoy3XpaNixyNlbj
 autogluon/timeseries/utils/datetime/lags.py,sha256=GoLtvcZ8oKb3QkoBJ9E59LSPLOP7Qjxrr2UmMSZgjyw,5909
 autogluon/timeseries/utils/datetime/seasonality.py,sha256=h_4w00iEytAz_N_EpCENQ8RCXy7KQITczrYjBgVqWkQ,764
 autogluon/timeseries/utils/datetime/time_features.py,sha256=PAXbYbQ0z_5GFbkxSNi41zLY_2-U3x0Ynm1m_WhdtGc,2572
-autogluon.timeseries-1.1.2b20241113.dist-info/LICENSE,sha256=CeipvOyAZxBGUsFoaFqwkx54aPnIKEtm9a5u2uXxEws,10142
-autogluon.timeseries-1.1.2b20241113.dist-info/METADATA,sha256=BtiE4lTblx5aiB8vlWmsZ3oj0Xy-lfxgWZE27eBa4fc,12388
-autogluon.timeseries-1.1.2b20241113.dist-info/NOTICE,sha256=7nPQuj8Kp-uXsU0S5so3-2dNU5EctS5hDXvvzzehd7E,114
-autogluon.timeseries-1.1.2b20241113.dist-info/WHEEL,sha256=bFJAMchF8aTQGUgMZzHJyDDMPTO3ToJ7x23SLJa1SVo,92
-autogluon.timeseries-1.1.2b20241113.dist-info/namespace_packages.txt,sha256=giERA4R78OkJf2ijn5slgjURlhRPzfLr7waIcGkzYAo,10
-autogluon.timeseries-1.1.2b20241113.dist-info/top_level.txt,sha256=giERA4R78OkJf2ijn5slgjURlhRPzfLr7waIcGkzYAo,10
-autogluon.timeseries-1.1.2b20241113.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-autogluon.timeseries-1.1.2b20241113.dist-info/RECORD,,
+autogluon.timeseries-1.1.2b20241115.dist-info/LICENSE,sha256=CeipvOyAZxBGUsFoaFqwkx54aPnIKEtm9a5u2uXxEws,10142
+autogluon.timeseries-1.1.2b20241115.dist-info/METADATA,sha256=GWCpPfrJry0oxm90irCuNAdgEvasKyVcnn4bnbWnshA,12388
+autogluon.timeseries-1.1.2b20241115.dist-info/NOTICE,sha256=7nPQuj8Kp-uXsU0S5so3-2dNU5EctS5hDXvvzzehd7E,114
+autogluon.timeseries-1.1.2b20241115.dist-info/WHEEL,sha256=bFJAMchF8aTQGUgMZzHJyDDMPTO3ToJ7x23SLJa1SVo,92
+autogluon.timeseries-1.1.2b20241115.dist-info/namespace_packages.txt,sha256=giERA4R78OkJf2ijn5slgjURlhRPzfLr7waIcGkzYAo,10
+autogluon.timeseries-1.1.2b20241115.dist-info/top_level.txt,sha256=giERA4R78OkJf2ijn5slgjURlhRPzfLr7waIcGkzYAo,10
+autogluon.timeseries-1.1.2b20241115.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+autogluon.timeseries-1.1.2b20241115.dist-info/RECORD,,