## Trading Strategy Sensitivity Analysis

When designing a trading strategy, I want to make sure that small changes in the strategy parameters will not transform the profitable strategy into the loosing one. I will study the strategy robustness and profitability under different parameter scenarios using a sample strategy presented by David Varadi in the Improving Trend-Following Strategies With Counter-Trend Entries post.

First, let’s implement this trend-following strategy using the backtesting library in the Systematic Investor Toolbox:

# Load Systematic Investor Toolbox (SIT) setInternet2(TRUE) con = gzcon(url('https://github.com/systematicinvestor/SIT/raw/master/sit.gz', 'rb')) source(con) close(con) #***************************************************************** # Load historical data #****************************************************************** load.packages('quantmod') tickers = spl('SPY') data <- new.env() getSymbols(tickers, src = 'yahoo', from = '1970-01-01', env = data, auto.assign = T) bt.prep(data, align='keep.all', dates='1970::2011') #***************************************************************** # Code Strategies #****************************************************************** prices = data$prices # Buy & Hold data$weight[] = 1 buy.hold = bt.run(data) # Trend-Following strategy: Long[Close > SMA(10) ] sma = bt.apply(data, function(x) { SMA(Cl(x), 10) } ) data$weight[] = NA data$weight[] = iif(prices >= sma, 1, 0) trend.following = bt.run(data, trade.summary=T) # Trend-Following With Counter-Trend strategy: Long[Close > SMA(10), DVB(1) CounterTrend ] dv = bt.apply(data, function(x) { DV(HLC(x), 1, TRUE) } ) data$weight[] = NA data$weight[] = iif(prices > sma & dv < 0.25, 1, data$weight) data$weight[] = iif(prices < sma & dv > 0.75, 0, data$weight) trend.following.dv1 = bt.run(data, trade.summary=T) #***************************************************************** # Create Report #****************************************************************** plotbt.custom.report(trend.following.dv1, trend.following, buy.hold)

The Counter-Trend Entries (trend.following.dv1, black line) improved the performance of the simple Trend-Following (trend.following, red line) strategy: both returns are higher and drawdowns are smaller.

Next, I will examine how CAGR, Sharpe, DVR, and Maximum Drawdowns are affected by varying length of the moving average from 10 to 100 and varying length of the DV from 1 to 5:

#***************************************************************** # Sensitivity Analysis #****************************************************************** ma.lens = seq(10, 100, by = 10) dv.lens = seq(1, 5, by = 1) # precompute indicators mas = matrix(double(), nrow(prices), len(ma.lens)) dvs = matrix(double(), nrow(prices), len(dv.lens)) for(i in 1:len(ma.lens)) { ma.len = ma.lens[i] mas[, i] = bt.apply(data, function(x) { SMA(Cl(x), ma.len) } ) } for(i in 1:len(dv.lens)) { dv.len = dv.lens[i] dvs[,i] = bt.apply(data, function(x) { DV(HLC(x), dv.len, TRUE) } ) } # allocate matrixes to store backtest results dummy = matrix(double(), len(ma.lens), 1+len(dv.lens)) rownames(dummy) = paste('SMA', ma.lens) colnames(dummy) = c('NO', paste('DV', dv.lens)) out = list() out$Cagr = dummy out$Sharpe = dummy out$DVR = dummy out$MaxDD = dummy # evaluate strategies for(ima in 1:len(ma.lens)) { sma = mas[, ima] cat('SMA =', ma.lens[ima], '\n') for(idv in 0:len(dv.lens)) { if( idv == 0 ) { data$weight[] = NA data$weight[] = iif(prices > sma, 1, 0) } else { dv = dvs[, idv] data$weight[] = NA data$weight[] = iif(prices > sma & dv < 0.25, 1, data$weight) data$weight[] = iif(prices < sma & dv > 0.75, 0, data$weight) } strategy = bt.run(data, silent=T) # add 1 to account for benchmark case, no counter-trend idv = idv + 1 out$Cagr[ima, idv] = compute.cagr(strategy$equity) out$Sharpe[ima, idv] = compute.sharpe(strategy$ret) out$DVR[ima, idv] = compute.DVR(strategy) out$MaxDD[ima, idv] = compute.max.drawdown(strategy$equity) } } #***************************************************************** # Create Report #****************************************************************** layout(matrix(1:4,nrow=2)) for(i in names(out)) { temp = out[[i]] temp[] = plota.format( 100 * temp, 1, '', '' ) plot.table(temp, smain = i, highlight = T, colorbar = F) }

