Cointegration in Python with Pandas

Table of Contents#

1. Core Concepts
2. Typical Usage Method
3. Common Practice
4. Best Practices
5. Code Examples
6. Conclusion
7. FAQ
8. References

Core Concepts#

Stationarity#

A stationary time series is one whose statistical properties such as mean, variance, and autocorrelation are constant over time. Most statistical models assume that the data is stationary. Non - stationary time series can often be made stationary through differencing.

Cointegration#

Two time series (X_t) and (Y_t) are cointegrated if there exists a non - zero vector (\beta = [\beta_1,\beta_2]) such that (Z_t=\beta_1X_t+\beta_2Y_t) is a stationary time series. In the context of pairs trading, if two stocks are cointegrated, their price difference (or a linear combination of their prices) will tend to revert to a long - term mean.

Engle - Granger Test#

The Engle - Granger test is a popular method for testing cointegration between two time series. It involves two steps:

1. Estimate the cointegrating relationship by regressing one time series on the other.
2. Test the residuals of the regression for stationarity using a unit root test, such as the Augmented Dickey - Fuller (ADF) test.

Typical Usage Method#

Data Preparation#

First, you need to import the necessary libraries and load your time series data into Pandas DataFrames. The data should be in a format where each column represents a different time series.

Cointegration Testing#

After preparing the data, you can perform the Engle - Granger test. This typically involves fitting a linear regression model, extracting the residuals, and then testing the residuals for stationarity.

Interpretation of Results#

If the residuals of the regression are stationary (i.e., the null hypothesis of the unit root test is rejected), then the two time series are cointegrated.

Common Practice#

Pairs Selection#

In pairs trading, the first step is to select pairs of assets that are likely to be cointegrated. This can be done by looking at assets in the same industry or with similar fundamental characteristics.

Risk Management#

Once you have identified cointegrated pairs, it is important to manage the risk associated with the trading strategy. This can include setting stop - loss levels and position sizing.

Backtesting#

Before implementing a pairs trading strategy in the real world, it is essential to backtest the strategy using historical data. This helps to evaluate the performance of the strategy and identify potential issues.

Best Practices#

Use High - Quality Data#

The accuracy of cointegration tests depends on the quality of the data. Make sure to use clean, accurate, and up - to - date data.

Consider Multiple Tests#

While the Engle - Granger test is widely used, it is a good practice to use multiple cointegration tests to confirm the results. Other tests include the Johansen test, which can be used to test for cointegration among more than two time series.

Regularly Re - evaluate Pairs#

Cointegrating relationships can change over time, so it is important to regularly re - evaluate the pairs to ensure that they are still cointegrated.

Code Examples#

import pandas as pd
import numpy as np
import statsmodels.api as sm
from statsmodels.tsa.stattools import adfuller
 
# Generate some sample time series data
np.random.seed(0)
n = 100
x = np.cumsum(np.random.randn(n))
y = 2 * x + np.random.randn(n)
 
# Create Pandas DataFrame
data = pd.DataFrame({'X': x, 'Y': y})
 
# Step 1: Perform linear regression
X = sm.add_constant(data['X'])
model = sm.OLS(data['Y'], X).fit()
residuals = model.resid
 
# Step 2: Test the residuals for stationarity using ADF test
def adf_test(series):
    result = adfuller(series)
    print('ADF Statistic: {}'.format(result[0]))
    print('p - value: {}'.format(result[1]))
    print('Critical Values:')
    for key, value in result[4].items():
        print('\t{}: {}'.format(key, value))
    if result[1] <= 0.05:
        print("The series is stationary.")
    else:
        print("The series is non - stationary.")
 
adf_test(residuals)

In this code, we first generate two time series x and y where y is a linear combination of x plus some noise. We then create a Pandas DataFrame to store the data. Next, we perform a linear regression of y on x and extract the residuals. Finally, we test the residuals for stationarity using the Augmented Dickey - Fuller test.

Conclusion#

Cointegration is a powerful concept in time series analysis, especially in the context of pairs trading. Python and Pandas provide a convenient and efficient way to perform cointegration tests. By understanding the core concepts, typical usage methods, common practices, and best practices, intermediate - to - advanced Python developers can effectively apply cointegration analysis in real - world situations.

FAQ#

Q1: What if the ADF test fails to reject the null hypothesis?#

If the ADF test fails to reject the null hypothesis, it means that the residuals are non - stationary, and the two time series are not cointegrated. You may need to look for other pairs of assets or consider alternative trading strategies.

Q2: Can I use cointegration analysis for more than two time series?#

Yes, you can use the Johansen test to test for cointegration among more than two time series. The Johansen test is more complex than the Engle - Granger test but can handle multiple time series.

Q3: How often should I re - evaluate cointegrated pairs?#

The frequency of re - evaluation depends on the nature of the assets and the market conditions. In general, it is a good idea to re - evaluate the pairs on a regular basis, such as monthly or quarterly.

References#

1. Engle, R. F., & Granger, C. W. J. (1987). Co - integration and error correction: representation, estimation, and testing. Econometrica, 55(2), 251 - 276.
2. Hyndman, R. J., & Athanasopoulos, G. (2018). Forecasting: principles and practice. OTexts.
3. Pandas documentation: https://pandas.pydata.org/docs/
4. Statsmodels documentation: https://www.statsmodels.org/stable/index.html