[RFC] add a callback function

[jschueller]

for scipy integration we should be able to pass an optional callback function to report at least the current best x/f values

subroutine CALLBACK(x, f)
    use consts_mod, only : RP
    implicit none
    real(RP), intent(in) :: bestx(:)
    real(RP), intent(in) :: bestf
    integer(RK), intent(out) :: stop
end subroutine CALLBACK

I propose it could also to cancel the minimization (or via the objective function) according to a "stop" argument (and add a new return code for this):

I dont know if there are other useful stuff we want to track, like the number of evaluations ...

in C it is usual to pass an additional pointer argument to hook back to struct/data:

typedef int (*cbfunc)(unsigned n, const double *bestx, conda double bestf, void *func_data);

see the "callback" argument of minimize:
https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.minimize.html

could also be useful for nlopt:
stevengj/nlopt#37

[zaikunzhang]

Thank you @jschueller . Could we ask the SciPy people what is the standard / preferred signature of this callback function, e.g., at scipy/scipy#18118 (comment) ? Thanks.

[jschueller]

seems they only report x:
https://github.com/scipy/scipy/blob/main/scipy/optimize/cobyla/cobyla.pyf#L11C9-L15C32

[zaikunzhang]

I am copying from #69 (comment)

The first question that we have to discuss is as follows. In callback(x, f, terminate, [, other inputs]), what do we want x and f to be? There are two possibilities.

• x is the current best point and f is its function value
• x is the most recently evaluated point and f is its function value

Another possibility is to change the signature of the callback function to callback(xnew, fnew, xbest, fbest, terminate, ...) to include both of them.

In addition,

• for lincona, we must include cstrv (constraint violatio) as an input to callback,
• for cobyla, we must include both cstrv and constr.

Insights from SciPy maintainers are greatly needed.

Thanks.

[zaikunzhang]

Comments by @andyfaff copied from the SciPy issue.

The design of the callback is made easier if the Fortran code can be stepped through as an iterator. i.e. Python takes control of the solve, possibly supplying things (e.g. func/grad evalutions) to the solver. It's best to have as much logic in Python as possible, Fortran as a whole is difficult to maintain.

For example, the core of differential_evolution is something akin to the following:

def solve(self):
    for i in range(numiters):
        if converged:
            # return final result
        else:
            result = next(self)


def __next__(self):
    # call the external code to take one solve step, fortran returns interesting things.
    x, fun, etc = make_fortran_step()

    # make intermediate result
    im_result = OptimizeResult(x=x, fun=fun)

    # call callback
    callback(intermediate_result=im_result)
    return im_result

L-BFGS-B/SLSQP kind of follow this pattern, and could be made cleaner in that regard.

Modern callbacks are being designed to return an intermediate OptimizeResult. See the docstring for minimize. The intermediate result should be filled out with as much information that makes sense to offer to the user.

[jschueller]

with the new callback we can do something similar as you get the new optimum, and if the point is good enough you can decide to continue or to stop

[nbelakovski]

This was resolved in #113, recommend we close this issue.