[PYTHON] 3. Normalverteilung mit neuronalem Netz!
Einführung
Dies ist der dritte in der Reihe.
Letztes Mal haben wir bestätigt, dass das neuronale Netzwerk trainiert werden kann, um den Durchschnitt und die Standardabweichung von 10 gegebenen Zahlen auszugeben.
Dieses Mal werde ich Normalverteilungsdaten geben und testen, ob es trainiert werden kann, die drei Parameter auszugeben, die der Normalverteilung zugrunde liegen.
Normalverteilung
Die Normalverteilung besteht nur aus drei Parametern. Hier sind die drei Parameter µ, σ und k.
- µ ist die x-Koordinate der Mittelachse der Normalverteilung
- σ ist ein Maß dafür, wie breit die Normalverteilung ist
- k ist die Vergrößerung, um wie viel sich in vertikaler Richtung ausdehnen soll
Die allgemeine Formel für die Normalverteilung lautet
y=k \times\frac{1}{\sqrt{2\pi\sigma^2}}exp{\left(-\frac{
(x - \mu)^2
}{
2\sigma^2
}\right)}
ist. Wenn Sie sich die Formel ansehen, sehen Sie die Bedeutung der drei Parameter (zumindest für k und µ). Stellen Sie diesen Ausdruck in Python zur Verfügung.
3-001.py
import math
#Definieren Sie die Funktion f.
f = lambda x,mu,sigma,k: k * (math.exp(-(x - mu)**2/2/sigma**2)) / math.sqrt(2*math.pi*sigma**2)
Generierung von Trainingsdaten
Ich habe beschlossen, 50.000 Daten wie folgt zu generieren. Die drei Parameter sind Zufallswerte mit einem Bereich wie unten gezeigt.
- x-Koordinate von 0 bis 10,
- σ von 0,1 bis 2
- µ von 3 bis 7
- k von 0,5 bis 10
Teilen wir zunächst die x-Koordinate zwischen 0 und 10 in 100 und erstellen ein ndarray.
3-002.py
import numpy as np
n = np.linspace(0, 10, 100)
Lassen Sie uns eine Wellenform erstellen, damit das Bild herauskommt. Es gibt keinen besonderen Grund, aber ich habe versucht, µ = 3, σ = 1 und k = 5 einzustellen.
3-003.py
import matplotlib.pyplot as plt
exampleData = []
for i in range(len(n)):
exampleData.append(f(n[i],3, 1, 5))
plt.title("Example of normal distribution")
plt.scatter(n, exampleData,label = "µ=3, σ=1, k=5",marker='.', s=20,alpha=1)
plt.legend(fontsize=14) #Legende anzeigen
plt.xlabel("x")
plt.ylabel("y")
plt.show()
100 numerische Daten werden in NN geworfen. Ich habe hier ein Streudiagramm verwendet, damit ich sehen kann, dass es sich um diskrete Daten handelt.
Lassen Sie uns nun die Daten generieren, die tatsächlich für das Training verwendet werden. Erstellen Sie zwei Listen, um die Trainingsdaten und die richtigen Antwortdaten zu speichern.
3-004.py
p = []
y = []
for kkk in range(50000):
mu1 = np.random.rand()*4 + 3 #Bestimmen Sie den Wert nach dem Zufallsprinzip. 3 bis 7
si1 = np.random.rand()*1.9 + 0.1 #Bestimmen Sie den Wert nach dem Zufallsprinzip. 0.von 1 bis 2
k1 = np.random.rand()*9.5 + 0.5 #Bestimmen Sie den Wert nach dem Zufallsprinzip. 0.5 bis 10
y .append(mu1)#Notieren Sie die richtigen Antwortdaten
y .append(si1)#Notieren Sie die richtigen Antwortdaten
y .append(k1)#Notieren Sie die richtigen Antwortdaten
for i in range(len(n)):
p.append(f(n[i],mu1, si1, k1))#Übergeben Sie den x-Koordinatenwert und drei Parameter an die definierte Funktion f und speichern Sie den Rückgabewert in der Liste p.
Ändern Sie die Liste in ndarray und ändern Sie dann die Form, um sie in das NN zu werfen.
3-005.py
#Machen Sie es zu einem ndarray und ändern Sie die Form.
t = np.array(p)
t = t.reshape(50000,len(n))
label = np.array(y)
label = label.reshape(50000,3)
Teilen Sie die Daten in die erste Hälfte 40000 und die zweite Hälfte 10000. Die erste Hälfte dient dem Training und die zweite Hälfte der Bewertung.
3-006.py
#Training in der ersten Hälfte 40.000. Bewertet in der zweiten Hälfte 10000.
d_training_x = t[:40000,:]
d_training_y = label[:40000,:]
d_test_x = t[40000:,:]
d_test_y = label[40000:,:]
NN-Design mit Keras
Ich weiß nicht, ob das Folgende optimal ist, aber ich habe 5 vollständig verbundene Schichten verbunden. Reduzieren Sie schrittweise die Anzahl der Ausgänge, sodass am Ende 3 Zahlen ausgegeben werden.
3-007.py
import keras
from keras.models import Sequential
from keras.layers import Dense
from keras.optimizers import Adam
batch_size = 128 #Trainieren Sie jeweils 128 Trainingsdaten
epochs = 20 #Wie viele Runden, um Trainingsdaten zu lernen
model = Sequential()
model.add(Dense(100, activation='linear', input_shape=(len(n),)))
model.add(Dense(100, activation='tanh'))
model.add(Dense(40, activation='linear'))
model.add(Dense(20, activation='tanh'))
model.add(Dense(3, activation='linear'))
#Probabilistischer Gradientenabstieg Adam
optimizer = Adam(lr=0.001, beta_1=0.9, beta_2=0.999)
#Verlustfunktion im Quadrat durchschnittlicher Fehler
model.compile(loss='mean_squared_error',optimizer=optimizer)
model.summary()##Überprüfen Sie die Form von NN
Ausbildung
Das Training hat begonnen. Der Rückgabewert von fit () wird in der Variablenhistorie gespeichert und der Lernfortschritt wird später grafisch dargestellt.
3-008.py
#Lernen
history = model.fit(d_training_x, d_training_y,
batch_size=batch_size,
epochs=100,
verbose=1,# verbose..Redundant, gesprächig
validation_data=(d_test_x, d_test_y))
Visualisierung des Lernens
Lassen Sie uns grafisch darstellen, wie das Lernen fortgeschritten ist.
3-009.py
#Zeichnen eines Diagramms
import matplotlib.pyplot as plt
plt.plot(history.history['val_loss'], label = "val_loss")
plt.plot(history.history['loss'], label = "loss")
plt.legend() #Legende anzeigen
plt.title("Can NN learn to calculate normal distribution?")
plt.xlabel("epoch")
plt.ylabel("Loss")
plt.show()
Der Verlust der vertikalen Achse ist der Fehler der Quadratsumme, wie unterschiedlich die richtigen Antwortdaten und die Ausgabedaten von der NN sind. Es werden zwei Diagramme aufgezeichnet: Verlust für die für das Training verwendeten Daten und val_loss bei Vorhersage anhand der Bewertungsdaten.
Bewertung von NN
Geben wir dem trainierten NN Bewertungsdaten.
3-010.py
#Geben Sie dem trainierten NN Daten
inp = d_test_x[:200,:]
out = d_test_y[:200,:]
pred = model.predict(inp, batch_size=1)
Lassen Sie uns die Ausgabe grafisch darstellen.
3-011.py
plt.title("Can NN learn to calculate normal distribution?")
plt.scatter(out[:,0], pred[:,0],label = "µ",marker='.', s=20,alpha=0.3)
plt.scatter(out[:,1], pred[:,1],label = "σ",marker='.', s=20,color="green",alpha=0.3)
plt.scatter(out[:,2], pred[:,2],label = "k",marker='.', s=20,color="red",alpha=0.3)
plt.legend(fontsize=14) #Legende anzeigen
plt.xlabel("expected value")
plt.ylabel("prediction")
plt.show()
Sie können sehen, dass der richtige Antwortwert und die Ausgabe von NN ziemlich nahe beieinander liegen. Mit anderen Worten, ich konnte richtig lernen.
Zusammenfassung
Es ist schwer zu erkennen, da es sich überlappt, aber alle drei Parameter werden ziemlich korrekt ausgegeben. Es ist fertig! Vorbereitung der ersten Serie Serie 2. Durchschnitt und Standardabweichung Serie 3. Normalverteilung Serie 4. Yen
Recommended Posts