Hardware

tala

Masao Tokunari and Tamiya Onodera (14 June 2024)

Ang kursong ito ay batay sa isang live na kurso na ibinigay sa University of Tokyo.

Ang lecture pdf ng araling ito ay nahahati sa dalawang bahagi. I-download ang bahagi 1 at i-download ang bahagi 2. Tandaan na maaaring maging deprecated ang ilang code snippet dahil mga static na larawan ang mga ito.

1. Panimula

Tinutuklas ng araling ito ang modernong quantum computing hardware.

Magsisimula tayo sa pag-verify ng ilang bersyon at pag-import ng mga kaugnay na package.

# 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 at Target

Nagbibigay ang Qiskit ng API para makuha ang impormasyon, parehong static at dynamic, tungkol sa isang quantum device. Gumagamit tayo ng Backend instance para makipag-ugnayan sa isang device, na kinabibilangan ng isang Target instance — isang abstract na modelo ng makina na nagbubuod ng mahahalagang katangian tulad ng instruction set architecture (ISA) nito at anumang mga katangian o hadlang na nauugnay dito. Gamitin natin ang mga backend instance na ito para makuha ang ilan sa impormasyong makikita sa pahina ng Compute resources sa IBM Quantum® Platform. Una, gumagawa tayo ng backend instance para sa isang device na gusto natin. Sa sumusunod, pinipili natin ang "ibm_kyoto", "ibm_kawasaki", o ang pinaka-hindi abala na Eagle machine. Maaaring mag-iba ang iyong access sa mga QPU; i-update ang pangalan ng backend ayon sa pagkakataon.

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'

Magsisimula tayo sa ilang pangunahing (static) na impormasyon tungkol sa device.

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 Ehersisyo

Subukan mong makuha ang pangunahing impormasyon tungkol sa isang Heron device, "ibm_strasbourg". Subukan mo ito nang mag-isa, pero may code na idinagdag sa ibaba para masuri mo ang iyong sarili.

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

Iguguhit natin ngayon ang coupling map ng device. Tulad ng makikita, ang mga node ay mga qubit na may numero. Ang mga gilid ay nagpapakita ng mga pares kung saan maaari kang direktang mag-apply ng 2-qubit entangling gate. Ang topology ay tinatawag na "heavy-hex lattice".

# 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. Mga katangian ng qubit

Ang Eagle device ay may 127 na qubit. Kukunin natin ang mga katangian ng ilan sa mga ito.

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)

Kalkulahin natin ang median ng mga T1 time ng mga qubit. Ihambing ang resulta sa ipinapakita para sa device sa 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 Ehersisyo

Kalkulahin ang median ng mga T2 time ng mga qubit. Subukan mo ito nang mag-isa, pero may code na idinagdag sa ibaba para masuri mo ang iyong sarili.

# 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 Mga error ng gate at readout

Lilipat tayo ngayon sa mga gate error. Una, pag-aaralan natin ang istraktura ng data ng target instance. Ito ay isang dictionary na ang mga key ay mga pangalan ng operasyon.

target = backend.target
target.keys()

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

Ang mga value nito ay mga dictionary rin. Tingnan natin ang ilan sa mga item ng value (dictionary) para sa operasyong '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)

Gawin natin ang parehong bagay para sa mga operasyong 'ecr' at '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)

Tulad ng makikita, ang mga error ng readout ay karaniwang mas malaki kaysa sa mga error ng 2-qubit na operasyon, na sa kabuuan ay mas malaki rin kaysa sa 1-qubit na operasyon.

Dahil naiintindihan na natin ang mga istraktura ng data, handa na tayong kalkulahin ang mga median error para sa mga gate na 'sx' at 'ecr'. Muli, ihambing ang mga resulta sa ipinapakita para sa device sa 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. Apendiks

Ang isang sikat na katangian ng Qiskit ay ang kakayahan nito sa visualization. Kabilang dito ang mga circuit visualizer, state at distribution visualizer, at target visualizer. Nagamit mo na ang una at pangalawa sa mga nakaraang Jupyter notebook. Gamitin natin ngayon ang ilang kakayahan ng target visualizer.

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'