web-dev-qa-db-fra.com

Comment afficher la progression de la fonction scipy.optimize?

J'utilise scipy.optimize pour minimiser une fonction de 12 arguments.

J'ai commencé l'optimisation il y a quelque temps et j'attends toujours les résultats.

Existe-t-il un moyen de forcer scipy.optimize pour afficher sa progression (comme combien est déjà fait, quel est le meilleur point actuel)?

pythonnumpyscipyoutputmathematical-optimization
40
Roman

Comme suggéré par mg007, certaines des routines scipy.optimize permettent une fonction de rappel (malheureusement, lesssq ne le permet pas pour le moment). Voici un exemple utilisant la routine "fmin_bfgs" où j'utilise une fonction de rappel pour afficher la valeur actuelle des arguments et la valeur de la fonction objectif à chaque itération.

import numpy as np
from scipy.optimize import fmin_bfgs

Nfeval = 1

def rosen(X): #Rosenbrock function
    return (1.0 - X[0])**2 + 100.0 * (X[1] - X[0]**2)**2 + \
           (1.0 - X[1])**2 + 100.0 * (X[2] - X[1]**2)**2

def callbackF(Xi):
    global Nfeval
    print '{0:4d}   {1: 3.6f}   {2: 3.6f}   {3: 3.6f}   {4: 3.6f}'.format(Nfeval, Xi[0], Xi[1], Xi[2], rosen(Xi))
    Nfeval += 1

print  '{0:4s}   {1:9s}   {2:9s}   {3:9s}   {4:9s}'.format('Iter', ' X1', ' X2', ' X3', 'f(X)')   
x0 = np.array([1.1, 1.1, 1.1], dtype=np.double)
[xopt, fopt, gopt, Bopt, func_calls, grad_calls, warnflg] = \
    fmin_bfgs(rosen, 
              x0, 
              callback=callbackF, 
              maxiter=2000, 
              full_output=True, 
              retall=False)

La sortie ressemble à ceci:

Iter    X1          X2          X3         f(X)      
   1    1.031582    1.062553    1.130971    0.005550
   2    1.031100    1.063194    1.130732    0.004973
   3    1.027805    1.055917    1.114717    0.003927
   4    1.020343    1.040319    1.081299    0.002193
   5    1.005098    1.009236    1.016252    0.000739
   6    1.004867    1.009274    1.017836    0.000197
   7    1.001201    1.002372    1.004708    0.000007
   8    1.000124    1.000249    1.000483    0.000000
   9    0.999999    0.999999    0.999998    0.000000
  10    0.999997    0.999995    0.999989    0.000000
  11    0.999997    0.999995    0.999989    0.000000
Optimization terminated successfully.
         Current function value: 0.000000
         Iterations: 11
         Function evaluations: 85
         Gradient evaluations: 17

Au moins de cette façon, vous pouvez regarder l'optimiseur suivre le minimum

29
Joel Vroom

En suivant l'exemple de @ joel, il existe un moyen soigné et efficace de faire la même chose. L'exemple suivant montre comment se débarrasser des variables global, call_back fonctions et réévaluation de la fonction cible plusieurs fois.

import numpy as np
from scipy.optimize import fmin_bfgs

def rosen(X, info): #Rosenbrock function
    res = (1.0 - X[0])**2 + 100.0 * (X[1] - X[0]**2)**2 + \
           (1.0 - X[1])**2 + 100.0 * (X[2] - X[1]**2)**2


    # display information
    if info['Nfeval']%100 == 0:
        print '{0:4d}   {1: 3.6f}   {2: 3.6f}   {3: 3.6f}   {4: 3.6f}'.format(info['Nfeval'], X[0], X[1], X[2], res)
    info['Nfeval'] += 1
    return res

print  '{0:4s}   {1:9s}   {2:9s}   {3:9s}   {4:9s}'.format('Iter', ' X1', ' X2', ' X3', 'f(X)')   
x0 = np.array([1.1, 1.1, 1.1], dtype=np.double)
[xopt, fopt, gopt, Bopt, func_calls, grad_calls, warnflg] = \
    fmin_bfgs(rosen, 
              x0, 
              args=({'Nfeval':0},), 
              maxiter=1000, 
              full_output=True, 
              retall=False,
              )

Cela va générer une sortie comme

Iter    X1          X2          X3         f(X)     
   0    1.100000    1.100000    1.100000    2.440000
 100    1.000000    0.999999    0.999998    0.000000
 200    1.000000    0.999999    0.999998    0.000000
 300    1.000000    0.999999    0.999998    0.000000
 400    1.000000    0.999999    0.999998    0.000000
 500    1.000000    0.999999    0.999998    0.000000
Warning: Desired error not necessarily achieved due to precision loss.
         Current function value: 0.000000
         Iterations: 12
         Function evaluations: 502
         Gradient evaluations: 98

Cependant, pas de lancement gratuit, ici j'ai utilisé function evaluation times au lieu de algorithmic iteration times comme compteur. Certains algorithmes peuvent évaluer la fonction cible plusieurs fois en une seule itération.

8
刘金国

Essayez d'utiliser:

options={'disp': True}

forcer scipy.optimize.minimize pour imprimer les résultats intermédiaires.

6
Yan

Quelle fonction de minimisation utilisez-vous exactement?

La plupart des fonctions ont un rapport d'avancement construit, y compris plusieurs niveaux de rapports montrant exactement les données que vous souhaitez, en utilisant l'indicateur disp (par exemple voir scipy.optimize.fmin_l_bfgs_b ).

3
Bitwise

Voici une solution qui fonctionne pour moi:

def f_(x):   # The rosenbrock function
    return (1 - x[0])**2 + 100 * (x[1] - x[0]**2)**2

def conjugate_gradient(x0, f):
    all_x_i = [x0[0]]
    all_y_i = [x0[1]]
    all_f_i = [f(x0)]
    def store(X):
        x, y = X
        all_x_i.append(x)
        all_y_i.append(y)
        all_f_i.append(f(X))
    optimize.minimize(f, x0, method="CG", callback=store, options={"gtol": 1e-12})
    return all_x_i, all_y_i, all_f_i

et par exemple:

conjugate_gradient([2, -1], f_)

Source

0
Camille Moatti