Nixtla

https://nixtlaverse.nixtla.io/
Admin
Nixtla is a comprehensive open-source ecosystem providing cutting-edge time series forecasting...
Tokens:601,597
Snippets:6,266
Trust Score:9
Update:2 months ago
Show doc for...
Tokens:
Raw
### Install datasetsforecast

Source: https://nixtlaverse.nixtla.io/neuralforecast/docs/getting-started/datarequirements.html

Install the library required to load example datasets.

```python
%%capture
!pip install datasetsforecast
```

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

### Install HierarchicalForecast

Source: https://nixtlaverse.nixtla.io/hierarchicalforecast/examples/introduction.html

Install the necessary packages to run the examples.

```python
!pip install hierarchicalforecast statsforecast datasetsforecast
```

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

### Setup Development Environment with uv

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

Commands to install uv and create a virtual environment for development.

```bash
$ pip install uv
$ uv venv --python 3.12
```

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

### 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 datasetsforecast

Source: https://nixtlaverse.nixtla.io/datasetsforecast/index.html

Install the library using pip.

```sh
pip install datasetsforecast
```

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

### Install dependencies and library from source

Source: https://nixtlaverse.nixtla.io/hierarchicalforecast/examples/installation.html

Install the package and its requirements from the local directory.

```bash
uv pip install -r setup.py
uv pip install .
```

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

### Install utilsforecast

Source: https://nixtlaverse.nixtla.io/utilsforecast/index.html

Installation commands for the library using PyPI or Conda.

```sh
pip install utilsforecast
```

```sh
conda install -c conda-forge utilsforecast
```

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

### Install HierarchicalForecast

Source: https://nixtlaverse.nixtla.io/hierarchicalforecast/index.html

Installation commands for the library using uv or pip.

```python
uv pip install hierarchicalforecast
```

```python
pip install hierarchicalforecast
```

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

### Install CoreForecast via PyPI

Source: https://nixtlaverse.nixtla.io/coreforecast

Install the library using pip.

```bash
pip install coreforecast
```

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

### 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 utilsforecast via PyPI

Source: https://nixtlaverse.nixtla.io/utilsforecast

Standard installation command for the utilsforecast package.

```bash
pip install utilsforecast
```

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

### Install MLForecast via PyPI

Source: https://nixtlaverse.nixtla.io/mlforecast/docs/getting-started/install.html

Standard installation command for the latest release from PyPI.

```bash
pip install mlforecast
```

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

### 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 Dependencies

Source: https://nixtlaverse.nixtla.io/neuralforecast/docs/tutorials/longhorizon_probabilistic.html

Install the required neuralforecast and datasetsforecast packages.

```python
%%capture
!pip install neuralforecast datasetsforecast
```

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

### 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 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 NeuralForecast and Hyperopt

Source: https://nixtlaverse.nixtla.io/neuralforecast/docs/capabilities/time_series_scaling.html

Install the necessary libraries for forecasting and hyperparameter optimization.

```python
%%capture
!pip install neuralforecast
!pip install hyperopt
```

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

