.. _sec_forecasting_quickstart:

Forecasting Time Series - Quick Start
=====================================


Via a simple ``fit()`` call, AutoGluon can train and tune

-  simple forecasting models (e.g., ARIMA, ETS, Theta),
-  powerful deep learning models (e.g., DeepAR, Temporal Fusion
   Transformer),
-  tree-based models (e.g., XGBoost, CatBoost, LightGBM),
-  an ensemble that combines predictions of other models

to produce multi-step ahead *probabilistic* forecasts for univariate
time series data.

This tutorial demonstrates how to quickly start using AutoGluon to
generate hourly forecasts for the `M4 forecasting
competition <https://www.sciencedirect.com/science/article/pii/S0169207019301128>`__
dataset.

Loading time series data as a ``TimeSeriesDataFrame``
-----------------------------------------------------

First, we import some required modules

.. code:: python

    import pandas as pd
    from autogluon.timeseries import TimeSeriesDataFrame, TimeSeriesPredictor

To use ``autogluon.timeseries``, we will only need the following two
classes:

-  ``TimeSeriesDataFrame`` stores a dataset consisting of multiple time
   series.
-  ``TimeSeriesPredictor`` takes care of fitting, tuning and selecting
   the best forecasting models, as well as generating new forecasts.

We load a subset of the M4 hourly dataset as a ``pandas.DataFrame``

.. code:: python

    df = pd.read_csv("https://autogluon.s3.amazonaws.com/datasets/timeseries/m4_hourly_subset/train.csv")
    df.head()




.. raw:: html

    <div>
    <style scoped>
        .dataframe tbody tr th:only-of-type {
            vertical-align: middle;
        }
    
        .dataframe tbody tr th {
            vertical-align: top;
        }
    
        .dataframe thead th {
            text-align: right;
        }
    </style>
    <table border="1" class="dataframe">
      <thead>
        <tr style="text-align: right;">
          <th></th>
          <th>item_id</th>
          <th>timestamp</th>
          <th>target</th>
        </tr>
      </thead>
      <tbody>
        <tr>
          <th>0</th>
          <td>H1</td>
          <td>1750-01-01 00:00:00</td>
          <td>605.0</td>
        </tr>
        <tr>
          <th>1</th>
          <td>H1</td>
          <td>1750-01-01 01:00:00</td>
          <td>586.0</td>
        </tr>
        <tr>
          <th>2</th>
          <td>H1</td>
          <td>1750-01-01 02:00:00</td>
          <td>586.0</td>
        </tr>
        <tr>
          <th>3</th>
          <td>H1</td>
          <td>1750-01-01 03:00:00</td>
          <td>559.0</td>
        </tr>
        <tr>
          <th>4</th>
          <td>H1</td>
          <td>1750-01-01 04:00:00</td>
          <td>511.0</td>
        </tr>
      </tbody>
    </table>
    </div>



AutoGluon expects time series data in `long
format <https://doc.dataiku.com/dss/latest/time-series/data-formatting.html#long-format>`__.
Each row of the data frame contains a single observation (timestep) of a
single time series represented by

-  unique ID of the time series (``"item_id"``) as int or str
-  timestamp of the observation (``"timestamp"``) as a
   ``pandas.Timestamp`` or compatible format
-  numeric value of the time series (``"target"``)

The raw dataset should always follow this format with at least three
columns for unique ID, timestamp, and target value, but the names of
these columns can be arbitrary. It is important, however, that we
provide the names of the columns when constructing a
``TimeSeriesDataFrame`` that is used by AutoGluon. AutoGluon will raise
an exception if the data doesn’t match the expected format.

.. code:: python

    train_data = TimeSeriesDataFrame.from_data_frame(
        df,
        id_column="item_id",
        timestamp_column="timestamp"
    )
    train_data.head()




