Bandingkan tetapan Transpiler

Anggaran penggunaan: kurang daripada satu minit pada pemproses Eagle r3 (NOTA: Ini adalah anggaran sahaja. Masa jalan anda mungkin berbeza.)

Latar belakang

Untuk memastikan keputusan yang lebih pantas dan lebih cekap, mulai 1 Mac 2024, Circuit dan observable perlu diubah untuk hanya menggunakan arahan yang disokong oleh QPU (unit pemprosesan kuantum) sebelum dihantar ke primitif Qiskit Runtime. Kita menyebut ini sebagai Circuit dan observable seni bina set arahan (ISA). Satu cara biasa untuk melakukan ini adalah menggunakan fungsi generate_preset_pass_manager Transpiler. Walau bagaimanapun, anda mungkin memilih untuk mengikuti proses yang lebih manual.

Sebagai contoh, anda mungkin ingin menyasarkan subset qubit tertentu pada peranti tertentu. Panduan ini menguji prestasi tetapan Transpiler yang berbeza dengan melengkapkan proses penuh membuat, mentranspil, dan menghantar Circuit.

Keperluan

Sebelum bermula, pastikan anda telah memasang yang berikut:

• Qiskit SDK v1.2 atau lebih baharu, dengan sokongan visualisasi
• Qiskit Runtime v0.28 atau lebih baharu (pip install qiskit-ibm-runtime)

Persediaan

# Added by doQumentation — required packages for this notebook
!pip install -q qiskit qiskit-ibm-runtime

# Create circuit to test transpiler on
from qiskit import QuantumCircuit
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
from qiskit.circuit.library import GroverOperator, Diagonal

# Use Statevector object to calculate the ideal output
from qiskit.quantum_info import Statevector
from qiskit.visualization import plot_histogram
from qiskit.transpiler import PassManager

from qiskit.circuit.library import XGate
from qiskit.quantum_info import hellinger_fidelity

# Qiskit Runtime
from qiskit_ibm_runtime import (
    QiskitRuntimeService,
    Batch,
    SamplerV2 as Sampler,
)
from qiskit_ibm_runtime.transpiler.passes.scheduling import (
    ASAPScheduleAnalysis,
    PadDynamicalDecoupling,
)

Langkah 1: Petakan input klasikal kepada masalah kuantum

Cipta Circuit kecil untuk dicuba dioptimumkan oleh Transpiler. Contoh ini mencipta Circuit yang melaksanakan algoritma Grover dengan oracle yang menandai keadaan 111. Seterusnya, simulasikan taburan ideal (apa yang anda jangka untuk diukur jika anda menjalankan ini pada komputer kuantum sempurna sebanyak kali yang tak terhingga) untuk perbandingan kemudian.

# To run on hardware, select the backend with the fewest number of jobs in the queue
service = QiskitRuntimeService()
backend = service.least_busy(
    operational=True, simulator=False, min_num_qubits=127
)
backend.name

'ibm_brisbanse'

oracle = Diagonal([1] * 7 + [-1])
qc = QuantumCircuit(3)
qc.h([0, 1, 2])
qc = qc.compose(GroverOperator(oracle))

qc.draw(output="mpl", style="iqp")

ideal_distribution = Statevector.from_instruction(qc).probabilities_dict()

plot_histogram(ideal_distribution)

Langkah 2: Optimumkan masalah untuk pelaksanaan perkakasan kuantum

Seterusnya, transpil Circuit untuk QPU. Anda akan membandingkan prestasi Transpiler dengan optimization_level ditetapkan kepada 0 (terendah) berbanding 3 (tertinggi). Tahap pengoptimuman terendah melakukan yang minimum yang diperlukan untuk menjalankan Circuit pada peranti; ia memetakan qubit Circuit kepada qubit peranti dan menambah Gate swap untuk membenarkan semua operasi dua qubit. Tahap pengoptimuman tertinggi jauh lebih pintar dan menggunakan banyak helah untuk mengurangkan jumlah bilangan Gate. Oleh sebab Gate berbilang qubit mempunyai kadar ralat yang tinggi dan qubit menyahkoheren dari masa ke masa, Circuit yang lebih pendek seharusnya memberikan keputusan yang lebih baik.

