Tingnan ang mga detalye ng backend

Package versions

The code on this page was developed using the following requirements. We recommend using these versions or newer.

qiskit-ibm-runtime~=0.46.1

Ipinapaliwanag ng pahinang ito kung paano mahanap ang impormasyon tungkol sa iyong mga available na backend.

Ilista o i-filter ang mga backend

Ilista ang mga backend na available sa iyo

Maaari kang gumamit ng Qiskit o IBM Quantum Platform para makita ang listahan ng mga backend na available sa iyo, o para maghanap ng isang partikular na backend.

Mga pangalan ng QPU

Ang mga QPU na naka-host sa IBM Cloud® ay may mga pangalang nagsisimula sa ibm_*. Lahat ng QPU ay pinangalanan ayon sa isang lungsod - halimbawa, ibm_kingston. Hindi ipinapakita ng pangalang ito kung saan talaga naka-host ang QPU.

View backends with Qiskit

Gamitin ang pamamaraan ng QiskitRuntimeService.backends(), gaya ng ipinapakita sa susunod na code block. Nagbabalik ang pamamaraang ito ng listahan ng mga instance ng IBMBackend.

Para patakbuhin ang sumusunod na code, tiyaking napatunayan mo na ang serbisyo. Tingnan ang I-set up ang iyong IBM Cloud account para sa karagdagang detalye.

Para maghanap ng isang partikular na backend, gamitin ang pamamaraan ng QiskitRuntimeService.backend() (pansinin na ito ay singular: backend), na tumatanggap ng pangalan ng backend bilang input parameter at nagbabalik ng instance ng IBMBackend na kumakatawan sa partikular na backend na iyon:

View backends on IBM Quantum Platform

Para makita ang mga backend na maa-access mo, pumunta sa listahan ng mga backend sa pahina ng Compute resources (pansinin na ang iyong napiling rehiyon ay maaaring makaapekto sa mga QPU na nakalista). I-click ang filter icon at piliin ang "All my instances" o isang partikular na pangalan ng instance para makita ang mga available na QPU.

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

# Initialize your account
from qiskit_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService()

service.backends()

[<IBMBackend('ibm_boston')>,
 <IBMBackend('ibm_pittsburgh')>,
 <IBMBackend('ibm_fez')>,
 <IBMBackend('ibm_marrakesh')>,
 <IBMBackend('ibm_kingston')>,
 <IBMBackend('ibm_miami')>]

service.backend("ibm_fez")

<IBMBackend('ibm_fez')>

# Optionally pass in an instance, region, or both, to
# further filter the backends.
service = QiskitRuntimeService()

service.backends(simulator=False, operational=True, min_num_qubits=100)

[<IBMBackend('ibm_boston')>,
 <IBMBackend('ibm_pittsburgh')>,
 <IBMBackend('ibm_fez')>,
 <IBMBackend('ibm_marrakesh')>,
 <IBMBackend('ibm_kingston')>,
 <IBMBackend('ibm_miami')>]

tala

Kung naka-log in ka sa isang partikular na instance o rehiyon, o kung ini-initialize mo ang serbisyo gamit ang isang partikular na instance o rehiyon sa pamamagitan ng QiskitRuntimeService(), ang mga backend na available lamang sa iyo sa instance o rehiyong iyon ang ibabalik.

I-filter ang mga backend

Filter by properties with Qiskit

Maaari mong i-filter ang mga available na backend ayon sa kanilang configuration o status. Para sa mas pangkalahatang mga filter, itakda ang argument na filters sa isang function na tumatanggap ng backend object at nagbabalik ng True kung natutugunan nito ang iyong mga pamantayan. Sumangguni sa dokumentasyon ng API para sa karagdagang detalye.

Ang sumusunod na code ay nagbabalik lamang ng mga backend na nakakatugon sa mga pamantayang ito at available sa iyo sa iyong kasalukuyang napiling instance:

• Tunay na quantum device ang mga ito (simulator=False)
• Kasalukuyang operational (operational=True)
• May kahit isang daang qubit (min_num_qubits=100)

