StatsForecast

https://nixtlaverse.nixtla.io/statsforecast
Admin
StatsForecast is a Python library for lightning-fast statistical and econometric time series...
Tokens:123,124
Snippets:1,896
Trust Score:9
Update:1 month ago
Show doc for...
Tokens:
Raw
### Install required forecasting libraries

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/tutorials/electricityloadforecasting.html

Install the necessary packages including StatsForecast, Prophet, and NeuralProphet to run the tutorial examples.

```python
# !pip install statsforecast "neuralprophet[live]" prophet
```

--------------------------------

### Install dependencies

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/experiments/autoarima_vs_prophet.html

Install the necessary libraries for the experiment.

```python
%%capture
# !pip install statsforecast prophet statsmodels sklearn matplotlib pmdarima
```

--------------------------------

### Install StatsForecast

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/models/mfles.html

Install the library using pip.

```python
# %pip install statsforecast
```

--------------------------------

### Install required libraries

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/experiments/prophet_spark_m5.html

Install the necessary packages for running the benchmark.

```python
pip install prophet "neuralforecast<1.0.0" "statsforecast[fugue]"
```

--------------------------------

### Install statsforecast and load data

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/how-to-guides/automatic_forecasting.html

Install the library and load the Air Passengers dataset for demonstration.

```python
# uncomment the following line to install the library
# %pip install statsforecast
```

```python
from statsforecast.utils import AirPassengersDF
```

```python
Y_df = AirPassengersDF
```

--------------------------------

### Install yfinance

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/tutorials/garch_tutorial.html

Install the yfinance library to download financial data.

```python
%%capture
# pip install yfinance
```

--------------------------------

### Install StatsForecast

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/tutorials/simulation.html

Install the StatsForecast library using pip.

```python
%pip install -U statsforecast
```

--------------------------------

### Install StatsForecast

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/getting-started/getting_started_short.html

Use this command to install the library if it is not already present in your environment.

```python
# uncomment the following line to install the library
# %pip install statsforecast
```

--------------------------------

### Install with extras

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/getting-started/installation.html

Syntax for installing optional features like polars, plotly, dask, spark, or ray.

```shell
pip install 'statsforecast[extra1,extra2]'
```

--------------------------------

### Install required libraries

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/tutorials/statisticalneuralmethods.html

Install the necessary forecasting and data handling libraries using pip.

```python
%%capture
!pip install statsforecast mlforecast neuralforecast datasetforecast s3fs pyarrow
```

--------------------------------

### Install StatsForecast library

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/tutorials/multipleseasonalities.html

Install the necessary package via pip.

```python
!pip install statsforecast
```

--------------------------------

### Install StatsForecast

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/tutorials/anomalydetection.html

Use pip to install or upgrade the StatsForecast library.

```bash
pip install statsforecast -U
```

--------------------------------

### Install StatsForecast

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/experiments/autoarimaprophet_adapter.html

Install the required package via pip.

```bash
pip install statsforecast
```

--------------------------------

### Importing necessary libraries

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/how-to-guides/sklearn_models.html

Initial setup for data handling, feature engineering, and model definition.

```python
from functools import partial

from datasetsforecast.m4 import M4, M4Info
from sklearn.linear_model import Lasso, Ridge
from utilsforecast.feature_engineering import pipeline, trend, fourier
from utilsforecast.plotting import plot_series

from statsforecast import StatsForecast
from statsforecast.models import SklearnModel
from statsforecast.utils import ConformalIntervals
```

--------------------------------

### Example Output Logs

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/tutorials/mlflow.html

Sample output showing metrics and MLflow run information.

```text
Metrics: 
{'mae': 6.712853959225143, 'mape': 0.11719246764336884}

MLflow run id:
0319bbd664424fcd88d6c532e3ecac77
```

```text
2023/10/20 23:45:36 WARNING mlflow.utils.environment: Encountered an unexpected error while inferring pip requirements (model URI: /var/folders/w2/91_v34nx0xs2npnl3zsl9tmm0000gn/T/tmpt4686vpu/model/model.pkl, flavor: statsforecast), fall back to return ['statsforecast==1.6.0']. Set logging level to DEBUG to see the full traceback.
```

--------------------------------

### Install dependencies

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/experiments/amazonstatsforecast.html

Install the StatsForecast library and s3fs for S3 filesystem support.

```python
%%capture
!pip install statsforecast s3fs
```

--------------------------------

### Install StatsForecast

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/tutorials/conformalprediction.html

Install or update the StatsForecast library using pip.

```python
%%capture
pip install statsforecast -U
```

--------------------------------

### Install StatsForecast and dependencies

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/experiments/ets_ray_m5.html

Installs the required libraries for distributed forecasting with Ray.

```python
%%capture
!pip install "statsforecast[ray]" neuralforecast s3fs pyarrow
```

--------------------------------

### Fixed Coefficients Example

Source: https://nixtlaverse.nixtla.io/statsforecast/src/core/models.html

Example format for the fixed parameter dictionary.

```python
{'ar1': 0.5, 'ar5': 0.75}
```

--------------------------------

### Install development versions

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/getting-started/installation.html

Commands to install the latest features from nightly wheels or directly from the GitHub repository.

