Perangkat Keras

catatan

Masao Tokunari dan Tamiya Onodera (14 Juni 2024)

Kursus ini didasarkan pada kursus langsung yang disampaikan di Universitas Tokyo.

PDF kuliah pelajaran ini dibagi menjadi dua bagian. Unduh bagian 1 dan unduh bagian 2. Perlu dicatat bahwa beberapa cuplikan kode mungkin menjadi usang karena ini adalah gambar statis.

1. Pendahuluan

Pelajaran ini mengeksplorasi perangkat keras komputasi kuantum modern.

Kita akan mulai dengan memverifikasi beberapa versi dan mengimpor beberapa paket yang relevan.

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

import statistics

from qiskit_ibm_runtime import QiskitRuntimeService

2. Backend dan Target

Qiskit menyediakan API untuk mendapatkan informasi, baik statis maupun dinamis, tentang perangkat kuantum. Kita menggunakan instance Backend untuk berinteraksi dengan perangkat, yang mencakup instance Target, sebuah model mesin abstrak yang merangkum fitur-fitur penting seperti instruction set architecture (ISA)-nya dan properti atau batasan apa pun yang terkait dengannya. Mari gunakan instance Backend ini untuk mendapatkan beberapa informasi yang kamu lihat di halaman Compute resources di IBM Quantum® Platform. Pertama, kita buat instance Backend untuk perangkat yang diinginkan. Berikut, kita memilih "ibm_kyoto", "ibm_kawasaki" atau mesin Eagle yang paling tidak sibuk. Aksesmu ke QPU mungkin berbeda; perbarui nama Backend sesuai kebutuhan.

service = QiskitRuntimeService()
# backend = service.backend("ibm_kawasaki") # an Eagle, if you have access to ibm_kawasaki
backend = service.least_busy(
    operational=True, simulator=False, min_num_qubits=127
)  # Eagle
backend.name

'ibm_strasbourg'

Kita mulai dengan beberapa informasi dasar (statis) tentang perangkat.

print(
    f"""
{backend.name}, {backend.num_qubits} qubits
processor type = {backend.processor_type}
basis gates = {backend.basis_gates}
"""
)

ibm_strasbourg, 127 qubits
processor type = {'family': 'Eagle', 'revision': 3}
basis gates = ['ecr', 'id', 'rz', 'sx', 'x']

2.1 Latihan

Coba dapatkan informasi dasar tentang perangkat Heron, "ibm_strasbourg". Coba sendiri dulu, tetapi kode telah ditambahkan di bawah agar kamu bisa memeriksanya sendiri.

a_heron = service.backend("ibm_strasbourg")  # a Heron

# your code here
print(
    f"""
{backend.name}, {a_heron.num_qubits} qubits
processor type = {a_heron.processor_type}
basis gates = {a_heron.basis_gates}
"""
)

ibm_strasbourg, 133 qubits
processor type = {'family': 'Heron', 'revision': '1'}
basis gates = ['cz', 'id', 'rz', 'sx', 'x']

2.2 Coupling map

Kita sekarang menggambar coupling map dari perangkat. Seperti yang bisa kamu lihat, node adalah Qubit yang dinomori. Edge menunjukkan pasangan yang padanya kamu bisa langsung menerapkan Gate entangling 2-Qubit. Topologinya disebut "kisi heavy-hex".

# This function requires that Graphviz is installed. If you need to install Graphviz you can refer to:
# https://graphviz.org/download/#executable-packages for instructions.
try:
    fig = backend.coupling_map.draw()
except RuntimeError as ex:
    print(ex)
fig

3. Properti Qubit

Perangkat Eagle memiliki 127 Qubit. Mari dapatkan properti beberapa di antaranya.

for qn in range(backend.num_qubits):
    if qn >= 5:
        break
    print(f"{qn}: {backend.qubit_properties(qn)}")

0: QubitProperties(t1=0.000183686508736532, t2=0.00023613944465408068, frequency=4832100227.116953)
1: QubitProperties(t1=0.00048794378526038294, t2=9.007098375327869e-05, frequency=4736264354.075363)
2: QubitProperties(t1=0.00021247781834456527, t2=7.81037910324034e-05, frequency=4859349851.150393)
3: QubitProperties(t1=0.0002936462084765663, t2=0.00011400214529510604, frequency=4679749549.503852)
4: QubitProperties(t1=0.00044229440258559125, t2=0.0003181648356339447, frequency=4845872064.050596)

