Afficher les détails du backend

• Versions de package

  Le code figurant sur cette page a été développé selon 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 vos backends disponibles.

Liste ou filtre des backends

Liste des backends disponibles

Vous pouvez utiliser Qiskit ou IBM Quantum Platform pour afficher la liste des backends disponibles ou rechercher un backend particulier.

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

Backends de filtrage

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

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

<IBMBackend('ibm_fez')>

Informations statiques sur le backend

Certaines informations relatives à un backend ne changent pas régulièrement, telles que son nom, sa version, le nombre de qubits dont il dispose, 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 sous forme d'attributs de backend l'objet. Pour obtenir la liste complète des attributs, consultez la IBMBackend documentation API. Pour plus d'informations sur la gestion des versions, consultez la section Gestion des versions QPU ci-dessous.

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

backend = service.backend("ibm_fez")

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

Gestion des versions QPU

Chaque QPU possède un numéro de version sous la forme X.Y.Z ( major.minor.revision ). Un circuit compilé pour un numéro de version donné est garanti de fonctionner sur ce QPU. Si le numéro de révision change, le circuit continuera à fonctionner. Si le numéro majeur ou mineur change, le circuit n'est pas garanti de fonctionner, bien qu'il puisse le faire.

Le numéro de version de révision augmentera pour les corrections qui ne perturbent pas le circuit compilé existant.

L'exemple de code présenté plus haut dans cette section montre comment trouver la version d'un backend. Sur IBM Quantum Platform, vous pouvez consulter la version sur la fiche d'informations détaillées d'un QPU (cliquez sur le nom du QPU dans le tableau des ressources de calcul pour ouvrir la fiche).

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

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 la mesure et la réinitialisation. Chaque porte du circuit doit être traduite (par le transcompilateur) en éléments du jeu d'instructions pris en charge par le QPU avant de pouvoir être exécutée sur le QPU.

Vous pouvez consulter les jeux d'instructions pris en charge pour un QPU avec Qiskit. La page Ressources de calcul de l' IBM Quantum Platform répertorie uniquement les portes unitaires (portes de base) prises en charge par un QPU.

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

Tableau des instructions prises en charge

Informations dynamiques sur le backend

Les backends ont également des propriétés qui changent à chaque fois que le backend est calibré, telles que la durée de vie des qubits et les taux d'erreur de fonctionnement. Les propriétés du backend sont mises à jour une fois la séquence d'étalonnage terminée. Ces propriétés peuvent être utilisées pour optimiser les circuits quantiques ou pour construire des modèles de bruit pour un simulateur classique. Consultez le guide des tâches d'étalonnage pour plus d'informations.

Sur IBM Quantum Platform, vous pouvez télécharger les données d'étalonnage sous forme de fichier CSV. Cliquez sur un QPU dans la page Ressources de calcul pour afficher sa fiche d'informations détaillées, puis cliquez sur l'icône de téléchargement dans le coin supérieur droit de la section Données d'étalonnage.

backend.properties(datetime=<datetime>)

Propriétés des qubits

Aller à la liste des propriétés des qubits

backend.properties().qubit_property() renvoie des informations sur les attributs physiques des qubits. Il contient un dictionnaire des différentes propriétés du qubit, chacune étant associée à sa valeur et à l'horodatage du dernier étalonnage.

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.

# fundamental physical properties of qubit 1

backend = service.backend("ibm_fez")

backend.qubit_properties(1)

Output:

QubitProperties(t1=0.00019233494213807877, t2=0.00023593910973864878, 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")

Output:

Qubit 126 Properties:
  T1: 1.6203279905573543e-05 seconds
  T2: 2.7965850265833494e-05 seconds
  Readout Error: 0.0601806640625
  P(0 | 1): 0.0908203125
  P(1 | 0): 0.029541015625
  Readout Length: 1.66e-06 seconds

Afficher les propriétés du qubit

• T1 (Temps de détente)

  Le temps d' $T_1$ e représente la durée moyenne pendant laquelle un qubit reste dans son état excité $|1\rangle$ avant de revenir à 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 secondes (s).

  Afficher avec Qiskit	backend.properties().t1(<qubit>)
  Voir sur IBM Quantum Platform	Section Données d'étalonnage, menu déroulant Qubit; recherchez la valeur médiane de l' $T_1$ e dans la section Détails

• T2 (Temps de déphasage)

  Le temps d' $T_2$ désigne la durée pendant 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 des processus de relaxation énergétique et de déphasage pur, fournissant ainsi des informations sur les propriétés de cohérence du qubit. Une résonance de phase ( $T_2$ ) est rapportée à partir d'une séquence d'écho de Hahn.

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

Propriétés de l'instruction

Aller à la liste des propriétés d'instruction

L'attribut backend.target est un qiskit.transpiler.Target objet : un objet qui contient toutes les informations nécessaires pour transcompiler un circuit pour ce backend. Cela inclut les erreurs d'instruction et les durées. Par exemple, la cellule suivante obtient les propriétés d'un cz portail agissant entre les qubits 1 et 0.

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

Output:

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

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

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

Output:

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

Afficher les propriétés de l'instruction

• prob-meas0-prep1

  Ce paramètre indique la probabilité de mesurer un qubit dans l'état 0 alors qu'il était censé être préparé dans l'état d' $|1\rangle$, désigné par le terme « $P(0 | 1)$ » (probabilité de mesure incorrecte). Il reflète les erreurs dans la préparation et la mesure des états (SPAM), en particulier les erreurs de mesure dans les qubits supraconducteurs.

  Afficher avec Qiskit	backend.properties().qubit_property(<qubit>, 'prob_meas0_prep1')
  Voir sur IBM Quantum Platform	Section Données d'étalonnage, 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 censé être préparé dans l'état d' $|0\rangle$, noté $P(1 | 0)$. Comme prob_meas0_prep1, il reflète les erreurs SPAM, les erreurs de mesure étant le facteur prédominant dans les qubits supraconducteurs.

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

• 2Q erreur (Héron et Engoulevent : CZ, Aigle : ECR)

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

  Afficher avec Qiskit	backend.target['<instruction>'][<qubit 1>, <qubit 2>]
  Voir sur IBM Quantum Platform	Section Calibration (Calibrage) : passez la souris sur la connexion qubit dans la vue Map (Carte), ou recherchez la valeur dans la vue Table (Tableau) sous la colonne CZ error (Erreur CZ) (Heron et Nighthawk) ou ECR error (Erreur ECR) (Eagle); recherchez la valeur pour l'erreur d' 2Q e (meilleure) dans la section Details (Détails)

• Erreur médiane d' 2Q ion (Héron : CZ, Aigle : ECR)

  Fidélité moyenne de la porte de l'opération à deux qubits à partir d'un benchmark aléatoire. Mesuré en « isolement » : lots avec une séparation minimale de deux qubits entre les bords. Ce benchmarking aléatoire utilise des couches alternées de portes Clifford à un seul qubit et de portes à deux qubits. La valeur finale de l'erreur d' 2Q ion inclut donc l'erreur de la couche de portes Clifford à un seul qubit.

  Calculer avec Qiskit	Suivez l'exemple dans ce notebook de la communauté Qiskit GitHub
  Voir sur IBM Quantum Platform	Section Détails; vous trouverez également les données par arête dans la section Données d'étalonnage

• Erreur 2Q (en couches)

  Erreur moyenne par porte superposée (EPLG) dans une chaîne de 100 qubits. L'EPLG moyen mesure l'erreur moyenne de porte dans une chaîne stratifiée de qubits d' $N$ s (ici, $N$ = 100). Elle est dérivée d'une quantité similaire appelée fidélité de couche (LF), où EPLG $_{100}$ = 4/5(1-LF $^{\frac{1}{99}}$ ) et où la fidélité de couche est la fidélité de processus de la chaîne de qubits d' $N$ s en couches. Pour plus de détails, consultez l'article Benchmarking quantum processor performance at scale (Évaluation comparative des performances des processeurs quantiques à grande échelle). Il convient de noter que dans l'article, l'EPLG est défini pour l'erreur de processus, mais par souci de cohérence avec les erreurs de grille rapportées individuellement, il est ici cité pour l'erreur de grille moyenne, d'où le facteur 4/5.

  Sur IBM Quantum Platform, la fiche d'informations détaillées pour chaque QPU comporte une section intitulée « Two-qubit gate error (layered) » (Erreur de porte à deux qubits (en couches)), qui fournit une vue détaillée de la valeur la plus basse 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 Détails. En pratique, six chaînes de 100 qubits (présélectionnées en fonction des performances optimales attendues) sont mesurées, et la valeur indiquée pour le nombre de qubits N est l'erreur la plus faible trouvée dans une chaîne de N longueur sous-ensemble recherchant parmi les six chaînes de 100 qubits.

  Calculer avec Qiskit	Suivez l'exemple dans ce notebook de la communauté Qiskit GitHub
  Voir sur IBM Quantum Platform	Section Détails et vue agrandie dans la section Erreur de porte à deux qubits (en couches)

• Erreur RZZ (Héron)

  Erreur dans la porte RZZ moyennée sur les angles RZZ à l'aide d'une variante du benchmarking aléatoire pour les unitaires arbitraires.

  Afficher avec Qiskit	Important : assurez-vous d'avoir défini use_fractional_gates=True lorsque vous chargez le backend, vous pourrez alors utiliser backend.target['rzz'][<qubit 1>, <qubit 2>]
  Voir sur IBM Quantum Platform	Section Calibration : sélectionnez RZZ dans le menu déroulant Connection et passez la souris sur la connexion qubit dans la vue Map. Vous pouvez également sélectionner l'erreur RZZ dans le menu déroulant Sortie graphique de la vue Graphique, ou trouver la valeur dans la vue Tableau sous la colonne Erreur RZZ

• Erreur d'identification / erreur √x (sx) / erreur de Pauli-X / erreur RX

  Erreur dans les portes quantiques discrètes à durée finie d'un qubit, mesurée à partir d'un benchmark aléatoire. La séquence de benchmarking aléatoire comprend les portes SX, ID et X, et on suppose que leurs erreurs sont identiques. La porte ID est un retard dont la durée est é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 à amplitude variable, et elle est donc signalée comme ayant la même erreur que ces portes.

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

• Erreur SX (médiane)

  Fidélité moyenne de la porte √X (SX) issue d'un benchmark aléatoire, mesurée simultanément sur tous les qubits. La séquence de benchmarking aléatoire comprend les portes SX, ID et X, et on suppose que leurs erreurs sont identiques.

  Voir sur IBM Quantum Platform	Section Détails

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

  Erreur dans la porte virtuelle RZ. Tous indiqués comme 0, car ils sont effectués dans le logiciel.

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

• Erreur de lecture

  L'erreur de lecture quantifie la probabilité moyenne de mesurer incorrectement l'état d'un qubit. Il est généralement calculé comme la moyenne de prob_meas0_prep1 et prob_meas1_prep0, fournissant ainsi un indicateur unique pour mesurer la fidélité.

  Afficher avec Qiskit	backend.properties().readout_error(<qubit>)
  Voir sur IBM Quantum Platform	Section Données d'étalonnage, 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'une sortie dans l'état 1 (0). La valeur indiquée correspond à la moyenne de ces deux erreurs. La médiane est calculée sur l'ensemble des qubits.

  Voir sur IBM Quantum Platform	Section Données d'étalonnage, section Détails

• Longueur de la porte à un qubit

  Durée d'une opération de porte à un seul qubit. Veuillez noter que les valeurs indiquées sur IBM Quantum Platform sont exprimées en nanosecondes. Les valeurs renvoyées dans Qiskit sont exprimées en secondes.

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

• Longueur de porte (portes 2Q )

  Durée de l'opération de la porte à deux qubits. Veuillez noter que les valeurs indiquées sur IBM Quantum Platform sont exprimées en nanosecondes. Les valeurs renvoyées dans Qiskit sont exprimées en secondes.

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

• Longueur de lecture

  La longueur de lecture spécifie la durée de l'opération de lecture pour un qubit. Il mesure le temps écoulé 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. Il est essentiel de comprendre ce paramètre pour optimiser l'exécution des circuits, en particulier lorsque des mesures sont intégrées à mi-circuit.

  Afficher 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 d'étalonnage, menu déroulant Qubit

Propriétés supplémentaires

• Nombre maximal de cycles par seconde (MCPS)

  Le nombre maximal de circuits par seconde (MCPS) comprend la mesure, la réinitialisation et la réinitialisation d'un circuit à l'aide d'une porte de Hadamard et d'une seule mesure.

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

• CLOPS (ou CLOPS_h)

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

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

• Statut

  Avec BackendStatus, vous pouvez trouver l'état du QPU (par exemple, Active, Paused, Offline) ainsi que le nombre de tâches en attente.

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

• Schéma topologique ou carte de couplage

  Un diagramme qui indique les paires de qubits qui prennent en charge les opérations de porte à deux qubits entre elles. On parle également de carte de couplage ou de 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.

  Afficher avec Qiskit	from qiskit.visualization import plot_gate_map Ensuite plot_gate_map(backend)
  Voir sur IBM Quantum Platform	Section des données d'étalonnage; cliquez sur « Agrandir » pour obtenir une vue plus grande

Etapes suivantes