### 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]'
```

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

### Setup and partial fitting for hyperparameter tuning

Source: https://nixtlaverse.nixtla.io/mlforecast/lgb_cv.html

Uses the setup method to prepare the model for iterative training and evaluates performance using partial_fit.

```python
cv4 = LightGBMCV(
    freq=1,
    lags=[24 * (i+1) for i in range(7)],
)
cv4.setup(
    train,
    n_windows=2,
    h=horizon,
    params={'verbose': -1},
)
```

```python
score = cv4.partial_fit(10)
score
```

```python
assert hist[0][1] == score
```

```python
score2 = cv4.partial_fit(20)
```

```python
assert hist[2][1] == score2
```

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

### Install SynForecast

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

Install the package using standard pip or the uv package manager.

```bash
pip install synforecast
```

```bash
uv add synforecast
```

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

### Install dependencies

Source: https://nixtlaverse.nixtla.io/neuralforecast/docs/tutorials/comparing_methods.html

Install LightGBM and XGBoost libraries for use with MLForecast.

```python
%%capture
!pip install lightgbm xgboost
```

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

### Install Required Libraries

Source: https://nixtlaverse.nixtla.io/mlforecast/docs/how-to-guides/transfer_learning.html

Install the necessary packages for MLForecast and data handling.

```python
%%capture
# !pip install mlforecast datasetsforecast utilsforecast s3fs
```

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

### Install SynForecast

Source: https://nixtlaverse.nixtla.io/synforecast/index.html

Install the package via pip. Building from source requires a Rust toolchain.

```bash
pip install synforecast
```

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

### Install MLForecast and dependencies

Source: https://nixtlaverse.nixtla.io/mlforecast/docs/tutorials/incremental_forecasting.html

Installs the necessary libraries for forecasting and data handling.

```python
!pip install mlforecast datasetsforecast s3fs xgboost -q
```

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

### Install required libraries

Source: https://nixtlaverse.nixtla.io/neuralforecast/docs/tutorials/intermittent_data.html

Install the necessary packages for data processing and forecasting.

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

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

### Install and Import Visualization Libraries

Source: https://nixtlaverse.nixtla.io/neuralforecast/docs/tutorials/comparing_methods.html

Install seaborn and import matplotlib and seaborn for plotting.

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

```python
import matplotlib.pyplot as plt
import seaborn as sns
```

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

### Install utilsforecast via Conda

Source: https://nixtlaverse.nixtla.io/utilsforecast

Installation command for users managing environments with Conda.

```bash
conda install -c conda-forge utilsforecast
```

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

### Install Optional Extras

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

Commands to install additional functionality for distributed training or cloud storage integration.

```shell
pip install neuralforecast[spark]
```

```shell
pip install neuralforecast[aws]
```

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

### Install NeuralForecast library

Source: https://nixtlaverse.nixtla.io/neuralforecast/docs/capabilities/cross_validation.html

Install the required library using pip within a notebook environment.

```python
%%capture
!pip install neuralforecast
```

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

### Install NeuralForecast and DatasetsForecast

Source: https://nixtlaverse.nixtla.io/neuralforecast/docs/tutorials/transfer_learning.html

Install the required packages for time series forecasting and dataset management.

```python
%%capture
!pip install datasetsforecast neuralforecast
```

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

### TimeXer usage example

Source: https://nixtlaverse.nixtla.io/neuralforecast/models.timexer.html

A complete example demonstrating data preparation, model initialization, training, and forecasting with TimeXer.

```python
import pandas as pd
import matplotlib.pyplot as plt

from neuralforecast import NeuralForecast
from neuralforecast.models import TimeXer
from neuralforecast.losses.pytorch import MAE, MSE
from neuralforecast.utils import AirPassengersPanel, AirPassengersStatic, augment_calendar_df

AirPassengersPanel, calendar_cols = augment_calendar_df(df=AirPassengersPanel, freq='M')

Y_train_df = AirPassengersPanel[AirPassengersPanel.ds<AirPassengersPanel['ds'].values[-12]] # 132 train
Y_test_df = AirPassengersPanel[AirPassengersPanel.ds>=AirPassengersPanel['ds'].values[-12]].reset_index(drop=True) # 12 test

model = TimeXer(h=12,
                input_size=24,
                n_series=2,
                stat_exog_list=['airline1'],
                patch_len=12,
                hidden_size=128,
                n_heads=16,
                e_layers=2,
                d_ff=256,
                factor=1,
                dropout=0.1,
                use_norm=True,
                loss=MSE(),
                valid_loss=MAE(),
                early_stop_patience_steps=3,
                batch_size=32)

fcst = NeuralForecast(models=[model], freq='ME')
fcst.fit(df=Y_train_df, static_df=AirPassengersStatic, val_size=12)
forecasts = fcst.predict(futr_df=Y_test_df)

# Plot predictions
fig, ax = plt.subplots(1, 1, figsize = (20, 7))
Y_hat_df = forecasts.reset_index(drop=False).drop(columns=['unique_id','ds'])
plot_df = pd.concat([Y_test_df, Y_hat_df], axis=1)
plot_df = pd.concat([Y_train_df, plot_df])

plot_df = plot_df[plot_df.unique_id=='Airline1'].drop('unique_id', axis=1)
plt.plot(plot_df['ds'], plot_df['y'], c='black', label='True')
plt.plot(plot_df['ds'], plot_df['TimeXer'], c='blue', label='Forecast')
ax.set_title('AirPassengers Forecast', fontsize=22)
ax.set_ylabel('Monthly Passengers', fontsize=20)
ax.set_xlabel('Year', fontsize=20)
ax.legend(prop={'size': 15})
ax.grid()
```

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

### Install HierarchicalForecast and StatsForecast

Source: https://nixtlaverse.nixtla.io/hierarchicalforecast/examples/australiandomestictourism-permbu-intervals.html

Install the necessary libraries for hierarchical forecasting and statistical modeling.

```python
!pip install hierarchicalforecast statsforecast
```

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

### Install required libraries

Source: https://nixtlaverse.nixtla.io/hierarchicalforecast/examples/australiandomestictourism-multimodel.html

Install the necessary packages for hierarchical, statistical, machine learning, and neural network forecasting.

```python
!pip install hierarchicalforecast statsforecast mlforecast datasetsforecast neuralforecast
```

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

### Install Required Libraries

Source: https://nixtlaverse.nixtla.io/neuralforecast/docs/tutorials/comparing_methods.html

Installs the necessary forecasting libraries including statsforecast, mlforecast, and neuralforecast.

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

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

### Install MLForecast development version

Source: https://nixtlaverse.nixtla.io/mlforecast/docs/getting-started/install.html

Commands to install the latest development code directly from the GitHub repository.

```bash
pip install git+https://github.com/Nixtla/mlforecast
```

```bash
git clone https://github.com/Nixtla/mlforecast mlforecast-dev && pip install mlforecast-dev/
```

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

### NBEATSx usage example

Source: https://nixtlaverse.nixtla.io/neuralforecast/models.nbeatsx.html

A complete example demonstrating how to initialize, train, and predict with NBEATSx, followed by plotting the results.

```python
import pandas as pd
import matplotlib.pyplot as plt