```shell
pip install --extra-index-url=http://nixtla-packages.s3-website.us-east-2.amazonaws.com --trusted-host nixtla-packages.s3-website.us-east-2.amazonaws.com statsforecast
```

```shell
pip install git+https://github.com/Nixtla/statsforecast
```

--------------------------------

### Install specific version

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/getting-started/installation.html

Recommended approach to fix the library version to avoid compatibility issues.

```shell
pip install statsforecast=="1.0.0"
```

--------------------------------

### Install MLFlow Dependencies

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/tutorials/mlflow.html

Install the required packages for MLFlow integration.

```bash
pip install mlflow mlflavors
```

--------------------------------

### Setup Data for MSTL Decomposition

Source: https://nixtlaverse.nixtla.io/statsforecast/src/feature_engineering.html

Initializes a sample time series dataset for use with decomposition models.

```python
import pandas as pd
from fastcore.test import test_fail
from utilsforecast.losses import smape

from statsforecast.models import Naive
from statsforecast.utils import generate_series

series = generate_series(10, freq='D')
series['unique_id'] = series['unique_id'].astype('int64')
```

--------------------------------

### Launch MLflow UI

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/tutorials/mlflow.html

Command to start the local MLflow server for viewing experiments and artifacts.

```bash
mlflow ui
```

--------------------------------

### Install Mamba and Dependencies

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/contribute/step-by-step.html

Commands to install the Mamba package manager and update the environment using the project configuration file.

```bash
conda install mamba -c conda-forge
```

```text
mamba env update -f environment.yml
```

```bash
mamba env update -f dev/environment.yml
```

--------------------------------

### Execution Time Output

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/experiments/ets_ray_m5.html

Example output showing the time taken for the forecast.

```text
Minutes taken by StatsForecast using: 5.4817593971888225
```

--------------------------------

### Forecast execution time output

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/experiments/amazonstatsforecast.html

Example output showing the time taken for the forecast execution.

```text
Statsforecast time M5 14.274124479293823
```

--------------------------------

### Install StatsForecast in editable mode

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/contribute/step-by-step.html

Use this command to link the package to the source code, ensuring changes are immediately reflected in the environment.

```bash
pip install -e ".[dev]"
```

--------------------------------

### Install StatsForecast via package managers

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/getting-started/installation.html

Standard commands to install the released version of StatsForecast using pip or conda.

```shell
pip install statsforecast
```

```shell
conda install -c conda-forge statsforecast
```

--------------------------------

### Import StatsForecast and Configure Environment

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/tutorials/crossvalidation.html

Initializes the environment and imports the StatsForecast class.

```python
import os
os.environ['NIXTLA_ID_AS_COL'] = '1'

from statsforecast import StatsForecast # required to instantiate StatsForecast object and use cross-validation method
```

--------------------------------

### Serve MLflow model via CLI

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/tutorials/mlflow.html

Run this command in your terminal to start the local REST API server for the specified model run.

```bash
mlflow models serve -m runs:/<run_id>/model --env-manager local --host 127.0.0.1
```

--------------------------------

### Install Seaborn dependency

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/tutorials/statisticalneuralmethods.html

Installs the seaborn library for data visualization.

```python
%%capture
!pip install seaborn
```

--------------------------------

### Instantiating the ADIDA Model

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/models/adida.html

Setting up the model instance with specific parameters.

```python
season_length = 52 # Hourly data
horizon = len(test) # number of predictions

# We call the model that we are going to use
models = [ADIDA()]
```

--------------------------------

### Initialize Prophet Environment

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/experiments/prophet_spark_m5.html

Imports necessary libraries and configures logging levels for Prophet.

```python
import logging
from time import time

import pandas as pd
from neuralforecast.data.datasets.m5 import M5, M5Evaluation
from prophet import Prophet
from pyspark.sql.types import *

# disable informational messages from prophet
logging.getLogger('py4j').setLevel(logging.ERROR)
```

--------------------------------

### Instantiating the Model

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/models/crostonsba.html

Define the horizon and initialize the model list.

```python
season_length = 24 # Hourly data
horizon = len(test) # number of predictions

# We call the model that we are going to use
models = [CrostonSBA()]
```

--------------------------------

### Instantiating the Model

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/models/crostonoptimized.html

Define the horizon and initialize the model list.

```python
season_length = 24 # Hourly data
horizon = len(test) # number of predictions

# We call the model that we are going to use
models = [CrostonOptimized()]
```

--------------------------------

### RMSE Output Example

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/tutorials/crossvalidation.html

Example output showing the calculated RMSE value.

```text
RMSE using cross-validation: 32.21
```

--------------------------------

### Instantiate Model

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/models/crostonclassic.html

Setting up the horizon and instantiating the CrostonClassic model.

```python
season_length = 24 # Hourly data
horizon = len(test) # number of predictions

models = [CrostonClassic()]
```

--------------------------------

### Configure and instantiate the model

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/models/seasonalexponentialsmoothingoptimized.html

Define the seasonal length and horizon, then initialize the model list.

```python
season_length = 24 # Hourly data
horizon = len(test) # number of predictions

models = [SeasonalExponentialSmoothingOptimized(season_length=season_length)]
```

