Vizualizează detaliile backend-ului

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

Această pagină explică cum să găsești informații despre backend-urile disponibile.

Listează sau filtrează backend-urile

Listează backend-urile disponibile pentru tine

Poți utiliza fie Qiskit, fie IBM Quantum Platform pentru a vizualiza o listă de backend-uri disponibile sau pentru a căuta un backend specific.

Nume QPU

QPU-urile găzduite pe IBM Cloud® au nume care încep cu ibm_*. Toate QPU-urile primesc un nume de oraș - de exemplu, ibm_kingston. Acest nume nu indică locul unde se află efectiv QPU-ul.

Vizualizează backend-urile cu Qiskit

Folosește metoda QiskitRuntimeService.backends(), așa cum se arată în blocul de cod următor. Această metodă returnează o listă de instanțe IBMBackend.

Pentru a rula codul următor, asigură-te că te-ai autentificat deja la serviciu. Vezi Configurează-ți contul IBM Cloud pentru mai multe detalii.

Pentru a căuta un backend specific, folosește metoda QiskitRuntimeService.backend() (observă că este la singular: backend), care primește ca parametru de intrare numele backend-ului și returnează o instanță IBMBackend reprezentând acel backend specific:

Vizualizează backend-urile pe IBM Quantum Platform

Pentru a vizualiza backend-urile la care ai acces, navighează la lista de backend-uri de pe pagina Compute resources (rețineți că regiunea selectată poate afecta QPU-urile listate). Dă clic pe pictograma de filtrare și alege fie „Toate instanțele mele", fie un nume de instanță specific pentru a vedea QPU-urile disponibile.

# 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')>]

notă

Dacă ești autentificat la o instanță sau regiune specifică, sau dacă ai inițializat serviciul cu o instanță sau regiune specifică folosind QiskitRuntimeService(), sunt returnate doar backend-urile disponibile pe acea instanță sau regiune.

Filtrează backend-urile

Filtrează după proprietăți cu Qiskit

Poți filtra backend-urile disponibile după configurația sau statusul lor. Pentru filtre mai generale, setează argumentul filters la o funcție care acceptă un obiect backend și returnează True dacă îndeplinește criteriile. Consultă documentația API pentru mai multe detalii.

Următorul cod returnează doar backend-urile care îndeplinesc aceste criterii și sunt disponibile pe instanța selectată curent:

• Sunt dispozitive cuantice reale (simulator=False)
• Sunt în prezent operaționale (operational=True)
• Au cel puțin o sută de qubiți (min_num_qubits=100)

O metodă similară este QiskitRuntimeService.least_busy(), care acceptă aceleași filtre ca backends(), dar returnează backend-ul care corespunde filtrelor și are cel mai mic număr de joburi în așteptare:

Filtrează după proprietăți pe IBM Quantum Platform

Pentru a vizualiza backend-urile la care ai acces, vizualizează tabelul de pe pagina Compute resources. Dă clic pe pictograma de filtrare pentru a vedea opțiunile de filtrare. Poți filtra după tipul procesorului și status. Rețineți că poți sorta tabelul după orice coloană prin trecerea cursorului peste titlul coloanei, apoi dând clic pe săgețile care apar.

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

<IBMBackend('ibm_fez')>

Informații statice despre backend

Unele informații despre un backend nu se schimbă regulat, cum ar fi numele, versiunea, numărul de qubiți, tipul procesorului (numele familiei, care indică topologia și numărul aproximativ de qubiți) și tipurile de funcții pe care le suportă. Aceste informații sunt disponibile ca atribute ale obiectului backend. Pentru o listă completă a atributelor, consulta documentația API IBMBackend. Găsești mai multe informații despre versionare în secțiunea Versionarea QPU de mai jos.

Regiunea unui backend (locația centrului de date unde datele și experimentele tale vor fi găzduite și procesate) este listată în cardul său de informații detaliate de pe pagina Compute resources de pe IBM Quantum Platform.

Vizualizează informații despre backend cu Qiskit

Vizualizează informații despre backend pe IBM Quantum Platform

Navighează la pagina Compute resources pentru a vizualiza un tabel cu toate QPU-urile, apoi dă clic pe numele oricărui QPU pentru a deschide cardul său de informații detaliate. Găsești informații despre backend în secțiunea Detalii a cardului.

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'}

Versionarea QPU

