Quantencircuits ausführen

Schau dir das Video über Quantencircuits und Primitives von Olivia Lanes an, oder öffne es in einem separaten Fenster auf YouTube.

Überblick über die Lektion

Diese Lektion bietet einen Überblick über die Grundlagen der Durchführung einer Quantenberechnung im Utility-Maßstab, von der verwendeten Quantenhardware bis hin zu den Prinzipien, die beim Entwurf eines Quantencircuits zu beachten sind. Am Ende dieser Lektion solltest du idealerweise wissen:

1. Was IBM®-Quantencomputer tatsächlich sind. Du musst die Grundlagen der Hardware-Eigenschaften kennen, um deine Quantencircuits optimal für die Ausführung darauf zu gestalten.

2. Was Qiskit ist, was Primitives sind und wie wir sie nutzen können, um Quantencircuits zu erstellen und auszuführen.

3. Der typische Workflow, den wir bei der Durchführung von Experimenten im großen Maßstab verfolgen. Dazu gehören die Auswahl der besten Primitives für deinen Anwendungsfall, die Abbildung eines Problems auf einen Quantencircuit sowie die Anwendung von Error Mitigation und Error Suppression, die es uns ermöglichen, das Maximum aus diesen Maschinen herauszuholen.

Hardware – IBM-Quantenprozessoren

Um zu verstehen, wie wir beim Entwurf großer Quantencircuits optimale Entscheidungen treffen können, müssen wir ein wenig über die tatsächliche Hardware wissen, die diese Circuits ausführen wird. Lass uns also kurz über physische Qubits und IBM-Quantenprozessoren sprechen.

IBM-Quantenprozessoren werden mit supraleitenden Transmon-Qubits gebaut, die elektrische Schaltkreise sind, die aus einem Josephson-Kontakt und einem parallel dazu geschalteten Kondensator bestehen. Der Josephson-Kontakt ist ein nichtlinearer Induktor, der aus zwei überlappenden Schichten supraleitenden Metalls mit einer isolierenden Barriere dazwischen besteht. Bei sehr niedrigen Temperaturen paaren sich die Elektronen in Supraleitern und bilden sogenannte Cooper-Paare. Cooper-Paare können spontan durch die isolierende Barriere von einer Seite des Kontakts zur anderen tunneln. Dieses Tunnelverhalten erzeugt die nichtlinearen Eigenschaften, die unser Qubit ausmachen.

Auf dem Chip werden Mikrowellenübertragungsleitungen hergestellt, um Mikrowellensignale an die Qubits zu liefern. Wenn wir hochkalibrierte Mikrowellenpulse – mit spezifischer Frequenz, Amplitude, Form und Dauer – an die Leitungen anlegen, können wir die Qubits dazu bringen, bestimmte Dinge zu tun. Das bildet die Grundlage unserer Quantengates. Wir fertigen den Chip so, dass benachbarte Qubits in einer bestimmten Gitterstruktur namens Heavy-Hex-Gitter verbunden sind. Diese Konnektivität – die sogenannte Topologie – unserer Prozessoren ist ein wichtiger Faktor beim Entwurf eines Circuits, worüber wir später in der Lektion sprechen werden.

Die Anweisungen für den Mikrowellenpuls gehen von deinem Computer über die Cloud zu raumtemperatur-Kontrollelektronik, die diese Anweisungen interpretiert und die Pulse physisch erzeugt. Nachdem die Raumtemperatur-Kontrollboxen die Pulse erzeugt haben, wandern sie durch Kabel in einen Verdünnungskühlschrank und schließlich zum Quantenchip. Das Signal geht in die Resonatoren, durch einen Drahtbond und fließt dann die Übertragungsleitung hinunter in unsere Qubits.

IBM hat Dutzende von Quantencomputern auf der ganzen Welt, und wir haben unsere Flotte kürzlich so aufgerüstet, dass sie ausschließlich Prozessoren mit mehr als 100 Qubits hat. Einige befinden sich in einem IBM-Quantenrechenzentrum im Norden von New York und werden über die Cloud für alle zugänglich gemacht – und einige sind dedizierte, vor Ort befindliche Systeme, die Partner im IBM Quantum® Network unterstützen. Du kannst dich bei quantum.cloud.ibm.com anmelden, um zu sehen, auf welche Prozessoren du Zugriff hast.

Jeder Prozessor listet drei Leistungsmetriken auf, die wir in der vorherigen Lektion besprochen haben, aber zur Erinnerung: Qubit-Anzahl, EPLG und CLOPS.

• Qubit-Anzahl. Das ist selbsterklärend: Es ist die Anzahl der gesamten verfügbaren Qubits auf einem einzelnen Quantenprozessor. Für ein relativ großes Problem im Utility-Maßstab musst du sicherstellen, dass du einen Prozessor mit genügend Qubits verwendest, um das Problem bewältigen zu können. Aber die Qubit-Anzahl allein ist nicht das einzige, was zählt.

• EPLG, oder „errors per layered gate" (Fehler pro geschichtetem Gate). Dies ist ein Maß für die Qualität der Qubits und Quantengates. Es misst den durchschnittlichen Fehler, den jedes Gate in einem Circuit einführt, der benachbarte Qubits in einer Kette von 100 Qubits verschränkt. Du möchtest, dass dies so klein wie möglich ist.

• CLOPS, oder „circuit layer operations per second" (Circuit-Schichtoperationen pro Sekunde). Dies quantifiziert die Geschwindigkeit des Prozessors. Es misst, wie viele Schichten eines bestimmten Benchmark-Circuits, der als Quantum-Volume-Circuit bezeichnet wird, eine Quantum Processing Unit (QPU) pro Zeiteinheit ausführen kann. Je höher die Zahl, desto schneller können wir rechnen.

Die Bedeutung jeder dieser Metriken variiert je nach spezifischer Anwendung, und in zukünftigen Lektionen werden wir uns reale Beispiele ansehen, um zu sehen, wie sich jeder dieser Faktoren auf das Ergebnis einer Berechnung auswirken kann.

Software: Qiskit und Qiskit Runtime

Um dein Quantenproblem in Anweisungen für einen Quantencomputer umzuwandeln, verwendest du Qiskit, das von IBM entwickelte Open-Source-Software-Development-Kit für die Arbeit mit Quantencomputern. Es gibt auch das Qiskit-Ecosystem – eine Sammlung von Software-Tutorials und -Funktionen, die auf den Kernfunktionalitäten von Qiskit aufbauen oder diese erweitern – und Qiskit Runtime – einen Quantencomputing-Service und ein Programmiermodell, das Nutzern ermöglicht, ihre Quanten-Workloads zu gestalten und zu optimieren und sie mithilfe von Qiskit Runtime Primitives effizient auszuführen.

Ein Primitive ist ein kleiner Baustein, den du verwenden kannst, um einen größeren Circuit oder Job zu entwerfen. Die beiden für uns wichtigsten Primitives sind der Sampler und der Estimator, auf die wir gleich noch genauer eingehen werden.

Mit dem jüngsten Release von Qiskit v1.0 ist Qiskit leistungsfähiger und stabiler denn je geworden. Für diejenigen unter euch, die gerade erst anfangen, seid ihr zum perfekten Zeitpunkt eingestiegen! Für diejenigen, die bereits mit Qiskit vertraut sind, müsst ihr die neueste Version herunterladen und neu installieren. Eine vollständige Installationsanleitung findest du in der Anleitung zur Installation von Qiskit.

Quantencircuits

Jetzt sind wir bereit, die Grundlage von Quantenprogrammen zu besprechen: Quantencircuits. Dieser Abschnitt dient nur als Auffrischung – wenn du nicht mit Quantencircuits vertraut bist, empfehlen wir dir, mehr darüber zu erfahren, indem du die Lektion Quantencircuits im Kurs „Basics of Quantum Information" besuchst, bevor du fortfährst.

