def test_vqe_callback(self, var_form_type):
""" VQE Callback test """
history = {'eval_count': [], 'parameters': [], 'mean': [], 'std': []}
def store_intermediate_result(eval_count, parameters, mean, std):
history['eval_count'].append(eval_count)
history['parameters'].append(parameters)
history['mean'].append(mean)
history['std'].append(std)
backend = BasicAer.get_backend('qasm_simulator')
num_qubits = self.qubit_op.num_qubits
init_state = Zero(num_qubits)
var_form = RY(num_qubits, depth=1, initial_state=init_state)
if var_form_type is QuantumCircuit:
params = ParameterVector('θ', var_form.num_parameters)
var_form = var_form.construct_circuit(params)
optimizer = COBYLA(maxiter=3)
algo = VQE(self.qubit_op, var_form, optimizer,
callback=store_intermediate_result, auto_conversion=False)
aqua_globals.random_seed = 50
quantum_instance = QuantumInstance(backend,
seed_transpiler=50,
shots=1024,
seed_simulator=50)
algo.run(quantum_instance)
self.assertTrue(all(isinstance(count, int) for count in history['eval_count']))
self.assertTrue(all(isinstance(mean, float) for mean in history['mean']))
self.assertTrue(all(isinstance(std, float) for std in history['std']))
for params in history['parameters']:
self.assertTrue(all(isinstance(param, float) for param in params))
def test_vqc_callback(self, use_circuits):
""" vqc callback test """
history = {
'eval_count': [],
'parameters': [],
'cost': [],
'batch_index': []
}
def store_intermediate_result(eval_count, parameters, cost,
batch_index):
history['eval_count'].append(eval_count)
history['parameters'].append(parameters)
history['cost'].append(cost)
history['batch_index'].append(batch_index)
aqua_globals.random_seed = self.seed
backend = BasicAer.get_backend('qasm_simulator')
num_qubits = 2
optimizer = COBYLA(maxiter=3)
feature_map = SecondOrderExpansion(feature_dimension=num_qubits,
depth=2)
var_form = RY(num_qubits=num_qubits, depth=1)
# convert to circuit if circuits should be used
if use_circuits:
x = ParameterVector('x', feature_map.feature_dimension)
feature_map = feature_map.construct_circuit(x)
theta = ParameterVector('theta', var_form.num_parameters)
var_form = var_form.construct_circuit(theta)
vqc = VQC(optimizer,
feature_map,
var_form,
self.training_data,
self.testing_data,
callback=store_intermediate_result)
quantum_instance = QuantumInstance(backend,
shots=1024,
seed_simulator=self.seed,
seed_transpiler=self.seed)
vqc.run(quantum_instance)
self.assertTrue(
all(isinstance(count, int) for count in history['eval_count']))
self.assertTrue(
all(isinstance(cost, float) for cost in history['cost']))
self.assertTrue(
all(isinstance(index, int) for index in history['batch_index']))
for params in history['parameters']:
self.assertTrue(all(isinstance(param, float) for param in params))
def test_vqe_qasm(self, var_form_type):
""" VQE QASM test """
backend = BasicAer.get_backend('qasm_simulator')
num_qubits = self.qubit_op.num_qubits
var_form = RY(num_qubits, depth=3)
if var_form_type is QuantumCircuit:
params = ParameterVector('θ', var_form.num_parameters)
var_form = var_form.construct_circuit(params)
optimizer = SPSA(max_trials=300, last_avg=5)
algo = VQE(self.qubit_op, var_form, optimizer, max_evals_grouped=1)
quantum_instance = QuantumInstance(backend, shots=10000,
seed_simulator=self.seed,
seed_transpiler=self.seed)
result = algo.run(quantum_instance)
self.assertAlmostEqual(result.eigenvalue.real, -1.85727503, places=2)
def test_vqe_qasm_snapshot_mode(self, var_form_type):
""" VQE Aer qasm_simulator snapshot mode test """
try:
# pylint: disable=import-outside-toplevel
from qiskit import Aer
except Exception as ex: # pylint: disable=broad-except
self.skipTest("Aer doesn't appear to be installed. Error: '{}'".format(str(ex)))
return
backend = Aer.get_backend('qasm_simulator')
num_qubits = self.qubit_op.num_qubits
init_state = Zero(num_qubits)
var_form = RY(num_qubits, depth=3, initial_state=init_state)
if var_form_type is QuantumCircuit:
params = ParameterVector('θ', var_form.num_parameters)
var_form = var_form.construct_circuit(params)
optimizer = L_BFGS_B()
algo = VQE(self.qubit_op, var_form, optimizer, max_evals_grouped=1)
quantum_instance = QuantumInstance(backend, shots=1,
seed_simulator=aqua_globals.random_seed,
seed_transpiler=aqua_globals.random_seed)
result = algo.run(quantum_instance)
self.assertAlmostEqual(result.eigenvalue.real, -1.85727503, places=6)
def setUp(self):
super().setUp()
self.seed = 7
aqua_globals.random_seed = self.seed
# Number training data samples
n_v = 5000
# Load data samples from log-normal distribution with mean=1 and standard deviation=1
m_u = 1
sigma = 1
self._real_data = aqua_globals.random.lognormal(mean=m_u,
sigma=sigma,
size=n_v)
# Set the data resolution
# Set upper and lower data values as list of k
# min/max data values [[min_0,max_0],...,[min_k-1,max_k-1]]
self._bounds = [0., 3.]
# Set number of qubits per data dimension as list of k qubit values[#q_0,...,#q_k-1]
num_qubits = [2]
# Batch size
batch_size = 100
# Set number of training epochs
# num_epochs = 10
num_epochs = 5
# Initialize qGAN
self.qgan = QGAN(self._real_data,
self._bounds,
num_qubits,
batch_size,
num_epochs,
snapshot_dir=None)
self.qgan.seed = 7
# Set quantum instance to run the quantum generator
self.qi_statevector = QuantumInstance(
backend=BasicAer.get_backend('statevector_simulator'),
seed_simulator=2,
seed_transpiler=2)
self.qi_qasm = QuantumInstance(
backend=BasicAer.get_backend('qasm_simulator'),
shots=1000,
seed_simulator=2,
seed_transpiler=2)
# Set entangler map
entangler_map = [[0, 1]]
# Set an initial state for the generator circuit
init_dist = UniformDistribution(sum(num_qubits),
low=self._bounds[0],
high=self._bounds[1])
q = QuantumRegister(sum(num_qubits), name='q')
qc = QuantumCircuit(q)
init_dist.build(qc, q)
init_distribution = Custom(num_qubits=sum(num_qubits), circuit=qc)
# Set variational form
var_form = RY(sum(num_qubits),
depth=1,
initial_state=init_distribution,
entangler_map=entangler_map,
entanglement_gate='cz')
# Set generator's initial parameters
init_params = aqua_globals.random.rand(
var_form._num_parameters) * 2 * 1e-2
# Set generator circuit
self.g_var_form = UnivariateVariationalDistribution(
sum(num_qubits),
var_form,
init_params,
low=self._bounds[0],
high=self._bounds[1])
theta = ParameterVector('θ', var_form.num_parameters)
var_form = var_form.construct_circuit(theta)
self.g_circuit = UnivariateVariationalDistribution(
sum(num_qubits),
var_form,
init_params,
low=self._bounds[0],
high=self._bounds[1])
two_qubit_reduction=core._two_qubit_reduction,
num_particles=core._molecule_info['num_particles'],
sq_list=sqlist)
circuit = init_state.construct_circuit()
outfile.write("\nHartree-Fock energy %f \n" % (molecule.hf_energy))
outfile.write("\nHartree-Fock circuit\n")
outfile.write(str(circuit.draw()) + "\n")
var_form = RY(H_op.num_qubits,
depth=3,
entanglement='full',
entanglement_gate='cz',
initial_state=init_state)
optimizer = CG(maxiter=1000)
algo = VQE(H_op, var_form, optimizer, aux_operators=A_op)
backend = Aer.get_backend('statevector_simulator')
quantum_instance = QuantumInstance(backend=backend)
algo_result = algo.run(quantum_instance)
get_results(H_op, A_op, molecule, core, algo_result, outfile)
outfile.write("\nRY circuit\n")
outfile.write(
str(var_form.construct_circuit(algo_result['optimal_point']).draw()) +
"\n")
print_circuit_requirements(
var_form.construct_circuit(algo_result['optimal_point']),
'ibmq_16_melbourne', 3, range(H_op.num_qubits), outfile)
def test_ecev(self, use_circuits):
""" European Call Expected Value test """
if not use_circuits:
# ignore deprecation warnings from the deprecation of VariationalForm as input for
# the univariate variational distribution
warnings.filterwarnings("ignore", category=DeprecationWarning)
bounds = np.array([0., 7.])
num_qubits = [3]
entangler_map = []
for i in range(sum(num_qubits)):
entangler_map.append([i, int(np.mod(i + 1, sum(num_qubits)))])
g_params = [
0.29399714, 0.38853322, 0.9557694, 0.07245791, 6.02626428,
0.13537225
]
# Set an initial state for the generator circuit
init_dist = NormalDistribution(int(sum(num_qubits)),
mu=1.,
sigma=1.,
low=bounds[0],
high=bounds[1])
init_distribution = np.sqrt(init_dist.probabilities)
init_distribution = Custom(num_qubits=sum(num_qubits),
state_vector=init_distribution)
var_form = RY(int(np.sum(num_qubits)),
depth=1,
initial_state=init_distribution,
entangler_map=entangler_map,
entanglement_gate='cz')
if use_circuits:
theta = ParameterVector('θ', var_form.num_parameters)
var_form = var_form.construct_circuit(theta)
uncertainty_model = UnivariateVariationalDistribution(int(
sum(num_qubits)),
var_form,
g_params,
low=bounds[0],
high=bounds[1])
if use_circuits:
uncertainty_model._var_form_params = theta
strike_price = 2
c_approx = 0.25
european_call = EuropeanCallExpectedValue(uncertainty_model,
strike_price=strike_price,
c_approx=c_approx)
uncertainty_model.set_probabilities(
QuantumInstance(BasicAer.get_backend('statevector_simulator')))
algo = AmplitudeEstimation(5, european_call)
result = algo.run(
quantum_instance=BasicAer.get_backend('statevector_simulator'))
self.assertAlmostEqual(result['estimation'], 1.2580, places=4)
self.assertAlmostEqual(result['max_probability'], 0.8785, places=4)
if not use_circuits:
warnings.filterwarnings(action="always",
category=DeprecationWarning)
return psi
# 1 - |<Psi|RY(theta1,..,theta4)>|^2 :: minimize this to obtain (theta1,..,theta4)
def diff(psi):
return lambda x: 1 - np.abs(psi.dot(ry_state_vec(x[0], x[1], x[2], x[3])))**2
# In[35]:
# RY-Ansatz parameters(theta1,..,theta4) obtained by VQD-iteration
params = np.array([1.70075589, 1.72352203, -0.32227027, -1.34956145])
# circuit for 2-qubit RY Ansatz
var_form = RY(2, depth=1, entanglement="linear")
circ = var_form.construct_circuit(parameters = params)
#circ.draw(output = 'mpl')
# In[36]:
# generate circuits for state tomography
tomo_circuits = state_tomography_circuits(circ, circ.qregs)
# In[44]:
# exec state tomography experiments
job = execute(tomo_circuits, backend = backend_qasm, shots = 8192)