--------------------------------

### ADF test output example

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/models/autoregressive.html

Example output showing a non-stationary result.

```text
Dickey-Fuller test results for columns: Sales
Test Statistic          -1.589903
p-value                  0.488664
No Lags Used            14.000000
                          ...    
Critical Value (1%)     -3.451691
Critical Value (5%)     -2.870939
Critical Value (10%)    -2.571778
Length: 7, dtype: float64
Conclusion:====>
The null hypothesis cannot be rejected
The data is not stationary
```

--------------------------------

### Initialize Jupyter Environment

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/contribute/step-by-step.html

Launch the development environment to begin making changes.

```bash
jupyter lab
```

--------------------------------

### Load libraries and instantiate model

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/models/dynamicoptimizedtheta.html

Import necessary classes and configure the DynamicOptimizedTheta model with seasonal parameters.

```python
from statsforecast import StatsForecast
from statsforecast.models import DynamicOptimizedTheta
```

```python
season_length = 12 # Monthly data
horizon = len(test) # number of predictions

# We call the model that we are going to use
models = [DynamicOptimizedTheta(season_length=season_length,
                decomposition_type="additive")] # multiplicative   additive
```

--------------------------------

### ADF Test Output Example

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/models/holtwinters.html

Example output showing the results of the Augmented Dickey-Fuller test.

```text
Dickey-Fuller test results for columns: Ads
Test Statistic         -7.089634e+00
p-value                 4.444804e-10
No Lags Used            9.000000e+00
                            ...     
Critical Value (1%)    -3.462499e+00
Critical Value (5%)    -2.875675e+00
Critical Value (10%)   -2.574304e+00
Length: 7, dtype: float64
Conclusion:====>
Reject the null hypothesis
The data is stationary
```

--------------------------------

### Initialize Ray and prepare data

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/distributed/ray.html

Configures the Ray environment and converts a Pandas DataFrame into a partitioned Ray Dataset.

```python
ray.init(logging_level=logging.ERROR)

series['unique_id'] = series['unique_id'].astype(str)
ctx = ray.data.context.DatasetContext.get_current()
ctx.use_streaming_executor = False
ray_series = ray.data.from_pandas(series).repartition(4)
```

--------------------------------

### ADF test output example

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/models/garch.html

Example output showing the results of the Augmented Dickey-Fuller test.

```text
Dickey-Fuller test results for columns: S&P500
Test Statistic          -0.814971
p-value                  0.814685
No Lags Used            10.000000
                          ...
Critical Value (1%)     -3.433341
Critical Value (5%)     -2.862861
Critical Value (10%)    -2.567473
Length: 7, dtype: float64
Conclusion:====>
The null hypothesis cannot be rejected
The data is not stationary
```

--------------------------------

### Instantiating Models

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/tutorials/uncertaintyintervals.html

Create a list of model instances, ensuring seasonal models are configured with the appropriate seasonal length.

```python
# Create a list of models and instantiation parameters
models = [
    AutoETS(season_length=24),
    HistoricAverage(),
    Naive(),
    RandomWalkWithDrift(),
    SeasonalNaive(season_length=24)
]
```

--------------------------------

### Instantiate the model

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/models/simpleexponentialoptimized.html

Define the forecast horizon and initialize the model list.

```python
horizon = len(test) # number of predictions

models = [SimpleExponentialSmoothingOptimized()] # multiplicative   additive
```

--------------------------------

### Load libraries and instantiate model

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/models/dynamicstandardtheta.html

Import necessary classes and configure the DynamicTheta model with seasonal parameters.

```python
from statsforecast import StatsForecast
from statsforecast.models import DynamicTheta
```

```python
season_length = 12 # Monthly data
horizon = len(test) # number of predictions

models = [DynamicTheta(season_length=season_length,
                decomposition_type="additive")] # multiplicative additive
```

--------------------------------

### Execution Time Output

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/tutorials/statisticalneuralmethods.html

Example output showing the time taken for cross-validation.

```text
CV Minutes: 5.206169327100118
```

--------------------------------

### Instantiating the Model

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/models/imapa.html

Define the seasonal period and horizon, then initialize the IMAPA model.

```python
season_length = 24 # Hourly data
horizon = len(test) # number of predictions

models = [IMAPA()]
```

--------------------------------

### Runtime Warning Output

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/tutorials/statisticalneuralmethods.html

Example of a runtime warning that may occur during cross-validation.

```text
/home/ubuntu/statsforecast/statsforecast/ets.py:1041: RuntimeWarning:

divide by zero encountered in double_scalars
```

--------------------------------

### ADF Test Output

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/models/arima.html

Example output from the ADF test indicating non-stationarity.

```text
Dickey-Fuller test results for columns: Life expectancy
Test Statistic         -1.578590
p-value                 0.494339
No Lags Used            2.000000
                          ...   
Critical Value (1%)    -3.550670
Critical Value (5%)    -2.913766
Critical Value (10%)   -2.594624
Length: 7, dtype: float64
Conclusion:====>
The null hypothesis cannot be rejected
The data is not stationary
```

--------------------------------

### Cross-Validation Progress Output

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/getting-started/getting_started_complete_polars.html