from neuralforecast import NeuralForecast
from neuralforecast.models import NBEATSx
from neuralforecast.losses.pytorch import MQLoss
from neuralforecast.utils import AirPassengersPanel, AirPassengersStatic

Y_train_df = AirPassengersPanel[AirPassengersPanel.ds<AirPassengersPanel['ds'].values[-12]] # 132 train
Y_test_df = AirPassengersPanel[AirPassengersPanel.ds>=AirPassengersPanel['ds'].values[-12]].reset_index(drop=True) # 12 test

model = NBEATSx(h=12, input_size=24,
                loss=MQLoss(level=[80, 90]),
                scaler_type='robust',
                dropout_prob_theta=0.5,
                stat_exog_list=['airline1'],
                futr_exog_list=['trend'],
                stack_types = ["identity", "trend", "seasonality", "exogenous"],
                n_blocks = [1,1,1,1],
                max_steps=200,
                val_check_steps=10,
                early_stop_patience_steps=2)

nf = NeuralForecast(
    models=[model],
    freq='ME'
)
nf.fit(df=Y_train_df, static_df=AirPassengersStatic, val_size=12)
Y_hat_df = nf.predict(futr_df=Y_test_df)

# Plot quantile predictions
Y_hat_df = Y_hat_df.reset_index(drop=False).drop(columns=['unique_id','ds'])
plot_df = pd.concat([Y_test_df, Y_hat_df], axis=1)
plot_df = pd.concat([Y_train_df, plot_df])

plot_df = plot_df[plot_df.unique_id=='Airline1'].drop('unique_id', axis=1)
plt.plot(plot_df['ds'], plot_df['y'], c='black', label='True')
plt.plot(plot_df['ds'], plot_df['NBEATSx-median'], c='blue', label='median')
plt.fill_between(x=plot_df['ds'][-12:], 
                 y1=plot_df['NBEATSx-lo-90'][-12:].values, 
                 y2=plot_df['NBEATSx-hi-90'][-12:].values,
                 alpha=0.4, label='level 90')
plt.legend()
plt.grid()
plt.plot()
```

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

### Setup Environment

Source: https://nixtlaverse.nixtla.io/neuralforecast/docs/tutorials/weighting_timesteps.html

Imports necessary libraries and configures logging and warning settings.

```python
import logging
import warnings

import numpy as np

from utilsforecast.evaluation import evaluate
from utilsforecast.losses import mae
from utilsforecast.plotting import plot_series

from neuralforecast import NeuralForecast
from neuralforecast.models import NHITS

warnings.filterwarnings("ignore")
logging.getLogger("pytorch_lightning").setLevel(logging.ERROR)
```

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

### Install required forecasting libraries

Source: https://nixtlaverse.nixtla.io/mlforecast/docs/tutorials/electricity_load_forecasting.html

Install the necessary packages for MLForecast, Prophet, and evaluation utilities.

```python
# %%capture
# !pip install prophet
# !pip install -U mlforecast
# !pip install -U utilsforecast
```

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

### Clone and Setup Development Environment

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

Clone the repository and initialize the development environment with pre-commit hooks.

```bash
git clone https://github.com/Nixtla/synforecast.git
cd synforecast
make devenv
```

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

### LightGBMCV.setup

Source: https://nixtlaverse.nixtla.io/mlforecast/lgb_cv.html

Initialize internal data structures to iteratively train the boosters.

```APIDOC
## LightGBMCV.setup

### Description
Initialize internal data structures to iteratively train the boosters. Use this before calling partial_fit.

