Pular para o conteúdo principal

Transpilação com gerenciadores de passagem

Package versions

The code on this page was developed using the following requirements. We recommend using these versions or newer.

qiskit[all]~=2.3.0
qiskit-ibm-runtime~=0.43.1

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

O que é um gerenciador de passagem (em estágios)?​

No contexto do Qiskit SDK, transpilação refere-se ao processo de transformar um circuito de entrada em uma forma adequada para execução em um dispositivo quântico. A transpilação geralmente ocorre em uma sequência de etapas chamadas passes de transpilação. O circuito é processado por cada passe de transpilação em sequência, sendo que a saída de um passe se torna a entrada do próximo. Por exemplo, um passe pode percorrer o circuito e mesclar todas as sequências consecutivas de portas de um único qubit, e então o próximo passe pode sintetizar essas portas no conjunto de base do dispositivo alvo. Os passes de transpilação incluídos no Qiskit estão localizados no módulo qiskit.transpiler.passes.

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

Um gerenciador de passagem em estágios é um tipo especial de gerenciador de passagem que representa um nível de abstração acima do gerenciador de passagem normal. Enquanto um gerenciador de passagem normal é composto por vários passes de transpilação, um gerenciador de passagem em estágios é composto por vários gerenciadores de passagem. Essa é uma abstração útil porque a transpilação geralmente 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 passagem em estágios são representados pela classe StagedPassManager. O restante desta página descreve como criar e personalizar gerenciadores de passagem (em estágios).

Gerar um gerenciador de passagem em estágios predefinido​

Para criar um gerenciador de passagem em estágios predefinido com padrões razoáveis, use a função generate_preset_pass_manager:

# Added by doQumentation — required packages for this notebook
!pip install -q numpy qiskit qiskit-ibm-runtime
from qiskit.transpiler import generate_preset_pass_manager
from qiskit_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService()
backend = service.backend("ibm_fez")
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 composto por uma porta Hadamard seguida de 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 of the previous code cell

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

Having trouble remembering pass manager details? Try asking Qiskit Code Assistant.

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

Crie seu próprio gerenciador de passagem​

O módulo qiskit.transpiler.passes inclui muitos passes de transpilação que podem ser usados para criar gerenciadores de passagem. Para criar um gerenciador de passagem, inicialize um PassManager com uma lista de passes. Por exemplo, o código a seguir cria um passe de transpilação que mescla portas adjacentes de dois qubits e, em seguida, as sintetiza em uma base de portas RyR_y, RzR_z e RxxR_{xx}.

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 composto por uma porta Hadamard seguida de 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 of the previous code cell

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

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

Output of the previous code cell

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

Criar um gerenciador de passagem em estágios​

Um StagedPassManager é um gerenciador de passagem composto por estágios individuais, onde cada estágio é definido por uma instância de PassManager. Você pode criar um StagedPassManager especificando os estágios desejados. Por exemplo, o código a seguir cria um gerenciador de passagem em estágios com dois estágios, init e translation. O estágio translation é definido pelo gerenciador de passagem 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 estágios que você pode incluir em um gerenciador de passagem em estágios.

Outra forma útil de criar um gerenciador de passagem em estágios é começar com um gerenciador de passagem em estágios predefinido e substituir alguns dos estágios. Por exemplo, o código a seguir gera um gerenciador de passagem 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 geradoras de estágios podem ser úteis para construir gerenciadores de passagem personalizados. Elas geram estágios que oferecem funcionalidades comuns usadas em muitos gerenciadores de passagem. Por exemplo, generate_embed_passmanager pode ser usado para gerar um estágio para "incorporar" um Layout inicial selecionado de um passe de layout no dispositivo alvo especificado.

Próximas etapas​

Recomendação