prediction-intervals
/prediction-intervals
Generates prediction intervals for time series forecasts using bootstrapping, conformal prediction, or built-in statistical model intervals. Covers interval configuration, residual management, and calibration. Use when the user needs uncertainty quantification for forecasts.
- Author
- skforecast ↗
- Repository
- skforecast-ai ↗
- Licence
- Apache-2.0
- Last repository change
- 16.10.2026
Assessment and security
- Files in this package
- 2
- Scripts
- 0
- HTML comments
- 0
- URLs in SKILL.md
- 1
No signals detected. Repository changed on 16.10.2026, without references to retired models or APIs.
Apache-2.0, otwarta: można używać i zmieniać, z zachowaniem licencji i informacji o zmianach.
What it does and when to use it
Generates prediction intervals for time series forecasts using bootstrapping, conformal prediction, or built-in statistical model intervals. Covers interval configuration, residual management, and calibration. Use when the user needs uncertainty quantification for forecasts.
Original author description
Generates prediction intervals for time series forecasts using bootstrapping, conformal prediction, or built-in statistical model intervals. Covers interval configuration, residual management, and calibration. Use when the user needs uncertainty quantification for forecasts.
How it works
- When to Use
- Intervals Are Quantiles
- Stop Conditions
- Bootstrapping Method
- Conformal Prediction
- Statistical Model Intervals
- Foundation Model Intervals
- During Backtesting
- Multi-Series Intervals
- Out-of-Sample Residuals (Better Calibration)
SKILL.md preview
---
name: prediction-intervals
description: >
Generates prediction intervals for time series forecasts using bootstrapping,
conformal prediction, or built-in statistical model intervals. Covers
interval configuration, residual management, and calibration.
Use when the user needs uncertainty quantification for forecasts.
---
# Prediction Intervals
## When to Use
Use prediction intervals to quantify forecast uncertainty. Skforecast offers three methods:
| Method | Forecasters | Description |
|--------|-------------|-------------|
| **Bootstrapping** | Recursive, Direct, RecursiveMultiSeries, DirectMultiVariate | Resample from training residuals |
| **Conformal** | All ML forecasters (incl. RNN, EquivalentDate) | Distribution-free intervals via conformal prediction |
| **Built-in** | ForecasterStats (ARIMA, ETS) | Parametric intervals from the statistical model |
### Choosing a method
- **Conformal**: distribution-free, fast, and gives a single symmetric coverage
guarantee. The default for multi-series forecasters and the only option for
`ForecasterRnn` / `ForecasterEquivalentDate`. Prefer it when you need a quick,
well-calibrated interval and do not need the full predictive distribution.
- **Bootstrapping**: resamples residuals to build the full predictive
distribution, so it also powers `predict_quantiles()` and `predict_dist()`.
Prefer it when you need arbitrary quantiles, a fitted distribution, or
asymmetric intervals. Needs enough stored residuals to be reliable.
- **Built-in**: parametric intervals from the statistical model itself
(`ForecasterStats`). No residual management required.
### Related skills
- **Prerequisite**: `forecasting-single-series` / `forecasting-multiple-series` (have a fitted forecaster before adding intervals)
- **Prerequisite**: `hyperparameter-optimization` (interval calibration assumes a tuned point forecaster)
- **Next**: `drift-detection` (monitor whether residual assumptions still hold once the model is in production)
## Intervals Are Quantiles
`interval` is expressed as **quantiles in `[0, 1]`**, not percentiles in
`[0, 100]`. For example, an 80% interval is `interval=[0.1, 0.9]`
(the default is `[0.05, 0.95]` = 90%).
- `interval` also accepts a single `float` as nominal coverage: `interval=0.95`
is equivalent to `interval=[0.025, 0.975]`.
- Mixing scales (e.g. `[0.1, 90]`) raises a `ValueError` (ambiguous scale).
- `predict_quantiles(quantiles=...)` uses the same 0-1 scale.
<details>
<summary>Old patterns: percentile intervals</summary>
Earlier versions took percentiles in `[0, 100]`, e.g. `interval=[10, 90]`.
Percentiles still work but emit a `FutureWarning` and will be removed in a
future release. Convert by dividing by 100, so `[10, 90]` becomes `[0.1, 0.9]`.
</details>
## Stop Conditions
Scan before writing code. Each row lists a rule, the symptom when it is broken, and the recovery. Full pitfall catalog: the `troubleshooting-common-errors` skill.
| Rule | Symptom | Recovery |
|------|---------|----------|
| Fit with `store_in_sample_residuals=True` before `predict_interval(method='bootstrapping')` | `No in-sample residuals stored` | Refit: `forecaster.fit(y=y_train, store_in_sample_residuals=True)` |
| Multi-series forecasters default to `method='conformal'`, not `'bootstrapping'` | Bootstrapping silently not applied on `ForecasterRecursiveMultiSeries` / `ForecasterDirectMultiVariate` | Pass `method='bootstrapping'` explicitly when that is what you want |
| ML forecasters accept `interval=`; only `ForecasterStats` accepts `alpha=` | `TypeError` / unexpected argument | Use `interval=[lower, upper]` for ML forecasters |
| `interval` must be quantiles in `[0, 1]`, not percentiles | `FutureWarning` (percentiles deprecated) | Use `interval=[0.1, 0.9]` instead of `interval=[10, 90]` |
| Do not mix quantile and percentile scales in one `interval` | `ValueError`: scale is ambiguous | Use a single scale, e.g. `interval=[0.05, 0.95]` |
## Bootstrapping Method
```python
from skforecast.recursive import ForecasterRecursive
from sklearn.ensemble import RandomForestRegressor
forecaster = ForecasterRecursive(
estimator=RandomForestRegressor(n_estimators=100, random_state=123),
lags=24,
)
# IMPORTANT: store_in_sample_residuals=True is required for bootstrapping
forecaster.fit(y=y_train, store_in_sample_residuals=True)
predictions = forecaster.predict_interval(
steps=10,
interval=[0.1, 0.9], # Quantiles → 80% interval (default is [0.05, 0.95] = 90%)
method='bootstrapping',
n_boot=250, # Number of bootstrap samples (default)
use_in_sample_residuals=True, # Use training residuals
use_binned_residuals=True, # Better calibration: residuals binned by prediction level
random_state=123,
)
# Returns: DataFrame with columns [pred, lower_bound, upper_bound]
```
## Conformal Prediction
```python
# IMPORTANT: store_in_sample_residuals=True is also required for conformal
forecaster.fit(y=y_train, store_in_sample_residuals=True)
predictions = forecaster.predict_interval(
steps=10,
interval=[0.1, 0.9],
method='conformal',
use_in_sample_residuals=True, # Uses in_sample_residuals_ stored during fit
use_binned_residuals=True,
)
```
## Statistical Model Intervals
```python
from skforecast.recursive import ForecasterStats
from skforecast.stats import Arima
forecaster = ForecasterStats(
estimator=Arima(order=(1, 1, 1), seasonal_order=(1, 1, 1), m=12)
)
forecaster.fit(y=y_train)
# Uses parametric intervals from statsmodels: different interface
predictions = forecaster.predict_interval(
steps=12,
interval=[0.1, 0.9], # Quantiles → 80% interval. Equivalently, alpha=0.2
)
```
## Foundation Model Intervals
`ForecasterFoundation` returns intervals and quantiles directly from the underlying foundation model's native quantile output, so no bootstrapping or conformal calibration is required.
```python
from skforecast.foundation import FoundationModel, ForecasterFoundation
forecaster = ForecasterFoundation(
estimator=FoundationModel(model_id='autogluon/chronos-2-small')
)
forecaster.fit(series=y_train)
predictions = forecaster.predict_interval(steps=24, interval=[0.1, 0.9])
predictions = forecaster.predict_quantiles(
steps=24, quantiles=[0.1, 0.5, 0.9]
)
```
TimesFM (2.5 and 3.0) and Moirai-2 restrict quantiles to `[0.1, 0.2, …, 0.9]`; TS-ICL restricts them to a 0.01 grid in `[0.01, 0.99]`; Chronos-2, TabICL, TabPFN-TS, TFC-T0, and Nori accept any quantile in `(0, 1)`. See the `foundation-forecasting` skill for details.
## During Backtesting
```python
from skforecast.model_selection import backtesting_forecaster, TimeSeriesFold
cv = TimeSeriesFold(
steps=10,
initial_train_size=len(y_train),
refit=False,
)
metric, predictions = backtesting_forecaster(
forecaster=forecaster,
y=data['target'],
cv=cv,
metric='mean_absolute_error',
interval=[0.1, 0.9],
interval_method='bootstrapping', # or 'conformal'
n_boot=250,
use_in_sample_residuals=True,
use_binned_residuals=True,
)
# predictions has columns: pred, lower_bound, upper_bound
```
## Multi-Series Intervals
```python
from skforecast.recursive import ForecasterRecursiveMultiSeries
# NOTE: default method for multi-series is 'conformal', not 'bootstrapping'
predictions = forecaster_multi.predict_interval(
steps=10,
levels=['series_1', 'series_2'],
interval=[0.1, 0.9],
method='conformal',
)
```
## Out-of-Sample Residuals (Better Calibration)
```python
# For better interval calibration, use out-of-sample residuals
# First, compute them via backtesting
metric, predictions_bt = backtesting_forecaster(
forecaster=forecaster,
y=data['target'],
cv=cv,
metric='mean_absolute_error',
)
# Set out-of-sample residuals on the forecaster
forecaster.set_out_sample_residuals(
y_true=data['target'].loc[predictions_bt.index],
y_pred=predictions_bt['pred'],
)
# Now use them for intervals
predictions = forecaster.predict_interval(
steps=10,
interval=[0.1, 0.9],
method='bootstrapping',
use_in_sample_residuals=False, # Use out-of-sample residuals
)
```
With binned residuals, keep an average of at least 10 out-of-sample residuals
per bin (100 residuals for the default `n_bins=10`). Below that,
`set_out_sample_residuals` issues a `ResidualsUsageWarning` and the intervals
tend to be too narrow: reduce the bins with `binner_kwargs={'n_bins': 3}` when
creating the forecaster, or predict with `use_binned_residuals=False`.
## Evaluating Interval Quality
```python
from skforecast.metrics import calculate_coverage
coverage = calculate_coverage(
y_true=y_test,
lower_bound=predictions['lower_bound'],
upper_bound=predictions['upper_bound'],
)
print(f"Coverage: {coverage:.2%}") # Should be close to 0.80 for [0.1, 0.9] interval
```
## Beyond Intervals
For bootstrapping-capable ML forecasters (Recursive, Direct, RecursiveMultiSeries,
DirectMultiVariate), two richer probabilistic outputs build on the same residual
resampling:
```python
# Arbitrary quantiles: returns one column per quantile (q_0.05, q_0.5, q_0.95)
predictions = forecaster.predict_quantiles(
steps=10,
quantiles=[0.05, 0.5, 0.95],
n_boot=250,
)
# Fit a scipy distribution to the bootstrapped predictions
from scipy.stats import norm
predictions = forecaster.predict_dist(
steps=10,
distribution=norm, # any scipy.stats distribution
n_boot=250,
)
```
See [references/interval-compatibility.md](references/interval-compatibility.md) for the full method/forecaster support matrix.
## Common Mistakes
1. **Passing percentiles instead of quantiles**: `interval` is on the 0-1 scale. Use `interval=[0.1, 0.9]`, not `[10, 90]` (percentiles are deprecated and emit a `FutureWarning`). Mixing scales, e.g. `[0.1, 90]`, raises a `ValueError`.
2. **Forgetting `store_in_sample_residuals=True`**: Required in `fit()` before using `predict_interval(method='bootstrapping')`.
3. **Wrong default method for multi-series**: `ForecasterRecursiveMultiSeries` and `ForecasterDirectMultiVariate` default to `method='conformal'`, not `'bootstrapping'`.
4. **Mixing `alpha` and `interval`**: `ForecasterStats` supports both `alpha` (e.g., `alpha=0.05` for 95% interval) and `interval=[lo, hi]` (quantiles). ML forecasters only support `interval`.
5. **Not evaluating coverage**: Always check if actual coverage matches nominal interval width.
6. **Ignoring physical bounds**: neither the model nor the intervals know that a series cannot be negative (counts, sales, demand), so predictions and lower bounds can fall below zero. Clip them after predicting, e.g. `predictions.clip(lower=0)`. See the FAQ [Non-negative predictions](https://skforecast.org/latest/faq/non-negative-predictions.html).
## References
See [references/interval-compatibility.md](references/interval-compatibility.md) for the complete compatibility matrix: which forecaster supports which method, parameter differences, binned residuals support, and common error patterns.
Files in this package (2)
- SKILL.md 11 KB
- references/interval-compatibility.md 7 KB
Versions
| Repository | Score | Licence |
|---|---|---|
| This page · skforecast/skforecast-ai | 100 | Apache-2.0 |
| skforecast/skforecast | 100 | BSD-3-Clause |
Identical content appears in 1 other GitHub folders. We show one copy with the highest score.
Database snapshot: 13.11.2026 · package version 3684c5c951d8 (SHA-256 digest of the entire package)
Downloads in the last 30 days: 0 · ranking
Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.
Similar skills
- 100nixtla-uncertainty-quantifier
Quantifies prediction uncertainty using conformal prediction. Use when risk assessment, scenario planning, or decision-making under uncertainty is required. Trigger with "quantify uncertainty", "generate prediction intervals", "confidence bands". - 100forecasting-single-series
Forecasts a single time series using ForecasterRecursive or ForecasterDirect. Covers data preparation, model creation, training, prediction, backtesting, and prediction intervals. Use when the user needs to predict future values of one time series. - 100conformal-methods-reviewer
Review any conformal prediction idea, draft, result, method, or theoretical argument for correctness, validity of coverage guarantees, and soundness of assumptions. Use when working on conformal prediction, prediction intervals, selective prediction, uncertainty quantification,… - 100timesfm
Forecasts time series with Google's pretrained TimesFM foundation model, zero-shot and with no training step. Use when the user asks to forecast sales or demand, predict server metrics, get prediction intervals, add covariates, or flag anomalies against a forecast without building a custom model. - 95timesfm-forecasting
Zero-shot time series forecasting with Google's TimesFM foundation model. Use for any univariate time series (sales, sensors, energy, vitals, weather) without training a custom model. Supports CSV/DataFrame/array inputs with point forecasts and prediction intervals. Includes a… - 100time-series-forecasting
Use when forecasting many related hourly or daily series, such as energy demand a day ahead: baselines to beat, leakage-free backtests, MASE scored on history, statistical and gradient-boosting models, totals that add up, conformal intervals and a buy level from costs, Prophet…