Forecasting API

tirex2.ForecastModel

High-level, batched forecasting interface around a TiRex2 backbone.

The wrapper takes ownership of the model only as a delegate: it batches the TimeseriesType it is given (building them from a GluonTS dataset in forecast_gluon), feeds them to TiRex2.predict, and formats the per-series quantile forecasts into the requested output type. Attribute access falls through to the wrapped model, so the backbone's own methods (e.g. predict) remain reachable on the wrapper.

Parameters:

Name	Type	Description	Default
model	TiRex2	An instantiated, ready-for-inference backbone exposing predict(timeseries: list[TimeseriesType], prediction_length: int) -> list[Tensor] and a quantiles buffer holding the quantile levels it forecasts.	required

Source code in src/tirex2/api_adapter/forecast.py

class ForecastModel:
    """High-level, batched forecasting interface around a ``TiRex2`` backbone.

    The wrapper takes ownership of the model only as a delegate: it batches the
    ``TimeseriesType`` it is given (building them from a GluonTS
    dataset in ``forecast_gluon``), feeds them to ``TiRex2.predict``, and formats the
    per-series quantile forecasts into the requested output type. Attribute access falls
    through to the wrapped model, so the backbone's own methods (e.g. ``predict``) remain
    reachable on the wrapper.

    Parameters
    ----------
    model : TiRex2
        An instantiated, ready-for-inference backbone exposing
        ``predict(timeseries: list[TimeseriesType], prediction_length: int) -> list[Tensor]``
        and a ``quantiles`` buffer holding the quantile levels it forecasts.
    """

    def __init__(self, model):
        self.model = model

    def _quantile_levels(self) -> list[float]:
        """Return the model's forecast quantile levels as clean Python floats (float32 noise rounded off)."""
        return [round(float(q), 6) for q in self.model.quantiles]

    def __getattr__(self, name):
        """Delegate unknown attribute lookups to the wrapped model."""
        try:
            model = object.__getattribute__(self, "model")
        except AttributeError:
            raise AttributeError(name)
        return getattr(model, name)

    def forecast(
        self,
        timeseries: list[TimeseriesType],
        prediction_length: int,
        *,
        output_type: ForecastOutputType = "torch",
        batch_size: int = 512,
        yield_per_batch: bool = False,
        **predict_kwargs,
    ):
        """Forecast a list of ``TimeseriesType`` objects, each with a target and optional covariates.

        Extra ``predict_kwargs`` are forwarded verbatim to ``TiRex2.predict``.
        In particular ``tta_sign_flip`` controls sign-flip test-time augmentation
        (roughly doubles inference cost), and ``tta_diff`` controls postprocessor
        differencing; when omitted, the checkpoint's configured defaults
        (``model-config.yaml``) are used. Pass ``True``/``False`` to override.

        Examples
        --------
        >>> import torch
        >>> from tirex2 import TimeseriesType, load_model
        >>> model = load_model("NX-AI/TiRex-2", device="cpu")
        >>> ts = TimeseriesType(target=torch.randn(1, 128), past_covariates=None, future_covariates=None)
        >>> forecasts = model.forecast([ts], prediction_length=32, output_type="numpy")
        >>> forecasts[0].shape
        (1, 9, 32)
        """
        return _gen_forecast(
            self.model,
            list(timeseries),
            None,
            prediction_length,
            output_type=output_type,
            batch_size=batch_size,
            yield_per_batch=yield_per_batch,
            quantile_levels=self._quantile_levels(),
            **predict_kwargs,
        )

    def forecast_gluon(
        self,
        gluonDataset,
        prediction_length: int,
        *,
        output_type: ForecastOutputType = "torch",
        batch_size: int = 512,
        yield_per_batch: bool = False,
        multivariate: bool = False,
        data_kwargs: dict | None = None,
        **predict_kwargs,
    ):
        """Forecast every entry of a GluonTS dataset, carrying its covariates and metadata through.

        With ``multivariate=False`` (default) each target variate is rendered as its own
        univariate ``QuantileForecast``; with ``multivariate=True`` each series yields a single
        forecast retaining the variate axis, so a multivariate dataset is scored jointly rather
        than channel-by-channel. The flag only affects ``output_type="gluonts"`` formatting.

        Extra ``predict_kwargs`` are forwarded verbatim to ``TiRex2.predict``.
        In particular ``tta_sign_flip`` controls sign-flip test-time augmentation
        (roughly doubles inference cost), and ``tta_diff`` controls postprocessor
        differencing; when omitted, the checkpoint's configured defaults
        (``model-config.yaml``) are used. Pass ``True``/``False`` to override.
        """
        try:
            from .gluon import build_gluon_timeseries
        except ImportError:
            raise ValueError("forecast_gluon needs GluonTS but GluonTS is not available (not installed)!")

        timeseries, meta = build_gluon_timeseries(gluonDataset, multivariate=multivariate, **(data_kwargs or {}))
        return _gen_forecast(
            self.model,
            timeseries,
            meta,
            prediction_length,
            output_type=output_type,
            batch_size=batch_size,
            yield_per_batch=yield_per_batch,
            quantile_levels=self._quantile_levels(),
            **predict_kwargs,
        )

    def forecast_df(
        self,
        df: "IntoDataFrame",
        prediction_length: int,
        *,
        id_column: str | None = None,
        timestamp_column: str | None = None,
        target: "str | Sequence[str] | None" = None,
        past_covariates: "str | Sequence[str] | None" = None,
        future_covariates: "str | Sequence[str] | None" = None,
        future_df: "IntoDataFrame | None" = None,
        output_type: Literal["dataframe", "pandas"] = "dataframe",
        batch_size: int = 512,
        yield_per_batch: bool = False,
        **predict_kwargs,
    ):
        """Forecast one or more series from an eager dataframe.

        ``df`` can be any eager dataframe supported by
        [narwhals](https://narwhals-dev.github.io/narwhals/). Use ``id_column`` for multiple
        series and ``timestamp_column`` or a pandas ``DatetimeIndex`` for the time axis.
        By default, all numeric columns except ids, timestamps and covariates are targets.

        **Joint Forecasting**: Targets within a series are forecast jointly. To forecast columns
        independently, reshape them into long format and identify each series with ``id_column``.

        **Future Covariates**: Supply known future covariate values in ``future_df``, using the same
        layout as ``df`` and timestamps that match the forecast steps. Past values of future
        covariates are taken from ``df``.

        **Output**: The result has one row per series, target and forecast step, with a median
        ``prediction`` and columns for each quantile. By default, it uses the same dataframe library
        as ``df``; set ``output_type="pandas"`` to get pandas instead.

        **Batching**: ``batch_size`` counts series, not rows. Set ``yield_per_batch=True`` to yield
        one result per batch. Extra ``predict_kwargs`` are passed to ``TiRex2.predict``.

        Examples
        --------
        Forecast monthly sales from a pandas dataframe:

        >>> import pandas as pd
        >>> from tirex2 import load_model
        >>> df = pd.DataFrame({
        ...     "timestamp": pd.date_range("2020-01-01", periods=24, freq="MS"),
        ...     "sales": range(24),
        ... })
        >>> model = load_model("NX-AI/TiRex-2", device="cpu")
        >>> forecast = model.forecast_df(df, 4, target="sales", timestamp_column="timestamp")
        >>> forecast
           timestamp target  prediction  ...        0.7        0.8        0.9
        0 2022-01-01  sales   23.985064  ...  24.005989  24.018473  24.036558
        1 2022-02-01  sales   24.975126  ...  25.003880  25.020775  25.046469
        2 2022-03-01  sales   25.964767  ...  26.000420  26.020782  26.051968
        3 2022-04-01  sales   26.956121  ...  26.995924  27.018373  27.053928
        [4 rows x 12 columns]

        Add a calendar feature whose future values are already known:

        >>> df["month"] = df["timestamp"].dt.month.astype("float32")
        >>> future_df = pd.DataFrame({"timestamp": pd.date_range("2022-01-01", periods=4, freq="MS")})
        >>> future_df["month"] = future_df["timestamp"].dt.month.astype("float32")
        >>> forecast = model.forecast_df(
        ...     df, 4, target="sales", timestamp_column="timestamp",
        ...     future_covariates="month", future_df=future_df,
        ... )
        >>> forecast
           timestamp target  prediction  ...        0.7        0.8        0.9
        0 2022-01-01  sales   23.984356  ...  24.001610  24.012691  24.030060
        1 2022-02-01  sales   24.972900  ...  24.998695  25.014589  25.039955
        2 2022-03-01  sales   25.958410  ...  25.990089  26.009071  26.039722
        3 2022-04-01  sales   26.944197  ...  26.980700  27.002466  27.038290
        [4 rows x 12 columns]

        See the [dataframe how-to guide](../how-to/dataframes.md) for more examples.

        ???+ warning "Calendar-aware inference"
            Without ``pandas`` installed, the forecast time step is estimated from the most common
            gap between input timestamps. Calendar schedules such as month starts and local times
            across daylight-saving changes may drift. Install ``pandas`` for calendar-aware inference.

        """
        if output_type not in ("dataframe", "pandas"):
            raise ValueError(
                f"Invalid output type: {output_type!r}; forecast_df returns a dataframe and accepts only "
                "'dataframe' or 'pandas'. Use forecast() for torch, numpy, gluonts or fev output."
            )
        quantile_levels = self._quantile_levels()
        timeseries, meta = build_df_timeseries(
            df,
            prediction_length=prediction_length,
            id_column=id_column,
            timestamp_column=timestamp_column,
            target=target,
            past_covariates=past_covariates,
            future_covariates=future_covariates,
            future_df=future_df,
        )
        if meta:
            validate_output_columns(id_column, meta[0]["timestamp_column"], quantile_levels)
        return _gen_forecast(
            self.model,
            timeseries,
            meta,
            prediction_length,
            output_type=output_type,
            batch_size=batch_size,
            yield_per_batch=yield_per_batch,
            quantile_levels=quantile_levels,
            **predict_kwargs,
        )

    def forecast_fev(
        self,
        window: "fev.EvaluationWindow",
        prediction_length: int,
        *,
        output_type: ForecastOutputType = "torch",
        batch_size: int = 512,
        yield_per_batch: bool = False,
        data_kwargs: dict | None = None,
        quantile_levels: list[float] | None = None,
        return_inference_time: bool = False,
        **predict_kwargs,
    ):
        """Forecast a single FEV evaluation window.

        The call mirrors ``forecast_gluon``: convert the external dataset
        representation into ``TimeseriesType``, then delegate batching,
        prediction and output rendering to the common forecast path. Use
        ``output_type="fev"`` to return predictions in the format accepted by
        ``fev.Task.evaluation_summary``. Pass ``return_inference_time=True`` to
        also return the model-only prediction time, excluding FEV input
        conversion and final ``DatasetDict`` construction.
        """
        try:
            import fev  # noqa: F401
        except ImportError:
            raise ValueError("forecast_fev needs fev but fev is not available (not installed)!")

        data_kwargs = data_kwargs or {}
        timeseries, meta = build_fev_timeseries(window, **data_kwargs)
        if output_type == "fev":
            requested_quantiles = quantile_levels if quantile_levels is not None else self._quantile_levels()
            for item in meta:
                item["quantile_levels"] = requested_quantiles

        return _gen_forecast(
            self.model,
            timeseries,
            meta,
            prediction_length,
            output_type=output_type,
            batch_size=batch_size,
            yield_per_batch=yield_per_batch,
            quantile_levels=self._quantile_levels(),
            return_inference_time=return_inference_time,
            **predict_kwargs,
        )

