© Carlos Castilla / 123RF.com

Das quelloffene Framework Qiskit soll Quantencomputertechnologie nicht nur verständlich und anwendbar machen, sondern auch produktionsreif. Die Community um das Projekt wächst, und es findet sich an zahlreichen Stellen der Quantum-Open-Source-Landschaft wieder.

Das Entwickeln von Quantenalgorithmen und entsprechenden Anwendungen setzt leistungsfähige Quantenchips voraus. Bei IBM arbeitet man daran, die Leistungsfähigkeit im Zusammenspiel von Hard- und Software kontinuierlich zu steigern. Die dazu geplanten Meilensteine [1] zeigt die IBM Quantum Development Roadmap (Abbildung 1). Um von IBM Quantum Hardware profitieren zu können, gilt es, Software und Infrastruktur so zu entwickeln, dass sie sich mit unterschiedlichsten Bedürfnissen und Erfahrungen nutzen lassen. Das erfordert Tools für verschiedene Entwicklertypen.

Abbildung 1: Das Team hat in der IBM Quantum Development Roadmap genau festgehalten, welche Ziele es wann erreichen will.

Kernel-Developer arbeiten an der direkten Schnittstelle zur Hardware, damit sich schnellere und bessere Quantenschaltkreise auf echter Hardware erstellen lassen. 2021 hatte Qiskit Runtime [2] sein Marktdebüt. Dahinter steckt eine Cloud-basierte Laufzeitumgebung, die sich aus klassischen und Quantensystemen zusammensetzt. In Zukunft sollen dynamische Schaltungen eine Rückkopplung und Weiterleitung von Quantenmessungen ermöglichen. Darüber hinaus soll Qiskit ermöglichen, Quantenprozessoren parallel zu verwenden und Techniken zur Fehlerkorrektur einführen.

Algorithmen-Developer setzen sogenannte Sampler und Estimator Primitives ein, um einfach und effizient mit Wahrscheinlichkeitsverteilungen und Erwartungswerten zu arbeiten. Während Sampler Primitives durch Abtasten von Quantenschaltungen Quasi-Wahrscheinlichkeiten erzeugen, berechnen Estimator Primitives die Erwartungswerte von Quantenoperatoren. Modell-Developer wiederum entwickeln Quantenanwendungen, um Lösungen für komplexe Probleme in ihren spezifischen Domänen wie maschinellem Lernen, Optimierung oder den Naturwissenschaften zu finden. Das Ziel liegt hier darin, keine spezifische Quantenexpertise zu benötigen.

Hinter Qiskit (als “Kiss-Kit” gesprochen) steckt ein frei verfügbares Software Development Kit (SDK), um mit Quantencomputern auf dem Level von Impulsen, Schaltkreisen oder Applikationsmodulen zu arbeiten. So lautet zumindest frei übersetzt die Definition, die sich derzeit auf der Startseite des SDK findet. Das Projekt ist seit der ersten Veröffentlichung 2017 nicht nur stark gewachsen, sondern hat sich darüber hinaus an zahlreichen Stellen fundamental verändert: Das Entwicklungsteam teilte eine der Kernkomponenten in einzelne Bestandteile auf, strukturierte die Verantwortlichkeiten innerhalb der zuständigen Teams neu und führte mit Qiskit Runtime ein neues Programmierparadigma ein.

Abbildung 2 gibt einen Überblick über Qiskit und die wesentlichen Projekte innerhalb der Qiskit-Community. Daneben gibt es zahlreiche andere Projekte, die den Namen Qiskit enthalten und einen wichtigen Teil der Quantum-Open-Source-Landschaft bilden [3].

Abbildung 2: Diese Übersicht zeigt die größten und typischerweise stabilsten Projekte im Qiskit-Umfeld.

Das Ökosystem

In Qiskit Terra [4] hat das Team grundlegende Funktionen (Core Capabilities) implementiert. Es handelt sich um die größte Komponente mit den meisten Werkzeugen für Quantenberechnungen im Qiskit-Ökosystem. Viele der übrigen Komponenten weisen Abhängigkeiten dazu auf. Die Tabelle “Qiskit-Module im Überblick” listet einige wichtige Bestandteile auf.

