Nota

Esta página foi gerada, a partir de tutorials/circuits_advanced/04_transpiler_passes_and_passmanager.ipynb.

Transpilador de passes e gerenciador de passes

Introdução

Um componente central do Qiskit Terra é o transpilador, que é projetado para modularidade e extensibilidade. O objetivo é ser capaz de escrever, facilmente, novas transformações de circuito (conhecidas como transpiler passes) e combiná-las com outros passes existentes. Quais passes são encadeados em conjunto e, em que ordem, tem um grande efeito sobre o resultado final. Este pipeline é determinado por um gerenciador de passe, que planeja os passes e, também, permite que os passes se comuniquem, entre si, fornecendo um espaço compartilhado. Desta forma, o transpilador abre a porta para pesquisa, em otimização agressiva de circuitos quânticos.

Neste notebook, olhamos para os passes embutidos, como usar o gerenciador de passes e desenvolver um simples transpilador de passe personalizado. Para fazer o último, precisamos, primeiramente, introduzir a representação interna dos circuitos quânticos em Qiskit, na forma de um Gráfico Acíclico Direcionado, ou DAG. Em seguida, ilustramos um simples mapeador de passe de troca, que transforma um circuito de entrada, para ser compatível com um dispositivo quântico de conectividade limitada.

Before you start: You may need to install the pydot library and the graphviz library for the DAG plotting routines. If you are using Anaconda Python, you can install both with the conda command. If you use your system’s native Python interpreter, install pydot using the pip command, and install graphviz using your system’s native package manager (e.g. yum, apt, dnf, brew, etc.).

from qiskit import QuantumCircuit
from qiskit.compiler import transpile
from qiskit.transpiler import PassManager

Objeto gerenciador de passes

Permite que você especifique o conjunto de passes desejados.

circ = QuantumCircuit(3)
circ.ccx(0, 1, 2)
circ.draw(output='mpl')

from qiskit.transpiler.passes import Unroller
pass_ = Unroller(['u1', 'u2', 'u3', 'cx'])
pm = PassManager(pass_)
new_circ = pm.run(circ)
new_circ.draw(output='mpl')

All of Qiskit’s transpiler passes are accessible from qiskit.transpiler.passes.

from qiskit.transpiler import passes
[pass_ for pass_ in dir(passes) if pass_[0].isupper()]

['ALAPSchedule',
 'ALAPScheduleAnalysis',
 'ASAPSchedule',
 'ASAPScheduleAnalysis',
 'AlignMeasures',
 'ApplyLayout',
 'BIPMapping',
 'BarrierBeforeFinalMeasurements',
 'BasicSwap',
 'BasisTranslator',
 'CSPLayout',
 'CXCancellation',
 'CXDirection',
 'CheckCXDirection',
 'CheckGateDirection',
 'CheckMap',
 'Collect1qRuns',
 'Collect2qBlocks',
 'CollectLinearFunctions',
 'CollectMultiQBlocks',
 'CommutationAnalysis',
 'CommutativeCancellation',
 'CommutativeInverseCancellation',
 'Commuting2qGateRouter',
 'ConsolidateBlocks',
 'ConstrainedReschedule',
 'ContainsInstruction',
 'ConvertConditionsToIfOps',
 'CountOps',
 'CountOpsLongestPath',
 'CrosstalkAdaptiveSchedule',
 'DAGFixedPoint',
 'DAGLongestPath',
 'Decompose',
 'DenseLayout',
 'Depth',
 'DynamicalDecoupling',
 'EchoRZXWeylDecomposition',
 'EnlargeWithAncilla',
 'Error',
 'FixedPoint',
 'FullAncillaAllocation',
 'GateDirection',
 'GatesInBasis',
 'HLSConfig',
 'HighLevelSynthesis',
 'HoareOptimizer',
 'InstructionDurationCheck',
 'InverseCancellation',
 'Layout2qDistance',
 'LayoutTransformation',
 'LinearFunctionsSynthesis',
 'LinearFunctionsToPermutations',
 'LookaheadSwap',
 'MergeAdjacentBarriers',
 'NoiseAdaptiveLayout',
 'NumTensorFactors',
 'Optimize1qGates',
 'Optimize1qGatesDecomposition',
 'Optimize1qGatesSimpleCommutation',
 'OptimizeCliffords',
 'OptimizeSwapBeforeMeasure',
 'PadDelay',
 'PadDynamicalDecoupling',
 'PulseGates',
 'RZXCalibrationBuilder',
 'RZXCalibrationBuilderNoEcho',
 'RemoveBarriers',
 'RemoveDiagonalGatesBeforeMeasure',
 'RemoveFinalMeasurements',
 'RemoveResetInZeroState',
 'ResetAfterMeasureSimplification',
 'ResourceEstimation',
 'SabreLayout',
 'SabreSwap',
 'SetIOLatency',
 'SetLayout',
 'Size',
 'StochasticSwap',
 'TemplateOptimization',
 'TimeUnitConversion',
 'TrivialLayout',
 'UnitarySynthesis',
 'Unroll3qOrMore',
 'UnrollCustomDefinitions',
 'Unroller',
 'VF2Layout',
 'VF2PostLayout',
 'ValidatePulseGates',
 'Width']

Diferentes variações do mesmo passe

Pode haver passes que façam o mesmo trabalho, mas de maneiras diferentes. Por exemplo, o TrivialLayout, DenseLayout e NoiseAdaptiveLayout todos escolhem um layout (ligação de qubits virtuais para qubits físicos), mas usam algoritmos e objetivos diferentes. Da mesma forma, o BasicSwap, LookaheadSwap e StochasticSwap todos fazem a inserção de swaps para tornar o circuito compatível com o mapa de acoplamento. A modularidade do transpilador permite reposicionamentos de plug-and-play para cada passe.

Abaixo, mostramos todos os passes de troca aplicados para o mesmo circuito para transformá-lo, para combinar com uma topologia de cadeia linear. Você pode ver diferenças de desempenho, em que o StochasticSwap é, claramente, o melhor. No entanto, isto pode variar, dependendo do circuito de entrada.

from qiskit.transpiler import CouplingMap, Layout
from qiskit.transpiler.passes import BasicSwap, LookaheadSwap, StochasticSwap

coupling = [[0, 1], [1, 2], [2, 3], [3, 4], [4, 5], [5, 6]]

circuit = QuantumCircuit(7)
circuit.h(3)
circuit.cx(0, 6)
circuit.cx(6, 0)
circuit.cx(0, 1)
circuit.cx(3, 1)
circuit.cx(3, 0)

coupling_map = CouplingMap(couplinglist=coupling)

bs = BasicSwap(coupling_map=coupling_map)
pass_manager = PassManager(bs)
basic_circ = pass_manager.run(circuit)

ls = LookaheadSwap(coupling_map=coupling_map)
pass_manager = PassManager(ls)
lookahead_circ = pass_manager.run(circuit)

ss = StochasticSwap(coupling_map=coupling_map)
pass_manager = PassManager(ss)
stochastic_circ = pass_manager.run(circuit)

circuit.draw(output='mpl')

basic_circ.draw(output='mpl')

lookahead_circ.draw(output='mpl')

stochastic_circ.draw(output='mpl')

Gerenciador de passes predefinidos

O Qiskit vem com vários gerenciadores de passe pré-definidos, correspondentes a vários níveis de otimização alcançados, através de diferentes condutas de passes. Atualmente, otimization_level 0 até 3 são suportados; quanto maior o número, mais otimizado ele é, à custa de mais tempo. Escolher um bom gestor de passe, pode ser uma tarefa de tentativa e erro, já que depende muito do circuito, que está sendo transpilado e do backend de destino.

Aqui, ilustramos os diferentes níveis, olhando para um circuito de síntese de estado. Inicializamos quatro qubits em um estado arbitrário e, em seguida, tentamos otimizar o circuito, que realiza isto.

• optimization_level=0: somente mapeia o circuito para o processo interno, sem nenhuma otimização explícita (exceto, quaisquer otimizações feitas pelo mapeador).

• optimization_level=1: mapeia o circuito, mas também realiza otimizações leves, colapsando portas adjacentes.

• optimization_level=2: otimizações médias, incluindo um layout adaptável ao ruído e um procedimento de cancelamento de portas, a partir de relações de comutação das portas.

• optimization_level=3: otimização pesada, que, além das etapas anteriores, faz a resíntese de blocos de portas de dois qubits no circuito.

import math
from qiskit.providers.fake_provider import FakeTokyo

backend = FakeTokyo()     # mimics the tokyo device in terms of coupling map and basis gates

qc = QuantumCircuit(10)

random_state = [
    1 / math.sqrt(4) * complex(0, 1),
    1 / math.sqrt(8) * complex(1, 0),
    0,
    0,
    0,
    0,
    0,
    0,
    1 / math.sqrt(8) * complex(1, 0),
    1 / math.sqrt(8) * complex(0, 1),
    0,
    0,
    0,
    0,
    1 / math.sqrt(4) * complex(1, 0),
    1 / math.sqrt(8) * complex(1, 0)]

qc.initialize(random_state, range(4))
qc.draw()

     »
q_0: »
     »
q_1: »
     »
q_2: »
     »
q_3: »
     »
q_4: »
     »
q_5: »
     »
q_6: »
     »
q_7: »
     »
q_8: »
     »
q_9: »
     »
«     ┌────────────────────────────────────────────────────────────────────────────┐
«q_0: ┤0                                                                           ├
«     │                                                                            │
«q_1: ┤1                                                                           ├
«     │  Initialize(0.5j,0.35355,0,0,0,0,0,0,0.35355,0.35355j,0,0,0,0,0.5,0.35355) │
«q_2: ┤2                                                                           ├
«     │                                                                            │
«q_3: ┤3                                                                           ├
«     └────────────────────────────────────────────────────────────────────────────┘
«q_4: ──────────────────────────────────────────────────────────────────────────────
«
«q_5: ──────────────────────────────────────────────────────────────────────────────
«
«q_6: ──────────────────────────────────────────────────────────────────────────────
«
«q_7: ──────────────────────────────────────────────────────────────────────────────
«
«q_8: ──────────────────────────────────────────────────────────────────────────────
«
«q_9: ──────────────────────────────────────────────────────────────────────────────
«                                                                                   

Agora, mapeie isto para o servidor de 20-qubit chamado Tokyo, com um nível de otimização diferente:

optimized_0 = transpile(qc, backend=backend, seed_transpiler=11, optimization_level=0)
print('gates = ', optimized_0.count_ops())
print('depth = ', optimized_0.depth())

gates =  OrderedDict([('cx', 70), ('u3', 15), ('u1', 15), ('reset', 4)])
depth =  87

optimized_1 = transpile(qc, backend=backend, seed_transpiler=11, optimization_level=1)
print('gates = ', optimized_1.count_ops())
print('depth = ', optimized_1.depth())

gates =  OrderedDict([('cx', 22), ('u3', 15), ('u1', 6)])
depth =  40

optimized_2 = transpile(qc, backend=backend, seed_transpiler=11, optimization_level=2)
print('gates = ', optimized_2.count_ops())
print('depth = ', optimized_2.depth())

gates =  OrderedDict([('cx', 20), ('u3', 15), ('u1', 6)])
depth =  38

optimized_3 = transpile(qc, backend=backend, seed_transpiler=11, optimization_level=3)
print('gates = ', optimized_3.count_ops())
print('depth = ', optimized_3.depth())

gates =  OrderedDict([('cx', 20), ('u3', 15), ('u1', 6)])
depth =  38

Apresentando o DAG

No Qiskit, representamos circuitos, internamente, usando um Gráfico Acíclico Direcionado (DAG). A vantagem desta representação sobre uma lista pura de portões (ou seja, netlist) é que, o fluxo de informações, entre as operações, são explícitas, tornando mais fácil para os passes tomarem decisões de transformação, sem alterar a semântica do circuito.

Let’s start by building a simple circuit, and examining its DAG.

from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
from qiskit.dagcircuit import DAGCircuit
q = QuantumRegister(3, 'q')
c = ClassicalRegister(3, 'c')
circ = QuantumCircuit(q, c)
circ.h(q[0])
circ.cx(q[0], q[1])
circ.measure(q[0], c[0])
circ.rz(0.5, q[1]).c_if(c, 2)
circ.draw(output='mpl')

No DAG, existem três tipos de vértices do gráfico: vértices de entrada do qubit/clbit (verde), vértices de operação (azul) e vértices de saída (vermelho). Cada aresta indica fluxo de dados (ou dependência) entre dois vértices.

