Quantum Machine Learning

Quantenmaschinelles Lernen (QML) wendet Quantencomputer auf Aufgaben des maschinellen Lernens an. Meist werden dabei parametrisierte Quantenschaltkreise trainiert, deren Gatterwinkel die Rolle von Modellgewichten übernehmen. Alternativ berechnet ein Quantenprozessor Ähnlichkeiten für Kernel-Verfahren. Ein Register aus n Qubits wird durch 2^n komplexe Amplituden beschrieben. Selbst ein kleiner Schaltkreis transformiert daher einen sehr großen Vektor. Eine Messung liefert jedoch nur eine zufällige Bitfolge. Jede Größe, die ein Modell benötigt, muss anhand vieler wiederholter Ausführungen geschätzt werden, den sogenannten Shots. Das Gebiet umfasst außerdem klassisches Lernen mit Daten aus Quantenexperimenten. Jacob Biamonte, Seth Lloyd und Kollegen gaben 2017 in einer Nature-Übersichtsarbeit einen Überblick über beide Ansätze.

Variations-Quantenschaltkreise#

Die meisten QML-Verfahren auf aktueller Hardware sind hybrid. Ein klassischer Computer kodiert jede Eingabe als Rotationswinkel. Ein Quantenprozessor führt einen parametrisierten Schaltkreis aus Rotationen und verschränkenden Gattern aus. Die gemessenen Erwartungswerte fließen in eine klassische Verlustfunktion ein, die ein klassischer Optimierungsalgorithmus minimiert, oft mit einfachem Gradientenabstieg. Diese Modelle werden auch Quantenneuronale Netze genannt, nach den trainierbaren Schichten eines klassischen neuronalen Netzes. Derselbe Ablauf wird für den variationalen Quanten-Eigenlöser (VQE) verwendet, der 2014 zur Schätzung der Grundzustandsenergien von Molekülen eingeführt wurde, sowie für QAOA, einen variationalen Algorithmus für kombinatorische Probleme, auf die sich die Quantenoptimierung konzentriert.

Backpropagation kann nicht in einen Quantenprozessor hineinsehen. Gradienten werden daher mit der Parameter-Shift-Regel berechnet: Bei einem Rotationsgatter entspricht die exakte Ableitung eines Erwartungswerts der halben Differenz zwischen den Ausführungen mit um +π/2 beziehungsweise -π/2 verschobenem Winkel. Eine Simulation eines Klassifikators mit zwei Qubits und NumPy zeigt den gesamten Ablauf:

import numpy as np

rng = np.random.default_rng(0)
x = rng.uniform(-np.pi, np.pi, size=(100, 2))  # 100 points with 2 features each
y = np.sign(np.cos(x[:, 0] - 1.0) * np.cos(x[:, 1] + 0.5))  # XOR-like labels


def circuit(features, theta):
    """Simulate RY encoding, trainable RY rotations, and a CNOT on 2 qubits, then return <Z> of qubit 2."""
    half = (features + theta) / 2  # RY(theta) after RY(x) is one rotation by x + theta
    state = np.kron([np.cos(half[0]), np.sin(half[0])], [np.cos(half[1]), np.sin(half[1])])
    state = state[[0, 1, 3, 2]]  # CNOT flips qubit 2 when qubit 1 is |1>
    return state @ np.diag([1, -1, 1, -1]) @ state


theta = np.zeros(2)
for _ in range(100):
    errors = np.array([circuit(xi, theta) for xi in x]) - y
    for i in range(2):  # parameter-shift rule: an exact gradient from two extra circuit runs
        shift = np.eye(2)[i] * np.pi / 2
        slopes = np.array([(circuit(xi, theta + shift) - circuit(xi, theta - shift)) / 2 for xi in x])
        theta[i] -= 0.5 * np.mean(errors * slopes)

accuracy = np.mean([np.sign(circuit(xi, theta)) == yi for xi, yi in zip(x, y)])
print(f"theta = {theta.round(2)}, accuracy = {accuracy:.2f}")