Isang katulad na pamamaraan ay ang QiskitRuntimeService.least_busy(), na tumatanggap ng parehong mga filter tulad ng backends() ngunit nagbabalik ng backend na nakakatugon sa mga filter at may pinakakaunting bilang ng mga job na nakabinbin sa queue:

Filter by properties on IBM Quantum Platform

Para makita ang mga backend na maa-access mo, tingnan ang talahanayan sa pahina ng Compute resources. I-click ang filter icon para makita ang mga opsyon ng filter. Maaari kang mag-filter ayon sa uri ng processor at status. Pansinin din na maaari mong ayusin ang talahanayan ayon sa anumang column sa pamamagitan ng pag-hover sa pamagat ng column, at pagkatapos ay pag-click sa mga arrow na lalabas.

service.least_busy(operational=True, min_num_qubits=100)

<IBMBackend('ibm_fez')>

Static na impormasyon ng backend

Ang ilang impormasyon tungkol sa isang backend ay hindi regular na nagbabago, tulad ng pangalan nito, bersyon, bilang ng mga qubit nito, uri ng processor nito (ang pangalan ng bird family, na nagpapahiwatig ng topology at tinatayang bilang ng qubit), at ang mga uri ng feature na sinusuportahan nito. Ang impormasyong ito ay available bilang mga katangian ng backend object. Para sa buong listahan ng mga katangian, tingnan ang dokumentasyon ng IBMBackend API. Hanapin ang karagdagang impormasyon sa versioning sa seksyong QPU versioning sa ibaba.

Ang rehiyon ng isang backend (ang lokasyon ng data center kung saan iho-host at ipoproseso ang iyong data at mga eksperimento) ay nakalista sa detalyadong information card nito sa pahina ng Compute resources sa IBM Quantum Platform.

View backend information with Qiskit

View backend information on IBM Quantum Platform

Pumunta sa pahina ng Compute resources para makita ang talahanayan ng lahat ng QPU, pagkatapos ay i-click ang pangalan ng anumang QPU para buksan ang detalyadong information card nito. Hanapin ang impormasyon ng backend sa ilalim ng seksyong Details ng card.

backend = service.backend("ibm_fez")

print(
    f"Name: {backend.name}\n"
    f"Version: {backend.backend_version}\n"
    f"No. of qubits: {backend.num_qubits}\n"
    f"Processor type: {backend.processor_type}\n"
)

Name: ibm_fez
Version: 1.3.37
No. of qubits: 156
Processor type: {'family': 'Heron', 'revision': '2'}

QPU versioning

Bawat QPU ay may version number sa anyo ng X.Y.Z (major.minor.revision). Ang isang Circuit na na-compile para sa isang partikular na version number ay garantisadong tatakbo sa QPU na iyon. Kung magbago ang revision number, magpapatuloy na tatakbo ang Circuit. Kung magbago ang major o minor number, hindi garantisadong tatakbo ang Circuit, bagaman posible pa rin.

Mag-i-increment ang revision version number para sa mga pag-aayos na hindi nagpapasira sa umiiral na compiled Circuit.

Ang code example kanina sa seksyong ito ay nagpapakita kung paano mahanap ang bersyon ng isang backend. Sa IBM Quantum Platform, maaari mong makita ang bersyon sa detalyadong information card ng isang QPU (i-click ang pangalan ng QPU sa talahanayan ng Compute resources para buksan ang card).

Nakalista sa sumusunod na talahanayan ang mga kondisyon kung saan maaaring magbago ang bersyon o revision number.

Major version	Minor version	Revision version
Mga pagbabago sa sample	Mga ikot ng warmup / cool-down	Mga software update ng QPU
Malalaking pagbabago sa control electronics	Pagpapalit ng ilang electronics, kung malaki ang epekto ng kapalit sa operasyon	Mga mano-manong kalibrasyon para mapabuti ang mga fidelity
Paglipat ng QPU sa bagong lokasyon, kung may malalaking pagbabago sa gawi ang resulta	Pag-alis ng isang Gate sa loob ng ilang panahon dahil sa mga isyu sa kalibrasyon, at hindi madaling gawin ang mga koreksyon sa software	Maliliit na pagbabago sa electronics na hindi nakakaapekto sa operasyon
	Pagbabago ng direksyon ng CNOT gate

