### Archive

Archive for February, 2012

## Portfolio Optimization – Why do we need a Risk Model

February 26, 2012 1 comment

In the last post, Multiple Factor Model – Building Risk Model, I have shown how to build a multiple factor risk model. In this post I want to explain why do we need a risk model and how it is used during portfolio construction process.

The covariance matrix is used during the mean-variance portfolio optimization to estimate portfolio risk. The sample covariance matrix can estimated using historical asset’s returns, but the use of the sample covariance matrix becomes problematic when the number of assets (N) is of the same order of magnitude or larger than the number of observations (T). In typical applications, there can be over a thousand stocks to choose from, but rarely more than ten years of monthly data (i.e. N = 1,000 and T = 120). I recommend following references for a detailed discussion:

One possible solution to estimating a covariance matrix is to model risk by a low-dimensional multiple factor model. Another advantage of using a multiple factor model to describe covariances between assets is that portfolio optimization algorithm works faster because the covariance matrix is quite sparse and well structured. For a detailed discussion please read: Portfolio Optimization with Factors, Scenarios, and Realistic Short Positions by B. Jacobs, K. Levy, and H. Markowitz (2005) [In problems with a large number of securities, computation time may differ by orders of magnitude between using a dense covariance matrix(sample covariance matrix) and using the diagonal or nearly diagonal covariance matrices permitted by a multiple factor model of covariance.]

The outline of this post:

• Construct minimum variance portfolio using the sample covariance matrix
• Construct minimum variance portfolio using the multiple factor risk model we created in the prior post

Let’s start by loading the multiple factor risk model we saved at the end of the prior post. [If you are missing risk.model.Rdata file, please execute fm.risk.model.test() function first to create and save multiple factor risk model.] Next, I will construct minimum variance portfolio using the historical covariance matrix.

```###############################################################################
# Load Systematic Investor Toolbox (SIT)
# https://systematicinvestor.wordpress.com/systematic-investor-toolbox/
###############################################################################
con = gzcon(url('http://www.systematicportfolio.com/sit.gz', 'rb'))
source(con)
close(con)
#*****************************************************************
#******************************************************************

# Load factor data that we saved at the end of the fm.all.factor.test function
nperiods = nrow(next.month.ret)
n = ncol(next.month.ret)
tickers = colnames(next.month.ret)

# Load multiple factor risk model data that we saved at the end of the fm.risk.model.test function

#*****************************************************************
# Construct minimum variance portfolio using the sample covariance matrix
#******************************************************************

#--------------------------------------------------------------------------
# Create Covariance matrix based on the last 24 months of returns
#--------------------------------------------------------------------------
temp = last(mlag(next.month.ret),24)
cov.temp = cov(temp, use='complete.obs', method='pearson')
hist.cov = cov.temp

#--------------------------------------------------------------------------
#--------------------------------------------------------------------------
if(!is.positive.definite(cov.temp)) {
cov.temp <- make.positive.definite(cov.temp, 0.000000001)
}

#--------------------------------------------------------------------------
# Create constraints
#--------------------------------------------------------------------------
# set min/max wgts for individual stocks: 0 =< x <= 1
constraints = new.constraints(n, lb = 0, ub = 1)

# wgts must sum to 1 (fully invested)
constraints = add.constraints(rep(1,n), 1, type = '=', constraints)

#--------------------------------------------------------------------------
# Solve QP problem
#--------------------------------------------------------------------------
sol = solve.QP.bounds(Dmat = cov.temp, dvec = rep(0, nrow(cov.temp)) ,
Amat=constraints\$A, bvec=constraints\$b, constraints\$meq,
lb = constraints\$lb, ub = constraints\$ub)

#--------------------------------------------------------------------------
# Plot Portfolio weights
#--------------------------------------------------------------------------
x = round(sol\$solution,4)
x = iif(x < 0, 0, x)
names(x) = colnames(next.month.ret)
hist.min.var.portfolio = x

# plot
barplot(100*x,las = 2,
main = 'Minimum variance portfolio weights (sample covariance matrix)')
```

To minimize portfolio risk computed under risk model framework we have to combine specific risk and factor covariance matrix into one covariance matrix. This process is described on pages 4-5 of the Portfolio Optimization with Factors, Scenarios, and Realistic Short Positions by B. Jacobs, K. Levy, and H. Markowitz (2005).

Let K be the number of factors in the risk model. We introduce K additional variables that represent portfolio’s factor exposure to each factor. Let’s add K constraints:

`X1...Xn * factor.exposures = Xn+1...Xn+k`

The new covariance matrix:

```[specific.risk  0                 ]
[0              factor.covariance ]```

Next, I will construct minimum variance portfolio using the the multiple factor risk model we created in the prior post.