Mari hitung median waktu T1 dari Qubit. Bandingkan hasilnya dengan yang ditampilkan untuk perangkat di IBM Quantum Platform.

t1s = [backend.qubit_properties(qq).t1 for qq in range(backend.num_qubits)]
f"Median T1: {(statistics.median(t1s)*10**6):.2f} \u03bcs"

'Median T1: 285.43 μs'

3.1 Latihan

Silakan hitung median waktu T2 dari Qubit. Coba sendiri dulu, tetapi kode telah ditambahkan di bawah agar kamu bisa memeriksanya sendiri.

# Your code here

t2s = [backend.qubit_properties(qq).t2 for qq in range(backend.num_qubits)]
f"Median T2: {(statistics.median(t2s)*10**6):.2f} \u03bcs"

'Median T2: 173.10 μs'

3.2 Error Gate dan readout

Kita sekarang beralih ke error Gate. Pertama, kita pelajari struktur data dari instance target. Ini adalah kamus yang kuncinya adalah nama operasi.

target = backend.target
target.keys()

dict_keys(['measure', 'id', 'sx', 'delay', 'x', 'for_loop', 'rz', 'if_else', 'ecr', 'reset', 'switch_case'])

Nilainya juga berupa kamus. Mari lihat beberapa item dari nilai (kamus) untuk operasi 'sx'.

for i, qq in enumerate(target["sx"]):
    if i >= 5:
        break
    print(i, qq, target["sx"][qq])

0 (0,) InstructionProperties(duration=6e-08, error=0.0007401311759115297)
1 (1,) InstructionProperties(duration=6e-08, error=0.0003163759907528654)
2 (2,) InstructionProperties(duration=6e-08, error=0.0003183859004638003)
3 (3,) InstructionProperties(duration=6e-08, error=0.00042235914178831863)
4 (4,) InstructionProperties(duration=6e-08, error=0.011163151923589715)

Mari lakukan hal yang sama untuk operasi 'ecr' dan 'measure'.

for i, edge in enumerate(target["ecr"]):
    if i >= 5:
        break
    print(i, edge, target["ecr"][edge])

0 (0, 14) InstructionProperties(duration=6.6e-07, error=0.01486295709788732)
1 (1, 0) InstructionProperties(duration=6.6e-07, error=0.015201590794522601)
2 (2, 1) InstructionProperties(duration=6.6e-07, error=0.00697838102630724)
3 (2, 3) InstructionProperties(duration=6.6e-07, error=0.008075067943986797)
4 (3, 4) InstructionProperties(duration=6.6e-07, error=0.0630164507876913)

for i, qq in enumerate(target["measure"]):
    if i >= 5:
        break
    print(i, qq, target["measure"][qq])

0 (0,) InstructionProperties(duration=1.6e-06, error=0.0078125)
1 (1,) InstructionProperties(duration=1.6e-06, error=0.155029296875)
2 (2,) InstructionProperties(duration=1.6e-06, error=0.057373046875)
3 (3,) InstructionProperties(duration=1.6e-06, error=0.02880859375)
4 (4,) InstructionProperties(duration=1.6e-06, error=0.01318359375)

Seperti yang bisa kamu lihat, error readout cenderung lebih besar dari operasi 2-Qubit, yang pada gilirannya cenderung lebih besar dari operasi 1-Qubit.

Setelah memahami struktur data, kita siap untuk menghitung error median untuk Gate 'sx' dan 'ecr'. Sekali lagi, bandingkan hasilnya dengan yang ditampilkan untuk perangkat di IBM Quantum Platform.

sx_errors = [inst_prop.error for inst_prop in target["sx"].values()]
f"Median SX error: {(statistics.median(sx_errors)):.3e}"

'Median SX error: 2.277e-04'

ecr_errors = [inst_prop.error for inst_prop in target["ecr"].values()]
f"Median ECR error: {(statistics.median(ecr_errors)):.3e}"

'Median ECR error: 6.895e-03'

4. Lampiran

Fitur populer dari Qiskit adalah kemampuan visualisasinya. Ini mencakup visualisasi Circuit, state dan distribusi, serta visualisasi target. Kamu sudah menggunakan dua yang pertama di notebook jupyter sebelumnya. Mari gunakan beberapa kemampuan dari visualisasi target.

from qiskit.visualization import plot_gate_map

plot_gate_map(backend, font_size=14)

from qiskit.visualization import plot_error_map

plot_error_map(backend)

# Check Qiskit version
import qiskit

qiskit.__version__

'2.0.2'