Trader sur la base de la mécanique quantique : comment construire un agent IA autonome

Le même calcul qui décrit une particule à deux endroits à la fois peut décrire un portefeuille dans deux positions simultanément. Voici comment transformer la structure de la mécanique quantique en un agent de trading autonome – et, tout aussi important, où l'analogie cesse d'être réelle pour devenir du marketing.

1. Pourquoi le quantique, et pourquoi maintenant

Chaque hedge fund sur la planète broie les mêmes trois idées jusqu'à la poussière : le momentum, le mean-reversion, et une forme de machine learning sur les flux d'ordres. L'avantage ne cesse de s'amincir car le modèle du marché que tout le monde partage est identique – un modèle classique, où un prix est un nombre unique et le futur une seule trajectoire bruyante.

La mécanique quantique offre un modèle de données différent. Un système quantique n'est jamais dans un seul état. Il vit dans une superposition de tous les états possibles à la fois, chacun portant une amplitude de probabilité complexe. Cela se trouve être une description remarquablement bonne d'un marché avant que vous ne placiez une transaction : l'actif est simultanément en hausse, en baisse, et en range, chaque résultat pondéré par une probabilité, jusqu'à ce que votre ordre force la réalité à en choisir un.

Voici la partie que la plupart des fils de discussion omettent, alors je vais la mettre d'emblée. Vous n'avez besoin d'aucun ordinateur quantique physique pour tout cela, et la majeure partie de ce qui suit n'est pas littéralement quantique. C'est inspiré du quantique : des algorithmes classiques qui empruntent la structure mathématique de la mécanique quantique – vecteurs d'état, amplitudes complexes, hamiltoniens, recuit, interférence – et tournent sur le même GPU que vous possédez déjà. La valeur réside dans la structure, pas dans les qubits. Être honnête à propos de cette distinction est ce qui sépare un cadre utilisable d'un mot à la mode.

Les banques et les boutiques quantitatives – Goldman Sachs, JPMorgan, HSBC, et des spécialistes comme Multiverse Computing parmi elles – ont activement recherché et publié sur les méthodes quantiques et inspirées du quantique pour la tarification des dérivés, le risque Monte Carlo, et l'optimisation de portefeuille. La théorie est publique. Ce que presque personne n'a écrit, c'est comment la connecter à un agent autonome – un système qui perçoit, décide, exécute et apprend par lui-même. C'est ce que nous construisons ici.

2. Le dictionnaire quantique-marché

Avant tout code, vous avez besoin de la correspondance. Chaque concept quantique ci-dessous a un analogue de trading précis. Traitez cette section comme le contrat conceptuel pour tout ce qui suit.

L'amplitude de probabilité correspond à la conviction – mais avec une phase. Les probabilités classiques sont simplement des nombres non négatifs. Les amplitudes quantiques sont complexes : chacune porte une magnitude et un angle de phase. La phase est l'amélioration complète. C'est ce qui permet à deux signaux haussiers de s'interférer destructivement et de s'annuler, ou à deux signaux faibles de s'interférer constructivement en un signal fort. Un ensemble classique qui moyenne des probabilités positives ne peut physiquement pas faire cela – le mieux qu'il puisse faire est de diluer. La phase permet aux signaux de se vétoiser activement.

L'intrication correspond à une corrélation que vous ne pouvez pas factoriser. Lorsque deux actifs évoluent comme un régime lié – pensez à une grande cryptomonnaie et aux memecoins qui surfent sur sa liquidité – vous ne pouvez pas honnêtement décrire l'un sans l'autre. L'agent encode cela comme un état non séparable, qui capture le co-mouvement lié au régime qu'une matrice de corrélation statique a tendance à aplatir et à sous-estimer, en particulier dans les queues de distribution.