.. raw:: html

    <div>
    <style scoped>
        .dataframe tbody tr th:only-of-type {
            vertical-align: middle;
        }
    
        .dataframe tbody tr th {
            vertical-align: top;
        }
    
        .dataframe thead th {
            text-align: right;
        }
    </style>
    <table border="1" class="dataframe">
      <thead>
        <tr style="text-align: right;">
          <th></th>
          <th></th>
          <th>target</th>
        </tr>
        <tr>
          <th>item_id</th>
          <th>timestamp</th>
          <th></th>
        </tr>
      </thead>
      <tbody>
        <tr>
          <th rowspan="5" valign="top">H1</th>
          <th>1750-01-01 00:00:00</th>
          <td>605.0</td>
        </tr>
        <tr>
          <th>1750-01-01 01:00:00</th>
          <td>586.0</td>
        </tr>
        <tr>
          <th>1750-01-01 02:00:00</th>
          <td>586.0</td>
        </tr>
        <tr>
          <th>1750-01-01 03:00:00</th>
          <td>559.0</td>
        </tr>
        <tr>
          <th>1750-01-01 04:00:00</th>
          <td>511.0</td>
        </tr>
      </tbody>
    </table>
    </div>



We refer to each individual time series stored in a
``TimeSeriesDataFrame`` as an *item*. For example, items might
correspond to different products in demand forecasting, or to different
stocks in financial datasets. This setting is also referred to as a
*panel* of time series. Note that this is *not* the same as multivariate
forecasting — AutoGluon generates forecasts for each time series
individually, without modeling interactions between different items
(time series).

``TimeSeriesDataFrame`` inherits from
`pandas.DataFrame <https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.html>`__,
so all attributes and methods of ``pandas.DataFrame`` are available in a
``TimeSeriesDataFrame``. It also provides other utility functions, such
as loaders for different data formats (see
:class:`autogluon.timeseries.TimeSeriesDataFrame` for details).

Training time series models with ``TimeSeriesPredictor.fit``
------------------------------------------------------------

To forecast future values of the time series, we need to create a
``TimeSeriesPredictor`` object.

Models in ``autogluon.timeseries`` forecast time series *multiple steps*
into the future. We choose the number of these steps — the *prediction
length* (also known as the *forecast horizon*) — depending on our task.
For example, our dataset contains time series measured at hourly
*frequency*, so we set ``prediction_length = 48`` to train models that
forecast up to 48 hours into the future.

We instruct AutoGluon to save trained models in the folder
``./autogluon-m4-hourly``. We also specify that AutoGluon should rank
models according to `symmetric mean absolute percentage error
(sMAPE) <https://en.wikipedia.org/wiki/Symmetric_mean_absolute_percentage_error>`__,
and that data that we want to forecast is stored in the column
``"target"`` of the ``TimeSeriesDataFrame``.

.. code:: python

    predictor = TimeSeriesPredictor(
        prediction_length=48,
        path="autogluon-m4-hourly",
        target="target",
        eval_metric="sMAPE",
    )
    
    predictor.fit(
        train_data,
        presets="medium_quality",
        time_limit=600,
    )