Fiecare QPU are un număr de versiune în forma X.Y.Z (major.minor.revizie). Un circuit compilat pentru un anumit număr de versiune are garanția că va rula pe acel QPU. Dacă numărul de revizie se schimbă, circuitul va continua să ruleze. Dacă numărul major sau minor se schimbă, circuitul nu are garanția că va rula, deși este posibil să o facă.

Numărul versiunii de revizie va fi incrementat pentru corecții care nu afectează circuitul compilat existent.

Exemplul de cod anterior din această secțiune demonstrează cum să găsești versiunea unui backend. Pe IBM Quantum Platform, poți vizualiza versiunea pe cardul de informații detaliate al unui QPU (dă clic pe numele QPU-ului din tabelul de pe Compute resources pentru a deschide cardul).

Condițiile în care un număr de versiune sau revizie se poate schimba sunt enumerate în tabelul următor.

Versiunea majoră	Versiunea minoră	Versiunea de revizie
Schimbări de eșantion	Cicluri de încălzire / răcire	Actualizări software ale QPU
Modificări majore ale electronicii de control	Înlocuirea unor componente electronice, dacă înlocuirea afectează considerabil funcționarea	Calibrări manuale pentru îmbunătățirea fidelității
Mutarea QPU într-o locație nouă, dacă rezultă schimbări semnificative de comportament	Eliminarea unui Gate pentru o perioadă de timp din cauza unor probleme de calibrare, iar corecțiile nu pot fi efectuate ușor în software	Modificări mici ale electronicii care nu afectează funcționarea
	Schimbarea direcției unui Gate CNOT

Instrucțiuni suportate

Fiecare familie de procesoare suportă nativ un set limitat de instrucțiuni. Acest set include Gate-uri cu un singur și două qubit-uri, precum și operațiuni non-unitare, cum ar fi measure și reset. Fiecare poartă din circuit trebuie tradus (de către Transpiler) în elementele setului de instrucțiuni suportate ale unui QPU înainte de a putea rula pe QPU.

Poți vizualiza seturile de instrucțiuni suportate pentru un QPU cu Qiskit. Pagina IBM Quantum Platform Compute resources listează doar Gate-urile unitare suportate (gate-uri de bază) pentru un QPU.

Găsește instrucțiunile suportate cu Qiskit

Găsește gate-urile de bază pe IBM Quantum Platform

Navighează la pagina Compute resources pentru a vizualiza un tabel cu toate QPU-urile, apoi dă clic pe numele oricărui QPU pentru a deschide cardul său de informații detaliate. Gate-urile de bază pentru acel QPU sunt listate în secțiunea Detalii.

Tabel cu instrucțiunile suportate

Categorie operațiune	Nume
Gate-uri cu un singur qubit	RZ, SX, X, ID, delay
Gate-uri cu două qubit-uri	CZ, ECR
Gate-uri fracționare	RX (un singur qubit), RZZ (două qubit-uri)
Instrucțiuni non-unitare	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']

Informații dinamice despre backend

Backend-urile au și proprietăți care se schimbă ori de câte ori backend-ul este calibrat, cum ar fi durata de viață a qubiților și ratele de eroare ale operațiunilor. Proprietățile backend-ului se actualizează după finalizarea secvenței de calibrare. Aceste proprietăți pot fi utilizate la optimizarea circuitelor cuantice sau pentru a construi modele de zgomot pentru un simulator clasic. Consultă ghidul Joburi de calibrare pentru mai multe informații.

Pe IBM Quantum Platform, poți descărca datele de calibrare ca fișier CSV. Dă clic pe un QPU de pe pagina Compute resources pentru a vizualiza cardul său de informații detaliate, apoi dă clic pe pictograma de descărcare din colțul din dreapta sus al secțiunii Date de calibrare.

Recuperează date istorice

Poți recupera date istorice ale proprietăților backend-ului în Qiskit cu următorul cod:

backend.properties(datetime=<datetime>)

Proprietăți ale qubiților

Sari la lista proprietăților qubiților

backend.properties().qubit_property() returnează informații despre atributele fizice ale qubiților. Conține un dicționar cu diverse proprietăți ale Qubitului, fiecare pereche cu valoarea sa și marcajul de timp al ultimei calibrări.

Exemplele de cod următoare demonstrează cum să listezi toate proprietățile sau să recuperezi proprietăți specifice ale unui anumit qubit.

Vizualizează proprietățile qubiților

T1 (Timp de relaxare)

Timpul $T_1$ reprezintă durata medie în care un qubit rămâne în starea sa excitată $|1\rangle$ înainte de a decade la starea de repaus $|0\rangle$ din cauza relaxării energetice. Acest parametru este utilizat pentru a caracteriza comportamentul de relaxare energetică al Qubitului și este exprimat în unități de secunde (s).

