Alphalens-reloaded

https://github.com/stefan-jansen/alphalens-reloaded
Admin
Alphalens-reloaded is a Python library for performance analysis of predictive (alpha) stock factors,...
Tokens:29,527
Snippets:249
Trust Score:9
License:Apache-2.0
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### Run Jupyter notebook server

Source: https://github.com/stefan-jansen/alphalens-reloaded/blob/main/README.md

Starts a Jupyter notebook server, typically at http://localhost:8888/, to run the example notebooks in the examples directory.

```bash
jupyter notebook
```

--------------------------------

### Install alphalens-reloaded with pip

Source: https://github.com/stefan-jansen/alphalens-reloaded/blob/main/README.md

Install alphalens-reloaded with pip.

```bash
pip install alphalens-reloaded
```

--------------------------------

### Setup: imports and matplotlib inline

Source: https://github.com/stefan-jansen/alphalens-reloaded/blob/main/docs/source/notebooks/intraday_factor.ipynb

Initial setup for the notebook: suppress warnings, import alphalens and pandas, and enable inline matplotlib plotting.

```python
import warnings
warnings.filterwarnings('ignore')
```

```python
import alphalens
import pandas as pd
```

```python
%matplotlib inline
```

--------------------------------

### Install alphalens-reloaded from master branch

Source: https://github.com/stefan-jansen/alphalens-reloaded/blob/main/README.md

Install the development version of alphalens-reloaded directly from the master branch of the GitHub repository.

```bash
pip install git+https://github.com/stefan-jansen/alphalens-reloaded
```

--------------------------------

### Install alphalens-reloaded with conda

Source: https://github.com/stefan-jansen/alphalens-reloaded/blob/main/README.md

Install alphalens-reloaded with conda from the ml4t channel.

```bash
conda install -c ml4t alphalens-reloaded
```

--------------------------------

### Compute mean reversion factor

Source: https://github.com/stefan-jansen/alphalens-reloaded/blob/main/src/alphalens/examples/pyfolio_integration.ipynb

Calculates a mean reversion factor based on the 5-day percentage change of the open price, negated so that recent winners get lower factor values.

```python
factor = df.loc[:,'Open'].unstack('asset')
factor = -factor.pct_change(5)
factor = factor.stack()
```

--------------------------------

### Compute overnight price gap factor

Source: https://github.com/stefan-jansen/alphalens-reloaded/blob/main/src/alphalens/examples/intraday_factor.ipynb

Extracts open and close prices, shifts close to get yesterday's close, and computes the factor as the overnight price gap (today open minus yesterday close) divided by yesterday close.

```python
today_open = df.loc[:, 'Open'].unstack('asset')
today_close = df.loc[:, 'Close'].unstack('asset')
yesterday_close = today_close.shift(1)
```

```python
factor = (today_open - yesterday_close) / yesterday_close
```

--------------------------------

### Get clean factor and forward returns

Source: https://github.com/stefan-jansen/alphalens-reloaded/blob/main/src/alphalens/examples/event_study.ipynb

Computes forward returns and cleans the factor data for the event study, using a single bin and no z-score filtering.

```python
factor_data = alphalens.utils.get_clean_factor_and_forward_returns(events,
                                                                   pricing,
                                                                   quantiles=None,
                                                                   bins=1,
                                                                   periods=(
                                                                       1, 2, 3, 4, 5, 6, 10),
                                                                   filter_zscore=None)
```

--------------------------------

### Get clean factor and forward returns

Source: https://github.com/stefan-jansen/alphalens-reloaded/blob/main/src/alphalens/examples/pyfolio_integration.ipynb

Calls alphalens.utils.get_clean_factor_and_forward_returns with periods (1,3,5) and 5 quantiles.

```python
factor_data = alphalens.utils.get_clean_factor_and_forward_returns(factor,
                                                                   pricing,
                                                                   periods=(1, 3, 5),
                                                                   quantiles=5,
                                                                   bins=None)
```

--------------------------------

### Prepare pricing data

Source: https://github.com/stefan-jansen/alphalens-reloaded/blob/main/src/alphalens/examples/pyfolio_integration.ipynb

Uses the open prices shifted by one day to serve as entry prices, avoiding lookahead bias.

```python
pricing = df.loc[:,'Open'].unstack('asset').iloc[1:]
```

--------------------------------

### Import Alphalens, Pyfolio, and Pandas

Source: https://github.com/stefan-jansen/alphalens-reloaded/blob/main/src/alphalens/examples/pyfolio_integration.ipynb

Imports the required libraries for the analysis.

```python
import alphalens
import pyfolio
import pandas as pd
```

--------------------------------

### Create Pyfolio input for full factor data

Source: https://github.com/stefan-jansen/alphalens-reloaded/blob/main/src/alphalens/examples/pyfolio_integration.ipynb

Prepares factor data for Pyfolio using alphalens.performance.create_pyfolio_input with a 1-day period, $100,000 capital, long-short, equal weight, and quantiles [1,5]. The output includes returns, positions, and benchmark returns.

```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')
```

--------------------------------

### Prepare pricing data

