自然语言菜鸟学习笔记（七）：RNN（循环神经网络）及变体（LSTM、GRU）理解与实现（TensorFlow）

客官°小女子只卖身不卖艺 2021-12-10 02:51 317阅读 0赞

**目录**

前言

RNN（循环神经网络）

为什么要用循环神经网络（RNN）？

循环神经网络（RNN）可以处理什么类型的任务？

多对一问题

一对多问题

多对多问题

循环神经网络结构

单层网络情况

正向传播

反向传播

存在问题

优化方案

多层网络情况

双向网络结构

LSTM（Long Short Term Memory）长短期记忆网络

LSTM与RNN的不同

选择性机制的实现

LSTM模型结构

记忆单元状态

遗忘门

输入门

输出门

GRU（Gated Recurrent Unit）门控循环单元

LSTM实现简单文本分类

预处理

代码

效果截图：

--------------------

# 前言 #

Stay hungry. Stay Foolish.

--------------------

# RNN（循环神经网络） #

上一篇介绍到深度学习最经典的CNN，这一篇来研究一下深度学习同样经典的RNN。首先先研究清楚为什么我们有了CNN这么好用的神经网络后还需要循环神经网络。

## **为什么要用循环神经网络（RNN）？** ##

![20190715123552324.png][]

首先上图是一张普通的神经网络模型，卷积神经网络也是这样的，输入一张图片，中间经过一个神经网络，输出他的类别。

但是上面的输入是固定输入固定输出的，比如输入一张图片，输出一个类别，那么如果拿来做输入不固定，或者输出不固定，又或者二者都不固定的任务，是不是就没辙了，比如输入是一个句子，或者要求输出是一个句子，而且输出的句子长度也不固定。循环神经网络就是用于应对这样的序列式问题，所以为了处理这一类变长的数据和序列式的问题，我们需要使用循环神经网络。

## **循环神经网络（RNN）可以处理什么类型的任务？** ##

它一般可以处理三种类型的任务：1. 输入不固定，输出固定单一（多对一问题）2. 输入固定单一，输出不固定（一对多问题） 3. 输入和输出都不固定（多对多问题）

### **多对一问题** ###

这样的问题的模型结构一般是这样的：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjUyNjE5_size_16_color_FFFFFF_t_70][]

输入可能是一句话，输出是一个固定的输出，这种情况下卷积神经网络可能是无法处理的，这就需要循环神经网络，这样的问题对应到任务上有：**文本分类、情感分析**（给一句评论输出这句话的情感态度）

### **一对多问题** ###

一对多问题的模型结构一般是这样的：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjUyNjE5_size_16_color_FFFFFF_t_70 1][]

这种问题可能输入是一张图片，输出是一句话对吧，常见任务很经典的就是：**Image Caption**（当然输入前也是要加一层CNN抽特征的）

### **多对多问题** ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjUyNjE5_size_16_color_FFFFFF_t_70 2][]

对于这种多对多的问题我们也称为序列到序列的问题（Seq2Seq），最经典的毫无疑问就是**机器翻译**了，输入一个源语言的句子，输出一个目标语言的句子。

## **循环神经网络结构** ##

### **单层网络情况** ###

下图就是循环神经网络的一个结构，可以看到有一个自指向的一个箭头，它代表一个中间状态，从头到尾的输出通过维持一个中间状态来记录之前输出的情况（也就是上下文信息），该状态和下一步的输入一起作为输入。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjUyNjE5_size_16_color_FFFFFF_t_70 3][]

### **正向传播** ###

![s\_\{t\} = F(s\_\{t-1\}, x\_\{t\})][s_t_ _ F_s_t-1_ x_t]    **===>**   ![s\_\{t\} = tanh(s\_\{t-1\}, x\_\{t\})][s_t_ _ tanh_s_t-1_ x_t]   **===>**   ![y\_\{t\} = softmax(V \* s\_\{t\})][y_t_ _ softmax_V _ s_t]

![s\_\{t\}][s_t]代表当前输入，![s\_\{t-1\}][s_t-1]代表上一步输出的隐藏状态，他们通过F函数这样的非线性变换得到这一步输出的隐藏状态。W、U、V均为参数矩阵

损失函数就是每一步的输出计算一个损失，然后求和作为损失

最终通过softmax归一化算出最终概率，正向传播的过程也就是序列从头到尾的一个过程。

### **反向传播** ###

其过程是序列的尾部到头部的过程，设E为Loss的值，梯度下降现在E要对每个参数进行求偏导，保证每个方向都成下降趋势。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjUyNjE5_size_16_color_FFFFFF_t_70 4][]

可以看到参数矩阵都是共享的，每一步的W都是一样的，可以看成是一个变量。

我们计算对W的偏导计算梯度 ：

