robRiskBudget: Simple and Robust Risk Budgeting with Expected Shortfall
In chindhanai/GSoC2017: Advancing factorAnalytics

Description Usage Arguments Details Value Author(s) References Examples

This function implements the Philips and Liu method to compute an optimal set of risk budgets. It takes into account both the volatility and the tail risk of strategies to create a portfolio with a targeted level of volatility but with a lower level of tail risk than achieved by a mean-variance risk budget. One of the option it provides is the option to average all off diagonal entries in the correlation matrix, and with this option in use, it works particularly well with weakly correlated strategies, as one often finds in multi-strategy hedge funds and absolute return portfolios.

robRiskBudget(returns = NULL, rf = 0, ER = NULL, IR = NULL, TE = NULL,
  corMat = NULL, ES = NULL, ESMethod = c("modified", "gaussian",
  "historical"), corMatMethod = c("auto", "mcd", "pairwiseQC", "pairwiseGK"),
  targetVol = 0.02, shrink = FALSE, avgCor = FALSE, p = 0.95,
  lower = 0, upper = 1, K = 100, maxit = 50, tol = 1e-05)

`returns`	A matrix with a time series of returns for each asset / strategy
`rf`	A vector with the risk free rate in each time period; could also be the returns of a common benchmark
`ER`	A vector of exogeneously derived prospective expected returns. Either IR or ER must be specified.
`IR`	A vector of exogeneously derived prospective information ratios. Either IR or ER must be specified.
`TE`	A vector of exogneously derived prospective volatilites (tracking errors). If it is not specified, it will be estimated from the time series of asset / strategy returns.
`corMat`	Exogneously derived correlation matrix. If it is not specified, it will be estimated from the time series of asset / strategy returns.
`ES`	The user's speculated expected shortfall. If it is not specified, it will be estimated from the time series of asset / strategy returns using one of 3 user-selectable methods.
`ESMethod`	The method used to compute ES (the methods are available in PerformanceAnalytics)
`corMatMethod`	the method used to estimate the robust correlation matrix, (the methods are available in library robust, and the default is "auto")
`targetVol`	The target volatility
`shrink`	Logical value that determines whether or not we want to shrink the expected returns toward their grand mean Uses James-Stein shrinkage, but is applicable only when expected returns are estimated by averaging historical returns,
`avgCor`	Logical value that determines if we want to set each off-diagonal element in the correlation matrix to the average of all its off-diagonal elements
`p`	User-specified confidence level for computing ES
`lower`	A numeric or vector of lower bounds \vec{σ}^L of risk budgets. Default is 0.
`upper`	A numeric or vector of upper bounds \vec{σ}^U of risk budgets. Default is 1.
`K`	A tuning factor for the iterative algorithm. Default is 100
`maxit`	A number of maximum iterations. Default is 50.
`tol`	An accuracy of the estimation with respect to the targeted volatility. Default is 10^-5

In the absence of any constraints, mean-variance risk budgets are given in closed form in terms of the Information Ratio IR and the correlation matrix C. In general, it is not obvious to allocate Expected Shortfall between strategies (or securities) in a way that achieves a target level of Expected Shortfall for the portfolio. This algorithm finds a pragmatic middle way to include tail risk in optimization - it starts by allocating risk using volatility as the measure of risk, but then uses Expected Shortfall to modify its allocations in such a way that the Expected Shortfall of the overall portfolio is reduced.

This simple closed form solution, with the inclusion of tail risk and with a stabilized correlation matrix, works surprisingly well in practice - it does not often result in negative solutions, and obviates the need for a long-only constraint - we just round up to 0 on the few occasions when a small negative risk budget appears. However, in the general case, if we want to bound the risk budgets between upper bound and lower bound, we either have to solve a full mean-variance optimization (and ignore tail risk) or create a simulation based historical optimization that includes it. Instead, we approximate the solution using an iterative scheme that clamps each risk budget between its applicable bounds, and uses a simple heuristic to increment or decrement all risk budgets in a way that allows the process to convergence in a few (usually two) iterations

robRiskBudget returns a list containing the following objects:

`initialRiskBudget`	The vector of unconstrained risk budgets
`finalRiskBudget`	The vector of final risk budgets for each asset
`iterativeRiskBudget`	The matrix of risk budgets in each iteration columnwise
`targetVol`	The target volatility for the portfolio
`avgCor`	The average of all off-diagonal correlations
`ER`	The average returns (shrunk if called for) or the user supplied expected returns
`TE`	The estimated tracking errors or the user supplied tracking errors
`ES`	The vector of estimated ESs or the user supplied ESs
`IR`	The shrunk average IRs or the user supplied IRs
`modIR`	The vector of modified IRs

Thomas Philips, Chindhanai Uthaisaad

Thomas Philips and Michael Liu. "Simple and Robust Risk Budgeting with Expected Shortfall", The Journal of Portfolio Management, Fall 2011, pp. 1-13.

data(RussellData)
RussellData = data
rf = RussellData[, 16]
robRiskData = RussellData[, 1:15]

riskBudget = robRiskBudget(robRiskData, rf = rf, shrink = TRUE, avgCor = TRUE,
ESMethod = "historical", corMatMethod = "mcd")
robRiskBudget(robRiskData, shrink = TRUE, corMatMethod = "pairwiseQC", avgCor = TRUE)
robRiskBudget(robRiskData, shrink = TRUE, corMatMethod = "mcd", avgCor = TRUE, upper = 0.0123)