from qiskit.converters import circuit_to_dag
from qiskit.tools.visualization import dag_drawer
dag = circuit_to_dag(circ)
dag_drawer(dag)

Therefore, writing a transpiler pass means using Qiskit’s DAGCircuit API to analyze or transform the circuit. Let’s see some examples of this.

a. Obter todos os nós de operações no DAG:

dag.op_nodes()

[DAGOpNode(op=Instruction(name='h', num_qubits=1, num_clbits=0, params=[]), qargs=(Qubit(QuantumRegister(3, 'q'), 0),), cargs=()),
 DAGOpNode(op=Instruction(name='cx', num_qubits=2, num_clbits=0, params=[]), qargs=(Qubit(QuantumRegister(3, 'q'), 0), Qubit(QuantumRegister(3, 'q'), 1)), cargs=()),
 DAGOpNode(op=Instruction(name='measure', num_qubits=1, num_clbits=1, params=[]), qargs=(Qubit(QuantumRegister(3, 'q'), 0),), cargs=(Clbit(ClassicalRegister(3, 'c'), 0),)),
 DAGOpNode(op=Instruction(name='rz', num_qubits=1, num_clbits=0, params=[0.5]), qargs=(Qubit(QuantumRegister(3, 'q'), 1),), cargs=())]

Each node is an instance of the DAGOpNode class. Let’s examine the information stored in the second op node.

node = dag.op_nodes()[3]
print("node name: ", node.name)
print("node op: ", node.op)
print("node qargs: ", node.qargs)
print("node cargs: ", node.cargs)
print("node condition: ", node.op.condition)

node name:  rz
node op:  Instruction(name='rz', num_qubits=1, num_clbits=0, params=[0.5])
node qargs:  (Qubit(QuantumRegister(3, 'q'), 1),)
node cargs:  ()
node condition:  (ClassicalRegister(3, 'c'), 2)

b. Adicione um operador para a parte de trás:

from qiskit.circuit.library import HGate
dag.apply_operation_back(HGate(), qargs=[q[0]])
dag_drawer(dag)

c. Add an operation to the front:

from qiskit.circuit.library import CCXGate
dag.apply_operation_front(CCXGate(), qargs=[q[0], q[1], q[2]], cargs=[])
dag_drawer(dag)

d. Substitute a node with a subcircuit:

from qiskit.circuit.library import CHGate, U2Gate, CXGate
mini_dag = DAGCircuit()
p = QuantumRegister(2, "p")
mini_dag.add_qreg(p)
mini_dag.apply_operation_back(CHGate(), qargs=[p[1], p[0]])
mini_dag.apply_operation_back(U2Gate(0.1, 0.2), qargs=[p[1]])

# substitute the cx node with the above mini-dag
cx_node = dag.op_nodes(op=CXGate).pop()
dag.substitute_node_with_dag(node=cx_node, input_dag=mini_dag, wires=[p[0], p[1]])
dag_drawer(dag)

Por fim, após todas as transformações serem completadas, podemos converter, de volta, para um objeto QuantumCircuit regular. Isto é o que o transpilador faz! Ele recebe um circuito, opera nele na forma DAG e fornece, como resultado, um circuito transformado.

from qiskit.converters import dag_to_circuit
circuit = dag_to_circuit(dag)
circuit.draw(output='mpl')

Implementando um passe BasicMapper

Now that we are familiar with the DAG, let’s use it to write a transpiler pass. Here we will implement a basic pass for mapping an arbitrary circuit to a device with limited qubit connectivity. We call this the BasicMapper. This pass is included in Qiskit Terra as well.

A primeira coisa a fazer, ao escrever um passe de transpilador, é decidir se a classe pass deriva de um TransformationPass ou AnalysisPass. Passes de transformação modificam o circuito, enquanto passes de análise, apenas coletam informações sobre um circuito (para ser usado por outros passes). Em seguida, o método run (dag) é implementado, fazendo a tarefa principal. Por fim, o passe é registrado, dentro do módulo qiskit.transpiler.passes.

Este passe funciona da seguinte forma: ele atravessa a DAG camada-por-camada (cada camada é um grupo de operações, que não atua em qubits independentes, portanto, em teoria, todas as operações em uma camada podem ser feitas de forma independente). Para cada operação, se ela já não atende às restrições de mapa de acoplamento, o passe identifica um caminho de troca e insere swaps para trazer os dois qubits próximos uns dos outros.

Siga os comentários no código para mais detalhes.

from copy import copy

from qiskit.transpiler.basepasses import TransformationPass
from qiskit.transpiler import Layout
from qiskit.circuit.library import SwapGate


class BasicSwap(TransformationPass):
    """Maps (with minimum effort) a DAGCircuit onto a `coupling_map` adding swap gates."""

    def __init__(self,
                 coupling_map,
                 initial_layout=None):
        """Maps a DAGCircuit onto a `coupling_map` using swap gates.

        Args:
            coupling_map (CouplingMap): Directed graph represented a coupling map.
            initial_layout (Layout): initial layout of qubits in mapping
        """
        super().__init__()
        self.coupling_map = coupling_map
        self.initial_layout = initial_layout

    def run(self, dag):
        """Runs the BasicSwap pass on `dag`.

        Args:
            dag (DAGCircuit): DAG to map.

        Returns:
            DAGCircuit: A mapped DAG.

        Raises:
            TranspilerError: if the coupling map or the layout are not
            compatible with the DAG.
        """
        new_dag = DAGCircuit()
        for qreg in dag.qregs.values():
            new_dag.add_qreg(qreg)
        for creg in dag.cregs.values():
            new_dag.add_creg(creg)


        if self.initial_layout is None:
            if self.property_set["layout"]:
                self.initial_layout = self.property_set["layout"]
            else:
                self.initial_layout = Layout.generate_trivial_layout(*dag.qregs.values())

        if len(dag.qubits) != len(self.initial_layout):
            raise TranspilerError('The layout does not match the amount of qubits in the DAG')

        if len(self.coupling_map.physical_qubits) != len(self.initial_layout):
            raise TranspilerError(
                "Mappers require to have the layout to be the same size as the coupling map")

        canonical_register = dag.qregs['q']
        trivial_layout = Layout.generate_trivial_layout(canonical_register)
        current_layout = trivial_layout.copy()

        for layer in dag.serial_layers():
            subdag = layer['graph']

            for gate in subdag.two_qubit_ops():
                physical_q0 = current_layout[gate.qargs[0]]
                physical_q1 = current_layout[gate.qargs[1]]
                if self.coupling_map.distance(physical_q0, physical_q1) != 1:
                    # Insert a new layer with the SWAP(s).
                    swap_layer = DAGCircuit()
                    swap_layer.add_qreg(canonical_register)

                    path = self.coupling_map.shortest_undirected_path(physical_q0, physical_q1)
                    for swap in range(len(path) - 2):
                        connected_wire_1 = path[swap]
                        connected_wire_2 = path[swap + 1]

                        qubit_1 = current_layout[connected_wire_1]
                        qubit_2 = current_layout[connected_wire_2]

                        # create the swap operation
                        swap_layer.apply_operation_back(SwapGate(),
                                                        qargs=[qubit_1, qubit_2],
                                                        cargs=[])

                    # layer insertion
                    order = current_layout.reorder_bits(new_dag.qubits)
                    new_dag.compose(swap_layer, qubits=order)

                    # update current_layout
                    for swap in range(len(path) - 2):
                        current_layout.swap(path[swap], path[swap + 1])

            order = current_layout.reorder_bits(new_dag.qubits)
            new_dag.compose(subdag, qubits=order)

        return new_dag

Let’s test this pass on a small example circuit.

q = QuantumRegister(7, 'q')
in_circ = QuantumCircuit(q)
in_circ.h(q[0])
in_circ.cx(q[0], q[4])
in_circ.cx(q[2], q[3])
in_circ.cx(q[6], q[1])
in_circ.cx(q[5], q[0])
in_circ.rz(0.1, q[2])
in_circ.cx(q[5], q[0])

<qiskit.circuit.instructionset.InstructionSet at 0x7ff990428370>

Agora, construímos um gerenciador de passes, que contém nosso novo passe. Passamos o circuito de exemplo, acima, para este gerenciador de passes e obtemos um novo circuito transformado.

from qiskit.transpiler import PassManager
from qiskit.transpiler import CouplingMap
from qiskit import BasicAer
pm = PassManager()
coupling = [[0, 1], [1, 2], [2, 3], [3, 4], [4, 5], [5, 6]]
coupling_map = CouplingMap(couplinglist=coupling)

pm.append([BasicSwap(coupling_map)])

out_circ = pm.run(in_circ)

in_circ.draw(output='mpl')

out_circ.draw(output='mpl')

Note that this pass only inserts the swaps necessary to make every two-qubit interaction conform to the device coupling map. It does not, for example, care about the direction of interactions, or the native gate set supported by the device. This is a design philosophy of Qiskit’s transpiler: every pass performs a small, well-defined action, and the aggressive circuit optimization is achieved by the pass manager through combining multiple passes.

Registro do Transpilador

Due to the complexity of the internal operations that the transpiler is performing it’s likely that you’ll end up in a situation where you’d like to debug an issue or just understand more of what is happening inside the transpiler when you call it. To facilitate this the transpiler emits log messages as part of its normal operation. This logging uses the Python standard library logging module to emit the log messages. Python’s standard logging was used because it allows Qiskit-Terra’s logging to integrate in a standard way with other applications and libraries.

Para uma introdução mais completa, aos logs do Python, consulte a documentação oficial e os tutoriais e cookbooks, mencionados lá.

Nota: a maioria das funções do módulo de registro utilizado nesta seção ajusta as configurações globais. Se você executar comandos nesta seção ele pode efetivar a saída de outras células se elas forem executadas em uma ordem diferente.

Configurando o Registro de Biblioteca Padrão Python

By default Python Standard Logging only prints log messages at the WARNING, ERROR, or CRITICAL log levels. Since none of the logs emitted by the transpiler use these log levels (they’re all informative) you need to configure logging.

A maneira mais simples de fazer isto é apenas executar:

import logging

logging.basicConfig(level='DEBUG')

