Obtener información del backend con Qiskit

Versiones de paquetes

El código de esta página fue desarrollado con los siguientes requisitos. Recomendamos usar estas versiones o más recientes.

qiskit-ibm-runtime~=0.43.1

Esta página explica cómo usar Qiskit para encontrar información sobre tus backends disponibles.

Listar backends

Para ver los backends a los que tienes acceso, puedes consultar la lista en la página de Recursos de cómputo, o usar el método QiskitRuntimeService.backends(). Este método devuelve una lista de instancias de IBMBackend:

Notas

Si has iniciado sesión en una instancia o región específica, o si inicializaste el servicio con una instancia o región específica usando QiskitRuntimeService(), solo se devuelven los backends disponibles para ti en esa instancia o región. De lo contrario, se devuelven todos los backends disponibles para ti en cualquier instancia y región.
La lista de backends devuelta puede no coincidir con la que se muestra en la página de Recursos de cómputo de IBM Quantum Platform. La lista en la página de Recursos de cómputo siempre se filtra según la región seleccionada en la parte superior de la página.

Para ejecutar el siguiente código, asegúrate de haberte autenticado previamente en el servicio. Consulta Configura tu cuenta de IBM Cloud para más detalles.

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

El método QiskitRuntimeService.backend() (nota que es singular: backend) recibe el nombre del backend como parámetro de entrada y devuelve una instancia de IBMBackend que representa ese backend en particular:

service.backend("ibm_fez")

<IBMBackend('ibm_fez')>

Filtrar backends

También puedes filtrar los backends disponibles por sus propiedades. Para filtros más generales, asigna al argumento filters una función que acepte un objeto backend y devuelva True si cumple tus criterios. Consulta la documentación de la API para más detalles.

El siguiente código devuelve solo los backends que cumplen estos criterios y están disponibles para ti en la instancia actualmente seleccionada:

Son dispositivos cuánticos reales (simulator=False)
Están operativos en este momento (operational=True)
Tienen al menos 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')>]

Usa estos argumentos de palabra clave para filtrar por cualquier atributo en la configuración del backend (esquema JSON) o en el estado (esquema JSON). Un método similar es QiskitRuntimeService.least_busy(), que acepta los mismos filtros que backends() pero devuelve el backend que cumple los filtros y tiene el menor número de trabajos pendientes en la cola:

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

<IBMBackend('ibm_torino')>

Información estática del backend

Cierta información sobre un backend no cambia con frecuencia, como su nombre, versión, número de qubits y los tipos de funcionalidades que admite. Esta información está disponible como atributos del objeto backend.

La siguiente celda construye una descripción de 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

Para una lista completa de atributos, consulta la documentación de la API de IBMBackend.

Gates y operaciones nativas

Cada familia de procesadores tiene un conjunto nativo de gates. Por defecto, los QPUs de cada familia solo admiten la ejecución de los gates y operaciones del conjunto nativo. Por lo tanto, cada gate del Circuit debe traducirse (mediante el Transpiler) a los elementos de ese conjunto.

Puedes ver los gates y operaciones nativas de un QPU con Qiskit, o en la página de Recursos de cómputo de 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()

Información dinámica del backend

Los backends también pueden tener propiedades que cambian cada vez que se calibran, como la frecuencia de los qubits y las tasas de error de las operaciones. Los backends suelen calibrarse cada 24 horas y sus propiedades se actualizan tras completar la secuencia de calibración. Estas propiedades pueden usarse para optimizar circuitos cuánticos o para construir modelos de ruido para un simulador clásico.

Propiedades de los qubits

El método backend.properties().qubit_property() devuelve información sobre los atributos físicos de los qubits. Contiene un diccionario con diversas propiedades del Qubit, cada una emparejada con su valor y la marca de tiempo de la última calibración.

T1 (Tiempo de relajación): El tiempo T1 representa la duración promedio que un Qubit permanece en su estado excitado $|1\rangle$ antes de decaer a su estado fundamental $|0\rangle$ debido a la relajación de energía. Este parámetro se usa para caracterizar el comportamiento de relajación de energía del Qubit y se expresa en segundos (s).
T2 (Tiempo de desfase): El tiempo T2 indica la escala de tiempo durante la cual un Qubit mantiene la coherencia de fase de una superposición entre los estados $|0\rangle$ y $|1\rangle$ . Tiene en cuenta tanto la relajación de energía como los procesos de desfase puro, lo que proporciona información sobre las propiedades de coherencia del Qubit.
frequency: Este parámetro especifica la frecuencia de resonancia del Qubit, indicando la diferencia de energía entre los estados $|0\rangle$ y $|1\rangle$ , expresada en hercios (Hz).
anharmonicity: La anarmonicidad es la diferencia de energía entre el primer y el segundo estado excitado del Qubit, también expresada en hercios (Hz).
readout_error: El error de lectura cuantifica la probabilidad promedio de medir incorrectamente el estado de un Qubit. Normalmente se calcula como la media de prob_meas0_prep1 y prob_meas1_prep0, proporcionando una única métrica para la fidelidad de medición.
prob_meas0_prep1: Este parámetro indica la probabilidad de medir un Qubit en el estado 0 cuando se pretendía prepararlo en el estado $|1\rangle$ , denotada como $P(0 | 1)$ . Refleja errores en la preparación y medición de estados (SPAM), especialmente errores de medición en qubits superconductores.
prob_meas1_prep0: De manera similar, este parámetro representa la probabilidad de medir un Qubit en el estado 1 cuando se pretendía prepararlo en el estado $|0\rangle$ , denotada como $P(1 | 0)$ . Al igual que prob_meas0_prep1, refleja errores SPAM, siendo los errores de medición el contribuyente predominante en qubits superconductores.
readout_length: El parámetro readout_length especifica la duración de la operación de lectura de un Qubit. Mide el tiempo desde el inicio del pulso de medición hasta la finalización de la digitalización de la señal, después de lo cual el sistema está listo para la siguiente operación. Comprender este parámetro es fundamental para optimizar la ejecución de circuitos, especialmente cuando se incorporan mediciones en mitad del 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

Propiedades de instrucciones

El atributo backend.target es un objeto qiskit.transpiler.Target: un objeto que contiene toda la información necesaria para transpilar un Circuit para ese backend. Esto incluye los errores y duraciones de las instrucciones. Por ejemplo, la siguiente celda obtiene las propiedades de un gate cz que actúa entre los qubits 1 y 0.

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

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

La siguiente celda muestra las propiedades de una operación de medición (incluyendo el error de lectura) en el Qubit 0.

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

InstructionProperties(duration=1.56e-06, error=0.013916015625)

Próximos pasos

Recomendaciones

Prueba el tutorial del algoritmo de Grover.
Consulta la referencia de la API del backend de QiskitRuntime.

Listar backends​

Filtrar backends​

Información estática del backend​

Gates y operaciones nativas​

Información dinámica del backend​

Propiedades de los qubits​

Propiedades de instrucciones​

Próximos pasos​