Transpiler

Fungsi generate_boxing_pass_manager() ialah alat yang fleksibel dan mudah untuk membina qiskit.transpiler.PassManager yang boleh mengumpulkan arahan litar ke dalam box beranotasi. Ini memberikan alternatif yang mudah kepada pengumpulan dan penganotasian litar secara manual, dan berguna untuk mengautomasikan aliran kerja, menguji strategi box litar yang berbeza, dan sebagainya.

Panduan ini menunjukkan cara menggunakan generate_boxing_pass_manager() dan argumennya. Untuk menonjolkan kesan setiap argumen fungsi, bahagian berikut terutamanya merujuk kepada litar di bawah.

from qiskit.circuit import Parameter, QuantumCircuit

circuit = QuantumCircuit(4, 7)
circuit.h(1)
circuit.h(2)
circuit.cz(1, 2)
circuit.h(1)
circuit.cx(1, 0)
circuit.cx(2, 3)
circuit.measure(range(1, 4), range(3))
circuit.cx(0, 1)
circuit.cx(1, 2)
circuit.cx(2, 3)
for qubit in range(4):
    circuit.rz(Parameter(f"th_{qubit}"), qubit)
    circuit.rx(Parameter(f"phi_{qubit}"), qubit)
    circuit.rz(Parameter(f"lam_{qubit}"), qubit)
circuit.measure(range(4), range(3, 7))

circuit.draw("mpl", scale=0.8)

Mengumpulkan operasi ke dalam box

Argumen enable_gates boleh ditetapkan kepada True atau False untuk menentukan sama ada gate dua qubit harus dikumpulkan ke dalam box. Begitu juga, enable_measures menentukan sama ada pengukuran harus dikumpulkan atau tidak. Coretan berikut menunjukkan contoh di mana kedua-dua gate dan pengukuran dikumpulkan.

from samplomatic.transpiler import generate_boxing_pass_manager

boxing_pass_manager = generate_boxing_pass_manager(
    enable_gates=True,
    enable_measures=True,
)
transpiled_circuit = boxing_pass_manager.run(circuit)
transpiled_circuit.draw("mpl", scale=0.8)

Seperti yang dapat dilihat dalam rajah, pass manager mencipta box daripada dua jenis: yang mengandungi satu lapisan gate dua qubit, dan yang mengandungi satu lapisan pengukuran. Pemisahan ini mencerminkan amalan piawai dalam protokol pembelajaran dan mitigasi hingar, yang biasanya menyasarkan lapisan operasi homogen. Gate dua qubit dan pengukuran diletakkan dalam box paling kiri yang dapat memuatkannya, dan setiap gate qubit tunggal diletakkan dalam box yang sama dengan gate dua qubit atau pengukuran yang mengikutinya.

Kod berikut menunjukkan contoh di mana enable_gates ditetapkan kepada False. Seperti yang dapat dilihat, gate dua qubit tidak dikumpulkan ke dalam box, begitu juga gate qubit tunggal yang mendahuluinya.

boxing_pass_manager = generate_boxing_pass_manager(
    enable_gates=False,
    enable_measures=True,
)
transpiled_circuit = boxing_pass_manager.run(circuit)
transpiled_circuit.draw("mpl", scale=0.8)

Memilih cara menganotasi box

Semua box gate dua qubit dan pengukuran dalam litar yang dikembalikan memiliki anotasi left-dressed. Khususnya, semua box yang mengandungi gate dua qubit dianotasi dengan Twirl. Bagi box pengukuran, pengguna boleh memilih antara Twirl, BasisTranform (dengan mode ditetapkan kepada "measure"), atau kedua-duanya. Kod berikut menjana litar di mana semua box di-twirl, dan box pengukuran turut dianotasi dengan BasisTranform.

boxing_pass_manager = generate_boxing_pass_manager(
    enable_gates=True,
    enable_measures=True,
    measure_annotations="all",
)
transpiled_circuit = boxing_pass_manager.run(circuit)

