Überblick

Verwenden der Bayes'schen Optimierungsbibliothek, Tatsächlich habe ich versucht zu sehen, ob es für ein gutes Gefühl optimiert werden kann.

Die verwendete Bibliothek ist "GPyOpt".

Die folgenden Bücher wurden als Referenz für die Theorie verwendet. "Gauß-Prozess und maschinelles Lernen" (Autor: Daichi Mochihashi, Seisei Ohba)

Überblick über das Experiment

Erstellen Sie eine Zielfunktion und ermitteln Sie ihren Mindestwert (innerhalb des angegebenen Definitionsbereichs) durch Bayes'sche Optimierung. Die detaillierten Einstellungen sind wie folgt. --Bayes Optimization Library: GPyOpt (.methods.BayesianOptimization) --Zielfunktion: 　　　y=f(x)=(x-300)(x-200)(x-15)(x-5)(x+6)(x+10)(x+100)

Optimierungspolitik: Minimierung
Definitionsbereich (x): [-100, 300] --Erfassungsfunktion: EI (erwarteter Verbesserungswert)
Anfangsdaten (x, y): 　　　x = -50 , 0 , 50 , 100 , 150 , 200 , 250 --Kernel: Nicht angegeben. (Die Standardeinstellungen der Bibliothek wurden nicht untersucht.) Dieses Mal werde ich den Kernel beiseite lassen und die Ergebnisse sehen.

Annahme

Buchtenoptimierung Eine Methode zum Ermitteln des Minimalwerts (Maximalwerts) der Zielfunktion unter Verwendung der Gaußschen Prozessregression. Für die Vorhersage (Wahrscheinlichkeitsverteilung) aus der Gaußschen Prozessregression Die Erfassungsfunktion wird angewendet und der Punkt, an dem der Funktionswert maximiert wird, wird als nächster Punkt gesucht.
Rückgabe des Gauß-Prozesses Eine Art Bayes'sche Schätzung. Der Zielfunktionswert $ f (x) $ für jeden Eingabepunkt ($ x $) wird einzeln als Wahrscheinlichkeitsvariable betrachtet. Betrachten Sie $ (f (x_ {1}), f (x_ {2}),…, f (x_ {n}),…) $ als multivariate Normalverteilung $ N (μ, Σ) $.

Erworbene Eingabepunkte 　x_{1} , x_{2} , … , x_{n} Dann wird der Zielfunktionswert (Normalverteilung) des neuen Eingabepunkts $ x_ {n + 1} $ gesetzt. 　f(x_{n+1})　〜　p(　f(x_{n+1})　|　x_{n+1}　,　f(x_{1}) , f(x_{2}) , … 　,f(x_{n})　) Eine Regressionsmethode, die als solche betrachtet wird. 　 Es wird manchmal in Form der Vorhersage des erwarteten Wertes des Zielfunktionswerts (Normalverteilung) verwendet. (Die obige Funktion $ f $ heißt "Gaußscher Prozess".)

Kernel In der Gaußschen Prozessregression $ (f (x_ {1}), f (x_ {2}),…, f (x_ {n}),…) Eine Funktion zum Spezifizieren jeder Komponente der Kovarianzmatrix $ Σ $ von $. Die $ (i, j) $ -Komponente, dh die Kovarianz von $ f (x_ {i}) $ und $ f (x_ {j}) $, hängt von $ x_ {i} $ und $ x_ {j} $ ab Definiert durch die Funktion $ k (x_ {i}, x_ {j}) $ Die Funktion $ k $ heißt "Kernel". Es gibt mehrere häufig verwendete Kernel. Als Grundeigenschaft "Wenn die Eingabepunkte $ x_ {i}, x_ {j} $ nahe sind, dann sind auch $ f (x_ {i}), f (x_ {j}) $ nahe."

Experimentdetails

1. Bibliotheksimport

#[Dokument] https://gpyopt.readthedocs.io/en/latest/index.html
#[Quelle] https://github.com/SheffieldML/GPyOpt/blob/master/GPyOpt/methods/bayesian_optimization.py

#pip install Gpyopt
import GPyOpt

import matplotlib.pyplot as plt
import numpy as np

2. Zielfunktion

#Objektive Funktionsdefinition
def f(x):
    y = (x-300)*(x-200)*(x-15)*(x-5)*(x+6)*(x+10)*(x+100)
    return y

#Definition des Definitionsbereichs
xlim_fr = -100
xlim_to = 300

#Graph
x = [i for i in range(xlim_fr , xlim_to + 1)]
y = [f(_x) for _x in x]

figsize = (10 , 5)
fig , ax = plt.subplots(1 , 1 , figsize=figsize)
ax.set_title('Outline of f')
ax.grid()
ax.plot(x , y)
ax.set_xlim(xlim_fr , xlim_to)
plt.show()