L'hamiltonien correspond à votre fonction de coût risque/rendement. En physique, l'hamiltonien H encode l'énergie d'un système. En trading, vous encodez votre objectif – maximiser le rendement attendu, minimiser la variance, respecter les limites de position et de budget – comme un paysage énergétique. Le portefeuille optimal est alors l'état fondamental : la configuration de plus basse énergie de H. La construction de portefeuille devient un problème de minimisation d'énergie, ce qui est un problème très bien étudié à résoudre.

La mesure et l'effondrement correspondent à l'exécution. Au moment où vous envoyez un ordre, la superposition s'effondre en un résultat réalisé. Le vrai travail de l'agent est de choisir quand et quoi mesurer pour que l'effondrement tende à atterrir sur une configuration rentable. Il y a même un principe de risque intégré par analogie avec Heisenberg : vous ne pouvez pas simultanément cerner le prix exact d'une position et son momentum exact avec une précision illimitée. Exiger plus de certitude sur l'un vous coûte de la certitude sur l'autre. C'est une analogie, pas une loi de la finance – mais c'est une analogie utile, et plus tard elle se transforme en une règle concrète de dimensionnement de position.

3. L'architecture d'un agent de trading quantique

L'agent est une boucle fermée de six modules. Le diagramme d'architecture joint à cet article montre le cycle complet ; voici ce que fait chaque étape.

1. Perception. Ingérer les données brutes du marché – carnet d'ordres, OHLCV, taux de financement, flux on-chain. Normaliser en un vecteur de caractéristiques x. C'est de la plomberie quanti ordinaire ; rien de quantique encore.

3. Constructeur d'hamiltonien. Traduire votre objectif risque/rendement plus les contraintes en un hamiltonien QUBO / Ising H. C'est là que les limites de budget, l'aversion au risque et les rendements attendus sont intégrés dans un paysage énergétique.

4. Solveur inspiré du quantique. Trouver l'état fondamental de H – la sélection d'actifs optimale – via le recuit simulé, un circuit QAOA sur un simulateur, ou un solveur à réseau de tenseurs. Ce module est votre optimiseur de portefeuille, et il est délibérément interchangeable.

5. Décision par mesure. Effondrer l'état en positions et tailles concrètes, avec la règle de style Heisenberg qui réduit l'exposition lorsque l'incertitude est élevée.

6. Exécution et retour d'information. Acheminer les ordres, observer le P&L réalisé, et mettre à jour les amplitudes. Le résultat mesuré devient le prior du lendemain – une boucle de renforcement qui permet à l'agent de s'adapter au lieu d'exécuter une stratégie figée.

4. Code : encoder le marché comme un état quantique

Nous utiliserons numpy pour les calculs d'état et nous nous appuierons sur les conventions qiskit / pennylane pour les parties inspirées du quantique. Rien ici n'a besoin de matériel quantique réel – cela tourne sur un ordinateur portable.

L'interférence est le point central, donc l'encodage doit permettre aux signaux de s'ajouter en nombres complexes avant de prendre les probabilités. Chaque modèle alpha contribue avec une amplitude complexe – la magnitude égale la conviction, la phase égale le timing ou l'alignement du régime – à chaque scénario de marché. Vous additionnez les contributions entre les modèles, et seulement ensuite appliquez la règle de Born.

1import numpy as np
2
3def combine_signals(contributions: np.ndarray) -> np.ndarray:
4    """
5    contributions : matrice complexe de forme [n_signaux, n_scenarios].
6                   |valeur| = conviction d'un modèle pour un scénario,
7                   angle   = sa phase (timing / alignement du régime).
8    retourne :    état normalisé |psi> sur les scénarios.
9    """
10    amplitudes = contributions.sum(axis=0)          # les signaux INTERFÈRENT ici
11    return amplitudes / np.linalg.norm(amplitudes)
12
13# Scénarios : [hausse, baisse, range, breakout]
14# Deux modèles de momentum penchent tous deux vers 'hausse' – mais ils sont déphasés, donc ils s'annulent partiellement.
15signal_A = np.array([0.7+0j, 0.1+0j, 0.2+0j, 0.3+0j])       # haussier, phase 0
16signal_B = np.array([0.6*np.exp(1j*2.7), 0.15, 0.2, 0.25])  # haussier mais ~antiphase
17
18psi = combine_signals(np.vstack([signal_A, signal_B]))
19
20# Probabilité de chaque scénario = |amplitude|^2  (règle de Born)
21probs = np.abs(psi) ** 2
22print(probs.round(3))   # -> [0.147 0.102 0.26 0.491]