```	#*****************************************************************
# Construct minimum variance portfolio using the multiple factor risk model
#******************************************************************
t = nperiods
factor.exposures = all.data[t,,-1]
nfactors = ncol(factor.exposures)

#--------------------------------------------------------------------------
# Create constraints
#--------------------------------------------------------------------------
# set min/max wgts for individual stocks: 0 =< x <= 1
constraints = new.constraints(n, lb = 0, ub = 1)

# wgts must sum to 1 (fully invested)
constraints = add.constraints(rep(1,n), 1, type = '=', constraints)

# BX - Xnew = 0
constraints = add.constraints(rbind(factor.exposures, -diag(nfactors)), rep(0, nfactors), type = '=', constraints)

#--------------------------------------------------------------------------
# Create Covariance matrix
# [Qu  0]
# [ 0 Qf]
#--------------------------------------------------------------------------
temp = diag(n)
diag(temp) = specific.variance[t,]^2
cov.temp = diag(n + nfactors)
cov.temp[1:n,1:n] = temp
cov.temp[(n+1):(n+nfactors),(n+1):(n+nfactors)] = factor.covariance[t,,]

#--------------------------------------------------------------------------
# Solve QP problem
#--------------------------------------------------------------------------

sol = solve.QP.bounds(Dmat = cov.temp, dvec = rep(0, nrow(cov.temp)) ,
Amat=constraints\$A, bvec=constraints\$b, constraints\$meq,
lb = constraints\$lb, ub = constraints\$ub)

#--------------------------------------------------------------------------
# Plot Portfolio weights
#--------------------------------------------------------------------------
x = round(sol\$solution,4)[1:n]
x = iif(x < 0, 0, x)
names(x) = colnames(next.month.ret)
risk.model.min.var.portfolio = x

# plot
barplot(100*x,las = 2,
main = 'Minimum variance portfolio weights (multiple factor risk model)')
```

The minimum variance portfolio computed under the risk model is more diversified. Also for a larger stock universe (i.e. 1000-2000 stocks) solving quadratic problem will take less time using a factor risk model that results in a sparse covariance matrix.

To view the complete source code for this example, please have a look at the fm.risk.model.test() function in factor.model.test.r at github.

## Multiple Factor Model – Building Risk Model

This is the fourth post in the series about Multiple Factor Models. I will build on the code presented in the prior post, Multiple Factor Model – Building CSFB Factors, and I will show how to build a multiple factor risk model. For an example of the multiple factor risk models, please read following references:

The outline of this post:

• Run cross sectional regression to estimate factor returns
• Compute factor covariance using shrinkage estimator
• Forecast stocks specific variances using GARCH(1,1)
• Compute portfolio risk using multiple factor model and compare it to the historical standard deviation of portfolio returns.

Let’s start by loading the CSFB factors that we saved at the end of the prior post. [If you are missing data.factors.Rdata file, please execute fm.all.factor.test() function first to create and save CSFB factors.] Next, I will run cross sectional regression to estimate factor returns.

```###############################################################################
# Load Systematic Investor Toolbox (SIT)
# https://systematicinvestor.wordpress.com/systematic-investor-toolbox/
###############################################################################
con = gzcon(url('http://www.systematicportfolio.com/sit.gz', 'rb'))
source(con)
close(con)
#*****************************************************************
# Load factor data that we saved at the end of the fm.all.factor.test functions
#******************************************************************

# remove Composite Average factor
factors.avg = factors.avg[which(names(factors.avg) != 'AVG')]

#*****************************************************************
# Run cross sectional regression to estimate factor returns
#******************************************************************
nperiods = nrow(next.month.ret)
n = ncol(next.month.ret)

# create sector dummy variables: binary 0/1 values for each sector
nsectors = len(levels(sectors))
sectors.matrix = array(double(), c(nperiods, n, nsectors))
dimnames(sectors.matrix)[[3]] = levels(sectors)
for(j in levels(sectors)) {
sectors.matrix[,,j] = matrix(sectors == j,  nr=nperiods, nc=n, byrow=T)
}

# create matrix for each factor
factors.matrix = abind(factors.avg, along = 3)

# combine sector dummies and all factors
all.data = abind(sectors.matrix, factors.matrix)

# create betas and specific.return
beta = all.data[,1,] * NA
specific.return = next.month.ret * NA
nfactors = ncol(beta)

# append next.month.ret to all.data
all.data = abind(next.month.ret, all.data, along = 3)
dimnames(all.data)[[3]][1] = 'Ret'

# estimate betas (factor returns)
for(t in 12:(nperiods-1)) {
temp = all.data[t:t,,]
x = temp[,-c(1:2)]
y = temp[,1]
b = lm(y~x)\$coefficients

b[2:nsectors] = b[1] + b[2:nsectors]
beta[(t+1),] = b

specific.return[(t+1),] = y - rowSums(temp[,-1] * matrix(b, n, nfactors, byrow=T), na.rm=T)
}
```

To estimate factor returns (betas), we solve for coefficients of the following multiple factor model:

```Ret = b1 * F1 + b2 * F2 + ... + bn * Fn + e
where
b1...bn are estimated factor returns
F1...Fn are factor exposures. I.e. sector dummies and CSFB factor exposures
e is stock specific return, not captured by factors F1...Fn```

Note that we cannot include the first sector dummy variable in the regression, otherwise we will get a linearly dependent relationship of the first sector dummy variable with all other sector dummy variables. The sector effect of the first sector dummy variable is absorbed into the intercept in the regression.

There are a few alternative ways of estimating this regression. For example, the robust linear model can be estimated with following code:

```	load.packages('MASS')
temp = rlm(y~x)\$coefficients
```

The quantile regression can can be estimated with following code:

```	load.packages('quantreg')
temp = rq(y ~ x, tau = 0.5)\$coefficients
```

Next let’s look at the cumulative factor returns.