Vizualizare cu Qiskit	backend.properties().t1(<qubit>)
Vizualizare pe IBM Quantum Platform	Secțiunea Date de calibrare, meniul derulant qubit; găsește valoarea mediană $T_1$ în secțiunea Detalii

T2 (Timp de defazare)

Timpul $T_2$ denotă scala de timp pe care un qubit menține coerența de fază a unei superpoziții între stările $|0\rangle$ și $|1\rangle$. Ține cont atât de relaxarea energetică, cât și de procesele de defazare pură, oferind informații despre proprietățile de coerență ale Qubitului. $T_2$ este raportat dintr-o secvență Hahn echo.

Vizualizare cu Qiskit	backend.properties().t2(<qubit>)
Vizualizare pe IBM Quantum Platform	Secțiunea Date de calibrare, meniul derulant qubit; găsește valoarea mediană $T_2$ în secțiunea Detalii

# 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

Proprietăți ale instrucțiunilor

Sari la lista proprietăților instrucțiunilor

Atributul backend.target este un obiect qiskit.transpiler.Target: un obiect care conține toate informațiile necesare pentru a transpila un circuit pentru acel backend. Aceasta include erorile și duratele instrucțiunilor. De exemplu, celula următoare obține proprietățile pentru un Gate cz care acționează între qubiții 1 și 0.

Celula următoare arată proprietățile pentru o operațiune de măsurare (inclusiv eroarea de citire) pe qubit-ul 0.

Vizualizează proprietățile instrucțiunilor

prob-meas0-prep1

Acest parametru indică probabilitatea de a măsura un qubit în starea 0 când a fost intenționat să fie pregătit în starea $|1\rangle$, denotată ca $P(0 | 1)$. Reflectă erorile de pregătire a stării și de măsurare (SPAM), în special erorile de măsurare ale Qubiților superconductori.

Vizualizare cu Qiskit	backend.properties().qubit_property(<qubit>, 'prob_meas0_prep1')
Vizualizare pe IBM Quantum Platform	Secțiunea Date de calibrare, meniul derulant qubit

prob-meas1-prep0

În mod similar, acest parametru reprezintă probabilitatea de a măsura un qubit în starea 1 când a fost intenționat să fie pregătit în starea $|0\rangle$, denotată ca $P(1 | 0)$. La fel ca prob_meas0_prep1, reflectă erorile SPAM, cu erorile de măsurare ca principal factor contributor în Qubiții superconductori.

Vizualizare cu Qiskit	backend.properties().qubit_property(<qubit>, 'prob_meas0_prep0')
Vizualizare pe IBM Quantum Platform	Secțiunea Date de calibrare, meniul derulant qubit

Eroare 2Q (Heron și Nighthawk: CZ, Eagle: ECR)

Eroarea cu două qubit-uri per muchie din același lot de măsurători utilizat pentru a calcula eroarea mediană 2Q. Eroarea 2Q (cea mai bună) se referă la cea mai mică eroare cu două qubit-uri pe orice muchie a dispozitivului, tot din acest lot de măsurători.

Vizualizare cu Qiskit	backend.target['<instruction>'][<qubit 1>, <qubit 2>]
Vizualizare pe IBM Quantum Platform	Secțiunea Calibrare: trece cursorul peste conexiunea qubiților în vizualizarea Hartă, sau găsește valoarea în vizualizarea Tabel în coloana eroare CZ (Heron și Nighthawk) sau eroare ECR (Eagle); găsește valoarea pentru eroare 2Q (cea mai bună) în secțiunea Detalii

Eroare 2Q mediană (Heron: CZ, Eagle: ECR)

Fidelitatea medie a Gate-ului pentru operațiunea cu două qubit-uri, din benchmarking randomizat. Măsurată „în izolare": loturi cu o separare minimă de două qubit-uri între muchii. Acest benchmarking randomizat folosește straturi alternante de Clifforzi cu un singur qubit și Gate-uri cu două qubit-uri, astfel încât valoarea finală a erorii 2Q include și eroarea stratului de Clifforzi cu un singur qubit.

Calculare cu Qiskit	Urmează exemplul din acest notebook GitHub Comunitate Qiskit
Vizualizare pe IBM Quantum Platform	Secțiunea Detalii; găsește de asemenea datele per muchie în secțiunea Date de calibrare