![\\frac\{\\partial E\}\{\\partial W\} = \\sum\_\{0\}^\{t\} \\frac\{\\partial E\_ \{t\}\}\{\\partial W\}][frac_partial E_partial W_ _ _sum_0_t_ _frac_partial E_ _t_partial W]

通过一个变换：

![\\frac\{\\partial E\_\{t\}\}\{\\partial W\} = \\frac\{\\partial E\_\{t\}\}\{\\partial y\_\{t\}\} \\frac\{\\partial y\_\{t\}\}\{\\partial s\_\{t\}\} \\frac\{\\partial s\_\{t\}\}\{\\partial W\}][frac_partial E_t_partial W_ _ _frac_partial E_t_partial y_t_ _frac_partial y_t_partial s_t_ _frac_partial s_t_partial W]

但![s\_\{t\}][s_t]对W求偏导是比较困难的，通过上面的公式可以知道![s\_\{t\}][s_t]是![s\_\{t-1\}][s_t-1]的函数：

![s\_\{t\} = tanh(s\_\{t-1\}, x\_\{t\})][s_t_ _ tanh_s_t-1_ x_t]（正向传播中的公式）

那么，知道这一点我们的公式可以变换为：

![\\frac\{\\partial E\_\{t\}\}\{\\partial W\} = \\frac\{\\partial E\_\{t\}\}\{\\partial y\_\{t\}\} \\frac\{\\partial y\_\{t\}\}\{\\partial s\_\{t\}\} (\\prod\_\{i = j + 1\}^\{t\} \\frac\{\\partial s\_\{i\}\}\{\\partial s\_\{i-1\}\}) \\frac\{\\partial s\_\{j\}\}\{\\partial W\}][frac_partial E_t_partial W_ _ _frac_partial E_t_partial y_t_ _frac_partial y_t_partial s_t_ _prod_i _ j _ 1_t_ _frac_partial s_i_partial s_i-1_ _frac_partial s_j_partial W]

当 j = 0的时候，![s\_\{0\}][s_0]对W求偏导是比较容易的，那么我们的反向传播的机制就会变成如下的一个流程：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjUyNjE5_size_16_color_FFFFFF_t_70 5][]

它会从当前时间的损失，一直反向传播到最开始的状态，影响到最开始的节点。

### **存在问题** ###

**梯度消失**，或者说较远的步骤对梯度下降贡献小。

来看看这个激活函数：tanh

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjUyNjE5_size_16_color_FFFFFF_t_70 6][]

可以看到激活函数的导数的范围是在  \[0 , 1\] 之间的，那么我们上面这条公式的中间求偏导假如步骤拉的很长的话，中间有十几步连乘，那么每一个 ![\\frac\{\\partial s\_\{i\}\}\{\\partial s\_\{i-1\}\}][frac_partial s_i_partial s_i-1]的值都在\[ 0, 1 \]之间，假设他们的值都是0.1也就是10的-1次方， 那么全部相乘也就是相当于10的负十几次方，这样的数微乎其微，基本可以当做消失了。那么说明我们的步骤拉的越长，对梯度的影响就越小，导致梯度消失。

### **优化方案** ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjUyNjE5_size_16_color_FFFFFF_t_70 7][]

对于这种问题我们可以通过只在黄色背景框的部分进行反向传播，缩短了序列长度。提高了程序执行效率并且解决了这样的问题。

### **多层网络情况** ###

多层的网络结构和单层的相似，就是再叠多几层，每一层的梯度下降还是和单层一致，输出给到下一层

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjUyNjE5_size_16_color_FFFFFF_t_70 8][]

**好处**

每一层经过一个非线性的变换，它的好处就是可以增加网络的拟合能力，神经网络的层数每多一层，它的语义层次，表达能力就更上一层楼，语义信息更强，对于具体的实际应用问题能更好拟合。

### **双向网络结构** ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjUyNjE5_size_16_color_FFFFFF_t_70 9][]

我们的序列按照正向的方向输入循环神经网络，那么逆向思维，我们能不能反向输入网络中，以未来状态作为初始状态呢，答案是ok的，这种做法就是双向的网络。

可以看到上图，输入的序列分别从两个方向输入网络中。

**好处**

如果单向的循环神经网络，我们当前的状态只能得到上文的信息，而得不到文末的信息，通过双向的网络结构，我们可以在当前时刻获得上下文的信息，将两个隐含状态做拼接给到输出。提高语言的表达能力。

**不足**

无法用于实时任务，比如输入的一句话是实时产生的，一开始的时候不知道最后的几个单词是什么，那么这种情况句子不完整，就没有句末的状态。

--------------------

# **LSTM（Long Short Term Memory）长短期记忆网络** #

LSTM大家可能都是非常熟悉了，随便翻几篇论文基本都能看见，那么为什么要提出LSTM，首先先来看RNN的不足之处。

