Pengenalan kepada fractional gates

Anggaran penggunaan: kurang dari 30 saat pada pemproses Heron r2 (NOTA: Ini adalah anggaran sahaja. Masa jalan sebenar mungkin berbeza.)

Latar belakang

Fractional gates pada IBM QPUs

Fractional gates ialah quantum gates berparameter yang membolehkan pelaksanaan terus putaran sudut sewenang-wenangnya (dalam had tertentu), menghapuskan keperluan untuk menguraikannya kepada beberapa basis gates. Dengan memanfaatkan interaksi asli antara qubit fizikal, pengguna boleh melaksanakan beberapa unitari dengan lebih cekap pada perkakasan.

IBM Quantum® Heron QPU menyokong fractional gates berikut:

• $R_{ZZ}(\theta)$ untuk $0 < \theta < \pi / 2$
• $R_X(\theta)$ untuk sebarang nilai nyata $\theta$

Gate-gate ini boleh mengurangkan dengan ketara kedalaman dan tempoh litar quantum. Ia amat berguna dalam aplikasi yang banyak bergantung pada $R_{ZZ}$ dan $R_X$, seperti simulasi Hamiltonian, Quantum Approximate Optimization Algorithm (QAOA), dan kaedah kernel quantum. Dalam tutorial ini, kita fokus pada kernel quantum sebagai contoh praktikal.

Had

Fractional gates kini merupakan ciri eksperimen dan ada beberapa kekangan:

• $R_{ZZ}$ dihadkan kepada sudut dalam julat $0 < \theta < \pi / 2$.
• Penggunaan fractional gates tidak disokong untuk litar dinamik, Pauli twirling, probabilistic error cancellation (PEC), dan zero-noise extrapolation (ZNE) (menggunakan probabilistic error amplification (PEA)).

Fractional gates memerlukan aliran kerja yang berbeza berbanding pendekatan standard. Tutorial ini menerangkan cara bekerja dengan fractional gates melalui aplikasi praktikal.

Lihat yang berikut untuk maklumat lanjut tentang fractional gates.

• Fractional gates
• Bila tidak perlu guna fractional gates

Gambaran keseluruhan

Aliran kerja untuk menggunakan fractional gates secara amnya mengikut aliran kerja Qiskit patterns. Perbezaan utama ialah semua sudut RZZ mesti memenuhi kekangan $0 < \theta \leq \pi/2$. Terdapat dua pendekatan untuk memastikan syarat ini dipenuhi. Tutorial ini memfokus dan mengesyorkan pendekatan kedua.

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

1. Jana nilai parameter yang memenuhi kekangan sudut RZZ

Jika anda yakin bahawa semua sudut RZZ berada dalam julat yang sah, anda boleh mengikuti aliran kerja Qiskit patterns standard. Dalam kes ini, anda hanya perlu menghantar nilai parameter sebagai sebahagian daripada PUB. Aliran kerja berjalan seperti berikut.

pm = generate_preset_pass_manager(backend=backend, ...)
t_circuit = pm.run(circuit)
t_observable = observable.apply_layout(t_circuit.layout)
sampler.run([(t_circuit, parameter_values)])
estimator.run([(t_circuit, t_observable, parameter_values)])

Jika anda cuba menghantar PUB yang mengandungi RZZ gate dengan sudut di luar julat yang sah, anda akan mendapat mesej ralat seperti:

'The instruction rzz is supported only for angles in the range [0, pi/2], but an angle (20.0) outside of this range has been requested; via parameter value(s) γ[0]=10.0, substituted in parameter expression 2.0*γ[0].'

Untuk mengelak ralat ini, anda patut pertimbangkan pendekatan kedua yang diterangkan di bawah.

2. Tetapkan nilai parameter kepada litar sebelum transpilasi

Pakej qiskit-ibm-runtime menyediakan pas Transpiler khusus yang dipanggil FoldRzzAngle. Pas ini mengubah litar quantum supaya semua sudut RZZ mematuhi kekangan sudut RZZ. Jika anda memberikan Backend kepada generate_preset_pass_manager atau transpile, Qiskit secara automatik akan menggunakan FoldRzzAngle pada litar quantum. Ini memerlukan anda menetapkan nilai parameter kepada litar quantum sebelum transpilasi. Aliran kerja berjalan seperti berikut.

