Previously

The idea of implied alpha was introduced in “Implied alpha — almost wordless”.

In a comment to that post Jeff noticed that the optimal portfolio given for the example is ever so close to the minimum variance portfolio.  That is because there is a problem with the example (though it sort of doesn’t matter).

It uses a risk aversion of 2.5 (which would be a risk aversion of 5 in some people’s minds).  That is a moderate risk aversion.  Except that the variance and the expected returns are scaled to percent.  This means that the risk aversion should have been divided by 100, but it wasn’t.  I should have given a risk aversion of 0.025.

Connection

This made me wonder about how implied alpha and minimum variance are connected.

Implied alpha tells you what you must have been thinking about the returns of the assets when you formed the portfolio (where “must” is subject to a list of assumptions and caveats).

A reason to do minimum variance is because you don’t think you know about returns.  Yet implied alpha goes against your wishes and tells you that you do have a view on returns — whether you like it or not.

What do the implied alphas of a minimum variance portfolio look like?

Computation

If w is the vector of weights for the portfolio and V is the variance matrix, then the implied alphas are:

cVw

for whatever positive value of c you like.

The assumption is that you are maximizing mean-variance utility, which is:

α’w – cw‘Vw

where c is the risk aversion (but some people have a division by 2).

In calculus you can find a maximum by taking the derivative of a function and setting it to zero.  If w were a scalar rather than a vector, we would have:

aw – cVw²

Taking the derivative with respect to w and setting it to zero gives us:

a – 2cVw = 0

It turns out that the analogous calculation works for vectors.  (That there is a 2 in this formula is sort of why some people divide by 2 in the utility formula.)

Sensibility

How can we make sense of Vw?

First, note that if all the correlations are positive (not so far-fetched) and the portfolio is long-only, then all numbers are positive and hence all the implied alphas will be positive.

Consider the implied alpha for the first asset.  It is the weight of the first asset times the variance of the first asset plus the sum of the covariances of the first asset with all the other assets times the respective weights.

Implied alphas that are relatively big are those that have large weights on large variances and covariances.  That is, they are the riskiest positions.  If a position is risky, we must think that it has good return potential or we’d scale it back.

Minimum variance

The following computations use 250 daily returns ending on 2013 May 17 on 441 large cap US equities to estimate the variance.

Let’s examine how much a change of variance estimate makes.  We’ll use a statistical factor model and Ledoit-Wolf shrinkage as competing estimates of the variance matrix.

We get the minimum variance portfolio (where the only constraint is that the portfolio is long-only) for each variance matrix.  The factor model optimization selected 36 assets to have positive weight while the Ledoit-Wolf optimization has 27 assets.  There are 24 assets in common, and the turnover (buys plus sells) to get from one to the other is 50%.

We then compute the implied alpha for each of these portfolios with each variance matrix.  Boxplots of these implied alphas are in Figure 1.

Figure 1: Boxplots of implied alpha vectors when optimizing and calculating implied alpha using a factor model (fm) or Ledoit-Wolf shrinkage (lw). The implied alphas computed with the same variance as was used in the optimization are all essentially equal.  That makes some sense — one way of getting the minimum variance portfolio is to do a mean-variance optimization where all the expected returns are equal.  In Portfolio Probe terminology the risk fractions are all equal.

When we mix the variance matrices, then the implied alphas spread out.  But it isn’t clear how significant the spread is.  To get a sense of that, three weight vectors were randomly generated.  For each vector 30 random uniforms were generated, scaled to sum to 1, and then random assets from the universe were assigned.

Figure 2: Boxplots of implied alpha from factor model optimization and Ledoit-Wolf calculation (fm-lw) plus implied alphas from three random weight vectors. The answer seems to be that the spreads in Figure 1 are not entirely trivial.

But wait, there’s more.

Figure 1 only looks at the implied alphas for the assets that have positive weights.  We can also get implied alphas for assets that are not in the portfolio.  Figure 3 shows implied alphas (using the same variance as in the optimization) for assets that are in the portfolio (positive weight) and out of the portfolio (zero weight).

Figure 3: Implied alphas for minimum variance portfolios divided by assets in the portfolio and those out of the portfolio. It appears that the “rule” is that the implied alphas for the assets in the minimum variance portfolio are all equal and the implied alphas for assets outside the portfolio are all larger.  This makes sense in that assets that are risky (have high implied alpha) are excluded.  However, it seems to foil the idea that doing a mean-variance optimization with the implied alphas would lead us back to the portfolio.

Question

How does the minimum variance portfolio “know” how many of the assets should be included?

Summary

Minimum variance portfolios have a strange but quite interesting set of implied alphas.

Epilogue

Did you ever have to finally decide?
And say yes to one and let the other one ride

from “Did you ever have to make up your mind?” by John Sebastian

Appendix R

Computations were in R.

create variance estimates

The variance estimates use functions in the BurStFin package:

require(BurStFin)
fm1305 <- factor.model.stat(diff(log(tail(
   univclose130518, 251))))
lw1305 <- var.shrink.eqcor(diff(log(tail(
   univclose130518, 251))), tol=1e-5)

create price vector

We want to use the most up-to-date prices — that is, the last row of the price object:

price1305 <- drop(tail(as.matrix(univclose130518), 1))
price1305 <- price1305[!is.na(price1305)]

In this case the object has class xts.  We need to coerce it to matrix otherwise we will end up with dates rather than tickers as the names.

There was also an asset with a missing value — we need to remove that.

do optimization

The optimization uses Portfolio Probe:

require(PortfolioProbe)

mvlo.fm <- trade.optimizer(price=price1305, 
   variance=fm1305, gross=1e6, long.only=TRUE, 
   utility="minimum variance")

compute implied alpha

A function to compute implied alphas given a trade optimization object is:

pp.impliedalpha.opt <- function(opt, variance, c=1, 
   prices, all.assets=FALSE)
{
  # placed in the public domain 2013 by Burns Statistics

  # testing status: untested

  if(all.assets) {
    weights <- valuation(opt, prices=prices, 
       all.assets=all.assets)$weight
  } else {
    weights <- valuation(opt)$weight
  }
  wnam <- names(weights)
  drop(variance[wnam, wnam] %*% weights) * c
}