刚才说到了RNN的参数共享的问题，也就是每一步的参数矩阵W是共享的，但是思考一个问题，就是一个W的矩阵将承载过多的信息，比如一个训练集有29000条句子，那么这个W矩阵要记录着29000种主谓情况，还有什么定状语从句，那么会导致一个什么问题，W矩阵信息过载，举个具体的例子：比如说句子里面有一个信息，小红去上学这一特征，但是这个特征假设对于我们整体的应用可能是没有用的，可能这一特征是有训练集有，测试集没有，那么如果我们把这些无关紧要的特征全部都记下来了，那我们的模型就变成了只能拟合训练集，在其他的测试集上表现不好导致过拟合，而且还有过载的问题就是这一个W的矩阵参数有限可能记录不了那么多的状态，有些不重要的信息记下来了，重要的可能记不下来了。

那么我们RNN的局限性就比较大了，每一句话过来都要记住全部的信息，对于我们的参数而言也有些负载，于是引入了LSTM选择性机制。

## **LSTM与RNN的不同** ##

LSTM是在RNN的单元上进行扩展，加入选择性机制：

1.  选择性输入
2.  选择性遗忘
3.  选择性输出

## **选择性机制的实现** ##

通过"门"机制，比如遗忘门等，其实际是通过Sigmoid的函数，Sigmoid的输出是0或者1，那么当一个值经过这个Sigmoid后若输出是0，选择将其遗忘，输出是1的话，选择将其记下来。

## **LSTM模型结构** ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjUyNjE5_size_16_color_FFFFFF_t_70 10][]

上面是一张经典的LSTM的结构图，可以看到它的大体结构和RNN的模型结构式一样的，只是在每个单元里面做了一些工作。![20190715131848921.png][]

为了理解模型图先来看看每个组件代表什么意思，黄色的框代表一个网络结构，粉色的圆形代表点积操作，一个箭头代表向量传递，第四个代表向量拼接，最后一个代表向量copy。

### **记忆单元状态** ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjUyNjE5_size_16_color_FFFFFF_t_70 11][]

这里![C\_\{t\}][C_t]就代表一个隐含状态。隐含状态会经过一个点乘，也就是一个遗忘门，后面还会经过一个相加，是加入输入的信息，然后传给下一个状态。

### **遗忘门** ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjUyNjE5_size_16_color_FFFFFF_t_70 12][]

![h\_\{t-1\}][h_t-1]是上一个单元的输出，![x\_\{t\}][x_t]是当前状态的输入，![h\_\{t-1\}][h_t-1]和![x\_\{t\}][x_t]同时作为输入输入到遗忘门中，经过遗忘门会得到0和1的向量，和上一个隐含状态做点积，物理意义可以理解为：当输入一些新的东西之后，模型会考虑遗忘之前的那些东西。

### 输入门 ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjUyNjE5_size_16_color_FFFFFF_t_70 13][]

输入仍是上一个单元的输出和当前的输入，可以看到左边的门机制是传入门，控制传入的信息，其机制和遗忘门类似，而右侧的tanh看他的公式和RNN的隐含状态的公式差不多：

![20190715132946764.png][]

输入通过这样的激活函数得到一个新的隐含状态![C\_\{t\}][C_t]，然后在通过传入门输出的 i 进行选择，他从物理意义上也就是一句话的语义有一部分要输入有一部分不要输入，选择后和隐含状态进行相加（融入隐含状态中）

### 输出门 ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjUyNjE5_size_16_color_FFFFFF_t_70 14][]

和上面两个门的机制一样，输出门是选择性输出，输入通过一个门机制选择那些东西要输出，计算出选择向量![o\_\{t\}][o_t]，然后和融合完的隐含状态![C\_\{t\}][C_t]做点积，得到输出 ![h\_\{t\}][h_t]

上面就是所谓的LSTM模型结构。

--------------------

# **GRU（Gated Recurrent Unit）门控循环单元** #

考虑到LSTM网络输入们和遗忘门之间有一些互补的关系，因此同时使用两个门机制显得有些冗余。

于是思考将输入门和遗忘门进行合并，合并的思路如下：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjUyNjE5_size_16_color_FFFFFF_t_70 15][]

通过一个门机制互补的形式合并输入门和遗忘门，并将其叫做更新门

GRU的结构图如下：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjUyNjE5_size_16_color_FFFFFF_t_70 16][]

1.输入门与和遗忘门合并成一个门：更新门 zt：

![20190715133231649.png][]

左侧的红色矩形框相当于原本的遗忘门，通过门机制点积上一个隐含状态，Sigmoid的取值为0或1，可以决定哪些特征遗忘，哪些特征保留。右侧的红色椭圆框代表原本的输入门，通过门机制去决定哪些需要输入，哪些不需要输入。