Mga sinusuportahang instruksyon

Natively na sinusuportahan ng bawat pamilya ng processor ang limitadong hanay ng mga instruksyon. Kasama sa hanay na ito ang mga single- at two-qubit gate, pati na rin ang mga non-unitary na operasyon tulad ng measure at reset. Bawat Gate sa Circuit ay dapat isalin (ng transpiler) sa mga elemento ng sinusuportahang instruction set ng isang QPU bago ito mapatakbo sa QPU.

Maaari mong makita ang mga sinusuportahang instruction set para sa isang QPU gamit ang Qiskit. Ang pahina ng Compute resources ng IBM Quantum Platform ay naglilista lamang ng mga sinusuportahang unitary gate (basis gates) para sa isang QPU.

Find supported instructions with Qiskit

Find basis gates on IBM Quantum Platform

Pumunta sa pahina ng Compute resources para makita ang talahanayan ng lahat ng QPU, pagkatapos ay i-click ang pangalan ng anumang QPU para buksan ang detalyadong information card nito. Ang mga basis gate para sa QPU na iyon ay nakalista sa seksyong Details.

Talahanayan ng mga sinusuportahang instruksyon

Kategorya ng operasyon	Pangalan
Single-qubit gates	RZ, SX, X, ID, delay
Two-qubit gates	CZ, ECR
Fractional gates	RX (single-qubit), RZZ (two-qubit)
Non-unitary instructions	measure, reset, measure_*, delay
Control flow	if_else (classical feedforward)

from qiskit_ibm_runtime import QiskitRuntimeService

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

print(f"Backend: {backend.name}")
print(f"    Processor type: {backend.processor_type}")
print(f"    Supported instructions: {backend.supported_instructions}")

Backend: ibm_kingston

Processor type: {'family': 'Heron', 'revision': '2'}
    Supported instructions: ['cz', 'id', 'delay', 'measure', 'measure_2', 'reset', 'rz', 'sx', 'x', 'if_else', 'store']

Dynamic na impormasyon ng backend

Mayroon din ang mga backend ng mga katangiang nagbabago tuwing kina-calibrate ang backend, tulad ng buhay ng qubit at mga rate ng error ng operasyon. Ina-update ang mga katangian ng backend pagkatapos makumpleto ang calibration sequence. Maaaring gamitin ang mga katangiang ito kapag ino-optimize ang mga quantum circuit o para bumuo ng mga noise model para sa classical simulator. Tingnan ang gabay na Calibration jobs para sa karagdagang impormasyon.

Sa IBM Quantum Platform, maaari kang mag-download ng calibration data bilang CSV file. I-click ang isang QPU sa pahina ng Compute resources para makita ang detalyadong information card nito, pagkatapos ay i-click ang download icon sa kanang sulok sa itaas ng seksyong Calibration data.

Kunin ang makasaysayang data

Maaari mong kunin ang makasaysayang data ng mga katangian ng backend sa Qiskit gamit ang sumusunod na code:

backend.properties(datetime=<datetime>)

Mga katangian ng qubit

Pumunta sa listahan ng mga katangian ng qubit

backend.properties().qubit_property() nagbabalik ng impormasyon tungkol sa mga pisikal na katangian ng mga qubit. Naglalaman ito ng dictionary ng iba't ibang katangian ng qubit, bawisa ay ipinares sa halaga nito at timestamp ng huling kalibrasyon.

Ipinapakita ng sumusunod na mga halimbawa ng code kung paano ilista ang lahat ng katangian, o kunin ang mga partikular na katangian, ng isang partikular na qubit.

Tingnan ang mga katangian ng qubit

T1 (Relaxation time)