Menyediakan litar untuk suntikan hingar

inject_noise_targets membolehkan anda menentukan box mana yang harus menerima anotasi InjectNoise. Contohnya, kod berikut menjana litar di mana box gate dua qubit memiliki anotasi InjectNoise tetapi box pengukuran tidak.

boxing_pass_manager = generate_boxing_pass_manager(
    enable_gates=True,
    enable_measures=True,
    inject_noise_targets="gates",
)
transpiled_circuit = boxing_pass_manager.run(circuit)

Jika litar mengandungi dua atau lebih box yang setara sehingga gate qubit tunggal, kesemuanya dianotasi dengan anotasi InjectNoise yang mempunyai ref yang sama. Oleh itu, bilangan ref unik dalam litar yang dikembalikan adalah sama dengan bilangan box unik.

Nilai bagi inject_noise_strategy memberi kesan kepada anotasi InjectNoise. Nilai berikut boleh digunakan:

• modifier_ref='': Disyorkan apabila anda tidak perlu mengubah suai peta hingar sebelum mengambil sampel daripadanya.

• modifier_ref=ref: Disyorkan apabila semua peta hingar perlu diskalakan secara seragam oleh faktor yang sama.

• Nilai modifier_ref yang unik: Disyorkan apabila setiap peta hingar perlu diskalakan oleh faktor yang berbeza.

Kod berikut menjana litar di mana box gate dua qubit memiliki anotasi InjectNoise dengan nilai modifier_ref yang unik.

boxing_pass_manager = generate_boxing_pass_manager(
    enable_gates=True,
    enable_measures=True,
    inject_noise_targets="gates",
    inject_noise_strategy="individual_modification",
)
transpiled_circuit = boxing_pass_manager.run(circuit)

Memilih strategi twirling

Boxing pass manager bermula dengan memilih gate belitan dan arahan pengukuran mana yang harus muncul dalam box yang sama. Setelah ini selesai, box secara amnya tidak akan berlebar penuh—ia berkemungkinan hanya merangkumi subset qubit yang aktif dalam litar atau yang terdapat dalam sasaran backend. Dalam konfigurasi tipikal boxing pass manager, memandangkan semua qubit yang menjadi sasaran arahan box di-twirl (malah yang tiada arahan di dalam box bertindak ke atasnya), mempunyai box berlebar separa menjejaskan kesan penyesuaian hingar oleh twirling. Qubit melahu tidak di-twirl dan boleh, contohnya, mengumpulkan ralat koheren semasa box dikenakan. twirling_strategy menyediakan pilihan untuk melanjutkan qubit yang dimiliki oleh setiap box, sekali gus mengubah bilangan qubit melahu:

• "active" (lalai) tidak melanjutkan box kepada mana-mana qubit melahu.

• "active_accum" melanjutkan semua box kepada qubit yang telah dikenakan arahan terdahulu dalam litar. Ini berguna jika anda mahu membiarkan qubit pada permulaan litar dalam keadaan dasarnya selama mungkin dengan tidak melakukan twirl padanya sehingga ia menjadi aktif.

• "active_circuit" melanjutkan semua box kepada qubit yang dikenakan oleh mana-mana arahan dalam litar. Ini berguna jika anda mempunyai litar berstruktur dengan lapisan belitan berulang dan anda mahu meminimumkan bilangan box unik kerana setiap satu perlu dipelajari hingarnya.

• "all" melanjutkan semua box kepada semua qubit dalam semua register kuantum litar. Ini berguna sebagai lanjutan kepada "active_circuit" di mana anda mahu semua qubit dalam QPU sentiasa di-twirl.

Dalam contoh berikut, setiap strategi dikenakan pada litar asas, kemudian hasilnya dilukis.

circuit = QuantumCircuit(5, 2)
circuit.h(range(4))
circuit.cx(0, 1)
circuit.cx(1, 2)
circuit.cx(2, 3)
circuit.cx(0, 1)
circuit.cx(1, 2)
circuit.cx(2, 3)
circuit.barrier()
circuit.h(range(4))
circuit.measure([1, 2], [0, 1])