```	#*****************************************************************
# helper function
#******************************************************************
fm.hist.plot <- function(temp, smain=NULL) {
ntemp = ncol(temp)
cols = plota.colors(ntemp)
plota(temp, ylim = range(temp), log='y', main=smain)
for(i in 1:ntemp) plota.lines(temp[,i], col=cols[i])
plota.legend(colnames(temp), cols, as.list(temp))
}

#*****************************************************************
# Examine historical cumulative factor returns
#******************************************************************
temp = make.xts(beta, index(next.month.ret))
temp = temp['2000::',]
temp[] = apply(coredata(temp), 2, function(x) cumprod(1 + ifna(x,0)))

fm.hist.plot(temp[,-c(1:nsectors)], 'Factor Returns')
```

The Price Reversals(PR) and Small Size(SS) factors have done well.

Next let’s estimate the factor covariance matrix over the rolling 24 month window.

```	load.packages('BurStFin')
factor.covariance = array(double(), c(nperiods, nfactors, nfactors))
dimnames(factor.covariance)[[2]] = colnames(beta)
dimnames(factor.covariance)[[3]] = colnames(beta)

# estimate factor covariance
for(t in 36:nperiods) {
factor.covariance[t,,] = var.shrink.eqcor(beta[(t-23):t,])
}
```

Next let’s forecast stocks specific variances using GARCH(1,1). I will use the GARCH estimation routine described in the Trading using Garch Volatility Forecast post.

```	#*****************************************************************
# Compute stocks specific variance foreasts using GARCH(1,1)
#******************************************************************

specific.variance = next.month.ret * NA

for(i in 1:n) {
specific.variance[,i] = bt.forecast.garch.volatility(specific.return[,i], 24)
}

# compute historical specific.variance
hist.specific.variance = next.month.ret * NA
for(i in 1:n) hist.specific.variance[,i] = runSD(specific.return[,i], 24)

# if specific.variance is missing use historical specific.variance
specific.variance[] = ifna(coredata(specific.variance), coredata(hist.specific.variance))

#*****************************************************************
# Save multiple factor risk model to be used later during portfolio construction
#******************************************************************
save(all.data, factor.covariance, specific.variance, file='risk.model.Rdata')
```

Now we have all the ingredients to compute a portfolio risk:

```Portfolio Risk = (common factor variance + specific variance)^0.5
common factor variance = (portfolio factor exposure) * factor covariance matrix * (portfolio factor exposure)'
specific variance = (specific.variance)^2 * (portfolio weights)^2```
```	#*****************************************************************
# Compute portfolio risk
#******************************************************************
portfolio = rep(1/n, n)
portfolio = matrix(portfolio, n, nfactors)

portfolio.risk = next.month.ret[,1] * NA
for(t in 36:(nperiods-1)) {
portfolio.exposure = colSums(portfolio * all.data[t,,-1], na.rm=T)

portfolio.risk[t] = sqrt(
portfolio.exposure %*% factor.covariance[t,,] %*% (portfolio.exposure) +
sum(specific.variance[t,]^2 * portfolio[,1]^2, na.rm=T)
)
}
```

Next let’s compare portfolio risk estimated using multiple factor risk model with portfolio historical risk.

```	#*****************************************************************
# Compute historical portfolio risk
#******************************************************************
portfolio = rep(1/n, n)
portfolio = t(matrix(portfolio, n, nperiods))

portfolio.returns = next.month.ret[,1] * NA
portfolio.returns[] = rowSums(mlag(next.month.ret) * portfolio, na.rm=T)

hist.portfolio.risk = runSD(portfolio.returns, 24)

#*****************************************************************
# Plot risks
#******************************************************************
plota(portfolio.risk['2000::',], type='l')
plota.lines(hist.portfolio.risk, col='blue')
plota.legend('Risk,Historical Risk', 'black,blue')
```

The multiple factor risk model does a decent job of estimating portfolio risk most of the time.

To view the complete source code for this example, please have a look at the fm.risk.model.test() function in factor.model.test.r at github.

## Multiple Factor Model – Building CSFB Factors

This is the third post in the series about Multiple Factor Models. I will build on the code presented in the prior post, Multiple Factor Model – Building Fundamental Factors, and I will show how to build majority of factors described in the CSFB Alpha Factor Framework. For details of the CSFB Alpha Factor Framework please read CSFB Quantitative Research, Alpha Factor Framework on page 11, page 49 by P. N. Patel, S. Yao, R. Carlson, A. Banerji, J. Handelman.

This post will include long sections of code to extract/format data and build factors. I created a few helper functions for data manipulations and visualizations in the factor.model.r at github. For example, consecutive.changes function counts the number of consecutive positive changes.

The outline of this post:

• Create majority of CSFB factors
• Create and test Composite Average factor

Let’s start by getting Fundamental data and creating factors. In the prior post, I mentioned that it takes a while to download historical fundamental data for all companies in the Dow Jones index, and I recommend saving fundamental data with save(data.fund, file=’data.fund.Rdata’) command. In the following code I will just load historical fundamental data with load(file=’data.fund.Rdata’) command instead of downloading all data again.

