Voir les détails du backend

Versions des paquets

Le code de cette page a été développé en utilisant les exigences suivantes. Nous recommandons d'utiliser ces versions ou des versions plus récentes.

qiskit-ibm-runtime~=0.47.0

Cette page explique comment trouver des informations sur tes Backends disponibles.

Lister ou filtrer les backends

Lister les backends disponibles

Tu peux utiliser Qiskit ou IBM Quantum Platform pour afficher la liste des backends disponibles, ou pour rechercher un backend particulier.

Noms des QPU

Les QPU hébergées sur IBM Cloud® ont des noms qui commencent par ibm_*. Toutes les QPU reçoivent un nom de ville — par exemple, ibm_kingston. Ce nom n'indique pas l'emplacement réel de la QPU.

Voir les backends avec Qiskit

Utilise la méthode QiskitRuntimeService.backends(), comme indiqué dans le bloc de code suivant. Cette méthode retourne une liste d'instances IBMBackend.

Pour exécuter le code suivant, assure-toi d'être déjà authentifié auprès du service. Consulte Configurer ton compte IBM Cloud pour plus de détails.

Pour rechercher un backend spécifique, utilise la méthode QiskitRuntimeService.backend() (note bien que c'est au singulier : backend), qui prend le nom du backend comme paramètre d'entrée et retourne une instance IBMBackend représentant ce backend particulier :

Voir les backends sur IBM Quantum Platform

Pour voir les backends auxquels tu as accès, accède à la liste des backends sur la page Ressources de calcul (note que ta région sélectionnée peut avoir un impact sur les QPU listées). Clique sur l'icône de filtre et choisis soit « Toutes mes instances » soit un nom d'instance spécifique pour voir les QPU disponibles.

# Added by doQumentation — installs the packages this notebook needs if they are missing
import importlib.util

_needed = {"qiskit_ibm_runtime": "qiskit-ibm-runtime"}
_missing = [pip for module, pip in _needed.items()
            if importlib.util.find_spec(module) is None]
# One at a time, so a package that fails to install does not block the others
for _pip in _missing:
    %pip install -q {_pip}
if not _missing:
    print("\u2713 All required packages are installed")

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

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

remarque

Si tu es connecté à une instance ou une région spécifique, ou si tu as initialisé le service avec une instance ou une région spécifique en utilisant QiskitRuntimeService(), seuls les backends disponibles dans cette instance ou région sont retournés.

Filtrer les backends

Filtrer par propriétés avec Qiskit

Tu peux filtrer les backends disponibles par leur configuration ou leur statut. Pour des filtres plus généraux, donne à l'argument filters une fonction qui accepte un objet backend et retourne True s'il répond à tes critères. Consulte la documentation API pour plus de détails.

Le code suivant ne retourne que les backends qui correspondent à ces critères et qui sont disponibles sur ton instance actuellement sélectionnée :

• Ce sont de vrais dispositifs quantiques (simulator=False)

• Ils sont actuellement opérationnels (operational=True)

• Ils ont au moins cent qubits (min_num_qubits=100)

Une méthode similaire est QiskitRuntimeService.least_busy(), qui prend les mêmes filtres que backends() mais retourne le backend qui correspond aux filtres et qui a le moins de jobs en attente dans la file :

Filtrer par propriétés sur IBM Quantum Platform

Pour voir les backends auxquels tu as accès, consulte le tableau sur la page Ressources de calcul. Clique sur l'icône de filtre pour voir les options de filtre. Tu peux filtrer par type de processeur et par statut. Note également que tu peux trier le tableau par n'importe quelle colonne en survolant le titre d'une colonne, puis en cliquant sur les flèches qui apparaissent.

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

<IBMBackend('ibm_fez')>

Informations statiques du backend

Certaines informations sur un backend ne changent pas régulièrement, comme son nom, sa version, le nombre de qubits qu'il possède, son type de processeur (le nom de la famille d'oiseaux, qui indique la topologie et le nombre approximatif de qubits), et les types de fonctionnalités qu'il prend en charge. Ces informations sont disponibles en tant qu'attributs de l'objet backend. Pour une liste complète des attributs, consulte la documentation API d'IBMBackend. Trouve plus d'informations sur le versionnage dans la section Versionnage des QPU ci-dessous.