La ligne clé est la règle de Born : la probabilité égale le carré de la magnitude de l'amplitude. Parce que les deux signaux haussiers sont additionnés en nombres complexes avant la mise au carré, leurs composantes déphasées s'annulent, et le scénario "hausse" encombré est réduit de 0.76 naïf à 0.147. L'agent estompe automatiquement un pari consensuel sur-correlé. C'est la différence concrète et mesurable entre cela et un simple ensemble de moyennes de probabilités, et le diagramme d'interférence joint à cet article montre les mêmes nombres côte à côte.

5. La partie difficile que personne ne vous montre : d'où vient la phase ?

Chaque fil de discussion qui vous vend du "trading quantique" code silencieusement les phases en dur et espère que vous ne le remarquerez pas. Dans l'extrait ci-dessus, j'ai écrit np.exp(1j\2.7) à la main. Dans un système réel, inventer la phase est tout le problème de recherche*, et prétendre le contraire est le moyen le plus rapide de se tromper soi-même.

Considérez donc la phase comme une cible de modélisation de première classe, pas une décoration. Voici quelques façons fondées de la dériver au lieu de deviner :

Phase de timing / cycle. Passez chaque signal à travers une transformée de Hilbert ou une décomposition en ondelettes et lisez la phase instantanée du cycle dominant. Deux modèles de momentum qui tirent dans la même direction mais sur des phases de cycle différentes devraient effectivement s'annuler partiellement – c'est exactement l'encombrement que vous voulez détecter.

Phase avance-retard. Estimez le décalage de corrélation croisée entre un signal et les rendements futurs. Convertissez ce décalage en un angle. Les signaux qui précèdent le prix reçoivent une phase ; les retardataires qui ne font que suivre en reçoivent une autre, de sorte qu'ils interfèrent destructivement avec les leaders au lieu de double-compter.

Phase de régime. Mappez un classifieur de régime (tendance vs range, volatilité haute vs basse) sur un angle de sorte que la contribution d'un signal tourne à mesure que le régime tourne. Un modèle de breakout et un modèle de mean-reversion se retrouvent alors naturellement près de phases opposées.

La discipline est simple : si vous ne pouvez pas expliquer pourquoi un signal a la phase qu'il a, vous n'avez pas le droit d'utiliser la phase. Revenez à la phase 0 pour tout, et vous revenez à un ensemble classique – ce qui est bien et honnête. La phase est puissante précisément parce qu'elle est durement gagnée.

6. Code : le portefeuille comme recherche d'état fondamental

La sélection de portefeuille sous contraintes est de l'optimisation combinatoire – choisir le meilleur sous-ensemble d'actifs soumis à un budget et des limites de risque. C'est exactement le type de problème pour lequel le recuit a été conçu. Nous encodons "quels actifs détenir" comme un QUBO (Quadratic Unconstrained Binary Optimization), le jumeau classique d'un hamiltonien d'Ising.

