def test_measurement_error_mitigation(self):
aqua_globals.random_seed = 0
# build noise model
noise_model = noise.NoiseModel()
read_err = noise.errors.readout_error.ReadoutError([[0.9, 0.1], [0.25, 0.75]])
noise_model.add_all_qubit_readout_error(read_err)
backend = Aer.get_backend('qasm_simulator')
quantum_instance = QuantumInstance(backend=backend, seed=167, seed_transpiler=167,
noise_model=noise_model)
quantum_instance_with_mitigation = QuantumInstance(backend=backend, seed=167, seed_transpiler=167,
noise_model=noise_model,
measurement_error_mitigation_cls=CompleteMeasFitter)
input = 'a & b & c'
oracle = LogicalExpressionOracle(input, optimization='off')
grover = Grover(oracle)
result_wo_mitigation = grover.run(quantum_instance)
prob_top_measurement_wo_mitigation = result_wo_mitigation['measurement'][
result_wo_mitigation['top_measurement']]
result_w_mitigation = grover.run(quantum_instance_with_mitigation)
prob_top_measurement_w_mitigation = result_w_mitigation['measurement'][result_w_mitigation['top_measurement']]
self.assertGreaterEqual(prob_top_measurement_w_mitigation, prob_top_measurement_wo_mitigation)
def test_measurement_error_mitigation_auto_refresh(self):
aqua_globals.random_seed = 0
# build noise model
noise_model = noise.NoiseModel()
read_err = noise.errors.readout_error.ReadoutError([[0.9, 0.1], [0.25, 0.75]])
noise_model.add_all_qubit_readout_error(read_err)
backend = Aer.get_backend('qasm_simulator')
quantum_instance = QuantumInstance(backend=backend, seed=1679, seed_transpiler=167,
noise_model=noise_model,
measurement_error_mitigation_cls=CompleteMeasFitter,
cals_matrix_refresh_period=0)
input = 'a & b & c'
oracle = LogicalExpressionOracle(input, optimization='off')
grover = Grover(oracle)
_ = grover.run(quantum_instance)
cals_matrix_1 = quantum_instance.cals_matrix.copy()
time.sleep(15)
aqua_globals.random_seed = 2
quantum_instance.set_config(seed=111)
_ = grover.run(quantum_instance)
cals_matrix_2 = quantum_instance.cals_matrix.copy()
diff = cals_matrix_1 - cals_matrix_2
total_diff = np.sum(np.abs(diff))
self.assertGreater(total_diff, 0.0)
def test_measurement_error_mitigation_qaoa(self):
"""measurement error mitigation test with QAOA"""
algorithm_globals.random_seed = 167
# build noise model
noise_model = noise.NoiseModel()
read_err = noise.errors.readout_error.ReadoutError([[0.9, 0.1],
[0.25, 0.75]])
noise_model.add_all_qubit_readout_error(read_err)
backend = Aer.get_backend("aer_simulator")
quantum_instance = QuantumInstance(
backend=backend,
seed_simulator=algorithm_globals.random_seed,
seed_transpiler=algorithm_globals.random_seed,
noise_model=noise_model,
measurement_error_mitigation_cls=CompleteMeasFitter,
)
w = rx.adjacency_matrix(
rx.undirected_gnp_random_graph(5,
0.5,
seed=algorithm_globals.random_seed))
qubit_op, _ = self._get_operator(w)
qaoa = QAOA(
optimizer=COBYLA(maxiter=1),
quantum_instance=quantum_instance,
initial_point=np.asarray([0.0, 0.0]),
)
result = qaoa.compute_minimum_eigenvalue(operator=qubit_op)
self.assertAlmostEqual(result.eigenvalue.real, 3.49, delta=0.05)
def _test_kraus_gate_noise_on_QFT(self, **options):
shots = 10000
# Build noise model
error1 = noise.amplitude_damping_error(0.2)
error2 = error1.tensor(error1)
noise_model = noise.NoiseModel()
noise_model.add_all_qubit_quantum_error(error1, ['h'])
noise_model.add_all_qubit_quantum_error(error2, ['cp', 'swap'])
backend = self.backend(**options, noise_model=noise_model)
ideal_circuit = transpile(QFT(3), backend)
# manaully build noise circuit
noise_circuit = QuantumCircuit(3)
for inst, qargs, cargs in ideal_circuit.data:
noise_circuit.append(inst, qargs, cargs)
if inst.name == "h":
noise_circuit.append(error1, qargs)
elif inst.name in ["cp", "swap"]:
noise_circuit.append(error2, qargs)
# compute target counts
noise_state = DensityMatrix(noise_circuit)
ref_target = {i: shots * p for i, p in noise_state.probabilities_dict().items()}
# Run sim
ideal_circuit.measure_all()
result = backend.run(ideal_circuit, shots=shots).result()
self.assertSuccess(result)
self.compare_counts(result, [ideal_circuit], [ref_target], hex_counts=False, delta=0.1 * shots)
def noise_model_converter(self, nm):
if nm is None:
return None
basis_gates = basis
qnoise = qiskitnoise.NoiseModel(basis_gates)
for noise in nm.noises:
op = self.noise_lookup[noise.name]
if op is qiskitnoise.depolarizing_error:
active = op(noise.probs[0], noise.level)
else:
if noise.level == 1:
active = op(*noise.probs)
else:
active = op(*noise.probs)
action = op(*noise.probs)
for i in range(noise.level - 1):
active = active.tensor(action)
if noise.level == 2:
targets = ['cx', 'cy', 'cz', 'crz', 'crx', 'cry', 'cu3', 'ch']
elif noise.level == 1:
targets = ['x', 'y', 'z', 'u3', 'u1', 'u2', 'h']
elif noise.level == 3:
targets = ['ccx']
else:
raise TequilaQiskitException(
'Sorry, no support yet for qiskit for noise on more than 3 qubits.'
)
qnoise.add_all_qubit_quantum_error(active, targets)
return qnoise
def test_measurement_error_mitigation_with_dedicated_shots(self):
from qiskit import Aer
from qiskit.providers.aer import noise
aqua_globals.random_seed = 0
# build noise model
noise_model = noise.NoiseModel()
read_err = noise.errors.readout_error.ReadoutError([[0.9, 0.1], [0.25, 0.75]])
noise_model.add_all_qubit_readout_error(read_err)
backend = Aer.get_backend('qasm_simulator')
quantum_instance = QuantumInstance(backend=backend, seed_simulator=1679, seed_transpiler=167, shots=100,
noise_model=noise_model,
measurement_error_mitigation_cls=CompleteMeasFitter,
cals_matrix_refresh_period=0)
input = 'a & b & c'
oracle = LogicalExpressionOracle(input)
grover = Grover(oracle)
_ = grover.run(quantum_instance)
cals_matrix_1, timestamp_1 = quantum_instance.cals_matrix(qubit_index=[0, 1, 2])
quantum_instance.measurement_error_mitigation_shots = 1000
_ = grover.run(quantum_instance)
cals_matrix_2, timestamp_2 = quantum_instance.cals_matrix(qubit_index=[0, 1, 2])
diff = cals_matrix_1 - cals_matrix_2
total_diff = np.sum(np.abs(diff))
self.assertGreater(total_diff, 0.0)
self.assertGreater(timestamp_2, timestamp_1)
def test_measurement_error_mitigation(self):
try:
from qiskit import Aer
from qiskit.providers.aer import noise
except Exception as e:
self.skipTest("Aer doesn't appear to be installed. Error: '{}'".format(str(e)))
return
aqua_globals.random_seed = 0
# build noise model
noise_model = noise.NoiseModel()
read_err = noise.errors.readout_error.ReadoutError([[0.9, 0.1], [0.25, 0.75]])
noise_model.add_all_qubit_readout_error(read_err)
backend = Aer.get_backend('qasm_simulator')
quantum_instance = QuantumInstance(backend=backend, seed_simulator=167, seed_transpiler=167,
noise_model=noise_model)
quantum_instance_with_mitigation = QuantumInstance(backend=backend, seed_simulator=167, seed_transpiler=167,
noise_model=noise_model,
measurement_error_mitigation_cls=CompleteMeasFitter)
input = 'a & b & c'
oracle = LogicalExpressionOracle(input)
grover = Grover(oracle)
result_wo_mitigation = grover.run(quantum_instance)
prob_top_measurement_wo_mitigation = result_wo_mitigation['measurement'][
result_wo_mitigation['top_measurement']]
result_w_mitigation = grover.run(quantum_instance_with_mitigation)
prob_top_measurement_w_mitigation = result_w_mitigation['measurement'][result_w_mitigation['top_measurement']]
self.assertGreaterEqual(prob_top_measurement_w_mitigation, prob_top_measurement_wo_mitigation)
def test_save_qiskit_noise_model(self):
# Given
noise_model = AerNoise.NoiseModel()
quantum_error = AerNoise.depolarizing_error(0.0, 1)
coherent_error = np.asarray([
np.asarray(
[0.87758256 - 0.47942554j, 0.0 + 0.0j, 0.0 + 0.0j,
0.0 + 0.0j]),
np.asarray(
[0.0 + 0.0j, 0.87758256 + 0.47942554j, 0.0 + 0.0j,
0.0 + 0.0j]),
np.asarray(
[0.0 + 0.0j, 0.0 + 0.0j, 0.87758256 + 0.47942554j,
0.0 + 0.0j]),
np.asarray(
[0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j,
0.87758256 - 0.47942554j]),
])
noise_model.add_quantum_error(
AerNoise.coherent_unitary_error(coherent_error), ["cx"], [0, 1])
filename = "noise_model.json"
# When
save_qiskit_noise_model(noise_model, filename)
# Then
with open("noise_model.json", "r") as f:
data = json.loads(f.read())
self.assertEqual(data["module_name"], "qeqiskit.utils")
self.assertEqual(data["function_name"], "load_qiskit_noise_model")
self.assertIsInstance(data["data"], dict)
# Cleanup
subprocess.run(["rm", "noise_model.json"])
def get_noise(prob_1, prob_2, qc):
# Error probabilities
# prob_1 = 0.001 # 1-qubit gate
# prob_2 = 0.01 # 2-qubit gate
# Depolarizing quantum errors
error_1 = noise.depolarizing_error(prob_1, 1)
error_2 = noise.depolarizing_error(prob_2, 2)
# Add errors to noise model
noise_model = noise.NoiseModel()
noise_model.add_all_qubit_quantum_error(error_1, ['u1', 'u2', 'u3'])
noise_model.add_all_qubit_quantum_error(error_2, ['cx'])
# Get basis gates from noise model
basis_gates = noise_model.basis_gates
# Make a circuit
# Perform a noise simulation
new_result = execute(qc,
Aer.get_backend('qasm_simulator'),
basis_gates=basis_gates,
noise_model=noise_model).result()
if np.empty_like(new_result) == 0:
new_counts = new_result.get_counts(0)
plot_histogram(new_counts)
return [noise_model, new_counts]
else:
return noise_model
def test_measurement_error_mitigation_with_diff_qubit_order_ignis(
self, fitter_str):
"""measurement error mitigation with different qubit order"""
algorithm_globals.random_seed = 0
# build noise model
noise_model = noise.NoiseModel()
read_err = noise.errors.readout_error.ReadoutError([[0.9, 0.1],
[0.25, 0.75]])
noise_model.add_all_qubit_readout_error(read_err)
fitter_cls = (CompleteMeasFitter_IG if fitter_str
== "CompleteMeasFitter" else TensoredMeasFitter_IG)
backend = Aer.get_backend("aer_simulator")
quantum_instance = QuantumInstance(
backend=backend,
seed_simulator=1679,
seed_transpiler=167,
shots=1000,
noise_model=noise_model,
measurement_error_mitigation_cls=fitter_cls,
cals_matrix_refresh_period=0,
)
# circuit
qc1 = QuantumCircuit(2, 2)
qc1.h(0)
qc1.cx(0, 1)
qc1.measure(0, 0)
qc1.measure(1, 1)
qc2 = QuantumCircuit(2, 2)
qc2.h(0)
qc2.cx(0, 1)
qc2.measure(1, 0)
qc2.measure(0, 1)
if fitter_cls == TensoredMeasFitter_IG:
with self.assertWarnsRegex(DeprecationWarning, r".*ignis.*"):
self.assertRaisesRegex(
QiskitError,
"TensoredMeasFitter doesn't support subset_fitter.",
quantum_instance.execute,
[qc1, qc2],
)
else:
# this should run smoothly
with self.assertWarnsRegex(DeprecationWarning, r".*ignis.*"):
quantum_instance.execute([qc1, qc2])
self.assertGreater(quantum_instance.time_taken, 0.0)
quantum_instance.reset_execution_results()
# failure case
qc3 = QuantumCircuit(3, 3)
qc3.h(2)
qc3.cx(1, 2)
qc3.measure(2, 1)
qc3.measure(1, 2)
self.assertRaises(QiskitError, quantum_instance.execute, [qc1, qc3])
def test_empty_circuit_noise(self, method, device):
"""Test simulation with empty circuit and noise model."""
backend = self.backend(method=method, device=device)
noise_model = noise.NoiseModel()
noise_model.add_all_qubit_quantum_error(noise.depolarizing_error(0.1, 1), ['x'])
result = backend.run(
QuantumCircuit(), shots=1, noise_model=noise_model).result()
self.assertSuccess(result)
def none(backend):
if backend.name() == 'qasm_simulator':
noise_model = noise.NoiseModel()
else:
print('SimulationError: Invalid option for noisy simulator')
sys.exit()
return noise_model
def test_measurement_error_mitigation_with_diff_qubit_order(self):
"""measurement error mitigation with different qubit order"""
try:
from qiskit.ignis.mitigation.measurement import CompleteMeasFitter
from qiskit import Aer
from qiskit.providers.aer import noise
except ImportError as ex:
self.skipTest(
"Package doesn't appear to be installed. Error: '{}'".format(
str(ex)))
return
algorithm_globals.random_seed = 0
# build noise model
noise_model = noise.NoiseModel()
read_err = noise.errors.readout_error.ReadoutError([[0.9, 0.1],
[0.25, 0.75]])
noise_model.add_all_qubit_readout_error(read_err)
backend = Aer.get_backend("aer_simulator")
quantum_instance = QuantumInstance(
backend=backend,
seed_simulator=1679,
seed_transpiler=167,
shots=1000,
noise_model=noise_model,
measurement_error_mitigation_cls=CompleteMeasFitter,
cals_matrix_refresh_period=0,
)
# circuit
qc1 = QuantumCircuit(2, 2)
qc1.h(0)
qc1.cx(0, 1)
qc1.measure(0, 0)
qc1.measure(1, 1)
qc2 = QuantumCircuit(2, 2)
qc2.h(0)
qc2.cx(0, 1)
qc2.measure(1, 0)
qc2.measure(0, 1)
# this should run smoothly
quantum_instance.execute([qc1, qc2])
self.assertGreater(quantum_instance.time_taken, 0.0)
quantum_instance.reset_execution_results()
# failure case
qc3 = QuantumCircuit(3, 3)
qc3.h(2)
qc3.cx(1, 2)
qc3.measure(2, 1)
qc3.measure(1, 2)
self.assertRaises(QiskitError, quantum_instance.execute, [qc1, qc3])
def run_simulation(self, shots=8192, error_prob=0, target_state='0'):
# add noise
error_1 = noise.depolarizing_error(error_prob, 1)
noise_model = noise.NoiseModel()
noise_model.add_all_qubit_quantum_error(error_1, ['x', 'z'])
# run simulation
self.qc.measure(0, 0)
emulator = Aer.get_backend('qasm_simulator')
job = execute(self.qc, emulator, noise_model=noise_model, shots=shots)
hist = job.result().get_counts()
print(hist)
def noisy_model(prob_one, prob_two):
# Depolarizing quantum errors
error_1 = noise.depolarizing_error(prob_one, 1)
error_2 = noise.depolarizing_error(prob_two, 2)
# Add errors to noise model
noise_model = noise.NoiseModel()
noise_model.add_all_qubit_quantum_error(error_1, ['u1', 'u2', 'u3'])
noise_model.add_all_qubit_quantum_error(error_2, ['cx'])
basis_gates = noise_model.basis_gates
return (noise_model, basis_gates)
def test_measurement_error_mitigation_with_diff_qubit_order(self):
""" measurement error mitigation with different qubit order"""
# pylint: disable=import-outside-toplevel
try:
from qiskit import Aer
from qiskit.providers.aer import noise
except ImportError as ex: # pylint: disable=broad-except
self.skipTest(
"Aer doesn't appear to be installed. Error: '{}'".format(
str(ex)))
return
aqua_globals.random_seed = 0
# build noise model
noise_model = noise.NoiseModel()
read_err = noise.errors.readout_error.ReadoutError([[0.9, 0.1],
[0.25, 0.75]])
noise_model.add_all_qubit_readout_error(read_err)
backend = Aer.get_backend('qasm_simulator')
quantum_instance = QuantumInstance(
backend=backend,
seed_simulator=1679,
seed_transpiler=167,
shots=1000,
noise_model=noise_model,
measurement_error_mitigation_cls=CompleteMeasFitter,
cals_matrix_refresh_period=0)
# circuit
qc1 = QuantumCircuit(2, 2)
qc1.h(0)
qc1.cx(0, 1)
qc1.measure(0, 0)
qc1.measure(1, 1)
qc2 = QuantumCircuit(2, 2)
qc2.h(0)
qc2.cx(0, 1)
qc2.measure(1, 0)
qc2.measure(0, 1)
# this should run smoothly
quantum_instance.execute([qc1, qc2])
# failure case
qc3 = QuantumCircuit(3, 3)
qc3.h(2)
qc3.cx(1, 2)
qc3.measure(2, 1)
qc3.measure(1, 2)
self.assertRaises(AquaError, quantum_instance.execute, [qc1, qc3])
def randbin3(data, F): # simulator --- WORKS with reversed probabilities
#error_1 = noise.depolarizing_error(data.phase_err, 1)
error_1 = noise.phase_amplitude_damping_error(param_phase=data.phase_err,
param_amp=data.amp_err)
error_2 = noise.thermal_relaxation_error(data.T_1,
data.T_2,
data.t * 10**(6),
excited_state_population=0)
noise_model = noise.NoiseModel()
noise_model.add_all_qubit_quantum_error(error_2, ['rz'])
basis_gates = noise_model.basis_gates
phi = data.const * F * data.t * data.F_degree
q = QuantumRegister(1)
c = ClassicalRegister(1)
# Create a Quantum Circuit acting on the q register
circuit = QuantumCircuit(q, c)
circuit.h(q)
circuit.rz(phi, q)
circuit.h(q)
# Map the quantum measurement to the classical bits
circuit.measure(q, c)
# Execute the circuit on the qasm simulator
job = execute(circuit,
simulator,
basis_gates=basis_gates,
noise_model=noise_model,
shots=data.num_of_repetitions)
#job_monitor(job)
# Grab results from the job
result = job.result()
# Returns counts
counts = result.get_counts(circuit)
#print(counts, 'for sim')
#return counts
try:
if counts['1'] < counts['0']: # LOWEST BECAUSE PROBS ARE REVERSED!!!
return 1
else:
return 0
except Exception:
return abs(int(list(counts.keys())[0]) - 1)
def test_backend_options_cleaned(self):
"""Test that the backend options are cleared upon new Aer device
initialization."""
noise_model = noise.NoiseModel()
bit_flip = noise.pauli_error([('X', 1), ('I', 0)])
# Create a noise model where the RX operation always flips the bit
noise_model.add_all_qubit_quantum_error(bit_flip, ["rx"])
dev = qml.device('qiskit.aer', wires=2, noise_model=noise_model)
assert 'noise_model' in dev.backend.options
dev2 = qml.device('qiskit.aer', wires=2)
assert 'noise_model' not in dev2.backend.options
def test_backend_options_cleaned(self):
"""Test that the backend options are cleared upon new Aer device
initialization."""
noise_model = noise.NoiseModel()
bit_flip = noise.pauli_error([("X", 1), ("I", 0)])
# Create a noise model where the RX operation always flips the bit
noise_model.add_all_qubit_quantum_error(bit_flip, ["rx"])
dev = qml.device("qiskit.aer", wires=2, noise_model=noise_model)
assert dev.backend.options.get("noise_model") is not None
dev2 = qml.device("qiskit.aer", wires=2)
assert dev2.backend.options.get("noise_model") is None
def test_measurement_error_mitigation_auto_refresh(self):
""" measurement error mitigation auto refresh test """
try:
# pylint: disable=import-outside-toplevel
from qiskit import Aer
from qiskit.providers.aer import noise
except ImportError as ex: # pylint: disable=broad-except
self.skipTest(
"Aer doesn't appear to be installed. Error: '{}'".format(
str(ex)))
return
aqua_globals.random_seed = 0
# build noise model
noise_model = noise.NoiseModel()
read_err = noise.errors.readout_error.ReadoutError([[0.9, 0.1],
[0.25, 0.75]])
noise_model.add_all_qubit_readout_error(read_err)
backend = Aer.get_backend('qasm_simulator')
quantum_instance = QuantumInstance(
backend=backend,
seed_simulator=1679,
seed_transpiler=167,
noise_model=noise_model,
measurement_error_mitigation_cls=CompleteMeasFitter,
cals_matrix_refresh_period=0)
oracle = LogicalExpressionOracle('a & b & c')
grover = Grover(oracle)
_ = grover.run(quantum_instance)
self.assertGreater(quantum_instance.time_taken, 0.)
quantum_instance.reset_execution_results()
cals_matrix_1, timestamp_1 = quantum_instance.cals_matrix(
qubit_index=[0, 1, 2])
time.sleep(15)
aqua_globals.random_seed = 2
quantum_instance.set_config(seed_simulator=111)
_ = grover.run(quantum_instance)
cals_matrix_2, timestamp_2 = quantum_instance.cals_matrix(
qubit_index=[0, 1, 2])
diff = cals_matrix_1 - cals_matrix_2
total_diff = np.sum(np.abs(diff))
self.assertGreater(total_diff, 0.0)
self.assertGreater(timestamp_2, timestamp_1)
def test_measurement_error_mitigation_with_vqe(self):
""" measurement error mitigation test with vqe """
try:
# pylint: disable=import-outside-toplevel
from qiskit import Aer
from qiskit.providers.aer import noise
except ImportError as ex: # pylint: disable=broad-except
self.skipTest(
"Aer doesn't appear to be installed. Error: '{}'".format(
str(ex)))
return
aqua_globals.random_seed = 0
# build noise model
noise_model = noise.NoiseModel()
read_err = noise.errors.readout_error.ReadoutError([[0.9, 0.1],
[0.25, 0.75]])
noise_model.add_all_qubit_readout_error(read_err)
backend = Aer.get_backend('qasm_simulator')
quantum_instance = QuantumInstance(
backend=backend,
seed_simulator=167,
seed_transpiler=167,
noise_model=noise_model,
measurement_error_mitigation_cls=CompleteMeasFitter)
h2_hamiltonian = -1.052373245772859 * (I ^ I) \
+ 0.39793742484318045 * (I ^ Z) \
- 0.39793742484318045 * (Z ^ I) \
- 0.01128010425623538 * (Z ^ Z) \
+ 0.18093119978423156 * (X ^ X)
optimizer = SPSA(maxiter=200)
var_form = EfficientSU2(2, reps=1)
vqe = VQE(
var_form=var_form,
operator=h2_hamiltonian,
quantum_instance=quantum_instance,
optimizer=optimizer,
)
result = vqe.compute_minimum_eigenvalue()
self.assertGreater(quantum_instance.time_taken, 0.)
quantum_instance.reset_execution_results()
self.assertAlmostEqual(result.eigenvalue.real, -1.86, places=2)
def test_measurement_error_mitigation(self):
""" measurement error mitigation test """
try:
# pylint: disable=import-outside-toplevel
from qiskit import Aer
from qiskit.providers.aer import noise
except ImportError as ex: # pylint: disable=broad-except
self.skipTest(
"Aer doesn't appear to be installed. Error: '{}'".format(
str(ex)))
return
aqua_globals.random_seed = 0
# build noise model
noise_model = noise.NoiseModel()
read_err = noise.errors.readout_error.ReadoutError([[0.9, 0.1],
[0.25, 0.75]])
noise_model.add_all_qubit_readout_error(read_err)
backend = Aer.get_backend('qasm_simulator')
quantum_instance = QuantumInstance(backend=backend,
seed_simulator=167,
seed_transpiler=167,
noise_model=noise_model)
qi_with_mitigation = \
QuantumInstance(backend=backend,
seed_simulator=167,
seed_transpiler=167,
noise_model=noise_model,
measurement_error_mitigation_cls=CompleteMeasFitter)
oracle = LogicalExpressionOracle('a & b & c')
grover = Grover(oracle)
result_wo_mitigation = grover.run(quantum_instance)
self.assertGreater(quantum_instance.time_taken, 0.)
quantum_instance.reset_execution_results()
prob_top_meas_wo_mitigation = result_wo_mitigation.measurement[
result_wo_mitigation.top_measurement]
result_w_mitigation = grover.run(qi_with_mitigation)
prob_top_meas_w_mitigation = \
result_w_mitigation.measurement[result_w_mitigation.top_measurement]
self.assertGreaterEqual(prob_top_meas_w_mitigation,
prob_top_meas_wo_mitigation)
def __get_counts(self,
params: List[float or int],
shots: int = 1000) -> dict:
"""
Here we run the circuit according to the given parameters for each gate and return the counts for each state.
:param params: List of the parameters of the RY and RX gates of the circuit.
:param shots: Total number of shots the circuit must execute
"""
# Error probabilities
prob_1 = 0.001 # 1-qubit gate
prob_2 = 0.01 # 2-qubit gate
# Depolarizing quantum errors
error_1 = noise.depolarizing_error(prob_1, 1)
error_2 = noise.depolarizing_error(prob_2, 2)
# Add errors to noise model
noise_model = noise.NoiseModel()
noise_model.add_all_qubit_quantum_error(error_1, ['u1', 'u2'])
noise_model.add_all_qubit_quantum_error(error_2, ['cx'])
# Get basis gates from noise model
basis_gates = noise_model.basis_gates
# Make a circuit
circ = QuantumCircuit(2, 2)
# Set gates and measurement
circ.ry(params[0], 0)
circ.rx(params[1], 1)
circ.cx(0, 1)
circ.measure([0, 1], [0, 1])
# Perform a noisy simulation and get the counts
# noinspection PyTypeChecker
result = execute(circ,
Aer.get_backend('qasm_simulator'),
basis_gates=basis_gates,
noise_model=noise_model,
shots=shots).result()
counts = result.get_counts(0)
return counts
def test_measurement_error_mitigation_with_vqe(self):
"""measurement error mitigation test with vqe"""
try:
from qiskit.ignis.mitigation.measurement import CompleteMeasFitter
from qiskit import Aer
from qiskit.providers.aer import noise
except ImportError as ex:
self.skipTest(
"Package doesn't appear to be installed. Error: '{}'".format(
str(ex)))
return
algorithm_globals.random_seed = 0
# build noise model
noise_model = noise.NoiseModel()
read_err = noise.errors.readout_error.ReadoutError([[0.9, 0.1],
[0.25, 0.75]])
noise_model.add_all_qubit_readout_error(read_err)
backend = Aer.get_backend("aer_simulator")
quantum_instance = QuantumInstance(
backend=backend,
seed_simulator=167,
seed_transpiler=167,
noise_model=noise_model,
measurement_error_mitigation_cls=CompleteMeasFitter,
)
h2_hamiltonian = (-1.052373245772859 * (I ^ I) + 0.39793742484318045 *
(I ^ Z) - 0.39793742484318045 * (Z ^ I) -
0.01128010425623538 * (Z ^ Z) + 0.18093119978423156 *
(X ^ X))
optimizer = SPSA(maxiter=200)
ansatz = EfficientSU2(2, reps=1)
vqe = VQE(ansatz=ansatz,
optimizer=optimizer,
quantum_instance=quantum_instance)
result = vqe.compute_minimum_eigenvalue(operator=h2_hamiltonian)
self.assertGreater(quantum_instance.time_taken, 0.0)
quantum_instance.reset_execution_results()
self.assertAlmostEqual(result.eigenvalue.real, -1.86, delta=0.05)
def test_measurement_error_mitigation_with_vqe(self, config):
"""measurement error mitigation test with vqe"""
if _ERROR_MITIGATION_IMPORT_ERROR is not None:
self.skipTest(
f"Package doesn't appear to be installed. Error: '{_ERROR_MITIGATION_IMPORT_ERROR}'"
)
return
fitter_str, mit_pattern = config
algorithm_globals.random_seed = 0
# build noise model
noise_model = noise.NoiseModel()
read_err = noise.errors.readout_error.ReadoutError([[0.9, 0.1],
[0.25, 0.75]])
noise_model.add_all_qubit_readout_error(read_err)
fitter_cls = (CompleteMeasFitter if fitter_str == "CompleteMeasFitter"
else TensoredMeasFitter)
backend = Aer.get_backend("aer_simulator")
quantum_instance = QuantumInstance(
backend=backend,
seed_simulator=167,
seed_transpiler=167,
noise_model=noise_model,
measurement_error_mitigation_cls=fitter_cls,
mit_pattern=mit_pattern,
)
h2_hamiltonian = (-1.052373245772859 * (I ^ I) + 0.39793742484318045 *
(I ^ Z) - 0.39793742484318045 * (Z ^ I) -
0.01128010425623538 * (Z ^ Z) + 0.18093119978423156 *
(X ^ X))
optimizer = SPSA(maxiter=200)
ansatz = EfficientSU2(2, reps=1)
vqe = VQE(ansatz=ansatz,
optimizer=optimizer,
quantum_instance=quantum_instance)
result = vqe.compute_minimum_eigenvalue(operator=h2_hamiltonian)
self.assertGreater(quantum_instance.time_taken, 0.0)
quantum_instance.reset_execution_results()
self.assertAlmostEqual(result.eigenvalue.real, -1.86, delta=0.05)
def test_batch_transpile_options_integrated(self):
"""
The goal is to verify that not only `_trasnpiled_circuits` works well
(`test_batch_transpiled_circuits` takes care of it) but that it's correctly called within
the entire flow of `BaseExperiment.run`.
"""
backend = Aer.get_backend("aer_simulator")
noise_model = noise.NoiseModel()
noise_model.add_all_qubit_quantum_error(
noise.depolarizing_error(0.5, 2), ["cx", "swap"])
expdata = self.batch2.run(backend, noise_model=noise_model, shots=1000)
expdata.block_for_results()
self.assertEqual(expdata.child_data(0).analysis_results(0).value, 8)
self.assertEqual(
expdata.child_data(1).child_data(0).analysis_results(0).value, 16)
self.assertEqual(
expdata.child_data(1).child_data(1).analysis_results(0).value, 4)
class NoisySimulationTest(unittest.TestCase):
"""Base class that contains methods and attributes
for doing tests of readout error noise with flexible
readout errors.
"""
sim = QasmSimulator()
# Example max qubit number
num_qubits = 4
# Create readout errors
readout_errors = []
for i in range(num_qubits):
p_error1 = (i + 1) * 0.002
p_error0 = 2 * p_error1
ro_error = noise.ReadoutError([[1 - p_error0, p_error0], [p_error1, 1 - p_error1]])
readout_errors.append(ro_error)
# TODO: Needs 2q errors?
# Readout Error only
noise_model = noise.NoiseModel()
for i in range(num_qubits):
noise_model.add_readout_error(readout_errors[i], [i])
seed_simulator = 100
shots = 10000
tolerance = 0.05
def execute_circs(self, qc_list: List[QuantumCircuit],
noise_model=None) -> Result:
"""Run circuits with the readout noise defined in this class
"""
backend = self.sim
qobj = assemble(transpile(qc_list, backend=backend),
backend=backend, shots=self.shots,
seed_simulator=self.seed_simulator,
noise_model=None if noise_model is None else self.noise_model,
method='density_matrix')
return backend.run(qobj).result()
def run_simulation(self, shots=8192, error_prob=0, target_state='000'):
# add noise
error_1 = noise.depolarizing_error(error_prob, 1)
noise_model = noise.NoiseModel()
noise_model.add_all_qubit_quantum_error(error_1, ['x', 'z'])
# run simulation
self.qc.measure([0, 1, 2], [4, 3, 2])
emulator = Aer.get_backend('qasm_simulator')
job = execute(self.qc, emulator, noise_model=noise_model, shots=shots)
hist = job.result().get_counts()
# print(hist)
# print statistics
successes = 0
first_three = [n[0:3] for n in list(hist.keys())]
for i in range(len(first_three)):
if (first_three[i] == target_state):
successes += hist.get(list(hist.keys())[i])
# print("success rate:", successes/shots)
return successes / shots
def test_noise_model_io_using_core_functions(self):
# Given
noise_model = AerNoise.NoiseModel()
quantum_error = AerNoise.depolarizing_error(0.0, 1)
coherent_error = np.asarray([
np.asarray(
[0.87758256 - 0.47942554j, 0.0 + 0.0j, 0.0 + 0.0j,
0.0 + 0.0j]),
np.asarray(
[0.0 + 0.0j, 0.87758256 + 0.47942554j, 0.0 + 0.0j,
0.0 + 0.0j]),
np.asarray(
[0.0 + 0.0j, 0.0 + 0.0j, 0.87758256 + 0.47942554j,
0.0 + 0.0j]),
np.asarray(
[0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j,
0.87758256 - 0.47942554j]),
])
noise_model.add_quantum_error(
AerNoise.coherent_unitary_error(coherent_error), ["cx"], [0, 1])
noise_model_data = noise_model.to_dict(serializable=True)
module_name = "qeqiskit.utils"
function_name = "load_qiskit_noise_model"
filename = "noise_model.json"
# When
save_noise_model(noise_model_data, module_name, function_name,
filename)
new_noise_model = load_noise_model(filename)
# Then
self.assertEqual(
noise_model.to_dict(serializable=True),
new_noise_model.to_dict(serializable=True),
)
# Cleanup
subprocess.run(["rm", "noise_model.json"])
def randbin3(data, F, theta_sphere, phi_sphere=0): # simulator --- WORKS
prob_1 = 0.3
error_1 = noise.depolarizing_error(prob_1, 1)
noise_model = noise.NoiseModel()
noise_model.add_all_qubit_quantum_error(error_1, ['u3'])
basis_gates = noise_model.basis_gates
phi = data.const * F * data.t * data.F_degree
q = QuantumRegister(1)
c = ClassicalRegister(1)
# Create a Quantum Circuit acting on the q register
circuit = QuantumCircuit(q, c)
rotate_angle = math.pi - 2*phi
circuit.u3(theta_sphere, phi_sphere, 0, q)
circuit.rz(2*phi, q)
circuit.h(q)
# Map the quantum measurement to the classical bits
circuit.measure(q, c)
# Execute the circuit on the qasm simulator
job = execute(circuit, Aer.get_backend('qasm_simulator'),
basis_gates=basis_gates,
noise_model=noise_model, shots=1)
#job_monitor(job)
# Grab results from the job
result = job.result()
# Returns counts
counts = result.get_counts(circuit)
return int(list(counts.keys())[0])