Source: https://github.com/stefan-jansen/alphalens-reloaded/blob/main/src/alphalens/examples/event_study.ipynb

Prepares the pricing DataFrame for Alphalens by selecting the 'Open' column, dropping the first row, and unstacking by asset.

```python
pricing = df.loc[:, 'Open'].iloc[1:].unstack('asset')
```

--------------------------------

### Create Pyfolio input for Monday factor data

Source: https://github.com/stefan-jansen/alphalens-reloaded/blob/main/src/alphalens/examples/pyfolio_integration.ipynb

Prepares the Monday-filtered factor data for Pyfolio with a 5-day holding period, $100,000 capital, long-short, equal weight, and quantiles [1,5].

```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')
```

--------------------------------

### Align pricing with factor observations

Source: https://github.com/stefan-jansen/alphalens-reloaded/blob/main/src/alphalens/examples/overview.ipynb

Builds a pricing DataFrame from asset open prices, aligned to the next available price after each daily factor observation. The result is printed with head().

```python
pricing = df.loc[:, 'Open'].iloc[1:].unstack('asset')
pricing.head()
```

--------------------------------

### Calculate Quantile Turnover

Source: https://github.com/stefan-jansen/alphalens-reloaded/blob/main/src/alphalens/examples/overview.ipynb

Sets up the quantile factor and turnover period, then computes the quantile turnover for each quantile and displays the first few rows.

```python
quantile_factor = factor_data['factor_quantile']
turnover_period = 1
```

```python
quantiles = range(1, int(quantile_factor.max()) + 1)
quantile_turnover = pd.concat([alphalens.performance.quantile_turnover(quantile_factor, q, 
                                                                       turnover_period)
                               for q in quantiles], axis=1)
```

```python
quantile_turnover.head()
```

--------------------------------

### Inspect formatted factor data with head()

Source: https://github.com/stefan-jansen/alphalens-reloaded/blob/main/src/alphalens/examples/overview.ipynb

Displays the first few rows of the formatted factor data. The resulting dataframe contains all information needed for calculations, with variables as columns and observations as rows. Integer columns represent forward returns or daily price changes for N days after a timestamp.

```python
factor_data.head()
```

--------------------------------

### Download price data with yfinance

Source: https://github.com/stefan-jansen/alphalens-reloaded/blob/main/src/alphalens/examples/intraday_factor.ipynb

Imports yfinance and pandas_datareader, overrides pandas_datareader to use yfinance, and downloads daily price data for the tickers from 2017-01-01 to 2017-06-01, converting the index to UTC.

```python
import yfinance as yf
import pandas_datareader.data as web
yf.pdr_override()

tickers = list(ticker_sector.keys())
df = web.get_data_yahoo(tickers, start='2017-01-01',  end='2017-06-01')
df.index = pd.to_datetime(df.index, utc=True)
```

--------------------------------

### Display daily mean returns by quantile

Source: https://github.com/stefan-jansen/alphalens-reloaded/blob/main/docs/source/notebooks/overview.ipynb

Shows the first few rows of the daily mean returns by quantile DataFrame using the .head() method.

```python
mean_return_by_q_daily.head()
```

--------------------------------

### Preview mean return by quantile data

Source: https://github.com/stefan-jansen/alphalens-reloaded/blob/main/src/alphalens/examples/overview.ipynb

Displays the first few rows of the grouped mean return by quantile data.

```python
mean_return_quantile_sector.head()
```

--------------------------------

### Compute and preview overall mean returns by quantile

Source: https://github.com/stefan-jansen/alphalens-reloaded/blob/main/src/alphalens/examples/overview.ipynb

Computes overall mean returns by quantile (by_date=False) and displays the first rows.

```python
mean_return_by_q, std_err_by_q = alphalens.performance.mean_return_by_quantile(factor_data,
                                                                               by_date=False)
```

```python
mean_return_by_q.head()
```

--------------------------------

### Compute and preview daily mean returns by quantile

Source: https://github.com/stefan-jansen/alphalens-reloaded/blob/main/src/alphalens/examples/overview.ipynb

Computes daily mean returns by quantile using alphalens.performance.mean_return_by_quantile with by_date=True, then displays the first rows of the result.

```python
mean_return_by_q_daily, std_err = alphalens.performance.mean_return_by_quantile(
    factor_data, by_date=True)
```

```python
mean_return_by_q_daily.head()
```

--------------------------------

### Stack data and inspect

Source: https://github.com/stefan-jansen/alphalens-reloaded/blob/main/src/alphalens/examples/pyfolio_integration.ipynb

Stacks the DataFrame to have a MultiIndex of date and asset, and prints info.

```python
df = df.stack()
df.index.names = ['date', 'asset']
df.info()
```

--------------------------------

### Preview Quantile Turnover DataFrame

Source: https://github.com/stefan-jansen/alphalens-reloaded/blob/main/docs/source/notebooks/overview.ipynb

Displays the first few rows of the quantile turnover DataFrame to inspect the computed values.

```python
quantile_turnover.head()
```

--------------------------------

### Import libraries

Source: https://github.com/stefan-jansen/alphalens-reloaded/blob/main/src/alphalens/examples/overview.ipynb