Die Kategorie High Level Applications umfasst vier separate Komponenten. Jede einzelne fokussiert sich auf ein anderes Themengebiet, innerhalb dessen Quantencomputing potenziell einen Mehrwert gegenüber klassischen IT-Systemen bietet.

Qiskit Nature zielt darauf ab, naturwissenschaftliche Problemstellungen mithilfe von Quantenalgorithmen zu lösen. Dazu gehört das Finden von Grund- und Anregungszuständen von Molekülstrukturen.

Qiskit Machine Learning stellt Werkzeuge für eine Reihe von Anwendungen im Forschungsbereich Quantum Machine Learning zur Verfügung. Dazu gehören Quantum Neural Networks (QNNs), Quantum Generative Adversarial Networks (QGANs) und Quantum Kernels. Die Klasse »TorchConnector« bietet eine Schnittstelle zu PyTorch und erlaubt es, klassische Abläufe im Bereich der künstlichen Intelligenz mit quantenbasierten Ansätzen zu kombinieren.

Qiskit Finance bietet quantenbasierte Ansätze, um typische Fragestellungen im Finanzwesen zu lösen, zum Beispiel Portfoliooptimierung, Risikoanalyse und Preisbewertung von Finanzoptionen.

Qiskit Optimization umfasst Werkzeuge, die mithilfe von Quantenalgorithmen Optimierungsprobleme beseitigen sollen. Zu den typischen Anwendungsbeispielen gehören die bekannten NP-schweren Max-Cut- und Traveling-Salesman-Probleme.

Der Hauptfokus der High Level Applications liegt darauf, Anwendungsproblemen mit quantenbasierten Ansätzen zu begegnen. Systemnahe oder Low-Level-Applikationen dagegen ermöglichen enger mit echten Quantencomputern verknüpfte Forschungsvorhaben.

Die Bibliothek Qiskit Experiments dient dazu, Charakterisierungs-, Kalibrierungs- und Verifikationsexperimente auf echten Qubits laufen zu lassen. Sie kommt beim Kalibrieren und Benchmarking von Quantencomputern zum Einsatz. Ingenieuren und Wissenschaftlern greift Qiskit Metal mit grafischer Unterstützung beim Entwickeln von Chips für supraleitende Quantencomputer unter die Arme.

Mit Qiskit Dynamics lassen sich zeitabhängige Quantensysteme bauen, transformieren und lösen. In Sachen Simulatoren und Hardware Provider liefert Qiskit Aer effiziente Simulatoren, die es erlauben, Quantenberechnungen mit bestimmten Einschränkungen auf klassischen Computern zu simulieren.

Quantenschaltkreise auf echten Quantencomputern auszuführen, erfordert eine Schnittstelle zwischen Qiskit und dem entsprechenden Hardwareanbieter. Diese Schnittstelle gibt es bereits bei einigen Anbietern, darunter IBM, AQT und IonQ.

Quantum Composer

Der IBM Quantum Composer bietet einen einfachen Einstieg, um Quantenschaltkreise online visuell mittels Drag & Drop zu definieren. Sie benötigen lediglich einen kostenlosen IBM Quantum Account [5]. Das Ergebnis Ihrer Arbeit lässt sich direkt als Code exportieren. In Abbildung 3 sehen Sie einen sogenannten GHZ-Zustand [6] für drei Qubits, bei dem alle maximal verschränkt sind.

Abbildung 3: Mithilfe von IBM Quantum Composer lassen sich Quantenschaltkreise online einfach abbilden.

Im IBM Quantum Lab können Sie Code direkt schreiben oder den zuvor exportierten Code bearbeiten. Listing 1 zeigt als Beispiel das Erstellen eines GHZ-Zustands. Dafür bringen Sie Qubit 0 in eine Superposition und verschränken anschließend die andern Qubits mithilfe sogenannter CX-Gatter (controlled-NOT) mit Qubit 0. Die Ergebnisse aus Abbildung 3 wurden mit dem Aer-Simulator berechnet und bestätigen, dass ein GHZ-Zustand vorliegt.

