Le goulot d’étranglement caché de l’apprentissage automatique quantique : importer des données dans un ordinateur quantique

• Comment les réseaux de neurones classiques lisent les données
• Les ordinateurs quantiques ne peuvent pas lire les bits
• Intégration de données classiques dans des états quantiques
• Le goulot d’étranglement du chargement des données dans l’apprentissage automatique quantique
• Conclusion

L’intelligence artificielle (IA) et l’apprentissage automatique (ML) modernes s’appuient fortement sur le traitement de grands volumes de données et sur les modèles d’apprentissage qui en découlent. En général, un La capacité du modèle à généraliser s’améliore à mesure que la quantité de données disponibles augmente. Cependant, lorsque nous passons de l’apprentissage automatique classique au Quantum Machine Learning (QML), l’un des premiers défis majeurs que nous rencontrons est que les ordinateurs quantiques ne peuvent pas lire directement les bits classiques. Avant qu’un calcul puisse avoir lieu, les données doivent d’abord être intégrées dans des états quantiques (qubits).

Cela peut paraître simple au premier abord, mais en pratique, cela s’avère étonnamment difficile. À mesure que la taille et la complexité des données augmentent, le coût de préparation de ces états quantiques peut croître de façon exponentielle. En fait, aucune méthode universellement efficace pour charger des données classiques arbitraires dans des systèmes quantiques n’est actuellement connue.

Dans cet article, nous explorerons pourquoi ce problème existe, examinerons certaines techniques courantes d’intégration de données quantiques et enfin discuterons de quelques approches modernes que les chercheurs étudient pour surmonter ces limitations.

Comment les réseaux de neurones classiques lisent les données

Les réseaux de neurones (NN) sont l’un des éléments fondamentaux de l’apprentissage automatique moderne. Une grande partie de leur succès vient de notre capacité croissante à collecter, stocker et traiter d’énormes quantités de données.

À la base, les réseaux de neurones sont des systèmes mathématiques conçus pour apprendre des modèles à partir de données. Au cours de la formation, ils ajustent progressivement leurs paramètres internes pour capturer les relations qui ont généré les données en premier lieu. Cela leur permet d’effectuer des tâches telles que la prédiction, la génération et la classification.

Par exemple:

• prédire les cours futurs des actions à partir des tendances historiques,
• générer du texte de type humain,
• identifier des objets dans des images,
• ou faire la distinction entre différentes catégories de données.

L’une des plus grandes forces des réseaux de neurones classiques est leur flexibilité. Ils peuvent traiter de nombreux types de données différents et apprendre les relations qui existent en leur sein :

• Données séquentielles → langue, séries temporelles financières, signaux audio
• Données spatiales → images, vidéos, cartes géographiques
• Données probabilistes ou bruitées → mesures de capteurs, désintégration radioactive, observations expérimentales

Bien qu’ils soient capables de gérer de nombreux types de données différents, les réseaux de neurones ne « voient » pas directement les images, l’audio ou le texte comme le font les humains. Sous le capot, tout est finalement converti en vecteurs ou tenseurs numériques avant d’être traité par le réseau.

Par exemple:

• Une image peut être représentée sous la forme d’une grille de valeurs d’intensité de pixels
• Une phrase peut être convertie en intégrations de jetons
• Un signal audio peut être représenté comme une séquence d’amplitudes échantillonnées dans le temps

Pour un réseau neuronal, tout cela est simplement une représentation numérique structurée.

Les ordinateurs quantiques ne peuvent pas lire les bits

Les ordinateurs quantiques constituent une manière fondamentalement différente de traiter l’information. Au lieu d’opérer sur des bits classiques, ils utilisent des bits quantiques, ou qubitsqui suivent les principes de la mécanique quantique tels que la superposition et l’intrication.

Un bit classique est une valeur binaire qui vaut 0 ou 1.

Un qubit, cependant, peut exister simultanément dans une superposition des deux états. Un état général d’un qubit s’écrit généralement comme :

|ψ⟩ = α |0⟩ + β |1⟩ où α et β sont des amplitudes de probabilité complexes satisfaisant la contrainte : |α|² + |β|² = 1.

Si certains de ces concepts ne vous semblent pas familiers, vous pouvez vous référer à mes articles sur l’informatique quantique destinés aux débutants. ici. Cependant, pour cet article, l’idée importante est simplement que les ordinateurs quantiques stockent les informations très différemment des ordinateurs classiques.

Puisque nous vivons dans un monde classique, la plupart de nos données existent naturellement sous forme de bits stockés dans la mémoire classique. Un processeur quantique ne peut pas lire directement une image, une phrase ou une forme d’onde audio comme le peut un réseau neuronal fonctionnant sur un GPU. Avant qu’un calcul quantique puisse avoir lieu, ces informations classiques doivent être codées en qubits. – une tâche qui s’avère bien plus difficile qu’il n’y paraît.