.. parsed-literal::
    :class: output

    ================ TimeSeriesPredictor ================
    TimeSeriesPredictor.fit() called
    Setting presets to: medium_quality
    Fitting with arguments:
    {'enable_ensemble': True,
     'evaluation_metric': 'sMAPE',
     'hyperparameter_tune_kwargs': None,
     'hyperparameters': 'medium_quality',
     'prediction_length': 48,
     'random_seed': None,
     'target': 'target',
     'time_limit': 600}
    Provided training data set with 148060 rows, 200 items (item = single time series). Average time series length is 740.3.
    Training artifacts will be saved to: /home/ci/autogluon/docs/_build/eval/tutorials/timeseries/autogluon-m4-hourly
    =====================================================
    AutoGluon will save models to autogluon-m4-hourly/
    AutoGluon will gauge predictive performance using evaluation metric: 'sMAPE'
    	This metric's sign has been flipped to adhere to being 'higher is better'. The reported score can be multiplied by -1 to get the metric value.
    
    Provided dataset contains following columns:
    	target:           'target'
    tuning_data is None. Will use the last prediction_length = 48 time steps of each time series as a hold-out validation set.
    
    Starting training. Start time is 2023-02-04 01:00:39
    Models that will be trained: ['Naive', 'SeasonalNaive', 'ETS', 'Theta', 'ARIMA', 'AutoETS', 'AutoGluonTabular', 'DeepAR']
    Training timeseries model Naive. Training for up to 599.88s of the 599.88s of remaining time.
    	-0.4341       = Validation score (-sMAPE)
    	0.00    s     = Training runtime
    	5.98    s     = Validation (prediction) runtime
    Training timeseries model SeasonalNaive. Training for up to 593.88s of the 593.88s of remaining time.
    	-0.1686       = Validation score (-sMAPE)
    	0.00    s     = Training runtime
    	0.41    s     = Validation (prediction) runtime
    Training timeseries model ETS. Training for up to 593.46s of the 593.46s of remaining time.
    	-0.2700       = Validation score (-sMAPE)
    	0.00    s     = Training runtime
    	36.33   s     = Validation (prediction) runtime
    Training timeseries model Theta. Training for up to 557.12s of the 557.12s of remaining time.
    	-0.2236       = Validation score (-sMAPE)
    	0.00    s     = Training runtime
    	16.91   s     = Validation (prediction) runtime
    Training timeseries model ARIMA. Training for up to 540.19s of the 540.19s of remaining time.
    	-0.5269       = Validation score (-sMAPE)
    	0.00    s     = Training runtime
    	20.52   s     = Validation (prediction) runtime
    Training timeseries model AutoETS. Training for up to 519.65s of the 519.65s of remaining time.
    	-0.2381       = Validation score (-sMAPE)
    	0.00    s     = Training runtime
    	119.62  s     = Validation (prediction) runtime
    Training timeseries model AutoGluonTabular. Training for up to 400.02s of the 400.02s of remaining time.
    	-0.1089       = Validation score (-sMAPE)
    	49.16   s     = Training runtime
    	4.01    s     = Validation (prediction) runtime
    Training timeseries model DeepAR. Training for up to 346.85s of the 346.85s of remaining time.
    	-0.1405       = Validation score (-sMAPE)
    	110.25  s     = Training runtime
    	2.93    s     = Validation (prediction) runtime
    Fitting simple weighted ensemble.
    	-0.1077       = Validation score (-sMAPE)
    	8.52    s     = Training runtime
    	12.92   s     = Validation (prediction) runtime
    Training complete. Models trained: ['Naive', 'SeasonalNaive', 'ETS', 'Theta', 'ARIMA', 'AutoETS', 'AutoGluonTabular', 'DeepAR', 'WeightedEnsemble']
    Total runtime: 382.51 s
    Best model: WeightedEnsemble
    Best model score: -0.1077




.. parsed-literal::
    :class: output

    <autogluon.timeseries.predictor.TimeSeriesPredictor at 0x7fbef6aa3940>



Here we used the ``"medium_quality"`` presets and limited the training
time to 10 minutes (600 seconds). The presets define which models
AutoGluon will try to fit. For ``medium_quality`` presets, these are
simple baselines (``Naive``, ``SeasonalNaive``), statistical models
(``ARIMA``, ``ETS``, ``Theta``), tree-based models XGBoost, LightGBM and
CatBoost wrapped by ``AutoGluonTabular``, a deep learning model
``DeepAR``, and a weighted ensemble combining these. Other available
presets for ``TimeSeriesPredictor`` are ``"fast_training"``,
``"high_quality"`` and ``"best_quality"``. Higher quality presets will
usually produce more accurate forecasts but take longer to train and may
produce less computationally efficient models.

Inside ``fit()``, AutoGluon will train as many models as possible within
the given time limit. Trained models are then ranked based on their
performance on an internal validation set. By default, this validation
set is constructed by holding out the last ``prediction_length``
timesteps of each time series in ``train_data``.

Generating forecasts with ``TimeSeriesPredictor.predict``
---------------------------------------------------------

We can now use the fitted ``TimeSeriesPredictor`` to forecast the future
time series values. By default, AutoGluon will make forecasts using the
model that had the best score on the internal validation set. The
forecast always includes predictions for the next ``prediction_length``
timesteps, starting from the end of each time series in ``train_data``.

.. code:: python

    predictions = predictor.predict(train_data)
    predictions.head()


.. parsed-literal::
    :class: output

    Global seed set to 123
    Model not specified in predict, will default to the model with the best validation score: WeightedEnsemble