circuit.draw("mpl", scale=0.6)

import matplotlib.pyplot as plt

plt.figure(figsize=(9, 6))
for idx, strategy in enumerate(["active", "active_accum", "active_circuit", "all"]):
    ax = plt.subplot(2, 2, idx + 1)
    pm = generate_boxing_pass_manager(twirling_strategy=strategy, remove_barriers="never")
    transpiled_circuit = pm.run(circuit)
    fig = transpiled_circuit.draw("mpl", scale=0.8, ax=ax)
    ax.set_title(f"twirling_strategy='{strategy}'")

plt.tight_layout()

Menentukan cara merawat barrier

Secara lalai, barrier dibuang daripada litar selepas semua gate belitan dan arahan pengukuran telah di-box seperti yang diarahkan, termasuk lanjutannya akibat pemilihan twirling_strategy, tetapi sebelum gate qubit tunggal ditambah ke dalam box serta-merta di sebelah kanannya, jika boleh.

Contohnya, litar berikut mengandungi barrier:

circuit_with_barrier = QuantumCircuit(4)
circuit_with_barrier.h(range(4))
circuit_with_barrier.cz(0, 1)
circuit_with_barrier.barrier()
circuit_with_barrier.cz(2, 3)
circuit_with_barrier.measure_all()

circuit_with_barrier.draw("mpl", scale=0.8)

Tingkah laku lalai menghalang kedua-dua gate belitan daripada berakhir dalam box yang sama, walaupun ia membenarkan gate qubit tunggal diserap ke dalam box tersedia seterusnya walaupun terdapat barrier.

boxing_pass_manager = generate_boxing_pass_manager()
transpiled_circuit = boxing_pass_manager.run(circuit_with_barrier)
transpiled_circuit.draw("mpl", scale=0.8)

Menetapkan remove_barriers kepada 'never' mengekalkan barrier supaya gate qubit tunggal terkekang.

boxing_pass_manager = generate_boxing_pass_manager(remove_barriers="never")

transpiled_circuit = boxing_pass_manager.run(circuit_with_barrier)
transpiled_circuit.draw("mpl", scale=0.8)

Akhir sekali, jika barrier dibuang serta-merta, gate belitan tidak lagi terkekang untuk berakhir dalam box yang berasingan.

boxing_pass_manager = generate_boxing_pass_manager(remove_barriers="immediately")

transpiled_circuit = boxing_pass_manager.run(circuit_with_barrier)
transpiled_circuit.draw("mpl", scale=0.8)

Cara stratifikasi berfungsi

Boxing pass manager menjalankan dua pass utama secara berurutan:

1. GroupGatesIntoBoxes — Menstratifikasi gate belitan ke dalam box. Gate qubit tunggal diabaikan pada peringkat ini; hanya gate dua qubit dikumpulkan.

2. AbsorbSingleQubitGates — Menyerap setiap gate qubit tunggal ke dalam box layak terdekat di sebelah kanannya.

Semasa stratifikasi, GroupGatesIntoBoxes melintasi DAG litar mengikut susunan topologi dan meletakkan setiap gate dua qubit dalam kumpulan terawal yang qubitnya belum diduduki. Tiga jenis arahan bertindak sebagai pembatas yang mengosongkan kumpulan semasa bagi qubit mereka, memaksa gate seterusnya pada qubit tersebut masuk ke dalam kumpulan baharu:

• Penghalang

• Arahan box sedia ada

• Measurements

Gate qubit tunggal bukan pembatas — ia tidak mempunyai kesan pada pengumpulan dan ditinggalkan untuk dikendalikan oleh AbsorbSingleQubitGates. Tiada analisis kekomutan dilakukan pada masa ini; pengumpulan mematuhi susunan topologi litar seadanya.

