Portfolio Optimization

pacman::p_load(tidyverse,tidyquant,PortfolioAnalytics,quantmod,PerformanceAnalytics,zoo,
               plotly,timekit,ggthemes,timetk)

Portfolio optimization is the process of selecting proportions of various assets to include in a portfolio, in such a way as to make the portfolio better than any other according to some criterion. The criterion will combine, directly or indirectly, considerations of the expected value of the portfolio’s rate of return as well as of the return’s dispersion and possibly other measures of financial risk. The objective of porrtfolio optimization is to maximize a measure of gain per unit measure of risk and minimize a measure of risk.

Modern portfolio theory was introduced by Harry Markowitz in 1952. It assumes that in general, an investor wants to maximize a portfolio’s expected return contingent on any given amount of risk, with risk measured by the standard deviation of the portfolio’s rate of return. For portfolios that meet this criterion, known as efficient portfolios, achieving a higher expected return requires taking on more risk, so investors are faced with a trade-off between risk and expected return. This risk-expected return relationship of efficient portfolios is graphically represented by a curve known as the efficient frontier. All efficient portfolios, each represented by a point on the efficient frontier, are well-diversified. For the specific formulas for efficient portfolios,[3] see Portfolio separation in mean-variance analysis. While ignoring higher moments can lead to significant over-investment in risky securities, especially when volatility is high[4], the development of portfolios for non-Gaussian economies is mathematically challenging.

Some of the best performing stocks year to date(November,2017) include Dynavax Tech(DVAX). Most of the best performing stocks were all from the Biotech space. Dynavax Tech (NASDAQ:DVAX) ranks first with a YTD gain of 444%. Straight Path (NYSEMKT:STRP) ranks second at +432.79%. Sangamo Therapeutics (NASDAQ:SGMO), Calithera Biosciences (NASDAQ:CALA), and Pieris Pharma (NASDAQ:PIRS) round out the top five. Eight of the top nine are Biotech stocks, and then Weight Watchers (NYSE:WTW) ranks tenth with a gain of 280%.

# Get data of the stock
Symbols=c("DVAX","STRP","SGMO","CALA","PIRS","KITE")
#Adjusted_price <- merge.zoo(SWX[,6], SPY[,6], ICUI[,6], MSFT[,6])
stock_prices  <- tq_get(Symbols, get = "stock.prices", from = " 2016-01-01")
stock_prices=stock_prices%>%select(symbol,date,adjusted)%>%rename(Stock=symbol,Price=adjusted) 
stock_prices%>%head()

#remove duplicated rows
stock_prices=stock_prices[!duplicated(stock_prices), ]
#Alternatively
#stock_prices[unique(stock_prices), ]
stock_prices2=stock_prices%>%spread(Stock,Price)
stock_prices2%>%head()

Alternatively

Use quantmod periodReturn to Convert daily Prices to daily Returns.

# Get stock pairs
stock_prices2 <- Symbols %>%
    tq_get(get  = "stock.prices",
           from = "2016-01-01",
           to   = today()) %>%
    group_by(symbol) 
stock_prices2%>%head()

stock_returns <- stock_prices2 %>%
    tq_transmute(select     = adjusted,
                 mutate_fun = periodReturn,
                 period     = "daily",
                 type       = "arithmetic",
                 col_rename = "returns") %>%
    spread(key = symbol, value = returns)
stock_returns%>%head()

stock_prices2 %>%
    tq_transmute(select     = adjusted,
                 mutate_fun = periodReturn,
                 period     = "monthly",
                 type       = "arithmetic",
                 col_rename = "returns") %>%
    ggplot(aes(x = date, y = returns, fill = symbol)) +
    geom_bar(stat = "identity", width = 30) +
    geom_hline(yintercept = 0, color = palette_light()[[1]]) +
    scale_y_continuous(labels = scales::percent) +
    labs(title = " Monthly Returns",
         subtitle = "",
         y = "Monthly Returns", x = "") + 
    facet_wrap(~ symbol, ncol = 2,scales = "free") +
    theme_tq() + 
    scale_fill_tq()

stock_prices_daily <- stock_prices2 %>%
    group_by(symbol)
stock_prices_daily %>%
    ggplot(aes(x = date, y = adjusted, color = symbol)) +
    geom_line(size = 1) +
    labs(title = "Daily Stock Prices",
         x = "", y = "Adjusted Prices", color = "") +
    facet_wrap(~ symbol, ncol = 2, scales = "free") +
    scale_y_continuous(labels = scales::dollar) +
    theme_tq() + 
    scale_color_tq()

