Note

இந்த பக்கம் tutorials/circuits_advanced/04_transpiler_passes_and_passmanager.ipynb இலிருந்து உருவாக்கப்பட்டது.

டிரான்ஸ்பைலர் பாஸ் மற்றும் பாஸ் மேலாளர்

முன்னுரை

Qiskit டெர்ராவின் மையக் கூறு டிரான்ஸ்பைலர் ஆகும், இது மட்டுப்படுத்தல் மற்றும் விரிவாக்கத்திற்காக வடிவமைக்கப்பட்டுள்ளது. புதிய சுற்று மாற்றங்களை (டிரான்ஸ்பைலர் passes என அழைக்கப்படுகிறது) எளிதாக எழுத முடியும், மேலும் அவற்றை ஏற்கனவே உள்ள பிற பாஸுடன் இணைக்க முடியும். எந்த பாஸ்கள் ஒன்றாக இணைக்கப்பட்டுள்ளன மற்றும் எந்த வரிசையில் இறுதி முடிவில் பெரிய தாக்கத்தை ஏற்படுத்துகிறது. இந்த பைப்லைன் ஒரு *pass manager*ஆல் தீர்மானிக்கப்படுகிறது, இது பாஸ்களை திட்டமிடுகிறது மற்றும் பகிரப்பட்ட இடத்தை வழங்குவதன் மூலம் பாஸ்கள் ஒருவருக்கொருவர் தொடர்பு கொள்ள அனுமதிக்கிறது. இந்த வழியில், குவாண்டம் சுற்றுகளின் ஆக்கிரோஷமான தேர்வுமுறை குறித்த ஆராய்ச்சிக்கான கதவு டிரான்ஸ்பைலர் திறக்கிறது.

இந்த நோட்புக்கில், உள்ளமைக்கப்பட்ட பாஸ்கள், பாஸ் மேலாளரை எவ்வாறு பயன்படுத்துவது மற்றும் எளிய தனிப்பயன் டிரான்ஸ்பைலர் பாஸை உருவாக்குவது ஆகியவற்றைப் பார்க்கிறோம். பிந்தையதைச் செய்ய, முதலில் கிஸ்கிட்டில் குவாண்டம் சுற்றுகளின் உள் பிரதிநிதித்துவத்தை ஒரு நேரடி அசைக்ளிக் வரைபடம் அல்லது DAG வடிவத்தில் அறிமுகப்படுத்த வேண்டும். பின்னர், ஒரு எளிய இடமாற்று மேப்பர் பாஸை நாங்கள் விளக்குகிறோம், இது ஒரு உள்ளீட்டு சுற்று ஒரு வரையறுக்கப்பட்ட-இணைப்பு குவாண்டம் சாதனத்துடன் இணக்கமாக இருக்கும்.

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

PassManager பொருள்

நீங்கள் விரும்பும் பாஸின் தொகுப்பைக் குறிப்பிட உங்களை அனுமதிக்கிறது.

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

ஒரே பாஸின் வெவ்வேறு மாறுபாடுகள்

ஒரே வேலையைச் செய்யும் பாஸ்கள் இருக்கலாம், ஆனால் வெவ்வேறு வழிகளில். எடுத்துக்காட்டாக, TrivialLayout, DenseLayout மற்றும் NoiseAdaptiveLayout அனைத்தும் ஒரு தளவமைப்பைத் தேர்வுசெய்கின்றன (மெய்நிகர் க்யூபிட்களை இயற்பியல் க்யூபிட்களுடன் பிணைத்தல்), ஆனால் வெவ்வேறு வழிமுறைகள் மற்றும் குறிக்கோள்களைப் பயன்படுத்துகின்றன. இதேபோல், BasicSwap, LookaheadSwap மற்றும் StochasticSwap அனைத்தும் இணைக்கும் வரைபடத்துடன் சுற்றுக்கு இணக்கமாக மாற்றங்களைச் செருகும். டிரான்ஸ்பைலரின் மட்டுப்படுத்தல் ஒவ்வொரு பாஸிற்கும் செருகுநிரல் மற்றும் விளையாட்டு மாற்றுகளை அனுமதிக்கிறது.