forecast

forecast(
    timeseries: list[TimeseriesType],
    prediction_length: int,
    *,
    output_type: ForecastOutputType = "torch",
    batch_size: int = 512,
    yield_per_batch: bool = False,
    **predict_kwargs,
)

Forecast a list of TimeseriesType objects, each with a target and optional covariates.

Extra predict_kwargs are forwarded verbatim to TiRex2.predict. In particular tta_sign_flip controls sign-flip test-time augmentation (roughly doubles inference cost), and tta_diff controls postprocessor differencing; when omitted, the checkpoint's configured defaults (model-config.yaml) are used. Pass True/False to override.

Examples:

>>> import torch
>>> from tirex2 import TimeseriesType, load_model
>>> model = load_model("NX-AI/TiRex-2", device="cpu")
>>> ts = TimeseriesType(target=torch.randn(1, 128), past_covariates=None, future_covariates=None)
>>> forecasts = model.forecast([ts], prediction_length=32, output_type="numpy")
>>> forecasts[0].shape
(1, 9, 32)

Source code in src/tirex2/api_adapter/forecast.py

def forecast(
    self,
    timeseries: list[TimeseriesType],
    prediction_length: int,
    *,
    output_type: ForecastOutputType = "torch",
    batch_size: int = 512,
    yield_per_batch: bool = False,
    **predict_kwargs,
):
    """Forecast a list of ``TimeseriesType`` objects, each with a target and optional covariates.

    Extra ``predict_kwargs`` are forwarded verbatim to ``TiRex2.predict``.
    In particular ``tta_sign_flip`` controls sign-flip test-time augmentation
    (roughly doubles inference cost), and ``tta_diff`` controls postprocessor
    differencing; when omitted, the checkpoint's configured defaults
    (``model-config.yaml``) are used. Pass ``True``/``False`` to override.

    Examples
    --------
    >>> import torch
    >>> from tirex2 import TimeseriesType, load_model
    >>> model = load_model("NX-AI/TiRex-2", device="cpu")
    >>> ts = TimeseriesType(target=torch.randn(1, 128), past_covariates=None, future_covariates=None)
    >>> forecasts = model.forecast([ts], prediction_length=32, output_type="numpy")
    >>> forecasts[0].shape
    (1, 9, 32)
    """
    return _gen_forecast(
        self.model,
        list(timeseries),
        None,
        prediction_length,
        output_type=output_type,
        batch_size=batch_size,
        yield_per_batch=yield_per_batch,
        quantile_levels=self._quantile_levels(),
        **predict_kwargs,
    )