The first column, labeled “NO”, shows the performance of the Trend-Following strategy (no Counter-Trend Entries). The Counter-Trend filter improves the strategy performance for most of the parameter scenarios. This is the result you want to get by doing Sensitivity Analysis, the strategy is robust and profitable under variety of parameters.

The next step, which you can do as a homework, is to examine the strategy performance with different instruments. For example, a more volatile Nasdaq (QQQ), or a Canadian S&P/TSX Index (XIU.TO).

To view the complete source code for this example, please have a look at the bt.improving.trend.following.test() function in bt.test.r at github.

## Introduction to Backtesting library in the Systematic Investor Toolbox

I wrote a simple Backtesting library to evaluate and analyze Trading Strategies. I will use this library to present the performance of trading strategies that I will study in the next series of posts.

It is very easy to write a simple Backtesting routine in R, for example:

bt.simple <- function(data, signal) { # lag singal signal = Lag(signal, 1) # back fill signal = na.locf(signal, na.rm = FALSE) signal[is.na(signal)] = 0 # calculate Close-to-Close returns ret = ROC(Cl(data), type='discrete') ret[1] = 0 # compute stats bt = list() bt$ret = ret * signal bt$equity = cumprod(1 + bt$ret) return(bt) } # Test for bt.simple functions load.packages('quantmod') # load historical prices from Yahoo Finance data = getSymbols('SPY', src = 'yahoo', from = '1980-01-01', auto.assign = F) # Buy & Hold signal = rep(1, nrow(data)) buy.hold = bt.simple(data, signal) # MA Cross sma = SMA(Cl(data),200) signal = ifelse(Cl(data) > sma, 1, 0) sma.cross = bt.simple(data, signal) # Create a chart showing the strategies perfromance in 2000:2009 dates = '2000::2009' buy.hold.equity = buy.hold$equity[dates] / as.double(buy.hold$equity[dates][1]) sma.cross.equity = sma.cross$equity[dates] / as.double(sma.cross$equity[dates][1]) chartSeries(buy.hold.equity, TA = c(addTA(sma.cross.equity, on=1, col='red')), theme ='white', yrange = range(buy.hold.equity, sma.cross.equity) )

The code I implemented in the Systematic Investor Toolbox is a bit longer, but follows the same logic. It provides extra functionality: ability to handle multiple securities, weights or shares backtesting, and customized reporting. Following is a sample code to implement the above strategies using the backtesting library in the Systematic Investor Toolbox:

# Load Systematic Investor Toolbox (SIT) setInternet2(TRUE) con = gzcon(url('https://github.com/systematicinvestor/SIT/raw/master/sit.gz', 'rb')) source(con) close(con) #***************************************************************** # Load historical data #****************************************************************** load.packages('quantmod') tickers = spl('SPY') data <- new.env() getSymbols(tickers, src = 'yahoo', from = '1970-01-01', env = data, auto.assign = T) bt.prep(data, align='keep.all', dates='1970::2011') #***************************************************************** # Code Strategies #****************************************************************** prices = data$prices # Buy & Hold data$weight[] = 1 buy.hold = bt.run(data) # MA Cross sma = bt.apply(data, function(x) { SMA(Cl(x), 200) } ) data$weight[] = NA data$weight[] = iif(prices >= sma, 1, 0) sma.cross = bt.run(data, trade.summary=T) #***************************************************************** # Create Report #****************************************************************** plotbt.custom.report(sma.cross, buy.hold)

The **bt.prep** function merges and aligns all symbols in the data environment. The **bt.apply** function applies user given function to each symbol in the data environment. The **bt.run** computes the equity curve of strategy specified by **data$weight** matrix. The **data$weight** matrix holds weights (signals) to open/close positions. The **plotbt.custom.report** function creates the customized report, which can be fined tuned by the user. Here is a sample output:

> buy.hold = bt.run(data) Performance summary : CAGR Best Worst 7.2 14.5 -9.9 > sma.cross = bt.run(data, trade.summary=T) Performance summary : CAGR Best Worst 6.3 5.8 -7.2

The visual performance summary:

The statistical performance summary:

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

## Asset Allocation Process Summary

I want to review the series of posts I wrote about Asset Allocation and Portfolio Construction and show how all of them fit into portfolio management framework.

**The first step of the Asset Allocation process** is to create the Input Assumptions: Expected Return, Risk, and Covariance. This is more art than science because we are trying to forecast future join realization for all asset classes. There are a number of approaches to create input assumptions, for example:

- Historical – estimate historical return, risk, covariance and assume that history will repeat itself.
- Ibbotson’s Building Blocks – estimate expected returns based on the risk premium. Please read Input Methodologies article by Morningstar for a detailed summary.
- The Black-Litterman model – estimate expected return using reverse optimization from current asset class market capitalizations.
- Probability Weighted Input Assumptions

The robust estimation of covariance matrix is usually preferred. For example, the Covariance Shrinkage Estimator is nicely explained in Honey, I Shrunk the Sample Covariance matrix by Olivier Ledoit and Michael Wolf (2003).

Introduction of new asset classes with short historical information is problematic when using historical input assumptions. For example, Treasury Inflation-Protected Securities (TIPS) were introduced by the U.S. Treasury Department in 1997. This is an attractive asset class that helps fight inflation. To incorporate TIPS, I suggest following methods outlined in Analyzing investments whose histories differ in length by R. Stambaugh (1997).

**The next step of the Asset Allocation process** to create efficient frontier and select target portfolio. I recommend looking at different risk measures in addition to the traditional standard deviation of the portfolio’s return. For example, Maximum Loss, Mean-Absolute Deviation, and Expected shortfall (CVaR) and Conditional Drawdown at Risk (CDaR) risk measures. To select a target portfolio look at the portfolios on the efficient frontier and select one that satisfies both your quantitative and qualitative requirements. For example, a quantitative requirement can be a low historic drawdown, and a qualitative requirement can be a sensible weights. For example, if model suggest 13.2343% allocation to Fixed Income, round it down to 13%.

I also recommend looking at your target portfolio in reference to the geometric efficient frontier to make sure your are properly compensated for the risk of your target portfolio. If you have a view on the possible future economic or market scenarios, please stress test your target portfolio to see how it will behave during these scenarios. For example read A scenarios approach to asset allocation article.

Sometimes, we want to combine short-term tactical models with long-term strategic target portfolio. I think the best way to introduce tactical information into the strategic asset mix is to use Black-Litterman model. Please read my post The Black-Litterman model for a numerical example.

**The next step of the Asset Allocation process** is to implement the target portfolio. If you follow a fund of funds approach and implement the target asset mix using external managers, please perform a style analysis to determine the style mix of each manager and visually study if manager’s style was consistent over time. We want to invest into the managers that follow their investment mandate, so we can correctly map them into our target asset portfolio.

We can use the information from style analysis to create managers input assumptions. Let’s combine alpha and covariance of tracking error from the style analysis with asset input assumptions to determine managers input assumptions.

Managers Input Assumptions:

Note, we simply add up mean and covariance because Managers Tracking Error and Assets Returns are independent by construction.

Next we can create managers efficient frontier, such that all portfolios on this frontier will have target asset allocation, as implied from each manager’s style analysis.

**The last step of the Asset Allocation process** is to decide how and when to rebalance: update the portfolio to the target mix. You can potentially rebalance daily, but it is very costly. A good alternative is to rebalance every time period, i.e. quarterly, annually, or set boundaries, i.e. if asset class weight is more than 3% from it’s target then rebalance.

In Conclusion, **the Asset Allocation process** consists of four decision steps:

- create Input Assumptions
- create Efficient Frontier
- implement Target Portfolio
- create Rebalancing Plan

All these steps include some quantitative and qualitative iterations. I highly recommend experimenting as much as possible before committing your hard earned savings to an asset allocation portfolio.

## Style Analysis

During the final stage of asset allocation process we have to decide how to implement our desired allocation. In many cases we will allocate capital to the mutual fund managers who will invest money according to their fund’s mandate. Usually there is no perfect relationship between asset classes and fund managers. To determine the true style of a manager one can examine its historical holdings or perform a Style Analysis. Style Analysis is a procedure that tries to attribute funds performance to the performance of asset classes by running the constrained linear regression. For a detailed review of Style Analysis I recommend following articles:

I want to examine to the style of the Fidelity Worldwide Fund (FWWFX). First, let’s get the historical fund and asset class prices from Yahoo Fiance:

# load Systematic Investor Toolbox setInternet2(TRUE) source(gzcon(url('https://github.com/systematicinvestor/SIT/raw/master/sit.gz', 'rb'))) #-------------------------------------------------------------------------- # Get Historical Data #-------------------------------------------------------------------------- load.packages('quantmod') # load historical prices from Yahoo Finance symbols = spl('FWWFX,EWA,EWC,EWQ,EWG,EWJ,EWU,SPY') symbol.names = spl('Fund,Australia,Canada,France,Germany,Japan,UK,USA') getSymbols(symbols, from = '1980-01-01', auto.assign = TRUE) # align dates for all symbols & convert to frequency hist.prices = merge(FWWFX,EWA,EWC,EWQ,EWG,EWJ,EWU,SPY) period.ends = endpoints(hist.prices, 'months') hist.prices = Ad(hist.prices)[period.ends, ] index(hist.prices) = as.Date(paste('1/', format(index(hist.prices), '%m/%Y'), sep=''), '%d/%m/%Y') colnames(hist.prices) = symbol.names # remove any missing data hist.prices = na.omit(hist.prices['1990::2010']) # compute simple returns hist.returns = na.omit( ROC(hist.prices, type = 'discrete') ) #load 3-Month Treasury Bill from FRED TB3M = quantmod::getSymbols('TB3MS', src='FRED', auto.assign = FALSE) TB3M = processTBill(TB3M, timetomaturity = 1/4) index(TB3M) = as.Date(paste('1/', format(index(TB3M), '%m/%Y'), sep=''), '%d/%m/%Y') TB3M = ROC(Ad(TB3M), type = 'discrete') colnames(TB3M) = 'Cash' # add Cash to the asset classes hist.returns = na.omit( merge(hist.returns, TB3M) )

To determine the Fidelity Worldwide Fund style, I will run a regression of fund returns on the country asset classes over a rolling 36 months window. First, let’s run the regression naively without any constraints:

#-------------------------------------------------------------------------- # Style Regression over 36 Month window, unconstrained #-------------------------------------------------------------------------- # setup ndates = nrow(hist.returns) n = ncol(hist.returns)-1 window.len = 36 style.weights = hist.returns[, -1] style.weights[] = NA style.r.squared = hist.returns[, 1] style.r.squared[] = NA # main loop for( i in window.len:ndates ) { window.index = (i - window.len + 1) : i fit = lm.constraint( hist.returns[window.index, -1], hist.returns[window.index, 1] ) style.weights[i,] = fit$coefficients style.r.squared[i,] = fit$r.squared } # plot aa.style.summary.plot('Style UnConstrained', style.weights, style.r.squared, window.len)

The allocations jump up and down in no consistent fashion. The regression also suggests that fund uses leverage (i.e. Cash -171%) which is not the case. To fix these problems, I will introduce following constraints:

- All style weights are between 0% and 100%.
- The sum of style weights is equal up to 100%.

#-------------------------------------------------------------------------- # Style Regression over Window, constrained #-------------------------------------------------------------------------- # setup load.packages('quadprog') style.weights[] = NA style.r.squared[] = NA # Setup constraints # 0 <= x.i <= 1 constraints = new.constraints(n, lb = 0, ub = 1) # SUM x.i = 1 constraints = add.constraints(rep(1, n), 1, type = '=', constraints) # main loop for( i in window.len:ndates ) { window.index = (i - window.len + 1) : i fit = lm.constraint( hist.returns[window.index, -1], hist.returns[window.index, 1], constraints ) style.weights[i,] = fit$coefficients style.r.squared[i,] = fit$r.squared } # plot aa.style.summary.plot('Style Constrained', style.weights, style.r.squared, window.len)

After introducing the constraints, the allocations are more stable, but the historical allocation to USA (highlighted with yellow) varies from 0% in 2000 to 60% in 2006. This is very suspicious, and the only way to check if this is true, is to look at the fund memorandum and historical holdings. For now, I will assume that the asset class allocations can vary around the current fund’s allocations. To get the current fund’s allocations, I will examine its current holdings at:

I imposed additional lower and upper bounds constrains:

#-------------------------------------------------------------------------- # Style Regression over Window, constrained + limits on allocation #-------------------------------------------------------------------------- # setup style.weights[] = NA style.r.squared[] = NA # Setup constraints temp = rep(0, n) names(temp) = colnames(hist.returns)[-1] lb = temp ub = temp ub[] = 1 lb['Australia'] = 0 ub['Australia'] = 5 lb['Canada'] = 0 ub['Canada'] = 5 lb['France'] = 0 ub['France'] = 15 lb['Germany'] = 0 ub['Germany'] = 15 lb['Japan'] = 0 ub['Japan'] = 15 lb['UK'] = 0 ub['UK'] = 25 lb['USA'] = 30 ub['USA'] = 100 lb['Cash'] = 2 ub['Cash'] = 15 # 0 <= x.i <= 1 constraints = new.constraints(n, lb = lb/100, ub = ub/100) # SUM x.i = 1 constraints = add.constraints(rep(1, n), 1, type = '=', constraints) # main loop for( i in window.len:ndates ) { window.index = (i - window.len + 1) : i fit = lm.constraint( hist.returns[window.index, -1], hist.returns[window.index, 1], constraints ) style.weights[i,] = fit$coefficients style.r.squared[i,] = fit$r.squared } # plot aa.style.summary.plot('Style Constrained+Limits', style.weights, style.r.squared, window.len)

The last style allocation looks more probable. If historical fund’s holdings were readily available we could have examined them to refine the upper and lower boundaries. The last step is to analyze fund’s actual returns vs returns implied by its style matrix.

#-------------------------------------------------------------------------- # Look at Manager's Tracking Error #-------------------------------------------------------------------------- manager.returns = hist.returns[, 1] manager.returns = manager.returns[window.len:ndates,] implied.returns = as.xts( rowSums(style.weights * hist.returns[, -1]), index(hist.returns)) implied.returns = implied.returns[window.len:ndates,] tracking.error = manager.returns - implied.returns alpha = 12*mean(tracking.error) covar.alpha = 12* cov(tracking.error) # plot layout(1:2) plota(cumprod(1+manager.returns), type='l') plota.lines(cumprod(1+implied.returns), col='red') plota.legend('Fund,Style', 'black,red') par(mar = c(4,4,2,1)) hist(100*tracking.error, xlab='Monthly Tracking Error', main= paste('Annualized Alpha =', round(100*alpha,1), 'Std Dev =', round(100*sqrt(covar.alpha),1)) )

The Fidelity Worldwide Fund outperformed its proxy, implied from the style matrix, consistently over the last decade. The fund’s alpha is 2.9% and standard deviation of alpha is 3.9%. So if you want to invest into Worldwide Fund, the Fidelity Worldwide Fund is not a bad choice.

To view the complete source code for this example, please have a look at the aa.style.test() function in aa.test.r at github.

## Periodic Table of Investment Returns

To get a better sense of historical data, I like to examine a Periodic Table of Investment Returns. For an example of a Periodic Table, have a look at the Single Country Index Returns Periodic Table for 2001-2010 published by iShares.

I can easily create a similar table with the following R code, using the historical data from the Black-Litterman Model post.

# load Systematic Investor Toolbox setInternet2(TRUE) source(gzcon(url('https://github.com/systematicinvestor/SIT/raw/master/sit.gz', 'rb'))) #-------------------------------------------------------------------------- # Get Historical Data #-------------------------------------------------------------------------- # Country's IA are based on monthly data ia = aa.test.create.ia.country() hist.returns = ia$hist.returns # convert returns to prices hist.prices = cumprod(1 + hist.returns) # extract annual prices period.ends = endpoints(hist.prices, 'years') hist.prices = hist.prices[period.ends, ] # compute simple returns hist.returns = na.omit( ROC(hist.prices, type = 'discrete') ) hist.returns = hist.returns['2000::2010'] #-------------------------------------------------------------------------- # Create Periodic table #-------------------------------------------------------------------------- # create temp matrix with data you want to plot temp = t(coredata(hist.returns)) colnames(temp) = format(index(hist.returns), '%Y') rownames(temp) = 1:ia$n rownames(temp)[1] = ' Best ' rownames(temp)[ia$n] = ' Worst ' # highlight each column col = plota.colors(ia$n) highlight = apply(temp,2, function(x) col[order(x, decreasing = T)] ) # sort each column temp[] = apply(temp,2, sort, decreasing = T) # format data as percentages temp[] = plota.format(100 * temp, 0, '', '%') # plot temp and legend plot.table(temp, highlight = highlight) plota.legend(ia$symbols,col,cex=1.5)

The Canadian and Australian markets outperformed US and Japanese markets in most years.

Here is a slightly different version of Periodic table:

#-------------------------------------------------------------------------- # Create Periodic table, another version #-------------------------------------------------------------------------- # create temp matrix with data you want to plot temp = t(coredata(hist.returns)) colnames(temp) = format(index(hist.returns), '%Y') # format data as percentages temp[] = plota.format(100 * temp, 0, '', '%') # highlight each column separately highlight = apply(temp,2, function(x) plot.table.helper.color(t(x)) ) # plot temp with colorbar plot.table(temp, highlight = highlight, colorbar = TRUE)

To view the complete source code for this example, please have a look at the aa.periodic.table.test() function in aa.test.r at github.