[Python] J'ai essayé le même calcul que la prédiction de LSTM à partir de zéro [Keras]
1. Vue d'ensemble
- Le but est de comprendre quel type de calcul Keras model.predict () effectue.
- Utilisez model.get_weights () pour obtenir des poids du modèle formé et appliquez-les aux données d'entraînement pour calculer la sortie du modèle.
- ** Le but est d'obtenir le même résultat que la sortie de model.predict ()! ** **
- Nous ne traitons pas du tout de rétro-propagation.
- Il y avait une scène où je voulais implémenter un modèle réalisé avec Keras dans un langage autre que Python. Je pensais comprendre le LSTM d'une manière ou d'une autre, mais j'étais accro à la mise en œuvre, alors lol
2. Préparation des données et des modèles
Les données
- Puisque le but est d'obtenir manuellement le même résultat que model.predict (), l'exhaustivité et la complexité du modèle lui-même ne sont pas nécessaires, j'ai donc d'abord créé les exemples de données suivants.
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 est les données d'entraînement et y est l'étiquette correspondante.
- X et y sont constitués de 4 échantillons.
- En regardant le premier échantillon, il s'agit d'une matrice 3x2.
- Cela signifie qu'il existe deux quantités de caractéristiques et trois données de séries chronologiques en tant que données.
- Les données sont classées dans l'ordre de la plus ancienne à la plus récente, et l'image est que les données [0, 1] ont été obtenues en premier, puis l'observation [2, 3] et enfin [4, 5].
modèle
- J'ai créé le modèle simple suivant.
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()
- Par défaut, recurrent_activation = 'hard_sigmoid' est défini, mais à la suite de diverses investigations, de nombreux documents et graphiques utilisent sigmoid, donc recurrent_activation = 'sigmoid' est défini une fois.
- Après cela, apprenons et le modèle est terminé.
history = model.fit(X, y, epochs=2, verbose=1)
3. Comprendre get_weights ()
- C'est l'un des endroits difficiles à comprendre. Je peux obtenir les paramètres du modèle avec get_weights (), mais la signification de la sortie n'était pas intuitive. (Au moins pour moi)
for weight in model.get_weights():
print(weight.shape)
#=> (2, 32)
# (8, 32)
# (32,)
# (8, 2)
# (2,)
- La documentation Keras était la suivante. Je veux une explication un peu plus détaillée ...
model.get_weights (): renvoie une liste de tous les tenseurs de poids de modèle avec des tableaux Numpy comme éléments.
-
Bien que je puisse imaginer à partir de la forme du tableau, j'ai étudié diverses choses et j'ai trouvé que les trois premiers sont des paramètres LSTM et les deux autres sont des paramètres de couche dense.
-
Vérifiez la cellule LSTM avant de discuter des paramètres de ce LSTM.
-
Ci-dessous, j'écrirai le code en utilisant autant que possible la notation indiquée ci-dessus. Le calcul réel est le suivant.
$ \ 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 $ -
Les conclusions sur les paramètres obtenus par get_weights () sont les suivantes.
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 $ sont collectivement stockés dans model.get_weights () [0]. La raison pour laquelle les paramètres sont séparés par 8 ici est que le modèle est créé avec 8 cellules dans le LSTM.
4. Calculez!
- À ce stade, tout ce que vous avez à faire est de calculer.
#Nous calculerons en utilisant le premier échantillon.
_X = X[0]
#Définissez la fonction d'activation.
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
#Premier C,Les valeurs de h sont toutes 0.
C = np.zeros((1,8))
h = np.zeros((1,8))
#Pièce LSTM
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
#Partie dense
output = np.dot(h,dense_W) + dense_b
#calcul softmax
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]
- Vérifiez le résultat de model.predict ().
print(model.predict(_X.reshape(1,3,2)))
#=> [[0.5211382 0.47886187]]
- Correspond parfaitement! !!
- Le but est de comprendre la signification de la valeur de retour de get_weights (). Le but était de comprendre à quel modèle se réfère chaque paramètre de la valeur de retour, et pour les paramètres LSTM, les quatre paramètres sont combinés en un seul paramètre.
5. [Extra] activation et recurrent_activation
- Le LSTM de Keras vous permet de spécifier activation et recurrent_activation, mais l'impression honnête est qu'il est difficile de dire à quelle fonction d'activation ils pointent.
- Maintenant que model.predict peut être calculé manuellement avec numpy, profitons de cette occasion pour vérifier où activation et recurrent_activation sont spécifiquement utilisées pour les transformations non linéaires.
Vérifiez l'activation et recurrent_activation.
- Tout d'abord, vérifiez l'activation.
#Créez un modèle avec l'activation modifiée en relu.
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)
#Calculez la sortie de la prédiction à l'aide de 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)
#La sortie ressemble à ceci:
print(result)
#=> [0.5606417941538421, 0.4393582058461578]
# model.predict()Vérifiez la sortie de.
print(model.predict(_X.reshape(1,3,2)))
#=> [[0.5606418 0.4393582]]
- Ensuite, regardons recurrent_activation.
#Créez un modèle avec l'activation modifiée en relu.
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)
#Calculez la sortie de la prédiction à l'aide de 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)
#La sortie ressemble à ceci:
print(result)
#=> [0.5115599582737976, 0.4884400417262024]
# model.predict()Vérifiez la sortie de.
print(model.predict(_X.reshape(1,3,2)))
#=> [[0.51155996 0.48844004]]
- Tout d'abord, vérifiez l'activation.
#Créez un modèle avec l'activation modifiée en relu.
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)
#Calculez la sortie de la prédiction à l'aide de 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)
#La sortie ressemble à ceci:
print(result)
#=> [0.5606417941538421, 0.4393582058461578]
# model.predict()Vérifiez la sortie de.
print(model.predict(_X.reshape(1,3,2)))
#=> [[0.5606418 0.4393582]]
- Ensuite, regardons recurrent_activation.
#Créez un modèle avec l'activation modifiée en relu.
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)
#Calculez la sortie de la prédiction à l'aide de 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)
#La sortie ressemble à ceci:
print(result)
#=> [0.5115599582737976, 0.4884400417262024]
# model.predict()Vérifiez la sortie de.
print(model.predict(_X.reshape(1,3,2)))
#=> [[0.51155996 0.48844004]]
- Si l'activation est $ f_a $ et l'activation récurrente est $ f_ {r} $,
$ \ 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 Il s'avère que h \ _t = f \ _r (C \ _t) o \ _t $
. - Il semble que ** $ \ sigma $ dans le diagramme de cellules LSTM utilisé ci-dessus soit la fonction spécifiée par l'activation, et $ \ rm tanh $ est la fonction spécifiée par recurrent_activation **.
Recommended Posts