Transpile com gerenciadores de etapas

• Versões do pacote

  O código desta página foi desenvolvido usando os seguintes requisitos. Recomendamos o uso dessas versões ou de versões mais recentes.

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

A maneira recomendada de transpilar um circuito é criar um gerenciador de passagens em etapas e, em seguida, executar seu método run com o circuito como entrada. Esta página explica como transpilar circuitos quânticos dessa forma.

O que é um gerenciador de senhas (em etapas)?

No contexto do Qiskit SDK, a transpilação refere-se ao processo de transformação de um circuito de entrada em um formato adequado para execução em um dispositivo quântico. Normalmente, a transpilação ocorre em uma sequência de etapas denominadas passagens do transpilador. O circuito é processado por cada passagem do transpilador em sequência, com a saída de uma passagem se tornando a entrada para a próxima. Por exemplo, uma passagem poderia percorrer o circuito e mesclar todas as sequências consecutivas de portas de um único qubit e, em seguida, a próxima passagem poderia sintetizar essas portas no conjunto de base do dispositivo de destino. As passagens do transpilador incluídas no Qiskit estão localizadas no módulo qiskit.transpiler.passes módulo.

Um gerenciador de passes é um objeto que armazena uma lista de passes do transpilador e pode executá-los em um circuito. Crie um gerenciador de passes inicializando um PassManager com uma lista de passagens do transpilador. Para executar a transpilação em um circuito, chame o método run com um circuito como entrada.

Um gerenciador de passagens em estágios é um tipo especial de gerenciador de passagens que representa um nível de abstração superior ao de um gerenciador de passagens normal. Enquanto um gerenciador de passes normal é composto de vários passes de transpiladores, um gerenciador de passes em estágios é composto de vários gerenciadores de passes. Essa é uma abstração útil porque a transpilação normalmente ocorre em estágios discretos, conforme descrito em Estágios do transpilador, com cada estágio sendo representado por um gerenciador de passagem. Os gerenciadores de passagens em estágios são representados pela classe StagedPassManager classe. O restante desta página descreve como criar e personalizar gerenciadores de passes (em etapas).

Gerar um gerenciador de passes pré-definido

Para criar um gerenciador de passagens pré-configurado com valores padrão adequados, use a generate_preset_pass_manager função.

from qiskit.transpiler import generate_preset_pass_manager
from qiskit_ibm_runtime.fake_provider import FakeSherbrooke

backend = FakeSherbrooke()
pass_manager = generate_preset_pass_manager(
    optimization_level=3, backend=backend
)

Para transpilar um circuito ou uma lista de circuitos com um gerenciador de passagem, passe o circuito ou a lista de circuitos para o método run . Vamos fazer isso em um circuito de dois qubits que consiste em um Hadamard seguido por duas portas CX adjacentes:

from qiskit import QuantumRegister, QuantumCircuit

# Create a circuit
qubits = QuantumRegister(2, name="q")
circuit = QuantumCircuit(qubits)
a, b = qubits
circuit.h(a)
circuit.cx(a, b)
circuit.cx(b, a)

# Transpile it by calling the run method of the pass manager
transpiled = pass_manager.run(circuit)

# Draw it, excluding idle qubits from the diagram
transpiled.draw("mpl", idle_wires=False)

Output:

Consulte Padrões de transpilação e opções de configuração para obter uma descrição dos possíveis argumentos da função generate_preset_pass_manager . Os argumentos para generate_preset_pass_manager correspondem aos argumentos para a função transpile função.

Se os gerenciadores de passagem predefinidos não atenderem às suas necessidades, personalize a transpilação criando gerenciadores de passagem (em etapas) ou até mesmo passagens de transpilação. O restante desta página descreve como criar gerenciadores de passes. Para obter instruções sobre como criar passagens de transpilação, consulte Escreva sua própria passagem de transpilação.

Crie seu próprio gerenciador de passes

O módulo qiskit.transpiler.passes inclui muitas passagens do transpilador que podem ser usadas para criar gerenciadores de passagens. Para criar um gerenciador de passes, inicialize um PassManager com uma lista de passes. Por exemplo, o código a seguir cria uma passagem de transpilador que mescla portas de dois qubits adjacentes e, em seguida, as sintetiza em uma base de $R_y$, $R_z$, e $R_{xx}$ portas.

from qiskit.transpiler import PassManager
from qiskit.transpiler.passes import (
    Collect2qBlocks,
    ConsolidateBlocks,
    UnitarySynthesis,
)

basis_gates = ["rx", "ry", "rxx"]
translate = PassManager(
    [
        Collect2qBlocks(),
        ConsolidateBlocks(basis_gates=basis_gates),
        UnitarySynthesis(basis_gates),
    ]
)

Para demonstrar esse gerenciador de passagem em ação, teste-o em um circuito de dois qubits que consiste em um Hadamard seguido por duas portas CX adjacentes:

from qiskit import QuantumRegister, QuantumCircuit

qubits = QuantumRegister(2, name="q")
circuit = QuantumCircuit(qubits)

a, b = qubits
circuit.h(a)
circuit.cx(a, b)
circuit.cx(b, a)

circuit.draw("mpl")

Output:

Para executar o gerenciador de passes no circuito, chame o método run .

translated = translate.run(circuit)
translated.draw("mpl")

Output:

Para obter um exemplo mais avançado que mostre como criar um gerenciador de passes para implementar a técnica de supressão de erros conhecida como desacoplamento dinâmico, consulte Criar um gerenciador de passes para desacoplamento dinâmico.

Criar um gerenciador de passes em etapas

O StagedPassManager é um gerenciador de passes composto de estágios individuais, em que cada estágio é definido por uma instância do PassManager . Você pode criar um StagedPassManager especificando os estágios desejados. Por exemplo, o código a seguir cria um gerenciador de passes em estágios com dois estágios, init e translation. O estágio translation é definido pelo gerenciador de passes que foi criado anteriormente.

from qiskit.transpiler import PassManager, StagedPassManager
from qiskit.transpiler.passes import UnitarySynthesis, Unroll3qOrMore

basis_gates = ["rx", "ry", "rxx"]
init = PassManager(
    [UnitarySynthesis(basis_gates, min_qubits=3), Unroll3qOrMore()]
)
staged_pm = StagedPassManager(
    stages=["init", "translation"], init=init, translation=translate
)

Não há limite para o número de etapas que você pode colocar em um gerenciador de passes por etapas.

Outra maneira útil de criar um gerenciador de passes em etapas é começar com um gerenciador de passes em etapas predefinido e, em seguida, trocar algumas das etapas. Por exemplo, o código a seguir gera um gerenciador de passagens predefinido com nível de otimização 3 e, em seguida, especifica um estágio pre_layout personalizado.

import numpy as np
from qiskit.circuit.library import HGate, PhaseGate, RXGate, TdgGate, TGate
from qiskit.transpiler.passes import InverseCancellation

pass_manager = generate_preset_pass_manager(3, backend)
inverse_gate_list = [
    HGate(),
    (RXGate(np.pi / 4), RXGate(-np.pi / 4)),
    (PhaseGate(np.pi / 4), PhaseGate(-np.pi / 4)),
    (TGate(), TdgGate()),
]
logical_opt = PassManager(
    [
        InverseCancellation(inverse_gate_list),
    ]
)

# Add pre-layout stage to run extra logical optimization
pass_manager.pre_layout = logical_opt

As funções do gerador de estágios podem ser úteis para a construção de gerenciadores de passagens personalizados. Eles geram estágios que fornecem funcionalidade comum usada em muitos gerenciadores de passes. Por exemplo, generate_embed_passmanager pode ser usado para gerar um estágio para "incorporar" uma inicial selecionada Layout de uma passagem de layout para o dispositivo de destino especificado.

Próximas etapas