Nota

Esta página fue generada a partir de tutorials/circuits_advanced/04_transpiler_passes_and_passmanager.ipynb.

Pases al Transpilador y Administrador de Pases

Introducción

Un componente central de Qiskit Terra es el transpilador, el cual está diseñado para modularidad y extensibilidad. El objetivo es lograr escribir fácilmente transformaciones de circuitos (conocidos como pases al transpilador), y combinarlos con otros pases existentes. Cuáles pases son conectados y en qué orden tiene un efecto substancial en el resultado final. Este camino es determinado por un administrador de pases, el cual ordena los pases y también permite que los pases se comuniquen entre sí, proporcionándoles un espacio compartido. De esta manera, el transpilador abre la puerta a la investigación sobre la optimización agresiva de los circuitos cuánticos.

En este cuaderno, analizamos los pases incorporados, cómo usar el administrador de pases y desarrollamos un pase personalizado simple de transpilador. Para hacer esto último, primero tenemos que introducir la representación interna de los circuitos cuánticos en Qiskit, en la forma de Grafos Acíclicos Dirigidos o DAG (Directed Acyclic Graph). Después, ilustramos un pase de mapeo de intercambio simple, el cual transforma un circuito de entrada para que sea compatible con un dispositivo cuántico de conectividad limitada.

Antes de comenzar: Es posible que necesites instalar las librerías pydot y graphviz para las rutinas de graficado de DAG. Si usas Anaconda Python, puedes instalar ambos con el comando conda. Si usas el intérprete de Python nativo a tu sistema, puedes instalar pydot con el comando pip, y graphviz con el administrador de paquetes nativo a tu sistema (por ejemplo, yum, apt, dnf, brew, etc.).

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

Objeto PassManager

Te permite especificar el conjunto de pases que quieres.

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')

Todos los pases al transpilador de Qiskit son accesibles con 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 Variantes del Mismo Pase

Puede haber diferentes pases que hagan lo mismo, pero de diferente manera. Por ejemplo, los pases TrivialLayout, DenseLayout y NoiseAdaptiveLayout escogen una disposición (enlace entre qubits virtuales a qubits físicos), pero usan diferentes algoritmos y objetivos. Similarmente, los pases BasicSwap, LookaheadSwap y StochasticSwap insertan intercambios para hacer a los circuitos compatibles con un mapa de acoplamiento. La modularidad del transpilador permite hacer cambios a los pases y ejecutarlos fácilmente.

A continuación, mostramos todos los pases de intercambio aplicados a un mismo circuito, para transformarlo para que coincida con una topología de cadena lineal. Las diferencias en rendimiento son evidentes, donde StochasticSwap es claramente el mejor. Sin embargo, esto puede variar dependiendo del 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')

Administradores de Pases Preestablecidos

Qiskit viene con varios administradores de pases predefinidos, que corresponden a varios niveles de optimización logrados a través de diferentes canalizaciones de pases. Actualmente, se soportan optimization_level de 0 a 3; entre más alto sea el número, más se optimizará, a expensas de un mayor tiempo. Elegir un buen administrador de pases puede requerir prueba y error, ya que depende en gran medida del circuito que se transpila y el backend al que se dirige.

Aquí ilustramos los diferentes niveles viendo el circuito de síntesis del estado. Inicializamos 4 qubits en un estado arbitrario y intentamos optimizar el circuito que logre esto.

• optimization_level=0: mapea el circuito al backend, sin optimización explicita (excepto por las optimizaciones que se hagan al mapear).

• optimization_level=1: mapea el circuito, pero también hace optimizaciones ligeras colapsando compuertas adyacentes.

• optimization_level=2: optimización media, incluye un diseño adaptable al ruido y un procedimiento de cancelación de compuerta basado en las relaciones de conmutación de compuerta.

• optimization_level=3: optimización intensa, que además de los pasos anteriores, hace una resíntesis de bloques de compuertas de dos qubits en el 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: ──────────────────────────────────────────────────────────────────────────────
«                                                                                   

