# Artificial Intelligence for Trading Nanodegree

## Alpha Research and Factor Modelling

## Project: Multi-Factor Model

## Table of Contents

- Project Overview
- Data
- Statistical Risk Model
- Alpha Factors
- The Combined Alpha Factor
- Evaluate Alpha Factors
- Optimal Portfolio Constrained by Risk Model
- Libraries
- References

### Project Overview

In this project, I will build a statistical risk model using PCA. I’ll use this model to build a portfolio along with **5 alpha factors**. I’ll **create** these factors, then **evaluate** them using **factor-weighted returns, quantile analysis, sharpe ratio,** and **turnover analysis.** At the end of the project, I’ll optimize the portfolio using the risk model and factors using multiple optimization formulations.

### Data

For the dataset, we'll be using the end of day from Quotemedia and sector data from Sharadar.

Udacity doesn't have a license to redistribute the data to us. They are working on alternatives to this problem.

### Statistical Risk Model

Portfolio risk is calculated using this formula:

where:

*X*is the portfolio weights (weights assigned to each stock)*B*is the factor betas (exposure of factors)*F*is the factor covariance matrix (combined with factor betas gives systematic risk)*S*is the idiosyncratic variance matrix (specific risk)

### Alpha Factors

After calculating the profile risk, the following five alpha factors were created:

- Momentum 1 Year Factor
^{[2]}

Each factor has a hypothesis that goes with it. For this factor, it is "Higher past 12-month (252 days) returns are proportional to future return". Using that hypothesis, we've generate this code:

```
from zipline.pipeline.factors import Returns
def momentum_1yr(window_length, universe, sector):
return Returns(window_length=window_length, mask=universe) \
.demean(groupby=sector) \
.rank() \
.zscore()
```

- Mean Reversion 5 Day Sector Neutral Factor
^{[1]}

I have implemented `mean_reversion_5day_sector_neutral`

using the hypothesis "Short-term outperformers (underperformers) compared to their sector will revert." Using the returns data from universe, demean using the sector data to partition, rank, then converted to a zscore.

```
def mean_reversion_5day_sector_neutral(window_length, universe, sector):
"""
Generate the mean reversion 5 day sector neutral factor
Parameters
----------
window_length : int
Returns window length
universe : Zipline Filter
Universe of stocks filter
sector : Zipline Classifier
Sector classifier
Returns
-------
factor : Zipline Factor
Mean reversion 5 day sector neutral factor
"""
return -Returns(window_length=window_length, mask = universe)\
.demean(groupby=sector)\
.rank()\
.zscore()
```

- Mean Reversion 5 Day Sector Neutral Smoothed Factor

Taking the output of the previous factor, we create a smoothed version. `mean_reversion_5day_sector_neutral_smoothed`

generates a mean reversion 5 day sector neutral smoothed factor. Calling the mean_reversion_5day_sector_neutral function to get the unsmoothed factor, then using `SimpleMovingAverage`

function to smooth it. We'll have to apply rank and zscore again.

```
from zipline.pipeline.factors import SimpleMovingAverage
def mean_reversion_5day_sector_neutral_smoothed(window_length, universe, sector):
"""
Generate the mean reversion 5 day sector neutral smoothed factor
Parameters
----------
window_length : int
Returns window length
universe : Zipline Filter
Universe of stocks filter
sector : Zipline Classifier
Sector classifier
Returns
-------
factor : Zipline Factor
Mean reversion 5 day sector neutral smoothed factor
"""
mean_reversion = mean_reversion_5day_sector_neutral(window_length, universe, sector)
return SimpleMovingAverage(inputs=[mean_reversion], window_length = window_length).rank().zscore()
```

- Overnight Sentiment Factor
^{[1]}

For this factor, were using the hypothesis from the paper Overnight Returns and Firm-Specific Investor Sentiment.

```
from zipline.pipeline.data import USEquityPricing
class CTO(Returns):
"""
Computes the overnight return, per hypothesis from
https://papers.ssrn.com/sol3/papers.cfm?abstract_id=2554010
"""
inputs = [USEquityPricing.open, USEquityPricing.close]
def compute(self, today, assets, out, opens, closes):
"""
The opens and closes matrix is 2 rows x N assets, with the most recent at the bottom.
As such, opens[-1] is the most recent open, and closes[0] is the earlier close
"""
out[:] = (opens[-1] - closes[0]) / closes[0]
class TrailingOvernightReturns(Returns):
"""
Sum of trailing 1m O/N returns
"""
window_safe = True
def compute(self, today, asset_ids, out, cto):
out[:] = np.nansum(cto, axis=0)
def overnight_sentiment(cto_window_length, trail_overnight_returns_window_length, universe):
cto_out = CTO(mask=universe, window_length=cto_window_length)
return TrailingOvernightReturns(
inputs=[cto_out],window_length=trail_overnight_returns_window_length
)\
.rank().zscore()
```

- Overnight Sentiment Smoothed

Just like the implemented factor, we'll also smooth this factor.

