Einführung in Quantum Machine Learning

Überblick und Motivation

Bevor du beginnst, füll bitte diese kurze Vorkurs-Umfrage aus – sie ist wichtig, um unser Inhaltsangebot und die Nutzererfahrung zu verbessern.

Willkommen beim Quantum Machine Learning!

Das folgende Video gibt eine kurze Einführung, die durch den Text unten ergänzt wird.

Zur kurzen Zusammenfassung und Ergänzung des Videos:

• Wir haben erlebt, dass ein Problem erstmals auf einem Quantencomputer gelöst wurde und Menschen anschließend einen Weg gefunden haben, es auf einem klassischen Supercomputer zu bewältigen. Dieser Kreislauf, bei dem sich klassisches und Quantencomputing gegenseitig an ihre Grenzen treiben, wird wahrscheinlich noch einige Jahre andauern.
• Es gibt spezifische Probleme, bei denen Quantencomputing einen nachweisbaren Vorteil gegenüber dem klassischen Computing bieten kann – vorausgesetzt, es werden Fortschritte bei der Fehlerreduzierung und der Anzahl verfügbarer Qubits erzielt. Aber wir befinden uns noch in einer Erkundungsphase, auf der Suche nach quantengeeigneten Datensätzen und nützlichen Quanten-Merkmalskarten.
• Quantum Machine Learning (QML) ist eines von vielen spannenden Gebieten, in denen Quantencomputing bestehende klassische Workflows ergänzen oder erweitern kann.

Machine Learning (ML) wendet Algorithmen auf Datensätze an, daher könnte QML plausiblerweise Quantenmechanik entweder auf der Daten- oder der Algorithmusseite einbeziehen – oder auf beiden. All diese Möglichkeiten sind potenziell interessant. Wir werden uns jedoch hauptsächlich auf Quantenalgorithmen beschränken, die auf klassische Daten angewendet werden. Ein Grund dafür ist, dass ML-Probleme mit klassischen Daten bereits so umfassend untersucht wurden und weithin verfügbar sind. Es besteht großes Interesse daran, Probleme zu lösen, die mit klassischen Daten beginnen. Ein weiterer Grund ist das Fehlen von QRAM. Ohne die Möglichkeit, große Mengen von Quantendaten über einen längeren Zeitraum zu speichern, sind Methoden, die mit Quantendaten beginnen, noch weit von der industriellen Anwendbarkeit entfernt. Es ist auch unklar, wie klassische Daten auf effiziente Weise „quanten-zugänglich" gemacht werden können. Zwei besonders interessante Arten von ML sind überwachtes Lernen, bei dem ein Algorithmus mit einem gelabelten Datensatz trainiert wird, und unüberwachtes Lernen, bei dem der Algorithmus versucht, eine Verteilung aus ungelabelten Stichproben zu erlernen. Ein unüberwachter Algorithmus könnte zum Beispiel lernen, neue Stichproben aus derselben Verteilung zu generieren oder die Stichproben in Gruppen mit ähnlichen Merkmalen zu clustern.

Das linke Bild zeigt zwei Kategorien gelabelter Daten, wie beim überwachten Lernen. In diesem Fall sind die Kategorien linear trennbar. Das rechte Bild zeigt Cluster von Daten. Bei einer unüberwachten Lernaufgabe wären diese Daten anfangs nicht gelabelt, und der Algorithmus würde die Verteilung untersuchen und möglicherweise nach Clustern suchen. Um die vom Algorithmus identifizierten Cluster beispielhaft zu visualisieren, wurden die Datenpunkte nun mit Labels versehen. Ein wesentlicher Unterschied zwischen beiden ist, dass der überwachte Lernprozess mit bereits gelabelten Daten beginnt, während der unüberwachte Prozess mit ungelabelten Daten startet – auch wenn die Daten am Ende mit Labels versehen sein können.

