def get_optimal_value(self):
"""
Computes the eigenvalue estimates of the initial state
Returns:
numpy.ndarray: array of eigenvalues estimates
"""
if 'opt_params' not in self._ret:
raise AquaError("Cannot find optimal vector before running the "
"algorithm to find optimal params.")
# TODO : Find better way to do this
num_working_qubits = self._num_working_qubits
circuit = self.get_optimal_circuit()
counts = None
if self._quantum_instance.is_statevector:
ret = self._quantum_instance.execute(circuit)
state_vec = Statevector(ret.get_statevector(circuit))
counts = state_vec.probabilities_dict()
else:
c = ClassicalRegister(circuit.width(), name='c')
q = find_regs_by_name(circuit, 'q')
circuit.add_register(c)
circuit.barrier(q)
circuit.measure(q[:num_working_qubits], c[:num_working_qubits])
ret = self._quantum_instance.execute(circuit)
counts = ret.get_counts(circuit)
keys = list(map(''.join, product(['0', '1'],
repeat=num_working_qubits)))
num_shots = sum(counts.values())
probs = dict.fromkeys(keys, 0.0)
for i, (k, v) in enumerate(counts.items()):
probs[k[-num_working_qubits:]] += v / num_shots
print({k: v for k, v in sorted(probs.items(), key=lambda item:
-item[1])})
eigvals = np.array(list(probs.values()))
idx = np.argsort(-eigvals)
return eigvals[idx]
def _cost_evaluation(self, parameters):
"""
Evaluate cost function at given parameters for the variational form.
Args:
parameters (numpy.ndarray): parameters for variational form.
Returns:
Union(float, list[float]): cost objective function value of each parameter.
"""
num_parameter_sets = len(parameters) // self._var_form.num_parameters
parameter_sets = np.split(parameters, num_parameter_sets)
global_objs = []
local_objs = []
weighted_objs = []
def _build_parameterized_circuits():
if self._var_form.support_parameterized_circuit and \
self._parameterized_circuits is not None:
parameterized_circuits = self.construct_circuit(
self._var_form_params,
statevector_mode=self._quantum_instance.is_statevector,
use_simulator_snapshot_mode=self._use_simulator_snapshot_mode)
self._parameterized_circuits = \
self._quantum_instance.transpile(parameterized_circuits)
_build_parameterized_circuits()
circuits = []
# binding parameters here since the circuits had been transpiled
if self._parameterized_circuits is not None:
for idx, parameter in enumerate(parameter_sets):
curr_param = {self._var_form_params: parameter}
for qc in self._parameterized_circuits:
tmp = qc.bind_parameters(curr_param)
tmp.name = str(idx) + '_' + tmp.name
circuits.append(tmp)
to_be_simulated_circuits = circuits
else:
for idx, parameter in enumerate(parameter_sets):
circuit = self.construct_circuit(
parameter,
statevector_mode=self._quantum_instance.is_statevector,
use_simulator_snapshot_mode=self._use_simulator_snapshot_mode,
circuit_name_prefix=str(idx))
circuits.append(circuit)
to_be_simulated_circuits = functools.reduce(lambda x, y:
x + y, circuits)
start_time = time()
result = self._quantum_instance.execute(to_be_simulated_circuits,
self._parameterized_circuits
is not None)
for idx, _ in enumerate(parameter_sets):
# Evaluate with result
circuits = list(filter(lambda circ:
circ.name.startswith('{}_'.format(idx)),
to_be_simulated_circuits))
# DIP test circuits
dip_test_circuit = circuits[0]
# PDIP circuits
pdip_test_circuits = circuits[1:]
# evaluate with results
dip_test_counts = None
pdip_test_counts = None
if self._quantum_instance.is_statevector:
np_state_vec = result.get_statevector(dip_test_circuit)
dip_test_state_vec = Statevector(np_state_vec)
dip_test_counts = dip_test_state_vec.probabilities_dict()
pdip_test_counts = \
[Statevector(result.get_statevector(circ)).probabilities_dict()
for circ in pdip_test_circuits]
else:
dip_test_counts = result.get_counts(dip_test_circuit)
pdip_test_counts = [result.get_counts(circ) for circ in
pdip_test_circuits]
obj_global = self._dip_test_post_process(dip_test_counts)
obj_local = self._pdip_test_post_process(pdip_test_counts)
obj_weigthed = self._q * obj_global + (1.0 - self._q) * obj_local
end_time = time()
global_objs.append(np.real(obj_global))
local_objs.append(np.real(obj_local))
weighted_objs.append(np.real(obj_weigthed))
self._eval_count += 1
if self._callback is not None:
self._callback(self._eval_count, parameter_sets[idx],
np.real(obj_global), np.real(obj_local),
np.real(obj_weigthed))
# If there is more than one parameter set then the calculation
# of the evaluation time has to be done more carefully,
# therefore we do not calculate it
if len(parameter_sets) == 1:
logger.info('Cost function evaluation %s '
'returned %s - %.5f (ms)',
self._eval_count,
np.real(obj_weigthed),
(end_time - start_time) * 1000)
else:
logger.info('Cost function evaluation %s returned %s',
self._eval_count,
np.real(obj_weigthed))
return weighted_objs if len(weighted_objs) > 1 \
else weighted_objs[0]