Mengapa remove_barriers="after_stratification" ialah lalai yang disyorkan

Mod lalai ialah "after_stratification" kerana ia menggabungkan dua kelebihan:

• Barrier mengekang cara gate belitan dikumpulkan (ia bertindak sebagai pembatas semasa stratifikasi).

• Barrier dibuang sebelum AbsorbSingleQubitGates dijalankan, jadi gate qubit tunggal masih boleh mengalir melepasi bekas kedudukan barrier dan diserap ke dalam box terdekat.

Sebaliknya:

• "never" mengekalkan barrier sepanjang masa, yang memerangkap gate qubit tunggal di antara barrier dan box, menghalang penyerapannya dan meninggalkan putaran tanpa twirl dalam litar.

• "immediately" membuang barrier sebelum stratifikasi, jadi ia tidak mempunyai kesan pada pengumpulan.

• "finally" berguna apabila anda mahu barrier dalam litar output (contohnya, untuk visualisasi), tetapi gate qubit tunggal di antara barrier dan box tidak diserap.

Kotakkan litar ISA dengan barrier

Litar dengan struktur berulang — seperti simulasi Hamiltonian Trotter, ansatze variasi dan jujukan penguatan ralat — lazimnya dibina secara programatik dan kemudian ditranspilasi ke bentuk ISA. Menambah kotak secara manual pada litar yang telah ditranspilasi adalah menyusahkan, jadi aliran kerja semula jadi adalah seperti berikut:

1. Bina litar logik, dengan menyisipkan barrier pada sempadan lapisan yang anda mahu jadikan sempadan kotak.

2. Transpilasi kepada litar ISA. Transpiler Qiskit mengekalkan barrier semasa penghalaan dan pengoptimuman.

3. Jalankan generate_boxing_pass_manager() pada litar ISA.

Barrier diperlukan apabila hujung satu lapisan tidak meliputi semua qubit. Algoritma tamak jika tidak akan meletakkan gate daripada lapisan seterusnya—pada qubit yang "bebas" itu—ke dalam kumpulan yang sama. Sebagai contoh konkrit, pertimbangkan simulasi Heisenberg ZZ dua langkah pada gelang 5 qubit. Setiap langkah Trotter mempunyai tiga lapisan ikatan: ikatan genap (0,1), (2,3), ikatan ganjil (1,2), (3,4), dan ikatan lilitan (4,0). Selepas lapisan ikatan ganjil, qubit 0 dan 4 kedua-duanya bebas. Tanpa barrier, ikatan lilitan (4,0) dikumpulkan secara tamak dengan ikatan daripada langkah Trotter seterusnya yang menggunakan qubit bebas tersebut, sekali gus mencampurkan gate daripada langkah berbeza dalam kotak yang sama.

from qiskit.circuit import Parameter, QuantumCircuit

n = 5  # 5-qubit ring: bonds (0,1), (1,2), (2,3), (3,4), (4,0)
dt = Parameter("dt")
heisenberg = QuantumCircuit(n)

for step in range(2):
    # Layer 1: even bonds (0,1) and (2,3)
    for idx in range(0, n - 1, 2):
        heisenberg.rzz(dt, idx, idx + 1)
    heisenberg.barrier()
    # Layer 2: odd bonds (1,2) and (3,4) -- qubits 0 and 4 are now free
    for idx in range(1, n - 1, 2):
        heisenberg.rzz(dt, idx, idx + 1)
    heisenberg.barrier()
    # Layer 3: wrap bond (4,0) -- both qubits were free after layer 2
    heisenberg.rzz(dt, n - 1, 0)
    if step < 1:
        heisenberg.barrier()  # separates the two Trotter steps

heisenberg.measure_all()

heisenberg.draw("mpl", scale=0.7)

Kod berikut mentranspilasi litar ke bentuk ISA, dengan andaian peranti asas mempunyai CX sebagai entangler natif. Perhatikan bahawa barrier kekal selepas transpilasi dan masih kelihatan dalam litar output.