```
def overnight_sentiment_smoothed(cto_window_length, trail_overnight_returns_window_length, universe):
unsmoothed_factor = overnight_sentiment(cto_window_length, trail_overnight_returns_window_length, universe)
return SimpleMovingAverage(
inputs=[unsmoothed_factor], window_length=trail_overnight_returns_window_length
) \
.rank() \
.zscore()
```

### Combined Alpha Factor

With all the factor implementations done, let's add them to a *zipline* pipeline.

```
universe = AverageDollarVolume(window_length=120).top(500)
sector = project_helper.Sector()
pipeline = Pipeline(screen=universe)
pipeline.add(
momentum_1yr(252, universe, sector),
'Momentum_1YR')
pipeline.add(
mean_reversion_5day_sector_neutral(5, universe, sector),
'Mean_Reversion_5Day_Sector_Neutral')
pipeline.add(
mean_reversion_5day_sector_neutral_smoothed(5, universe, sector),
'Mean_Reversion_5Day_Sector_Neutral_Smoothed')
pipeline.add(
overnight_sentiment(2, 5, universe),
'Overnight_Sentiment')
pipeline.add(
overnight_sentiment_smoothed(2, 5, universe),
'Overnight_Sentiment_Smoothed')
all_factors = engine.run_pipeline(pipeline, factor_start_date, universe_end_date)
# all_factors.head()
```

### Evaluate Alpha Factors

*Note:* *We're evaluating the alpha factors using delay of 1*

#### Quantile Analysis

Let's view the factor returns over time. It looks like moving up and to the right.

It is not enough to look just at the factor weighted return. A good alpha is also monotonic in quantiles. Let's looks the basis points for the factor returns.

Observations:

- None of these alphas are
**strictly monotonic**; this should lead you to question why this is? Further research and refinement of the alphas needs to be done. What is it about these alphas that leads to the highest ranking stocks in all alphas except MR 5D smoothed to*not*perform the best. - The majority of the return is coming from the
**short side**in all these alphas. The negative return in quintile 1 is very large in all alphas. This could also a cause for concern becuase when you short stocks, you need to locate the short; shorts can be expensive or not available at all. - If you look at the magnitude of the return spread (i.e., Q1 minus Q5), we are working with daily returns in the 0.03%, i.e.,
**3 basis points**, neighborhood*before all transaction costs, shorting costs, etc.*. Assuming 252 days in a year, that's 7.56% return annualized. Transaction costs may cut this in half. As such, it should be clear that these alphas can only survive in an institutional setting and that leverage will likely need to be applied in order to achieve an attractive return.

#### Turnover Analysis

Without doing a full and formal backtest, we can analyze how stable the alphas are over time. Stability in this sense means that from period to period, the alpha ranks do not change much. Since trading is costly, we always prefer, all other things being equal, that the ranks do not change significantly per period. We can measure this with the **factor rank autocorrelation (FRA)**.

#### Sharpe Ratio of the Alphas

The last analysis we'll do on the factors will be sharpe ratio. Function `sharpe_ratio`

calculate the sharpe ratio of factor returns.

```
def sharpe_ratio(factor_returns, annualization_factor):
"""
Get the sharpe ratio for each factor for the entire period
Parameters
----------
factor_returns : DataFrame
Factor returns for each factor and date
annualization_factor: float
Annualization Factor
Returns
-------
sharpe_ratio : Pandas Series of floats
Sharpe ratio
"""
return annualization_factor * np.mean(factor_returns)/np.std(factor_returns, ddof=1)
```

Let's see what the sharpe ratio for the factors are. Generally, a Sharpe Ratio of near 1.0 or higher is an acceptable single alpha for this universe.

Observation:

Sharpe Ratio of 1.13 for momentum factor is good but if we look at the auto-correlation plots, FRA for momentum factor looks stable. So smoothing the momentum factor will not have any significant change.

#### The Combined Alpha Vector

To use these alphas in a portfolio, we need to combine them somehow so we get a single score per stock. This is a area where machine learning can be very helpful. In this module, however, we will take the simplest approach of combination: simply averaging the scores from each alpha.

### Optimal Portfolio Constrained by Risk Model

#### Objective and Constraints

This is the list of contraints that will optimize against:

Where *x* is the portfolio weights, *B* is the factor betas, and *r* is the portfolio risk

The first constraint is that the predicted risk be less than some maximum limit. The second and third constraints are on the maximum and minimum portfolio factor exposures. The fourth constraint is the "market neutral constraint: the sum of the weights must be zero. The fifth constraint is the leverage constraint: the sum of the absolute value of the weights must be less than or equal to 1.0. The last are some minimum and maximum limits on individual holdings.

Weights generated after applying those constraints:

Yikes. It put most of the weight in a few stocks.

#### Optimize with a Regularization Parameter

This is the weights distribution after applying regularization to the **objective function**.

Nice. Well diverfied.

#### Optimize with a Strict Factor Constraints and Target Weighting

Another common formulation is to take a predefined target weighting(e.g., a quantile portfolio), and solve to get as close to that portfolio while respecting portfolio-level constraints.

### Libraries

This project used Python 3.6.3. The necessary libraries are mentioned in `requirements.txt`

: