Einführung in Primitives

Paketversionen

Der Code auf dieser Seite wurde mit den folgenden Anforderungen entwickelt. Wir empfehlen, diese oder neuere Versionen zu verwenden.

qiskit[all]~=2.3.0
qiskit-ibm-runtime~=0.43.1

Warum hat Qiskit Primitives eingeführt?

Ähnlich wie in den Anfängen klassischer Computer, als Entwickler CPU-Register direkt manipulieren mussten, lieferte das frühe Interface zu QPUs schlicht die Rohdaten der Steuerelektronik zurück. Das war kein großes Problem, solange QPUs in Laboren betrieben wurden und nur Forschern direkten Zugang gewährten. Da die meisten Entwickler mit der Aufbereitung solcher Rohdaten zu 0en und 1en weder vertraut sein würden noch sein sollten, führte Qiskit backend.run ein – eine erste Abstraktionsschicht für den Cloud-Zugriff auf QPUs. Dadurch konnten Entwickler mit einem vertrauten Datenformat arbeiten und sich auf das Wesentliche konzentrieren.

Als der Zugang zu QPUs weiter verbreitet wurde und immer mehr Quantenalgorithmen entwickelt wurden, entstand erneut der Bedarf nach einer übergeordneten Abstraktionsebene. Als Antwort darauf führte Qiskit das Primitives-Interface ein, das für zwei zentrale Aufgaben in der Quantenalgorithmusentwicklung optimiert ist: die Schätzung von Erwartungswerten (Estimator) und das Sampling von Circuits (Sampler). Das Ziel ist es einmal mehr, Entwicklern zu helfen, sich stärker auf Innovation und weniger auf Datenkonvertierung zu konzentrieren. Das Primitives-Interface löst das backend.run-Interface ab, da Sampler denselben direkten Hardware-Zugriff bietet, den backend.run bereitgestellt hat.

Was ist ein Primitive?

Computersysteme bauen auf mehreren Abstraktionsschichten auf. Abstraktionen ermöglichen es dir, dich auf eine bestimmte Detailtiefe zu konzentrieren, die für die jeweilige Aufgabe relevant ist. Je näher du der Hardware kommst, desto niedrigere Abstraktionsebenen benötigst du (zum Beispiel musst du möglicherweise Daten auf der Ebene von CPU-Instruktionen verschieben oder manipulieren). Je komplexer die Aufgabe, die du ausführen möchtest, desto höher sind die erforderlichen Abstraktionsebenen (zum Beispiel könnte eine Programmbibliothek für algebraische Berechnungen zum Einsatz kommen).

In diesem Kontext ist ein Primitive die kleinste Verarbeitungseinheit – der einfachste Baustein, aus dem sich auf einer bestimmten Abstraktionsebene etwas Nützliches zusammensetzen lässt.

Die jüngsten Fortschritte im Quantencomputing haben den Bedarf erhöht, auf höheren Abstraktionsebenen zu arbeiten. Da sich das Feld in Richtung größerer Quantum Processing Units (QPUs) und komplexerer Workflows bewegt, verlagert sich der Fokus vom Interagieren mit einzelnen Qubit-Signalen hin zur Betrachtung von Quantengeräten als Systeme, die notwendige Aufgaben erfüllen.

Die zwei häufigsten Aufgaben für Quantencomputer sind das Sampling von Quantenzuständen und die Berechnung von Erwartungswerten. Diese Aufgaben haben das Design der Qiskit Primitives motiviert: Estimator und Sampler.

• Estimator berechnet Erwartungswerte von Observablen bezüglich Zuständen, die von Quantum Circuits präpariert wurden.
• Sampler sampelt das Ausgaberegister aus der Ausführung von Quantum Circuits.

Kurz gesagt: Das durch die Qiskit Primitives eingeführte Berechnungsmodell bringt die Quantenprogrammierung einen Schritt näher an den heutigen Stand der klassischen Programmierung, bei der der Fokus weniger auf den Hardware-Details und mehr auf den angestrebten Ergebnissen liegt.

Definition und Implementierungen von Primitives

Es gibt zwei Arten von Qiskit Primitives: die Basisklassen und deren Implementierungen. Die Estimator- und Sampler-Primitives werden durch Open-Source-Basis-Klassen definiert, die im Qiskit SDK (im Modul qiskit.primitives) enthalten sind. Provider (wie Qiskit Runtime) können diese Basisklassen nutzen, um eigene Sampler- und Estimator-Implementierungen abzuleiten. Die meisten Nutzer werden mit Provider-Implementierungen interagieren, nicht mit den Basis-Primitives.

Basisklassen

Die Base-Primitives sind abstrakte Klassen, die ein gemeinsames Interface für die Implementierung von Primitives definieren. Alle anderen Klassen im Modul qiskit.primitives erben von diesen Basisklassen. Entwickler sollten diese Klassen verwenden, wenn sie ihr eigenes auf Primitives basierendes Ausführungsmodell für einen bestimmten Provider erstellen möchten. Diese Klassen können auch für diejenigen nützlich sein, die hochgradig angepasste Verarbeitungen vornehmen wollen und die vorhandenen Primitives-Implementierungen für ihre Bedürfnisse als zu einfach empfinden. Allgemeine Nutzer werden die Basisklassen nicht direkt verwenden.

BaseEstimatorV1 und BaseSamplerV1 – Die V1-Primitives sind zwar noch verwendbar, diese Leitfäden konzentrieren sich jedoch auf die V2-Primitives, da diese die neueste und am häufigsten verwendete Version sind.

BaseEstimatorV2 und BaseSamplerV2 – Die Qiskit-Referenz-Primitives folgen diesen Interface-Spezifikationen.

Implementierungen

Alle Primitives werden aus den Basisklassen erstellt und haben daher dieselbe allgemeine Struktur und Verwendung. Zum Beispiel ist das Eingabeformat für alle Estimator-Primitives identisch. Es gibt jedoch Unterschiede in den Implementierungen, die sie einzigartig machen.

Dies sind Implementierungen der Primitives-Basisklassen:

• Die Qiskit Runtime Primitives, EstimatorV2 und SamplerV2, bieten eine ausgefeiltere Implementierung (beispielsweise durch Fehlerminderung) als Cloud-basierter Dienst. Diese Implementierung der Basis-Primitives wird für den Zugriff auf IBM Quantum®-Hardware verwendet.

• StatevectorEstimator und StatevectorSampler – Referenzimplementierungen der Primitives, die den in Qiskit integrierten Simulator verwenden. Sie sind mit dem Qiskit-Modul quantum_info aufgebaut und liefern Ergebnisse auf Basis idealer Zustandsvektor-Simulationen. Der Zugriff erfolgt über Qiskit. Weitere Informationen zur Verwendung findest du unter Exakte Simulation mit Qiskit Primitives.

• BackendEstimatorV2 und BackendSamplerV2 – Mit diesen Klassen kannst du beliebige Quantencomputing-Ressourcen in ein Primitive „einwickeln". So kannst du Primitive-style Code für Provider schreiben, die noch kein auf Primitives basierendes Interface besitzen. Diese Klassen lassen sich genauso verwenden wie der reguläre Sampler und Estimator, müssen jedoch mit einem zusätzlichen backend-Argument initialisiert werden, um den gewünschten Quantencomputer auszuwählen. Der Zugriff erfolgt über Qiskit. Weitere Informationen findest du im Leitfaden zu Backend-Primitives.

Optionen

Du kannst Primitives Optionen übergeben, um sie an deine Bedürfnisse anzupassen. Während das Interface der run()-Methode der Primitives über alle Implementierungen hinweg gleich ist, sind es die Optionen nicht. Konsultiere die API-Referenzen für eine bestimmte Primitives-Implementierung, um mehr über die unterstützten Optionen zu erfahren.

Sieh dir zum Beispiel die Themen Estimator-Optionen und Sampler-Optionen an, um mehr über die Optionen der Qiskit Runtime Primitives zu erfahren, oder die Qiskit Aer API-Referenzen für die Qiskit Aer Primitives-Optionen.

Vorteile der Qiskit Primitives

Mit Primitives können Qiskit-Nutzer Quantencode für eine bestimmte QPU schreiben, ohne jeden Detail explizit verwalten zu müssen. Außerdem kannst du durch die zusätzliche Abstraktionsschicht möglicherweise einfacher auf erweiterte Hardware-Funktionen eines bestimmten Providers zugreifen. Mit den Qiskit Runtime Primitives kannst du beispielsweise von den neuesten Fortschritten in der Fehlerminderung und -unterdrückung profitieren, indem du Optionen wie das resilience_level des Primitives anpasst, anstatt eigene Implementierungen dieser Techniken zu erstellen.

Für Hardware-Provider bedeutet die native Implementierung von Primitives, dass du deinen Nutzern einen direkteren Zugang zu deinen Hardware-Funktionen wie erweiterten Nachverarbeitungstechniken ermöglichst. Es wird dadurch einfacher für deine Nutzer, von den besten Fähigkeiten deiner Hardware zu profitieren.

Nächste Schritte

Empfehlungen

• Verstehe den Primitive-Eingaben und -Ausgaben.
• Sieh dir detaillierte Beispiele an.
• Übe mit Primitives, indem du die Lektion zur Kostenfunktion in IBM Quantum Learning durcharbeitest.
• Lies Erstelle einen Provider, um zu erfahren, wie du eigene Sampler- und Estimator-Primitives implementierst.
• Sieh dir die API-Referenzen an.
• Lies Migration zu V2-Primitives.
• Erfahre mehr über die Qiskit Runtime Primitives, die für die Ausführung von Circuits auf IBM QPUs verwendet werden.