def test_probabilities_qargs(self, qargs):
"""Test probabilities method with qargs"""
# Get initial state
nq = 4
nc = len(qargs)
state_circ = QuantumCircuit(nq, nc)
for i in range(nq):
state_circ.ry((i + 1) * np.pi / (nq + 1), i)
# Get probabilities
state = Statevector(state_circ)
probs = state.probabilities(qargs)
# Estimate target probs from simulator measurement
sim = QasmSimulatorPy()
shots = 5000
seed = 100
circ = transpile(state_circ, sim)
circ.measure(qargs, range(nc))
result = sim.run(circ, shots=shots, seed_simulator=seed).result()
target = np.zeros(2**nc, dtype=float)
for i, p in result.get_counts(0).int_outcomes().items():
target[i] = p / shots
# Compare
delta = np.linalg.norm(probs - target)
self.assertLess(delta, 0.05)
def test_runtime(self, subroutine):
"""Test vqe and qaoa runtime"""
optimizer = {"name": "SPSA", "maxiter": 100}
backend = QasmSimulatorPy()
if subroutine == "vqe":
ry_ansatz = TwoLocal(5, "ry", "cz", reps=3, entanglement="full")
initial_point = np.random.default_rng(42).random(
ry_ansatz.num_parameters)
solver = VQEProgram(
ansatz=ry_ansatz,
optimizer=optimizer,
initial_point=initial_point,
backend=backend,
provider=FakeVQERuntimeProvider(),
)
else:
reps = 2
initial_point = np.random.default_rng(42).random(2 * reps)
solver = QAOAProgram(
optimizer=optimizer,
reps=reps,
initial_point=initial_point,
backend=backend,
provider=FakeQAOARuntimeProvider(),
)
opt = MinimumEigenOptimizer(solver)
result = opt.solve(self.op_ordering)
self.assertIsInstance(result, MinimumEigenOptimizationResult)
def get_standard_program(self, use_deprecated=False):
"""Get a standard VQEClient and operator to find the ground state of."""
circuit = RealAmplitudes(3)
operator = Z ^ I ^ Z
initial_point = np.random.random(circuit.num_parameters)
backend = QasmSimulatorPy()
if use_deprecated:
vqe_cls = VQEProgram
provider = FakeRuntimeProvider(use_deprecated=True)
warnings.filterwarnings("ignore", category=DeprecationWarning)
else:
provider = FakeRuntimeProvider(use_deprecated=False)
vqe_cls = VQEClient
vqe = vqe_cls(
ansatz=circuit,
optimizer=SPSA(),
initial_point=initial_point,
backend=backend,
provider=provider,
)
if use_deprecated:
warnings.filterwarnings("always", category=DeprecationWarning)
return vqe, operator
def test_standard_case(self, optimizer):
"""Test a standard use case."""
circuit = RealAmplitudes(3)
operator = Z ^ I ^ Z
initial_point = np.random.RandomState(42).random(
circuit.num_parameters)
backend = QasmSimulatorPy()
for use_deprecated in [False, True]:
if use_deprecated:
vqe_cls = VQEProgram
result_cls = VQEProgramResult
warnings.filterwarnings("ignore", category=DeprecationWarning)
else:
vqe_cls = VQEClient
result_cls = VQERuntimeResult
vqe = vqe_cls(
ansatz=circuit,
optimizer=optimizer,
initial_point=initial_point,
backend=backend,
provider=self.provider,
)
if use_deprecated:
warnings.filterwarnings("always", category=DeprecationWarning)
result = vqe.compute_minimum_eigenvalue(operator)
self.assertIsInstance(result, result_cls)
def test_standard_case(self, optimizer):
"""Test a standard use case."""
operator = Z ^ I ^ Z
reps = 2
initial_point = np.random.RandomState(42).random(2 * reps)
backend = QasmSimulatorPy()
for use_deprecated in [False, True]:
if use_deprecated:
qaoa_cls = QAOAProgram
result_cls = VQEProgramResult
warnings.filterwarnings("ignore", category=DeprecationWarning)
else:
qaoa_cls = QAOAClient
result_cls = VQERuntimeResult
qaoa = qaoa_cls(
optimizer=optimizer,
reps=reps,
initial_point=initial_point,
backend=backend,
provider=self.provider,
)
if use_deprecated:
warnings.filterwarnings("always", category=DeprecationWarning)
result = qaoa.compute_minimum_eigenvalue(operator)
self.assertIsInstance(result, result_cls)
def setup(self, rb_pattern):
length_vector = np.arange(1, 200, 4)
nseeds = 1
self.seed = 10
self.circuits = build_rb_circuit(nseeds=nseeds,
length_vector=length_vector,
rb_pattern=rb_pattern,
seed=self.seed)
self.sim_backend = QasmSimulatorPy()
def setup(self, width, depth):
random_seed = np.random.seed(10)
if NO_KAK:
self.circuit = build_qv_model_circuit(
width=width, depth=depth, seed=random_seed)
else:
self.circuit = build_model_circuit_kak(width, depth, random_seed)
self.sim_backend = QasmSimulatorPy()
def simulate_experiment_data(self, thetas, shots=1024):
"""Generate experiment data for Ry rotations"""
circuits = []
for theta in thetas:
qc = QuantumCircuit(1)
qc.ry(theta, 0)
qc.measure_all()
circuits.append(qc)
sim = QasmSimulatorPy()
circuits = transpile(circuits, sim)
job = sim.run(circuits, shots=shots, seed_simulator=10)
result = job.result()
data = [
{"counts": result.get_counts(i), "metadata": {"xval": theta}}
for i, theta in enumerate(thetas)
]
return data
def simulate_experiment_data(self, thetas, amplitudes, shots=1024):
"""Generate experiment data for Rx rotations with an arbitrary amplitude calibration."""
circuits = []
for theta in thetas:
qc = QuantumCircuit(1)
qc.rx(theta, 0)
qc.measure_all()
circuits.append(qc)
sim = QasmSimulatorPy()
circuits = transpile(circuits, sim)
job = sim.run(circuits, shots=shots, seed_simulator=10)
result = job.result()
data = [{
"counts": self._add_uncertainty(result.get_counts(i)),
"metadata": {
"xval": amplitudes[i],
"meas_level": MeasLevel.CLASSIFIED,
"meas_return": "avg",
},
} for i, theta in enumerate(thetas)]
return data
def setUp(self):
super().setUp()
self._trainer_provider = FakeTorchTrainerRuntimeProvider()
self._infer_provider = FakeTorchInferRuntimeProvider()
self._backend = QasmSimulatorPy()
# construct a simple qnn for unit tests
param_x = Parameter("x")
feature_map = QuantumCircuit(1, name="fm")
feature_map.ry(param_x, 0)
param_y = Parameter("y")
ansatz = QuantumCircuit(1, name="vf")
ansatz.ry(param_y, 0)
self._qnn = TwoLayerQNN(1, feature_map, ansatz)
def test_standard_case(self, optimizer):
"""Test a standard use case."""
operator = Z ^ I ^ Z
reps = 2
initial_point = np.random.RandomState(42).random(2 * reps)
backend = QasmSimulatorPy()
qaoa = QAOAProgram(
optimizer=optimizer,
reps=reps,
initial_point=initial_point,
backend=backend,
provider=self.provider,
)
result = qaoa.compute_minimum_eigenvalue(operator)
self.assertIsInstance(result, VQEProgramResult)
def test_standard_case(self):
"""Test a standard use case."""
circuit = RealAmplitudes(3)
operator = Z ^ I ^ Z
initial_point = np.random.random(circuit.num_parameters)
optimizer = {"name": "SPSA", "maxiter": 100}
backend = QasmSimulatorPy()
vqe = VQEProgram(
ansatz=circuit,
optimizer=optimizer,
initial_point=initial_point,
backend=backend,
provider=self.provider,
)
result = vqe.compute_minimum_eigenvalue(operator)
self.assertIsInstance(result, VQEResult)
def setup(self, size, _):
edge_len = int((2 * size + 2)**0.5) + 1
self.coupling_map = CouplingMap.from_grid(edge_len, edge_len)
self.sim_backend = QasmSimulatorPy()
self.circuit = build_ripple_adder_circuit(size)