2.引入重置门 ![r\_\{t\}][r_t]，用来控制输入的内容的计算是否依赖上一时刻的状态 ![h\_\{t-1\}][h_t-1]，决定上一个隐含状态，对当前的输入内容有多少影响。这么说可能有点抽象，大家可能就会有一个疑问：那么我不是有输入门（现融进更新门）控制哪些需要输入哪些不用输入吗？那这个重置门又来控制一遍，不是做了重复工？

解决疑问：OK，这个问题也是我最初的问题，后来思考明白了，首先我们来看输入内容的公式

![20190715133314958.png][]

可以看到这里![r\_\{t\}][r_t]是乘以![h\_\{t-1\}][h_t-1]，那么可以说明什么？说明重置门控制的是上一个隐含状态![h\_\{t-1\}][h_t-1]在输入内容里面的占比

而输入门的公式是怎么样的？

![20190715133329959.png][]

输入门是乘以整一个输入内容，那么两者控制的内容是不是不一样？

如果还是很迷可以这么来看，输入门控制的是![\[ h\_\{t-1\}, x \]][h_t-1_ x]这个整体的比例，而重置门控制的是![\[ h\_\{t-1\}, x \]][h_t-1_ x] 中ht-1这一个变量的比例。

3.去除 LSTM 中的内部细胞记忆单元 ![C\_\{t\}][C_t]， 直接在当前状态 ![h\_\{t\}][h_t] 和历史状态 ![h\_\{t-1\}][h_t-1]之间引入线性依赖关系

--------------------

# **LSTM实现简单文本分类** #

## 预处理 ##

数据集：

格式

类别 \\t 一段一百字左右的中文新闻\\n

样本截图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjUyNjE5_size_16_color_FFFFFF_t_70 17][]

预处理分词后结果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjUyNjE5_size_16_color_FFFFFF_t_70 18][]

数据集及预处理完毕文件下载：

链接：https://pan.baidu.com/s/1H\_xSJvfoS3r2bS97KtFsaQ   
提取码：i2h6

## 代码 ##

版本：

tensorflow 1.13.1

python 3.6

代码逐行注释，所以不做文字说明：

import tensorflow as tf
    import os
    import sys
    import numpy as np
    import math
    
    # 打印日志
    tf.logging.set_verbosity(tf.logging.INFO)
    
    
    def get_default_params():
        # 返回对象
        return tf.contrib.training.HParams(
            # 词向量大小
            num_embedding_size=16,
            # 步长
            num_timesteps=50,
            # lstm单元输出维度（又叫输出神经元数）
            num_lstm_nodes=[32, 32],
            # 层数
            num_lstm_layers=2,
            # 全连接输出维度，最后一维
            num_fc_nodes=32,
            batch_size=100,
            # 控制梯度，梯度上线
            clip_lstm_grads=1.0,
            # 学习率
            learning_rate=0.001,
            # 词频最低下限
            num_word_threshold=10
        )
    
    
    # 设置参数
    hps = get_default_params()
    
    train_file = 'data/new_train_seg.txt'
    val_file = 'data/new_val_seg.txt'
    test_file = 'data/new_test_seg.txt'
    vocab_file = 'data/new_vocab.txt'
    category_file = 'data/new_category.txt'
    
    
    class Vocab:
        def __init__(self, filename, num_word_threshold):
            # 词典
            self._word_to_id = {}
            # <UNK> 的id（初始值）
            self._unk = -1
            # 频率下限
            self._num_word_threshold = num_word_threshold
            # 将词典读出来存到dict里
            self._read_dict(filename)
    
        def _read_dict(self, filename):
            with open(filename, 'r', encoding="utf-8") as f:
                lines = f.readlines()
            for line in lines:
                word, frequency = line.strip('\r\n').split('\t')
                frequency = int(frequency)
                # 低于下限不要
                if frequency < self._num_word_threshold:
                    continue
                idx = len(self._word_to_id)
                if word == '<UNK>':
                    # 刷新UNK的id
                    self._unk = idx
                self._word_to_id[word] = idx
    
        def word_to_id(self, word):
            # 如果没有word返回UNK
            return self._word_to_id.get(word, self._unk)
    
        @property
        def unk(self):
            return self._unk
    
        def size(self):
            # 返回大小
            return len(self._word_to_id)
    
        def sentence_to_id(self, sentence):
            # 分词进字典里吧id取出来变成list
            word_ids = [self.word_to_id(cur_word) for cur_word in sentence.split()]
            return word_ids
    
    
    class CategoryDict:
        def __init__(self, filename):
            self._category_to_id = {}
            # 读取类别并存入字典，给每个一个id
            with open(filename, 'r', encoding="utf-8") as f:
                lines = f.readlines()
            for line in lines:
                category = line.strip('\r\n')
                idx = len(self._category_to_id)
                self._category_to_id[category] = idx
    
        def size(self):
            return len(self._category_to_id)
    
        def category_to_id(self, category):
            # 传入类别返回id
            if not category in self._category_to_id:
                print("%s is not in our category list" % category)
            return self._category_to_id[category]
    
    
    # 建立词典
    vocab = Vocab(vocab_file, hps.num_word_threshold)
    vocab_size = vocab.size()
    # 打日志
    tf.logging.info('vocab_size: %d' % vocab_size)
    # 建立类别词典
    category_vocab = CategoryDict(category_file)
    num_classes = category_vocab.size()
    tf.logging.info('num_classes: %d' % num_classes)
    
    
    class TextDataSet:
        def __init__(self, filename, vocab, category_vocab, num_timesteps):
            self._vocab = vocab
            self._category_vocab = category_vocab
            self._num_timesteps = num_timesteps
            # matrix
            self._inputs = []
            # vector
            self._outputs = []
            self._indicator = 0
            self._parse_file(filename)
    
        def _parse_file(self, filename):
            tf.logging.info('Loading data from %s', filename)
            with open(filename, 'r', encoding="utf-8") as f:
                lines = f.readlines()
            for line in lines:
                label, content = line.strip('\r\n').split('\t')
                # 将传入的类别转化为对应的id
                id_label = self._category_vocab.category_to_id(label)
                # 将传入的句子转化为一个词一个词对应的id
                id_words = self._vocab.sentence_to_id(content)
                # 控制句长在50,超过截断
                id_words = id_words[0: self._num_timesteps]
                # padding
                padding_num = self._num_timesteps - len(id_words)
                id_words = id_words + [
                    self._vocab.unk for i in range(padding_num)]
                # 将句子的向量放到输入list
                self._inputs.append(id_words)
                # 将类别的向量放到输出的list
                self._outputs.append(id_label)
            self._inputs = np.asarray(self._inputs, dtype=np.int32)
            self._outputs = np.asarray(self._outputs, dtype=np.int32)
            self._random_shuffle()
            self._num_examples = len(self._inputs)
    
        def _random_shuffle(self):
            # 整个input的顺序
            p = np.random.permutation(len(self._inputs))
            self._inputs = self._inputs[p]
            self._outputs = self._outputs[p]
    
        def num_examples(self):
            # 返回输入list的长度
            return self._num_examples
    
        def next_batch(self, batch_size):
            # 获取下一个batch
            end_indicator = self._indicator + batch_size
            # 当获取的指针超过数据集大小时，归0
            if end_indicator > len(self._inputs):
                self._random_shuffle()
                self._indicator = 0
                end_indicator = batch_size
            # 归0还超过就报错
            if end_indicator > len(self._inputs):
                print("batch_size: %d is too large" % batch_size)
    
            # 取值
            batch_inputs = self._inputs[self._indicator: end_indicator]
            batch_outputs = self._outputs[self._indicator: end_indicator]
            self._indicator = end_indicator
            return batch_inputs, batch_outputs
    
    
    train_dataset = TextDataSet(
        train_file, vocab, category_vocab, hps.num_timesteps)
    val_dataset = TextDataSet(
        val_file, vocab, category_vocab, hps.num_timesteps)
    test_dataset = TextDataSet(
        test_file, vocab, category_vocab, hps.num_timesteps)
    
    
    # 创建模型
    def create_model(hps, vocab_size, num_classes):
        num_timesteps = hps.num_timesteps
        batch_size = hps.batch_size
    
        # 占位，当run的时候赋值
        inputs = tf.placeholder(tf.int32, (batch_size, num_timesteps))
        outputs = tf.placeholder(tf.int32, (batch_size,))
        # dropout
        keep_prob = tf.placeholder(tf.float32, name='keep_prob')
    
        # 保存模型运行进度
        global_step = tf.Variable(
            tf.zeros([], tf.int64), name='global_step', trainable=False)
    
        # embedding的值初始化到-1到1
        embedding_initializer = tf.random_uniform_initializer(-1.0, 1.0)
        # 上下文管理器
        with tf.variable_scope(
                'embedding', initializer=embedding_initializer):
            embeddings = tf.get_variable(
                'embedding',
                [vocab_size, hps.num_embedding_size],
                tf.float32)
            #在embedding的命名空间内创建名字为embedding的变量
            # [1, 10, 7] -> [embeddings[1], embeddings[10], embeddings[7]]
            embed_inputs = tf.nn.embedding_lookup(embeddings, inputs)
    
        # 初始化随机值
        scale = 1.0 / math.sqrt(hps.num_embedding_size + hps.num_lstm_nodes[-1]) / 3.0
        lstm_init = tf.random_uniform_initializer(-scale, scale)
        with tf.variable_scope('lstm_nn', initializer=lstm_init):
            # 双层所以写一个list
            cells = []
            for i in range(hps.num_lstm_layers):
                # 先设置每一层的
                cell = tf.contrib.rnn.BasicLSTMCell(
                    # 输出神经元的数量，也就是输出一个32维的向量
                    hps.num_lstm_nodes[i],
                    state_is_tuple=True)
                # dropout
                cell = tf.contrib.rnn.DropoutWrapper(
                    cell,
                    output_keep_prob=keep_prob)
                # 双层的，将每一层加入列表
                cells.append(cell)
            # 合并两层
            cell = tf.contrib.rnn.MultiRNNCell(cells)
    
            # 初始化隐含状态为0
            initial_state = cell.zero_state(batch_size, tf.float32)
            # rnn_outputs => [batch_size, num_timesteps, lstm_outputs[-1]（32）]
            rnn_outputs, _ = tf.nn.dynamic_rnn(
                cell, embed_inputs, initial_state=initial_state)
            # 取最后一步
            # [batch_size, 1, lstm_outputs[-1]（32）]
            last = rnn_outputs[:, -1, :]
    
        # 输出和全连接层拼接
        fc_init = tf.uniform_unit_scaling_initializer(factor=1.0)
        with tf.variable_scope('fc', initializer=fc_init):
            # 上面lstm的cell的输出拿过来
            # 激活函数用relu
            # 第二个参数是输出维度大小，就是最后一个参数,这里是没有变化的
            fc1 = tf.layers.dense(last,
                                  hps.num_fc_nodes,
                                  activation=tf.nn.relu,
                                  name='fc1')
            # dropout
            fc1_dropout = tf.contrib.layers.dropout(fc1, keep_prob)
            # [batch_size, 1, lstm_outputs[-1]（32）]
            # 在经过一层全连接映射到多少个类别上 [batch_size, 1, class_size]
            # [batch_size, 1 , 10]
            logits = tf.layers.dense(fc1_dropout,
                                     num_classes,
                                     name='fc2')
    
        with tf.name_scope('metrics'):
            # 做了softmax并且计算了差值，如果单单softmax => tf.nn.softmax(self.logits)
            softmax_loss = tf.nn.sparse_softmax_cross_entropy_with_logits(
                logits=logits, labels=outputs)
            # 计算均值
            loss = tf.reduce_mean(softmax_loss)
            # [0, 1, 5, 4, 2] -> argmax: 2（下标）
            # 这里第一个参数就是softmax，第二个参数意思是取第几维最大，比如是1的话就是在第一维里去最大
            y_pred = tf.argmax(tf.nn.softmax(logits),
                               1,
                               output_type=tf.int32)
            # 计算准确率，看看算对多少个
            correct_pred = tf.equal(outputs, y_pred)
            # tf.cast  将数据转换成 tf.float32 类型
            accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))
    
        with tf.name_scope('train_op'):
            # 获得所有可训练的变量（优化器优化列表中的变量）
            tvars = tf.trainable_variables()
            # 看看这些变量叫啥
            for var in tvars:
                tf.logging.info('variable name: %s' % (var.name))
            # tf.gradients求导（梯度下降，对每个训练变量求偏导，每个方向都往下走）
            # 不超过hps.clip_lstm_grads，防止梯度爆炸
            grads, _ = tf.clip_by_global_norm(
                tf.gradients(loss, tvars), hps.clip_lstm_grads)
            # Adam优化器
            optimizer = tf.train.AdamOptimizer(hps.learning_rate)
            # 这里是应用，将梯度grads应用到变量上,让函数吧global_step回调
            train_op = optimizer.apply_gradients(
                zip(grads, tvars), global_step=global_step)
    
        return ((inputs, outputs, keep_prob),
                (loss, accuracy),
                (train_op, global_step))
    
    
    placeholders, metrics, others = create_model(
        hps, vocab_size, num_classes)
    
    inputs, outputs, keep_prob = placeholders
    loss, accuracy = metrics
    train_op, global_step = others
    
    
    def eval_holdout(sess, accuracy, dataset_for_test, batch_size):
        # 数据集大小/batch_size  其实就是iter，校验集拿来校验一轮
        num_batches = dataset_for_test.num_examples() // batch_size
        tf.logging.info("Eval holdout: num_examples = %d, batch_size = %d",
                        dataset_for_test.num_examples(), batch_size)
        accuracy_vals = []
        for i in range(num_batches):
            batch_inputs, batch_labels = dataset_for_test.next_batch(batch_size)
            accuracy_val = sess.run(accuracy,
                                    feed_dict = {
                                        inputs: batch_inputs,
                                        outputs: batch_labels,
                                        keep_prob: 1.0,
                                    })
            accuracy_vals.append(accuracy_val)
        # 计算平均准确率
        return np.mean(accuracy_vals)
    
    
    init_op = tf.global_variables_initializer()
    # dropout
    train_keep_prob_value = 0.8
    # 跑一万个batch
    num_train_steps = 10000
    
    
    with tf.Session() as sess:
        sess.run(init_op)
        for i in range(num_train_steps):
            batch_inputs, batch_labels = train_dataset.next_batch(
                hps.batch_size)
            # 那三个占位符输进去
            # 计算loss, accuracy, train_op, global_step的图
            outputs_val = sess.run([loss, accuracy, train_op, global_step],
                                   feed_dict={
                                       inputs: batch_inputs,
                                       outputs: batch_labels,
                                       keep_prob: train_keep_prob_value,
                                   })
            loss_val, accuracy_val, _, global_step_val = outputs_val
            # 两百个batch输出一次
            if global_step_val % 200 == 0:
                tf.logging.info("Step: %5d, loss: %3.3f, accuracy: %3.3f"
                                % (global_step_val, loss_val, accuracy_val))
    
            # 一千个batch校验一次
            if global_step_val % 1000 == 0:
                accuracy_eval = eval_holdout(sess, accuracy, val_dataset, hps.batch_size)
                accuracy_test = eval_holdout(sess, accuracy, test_dataset, hps.batch_size)
                tf.logging.info("Step: %5d, val_accuracy: %3.3f, test_accuracy: %3.3f"
                                % (global_step_val, accuracy_eval, accuracy_test))