Example of the progress bars displayed during the cross-validation process.

```text
Cross Validation Time Series 1: 100%|██████████| 2/2 [00:00<00:00,  2.02it/s]
Cross Validation Time Series 1: 100%|██████████| 2/2 [00:00<00:00,  2.02it/s]
Cross Validation Time Series 1: 100%|██████████| 2/2 [00:00<00:00,  2.26it/s]
Cross Validation Time Series 1: 100%|██████████| 2/2 [00:00<00:00,  2.76it/s]
Cross Validation Time Series 1: 100%|██████████| 2/2 [00:00<00:00,  2.25it/s]
Cross Validation Time Series 1: 100%|██████████| 2/2 [00:00<00:00,  2.78it/s]
Cross Validation Time Series 1: 100%|██████████| 2/2 [00:00<00:00,  3.20it/s]
Cross Validation Time Series 1: 100%|██████████| 2/2 [00:00<00:00,  4.14it/s]
Cross Validation Time Series 1: 100%|██████████| 2/2 [00:00<00:00,  4.11it/s]
Cross Validation Time Series 1: 100%|██████████| 2/2 [00:00<00:00,  4.75it/s]
```

--------------------------------

### Import Libraries

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/tutorials/garch_tutorial.html

Import pandas and yfinance, and configure the environment for StatsForecast.

```python
import os
os.environ['NIXTLA_ID_AS_COL'] = '1'

import yfinance as yf
import pandas as pd
```

--------------------------------

### Execute Seasonal Decomposition

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/models/crostonoptimized.html

Example usage of the decomposition function on a time series column.

```python
plotSeasonalDecompose(
    df["y"],
    model="additive",
    period=24,
    title="Seasonal Decomposition")
```

--------------------------------

### Tqdm Warning Output

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/getting-started/getting_started_complete_polars.html

Example of a warning message that may appear if IProgress is not found.

```text
/Users/nasaul/nixtla/statsforecast/.venv/lib/python3.9/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html
  from .autonotebook import tqdm as notebook_tqdm
```

--------------------------------

### Initialize Dask client

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/tutorials/statisticalneuralmethods.html

Set up the Dask execution engine for distributed processing.

```python
client = Client() # without this, dask is not in distributed mode
# fugue.dask.dataframe.default.partitions determines the default partitions for a new DaskDataFrame
engine = DaskExecutionEngine({"fugue.dask.dataframe.default.partitions": 96})
```

--------------------------------

### Configure ARIMA model parameters

Source: https://nixtlaverse.nixtla.io/statsforecast/src/core/models.html

Example dictionary for setting fixed coefficients in the ARIMA model.

```python
{'ar1': 0.5, 'ma2': 0.75}
```

--------------------------------

### ADF test output after differentiation

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/models/autoregressive.html

Example output showing a stationary result after applying a differential.

```text
Dickey-Fuller test results for columns: Sales
Test Statistic          -4.310935
p-value                  0.000425
No Lags Used            17.000000
                          ...    
Critical Value (1%)     -3.451974
Critical Value (5%)     -2.871063
Critical Value (10%)    -2.571844
Length: 7, dtype: float64
Conclusion:====>
Reject the null hypothesis
The data is stationary
```

--------------------------------

### Instantiating Simple Exponential Smoothing Models

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/models/simpleexponentialsmoothing.html

Configuring multiple SimpleExponentialSmoothing models with different alpha values for forecasting.

```python
horizon = len(test)
# We call the model that we are going to use
models = [SimpleExponentialSmoothing(alpha=0.1, alias="SES01"),
          SimpleExponentialSmoothing(alpha=0.5,alias="SES05"),
          SimpleExponentialSmoothing(alpha=0.8,alias="SES08")
          ]
```

--------------------------------

### Configure MFLES with three testing windows

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/models/mfles.html

Demonstrates initializing and fitting the AutoMFLES model using three testing windows to potentially improve consistency.

```python
season_length = [12]

mfles_model = AutoMFLES(
      season_length = season_length,
      test_size = 12,
      n_windows = 3, # Trying just 1 window here
      metric = 'smape')
mfles_model.fit(y=y)
predicted = mfles_model.predict(12)['mean']
fitted = mfles_model.predict_in_sample()['fitted']

plt.plot(np.append(fitted, predicted), linestyle='dashed', color='red')
plt.plot(y)
plt.show()
```

--------------------------------

### Tqdm warning output

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/experiments/amazonstatsforecast.html

Example of a warning message encountered when using tqdm in notebook environments.

```text
/home/ubuntu/fede/statsforecast/statsforecast/core.py:21: TqdmExperimentalWarning: Using `tqdm.autonotebook.tqdm` in notebook mode. Use `tqdm.tqdm` instead to force console mode (e.g. in jupyter console)
  from tqdm.autonotebook import tqdm
```

--------------------------------

### Initialize Spark session and Fugue backend

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/experiments/prophet_spark_m5.html

Configure the Spark session and initialize the Fugue backend for distributed execution.

```python
spark = SparkSession.builder.getOrCreate()
backend = FugueBackend(spark, {"fugue.spark.use_pandas_udf":True})
```

--------------------------------