forecast_gluon

forecast_gluon(
    gluonDataset,
    prediction_length: int,
    *,
    output_type: ForecastOutputType = "torch",
    batch_size: int = 512,
    yield_per_batch: bool = False,
    multivariate: bool = False,
    data_kwargs: dict | None = None,
    **predict_kwargs,
)

Forecast every entry of a GluonTS dataset, carrying its covariates and metadata through.

With multivariate=False (default) each target variate is rendered as its own univariate QuantileForecast; with multivariate=True each series yields a single forecast retaining the variate axis, so a multivariate dataset is scored jointly rather than channel-by-channel. The flag only affects output_type="gluonts" formatting.

Extra predict_kwargs are forwarded verbatim to TiRex2.predict. In particular tta_sign_flip controls sign-flip test-time augmentation (roughly doubles inference cost), and tta_diff controls postprocessor differencing; when omitted, the checkpoint's configured defaults (model-config.yaml) are used. Pass True/False to override.

Source code in src/tirex2/api_adapter/forecast.py

def forecast_gluon(
    self,
    gluonDataset,
    prediction_length: int,
    *,
    output_type: ForecastOutputType = "torch",
    batch_size: int = 512,
    yield_per_batch: bool = False,
    multivariate: bool = False,
    data_kwargs: dict | None = None,
    **predict_kwargs,
):
    """Forecast every entry of a GluonTS dataset, carrying its covariates and metadata through.

    With ``multivariate=False`` (default) each target variate is rendered as its own
    univariate ``QuantileForecast``; with ``multivariate=True`` each series yields a single
    forecast retaining the variate axis, so a multivariate dataset is scored jointly rather
    than channel-by-channel. The flag only affects ``output_type="gluonts"`` formatting.

    Extra ``predict_kwargs`` are forwarded verbatim to ``TiRex2.predict``.
    In particular ``tta_sign_flip`` controls sign-flip test-time augmentation
    (roughly doubles inference cost), and ``tta_diff`` controls postprocessor
    differencing; when omitted, the checkpoint's configured defaults
    (``model-config.yaml``) are used. Pass ``True``/``False`` to override.
    """
    try:
        from .gluon import build_gluon_timeseries
    except ImportError:
        raise ValueError("forecast_gluon needs GluonTS but GluonTS is not available (not installed)!")

    timeseries, meta = build_gluon_timeseries(gluonDataset, multivariate=multivariate, **(data_kwargs or {}))
    return _gen_forecast(
        self.model,
        timeseries,
        meta,
        prediction_length,
        output_type=output_type,
        batch_size=batch_size,
        yield_per_batch=yield_per_batch,
        quantile_levels=self._quantile_levels(),
        **predict_kwargs,
    )

