def test_pass_manager_drawer_style(self):
"""Test to see if the colours are updated when provided by the user"""
# set colours for some passes, but leave others to take the default values
style = {SetLayout: 'cyan',
CheckMap: 'green',
EnlargeWithAncilla: 'pink',
RemoveResetInZeroState: 'grey'}
filename = self._get_resource_path('current_l1.dot')
level_1_pass_manager(self.config).draw(filename=filename, style=style, raw=True)
self.assertFilesAreEqual(filename,
path_to_diagram_reference('pass_manager_style_l1.dot'))
os.remove(filename)
def _transpile_circuit(circuit_config_tuple):
"""Select a PassManager and run a single circuit through it.
Args:
circuit_config_tuple (tuple):
circuit (QuantumCircuit): circuit to transpile
transpile_config (dict): configuration dictating how to transpile. The
dictionary has the following format:
{'optimization_level': int,
'pass_manager': PassManager,
'output_name': string,
'callback': callable,
'pass_manager_config': PassManagerConfig}
Returns:
QuantumCircuit: transpiled circuit
Raises:
TranspilerError: if transpile_config is not valid or transpilation incurs error
"""
circuit, transpile_config = circuit_config_tuple
pass_manager_config = transpile_config['pass_manager_config']
# Workaround for ion trap support: If basis gates includes
# Mølmer-Sørensen (rxx) and the circuit includes gates outside the basis,
# first unroll to u3, cx, then run MSBasisDecomposer to target basis.
basic_insts = ['measure', 'reset', 'barrier', 'snapshot']
device_insts = set(pass_manager_config.basis_gates).union(basic_insts)
ms_basis_swap = None
if 'rxx' in pass_manager_config.basis_gates and \
not device_insts >= circuit.count_ops().keys():
ms_basis_swap = pass_manager_config.basis_gates
pass_manager_config.basis_gates = list(
set(['u3', 'cx']).union(pass_manager_config.basis_gates))
if transpile_config['pass_manager'] is not None:
# either the pass manager is already selected...
pass_manager = transpile_config['pass_manager']
else:
# or we choose an appropriate one based on desired optimization level (default: level 1)
if transpile_config['optimization_level'] is not None:
level = transpile_config['optimization_level']
else:
level = 1
if level == 0:
pass_manager = level_0_pass_manager(pass_manager_config)
elif level == 1:
pass_manager = level_1_pass_manager(pass_manager_config)
elif level == 2:
pass_manager = level_2_pass_manager(pass_manager_config)
elif level == 3:
pass_manager = level_3_pass_manager(pass_manager_config)
else:
raise TranspilerError("optimization_level can range from 0 to 3.")
if ms_basis_swap is not None:
pass_manager.append(MSBasisDecomposer(ms_basis_swap))
return pass_manager.run(circuit,
callback=transpile_config['callback'],
output_name=transpile_config['output_name'])
def _combine_args(shared_transpiler_args, unique_config):
# Pop optimization_level to exclude it from the kwargs when building a
# PassManagerConfig
level = shared_transpiler_args.pop("optimization_level")
pass_manager_config = shared_transpiler_args
pass_manager_config.update(unique_config.pop("pass_manager_config"))
pass_manager_config = PassManagerConfig(**pass_manager_config)
# restore optimization_level in the input shared dict in case it's used again
# in the same process
shared_transpiler_args["optimization_level"] = level
transpile_config = unique_config
transpile_config["pass_manager_config"] = pass_manager_config
if transpile_config["faulty_qubits_map"]:
pass_manager_config.initial_layout = _remap_layout_faulty_backend(
pass_manager_config.initial_layout,
transpile_config["faulty_qubits_map"])
# we choose an appropriate one based on desired optimization level
if level == 0:
pass_manager = level_0_pass_manager(pass_manager_config)
elif level == 1:
pass_manager = level_1_pass_manager(pass_manager_config)
elif level == 2:
pass_manager = level_2_pass_manager(pass_manager_config)
elif level == 3:
pass_manager = level_3_pass_manager(pass_manager_config)
else:
raise TranspilerError("optimization_level can range from 0 to 3.")
return transpile_config, pass_manager
def transpile_circuit(circuit, transpile_config):
"""Select a PassManager and run a single circuit through it.
Args:
circuit (QuantumCircuit): circuit to transpile
transpile_config (TranspileConfig): configuration dictating how to transpile
Returns:
QuantumCircuit: transpiled circuit
Raises:
TranspilerError: if transpile_config is not valid or transpilation incurs error
"""
# either the pass manager is already selected...
if transpile_config.pass_manager is not None:
pass_manager = transpile_config.pass_manager
# or we choose an appropriate one based on desired optimization level (default: level 1)
else:
# Workaround for ion trap support: If basis gates includes
# Mølmer-Sørensen (rxx) and the circuit includes gates outside the basis,
# first unroll to u3, cx, then run MSBasisDecomposer to target basis.
basic_insts = ['measure', 'reset', 'barrier', 'snapshot']
device_insts = set(transpile_config.basis_gates).union(basic_insts)
ms_basis_swap = None
if 'rxx' in transpile_config.basis_gates and \
not device_insts >= circuit.count_ops().keys():
ms_basis_swap = transpile_config.basis_gates
transpile_config.basis_gates = list(
set(['u3', 'cx']).union(transpile_config.basis_gates))
level = transpile_config.optimization_level
if level is None:
level = 1
if level == 0:
pass_manager = level_0_pass_manager(transpile_config)
elif level == 1:
pass_manager = level_1_pass_manager(transpile_config)
elif level == 2:
pass_manager = level_2_pass_manager(transpile_config)
elif level == 3:
pass_manager = level_3_pass_manager(transpile_config)
else:
raise TranspilerError("optimization_level can range from 0 to 3.")
if ms_basis_swap is not None:
pass_manager.append(MSBasisDecomposer(ms_basis_swap))
# Set a callback on the pass manager there is one
if getattr(transpile_config, 'callback', None):
pass_manager.callback = transpile_config.callback
out_circuit = pass_manager.run(circuit)
out_circuit.name = transpile_config.output_name
return out_circuit
def _transpile_circuit(
circuit_config_tuple: Tuple[QuantumCircuit, Dict]) -> QuantumCircuit:
"""Select a PassManager and run a single circuit through it.
Args:
circuit_config_tuple (tuple):
circuit (QuantumCircuit): circuit to transpile
transpile_config (dict): configuration dictating how to transpile. The
dictionary has the following format:
{'optimization_level': int,
'output_name': string,
'callback': callable,
'pass_manager_config': PassManagerConfig}
Returns:
The transpiled circuit
Raises:
TranspilerError: if transpile_config is not valid or transpilation incurs error
"""
circuit, transpile_config = circuit_config_tuple
pass_manager_config = transpile_config['pass_manager_config']
if transpile_config['faulty_qubits_map']:
pass_manager_config.initial_layout = _remap_layout_faulty_backend(
pass_manager_config.initial_layout,
transpile_config['faulty_qubits_map'])
# we choose an appropriate one based on desired optimization level
level = transpile_config['optimization_level']
if level == 0:
pass_manager = level_0_pass_manager(pass_manager_config)
elif level == 1:
pass_manager = level_1_pass_manager(pass_manager_config)
elif level == 2:
pass_manager = level_2_pass_manager(pass_manager_config)
elif level == 3:
pass_manager = level_3_pass_manager(pass_manager_config)
else:
raise TranspilerError("optimization_level can range from 0 to 3.")
if pass_manager_config.scheduling_method is not None:
if pass_manager_config.basis_gates:
if 'delay' not in pass_manager_config.basis_gates:
pass_manager_config.basis_gates.append('delay')
else:
pass_manager_config.basis_gates = ['delay']
result = pass_manager.run(circuit,
callback=transpile_config['callback'],
output_name=transpile_config['output_name'])
if transpile_config['faulty_qubits_map']:
return _remap_circuit_faulty_backend(
result, transpile_config['backend_num_qubits'],
pass_manager_config.backend_properties,
transpile_config['faulty_qubits_map'])
return result
def test_default_pass_manager_two(self):
"""Test default_pass_manager.run(circuitS).
circuit1 and circuit2:
qr0:-[H]--.------------ -> 1
|
qr1:-----(+)--.-------- -> 2
|
qr2:---------(+)--.---- -> 3
|
qr3:-------------(+)--- -> 5
device:
0 - 1 - 2 - 3 - 4 - 5 - 6
| | | | | |
13 - 12 - 11 - 10 - 9 - 8 - 7
"""
qr = QuantumRegister(4, "qr")
circuit1 = QuantumCircuit(qr)
circuit1.h(qr[0])
circuit1.cx(qr[0], qr[1])
circuit1.cx(qr[1], qr[2])
circuit1.cx(qr[2], qr[3])
circuit2 = QuantumCircuit(qr)
circuit2.cx(qr[1], qr[2])
circuit2.cx(qr[0], qr[1])
circuit2.cx(qr[2], qr[3])
coupling_map = FakeMelbourne().configuration().coupling_map
basis_gates = FakeMelbourne().configuration().basis_gates
initial_layout = [None, qr[0], qr[1], qr[2], None, qr[3]]
pass_manager = level_1_pass_manager(
PassManagerConfig(
basis_gates=basis_gates,
coupling_map=CouplingMap(coupling_map),
initial_layout=Layout.from_qubit_list(initial_layout),
seed_transpiler=42,
))
new_circuits = pass_manager.run([circuit1, circuit2])
for new_circuit in new_circuits:
bit_indices = {
bit: idx
for idx, bit in enumerate(new_circuit.qregs[0])
}
for gate, qargs, _ in new_circuit.data:
if isinstance(gate, CXGate):
self.assertIn([bit_indices[x] for x in qargs],
coupling_map)
def transpile_circuit(circuit, transpile_config):
"""Select a PassManager and run a single circuit through it.
Args:
circuit (QuantumCircuit): circuit to transpile
transpile_config (TranspileConfig): configuration dictating how to transpile
Returns:
QuantumCircuit: transpiled circuit
Raises:
TranspilerError: if transpile_config is not valid or transpilation incurs error
"""
# if the pass manager is not already selected, choose an appropriate one.
if transpile_config.pass_manager:
pass_manager = transpile_config.pass_manager
elif transpile_config.optimization_level is not None:
level = transpile_config.optimization_level
if level == 0:
pass_manager = level_0_pass_manager(transpile_config)
elif level == 1:
pass_manager = level_1_pass_manager(transpile_config)
elif level == 2:
pass_manager = level_2_pass_manager(transpile_config)
elif level == 3:
pass_manager = level_3_pass_manager(transpile_config)
else:
raise TranspilerError("optimization_level can range from 0 to 3.")
# legacy behavior
elif transpile_config.coupling_map:
pass_manager = level_1_pass_manager(transpile_config)
else:
pass_manager = default_pass_manager_simulator(transpile_config)
# Set a callback on the pass manager if it's set
if getattr(transpile_config, 'callback', None):
pass_manager.callback = transpile_config.callback
return pass_manager.run(circuit)
def test_custom_pass_manager(self, backend):
"""Test quantum kernel with a custom pass manager."""
quantum_instance = QuantumInstance(
backend,
shots=100,
seed_simulator=algorithm_globals.random_seed,
seed_transpiler=algorithm_globals.random_seed,
pass_manager=level_1_pass_manager(
PassManagerConfig(basis_gates=["u3", "cx"])),
bound_pass_manager=level_1_pass_manager(
PassManagerConfig(basis_gates=["u3", "cx"])),
)
kernel = QuantumKernel(feature_map=self.feature_map,
quantum_instance=quantum_instance)
svc = SVC(kernel=kernel.evaluate)
svc.fit(self.sample_train, self.label_train)
score = svc.score(self.sample_test, self.label_test)
self.assertEqual(score, 0.5)
def test_2step_transpile(self):
"""Test the two-step transpiler pass."""
# count how often the pass for parameterized circuits is called
pre_counter = LogPass("pre_passmanager")
pre_pass = PassManager(pre_counter)
config = PassManagerConfig(basis_gates=["u3", "cx"])
pre_pass += level_1_pass_manager(config)
# ... and the pass for bound circuits
bound_counter = LogPass("bound_pass_manager")
bound_pass = PassManager(bound_counter)
quantum_instance = QuantumInstance(
backend=BasicAer.get_backend("statevector_simulator"),
basis_gates=["u3", "cx"],
pass_manager=pre_pass,
bound_pass_manager=bound_pass,
)
optimizer = SPSA(maxiter=5, learning_rate=0.01, perturbation=0.01)
vqe = VQE(optimizer=optimizer, quantum_instance=quantum_instance)
_ = vqe.compute_minimum_eigenvalue(Z)
with self.assertLogs(logger, level="INFO") as cm:
_ = vqe.compute_minimum_eigenvalue(Z)
expected = [
"pre_passmanager",
"bound_pass_manager",
"bound_pass_manager",
"bound_pass_manager",
"bound_pass_manager",
"bound_pass_manager",
"bound_pass_manager",
"bound_pass_manager",
"bound_pass_manager",
"bound_pass_manager",
"bound_pass_manager",
"bound_pass_manager",
"pre_passmanager",
"bound_pass_manager",
]
self.assertEqual([record.message for record in cm.records], expected)
def test_default_pass_manager_single(self):
"""Test default_pass_manager.run(circuit).
circuit:
qr0:-[H]--.------------ -> 1
|
qr1:-----(+)--.-------- -> 2
|
qr2:---------(+)--.---- -> 3
|
qr3:-------------(+)--- -> 5
device:
0 - 1 - 2 - 3 - 4 - 5 - 6
| | | | | |
13 - 12 - 11 - 10 - 9 - 8 - 7
"""
qr = QuantumRegister(4, 'qr')
circuit = QuantumCircuit(qr)
circuit.h(qr[0])
circuit.cx(qr[0], qr[1])
circuit.cx(qr[1], qr[2])
circuit.cx(qr[2], qr[3])
coupling_map = FakeMelbourne().configuration().coupling_map
basis_gates = FakeMelbourne().configuration().basis_gates
initial_layout = [None, qr[0], qr[1], qr[2], None, qr[3]]
pass_manager = level_1_pass_manager(
TranspileConfig(
basis_gates=basis_gates,
coupling_map=CouplingMap(coupling_map),
initial_layout=Layout.from_qubit_list(initial_layout),
seed_transpiler=42,
optimization_level=1))
new_circuit = pass_manager.run(circuit)
for gate, qargs, _ in new_circuit.data:
if isinstance(gate, CnotGate):
self.assertIn([x.index for x in qargs], coupling_map)
def transpile_circuit(circuit, transpile_config):
"""Select a PassManager and run a single circuit through it.
Args:
circuit (QuantumCircuit): circuit to transpile
transpile_config (TranspileConfig): configuration dictating how to transpile
Returns:
QuantumCircuit: transpiled circuit
Raises:
TranspilerError: if transpile_config is not valid or transpilation incurs error
"""
# either the pass manager is already selected...
if transpile_config.pass_manager:
pass_manager = transpile_config.pass_manager
# or we choose an appropriate one based on desired optimization level (default: level 1)
else:
level = transpile_config.optimization_level
if level is None:
level = 1
if level == 0:
pass_manager = level_0_pass_manager(transpile_config)
elif level == 1:
pass_manager = level_1_pass_manager(transpile_config)
elif level == 2:
pass_manager = level_2_pass_manager(transpile_config)
elif level == 3:
pass_manager = level_3_pass_manager(transpile_config)
else:
raise TranspilerError("optimization_level can range from 0 to 3.")
# Set a callback on the pass manager there is one
if getattr(transpile_config, 'callback', None):
pass_manager.callback = transpile_config.callback
out_circuit = pass_manager.run(circuit)
out_circuit.name = transpile_config.output_name
return out_circuit
def _transpile_circuit(
circuit_config_tuple: Tuple[QuantumCircuit, Dict]) -> QuantumCircuit:
"""Select a PassManager and run a single circuit through it.
Args:
circuit_config_tuple (tuple):
circuit (QuantumCircuit): circuit to transpile
transpile_config (dict): configuration dictating how to transpile. The
dictionary has the following format:
{'optimization_level': int,
'output_name': string,
'callback': callable,
'pass_manager_config': PassManagerConfig}
Returns:
The transpiled circuit
Raises:
TranspilerError: if transpile_config is not valid or transpilation incurs error
"""
circuit, transpile_config = circuit_config_tuple
pass_manager_config = transpile_config['pass_manager_config']
if transpile_config['faulty_qubits_map']:
pass_manager_config.initial_layout = _remap_layout_faulty_backend(
pass_manager_config.initial_layout,
transpile_config['faulty_qubits_map'])
ms_basis_swap = None
if (pass_manager_config.translation_method == 'unroller'
and pass_manager_config.basis_gates is not None):
# Workaround for ion trap support: If basis gates includes
# Mølmer-Sørensen (rxx) and the circuit includes gates outside the basis,
# first unroll to u3, cx, then run MSBasisDecomposer to target basis.
basic_insts = ['measure', 'reset', 'barrier', 'snapshot']
device_insts = set(pass_manager_config.basis_gates).union(basic_insts)
if 'rxx' in pass_manager_config.basis_gates and \
not device_insts >= circuit.count_ops().keys():
ms_basis_swap = pass_manager_config.basis_gates
pass_manager_config.basis_gates = list(
set(['u3', 'cx']).union(pass_manager_config.basis_gates))
# we choose an appropriate one based on desired optimization level
level = transpile_config['optimization_level']
if level == 0:
pass_manager = level_0_pass_manager(pass_manager_config)
elif level == 1:
pass_manager = level_1_pass_manager(pass_manager_config)
elif level == 2:
pass_manager = level_2_pass_manager(pass_manager_config)
elif level == 3:
pass_manager = level_3_pass_manager(pass_manager_config)
else:
raise TranspilerError("optimization_level can range from 0 to 3.")
if ms_basis_swap is not None:
pass_manager.append(MSBasisDecomposer(ms_basis_swap))
result = pass_manager.run(circuit,
callback=transpile_config['callback'],
output_name=transpile_config['output_name'])
if transpile_config['faulty_qubits_map']:
return _remap_circuit_faulty_backend(
result, transpile_config['backend_num_qubits'],
pass_manager_config.backend_properties,
transpile_config['faulty_qubits_map'])
return result