1import numpy as np
2
3def build_portfolio_hamiltonian(expected_returns, cov, risk_aversion=1.0,
4                                budget=3, penalty=5.0):
5    """
6    Construit une matrice QUBO Q de sorte que minimiser x^T Q x  (x dans {0,1}^n)
7    sélectionne les meilleurs 'budget' actifs : maximiser le rendement, minimiser le risque,
8    et pénaliser doucement le non-respect de la contrainte de budget.
9    """
10    n = len(expected_returns)
11    Q = np.zeros((n, n))
12
13    # rendement (inversé, car on minimise) plus un terme de risque de la covariance
14    for i in range(n):
15        Q[i, i] += -expected_returns[i] + risk_aversion * cov[i, i]
16        for j in range(i + 1, n):
17            Q[i, j] += 2 * risk_aversion * cov[i, j]
18
19    # contrainte de budget (somme x_i - budget)^2 comme pénalité douce
20    for i in range(n):
21        Q[i, i] += penalty * (1 - 2 * budget)
22        for j in range(i + 1, n):
23            Q[i, j] += 2 * penalty
24    return Q
25
26def simulated_anneal(Q, steps=20000, T0=5.0):
27    """Recuit inspiré du quantique : refroidir lentement le système dans son état fondamental."""
28    n = Q.shape[0]
29    x = np.random.randint(0, 2, n)
30    def energy(x): return x @ Q @ x
31    e = energy(x)
32    for t in range(steps):
33        T = T0 * (1 - t / steps)                 # programme de température linéaire
34        i = np.random.randint(n)
35        x_new = x.copy(); x_new[i] ^= 1          # retourner un actif dedans/dehors
36        e_new = energy(x_new)
37        # toujours accepter les améliorations, et parfois les mauvais mouvements (c'est ainsi qu'il échappe aux minima locaux)
38        if e_new < e or np.random.rand() < np.exp(-(e_new - e) / max(T, 1e-9)):
39            x, e = x_new, e_new
40    return x, e
41
42returns = np.array([0.12, 0.09, 0.15, 0.04, 0.11])
43cov = np.array([
44    [0.10, 0.02, 0.01, 0.00, 0.03],
45    [0.02, 0.08, 0.02, 0.01, 0.01],
46    [0.01, 0.02, 0.18, 0.00, 0.02],
47    [0.00, 0.01, 0.00, 0.03, 0.00],
48    [0.03, 0.01, 0.02, 0.00, 0.09],
49])
50Q = build_portfolio_hamiltonian(returns, cov, risk_aversion=2.0, budget=2)
51selection, ground_energy = simulated_anneal(Q)
52print("Conserver les actifs :", np.where(selection == 1)[0], "| énergie :", round(ground_energy, 3))

Une note honnête sur l'échelle. Avec cinq actifs, vous n'avez pas besoin de recuit – vous pourriez énumérer toutes les 32 combinaisons par force brute. Le recuit mérite sa place à des centaines d'actifs avec des contraintes dures, où l'espace de recherche explose et les solveurs exacts s'étouffent. La raison de l'écrire ainsi à petite échelle est que l'interface ne change jamais : remplacez simulated_anneal par un backend réel – le recuit de D-Wave, un circuit QAOA sur un simulateur Qiskit, ou un solveur à réseau de tenseurs du genre de ceux que Multiverse livre – et rien d'autre dans l'agent ne bouge. Le solveur est un plugin.

7. Code : la boucle de l'agent (perception à effondrement à exécution)

Maintenant, câblez le tout. Voici le squelette d'un agent autonome – la même boucle de contrôle percevoir/décider/agir qu'un agent LLM utilise, mais avec un état de style quantique comme modèle du monde au lieu de texte.