Es gibt theta = [-0.99 0.4 ], accuracy = 0.97 aus: Der Schaltkreis lernt Winkelkorrekturen nahe -1.0 und 0.5, mit denen die Labels erzeugt wurden, und klassifiziert 97 % der Punkte korrekt. Durch das CNOT wird der Erwartungswert des zweiten Qubits zum Produkt der beiden kodierten Kosinuswerte. Ohne das CNOT würde dieses Qubit nur das zweite Merkmal sehen. Auf echter Hardware wäre jeder Erwartungswert selbst ein Mittelwert aus Tausenden von Shots. PennyLane, Qiskit Machine Learning und TensorFlow Quantum bieten dieselben Bausteine mit Simulatoren und Zugriff auf echte Quantenprozessoren.

Quanten-Kernel und hybride Modelle#

Ein Quanten-Kernel bildet zwei Eingaben mithilfe eines festen Kodierungsschaltkreises auf Quantenzustände ab und schätzt deren Überlappung. Diese dient anschließend als Ähnlichkeitsmaß in einer klassischen Support-Vektor-Maschine (SVM). Vojtěch Havlíček und Kollegen von IBM demonstrierten dieses Verfahren 2019 in einer Nature-Arbeit auf einem supraleitenden Prozessor. Reale Daten haben weit mehr Merkmale als verfügbare Qubits. Deshalb komprimieren Pipelines die Eingaben zunächst mit einer Hauptkomponentenanalyse (PCA) oder einem vortrainierten Netzwerk. Andrea Mari und Kollegen von Xanadu verwendeten diese Form des Transferlernens 2020. Sie übergaben Merkmale aus einem vortrainierten ResNet-18 an einen Variationsschaltkreis mit 4 Qubits für die Bildklassifizierung.

Stand des Quantenvorteils#

Der deutlichste Vorteil zeigt sich bei Quantendaten. 2022 nutzten Hsin-Yuan Huang und Kollegen von Caltech und Google Quantum AI bis zu 40 supraleitende Qubits und 1.300 Quantengatter auf Googles Sycamore-Prozessor. Sie zeigten, dass ein Lernverfahren, das Quantenzustände speichert und auf einem Quantencomputer verarbeitet, Eigenschaften eines Quantensystems mit exponentiell weniger Experimenten erlernen kann als jedes Lernverfahren, das jede Kopie nur einzeln misst.

Beschleunigungen bei klassischen Daten sind weniger eindeutig. Frühe Vorschläge bauten auf dem HHL-Algorithmus von 2009 für lineare Gleichungssysteme auf. Dieser setzt dünn besetzte, gut konditionierte Eingaben voraus, die bereits im Quantenspeicher abgelegt sind. 2018 fand Ewin Tang einen quanteninspirierten klassischen Algorithmus, der die behauptete exponentielle Beschleunigung für Empfehlungssysteme aufhob. Beim Training treten barren plateaus auf, die Jarrod McClean und Kollegen 2018 beschrieben: Bei vielen zufällig initialisierten Schaltkreisen schrumpfen die Gradienten exponentiell mit der Zahl der Qubits. Das ist das Quantenpendant des Problems mit verschwindenden Gradienten und lässt zugleich die erforderliche Zahl der Shots exponentiell steigen. Die heutigen Prozessoren entsprechen den Geräten der verrauschten Quantenhardware im mittleren Größenbereich (NISQ), wie John Preskill sie 2018 nannte. Ihre Gatterfehler begrenzen die Schaltkreistiefe.

Das Laden von Daten ist ein weiterer Engpass. Ein einzelnes RGB-Bild mit 640 x 640 Pixeln und der standardmäßigen Eingabegröße von Ultralytics YOLO26 enthält 1.228.800 Werte. Durch Amplitudenkodierung passen diese in 21 Qubits, aber die Vorbereitung eines beliebigen 21-Qubit-Zustands erfordert eine Anzahl von Gattern, die mit 2²¹ wächst. Das sind ungefähr so viele Operationen, wie eine CPU zum Einlesen der Pixel benötigt.