```###############################################################################
# Load Systematic Investor Toolbox (SIT)
# https://systematicinvestor.wordpress.com/systematic-investor-toolbox/
###############################################################################
con = gzcon(url('http://www.systematicportfolio.com/sit.gz', 'rb'))
source(con)
close(con)

#*****************************************************************
# Find Sectors for each company in DOW 30
#******************************************************************
tickers = spl('XLY,XLP,XLE,XLF,XLV,XLI,XLB,XLK,XLU')
tickers.desc = spl('ConsumerCyclicals,ConsumerStaples,Energy,Financials,HealthCare,Industrials,Materials,Technology,Utilities')

sector.map = c()
for(i in 1:len(tickers)) {
sector.map = rbind(sector.map,
cbind(sector.spdr.components(tickers[i]), tickers.desc[i])
)
}
colnames(sector.map) = spl('ticker,sector')

#*****************************************************************
#******************************************************************
tickers = dow.jones.components()

sectors = factor(sector.map[ match(tickers, sector.map[,'ticker']), 'sector'])
names(sectors) = tickers

# get fundamental data

# get pricing data

#*****************************************************************
# Combine fundamental and pricing data
#******************************************************************
for(i in tickers) {
fund = data.fund[[i]]
fund.date = date.fund.data(fund)
nperiods = ncol(fund)

# D - holds all data to be merged with pricing data
D = list()

#--------------------------------------------------------------
# Data for Traditional and Relative Value
#--------------------------------------------------------------

# Earnings per Share
D\$EPS = get.fund.data('Diluted EPS from Total Operations', fund, fund.date, is.12m.rolling=T)

# Sales, exception not available for financial service firms
D\$SALE = get.fund.data('total revenue', fund, fund.date, is.12m.rolling=T)

# Common Shares Outstanding
D\$CSHO = get.fund.data('total common shares out', fund, fund.date)

# Common Equity
D\$CEQ = get.fund.data('total equity', fund, fund.date)

# Dividends
D\$DV.PS = get.fund.data('dividends paid per share', fund, fund.date, is.12m.rolling=T)

# Cash Flow
D\$CFL = get.fund.data('net cash from operating activities', fund, fund.date, cash.flow=T, is.12m.rolling=T)

#--------------------------------------------------------------
# Data for Historical Growth
#--------------------------------------------------------------

# Consecutive Quarters of Positive Changes in Trailing 12 Month Cash Flow
D\$CFL.CON.CHG = consecutive.changes(D\$CFL)
# check
#merge(D\$CFL, sign(diff(D\$CFL)), consecutive.changes(D\$CFL), consecutive.changes(D\$CFL,F))

# Consecutive Quarters of Positive Change in Quarterly Earnings
D\$EPS.CON.CHG = consecutive.changes(D\$EPS)

# 12 Month Change in Quarterly Cash Flow
temp = get.fund.data('net cash from operating activities', fund, fund.date, cash.flow=T)
D\$CFL.CHG = temp / mlag(temp,4)

# 3 Year Average Annual Sales Growth
D\$SALE.3YR.GR = D\$SALE
if(!all(is.na(D\$SALE))) D\$SALE.3YR.GR = SMA(ifna(D\$SALE / mlag(D\$SALE,4) - 1,NA), 3*4)

# 3 Year Average Annual Earnings Growth
D\$EPS.3YR.GR = SMA(D\$EPS / mlag(D\$EPS,4) - 1, 3*4)

# 12 Quarter Trendline in Trailing 12 Month Earnings
D\$EPS.TREND = D\$EPS * NA
D\$EPS.TREND[12:nperiods] = sapply(12:nperiods, function(i) beta.degree(ols(cbind(1,1:12), D\$EPS[(i-12+1):i])\$coefficients[2]))

# Slope of Trend Line Through Last 4 Quarters of Trailing 12M Cash Flows
D\$CFL.TREND = D\$CFL * NA
D\$CFL.TREND[4:nperiods] = sapply(4:nperiods, function(i) beta.degree(ols(cbind(1,1:4), D\$CFL[(i-4+1):i])\$coefficients[2]))

#--------------------------------------------------------------
# Data for Profit Trends
#--------------------------------------------------------------
RECT = get.fund.data('receivables', fund, fund.date)
INVT = get.fund.data('inventories', fund, fund.date)

D\$AT = get.fund.data('total assets', fund, fund.date)
XSGA = get.fund.data('Selling, General & Administrative (SG&A) Expense', fund, fund.date, is.12m.rolling=T)

# Consecutive Quarters of Declines in (Receivables+Inventories) / Sales
D\$RS.CON.CHG = consecutive.changes((RECT + INVT) / D\$SALE, F)

# Consecutive Qtrs of Positive Change in Trailing 12M Cash Flow / Sales
D\$CS.CON.CHG = consecutive.changes(D\$CFL/D\$SALE)

# Consecutive Quarters of Declines in Trailing 12 Month Overhead / Sales
D\$OS.CON.CHG = consecutive.changes(XSGA/D\$SALE, F)

# (Industry Relative) Trailing 12 Month (Receivables+Inventories) / Sales
D\$RS = (RECT + INVT) / D\$SALE

# (Industry Relative) Trailing 12 Month Sales / Assets
D\$SA = D\$SALE / D\$AT

# Trailing 12 Month Overhead / Sales
D\$OS = XSGA / D\$SALE

# Trailing 12 Month Earnings / Sales
D\$ES = D\$EPS / D\$SALE

#--------------------------------------------------------------
# Merge Fundamental and Pricing data
#--------------------------------------------------------------

# merge
data[[i]] = merge(data[[i]], as.xts(abind(D,along=2), fund.date))
}

bt.prep(data, align='keep.all', dates='1995::2011')

#*****************************************************************
# Create Factors
#******************************************************************
prices = data\$prices
prices = bt.apply.matrix(prices, function(x) ifna.prev(x))

# re-map sectors
sectors	= sectors[colnames(prices)]

# create factors
factors = list()
factor.names = list()
```

