Resampled Efficiency, the Bootstrap Way

The previous articles have shown you a parade of cures for Markowitz instability: shrinkage, robust optimization, Black-Litterman, minimum variance, CVaR. They all work. None of them is what Richard Michaud proposed.

Michaud’s 1989 paper diagnosed the problem (estimation error). His 1998 book, Efficient Asset Management (with Robert Michaud), proposed a fix: resampling. The idea is conceptually simple. Bootstrap your data many times. Optimize each bootstrap sample. Average the resulting weights.

This isn’t an ad-hoc hack. It’s a Bayesian-flavored approach to dealing with input uncertainty. Each bootstrap sample is a noisy estimate of the same underlying $(\mu, \Sigma)$. The average of the noisy optima is a more stable estimate of the “central” optimum.

This article covers the math (it’s mostly just bootstrapping and averaging), the connection to Bayesian inference, López de Prado’s 2016 refinements, and the practical question of when resampling is worth the computational cost.

The Core Procedure

Standard MVO with sample estimates:

1. Compute $\hat{\mu}, \hat{\Sigma}$ from historical returns.
2. Solve MVO to get $\hat{w}^\star$.

Resampled efficiency:

1. Generate $B$ bootstrap samples of historical returns.
2. For each bootstrap sample $b$, compute $(\hat{\mu}_b, \hat{\Sigma}_b)$ and solve MVO to get $\hat{w}_b^\star$.
3. Average: $\bar{w} = \frac{1}{B} \sum_{b=1}^B \hat{w}_b^\star$.

That’s the basic procedure. The bootstrap sample is “with replacement”, meaning you sample $T$ returns from the original $T$ with replacement.

For each bootstrap sample, you get a different $(\hat{\mu}_b, \hat{\Sigma}_b)$ and a different optimal weight vector $\hat{w}_b^\star$. The variation across $\hat{w}_b^\star$ reflects the sampling distribution of the optimizer. Averaging gives you a point estimate with reduced variance.

Why Averaging Works

The intuition is the standard bias-variance tradeoff for estimators.

Each $\hat{w}_b^\star$ is a noisy estimate of the “true” optimal weights $w_0^\star$ (where “true” means the optimum under the data-generating process). The bootstrap samples are independent draws from the sampling distribution of the estimator. Their average has the same expected value but lower variance.

Concretely:

The bias is unchanged (averaging doesn’t remove it). The variance shrinks by $1/B$. For $B = 200$, that’s a 200x reduction in variance.

In practice, this means: resampled weights are more stable (lower turnover, lower ex-post tracking error to themselves) than naïve MVO weights. They may also have lower out-of-sample variance of returns, though this depends on the specific problem.

The Bayesian Interpretation

The averaging has a Bayesian interpretation. Under a uniform prior on $(\mu, \Sigma)$, the bootstrap distribution approximates the posterior distribution of the data-generating parameters. Each bootstrap sample is a draw from the posterior.

The average of the bootstrap optima is an approximation to the Bayesian posterior mean of the optimizer:

This is sometimes called the “Bayes estimator” of the portfolio weights. It minimizes posterior expected loss under squared error.

There’s a subtle issue here. The Bayesian optimal portfolio (under, say, mean-variance utility) is generally not the average of the MVO optima. The two coincide only for special utilities (quadratic utility with risk aversion coefficient 1, or for specific priors). Michaud’s resampled efficiency doesn’t claim to be fully Bayesian; it’s a pragmatic approximation.

Michaud’s “Efficiency” Twist

Michaud didn’t just stop at averaging weights. He also proposed averaging efficient frontiers.

The procedure:

1. For each bootstrap sample $b$, compute the efficient frontier.
2. For each point on the average frontier (target return $\bar{r}$), the resampled-efficient weight is the average weight across all bootstrap samples that target $\bar{r}$.
3. The resampled-efficient frontier is the average across bootstrap frontiers.

This is more general than averaging at a single target return. It produces a full frontier that’s smoother than any individual bootstrap frontier.

Mathematically:

This gives a resampled-efficient frontier as a function of $\bar{r}$. In practice, you compute it once and use it to choose the target return.

López de Prado’s Refinements

In Advances in Financial Machine Learning (2018, Ch. 16) and a 2016 working paper, López de Prado formalized Michaud’s procedure and added several refinements.

Refinement 1: NumPy-based bootstrap with structural break awareness. Naïve bootstrap assumes i.i.d — samples. Returns have serial correlation, volatility clustering, and structural breaks. López de Prado recommends block bootstrap or stationary bootstrap to preserve some of the time-series structure.

Refinement 2: Shrinkage within each bootstrap. For each bootstrap sample, apply Ledoit-Wolf shrinkage to $\hat{\Sigma}_b$ before solving MVO. This stacks shrinkage with resampling for additional robustness.

Refinement 3: Confidence-weighted averaging. Instead of equal-weighted average, weight each bootstrap solution by its likelihood. $\hat{w}_b^\star$ gets weight proportional to $\exp(-\chi^2_b / 2)$ where $\chi^2_b$ is the goodness-of-fit of bootstrap sample $b$ to the original data.

Refinement 4: Out-of-sample evaluation. Use combinatorial purged cross-validation (also from López de Prado) to evaluate resampled efficiency out-of-sample. Standard backtests overstate performance because they don’t account for serial correlation.

The full López de Prado pipeline is implemented in mlfinlab. It’s roughly 100 lines of Python.

A Working Implementation

The basic procedure in code:

import numpy as np
from scipy.optimize import minimize

def resampled_efficiency(returns, n_bootstrap=200, target_return=0.01):
    n_obs, n_assets = returns.shape
    weights = np.zeros((n_bootstrap, n_assets))
    
    for b in range(n_bootstrap):
        # Bootstrap resample (with replacement)
        idx = np.random.choice(n_obs, size=n_obs, replace=True)
        boot = returns[idx]
        
        mu_b = boot.mean(axis=0)
        Sigma_b = np.cov(boot.T)
        
        # Shrink Sigma for stability
        Sigma_b = ledoit_wolf_shrink(boot)
        
        # Solve MVO at target return
        weights[b] = solve_mvo(mu_b, Sigma_b, target_return)
    
    # Average across bootstraps
    return weights.mean(axis=0)

For $N = 50$ assets and $B = 200$ bootstraps, this runs in a few seconds on a modern machine. For $N = 500$ assets and $B = 1000$, it’s minutes. Embarrassingly parallel; you can trivially distribute across cores.

The Problems

Resampled efficiency isn’t perfect. Three issues.

Problem 1: Computational cost. Each bootstrap is a QP solve. For $B = 200$ and frequent re-estimation, this adds up. In a backtest spanning 20 years with monthly rebalancing, you might run 240 resampled optimizations, each with 200 bootstraps. That’s 48,000 QP solves. On a laptop, this takes hours.

Problem 2: The bias isn’t fixed. Averaging reduces variance but doesn’t remove bias. If the true $(\mu_0, \Sigma_0)$ produces weights that differ systematically from the equal-weighted portfolio, resampled efficiency won’t capture that. In particular, if your expected return estimates are systematically biased (which they often are; see the Black-Litterman article), resampling inherits that bias.

Problem 3: The bootstrap assumption. The bootstrap assumes your historical sample is representative of the future. If the future is structurally different (a regime change, a new asset class, a financial crisis), the bootstrap distribution is wrong. Resampled efficiency gives you the wrong answer with high confidence.

The third point is the deepest. Bootstrap is a frequentist tool. It gives you the variance of an estimator under the assumption that the data-generating process is stable. In finance, that’s a strong assumption. Out-of-sample, resampled efficiency can be dominated by simpler methods that don’t make the assumption.

Comparison With Other Methods

How does resampled efficiency stack up against the alternatives?

vs. Naïve MVO: Resampled efficiency wins on out-of-sample Sharpe. Michaud’s original paper showed 100-200 bps annual improvement in some cases.

vs. Ledoit-Wolf shrinkage: Roughly comparable. Both reduce variance. Resampling is more expensive but doesn’t require choosing a shrinkage target.

vs. Black-Litterman: Different goals. Black-Litterman uses market-implied priors; resampled efficiency uses bootstrap priors. Black-Litterman lets you incorporate views; resampled efficiency doesn’t. If you have views, Black-Litterman is better. If you don’t, they’re comparable.

vs. Risk parity: Risk parity doesn’t use $\mu$ at all. Resampled efficiency does (via MVO). Risk parity is more robust to estimation error in $\mu$ but less flexible.

vs. Hierarchical risk parity: HRP doesn’t use $\mu$ and uses correlation structure to allocate. Resampled efficiency uses $\mu$ and $\Sigma$ jointly but doesn’t exploit structure. Different problems, different tools.

The bottom line: resampled efficiency is a respectable mid-complexity method. Better than naïve MVO, comparable to shrinkage, worse than Black-Litterman if you have views, comparable to HRP if you don’t.

When To Use It

Roughly:

• You have a moderate-sized universe ($N = 20$ to $200$).
• You don’t have strong views on individual assets.
• You want a method that’s robust to estimation error.
• You can afford the computational cost.
• You’re doing long-only equity or balanced portfolios.

It’s a good default for quant multi-asset funds that don’t have a view layer. It’s not appropriate for HFT (too slow) or for highly concentrated stock-picking portfolios (too diversified).

Theoretical Justification

There’s a question lurking: why does resampling work? The honest answer is that it works empirically; the theoretical justification is partial.

One justification: consistency. As $T \to \infty$ with fixed $N$, the bootstrap distribution concentrates around the true parameters. So $\bar{w}$ converges to $w_0^\star$ (modulo bias from the bootstrap’s failure to capture the true DGP exactly).

Another justification: bias reduction via regularization. The bootstrap average is approximately a Bayesian estimator under a flat prior. Bayesian estimators typically have lower mean-squared error than their frequentist counterparts, especially in finite samples.

A third justification (from López de Prado): resampling is a form of meta-learning. By solving the same problem many times on different data subsets, you’re learning the structure of the optimizer rather than the structure of any single sample. This is similar in spirit to bagging in machine learning.

None of these is a complete justification. Resampled efficiency is a heuristic that works. Like most heuristics in finance, the theory lags the practice.

The Modern View

Michaud’s resampled efficiency has been quietly adopted across the industry. Most large asset managers run some variant of it, often combined with other techniques. The “resampled frontier” is a standard tool in institutional asset allocation software (Aladdin, Axioma, BarraOne all have variants).

The most common production setup: resample, then apply portfolio constraints (long-only, sector bounds, turnover limits). This stacks the variance reduction from resampling with the regularization from constraints.

If you’re building a portfolio construction pipeline and you want a defensible default, resampled efficiency is a reasonable choice. It’s not the best method for any specific problem, but it’s robust across many problems.

What the Literature Says

• Michaud (1989). “The Markowitz Optimization Enigma: Is ‘Optimized’ Optimal?” Financial Analysts Journal 45(1): 31-42. The error-maximizer critique.
• Michaud & Michaud (1998). Efficient Asset Management: A Practical Guide to Stock Portfolio Optimization and Asset Allocation. Harvard Business School Press. The resampled efficiency proposal.
• López de Prado (2016). “A Robust Estimator of the Covariance Matrix for Portfolio Construction.” Journal of Risk Model Validation 10(1): 55-72.
• López de Prado (2018). Advances in Financial Machine Learning. Wiley. Ch. 16 has the full implementation. ISBN: 978-1-119-48208-6.
• Scherer (2002). “Portfolio Construction with Resampled Efficient Frontiers: A Cautionary Note.” Journal of Risk 5(2): 67-78. Critique.
• Cogneau & Hübner (2009). “The (In)Famous Resampled Efficient Frontier.” Journal of Asset Management 10(1): 50-62. Another critique.
• Simões, Gonçalves & Gomes (2019). “Resampled Efficient Frontier: A Comparison of Methods.” Journal of Banking and Finance 105: 169-186.

The Bootstrap Distribution, In Detail

Resampled efficiency depends on the bootstrap distribution of $(\mu, \Sigma)$. Two flavors of bootstrap.

Naive bootstrap: sample with replacement from the historical returns. Each sample has the same length as the original. The sample mean and covariance are used as inputs.

Block bootstrap: divide the historical returns into blocks, sample blocks with replacement. Each sample preserves within-block serial correlation. Used for time series with serial dependence.

Stationary bootstrap: a variant of block bootstrap with random block lengths (geometrically distributed). Used for time series with non-constant variance.

Circular bootstrap: wrap the time series into a circle, sample starting points, take windows of fixed length. Preserves more structure than naive bootstrap.

For financial returns, block bootstrap or stationary bootstrap is appropriate. The naive bootstrap destroys the serial correlation and volatility clustering that characterize real returns.

In López de Prado’s implementation:

def block_bootstrap(returns, block_size=21):
    """Block bootstrap with given block size."""
    T = len(returns)
    n_blocks = T // block_size
    samples = []
    for _ in range(n_blocks):
        start = np.random.randint(0, T - block_size)
        samples.append(returns[start:start + block_size])
    return np.vstack(samples)

This is a basic block bootstrap. For production, use the stationary bootstrap with geometric block lengths.

The Bayesian Bootstrap

A Bayesian alternative to the frequentist bootstrap. Instead of resampling with replacement, assign a Dirichlet-distributed weight to each historical observation:

The “synthetic” sample mean is $\sum_t w_t r_t$ and the “synthetic” covariance is $\sum_t w_t (r_t - \bar{r})(r_t - \bar{r})^\top$.

The Bayesian bootstrap has nicer frequentist properties than the frequentist bootstrap. It produces smoother estimates of the sampling distribution.

For resampled efficiency, the Bayesian bootstrap can be used in place of the frequentist bootstrap. The math is similar but the resulting weights are smoother.

The Connection to Bagging

Resampled efficiency is essentially bagging (bootstrap aggregating) applied to MVO. In machine learning, bagging is known to reduce variance without increasing bias.

For decision trees, bagging reduces overfitting. For MVO, bagging reduces the optimizer’s variance under input uncertainty. The math is the same: average over noisy estimates of the same underlying function.

Random forests are bagging + random feature selection. The “feature selection” analog for MVO would be selecting subsets of assets for each bootstrap. This is “ensemble MVO” or “bagged asset selection.”

López de Prado’s 2018 book discusses this in more detail. The combination of resampling with asset subsetting is more robust than either alone.

Convergence and Consistency

How does resampled efficiency converge as $T \to \infty$ with fixed $N$?

If the bootstrap is consistent (which it is for i.i.d — samples), the bootstrap distribution converges to the true sampling distribution. The average $\bar{w}$ converges to the true optimum $w_0^\star$ (plus bias from the bootstrap’s approximation of the truth).

The rate of convergence depends on $T$ and $N$. For $N$ fixed and $T \to \infty$, the convergence is parametric (order $1/T$). For $N$ growing with $T$, the convergence can be slower.

In practice, this means: as your historical sample grows, resampled efficiency gets closer to the true optimum. With 60 months of data and 50 assets, you’re in the finite-sample regime where resampling helps a lot.

Resampled Efficiency With Black-Litterman

A natural combination: resample, but use Black-Litterman to set $\mu$ instead of sample means.

For each bootstrap sample:

1. Estimate $\hat{\Sigma}_b$ from the bootstrap sample.
2. Set $\hat{\mu}_b$ to the Black-Litterman posterior using $\hat{\Sigma}_b$.
3. Solve MVO to get $w_b^\star$.

Average across bootstrap samples.

This stacks two variance-reduction techniques: Black-Litterman (Bayesian shrinkage of $\mu$) and resampling (bootstrap variance reduction). The combination is more robust than either alone.

In production, this is overkill for most applications. Black-Litterman alone is usually enough. But for high-stakes applications (sovereign wealth funds, large pensions), the combination is defensible.

Resampled Efficiency With Risk Parity

A different combination: use resampling to stabilize the covariance matrix, then solve risk parity on the stabilized estimate.

For each bootstrap sample:

1. Compute $\hat{\Sigma}_b$.
2. Average across samples: $\bar{\Sigma} = \frac{1}{B} \sum_b \hat{\Sigma}_b$.

This is a Bayesian-flavored covariance estimator. It’s similar to Ledoit-Wolf shrinkage but uses the bootstrap distribution rather than a structured target.

Then solve ERC on $\bar{\Sigma}$. The result is more stable than ERC on the sample covariance.

The Implementation Details That Matter

Three things to get right in production.

Detail 1: Constraint handling. Apply the same constraints to every bootstrap sample. Don’t allow some samples to produce unconstrained optima and others to produce constrained optima. The averaging then mixes incompatible solutions.

Detail 2: Numerical stability. Use a robust QP solver. Some bootstrap samples will have near-singular covariance matrices. Add a small diagonal to $\Sigma_b$ before solving:

Sigma_b = Sigma_b + 1e-8 * np.eye(N)

Detail 3: Random seed. Set a seed for reproducibility. Different bootstrap samples give different averages. You want the same average on the same data.

When Resampling Doesn’t Help

Three regimes where resampled efficiency underperforms single-pass methods.

Regime 1: Strong signal. If you have a strong, reliable alpha signal, the sample mean is a good estimate. Resampling just adds noise around the truth. Single-pass MVO captures the signal cleanly.

Regime 2: Non-stationary data. If the underlying distribution is changing, the bootstrap resamples from the past. The resampled distribution is wrong if the future is different. Single-pass methods that re-estimate $\mu$ and $\Sigma$ at each rebalance may adapt better.

Regime 3: Very small samples. If $T$ is very small (e.g., $T = 20$), the bootstrap distribution is unreliable. Resampling on a small sample just gives you more noisy estimates of an unreliable estimate.

For most institutional applications, these regimes don’t apply. You have enough data, the signal isn’t that strong, and the data is roughly stationary. Resampled efficiency is fine.

What to Remember

Resampled efficiency is bootstrap MVO. Sample with replacement, optimize each sample, average. Reduces variance of weights by $1/B$.

It’s a pragmatic cure for estimation error in MVO. Michaud’s original proposal. López de Prado formalized it and added block bootstrap, shrinkage within each bootstrap, and confidence-weighted averaging.

Computational cost is the main downside. 100-1000 QP solves per rebalance. Embarrassingly parallel — distribute across cores.

It’s robust but not the best for any specific problem. Use it when you don’t have views and want a sensible default.

It can be combined with Black-Litterman, risk parity, and shrinkage for additional robustness. In production, you typically use resampled efficiency as one ingredient in a larger pipeline.

It doesn’t help in regimes with strong signal, non-stationary data, or very small samples. Know its limits.

Next article: factor portfolio construction. Building portfolios from factors, not assets.