Imports pandas, alphalens, and seaborn for data manipulation and visualization.

```python
import pandas as pd
import alphalens
import seaborn as sns
```

--------------------------------

### Display overall mean returns by quantile

Source: https://github.com/stefan-jansen/alphalens-reloaded/blob/main/docs/source/notebooks/overview.ipynb

Shows the first few rows of the overall mean returns by quantile DataFrame using the .head() method.

```python
mean_return_by_q.head()
```

--------------------------------

### Create pricing DataFrame with open and close prices

Source: https://github.com/stefan-jansen/alphalens-reloaded/blob/main/src/alphalens/examples/intraday_factor.ipynb

Adjusts the index of today's open and close price DataFrames to reflect market open (9:30) and close (16:00) times, then concatenates them into a single pricing DataFrame sorted by timestamp. This pricing DataFrame is used to compute forward returns based on open-to-close price differences.

```python
# Fix time as Yahoo doesn't set it
today_open.index += pd.Timedelta('9h30m')
today_close.index += pd.Timedelta('16h')
# pricing will contain both open and close
pricing = pd.concat([today_open, today_close]).sort_index()
```

--------------------------------

### Inspect DataFrame info

Source: https://github.com/stefan-jansen/alphalens-reloaded/blob/main/src/alphalens/examples/event_study.ipynb

Displays summary information about the downloaded DataFrame.

```python
df.info()
```

--------------------------------

### Download and reshape price data

Source: https://github.com/stefan-jansen/alphalens-reloaded/blob/main/docs/source/notebooks/intraday_factor.ipynb

Downloads daily price data for the tickers using yfinance and pandas_datareader, then stacks the DataFrame to a multi-index (date, asset) format.

```python
import yfinance as yf
import pandas_datareader.data as web
yf.pdr_override()

tickers = list(ticker_sector.keys())
df = web.get_data_yahoo(tickers, start='2017-01-01',  end='2017-06-01')
df.index = pd.to_datetime(df.index, utc=True)
```

```python
df = df.stack()
df.index.names = ['date', 'asset']
df.info()
```

--------------------------------

### Compute and preview long-short factor returns

Source: https://github.com/stefan-jansen/alphalens-reloaded/blob/main/src/alphalens/examples/overview.ipynb

Computes long-short factor returns and displays the first rows.

```python
ls_factor_returns = alphalens.performance.factor_returns(factor_data)
```

```python
ls_factor_returns.head()
```

--------------------------------

### Set single bin/quantile

Source: https://github.com/stefan-jansen/alphalens-reloaded/blob/main/src/alphalens/examples/event_study.ipynb

Configures a single bin/quantile for event study, with a workaround for pandas versions below 0.20.0 that may throw ValueError with identical values.

```python
# We want to have only one  bin/quantile. So we can either use quantiles=1 or bins=1

quantiles = None
bins = 1

# Beware that in pandas versions below 0.20.0 there were few bugs in panda.qcut and pandas.cut
# that resulted in ValueError exception to be thrown when identical values were present in the
# dataframe and 1 quantile/bin was selected.
# As a workaroung use the bins custom range option that include all your values. E.g.

quantiles = None
bins = [-1000000, 1000000]
```

--------------------------------

### Align factor index to market open and stack

Source: https://github.com/stefan-jansen/alphalens-reloaded/blob/main/src/alphalens/examples/intraday_factor.ipynb

Aligns the factor index to the market open time (9:30) and stacks the factor DataFrame to a long format with a MultiIndex named 'date' and 'asset'. This prepares the factor for alignment with the pricing data.

```python
# Align factor to open price
factor.index += pd.Timedelta('9h30m')
factor = factor.stack()
factor.index = factor.index.set_names(['date', 'asset'])
```

--------------------------------

### Download price data with yfinance

Source: https://github.com/stefan-jansen/alphalens-reloaded/blob/main/src/alphalens/examples/overview.ipynb

Downloads historical price data for the tickers using yfinance and pandas_datareader, and sets the index to UTC.

```python
import yfinance as yf
import pandas_datareader.data as web
yf.pdr_override()

tickers = list(ticker_sector.keys())
df = web.get_data_yahoo(tickers, start='2014-12-01',  end='2017-01-01')
df.index = pd.to_datetime(df.index, utc=True)
```

--------------------------------

### Inspect pricing DataFrame

Source: https://github.com/stefan-jansen/alphalens-reloaded/blob/main/src/alphalens/examples/intraday_factor.ipynb

Displays the first few rows of the pricing DataFrame to inspect the concatenated open and close prices.

```python
pricing.head()
```

--------------------------------

### Build events DataFrame for price drop below $30

Source: https://github.com/stefan-jansen/alphalens-reloaded/blob/main/src/alphalens/examples/event_study.ipynb

Creates an events DataFrame marking days when a security's open price falls below $30 after being at or above $30 the previous day. The resulting stacked DataFrame contains positive values (the price) only on event dates; all other entries are NaN. Positive values are required for long positions.

```python
today_price = df.loc[:, 'Open'].unstack('asset')
yesterday_price = today_price.shift(1)
events = today_price[(today_price < 30.0) & (yesterday_price >= 30)]
events = events.stack()
events = events.astype(float)
events
```

