特色栏目： python 批处理 net编程 Javascript Php Asp Css Html5 Android seo centos

Keras代码超详细讲解LSTM实现细节

来源：互联网收集：自由互联发布时间：2021-06-10

1.首先我们了解一下keras中的Embedding层： from keras.layers.embeddings import Embedding： Embedding参数如下：输入尺寸：（batch_size,input_length）输出尺寸：（batch_size,input_length,output_dim）举个例子：

1.首先我们了解一下keras中的Embedding层：from keras.layers.embeddings import Embedding：

Embedding参数如下：

分享图片

输入尺寸：（batch_size,input_length）

输出尺寸：（batch_size,input_length,output_dim）

举个例子：（随机初始化Embedding）:

from keras.models import Sequential from keras.layers import Embedding import numpy as np model = Sequential() model.add(Embedding(1000, 64, input_length=10)) # 输入大小为(None，10)，Nnoe是batch_size大小，10代表每一个batch中有10条样本 # 输出大小为(None, 10, 64),其中64代表输入中每个每条样本被embedding成了64维的向量 input_array = np.random.randint(1000, size=(32, 10)) model.compile(‘rmsprop‘, ‘mse‘) output_array = model.predict(input_array) print(output_array) assert output_array.shape == (32, 10, 64)

具体可以看下面的例子：

from keras.models import Sequential from keras.layers import Flatten, Dense, Embedding import numpy as np model = Sequential() model.add(Embedding(3, 2, input_length=7))
 #通俗的讲，这个过程中，Embedding层生成了一个大小为3*2的随机矩阵（3代表词汇表大小，，2代表没个词embedding后的向量大小），记为M，查看矩阵M：
 model.layers[0].get_weights() #输出 [array([[-0.00732628, -0.02913231], [ 0.00573028,  0.0329752 ], [-0.0401206 , -0.01729034]], dtype=float32)]

矩阵的每一行是该行下标指示的标记的数值向量，即矩阵M的第i（0，1，2）行是index为i的单词对应的数值向量,比如说，我的输入如果index=1，则对应的embedding向量= [ 0.00573028, 0.0329752 ]，具体看下面：

data = np.array([[0,1,2,1,1,0,1],[0,1,2,1,1,0,1]] model.predict(data)) #输出 [[[-0.00732628 -0.02913231] [ 0.00573028  0.0329752 ] [-0.0401206  -0.01729034] [ 0.00573028  0.0329752 ] [ 0.00573028  0.0329752 ] [-0.00732628 -0.02913231] [ 0.00573028  0.0329752 ]] [[-0.00732628 -0.02913231] [ 0.00573028  0.0329752 ] [-0.0401206  -0.01729034] [ 0.00573028  0.0329752 ] [ 0.00573028  0.0329752 ] [-0.00732628 -0.02913231] [ 0.00573028  0.0329752 ]]]

data是Embedding层的输入，它包含2个batch，每个batch有7条样本，即data.shape = (2,7), 输出out的shape = (2,7,2)，即每一条样本被embedding成了2维向量。

有时候我们可以用预训练好的embedding matrix初始化（使用百度百科（word2vec）的语料库）：

def create_embedding(word_index, num_words, word2vec_model): embedding_matrix = np.zeros((num_words, EMBEDDING_DIM)) for word, i in word_index.items(): try: embedding_vector = word2vec_model[word] embedding_matrix[i] = embedding_vector except: continue
    return embedding_matrix #word_index:词典 #num_word:词典长度+1 #word2vec_model:词向量的model embedding_matrix = create_embedding(word_index, num_words, word2vec_model) model = Sequential() embedding_layer = Embedding(num_words, EMBEDDING_DIM, #embedding后的向量大小  embeddings_initializer=Constant(embedding_matrix), #使用预训练好的embedding matrix初始化 input_length=MAX_SEQUENCE_LENGTH, #输入的每个batch中样本个数 trainable=False) input = Input(shape=(MAX_SEQUENCE_LENGTH,), dtype=‘int32‘) embedded_input = embedding_layer(sequence_input)
 model.add(embedded_sequences)

其实Keras实现LLSTM(其它网络模型也一样)，就像是在堆积木：

#单层LSTM
model = Sequential() model.add(Embedding(len(words)+1, 256, input_length=maxlen)) model.add(LSTM(output_dim=128, activation=‘sigmoid‘, inner_activation=‘hard_sigmoid‘)) model.add(Dropout(0.5)) model.add(Dense(1)) model.add(Activation(‘sigmoid‘)) model.compile(loss=‘binary_crossentropy‘, optimizer=‘rmsprop‘, metrics=[‘accuracy‘]) #model.compile(loss=‘binary_crossentropy‘, optimizer=‘adam‘, class_mode="binary") model.fit(x, y, batch_size=16, nb_epoch=10) y_= model.predict_classes(x)


#多层LSTM