forecast_df

forecast_df(
    df: IntoDataFrame,
    prediction_length: int,
    *,
    id_column: str | None = None,
    timestamp_column: str | None = None,
    target: str | Sequence[str] | None = None,
    past_covariates: str | Sequence[str] | None = None,
    future_covariates: str | Sequence[str] | None = None,
    future_df: IntoDataFrame | None = None,
    output_type: Literal[
        "dataframe", "pandas"
    ] = "dataframe",
    batch_size: int = 512,
    yield_per_batch: bool = False,
    **predict_kwargs,
)

Forecast one or more series from an eager dataframe.

df can be any eager dataframe supported by narwhals. Use id_column for multiple series and timestamp_column or a pandas DatetimeIndex for the time axis. By default, all numeric columns except ids, timestamps and covariates are targets.

Joint Forecasting: Targets within a series are forecast jointly. To forecast columns independently, reshape them into long format and identify each series with id_column.

Future Covariates: Supply known future covariate values in future_df, using the same layout as df and timestamps that match the forecast steps. Past values of future covariates are taken from df.

Output: The result has one row per series, target and forecast step, with a median prediction and columns for each quantile. By default, it uses the same dataframe library as df; set output_type="pandas" to get pandas instead.

Batching: batch_size counts series, not rows. Set yield_per_batch=True to yield one result per batch. Extra predict_kwargs are passed to TiRex2.predict.

