autogluon.timeseries 1.3.2b20250629__tar.gz → 1.3.2b20250630__tar.gz

{autogluon.timeseries-1.3.2b20250629 → autogluon.timeseries-1.3.2b20250630}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: autogluon.timeseries
-Version: 1.3.2b20250629
+Version: 1.3.2b20250630
 Summary: Fast and Accurate ML in 3 Lines of Code
 Home-page: https://github.com/autogluon/autogluon
 Author: AutoGluon Community

{autogluon.timeseries-1.3.2b20250629 → autogluon.timeseries-1.3.2b20250630}/src/autogluon/timeseries/models/chronos/model.py

@@ -116,8 +116,11 @@ class ChronosModel(AbstractTimeSeriesModel):
         Chronos models (i.e., ``autogluon/chronos-t5-{model_size}``) can be specified with aliases
         ``tiny``, ``mini`` , ``small``, ``base``, and ``large``. Chronos-Bolt models can be specified
         with ``bolt_tiny``, ``bolt_mini``, ``bolt_small``, and ``bolt_base``.
-    batch_size : int, default = 16
-        Size of batches used during inference
+    batch_size : int, default = 256
+        Size of batches used during inference. The default ``batch_size`` is selected based on the model type. For Chronos-Bolt
+        models the ``batch_size`` is set to 256 whereas Chronos models used a ``batch_size`` of 16, except Chronos (Large) which
+        uses 8. For the Chronos-Bolt models, the ``batch_size`` is reduced by a factor of 4 when the prediction horizon is greater
+        than the model's default prediction length.
     num_samples : int, default = 20
         Number of samples used during inference, only used for the original Chronos models
     device : str, default = None
@@ -583,6 +586,7 @@ class ChronosModel(AbstractTimeSeriesModel):
         self,
         data: TimeSeriesDataFrame,
         context_length: int,
+        batch_size: int,
         num_workers: int = 0,
         time_limit: Optional[float] = None,
     ):
@@ -596,7 +600,7 @@ class ChronosModel(AbstractTimeSeriesModel):
 
         return ChronosInferenceDataLoader(
             chronos_dataset,
-            batch_size=self.batch_size,
+            batch_size=batch_size,
             shuffle=False,
             num_workers=num_workers,
             on_batch=timeout_callback(seconds=time_limit),
@@ -615,6 +619,8 @@ class ChronosModel(AbstractTimeSeriesModel):
         known_covariates: Optional[TimeSeriesDataFrame] = None,
         **kwargs,
     ) -> TimeSeriesDataFrame:
+        from .pipeline import ChronosBoltPipeline
+
         # 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
@@ -628,23 +634,42 @@ class ChronosModel(AbstractTimeSeriesModel):
         with warning_filter(all_warnings=True):
             import torch
 
+            self.model_pipeline.model.eval()
+            batch_size = self.batch_size
+            if (
+                isinstance(self.model_pipeline, ChronosBoltPipeline)
+                and self.prediction_length > self.model_pipeline.model_prediction_length
+            ):
+                batch_size = max(1, batch_size // 4)
+                logger.debug(
+                    f"\tThe prediction_length {self.prediction_length} exceeds model's prediction_length {self.model_pipeline.model_prediction_length}. "
+                    f"The inference batch_size has been reduced from {self.batch_size} to {batch_size} to avoid OOM errors."
+                )
+
             inference_data_loader = self._get_inference_data_loader(
                 data=data,
+                batch_size=batch_size,
                 num_workers=self.data_loader_num_workers,
                 context_length=context_length,
                 time_limit=kwargs.get("time_limit"),
             )
 
-            self.model_pipeline.model.eval()
             with torch.inference_mode(), disable_duplicate_logs(logger):
                 batch_quantiles, batch_means = [], []
                 for batch in inference_data_loader:
-                    qs, mn = self.model_pipeline.predict_quantiles(
-                        batch,
-                        prediction_length=self.prediction_length,
-                        quantile_levels=self.quantile_levels,
-                        num_samples=self.num_samples,
-                    )
+                    try:
+                        qs, mn = self.model_pipeline.predict_quantiles(
+                            batch,
+                            prediction_length=self.prediction_length,
+                            quantile_levels=self.quantile_levels,
+                            num_samples=self.num_samples,
+                        )
+                    except torch.OutOfMemoryError as ex:
+                        logger.error(
+                            "The call to predict() resulted in an out of memory error. Try reducing the batch_size by setting:"
+                            f" predictor.fit(..., hyperparameters={{'Chronos': {{'batch_size': {batch_size // 2}, ...}}}})"
+                        )
+                        raise ex
                     batch_quantiles.append(qs.numpy())
                     batch_means.append(mn.numpy())
 

{autogluon.timeseries-1.3.2b20250629 → autogluon.timeseries-1.3.2b20250630}/src/autogluon/timeseries/models/chronos/pipeline/chronos_bolt.py

@@ -381,6 +381,8 @@ class ChronosBoltPipeline(BaseChronosPipeline):
     def __init__(self, model: ChronosBoltModelForForecasting):
         super().__init__(inner_model=model)
         self.model = model
+        self.model_context_length: int = self.model.config.chronos_config["context_length"]
+        self.model_prediction_length: int = self.model.config.chronos_config["prediction_length"]
 
     @property
     def quantiles(self) -> List[float]:
@@ -394,14 +396,12 @@ class ChronosBoltPipeline(BaseChronosPipeline):
     ):
         context_tensor = self._prepare_and_validate_context(context=context)
 
