Quantencomputing für Data Science: ein Praxistest

Wie praxistauglich ist Quantencomputing für Data Science und ML heute? Anhand von drei konkreten Anwendungsfällen lässt sich eine erste Einschätzung treffen.

Lesezeit: 14 Min.
In Pocket speichern
vorlesen Druckansicht Kommentare lesen 46 Beiträge
Quantencomputing für Data Science: Ein Praxistest

(Bild: Bartlomiej K. Wroblewski / Shutterstock.com)

Von
  • Christian Koch
  • Eldar Sultanow
Inhaltsverzeichnis

Rund um das Thema Quantencomputing ist ein regelrechter Hype ausgebrochen. Die Technik könnte im Bereich der Data Science und des maschinellen Lernens neue Horizonte eröffnen. Doch wie praxistauglich ist sie heute bereits? Anhand eines Tests in drei Anwendungsfällen untersuchen die Autoren den konkreten Nutzen für Data Scientists.

Im Unterschied zu klassischen Computern basieren Algorithmen eines Quantencomputers nicht auf Bits, sondern auf Qubits. Ein Bit kann entweder den Zustand 0 oder 1 annehmen. Misst man ein einmal gesetztes Bit mehrere Male, erhält man stets dasselbe Ergebnis. Bei einem Qubit verhält sich das anders. Prinzipiell kann es, so seltsam sich das anhört, gleichzeitig die Werte 0 und 1 annehmen. Misst man den Wert eines Qubits mehrmals, treten die Werte 0 und 1 mit einer gewissen Wahrscheinlichkeit auf. Im Ausgangszustand beträgt diese für den Wert 0 in der Regel hundert Prozent. Durch Überlagerung (Superposition) der Zustände lassen sich für ein Qubit andere Wahrscheinlichkeitsverteilungen erzeugen. Möglich wird das durch die Quantenmechanik, die Gesetzen folgt, die wir in dieser Form aus der alltäglichen Umgebung nicht kennen.

Der entscheidende Vorteil eines Quantencomputers liegt in seiner Probabilistik. Klassische Computer sind stark in Problemen, bei denen man ein einziges Endergebnis benötigt. Quantencomputer können im Gegensatz dazu sehr gut mit Wahrscheinlichkeiten umgehen und mit mehreren Werten gleichzeitig rechnen. Führt man eine Operation mit einem Qubit in einem überlagerten Zustand einmal aus, wird sie sowohl auf die Zahl 0 als auch auf die Zahl 1 angewandt. Das Qubit repräsentiert ja gleichzeitig beide Zustände. Je mehr Qubits in die Rechnung einfließen, desto größer fällt der Vorteil gegenüber einem klassischen Computer aus. Ein Rechner mit drei Qubits kann beispielsweise bis zu acht (das entspricht 2³) mögliche Zustände gleichzeitig abdecken: Die Binärzahlen 000, 001, 010, 011, 100, 101, 110 und 111.

In der wissenschaftlichen Literatur herrscht generell Einigkeit darüber, dass Quantencomputer zur Lösung bisher unlösbarer Probleme beitragen werden, unter anderem in den Bereichen Data Science und künstliche Intelligenz. Momentan stehen allerdings noch keine optimalen Quantencomputer zur Verfügung. Die aktuelle Generation nennt sich Noisy Intermediate-Scale Quantum (NISQ). Diese Rechner sind in der Anzahl ihrer Qubits begrenzt und störanfällig, sie unterliegen einem Rauschen (Noise). Im Jahr 2021 konnten die ersten Unternehmen Quantencomputer mit über 100 Qubits aufbauen, darunter IBM und QuEra Computing. Doch wie hoch ist der praktische Nutzen dieser NISQ-Generation? Das soll im Folgenden ein Test zeigen, für den die Autoren drei Anwendungsfälle mit den Frameworks Qiskit und PennyLane umsetzen und auf ihre Praxistauglichkeit prüfen. Im Vergleich zu Alternativen wie Cirq (Google) und Q# (Microsoft) bietet IBMs Qiskit-Framework eine sehr gute Dokumentation und den Vorteil, die Schaltkreise kostenlos auf einem echten Quantencomputer ausführen zu können.

