Getting Started
Fit an LSTM and NHITS model
This notebook provides an example on how to start using the main
functionalities of the NeuralForecast library. The
NeuralForecast
class allows users to easily interact with NeuralForecast.models
PyTorch models. In this example we will forecast AirPassengers data with
a classic
LSTM
and the recent
NHITS
models. The full list of available models is available
here.
You can run these experiments using GPU with Google Colab.
1. Installing NeuralForecast
!pip install neuralforecast
2. Loading AirPassengers Data
The core.NeuralForecast
class contains shared, fit
, predict
and
other methods that take as inputs pandas DataFrames with columns
['unique_id', 'ds', 'y']
, where unique_id
identifies individual time
series from the dataset, ds
is the date, and y
is the target
variable.
In this example dataset consists of a set of a single series, but you can easily fit your model to larger datasets in long format.
from neuralforecast.utils import AirPassengersDF
Y_df = AirPassengersDF # Defined in neuralforecast.utils
Y_df.head()
unique_id | ds | y | |
---|---|---|---|
0 | 1.0 | 1949-01-31 | 112.0 |
1 | 1.0 | 1949-02-28 | 118.0 |
2 | 1.0 | 1949-03-31 | 132.0 |
3 | 1.0 | 1949-04-30 | 129.0 |
4 | 1.0 | 1949-05-31 | 121.0 |
Important
DataFrames must include all
['unique_id', 'ds', 'y']
columns. Make surey
column does not have missing or non-numeric values.
3. Model Training
Fit the models
Using the
NeuralForecast.fit
method you can train a set of models to your dataset. You can define the
forecasting horizon
(12 in this example), and modify the
hyperparameters of the model. For example, for the
LSTM
we changed the default hidden size for both encoder and decoders.
from neuralforecast import NeuralForecast
from neuralforecast.models import LSTM, NHITS, RNN
horizon = 12
# Try different hyperparmeters to improve accuracy.
models = [LSTM(h=horizon, # Forecast horizon
max_steps=500, # Number of steps to train
scaler_type='standard', # Type of scaler to normalize data
encoder_hidden_size=64, # Defines the size of the hidden state of the LSTM
decoder_hidden_size=64,), # Defines the number of hidden units of each layer of the MLP decoder
NHITS(h=horizon, # Forecast horizon
input_size=2 * horizon, # Length of input sequence
max_steps=100, # Number of steps to train
n_freq_downsample=[2, 1, 1]) # Downsampling factors for each stack output
]
nf = NeuralForecast(models=models, freq='M')
nf.fit(df=Y_df)
Tip
The performance of Deep Learning models can be very sensitive to the choice of hyperparameters. Tuning the correct hyperparameters is an important step to obtain the best forecasts. The
Auto
version of these models,AutoLSTM
andAutoNHITS
, already perform hyperparameter selection automatically.
Predict using the fitted models
Using the
NeuralForecast.predict
method you can obtain the h
forecasts after the training data Y_df
.
Y_hat_df = nf.predict()
Predicting DataLoader 0: 100%|ββββββββββ| 1/1 [00:00<00:00, 50.58it/s]
Predicting DataLoader 0: 100%|ββββββββββ| 1/1 [00:00<00:00, 126.52it/s]
The
NeuralForecast.predict
method returns a DataFrame with the forecasts for each unique_id
,
ds
, and model.
Y_hat_df = Y_hat_df.reset_index()
Y_hat_df.head()
unique_id | ds | LSTM | NHITS | |
---|---|---|---|---|
0 | 1.0 | 1961-01-31 | 424.380310 | 453.039185 |
1 | 1.0 | 1961-02-28 | 442.092010 | 429.609192 |
2 | 1.0 | 1961-03-31 | 448.555664 | 498.796204 |
3 | 1.0 | 1961-04-30 | 473.586609 | 509.536224 |
4 | 1.0 | 1961-05-31 | 512.466370 | 524.131592 |
4. Plot Predictions
Finally, we plot the forecasts of both models againts the real values.
import pandas as pd
import matplotlib.pyplot as plt
fig, ax = plt.subplots(1, 1, figsize = (20, 7))
plot_df = pd.concat([Y_df, Y_hat_df]).set_index('ds') # Concatenate the train and forecast dataframes
plot_df[['y', 'LSTM', 'NHITS']].plot(ax=ax, linewidth=2)
ax.set_title('AirPassengers Forecast', fontsize=22)
ax.set_ylabel('Monthly Passengers', fontsize=20)
ax.set_xlabel('Timestamp [t]', fontsize=20)
ax.legend(prop={'size': 15})
ax.grid()
Tip
For this guide we are using a simple
LSTM
model. More recent models, such asRNN
,GRU
, andDilatedRNN
achieve better accuracy thanLSTM
in most settings. The full list of available models is available here.
References
- Boris N. Oreshkin, Dmitri Carpov, Nicolas Chapados, Yoshua Bengio
(2020). βN-BEATS: Neural basis expansion analysis for interpretable
time series forecastingβ. International Conference on Learning
Representations.
- Cristian Challu, Kin G. Olivares, Boris N. Oreshkin, Federico Garza, Max Mergenthaler-Canseco, Artur Dubrawski (2021). NHITS: Neural Hierarchical Interpolation for Time Series Forecasting. Accepted at AAAI 2023.