### Parameters
- **df** (pandas DataFrame) - Required - Series data in long format.
- **n_windows** (int) - Required - Number of windows to evaluate.
- **h** (int) - Required - Forecast horizon.
- **id_col** (str) - Optional - Column name for series identifier. Default: 'unique_id'.
- **time_col** (str) - Optional - Column name for time. Default: 'ds'.
- **target_col** (str) - Optional - Column name for target. Default: 'y'.
```

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

### Install MLForecast extras via PyPI

Source: https://nixtlaverse.nixtla.io/mlforecast/docs/getting-started/install.html

Commands to install optional dependencies for dataframes, remote storage, or distributed training.

```bash
pip install "mlforecast[polars]"
```

```bash
pip install "mlforecast[aws]"
```

```bash
pip install "mlforecast[gcp]"
```

```bash
pip install "mlforecast[azure]"
```

```bash
pip install "mlforecast[dask]"
```

```bash
pip install "mlforecast[ray]"
```

```bash
pip install "mlforecast[spark]"
```

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

### Spark partitioning example

Source: https://nixtlaverse.nixtla.io/neuralforecast/docs/tutorials/large_datasets.html

Demonstrates how to create the required directory structure using a Spark DataFrame.

```python
spark.conf.set("spark.sql.parquet.outputTimestampType", "TIMESTAMP_MICROS")
(
  spark_df
  .repartition(id_col)
  .sortWithinPartitions(id_col, time_col)
  .write
  .partitionBy(id_col)
  .parquet(out_dir)
)
```

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

### Install StatsForecast

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

Install the required package via pip.

```bash
pip install statsforecast
```

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

### Install NeuralForecast in Development Mode

Source: https://nixtlaverse.nixtla.io/neuralforecast/docs/getting-started/introduction.html

Clone the repository and install in editable mode to apply and test code modifications in real time.

```bash
git clone https://github.com/Nixtla/neuralforecast.git
cd neuralforecast
pip install -e .
```

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

### Install Dependencies

Source: https://nixtlaverse.nixtla.io/hierarchicalforecast/examples/probabilistic-reconciliation-comparison.html

Install the required hierarchicalforecast and statsforecast packages.

```python
# Install dependencies if needed
# !pip install hierarchicalforecast statsforecast
```

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

### NHITS usage and forecasting example

Source: https://nixtlaverse.nixtla.io/neuralforecast/models.nhits.html

A complete example demonstrating how to initialize, train, and predict with the NHITS model, followed by plotting quantile forecasts.

```python
import pandas as pd
import matplotlib.pyplot as plt

from neuralforecast import NeuralForecast
from neuralforecast.models import NHITS
from neuralforecast.losses.pytorch import DistributionLoss
from neuralforecast.utils import AirPassengersPanel, AirPassengersStatic

Y_train_df = AirPassengersPanel[AirPassengersPanel.ds<AirPassengersPanel['ds'].values[-12]].reset_index(drop=True) # 132 train
Y_test_df = AirPassengersPanel[AirPassengersPanel.ds>=AirPassengersPanel['ds'].values[-12]].reset_index(drop=True) # 12 test

model = NHITS(h=12,
              input_size=24,
              loss=DistributionLoss(distribution='StudentT', level=[80, 90], return_params=True),
              stat_exog_list=['airline1'],
              futr_exog_list=['trend'],
              n_freq_downsample=[2, 1, 1],
              scaler_type='robust',
              max_steps=200,
              early_stop_patience_steps=2,
              inference_windows_batch_size=1,
              val_check_steps=10,
              learning_rate=1e-3)

fcst = NeuralForecast(models=[model], freq='ME')
fcst.fit(df=Y_train_df, static_df=AirPassengersStatic, val_size=12)
forecasts = fcst.predict(futr_df=Y_test_df)

# Plot quantile predictions
Y_hat_df = forecasts.reset_index(drop=False).drop(columns=['unique_id','ds'])
plot_df = pd.concat([Y_test_df, Y_hat_df], axis=1)
plot_df = pd.concat([Y_train_df, plot_df])

plot_df = plot_df[plot_df.unique_id=='Airline1'].drop('unique_id', axis=1)
plt.plot(plot_df['ds'], plot_df['y'], c='black', label='True')
plt.plot(plot_df['ds'], plot_df['NHITS-median'], c='blue', label='median')
plt.fill_between(x=plot_df['ds'][-12:], 
                 y1=plot_df['NHITS-lo-90'][-12:].values, 
                 y2=plot_df['NHITS-hi-90'][-12:].values,
                 alpha=0.4, label='level 90')
plt.legend()
plt.grid()
plt.plot()
```

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

### LightGBMCV.setup method signature

Source: https://nixtlaverse.nixtla.io/mlforecast/lgb_cv.html

Method signature for initializing internal data structures before training.

```python
setup(df, n_windows, h, id_col='unique_id', time_col='ds', target_col='y', step_size=None, params=None, static_features=None, dropna=True, keep_last_n=None, weights=None, metric='mape', input_size=None, weight_col=None)
```

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

### Setup data for sample weights

Source: https://nixtlaverse.nixtla.io/mlforecast/docs/how-to-guides/sample_weights.html

Import necessary libraries and generate a sample series with a weight column.

```python
import numpy as np
from mlforecast.utils import generate_daily_series
```

```python
series = generate_daily_series(2)
series['weight'] = np.random.default_rng(seed=0).random(series.shape[0])
series.head(2)
```

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

### 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
```

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