-        model_context_length = self.model.config.chronos_config["context_length"]
-        model_prediction_length = self.model.config.chronos_config["prediction_length"]
         if prediction_length is None:
-            prediction_length = model_prediction_length
+            prediction_length = self.model_prediction_length
 
-        if prediction_length > model_prediction_length:
+        if prediction_length > self.model_prediction_length:
             msg = (
-                f"We recommend keeping prediction length <= {model_prediction_length}. "
+                f"We recommend keeping prediction length <= {self.model_prediction_length}. "
                 "The quality of longer predictions may degrade since the model is not optimized for it. "
             )
             if limit_prediction_length:
@@ -414,32 +414,47 @@ class ChronosBoltPipeline(BaseChronosPipeline):
 
         # We truncate the context here because otherwise batches with very long
         # context could take up large amounts of GPU memory unnecessarily.
-        if context_tensor.shape[-1] > model_context_length:
-            context_tensor = context_tensor[..., -model_context_length:]
+        if context_tensor.shape[-1] > self.model_context_length:
+            context_tensor = context_tensor[..., -self.model_context_length :]
 
-        # TODO: We unroll the forecast of Chronos Bolt greedily with the full forecast
-        # horizon that the model was trained with (i.e., 64). This results in variance collapsing
-        # every 64 steps.
+        context_tensor = context_tensor.to(device=self.model.device, dtype=torch.float32)
+        # First block prediction
+        with torch.no_grad():
+            prediction: torch.Tensor = self.model(context=context_tensor).quantile_preds.to(context_tensor)
+
+            predictions.append(prediction)
+            remaining -= prediction.shape[-1]
+
+        # NOTE: The following heuristic for better prediction intervals with long-horizon forecasts
+        # uses all quantiles generated by the model for the first `model_prediction_length` steps,
+        # concatenating each quantile with the context and generating the next `model_prediction_length` steps.
+        # The `num_quantiles * num_quantiles` "samples" thus generated are then reduced to `num_quantiles`
+        # by computing empirical quantiles. Note that this option scales the batch size by `num_quantiles`
+        # when the `prediction_length` is greater than `model_prediction_length`.
+
+        if remaining > 0:
+            # Expand the context along quantile axis
+            context_tensor = context_tensor.unsqueeze(1).repeat(1, len(self.quantiles), 1)
+
+        quantile_tensor = torch.tensor(self.quantiles, device=context_tensor.device)
         while remaining > 0:
+            # Append the prediction to context
+            context_tensor = torch.cat([context_tensor, prediction], dim=-1)[..., -self.model_context_length :]
+            (batch_size, n_quantiles, context_length) = context_tensor.shape
+
             with torch.no_grad():
+                # Reshape (batch, n_quantiles, context_length) -> (batch * n_quantiles, context_length)
                 prediction = self.model(
-                    context=context_tensor.to(
-                        device=self.model.device,
-                        dtype=torch.float32,  # scaling should be done in 32-bit precision
-                    ),
+                    context=context_tensor.reshape(batch_size * n_quantiles, context_length)
                 ).quantile_preds.to(context_tensor)
+            # Reshape predictions from (batch * n_quantiles, n_quantiles, model_prediction_length) to (batch, n_quantiles * n_quantiles, model_prediction_length)
+            prediction = prediction.reshape(batch_size, n_quantiles * n_quantiles, -1)
+            # Reduce `n_quantiles * n_quantiles` to n_quantiles and transpose back to (batch_size, n_quantiles, model_prediction_length)
+            prediction = torch.quantile(prediction, q=quantile_tensor, dim=1).transpose(0, 1)
 
             predictions.append(prediction)
             remaining -= prediction.shape[-1]
 
-            if remaining <= 0:
-                break
-
-            central_idx = torch.abs(torch.tensor(self.quantiles) - 0.5).argmin()
-            central_prediction = prediction[:, central_idx]
-
-            context_tensor = torch.cat([context_tensor, central_prediction], dim=-1)
-
         return torch.cat(predictions, dim=-1)[..., :prediction_length]
 
     def predict_quantiles(

{autogluon.timeseries-1.3.2b20250629 → autogluon.timeseries-1.3.2b20250630}/src/autogluon/timeseries/version.py

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

{autogluon.timeseries-1.3.2b20250629 → autogluon.timeseries-1.3.2b20250630}/src/autogluon.timeseries.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: autogluon.timeseries
-Version: 1.3.2b20250629
+Version: 1.3.2b20250630
 Summary: Fast and Accurate ML in 3 Lines of Code
 Home-page: https://github.com/autogluon/autogluon
 Author: AutoGluon Community

{autogluon.timeseries-1.3.2b20250629 → autogluon.timeseries-1.3.2b20250630}/src/autogluon.timeseries.egg-info/requires.txt

@@ -17,10 +17,10 @@ fugue>=0.9.0
 tqdm<5,>=4.38
 orjson~=3.9
 tensorboard<3,>=2.9
-autogluon.core[raytune]==1.3.2b20250629
-autogluon.common==1.3.2b20250629
-autogluon.features==1.3.2b20250629
-autogluon.tabular[catboost,lightgbm,xgboost]==1.3.2b20250629
+autogluon.core[raytune]==1.3.2b20250630
+autogluon.common==1.3.2b20250630
+autogluon.features==1.3.2b20250630
+autogluon.tabular[catboost,lightgbm,xgboost]==1.3.2b20250630
 
 [all]