Ang $T_1$ na oras ay kumakatawan sa average na tagal ng pananatili ng isang qubit sa excited state nito na $|1\rangle$ bago ito lumipat sa ground state nito na $|0\rangle$ dahil sa energy relaxation. Ginagamit ang parameter na ito para ilarawan ang gawi ng energy relaxation ng qubit, at ipinapahayag sa mga yunit ng segundo (s).

Tingnan gamit ang Qiskit	backend.properties().t1(<qubit>)
Tingnan sa IBM Quantum Platform	Seksyon ng Calibration data, dropdown menu ng Qubit; hanapin ang halagang $T_1$ median sa seksyong Details

T2 (Dephasing time)

Ang $T_2$ na oras ay tumutukoy sa timescale kung saan pinapanatili ng isang qubit ang phase coherence ng isang superposition sa pagitan ng $|0\rangle$ at $|1\rangle$ na mga estado. Isinasaalang-alang nito ang parehong energy relaxation at mga proseso ng pure dephasing, na nagbibigay ng kaalaman tungkol sa mga katangian ng coherence ng qubit. Ang $T_2$ ay iniuulat mula sa isang Hahn echo sequence.

Tingnan gamit ang Qiskit	backend.properties().t2(<qubit>)
Tingnan sa IBM Quantum Platform	Seksyon ng Calibration data, dropdown menu ng Qubit; hanapin ang halagang $T_2$ median sa seksyong Details

# fundamental physical properties of qubit 1

backend = service.backend("ibm_fez")

backend.qubit_properties(1)

QubitProperties(t1=0.00018243651954462543, t2=0.00020405172321184844, frequency=None)

# Retrieve qubit properties
qubit_index = 126  # Replace with your qubit index
qubit_props = backend.properties().qubit_property(qubit_index)

# Access specific properties
t1 = qubit_props.get("T1", (None,))[0]
t2 = qubit_props.get("T2", (None,))[0]
readout_error = qubit_props.get("readout_error", (None,))[0]
prob_meas0_prep1 = qubit_props.get("prob_meas0_prep1", (None,))[0]
prob_meas1_prep0 = qubit_props.get("prob_meas1_prep0", (None,))[0]
readout_length = qubit_props.get("readout_length", (None,))[0]

print(f"Qubit {qubit_index} Properties:")
print(f"  T1: {t1} seconds")
print(f"  T2: {t2} seconds")
print(f"  Readout Error: {readout_error}")
print(f"  P(0 | 1): {prob_meas0_prep1}")
print(f"  P(1 | 0): {prob_meas1_prep0}")
print(f"  Readout Length: {readout_length} seconds")

Qubit 126 Properties:
  T1: 0.0001248478211384773 seconds
  T2: 7.96150033446492e-05 seconds
  Readout Error: 0.0244140625
  P(0 | 1): 0.029052734375
  P(1 | 0): 0.019775390625
  Readout Length: 1.56e-06 seconds

Mga katangian ng instruksyon

Pumunta sa listahan ng mga katangian ng instruksyon

Ang katangiang backend.target ay isang object na qiskit.transpiler.Target: isang object na naglalaman ng lahat ng impormasyong kailangan para ma-transpile ang isang circuit para sa backend na iyon. Kasama dito ang mga error at tagal ng instruksyon. Halimbawa, kinukuha ng sumusunod na cell ang mga katangian para sa isang cz gate na kumikilos sa pagitan ng mga qubit 1 at 0.

Ipinapakita ng sumusunod na cell ang mga katangian para sa isang operasyon ng pagsukat (kasama ang readout error) sa qubit 0.

Tingnan ang mga katangian ng instruksyon

prob-meas0-prep1

Ang parameter na ito ay nagpapakita ng posibilidad ng pagsukat ng isang qubit sa estado 0 nang nilalayon itong ihanda sa estado $|1\rangle$, na tinutukoy bilang $P(0 | 1)$. Sumasalamin ito sa mga error sa state preparation at measurement (SPAM), partikular na mga error sa pagsukat sa mga superconducting qubit.