stock_prices2 %>%
    tq_transmute(select     = adjusted,
                 mutate_fun = periodReturn,
                 period     = "monthly",
                 type       = "arithmetic",
                 col_rename = "returns")%>%
    ggplot(aes(x = date, y = returns, fill = symbol)) +
    geom_line(aes(color=symbol)) +
    geom_hline(yintercept = 0, color = palette_light()[[1]]) +
    scale_y_continuous(labels = scales::percent) +
    labs(title = " Monthly Returns",
         subtitle = "",
         y = "Monthly Returns", x = "") + 
    facet_wrap(~ symbol, ncol = 2,scales = "free") +
    theme_tq() + 
    scale_fill_tq()

stock_prices2 %>%
    tq_transmute(select     = adjusted,
                 mutate_fun = periodReturn,
                 period     = "monthly",
                 type       = "arithmetic",
                 col_rename = "returns")%>%
    ggplot(aes(x = date, y = returns, fill = symbol)) +
    geom_smooth(aes(color=symbol),method = 'loess' , formula = y ~ x) +
    geom_hline(yintercept = 0, color = palette_light()[[1]]) +
    scale_y_continuous(labels = scales::percent) +
    labs(title = " Monthly Returns",
         subtitle = "",
         y = "Monthly Returns", x = "") + 
    facet_wrap(~ symbol, ncol = 2,scales = "free") +
    theme_tq() + 
    scale_fill_tq()

stock_prices2 %>%
    tq_transmute(select     = adjusted,
                 mutate_fun = periodReturn,
                 period     = "monthly",
                 type       = "arithmetic",
                 col_rename = "returns")%>%
    ggplot(aes(x = date, y = returns, fill = symbol))+geom_density(stat = "identity") +
  theme_bw()

stock_prices2 %>%
    tq_transmute(select     = adjusted,
                 mutate_fun = periodReturn,
                 period     = "quarterly",
                 type       = "arithmetic",
                 col_rename = "returns")%>%
    ggplot(aes(x = date, y = returns, fill = symbol))+geom_density(stat = "identity",alpha=0.6) +
  labs(title = " Monthly Returns",
         subtitle = "",
         y = "Monthly Returns", x = "") + 
    facet_wrap(~ symbol, ncol = 2,scales = "free") +
    theme_tq() + 
    scale_fill_tq()

library(ggthemes)
#AAPL <- tq_get("AAPL")
# SMA
#AAPL %>%
stockd=tq_get(Symbols, get = "stock.prices", from = " 2016-01-01")
stockd%>%ggplot(aes(x = date, y = adjusted)) +
geom_line() + # Plot stock price
geom_bbands(aes(high = high, low = low, close = close), ma_fun = SMA, n = 100,show.legend=TRUE) +
ggthemes::theme_hc() +
  scale_colour_hc()+facet_wrap(~  symbol, ncol = 2,scales = "free") 

#coord_x_date(xlim = c(today() - years(1), today()), ylim = c(15, 30))

Convert stock returns to time series object.

stock_returns=stock_returns%>%tk_xts()
#stock_returns%>%tk_zoo(),tk_ts(),tk_xts()
stock_returns%>%head()

                  CALA          DVAX         KITE        PIRS         SGMO         STRP
2016-01-04  0.00000000  0.0000000000  0.000000000  0.00000000  0.000000000  0.000000000
2016-01-05  0.04704301  0.0004319654  0.006298498 -0.02620087 -0.004469274 -0.051810638
2016-01-06 -0.09627728 -0.0854922280 -0.083132722 -0.04484305 -0.077441077 -0.033489953
2016-01-07 -0.08948864  0.4022663362 -0.043759845 -0.06103286 -0.069343066 -0.077203704
2016-01-08 -0.06708268 -0.0979797947 -0.008786363  0.00500000 -0.031372549 -0.009222661
2016-01-11 -0.06521739 -0.0656961528 -0.035826462 -0.04477612 -0.133603239 -0.059840426

# Save mean return vector and sample covariance matrix
returns.portfolio<-na.omit(stock_returns)
meanReturns <- colMeans(returns.portfolio)
covMat <- cov(returns.portfolio)

The optimal portfolio in your setting is independent of the initial weights.

p <- portfolio.spec(assets = colnames(returns.portfolio))
p

**************************************************
PortfolioAnalytics Portfolio Specification 
**************************************************

Call:
portfolio.spec(assets = colnames(returns.portfolio))

Number of assets: 6 
Asset Names
[1] "CALA" "DVAX" "KITE" "PIRS" "SGMO" "STRP"