from qiskit import QuantumCircuit, execute, Aer, QuantumRegister
qc = QuantumCircuit( 3, 3
 )
qc.h( 0 )
qc.cx( 0, 1 )
qc.cx( 0, 2 )
qc.measure_all()
simulator = Aer.get_backend( 'qasm_simulator' )
job = execute( qc, simulator, shots=4000 )
result = job.result()
counts=result.get_counts()
print(counts)

Statt den Schaltkreis zu simulieren, kann man ihn auf einem Quantencomputer laufen lassen. Als Backend für das Beispiel aus Listing 2 diente anstelle eines Simulators einer der verfügbaren IBM-Quantencomputer. Hier fallen die Resultate aufgrund des Rauschens auf dem realen System nicht ganz so eindeutig aus. Unter den 4000 Messungen finden sich auch einige, die weder |000> noch |111> zeigen – auch wenn der Großteil nach wie vor die richtigen Zustände abbildet. Wie sich solche Fehler vermeiden lassen, sehen wir später.

from qiskit import IBMQ
# Abfrage der frei verfügbaren Quantencomputer
provider = IBMQ.load_account()
provider = IBMQ.get_provider( hub='ibm-q' )
print(provider.backends())
# Ausführung auf einem realen Quantencomputer
device = provider.get_backend( 'ibmq_lima' )
job = execute( qc, backend=device, shots=4000 )
result = job.result()
counts=result.get_counts()
print(counts)

Qiskit Runtime

Sie können Python und Qiskit auch lokal auf einem Computer installieren. Wir demonstrieren das hier zusammen mit Qiskit Runtime, dem neuen Paradigma, um Berechnungen auf Quantencomputern mit Qiskit auszuführen. Die Idee dahinter: Hybride Algorithmen, die klassische mit Quantenberechnungen mischen, führt man direkt in der Cloud aus, statt zwischen einem lokalen, klassischen Computer und einem Quantencomputer in der Cloud zu kommunizieren. Dazu dienen vorgefertigte Programme, die dann auf der Runtime-Architektur laufen und die Berechnung auf den gewünschten Daten übernehmen.

Die Runtime zeigt sowohl für hybride als auch für generellere Algorithmen Verbesserungen auf, wie etwa für »Sampler«, der die Quasi-Wahrscheinlichkeiten für einen Quantenschaltkreis berechnet. Sie verwenden Qiskit Runtime wieder mit einem IBM Quantum Account. Alternativ funktioniert eine Qiskit-Runtime-Instanz in der IBM-Cloud. Dafür installieren Sie vorab via PIP sowohl Qiskit (Paket qiskit) als auch den Qiskit Runtime IBM Client (qiskit-ibm-runtime).

Zuerst gilt es, den generellen GHZ-Zustand für n Qubits (Listing 3, Zeile 6 und 7) zu erstellen (oben haben Sie das Beispiel für drei Qubits gesehen). Anschließend wenden Sie ein bitweises XOR mit der Zahl 1 auf diesen Zustand an, um das erste Qubit zu flippen (Zeile 8). Danach benutzen Sie »Sampler« (ab Zeile 16), um die Quasi-Wahrscheinlichkeiten des Schaltkreises zu ermitteln.

from qiskit.circuit.library import XOR
from qiskit_ibm_runtime import QiskitRuntimeService, Sampler
N = 5
qc2 = QuantumCircuit(N)
qc2.h( 0 )
for x in range( 1, N ):
  qc2.cx( 0, x )
qc2.compose( XOR(N,1), inplace=True )
qc2.measure_all()
program_inputs = {
  "circuits": qc2,
  "circuit_indices": [0],
}
service = QiskitRuntimeService( channel="ibm_quantum", token=IBM-Quantum-API-Key)
options = { 'backend_name': 'ibmq_lima' }
job = service.run(
  program_id="sampler",
  options=options,
  inputs=program_inputs,
)
print(job.result())

Beispiel: Serious Games