.. raw:: html

    <div>
    <style scoped>
        .dataframe tbody tr th:only-of-type {
            vertical-align: middle;
        }
    
        .dataframe tbody tr th {
            vertical-align: top;
        }
    
        .dataframe thead th {
            text-align: right;
        }
    </style>
    <table border="1" class="dataframe">
      <thead>
        <tr style="text-align: right;">
          <th></th>
          <th></th>
          <th>mean</th>
          <th>0.1</th>
          <th>0.2</th>
          <th>0.3</th>
          <th>0.4</th>
          <th>0.5</th>
          <th>0.6</th>
          <th>0.7</th>
          <th>0.8</th>
          <th>0.9</th>
        </tr>
        <tr>
          <th>item_id</th>
          <th>timestamp</th>
          <th></th>
          <th></th>
          <th></th>
          <th></th>
          <th></th>
          <th></th>
          <th></th>
          <th></th>
          <th></th>
          <th></th>
        </tr>
      </thead>
      <tbody>
        <tr>
          <th rowspan="5" valign="top">H1</th>
          <th>1750-01-30 04:00:00</th>
          <td>656.114372</td>
          <td>585.443149</td>
          <td>619.846842</td>
          <td>637.488263</td>
          <td>648.272016</td>
          <td>656.499391</td>
          <td>664.142341</td>
          <td>673.257205</td>
          <td>687.407885</td>
          <td>719.433649</td>
        </tr>
        <tr>
          <th>1750-01-30 05:00:00</th>
          <td>586.323865</td>
          <td>515.876737</td>
          <td>550.381785</td>
          <td>567.859066</td>
          <td>578.617251</td>
          <td>586.689677</td>
          <td>594.257317</td>
          <td>603.358807</td>
          <td>617.538712</td>
          <td>649.750630</td>
        </tr>
        <tr>
          <th>1750-01-30 06:00:00</th>
          <td>549.195173</td>
          <td>477.522066</td>
          <td>512.200689</td>
          <td>530.092362</td>
          <td>541.106824</td>
          <td>549.451446</td>
          <td>557.333342</td>
          <td>566.699517</td>
          <td>581.117846</td>
          <td>613.746183</td>
        </tr>
        <tr>
          <th>1750-01-30 07:00:00</th>
          <td>512.129297</td>
          <td>440.691317</td>
          <td>475.142323</td>
          <td>493.083844</td>
          <td>504.056815</td>
          <td>512.365382</td>
          <td>520.295670</td>
          <td>529.671247</td>
          <td>543.847530</td>
          <td>576.816137</td>
        </tr>
        <tr>
          <th>1750-01-30 08:00:00</th>
          <td>486.210995</td>
          <td>414.201189</td>
          <td>448.709973</td>
          <td>466.497031</td>
          <td>477.746095</td>
          <td>486.078310</td>
          <td>494.280166</td>
          <td>504.023036</td>
          <td>518.548270</td>
          <td>551.628344</td>
        </tr>
      </tbody>
    </table>
    </div>



AutoGluon produces a *probabilistic* forecast: in addition to predicting
the mean (expected value) of the time series in the future, models also
provide the quantiles of the forecast distribution. The quantile
forecasts give us an idea about the range of possible outcomes. For
example, if the ``"0.1"`` quantile is equal to ``500.0``, it means that
the model predicts a 10% chance that the target value will be below
``500.0``.

We will now visualize the forecast and the actually observed values for
one of the time series in the dataset. We plot the mean forecast, as
well as the 10% and 90% quantiles to show the range of potential
outcomes.

.. code:: python

    import matplotlib.pyplot as plt
    
    # TimeSeriesDataFrame can also be loaded directly from a file
    test_data = TimeSeriesDataFrame.from_path("https://autogluon.s3.amazonaws.com/datasets/timeseries/m4_hourly_subset/test.csv")
    
    plt.figure(figsize=(20, 3))
    
    item_id = "H1"
    y_past = train_data.loc[item_id]["target"]
    y_pred = predictions.loc[item_id]
    y_test = test_data.loc[item_id]["target"][-48:]
    
    plt.plot(y_past[-200:], label="Past time series values")
    plt.plot(y_pred["mean"], label="Mean forecast")
    plt.plot(y_test, label="Future time series values")
    
    plt.fill_between(
        y_pred.index, y_pred["0.1"], y_pred["0.9"], color="red", alpha=0.1, label=f"10%-90% confidence interval"
    )
    plt.legend();


.. parsed-literal::
    :class: output

    Loaded data from: https://autogluon.s3.amazonaws.com/datasets/timeseries/m4_hourly_subset/test.csv | Columns = 3 / 3 | Rows = 157660 -> 157660