La région d'un backend (l'emplacement du centre de données où tes données et expériences seront hébergées et traitées) est indiquée dans sa fiche d'information détaillée sur la page Ressources de calcul sur IBM Quantum Platform.

Voir les informations du backend avec Qiskit

Voir les informations du backend sur IBM Quantum Platform

Accède à la page Ressources de calcul pour voir un tableau de toutes les QPU, puis clique sur le nom d'une QPU pour ouvrir sa fiche d'information détaillée. Les informations sur le backend se trouvent dans la section Détails de la fiche.

backend = service.least_busy(operational=True, simulator=False)

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

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

Versionnage des QPU

Chaque QPU a un numéro de version au format X.Y.Z (majeur.mineur.révision). Un circuit compilé pour un numéro de version donné fonctionnera à coup sûr sur cette QPU. Si le numéro de révision change, le circuit continuera à fonctionner. Si le numéro majeur ou mineur change, il n'est pas garanti que le circuit fonctionne, bien que cela puisse être le cas.

Le numéro de version de révision sera incrémenté pour les correctifs qui ne cassent pas le circuit compilé existant.

L'exemple de code plus haut dans cette section montre comment trouver la version d'un backend. Sur IBM Quantum Platform, tu peux voir la version sur la fiche d'informations détaillées d'un QPU (clique sur le nom du QPU dans le tableau Ressources de calcul pour ouvrir la fiche).

Les conditions dans lesquelles un numéro de version ou de révision peut changer sont listées dans le tableau suivant.

Version majeure	Version mineure	Version de révision
Modifications d'échantillon	Cycles de préchauffage / refroidissement	Mises à jour du logiciel du QPU
Modifications majeures de l'électronique de contrôle	Remplacement de certains éléments électroniques, si le remplacement affecte sensiblement le fonctionnement	Calibrations manuelles pour améliorer les fidélités
Déplacement du QPU vers un nouvel emplacement, si des changements de comportement significatifs en résultent	Suppression d'une porte pendant une certaine durée en raison de problèmes de calibration, et les corrections ne peuvent pas être facilement effectuées dans le logiciel	Petits changements électroniques qui n'affectent pas le fonctionnement
	Changement de la direction d'une porte CNOT

Instructions prises en charge

Chaque famille de processeurs prend en charge nativement un ensemble limité d'instructions. Cet ensemble comprend des portes à un et deux qubits, ainsi que des opérations non unitaires telles que measure et reset. Chaque porte dans le circuit doit être traduite (par le transpiler) vers les éléments du jeu d'instructions pris en charge d'une QPU avant de pouvoir s'exécuter sur la QPU.

Tu peux voir les jeux d'instructions pris en charge pour une QPU avec Qiskit. La page Ressources de calcul d'IBM Quantum Platform liste uniquement les portes unitaires prises en charge (portes de base) pour une QPU.

Trouver les instructions prises en charge avec Qiskit

Trouver les portes de base sur IBM Quantum Platform

Accède à la page Ressources de calcul pour voir un tableau de toutes les QPU, puis clique sur le nom d'une QPU pour ouvrir sa fiche d'information détaillée. Les portes de base pour cette QPU sont listées dans la section Détails.

Tableau des instructions prises en charge

Catégorie d'opération	Nom
Portes à un qubit	RZ, SX, X, XSlow, ID, delay
Portes à deux qubits	CZ, ECR
Portes fractionnaires	RX (un qubit), RZZ (deux qubits)
Instructions non unitaires	measure, reset, measure_*, reset_*, measure_reset*, delay
Flux de contrôle	if_else (feedforward classique)

from qiskit_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService()
backend = service.least_busy(operational=True, simulator=False)

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

Informations dynamiques du backend