Sie wissen nun, wie Sie mit Qiskit die ersten Schritte mit Quantum Computing machen können. Zusätzlich erweisen sich sogenannte Serious Games als hilfreich, wenn Sie sich der neuen Technologie annähern und ein Verständnis dafür aufbauen wollen.

Ein Beispiel bietet das Quanten-Münzspiel, das sich die Prinzipien der Superposition und Interferenz zunutze macht. Dabei symbolisiert ein Qubit eine Münze, die zwei Spieler (Alice und Bob) abwechselnd entweder umdrehen oder in ihrer aktuellen Position belassen. Das Umdrehen entspricht dem Anwenden eines X-Gatters auf das Qubit, das Belassen dem Zustand eines Id-Gatters. Der Ablauf ist immer gleich: Am Anfang liegt Kopf oben, was dem Zustand |1> entspricht. Alice beginnt, drei Züge werden verdeckt gespielt. Am Ende gewinnt Alice, falls Kopf oben liegt, und Bob bei Zahl.

Klassisch liegt die Gewinnchance für beide bei jeweils 50 Prozent, da keiner die Züge des anderen kennt. Mit einem Quantencomputer lässt sich die Wahrscheinlichkeit jedoch beeinflussen. Alice kann zusätzlich ein Hadamard-Gatter anwenden, um das Qubit in eine Superposition zu versetzen, sodass die Münze quasi auf der Kippe zwischen Kopf und Zahl steht. Bobs Zug hat dann keinen Einfluss mehr, da weder die Anwendung des X- noch des Id-Gatters den Zustand des Qubits und somit der Münze maßgeblich verändert. Wendet Alice in ihrem letzten Zug nun wieder ein H-Gatter an, das die Superposition auflöst, gewinnt sie mit einer Wahrscheinlichkeit von 100 Prozent. Abbildung 4 zeigt den Spielverlauf anhand der Bloch-Sphäre.

Abbildung 4: Bei einem Quanten-Münzspiel stehen die Chancen für die beiden Spieler nicht mehr gleich.

Ein weiteres, etwas komplexeres Beispiel ist das GHZ-Spiel, in dem man sich die Verschränkung des oben erwähnten GHZ-Schaltkreises zunutze macht. Die Einzelheiten und genauen Anleitungen zu beiden Spielen finden Sie bei Interesse auf der Github-Seite eines der Autoren [7].

from qiskit_aqt_provider import AQTProvider
aqt = AQTProvider('MY_TOKEN')
print(aqt.backends())
sim_backend = aqt.backends.aqt_qasm_simulator

Team Quantimize

Hinter dem Team Quantimize [8] stecken fünf Quantentechnologiestudenten, die bereits an einigen Quantum-Challenges wie dem Qiskit Global Hackathon 2021 teilgenommen haben. Ihr bisher größtes Projekt war jedoch die Deloitte Quantum Climate Challenge 2022. Die Aufgabe bestand darin, Flugrouten zu optimieren, um die Erdatmosphäre möglichst zu schonen, da das Verbrennen von Kerosin nicht überall den gleichen Effekt hat. Team Quantimize nutzte Atmosphärendaten des Deutschen Luft- und Raumfahrtzentrums (DLR) sowie Informationen über Mindestabstände der Deutschen Flugsicherung (DFS), um eine optimierte, quantenbasierte Lösung zu finden.

Die Idee war es, die Atmosphärendaten auf eine Karte aus Qubits zu mappen, die sich alle in Superposition befinden. Mittels des Quantum Approximate Optimization Algorithm (QAOA) ermittelten die Studierenden nun die beste Flugroute. Bei QAOA handelt es sich um einen iterativen Prozess, der im Zusammenspiel aus einem klassischen und einem Quantencomputer ein Optimierungsproblem behebt (Abbildung 5). Der Algorithmus sortiert die Qubits in die Zustände |0> und |1>, sodass die Trennlinie zwischen ihnen die Flugroute ergibt.

Abbildung 5: Als iterativer Prozess, bei dem ein klassischer und ein Quantencomputer zusammenarbeiten, löst QAOA Optimierungsprobleme.

