Wrapper function `optimize(...)`

[Giannis1993]

This is an issue to discuss the structure of this wrapper function. I think there could be some improvements on the initilializations/imports, but I did not want to use from somewhere import * which would make things simpler. My proposal would be to implement something as follows:

def optimize(problem, solver, approximation, criterion, *args, **kwargs):
    """
    This is a wrapper function for the main file of an optimization.
    Takes as arguments the following objects and performs the optimization main loop.

    :param problem: An object that holds the initial problem to be solved.
    :param solver: An object that holds the solver to be used.
    :param approximation: An object that holds the approximation (and the intervening vars) to be used, e.g. Taylor1(Linear())
    :param criterion: An object that holds the convergence criterion.
    :param args:
    :param kwargs:
    :return:
    """

    logger.info("Solving test_poly using y=MMA and solver=Ipopt Svanberg")

    # Instantiate the subproblem       # TODO: improve imports (didn't want to use import *)
    subproblem = sao.problems.subproblem.Subproblem(approximation=approximation)
    subproblem.set_limits([sao.move_limits.Bounds(prob.xmin, prob.xmax),
                           sao.move_limits.MoveLimit(move_limit=0.1, dx=prob.xmax - prob.xmin)])

    # Initialize design and iteration counter
    x_k = kwargs.get('x0', prob.x0)
    itte = 0

    # Optionally, instantiate plotter           # TODO: Change the 'criterion' to f'{criterion.__class__.__name__}'
    plot_flag = kwargs.get('plot', False)
    if plot_flag:
        plotter = sao.util.Plot(['objective', 'constraint', 'criterion', 'max_constr_violation'], path=".")

    # Optimization loop
    while not criterion.converged:

        # Evaluate responses and sensitivities at current point, i.e. g(X^(k)), dg(X^(k)), ddg(X^(k))
        f = problem.g(x_k)
        df = problem.dg(x_k)
        ddf = (prob.ddg(x_k) if subproblem.approx.__class__.__name__ == 'Taylor2' else None)

        # Build approximate sub-problem at X^(k)
        subproblem.build(x_k, f, df, ddf)

        # Call solver (x_k, g and dg are within approx instance)
        x_k, y, z, lam, xsi, eta, mu, zet, s = solver.subsolv(subproblem)

        # Print & Plot              # TODO: Print and Plot the criterion as criterion.value (where 0 is now)
        logger.info(
            'iter: {:^4d}  |  x: {:<10s}  |  obj: {:^9.3f}  |  criterion: {:^6.3f}  |  max_constr_viol: {:^6.3f}'.format(
                itte, np.array2string(x_k[0]), f[0], 0, max(0, max(f[1:]))))

        if plot_flag:
            plotter.plot([f[0], f[1], 0, max(0, max(f[1:]))])        # TODO: Add functionality to (optionally) plot criterion.value

        itte += 1

    logger.info('Optimization loop converged!')

and would be used as:

def main():
    """
    This is an example where the optimizer wrapper function is used.
    The result should be equivalent to that of `example_polynomial_2D().`

    :return:
    """

    # Instantiate problem, solver, approximation and convergence criterion
    problem = Polynomial2D()
    solver = SvanbergIP(prob.n, prob.m)
    approximation = Taylor2(Linear())
    x_k = np.array([2, 1.5])
    criterion = VariableChange(x_k)

    # Call wrapper function that includes the main optimization loop
    optimize(problem, solver, approximation, criterion, x0=x_k, plot_flag=True)

[MaxvdKolk]

Looks good! Some remarks:

• We can pass the plotter as an optional argument too. In that case, the loop can check for if plotter: plotter.plot(...) and it does not have to be setup within this defined loop? If we want a wrapper routine that also plots, my suggestion would be to include a optimize_and_show (or something like that) that does automatically do the plotting.

  • The imports can be done either in the function or the file that defines this wrapper. There seem to be not so many that are needed, only Subproblem, Bounds, and MoveLimit right?

  • Not sure if we need to use the short hands for some variable names, e.g. problem vs prob, approximation vs approx.

• We can probably improve this line: ddf = (prob.ddg(x_k) if subprob.approx.__class__.__name__ == 'Taylor2' else None) to use isinstance(Taylor2) or in another way such that this check is not needed.

• The return arguments for the current solver do not work for all solvers I think, it might be better to write as x_k, _ = ...? For this we might need to unify/clarify the subsolver return arguments.

[Giannis1993]

Implemented Max's feedback and added it to #88. Closing this issue.