Next let’s create majority of CSFB factors.

```	#*****************************************************************
#******************************************************************
factors\$TV = list()

# Market Value - capitalization
CSHO =  bt.apply(data, function(x) ifna.prev(x[, 'CSHO']))
MKVAL = prices * CSHO

# Price / Earnings
EPS = bt.apply(data, function(x) ifna.prev(x[, 'EPS']))
factors\$TV\$EP = EPS / prices

# Price / Trailing Sales
SALE = bt.apply(data, function(x) ifna.prev(x[, 'SALE']))
factors\$TV\$SP = SALE / MKVAL

# Price / Trailing Cash Flow
CFL = bt.apply(data, function(x) ifna.prev(x[, 'CFL']))
factors\$TV\$CFP = CFL / MKVAL

# Dividend Yield
DV.PS = bt.apply(data, function(x) ifna.prev(x[, 'DV.PS']))
factors\$TV\$DY = DV.PS / prices

# Price / Book Value
CEQ = bt.apply(data, function(x) ifna.prev(x[, 'CEQ']))
factors\$TV\$BP = CEQ	/ MKVAL

# Eliminate Price/Sales and Price/Cash Flow for financial firms
factors\$TV\$SP[, sectors == 'Financials'] = NA
factors\$TV\$CFP[, sectors == 'Financials'] = NA

#*****************************************************************
# Create Historical Growth
#******************************************************************
factors\$HG = list()
factor.names\$HG = 'Historical Growth'

for(i in spl('CFL.CON.CHG,EPS.CON.CHG,CFL.CHG,SALE.3YR.GR,EPS.3YR.GR,EPS.TREND,CFL.TREND')) {
factors\$HG[[i]] = bt.apply(data, function(x) ifna.prev(x[, i]))
}

#*****************************************************************
# Create Profit Trends
#******************************************************************
factors\$PT = list()
factor.names\$PT = 'Profit Trends'

for(i in spl('RS.CON.CHG,CS.CON.CHG,OS.CON.CHG,RS,SA,OS,ES')) {
factors\$PT[[i]] = bt.apply(data, function(x) ifna.prev(x[, i]))
}

#*****************************************************************
# Create Price Momentum
#******************************************************************
factors\$PM = list()
factor.names\$PM = 'Price Momentum'

# find week ends
week.ends = endpoints(prices, 'weeks')
week.prices = prices[week.ends,]
week.nperiods = nrow(week.prices)

#Slope of 52 Week Trend Line
factors\$PM\$S52W.TREND = bt.apply.matrix(week.prices, function(x) {
c(rep(NA,51),
sapply(52:week.nperiods, function(i) beta.degree(ols(cbind(1,1:52), x[(i - 52 + 1):i])\$coefficients[2]))
)})

#4/52 Week Price Oscillator
factors\$PM\$PP04.52W = bt.apply.matrix(week.prices, EMA, 4) / bt.apply.matrix(week.prices, EMA, 52)

#39 Week Return
factors\$PM\$R39W = week.prices / mlag(week.prices, 39)

#51 Week Volume Price Trend
# compute weekly volume
temp = bt.apply(data, function(x) cumsum(ifna(Vo(x),0)))
temp = temp[week.ends,]
week.volume = temp - mlag(temp)
temp = (week.prices - mlag(week.prices)) * week.volume
factors\$PM\$VPT51W = bt.apply.matrix(temp, runSum, 51)

# Convert weekly to daily
for(i in 1:len(factors\$PM)) {
temp = prices * NA
temp[week.ends,] = factors\$PM[[i]]
factors\$PM[[i]] = bt.apply.matrix(temp, function(x) ifna.prev(x))
}

#Percent Above 260 Day Low
factors\$PM\$P260LOW = prices / bt.apply.matrix(prices, runMin, 260)

# Flip sign
for(i in names(factors\$PM)) factors\$PM[[i]] = -factors\$PM[[i]]

#*****************************************************************
# Create Price Reversal
#******************************************************************
factors\$PR = list()
factor.names\$PR = 'Price Reversal'

#5 Day Industry Relative Return
factors\$PR\$r5DR = prices/mlag(prices, 5)
factors\$PR\$r5DR = factors\$PR\$r5DR / sector.mean(factors\$PR\$r5DR, sectors)

#5 Day Money Flow / Volume
factors\$PR\$MFV = bt.apply(data, function(x) {
MFI(cbind(ifna.prev(Hi(x)),ifna.prev(Lo(x)),ifna.prev(Cl(x))), 5) / ifna.prev(Vo(x))
})

#10 Day MACD - Signal Line
factors\$PR\$MACD = bt.apply.matrix(prices, function(x) {
temp=MACD(x, 10)
temp[, 'macd'] - temp[, 'signal']
})

#14 Day RSI (Relative Strength Indicator)
factors\$PR\$RSI = bt.apply.matrix(prices, RSI, 14)

#14 Day Stochastic
factors\$PR\$STOCH = bt.apply(data, function(x) {
stoch(cbind(ifna.prev(Hi(x)),ifna.prev(Lo(x)),ifna.prev(Cl(x))),14)[,'slowD']
})

#4 Week Industry Relative Return
factors\$PR\$rR4W = week.prices / mlag(week.prices,4)
factors\$PR\$rR4W = factors\$PR\$rR4W / sector.mean(factors\$PR\$rR4W, sectors)

# Convert weekly to daily
temp = prices * NA
temp[week.ends,] = factors\$PR\$rR4W
factors\$PR\$rR4W = bt.apply.matrix(temp, function(x) ifna.prev(x))

# VOMO - Volume x Momentum
volume = bt.apply(data, function(x) ifna.prev(Vo(x)))
factors\$PR\$VOMO = (prices / mlag(prices,10) - 1) * bt.apply.matrix(volume, runMean, 22) / bt.apply.matrix(volume, runMean, 66)

# Flip sign
for(i in names(factors\$PR)) factors\$PR[[i]] = -factors\$PR[[i]]

#*****************************************************************
# Create Small Size
#******************************************************************
factors\$SS = list()
factor.names\$SS = 'Small Size'

#Log of Market Capitalization
factors\$SS\$MC = log(MKVAL)

#Log of Market Capitalization Cubed
factors\$SS\$MC3 = log(MKVAL)^3

#Log of Stock Price
factors\$SS\$P = log(prices)

#Log of Total Assets
factors\$SS\$AT = log(bt.apply(data, function(x) ifna.prev(x[, 'AT'])))

#Log of Trailing-12-Month Sales
factors\$SS\$SALE = log(bt.apply(data, function(x) ifna.prev(x[, 'SALE'])))

# Flip sign
for(i in names(factors\$SS)) factors\$SS[[i]] = -factors\$SS[[i]]

#*****************************************************************
# Convert to monthly
#******************************************************************
# find month ends
month.ends = endpoints(prices, 'months')

prices = prices[month.ends,]
n = ncol(prices)
nperiods = nrow(prices)

ret = prices / mlag(prices) - 1
next.month.ret = mlag(ret, -1)

MKVAL = MKVAL[month.ends,]

for(j in 1:len(factors)) {
for(i in 1:len(factors[[j]])) {
factors[[j]][[i]] = factors[[j]][[i]][month.ends,]
factors[[j]][[i]][] = ifna(factors[[j]][[i]],NA)
}
}

#*****************************************************************
# Create Relative Value
#******************************************************************
factors\$RV = list()
factor.names\$RV = 'Relative Value'

# relative
for(i in spl('EP,SP,CFP')) {
factors\$RV[[paste('r',i,sep='')]] = factors\$TV[[i]] / sector.mean(factors\$TV[[i]], sectors)
}

# spreads, 5 Year Avg = 60 months
for(i in spl('rEP,rSP,rCFP')) {
factors\$RV[[paste('s',i,sep='')]] = factors\$RV[[i]] -
apply(factors\$RV[[i]], 2, function(x) if(all(is.na(x))) x else SMA(x,60) )
}

#*****************************************************************
# Profit Trends (Relative)
#******************************************************************
# relative
for(i in spl('RS,SA')) {
factors\$PT[[paste('r',i,sep='')]] = factors\$PT[[i]] / sector.mean(factors\$PT[[i]], sectors)
}
```