Les backends ont également des propriétés qui changent à chaque calibration du backend, comme la durée de vie des qubits et les taux d'erreur des opérations. Les propriétés du backend sont mises à jour après la fin de la séquence de calibration. Ces propriétés peuvent être utilisées pour optimiser des circuits quantiques ou pour construire des modèles de bruit pour un simulateur classique. Consulte le guide Jobs de calibration pour plus d'informations.

Sur IBM Quantum Platform, tu peux télécharger les données de calibration sous forme de fichier CSV. Clique sur une QPU sur la page Ressources de calcul pour voir sa fiche d'information détaillée, puis clique sur l'icône de téléchargement dans le coin supérieur droit de la section Données de calibration.

Récupérer des données historiques

Tu peux récupérer les données historiques des propriétés du backend dans Qiskit avec le code suivant :

backend.properties(datetime=<datetime>)

Propriétés des qubits

Accéder à la liste des propriétés des qubits

backend.properties().qubit_property() retourne des informations sur les attributs physiques des qubits. Il contient un dictionnaire de diverses propriétés du qubit, chacune associée à sa valeur et à l'horodatage de la dernière calibration.

Les exemples de code suivants montrent comment lister toutes les propriétés, ou récupérer des propriétés spécifiques, d'un qubit particulier.

Voir les propriétés des qubits

T1 (Temps de relaxation)

Le temps $T_1$ représente la durée moyenne pendant laquelle un qubit reste dans son état excité $|1\rangle$ avant de retomber dans son état fondamental $|0\rangle$ en raison de la relaxation énergétique. Ce paramètre est utilisé pour caractériser le comportement de relaxation énergétique du qubit, et est exprimé en unités de secondes (s).

Voir avec Qiskit	backend.properties().t1(<qubit>)
Voir sur IBM Quantum Platform	Section Données de calibration : menu déroulant qubit ; trouve la valeur médiane $T_1$ dans la section Détails

T2 (Dephasing time)

Le temps $T_2$ désigne l'échelle de temps sur laquelle un qubit maintient la cohérence de phase d'une superposition entre les états $|0\rangle$ et $|1\rangle$. Il tient compte à la fois de la relaxation énergétique et des processus de déphasage pur, offrant un aperçu des propriétés de cohérence du qubit. $T_2$ est rapporté à partir d'une séquence d'écho de Hahn.

Voir avec Qiskit	backend.properties().t2(<qubit>)
Voir sur IBM Quantum Platform	Section Données de calibration, menu déroulant qubit ; trouve la valeur médiane $T_2$ dans la section Détails

# fundamental physical properties of qubit 1

backend = service.least_busy(operational=True, simulator=False)

backend.qubit_properties(1)

QubitProperties(t1=0.00022010760855770256, t2=0.0002363339150114578, frequency=None)

# Retrieve qubit properties
qubit_index = backend.num_qubits - 1  # 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")

Propriétés des instructions

Accéder à la liste des propriétés des instructions

L'attribut backend.target est un objet qiskit.transpiler.Target : un objet qui contient toutes les informations nécessaires pour transpiler un circuit pour ce backend. Cela inclut les erreurs et les durées des instructions. Par exemple, la cellule suivante obtient les propriétés d'une porte cz agissant entre une paire connectée de qubits.

La cellule suivante montre les propriétés d'une opération de mesure (y compris l'erreur de lecture) sur le qubit 0.

Voir les propriétés des instructions

prob-meas0-prep1

Ce paramètre indique la probabilité de mesurer un qubit dans l'état $|0\rangle$ alors qu'il était prévu de le préparer dans l'état $|1\rangle$, noté $P(0 | 1)$. Il reflète les erreurs de préparation d'état et de mesure (SPAM), notamment les erreurs de mesure dans les qubits supraconducteurs.

Voir avec Qiskit	backend.properties().qubit_property(<qubit>, 'prob_meas0_prep1')
Voir sur IBM Quantum Platform	Section de données de calibration : menu déroulant Qubit

prob-meas1-prep0

