Guide To GluonTS and PytorchTS For Time-Series Forecasting (With Python Implementation)
GluonTS is a toolkit that is specifically designed for probabilistic time series modeling, It is a subpart of the Gluon organization, Gluon is an open-source deep-learning interface that allows developers to build neural nets without compromising performance and efficiency. AWS and Microsoft first introduced it on October 12th, 2017 that provides many different neural network architectures and leverages the deep learning models. It combines many packages into one like mxnet– a lightweight, portable, flexible Distributed/Mobile Deep learning model; for Python, R, Julia, Scala. Go, Javascript, and more. Gluon’s goal is to leverage Jupyter notebooks’ strengths to present graphics, equations, and code together in one place. Table of contentsGluonTSInstallationGetting Started Let’s take an example dataset to forecast time series dataset using GluonTSTrainingEvaluateOutputPyTorch-tsInstallationGetting StartedConclusion GluonTS “GluonTS simplifies the development of and experimentation with time series models for common tasks such as forecasting or anomaly detection. It provides all necessary components and tools that scientists need for quickly building new models, for efficiently running and analyzing experiments and for evaluating model accuracy.”— GluonTS Arxiv Research paper GluonTS is a toolkit that is specifically designed for probabilistic time series modeling, GlounTS provides the utilities for loading and looping over time-series datasets. It also provides state of the art models for time series forecasting, and a building block to define your own models and quickly test with different solutions, GluonTS has many features like you can: Train and evaluate any inbuilt models on your custom datasetQuickly create your solution using GluonTSIt provides custom abstractions and building blocks to create custom models.Provide multiple baseline algorithms for comparison.Plotting and evaluation facilitiesArtificial and real datasets. Installation pip install gluonts # as gluonts relies on mxnet # install MXnet using pip pip install mxnet Getting Started We have seen time series forecasting using TensorFlow and PyTorch, but they come with a lot of code and require great proficiency over the framework. GluonTS provide simple and on point code for running your time series forecasting here is an example code to run GluonTS for predicting Twitter volume with DeepAR. You can run the following code in a cloud development environment at: https://github.com/mmaithani/data-science/blob/main/Gluonts_twitter_volume_forecasting.ipynb #importing gluonTS utilities and pandas from gluonts.dataset import common from gluonts.model import deepar from gluonts.trainer import Trainer import pandas as pd #getting train datatset of twitter volume url = "https://raw.githubusercontent.com/numenta/NAB/master/data/realTweets/Twitter_volume_AMZN.csv" df = pd.read_csv(url, header=0, index_col=0) data = common.ListDataset([{ "start": df.index[0], "target": df.value[:"2015-04-05 00:00:00"] }], freq="5min") #initializing trainers and deepAR estimators trainer = Trainer(epochs=10) estimator = deepar.DeepAREstimator( freq="5min", prediction_length=12, trainer=trainer) predictor = estimator.train(training_data=data) prediction = next(predictor.predict(data)) print(prediction.mean) prediction.plot(output_file='graph.png') Let’s take an example dataset to forecast time series dataset using GluonTS #importing modules %matplotlib inline import mxnet as mx from mxnet import gluon import numpy as np import pandas as pd import matplotlib.pyplot as plt import json Importing inbuilt GluonTS datasets from gluonts.dataset.repository.datasets import get_dataset, dataset_recipes from gluonts.dataset.util import to_pandas print(f"Available datasets: {list(dataset_recipes.keys())}") We are going to use the m4_hourly dataset, now the datasets provided by gluonts are objects that consist of three main attributes we will see later. dataset = get_dataset("m4_hourly", regenerate=True) Three main attributes of GluonTs dataset are dataset.train is a training dataset, dataset.test is a testing dataset, and dataset.metadata contains metadata of the dataset. Let’s plot and iterate the dataset using the following command. 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.show() Similarly, you can plot test dataset 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.show() Preprocessing N = 10 # number of time series T = 100 # number of timesteps prediction_length = 24 freq = "1H" custom_dataset = np.random.normal(size=(N, T)) start = pd.Timestamp("01-01-2019", freq=freq) # can be different for each time series Now for splitting dataset and converting it to gluonts format use following commands: from gluonts.dataset.common import ListDataset # train dataset: cut "prediction_length", add "target" and "start" fields train_ds = ListDataset([{'target': x, 'start': start} for x in custom_dataset[:, :-prediction_length]], freq=freq) # test dataset: using whole dataset, add "target" and "start" fields test_ds = ListDataset([{'target': x, 'start': start} for x in custom_dataset], freq=freq) Training GlounTS comes with its own hyper parameters and feedforward neural network like SimpleFeedForwardEstimator that accepts an input window of length context_length and predicts the distribution of the value. Let;s import necessary training methods and assign estimators values using following commands: from gluonts.model.simple_feedforward import SimpleFeedForwardEstimator from gluonts.trainer import Trainer estimator = SimpleFeedForwardEstimator( num_hidden_dimensions=[10], prediction_length=dataset.metadata.prediction_length, context_length=100, freq=dataset.metadata.freq, trainer=Trainer(ctx="cpu", epochs=5, learning_rate=1e-3, num_batches_per_epoch=100 ) ) #start training predictor = estimator.train(dataset.train) Evaluate For evaluating the models we have further make_evaluation_predictions function that automates the process of prediction and model evaluation. from gluonts.evaluation.backtest import make_evaluation_predictions forecast_it, ts_it = make_evaluation_predictions( dataset=dataset.test, # test dataset predictor=predictor, # predictor num_samples=100, # number of sample paths for evaluation ) Convert the generators to list to ease the computations and examine the first element of these lists: forecasts = list(forecast_it) tss = list(ts_it) # first entry of the time series list ts_entry = tss[0] Convert the first five value of time-series from pandas to NumPy and initialize first entry of dataset.test np.array(ts_entry[:5]).reshape(-1,) dataset_test_entry = next(iter(dataset.test)) Similarly first 5 values and forecast entries dataset_test_entry['target'][:5] forecast_entry = forecasts[0] Output For visualizing the outputs use following commands: def plot_prob_forecasts(ts_entry, forecast_entry): plot_length = 150 prediction_intervals = (50.0, 90.0) legend = ["observations", "median prediction"] + [f"{k}% prediction interval" for k in prediction_intervals][::-1] fig, ax = plt.subplots(1, 1, figsize=(10, 7)) ts_entry[-plot_length:].plot(ax=ax) # plot the time series forecast_entry.plot(prediction_intervals=prediction_intervals, color='g') plt.grid(which="both") plt.legend(legend, loc="upper left") plt.show() plot_prob_forecasts(ts_entry, forecast_entry) You can also evaluate the quality of time series forecast using evaluator class, that can compute the aggregate performance metrics, from gluonts.evaluation import Evaluator evaluator = Evaluator(quantiles=[0.1, 0.5, 0.9]) agg_metrics, item_metrics = evaluator(iter(tss), iter(forecasts), num_series=len(dataset.test)) print(json.dumps(agg_metrics, indent=4)) PyTorch-ts You can achieve similar results using a third party framework called PyTorch-ts, built by Zalando Research, that is specifically designed for PyTorch enthusiasts, Pytorch-ts is probabilistic Time Series forecasting framework based on GluonTS backend and its installation and usage are pretty easy, you can find the source code here, There very minimal changes in Pytorch-ts as it used the Pytorch time series model by utilizing GluonTS as its API for loading dataset, transforming and testing. Installation $ pip install pytorchts Getting Started We are going to use a dataset volume of tweets mentioning the AMZN ticker symbol, to leverage the power of this model, first import the necessary packages using below commands, Notebook is available at: https://github.com/mmaithani/data-science/blob/main/PyTorch_ts_time_series_forecasting(gluonts).ipynb import pandas as pd import torch import matplotlib.pyplot as plt from pts.dataset import ListDataset from pts.model.deepar import DeepAREstimator from pts import Trainer from pts.dataset import to_pandas Import the Amazon tweets dataset: and plot the first 100 data points using pandas and plt. url = "https://raw.githubusercontent.com/numenta/NAB/master/data/realTweets/Twitter_volume_AMZN.csv" df = pd.read_csv(url, header=0, index_col=0, parse_dates=True) df[:100].plot(linewidth=2) plt.grid(which='both') plt.show(} Train the dataset using Pytorch-ts, we are using the data up to midnight on April 5th, 2015, and a 5mins data so req is set to 5min with 15epochs and we are expecting prediction for next hour, so prediction_length is set to 12. training_data = ListDataset( [{"start": df.index[0], "target": df.value[:"2015-04-05 00:00:00"]}], freq = "5min") # parameter initialization device = torch.device("cuda" if torch.cuda.is_available() else "cpu") estimator = DeepAREstimator(freq="5min", prediction_length=12, input_size=43, trainer=Trainer(epochs=15, device=device)) predictor = estimator.train(training_data=training_data) Model is trained so lets forecast the hour following the midnight on 15-04-2015: test_data = ListDataset( [{"start": df.index[0], "target": df.value[:"2015-04-15 00:00:00"]}], freq = "5min") for test_entry, forecast in zip(test_data, predictor.predict(test_data)): to_pandas(test_entry)[-60:].plot(linewidth=2) forecast.plot(color='b', prediction_intervals=[50.0, 90.0]) plt.grid(which='both') Conclusion We have discussed time series forecasting using GluonTS a forecasting library explicitly made for probabilistic time series problems and the outputs were quite satisfactory. We saw the same approach using PytorchTs (PyTorch-based time series framework backed by Gluon) also the Gluon integrates many other features. There are third party libraries are also been made on top of GluonTS that we are not discussing in this article like pytorch-ts which is a PyTorch-based Probabilistic time series forecasting model based on GluonTS backend. Working notebooks and other resources used in the above demonstration: GluonTs  notebook  PyTorch-ts notebookGluonTs on M4 dataset notebookGluonTS Research Paper
GluonTS is a toolkit that is specifically designed for probabilistic time series modeling, It is a subpart of the Gluon organization, Gluon is an open-source deep-learning interface that allows developers to build neural nets without compromising performance and efficiency. AWS and Microsoft first introduced it on October 12th, 2017 that provides many different neural network […]
GluonTS simplifies the development and experimentation with time series models, while Pytorch-TS is a probabilistic Time Series framework
["Matplotlib", "Time Series", "Time Series Forecasting", "time series prediction"]
["NumPy", "AI", "neural network", "TensorFlow", "PyTorch", "Time Series Forecasting", "Ray", "deep learning", "Time Series", "Jupyter", "time series prediction", "Matplotlib", "Pandas"]
["AI", "deep learning", "neural network", "Ray", "TensorFlow", "PyTorch", "Jupyter", "Pandas", "NumPy", "Matplotlib"]
Mohit is a Data &amp; Technology Enthusiast with good exposure to solving real-world problems in various avenues of IT and Deep learning domain. He believes in solving human's daily problems with the help of technology.