This is used like:

mvlo.fmia <- pp.impliedalpha.opt(mvlo.fm, 
   fm1305, 1e5)
mvlo.fmiaaa <- pp.impliedalpha.opt(mvlo.fm, 
   fm1305, 1e5, prices=price1305, all.assets=TRUE)

generate random weight vectors

rw1 <- runif(30)
rw1 <- rw1 / sum(rw1)
names(rw1) <- sample(names(price1305), 30)

plot

Just the factor model part of Figure 3 (without spice) is:

boxplot(list("fm - in"=mvlo.fmia, 
   "fm - out"=mvlo.fmiaaa[!(names(mvlo.fmiaaa) 
      %in% names(mvlo.fmia))]))

Fine print

• The data are from Yahoo
• Almost all of the S&P 500 stocks are used (as implied by Wikipedia on 2013 January 5 — see the R commands to scrape the data)
• The initial post was “Replacing market indices”
• The R code is in marketportrait_funs.R — you are free to use these functions however you like

Previously

There have been posts on:

• “What the hell is a variance matrix?”
• factor models
• Ledoit-Wolf shrinkage

Question

Two of the several ways to produce an estimate of the variance matrix of asset returns is a statistical factor model and Ledoit-Wolf shrinkage.  Can we learn anything about what is happening when the two estimates give different answers for a portfolio?

We can manufacture such portfolios by generating random portfolios that satisfy some constraints including that the portfolio variances have some minimum difference.

Data

Daily returns during 2012 were used for 442 large cap US stocks.  The variance estimates were based on these returns.

The portfolios were generated as of the end of 2012.  All of the portfolios that were created had the constraints:

• long-only
• exactly 10 assets in the portfolio
• the minimum weight of assets in the portfolio is 0.5%

Many of the portfolios had additional constraints on variance.

All sets of random portfolios consist of 1000 portfolios.

Results

Figure 1 shows the distribution of the volatility for portfolios that obey only the constraints given above.

Figure 1: Distribution of volatility of random portfolios with 10 assets, are long-only and meet the minimum weight constraint. The volatility range of 14% to 15% was selected as an additional constraint.  Figure 2 shows the distribution of the difference in estimated portfolio variances for portfolios generated with the basic constraints plus the volatility range.

Figure 2: Distribution of variance differences for portfolios with Ledoit-Wolf volatility between 14% and 15%. 

We see that in this case the factor model is likely to give a smaller estimate of volatility than Ledoit-Wolf. Which one is more likely to have a larger value depends on the particular constraints.  The picture when the factor model is used to estimate volatility is very similar to Figure 2 — that is not always the case with other constraints.

The 10 and -10 on the x-axis is a difference of about 0.8% to 0.9% in volatility for the volatility range we are in.  That is the minimum difference that is imposed for the portfolios that have divergent volatility estimates.

Figure 3 shows the fraction of random portfolios with 14% to 15% Ledoit-Wolf volatility that each asset appears in versus the asset volatility.

Figure 3: Fraction of portfolios in which each asset appears versus the asset volatility for portfolios with 14% to 15% Ledoit-Wolf volatility.

We see that the higher volatility assets are less likely to appear.  This is because the restriction to a volatility of 14% to 15% is below average.  The selection effect is quite mild though.

Figures 4 and 5 compare the volatility estimates for the portfolios that have a difference of variances imposed.

Figure 4: Ledoit-Wolf volatility versus factor model volatility for portfolios with larger Ledoit-Wolf volatility.

Figure 5: Ledoit-Wolf volatility versus factor model volatility for portfolios with larger factor model volatility. In Figure 4 the full range of 14% to 15% volatility is represented with some of the portfolios having a substantially larger difference than the limit imposed.  There is a tendency for portfolios to have a larger volatility (but that is true without the difference constraint).

Figure 5 hints at the difficulty of imposing the difference in this direction.  Only the upper range of volatility is represented, almost all the portfolios are near 15% Ledoit-Wolf volatility, and the difference is never much larger than the minimum imposed.

Figures 6 and 7 show the occurrence of individual stocks in the portfolios with the variance differences imposed.

Figure 6: Fraction of portfolios in which each asset appears versus the asset volatility for portfolios with larger Ledoit-Wolf volatility.

Figure 7: Fraction of portfolios in which each asset appears versus the asset volatility for portfolios with larger factor model volatility. There is quite strong selection for particular assets — especially for the larger factor model case.

Below we look at the five most popular assets as shown in Figures 6 and 7 in terms of the diferences in the variance matrix estimates.

Big Ledoit-Wolf popular assets

Ledoit-Wolf variance (for percent returns):

        DF   BBY  NFLX  BIG  FDO
DF   10.20  1.73  0.21 0.85 0.52
BBY   1.73 11.37  2.58 1.47 0.57
NFLX  0.21  2.58 18.52 3.31 1.28
BIG   0.85  1.47  3.31 8.92 1.21
FDO   0.52  0.57  1.28 1.21 2.51

Factor model minus Ledoit-Wolf variance (for percent returns):

        DF   BBY  NFLX   BIG   FDO
DF   -0.04 -1.15  0.25 -0.74 -0.24
BBY  -1.15 -0.04 -1.09 -0.75 -0.21
NFLX  0.25 -1.09 -0.07 -2.12 -0.75
BIG  -0.74 -0.75 -2.12 -0.04 -0.80
FDO  -0.24 -0.21 -0.75 -0.80 -0.01

Ledoit-Wolf correlation:

       DF  BBY NFLX  BIG  FDO
DF   1.00 0.16 0.01 0.09 0.10
BBY  0.16 1.00 0.18 0.15 0.11
NFLX 0.01 0.18 1.00 0.26 0.19
BIG  0.09 0.15 0.26 1.00 0.26
FDO  0.10 0.11 0.19 0.26 1.00