model = Sequential()

#多层LSTM中，最后一个LSTM层return_sequences通常为false，非最后一层为True

#return_sequences：默认为false。当为False时，返回最后一层最后一个步长的隐藏状态;当为True时，返回最后一层的所有隐藏状态

model.add(LSTM(layers[1], input_shape=(seq_len, layers[0]),return_sequences=True))
#model.add(Dropout(0.2))

model.add(LSTM(layers[2],return_sequences=False))
#model.add(Dropout(0.2))

model.add(Dense(units=layers[3], activation=‘tanh‘))

下面附上LSTM在keras中参数return_sequences，return_state的超详细区别：

一，定义

return_sequences：默认为false。当为假时，返回最后一层最后一个步长的隐藏状态;当为真时，返回最后一层的所有隐藏状态。

return_state：默认false。当为真时，返回最后一层的最后一个步长的输出隐藏状态和输入单元状态。

二，实例验证

下图的输入是一个步长为3，维度为1的数组。

一共有2层神经网络（其中第一层必须加上“return_sequences =真”，这样才能转化成步长为3的输入变量）

（1）return_sequences =True

from keras.models import Model from keras.layers import Input from keras.layers import LSTM from numpy import array from keras.models import Sequential data = array([0.1,0.2,0.3]).reshape((1,3,1)) inputs1 = Input(shape=(3,1)) lstm1,state_h,state_c = LSTM(2,return_sequences=True,return_state=True)(inputs1) #第一层LSTM lstm2 = LSTM(2,return_sequences=True)(lstm1) #第二层LSTM model = Model(input = inputs1,outputs = [lstm2]) print(model.predict(data))

输出结果为:(最后一层LSTM2的每一个时间步长hidden_??state的结果）

[[[0.00120299 0.0009285]
[0.0040868 0.00327]
[0.00869473 0.00720878]]]

（2）return_sequence = False，return_state = True

from keras.models import Model from keras.layers import Input from keras.layers import LSTM from numpy import array from keras.models import Sequential data = array([0.1,0.2,0.3]).reshape((1,3,1)) inputs1 = Input(shape=(3,1)) lstm1,state_h,state_c = LSTM(2,return_sequences=True,return_state=True)(inputs1) lstm2,state_h2,state_c2 = LSTM(2,return_state=True)(lstm1) model = Model(input = inputs1,outputs = [lstm2,state_h2,state_c2]) print(model.predict(data))

输出为：

因为return_state =真，返回了最后一层最后一个时间步长的输出hidden_??state和输入cell_state。

[array（[[ - 0.00234587,0.00718377]]，dtype = float32），array（[[ - 0.00234587,0.00718377]]，dtype = float32），array（[[ - 0.00476015,0.01406127]]，dtype = float32）]

（3）return_sequence = True，return_state = True

from keras.models import Model from keras.layers import Input from keras.layers import LSTM from numpy import array from keras.models import Sequential data = array([0.1,0.2,0.3]).reshape((1,3,1)) inputs1 = Input(shape=(3,1)) lstm1,state_h,state_c = LSTM(2,return_sequences=True,return_state=True)(inputs1) lstm2,state_h2,state_c2 = LSTM(2,return_sequences=True,return_state=True)(lstm1) model = Model(input = inputs1,outputs = [lstm2,state_h2,state_c2]) print(model.predict(data))

输出为：最后一层所有时间步长的隐藏状态，及最后一层最后一步的隐藏状态，细胞状态。

[array（[[[ - [2.0248523e-04，-1.0290105e-03]，
[ - 3.6455912e-04，-3.3424206e-03]，
[ - 3.66696041e-05，-6.6624139e-03]]]，dtype = FLOAT32），

array（[[ - 3.669604e-05，-6.662414e-03]]，dtype = float32），

array（[[ - 7.3107367e-05，-1.3788906e-02]]，dtype = float32）]

（4）return_sequence = False，return_state = False

from keras.models import Model from keras.layers import Input from keras.layers import LSTM from numpy import array from keras.models import Sequential data = array([0.1,0.2,0.3]).reshape((1,3,1)) inputs1 = Input(shape=(3,1)) lstm1,state_h,state_c = LSTM(2,return_sequences=True,return_state=True)(inputs1) lstm2 = LSTM(2)(lstm1) model = Model(input = inputs1,outputs = [lstm2]) print(model.predict(data))

输出为：最后一层的最后一个步长的隐藏状态。

[[-0.01998264 -0.00451741]]

本文参考自：

https://www.jianshu.com/p/a3f3033a7379

https://blog.csdn.net/qq_33472765/article/details/86561245

https://www.wandouip.com/t5i152855/

https://blog.csdn.net/weixin_36541072/article/details/53786020

上一篇：Codeforces Edu Round 66 A-E
下一篇：PAT-A1033 or codeup 2031 To Fill or Not to Fill （贪心）题解