El transpilador impulsado por IA pasa

Las etapas de transpilación basadas en IA son etapas que sirven como sustituto directo de las etapas «tradicionales» de Qiskit para algunas tareas de transpilación. A menudo ofrecen mejores resultados que los algoritmos heurísticos existentes (por ejemplo, una menor profundidad y un menor número de CNOT), pero también son mucho más rápidos que los algoritmos de optimización, como los solucionadores de satisfacibilidad booleana. El transpilador de IA ejecuta las ejecuciones en tu entorno local.

Actualmente están disponibles los siguientes pases:

Pases de ruta

• AIRouting: Selección de la disposición y trazado de los circuitos

Pases de síntesis de circuitos

• AICliffordSynthesis: Síntesis de circuitos Clifford
• AILinearFunctionSynthesis: Síntesis de circuitos de funciones lineales
• AIPermutationSynthesis: Síntesis de circuitos de permutación

Para utilizar las etapas del transpilador de IA, primero instala el qiskit-ibm-transpiler paquete. Visita la documentación de la API de qiskit-ibm-transpiler para obtener más información sobre las diferentes opciones disponibles.

pip install qiskit-ibm-transpiler

Pase de enrutamiento de IA

El paso AIRouting actúa a la vez como etapa de trazado y etapa de enrutamiento. Puede utilizarse en PassManager de la siguiente manera:

from qiskit.transpiler import PassManager
from qiskit.circuit.library import efficient_su2
from qiskit_ibm_transpiler.ai.routing import AIRouting
from qiskit_ibm_runtime import QiskitRuntimeService
import logging

backend = QiskitRuntimeService().backend("ibm_fez")
ai_passmanager = PassManager(
    [
        AIRouting(
            backend=backend,
            optimization_level=2,
            layout_mode="optimize",
        )
    ]
)


circuit = efficient_su2(101, entanglement="circular", reps=1)
logging.getLogger(
    "qiskit_ibm_transpiler.wrappers.ai_local_synthesis"
).setLevel(logging.WARNING)
transpiled_circuit = ai_passmanager.run(circuit)

En este caso, backend determina el mapa de acoplamiento que se va a trazar, optimization_level (1, 2 o 3) determina el esfuerzo computacional que se va a emplear en el proceso (un valor más alto suele dar mejores resultados, pero lleva más tiempo) y layout_mode especifica cómo manejar la selección del trazado. La página layout_mode incluye las siguientes opciones:

• keep: Respeta el diseño establecido por las pasadas anteriores del transpilador (o utiliza el diseño trivial si no se ha establecido). Normalmente sólo se utiliza cuando el circuito debe ejecutarse en qubits específicos del dispositivo. A menudo produce peores resultados porque tiene menos margen de optimización.
• improve: Utiliza como punto de partida la disposición establecida por los pases anteriores del transpilador. Es útil cuando se tiene una buena estimación inicial del trazado; por ejemplo, para circuitos que se construyen de una forma que sigue aproximadamente el mapa de acoplamiento del dispositivo. También es útil si desea probar otros pases de trazado específicos combinados con el pase AIRouting .
• optimize: Este es el modo por defecto. Funciona mejor para circuitos generales en los que es posible que no tengas buenas suposiciones sobre el trazado. Este modo ignora las selecciones de diseño anteriores.

La síntesis de circuitos de IA pasa

Los pases de síntesis de circuitos AI permiten optimizar piezas de distintos tipos de circuitos (Clifford, Función lineal, Permutación, Red Pauli) resintetizándolas. Una forma típica de utilizar el pase de síntesis es la siguiente:

from qiskit.transpiler import PassManager

from qiskit_ibm_transpiler.ai.routing import AIRouting
from qiskit_ibm_transpiler.ai.synthesis import AILinearFunctionSynthesis
from qiskit_ibm_transpiler.ai.collection import CollectLinearFunctions
from qiskit.circuit.library import efficient_su2

ibm_kingston = QiskitRuntimeService().backend("ibm_kingston")
ai_passmanager = PassManager(
    [
        AIRouting(
            backend=ibm_kingston,
            optimization_level=3,
            layout_mode="optimize",
            local_mode=True,
        ),  # Route circuit
        CollectLinearFunctions(),  # Collect Linear Function blocks
        AILinearFunctionSynthesis(
            backend=ibm_kingston, local_mode=True
        ),  # Re-synthesize Linear Function blocks
    ]
)

circuit = efficient_su2(10, entanglement="full", reps=1)

transpiled_circuit = ai_passmanager.run(circuit)

La síntesis respeta el mapa de acoplamiento del dispositivo: puede ejecutarse con seguridad después de otros pases de enrutamiento sin alterar el circuito, por lo que el circuito global seguirá respetando las restricciones del dispositivo. Por defecto, la síntesis sustituirá el subcircuito original sólo si el subcircuito sintetizado mejora el original (actualmente sólo comprueba el recuento CNOT), pero se puede forzar a que sustituya siempre el circuito configurando replace_only_if_better=False.

Los siguientes pases de síntesis están disponibles en qiskit_ibm_transpiler.ai.synthesis:

