2. Examples: forecasting (30%)

Forecasting

Basic case

Code

For this case we will use well known time series forecasting M4 benchmark. Also we'd like to show how to use so called initial assumption for the framework.

First, we need to import necessary modules to instantiate main fedot_ind class and PipelineBuilder to design initial assumption, as well as several supplementary modules to make it easier to create a forecasting model:

import pandas as pd
import matplotlib.pyplot as plt

from fedot_ind.api.main import FedotIndustrial

from fedot.core.pipelines.pipeline_builder import PipelineBuilder
from fedot.core.data.data import InputData
from fedot.core.data.data_split import train_test_data_setup
from fedot.core.repository.dataset_types import DataTypesEnum
from fedot.core.repository.tasks import TsForecastingParams, Task, TaskTypesEnum

Then we are able to load some random time series from M4 benchmark and visualize it:

TS_INDEX = 'H88'

test_data = TimeSeriesDataFrame.from_path("https://autogluon.s3.amazonaws.com/datasets/timeseries/m4_hourly_subset/test.csv")
target = test_data.loc[TS_INDEX]
target.plot()

After that we should create input data object out of initial time series:

horizon = 48
task = Task(TaskTypesEnum.ts_forecasting,
            TsForecastingParams(forecast_length=horizon))

train_input = InputData(idx=target.index.values,
                        features=target.target.values,
                        target=target.target.values,
                        task=task,
                        data_type=DataTypesEnum.ts)
train_data, test_data = train_test_data_setup(train_input, validation_blocks=None)

To configure experiment setup our framework allows to use some initial assumption in the form of pipeline. In this case we apply eigen_basis transformation (CODE) followed by auto-regression node:

initial_assumption = PipelineBuilder().add_node('eigen_basis', params={'low_rank_approximation': False,
                                                                       'rank_regularization': 'explained_dispersion'})\
                                      .add_node('ar')

api_config = dict(problem='ts_forecasting',
                  metric='rmse',
                  timeout=5,
                  task_params={'forecast_length': 48},
                  n_jobs=2,
                  initial_assumption=initial_assumption,
                  logging_level=20)

This way we have prepared everything to start our experiment:

industrial = FedotIndustrial(**api_config)
industrial.fit(train_data)
industrial.solver.current_pipeline.show()

In this particular case Fedot.Industrial haven't composed final pipeline that differs from selected initial assumption, but it spend time to tune it:

To obtain predictions using composed model we simply call for predict() method and visualize it with matplotlib library:

preds = industrial.predict(test_data)

fig, ax = plt.subplots(figsize=(10, 5))

ax.plot(range(700, 748),
        preds,  
        label='predict', 
        color='red')
ax.plot(target.target.values, 
        label='target', 
        color='grey')
plt.legend()

Exogen

Code

With strategy

Code