Representa los ordenadores cuánticos para el transpilador

• Versiones del paquete

  El código de esta página se ha desarrollado teniendo en cuenta los siguientes requisitos. Recomendamos utilizar estas versiones o versiones más recientes.

  qiskit[all]~=2.5.0
  qiskit-ibm-runtime~=0.47.0
  

Para convertir un circuito abstracto en un circuito ISA que pueda ejecutarse en una QPU (unidad de procesamiento cuántico) específica, el transpilador necesita cierta información sobre la QPU. Esta información se encuentra en dos lugares: el objeto BackendV2 (o legado BackendV1) al que planea enviar trabajos, y el atributo Target del backend.

• El Target contiene todas las restricciones relevantes de un dispositivo, como el conjunto de instrucciones que admite, la conectividad de qubits y la información sobre pulsos o sincronización.
• El Backend posee un Target por defecto, contiene información adicional, como el InstructionScheduleMap, y proporciona la interfaz para enviar trabajos de circuitos cuánticos.

También puedes proporcionar explícitamente información para que el transpilador la utilice, por ejemplo, si tienes un caso de uso específico, o si crees que esta información ayudará al transpilador a generar un circuito más optimizado.

La precisión con la que el transpilador produce el circuito más adecuado para un hardware específico depende de la información que Target o Backend tengan sobre sus restricciones.

En esta página se muestran varios ejemplos de cómo pasar información de la QPU al transpilador.

Configuración predeterminada

El uso más sencillo del transpilador es proporcionar toda la información de la QPU mediante Backend o Target. Para entender mejor cómo funciona el transpilador, construye un circuito y transpílalo con información diferente, como se indica a continuación.

Importar las bibliotecas necesarias e instanciar la QPU: Para convertir un circuito abstracto en un circuito ISA que pueda ejecutarse en un procesador específico, el transpilador necesita cierta información sobre el procesador. Normalmente, esta información se almacena en el archivo Backend o Target proporcionado al transpilador, y no se necesita más información. Sin embargo, también puedes proporcionar explícitamente información para que el transpilador la utilice, por ejemplo, si tienes un caso de uso específico, o si crees que esta información ayudará al transpilador a generar un circuito más optimizado.

En este tema se muestran varios ejemplos de cómo pasar información al transpilador.

from qiskit_ibm_runtime.fake_provider import FakeSherbrooke

backend = FakeSherbrooke()
target = backend.target

El circuito de ejemplo utiliza una instancia de efficient_su2 de la biblioteca de circuitos de Qiskit.

from qiskit.circuit.library import efficient_su2

qc = efficient_su2(12, entanglement="circular", reps=1)

qc.draw("mpl")

Output:

Este ejemplo utiliza la configuración predeterminada para transpilar a la backend's target, que proporciona toda la información necesaria para convertir el circuito a uno que se ejecutará en el backend.

from qiskit.transpiler import generate_preset_pass_manager

pass_manager = generate_preset_pass_manager(
    optimization_level=1, target=target, seed_transpiler=12345
)
qc_t_target = pass_manager.run(qc)
qc_t_target.draw("mpl", idle_wires=False, fold=-1)

Output:

Este ejemplo se utiliza en secciones posteriores de este tema para ilustrar que el mapa de acoplamiento y el conjunto de instrucciones compatibles son los datos esenciales que se deben transmitir al transpilador para lograr una construcción óptima del circuito. La QPU normalmente puede seleccionar ajustes predeterminados para otra información que no se transmite, como la sincronización y la programación.

Mapa de acoplamiento

El mapa de acoplamiento es un gráfico que muestra qué qubits están conectados y, por tanto, tienen puertas de dos qubits entre ellos. A veces este gráfico es direccional, lo que significa que las puertas de dos qubits sólo pueden ir en una dirección. Sin embargo, el transpilador siempre puede invertir la dirección de una puerta añadiendo puertas adicionales de un solo qubit. Un circuito cuántico abstracto siempre puede representarse en este grafo, aunque su conectividad sea limitada, introduciendo puertas SWAP para desplazar la información cuántica.

Los qubits de nuestros circuitos abstractos se denominan qubits virtuales y los del mapa de acoplamiento son qubits físicos. El transpilador proporciona una correspondencia entre qubits virtuales y físicos. Uno de los primeros pasos de la transpilación, la fase de maquetación, realiza este mapeo.

Pase el argumento de la palabra clave coupling_map para ver su efecto en el transpilador:

coupling_map = target.build_coupling_map()

pass_manager = generate_preset_pass_manager(
    optimization_level=0, coupling_map=coupling_map, seed_transpiler=12345
)
qc_t_cm_lv0 = pass_manager.run(qc)
qc_t_cm_lv0.draw("mpl", idle_wires=False, fold=-1)

Output:

Como se muestra arriba, se insertaron varias compuertas SWAP (cada una formada por tres compuertas CX), lo que provocará muchos errores en los dispositivos actuales. Para ver qué qubits están seleccionados en la topología qubit real, utilice plot_circuit_layout de Qiskit Visualizations:

from qiskit.visualization import plot_circuit_layout

plot_circuit_layout(qc_t_cm_lv0, backend, view="physical")

Output:

Esto demuestra que nuestros qubits virtuales 0-11 se mapearon trivialmente a la línea de qubits físicos 0-11. Volvamos al valor por defecto (optimization_level=1), que utiliza VF2Layout si se requiere algún enrutamiento.

pass_manager = generate_preset_pass_manager(
    optimization_level=1, coupling_map=coupling_map, seed_transpiler=12345
)
qc_t_cm_lv1 = pass_manager.run(qc)
qc_t_cm_lv1.draw("mpl", idle_wires=False, fold=-1)

Output:

Ahora no hay puertas SWAP insertadas y los qubits físicos seleccionados son los mismos cuando se utiliza la clase target .

from qiskit.visualization import plot_circuit_layout

plot_circuit_layout(qc_t_cm_lv1, backend, view="physical")

Output:

Ahora la disposición es en anillo. Como esta disposición respeta la conectividad del circuito, no hay puertas SWAP, lo que proporciona un circuito mucho mejor para la ejecución.

Instrucciones compatibles

Cada ordenador cuántico admite un conjunto limitado de instrucciones. Cada puerta del circuito debe traducirse a los elementos de este conjunto. Este conjunto debe estar formado por puertas de uno y dos qubits que proporcionen un conjunto de puertas universal, lo que significa que cualquier operación cuántica puede descomponerse en esas puertas. Esto lo realiza BasisTranslator y se basis_gates puede especificar como argumento clave para el transpilador con el fin de proporcionar esta información.

basis_gates = list(target.operation_names)
print(basis_gates)

Output:

['x', 'switch_case', 'for_loop', 'rz', 'sx', 'measure', 'id', 'ecr', 'delay', 'reset', 'if_else']

Las puertas de un solo qubit predeterminadas en FakeSherbrooke son rz, x, y sx, y la puerta de dos qubits predeterminada es ecr (resonancia cruzada con eco). Las puertas CX se construyen a partir de ecr puertas, por lo que en algunas QPU ecr se especifica como la puerta de base de dos qubits, mientras que en otras cx es la opción predeterminada. La ecr puerta es la parte que se entrelaza de la cx puerta. Además de las puertas de control, también hay instrucciones delay measurement y.

pass_manager = generate_preset_pass_manager(
    optimization_level=1,
    coupling_map=coupling_map,
    basis_gates=basis_gates,
    seed_transpiler=12345,
)
qc_t_cm_bg = pass_manager.run(qc)
qc_t_cm_bg.draw("mpl", idle_wires=False, fold=-1)

Output:

Tenga en cuenta que los CXGate objetos se han descompuesto en ecr puertas y puertas de base de un solo qubit.

Tasas de error del dispositivo

La clase Target puede contener información sobre las tasas de error de las operaciones en el dispositivo. Por ejemplo, el siguiente código recupera las propiedades de la puerta de resonancia cruzada con eco (ECR) entre el qubit 1 y el 0 (nótese que la puerta ECR es direccional):

target["ecr"][(1, 0)]

Output:

InstructionProperties(duration=5.333333333333332e-07, error=0.007494257741828603)

La salida muestra la duración de la puerta (en segundos) y su tasa de error. Para revelar la información de error al transpilador, construya un modelo de destino con basis_gates y coupling_map y rellénelo con los valores de error del backend FakeSherbrooke.

from qiskit.transpiler import Target
from qiskit.circuit.controlflow import IfElseOp, SwitchCaseOp, ForLoopOp

err_targ = Target.from_configuration(
    basis_gates=basis_gates,
    coupling_map=coupling_map,
    num_qubits=target.num_qubits,
    custom_name_mapping={
        "if_else": IfElseOp,
        "switch_case": SwitchCaseOp,
        "for_loop": ForLoopOp,
    },
)

for i, (op, qargs) in enumerate(target.instructions):
    if op.name in basis_gates:
        err_targ[op.name][qargs] = target.instruction_properties(i)

Transpile con nuestro nuevo objetivo err_targ como objetivo:

pass_manager = generate_preset_pass_manager(
    optimization_level=1, target=err_targ, seed_transpiler=12345
)
qc_t_cm_bg_et = pass_manager.run(qc)
qc_t_cm_bg_et.draw("mpl", idle_wires=False, fold=-1)

Output:

Dado que el objetivo incluye información de error, el paso VF2PostLayout intenta encontrar los qubits óptimos a utilizar, dando como resultado el mismo circuito que se encontró originalmente con los mismos qubits físicos.

Próximos pasos