python - roots - ¿Cómo mostrar el progreso de la función scipy.optimize?

scipy.optimize python

Question

Uso scipy.optimize para minimizar una función de 12 argumentos.

Comencé la optimización hace un tiempo y aún esperaba resultados.

¿Hay alguna manera de forzar scipy.optimize para que muestre su progreso (como cuánto se ha hecho, cuál es el mejor punto actual)?

Answer 1

¿Qué función de minimización estás usando exactamente?

La mayoría de las funciones tienen un informe de progreso incorporado, que incluye varios niveles de informes que muestran exactamente los datos que desea, utilizando el indicador disp (por ejemplo, consulte scipy.optimize.fmin_l_bfgs_b ).

Answer 2

Como sugirió mg007, algunas de las rutinas scipy.optimize permiten una función de devolución de llamada (desafortunadamente, leastsq no permite esto en este momento). A continuación se muestra un ejemplo utilizando la rutina "fmin_bfgs" donde utilizo una función de devolución de llamada para mostrar el valor actual de los argumentos y el valor de la función objetivo en cada iteración.

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 salida se ve así:

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

Al menos de esta manera puede ver como el optimizador rastrea el mínimo

Answer 3

Intenta usar:

options={''disp'': True}

para forzar scipy.optimize.minimize para imprimir resultados intermedios.

Answer 4

Siguiendo el ejemplo de @ joel, hay una forma ordenada y eficiente de hacer algo similar. El siguiente ejemplo muestra cómo podemos deshacernos de global variables global , call_back funciones call_back y la reevaluación de la función objetivo varias veces .

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,
)

Esto generará resultados como

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

Sin embargo, no hay lanzamiento libre, aquí utilicé function evaluation times lugar de function evaluation times de algorithmic iteration times como contador. Algunos algoritmos pueden evaluar la función objetivo varias veces en una única iteración.