End-to-end portfolio optimization: differentiable layers and Sharpe loss.

Predict then optimize, or learn the portfolio

Lessons 4.1.1 to 4.1.4 built portfolios in two steps: estimate expected returns and covariances, and pass those estimates to an optimizer. If the returns are predicted by a machine learning model, the recipe is the same: predict then optimize (PTO). The model is trained on the error of its predictions, and the optimizer takes no part in the training.

The problem is that the squared error of the prediction is not what you want to minimize. A portfolio does not care about getting right the return of an asset it is not going to buy; it cares a lot about the ranking among the assets competing for weight and about what happens in the tails. The end-to-end (E2E) approach, or decision-focused learning, puts the optimizer inside the model and trains on the final metric: the Sharpe of the resulting portfolio. For that, the gradient has to go through the optimizer, which must be a differentiable layer.

flowchart TB
  F[Features] --> M[Model mu]
  M --> O[Optimizer]
  S[Covariance] --> O
  O --> W[Weights]
  W --> P[Return]
  P --> L[Sharpe loss]
  L -. gradient .-> M

In PTO, the backward arrow comes out of a prediction error and does not go through the optimizer. Elmachtoub and Grigas (2017) formalized the general idea (Smart predict, then optimize); Zhang, Zohren and Roberts (2020) trained networks that produce weights with a softmax layer and a Sharpe loss; Butler and Kwon (2021) integrated the prediction into a mean-variance layer. The promise is reasonable. The question of this lesson is the usual one: whether it survives an honest walk-forward against simple baselines.

The universe, the features and the covariance

The universe is the level 4 one of 38 total return indices (universo4_*), without MONET, the money market asset: its excess over the risk-free rate is almost zero with a volatility of 0.2%, and a Sharpe loss with no other constraints can end up concentrated in an asset like that (question 5 of the self-assessment). That leaves 37.

At each month end, for each asset, three features standardized across assets (12-month momentum skipping the last month, last month's return and three-month volatility), the covariance of the last year and the next month's return in excess of the risk-free rate. The covariance is Ledoit-Wolf on the standardized returns, that is, shrinking the correlation and not the covariance: lesson 4.1.2 showed that the scaled identity target spoils minimum variance when volatilities range from 1% to 30%.

import numpy as np
import pandas as pd
import torch
from sklearn.covariance import LedoitWolf

torch.manual_seed(0)
torch.use_deterministic_algorithms(True)
torch.set_default_dtype(torch.float64)

precios = pd.read_parquet("universo4_precios.parquet")
precios = precios.set_index("fecha").drop(columns="MONET")
rf = pd.read_parquet("universo4_factores_diarios.parquet")
rf = rf.set_index("fecha")["rf"]
cols = precios.columns.tolist()
r = precios.pct_change().iloc[1:]
ex = r.sub(rf.loc[r.index], axis=0)          # simple daily excess
logp = np.log(precios).iloc[1:]               # aligned with r
fin_mes = r.index.to_series().groupby(r.index.to_period("M")).max()
print(f"{len(cols)} assets | {r.index[0].date()} to "
      f"{r.index[-1].date()} | {len(fin_mes)} month ends")

37 assets | 2006-01-04 to 2025-12-31 | 240 month ends

def features(i):
    """Features of each asset at the close of session i, standardized
    across assets: 12-1 momentum, 1-month return, 3-month vol."""
    f = pd.DataFrame({
        "mom_12_1": logp.iloc[i - 21] - logp.iloc[i - 252],
        "ret_1m": logp.iloc[i] - logp.iloc[i - 21],
        "vol_3m": ex.iloc[i - 62:i + 1].std() * np.sqrt(252)})
    return ((f - f.mean()) / f.std()).to_numpy()

def covarianza(i):
    """Ledoit-Wolf of the last year's correlation, monthly."""
    x = ex.iloc[i - 251:i + 1].to_numpy()
    sd = x.std(axis=0)
    corr = LedoitWolf().fit(x / sd).covariance_
    return corr * np.outer(sd, sd) * 21

F, S, R, meses = [], [], [], []
fines = fin_mes.to_numpy()
for d0, d1 in zip(fines[:-1], fines[1:]):
    i0, i1 = r.index.get_loc(d0), r.index.get_loc(d1)
    if i0 < 252:
        continue
    F.append(features(i0))
    S.append(covarianza(i0))
    tramo = r.index[i0 + 1:i1 + 1]
    R.append((1 + r.loc[tramo]).prod().to_numpy()
             - (1 + rf.loc[tramo]).prod())
    meses.append(pd.Timestamp(d0))
F, S, R = (torch.tensor(np.array(a)) for a in (F, S, R))
meses = pd.DatetimeIndex(meses)
print("F", tuple(F.shape), "| S", tuple(S.shape), "| R", tuple(R.shape))
print("decisions:", meses[0].date(), "to", meses[-1].date())

F (227, 37, 3) | S (227, 37, 37) | R (227, 37)
decisions: 2007-01-31 to 2025-11-28

Each decision is made at the close of the last day of the month with data up to that day, and its outcome is the next month's return. The first decision needs a year of history (January 2007); the last one, in November 2025, covers December.

A differentiable optimization layer

The layer solves, for some expected returns $\hat\mu$ that will come out of the model, the long-only mean-variance problem:

If there were only the budget constraint, the Karush-Kuhn-Tucker conditions would give a closed formula, differentiable as is: the minimum variance portfolio plus a tilt proportional to $\hat\mu$,

Before using it, it is worth looking at the portfolio it gives in this universe:

def mv_presupuesto(mu, Sigma, gamma=5.0):
    """min gamma/2 w'Sw - mu'w with 1'w = 1 (no w >= 0): KKT."""
    uno = torch.ones(mu.shape[-1])
    s1 = torch.linalg.solve(Sigma, uno)
    smu = torch.linalg.solve(Sigma, mu)
    return s1 / s1.sum() + (smu - s1 * smu.sum() / s1.sum()) / gamma

k = 48                                       # January 2011
mu_ej = F[k] @ torch.tensor([0.0, 0.0, -0.2]) / 100
w_cf = mv_presupuesto(mu_ej, S[k])
print(f"{meses[k].date()}: sum {w_cf.sum():.3f} | gross "
      f"{w_cf.abs().sum():.2f} | min. {w_cf.min():.2f} | "
      f"max. {w_cf.max():.2f}")
top = pd.Series(w_cf.numpy(), cols).sort_values()
print(top.iloc[[0, 1, -2, -1]].round(2).to_string())

2011-01-31: sum 1.000 | gross 17.42 | min. -1.67 | max. 1.85
RF_T20    -1.67
RF_T710   -1.36
RF_T37     1.77
RF_T13     1.85

With a modest prediction (−0.2% per month for each standard deviation of volatility), the portfolio without the long-only constraint has a gross exposure of 17 times capital: longs of 1.85 and 1.77 in the 1-3 and 3-7 year bonds and shorts of 1.67 and 1.36 in the 20 and 7-10 year ones. It bets with a lot of leverage on the differences between nearly redundant assets. A Sharpe loss would exploit that freedom. The $w \ge 0$ constraint is the cheapest regularization, and with it there is no closed formula anymore.

The standard tool to differentiate a constrained convex problem is cvxpylayers (Agrawal et al., 2019), which differentiates the problem's optimality conditions. Version 1.2.0 (Apache-2.0) requires cvxpy, which is not in the course's ml environment; this is how it would be written:

import cvxpy as cp
from cvxpylayers.torch import CvxpyLayer

n = 37
w = cp.Variable(n)
mu = cp.Parameter(n)
L = cp.Parameter((n, n))            # Sigma = L L' (Cholesky)
gamma = 5.0
objetivo = cp.Minimize(gamma / 2 * cp.sum_squares(L.T @ w) - mu @ w)
problema = cp.Problem(objetivo, [cp.sum(w) == 1, w >= 0])
assert problema.is_dpp()             # parameters multiplying w
capa_cvx = CvxpyLayer(problema, parameters=[mu, L], variables=[w])
(pesos,) = capa_cvx(mu_tch, torch.linalg.cholesky(S_tch))

The dependency-free alternative is to unroll an iterative algorithm: accelerated projected gradient (FISTA) on the objective, with an exact projection onto the set $\{w \ge 0, \mathbf{1}'w = 1\}$ (sort, accumulate and cut). Each iteration is made of PyTorch operations, so autograd differentiates through the 30 iterations as it would through 30 layers of a network.

There is a numerical detail that decides whether the layer is usable. The variances of the universe range from the short bond (≈ 1.5% annual volatility) to emerging market equities (≈ 27%): the covariance is very badly conditioned, and projected gradient with step $1/(\gamma\lambda_{\max}(\Sigma))$ crawls in the directions of the low-volatility assets. The solution is to precondition with the diagonal $D = \operatorname{diag}(\Sigma)$: the step is divided by each asset's variance (working in volatility units), the step size is set by the largest eigenvalue of the correlation (much better conditioned) and the projection is done in the $D$-weighted norm, which has the same sorting solution as the Euclidean one: $w_i = \max(0,\ y_i - \tau/d_i)$, with $\tau$ the value that makes the weights sum to 1.

def proyectar(y, d):
    """argmin sum d_i (w_i - y_i)^2 with w >= 0, sum(w) = 1, by rows:
    w_i = max(0, y_i - tau / d_i)."""
    b = y * d                                # breakpoints
    orden = torch.argsort(b, dim=-1, descending=True)
    ys, inv_d = y.gather(-1, orden), (1 / d).gather(-1, orden)
    tau_k = (ys.cumsum(-1) - 1) / inv_d.cumsum(-1)
    rho = (b.gather(-1, orden) > tau_k).sum(-1, keepdim=True)
    tau = tau_k.gather(-1, rho - 1)
    return torch.clamp(y - tau / d, min=0)

var = torch.diagonal(S, dim1=1, dim2=2)          # D of each month
corr = S / torch.sqrt(var[:, :, None] * var[:, None, :])
lam_corr = torch.linalg.eigvalsh(corr)[:, -1:]
print(f"median condition number: covariance "
      f"{torch.linalg.cond(S).median():.0f}, correlation "
      f"{torch.linalg.cond(corr).median():.0f}")

def capa(mu, meses_, gamma=5.0, iters=30):
    """argmin gamma/2 w'Sw - mu'w, w >= 0, 1'w = 1: FISTA
    preconditioned by the diagonal, with each month's S."""
    Sig, d = S[meses_], var[meses_]
    paso = 1 / (gamma * lam_corr[meses_])
    w = torch.full(mu.shape, 1 / mu.shape[-1])
    z, t = w, 1.0
    for _ in range(iters):
        grad = gamma * torch.einsum("bij,bj->bi", Sig, z) - mu
        w_n = proyectar(z - paso * grad / d, d)
        t_n = (1 + np.sqrt(1 + 4 * t * t)) / 2
        z = w_n + (t - 1) / t_n * (w_n - w)
        w, t = w_n, t_n
    return w

from scipy.optimize import minimize
n = len(cols)
for nombre, mu_ in (("minimum variance", torch.zeros(n)),
                    ("with the prediction", mu_ej)):
    ref = minimize(
        lambda x: 2.5 * x @ S[k].numpy() @ x - mu_.numpy() @ x,
        np.full(n, 1 / n), method="SLSQP", bounds=[(0, 1)] * n,
        constraints=[{"type": "eq", "fun": lambda x: x.sum() - 1}],
        options={"ftol": 1e-15, "maxiter": 1000}).x
    w_capa = capa(mu_[None], [k])[0].numpy()
    print(f"{nombre}: max. |w - SLSQP| = "
          f"{np.abs(w_capa - ref).max():.4f} | assets with weight: "
          f"{(w_capa > 1e-3).sum()} (SLSQP: {(ref > 1e-3).sum()})")

median condition number: covariance 23925, correlation 426
minimum variance: max. |w - SLSQP| = 0.0022 | assets with weight: 5 (SLSQP: 5)
with the prediction: max. |w - SLSQP| = 0.0000 | assets with weight: 1 (SLSQP: 1)

With 30 preconditioned iterations, the layer ends up thousandths of weight away from the SLSQP solution in both cases (without preconditioning, with 30 iterations the distance was tens of weight points). 30 will be used: the layer is a fixed, differentiable approximation of the optimizer, and it is the same in training and in evaluation.

The second check is the gradient. Autograd differentiates the unrolled algorithm; finite differences, the result. They should be similar, except when an asset enters or leaves the portfolio (the support changes and the function has a corner):

def sharpe(w, Rm):
    """Monthly Sharpe of portfolio w (simple returns, sum of w * r)."""
    rp = (w * Rm).sum(-1)
    return rp.mean() / rp.std()

ent0 = np.arange(0, 46)                  # 2007-01 to 2010-10
def perdida(theta):
    w = capa(F[ent0] @ theta / 100, ent0)
    return -sharpe(w, R[ent0])

theta0 = torch.zeros(3, requires_grad=True)
perdida(theta0).backward()
h = 1e-4
fd = [((perdida(h * e) - perdida(-h * e)) / (2 * h)).item()
      for e in torch.eye(3)]
print("autograd:", theta0.grad.numpy().round(2))
print("finite diff.:", np.round(fd, 2))

autograd: [ 2.43 -0.6  11.48]
finite diff.: [ 2.72  0.23 10.61]

The two large components (momentum and volatility) agree in sign and approximate magnitude; the one for last month's return is small and does not even have the same sign. They do not match exactly because at $\theta = 0$ there are assets on the edge of the support (minimum variance has five assets with weight) and a finite difference of $10^{-4}$ crosses corners that the local derivative does not see: the loss is piecewise smooth. This is normal in layers with inequality constraints, and it is one of the reasons why training these layers is noisy.

The model and the Sharpe loss

The model is deliberately small: $\hat\mu_i = \theta' f_i / 100$, a linear combination of the three features with three parameters (the /100 puts $\hat\mu$ on a monthly return scale and leaves $\theta$ of order 1). With $\theta = 0$ the layer returns the minimum variance portfolio; training decides how much to tilt and in which direction. The loss is the negative monthly Sharpe over the training months:

The portfolio returns are the sum of weights times the simple returns of each asset (with log returns, the Sharpe of a portfolio comes out understated: lesson 4.1.1).

def entrenar_e2e(ent, epocas=150, lr=0.01, cada=None):
    torch.manual_seed(0)
    theta = torch.zeros(3, requires_grad=True)
    opt = torch.optim.Adam([theta], lr=lr)
    hist = {}
    for e in range(epocas + 1):
        opt.zero_grad()
        p_ = perdida_en(theta, ent)
        if cada and e % cada == 0:
            hist[e] = round(float(-p_.item() * np.sqrt(12)), 2)
        if e < epocas:
            p_.backward()
            opt.step()
    return theta.detach(), hist

def perdida_en(theta, ent):
    w = capa(F[ent] @ theta / 100, ent)
    return -sharpe(w, R[ent])

theta_ej, hist = entrenar_e2e(ent0, cada=30)
print("annualized in-sample Sharpe by epoch:", hist)
print("theta (mom_12_1, ret_1m, vol_3m):", theta_ej.numpy().round(3))

annualized in-sample Sharpe by epoch: {0: 0.96, 30: 1.49, 60: 1.5, 90: 1.53, 120: 1.53, 150: 1.56}
theta (mom_12_1, ret_1m, vol_3m): [-0.025  0.115 -0.184]

In 150 epochs the in-sample Sharpe rises from 0.96 (minimum variance, epoch 0) to 1.56. The model learned to weight against volatility and in favor of last month's return. In 2007-2010 that describes well what happened: bonds and low-volatility assets were the safe haven of the crisis. Whether it is a rule or a memory of 46 months, the walk-forward will tell.

Walk-forward: six portfolios

Every three years (January 2011, 2014, 2017, 2020 and 2023) the model is retrained with all the months whose return already ended before the decision date: the last training month is the second to last, because the return of the last one ends exactly on that day (the gap of lesson 5.4.3). Six portfolios, all long-only and rebalanced every month:

nombres = ["1/N", "inverse vol.", "min. variance", "PTO",
           "E2E mean-variance", "E2E softmax"]
W = {m: torch.zeros(len(meses), n) for m in nombres}
ventanas = []
for anyo in (2011, 2014, 2017, 2020, 2023):
    pru = np.flatnonzero((meses.year >= anyo) & (meses.year < anyo + 3))
    ent = np.arange(0, pru[0] - 1)       # one-month gap
    # PTO: least squares of the month's relative return
    X_ = F[ent].reshape(-1, 3).numpy()
    y_ = (R[ent] - R[ent].mean(1, keepdim=True)).reshape(-1).numpy()
    th_pto = torch.tensor(np.linalg.lstsq(X_, y_, rcond=None)[0])
    # E2E with the layer and E2E softmax
    th_e2e, _ = entrenar_e2e(ent)
    torch.manual_seed(0)
    th_sm = torch.zeros(3, requires_grad=True)
    opt = torch.optim.Adam([th_sm], lr=0.05)
    for _ in range(150):
        opt.zero_grad()
        (-sharpe(torch.softmax(F[ent] @ th_sm, -1), R[ent])).backward()
        opt.step()
    with torch.no_grad():
        cero = torch.zeros(len(pru), n)
        vi = 1 / torch.diagonal(S[pru], dim1=1, dim2=2).sqrt()
        W["1/N"][pru] = 1 / n
        W["inverse vol."][pru] = vi / vi.sum(1, keepdim=True)
        W["min. variance"][pru] = capa(cero, pru)
        W["PTO"][pru] = capa(F[pru] @ th_pto, pru)
        W["E2E mean-variance"][pru] = capa(F[pru] @ th_e2e / 100, pru)
        W["E2E softmax"][pru] = torch.softmax(F[pru] @ th_sm, -1)
        sh_ent = {
            "min. variance": sharpe(capa(torch.zeros(len(ent), n),
                                         ent), R[ent]),
            "E2E mean-variance": -perdida_en(th_e2e, ent)}
    ventanas.append({
        "trained until": meses[ent[-1]].strftime("%Y-%m"),
        "θ E2E": th_e2e.numpy().round(2).tolist(),
        "in-sample Sharpe E2E": float(sh_ent["E2E mean-variance"])
        * np.sqrt(12),
        "in-sample Sharpe min. var.": float(sh_ent["min. variance"])
        * np.sqrt(12)})
pd.DataFrame(ventanas, index=[2011, 2014, 2017, 2020, 2023]).round(2)

     trained until                 θ E2E  in-sample Sharpe E2E  in-sample Sharpe min. var.
2011       2010-11  [-0.02, 0.12, -0.18]                  1.63                        1.05
2014       2013-11    [0.0, 0.12, -0.18]                  0.89                        0.63
2017       2016-11   [-0.02, 0.09, -0.1]                  0.77                        0.61
2020       2019-11  [-0.05, 0.11, -0.12]                  0.65                        0.43
2023       2022-11  [0.01, -0.02, -0.02]                  0.20                        0.15

In every window the E2E has a higher in-sample Sharpe than minimum variance, which is the portfolio it starts from with $\theta = 0$. Its $\theta$ almost always tells the same story: weight against volatility and in favor of the last month. The question is what happens in the three years following each training:

def sharpe_anual(m, meses_):
    rp = (W[m][meses_] * R[meses_]).sum(-1)
    return float(rp.mean() / rp.std() * np.sqrt(12))

v = pd.DataFrame(ventanas, index=[2011, 2014, 2017, 2020, 2023])
for m in ("E2E mean-variance", "min. variance"):
    v[f"out-of-sample Sharpe {m}"] = [
        sharpe_anual(m, np.flatnonzero((meses.year >= a)
                                       & (meses.year < a + 3)))
        for a in v.index]
v.drop(columns=["trained until", "θ E2E"]).round(2).T

                                        2011  2014  2017  2020  2023
in-sample Sharpe E2E                    1.63  0.89  0.77  0.65  0.20
in-sample Sharpe min. var.              1.05  0.63  0.61  0.43  0.15
out-of-sample Sharpe E2E mean-variance  0.30  0.66 -0.48 -0.84 -0.38
out-of-sample Sharpe min. variance      0.35  0.64 -0.75 -0.67  0.18

In sample, the E2E beats minimum variance in all five windows, by 0.05 to 0.58 Sharpe points. In the following three years it wins in one (2017-2019, −0.48 against −0.75), ties in another (2014-2016) and loses in three; in 2023-2025 it loses by more than half a point. The in-sample advantage does not predict the out-of-sample advantage, which is the practical definition of overfitting. In the last window, moreover, training barely moves away from $\theta = 0$: with 2022 in the sample (bonds and equities falling at the same time), no tilt improved the training Sharpe.

Out-of-sample results

For 2011-2025 (179 months): excess return, volatility, gross and net Sharpe (10 bp per unit of turnover, as in lesson 4.1.5), maximum drawdown, annual turnover, effective number of assets ($1/\sum w_i^2$) and the average true Sharpe of the weights chosen, $w'\mu/\sqrt{w'\Sigma w}$ with the published μ and Σ of the universe (universo4_verdad.csv and universo4_cov_verdad.csv, block total). The last one separates what each method chose from the luck it had afterwards, as in lesson 4.1.4.

verdad = pd.read_csv("universo4_verdad.csv", index_col="activo")
mu_v = verdad.loc[cols, "mu_verdadero"].to_numpy()
cv = pd.read_csv("universo4_cov_verdad.csv")
cv = cv[cv["regimen"] == "total"].set_index("activo")
sig_v = cv.loc[cols, cols].to_numpy()

prueba = np.flatnonzero(meses.year >= 2011)
Rp = R[prueba].numpy()
filas = {}
for m in nombres:
    w = W[m][prueba].numpy()
    rp = (w * Rp).sum(1)
    rot = np.r_[0.0, np.abs(np.diff(w, axis=0)).sum(1)]
    neto = rp - 0.001 * rot
    curva = np.cumprod(1 + rp)
    filas[m] = {
        "excess %": 1200 * rp.mean(),
        "vol. %": 100 * np.sqrt(12) * rp.std(),
        "Sharpe": np.sqrt(12) * rp.mean() / rp.std(),
        "net Sharpe": np.sqrt(12) * neto.mean() / neto.std(),
        "max. drawdown %": 100 * (curva / np.maximum.accumulate(curva)
                                  - 1).min(),
        "turnover %": 1200 * rot.mean(),
        "effective n": np.mean(1 / (w ** 2).sum(1)),
        "true Sharpe": np.mean([x @ mu_v / np.sqrt(x @ sig_v @ x)
                                for x in w])}
tabla = pd.DataFrame(filas).T
print(f"{len(prueba)} months, {meses[prueba[0]].date()} to "
      f"{meses[prueba[-1]].date()}")
print(tabla.round(2).to_string())

179 months, 2011-01-31 to 2025-11-28
                   excess %  vol. %  Sharpe  net Sharpe  max. drawdown %  turnover %  effective n  true Sharpe
1/N                    6.54   13.89    0.47        0.47           -22.83        0.00        37.00         0.39
inverse vol.           3.15    7.68    0.41        0.41           -16.69       26.12        16.53         0.47
min. variance         -0.03    1.60   -0.02       -0.03            -7.44       16.60         1.07         0.39
PTO                    2.42    4.42    0.55        0.36           -12.47      833.17         1.65         0.31
E2E mean-variance     -0.24    1.80   -0.13       -0.23           -10.34      191.23         1.10         0.30
E2E softmax            0.38    3.11    0.12       -0.05           -12.80      531.52         3.73         0.39

Turnover is the first symptom: the three portfolios that learn something turn over between ten and fifty times more than the simple ones, and costs take their toll.

The figure at the top puts the realized and the true Sharpe of each portfolio on the same scale. Four readings:

• E2E mean-variance is the worst by true Sharpe (0.30) and also by realized Sharpe (−0.13; −0.23 net). It does not improve on the portfolio it starts from with $\theta = 0$, minimum variance (0.39 true), and it turns over ten times more (191% per year against 17%).
• Minimum variance is almost a single asset: 1.07 effective assets, mostly the 1-3 year bond, as in lesson 4.1.4. Its realized Sharpe (−0.02) understates what it chose (0.39), because the universe's bonds returned less than their expectation in the sample.
• PTO has the best realized Sharpe (0.55) and the second-worst true one (0.31). Its weights depend on predictions with very little signal, jump from one month to the next (833% turnover per year) and happened to be right in the period. It is the result a backtest rewards and the truth does not support.
• Inverse volatility has the best true Sharpe (0.47) with 16.5 effective assets and 26% turnover: the simplest portfolio with a covariance beats everything that learns something. 1/N, with the highest realized Sharpe after PTO (0.47), has a true Sharpe of 0.39.

How noisy the comparison is

With $T$ years of monthly returns, the standard error of an annual Sharpe is about $\sqrt{(1 + S^2/2)/T}$. With 15 years:

anyos = len(prueba) / 12
et = np.sqrt((1 + tabla["Sharpe"] ** 2 / 2) / anyos)
pd.DataFrame({"Sharpe": tabla["Sharpe"], "std. error": et,
              "true Sharpe": tabla["true Sharpe"]}).round(2)

                   Sharpe  std. error  true Sharpe
1/N                  0.47        0.27         0.39
inverse vol.         0.41        0.27         0.47
min. variance       -0.02        0.26         0.39
PTO                  0.55        0.28         0.31
E2E mean-variance   -0.13        0.26         0.30
E2E softmax          0.12        0.26         0.39

A standard error of 0.26 to 0.28 per portfolio, larger than almost all the distances between them. A backtest of a single history cannot rank these portfolios; the true Sharpe, which does not exist on real data, can. And six methods have been tried (and in a real case, many more variants of features, γ and epochs): any winner by realized Sharpe would also have to pass the Deflated Sharpe discount of lesson 5.4.4.

When end-to-end can work

The result does not condemn the idea; it says what it needs. The E2E has the same information as PTO and more freedom to use it, and freedom is paid for in estimation variance:

The papers that find improvements with E2E (Butler and Kwon, 2021; Uysal et al., 2021 with risk budgets) usually reduce the model's freedom, not increase it: layers with more structure, predictions that only tilt a robust portfolio and losses that mix the prediction error with the decision error. Before any of them, the question of this lesson: does it improve on its own portfolio with $\theta = 0$, out of sample and after costs?

Exercises

1. Train the E2E mean-variance on 2007-2010 for 450 epochs and measure every 75 epochs the Sharpe in sample and in 2011-2013 (without retraining). What happens to each one? Can you use the 2011-2013 curve to choose the number of epochs?

pru0 = np.flatnonzero((meses.year >= 2011) & (meses.year < 2014))
torch.manual_seed(0)
theta = torch.zeros(3, requires_grad=True)
opt = torch.optim.Adam([theta], lr=0.01)
curva = {}
for e in range(451):
    opt.zero_grad()
    p_ = perdida_en(theta, ent0)
    if e % 75 == 0:
        with torch.no_grad():
            fuera = -perdida_en(theta, pru0)
        curva[e] = {"in sample": -p_.item() * np.sqrt(12),
                    "2011-2013": fuera.item() * np.sqrt(12)}
    if e < 450:
        p_.backward()
        opt.step()
pd.DataFrame(curva).T.round(2)

     in sample  2011-2013
0         0.96       0.35
75        1.51       0.30
150       1.56       0.31
225       1.61       0.31
300       1.65       0.35
375       1.68       0.36
450       1.69       0.37

2. Recompute the net Sharpe of the table with costs of 5, 10, 25 and 50 bp per unit of turnover. From what cost does PTO stop paying off against minimum variance?

sens = {}
for c in (5, 10, 25, 50):
    fila = {}
    for m in ("min. variance", "PTO", "E2E mean-variance",
              "inverse vol."):
        w = W[m][prueba].numpy()
        rot = np.r_[0.0, np.abs(np.diff(w, axis=0)).sum(1)]
        rn = (w * Rp).sum(1) - c / 1e4 * rot
        fila[m] = np.sqrt(12) * rn.mean() / rn.std()
    sens[f"{c} bp"] = fila
pd.DataFrame(sens).round(2)

                   5 bp  10 bp  25 bp  50 bp
min. variance     -0.02  -0.03  -0.04  -0.07
PTO                0.46   0.36   0.08  -0.39
E2E mean-variance -0.18  -0.23  -0.38  -0.61
inverse vol.       0.41   0.41   0.40   0.39

3. The layer of this lesson fixes γ = 5 and leaves the scale of $\theta$ free. Would anything change if γ were also trained? And if the budget constraint were removed and the Sharpe loss left to decide the size?