Ein Quantencircuit ist ein Netzwerk von Quantengates und Messungen, die durch Leitungen verbunden sind, die Qubits darstellen, wie unten gezeigt. Quantencircuits können wie Notenblätter gelesen werden, von links nach rechts, beginnend bei Zeit 0 auf der linken Seite. Virtuelle Qubits – diejenigen, die noch keinem physischen Qubit auf einem Prozessor zugewiesen wurden – sind in aufsteigender Reihenfolge von oben nach unten aufgelistet.

Gates werden durch verschiedene Symbole auf den Leitungen der beteiligten Qubit(s) dargestellt. Einzelqubit-Gates – wie ein Hadamard-Gate, unten abgebildet (das Kästchen mit dem H) – betreffen nur das Qubit, auf dessen Leitung es platziert ist. Mehrqubit-Gates – wie ein CNOT-Gate, ebenfalls unten gezeigt (das Pluszeichen im Kreis mit einer Linie, die mit q0 verbunden ist) – betreffen zwei oder mehr Qubits. Im dargestellten CNOT-Gate ändert sich der Zustand von q1 entsprechend dem Zustand von q0. Nachdem alle Gates ausgeführt wurden, können wir die Qubits messen, angezeigt durch die schwarzen Gates mit dem Messsymbol. Die Ergebnisse der Messungen werden in klassische Register geschrieben, dem doppellinierten „meas"-Bus unten.

Eine wichtige Eigenschaft eines Circuits ist seine Tiefe. Die Tiefe eines Quantencircuits ist die minimale Anzahl von „Schichten" von Quantengates, die parallel ausgeführt werden und zum Abschluss des Circuits erforderlich sind. Quantengates können parallel (gleichzeitig) ausgeführt werden, solange sie keine Qubits gemeinsam haben. Aber wenn zwei oder mehr Gates auf dasselbe Qubit wirken, können wir sie nicht parallel ausführen – sie müssen in zwei separaten Schichten, eine nach der anderen, ausgeführt werden.

Es gibt eine andere, weniger offensichtliche Methode, die Tiefe eines Circuits zu bestimmen, indem man eine Art Spiel spielt. Die Regeln sind einfach: Ausgehend von einer beliebigen Qubit-Leitung auf der linken Seite muss man nach rechts reisen und die Anzahl der Gates zählen, denen man auf seinem Weg begegnet. Man darf zu einer benachbarten Leitung springen, nur wenn sie durch ein Mehrqubit-Gate mit der aktuellen Leitung verbunden ist. Das Ziel ist, die Anzahl der angetroffenen Gates auf dem Weg zu maximieren. Diese maximale Zahl ist auch die Tiefe des Circuits.

Da die Implementierung von Quantengates Zeit in Anspruch nimmt, entspricht die Tiefe eines Circuits in etwa der Zeit, die ein Quantencomputer für die Ausführung des Circuits benötigt. Einige Maschinen sind aufgrund der Dekohärenzzeiten der Qubits auf dem Prozessor besser für große Tiefencircuits geeignet als andere. Daher müssen wir die Tiefe eines Circuits kennen, um zu wissen, ob er auf einem bestimmten Gerät ausgeführt werden kann.

Entwurf eines Quantencircuits: Qiskit Patterns

Wie gehen wir also beim Entwurf und der Ausführung eines Quantencircuits vor? Der einfachste Weg, einen typischen Quantencomputing-Workflow zu verstehen, sind Qiskit Patterns. Qiskit Patterns sind ein konzeptionelles Framework, das Nutzern ermöglicht, Quanten-Workloads durch die Implementierung bestimmter Schritte mit modularen Tools auszuführen. Dies ermöglicht die Durchführung von Quantencomputing-Aufgaben durch eine leistungsstarke heterogene (CPU/GPU/QPU)-Computing-Infrastruktur. Die Schritte können als Service durchgeführt werden und können Ressourcenmanagement beinhalten, das eine nahtlose Zusammensetzbarkeit neuer Funktionen ermöglicht, sobald sie entwickelt werden.