### Differenced Series ADF Output

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/models/arima.html

Example output from the ADF test on the differenced series indicating stationarity.

```text
Dickey-Fuller test results for columns: Life expectancy
Test Statistic         -8.510100e+00
p-value                 1.173776e-13
No Lags Used            1.000000e+00
                            ...     
Critical Value (1%)    -3.550670e+00
Critical Value (5%)    -2.913766e+00
Critical Value (10%)   -2.594624e+00
Length: 7, dtype: float64
Conclusion:====>
Reject the null hypothesis
The data is stationary
```

--------------------------------

### Instantiate the StatsForecast class

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/how-to-guides/automatic_forecasting.html

Configure the models and instantiate the StatsForecast object with the desired frequency and parallel processing settings.

```python
season_length = 12 # Define season length as 12 months for monthly data
horizon = 1 # Forecast horizon is set to 1 month

# Define a list of models for forecasting
models = [
    AutoARIMA(season_length=season_length), # ARIMA model with automatic order selection and seasonal component
    AutoETS(season_length=season_length), # ETS model with automatic error, trend, and seasonal component
    AutoTheta(season_length=season_length), # Theta model with automatic seasonality detection
    AutoCES(season_length=season_length), # CES model with automatic seasonality detection
]

# Instantiate StatsForecast class with models, data frequency ('M' for monthly),
# and parallel computation on all CPU cores (n_jobs=-1)
sf = StatsForecast(
    models=models, # models for forecasting
    freq=pd.offsets.MonthEnd(),  # frequency of the timestamps
    n_jobs=1  # number of jobs to run in parallel, -1 means using all processors
)
```

--------------------------------

### Load and Prepare Data

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/tutorials/uncertaintyintervals.html

Import pandas and load the M4 hourly dataset, renaming the target column in the test set.

```python
import pandas as pd
```

```python
train = pd.read_csv('https://auto-arima-results.s3.amazonaws.com/M4-Hourly.csv')
test = pd.read_csv('https://auto-arima-results.s3.amazonaws.com/M4-Hourly-test.csv').rename(columns={'y': 'y_test'})
```

```python
train.head()
```

```python
test.head()
```

--------------------------------

### Configuring Plotting Styles

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/models/autoarima.html

Setup for matplotlib and seaborn visualization parameters, including a custom dark theme.

```python
import matplotlib.pyplot as plt
import seaborn as sns
from statsmodels.graphics.tsaplots import plot_acf
from statsmodels.graphics.tsaplots import plot_pacf
plt.style.use('fivethirtyeight')
plt.rcParams['lines.linewidth'] = 1.5
dark_style = {
    'figure.facecolor': '#212946',
    'axes.facecolor': '#212946',
    'savefig.facecolor':'#212946',
    'axes.grid': True,
    'axes.grid.which': 'both',
    'axes.spines.left': False,
    'axes.spines.right': False,
    'axes.spines.top': False,
    'axes.spines.bottom': False,
    'grid.color': '#2A3459',
    'grid.linewidth': '1',
    'text.color': '0.9',
    'axes.labelcolor': '0.9',
    'xtick.color': '0.9',
    'ytick.color': '0.9',
    'font.size': 12 }
plt.rcParams.update(dark_style)

from pylab import rcParams
rcParams['figure.figsize'] = (18,7)
```

--------------------------------

### Perform Basic Simulation

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/tutorials/simulation.html

Initialize an AutoARIMA model and simulate 100 future paths for a 48-hour horizon.

```python
# Initialize the model
models = [AutoARIMA(season_length=24)]
sf = StatsForecast(models=models, freq=1, n_jobs=1)

# Simulate 100 paths for a horizon of 48 hours
n_paths = 100
h = 48
# The simulation method handles the fitting (if needed) and the simulation
sims = sf.simulate(df=df, h=h, n_paths=n_paths, seed=42)

sims.head()
```

--------------------------------

### Example output of statistical comparison

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/tutorials/simulation.html

Displays the expected console output format for the statistical comparison of simulated trajectories.

```text
Statistical Comparison of Simulated Trajectories:
================================================================================
Distribution   Mean Std Dev    Min     Max 5th percentile 95th percentile
      Normal 670.15  161.78 307.35 1015.69         433.04          910.30
    t (Auto) 669.82  164.69 306.78 1027.63         431.49          914.23
    t (df=3) 667.69  164.39 314.33 1043.34         430.01          907.51
   Bootstrap 669.94  165.51 324.97 1059.47         429.79          913.07
```

--------------------------------

### Import and Define Volatility Models

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/tutorials/garch_tutorial.html

Import GARCH, ARCH, and Naive models and define a list of model instances with varying p and q parameters.

```python
from statsforecast.models import (
    GARCH,
    ARCH,
    Naive
)

models = [ARCH(1),
          ARCH(2),
          GARCH(1,1),
          GARCH(1,2),
          GARCH(2,2),
          GARCH(2,1),
          Naive()
]
```

--------------------------------

### Ray Execution Warning

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/experiments/ets_ray_m5.html

Example of a warning message generated when scheduling many fine-grained tasks on a Ray cluster.