Next let’s create Composite Average factor and chart its performance.

```	#*****************************************************************
# Normalize and add Average factor
#******************************************************************
for(j in names(factors)) {
factors[[j]] = normalize.normal(factors[[j]])
}

#*****************************************************************
# Create Composite Average factor
#******************************************************************
factors.avg = list()
for(j in names(factors)) factors.avg[[j]] = factors[[j]]\$AVG

#*****************************************************************
# Backtest qutiles and qutile spread
#******************************************************************
plot.quantiles(factors.avg, next.month.ret, 'Average')

plot.bt.quantiles(factors.avg\$AVG, next.month.ret, 'Composite Average', data)
```

Please note that I’m using the current Dow Jones index components through out the whole history. This is a problem because the Dow Jones index changed its composition a few times in the last 20 years. One of the signs of this bias is high spread for Small Size group of factors. It is not obvious that buying low priced stocks and selling high priced stocks should consistently make money; but it makes sense, if we know beforehand that that low priced companies will be part of Dow Jones index at some point.

Instead of using a simple average of all factors to rank stocks, we can run cross sectional regression to estimate factor loading, and create Alpha model using estimated factor loading. For a complete description of this process, I recommend reading Commonality In The Determinants Of Expected Stock Returns by R. Haugen, N. Baker (1996) pages 8-9.

