Introduction à l'apprentissage automatique quantique

Aperçu et motivation

Avant de commencer, merci de remplir ce court sondage pré-cours, qui est important pour nous aider à améliorer notre contenu et l'expérience utilisateur.

Bienvenue dans l'apprentissage automatique quantique !

La vidéo ci-dessous donnera une brève introduction qui est complétée par le texte ci-dessous.

Pour récapituler et compléter brièvement la vidéo :

• Nous avons vu un problème résolu pour la première fois sur un ordinateur quantique, puis des personnes ont trouvé une façon de le faire sur un superordinateur classique. Ce cycle d'informatique classique et quantique se repoussant mutuellement à leurs limites va probablement continuer pendant quelques années.
• Il existe des problèmes spécifiques où l'informatique quantique peut avoir un avantage démontrable sur l'informatique classique, étant donné des progrès dans des domaines tels que la réduction des erreurs et le nombre de qubits disponibles. Mais c'est toujours une période d'exploration, à la recherche d'ensembles de données adaptés au quantum et de cartes de caractéristiques quantiques utiles.
• L'apprentissage automatique quantique (QML) est l'un des nombreux domaines passionnants où l'informatique quantique peut augmenter ou compléter les flux de travail classiques existants.

L'apprentissage automatique (ML) applique des algorithmes à des ensembles de données, et le QML pourrait donc plausiblement inclure la mécanique quantique dans les données, les algorithmes, ou les deux. Toutes ces possibilités sont potentiellement intéressantes. Mais nous nous limiterons principalement aux discussions d'algorithmes quantiques appliqués à des données classiques. Une raison à cela est que les problèmes ML avec des données classiques sont déjà si bien étudiés et largement disponibles. Il y a un large intérêt pour résoudre des problèmes qui commencent avec des données classiques. Une autre raison est l'absence de QRAM. Sans la capacité de stocker de grandes quantités de données quantiques sur une échelle de temps relativement longue, les méthodes qui commencent avec des données quantiques sont encore assez loin d'être applicables à l'industrie. Il n'est également pas clair comment « accéder quantiquement » à des données classiques de manière efficace. Deux types de ML d'un intérêt particulier sont l'apprentissage supervisé, dans lequel on entraîne un algorithme en utilisant un ensemble de données étiqueté, et l'apprentissage non supervisé, dans lequel l'algorithme tente d'apprendre sur une distribution à partir d'échantillons non étiquetés. Un algorithme non supervisé pourrait, par exemple, apprendre à générer de nouveaux échantillons à partir de la même distribution, ou à regrouper les échantillons en groupes aux caractéristiques similaires.

L'image de gauche montre deux catégories de données étiquetées comme dans l'apprentissage supervisé. Dans ce cas, les catégories sont linéairement séparables. L'image de droite montre des clusters de données. Dans une tâche d'apprentissage non supervisé, ces données ne seraient pas initialement étiquetées et l'algorithme étudierait la distribution, cherchant peut-être des clusters. À des fins de visualisation des exemples de clusters que l'algorithme pourrait identifier, les points de données ont maintenant été étiquetés. Une différence clé entre les deux est que le processus d'apprentissage supervisé commence avec les données déjà étiquetées et le processus non supervisé commence avec des données non étiquetées, même si les données sont étiquetées à la fin.

Ceux ayant une formation en apprentissage automatique savent déjà que de nombreuses méthodes de résolution impliquent de mapper les données dans des espaces de dimension supérieure. C'est particulièrement bien exploré dans le contexte des noyaux. Pour rappel bref, parfois les données peuvent être séparables en catégories par une droite, un plan ou un hyperplan (nous dirons souvent simplement « hyperplan » par souci de concision), dans le même nombre de dimensions que les données. C'est montré dans la première image ci-dessus. D'autres fois, les données peuvent ne pas être séparables par un hyperplan dans ces dimensions, comme le montre la deuxième image. Mais il peut toujours y avoir une structure dans les données qui peut être exploitée dans un mappage vers des dimensions supérieures, ce qui rend alors les données séparables dans cet espace de dimension supérieure. Ceci est illustré par le mappage des données 2D avec une symétrie circulaire dans l'espace 3D dans lequel les points de données sont disposés le long d'une surface paraboloïde.

