04-2.RNN-Seq2Seq.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br></br>\n",
    "# **자연어와 Deep Learning**\n",
    "## **LSTM 단어 알파벳 완성모델**\n",
    "\n",
    "<br></br>\n",
    "## **1 Data : 학습대상**\n",
    "1. **X (Input Data)** : Sequence Data (전체 4개 알파벳의 연속성을 학습)\n",
    "1. **Y (Output Data)** : Sequence Data (전체 2개 한글의 연속성을 학습)\n",
    "1. **Sequence Data 를 Output** 으로 연결하기 위해 서로 다른 **RNN/ LSTM Cell을 덧붙인다**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 분석할 데이터 (원하는 다른 내용으로 변경가능) \n",
    "seq_data = [['word', '단어'], ['wood', '나무'], ['game', '놀이'], \n",
    "            ['girl', '소녀'], ['kiss', '키스'], ['love', '사랑']]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br></br>\n",
    "## **2 데이터 임배딩 객체/ 함수(Batch 함수) 정의**\n",
    "one-hot-encoding 활용"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Train 에 사용할 Input / Output 데이터를 숫자로 변환하기 위한 Index 를 특정한다 \n",
    "char_arr = [ c for c in 'SPabcdefghijklmnopqrstuvwxyz나놀녀단랑무사소스어이키E'] \n",
    "num_dic  = { n : i for i, n in enumerate(char_arr)}\n",
    "dic_len  = len(num_dic)\n",
    "\n",
    "print(\"One-Hot-Encoding 객체의 수 : {}개\\nOne-Hot-Encoding 내용 :\\n{}\".format(\n",
    "    dic_len, num_dic))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Tensorflow 에 입력을 위한 Batch 함수를 정의한다\n",
    "def make_batch(seq_data):\n",
    "    input_batch, output_batch, target_batch = [], [], []\n",
    "    for seq in seq_data:\n",
    "        input_data = [num_dic[n] for n in seq[0]]\n",
    "        output = [num_dic[n] for n in ('S' + seq[1])] \n",
    "        target = [num_dic[n] for n in (seq[1] + 'E')]\n",
    "        input_batch.append(np.eye(dic_len)[input_data])\n",
    "        output_batch.append(np.eye(dic_len)[output])\n",
    "        target_batch.append(target)\n",
    "    return input_batch, output_batch, target_batch"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br></br>\n",
    "## **3 모델의 정의**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 학습에 필요한 모듈을 불러온다\n",
    "import tensorflow as tf\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 학습에 필요한 Parameter\n",
    "tf.reset_default_graph()\n",
    "learning_rate = 0.01\n",
    "n_hidden, total_epoch = 128, 100\n",
    "n_class = n_input = dic_len\n",
    "\n",
    "# Encoder / Decoder / Target 을 각각 정의한다\n",
    "enc_input = tf.placeholder(tf.float32, [None, None, n_input])\n",
    "dec_input = tf.placeholder(tf.float32, [None, None, n_input])\n",
    "targets   = tf.placeholder(tf.int64, [None, None])  # [batch size, time steps]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# RNN Encoder Cell을 정의한다\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",
    "    outputs, enc_states = tf.nn.dynamic_rnn(enc_cell, enc_input,dtype=tf.float32)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# RNN Decoder Cell을 정의한다\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",
    "    outputs, dec_states = tf.nn.dynamic_rnn(dec_cell, dec_input, \n",
    "                                            initial_state = enc_states, \n",
    "                                            dtype = tf.float32)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Cell 을 활용한 Model (Graph) 를 정의한다\n",
    "# Cost 함수, Optimizer 함수를 정의한다\n",
    "model = tf.layers.dense(outputs, n_class, activation=None)\n",
    "cost  = tf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits(\n",
    "    logits = model, labels = targets))\n",
    "optimizer = tf.train.AdamOptimizer(learning_rate).minimize(cost)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br></br>\n",
    "## **4 모델의 학습**\n",
    "위에서 정의한 Model 에, **make_batch** 로 단어를 숫자로 변환 후 학습한다"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "sess = tf.Session()\n",
    "sess.run(tf.global_variables_initializer())\n",
    "input_batch, output_batch, target_batch = make_batch(seq_data)\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",
    "    if epoch % 9 == 0 :\n",
    "        print('Epoch: {:4d}  cost = {:.6f}'.format((epoch + 1),loss))\n",
    "print('최적화 완료!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br></br>\n",
    "## **5 모델의 검증**\n",
    "seq_data 를 활용하여 모델을 검증한다"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "%%time\n",
    "def translate(word):\n",
    "    seq_data   = [word, 'P' * len(word)]\n",
    "    input_batch, output_batch, target_batch = make_batch([seq_data])\n",
    "    prediction = tf.argmax(model, 2)   # [None, None, n_input]\n",
    "    result     = sess.run(prediction,\n",
    "                      feed_dict={enc_input: input_batch,\n",
    "                                 dec_input: output_batch,\n",
    "                                 targets: target_batch})\n",
    "    decoded    = [char_arr[i] for i in result[0]]\n",
    "    end        = decoded.index('E')\n",
    "    translated = ''.join(decoded[:end])\n",
    "    return translated"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "print('\\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",
    "sess.close()"
   ]
  }
 ],
 "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.6.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}