def test_ibmq_grouped_pauli_expectation(self):
""" pauli expect op vector state vector test """
from qiskit import IBMQ
p = IBMQ.load_account()
backend = p.get_backend('ibmq_qasm_simulator')
q_instance = QuantumInstance(backend, seed_simulator=self.seed, seed_transpiler=self.seed)
paulis_op = ListOp([X, Y, Z, I])
states_op = ListOp([One, Zero, Plus, Minus])
valids = [[+0, 0, 1, -1],
[+0, 0, 0, 0],
[-1, 1, 0, -0],
[+1, 1, 1, 1]]
converted_meas = self.expect.convert(~StateFn(paulis_op) @ states_op)
sampled = CircuitSampler(q_instance).convert(converted_meas)
np.testing.assert_array_almost_equal(sampled.eval(), valids, decimal=1)
def test_uvcc_vscf(self):
""" uvcc vscf test """
co2_2modes_2modals_2body = [[[[[0, 0, 0]], 320.8467332810141],
[[[0, 1, 1]], 1760.878530705873],
[[[1, 0, 0]], 342.8218290247543],
[[[1, 1, 1]], 1032.396323618631]],
[[[[0, 0, 0], [1, 0, 0]], -57.34003649795117],
[[[0, 0, 1], [1, 0, 0]], -56.33205925807966],
[[[0, 1, 0], [1, 0, 0]], -56.33205925807966],
[[[0, 1, 1], [1, 0, 0]], -60.13032761856809],
[[[0, 0, 0], [1, 0, 1]], -65.09576309934431],
[[[0, 0, 1], [1, 0, 1]], -62.2363839133389],
[[[0, 1, 0], [1, 0, 1]], -62.2363839133389],
[[[0, 1, 1], [1, 0, 1]], -121.5533969109279],
[[[0, 0, 0], [1, 1, 0]], -65.09576309934431],
[[[0, 0, 1], [1, 1, 0]], -62.2363839133389],
[[[0, 1, 0], [1, 1, 0]], -62.2363839133389],
[[[0, 1, 1], [1, 1, 0]], -121.5533969109279],
[[[0, 0, 0], [1, 1, 1]], -170.744837386338],
[[[0, 0, 1], [1, 1, 1]], -167.7433236025723],
[[[0, 1, 0], [1, 1, 1]], -167.7433236025723],
[[[0, 1, 1], [1, 1, 1]], -179.0536532281924]]]
basis = [2, 2]
bosonic_op = BosonicOperator(co2_2modes_2modals_2body, basis)
qubit_op = bosonic_op.mapping('direct', threshold=1e-5)
with warnings.catch_warnings():
warnings.filterwarnings('ignore', category=DeprecationWarning)
init_state = VSCF(basis)
num_qubits = sum(basis)
uvcc_varform = UVCC(num_qubits, basis, [0, 1], initial_state=init_state)
q_instance = QuantumInstance(BasicAer.get_backend('statevector_simulator'),
seed_transpiler=90, seed_simulator=12)
optimizer = COBYLA(maxiter=1000)
algo = VQE(uvcc_varform, optimizer=optimizer, quantum_instance=q_instance)
vqe_result = algo.compute_minimum_eigenvalue(qubit_op)
energy = vqe_result['optimal_value']
self.assertAlmostEqual(energy, self.reference_energy, places=4)
def test_vertex_cover_vqe(self):
""" Vertex Cover VQE test """
aqua_globals.random_seed = self.seed
q_i = QuantumInstance(BasicAer.get_backend('qasm_simulator'),
seed_simulator=aqua_globals.random_seed,
seed_transpiler=aqua_globals.random_seed)
result = VQE(EfficientSU2(reps=3),
SPSA(maxiter=200),
max_evals_grouped=2,
quantum_instance=q_i).compute_minimum_eigenvalue(
operator=self.qubit_op)
x = sample_most_likely(result.eigenstate)
sol = vertex_cover.get_graph_solution(x)
oracle = self._brute_force()
self.assertEqual(np.count_nonzero(sol), oracle)
def test_uccsd_hf(self):
""" uccsd hf test """
ansatz = self._prepare_uccsd_hf(self.qubit_converter)
optimizer = SLSQP(maxiter=100)
backend = BasicAer.get_backend('statevector_simulator')
solver = VQE(ansatz=ansatz,
optimizer=optimizer,
quantum_instance=QuantumInstance(backend=backend))
gsc = GroundStateEigensolver(self.qubit_converter, solver)
result = gsc.solve(self.electronic_structure_problem)
self.assertAlmostEqual(result.total_energies[0],
self.reference_energy,
places=6)
def test_with_gradient(self, optimizer):
"""Test VQE using Gradient()."""
quantum_instance = QuantumInstance(
backend=Aer.get_backend("qasm_simulator"),
shots=1,
seed_simulator=algorithm_globals.random_seed,
seed_transpiler=algorithm_globals.random_seed,
)
vqe = VQE(
ansatz=self.ry_wavefunction,
optimizer=optimizer,
gradient=Gradient(),
expectation=AerPauliExpectation(),
quantum_instance=quantum_instance,
max_evals_grouped=1000,
)
vqe.compute_minimum_eigenvalue(operator=self.h2_op)
def test_clique_vqe(self):
""" VQE Clique test """
algorithm_globals.random_seed = 10598
q_i = QuantumInstance(BasicAer.get_backend('statevector_simulator'),
seed_simulator=algorithm_globals.random_seed,
seed_transpiler=algorithm_globals.random_seed)
result = VQE(RealAmplitudes(reps=5, entanglement='linear'),
COBYLA(),
max_evals_grouped=2,
quantum_instance=q_i).compute_minimum_eigenvalue(
operator=self.qubit_op)
x = sample_most_likely(result.eigenstate)
ising_sol = clique.get_graph_solution(x)
np.testing.assert_array_equal(ising_sol, [1, 1, 1, 1, 1])
oracle = self._brute_force()
self.assertEqual(clique.satisfy_or_not(ising_sol, self.w, self.k),
oracle)
def setUp(self) -> None:
super().setUp()
try:
from qiskit import Aer
self.seed = 97
self.backend = Aer.get_backend('qasm_simulator')
q_instance = QuantumInstance(self.backend,
seed_simulator=self.seed,
seed_transpiler=self.seed)
self.sampler = CircuitSampler(q_instance, attach_results=True)
self.expect = AerPauliExpectation()
except Exception as ex: # pylint: disable=broad-except
self.skipTest(
"Aer doesn't appear to be installed. Error: '{}'".format(
str(ex)))
return
def test_int_values(self):
"""test AQGD with int values passed as eta and momentum."""
q_instance = QuantumInstance(
Aer.get_backend("aer_simulator_statevector"),
seed_simulator=algorithm_globals.random_seed,
seed_transpiler=algorithm_globals.random_seed,
)
aqgd = AQGD(maxiter=1000, eta=1, momentum=0)
vqe = VQE(
ansatz=RealAmplitudes(),
optimizer=aqgd,
gradient=Gradient("lin_comb"),
quantum_instance=q_instance,
)
result = vqe.compute_minimum_eigenvalue(operator=self.qubit_op)
self.assertAlmostEqual(result.eigenvalue.real, -1.857, places=3)
def test_vqe_uvccsd_factory(self):
"""Test with VQE plus UVCCSD"""
optimizer = COBYLA(maxiter=5000)
quantum_instance = QuantumInstance(
backend=qiskit.BasicAer.get_backend("statevector_simulator"),
seed_simulator=algorithm_globals.random_seed,
seed_transpiler=algorithm_globals.random_seed,
)
solver = VQEUVCCFactory(quantum_instance=quantum_instance,
optimizer=optimizer)
gsc = GroundStateEigensolver(self.qubit_converter, solver)
esc = QEOM(gsc, "sd")
results = esc.solve(self.vibrational_problem)
for idx, energy in enumerate(self.reference_energies):
self.assertAlmostEqual(results.computed_vibrational_energies[idx],
energy,
places=1)
def test_aux_ops_reusability(self):
""" Test that the auxiliary operators can be reused """
# Regression test against #1475
solver = VQEUCCFactory(
QuantumInstance(BasicAer.get_backend('statevector_simulator')))
calc = AdaptVQE(self.qubit_converter, solver)
modes = 4
h_1 = np.eye(modes, dtype=complex)
h_2 = np.zeros((modes, modes, modes, modes))
aux_ops = [build_ferm_op_from_ints(h_1, h_2)]
aux_ops_copy = copy.deepcopy(aux_ops)
_ = calc.solve(self.problem)
assert all(
frozenset(a.to_list()) == frozenset(b.to_list())
for a, b in zip(aux_ops, aux_ops_copy))
def test_simple(self):
"""test AQGD optimizer with the parameters as single values."""
q_instance = QuantumInstance(
Aer.get_backend("aer_simulator_statevector"),
seed_simulator=algorithm_globals.random_seed,
seed_transpiler=algorithm_globals.random_seed,
)
aqgd = AQGD(momentum=0.0)
vqe = VQE(
ansatz=RealAmplitudes(),
optimizer=aqgd,
gradient=Gradient("fin_diff"),
quantum_instance=q_instance,
)
result = vqe.compute_minimum_eigenvalue(operator=self.qubit_op)
self.assertAlmostEqual(result.eigenvalue.real, -1.857, places=3)
def _set_quantum_instance(
self,
quantum_instance: Optional[Union[QuantumInstance, Backend]],
output_shape: Union[int, Tuple[int, ...]],
interpret: Optional[Callable[[int], Union[int, Tuple[int, ...]]]],
) -> None:
"""
Internal method to set a quantum instance and compute/initialize internal properties such
as an interpret function, output shape and a sampler.
Args:
quantum_instance: A quantum instance to set.
output_shape: An output shape of the custom interpretation.
interpret: A callable that maps the measured integer to another unsigned integer or
tuple of unsigned integers.
"""
if isinstance(quantum_instance, Backend):
quantum_instance = QuantumInstance(quantum_instance)
self._quantum_instance = quantum_instance
if self._quantum_instance is not None:
# add measurements in case none are given
if self._quantum_instance.is_statevector:
if len(self._circuit.clbits) > 0:
self._circuit.remove_final_measurements()
elif len(self._circuit.clbits) == 0:
self._circuit.measure_all()
# set interpret and compute output shape
self.set_interpret(interpret, output_shape)
# prepare sampler
self._sampler = CircuitSampler(self._quantum_instance, param_qobj=False, caching="all")
# transpile the QNN circuit
try:
self._circuit = self._quantum_instance.transpile(
self._circuit, pass_manager=self._quantum_instance.unbound_pass_manager
)[0]
self._circuit_transpiled = True
except QiskitError:
# likely it is caused by RawFeatureVector, we just ignore this error and
# transpile circuits when it is required.
self._circuit_transpiled = False
else:
self._output_shape = output_shape
def __init__(self, h, w, outputs):
super(DQN, self).__init__()
# We did a lot of experimentation with model sizes and types, so we decided to leave some
# of our attempts here
#1
# self.conv1 = nn.Conv2d(1, 16, kernel_size=5, stride=2)
# self.bn1 = nn.BatchNorm2d(16)
# self.conv2 = nn.Conv2d(16, 32, kernel_size=5, stride=2)
# self.bn2 = nn.BatchNorm2d(32)
# self.conv3 = nn.Conv2d(32, 32, kernel_size=5, stride=2)
# self.bn3 = nn.BatchNorm2d(32)
#2
# # Number of Linear input connections depends on output of conv2d layers
# # and therefore the input image size, so compute it.
# def conv2d_size_out(size, kernel_size = 5, stride = 2):
# return (size - (kernel_size - 1) - 1) // stride + 1
# convw = conv2d_size_out(conv2d_size_out(conv2d_size_out(w)))
# convh = conv2d_size_out(conv2d_size_out(conv2d_size_out(h)))
# linear_input_size = convw * convh * 32
#3
# self.conv1 = nn.Conv2d(1, 128, kernel_size=2, stride=1, padding=1)
# self.bn1 = nn.BatchNorm2d(128)
# self.conv2 = nn.Conv2d(128, 256, kernel_size=5, stride=1, padding=1)
# self.bn2 = nn.BatchNorm2d(256)
# self.fcl1 = nn.Linear(12544,5000)
# self.fcl2 = nn.Linear(5000, 64)
qi = QuantumInstance(Aer.get_backend('statevector_simulator'))
feature_map = ZZFeatureMap(4)
ansatz = RealAmplitudes(4, reps=1)
qnn = TwoLayerQNN(4,
feature_map,
ansatz,
exp_val=AerPauliExpectation(),
quantum_instance=qi)
#4
# Our final network choice. It is wide enough to capture a lot of detail but not too
# large to have problems with vanishing gradients on such a small sample size
self.conv1 = nn.Conv2d(1, 256, kernel_size=2, stride=1, padding=1)
self.bn1 = nn.BatchNorm2d(256)
self.fcl1 = nn.Linear(20736, 10000)
self.fcl2 = nn.Linear(10000, 4)
self.qnn = TorchConnector(qnn)
def test_gradient_wrapper(self, backend_type):
"""Test the gradient wrapper for probability gradients
dp0/da = cos(a)sin(b) / 2
dp1/da = - cos(a)sin(b) / 2
dp0/db = sin(a)cos(b) / 2
dp1/db = - sin(a)cos(b) / 2
"""
method = "param_shift"
a = Parameter("a")
b = Parameter("b")
params = [a, b]
q = QuantumRegister(1)
qc = QuantumCircuit(q)
qc.h(q)
qc.rz(params[0], q[0])
qc.rx(params[1], q[0])
op = CircuitStateFn(primitive=qc, coeff=1.0)
shots = 8000
backend = BasicAer.get_backend(backend_type)
q_instance = QuantumInstance(backend=backend, shots=shots)
if method == "fin_diff":
np.random.seed(8)
prob_grad = Gradient(grad_method=method, epsilon=shots ** (-1 / 6.0)).gradient_wrapper(
operator=op, bind_params=params, backend=q_instance
)
else:
prob_grad = Gradient(grad_method=method).gradient_wrapper(
operator=op, bind_params=params, backend=q_instance
)
values = [[np.pi / 4, 0], [np.pi / 4, np.pi / 4], [np.pi / 2, np.pi]]
correct_values = [
[[0, 0], [1 / (2 * np.sqrt(2)), -1 / (2 * np.sqrt(2))]],
[[1 / 4, -1 / 4], [1 / 4, -1 / 4]],
[[0, 0], [-1 / 2, 1 / 2]],
]
for i, value in enumerate(values):
result = prob_grad(value)
if backend_type == "qasm_simulator": # sparse result
result = [result[0].toarray(), result[1].toarray()]
self.assertTrue(np.allclose(result[0], correct_values[i][0], atol=0.1))
self.assertTrue(np.allclose(result[1], correct_values[i][1], atol=0.1))
def test_exact_cover_vqe(self):
""" Exact Cover VQE test """
algorithm_globals.random_seed = 10598
q_i = QuantumInstance(BasicAer.get_backend('statevector_simulator'),
seed_simulator=algorithm_globals.random_seed,
seed_transpiler=algorithm_globals.random_seed)
result = VQE(EfficientSU2(self.qubit_op.num_qubits, reps=5),
COBYLA(),
max_evals_grouped=2,
quantum_instance=q_i).compute_minimum_eigenvalue(
operator=self.qubit_op)
x = sample_most_likely(result.eigenstate)
ising_sol = exact_cover.get_solution(x)
oracle = self._brute_force()
self.assertEqual(
exact_cover.check_solution_satisfiability(ising_sol,
self.list_of_subsets),
oracle)
def test_uccsd_hf_aer_qasm_snapshot(self):
""" uccsd hf test with Aer qasm_simulator snapshot. """
try:
# pylint: disable=import-outside-toplevel
from qiskit import Aer
backend = Aer.get_backend('qasm_simulator')
except ImportError as ex: # pylint: disable=broad-except
self.skipTest("Aer doesn't appear to be installed. Error: '{}'".format(str(ex)))
return
optimizer = SPSA(maxiter=200, last_avg=5)
solver = VQE(var_form=self.var_form, optimizer=optimizer,
expectation=AerPauliExpectation(),
quantum_instance=QuantumInstance(backend=backend))
gsc = GroundStateEigensolver(self.fermionic_transformation, solver)
result = gsc.solve(self.driver)
self.assertAlmostEqual(result.total_energies[0], self.reference_energy, places=3)
def __init__(
self,
num_iterations: int,
quantum_instance: Optional[Union[QuantumInstance, Backend]] = None,
) -> None:
"""Args:
num_iterations: The number of iterations (rounds) of the phase estimation to run.
quantum_instance: The quantum instance on which the circuit will be run.
Raises:
ValueError: if num_iterations is not greater than zero.
"""
if isinstance(quantum_instance, Backend):
quantum_instance = QuantumInstance(quantum_instance)
self._quantum_instance = quantum_instance
if num_iterations <= 0:
raise ValueError("`num_iterations` must be greater than zero.")
self._num_iterations = num_iterations
def test_vqe_ucc_factory_with_mp2(self):
"""Test when using MP2InitialPoint to generate the initial point."""
informed_start = MP2InitialPoint()
solver = VQEUCCFactory(
quantum_instance=QuantumInstance(
BasicAer.get_backend("statevector_simulator")),
initial_point=informed_start,
)
calc = GroundStateEigensolver(self.qubit_converter, solver)
res = calc.solve(self.electronic_structure_problem)
np.testing.assert_array_almost_equal(
solver.initial_point.to_numpy_array(), [0.0, 0.0, -0.07197145])
self.assertAlmostEqual(res.total_energies[0],
self.reference_energy,
places=6)
def test_vqe_uccsd_with_callback(self):
"""Test VQE UCCSD with callback."""
def callback(nfev, parameters, energy, stddev):
# pylint: disable=unused-argument
print(f"iterations {nfev}: energy: {energy}")
solver = VQEUCCFactory(
quantum_instance=QuantumInstance(BasicAer.get_backend("statevector_simulator")),
callback=callback,
)
calc = GroundStateEigensolver(self.qubit_converter, solver)
with contextlib.redirect_stdout(io.StringIO()) as out:
res = calc.solve(self.electronic_structure_problem)
self.assertAlmostEqual(res.total_energies[0], self.reference_energy, places=6)
for idx, line in enumerate(out.getvalue().split("\n")):
if line.strip():
self.assertTrue(line.startswith(f"iterations {idx+1}: energy: "))
def test_LiH(self):
"""Lih test"""
driver = PySCFDriver(
atom="Li .0 .0 .0; H .0 .0 1.6",
unit=UnitsType.ANGSTROM,
basis="sto3g",
)
transformer = ActiveSpaceTransformer(num_electrons=2,
num_molecular_orbitals=3)
problem = ElectronicStructureProblem(driver, [transformer])
solver = VQEUCCFactory(quantum_instance=QuantumInstance(
BasicAer.get_backend("statevector_simulator")))
calc = AdaptVQE(self.qubit_converter, solver)
res = calc.solve(problem)
self.assertAlmostEqual(res.electronic_energies[0],
-8.855126478,
places=6)
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_readme_sample(self):
""" readme sample test """
# pylint: disable=import-outside-toplevel,redefined-builtin
def print(*args):
""" overloads print to log values """
if args:
self.log.debug(args[0], *args[1:])
# --- Exact copy of sample code ----------------------------------------
from qiskit import BasicAer
from qiskit.utils import QuantumInstance, algorithm_globals
from qiskit.algorithms.optimizers import COBYLA
from qiskit.circuit.library import TwoLocal
from qiskit_machine_learning.algorithms import VQC
from qiskit_machine_learning.datasets import wine
from qiskit_machine_learning.circuit.library import RawFeatureVector
seed = 1376
algorithm_globals.random_seed = seed
# Use Wine data set for training and test data
feature_dim = 4 # dimension of each data point
_, training_input, test_input, _ = wine(training_size=12,
test_size=4,
n=feature_dim)
feature_map = RawFeatureVector(feature_dimension=feature_dim)
vqc = VQC(COBYLA(maxiter=100), feature_map,
TwoLocal(feature_map.num_qubits, ['ry', 'rz'], 'cz', reps=3),
training_input, test_input)
result = vqc.run(
QuantumInstance(BasicAer.get_backend('statevector_simulator'),
shots=1024,
seed_simulator=seed,
seed_transpiler=seed))
print('Testing accuracy: {:0.2f}'.format(result['testing_accuracy']))
# ----------------------------------------------------------------------
self.assertGreater(result['testing_accuracy'], 0.8)
def test_h2_bopes_sampler_qeom(self):
"""Test BOPES Sampler on H2"""
# Molecule
dof = partial(Molecule.absolute_distance, atom_pair=(1, 0))
m = Molecule(
geometry=[["H", [0.0, 0.0, 1.0]], ["H", [0.0, 0.45, 1.0]]],
degrees_of_freedom=[dof],
)
driver = ElectronicStructureMoleculeDriver(
m, driver_type=ElectronicStructureDriverType.PYSCF)
problem = ElectronicStructureProblem(driver)
qubit_converter = QubitConverter(JordanWignerMapper(),
z2symmetry_reduction=None)
quantum_instance = QuantumInstance(
backend=qiskit.providers.aer.Aer.get_backend(
"aer_simulator_statevector"),
seed_simulator=self.seed,
seed_transpiler=self.seed,
)
solver = VQE(quantum_instance=quantum_instance)
me_gsc = GroundStateEigensolver(qubit_converter, solver)
qeom_solver = QEOM(me_gsc, "sd")
# BOPES sampler
sampler = BOPESSampler(qeom_solver)
# absolute internuclear distance in Angstrom
points = [0.7, 1.0, 1.3]
results = sampler.sample(problem, points)
points_run = results.points
energies = results.energies
np.testing.assert_array_almost_equal(points_run, [0.7, 1.0, 1.3])
np.testing.assert_array_almost_equal(
energies,
[
[-1.13618945, -0.47845306, -0.1204519, 0.5833141],
[-1.10115033, -0.74587179, -0.35229063, 0.03904763],
[-1.03518627, -0.85523694, -0.42240202, -0.21860355],
],
decimal=2,
)
def __init__(self, operator: OperatorBase,
input_params: Optional[List[Parameter]] = None,
weight_params: Optional[List[Parameter]] = None,
exp_val: Optional[ExpectationBase] = None,
gradient: Optional[Gradient] = None,
quantum_instance: Optional[Union[QuantumInstance, BaseBackend, Backend]] = None):
"""Initializes the Opflow Quantum Neural Network.
Args:
operator: The parametrized operator that represents the neural network.
input_params: The operator parameters that correspond to the input of the network.
weight_params: The operator parameters that correspond to the trainable weights.
exp_val: The Expected Value converter to be used for the operator.
gradient: The Gradient converter to be used for the operator's backward pass.
quantum_instance: The quantum instance to evaluate the network.
"""
self.operator = operator
self.input_params = list(input_params or [])
self.weight_params = list(weight_params or [])
self.exp_val = exp_val # TODO: currently not used by Gradient!
self.gradient = gradient or Gradient()
if isinstance(quantum_instance, (BaseBackend, Backend)):
quantum_instance = QuantumInstance(quantum_instance)
if quantum_instance:
self.quantum_instance = quantum_instance
self.circuit_sampler = CircuitSampler(
self.quantum_instance,
param_qobj=is_aer_provider(self.quantum_instance.backend)
)
# TODO: replace by extended caching in circuit sampler after merged: "caching='all'"
self.gradient_sampler = deepcopy(self.circuit_sampler)
else:
self.quantum_instance = None
self.circuit_sampler = None
self.gradient_sampler = None
self.forward_operator = self.exp_val.convert(operator) if exp_val else operator
self.gradient_operator = self.gradient.convert(operator,
self.input_params + self.weight_params)
output_shape = self._get_output_shape_from_op(operator)
super().__init__(len(self.input_params), len(self.weight_params),
sparse=False, output_shape=output_shape)
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.ignis.mitigation.measurement import CompleteMeasFitter
from qiskit import Aer
from qiskit.providers.aer import noise
except ImportError as ex: # pylint: disable=broad-except
self.skipTest("Package 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])
self.assertGreater(quantum_instance.time_taken, 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_circuit_sampler2(self, method):
"""Test the probability gradient with the circuit sampler
dp0/da = cos(a)sin(b) / 2
dp1/da = - cos(a)sin(b) / 2
dp0/db = sin(a)cos(b) / 2
dp1/db = - sin(a)cos(b) / 2
"""
a = Parameter('a')
b = Parameter('b')
params = [a, b]
q = QuantumRegister(1)
qc = QuantumCircuit(q)
qc.h(q)
qc.rz(params[0], q[0])
qc.rx(params[1], q[0])
op = CircuitStateFn(primitive=qc, coeff=1.)
shots = 8000
if method == 'fin_diff':
np.random.seed(8)
prob_grad = Gradient(grad_method=method, epsilon=shots ** (-1 / 6.)).convert(
operator=op,
params=params)
else:
prob_grad = Gradient(grad_method=method).convert(operator=op, params=params)
values_dict = [{a: [np.pi / 4], b: [0]}, {params[0]: [np.pi / 4], params[1]: [np.pi / 4]},
{params[0]: [np.pi / 2], params[1]: [np.pi]}]
correct_values = [[[0, 0], [1 / (2 * np.sqrt(2)), - 1 / (2 * np.sqrt(2))]],
[[1 / 4, -1 / 4], [1 / 4, - 1 / 4]],
[[0, 0], [- 1 / 2, 1 / 2]]]
backend = BasicAer.get_backend('qasm_simulator')
q_instance = QuantumInstance(backend=backend, shots=shots)
for i, value_dict in enumerate(values_dict):
sampler = CircuitSampler(backend=q_instance).convert(prob_grad,
params=value_dict)
result = sampler.eval()
np.testing.assert_array_almost_equal(result[0], correct_values[i], decimal=1)
def test_gradient_wrapper(self, backend):
"""Test the gradient wrapper for probability gradients
dp0/da = cos(a)sin(b) / 2
dp1/da = - cos(a)sin(b) / 2
dp0/db = sin(a)cos(b) / 2
dp1/db = - sin(a)cos(b) / 2
"""
method = 'param_shift'
a = Parameter('a')
b = Parameter('b')
params = [a, b]
q = QuantumRegister(1)
qc = QuantumCircuit(q)
qc.h(q)
qc.rz(params[0], q[0])
qc.rx(params[1], q[0])
op = CircuitStateFn(primitive=qc, coeff=1.)
shots = 8000
backend = BasicAer.get_backend(backend)
q_instance = QuantumInstance(backend=backend, shots=shots)
if method == 'fin_diff':
np.random.seed(8)
prob_grad = Gradient(grad_method=method,
epsilon=shots**(-1 / 6.)).gradient_wrapper(
operator=op,
bind_params=params,
backend=q_instance)
else:
prob_grad = Gradient(grad_method=method).gradient_wrapper(
operator=op, bind_params=params, backend=q_instance)
values = [[np.pi / 4, 0], [np.pi / 4, np.pi / 4], [np.pi / 2, np.pi]]
correct_values = [[[0, 0],
[1 / (2 * np.sqrt(2)), -1 / (2 * np.sqrt(2))]],
[[1 / 4, -1 / 4], [1 / 4, -1 / 4]],
[[0, 0], [-1 / 2, 1 / 2]]]
for i, value in enumerate(values):
result = prob_grad(value)
np.testing.assert_array_almost_equal(result,
correct_values[i],
decimal=1)
def test_excitation_preserving(self):
"""Test the excitation preserving wavefunction on a chemistry example."""
driver = HDF5Driver(
self.get_resource_path("test_driver_hdf5.hdf5",
"second_q/drivers/hdf5d"))
converter = QubitConverter(ParityMapper())
problem = ElectronicStructureProblem(driver)
_ = problem.second_q_ops()
particle_number = cast(
ParticleNumber,
problem.grouped_property_transformed.get_property(ParticleNumber))
num_particles = (particle_number.num_alpha, particle_number.num_beta)
num_spin_orbitals = particle_number.num_spin_orbitals
optimizer = SLSQP(maxiter=100)
initial_state = HartreeFock(num_spin_orbitals, num_particles,
converter)
wavefunction = ExcitationPreserving(num_spin_orbitals)
wavefunction.compose(initial_state, front=True, inplace=True)
solver = VQE(
ansatz=wavefunction,
optimizer=optimizer,
quantum_instance=QuantumInstance(
BasicAer.get_backend("statevector_simulator"),
seed_simulator=algorithm_globals.random_seed,
seed_transpiler=algorithm_globals.random_seed,
),
)
gsc = GroundStateEigensolver(converter, solver)
result = gsc.solve(problem)
self.assertAlmostEqual(result.total_energies[0],
self.reference_energy,
places=4)
def test_qaoa_random_initial_point(self):
""" QAOA random initial point """
aqua_globals.random_seed = 10598
w = nx.adjacency_matrix(
nx.fast_gnp_random_graph(5, 0.5,
seed=aqua_globals.random_seed)).toarray()
qubit_op, _ = max_cut.get_operator(w)
q_i = QuantumInstance(BasicAer.get_backend('qasm_simulator'),
seed_simulator=aqua_globals.random_seed,
seed_transpiler=aqua_globals.random_seed,
shots=4096)
qaoa = QAOA(optimizer=NELDER_MEAD(disp=True),
p=1,
quantum_instance=q_i)
_ = qaoa.compute_minimum_eigenvalue(operator=qubit_op)
np.testing.assert_almost_equal([-0.8792, 0.3948],
qaoa.optimal_params,
decimal=4)
def test_vqe_optimizer(self):
"""Test running same VQE twice to re-use optimizer, then switch optimizer"""
vqe = VQE(
optimizer=SLSQP(),
quantum_instance=QuantumInstance(BasicAer.get_backend("statevector_simulator")),
)
def run_check():
result = vqe.compute_minimum_eigenvalue(operator=self.h2_op)
self.assertAlmostEqual(result.eigenvalue.real, -1.85727503, places=5)
run_check()
with self.subTest("Optimizer re-use"):
run_check()
with self.subTest("Optimizer replace"):
vqe.optimizer = L_BFGS_B()
run_check()