```	#*****************************************************************
# Save CSFB factors to be used later to create multiple factor Risk Model
#******************************************************************
save(data, sectors, factors.avg, next.month.ret, file='data.factors.Rdata')
# remove Composite Average factor
factors.avg = factors.avg[which(names(factors.avg) != 'AVG')]

#*****************************************************************
# Run cross sectional regression and create Alpha model
#******************************************************************
nperiods = nrow(next.month.ret)
n = ncol(next.month.ret)

# create matrix for each factor
factors.matrix = abind(factors.avg, along = 3)
all.data = factors.matrix

# betas
beta = all.data[,1,] * NA

# append next.month.ret to all.data
all.data = abind(next.month.ret, all.data, along = 3)
dimnames(all.data)[[3]][1] = 'Ret'

# estimate betas (factor returns)
for(t in 12:(nperiods-1)) {
temp = all.data[t:t,,]
x = temp[,-1]
y = temp[,1]
beta[(t+1),] = lm(y~x-1)\$coefficients
}

# create Alpha return forecasts
alpha = next.month.ret * NA

for(t in 18:(nperiods-1)) {
# average betas over the last 6 months
coef = colMeans(beta[(t-5):t,],na.rm=T)
alpha[t,] = rowSums(all.data[t,,-1] * t(repmat(coef, 1,n)), na.rm=T)
}

#*****************************************************************
# Backtest qutiles and qutile spread
#******************************************************************
layout(1:2)
temp = compute.quantiles(alpha, next.month.ret, plot=T)
plot.bt.quantiles(alpha, next.month.ret, 'Alpha', data)
```

The performance of the regression model lags the performance of the simple average of all factors to rank stocks. There are might be many reasons for this, but I want to show you one quick and rational way to increase performance of the regression model.

We do not restrict estimated factor loadings during regression; however, a negative coefficient for a Value factor does not make sense. I don’t want explicitly say that good Value companies should have lower ranks than bad Value companies, just because there is a negative coefficient for a Value factor. One possible solution is to only use factor loadings that are positive to construct Alpha score. Here is the modified code:

```	for(t in 18:(nperiods-1)) {
# average betas over the last 6 months
coef = colMeans(beta[(t-5):t,],na.rm=T)

coef = iif(coef > 0, coef, 0)

alpha[t,] = rowSums(all.data[t,,-1] * t(repmat(coef, 1,n)), na.rm=T)
}
```

The regression model still lags the performance of the simple average of all factors to rank stocks.

In the next post I will show how to create a risk model and estimate risk.

To view the complete source code for this example, please have a look at the fm.all.factor.test() function in factor.model.test.r at github.

## Multiple Factor Model – Building Fundamental Factors

This is the second post in the series about Multiple Factor Models. I will build on the code presented in the prior post, Multiple Factor Model – Fundamental Data, and I will show how to build Fundamental factors described in the CSFB Alpha Factor Framework. For details of the CSFB Alpha Factor Framework please read CSFB Quantitative Research, Alpha Factor Framework on page 11, page 49 by P. N. Patel, S. Yao, R. Carlson, A. Banerji, J. Handelman.

The CSFB Alpha Factor Framework has both traditional Fundamental factors and industry relative Fundamental factors. Let’s start by getting Fundamental data that we will need to create Price/Earnings, Price/Sales, Price/Cash Flow, Dividend Yield, Price/Book factors. In the prior post, I mentioned that it takes a while to download historical fundamental data for all companies in the Dow Jones index, and I recommend saving fundamental data with save(data.fund, file=’data.fund.Rdata’) command. In the following code I will just load historical fundamental data with load(file=’data.fund.Rdata’) command instead of downloading all data again.

```###############################################################################
# Load Systematic Investor Toolbox (SIT)
# https://systematicinvestor.wordpress.com/systematic-investor-toolbox/
###############################################################################
con = gzcon(url('http://www.systematicportfolio.com/sit.gz', 'rb'))
source(con)
close(con)

#*****************************************************************
# Find Sectors for each company in DOW 30
#******************************************************************
tickers = spl('XLY,XLP,XLE,XLF,XLV,XLI,XLB,XLK,XLU')
tickers.desc = spl('ConsumerCyclicals,ConsumerStaples,Energy,Financials,HealthCare,Industrials,Materials,Technology,Utilities')

sector.map = c()
for(i in 1:len(tickers)) {
sector.map = rbind(sector.map,
cbind(sector.spdr.components(tickers[i]), tickers.desc[i])
)
}
colnames(sector.map) = spl('ticker,sector')

#*****************************************************************
#******************************************************************
tickers = dow.jones.components()

sectors = factor(sector.map[ match(tickers, sector.map[,'ticker']), 'sector'])
names(sectors) = tickers

# get fundamental data

# get pricing data

#*****************************************************************
# Combine fundamental and pricing data
#******************************************************************
for(i in tickers) {
fund = data.fund[[i]]
fund.date = date.fund.data(fund)

# Earnings per Share
EPS = get.fund.data('Diluted EPS from Total Operations', fund, fund.date, is.12m.rolling=T)

# Sales, exception not available for financial firms
SALE = get.fund.data('total revenue', fund, fund.date, is.12m.rolling=T)

# Common Shares Outstanding
CSHO = get.fund.data('total common shares out', fund, fund.date)

# Common Equity
CEQ = get.fund.data('total equity', fund, fund.date)

# Dividends
DV.PS = get.fund.data('dividends paid per share', fund, fund.date, is.12m.rolling=T)

# Cash Flow, exception not available for financial firms
CFL = get.fund.data('net cash from operating activities', fund, fund.date, cash.flow=T, is.12m.rolling=T)

# merge
data[[i]] = merge(data[[i]], EPS, SALE, CSHO, CEQ, DV.PS, CFL)
}

bt.prep(data, align='keep.all', dates='1995::2011')

#*****************************************************************
# Create Factors
#******************************************************************
prices = data\$prices
prices = bt.apply.matrix(prices, function(x) ifna.prev(x))

sectors	= sectors[colnames(prices)]

# create factors
factors = list()
```