Aus dem Diagramm innerhalb des Definitionsbereichs Es scheint, dass x einen Mindestwert um 270 hat. Stellen Sie sicher, dass die Bayes'sche Optimierung Ihnen diesen Punkt gibt.

3. Anfangsdaten

#Anfangsdaten
init_X = [i for i in range(-50 , 300 , 50)]
init_X_np = np.array(init_X).reshape((len(init_X) , 1))

init_Y = [f(i) for i in init_X]
init_Y_np = np.array(init_Y).reshape((len(init_Y) , 1))

print(len(init_X))
print(len(init_Y))

print(init_X_np[:5])
print(init_Y_np[:5])

#Zeichnen Sie die Position der Anfangsdaten
figsize = (10 , 5)
fig , ax = plt.subplots(1 , 1 , figsize=figsize)
ax.set_title('Outline of f and Initial Data')
ax.grid()
ax.plot(x , y , label="f" , color="y")

#Anfangsdaten
for init_x , init_y in zip(init_X , init_Y):
    ax.plot(init_x , init_y , marker="o" , color="r")

ax.set_xlim(xlim_fr , xlim_to)
plt.show()

Der rote Punkt wird als Anfangsdaten angegeben.

Der Optimierungsfluss ist wie folgt.

(1) Berechnen Sie aus den erfassten Daten die Vorhersage (Wahrscheinlichkeitsverteilung) des f-Wertes im definierten Bereich. (2) Berechnen Sie den Erfassungsfunktionswert aus jeder Vorhersage. (3) Erfassen Sie den Punkt (x), an dem der erfasste Funktionswert maximiert wird, als nächsten Punkt und suchen Sie.

4. Bayesianische Optimierung_Modellinitialisierung

#Definitionsbereich
bounds = [{'name': 'x', 'type': 'continuous', 'domain': (xlim_fr,xlim_to)}]

# X , Y :Anfangsdaten
# initial_design_numdata :Die Anzahl der anfänglichen Daten, die eingestellt werden sollen. X oben,Wenn Y angegeben ist, ist keine Einstellung erforderlich.
# normalize_Y :Zielfunktion(Gaußscher Prozess)Richtig zu standardisieren.(Diesmal False, um den Vergleich der Vorhersage mit dem wahren Wert zu erleichtern)
myBopt = GPyOpt.methods.BayesianOptimization(f=f
                                             , domain=bounds
                                             , X=init_X_np
                                             , Y=init_Y_np
                                             , normalize_Y=False
                                             , maximize=False
                                             #, initial_design_numdata=50
                                             , acquisition_type='EI')

5. Bayesian Optimierungszug

myBopt.run_optimization(max_iter=10)

6. Bayesianische Optimierungsergebnisse / -prozesse

#Optimale Lösung erhalten
x_opt = myBopt.x_opt
fx_opt = myBopt.fx_opt
print("x_opt" , ":" , x_opt)
print("fx_opt" , ":" , fx_opt)

#Optimierungsverlauf
print("X.shape" , ":" , myBopt.X.shape)
print("Y.shape" , ":" , myBopt.Y.shape)

print("-" * 50)
print("X[:5]" , ":")
print(myBopt.X[:5])
print("-" * 50)
print("Y[:5]" , ":")
print(myBopt.Y[:5])

7. Prediction_Graphing

#Gaußsches Prozessregressionsmodell
model = myBopt.model.model

#Vorhersage (erste Komponente: Mittelwert, zweite Komponente: std)
np_x = np.array(x).reshape(len(x) , 1)
pred = model.predict(np_x)

model.plot()
myBopt.plot_acquisition()

model.plot()
plt.plot(x , y , label="f" , color="y")
plt.plot(x_opt , fx_opt , label="Optimal solution" , marker="o" , color="r")
plt.xlim(xlim_fr , xlim_to)
plt.legend()
plt.grid()
plt.title("f of True & Predict")
plt.show()

Der rote Punkt im dritten Diagramm ist die optimale Lösung. In der Grafik wurde der Mindestwert richtig gefunden.

Zusammenfassung

(Abgesehen von detaillierten Fehlern) Durch die Bayes'sche Optimierung konnten wir tatsächlich den Mindestwert finden.

Diesmal jedoch als Ausgangsdaten, Es hat einen Wert nahe der optimalen Lösung (Mindestwert) von $ x = 250 $. Das hat möglicherweise die Optimierung erleichtert.

Wenn die Anfangsdaten "nur Daten von der optimalen Lösung entfernt" sind Möglicherweise müssen Sie die Anzahl der Versuche erhöhen.

[PYTHON] Ich habe die Bayes'sche Optimierung ausprobiert!