Examples:

Forecast monthly sales from a pandas dataframe:

>>> import pandas as pd
>>> from tirex2 import load_model
>>> df = pd.DataFrame({
...     "timestamp": pd.date_range("2020-01-01", periods=24, freq="MS"),
...     "sales": range(24),
... })
>>> model = load_model("NX-AI/TiRex-2", device="cpu")
>>> forecast = model.forecast_df(df, 4, target="sales", timestamp_column="timestamp")
>>> forecast
   timestamp target  prediction  ...        0.7        0.8        0.9
0 2022-01-01  sales   23.985064  ...  24.005989  24.018473  24.036558
1 2022-02-01  sales   24.975126  ...  25.003880  25.020775  25.046469
2 2022-03-01  sales   25.964767  ...  26.000420  26.020782  26.051968
3 2022-04-01  sales   26.956121  ...  26.995924  27.018373  27.053928
[4 rows x 12 columns]

Add a calendar feature whose future values are already known:

>>> df["month"] = df["timestamp"].dt.month.astype("float32")
>>> future_df = pd.DataFrame({"timestamp": pd.date_range("2022-01-01", periods=4, freq="MS")})
>>> future_df["month"] = future_df["timestamp"].dt.month.astype("float32")
>>> forecast = model.forecast_df(
...     df, 4, target="sales", timestamp_column="timestamp",
...     future_covariates="month", future_df=future_df,
... )
>>> forecast
   timestamp target  prediction  ...        0.7        0.8        0.9