கீழே, ஒரு நேரியல் சங்கிலி இடவியலுடன் பொருந்துமாறு மாற்றுவதற்காக, ஒரே சுற்றுக்கு பயன்படுத்தப்படும் ஸ்வாப்பர் பாஸ்கள் அனைத்தையும் காண்பிக்கிறோம். செயல்திறனில் உள்ள வேறுபாடுகளை நீங்கள் காணலாம், அங்கு StochasticSwap தெளிவாக சிறந்தது. இருப்பினும், உள்ளீட்டு சுற்றுக்கு ஏற்ப இது மாறுபடும்.

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

முன்னமைக்கப்பட்ட பாஸ் மேலாளர்கள்

Qiskit பல முன் வரையறுக்கப்பட்ட பாஸ் மேலாளர்களுடன் வருகிறது, இது பல்வேறு அளவிலான பாஸ்கள் மூலம் அடையப்பட்ட பல்வேறு நிலை தேர்வுமுறைகளுக்கு ஒத்திருக்கிறது. தற்போது optimization_level 0 முதல் 3 வரை ஆதரிக்கப்படுகிறது; அதிக எண்ணிக்கையில், அதிக நேரத்தின் இழப்பில் இது மிகவும் உகந்ததாக இருக்கும். ஒரு நல்ல பாஸ் மேலாளரைத் தேர்ந்தெடுப்பது சோதனை மற்றும் பிழையை எடுக்கக்கூடும், ஏனெனில் இது சுற்று பரிமாற்றம் மற்றும் பின்தளத்தில் குறிவைக்கப்படுவதைப் பொறுத்தது.

ஒரு நிலை தொகுப்பு சுற்று பார்ப்பதன் மூலம் வெவ்வேறு நிலைகளை இங்கே விளக்குகிறோம். நாங்கள் நான்கு க்யூபிட்களை ஒரு தன்னிச்சையான நிலைக்குத் துவக்குகிறோம், பின்னர் இதை அடையும் சுற்றுகளை மேம்படுத்த முயற்சிக்கிறோம்.

• optimization_level=0: வெளிப்படையான தேர்வுமுறை இல்லாமல் (மேப்பர் செய்யும் எந்த மேம்படுத்தல்களையும் தவிர), பின்தளத்தில் சுற்றுக்கு வரைபடம்.

• optimization_level=1: சுற்று வரைபடத்தை வரைபடமாக்குகிறது, ஆனால் அருகிலுள்ள வாயில்களை உடைப்பதன் மூலம் குறைந்த எடை மேம்படுத்தல்களையும் செய்கிறது.

• optimization_level=2: நடுத்தர எடை உகப்பாக்கம், இதில் சத்தம்-தகவமைப்பு தளவமைப்பு மற்றும் கேட் பரிமாற்ற உறவுகளின் அடிப்படையில் ஒரு கேட்-ரத்து நடைமுறை.

• optimization_level=3: கனமான எடை உகப்பாக்கம், இது முந்தைய படிகளுக்கு மேலதிகமாக, சுற்றுகளில் இரண்டு-க்யூபிட் தொகுதிகளின் கேட்களை மறுசீரமைக்கிறது.

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: ──────────────────────────────────────────────────────────────────────────────
«                                                                                   

இப்போது இதை 20-க்யூபிட் டோக்கியோ சாதனத்தில் வரைபடமாக்குங்கள், வெவ்வேறு தேர்வுமுறை நிலைகளுடன்:

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

DAG ஐ அறிமுகப்படுத்துகிறது

Qiskit ட்டில், திசைக்கப்பட்ட அசைக்ளிக் வரைபடம் (DAG) பயன்படுத்தி உள்நாட்டில் சுற்றுகளை பிரதிநிதித்துவப்படுத்துகிறோம். வாயில்களின் தூய்மையான பட்டியலில் (அதாவது, * netlist *) இந்த பிரதிநிதித்துவத்தின் நன்மை என்னவென்றால், செயல்பாடுகளுக்கு இடையிலான தகவல்களின் ஓட்டம் வெளிப்படையானது, இது சுற்றுகளின் சொற்பொருளை மாற்றாமல் மாற்ற முடிவுகளை எடுக்க பாஸ்களை எளிதாக்குகிறது.

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