Un objectif commun dans le QML est de trouver un mappage de l'ensemble de caractéristiques de dimension inférieure vers un espace de dimension supérieure, qui sépare efficacement nos points de données de sorte que nous puissions utiliser le mappage pour classer de nouveaux points de données. Mais ce n'est pas une tâche facile, et toute discussion sur l'utilité potentielle de l'informatique quantique en apprentissage automatique doit être accompagnée des mises en garde appropriées. En particulier, nous devons aborder la nuance dans la sélection des ensembles de données et les défis pour atteindre l'échelle utilitaire. Nous devons aussi nous éloigner des tentatives de surpasser les algorithmes ML classiques sur des données déjà traitées efficacement et correctement par les algorithmes classiques, et recentrer la discussion sur l'exploration de nouvelles cartes de caractéristiques qui pourraient être utiles.

Gestion des attentes

De nombreux ensembles de données utilisés dans les applications QML décrites dans la littérature sont « ingéniés en caractéristiques » (feature-engineered), ce qui signifie qu'un ensemble de données est sélectionné ou généré spécifiquement pour montrer un cas d'utilisation étroit dans lequel l'informatique quantique est utile. Si cela semble être de la tromperie, c'est que l'on comprend mal la tâche en question. Il n'est pas le cas que certaines cartes de caractéristiques quantiques nous permettent de résoudre toutes ou beaucoup de tâches de classification plus efficacement ou de manière plus évolutive que les algorithmes d'apprentissage automatique classiques. Plutôt, certaines cartes de caractéristiques quantiques (pas toutes) se comportent différemment des cartes de caractéristiques classiques. La tâche consiste alors à explorer les circuits quantiques dans le contexte de structures de données complexes. Quelques questions spécifiques à aborder sont :

1. Quels circuits quantiques sont les plus susceptibles de se comporter de manière nouvelle, par rapport aux alternatives classiques ?
2. Existe-t-il des problèmes réels impliquant des données dont les propriétés sont mieux explorées à l'aide de tels circuits quantiques nouveaux ?
3. Ces circuits quantiques s'adaptent-ils sur des ordinateurs quantiques à court terme ?

Explication insuffisante

On rencontre souvent une explication simplifiée de la puissance potentielle de l'informatique quantique. Elle ressemble à ceci :

Tout comme les ordinateurs classiques utilisent des bits d'information, les ordinateurs quantiques utilisent des qubits. Étant donné un nombre de bits, disons 4, un ordinateur classique peut prendre l'un quelconque des $2^4 = 16$ états possibles, alors qu'un ordinateur quantique peut exister dans une superposition des 16 états simultanément, et des opérations peuvent être effectuées sur toute cette superposition. Dans certains cas, cela nous permet naturellement de concevoir des algorithmes d'apprentissage potentiellement intéressants basés sur des mappages vers des espaces de dimension supérieure.

C'est une affirmation vraie, mais elle est inadéquate et un peu trompeuse, comme nous allons l'expliquer. On voit aussi soulignées les différences entre les coefficients complexes et réels, comme dans :

Un système classique probabiliste dans lequel un système peut être décrit comme ayant certaines probabilités d'être dans différents états, peut être décrit comme suit.

$$|s\rangle = a|0000\rangle+b|0001\rangle+c|0010\rangle+... a, b, c \in \reals$$

Dans un tel système, les coefficients $a$, $b$, $c$, etc. ne peuvent être significatifs que s'ils sont des nombres réels positifs. Les états dans les ordinateurs quantiques sont décrits par des amplitudes de probabilité qui peuvent être des nombres complexes.

$$|\psi \rangle = A|0000\rangle+B|0001\rangle+C|0010\rangle+... A, B, C \in \mathbb{C}$$

Les affirmations ci-dessus ont été formulées très soigneusement de sorte qu'elles soient vraies (beaucoup d'affirmations superficiellement similaires sont incorrectes). Mais ces affirmations correctes ne sont pas une explication de la puissance de l'informatique quantique en apprentissage automatique. D'une part, toute application de l'informatique quantique à l'apprentissage automatique impliquera des mesures et nous ne pouvons pas mesurer un qubit dans plusieurs états à la fois. On peut préparer un qubit dans une superposition comme $|\psi\rangle = \frac{1}{\sqrt{2}}\left(|0\rangle+|1\rangle\right)$ mais une mesure donnera soit $|0\rangle$ soit $|1\rangle$. Donc, au minimum, cette histoire sur l'augmentation de la dimensionnalité est incomplète. De plus, dans le contexte des noyaux, une dimensionnalité accrue en informatique quantique ne peut pas être une condition suffisante pour la puissance de calcul par rapport aux alternatives classiques, car les noyaux gaussiens sont de dimension infinie. Il y a des subtilités là-dedans, car les cartes de caractéristiques gaussiennes ne sont utilisées qu'en conjonction avec le « kernel trick » qui évite d'avoir à calculer un vecteur mappé de dimension infinie. Mais le point demeure :

