Aller au contenu principal

Obtenir des informations sur le backend avec Qiskit

Versions des packages

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

qiskit-ibm-runtime~=0.43.1

Cette page explique comment utiliser Qiskit pour trouver des informations sur les backends auxquels tu as accès.

Lister les backends​

Pour consulter les backends disponibles, tu peux soit afficher la liste sur la page Ressources de calcul, soit utiliser la méthode QiskitRuntimeService.backends(). Cette méthode retourne une liste d'instances IBMBackend :

Notes
  • 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 particulière via QiskitRuntimeService(), seuls les backends disponibles sur cette instance ou région sont retournés. Sinon, tous les backends disponibles sur l'ensemble des instances et régions te sont retournés.
  • La liste des backends retournée peut différer de celle affichée sur la page Ressources de calcul d'IBM Quantum Platform. La liste sur cette page est toujours filtrée selon la région sélectionnée en haut de la page.

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.

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

La méthode QiskitRuntimeService.backend() (note le singulier : backend) prend le nom du backend en paramètre et retourne une instance IBMBackend représentant ce backend en particulier :

service.backend("ibm_fez")
<IBMBackend('ibm_fez')>

Filtrer les backends​

Tu peux également filtrer les backends disponibles selon leurs propriétés. Pour des filtres plus généraux, passe à l'argument filters une fonction qui accepte un objet backend et renvoie True s'il satisfait tes critères. Consulte la documentation de l'API pour plus de détails.

Le code suivant ne retourne que les backends répondant à ces critères et disponibles sur l'instance actuellement sélectionnée :

  • Sont de vrais dispositifs quantiques (simulator=False)
  • Sont actuellement opérationnels (operational=True)
  • Ont au moins 5 qubits (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')>]

Ces arguments nommés permettent de filtrer sur n'importe quel attribut de la configuration (schéma JSON) ou du statut (schéma JSON) du backend. Une méthode similaire est QiskitRuntimeService.least_busy(), qui accepte les mêmes filtres que backends() mais retourne le backend correspondant aux critères avec le moins de jobs en attente dans la file :

service.least_busy(operational=True, min_num_qubits=5)
<IBMBackend('ibm_torino')>

Informations statiques sur le 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 et les types de fonctionnalités qu'il prend en charge. Ces informations sont disponibles en tant qu'attributs de l'objet backend.

La cellule suivante construit une description d'un 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

Pour une liste complète des attributs, consulte la documentation de l'API IBMBackend.

Portes et opérations natives​

Chaque famille de processeurs dispose d'un ensemble de portes natives. Par défaut, les QPUs de chaque famille ne prennent en charge que l'exécution des portes et opérations de cet ensemble natif. Ainsi, chaque porte du circuit doit être traduite (par le transpiler) vers les éléments de cet ensemble.

Tu peux consulter les portes et opérations natives d'un QPU soit avec Qiskit, soit sur la page Ressources de calcul d'IBM Quantum® Platform.


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()

Informations dynamiques sur le backend​

Les backends peuvent également avoir des propriétés qui changent à chaque calibration, comme la fréquence des qubits et les taux d'erreur des opérations. Les backends sont généralement calibrés toutes les 24 heures, et leurs propriétés sont mises à jour à 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 destinés à un simulateur classique.

Propriétés des qubits​

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

  • T1 (Relaxation Time) : Le temps T1 représente la durée moyenne pendant laquelle un qubit reste dans son état excité ∣1⟩|1\rangle avant de retomber dans son état fondamental ∣0⟩|0\rangle par relaxation énergétique. Ce paramètre caractérise le comportement de relaxation énergétique du qubit et s'exprime en secondes (s).

  • T2 (Dephasing Time) : Le temps T2 désigne l'échelle de temps sur laquelle un qubit maintient la cohérence de phase d'une superposition entre les états ∣0⟩|0\rangle et ∣1⟩|1\rangle. Il tient compte à la fois de la relaxation énergétique et des processus de déphasage pur, offrant ainsi un aperçu des propriétés de cohérence du qubit.

  • frequency : Ce paramètre indique la fréquence de résonance du qubit, c'est-à-dire la différence d'énergie entre les états ∣0⟩|0\rangle et ∣1⟩|1\rangle, exprimée en hertz (Hz).

  • anharmonicity : L'anharmonicité est la différence d'énergie entre le premier et le deuxième état excité du qubit, également exprimée en hertz (Hz).

  • readout_error : 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 métrique unique pour la fidélité de mesure.

  • 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 ∣1⟩|1\rangle, notée P(0∣1)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.

  • 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 ∣0⟩|0\rangle, notée P(1∣0)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.

  • readout_length : Le paramètre readout_length spécifie la durée de l'opération de lecture d'un qubit. Il mesure le temps entre l'initiation 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. La compréhension de ce paramètre est essentielle pour optimiser l'exécution des circuits, notamment lors de l'utilisation de mesures mid-circuit.

# 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

Propriétés des instructions​

L'attribut backend.target est un objet qiskit.transpiler.Target : il contient toutes les informations nécessaires pour transpiler un circuit pour ce backend, notamment les erreurs et les durées des instructions. Par exemple, la cellule suivante récupère les propriétés d'une porte cz agissant entre les qubits 1 et 0.

backend.target["cz"][(1, 0)]
InstructionProperties(duration=6.8e-08, error=0.007831625819164134)

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

backend.target["measure"][(0,)]
InstructionProperties(duration=1.56e-06, error=0.013916015625)

Étapes suivantes​

Recommandations