--------------------------------

### Display factor long/short returns

Source: https://github.com/stefan-jansen/alphalens-reloaded/blob/main/docs/source/notebooks/overview.ipynb

Shows the first few rows of the factor long/short returns DataFrame using the .head() method.

```python
ls_factor_returns.head()
```

--------------------------------

### Generate full tear sheet with Pyfolio

Source: https://github.com/stefan-jansen/alphalens-reloaded/blob/main/src/alphalens/examples/pyfolio_integration.ipynb

Runs pyfolio.tears.create_full_tear_sheet on the prepared returns, positions, and benchmark to produce a comprehensive performance analysis.

```python
pyfolio.tears.create_full_tear_sheet(pf_returns,
                                     positions=pf_positions,
                                     benchmark_rets=pf_benchmark)
```

--------------------------------

### Plot Monthly IC Heatmap

Source: https://github.com/stefan-jansen/alphalens-reloaded/blob/main/src/alphalens/examples/overview.ipynb

Plots a heatmap of monthly IC values to assess factor consistency across market regimes.

```python
alphalens.plotting.plot_monthly_ic_heatmap(mean_monthly_ic);
```

--------------------------------

### Create event returns tear sheet

Source: https://github.com/stefan-jansen/alphalens-reloaded/blob/main/src/alphalens/examples/intraday_factor.ipynb

Generates an event returns tear sheet using the factor data and pricing, showing event-based return analysis.

```python
alphalens.tears.create_event_returns_tear_sheet(non_predictive_factor_data, pricing);
```

--------------------------------

### Preview IC by sector data

Source: https://github.com/stefan-jansen/alphalens-reloaded/blob/main/src/alphalens/examples/overview.ipynb

Displays the first few rows of the grouped IC data frame.

```python
ic_by_sector.head()
```

--------------------------------

### Define sector and ticker mappings

Source: https://github.com/stefan-jansen/alphalens-reloaded/blob/main/src/alphalens/examples/intraday_factor.ipynb

Defines dictionaries mapping sector codes to sector names and tickers to sector codes for a small universe of large cap stocks.

```python
sector_names = {
    0 : "information_technology",
    1 : "financials",
    2 : "health_care",
    3 : "industrials",
    4 : "utilities", 
    5 : "real_estate", 
    6 : "materials", 
    7 : "telecommunication_services", 
    8 : "consumer_staples", 
    9 : "consumer_discretionary", 
    10 : "energy" 
}

ticker_sector = {
    "ACN" : 0, "ATVI" : 0, "ADBE" : 0, "AMD" : 0, "AKAM" : 0, "ADS" : 0, "GOOGL" : 0, "GOOG" : 0, 
    "APH" : 0, "ADI" : 0, "ANSS" : 0, "AAPL" : 0, "AMAT" : 0, "ADSK" : 0, "ADP" : 0, "AVGO" : 0,
    "AMG" : 1, "AFL" : 1, "ALL" : 1, "AXP" : 1, "AIG" : 1, "AMP" : 1, "AON" : 1, "AJG" : 1, "AIZ" : 1, "BAC" : 1,
    "BK" : 1, "BBT" : 1, "BRK.B" : 1, "BLK" : 1, "HRB" : 1, "BHF" : 1, "COF" : 1, "CBOE" : 1, "SCHW" : 1, "CB" : 1,
    "ABT" : 2, "ABBV" : 2, "AET" : 2, "A" : 2, "ALXN" : 2, "ALGN" : 2, "AGN" : 2, "ABC" : 2, "AMGN" : 2, "ANTM" : 2,
    "BCR" : 2, "BAX" : 2, "BDX" : 2, "BIIB" : 2, "BSX" : 2, "BMY" : 2, "CAH" : 2, "CELG" : 2, "CNC" : 2, "CERN" : 2,
    "MMM" : 3, "AYI" : 3, "ALK" : 3, "ALLE" : 3, "AAL" : 3, "AME" : 3, "AOS" : 3, "ARNC" : 3, "BA" : 3, "CHRW" : 3,
    "CAT" : 3, "CTAS" : 3, "CSX" : 3, "CMI" : 3, "DE" : 3, "DAL" : 3, "DOV" : 3, "ETN" : 3, "EMR" : 3, "EFX" : 3,
    "AES" : 4, "LNT" : 4, "AEE" : 4, "AEP" : 4, "AWK" : 4, "CNP" : 4, "CMS" : 4, "ED" : 4, "D" : 4, "DTE" : 4,
    "DUK" : 4, "EIX" : 4, "ETR" : 4, "ES" : 4, "EXC" : 4, "FE" : 4, "NEE" : 4, "NI" : 4, "NRG" : 4, "PCG" : 4,
    "ARE" : 5, "AMT" : 5, "AIV" : 5, "AVB" : 5, "BXP" : 5, "CBG" : 5, "CCI" : 5, "DLR" : 5, "DRE" : 5,
    "EQIX" : 5, "EQR" : 5, "ESS" : 5, "EXR" : 5, "FRT" : 5, "GGP" : 5, "HCP" : 5, "HST" : 5, "IRM" : 5, "KIM" : 5,
    "APD" : 6, "ALB" : 6, "AVY" : 6, "BLL" : 6, "CF" : 6, "DWDP" : 6, "EMN" : 6, "ECL" : 6, "FMC" : 6, "FCX" : 6,
    "IP" : 6, "IFF" : 6, "LYB" : 6, "MLM" : 6, "MON" : 6, "MOS" : 6, "NEM" : 6, "NUE" : 6, "PKG" : 6, "PPG" : 6,
    "T" : 7, "CTL" : 7, "VZ" : 7, 
    "MO" : 8, "ADM" : 8, "BF.B" : 8, "CPB" : 8, "CHD" : 8, "CLX" : 8, "KO" : 8, "CL" : 8, "CAG" : 8,
    "STZ" : 8, "COST" : 8, "COTY" : 8, "CVS" : 8, "DPS" : 8, "EL" : 8, "GIS" : 8, "HSY" : 8, "HRL" : 8,
    "AAP" : 9, "AMZN" : 9, "APTV" : 9, "AZO" : 9, "BBY" : 9, "BWA" : 9, "KMX" : 9, "CCL" : 9, 
    "APC" : 10, "ANDV" : 10, "APA" : 10, "BHGE" : 10, "COG" : 10, "CHK" : 10, "CVX" : 10, "XEC" : 10, "CXO" : 10,
    "COP" : 10, "DVN" : 10, "EOG" : 10, "EQT" : 10, "XOM" : 10, "HAL" : 10, "HP" : 10, "HES" : 10, "KMI" : 10
}
```

