Description Usage Arguments Details Value Author(s) References Examples

View source: R/robRiskBudget.R

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.

1 2 3 4 5 | ```
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 IRs toward their grand mean. using James-Stein shrinkage. |

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

`upper` |
A numeric or vector of upper bounds |

`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.

1 2 3 4 5 6 7 8 | ```
data("RussellData")
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)
``` |

Embedding an R snippet on your website

Add the following code to your website.

For more information on customizing the embed code, read Embedding Snippets.