De même, ce paramètre représente la probabilité de mesurer un qubit dans l'état $|1\rangle$ alors qu'il était prévu de le préparer dans l'état $|0\rangle$, noté $P(1 | 0)$. Comme prob_meas0_prep1, il reflète les erreurs SPAM, les erreurs de mesure étant le contributeur prédominant dans les qubits supraconducteurs.

Voir avec Qiskit	backend.properties().qubit_property(<qubit>, 'prob_meas0_prep0')
Voir sur IBM Quantum Platform	Section Données de calibration : menu déroulant Qubit

Erreur 2Q (Heron et Nighthawk : CZ, Eagle : ECR)

L'erreur à deux qubits par arête provenant du même lot de mesures utilisé pour calculer l'erreur 2Q médiane. Erreur 2Q (meilleure) fait référence à l'erreur à deux qubits la plus faible sur n'importe quelle arête du dispositif, également issue de ce lot de mesures.

Voir avec Qiskit	backend.target['<instruction>'][<qubit 1>, <qubit 2>]
Voir sur IBM Quantum Platform	Section Calibration : survole la connexion entre qubits en vue Carte, ou trouve la valeur en vue Tableau dans la colonne Erreur CZ (Heron et Nighthawk) ou Erreur ECR (Eagle) ; trouve la valeur de Erreur 2Q (meilleure) dans la section Détails

Erreur 2Q médiane (Heron : CZ, Eagle : ECR)

Fidélité moyenne des portes de l'opération à deux qubits obtenue par benchmarking randomisé. Mesurée en « isolation » : lots avec une séparation minimale de deux qubits entre les arêtes. Ce benchmarking randomisé utilise des couches alternées de Cliffords à un qubit et de portes à deux qubits, et donc la valeur finale de l'erreur 2Q inclut l'erreur de la couche de Cliffords à un qubit.

Calculer avec Qiskit	Suis l'exemple dans ce notebook GitHub Qiskit Community
Voir sur IBM Quantum Platform	Section Détails ; les données par arête se trouvent aussi dans la section Données de calibration

Erreur 2Q (en couches)

Erreur moyenne par porte en couches (EPLG) dans une chaîne de 100 qubits. L'EPLG moyen mesure l'erreur de porte moyenne dans une chaîne en couches de $N$ qubits ($N$=100 ici). Elle est dérivée d'une quantité similaire connue sous le nom de fidélité de couche (LF) où EPLG$_{100}$ = 4/5(1-LF$^{\frac{1}{99}}$) et la fidélité de couche est la fidélité de processus de la chaîne en couches de $N$ qubits. Pour plus de détails, consulte l'article Benchmarking quantum processor performance at scale. Note que dans l'article, l'EPLG est défini pour l'erreur de processus, mais par souci de cohérence avec les erreurs de porte rapportées individuellement, elle est exprimée pour l'erreur de porte moyenne, d'où le facteur de 4/5.

Sur IBM Quantum Platform, la fiche d'information détaillée de chaque QPU comporte une section appelée Two-qubit gate error (layered), qui fournit la vue détaillée de la valeur la plus basse de two-qubit gate error (layered) mesurée en fonction du nombre de qubits dans la chaîne. La valeur finale, pour une longueur de chaîne de 100, est la valeur présentée dans la section Details. En pratique, six chaînes de 100 qubits (présélectionnées en fonction de la performance optimale attendue) sont mesurées, et la valeur indiquée pour un nombre de qubits N est l'erreur la plus basse trouvée sur une sous-chaîne de longueur N en parcourant les six chaînes de 100 qubits.

Calculer avec Qiskit	Suis l'exemple dans ce notebook GitHub Qiskit Community
Voir sur IBM Quantum Platform	Section Détails, avec une vue développée dans la section Erreur de porte à deux qubits (en couches)

Erreur RZZ (Heron)

Erreur dans la porte RZZ moyennée sur les angles RZZ en utilisant une variante du benchmarking randomisé pour les unitaires arbitraires.