Tingnan gamit ang Qiskit	backend.properties().qubit_property(<qubit>, 'prob_meas0_prep1')
Tingnan sa IBM Quantum Platform	Seksyon ng Calibration data, dropdown menu ng Qubit

prob-meas1-prep0

Katulad nito, ang parameter na ito ay kumakatawan sa posibilidad ng pagsukat ng isang qubit sa estado 1 nang nilalayon itong ihanda sa estado $|0\rangle$, na tinutukoy bilang $P(1 | 0)$. Tulad ng prob_meas0_prep1, sumasalamin ito sa mga SPAM error, na ang mga error sa pagsukat ang pangunahing kontribyutor sa mga superconducting qubit.

Tingnan gamit ang Qiskit	backend.properties().qubit_property(<qubit>, 'prob_meas0_prep0')
Tingnan sa IBM Quantum Platform	Seksyon ng Calibration data, dropdown menu ng Qubit

2Q error (Heron at Nighthawk: CZ, Eagle: ECR)

Ang two-qubit error bawat edge mula sa parehong batch ng mga pagsukat na ginamit para kalkulahin ang 2Q median error. Ang 2Q error (pinakamababa) ay tumutukoy sa pinakamababang two-qubit error sa anumang edge ng device, mula rin sa batch ng mga pagsukat na ito.

Tingnan gamit ang Qiskit	backend.target['<instruction>'][<qubit 1>, <qubit 2>]
Tingnan sa IBM Quantum Platform	Seksyon ng Calibration: mag-hover sa koneksyon ng qubit sa Map view, o hanapin ang halaga sa Table view sa ilalim ng column na CZ error (Heron at Nighthawk) o ECR error (Eagle); hanapin ang halaga para sa 2Q error (pinakamababa) sa seksyong Details

Median na 2Q error (Heron: CZ, Eagle: ECR)

Average gate fidelity ng two-qubit na operasyon mula sa randomized benchmarking. Sinusukat sa "isolation": mga batch na may minimum na pagitan ng dalawang qubit sa pagitan ng mga edge. Gumagamit ang randomized benchmarking na ito ng mga alternating layer ng single-qubit Cliffords at two-qubit gates, kaya kasama sa panghuling 2Q error value ang error ng layer ng single-qubit Cliffords.

Kalkulahin gamit ang Qiskit	Sundin ang halimbawa sa notebook na ito ng Qiskit Community GitHub
Tingnan sa IBM Quantum Platform	Seksyon ng Details; hanapin din ang per-edge na data sa seksyong Calibration data

2Q error (layered)

Average error per layered gate (EPLG) sa isang chain ng 100 qubit. Sinusukat ng average EPLG ang average gate error sa isang layered chain ng $N$ qubit ($N$=100 dito). Ito ay nagmula sa isang katulad na dami na kilala bilang layer fidelity (LF) kung saan EPLG$_{100}$ = 4/5(1-LF$^{\frac{1}{99}}$) at ang layer fidelity ay ang process fidelity ng layered chain ng $N$ qubit. Para sa mga detalye, tingnan ang papel na Benchmarking quantum processor performance at scale. Tandaan na sa papel, ang EPLG ay tinukoy para sa process error, ngunit para sa pagkakatugma sa mga indibidwal na iniulat na gate error dito, ito ay sinipi para sa average gate error, kaya ang factor na 4/5.

Sa IBM Quantum Platform, ang detalyadong information card para sa bawat QPU ay may seksyon na tinatawag na Two-qubit gate error (layered), na nagbibigay ng expanded view ng pinakamababang two-qubit gate error (layered) na sinusukat bilang function ng bilang ng mga qubit sa chain. Ang panghuling halaga, sa chain length na 100, ay ang halagang ipinakita sa seksyong Details. Sa pagsasagawa, anim na 100-qubit chain (pre-selected batay sa inaasahang pinakamainam na performance) ang sinusukat, at ang halagang iniulat para sa bilang ng qubit na N ay ang pinakamababang error na natagpuan sa isang subset length N chain na naghahanap sa anim na 100-qubit chain.

