Voir les détails du 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

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() (noter 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 — 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')>]

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

Versionnage des QPU

Chaque QPU possède un numéro de version sous la forme X.Y.Z (majeure.mineure.révision). Un circuit compilé pour un numéro de version donné est garanti de fonctionner sur cette QPU. Si le numéro de révision change, le circuit continuera de fonctionner. Si le numéro majeur ou mineur change, le circuit n'est pas garanti de fonctionner, même si c'est possible.

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

L'exemple de code précédent dans cette section montre comment trouver la version d'un backend. Sur IBM Quantum Platform, tu peux voir la version dans la fiche d'information détaillée d'une QPU (clique sur le nom de la 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
Changements d'échantillon	Cycles de réchauffement / refroidissement	Mises à jour logicielles de la QPU
Changements majeurs de l'électronique de contrôle	Remplacement de certains composants électroniques, si le remplacement affecte sensiblement le fonctionnement	Calibrations manuelles pour améliorer les fidélités
Déplacement de la 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, lorsque les corrections ne peuvent pas facilement être effectuées par logiciel	Petits changements électroniques qui n'affectent pas le fonctionnement
	Changement de direction d'une porte CNOT

Instructions supportées

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 supporté d'une QPU avant de pouvoir s'exécuter sur la QPU.

Tu peux voir les jeux d'instructions supportés pour une QPU avec Qiskit. La page Ressources de calcul d'IBM Quantum Platform liste uniquement les portes unitaires supportées (portes de base) pour une QPU.

Trouver les instructions supportées 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 supportées

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

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

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 décroître vers 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 ; trouver la valeur médiane $T_1$ dans la section Détails

T2 (Temps de déphasage)

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 ; trouver la valeur médiane $T_2$ dans la section Détails

# 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

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 les qubits 1 et 0.

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 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 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 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 issue du même lot de mesures utilisé pour calculer l'erreur médiane 2Q. L'erreur 2Q (meilleure) désigne 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 dans la vue Carte, ou trouve la valeur dans la vue Tableau sous la colonne Erreur CZ (Heron et Nighthawk) ou Erreur ECR (Eagle) ; trouve la valeur Erreur 2Q (meilleure) dans la section Détails

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

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

Calculer avec Qiskit	Suis l'exemple dans ce notebook GitHub de la communauté Qiskit
Voir sur IBM Quantum Platform	Section Détails ; trouver également les données par arête 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 intitulée Erreur de porte à deux qubits (en couches), qui fournit la vue étendue de l'erreur de porte à deux qubits (en couches) la plus faible, mesurée en fonction du nombre de qubits dans la chaîne. La valeur finale, à une longueur de chaîne de 100, est la valeur présentée dans la section Détails. En pratique, six chaînes de 100 qubits (présélectionnées sur la base des performances optimales attendues) sont mesurées, et la valeur rapportée pour un nombre de qubits N est l'erreur la plus faible trouvée dans une sous-chaîne de longueur N en cherchant parmi les six chaînes de 100 qubits.

Calculer avec Qiskit	Suis l'exemple dans ce notebook GitHub de la communauté Qiskit
Voir sur IBM Quantum Platform	Section Détails, et une vue étendue 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 aléatoire pour les unitaires arbitraires.

Voir avec Qiskit	Important : assure-toi d'avoir défini use_fractional_gates=True lors du chargement du backend, puis tu peux 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 dans la vue Carte. Tu peux également sélectionner l'erreur RZZ dans le menu déroulant de sortie du Graphe dans la vue Graphe, ou trouver la valeur dans la vue Tableau sous la colonne Erreur RZZ

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

Erreur dans les portes à un qubit discrètes de durée finie, mesurée par benchmarking aléatoire. La séquence de benchmarking aléatoire inclut les portes SX, ID et X, et il est supposé que leurs erreurs sont identiques. La porte ID est un délai d'une durée égale à la durée 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 aléatoire, mesurée simultanément sur tous les qubits. La séquence de benchmarking aléatoire 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 sur l'axe Z (RZ)

Erreur dans la porte RZ virtuelle. Rapportée comme étant toujours 0 car ces opérations sont effectuées par logiciel.

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 couramment calculée comme la moyenne de prob_meas0_prep1 et prob_meas1_prep0, fournissant une métrique unique 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 (1) et en mesurant la probabilité d'un résultat dans l'état 1 (0). 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 porte à un qubit

Durée d'une opération de porte à un seul qubit. Note que les valeurs affichées sur IBM Quantum Platform sont en nanosecondes. Les valeurs retournées dans 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 porte (portes 2Q)

Durée de l'opération de porte à deux qubits. Note que les valeurs affichées sur IBM Quantum Platform sont en nanosecondes. Les valeurs retournées dans 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 depuis le début de l'impulsion de mesure jusqu'à 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 crucial pour optimiser l'exécution des circuits, en particulier lors de l'intégration 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

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)

Propriétés supplémentaires

CLOPS (ou CLOPS_h)

Les opérations de couche de circuit par seconde (CLOPS) mesurent le nombre de couches d'un circuit 100x100 (circuit adapté au matériel) qu'une QPU peut exécuter par unité de temps.

Calculer avec Qiskit	Trouve le code CLOPS dans le GitHub de la communauté Qiskit
Voir sur IBM Quantum Platform	Section Détails

Statut

Avec BackendStatus, tu peux trouver le statut de la QPU (par exemple, Active, Paused, Offline) ainsi que le nombre de jobs 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 supportant des opérations de porte à deux qubits entre eux. C'est également appelé la carte de couplage ou connectivité. Les qubits sont représentés par des cercles et les opérations de porte à deux qubits supportées 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 Agrandir pour une vue plus grande

Que signifie `error = 1` ?

Si le benchmarking d'un qubit ou d'une arête n'aboutit pas sur 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 périmée et sera indiquée comme 1. Ce n'est pas une indication que le qubit ou l'arête est nécessairement non fonctionnel ou que l'erreur est 1 ; plutôt, l'erreur est considérée comme indéfinie et tu dois procéder avec 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.