### Create virtual environment

Source: https://nixtlaverse.nixtla.io/hierarchicalforecast/examples/installation.html

Initialize a virtual environment using uv.

```bash
$ uv venv --python 3.10
```

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

### 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
```

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

### 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
```

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

### KAN model training and forecasting example

Source: https://nixtlaverse.nixtla.io/neuralforecast/models.kan.html

Demonstrates initializing the KAN model, fitting it to training data, and generating quantile forecasts.

```python
import pandas as pd
import matplotlib.pyplot as plt

from neuralforecast import NeuralForecast
from neuralforecast.models import KAN
from neuralforecast.losses.pytorch import DistributionLoss
from neuralforecast.utils import AirPassengersPanel, AirPassengersStatic

Y_train_df = AirPassengersPanel[AirPassengersPanel.ds<AirPassengersPanel['ds'].values[-12]] # 132 train
Y_test_df = AirPassengersPanel[AirPassengersPanel.ds>=AirPassengersPanel['ds'].values[-12]].reset_index(drop=True) # 12 test

fcst = NeuralForecast(
    models=[
            KAN(h=12,
                input_size=24,
                loss = DistributionLoss(distribution="Normal"),
                max_steps=100,
                scaler_type='standard',
                futr_exog_list=['y_[lag12]'],
                hist_exog_list=None,
                stat_exog_list=['airline1'],
                ),     
    ],
    freq='ME'
)
fcst.fit(df=Y_train_df, static_df=AirPassengersStatic)
forecasts = fcst.predict(futr_df=Y_test_df)

# Plot quantile predictions
Y_hat_df = forecasts.reset_index(drop=False).drop(columns=['unique_id','ds'])
plot_df = pd.concat([Y_test_df, Y_hat_df], axis=1)
plot_df = pd.concat([Y_train_df, plot_df])

plot_df = plot_df[plot_df.unique_id=='Airline1'].drop('unique_id', axis=1)
plt.plot(plot_df['ds'], plot_df['y'], c='black', label='True')
plt.plot(plot_df['ds'], plot_df['KAN-median'], c='blue', label='median')
plt.fill_between(x=plot_df['ds'][-12:], 
                 y1=plot_df['KAN-lo-90'][-12:].values,
                 y2=plot_df['KAN-hi-90'][-12:].values,
                 alpha=0.4, label='level 90')
plt.legend()
plt.grid()
```

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

### 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
```

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

### Install NeuralForecast dependencies

Source: https://nixtlaverse.nixtla.io/neuralforecast/docs/tutorials/longhorizon_nhits.html

Install the necessary libraries to run NeuralForecast models.

```python
%%capture
!pip install neuralforecast datasetsforecast utilsforecast
```

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

### Initialize FullAttention

Source: https://nixtlaverse.nixtla.io/neuralforecast/common.modules.html

Example instantiation of the FullAttention module with default parameters.

```python
FullAttention(
    mask_flag=True,
    factor=5,
    scale=None,
    attention_dropout=0.1,
    output_attention=False,
)
```

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

### Setup imports

Source: https://nixtlaverse.nixtla.io/mlforecast/docs/how-to-guides/one_model_per_horizon.html

Required imports for data processing, evaluation, and model training.

```python
import random
import lightgbm as lgb
import pandas as pd
from datasetsforecast.m4 import M4, M4Info
from utilsforecast.evaluation import evaluate
from utilsforecast.losses import smape

from mlforecast import MLForecast
from mlforecast.lag_transforms import ExponentiallyWeightedMean, RollingMean
from mlforecast.target_transforms import Differences
```

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

### BiTCN training and prediction workflow

Source: https://nixtlaverse.nixtla.io/neuralforecast/models.bitcn.html

A complete example demonstrating data preparation, model initialization with GMM loss, fitting, and plotting quantile forecasts.

```python
import pandas as pd
import matplotlib.pyplot as plt

from neuralforecast import NeuralForecast
from neuralforecast.losses.pytorch import GMM
from neuralforecast.models import BiTCN
from neuralforecast.utils import AirPassengersPanel, AirPassengersStatic

Y_train_df = AirPassengersPanel[AirPassengersPanel.ds<AirPassengersPanel['ds'].values[-12]] # 132 train
Y_test_df = AirPassengersPanel[AirPassengersPanel.ds>=AirPassengersPanel['ds'].values[-12]].reset_index(drop=True) # 12 test

