Transformer_Korean_Chatbot.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "name": "Transformer Korean Chatbot.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "machine_shape": "hm"
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    }
  },
  "cells": [
    {
      "cell_type": "code",
      "metadata": {
        "id": "PgzTgkaL9OnI"
      },
      "source": [
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "import tensorflow as tf"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "fvo8VpnvRcDM",
        "outputId": "e60e93cf-7dd0-4b6f-fc7c-a202c3470939"
      },
      "source": [
        "tf.__version__"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'2.6.0'"
            ]
          },
          "metadata": {},
          "execution_count": 2
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JY6lwO-oWZJd"
      },
      "source": [
        "# 최종 버전\n",
        "class PositionalEncoding(tf.keras.layers.Layer):\n",
        "  def __init__(self, position, d_model):\n",
        "    super(PositionalEncoding, self).__init__()\n",
        "    self.pos_encoding = self.positional_encoding(position, d_model)\n",
        "\n",
        "  def get_angles(self, position, i, d_model):\n",
        "    angles = 1 / tf.pow(10000, (2 * (i // 2)) / tf.cast(d_model, tf.float32))\n",
        "    return position * angles\n",
        "\n",
        "  def positional_encoding(self, position, d_model):\n",
        "    angle_rads = self.get_angles(\n",
        "        position=tf.range(position, dtype=tf.float32)[:, tf.newaxis],\n",
        "        i=tf.range(d_model, dtype=tf.float32)[tf.newaxis, :],\n",
        "        d_model=d_model)\n",
        "\n",
        "    # 배열의 짝수 인덱스(2i)에는 사인 함수 적용\n",
        "    sines = tf.math.sin(angle_rads[:, 0::2])\n",
        "\n",
        "    # 배열의 홀수 인덱스(2i+1)에는 코사인 함수 적용\n",
        "    cosines = tf.math.cos(angle_rads[:, 1::2])\n",
        "\n",
        "    angle_rads = np.zeros(angle_rads.shape)\n",
        "    angle_rads[:, 0::2] = sines\n",
        "    angle_rads[:, 1::2] = cosines\n",
        "    pos_encoding = tf.constant(angle_rads)\n",
        "    pos_encoding = pos_encoding[tf.newaxis, ...]\n",
        "\n",
        "    print(pos_encoding.shape)\n",
        "    return tf.cast(pos_encoding, tf.float32)\n",
        "\n",
        "  def call(self, inputs):\n",
        "    return inputs + self.pos_encoding[:, :tf.shape(inputs)[1], :]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 301
        },
        "id": "QiNrtgQUV36E",
        "outputId": "3467cf4d-9ecd-4840-e789-fe5dfaa951a8"
      },
      "source": [
        "sample_pos_encoding = PositionalEncoding(50, 128)\n",
        "\n",
        "plt.pcolormesh(sample_pos_encoding.pos_encoding.numpy()[0], cmap='RdBu')\n",
        "plt.xlabel('Depth')\n",
        "plt.xlim((0, 128))\n",
        "plt.ylabel('Position')\n",
        "plt.colorbar()\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(1, 50, 128)\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 2 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "F6534luH9d0K"
      },
      "source": [
        "def scaled_dot_product_attention(query, key, value, mask):\n",
        "  # query 크기 : (batch_size, num_heads, query의 문장 길이, d_model/num_heads)\n",
        "  # key 크기 : (batch_size, num_heads, key의 문장 길이, d_model/num_heads)\n",
        "  # value 크기 : (batch_size, num_heads, value의 문장 길이, d_model/num_heads)\n",
        "  # padding_mask : (batch_size, 1, 1, key의 문장 길이)\n",
        "\n",
        "  # Q와 K의 곱. 어텐션 스코어 행렬.\n",
        "  matmul_qk = tf.matmul(query, key, transpose_b=True)\n",
        "\n",
        "  # 스케일링\n",
        "  # dk의 루트값으로 나눠준다.\n",
        "  depth = tf.cast(tf.shape(key)[-1], tf.float32)\n",
        "  logits = matmul_qk / tf.math.sqrt(depth)\n",
        "\n",
        "  # 마스킹. 어텐션 스코어 행렬의 마스킹 할 위치에 매우 작은 음수값을 넣는다.\n",
        "  # 매우 작은 값이므로 소프트맥스 함수를 지나면 행렬의 해당 위치의 값은 0이 된다.\n",
        "  if mask is not None:\n",
        "    logits += (mask * -1e9)\n",
        "\n",
        "  # 소프트맥스 함수는 마지막 차원인 key의 문장 길이 방향으로 수행된다.\n",
        "  # attention weight : (batch_size, num_heads, query의 문장 길이, key의 문장 길이)\n",
        "  attention_weights = tf.nn.softmax(logits, axis=-1)\n",
        "\n",
        "  # output : (batch_size, num_heads, query의 문장 길이, d_model/num_heads)\n",
        "  output = tf.matmul(attention_weights, value)\n",
        "\n",
        "  return output, attention_weights"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RNU5ilcw9f3q"
      },
      "source": [
        "class MultiHeadAttention(tf.keras.layers.Layer):\n",
        "\n",
        "  def __init__(self, d_model, num_heads, name=\"multi_head_attention\"):\n",
        "    super(MultiHeadAttention, self).__init__(name=name)\n",
        "    self.num_heads = num_heads\n",
        "    self.d_model = d_model\n",
        "\n",
        "    assert d_model % self.num_heads == 0\n",
        "\n",
        "    # d_model을 num_heads로 나눈 값.\n",
        "    # 논문 기준 : 64\n",
        "    self.depth = d_model // self.num_heads\n",
        "\n",
        "    # WQ, WK, WV에 해당하는 밀집층 정의\n",
        "    self.query_dense = tf.keras.layers.Dense(units=d_model)\n",
        "    self.key_dense = tf.keras.layers.Dense(units=d_model)\n",
        "    self.value_dense = tf.keras.layers.Dense(units=d_model)\n",
        "\n",
        "    # WO에 해당하는 밀집층 정의\n",
        "    self.dense = tf.keras.layers.Dense(units=d_model)\n",
        "\n",
        "  # num_heads 개수만큼 q, k, v를 split하는 함수\n",
        "  def split_heads(self, inputs, batch_size):\n",
        "    inputs = tf.reshape(\n",
        "        inputs, shape=(batch_size, -1, self.num_heads, self.depth))\n",
        "    return tf.transpose(inputs, perm=[0, 2, 1, 3])\n",
        "\n",
        "  def call(self, inputs):\n",
        "    query, key, value, mask = inputs['query'], inputs['key'], inputs[\n",
        "        'value'], inputs['mask']\n",
        "    batch_size = tf.shape(query)[0]\n",
        "\n",
        "    # 1. WQ, WK, WV에 해당하는 밀집층 지나기\n",
        "    # q : (batch_size, query의 문장 길이, d_model)\n",
        "    # k : (batch_size, key의 문장 길이, d_model)\n",
        "    # v : (batch_size, value의 문장 길이, d_model)\n",
        "    # 참고) 인코더(k, v)-디코더(q) 어텐션에서는 query 길이와 key, value의 길이는 다를 수 있다.\n",
        "    query = self.query_dense(query)\n",
        "    key = self.key_dense(key)\n",
        "    value = self.value_dense(value)\n",
        "\n",
        "    # 2. 헤드 나누기\n",
        "    # q : (batch_size, num_heads, query의 문장 길이, d_model/num_heads)\n",
        "    # k : (batch_size, num_heads, key의 문장 길이, d_model/num_heads)\n",
        "    # v : (batch_size, num_heads, value의 문장 길이, d_model/num_heads)\n",
        "    query = self.split_heads(query, batch_size)\n",
        "    key = self.split_heads(key, batch_size)\n",
        "    value = self.split_heads(value, batch_size)\n",
        "\n",
        "    # 3. 스케일드 닷 프로덕트 어텐션. 앞서 구현한 함수 사용.\n",
        "    # (batch_size, num_heads, query의 문장 길이, d_model/num_heads)\n",
        "    scaled_attention, _ = scaled_dot_product_attention(query, key, value, mask)\n",
        "    # (batch_size, query의 문장 길이, num_heads, d_model/num_heads)\n",
        "    scaled_attention = tf.transpose(scaled_attention, perm=[0, 2, 1, 3])\n",
        "\n",
        "    # 4. 헤드 연결(concatenate)하기\n",
        "    # (batch_size, query의 문장 길이, d_model)\n",
        "    concat_attention = tf.reshape(scaled_attention,\n",
        "                                  (batch_size, -1, self.d_model))\n",
        "\n",
        "    # 5. WO에 해당하는 밀집층 지나기\n",
        "    # (batch_size, query의 문장 길이, d_model)\n",
        "    outputs = self.dense(concat_attention)\n",
        "\n",
        "    return outputs"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QrCdqp8z9ily"
      },
      "source": [
        "def create_padding_mask(x):\n",
        "  mask = tf.cast(tf.math.equal(x, 0), tf.float32)\n",
        "  # (batch_size, 1, 1, key의 문장 길이)\n",
        "  return mask[:, tf.newaxis, tf.newaxis, :]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nskamzrs9j1K"
      },
      "source": [
        "def encoder_layer(dff, d_model, num_heads, dropout, name=\"encoder_layer\"):\n",
        "  inputs = tf.keras.Input(shape=(None, d_model), name=\"inputs\")\n",
        "\n",
        "  # 인코더는 패딩 마스크 사용\n",
        "  padding_mask = tf.keras.Input(shape=(1, 1, None), name=\"padding_mask\")\n",
        "\n",
        "  # 멀티-헤드 어텐션 (첫번째 서브층 / 셀프 어텐션)\n",
        "  attention = MultiHeadAttention(\n",
        "      d_model, num_heads, name=\"attention\")({\n",
        "          'query': inputs, 'key': inputs, 'value': inputs, # Q = K = V\n",
        "          'mask': padding_mask # 패딩 마스크 사용\n",
        "      })\n",
        "\n",
        "  # 드롭아웃 + 잔차 연결과 층 정규화\n",
        "  attention = tf.keras.layers.Dropout(rate=dropout)(attention)\n",
        "  attention = tf.keras.layers.LayerNormalization(\n",
        "      epsilon=1e-6)(inputs + attention)\n",
        "\n",
        "  # 포지션 와이즈 피드 포워드 신경망 (두번째 서브층)\n",
        "  outputs = tf.keras.layers.Dense(units=dff, activation='relu')(attention)\n",
        "  outputs = tf.keras.layers.Dense(units=d_model)(outputs)\n",
        "\n",
        "  # 드롭아웃 + 잔차 연결과 층 정규화\n",
        "  outputs = tf.keras.layers.Dropout(rate=dropout)(outputs)\n",
        "  outputs = tf.keras.layers.LayerNormalization(\n",
        "      epsilon=1e-6)(attention + outputs)\n",
        "\n",
        "  return tf.keras.Model(\n",
        "      inputs=[inputs, padding_mask], outputs=outputs, name=name)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "34a0WK-B9lgi"
      },
      "source": [
        "def encoder(vocab_size, num_layers, dff,\n",
        "            d_model, num_heads, dropout,\n",
        "            name=\"encoder\"):\n",
        "  inputs = tf.keras.Input(shape=(None,), name=\"inputs\")\n",
        "\n",
        "  # 인코더는 패딩 마스크 사용\n",
        "  padding_mask = tf.keras.Input(shape=(1, 1, None), name=\"padding_mask\")\n",
        "\n",
        "  # 포지셔널 인코딩 + 드롭아웃\n",
        "  embeddings = tf.keras.layers.Embedding(vocab_size, d_model)(inputs)\n",
        "  embeddings *= tf.math.sqrt(tf.cast(d_model, tf.float32))\n",
        "  embeddings = PositionalEncoding(vocab_size, d_model)(embeddings)\n",
        "  outputs = tf.keras.layers.Dropout(rate=dropout)(embeddings)\n",
        "\n",
        "  # 인코더를 num_layers개 쌓기\n",
        "  for i in range(num_layers):\n",
        "    outputs = encoder_layer(dff=dff, d_model=d_model, num_heads=num_heads,\n",
        "        dropout=dropout, name=\"encoder_layer_{}\".format(i),\n",
        "    )([outputs, padding_mask])\n",
        "\n",
        "  return tf.keras.Model(\n",
        "      inputs=[inputs, padding_mask], outputs=outputs, name=name)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ng1ysGoJ9mha"
      },
      "source": [
        "# 디코더의 첫번째 서브층(sublayer)에서 미래 토큰을 Mask하는 함수\n",
        "def create_look_ahead_mask(x):\n",
        "  seq_len = tf.shape(x)[1]\n",
        "  look_ahead_mask = 1 - tf.linalg.band_part(tf.ones((seq_len, seq_len)), -1, 0)\n",
        "  padding_mask = create_padding_mask(x) # 패딩 마스크도 포함\n",
        "  return tf.maximum(look_ahead_mask, padding_mask)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "I3QDoLz49oPK"
      },
      "source": [
        "def decoder_layer(dff, d_model, num_heads, dropout, name=\"decoder_layer\"):\n",
        "  inputs = tf.keras.Input(shape=(None, d_model), name=\"inputs\")\n",
        "  enc_outputs = tf.keras.Input(shape=(None, d_model), name=\"encoder_outputs\")\n",
        "\n",
        "  # 디코더는 룩어헤드 마스크(첫번째 서브층)와 패딩 마스크(두번째 서브층) 둘 다 사용.\n",
        "  look_ahead_mask = tf.keras.Input(\n",
        "      shape=(1, None, None), name=\"look_ahead_mask\")\n",
        "  padding_mask = tf.keras.Input(shape=(1, 1, None), name='padding_mask')\n",
        "\n",
        "  # 멀티-헤드 어텐션 (첫번째 서브층 / 마스크드 셀프 어텐션)\n",
        "  attention1 = MultiHeadAttention(\n",
        "      d_model, num_heads, name=\"attention_1\")(inputs={\n",
        "          'query': inputs, 'key': inputs, 'value': inputs, # Q = K = V\n",
        "          'mask': look_ahead_mask # 룩어헤드 마스크\n",
        "      })\n",
        "\n",
        "  # 잔차 연결과 층 정규화\n",
        "  attention1 = tf.keras.layers.LayerNormalization(\n",
        "      epsilon=1e-6)(attention1 + inputs)\n",
        "\n",
        "  # 멀티-헤드 어텐션 (두번째 서브층 / 디코더-인코더 어텐션)\n",
        "  attention2 = MultiHeadAttention(\n",
        "      d_model, num_heads, name=\"attention_2\")(inputs={\n",
        "          'query': attention1, 'key': enc_outputs, 'value': enc_outputs, # Q != K = V\n",
        "          'mask': padding_mask # 패딩 마스크\n",
        "      })\n",
        "\n",
        "  # 드롭아웃 + 잔차 연결과 층 정규화\n",
        "  attention2 = tf.keras.layers.Dropout(rate=dropout)(attention2)\n",
        "  attention2 = tf.keras.layers.LayerNormalization(\n",
        "      epsilon=1e-6)(attention2 + attention1)\n",
        "\n",
        "  # 포지션 와이즈 피드 포워드 신경망 (세번째 서브층)\n",
        "  outputs = tf.keras.layers.Dense(units=dff, activation='relu')(attention2)\n",
        "  outputs = tf.keras.layers.Dense(units=d_model)(outputs)\n",
        "\n",
        "  # 드롭아웃 + 잔차 연결과 층 정규화\n",
        "  outputs = tf.keras.layers.Dropout(rate=dropout)(outputs)\n",
        "  outputs = tf.keras.layers.LayerNormalization(\n",
        "      epsilon=1e-6)(outputs + attention2)\n",
        "\n",
        "  return tf.keras.Model(\n",
        "      inputs=[inputs, enc_outputs, look_ahead_mask, padding_mask],\n",
        "      outputs=outputs,\n",
        "      name=name)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5i9lZmji9qDa"
      },
      "source": [
        "def decoder(vocab_size, num_layers, dff,\n",
        "            d_model, num_heads, dropout,\n",
        "            name='decoder'):\n",
        "  inputs = tf.keras.Input(shape=(None,), name='inputs')\n",
        "  enc_outputs = tf.keras.Input(shape=(None, d_model), name='encoder_outputs')\n",
        "\n",
        "  # 디코더는 룩어헤드 마스크(첫번째 서브층)와 패딩 마스크(두번째 서브층) 둘 다 사용.\n",
        "  look_ahead_mask = tf.keras.Input(\n",
        "      shape=(1, None, None), name='look_ahead_mask')\n",
        "  padding_mask = tf.keras.Input(shape=(1, 1, None), name='padding_mask')\n",
        "\n",
        "  # 포지셔널 인코딩 + 드롭아웃\n",
        "  embeddings = tf.keras.layers.Embedding(vocab_size, d_model)(inputs)\n",
        "  embeddings *= tf.math.sqrt(tf.cast(d_model, tf.float32))\n",
        "  embeddings = PositionalEncoding(vocab_size, d_model)(embeddings)\n",
        "  outputs = tf.keras.layers.Dropout(rate=dropout)(embeddings)\n",
        "\n",
        "  # 디코더를 num_layers개 쌓기\n",
        "  for i in range(num_layers):\n",
        "    outputs = decoder_layer(dff=dff, d_model=d_model, num_heads=num_heads,\n",
        "        dropout=dropout, name='decoder_layer_{}'.format(i),\n",
        "    )(inputs=[outputs, enc_outputs, look_ahead_mask, padding_mask])\n",
        "\n",
        "  return tf.keras.Model(\n",
        "      inputs=[inputs, enc_outputs, look_ahead_mask, padding_mask],\n",
        "      outputs=outputs,\n",
        "      name=name)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-GEC6CXF9q7S"
      },
      "source": [
        "def transformer(vocab_size, num_layers, dff,\n",
        "                d_model, num_heads, dropout,\n",
        "                name=\"transformer\"):\n",
        "\n",
        "  # 인코더의 입력\n",
        "  inputs = tf.keras.Input(shape=(None,), name=\"inputs\")\n",
        "\n",
        "  # 디코더의 입력\n",
        "  dec_inputs = tf.keras.Input(shape=(None,), name=\"dec_inputs\")\n",
        "\n",
        "  # 인코더의 패딩 마스크\n",
        "  enc_padding_mask = tf.keras.layers.Lambda(\n",
        "      create_padding_mask, output_shape=(1, 1, None),\n",
        "      name='enc_padding_mask')(inputs)\n",
        "\n",
        "  # 디코더의 룩어헤드 마스크(첫번째 서브층)\n",
        "  look_ahead_mask = tf.keras.layers.Lambda(\n",
        "      create_look_ahead_mask, output_shape=(1, None, None),\n",
        "      name='look_ahead_mask')(dec_inputs)\n",
        "\n",
        "  # 디코더의 패딩 마스크(두번째 서브층)\n",
        "  dec_padding_mask = tf.keras.layers.Lambda(\n",
        "      create_padding_mask, output_shape=(1, 1, None),\n",
        "      name='dec_padding_mask')(inputs)\n",
        "\n",
        "  # 인코더의 출력은 enc_outputs. 디코더로 전달된다.\n",
        "  enc_outputs = encoder(vocab_size=vocab_size, num_layers=num_layers, dff=dff,\n",
        "      d_model=d_model, num_heads=num_heads, dropout=dropout,\n",
        "  )(inputs=[inputs, enc_padding_mask]) # 인코더의 입력은 입력 문장과 패딩 마스크\n",
        "\n",
        "  # 디코더의 출력은 dec_outputs. 출력층으로 전달된다.\n",
        "  dec_outputs = decoder(vocab_size=vocab_size, num_layers=num_layers, dff=dff,\n",
        "      d_model=d_model, num_heads=num_heads, dropout=dropout,\n",
        "  )(inputs=[dec_inputs, enc_outputs, look_ahead_mask, dec_padding_mask])\n",
        "\n",
        "  # 다음 단어 예측을 위한 출력층\n",
        "  outputs = tf.keras.layers.Dense(units=vocab_size, name=\"outputs\")(dec_outputs)\n",
        "\n",
        "  return tf.keras.Model(inputs=[inputs, dec_inputs], outputs=outputs, name=name)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 568
        },
        "id": "ori23vQy9sRq",
        "outputId": "c9e0a219-654a-40f0-96df-6d2df766df27"
      },
      "source": [
        "small_transformer = transformer(\n",
        "    vocab_size = 9000,\n",
        "    num_layers = 4,\n",
        "    dff = 512,\n",
        "    d_model = 128,\n",
        "    num_heads = 4,\n",
        "    dropout = 0.3,\n",
        "    name=\"small_transformer\")\n",
        "\n",
        "tf.keras.utils.plot_model(\n",
        "    small_transformer, to_file='small_transformer.png', show_shapes=True)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(1, 9000, 128)\n",
            "(1, 9000, 128)\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<IPython.core.display.Image object>"
            ]
          },
          "metadata": {},
          "execution_count": 14
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7DgCW2_k-8KM"
      },
      "source": [
        "def loss_function(y_true, y_pred):\n",
        "  y_true = tf.reshape(y_true, shape=(-1, MAX_LENGTH - 1))\n",
        "\n",
        "  loss = tf.keras.losses.SparseCategoricalCrossentropy(\n",
        "      from_logits=True, reduction='none')(y_true, y_pred)\n",
        "\n",
        "  mask = tf.cast(tf.not_equal(y_true, 0), tf.float32)\n",
        "  loss = tf.multiply(loss, mask)\n",
        "\n",
        "  return tf.reduce_mean(loss)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kkkz7qka_tSU"
      },
      "source": [
        "class CustomSchedule(tf.keras.optimizers.schedules.LearningRateSchedule):\n",
        "\n",
        "  def __init__(self, d_model, warmup_steps=4000):\n",
        "    super(CustomSchedule, self).__init__()\n",
        "    self.d_model = d_model\n",
        "    self.d_model = tf.cast(self.d_model, tf.float32)\n",
        "    self.warmup_steps = warmup_steps\n",
        "\n",
        "  def __call__(self, step):\n",
        "    arg1 = tf.math.rsqrt(step)\n",
        "    arg2 = step * (self.warmup_steps**-1.5)\n",
        "\n",
        "    return tf.math.rsqrt(self.d_model) * tf.math.minimum(arg1, arg2)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 296
        },
        "id": "k4lA_Efe_uOx",
        "outputId": "0ac170c0-3298-4ebe-c2d7-33543b829fa5"
      },
      "source": [
        "sample_learning_rate = CustomSchedule(d_model=128)\n",
        "\n",
        "plt.plot(sample_learning_rate(tf.range(200000, dtype=tf.float32)))\n",
        "plt.ylabel(\"Learning Rate\")\n",
        "plt.xlabel(\"Train Step\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Text(0.5, 0, 'Train Step')"
            ]
          },
          "metadata": {},
          "execution_count": 17
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "w9tpZXei_1xK"
      },
      "source": [
        "# 챗봇 구현"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "M5W2D7Uq_u_x"
      },
      "source": [
        "import pandas as pd\n",
        "import urllib.request\n",
        "import tensorflow_datasets as tfds\n",
        "import tensorflow as tf\n",
        "import time\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "import re"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 205
        },
        "id": "t7ku6KRb_545",
        "outputId": "38f43203-6e81-4861-fc7e-d351e6a5ddae"
      },
      "source": [
        "urllib.request.urlretrieve(\"https://raw.githubusercontent.com/songys/Chatbot_data/master/ChatbotData.csv\", filename=\"ChatBotData.csv\")\n",
        "\n",
        "train_data = pd.read_csv('ChatBotData.csv')\n",
        "train_data.head()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "<div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>Q</th>\n",
              "      <th>A</th>\n",
              "      <th>label</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>12시 땡!</td>\n",
              "      <td>하루가 또 가네요.</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>1지망 학교 떨어졌어</td>\n",
              "      <td>위로해 드립니다.</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>3박4일 놀러가고 싶다</td>\n",
              "      <td>여행은 언제나 좋죠.</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>3박4일 정도 놀러가고 싶다</td>\n",
              "      <td>여행은 언제나 좋죠.</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>PPL 심하네</td>\n",
              "      <td>눈살이 찌푸려지죠.</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "                 Q            A  label\n",
              "0           12시 땡!   하루가 또 가네요.      0\n",
              "1      1지망 학교 떨어졌어    위로해 드립니다.      0\n",
              "2     3박4일 놀러가고 싶다  여행은 언제나 좋죠.      0\n",
              "3  3박4일 정도 놀러가고 싶다  여행은 언제나 좋죠.      0\n",
              "4          PPL 심하네   눈살이 찌푸려지죠.      0"
            ]
          },
          "metadata": {},
          "execution_count": 2
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3hpk8Z-P_6hh",
        "outputId": "9f26f756-9e5e-4778-f4b6-7aa3fcd3a529"
      },
      "source": [
        "print('챗봇 샘플의 개수 :', len(train_data))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "챗봇 샘플의 개수 : 11823\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bXg6ws2s_9Ch",
        "outputId": "12f1a60d-4d21-4b17-b82e-f6c2c58b2108"
      },
      "source": [
        "print(train_data.isnull().sum())"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Q        0\n",
            "A        0\n",
            "label    0\n",
            "dtype: int64\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9AKOHALL_9rJ"
      },
      "source": [
        "questions = []\n",
        "for sentence in train_data['Q']:\n",
        "    # 구두점에 대해서 띄어쓰기\n",
        "    # ex) 12시 땡! -> 12시 땡 !\n",
        "    sentence = re.sub(r\"([?.!,])\", r\" \\1 \", sentence)\n",
        "    sentence = sentence.strip()\n",
        "    questions.append(sentence)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GoJs0Od8_-aB"
      },
      "source": [
        "answers = []\n",
        "for sentence in train_data['A']:\n",
        "    # 구두점에 대해서 띄어쓰기\n",
        "    # ex) 12시 땡! -> 12시 땡 !\n",
        "    sentence = re.sub(r\"([?.!,])\", r\" \\1 \", sentence)\n",
        "    sentence = sentence.strip()\n",
        "    answers.append(sentence)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6AS2olsI__KJ",
        "outputId": "3e6686d6-507c-4453-c3a0-49d8ec415e47"
      },
      "source": [
        "len(questions)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "11823"
            ]
          },
          "metadata": {},
          "execution_count": 26
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KM7QxzSG__9B",
        "outputId": "1da90ec9-8d20-4df9-ece0-1da24879bbd1"
      },
      "source": [
        "print(questions[:5])\n",
        "print(answers[:5])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['12시 땡 !', '1지망 학교 떨어졌어', '3박4일 놀러가고 싶다', '3박4일 정도 놀러가고 싶다', 'PPL 심하네']\n",
            "['하루가 또 가네요 .', '위로해 드립니다 .', '여행은 언제나 좋죠 .', '여행은 언제나 좋죠 .', '눈살이 찌푸려지죠 .']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iSYgYFMVABRq"
      },
      "source": [
        "# 서브워드텍스트인코더를 사용하여 질문과 답변을 모두 포함한 단어 집합(Vocabulary) 생성\n",
        "tokenizer = tfds.deprecated.text.SubwordTextEncoder.build_from_corpus(\n",
        "    questions + answers, target_vocab_size=2**13)\n",
        "\n",
        "# 시작 토큰과 종료 토큰에 대한 정수 부여.\n",
        "START_TOKEN, END_TOKEN = [tokenizer.vocab_size], [tokenizer.vocab_size + 1]\n",
        "\n",
        "# 시작 토큰과 종료 토큰을 고려하여 단어 집합의 크기를 + 2\n",
        "VOCAB_SIZE = tokenizer.vocab_size + 2"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Ln_by7YmGPTI",
        "outputId": "7a63ada7-5481-4b92-c45d-3e517e970c4b"
      },
      "source": [
        "print('시작 토큰 번호 :',START_TOKEN)\n",
        "print('종료 토큰 번호 :',END_TOKEN)\n",
        "print('단어 집합의 크기 :',VOCAB_SIZE)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "시작 토큰 번호 : [8178]\n",
            "종료 토큰 번호 : [8179]\n",
            "단어 집합의 크기 : 8180\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OnCM12LCACDB",
        "outputId": "0a22c38f-7b56-4ae0-f8f2-096ced558dd4"
      },
      "source": [
        "# 서브워드텍스트인코더 토크나이저의 .encode()를 사용하여 텍스트 시퀀스를 정수 시퀀스로 변환.\n",
        "print('Tokenized sample question: {}'.format(tokenizer.encode(questions[20])))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Tokenized sample question: [5766, 611, 3509, 141, 685, 3747, 849]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "X6616jr1ALcS",
        "outputId": "9d57ec4d-d86e-498b-83b6-c8b32c068069"
      },
      "source": [
        "# 서브워드텍스트인코더 토크나이저의 .encode()와 decode() 테스트해보기\n",
        "\n",
        "# 임의의 입력 문장을 sample_string에 저장\n",
        "sample_string = questions[20]\n",
        "\n",
        "# encode() : 텍스트 시퀀스 --> 정수 시퀀스\n",
        "tokenized_string = tokenizer.encode(sample_string)\n",
        "print ('정수 인코딩 후의 문장 {}'.format(tokenized_string))\n",
        "\n",
        "# decode() : 정수 시퀀스 --> 텍스트 시퀀스\n",
        "original_string = tokenizer.decode(tokenized_string)\n",
        "print ('기존 문장: {}'.format(original_string))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "정수 인코딩 후의 문장 [5766, 611, 3509, 141, 685, 3747, 849]\n",
            "기존 문장: 가스비 비싼데 감기 걸리겠어\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ySXbL7GQAPhS",
        "outputId": "649fe380-d7c1-4cc3-d70d-7a274c53ae6f"
      },
      "source": [
        "# 각 정수는 각 단어와 어떻게 mapping되는지 병렬로 출력\n",
        "# 서브워드텍스트인코더는 의미있는 단위의 서브워드로 토크나이징한다. 띄어쓰기 단위 X 형태소 분석 단위 X\n",
        "for ts in tokenized_string:\n",
        "  print ('{} ----> {}'.format(ts, tokenizer.decode([ts])))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "5766 ----> 가스\n",
            "611 ----> 비 \n",
            "3509 ----> 비싼\n",
            "141 ----> 데 \n",
            "685 ----> 감기 \n",
            "3747 ----> 걸리\n",
            "849 ----> 겠어\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Dl69HqzjATYG"
      },
      "source": [
        "# 최대 길이를 40으로 정의\n",
        "MAX_LENGTH = 40\n",
        "\n",
        "# 토큰화 / 정수 인코딩 / 시작 토큰과 종료 토큰 추가 / 패딩\n",
        "def tokenize_and_filter(inputs, outputs):\n",
        "  tokenized_inputs, tokenized_outputs = [], []\n",
        "  \n",
        "  for (sentence1, sentence2) in zip(inputs, outputs):\n",
        "    # encode(토큰화 + 정수 인코딩), 시작 토큰과 종료 토큰 추가\n",
        "    sentence1 = START_TOKEN + tokenizer.encode(sentence1) + END_TOKEN\n",
        "    sentence2 = START_TOKEN + tokenizer.encode(sentence2) + END_TOKEN\n",
        "\n",
        "    tokenized_inputs.append(sentence1)\n",
        "    tokenized_outputs.append(sentence2)\n",
        "  \n",
        "  # 패딩\n",
        "  tokenized_inputs = tf.keras.preprocessing.sequence.pad_sequences(\n",
        "      tokenized_inputs, maxlen=MAX_LENGTH, padding='post')\n",
        "  tokenized_outputs = tf.keras.preprocessing.sequence.pad_sequences(\n",
        "      tokenized_outputs, maxlen=MAX_LENGTH, padding='post')\n",
        "  \n",
        "  return tokenized_inputs, tokenized_outputs"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qJJc_H5oAWmC"
      },
      "source": [
        "questions, answers = tokenize_and_filter(questions, answers)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4-iBwtZqAXxC",
        "outputId": "77915d6b-b400-4b6c-f4d6-43a4f43f2729"
      },
      "source": [
        "print('질문 데이터의 크기(shape) :', questions.shape)\n",
        "print('답변 데이터의 크기(shape) :', answers.shape)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "질문 데이터의 크기(shape) : (11823, 40)\n",
            "답변 데이터의 크기(shape) : (11823, 40)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fUnwWj4pAYox",
        "outputId": "cbbe5ba7-e8d7-4fd4-9200-b90e6156b220"
      },
      "source": [
        "# 0번째 샘플을 임의로 출력\n",
        "print(questions[0])\n",
        "print(answers[0])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[8178 7915 4207 3060   41 8179    0    0    0    0    0    0    0    0\n",
            "    0    0    0    0    0    0    0    0    0    0    0    0    0    0\n",
            "    0    0    0    0    0    0    0    0    0    0    0    0]\n",
            "[8178 3844   74 7894    1 8179    0    0    0    0    0    0    0    0\n",
            "    0    0    0    0    0    0    0    0    0    0    0    0    0    0\n",
            "    0    0    0    0    0    0    0    0    0    0    0    0]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ThFD6K_tAZN5",
        "outputId": "e025c4af-c668-420b-fde7-f209387cc142"
      },
      "source": [
        "print('단어 집합의 크기(Vocab size): {}'.format(VOCAB_SIZE))\n",
        "print('전체 샘플의 수(Number of samples): {}'.format(len(questions)))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "단어 집합의 크기(Vocab size): 8180\n",
            "전체 샘플의 수(Number of samples): 11823\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_FXoh56KAaBx"
      },
      "source": [
        "# 텐서플로우 dataset을 이용하여 셔플(shuffle)을 수행하되, 배치 크기로 데이터를 묶는다.\n",
        "# 또한 이 과정에서 교사 강요(teacher forcing)을 사용하기 위해서 디코더의 입력과 실제값 시퀀스를 구성한다.\n",
        "BATCH_SIZE = 64\n",
        "BUFFER_SIZE = 20000\n",
        "\n",
        "# 디코더의 실제값 시퀀스에서는 시작 토큰을 제거해야 한다.\n",
        "dataset = tf.data.Dataset.from_tensor_slices((\n",
        "    {\n",
        "        'inputs': questions,\n",
        "        'dec_inputs': answers[:, :-1] # 디코더의 입력. 마지막 패딩 토큰이 제거된다.\n",
        "    },\n",
        "    {\n",
        "        'outputs': answers[:, 1:]  # 맨 처음 토큰이 제거된다. 다시 말해 시작 토큰이 제거된다.\n",
        "    },\n",
        "))\n",
        "\n",
        "dataset = dataset.cache()\n",
        "dataset = dataset.shuffle(BUFFER_SIZE)\n",
        "dataset = dataset.batch(BATCH_SIZE)\n",
        "dataset = dataset.prefetch(tf.data.experimental.AUTOTUNE)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "H9vu74odAaxB",
        "outputId": "5f39fab4-ffaf-4877-aa1b-b4d7c7f4569c"
      },
      "source": [
        "# 임의의 샘플에 대해서 [:, :-1]과 [:, 1:]이 어떤 의미를 가지는지 테스트해본다.\n",
        "print(answers[0]) # 기존 샘플\n",
        "print(answers[:1][:, :-1]) # 마지막 패딩 토큰 제거하면서 길이가 39가 된다.\n",
        "print(answers[:1][:, 1:]) # 맨 처음 토큰이 제거된다. 다시 말해 시작 토큰이 제거된다. 길이는 역시 39가 된다."
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[8178 3844   74 7894    1 8179    0    0    0    0    0    0    0    0\n",
            "    0    0    0    0    0    0    0    0    0    0    0    0    0    0\n",
            "    0    0    0    0    0    0    0    0    0    0    0    0]\n",
            "[[8178 3844   74 7894    1 8179    0    0    0    0    0    0    0    0\n",
            "     0    0    0    0    0    0    0    0    0    0    0    0    0    0\n",
            "     0    0    0    0    0    0    0    0    0    0    0]]\n",
            "[[3844   74 7894    1 8179    0    0    0    0    0    0    0    0    0\n",
            "     0    0    0    0    0    0    0    0    0    0    0    0    0    0\n",
            "     0    0    0    0    0    0    0    0    0    0    0]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "A0tcomE6AblR",
        "outputId": "c57c83df-d833-4bdb-85c0-c132215af4e1"
      },
      "source": [
        "tf.keras.backend.clear_session()\n",
        "\n",
        "# Hyper-parameters\n",
        "NUM_LAYERS = 2\n",
        "D_MODEL = 256\n",
        "NUM_HEADS = 8\n",
        "DFF = 512\n",
        "DROPOUT = 0.1\n",
        "\n",
        "model = transformer(\n",
        "    vocab_size=VOCAB_SIZE,\n",
        "    num_layers=NUM_LAYERS,\n",
        "    dff=DFF,\n",
        "    d_model=D_MODEL,\n",
        "    num_heads=NUM_HEADS,\n",
        "    dropout=DROPOUT)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(1, 8180, 256)\n",
            "(1, 8180, 256)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "w3qpxTy7Ainq"
      },
      "source": [
        "MAX_LENGTH = 40\n",
        "\n",
        "learning_rate = CustomSchedule(D_MODEL)\n",
        "\n",
        "optimizer = tf.keras.optimizers.Adam(\n",
        "    learning_rate, beta_1=0.9, beta_2=0.98, epsilon=1e-9)\n",
        "\n",
        "def accuracy(y_true, y_pred):\n",
        "  # ensure labels have shape (batch_size, MAX_LENGTH - 1)\n",
        "  y_true = tf.reshape(y_true, shape=(-1, MAX_LENGTH - 1))\n",
        "  return tf.keras.metrics.sparse_categorical_accuracy(y_true, y_pred)\n",
        "\n",
        "model.compile(optimizer=optimizer, loss=loss_function, metrics=[accuracy])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jq-Ow4L0Aoqy",
        "outputId": "2fcee7c2-8fc2-4d8b-8004-1ad7a7b26c7d"
      },
      "source": [
        "EPOCHS = 50\n",
        "\n",
        "model.fit(dataset, epochs=EPOCHS)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/50\n",
            "185/185 [==============================] - 20s 57ms/step - loss: 1.4492 - accuracy: 0.0216\n",
            "Epoch 2/50\n",
            "185/185 [==============================] - 10s 56ms/step - loss: 1.1760 - accuracy: 0.0491\n",
            "Epoch 3/50\n",
            "185/185 [==============================] - 10s 56ms/step - loss: 1.0066 - accuracy: 0.0506\n",
            "Epoch 4/50\n",
            "185/185 [==============================] - 10s 56ms/step - loss: 0.9295 - accuracy: 0.0543\n",
            "Epoch 5/50\n",
            "185/185 [==============================] - 10s 56ms/step - loss: 0.8702 - accuracy: 0.0576\n",
            "Epoch 6/50\n",
            "185/185 [==============================] - 10s 56ms/step - loss: 0.8102 - accuracy: 0.0618\n",
            "Epoch 7/50\n",
            "185/185 [==============================] - 10s 56ms/step - loss: 0.7443 - accuracy: 0.0680\n",
            "Epoch 8/50\n",
            "185/185 [==============================] - 10s 56ms/step - loss: 0.6720 - accuracy: 0.0759\n",
            "Epoch 9/50\n",
            "185/185 [==============================] - 10s 56ms/step - loss: 0.5938 - accuracy: 0.0844\n",
            "Epoch 10/50\n",
            "185/185 [==============================] - 10s 56ms/step - loss: 0.5114 - accuracy: 0.0937\n",
            "Epoch 11/50\n",
            "185/185 [==============================] - 10s 57ms/step - loss: 0.4277 - accuracy: 0.1042\n",
            "Epoch 12/50\n",
            "185/185 [==============================] - 10s 56ms/step - loss: 0.3475 - accuracy: 0.1149\n",
            "Epoch 13/50\n",
            "185/185 [==============================] - 10s 56ms/step - loss: 0.2729 - accuracy: 0.1258\n",
            "Epoch 14/50\n",
            "185/185 [==============================] - 10s 56ms/step - loss: 0.2068 - accuracy: 0.1360\n",
            "Epoch 15/50\n",
            "185/185 [==============================] - 10s 56ms/step - loss: 0.1513 - accuracy: 0.1457\n",
            "Epoch 16/50\n",
            "185/185 [==============================] - 10s 56ms/step - loss: 0.1090 - accuracy: 0.1532\n",
            "Epoch 17/50\n",
            "185/185 [==============================] - 10s 56ms/step - loss: 0.0797 - accuracy: 0.1586\n",
            "Epoch 18/50\n",
            "185/185 [==============================] - 10s 56ms/step - loss: 0.0619 - accuracy: 0.1617\n",
            "Epoch 19/50\n",
            "185/185 [==============================] - 10s 57ms/step - loss: 0.0510 - accuracy: 0.1637\n",
            "Epoch 20/50\n",
            "185/185 [==============================] - 10s 56ms/step - loss: 0.0463 - accuracy: 0.1642\n",
            "Epoch 21/50\n",
            "185/185 [==============================] - 10s 56ms/step - loss: 0.0418 - accuracy: 0.1650\n",
            "Epoch 22/50\n",
            "185/185 [==============================] - 10s 56ms/step - loss: 0.0414 - accuracy: 0.1650\n",
            "Epoch 23/50\n",
            "185/185 [==============================] - 10s 56ms/step - loss: 0.0362 - accuracy: 0.1663\n",
            "Epoch 24/50\n",
            "185/185 [==============================] - 10s 56ms/step - loss: 0.0325 - accuracy: 0.1670\n",
            "Epoch 25/50\n",
            "185/185 [==============================] - 10s 56ms/step - loss: 0.0279 - accuracy: 0.1680\n",
            "Epoch 26/50\n",
            "185/185 [==============================] - 10s 56ms/step - loss: 0.0245 - accuracy: 0.1691\n",
            "Epoch 27/50\n",
            "185/185 [==============================] - 10s 56ms/step - loss: 0.0223 - accuracy: 0.1695\n",
            "Epoch 28/50\n",
            "185/185 [==============================] - 10s 56ms/step - loss: 0.0201 - accuracy: 0.1700\n",
            "Epoch 29/50\n",
            "185/185 [==============================] - 10s 56ms/step - loss: 0.0181 - accuracy: 0.1707\n",
            "Epoch 30/50\n",
            "185/185 [==============================] - 10s 56ms/step - loss: 0.0173 - accuracy: 0.1707\n",
            "Epoch 31/50\n",
            "185/185 [==============================] - 10s 56ms/step - loss: 0.0155 - accuracy: 0.1713\n",
            "Epoch 32/50\n",
            "185/185 [==============================] - 10s 56ms/step - loss: 0.0140 - accuracy: 0.1716\n",
            "Epoch 33/50\n",
            "185/185 [==============================] - 10s 56ms/step - loss: 0.0130 - accuracy: 0.1719\n",
            "Epoch 34/50\n",
            "185/185 [==============================] - 10s 56ms/step - loss: 0.0119 - accuracy: 0.1722\n",
            "Epoch 35/50\n",
            "185/185 [==============================] - 10s 56ms/step - loss: 0.0113 - accuracy: 0.1724\n",
            "Epoch 36/50\n",
            "185/185 [==============================] - 10s 56ms/step - loss: 0.0107 - accuracy: 0.1725\n",
            "Epoch 37/50\n",
            "185/185 [==============================] - 10s 56ms/step - loss: 0.0103 - accuracy: 0.1726\n",
            "Epoch 38/50\n",
            "185/185 [==============================] - 10s 56ms/step - loss: 0.0094 - accuracy: 0.1728\n",
            "Epoch 39/50\n",
            "185/185 [==============================] - 10s 56ms/step - loss: 0.0089 - accuracy: 0.1729\n",
            "Epoch 40/50\n",
            "185/185 [==============================] - 10s 56ms/step - loss: 0.0088 - accuracy: 0.1729\n",
            "Epoch 41/50\n",
            "185/185 [==============================] - 10s 56ms/step - loss: 0.0079 - accuracy: 0.1732\n",
            "Epoch 42/50\n",
            "185/185 [==============================] - 10s 56ms/step - loss: 0.0081 - accuracy: 0.1732\n",
            "Epoch 43/50\n",
            "185/185 [==============================] - 10s 56ms/step - loss: 0.0072 - accuracy: 0.1734\n",
            "Epoch 44/50\n",
            "185/185 [==============================] - 10s 56ms/step - loss: 0.0069 - accuracy: 0.1735\n",
            "Epoch 45/50\n",
            "185/185 [==============================] - 10s 56ms/step - loss: 0.0067 - accuracy: 0.1734\n",
            "Epoch 46/50\n",
            "185/185 [==============================] - 10s 56ms/step - loss: 0.0064 - accuracy: 0.1735\n",
            "Epoch 47/50\n",
            "185/185 [==============================] - 10s 56ms/step - loss: 0.0062 - accuracy: 0.1735\n",
            "Epoch 48/50\n",
            "185/185 [==============================] - 10s 56ms/step - loss: 0.0060 - accuracy: 0.1736\n",
            "Epoch 49/50\n",
            "185/185 [==============================] - 10s 56ms/step - loss: 0.0058 - accuracy: 0.1737\n",
            "Epoch 50/50\n",
            "185/185 [==============================] - 10s 56ms/step - loss: 0.0057 - accuracy: 0.1737\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<keras.callbacks.History at 0x7fe1f51b8650>"
            ]
          },
          "metadata": {},
          "execution_count": 42
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dOTNLOCdArDi"
      },
      "source": [
        "def evaluate(sentence):\n",
        "  sentence = preprocess_sentence(sentence)\n",
        "\n",
        "  sentence = tf.expand_dims(\n",
        "      START_TOKEN + tokenizer.encode(sentence) + END_TOKEN, axis=0)\n",
        "\n",
        "  output = tf.expand_dims(START_TOKEN, 0)\n",
        "\n",
        "  # 디코더의 예측 시작\n",
        "  for i in range(MAX_LENGTH):\n",
        "    predictions = model(inputs=[sentence, output], training=False)\n",
        "\n",
        "    # 현재(마지막) 시점의 예측 단어를 받아온다.\n",
        "    predictions = predictions[:, -1:, :]\n",
        "    predicted_id = tf.cast(tf.argmax(predictions, axis=-1), tf.int32)\n",
        "\n",
        "    # 만약 마지막 시점의 예측 단어가 종료 토큰이라면 예측을 중단\n",
        "    if tf.equal(predicted_id, END_TOKEN[0]):\n",
        "      break\n",
        "\n",
        "    # 마지막 시점의 예측 단어를 출력에 연결한다.\n",
        "    # 이는 for문을 통해서 디코더의 입력으로 사용될 예정이다.\n",
        "    output = tf.concat([output, predicted_id], axis=-1)\n",
        "\n",
        "  return tf.squeeze(output, axis=0)\n",
        "\n",
        "\n",
        "def predict(sentence):\n",
        "  prediction = evaluate(sentence)\n",
        "\n",
        "  predicted_sentence = tokenizer.decode(\n",
        "      [i for i in prediction if i < tokenizer.vocab_size])\n",
        "\n",
        "  print('Input: {}'.format(sentence))\n",
        "  print('Output: {}'.format(predicted_sentence))\n",
        "\n",
        "  return predicted_sentence"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PAHvRASLBQyz"
      },
      "source": [
        "def preprocess_sentence(sentence):\n",
        "  sentence = re.sub(r\"([?.!,])\", r\" \\1 \", sentence)\n",
        "  sentence = sentence.strip()\n",
        "  return sentence"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ujmHO_QdUTji",
        "outputId": "7a05d963-a4c4-4cf3-ec82-12cd8a1ad73b"
      },
      "source": [
        "output = predict('영화 볼래?')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Input: 영화 볼래?\n",
            "Output: 최신 영화가 좋을 것 같아요 .\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "V3H--FxhUUoC",
        "outputId": "5ec6c143-e819-474f-ae27-7598de1cb8b2"
      },
      "source": [
        "output = predict(\"고민이 있어\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Input: 고민이 있어\n",
            "Output: 생각을 종이에 끄젹여여 보는게 도움이 될 수도 있어요 .\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mW_bzLFCUWrg",
        "outputId": "31920f25-1f04-4cce-cd27-25b3779aa43e"
      },
      "source": [
        "output = predict(\"너무 화가나\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Input: 너무 화가나\n",
            "Output: 그럴수록 당신이 힘들 거예요 .\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QYqi9AeZUl_q",
        "outputId": "1ec54330-83e2-4d22-adcd-40d549405855"
      },
      "source": [
        "output = predict(\"게임하고싶은데 할래?\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Input: 게임하고싶은데 할래?\n",
            "Output: 게임하세요 !\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "O6GJLMO1UorF",
        "outputId": "5ebc60f7-0edc-4fd1-840b-4153e98cedbf"
      },
      "source": [
        "output = predict(\"나 너 좋아하는 것 같아\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Input: 나 너 좋아하는 것 같아\n",
            "Output: 호의인지 호감인지 헷갈리나요 ?\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tUl6DCxFUvm2",
        "outputId": "80c1c121-570a-45a1-d5be-9d9d084d4ab6"
      },
      "source": [
        "output = predict(\"딥 러닝 자연어 처리를 잘 하고 싶어\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Input: 딥 러닝 자연어 처리를 잘 하고 싶어\n",
            "Output: 다른 사람들이 원하는 내가 되는 건 어려워요 .\n"
          ]
        }
      ]
    }
  ]
}