• AICliffordSynthesis : Síntesis para circuitos Clifford (bloques de compuertas H, S, y CX ). Actualmente, hasta nueve bloques de qubits.
• AILinearFunctionSynthesis : Síntesis para circuitos de función lineal (bloques de compuertas CX y SWAP ). Actualmente, hasta nueve bloques de qubits.
• AIPermutationSynthesis : Síntesis de circuitos de permutación (bloques de puertas SWAP ). Actualmente disponible para bloques de 65, 33 y 27 qubits.
• AIPauliNetworkSynthesis : Síntesis para circuitos de Red Pauli (bloques de compuertas H, S, SX, CX, RX, RY y RZ ). Actualmente, hasta seis bloques de qubits.

Esperamos aumentar gradualmente el tamaño de los bloques admitidos.

Todos los pases utilizan un pool de hilos para enviar varias peticiones en paralelo. Por defecto, el número de hilos máximos es el número de núcleos más cuatro (valores por defecto para el objeto ThreadPoolExecutor Python ). Sin embargo, puede establecer su propio valor con el argumento max_threads en la instanciación del pase. Por ejemplo, la siguiente línea instancia el pase AILinearFunctionSynthesis , lo que le permite utilizar un máximo de 20 hilos.

AILinearFunctionSynthesis(backend=ibm_torino, max_threads=20)  # Re-synthesize Linear Function blocks using 20 threads max

También puede establecer la variable de entorno AI_TRANSPILER_MAX_THREADS en el número deseado de hilos máximos, y todos los pases de síntesis instanciados después utilizarán ese valor.

Para que los pases de síntesis de IA sinteticen un subcircuito, éste debe estar en un subgrafo conectado del mapa de acoplamiento (una forma de hacerlo es con un pase de enrutamiento antes de reunir los bloques, pero no es la única forma de hacerlo). Los pases de síntesis comprobarán automáticamente si el subgrafo específico es compatible y, en caso contrario, emitirán una advertencia y dejarán el subcircuito original sin cambios.

Los siguientes pases de colección personalizados para Cliffords, Funciones lineales y Permutaciones que pueden importarse de qiskit_ibm_transpiler.ai.collection también complementan los pases de síntesis:

• RecogerCliffords : Recoge bloques Clifford como objetos Instruction y almacena el subcircuito original para compararlo con él después de la síntesis.
• RecopilarFuncionesLineales : Recoge bloques de SWAP y CX como objetos LinearFunction y almacena el subcircuito original para compararlo con él después de la síntesis.
• RecogerPermutaciones : Recoge bloques de circuitos de SWAP como Permutations.
• RecogerRedesPauli : Recoge bloques de redes Pauli y almacena el subcircuito original para compararlo con él después de la síntesis.

Estos pases de recopilación personalizados limitan los tamaños de los subcircuitos recopilados para que sean compatibles con los pases de síntesis basados en IA. Por lo tanto, se recomienda utilizarlos después de los pases de enrutamiento y antes de los pases de síntesis para una mejor optimización global.

Transpilación híbrida de circuitos heurísticos y de IA

qiskit-ibm-transpiler permite configurar un gestor de pases híbrido que combina lo mejor de la heurística de Qiskit y los pases del transpilador basados en IA. Esta función se comporta de forma similar al método Qiskit generate_pass_manager . Una forma típica de utilizar generate_ai_pass_manager es la siguiente:

from qiskit_ibm_transpiler import generate_ai_pass_manager
from qiskit.circuit.library import efficient_su2
from qiskit_ibm_runtime import QiskitRuntimeService


backend = QiskitRuntimeService().backend("ibm_kingston")
kingston_coupling_map = backend.coupling_map


su2_circuit = efficient_su2(101, entanglement="circular", reps=1)

ai_transpiler_pass_manager = generate_ai_pass_manager(
    coupling_map=kingston_coupling_map,
    ai_optimization_level=3,
    optimization_level=3,
    ai_layout_mode="optimize",
)

ai_su2_transpiled_circuit = ai_transpiler_pass_manager.run(su2_circuit)

En este ejemplo se utilizan las siguientes opciones:

• coupling_map - Especifica qué mapa de acoplamiento utilizar para la transpilación.
• ai_optimization_level - Especifica el nivel de optimización (1-3) que se utilizará para los componentes de IA de PassManager.
• optimization_level - Especifica cuánta optimización realizar en el circuito para los componentes heurísticos de PassManager.
• ai_layout_mode - Especifica cómo la parte de enrutamiento AI de la PassManager maneja el diseño. Consulte la sección AI routing pass para revisar las opciones de configuración de este parámetro ai_layout_mode .

Citación

Referencia bibliográfica Si utilizas alguna función basada en inteligencia artificial del qiskit-ibm-transpiler paquete en tu investigación, utiliza la siguiente referencia bibliográfica recomendada:

@misc{2405.13196,
Author = {David Kremer and Victor Villar and Hanhee Paik and Ivan Duran and Ismael Faro and Juan Cruz-Benito},
Title = {Practical and efficient quantum circuit synthesis and transpiling with Reinforcement Learning},
Year = {2024},
Eprint = {arXiv:2405.13196},
}