--------------------------------

### Create factor tear sheet with alphalens

Source: https://github.com/stefan-jansen/alphalens-reloaded/blob/main/README.md

Two-step process to create a factor tear sheet: first ingest and format data with get_clean_factor_and_forward_returns, then run the analysis with create_full_tear_sheet.

```python
import alphalens

# Ingest and format data
factor_data = alphalens.utils.get_clean_factor_and_forward_returns(my_factor,
                                                                   pricing,
                                                                   quantiles=5,
                                                                   groupby=ticker_sector,
                                                                   groupby_labels=sector_names)

# Run analysis
alphalens.tears.create_full_tear_sheet(factor_data)
```

--------------------------------

### Compute daily mean returns by quantile

Source: https://github.com/stefan-jansen/alphalens-reloaded/blob/main/docs/source/notebooks/overview.ipynb

Calculates the mean daily returns for each factor quantile using alphalens.performance.mean_return_by_quantile with by_date=True. The result is stored in mean_return_by_q_daily and std_err.

```python
mean_return_by_q_daily, std_err = alphalens.performance.mean_return_by_quantile(
    factor_data, by_date=True)
```

--------------------------------

### Download stock data with yfinance

Source: https://github.com/stefan-jansen/alphalens-reloaded/blob/main/src/alphalens/examples/pyfolio_integration.ipynb

Uses yfinance and pandas_datareader to download daily stock data for the tickers from 2015-01-01 to 2017-01-01, and converts the index to UTC.

```python
import yfinance as yf
import pandas_datareader.data as web
yf.pdr_override()

df = web.get_data_yahoo(tickers, start='2015-01-01',  end='2017-01-01')
df.index = pd.to_datetime(df.index, utc=True)
```

--------------------------------

### Create returns tear sheet

Source: https://github.com/stefan-jansen/alphalens-reloaded/blob/main/src/alphalens/examples/intraday_factor.ipynb

Generates a returns tear sheet for the factor data, providing performance analysis and visualizations.

```python
alphalens.tears.create_returns_tear_sheet(non_predictive_factor_data)
```

--------------------------------

### Import alphalens and pandas

Source: https://github.com/stefan-jansen/alphalens-reloaded/blob/main/src/alphalens/examples/event_study.ipynb

Imports the Alphalens library and pandas for data manipulation.

```python
import alphalens
import pandas as pd
```

--------------------------------

### Download price data with yfinance

Source: https://github.com/stefan-jansen/alphalens-reloaded/blob/main/src/alphalens/examples/event_study.ipynb

Downloads historical price data for the ticker universe from Yahoo Finance using pandas_datareader with yfinance override, covering June 2015 to January 2017.

```python
import yfinance as yf
import pandas_datareader.data as web
yf.pdr_override()

df = web.get_data_yahoo(tickers, start='2015-06-01',  end='2017-01-01')
df.index = pd.to_datetime(df.index)
```

--------------------------------

### Create predictive factor with look-ahead bias

Source: https://github.com/stefan-jansen/alphalens-reloaded/blob/main/src/alphalens/examples/overview.ipynb

Creates a predictive factor by calculating the percentage change over 5 days and shifting it back to introduce look-ahead bias, making the factor predictive.

```python
lookahead_bias_days = 5

predictive_factor = df.loc[:, 'Open'].unstack('asset')
predictive_factor = predictive_factor.pct_change(lookahead_bias_days)
# introduce look-ahead bias and make the factor predictive
predictive_factor = predictive_factor.shift(-lookahead_bias_days)

predictive_factor = predictive_factor.stack()
```

