[PYTHON] 2. Mittelwert und Standardabweichung beim neuronalen Netz!

Einführung

Dies ist der zweite in der Reihe. Ist es möglich, ein neuronales Netzwerk (NN) zu trainieren, um den Durchschnitt einiger gegebener numerischer Daten auszugeben? Und was ist mit der Standardabweichung? Machen wir das.

Die Probleme, die NN lernen kann, sind grob in "Klassifizierungsprobleme" und "Rückgabeprobleme" unterteilt. Diesmal entspricht es dem "Rückgabeproblem".

Politik

1. Geben Sie dem neuronalen Netzwerk 10 (feste) Zufallszahlen.
2. Berechnen Sie den Durchschnitt von 10 Zahlen und die Standardabweichung.
3. Geben Sie dem von Keras erstellten NN 10 Zahlen sowie deren Durchschnitt und Standardabweichung als Trainingsdaten an.
4. Die Anzahl der NN-Ausgänge beträgt 2 (2 für "Mittelwert" und "Standardabweichung").
5. Bewerten Sie nach dem Training des NN die Leistung des trainierten NN anhand eines Datensatzes, der nicht für das Training verwendet wurde.

Machen wir das. Im Allgemeinen ist es schwierig, Trainingsdaten für das NN-Training vorzubereiten, aber diesmal ist es einfach, sie vorzubereiten.

Vorbereitung der Trainingsdaten

Vorerst habe ich beschlossen, 50.000 Trainingsdatensätze vorzubereiten. Ein Satz besteht aus 10 Zahlen. Die 10 Zahlen sind 10 Zufallszahlen, die den Verteilungsdaten von Mittelwert a und Standardabweichung b unter Verwendung der Zufallsnormalen von numpy (a, b, 10) folgen, aber hier sind auch a und b selbst Es wird von random.rand () von numpy generiert.

Berechnen Sie "10 Zahlen" und "Durchschnitt und Standardabweichung dieser" und speichern Sie sie zuerst in der Liste.

001.py

import numpy as np
trainDataSize = 50000 #Anzahl der zu erstellenden Datensätze
dataLength = 10 #Anzahl der Daten pro Satz
d = []#Füllen Sie jeweils 10 leere Listen aus.
average_std = []#Die zweite leere Liste. Geben Sie zwei Zahlen gleichzeitig ein.
for num in range(trainDataSize):
	xx = np.random.normal(np.random.rand(),np.random.rand(),dataLength)
	average_std.append(np.mean(xx))
	average_std.append(np.std(xx))
	d.append(xx)

Wenn Sie eine Liste mit allen 50000 Sätzen haben, konvertieren Sie sie erneut in ndarray.

002.py

d = np.array(d) #Mach es zu einem Ndarray.
average_std = np.array(average_std)#Mach es zu einem Ndarray.

Der Grund, warum ich ndarray von Anfang an nicht benutze, ist, dass es langsam ist.

002.py

#Schlechter Code. Weil es spät ist.
d = np.array([])#Leeres Numpy-Array
for num in range(trainDataSize):
	xx = np.random.normal(np.random.rand(),np.random.rand(),dataLength)
	d = np.append(d,xx) #Dieser Prozess ist langsam!

Das erstellte ndarray ist dasjenige, in dem numerische Daten der Reihe nach geworfen werden. Ändern Sie nun die Form der Matrix.

003.py

d = d.reshape(50000,10)
average_std = average_std.reshape(50000,2)

Teilen Sie den 50000-Datensatz in zwei, 40000 Sätze für das Training und 10000 Sätze für die Auswertung. Da wir diesmal keine Hyperparameter berücksichtigen, werden wir uns dazu entschließen, diese in zwei Teile zu teilen.

004.py

#Training in der ersten Hälfte 40.000. Bewertet in der zweiten Hälfte 10000.
d_training_x = d[:40000,:]
d_training_y = average_std[:40000,:]
d_test_x = d[40000:,:]
d_test_y = average_std[40000:,:]

NN Design

Der Punkt ist

1. Stellen Sie die Eingabeform auf 10 (erforderlich).
2. Stellen Sie die Anzahl der Ausgänge der letzten Ebene auf 2 (erforderlich).
3. Machen Sie die letzte Aktivierungsfunktion linear. In diesem Fall sind Softmax, Sigmoid und ReLu nicht geeignet. Weil es Fälle gibt, in denen der Durchschnitt unter 0 liegt.
4. Setzen Sie die Verlustfunktion auf mean_squared_error. Kreuzentropie ist in diesem Fall nicht geeignet (da es sich nicht um ein Klassifizierungsproblem handelt).
5. Die Anzahl der anderen Schichten, die Anzahl der Ausgänge jeder Schicht und die Aktivierungsfunktion wurden entsprechend bestimmt.

005.py

import keras
from keras.models import Sequential
from keras.layers import Dense
from keras.optimizers import Adam

model = Sequential()
model.add(Dense(100, activation='tanh', input_shape=(10,)))#Es gibt 10 Eingangssteckplätze.
model.add(Dense(100, activation='tanh'))
model.add(Dense(40, activation='sigmoid'))
model.add(Dense(20, activation='sigmoid'))
model.add(Dense(2, activation='linear')) #Es gibt zwei Ausgangssteckplätze.
#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() #NN Zusammenfassung Ausgabe

NN Training

Zum Schluss werde ich die Trainingsdaten einwerfen.

006.py