Ahora mapeamos esto al dispositivo Tokyo de 20-qubits, con diferentes niveles de optimización:

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

Introducción al DAG

En Qiskit representamos a los circuitos internamente usando Grafos Acíclicos Dirigidos (Directed Acyclic Graph, DAG). La ventaja de esta representación sobre una lista pura de compuertas (es decir, netlist) es que el flujo de información entre operaciones es explícito, lo que facilita que los pases tomen decisiones de transformación sin cambiar la semántica del circuito.

Empecemos por construir un circuito simple y examinar su 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')

En el DAG, hay tres tipos de nodos de grafos: nodos de entrada de qubit/clbit (verde), nodos de operación (azul) y nodos de salida (rojo). Cada borde indica el flujo de datos (o dependencia) entre dos nodos.

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

Por lo tanto, escribir un pase al transpilador significa utilizar la API DAGCircuit de Qiskit para analizar o transformar el circuito. Veamos algunos ejemplos de esto.

a. Poner todos los nodos op en el 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=())]

Cada nodo es una instancia de la clase DAGOpNode. Examinemos la información guardada en el segundo nodo op.

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. Añadir una operación a la parte trasera:

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

c. Añadir una operación a la parte delantera:

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

d. Substituir un nodo con un subcircuito:

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)

Finalmente, después de que todas las transformaciones hayan sido completadas, podemos convertir de vuelta a un objeto QuantumCircuit. ¡Esto es lo que hace el transpilador! Toma un circuito, opera sobre el en su forma DAG, y regresa un circuito transformado.

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

Implementación de un Pase BasicMapper

Ahora que estamos familiarizados con el DAG, usémoslo para escribir un pase al transpilador. Aquí vamos a implementar un pase básico para mapear un circuito arbitrario a un dispositivo con conectividad de qubits limitada. Llamamos a esto un BasicMapper. Este pase también está incluido en Qiskit Terra.

La primera cosa que hay que hacer al escribir un pase al transpilador es decidir si la clase del pase deriva de TransformationPass o AnalysisPass. Los pases de transformación modifican el circuito, mientras que los pases de análisis solo recopilan información acerca de un circuito (para ser usada por otros pases). Luego, se implementa el método run(dag), que ejecuta la tarea principal. Finalmente, el pase se registra en el módulo qiskit.transpiler.passes.

Este pase funciona de la siguiente manera: atraviesa el DAG capa por capa (cada capa es un grupo de operaciones que no actúa en qubits independientes, entonces, en teoría, todas las operaciones en una capa pueden ser ejecutadas independientemente). Para cada operación, si no cumple ya las restricciones del mapa de acoplamiento, el pase identifica una ruta de intercambio e inserta swaps para acercar los dos qubits entre sí.

Sigue los comentarios del código para más detalles.

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

Probemos este pase en un circuito pequeño de ejemplo.

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>

Ahora, construimos el administrador de pases que contiene a nuestro nuevo pase. Pasamos el circuito de ejemplo anterior a este administrador de pases para obtener un nuevo 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')

Ten en cuenta que este pase solo inserta los swaps necesarios para hacer que todas las interacciones entre dos qubits se ajusten al mapa de acoplamiento del dispositivo. No se preocupa, por ejemplo, de la dirección de las interacciones, o el conjunto de compuertas nativo soportado por el dispositivo. Esta es una filosofía de diseño del transpilador de Qiskit: cada pase realiza una acción pequeña y bien definida, y la optimización agresiva de circuitos es lograda por el administrador de pases mediante una combinación de múltiples pases.

Logging del Transpilador

Debido a la complejidad de las operaciones internas que el transpilador está realizando, es probable que termines en una situación donde te gustaría depurar un problema o simplemente entender más de lo que está pasando dentro del transpilador cuando lo llamas. Para facilitar esto, el transpilador emite mensajes de registro como parte de su funcionamiento normal. Este registro utiliza el módulo logging de la biblioteca estándar de Python para emitir los mensajes de registro. El logging estándar de Python se utilizó porque permite que los registros de Qiskit-Terra se integren de manera estándar con otras aplicaciones y bibliotecas.

