Chapter 6.2 理解循环神经网络.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "目前你见过的所有神经网络（比如密集连接网络和卷积神经网络）都有一个主要特点，那就是它们都没有记忆。它们单独处理每个输入，在输入与输入之间没有保存任何状态。对于这样的网络，要想处理数据点的序列或时间序列，你需要向网络同时展示整个序列，即将序列转换成单个数据点。例如，你在 IMDB示例中就是这么做的：将全部电影评论转换为一个大向量，然后一次性处理。这种网络叫作前馈网络（feedforward network）。   \n",
    "\n",
    "与此相反，当你在阅读这个句子时，你是一个词一个词地阅读（或者说，眼睛一次扫视一次扫视地阅读），同时会记住之前的内容。这让你能够动态理解这个句子所传达的含义。生物智能以渐进的方式处理信息，同时保存一个关于所处理内容的内部模型，这个模型是根据过去的信息构建的，并随着新信息的进入而不断更新。   \n",
    "\n",
    "循环神经网络（RNN，recurrent  neural network）采用同样的原理，不过是一个极其简化的版本：它处理序列的方式是，遍历所有序列元素，并保存一个状态（state），其中包含与已查看内容相关的信息。实际上，RNN是一类具有内部环的神经网络（见图   6-9）。在处理两个不同的独立序列（比如两条不同的 IMDB评论）之间，RNN状态会被重置，因此，你仍可以将一个序列看作单个数据点，即网络的单个输入。真正改变的是，数据点不再是在单个步骤中进行处理，相反，网络内部会对序列元素进行遍历。\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "为了将环（loop）和状态的概念解释清楚，我们用 Numpy来实现一个简单  RNN的前向传递。这个 RNN的输入是一个张量序列，我们将其编码成大小为 (timesteps,  input_features)的二维张量。它对时间步（timestep）进行遍历，在每个时间步，它考虑 t时刻的当前状态与 t时刻的输入［形状为 (input_ features,)］，对二者计算得到t时刻的输出。然后，我们将下一个时间步的状态设置为上一个时间步的输出。对于第一个时间步，上一个时间步的输出没有定义，所以它没有当前状态。因此，你需要将状态初始化为一个全零向量，这叫作网络的初始状态（initial state）。\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os, shutil\n",
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "from tensorflow import keras"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# RNN 伪代码\n",
    "state_t= 0 # t时刻的状态\n",
    "for input_t in input_sequence: # 对序列元素进行遍历\n",
    "    output_t= f(input_t, state_t) # f为自定义函数，从输入和状态到输出的变换，其参数一般包括两个矩阵(W和I)和一个偏置向量。\n",
    "    state_t= output_t\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# RNN 伪代码详细版\n",
    "state_t= 0 # t时刻的状态\n",
    "for input_t in input_sequence: # 对序列元素进行遍历\n",
    "    output_t= activation(dot(W, input_t)+dot(U, input_t)+b)\n",
    "    state_t= output_t\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 简单RNN的Numpy实现\n",
    "timesteps= 100 # 输入序列的时间步数\n",
    "input_features= 32 # 输入特征空间的维度\n",
    "output_features=64 # 输出特征空间的维度\n",
    "\n",
    "inputs= np.random.random((timesteps, input_features))  ## 输入数据：随机噪声\n",
    "state_t= np.zeros((output_features)) # 初始状态：全零向量\n",
    "\n",
    "W= np.random.random((output_features, input_features)) # 创建随机的权重矩阵\n",
    "U= np.random.random((output_features, output_features))\n",
    "b= np.random.random((output_features))\n",
    "\n",
    "successive_outputs=[]\n",
    "for input_t in inputs:\n",
    "    output_t= np.tanh(np.dot(W, input_t)+ np.dot(U, state_t)+b) # 由输入和当前状态(前一个输出)计算出当前输出# np.tanh= p.sinh(x)/np.cosh(x) \n",
    "                                                                # a=np.array([2,3,4]) b=np.array([3,4,5]) np.dot(a,b)=2*3+3*4+4*5\n",
    "    successive_outputs.append(output_t) #将这个输出保存到一个列表中\n",
    "    state_t=output_t\n",
    "    \n",
    "final_output_sequence= np.stack(successive_outputs,axis=0) #最终输出是一个形状为（timesteps，output_features）的二维张量\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "足够简单。总之，RNN是一个for循环，它重复使用循环前一次迭代的计算结果，仅此而已。当然，你可以构建许多不同的RNN，它们都满足上述定义。这个例子只是最简单的RNN表述之一。RNN的特征在于其时间步函数.   \n",
    "\n",
    "本例中，最终输出是一个形状为(timesteps,  output_features)的二维张量，其中每个时间步是循环在 t时刻的输出。输出张量中的每个时间步 t包含输入序列中时间步0~t的信息，即关于全部过去的信息。因此，在多数情况下，你并不需要这个所有输出组成的序列，你只需要最后一个输出（循环结束时的 output_t），因为它已经包含了整个序列的信息。\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6.2.1　Keras中的循环层\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow.keras.layers import SimpleRNN"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "二者有一点小小的区别： SimpleRNN层能够像其他   Keras层一样处理序列批量，而不是像 Numpy示例那样只能处理单个序列。因此，它接收形状为    (batch_size, timesteps,input_features)的输入，而不是(timesteps,  input_features)。\n",
    "\n",
    "与 Keras中的所有循环层一样，SimpleRNN可以在两种不同的模式下运行：一种是返回每个时间步连续输出的完整序列，即形状为 (batch_size, timesteps, output_features)的三维张量；另一种是只返回每个输入序列的最终输出，即形状为  (batch_size, output_features)的二维张量。这两种模式由 return_sequences这个构造函数参数来控制。我们来看一个使用SimpleRNN的例子，它只返回最后一个时间步的输出。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "embedding (Embedding)        (None, None, 32)          320000    \n",
      "_________________________________________________________________\n",
      "simple_rnn (SimpleRNN)       (None, 32)                2080      \n",
      "=================================================================\n",
      "Total params: 322,080\n",
      "Trainable params: 322,080\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "from tensorflow.keras.models import Sequential\n",
    "from tensorflow.keras.layers import Embedding, SimpleRNN\n",
    "\n",
    "model= Sequential()\n",
    "model.add(Embedding(10000,32))\n",
    "model.add(SimpleRNN(32)) # 添加 SimpleRNN\n",
    "model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential_2\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "embedding_2 (Embedding)      (None, None, 32)          320000    \n",
      "_________________________________________________________________\n",
      "simple_rnn_1 (SimpleRNN)     (None, None, 32)          2080      \n",
      "_________________________________________________________________\n",
      "simple_rnn_2 (SimpleRNN)     (None, None, 32)          2080      \n",
      "_________________________________________________________________\n",
      "simple_rnn_3 (SimpleRNN)     (None, None, 32)          2080      \n",
      "_________________________________________________________________\n",
      "simple_rnn_4 (SimpleRNN)     (None, 32)                2080      \n",
      "=================================================================\n",
      "Total params: 328,320\n",
      "Trainable params: 328,320\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "# 为了提高网络的表示能力，将多个循环层逐个堆叠有时也是很有用的。在这种情况下，你需要让所有中间层都返回完整的输出序列。\n",
    "model = Sequential()\n",
    "model.add(Embedding(10000, 32))\n",
    "model.add(SimpleRNN(32, return_sequences=True)) # 添加return_sequences则返回完整的状态序列。\n",
    "model.add(SimpleRNN(32, return_sequences=True))\n",
    "model.add(SimpleRNN(32, return_sequences=True))\n",
    "model.add(SimpleRNN(32))  # This last layer only returns the last outputs.\n",
    "model.summary()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "接下来，我们将这个模型应用于 IMDB电影评论分类问题。首先，对数据进行预处理。\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loading data...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<__array_function__ internals>:5: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "/Users/yihuawang/conda/lib/python3.8/site-packages/tensorflow/python/keras/datasets/imdb.py:159: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  x_train, y_train = np.array(xs[:idx]), np.array(labels[:idx])\n",
      "/Users/yihuawang/conda/lib/python3.8/site-packages/tensorflow/python/keras/datasets/imdb.py:160: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  x_test, y_test = np.array(xs[idx:]), np.array(labels[idx:])\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "25000 train sequences\n",
      "25000 test sequences\n",
      "Pad sequences (samples x time)\n",
      "input_train shape: (25000, 500)\n",
      "input_test shape: (25000, 500)\n"
     ]
    }
   ],
   "source": [
    "from tensorflow.keras.datasets import imdb\n",
    "from tensorflow.keras.preprocessing import sequence\n",
    "\n",
    "max_features = 10000  # number of words to consider as features\n",
    "maxlen = 500  # cut texts after this number of words (among top max_features most common words)\n",
    "batch_size = 32\n",
    "\n",
    "print('Loading data...')\n",
    "(input_train, y_train), (input_test, y_test) = imdb.load_data(num_words=max_features)\n",
    "print(len(input_train), 'train sequences')\n",
    "print(len(input_test), 'test sequences')\n",
    "\n",
    "print('Pad sequences (samples x time)')\n",
    "input_train = sequence.pad_sequences(input_train, maxlen=maxlen)\n",
    "input_test = sequence.pad_sequences(input_test, maxlen=maxlen)\n",
    "print('input_train shape:', input_train.shape)\n",
    "print('input_test shape:', input_test.shape)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/10\n",
      "157/157 [==============================] - 15s 89ms/step - loss: 0.6822 - acc: 0.5506 - val_loss: 0.5469 - val_acc: 0.7332\n",
      "Epoch 2/10\n",
      "157/157 [==============================] - 14s 86ms/step - loss: 0.4502 - acc: 0.8007 - val_loss: 0.4215 - val_acc: 0.8188\n",
      "Epoch 3/10\n",
      "157/157 [==============================] - 14s 86ms/step - loss: 0.3158 - acc: 0.8730 - val_loss: 0.4008 - val_acc: 0.8308\n",
      "Epoch 4/10\n",
      "157/157 [==============================] - 14s 86ms/step - loss: 0.2245 - acc: 0.9160 - val_loss: 0.4027 - val_acc: 0.8356\n",
      "Epoch 5/10\n",
      "157/157 [==============================] - 14s 86ms/step - loss: 0.1586 - acc: 0.9473 - val_loss: 0.4515 - val_acc: 0.8376\n",
      "Epoch 6/10\n",
      "157/157 [==============================] - 14s 89ms/step - loss: 0.0962 - acc: 0.9707 - val_loss: 0.7182 - val_acc: 0.7678\n",
      "Epoch 7/10\n",
      "157/157 [==============================] - 14s 91ms/step - loss: 0.0646 - acc: 0.9803 - val_loss: 0.5582 - val_acc: 0.8206\n",
      "Epoch 8/10\n",
      "157/157 [==============================] - 14s 90ms/step - loss: 0.0854 - acc: 0.9686 - val_loss: 0.6400 - val_acc: 0.8196\n",
      "Epoch 9/10\n",
      "157/157 [==============================] - 14s 90ms/step - loss: 0.0341 - acc: 0.9910 - val_loss: 0.7700 - val_acc: 0.7706\n",
      "Epoch 10/10\n",
      "157/157 [==============================] - 14s 90ms/step - loss: 0.0198 - acc: 0.9948 - val_loss: 0.7408 - val_acc: 0.7970\n"
     ]
    }
   ],
   "source": [
    "#我们用一个Embedding层和一个SimpleRNN层来训练一个简单的循环网络。\n",
    "\n",
    "from tensorflow.keras.layers import Dense\n",
    "model = Sequential()\n",
    "model.add(Embedding(max_features, 32))\n",
    "model.add(SimpleRNN(32))\n",
    "model.add(Dense(1, activation='sigmoid'))\n",
    "model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['acc'])\n",
    "history = model.fit(input_train, y_train,\n",
    "                    epochs=10,\n",
    "                    batch_size=128,\n",
    "                    validation_split=0.2)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#显示训练和验证的损失和精度\n",
    "import matplotlib.pyplot as plt\n",
    "acc = history.history['acc']\n",
    "val_acc = history.history['val_acc']\n",
    "loss = history.history['loss']\n",
    "val_loss = history.history['val_loss']\n",
    "epochs = range(1, len(acc) + 1)\n",
    "plt.plot(epochs, acc, 'bo', label='Training acc')\n",
    "plt.plot(epochs, val_acc, 'b', label='Validation acc')\n",
    "plt.title('Training and validation accuracy')\n",
    "plt.legend()\n",
    "plt.figure()\n",
    "plt.plot(epochs, loss, 'bo', label='Training loss')\n",
    "plt.plot(epochs, val_loss, 'b', label='Validation loss')\n",
    "plt.title('Training and validation loss')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在第 3章，处理这个数据集的第一个简单方法得到的测试精度是  88%。不幸的是，与这个基准相比，这个小型循环网络的表现并不好（验证精度只有 85%）。问题的部分原因在于，输入只考虑了前 500个单词，而不是整个序列，因此，RNN获得的信息比前面的基准模型更少。另一部分原因在于，SimpleRNN不擅长处理长序列，比如文本。\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6.2.2　理解 LSTM层和 GRU层\n",
    "LSTM层。其背后的长短期记忆（LSTM，long   short-term memory）, 是SimpleRNN层的一种变体，它增加了一种携带信息跨越多个时间步的方法。假设有一条传送带，其运行方向平行于你所处理的序列。序列中的信息可以在任意位置跳上传送带，然后被传送到更晚的时间步，并在需要时原封不动地跳回来。这实际上就是   LSTM的原理：它保存信息以便后面使用，从而防止较早期的信号在处理过程中逐渐消失。\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# SimpleRNN\n",
    "y = activation(dot(state_t, U) + dot(input_t, W) + b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# LSTM\n",
    "output_t = activation(dot(state_t, Uo) + dot(input_t, Wo) + dot(C_t, Vo) + bo) # 多了一个dot(C_t, Vo)\n",
    "\n",
    "\n",
    "i_t = activation(dot(state_t, Ui) + dot(input_t, Wi) + bi)\n",
    "f_t = activation(dot(state_t, Uf) + dot(input_t, Wf) + bf)\n",
    "k_t = activation(dot(state_t, Uk) + dot(input_t, Wk) + bk)\n",
    "\n",
    "# 对i_t、f_t和k_t进行组合，可以得到新的携带状态（下一个c_t）。\n",
    "c_(t+1) = i_t * k_t + c_t * f_t\n",
    "\n",
    "# 作为人类，理解它不应该是你要做的。你只需要记住 LSTM单元的作用：允许过去的信息稍后重新进入，从而解决梯度消失问题。\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6.2.3　Keras中一个  LSTM的具体例子\n",
    "现在我们来看一个更实际的问题：使用  LSTM层来创建一个模型，然后在    IMDB数据上训练模型（见图  6-16和图 6-17）。这个网络与前面介绍的SimpleRNN网络类似。你只需指定LSTM层的输出维度，其他所有参数（有很多）都使用  Keras默认值。Keras具有很好的默认值，无须手动调参，模型通常也能正常运行。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/10\n",
      "157/157 [==============================] - 29s 176ms/step - loss: 0.5931 - acc: 0.6812 - val_loss: 0.3478 - val_acc: 0.8554\n",
      "Epoch 2/10\n",
      "157/157 [==============================] - 25s 159ms/step - loss: 0.2973 - acc: 0.8845 - val_loss: 0.3476 - val_acc: 0.8512\n",
      "Epoch 3/10\n",
      "157/157 [==============================] - 26s 168ms/step - loss: 0.2300 - acc: 0.9171 - val_loss: 0.3098 - val_acc: 0.8656\n",
      "Epoch 4/10\n",
      "157/157 [==============================] - 26s 163ms/step - loss: 0.1969 - acc: 0.9318 - val_loss: 0.2966 - val_acc: 0.8796\n",
      "Epoch 5/10\n",
      "157/157 [==============================] - 26s 163ms/step - loss: 0.1771 - acc: 0.9356 - val_loss: 0.4911 - val_acc: 0.8360\n",
      "Epoch 6/10\n",
      "157/157 [==============================] - 25s 161ms/step - loss: 0.1548 - acc: 0.9463 - val_loss: 0.3442 - val_acc: 0.8828\n",
      "Epoch 7/10\n",
      "157/157 [==============================] - 25s 158ms/step - loss: 0.1379 - acc: 0.9527 - val_loss: 0.5131 - val_acc: 0.8286\n",
      "Epoch 8/10\n",
      "157/157 [==============================] - 25s 162ms/step - loss: 0.1308 - acc: 0.9551 - val_loss: 1.0895 - val_acc: 0.7834\n",
      "Epoch 9/10\n",
      "157/157 [==============================] - 25s 158ms/step - loss: 0.1343 - acc: 0.9600 - val_loss: 0.3467 - val_acc: 0.8866\n",
      "Epoch 10/10\n",
      "157/157 [==============================] - 25s 162ms/step - loss: 0.1043 - acc: 0.9660 - val_loss: 0.3820 - val_acc: 0.8830\n"
     ]
    }
   ],
   "source": [
    "from tensorflow.keras.layers import LSTM\n",
    "model = Sequential()\n",
    "model.add(Embedding(max_features, 32))\n",
    "model.add(LSTM(32))\n",
    "model.add(Dense(1, activation='sigmoid'))\n",
    "model.compile(optimizer='rmsprop',\n",
    "              loss='binary_crossentropy',\n",
    "              metrics=['acc'])\n",
    "history = model.fit(input_train, y_train,\n",
    "                    epochs=10,\n",
    "                    batch_size=128,\n",
    "                    validation_split=0.2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "acc = history.history['acc']\n",
    "val_acc = history.history['val_acc']\n",
    "loss = history.history['loss']\n",
    "val_loss = history.history['val_loss']\n",
    "epochs = range(1, len(acc) + 1)\n",
    "plt.plot(epochs, acc, 'bo', label='Training acc')\n",
    "plt.plot(epochs, val_acc, 'b', label='Validation acc')\n",
    "plt.title('Training and validation accuracy')\n",
    "plt.legend()\n",
    "plt.figure()\n",
    "plt.plot(epochs, loss, 'bo', label='Training loss')\n",
    "plt.plot(epochs, val_loss, 'b', label='Validation loss')\n",
    "plt.title('Training and validation loss')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "验证精度达到了  89%。还不错，肯定比 SimpleRNN网络好多了   \n",
    "\n",
    "但对于一种计算量如此之大的方法而言，这个结果也说不上是突破性的。为什么   LSTM不能表现得更好？   \n",
    "\n",
    "一个原因是你没有花力气来调节超参数，比如嵌入维度或   LSTM输出维度。   \n",
    "\n",
    "另一个原因可能是缺少正则化。   \n",
    "\n",
    "但说实话，主要原因在于，适用于评论分析全局的长期性结构（这正是 LSTM所擅长的），对情感分析问题帮助不大。   \n",
    "\n",
    "对于这样的基本问题，观察每条评论中出现了哪些词及其出现频率就可以很好地解决。这也正是第一个全连接方法的做法。    \n",
    "\n",
    "但还有更加困难的自然语言处理问题，特别是问答和机器翻译，这时 LSTM的优势就明显了。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6.2.4　小结\n",
    "\n",
    "现在你已经学会了以下内容。\n",
    "\n",
    "循环神经网络（RNN）的概念及其工作原理。   \n",
    "\n",
    "长短期记忆（LSTM）是什么，为什么它在长序列上的效果要好于普通  RNN。 因为LSTM允许过去的信息稍后重新进入，因此受梯度消失问题的影响要小的多。   \n",
    "\n",
    "如何使用  Keras的  RNN层来处理序列数据。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}