Segarkan ciri backend dengan penanda arasan masa-nyata

Anggaran penggunaan: 3 minit pada ibm_kingston (NOTA: Ini hanyalah anggaran. Masa larian anda mungkin berbeza.)

Hasil pembelajaran

Mengapa ciri yang dilaporkan oleh QPU boleh ketinggalan berbanding tingkah laku semasa peranti, dan bila ia berbaloi untuk mengukurnya semula sendiri
Apa yang diukur oleh setiap satu daripada lima eksperimen pencirian standard (bacaan, penanda arasan rawak satu-qubit, penanda arasan rawak dua-qubit berlapis, $T_1$ , dan $T_2$ )
Cara menjalankan suite pencirian penuh dalam satu panggilan atau langkah demi langkah, dan mendapatkan kembali objek backend dengan ciri yang telah disegarkan
Cara membandingkan ciri yang diukur berbanding yang dilaporkan, dan mengapa sesetengah perbezaan mencerminkan metodologi pengukuran dan bukannya hanyutan peranti

Prasyarat

Aliran kerja corak Qiskit
Mod pelaksanaan Qiskit Runtime, khususnya batch mode
Cara meneroka maklumat QPU, seperti ciri backend dan data kalibrasi

Latar belakang

Setiap QPU IBM Quantum® melaporkan satu set ciri yang menerangkan sebaik mana setiap qubitnya berfungsi pada masa ini: masa relaksasi ( $T_1$ ), masa koheren ( $T_2$ ), ralat bacaan, dan ralat get satu- dan dua-qubit. Nombor ini penting dalam praktiknya. Transpiler menggunakannya untuk menentukan qubit fizikal mana yang sepatutnya menjalankan litar anda, teknik mitigasi ralat bergantung padanya, dan anda mungkin menggunakannya untuk menilai sama ada peranti berfungsi cukup baik untuk sesuatu eksperimen.

Ciri yang dilaporkan berasal daripada prosedur kalibrasi yang biasanya dijalankan kira-kira sekali sehari. Qubit superkonduktor, bagaimanapun, boleh hanyut pada skala masa yang lebih pendek, dan kecacatan sementara (dipanggil sistem dua-aras) boleh sementara merosotkan qubit yang kelihatan cemerlang pada masa kalibrasi. Tambahan pula, tugasan sering ditranspilasi jauh sebelum ia benar-benar dilaksanakan, jadi keputusan berdasarkan ciri yang dilaporkan boleh bergantung pada maklumat lapuk. Tutorial Penanda arasan masa-nyata untuk pemilihan qubit menunjukkan sejauh mana ciri ini boleh berubah-ubah dari hari ke hari, dan membina aliran kerja pencirian penuh secara manual daripada Qiskit Experiments individu.

Tutorial ini menunjukkan versi diperkemas aliran kerja tersebut, dengan menggunakan utiliti BackendCharacterization daripada Qiskit Device Benchmarking, yang membungkus pembinaan eksperimen, penghantaran tugasan, dan penyesuaian lengkung ke dalam beberapa panggilan. Anda menghabiskan kira-kira 70 saat masa QPU dan mendapatkan kembali objek backend yang ciri-cirinya mencerminkan peranti pada masa ini, sedia untuk dibandingkan dengan nilai yang dilaporkan atau dihantar ke alat hiliran.

Eksperimen pencirian

Suite ini mengukur lima ciri, setiap satu dengan eksperimen standard:

Ralat bacaan (readout): Setiap qubit disediakan dalam $|0\rangle$ atau $|1\rangle$ dan segera diukur. Kebarangkalian membaca keadaan yang salah memberikan ralat penyediaan keadaan dan pengukuran (SPAM).
Ralat get satu-qubit (rb_1q): Penanda arasan rawak (RB) menjalankan urutan get Clifford satu-qubit rawak yang secara ideal terkompos kepada identiti. Cara kebarangkalian kelangsungan mereput dengan panjang urutan menghasilkan purata ralat setiap get, tidak bergantung pada ralat SPAM.
Ralat get dua-qubit (rb_2q): Idea RB yang sama digunakan pada lapisan penuh get dua-qubit yang tidak bertindih yang dilaksanakan serentak, seperti dalam eksperimen kesetiaan lapisan. Kerana banyak get berjalan sekaligus, kadar ralat yang terhasil termasuk kesan crosstalk dan lebih hampir kepada apa yang dialami sebenarnya oleh litar yang dalam.
$T_1$ (t1): Setiap qubit dieksitasikan dan diukur selepas kelewatan yang meningkat. Peruputan populasi keadaan tereksitasi memberikan masa relaksasi.
$T_2$ (t2): Eksperimen gema Hahn meletakkan setiap qubit dalam superposisi, menggunakan denyut gema di pertengahan kelewatan, dan mengukur seberapa cepat koheren fasa hilang. Secara lalai satu gema digunakan; varian pelbagai-gema (bergaya CPMG) ditunjukkan di penghujung tutorial ini.

Apa yang dilakukan dan tidak dilakukan oleh penyegaran

Ingat tiga perkara ini apabila menggunakan aliran kerja ini:

Ciri yang disegarkan hanya wujud dalam objek backend yang dikembalikan kepada anda. Tiada apa yang berubah pada peranti itu sendiri atau dalam data kalibrasi yang dilaporkan oleh IBM Quantum kepada pengguna lain.
Nilai yang diukur adalah gambaran seketika yang diambil dengan metodologi tertentu. Sebahagian daripadanya, terutamanya ralat dua-qubit berlapis dan nilai $T_2$ gema-tunggal selari, diukur secara berbeza daripada data kalibrasi yang dilaporkan, jadi sebahagian daripada apa jua jurang yang anda perhatikan adalah bersifat metodologi dan bukannya hanyutan. Tutorial ini menunjukkan di mana perkara itu berlaku.
Pencirian itu sendiri memerlukan masa QPU (kira-kira 70 saat untuk suite penuh pada pemproses Heron r2), yang merupakan kos untuk mendapatkan maklumat terkini.

Aliran kerja ini mengikuti empat langkah corak Qiskit:

Langkah 1: Petakan input klasik kepada masalah kuantum. Pilih peranti dan set ciri untuk diukur.
Langkah 2: Optimumkan masalah untuk pelaksanaan perkakasan kuantum. Utiliti ini membina litar eksperimen terus dalam get asli peranti dan menyelarikannya merentas cip.
Langkah 3: Laksanakan menggunakan primitif Qiskit. Eksperimen dijalankan sebagai tugasan Sampler di dalam kelompok.
Langkah 4: Pasca-proses dan kembalikan keputusan dalam format klasik yang dikehendaki. Sesuaikan data pengukuran ke dalam peta ralat setiap-qubit, segarkan backend, dan bandingkan ciri yang diukur berbanding yang dilaporkan.

Keperluan

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

