神经网络学习小记录37——Keras实现GRU与GRU参数量详解_keras gru

学习前言

我死了我死了我死了！

什么是GRU

GRU是LSTM的一个变种。

传承了LSTM的门结构，但是将LSTM的三个门转化成两个门，分别是更新门和重置门。

1、GRU单元的输入与输出

下图是每个GRU单元的结构。

在n时刻，每个GRU单元的输入有两个：

• 当前时刻网络的输入值X_t；
• 上一时刻GRU的输出值h_t-1；

输出有一个：

• 当前时刻GRU输出值h_t；

2、GRU的门结构

GRU含有两个门结构，分别是：

更新门z_t和重置门r_t：

更新门用于控制前一时刻的状态信息被代入到当前状态的程度，更新门的值越大说明前一时刻的状态信息带入越少，这一时刻的状态信息带入越多。

重置门用于控制忽略前一时刻的状态信息的程度，重置门的值越小说明忽略得越多。

3、GRU的参数量计算

a、更新门

更新门在图中的标号为z_t，需要结合h_t-1和X_t来决定上一时刻的输出h_t-1有多少得到保留，更新门的值越大说明前一时刻的状态信息保留越少，这一时刻的状态信息保留越多。

结合公式我们可以知道：
z_t由h_t-1和X_t来决定。

当更新门z_t的值较大的时候，上一时刻的输出h_t-1保留较少，而这一时刻的状态信息保留较多。

$$W_z的参数量=(x_{dim}+h_{dim})\ast h_{dim}$$
$$b_z的参数量=h_{dim}$$
更新门的总参数量为：
$$总参数量=((x_{dim}+h_{dim})\ast h_{dim}+h_{dim})$$

b、重置门

重置门在图中的标号为r_t，需要结合h_t-1和X_t来控制忽略前一时刻的状态信息的程度，重置门的值越小说明忽略得越多。

结合公式我们可以知道：

r_t由h_t-1和X_t来决定。

当重置门r_t的值较小的时候，上一时刻的输出h_t-1保留较少，说明忽略得越多。

$$W_t的参数量=(x_{dim}+h_{dim})\ast h_{dim}$$
$$b_t的参数量=h_{dim}$$
$$W的参数量=(x_{dim}+h_{dim})\ast h_{dim}$$
$$b的参数量=h_{dim}$$
重置门的总参数量为：
$$总参数量=2\ast ((x_{dim}+h_{dim})\ast h_{dim}+h_{dim})$$

c、全部参数量

所以所有的门总参数量为：
$$总参数量=3\ast ((x_{dim}+h_{dim})\ast h_{dim}+h_{dim})$$

在Keras中实现GRU

GRU一般需要输入两个参数。
一个是unit、一个是input_shape。

LSTM(CELL_SIZE, input_shape = (TIME_STEPS,INPUT_SIZE))
1

unit用于指定神经元的数量。
input_shape用于指定输入的shape，分别指定TIME_STEPS和INPUT_SIZE。

实现代码

import numpy as np
from keras.models import Sequential
from keras.layers import Input,Activation,Dense
from keras.models import Model
from keras.datasets import mnist
from keras.layers.recurrent import GRU
from keras.utils import np_utils
from keras.optimizers import Adam

TIME_STEPS = 28
INPUT_SIZE = 28
BATCH_SIZE = 50
index_start = 0
OUTPUT_SIZE = 10
CELL_SIZE = 75
LR = 1e-3

(X_train,Y_train),(X_test,Y_test) = mnist.load_data()
 
X_train = X_train.reshape(-1,28,28)/255
X_test = X_test.reshape(-1,28,28)/255

Y_train = np_utils.to_categorical(Y_train,num_classes= 10)
Y_test = np_utils.to_categorical(Y_test,num_classes= 10)

inputs = Input(shape=[TIME_STEPS,INPUT_SIZE])

x = GRU(CELL_SIZE, input_shape = (TIME_STEPS,INPUT_SIZE))(inputs)
x = Dense(OUTPUT_SIZE)(x)
x = Activation("softmax")(x)

model = Model(inputs,x)
adam = Adam(LR)
model.summary()
model.compile(loss = 'categorical_crossentropy',optimizer = adam,metrics = ['accuracy'])

for i in range(50000):
    X_batch = X_train[index_start:index_start + BATCH_SIZE,:,:]
    Y_batch = Y_train[index_start:index_start + BATCH_SIZE,:]
    index_start += BATCH_SIZE
    cost = model.train_on_batch(X_batch,Y_batch)
    if index_start >= X_train.shape[0]:
        index_start = 0
    if i%100 == 0:
        cost,accuracy = model.evaluate(X_test,Y_test,batch_size=50)
        print("accuracy:",accuracy)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

实现效果：

10000/10000 [==============================] - 2s 231us/step
accuracy: 0.16749999986961484
10000/10000 [==============================] - 2s 206us/step
accuracy: 0.6134000015258789
10000/10000 [==============================] - 2s 214us/step
accuracy: 0.7058000019192696
10000/10000 [==============================] - 2s 209us/step
accuracy: 0.797899999320507
1
2
3
4
5
6
7
8