Guide to Giotto-Time: A Time-Series Forecasting Python Library

Giotto-Time is an open-source Python library to perform time-series forecasting in machine learning with simple codes and built-in pipelines.
Giotto-Time cover image

Giotto-Time is an open-source Python library to perform time-series forecasting in machine learning. It is built on top of SciKit-Learn with a few modifications and wrappings to do end-to-end time-series analysis in a single go. Giotto-Time gives importance to every task associated with the time-series analysis. With Giotto-Time library, Giotto spans its list of powerful open source tools to perform various machine learning tasks.

Time-series forecasting is a centuries-old method of predicting the future with past data in hand. It finds applications in a variety of domains, including e-commerce, finance, space science, weather forecasting and medical sciences. Unlike time-insensitive structured data, time-series data do need more care in every stage of problem solving. Preprocessing time-series data is one of the difficult tasks that needs field expertise to perform. 

Giotto-Time is introduced to make the time-series modeling tasks simple. This library presents data preprocessing, data cleaning, data extraction, data analysis, forecast modeling and causality testing with very few lines of code. Data analysis in Giotto-Time is associated with data visualization, for which the library introduces special plots. The data visualization module is built on top of the MatPlotLib library. 


Sign up for your weekly dose of what's up in emerging technology.

We explore the Giotto-Time library in the sequel with some examples and hands-on codes. Giotto-Time is available as a PyPi package. We can simply pip install it.

!pip install giotto-time

Time-Series Forecasting with Giotto-Time

Import the necessary libraries and modules. 

 import pandas as pd
 import numpy as np
 import matplotlib.pyplot as plt
 from sklearn.linear_model import LinearRegression
 from gtime.preprocessing import TimeSeriesPreparation
 from gtime.compose import FeatureCreation
 from gtime.feature_extraction import Shift, MovingAverage
 from gtime.feature_generation import PeriodicSeasonal, Constant, Calendar
 from gtime.model_selection import horizon_shift, FeatureSplitter
 from gtime.forecasting import GAR 

Define a function to generate some synthetic time-series data using Pandas’ testing module.

 def test_time_series():
     from pandas.util import testing as testing
     testing.N, testing.K = 500, 1
     df = testing.makeTimeDataFrame( freq="D" )
     return df 

Generate synthetic time-series data.

 time_series = test_time_series()
 print(f'Time series shape: {time_series.shape}')
 print(f'Time series index type: {time_series.index.__class__}') 


The time-series data should be in PeriodIndex format to proceed further. The Giotto-Time library offers a time-series preprocessing module using which we can transform the data from DatetimeIndex to PeriodIndex.

 time_series_preparation = TimeSeriesPreparation()
 period_index_time_series = time_series_preparation.transform(time_series)
 print(f'Time series index type after the preprocessing: \n{period_index_time_series.index.__class__}') 


Let’s visualize the time-series data.

 period_index_time_series.plot(figsize=(10, 5)) 
giotto time series data