Von Qiskit versprach sich das Team für diese Challenge ein einfaches Handling sowie ein Optimum aus Simulation und Berechnung auf einem Quantencomputer. Dank der guten Dokumentation konnten sie den bestehenden QAOA-Algorithmus direkt auf ihr Problem anwenden und in einen Quanten-Circuit umwandeln. Listing 5 demonstriert das Kernelement der Optimierung, wobei »cost_grid« für die diskretisierten Atmosphärendaten steht.

Das Team Quantimize setzte Qiskit dazu ein, seinen Quanten-Circuit zu simulieren und anschließend auf einem IBM-Quantencomputer laufen zu lassen. Mittels Brute Force ließ sich bestätigen, dass sowohl die Simulation als auch der Quantencomputer passende Ergebnisse liefern. Mit dieser Idee konnte das Team die Jury überzeugen.

import qiskit
def run_QAOA( cost_grid, backend=qiskit.Aer.get_backend( 'qasm_simulator' ) ):
  # Kostenfunktion aus einer Kostenmatrix (cost_grid) generieren;
  # selbst geschriebene Funktion
  function, coeffs = construct_function( cost_grid )
  # Quadratisches Programm erstellen; selbst geschriebene Funktion,
  # nutzt qiskit.optimization.QuadraticProgram
  qp = generate_QP( coeffs, len( cost_grid ) )
  # Backend und Optimierungsalgorithmus initialisieren
  qins = qiskit.utils.QuantumInstance( backend=backend, shots=1000, seed_simulator=123 )
  meo = qiskit_optimization.algorithms.MinimumEigenOptimizer( min_eigen_solver=qiskit.algorithms.QAOA( reps=1, quantum_instance=qins) )
  # Problem mit dem eingebauten QAOA-Algorithmus lösen
  result = meo.solve(qp)

Quantum Error Mitigation

Quantum Error Mitigation ebnet den Weg für die kommerzielle Nutzung von Quantencomputern und ist eine wichtige Technik, um heutige Quantencomputer ohne fehlertolerante Qubits nutzen zu können. Ein simples Beispiel zur Measurement Error Mitigation soll die Implementierung dieser Fehlervermeidungstechnik etwas detaillierter verdeutlichen.

Eine einfachere Form des Rauschens lässt sich durch die abschließende Messung im Schaltkreis erzeugen (Listing 6). An diesem Punkt wird einer der möglichen Bit-Strings extrahiert, der unter anderem durch das aufgrund der Messung verursachte Rauschen nicht exakt ist. Als Beispiel dient hier wieder der GHZ-Schaltkreis, die Simulation eines rauschfreien Ergebnisses haben wir schon gesehen. Beim Ausführen auf einem realen Quantencomputer zeigt sich das Rauschen deutlich in der breiteren Verteilung, die auch Wahrscheinlichkeiten der nicht korrekten Zustände enthält (Abbildung 6).

from qiskit.visualization import plot_histogram
qdev = my_provider.get_backend( 'ibmq_lima' )
results = execute( qc, qdev, shots=10000 ).result()
noisy_counts = results.get_counts()
print( noisy_counts )
plot_histogram( noisy_counts )

Abbildung 6: Durch abschließendes Messen im Schaltkreis lässt sich eine simplere Form des Rauschens erzeugen.

Im einfachen Fall eines Fehlervermeidungskonzepts werden nun die einzelnen acht Basiszustände durchlaufen, die sich aus den drei Qubits des GHZ-Schaltkreises ergeben (Listing 7).

from qiskit.utils.mitigation import *
qr = QuantumRegister( 2 )
meas_calibs, state_labels = complete_meas_cal( qr=qr, circlabel='mcal' )
for circuit in meas_calibs:
  print('Circuit',circuit.name)
  print(circuit)
  print()

Als Beispiel zeigt Abbildung 7 drei der acht Schaltkreise. Aus den einzelnen Messergebnissen lässt sich die Korrekturmatrix aus Abbildung 8 errechnen, die die Abweichungen berücksichtigt. Diese Korrektur wendet man auf die Messergebnisse des Beispielschaltkreises an (Listing 8). In Abbildung 9 sieht man deutlich, dass die Measurement-Error-Mitigation-Methode die durch Rauschen entstandenen Fehler sehr gut korrigiert.

