code/class_7/3 - Seq2Seq.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 챗봇, 번역, 이미지 캡셔닝등에 사용되는 시퀀스 학습/생성 모델인 Seq2Seq 을 구현해봅니다.\n",
    "# 영어 단어를 한국어 단어로 번역하는 프로그램을 만들어봅니다.\n",
    "import tensorflow as tf\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# S: 디코딩 입력의 시작을 나타내는 심볼\n",
    "# E: 디코딩 출력을 끝을 나타내는 심볼\n",
    "# P: 현재 배치 데이터의 time step 크기보다 작은 경우 빈 시퀀스를 채우는 심볼\n",
    "#    예) 현재 배치 데이터의 최대 크기가 4 인 경우\n",
    "#       word -> ['w', 'o', 'r', 'd']\n",
    "#       to   -> ['t', 'o', 'P', 'P']\n",
    "char_arr = [c for c in 'SEPabcdefghijklmnopqrstuvwxyz단어나무놀이소녀키스사랑']\n",
    "num_dic = {n: i for i, n in enumerate(char_arr)}\n",
    "dic_len = len(num_dic)\n",
    "\n",
    "# 영어를 한글로 번역하기 위한 학습 데이터\n",
    "seq_data = [['word', '단어'], ['wood', '나무'],\n",
    "            ['game', '놀이'], ['girl', '소녀'],\n",
    "            ['kiss', '키스'], ['love', '사랑']]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_batch(seq_data):\n",
    "    input_batch = []\n",
    "    output_batch = []\n",
    "    target_batch = []\n",
    "\n",
    "    for seq in seq_data:\n",
    "        # 인코더 셀의 입력값. 입력단어의 글자들을 한글자씩 떼어 배열로 만든다.\n",
    "        input = [num_dic[n] for n in seq[0]]\n",
    "        # 디코더 셀의 입력값. 시작을 나타내는 S 심볼을 맨 앞에 붙여준다.\n",
    "        output = [num_dic[n] for n in ('S' + seq[1])]\n",
    "        # 학습을 위해 비교할 디코더 셀의 출력값. 끝나는 것을 알려주기 위해 마지막에 E 를 붙인다.\n",
    "        target = [num_dic[n] for n in (seq[1] + 'E')]\n",
    "\n",
    "        input_batch.append(np.eye(dic_len)[input])\n",
    "        output_batch.append(np.eye(dic_len)[output])\n",
    "        # 출력값만 one-hot 인코딩이 아님 (sparse_softmax_cross_entropy_with_logits 사용)\n",
    "        target_batch.append(target)\n",
    "\n",
    "    return input_batch, output_batch, target_batch\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "#########\n",
    "# 옵션 설정\n",
    "######\n",
    "learning_rate = 0.01\n",
    "n_hidden = 128\n",
    "total_epoch = 100\n",
    "# 입력과 출력의 형태가 one-hot 인코딩으로 같으므로 크기도 같다.\n",
    "n_class = n_input = dic_len\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "#########\n",
    "# 신경망 모델 구성\n",
    "######\n",
    "# Seq2Seq 모델은 인코더의 입력과 디코더의 입력의 형식이 같다.\n",
    "# [batch size, time steps, input size]\n",
    "enc_input = tf.placeholder(tf.float32, [None, None, n_input])\n",
    "dec_input = tf.placeholder(tf.float32, [None, None, n_input])\n",
    "# [batch size, time steps]\n",
    "targets = tf.placeholder(tf.int64, [None, None])\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 인코더 셀을 구성한다.\n",
    "with tf.variable_scope('encode'):\n",
    "    enc_cell = tf.nn.rnn_cell.BasicRNNCell(n_hidden)\n",
    "    enc_cell = tf.nn.rnn_cell.DropoutWrapper(enc_cell, output_keep_prob=0.5)\n",
    "\n",
    "    outputs, enc_states = tf.nn.dynamic_rnn(enc_cell, enc_input,\n",
    "                                            dtype=tf.float32)\n",
    "\n",
    "# 디코더 셀을 구성한다.\n",
    "with tf.variable_scope('decode'):\n",
    "    dec_cell = tf.nn.rnn_cell.BasicRNNCell(n_hidden)\n",
    "    dec_cell = tf.nn.rnn_cell.DropoutWrapper(dec_cell, output_keep_prob=0.5)\n",
    "\n",
    "    # Seq2Seq 모델은 인코더 셀의 최종 상태값을\n",
    "    # 디코더 셀의 초기 상태값으로 넣어주는 것이 핵심.\n",
    "    outputs, dec_states = tf.nn.dynamic_rnn(dec_cell, dec_input,\n",
    "                                            initial_state=enc_states,\n",
    "                                            dtype=tf.float32)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = tf.layers.dense(outputs, n_class, activation=None)\n",
    "\n",
    "\n",
    "cost = tf.reduce_mean(\n",
    "            tf.nn.sparse_softmax_cross_entropy_with_logits(\n",
    "                logits=model, labels=targets))\n",
    "\n",
    "optimizer = tf.train.AdamOptimizer(learning_rate).minimize(cost)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 0001 cost = 3.744303\n",
      "Epoch: 0002 cost = 2.456863\n",
      "Epoch: 0003 cost = 1.500961\n",
      "Epoch: 0004 cost = 0.883574\n",
      "Epoch: 0005 cost = 0.712510\n",
      "Epoch: 0006 cost = 0.380442\n",
      "Epoch: 0007 cost = 0.357352\n",
      "Epoch: 0008 cost = 0.146936\n",
      "Epoch: 0009 cost = 0.138639\n",
      "Epoch: 0010 cost = 0.115450\n",
      "Epoch: 0011 cost = 0.061370\n",
      "Epoch: 0012 cost = 0.139445\n",
      "Epoch: 0013 cost = 0.137623\n",
      "Epoch: 0014 cost = 0.046505\n",
      "Epoch: 0015 cost = 0.127899\n",
      "Epoch: 0016 cost = 0.084804\n",
      "Epoch: 0017 cost = 0.061295\n",
      "Epoch: 0018 cost = 0.004998\n",
      "Epoch: 0019 cost = 0.046782\n",
      "Epoch: 0020 cost = 0.081580\n",
      "Epoch: 0021 cost = 0.029462\n",
      "Epoch: 0022 cost = 0.062209\n",
      "Epoch: 0023 cost = 0.027252\n",
      "Epoch: 0024 cost = 0.004449\n",
      "Epoch: 0025 cost = 0.044040\n",
      "Epoch: 0026 cost = 0.008638\n",
      "Epoch: 0027 cost = 0.003178\n",
      "Epoch: 0028 cost = 0.008678\n",
      "Epoch: 0029 cost = 0.013379\n",
      "Epoch: 0030 cost = 0.014027\n",
      "Epoch: 0031 cost = 0.001706\n",
      "Epoch: 0032 cost = 0.004238\n",
      "Epoch: 0033 cost = 0.003071\n",
      "Epoch: 0034 cost = 0.012580\n",
      "Epoch: 0035 cost = 0.000570\n",
      "Epoch: 0036 cost = 0.000639\n",
      "Epoch: 0037 cost = 0.001980\n",
      "Epoch: 0038 cost = 0.001351\n",
      "Epoch: 0039 cost = 0.001351\n",
      "Epoch: 0040 cost = 0.001167\n",
      "Epoch: 0041 cost = 0.002144\n",
      "Epoch: 0042 cost = 0.001571\n",
      "Epoch: 0043 cost = 0.000589\n",
      "Epoch: 0044 cost = 0.001402\n",
      "Epoch: 0045 cost = 0.001685\n",
      "Epoch: 0046 cost = 0.001071\n",
      "Epoch: 0047 cost = 0.002768\n",
      "Epoch: 0048 cost = 0.000547\n",
      "Epoch: 0049 cost = 0.000649\n",
      "Epoch: 0050 cost = 0.001763\n",
      "Epoch: 0051 cost = 0.000608\n",
      "Epoch: 0052 cost = 0.000881\n",
      "Epoch: 0053 cost = 0.002255\n",
      "Epoch: 0054 cost = 0.001955\n",
      "Epoch: 0055 cost = 0.001847\n",
      "Epoch: 0056 cost = 0.000608\n",
      "Epoch: 0057 cost = 0.000333\n",
      "Epoch: 0058 cost = 0.000764\n",
      "Epoch: 0059 cost = 0.002662\n",
      "Epoch: 0060 cost = 0.001120\n",
      "Epoch: 0061 cost = 0.001024\n",
      "Epoch: 0062 cost = 0.000330\n",
      "Epoch: 0063 cost = 0.000988\n",
      "Epoch: 0064 cost = 0.000153\n",
      "Epoch: 0065 cost = 0.000441\n",
      "Epoch: 0066 cost = 0.000306\n",
      "Epoch: 0067 cost = 0.000612\n",
      "Epoch: 0068 cost = 0.000605\n",
      "Epoch: 0069 cost = 0.000216\n",
      "Epoch: 0070 cost = 0.000608\n",
      "Epoch: 0071 cost = 0.000566\n",
      "Epoch: 0072 cost = 0.000555\n",
      "Epoch: 0073 cost = 0.001295\n",
      "Epoch: 0074 cost = 0.001016\n",
      "Epoch: 0075 cost = 0.000635\n",
      "Epoch: 0076 cost = 0.000266\n",
      "Epoch: 0077 cost = 0.001427\n",
      "Epoch: 0078 cost = 0.000137\n",
      "Epoch: 0079 cost = 0.000135\n",
      "Epoch: 0080 cost = 0.000773\n",
      "Epoch: 0081 cost = 0.000354\n",
      "Epoch: 0082 cost = 0.000991\n",
      "Epoch: 0083 cost = 0.000362\n",
      "Epoch: 0084 cost = 0.000245\n",
      "Epoch: 0085 cost = 0.000456\n",
      "Epoch: 0086 cost = 0.001225\n",
      "Epoch: 0087 cost = 0.000423\n",
      "Epoch: 0088 cost = 0.001700\n",
      "Epoch: 0089 cost = 0.000396\n",
      "Epoch: 0090 cost = 0.000346\n",
      "Epoch: 0091 cost = 0.000340\n",
      "Epoch: 0092 cost = 0.001059\n",
      "Epoch: 0093 cost = 0.000504\n",
      "Epoch: 0094 cost = 0.000444\n",
      "Epoch: 0095 cost = 0.000531\n",
      "Epoch: 0096 cost = 0.000046\n",
      "Epoch: 0097 cost = 0.000175\n",
      "Epoch: 0098 cost = 0.000280\n",
      "Epoch: 0099 cost = 0.000113\n",
      "Epoch: 0100 cost = 0.000794\n",
      "최적화 완료!\n"
     ]
    }
   ],
   "source": [
    "#########\n",
    "# 신경망 모델 학습\n",
    "######\n",
    "sess = tf.Session()\n",
    "sess.run(tf.global_variables_initializer())\n",
    "\n",
    "input_batch, output_batch, target_batch = make_batch(seq_data)\n",
    "\n",
    "for epoch in range(total_epoch):\n",
    "    _, loss = sess.run([optimizer, cost],\n",
    "                       feed_dict={enc_input: input_batch,\n",
    "                                  dec_input: output_batch,\n",
    "                                  targets: target_batch})\n",
    "\n",
    "    print('Epoch:', '%04d' % (epoch + 1),\n",
    "          'cost =', '{:.6f}'.format(loss))\n",
    "\n",
    "print('최적화 완료!')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "=== 번역 테스트 ===\n",
      "word -> 단어\n",
      "wodr -> 나무\n",
      "love -> 사랑\n",
      "loev -> 사랑\n",
      "abcd -> 키스\n"
     ]
    }
   ],
   "source": [
    "#########\n",
    "# 번역 테스트\n",
    "######\n",
    "# 단어를 입력받아 번역 단어를 예측하고 디코딩하는 함수\n",
    "def translate(word):\n",
    "    # 이 모델은 입력값과 출력값 데이터로 [영어단어, 한글단어] 사용하지만,\n",
    "    # 예측시에는 한글단어를 알지 못하므로, 디코더의 입출력값을 의미 없는 값인 P 값으로 채운다.\n",
    "    # ['word', 'PPPP']\n",
    "    seq_data = [word, 'P' * len(word)]\n",
    "\n",
    "    input_batch, output_batch, target_batch = make_batch([seq_data])\n",
    "\n",
    "    # 결과가 [batch size, time step, input] 으로 나오기 때문에,\n",
    "    # 2번째 차원인 input 차원을 argmax 로 취해 가장 확률이 높은 글자를 예측 값으로 만든다.\n",
    "    prediction = tf.argmax(model, 2)\n",
    "\n",
    "    result = sess.run(prediction,\n",
    "                      feed_dict={enc_input: input_batch,\n",
    "                                 dec_input: output_batch,\n",
    "                                 targets: target_batch})\n",
    "\n",
    "    # 결과 값인 숫자의 인덱스에 해당하는 글자를 가져와 글자 배열을 만든다.\n",
    "    decoded = [char_arr[i] for i in result[0]]\n",
    "\n",
    "    # 출력의 끝을 의미하는 'E' 이후의 글자들을 제거하고 문자열로 만든다.\n",
    "    end = decoded.index('E')\n",
    "    translated = ''.join(decoded[:end])\n",
    "\n",
    "    return translated\n",
    "\n",
    "\n",
    "print('\\n=== 번역 테스트 ===')\n",
    "\n",
    "print('word ->', translate('word'))\n",
    "print('wodr ->', translate('wodr'))\n",
    "print('love ->', translate('love'))\n",
    "print('loev ->', translate('loev'))\n",
    "print('abcd ->', translate('abcd'))\n"
   ]
  },
  {
   "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}