Markowitz Optimization involves minimizing the risk(variance) of returns and maximizing returns.

p <- add.objective(portfolio = p, type = "risk", name = "var")
p <- add.constraint(portfolio = p, type = "full_investment")

The full_investment part is equivalent to setting a constraint on the sum of the portfolio weights such that they always sum-up to 1. This is a case where the investor cares about the risk of the portfolio. Your optimization therefore returns the portfolio weights which attain the lowest possible portfolio variance. This is the global minimum variance portfolio. If the efficient portfolio is of interest, then an additional constraint, namely the minimal expected return can be added.

p <- add.constraint(portfolio=p, type = "return",     return_target= 0.0035)

The return_target=0.0035 can be replaced with any number,I have chosen the overall mean of returns.You can also chose something such as 0.15/250 (There are 250 work days in a year) to reflect that you have daily data and in this case you would like to have a portfolio which makes 15% per year in expectation.

The input R should be the time-series of returns you have. You also specify the optimizing function apropriate for the objective function ,here in this case ROI.

#Optimize
optimize.portfolio(R=returns.portfolio, portfolio = p, 
          optimize_method = "ROI", trace = TRUE)

***********************************
PortfolioAnalytics Optimization
***********************************

Call:
optimize.portfolio(R = returns.portfolio, portfolio = p, optimize_method = "ROI", 
    trace = TRUE)

Optimal Weights:
  CALA   DVAX   KITE   PIRS   SGMO   STRP 
0.1188 0.0675 0.3648 0.2493 0.0711 0.1286 

Objective Measure:
 StdDev 
0.02919 

creating a portfolio specification. This can be done by using portfolio.spec()

# Start with the names of the assets
port <- portfolio.spec(assets = colnames(stock_returns))

Now for some constraints. Let’s use the following:

Box constraints Leverage (weight sum)

# Box
port <- add.constraint(port, type = "box", min = 0.05, max = 0.8)
# Leverage
port <- add.constraint(portfolio = port, type = "full_investment")

The random solver is used to create a set of feasible portfolios that satisfy all the constraints specified above.

# Generate random portfolios
rportfolios <- random_portfolios(port, permutations = 5000, rp_method = "sample")

Add some objectives and optimize. For simplicity’s sake let’s do some mean-variance optimization.

# Get minimum variance portfolio
minvar.port <- add.objective(port, type = "risk", name = "var")
# Optimize
minvar.opt <- optimize.portfolio(stock_returns, minvar.port, optimize_method = "random", 
                                 rp = rportfolios)
# Generate maximum return portfolio
maxret.port <- add.objective(port, type = "return", name = "mean")
# Optimize
maxret.opt <- optimize.portfolio(stock_returns, maxret.port, optimize_method = "random", 
                                 rp = rportfolios)
# Generate vector of returns
minret <- 0.06/100
maxret <- maxret.opt$weights %*% meanReturns
vec <- seq(minret, maxret, length.out = 50)

We can build the efficient frontier at this stage after specifying the minimum variance as well as the maximum return portfolios. We add a weight concentration objective to prevent highly concentrated portfolios. random_portfolios() function ignores any diversification constraints.

# Get a character vector of the fund names
fund.names <- colnames(stock_returns)

Creating the Portfolio Object

The portfolio object is instantiated with the portfolio.spec function. The main argument to portfolio.spec is assets, this is a required argument. The assets argument can be a scalar value for the number of assets, a character vector of fund names, or a named vector of initial weights. If initial weights are not specied, an equal weight portfolio will be assumed. The pspec object is an S3 object of class “portfolio”. When rst created, the portfolio object has an element named assets with the initial weights, an element named category_labels, an element named weight_seq with sequence of weights if specied, an empty constraints list and an empty objectives list.

# Specify a portfolio object by passing a character vector for the
# assets argument.
pspec <- portfolio.spec(assets=fund.names)
print.default(pspec)

$assets
     CALA      DVAX      KITE      PIRS      SGMO      STRP 
0.1666667 0.1666667 0.1666667 0.1666667 0.1666667 0.1666667 

$category_labels
NULL

$weight_seq
NULL

$constraints
list()

$objectives
list()

$call
portfolio.spec(assets = fund.names)

attr(,"class")
[1] "portfolio.spec" "portfolio"     

Adding Constraints to the Portfolio Object

Adding constraints to the portfolio object is done with add.constraint. The add.constraint function is the main interface for adding and/or updating constraints to the portfolio object. This function allows the user to specify the portfolio to add the constraints to, the type of constraints, arguments for the constraint, and whether or not to enable the constraint (enabled=TRUE is the default). If updating an existing constraint, the indexnum argument can be specied.