--------------------------------

### View IC Data

Source: https://github.com/stefan-jansen/alphalens-reloaded/blob/main/src/alphalens/examples/overview.ipynb

Displays the first few rows of the IC data.

```python
ic.head()
```

--------------------------------

### Plot quantile returns violin chart

Source: https://github.com/stefan-jansen/alphalens-reloaded/blob/main/src/alphalens/examples/overview.ipynb

Plots a violin chart of daily mean returns by quantile, showing distribution details, and removes chart spines.

```python
alphalens.plotting.plot_quantile_returns_violin(mean_return_by_q_daily)
sns.despine()
```

--------------------------------

### Create Turnover Tear Sheet

Source: https://github.com/stefan-jansen/alphalens-reloaded/blob/main/src/alphalens/examples/overview.ipynb

Generates a comprehensive tear sheet with all turnover analysis calculations for the given factor data.

```python
alphalens.tears.create_turnover_tear_sheet(factor_data);
```

--------------------------------

### Compute clean factor and forward returns with periods (1,2)

Source: https://github.com/stefan-jansen/alphalens-reloaded/blob/main/src/alphalens/examples/intraday_factor.ipynb

Calls Alphalens' utility to clean the factor data and compute forward returns for periods 1 and 2. Period 1 returns are from market open to close, while period 2 returns are from today's open to tomorrow's open. The groupby parameters assign sector labels to assets.

```python
non_predictive_factor_data = alphalens.utils.get_clean_factor_and_forward_returns(factor, 
                                                                                  pricing, 
                                                                                  periods=(1,2),
                                                                                  groupby=ticker_sector,
                                                                                  groupby_labels=sector_names)
```

--------------------------------

### Create Information Tear Sheet

Source: https://github.com/stefan-jansen/alphalens-reloaded/blob/main/src/alphalens/examples/overview.ipynb

Generates a comprehensive tear sheet with all information analysis calculations for the given factor data.

```python
alphalens.tears.create_information_tear_sheet(factor_data);
```

--------------------------------

### Create full tear sheet with alphalens.tears.create_full_tear_sheet

Source: https://github.com/stefan-jansen/alphalens-reloaded/blob/main/src/alphalens/examples/overview.ipynb

Generates a comprehensive tear sheet with all statistics and plots for the given factor data. Use this to analyze all metrics at once.

```python
alphalens.tears.create_full_tear_sheet(factor_data)
```

--------------------------------

### Define Quantile Factor and Turnover Period

Source: https://github.com/stefan-jansen/alphalens-reloaded/blob/main/docs/source/notebooks/overview.ipynb

Extracts the factor quantile column and sets the turnover period to 1 for subsequent turnover calculations.

```python
quantile_factor = factor_data['factor_quantile']
turnover_period = 1
```

--------------------------------

### Plot cumulative returns by quantile

Source: https://github.com/stefan-jansen/alphalens-reloaded/blob/main/docs/source/notebooks/overview.ipynb

Plots the cumulative returns for each factor quantile over time using alphalens.plotting.plot_cumulative_returns_by_quantile with a period of '1D'.

```python
alphalens.plotting.plot_cumulative_returns_by_quantile(
    mean_return_by_q_daily, period='1D');
```

--------------------------------

### Create summary tear sheet

Source: https://github.com/stefan-jansen/alphalens-reloaded/blob/main/src/alphalens/examples/pyfolio_integration.ipynb

Generates a summary tear sheet from the factor data.

```python
alphalens.tears.create_summary_tear_sheet(factor_data);
```

--------------------------------

### Plot Top and Bottom Quantile Turnover

Source: https://github.com/stefan-jansen/alphalens-reloaded/blob/main/src/alphalens/examples/overview.ipynb

Plots the turnover of the top and bottom quantiles over time, showing how much of the factor is being remade each period.

```python
alphalens.plotting.plot_top_bottom_quantile_turnover(quantile_turnover, 
                                                     turnover_period);
```

--------------------------------

### Format factor and pricing data with get_clean_factor_and_forward_returns

Source: https://github.com/stefan-jansen/alphalens-reloaded/blob/main/src/alphalens/examples/overview.ipynb

Formats factor and pricing data into the exact inputs expected by the tear sheet functions. The function reports how much data was dropped; factor data can be dropped due to NaNs, insufficient price data for forward returns, or inability to perform binning. Use the 'max_loss' argument to control the maximum allowed data loss.

```python
factor_data = alphalens.utils.get_clean_factor_and_forward_returns(predictive_factor,
                                                                   pricing,
                                                                   quantiles=5,
                                                                   bins=None,
                                                                   groupby=ticker_sector,
                                                                   groupby_labels=sector_names)
```

--------------------------------

### Compute and display factor alpha and beta

Source: https://github.com/stefan-jansen/alphalens-reloaded/blob/main/src/alphalens/examples/overview.ipynb

Computes annualized alpha and beta for the factor and displays the result.

```python
alpha_beta = alphalens.performance.factor_alpha_beta(factor_data)
```

```python
alpha_beta
```

