DiffQuant : optimisation Sharpe dans un simulateur différentiable

## DiffQuant : Simulateur de trading différentiable pour optimisation directe du Sharpe

Dans le trading algorithmique basé sur l’apprentissage automatique, les modèles sont traditionnellement entraînés à prédire les rendements ou la direction des prix via l’erreur quadratique moyenne (MSE) ou l’entropie croisée, tandis que les performances sont évaluées via le ratio de Sharpe tenant compte des frais. Cela crée un décalage : des prévisions précises des micro-mouvements ne garantissent pas la rentabilité hors échantillon. DiffQuant élimine les objectifs proxies en construisant un graphe différentiable unique des caractéristiques de marché au PnL final et au Sharpe. Les tests walk-forward délivrent un Sharpe de +1,73 et +8,22 % de rendement après commissions.

Défis des objectifs proxies traditionnels

Le pipeline standard sépare prédiction et trading :

• Le modèle minimise la MSE sur le rendement_{t+1}.
• La taille de la position est déterminée par des heuristiques.
• Le backtesteur applique les commissions a posteriori.

Cela conduit à :

• Décalage des espaces d’erreur : Précision sur les fluctuations bruitées provoque du surtrading et des saignées dues aux frais.
• Pas de gradient sur la taille de position : Le modèle n’apprend pas l’agressivité d’entrée.
• Ignorer les frais pendant l’entraînement : Glissement et commissions sont hors du graphe de calcul.

DiffQuant intègre la dimensionnement de position, la simulation PnL et les métriques dans un graphe PyTorch, propageant les gradients de bout en bout.

Simulateur de trading différentiable

Le simulateur calcule le PnL via des opérations tensorielles sur l’horizon t ∈ [0, H-1] :

$$r_t = \frac{c_t - c_{t-1}}{|c_{t-1}| + \varepsilon}$$

$$gross_t = p_{t-1} \cdot r_t$$

$$cost_t = smooth\_abs(\Delta p_t) \cdot (commission + slippage)$$

$$pnl_t = gross_t - cost_t$$

Innovation clé — smooth_abs pour la différentiabilité :

$$smooth\_abs(x) = \sqrt{x^2 + \varepsilon}, \quad \varepsilon = 10^{-6}$$

Cela assure une douceur C^∞ près de zéro, où la politique démarre plate, évitant les discontinuités des sous-gradients.

Les gradients du -Sharpe traversent PnL → positions → modèle, l’entraînant à prendre en compte les frais de bout en bout.

Architecture de politique avec iTransformer

Socle : iTransformer (ICLR 2024) : un transformer inversé où les tokens sont les canaux de caractéristiques, pas les pas de temps. Pour les données financières, cela capture les dépendances inter-canaux (prix-volume-volatilité).

Config : d_model=32, n_layers=4, n_heads=2, d_ff=64 (52k paramètres).

Graphe complet :

• Normalisation Z-score sur fenêtre de contexte (B, ctx, F) sans anticipation.
• iTransformerEncoder.
• Concat extras : [prev_pos, prev_delta, t/H, (H-t)/H].
• PolicyHead : direction_head × gate_head.

Position : $$p_t = \tanh\left(\frac{d_t}{\tau_{dir}}\right) \times \sigma\left(\frac{g_t}{\tau_{gate}}\right)$$

Le signal de gate masque les directions incertaines (comme le masquage d’action). gate_bias=-1.0 stabilise les débuts quasi-plats.

Roulage itératif :

for t in range(H):
    window = full_seq[:, t : t + ctx, :]
    window_norm = normalize_context(window)
    extras = [prev_pos, prev_delta, t/H, (H-t)/H]
    pos_t = model(window_norm, extras)
    positions_list.append(pos_t)
positions = cat(positions_list)
step_pnl = simulator.simulate(closes, positions)
loss = hybrid_loss(step_pnl, positions)
loss.backward()

Perte hybride pour éviter les pathologies

Le Sharpe pur mène au churning, à l’effondrement plat, au biais long, à l’exposition terminale, à l’aveugle aux drawdowns. L’hybride les corrige :

$$\mathcal{L} = \lambda_1 \cdot (-Sharpe) + \lambda_2 \cdot turnover + \lambda_3 \cdot drawdown_{log} + \lambda_4 \cdot |p_H| + \lambda_5 \cdot (\hat{f} - f^*)^2 + \lambda_6 \cdot |\bar{p}|$$

• $\lambda_2$ : Pénalité de rotation contre le churning.
• $\lambda_3$ : Log-drawdown pour stabilité.
• $\lambda_4$ : Exposition nulle en fin d’horizon.
• $\lambda_5$ : Fraction plate cible via sigmoïde.
• $\lambda_6$ : Anti-biais, crucial en marchés haussiers.

$$drawdown_{log} = mean(cummax(cumsum(log(1+pnl))) - cumsum(log(1+pnl)))$$

Augmentation miroir pour symétrie

Données d’entraînement (2024–2025) : BTC haussier. Sans intervention, modèle long-only. L’augmentation miroir inverse prix et caractéristiques sur sous-ensembles de batch, créant des paires symétriques.

Résultat : short_fraction 17,3 % (test), 20,9 % (backtest).

Expériences : Données et découpages

| Paramètre | Valeur |

|-----------|--------|

| Instrument | BTCUSDT Binance Futures |

| Résolution | Barres 30 min (agrégées de 1 min) |

| Période | 2021–2025 |

Découpages :

• Entraînement : janv. 2024 – mars 2025.
• Test : juil.–sept. 2025.
• Backtest : oct.–déc. 2025.
• Walk-forward OOS.

Enseignements clés

• Graphe différentiable unique des caractéristiques au Sharpe résout les problèmes proxies, incluant frais et dimensionnement.
• iTransformer + direction×gate active l’attention inter-canaux et le trading confiant.
• Perte hybride anti-biais prévient pathologies comme churning et long-only.
• Augmentation miroir produit politique symétrique sur données asymétriques.
• Sharpe walk-forward +1,73 après commissions sur BTC OOS.

— Editorial Team