fcst = NeuralForecast(
    models=[
            BiTCN(h=12,
                input_size=24,
                loss=GMM(n_components=7, level=[80,90]),
                max_steps=100,
                scaler_type='standard',
                futr_exog_list=['y_[lag12]'],
                hist_exog_list=None,
                stat_exog_list=['airline1'],
                windows_batch_size=2048,
                val_check_steps=10,
                early_stop_patience_steps=-1,
                ),     
    ],
    freq='ME'
)
fcst.fit(df=Y_train_df, static_df=AirPassengersStatic)
forecasts = fcst.predict(futr_df=Y_test_df)

# Plot quantile predictions
Y_hat_df = forecasts.reset_index(drop=False).drop(columns=['unique_id','ds'])
plot_df = pd.concat([Y_test_df, Y_hat_df], axis=1)
plot_df = pd.concat([Y_train_df, plot_df])

plot_df = plot_df[plot_df.unique_id=='Airline1'].drop('unique_id', axis=1)
plt.plot(plot_df['ds'], plot_df['y'], c='black', label='True')
plt.plot(plot_df['ds'], plot_df['BiTCN-median'], c='blue', label='median')
plt.fill_between(x=plot_df['ds'][-12:], 
                 y1=plot_df['BiTCN-lo-90'][-12:].values,
                 y2=plot_df['BiTCN-hi-90'][-12:].values,
                 alpha=0.4, label='level 90')
plt.legend()
plt.grid()
```

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

### LightGBMCV.setup

Source: https://nixtlaverse.nixtla.io/mlforecast/lgb_cv.html

Configures the LightGBMCV instance with necessary parameters for time series forecasting and cross-validation.

```APIDOC
## LightGBMCV.setup

### Description
Initializes the LightGBMCV object with the specified forecasting horizon, column identifiers, and model parameters.

### Parameters
- **h** (int) - Required - Forecast horizon.
- **id_col** (str) - Optional - Column that identifies each serie. Defaults to 'unique_id'.
- **time_col** (str) - Optional - Column that identifies each timestep. Defaults to 'ds'.
- **target_col** (str) - Optional - Column that contains the target. Defaults to 'y'.
- **step_size** (int) - Optional - Step size between each cross validation window. Defaults to None.
- **params** (dict) - Optional - Parameters to be passed to the LightGBM Boosters. Defaults to None.
- **static_features** (list of str) - Optional - Names of the features that are static. Defaults to None.
- **dropna** (bool) - Optional - Drop rows with missing values produced by the transformations. Defaults to True.
- **keep_last_n** (int) - Optional - Keep only these many records from each serie for the forecasting step. Defaults to None.
- **weights** (sequence of float) - Optional - Weights to multiply the metric of each window. Defaults to None.
- **metric** (str or callable) - Optional - Metric used to assess performance and perform early stopping. Defaults to 'mape'.
```

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

### Install CoreForecast via Conda

Source: https://nixtlaverse.nixtla.io/coreforecast

Install the library using the conda-forge channel.

```bash
conda install -c conda-forge coreforecast
```

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

### 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
```

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

### Verify Installation

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

Confirm the native Rust extension is correctly loaded by importing the internal library.

```bash
python -c "import synforecast; from synforecast import _lib; print(synforecast.__version__)"
```

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

### Cross-Validation Output Example

Source: https://nixtlaverse.nixtla.io/neuralforecast/docs/tutorials/comparing_methods.html

Example output showing the execution time in minutes.

```text
CV Minutes: 1.6215598344802857
```

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

### Cross-validation output example

Source: https://nixtlaverse.nixtla.io/mlforecast/docs/how-to-guides/cross_validation.html

Example output showing the calculated RMSE value.

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

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

### Install required libraries

Source: https://nixtlaverse.nixtla.io/utilsforecast/docs/tutorials/multi_objective_model_selection.html

Install the necessary packages for time series forecasting and evaluation.

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

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

### 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()]
```

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

### XLinear usage example

Source: https://nixtlaverse.nixtla.io/neuralforecast/models.xlinear.html

Demonstrates initializing the XLinear model, fitting it to the AirPassengers dataset, and generating forecasts.

```python
import pandas as pd
import matplotlib.pyplot as plt

from neuralforecast import NeuralForecast
from neuralforecast.models import XLinear
from neuralforecast.losses.pytorch import MAE
from neuralforecast.utils import AirPassengersPanel, AirPassengersStatic

Y_train_df = AirPassengersPanel[AirPassengersPanel.ds<AirPassengersPanel['ds'].values[-12]] # 132 train
Y_test_df = AirPassengersPanel[AirPassengersPanel.ds>=AirPassengersPanel['ds'].values[-12]].reset_index(drop=True) # 12 test

model = XLinear(h=12, 
            input_size=24,
            n_series=2,
            stat_exog_list=['airline1'],
            hist_exog_list=["y_[lag12]"],
            futr_exog_list=['trend'],            
            loss = MAE(),
            scaler_type='robust',
            learning_rate=1e-3,
            max_steps=200,
            val_check_steps=10,
            early_stop_patience_steps=2)