--------------------------------

### Inspect pricing data

Source: https://github.com/stefan-jansen/alphalens-reloaded/blob/main/src/alphalens/examples/event_study.ipynb

Displays summary information about the pricing DataFrame, including index and column types and memory usage.

```python
pricing.info()
```

--------------------------------

### Preview Factor Autocorrelation DataFrame

Source: https://github.com/stefan-jansen/alphalens-reloaded/blob/main/docs/source/notebooks/overview.ipynb

Displays the first few rows of the factor autocorrelation DataFrame to inspect the computed autocorrelation values.

```python
factor_autocorrelation.head()
```

--------------------------------

### Create event study tear sheet

Source: https://github.com/stefan-jansen/alphalens-reloaded/blob/main/src/alphalens/examples/event_study.ipynb

Generates the event study tear sheet with average return plots for periods 5 and 10.

```python
alphalens.tears.create_event_study_tear_sheet(factor_data, 
                                              pricing, 
                                              avgretplot=(5, 10));
```

--------------------------------

### View Mean Monthly IC

Source: https://github.com/stefan-jansen/alphalens-reloaded/blob/main/src/alphalens/examples/overview.ipynb

Displays the first few rows of the mean monthly IC data.

```python
mean_monthly_ic.head()
```

--------------------------------

### Compute mean return by quantile and group

Source: https://github.com/stefan-jansen/alphalens-reloaded/blob/main/src/alphalens/examples/overview.ipynb

Computes mean returns by quantile, grouped by sector. Returns two objects: the mean returns and the associated error.

```python
mean_return_quantile_sector, mean_return_quantile_sector_err = alphalens.performance.mean_return_by_quantile(factor_data, 
                                                                                                             by_group=True)
```

--------------------------------

### Compute overall mean returns by quantile

Source: https://github.com/stefan-jansen/alphalens-reloaded/blob/main/docs/source/notebooks/overview.ipynb

Calculates the mean returns for each factor quantile across the entire period using alphalens.performance.mean_return_by_quantile with by_date=False. The result is stored in mean_return_by_q and std_err_by_q.

```python
mean_return_by_q, std_err_by_q = alphalens.performance.mean_return_by_quantile(
    factor_data, by_date=False)
```

--------------------------------

### Display factor head

Source: https://github.com/stefan-jansen/alphalens-reloaded/blob/main/src/alphalens/examples/overview.ipynb

Displays the first few rows of the predictive factor.

```python
predictive_factor.head()
```

--------------------------------

### Plot quantile returns bar by group

Source: https://github.com/stefan-jansen/alphalens-reloaded/blob/main/src/alphalens/examples/overview.ipynb

Plots a bar chart of mean returns by quantile, grouped by sector.

```python
alphalens.plotting.plot_quantile_returns_bar(mean_return_quantile_sector, 
                                             by_group=True);
```

--------------------------------

### Compute factor alpha and beta

Source: https://github.com/stefan-jansen/alphalens-reloaded/blob/main/docs/source/notebooks/overview.ipynb

Calculates the annualized alpha and beta of the factor using alphalens.performance.factor_alpha_beta and stores the result in alpha_beta.

```python
alpha_beta = alphalens.performance.factor_alpha_beta(factor_data)
```

--------------------------------

### Suppress warnings

Source: https://github.com/stefan-jansen/alphalens-reloaded/blob/main/src/alphalens/examples/pyfolio_integration.ipynb

Ignores warnings to keep the notebook output clean.

```python
import warnings
warnings.filterwarnings('ignore')
```

--------------------------------

### Compute and plot mean quantile returns spread time series

Source: https://github.com/stefan-jansen/alphalens-reloaded/blob/main/src/alphalens/examples/overview.ipynb

Computes the spread between top and bottom quantile returns and plots the time series with standard error bands.

```python
quant_return_spread, std_err_spread = alphalens.performance.compute_mean_returns_spread(mean_return_by_q_daily,
                                                                                        upper_quant=5,
                                                                                        lower_quant=1,
                                                                                        std_err=std_err)
```

```python
alphalens.plotting.plot_mean_quantile_returns_spread_time_series(
    quant_return_spread, std_err_spread);
```

--------------------------------

### Compute factor long/short returns

Source: https://github.com/stefan-jansen/alphalens-reloaded/blob/main/docs/source/notebooks/overview.ipynb

Calculates the factor long/short returns using alphalens.performance.factor_returns and stores the result in ls_factor_returns.

```python
ls_factor_returns = alphalens.performance.factor_returns(factor_data)
```

--------------------------------

### Compute Mean Monthly IC

Source: https://github.com/stefan-jansen/alphalens-reloaded/blob/main/src/alphalens/examples/overview.ipynb

Calculates the mean information coefficient aggregated by month.

```python
mean_monthly_ic = alphalens.performance.mean_information_coefficient(factor_data, 
                                                                     by_time='M')
```

--------------------------------

### Plot cumulative returns by quantile

Source: https://github.com/stefan-jansen/alphalens-reloaded/blob/main/src/alphalens/examples/overview.ipynb

Plots cumulative returns by quantile for the 1D period and removes chart spines.

