Cet article s’inspire du workshop « QML4Africa » que j’ai suivi lors du Deep Learning Indaba à Kigali, Rwanda. À travers des séances pratiques utilisant Qiskit et d’autres outils quantiques, ce workshop m’a ouvert les portes de l’informatique quantique et de l’apprentissage quantique (QML).
L’apprentissage profond repose sur des réseaux de neurones artificiels, composés de couches successives de neurones interconnectés. Chaque neurone effectue une combinaison linéaire pondérée de ses entrées, suivie d’une fonction d’activation non linéaire :
\[ y = \sigma(\mathbf{w}^\top \mathbf{x} + b), \]
où \(\mathbf{x}\) est le vecteur d’entrée, \(\mathbf{w}\) les poids, \(b\) un biais, et \(\sigma\) une fonction comme ReLU ou la sigmoïde. Grâce au théorème d'approximation universelle, un réseau suffisamment profond peut approximer n’importe quelle fonction continue — ce qui explique en partie son succès spectaculaire dans des domaines aussi variés que la vision par ordinateur, le traitement du langage naturel ou la bioinformatique.
L’entraînement de ces modèles s’appuie sur la descente de gradient : les poids sont ajustés pour minimiser une fonction de perte \(\mathcal{L}\), comme l’erreur quadratique moyenne ou l’entropie croisée. La rétropropagation (backpropagation), fondée sur la règle de la chaîne, permet de calculer efficacement les gradients, rendant possible l’optimisation de réseaux comptant des milliards de paramètres. En pratique, on utilise souvent des variantes stochastiques comme SGD (Stochastic Gradient Descent) ou Adam, qui opèrent sur des mini-lots de données pour équilibrer stabilité et efficacité.
Pourtant, malgré ces succès, le deep learning classique bute sur des limites structurelles :
Ce constat ouvre la voie à l’exploration de paradigmes alternatifs, capables de mieux exploiter la structure intrinsèque des données.
Le deep learning classique opère dans un espace euclidien discret, où chaque dimension est indépendante et les interactions entre variables doivent être apprises couche après couche. Cette approche peine à modéliser naturellement des corrélations non locales, des symétries globales ou des structures topologiques complexes.
C’est ici qu’intervient l’apprentissage quantique (Quantum Machine Learning, QML). Grâce à la superposition et à l’intrication, le QML encode les données dans un espace plus riche que celui du deep learning classique — un espace dit de Hilbert — ce qui permet de capturer des structures complexes avec moins de ressources.
Et si on remplaçait les neurones par des circuits quantiques ?
Cette question n’est plus purement spéculative. Elle ouvre la voie à une nouvelle génération de modèles d’intelligence artificielle, plus compacts, plus expressifs, et capables de résoudre des problèmes inaccessibles aux approches classiques.
Mais pour comprendre cette révolution, il faut d’abord se familiariser avec les briques de base du calcul quantique.
Dans un ordinateur classique, l’information est stockée dans des bits (0 ou 1).
Dans un ordinateur quantique, on utilise des qubits. Un qubit peut être dans un état de superposition :
\[ |\psi\rangle = \alpha |0\rangle + \beta |1\rangle, \quad \text{avec} \quad |\alpha|^2 + |\beta|^2 = 1. \]
Tant qu’on ne le mesure pas, le qubit « contient » les deux valeurs simultanément. À la mesure, il s’effondre en 0 (probabilité \(|\alpha|^2\)) ou en 1 (probabilité \(|\beta|^2\)).
Analogie : une pièce lancée en l’air est « pile et face à la fois ». Ce n’est qu’en la rattrapant (mesure) qu’elle devient l’un ou l’autre.
On ne peut pas connaître \(\alpha\) et \(\beta\) directement. Mais on peut estimer la valeur moyenne (expectation value) d’un observable, comme l’opérateur de Pauli \(Z = \begin{bmatrix} 1 & 0 \\ 0 & -1 \end{bmatrix}\) :
\[ \langle Z \rangle = \langle \psi | Z | \psi \rangle = |\alpha|^2 - |\beta|^2 \in [-1, +1]. \]
Cette valeur continue est la sortie typique d’un circuit quantique en apprentissage.
Important : pour estimer \(\langle Z \rangle\), on exécute le circuit plusieurs fois et on fait la moyenne des résultats (0 ou 1). C’est ce qu’on appelle une estimation empirique.
Les portes quantiques sont des transformations réversibles appliquées aux qubits. Elles sont représentées par des matrices unitaires. Voici les plus utilisées en QML :
\[ H = \frac{1}{\sqrt{2}} \begin{bmatrix} 1 & 1 \\ 1 & -1 \end{bmatrix} \quad \Rightarrow \quad H|0\rangle = \frac{|0\rangle + |1\rangle}{\sqrt{2}} \]
Elle transforme un état classique en superposition égale.
Un qubit peut être vu comme un point sur la sphère de Bloch. Les portes de rotation permettent de le faire tourner autour des axes X, Y ou Z :
\[ R_x(\theta) = \begin{bmatrix} \cos(\theta/2) & -i\sin(\theta/2) \\ -i\sin(\theta/2) & \cos(\theta/2) \end{bmatrix}, \quad R_y(\theta) = \begin{bmatrix} \cos(\theta/2) & -\sin(\theta/2) \\ \sin(\theta/2) & \cos(\theta/2) \end{bmatrix} \]
\[ R_z(\theta) = \begin{bmatrix} e^{-i\theta/2} & 0 \\ 0 & e^{i\theta/2} \end{bmatrix} \]
En QML, les angles de rotation sont les paramètres entraînables (comme les poids dans un réseau de neurones).
Par exemple, pour encoder une donnée \(x_i \in [0, \pi]\), on applique souvent la porte \(R_y(x_i)\) à un qubit initialement dans l’état \(|0\rangle\) :
\[ R_y(x_i)|0\rangle = \cos\left(\frac{x_i}{2}\right)|0\rangle + \sin\left(\frac{x_i}{2}\right)|1\rangle. \]
La porte CNOT (Controlled-NOT) agit sur deux qubits :
Son action sur une superposition crée de l’intrication :
\[ \text{CNOT} \left( \frac{|0\rangle + |1\rangle}{\sqrt{2}} \otimes |0\rangle \right) = \frac{|00\rangle + |11\rangle}{\sqrt{2}}. \]
Cet état ne peut pas être séparé en deux qubits indépendants. L’intrication permet de modéliser des corrélations globales impossibles à capturer avec des neurones classiques indépendants.
Un circuit quantique est une séquence d’opérations (portes) appliquées à un ou plusieurs qubits, suivie d’une mesure. On le représente comme un diagramme temporel :
q0: ──H──Ry(x1)──●──Rx(θ)──M──
│
q1: ─────Ry(x2)──X──────────M──
En QML, on construit des circuits paramétrés : certaines portes contiennent des paramètres ajustables (\(\theta\)), que l’on va optimiser pendant l’entraînement.
Un neurone reçoit des entrées \(x_1, \dots, x_n\), les combine linéairement avec des poids \(w_i\), ajoute un biais \(b\), puis applique une activation non linéaire :
\[ y = \sigma\left( \sum_{i=1}^n w_i x_i + b \right) = \sigma(\mathbf{w}^\top \mathbf{x} + b). \]
Ce mécanisme fonctionne bien, mais il est intrinsèquement local et linéaire par morceaux. Pour capturer des dépendances complexes, il faut empiler des couches — ce qui conduit à des architectures massives.
Dans un modèle quantique, l’unité de base n’est plus le bit, mais le qubit. Grâce à la superposition, un petit nombre de qubits peut représenter exponentiellement plus d’informations qu’un nombre équivalent de bits classiques.
La première étape consiste à encoder les données classiques dans un état quantique. L’encodage angulaire est une méthode courante : chaque caractéristique \(x_i \in [0, \pi]\) devient l’angle d’une rotation \(R_y(x_i)\).
Chaque caractéristique \(x_i \in [0, \pi]\) devient l’angle d’une rotation :
\[ R_y(x_i)|0\rangle = \cos\left(\frac{x_i}{2}\right)|0\rangle + \sin\left(\frac{x_i}{2}\right)|1\rangle. \]
Pour les données de grande dimension, on empile des blocs de rotations (Rx, Rz, Rx…) sur plusieurs qubits, entrelacés avec des CNOT pour créer de l’intrication. Cela permet d’encoder des centaines de dimensions même avec peu de qubits.
On applique ensuite une séquence de portes paramétrées (rotations \(R_x, R_y, R_z\)) et des portes CNOT pour générer de l’intrication. Ces opérations permettent au circuit de capturer des corrélations non locales.
<En QML, la rétropropagation n’est pas applicable : les mesures intermédiaires détruiraient la superposition, rendant impossible le calcul de gradients classiques.
À la place, on utilise la règle du décalage de paramètre (parameter-shift rule). Pour une porte de la forme \(U(\theta) = e^{-i\theta G}\), où \(G\) est une matrice de Pauli (comme \(X\), \(Y\) ou \(Z\)), le gradient de la fonction de perte \(C(\theta)\) est :
\[ \frac{dC}{d\theta} = \frac{C\left(\theta + \frac{\pi}{2}\right) - C\left(\theta - \frac{\pi}{2}\right)}{2}. \]
Cette formule permet de calculer exactement le gradient en exécutant deux fois le même circuit — sans perturber l’état quantique. C’est une méthode élégante, robuste, et parfaitement adaptée aux simulateurs et aux processeurs quantiques actuels.
Le problème XOR est un classique de l’apprentissage automatique :
– Entrées : (0,0) → 0 ; (0,1) → 1 ; (1,0) → 1 ; (1,1) → 0.
– Les points de même classe ne sont pas linéairement séparables.
Un perceptron classique échoue. Il faut au moins deux couches pour résoudre ce problème.
En QML, un circuit à un seul qubit suffit :
Avec \(\theta_1 = \theta_2 = \pi\) et \(\alpha = -\pi/2\), ce circuit classe parfaitement les quatre cas. Le « secret » réside dans la phase quantique introduite par \(R_z\) : elle permet de distinguer les cas (0,0)/(1,1) des cas (0,1)/(1,0), même si leurs amplitudes sont identiques.
Un seul « neurone quantique » remplace ici plusieurs neurones classiques.
Cet exemple théorique montre le potentiel expressif du QML, mais en pratique, les avantages ne se manifestent que pour des problèmes bien spécifiques, et les circuits quantiques actuels restent limités par le bruit et le nombre de qubits.
Aujourd’hui, la plupart des systèmes QML utilisent des architectures hybrides :
Ce paradigme permet de tirer parti du quantique là où il est utile, sans tout reconstruire depuis zéro. Des applications prometteuses émergent en :
Expérimentez par vous-même ! Vous n’avez pas besoin d’un ordinateur quantique pour commencer à explorer l’apprentissage quantique. Plusieurs outils open source, gratuits et bien documentés permettent de simuler des circuits quantiques sur votre propre machine :
Tous ces outils fonctionnent avec Python, disposent de tutoriels interactifs et de communautés actives. En quelques lignes de code, vous pouvez déjà encoder des données, entraîner un petit modèle hybride, et visualiser les résultats — le tout depuis un notebook Jupyter.
L’apprentissage quantique ne cherche pas à remplacer le deep learning, mais à compléter son arsenal là où celui-ci atteint ses limites. En combinant l’intuition géométrique du machine learning avec la puissance expressive de la mécanique quantique, le QML ouvre la voie à des modèles plus économes, plus intelligents, et mieux adaptés à des problèmes à données rares ou à structure complexe.
Même si les ordinateurs quantiques universels restent à l’horizon, le moment d’explorer cette frontière est maintenant.
Dans les prochains articles, je m’attacherai à reproduire des architectures classiques du deep learning (comme les perceptrons multicouches ou les réseaux convolutionnels) dans un cadre quantique, en les reformulant sous forme de circuits paramétrés. L’objectif sera de comprendre non seulement comment transposer ces modèles, mais surtout quand et pourquoi le quantique apporte un réel avantage.
Pour approfondir vos connaissances et explorer des outils avancés, voici quelques ressources :
Ma recommandation musicale du jour : à écouter sans modération !
Écouter sur YouTube