Vorwort

Beim letzten Mal gibt es einen Artikel. Bayes-Optimierung mit Python sehr einfach

Wenn Sie die Probenahme für eine lange Zeit fortsetzen können, aber anhalten möchten, wenn ein bestimmter Auswertungswert erreicht ist, müssen Sie ihn mit dem in scikit-optimize bereitgestellten Rückruf stoppen, da er sonst nicht stoppt, bis die angegebene Anzahl von Probenahmen abgeschlossen ist. Hmm. Wenn Sie den Prozess beenden, wird er gestoppt, aber Sie können die Ergebnisse bis zu diesem Zeitpunkt nicht empfangen und verarbeiten.

Daher möchte ich scikit-optimize.callbacks.EarlyStopper verwenden, um die Optimierung unter allen Umständen zu unterbrechen, aber dieser EarlyStopper wird nicht im Detail erklärt. Es heißt, es in help () zu sehen, aber es wird auf der gleichen Ebene wie der unten stehende Link angezeigt.

In diesem Artikel möchte ich aufzeichnen, wie man es auf Japanisch verwendet.

skopt.callbacks.EarlyStopper

In [0]:from skopt.callbacks import EarlyStopper
In [1]:help(EarlyStopper)
Help on class EarlyStopper in module skopt.callbacks:

class EarlyStopper(builtins.object)
 |  Decide to continue or not given the results so far.
 |  
 |  The optimization procedure will be stopped if the callback returns True.
 |  
 |  Methods defined here:
 |  
 |  __call__(self, result)
 |      Parameters
 |      ----------
 |      result : `OptimizeResult`, scipy object
 |          The optimization as a OptimizeResult object.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)

Vollständiger Quellcode

Da es auch in Letztes Mal erklärt wird, werde ich es durch einen Auszug aus dem geänderten Teil erklären.

import numpy as np
from skopt import gp_minimize
from skopt.callbacks import EarlyStopper

class Stopper(EarlyStopper):
    def __call__(self, result):
        ret = False
        if result.fun < -1.0:
            ret = True
        return ret

def func(param=None):
    ret = np.cos(param[0] + 2.34) + np.cos(param[1] - 0.78)
    return -ret

if __name__ == '__main__':
    x1 = (-np.pi, np.pi)
    x2 = (-np.pi, np.pi)
    x = (x1, x2)
    result = gp_minimize(func, x, 
                          n_calls=30,
                          noise=0.0,
                          model_queue_size=1,
                          callback=[Stopper()],
                          verbose=True)

EarlyStopper-Vererbungsklasse

from skopt.callbacks import EarlyStopper

class Stopper(EarlyStopper):
    def __call__(self, result):
        ret = False
        if result.fun < -1.0:
            ret = True
        return ret

Irgendwie konnte ich es vorhersagen, aber ich beschloss, es zu erben und selbst zu implementieren. Deshalb habe ich EarlyStopper importiert und meinen eigenen Stopper hergestellt. Ich kenne den Konstruktor nicht, muss ihn aber nicht überschreiben. Alles was Sie tun müssen, ist __call__ zu überschreiben. Zu diesem Zeitpunkt wird das Argument "Ergebnis" in "call" angegeben, aber das neueste "Ergebnis" wird jedes Mal während der Optimierung übergeben. Dieses Mal habe ich in diesem "Ergebnis" auf das Mitglied "fun" verwiesen. Wenn dieser Wert kleiner als -1,0 ist, wird True zurückgegeben, andernfalls wird False zurückgegeben. ** Wenn dieses __call__ True zurückgibt, wird es unterbrochen, und wenn es False ist, wird es fortgesetzt. ** ** **

Auf gp_minimize setzen

    result = gp_minimize(func, x, 
                          n_calls=30,
                          noise=0.0,
                          model_queue_size=1,
                          callback=[Stopper()],
                          verbose=True)

Übergeben Sie eine Instanz der Stopper-Klasse an das Argument "Rückruf", das nicht in [Letztes Mal] festgelegt wurde (https://qiita.com/saiaron/items/997b330c0e77d6a18f1f). Zu diesem Zeitpunkt besteht der Grund für die Übergabe von List darin, dass mehrere Rückrufe akzeptiert werden können. Übergeben Sie auch nur eine als Liste. Davon abgesehen ist es dasselbe wie beim letzten Mal. Damit sollte die Anzahl der Proben 30 oder weniger betragen, aber natürlich hört es nicht auf, es sei denn, es erreicht den Schwellenwert von -1,0.

Das Problem ist jedoch zu einfach, daher ist es definitiv cool.

Ergebnis

Iteration No: 1 started. Evaluating function at random point.
Iteration No: 1 ended. Evaluation done at random point.
Time taken: 0.0000
Function value obtained: -0.9218
Current minimum: -0.9218
Iteration No: 2 started. Evaluating function at random point.
Iteration No: 2 ended. Evaluation done at random point.
Time taken: 0.0000
Function value obtained: 0.9443
Current minimum: -0.9218
Iteration No: 3 started. Evaluating function at random point.
Iteration No: 3 ended. Evaluation done at random point.
Time taken: 0.0000
Function value obtained: 1.6801
Current minimum: -0.9218
Iteration No: 4 started. Evaluating function at random point.
Iteration No: 4 ended. Evaluation done at random point.
Time taken: 0.0000
Function value obtained: -0.0827
Current minimum: -0.9218
Iteration No: 5 started. Evaluating function at random point.
Iteration No: 5 ended. Evaluation done at random point.
Time taken: 0.0000
Function value obtained: -1.1247
Current minimum: -1.1247
Iteration No: 6 started. Evaluating function at random point.

Die Bewertungswerte lagen bei der 5. Stichprobe unter -1,1247 und -1,0, daher hörte ich auf, die 6. Stichprobe durchzuführen. Erfolg. Nun, ich habe es auf eine Schwelle gesetzt, die definitiv erwischt werden würde ...

Serpentin

Es gibt verschiedene andere Rückrufe in "scikit-optimize", aber wenn es unter keinen Umständen ** wird, gibt es nur diesen "Early Stopper". Ich denke also, dass dieser "EarlyStopper" der einzige ist, der wahrscheinlich von selbst geerbt und implementiert werden muss. Andere sollten auf die gleiche Weise wie diesmal festgelegt werden können, wenn Sie die Parameter beim Erstellen der Instanz festlegen. Ich benutze es nicht, weil es schwer zu verstehen ist, woran ich denken soll ...

skopt.callbacks