fcst = NeuralForecast(
    models=[model],
    freq='ME'
)
fcst.fit(df=Y_train_df, static_df=AirPassengersStatic, val_size=12)
forecasts = fcst.predict(futr_df=Y_test_df)

# Plot predictions
Y_hat_df = forecasts.reset_index(drop=False).drop(columns=['unique_id','ds'])
plot_df = pd.concat([Y_test_df, Y_hat_df], axis=1)
plot_df = pd.concat([Y_train_df, plot_df])

plot_df = plot_df[plot_df.unique_id=='Airline1'].drop('unique_id', axis=1)
plt.plot(plot_df['ds'], plot_df['y'], c='black', label='True')
plt.plot(plot_df['ds'], plot_df['XLinear'], c='blue', label='median')
plt.grid()
plt.legend()
plt.plot()
```

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

### Environment Setup for NeuralForecast

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

Initializes logging, warnings, and torch precision settings required for running simulations.

```python
import logging
import warnings

import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import torch

warnings.filterwarnings("ignore")
logging.getLogger("pytorch_lightning").setLevel(logging.ERROR)
torch.set_float32_matmul_precision("high")
```

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

### Install Optional Engines

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

Install additional dependencies required for specific dataframe engine support.

```bash
pip install pyarrow          # engine="pyarrow"
pip install "modin[dask]"    # engine="modin"
```

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

### Initialize Dask client

Source: https://nixtlaverse.nixtla.io/mlforecast/docs/getting-started/quick_start_distributed.html

Sets up a Dask client to manage the cluster.

```python
client = Client(n_workers=2, threads_per_worker=1)
```

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

### 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)
```

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

### Build from Source

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

Install from the source distribution to compile the Rust extension, requiring a stable Rust toolchain.

```bash
pip install synforecast --no-binary synforecast
```

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

### Install Development Dependencies

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

Commands to install the development version of NeuralForecast with specific PyTorch backends.

```bash
$ uv pip install -e ".[dev]" --torch-backend cpu # for cpu backend
$ uv pip install -e ".[dev]" --torch-backend cu118 # for CUDA 11.8 PyTorch backend
```

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

### Install MLForecast via Conda

Source: https://nixtlaverse.nixtla.io/mlforecast/docs/getting-started/install.html

Standard installation command for the latest release from the conda-forge channel.

```bash
conda install -c conda-forge mlforecast
```

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

### 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
```

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

### TCN Forecasting and Visualization Example

Source: https://nixtlaverse.nixtla.io/neuralforecast/models.tcn.html

A complete workflow demonstrating how to initialize the TCN model, fit it to training data, generate forecasts, and plot the resulting quantile predictions.

```python
import pandas as pd
import matplotlib.pyplot as plt

from neuralforecast import NeuralForecast
from neuralforecast.models import TCN
from neuralforecast.losses.pytorch import  DistributionLoss
from neuralforecast.utils import AirPassengersPanel, AirPassengersStatic

Y_train_df = AirPassengersPanel[AirPassengersPanel.ds<AirPassengersPanel['ds'].values[-12]] # 132 train
Y_test_df = AirPassengersPanel[AirPassengersPanel.ds>=AirPassengersPanel['ds'].values[-12]].reset_index(drop=True) # 12 test

fcst = NeuralForecast(
    models=[TCN(h=12,
                input_size=-1,
                loss=DistributionLoss(distribution='Normal', level=[80, 90]),
                learning_rate=5e-4,
                kernel_size=2,
                dilations=[1,2,4,8,16],
                encoder_hidden_size=128,
                context_size=10,
                decoder_hidden_size=128,
                decoder_layers=2,
                max_steps=500,
                scaler_type='robust',
                futr_exog_list=['y_[lag12]'],
                hist_exog_list=None,
                stat_exog_list=['airline1'],
                )
    ],
    freq='ME'
)
fcst.fit(df=Y_train_df, static_df=AirPassengersStatic)
forecasts = fcst.predict(futr_df=Y_test_df)

# Plot quantile predictions
Y_hat_df = forecasts.reset_index(drop=False).drop(columns=['unique_id','ds'])
plot_df = pd.concat([Y_test_df, Y_hat_df], axis=1)
plot_df = pd.concat([Y_train_df, plot_df])

plot_df = plot_df[plot_df.unique_id=='Airline1'].drop('unique_id', axis=1)
plt.plot(plot_df['ds'], plot_df['y'], c='black', label='True')
plt.plot(plot_df['ds'], plot_df['TCN-median'], c='blue', label='median')
plt.fill_between(x=plot_df['ds'][-12:], 
                 y1=plot_df['TCN-lo-90'][-12:].values,
                 y2=plot_df['TCN-hi-90'][-12:].values,
                 alpha=0.4, label='level 90')