pm = generate_preset_pass_manager(backend=backend, ...)
b_circuit = circuit.assign_parameters(parameter_values)
t_circuit = pm.run(b_circuit)
t_observable = observable.apply_layout(t_circuit.layout)
sampler.run([(t_circuit,)])
estimator.run([(t_circuit, t_observable)])

Perlu diambil perhatian bahawa aliran kerja ini menanggung kos pengiraan yang lebih tinggi berbanding pendekatan pertama, kerana ia melibatkan penetapan nilai parameter kepada litar quantum dan menyimpan litar terikat parameter secara tempatan. Selain itu, terdapat isu yang diketahui dalam Qiskit di mana transformasi gate RZZ mungkin gagal dalam senario tertentu. Untuk penyelesaian sementara, sila rujuk bahagian Penyelesaian masalah. Tutorial ini menunjukkan cara menggunakan fractional gates melalui pendekatan kedua menerusi contoh yang diilhamkan oleh kaedah kernel quantum. Untuk memahami dengan lebih baik situasi di mana kernel quantum berkemungkinan berguna, kami mengesyorkan bacaan Liu, Arunachalam & Temme (2021).

Anda juga boleh melalui tutorial Quantum kernel training dan pelajaran Quantum kernels dalam kursus Quantum machine learning di IBM Quantum Learning.

Keperluan

Sebelum memulakan tutorial ini, pastikan anda telah memasang yang berikut:

• Qiskit SDK v2.0 atau lebih baharu, dengan sokongan visualisasi
• Qiskit Runtime v0.37 atau lebih baharu (pip install qiskit-ibm-runtime)
• Qiskit Basis Constructor (pip install qiskit_basis_constructor)

Persediaan

import matplotlib.pyplot as plt
import numpy as np
from qiskit import QuantumCircuit, generate_preset_pass_manager
from qiskit.circuit import ParameterVector
from qiskit.circuit.library import unitary_overlap
from qiskit_ibm_runtime import QiskitRuntimeService, SamplerV2

Aktifkan fractional gates dan semak basis gates

Untuk menggunakan fractional gates, anda boleh mendapatkan Backend yang menyokongnya dengan menetapkan pilihan use_fractional_gates=True. Jika Backend menyokong fractional gates, anda akan nampak rzz dan rx tersenarai dalam basis gates-nya.

service = QiskitRuntimeService()
backend = service.least_busy(
    operational=True, simulator=False, min_num_qubits=133
)  # backend should be a heron device or later
backend_name = backend.name
backend_c = service.backend(backend_name)  # w/o fractional gates
backend_f = service.backend(
    backend_name, use_fractional_gates=True
)  # w/ fractional gates
print(f"Backend: {backend_name}")
print(f"No fractional gates: {backend_c.basis_gates}")
print(f"With fractional gates: {backend_f.basis_gates}")
if "rzz" not in backend_f.basis_gates:
    print(f"Backend {backend_name} does not support fractional gates")

Backend: ibm_fez
No fractional gates: ['cz', 'id', 'rz', 'sx', 'x']
With fractional gates: ['cz', 'id', 'rx', 'rz', 'rzz', 'sx', 'x']

Aliran kerja dengan fractional gates

Langkah 1: Petakan input klasikal kepada masalah quantum

Circuit kernel quantum

Dalam bahagian ini, kita meneroka Circuit kernel quantum menggunakan RZZ gates untuk memperkenalkan aliran kerja bagi fractional gates.

Kita mulakan dengan membina Circuit quantum untuk mengira entri individu matriks kernel. Ini dilakukan dengan menggabungkan Circuit peta ciri ZZ dengan tindih tindih unitari. Fungsi kernel mengambil vektor dalam ruang yang dipetakan ciri dan mengembalikan hasil darab dalamnya sebagai entri matriks kernel: $K(x, y) = \langle \Phi(x) | \Phi(y) \rangle,$ di mana $|\Phi(x)\rangle$ mewakili keadaan quantum yang dipetakan ciri.