Sum of Weights Constraint

The weight_sum constraint species the constraint on the sum of the weights. Aliases for the weight_sum constraint type include weight and leverage. Here we add a constraint that the weights must sum to 1, or the full investment constraint.

# Add the full investment constraint that specifies the weights must sum to 1.
pspec <- add.constraint(portfolio=pspec,
type="weight_sum",
min_sum=1,
max_sum=1)

There are two special cases for the leverage constraint: 1. The sum of the weights equal 1, i.e. the full investment constraint. The full investment con- straint can be specied with type=“full_investment”. This automatically sets min_sum=1 and max_sum=1. 2. The sum of the weights equal 0, i.e. the dollar neutral or active constraint. This constraint can be specified with type=“dollar_neutral” or type=“active”.

# The full investment constraint can also be specified with type="full_investment"
# pspec <- add.constraint(portfolio=pspec, type="full_investment")
# Another common constraint is that portfolio weights sum to 0.
# This can be specified any of the following ways
# pspec <- add.constraint(portfolio=pspec, type="weight_sum",
# min_sum=0,
# max_sum=0)
# pspec <- add.constraint(portfolio=pspec, type="dollar_neutral")
# pspec <- add.constraint(portfolio=pspec, type="active")

Box Constraint

Box constraints allows the user to specify upper and lower bounds on the weights of the assets. Here we add box constraints for the asset weights so that the minimum weight of any asset must be greater than or equal to 0.05 and the maximum weight of any asset must be less than or equal to 0.4. The values for min and max can be passed in as scalars or vectors. If min and max are scalars, the values for min and max will be replicated as vectors to the length of assets. If min and max are not specied, a minimum weight of 0 and maximum weight of 1 are assumed. Note that min and max can be specied as vectors with dierent weights for linear inequality constraints.

# Add box constraints
pspec <- add.constraint(portfolio=pspec,
 type="box",
 min=0.05,
 max=0.4)
# min and max can also be specified per asset
# pspec <- add.constraint(portfolio=pspec,
# type="box",
# min=c(0.05, 0, 0.08, 0.1),
# max=c(0.4, 0.3, 0.7, 0.55))
# A special case of box constraints is long only where min=0 and max=1
# The default action is long only if min and max are not specified
# pspec <- add.constraint(portfolio=pspec, type="box")
# pspec <- add.constraint(portfolio=pspec, type="long_only")

Group Constraint

Group constraints allow the user to specify the the sum of weights by group. Group constraints are currently supported by the ROI, DEoptim, and random portfolio solvers. The following code groups the assets such that the rst 3 assets are grouped together labeled GroupA and the fourth asset is in its own group labeled GroupB. The group_min argument species that the sum of the weights in GroupA must be greater than or equal to 0.1 and the sum of the weights in GroupB must be greater than or equal to 0.15. The group_max argument species that the sum of the weights in GroupA must be less than or equal to 0.85 and the sum of the weights in GroupB must be less than or equal to 0.55.The group_labels argument is optional and is useful if groups is not a named list for labeling groups in terms of market capitalization, sector, etc.

# Add group constraints
pspec <- add.constraint(portfolio=pspec, type="group",
groups=list(groupA=c(1, 2, 3),
grouB=4),
group_min=c(0.1, 0.15),
group_max=c(0.85, 0.55))

Position Limit Constraint

The position limit constraint allows the user to specify limits on the number of assets with non- zero, long, or short positions. The ROI solver interfaces to the Rglpk package (i.e. using the glpk plugin) for solving maximizing return and ETL/ES/cVaR objectives. The Rglpk package supports integer programming and thus supports position limit constraints for the max_pos argument. The quadprog package does not support integer programming, and therefore max_pos is not supported for the ROI solver using the quadprog plugin. Note that max_pos_long and max_pos_short are not supported for either ROI solver. All position limit constraints are fully supported for DEoptim and random solvers.

# Add position limit constraint such that we have a maximum number of three assets with non-zero > 
pspec <- add.constraint(portfolio=pspec, type="position_limit", max_pos=3)
# Can also specify maximum number of long positions and short positions
# pspec <- add.constraint(portfolio=pspec, type="position_limit", max_pos_long=3, max_pos_short=3)

Diversification Constraint

The diversication constraint allows the user to target diversication. Diversication is dened as diversification = PN i=1 w2 i for N assets. The diversication constraint is implemented for the global optimizers by applying a penalty if the diversication value is more than 5% away from div_target. Note that diversication as a constraint is not supported for the ROI solvers, it is only supported for the global numeric solvers.