```text
/home/ubuntu/miniconda/envs/ray/lib/python3.7/site-packages/ray/util/client/worker.py:618: UserWarning: More than 10MB of messages have been created to schedule tasks on the server. This can be slow on Ray Client due to communication overhead over the network. If you're running many fine-grained tasks, consider running them inside a single remote function. See the section on "Too fine-grained tasks" in the Ray Design Patterns document for more details: https://docs.google.com/document/d/167rnnDFIVRhHhK4mznEIemOtj63IOhtIPvSYaPgI4Fg/edit#heading=h.f7ins22n6nyl. If your functions frequently use large objects, consider storing the objects remotely with ray.put. An example of this is shown in the "Closure capture of large / unserializable object" section of the Ray Design Patterns document, available here: https://docs.google.com/document/d/167rnnDFIVRhHhK4mznEIemOtj63IOhtIPvSYaPgI4Fg/edit#heading=h.1afmymq455wu
  UserWarning,
```

--------------------------------

### Filter dataset for processing

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/getting-started/getting_started_complete.html

Select a subset of unique IDs and the most recent observations to reduce processing time for the example.

```python
uids = Y_df['unique_id'].unique()[:10] # Select 10 ids to make the example faster
Y_df = Y_df.query('unique_id in @uids')
Y_df = Y_df.groupby('unique_id').tail(7 * 24) #Select last 7 days of data to make example faster
```

--------------------------------

### Importing Libraries

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/models/autotheta.html

Initial imports for data manipulation and statistical analysis.

```python
import pandas as pd

import scipy.stats as stats
```

--------------------------------

### Load StatsForecast libraries

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/models/standardtheta.html

Import the necessary classes for model initialization.

```python
from statsforecast import StatsForecast
from statsforecast.models import Theta
```

--------------------------------

### View Augmented Dickey-Fuller test output

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/models/arch.html

Example output from the Augmented Dickey-Fuller test showing test statistics and the stationarity conclusion.

```text
Dickey-Fuller test results for columns: S&P500
Test Statistic          -0.814971
p-value                  0.814685
No Lags Used            10.000000
                          ...    
Critical Value (1%)     -3.433341
Critical Value (5%)     -2.862861
Critical Value (10%)    -2.567473
Length: 7, dtype: float64
Conclusion:====>
The null hypothesis cannot be rejected
The data is not stationary
```

--------------------------------

### Initialize StatsForecast models

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/experiments/amazonstatsforecast.html

Instantiate the StatsForecast object with a list of models and configuration parameters like frequency and parallel jobs.

```python
from statsforecast import StatsForecast
from statsforecast.models import (
    AutoETS,
    DynamicOptimizedTheta,
    SeasonalNaive
)

# Create list of models
models = [
    AutoETS(season_length=7),
    DynamicOptimizedTheta(season_length=7),
]

# Instantiate StatsForecast class
sf = StatsForecast( 
    models=models,
    freq='D', 
    n_jobs=-1,
    fallback_model=SeasonalNaive(season_length=7)
)
```

--------------------------------

### Initialize StatsForecast with MSTL and SeasonalNaive

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/tutorials/electricityloadforecasting.html

Configure the StatsForecast object with the MSTL model and a SeasonalNaive benchmark.

```python
sf = StatsForecast(
    models=[mstl, SeasonalNaive(season_length=24)], # add SeasonalNaive model to the list
    freq='h'
)
```

--------------------------------

### Import Prophet

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/tutorials/electricityloadforecasting.html

Import the Prophet library for time series modeling.

```python
from prophet import Prophet
```

--------------------------------

### Load and prepare M5 dataset

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/tutorials/statisticalneuralmethods.html

Load the M5 dataset from a URL and rename columns to comply with Nixtlaverse requirements.

```python
# Load the training target dataset from the provided URL
Y_df = pd.read_parquet('https://m5-benchmarks.s3.amazonaws.com/data/train/target.parquet')

# Rename columns to match the Nixtlaverse's expectations
# The 'item_id' becomes 'unique_id' representing the unique identifier of the time series
# The 'timestamp' becomes 'ds' representing the time stamp of the data points
# The 'demand' becomes 'y' representing the target variable we want to forecast
Y_df = Y_df.rename(columns={
    'item_id': 'unique_id',
    'timestamp': 'ds',
    'demand': 'y'
})

# Convert the 'ds' column to datetime format to ensure proper handling of date-related operations in subsequent steps
Y_df['ds'] = pd.to_datetime(Y_df['ds'])
```

--------------------------------

### Import Ray dependencies

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/distributed/ray.html

Required imports for Ray initialization and logging configuration.

```python
import ray
import logging
```

--------------------------------

### Instantiate MSTL Model

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/tutorials/anomalydetection.html

Create a list of models with specified seasonal periods for hourly and daily data.

```python
# Create a list of models and instantiation parameters
models = [MSTL(season_length = [24, 24*7])]
```

--------------------------------

### Instantiate GARCH Models

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/models/garch.html

Define the horizon and a list of GARCH model configurations with different parameters.

```python
season_length = 7 # Dayly data
horizon = len(test) # number of predictions biasadj=True, include_drift=True,

models = [GARCH(1,1),
          GARCH(1,2),
          GARCH(2,2),
          GARCH(2,1),
          GARCH(3,1),
          GARCH(3,2),
          GARCH(3,3),
          GARCH(1,3),
          GARCH(2,3)]
```