Kita bina secara manual Circuit peta ciri ZZ menggunakan RZZ gates. Walaupun Qiskit menyediakan zz_feature_map terbina dalam, ia tidak menyokong RZZ gates setakat Qiskit v2.0.2 (lihat isu).

Seterusnya, kita kira fungsi kernel untuk input yang sama — contohnya, $K(x, x) = 1$. Pada komputer quantum beringar, nilai ini mungkin kurang daripada 1 disebabkan hingar. Hasil yang lebih hampir kepada 1 menunjukkan hingar yang lebih rendah dalam pelaksanaan. Dalam tutorial ini, kita merujuk nilai ini sebagai fideliti, yang ditakrifkan sebagai $\text{fidelity} = K(x, x).$

optimization_level = 2
shots = 2000
reps = 3
rng = np.random.default_rng(seed=123)

def my_zz_feature_map(num_qubits: int, reps: int = 1) -> QuantumCircuit:
    x = ParameterVector("x", num_qubits * reps)
    qc = QuantumCircuit(num_qubits)
    qc.h(range(num_qubits))
    for k in range(reps):
        K = k * num_qubits
        for i in range(num_qubits):
            qc.rz(x[i + K], i)
        pairs = [(i, i + 1) for i in range(num_qubits - 1)]
        for i, j in pairs[0::2] + pairs[1::2]:
            qc.rzz((np.pi - x[i + K]) * (np.pi - x[j + K]), i, j)
    return qc

def quantum_kernel(num_qubits: int, reps: int = 1) -> QuantumCircuit:
    qc = my_zz_feature_map(num_qubits, reps=reps)
    inner_product = unitary_overlap(qc, qc, "x", "y", insert_barrier=True)
    inner_product.measure_all()
    return inner_product

