def _compute_gradients(self, excitation_pool, theta, delta, var_form,
operator, optimizer):
"""
Computes the gradients for all available excitation operators.
Args:
excitation_pool (list): pool of excitation operators
theta (list): list of (up to now) optimal parameters
delta (float): finite difference step size (for gradient computation)
var_form (VariationalForm): current variational form
operator (BaseOperator): system Hamiltonian
optimizer (Optimizer): classical optimizer algorithm
Returns:
list: List of pairs consisting of gradient and excitation operator.
"""
res = []
# compute gradients for all excitation in operator pool
for exc in excitation_pool:
# push next excitation to variational form
var_form.push_hopping_operator(exc)
# construct auxiliary VQE instance
vqe = VQE(operator, var_form, optimizer)
vqe.quantum_instance = self.quantum_instance
vqe._operator = vqe._config_the_best_mode(
operator, self.quantum_instance.backend)
vqe._use_simulator_snapshot_mode = self._use_simulator_snapshot_mode
# evaluate energies
parameter_sets = theta + [-delta] + theta + [delta]
energy_results = vqe._energy_evaluation(np.asarray(parameter_sets))
# compute gradient
gradient = (energy_results[0] - energy_results[1]) / (2 * delta)
res.append((np.abs(gradient), exc))
# pop excitation from variational form
var_form.pop_hopping_operator()
return res
def _run(self) -> 'VQEAdaptResult':
"""
Run the algorithm to compute the minimum eigenvalue.
Returns:
dict: Dictionary of results
Raises:
AquaError: wrong setting of operator and backend.
"""
self._ret = {} # TODO should be eliminated
self._operator = VQE._config_the_best_mode(
self, self._operator, self._quantum_instance.backend)
self._use_simulator_snapshot_mode = \
is_aer_statevector_backend(self._quantum_instance.backend) \
and isinstance(self._operator, (WeightedPauliOperator, TPBGroupedWeightedPauliOperator))
self._quantum_instance.circuit_summary = True
cycle_regex = re.compile(r'(.+)( \1)+')
# reg-ex explanation:
# 1. (.+) will match at least one number and try to match as many as possible
# 2. the match of this part is placed into capture group 1
# 3. ( \1)+ will match a space followed by the contents of capture group 1
# -> this results in any number of repeating numbers being detected
threshold_satisfied = False
alternating_sequence = False
prev_op_indices = []
theta = []
max_grad = ()
iteration = 0
while not threshold_satisfied and not alternating_sequence:
iteration += 1
logger.info('--- Iteration #%s ---', str(iteration))
# compute gradients
cur_grads = self._compute_gradients(self._excitation_pool, theta,
self._delta,
self._var_form_base,
self._operator,
self._optimizer)
# pick maximum gradient
max_grad_index, max_grad = max(enumerate(cur_grads),
key=lambda item: np.abs(item[1][0]))
# store maximum gradient's index for cycle detection
prev_op_indices.append(max_grad_index)
# log gradients
gradlog = "\nGradients in iteration #{}".format(str(iteration))
gradlog += "\nID: Excitation Operator: Gradient <(*) maximum>"
for i, grad in enumerate(cur_grads):
gradlog += '\n{}: {}: {}'.format(str(i), str(grad[1]),
str(grad[0]))
if grad[1] == max_grad[1]:
gradlog += '\t(*)'
logger.info(gradlog)
if np.abs(max_grad[0]) < self._threshold:
logger.info(
"Adaptive VQE terminated succesfully with a final maximum gradient: %s",
str(np.abs(max_grad[0])))
threshold_satisfied = True
break
# check indices of picked gradients for cycles
if cycle_regex.search(' '.join(map(str,
prev_op_indices))) is not None:
logger.info("Alternating sequence found. Finishing.")
logger.info("Final maximum gradient: %s",
str(np.abs(max_grad[0])))
alternating_sequence = True
break
# add new excitation to self._var_form_base
self._var_form_base.push_hopping_operator(max_grad[1])
theta.append(0.0)
# run VQE on current Ansatz
algorithm = VQE(self._operator,
self._var_form_base,
self._optimizer,
initial_point=theta)
vqe_result = algorithm.run(self._quantum_instance)
self._ret['opt_params'] = vqe_result.optimal_point
theta = vqe_result.optimal_point.tolist()
# once finished evaluate auxiliary operators if any
if self._aux_operators is not None and self._aux_operators:
algorithm = VQE(self._operator,
self._var_form_base,
self._optimizer,
initial_point=theta,
aux_operators=self._aux_operators)
vqe_result = algorithm.run(self._quantum_instance)
self._ret['opt_params'] = vqe_result.optimal_point
if threshold_satisfied:
finishing_criterion = 'Threshold converged'
elif alternating_sequence:
finishing_criterion = 'Aborted due to cyclicity'
else:
raise AquaError(
'The algorithm finished due to an unforeseen reason!')
# extend VQE returned information with additional outputs
result = VQEAdaptResult()
result.combine(vqe_result)
result.num_iterations = iteration
result.final_max_gradient = max_grad[0]
result.finishing_criterion = finishing_criterion
logger.info('The final energy is: %s', str(result.optimal_value.real))
return result