A função basicConfig() (veja os docs aqui: https://docs.python.org/3/library/logging.html#logging.basicConfig) configura um manipulador de raiz e formatador. Também especificamos o nível de log <https://docs.python.org/3/library/logging.html#levels> __ para exibir com o level kwarg. Fixá-lo em um nível, também, incluirá níveis mais altos. Por exemplo, se configurar para 'INFO', além do nível INFO, este incluirá, também, os níveis de log WARNING, ERROR, e CRITICAL.

Agora, o ambiente python neste notebook está configurado para emitir mensagens de log para stderr, quando você executar o transpilador. Por exemplo:

Note: basicConfig() will only work when called the first time it’s called. It detects if a root handler and formatter have already been setup (either by using an earlier basicConfig() call or otherwise) and does nothing if they have. Further adjustments will have to by interacting with the handler directly.

from qiskit.providers.fake_provider import FakeTenerife


log_circ = QuantumCircuit(2, 2)
log_circ.h(0)
log_circ.h(1)
log_circ.h(1)
log_circ.x(1)
log_circ.cx(0, 1)
log_circ.measure([0,1], [0,1])

backend = FakeTenerife()

transpile(log_circ, backend);

DEBUG:stevedore.extension:found extension EntryPoint(name='basic', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:BasicSwapPassManager', group='qiskit.transpiler.routing')
DEBUG:stevedore.extension:found extension EntryPoint(name='lookahead', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:LookaheadSwapPassManager', group='qiskit.transpiler.routing')
DEBUG:stevedore.extension:found extension EntryPoint(name='none', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:NoneRoutingPassManager', group='qiskit.transpiler.routing')
DEBUG:stevedore.extension:found extension EntryPoint(name='sabre', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:SabreSwapPassManager', group='qiskit.transpiler.routing')
DEBUG:stevedore.extension:found extension EntryPoint(name='stochastic', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:StochasticSwapPassManager', group='qiskit.transpiler.routing')
INFO:qiskit.transpiler.runningpassmanager:Pass: ContainsInstruction - 0.01121 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: UnitarySynthesis - 0.07796 (ms)
DEBUG:stevedore.extension:found extension EntryPoint(name='clifford.default', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:DefaultSynthesisClifford', group='qiskit.synthesis')
DEBUG:stevedore.extension:found extension EntryPoint(name='linear_function.default', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:DefaultSynthesisLinearFunction', group='qiskit.synthesis')
INFO:qiskit.transpiler.runningpassmanager:Pass: HighLevelSynthesis - 1.30749 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: Unroll3qOrMore - 0.02146 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: SetLayout - 0.00739 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: TrivialLayout - 0.06509 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: CheckMap - 0.09203 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: FullAncillaAllocation - 0.18358 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: EnlargeWithAncilla - 0.11158 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: ApplyLayout - 0.24843 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: ContainsInstruction - 0.01645 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: CheckMap - 0.08273 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: UnitarySynthesis - 0.14734 (ms)
DEBUG:stevedore.extension:found extension EntryPoint(name='clifford.default', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:DefaultSynthesisClifford', group='qiskit.synthesis')
DEBUG:stevedore.extension:found extension EntryPoint(name='linear_function.default', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:DefaultSynthesisLinearFunction', group='qiskit.synthesis')
INFO:qiskit.transpiler.runningpassmanager:Pass: HighLevelSynthesis - 2.12932 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: UnrollCustomDefinitions - 0.18430 (ms)
INFO:qiskit.transpiler.passes.basis.basis_translator:Begin BasisTranslator from source basis {('cx', 2), ('x', 1), ('measure', 1), ('h', 1)} to target basis {'snapshot', 'u1', 'u3', 'u2', 'measure', 'reset', 'id', 'barrier', 'cx', 'delay'}.
DEBUG:qiskit.transpiler.passes.basis.basis_translator:Begining basis search from {('cx', 2), ('x', 1), ('measure', 1), ('h', 1)} to {'snapshot', 'u1', 'u3', 'u2', 'measure', 'reset', 'id', 'barrier', 'cx', 'delay'}.
DEBUG:qiskit.transpiler.passes.basis.basis_translator:Gate r generated using rule
   ┌───────────────────────────────────┐
q: ┤ U3(theta,phi - π/2,π/2 - 1.0*phi) ├
   └───────────────────────────────────┘
 with total cost of 1.0.
DEBUG:qiskit.transpiler.passes.basis.basis_translator:Gate u generated using rule
   ┌───────────────────┐
q: ┤ U3(theta,phi,lam) ├
   └───────────────────┘
 with total cost of 1.0.
DEBUG:qiskit.transpiler.passes.basis.basis_translator:Gate tdg generated using rule
   ┌──────────┐
q: ┤ U1(-π/4) ├
   └──────────┘
 with total cost of 1.0.
DEBUG:qiskit.transpiler.passes.basis.basis_translator:Gate s generated using rule
   ┌─────────┐
q: ┤ U1(π/2) ├
   └─────────┘
 with total cost of 1.0.
DEBUG:qiskit.transpiler.passes.basis.basis_translator:Gate rz generated using rule
global phase: -0.5*theta
   ┌───────────┐
q: ┤ U1(theta) ├
   └───────────┘
 with total cost of 1.0.
DEBUG:qiskit.transpiler.passes.basis.basis_translator:Gate z generated using rule
   ┌───────┐
q: ┤ U1(π) ├
   └───────┘
 with total cost of 1.0.
DEBUG:qiskit.transpiler.passes.basis.basis_translator:Gate ry generated using rule
   ┌──────────────┐
q: ┤ R(theta,π/2) ├
   └──────────────┘
 with total cost of 1.0.
DEBUG:qiskit.transpiler.passes.basis.basis_translator:Gate x generated using rule
   ┌───────────┐
q: ┤ U3(π,0,π) ├
   └───────────┘
 with total cost of 1.0.
DEBUG:qiskit.transpiler.passes.basis.basis_translator:Gate t generated using rule
   ┌─────────┐
q: ┤ U1(π/4) ├
   └─────────┘
 with total cost of 1.0.
DEBUG:qiskit.transpiler.passes.basis.basis_translator:Gate p generated using rule
   ┌───────────┐
q: ┤ U1(theta) ├
   └───────────┘
 with total cost of 1.0.
DEBUG:qiskit.transpiler.passes.basis.basis_translator:Gate h generated using rule
   ┌─────────┐
q: ┤ U2(0,π) ├
   └─────────┘
 with total cost of 1.0.
DEBUG:qiskit.transpiler.passes.basis.basis_translator:Transformation path:
DEBUG:qiskit.transpiler.passes.basis.basis_translator:h/1 => []
   ┌─────────┐
q: ┤ U2(0,π) ├
   └─────────┘
DEBUG:qiskit.transpiler.passes.basis.basis_translator:p/1 => [Parameter(theta)]
   ┌───────────┐
q: ┤ U1(theta) ├
   └───────────┘
DEBUG:qiskit.transpiler.passes.basis.basis_translator:t/1 => []
   ┌─────────┐
q: ┤ U1(π/4) ├
   └─────────┘
DEBUG:qiskit.transpiler.passes.basis.basis_translator:x/1 => []
   ┌───────────┐
q: ┤ U3(π,0,π) ├
   └───────────┘
DEBUG:qiskit.transpiler.passes.basis.basis_translator:ry/1 => [Parameter(theta)]
   ┌──────────────┐
q: ┤ R(theta,π/2) ├
   └──────────────┘
DEBUG:qiskit.transpiler.passes.basis.basis_translator:z/1 => []
   ┌───────┐
q: ┤ U1(π) ├
   └───────┘
DEBUG:qiskit.transpiler.passes.basis.basis_translator:rz/1 => [Parameter(theta)]
global phase: -0.5*theta
   ┌───────────┐
q: ┤ U1(theta) ├
   └───────────┘
DEBUG:qiskit.transpiler.passes.basis.basis_translator:s/1 => []
   ┌─────────┐
q: ┤ U1(π/2) ├
   └─────────┘
DEBUG:qiskit.transpiler.passes.basis.basis_translator:tdg/1 => []
   ┌──────────┐
q: ┤ U1(-π/4) ├
   └──────────┘
DEBUG:qiskit.transpiler.passes.basis.basis_translator:u/1 => [Parameter(theta), Parameter(phi), Parameter(lam)]
   ┌───────────────────┐
q: ┤ U3(theta,phi,lam) ├
   └───────────────────┘
DEBUG:qiskit.transpiler.passes.basis.basis_translator:r/1 => [Parameter(theta), Parameter(phi)]
   ┌───────────────────────────────────┐
q: ┤ U3(theta,phi - π/2,π/2 - 1.0*phi) ├
   └───────────────────────────────────┘
INFO:qiskit.transpiler.passes.basis.basis_translator:Basis translation path search completed in 0.079s.
DEBUG:qiskit.transpiler.passes.basis.basis_translator:Composing transform step: h/1 [] =>
   ┌─────────┐
q: ┤ U2(0,π) ├
   └─────────┘
DEBUG:qiskit.transpiler.passes.basis.basis_translator:Updating transform for mapped instr ('h', 1) h, [] from
      ┌───┐
q270: ┤ h ├
      └───┘
DEBUG:qiskit.transpiler.passes.basis.basis_translator:Updated transform for mapped instr ('h', 1) h, [] to
      ┌─────────┐
q270: ┤ U2(0,π) ├
      └─────────┘
DEBUG:qiskit.transpiler.passes.basis.basis_translator:Composing transform step: p/1 [Parameter(theta)] =>
   ┌───────────┐
q: ┤ U1(theta) ├
   └───────────┘
DEBUG:qiskit.transpiler.passes.basis.basis_translator:Composing transform step: t/1 [] =>
   ┌─────────┐
q: ┤ U1(π/4) ├
   └─────────┘
DEBUG:qiskit.transpiler.passes.basis.basis_translator:Composing transform step: x/1 [] =>
   ┌───────────┐
q: ┤ U3(π,0,π) ├
   └───────────┘
DEBUG:qiskit.transpiler.passes.basis.basis_translator:Updating transform for mapped instr ('x', 1) x, [] from
      ┌───┐
q268: ┤ x ├
      └───┘
DEBUG:qiskit.transpiler.passes.basis.basis_translator:Updated transform for mapped instr ('x', 1) x, [] to
      ┌───────────┐
q268: ┤ U3(π,0,π) ├
      └───────────┘
DEBUG:qiskit.transpiler.passes.basis.basis_translator:Composing transform step: ry/1 [Parameter(theta)] =>
   ┌──────────────┐
q: ┤ R(theta,π/2) ├
   └──────────────┘
DEBUG:qiskit.transpiler.passes.basis.basis_translator:Composing transform step: z/1 [] =>
   ┌───────┐
q: ┤ U1(π) ├
   └───────┘
DEBUG:qiskit.transpiler.passes.basis.basis_translator:Composing transform step: rz/1 [Parameter(theta)] =>
global phase: -0.5*theta
   ┌───────────┐
q: ┤ U1(theta) ├
   └───────────┘
DEBUG:qiskit.transpiler.passes.basis.basis_translator:Composing transform step: s/1 [] =>
   ┌─────────┐
q: ┤ U1(π/2) ├
   └─────────┘
DEBUG:qiskit.transpiler.passes.basis.basis_translator:Composing transform step: tdg/1 [] =>
   ┌──────────┐
q: ┤ U1(-π/4) ├
   └──────────┘
DEBUG:qiskit.transpiler.passes.basis.basis_translator:Composing transform step: u/1 [Parameter(theta), Parameter(phi), Parameter(lam)] =>
   ┌───────────────────┐
q: ┤ U3(theta,phi,lam) ├
   └───────────────────┘
DEBUG:qiskit.transpiler.passes.basis.basis_translator:Composing transform step: r/1 [Parameter(theta), Parameter(phi)] =>
   ┌───────────────────────────────────┐
q: ┤ U3(theta,phi - π/2,π/2 - 1.0*phi) ├
   └───────────────────────────────────┘
INFO:qiskit.transpiler.passes.basis.basis_translator:Basis translation paths composed in 0.045s.
INFO:qiskit.transpiler.passes.basis.basis_translator:Basis translation instructions replaced in 0.000s.
INFO:qiskit.transpiler.runningpassmanager:Pass: BasisTranslator - 127.81143 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: CheckGateDirection - 0.14639 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: GateDirection - 0.28825 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: RemoveResetInZeroState - 0.03529 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: Depth - 0.06032 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: FixedPoint - 0.05436 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: Size - 0.51093 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: FixedPoint - 0.02146 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: Optimize1qGatesDecomposition - 3.89552 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: CXCancellation - 0.05627 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: GatesInBasis - 0.06032 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: Depth - 0.07224 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: FixedPoint - 0.01645 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: Size - 0.05436 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: FixedPoint - 0.01717 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: Optimize1qGatesDecomposition - 2.38466 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: CXCancellation - 0.10848 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: GatesInBasis - 0.08154 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: Depth - 0.10681 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: FixedPoint - 0.01884 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: Size - 0.08702 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: FixedPoint - 0.02027 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: ContainsInstruction - 0.07558 (ms)
INFO:qiskit.compiler.transpiler:Total Transpile Time - 205.91760 (ms)

As you can clearly see here when calling transpile() it now prints 2 types of log messages. The first is at the INFO log level and come from the pass manager. These indicate each pass that was executed and how long that took. The second are at the DEBUG level and come from the StochasticSwap pass and describes the internal operation of that pass. It’s useful for debugging issues in the pass’s operation.

Ajustando o nível do log para o transpiler

O transpilador qiskit usa um único namespace qiskit.transpiler, como usado por logging.getLogger('qiskit.transpiler'). Isso faz com que seja muito fácil ajustar o nível de log apenas para o transpiler. Por exemplo, se você deseja ver mensagens de log no nível INFO ou mais detalhadas você pode executar:

logging.getLogger('qiskit.transpiler').setLevel('INFO')
transpile(log_circ, backend);

DEBUG:stevedore.extension:found extension EntryPoint(name='basic', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:BasicSwapPassManager', group='qiskit.transpiler.routing')
DEBUG:stevedore.extension:found extension EntryPoint(name='lookahead', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:LookaheadSwapPassManager', group='qiskit.transpiler.routing')
DEBUG:stevedore.extension:found extension EntryPoint(name='none', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:NoneRoutingPassManager', group='qiskit.transpiler.routing')
DEBUG:stevedore.extension:found extension EntryPoint(name='sabre', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:SabreSwapPassManager', group='qiskit.transpiler.routing')
DEBUG:stevedore.extension:found extension EntryPoint(name='stochastic', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:StochasticSwapPassManager', group='qiskit.transpiler.routing')
INFO:qiskit.transpiler.runningpassmanager:Pass: ContainsInstruction - 0.00882 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: UnitarySynthesis - 0.04649 (ms)
DEBUG:stevedore.extension:found extension EntryPoint(name='clifford.default', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:DefaultSynthesisClifford', group='qiskit.synthesis')
DEBUG:stevedore.extension:found extension EntryPoint(name='linear_function.default', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:DefaultSynthesisLinearFunction', group='qiskit.synthesis')
INFO:qiskit.transpiler.runningpassmanager:Pass: HighLevelSynthesis - 3.08633 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: Unroll3qOrMore - 0.03195 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: SetLayout - 0.00644 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: TrivialLayout - 0.05007 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: CheckMap - 0.09489 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: FullAncillaAllocation - 0.09966 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: EnlargeWithAncilla - 0.06652 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: ApplyLayout - 0.28276 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: ContainsInstruction - 0.01192 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: CheckMap - 0.06318 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: UnitarySynthesis - 0.12589 (ms)
DEBUG:stevedore.extension:found extension EntryPoint(name='clifford.default', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:DefaultSynthesisClifford', group='qiskit.synthesis')
DEBUG:stevedore.extension:found extension EntryPoint(name='linear_function.default', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:DefaultSynthesisLinearFunction', group='qiskit.synthesis')
INFO:qiskit.transpiler.runningpassmanager:Pass: HighLevelSynthesis - 1.47748 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: UnrollCustomDefinitions - 0.05245 (ms)
INFO:qiskit.transpiler.passes.basis.basis_translator:Begin BasisTranslator from source basis {('cx', 2), ('x', 1), ('measure', 1), ('h', 1)} to target basis {'snapshot', 'u1', 'u3', 'u2', 'measure', 'reset', 'id', 'barrier', 'cx', 'delay'}.
INFO:qiskit.transpiler.passes.basis.basis_translator:Basis translation path search completed in 0.001s.
INFO:qiskit.transpiler.passes.basis.basis_translator:Basis translation paths composed in 0.002s.
INFO:qiskit.transpiler.passes.basis.basis_translator:Basis translation instructions replaced in 0.000s.
INFO:qiskit.transpiler.runningpassmanager:Pass: BasisTranslator - 7.40910 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: CheckGateDirection - 0.07319 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: GateDirection - 0.15426 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: RemoveResetInZeroState - 0.02313 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: Depth - 0.08106 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: FixedPoint - 0.01669 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: Size - 0.04125 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: FixedPoint - 0.02027 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: Optimize1qGatesDecomposition - 4.40145 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: CXCancellation - 0.13161 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: GatesInBasis - 0.08607 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: Depth - 0.05746 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: FixedPoint - 0.01931 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: Size - 0.13041 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: FixedPoint - 0.02146 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: Optimize1qGatesDecomposition - 1.33228 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: CXCancellation - 0.07725 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: GatesInBasis - 0.10133 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: Depth - 0.10204 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: FixedPoint - 0.02313 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: Size - 0.06318 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: FixedPoint - 0.01836 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: ContainsInstruction - 0.04482 (ms)
INFO:qiskit.compiler.transpiler:Total Transpile Time - 79.09131 (ms)

Configurando o log para trabalhar com execução paralela

Ao executar o transpilador com vários circuitos, por padrão, estes circuitos são transpilados em paralelo. Se você deseja fazer isto com o registro de log ativado e ser capaz de entender a saída, algumas etapas adicionais são necessárias.

If you were just to enable logging as above and then pass transpile() multiple circuits you’ll get results that are difficult to decipher. For example:

# Change log level back to DEBUG
logging.getLogger('qiskit.transpiler').setLevel('DEBUG')
# Transpile multiple circuits
circuits = [log_circ, log_circ]
transpile(circuits, backend);

DEBUG:stevedore.extension:found extension EntryPoint(name='basic', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:BasicSwapPassManager', group='qiskit.transpiler.routing')
DEBUG:stevedore.extension:found extension EntryPoint(name='basic', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:BasicSwapPassManager', group='qiskit.transpiler.routing')
DEBUG:stevedore.extension:found extension EntryPoint(name='lookahead', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:LookaheadSwapPassManager', group='qiskit.transpiler.routing')
DEBUG:stevedore.extension:found extension EntryPoint(name='lookahead', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:LookaheadSwapPassManager', group='qiskit.transpiler.routing')
DEBUG:stevedore.extension:found extension EntryPoint(name='none', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:NoneRoutingPassManager', group='qiskit.transpiler.routing')
DEBUG:stevedore.extension:found extension EntryPoint(name='none', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:NoneRoutingPassManager', group='qiskit.transpiler.routing')
DEBUG:stevedore.extension:found extension EntryPoint(name='sabre', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:SabreSwapPassManager', group='qiskit.transpiler.routing')
DEBUG:stevedore.extension:found extension EntryPoint(name='sabre', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:SabreSwapPassManager', group='qiskit.transpiler.routing')
DEBUG:stevedore.extension:found extension EntryPoint(name='stochastic', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:StochasticSwapPassManager', group='qiskit.transpiler.routing')
DEBUG:stevedore.extension:found extension EntryPoint(name='stochastic', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:StochasticSwapPassManager', group='qiskit.transpiler.routing')
INFO:qiskit.transpiler.runningpassmanager:Pass: ContainsInstruction - 0.11110 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: UnitarySynthesis - 0.27680 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: ContainsInstruction - 0.14544 (ms)
DEBUG:stevedore.extension:found extension EntryPoint(name='clifford.default', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:DefaultSynthesisClifford', group='qiskit.synthesis')
INFO:qiskit.transpiler.runningpassmanager:Pass: UnitarySynthesis - 0.21100 (ms)
DEBUG:stevedore.extension:found extension EntryPoint(name='clifford.default', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:DefaultSynthesisClifford', group='qiskit.synthesis')
DEBUG:stevedore.extension:found extension EntryPoint(name='linear_function.default', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:DefaultSynthesisLinearFunction', group='qiskit.synthesis')
DEBUG:stevedore.extension:found extension EntryPoint(name='linear_function.default', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:DefaultSynthesisLinearFunction', group='qiskit.synthesis')
INFO:qiskit.transpiler.runningpassmanager:Pass: HighLevelSynthesis - 3.80325 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: HighLevelSynthesis - 3.51930 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: Unroll3qOrMore - 0.07844 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: Unroll3qOrMore - 0.07057 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: SetLayout - 0.02217 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: SetLayout - 0.00978 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: TrivialLayout - 0.27537 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: TrivialLayout - 0.20695 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: CheckMap - 0.25034 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: CheckMap - 0.25201 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: FullAncillaAllocation - 0.17428 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: EnlargeWithAncilla - 0.14925 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: FullAncillaAllocation - 0.25582 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: EnlargeWithAncilla - 0.23961 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: ApplyLayout - 0.50950 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: ContainsInstruction - 0.08559 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: ApplyLayout - 1.11890 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: CheckMap - 0.11158 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: ContainsInstruction - 0.01860 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: CheckMap - 0.09012 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: UnitarySynthesis - 0.16379 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: UnitarySynthesis - 0.11730 (ms)
DEBUG:stevedore.extension:found extension EntryPoint(name='clifford.default', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:DefaultSynthesisClifford', group='qiskit.synthesis')
DEBUG:stevedore.extension:found extension EntryPoint(name='clifford.default', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:DefaultSynthesisClifford', group='qiskit.synthesis')
DEBUG:stevedore.extension:found extension EntryPoint(name='linear_function.default', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:DefaultSynthesisLinearFunction', group='qiskit.synthesis')
INFO:qiskit.transpiler.runningpassmanager:Pass: HighLevelSynthesis - 3.08251 (ms)
DEBUG:stevedore.extension:found extension EntryPoint(name='linear_function.default', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:DefaultSynthesisLinearFunction', group='qiskit.synthesis')
INFO:qiskit.transpiler.runningpassmanager:Pass: UnrollCustomDefinitions - 0.16665 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: HighLevelSynthesis - 2.89869 (ms)
INFO:qiskit.transpiler.passes.basis.basis_translator:Begin BasisTranslator from source basis {('cx', 2), ('x', 1), ('measure', 1), ('h', 1)} to target basis {'snapshot', 'u1', 'u3', 'u2', 'measure', 'reset', 'id', 'barrier', 'cx', 'delay'}.
INFO:qiskit.transpiler.runningpassmanager:Pass: UnrollCustomDefinitions - 0.64802 (ms)
DEBUG:qiskit.transpiler.passes.basis.basis_translator:Begining basis search from {('cx', 2), ('x', 1), ('measure', 1), ('h', 1)} to {'snapshot', 'u1', 'u3', 'u2', 'measure', 'reset', 'id', 'barrier', 'cx', 'delay'}.
INFO:qiskit.transpiler.passes.basis.basis_translator:Begin BasisTranslator from source basis {('cx', 2), ('x', 1), ('measure', 1), ('h', 1)} to target basis {'snapshot', 'u1', 'u3', 'u2', 'measure', 'reset', 'id', 'barrier', 'cx', 'delay'}.
DEBUG:qiskit.transpiler.passes.basis.basis_translator:Begining basis search from {('cx', 2), ('x', 1), ('measure', 1), ('h', 1)} to {'snapshot', 'u1', 'u3', 'u2', 'measure', 'reset', 'id', 'barrier', 'cx', 'delay'}.
DEBUG:qiskit.transpiler.passes.basis.basis_translator:Gate r generated using rule
   ┌───────────────────────────────────┐
q: ┤ U3(theta,phi - π/2,π/2 - 1.0*phi) ├
   └───────────────────────────────────┘
 with total cost of 1.0.
DEBUG:qiskit.transpiler.passes.basis.basis_translator:Gate r generated using rule
   ┌───────────────────────────────────┐
q: ┤ U3(theta,phi - π/2,π/2 - 1.0*phi) ├
   └───────────────────────────────────┘
 with total cost of 1.0.
DEBUG:qiskit.transpiler.passes.basis.basis_translator:Gate u generated using rule
   ┌───────────────────┐
q: ┤ U3(theta,phi,lam) ├
   └───────────────────┘
 with total cost of 1.0.
DEBUG:qiskit.transpiler.passes.basis.basis_translator:Gate u generated using rule
   ┌───────────────────┐
q: ┤ U3(theta,phi,lam) ├
   └───────────────────┘
 with total cost of 1.0.
DEBUG:qiskit.transpiler.passes.basis.basis_translator:Gate tdg generated using rule
   ┌──────────┐
q: ┤ U1(-π/4) ├
   └──────────┘
 with total cost of 1.0.
DEBUG:qiskit.transpiler.passes.basis.basis_translator:Gate s generated using rule
   ┌─────────┐
q: ┤ U1(π/2) ├
   └─────────┘
 with total cost of 1.0.
DEBUG:qiskit.transpiler.passes.basis.basis_translator:Gate tdg generated using rule
   ┌──────────┐
q: ┤ U1(-π/4) ├
   └──────────┘
 with total cost of 1.0.
DEBUG:qiskit.transpiler.passes.basis.basis_translator:Gate s generated using rule
   ┌─────────┐
q: ┤ U1(π/2) ├
   └─────────┘
 with total cost of 1.0.
DEBUG:qiskit.transpiler.passes.basis.basis_translator:Gate rz generated using rule
global phase: -0.5*theta
   ┌───────────┐
q: ┤ U1(theta) ├
   └───────────┘
 with total cost of 1.0.
DEBUG:qiskit.transpiler.passes.basis.basis_translator:Gate z generated using rule
   ┌───────┐
q: ┤ U1(π) ├
   └───────┘
 with total cost of 1.0.
DEBUG:qiskit.transpiler.passes.basis.basis_translator:Gate rz generated using rule
global phase: -0.5*theta
   ┌───────────┐
q: ┤ U1(theta) ├
   └───────────┘
 with total cost of 1.0.
DEBUG:qiskit.transpiler.passes.basis.basis_translator:Gate ry generated using rule
   ┌──────────────┐
q: ┤ R(theta,π/2) ├
   └──────────────┘
 with total cost of 1.0.
DEBUG:qiskit.transpiler.passes.basis.basis_translator:Gate z generated using rule
   ┌───────┐
q: ┤ U1(π) ├
   └───────┘
 with total cost of 1.0.
DEBUG:qiskit.transpiler.passes.basis.basis_translator:Gate x generated using rule
   ┌───────────┐
q: ┤ U3(π,0,π) ├
   └───────────┘
 with total cost of 1.0.
DEBUG:qiskit.transpiler.passes.basis.basis_translator:Gate ry generated using rule
   ┌──────────────┐
q: ┤ R(theta,π/2) ├
   └──────────────┘
 with total cost of 1.0.
DEBUG:qiskit.transpiler.passes.basis.basis_translator:Gate x generated using rule
   ┌───────────┐
q: ┤ U3(π,0,π) ├
   └───────────┘
 with total cost of 1.0.
DEBUG:qiskit.transpiler.passes.basis.basis_translator:Gate t generated using rule
   ┌─────────┐
q: ┤ U1(π/4) ├
   └─────────┘
 with total cost of 1.0.
DEBUG:qiskit.transpiler.passes.basis.basis_translator:Gate p generated using rule
   ┌───────────┐
q: ┤ U1(theta) ├
   └───────────┘
 with total cost of 1.0.
DEBUG:qiskit.transpiler.passes.basis.basis_translator:Gate t generated using rule
   ┌─────────┐
q: ┤ U1(π/4) ├
   └─────────┘
 with total cost of 1.0.
DEBUG:qiskit.transpiler.passes.basis.basis_translator:Gate h generated using rule
   ┌─────────┐
q: ┤ U2(0,π) ├
   └─────────┘
 with total cost of 1.0.
DEBUG:qiskit.transpiler.passes.basis.basis_translator:Gate p generated using rule
   ┌───────────┐
q: ┤ U1(theta) ├
   └───────────┘
 with total cost of 1.0.
DEBUG:qiskit.transpiler.passes.basis.basis_translator:Transformation path:
DEBUG:qiskit.transpiler.passes.basis.basis_translator:Gate h generated using rule
   ┌─────────┐
q: ┤ U2(0,π) ├
   └─────────┘
 with total cost of 1.0.
DEBUG:qiskit.transpiler.passes.basis.basis_translator:Transformation path:
DEBUG:qiskit.transpiler.passes.basis.basis_translator:h/1 => []
   ┌─────────┐
q: ┤ U2(0,π) ├
   └─────────┘
DEBUG:qiskit.transpiler.passes.basis.basis_translator:h/1 => []
   ┌─────────┐
q: ┤ U2(0,π) ├
   └─────────┘
DEBUG:qiskit.transpiler.passes.basis.basis_translator:p/1 => [Parameter(theta)]
   ┌───────────┐
q: ┤ U1(theta) ├
   └───────────┘
DEBUG:qiskit.transpiler.passes.basis.basis_translator:t/1 => []
   ┌─────────┐
q: ┤ U1(π/4) ├
   └─────────┘
DEBUG:qiskit.transpiler.passes.basis.basis_translator:p/1 => [Parameter(theta)]
   ┌───────────┐
q: ┤ U1(theta) ├
   └───────────┘
DEBUG:qiskit.transpiler.passes.basis.basis_translator:t/1 => []
   ┌─────────┐
q: ┤ U1(π/4) ├
   └─────────┘
DEBUG:qiskit.transpiler.passes.basis.basis_translator:x/1 => []
   ┌───────────┐
q: ┤ U3(π,0,π) ├
   └───────────┘
DEBUG:qiskit.transpiler.passes.basis.basis_translator:ry/1 => [Parameter(theta)]
   ┌──────────────┐
q: ┤ R(theta,π/2) ├
   └──────────────┘
DEBUG:qiskit.transpiler.passes.basis.basis_translator:x/1 => []
   ┌───────────┐
q: ┤ U3(π,0,π) ├
   └───────────┘
DEBUG:qiskit.transpiler.passes.basis.basis_translator:z/1 => []
   ┌───────┐
q: ┤ U1(π) ├
   └───────┘
DEBUG:qiskit.transpiler.passes.basis.basis_translator:ry/1 => [Parameter(theta)]
   ┌──────────────┐
q: ┤ R(theta,π/2) ├
   └──────────────┘
DEBUG:qiskit.transpiler.passes.basis.basis_translator:z/1 => []
   ┌───────┐
q: ┤ U1(π) ├
   └───────┘
DEBUG:qiskit.transpiler.passes.basis.basis_translator:rz/1 => [Parameter(theta)]
global phase: -0.5*theta
   ┌───────────┐
q: ┤ U1(theta) ├
   └───────────┘
DEBUG:qiskit.transpiler.passes.basis.basis_translator:s/1 => []
   ┌─────────┐
q: ┤ U1(π/2) ├
   └─────────┘
DEBUG:qiskit.transpiler.passes.basis.basis_translator:rz/1 => [Parameter(theta)]
global phase: -0.5*theta
   ┌───────────┐
q: ┤ U1(theta) ├
   └───────────┘
DEBUG:qiskit.transpiler.passes.basis.basis_translator:tdg/1 => []
   ┌──────────┐
q: ┤ U1(-π/4) ├
   └──────────┘
DEBUG:qiskit.transpiler.passes.basis.basis_translator:s/1 => []
   ┌─────────┐
q: ┤ U1(π/2) ├
   └─────────┘
DEBUG:qiskit.transpiler.passes.basis.basis_translator:u/1 => [Parameter(theta), Parameter(phi), Parameter(lam)]
   ┌───────────────────┐
q: ┤ U3(theta,phi,lam) ├
   └───────────────────┘
DEBUG:qiskit.transpiler.passes.basis.basis_translator:tdg/1 => []
   ┌──────────┐
q: ┤ U1(-π/4) ├
   └──────────┘
DEBUG:qiskit.transpiler.passes.basis.basis_translator:u/1 => [Parameter(theta), Parameter(phi), Parameter(lam)]
   ┌───────────────────┐
q: ┤ U3(theta,phi,lam) ├
   └───────────────────┘
DEBUG:qiskit.transpiler.passes.basis.basis_translator:r/1 => [Parameter(theta), Parameter(phi)]
   ┌───────────────────────────────────┐
q: ┤ U3(theta,phi - π/2,π/2 - 1.0*phi) ├
   └───────────────────────────────────┘
INFO:qiskit.transpiler.passes.basis.basis_translator:Basis translation path search completed in 0.096s.
DEBUG:qiskit.transpiler.passes.basis.basis_translator:r/1 => [Parameter(theta), Parameter(phi)]
   ┌───────────────────────────────────┐
q: ┤ U3(theta,phi - π/2,π/2 - 1.0*phi) ├
   └───────────────────────────────────┘
INFO:qiskit.transpiler.passes.basis.basis_translator:Basis translation path search completed in 0.092s.
DEBUG:qiskit.transpiler.passes.basis.basis_translator:Composing transform step: h/1 [] =>
   ┌─────────┐
q: ┤ U2(0,π) ├
   └─────────┘
DEBUG:qiskit.transpiler.passes.basis.basis_translator:Composing transform step: h/1 [] =>
   ┌─────────┐
q: ┤ U2(0,π) ├
   └─────────┘
DEBUG:qiskit.transpiler.passes.basis.basis_translator:Updating transform for mapped instr ('h', 1) h, [] from
      ┌───┐
q284: ┤ h ├
      └───┘
DEBUG:qiskit.transpiler.passes.basis.basis_translator:Updating transform for mapped instr ('h', 1) h, [] from
      ┌───┐
q284: ┤ h ├
      └───┘
DEBUG:qiskit.transpiler.passes.basis.basis_translator:Updated transform for mapped instr ('h', 1) h, [] to
      ┌─────────┐
q284: ┤ U2(0,π) ├
      └─────────┘
DEBUG:qiskit.transpiler.passes.basis.basis_translator:Composing transform step: p/1 [Parameter(theta)] =>
   ┌───────────┐
q: ┤ U1(theta) ├
   └───────────┘
DEBUG:qiskit.transpiler.passes.basis.basis_translator:Updated transform for mapped instr ('h', 1) h, [] to
      ┌─────────┐
q284: ┤ U2(0,π) ├
      └─────────┘
DEBUG:qiskit.transpiler.passes.basis.basis_translator:Composing transform step: t/1 [] =>
   ┌─────────┐
q: ┤ U1(π/4) ├
   └─────────┘
DEBUG:qiskit.transpiler.passes.basis.basis_translator:Composing transform step: p/1 [Parameter(theta)] =>
   ┌───────────┐
q: ┤ U1(theta) ├
   └───────────┘
DEBUG:qiskit.transpiler.passes.basis.basis_translator:Composing transform step: t/1 [] =>
   ┌─────────┐
q: ┤ U1(π/4) ├
   └─────────┘
DEBUG:qiskit.transpiler.passes.basis.basis_translator:Composing transform step: x/1 [] =>
   ┌───────────┐
q: ┤ U3(π,0,π) ├
   └───────────┘
DEBUG:qiskit.transpiler.passes.basis.basis_translator:Composing transform step: x/1 [] =>
   ┌───────────┐
q: ┤ U3(π,0,π) ├
   └───────────┘
DEBUG:qiskit.transpiler.passes.basis.basis_translator:Updating transform for mapped instr ('x', 1) x, [] from
      ┌───┐
q282: ┤ x ├
      └───┘
DEBUG:qiskit.transpiler.passes.basis.basis_translator:Updating transform for mapped instr ('x', 1) x, [] from
      ┌───┐
q282: ┤ x ├
      └───┘
DEBUG:qiskit.transpiler.passes.basis.basis_translator:Updated transform for mapped instr ('x', 1) x, [] to
      ┌───────────┐
q282: ┤ U3(π,0,π) ├
      └───────────┘
DEBUG:qiskit.transpiler.passes.basis.basis_translator:Updated transform for mapped instr ('x', 1) x, [] to
      ┌───────────┐
q282: ┤ U3(π,0,π) ├
      └───────────┘
DEBUG:qiskit.transpiler.passes.basis.basis_translator:Composing transform step: ry/1 [Parameter(theta)] =>
   ┌──────────────┐
q: ┤ R(theta,π/2) ├
   └──────────────┘
DEBUG:qiskit.transpiler.passes.basis.basis_translator:Composing transform step: ry/1 [Parameter(theta)] =>
   ┌──────────────┐
q: ┤ R(theta,π/2) ├
   └──────────────┘
DEBUG:qiskit.transpiler.passes.basis.basis_translator:Composing transform step: z/1 [] =>
   ┌───────┐
q: ┤ U1(π) ├
   └───────┘
DEBUG:qiskit.transpiler.passes.basis.basis_translator:Composing transform step: z/1 [] =>
   ┌───────┐
q: ┤ U1(π) ├
   └───────┘
DEBUG:qiskit.transpiler.passes.basis.basis_translator:Composing transform step: rz/1 [Parameter(theta)] =>
global phase: -0.5*theta
   ┌───────────┐
q: ┤ U1(theta) ├
   └───────────┘
DEBUG:qiskit.transpiler.passes.basis.basis_translator:Composing transform step: rz/1 [Parameter(theta)] =>
global phase: -0.5*theta
   ┌───────────┐
q: ┤ U1(theta) ├
   └───────────┘
DEBUG:qiskit.transpiler.passes.basis.basis_translator:Composing transform step: s/1 [] =>
   ┌─────────┐
q: ┤ U1(π/2) ├
   └─────────┘
DEBUG:qiskit.transpiler.passes.basis.basis_translator:Composing transform step: s/1 [] =>
   ┌─────────┐
q: ┤ U1(π/2) ├
   └─────────┘
DEBUG:qiskit.transpiler.passes.basis.basis_translator:Composing transform step: tdg/1 [] =>
   ┌──────────┐
q: ┤ U1(-π/4) ├
   └──────────┘
DEBUG:qiskit.transpiler.passes.basis.basis_translator:Composing transform step: tdg/1 [] =>
   ┌──────────┐
q: ┤ U1(-π/4) ├
   └──────────┘
DEBUG:qiskit.transpiler.passes.basis.basis_translator:Composing transform step: u/1 [Parameter(theta), Parameter(phi), Parameter(lam)] =>
   ┌───────────────────┐
q: ┤ U3(theta,phi,lam) ├
   └───────────────────┘
DEBUG:qiskit.transpiler.passes.basis.basis_translator:Composing transform step: u/1 [Parameter(theta), Parameter(phi), Parameter(lam)] =>
   ┌───────────────────┐
q: ┤ U3(theta,phi,lam) ├
   └───────────────────┘
DEBUG:qiskit.transpiler.passes.basis.basis_translator:Composing transform step: r/1 [Parameter(theta), Parameter(phi)] =>
   ┌───────────────────────────────────┐
q: ┤ U3(theta,phi - π/2,π/2 - 1.0*phi) ├
   └───────────────────────────────────┘
DEBUG:qiskit.transpiler.passes.basis.basis_translator:Composing transform step: r/1 [Parameter(theta), Parameter(phi)] =>
   ┌───────────────────────────────────┐
q: ┤ U3(theta,phi - π/2,π/2 - 1.0*phi) ├
   └───────────────────────────────────┘
INFO:qiskit.transpiler.passes.basis.basis_translator:Basis translation paths composed in 0.054s.
INFO:qiskit.transpiler.passes.basis.basis_translator:Basis translation paths composed in 0.059s.
INFO:qiskit.transpiler.passes.basis.basis_translator:Basis translation instructions replaced in 0.000s.
INFO:qiskit.transpiler.passes.basis.basis_translator:Basis translation instructions replaced in 0.000s.
INFO:qiskit.transpiler.runningpassmanager:Pass: BasisTranslator - 157.53222 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: BasisTranslator - 164.86216 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: CheckGateDirection - 0.11420 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: CheckGateDirection - 0.15402 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: GateDirection - 0.24891 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: GateDirection - 0.38290 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: RemoveResetInZeroState - 0.12541 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: RemoveResetInZeroState - 0.08464 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: Depth - 0.13971 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: Depth - 0.09847 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: FixedPoint - 0.04601 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: FixedPoint - 0.03552 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: Size - 0.10777 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: Size - 0.07534 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: FixedPoint - 0.03409 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: FixedPoint - 0.02384 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: Optimize1qGatesDecomposition - 5.46145 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: CXCancellation - 0.15616 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: GatesInBasis - 0.17238 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: Depth - 0.06294 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: Optimize1qGatesDecomposition - 6.20103 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: FixedPoint - 0.02456 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: CXCancellation - 0.20838 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: Size - 0.05889 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: GatesInBasis - 0.08988 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: FixedPoint - 0.02050 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: Depth - 0.09155 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: Optimize1qGatesDecomposition - 1.33586 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: FixedPoint - 0.02384 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: CXCancellation - 0.11396 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: Size - 0.06008 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: FixedPoint - 0.01812 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: GatesInBasis - 0.07248 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: Depth - 0.12565 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: Optimize1qGatesDecomposition - 1.33085 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: FixedPoint - 0.01884 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: CXCancellation - 0.10204 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: Size - 0.06866 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: GatesInBasis - 0.05865 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: FixedPoint - 0.02265 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: Depth - 0.11039 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: ContainsInstruction - 0.06700 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: FixedPoint - 0.02861 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: Size - 0.07248 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: FixedPoint - 0.05746 (ms)
INFO:qiskit.transpiler.runningpassmanager:Pass: ContainsInstruction - 0.06485 (ms)
INFO:qiskit.compiler.transpiler:Total Transpile Time - 401.94011 (ms)

As you can see here we get log messages from all 3 circuits being transpiled together. There is no way to know which pass is part of which circuit’s transpilation. Luckily Python logging provides tools to deal with this. The simplest one is to just change the log formatter so that includes additional information so we can associate a log message with the process it came from.

formatter = logging.Formatter('%(name)s - %(processName)-10s - %(levelname)s: %(message)s')
handler = logging.getLogger().handlers[0]
handler.setFormatter(formatter)

Em seguida, reexecute a chamada transpile() e veja o novo formatador de log.

transpile(circuits, backend);

stevedore.extension - ForkProcess-8 - DEBUG: found extension EntryPoint(name='basic', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:BasicSwapPassManager', group='qiskit.transpiler.routing')
stevedore.extension - ForkProcess-7 - DEBUG: found extension EntryPoint(name='basic', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:BasicSwapPassManager', group='qiskit.transpiler.routing')
stevedore.extension - ForkProcess-7 - DEBUG: found extension EntryPoint(name='lookahead', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:LookaheadSwapPassManager', group='qiskit.transpiler.routing')
stevedore.extension - ForkProcess-8 - DEBUG: found extension EntryPoint(name='lookahead', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:LookaheadSwapPassManager', group='qiskit.transpiler.routing')
stevedore.extension - ForkProcess-7 - DEBUG: found extension EntryPoint(name='none', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:NoneRoutingPassManager', group='qiskit.transpiler.routing')
stevedore.extension - ForkProcess-8 - DEBUG: found extension EntryPoint(name='none', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:NoneRoutingPassManager', group='qiskit.transpiler.routing')
stevedore.extension - ForkProcess-8 - DEBUG: found extension EntryPoint(name='sabre', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:SabreSwapPassManager', group='qiskit.transpiler.routing')
stevedore.extension - ForkProcess-7 - DEBUG: found extension EntryPoint(name='sabre', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:SabreSwapPassManager', group='qiskit.transpiler.routing')
stevedore.extension - ForkProcess-8 - DEBUG: found extension EntryPoint(name='stochastic', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:StochasticSwapPassManager', group='qiskit.transpiler.routing')
stevedore.extension - ForkProcess-7 - DEBUG: found extension EntryPoint(name='stochastic', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:StochasticSwapPassManager', group='qiskit.transpiler.routing')
qiskit.transpiler.runningpassmanager - ForkProcess-8 - INFO: Pass: ContainsInstruction - 0.03219 (ms)
qiskit.transpiler.runningpassmanager - ForkProcess-7 - INFO: Pass: ContainsInstruction - 0.03409 (ms)
qiskit.transpiler.runningpassmanager - ForkProcess-7 - INFO: Pass: UnitarySynthesis - 0.22340 (ms)
qiskit.transpiler.runningpassmanager - ForkProcess-8 - INFO: Pass: UnitarySynthesis - 0.22054 (ms)
stevedore.extension - ForkProcess-8 - DEBUG: found extension EntryPoint(name='clifford.default', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:DefaultSynthesisClifford', group='qiskit.synthesis')
stevedore.extension - ForkProcess-7 - DEBUG: found extension EntryPoint(name='clifford.default', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:DefaultSynthesisClifford', group='qiskit.synthesis')
stevedore.extension - ForkProcess-8 - DEBUG: found extension EntryPoint(name='linear_function.default', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:DefaultSynthesisLinearFunction', group='qiskit.synthesis')
stevedore.extension - ForkProcess-7 - DEBUG: found extension EntryPoint(name='linear_function.default', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:DefaultSynthesisLinearFunction', group='qiskit.synthesis')
qiskit.transpiler.runningpassmanager - ForkProcess-7 - INFO: Pass: HighLevelSynthesis - 4.45032 (ms)
qiskit.transpiler.runningpassmanager - ForkProcess-8 - INFO: Pass: HighLevelSynthesis - 3.88885 (ms)
qiskit.transpiler.runningpassmanager - ForkProcess-8 - INFO: Pass: Unroll3qOrMore - 0.06819 (ms)
qiskit.transpiler.runningpassmanager - ForkProcess-7 - INFO: Pass: Unroll3qOrMore - 0.09251 (ms)
qiskit.transpiler.runningpassmanager - ForkProcess-8 - INFO: Pass: SetLayout - 0.02050 (ms)
qiskit.transpiler.runningpassmanager - ForkProcess-7 - INFO: Pass: SetLayout - 0.03481 (ms)
qiskit.transpiler.runningpassmanager - ForkProcess-7 - INFO: Pass: TrivialLayout - 0.19765 (ms)
qiskit.transpiler.runningpassmanager - ForkProcess-8 - INFO: Pass: TrivialLayout - 0.20719 (ms)
qiskit.transpiler.runningpassmanager - ForkProcess-7 - INFO: Pass: CheckMap - 0.23437 (ms)
qiskit.transpiler.runningpassmanager - ForkProcess-8 - INFO: Pass: CheckMap - 0.21529 (ms)
qiskit.transpiler.runningpassmanager - ForkProcess-7 - INFO: Pass: FullAncillaAllocation - 0.22936 (ms)
qiskit.transpiler.runningpassmanager - ForkProcess-8 - INFO: Pass: FullAncillaAllocation - 0.19598 (ms)
qiskit.transpiler.runningpassmanager - ForkProcess-7 - INFO: Pass: EnlargeWithAncilla - 0.20957 (ms)
qiskit.transpiler.runningpassmanager - ForkProcess-8 - INFO: Pass: EnlargeWithAncilla - 0.20599 (ms)
qiskit.transpiler.runningpassmanager - ForkProcess-8 - INFO: Pass: ApplyLayout - 1.73903 (ms)
qiskit.transpiler.runningpassmanager - ForkProcess-7 - INFO: Pass: ApplyLayout - 1.93524 (ms)
qiskit.transpiler.runningpassmanager - ForkProcess-8 - INFO: Pass: ContainsInstruction - 0.16189 (ms)
qiskit.transpiler.runningpassmanager - ForkProcess-7 - INFO: Pass: ContainsInstruction - 0.08154 (ms)
qiskit.transpiler.runningpassmanager - ForkProcess-8 - INFO: Pass: CheckMap - 0.11396 (ms)
qiskit.transpiler.runningpassmanager - ForkProcess-7 - INFO: Pass: CheckMap - 0.10371 (ms)
qiskit.transpiler.runningpassmanager - ForkProcess-7 - INFO: Pass: UnitarySynthesis - 0.12875 (ms)
qiskit.transpiler.runningpassmanager - ForkProcess-8 - INFO: Pass: UnitarySynthesis - 0.09084 (ms)
stevedore.extension - ForkProcess-8 - DEBUG: found extension EntryPoint(name='clifford.default', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:DefaultSynthesisClifford', group='qiskit.synthesis')
stevedore.extension - ForkProcess-7 - DEBUG: found extension EntryPoint(name='clifford.default', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:DefaultSynthesisClifford', group='qiskit.synthesis')
stevedore.extension - ForkProcess-7 - DEBUG: found extension EntryPoint(name='linear_function.default', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:DefaultSynthesisLinearFunction', group='qiskit.synthesis')
stevedore.extension - ForkProcess-8 - DEBUG: found extension EntryPoint(name='linear_function.default', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:DefaultSynthesisLinearFunction', group='qiskit.synthesis')
qiskit.transpiler.runningpassmanager - ForkProcess-7 - INFO: Pass: HighLevelSynthesis - 7.49135 (ms)
qiskit.transpiler.runningpassmanager - ForkProcess-8 - INFO: Pass: HighLevelSynthesis - 10.27989 (ms)
qiskit.transpiler.runningpassmanager - ForkProcess-7 - INFO: Pass: UnrollCustomDefinitions - 0.27299 (ms)
qiskit.transpiler.runningpassmanager - ForkProcess-8 - INFO: Pass: UnrollCustomDefinitions - 0.24176 (ms)
qiskit.transpiler.passes.basis.basis_translator - ForkProcess-7 - INFO: Begin BasisTranslator from source basis {('cx', 2), ('x', 1), ('measure', 1), ('h', 1)} to target basis {'snapshot', 'u1', 'u3', 'u2', 'measure', 'reset', 'id', 'barrier', 'cx', 'delay'}.
qiskit.transpiler.passes.basis.basis_translator - ForkProcess-8 - INFO: Begin BasisTranslator from source basis {('cx', 2), ('x', 1), ('measure', 1), ('h', 1)} to target basis {'snapshot', 'u1', 'u3', 'u2', 'measure', 'reset', 'id', 'barrier', 'cx', 'delay'}.
qiskit.transpiler.passes.basis.basis_translator - ForkProcess-7 - DEBUG: Begining basis search from {('cx', 2), ('x', 1), ('measure', 1), ('h', 1)} to {'snapshot', 'u1', 'u3', 'u2', 'measure', 'reset', 'id', 'barrier', 'cx', 'delay'}.
qiskit.transpiler.passes.basis.basis_translator - ForkProcess-8 - DEBUG: Begining basis search from {('cx', 2), ('x', 1), ('measure', 1), ('h', 1)} to {'snapshot', 'u1', 'u3', 'u2', 'measure', 'reset', 'id', 'barrier', 'cx', 'delay'}.
qiskit.transpiler.passes.basis.basis_translator - ForkProcess-8 - DEBUG: Gate r generated using rule
   ┌───────────────────────────────────┐
q: ┤ U3(theta,phi - π/2,π/2 - 1.0*phi) ├
   └───────────────────────────────────┘
 with total cost of 1.0.
qiskit.transpiler.passes.basis.basis_translator - ForkProcess-7 - DEBUG: Gate r generated using rule
   ┌───────────────────────────────────┐
q: ┤ U3(theta,phi - π/2,π/2 - 1.0*phi) ├
   └───────────────────────────────────┘
 with total cost of 1.0.
qiskit.transpiler.passes.basis.basis_translator - ForkProcess-8 - DEBUG: Gate u generated using rule
   ┌───────────────────┐
q: ┤ U3(theta,phi,lam) ├
   └───────────────────┘
 with total cost of 1.0.
qiskit.transpiler.passes.basis.basis_translator - ForkProcess-7 - DEBUG: Gate u generated using rule
   ┌───────────────────┐
q: ┤ U3(theta,phi,lam) ├
   └───────────────────┘
 with total cost of 1.0.
qiskit.transpiler.passes.basis.basis_translator - ForkProcess-8 - DEBUG: Gate tdg generated using rule
   ┌──────────┐
q: ┤ U1(-π/4) ├
   └──────────┘
 with total cost of 1.0.
qiskit.transpiler.passes.basis.basis_translator - ForkProcess-7 - DEBUG: Gate tdg generated using rule
   ┌──────────┐
q: ┤ U1(-π/4) ├
   └──────────┘
 with total cost of 1.0.
qiskit.transpiler.passes.basis.basis_translator - ForkProcess-8 - DEBUG: Gate s generated using rule
   ┌─────────┐
q: ┤ U1(π/2) ├
   └─────────┘
 with total cost of 1.0.
qiskit.transpiler.passes.basis.basis_translator - ForkProcess-7 - DEBUG: Gate s generated using rule
   ┌─────────┐
q: ┤ U1(π/2) ├
   └─────────┘
 with total cost of 1.0.
qiskit.transpiler.passes.basis.basis_translator - ForkProcess-8 - DEBUG: Gate rz generated using rule
global phase: -0.5*theta
   ┌───────────┐
q: ┤ U1(theta) ├
   └───────────┘
 with total cost of 1.0.
qiskit.transpiler.passes.basis.basis_translator - ForkProcess-7 - DEBUG: Gate rz generated using rule
global phase: -0.5*theta
   ┌───────────┐
q: ┤ U1(theta) ├
   └───────────┘
 with total cost of 1.0.
qiskit.transpiler.passes.basis.basis_translator - ForkProcess-8 - DEBUG: Gate z generated using rule
   ┌───────┐
q: ┤ U1(π) ├
   └───────┘
 with total cost of 1.0.
qiskit.transpiler.passes.basis.basis_translator - ForkProcess-7 - DEBUG: Gate z generated using rule
   ┌───────┐
q: ┤ U1(π) ├
   └───────┘
 with total cost of 1.0.
qiskit.transpiler.passes.basis.basis_translator - ForkProcess-8 - DEBUG: Gate ry generated using rule
   ┌──────────────┐
q: ┤ R(theta,π/2) ├
   └──────────────┘
 with total cost of 1.0.
qiskit.transpiler.passes.basis.basis_translator - ForkProcess-7 - DEBUG: Gate ry generated using rule
   ┌──────────────┐
q: ┤ R(theta,π/2) ├
   └──────────────┘
 with total cost of 1.0.
qiskit.transpiler.passes.basis.basis_translator - ForkProcess-8 - DEBUG: Gate x generated using rule
   ┌───────────┐
q: ┤ U3(π,0,π) ├
   └───────────┘
 with total cost of 1.0.
qiskit.transpiler.passes.basis.basis_translator - ForkProcess-7 - DEBUG: Gate x generated using rule
   ┌───────────┐
q: ┤ U3(π,0,π) ├
   └───────────┘
 with total cost of 1.0.
qiskit.transpiler.passes.basis.basis_translator - ForkProcess-8 - DEBUG: Gate t generated using rule
   ┌─────────┐
q: ┤ U1(π/4) ├
   └─────────┘
 with total cost of 1.0.
qiskit.transpiler.passes.basis.basis_translator - ForkProcess-7 - DEBUG: Gate t generated using rule
   ┌─────────┐
q: ┤ U1(π/4) ├
   └─────────┘
 with total cost of 1.0.
qiskit.transpiler.passes.basis.basis_translator - ForkProcess-8 - DEBUG: Gate p generated using rule
   ┌───────────┐
q: ┤ U1(theta) ├
   └───────────┘
 with total cost of 1.0.
qiskit.transpiler.passes.basis.basis_translator - ForkProcess-8 - DEBUG: Gate h generated using rule
   ┌─────────┐
q: ┤ U2(0,π) ├
   └─────────┘
 with total cost of 1.0.
qiskit.transpiler.passes.basis.basis_translator - ForkProcess-7 - DEBUG: Gate p generated using rule
   ┌───────────┐
q: ┤ U1(theta) ├
   └───────────┘
 with total cost of 1.0.
qiskit.transpiler.passes.basis.basis_translator - ForkProcess-8 - DEBUG: Transformation path:
qiskit.transpiler.passes.basis.basis_translator - ForkProcess-7 - DEBUG: Gate h generated using rule
   ┌─────────┐
q: ┤ U2(0,π) ├
   └─────────┘
 with total cost of 1.0.
qiskit.transpiler.passes.basis.basis_translator - ForkProcess-8 - DEBUG: h/1 => []
   ┌─────────┐
q: ┤ U2(0,π) ├
   └─────────┘
qiskit.transpiler.passes.basis.basis_translator - ForkProcess-7 - DEBUG: Transformation path:
qiskit.transpiler.passes.basis.basis_translator - ForkProcess-7 - DEBUG: h/1 => []
   ┌─────────┐
q: ┤ U2(0,π) ├
   └─────────┘
qiskit.transpiler.passes.basis.basis_translator - ForkProcess-8 - DEBUG: p/1 => [Parameter(theta)]
   ┌───────────┐
q: ┤ U1(theta) ├
   └───────────┘
qiskit.transpiler.passes.basis.basis_translator - ForkProcess-7 - DEBUG: p/1 => [Parameter(theta)]
   ┌───────────┐
q: ┤ U1(theta) ├
   └───────────┘
qiskit.transpiler.passes.basis.basis_translator - ForkProcess-8 - DEBUG: t/1 => []
   ┌─────────┐
q: ┤ U1(π/4) ├
   └─────────┘
qiskit.transpiler.passes.basis.basis_translator - ForkProcess-7 - DEBUG: t/1 => []
   ┌─────────┐
q: ┤ U1(π/4) ├
   └─────────┘
qiskit.transpiler.passes.basis.basis_translator - ForkProcess-8 - DEBUG: x/1 => []
   ┌───────────┐
q: ┤ U3(π,0,π) ├
   └───────────┘
qiskit.transpiler.passes.basis.basis_translator - ForkProcess-7 - DEBUG: x/1 => []
   ┌───────────┐
q: ┤ U3(π,0,π) ├
   └───────────┘
qiskit.transpiler.passes.basis.basis_translator - ForkProcess-8 - DEBUG: ry/1 => [Parameter(theta)]
   ┌──────────────┐
q: ┤ R(theta,π/2) ├
   └──────────────┘
qiskit.transpiler.passes.basis.basis_translator - ForkProcess-7 - DEBUG: ry/1 => [Parameter(theta)]
   ┌──────────────┐
q: ┤ R(theta,π/2) ├
   └──────────────┘
qiskit.transpiler.passes.basis.basis_translator - ForkProcess-8 - DEBUG: z/1 => []
   ┌───────┐
q: ┤ U1(π) ├
   └───────┘
qiskit.transpiler.passes.basis.basis_translator - ForkProcess-7 - DEBUG: z/1 => []
   ┌───────┐
q: ┤ U1(π) ├
   └───────┘
qiskit.transpiler.passes.basis.basis_translator - ForkProcess-8 - DEBUG: rz/1 => [Parameter(theta)]
global phase: -0.5*theta
   ┌───────────┐
q: ┤ U1(theta) ├
   └───────────┘
qiskit.transpiler.passes.basis.basis_translator - ForkProcess-8 - DEBUG: s/1 => []
   ┌─────────┐
q: ┤ U1(π/2) ├
   └─────────┘
qiskit.transpiler.passes.basis.basis_translator - ForkProcess-7 - DEBUG: rz/1 => [Parameter(theta)]
global phase: -0.5*theta
   ┌───────────┐
q: ┤ U1(theta) ├
   └───────────┘
qiskit.transpiler.passes.basis.basis_translator - ForkProcess-8 - DEBUG: tdg/1 => []
   ┌──────────┐
q: ┤ U1(-π/4) ├
   └──────────┘
qiskit.transpiler.passes.basis.basis_translator - ForkProcess-7 - DEBUG: s/1 => []
   ┌─────────┐
q: ┤ U1(π/2) ├
   └─────────┘
qiskit.transpiler.passes.basis.basis_translator - ForkProcess-7 - DEBUG: tdg/1 => []
   ┌──────────┐
q: ┤ U1(-π/4) ├
   └──────────┘
qiskit.transpiler.passes.basis.basis_translator - ForkProcess-8 - DEBUG: u/1 => [Parameter(theta), Parameter(phi), Parameter(lam)]
   ┌───────────────────┐
q: ┤ U3(theta,phi,lam) ├
   └───────────────────┘
qiskit.transpiler.passes.basis.basis_translator - ForkProcess-7 - DEBUG: u/1 => [Parameter(theta), Parameter(phi), Parameter(lam)]
   ┌───────────────────┐
q: ┤ U3(theta,phi,lam) ├
   └───────────────────┘
qiskit.transpiler.passes.basis.basis_translator - ForkProcess-8 - DEBUG: r/1 => [Parameter(theta), Parameter(phi)]
   ┌───────────────────────────────────┐
q: ┤ U3(theta,phi - π/2,π/2 - 1.0*phi) ├
   └───────────────────────────────────┘
qiskit.transpiler.passes.basis.basis_translator - ForkProcess-7 - DEBUG: r/1 => [Parameter(theta), Parameter(phi)]
   ┌───────────────────────────────────┐
q: ┤ U3(theta,phi - π/2,π/2 - 1.0*phi) ├
   └───────────────────────────────────┘
qiskit.transpiler.passes.basis.basis_translator - ForkProcess-8 - INFO: Basis translation path search completed in 0.089s.
qiskit.transpiler.passes.basis.basis_translator - ForkProcess-7 - INFO: Basis translation path search completed in 0.092s.
qiskit.transpiler.passes.basis.basis_translator - ForkProcess-8 - DEBUG: Composing transform step: h/1 [] =>
   ┌─────────┐
q: ┤ U2(0,π) ├
   └─────────┘
qiskit.transpiler.passes.basis.basis_translator - ForkProcess-7 - DEBUG: Composing transform step: h/1 [] =>
   ┌─────────┐
q: ┤ U2(0,π) ├
   └─────────┘
qiskit.transpiler.passes.basis.basis_translator - ForkProcess-8 - DEBUG: Updating transform for mapped instr ('h', 1) h, [] from
      ┌───┐
q284: ┤ h ├
      └───┘
qiskit.transpiler.passes.basis.basis_translator - ForkProcess-7 - DEBUG: Updating transform for mapped instr ('h', 1) h, [] from
      ┌───┐
q284: ┤ h ├
      └───┘
qiskit.transpiler.passes.basis.basis_translator - ForkProcess-8 - DEBUG: Updated transform for mapped instr ('h', 1) h, [] to
      ┌─────────┐
q284: ┤ U2(0,π) ├
      └─────────┘
qiskit.transpiler.passes.basis.basis_translator - ForkProcess-7 - DEBUG: Updated transform for mapped instr ('h', 1) h, [] to
      ┌─────────┐
q284: ┤ U2(0,π) ├
      └─────────┘
qiskit.transpiler.passes.basis.basis_translator - ForkProcess-8 - DEBUG: Composing transform step: p/1 [Parameter(theta)] =>
   ┌───────────┐
q: ┤ U1(theta) ├
   └───────────┘
qiskit.transpiler.passes.basis.basis_translator - ForkProcess-7 - DEBUG: Composing transform step: p/1 [Parameter(theta)] =>
   ┌───────────┐
q: ┤ U1(theta) ├
   └───────────┘
qiskit.transpiler.passes.basis.basis_translator - ForkProcess-8 - DEBUG: Composing transform step: t/1 [] =>
   ┌─────────┐
q: ┤ U1(π/4) ├
   └─────────┘
qiskit.transpiler.passes.basis.basis_translator - ForkProcess-7 - DEBUG: Composing transform step: t/1 [] =>
   ┌─────────┐
q: ┤ U1(π/4) ├
   └─────────┘
qiskit.transpiler.passes.basis.basis_translator - ForkProcess-8 - DEBUG: Composing transform step: x/1 [] =>
   ┌───────────┐
q: ┤ U3(π,0,π) ├
   └───────────┘
qiskit.transpiler.passes.basis.basis_translator - ForkProcess-8 - DEBUG: Updating transform for mapped instr ('x', 1) x, [] from
      ┌───┐
q282: ┤ x ├
      └───┘
qiskit.transpiler.passes.basis.basis_translator - ForkProcess-7 - DEBUG: Composing transform step: x/1 [] =>
   ┌───────────┐
q: ┤ U3(π,0,π) ├
   └───────────┘
qiskit.transpiler.passes.basis.basis_translator - ForkProcess-7 - DEBUG: Updating transform for mapped instr ('x', 1) x, [] from
      ┌───┐
q282: ┤ x ├
      └───┘
qiskit.transpiler.passes.basis.basis_translator - ForkProcess-8 - DEBUG: Updated transform for mapped instr ('x', 1) x, [] to
      ┌───────────┐
q282: ┤ U3(π,0,π) ├
      └───────────┘
qiskit.transpiler.passes.basis.basis_translator - ForkProcess-8 - DEBUG: Composing transform step: ry/1 [Parameter(theta)] =>
   ┌──────────────┐
q: ┤ R(theta,π/2) ├
   └──────────────┘
qiskit.transpiler.passes.basis.basis_translator - ForkProcess-7 - DEBUG: Updated transform for mapped instr ('x', 1) x, [] to
      ┌───────────┐
q282: ┤ U3(π,0,π) ├
      └───────────┘
qiskit.transpiler.passes.basis.basis_translator - ForkProcess-8 - DEBUG: Composing transform step: z/1 [] =>
   ┌───────┐
q: ┤ U1(π) ├
   └───────┘
qiskit.transpiler.passes.basis.basis_translator - ForkProcess-7 - DEBUG: Composing transform step: ry/1 [Parameter(theta)] =>
   ┌──────────────┐
q: ┤ R(theta,π/2) ├
   └──────────────┘
qiskit.transpiler.passes.basis.basis_translator - ForkProcess-7 - DEBUG: Composing transform step: z/1 [] =>
   ┌───────┐
q: ┤ U1(π) ├
   └───────┘
qiskit.transpiler.passes.basis.basis_translator - ForkProcess-7 - DEBUG: Composing transform step: rz/1 [Parameter(theta)] =>
global phase: -0.5*theta
   ┌───────────┐
q: ┤ U1(theta) ├
   └───────────┘
qiskit.transpiler.passes.basis.basis_translator - ForkProcess-8 - DEBUG: Composing transform step: rz/1 [Parameter(theta)] =>
global phase: -0.5*theta
   ┌───────────┐
q: ┤ U1(theta) ├
   └───────────┘
qiskit.transpiler.passes.basis.basis_translator - ForkProcess-7 - DEBUG: Composing transform step: s/1 [] =>
   ┌─────────┐
q: ┤ U1(π/2) ├
   └─────────┘
qiskit.transpiler.passes.basis.basis_translator - ForkProcess-8 - DEBUG: Composing transform step: s/1 [] =>
   ┌─────────┐
q: ┤ U1(π/2) ├
   └─────────┘
qiskit.transpiler.passes.basis.basis_translator - ForkProcess-8 - DEBUG: Composing transform step: tdg/1 [] =>
   ┌──────────┐
q: ┤ U1(-π/4) ├
   └──────────┘
qiskit.transpiler.passes.basis.basis_translator - ForkProcess-7 - DEBUG: Composing transform step: tdg/1 [] =>
   ┌──────────┐
q: ┤ U1(-π/4) ├
   └──────────┘
qiskit.transpiler.passes.basis.basis_translator - ForkProcess-8 - DEBUG: Composing transform step: u/1 [Parameter(theta), Parameter(phi), Parameter(lam)] =>
   ┌───────────────────┐
q: ┤ U3(theta,phi,lam) ├
   └───────────────────┘
qiskit.transpiler.passes.basis.basis_translator - ForkProcess-7 - DEBUG: Composing transform step: u/1 [Parameter(theta), Parameter(phi), Parameter(lam)] =>
   ┌───────────────────┐
q: ┤ U3(theta,phi,lam) ├
   └───────────────────┘
qiskit.transpiler.passes.basis.basis_translator - ForkProcess-7 - DEBUG: Composing transform step: r/1 [Parameter(theta), Parameter(phi)] =>
   ┌───────────────────────────────────┐
q: ┤ U3(theta,phi - π/2,π/2 - 1.0*phi) ├
   └───────────────────────────────────┘
qiskit.transpiler.passes.basis.basis_translator - ForkProcess-8 - DEBUG: Composing transform step: r/1 [Parameter(theta), Parameter(phi)] =>
   ┌───────────────────────────────────┐
q: ┤ U3(theta,phi - π/2,π/2 - 1.0*phi) ├
   └───────────────────────────────────┘
qiskit.transpiler.passes.basis.basis_translator - ForkProcess-8 - INFO: Basis translation paths composed in 0.047s.
qiskit.transpiler.passes.basis.basis_translator - ForkProcess-7 - INFO: Basis translation paths composed in 0.045s.
qiskit.transpiler.passes.basis.basis_translator - ForkProcess-8 - INFO: Basis translation instructions replaced in 0.000s.
qiskit.transpiler.passes.basis.basis_translator - ForkProcess-7 - INFO: Basis translation instructions replaced in 0.000s.
qiskit.transpiler.runningpassmanager - ForkProcess-8 - INFO: Pass: BasisTranslator - 142.57407 (ms)
qiskit.transpiler.runningpassmanager - ForkProcess-7 - INFO: Pass: BasisTranslator - 144.40155 (ms)
qiskit.transpiler.runningpassmanager - ForkProcess-8 - INFO: Pass: CheckGateDirection - 0.15712 (ms)
qiskit.transpiler.runningpassmanager - ForkProcess-7 - INFO: Pass: CheckGateDirection - 0.17142 (ms)
qiskit.transpiler.runningpassmanager - ForkProcess-8 - INFO: Pass: GateDirection - 0.28253 (ms)
qiskit.transpiler.runningpassmanager - ForkProcess-8 - INFO: Pass: RemoveResetInZeroState - 0.07534 (ms)
qiskit.transpiler.runningpassmanager - ForkProcess-7 - INFO: Pass: GateDirection - 0.24128 (ms)
qiskit.transpiler.runningpassmanager - ForkProcess-8 - INFO: Pass: Depth - 0.14544 (ms)
qiskit.transpiler.runningpassmanager - ForkProcess-7 - INFO: Pass: RemoveResetInZeroState - 0.08249 (ms)
qiskit.transpiler.runningpassmanager - ForkProcess-8 - INFO: Pass: FixedPoint - 0.04268 (ms)
qiskit.transpiler.runningpassmanager - ForkProcess-7 - INFO: Pass: Depth - 0.16069 (ms)
qiskit.transpiler.runningpassmanager - ForkProcess-8 - INFO: Pass: Size - 0.14091 (ms)
qiskit.transpiler.runningpassmanager - ForkProcess-7 - INFO: Pass: FixedPoint - 0.03624 (ms)
qiskit.transpiler.runningpassmanager - ForkProcess-8 - INFO: Pass: FixedPoint - 0.01359 (ms)
qiskit.transpiler.runningpassmanager - ForkProcess-7 - INFO: Pass: Size - 0.10967 (ms)
qiskit.transpiler.runningpassmanager - ForkProcess-7 - INFO: Pass: FixedPoint - 0.02694 (ms)
qiskit.transpiler.runningpassmanager - ForkProcess-8 - INFO: Pass: Optimize1qGatesDecomposition - 4.01998 (ms)
qiskit.transpiler.runningpassmanager - ForkProcess-8 - INFO: Pass: CXCancellation - 0.13161 (ms)
qiskit.transpiler.runningpassmanager - ForkProcess-7 - INFO: Pass: Optimize1qGatesDecomposition - 3.88145 (ms)
qiskit.transpiler.runningpassmanager - ForkProcess-8 - INFO: Pass: GatesInBasis - 0.12183 (ms)
qiskit.transpiler.runningpassmanager - ForkProcess-7 - INFO: Pass: CXCancellation - 0.20623 (ms)
qiskit.transpiler.runningpassmanager - ForkProcess-8 - INFO: Pass: Depth - 0.06962 (ms)
qiskit.transpiler.runningpassmanager - ForkProcess-7 - INFO: Pass: GatesInBasis - 0.06723 (ms)
qiskit.transpiler.runningpassmanager - ForkProcess-8 - INFO: Pass: FixedPoint - 0.02122 (ms)
qiskit.transpiler.runningpassmanager - ForkProcess-8 - INFO: Pass: Size - 0.04506 (ms)
qiskit.transpiler.runningpassmanager - ForkProcess-8 - INFO: Pass: FixedPoint - 0.03147 (ms)
qiskit.transpiler.runningpassmanager - ForkProcess-7 - INFO: Pass: Depth - 0.11611 (ms)
qiskit.transpiler.runningpassmanager - ForkProcess-7 - INFO: Pass: FixedPoint - 0.01955 (ms)
qiskit.transpiler.runningpassmanager - ForkProcess-8 - INFO: Pass: Optimize1qGatesDecomposition - 1.07360 (ms)
qiskit.transpiler.runningpassmanager - ForkProcess-7 - INFO: Pass: Size - 0.06151 (ms)
qiskit.transpiler.runningpassmanager - ForkProcess-8 - INFO: Pass: CXCancellation - 0.10633 (ms)
qiskit.transpiler.runningpassmanager - ForkProcess-7 - INFO: Pass: FixedPoint - 0.02623 (ms)
qiskit.transpiler.runningpassmanager - ForkProcess-8 - INFO: Pass: GatesInBasis - 0.07534 (ms)
qiskit.transpiler.runningpassmanager - ForkProcess-7 - INFO: Pass: Optimize1qGatesDecomposition - 1.08242 (ms)
qiskit.transpiler.runningpassmanager - ForkProcess-8 - INFO: Pass: Depth - 0.07391 (ms)
qiskit.transpiler.runningpassmanager - ForkProcess-8 - INFO: Pass: FixedPoint - 0.02074 (ms)
qiskit.transpiler.runningpassmanager - ForkProcess-8 - INFO: Pass: Size - 0.05603 (ms)
qiskit.transpiler.runningpassmanager - ForkProcess-8 - INFO: Pass: FixedPoint - 0.02646 (ms)
qiskit.transpiler.runningpassmanager - ForkProcess-8 - INFO: Pass: ContainsInstruction - 0.05937 (ms)
qiskit.transpiler.runningpassmanager - ForkProcess-7 - INFO: Pass: CXCancellation - 0.08416 (ms)
qiskit.transpiler.runningpassmanager - ForkProcess-7 - INFO: Pass: GatesInBasis - 0.05841 (ms)
qiskit.transpiler.runningpassmanager - ForkProcess-7 - INFO: Pass: Depth - 0.06700 (ms)
qiskit.transpiler.runningpassmanager - ForkProcess-7 - INFO: Pass: FixedPoint - 0.02432 (ms)
qiskit.transpiler.runningpassmanager - ForkProcess-7 - INFO: Pass: Size - 0.04792 (ms)
qiskit.transpiler.runningpassmanager - ForkProcess-7 - INFO: Pass: FixedPoint - 0.02933 (ms)
qiskit.transpiler.runningpassmanager - ForkProcess-7 - INFO: Pass: ContainsInstruction - 0.06461 (ms)
qiskit.compiler.transpiler - MainProcess - INFO: Total Transpile Time - 393.94832 (ms)

Now the format for the log messages has been changed and it includes a process name for each of the transpilation processes so it’s at least clear which log messages go together.

Existem muitas opções diferentes, para como você pode configurar, este exemplo é bem limitado. Consulte a documentação para obter mais exemplos e opções para construir casos de uso mais sofisticados, que se adequam ao seu caso de uso ou preferências específicas.

import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright

Version Information

Qiskit Software	Version
qiskit-terra	0.22.3
qiskit-aer	0.11.2
qiskit-ignis	0.7.0
qiskit-ibmq-provider	0.19.2
qiskit	0.39.4
System information
Python version	3.10.6
Python compiler	GCC 11.3.0
Python build	main, Nov 14 2022 16:10:14
OS	Linux
CPUs	4
Memory (Gb)	3.7695083618164062
Thu Dec 22 18:19:13 2022 JST

This code is a part of Qiskit

© Copyright IBM 2017, 2022.

This code is licensed under the Apache License, Version 2.0. You may
obtain a copy of this license in the LICENSE.txt file in the root directory
of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.

Any modifications or derivative works of this code must retain this
copyright notice, and modified files need to carry a notice indicating
that they have been altered from the originals.