def random_parameters(inner_product: QuantumCircuit) -> np.ndarray:
    return np.tile(rng.random(inner_product.num_parameters // 2), 2)

def fidelity(result) -> float:
    ba = result.data.meas
    return ba.get_int_counts().get(0, 0) / ba.num_shots

Circuit kernel quantum dan nilai parameter yang sepadan dijana untuk sistem dengan 4 hingga 40 qubit, dan fideliti-fideliti mereka dinilai selepas itu.

qubits = list(range(4, 44, 4))
circuits = [quantum_kernel(i, reps=reps) for i in qubits]
params = [random_parameters(circ) for circ in circuits]

Circuit empat-qubit divisualisasikan di bawah.

circuits[0].draw("mpl", fold=-1)

Dalam aliran kerja Qiskit patterns standard, nilai parameter biasanya dihantar kepada primitif Sampler atau Estimator sebagai sebahagian daripada PUB. Walau bagaimanapun, apabila menggunakan Backend yang menyokong fractional gates, nilai parameter ini mesti ditetapkan secara eksplisit kepada Circuit quantum sebelum transpilasi.

b_qc = [
    circ.assign_parameters(param) for circ, param in zip(circuits, params)
]
b_qc[0].draw("mpl", fold=-1)

Langkah 2: Optimumkan masalah untuk pelaksanaan perkakasan quantum

Kemudian kita transpilasi Circuit menggunakan pass manager mengikut corak Qiskit standard. Dengan memberikan Backend yang menyokong fractional gates kepada generate_preset_pass_manager, pas khusus yang dipanggil FoldRzzAngle akan dimasukkan secara automatik. Pas ini mengubah Circuit untuk mematuhi kekangan sudut RZZ. Hasilnya, RZZ gates dengan nilai negatif dalam rajah sebelumnya diubah menjadi nilai positif, dan beberapa gate X tambahan ditambah.

backend_f = service.backend(name=backend_name, use_fractional_gates=True)
# pm_f includes `FoldRzzAngle` pass
pm_f = generate_preset_pass_manager(
    optimization_level=optimization_level, backend=backend_f
)

t_qc_f = pm_f.run(b_qc)
print(t_qc_f[0].count_ops())
t_qc_f[0].draw("mpl", fold=-1)

OrderedDict([('rz', 35), ('rzz', 18), ('x', 13), ('rx', 9), ('measure', 4), ('barrier', 2)])

Untuk menilai impak fractional gates, kita nilai bilangan gate bukan tempatan (CZ dan RZZ untuk Backend ini), bersama kedalaman Circuit dan tempoh, serta bandingkan metrik ini dengan aliran kerja standard kemudian.

nnl_f = [qc.num_nonlocal_gates() for qc in t_qc_f]
depth_f = [qc.depth() for qc in t_qc_f]
duration_f = [
    qc.estimate_duration(backend_f.target, unit="u") for qc in t_qc_f
]

Langkah 3: Laksanakan menggunakan primitif Qiskit

Kita jalankan Circuit yang telah ditranspilasi dengan Backend yang menyokong fractional gates.

sampler_f = SamplerV2(mode=backend_f)
sampler_f.options.dynamical_decoupling.enable = True
sampler_f.options.dynamical_decoupling.sequence_type = "XY4"
sampler_f.options.dynamical_decoupling.skip_reset_qubits = True

job = sampler_f.run(t_qc_f, shots=shots)
print(job.job_id())

d4bninsi51bc738j97eg

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

Anda boleh mendapatkan nilai fungsi kernel $K(x, x)$ dengan mengukur kebarangkalian bitstring semua-sifar 00...00 dalam output.

# job = service.job("d1obougt0npc73flhiag")
result = job.result()
fidelity_f = [fidelity(result=res) for res in result]
print(fidelity_f)
usage_f = job.usage()

[0.9005, 0.647, 0.3345, 0.355, 0.3315, 0.174, 0.1875, 0.149, 0.1175, 0.085]

Perbandingan aliran kerja dan Circuit tanpa fractional gates

Dalam bahagian ini, kami membentangkan aliran kerja Qiskit patterns standard menggunakan Backend yang tidak menyokong fractional gates. Dengan membandingkan Circuit yang ditranspilasi, anda akan perasan bahawa versi menggunakan fractional gates (dari bahagian sebelumnya) lebih padat berbanding yang tanpa fractional gates.

# step 1: map classical inputs to quantum problem
# `circuits` and `params` from the previous section are reused here

# step 2: optimize circuits
backend_c = service.backend(backend_name)  # w/o fractional gates
pm_c = generate_preset_pass_manager(
    optimization_level=optimization_level, backend=backend_c
)
t_qc_c = pm_c.run(circuits)
print(t_qc_c[0].count_ops())
t_qc_c[0].draw("mpl", fold=-1)

OrderedDict([('rz', 130), ('sx', 80), ('cz', 36), ('measure', 4), ('barrier', 2)])

nnl_c = [qc.num_nonlocal_gates() for qc in t_qc_c]
depth_c = [qc.depth() for qc in t_qc_c]
duration_c = [
    qc.estimate_duration(backend_c.target, unit="u") for qc in t_qc_c
]

# step 3: execute
sampler_c = SamplerV2(backend_c)
sampler_c.options.dynamical_decoupling.enable = True
sampler_c.options.dynamical_decoupling.sequence_type = "XY4"
sampler_c.options.dynamical_decoupling.skip_reset_qubits = True

job = sampler_c.run(pubs=zip(t_qc_c, params), shots=shots)
print(job.job_id())

d4bnirvnmdfs73ae3a2g

# step 4: post-processing
# job = service.job("d1obp8j3rr0s73bg4810")
result = job.result()
fidelity_c = [fidelity(res) for res in result]
print(fidelity_c)
usage_c = job.usage()

[0.6675, 0.5725, 0.098, 0.102, 0.065, 0.0235, 0.006, 0.0015, 0.0015, 0.002]

Perbandingan kedalaman dan kesetiaan

Dalam bahagian ini, kita bandingkan bilangan gate bukan-tempatan dan kesetiaan antara Circuit yang menggunakan dan tidak menggunakan fractional gates. Ini menunjukkan potensi manfaat penggunaan fractional gates dari segi kecekapan pelaksanaan dan kualiti.

plt.plot(qubits, depth_c, "-o", label="no fractional gates")
plt.plot(qubits, depth_f, "-o", label="with fractional gates")
plt.xlabel("number of qubits")
plt.ylabel("depth")
plt.title("Comparison of depths")
plt.grid()
plt.legend()

<matplotlib.legend.Legend at 0x12bcaac50>

plt.plot(qubits, duration_c, "-o", label="no fractional gates")
plt.plot(qubits, duration_f, "-o", label="with fractional gates")
plt.xlabel("number of qubits")
plt.ylabel("duration (µs)")
plt.title("Comparison of durations")
plt.grid()
plt.legend()

<matplotlib.legend.Legend at 0x12bdef310>

plt.plot(qubits, nnl_c, "-o", label="no fractional gates")
plt.plot(qubits, nnl_f, "-o", label="with fractional gates")
plt.xlabel("number of qubits")
plt.ylabel("number of non-local gates")
plt.title("Comparison of numbers of non-local gates")
plt.grid()
plt.legend()

<matplotlib.legend.Legend at 0x12be8ac90>

plt.plot(qubits, fidelity_c, "-o", label="no fractional gates")
plt.plot(qubits, fidelity_f, "-o", label="with fractional gates")
plt.xlabel("number of qubits")
plt.ylabel("fidelity")
plt.title("Comparison of fidelities")
plt.grid()
plt.legend()

<matplotlib.legend.Legend at 0x12bea8290>

Kita bandingkan masa penggunaan QPU dengan dan tanpa fractional gates. Keputusan dalam sel berikut menunjukkan bahawa masa penggunaan QPU adalah hampir sama.

print(f"no fractional gates: {usage_c} seconds")
print(f"fractional gates: {usage_f} seconds")

no fractional gates: 7 seconds
fractional gates: 7 seconds

Topik lanjutan: Menggunakan hanya fractional RX gates

Keperluan untuk alur kerja yang diubah suai apabila menggunakan fractional gates terutamanya berpunca daripada sekatan pada sudut Gate RZZ. Walau bagaimanapun, jika anda hanya menggunakan fractional RX gates dan tidak menggunakan fractional RZZ gates, anda boleh terus mengikuti alur kerja standard Qiskit patterns. Pendekatan ini masih boleh memberikan manfaat yang bermakna, terutamanya dalam Circuit yang melibatkan banyak Gate RX dan Gate U, dengan mengurangkan jumlah bilangan gate dan berpotensi meningkatkan prestasi. Dalam bahagian ini, kami tunjukkan cara untuk mengoptimumkan Circuit anda menggunakan hanya fractional RX gates, sambil mengetepikan Gate RZZ.

Untuk menyokong ini, kami menyediakan fungsi utiliti yang membolehkan anda melumpuhkan gate asas tertentu dalam objek Target. Di sini, kita gunakannya untuk melumpuhkan Gate RZZ.

from qiskit.circuit.library import n_local
from qiskit.transpiler import Target

def remove_instruction_from_target(target: Target, gate_name: str) -> Target:
    new_target = Target(
        description=target.description,
        num_qubits=target.num_qubits,
        dt=target.dt,
        granularity=target.granularity,
        min_length=target.min_length,
        pulse_alignment=target.pulse_alignment,
        acquire_alignment=target.acquire_alignment,
        qubit_properties=target.qubit_properties,
        concurrent_measurements=target.concurrent_measurements,
    )

    for name, qarg_map in target.items():
        if name == gate_name:
            continue
        instruction = target.operation_from_name(name)
        if qarg_map == {None: None}:
            qarg_map = None
        new_target.add_instruction(instruction, qarg_map, name=name)
    return new_target

Kita gunakan Circuit yang terdiri daripada Gate U, CZ, dan RZZ sebagai contoh.

qc = n_local(3, "u", "cz", "linear", reps=1)
qc.rzz(1.1, 0, 1)
qc.draw("mpl")

Kita dahulukan dengan mentranspilasikan Circuit untuk Backend yang tidak menyokong fractional gates.

pm_c = generate_preset_pass_manager(
    optimization_level=optimization_level, backend=backend_c
)
t_qc = pm_c.run(qc)
print(t_qc.count_ops())
t_qc.draw("mpl")

OrderedDict([('rz', 23), ('sx', 16), ('cz', 4)])

Kemudian, kita transpilasikan Circuit yang sama menggunakan fractional RX gates, sambil mengecualikan Gate RZZ. Ini menghasilkan sedikit pengurangan dalam jumlah bilangan gate, berkat pelaksanaan Gate RX yang lebih cekap.

backend_f = service.backend(backend_name, use_fractional_gates=True)
target = remove_instruction_from_target(backend_f.target, "rzz")
pm_f = generate_preset_pass_manager(
    optimization_level=optimization_level,
    target=target,
)
t_qc = pm_f.run(qc)
print(t_qc.count_ops())
t_qc.draw("mpl")

OrderedDict([('rz', 22), ('sx', 14), ('cz', 4), ('rx', 1)])

Optimumkan Gate U dengan fractional RX gates

Dalam bahagian ini, kami tunjukkan cara mengoptimumkan Gate U menggunakan fractional RX gates, berdasarkan Circuit yang sama yang diperkenalkan dalam bahagian sebelumnya.

Anda perlu memasang pakej qiskit-basis-constructor ini untuk bahagian ini. Ini adalah versi beta bagi plugin transpilasi baru untuk Qiskit, yang mungkin akan diintegrasikan ke dalam Qiskit pada masa hadapan.

# %pip install qiskit-basis-constructor

from qiskit.circuit.library import UGate
from qiskit_basis_constructor import DEFAULT_EQUIVALENCE_LIBRARY

Kita transpilasikan Circuit menggunakan hanya fractional RX gates, mengecualikan Gate RZZ. Dengan memperkenalkan peraturan penguraian tersuai, seperti yang ditunjukkan di bawah, kita boleh mengurangkan bilangan gate single-Qubit yang diperlukan untuk melaksanakan Gate U.

Ciri ini sedang dalam perbincangan dalam isu GitHub ini.

# special decomposition rule for UGate
x = ParameterVector("x", 3)
zxz = QuantumCircuit(1)
zxz.rz(x[2] - np.pi / 2, 0)
zxz.rx(x[0], 0)
zxz.rz(x[1] + np.pi / 2, 0)
DEFAULT_EQUIVALENCE_LIBRARY.add_equivalence(UGate(x[0], x[1], x[2]), zxz)

Seterusnya, kita terapkan Transpiler menggunakan terjemahan constructor-beta yang disediakan oleh pakej qiskit-basis-constructor. Hasilnya, jumlah bilangan gate berkurangan berbanding transpilasi sebelumnya.

pm_f = generate_preset_pass_manager(
    optimization_level=optimization_level,
    target=target,
    translation_method="constructor-beta",
)
t_qc = pm_f.run(qc)
print(t_qc.count_ops())
t_qc.draw("mpl")

OrderedDict([('rz', 16), ('rx', 9), ('cz', 4)])

Penyelesaian masalah

Isu: Sudut RZZ yang tidak sah mungkin kekal selepas transpilasi

Setakat Qiskit v2.0.3, terdapat isu yang diketahui di mana Gate RZZ dengan sudut yang tidak sah mungkin kekal dalam Circuit walaupun selepas transpilasi. Isu ini biasanya timbul dalam keadaan berikut.

Kegagalan apabila menggunakan pilihan target dengan generate_preset_pass_manager atau transpiler

Apabila pilihan target digunakan dengan generate_preset_pass_manager atau transpiler, pas Transpiler khusus FoldRzzAngle tidak dipanggil. Untuk memastikan pengendalian sudut RZZ yang betul untuk fractional gates, kami mengesyorkan agar sentiasa menggunakan pilihan backend sebagai gantinya. Lihat isu ini untuk maklumat lanjut.

Kegagalan apabila Circuit mengandungi gate tertentu

Jika Circuit anda mengandungi gate tertentu seperti XXPlusYYGate, Transpiler Qiskit mungkin menghasilkan Gate RZZ dengan sudut yang tidak sah. Jika anda menghadapi isu ini, lihat isu GitHub ini untuk penyelesaian alternatif.

Tinjauan tutorial

Sila ambil tinjauan ringkas ini untuk memberikan maklum balas tentang tutorial ini. Pandangan anda akan membantu kami memperbaiki kandungan dan pengalaman pengguna kami.

Pautan ke tinjauan

Note: This survey is provided by IBM Quantum and relates to the original English content. To give feedback on doQumentation's website, translations, or code execution, please open a GitHub issue.