1. Übersicht

Der Zweck ist zu verstehen, welche Art von Berechnung Keras model.predict () macht.
Verwenden Sie model.get_weights (), um Gewichte aus dem trainierten Modell abzurufen und diese auf die Trainingsdaten anzuwenden, um die Ausgabe des Modells zu berechnen.
** Das Ziel ist es, das gleiche Ergebnis wie die Ausgabe von model.predict () zu erzielen! ** **.
Wir beschäftigen uns überhaupt nicht mit Rückausbreitung.
Es gab eine Szene, in der ich ein mit Keras erstelltes Modell in einer anderen Sprache als Python implementieren wollte. Ich dachte, ich verstehe LSTM irgendwie, aber ich war süchtig nach der Implementierung, also lol

2. Daten- und Modellvorbereitung

Daten

Da der Zweck darin besteht, manuell das gleiche Ergebnis wie model.predict () zu erhalten, ist die Vollständigkeit und Komplexität des Modells selbst nicht erforderlich. Daher habe ich zuerst die folgenden Beispieldaten erstellt.

X = np.arange(24).reshape(4,3,2)
y = np.array([[0,1],[0,1],[0,1],[1,0]])
print(X.shape)
#=> (4, 3, 2)
print(y.shape)
#=> (4, 2)
print(X[0])
#=> [[0 1]
#    [2 3]
#    [4 5]]

X sind die Trainingsdaten und y ist das entsprechende Etikett.
X und y bestehen aus 4 Proben.
Bei der ersten Stichprobe handelt es sich um eine 3x2-Matrix.
Dies bedeutet, dass zwei Merkmalsgrößen und drei Zeitreihendaten als Daten vorhanden sind.
Die Daten sind in der Reihenfolge vom ältesten zum neuesten angeordnet, und das Bild zeigt, dass die Daten [0, 1] zuerst erhalten wurden, dann die Beobachtung [2, 3] und schließlich [4, 5].

Modell-

Ich habe das folgende einfache Modell erstellt.

from keras.layers import Input, Dense
from keras.models import Model
from keras.layers.recurrent import LSTM
import tensorflow as tf
from keras import backend

tf.reset_default_graph()
backend.clear_session()

inputs = Input(shape=[3,2])
x = LSTM(8, activation='tanh', recurrent_activation='sigmoid')(inputs)
outputs = Dense(2, activation='softmax')(x)
model = Model(inputs=inputs, outputs=outputs)
model.compile(optimizer='adam',loss='categorical_crossentropy')
model.summary()

Standardmäßig ist wiederkehrende_Aktivierung = 'hard_sigmoid' festgelegt. Aufgrund verschiedener Untersuchungen gibt es jedoch viele Dokumente und Diagramme, in denen sigmoid verwendet wird. Daher wird wiederkehrende_aktivierung = 'sigmoid' einmal festgelegt.
Danach lernen wir und das Modell ist fertig.

history = model.fit(X, y, epochs=2, verbose=1)

3. Get_weights () verstehen

Dies ist einer der schwer zu verstehenden Orte. Ich kann die Parameter des Modells mit get_weights () abrufen, aber die Bedeutung der Ausgabe war nicht intuitiv. (Zumindest für mich)

for weight in model.get_weights():
    print(weight.shape)
#=> (2, 32)
#   (8, 32)
#   (32,)
#   (8, 2)
#   (2,)

Die Keras-Dokumentation war wie folgt. Ich möchte eine etwas detailliertere Erklärung ...

model.get_weights (): Gibt eine Liste aller Modellgewichtstensoren mit Numpy-Arrays als Elementen zurück.

Obwohl ich mir die Form des Arrays vorstellen kann, habe ich verschiedene Dinge untersucht und festgestellt, dass die ersten drei LSTM-Parameter und die restlichen zwei Dense-Layer-Parameter sind.
Überprüfen Sie die LSTM-Zelle, bevor Sie die Parameter für dieses LSTM erläutern.
Unten werde ich den Code so oft wie möglich mit der oben gezeigten Notation schreiben. Die tatsächliche Berechnung ist wie folgt.
$ \ quad i_t = \ sigma (x_t W ^ i + h_ {t-1} U ^ i + b ^ i) $
$ \ quad f_t = \ sigma (x_t W ^ f + h_ {t -1} U ^ f + b ^ f) $
$ \ quad \ tilde {C} _t = {\ rm tanh} (x \ _ t W ^ g + h \ _ {t-1} U ^ g + b ^ g) $
$ \ quad o \ _t = \ sigma (x \ _ t W ^ o + h \ _ {t-1} U ^ o + b ^ o) $
$ \ quad C \ _t = f \ _t C \ _ {t-1} + i \ _t \ tilde {C} \ _t $
$ \ quad h \ _t = {\ rm tanh} (C \ _t) o \ _t $
Die Schlussfolgerungen zu den von get_weights () erhaltenen Parametern lauten wie folgt.