Intégration de données classiques dans des états quantiques

L’information classique doit d’une manière ou d’une autre être traduite en états quantiques. Ce processus est connu sous le nom intégration de données quantiques ou préparation d’état quantique. Les moyens possibles d’y parvenir sont les amplitudes, les phases ou les rotations des qubits.
Au fil des années, les chercheurs ont proposé plusieurs approches pour intégrer des données classiques dans des systèmes quantiques. Deux des techniques les plus couramment utilisées sont :

• Codage basé sur l’angle
• Codage d’amplitude

Chaque approche présente ses propres avantages, limites et coûts de calcul.

Codage basé sur l’angle

L’une des approches les plus simples et les plus largement utilisées pour l’intégration de données quantiques est codage d’angle (aussi appelé intégration basée sur la rotation).

Dans cette méthode, les caractéristiques classiques sont codées sous forme d’angles de rotation appliqués aux qubits à l’aide de portes quantiques telles que RX, RY et RZ qui font tourner un qubit le long des axes X, Y et Z respectivement.
Par exemple, un vecteur classique : X = [x₁, x₂, x₃] peut être intégré dans un circuit quantique en faisant tourner différents qubits en fonction de la valeur de chaque caractéristique.

Examinons une implémentation simple d’un codage basé sur la rotation dans PennyLane :

import pennylane as qml
import numpy as np

# Classical input vector
x = np.array([0.2, 0.7, 1.1])

n_qubits = len(x)
dev = qml.device("default.qubit", wires=n_qubits)

@qml.qnode(dev)
def rotational_embedding_circuit(x):
    # Each feature x_i rotates one qubit
    qml.AngleEmbedding(
        features=x,
        wires=range(n_qubits),
        rotation="Y"   # can also be "X" or "Z"
    )

    return qml.state()

state = rotational_embedding_circuit(x)

qml.draw_mpl(rotational_embedding_circuit, style='pennylane_sketch')(x)
print(state)

L’un des principaux inconvénients du codage basé sur la rotation est sa faible évolutivité par rapport au nombre de qubits. En général, nous avons besoin d’autant de qubits qu’il y a de caractéristiques dans le vecteur d’entrée.

Encodage basé sur l’amplitude

Le codage basé sur l’amplitude est une autre technique permettant d’intégrer des données classiques dans des systèmes quantiques. Contrairement au codage basé sur la rotation, où chaque fonctionnalité contrôle la rotation d’un qubit, le codage d’amplitude stocke les informations directement dans les amplitudes d’un état quantique, par exemple les termes α et β dans |ψ⟩ = α |0⟩ + β |1⟩.

Par exemple:

X = [x₁, x₂, x₃, x₄] peut être codé en utilisant log₂(|X|) = 2

qubits comme :

∣ψ(x)⟩= x₁∣00⟩ + x₂∣01⟩ + x₃∣10⟩ + x₄∣11⟩.

Ceci est nettement plus compact que le codage basé sur la rotation que nous avons vu précédemment.

En fait, c’est l’une des idées les plus fascinantes de l’informatique quantique, car le nombre d’amplitudes augmente de façon exponentielle avec le nombre de qubits.

Par exemple:

• 2 qubits → 2² = 4 amplitudes
• 10 qubits → 2¹⁰ = 1024 amplitudes
• 20 qubits → plus d’un million d’amplitudes

Cela signifie qu’un système à n qubits est décrit par des amplitudes de 2ⁿ, conduisant à un espace d’états à croissance exponentielle.

En conséquence, le codage en amplitude est exponentiellement plus efficace en termes d’espace que le codage basé sur la rotation. Au lieu de nécessiter un qubit par fonctionnalité, cela ne nécessite qu’environ : log₂(n) qubits pour n fonctionnalités.

Examinons maintenant une implémentation simple du codage d’amplitude dans PennyLane :

import pennylane as qml
import numpy as np

# Classical input vector
x = np.array([0.2, 0.4, 0.6, 0.8])

# Amplitude encoding needs a normalized vector
x = x / np.linalg.norm(x)

# Number of qubits needed:
# 2 qubits can represent 2^2 = 4 amplitudes
n_qubits = int(np.log2(len(x)))

dev = qml.device("default.qubit", wires=n_qubits)

@qml.qnode(dev)
def amplitude_encoding_circuit(x):
    qml.AmplitudeEmbedding(
        features=x,
        wires=range(n_qubits),
        normalize=True
    )

    return qml.state()

state = amplitude_encoding_circuit(x)

qml.draw_mpl(amplitude_encoding_circuit, style='pennylane_sketch')(x)
print(state)

Si vous êtes aussi méfiant que moi, vous pensez peut-être déjà :

