Gumawa ng pass manager para sa dynamical decoupling

Mga bersyon ng package

Ang code sa pahinang ito ay ginawa gamit ang mga sumusunod na requirements. Inirerekomenda namin ang paggamit ng mga bersyong ito o mas bago.

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

Ipinapakita ng pahinang ito kung paano gamitin ang PadDynamicalDecoupling pass para magdagdag ng error suppression technique na tinatawag na dynamical decoupling sa circuit.

Gumagana ang dynamical decoupling sa pamamagitan ng pagdaragdag ng mga pulse sequence (kilala bilang dynamical decoupling sequences) sa mga idle qubit para i-flip ang mga ito sa paligid ng Bloch sphere, na nagkakansela sa epekto ng mga noise channel at sa gayon ay pinipigilan ang decoherence. Ang mga pulse sequence na ito ay katulad ng mga refocusing pulse na ginagamit sa nuclear magnetic resonance. Para sa kumpletong paglalarawan, tingnan ang A Quantum Engineer's Guide to Superconducting Qubits.

Dahil ang PadDynamicalDecoupling pass ay gumagana lamang sa mga naka-schedule na circuit at kasangkot ang mga gate na hindi kinakailangang basis gate ng ating target, kakailanganin mo rin ang mga ALAPScheduleAnalysis at BasisTranslator pass.

Kunin ang target information mula sa backend at i-save ang mga pangalan ng operation bilang basis_gates dahil kakailanganing i-modify ang target para magdagdag ng timing information para sa mga gate na ginagamit sa dynamical decoupling.

tala

Ginagamit ang FakeSherbrooke mock backend mula sa qiskit_ibm_runtime sa mga halimbawang ito, pero maaari mo itong subukan sa anumang Qiskit-compatible na tunay o pekeng backend. Maaaring iba ang iyong mga resulta.

# Added by doQumentation — installs the packages this notebook needs if they are missing
import importlib.util

_needed = {"numpy": "numpy", "qiskit": "qiskit", "qiskit_ibm_runtime": "qiskit-ibm-runtime"}
_missing = [pip for module, pip in _needed.items()
            if importlib.util.find_spec(module) is None]
# One at a time, so a package that fails to install does not block the others
for _pip in _missing:
    %pip install -q {_pip}
if not _missing:
    print("\u2713 All required packages are installed")

from qiskit_ibm_runtime.fake_provider import FakeSherbrooke

backend = FakeSherbrooke()

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

Gumawa ng efficient_su2 circuit bilang halimbawa. Una, i-transpile ang circuit papunta sa backend dahil kailangang idagdag ang mga dynamical decoupling pulse pagkatapos na ma-transpile at ma-schedule ang circuit. Ang dynamical decoupling ay kadalasang gumagana nang pinakamahusay kapag may maraming idle time sa mga quantum circuit - ibig sabihin, may mga qubit na hindi ginagamit habang aktibo ang iba. Ganito ang nangyayari sa circuit na ito dahil ang mga two-qubit ecr gate ay inilalapat nang sunud-sunod sa ansatz na ito.

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 of the previous code cell

Ang isang dynamical decoupling sequence ay isang serye ng mga gate na kung pagsasamahin ay bumubuo sa identity at pantay-pantay ang agwat sa oras. Bilang halimbawa, magsimula sa paglikha ng isang simpleng sequence na tinatawag na XY4 na binubuo ng apat na gate.

from qiskit.circuit.library import XGate, YGate

X = XGate()
Y = YGate()

dd_sequence = [X, Y, X, Y]

Dahil sa regular na timing ng mga dynamical decoupling sequence, kailangang idagdag ang impormasyon tungkol sa YGate sa target dahil ito ay hindi basis gate, samantalang basis gate ang XGate. Alam natin a priori na ang YGate ay may parehong duration at error gaya ng XGate, kaya maaari lamang nating kunin ang mga property na iyon mula sa target at idagdag muli ang mga ito para sa mga YGate object. Ito rin ang dahilan kung bakit hiwalay na na-save ang basis_gates, dahil idinadagdag natin ang YGate instruction sa target kahit na hindi ito talagang basis gate ng 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)

Ang mga ansatz circuit tulad ng efficient_su2 ay parameterized, kaya kailangang may value na naka-bind sa mga ito bago ipadala sa backend. Dito, magtalaga ng mga random na parameter.

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
)

Sunod, isagawa ang mga custom pass. I-instantiate ang PassManager gamit ang ALAPScheduleAnalysis at PadDynamicalDecoupling. Patakbuhin muna ang ALAPScheduleAnalysis para magdagdag ng timing information tungkol sa quantum circuit bago maidagdag ang mga pantay-pantay na dynamical decoupling sequence. Ang mga pass na ito ay pinapatakbo sa circuit gamit ang .run().

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)

Gamitin ang visualization tool na timeline_drawer para makita ang timing ng circuit at kumpirmahin na lumalabas sa circuit ang isang pantay-pantay na sequence ng mga XGate object at YGate object.

from qiskit.visualization import timeline_drawer

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

Output of the previous code cell

Panghuli, dahil hindi talagang basis gate ng ating backend ang YGate, manu-manong ilapat ang BasisTranslator pass (isa itong default pass, ngunit isinasagawa ito bago ang scheduling, kaya kailangan itong ilapat muli). Ang session equivalence library ay isang library ng mga circuit equivalence na nagbibigay-daan sa transpiler na i-decompose ang mga circuit sa mga basis gate, gaya rin ng tinukoy bilang argumento.

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 of the previous code cell

Ngayon, wala na ang mga YGate object sa ating circuit, at may explicit na timing information sa anyo ng mga Delay gate. Ang na-transpile na circuit na ito na may dynamical decoupling ay handa na ngayong ipadala sa backend.

Mga susunod na hakbang

Mga rekomendasyon

Para matutunan kung paano gamitin ang function na generate_preset_passmanager sa halip na sumulat ng sariling mga pass, magsimula sa paksa na Transpilation default settings and configuration options.
Subukan ang gabay na Compare transpiler settings.
Tingnan ang Transpile API documentation.

Mga susunod na hakbang​

Mga susunod na hakbang