1class QuantumTradingAgent:
2    def __init__(self, universe, risk_aversion=2.0, budget=2, gross_leverage=1.0):
3        self.universe = universe
4        self.risk_aversion = risk_aversion
5        self.budget = budget
6        self.gross_leverage = gross_leverage
7        self.memory = []                     # tampon de retour d'information / RL
8
9    def perceive(self, market):
10        contributions = self.model_conviction(market)   # vos modèles alpha -> matrice complexe
11        return combine_signals(contributions)            # -> état |psi> sur les scénarios
12
13    def deliberate(self, market):
14        Q = build_portfolio_hamiltonian(
15            market["expected_returns"], market["cov"],
16            self.risk_aversion, self.budget)
17        selection, _ = simulated_anneal(Q)
18        return selection
19
20    def measure(self, psi, selection, market):
21        """
22        Effondrement en ordres. Deux choses se produisent ici :
23        1) une porte de CONVICTION globale issue de l'état des scénarios (directionnelle + réduction de volatilité Heisenberg)
24        2) un poids PAR ACTIF de sorte que les actifs choisis soient dimensionnés par leur propre rendement attendu
25        """
26        scenario_probs = np.abs(psi) ** 2
27        directional = scenario_probs[0] + scenario_probs[3]      # P(hausse) + P(breakout)
28        vol = market["volatility"]
29        gate = directional / (1.0 + self.risk_aversion * vol)   # réduire en forte volatilité / faible conviction
30
31        idx = np.where(selection == 1)[0]
32        if len(idx) == 0:
33            return {}
34        edge = np.clip(market["expected_returns"][idx], 0, None) # seulement les noms à bord positif long
35        weights = edge / edge.sum() if edge.sum() > 0 else np.ones(len(idx)) / len(idx)
36
37        sizes = self.gross_leverage * gate * weights
38        return {int(a): round(float(s), 4) for a, s in zip(idx, sizes)}
39
40    def act(self, market):
41        psi = self.perceive(market)
42        selection = self.deliberate(market)
43        orders = self.measure(psi, selection, market)
44        # execute(orders)   <- acheminer vers l'échange / le courtier ici
45        self.memory.append((market, orders))
46        return orders

Regardez attentivement measure(), car la version naïve précédente avait un vrai défaut : elle appliquait une taille identique à chaque actif sélectionné, ignorant à quel point chacun était bon. Cette version le corrige avec deux étapes. Une porte globale lit l'état des scénarios – la conviction directionnelle, soit P(hausse) + P(breakout), divisée par un terme de volatilité. Cette division est la règle de style Heisenberg qui fait la gestion du risque : plus le marché résiste à une tarification précise, c'est-à-dire plus la volatilité est élevée, plus l'engagement total de l'agent est petit. Ensuite, un poids par actif distribue ce budget entre les noms sélectionnés proportionnellement à leur propre bord attendu, et refuse de prendre une position longue sur quoi que ce soit avec un rendement attendu négatif. La conviction fixe combien vous pariez ; le bord par actif fixe où cela va.

8. Le test de réalité de Wall Street

Où cela gagne-t-il réellement de l'argent, et où est-ce une belle démo ? Être spécifique ici est ce qui rend le reste crédible.

Avantage réel aujourd'hui, sur du matériel classique :

Optimisation de portefeuille à grande échelle. Avec des centaines d'actifs et des contraintes dures, les recuits et les méthodes à réseau de tenseurs gèrent la combinatoire et les contraintes plus élégamment que les solveurs naïfs de variance moyenne, et souvent plus rapidement. C'est l'application la plus mature, la moins sujette au battage médiatique.

Estimation du risque via l'estimation d'amplitude quantique. En théorie, cela offre une accélération quadratique par rapport au Monte Carlo classique pour la VaR et la CVaR. C'est l'une des directions de recherche les plus activement poursuivies dans les grandes banques, car les exécutions de risque sont coûteuses et tournent constamment. Notez la mise en garde : l'accélération annoncée est un résultat asymptotique théorique, et le matériel d'aujourd'hui ne la réalise pas encore à l'échelle de la production.

Combinaison de signaux par interférence. Modéliser la conviction avec une phase de sorte que les transactions encombrées et sur-correlées s'annulent est un recadrage véritablement utile, et cela fonctionne sur votre GPU existant aujourd'hui. C'est l'idée la plus immédiatement pratique de cet article – à condition de résoudre honnêtement le problème de la phase de la section 5.

Encore principalement de la recherche :

Tarification de dérivés de bout en bout sur du matériel quantique réel. Prometteur en principe, mais le bruit et le nombre de qubits le limitent aujourd'hui.

Prédiction de prix "ML quantique". Lourdement surfait. Le coût de chargement des données de marché classiques dans un état quantique mange généralement toute accélération que vous espériez gagner. Soyez très sceptique envers quiconque vend cela.