--------------------------------

### Importing StatsForecast and CrostonSBA

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/models/crostonsba.html

Load the necessary classes to begin using the model.

```python
from statsforecast import StatsForecast
from statsforecast.models import CrostonSBA
```

--------------------------------

### Initialize RandomWalkWithDrift Model

Source: https://nixtlaverse.nixtla.io/statsforecast/src/core/models.html

Instantiate the model with optional custom alias and prediction interval configuration.

```python
RandomWalkWithDrift(alias='RWD', prediction_intervals=None)
```

--------------------------------

### Instantiate MSTL Model

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/models/multipleseasonaltrend.html

Configure the MSTL model with specific seasonal periods and a trend forecaster.

```python
from statsforecast.utils import ConformalIntervals
horizon = len(test) # number of predictions

models = [MSTL(season_length=[24, 168], # seasonalities of the time series
trend_forecaster=AutoARIMA(prediction_intervals=ConformalIntervals(n_windows=3, h=horizon)))]
```

--------------------------------

### Initialize SimpleExponentialSmoothing

Source: https://nixtlaverse.nixtla.io/statsforecast/src/core/models.html

Constructor for the SimpleExponentialSmoothing model. Requires the alpha smoothing parameter.

```python
SimpleExponentialSmoothing(alpha, alias='SES', prediction_intervals=None)
```

--------------------------------

### Initialize AutoCES

Source: https://nixtlaverse.nixtla.io/statsforecast/src/core/models.html

Instantiate the AutoCES model with specific configuration parameters.

```python
AutoCES(season_length=1, model='Z', alias='CES', prediction_intervals=None, distribution='normal')
```

--------------------------------

### Initialize and fit StatsForecast

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/models/autoregressive.html

Create the StatsForecast object with the specified models and frequency, then fit it to the training data.

```python
sf = StatsForecast(models=models, freq='MS')
```

```python
sf.fit(df=train)
```

```text
StatsForecast(models=[AutoRegressive])
```

--------------------------------

### Import NeuralProphet

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/tutorials/electricityloadforecasting.html

Import the NeuralProphet library.

```python
from neuralprophet import NeuralProphet
```

--------------------------------

### Configure plotting environment

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/models/autoregressive.html

Sets up Matplotlib and Seaborn styles for visualization.

```python
import matplotlib.pyplot as plt
import seaborn as sns
from statsmodels.graphics.tsaplots import plot_acf, plot_pacf

plt.style.use('fivethirtyeight')
plt.rcParams['lines.linewidth'] = 1.5
dark_style = {
    'figure.facecolor': '#212946',
    'axes.facecolor': '#212946',
    'savefig.facecolor':'#212946',
    'axes.grid': True,
    'axes.grid.which': 'both',
    'axes.spines.left': False,
    'axes.spines.right': False,
    'axes.spines.top': False,
    'axes.spines.bottom': False,
    'grid.color': '#2A3459',
    'grid.linewidth': '1',
    'text.color': '0.9',
    'axes.labelcolor': '0.9',
    'xtick.color': '0.9',
    'ytick.color': '0.9',
    'font.size': 12 }
plt.rcParams.update(dark_style)

from pylab import rcParams
rcParams['figure.figsize'] = (18,7)
```

--------------------------------

### Import Required Libraries

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/tutorials/mlflow.html

Load necessary modules for data handling, modeling, and MLFlow tracking.

```python
import pandas as pd
import mlflow
from sklearn.metrics import mean_absolute_error, mean_absolute_percentage_error
from statsforecast import StatsForecast
from statsforecast.models import AutoARIMA

import mlflavors
import requests
```

--------------------------------

### Initializing StatsForecast

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/models/adida.html

Configuring the StatsForecast object with the model list and data frequency.

```python
sf = StatsForecast(models=models,
                   freq='7d',
                   n_jobs=-1)
```

--------------------------------

### Import StatsForecast Models

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/models/arch.html

Load the necessary classes for modeling.

```python
from statsforecast import StatsForecast
from statsforecast.models import ARCH
```

--------------------------------

### Instantiate MSTL model

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/tutorials/electricitypeakforecasting.html

Configure the MSTL model with specific seasonal lengths and a trend forecaster.

```python
models = [
    MSTL(
        season_length=[24, 24 * 7], # seasonalities of the time series
        trend_forecaster=SklearnModel(LinearRegression()) # model used to forecast trend
    )
]
```

--------------------------------

### Import StatsForecast and models

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/how-to-guides/automatic_forecasting.html

Import the core StatsForecast class and the required automatic forecasting models.

```python
import pandas as pd

from statsforecast import StatsForecast
from statsforecast.models import AutoARIMA, AutoETS, AutoTheta, AutoCES
```

--------------------------------

### Import StatsForecast libraries

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/models/seasonalexponentialsmoothingoptimized.html

Load the StatsForecast class and the SeasonalExponentialSmoothingOptimized model.

```python
from statsforecast import StatsForecast
from statsforecast.models import SeasonalExponentialSmoothingOptimized
```

