RNN理解笔记

在深度学习方面，图像识别、语音识别主要运用卷积神经网络（CNN），而文字语言处理主要运用循环神经网络（RNN）

循环神经网络的应用场景比较多，好比暂时能写论文，写程序，写诗，可是，（老是会有可是的），可是他们如今还不能正常使用，学习出来的东西没有逻辑，因此要想真正让它更有用，路还很远。 ###普通神经元 ###全链接深度神经网络 ###循环神经元 ###循环神经网络解析

###例如： """

我是中国人 你在作什么 是吗<eco><eco><eco>

是一个batch内的佯本，进行rnn训练.

假设隐藏层神经元数量为k，一次处理3句话，每句话序列长度为5(即时间维度)，字向量是n维则(即n个输入节点)：[batch ,n_steps ,word_embeding]=[3,5,n] 过程： 一、分别将batch的一个字输入网络(我、你、是),根据网络权重w0/b0(nk个)计算 和 初始状态（s0一、s0二、h03），分别产生状态s十一、s十二、s13； 二、分别将batch的第二个字输入网络（是、在、吗），根据网络权重w0/b0(nk个)计算 和 状态（s十一、s十二、s13），分别产生状态s2一、s2二、s23； . . . 三、计算完最后一个字后，将batch个佯本产生的结果总和来进行权重w0/b0调整为-->w1/b1,一个batch结束 四、进行下一个batch佯本集计算，循环步骤1 注意：batch中3句话分别进行计算相互不干扰，但共享权重。（也能够理解为分别单独计算第一句话进入网络，计算第二句话也进入网络，计算第三句话进入网络，只是用矩阵形式方便一块儿计算。 且进行计算完3句话后，用总的偏差来梯度调整权重，而不是分别每句话计算完就调整权重。这是用batch所在） batch做用参考https://www.jianshu.com/p/037d3b305ef3 """

-----------------------------------------------------------程序分析---------------------------------------------------------------- import tensorflow as tf import numpy as np

单步RNN：RNNCell

""" 我是中国人 你在作什么 是吗<eco><eco><eco>

假设隐藏层LSTM神经元数量为k，一次处理3句话，每句话序列长度为5(即时间维度)，字向量是n维则(即n个输入节点)：[batch ,n_steps ,word_embeding]=[3,5,n] 过程：（其中步骤1叫单步执行，至关于call方法，步骤1到3是多步执行，dynamic_rnn函数来实现） 一、分别将batch的一个字输入网络(我、你、是),根据网络权重w0/b0(nk个)计算 和 初始状态（h0一、h0二、h03），分别产生状态h十一、h十二、h13； 二、分别将batch的第二个字输入网络（是、在、吗），根据网络权重w0/b0(nk个)计算 和 状态（h十一、h十二、h13），分别产生状态h2一、h2二、h23； . . . 三、计算完最后一个字后，将batch个佯本产生的结果总和来进行权重w0/b0调整为-->w1/b1,一个batch结束 四、进行下一个batch佯本集计算，循环步骤1 注意：batch中3句话分别进行计算相互不干扰，但共享权重。（也能够理解为分别单独计算第一句话进入网络，计算第二句话也进入网络，计算第三句话进入网络，只是用矩阵形式方便一块儿计算。 且进行计算完3句话后，用总的偏差来梯度调整权重，而不是分别每句话计算完就调整权重。这是batch用处所在）

"""

cell = tf.nn.rnn_cell.BasicRNNCell(num_units=128) # state_size = 128 print(cell.state_size) # 128

inputs = tf.placeholder(np.float32, shape=(32, 100)) # 32 是 batch_size h0 = cell.zero_state(32, np.float32) # 经过zero_state获得一个全0的初始状态，形状为(batch_size, state_size) output, h1 = cell.call(inputs, h0) #调用call函数 print(h1.shape) # (32, 128) --#--------------------lstm状态有h和c------------------ lstm_cell = tf.nn.rnn_cell.BasicLSTMCell(num_units=128) inputs = tf.placeholder(np.float32, shape=(32, 100)) # 32 是 batch_size h0 = lstm_cell.zero_state(32, np.float32) # 经过zero_state获得一个全0的初始状态 output, h1 = lstm_cell.call(inputs, h0) # call方法inputs必须是[batch_size,输入节点数]（即单步执行）

print(h1.h) # shape=(32, 128) print(h1.c) # shape=(32, 128)

执行多步：tf.nn.dynamic_rnn

inputs2 = tf.placeholder(np.float32, shape=(32, 20, 100)) # 32 是 batch_size 20是序列长度，100是输入节点维数。shape = (batch_size, time_steps, input_size) # initial_state: shape = (batch_size, cell.state_size)。初始状态。通常能够取零矩阵 initial_state = lstm_cell.zero_state(32, np.float32) # 经过zero_state获得一个全0的初始状态 outputs, state = tf.nn.dynamic_rnn(lstm_cell, inputs2, initial_state=initial_state) # state为最后一步的状态，outputs为每一步的输出数组（但最后的state 并不等于outpus的最后一行，这里有待研究） print(state.h) # shape=(32, 128)

堆叠RNNCell：MultiRNNCell

''' 不少时候，单层RNN的能力有限，咱们须要多层的RNN。将x输入第一层RNN的后获得隐层状态h，这个隐层状态就至关于第二层RNN的输入，第二层RNN的隐层状态又至关于第三层RNN的输入， 以此类推。在TensorFlow中，可使用tf.nn.rnn_cell.MultiRNNCell函数对RNNCell进行堆叠 '''