Para una introducción más a fondo del logging de Python, consulte la documentación oficial y los tutoriales y libros de código enlazados ahí.

Nota: la mayoría de las funciones del módulo logging usadas aquí ajustan configuraciones globales. Si corres comandos de esta sección puede que afecte las salidas de otras celdas si son ejecutadas en diferente orden.

Configuración de la Biblioteca Estándar de Python Logging

Por defecto, el Logging Estándar de Python solo imprime mensajes en los niveles de registro WARNING, ERROR, o CRITICAL. Ya que ninguno de los registros emitidos por el transpilador usa estos niveles de registro (todos son informativos) tienes que configurar logging.

La forma más sencilla de hacer esto es simplemente ejecutar:

import logging

logging.basicConfig(level='DEBUG')

La función basicConfig() (ver la documentación aquí: https://docs.python.org/3/library/logging.html#logging.basicConfig) configura un controlador raíz y un formateador. También especificamos el nivel de registro a mostrar con el kwarg level. Configurarlo a un nivel también va a hacer que incluya los niveles más altos. Por ejemplo, si lo configuras al nivel 'INFO' además del nivel INFO esto también va a incluir los niveles de registro WARNING, ERROR, and CRITICAL.

Ahora el entorno de python de este cuaderno se configura para emitir mensajes de registro a stderr cuando corras el transpilador. Por ejemplo:

Nota: basicConfig() solo va a funcionar cuando se ejecute por primera vez. Detecta si un controlador raíz y un formateador ya han sido configurados (ya sea mediante una llamada anterior a basicConfig() o de otra manera) y no hace nada si ya fueron configurados. Ajustes adicionales tendrán que interactuar directamente con el controlador.

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)

Como puedes ver claramente aquí, al ejecutar transpile() ahora imprime 2 tipos de mensaje de registro. El primero está al nivel de registro INFO y proviene del administrador de pases. Estos indican cada pase que se ejecutó y cuánto tiempo tomó. El segundo está al nivel de registro DEBUG y proviene del pase StochasticSwap y describe la operación interna de ese pase. Es útil para depurar problemas en la operación del pase.

Ajustando el nivel de registro para el transpilador

El transpilador qiskit usa un solo espacio de nombres qiskit.transpiler, como lo usa logging.getLogger('qiskit.transpiler'). Esto hace que sea muy fácil ajustar el nivel de registro solamente para el transpilador. Por ejemplo, si solo desea ver los mensajes de registro en el nivel INFO o superior, puede ejecutar:

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)

Configuración del registro para lidiar con la ejecución en paralelo

Cuando se ejecuta el transpilador con múltiples circuitos, por defecto estos circuitos se transpilan en paralelo. Si deseas hacerlo con el logging (registro) habilitado y poder entender el mensaje de salida, se necesitan algunos pasos adicionales.

Si habilitas el logging como se hizo arriba, y pasas transpile() a múltiples circuitos obtendrás resultados que son difíciles de descifrar. Por ejemplo:

# 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)

Como puedes ver, aquí obtenemos mensajes de registro de los 3 circuitos que han sido transpilados juntos. No hay manera de saber cuál pase es parte de la transpilación de qué circuito. Por suerte, el logging de Python proporciona herramientas para lidiar con esto. La mejor manera es simplemente cambiar el formateador de registro para que incluya información adicional, para que podamos asociar los mensajes de registro al proceso que lo emitió.

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

Luego, vuelve a ejecutar transpile() y observa el nuevo formateador de registro.

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)

Ahora el formato de mensajes de registro ha sido cambiado e incluye el nombre del proceso para cada proceso de transpilación para que por lo menos sea claro que mensajes de registro van juntos.

Hay muchas opciones de cómo puedes configurar, este ejemplo es bastante limitado. Consulta la documentación para más ejemplos y opciones para construir casos de uso más sofisticados que se adapten a tu caso específico o a tus preferencias.

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.