--------------------------------

### Simulate with automatic parameter inference

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/tutorials/simulation.html

Demonstrates how to perform simulations using different error distributions where parameters are automatically inferred from residuals.

```python
# Student's t-distribution with automatic parameter inference
# The degrees of freedom, location, and scale are automatically estimated from residuals
sims_t_auto = sf.simulate(
    df=df, 
    h=h, 
    n_paths=n_paths, 
    error_distribution='t',  # No error_params specified - parameters inferred automatically
    seed=42
)

# Laplace distribution with automatic parameter inference
sims_laplace = sf.simulate(
    df=df, 
    h=h, 
    n_paths=n_paths, 
    error_distribution='laplace',
    seed=42
)

# Skew-normal distribution with automatic parameter inference
sims_skewnorm = sf.simulate(
    df=df, 
    h=h, 
    n_paths=n_paths, 
    error_distribution='skew-normal',
    seed=42
)
```

--------------------------------

### Initialize AutoETS Model

Source: https://nixtlaverse.nixtla.io/statsforecast/src/core/models.html

Instantiate the AutoETS model with specific configuration parameters for error, trend, and seasonality components.

```python
AutoETS(season_length=1, model='ZZZ', damped=None, phi=None, alias='AutoETS', prediction_intervals=None, distribution='normal')
```

--------------------------------

### Load StatsForecast Libraries

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/models/garch.html

Import the StatsForecast class and the GARCH model.

```python
from statsforecast import StatsForecast
from statsforecast.models import GARCH
```

--------------------------------

### Configure plotting libraries and styles

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/models/adida.html

Initializes matplotlib and seaborn with a custom dark theme for visualization.

```python
import matplotlib.pyplot as plt
import seaborn as sns
from statsmodels.graphics.tsaplots import plot_acf
from statsmodels.graphics.tsaplots import plot_pacf
import plotly.graph_objects as go
plt.style.use('grayscale') # fivethirtyeight  grayscale  classic
plt.rcParams['lines.linewidth'] = 1.5
dark_style = {
    'figure.facecolor': '#008080',  # #212946
    'axes.facecolor': '#008080',
    'savefig.facecolor': '#008080',
    'axes.grid': True,
    'axes.grid.which': 'both',
    'axes.spines.left': False,
    'axes.spines.right': False,
    'axes.spines.top': False,
    'axes.spines.bottom': False,
    'grid.color': '#000000',  #2A3459
    'grid.linewidth': '1',
    'text.color': '0.9',
    'axes.labelcolor': '0.9',
    'xtick.color': '0.9',
    'ytick.color': '0.9',
    'font.size': 12 }
plt.rcParams.update(dark_style)

from pylab import rcParams
rcParams['figure.figsize'] = (18,7)
```

--------------------------------

### Configure plotting libraries and styles

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/models/crostonsba.html

Initializes matplotlib and seaborn with a custom dark theme for visualization.

```python
import matplotlib.pyplot as plt
import seaborn as sns
from statsmodels.graphics.tsaplots import plot_acf, plot_pacf
plt.style.use('grayscale') # fivethirtyeight  grayscale  classic
plt.rcParams['lines.linewidth'] = 1.5
dark_style = {
    'figure.facecolor': '#008080',  # #212946
    'axes.facecolor': '#008080',
    'savefig.facecolor': '#008080',
    'axes.grid': True,
    'axes.grid.which': 'both',
    'axes.spines.left': False,
    'axes.spines.right': False,
    'axes.spines.top': False,
    'axes.spines.bottom': False,
    'grid.color': '#000000',  #2A3459
    'grid.linewidth': '1',
    'text.color': '0.9',
    'axes.labelcolor': '0.9',
    'xtick.color': '0.9',
    'ytick.color': '0.9',
    'font.size': 12 }
plt.rcParams.update(dark_style)


from pylab import rcParams
rcParams['figure.figsize'] = (18,7)
```

--------------------------------

### Initialize and fit StatsForecast

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/models/dynamicoptimizedtheta.html

Create the StatsForecast object and fit the model to the training data.

```python
sf = StatsForecast(models=models, freq='MS')
```

```python
sf.fit(df=train)
```

--------------------------------

### Create Conda Environment

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/contribute/step-by-step.html

Commands to initialize a new Python environment using Conda or Mamba.

```bash
conda create -n nixtla-env python=3.10
```

```bash
mamba create -n nixtla-env python=3.10
```

--------------------------------

### Instantiate and Fit Model

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/getting-started/getting_started_short.html

Initialize the StatsForecast object with the desired models and frequency, then fit it to the dataframe.

```python
sf = StatsForecast(
    models=[AutoARIMA(season_length = 12)],
    freq='MS',
)
sf.fit(df)
```

--------------------------------

### Instantiate Seasonal Exponential Smoothing Model

Source: https://nixtlaverse.nixtla.io/statsforecast/docs/models/seasonalexponentialsmoothing.html

Configure the model parameters, including season length and smoothing alpha.

```python
season_length = 24 # Hourly data
horizon = len(test) # number of predictions

models = [SeasonalExponentialSmoothing(alpha=0.8, season_length=season_length)]
```
Tokens:
Raw