def get_a_cell(): return tf.nn.rnn_cell.BasicRNNCell(num_units=128) # 每调用一次这个函数就返回一个BasicRNNCell

cell = tf.nn.rnn_cell.MultiRNNCell([get_a_cell() for _ in range(3)]) # 用tf.nn.rnn_cell MultiRNNCell建立3层RNN 获得的cell实际也是RNNCell的子类 它的state_size是(128, 128, 128) (128, 128, 128)并非128x128x128的意思 而是表示共有3个隐层状态，每一个隐层状态的大小为128 print(cell.state_size) # (128, 128, 128) 使用对应的call函数 inputs = tf.placeholder(np.float32, shape=(32, 100)) # 32 是 batch_size h0 = cell.zero_state(32, np.float32) # 经过zero_state获得一个全0的初始状态 output1, h1 = cell.call(inputs, h0) print(h1) # tuple中含有3个32x128的向量 经过MultiRNNCell获得的cell并非什么新鲜事物，它实际也是RNNCell的子类，所以也有call方法、state_size和output_size属性。一样能够经过tf.nn.dynamic_rnn来一次运行多步。

坑1：Output说明

''' BasicRNNCell对照来看。h就对应了BasicRNNCell的state。那么，y是否是就对应了BasicRNNCell的output呢？答案是否认的

def call(self, inputs, state): """Most basic RNN: output = new_state = act(W * input + U * state + B).""" output = self._activation(_linear([inputs, state], self._num_units, True)) return output, output # call 源码，output和state是同样的。所以，咱们还须要额外对输出定义新的变换，才能获得图中真正的输出y

再来看一下BasicLSTMCell的call函数定义（函数的最后几行）：

new_c = ( c * sigmoid(f + self._forget_bias) + sigmoid(i) * self._activation(j)) new_h = self._activation(new_c) * sigmoid(o)

if self._state_is_tuple: new_state = LSTMStateTuple(new_c, new_h) else: new_state = array_ops.concat([new_c, new_h], 1) return new_h, new_state

只须要关注self._state_is_tuple == True的状况，由于self._state_is_tuple == False的状况将在将来被弃用。返回的隐状态是new_c和new_h的组合，而output就是单独的new_h。若是咱们处理的是分类问题，那么咱们还须要对new_h添加单独的Softmax层才能获得最后的分类几率输出。 '''

坑2：initial_state

看以下代码：

def build_lstm(self):
        def get_a_cell(lstm_size, keep_prob):
            # 建立单个lstm，并增长drop层
            lstm = tf.nn.rnn_cell.BasicLSTMCell(lstm_size)
            drop = tf.nn.rnn_cell.DropoutWrapper(lstm, output_keep_prob=keep_prob)
            return drop

        with tf.name_scope('lstm'):
            # 堆叠多层lstm
            cell = tf.nn.rnn_cell.MultiRNNCell(
                [get_a_cell(self.lstm_size, self.keep_prob) for _ in range(self.num_layers)]
            )
        self.initial_state = cell.zero_state(self.batch_size, tf.float32)

        # 经过dynamic_rnn对cell展开时间维度
        self.lstm_outputs, self.final_state = tf.nn.dynamic_rnn(cell, self.lstm_inputs, initial_state=self.initial_state)

    def train(self, batch_generator, max_steps, save_path, save_every_n, log_every_n):
        self.session = tf.Session()
        with self.session as sess:
            sess.run(tf.global_variables_initializer())
            # Train network
            step = 0
            new_state = sess.run(self.initial_state)
            for x, y in batch_generator:
                step += 1
                start = time.time()
                feed = {self.inputs: x,
                        self.targets: y,
                        self.keep_prob: self.train_keep_prob,
                        self.initial_state: new_state}  #
                batch_loss, new_state, _ = sess.run([self.loss,
                                                     self.final_state,
                                                     self.optimizer],
                                                    feed_dict=feed)

该程序将运行完一个batch后的状态做为下一个batch的初始状态，这样是有问题的。由于每一个batch佯本并不受上一个batch佯本的影响（在一个batch里面，序列之间是受影响的，dynamic_rnn函数已经自动将序列间的状态进行传递，最终输出的是序列最后一个字的状态）。因此每次训练完一个batch佯本，initial_state应该被置为0。 feed 部分不须要传入self.initial_state，每一个batch的初始状态都是：self.initial_state = cell.zero_state(self.batch_size, tf.float32)。程序修改以下：

def train(self, batch_generator, max_steps, save_path, save_every_n, log_every_n):
        self.session = tf.Session()
        with self.session as sess:
            sess.run(tf.global_variables_initializer())
            # Train network
            step = 0
            # new_state = sess.run(self.initial_state)
            for x, y in batch_generator:
                step += 1
                start = time.time()
                feed = {self.inputs: x,
                        self.targets: y,
                        self.keep_prob: self.train_keep_prob,}
                        # self.initial_state: new_state}  #
                batch_loss, new_state, _ = sess.run([self.loss,
                                                     self.final_state,
                                                     self.optimizer],
                                                    feed_dict=feed)

另外，在测试阶段，由于输入的是第一个字，因此须要将输出的状态传入到下一个字，这点是须要注意的。