Factor model minus Ledoit-Wolf correlation:

        DF   BBY  NFLX   BIG   FDO
DF    0.00 -0.11  0.02 -0.08 -0.05
BBY  -0.11  0.00 -0.07 -0.07 -0.04
NFLX  0.02 -0.07  0.00 -0.16 -0.11
BIG  -0.08 -0.07 -0.16  0.00 -0.17
FDO  -0.05 -0.04 -0.11 -0.17  0.00

Big factor model popular assets

Ledoit-Wolf variance (for percent returns):

       CA MOLX  EMN  AON  ADI
CA   2.05 0.82 0.54 0.30 0.72
MOLX 0.82 1.99 1.51 0.76 1.10
EMN  0.54 1.51 4.05 1.07 1.30
AON  0.30 0.76 1.07 1.08 0.66
ADI  0.72 1.10 1.30 0.66 1.50

Factor model minus Ledoit-Wolf variance (for percent returns):

        CA MOLX   EMN   AON  ADI
CA   -0.01 0.11  0.47  0.20 0.10
MOLX  0.11 0.11  0.21  0.07 0.15
EMN   0.47 0.21 -0.02 -0.03 0.13
AON   0.20 0.07 -0.03  0.00 0.02
ADI   0.10 0.15  0.13  0.02 0.09

Ledoit-Wolf correlation:

       CA MOLX  EMN  AON  ADI
CA   1.00 0.41 0.19 0.20 0.41
MOLX 0.41 1.00 0.53 0.52 0.64
EMN  0.19 0.53 1.00 0.51 0.53
AON  0.20 0.52 0.51 1.00 0.52
ADI  0.41 0.64 0.53 0.52 1.00

Factor model minus Ledoit-Wolf correlation:

       CA MOLX   EMN   AON  ADI
CA   0.00 0.04  0.16  0.14 0.05
MOLX 0.04 0.00  0.06  0.03 0.05
EMN  0.16 0.06  0.00 -0.01 0.04
AON  0.14 0.03 -0.01  0.00 0.00
ADI  0.05 0.05  0.04  0.00 0.00

Questions

Anyone see any significance in the assets that are selected for in the portfolios with big differences?

Summary

The differences in correlation estimates seem to be driving the differences in portfolio volatility estimates.  Given that there are almost 100,000 correlations, the correlation differences that have the largest impact don’t seem all that big.

Portfolios with 10 assets are more likely to have large discrepancies than larger portfolios.  Hence it seems unlikely that volatility estimates for real portfolios will differ much between the two methods.

Epilogue

Both of us say there are laws to obey
But frankly I don’t like your tone

from “Different Sides” by Leonard Cohen

Appendix R

Computations and plots were done in R.

variance estimation

The two variance estimates use functions from the BurStFin package.

require(BurStFin)

fm12 <- factor.model.stat(initret12)
lw12b <- var.shrink.eqcor(initret12, tol=1e-5)

As “Correlations and positive-definiteness” points out, the default value of the tol argument in the Ledoit-Wolf estimate is over zealous about making sure that there are no portfolios estimated to have very small variance.  (The default will be changed when the package is updated.)

generate wild portfolios

The generation and manipulation of the random portfolios depends on the Portfolio Probe package.  1000 portfolios with just the initial three constraints are generated with:

require(PortfolioProbe)

rp10wild <- random.portfolio(1000, priceEnd12, 
   port.size=c(10,10), gross=1e6, long.only=TRUE, 
   min.weight.thresh=.005)

There is an additional constraint in the command that the gross value needs to be close to $1 million.  While a specification of the amount of money in the portfolios is mandatory, it has no effect on our results (unless the amount is tiny).

The min.weight.thresh argument is new in Portfolio Probe version 1.06.

get volatility

The volatility estimate for each of the portfolios is produced with:

vol.rp10wild <- sqrt(unlist(randport.eval(rp10wild, 
   keep="var.values",
   additional.args=list(variance=lw12b))) * 252) * 100

This first produces a vector of the Ledoit-Wolf estimates of the variance of each portfolio, and then transforms that into volatility.

generate volatility restricted portfolios

We want to restrict volatility to the range of 14% to 15%.  However, the software thinks in terms of variance rather than volatility.  So we need to transform to the variance scale that we have.  We also need the bounds for the variance constraint to be a two-column matrix:

vcmat1 <- matrix(c(.14, .15)^2/252, 1, 2)

Now we use this matrix:

rp10vtest <- random.portfolio(1000, priceEnd12, 
   port.size=c(10,10), gross=1e6, long.only=TRUE, 
   min.weight.thresh=.005, variance=lw12b, 
   var.constraint=vcmat1)

see variance differences

Now we can see what the difference is between the two variance estimates for each of these portfolios:

vardif.rp10vtest <- unlist(randport.eval(rp10vtest, 
   keep="var.values",
   additional.args=list(variance=fm12-lw12b, 
      var.constraint=NULL)))

We change what it thnks the problem is by putting in a different value for the variance matrix and removing the variance constraint.

You may be wondering if the difference of variance matrices really gives us the portfolio variance differences.  The portfolio variance is the double sum over assets of the (i,j) position in the variance matrix times the i-th weight times the j-th weight.  So it is linear in the variance matrix values.

count assets in portfolios

The command to count how many times each asset appears in a portfolio is:

acount.rp10vtest <- table(sapply(rp10vtest, names))

generate variance difference portfolios

Now we know what variance differences are feasible.  We want to impose two different variance constraints:

• volatility is 14% to 15% (according to one of the variance matrices)
• the difference of variances is at least 1e-5

To do this we need to provide two variance matrices in the form of a three-dimensional array, where each slice of the third dimension is a variance matrix.  We also need a constraint on each of the variances.  So we need a 2 by 2 matrix: columns are minimum and maximum allowed, rows are for the different variances.

vcmat2 <- rbind(vcmat1, c(1e5, Inf))

The random portfolios are generated with:

rp10biglw <- random.portfolio(1000, priceEnd12, 
   port.size=c(10,10), gross=1e6, long.only=TRUE, 
   min.weight.thresh=.005, 
   variance=threeDarr(fm12, lw12b-fm12), 
   var.constraint=vcmat2)

The threeDarr function is in the BurStFin package and it stacks matrices into a three-dimensional array.

difficult constraints

Figure 2 shows that the variance difference where Ledoit-Wolf is bigger (what the command above is getting) is rare, but not exceedingly rare.  But we might think that the difference where the factor model is bigger could be impossible.  As Figure 5 shows, it isn’t impossible but barely.

When generating random portfolios, you want it to give up trying if it can’t find any within a reasonable amount of time — you don’t want to have to throw your computer away every time you ask it to do something impossible.  The default settings suggested that the factor-model-bigger problem was impossible.  Changing the settings so it worked harder on each try, and was less frustrated with failure allowed the generation to go ahead.

The time to generate random portfolios heavily depends on the constraints.  To get 1000 portfolios that satisfied the Ledoit-Wolf bigger constraint took 5 seconds.  To get the factor model bigger constraint it took just under 23 hours.

selected variances and correlations

To get the most selected names:

acnam.biglw <- rev(names(tail(sort(acount.rp10biglw),5)))

Variance matrix selection was:

round(lw12b[acnam.biglw, acnam.biglw] * 1e4, 2)

Correlation matrix selection was:

round(cov2cor(lw12b[acnam.biglw, acnam.biglw]), 2)

Fine print

• The data are from Yahoo
• Almost all of the S&P 500 stocks are used (as implied by Wikipedia on 2013 January 5 — see the R commands to scrape the data)
• The initial post was “Replacing market indices”
• The R code is in marketportrait_funs.R — you are free to use these functions however you like

Previously

An introduction to the difference between simple and log returns is:

• A tale of two returns

Issue

Suppose you are predicting the mean annual return of an asset for some number of years.  To simplify the discussion, let’s buy into the fantasy that the observed returns are a good (unbiased) estimate of future returns.  If you take the mean of the historical simple returns, you will be over-estimating the mean return — call this “Amean” (as in arithmetic mean).  Better is to take the mean of the log returns and then transform that mean into a simple return — call this “Gmean”.

The approximation of Gmean using only simple returns is Amean minus half the variance of the historical simple returns.

Perhaps others will disagree but I don’t think the issue is computational — if someone can compute a variance, they should just about be able to take a logarithm.  I think the issue is of how we think rather than how we compute.  It is easy to get optimistic.

“On the relationship between Arithmetic and Geometric Returns” explains where the approximation comes from, and discusses three more as well.

Pictures

We’ll investigate a world in which the true annual return each year is 5% and the volatility is 20%.

What varies is the distribution of returns and the length of the history available.

The other constant is that we always look at 1000 realizations of a simulation.

normal decade

Figures 1 through 3 show the simulations where the log returns have a normal distribution and we have a decade of data (that is, 10 annual returns).

Figure 1: Amean versus Gmean for a decade with the normal distribution.

Figure 2: Amean minus Gmean versus Gmean for a decade with the normal distribution. The bias in Amean relative to Gmean is always non-trivial in this case and often quite significant.

Figure 3: The approximation minus Gmean versus Gmean for a decade with the normal distribution. The approximation is pretty much unbiased, but it can be substantially far from Gmean.

Remember that the true answer in all cases is 5 — it is just that Gmean is pretty much our best guide if we don’t get to know the secrets of the universe.

t6 decade

Figures 4 through 6 show the simulations from a decade of data where the distribution of daily returns is the t with 6 degrees of freedom.

Figure 4: Amean versus Gmean for a decade with the t6 distribution.

Figure 5: Amean minus Gmean versus Gmean for a decade with the t6 distribution.

Figure 6: The approximation minus Gmean versus Gmean for a decade with the t6 distribution. There are some differences between the normal and t6 cases, but they are fairly subtle.  A more realistic change in return distribution would be to put in volatility clustering.  That probably would give significantly different results from the normal case.

normal century

Figures 7 through 9 show the simulations assuming a century of data and normally distributed returns.

Figure 7: Amean versus Gmean for a century with the normal distribution.

Figure 8: Amean minus Gmean versus Gmean for a century with the normal distribution.

Figure 9: The approximation minus Gmean versus Gmean for a century with the normal distribution. Even though the true mean return is 5% there are a few centuries out of 1000 that experienced a negative return.  Awesome.

normal millennium

Figures 10 through 12 show simulations assuming a thousand years of data and normally distributed returns.

Figure 10: Amean versus Gmean for a decade with the millennium distribution.

Figure 11: Amean minus Gmean versus Gmean for a millennium with the normal distribution.

Figure 12: The approximation minus Gmean versus Gmean for a millennium with the normal distribution.

Summary

Be careful when averaging returns.

We have no claim to know what’s right.  That is, we don’t have a chance in hell of knowing the true expected return of equities.

Epilogue

Oh my fair North Star
I have held to you dearly
I have asked you to steer me

from “Mercy of the Fallen” by Dar Williams

Appendix R

The simulations were performed in R.

simulation function

The function that produced the simulations was:

pp.simulret <- function(years, meanann, vol, 
   distribution="normal", trials=1000, ...)
{
  # simulate years of returns based on daily returns

  # placed in the public domain 2013 by Burns Statistics

  # testing status: untested

  dots <- list(...)
  if(length(dots)) {
    df <- dots$df
  }

  ans <- array(NA, c(trials, 4), list(NULL, 
            c("Amean", "Gmean", "Var", "approx")))
  for(i in 1:trials) {
    switch(distribution, 
           normal={
             logret <- rnorm(years * 252, meanann/25200,
                             vol/100/sqrt(252))
           },
           t={
             logret <- rt(years * 252, df=df) * 
               sqrt((df-2)/df) * vol/100/sqrt(252) +
               meanann/25200
           })
    logret
    annlret <- colSums(matrix(logret, nrow=252))
    annsret <- (exp(annlret) - 1)
    ans[i,-4] <- c(mean(annsret), mean(annlret), 
        var(annsret))
  }
  ans[,4] <- ans[,1] - ans[,3]/2
  ans[, -3] <- ans[,-3] * 100
  ans
}