## 效果截图： ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjUyNjE5_size_16_color_FFFFFF_t_70 19][]

以上是对循环神经网络的粗浅认识

本菜鸟学习不好，如有不妥望各位大佬指点

如要转载请说明原文：[https://blog.csdn.net/qq\_36652619/article/details/95952068][https_blog.csdn.net_qq_36652619_article_details_95952068]

[20190715123552324.png]: /images/20211209/897fc49ac42c430b8f780ffca717d866.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjUyNjE5_size_16_color_FFFFFF_t_70]: /images/20211209/b4f51aa4147b4a5398a2da426f8a3afa.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjUyNjE5_size_16_color_FFFFFF_t_70 1]: /images/20211209/b5888ab1828349338f148d2efb46d05f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjUyNjE5_size_16_color_FFFFFF_t_70 2]: /images/20211209/c0066f1aa92743bd8ce85dbec4f5f8c8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjUyNjE5_size_16_color_FFFFFF_t_70 3]: /images/20211209/aefbd5cb1aa74a89a8d5706a29fb8c9d.png
[s_t_ _ F_s_t-1_ x_t]: https://private.codecogs.com/gif.latex?s_%7Bt%7D%20%3D%20F%28s_%7Bt-1%7D%2C%20x_%7Bt%7D%29
[s_t_ _ tanh_s_t-1_ x_t]: https://private.codecogs.com/gif.latex?s_%7Bt%7D%20%3D%20tanh%28s_%7Bt-1%7D%2C%20x_%7Bt%7D%29
[y_t_ _ softmax_V _ s_t]: https://private.codecogs.com/gif.latex?y_%7Bt%7D%20%3D%20softmax%28V%20*%20s_%7Bt%7D%29
[s_t]: https://private.codecogs.com/gif.latex?s_%7Bt%7D
[s_t-1]: https://private.codecogs.com/gif.latex?s_%7Bt-1%7D
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjUyNjE5_size_16_color_FFFFFF_t_70 4]: /images/20211209/1fefdd7aec3845598f1907a65cf611af.png
[frac_partial E_partial W_ _ _sum_0_t_ _frac_partial E_ _t_partial W]: https://private.codecogs.com/gif.latex?%5Cfrac%7B%5Cpartial%20E%7D%7B%5Cpartial%20W%7D%20%3D%20%5Csum_%7B0%7D%5E%7Bt%7D%20%5Cfrac%7B%5Cpartial%20E_%20%7Bt%7D%7D%7B%5Cpartial%20W%7D
[frac_partial E_t_partial W_ _ _frac_partial E_t_partial y_t_ _frac_partial y_t_partial s_t_ _frac_partial s_t_partial W]: https://private.codecogs.com/gif.latex?%5Cfrac%7B%5Cpartial%20E_%7Bt%7D%7D%7B%5Cpartial%20W%7D%20%3D%20%5Cfrac%7B%5Cpartial%20E_%7Bt%7D%7D%7B%5Cpartial%20y_%7Bt%7D%7D%20%5Cfrac%7B%5Cpartial%20y_%7Bt%7D%7D%7B%5Cpartial%20s_%7Bt%7D%7D%20%5Cfrac%7B%5Cpartial%20s_%7Bt%7D%7D%7B%5Cpartial%20W%7D
[frac_partial E_t_partial W_ _ _frac_partial E_t_partial y_t_ _frac_partial y_t_partial s_t_ _prod_i _ j _ 1_t_ _frac_partial s_i_partial s_i-1_ _frac_partial s_j_partial W]: https://private.codecogs.com/gif.latex?%5Cfrac%7B%5Cpartial%20E_%7Bt%7D%7D%7B%5Cpartial%20W%7D%20%3D%20%5Cfrac%7B%5Cpartial%20E_%7Bt%7D%7D%7B%5Cpartial%20y_%7Bt%7D%7D%20%5Cfrac%7B%5Cpartial%20y_%7Bt%7D%7D%7B%5Cpartial%20s_%7Bt%7D%7D%20%28%5Cprod_%7Bi%20%3D%20j%20&plus;%201%7D%5E%7Bt%7D%20%5Cfrac%7B%5Cpartial%20s_%7Bi%7D%7D%7B%5Cpartial%20s_%7Bi-1%7D%7D%29%20%5Cfrac%7B%5Cpartial%20s_%7Bj%7D%7D%7B%5Cpartial%20W%7D
[s_0]: https://private.codecogs.com/gif.latex?s_%7B0%7D
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjUyNjE5_size_16_color_FFFFFF_t_70 5]: /images/20211209/3715eed40759460095588f0d9c2fffcb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjUyNjE5_size_16_color_FFFFFF_t_70 6]: /images/20211209/a79a0fea035649f492c995350b1ff6e5.png
[frac_partial s_i_partial s_i-1]: https://private.codecogs.com/gif.latex?%5Cfrac%7B%5Cpartial%20s_%7Bi%7D%7D%7B%5Cpartial%20s_%7Bi-1%7D%7D
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjUyNjE5_size_16_color_FFFFFF_t_70 7]: /images/20211209/7f050d238db14db89dc0a1cc9f311a5c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjUyNjE5_size_16_color_FFFFFF_t_70 8]: /images/20211209/10e5eb7df31045e5a67355e191fe36f5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjUyNjE5_size_16_color_FFFFFF_t_70 9]: /images/20211209/9d34d1f6bb4c4a899359b967625b5b93.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjUyNjE5_size_16_color_FFFFFF_t_70 10]: /images/20211209/c8a5504e9fb748258c7f5edc21bda96a.png
[20190715131848921.png]: /images/20211209/d65640e330d54574a9b222d03c02afc7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjUyNjE5_size_16_color_FFFFFF_t_70 11]: /images/20211209/76aaf76343c741f6ab23a8a3312c8da4.png
[C_t]: https://private.codecogs.com/gif.latex?C_%7Bt%7D
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjUyNjE5_size_16_color_FFFFFF_t_70 12]: /images/20211209/a78adca7f59b4c20b2fd7fad74967b35.png
[h_t-1]: https://private.codecogs.com/gif.latex?h_%7Bt-1%7D
[x_t]: https://private.codecogs.com/gif.latex?x_%7Bt%7D
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjUyNjE5_size_16_color_FFFFFF_t_70 13]: /images/20211209/ca0f3ac95ba844aeae900c1e76d72dcd.png
[20190715132946764.png]: /images/20211209/8799ce5a9e5947a593170c784a5b4614.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjUyNjE5_size_16_color_FFFFFF_t_70 14]: /images/20211209/76fa70eaa4a94f08a95a1879901fa96f.png
[o_t]: https://private.codecogs.com/gif.latex?o_%7Bt%7D
[h_t]: https://private.codecogs.com/gif.latex?h_%7Bt%7D
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjUyNjE5_size_16_color_FFFFFF_t_70 15]: /images/20211209/6d568d0095a846b0a904244e77efe5fe.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjUyNjE5_size_16_color_FFFFFF_t_70 16]: /images/20211209/3148e42751124502beae79cf4ad3ac15.png
[20190715133231649.png]: /images/20211209/f64dd261d6a8427e803f8287dff9030a.png
[r_t]: https://private.codecogs.com/gif.latex?r_%7Bt%7D
[20190715133314958.png]: /images/20211209/a1fd0727c54e4644ab1b43c30cfad6c1.png
[20190715133329959.png]: /images/20211209/8927646d46054beba71724b940c1f825.png
[h_t-1_ x]: https://private.codecogs.com/gif.latex?%5B%20h_%7Bt-1%7D%2C%20x%20%5D
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjUyNjE5_size_16_color_FFFFFF_t_70 17]: /images/20211209/cb7b375cf5fd456bbb11a80b7c64ba66.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjUyNjE5_size_16_color_FFFFFF_t_70 18]: /images/20211209/908276c067114e4f8c176db59648f2b4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjUyNjE5_size_16_color_FFFFFF_t_70 19]: /images/20211209/d5e567b3b95445b1851a5d5b0f1c9a84.png
[https_blog.csdn.net_qq_36652619_article_details_95952068]: https://blog.csdn.net/qq_36652619/article/details/95952068