0 2022-01-01  sales   23.984356  ...  24.001610  24.012691  24.030060
1 2022-02-01  sales   24.972900  ...  24.998695  25.014589  25.039955
2 2022-03-01  sales   25.958410  ...  25.990089  26.009071  26.039722
3 2022-04-01  sales   26.944197  ...  26.980700  27.002466  27.038290
[4 rows x 12 columns]

See the dataframe how-to guide for more examples.

Calendar-aware inference

Without pandas installed, the forecast time step is estimated from the most common gap between input timestamps. Calendar schedules such as month starts and local times across daylight-saving changes may drift. Install pandas for calendar-aware inference.

Source code in src/tirex2/api_adapter/forecast.py

def forecast_df(
    self,
    df: "IntoDataFrame",
    prediction_length: int,
    *,
    id_column: str | None = None,
    timestamp_column: str | None = None,
    target: "str | Sequence[str] | None" = None,
    past_covariates: "str | Sequence[str] | None" = None,
    future_covariates: "str | Sequence[str] | None" = None,
    future_df: "IntoDataFrame | None" = None,
    output_type: Literal["dataframe", "pandas"] = "dataframe",
    batch_size: int = 512,
    yield_per_batch: bool = False,
    **predict_kwargs,
):
    """Forecast one or more series from an eager dataframe.

    ``df`` can be any eager dataframe supported by
    [narwhals](https://narwhals-dev.github.io/narwhals/). Use ``id_column`` for multiple
    series and ``timestamp_column`` or a pandas ``DatetimeIndex`` for the time axis.
    By default, all numeric columns except ids, timestamps and covariates are targets.

    **Joint Forecasting**: Targets within a series are forecast jointly. To forecast columns
    independently, reshape them into long format and identify each series with ``id_column``.

    **Future Covariates**: Supply known future covariate values in ``future_df``, using the same
    layout as ``df`` and timestamps that match the forecast steps. Past values of future
    covariates are taken from ``df``.

    **Output**: The result has one row per series, target and forecast step, with a median
    ``prediction`` and columns for each quantile. By default, it uses the same dataframe library
    as ``df``; set ``output_type="pandas"`` to get pandas instead.

    **Batching**: ``batch_size`` counts series, not rows. Set ``yield_per_batch=True`` to yield
    one result per batch. Extra ``predict_kwargs`` are passed to ``TiRex2.predict``.

    Examples
    --------
    Forecast monthly sales from a pandas dataframe:

    >>> import pandas as pd
    >>> from tirex2 import load_model
    >>> df = pd.DataFrame({
    ...     "timestamp": pd.date_range("2020-01-01", periods=24, freq="MS"),
    ...     "sales": range(24),
    ... })
    >>> model = load_model("NX-AI/TiRex-2", device="cpu")
    >>> forecast = model.forecast_df(df, 4, target="sales", timestamp_column="timestamp")
    >>> forecast
       timestamp target  prediction  ...        0.7        0.8        0.9
    0 2022-01-01  sales   23.985064  ...  24.005989  24.018473  24.036558
    1 2022-02-01  sales   24.975126  ...  25.003880  25.020775  25.046469
    2 2022-03-01  sales   25.964767  ...  26.000420  26.020782  26.051968
    3 2022-04-01  sales   26.956121  ...  26.995924  27.018373  27.053928
    [4 rows x 12 columns]

    Add a calendar feature whose future values are already known:

    >>> df["month"] = df["timestamp"].dt.month.astype("float32")
    >>> future_df = pd.DataFrame({"timestamp": pd.date_range("2022-01-01", periods=4, freq="MS")})
    >>> future_df["month"] = future_df["timestamp"].dt.month.astype("float32")
    >>> forecast = model.forecast_df(
    ...     df, 4, target="sales", timestamp_column="timestamp",
    ...     future_covariates="month", future_df=future_df,
    ... )
    >>> forecast
       timestamp target  prediction  ...        0.7        0.8        0.9
    0 2022-01-01  sales   23.984356  ...  24.001610  24.012691  24.030060
    1 2022-02-01  sales   24.972900  ...  24.998695  25.014589  25.039955
    2 2022-03-01  sales   25.958410  ...  25.990089  26.009071  26.039722
    3 2022-04-01  sales   26.944197  ...  26.980700  27.002466  27.038290
    [4 rows x 12 columns]

    See the [dataframe how-to guide](../how-to/dataframes.md) for more examples.

    ???+ warning "Calendar-aware inference"
        Without ``pandas`` installed, the forecast time step is estimated from the most common
        gap between input timestamps. Calendar schedules such as month starts and local times
        across daylight-saving changes may drift. Install ``pandas`` for calendar-aware inference.

    """
    if output_type not in ("dataframe", "pandas"):
        raise ValueError(
            f"Invalid output type: {output_type!r}; forecast_df returns a dataframe and accepts only "
            "'dataframe' or 'pandas'. Use forecast() for torch, numpy, gluonts or fev output."
        )
    quantile_levels = self._quantile_levels()
    timeseries, meta = build_df_timeseries(
        df,
        prediction_length=prediction_length,
        id_column=id_column,
        timestamp_column=timestamp_column,
        target=target,
        past_covariates=past_covariates,
        future_covariates=future_covariates,
        future_df=future_df,
    )
    if meta:
        validate_output_columns(id_column, meta[0]["timestamp_column"], quantile_levels)
    return _gen_forecast(
        self.model,
        timeseries,
        meta,
        prediction_length,
        output_type=output_type,
        batch_size=batch_size,
        yield_per_batch=yield_per_batch,
        quantile_levels=quantile_levels,
        **predict_kwargs,
    )

