QESEM: Fungsi Qiskit oleh Qedma
Lihat rujukan API
Versi pakej
Kod pada halaman ini dibangunkan menggunakan keperluan berikut. Kami mengesyorkan menggunakan versi ini atau yang lebih baharu.
qiskit[all]~=2.5.0
qiskit-ibm-runtime~=0.47.0
Fungsi Qiskit adalah ciri eksperimental yang hanya tersedia untuk pengguna Pelan Premium IBM Quantum®, Pelan Flex, dan Pelan On-Prem (melalui API Platform IBM Quantum). Ia berada dalam status keluaran pratonton dan tertakluk kepada perubahan.
Gambaran keseluruhan
Walaupun unit pemprosesan kuantum telah bertambah baik dengan pesat dalam beberapa tahun kebelakangan ini, ralat akibat hingar dan ketidaksempurnaan perkakasan sedia ada tetap menjadi cabaran utama bagi pembangun algoritma kuantum. Apabila bidang ini mendekati pengiraan kuantum skala utiliti yang tidak boleh disahkan secara klasik, penyelesaian untuk membatalkan hingar dengan ketepatan yang terjamin semakin penting. Untuk mengatasi cabaran ini, Qedma telah membangunkan Quantum Error Mitigation (QESEM), yang disepadukan dengan lancar pada Platform IBM Quantum sebagai Fungsi Qiskit.
Dengan QESEM, pengguna boleh menjalankan litar kuantum mereka pada QPU berbising untuk mendapatkan keputusan tepat bebas ralat dengan overhed masa QPU yang sangat cekap, hampir kepada had asas. Untuk mencapai ini, QESEM memanfaatkan suite kaedah proprietari yang dibangunkan oleh Qedma untuk pencirian dan pengurangan ralat. Teknik pengurangan ralat merangkumi pengoptimuman gate, pentranspilan peka-hingar, penindasan ralat (ES), dan mitigasi ralat tidak berat sebelah (EM). Dengan gabungan kaedah berasaskan pencirian ini, pengguna boleh mencapai keputusan yang boleh dipercayai dan bebas ralat untuk litar kuantum bervolum besar yang generik, membuka kunci aplikasi yang tidak dapat dicapai sebaliknya.
Untuk penerangan penuh komponen asas, serta demonstrasi skala utiliti, rujuk kertas Reliable high-accuracy error mitigation for utility-scale quantum circuits.
Penerangan
Anda boleh menggunakan fungsi QESEM oleh Qedma untuk menganggarkan dan melaksanakan litar anda dengan mudah menggunakan penindasan dan mitigasi ralat, mencapai volum litar yang lebih besar dan ketepatan yang lebih tinggi. Untuk menggunakan QESEM, anda menyediakan litar kuantum, satu set boleh cerap untuk diukur, ketepatan statistik sasaran untuk setiap boleh cerap, dan QPU yang dipilih. Sebelum menjalankan litar ke ketepatan sasaran, anda boleh menganggarkan masa QPU yang diperlukan berdasarkan pengiraan analitik yang tidak memerlukan pelaksanaan litar. Setelah anda berpuas hati dengan anggaran masa QPU, anda boleh melaksanakan litar dengan QESEM.
Apabila anda melaksanakan litar, QESEM menjalankan protokol pencirian peranti yang disesuaikan dengan litar anda, menghasilkan model hingar yang boleh dipercayai untuk ralat yang berlaku dalam litar. Berdasarkan pencirian, QESEM pertama melaksanakan pentranspilan peka-hingar untuk memetakan litar input ke set qubit dan gate fizikal, yang meminimumkan hingar yang mempengaruhi boleh cerap sasaran. Ini termasuk gate yang tersedia secara asli (CX/CZ pada peranti IBM®), serta gate tambahan yang dioptimumkan oleh QESEM, membentuk set gate lanjutan QESEM. QESEM kemudian menjalankan set litar ES dan EM berasaskan pencirian pada QPU dan mengumpul hasil pengukuran mereka. Ini kemudian diproses secara klasik untuk memberikan nilai jangkaan tidak berat sebelah dan bar ralat untuk setiap boleh cerap, sepadan dengan ketepatan yang diminta.
QESEM telah terbukti memberikan keputusan berketetapan tinggi untuk pelbagai aplikasi kuantum dan pada volum litar terbesar yang boleh dicapai hari ini. QESEM menawarkan ciri-ciri berikut untuk pengguna, yang ditunjukkan dalam bahagian penanda aras di bawah:
- Ketepatan terjamin: QESEM mengeluarkan anggaran tidak berat sebelah untuk nilai jangkaan boleh cerap. Kaedah EM-nya dilengkapi dengan jaminan teori, yang - bersama dengan pencirian terkini Qedma - memastikan mitigasi menumpu ke output litar tanpa hingar sehingga ketepatan yang ditentukan pengguna. Berbanding dengan banyak kaedah EM heuristik yang terdedah kepada ralat sistematik atau berat sebelah, ketepatan terjamin QESEM penting untuk memastikan keputusan yang boleh dipercayai dalam litar dan boleh cerap kuantum yang generik.
- Penskalaan ke QPU besar: Masa QPU QESEM bergantung pada volum litar, tetapi bebas daripada bilangan qubit. Qedma telah menunjukkan QESEM pada peranti kuantum terbesar yang tersedia hari ini, termasuk peranti IBM Quantum Eagle 127-qubit dan Heron 133-qubit.
- Bebas aplikasi: QESEM telah ditunjukkan pada pelbagai aplikasi, termasuk simulasi Hamiltonian, VQE, QAOA, dan anggaran amplitud. Pengguna boleh memasukkan sebarang litar kuantum dan boleh cerap untuk diukur, dan mendapatkan keputusan tepat bebas ralat. Satu-satunya batasan didiktekan oleh spesifikasi perkakasan dan masa QPU yang diperuntukkan, yang menentukan volum litar yang boleh diakses dan ketepatan output. Berbanding, banyak penyelesaian pengurangan ralat adalah khusus untuk aplikasi atau melibatkan heuristik yang tidak terkawal, menjadikannya tidak terpakai untuk litar dan aplikasi kuantum generik.
- Set gate lanjutan: QESEM menyokong gate dengan sudut pecahan, dan menyediakan gate sudut pecahan yang dioptimumkan Qedma pada peranti IBM Quantum Heron dan Eagle. Set gate lanjutan ini membolehkan kompilasi yang lebih cekap dan membuka kunci volum litar yang lebih besar sebanyak faktor 2 berbanding kompilasi CX/CZ lalai.
- Boleh cerap multiasas: QESEM menyokong boleh cerap input yang terdiri daripada banyak rentetan Pauli yang tidak bertukar ganti, seperti Hamiltonian generik. Pilihan asas pengukuran dan pengoptimuman peruntukan sumber QPU (tembakan dan litar) kemudian dilakukan secara automatik oleh QESEM untuk meminimumkan masa QPU yang diperlukan untuk ketepatan yang diminta. Pengoptimuman ini, yang mengambil kira kesetiaan perkakasan dan kadar pelaksanaan, membolehkan anda menjalankan litar yang lebih dalam dan mendapatkan ketepatan yang lebih tinggi.
Penanda aras
QESEM telah diuji pada pelbagai kes penggunaan dan aplikasi. Contoh-contoh berikut boleh membantu anda menilai jenis beban kerja yang boleh anda jalankan dengan QESEM.
Angka merit utama untuk mengukur kesukaran mitigasi ralat dan simulasi klasik untuk litar dan boleh cerap tertentu ialah volum aktif: bilangan gate CNOT yang mempengaruhi boleh cerap dalam litar. Volum aktif bergantung pada kedalaman dan lebar litar, pada wajaran boleh cerap, dan pada struktur litar, yang menentukan kon cahaya boleh cerap. Untuk maklumat lanjut, lihat ucapan dari Sidang Kemuncak IBM Quantum 2024. QESEM memberikan nilai yang sangat besar dalam rejim volum tinggi, memberikan keputusan yang boleh dipercayai untuk litar dan boleh cerap generik.
| Aplikasi | Bilangan qubit | Peranti | Penerangan litar | Ketepatan | Jumlah masa | Penggunaan runtime |
|---|---|---|---|---|---|---|
| Litar VQE | 8 | Eagle (r3) | 21 lapisan jumlah, 9 asas pengukuran, rantai 1D | 98% | 35 min | 14 min |
| Kicked Ising | 28 | Eagle (r3) | 3 lapisan unik x 3 langkah, topologi hex-berat 2D | 97% | 22 min | 4 min |
| Kicked Ising | 28 | Eagle (r3) | 3 lapisan unik x 8 langkah, topologi hex-berat 2D | 97% | 116 min | 23 min |
| Simulasi Hamiltonian Trotterized | 40 | Eagle (r3) | 2 lapisan unik x 10 langkah Trotter, rantai 1D | 97% | 3 jam | 25 min |
| Simulasi Hamiltonian Trotterized | 119 | Eagle (r3) | 3 lapisan unik x 9 langkah Trotter, topologi hex-berat 2D | 95% | 6.5 jam | 45 min |
| Kicked Ising | 136 | Heron (r2) | 3 lapisan unik x 15 langkah, topologi hex-berat 2D | 99% | 52 min | 9 min |
Ketepatan diukur di sini relatif terhadap nilai ideal boleh cerap: , di mana '' ialah ketepatan mutlak mitigasi (ditetapkan oleh input pengguna), dan ialah boleh cerap pada litar tanpa hingar. 'Penggunaan runtime' mengukur penggunaan penanda aras dalam mod kelompok (jumlah penggunaan kerja individu), manakala 'jumlah masa' mengukur penggunaan dalam mod sesi (masa dinding eksperimen), yang merangkumi masa klasik dan komunikasi tambahan. QESEM tersedia untuk pelaksanaan dalam kedua-dua mod, supaya pengguna boleh memanfaatkan sebaik-baiknya sumber yang ada.
Litar Kicked Ising 28-qubit mensimulasikan Quasicrystal Masa Diskret yang dikaji oleh Shinjo et al. (lihat arXiv 2403.16718 dan Q2B24 Tokyo) pada tiga gelung bersambung ibm_kawasaki. Parameter litar yang diambil di sini ialah , dengan keadaan awal feromagnet . Boleh cerap yang diukur ialah nilai mutlak kemagnetan . Eksperimen Kicked Ising skala utiliti dijalankan pada 136 qubit terbaik ibm_fez; penanda aras khusus ini dijalankan pada sudut Clifford , di mana volum aktif berkembang perlahan dengan kedalaman litar, yang - bersama dengan kesetiaan peranti yang tinggi - membolehkan ketepatan tinggi pada masa runtime yang singkat.
Litar simulasi Hamiltonian Trotterized adalah untuk model Ising Medan Transversal pada sudut pecahan: dan secara berturutan (lihat Q2B24 Tokyo). Litar skala utiliti dijalankan pada 119 qubit terbaik ibm_brisbane, manakala eksperimen 40-qubit dijalankan pada rantai terbaik yang tersedia. Ketepatan dilaporkan untuk kemagnetan; keputusan berketetapan tinggi diperoleh untuk boleh cerap berwajaran lebih tinggi juga.
Litar VQE dibangunkan bersama penyelidik dari Pusat Teknologi dan Aplikasi Kuantum di Deutsches Elektronen-Synchrotron (DESY). Boleh cerap sasaran di sini ialah Hamiltonian yang terdiri daripada sejumlah besar rentetan Pauli yang tidak bertukar ganti, menekankan prestasi QESEM yang dioptimumkan untuk boleh cerap pelbagai asas. Mitigasi diterapkan pada ansatz yang dioptimumkan secara klasik; walaupun keputusan ini masih belum diterbitkan, keputusan dengan kualiti yang sama akan diperoleh untuk litar berbeza dengan sifat struktur yang serupa.
Mulakan
Sahkan menggunakan kunci API Platform IBM Quantum anda, dan pilih Fungsi Qiskit QESEM seperti berikut. (Petikan kod ini menganggap anda sudah menyimpan akaun anda ke persekitaran tempatan.)
# Added by doQumentation — required packages for this notebook
!pip install -q qiskit qiskit-ibm-catalog qiskit-ibm-runtime
import qiskit
from qiskit_ibm_catalog import QiskitFunctionsCatalog
catalog = QiskitFunctionsCatalog(channel="ibm_quantum_platform")
# verify that you have access to the function
catalog.list()
# load the function
qesem_function = catalog.load("qedma/qesem")
Contoh
Contoh kerja anggaran masa
Kerja anggaran masa berguna untuk menganggarkan masa QPU yang diperlukan untuk pub dan backend_name tertentu. backend_name juga boleh ditetapkan kepada mana-mana Backend simulator; contohnya, fake_fez.
QESEM menggunakan kaedah EM berasaskan pencirian, kuasi-kebarangkalian. Kaedah ini mempunyai overhed masa QPU yang secara kasarnya berskala seperti:
Di mana ialah isipadu aktif Circuit, ialah ketepatan sasaran, dan ialah ketidaksetiaan get asli.
Perhatikan bahawa "estimate_time_only": "empirical" menggunakan beberapa minit masa QPU untuk menganggarkan masa yang diperlukan untuk kerja tersebut (jika Backend adalah peranti sebenar; jika ia simulator, maka tiada masa QPU digunakan). Ini biasanya mengambil masa sekitar 5 minit, tetapi tidak lebih daripada 10 minit. Jika ketidaksetiaan berubah secara mendadak antara kerja anggaran masa empirikal dan kerja mitigasi, masa QPU juga akan berubah secara mendadak.
Untuk bermula, cuba contoh asas ini untuk menganggarkan masa QPU yang diperlukan untuk menjalankan QESEM bagi pub tertentu:
# This cell is hidden from users
from qiskit_ibm_runtime import QiskitRuntimeService
service = QiskitRuntimeService()
backend_name = service.least_busy().name
backend_name = "fake_fez"
circ = qiskit.QuantumCircuit(5)
circ.cx(0, 1)
circ.cx(2, 3)
circ.cx(1, 2)
circ.cx(3, 4)
avg_magnetization = qiskit.quantum_info.SparsePauliOp.from_sparse_list(
[("Z", [q], 1 / 5) for q in range(5)], num_qubits=5
)
other_observable = qiskit.quantum_info.SparsePauliOp.from_sparse_list(
[("ZZ", [0, 1], 1.0), ("XZ", [1, 4], 0.5)], num_qubits=5
)
time_estimation_job = qesem_function.run(
pubs=[(circ, [avg_magnetization, other_observable])],
options={
"estimate_time_only": "empirical",
},
backend_name=backend_name, # example: "fake_fez", "ibm_fez"
)
time_estimate_result = (
time_estimation_job.result()
) # a list of results per pub (circuit)
Petikan kod berikut menunjukkan cara mendapatkan semula pelbagai metrik pelaksanaan daripada kerja anggaran masa (estimate_time_only ditetapkan):
pub_result = time_estimate_result[0]
print(
f"The estimated QPU time for mitigation for this PUB is: {pub_result.metadata['time_estimation_sec']}"
)
print(
f"The QPU time that this time estimation job took is (here it is 0 because we used fake_fez): {pub_result.metadata['total_qpu_time']}"
)
print(
f"Gates fidelity measured during the experiment: {pub_result.metadata['gate_fidelities']}"
)
print(f"Total shots: {pub_result.metadata['total_shots']}")
print(f"Resource usage breakdown: {pub_result.metadata['resource_usage']}")
The estimated QPU time for mitigation for this PUB is: 300
The QPU time that this time estimation job took is (here it is 0 because we used fake_fez): 0
Gates fidelity measured during the experiment: {'CZ': 0.9951354916722668, 'ID1Q': 0.9991246627329172}
Total shots: 220000
Resource usage breakdown: {'RUNNING: MAPPING': {'CPU_TIME': 33.6066133165732, 'GPU_TIME': 0.0, 'QPU_TIME': 0.0}, 'RUNNING: OPTIMIZING_FOR_HARDWARE': {'CPU_TIME': 184.53575124032795, 'GPU_TIME': 0.0, 'QPU_TIME': 0.0}, 'RUNNING: WAITING_FOR_QPU': {'CPU_TIME': 0.0, 'GPU_TIME': 0.0, 'QPU_TIME': 0.0}, 'RUNNING: EXECUTING_QPU': {'CPU_TIME': 0.0, 'GPU_TIME': 0.0, 'QPU_TIME': 0.0}, 'RUNNING: POST_PROCESSING': {'CPU_TIME': 0.0, 'GPU_TIME': 0.0, 'QPU_TIME': 0.0}}
Apabila anggaran masa empirikal didayakan, QESEM menjalankan sebilangan kecil Circuit untuk menyediakan anggaran masa QPU yang lebih tepat. Keputusan mitigasi daripada Circuit ini tersedia dalam medan empirical_estimation_mitigation_results kerja tersebut.
Kerana keputusan ini diperoleh daripada sampel Circuit yang terhad, ia jauh kurang tepat berbanding keputusan akhir yang diperoleh daripada kerja mitigasi QESEM yang lengkap. Walau bagaimanapun, apabila Circuit kecil atau ketepatan sasaran rendah, mitigasi yang dilakukan semasa anggaran masa empirikal mungkin mencukupi untuk mencapai ketepatan yang diinginkan, dan kerja mitigasi penuh mungkin tidak diperlukan.
Medan empirical_estimation_mitigation_results ialah senarai objek PrimitiveResult bagi setiap parameter input. Jika Circuit tidak diparameterkan, senarai itu akan berpanjangan 1.
empirical_estimation_mitigation_results = time_estimate_result[0].metadata[
"empirical_estimation_mitigation_results"
][0] # a list per parameter
print("Partial results for the observables:")
print(
f" Mitigated expectation values: {empirical_estimation_mitigation_results.data.evs}"
)
print(
f" Mitigated error bars: {empirical_estimation_mitigation_results.data.stds}"
)
print(
f" Number of shots used for mitigation: {empirical_estimation_mitigation_results.metadata['mitigation_shots']}"
)
transpiled_circ = empirical_estimation_mitigation_results.metadata[
"transpiled_circ"
]
print(f" Qubit mapping: {transpiled_circ['qubit_maps']}")
print(
f" Number of measurement bases: {transpiled_circ['num_measurement_bases']}\n"
)
# results per obs
emp_obs_results = empirical_estimation_mitigation_results.metadata["results"][
0
]
# print(f"Results for each observable: {results}")
print("Results for each observable:")
for i, (obs_array, result_dict) in enumerate(emp_obs_results):
# obs_array, result_dict = results
print(f"Observable {i+1}: {obs_array}")
print(
f" QESEM mitigated value: {result_dict['qesem']['value']} \u00b1 {result_dict['qesem']['error_bar']}"
)
Partial results for the observables:
Mitigated expectation values: [1.00347302 1.00693905]
Mitigated error bars: [0.00304061 0.00714276]
Number of shots used for mitigation: 180000
Qubit mapping: [[[0, 136], [1, 143], [2, 142], [3, 141], [4, 140]]]
Number of measurement bases: 2
Results for each observable:
Observable 1: ObservablesArray({'IIIIZ': 0.2, 'IIIZI': 0.2, 'IIZII': 0.2, 'IZIII': 0.2, 'ZIIII': 0.2}, shape=())
QESEM mitigated value: 1.003473015776871 ± 0.0030406128032204015
Observable 2: ObservablesArray({'IIIZZ': 1.0, 'ZIIXI': 0.5}, shape=())
QESEM mitigated value: 1.0069390542613554 ± 0.0071427606736885925
Contoh kerja mitigasi QESEM
Contoh berikut melaksanakan kerja QESEM:
sample_job = qesem_function.run(
pubs=[(circ, [avg_magnetization, other_observable])],
backend_name=backend_name, # example: "ibm_fez"
# options = {
# "estimate_time_only": "empirical",
# "default_precision": 0.2, # Default precision is applied to all pubs that don't have a precision specified, see API reference for more details
# "max_execution_time": 3600, # You can specify a maximum QPU time in seconds, see API reference for more details
# "transpilation_level": "standard", # "minimal_with_layout_opt" for minimal transpilation, see API reference for more details
# "parallel_execution": True, # True for parallel execution, see API reference for more details
# },
)
Untuk penerangan terperinci tentang setiap medan input dan pilihan, lihat rujukan API QESEM. Anda boleh menggunakan API Qiskit Serverless yang biasa untuk menyemak status beban kerja Fungsi Qiskit anda atau mendapatkan semula keputusan:
# Print the ID so you can use it later, if necessary
print(sample_job.job_id)
print(sample_job.status())
sample_result = sample_job.result()
3ac6b2df-15b0-4dc0-8f48-cf14bd20a1c8
DONE
Petikan kod berikut menunjukkan cara mendapatkan semula keputusan mitigasi dan metrik pelaksanaan. Ini mengandungi data penting yang membolehkan pemahaman lebih mendalam tentang bagaimana parameter berbeza mempengaruhi pelaksanaan QESEM. Ia juga mungkin relevan apabila menulis kertas berdasarkan penyelidikan anda.
for pub_idx, pub_result in enumerate(
sample_result
): # each element in the list is a result for a different pub, here we sent only one pub
print(f"\nPUB {pub_idx}:")
print(
f" The QPU time that this job took is (here it is 0 because we used fake_fez): {pub_result.metadata['total_qpu_time']}"
)
print(
f" Gates fidelity measured during the experiment: {pub_result.metadata['gate_fidelities']}"
)
print(f" Total shots: {pub_result.metadata['total_shots']}")
print(
f" Number of shots used for mitigation: {pub_result.metadata['mitigation_shots']}"
)
print(
f" Resource usage breakdown: {pub_result.metadata['resource_usage']}"
)
PUB 0:
The QPU time that this job took is (here it is 0 because we used fake_fez): 0.0
Gates fidelity measured during the experiment: {'CZ': 0.9953704216147041, 'ID1Q': 0.9991834123567518}
Total shots: 446000
Number of shots used for mitigation: 194000
Resource usage breakdown: {'RUNNING: MAPPING': {'CPU_TIME': 32.52745003718883, 'GPU_TIME': 0.0, 'QPU_TIME': 0.0}, 'RUNNING: OPTIMIZING_FOR_HARDWARE': {'CPU_TIME': 257.850521848537, 'GPU_TIME': 0.0, 'QPU_TIME': 0.0}, 'RUNNING: WAITING_FOR_QPU': {'CPU_TIME': 0.0, 'GPU_TIME': 0.0, 'QPU_TIME': 0.0}, 'RUNNING: EXECUTING_QPU': {'CPU_TIME': 0.0, 'GPU_TIME': 0.0, 'QPU_TIME': 0.0}, 'RUNNING: POST_PROCESSING': {'CPU_TIME': 0.0, 'GPU_TIME': 0.0, 'QPU_TIME': 0.0}}
Dalam metadata["results"], keputusan dikumpulkan dahulu mengikut instans Circuit dan kemudian mengikut boleh diperhatikan.
print("Full QESEM mitigation results:")
for pub_idx, pub_result in enumerate(sample_result):
print(f"\nPUB {pub_idx}:")
print(f" Mitigated expectation values: {pub_result.data.evs}")
print(f" Mitigated error bars: {pub_result.data.stds}")
noisy_results = pub_result.metadata.get("noisy_results")
print(f" Unmitigated expectation values: {noisy_results.evs}")
print(f" Unmitigated error bars: {noisy_results.stds}")
print(" Transpiled circuits:")
for circ_idx, transpiled_circ in enumerate(
pub_result.metadata["transpiled_circs"]
):
print(f" Circuit {circ_idx}:")
# print(f" Circuit: \n {transpiled_circ['circuit']}") # not printing it because it's long but you can see the transpiled circuit itself
print(f" Qubit mapping: {transpiled_circ['qubit_maps']}")
print(
f" Measurement bases: {transpiled_circ['num_measurement_bases']}"
)
print(" Results for each observable:")
for circ_idx, circ_results in enumerate(pub_result.metadata["results"]):
print(f" Circuit {circ_idx}:")
for obs_idx, (obs_array, result_dict) in enumerate(circ_results):
print(f" Observable {obs_idx}: {obs_array}")
print(
f" QESEM mitigated value: {result_dict['qesem']['value']} ± {result_dict['qesem']['error_bar']}"
)
print(
f" Unmitigated value: {result_dict['unmitigated']['value']} ± {result_dict['unmitigated']['error_bar']}"
)
Full QESEM mitigation results:
PUB 0:
Mitigated expectation values: [1.00648343 1.00636289]
Mitigated error bars: [0.00253812 0.00693586]
Unmitigated expectation values: [0.98031429 0.96357143]
Unmitigated error bars: [0.00124128 0.00578812]
Transpiled circuits:
Circuit 0:
Qubit mapping: [[[0, 140], [1, 141], [2, 142], [3, 143], [4, 136]]]
Measurement bases: 2
Results for each observable:
Circuit 0:
Observable 0: ObservablesArray({'IIIIZ': 0.2, 'IIIZI': 0.2, 'IIZII': 0.2, 'IZIII': 0.2, 'ZIIII': 0.2}, shape=())
QESEM mitigated value: 1.0064834305181962 ± 0.002538119914534849
Unmitigated value: 0.9803142857142859 ± 0.0012412835813609938
Observable 1: ObservablesArray({'IIIZZ': 1.0, 'ZIIXI': 0.5}, shape=())
QESEM mitigated value: 1.0063628870614818 ± 0.006935859820870656
Unmitigated value: 0.9635714285714285 ± 0.005788121870526659
Pecahan keputusan utama:
mitigated: nilai jangkaan QESEM yang telah dimitigasi sepenuhnya.unmitigated: keputusan hingar fizikal mentah tanpa mitigasi ralat.
Keputusan ekstrapolasi heuristik QESEM
Dalam larian QESEM standard dengan satu titik apungan precision tunggal, keputusan juga termasuk titik penskalaan hingar yang tersedia secara automatik yang digunakan untuk heuristik QESEM. Titik ini dikira tanpa sumber QPU tambahan.
Skala 1.0 mewakili tahap hingar peranti fizikal dengan mitigasi bacaan (REM), manakala skala 2.0 ialah titik amplifikasi hingar pelengkap, juga dengan REM. Titik ini digunakan untuk menghasilkan keputusan qesem_heuristic.
-
qesem_heuristic: anggaran gaya ZNE yang dikira daripada data berskala hingar yang tersedia. Buat masa ini, ini menggunakan ekstrapolasi eksponen. -
noise_scaling.results_with_REM: nilai jangkaan pada skala hingar yang berbeza, semuanya dengan mitigasi bacaan (REM).
Butiran yang halus tetapi penting ialah keputusan skala 1.0 tidak sama dengan keputusan unmitigated. Kedua-duanya sepadan dengan tahap hingar peranti fizikal, tetapi titik skala 1.0 termasuk mitigasi bacaan, manakala unmitigated tidak.
print("QESEM heuristic results:")
for pub_idx, pub_result in enumerate(sample_result):
print(f"\nPUB {pub_idx}:")
for circ_idx, circ_results in enumerate(pub_result.metadata["results"]):
print(f" Circuit {circ_idx}:")
for obs_idx, (obs_array, result_dict) in enumerate(circ_results):
print(f" Observable {obs_idx}: {obs_array}")
qesem_heuristic = result_dict["qesem_heuristic"][0]
print(" QESEM heuristic:")
print(
f" Value: {qesem_heuristic['value']} ± {qesem_heuristic['error_bar']}"
)
print(
f" Extrapolation: {qesem_heuristic['extrapolation']}"
)
print(
f" Scale factors: {qesem_heuristic['scale_factors']}"
)
noise_scaling = result_dict["noise_scaling"]
print(" Noise scaling results:")
print(
f" Scaling method: {noise_scaling['scaling_method']}"
)
print(" Results with Readout mitigation (REM):")
for rem_result in sorted(
(
item
for item in noise_scaling["results_with_REM"]
if item["scale"] != 0.0
),
key=lambda item: item["scale"],
):
print(
f" Scale factor {rem_result['scale']}: {rem_result['value']} ± {rem_result['error_bar']}"
)
QESEM heuristic results:
PUB 0:
Circuit 0:
Observable 0: ObservablesArray({'IIIIZ': 0.2, 'IIIZI': 0.2, 'IIZII': 0.2, 'IZIII': 0.2, 'ZIIII': 0.2}, shape=())
QESEM heuristic:
Value: 1.0008161638888535 ± 0.0038859458884403964
Extrapolation: exponential
Scale factors: [1.0, 2.0]
Noise scaling results:
Scaling method: QESEM
Results with Readout mitigation (REM):
Scale factor 1.0: 0.9918395459270772 ± 0.0012565417579355634
Scale factor 2.0: 0.982943441922748 ± 0.0028919278067695018
Observable 1: ObservablesArray({'IIIZZ': 1.0, 'ZIIXI': 0.5}, shape=())
QESEM heuristic:
Value: 0.9960853148925298 ± 0.013811635038961175
Extrapolation: exponential
Scale factors: [1.0, 2.0]
Noise scaling results:
Scaling method: QESEM
Results with Readout mitigation (REM):
Scale factor 1.0: 0.9902860583785115 ± 0.005921236914723409
Scale factor 2.0: 0.984520565414274 ± 0.006909522262347639
Contoh berikut memberi tumpuan kepada input dan hasil khusus ciri, jadi ia tidak mencetak metrik pelaksanaan penuh setiap kali. Metadata peringkat atas yang ditunjukkan sebelum ini, seperti total_qpu_time, gate_fidelities, total_shots, mitigation_shots, dan resource_usage, juga tersedia untuk pekerjaan ini.
Sesetengah pemboleh ubah daripada contoh sebelumnya, termasuk Backend, boleh diperhatikan, dan parameter Circuit asas, digunakan semula di bawah untuk keringkasan.
Semua contoh berikut juga boleh dijalankan dengan anggaran masa empirikal. Untuk mengaktifkannya, hantar "estimate_time_only": "empirical" dalam pilihan fungsi.
Contoh Circuit berparameter
Banyak algoritma menilai Circuit yang sama pada beberapa nilai parameter. Menghantar Circuit berparameter sebagai satu kerja QESEM membolehkan QESEM berkongsi pencirian dan kalibrasi merentasi instans Circuit, yang boleh mengurangkan overhed masa QPU berbanding menjalankan kerja berasingan.
Menghantar Circuit berparameter memerlukan penggunaan tahap transpilasi "minimal_with_layout_opt".
Circuit yang dihantar pada tahap ini sepatutnya sudah dinyatakan menggunakan get asas Backend, bergantung kepada Backend. Pada tahap ini, QESEM mengekalkan struktur yang dihantar sedekat mungkin dengan Circuit input, menghormati sekatan semasa layerifikasi (mengumpulkan operasi ke dalam lapisan get dua-Qubit selari), dan masih mengendalikan pemetaan perkakasan kepada Qubit ketepatan tinggi dan kesambungan peranti secara automatik.
Pada dasarnya, ini bermakna anda perlu mentranspilasi Circuit kepada get asas Backend sasaran sebelum penghantaran. Contoh transpilasi get asas yang mudah ditunjukkan di bawah.
QESEM kini hanya menyokong satu boleh diperhatikan bagi setiap set parameter. Dua baris parameter di bawah dizip dengan dua boleh diperhatikan: baris pertama diukur dengan avg_magnetization, dan baris kedua diukur dengan other_observable.
# Transpile to the backend basis gates only. With minimal_with_layout_opt, QESEM handles hardware mapping/connectivity and observable layout internally.
from qiskit_ibm_runtime.fake_provider import FakeFez
backend = FakeFez()
basis = backend.operation_names
print(basis)
param0 = qiskit.circuit.Parameter("param0")
param1 = qiskit.circuit.Parameter("param1")
parametrized_circ = qiskit.QuantumCircuit(5)
parametrized_circ.rx(param0, 0)
parametrized_circ.rx(param1, 1)
parametrized_circ.cx(0, 1)
parametrized_circ.cx(2, 3)
parametrized_circ.cx(1, 2)
parametrized_circ.cx(3, 4)
parametrized_circ = qiskit.transpile(
parametrized_circ, basis_gates=basis, optimization_level=1
)
parametrized_parameter_values = [[0.5, 0.1], [0.0, 0.6]]
parametrized_observables = [avg_magnetization, other_observable]
parametrized_job = qesem_function.run(
pubs=[
(
parametrized_circ,
parametrized_observables,
parametrized_parameter_values,
0.1,
)
],
backend_name=backend_name,
options={
"max_execution_time": 300,
"transpilation_level": "minimal_with_layout_opt",
},
)
print(parametrized_job.job_id)
print(parametrized_job.status())
d1b0e29b-196c-4896-aec6-44a268ebd874
DONE
parametrized_result = parametrized_job.result()
print("Parameterized circuit QESEM results:")
for pub_idx, pub_result in enumerate(parametrized_result):
print(f"\nPUB {pub_idx}:")
print(f" Mitigated expectation values: {pub_result.data.evs}")
print(f" Mitigated error bars: {pub_result.data.stds}")
noisy_results = pub_result.metadata["noisy_results"]
print(f" Unmitigated expectation values: {noisy_results.evs}")
print(f" Unmitigated error bars: {noisy_results.stds}")
print(" Results for each parameter value:")
for param_idx, param_results in enumerate(pub_result.metadata["results"]):
print(
f" Parameter set {param_idx}: {parametrized_parameter_values[param_idx]}"
)
for obs_idx, (obs_array, result_dict) in enumerate(param_results):
print(f" Observable {obs_idx}: {obs_array}")
print(
f" QESEM mitigated value: {result_dict['qesem']['value']} ± {result_dict['qesem']['error_bar']}"
)
print(
f" Unmitigated value: {result_dict['unmitigated']['value']} ± {result_dict['unmitigated']['error_bar']}"
)
Parameterized circuit QESEM results:
PUB 0:
Mitigated expectation values: [0.92392021 0.82517653]
Mitigated error bars: [0.00565281 0.00616016]
Unmitigated expectation values: [0.9028 0.78771429]
Unmitigated error bars: [0.00335142 0.00925413]
Results for each parameter value:
Parameter set 0: [0.5, 0.1]
Observable 0: ObservablesArray({'IIIIZ': 0.2, 'IIIZI': 0.2, 'IIZII': 0.2, 'IZIII': 0.2, 'ZIIII': 0.2}, shape=())
QESEM mitigated value: 0.923920210615709 ± 0.005652811570890183
Unmitigated value: 0.9028 ± 0.0033514176105045447
Parameter set 1: [0.0, 0.6]
Observable 0: ObservablesArray({'IIIZZ': 1.0, 'ZIIXI': 0.5}, shape=())
QESEM mitigated value: 0.8251765289285893 ± 0.006160161743353999
Unmitigated value: 0.7877142857142858 ± 0.009254130564027902
Contoh multi-pub
Pelaksanaan multi-pub berguna apabila anda ingin menjalankan beberapa Circuit berkaitan dalam satu kerja QESEM. Seperti pelaksanaan berparameter, ini boleh mengurangkan overhed kerana QESEM boleh berkongsi pencirian dan kalibrasi merentasi instans Circuit dan bukannya mengulanginya dalam kerja berasingan.
Ini amat berguna untuk Circuit dengan struktur lapisan yang dikongsi, seperti beban kerja jenis Trotter, di mana Circuit yang berbeza menggunakan semula lapisan unik yang sama. Dalam kes itu, menjalankannya bersama boleh mengurangkan kos pencirian berbanding kerja QESEM bebas.
Kerja multi-pub memerlukan "transpilation_level": "minimal_with_layout_opt". Seperti dalam contoh berparameter, Circuit perlu ditranspilasi kepada get asas Backend sasaran sebelum penghantaran. QESEM kemudian mengendalikan kesambungan peranti, susun atur, dan pemetaan kepada Qubit ketepatan tinggi secara dalaman.
Setiap PUB di bawah mengandungi satu Circuit dan dua boleh diperhatikan yang sama yang digunakan sebelum ini dalam notebook, jadi PrimitiveResult yang dikembalikan mengandungi satu PubResult bagi setiap Circuit input.
Contoh di bawah menggunakan dua Circuit Trotter mudah dengan corak lapisan yang sama: circ_a mempunyai satu lapisan Trotter, dan circ_b mengulangi corak lapisan yang sama dua kali. Ini menjadikan struktur yang dikongsi jelas.
def make_trotter_circuit(num_qubits, num_layers, zz_angle=0.2, x_angle=0.1):
trotter_circ = qiskit.QuantumCircuit(num_qubits)
for _ in range(num_layers):
for q in range(num_qubits):
trotter_circ.rx(x_angle, q)
trotter_circ.barrier()
for q in range(0, num_qubits - 1, 2):
trotter_circ.rzz(zz_angle, q, q + 1)
trotter_circ.barrier()
for q in range(1, num_qubits - 1, 2):
trotter_circ.rzz(zz_angle, q, q + 1)
trotter_circ.barrier()
return trotter_circ
circ_a = make_trotter_circuit(num_qubits=5, num_layers=1)
circ_b = make_trotter_circuit(num_qubits=5, num_layers=2)
multi_pubs = [
(
qiskit.transpile(qci, basis_gates=basis, optimization_level=1),
[avg_magnetization, other_observable],
)
for qci in [circ_a, circ_b]
]
multi_circ_job = qesem_function.run(
pubs=multi_pubs,
backend_name=backend_name,
options={
"max_execution_time": 300,
"transpilation_level": "minimal_with_layout_opt",
"default_precision": 0.1,
},
)
print(multi_circ_job.job_id)
print(multi_circ_job.status())
e34565b8-7262-4133-a120-de42ce624a99
DONE
multi_circ_result = multi_circ_job.result()
print("Multi-pub QESEM results:")
for pub_idx, pub_result in enumerate(multi_circ_result):
print(f"\nPUB {pub_idx}:")
print(f" Mitigated expectation values: {pub_result.data.evs}")
print(f" Mitigated error bars: {pub_result.data.stds}")
noisy_results = pub_result.metadata["noisy_results"]
print(f" Unmitigated expectation values: {noisy_results.evs}")
print(f" Unmitigated error bars: {noisy_results.stds}")
print(" Results for each observable:")
for circ_idx, circ_results in enumerate(pub_result.metadata["results"]):
print(f" Circuit {circ_idx}:")
for obs_idx, (obs_array, result_dict) in enumerate(circ_results):
print(f" Observable {obs_idx}: {obs_array}")
print(
f" QESEM mitigated value: {result_dict['qesem']['value']} ± {result_dict['qesem']['error_bar']}"
)
print(
f" Unmitigated value: {result_dict['unmitigated']['value']} ± {result_dict['unmitigated']['error_bar']}"
)
Multi-pub QESEM results:
PUB 0:
Mitigated expectation values: [0.99502406 1.02209332]
Mitigated error bars: [0.00483819 0.00707488]
Unmitigated expectation values: [0.96934286 0.97271429]
Unmitigated error bars: [0.00124855 0.00617294]
Results for each observable:
Circuit 0:
Observable 0: ObservablesArray({'IIIIZ': 0.2, 'IIIZI': 0.2, 'IIZII': 0.2, 'IZIII': 0.2, 'ZIIII': 0.2}, shape=())
QESEM mitigated value: 0.9950240647925642 ± 0.004838188086259301
Unmitigated value: 0.9693428571428573 ± 0.0012485470362492692
Observable 1: ObservablesArray({'IIIZZ': 1.0, 'ZIIXI': 0.5}, shape=())
QESEM mitigated value: 1.0220933230604674 ± 0.007074884384355636
Unmitigated value: 0.9727142857142859 ± 0.006172939375512439
PUB 1:
Mitigated expectation values: [0.98850017 1.02555188]
Mitigated error bars: [0.0077912 0.01672652]
Unmitigated expectation values: [0.93682857 0.95371429]
Unmitigated error bars: [0.00156245 0.00665735]
Results for each observable:
Circuit 0:
Observable 0: ObservablesArray({'IIIIZ': 0.2, 'IIIZI': 0.2, 'IIZII': 0.2, 'IZIII': 0.2, 'ZIIII': 0.2}, shape=())
QESEM mitigated value: 0.988500171577252 ± 0.007791203181151346
Unmitigated value: 0.9368285714285716 ± 0.001562451883089579
Observable 1: ObservablesArray({'IIIZZ': 1.0, 'ZIIXI': 0.5}, shape=())
QESEM mitigated value: 1.02555188098689 ± 0.016726524388086233
Unmitigated value: 0.9537142857142858 ± 0.006657345655544263
Contoh Penalaan Ralat Kuasi-Kebarangkalian (QET)
Penalaan Ralat Kuasi-Kebarangkalian (QET) meminta nilai jangkaan pada faktor skala hingar terpilih. Ini berguna untuk kajian penskalaan hingar tersuai dan aliran kerja Zero-Noise Extrapolation. Skala 1.0 ialah tahap hingar fizikal, nilai antara 0.0 dan 1.0 mengurangkan hingar secara separa, dan nilai melebihi 1.0 mengamplifikasi hingar.
Untuk menggunakan QET dengan Fungsi Qiskit, hantar kamus sebagai kejituan PUB. Kamus tersebut memetakan setiap skala hingar yang diminta kepada kejituan sasarannya. Keputusan faktor skala yang dipulangkan disimpan dalam noise_scaling.results_with_REM dan termasuk mitigasi bacaan. Oleh itu, titik skala 1.0 tidak sama dengan nilai tanpa mitigasi, kerana 1.0 termasuk mitigasi bacaan manakala unmitigated tidak.
Apabila skala diminta, QESEM juga memulangkan skala pelengkap sekitar 1.0 tanpa penggunaan QPU tambahan. Sebagai contoh, meminta 0.5 juga boleh memulangkan 1.5, dan meminta 1.3 juga boleh memulangkan 0.7. Kejituan pada skala pelengkap tidak dijamin.
noise_scale_precision = {0.5: 0.15, 1.3: 0.2}
qet_job = qesem_function.run(
pubs=[
(
circ,
[avg_magnetization, other_observable],
None,
noise_scale_precision,
)
],
backend_name=backend_name,
options={"max_execution_time": 300},
)
print(qet_job.job_id)
print(qet_job.status())
8195fa58-f037-4651-8715-36ce1cdc5521
DONE
qet_result = qet_job.result()
print("QET noise-scaling results:")
for pub_idx, pub_result in enumerate(qet_result):
print(f"\nPUB {pub_idx}:")
noisy_results = pub_result.metadata["noisy_results"]
print(f" Unmitigated expectation values: {noisy_results.evs}")
print(f" Unmitigated error bars: {noisy_results.stds}")
print(" Results for each observable:")
for circ_idx, circ_results in enumerate(pub_result.metadata["results"]):
print(f" Circuit {circ_idx}:")
for obs_idx, (obs_array, result_dict) in enumerate(circ_results):
print(f" Observable {obs_idx}: {obs_array}")
noise_scaling = result_dict["noise_scaling"]
print(
f" Scaling method: {noise_scaling['scaling_method']}"
)
print(" Results with Readout mitigation (REM):")
for rem_result in sorted(
(
item
for item in noise_scaling["results_with_REM"]
if item["scale"] != 0.0
),
key=lambda item: item["scale"],
):
print(
f" Scale factor {rem_result['scale']}: {rem_result['value']} ± {rem_result['error_bar']}"
)
QET noise-scaling results:
PUB 0:
Unmitigated expectation values: [0.97822857 0.96171429]
Unmitigated error bars: [0.00123812 0.00672958]
Results for each observable:
Circuit 0:
Observable 0: ObservablesArray({'IIIIZ': 0.2, 'IIIZI': 0.2, 'IIZII': 0.2, 'IZIII': 0.2, 'ZIIII': 0.2}, shape=())
Scaling method: QESEM
Results with Readout mitigation (REM):
Scale factor 0.5: 0.9938730340199383 ± 0.0032116907357568275
Scale factor 0.7: 0.9963976191853445 ± 0.00036300258869586616
Scale factor 1.0: 0.9898115079506586 ± 0.0012525947426560995
Scale factor 1.3: 0.9864667065580341 ± 0.002633221613518526
Scale factor 1.5: 0.9838755527197551 ± 0.002948417797996015
Observable 1: ObservablesArray({'IIIZZ': 1.0, 'ZIIXI': 0.5}, shape=())
Scaling method: QESEM
Results with Readout mitigation (REM):
Scale factor 0.5: 1.0006538544450332 ± 0.002121742014777343
Scale factor 0.7: 1.0004159801523036 ± 0.0021671375357823794
Scale factor 1.0: 0.9898058846339917 ± 0.00690183710903159
Scale factor 1.3: 0.9948946719997267 ± 0.002146532859610311
Scale factor 1.5: 0.9927220368192772 ± 0.0020875057190323882
Dapatkan mesej ralat
Jika status beban kerja anda adalah ERROR, gunakan job.result() untuk mendapatkan mesej ralat seperti berikut:
# Get the result and truncate for readability
result = sample_job.result()
result_str = str(result)
max_length = 500 # Adjust this value as necessary
if len(result_str) > max_length:
truncated = (
result_str[:max_length]
+ f"... (truncated {len(result_str) - max_length} characters)"
)
else:
truncated = result_str
print(truncated)
PrimitiveResult([PubResult(data=DataBin(evs=np.ndarray(<shape=(2,), dtype=float64>), stds=np.ndarray(<shape=(2,), dtype=float64>), shape=(2,)), metadata={'gate_fidelities': {'CZ': 0.9979444718552628, 'ID1Q': 0.9991994239814883}, 'total_shots': 498600, 'mitigation_shots': 223400, 'transpiled_circs': [{'circuit': 'OPENQASM 3.0;\ninclude "stdgates.inc";\nbit[76] c0;\nqubit[76] q0;\nrx(0) q0[54];\nrx(0) q0[59];\nrx(0) q0[75];\nrz(pi/2) q0[54];\nrz(pi/2) q0[59];\nrz(pi/2) q0[75];\nrx(pi/2) q0[54];\nr... (truncated 3771 characters)
Dapatkan sokongan
Pasukan sokongan Qedma sedia membantu! Jika anda menghadapi sebarang isu atau mempunyai soalan tentang penggunaan Fungsi Qiskit QESEM, jangan teragak-agak untuk menghubungi kami. Kakitangan sokongan kami yang berpengetahuan dan mesra bersedia membantu anda dengan sebarang kebimbangan teknikal atau pertanyaan yang anda miliki.
Anda boleh menghantar e-mel kepada kami di support@qedma.com untuk mendapatkan bantuan. Sila sertakan seberapa banyak maklumat tentang isu yang anda alami untuk membantu kami memberikan respons yang cepat dan tepat. Anda juga boleh menghubungi wakil Qedma POC khusus anda melalui e-mel atau telefon.
Untuk membantu kami membantu anda dengan lebih cekap, sila berikan maklumat berikut apabila menghubungi kami:
-
Penerangan terperinci tentang isu tersebut
-
ID kerja
-
Sebarang mesej atau kod ralat yang berkaitan
Kami komited untuk memberikan anda sokongan yang segera dan berkesan untuk memastikan anda mendapat pengalaman terbaik dengan Fungsi Qiskit kami.
Kami sentiasa berusaha untuk meningkatkan produk kami dan kami mengalu-alukan cadangan anda! Jika anda mempunyai idea tentang cara kami boleh meningkatkan perkhidmatan atau ciri yang anda ingin lihat, sila hantar pemikiran anda kepada support@qedma.com.
Langkah seterusnya
-
Lawati rujukan API untuk Fungsi Qiskit ini.
-
Cuba tutorial Simulate 2D tilted-field Ising with the QESEM function.