Wie kann ich den Fortschritt der scipy.optimize-Funktion anzeigen?

Benutze ich scipy.optimize zur Minimierung einer Funktion von 12 Argumente.

Begann ich die Optimierung eine Weile her, und warten noch auf Ergebnisse.

Ist es ein Weg, um Kraft scipy.optimize um Ihren Fortschritt anzuzeigen (wie viel ist schon getan, was sind die aktuellen best-point)?

Kommentar zu dem Problem
Haben Sie überprüft callback - parameter der Minimierung Funktion? Kommentarautor: mg007
Für einen anderen Ansatz, ohne callback, siehe Funcgradmon. Es speichert alle x f g Werte, dann schreiben Sie Sie in eine Datei Plotten. Kommentarautor: denis

InformationsquelleAutor der Frage Roman | 2013-05-24

  1. 25

    Als mg007 vorgeschlagen, einige der scipy.Optimierung der Routinen ermöglichen eine callback-Funktion (leider leastsq jedoch noch nicht möglich im moment). Unten ist ein Beispiel für die Verwendung der "fmin_bfgs" - routine, wo ich benutze eine callback-Funktion, um den aktuellen Wert der Argumente und der Wert der Zielfunktion bei jeder iteration.

    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)

    Die Ausgabe sieht wie folgt aus:

    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

    Mindestens diese Weise können Sie beobachten, wie der Optimierer verfolgt die minimale

    InformationsquelleAutor der Antwort Joel Vroom

  2. 4

    Folgende @Joels Beispiel, es ist eine saubere und effiziente Art und Weise zu tun, die ähnliche Sache. Folgende Beispiel zeigen, wie können wir loswerden global Variablen call_back Funktionen und re-Evaluierung Ziel-Funktion mehrere Male.

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

    Dies erzeugt eine Ausgabe wie 

    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

    Allerdings keine starten, hier habe ich function evaluation times statt algorithmic iteration times als Zähler. Einige algorithmen auswerten dürfen target-Funktion mehrfach in einer einzelnen iteration.

    InformationsquelleAutor der Antwort 刘金国

  3. 3

    Die Minimierung der Funktion benutzt du genau?

    Meisten Funktionen haben Fortschrittsbericht gebaut, darunter mehrere Ebenen der Berichte, die zeigen genau die Daten, die Sie wollen, indem Sie mit der disp flag (siehe zum Beispiel scipy.optimieren.fmin_l_bfgs_b).

    InformationsquelleAutor der Antwort Bitwise

  4. 3

    Versuchen Sie es mit:

    options={'disp': True}

    zwingen scipy.optimize.minimize zum drucken von Zwischenergebnissen.

    InformationsquelleAutor der Antwort user3313382

Schreibe einen Kommentar