DAG இல், மூன்று வகையான வரைபட முனைகள் உள்ளன: க்யூபிட் / கிளிபிட் உள்ளீட்டு முனைகள் (பச்சை), செயல்பாட்டு முனைகள் (நீலம்) மற்றும் வெளியீட்டு முனைகள் (சிவப்பு). ஒவ்வொரு விளிம்பும் இரண்டு முனைகளுக்கு இடையில் தரவு ஓட்டத்தை (அல்லது சார்பு) குறிக்கிறது.

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. Get all op nodes in the 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. Add an operation to the back:

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)

இறுதியாக, அனைத்து மாற்றங்களும் முடிந்தபின், நாம் ஒரு வழக்கமான குவாண்டம் சர்க்யூட் பொருளுக்கு மாற்றலாம். டிரான்ஸ்பைலர் இதைத்தான் செய்கிறது! இது ஒரு சுற்று எடுத்து, DAG வடிவத்தில் இயங்குகிறது, மற்றும் மாற்றப்பட்ட சுற்று வெளியிடுகிறது.

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

ஒரு அடிப்படை மேப்பர் பாஸை செயல்படுத்துகிறது

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.

டிரான்ஸ்பைலர் பாஸ் எழுதும் போது செய்ய வேண்டிய முதல் விஷயம், பாஸ் வகுப்பு TransformationPass அல்லது AnalysisPass என்பதிலிருந்து பெறப்பட்டதா என்பதை தீர்மானிக்க வேண்டும். உருமாற்ற பாஸ்கள் சுற்றுவட்டத்தை மாற்றியமைக்கின்றன, பகுப்பாய்வு பாஸ்கள் ஒரு சுற்று பற்றிய தகவல்களை மட்டுமே சேகரிக்கின்றன (பிற பாஸ்கள் பயன்படுத்த). பின்னர், run (dag) முறை செயல்படுத்தப்படுகிறது, இது முக்கிய பணியை செய்கிறது. இறுதியாக, பாஸ் qiskit.transpiler.passes தொகுதிக்குள் பதிவு செய்யப்பட்டுள்ளது.

இந்த பாஸ் பின்வருமாறு செயல்படுகிறது: இது DAG லேயர்-பை-லேயரைக் கடந்து செல்கிறது (ஒவ்வொரு லேயரும் சுயாதீனமான க்யூபிட்களில் செயல்படாத செயல்பாடுகளின் குழு, எனவே கோட்பாட்டில் ஒரு அடுக்கில் உள்ள அனைத்து செயல்பாடுகளும் சுயாதீனமாக செய்யப்படலாம்). ஒவ்வொரு செயல்பாட்டிற்கும், இது ஏற்கனவே இணைப்பு வரைபடக் கட்டுப்பாடுகளைச் சந்திக்கவில்லை என்றால், பாஸ் ஒரு இடமாற்று பாதையை அடையாளம் கண்டு, இரண்டு க்யூபிட்களையும் ஒருவருக்கொருவர் நெருக்கமாகக் கொண்டுவருவதற்கு இடமாற்றுகளைச் செருகும்.

மேலும் விவரங்களுக்கு குறியீட்டில் உள்ள கருத்துகளைப் பின்பற்றவும்.

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>

இப்போது எங்கள் புதிய பாஸைக் கொண்ட பாஸ் மேலாளரை உருவாக்குகிறோம். மேலே உள்ள எடுத்துக்காட்டு சுற்று இந்த பாஸ் மேலாளருக்கு அனுப்புகிறோம், மேலும் புதிய, மாற்றப்பட்ட சுற்று பெறுகிறோம்.

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.

டிரான்ஸ்பைலர் பதிவு செய்தல்

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.

பைத்தான் பதிவு குறித்த முழுமையான அறிமுகத்திற்கு official documentation மற்றும் பயிற்சிகள் மற்றும் சமையல் புத்தகம் ஆகியவை அங்கிருந்து இணைக்கப்பட்டுள்ளன.

