def test_kraus_circuit_noise(self, method, device):
"""Test simulation with Kraus quantum errors in circuit."""
backend = self.backend(method=method, device=device)
shots = 1000
error0 = noise.amplitude_damping_error(0.05)
error1 = noise.amplitude_damping_error(0.15)
error01 = error1.tensor(error0)
# Target Circuit 0
tc0 = QuantumCircuit(2)
tc0.h(0)
tc0.append(qi.Kraus(error0), [0])
tc0.cx(0, 1)
tc0.append(qi.Kraus(error01), [0, 1])
target_probs0 = qi.DensityMatrix(tc0).probabilities_dict()
# Sim circuit 0
qc0 = QuantumCircuit(2)
qc0.h(0)
qc0.append(error0, [0])
qc0.cx(0, 1)
qc0.append(error01, [0, 1])
qc0.measure_all()
# Target Circuit 1
tc1 = QuantumCircuit(2)
tc1.h(1)
tc1.append(qi.Kraus(error0), [1])
tc1.cx(1, 0)
tc1.append(qi.Kraus(error01), [1, 0])
target_probs1 = qi.DensityMatrix(tc1).probabilities_dict()
# Sim circuit 1
qc1 = QuantumCircuit(2)
qc1.h(1)
qc1.append(error0, [1])
qc1.cx(1, 0)
qc1.append(error01, [1, 0])
qc1.measure_all()
result = backend.run([qc0, qc1], shots=shots).result()
self.assertSuccess(result)
probs = [{
key: val / shots
for key, val in result.get_counts(i).items()
} for i in range(2)]
self.assertDictAlmostEqual(target_probs0, probs[0], delta=0.1)
self.assertDictAlmostEqual(target_probs1, probs[1], delta=0.1)
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 create_amplitude_damping_noise(T_1: float,
t_step: float = 10e-9) -> NoiseModel:
"""Creates an amplitude damping noise model
Args:
T_1: Relaxation time (seconds)
t_step: Discretized time step over which the relaxation occurs over (seconds)
"""
gamma = 1 - pow(np.e, -1 / T_1 * t_step)
error = amplitude_damping_error(gamma)
gate_error = error.tensor(error)
noise_model = NoiseModel()
noise_model.add_all_qubit_quantum_error(error, ["id", "u3"])
noise_model.add_all_qubit_quantum_error(gate_error, ["cx"])
return noise_model
def create_amplitude_damping_noise(T_1, t_step=10e-9):
""" Creates an amplitude damping noise model
Args:
T_1 (float) : Relaxation time (seconds)
t_step (float) : Discretized time step over which the relaxation occurs over (seconds)
Returns:
qiskit.providers.aer.noise.NoiseModel
"""
gamma = (1 - pow(np.e, - 1/T_1*t_step))
error = amplitude_damping_error(gamma)
gate_error = error.tensor(error)
noise_model = NoiseModel()
noise_model.add_all_qubit_quantum_error(error, ['id', 'u3'])
noise_model.add_all_qubit_quantum_error(gate_error, ['cx'])
return noise_model
def __init__(self,
name = 'simulator_benchmark',
apps = {},
qubits = DEFAULT_QUBITS,
runtime_names = DEFAULT_RUNTIME,
measures = DEFAULT_MEASUREMENT_METHODS,
measure_counts = DEFAULT_MEASUREMENT_COUNTS,
noise_model_names = DEFAULT_NOISE_MODELS,
fusion_bits = DEFAULT_FUSION_BITS,
fusion = DEFAULT_FUSION,
save_qasm = False,
save_conf = False):
self.timeout = 60 * 1000
self.__name__ = name
self.apps = apps if isinstance(apps, list) else [app for app in apps]
self.app2rep = {} if isinstance(apps, list) else apps
self.qubits = qubits
self.runtime_names = runtime_names
self.measures = measures
self.measure_counts = measure_counts
self.noise_model_names = noise_model_names
self.fusion_bits = fusion_bits
self.fusion = fusion
self.save_qasm = save_qasm
self.save_conf = save_conf
self.params = (self.apps, self.measures, self.measure_counts, self.noise_model_names, self.qubits)
self.param_names = ["application", "measure_method", "measure_counts", "noise", "qubit"]
all_simulators = [ QASM_SIMULATOR ]
self.simulators = {}
self.backend_options_list = {}
self.backend_qubits = {}
self.noise_models = {}
self.noise_models[self.NOISE_IDEAL] = None
if self.NOISE_DAMPING in self.noise_model_names:
noise_model = NoiseModel()
error = amplitude_damping_error(1e-3)
noise_model.add_all_qubit_quantum_error(error, ['u3'])
self.noise_models[self.NOISE_DAMPING] = noise_model
if self.NOISE_DEPOLARIZING in self.noise_model_names:
noise_model = NoiseModel()
noise_model.add_all_qubit_quantum_error(depolarizing_error(1e-3, 1), ['u3'])
noise_model.add_all_qubit_quantum_error(depolarizing_error(1e-2, 2), ['cx'])
self.noise_models[self.NOISE_DEPOLARIZING] = noise_model
if self.RUNTIME_STATEVECTOR_CPU in runtime_names:
self.simulators[self.RUNTIME_STATEVECTOR_CPU] = QASM_SIMULATOR
self.backend_options_list[self.RUNTIME_STATEVECTOR_CPU] = { 'method': self.RUNTIME_STATEVECTOR_CPU,
'fusion_max_qubit': self.fusion_bits,
'fusion_threshold': 0,
'fusion_enable': self.fusion
}
self.backend_qubits[self.RUNTIME_STATEVECTOR_CPU] = self.qubits
if self.RUNTIME_STATEVECTOR_GPU in runtime_names:
self.simulators[self.RUNTIME_STATEVECTOR_GPU] = QASM_SIMULATOR
self.backend_options_list[self.RUNTIME_STATEVECTOR_GPU] = { 'method': self.RUNTIME_STATEVECTOR_GPU,
'fusion_max_qubit': self.fusion_bits,
'fusion_threshold': 0,
'fusion_enable': self.fusion,
'max_memory_mb': 307200
}
self.backend_qubits[self.RUNTIME_STATEVECTOR_GPU] = self.qubits
if self.RUNTIME_MPS_CPU in runtime_names:
self.simulators[self.RUNTIME_MPS_CPU] = QASM_SIMULATOR
self.backend_options_list[self.RUNTIME_MPS_CPU] = { 'method': self.RUNTIME_MPS_CPU }
self.backend_qubits[self.RUNTIME_MPS_CPU] = self.qubits
if self.RUNTIME_DENSITY_MATRIX_CPU in runtime_names:
self.simulators[self.RUNTIME_DENSITY_MATRIX_CPU] = QASM_SIMULATOR
self.backend_options_list[self.RUNTIME_DENSITY_MATRIX_CPU] = { 'method': self.RUNTIME_DENSITY_MATRIX_CPU }
self.backend_qubits[self.RUNTIME_DENSITY_MATRIX_CPU] = [qubit for qubit in qubits if qubit <= 15]
if self.RUNTIME_DENSITY_MATRIX_GPU in runtime_names:
self.simulators[self.RUNTIME_DENSITY_MATRIX_GPU] = QASM_SIMULATOR
self.backend_options_list[self.RUNTIME_DENSITY_MATRIX_GPU] = { 'method': self.RUNTIME_DENSITY_MATRIX_GPU }
self.backend_qubits[self.RUNTIME_DENSITY_MATRIX_GPU] = [qubit for qubit in qubits if qubit <= 15]
nwqsim = NWQSimProvider('NWQSim')
print(nwqsim.backends)
backend = nwqsim.backends['dmsim_cpu']
backend.set_n_cpus(4)
#Bell State
circuit = QuantumCircuit(2, 2)
circuit.h(0)
circuit.cx(0, 1)
circuit.measure([0, 1], [0, 1])
noise_model = NoiseModel()
#Add amplitude and phase damping error for 1-qubit
param_amplitude_damping = 0.05
param_phase_damping = 0.03
amplitude_error = amplitude_damping_error(param_amplitude_damping)
phase_error = phase_damping_error(param_phase_damping)
qerror_q1 = phase_error.compose(amplitude_error)
#Add depolarizing error for 2-qubit
param_q2 = 0.08
qerror_q2 = depolarizing_error(param_q2, 2)
q1_superop = SuperOp(qerror_q1)
q2_superop = SuperOp(qerror_q2)
backend.set_noise_1q_sop(q1_superop)
backend.set_noise_2q_sop(q2_superop)
result = execute(circuit, backend, seed_transpiler=111).result()
print(result.get_counts(circuit))
print(result.get_statevector())
def main():
# Noise
device_backend = FakeVigo()
coupling_map = device_backend.configuration().coupling_map
simulator = Aer.get_backend('qasm_simulator')
noise_model = NoiseModel()
basis_gates = noise_model.basis_gates
error = amplitude_damping_error(0.5)
# error = depolarizing_error(0.5, 1)
noise_model.add_all_qubit_quantum_error(error, ['id', 'u1', 'u2', 'u3'])
# Circuit
circ = QuantumCircuit(1, 1)
circ.h(0)
circ.measure([0], [0])
print("*" * 25 + " Circuit " + "*" * 25)
print(circ.draw())
model1 = {'name': 'noisy', 'model': noise_model}
model2 = {'name': 'ideal', 'model': None}
noise_models = [model1, model2]
print()
print("*" * 25 + " Noise Models " + "*" * 25)
pprint(noise_models)
# Execution
Dataset = [(run_circuit(circ, simulator, nm['model'], coupling_map,
basis_gates), nm) for nm in noise_models]
# Data Prep
for counts, nm in Dataset:
counts.setdefault('0', 0)
counts.setdefault('1', 0)
X = [[x[1] for x in sorted(counts.items())] for counts, nm in Dataset]
Y_raw = [nm['name'] for counts, nm in Dataset]
zeros = [x[0] for x in X]
le = preprocessing.LabelEncoder()
le.fit(Y_raw)
Y = le.transform(Y_raw)
print()
print("*" * 25 + " Dataset " + "*" * 25)
print("Features: ", X)
print("Labels: ", Y_raw)
print("Encoded Labels: ", Y)
# Training Classifier
clf = RandomForestClassifier(random_state=0)
clf.fit(X, Y)
print()
print("*" * 25 + " Predictions " + "*" * 25)
# Predict labels on original data
print("Prediction on training set: ",
list(le.inverse_transform(clf.predict(X))))
# Predict labels on new data
Xtest = []
Ytest = []
for i in range(max(0, min(zeros) - 50), min(max(zeros) + 51, 1001)):
feature = [[i, 1000 - i]]
prediction = list(le.inverse_transform(clf.predict(feature)))
# print("Prediction on {}: {}".format(feature, prediction))
Xtest.append(i)
Ytest.append(prediction[0])
# Plot Diagrams
fig = plt.figure()
plt.scatter(Xtest, Ytest, label="test set")
plt.scatter(zeros, Y_raw, label="training set")
plt.xlabel("Feature = Count of '0' measurements")
plt.ylabel("Predicted Label")
plt.legend()
# fig.axes.append(circ.draw(output='mpl').axes[0])
plt.show()