La grande dimensionnalité des états quantiques intriqués n'est pas du parallélisme exponentiel, et n'est pas une condition suffisante pour une puissance accrue en apprentissage automatique.

Dans les leçons qui suivent, nous présentons des workflows pour l'incorporation de circuits quantiques dans des tâches d'apprentissage automatique, et nous le faisons dans le but explicite de faciliter l'exploration de la puissance de l'informatique quantique. Aucune carte de caractéristiques ou algorithme dans ce cours n'est présenté comme un chemin rapide vers de meilleurs résultats d'apprentissage automatique pour les problèmes généraux, car il n'existe pas de telle carte de caractéristiques ou d'algorithme. Plutôt, nous présentons une large gamme d'outils quantiques à utiliser pour l'exploration de l'informatique quantique utile.

Déquantisation

La déquantisation désigne le remplacement d'un algorithme quantique donné par un algorithme classique qui se comporte de manière similaire à un algorithme quantique pour un ensemble de tâches données, incluant généralement l'évolutivité. Par certaines définitions, l'algorithme classique devrait être seulement polynomialement plus lent que l'algorithme quantique.

Plusieurs algorithmes d'apprentissage automatique quantique (QML) qui étaient initialement censés offrir des accélérations significatives par rapport aux algorithmes classiques ont été déquantisés ces dernières années. Ce processus de déquantisation a conduit à des informations importantes sur les avantages et les limites potentiels des approches quantiques de l'apprentissage automatique.

L'un des résultats de déquantisation les plus notables est venu du travail d'Ewin Tang sur les systèmes de recommandation. Tang a découvert un algorithme classique capable d'effectuer des tâches de recommandation à des vitesses auparavant considérées comme réalisables uniquement par des ordinateurs quantiques. Cette découverte a remis en question l'hypothèse selon laquelle les algorithmes quantiques avaient un avantage exponentiel pour ce problème. Des travaux plus récents de Shin et al. se sont concentrés sur l'identification des conditions sur la déquantisabilité de la classe de fonctions d'un modèle d'apprentissage automatique quantique variationnel.

Une approche courante de la déquantisation (mais pas le seul truc) est la prise en compte des frais généraux de chargement de données. Autrement dit, tout algorithme quantique appliqué à des données classiques comportera une étape dans laquelle les données classiques sont encodées dans l'ordinateur quantique. Si un algorithme quantique suppose un point de départ auquel les données quantiques sont déjà disponibles, on dissimule effectivement le temps requis pour l'encodage. Il existe des contextes dans lesquels supposer des données quantiques peut être raisonnable, mais de nombreuses applications d'intérêt commenceront avec des données classiques. Certains cas de déquantisation ont montré que lorsque ce temps d'encodage est inclus, et lorsque le chargement de données classiques peut être accompli efficacement, l'algorithme quantique n'est plus plus performant que son homologue classique.

Même si un algorithme ne peut pas être déquantisé, cela ne signifie pas qu'il est plus efficace ou évolutif que tous les algorithmes classiques. Comme exemple extrême et artificiel : imaginez un algorithme pour sélectionner les j plus grands éléments d'un ensemble de taille k. On pourrait écrire un algorithme quantique qui utilise l'algorithme de Shor pour factoriser chacun des k éléments en facteurs premiers, puis déterminer les plus grands éléments en utilisant les facteurs premiers. Un tel algorithme ne peut probablement pas être déquantisé, mais est considérablement moins efficace que les algorithmes classiques pour accomplir la même sélection des plus grands éléments (bien que pas la partie de factorisation inutile).

Preuve d'existence

En 2021, les chercheurs IBM Quantum® Yunchao Liu, Srinivasan Arunachalam et Kristan Temme ont publié un article dans Nature, A rigorous and robust quantum speed-up in supervised machine learning. En accord avec les mises en garde ci-dessus, un problème de classification a été soigneusement choisi pour ce travail qui est (1) connu pour être classiquement difficile, et (2) adapté aux algorithmes quantiques pour montrer une accélération.