W = model.get_weights()[0]
U = model.get_weights()[1]
b = model.get_weights()[2]
dense_W = model.get_weights()[3]
dense_b = model.get_weights()[4]

W_i, W_f, W_tC, W_o = W[:,:8], W[:,8:16], W[:,16:24], W[:,:24:]
U_i, U_f, U_tC, U_o = U[:,:8], U[:,8:16], U[:,16:24], U[:,:24:]
b_i, b_f, b_tC, b_o = b[:8], b[8:16], b[16:24], b[24:]

$ W ^ i $, $ W ^ f $, $ W ^ g $, $ W ^ o $ werden gemeinsam in model.get_weights () [0] gespeichert. Der Grund, warum die Parameter hier durch 8 getrennt sind, besteht darin, dass das Modell mit 8 Zellen im LSTM erstellt wird.

4. Berechnen!

Zu diesem Zeitpunkt müssen Sie nur noch berechnen.

#Wir werden anhand der ersten Stichprobe berechnen.
_X = X[0]

#Definieren Sie die Aktivierungsfunktion.
def sigmoid(x):
    return(1.0/(1.0+np.exp(-x)))
def relu(x):
    ret_x = x
    ret_x[ret_x<0] = 0
    return ret_x

#Erste C.,Die Werte von h sind alle 0.
C = np.zeros((1,8))
h = np.zeros((1,8))

#LSTM-Teil
for i in range(len(_X)):
    x_t = _X[i]
    i_t = sigmoid(np.dot(x_t,W_i) + np.dot(h,U_i) + b_i)
    f_t = sigmoid(np.dot(x_t,W_f) + np.dot(h,U_f) + b_f)
    tC = np.tanh(np.dot(x_t,W_g) + np.dot(h,U_g) + b_g)
    o_t = sigmoid(np.dot(x_t,W_o) + np.dot(h,U_o) + b_o)
    C = f_t*C + i_t*tC
    h = np.tanh(C) * o_t

#Dichter Teil
output = np.dot(h,dense_W) + dense_b

#Softmax-Berechnung
E = []
Esum = 0
for i in range(2):
    E.append(np.exp(output[0,i]))
    Esum += np.exp(output[0,i])
result = []
for i in range(2):
    result.append(E[i]/Esum)
    
print(result)
#=> [0.5211381547054326, 0.4788618452945675]

Überprüfen Sie das Ergebnis von model.predict ().

print(model.predict(_X.reshape(1,3,2)))
#=> [[0.5211382  0.47886187]]

Passt perfekt! !!
Es geht darum, die Bedeutung des Rückgabewerts von get_weights () zu verstehen. Es ging darum zu verstehen, auf welches der Modelle sich jeder Parameter des Rückgabewerts bezieht, und für die LSTM-Parameter werden die vier Parameter zu einem Parameter kombiniert.

5. [Extra] Aktivierung und wiederkehrende Aktivierung

Mit Keras LSTM können Sie Aktivierung und wiederkehrende Aktivierung angeben. Der ehrliche Eindruck ist jedoch, dass es schwierig ist zu sagen, auf welche Aktivierungsfunktion sie verweisen.
Nachdem model.predict nun manuell mit numpy berechnet werden kann, nutzen wir diese Gelegenheit, um zu überprüfen, wo Aktivierung und wiederkehrende Aktivierung speziell für nichtlineare Transformationen verwendet werden.

Überprüfen Sie die Aktivierung und die wiederkehrende Aktivierung.

Überprüfen Sie zuerst die Aktivierung.

#Erstellen Sie ein Modell, dessen Aktivierung in relu geändert wurde.
tf.reset_default_graph()
backend.clear_session()

inputs = Input(shape=[3,2])
x = LSTM(8, activation='relu', recurrent_activation='sigmoid')(inputs) # relu!
outputs = Dense(2, activation='softmax')(x)
model = Model(inputs=inputs, outputs=outputs)
model.compile(optimizer='adam',loss='categorical_crossentropy')
history = model.fit(X, y, epochs=2, verbose=1)


#Berechnen Sie die Ausgabe der Vorhersage mit numpy.
C = np.zeros((1,8))
h = np.zeros((1,8))
_X = X[0]

W = model.get_weights()[0]
U = model.get_weights()[1]
b = model.get_weights()[2]
dense_W = model.get_weights()[3]
dense_b = model.get_weights()[4]

W_i, W_f, W_g, W_o = W[:,:8], W[:,8:16], W[:,16:24], W[:,24:]
U_i, U_f, U_g, U_o = U[:,:8], U[:,8:16], U[:,16:24], U[:,24:]
b_i, b_f, b_g, b_o = b[:8], b[8:16], b[16:24], b[24:]