from qiskit.transpiler import generate_preset_pass_manager

preset_pm = generate_preset_pass_manager(
    basis_gates=["rz", "sx", "cx"],
    coupling_map=[[0, 1], [1, 2], [2, 3], [3, 4], [4, 0]],
    optimization_level=1,
)
isa_circuit = preset_pm.run(heisenberg)
isa_circuit.draw("mpl", scale=0.5, fold=200)

Seterusnya, gunakan boxing pass manager pada litar ISA. Setiap satu daripada tiga lapisan ikatan menjadi kotak yang berasingan dalam setiap langkah Trotter.

boxing_pm = generate_boxing_pass_manager()
boxed_isa = boxing_pm.run(isa_circuit)
boxed_isa.draw("mpl", scale=0.5, fold=100)

Menggabungkan pass manager Samplomatic ke dalam pass manager praset Qiskit

Kod di bawah menunjukkan cara menggabungkan generate_boxing_pass_manager() ke dalam pass manager praset Qiskit. Litar yang ditranspilasi ialah ISA dan mengandungi kotak.

from qiskit.transpiler import generate_preset_pass_manager

preset_pass_manager = generate_preset_pass_manager(
    basis_gates=["rz", "sx", "cx"],
    coupling_map=[[0, 1], [1, 2]],
    optimization_level=0,
)
boxing_pass_manager = generate_boxing_pass_manager()

# Run the boxing pass manager after the scheduling stage
preset_pass_manager.post_scheduling = boxing_pass_manager

circuit = QuantumCircuit(3)
circuit.h(0)
circuit.cx(0, 1)
circuit.cx(0, 2)
circuit.measure_all()

transpiled_circuit = preset_pass_manager.run(circuit)
transpiled_circuit.draw("mpl", scale=0.8)

Corak ini juga sesuai digabungkan dengan aliran kerja pengotakan ISA berasaskan barrier. Boxing pass manager dijalankan sebagai langkah selepas penjadualan, setelah barrier daripada litar logik asal kekal selepas transpilasi, jadi ia memandu stratifikasi seperti yang dijangkakan.

preset_pm = generate_preset_pass_manager(
    basis_gates=["rz", "sx", "cx"],
    coupling_map=[[0, 1], [1, 2], [2, 3], [3, 4], [4, 0]],
    optimization_level=1,
)
preset_pm.post_scheduling = generate_boxing_pass_manager()

boxed_heisenberg = preset_pm.run(heisenberg)
boxed_heisenberg.draw("mpl", scale=0.5, fold=100)

Periksa dan ubah suai anotasi

Selepas pengotakan automatik, anda mungkin mahu memeriksa anotasi pada kotak tertentu atau melaraskannya. Contohnya, untuk menambah suntikan hingar, mengalih keluar anotasi, atau menukar kumpulan twirling. Samplomatic menyediakan satu set fungsi utiliti dalam samplomatic.utils untuk tujuan ini. Kesemuanya mengembalikan litar baharu tanpa mengubah litar asal.

extend_annotations() menambah satu atau lebih anotasi pada setiap kotak dalam litar.

from samplomatic import InjectNoise, Twirl
from samplomatic.utils import extend_annotations

boxed = generate_boxing_pass_manager().run(circuit_with_barrier)

# Add InjectNoise to every box
with_noise = extend_annotations(boxed, InjectNoise("my_noise_ref"))
with_noise.draw("mpl", scale=0.8)

filter_annotations() hanya mengekalkan anotasi bagi jenis yang ditentukan dan membuang selebihnya. replace_annotations() menggunakan callable pada setiap anotasi; callable itu mengembalikan senarai anotasi sebagai gantian (kembalikan [] untuk mengalih keluar, senarai satu elemen untuk menggantikan, atau senarai berbilang elemen untuk mengembangkan).

from samplomatic.utils import filter_annotations, replace_annotations

