Erstellen Sie einen Passmanager für die dynamische Entkopplung

• Paketversionen

  Der Code auf dieser Seite wurde unter Berücksichtigung der folgenden Anforderungen entwickelt. Wir empfehlen die Verwendung dieser oder neuerer Versionen.

  qiskit[all]~=2.5.2
  qiskit-ibm-runtime~=0.47.0
  

Auf dieser Seite wird gezeigt, wie man mit dem PadDynamicalDecoupling pass verwenden, um eine Fehlerunterdrückungstechnik namens dynamische Entkopplung in die Schaltung einzubauen.

Die dynamische Entkopplung funktioniert durch das Hinzufügen von Impulssequenzen (bekannt als dynamische Entkopplungssequenzen ) zu untätigen Qubits, um sie um die Bloch-Sphäre zu drehen, was die Wirkung von Rauschkanälen aufhebt und dadurch die Dekohärenz unterdrückt. Diese Impulsfolgen ähneln den Refokussierungsimpulsen, die bei der kernmagnetischen Resonanz verwendet werden. Eine vollständige Beschreibung finden Sie in A Quantum Engineer's Guide to Superconducting Qubits.

Da der Durchgang PadDynamicalDecoupling nur auf geplanten Schaltungen arbeitet und Gatter einbezieht, die nicht unbedingt Basisgatter unseres Ziels sind, benötigen Sie die ALAPScheduleAnalysis und BasisTranslator durchgänge ebenfalls.

Rufen Sie die target Informationen aus der backend Tabelle ab und speichern Sie die Operationsnamen als basis_gates [Dateiname], da die Tabelle angepasst target werden muss, um Zeitangaben für die bei der dynamischen Entkopplung verwendeten Gatter hinzuzufügen.

from qiskit_ibm_runtime.fake_provider import FakeSherbrooke

backend = FakeSherbrooke()

target = backend.target
basis_gates = list(target.operation_names)

Erstellen Sie als Beispiel eine Schaltung efficient_su2 . Transpilieren Sie zunächst die Schaltung in das Backend, da dynamische Entkopplungsimpulse hinzugefügt werden müssen, nachdem die Schaltung transpiliert und terminiert worden ist. Die dynamische Entkopplung funktioniert oft am besten, wenn es in den Quantenschaltkreisen viel Leerlaufzeit gibt - das heißt, es gibt Qubits, die nicht benutzt werden, während andere aktiv sind. Dies ist in dieser Schaltung der Fall, da die Zwei-Qubit-Gatter ecr in diesem Ansatz nacheinander angewendet werden.

from qiskit.transpiler import generate_preset_pass_manager
from qiskit.circuit.library import efficient_su2

qc = efficient_su2(12, entanglement="circular", reps=1)
pm = generate_preset_pass_manager(1, target=target, seed_transpiler=12345)
qc_t = pm.run(qc)
qc_t.draw("mpl", fold=-1, idle_wires=False)

Output:

Eine dynamische Entkopplungssequenz ist eine Reihe von Gattern, die sich zur Identität zusammensetzen und in einem regelmäßigen zeitlichen Abstand angeordnet sind. Beginnen Sie beispielsweise mit der Erstellung einer einfachen Sequenz namens XY4, die aus vier Gattern besteht.

from qiskit.circuit.library import XGate, YGate

X = XGate()
Y = YGate()

dd_sequence = [X, Y, X, Y]

Aufgrund des regelmäßigen Zeitpunkts dynamischer Entkopplungssequenzen müssen YGate Informationen über das zum hinzugefügt werden, target da es sich nicht um ein Basisgatter handelt, während das ein XGate Basisgatter ist. Wir wissen a priori, dass das die gleiche Dauer und YGate den gleichen Fehler wie das hat XGate, daher können wir diese Eigenschaften einfach aus dem abrufen target und sie für die YGate Objekte wieder hinzufügen. Aus diesem Grund wurden auch basis_gates die separat gespeichert, da wir die YGate Anweisung zum hinzufügen target , obwohl es sich nicht um ein tatsächliches Basisgatter von handelt ibm_fez.

from qiskit.transpiler import InstructionProperties

y_gate_properties = {}
for qubit in range(target.num_qubits):
    y_gate_properties.update(
        {
            (qubit,): InstructionProperties(
                duration=target["x"][(qubit,)].duration,
                error=target["x"][(qubit,)].error,
            )
        }
    )

target.add_instruction(YGate(), y_gate_properties)

Ansatzschaltungen wie efficient_su2 sind parametrisiert, d. h. sie müssen mit einem Wert versehen werden, bevor sie an das Backend gesendet werden. Weisen Sie hier zufällige Parameter zu.

import numpy as np

rng = np.random.default_rng(1234)
qc_t.assign_parameters(
    rng.uniform(-np.pi, np.pi, qc_t.num_parameters), inplace=True
)

Führen Sie anschließend die benutzerdefinierten Übergänge aus. Richten Sie die PassManager mit ALAPScheduleAnalysis und PadDynamicalDecoupling ein. Führen Sie zuerst ALAPScheduleAnalysis aus, um Zeitinformationen über den Quantenschaltkreis hinzuzufügen, bevor die dynamischen Entkopplungssequenzen in regelmäßigen Abständen hinzugefügt werden können. Diese Pässe werden auf der Strecke mit .run() gefahren.

from qiskit.transpiler import PassManager
from qiskit.transpiler.passes.scheduling import (
    ALAPScheduleAnalysis,
    PadDynamicalDecoupling,
)

dd_pm = PassManager(
    [
        ALAPScheduleAnalysis(target=target),
        PadDynamicalDecoupling(target=target, dd_sequence=dd_sequence),
    ]
)
qc_dd = dd_pm.run(qc_t)

Verwenden Sie das Visualisierungstool, timeline_drawer um das Timing der Schaltung anzuzeigen und zu überprüfen, ob eine regelmäßig angeordnete Folge von XGate Objekten und YGate Objekten in der Schaltung erscheint.

from qiskit.visualization import timeline_drawer

timeline_drawer(qc_dd, idle_wires=False, target=target)

Output:

Da YGate kein tatsächliches Basis-Gate unseres Backends ist, müssen Sie den BasisTranslator -Pass manuell anwenden (dies ist ein Standard-Pass, der jedoch vor der Planung ausgeführt wird, so dass er erneut angewendet werden muss). Die Sitzungsäquivalenzbibliothek ist eine Bibliothek von Schaltkreisäquivalenzen, die es dem Transpiler ermöglicht, Schaltkreise in Basisgatter zu zerlegen, wie ebenfalls als Argument angegeben.

from qiskit.circuit.equivalence_library import (
    SessionEquivalenceLibrary as sel,
)
from qiskit.transpiler.passes import BasisTranslator

qc_dd = BasisTranslator(sel, basis_gates)(qc_dd)
qc_dd.draw("mpl", fold=-1, idle_wires=False)

Output:

Nun fehlen Objekte in unserem YGate Schaltkreis, und es gibt explizite Zeitinformationen in Form von Delay Gattern. Diese transpilierte Schaltung mit dynamischer Entkopplung kann nun an das Backend gesendet werden.

Nächste Schritte