« Cela a l’air trop beau pour être vrai. »

Et vous auriez raison. Bien que le codage en amplitude nous permette de représenter de manière exponentielle plus de données que le codage en angle, la préparation de tels états quantiques nécessite généralement un nombre exponentiellement élevé d’opérations.

La représentation est exponentiellement compacte.
Le processus de chargement ne l’est généralement pas.

Le tableau suivant compare les deux approches de codage :

Le goulot d’étranglement du chargement des données dans l’apprentissage automatique quantique

Les systèmes modernes d’apprentissage automatique fonctionnent avec des données extrêmement volumineuses et de grande dimension. Les images peuvent contenir des millions de pixels, les signaux audio peuvent s’étendre sur des milliers de pas de temps et les modèles de langage modernes fonctionnent sur des vecteurs d’intégration massifs.

Nous avons examiné deux approches fondamentales pour intégrer des données classiques dans des systèmes quantiques. Bien que le codage en amplitude semble théoriquement attrayant en raison de sa compacité exponentielle, le processus de préparation réelle de tels états quantiques devient de plus en plus difficile à mesure que la taille des données augmente.

Cela crée l’un des plus grands goulots d’étranglement pratiques du Quantum Machine Learning :

Le chargement d’informations classiques dans un système quantique peut lui-même devenir coûteux en termes de calcul.

Dans de nombreux cas, le coût de la préparation de l’État peut compenser partiellement ou totalement les avantages théoriques promis par les algorithmes quantiques.

Il s’agit d’une subtilité importante qui est souvent négligée dans les discussions autour de l’apprentissage automatique quantique. De nombreux articles de recherche accordent très peu d’attention au fait que :

Un modèle quantique peut traiter des informations dans un espace de Hilbert exponentiellement grand, mais avant qu’un calcul puisse avoir lieu, les données doivent d’abord être intégrées efficacement dans cet espace.

Et cela s’avère être un problème extrêmement difficile.

Pour les données classiques arbitraires, aucune méthode de préparation d’état quantique universellement efficace n’est actuellement connue. En fait, la préparation d’un état quantique complètement général nécessite souvent un nombre exponentiel d’opérations quantiques.

Cela crée un compromis fascinant :

• Le codage basé sur la rotation est relativement facile à mettre en œuvre mais s’adapte mal au nombre de qubits.
• Le codage d’amplitude est exponentiellement compact mais peut être exponentiellement coûteux à préparer.

Autrement dit:

Le problème de représentation et le problème de chargement ne sont pas la même chose.

Un ordinateur quantique est peut-être capable de représenter des quantités d’informations exponentiellement importantes, mais charger efficacement ces informations dans le système quantique constitue un défi fondamentalement différent.

En outre, au cours du processus d’intégration, d’importantes relations structurelles présentes dans les données originales – telles que les relations spatiales dans les images ou les dépendances temporelles dans les données séquentielles – peuvent également devenir difficiles à préserver naturellement dans les représentations quantiques.

Conclusion

L’apprentissage automatique quantique promet l’accès à des espaces de représentation exponentiellement grands, mais avant qu’un calcul puisse avoir lieu, les informations classiques doivent d’abord être intégrées efficacement dans les systèmes quantiques.

Comme nous l’avons exploré dans cet article, cela s’avère bien plus difficile qu’il n’y paraît au départ. Alors que des méthodes telles que le codage en amplitude offrent des représentations extrêmement compactes, le processus de préparation d’états quantiques arbitraires lui-même peut devenir coûteux en termes de calcul.

Cela a fait du chargement de données quantiques l’un des principaux goulots d’étranglement pratiques de la recherche moderne sur QML. De nombreuses discussions autour de l’apprentissage automatique quantique se concentrent fortement sur la puissance des espaces de Hilbert exponentiellement grands tout en accordant beaucoup moins d’attention au coût pour atteindre réellement ces états – presque comme dire :

« Nous pouvons faire du thé au sommet de la montagne, mais comment y arriver est un autre problème. »

Les chercheurs explorent désormais activement de nouvelles approches telles que les intégrations quantiques apprises, les techniques de rechargement de données et les intégrations préservant la structure pour surmonter certaines de ces limitations. Même les grandes entreprises comme IA quantique de Google ont récemment exploré des stratégies d’intégration et de représentation plus efficaces pour les systèmes d’apprentissage automatique quantique.

Nous pourrions explorer certaines de ces approches dans de prochains articles.

Merci d’avoir lu!

Clause de non-responsabilité:

Cet article a été affiné grammaticalement avec l’aide de grands modèles linguistiques (LLM). Toutes les illustrations de cet article ont été créées par l’auteur à l’aide des outils de génération d’images GPT et Gemini, tandis que les schémas de circuits quantiques ont été générés à l’aide de PennyLane.

Version 1.1