Kalkulahin gamit ang Qiskit	Sundin ang halimbawa sa notebook na ito ng Qiskit Community GitHub
Tingnan sa IBM Quantum Platform	Seksyon ng Details, at expanded view sa seksyong Two-qubit gate error (layered)

RZZ error (Heron)

Error sa RZZ gate na pinag-average sa mga RZZ angle gamit ang isang variant ng randomized benchmarking para sa mga arbitrary unitary.

Tingnan gamit ang Qiskit	Mahalaga: Tiyakin na itinakda mo ang use_fractional_gates=True kapag ni-load mo ang backend, pagkatapos ay maaari mong gamitin ang backend.target['rzz'][<qubit 1>, <qubit 2>]
Tingnan sa IBM Quantum Platform	Seksyon ng Calibration: Piliin ang RZZ sa dropdown menu ng Connection at mag-hover sa koneksyon ng qubit sa Map view. Maaari ka ring pumili ng RZZ error sa dropdown menu ng Graph output sa Graph view, o hanapin ang halaga sa Table view sa ilalim ng column na RZZ error

ID error / √x (sx) error / Pauli-X error / RX error

Error sa mga finite-duration discrete one-qubit gate, sinusukat mula sa randomized benchmarking. Kasama sa randomized benchmarking sequence ang SX, ID, at X gates, at ipinapalagay na pareho ang kanilang mga error. Ang ID gate ay isang delay na may tagal na katumbas ng tagal ng √X at X gates. Ang RX gate ay mayroon ding parehong tagal bilang √X at X gates na may variable na amplitude, kaya iniuulat itong may parehong error bilang mga gate na ito.

Tingnan gamit ang Qiskit	backend.target['<instruction>'][<qubit 1>, ]
Tingnan sa IBM Quantum Platform	Seksyon ng Calibration: dropdown menu ng Qubit

SX error (median)

Average gate fidelity ng √X (SX) gate mula sa randomized benchmarking, sinusukat nang sabay-sabay sa lahat ng qubit. Kasama sa randomized benchmarking sequence ang SX, ID, at X gates, at ipinapalagay na pareho ang kanilang mga error.

Tingnan sa IBM Quantum Platform	Seksyon ng Details

Z-axis rotation (RZ) error

Error sa virtual na RZ gate. Iniuulat bilang lahat ng 0 dahil isinasagawa ang mga ito sa software.

Tingnan gamit ang Qiskit	backend.target['<instruction>'][<qubit 1>, ]
Tingnan sa IBM Quantum Platform	Seksyon ng Calibration: dropdown menu ng Connection

Readout error

Sinusukat ng readout error ang average na posibilidad ng maling pagsukat ng estado ng isang qubit. Karaniwan itong kinakalkula bilang mean ng prob_meas0_prep1 at prob_meas1_prep0, na nagbibigay ng isang sukatan para sa measurement fidelity.

Tingnan gamit ang Qiskit	backend.properties().readout_error(<qubit>)
Tingnan sa IBM Quantum Platform	Seksyon ng Calibration data, dropdown menu ng Qubit

Readout error (median)

Fidelity ng readout na operasyon. Sinusukat ang readout error sa pamamagitan ng paghahanda ng qubit sa estado 0 (1) at pagsukat sa posibilidad ng output sa estado 1 (0). Ang iniulat na halaga ay ang average ng dalawang error na ito. Ang median ay kinukuha sa lahat ng qubit.

Tingnan sa IBM Quantum Platform	Seksyon ng Calibration data, seksyon ng Details

Single-qubit gate length

Tagal ng isang single-qubit gate na operasyon. Tandaan na ang mga halagang ipinapakita sa IBM Quantum Platform ay nasa nanosecond. Ang mga halagang ibinibigay ng Qiskit ay nasa segundo.

Tingnan gamit ang Qiskit	backend.target['<instruction>'][<qubit 1>, ].duration
Tingnan sa IBM Quantum Platform	Seksyon ng Calibration: dropdown menu ng Qubit

