Testing Mean-Reversion Stock Factors with Alphalens and Pyfolio
Notebook Alphalens
Summary
This tutorial shows how to evaluate a stock factor with Alphalens and then examine a portfolio built from its strongest and weakest ranked groups with Pyfolio. Its example defines a mean-reversion signal from the negative five-day change in opening prices, using a universe of US stocks. Alphalens calculates forward returns over several holding periods and produces a factor summary; the selected extreme quantiles are then used to create a long-short portfolio for performance analysis.
A key implementation lesson is to align factor observations with the next available entry price and subsequent exit prices, so prices used for trading do not leak into the factor calculation. The example uses opening prices and converts timestamps to UTC for Pyfolio. It also filters observations to Mondays and evaluates those signals with a five-day holding period. The document describes an analysis workflow rather than establishing that the factor is profitable: it gives no numerical performance results or robustness checks, and the historical sample and stock universe are specific to the example.
Key ideas
- The example defines a mean-reversion factor as the negative five-day percentage change in opening prices.
- Factor timestamps must be aligned with entry and exit prices to avoid lookahead bias.
- Alphalens can summarize forward returns across factor quantiles and prepare portfolio inputs for Pyfolio.
- The example forms a long-short portfolio from the highest and lowest factor quantiles.
- Filtering factor observations by weekday enables analysis of a calendar-based subset.
Tags
Full text
# Alphalens and Pyfolio integration
# Alphalens and Pyfolio integration
Alphalens can simulate the performance of a portfolio where the factor values are use to weight stocks. Once the portfolio is built, it can be analyzed by Pyfolio. For details on how this portfolio is built see:
- alphalens.performance.factor_returns
- alphalens.performance.cumulative_returns
- alphalens.performance.create_pyfolio_input
```python
%pylab inline --no-import-all
import alphalens
import pyfolio
import pandas as pd
import numpy as np
import datetime
```
First load some stocks data
```python
tickers = [ 'ACN', 'ATVI', 'ADBE', 'AMD', 'AKAM', 'ADS', 'GOOGL', 'GOOG', 'APH', 'ADI', 'ANSS', 'AAPL',
'AVGO', 'CA', 'CDNS', 'CSCO', 'CTXS', 'CTSH', 'GLW', 'CSRA', 'DXC', 'EBAY', 'EA', 'FFIV', 'FB',
'FLIR', 'IT', 'GPN', 'HRS', 'HPE', 'HPQ', 'INTC', 'IBM', 'INTU', 'JNPR', 'KLAC', 'LRCX', 'MA', 'MCHP',
'MSFT', 'MSI', 'NTAP', 'NFLX', 'NVDA', 'ORCL', 'PAYX', 'PYPL', 'QRVO', 'QCOM', 'RHT', 'CRM', 'STX',
'AMG', 'AFL', 'ALL', 'AXP', 'AIG', 'AMP', 'AON', 'AJG', 'AIZ', 'BAC', 'BK', 'BBT', 'BRK.B', 'BLK', 'HRB',
'BHF', 'COF', 'CBOE', 'SCHW', 'CB', 'CINF', 'C', 'CFG', 'CME', 'CMA', 'DFS', 'ETFC', 'RE', 'FITB', 'BEN',
'GS', 'HIG', 'HBAN', 'ICE', 'IVZ', 'JPM', 'KEY', 'LUK', 'LNC', 'L', 'MTB', 'MMC', 'MET', 'MCO', 'MS',
'NDAQ', 'NAVI', 'NTRS', 'PBCT', 'PNC', 'PFG', 'PGR', 'PRU', 'RJF', 'RF', 'SPGI', 'STT', 'STI', 'SYF', 'TROW',
'ABT', 'ABBV', 'AET', 'A', 'ALXN', 'ALGN', 'AGN', 'ABC', 'AMGN', 'ANTM', 'BCR', 'BAX', 'BDX', 'BIIB', 'BSX',
'BMY', 'CAH', 'CELG', 'CNC', 'CERN', 'CI', 'COO', 'DHR', 'DVA', 'XRAY', 'EW', 'EVHC', 'ESRX', 'GILD', 'HCA',
'HSIC', 'HOLX', 'HUM', 'IDXX', 'ILMN', 'INCY', 'ISRG', 'IQV', 'JNJ', 'LH', 'LLY', 'MCK', 'MDT', 'MRK', 'MTD',
'MYL', 'PDCO', 'PKI', 'PRGO', 'PFE', 'DGX', 'REGN', 'RMD', 'SYK', 'TMO', 'UNH', 'UHS', 'VAR', 'VRTX', 'WAT',
'MMM', 'AYI', 'ALK', 'ALLE', 'AAL', 'AME', 'AOS', 'ARNC', 'BA', 'CHRW', 'CAT', 'CTAS', 'CSX', 'CMI', 'DE',
'DAL', 'DOV', 'ETN', 'EMR', 'EFX', 'EXPD', 'FAST', 'FDX', 'FLS', 'FLR', 'FTV', 'FBHS', 'GD', 'GE', 'GWW',
'HON', 'INFO', 'ITW', 'IR', 'JEC', 'JBHT', 'JCI', 'KSU', 'LLL', 'LMT', 'MAS', 'NLSN', 'NSC', 'NOC', 'PCAR',
'PH', 'PNR', 'PWR', 'RTN', 'RSG', 'RHI', 'ROK', 'COL', 'ROP', 'LUV', 'SRCL', 'TXT', 'TDG', 'UNP', 'UAL',
'AES', 'LNT', 'AEE', 'AEP', 'AWK', 'CNP', 'CMS', 'ED', 'D', 'DTE', 'DUK', 'EIX', 'ETR', 'ES', 'EXC']
```
```python
import pandas_datareader.data as web
pan = web.DataReader(tickers, "google", datetime.datetime(2015, 1, 1), datetime.datetime(2017, 1, 1))
```
```python
pan = pan.transpose(2,1,0)
```
We'll compute a simple mean reversion factor looking at recent stocks performance: stocks that performed well in the last 5 days will have high rank and vice versa.
```python
factor = pan.loc[:,:,'Open']
factor = -factor.pct_change(5)
factor = factor.stack()
factor.index = factor.index.set_names(['date', 'asset'])
```
The pricing data passed to alphalens should contain the entry price for the assets so it must reflect the next available price after a factor value was observed at a given timestamp. Those prices must not be used in the calculation of the factor values for that time. Always double check to ensure you are not introducing lookahead bias to your study.
The pricing data must also contain the exit price for the assets, for period 1 the price at the next timestamp will be used, for period 2 the price after 2 timestats will be used and so on.
There are no restrinctions/assumptions on the time frequencies a factor should be computed at and neither on the specific time a factor should be traded (trading at the open vs trading at the close vs intraday trading), it is only required that factor and price DataFrames are properly aligned given the rules above.
In our example, before the trading starts every day, we observe yesterday factor values. The price we pass to alphalens is the next available price after that factor observation: the daily open price that will be used as assets entry price. Also, we are not adding additional prices so the assets exit price will be the following days open prices (how many days depends on 'periods' argument). The retuns computed by Alphalens will therefore based on assets open prices.
```python
pricing = pan.loc[:,:,'Open'].iloc[1:]
```
# Prepare data and run Alphalens
Pyfolio wants timezone set to UTC otherwise it refuses to work
```python
pricing.index = pricing.index.tz_localize('UTC')
```
```python
factor = factor.unstack()
factor.index = factor.index.tz_localize('UTC')
factor = factor.stack()
```
```python
factor_data = alphalens.utils.get_clean_factor_and_forward_returns(factor,
pricing,
periods=(1, 3, 5),
quantiles=5,
bins=None)
```
```python
alphalens.tears.create_summary_tear_sheet(factor_data)
```
# Prepare data for Pyfolio
We can see in Alphalens analysis that quantiles 1 and 5 are the most predictive so we'll build a portfolio data using only those quantiles.
```python
pf_returns, pf_positions, pf_benchmark = \
alphalens.performance.create_pyfolio_input(factor_data,
period='1D',
capital=100000,
long_short=True,
group_neutral=False,
equal_weight=True,
quantiles=[1,5],
groups=None,
benchmark_period='1D')
```
Now that we have prepared the data we can run Pyfolio functions
```python
pyfolio.tears.create_full_tear_sheet(pf_returns,
positions=pf_positions,
benchmark_rets=pf_benchmark)
```
## Analyzing subsets of data
Sometimes it might be useful to analyze subets of your factor data, for example it could be interesting to see the comparison of your factor in different days of the week. Below we'll see how to select and analyze factor data corresponding to Mondays, the positions will be held the for a period of 5 days
```python
monday_factor_data = factor_data[ factor_data.index.get_level_values('date').weekday == 0 ]
```
```python
pf_returns, pf_positions, pf_benchmark = \
alphalens.performance.create_pyfolio_input(monday_factor_data,
period='5D',
capital=100000,
long_short=True,
group_neutral=False,
equal_weight=True,
quantiles=[1,5],
groups=None,
benchmark_period='1D')
```
```python
pyfolio.tears.create_full_tear_sheet(pf_returns,
positions=pf_positions,
benchmark_rets=pf_benchmark)
```
Shown in full with attribution under the source's licence. Licence: Apache-2.0
This summary was written by Stratmill's research agent from the original; it is not a copy of the source.