Kunin ang impormasyon ng backend gamit ang Qiskit

Mga bersyon ng package

Ang code sa pahinang ito ay binuo gamit ang mga sumusunod na kinakailangan. Inirerekomenda naming gamitin ang mga bersyong ito o mas bago.

qiskit-ibm-runtime~=0.43.1

Ipinaliliwanag ng pahinang ito kung paano gamitin ang Qiskit para mahanap ang impormasyon tungkol sa iyong mga available na backend.

Ilista ang mga backend

Para makita ang mga backend na available sa iyo, maaari kang tumingin ng listahan sa Compute resources page, o gamitin ang QiskitRuntimeService.backends() na method. Ibinabalik ng method na ito ang listahan ng mga IBMBackend instance:

Mga Tala

Kung naka-log in ka sa isang partikular na instance o rehiyon, o kung ini-initialize mo ang serbisyo na may partikular na instance o rehiyon gamit ang QiskitRuntimeService(), ang mga backend lamang na available sa iyo sa instance o rehiyong iyon ang ibabalik. Kung hindi, lahat ng backend na available sa iyo sa anumang instance at sa anumang rehiyon ay ibabalik.
Ang listahan ng mga backend na ibinabalik ay maaaring hindi katulad ng ipinapakita sa IBM Quantum Platform Compute resources page. Ang listahan sa Compute resources page ay palaging nafi-filter ayon sa rehiyong pinili sa itaas ng pahina.

Para mapatakbo ang sumusunod na code, tiyaking nakapag-authenticate ka na sa serbisyo. Tingnan ang I-set up ang iyong IBM Cloud account para sa karagdagang detalye.

# 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_pittsburgh')>,
 <IBMBackend('ibm_boston')>,
 <IBMBackend('ibm_fez')>,
 <IBMBackend('ibm_miami')>,
 <IBMBackend('ibm_marrakesh')>,
 <IBMBackend('ibm_torino')>,
 <IBMBackend('ibm_kingston')>]

Ang QiskitRuntimeService.backend() na method (pansinin na ito ay isahan: backend) ay tumatanggap ng pangalan ng backend bilang input parameter at nagbabalik ng IBMBackend instance na kumakatawan sa partikular na backend na iyon:

service.backend("ibm_fez")

<IBMBackend('ibm_fez')>

I-filter ang mga backend

Maaari mo ring i-filter ang mga available na backend ayon sa kanilang mga katangian. Para sa mas pangkalahatang mga filter, itakda ang filters na argumento sa isang function na tumatanggap ng backend object at nagbabalik ng True kung natutugunan nito ang iyong mga pamantayan. Tingnan ang dokumentasyon ng API para sa karagdagang detalye.

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

Mga tunay na quantum device (simulator=False)
Kasalukuyang gumagana (operational=True)
May kahit 5 qubit (min_num_qubits=5)

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

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

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

Gamitin ang mga keyword argument na ito para mag-filter ayon sa anumang attribute sa backend configuration (JSON schema) o status (JSON schema). Isang katulad na method ay ang QiskitRuntimeService.least_busy(), na gumagamit ng parehong mga filter tulad ng backends() ngunit nagbabalik ng backend na nakakatugon sa mga filter at may pinakamaliit na bilang ng mga trabaho na naghihintay sa pila:

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

<IBMBackend('ibm_torino')>

Impormasyon ng static na backend

Ang ilang impormasyon tungkol sa isang backend ay hindi regular na nagbabago, tulad ng pangalan nito, bersyon, bilang ng mga qubit nito, at mga uri ng feature na sinusuportahan nito. Ang impormasyong ito ay available bilang mga attribute ng backend object.

Ang sumusunod na cell ay gumagawa ng paglalarawan ng isang backend.

backend = service.backend("ibm_fez")

print(
    f"Name: {backend.name}\n"
    f"Version: {backend.version}\n"
    f"No. of qubits: {backend.num_qubits}\n"
)

Name: ibm_fez
Version: 2
No. of qubits: 156

Para sa kumpletong listahan ng mga attribute, tingnan ang IBMBackend API documentation.

Mga native na Gate at operasyon

Ang bawat pamilya ng processor ay may native na gate set. Bilang default, ang mga QPU sa bawat pamilya ay sumusuporta lamang sa pagpapatakbo ng mga Gate at operasyon sa native gate set. Kaya naman, ang bawat gate sa Circuit ay kailangang isalin (ng Transpiler) sa mga elemento ng set na ito.

Maaari mong makita ang mga native na Gate at operasyon para sa isang QPU alinman gamit ang Qiskit, o sa IBM Quantum® Platform Compute resources page.

from qiskit_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService()

for backend in service.backends():
    config = backend.configuration()
    if "simulator" in config.backend_name:
        continue
    print(f"Backend: {config.backend_name}")
    print(f"    Processor type: {config.processor_type}")
    print(f"    Supported instructions:")
    for instruction in config.supported_instructions:
        print(f"        {instruction}")
    print()

Impormasyon ng dynamic na backend

Ang mga backend ay maaari ding magkaroon ng mga katangian na nagbabago tuwing ma-calibrate ang backend, tulad ng qubit frequency at mga error rate ng operasyon. Ang mga backend ay karaniwang naka-calibrate tuwing 24 na oras, at ang kanilang mga katangian ay ina-update pagkatapos makumpleto ang calibration sequence. Maaaring gamitin ang mga katangiang ito kapag ino-optimize ang mga quantum circuit o para gumawa ng mga noise model para sa isang klasikal na simulator.