Eroare 2Q (stratificată)

Eroarea medie per Gate stratificat (EPLG) într-un lanț de 100 de qubiți. EPLG mediu măsoară eroarea medie a Gate-ului într-un lanț stratificat de $N$ qubiți ($N$=100 aici). Este derivat dintr-o cantitate similară cunoscută sub numele de fidelitate a stratului (LF), unde EPLG$_{100}$ = 4/5(1-LF$^{\frac{1}{99}}$) și fidelitatea stratului este fidelitatea procesului lanțului stratificat de $N$ qubiți. Pentru detalii, consultă lucrarea Benchmarking quantum processor performance at scale. Rețineți că în lucrare EPLG este definit pentru eroarea procesului, dar pentru consecvență cu erorile de poartă raportate individual, este citat pentru eroarea medie a Gate-ului, de unde factorul 4/5.

Pe IBM Quantum Platform, cardul de informații detaliate pentru fiecare QPU are o secțiune numită Eroare Gate cu două qubit-uri (stratificată), care furnizează vizualizarea extinsă a celei mai mici erori Gate cu două qubit-uri (stratificată) măsurate ca funcție de numărul de qubiți din lanț. Valoarea finală, la lungimea lanțului 100, este valoarea prezentată în secțiunea Detalii. În practică, șase lanțuri de 100 de qubiți (preselecționate pe baza performanței optime așteptate) sunt măsurate, iar valoarea raportată pentru numărul de qubiți N este cea mai mică eroare găsită într-un lanț de subset cu lungimea N, căutând în cele șase lanțuri de 100 de qubiți.

Calculare cu Qiskit	Urmează exemplul din acest notebook GitHub Comunitate Qiskit
Vizualizare pe IBM Quantum Platform	Secțiunea Detalii, și o vizualizare extinsă în secțiunea Eroare Gate cu două qubit-uri (stratificată)

Eroare RZZ (Heron)

Eroare în Gate-ul RZZ mediată peste unghiurile RZZ folosind o variantă de benchmarking randomizat pentru unitare arbitrare.

Vizualizare cu Qiskit	Important: asigură-te că ai setat use_fractional_gates=True când încarci backend-ul, apoi poți folosi backend.target['rzz'][<qubit 1>, <qubit 2>]
Vizualizare pe IBM Quantum Platform	Secțiunea Calibrare: selectează RZZ în meniul derulant Conexiune și trece cursorul peste conexiunea qubiților în vizualizarea Hartă. Poți selecta de asemenea eroarea RZZ în meniul derulant de ieșire Grafic în vizualizarea Grafic, sau găsești valoarea în vizualizarea Tabel în coloana eroare RZZ

Eroare ID / eroare √x (sx) / eroare Pauli-X / eroare RX

Eroare în Gate-urile discrete cu durată finită cu un singur qubit, măsurată prin benchmarking randomizat. Secvența de benchmarking randomizat include Gate-urile SX, ID și X, iar erorile acestora sunt considerate identice. Gate-ul ID este o întârziere cu durată egală cu durata Gate-urilor √X și X. Gate-ul RX are de asemenea aceeași durată ca Gate-urile √X și X, cu amplitudine variabilă, și prin urmare este raportat ca având aceeași eroare ca aceste poartă-uri.

Vizualizare cu Qiskit	backend.target['<instruction>'][<qubit 1>, ]
Vizualizare pe IBM Quantum Platform	Secțiunea Calibrare: meniul derulant qubit

Eroare SX (mediană)

Fidelitatea medie a Gate-ului pentru Gate-ul √X (SX) din benchmarking randomizat, măsurată simultan pe toți qubiții. Secvența de benchmarking randomizat include Gate-urile SX, ID și X, iar erorile acestora sunt considerate identice.

Vizualizare pe IBM Quantum Platform	Secțiunea Detalii

Eroare rotație pe axa Z (RZ)

Eroare în Gate-ul virtual RZ. Raportată ca 0 deoarece acestea sunt efectuate în software.

Vizualizare cu Qiskit	backend.target['<instruction>'][<qubit 1>, ]
Vizualizare pe IBM Quantum Platform	Secțiunea Calibrare: meniul derulant Conexiune

Eroare de citire

Eroarea de citire cuantifică probabilitatea medie de a măsura incorect starea unui qubit. Este calculată de obicei ca media dintre prob_meas0_prep1 și prob_meas1_prep0, oferind o singură metrică pentru fidelitatea măsurătorii.