Hier sind die Hauptschritte, die erfahrene Qiskit-Nutzer wahrscheinlich kennen werden.

1. Abbilden (Map). In diesem Schritt formalisieren wir, wie wir ein allgemeines Problem, das uns interessiert, nehmen und herausfinden, wie wir es in Form eines Quantencircuits auf einen Quantencomputer abbilden können.

2. Optimieren (Optimize). In diesem Schritt verwenden wir den Qiskit Transpiler, um den Circuit auf einer tatsächlichen physischen Qubit-Hardware zu routen und zu platzieren. Dies beinhaltet die Übersetzung der einzelnen Quantengates in Sequenzen von Operationen, die auf der Hardware ausgeführt werden, sowie eine Optimierung der Gate-Platzierung.

3. Ausführen (Execute). Qiskit Runtime Primitives stellen die Schnittstelle zu IBM-Quantum-Hardware bereit, die es ermöglicht, transpilierte Circuits auszuführen. Dieser Schritt umfasst auch Error Suppression- und Mitigation-Techniken, die weitgehend vom Nutzer abstrahiert werden können.

4. Nachverarbeiten (Post-process). In diesem Schritt werden die Daten des Quantenprozessors selbst verarbeitet und dem Nutzer nützliche Ergebnisse zum ursprünglichen Problem geliefert. Im Wesentlichen umfasst dies jede weitere Analyse der gewonnenen Daten.

Abbilden (Map)

Der Map-Schritt stellt im Wesentlichen die Frage: „Wie übersetze ich mein Problem in einen Quantencircuit, der vernünftigerweise auf Quantenhardware ausgeführt werden kann?" Es steht außer Frage: Das Abbilden ist ein schwieriges Problem und ein aktives Forschungsgebiet. Es gibt keine narrensichere Methode, die Erfolg garantiert, aber es gibt empfohlene Richtlinien und Beispiele für Probleme, die wir bereits wissen, wie man sie abbildet.

Die erste Richtlinie lautet: Lass klassische Computer alles tun, was sie besser können. Aufgaben, die für klassische Computer einfach sind, werden wahrscheinlich nicht von einem Quantencomputer profitieren. Quantencomputer sind für Probleme, die klassisch schwer sind. Wenn du natürlich zum allerersten Mal Qiskit oder einen Quantencomputer verwendest, mach dir keine Sorgen um ein rechnerisch komplexes Problem. Teile es in kleinere, handhabbare Probleme auf, die du lösen kannst, bevor du direkt auf ein Projekt im Utility-Maßstab zielst.

Als nächstes übersetze die Ergebnisse für dein Problem, die du messen oder verstehen möchtest, in einen Erwartungswert oder eine Kostenfunktion. Eine Kostenfunktion ist eine problemspezifische Funktion, die das Ziel des Problems als etwas Zu-Minimierendes oder Zu-Maximierendes definiert. Sie kann verwendet werden, um zu sehen, wie gut ein Testzustand oder eine Lösung in Bezug auf dieses Ziel abschneidet. Dieses Konzept kann auf verschiedene Anwendungen in der Chemie, im maschinellen Lernen, im Finanzwesen, in der Optimierung usw. angewendet werden – es spielt keine Rolle, aus welchem Fachgebiet du das Problem angehst.

Beachte auch, dass die Hardware, die du verwenden wirst, eine spezifische Topologie hat, wie wir im Hardware-Abschnitt besprochen haben. Einige Qubits sind verbunden, andere nicht – du musst dein Problem auf einen Circuit abbilden, der die Heavy-Hex-Topologie der IBM-Quantenprozessoren respektiert.