Sel berikut mentranspil qc untuk kedua-dua nilai optimization_level, mencetak bilangan Gate dua qubit, dan menambah Circuit yang ditranspil ke dalam senarai. Sesetengah algoritma Transpiler adalah rawak, jadi ia menetapkan benih untuk kebolehulangan.

# Need to add measurements to the circuit
qc.measure_all()

# Find the correct two-qubit gate
twoQ_gates = set(["ecr", "cz", "cx"])
for gate in backend.basis_gates:
    if gate in twoQ_gates:
        twoQ_gate = gate

circuits = []
for optimization_level in [0, 3]:
    pm = generate_preset_pass_manager(
        optimization_level, backend=backend, seed_transpiler=0
    )
    t_qc = pm.run(qc)
    print(
        f"Two-qubit gates (optimization_level={optimization_level}): ",
        t_qc.count_ops()[twoQ_gate],
    )
    circuits.append(t_qc)

Two-qubit gates (optimization_level=0):  21
Two-qubit gates (optimization_level=3):  14

Oleh sebab CNOT biasanya mempunyai kadar ralat yang tinggi, Circuit yang ditranspil dengan optimization_level=3 seharusnya berprestasi jauh lebih baik.

Satu lagi cara anda boleh meningkatkan prestasi ialah melalui penyahgandingan dinamik, dengan menggunakan urutan Gate pada qubit yang melahu. Ini membatalkan beberapa interaksi yang tidak dikehendaki dengan persekitaran. Sel berikut menambah penyahgandingan dinamik kepada Circuit yang ditranspil dengan optimization_level=3 dan menambahnya ke dalam senarai.

# Get gate durations so the transpiler knows how long each operation takes
durations = backend.target.durations()

# This is the sequence we'll apply to idling qubits
dd_sequence = [XGate(), XGate()]

# Run scheduling and dynamic decoupling passes on circuit
pm = PassManager(
    [
        ASAPScheduleAnalysis(durations),
        PadDynamicalDecoupling(durations, dd_sequence),
    ]
)
circ_dd = pm.run(circuits[1])

# Add this new circuit to our list
circuits.append(circ_dd)

circ_dd.draw(output="mpl", style="iqp", idle_wires=False)

Langkah 3: Laksanakan menggunakan primitif Qiskit

Pada ketika ini, anda mempunyai senarai Circuit yang ditranspil untuk QPU yang ditentukan. Seterusnya, cipta instans primitif Sampler dan mulakan kerja berkumpulan menggunakan pengurus konteks (with ...:), yang membuka dan menutup kelompok secara automatik.

Dalam pengurus konteks, sampel Circuit dan simpan keputusan ke result.

with Batch(backend=backend):
    sampler = Sampler()
    job = sampler.run(
        [(circuit) for circuit in circuits],  # sample all three circuits
        shots=8000,
    )
    result = job.result()

Langkah 4: Proses pasca dan kembalikan keputusan dalam format klasikal yang dikehendaki

Akhir sekali, plot keputusan daripada jalankan peranti berbanding taburan ideal. Anda boleh melihat keputusan dengan optimization_level=3 lebih hampir kepada taburan ideal disebabkan bilangan Gate yang lebih rendah, dan optimization_level=3 + dd lebih hampir lagi disebabkan penyahgandingan dinamik.

binary_prob = [
    {
        k: v / res.data.meas.num_shots
        for k, v in res.data.meas.get_counts().items()
    }
    for res in result
]
plot_histogram(
    binary_prob + [ideal_distribution],
    bar_labels=False,
    legend=[
        "optimization_level=0",
        "optimization_level=3",
        "optimization_level=3 + dd",
        "ideal distribution",
    ],
)

Anda boleh mengesahkan ini dengan mengira kesetiaan Hellinger antara setiap set keputusan dan taburan ideal (lebih tinggi adalah lebih baik, dan 1 adalah kesetiaan sempurna).

for prob in binary_prob:
    print(f"{hellinger_fidelity(prob, ideal_distribution):.3f}")

0.848
0.945
0.990