.. figure:: output_forecasting-quickstart_a33e23_11_1.png


Evaluating the performance of different models
----------------------------------------------

We can view the performance of each model AutoGluon has trained via the
``leaderboard()`` method. We provide the test data set to the
leaderboard function to see how well our fitted models are doing on the
unseen test data. The leaderboard also includes the validation scores
computed on the internal validation dataset.

In AutoGluon leaderboards, higher scores always correspond to better
predictive performance. Therefore our sMAPE scores are multiplied by
``-1``, such that higher “negative sMAPE”s correspond to more accurate
forecasts.

.. code:: python

    # The test score is computed using the last
    # prediction_length=48 timesteps of each time series in test_data
    predictor.leaderboard(test_data, silent=True)


.. parsed-literal::
    :class: output

    Additional data provided, testing on additional data. Resulting leaderboard will be sorted according to test score (`score_test`).




.. raw:: html

    <div>
    <style scoped>
        .dataframe tbody tr th:only-of-type {
            vertical-align: middle;
        }
    
        .dataframe tbody tr th {
            vertical-align: top;
        }
    
        .dataframe thead th {
            text-align: right;
        }
    </style>
    <table border="1" class="dataframe">
      <thead>
        <tr style="text-align: right;">
          <th></th>
          <th>model</th>
          <th>score_test</th>
          <th>score_val</th>
          <th>pred_time_test</th>
          <th>pred_time_val</th>
          <th>fit_time_marginal</th>
          <th>fit_order</th>
        </tr>
      </thead>
      <tbody>
        <tr>
          <th>0</th>
          <td>WeightedEnsemble</td>
          <td>-0.103661</td>
          <td>-0.107725</td>
          <td>6.891848</td>
          <td>12.922808</td>
          <td>8.522340</td>
          <td>9</td>
        </tr>
        <tr>
          <th>1</th>
          <td>AutoGluonTabular</td>
          <td>-0.105318</td>
          <td>-0.108919</td>
          <td>4.383806</td>
          <td>4.008490</td>
          <td>49.155455</td>
          <td>7</td>
        </tr>
        <tr>
          <th>2</th>
          <td>SeasonalNaive</td>
          <td>-0.119063</td>
          <td>-0.168566</td>
          <td>0.675475</td>
          <td>0.412113</td>
          <td>0.002674</td>
          <td>2</td>
        </tr>
        <tr>
          <th>3</th>
          <td>DeepAR</td>
          <td>-0.155630</td>
          <td>-0.140511</td>
          <td>2.741418</td>
          <td>2.930491</td>
          <td>110.253879</td>
          <td>8</td>
        </tr>
        <tr>
          <th>4</th>
          <td>Theta</td>
          <td>-0.194352</td>
          <td>-0.223630</td>
          <td>17.686495</td>
          <td>16.914176</td>
          <td>0.001509</td>
          <td>4</td>
        </tr>
        <tr>
          <th>5</th>
          <td>AutoETS</td>
          <td>-0.195432</td>
          <td>-0.238137</td>
          <td>124.697685</td>
          <td>119.621259</td>
          <td>0.001485</td>
          <td>6</td>
        </tr>
        <tr>
          <th>6</th>
          <td>ETS</td>
          <td>-0.217874</td>
          <td>-0.269993</td>
          <td>37.479012</td>
          <td>36.326315</td>
          <td>0.001464</td>
          <td>3</td>
        </tr>
        <tr>
          <th>7</th>
          <td>Naive</td>
          <td>-0.453291</td>
          <td>-0.434068</td>
          <td>0.184462</td>
          <td>5.983827</td>
          <td>0.003098</td>
          <td>1</td>
        </tr>
        <tr>
          <th>8</th>
          <td>ARIMA</td>
          <td>-0.518139</td>
          <td>-0.526885</td>
          <td>21.852686</td>
          <td>20.521975</td>
          <td>0.001479</td>
          <td>5</td>
        </tr>
      </tbody>
    </table>
    </div>



Summary
-------

We used ``autogluon.timeseries`` to make probabilistic multi-step
forecasts on the M4 Hourly dataset. Check out
:ref:`sec_forecasting_indepth` to learn about the advanced
capabilities of AutoGluon for time series forecasting.