L'article traite de la classification des données basée sur des logarithmes discrets. Pour citer l'article, « Pour un grand nombre premier $p$ et un générateur $g$ de $\mathbb{Z}^*_p = \{1, 2, \ldots, p − 1\}$, c'est une conjecture largement acceptée qu'aucun algorithme classique ne peut calculer $\text{log}_g(x)$ sur l'entrée $x \in \mathbb{Z}^*_p$, en temps polynomial en $n = \lceil{\text{log}_2(p)}\rceil$, le nombre de bits nécessaires pour représenter $p$. » En revanche, l'algorithme de Shor est connu pour résoudre le problème du logarithme discret en temps polynomial. Ce choix de problèmes satisfait donc simultanément les critères ci-dessus : difficulté classique (peu susceptible d'être déquantisé), et connu pour être adapté aux algorithmes quantiques.

Grâce à ce choix judicieux de problème de classification, les auteurs ont pu montrer une accélération exponentielle en utilisant des méthodes à noyau quantique (esquissées brièvement ci-dessous et discutées dans des leçons ultérieures) qui est à la fois de bout en bout et robuste. Ici, « de bout en bout » fait référence aux hypothèses sur le démarrage avec des données classiques ; les auteurs dans ce cas incluent bien le temps pour l'encodage des données. Ici, « robuste » fait référence au fait que les données à classifier sont séparées par une large marge en utilisant l'algorithme quantique, de sorte que le succès de la classification est robuste aux considérations du monde réel comme les erreurs d'échantillonnage fini.

Tout cela pour dire que des problèmes existent bien pour lesquels les noyaux quantiques peuvent produire une accélération exponentielle. Mais l'état actuel de la science est que ces problèmes sont sélectionnés sur la base d'observations ou de justifications théoriques qu'ils devraient être adaptés aux algorithmes quantiques. Il n'est pas réaliste de s'attendre à une accélération quantique pour les tâches d'apprentissage automatique que les ordinateurs classiques effectuent déjà très bien.

Identifier ces cas idéaux pour l'exploration de l'utilité quantique est une responsabilité énorme pour les apprenants de ce cours. Et ce n'est pas une tâche pouvant être accomplie dans un cours comme celui-ci. Cette exploration est une tâche pour l'ensemble du réseau IBM Quantum, composé de chercheurs comme toi. Ce cours démontrera des workflows QML et des stratégies d'encodage pour que tu puisses commencer à explorer l'utilité quantique dans ton domaine d'expertise.

Nous espérons que cette introduction a clarifié quelques points sur l'apprentissage automatique quantique :

1. Les algorithmes quantiques peuvent offrir une accélération exponentielle par rapport aux algorithmes classiques pour des problèmes très spécifiques qui sont classiquement difficiles et bien adaptés aux algorithmes quantiques.
2. La grande dimensionnalité des états intriqués en informatique quantique est importante, mais elle n'est pas suffisante pour simplement obtenir un avantage sur les algorithmes classiques.
3. Trouver des problèmes bien adaptés aux algorithmes quantiques est une tâche extrêmement difficile, qui incombera largement aux apprenants de ce cours.

Questions de vérification

Qu'est-ce qui différencie les états quantiques des états classiques ?

Réponse :

Beaucoup de choses. En particulier : des coefficients complexes et la superposition avec une seule copie. Il y a beaucoup d'autres différences qui seront discutées dans de futures leçons, notamment l'intrication et l'interférence.

Vrai ou faux ? Les états quantiques fortement intriqués nous permettent de résoudre la plupart des problèmes d'apprentissage automatique plus efficacement sur un ordinateur quantique.

Réponse :

Faux. La plupart des problèmes d'apprentissage automatique sont résolus très efficacement par des algorithmes classiques et les algorithmes quantiques ne sont pas susceptibles d'offrir une accélération substantielle. L'objectif dans le QML est de trouver des ensembles de données dont les caractéristiques sont bien décrites par des états quantiques et/ou de trouver des mappages de caractéristiques de données qui optimisent la précision des modèles.

Objectifs d'apprentissage du cours

En complétant ce cours, tu peux t'attendre à développer les compétences et aptitudes fondamentales suivantes. Les apprenants seront capables de :

1. Expliquer ce qu'est le QML et où le quantum se connecte à l'apprentissage automatique classique.

2. Appliquer le vocabulaire quantique et les termes clés aux workflows ML.

3. Identifier les composants clés d'un workflow QML (différents types).

4. Identifier différents types de QML et les distinguer les uns des autres.

5. Implémenter des méthodes à noyau quantique et des classificateurs quantiques variationnels en utilisant les primitives Qiskit Runtime et en suivant les patterns Qiskit.

6. Identifier où le QML est le plus prometteur et où il ne l'est pas.

7. Adapter un problème exemple à leur propre ensemble de données.

8. Être conscient des problèmes dans le QML comme le temps d'entraînement, le bruit et les erreurs cumulatives dans les lectures multi-états.

9. Formuler des recommandations sur les domaines où le QML pourrait bénéficier à leur organisation.

Structure du cours

Ce cours est composé de plusieurs leçons. Chaque leçon comporte plusieurs questions de vérification tout au long du texte, pour que tu puisses pratiquer de nouvelles compétences ou vérifier ta compréhension au fur et à mesure. Celles-ci ne sont pas obligatoires.

À la fin du cours, il y a un quiz de 20 questions. Tu dois obtenir au moins 70% à ce quiz pour obtenir ton badge d'apprentissage automatique quantique, via Credly. Si tu obtiens au moins 70%, ton badge te sera automatiquement envoyé par e-mail peu de temps après. Tu ne peux soumettre le quiz que deux fois. Après la première soumission, tu auras l'opportunité de reprendre les questions manquées. Après la deuxième soumission, ton score est définitif. Consulte le quiz pour plus de détails.

La structure du cours est la suivante :

• Leçon 1 : Introduction et aperçu
• Leçon 2 : Récapitulatif de l'apprentissage automatique
• Leçon 3 : Encodage des données
• Leçon 4 : Méthodes à noyau quantique et machines à vecteurs de support
• Leçon 5 : Classificateurs quantiques variationnels / réseaux de neurones
• Examen pour le badge

Exécute ton premier code QML

Il est souvent utile de voir où on s'en va, avant de décomposer en morceaux et d'approfondir les bases. Les cellules de code ci-dessous effectuent une instance simple d'une méthode à noyau quantique. Plus précisément, un seul élément de matrice à noyau est calculé. Les utilisateurs novices aux méthodes à noyau ou aux noyaux quantiques ne doivent pas être intimidés par cela ; plusieurs leçons dans ce cours seront consacrées à disséquer exactement ce qui est fait dans ces cellules.

Avec ce code, nous introduisons simultanément les patterns Qiskit : un cadre pour aborder l'informatique quantique à l'échelle utilitaire. Ce cadre consiste en quatre étapes très générales pouvant être appliquées à la plupart des problèmes (bien que dans certains flux de travail, certaines étapes puissent être itérées plusieurs fois).

Patterns Qiskit :

• Étape 1 : Mapper les entrées classiques à un problème quantique
• Étape 2 : Optimiser le problème pour l'exécution quantique
• Étape 3 : Exécuter en utilisant les primitives Qiskit Runtime
• Étape 4 : Analyse / post-traitement

Dans les cellules ci-dessous, nous offrons seulement des explications superficielles des différentes étapes, juste assez pour que tu trouves la leçon appropriée pour en apprendre davantage.

# Added by doQumentation — required packages for this notebook
!pip install -q numpy pandas qiskit

# Import some qiskit packages required for setting up our quantum circuits.
from qiskit.circuit import Parameter, ParameterVector, QuantumCircuit
from qiskit.circuit.library import unitary_overlap

# Import StatevectorSampler as our sampler.
from qiskit.primitives import StatevectorSampler

# Step 1: Map classical inputs to a quantum problem:

# Start by getting some appropriate data. The data imported below consist of 128 rows or data points.
# Each row has 14 columns that correspond to data features, and a 15th column with a label (+/-1).
!wget https://raw.githubusercontent.com/qiskit-community/prototype-quantum-kernel-training/main/data/dataset_graph7.csv

# Import some required packages, and write a function to pull some training data out of the csv file you got above.
import pandas as pd
import numpy as np

def get_training_data():
    """Read the training data."""
    df = pd.read_csv("dataset_graph7.csv", sep=",", header=None)
    training_data = df.values[:20, :]
    ind = np.argsort(training_data[:, -1])
    X_train = training_data[ind][:, :-1]

    return X_train

# Prepare training data
X_train = get_training_data()

# Empty kernel matrix
num_samples = np.shape(X_train)[0]

# Prepare feature map for computing overlap between two data points.
# This could be pre-built feature maps like ZZFeatureMap, or a custom quantum circuit, as shown here.
num_features = np.shape(X_train)[1]
num_qubits = int(num_features / 2)
entangler_map = [[0, 2], [3, 4], [2, 5], [1, 4], [2, 3], [4, 6]]
fm = QuantumCircuit(num_qubits)
training_param = Parameter("θ")
feature_params = ParameterVector("x", num_qubits * 2)
fm.ry(training_param, fm.qubits)
for cz in entangler_map:
    fm.cz(cz[0], cz[1])
for i in range(num_qubits):
    fm.rz(-2 * feature_params[2 * i + 1], i)
    fm.rx(-2 * feature_params[2 * i], i)

# Pick two data points, here 14 and 19, and assign the features to the circuits as parameters.
x1 = 14
x2 = 19
unitary1 = fm.assign_parameters(list(X_train[x1]) + [np.pi / 2])
unitary2 = fm.assign_parameters(list(X_train[x2]) + [np.pi / 2])

# Create the overlap circuit
overlap_circ = unitary_overlap(unitary1, unitary2)
overlap_circ.measure_all()
overlap_circ.draw("mpl", scale=0.6, style="iqp")

# Step 2: Optimize problem for quantum execution

# Use Qiskit Runtime service to get the least busy backend for running on real quantum computers.
# from qiskit_ibm_runtime import QiskitRuntimeService

# service = QiskitRuntimeService(channel="ibm_quantum")
# backend = service.least_busy(
#    operational=True, simulator=False, min_num_qubits=overlap_circ.num_qubits
# )

# Transpile the circuits optimally for the chosen backend using a pass manager.
# from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
# pm = generate_preset_pass_manager(optimization_level=3, backend=backend)
# overlap_ibm = pm.run(overlap_circ)

# Step 3: Execute using Qiskit Runtime Primitives

# Specify the number of shots to use.
num_shots = 10_000

## Evaluate the problem using statevector-based primitives from Qiskit
sampler = StatevectorSampler()
counts = (
    sampler.run([overlap_circ], shots=num_shots).result()[0].data.meas.get_int_counts()
)

# Step 4: Analyze and post-processing

# Find the probability of 0.
counts.get(0, 0.0) / num_shots

--2025-05-09 10:04:28--  https://raw.githubusercontent.com/qiskit-community/prototype-quantum-kernel-training/main/data/dataset_graph7.csv
Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 185.199.110.133, 185.199.109.133, 185.199.108.133, ...
Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|185.199.110.133|:443... connected.
HTTP request sent, awaiting response... 200 OK
Length: 49405 (48K) [text/plain]
Saving to: ‘dataset_graph7.csv.2’

dataset_graph7.csv. 100%[===================>]  48.25K  --.-KB/s    in 0.03s   

2025-05-09 10:04:29 (1.37 MB/s) - ‘dataset_graph7.csv.2’ saved [49405/49405]

0.8199

Bien que tu n'aies pas besoin de comprendre toutes les étapes ci-dessus, nous devrions essayer de comprendre la sortie, afin de savoir pourquoi nous faisons cela. De nombreux processus en apprentissage automatique utilisent des produits scalaires dans le cadre de la classification binaire (entre autres). La mécanique quantique a un lien évident avec cela, puisque les probabilités de mesurer divers états $|\phi_i\rangle$ sont données par le produit scalaire avec un état initial $|\psi\rangle$ à travers le produit scalaire : $P_i = |\langle\phi_i|\psi\rangle|^2$. Donc ce que nous avons fait ci-dessus, c'est créer un circuit quantique qui contient les caractéristiques de nos deux points de données, les projette dans l'espace d'un vecteur quantique, puis estime le produit scalaire dans cet espace via des mesures. C'est un exemple d'estimation de noyau quantique. Note que nous n'avons implémenté ce processus que pour deux des points de données (le 14e et le 19e). Si nous le faisions pour toutes les paires possibles, nous pourrions prendre la sortie (dans ce cas le nombre 0.821...) et remplir une matrice de résultats décrivant le recouvrement entre tous les points de l'ensemble de données d'entraînement. C'est la « matrice de noyau ».

Vérifie ta compréhension

Lis la question ci-dessous, réfléchis à ta réponse, puis clique sur le triangle pour révéler la solution.

Dans le processus ci-dessus, nous avons calculé une entrée de la matrice de noyau pour les 14e et 19e points de données. Quelle valeur devrions-nous obtenir si nous utilisons le même point de données deux fois (comme le 14e et le 14e à nouveau) ? En d'autres termes, quelles devraient être les entrées diagonales de la matrice de noyau ? Réponds à cette question en l'absence de bruit, mais note que des écarts par rapport à ta réponse sont possibles en présence de bruit.

Réponse :

Les diagonales devraient être 1.0. Ce processus devrait calculer le produit scalaire normalisé d'un vecteur avec lui-même, ce qui doit toujours être égal à un.