pspec <- add.constraint(portfolio=pspec, type="diversification", div_target=0.7)

Turnover Constraint

A target turnover can be specified as a constraint. The turnover is calculated from a set of initial weights. The initial weights can be specied, by default they are the initial weights in the portfolio object. The turnover constraint is implemented for the global optimizers by applying a penalty if the turnover value is more than 5% away from turnover_target. Note that the turnover constraint is not currently supported for quadratic utility and minimum variance problems using the ROI solver.

pspec <- add.constraint(portfolio=pspec, type="turnover", turnover_target=0.2)

Target Return Constraint

The target return constraint allows the user to specify a target mean return.

pspec <- add.constraint(portfolio=pspec, type="return", return_target=0.007)

Factor Exposure Constraint

The factor exposure constraint allows the user to set upper and lower bounds on exposures to risk factors. The exposures can be passed in as a vector or matrix. Here we specify a vector for B with arbitrary values, e.g. betas of the assets, with a market risk exposure range of 0.6 to 0.9.

pspec <- add.constraint(portfolio=pspec, type="factor_exposure",
B=c(0.08, 0.37, 0.79, 1.43,0.5,0.4),
lower=0.6, upper=0.9)

Transaction Cost Constraint

The transaction cost constraint allows the user to specify proportional transaction costs. Propor- tional transaction cost constraints can be implemented for quadratic utility and minimum variance 7 problems using the ROI solver. Transaction costs are supported as a penalty for the global numeric solvers. Here we add the transaction cost contraint with the proportional transaction cost value of 1%.

pspec <- add.constraint(portfolio=pspec, type="transaction_cost", ptc=0.01)

The print method for the portfolio object shows a concise view of the portfolio and the con- straints that have been added.

print(pspec)

**************************************************
PortfolioAnalytics Portfolio Specification 
**************************************************

Call:
portfolio.spec(assets = fund.names)

Number of assets: 6 
Asset Names
[1] "CALA" "DVAX" "KITE" "PIRS" "SGMO" "STRP"

Constraints
Enabled constraint types
        - weight_sum 
        - box 
        - group 
        - position_limit 
        - diversification 
        - turnover 
        - return 
        - factor_exposure 
        - transaction_cost 

The summary method gives a more detailed view of the constraints.

summary(pspec)

$assets
     CALA      DVAX      KITE      PIRS      SGMO      STRP 
0.1666667 0.1666667 0.1666667 0.1666667 0.1666667 0.1666667 

$enabled_constraints
$enabled_constraints[[1]]
An object containing 6 nonlinear constraints.

$enabled_constraints[[2]]
An object containing 5 nonlinear constraints.

$enabled_constraints[[3]]
An object containing 7 nonlinear constraints.

$enabled_constraints[[4]]
An object containing 4 nonlinear constraints.

$enabled_constraints[[5]]
An object containing 4 nonlinear constraints.

$enabled_constraints[[6]]
An object containing 4 nonlinear constraints.

$enabled_constraints[[7]]
An object containing 4 nonlinear constraints.

$enabled_constraints[[8]]
An object containing 6 nonlinear constraints.

$enabled_constraints[[9]]
An object containing 4 nonlinear constraints.


$disabled_constraints
list()

$enabled_objectives
list()

$disabled_objectives
list()

attr(,"class")
[1] "summary.portfolio"

This demonstrates adding constraints to the portfolio object. As an alternative to adding constraints directly to the portfolio object, constraints can be specified as separate objects.

Specifying Constraints as Separate Objects

The following examples will demonstrate how to specify constraints as separate objects for all constraints types.

# full investment constraint
weight_constr <- weight_sum_constraint(min_sum=1, max_sum=1)
# box constraint
box_constr <- box_constraint(assets=pspec$assets, min=0, max=1)
# group constraint
group_constr<-group_constraint(assets=pspec$assets,
groups=list(c(1, 2, 3),
4),
group_min=c(0.1, 0.15),
group_max=c(0.85, 0.55),
group_labels=c("GroupA", "GroupB"))
# position limit constraint
poslimit_constr <- position_limit_constraint(assets=pspec$assets, max_pos=3)
# diversification constraint
div_constr <- diversification_constraint(div_target=0.7)
# turnover constraint
to_constr <- turnover_constraint(turnover_target=0.2)
# target return constraint
ret_constr <- return_constraint(return_target=0.007)
# factor exposure constraint
exp_constr <- factor_exposure_constraint(assets=pspec$assets,
B=c(0.08, 0.37, 0.79, 1.43,0.5,0.4),
 lower=0.6, upper=0.9)