for i in range(len(_X)):
    x_t = _X[i]
    i_t = sigmoid(np.dot(x_t,W_i) + np.dot(h,U_i) + b_i)
    f_t = sigmoid(np.dot(x_t,W_f) + np.dot(h,U_f) + b_f)
    tC = relu(np.dot(x_t,W_g) + np.dot(h,U_g) + b_g) # relu!
    o_t = sigmoid(np.dot(x_t,W_o) + np.dot(h,U_o) + b_o)
    C = f_t*C + i_t*tC
    h = relu(C) * o_t # relu!

output = np.dot(h,dense_W) + dense_b

E = []
Esum = 0
for i in range(2):
    E.append(np.exp(output[0,i]))
    Esum += np.exp(output[0,i])
result = []
for i in range(2):
    result.append(E[i]/Esum)

#Die Ausgabe sieht folgendermaßen aus:
print(result)
#=> [0.5606417941538421, 0.4393582058461578]

# model.predict()Überprüfen Sie die Ausgabe von.
print(model.predict(_X.reshape(1,3,2)))
#=> [[0.5606418 0.4393582]]

Schauen wir uns als nächstes die wiederkehrende Aktivierung an.

#Erstellen Sie ein Modell, dessen Aktivierung in relu geändert wurde.
tf.reset_default_graph()
backend.clear_session()

inputs = Input(shape=[3,2])
x = LSTM(8, activation='tanh', recurrent_activation='relu')(inputs) # relu!
outputs = Dense(2, activation='softmax')(x)
model = Model(inputs=inputs, outputs=outputs)
model.compile(optimizer='adam',loss='categorical_crossentropy')
history = model.fit(X, y, epochs=2, verbose=1)


#Berechnen Sie die Ausgabe der Vorhersage mit numpy.
C = np.zeros((1,8))
h = np.zeros((1,8))
_X = X[0]

W = model.get_weights()[0]
U = model.get_weights()[1]
b = model.get_weights()[2]
dense_W = model.get_weights()[3]
dense_b = model.get_weights()[4]

W_i, W_f, W_g, W_o = W[:,:8], W[:,8:16], W[:,16:24], W[:,24:]
U_i, U_f, U_g, U_o = U[:,:8], U[:,8:16], U[:,16:24], U[:,24:]
b_i, b_f, b_g, b_o = b[:8], b[8:16], b[16:24], b[24:]

for i in range(len(_X)):
    x_t = _X[i]
    i_t = relu(np.dot(x_t,W_i) + np.dot(h,U_i) + b_i) # relu!
    f_t = relu(np.dot(x_t,W_f) + np.dot(h,U_f) + b_f) # relu!
    tC = np.tanh(np.dot(x_t,W_g) + np.dot(h,U_g) + b_g)
    o_t = relu(np.dot(x_t,W_o) + np.dot(h,U_o) + b_o) # relu!
    C = f_t*C + i_t*tC
    h = np.tanh(C) * o_t

output = np.dot(h,dense_W) + dense_b

E = []
Esum = 0
for i in range(2):
    E.append(np.exp(output[0,i]))
    Esum += np.exp(output[0,i])
result = []
for i in range(2):
    result.append(E[i]/Esum)

#Die Ausgabe sieht folgendermaßen aus:
print(result)
#=> [0.5115599582737976, 0.4884400417262024]

# model.predict()Überprüfen Sie die Ausgabe von.
print(model.predict(_X.reshape(1,3,2)))
#=> [[0.51155996 0.48844004]]

Wenn die Aktivierung $ f_a $ und die wiederkehrende Aktivierung $ f_ {r} $ ist,
$ \ quad i_t = f \ a (x_t W ^ i + h {t-1} U ^ i + b ^ i) $
$ \ quad f_t = f \ a (x_t W ^ f + h {t-1} U ^ f + b ^ f) $
$ \ quad \ tilde {C} _t = f \ _r (x \ _t W ^ g + h \ _ {t-1} U ^ g + b ^ g) $
$ \ quad o \ _ t = f \ _a (x \ _ t W ^ o + h \ _ {t- 1} U ^ o + b ^ o) $
$ \ quad C \ _t = f \ _t C \ _ {t-1} + i \ _t \ tilde {C} \ _ t $
$ \ quad Es stellt sich heraus, dass h \ _t = f \ _r (C \ _t) o \ _t $
.
Es scheint, dass ** $ \ sigma $ im oben verwendeten LSTM-Zellendiagramm die durch Aktivierung angegebene Funktion ist und $ \ rm tanh $ die durch wiederkehrende Aktivierung angegebene Funktion ist **.