add termination callback to SPSA

[peendebak]

Summary

The SPSA optimizer is suitable for noisy optimization if evaluation of the cost function is expensive. The current implementation terminates after the maximum number of iterations, even if the optimizer already converged to a local optimum.

This PR adds a callback termination_callback that can be implemented by the user to abort the optimization.

An example:

from qiskit.algorithms.optimizers import SPSA
import numpy as np

def objective(x, a=2):
    objective.n=objective.n+1
    return (x[0]-a)**2 + 4*(x[1])**2 + .01*np.random.rand()

class AverageDecreaseTermination:
    
    def __init__(self, N : int, tolerance :  float = 0):
        """ Callback to terminate optmization when the average decrease over the last N data points is smaller than the specified tolerance """ 
        self.N = N
        self.tolerance = tolerance
        self.values = []
    
    def __call__(self, parameters, value) -> bool:
        """ 
        Returns:
            True if the optimization loop should be aborted 
        """
        self.values.append(value)
        
        if len(self.values)>self.N:
            last_values = self.values[-self.N:]
            pp=np.polyfit(range(self.N), last_values, 1)
            slope=pp[0] / self.N 
            
            #print(f'AverageDecreaseTermination: slope {slope}')
            if slope>self.tolerance:
                return True
        return False
    
# SPSA optimization       
objective.n=0
optimizer = SPSA()
point, value, iterations = optimizer.optimize(2, objective, initial_point = (.75,0))
print(f'point {point}, value {value}, iterations {iterations}, objective evaluations {objective.n}')


# SPSA optimization with early abort
objective.n=0
termination_callback = AverageDecreaseTermination(8)
optimizer = SPSA(termination_callback=termination_callback)
point, value, iterations = optimizer.optimize(2, objective, initial_point = (1.5,0))
print(f'point {point}, value {value}, iterations {iterations}, objective evaluations {objective.n}')

Details and comments

For noisy optimization a simple termination criterium such as a tolerance on decrease of the objective function is not suitable. For this reason a callback is specified so that the user can choose which termination criterium to use.

To keep the number of objective evaluations as low as possible, the internal evaluations of the loss function have been used to provide an estimate of the objective value.

[Cryoris]

That's an interesting addition 👍🏻 could you make sure that QN-SPSA (which derives from SPSA) is adjusted accordingly and that the termination callback is included in the settings?

[peendebak]

@Cryoris Addressed the review comments

[woodsp-ibm]

An ability to allow SPSA to stop ahead of max iters has often asked for more than once but finding suitable criteria was not so easy. This seems like a neat way to address that!

[woodsp-ibm]

@nonhermitian I know you had commented in the past about terminating SPSA prior to max iters and there was an issue at one point. I believe you mentioned some thoughts around heuristics for termination. Do you think this mechanism can cater to what you had in mind?

[nonhermitian]

It looks like it can be quite generic so yeah I would think so.

It was hard to find a reliable way to terminate, but this would allow further exploration of that.

[woodsp-ibm]

LGTM. Thanks for this contribution - for the idea, improving the optimizers with it, and for your patience/effort in sorting out all the comments and suggestions to complete this.

[Cryoris]

Thanks for the effort @peendebak!