It is used like:

sim.norm.decade20 <- pp.simulret(10, 5, 20, 
   dist="normal")

plot function

The function to do the plots was:

pp.simulretplot <- function(x, type, ...)
{
  # plots for simulated returns

  # placed in the public domain 2013 by Burns Statistics

  # testing status: untested
  switch(type,
         gam={
           plot(x[, "Gmean"], x[, "Amean"], 
              col="steelblue", xlab="Gmean", 
              ylab="Amean", ...)
           abline(0, 1, col="gold")
         },
         ram={
           plot(x[, "Gmean"], x[, "Amean"]-x[, "Gmean"],
              col="steelblue", xlab="Gmean", 
              ylab="Amean - Gmean", ...)
           abline(h=0, col="gold")
         },
         gap={
           plot(x[, "Gmean"], x[, "approx"], 
              col="steelblue", xlab="Gmean", 
              ylab="Approximation", ...)
           abline(0, 1, col="gold")
         },
         rap={
           plot(x[, "Gmean"], x[, "approx"]-x[, "Gmean"],
              col="steelblue", xlab="Gmean", 
              ylab="Approximation - Gmean", ...)
           abline(h=0, col="gold")
         })
}

Figures 1, 2 and 3 were produced with:

pp.simulretplot(sim.norm.decade20, 'gam')
pp.simulretplot(sim.norm.decade20, 'ram')
pp.simulretplot(sim.norm.decade20, 'rap')

Fine print

• The data are from Yahoo
• Almost all of the S&P 500 stocks are used (as implied by Wikipedia on 2013 January 5 — see the R commands to scrape the data)
• The initial post was “Replacing market indices”
• The R code is in marketportrait_funs.R — you are free to use these functions however you like

1. A practical introduction to garch modeling (posted in 2012)
2. A tale of two returns (posted in 2010)
3. Stock-picking opportunity and the ratio of variabilities
4. A pictorial history of US large cap correlation
5. The top 7 portfolio optimization problems (posted in 2012)
6. garch and the distribution of returns
7. Alternative equity indices and random portfolios
8. Predicted correlations and portfolio optimization
9. The distribution of financial returns made simple (posted in 2012)
10. Slouching towards simulating investment skill
11. The number 1 novice quant mistake (posted in 2011)

Most popular posts in 2013

As of 2013 April 30.

1. A practical introduction to garch modeling (posted in 2012)
2. A tale of two returns (posted in 2010)
3. The top 7 portfolio optimization problems (posted in 2012)
4. Predicted correlations and portfolio optimization
5. The mystery of volatility estimates from daily versus monthly returns (posted in 2011)
6. The number 1 novice quant mistake (posted in 2011)
7. The distribution of financial returns made simple (posted in 2012)
8. Simple tests of predicted returns
9. Market predictions for year 2013
10. A comparison of some heuristic optimization methods
11. Clustering and sector strength
12. The components garch model in the rugarch package
13. Variability of predicted portfolio volatility

See also

• Blog year 2012 in review
• Blog year 2011 in review
• Blog year 2010 in review

Previously

In “Simple tests of predicted returns” we saw that prediction quality need not look like what you would find in a textbook.  For example, there was a case where there was no predictive power on the low values, but good prediction for high values.

Data

443 large cap US equities are used.  The variance matrix is estimated using the daily returns during 2011 (via a Ledoit-Wolf shrinkage model).

Both long-only and long-short portfolios are created.  The constraints for the long-only portfolios are:

• no more than 60 names in the portfolio
• predicted volatility is no more than 20%

The constraints for the long-short portfolios are:

• dollar neutral (net value of zero)
• no more than 60 names in the portfolio
• predicted volatility is no more than 10%

Simulating

There are unlimited ways of simulating skill.  Here we take a brief look at two.

Wilma

Wilma gets the correlation right (or wrong) separately for the halves of the data above and below the median of the realized values.  Three cases were created:

• the correlation is 10% for both halves (blue)
• the correlation is zero for the low half and 10% for the high half (gold)
• the correlation is -10% for the low half and 10% for the high half (black)

The colors indicate how the cases appear in the figures.  Figures 1 and 2 show the distributions of random portfolios generated using the three predictions plus a set that uses no predictions (colored green).

The sets of random portfolios use the predictions by having an extra constraint that the predicted return must be at least 90% of the way to the maximum predicted return.  In practice a fund manager is constrained by turnover considerations from moving to the best portfolio — the random portfolios are imitating this.

Figure 1: Distributions of 2012 Q1 returns for long-only portfolios: no prediction (green), Wilma 10,10 (blue), 0,10 (gold), -10,10 (black).

Figure 2: Distributions of 2012 Q1 returns for dollar-neutral portfolios: no prediction (green), Wilma 10,10 (blue), 0,10 (gold), -10,10 (black). Let’s focus on the blue distribution in Figures 1 and 2.  This is using one specific vector of predictions.  The variability is due to using that one prediction differently.  Think of it as Wilma having lots of different portfolios and using this one prediction vector to rebalance each of them.

But different prediction vectors with the same correlations may be more or less effective.  In fact, they can have significantly different correlations over the whole universe, as Figure 3 shows.

Figure 3: Correlation between realized and Wilma predictions where both halves have correlation 10%, with the correlation of the prediction used (blue). The overall correlation is generally higher than 10% because the relationship is seen over a wider range.  But the overall correlation can be less than 10% as well by the lines having different slopes in the two halves.

Barney

Barney’s skill is different than Wilma’s.  Barney knows that a certain fraction of predictions and realized values match (or don’t match) in terms of being above or below their respective medians.  (This description is not quite accurate, and is probably hard to follow anyway — see the code in Appendix R  below for the real story.)

Again three predictions are used:

• 20% in each half are quaranteed to match (blue)
• 20% guaranteed to match in the high half (gold)
• 20% guaranteed not to match in the low half and 20% guaranteed to match in the high half (black)

Figures 4 and 5 show the returns of the random portfolios  using the same scheme of constraining the expected returns.

Figure 4: Distributions of 2012 Q1 returns for long-only portfolios: no prediction (green), Barney 20,20 (blue), 0,20 (gold), -20,20 (black).

Figure 5: Distributions of 2012 Q1 returns for dollar neutral portfolios: no prediction (green), Barney 20,20 (blue), 0,20 (gold), -20,20 (black). 

Figure 5 is a mess in the sense that the differences between the distributions are subtle.  This is probably realistic.  The scheme from here would be to try to condition out more noise so that the effect of the prediction quality is more visible.

Figure 4 is a mess in the sense that it violates our expectations.  The supposedly best prediction does worst, and the supposedly mediocre prediction does very well.  One possibility is that there is a bug in the computations.  That shouldn’t be entirely ruled out, but there is a reasonable explanation for what we are seeing.

Figures 6 and 7 show the two predictions in question versus the realized returns.

Figure 6: Realized returns versus Barney predictions with 20% guarantee on the top half.

Figure 7: Realized returns versus Barney predictions with 20% guarantee on both halves. Note in particular the highlighted points in Figures 6 and 7.  The most positive predictions are going to be the most important in long-only portfolios.  The center does not hold.  The 0-20 prediction has relatively good predictions in the tail, while the 20-20 has rather poor predictions in the tail.

Notice that a bound on position size is not one of the constraints.  The two most extreme points in Figures 6 and 7 are likely to be driving a lot of the returns.

Summary

Simulating investment skill is feasible and probably quite useful when done well.  Doing it well is unlikely to be done in an afternoon.

The textbook measures of the quality of prediction are going to be inadequate.

Be careful of the most extreme predictions.

Epilogue

Surely some revelation is at hand

from “The Second Coming” by W. B. Yeats

Joni Mitchell’s version.

Appendix R

The computations were done with R.

Wilma

The function to do the Wilma prediction:

pp.wilma <- function(realized, predicted=NULL, 
   cors=c(.1, .1), tol=.01)
{
  # simulate investment skill by adjusting correlation

  # Placed in the public domain 2013 by Burns Statistics

  # Testing status: untested

  if(length(predicted)) {
    if(length(predicted) != length(realized)) {
      stop("'realized' and 'predicted' need to be the same length")
    }
    if(length(intersect(names(realized), names(predicted)))) {
      stop("'realized' and 'predicted' need to for the same assets")
    }
    predicted <- predicted[names(realized)]
  } else {
    predicted <- realized
    predicted[] <- sample(predicted)
  }
  rmed <- median(realized)
  low <- realized <= rmed

  sfun.cor <- function(w, real, pred, targetCor) {
    cor(real, w * real + (1 - w) * pred) - targetCor
  }

  wlow <- uniroot(sfun.cor, c(-1,1), tol=tol, 
     real=realized[low], pred=predicted[low], 
     targetCor=cors[1])$root
  predicted[low] <- wlow * realized[low] + (1 - wlow) * 
     predicted[low]
  whi <- uniroot(sfun.cor, c(-1,1), tol=tol, 
     real=realized[!low], pred=predicted[!low], 
     targetCor=cors[2])$root
  predicted[!low] <- whi * realized[!low] + (1 - whi) * 
     predicted[!low]

  predicted
}

The three predictions were created (the rough beast is born) with:

pw12q1.1010 <- pp.wilma(real12q1, cors=c(.1, .1))
pw12q1.0010 <- pp.wilma(real12q1, cors=c(0, .1))
pw12q1.n1010 <- pp.wilma(real12q1, cors=c(-.1, .1))

Barney

The function to do the Barney prediction:

pp.barney <- function(realized, predicted=NULL, 
   fraction=c(.1, .1))
{
  # simulate investment skill by adjusting signs of predictions

  # Placed in the public domain 2013 by Burns Statistics

  # Testing status: untested

  if(length(predicted)) {
    if(length(predicted) != length(realized)) {
      stop("'realized' and 'predicted' need to be the same length")
    }
    if(length(intersect(names(realized), names(predicted)))) {
      stop("'realized' and 'predicted' need to for the same assets")
    }
    predicted <- predicted[names(realized)]
  } else {
    predicted <- realized
    predicted[] <- sample(predicted)
  }

  srmed <- sign(realized - median(realized))
  predicted <- predicted - median(predicted)
  lowi <- which(predicted < 0)
  hii <- which(predicted >= 0)
  changelow <- sample(lowi, round(abs(fraction[1]) * 
     length(lowi)),replace=FALSE)
  if(fraction[1] < 0) {
    predicted[changelow] <- -srmed[changelow] * 
      abs(predicted[changelow])
  } else if(fraction[1] > 0) {
    predicted[changelow] <- srmed[changelow] * 
      abs(predicted[changelow])
  }
  changehi <- sample(hii, round(abs(fraction[2]) * 
     length(hii)), replace=FALSE)
  if(fraction[2] < 0) {
    predicted[changehi] <- -srmed[changehi] * 
      abs(predicted[changehi])
  } else if(fraction[2] > 0) {
    predicted[changehi] <- srmed[changehi] * 
      abs(predicted[changehi])
  }

  predicted
}

The three predictions were created with:

pb12q1.2020 <- pp.barney(real12q1, fraction=c(.2, .2))
pb12q1.0020 <- pp.barney(real12q1, fraction=c(0, .2))
pb12q1.n2020 <- pp.barney(real12q1, fraction=c(-.2, .2))

estimate variance matrix

The variance estimate uses 250 daily returns in 2011:

require(BurStFin)
lwvar11 <- var.shrink.eqcor(initret[seq(to=2014,
   length=250), ])

allowable volatility

The rest of the computations depend on Portfolio Probe:

require(PortfolioProbe)

The first thing to do is to get the minimum variance portfolio with the constraints that we are using so that we will know how much volatility we need to allow for:

op.minvar.lo <- trade.optimizer(prices=initclose[2015,],
   variance=lwvar11, gross=1e7, long.only=TRUE, 
   port.size=60)

The predicted volatility of the minimum variance portfolio is:

> sqrt(252 * op.minvar.lo$var.value) 
[1] 0.133833

We can comfortably have 20% volatility in our portfolios.

allowable predicted return

The next step is to see what the best predicted expected return is given the constraints by doing another optimization:

op.pw1010.lo <- trade.optimizer(prices=initclose[2015,],
   variance=lwvar11, expected.return=pw12q1.1010, 
   gross=1e7, long.only=TRUE, port.size=60,
   var.constraint=.2^2/252)

The expected return of the optimal portfolio is in the alpha.value component of the resulting object, but we don’t really need to look at it in this case.  Optimizations were also done with the other prediction vectors.

We also do this for a dollar neutral portfolio where we limit volatility to 10%:

op.pw1010.ls <- trade.optimizer(prices=initclose[2015,], 
   variance=lwvar11, expected.return=pw12q1.1010, 
   gross=1e7, net=0, port.size=60,
   var.constraint=.1^2/252)

generate random portfolios

We start by generating random portfolios (10,000 in each go) with the same constraints as the optimizations:

rpvclo <- random.portfolio(number.rand=1e4, 
   prices=initclose[2015,], variance=lwvar11,
   gross=1e7, long.only=TRUE, port.size=60,
   var.constraint=.2^2/252)
rpvcls <- random.portfolio(number.rand=1e4, 
   prices=initclose[2015,], variance=lwvar11,
   gross=1e7, net=0, port.size=60,
   var.constraint=.1^2/252)

Now we generate random portfolios with these constraints plus a constraint on the expected return:

rp.pw1010.lo <- random.portfolio(number.rand=1e4, 
   prices=initclose[2015,], variance=lwvar11,
   expected.return=pw12q1.1010, 
   gross=1e7, long.only=TRUE, port.size=60,
   var.constraint=.2^2/252,
   alpha.constraint=unname(mean(pw12q1.1010) + .9 *
      (op.pw1010.lo$alpha.value - mean(pw12q1.1010))))

The alpha constraint is simpler in the dollar neutral case because we know that we expect zero when no prediction is used.

get returns

The only other operation of note is getting the returns of the random portfolios over the quarter of interest.  Really only the density of the returns is used:

density(100 * valuation(rp.pw1010.lo, 
   prices=initclose[c(2015, 2078),], returns='simple'))

This uses the valuation function from Portfolio Probe where the prices at the start and finish of the quarter are given and simple returns are asked for.

Fine print

• The data are from Yahoo
• Almost all of the S&P 500 stocks are used (as implied by Wikipedia on 2013 January 5 — see the R commands to scrape the data)
• The initial post was “Replacing market indices”
• The R code is in marketportrait_funs.R — you are free to use these functions however you like

Previously

There are posts on garch — in particular:

• A practical introduction to garch modeling
• The components garch model in the rugarch package
• garch and long tails

There has also been discussion of the distribution of returns, including a satire called “The distribution of financial returns made simple”.

Question

Volatility clustering affects the distribution of returns — the high volatility periods make the returns look longer tailed than if we take the volatility clustering into account.

The question we try to sneak up on is: What is the distribution of returns when volatility clustering is accounted for?  More specifically, what is the distribution using a reasonable garch model?

Data

Daily log returns of 443 large cap US stocks with histories from the start of 2004 into the first few days of 2013 were used.  There were 2267 days of returns for each stock.

The components garch model assuming a t distribution was fit to each stock.

Results

Actual results

The estimated degrees of freedom for the stocks is shown in Figure 1.  Estimation failed for one stock.

Figure 1: Estimated degrees of freedom for the t in the components garch model for the US large cap stocks. A lot of the estimates are close to 6 and hardly any (about 5%) are greater than 10.

Normal distribution

Next was to see what degrees of freedom are estimated if the residuals are normally distributed.  The fits from the first three stocks were used — separately — to simulate series (200 each) and then fit the model to those simulated series.

Figure 2 shows the distributions of the estimated degrees of freedom from the three fits.

Figure 2: Distributions of estimated degrees of freedom using the initial simulated series from three fits. I’m hoping that we can all agree that the normal distribution can be ruled out as the actual distribution.  There is virtually no overlap between the distribution in Figure 1 and those in Figure 2.

It appears that the black distribution in Figure 2 is different from the other two — that it has a much higher probability of being less than 80.  But the distributions are based on only 200 series each; there will be noise.  A further 1000 series were generated for each fit to see if the pattern persists with new, more extensive data.  Figure 3 shows the results.

Figure 3: Distributions of estimated degrees of freedom using the confirmatory simulated series from three fits. The distributions do indeed appear to be different — the black one has just over 50% probability of being less than 80 while the other two have less than 40%.

This means that we can’t assume that the estimate of the degrees of freedom is independent of the other parameters.

t distribution

The next test was — for each stock — simulate a series using the coefficients estimated for the stock but with residuals following a t distribution with 6 degrees of freedom.  The distribution of estimated degrees of freedom from fitting the simulated series is shown in Figure 4.

Figure 4: Distribution of estimated degrees of freedom for series created with a t with 6 degrees of freedom and coefficients specific to each stock. This is much too centered near 6 compared to Figure 1. About 20% of the real estimated degrees of freedom are smaller than the smallest degree of freedom estimated from the t6 simulations.  Likewise, about 10% of the real degrees of freedom are bigger than the biggest from the t6 simulations.

I propose two (not necessarily mutually exclusive) possibilities:

• Different stocks have different distributions
• The real distribution is not t and the degrees of freedom are not a good approximation

Summary

We’ve shown — once again — that the normal distribution is not believable.

We’ve also highlighted our ignorance about the true situation.

Appendix R

The R language was used to do the computing.

collect coefficients from the model on stocks

We start by making sure the rugarch package is loaded in the session, create the specification object that we want, and fit garch models to the first three stocks:

require(rugarch)

comtspec <- ugarchspec(mean.model=list(
  armaOrder=c(0,0)), distribution="std",
  variance.model=list(model="csGARCH"))
fit1 <- ugarchfit(spec=comtspec, initret[,1])
fit2 <- ugarchfit(spec=comtspec, initret[,2])
fit3 <- ugarchfit(spec=comtspec, initret[,3])

The initret object is the matrix of returns.  Next we create a matrix to hold the coefficients for all of the stocks:

gcoefmat <- array(NA, c(443, length(coef(fit1))), 
   list(colnames(initret),names(coef(fit1))))

That the matrix is initialized with missing values is not accidental.  We’re not guaranteed that the default estimation will work.  Now we’re ready to collect the coefficients:

for(i in 1:443) {
  thiscoef <- try(coef(ugarchfit(spec=comtspec, initret[,i])))
  if(!inherits(thiscoef, "try-error") && length(thiscoef) == 7) {
    gcoefmat[i,] <- thiscoef
  }
  cat("."); if(i %% 50 == 0) cat("\n")
} 
cat("\n")

This takes evasive action in case we don’t get a vector of coefficients like we expect — it uses the try function to continue going even if there is an error.  It also gives an indication of how far along the loop is (since fitting over 400 garch models is not especially instantaneous).

simulate garch from a specific distribution

Here is a function that will take a garch fit object and simulate a number of series using residuals from a particular distribution:

pp.garchDistSim <- function(gfit, FUN, trials=200, 
   burnIn=100, ...)
{
  # simulate a garch model given a fit

  # placed in the public domain 2013 by Burns Statistics

  # testing status: untested

  ntimes <- gfit@model$modeldata$T
  FUN <- match.fun(FUN)
  inresid <- scale(matrix(FUN((ntimes+burnIn) * trials, 
       ...), ntimes+burnIn, trials))
  simseries <- ugarchsim(gfit, n.sim=ntimes, 
       n.start=burnIn, m.sim=trials, 
       startMethod="sample", custom.dist=list(name="sample",
       distfit = inresid))@simulation$seriesSim
  simseries        
}

The residuals that are given to the simulation function are scaled (with the scale function) to have zero mean and variance 1 because the routine expects the residuals to be distributed like that.  It can get grumpy if that is obviously not the case.

simulate with normals

The function above is used like:

gsnorm1 <- pp.garchDistSim(fit1, rnorm, trials=200)
gsnorm2 <- pp.garchDistSim(fit2, rnorm, trials=200)
gsnorm3 <- pp.garchDistSim(fit3, rnorm, trials=200)

Once we have these series, we can fit the garch model to them and save the coefficients:

gsnorm1.coefmat <- array(NA, c(200, 7), 
   list(NULL, names(coef(fit1))))
gsnorm2.coefmat <- gsnorm3.coefmat <- gsnorm1.coefmat

for(i in 1:200) {
  thiscoef <- try(coef(ugarchfit(spec=comtspec, gsnorm1[,i])))
  if(!inherits(thiscoef, "try-error") && length(thiscoef) == 7) {
    gsnorm1.coefmat[i,] <- thiscoef
  }
  cat("."); if(i %% 50 == 0) cat("\n")
} 
cat("\n")

difference of distributions from normal

We can get the confidence interval for the proportion of the black distribution from the confirmatory normal estimates being less than 80 by using the binom.test function:

> binom.test(sum(gsnorm2M.coefmat[,7] < 80, na.rm=TRUE),
+            sum(!is.na(gsnorm2M.coefmat[,7])))

	Exact binomial test

data:  sum(gsnorm2M.coefmat[, 7] < 80, na.rm = TRUE)
  and sum(!is.na(gsnorm2M.coefmat[, 7]))
number of successes = 489, number of trials = 963, 
  p-value = 0.6519
alternative hypothesis: true probability of success is
  not equal to 0.5
95 percent confidence interval:
 0.4757106 0.5398179
sample estimates:
probability of success 
             0.5077882

That the binomial test sees 963 observations means that 37 of the 1000 series didn’t produce an appropriate vector of coefficients using the default fitting settings.

The stock that is the odd one out (the black one) is ABT.  The other two are MMM and ANF.  The fit for ABT is significantly more persistent than for the other two (but experimentation is needed to understand what is happening).

simulate given a garch specification

Here is a function that simulates series given a garch specification:

pp.gspecDistSim <- function(spec, FUN, ntimes, trials=1, 
 burnIn=100, ...)
{
  # simulate a garch model given a specification

  # placed in the public domain 2013 by Burns Statistics

  # testing status: untested

  FUN <- match.fun(FUN)
  inresid <- scale(matrix(FUN((ntimes+burnIn) * trials, ...),
     ntimes+burnIn, trials))
  simseries <- ugarchpath(spec, n.sim=ntimes, 
     n.start=burnIn, m.sim=trials, startMethod="sample", 
 custom.dist=list(name="sample",
     distfit = inresid))@path$seriesSim
  simseries        
}

paired simulation with a t

The function immediately above was used like:

gst6specific.coefmat <- array(NA, c(443, 7), 
   dimnames(gcoefmat))
for(i in 1:443) {
  thisspec <- comtspec
  stockcoef <- gcoefmat[i,]
  if(any(is.na(stockcoef))) next
  setfixed(thisspec) <- as.list(stockcoef) 
  simser <- pp.gspecDistSim(thisspec, rt, ntimes=2267, 
     trials=1, df=6)
  thiscoef <- try(coef(ugarchfit(spec=comtspec, simser)))
  if(!inherits(thiscoef, "try-error") && length(thiscoef) == 7) {
    gst6specific.coefmat[i,] <- thiscoef
  }
  cat("."); if(i %% 50 == 0) cat("\n")
} 
cat("\n")

Note that the call to pp.gspecDistSim in this loop is using R’s dot-dot-dot mechanism.