Abbildung 7: Im Rahmen der Measurement Error Mitigation werden die acht einzelnen Basiszustände durchlaufen, die sich aus den drei Qubits des GHZ-Schaltkreises ergeben.

Abbildung 8: Aus den einzelnen Messergebnissen lässt sich eine Korrekturmatrix errechnen, die die Abweichungen berücksichtigt.

Abbildung 9: Die Measurement Error Mitigation per Korrekturmatrix hilft dabei, die durch Rauschen bedingten Fehler zu korrigieren.

from qiskit.compiler import transpile, assemble
t_qc = transpile( meas_calibs, qdev )
qobj = assemble( t_qc, shots=10000 )
cal_results = qdev.run( qobj, shots=10000 ).result()
meas_fitter = CompleteMeasFitter( cal_results, state_labels, circlabel='mcal' )
array_to_latex( meas_fitter.cal_matrix )
# Get the filter object
meas_filter = meas_fitter.filter
# Results with mitigation
mitigated_results = meas_filter.apply( results )
mitigated_counts = mitigated_results.get_counts()
noisy_counts = results.get_counts()
plot_histogram( [ noisy_counts, mitigated_counts ], legend=[ 'noisy', 'mitigated' ] )

Da der Aufwand der zusätzlichen Messungen für die Bestimmung der Korrekturmatrix exponentiell mit der Anzahl der Qubits wächst, hat man diese Methode weiter verfeinert. Das vermeidet Fehler bei Messungen von Schaltkreisen auch dann schnell und effektiv, wenn eine größere Anzahl an Qubits Verwendung findet.

In Qiskit zeigt sich diese verfeinerte Methode in den Ergebnisausgaben der Sampler-Primitive (Quasi-Probabilities). Benutzt man wieder den einfachen Schaltkreis für den GHZ-Zustand aus dem obigen Beispiel, gestaltet sich die Berechnung mit »Sampler« auf dem nicht rauschfreien QASM-Simulator wie in Listing 9. Die fast gleichmäßige Wahrscheinlichkeitsverteilung der beiden korrekten Zustände wird hier in quasi-wahrscheinlicher Verteilung abgebildet.

service = QiskitRuntimeService()
with Sampler( circuits=[qc], service=service, options={ "backend": "ibmq_qasm_simulator" } ) as sampler:
  result = sampler( circuits=[0], shots=10000 )
  print( result )
SamplerResult( quasi_dists=[{'000': 0.4944, '111': 0.5056}], metadata=['shots': 10000}] )

Ungeachtet der Erfolge, die sich mit der Measurement Error Mitigation erzielen lassen, liegt ein Fokus der aktuellen Forschungen zu Quantum Error Mitigation auf weitergehenden, allgemein anwendbaren Methoden. Zero Noise Extrapolation (ZNE) und die probabilistische Fehlerunterdrückung (Probabilistic Error Cancellation, PEC) haben sich als vielversprechend erwiesen.

Bei ZNE arbeitet man mit Rauschverstärkung direkt im relevanten Schaltkreis, bei PEC erlernt man das Rauschen anhand zufällig ausgewählter Instanzen von verrauschten Schaltungen. Ein Blog-Artikel [9] von IBM Research über die Nützlichkeit dieser Methoden gibt dazu einen detaillierteren Überblick.

Fazit

Bei Qiskit handelt es sich um das Vorhaben einer großen Community, die Quantencomputertechnologie verständlich, anwendbar und produktionsreif machen will. Gemeinschaftsbeiträge wie Meetups oder eine jährliche Summer School sind essenziell für die Weiterentwicklung des Projekts. Dieser Artikel versteht sich als ein weiteres Beispiel dafür: Er soll die ersten Schritte im Bereich Quantum Computing für Interessierte erleichtern und sie dazu bewegen, sich innerhalb dieser großen, stetig wachsenden Community zu engagieren. (csi/jlu)