introduction

Le but de cet article est d'extraire des pondérations du modèle LSTM appris dans Keras et d'implémenter la partie feedforward dans numpy. Pour mon objectif personnel, je voulais jouer avec Keras.

environnement

Python 3.6.1 :: Anaconda 4.4.0 (64-bit)
Keras 2.0.5 (backend : tensorflow)

Créer des données

Pour les données, j'ai utilisé les données de prédiction d'onde sinusoïdale utilisant RNN dans la bibliothèque d'apprentissage en profondeur Keras telles quelles. Cet article semble être basé sur j'ai essayé de prédire en laissant RNN apprendre les ondes de péché, donc je leur suis reconnaissant à tous les deux.

import pandas as pd
import math
import numpy as np

np.random.seed(0)
#Coefficient aléatoire
random_factor = 0.05
#Nombre d'étapes par cycle
steps_per_cycle = 80
#Nombre de cycles à générer
number_of_cycles = 50

df = pd.DataFrame(np.arange(steps_per_cycle * number_of_cycles + 1), columns=["t"])
df["sin_t"] = df.t.apply(lambda x: math.sin(x * (2 * math.pi / steps_per_cycle)+ np.random.uniform(-1.0, +1.0) * random_factor))

def _load_data(data, n_prev = 100):  
    """
    data should be pd.DataFrame()
    """

    docX, docY = [], []
    for i in range(len(data)-n_prev):
        docX.append(data.iloc[i:i+n_prev].as_matrix())
        docY.append(data.iloc[i+n_prev].as_matrix())
    alsX = np.array(docX)
    alsY = np.array(docY)

    return alsX, alsY

def train_test_split(df, test_size=0.1, n_prev = 100):  
    """
    This just splits data to training and testing parts
    """
    ntrn = round(len(df) * (1 - test_size))
    ntrn = int(ntrn)
    X_train, y_train = _load_data(df.iloc[0:ntrn], n_prev)
    X_test, y_test = _load_data(df.iloc[ntrn:], n_prev)

    return (X_train, y_train), (X_test, y_test)

length_of_sequences = 5
(X_train, y_train), (X_test, y_test) = train_test_split(df[["sin_t"]], n_prev =length_of_sequences)

Créer un modèle

Comme vous pouvez le voir dans la documentation Keras, reportez-vous à ici pour le moment. Cela semble bon. Le modèle sans $ V_o $ dans la partie Notre modèle ci-dessous a été implémenté dans Keras.

Alors, faisons un modèle comme suit, puis faisons une prédiction.

from keras.models import Sequential  
from keras.layers.core import Dense, Activation  
from keras.layers.recurrent import LSTM

in_out_neurons = 1
h_num = 100

model = Sequential()  
model.add(LSTM(h_num, activation="tanh", recurrent_activation="sigmoid", batch_input_shape=(None, length_of_sequences, in_out_neurons), return_sequences=False))  
model.add(Dense(in_out_neurons))
model.add(Activation("linear"))
model.compile(loss="mean_squared_error", optimizer="rmsprop")
model.fit(X_train, y_train, batch_size=600, epochs=15, validation_split=0.05) 

y_hat_keras = model.predict(X_test)

Obtenir les paramètres appris

Obtenez les paramètres du modèle que vous avez appris plus tôt. Cela semble possible avec la méthode get_weights () ''. Cette méthode a été trouvée à la fois dans l'objet keras.models.Sequential '' et dans l'objet keras.layers '', donc avec model.get_weights () '' comme suit: Vous pouvez l'obtenir, ou vous pouvez l'obtenir avec model.layers [0] .get_weights () ``.

`model.get_weights()Quel paramètre est quel? Donc, pour le moment, modèle.Après avoir vérifié les couches, etc., modélisez.get_weights()Je pense qu'il vaut mieux l'obtenir avec.`