Wer sich mit Machine Learning auskennt, weiß bereits, dass viele Lösungsmethoden die Abbildung von Daten in höherdimensionale Räume beinhalten. Dies wurde besonders im Kontext von Kerneln intensiv erforscht. Zur kurzen Erinnerung: Manchmal lassen sich Daten durch eine Linie, eine Ebene oder eine Hyperebene (wir sagen der Einfachheit halber oft einfach „Hyperebene") in denselben Dimensionen trennen, in denen sie vorliegen. Das zeigt das erste Bild oben. Manchmal sind Daten in diesen Dimensionen jedoch nicht durch eine Hyperebene trennbar, wie das zweite Bild zeigt. Dennoch kann eine Struktur in den Daten vorhanden sein, die durch eine Abbildung in höhere Dimensionen ausgenutzt werden kann, sodass die Daten in diesem höherdimensionalen Raum trennbar sind. Das veranschaulicht die Abbildung der 2D-Daten mit kreisförmiger Symmetrie in den 3D-Raum, in dem die Datenpunkte entlang einer Paraboloid-Oberfläche angeordnet sind.

Ein häufiges Ziel im QML ist es, eine Abbildung aus dem niedrigerdimensionalen Merkmalsraum in einen höherdimensionalen Raum zu finden, die unsere Datenpunkte so wirksam trennt, dass wir die Abbildung zur Klassifizierung neuer Datenpunkte nutzen können. Doch das ist keine leichte Aufgabe, und jede Diskussion über den potenziellen Nutzen von Quantencomputing im Machine Learning muss mit den entsprechenden Einschränkungen versehen sein. Insbesondere müssen wir auf die Nuancen bei der Datensatzauswahl und die Herausforderungen beim Erreichen von Utility-Scale eingehen. Wir müssen auch aufhören, klassische ML-Algorithmen bei Daten übertreffen zu wollen, die von klassischen Algorithmen bereits effizient und gut behandelt werden, und stattdessen die Diskussion darauf verlagern, neue Merkmalskarten zu untersuchen, die nützlich sein könnten.

Erwartungen steuern

Viele in der Literatur beschriebene Datensätze für QML-Anwendungen sind „feature-engineered", d. h., ein Datensatz wird speziell ausgewählt oder erzeugt, um einen engen Anwendungsfall zu demonstrieren, in dem Quantencomputing nützlich ist. Wenn das nach Mogeln klingt, haben wir die eigentliche Aufgabe missverstanden. Es ist nicht so, dass einige Quanten-Merkmalskarten es uns ermöglichen, alle oder viele Klassifizierungsaufgaben effizienter oder skalierbarer zu lösen als klassische ML-Algorithmen. Vielmehr verhalten sich einige Quanten-Merkmalskarten (nicht alle) anders als klassische. Die eigentliche Aufgabe besteht darin, Quantenschaltkreise im Kontext komplexer Datenstrukturen zu untersuchen. Einige konkrete Fragen dabei sind:

1. Welche Quantenschaltkreise verhalten sich am ehesten auf neuartige Weise, verglichen mit klassischen Alternativen?
2. Gibt es reale Probleme mit Daten, deren Eigenschaften am besten mit solchen neuartigen Quantenschaltkreisen untersucht werden?
3. Skalieren diese Quantenschaltkreise auf near-term Quantencomputern?

Unzureichende Erklärungen

Man begegnet häufig einer vereinfachten Erklärung, wie Quantencomputing leistungsfähig sein kann. Sie lautet ungefähr so:

So wie klassische Computer Informationsbits verwenden, nutzen Quantencomputer Qubits. Bei einer bestimmten Anzahl von Bits, sagen wir 4, kann ein klassischer Computer jeden der $2^4 = 16$ möglichen Zustände annehmen, während ein Quantencomputer in einer Superposition aller 16 Zustände gleichzeitig existieren kann, und Operationen können auf dieser gesamten Superposition durchgeführt werden. In manchen Fällen ermöglicht uns dies auf natürliche Weise, potenziell interessante Lernalgorithmen auf der Grundlage von Abbildungen in höherdimensionale Räume zu entwerfen.

Das ist eine zutreffende Aussage, aber sie ist unzureichend und etwas irreführend, wie wir erläutern werden. Man hebt auch die Unterschiede zwischen komplexen und reellen Koeffizienten hervor, zum Beispiel:

Ein probabilistisches klassisches System, in dem ein System als mit bestimmten Wahrscheinlichkeiten in verschiedenen Zuständen befindlich beschrieben werden kann, lässt sich wie folgt darstellen.

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

In einem solchen System können die Koeffizienten $a$, $b$, $c$ usw. nur dann sinnvoll sein, wenn sie positive reelle Zahlen sind. Die Zustände in Quantencomputern werden durch Wahrscheinlichkeitsamplituden beschrieben, die komplexe Zahlen sein können.

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

Die obigen Aussagen wurden sehr sorgfältig formuliert, sodass sie korrekt sind (viele oberflächlich ähnliche Aussagen sind falsch). Aber diese korrekten Aussagen erklären nicht die Leistungsfähigkeit von Quantencomputing im Machine Learning. Zum einen wird jede Anwendung von Quantencomputing auf Machine Learning Messungen beinhalten, und wir können ein Qubit nicht so messen, dass es sich gleichzeitig in mehreren Zuständen befindet. Wir können ein Qubit in einer Superposition wie $|\psi\rangle = \frac{1}{\sqrt{2}}\left(|0\rangle+|1\rangle\right)$ präparieren, aber eine Messung ergibt entweder $|0\rangle$ oder $|1\rangle$. Allein schon deshalb ist diese Geschichte über zunehmende Dimensionalität unvollständig. Weiterhin kann im Kontext von Kerneln eine erhöhte Dimensionalität im Quantencomputing keine hinreichende Bedingung für mehr Rechenleistung gegenüber klassischen Alternativen sein, da Gaußsche Kernel unendlichdimensional sind. Dabei gibt es Feinheiten, da Gaußsche Merkmalskarten nur in Verbindung mit dem „Kernel-Trick" verwendet werden, der die Notwendigkeit umgeht, einen unendlichdimensionalen abgebildeten Vektor jemals berechnen zu müssen. Aber der Punkt bleibt bestehen:

Hohe Dimensionalität verschränkter Quantenzustände ist kein exponentieller Parallelismus und keine hinreichende Bedingung für mehr Leistung im Machine Learning.

In den folgenden Lektionen stellen wir Workflows vor, um Quantenschaltkreise in Machine-Learning-Aufgaben einzubinden, und wir tun dies mit dem ausdrücklichen Ziel, die Erkundung der Leistungsfähigkeit des Quantencomputings zu erleichtern. Keine Merkmalskarte oder kein Algorithmus in diesem Kurs wird als schneller Weg zu besseren ML-Ergebnissen für allgemeine Probleme präsentiert, weil eine solche Merkmalskarte oder ein solcher Algorithmus nicht existiert. Stattdessen stellen wir eine breite Palette von Quantenwerkzeugen vor, die bei der Erkundung nützlichen Quantencomputings eingesetzt werden können.

Dequantisierung

Dequantisierung bezeichnet die Ersetzung eines gegebenen Quantenalgorithmus durch einen klassischen, der für eine bestimmte Menge von Aufgaben ähnlich wie ein Quantenalgorithmus abschneidet, typischerweise einschließlich des Skalierungsverhaltens. Nach einigen Definitionen sollte der klassische Algorithmus nur polynomiell langsamer sein als der Quantenalgorithmus.

Mehrere Quantum-Machine-Learning-Algorithmen (QML), von denen man anfangs annahm, sie bieten bedeutende Geschwindigkeitsvorteile gegenüber klassischen Algorithmen, wurden in den letzten Jahren dequantisiert. Dieser Prozess der Dequantisierung hat wichtige Erkenntnisse über die potenziellen Vorteile und Grenzen quantenmechanischer Ansätze für Machine Learning geliefert.

Eines der bemerkenswertesten Dequantisierungsergebnisse stammt aus Ewin Tangs Arbeit zu Empfehlungssystemen. Tang entdeckte einen klassischen Algorithmus, der Empfehlungsaufgaben mit Geschwindigkeiten bewältigen konnte, die zuvor nur von Quantencomputern für erreichbar gehalten wurden. Diese Entdeckung stellte die Annahme in Frage, dass Quantenalgorithmen für dieses Problem einen exponentiellen Vorteil hätten. Neuere Arbeiten von Shin et al. konzentrieren sich auf die Identifizierung von Bedingungen für die Dequantisierbarkeit der Funktionsklasse eines variationellen Quanten-ML-Modells.

Ein gängiger Ansatz zur Dequantisierung (wenn auch nicht der einzige) ist die Berücksichtigung des Overhead beim Datenladen. Das heißt: Jeder Quantenalgorithmus, der auf klassische Daten angewendet wird, hat einen Schritt, in dem klassische Daten in den Quantencomputer kodiert werden. Wenn ein Quantenalgorithmus davon ausgeht, dass Quantendaten bereits vorhanden sind, versteckt man effektiv die für die Kodierung benötigte Zeit. Es gibt Kontexte, in denen die Annahme von Quantendaten sinnvoll sein kann, aber viele interessante Anwendungen beginnen mit klassischen Daten. Einige Dequantisierungsfälle haben gezeigt, dass der Quantenalgorithmus seinen klassischen Gegenspieler nicht mehr übertrifft, wenn diese Kodierungszeit einbezogen wird und das klassische Datenladen effizient bewerkstelligt werden kann.

Selbst wenn ein Algorithmus nicht dequantisiert werden kann, bedeutet das nicht, dass er effizienter oder skalierbarer ist als alle klassischen Algorithmen. Als extremes, konstruiertes Beispiel: Stell dir vor, einen Algorithmus zu entwickeln, der die größten $j$ Elemente aus einer Menge der Größe $k$ auswählt. Man könnte einen Quantenalgorithmus schreiben, der Shors Algorithmus verwendet, um jedes der $k$ Elemente in Primfaktoren zu zerlegen, und dann die größten Elemente anhand der Primfaktoren bestimmt. Ein solcher Algorithmus lässt sich wahrscheinlich nicht dequantisieren, ist aber erheblich ineffizienter als klassische Algorithmen, die dieselbe Auswahl der größten Elemente durchführen (wenn auch ohne den unnötigen Faktorisierungsschritt).

Existenzbeweis

Im Jahr 2021 veröffentlichten IBM Quantum®-Forscher Yunchao Liu, Srinivasan Arunachalam und Kristan Temme ein Paper in Nature: A rigorous and robust quantum speed-up in supervised machine learning. Konsistent mit den obigen Einschränkungen wurde für diese Arbeit sorgfältig ein Klassifizierungsproblem ausgewählt, das (1) nachweislich klassisch schwer ist und (2) sich für Quantenalgorithmen zur Demonstration eines Geschwindigkeitsvorteils eignet.

Das Paper behandelt die Klassifizierung von Daten auf der Grundlage diskreter Logarithmen. Um das Paper zu zitieren: „Für eine große Primzahl $p$ und einen Generator $g$ von $\mathbb{Z}^*_p = {1, 2, . . . , p − 1}$ ist es eine weit verbreitete Vermutung, dass kein klassischer Algorithmus $\text{log}_g(x)$ für eine Eingabe $x \in \mathbb{Z}^*_p$ in Zeit polynomiell in $n = \lceil{\text{log}_2(p)}\rceil$, der Anzahl der zur Darstellung von $p$ benötigten Bits, berechnen kann." Im Gegensatz dazu ist bekannt, dass Shors Algorithmus das Problem des diskreten Logarithmus in polynomieller Zeit löst. Diese Problemwahl erfüllt also gleichzeitig die oben genannten Kriterien: klassische Schwierigkeit (unwahrscheinlich dequantisierbar) und bekannte Eignung für Quantenalgorithmen.

Durch diese überlegte Wahl des Klassifizierungsproblems konnten die Autoren einen exponentiellen Geschwindigkeitsvorteil mit quantenmechanischen Kernel-Methoden (kurz skizziert unten und in späteren Lektionen diskutiert) zeigen, der sowohl end-to-end als auch robust ist. „End-to-end" bezieht sich hier auf die Annahmen über den Start mit klassischen Daten; die Autoren schließen in diesem Fall die Zeit für die Datenkodierung ein. „Robust" bedeutet hier, dass die zu klassifizierenden Daten durch den Quantenalgorithmus mit einem großen Abstand getrennt werden, sodass der Klassifizierungserfolg gegenüber realen Einflüssen wie endlichem Sampling-Fehler robust ist.

All das soll zeigen, dass Probleme existieren, bei denen Quantenkerne einen exponentiellen Geschwindigkeitsvorteil erzielen können. Aber der aktuelle Stand der Wissenschaft ist, dass solche Probleme auf der Grundlage von Beobachtungen oder theoretischen Begründungen ausgewählt werden, dass sie für Quantenalgorithmen geeignet sein sollten. Es ist nicht realistisch, einen Quantenvorteil für Machine-Learning-Aufgaben zu erwarten, die klassische Computer bereits sehr gut bewältigen.

Das Identifizieren solcher idealer Fälle für die Erkundung der Quantennützlichkeit ist eine enorme Verantwortung für die Lernenden in diesem Kurs. Und es ist keine Aufgabe, die in einem Kurs wie diesem bewältigt werden kann. Diese Erkundung ist eine Aufgabe für das gesamte IBM Quantum Network, das aus Forschenden wie dir besteht. Dieser Kurs demonstriert QML-Workflows und Kodierungsstrategien, damit du damit beginnen kannst, in deinem Fachgebiet nach Quantennützlichkeit zu suchen.

Wir hoffen, dass diese Einführung einige Dinge über Quantum Machine Learning klargestellt hat:

1. Quantenalgorithmen können einen exponentiellen Geschwindigkeitsvorteil gegenüber klassischen Algorithmen für sehr spezifische Probleme bieten, die klassisch schwer und für Quantenalgorithmen gut geeignet sind.
2. Die hohe Dimensionalität verschränkter Zustände im Quantencomputing ist wichtig, aber sie reicht nicht aus, um einfach einen Vorteil gegenüber klassischen Algorithmen zu erlangen.
3. Probleme zu finden, die für Quantenalgorithmen gut geeignet sind, ist eine äußerst schwierige Aufgabe, die größtenteils den Lernenden in diesem Kurs zufallen wird.

Verständnisfragen

Was unterscheidet Quantenzustände von klassischen Zuständen?

Antwort:

Vieles. Besonders hervorzuheben: komplexe Koeffizienten und Superposition mit einer einzigen Kopie. Es gibt viele weitere Unterschiede, die in zukünftigen Lektionen besprochen werden, darunter Verschränkung und Interferenz.

Richtig oder falsch? Stark verschränkte Quantenzustände ermöglichen es uns, die meisten Machine-Learning-Probleme auf einem Quantencomputer effizienter zu lösen.

Antwort:

Falsch. Die meisten Machine-Learning-Probleme werden von klassischen Algorithmen sehr effizient gelöst, und Quantenalgorithmen werden wahrscheinlich keinen wesentlichen Geschwindigkeitsvorteil bieten. Das Ziel im QML ist es, Datensätze mit Merkmalen zu finden, die gut durch Quantenzustände beschrieben werden, und/oder Abbildungen von Datenmerkmalen zu finden, die die Genauigkeit von Modellen optimieren.

Lernziele des Kurses

Durch den Abschluss dieses Kurses kannst du folgende Kernkompetenzen und Fähigkeiten aufbauen. Die Lernenden werden in der Lage sein:

1. Zu erklären, was QML ist und wo Quantencomputing mit klassischem Machine Learning verbunden ist.

2. Quantenvokabular und Schlüsselbegriffe auf ML-Workflows anzuwenden.

3. Die wichtigsten Komponenten eines QML-Workflows (verschiedene Typen) zu identifizieren.

4. Verschiedene Arten von QML zu identifizieren und zwischen ihnen zu unterscheiden.

5. Quantenkernel-Methoden und variationelle Quantenklassifikatoren mit Qiskit Runtime Primitives und gemäß Qiskit Patterns zu implementieren.

6. Zu identifizieren, wo QML am vielversprechendsten ist und wo nicht.

7. Ein Beispielproblem an den eigenen Datensatz anzupassen.

8. Sich der Probleme im QML wie Trainingszeit, Rauschen und kumulativen Fehlern bei mehrfachen Zustandsmessungen bewusst zu sein.

9. Empfehlungen auszusprechen, wo QML der eigenen Organisation zugutekommen könnte.

Kursstruktur

Dieser Kurs besteht aus mehreren Lektionen. Jede Lektion enthält mehrere Verständnisfragen im Text, mit denen du neue Fähigkeiten üben oder dein Verständnis unterwegs überprüfen kannst. Diese sind nicht verpflichtend.

Am Ende des Kurses gibt es ein Quiz mit 20 Fragen. Du musst mindestens 70 % erreichen, um dein Quantum Machine Learning-Badge über Credly zu erhalten. Wenn du mindestens 70 % erreichst, wird dir dein Badge kurz darauf automatisch per E-Mail zugesandt. Du kannst das Quiz nur zweimal einreichen. Nach der ersten Einreichung hast du die Möglichkeit, die Fragen, die du verfehlt hast, erneut zu versuchen. Nach der zweiten Einreichung ist dein Ergebnis endgültig. Weitere Details findest du beim Quiz.

Die Kursstruktur ist wie folgt:

• Lektion 1: Einführung und Überblick
• Lektion 2: Rückblick auf Machine Learning
• Lektion 3: Datenkodierung
• Lektion 4: Quantenkernel-Methoden und Support Vector Machines
• Lektion 5: Variationelle Quantenklassifikatoren / Neuronale Netze
• Prüfung für Badge

Führe deinen ersten QML-Code aus

Es ist oft hilfreich zu sehen, wohin wir unterwegs sind, bevor wir die Einzelteile auseinandernehmen und in die Hintergründe eintauchen. Die folgenden Code-Zellen führen eine einfache Instanz einer Quantenkernel-Methode durch. Konkret wird ein einzelnes Kernelmatrixelement berechnet. Nutzer, die noch nicht mit Kernel-Methoden oder Quantenkernen vertraut sind, sollten sich davon nicht einschüchtern lassen; mehrere Lektionen in diesem Kurs werden sich damit befassen, was in diesen Zellen genau getan wird.

Mit diesem Code stellen wir gleichzeitig Qiskit Patterns vor: ein Framework für den Umgang mit Quantencomputing im Utility-Scale. Dieses Framework besteht aus vier Schritten, die sehr allgemein sind und auf die meisten Probleme angewendet werden können (obwohl in manchen Arbeitsabläufen bestimmte Schritte mehrmals durchlaufen werden).

Qiskit Patterns:

• Schritt 1: Klassische Eingaben auf ein Quantenproblem abbilden
• Schritt 2: Problem für die Quantenausführung optimieren
• Schritt 3: Mit Qiskit Runtime Primitives ausführen
• Schritt 4: Analysieren / Nachbearbeitung

In den folgenden Zellen bieten wir nur oberflächliche Erklärungen der verschiedenen Schritte, gerade genug, damit du die passende Lektion findest, um mehr zu erfahren.

# 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

Auch wenn du nicht alle Schritte oben verstehen musst, sollten wir versuchen, die Ausgabe zu verstehen, damit wir wissen, warum wir das tun. Viele Prozesse im Machine Learning verwenden innere Produkte als Teil der binären Klassifizierung (unter anderem). Die Quantenmechanik hat eine offensichtliche Verbindung dazu, da die Wahrscheinlichkeiten, verschiedene Zustände $|\phi_i\rangle$ zu messen, durch das innere Produkt mit einem Anfangszustand $|\psi\rangle$ gegeben sind: $P_i = |\langle\phi_i|\psi\rangle|^2$. Was wir also oben getan haben, ist einen Quantenschaltkreis zu erstellen, der die Merkmale unserer beiden Datenpunkte enthält, sie in den Raum eines Quantenvektors abbildet und dann das innere Produkt in diesem Raum durch Messungen schätzt. Das ist ein Beispiel für Quantenkernel-Schätzung. Beachte, dass wir diesen Prozess nur für zwei der Datenpunkte (den 14. und 19.) implementiert haben. Wenn wir das für alle möglichen Paare täten, könnten wir die Ausgabe (in diesem Fall die Zahl 0,821...) nehmen und eine Matrix von Ergebnissen befüllen, die die Überlappung zwischen allen Punkten im Trainingsdatensatz beschreibt. Das ist die „Kernelmatrix".

Überprüfe dein Verständnis

Lies die folgende Frage, denk über deine Antwort nach, und klicke dann auf das Dreieck, um die Lösung anzuzeigen.

Im obigen Prozess haben wir einen Kernelmatrixeintrag für den 14. und 19. Datenpunkt berechnet. Welchen Wert sollten wir erhalten, wenn wir denselben Datenpunkt zweimal verwenden (z. B. den 14. und nochmals den 14.)? Mit anderen Worten: Was sollten die Diagonaleinträge in der Kernelmatrix sein? Beantworte diese Frage ohne Rauschen, beachte aber, dass Abweichungen von deiner Antwort bei Rauschen möglich sind.

Antwort:

Die Diagonalen sollten 1,0 sein. Dieser Prozess sollte das normierte innere Produkt eines Vektors mit sich selbst berechnen, was stets eins sein muss.