Mga katangian ng Qubit

Ang backend.properties().qubit_property() ay nagbabalik ng impormasyon tungkol sa mga pisikal na katangian ng mga qubit. Naglalaman ito ng isang dictionary ng iba't ibang katangian ng qubit, na bawat isa ay may kasamang halaga at timestamp ng huling calibration.

T1 (Relaxation Time): Ang T1 na oras ay kumakatawan sa average na tagal na nananatili ang isang qubit sa excited state nitong $|1\rangle$ bago bumagsak sa ground state nitong $|0\rangle$ dahil sa energy relaxation. Ang parameter na ito ay ginagamit para ilarawan ang energy relaxation behavior ng qubit, at ipinahayag sa mga yunit ng segundo (s).
T2 (Dephasing Time): Ang T2 na oras ay nagtatanda ng timescale kung saan pinapanatili ng isang qubit ang phase coherence ng isang superposition sa pagitan ng mga state na $|0\rangle$ at $|1\rangle$ . 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.
frequency: Tinutukoy ng parameter na ito ang resonant frequency ng qubit, na nagpapakita ng pagkakaiba ng enerhiya sa pagitan ng mga state na $|0\rangle$ at $|1\rangle$ , na ipinahayag sa hertz (Hz).
anharmonicity: Ang anharmonicity ay ang pagkakaiba ng enerhiya sa pagitan ng una at pangalawang excited state ng qubit, na ipinahayag din sa hertz (Hz).
readout_error: Ang readout error ay sinusukat ang average na posibilidad ng maling pagsukat sa state ng isang qubit. Karaniwan itong kinakalkula bilang mean ng prob_meas0_prep1 at prob_meas1_prep0, na nagbibigay ng isang solong metric para sa measurement fidelity.
prob_meas0_prep1: Ipinapakita ng parameter na ito ang posibilidad ng pagsukat sa isang qubit sa state 0 noong nilalayong ihanda ito sa state na $|1\rangle$ , na tinatawag na $P(0 | 1)$ . Sumasalamin ito sa mga error sa state preparation at measurement (SPAM), lalo na ang mga error sa pagsukat sa mga superconducting qubit.
prob_meas1_prep0: Katulad nito, kinakatawan ng parameter na ito ang posibilidad ng pagsukat sa isang qubit sa state 1 noong nilalayong ihanda ito sa state na $|0\rangle$ , na tinatawag na $P(1 | 0)$ . Tulad ng prob_meas0_prep1, sumasalamin ito sa mga SPAM error, na ang mga error sa pagsukat ang pangunahing nag-aambag sa mga superconducting qubit.
readout_length: Tinutukoy ng readout_length ang tagal ng readout operation para sa isang qubit. Sinusukat nito ang oras mula sa pagsisimula ng measurement pulse hanggang sa pagkumpleto ng signal digitization, pagkatapos nito ay handa na ang sistema para sa susunod na operasyon. Mahalaga ang pag-unawa sa parameter na ito para ma-optimize ang pagsasagawa ng circuit, lalo na kapag isinama ang mga mid-circuit measurement.

# fundamental physical properties of qubit 1
backend.qubit_properties(1)

QubitProperties(t1=0.00023160183954439313, t2=0.0002759670226087048, frequency=None)

# calibration data with detailed properties of qubit 0
backend.properties().qubit_property(0)

{'T1': (5.199156952582205e-05,
  datetime.datetime(2026, 1, 14, 16, 18, 26, tzinfo=tzlocal())),
 'T2': (2.253552085985709e-05,
  datetime.datetime(2026, 1, 14, 16, 19, 6, tzinfo=tzlocal())),
 'readout_error': (0.013916015625,
  datetime.datetime(2026, 1, 14, 21, 38, 31, tzinfo=tzlocal())),
 'prob_meas0_prep1': (0.026123046875,
  datetime.datetime(2026, 1, 14, 21, 38, 31, tzinfo=tzlocal())),
 'prob_meas1_prep0': (0.001708984375,
  datetime.datetime(2026, 1, 14, 21, 38, 31, tzinfo=tzlocal())),
 'readout_length': (1.56e-06,
  datetime.datetime(2026, 1, 14, 21, 38, 31, tzinfo=tzlocal()))}

# 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]
frequency = qubit_props.get("frequency", (None,))[0]
anharmonicity = qubit_props.get("anharmonicity", (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"  Frequency: {frequency} Hz")
print(f"  Anharmonicity: {anharmonicity} Hz")
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: 9.563335658857979e-05 seconds
  T2: 6.570556299807121e-05 seconds
  Frequency: None Hz
  Anharmonicity: None Hz
  Readout Error: 0.006591796875
  P(0 | 1): 0.009765625
  P(1 | 0): 0.00341796875
  Readout Length: 1.56e-06 seconds

Mga katangian ng instruksyon

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

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

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

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

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

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

Mga susunod na hakbang

Mga Rekomendasyon

Subukan ang tutorial ng Grover's algorithm.
Suriin ang sanggunian ng QiskitRuntime backend API.

Ilista ang mga backend​

I-filter ang mga backend​

Impormasyon ng static na backend​

Mga native na Gate at operasyon​

Impormasyon ng dynamic na backend​

Mga katangian ng Qubit​

Mga katangian ng instruksyon​

Mga susunod na hakbang​