Qiskit SDK v2.0 atau lebih baharu, dengan sokongan visualization
Qiskit Runtime v0.40 atau lebih baharu (pip install qiskit-ibm-runtime)
Qiskit Device Benchmarking, yang juga memasang Qiskit Experiments (pip install git+https://github.com/qiskit-community/qiskit-device-benchmarking.git)

Persediaan

Import pustaka yang diperlukan.

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

_needed = {"numpy": "numpy", "qiskit_device_benchmarking": "git+https://github.com/qiskit-community/qiskit-device-benchmarking.git", "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")

import logging
import sys

import numpy as np
from qiskit_ibm_runtime import Batch, QiskitRuntimeService

from qiskit_device_benchmarking.utilities.characterization_utils import (
    BackendCharacterization,
    plot_characterization_comparison,
)

Suite pencirian membina beberapa eksperimen, menghantar berbilang tugasan, dan memadankan keputusan, yang boleh mengambil masa beberapa minit secara keseluruhan. Aktifkan log tahap INFO supaya setiap peringkat mencetak kemajuannya semasa ia berlaku.

logger = logging.getLogger("qiskit_device_benchmarking")
logger.setLevel(logging.INFO)
logger.addHandler(logging.StreamHandler(stream=sys.stdout))

Contoh simulator berskala kecil

Tutorial ini tidak mengandungi contoh simulator. Aliran kerja ini mengukur kecacatan fizikal sesuatu peranti tertentu: seberapa cepat qubitnya mengendur (relaksasi) dan menyahfasa, dan seberapa kerap gate serta bacaannya gagal. Simulator ideal tidak mempunyai sebarang kecacatan ini, jadi tiada apa untuk dicirikan. Anda boleh melampirkan model hingar sintetik kepada backend palsu, tetapi eksperimen kemudiannya hanya akan memulihkan nombor yang anda sendiri masukkan. Atas sebab itu, kami terus ke perkakasan, dipecahkan kepada empat langkah corak Qiskit.

Contoh perkakasan berskala besar

Langkah 1: Memetakan input klasik kepada masalah kuantum

Dalam aliran kerja ini, "masalah" ialah peranti itu sendiri: input klasik ialah QPU yang anda mahu cirikan dan senarai sifat yang hendak diukur, dan eksperimen kuantum ialah litar pencirian yang dijana daripadanya.

Pertama, pilih backend. Tutorial ini menggunakan ibm_kingston, sebuah pemproses Heron r2 156-qubit; anda boleh menggantikannya dengan mana-mana peranti IBM Quantum yang anda ada akses (atau pilih satu dengan service.least_busy()).

service = QiskitRuntimeService()
device = "ibm_kingston"
backend = service.backend(device)

Seterusnya, pilih sifat mana yang hendak diukur. Anda boleh menghantar mana-mana subset eksperimen berikut:

readout: eksperimen SPAM (penyediaan dan pengukuran keadaan)
rb_1q: penanda aras rawak satu-qubit terasing
rb_2q: penanda aras rawak dua-qubit serentak daripada eksperimen kesetiaan lapisan
t2: eksperimen gema Hahn $T_2$ (satu gema secara lalai)
t1: eksperimen relaksasi $T_1$

Jalankan suite penuh untuk mendapatkan gambaran lengkap peranti; buang entri daripada senarai jika anda hanya mengambil berat tentang sesetengah sifat dan mahu menjimatkan masa QPU.

experiments = ["readout", "rb_1q", "rb_2q", "t1", "t2"]

Langkah 2: Mengoptimumkan masalah untuk pelaksanaan perkakasan kuantum

Dalam kebanyakan tutorial, di sinilah anda akan mentranspil litar anda. Di sini, BackendCharacterization menguruskan itu secara dalaman. Ia membina litar eksperimen terus dalam gate asli peranti, menjalankan eksperimen satu-qubit pada semua qubit secara selari, dan menjadualkan penanda aras dua-qubit merentasi lapisan berasingan peta gandingan supaya keseluruhan peranti diliputi dengan beberapa job sahaja. Disebabkan penyelarian ini, keseluruhan suite hanya mengambil kira-kira 70 saat masa QPU.

Mulakan kelas yang menguruskan aliran kerja:

# Initialize the class used to run the experiments
characterizer = BackendCharacterization(backend)

Langkah 3: Melaksanakan menggunakan primitif Qiskit

Kaedah run_experiments membina litar dan menghantarnya sebagai job Sampler. Jalankan ia di dalam konteks Batch supaya job dijadualkan bersama pada QPU, dan kaedah tersebut kembali sebaik sahaja semua job telah dihantar. (Anda juga boleh menjalankannya di luar batch, atau di dalam Session.)

nota

Anda mungkin melihat amaran tentang backend dihantar semasa pengurus konteks sesi dibuka. Ini dijangka dan boleh diabaikan dengan selamat.

# Run the characterization experiments inside a Batch
with Batch(backend=backend):
    jobs = characterizer.run_experiments(experiments=experiments)

base_primitive.get_mode_service_backend:WARNING:2026-07-14 14:23:02,051: A backend was passed in as the mode but a session context manager is open so this job will run inside this session/batch instead of in job mode.

Building readout experiments
Building 1Q RB experiments
Building 2Q RB experiments
Building T1 experiments
Building T2 experiments
Layered two-qubit RB submitted: ['d9b7tfu6hjac73ffba2g', 'd9b7tjug26ic73dfju3g', 'd9b7u3u6hjac73ffban0', 'd9b7u7rv6alc73csmicg']
Readout job submitted: d9b7u8bv6alc73csmidg
T1 experiment submitted: ['d9b7u8ug26ic73dfjuqg']
T2 (Hahn) experiment submitted: ['d9b7u9fu62qs738othg0']
Single-qubit RB submitted: ['d9b7v8m6hjac73ffbc40', 'd9b7veeg26ic73dfk040']

Kaedah ini mengembalikan job yang dihantar sebagai kamus yang dikunci mengikut eksperimen, yang berguna untuk menjejak mereka pada papan pemuka IBM Quantum Platform atau untuk debugging.

# Print all the job IDs for debugging purposes
jobs

{'rb_2q': [<RuntimeJobV2('d9b7tfu6hjac73ffba2g', 'sampler')>,
  <RuntimeJobV2('d9b7tjug26ic73dfju3g', 'sampler')>,
  <RuntimeJobV2('d9b7u3u6hjac73ffban0', 'sampler')>,
  <RuntimeJobV2('d9b7u7rv6alc73csmicg', 'sampler')>],
 'readout': [<RuntimeJobV2('d9b7u8bv6alc73csmidg', 'sampler')>],
 't1': [<RuntimeJobV2('d9b7u8ug26ic73dfjuqg', 'sampler')>],
 't2': [<RuntimeJobV2('d9b7u9fu62qs738othg0', 'sampler')>],
 'rb_1q': [<RuntimeJobV2('d9b7v8m6hjac73ffbc40', 'sampler')>,
  <RuntimeJobV2('d9b7veeg26ic73dfk040', 'sampler')>]}

Langkah 4: Memproses pasca dan mengembalikan keputusan dalam format klasik yang dikehendaki

Analisis keputusan

Kaedah analyze_results menunggu job selesai dan memadankan data pengukuran: reputan eksponen untuk $T_1$ dan $T_2$ , reputan kebarangkalian kemandirian untuk eksperimen RB, dan matriks penugasan untuk bacaan. Ia mengembalikan kamus peta ralat, satu entri bagi setiap sifat yang diukur, setiap satu memetakan qubit (atau pasangan qubit) kepada nilai terukurnya.

error_maps = characterizer.analyze_results()

print(f"The following error maps are available: {list(error_maps.keys())}")
readout_q0 = error_maps["readout_error"][0]
print(f"For example, readout error for qubit 0 is {readout_q0}")

The following error maps are available: ['readout_error', 'oneq_error_x', 'oneq_error_sx', 'lf_error_map', 't1_map', 't2_map']
For example, readout error for qubit 0 is 0.007600000000000051

Peta tersebut meliputi ralat bacaan, ralat gate x dan sx satu-qubit, ralat dua-qubit berlapis (lf_error_map, daripada eksperimen kesetiaan lapisan), dan masa $T_1$ dan $T_2$ dalam saat.

Kemas kini sifat backend

Kaedah update_backend menulis nilai terukur ke dalam sifat salinan backend dan mengembalikannya. Objek backend asal mengekalkan data penentukuran yang dilaporkan, supaya kita dapat membandingkan kedua-duanya, seperti yang ditunjukkan di bawah. Ingat bahawa kemas kini ini adalah semata-mata setempat kepada sesi Python anda; ia tidak mengubah apa-apa pada peranti atau untuk pengguna lain.

backend_updated = characterizer.update_backend()

Updating readout error
Updating single-qubit X error
Updating single-qubit SX error
Updating two-qubit error
Updating T1
Updating T2

Bandingkan sifat terukur berbanding yang dilaporkan

Akhir sekali, plotkan sifat masa nyata yang diukur berbanding nilai yang dilaporkan oleh backend. Dalam setiap panel, qubit (atau pasangan qubit) disusun mengikut nilai terukur, jadi lengkung terukur adalah licin secara pembinaan dan serakan nilai yang dilaporkan di sekelilingnya menunjukkan di mana kedua-duanya tidak bersetuju. Satu plot ditunjukkan untuk RB satu-qubit kerana ralat terukur yang sama bagi setiap gate diberikan kepada kedua-dua gate x dan sx. Had paksi dipilih daripada bahagian utama data supaya beberapa titik ekstrem tidak memampatkan plot; sebarang titik di luar julat dikira dalam anotasi pada plot (atau laluk ylim untuk mengatasi had tersebut).

plot_characterization_comparison(
    old_props=backend.properties().to_dict(),
    new_props=backend_updated.properties().to_dict(),
    plots=["readout", "rb_1q", "rb_2q", "t1", "t2"],
)

Output of the previous code cell

Plot ini memerlukan pembacaan yang teliti, kerana bukan setiap jurang antara kedua-dua lengkung bermakna peranti telah hanyut:

Ralat bacaan dan satu-qubit: Nilai terukur mengikuti nilai yang dilaporkan bagi kebanyakan qubit, manakala nilai yang dilaporkan untuk segelintir qubit jauh terpesong daripada lengkung terukur. Ketidaksepakatan yang setempat itulah hanyutan yang direka untuk ditangkap oleh aliran kerja ini.
$T_1$ : Kedua-dua set data berserak di sekeliling satu sama lain tanpa ofset sistematik, yang konsisten dengan $T_1$ turun naik secara semula jadi dari semasa ke semasa.
Ralat dua-qubit: Nilai terukur duduk secara sistematik lebih tinggi daripada nilai yang dilaporkan. Ini dijangka kerana nilai yang dilaporkan diukur pada gate terasing, manakala eksperimen kesetiaan lapisan menjalankan banyak gate secara serentak dan oleh itu merangkumi crosstalk. Nombor berlapis lebih relevan untuk litar yang mendalam, tetapi ia tidak boleh dibandingkan secara langsung dengan data penentukuran yang dilaporkan.
$T_2$ : Nilai terukur duduk jauh lebih rendah daripada nilai yang dilaporkan bagi kebanyakan qubit. Sekali lagi, metodologi memainkan peranan besar, seperti yang diteliti dalam bahagian seterusnya.

Periksa keputusan eksperimen individu

Anda juga boleh memeriksa keputusan mentah eksperimen pencirian individu melalui sifat experiment_data, yang mengembalikan objek ExperimentData Qiskit Experiments yang mendasarinya. Sebagai contoh, yang berikut memaparkan lengkung reputan $T_1$ terukur bagi satu qubit, yang berguna untuk menyemak kualiti padanan sebelum mempercayai nombor yang dihasilkannya.

t1_data = characterizer.experiment_data["t1"]

# Each qubit has its own fit figure
n_figs = len(t1_data.figure_names)
print(f"{n_figs} figures available, e.g. {t1_data.figure_names[0]}")

# Show the T1 decay curve of the first qubit
t1_data.figure(0)

156 figures available, e.g. T1_Q0_c78ef792.svg

Output of the previous code cell

Ukur T2 dengan jujukan denyut penyahgandingan dinamik

Secara lalai, eksperimen $T_2$ menggunakan satu gema Hahn dan mengukur semua qubit secara selari, yang, seperti yang ditunjukkan oleh plot perbandingan di atas, boleh menghasilkan nilai $T_2$ yang jauh lebih rendah daripada yang dilaporkan oleh backend. Satu hipotesis ialah bilangan gema: nilai yang dilaporkan mungkin ditentukur dengan penyahgandingan dinamik, yang menekan hingar frekuensi rendah. Untuk menguji ini, jalankan pencirian $T_2$ sahaja dengan t2_num_echoes ditetapkan kepada nilai yang lebih besar, yang menggunakan jujukan denyut gema bergaya CPMG. Kelewatan mewakili jumlah masa evolusi bebas dalam kedua-dua kes, jadi nilai $T_2$ yang dipadankan boleh dibandingkan secara langsung dengan keputusan gema tunggal.

# Run a T2-only characterization using a CPMG-style train of 8 echoes
characterizer_dd = BackendCharacterization(backend)
backend_updated_dd = characterizer_dd.run_and_update(
    experiments=["t2"], t2_num_echoes=8
)

Building T2 experiments
T2 (Hahn) experiment submitted: ['d9b96s6g26ic73dflcn0']
Updating T2

# Compare the multi-echo T2 against the backend-reported values
plot_characterization_comparison(
    old_props=backend.properties().to_dict(),
    new_props=backend_updated_dd.properties().to_dict(),
    plots=["t2"],
    title_prefix="8-echo CPMG",
)

# Compare medians across the reported values, the single-echo run,
# and the 8-echo run
reported_t2s = [
    prop["value"]
    for qubit in backend.properties().to_dict()["qubits"]
    for prop in qubit
    if prop["name"] == "T2"
]
t2_reported = np.median(reported_t2s)
t2_single = np.median(list(error_maps["t2_map"].values())) * 1e6
t2_dd = (
    np.median(list(characterizer_dd.analyze_results()["t2_map"].values()))
    * 1e6
)
print(
    f"Median T2 — reported: {t2_reported:.0f} us | "
    f"single echo: {t2_single:.0f} us | 8-echo CPMG: {t2_dd:.0f} us"
)

Output of the previous code cell

Median T2 — reported: 142 us | single echo: 53 us | 8-echo CPMG: 56 us

Dalam larian ini, gema tambahan hampir tidak mengubah keputusan: median 8-gema (56 µs) hampir dengan yang gema tunggal (53 µs), dan kedua-duanya kekal jauh lebih rendah daripada median yang dilaporkan (142 µs). Bilangan gema sahaja tidak menjelaskan jurang ini; perbezaan metodologi lain terlibat, seperti perincian prosedur penentukuran, mengukur semua qubit secara selari dan bukannya secara terasing, dan sebagainya.

Pengajaran praktikal ialah untuk mengendalikan perbandingan $T_2$ (dan ralat dua-qubit berlapis) merentasi metodologi dengan berhati-hati. Nilai yang disegarkan ialah gambaran konsisten-diri yang diambil di bawah keadaan yang hampir dengan beban kerja sebenar, yang menjadikannya sesuai untuk membandingkan qubit antara satu sama lain atau menjejak peranti dari semasa ke semasa. Namun, jurang berbanding data penentukuran yang dilaporkan bukanlah secara automatik bukti hanyutan.

Langkah 1–4 dimampatkan kepada satu panggilan sahaja

Untuk kegunaan harian, anda jarang memerlukan keputusan pertengahan. Kaedah run_and_update merantai segala yang anda lakukan di atas (membina, menghantar, memadankan, dan mengemas kini) ke dalam satu panggilan sahaja yang mengembalikan backend yang disegarkan. Ia menerima senarai experiments yang sama (dan meneruskan pilihan seperti t2_num_echoes), dan boleh juga dibalut dalam konteks Batch atau Session.

nota

Sel berikut tidak akan kembali sehingga semua pekerjaan dan pemprosesan pasca selesai.

# Initialize a fresh characterizer
characterizer = BackendCharacterization(backend)

# Run all of the experiments and update the backend in a single call
backend_updated = characterizer.run_and_update(experiments=experiments)

Building readout experiments
Building 1Q RB experiments
Building 2Q RB experiments
Building T1 experiments
Building T2 experiments
Layered two-qubit RB submitted: ['d9b7oqnu62qs738otat0', 'd9b7p76g26ic73dfjolg', 'd9b7pnm6hjac73ffb57g', 'd9b7q4fu62qs738otce0']
Readout job submitted: d9b7q4mg26ic73dfjprg
T1 experiment submitted: ['d9b7q57u62qs738otcfg']
T2 (Hahn) experiment submitted: ['d9b7q5m6hjac73ffb5pg']
Single-qubit RB submitted: ['d9b7r4e6hjac73ffb71g', 'd9b7reu6hjac73ffb7d0']
Updating readout error
Updating single-qubit X error
Updating single-qubit SX error
Updating two-qubit error
Updating T1
Updating T2

Objek backend_updated yang disegarkan kini sedia digunakan di mana-mana sifat backend menyumbang kepada aliran kerja anda. Cuba proses ini bersama-sama dengan tutorial Penanda aras masa nyata untuk pemilihan qubit untuk memilih qubit berprestasi terbaik semasa mentranspil litar. Oleh kerana peranti terus hanyut, segarkan sifat berhampiran dengan masa anda sebenarnya melaksanakan beban kerja anda.

Langkah seterusnya

Jika anda mendapati kerja ini menarik, anda mungkin berminat dengan bahan berikut:

Cadangan

Gunakan sifat yang disegarkan untuk memilih qubit yang lebih baik dalam tutorial Penanda aras masa nyata untuk pemilihan qubit
Ketahui bagaimana data penentukuran yang dilaporkan didedahkan dalam panduan Maklumat QPU
Terokai eksperimen pencirian individu dalam dokumentasi Qiskit Experiments
Layari lagi penanda aras peringkat peranti dalam repositori Qiskit Device Benchmarking

Hasil pembelajaran​

Prasyarat​

Latar belakang​

Eksperimen pencirian​

Apa yang dilakukan dan tidak dilakukan oleh penyegaran​

Keperluan​

Persediaan​

Contoh simulator berskala kecil​

Contoh perkakasan berskala besar​

Langkah 1: Memetakan input klasik kepada masalah kuantum​

Langkah 2: Mengoptimumkan masalah untuk pelaksanaan perkakasan kuantum​

Langkah 3: Melaksanakan menggunakan primitif Qiskit​

Langkah 4: Memproses pasca dan mengembalikan keputusan dalam format klasik yang dikehendaki​

Analisis keputusan​

Kemas kini sifat backend​

Bandingkan sifat terukur berbanding yang dilaporkan​

Periksa keputusan eksperimen individu​

Ukur T2 dengan jujukan denyut penyahgandingan dinamik​

Langkah 1–4 dimampatkan kepada satu panggilan sahaja​

Langkah seterusnya​

Hasil pembelajaran

Prasyarat

Latar belakang

Eksperimen pencirian

Apa yang dilakukan dan tidak dilakukan oleh penyegaran

Keperluan

Persediaan

Contoh simulator berskala kecil

Contoh perkakasan berskala besar

Langkah 1: Memetakan input klasik kepada masalah kuantum

Langkah 2: Mengoptimumkan masalah untuk pelaksanaan perkakasan kuantum

Langkah 3: Melaksanakan menggunakan primitif Qiskit

Langkah 4: Memproses pasca dan mengembalikan keputusan dalam format klasik yang dikehendaki

Analisis keputusan

Kemas kini sifat backend

Bandingkan sifat terukur berbanding yang dilaporkan

Periksa keputusan eksperimen individu

Ukur T2 dengan jujukan denyut penyahgandingan dinamik

Langkah 1–4 dimampatkan kepada satu panggilan sahaja

Langkah seterusnya