Für jetzt ist das Wichtigste, das du im Hinterkopf behalten solltest, dass diese Phase Übung erfordert. Du musst nicht nur dein Problem, sondern auch die Hardware-Fähigkeiten gut verstehen – und wir werden in zukünftigen Lektionen konkrete Beispiele und Anwendungsfälle durchgehen, um zu sehen, wie all diese Überlegungen ausbalanciert werden können.

Optimieren (Optimize)

Als nächstes müssen wir einen Quantenprozessor auswählen, der genug Qubits in ausreichend hoher Qualität hat, dass wir unseren Quantencircuit ausführen können. Treffe diese Entscheidungen anhand der drei Metriken, die wir im Hardware-Abschnitt besprochen haben: Qubit-Anzahl, EPLG und CLOPS.

Dann optimieren wir unseren Circuit für die ausgewählte Hardware. Zunächst müssen wir unseren Circuit effizient platzieren und routen. Layout bezeichnet die Abbildung der virtuellen Qubits im Circuit auf die physischen Qubits auf dem Prozessor. Routing bezeichnet die Anpassung des Circuits, damit die Konnektivität zwischen virtuellen Qubits im Circuit mit der Konnektivität der physischen Qubits auf dem Prozessor übereinstimmt. Es gibt ein paar Dinge, die man beim Layout- und Routing-Schritt beachten sollte.

1. Nicht alle Qubits sind verbunden. Einige befinden sich auf dem Chip sehr weit voneinander entfernt, und wir müssen Fernwechselwirkungen wo immer möglich reduzieren oder eliminieren. Du könntest eine Sequenz von SWAP-Gates zwischen benachbarten Qubits anwenden, um die Qubit-Informationen zu verschieben, aber SWAP-Gates sind kostspielig und fehleranfällig, daher gibt es möglicherweise bessere Wege. Versuche, zu viele kostspielige SWAP-Gates zu vermeiden.

2. Layout und Routing sind iterative Prozesse. Du kannst es von Hand machen, aber es gibt auch ein Qiskit-Tool namens mapomatic, das Empfehlungen für ein physisches Qubit-Layout basierend auf ungefähren Fehlerraten geben kann. Der Transpiler (den wir gleich besprechen werden) kann auch einen fundierten Vorschlag machen.

Als nächstes können wir Sequenzen von Einzelqubit-Gates, die auf dasselbe Qubit wirken, zu einzelnen Gates zusammensetzen – und wir können manchmal auch unnötige Gates oder Kombinationen von Gates loswerden. Einige Kombinationen von Gates können beispielsweise auf einfachere Kombinationen reduziert werden – und manchmal entspricht eine Kombination von Gates der Identitätsoperation, sodass wir sie einfach eliminieren können. Du kannst dies automatisch mit dem Qiskit Transpiler tun – aber du kannst es auch manuell Gate für Gate machen, wenn du mehr Kontrolle möchtest.

Sobald wir das Circuit-Layout, Routing und die Gate-Anzahl verbessert haben – entweder von Hand oder mit dem Transpiler –, möchten wir unseren Circuit normalerweise visualisieren, um sicherzustellen, dass das Timing aller Gates Sinn ergibt. Es gibt ein Argument, das du im Transpiler setzen kannst, um den Zeitplan deines Circuits zu visualisieren und sicherzustellen, dass alles so ausgerichtet ist, wie du es erwarten würdest.

Qiskit Transpiler

Wie bereits erwähnt, kann der Qiskit Transpiler in den frühen Phasen des Patterns-Workflows helfen. Nun wollen wir uns seine Fähigkeiten genauer ansehen. Er kann einen gegebenen Eingangs-Circuit neu schreiben, damit er der Topologie eines bestimmten Quantengeräts entspricht, und den Circuit für die Ausführung und die Widerstandsfähigkeit gegen Rauschen optimieren. Außerdem schreibt er einen gegebenen Circuit in die Basisgates des spezifischen Quantenprozessors um, den du ausgewählt hast.