In the Dow Jones index there are 4 financial firms (AXP, BAC, JPM, TRV) and Sales and Cash Flow are not really measurable for financial firms. Please read Valuing Financial Service Firms by A. Damodaran for detailed explanation why Sales and Cash Flow are not really measurable for financial firms.

Next let’s create Traditional Value factors: Price/Earnings, Price/Sales, Price/Cash Flow, Dividend Yield, Price/Book.

```	#*****************************************************************
#******************************************************************
factors\$TV = list()

# Market Value - capitalization
CSHO =  bt.apply(data, function(x) ifna.prev(x[, 'CSHO']))
MKVAL = prices * CSHO

# Price / Earnings
EPS = bt.apply(data, function(x) ifna.prev(x[, 'EPS']))
factors\$TV\$EP = EPS / prices

# Price / Trailing Sales
SALE = bt.apply(data, function(x) ifna.prev(x[, 'SALE']))
factors\$TV\$SP = SALE / MKVAL

# Price / Trailing Cash Flow
CFL = bt.apply(data, function(x) ifna.prev(x[, 'CFL']))
factors\$TV\$CFP = CFL / MKVAL

# Dividend Yield
DV.PS = bt.apply(data, function(x) ifna.prev(x[, 'DV.PS']))
factors\$TV\$DY = DV.PS / prices

# Price / Book Value
CEQ = bt.apply(data, function(x) ifna.prev(x[, 'CEQ']))
factors\$TV\$BP = CEQ	/ MKVAL

# Eliminate Price/Sales and Price/Cash Flow for financial firms
factors\$TV\$SP[, sectors == 'Financials'] = NA
factors\$TV\$CFP[, sectors == 'Financials'] = NA

#*****************************************************************
# Convert to monthly
#******************************************************************
# find month ends
month.ends = endpoints(prices, 'months')

prices = prices[month.ends,]
n = ncol(prices)
nperiods = nrow(prices)

ret = prices / mlag(prices) - 1
next.month.ret = mlag(ret, -1)

MKVAL = MKVAL[month.ends,]

for(j in 1:len(factors)) {
for(i in 1:len(factors[[j]])) {
factors[[j]][[i]] = factors[[j]][[i]][month.ends,]
}
}
```

To create an overall Traditional Value factor, let’s first normalize (convert to z scores) all Traditional Value factors by subtracting capitalization weighted average and dividing by standard deviation. The overall Traditional Value factor is an average of all normalized Traditional Value factors.

```	#*****************************************************************
# Create the overall Traditional Value factor
#******************************************************************
# check missing data for financial firms
sapply(factors\$TV, count)

# normalize (convert to z scores) cross sectionaly all Traditional Value factors
for(i in names(factors\$TV)) {
factors\$TV[[i]] = (factors\$TV[[i]] - cap.weighted.mean(factors\$TV[[i]], MKVAL)) /
apply(factors\$TV[[i]], 1, sd, na.rm=T)
}

# compute the overall Traditional Value factor
temp = abind(factors\$TV, along = 3)
factors\$TV\$AVG = factors\$TV[[1]]
factors\$TV\$AVG[] = apply(temp, c(1,2), mean, na.rm=T)

# plot quintile charts for all Traditional Value factors
layout(matrix(1:6,nc=2))
sapply(1:len(factors\$TV), function(i)
)
```

I created a compute.quantiles() function in factor.model.r at github to compute and plot quantiles. For example, the quantiles chart for EP factor shows the average next month performance of stocks in each quantiles. The quantiles are created each month by ranking stocks by EP factor and grouping them into 5 quantiles. There is tendency of quantile 5 (Q5) to outperform quantile 1 (Q1) in most cases. The relationship between quantiles is not perfect, but the spread between Q5-Q1 is positive.

Next let’s examine quantiles for the overall Traditional Value factor in more details.

```	#*****************************************************************
# Backtest quantiles and quantile spread
#******************************************************************
out = compute.quantiles(factors\$TV\$AVG, next.month.ret, plot=F)

prices = data\$prices
prices = bt.apply.matrix(prices, function(x) ifna.prev(x))

# create strategies that invest in each qutile
models = list()

for(i in 1:5) {
data\$weight[] = NA
data\$weight[month.ends,] = iif(out\$quantiles == i, out\$weights, 0)
capital = 100000
data\$weight[] = (capital / prices) * (data\$weight)
models[[paste('Q',i,sep='')]] = bt.run(data, type='share', capital=capital)
}

data\$weight[] = NA
data\$weight[month.ends,] = iif(out\$quantiles == 5, out\$weights,
iif(out\$quantiles == 1, -out\$weights, 0))
capital = 100000
data\$weight[] = (capital / prices) * (data\$weight)
models\$Q5_Q1 = bt.run(data, type='share', capital=capital)

#*****************************************************************
# Create Report
#******************************************************************
plotbt(models, plotX = T, log = 'y', LeftMargin = 3)
mtext('Cumulative Performance', side = 2, line = 1)
```

The quantile spread Q5-Q1 shows consistent positive performance after 2000, but is inverted from 1995 to 2000. This is a bit strange and calls for more investigation.

In the next posts, I will show how to run pooled cross sectional regression to create alpha scores.

To view the complete source code for this example, please have a look at the fm.fund.factor.test() function in factor.model.test.r at github.