Voir avec Qiskit	Important : assure-toi d'avoir défini use_fractional_gates=True lors du chargement du backend, tu peux ensuite utiliser backend.target['rzz'][<qubit 1>, <qubit 2>]
Voir sur IBM Quantum Platform	Section Calibration : sélectionne RZZ dans le menu déroulant Connexion et survole la connexion entre qubits en vue Carte. Tu peux aussi sélectionner Erreur RZZ dans le menu déroulant de sortie du Graphique en vue Graphique, ou trouver la valeur en vue Tableau dans la colonne Erreur RZZ

Erreur ID / erreur √x (sx) / erreur Pauli-X / erreur RX

Erreur des portes discrètes à un qubit de durée finie, mesurée par benchmarking randomisé. La séquence de benchmarking randomisé inclut les portes SX, ID et X, et leurs erreurs sont supposées identiques. La porte ID est un délai de durée égale à celle des portes √X et X. La porte RX a également la même durée que les portes √X et X avec une amplitude variable, et est donc rapportée comme ayant la même erreur que ces portes.

Voir avec Qiskit	backend.target['<instruction>'][<qubit 1>, ]
Voir sur IBM Quantum Platform	Section Calibration : menu déroulant qubit

Erreur SX (médiane)

Fidélité de porte moyenne de la porte √X (SX) issue du benchmarking randomisé, mesurée simultanément sur tous les qubits. La séquence de benchmarking randomisé inclut les portes SX, ID et X, et il est supposé que leurs erreurs sont identiques.

Voir sur IBM Quantum Platform	Section Détails

Erreur de rotation autour de l'axe Z (RZ)

Erreur de la porte RZ virtuelle. Rapportée comme étant toujours 0, car ces opérations sont effectuées de manière logicielle.

Voir avec Qiskit	backend.target['<instruction>'][<qubit 1>, ]
Voir sur IBM Quantum Platform	Section Calibration : menu déroulant Connexion

Erreur de lecture

L'erreur de lecture quantifie la probabilité moyenne de mesurer incorrectement l'état d'un qubit. Elle est généralement calculée comme la moyenne de prob_meas0_prep1 et prob_meas1_prep0, fournissant une seule métrique pour la fidélité de mesure.

Voir avec Qiskit	backend.properties().readout_error(<qubit>)
Voir sur IBM Quantum Platform	Section Données de calibration : menu déroulant qubit

Erreur de lecture (médiane)

Fidélité de l'opération de lecture. L'erreur de lecture est mesurée en préparant le qubit dans l'état $|0\rangle$ ($|1\rangle$) et en mesurant la probabilité d'une sortie dans l'état $|1\rangle$ ($|0\rangle$). La valeur rapportée est la moyenne de ces deux erreurs. La médiane est calculée sur tous les qubits.

Voir sur IBM Quantum Platform	Section Données de calibration : section Détails

Durée de la porte à un qubit

Durée d'une opération de porte à un qubit. Remarque : les valeurs affichées sur IBM Quantum Platform sont en nanosecondes. Les valeurs renvoyées par Qiskit sont en secondes.

Voir avec Qiskit	backend.target['<instruction>'][<qubit 1>, ].duration
Voir sur IBM Quantum Platform	Section Calibration : menu déroulant qubit

Durée de la porte (portes 2Q)

Durée de l'opération de porte à deux qubits. Remarque : les valeurs affichées sur IBM Quantum Platform sont en nanosecondes. Les valeurs renvoyées par Qiskit sont en secondes.

Voir avec Qiskit	backend.target['<instruction>'][<qubit 1>, <qubit 2> ].duration
Voir sur IBM Quantum Platform	Section Calibration : menu déroulant qubit

Durée de lecture

La durée de lecture spécifie la durée de l'opération de lecture pour un qubit. Elle mesure le temps entre le début de l'impulsion de mesure et la fin de la numérisation du signal, après quoi le système est prêt pour l'opération suivante. Comprendre ce paramètre est essentiel pour optimiser l'exécution des circuits, en particulier lors de l'utilisation de mesures en cours de circuit.

