Chap14-Recurrent_Neural_Networks/Chap14_3-Recurrent_Neural_Networks.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Chap14-3. 순환 신경망 (RNN, Recurrent Neural Network) - (3)\n",
    "\n",
    "저번 포스팅인 [07-2. 순환 신경망(RNN) - (2)](http://excelsior-cjh.tistory.com/184)에서는 RNN을 학습시키는 방법인 BPTT와 텐서플로를 이용해 MNIST 분류기와 시계열 데이터를 예측하는 RNN 모델을 구현해 보았다. 그리고 심층 RNN을 구현하는 방법과 RNN에 드롭아웃을 적용하는 방법에 대해 알아보았다. \n",
    "\n",
    "이번 포스팅에서는 RNN의 변형이라고 할 수 있는 LSTM과 LSTM의 변형인 GRU에 대해 알아보도록 하자."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. RNN Cell의 문제점"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.1 BPTT의 문제점\n",
    "\n",
    "[저번 포스팅](http://excelsior-cjh.tistory.com/184)에서 살펴본 BPTT는 RNN에서의 역전파 방법인 BPTT(BackPropagation Through Time)은 아래의 그림과 같이 모든 타임스텝마다 처음부터 끝까지 역전파한다.\n",
    "\n",
    "\n",
    "\n",
    "![bptt](./images/bptt01.png)\n",
    "\n",
    "\n",
    "\n",
    "그렇기 때문에 타임 스텝이 클 경우, 위의 그림과 같이 RNN을 펼치게(unfold)되면 매우 깊은 네트워크가 될것이며, 이러한 네트워크는 [05-1. 심층 신경망 학습](http://excelsior-cjh.tistory.com/177?category=940400)에서 살펴본 **그래디언트 소실 및 폭주**(vanishing & exploding gradient) 문제가 발생할 가능성이 크다. 그리고, 계산량 또한 많기 때문에 한번 학습하는데 아주 오랜 시간이 걸리는 문제가 있다. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Truncated BPTT\n",
    "\n",
    "BPTT의 이러한 문제를 해결하기 위해 아래의 그림과 같이 타임 스텝을 일정 구간(보통 5-steps)으로 나누어 역전파(backprop)를 계산하여, 전체 역전파로 근사시키는 방법인 **Truncated BPTT**를  대안으로 사용할 수 있다. \n",
    "\n",
    "\n",
    "\n",
    "![truncated-bptt](./images/bptt02.png)\n",
    "\n",
    "\n",
    "\n",
    "하지만 truncated-BPTT의 문제는 만약 학습 데이터가 장기간에 걸쳐 패턴이 발생한다고 하면, 이러한 장기간(Long-Term)의 패턴을 학습할 수 없는 문제가 있다. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.2 장기 의존성(Long-Term Dependency) 문제\n",
    "\n",
    "[저번 포스팅](http://excelsior-cjh.tistory.com/183)에서 살펴 보았듯이 RNN은 타임 스텝 $t$에서 이전 타임 스텝($t-1$)의 상태(state, $h_{t-1}$)를 입력으로 받는 구조이기 때문에,  이전의 정보가 현재의 타임 스텝 $t$에 영향을 줄 수 있다. 따라서, RNN의 순환 뉴런(Reccurent Neurons)의 출력은 이전 타임 스텝의 모든 입력에 대한 함수이므로, 이를 **메모리 셀(memory cell)**이라고 한다. \n",
    "\n",
    "이렇듯, RNN은 이론적으로 모든 이전 타임 스텝이 영향을 주지만 앞쪽의 타임 스텝(예를 들어 $t=0, t=1$)은 타임 스텝이 길어질 수록 영향을 주지 못하는 문제가 발생하는데 이를 **장기 의존성(Long-Term Dependency) 문제**라고 한다. 이러한 문제가 발생하는 이유는 입력 데이터가 RNN Cell을 거치면서 특정 연산을 통해 데이터가 변환되어, 일부 정보는 타임 스텝마다 사라지기 때문이다.\n",
    "\n",
    "\n",
    "\n",
    "![](./images/rnn08.png)\n",
    "\n",
    "\n",
    "\n",
    "이러한 문제를 해결하기 위해 장기간의 메모리를 가질 수 있는 여러 종류의 셀이 만들어졌는데, 그 중에서 대표적인 셀들이 LSTM과 GRU 셀이다. 먼저, LSTM 셀에 대해 알아보도록 하자."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. LSTM Cell\n",
    "\n",
    "[**LSTM**(Long Short-Term Memory) 셀](https://www.mitpressjournals.org/doi/abs/10.1162/neco.1997.9.8.1735#.WIxuWvErJnw)은 S.Hochreiter와 J.Schmidhuber가 1997년에 제안한 셀로써, RNN 셀의 장기 의존성 문제를 해결할 뿐만 아니라 학습 또한 빠르게 수렴한다. LSTM 셀의 구조는 아래의 그림(원 출처: [colah's blog](http://colah.github.io/posts/2015-08-Understanding-LSTMs/))과 같다.\n",
    "\n",
    "\n",
    "\n",
    "![LSTM](./images/lstm.PNG)\n",
    "\n",
    "\n",
    "\n",
    "위의 그림에서 보면 LSTM 셀에서는 상태(state)가 두 개의 벡터 $\\mathbf{h}_t$와 $\\mathbf{c}_t$로 나누어 진다는 것을 알 수 있다. $\\mathbf{h}_t$를 단기 상태(short-term state), $\\mathbf{c}_t$를 장기 상태(long-term state)라고 볼 수 있다. \n",
    "\n",
    "위의 LSTM 셀을 자세히 살펴보도록 하자. LSTM의 핵심은 네트워크가 장기 상태($\\mathbf{c}_t$)에서 기억할 부분, 삭제할 부분,  그리고 읽어 들일 부분을 학습하는 것이다. 장기 기억 $\\mathbf{c}_{t-1}$은 셀의 왼쪽에서 오른쪽으로 통과하게 되는데 **forget gate**를 지나면서 일부를 기억(정보)을 잃고, 그 다음 덧셈(+) 연산으로 **input gate**로 부터 새로운 기억 일부를 추가한다. 이렇게 만들어진 $\\mathbf{c}_t$는 별도의 추가 연산 없이 바로 출력되며, 이러한 장기 기억 $\\mathbf{c}_t$는 타임 스텝마다 일부의 기억을 삭제하고 추가하는 과정을 거치게 된다. 그리고 덧셈 연산 후에 $\\mathbf{c}_t$는 복사되어 **output gate**의 $\\tanh$함수로 전달되어 단기 상태 $\\mathbf{h}_{t}$와 셀의 출력인 $\\mathbf{y}_t$를 만든다. 이번에는 위에서 설명한 forget, input, output 게이트(gate)가 어떻게 작동하는지에 대해 알아보도록 하자. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "먼저, 현재 입력 벡터 $\\mathbf{x}_{t}$와 이전의 단기 상태 $\\mathbf{h}_{t-1}$이 **네 개의 다른 FC-레이어(Fully-Connected layer)에 주입**되는데, 이 레이어는 모두 다음과 같이 다른 목적을 가진다.\n",
    "\n",
    "- 주요 레이어는 $\\mathbf{g}_t​$를 출력하는 레이어이며, 현재 입력 데이터 $\\mathbf{x}_t​$와 이전 타임스텝의 단기 상태 $\\mathbf{h}_{t-1}​$을 분석하는 역할을 한다. LSTM 셀에서는 이 레이어의 출력인 $\\mathbf{g}_{t}​$가 $\\mathbf{i}_{t}​$의 곱셈($\\times​$)연산 후 장기 상태 $\\mathbf{c}_{t}​$에 일부분이 더해지게 된다. 반면에, [기본 RNN 셀](http://excelsior-cjh.tistory.com/183)에서는 이 레이어만 있으며, 바로 $\\mathbf{y}_{t}​$와 $\\mathbf{h}_{t}​$로 출력된다. \n",
    "\n",
    "- $\\mathbf{f}_{t}, \\mathbf{i}_{t}, \\mathbf{o}_{t}$를 출력하는 세 개의 레이어에서는 활성화 함수로 시그모이드(sigmoid, logistic)를 사용한다. 시그모이드 함수의 출력의 범위는 0 ~ 1 이며, 이 출력값은 각 forget, input, output 게이트의 원소별(element-wise) 곱셈연산에 입력된다. 따라서, 출력이 `0`일 경우에는 게이트를 닫고 `1`일 경우에는 게이트를 열기 때문에  $\\mathbf{f}_{t}, \\mathbf{i}_{t}, \\mathbf{o}_{t}$를 **gate controller**라고 한다.\n",
    "  - **Forget gate** : $\\mathbf{f}_{t}$에 의해 제어되며 장기 상태 $\\mathbf{c}_{t}$의 어느 부분을 삭제할지 제어한다.\n",
    "  - **Input gate** : $\\mathbf{i}_{t}$에 의해 제어되며 $\\mathbf{g}_{t}$의 어느 부분이 장기 상태 $\\mathbf{c}_{t}$에 더해져야 하는지 제어한다.\n",
    "  - **Output gate** : $\\mathbf{o}_{t}$는 장기 상태 $\\mathbf{c}_{t}$의 어느 부분을 읽어서 $\\mathbf{h}_{t}$ 와 $\\mathbf{y}_{t}$로 출력해야 하는지 제어한다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "다음의 식은 위의 그림에서 타임 스텝 $t$에서, 셀의 장기 상태, 단기 상태, 그리고 각 레이어의 출력을 구하는 식을 나타낸 것이다.\n",
    "\n",
    "\n",
    "$$\n",
    "\\begin{eqnarray} \n",
    "\\mathbf{f}_{t} & = & \\sigma \\left( \\mathbf{W}_{xf}^{T} \\cdot \\mathbf{x}_{t} + \\mathbf{W}_{hf}^{T} \\cdot \\mathbf{h}_{t-1} + \\mathbf{b}_{f} \\right) \\\\ \\mathbf{i}_{t} & =  & \\sigma \\left( \\mathbf{W}_{xi}^{T} \\cdot \\mathbf{x}_{t} + \\mathbf{W}_{hi}^{T} \\cdot \\mathbf{h}_{t-1} + \\mathbf{b}_{i} \\right) \\\\ \\mathbf{o}_{t} & = & \\sigma \\left( \\mathbf{W}_{xo}^{T} \\cdot \\mathbf{x}_{t} + \\mathbf{W}_{ho}^{T} \\cdot \\mathbf{h}_{t-1} + \\mathbf{b}_{o} \\right) \\\\ \\mathbf{g}_{t} & = & \\tanh \\left( \\mathbf{W}_{xg}^{T} \\cdot \\mathbf{x}_{t} + \\mathbf{W}_{hg}^{T} \\cdot \\mathbf{h}_{t-1} + \\mathbf{b}_{g} \\right) \\\\ \\mathbf{c}_{t} & = & \\mathbf{f}_{t} \\otimes \\mathbf{c}_{t-1} + \\mathbf{i}_{t} \\otimes \\mathbf{g}_{t} \\\\ \\mathbf{y}_{t}, \\mathbf{h}_{t} & = & \\mathbf{o}_{t} \\otimes \\tanh \\left( \\mathbf{c}_{t} \\right) \n",
    "\\end{eqnarray}\n",
    "$$\n",
    "\n",
    "\n",
    "- $\\mathbf{W}_{xf}, \\mathbf{W}_{xi}, \\mathbf{W}_{xo}, \\mathbf{W}_{xg}$ : 입력 벡터 $\\mathbf{x}_{t}$에 연결된 네 개의 레이어에 대한 가중치 행렬\n",
    "- $\\mathbf{W}_{hf}, \\mathbf{W}_{hi}, \\mathbf{W}_{ho}, \\mathbf{W}_{hg}$ : 이전 타임스텝의 단기 상태 $\\mathbf{h}_{t-1}$에 연결된 네 개의 레이어에 대한 가중치 행렬\n",
    "- $\\mathbf{b}_{f}, \\mathbf{b}_{i}, \\mathbf{b}_{o}, \\mathbf{b}_{g}$ : 네 개의 레이어에 대한 편향(bias), [텐서플로](https://www.tensorflow.org/api_docs/python/tf/nn/rnn_cell/LSTMCell)(TensorFlow)에서는 $\\mathbf{b}_{f}$ 를 `1`로 초기화하여 학습 시작시에 모든것을 잃어버리는 것을 방지한다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.1 텐서플로에서의 LSTM 셀\n",
    "\n",
    "텐서플로(TensorFlow)에서는 [`tf.nn.rnn_cell.BasicLSTMCell`](https://www.tensorflow.org/api_docs/python/tf/nn/rnn_cell/BasicLSTMCell)을 이용해 LSTM 셀을 구현할 수 있으며, `BasicLSTMCell` 사용법은 '[07-1. 순환 신경망(RNN)](http://excelsior-cjh.tistory.com/183)'에서의 예제에서 아래의 코드와 같이 `BasicRNNCell` → `BasicLSTMCell`로 바꿔주면 된다.\n",
    "\n",
    "```python\n",
    "lstm_cell = tf.nn.rnn_cell.BasicLSTMCell(num_units=n_neurons)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Set Up"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "\n",
    "# 일관된 출력을 위해 유사난수 초기화\n",
    "def reset_graph(seed=42):\n",
    "    tf.reset_default_graph()\n",
    "    tf.set_random_seed(seed)\n",
    "    np.random.seed(seed)\n",
    "\n",
    "%matplotlib inline\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "plt.rcParams['axes.labelsize'] = 14\n",
    "plt.rcParams['xtick.labelsize'] = 12\n",
    "plt.rcParams['ytick.labelsize'] = 12\n",
    "\n",
    "# 한글출력\n",
    "# matplotlib.rc('font', family='AppleGothic')  # MacOS\n",
    "matplotlib.rc('font', family='Malgun Gothic')  # Windows\n",
    "plt.rcParams['axes.unicode_minus'] = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train_x.shape : (55000, 784)\n",
      "valid_x.shape : (5000, 28, 28)\n",
      "test_x.shape : (10000, 28, 28)\n"
     ]
    }
   ],
   "source": [
    "################\n",
    "# Layer Params #\n",
    "################\n",
    "n_steps = 28\n",
    "n_inputs = 28\n",
    "n_neurons = 150\n",
    "n_outputs = 10\n",
    "n_layers = 3\n",
    "\n",
    "# MNIST Data Load\n",
    "(train_x, train_y), (test_x, test_y) = tf.keras.datasets.mnist.load_data()\n",
    "train_x = train_x.astype(np.float32).reshape(-1, 28*28) / 255.0  # (784,)\n",
    "test_x = test_x.astype(np.float32).reshape(-1, 28*28) / 255.0\n",
    "train_y = train_y.astype(np.int32)\n",
    "test_y = test_y.astype(np.int32)\n",
    "valid_x, train_x = train_x[:5000], train_x[5000:]\n",
    "valid_y, train_y = train_y[:5000], train_y[5000:]\n",
    "test_x = test_x.reshape([-1, n_steps, n_inputs])\n",
    "valid_x = valid_x.reshape([-1, n_steps, n_inputs])\n",
    "\n",
    "print('train_x.shape :', train_x.shape)\n",
    "print('valid_x.shape :', valid_x.shape)\n",
    "print('test_x.shape :', test_x.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Mini-batch\n",
    "def shuffle_batch(features, labels, batch_size):\n",
    "    rnd_idx = np.random.permutation(len(features))\n",
    "    n_batches = len(features) // batch_size\n",
    "    for batch_idx in np.array_split(rnd_idx, n_batches):\n",
    "        batch_x, batch_y = features[batch_idx], labels[batch_idx]\n",
    "        yield batch_x, batch_y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "reset_graph()\n",
    "\n",
    "inputs = tf.placeholder(tf.float32, [None, n_steps, n_inputs])\n",
    "labels = tf.placeholder(tf.int32, [None])\n",
    "\n",
    "# LSTM Model\n",
    "lstm_cells = [tf.nn.rnn_cell.LSTMCell(num_units=n_neurons)\n",
    "              for layer in range(n_layers)]\n",
    "multi_cell = tf.nn.rnn_cell.MultiRNNCell(lstm_cells)\n",
    "outputs, states = tf.nn.dynamic_rnn(multi_cell, inputs, dtype=tf.float32)\n",
    "top_layer_h_state = states[-1][1]\n",
    "# dense layer\n",
    "logits = tf.layers.dense(top_layer_h_state, n_outputs)  # states = outputs[-1]\n",
    "\n",
    "# loss\n",
    "xentropy = tf.reduce_mean(\n",
    "    tf.nn.sparse_softmax_cross_entropy_with_logits(labels=labels, logits=logits))\n",
    "\n",
    "################\n",
    "# Train Params #\n",
    "################\n",
    "learning_rate = 0.001\n",
    "n_epochs = 5\n",
    "batch_size = 150\n",
    "\n",
    "# optimizer\n",
    "train_op = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(xentropy)\n",
    "\n",
    "# metric\n",
    "correct = tf.nn.in_top_k(logits, labels, 1)\n",
    "accuracy = tf.reduce_mean(tf.cast(correct, tf.float32))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Train\n",
    "with tf.Session() as sess:\n",
    "    tf.global_variables_initializer().run()\n",
    "    for epoch in range(n_epochs):\n",
    "        for batch_x, batch_y in shuffle_batch(train_x, train_y, batch_size):\n",
    "            batch_x = batch_x.reshape([-1, n_steps, n_inputs])\n",
    "            sess.run(train_op, \n",
    "                     feed_dict={inputs: batch_x, labels: batch_y})\n",
    "        acc_batch = accuracy.eval(feed_dict={inputs: batch_x, labels: batch_y})\n",
    "        acc_valid = accuracy.eval(feed_dict={inputs: valid_x, labels: valid_y})\n",
    "        loss_batch = xentropy.eval(feed_dict={inputs: batch_x, labels: batch_y})\n",
    "        print('epoch : {:03d}'.format(epoch),\n",
    "              'acc_batch : {:.4f}, acc_valid : {:.4f}'.format(acc_batch, acc_valid),\n",
    "              'loss_batch : {:.4f}'.format(loss_batch))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2 핍홀(peephole) 연결\n",
    "\n",
    "핍홀 연결(peephole connection)은 2000년에 F. Gers와 J.Schmidhuber가 ['Recurrent Nets that and Count'](ftp://ftp.idsia.ch/pub/juergen/TimeCount-IJCNN2000.pdf) 논문에서 제안한 LSTM의 변종이다. 기존의 LSTM에서 gate controller($\\mathbf{f}_{t}, \\mathbf{i}_{t}, \\mathbf{o}_{t}$)는 입력 $\\mathbf{x}_{t}$와 이전 타임스텝의 단기 상태 $\\mathbf{h}_{t-1}$만 입력으로 받는다. 하지만 위의 논문에서 제안한 핍홀 연결을 아래의 그림과 같이 연결 해주면서 gate controller에 이전 타임스텝의 장기 상태 $\\mathbf{c}_{t-1}$가 입력으로 추가되며, 좀 더 많은 맥락(context)를 인식할 수 있다.\n",
    "\n",
    "\n",
    "$$\n",
    "\\begin{eqnarray} \n",
    "\\mathbf{f}_{t} & = & \\sigma \\left( \\mathbf{W}_{cf}^{T} \\cdot \\mathbf{c}_{t-1} + \\mathbf{W}_{xf}^{T} \\cdot \\mathbf{x}_{t} + \\mathbf{W}_{hf}^{T} \\cdot \\mathbf{h}_{t-1} + \\mathbf{b}_{f} \\right) \\\\ \\mathbf{i}_{t} & =  & \\sigma \\left( \\mathbf{W}_{ci}^{T} \\cdot \\mathbf{c}_{t-1} + \\mathbf{W}_{xi}^{T} \\cdot \\mathbf{x}_{t} + \\mathbf{W}_{hi}^{T} \\cdot \\mathbf{h}_{t-1} + \\mathbf{b}_{i} \\right) \\\\ \\mathbf{o}_{t} & = & \\sigma \\left( \\mathbf{W}_{co}^{T} \\cdot \\mathbf{c}_{t-1} + \\mathbf{W}_{xo}^{T} \\cdot \\mathbf{x}_{t} + \\mathbf{W}_{ho}^{T} \\cdot \\mathbf{h}_{t-1} + \\mathbf{b}_{o} \\right)\n",
    "\\end{eqnarray}\n",
    "$$\n",
    "![peephole connection](./images/lstm02.PNG)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "텐서플로에서 핍홀 연결을 구현하기 위해서는 `BasicLSTMCell` 대신 [`LSTMCell`](https://www.tensorflow.org/api_docs/python/tf/nn/rnn_cell/LSTMCell)을 사용하고 `use_peepholes`인자를 `True`로 설정하면 된다.\n",
    "\n",
    "```python\n",
    "# Use peephole\n",
    "lstm_cell = tf.nn.rnn_cell.LSTMCell(num_units=n_neurons, use_peepholes=True)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. GRU Cell\n",
    "\n",
    "**GRU(Gated Recurrent Unit)** 셀은 2014년에 K. Cho(조경현) 등에 의해 ['이 논문'](https://arxiv.org/pdf/1406.1078v3.pdf)에서 제안된 LSTM 셀의 **간소화된 버전**이라고 할 수 있으며, 다음의 그림과 같은 구조를 가진다.\n",
    "\n",
    "\n",
    "\n",
    "![GRU](./images/gru.PNG)\n",
    "\n",
    "\n",
    "\n",
    "- LSTM Cell에서의 두 상태 벡터 $\\mathbf{c}_{t}$와 $\\mathbf{h}_{t}$가 하나의 벡터 $\\mathbf{h}_{t}$로 합쳐졌다.\n",
    "- 하나의 gate controller인 $\\mathbf{z}_{t}$가 **forget**과 **input** 게이트(gate)를 모두 제어한다.  $\\mathbf{z}_{t}$가 `1`을 출력하면 forget 게이트가 열리고 input 게이트가 닫히며, $\\mathbf{z}_{t}$가 `0`일 경우 반대로 forget 게이트가 닫히고 input 게이트가 열린다. 즉, 이전($t-1$)의 기억이 저장 될때 마다 타임 스텝 $t$의 입력은 삭제된다. \n",
    "- GRU 셀은 output 게이트가 없어 전체 상태 벡터 $\\mathbf{h}_{t}$가 타임 스텝마다 출력되며, 이전 상태 $\\mathbf{h}_{t-1}$의 어느 부분이 출력될지 제어하는 새로운 gate controller인 $\\mathbf{r}_{t}$가 있다.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "GRU 셀의 상태(state)와 각 레이어의 출력을 계산하는 식은 다음과 같다.\n",
    "\n",
    "\n",
    "$$\n",
    "\\begin{eqnarray} \n",
    "\\mathbf{r}_{t} & = & \\sigma \\left( \\mathbf{W}_{xr}^{T} \\cdot \\mathbf{x}_{t} + \\mathbf{W}_{hr}^{T} \\cdot \\mathbf{h}_{t-1} + \\mathbf{b}_{r} \\right) \\\\ \\mathbf{z}_{t} & =  & \\sigma \\left( \\mathbf{W}_{xz}^{T} \\cdot \\mathbf{x}_{t} + \\mathbf{W}_{hz}^{T} \\cdot \\mathbf{h}_{t-1} + \\mathbf{b}_{z} \\right) \\\\ \\mathbf{g}_{t} & = & \\tanh \\left( \\mathbf{W}_{xg}^{T} \\cdot \\mathbf{x}_{t} + \\mathbf{W}_{hg}^{T} \\cdot \\left( \\mathbf{r}_{t} \\otimes \\mathbf{h}_{t-1} \\right) + \\mathbf{b}_{g} \\right) \\\\ \\mathbf{h}_{t} & = & \\mathbf{z}_{t} \\otimes \\mathbf{h}_{t-1} + \\left( 1 - \\mathbf{z}_{t} \\right) \\otimes \\mathbf{g}_{t}\n",
    "\\end{eqnarray}\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "텐서플로에서 GRU 셀은 [`tf.nn.rnn_cell.GRUCell`](https://www.tensorflow.org/api_docs/python/tf/nn/rnn_cell/GRUCell)을 이용해 다음과 같이 구현할 수 있다.\n",
    "\n",
    "```python\n",
    "# GRU Cell\n",
    "gru_cell = tf.nn.rnn_cell.GRUCell(num_units=n_neurons)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## 4. 마무리\n",
    "\n",
    "이번 포스팅에서는 RNN의 문제인 BPTT와 Long-Term Dependency 문제에 대해 알아 보았고, 그리고 RNN의 변형인 LSTM, LSTM의 변형인 GRU에 대해 알아보았다. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "tensorflow",
   "language": "python",
   "name": "tensorflow"
  },
  "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.6.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}