Extract features and generate new features using the FeatureCreation API of Giotto-Time. Here, moving average of time period is determined and appended as a feature. In addition, a temporal shift is performed to generate two new features.

 # Feature generation pipeline
 dft = FeatureCreation(
     [('s0', Shift(0), ['time_series']), 
      ('s1', Shift(1), ['time_series']),
      ('ma3', MovingAverage(window_size=3), ['time_series']),

Fit the time-series data into the feature generation pipeline.

 X = dft.fit_transform(period_index_time_series)


giotto feature generation

Generate the ground truth (output variable) using horizon_shift method. 

 y = horizon_shift(period_index_time_series, horizon=3)


ground truth data

Next, split the data into train and test sets using the FeatureSplitter method. Sample some data from each split part.

 feature_splitter = FeatureSplitter()
 X_train, y_train, X_test, y_test = feature_splitter.transform(X, y)








Develop a simple linear regression model from the SciKit-Learn library. Build a Generalized Auto-Regressive (GAR) model on top of the linear regression model to perform a simple time-series forecasting, and train the model with the training dataset.

 lr = LinearRegression()
 model = GAR(lr)
 model =, y_train) 

Once the model is trained, infer the future by predicting it.

 predictions = model.predict(X_test)


Find the Colab Notebook here with above code implementation.

Time-Series Plotting with Giotto-Time

Import the necessary libraries and modules. 

 import pandas as pd
 import numpy as np
 import matplotlib.pyplot as plt
 %matplotlib inline  
 from gtime.preprocessing import TimeSeriesPreparation
 from gtime.plotting import seasonal_plot, seasonal_subplots, lag_plot, acf_plot 

Load the Kansas Wheat Index data from the Giotta-Time’s official google cloud storage.

 df_sp = pd.read_csv('', sep='\t')
 df_column = df_sp.set_index('Effective date ')['S&P GSCI Kansas Wheat'] 

Transform the data into PeriodIndex format and fill the missing values.

 df_column.index = pd.to_datetime(df_column.index)
 time_series_preparation = TimeSeriesPreparation(output_name='Wheat price index')
 period_index_time_series = time_series_preparation.transform(df_column)
 df = period_index_time_series.resample('D').fillna(method='ffill') 

Calculate logarithmic value of sales returns and generate a returns data.

 returns = (np.log(df / df.shift(1))).dropna()
 returns.columns = ['Wheat price returns'] 

Plot the Wheat price and returns to visualize the data.

 ax = df.plot(figsize=(10, 5))
 ax = returns.plot(ax=ax, secondary_y=True) 


Seasonal plots are powerful tools in Giotto-Time library that give an overall picture of how the time-series data vary over seasons such as yearly, monthly, weekly, etc. The following codes generate seasonal plots for price index data.

 fig = plt.figure(figsize=(6,6))
 m1 = fig.add_subplot(111, title='Seasonal plot (year/monthly)')
 seasonal_plot(df, 'year', freq='M', agg='last', ax=m1)


Giotto seasonal plot

Plot monthly returns with seasonal plot in polar form.

 fig = plt.figure(figsize=(6, 6))
 m2 = fig.add_subplot(111, projection='polar')
 seasonal_plot(returns, 'year', freq='M', agg='last', ax=m2, polar=True)
 m2.set_title('Monthly returns')


Giotto seasonal plot polar

Seasonal plots can also be realized through Whisker’s box plot. This plot gives the basic statistical summary such as mean, mode, quartiles, minimum and maximum entries.

 seasonal_subplots(returns, 'year', 'M', agg='last', box=True) 


Giotto box plot

Lag plots have a prominent place in time-series analysis. It compares the data with its own temporal lags. Giotto-Time’s lag plots are simple to execute. Let’s visualize the price index data in a lag plot with three different lags, one day, one month and one year.

 lag_plot(df, lags=[1, 30, 365]) 


time-series autocorrelation
time-series autocorrelation
time-series autocorrelation

Let’s visualize the lag plot for the returns data. 

 lag_plot(returns, lags=[1, 30, 365])


Autocorrelation of price index seems good even up to a lag of one month. But, in the case of returns, the plot is random irrespective of the lag.

Find the Colab Notebook here with the above code implementation.

Wrapping up

We discussed the open-source time-series forecasting Python library, Giotto-Time. We went through hands-on practice with Python codes on two tasks.

  1. Time-series forecasting
  2. Time-series data plotting

Giotto-Time’s full potential can be explored with real-world time-series problems consisting of data cleaning, data analysis, feature generation, forecasting and causality testing.

Further reading:

More Great AIM Stories

Rajkumar Lakshmanamoorthy
A geek in Machine Learning with a Master's degree in Engineering and a passion for writing and exploring new things. Loves reading novels, cooking, practicing martial arts, and occasionally writing novels and poems.

Our Upcoming Events

Conference, in-person (Bangalore)
Machine Learning Developers Summit (MLDS) 2023
19-20th Jan, 2023

Conference, in-person (Bangalore)
Rising 2023 | Women in Tech Conference
16-17th Mar, 2023

Conference, in-person (Bangalore)
Data Engineering Summit (DES) 2023
27-28th Apr, 2023

Conference, in-person (Bangalore)
MachineCon 2023
23rd Jun, 2023

Conference, in-person (Bangalore)
Cypher 2023
20-22nd Sep, 2023

3 Ways to Join our Community

Whatsapp group

Discover special offers, top stories, upcoming events, and more.

Discord Server

Stay Connected with a larger ecosystem of data science and ML Professionals

Subscribe to our newsletter

Get the latest updates from AIM