Le résultat honnête : l'agent inspiré du quantique est constructible et backtestable dès maintenant, car chaque module tourne sur du matériel classique. Vous capturez les idées structurelles – une superposition d'hypothèses, une interférence destructive contre l'encombrement, une optimisation basée sur l'hamiltonien – sans attendre les ordinateurs quantiques tolérants aux pannes. Lorsque le matériel mûrira, vous remplacez le module 4 et gardez le reste.

9. Ce qui tuera réellement cela en production

Chaque stratégie semble brillante jusqu'à ce qu'elle rencontre le marché. Avant de risquer un dollar, intériorisez les quatre choses qui détruisent silencieusement les agents inspirés du quantique en particulier.

Coûts de transaction et slippage. La couche d'interférence remanie la conviction à chaque nouvelle donnée, ce qui tente l'agent à retourner son carnet. Les frais et le slippage ne se soucient pas de l'élégance de votre vecteur d'état. Ajoutez une pénalité de rotation directement dans l'hamiltonien et relancez – de nombreux "avantages" s'évaporent dès que des coûts réalistes sont facturés.

Surapprentissage des phases. La phase vous donne tout un ensemble supplémentaire de paramètres libres, et les paramètres libres sont la façon dont les backtests mentent. Il est trivialement facile de régler les phases jusqu'à ce que l'année dernière imprime de l'argent et que l'année prochaine saigne. Fixez les règles de phase à partir de la théorie (section 5) avant de regarder les rendements, et ne laissez jamais le backtest les choisir pour vous.

Data-snooping à travers la boucle. Parce que c'est une boucle de rétroaction fermée, la fuite se cumule. Si votre modèle de conviction, votre estimation de covariance, ou vos étiquettes de régime jettent ne serait-ce qu'un léger coup d'œil dans le futur, l'agent entier hérite du mensonge. Testez en marche avant la boucle entière, pas seulement le signal isolément.

Fragilité de la covariance face au régime. Le QUBO s'appuie sur une matrice de covariance, et les covariances explosent exactement quand vous en avez besoin – lors d'un krach, les corrélations convergent vers un. Testez la sélection de l'état fondamental sous une covariance choquée, pas seulement celle du marché calme, sinon l'optimiseur vous remettra joyeusement un portefeuille diversifié uniquement sur le papier.

10. Votre liste de contrôle de construction

Si vous voulez réellement livrer cela, voici l'ordre des opérations.

Commencez par le solveur inspiré du quantique – numpy simple plus recuit simulé. Pas de matériel, pas de comptes, pas de dépendances.

Remplacez les amplitudes ajustées à la main par un modèle de conviction appris alimentant combine_signals, et dérivez les phases de la théorie plutôt que de les ajuster.

Backtestez la boucle entière, avec les coûts, pas seulement le signal. Facturez des frais et un slippage réalistes, ajoutez une pénalité de rotation, et avancez-la en marche avant. La logique d'interférence et de dimensionnement est là où se cachent à la fois l'avantage et l'auto-illusion.

Ce n'est qu'après que l'abstraction a fait ses preuves en simulation que vous devriez chercher un vrai backend – d'abord un simulateur Qiskit ou PennyLane, puis D-Wave, puis le matériel. Remplacer le module 4 est un changement d'une ligne par conception.

Le marché a toujours été une onde de probabilité. Presque tout le monde le trade encore comme un nombre unique – et l'écart entre ces deux vues est toute l'opportunité.

Si cela a changé votre façon de penser les marchés, repostez le haut et suivez-moi. Le dépôt complet de l'agent open source arrive la semaine prochaine. ⚛️

Avertissement. Ce n'est pas un conseil financier, et ce n'est pas une promesse de rendements. Inspiré du quantique ne signifie pas garanti quantique – la majeure partie de ce qui fait fonctionner cela est une modélisation classique disciplinée portant un manteau quantique. Backtestez tout avec des coûts réels ; le marché effondre votre fonction d'onde, que vous soyez prêt ou non.