# Keep only Twirl annotations, drop everything else
twirl_only = filter_annotations(with_noise, Twirl)

# Replace the twirling group on every Twirl annotation
updated = replace_annotations(
    twirl_only, lambda a: [Twirl(group="local_c1")] if isinstance(a, Twirl) else [a]
)

Fungsi serba guna map_annotations() menerima sebarang callable yang memetakan senarai anotasi kepada senarai baharu, memberi anda kawalan penuh ke atas transformasi bagi setiap kotak. strip_annotations() ialah pembungkus kemudahan yang mengalih keluar semua anotasi daripada setiap kotak.

Untuk perubahan secara pukal seperti menambah InjectNoise pada semua kotak gate, parameter inject_noise_targets bagi generate_boxing_pass_manager() ialah pilihan yang paling ringkas. Utiliti ini berguna untuk suntingan terpilih bagi setiap kotak yang tidak dilindungi oleh parameter pass manager.

Bina litar

Setiap pass manager yang dihasilkan oleh generate_boxing_pass_manager() mengembalikan litar yang boleh diubah dengan berjaya menjadi pasangan templat/samplex oleh build(). Contohnya, kod berikut memanggil fungsi build() pada litar yang dihasilkan oleh boxing pass manager.

from samplomatic import build

boxing_pass_manager = generate_boxing_pass_manager(
    enable_gates=True,
    enable_measures=True,
)
transpiled_circuit = boxing_pass_manager.run(circuit)

template, samplex = build(transpiled_circuit)

Bagi memastikan sebarang litar yang ditranspilasi dapat dibina dengan berjaya, pass manager tahu cara menyertakan kotak tambahan apabila diperlukan. Contohnya, pertimbangkan litar di bawah, yang berakhir dengan qubit 0 yang tidak diukur.

circuit_with_unmeasured_qubit = QuantumCircuit(4, 3)
circuit_with_unmeasured_qubit.cz(0, 1)
circuit_with_unmeasured_qubit.cz(2, 3)
for qubit in range(4):
    circuit_with_unmeasured_qubit.rz(Parameter(f"th_{qubit}"), qubit)
    circuit_with_unmeasured_qubit.rx(Parameter(f"phi_{qubit}"), qubit)
    circuit_with_unmeasured_qubit.rz(Parameter(f"lam_{qubit}"), qubit)
circuit_with_unmeasured_qubit.measure(range(1, 4), range(3))

circuit_with_unmeasured_qubit.draw("mpl", scale=0.8)

Melukis kotak berpakaian-kiri di sekeliling gate dan pengukuran akan menghasilkan litar yang mempunyai gate maya yang tidak dikumpulkan pada qubit 0, dan memanggil build() pada litar ini akan menyebabkan ralat. Untuk mengelakkannya, pass manager yang dikembalikan oleh generate_boxing_pass_manager() boleh menambah kotak berpakaian-kanan yang bertindak sebagai pengumpul. Contohnya, dalam kod berikut, qubit 0 ditamatkan oleh kotak berpakaian-kanan yang mengutip gate maya yang tidak dikumpulkan. Gate satu-qubit yang bertindak pada qubit 0 juga diletakkan di dalam kotak itu bagi meminimumkan kedalaman litar yang terhasil.

boxing_pass_manager = generate_boxing_pass_manager(
    enable_gates=True,
    enable_measures=True,
)
transpiled_circuit = boxing_pass_manager.run(circuit_with_unmeasured_qubit)
transpiled_circuit.draw("mpl", scale=0.8)

Dalam contoh lain, kotak berpakaian-kanan ditambah untuk mengumpulkan gate maya yang jika tidak akan kekal tidak dikumpulkan akibat pengukuran yang tidak dikotakkan.

boxing_pass_manager = generate_boxing_pass_manager(
    enable_gates=True,
    enable_measures=False,
)
transpiled_circuit = boxing_pass_manager.run(circuit_with_unmeasured_qubit)
transpiled_circuit.draw("mpl", scale=0.8)