Qiskit hat vier eingebaute Transpilierungs-Pipelines, die verschiedenen Optimierungsebenen entsprechen, und sofern du nicht bereits mit Quantencircuit-Optimierung vertraut bist, empfehlen wir dir, eine davon zu verwenden. Standardmäßig umfasst der Transpilierungsprozess diese sechs Schritte:

1. Initialisierung. Diese Phase führt alle anfänglichen Durchläufe aus, die erforderlich sind, bevor wir damit beginnen, den Circuit auf dem Backend einzubetten. Dies umfasst typischerweise das Entfalten benutzerdefinierter Anweisungen und die Konvertierung des Circuits in Einzel- und Zwei-Qubit-Gates.

2. Layout. Diese Phase bildet die virtuellen Qubits im Circuit auf die physischen Qubits eines Backends ab. Weitere Details findest du unter Layout Stage.

3. Routing. Diese Phase wird nach dem Anwenden eines Layouts ausgeführt und fügt Gates (wie Swap-Gates) in den ursprünglichen Circuit ein, um ihn mit der Konnektivität des Backends kompatibel zu machen. Weitere Details findest du unter Routing Stage.

4. Übersetzung. Diese Phase übersetzt die Gates im Circuit in den Basissatz des Ziel-Backends. Weitere Details findest du unter Translation Stage.

5. Optimierung. Diese Phase führt die Haupt-Optimierungsschleife wiederholt aus, bis eine Bedingung (wie das Erreichen einer bestimmten Zieltiefe) erfüllt ist. Wir haben vier verschiedene Optimierungsebenen zur Auswahl, die unten beschrieben sind.

6. Scheduling. Diese Phase ist für hardware-bewusste Scheduling-Durchläufe. Auf einem hohen Niveau kann das Scheduling als das Einfügen von Verzögerungen in den Circuit verstanden werden, um die Leerlaufzeit auf den Qubits zwischen der Ausführung von Anweisungen zu berücksichtigen.

Es gibt vier Optimierungsebenen von 0 bis 3, wobei höhere Optimierungsebenen mehr Zeit und Rechenaufwand erfordern, aber möglicherweise einen besseren Circuit ergeben. Optimierungsebene 0 ist für Gerätekalibrierungsexperimente vorgesehen und bildet als solche nur den Eingangs-Circuit auf die Einschränkungen des Ziel-Backends ab, ohne Optimierungen durchzuführen. Optimierungsebene 3 investiert den meisten Aufwand zur Optimierung des Circuits. Da jedoch viele der Optimierungstechniken im Transpiler auf Heuristiken basieren, führt mehr Rechenaufwand nicht immer zu einer Verbesserung der Qualität des Ausgabe-Circuits. Wenn dies von weiterem Interesse ist, lies die Transpiler-Dokumentation in der Qiskit-Dokumentation.

Error Suppression

Der erste Schritt zur Reduzierung von Fehlern in einem Circuit ist die Optimierung des Layouts, des Routings und die Minimierung der Gate-Anzahl, was wir bereits entweder mit dem Transpiler oder von Hand getan haben. Lass uns nun über einige ausgefeiltere Methoden der Error Suppression sprechen.

Error Suppression bezeichnet eine Klasse von Techniken, die einen Circuit während der Kompilierung transformieren, um Fehler zu minimieren. Sie unterscheidet sich von Error Mitigation, die wir später im Abschnitt „Execute" besprechen werden. Die beiden häufigsten Formen der Error Suppression, die wir verwenden, sind Dynamical Decoupling und Pauli Twirling:

1. Dynamical Decoupling wird verwendet, um einen Teil des durch Umweltrauschen eingeführten Fehlers, wenn ein Qubit im Leerlauf sitzt, effektiv aufzuheben. Durch das Anwenden einer Reihe von Gates zu bestimmten Zeitpunkten kann man dafür sorgen, dass sich das Rauschen, das in einem Teil der Leerlaufzeit akkumuliert, ungefähr mit dem Rauschen im anderen Teil aufhebt.
2. Pauli Twirling ist eine Methode, bei der zufällige Gates eingefügt werden, nicht um das Rauschen zu beseitigen, wie beim Dynamical Decoupling, sondern um es zu vereinfachen. Durch das Einfügen zufälliger Gates wird verhindert, dass sich die Auswirkungen verschiedener Fehler so schnell aufbauen, und das Rauschen wird einfacher zu charakterisieren, da es nun stochastischen Charakter hat. Diese Methode bildet auch die Grundlage einer leistungsstarken Error-Mitigation-Technik, die wir im Folgenden besprechen werden.

Ausführen (Execute)

Jetzt sind wir bereit, das Quantenprogramm auszuführen. Die Qiskit Runtime Primitives stellen eine Schnittstelle zur IBM-Quantum-Hardware bereit und abstrahieren auch Error Suppression und Mitigation vom Nutzer. Es stehen zwei Primitives zur Auswahl: der Sampler und der Estimator.

Der Sampler von Qiskit Runtime führt den Circuit mehrfach auf einem Quantengerät aus, nimmt bei jedem Lauf Messungen vor und rekonstruiert die Wahrscheinlichkeitsverteilung aus den wiederhergestellten Bitstrings. Je mehr Durchläufe (oder Shots) er durchführt, desto genauer werden die Ergebnisse sein, aber das erfordert mehr Zeit und Quantenressourcen. Insbesondere berechnet er die Wahrscheinlichkeit, jeden möglichen Standardbasisstatus zu erhalten, indem er den vom Circuit vorbereiteten Zustand misst.

Der Estimator von Qiskit Runtime verwendet einen komplexen algebraischen Prozess, um den Erwartungswert auf einem echten Quantengerät zu schätzen, indem er die Observable in eine Kombination anderer Observablen mit bekannten Eigenbasen zerlegt.

Der Execute-Schritt ist auch, wenn wir die Error Mitigation-Strategie auswählen können. Error Mitigation bezeichnet Techniken, die es Nutzern ermöglichen, Circuit-Fehler zu reduzieren, indem das Geräterauschen modelliert wird, das zum Zeitpunkt der Ausführung vorhanden war. Typischerweise führt dies zu einem quantenseitigen Vorverarbeitungsaufwand für das Modelltraining und einem klassischen Nachverarbeitungsaufwand, um Fehler in den Rohergebnissen mithilfe des generierten Modells zu mindern. Im Austausch für diesen Overhead können wir viel genauere Ergebnisse erhalten.

Es gibt mehrere Techniken, die wir für Error Mitigation implementieren können. Wir werden drei besprechen, in aufsteigender Reihenfolge der Fehlerresilienz, aber auch in aufsteigender Reihenfolge der Rechenkosten. Beachte jedoch, dass dies ein aktives Forschungsgebiet ist – daher werden wir wahrscheinlich weiterhin neue erfinden und alte verbessern.

Bei Resilienz-Level 0 macht der Transpiler nichts mit deinem Circuit.

Bei Level 1 führt er eine Methode namens Twirled Readout Error eXtinction (T-REX) ein. T-REX verwendet Pauli Twirling, wie im Abschnitt über Error Suppression besprochen. Wie erwähnt, kann das Einfügen zufälliger Gates in den Circuit selbst sehr kompliziertes, schwer zu modellierendes Rauschen stochastisch wirken lassen und es in der Nachverarbeitung viel einfacher machen, es zu berücksichtigen oder abzuziehen.

Bei Resilienz-Level 2 wird Zero Noise Extrapolation (ZNE) hinzugefügt. Dies ist eine beliebte Technik, mit der wir in letzter Zeit viel Erfolg hatten. Die Idee hinter ZNE mag etwas überraschend sein – wir fügen tatsächlich Rauschen zu dem hinzu, was bereits vorhanden ist! Aber das ermöglicht es uns, in die entgegengesetzte Richtung zu extrapolieren und vorherzusagen, wie die Ergebnisse aussehen würden, wenn es immer weniger Rauschen gäbe.

