def test_reduce_noise_model(self):
"""Test reduction mapping of noise model."""
error1 = depolarizing_error(0.5, 1)
error2 = depolarizing_error(0.5, 2)
roerror1 = [[0.9, 0.1], [0.5, 0.5]]
roerror2 = [[0.8, 0.2, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0],
[0, 0, 0.1, 0.9]]
model = NoiseModel()
model.add_all_qubit_quantum_error(error1, ['u3'], False)
model.add_quantum_error(error1, ['u3'], [1], False)
with self.assertWarns(DeprecationWarning):
model.add_nonlocal_quantum_error(error2, ['cx'], [2, 0], [3, 1],
False)
model.add_all_qubit_readout_error(roerror1, False)
model.add_readout_error(roerror2, [0, 2], False)
remapped_model = remap_noise_model(model, [0, 1, 2],
discard_qubits=True,
warnings=False)
target = NoiseModel()
target.add_all_qubit_quantum_error(error1, ['u3'], False)
target.add_quantum_error(error1, ['u3'], [1], False)
target.add_all_qubit_readout_error(roerror1, False)
target.add_readout_error(roerror2, [0, 2], False)
self.assertEqual(remapped_model, target)
def test_w_noise(self):
""" with noise test """
# build noise model
# Asymmetric readout error on qubit-0 only
try:
# pylint: disable=import-outside-toplevel
from qiskit.providers.aer.noise import NoiseModel
from qiskit import Aer
self.backend = Aer.get_backend('qasm_simulator')
except Exception as ex: # pylint: disable=broad-except
self.skipTest(
"Aer doesn't appear to be installed. Error: '{}'".format(
str(ex)))
return
probs_given0 = [0.9, 0.1]
probs_given1 = [0.3, 0.7]
noise_model = NoiseModel()
noise_model.add_readout_error([probs_given0, probs_given1], [0])
quantum_instance = QuantumInstance(self.backend,
seed_transpiler=self.random_seed,
seed_simulator=self.random_seed,
shots=1024,
noise_model=noise_model)
res_w_noise = quantum_instance.execute(self.qc).get_counts(self.qc)
quantum_instance.skip_qobj_validation = True
res_w_noise_skip_validation = quantum_instance.execute(
self.qc).get_counts(self.qc)
self.assertTrue(_compare_dict(res_w_noise,
res_w_noise_skip_validation))
def test_w_noise(self):
# build noise model
# Asymetric readout error on qubit-0 only
try:
from qiskit.providers.aer.noise import NoiseModel
except Exception as e:
self.skipTest(
"Aer doesn't appear to be installed. Error: '{}'".format(
str(e)))
return
probs_given0 = [0.9, 0.1]
probs_given1 = [0.3, 0.7]
noise_model = NoiseModel()
noise_model.add_readout_error([probs_given0, probs_given1], [0])
quantum_instance = QuantumInstance(self.backend,
seed_transpiler=self.random_seed,
seed_simulator=self.random_seed,
shots=1024,
noise_model=noise_model,
circuit_caching=False)
res_w_noise = quantum_instance.execute(self.qc).get_counts(self.qc)
quantum_instance.skip_qobj_validation = True
res_w_noise_skip_validation = quantum_instance.execute(
self.qc).get_counts(self.qc)
self.assertTrue(_compare_dict(res_w_noise,
res_w_noise_skip_validation))
def test_noise_model_basis_gates(self):
"""Test noise model basis_gates"""
basis_gates = ['u1', 'u2', 'u3', 'cx']
model = NoiseModel(basis_gates)
target = sorted(basis_gates)
self.assertEqual(model.basis_gates, target)
# Check adding readout errors doesn't add to basis gates
model = NoiseModel(basis_gates)
target = sorted(basis_gates)
model.add_all_qubit_readout_error([[0.9, 0.1], [0, 1]], False)
self.assertEqual(model.basis_gates, target)
model.add_readout_error([[0.9, 0.1], [0, 1]], [2], False)
self.assertEqual(model.basis_gates, target)
# Check a reset instruction error isn't added to basis gates
model = NoiseModel(basis_gates)
target = sorted(basis_gates)
model.add_all_qubit_quantum_error(reset_error(0.2), ['reset'], False)
self.assertEqual(model.basis_gates, target)
# Check a non-standard gate isn't added to basis gates
model = NoiseModel(basis_gates)
target = sorted(basis_gates)
model.add_all_qubit_quantum_error(reset_error(0.2), ['label'], False)
self.assertEqual(model.basis_gates, target)
# Check a standard gate is added to basis gates
model = NoiseModel(basis_gates)
target = sorted(basis_gates + ['h'])
model.add_all_qubit_quantum_error(reset_error(0.2), ['h'], False)
self.assertEqual(model.basis_gates, target)
def test_readout_error_qubit1(self):
"""Test readout error on qubit 1 for bell state"""
# Test circuit: ideal bell state
qr = QuantumRegister(2, 'qr')
cr = ClassicalRegister(2, 'cr')
circuit = QuantumCircuit(qr, cr)
circuit.h(qr[0])
circuit.cx(qr[0], qr[1])
# Ensure qubit 0 is measured before qubit 1
circuit.barrier(qr)
circuit.measure(qr[0], cr[0])
circuit.barrier(qr)
circuit.measure(qr[1], cr[1])
backend = QasmSimulator()
# Asymetric readout error on qubit-0 only
probs_given0 = [0.9, 0.1]
probs_given1 = [0.3, 0.7]
noise_model = NoiseModel()
noise_model.add_readout_error([probs_given0, probs_given1], [1])
shots = 2000
target = {'0x0': probs_given0[0] * shots / 2,
'0x1': probs_given1[0] * shots / 2,
'0x2': probs_given0[1] * shots / 2,
'0x3': probs_given1[1] * shots / 2}
qobj = compile([circuit], backend, shots=shots,
basis_gates=noise_model.basis_gates)
result = backend.run(qobj, noise_model=noise_model).result()
self.is_completed(result)
self.compare_counts(result, [circuit], [target], delta=0.05 * shots)
def test_readout_error_correlated_2qubit(self):
"""Test a correlated two-qubit readout error"""
# Test circuit: prepare all plus state
qr = QuantumRegister(2, 'qr')
cr = ClassicalRegister(2, 'cr')
circuit = QuantumCircuit(qr, cr)
circuit.h(qr)
circuit.barrier(qr)
# We will manually add a correlated measure operation to
# the compiled qobj
backend = QasmSimulator()
# Correlated 2-qubit readout error
probs_given00 = [0.3, 0, 0, 0.7]
probs_given01 = [0, 0.6, 0.4, 0]
probs_given10 = [0, 0, 1, 0]
probs_given11 = [0.1, 0, 0, 0.9]
probs_noise = [
probs_given00, probs_given01, probs_given10, probs_given11
]
noise_model = NoiseModel()
noise_model.add_readout_error(probs_noise, [0, 1])
# Expected counts
shots = 2000
probs_ideal = [0.25, 0.25, 0.25, 0.25]
p00 = sum([
ideal * noise[0] for ideal, noise in zip(probs_ideal, probs_noise)
])
p01 = sum([
ideal * noise[1] for ideal, noise in zip(probs_ideal, probs_noise)
])
p10 = sum([
ideal * noise[2] for ideal, noise in zip(probs_ideal, probs_noise)
])
p11 = sum([
ideal * noise[3] for ideal, noise in zip(probs_ideal, probs_noise)
])
target = {
'0x0': p00 * shots,
'0x1': p01 * shots,
'0x2': p10 * shots,
'0x3': p11 * shots
}
qobj = compile([circuit],
backend,
shots=shots,
basis_gates=noise_model.basis_gates)
# Add measure to qobj
item = measure_instr([0, 1], [0, 1])
append_instr(qobj, 0, item)
# Execute
result = backend.run(qobj, noise_model=noise_model).result()
self.is_completed(result)
self.compare_counts(result, [circuit], [target], delta=0.05 * shots)
def make_noise_model(dep_err_rate, ro_err_rate, qubits):
# Define a noise model that applies uniformly to the given qubits
model = NoiseModel()
dep_err = depolarizing_error(dep_err_rate, 2)
ro_err = ReadoutError(
[[1 - ro_err_rate, ro_err_rate], [ro_err_rate, 1 - ro_err_rate]]
)
# Add depolarising error to CX gates between any qubits (implying full connectivity)
for i, j in product(qubits, repeat=2):
model.add_quantum_error(dep_err, ["cx"], [i, j])
# Add readout error for each qubit
for i in qubits:
model.add_readout_error(ro_err, qubits=[i])
return model
def test_w_noise(self):
"""with noise test"""
# build noise model
# Asymmetric readout error on qubit-0 only
try:
from qiskit.providers.aer.noise import NoiseModel
from qiskit import Aer
self.backend = Aer.get_backend("qasm_simulator")
except ImportError as ex:
self.skipTest(
"Aer doesn't appear to be installed. Error: '{}'".format(
str(ex)))
return
probs_given0 = [0.9, 0.1]
probs_given1 = [0.3, 0.7]
noise_model = NoiseModel()
noise_model.add_readout_error([probs_given0, probs_given1], [0])
quantum_instance = QuantumInstance(
self.backend,
seed_transpiler=self.random_seed,
seed_simulator=self.random_seed,
shots=1024,
noise_model=noise_model,
)
res_w_noise = quantum_instance.execute(self.qc).get_counts(self.qc)
quantum_instance.skip_qobj_validation = True
res_w_noise_skip_validation = quantum_instance.execute(
self.qc).get_counts(self.qc)
self.assertTrue(_compare_dict(res_w_noise,
res_w_noise_skip_validation))
# BasicAer should fail:
with self.assertRaises(QiskitError):
_ = QuantumInstance(BasicAer.get_backend("qasm_simulator"),
noise_model=noise_model)
with self.assertRaises(QiskitError):
quantum_instance = QuantumInstance(
BasicAer.get_backend("qasm_simulator"))
quantum_instance.set_config(noise_model=noise_model)
def test_w_noise(self):
# build noise model
# Asymetric readout error on qubit-0 only
probs_given0 = [0.9, 0.1]
probs_given1 = [0.3, 0.7]
noise_model = NoiseModel()
noise_model.add_readout_error([probs_given0, probs_given1], [0])
quantum_instance = QuantumInstance(self.backend,
seed_mapper=self.random_seed,
run_config=self.run_config,
noise_model=noise_model)
res_w_noise = quantum_instance.execute(self.qc).get_counts(self.qc)
quantum_instance.skip_qobj_validation = True
res_w_noise_skip_validation = quantum_instance.execute(
self.qc).get_counts(self.qc)
self.assertTrue(_compare_dict(res_w_noise,
res_w_noise_skip_validation))
def test_noise_models_equal(self):
"""Test two noise models are Equal"""
roerror = [[0.9, 0.1], [0.5, 0.5]]
error1 = pauli_error([['X', 1]], standard_gates=False)
error2 = pauli_error([['X', 1]], standard_gates=True)
model1 = NoiseModel()
model1.add_all_qubit_quantum_error(error1, ['u3'], False)
model1.add_quantum_error(error1, ['u3'], [2], False)
model1.add_nonlocal_quantum_error(error1, ['cx'], [0, 1], [3], False)
model1.add_all_qubit_readout_error(roerror, False)
model1.add_readout_error(roerror, [0], False)
model2 = NoiseModel()
model2.add_all_qubit_quantum_error(error2, ['u3'], False)
model2.add_quantum_error(error2, ['u3'], [2], False)
model2.add_nonlocal_quantum_error(error2, ['cx'], [0, 1], [3], False)
model2.add_all_qubit_readout_error(roerror, False)
model2.add_readout_error(roerror, [0], False)
self.assertEqual(model1, model2)
def test_remap_readout_errors(self):
"""Test remapping of readout errors."""
model = NoiseModel()
error1 = [[0.9, 0.1], [0.5, 0.5]]
error2 = [[0.8, 0.2, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0.1, 0.9]]
model.add_readout_error(error1, [1], False)
model.add_readout_error(error2, [0, 2], False)
remapped_model = remap_noise_model(model, [[0, 1], [1, 2], [2, 0]], warnings=False)
target = NoiseModel()
target.add_readout_error(error1, [2], False)
target.add_readout_error(error2, [1, 0], False)
self.assertEqual(remapped_model, target)
def readout_error_noise_models():
"""Readout error test circuit noise models."""
noise_models = []
# 1-qubit readout error on qubit 0
noise_model = NoiseModel()
noise_model.add_readout_error(ROERROR_1Q, [0])
noise_models.append(noise_model)
# 1-qubit readout error on qubit 1
noise_model = NoiseModel()
noise_model.add_readout_error(ROERROR_1Q, [1])
noise_models.append(noise_model)
# 1-qubit readout error on qubit 1
noise_model = NoiseModel()
noise_model.add_all_qubit_readout_error(ROERROR_1Q)
noise_models.append(noise_model)
# 2-qubit readout error on qubits 0,1
noise_model = NoiseModel()
noise_model.add_readout_error(ROERROR_2Q, [0, 1])
noise_models.append(noise_model)
return noise_models
def test_noise_model_noise_qubits(self):
"""Test noise instructions"""
model = NoiseModel()
target = []
self.assertEqual(model.noise_qubits, target)
# Check adding a default error isn't added to noise qubits
model = NoiseModel()
model.add_all_qubit_quantum_error(pauli_error([['XX', 1]]), ['label'],
False)
target = []
self.assertEqual(model.noise_qubits, target)
# Check adding a local error adds to noise qubits
model = NoiseModel()
model.add_quantum_error(pauli_error([['XX', 1]]), ['label'], [1, 0],
False)
target = sorted([0, 1])
self.assertEqual(model.noise_qubits, target)
# Check adding a non-local error adds to noise qubits
model = NoiseModel()
with self.assertWarns(DeprecationWarning):
model.add_nonlocal_quantum_error(pauli_error([['XX', 1]]),
['label'], [0], [1, 2], False)
target = sorted([0, 1, 2])
self.assertEqual(model.noise_qubits, target)
# Check adding a default error isn't added to noise qubits
model = NoiseModel()
model.add_all_qubit_readout_error([[0.9, 0.1], [0, 1]], False)
target = []
self.assertEqual(model.noise_qubits, target)
# Check adding a local error adds to noise qubits
model = NoiseModel()
model.add_readout_error([[0.9, 0.1], [0, 1]], [2], False)
target = [2]
self.assertEqual(model.noise_qubits, target)
def test_noise_models_equal(self):
"""Test two noise models are Equal"""
roerror = [[0.9, 0.1], [0.5, 0.5]]
error1 = kraus_error([np.diag([1, 0]), np.diag([0, 1])])
error2 = pauli_error([("I", 0.5), ("Z", 0.5)])
model1 = NoiseModel()
model1.add_all_qubit_quantum_error(error1, ['u3'], False)
model1.add_quantum_error(error1, ['u3'], [2], False)
with self.assertWarns(DeprecationWarning):
model1.add_nonlocal_quantum_error(error1, ['cx'], [0, 1], [3], False)
model1.add_all_qubit_readout_error(roerror, False)
model1.add_readout_error(roerror, [0], False)
model2 = NoiseModel()
model2.add_all_qubit_quantum_error(error2, ['u3'], False)
model2.add_quantum_error(error2, ['u3'], [2], False)
with self.assertWarns(DeprecationWarning):
model2.add_nonlocal_quantum_error(error2, ['cx'], [0, 1], [3], False)
model2.add_all_qubit_readout_error(roerror, False)
model2.add_readout_error(roerror, [0], False)
self.assertEqual(model1, model2)
def generateNoiseModel(machine,
coherent=True,
incoherent=False,
readout=False,
custom_t=False,
t1=None,
t2=None,
reverse=False):
"""
Returns a realistic copy of london noise model with custom t1, t2 times
"""
#initializing noise model
noise_thermal = NoiseModel()
amp = 1
#for every qubit (5 qubit london machine)
for q in range(5):
#types of erroneous gates
gates = ['u3', 'u2', 'u1', 'id']
for gate in gates:
dep_error = None
if (coherent):
dep_error = generateDepolarizingError(machine, gate, [q])
rel_error = None
if (incoherent):
generateRelaxationError(machine,
gate, [q],
t1,
t2,
amp=amp,
custom_t=custom_t)
if (dep_error == None and rel_error != None):
error_obj = rel_error
noise_thermal.add_quantum_error(error_obj, gate, [q])
elif (dep_error != None and rel_error == None):
error_obj = dep_error
noise_thermal.add_quantum_error(error_obj, gate, [q])
elif (dep_error != None and rel_error != None):
error_obj = dep_error.compose(rel_error)
noise_thermal.add_quantum_error(error_obj, gate, [q])
#2 qubit gate errors
qubits = [i for i in range(5)]
qubits.remove(q)
for j in qubits:
dep_error = None
if (coherent):
dep_error = generateDepolarizingError(machine, 'cx', [q, j])
rel_error = None
if (incoherent):
rel_error = generateRelaxationError(machine,
'cx', [q, j],
t1,
t2,
amp=amp,
custom_t=custom_t)
if (dep_error == None and rel_error != None):
error_obj = rel_error
noise_thermal.add_quantum_error(error_obj, 'cx', [q, j])
elif (dep_error != None and rel_error == None):
error_obj = dep_error
noise_thermal.add_quantum_error(error_obj, 'cx', [q, j])
elif (dep_error != None and rel_error != None):
error_obj = dep_error.compose(rel_error)
noise_thermal.add_quantum_error(error_obj, 'cx', [q, j])
if (readout):
#adding the readout error
p1_0 = machine.properties().qubit_property(q,
'prob_meas1_prep0')[0]
p0_1 = machine.properties().qubit_property(q,
'prob_meas0_prep1')[0]
print('Original: ' + str(p1_0) + ' ' + str(p0_1))
if (reverse):
temp = p1_0
p1_0 = p0_1
p0_1 = temp
print('Reverse: ' + str(p1_0) + ' ' + str(p0_1))
matrix = [[1 - p1_0, p1_0], [p0_1, 1 - p0_1]]
error = ReadoutError(matrix)
noise_thermal.add_readout_error(error, [q])
return noise_thermal
import numpy as np
from qiskit.providers.aer.noise import NoiseModel
from qiskit.providers.aer import noise
from qiskit.providers.aer.noise.errors import ReadoutError
from qiskit import IBMQ
# Global params
NB_SHOTS = 128
# ===================
# Noise models
# ===================
#noise in the readout (3q, p0g1 = p1g0 for the same qubit, but different over qubits)
ro_errors_proba = [[0.1, 0.1],[0.05,0.05],[0.15, 0.15]]
noise_ro = NoiseModel()
for n, ro in enumerate(ro_errors_proba):
noise_ro.add_readout_error(ReadoutError([[1 - ro[0], ro[0]], [ro[1], 1 - ro[1]]]), [n])
ro_errors_proba_sym = [[0.1, 0.1],[0.1,0.1],[0.1, 0.1]]
noise_rosym = NoiseModel()
for n, ro in enumerate(ro_errors_proba_sym):
noise_rosym.add_readout_error(ReadoutError([[1 - ro[0], ro[0]], [ro[1], 1 - ro[1]]]), [n])
provider = IBMQ.load_account()
device = provider.get_backend('ibmq_essex')
properties = device.properties()
noise_essex = noise.device.basic_device_noise_model(properties)
# ===================
# utility functions
def _get_noise_model_from_backend_v2(
self,
gate_error=True,
readout_error=True,
thermal_relaxation=True,
temperature=0,
gate_lengths=None,
gate_length_units="ns",
standard_gates=None,
):
"""Build noise model from BackendV2.
This is a temporary fix until qiskit-aer supports building noise model
from a BackendV2 object.
"""
from qiskit.circuit import Delay
from qiskit.providers.exceptions import BackendPropertyError
from qiskit.providers.aer.noise import NoiseModel
from qiskit.providers.aer.noise.device.models import (
_excited_population,
basic_device_gate_errors,
basic_device_readout_errors,
)
from qiskit.providers.aer.noise.passes import RelaxationNoisePass
if self._props_dict is None:
self._set_props_dict_from_json()
properties = BackendProperties.from_dict(self._props_dict)
basis_gates = self.operation_names
num_qubits = self.num_qubits
dt = self.dt
noise_model = NoiseModel(basis_gates=basis_gates)
# Add single-qubit readout errors
if readout_error:
for qubits, error in basic_device_readout_errors(properties):
noise_model.add_readout_error(error, qubits)
# Add gate errors
with warnings.catch_warnings():
warnings.filterwarnings(
"ignore",
module="qiskit.providers.aer.noise.device.models",
)
gate_errors = basic_device_gate_errors(
properties,
gate_error=gate_error,
thermal_relaxation=thermal_relaxation,
gate_lengths=gate_lengths,
gate_length_units=gate_length_units,
temperature=temperature,
standard_gates=standard_gates,
)
for name, qubits, error in gate_errors:
noise_model.add_quantum_error(error, name, qubits)
if thermal_relaxation:
# Add delay errors via RelaxationNiose pass
try:
excited_state_populations = [
_excited_population(freq=properties.frequency(q),
temperature=temperature)
for q in range(num_qubits)
]
except BackendPropertyError:
excited_state_populations = None
try:
delay_pass = RelaxationNoisePass(
t1s=[properties.t1(q) for q in range(num_qubits)],
t2s=[properties.t2(q) for q in range(num_qubits)],
dt=dt,
op_types=Delay,
excited_state_populations=excited_state_populations,
)
noise_model._custom_noise_passes.append(delay_pass)
except BackendPropertyError:
# Device does not have the required T1 or T2 information
# in its properties
pass
return noise_model
