pytorch-ts/examples/m5.ipynb

In [1]:

import matplotlib.pyplot as plt
import json
from functools import partial

In [2]:

import torch

In [3]:

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

In [20]:

from gluonts.dataset.repository.datasets import get_dataset
from gluonts.dataset.util import to_pandas
from gluonts.evaluation import Evaluator
from gluonts.evaluation.backtest import make_evaluation_predictions

In [14]:

from pts.model.deepar import DeepAREstimator
from pts.modules import ZeroInflatedNegativeBinomialOutput
from pts import Trainer

In [8]:

dataset = get_dataset("pts_m5", regenerate=False)

saving time-series into /Users/krasul/.mxnet/gluon-ts/datasets/pts_m5/train/data.json
saving time-series into /Users/krasul/.mxnet/gluon-ts/datasets/pts_m5/test/data.json

In [9]:

entry = next(iter(dataset.train))
train_series = to_pandas(entry)
train_series.plot()
plt.grid(which="both")
plt.legend(["train series"], loc="upper left")
plt.title(entry['item_id'])
plt.show()

In [10]:

entry = next(iter(dataset.test))
test_series = to_pandas(entry)
test_series.plot()
plt.axvline(train_series.index[-1], color='r') # end of train dataset
plt.grid(which="both")
plt.legend(["test series", "end of train series"], loc="upper left")
plt.title(entry['item_id'])
plt.show()

In [11]:

print(f"Recommended prediction horizon: {dataset.metadata.prediction_length}")
print(f"Frequency of the time series: {dataset.metadata.freq}")

Recommended prediction horizon: 28
Frequency of the time series: D

In [17]:

estimator = DeepAREstimator(
    distr_output=ZeroInflatedNegativeBinomialOutput(),
    cell_type='GRU',
    input_size=72,
    num_cells=64,
    num_layers=3,
    dropout_rate=0.2,
    use_feat_dynamic_real=True,
    use_feat_static_cat=True,
    cardinality=[int(cat_feat_info.cardinality) for cat_feat_info in dataset.metadata.feat_static_cat],
    embedding_dimension = [4, 4, 4, 4, 16],
    prediction_length=dataset.metadata.prediction_length,
    context_length=dataset.metadata.prediction_length*2,
    freq=dataset.metadata.freq,
    scaling=True,
    trainer=Trainer(device=device,
                    epochs=1,
                    learning_rate=1e-3,
                    num_batches_per_epoch=120,
                    batch_size=256,
                    num_workers=8,
                   )
)

In [18]:

predictor = estimator.train(dataset.train)

119it [02:44,  1.39s/it, avg_epoch_loss=1.18, epoch=0]

In [21]:

forecast_it, ts_it = make_evaluation_predictions(
    dataset=dataset.test,  # test dataset
    predictor=predictor,  # predictor
    num_samples=100,  # number of sample paths we want for evaluation
)

In [ ]:

forecasts = list(forecast_it)
tss = list(ts_it)

In [ ]:

evaluator = Evaluator()
agg_metrics, item_metrics = evaluator(iter(tss), iter(forecasts), num_series=len(dataset.test))

In [ ]:

print(json.dumps(agg_metrics, indent=4))

In [19]:

item_metrics.plot(x='MSIS', y='MASE', kind='scatter')
plt.grid(which="both")
plt.show()

In [ ]: