The hedge that learned not to trade, read closely

A textbook option hedge is fidgety. As the market moves, its prescribed stock position—called delta—moves too. In a frictionless equation that is fine. In a real account, every correction crosses a spread or pays a fee. A hedge can become safer on paper while losing money through the act of staying “perfect.”

Deep Hedging asks a practical question instead: what sequence of trades gives the best final risk after costs? Its neural network learns the decision directly from simulated market paths. The paper's memorable lesson is not that a network trades faster. Under friction, it often learns when not to trade.

The seller receives an option premium, pays the option's terminal payoff, and earns the gains from holding the underlying asset. If the position changes by Δδ at price S, a simple proportional trading bill is cS|Δδ|. The terminal profit and loss is therefore premium plus trading gains, minus payoff and all transaction costs.

A call option is the right to buy at a fixed strike price. Delta is the amount of stock used to offset a small option-price move. Hedging gives up some upside to reduce uncertainty; it does not make loss impossible.

We replace the network with an interpretable policy. Draw a band around today's textbook delta. If tomorrow's target remains inside, hold the position. If it exits, trade only to the nearest edge. With a previous position of 0.50 and a half-width of 0.10, a target of 0.55 means hold; a target of 0.80 means move only to 0.70.

def band_position(previous, target, half_width):
    if target > previous + half_width:
        return target - half_width
    if target < previous - half_width:
        return target + half_width
    return previous

This no-trade band is not the algorithm claimed by the authors. It is a compact surrogate for the behavior their optimization can discover. We select its width on 800 seeded geometric-Brownian-motion paths, then evaluate it on 1,600 different seeded paths. The training and test samples never overlap.

Average profit can hide rare, severe losses. The paper instead allows a convex risk measure: a score that penalizes dangerous loss distributions while preserving sensible diversification behavior. We use entropic risk. Its risk-aversion setting controls how sharply large losses dominate; at zero, it reduces to the ordinary mean.

def entropic_risk(losses, risk_aversion):
    if risk_aversion == 0:
        return sum(losses) / len(losses)
    scaled = [risk_aversion * loss for loss in losses]
    maximum = max(scaled)
    mean_exp = sum(exp(value - maximum) for value in scaled) / len(scaled)
    return (maximum + log(mean_exp)) / risk_aversion

The authors describe the optimization machinery as model-free: the same training method can consume paths from many market models without deriving a new hedge equation. But training still needs scenarios. Someone must choose a simulator, estimate its parameters, and decide which crashes, volatility shifts, spreads, and liquidity droughts appear often enough for the policy to learn them.

That moves model risk; it does not erase it. To make the point visible, we fit the band in a 20%-volatility world, then change the volatility of the test market. The orange policy keeps both its old band and its old 20% delta model. The green policy is retuned with the new volatility.

• Train on a mixture of calm, jumpy, and illiquid regimes, then hold out an entire regime rather than merely fresh paths from the same model.
• Attribute the gain separately to lower turnover, nonlinear state features, and the chosen risk measure.
• Compare the learned policy with transparent band and quadratic-cost controls at the same out-of-sample risk.

To see how the policy itself can be learned, poke at the neural-network page. The useful connection is simple: supervised learning predicts a supplied label, while deep hedging trains actions against the final economic objective.