forecast_fev

forecast_fev(
    window: EvaluationWindow,
    prediction_length: int,
    *,
    output_type: ForecastOutputType = "torch",
    batch_size: int = 512,
    yield_per_batch: bool = False,
    data_kwargs: dict | None = None,
    quantile_levels: list[float] | None = None,
    return_inference_time: bool = False,
    **predict_kwargs,
)

Forecast a single FEV evaluation window.

The call mirrors forecast_gluon: convert the external dataset representation into TimeseriesType, then delegate batching, prediction and output rendering to the common forecast path. Use output_type="fev" to return predictions in the format accepted by fev.Task.evaluation_summary. Pass return_inference_time=True to also return the model-only prediction time, excluding FEV input conversion and final DatasetDict construction.

Source code in src/tirex2/api_adapter/forecast.py

def forecast_fev(
    self,
    window: "fev.EvaluationWindow",
    prediction_length: int,
    *,
    output_type: ForecastOutputType = "torch",
    batch_size: int = 512,
    yield_per_batch: bool = False,
    data_kwargs: dict | None = None,
    quantile_levels: list[float] | None = None,
    return_inference_time: bool = False,
    **predict_kwargs,
):
    """Forecast a single FEV evaluation window.

    The call mirrors ``forecast_gluon``: convert the external dataset
    representation into ``TimeseriesType``, then delegate batching,
    prediction and output rendering to the common forecast path. Use
    ``output_type="fev"`` to return predictions in the format accepted by
    ``fev.Task.evaluation_summary``. Pass ``return_inference_time=True`` to
    also return the model-only prediction time, excluding FEV input
    conversion and final ``DatasetDict`` construction.
    """
    try:
        import fev  # noqa: F401
    except ImportError:
        raise ValueError("forecast_fev needs fev but fev is not available (not installed)!")

    data_kwargs = data_kwargs or {}
    timeseries, meta = build_fev_timeseries(window, **data_kwargs)
    if output_type == "fev":
        requested_quantiles = quantile_levels if quantile_levels is not None else self._quantile_levels()
        for item in meta:
            item["quantile_levels"] = requested_quantiles

    return _gen_forecast(
        self.model,
        timeseries,
        meta,
        prediction_length,
        output_type=output_type,
        batch_size=batch_size,
        yield_per_batch=yield_per_batch,
        quantile_levels=self._quantile_levels(),
        return_inference_time=return_inference_time,
        **predict_kwargs,
    )