```python
alphalens.plotting.plot_cumulative_returns_by_quantile(mean_return_by_q_daily['1D'], period='1D')
sns.despine();
```

--------------------------------

### Plot Quantile Returns Bar

Source: https://github.com/stefan-jansen/alphalens-reloaded/blob/main/docs/source/notebooks/overview.ipynb

Plots a bar chart of the mean returns by quantile, optionally grouped by sector or other grouping information.

```python
alphalens.plotting.plot_quantile_returns_bar(
    mean_return_quantile_sector, by_group=True)
```

--------------------------------

### Define stock tickers

Source: https://github.com/stefan-jansen/alphalens-reloaded/blob/main/src/alphalens/examples/pyfolio_integration.ipynb

Defines a list of stock tickers used for the analysis.

```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']
```

--------------------------------

### Display factor alpha and beta

Source: https://github.com/stefan-jansen/alphalens-reloaded/blob/main/docs/source/notebooks/overview.ipynb

Displays the computed alpha and beta values by evaluating the alpha_beta variable.

```python
alpha_beta
```

--------------------------------

### Plot IC Histogram

Source: https://github.com/stefan-jansen/alphalens-reloaded/blob/main/src/alphalens/examples/overview.ipynb

Plots a histogram of daily IC values to see the distribution and potential fat tails.

```python
alphalens.plotting.plot_ic_hist(ic);
```

--------------------------------

### Compute mean returns spread

Source: https://github.com/stefan-jansen/alphalens-reloaded/blob/main/docs/source/notebooks/overview.ipynb

Calculates the spread between the top and bottom quantiles using alphalens.performance.compute_mean_returns_spread, specifying upper_quant=5, lower_quant=1, and the standard error from the daily returns.

```python
quant_return_spread, std_err_spread = alphalens.performance.compute_mean_returns_spread(mean_return_by_q_daily,
                                                                                        upper_quant=5,
                                                                                        lower_quant=1,
                                                                                        std_err=std_err)
```

--------------------------------

### Define sector name mapping for alphalens

Source: https://github.com/stefan-jansen/alphalens-reloaded/blob/main/src/alphalens/examples/overview.ipynb

Defines a mapping from sector codes to descriptive names, suitable for passing to alphalens when sector mappings are provided as codes.

```python
sector_names = {
    0: "information_technology",
    1: "financials",
    2: "health_care",
    3: "industrials",
    4: "utilities",
    5: "real_estate",
    6: "materials",
    7: "telecommunication_services",
    8: "consumer_staples",
    9: "consumer_discretionary",
    10: "energy"
}
```

--------------------------------

### Define ticker universe

Source: https://github.com/stefan-jansen/alphalens-reloaded/blob/main/src/alphalens/examples/event_study.ipynb

Defines a universe of 500 large-cap stock tickers used for the event study.

```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']
```

--------------------------------

### Plot IC Time Series

Source: https://github.com/stefan-jansen/alphalens-reloaded/blob/main/src/alphalens/examples/overview.ipynb

Plots the daily IC values over time to visualize the predictive power of the factor.

```python
alphalens.plotting.plot_ic_ts(ic);
```

--------------------------------

### Compute Quantile Turnover

Source: https://github.com/stefan-jansen/alphalens-reloaded/blob/main/docs/source/notebooks/overview.ipynb

Calculates quantile turnover for each quantile level and concatenates the results into a single DataFrame.

```python
quantile_turnover = pd.concat([alphalens.performance.quantile_turnover(quantile_factor, q, turnover_period)
                               for q in range(1, int(quantile_factor.max()) + 1)], axis=1)
```

--------------------------------

### Plot mean quantile returns spread time series

Source: https://github.com/stefan-jansen/alphalens-reloaded/blob/main/docs/source/notebooks/overview.ipynb

Plots the time series of the mean quantile returns spread using alphalens.plotting.plot_mean_quantile_returns_spread_time_series, passing the spread and its standard error.

```python
alphalens.plotting.plot_mean_quantile_returns_spread_time_series(
    quant_return_spread, std_err_spread);
```

--------------------------------

### Filter ticker_sector to available tickers

Source: https://github.com/stefan-jansen/alphalens-reloaded/blob/main/src/alphalens/examples/intraday_factor.ipynb

Filters the ticker_sector dictionary to only include tickers that are present in the downloaded data.

```python
available_tickers = df.index.unique('asset')
ticker_sector = {k: v for k, v in ticker_sector.items() if k in available_tickers}
```

--------------------------------

### Enable inline plotting

Source: https://github.com/stefan-jansen/alphalens-reloaded/blob/main/src/alphalens/examples/pyfolio_integration.ipynb

Sets matplotlib to display plots inline in the notebook.

```python
%matplotlib inline
```

--------------------------------

### Plot quantile returns bar chart

Source: https://github.com/stefan-jansen/alphalens-reloaded/blob/main/src/alphalens/examples/overview.ipynb

Plots a bar chart of mean returns by quantile and removes chart spines with sns.despine().

```python
alphalens.plotting.plot_quantile_returns_bar(mean_return_by_q)
sns.despine()
```
Tokens:
Raw