குறிப்பு: இந்த பிரிவில் பயன்படுத்தப்படும் பெரும்பாலான பதிவு தொகுதி செயல்பாடுகள் உலகளாவிய அமைப்புகளை சரிசெய்கின்றன. இந்த பிரிவில் நீங்கள் கட்டளைகளை இயக்கினால், மற்ற கலங்களிலிருந்து அவை வேறு வரிசையில் இயங்கினால் அது வெளியீட்டை பாதிக்கும்.

பைதான் நிலையான நூலக பதிவை கட்டமைத்தல்

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.

இதைச் செய்வதற்கான எளிய வழி ஓடுவதுதான்:

import logging

logging.basicConfig(level='DEBUG')

அவர் basicConfig() செயல்பாடு (இங்கே ஆவணங்களைக் காண்க: https://docs.python.org/3/library/logging.html#logging.basicConfig) ஒரு ரூட் ஹேண்ட்லர் மற்றும் வடிவமைப்பாளரை உள்ளமைக்கிறது. level குவார்க்குடன் காண்பிக்க log level ஐயும் குறிப்பிடுகிறோம். அதை ஒரு நிலைக்கு அமைப்பது மேலும் உயர் நிலைகளையும் உள்ளடக்கும். எடுத்துக்காட்டாக, நீங்கள் அதை INFO நிலைக்கு கூடுதலாக 'INFO என அமைத்தால், இதில் WARNING, ERROR, மற்றும் CRITICAL பதிவு நிலைகளும் அடங்கும்.

இப்போது இந்த நோட்புக்கில் உள்ள பைதான் சூழல் நீங்கள் டிரான்ஸ்பைலரை இயக்கும்போது stderr க்கு பதிவு செய்திகளை வெளியிடுவதற்கு கட்டமைக்கப்பட்டுள்ளது. உதாரணத்திற்கு:

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.

டிரான்ஸ்பைலருக்கான பதிவு அளவை சரிசெய்தல்

Logging.getLogger ('qiskit.transpiler') பயன்படுத்தும் Qiskit டிரான்ஸ்பைலர் qiskit.transpiler என்ற ஒற்றை பெயர்வெளியைப் பயன்படுத்துகிறது. இது டிரான்ஸ்பைலருக்கான பதிவு அளவை சரிசெய்ய மிகவும் எளிதாக்குகிறது. எடுத்துக்காட்டாக, நீங்கள் INFO மட்டத்தில் அல்லது அதற்கு மேல் பதிவு செய்திகளைக் காண விரும்பினால் மட்டுமே இயக்க முடியும்:

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)

இணையான செயல்பாட்டைச் சமாளிக்க பதிவுகளை அமைத்தல்

இயல்புநிலையாக பல சுற்றுகளுடன் டிரான்ஸ்பைலரை இயக்கும் போது இந்த சுற்றுகள் இணையாக அனுப்பப்படுகின்றன. உள்நுழைவு இயக்கப்பட்டிருப்பதன் மூலம் இதைச் செய்ய விரும்பினால், வெளியீட்டைப் புரிந்து கொள்ள சில கூடுதல் படிகள் தேவை.

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)

பின்னர் transpile() அழைப்பை மீண்டும் இயக்கி புதிய பதிவு வடிவமைப்பைக் காண்க.

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.

நீங்கள் எவ்வாறு கட்டமைக்க முடியும் என்பதற்கு பல வேறுபட்ட விருப்பங்கள் உள்ளன, இந்த எடுத்துக்காட்டு மிகவும் குறைவாகவே உள்ளது. உங்கள் குறிப்பிட்ட பயன்பாட்டு வழக்கு அல்லது விருப்பங்களுக்கு ஏற்றவாறு அதிநவீன பயன்பாட்டு நிகழ்வுகளை உருவாக்க கூடுதல் எடுத்துக்காட்டுகள் மற்றும் விருப்பங்களுக்கு ஆவணங்களைப் பார்க்கவும்.

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.