Transpiler com tecnologia de IA aprovado

As etapas de transpilagem baseadas em IA são etapas que funcionam como um substituto direto das etapas “tradicionais” do Qiskit para algumas tarefas de transpilagem. Frequentemente, eles produzem melhores resultados do que os algoritmos heurísticos existentes (como menor profundidade e menor contagem de CNOT), mas também são muito mais rápidos do que algoritmos de otimização, como os solucionadores de satisfatibilidade booleana. O transpiler de IA é executado no seu ambiente local.

Os seguintes passes estão disponíveis no momento:

Passes de roteamento

• AIRouting: Seleção de layout e roteamento de circuitos

A síntese de circuitos passa

• AICliffordSynthesis: Síntese de circuitos Clifford
• AILinearFunctionSynthesis: Síntese de circuitos de função linear
• AIPermutationSynthesis: Síntese de circuitos de permutação

Para usar as etapas do transpiler de IA, instale primeiro o qiskit-ibm-transpiler pacote. Consulte a documentação da API do qiskit-ibm-transpiler para obter mais informações sobre as diferentes opções disponíveis.

pip install qiskit-ibm-transpiler

Passe de roteamento de IA

A passagem AIRouting atua como um estágio de layout e um estágio de roteamento. Ele pode ser usado em um PassManager da seguinte forma:

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)

Aqui, o backend determina qual mapa de acoplamento deve ser roteado, o optimization_level (1, 2 ou 3) determina o esforço computacional a ser despendido no processo (um valor mais alto geralmente oferece melhores resultados, mas leva mais tempo) e o layout_mode especifica como lidar com a seleção do layout. O site layout_mode inclui as seguintes opções:

• keep: Respeita o layout definido pelas passagens anteriores do transpilador (ou usa o layout trivial se não estiver definido). Normalmente, ele só é usado quando o circuito precisa ser executado em qubits específicos do dispositivo. Geralmente produz resultados piores porque tem menos espaço para otimização.
• improve: Usa o layout definido pelas passagens anteriores do transpilador como ponto de partida. É útil quando você tem uma boa estimativa inicial do layout; por exemplo, para circuitos que são construídos de uma forma que segue aproximadamente o mapa de acoplamento do dispositivo. Também é útil se você quiser experimentar outros passes de layout específicos combinados com o passe AIRouting .
• optimize: Esse é o modo padrão. Ele funciona melhor para circuitos gerais em que você pode não ter boas estimativas de layout. Esse modo ignora as seleções de layout anteriores.

A síntese do circuito de IA é aprovada

Os passes de síntese de circuitos de IA permitem que você otimize peças de diferentes tipos de circuitos (Clifford, Função Linear, Permutação, Rede Pauli) ao sintetizá-los novamente. Uma maneira típica de usar a passagem de síntese é a seguinte:

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)

A síntese respeita o mapa de acoplamento do dispositivo: ela pode ser executada com segurança após outras passagens de roteamento sem perturbar o circuito, de modo que o circuito geral ainda seguirá as restrições do dispositivo. Por padrão, a síntese substituirá o subcircuito original somente se o subcircuito sintetizado melhorar o original (atualmente, verificando apenas a contagem de CNOT), mas isso pode ser forçado a sempre substituir o circuito definindo replace_only_if_better=False.

Os seguintes passes de síntese estão disponíveis em qiskit_ibm_transpiler.ai.synthesis:

• AICliffordSynthesis : Síntese para circuitos Clifford (blocos de portas H, S e CX ). Atualmente, até nove blocos de qubit.
• AILinearFunctionSynthesis : Síntese para circuitos de função linear (blocos de CX e SWAP gates). Atualmente, até nove blocos de qubit.
• AIPermutationSynthesis : Síntese para circuitos de permutação (blocos de SWAP gates). Atualmente disponível para blocos de 65, 33 e 27 qubits.
• AIPauliNetworkSynthesis : Síntese para circuitos de rede Pauli (blocos de portas H, S, SX, CX, RX, RY e RZ ). Atualmente, até seis blocos de qubit.

Esperamos aumentar gradualmente o tamanho dos blocos suportados.

Todos os passes usam um pool de threads para enviar várias solicitações em paralelo. Por padrão, o número máximo de threads é o número de núcleos mais quatro (valores padrão para o objeto ThreadPoolExecutor Python ). No entanto, você pode definir seu próprio valor com o argumento max_threads na instanciação do passe. Por exemplo, a linha a seguir instancia a passagem AILinearFunctionSynthesis , o que permite que ela use um máximo de 20 threads.

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

Você também pode definir a variável de ambiente AI_TRANSPILER_MAX_THREADS como o número desejado de threads máximos, e todas as passagens de síntese instanciadas depois disso usarão esse valor.

Para que as passagens de síntese de IA sintetizem um subcircuito, ele deve estar em um subgráfico conectado do mapa de acoplamento (uma maneira de fazer isso é com uma passagem de roteamento antes de coletar os blocos, mas essa não é a única maneira de fazer isso). Os passes de síntese verificarão automaticamente se o subgrafo específico é compatível e, se não for, emitirão um aviso e deixarão o subcircuito original inalterado.

Os seguintes passes de coleção personalizados para Cliffords, Funções Lineares e Permutações que podem ser importados do site qiskit_ibm_transpiler.ai.collection também complementam os passes de síntese:

• CollectCliffords : Coleta blocos Clifford como objetos Instruction e armazena o subcircuito original para compará-lo após a síntese.
• CollectLinearFunctions : Coleta blocos de SWAP e CX como objetos LinearFunction e armazena o subcircuito original para comparar com ele após a síntese.
• CollectPermutations : Coleta blocos de circuitos SWAP como Permutations.
• CollectPauliNetworks : Coleta blocos de rede Pauli e armazena o subcircuito original para comparar com ele após a síntese.

Esses passes de coleta personalizados limitam os tamanhos dos subcircuitos coletados para que sejam compatíveis com os passes de síntese com tecnologia de IA. Portanto, recomenda-se usá-los após as passagens de roteamento e antes das passagens de síntese para uma melhor otimização geral.

Transpilação híbrida de circuitos heurísticos-IA

O site qiskit-ibm-transpiler permite que você configure um gerenciador de passes híbrido que combina o melhor da heurística do Qiskit e os passes do transpilador com tecnologia de IA. Esse recurso se comporta de forma semelhante ao método do Qiskit generate_pass_manager . Uma maneira típica de usar o site generate_ai_pass_manager é a seguinte:

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)

As opções a seguir são usadas neste exemplo:

• coupling_map - Especifica o mapa de acoplamento a ser usado para a transpilação.
• ai_optimization_level - Especifica o nível de otimização (1-3) a ser usado para os componentes de IA do site PassManager.
• optimization_level - Especifica a quantidade de otimização a ser executada no circuito para os componentes heurísticos do site PassManager.
• ai_layout_mode - Especifica como a parte de roteamento de IA do site PassManager lida com o layout. Consulte a seção de passagem de roteamento de IA para analisar as opções de configuração desse parâmetro ai_layout_mode .

Citação

Citação Caso utilize qualquer recurso baseado em IA do qiskit-ibm-transpiler pacote em sua pesquisa, utilize a seguinte citação 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},
}