Adding Objectives

Objectives can be added to the portfolio object with add.objective. The add.objective function is the main function for adding and/or updating business objectives to the portfolio object. This function allows the user to specify the portfolio to add the objectives to, the type (currently ‘return’, ‘risk’, ‘risk budget’, or ‘weight concentration’), name of the objective function, arguments to the objective function, and whether or not to enable the objective. If updating an existing constraint, the indexnum argument can be specified.

Portfolio Risk Objective

The portfolio risk objective allows the user to specify a risk function to minimize Here we add a risk objective to minimize portfolio expected tail loss with a condence level of 0.95. Other default arguments to the function can be passed in as a named list to arguments. Note that the name of the function must correspond to a function in R. Many functions are available in the PerformanceAnalytics package or a user dened function.

pspec <- add.objective(portfolio=pspec,
 type='risk',
 name='ETL',
 arguments=list(p=0.95))

Portfolio Return Objective

The return objective allows the user to specify a return function to maximize. Here we add a return objective to maximize the portfolio mean return.

pspec <- add.objective(portfolio=pspec,

Portfolio Risk Budget Objective

The portfolio risk objective allows the user to specify constraints to minimize component con- tribution (i.e. equal risk contribution) or specify upper and lower bounds on percentage risk contribution. Here we specify that no asset can contribute more than 30% to total portfolio risk. See the risk budget optimization vignette for more detailed examples of portfolio optimizations with risk budgets.

pspec <- add.objective(portfolio=pspec, type="risk_budget", name="ETL",
arguments=list(p=0.95), max_prisk=0.3)
# for an equal risk contribution portfolio, set min_concentration=TRUE
# pspec <- add.objective(portfolio=pspec, type="risk_budget", name="ETL",
# arguments=list(p=0.95), min_concentration=TRUE)

Portfolio Weight Concentration Objective

The weight concentration objective allows the user to specify an objective to minimize concentra- tion as measured by the Herndahl-Hirschman Index. For otpimization problems solved with the global numeric optimizers, the portfolio HHI value is penalized using conc_aversion value as the multiplier. For quadratic utility problems with weight concentration as an objective using the ROI solver, this is implemented as a penalty to the objective function. The objective function is implemented as follows:

Where μ is the estimated mean asset returns,  is the risk aversion parameter, lambdahhi is the concentration aversion parameter, HHI is the portfolio HHI,  is the estimated covariance matrix of asset returns and w is the set of weights. Here we add a weight concentration objective for the overall portfolio HHI.

pspec <- add.objective(portfolio=pspec, type="weight_concentration",
 name="HHI", conc_aversion=0.1)

The weight concentration aversion parameter by groups can also be specied. Here we add a weight concentration objective specifying groups and concentration aversion parameters by group.

pspec <- add.objective(portfolio=pspec, type="weight_concentration",
 name="HHI",
conc_aversion=c(0.03, 0.06),
conc_groups=list(c(1, 2),
c(3, 4)))

The print method for the portfolio object will now show all the constraints and objectives that have been added.

print(pspec)

**************************************************
PortfolioAnalytics Portfolio Specification 
**************************************************

Call:
portfolio.spec(assets = fund.names)

Number of assets: 6 
Asset Names
[1] "CALA" "DVAX" "KITE" "PIRS" "SGMO" "STRP"

Constraints
Enabled constraint types
        - weight_sum 
        - box 
        - group 
        - position_limit 
        - diversification 
        - turnover 
        - return 
        - factor_exposure 
        - transaction_cost 

Objectives:
Enabled objective names
        - ETL 
        - mean 
        - ETL 
        - HHI 
        - HHI 

The summary function gives a more detailed view.

 summary(pspec)

$assets
     CALA      DVAX      KITE      PIRS      SGMO      STRP 
0.1666667 0.1666667 0.1666667 0.1666667 0.1666667 0.1666667 

$enabled_constraints
$enabled_constraints[[1]]
An object containing 6 nonlinear constraints.

$enabled_constraints[[2]]
An object containing 5 nonlinear constraints.

$enabled_constraints[[3]]
An object containing 7 nonlinear constraints.

$enabled_constraints[[4]]
An object containing 4 nonlinear constraints.

$enabled_constraints[[5]]
An object containing 4 nonlinear constraints.

$enabled_constraints[[6]]
An object containing 4 nonlinear constraints.

$enabled_constraints[[7]]
An object containing 4 nonlinear constraints.

$enabled_constraints[[8]]
An object containing 6 nonlinear constraints.

$enabled_constraints[[9]]
An object containing 4 nonlinear constraints.


$disabled_constraints
list()

$enabled_objectives
$enabled_objectives[[1]]
$name
[1] "ETL"

$target
NULL

$arguments
$arguments$p
[1] 0.95

$arguments$portfolio_method
[1] "single"


$enabled
[1] TRUE

$multiplier
[1] 1

$call
add.objective(portfolio = pspec, type = "risk", name = "ETL", 
    arguments = list(p = 0.95))

attr(,"class")
[1] "portfolio_risk_objective" "objective"               

$enabled_objectives[[2]]
$name
[1] "mean"

$target
NULL

$arguments
list()

$enabled
[1] TRUE

$multiplier
[1] -1

$call
add.objective(portfolio = pspec, type = "return", name = "mean")

attr(,"class")
[1] "return_objective" "objective"       

$enabled_objectives[[3]]
$name
[1] "ETL"

$target
NULL

$arguments
$arguments$p
[1] 0.95

$arguments$portfolio_method
[1] "component"


$enabled
[1] TRUE

$multiplier
[1] 1

$max_prisk
CALA DVAX KITE PIRS SGMO STRP 
 0.3  0.3  0.3  0.3  0.3  0.3 

$min_concentration
[1] FALSE

$min_difference
[1] FALSE

$call
add.objective(portfolio = pspec, type = "risk_budget", name = "ETL", 
    arguments = list(p = 0.95), max_prisk = 0.3)

attr(,"class")
[1] "risk_budget_objective" "objective"            

$enabled_objectives[[4]]
$name
[1] "HHI"

$target
NULL

$arguments
list()

$enabled
[1] TRUE

$multiplier
[1] 1

$conc_aversion
[1] 0.1

$call
add.objective(portfolio = pspec, type = "weight_concentration", 
    name = "HHI", conc_aversion = 0.1)

attr(,"class")
[1] "weight_concentration_objective" "objective"                     

$enabled_objectives[[5]]
$name
[1] "HHI"

$target
NULL

$arguments
$arguments$groups
$arguments$groups[[1]]
[1] 1 2

$arguments$groups[[2]]
[1] 3 4



$enabled
[1] TRUE

$multiplier
[1] 1

$conc_aversion
[1] 0.03 0.06

$conc_groups
$conc_groups[[1]]
[1] 1 2

$conc_groups[[2]]
[1] 3 4


$call
add.objective(portfolio = pspec, type = "weight_concentration", 
    name = "HHI", conc_aversion = c(0.03, 0.06), conc_groups = list(c(1, 
        2), c(3, 4)))

attr(,"class")
[1] "weight_concentration_objective" "objective"                     


$disabled_objectives
list()

attr(,"class")
[1] "summary.portfolio"

Solvers

The PortfolioAnalytics package currently supports random portfolios, DEoptim, pso, GenSA, and ROI as back ends. Note that some of the QP/LP problems are solved directly with Rglpk and quad- prog. The solver can be specied with the optimize_method argument in optimize.portfolio and optimize.portfolio.rebalancing.

DEoptim

PortfolioAnalytics uses the DEoptim function from the R package DEoptim. Dierential evolution is a stochastic global optimization algorithm. See ?DEoptim and the references contained therein for more information. See also Large scale portfolio optimization with DEoptim. 5.2 Random Portfolios PortfolioAnalytics has three methods to generate random portfolios. 1. The ‘sample’ method to generate random portfolios is based on an idea by Pat Burns. This is the most exible method, but also the slowest, and can generate portfolios to satisfy leverage, box, group, and position limit constraints. 2. The ‘simplex’ method to generate random portfolios is based on a paper by W. T. Shaw. The simplex method is useful to generate random portfolios with the full investment constraint, where the sum of the weights is equal to 1, and min box constraints. Values for min_sum and max_sum of the leverage constraint will be ignored, the sum of weights will equal 1. All other constraints such as the box constraint max, group and position limit constraints will be handled by elimination. If the constraints are very restrictive, this may result in very few feasible portfolios remaining. Another key point to note is that the solution may not be along the vertexes depending on the objective. For example, a risk budget objective will likely place the portfolio somewhere on the interior. 3. The ‘grid’ method to generate random portfolios is based on the gridSearch function in package NMOF. The grid search method only satises the min and max box constraints. The min_sum and max_sum leverage constraint will likely be violated and the weights in the random portfolios should be normalized. Normalization may cause the box constraints to be violated and will be penalized in constrained_objective. The following plots illustrate the various methods to generate random portfolios.

pso

PortfolioAnalytics uses the psoptim function from the R package pso. Particle swarm optimization is a heuristic optimization algorithm. See ?psoptim and the references contained therein for more information.

GenSA

PortfolioAnalytics uses the GenSA function from the R package GenSA. Generalized simmulated annealing is generic probabilistic heuristic optimization algorithm. See ?GenSA and the references contained therein for more information.

ROI

The ROI package serves as an interface to the Rglpk package and the quadprog package to solve linear and quadratic programming problems. The interface to the ROI package solves a limited type of convex optimization problems: 1. Maxmimize portfolio return subject leverage, box, group, position limit, target mean return, and/or factor exposure constraints on weights. 2. Minimize portfolio variance subject to leverage, box, group, turnover, and/or factor exposure constraints (otherwise known as global minimum variance portfolio). 3. Minimize portfolio variance subject to leverage, box, group, and/or factor exposure con- straints and a desired portfolio return. 4. Maximize quadratic utility subject to leverage, box, group, target mean return, turnover, and/or factor exposure constraints and risk aversion parameter. (The risk aversion parameter is passed into optimize.portfolio as an added argument to the portfolio object).

5. Minimize ETL subject to leverage, box, group, position limit, target mean return, and/or factor exposure constraints and target portfolio return. 6 Optimization The previous sections demonstrated how to specify a portfolio object, add constraints, add objec- tives, and the solvers available. This section will demonstrate run the optimizations via optimize.portfolio. Only a small number of examples will be shown here, see the demos for several more examples.

Initial Portfolio Object

pacman::p_load("DEoptim","ROI","ROI.plugin.glpk","ROI.plugin.quadprog")
#library(DEoptim)
#library(ROI)
#require(ROI.plugin.glpk)
#require(ROI.plugin.quadprog)
funds <- colnames(stock_returns)
# Create an initial portfolio object with leverage and box constraints
init <- portfolio.spec(assets=funds)
init <- add.constraint(portfolio=init, type="leverage",
min_sum=0.99, max_sum=1.01)
init <- add.constraint(portfolio=init, type="box", min=0.05, max=0.65)
#init <- add.constraint(portfolio = init, type = "full_investment")

Maximize mean return with ROI

Add an objective to maximize mean return.

maxret <- add.objective(portfolio=init, type="return", name="mean")

Run the optimization.

opt_maxret <- optimize.portfolio(R=stock_returns, portfolio=maxret,
optimize_method="ROI",
trace=TRUE)
print(opt_maxret)

***********************************
PortfolioAnalytics Optimization
***********************************

Call:
optimize.portfolio(R = stock_returns, portfolio = maxret, optimize_method = "ROI", 
    trace = TRUE)

Optimal Weights:
CALA DVAX KITE PIRS SGMO STRP 
0.05 0.05 0.05 0.16 0.05 0.65 

Objective Measure:
    mean 
0.005823 

Minimize variance with ROI

Add an objective to minimize portfolio variance.

minvar <- add.objective(portfolio=init, type="risk", name="var")

Run the optimization. Note that although ‘var’ is the risk metric, ‘StdDev’ is returned as an objective measure.

opt_minvar <- optimize.portfolio(R=stock_returns, portfolio=minvar,
optimize_method="ROI", trace=TRUE)
print(opt_minvar)

***********************************
PortfolioAnalytics Optimization
***********************************

Call:
optimize.portfolio(R = stock_returns, portfolio = minvar, optimize_method = "ROI", 
    trace = TRUE)

Optimal Weights:
  CALA   DVAX   KITE   PIRS   SGMO   STRP 
0.0947 0.0845 0.3554 0.2806 0.0937 0.0810 

Objective Measure:
 StdDev 
0.02839 

Maximize quadratic utility with ROI

Add mean and var objectives for quadratic utility. Note that the risk aversion parameter for quadratic utility is specifed in the objective as shown below.

qu <- add.objective(portfolio=init, type="return", name="mean")
qu <- add.objective(portfolio=qu, type="risk", name="var", risk_aversion=0.25)

Run the optimization.

opt_qu <- optimize.portfolio(R=stock_returns, portfolio=qu,
optimize_method="ROI",
trace=TRUE)
print(opt_qu)

***********************************
PortfolioAnalytics Optimization
***********************************

Call:
optimize.portfolio(R = stock_returns, portfolio = qu, optimize_method = "ROI", 
    trace = TRUE)

Optimal Weights:
  CALA   DVAX   KITE   PIRS   SGMO   STRP 
0.0500 0.0500 0.1281 0.0819 0.0500 0.6500 

Objective Measure:
    mean 
0.005822 


 StdDev 
0.05839