Das Hinzufügen von Rauschen kann auf verschiedene Arten erfolgen. Zum Beispiel können wir die Gates verlängern, damit sie länger dauern und somit fehleranfälliger sind, oder mehr Gates ausführen, die letztendlich in einer Identitätsoperation resultieren, sodass sich der Circuit funktional nicht ändert, wir aber absichtlich mehr Rauschen abtasten. Du musst dies jedoch für jeden Circuit und jeden Erwartungswert tun, den du verfolgen möchtest – daher kannst du sehen, wie es am Ende rechenintensiv werden kann.

Eine spezifische Art von ZNE wird Probabilistic Error Amplification (PEA) genannt. Sobald wir ein Rauschmodell für ein Gate gelernt haben, arbeitet PEA, indem Fehler aus diesem Rauschmodell abgetastet und absichtlich in den Circuit injiziert werden. Dies ist in Qiskit noch nicht verfügbar, wird aber später in diesem Jahr erscheinen.

Die letzte Form von Error Mitigation, die wir besprechen werden, ist Probabilistic Error Cancellation (PEC). Anstatt auf Level 3 zu sein, ist PEC eine spezielle Fähigkeit, die du manuell in Qiskit aktivieren musst, weil die erforderlichen Rechenressourcen im Vergleich zu den anderen Error-Mitigation-Techniken nicht sehr gut skalieren. Du beginnst damit, das Rauschen zu charakterisieren, das deinen Circuit beeinflusst – führe Rauschlernen- oder Rauschcharakterisierungs-Circuits für jede eindeutige Schicht von Zwei-Qubit-Gates in deinem Circuit aus. Diese Ergebnisse ermöglichen es dir, das Rauschen in Pauli-Operatoren zu beschreiben. Wenn du diese Rauschterme kennst, kannst du deine Circuits so modifizieren, dass sie effektiv die entgegengesetzten Pauli-Gates eingebaut haben, um diese Rauschkanäle zu beseitigen. In gewisser Weise ähnelt der Prozess der Funktionsweise von Noise-Cancelling-Kopfhörern. Diese Methode, das Rauschen rückgängig zu machen, ist jedoch sehr kostspielig, mit einer Laufzeit, die schnell und exponentiell mit der Anzahl der Gates wächst, sodass es möglicherweise nicht die beste Wahl für einen sehr großen Circuit ist.

Nachverarbeiten (Post-process)

Die Nachverarbeitungsphase ist der Ort, wo wir den Output unseres Quantencircuits visualisieren und analysieren. Es stehen dir eine Reihe von Qiskit-Tools zur Verfügung, wie z. B. die Visualisierungs- und Quantum-Info-Module. Wir werden diese hier nicht behandeln, aber wir werden diese Module in Aktion sehen, wenn wir in zukünftigen Lektionen in einige Anwendungsbeispiele eintauchen.

Fazit

Hoffentlich hat dir diese Lektion einen schnellen Überblick über die wichtigsten Überlegungen und den Workflow gegeben, den wir verwenden, wenn wir eine Quantenberechnung im Utility-Maßstab durchführen möchten. Sie war vollgepackt mit Informationen, und vieles davon wird erst richtig sitzen, wenn wir einige tatsächliche Beispiele sehen, wo diese theoretischen Konzepte in die Praxis umgesetzt werden. Das ist also, was der Rest des Kurses sein wird. Schließlich heißt dieser Kurs nicht umsonst „Quantum Computing in Practice"!

Beim nächsten Mal werden wir uns ein konkretes Beispiel ansehen, wie man den Qiskit-Patterns-Workflow verwendet, um einen Quantencircuit zu entwerfen und auszuführen, der das klassische Problem aus der Graphentheorie namens MaxCut löst.