Voir avec Qiskit	Pour measure : backend.properties().readout_length(<qubit>) Pour measure_2 : backend.target['measure_2'][<qubit 1>, ].duration
Voir sur IBM Quantum Platform	Section Données de calibration : menu déroulant qubit

Erreur d'initialisation

L'erreur d'initialisation quantifie le pourcentage de la population dans l'état $|1\rangle$ après le délai de répétition par défaut et la procédure d'initialisation du qubit, lorsque l'expérience précédente avait préparé le qubit dans l'état $|1\rangle$. Remarque : cette quantité diffère subtilement de la quantité prob_meas1_prep0, qui mesure le pourcentage des mesures attribuées à l'état $|1\rangle$. Cette dernière est une mesure à la fois de l'erreur d'initialisation et de la procédure de discrimination entre les états $|0\rangle$ et $|1\rangle$. Dans la limite d'une mesure parfaite, les deux quantités sont identiques.

Voir avec Qiskit	backend.properties().qubit_property(<qubit>, 'init_error')
Voir sur IBM Quantum Platform	Section Données de calibration: menu déroulant qubit

# Get the cz gate properties for a connected pair of qubits
# (the first edge in this backend's coupling map)
edge = next(iter(backend.target["cz"]))
backend.target["cz"][edge]

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

InstructionProperties(duration=1.66e-06, error=0.0126953125)

Propriétés supplémentaires

Nombre maximal de circuits par seconde (MCPS)

Le nombre maximal de circuits par seconde (MCPS) inclut la mesure, la réinitialisation et la reconfiguration d'un circuit avec une porte de Hadamard et une seule mesure.

Voir avec Qiskit	mcps = backend.configuration().mcps
Voir sur IBM Quantum Platform	Section Détails

CLOPS (ou CLOPS_h)

Le nombre d'opérations de couches de circuit par seconde (CLOPS) mesure combien de couches d'un circuit 100x100 (circuit adapté au matériel) un QPU peut exécuter par unité de temps.

Calculer avec Qiskit	Retrouve le code CLOPS sur le GitHub Qiskit Community
Voir sur IBM Quantum Platform	Section Détails

Statut

Avec BackendStatus, tu peux trouver le statut du QPU (par exemple, Active, Paused, Offline) ainsi que le nombre de tâches en attente.

Voir avec Qiskit	print(backend.status().status_msg), print(backend.status().pending_jobs)
Voir sur IBM Quantum Platform	Section Détails

Diagramme de topologie ou carte de couplage

Un diagramme qui indique les paires de qubits prenant en charge des opérations de porte à deux qubits entre elles. On l'appelle aussi la carte de couplage ou connectivité. Les qubits sont représentés par des cercles et les opérations de porte à deux qubits prises en charge sont affichées sous forme de lignes reliant les qubits.

Voir avec Qiskit	from qiskit.visualization import plot_gate_map puis plot_gate_map(backend)
Voir sur IBM Quantum Platform	Section Données de calibration ; clique sur Développer pour une vue agrandie

Que signifie `error = 1` ?

Si le benchmarking d'un qubit ou d'une arête ne réussit pas pendant plusieurs jours, que ce soit en raison d'une mauvaise qualité des données ou d'autres facteurs internes, la valeur d'erreur rapportée est considérée comme obsolète et sera indiquée comme 1. Cela ne signifie pas nécessairement que le qubit ou l'arête ne fonctionne pas, ni que l'erreur vaut réellement 1 ; l'erreur est plutôt considérée comme indéfinie, et tu dois faire preuve de prudence lors de l'utilisation de ce qubit ou de cette porte.

Étapes suivantes

Recommandations

• Apprends à créer des modèles de bruit pour effectuer une simulation classique bruitée.
• Consulte la rubrique Étapes du transpiler pour apprendre comment le transpiler utilise les propriétés du backend pour l'optimisation des circuits.
• Consulte la référence de l'API backend QiskitRuntime.