Beginnen wir mit einem naheliegenden Einsatzzweck eines Quantencomputers: dem Generieren von Zufallszahlen. Das sogenannte Sampling zieht Zahlen aus einer bestimmten Wahrscheinlichkeitsverteilung. Die Technik ist ein wichtiges Werkzeug für Data Scientists, die sie unter anderem für die Modellierung von Markov-Ketten und zum Training neuronaler Netze einsetzen. Als spezieller stochastischer Prozess dienen Markow-Ketten dazu, Wahrscheinlichkeiten für das Eintreten zukünftiger Ereignisse anzugeben. Auf beide Anwendungsfälle geht der Artikel detaillierter ein.

Qiskit lässt sich zum Beispiel zum Ziehen von Zufallszahlen auf einem Quantencomputer nutzen. Es ist in Python geschrieben und bietet den Vorteil, dass der Code kostenlos auf einem echten Quantencomputer ausführbar ist. Da die Maschinen bei IBM Quantum (IBMQ) in der Regel stark ausgelastet sind, müssen Entwicklerinnen und Entwickler lediglich etwas Zeit mitbringen. Verglichen mit dem Quantencomputing bei anderen kommerziellen Anbietern wie Google, Amazon oder Microsoft ist IBMQ eine günstige Alternative. Für das weiter unten folgende Beispiel mit 8000 Messungen fielen auf einer D-Wave-Maschine beispielsweise nach der aktuell gültigen Preisliste von AWS circa 1,82 US-Dollar an (ein Task mit 8000 Shots). Bei IonQ- und Rigetti-Systemen wären die Kosten höher.

Die folgenden wichtigen Codefragmente dienen dem Verständnis des ersten Beispiels. Der vollständige Sourcecode liegt in einem Jupyter Notebook auf GitHub parat.

Zunächst importiert das Notebook einige Bibliotheken:

from datetime import datetime
import pandas as pd
import qiskit as qml
from qiskit.providers.ibmq import least_busy
import matplotlib.pyplot as plt

Neben Qiskit umfasst der Import Data-Science-Libraries wie pandas. Der nächste Codeblock definiert einige globale Variablen zur Steuerung des Notebooks:

LOCAL_SIMULATION = False
SHOTS = 8000
BINOMIAL_N = 20
RANDOM_WALK_DAYS = 200

Die Variable LOCAL_SIMULATION konfiguriert, ob der Code lokal in einem Simulator oder remote auf einem echten Quantencomputer läuft. Im nächsten Schritt meldet sich das Notebook mit einem Account bei IBMQ an:

if not qml.IBMQ.active_account():
    qml.IBMQ.load_account()

Als Vorbereitung zum Ausführen des Codes ist eine Registrierung bei IBMQ notwendig. Eine Anleitung dazu findet sich in der Dokumentation. Nach der Anmeldung wählt der Code ein für den Anwendungsfall geeignetes Backend aus:

provider = qml.IBMQ.get_provider(hub='ibm-q')

if LOCAL_SIMULATION:
    backend = qml.Aer.get_backend('aer_simulator')
else:
    backend = least_busy(provider.backends(simulator=False, operational=True))

Falls die Variable LOCAL_SIMULATION gesetzt ist, kommt ein Simulator zum Einsatz, anderenfalls der am wenigsten frequentierte Quantencomputer bei IBMQ. Da das Beispiel mit nur einem Qubit ausführbar ist, kommen grundsätzlich alle verfügbaren Rechner unabhängig von ihrer Größe infrage. Dadurch verkürzt sich die Wartezeit. Da Quantencomputer immer noch eine Rarität sind, verbringen Entwicklerinnen und Entwickler gemeinsam mit anderen Anfragenden viel Zeit in Warteschleifen. Je mehr Qubits ein Rechner hat, desto gefragter ist er.

Nun folgt der Kernschritt des ersten Beispiels, die Definition eines Quantenschaltkreises:

circuit = qml.QuantumCircuit(1)
circuit.h(0)
circuit.measure_all()
compiled_circuit = qml.transpile(circuit, backend)

Ähnlich wie bei einem klassischen Rechner bilden Schaltkreise bei Quantencomputern ein grundlegendes Programmierelement. Der vorangehende Codeblock definiert einen Schaltkreis, der auf einem Qubit operiert, das sich zunächst im Ausgangszustand befindet. Mit einem Hadamard-Gatter werden die Werte 0 und 1 in der zweiten Zeile in einen überlagerten Zustand überführt. Die Wahrscheinlichkeit für eine Messung der Zahlen 0 und 1 liegt danach bei jeweils 50 Prozent. Eine Messung wird in der Quantenwelt auch als Shot bezeichnet. Das Beispiel sieht 8000 Messungen im Backend vor und liefert im Ergebnis ebenso viele Zufallszahlen:

result = backend.run(compiled_circuit, memory=True, shots=SHOTS).result()
random_numbers = result.get_memory()

Die erzeugten Zahlen folgen einer Bernoulli-Verteilung. Sie beschreibt Zufallsereignisse mit nur zwei möglichen Ausgängen ("Misserfolg" / "Erfolg" oder 0 / 1). Im Beispiel entsprechen die Werte mit gleicher Wahrscheinlichkeit 0 oder 1 (p=0,5). Im Unterschied zur Mehrheit klassischer Verfahren handelt es sich bei den erzeugten Daten nicht um Pseudozufallszahlen, sondern um tatsächlich zufällige Werte. Die Visualisierung der Verteilung in Abbildung 1 liefert folgendes Bild:

Bernoulli-Verteilung der Zufallszahlen für 8000 Messungen (Abb. 1)

Die Verteilung der Zufallszahlen weist wie erwartet etwa 4000 Ausprägungen der Werte 0 und 1 auf. Auch andere Verteilungen können Data Scientists mit Hilfe von Quantendaten erzeugen. Der nachfolgende Code-Block transformiert beispielsweise die im Quantencomputer erzeugte Bernoulli-Verteilung durch eine simple Operation in eine Binomialverteilung:

binomial_frame = bernoulli_frame.groupby(
    bernoulli_frame.index // BINOMIAL_N).sum().reset_index(drop=True)

Quantum Sampling ist der erste Bereich in dem Wissenschaftler Quantenüberlegenheit zeigen konnten. Ein Quantencomputer erfüllt dabei eine Aufgabe, die sich auf einem klassischen Rechner nicht in akzeptabler Zeit – beispielsweise in Sekunden oder allenfalls Tagen – bearbeiten lässt. In Zukunft dürften weitere Bereiche hinzukommen, darunter beispielsweise Simulationen.

Im nächsten Abschnitt dienen die erzeugten Zufallszahlen dazu, den Kursverlauf einer Aktie mithilfe einer Markov-Kette darzustellen.

Eine Markov-Kette führt eine bestimmte Anzahl an Zufallsexperimenten nacheinander aus und kommt so zu einem möglichen Endergebnis. Eine spezielle Form der Markov-Kette ist der Random Walk. Dieser Zufallsprozess kommt unter anderem am Finanzmarkt zur Simulation von Aktienkursen zum Einsatz. Das nachfolgende Diagramm zeigt 40 Random Walks einer (fiktiven) Aktie mit einem Eröffnungskurs p0=100 Euro über 200 Tage. Die Random Walks wurden mit einer vom Quantencomputer erzeugten Bernoulli-Verteilung generiert (Der Code findet sich im bereits erwähnten Jupyter Notebook auf GitHub).

40 Random Walks einer (fiktiven) Aktie mit einem Eröffnungskurs p0=100 Euro über 200 Tage (Abb. 2)

Das Chart in Abbildung 2 zeigt den möglichen Verlauf des Aktienkurses über 200 Tage ausgehend vom Eröffnungskurs. Die Simulation basiert auf einem Quantum Sample. Der Code zum Erzeugen der Markov-Ketten läuft im Notebook auf einem klassischen Rechner. Soll ein Quantencomputer die Markov-Kette ausführen, lässt sich das mit einem komplizierteren Quantenschaltkreis realisieren.

Der Algorithmus zur Simulation der Aktie funktioniert im Beispiel wie folgt:

  1. Ein Random Walk beginnt mit einem Eröffnungskurs von p0=100
  2. Pro Random Walk werden nacheinander 200 Zufallszahlen gezogen
  3. Wenn der Wert 1 für einen simulierten Tag auftritt, steigt der Kurs um 1 Prozent
  4. Anderenfalls sinkt der Kurs um 1 Prozent

Auf diese Weise entstehen alternative Pfade des Aktienkurses. Die täglichen Schwankungen für die Simulation lassen sich in der Praxis schätzen oder aus Vergangenheitsdaten ermitteln. Das nachfolgende Diagramm (Abb. 3) zeigt die Verteilung der Schlusskurse pn nach 40 Läufen mit den obigen Parametern (da es sich um einen Zufallsprozess handelt, variiert die Darstellung):

Verteilung der Aktienschlusskurse pn nach 40 Durchläufen (Abb. 3)

Investoren nutzen Random Walks in der Praxis, um anhand möglicher Schwankungen das Risiko eines Finanzinstruments über einen bestimmten Zeitraum zu schätzen. Zudem bildet die Varianz eine Grundlage zur Bepreisung von Derivaten wie Optionen. Insbesondere bei der Simulation sehr vieler Wertpapiere kann ein Quantencomputer Geschwindigkeitsvorteile bieten. Positiv schlägt sich darüber hinaus nieder, dass es sich bei den Samples um echte Zufallszahlen handelt, die nicht das Ergebnis eines deterministischen Algorithmus sind. Das Beispiel beschränkt sich auf einen simplen, symmetrischen Random Walk. Qiskit bietet im Rahmen seiner Finanzmarktbibliothek fortgeschrittenere Algorithmen.

Der letzte Anwendungsfall behandelt das Training eines künstlichen neuronalen Netzes. Ein mit Hilfe eines Quantencomputers trainiertes Netz nennt sich Quantum Neural Network (QNN). Technische Grundlage für dieses Beispiel ist die Bibliothek PennyLane. Sie ist wie Qiskit ebenfalls in Python geschrieben und auf Quantum Machine Learning (QML) spezialisiert. Das Framework basiert auf anderen Low-Level-Verfahren . Neben Qiskit sind Cirq und Q# eine mögliche Basis.

Auch der vollständige Quellcode für das QNN-Beispiel steht auf GitHub in einem Jupyter Notebook parat. Die Vorgehensweise orientiert sich an einem Tutorial von PennyLane, das Interessierten eine detailliertere Beschreibung bietet. Die nachfolgenden Codefragmente helfen dabei, ein grundlegendes Verständnis des Beispiels zu gewinnen.

Zunächst importiert das Notebook einige Bibliotheken:

import pennylane as pl
import tensorflow as tf
import numpy as np
from sklearn.datasets import make_moons
import matplotlib.pyplot as plt

Neben PennyLane kommen die klassischen Libraries TensorFlow und Keras zum Einsatz. Sie fungieren als Werkzeuge für das Training des Netzes. Im nächsten Schritt wird ein passendes Backend gewählt. Das Notebook setzt den von PennyLane mitgelieferten Simulator ein. Der Code ist auch auf echten Quantencomputern ausführbar. Hierbei gibt es jedoch ein Problem, das im Folgenden noch diskutiert wird.

N_QUBITS = 2
backend = pl.device("default.qubit", wires=N_QUBITS)

Ziel des QNNs ist es, zwei Mengen voneinander zu trennen. Der Code konfiguriert hierzu ein Backend mit zwei Qubits, die beiden Mengen erzeugt die Funktion make_moons aus der Bibliothek scikit-learn. Der Trainingsdatensatz ist in Abbildung 4 visualisiert:

Visualisierung des Trainingsdatensatzes der Funktion "make_moons" aus der Bibliothek scikit-learn (Abb. 4)

Das neuronale Netz klassifiziert anhand der Koordinaten eines Punktes die Zugehörigkeit zu einem der beiden Monde – erkennbar anhand der Einfärbung. Sind die Punkte des oberen Mondes bei der Vorhersage komplett blau eingefärbt und die des unteren Mondes komplett orange beträgt die Accuracy 100 Prozent. Das Netz ist ein hybrides quantenklassisches Modell und besteht aus mehreren Layern. Ein klassischer Input-Layer nimmt die Koordinaten entgegen und gibt sie an einen Quanten-Layer weiter. Dieser berechnet mithilfe eines Schaltkreises Gewichte und übermittelt sie an einen klassischen Output-Layer, der schließlich die Klassenzugehörigkeit bestimmt. Das Netz ist im Detail wie folgt aufgebaut:

# Define classical layers
input_layer = tf.keras.layers.Dense(2)
output_layer = tf.keras.layers.Dense(2, activation="sigmoid")

# Define a quantum circuit with two qubits
@pl.qnode(backend)
def qnode(inputs, weights):
    pl.templates.AngleEmbedding(inputs, wires=range(N_QUBITS))
    pl.templates.BasicEntanglerLayers(weights, wires=range(N_QUBITS))
    return [pl.expval(pl.PauliZ(wires=i)) for i in range(N_QUBITS)]

# Convert quantum circuit to keras layer
N_LAYERS = 6
weight_shapes = {"weights": (N_LAYERS, N_QUBITS)}
qlayer = pl.qnn.KerasLayer(qnode, weight_shapes, output_dim=N_QUBITS)

Die Syntax zur Definition eines Quantenschaltkreises weicht bei PennyLane etwas von der von Qiskit ab. PennyLane definiert den Schaltkreis über einen sogenannten QNode. Die grundlegende Funktionsweise ist aber bei beiden Frameworks identisch. Der Quanten-Layer wird anschließend in eine Keras-Komponente umgewandelt. Das Training des Netzes erfolgt dann in der üblichen TensorFlow/Keras-Syntax:

model = tf.keras.models.Sequential([input_layer, qlayer, output_layer])
opt = tf.keras.optimizers.Adam(learning_rate=0.1)
model.compile(optimizer=opt, loss="binary_crossentropy", metrics=["accuracy"])
fitting = model.fit(x, y_hot, epochs=10, batch_size=5, validation_split=0.25, verbose=2)

Nach einem Training mit zehn Epochen erzielt das Modell in einer Vorhersage eine Genauigkeit (Accuracy) von mehr als 90 Prozent. Da im Prozess auch Zufall eine Rolle spielt, kann das Ergebnis etwas variieren. Das Netz ist somit für über 90 Prozent der Datenpunkte in der Lage eine Zuordnung zum richtigen Mond zu treffen. Abbildung 5 zeigt die Qualität der Vorhersage:

Qualität der Vorhersage: Das Quantum Neural Network ordnet 90 Prozent der Datenpunkte richtig zu (Abb. 5)

In einem realen Anwendungsfall müssten Data Scientists das Modell professioneller entwickeln, um beispielsweise Probleme wie Overfitting zu vermeiden. Für das gewählte Beispiel ist das nicht notwendig. Dennoch stellt sich die Frage, wie praktikabel der Anwendungsfall ist. Sollten Data Scientists zum Trainieren neuronaler Netze klassische Rechner durch eine Quantum Processing Unit (QPU) ersetzen? Die Antwort ist: Nein.

Das Beispiel zeigt die prinzipielle Machbarkeit des Anwendungsfalls. Das trainierte QNN ist jedoch weder im Hinblick auf die Qualität noch auf die Trainingsdauer einer klassischen Variante überlegen. Im Gegenteil: Der Einsatz eines echten Quantencomputers anstelle eines Simulators würde mehrere Tage oder sogar Wochen dauern. Das liegt einerseits an den Wartezeiten, aber auch an der reinen Rechenzeit. Ein klassischer Computer mit Grafikbeschleuniger (Graphics Processing Unit – GPU) erledigt diese Aufgabe deutlich schneller. Die Praxistauglichkeit ist für diesen Anwendungsfall daher (noch) nicht gegeben.

Die Tests unterstreichen das grundsätzlich hohe Potenzial von Quantencomputern für den Bereich Data Science und maschinelles Lernen. Die aktuelle NISQ-Generation kann in einigen Anwendungsgebieten schon heute einen Mehrwert liefern. Für Quantum Sampling hat die Wissenschaft die Quantenüberlegenheit bereits gezeigt. Quantencomputer sind vor allem in Bereichen stark, die auf Zufallszahlen und Kombinatorik bauen. Ein mögliches Anwendungsgebiet sind Markov-Ketten.

Potenziell können Quantencomputer auch für neuronale Netze einen Mehrwert bieten, aber auf dem heutigen Stand der Technik sind sie dafür noch keine realistische Alternative. Hier bleiben klassische Rechner erste Wahl. Bis neuere Generationen verfügbar sind, sollten sich Data Scientists auf die naheliegenden Einsatzgebiete konzentrieren. Es lohnt sich aber in jedem Fall, die Entwicklung der Quantencomputer im Blick zu behalten.

Christian Koch
ist Datenarchitekt bei der TeamBank AG und Dozent an der Technischen Hochschule Nürnberg Georg Simon Ohm. Seine Spezialgebiete umfassen Datenarchitekturen, Data Science und Machine Learning.

Eldar Sultanow
ist Architekt bei Capgemini. Seine Schwerpunkte sind moderne Softwarearchitekturen, Data Science und Unternehmensarchitekturmanagement.

(map)