plt.legend()
plt.grid()
plt.plot()
```

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

### ADF test output example

Source: https://nixtlaverse.nixtla.io/mlforecast/docs/tutorials/prediction_intervals_in_forecasting_models.html

Example output showing the statistical results of the ADF test.

```text
Dickey-Fuller test results for columns: Ads
Test Statistic                -1.076452e+01
p-value                        2.472132e-19
No Lags Used                   3.900000e+01
Number of observations used    1.028000e+04
Critical Value (1%)           -3.430986e+00
Critical Value (5%)           -2.861821e+00
Critical Value (10%)          -2.566920e+00
dtype: float64
Conclusion:====>
Reject the null hypothesis
The data is stationary
```

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

### Importing dependencies for LightGBMCV example

Source: https://nixtlaverse.nixtla.io/mlforecast/lgb_cv.html

Required imports for running the LightGBMCV example with M4 dataset.

```python
import random

from datasetsforecast.m4 import M4, M4Info
from fastcore.test import test_eq, test_fail
from mlforecast.target_transforms import Differences
from nbdev import show_doc

from mlforecast.lag_transforms import SeasonalRollingMean
```

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

### 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
```

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

### Instantiate an Auto model with Optuna

Source: https://nixtlaverse.nixtla.io/neuralforecast/docs/capabilities/hyperparameter_tuning.html

Basic configuration for an AutoNHITS model using the Optuna backend and TPESampler.

```python
model = AutoNHITS(
    h=12,
    loss=MAE(),
    config=config_nhits,
    search_alg=optuna.samplers.TPESampler(seed=0),
    backend='optuna',
    num_samples=10,
)
```

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

### TFT Model Training and Prediction Example

Source: https://nixtlaverse.nixtla.io/neuralforecast/models.tft.html

Demonstrates the full workflow for the TFT model, including data splitting, model configuration with exogenous variables, training, and plotting quantile predictions.

```python
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd

from neuralforecast import NeuralForecast

# from neuralforecast.models import TFT
from neuralforecast.losses.pytorch import DistributionLoss
from neuralforecast.utils import AirPassengersPanel, AirPassengersStatic

AirPassengersPanel["month"] = AirPassengersPanel.ds.dt.month
Y_train_df = AirPassengersPanel[
    AirPassengersPanel.ds < AirPassengersPanel["ds"].values[-12]
]  # 132 train
Y_test_df = AirPassengersPanel[
    AirPassengersPanel.ds >= AirPassengersPanel["ds"].values[-12]
].reset_index(drop=True)  # 12 test

nf = NeuralForecast(
    models=[
        TFT(
            h=12,
            input_size=48,
            hidden_size=20,
            grn_activation="ELU",
            rnn_type="lstm",
            n_rnn_layers=1,
            one_rnn_initial_state=False,
            loss=DistributionLoss(distribution="StudentT", level=[80, 90]),
            learning_rate=0.005,
            stat_exog_list=["airline1"],
            futr_exog_list=["y_[lag12]", "month"],
            hist_exog_list=["trend"],
            max_steps=300,
            val_check_steps=10,
            early_stop_patience_steps=10,
            scaler_type="robust",
            windows_batch_size=None,
            enable_progress_bar=True,
        ),
    ],
    freq="ME",
)
nf.fit(df=Y_train_df, static_df=AirPassengersStatic, val_size=12)
Y_hat_df = nf.predict(futr_df=Y_test_df)

# Plot quantile predictions
Y_hat_df = Y_hat_df.reset_index(drop=False).drop(columns=["unique_id", "ds"])
plot_df = pd.concat([Y_test_df, Y_hat_df], axis=1)
plot_df = pd.concat([Y_train_df, plot_df])

plot_df = plot_df[plot_df.unique_id == "Airline1"].drop("unique_id", axis=1)
plt.plot(plot_df["ds"], plot_df["y"], c="black", label="True")
plt.plot(plot_df["ds"], plot_df["TFT"], c="purple", label="mean")
plt.plot(plot_df["ds"], plot_df["TFT-median"], c="blue", label="median")
plt.fill_between(
    x=plot_df["ds"][-12:],
    y1=plot_df["TFT-lo-90"][-12:].values,
    y2=plot_df["TFT-hi-90"][-12:].values,
    alpha=0.4,
    label="level 90",
)
plt.legend()
plt.grid()
plt.plot()
```

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

### Install NeuralForecast via Conda

Source: https://nixtlaverse.nixtla.io/neuralforecast/docs/getting-started/introduction.html

Use conda to install the released version of the library from the conda-forge channel.

```python
conda install -c conda-forge neuralforecast
```

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

### 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()]
```
Tokens:
Raw