history = model.fit(d_training_x, d_training_y,
batch_size=256,#Die Trainingsdaten werden sofort für 256 Datensätze eingegeben.
epochs=20,#Wie viele Runden werden die Trainingsdaten wiederholt?
verbose=1,#wortreich ist überflüssig, was wiederum "sprechen" bedeutet. Bei der Einstellung 1 wird der Trainingsprozess einzeln ausgegeben.
validation_data=(d_test_x, d_test_y))

Überprüfen Sie den Lernfortschritt

Hier wird der Rückgabewert von fit () im Variablenverlauf gespeichert. Wenn Sie den Rückgabewertverlauf mit type () betrachten, sieht er wie ein Objekt aus. Lassen Sie uns mit vars () überprüfen.

007.py

type(history) # <class 'keras.callbacks.callbacks.History'>
vars(history) 
#Es werden viele Informationen ausgegeben.
#In Bezug auf die Ausgabeinformationen lauten die Felder des Verlaufsobjekts wie folgt.
# validation_data (aufführen)、
# model (Verweis auf das NN-Modell)、
# params (Wörterbuch. Schlüssel ist'batch_size'、'epochs'、'steps'、'samples'、'verbose'、'do_validation'、'metrics')
# epoch (aufführen)、
# history (Wörterbuch. Schlüssel ist'val_loss'、'loss')
#
#Der Schlüssel der Geschichte ist'val_loss'Wann'loss'Ist.
#Verlust ist der Verlust für Trainingsdaten. val_Verlust ist der Verlust der Daten zur Auswertung. Da der Variablenname hier Geschichte ist, Geschichte.history['val_loss']Sie können auf die Fortschrittsdaten des Lernfortschritts zugreifen.

Lassen Sie uns den Lernfortschritt darstellen.

008.py

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 average and standard deviation?")
plt.xlabel("epoch")
plt.ylabel(" Loss")
plt.show()

Die Grafik, die ich damit geschrieben habe:

Bewertung von NN

Sie können sehen, dass das Lernen fortgeschritten ist, aber wie genau konnten Sie "rechnen"? Werfen Sie die ersten 200 Sätze von Bewertungsdaten in das NN und zeichnen Sie die Ausgabe (vertikale Achse) gegen die mathematischen Berechnungsergebnisse (horizontale Achse).

009.py

#Geben Sie dem trainierten NN Daten
inp = d_test_x[:200,:]
out = d_test_y[:200,:]
pred = model.predict(inp, batch_size=1)

#Machen Sie ein Diagramm:durchschnittlich
plt.scatter(out[:,0], pred[:,0])
plt.legend() #Legende anzeigen
plt.title("average")
plt.xlabel("mathematical calculation")
plt.ylabel("NN output")
#Zeichne eine Linie. Wenn Sie in diese Linie kommen, können Sie gut vorhersagen.
x = np.arange(-0.5, 2, 0.01)
y = x
plt.plot(x, y)
plt.show()

Sie können sehen, dass die "Berechnung" mit ungefähr hoher Genauigkeit durchgeführt wird. Was ist dann mit der Standardabweichung?

009.py

#Machen Sie ein Diagramm:Standardabweichung
plt.scatter(out[:,1], pred[:,1])
plt.legend() #Legende anzeigen
plt.title("standard deviation")
plt.xlabel("mathematical calculation")
plt.ylabel("NN output")
x = np.arange(0, 1.5, 0.01)
y = x
plt.plot(x, y)
plt.show()

Ist es ein anständiger Ort? Der Durchschnitt ist besser, aber die Standardabweichung reicht nicht aus.

Erwägung

Grob gesagt besteht die vom neuronalen Netzwerk durchgeführte Berechnung darin, das Produkt des Eingabewerts * x * multipliziert mit jedem Gewichtungsparameter * w * zu erhalten und den Ausgabewert zu erhalten, indem die Summe dieser Produkte als Eingabe der Aktivierungsfunktion verwendet wird. ist.

Für den Durchschnitt multiplizieren Sie jeden Eingabewert mit 0,1 (in diesem Fall 1/10 = 0,1, da 10 Werte eingegeben werden müssen) und addieren Sie diese, um den Durchschnitt zu erhalten. Daher berechnet NN den Durchschnitt von 10 Werten mit hoher Genauigkeit. Es ist leicht vorstellbar, was Sie tun können.

Was ist dagegen mit der Standardabweichung? Berechnen Sie den Durchschnittswert, addieren Sie dann den mit -1 multiplizierten Durchschnittswert zu jedem Eingabewert (dh nehmen Sie die Differenz zum Durchschnitt), quadrieren Sie diesen, addieren Sie ihn und dividieren Sie durch 9. Sollte die Standardabweichung sein. Der schwierige Teil dieses Prozesses ist das Quadrieren.

Intern multipliziert NN einen festen Gewichtungsparameter und einen Eingabewert, addiert sie und übergibt sie an die Aktivierungsfunktion. Ist es wirklich möglich, den quadratischen Wert eines Eingabewerts nahezu fehlerfrei zurückzugeben? Sie sollten in der Lage sein, jede Kurve durch Erhöhen der Parameter auszudrücken, aber ich bin mir nicht sicher, um welche Art von Berechnung es sich handelt.

Vielleicht wäre es schön, wenn es eine Aktivierungsfunktion gäbe, die den Eingangswert quadriert (auf die n-te Potenz erweitert). Ich würde gerne irgendwo darüber nachdenken.

Zusammenfassung

Nachdem wir nun eine NN haben, die Werte nahe dem Mittelwert und der Standardabweichung ausgeben kann, möchte ich Teil 2 abschließen. Vorbereitung der ersten Serie Serie 2. Durchschnitt und Standardabweichung Serie 3. Normalverteilung Serie 4. Yen