```python
weights = model.get_weights()

W, U, b, W_out, b_out = model.get_weights()

print("W.shape : ", W.shape)
print("U.shape : ", U.shape)
print("b.shape : ", b.shape)
print("W_out.shape : ", W_out.shape)
print("b_out.shape : ", b_out.shape)

Wi = W[:,0:h_num]
Wf = W[:,h_num:2*h_num]
Wc = W[:,2*h_num:3*h_num]
Wo = W[:,3*h_num:]

print("Wi : ",Wi.shape)
print("Wf : ",Wf.shape)
print("Wc : ",Wc.shape)
print("Wo : ",Wo.shape)

Ui = U[:,0:h_num]
Uf = U[:,h_num:2*h_num]
Uc = U[:,2*h_num:3*h_num]
Uo = U[:,3*h_num:]

print("Ui : ",Ui.shape)
print("Uf : ",Uf.shape)
print("Uc : ",Uc.shape)
print("Uo : ",Uo.shape)

bi = b[0:h_num]
bf = b[h_num:2*h_num]
bc = b[2*h_num:3*h_num]
bo = b[3*h_num:]
print("bi : ",bi.shape)
print("bf : ",bf.shape)
print("bc : ",bc.shape)
print("bo : ",bo.shape)

En regardant le code original, vous pouvez voir cette entrée, oubliez, cellule de mémoire, dans un tableau. Puisque les poids sont stockés dans l'ordre de sortie, ils sont découpés comme ci-dessus.

mon feed forward

La partie formule du document original ne décrivait pas le nombre de dimensions de la matrice, et c'était un peu difficile à lire, alors j'ai soigneusement commenté ce côté. (J'ai l'impression que le code est devenu assez difficile à lire)

def sigmoid(x):
    return 1.0 / (1.0 + np.exp(-x))

x = X_test
n = x.shape[0]

#initial
ht_1 = np.zeros(n*h_num).reshape(n,h_num) #h_{t-1}Veux dire.
Ct_1 = np.zeros(n*h_num).reshape(n,h_num) ##C_{t-1}Veux dire.

ht_list = []

for t in np.arange(x.shape[1]):
    xt = np.array(x[:,t,:])

	#it :porte d'entrée t-term
    it = sigmoid(np.dot(xt, Wi) + np.dot(ht_1, Ui) + bi)
    # it : (390, 100)
    # xt : (390, 1), Wi : (1, 100)
    # ht_1 : (390, 100), Ui : (100, 100)
    # bi : (100,)

	# Ct_tilda :Candidat pour la t-ième période de la cellule mémoire
    Ct_tilda = np.tanh(np.dot(xt, Wc) + np.dot(ht_1, Uc) + bc)
    # Ct_tilda : (390, 100)
    # xt : (390, 1), Wc : (1, 100)
    # ht_1 : (390, 100), Uc : (100, 100)
    # bc : (100,)   

	# ft :porte oublier le terme t
    ft = sigmoid(np.dot(xt, Wf) + np.dot(ht_1, Uf) + bf)
    # ft : (390, 100)
    # xt : (390, 1), Wf : (1, 100)
    # ht_1 : (390, 100), Uf : (100, 100)
    # bf : (100,)

	#cellule de mémoire t-term
    Ct = it * Ct_tilda + ft * Ct_1

	# ot :porte de sortie t-term
    ot = sigmoid( np.dot(xt, Wo) + np.dot(ht_1, Uo) + bo)
    
    # ht :La couche cachée de la période t
    ht = ot * np.tanh(Ct)
    ht_list.append(ht)

    ht_1 = ht
    Ct_1 = Ct

my_y_hat = np.dot(ht, W_out) + b_out

En regardant la documentation Keras, je ne pouvais pas tout à fait comprendre la différence entre les arguments activation et recurrent_activation, mais en regardant le code à l'intérieur, l'activité liée à la cellule mémoire (Ct, Ct_tilde) La fonction d'activation était activation, et la fonction d'activation pour chaque porte (it, ft, ot) était `` `` recurrent_activation. En d'autres termes, dans mon feed-back, la partie qui utilise tanh est activation, et la partie qui utilise sigmoïde est recurrent_activation```.

Graphique des résultats

Comparaison de Keras y_hat et my_y_hat

import matplotlib.pyplot as plt

fig = plt.figure()
ax = fig.add_subplot(111)
ax.plot(y_test,label="true", color="blue")
ax.plot(y_hat_keras, label="keras y_hat", color="red")
ax.plot(my_y_hat, label="my y_hat", linestyle="dashed", color="green")
ax.legend(loc="upper right")
ax.set_ylabel("y")
ax.set_xlabel("x")
fig.savefig("./predict1.png ")

N'est-ce pas un bon sentiment?

Comparaison de ht à chaque t

import matplotlib.cm as cm

fig = plt.figure()
ax = fig.add_subplot(111)
ax.plot(y_test, color="red")
for i in np.arange(len(ht_list)):
    y_hat_iter = np.dot(ht_list[i], W_out) + b_out
    ax.plot(y_hat_iter, color=cm.cool(i/len(ht_list)))

ax.set_ylabel("y")
ax.set_xlabel("x")
fig.savefig("./predict2.png ")

plt.close("all")

À mesure que t augmente, le bleu clair devient violet. Vous pouvez voir que lorsque t augmente, il s'approche de la valeur réelle.

À la fin

Je voudrais essayer même les signaux non stationnaires. Keras est facile à lire car le code d'origine est également en python. De plus, la lecture du code original est une expérience très enrichissante.

[PYTHON] Implémenter Keras LSTM feed forward avec numpy