Gate length (2Q gates)

Tagal ng two-qubit gate na operasyon. Tandaan na ang mga halagang ipinapakita sa IBM Quantum Platform ay nasa nanosecond. Ang mga halagang ibinibigay ng Qiskit ay nasa segundo.

Tingnan gamit ang Qiskit	backend.target['<instruction>'][<qubit 1>, <qubit 2> ].duration
Tingnan sa IBM Quantum Platform	Seksyon ng Calibration: dropdown menu ng Qubit

Readout length

Tinutukoy ng readout length ang tagal ng readout na operasyon para sa isang qubit. Sinusukat nito ang oras mula sa pagsisimula ng measurement pulse hanggang sa pagkumpleto ng signal digitization, pagkatapos ay handa na ang sistema para sa susunod na operasyon. Mahalaga ang pag-unawa sa parameter na ito para ma-optimize ang pagpapatakbo ng Circuit, lalo na kapag isinasama ang mga mid-circuit measurements.

Tingnan gamit ang Qiskit	Para sa measure: backend.properties().readout_length(<qubit>) Para sa measure_2: backend.target['measure_2'][<qubit 1>, ].duration
Tingnan sa IBM Quantum Platform	Seksyon ng Calibration data, dropdown menu ng Qubit

backend.target["cz"][(1, 0)]

InstructionProperties(duration=6.8e-08, error=0.010202155482934266)

backend.target["measure"][(0,)]

InstructionProperties(duration=1.56e-06, error=0.025634765625)

Karagdagang mga katangian

CLOPS (o CLOPS_h)

Ang circuit layer operations per second (CLOPS) ay isang sukatan ng kung gaano karaming layer ng isang 100x100 Circuit (hardware-aware circuit) ang maaaring i-execute ng isang QPU bawat yunit ng oras.

Kalkulahin gamit ang Qiskit	Hanapin ang CLOPS code sa Qiskit Community GitHub
Tingnan sa IBM Quantum Platform	Seksyon ng Details

Status

Gamit ang BackendStatus, maaari mong makita ang status ng QPU (halimbawa, Active, Paused, Offline) pati na rin ang bilang ng mga nakabinbing job.

Tingnan gamit ang Qiskit	print(backend.status().status_msg), print(backend.status().pending_jobs)
Tingnan sa IBM Quantum Platform	Seksyon ng Details

Topology diagram o coupling map

Isang diagram na nagpapakita ng mga pares ng qubit na sumusuporta sa two-qubit gate operations sa pagitan nila. Tinatawag din itong coupling map o connectivity. Ang mga qubit ay kinakatawan bilang mga bilog at ang mga sinusuportahang two-qubit gate operations ay ipinapakita bilang mga linya na nagkokonekta sa mga qubit.

Tingnan gamit ang Qiskit	from qiskit.visualization import plot_gate_map then plot_gate_map(backend)
Tingnan sa IBM Quantum Platform	Seksyon ng Calibration data; I-click ang Expand para sa mas malaking view

Ano ang ibig sabihin ng `error = 1`?

Kung ang benchmarking ng isang qubit o edge ay hindi nagtagumpay sa loob ng ilang araw, maging dahil sa mahinang kalidad ng data o iba pang panloob na kadahilanan, ang iniulat na error value ay itinuturing na lipas na at iuulat bilang 1. Hindi ito nagpapahiwatig na ang qubit o edge ay tiyak na hindi gumagana o na ang error ay talagang 1; sa halip, ang error ay itinuturing na hindi natukoy at dapat kang mag-ingat kapag ginagamit ang qubit o gate na iyon.

Mga susunod na hakbang

Mga Rekomendasyon

• Alamin kung paano bumuo ng mga noise model para gumawa ng maingay na classical simulation.
• Suriin ang paksa ng Mga yugto ng Transpiler para matuto kung paano ginagamit ng transpiler ang mga katangian ng backend para sa pag-optimize ng circuit.
• Suriin ang sanggunian ng QiskitRuntime backend API.