Vizualizare cu Qiskit	backend.properties().readout_error(<qubit>)
Vizualizare pe IBM Quantum Platform	Secțiunea Date de calibrare, meniul derulant qubit

Eroare de citire (mediană)

Fidelitatea operațiunii de citire. Eroarea de citire se măsoară prin pregătirea qubitului în starea 0 (1) și măsurarea probabilității unui rezultat în starea 1 (0). Valoarea raportată este media acestor două erori. Mediana este calculată pe toți qubiții.

Vizualizare pe IBM Quantum Platform	Secțiunea Date de calibrare, secțiunea Detalii

Durata Gate-ului cu un singur Qubit

Durata unei operațiuni Gate cu un singur qubit. Rețineți că valorile afișate pe IBM Quantum Platform sunt în nanosecunde. Valorile returnate în Qiskit sunt în secunde.

Vizualizare cu Qiskit	backend.target['<instruction>'][<qubit 1>, ].duration
Vizualizare pe IBM Quantum Platform	Secțiunea Calibrare: meniul derulant qubit

Durata Gate-ului (Gate-uri 2Q)

Durata operațiunii Gate cu două qubit-uri. Rețineți că valorile afișate pe IBM Quantum Platform sunt în nanosecunde. Valorile returnate în Qiskit sunt în secunde.

Vizualizare cu Qiskit	backend.target['<instruction>'][<qubit 1>, <qubit 2> ].duration
Vizualizare pe IBM Quantum Platform	Secțiunea Calibrare: meniul derulant qubit

Durata citirii

Durata citirii specifică durata operațiunii de citire pentru un qubit. Măsoară timpul de la inițierea pulsului de măsurare până la finalizarea digitizării semnalului, după care sistemul este pregătit pentru operațiunea următoare. Înțelegerea acestui parametru este crucială pentru optimizarea execuției Circuit-ului, mai ales când se încorporează măsurători în mijlocul Circuit-ului.

Vizualizare cu Qiskit	Pentru measure: backend.properties().readout_length(<qubit>) Pentru measure_2: backend.target['measure_2'][<qubit 1>, ].duration
Vizualizare pe IBM Quantum Platform	Secțiunea Date de calibrare, meniul derulant 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)

Proprietăți suplimentare

CLOPS (sau CLOPS_h)

Operații per strat de circuit pe secundă (CLOPS) este o măsură a câte straturi dintr-un Circuit 100x100 (Circuit adaptat hardware-ului) poate executa un QPU pe unitate de timp.

Calculare cu Qiskit	Găsește codul CLOPS pe GitHub-ul Comunității Qiskit
Vizualizare pe IBM Quantum Platform	Secțiunea Detalii

Status

Cu BackendStatus, poți găsi statusul QPU-ului (de exemplu, Active, Paused, Offline) și numărul de joburi în așteptare.

Vizualizare cu Qiskit	print(backend.status().status_msg), print(backend.status().pending_jobs)
Vizualizare pe IBM Quantum Platform	Secțiunea Detalii

Diagramă de topologie sau hartă de cuplare

O diagramă care indică perechile de Qubiți ce suportă operațiuni Gate cu două qubit-uri între ele. Aceasta se mai numește și hartă de cuplare sau conectivitate. Qubiții sunt reprezentați ca cercuri, iar operațiunile Gate cu două qubit-uri suportate sunt afișate ca linii care conectează Qubiții.

Vizualizare cu Qiskit	from qiskit.visualization import plot_gate_map then plot_gate_map(backend)
Vizualizare pe IBM Quantum Platform	Secțiunea Date de calibrare; Dă clic pe Extinde pentru o vizualizare mai mare

Ce înseamnă `error = 1`?

Dacă benchmarking-ul unui qubit sau al unei muchii nu reușește pe parcursul mai multor zile, fie din cauza calității slabe a datelor, fie din alte motive interne, valoarea erorii raportate este considerată învechită și va fi raportată ca 1. Aceasta nu indică faptul că qubit-ul sau muchia sunt neapărat nefuncționale sau că eroarea este 1; mai degrabă, eroarea este considerată nedefinită și ar trebui să procedezi cu prudență atunci când operezi acel qubit sau Gate.

Pași următori

Recomandări

• Află cum să construiești modele de zgomot pentru simulare clasică cu zgomot.
• Revizuiește subiectul Etapele Transpiler-ului pentru a afla cum Transpiler-ul utilizează proprietățile backend-ului pentru optimizarea Circuit-ului.
• Revizuiește referința API-ul backend QiskitRuntime.