[E-12]Chatbot.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "ea139045",
   "metadata": {},
   "source": [
    "# 한국어 데이터로 챗봇 만들기"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 240,
   "id": "d314415f",
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "import tensorflow_datasets as tfds\n",
    "import os\n",
    "import re\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2f59f10d",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "30c09e27",
   "metadata": {},
   "source": [
    "# 데이터 수집 & 전처리\n",
    "\n",
    "(송영숙님이 공개한 챗봇 데이터를 사용합니다)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 241,
   "id": "4d0cc73b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50000\n"
     ]
    }
   ],
   "source": [
    "# 사용할 샘플의 최대 개수\n",
    "MAX_SAMPLES = 50000\n",
    "print(MAX_SAMPLES)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 242,
   "id": "1229f27e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 전처리 함수\n",
    "def preprocess_sentence(sentence):\n",
    "    sentence = sentence.lower().strip()\n",
    "\n",
    "    # 단어와 구두점(punctuation) 사이의 거리를 만듭니다.\n",
    "    # 예를 들어서 \"I am a student.\" => \"I am a student .\"와 같이\n",
    "    # student와 온점 사이에 거리를 만듭니다.\n",
    "    sentence = re.sub(r\"([?.!,])\", r\" \\1 \", sentence)\n",
    "    sentence = re.sub(r'[\" \"]+', \" \", sentence)\n",
    "\n",
    "    # (ㄱ-ㅎ, 가-힣, \".\", \"?\", \"!\", \",\")를 제외한 모든 문자를 공백인 ' '로 대체합니다.\n",
    "    sentence = re.sub(r\"[^a-zA-Zㄱ-ㅎ가-힣?.!,]+\", \" \", sentence)\n",
    "    sentence = sentence.strip()\n",
    "    return sentence"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 243,
   "id": "8e67b725",
   "metadata": {},
   "outputs": [],
   "source": [
    "filepath = os.path.join(os.getenv(\"HOME\"), 'aiffel/transformer_chatbot/data', 'ChatbotData .csv')\n",
    "data = pd.read_csv(filepath)\n",
    "\n",
    "questions, answers = [], []\n",
    "for q, a in zip(data['Q'], data['A']):\n",
    "    questions.append(preprocess_sentence(q))\n",
    "    answers.append(preprocess_sentence(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 244,
   "id": "87861daf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "전처리 후의 22번째 질문 샘플: 가스비 장난 아님\n",
      "전처리 후의 22번째 답변 샘플: 가장 확실한 시간은 오늘이에요 . 어제와 내일을 놓고 고민하느라 시간을 낭비하지 마세요 .\n"
     ]
    }
   ],
   "source": [
    "print('전처리 후의 22번째 질문 샘플: {}'.format(questions[21]))\n",
    "print('전처리 후의 22번째 답변 샘플: {}'.format(answers[22]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 245,
   "id": "4efb4bf3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11823"
      ]
     },
     "execution_count": 245,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(questions)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0280abac",
   "metadata": {},
   "source": [
    "### 문장 분석"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 246,
   "id": "a114341f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "텍스트의 최소 길이 : 1\n",
      "텍스트의 최대 길이 : 57\n",
      "텍스트의 평균 길이 : 13.177619893428064\n",
      "요약의 최소 길이 : 1\n",
      "요약의 최대 길이 : 78\n",
      "요약의 평균 길이 : 16.03129493360399\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "question_len = [len(s) for s in questions]\n",
    "answer_len = [len(s) for s in answers]\n",
    "\n",
    "print('텍스트의 최소 길이 : {}'.format(np.min(question_len)))\n",
    "print('텍스트의 최대 길이 : {}'.format(np.max(question_len)))\n",
    "print('텍스트의 평균 길이 : {}'.format(np.mean(question_len)))\n",
    "print('요약의 최소 길이 : {}'.format(np.min(answer_len)))\n",
    "print('요약의 최대 길이 : {}'.format(np.max(answer_len)))\n",
    "print('요약의 평균 길이 : {}'.format(np.mean(answer_len)))\n",
    "\n",
    "plt.subplot(1,2,1)\n",
    "plt.boxplot(question_len)\n",
    "plt.title('Questions')\n",
    "\n",
    "plt.subplot(1,2,2)\n",
    "plt.boxplot(answer_len)\n",
    "plt.title('Answers')\n",
    "plt.tight_layout()\n",
    "plt.show()\n",
    "\n",
    "plt.title('Questions')\n",
    "plt.hist(question_len, bins = 40)\n",
    "plt.xlabel('length of samples')\n",
    "plt.ylabel('number of samples')\n",
    "plt.show()\n",
    "\n",
    "plt.title('Answers')\n",
    "plt.hist(answer_len, bins = 40)\n",
    "plt.xlabel('length of samples')\n",
    "plt.ylabel('number of samples')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5c2d7bd2",
   "metadata": {},
   "source": [
    "##### 한국어에 맞는 최대길이를 찾기 위해 데이터를 확인했습니다.\n",
    "\n",
    "- Question\n",
    "    - 평균 13\n",
    "    - 최대 57\n",
    "- Answer\n",
    "    - 평균 16\n",
    "    - 최대 78\n",
    "\n",
    "각 데이터는 위와 같았습니다.\n",
    "\n",
    "Question과 Answer이 한 쌍으로 무조건 같이 들어가기 때문에\n",
    "\n",
    "적절한 수준에서 최대길이를 설정하는 것이 좋을 거라 판단했고, 특정 길이일 때 샘플의 비율을 확인했습니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 247,
   "id": "fe8d90dd",
   "metadata": {},
   "outputs": [],
   "source": [
    "def below_threshold_len(max_len, data_list):\n",
    "    cnt = 0\n",
    "    for s in data_list:\n",
    "        if(len(s) <= max_len):\n",
    "            cnt = cnt + 1\n",
    "    print('전체 샘플 중 길이가 %s 이하인 샘플의 비율: %s'%(max_len, (cnt / len(data_list))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 248,
   "id": "08c645e5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "전체 샘플 중 길이가 30 이하인 샘플의 비율: 0.9822380106571936\n",
      "전체 샘플 중 길이가 30 이하인 샘플의 비율: 0.9625306605768418\n"
     ]
    }
   ],
   "source": [
    "questions_max_len = 30\n",
    "answers_max_len = 30\n",
    "\n",
    "below_threshold_len(questions_max_len, questions)\n",
    "below_threshold_len(answers_max_len,  answers)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b8e2970d",
   "metadata": {},
   "source": [
    "#### 위 그래프와 샘플 비율을 통해 max_len을 30으로 설정했습니다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1e93668c",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "# SubwordTextEncoder 사용"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 249,
   "id": "9bed8c79",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 질문과 답변 데이터셋에 대해서 Vocabulary 생성. (Tensorflow 2.3.0 이상) (클라우드는 2.4 입니다)\n",
    "tokenizer = tfds.deprecated.text.SubwordTextEncoder.build_from_corpus(questions + answers, target_vocab_size=2**13)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 250,
   "id": "2b4d916d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 시작 토큰과 종료 토큰에 고유한 정수를 부여합니다.\n",
    "START_TOKEN, END_TOKEN = [tokenizer.vocab_size], [tokenizer.vocab_size + 1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 251,
   "id": "4f8643f2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "START_TOKEN의 번호 : [8135]\n",
      "END_TOKEN의 번호 : [8136]\n"
     ]
    }
   ],
   "source": [
    "print('START_TOKEN의 번호 :' ,[tokenizer.vocab_size])\n",
    "print('END_TOKEN의 번호 :' ,[tokenizer.vocab_size + 1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 252,
   "id": "e363c1e2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8137\n"
     ]
    }
   ],
   "source": [
    "# 시작 토큰과 종료 토큰을 고려하여 +2를 하여 단어장의 크기를 산정합니다.\n",
    "VOCAB_SIZE = tokenizer.vocab_size + 2\n",
    "print(VOCAB_SIZE)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "48e3ca4c",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "# 정수 인코딩 & 패딩"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 253,
   "id": "24383205",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "30\n"
     ]
    }
   ],
   "source": [
    "# 샘플의 최대 허용 길이 또는 패딩 후의 최종 길이\n",
    "MAX_LENGTH = 30\n",
    "print(MAX_LENGTH)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 254,
   "id": "1523d2a9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "가스비 장난 아님\n",
      "정수 인코딩 후의 21번째 질문 샘플: [5744, 610, 2485, 4149]\n",
      "다음 달에는 더 절약해봐요 .\n",
      "정수 인코딩 후의 21번째 답변 샘플: [2353, 7486, 7, 6252, 97, 1]\n"
     ]
    }
   ],
   "source": [
    "# 임의의 22번째 샘플에 대해서 정수 인코딩 작업을 수행.\n",
    "# 각 토큰을 고유한 정수로 변환\n",
    "print(questions[21])\n",
    "print('정수 인코딩 후의 21번째 질문 샘플: {}'.format(tokenizer.encode(questions[21])))\n",
    "print(answers[21])\n",
    "print('정수 인코딩 후의 21번째 답변 샘플: {}'.format(tokenizer.encode(answers[21])))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 255,
   "id": "6d0d16ca",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정수 인코딩, 최대 길이를 초과하는 샘플 제거, 패딩\n",
    "def tokenize_and_filter(inputs, outputs):\n",
    "    tokenized_inputs, tokenized_outputs = [], []\n",
    "  \n",
    "    for (sentence1, sentence2) in zip(inputs, outputs):\n",
    "        # 정수 인코딩 과정에서 시작 토큰과 종료 토큰을 추가\n",
    "        sentence1 = START_TOKEN + tokenizer.encode(sentence1) + END_TOKEN\n",
    "        sentence2 = START_TOKEN + tokenizer.encode(sentence2) + END_TOKEN\n",
    "        \n",
    "        # 최대 길이 25 이하인 경우에만 데이터셋으로 허용\n",
    "        if len(sentence1) <= MAX_LENGTH and len(sentence2) <= MAX_LENGTH:\n",
    "            tokenized_inputs.append(sentence1)\n",
    "            tokenized_outputs.append(sentence2)\n",
    "            \n",
    "    # 최대 길이 325으로 모든 데이터셋을 패딩\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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 256,
   "id": "5f79328c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "단어장의 크기 : 8137\n",
      "필터링 후의 질문 샘플 개수: 11822\n",
      "필터링 후의 답변 샘플 개수: 11822\n"
     ]
    }
   ],
   "source": [
    "questions, answers = tokenize_and_filter(questions, answers)\n",
    "print('단어장의 크기 :',(VOCAB_SIZE))\n",
    "print('필터링 후의 질문 샘플 개수: {}'.format(len(questions)))\n",
    "print('필터링 후의 답변 샘플 개수: {}'.format(len(answers)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 257,
   "id": "f83f4e5d",
   "metadata": {},
   "outputs": [],
   "source": [
    "BATCH_SIZE = 64\n",
    "BUFFER_SIZE = 20000\n",
    "\n",
    "# 디코더는 이전의 target을 다음의 input으로 사용합니다.\n",
    "# 이에 따라 outputs에서는 START_TOKEN을 제거하겠습니다.\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",
    "dataset = dataset.cache()\n",
    "dataset = dataset.shuffle(BUFFER_SIZE)\n",
    "dataset = dataset.batch(BATCH_SIZE)\n",
    "dataset = dataset.prefetch(tf.data.experimental.AUTOTUNE)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d830e846",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "# 모델 구성\n",
    "\n",
    "### PositionalEncoding"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 258,
   "id": "70106f92",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 포지셔널 인코딩 레이어\n",
    "class PositionalEncoding(tf.keras.layers.Layer):\n",
    "\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",
    "        # 각도 배열 생성\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",
    "        # 배열의 짝수 인덱스에는 sin 함수 적용\n",
    "        sines = tf.math.sin(angle_rads[:, 0::2])\n",
    "        # 배열의 홀수 인덱스에는 cosine 함수 적용\n",
    "        cosines = tf.math.cos(angle_rads[:, 1::2])\n",
    "\n",
    "        # sin과 cosine이 교차되도록 재배열\n",
    "        pos_encoding = tf.stack([sines, cosines], axis=0)\n",
    "        pos_encoding = tf.transpose(pos_encoding,[1, 2, 0]) \n",
    "        pos_encoding = tf.reshape(pos_encoding, [position, d_model])\n",
    "\n",
    "        pos_encoding = pos_encoding[tf.newaxis, ...]\n",
    "        return tf.cast(pos_encoding, tf.float32)\n",
    "\n",
    "    def call(self, inputs):\n",
    "        return inputs + self.pos_encoding[:, :tf.shape(inputs)[1], :]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4d748fd5",
   "metadata": {},
   "source": [
    "### Scaled dot project attention"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 259,
   "id": "f08517d3",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 스케일드 닷 프로덕트 어텐션 함수\n",
    "def scaled_dot_product_attention(query, key, value, mask):\n",
    "    # 어텐션 가중치는 Q와 K의 닷 프로덕트 (q와 k의 내적))\n",
    "    matmul_qk = tf.matmul(query, key, transpose_b=True)\n",
    "\n",
    "    # 가중치를 정규화\n",
    "    depth = tf.cast(tf.shape(key)[-1], tf.float32)\n",
    "    logits = matmul_qk / tf.math.sqrt(depth)\n",
    "\n",
    "    # 패딩에 마스크 추가\n",
    "    if mask is not None:\n",
    "        logits += (mask * -1e9)\n",
    "\n",
    "    # softmax적용\n",
    "    attention_weights = tf.nn.softmax(logits, axis=-1)\n",
    "\n",
    "    # 최종 어텐션은 가중치와 V의 닷 프로덕트\n",
    "    output = tf.matmul(attention_weights, value)\n",
    "    return output"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "34be9d09",
   "metadata": {},
   "source": [
    "### MultiHeadAttention"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 260,
   "id": "ab2e466b",
   "metadata": {},
   "outputs": [],
   "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 # ex: 8\n",
    "        self.d_model = d_model # ex: 512\n",
    "        \n",
    "        assert d_model % self.num_heads == 0\n",
    "        \n",
    "        self.depth = d_model // self.num_heads # ex: 64\n",
    "        \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",
    "        self.dense = tf.keras.layers.Dense(units=d_model)\n",
    "        \n",
    "    def split_heads(self, inputs, batch_size):\n",
    "        inputs = tf.reshape(\n",
    "            inputs, shape=(batch_size, -1, self.num_heads, self.depth)) # reshape의 -1은 행렬 크기에 맞춰서 추론되어 자동 결정됨 \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['value'], inputs['mask']\n",
    "        batch_size = tf.shape(query)[0]\n",
    "        \n",
    "        # Q, K, V에 각각 Dense를 적용합니다\n",
    "        query = self.query_dense(query)\n",
    "        key = self.key_dense(key)\n",
    "        value = self.value_dense(value)\n",
    "        \n",
    "        # 병렬 연산을 위한 머리를 여러 개 만듭니다\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",
    "\n",
    "        # 스케일드 닷 프로덕트 어텐션 함수\n",
    "        scaled_attention = scaled_dot_product_attention(query, key, value, mask)\n",
    "\n",
    "        scaled_attention = tf.transpose(scaled_attention, perm=[0, 2, 1, 3])\n",
    "\n",
    "        # 어텐션 연산 후에 각 결과를 다시 연결(concatenate)합니다\n",
    "        concat_attention = tf.reshape(scaled_attention,\n",
    "                                  (batch_size, -1, self.d_model))\n",
    "\n",
    "        # 최종 결과에도 Dense를 한 번 더 적용합니다\n",
    "        outputs = self.dense(concat_attention)\n",
    "        \n",
    "        return outputs"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8b0ac13b",
   "metadata": {},
   "source": [
    "### Padding Mask"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 261,
   "id": "bf11dae4",
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_padding_mask(x):\n",
    "    mask = tf.cast(tf.math.equal(x, 0), tf.float32)\n",
    "    # (batch_size, 1, 1, sequence length)\n",
    "    return mask[:, tf.newaxis, tf.newaxis, :]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0b86600c",
   "metadata": {},
   "source": [
    "### Look-ahead Mask"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 262,
   "id": "23c1414c",
   "metadata": {},
   "outputs": [],
   "source": [
    "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) # padding_mask에서 원 값이 0인 경우 1로 설정하기 때문에 -> 1 값을 골라는 것임"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "411f257a",
   "metadata": {},
   "source": [
    "### 인코더 레이어"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 263,
   "id": "66422477",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 인코더 하나의 레이어를 함수로 구현.\n",
    "# 이 하나의 레이어 안에는 두 개의 서브 레이어가 존재합니다.\n",
    "def encoder_layer(units, 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,\n",
    "          'key': inputs,\n",
    "          'value': inputs,\n",
    "          'mask': padding_mask\n",
    "      })\n",
    "\n",
    "    # 어텐션의 결과는 Dropout과 Layer Normalization이라는 훈련을 돕는 테크닉을 수행\n",
    "    attention = tf.keras.layers.Dropout(rate=dropout)(attention)\n",
    "    attention = tf.keras.layers.LayerNormalization(\n",
    "      epsilon=1e-6)(inputs + attention)\n",
    "\n",
    "    # 두 번째 서브 레이어 : 2개의 완전연결층\n",
    "    outputs = tf.keras.layers.Dense(units=units, activation='relu')(attention)\n",
    "    outputs = tf.keras.layers.Dense(units=d_model)(outputs)\n",
    "\n",
    "    # 완전연결층의 결과는 Dropout과 LayerNormalization이라는 훈련을 돕는 테크닉을 수행\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)\n",
    "\n",
    "\n",
    "def encoder(vocab_size,\n",
    "            num_layers,\n",
    "            units,\n",
    "            d_model,\n",
    "            num_heads,\n",
    "            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",
    "\n",
    "    # 포지셔널 인코딩\n",
    "    embeddings = PositionalEncoding(vocab_size, d_model)(embeddings)\n",
    "    \n",
    "    outputs = tf.keras.layers.Dropout(rate=dropout)(embeddings)\n",
    "    \n",
    "    # num_layers만큼 쌓아올린 인코더의 층.\n",
    "    for i in range(num_layers):\n",
    "        outputs = encoder_layer(\n",
    "            units=units,\n",
    "            d_model=d_model,\n",
    "            num_heads=num_heads,\n",
    "            dropout=dropout,\n",
    "            name=\"encoder_layer_{}\".format(i),\n",
    "        )([outputs, padding_mask])\n",
    "\n",
    "    return tf.keras.Model(\n",
    "      inputs=[inputs, padding_mask], outputs=outputs, name=name)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a2a49c3f",
   "metadata": {},
   "source": [
    "### 디코더 레이어"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 264,
   "id": "bd934a32",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 디코더 하나의 레이어를 함수로 구현.\n",
    "# 이 하나의 레이어 안에는 세 개의 서브 레이어가 존재합니다.\n",
    "def decoder_layer(units, 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",
    "    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,\n",
    "          'key': inputs,\n",
    "          'value': inputs,\n",
    "          'mask': look_ahead_mask\n",
    "      })\n",
    "\n",
    "    # 멀티 헤드 어텐션의 결과는 LayerNormalization이라는 훈련을 돕는 테크닉을 수행\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,\n",
    "          'key': enc_outputs,\n",
    "          'value': enc_outputs,\n",
    "          'mask': padding_mask\n",
    "      })\n",
    "\n",
    "    # 마스크드 멀티 헤드 어텐션의 결과는\n",
    "    # Dropout과 LayerNormalization이라는 훈련을 돕는 테크닉을 수행\n",
    "    attention2 = tf.keras.layers.Dropout(rate=dropout)(attention2)\n",
    "    attention2 = tf.keras.layers.LayerNormalization(\n",
    "      epsilon=1e-6)(attention2 + attention1)\n",
    "\n",
    "    # 세 번째 서브 레이어 : 2개의 완전연결층\n",
    "    outputs = tf.keras.layers.Dense(units=units, activation='relu')(attention2)\n",
    "    outputs = tf.keras.layers.Dense(units=d_model)(outputs)\n",
    "\n",
    "    # 완전연결층의 결과는 Dropout과 LayerNormalization 수행\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)\n",
    "\n",
    "\n",
    "def decoder(vocab_size,\n",
    "            num_layers,\n",
    "            units,\n",
    "            d_model,\n",
    "            num_heads,\n",
    "            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",
    "    look_ahead_mask = tf.keras.Input(\n",
    "      shape=(1, None, None), name='look_ahead_mask')\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",
    "\n",
    "    # 포지셔널 인코딩\n",
    "    embeddings = PositionalEncoding(vocab_size, d_model)(embeddings)\n",
    "\n",
    "    # Dropout이라는 훈련을 돕는 테크닉을 수행\n",
    "    outputs = tf.keras.layers.Dropout(rate=dropout)(embeddings)\n",
    "\n",
    "    for i in range(num_layers):\n",
    "        outputs = decoder_layer(\n",
    "            units=units,\n",
    "            d_model=d_model,\n",
    "            num_heads=num_heads,\n",
    "            dropout=dropout,\n",
    "            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)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 265,
   "id": "770cadb7",
   "metadata": {},
   "outputs": [],
   "source": [
    "def transformer(vocab_size,\n",
    "                num_layers,\n",
    "                units,\n",
    "                d_model,\n",
    "                num_heads,\n",
    "                dropout,\n",
    "                name=\"transformer\"):\n",
    "    inputs = tf.keras.Input(shape=(None,), name=\"inputs\")\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",
    "    # 내부적으로 패딩 마스크도 포함되어져 있습니다.\n",
    "    look_ahead_mask = tf.keras.layers.Lambda(\n",
    "        create_look_ahead_mask,\n",
    "        output_shape=(1, None, None),\n",
    "        name='look_ahead_mask')(dec_inputs)\n",
    "    \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) # 두번째 어텐션 블록에서 인코더-디코더 어텐션을 하기 때문에 인코더에 들어가는 inputs기준 패딩 마스크\n",
    "\n",
    "    # 인코더\n",
    "    enc_outputs = encoder(\n",
    "        vocab_size=vocab_size,\n",
    "        num_layers=num_layers,\n",
    "        units=units,\n",
    "        d_model=d_model,\n",
    "        num_heads=num_heads,\n",
    "        dropout=dropout,\n",
    "    )(inputs=[inputs, enc_padding_mask])\n",
    "\n",
    "    # 디코더\n",
    "    dec_outputs = decoder(\n",
    "        vocab_size=vocab_size,\n",
    "        num_layers=num_layers,\n",
    "        units=units,\n",
    "        d_model=d_model,\n",
    "        num_heads=num_heads,\n",
    "        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)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "72acb93d",
   "metadata": {},
   "source": [
    "### 손실 함수"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 266,
   "id": "8cbf657f",
   "metadata": {},
   "outputs": [],
   "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)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "42ace2d2",
   "metadata": {},
   "source": [
    "### 커스텀 된 학습률"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 267,
   "id": "02944289",
   "metadata": {},
   "outputs": [],
   "source": [
    "class CustomSchedule(tf.keras.optimizers.schedules.LearningRateSchedule):\n",
    "\n",
    "    def __init__(self, d_model, warmup_steps=4000):\n",
    "        super(CustomSchedule, self).__init__()\n",
    "\n",
    "        self.d_model = d_model\n",
    "        self.d_model = tf.cast(self.d_model, tf.float32)\n",
    "\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)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "151f2e8a",
   "metadata": {},
   "source": [
    "### 모델 생성"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 268,
   "id": "a03aa868",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"transformer\"\n",
      "__________________________________________________________________________________________________\n",
      "Layer (type)                    Output Shape         Param #     Connected to                     \n",
      "==================================================================================================\n",
      "inputs (InputLayer)             [(None, None)]       0                                            \n",
      "__________________________________________________________________________________________________\n",
      "dec_inputs (InputLayer)         [(None, None)]       0                                            \n",
      "__________________________________________________________________________________________________\n",
      "enc_padding_mask (Lambda)       (None, 1, 1, None)   0           inputs[0][0]                     \n",
      "__________________________________________________________________________________________________\n",
      "encoder (Functional)            (None, None, 256)    3137280     inputs[0][0]                     \n",
      "                                                                 enc_padding_mask[0][0]           \n",
      "__________________________________________________________________________________________________\n",
      "look_ahead_mask (Lambda)        (None, 1, None, None 0           dec_inputs[0][0]                 \n",
      "__________________________________________________________________________________________________\n",
      "dec_padding_mask (Lambda)       (None, 1, 1, None)   0           inputs[0][0]                     \n",
      "__________________________________________________________________________________________________\n",
      "decoder (Functional)            (None, None, 256)    3664640     dec_inputs[0][0]                 \n",
      "                                                                 encoder[0][0]                    \n",
      "                                                                 look_ahead_mask[0][0]            \n",
      "                                                                 dec_padding_mask[0][0]           \n",
      "__________________________________________________________________________________________________\n",
      "outputs (Dense)                 (None, None, 8137)   2091209     decoder[0][0]                    \n",
      "==================================================================================================\n",
      "Total params: 8,893,129\n",
      "Trainable params: 8,893,129\n",
      "Non-trainable params: 0\n",
      "__________________________________________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "tf.keras.backend.clear_session()\n",
    "\n",
    "# 하이퍼파라미터\n",
    "NUM_LAYERS = 2 # 인코더와 디코더의 층의 개수\n",
    "D_MODEL = 256 # 인코더와 디코더 내부의 입, 출력의 고정 차원\n",
    "NUM_HEADS = 8 # 멀티 헤드 어텐션에서의 헤드 수 \n",
    "UNITS = 512 # 피드 포워드 신경망의 은닉층의 크기\n",
    "DROPOUT = 0.1 # 드롭아웃의 비율\n",
    "\n",
    "model = transformer(\n",
    "    vocab_size=VOCAB_SIZE,\n",
    "    num_layers=NUM_LAYERS,\n",
    "    units=UNITS,\n",
    "    d_model=D_MODEL,\n",
    "    num_heads=NUM_HEADS,\n",
    "    dropout=DROPOUT)\n",
    "\n",
    "model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 294,
   "id": "3e791901",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 294,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tf.keras.utils.plot_model(model, 'model.png', show_shapes=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b45b90f8",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "# 모델 훈련"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 269,
   "id": "ff050ef3",
   "metadata": {},
   "outputs": [],
   "source": [
    "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",
    "    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])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 270,
   "id": "de27e2be",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/20\n",
      "185/185 [==============================] - 13s 44ms/step - loss: 1.9552 - accuracy: 0.0267\n",
      "Epoch 2/20\n",
      "185/185 [==============================] - 8s 44ms/step - loss: 1.5866 - accuracy: 0.0641\n",
      "Epoch 3/20\n",
      "185/185 [==============================] - 8s 44ms/step - loss: 1.3547 - accuracy: 0.0679\n",
      "Epoch 4/20\n",
      "185/185 [==============================] - 8s 44ms/step - loss: 1.2493 - accuracy: 0.0726\n",
      "Epoch 5/20\n",
      "185/185 [==============================] - 8s 44ms/step - loss: 1.1685 - accuracy: 0.0776\n",
      "Epoch 6/20\n",
      "185/185 [==============================] - 8s 44ms/step - loss: 1.0870 - accuracy: 0.0832\n",
      "Epoch 7/20\n",
      "185/185 [==============================] - 8s 44ms/step - loss: 0.9970 - accuracy: 0.0913\n",
      "Epoch 8/20\n",
      "185/185 [==============================] - 8s 44ms/step - loss: 0.8981 - accuracy: 0.1021\n",
      "Epoch 9/20\n",
      "185/185 [==============================] - 8s 44ms/step - loss: 0.7919 - accuracy: 0.1135\n",
      "Epoch 10/20\n",
      "185/185 [==============================] - 8s 44ms/step - loss: 0.6804 - accuracy: 0.1265\n",
      "Epoch 11/20\n",
      "185/185 [==============================] - 8s 44ms/step - loss: 0.5697 - accuracy: 0.1398\n",
      "Epoch 12/20\n",
      "185/185 [==============================] - 8s 44ms/step - loss: 0.4629 - accuracy: 0.1547\n",
      "Epoch 13/20\n",
      "185/185 [==============================] - 8s 44ms/step - loss: 0.3640 - accuracy: 0.1689\n",
      "Epoch 14/20\n",
      "185/185 [==============================] - 8s 44ms/step - loss: 0.2759 - accuracy: 0.1829\n",
      "Epoch 15/20\n",
      "185/185 [==============================] - 8s 45ms/step - loss: 0.2052 - accuracy: 0.1948\n",
      "Epoch 16/20\n",
      "185/185 [==============================] - 8s 45ms/step - loss: 0.1490 - accuracy: 0.2053\n",
      "Epoch 17/20\n",
      "185/185 [==============================] - 8s 44ms/step - loss: 0.1086 - accuracy: 0.2126\n",
      "Epoch 18/20\n",
      "185/185 [==============================] - 8s 45ms/step - loss: 0.0841 - accuracy: 0.2170\n",
      "Epoch 19/20\n",
      "185/185 [==============================] - 8s 44ms/step - loss: 0.0699 - accuracy: 0.2195\n",
      "Epoch 20/20\n",
      "185/185 [==============================] - 8s 45ms/step - loss: 0.0626 - accuracy: 0.2206\n"
     ]
    }
   ],
   "source": [
    "EPOCHS = 20\n",
    "history = model.fit(dataset, epochs=EPOCHS, verbose=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 271,
   "id": "faf5ed66",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAzgAAAE/CAYAAACKFmYTAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAABTIklEQVR4nO3dd3hUddrG8e9DIFTpvSNFBQslNPtaEEXFLoiCoiJrW+ta1rWgu+q6u+raURFRFBsiKrbXXugdlC4CAST0XpI87x/nZHeMCQRIcmYm9+e65srMKZN7hoEfz5zfeY65OyIiIiIiIsmgVNQBRERERERECosKHBERERERSRoqcEREREREJGmowBERERERkaShAkdERERERJKGChwREREREUkaKnBERERERCRpqMARKQAzW2xmJ0WdQ0RESgYz+8rM1plZ2aiziCQaFTgiIiIiccTMmgLHAA6cWYy/t3Rx/S6RoqQCR2QfmVlZM3vMzJaHt8dyvmkzs5pm9oGZrTeztWb2rZmVCtfdZmbpZrbJzOaa2YnRvhIREYkzfYFxwFCgX85CM2tkZiPNLMPM1pjZkzHrrjSzn8Kx5Uczax8udzNrEbPdUDN7ILx/vJktC8ellcBLZlYtHL8ywiNIH5hZw5j9q5vZS+G4t87MRoXLZ5nZGTHblTGz1WbWrqjeJJH8qMAR2Xd/AboAbYEjgE7AXeG6m4FlQC2gDnAn4GZ2EHAt0NHdDwBOARYXa2oREYl3fYHh4e0UM6tjZinAB8AvQFOgATACwMzOB+4N96tMcNRnTQF/V12gOtAEGEDwf8OXwseNgW3AkzHbvwJUANoAtYFHw+XDgItjtjsNWOHuUwuYQ6TQ6FCkyL7rA1zn7qsAzOw+4Dngr8AuoB7QxN0XAN+G22QBZYHWZpbh7oujCC4iIvHJzI4mKC7edPfVZrYQuIjgiE594FZ3zww3/y78eQXwD3efGD5esBe/Mhu4x913hI+3Ae/E5Pkb8GV4vx5wKlDD3deFm3wd/nwV+KuZVXb3jcAlBMWQSLHTERyRfVef4Ju0HL+EywAeIRhgPjWzRWZ2O0BY7NxA8E3bKjMbYWb1ERERCfQDPnX31eHj18JljYBfYoqbWI2Ahfv4+zLcfXvOAzOrYGbPmdkvZrYR+AaoGh5BagSsjSlu/svdlwPfA+eaWVWCQmj4PmYS2S8qcET23XKCb9lyNA6X4e6b3P1mdz+QYKrATTnn2rj7a+6e8w2dAw8Xb2wREYlHZlYeuAA4zsxWhufF3EgwDfpXoHE+jQCWAs3zedqtBFPKctTNtd5zPb4ZOAjo7O6VgWNz4oW/p3pYwOTlZYJpaucDY909PZ/tRIqUChyRgitjZuVybsDrwF1mVsvMagJ3Exyix8xON7MWZmbABiALyDazg8zshLAZwXaCqQDZ0bwcERGJM2cRjBetCc7vbAscQjDN+SxgBfCQmVUMx6Kjwv1eAG4xsw4WaGFmOV/ATQMuMrMUM+sOHLeHDAcQjE3rzaw6cE/OCndfAXwEPB02IyhjZsfG7DsKaA/8ieCcHJFIqMARKbgxBP/o59zKAZOAGcBMYArwQLhtS+D/gM3AWOBpd/+S4Pybh4DVwEqCEzTvKL6XICIicawf8JK7L3H3lTk3gpP8ewNnAC2AJQSNbC4EcPe3gL8RTGfbRFBoVA+f80/hfusJzh0dtYcMjwHlCcapccDHudZfQnCe6RxgFcG0a8IcOefvNANGFvxlixQuc899ZFJEREREZO+Z2d1AK3e/eI8bixQRdVETERERkf0WTmm7nOAoj0hkNEVNRERERPaLmV1J0ITgI3f/Juo8UrJpipqIiIiIiCQNHcEREREREZGkoQJHRERERESSRlw2GahZs6Y3bdo06hgiIiXa5MmTV7t7rahzxCONUyIi0ctvnIrLAqdp06ZMmjQp6hgiIiWamf0SdYZ4pXFKRCR6+Y1TmqImIiIiIiJJY48Fjpk1MrMvzexHM5ttZn/KYxszs/+Y2QIzm2Fm7WPW9TOz+eGtX2G/ABERKTnMrLuZzQ3Hm9vzWH9TOF7NMLPPzaxJuLytmY0Nx7EZZnZhzD5DzexnM5sW3toW40sSEZFCVpApapnAze4+xcwOACab2Wfu/mPMNqcCLcNbZ+AZoHN4wad7gDTAw31Hu/u6Qn0VIiKS9MwsBXgKOBlYBkwMx5TY8WgqkObuW83sj8A/gAuBrUBfd59vZvUJxqNP3H19uN+t7v52sb0YEREpMns8guPuK9x9Snh/E/AT0CDXZj2BYR4YB1Q1s3rAKcBn7r42LGo+A7oX6isQEZGSohOwwN0XuftOYATB+PNf7v6lu28NH44DGobL57n7/PD+cmAVoAYKIiJJaK/OwTGzpkA7YHyuVQ0Irl6bY1m4LL/lIiIie2tvx5TLgY9yLzSzTkAqsDBm8d/CqWuPmlnZwggrIiLRKHCBY2aVgHeAG9x9Y2EHMbMBZjbJzCZlZGQU9tOLiEgJYmYXE0yPfiTX8nrAK8Bl7p4dLr4DOBjoCFQHbsvnOTVOiYgkgAIVOGZWhqC4Ge7uI/PYJB1oFPO4Ybgsv+W/4+6D3T3N3dNq1dKsARER+Z0CjSlmdhLwF+BMd98Rs7wy8CHwl3A6NfDfqdgebvsSwVS439E4JSKSGArSRc2AF4Gf3P3f+Ww2GugbdlPrAmxw9xXAJ0A3M6tmZtWAbuEyERGRvTURaGlmzcwsFehFMP78l5m1A54jKG5WxSxPBd4lOF/07Vz71At/GnAWMKsoX4SIiBStgnRROwq4BJhpZtPCZXcCjQHc/VlgDHAasICgU81l4bq1ZnY/waAEMMjd1xZaehERKTHcPdPMriX4oiwFGOLus81sEDDJ3UcTTEmrBLwV1CsscfczgQuAY4EaZnZp+JSXuvs0YLiZ1QIMmAYMLL5XJSIihc3cPeoMv5OWlub7dIXobdvgrbcgLQ1aty78YCIiJYiZTXb3tKhzxKN9HqdEREqg7Gxn0/ZM1mzZwdotO/9769isOs1rVdrn581vnCrIEZzEsWMHXHklXH01PPpo1GlERERERJLOrqzs3xQqa7bsZF34c+2WHazbsos1//25k3Vbd5KV/fuDKn8/+7D9KnDyk1wFTtWq0KMHjBgB//wnpKREnUhEREREJGFt2LqL2Ss28OPyjcxevpHZyzewMGNLngWLGVQtX4bqFVOpXjGVpjUr0L5J1fBxWapXLBP8rJBK9Uqp1KyUWiSZk6vAAbjoInj3XfjySzjppKjTiIiIiIjEPXdn5cbtzE7/XyEze/lG0tdv++82dSqXpU39KnRrXZd6VcsFhUrF/92qVkglpZRF+CoCyVfg9OgBlSvDa6+pwBERERERySUr2/l59RZmL//fkZkfV2xk7ZadQHAkplmNirRrXJWLuzShTf3KtK5fmZqVEuM6yMlX4JQvD+ecA++8A08/DeXKRZ1IRERERCRSS9du5eNZK/nsx1+Zmb6BbbuyAEhNKUWrupU4+ZA6tK5fmTb1K3NIvcpULJu4ZULiJt+dPn1g6FD48EM499yo04iIiIiIFLvFq7fw0ayVfDRrBTOWbQCgTf3KXNixEW3qV6ZN/Sq0qF2J1NJ7vDRmQknOAucPf4C6dWH4cBU4IiIiIlJiLFi1mY9nrWDMzJX8uGIjAEc0qsodpx7MqYfWo3GNChEnLHrJWeCkpECvXsEUtfXrg+5qIiIiIiJJxt2Z9+tmxsxcwUezVjDv180AdGhSjbt6HEL3Q+vSsFryFzWxkrPAgaCb2mOPwciR0L9/1GlERERERAqFu/PTik18NGsFY2auYGHGFsygY9Pq3HtGa7ofWo+6VUrueejJW+CkpUGLFsE0NRU4IiIiIpLgZi/fwAczVvDRzBUsXrOVUgZdDqzBpUc145Q2dah9QMktamIlb4FjFjQbGDQIli+H+vWjTiQiIiIistcWZmzm4Y/m8OmPv1K6lHFki5pcdVxzurWuQ40Ead1cnJK3wIFgmtp998GIEXDTTVGnEREREREpsNWbd/D4/83ntQlLKFe6FDef3IpLujahaoXUqKPFteQucFq1CqaqvfaaChwRERERSQjbdmbx4neLePbrRWzblcVFnRrzp5NaJsyFNqOW3AUOBEdxbroJ5s6Fgw6KOo2IiIiISJ6ysp13pizj35/OY+XG7XRrXYfbTj2Y5rUqRR0toSTXVX3ycuGFwfk4r70WdRIRERERkTx9PS+DHv/5lj+/PYM6Vcrx5lVdGdw3TcXNPkj+Izj168MJJwQFzr33BsWOiIiIiEgc+HH5Rh786Ce+nb+axtUr8ORF7ehxWD1M/2fdZ8lf4EAwTe3yy2HiROjUKeo0IiIiIlLCrdiwjX9+Mo+RU5dRuVwZ/np6ay7u0piypVOijpbwSkaBc+65cPXVwVEcFTgiIiIiEpFN23fxzFcLefG7n3GHK485kGuOb0GVCmWijpY0SkaBU6UK9OgRtIv+178gRZWxiIiIiBSfXVnZvDZ+CY9/Pp+1W3bSs219bul2EI2qV4g6WtIpGQUOBNPURo6EL76Ak0+OOo2IiIiIlBA/Lt/Ida9PYWHGFrocWJ07TzuEwxtWjTpW0io5BU6PHlC5cjBNTQWOiIiIiBSDd6cu446RM6lSvgwv9E3jxENqq4FAEUv+NtE5ypULzsV55x3Yti3qNCIiIiKSxHZmZnPPe7O48Y3pHN6wKu9fdzQnta6j4qYYlJwCB6BPH9i0CT78MOokIiIiIpKkft24nd7Pj+Plsb9wxdHNGH5FZ2ofUC7qWCXGHgscMxtiZqvMbFY+6281s2nhbZaZZZlZ9XDdYjObGa6bVNjh99rxx0Pdurrop4hIgjKz7mY218wWmNnteay/ycx+NLMZZva5mTWJWdfPzOaHt34xyzuEY9UCM/uP6etVEdkP4xetocd/vuOnFRt5onc77jq9NWVSStYxhagV5N0eCnTPb6W7P+Lubd29LXAH8LW7r43Z5A/h+rT9SloYUlKgV6/gCM66dVGnERGRvWBmKcBTwKlAa6C3mbXOtdlUIM3dDwfeBv4R7lsduAfoDHQC7jGzauE+zwBXAi3DW75jnohIftydF7/7mYteGM8B5Uoz6pqjOOOI+lHHKpH2WOC4+zfA2j1tF+oNvL5fiYpanz6wc2fQUU1ERBJJJ2CBuy9y953ACKBn7Abu/qW7bw0fjgMahvdPAT5z97Xuvg74DOhuZvWAyu4+zt0dGAacVQyvRUSSyJYdmVw/Yhr3f/AjJx5cm/euPYpWdQ6IOlaJVWjHy8ysAsG3Xu/ELHbgUzObbGYDCut37ZcOHaBlS01TExFJPA2ApTGPl4XL8nM58NEe9m0Q3i/oc4qI/MaijM2c/fT3fDhjObeechDPXtyByuV00c4oFWab6DOA73NNTzva3dPNrDbwmZnNCY8I/U5YAA0AaNy4cSHG+t0vCo7i3HcfpKdDA41jIiLJxswuBtKA4wrxOYtnnBKRhPHp7JXc/OZ0SqcYL/fvxDEta0UdSSjcLmq9yDU9zd3Tw5+rgHcJphfkyd0Hu3uau6fVqlXEH47evcEd3nijaH+PiIgUpnSgUczjhuGy3zCzk4C/AGe6+4497JvO/6ax5fucUMzjlIjEtaxs55FP5jDglck0q1WR9687WsVNHCmUAsfMqhB8S/ZezLKKZnZAzn2gG5BnJ7Zi16oVpKXB8OFRJxERkYKbCLQ0s2Zmlkrwxdro2A3MrB3wHEFxsypm1SdANzOrFjYX6AZ84u4rgI1m1iXsntaXmLFMRCS3tVt2culLE3jqy4X06tiIN6/qSsNqFaKOJTH2OEXNzF4Hjgdqmtkygi40ZQDc/dlws7OBT919S8yudYB3w26bpYHX3P3jwou+n/r0gRtvhDlz4OCDo04jIiJ74O6ZZnYtQbGSAgxx99lmNgiY5O6jgUeASsBb4fizxN3PdPe1ZnY/QZEEMChmSvXVBB1DyxOcs/MRIiJ5mLlsAwNfnUzGph08dM5h9Oqk6arxyIKmMfElLS3NJ00q4svmrFgBDRvCXXcF5+OIiMhvmNnkuGjxH4eKZZwSkbjyxsQl/PW92dSsmMozF3fgiEZVo45U4uU3TpXcqw7VqwcnnBBMU4vDIk9EREREorcrK5s7Rs7ktndm0rFpNd6/7mgVN3Gu5BY4ABddBAsXwsSJe95WREREREqUzTsy6T90Iq9PWMLA45ozrH9nalQqG3Us2YOSXeCccw6ULatmAyIiIiLyG6s2bafX4LH8sHAND597GLefejAppSzqWFIAJbvAqVIFTj89aBedmRl1GhERERGJA4syNnPuMz+wcNUWnu/bgQs7qplAIinZBQ4E09R+/RW+/DLqJCIiIiISsalL1nHes2PZsiOL1wd04YSD60QdSfaSCpzTTguO5GiamoiIiEiJ9sWcX7no+fFUKluad/54JG3VTCAhqcApVw7OPRdGjoRt26JOIyIiIiIRGDFhCVcOm0yL2pV4549H0qxmxagjyT5SgQPBRT83bYIPPog6iYiIiIgUI3fn8f+bz+0jZ3JUi5qMGNCFWgeoU1oiU4EDcNxxwXVxXnst6iQiIiIiUkwys7K5892ZPPp/8zi3fUNe7JdGxbKlo44l+0kFDkBKCvTqBWPGwLp1UacRERERkSK2bWcWA1+dzOsTlnLNH5rzz/MPp0yK/mucDPSnmKNPH9i5E955J+okIiIiIlKE1m7ZSe/nx/H5nFXc37MNt55yMGa6xk2yUIGTo317aNVK09REREREktjStVs595kf+GnFRp7p04FLujaNOpIUMhU4OcyCozhffQXp6VGnEREREZFCNit9A2c//QNrt+xk+BWd6X5o3agjSRFQgROrd29whxEjok4iIiIiIoXom3kZXPjcWFJTjLcHdiWtafWoI0kRUYETq2VL6NhR09REREREksjIKcvoP3QijapXYOTVR9GyzgFRR5IipAIntz59YMoUmDMn6iQiIiIisp+e/XohN705nY5Nq/PmwK7UrVIu6khSxFTg5HbhhUHb6CeeiDqJiIiIiOyHZ75ayEMfzeH0w+sxtH9HKpcrE3UkKQYqcHKrWxeuugqeew5++inqNCIiIiKyD4aNXczDH8/hzCPq83ivdpQtnRJ1JCkmKnDycu+9ULEi/PnPUScRERERkb309uRl3P3ebE46pA7/uuAIUkrpGjcliQqcvNSqBX/5C3zwAfzf/0WdRkREREQK6KOZK/jz29M5qkUNnryoHWVS9N/dkkZ/4vm5/npo2hRuvhmysqJOIyIiIiJ78OXcVVw/YirtGldj8CVplCujaWklkQqc/JQrBw89BDNmwMsvR51GRERERHZj3KI1DHxlMq3qHMCQSztSsWzpqCNJRFTg7M4FF0CXLsF0tc2bo04jIiIiInmYvnQ9V7w8iUbVKzCsfyeqlFe3tJJMBc7umMGjj8LKlfCPf0SdRkSkxDOz7mY218wWmNnteaw/1symmFmmmZ0Xs/wPZjYt5rbdzM4K1w01s59j1rUtvlckIvtrzsqN9B0ygWoVy/Dq5Z2pUals1JEkYnsscMxsiJmtMrNZ+aw/3sw2xAwMd8es2+1AlBC6dIFeveCf/4Rly6JOIyJSYplZCvAUcCrQGuhtZq1zbbYEuBR4LXahu3/p7m3dvS1wArAV+DRmk1tz1rv7tKJ5BSJS2H5evYWLX5hAuTKleO2KLrqIpwAFO4IzFOi+h22+jRkYBkGBB6LE8OCDkJ0dTFUTEZGodAIWuPsid98JjAB6xm7g7ovdfQaQvZvnOQ/4yN23Fl1UESlq6eu30ef5cWS7M/yKzjSqXiHqSBIn9ljguPs3wNp9eO49DkQJo2lTuOEGGDYMJk+OOo2ISEnVAFga83hZuGxv9QJez7Xsb2Y2w8weNbM857eY2QAzm2RmkzIyMvbh14pIYVm1aTt9nh/Hph2ZDOvfiRa1D4g6ksSRwjoHp6uZTTezj8ysTbissAai+HDHHcH1cW6+GdyjTiMiIvvAzOoBhwGfxCy+AzgY6AhUB27La193H+zuae6eVqtWrSLPKiJ5W791J5e8MIFVm3Yw9LKOHNqgStSRJM4URoEzBWji7kcATwCj9uVJ4v6bsSpV4L774Ouv4b33ok4jIlISpQONYh43DJftjQuAd919V84Cd1/hgR3ASwQzEEQkDm3avot+Qybw85otPN83jQ5NqkcdSeLQfhc47r7R3TeH98cAZcysJns5ECXEN2NXXgmHHAK33go7d0adRkSkpJkItDSzZmaWSjDVbPRePkdvck1PC4/qYGYGnAXk2VRHRKK1bWcWl788iVnLN/L0Re05qkXNqCNJnNrvAsfM6oaDAmbWKXzONRTOQBRfSpeGf/0LFiyAZ56JOo2ISIni7pnAtQTTy34C3nT32WY2yMzOBDCzjma2DDgfeM7MZufsb2ZNCb54+zrXUw83s5nATKAm8ECRvxgR2Ss7M7MZ+OpkJi5ey78vOIKTWteJOpLEsT1e4tXMXgeOB2qGg8Y9QBkAd3+WoBvNH80sE9gG9HJ3BzLNLGcgSgGGuPvsPH5FYuneHbp1C6arXXIJVNehURGR4hLOFBiTa9ndMfcnEswYyGvfxeRxLqi7n1C4KUWkMGVmZfOnEVP5el4GD51zGD3bJu4p3VI89ljguHvvPax/Engyn3W/G4gSnllwTZy2beH++4MLgYqIiIhIocvOdv78zgw+mrWSv57eml6dGkcdSRJAYXVRK1kOOwwuvxyeegrmz486jYiIiEjScXfufX82I6ekc9PJrbj86GZRR5IEoQJnXw0aBGXLwm15dhMVERERkf3wyCdzGTb2FwYceyDXndAi6jiSQFTg7Ku6deH22+Hdd4PW0SIiIiJSKJ7+agFPf7WQizo35o5TDybsZyVSICpw9sdNN0GjRsHFP7Ozo04jIiIikvBeGbuYf3w8l55t63N/z0NV3MheU4GzP8qXhwcfhMmTYfjwqNOIiIiIJLR3py7jr+/N5qRDavPP848gpZSKG9l7KnD2V+/e0LEj3HEHbN0adRoRERGRhPTJ7JXc8tYMjmxegycvak+ZFP03VfaNPjn7q1Qp+Pe/IT09+CkiIiIie+W7+au57rWpHNagCs/3TaNcmZSoI0kCU4FTGI4+Gs49Fx56CFasiDqNiIiISMKY/Mtarhw2iQNrVWToZR2pWHaPl2kU2S0VOIXl4Ydh507461+jTiIiIiKSEGYv38ClL02kbpVyDLu8E1UrpEYdSZKACpzC0rw5XHcdDBkC06dHnUZEREQkri3M2EzfFydwQNnSvHpFZ2ofUC7qSJIkVOAUprvugmrVgrbR7lGnEREREYlLy9Zt5eIXxmMGr17RmQZVy0cdSZKICpzCVK0a3HsvfP45jBkTdRoRERGRuLNq03YufmE8W3ZkMqx/Zw6sVSnqSJJkVOAUtoEDoVUruOUW2LUr6jQiIiIicWP91p1c8sIEVm3awdD+nWhdv3LUkSQJqcApbGXKwCOPwJw5cP31KnJEREREgM07Mun30kR+Xr2F5/um0b5xtagjSZJSgVMUzjgjOILz7LNwyimwenXUiUREREQis31XFle+PIlZ6Rt4qk97jmpRM+pIksRU4BQFs+Aozssvww8/QMeOMGNG1KlEREREit2urGyuGT6FcT+v4d8XHMHJretEHUmSnAqcotS3L3z7bTBNrWtXeOutqBOJiIiIFJusbOemN6fz+ZxVPHDWofRs2yDqSFICqMApah07wqRJ0LYtXHBB0Eo6OzvqVCIiIiJFyt25a9RM3p++nNtPPZg+nZtEHUlKCBU4xaFuXfjiC7j8cvjb36BnT9iwIepUIiIiIkXC3Xnwozm8PmEp1/6hBQOPax51JClBVOAUl7Jl4fnn4ckn4eOPoUsXmDcv6lQiIiIihW7wN4sY/M0i+nVtws3dWkUdR0oYFTjFyQyuuQY++yzorNapE3z0UdSpRERERArNu1OX8eBHczj98Hrcc0YbzCzqSFLCqMCJwvHHB+flNGsGPXrAww+De9SpRERERPbLN/MyuPWtGXQ9sAb/uuAISpVScSPFTwVOVJo0ge+/DxoP3H47XHQRbN0adSoRkbhmZt3NbK6ZLTCz2/NYf6yZTTGzTDM7L9e6LDObFt5GxyxvZmbjw+d8w8xSi+O1iCSbmcs28MdXJ9OidiWe69uBsqVToo4kJZQKnChVqACvvw4PPghvvAFHHw2//BJ1KhGRuGRmKcBTwKlAa6C3mbXOtdkS4FLgtTyeYpu7tw1vZ8Ysfxh41N1bAOuAyws9vEiS+2XNFi4bOoGqFVJ5uX8nKpcrE3UkKcH2WOCY2RAzW2Vms/JZ38fMZpjZTDP7wcyOiFm3OFw+zcwmFWbwpGEWHMH54ANYtAjS0uCbb6JOJSISjzoBC9x9kbvvBEYAPWM3cPfF7j4DKFA/fgtODjgBeDtc9DJwVqElFikBVm/eQb8hE8jMdoZd3ok6lctFHUlKuIIcwRkKdN/N+p+B49z9MOB+YHCu9X8Ivy1L27eIJcRpp8H48VCjBpx4IjzzjM7LERH5rQbA0pjHy8JlBVXOzCaZ2TgzOytcVgNY7+6Ze3pOMxsQ7j8pIyNjL6OLJKctOzLpP3QiKzdu58V+HWleq1LUkUT2XOC4+zfA2t2s/8Hd14UPxwENCylbyXPQQUGRc8opcPXVcNVVsGNH1KlERJJFk/DLtouAx8xsry7M4e6D3T3N3dNq1apVNAlFEsiurGyuHj6FWekbeLJ3ezo0qRZ1JBGg8M/BuRyI7XvswKdmNtnMBuxuR30zFqpSBd57D+68M7huTtu28PXXUacSEYkH6UCjmMcNw2UF4u7p4c9FwFdAO2ANUNXMSu/Lc4qUVO7Obe/M4Ot5Gfz97MM4qXWdqCOJ/FehFThm9geCAue2mMVHu3t7ghNCrzGzY/PbX9+MxUhJgb/9LbhGzvbtQVvpyy4Lrp0jIlJyTQRahl3PUoFewOg97AOAmVUzs7Lh/ZrAUcCP7u7Al0BOx7V+wHuFnlwkyTzyyVxGTknnxpNa0atT46jjiPxGoRQ4ZnY48ALQ093X5CyP+bZsFfAuwQmiUlDdu8Ps2UETgldfhYMPhpde0rk5IlIihefJXAt8AvwEvOnus81skJmdCWBmHc1sGXA+8JyZzQ53PwSYZGbTCQqah9z9x3DdbcBNZraA4JycF4vvVYkknpd/WMzTXy3kos6Nuf7EFlHHEfmd0nveZPfMrDEwErjE3efFLK8IlHL3TeH9bsCg/f19JU6FCkEb6T59YOBA6N8fhg6FZ5+FQw6JOp2ISLFy9zHAmFzL7o65P5E8zgV19x+Aw/J5zkXoCziRAhkzcwX3vj+bk1vX4f6ehxI0IhSJLwVpE/06MBY4yMyWmdnlZjbQzAaGm9xN8I3X07naQdcBvgu/LZsAfOjuHxfBaygZDj00aB/9/PMwcyYccQTcdRds2xZ1MhERESkBxi1aww0jptG+cTWe6N2OlFIqbiQ+mcfhdKe0tDSfNEmXzcnXqlVwyy3wyitw4IHw9NNB5zURkUJkZpPV4j9vGqekpJmzciPnPzuWOpXL8fbArlStkBp1JJF8x6nC7qImxaF2bRg2DD7/HEqXDs7V6d0bVq6MOpmIiIgkmfT12+g3ZAIVUlN4uX8nFTcS91TgJLITToAZM+Dee2HkyKAJwTPPQHaBLuAtIiIislvrt+6k35AJbN2Zxcv9O9GgavmoI4nskQqcRFe2LNxzT3BeTocOwQVCjzwSpk+POpmIiIgksO27srj85UksWbOVwZekcXDdylFHEikQFTjJolUr+L//C87LWbQoKHZuuQU2b446mYiIiCSYzKxsrnt9KlOWrOPRC9vStXmNqCOJFJgKnGRiBhdfDHPmBO2k//UvaN0aRhfoOngiIiIiuDt3j57NZz/+yj2nt6bH4fWijiSyV1TgJKPq1WHwYPj+e6hSBXr2hHPPhfT0qJOJiIhIHHN37nv/R14bv4Q/Ht+cS49qFnUkkb2mAieZHXkkTJkSXCh0zJjgwqBPPAFZWVEnExERkTiTU9wM/WExlx/djD+fclDUkUT2iQqcZFemDNx+O8yeDV27wvXXBz+nTYs6mYiIiMSJ2OLmiqObcVePQzDThTwlManAKSkOPBA+/hhefx2WLIG0NDUhEBERkd8VN39RcSMJTgVOSWIGvXrBTz/BFVcETQjatIEPPog6mYiIiETA3bl39GyG/rCYK49RcSPJQQVOSVStGjz7LHz3HRxwAJxxBpx/PixfHnUyERERKSY5xc3LY3/hymOacedpKm4kOajAKcmOOipoQvD3vwdHcQ4+GJ56Sk0IREREkpy7c09Y3Aw49kAVN5JUVOCUdKmpcMcdMGsWdOkC114bdF+bPj3qZCIiIlIEcoqbYWFxc8epB6u4kaSiAkcCzZvDJ5/A8OGweDF06AB//jNs2RJ1MhERESkk7s7d7wXFzVUqbiRJqcCR/zGDiy4KmhD07w+PPBI0IRgzJupkIiIisp9yiptXxgXFze0qbiRJqcCR36teHQYPhm+/hYoVoUcPuOQSWL8+6mQiIiKyD9ydv743KyhujlNxI8lNBY7k7+ijYepUuOee4Po5hx8OX3wRdSoRERHZC9nZQXHz6rglQXHTXcWNJDcVOLJ7qalw770wdixUqAAnngg33gjbtkWdTERERPYgtrgZeFxzFTdSIqjAkYLp2DFoKX3ttfDYY0ETgilTok4lIiIi+cgpboaPX8Ifj2/Obd0PUnEjJYIKHCm4ChXgiSfg009h40bo3BkeeAAyM6NOJiIiIjGys527YoqbP5+i4kZKDhU4svdOPhlmzoTzz4e//hWOOQbmz486lYiUAGbW3czmmtkCM7s9j/XHmtkUM8s0s/Nilrc1s7FmNtvMZpjZhTHrhprZz2Y2Lby1LaaXI1Ikcoqb18Yv4WoVN1ICqcCRfVOtGrz2GowYAXPnQtu28Mwz4B51MhFJUmaWAjwFnAq0BnqbWetcmy0BLgVey7V8K9DX3dsA3YHHzKxqzPpb3b1teJtWBPFFikXu4uZWFTdSAqnAkf1z4YXB0Zyjj4arr4bTToPly6NOJSLJqROwwN0XuftOYATQM3YDd1/s7jOA7FzL57n7/PD+cmAVUKt4YosUj+xs546RM1XcSIlXoALHzIaY2Sozm5XPejOz/4RTBmaYWfuYdf3MbH5461dYwSWONGgAH38MTz0FX38Nhx0Gb70VdSoRST4NgKUxj5eFy/aKmXUCUoGFMYv/Fo5fj5pZ2f2LKVL8srKdW96ezhuTlnL9iS1V3EiJVtAjOEMJDunn51SgZXgbADwDYGbVgXuAzgTfvN1jZtX2NazEMbPgCM7UqdCiBVxwAVx8sS4OKiJxxczqAa8Al7l7zlGeO4CDgY5AdeC2fPYdYGaTzGxSRkZGseQVKYjMrGxufGMaI6ekc9PJrbjp5FYqbqREK1CB4+7fAGt3s0lPYJgHxgFVw0HkFOAzd1/r7uuAz9h9oSSJ7qCD4Pvv4b77gvNzDjsMPv886lQikhzSgUYxjxuGywrEzCoDHwJ/CccqANx9RTh+7QBeIvhC7nfcfbC7p7l7Wq1amt0m8WFXVjZ/GjGN0dOX8+fuB3H9iS2jjiQSucI6Bye/aQOFMp1AEkzp0nD33TBuHFSsCCedBDfcoIuDisj+mgi0NLNmZpYK9AJGF2THcPt3Cb6MezvXunrhTwPOAvKcji0Sb3ZmZnPta1P4cOYK7upxCFcf3yLqSCJxIW6aDOjQfxJKSwsuBnrddfD449C1q9pJi8g+c/dM4FrgE+An4E13n21mg8zsTAAz62hmy4DzgefMbHa4+wXAscClebSDHm5mM4GZQE3ggeJ7VSL7ZkdmFlcPn8wns3/lnjNac8UxB0YdSSRulC6k58lv2kA6cHyu5V/l9QTuPhgYDJCWlqZew8miQgX4z3+ge3e45BLo0AFeegnOPTfqZCKSgNx9DDAm17K7Y+5PJBhrcu/3KvBqPs95QiHHFClS23dlMfDVyXw1N4P7zzqUS7o0iTqSSFwprCM4o4G+YTe1LsAGd19B8C1bNzOrFjYX6BYuk5LmtNOCBgStW8N55wVT1nbujDqViIhIQtm2M4srh03i63kZPHTOYSpuRPJQoCM4ZvY6wZGYmuGh/3uAMgDu/izBt2mnAQsILqZ2WbhurZndTzBvGmCQu++uWYEks8aN4Ztv4Lbb4LHHgnN03nwzWC4iIiK7tXVnJpcPncS4n9fwyHlHcF6H3x2sFBEKWOC4e+89rHfgmnzWDQGG7H00SUqpqfDoo8GFQfv3h3btYNgw6NEj6mQiIiJxa/OOTPoPncikxWt59IK2nNVOPZtE8hM3TQakhDn3XJg8GRo1gtNPhzvvhMzMqFOJiIjEnU3bd9FvyAQm/7KOx3u1U3EjsgcqcCQ6LVrA2LFw5ZXw4INBO+kVK6JOJSIiEjc2bNvFxS9OYPrS9TzZux1nHFE/6kgicU8FjkSrfHkYPDiYpjZxIrRtC198EXUqERGRyK3fupOLXxjPj8s38HSf9px6WL2oI4kkBBU4Eh8uuQQmTIAaNeDkk+H++yE7O+pUIiIikVi7ZScXPT+euSs38dwlHejWpm7UkUQShgociR9t2gRFTu/ecPfdQWtpXfRVRERKmNWbd3DR8+NYmLGZ5/ulccLBdaKOJJJQVOBIfKlUCV55BZ57Dr76Kuiy9sMPUacSEREpFqs2baf34HEsXrOFIZd25LhWtaKOJJJwVOBI/DGDAQOCwqZsWTjuOPjXv8A96mQiIiJF5pc1W+j13DjS129j6GWdOKpFzagjiSQkFTgSv9q3D1pJn3EG3HILnH02rF8fdSoREZFCN2nxWs5++gfWbt3JsP6d6HJgjagjiSQsFTgS36pWhXfegX//Gz78ELp0gblzo04lIiJSaEZNTeei58dTtXwZ3r36KNKaVo86kkhCU4Ej8c8MbrwRPv8c1qyBzp3ho4+iTiUiIrJf3J1HP5vHDW9Mo32Tqoy8+kia1awYdSyRhKcCRxLHscfCpEnQtCn06AGPPKLzckREJCFt35XFn0ZM4/HP53N+h4YM69+ZqhVSo44lkhRU4EhiadIEvv8ezjsP/vzn4Po527ZFnUpERKTA1mzeQZ8XxjN6+nL+3P0g/nHe4aSW1n/JRApL6agDiOy1ihXhjTfgiCPgrruCc3LefRcaNow6mYiIyG7N/3UT/V+eyKqNO3i6T3tOO6xe1JFEko6+LpDEZAZ/+Qu89x7MmQMdO8LYsVGnEhERydd381dzzjM/sG1nNm9c1VXFjUgRUYEjie3MM2HcuOCozvHHw0svRZ1IRETkd14bv4R+L02gQdXyjLrmSNo2qhp1JJGkpQJHEl+bNjBhQtCEoH9/uOEGyMyMOpWIiAhZ2c7fPvyRO9+dyTEta/LWwK40rFYh6lgiSU0FjiSH6tWD1tE33ACPPw7duwctpUVERCKydWcmA1+dzPPf/kzfrk14oW8aB5QrE3UskaSnAkeSR+nS8OijMGQIfPstdOoEs2dHnUpEREqglRu2c/6zY/n8p1+594zWDOp5KKVT9N8ukeKgv2mSfC67DL76CrZuhS5dgkYEIiIixWRW+gZ6PvUdi1dv4YV+aVx6VLOoI4mUKCpwJDl17RpcFPSQQ+Css+CBB3RRUBERKXKf/fgr5z87llJmvDXwSE44uE7UkURKHBU4krwaNICvv4aLL4a//hUuvBC2bIk6lYjsBzPrbmZzzWyBmd2ex/pjzWyKmWWa2Xm51vUzs/nhrV/M8g5mNjN8zv+YmRXHa5Hk4u688O0iBrwyiZZ1KvHeNUfRun7lqGOJlEgqcCS5lS8Pw4bBI4/AO+/AUUfBkiVRpxKRfWBmKcBTwKlAa6C3mbXOtdkS4FLgtVz7VgfuAToDnYB7zKxauPoZ4EqgZXjrXkQvQZLU9l1Z3Pr2DB748CdOaV2XNwZ0pXblclHHEimxVOBI8jODW26BDz+ExYuhc+dg+pqIJJpOwAJ3X+TuO4ERQM/YDdx9sbvPALJz7XsK8Jm7r3X3dcBnQHczqwdUdvdx7u7AMOCson4hkjx+3bidXoPH8fbkZVx/Ykue7tOe8qkpUccSKdFU4EjJ0b07/PADlCsXXDPn3XejTiQie6cBsDTm8bJw2f7s2yC8vy/PKSXclCXrOOOJ75j36yaevbg9N53cilKlNMNRJGoFKnAKMOf5UTObFt7mmdn6mHVZMetGF2J2kb3XujWMHw9HHAHnngv//KeaD4hIgZjZADObZGaTMjIyoo4jEXtr0lJ6PTeOsmVKMfLqI+l+aL2oI4lIqPSeNoiZ83wywTdbE81stLv/mLONu98Ys/11QLuYp9jm7m0LLbHI/qpdG774Avr1g1tvhQUL4IknoIwuviYS59KBRjGPG4bLCrrv8bn2/Spc3rAgz+nug4HBAGlpafpmpITKzMrmb2N+4qXvF3Nk8xo8dVF7qlVMjTqWiMQoyBGcPc55zqU38HphhBMpMuXLw4gRcMcd8NxzcPrpsGFD1KlEZPcmAi3NrJmZpQK9gILODPgE6GZm1cLmAt2AT9x9BbDRzLqE3dP6Arp4luRp3Zad9HtpAi99v5jLjmrKsP6dVNyIxKGCFDgFnvNsZk2AZsAXMYvLhYf0x5nZWfsaVKTQlSoFf/87vPhicETnqKPgl1+iTiUi+XD3TOBagmLlJ+BNd59tZoPM7EwAM+toZsuA84HnzGx2uO9a4H6CImkiMChcBnA18AKwAFgIfFSML0sSxJyVGznzqe+Y+PM6HjnvcO45ow2lU3Qqs0g82uMUtb3UC3jb3bNiljVx93QzOxD4wsxmuvvC3Dua2QBgAEDjxo0LOZbIbvTvD02aBOfkdO4M778PHTtGnUpE8uDuY4AxuZbdHXN/Ir+dcha73RBgSB7LJwGHFm5SSSYfz1rBTW9Op1LZ0oy4qgvtG1fb804iEpmCfPWwN3Oee5Frepq7p4c/FxHMd273+92Cuc3unubuabVq1SpALJFCdOKJQYe18uXhuONg5MioE4mISMSys51HP5vHwFen0KrOAbx/3dEqbkQSQEEKnALNeTazg4FqwNiYZdXMrGx4vyZwFPBj7n1F4kJsh7XzzlOHNRGREmzzjkwGvjqZxz+fz7ntGzJiQBfq6OKdIglhj1PU3D3TzHLmPKcAQ3LmPAOT3D2n2OkFjAgvlJbjEII50NkExdRDsd3XROJOToe1Sy8NOqzNnw9PPqkOayIiJcgva7Zw5bBJLMzYwt2nt+ayo5oS9KAQkURQoHNw9jTnOXx8bx77/QActh/5RIpf+fLw+uvQvDk8+CD8/DO89RZUqRJ1MhERKWLfzs/g2temYgbD+nfiqBY1o44kIntJ7T9E8hLbYe3LL4MOa4sXR51KRESKiLvzwreL6DdkAnUrl2P0NUeruBFJUCpwRHanf3/4+GNYtizosDZhQtSJRESkkK3fupOb3pzOAx/+RLfWdRl59ZE0rlEh6lgiso9U4IjsyYknwtixULFi0GHtnXeiTiQiIoUgO9t5c9JSTvjX14yevpwbT2rF033aU7FsYV9FQ0SKkwockYI45BAYNw7atg06rP3jH+qwJiKSwH5asZELnhvLn9+eQbOaFfnguqP500ktKVVKzQREEp2+ohApqNgOa7fdBvPmwdNPQ2pq1MlERKSANu/I5LHP5vHSD4upUr4M/zjvcM5r31CFjUgSUYEjsjdyOqy1agUPPBB0WHv7baimC7+JiMQzd+fDmSu4/4MfWbVpB706Nua27gdRtYK+pBJJNipwRPZWqVJw//3QsiVccQV07Qoffhi0lRYRkbizKGMz94yezbfzV9OmfmWevbgD7RrriymRZKUCR2Rf9e0LTZvC2WcHHdZGjYKjj446lYiIhLbvyuKpLxfw3NeLKFu6FPed2YaLuzQhRdPRRJKamgyI7I9jjw2aD1SvHnRbe/XVqBOJiAjwxZxfOfnRr3niiwX0OLwen99yHP2ObKriRqQE0BEckf3VsmVQ5JxzDlxyCcyfD/feC6ZBVESkuC1bt5VB7//Ipz/+SovalXjtys4c2VwX7BQpSVTgiBSG6tXh00/hqqtg0KCgyBkyBMqVizqZiEiJsDMzmxe+W8R/Pp+PYdzW/WAuP7oZqaU1WUWkpFGBI1JYUlODouagg+COO+CXX4LzcmrVijqZiEjScne+W7Cae0fPZmHGFk5pU4e7z2hDg6rlo44mIhFRgSNSmMzg9tuDjmp9+wbNBz74AFq3jjqZiEhS2bIjk1HT0nll7C/MWbmJRtXLM+TSNE44uE7U0UQkYipwRIrC+edD48bQsycceWRwrZyTToo6lYhIwluUsZlXxv3C25OXsWl7JofUq8yD5xzG2e0aUK5MStTxRCQOqMARKSqdO8P48XD66dC9OzzzDFx5ZdSpREQSTla288WcVQwbu5hv56+mTIpx6qH16Nu1CR2aVMPU1EVEYqjAESlKTZrA99/DhRfCgAEwbx489BCk6FtGEZE9WbtlJ29MXMqr434hff026lYux00nt6JXp0bUPkBNXEQkbypwRIpa5crw/vvwpz/BP/8ZdFgbPhwqVow6mYhIXJq2dD3Dxi7mgxkr2JmZTZcDq3NXj0M4qXUdyqSoK5qI7J4KHJHiULo0PPlk0GHtxhuDC4SOHg0NGkSdTEQkLmzflcUHM1bwytjFTF+2gYqpKVyY1ohLujahVZ0Doo4nIglEBY5IcTGD66+HAw+E3r2hY0d4993gXB0RkRJq6dqtDB+/hDcmLmHd1l00r1WR+85swzntG3BAuTJRxxORBKQCR6S4nX46/PBD0GHtuONg8OCgpbSI7JGZdQceB1KAF9z9oVzrywLDgA7AGuBCd19sZn2AW2M2PRxo7+7TzOwroB6wLVzXzd1XFe0rKdm27szk41kreXvyMn5YuIZSBt1a16Vv1yZ0bV5DTQNEZL+owBGJwmGHwYQJQTvpfv1g5kw1HxDZAzNLAZ4CTgaWARPNbLS7/xiz2eXAOndvYWa9gIcJipzhwPDweQ4DRrn7tJj9+rj7pOJ4HSWVuzPh57W8M2UZH85YwZadWTSuXoGbTm7FeR0aUl8X5hSRQqICRyQqNWvCp5/CDTcEzQdmzYLXX4eqVaNOJhKvOgEL3H0RgJmNAHoCsQVOT+De8P7bwJNmZu7uMdv0BkYUfVyBYArayCnpvDNlGUvWbqViago9Dq/HeR0a0bGpWjyLSOFTgSMSpTJl4KmngiM6110HXboEzQdatYo6mUg8agAsjXm8DMh9Ett/t3H3TDPbANQAVsdscyFBIRTrJTPLAt4BHshVEMle2rozk49mBlPQxi5agxkc2bwGN57cklPa1KVCqv77ISJFR//CiMSDgQPhkEPgvPOgUyd44w045ZSoU4kkHTPrDGx191kxi/u4e7qZHUBQ4FxCcB5P7n0HAAMAGjduXBxxE0p2tjNx8VrenryMMTODKWhNalTg5pNbcXb7BjSsViHqiCJSQhSombyZdTezuWa2wMxuz2P9pWaWYWbTwtsVMev6mdn88NavMMOLJJXjjoOJE4OLg552Gjz6KOhLZJFY6UCjmMcNw2V5bmNmpYEqBM0GcvQCXo/dwd3Tw5+bgNcIpsL9jrsPdvc0d0+rVavWfryM5LJ07VYe+795HPfPL7lw8Dg+mrWSM46oz9sDu/LVLcdz3YktVdyISLHa4xGcAp7UCfCGu1+ba9/qwD1AGuDA5HDfdYWSXiTZNG0K338fdFW76SaYMQOefRbKlo06mUg8mAi0NLNmBIVML+CiXNuMBvoBY4HzgC9yppuZWSngAuCYnI3DIqiqu682szLA6cD/FfULSXQbtu5izKwVjJqazvif12IGRzWvyc0nH8QpbepSPlUNU0QkOgWZolaQkzrzcwrwmbuvDff9DOhOrm/PRCRGpUrw9tswaBDcdx/MmQMjR0K9elEnE4lUeE7NtcAnBG2ih7j7bDMbBExy99HAi8ArZrYAWEtQBOU4FliaM56FygKfhMVNCkFx83wxvJyEs31XFp//tIr3pqXz1dwMdmZlc2CtitzSrRXntFcXNBGJHwUpcApyUifAuWZ2LDAPuNHdl+azb56XbtfcZpEYpUrBvffCoYcGbaQ7doRRoyAtLepkIpFy9zHAmFzL7o65vx04P599vwK65Fq2heCaOZKHrGxn7MI1jJqWziezVrJpRya1DyhL365N6Nm2AYc2qKwuaCISdwqrycD7wOvuvsPMrgJeBk7Ymydw98HAYIC0tDSdeCACQdOBFi2Ci4Iecwy89BL06rXn/URE9pG7MzN9A6OmLuf9GcvJ2LSDA8qWpvuhdTmrXQO6HFiDlFIqakQkfhWkwNnjSZ3uHnsC5wvAP2L2PT7Xvl/tbUiREq1t26D5wLnnQu/ewUVB778/OMojIlJIFq/ewqhp6YyetpxFq7eQmlKKPxxci7PaNuAPB9emXBmdVyMiiaEgBc4eT+o0s3ruviJ8eCbwU3j/E+DvZlYtfNwNuGO/U4uUNLVrw+efwzXXwN//HhQ5r74KlStHnUxEEljGph18MGM5o6YtZ/rS9ZhBl2Y1GHDsgZx6aD2qVCgTdUQRkb22xwKngCd1Xm9mZwKZBCd1Xhruu9bM7icokgAG5TQcEJG9lJoKgwfDEUfADTdA167BeTktW0adTEQShLuzYNVmvp6XwZdzVzF24RqyHVrXq8ydpx3MGUfUp14VNQsQkcRm8Xix5rS0NJ80aVLUMUTi1+efwwUXwK5d8OKLcH6e51SL7Bczm+zu6myRh0QapzZs28UPC1bzzfwMvp6bwfIN2wFoWbsSp7SpS8+29WlZ54CIU4qI7L38xqnCajIgIsXpxBNh6tSgyLngArjuOvjnP4OjPCJSomVnO7OXb+Treav4el4GU5asJyvbOaBsaY5uWZPrT6zFsa1qqa2ziCQtFTgiiapxY/jmG7jtNnjsMRg/Ht58E5o0iTqZiBSzNZt38O381Xw9L4Nv5mWwZstOAA5rUIU/Htec4w6qRdtGVSmTouYkIpL8VOCIJLLUVHj0UTj6aOjfH9q1g1degR49ok4mIkUoMyubqUvX8828DL6el8HM9A24Q42KqRzbqhbHtarF0S1rUrNS2aijiogUOxU4Isng3HOD5gPnnQennw533AGDBkFp/RUXSTbZ2U7Pp75n9vKNpJQy2jeuys0nt+K4VrVpU78ypXSNGhEp4fS/H5Fk0aIFjB0Lf/oTPPgg/PADvP461KsXdTIRKUTjfl7D7OUbufnkVvQ9silVyquVs4hILE3GFUkm5csHraSHDQsuDtq2LXzxRdSpRKQQvTd1ORVTU7jimANV3IiI5EEFjkgyuuQSmDABqleHk0+GBx6A7OyoU4nIftq+K4sxM1fQ/dB6lE9NiTqOiEhcUoEjkqzatAmO4vTqBX/9K5x2GqxeHXUqEdkPX85ZxaYdmZzVrn7UUURE4pYKHJFkVqkSvPoqPPssfPll0GVt7NioU4nIPho1LZ1aB5TlyOY1o44iIhK3VOCIJDszuOqqoLApUwaOPTZoLe0edTIR2Qsbtu7iyzkZnHF4fVLUKU1EJF8qcERKivbtYcqUoI30TTcFraXXr486lYgU0EezVrAzK1vT00RE9kAFjkhJUrUqjBwJ//oXvP8+dOgA48dHnUpECmDUtHQOrFmRwxpUiTqKiEhcU4EjUtKYBUdwvv4adu2CI4+EO++EHTuiTiYi+Vi+fhvjFq3lrHYNMNP0NBGR3VGBI1JSHXkkzJwJl14aXBi0Y0eYOjXqVCKSh9HTlwPQs62mp4mI7IkKHJGSrEoVePFF+OADyMiATp1g0KDgyI6IxI1RU9Np17gqTWpUjDqKiEjcU4EjItCjB8yeDRdcAPfcA127Bo9FJHJzV25izspNnNW2QdRRREQSggocEQlUrw7Dh8Pbb8OSJUHXtYcfhqysqJOJlGijpqWTUsrocXi9qKOIiCQEFTgi8lvnnguzZgXtpG+/HY45BubNizqVSImUne2MnracY1rWpGalslHHERFJCCpwROT3atcOjuQMHw5z5kDbtvD445CdHXUyKeHMrLuZzTWzBWZ2ex7ry5rZG+H68WbWNFze1My2mdm08PZszD4dzGxmuM9/LI7alE1cvJb09ds4u52mp4mIFJQKHBHJmxlcdFFwNOcPf4AbboATT4Sff446mZRQZpYCPAWcCrQGeptZ61ybXQ6sc/cWwKPAwzHrFrp72/A2MGb5M8CVQMvw1r2oXsPeGjVtORVSUzi5dZ2oo4iIJAwVOCKye/XrB13WXnwRJk+Gww+H554D96iTScnTCVjg7ovcfScwAuiZa5uewMvh/beBE3d3RMbM6gGV3X2cuzswDDir0JPvg52Z2YyZuYJuretQIbV01HFERBKGChwR2TMz6N8/OJrTpQsMHAjdu8PSpVEnk5KlARD7oVsWLstzG3fPBDYANcJ1zcxsqpl9bWbHxGy/bA/PGYmv5q5iw7Zd9NT0NBGRvaICR0QKrnFj+PRTePpp+O47OOwwePllHc2RRLACaOzu7YCbgNfMrPLePIGZDTCzSWY2KSMjo0hCxnpv2nJqVEzlmBY1i/x3iYgkkwIVOAU4qfMmM/vRzGaY2edm1iRmXVbMSZ2jCzO8iETADP74R5gxI5iudumlQae1sWOjTibJLx1oFPO4Ybgsz23MrDRQBVjj7jvcfQ2Au08GFgKtwu0b7uE5Cfcb7O5p7p5Wq1atQng5+du4fRef/fQrpx9ej9Ip+i5SRGRv7PFfzQKe1DkVSHP3wwnmPP8jZt22mJM6zyyk3CIStebN4csvg/NxFi6EI4+Ec86BuXOjTibJayLQ0syamVkq0AvI/cXZaKBfeP884At3dzOrFY5nmNmBBM0EFrn7CmCjmXUJz9XpC7xXHC9mdz6etZKdmdmaniYisg8K8rXQHk/qdPcv3X1r+HAcv/02TESSVUoKDBgACxbA/ffDZ59BmzbBEZ6VK6NOJ0kmPKfmWuAT4CfgTXefbWaDzCznC7QXgRpmtoBgKlrOrINjgRlmNo3gi7iB7r42XHc18AKwgODIzkfF8Xp2571p6TSpUYF2japGHUVEJOEUpMApyEmdsS7nt4NDuXDO8jgzO2vvI4pI3KtYEe66KziS88c/wgsvQIsWcM89sGlT1Okkibj7GHdv5e7N3f1v4bK73X10eH+7u5/v7i3cvZO7LwqXv+PubcLZBO3d/f2Y55zk7oeGz3lt2E0tMr9u3M4PC9fQs20D4uiSPCIiCaNQJ/aa2cVAGvBIzOIm7p4GXAQ8ZmbN89m3WE/eFJEiULs2PPEE/PQTnHYaDBoUFDpPPQW7dkWdTiQhvD99Oe5wVtv6UUcREUlIBSlwCnJSJ2Z2EvAX4Ex335Gz3N3Tw5+LgK+Adnn9kuI8eVNEiliLFvDmmzB+PBxyCFx7LbRuDW+9pY5rInswalo6hzeswoG1KkUdRUQkIRWkwNnjSZ1m1g54jqC4WRWzvJqZlQ3v1wSOAn4srPAiEuc6dQoaEXzwAZQtCxdcAF27wjffRJ1MJC4tWLWJWekb6dlWzQVERPbVHgucAp7U+QhQCXgrVzvoQ4BJZjYd+BJ4yN1V4IiUJGbQowdMnw5DhsCyZXDccXDGGTB7dtTpROLKqKnLKWVwxhH1oo4iIpKwShdkI3cfA4zJtezumPsn5bPfD8Bh+xNQRJJESgpcdhn06gWPPw4PPfS/6+jcdx80VPNFKdncnfemp3NUi5rUPqBc1HFERBKWrh4mIsWrfHm4/fag49qf/gSvvgotW8LAgfCjDvBKyTVlyTqWrt3GWZqeJiKyX1TgiEg0atSAf/87uDDoRRfB0KHBNXS6dQvO2cnOjjqhSLEaNXU55cqU4pRD60YdRUQkoanAEZFoNW0KL74IS5fC3/4WnJdzxhnQqlUwlW3jxqgTihS5XVnZfDBjOScdUodKZQs0e1xERPKhAkdE4kOtWnDnnbB4MYwYAXXqwA03QIMGcP31MG9e1AlFisw38zJYt3WXpqeJiBQCFTgiEl/KlIELL4Tvv4cJE+Dss+HZZ+Ggg4KLh37yiaavSdIZNW05VSuU4dhWug6ciMj+UoEjIvGrY0cYNgyWLIF774UpU6B79+Bcnaefhs2bo04ost8278jksx9Xcvrh9UgtrWFZRGR/6V9SEYl/devCPffAL7/AK69ApUpwzTVBa+mbb4ZFi6JOKLLPPp29ku27sjU9TUSkkKjAEZHEUbYsXHxxMHXthx/g1FPhP/+BFi2gZ0944w01JZCEM2rachpWK0+HJtWijiIikhRU4IhI4jGDrl3h9deDpgR33gnjxgUXEa1ZM5jG9uyzsHx51ElFdmvVpu18Nz+Dnm3rY2ZRxxERSQoqcEQksTVoAA88EBQz334bXDx04UL44x+DdZ07w9//HlxE1D3qtCK/8cH0FWQ7mp4mIlKIVOCISHJISYGjj4ZHHglaSs+eHVxXB+AvfwkaE7RqBbfeCt99B1lZ0eYVAd6blk7repVpWeeAqKOIiCQNFTgiknzMoHXrYOra+PGwbBk88ww0bx5cPPSYY6BePbj8cnj/fdi2LerEUgL9vHoL05dt4Ox2OnojIlKYVOCISPJr0AAGDoSPP4aMjOBCoieeCG+/DWeeGZy3c845MHQozJ2roztSLEZNTccMzjiiftRRRESSSumoA4iIFKsqVYILiV54IezcCV99Be+9F9zefTfYpkIFOPxwaNsW2rULfh56aLBcpBC4O6OmpdP1wBrUrVIu6jgiIklFBY6IlFypqdCtW3B78kmYOTO4mOi0acHt9deDbmwApUrBQQcFxU7srXbtqNJLApu2dD2/rNnKNce3iDqKiEjSUYEjIgLBeTuHHx7ccrgHbahzCp5p0+D774PCJ0f9+r8teI44Apo0Ca7ZI5KP96YtJ7V0KbofVjfqKCIiSUcFjohIfsygWbPgdvbZ/1u+du1vi55p0+CTT3577k6tWtCw4e5vmvJWImVmZfPBjOWceHBtKpcrE3UcEZGkowJHRGRvVa8OJ5wQ3HJs3x60pp45E5YuDTq3LVsGv/wSHPVZuzbv58mr8KlfH6pVC84Xqlw5uFWoEBRckvC+W7Ca1Zt30lPXvhERKRIqcERECkO5ctChQ3DLy9atkJ7+v8In923SJFi1Kv/nT0kJCp3Yoifnfn7LunZNunOEzKw78DiQArzg7g/lWl8WGAZ0ANYAF7r7YjM7GXgISAV2Are6+xfhPl8B9YCcfuHd3H03fxj7571py6lcrjR/OLhWUf0KEZESTQWOiEhxqFABWrYMbvnZsQOWLw8KofXrYePG4LZhw29/5txfsQLmzPnf4507f/t8n3wSNFBIEmaWAjwFnAwsAyaa2Wh3/zFms8uBde7ewsx6AQ8DFwKrgTPcfbmZHQp8AsQeQunj7pOK+jVs35XFp7NXcmbb+pQtnVLUv05EpERSgSMiEi/Klv3fOT/7YseO3xZCLZKuQ1cnYIG7LwIwsxFATyC2wOkJ3Bvefxt40szM3afGbDMbKG9mZd19R9HH/p9yZVL4+IZji/NXioiUOCpwRESSRdmyQXODWkk79akBsDTm8TKgc37buHummW0AahAcwclxLjAlV3HzkpllAe8AD7i7F3b4HI2qq7mEiEhRKhV1ABERkeJiZm0Ipq1dFbO4j7sfBhwT3i7JZ98BZjbJzCZlZGQUfVgREdknKnBERCRRpAONYh43DJfluY2ZlQaqEDQbwMwaAu8Cfd19Yc4O7p4e/twEvEYwFe533H2wu6e5e1qt5D1KJiKS8ApU4JhZdzOba2YLzOz2PNaXNbM3wvXjzaxpzLo7wuVzzeyUQswuIiIly0SgpZk1M7NUoBcwOtc2o4F+4f3zgC/c3c2sKvAhcLu7f5+zsZmVNrOa4f0ywOnArKJ9GSIiUpT2WODEdK05FWgN9Daz1rk2+2/XGuBRgsP/hNv1AtoA3YGnw+cTERHZK+6eCVxL0AHtJ+BNd59tZoPM7MxwsxeBGma2ALgJyPlS7lqgBXC3mU0Lb7WBssAnZjYDmEZwBOj5YntRIiJS6ArSZGCfu9aEy0eEJ3L+HA44nYCxhRNfRERKEncfA4zJtezumPvbgfPz2O8B4IF8njafixeJiEgiKsgUtby61uS+/PJvutYAOV1rCrKviIiIiIhIoYibJgPqTiMiIiIiIvurIAXO/nStKci+gLrTiIiIiIjI/itIgbPPXWvC5b3CLmvNgJbAhMKJLiIiIiIi8lt7bDIQXgk6p2tNCjAkp2sNMMndRxN0rXklbCKwlqAIItzuTYKGBJnANe6eVUSvRURERERESjgLDrTEFzPLAH7Zj6eoCawupDhFKVFyQuJkTZSckDhZEyUnJE7WRMnZxN01ZzgPGqfiUqJkTZSckDhZEyUnJE7WRMmZ5zgVlwXO/jKzSe6eFnWOPUmUnJA4WRMlJyRO1kTJCYmTNVFyStFJlM9AouSExMmaKDkhcbImSk5InKyJkjM/cdNFTUREREREZH+pwBERERERkaSRrAXO4KgDFFCi5ITEyZooOSFxsiZKTkicrImSU4pOonwGEiUnJE7WRMkJiZM1UXJC4mRNlJx5SspzcEREREREpGRK1iM4IiIiIiJSAiVsgWNm3c1srpktMLPb81hf1szeCNePN7OmEcTEzBqZ2Zdm9qOZzTazP+WxzfFmtsHMpoW3u6PIGmZZbGYzwxyT8lhvZvaf8H2dYWbtI8h4UMx7Nc3MNprZDbm2iew9NbMhZrbKzGbFLKtuZp+Z2fzwZ7V89u0XbjPfzPrltU0R53zEzOaEf7bvmlnVfPbd7eekmLLea2bpMX/Gp+Wz727/rSiGnG/EZFxsZtPy2bdY31MpHokwVmmcKpKMGqeKLqfGqcLPmXzjlLsn3I3ggqMLgQOBVGA60DrXNlcDz4b3ewFvRJS1HtA+vH8AMC+PrMcDH0T9voZZFgM1d7P+NOAjwIAuwPg4+CysJOiDHhfvKXAs0B6YFbPsH8Dt4f3bgYfz2K86sCj8WS28X62Yc3YDSof3H84rZ0E+J8WU9V7glgJ8Pnb7b0VR58y1/l/A3fHwnupW9LdEGas0ThXL50DjVOHl1DhVyDlzrU+KcSpRj+B0Aha4+yJ33wmMAHrm2qYn8HJ4/23gRDOzYswIgLuvcPcp4f1NwE9Ag+LOUYh6AsM8MA6oamb1IsxzIrDQ3ffngnuFyt2/AdbmWhz7eXwZOCuPXU8BPnP3te6+DvgM6F6cOd39U3fPDB+OAxoW1e/fG/m8pwVRkH8rCs3ucob//lwAvF5Uv1/iTkKMVRqnipzGqULMqXFq/5SUcSpRC5wGwNKYx8v4/T/G/90m/IuwAahRLOnyEU49aAeMz2N1VzObbmYfmVmb4k32Gw58amaTzWxAHusL8t4Xp17k/xcxXt5TgDruviK8vxKok8c28fbe9if4FjQve/qcFJdrw2kKQ/KZThFP7+kxwK/uPj+f9fHynkrhSbixSuNUkdA4VXQ0ThWupBmnErXASThmVgl4B7jB3TfmWj2F4ND1EcATwKhijhfraHdvD5wKXGNmx0aYZbfMLBU4E3grj9Xx9J7+hgfHeeO6faGZ/QXIBIbns0k8fE6eAZoDbYEVBIfV41lvdv+tWDy8p1KCaZwqfBqnio7GqSKRNONUohY46UCjmMcNw2V5bmNmpYEqwJpiSZeLmZUhGDSGu/vI3OvdfaO7bw7vjwHKmFnNYo6ZkyU9/LkKeJfg0Gmsgrz3xeVUYIq7/5p7RTy9p6Ffc6ZIhD9X5bFNXLy3ZnYpcDrQJxzkfqcAn5Mi5+6/unuWu2cDz+eTIV7e09LAOcAb+W0TD++pFLqEGas0ThUZjVNFQONU4Uu2cSpRC5yJQEszaxZ+O9ILGJ1rm9FATneP84Av8vtLUJTC+YwvAj+5+7/z2aZuzpxrM+tE8OcSxQBX0cwOyLlPcCLfrFybjQb6WqALsCHmkHZxy/ebhnh5T2PEfh77Ae/lsc0nQDczqxYexu4WLis2ZtYd+DNwprtvzWebgnxOilyuOfVn55OhIP9WFIeTgDnuviyvlfHynkqhS4ixSuNUkdI4Vcg0ThWZ5BqnCtqNIN5uBF1S5hF0nvhLuGwQwQceoBzBIeEFwATgwIhyHk1wmHcGMC28nQYMBAaG21wLzCbonDEOODKirAeGGaaHeXLe19isBjwVvu8zgbSIslYkGAiqxCyLi/eUYDBbAewimEt7OcGc+s+B+cD/AdXDbdOAF2L27R9+ZhcAl0WQcwHBXOCcz2pOd6f6wJjdfU4iyPpK+BmcQTAY1MudNXz8u38rijNnuHxozmczZttI31PdiueW1+ePOBur0DhVVFk1ThVNTo1ThZwzXD6UJBqnLAwtIiIiIiKS8BJ1ipqIiIiIiMjvqMAREREREZGkoQJHRERERESShgocERERERFJGipwREREREQkaajAERERERGRpKECR0REREREkoYKHBERERERSRr/D3hjU+fPCxkTAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 1008x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(14, 5))\n",
    "\n",
    "plt.subplot(1,2,1)\n",
    "plt.plot(history.history['loss'], c='r')\n",
    "plt.title('Loss')\n",
    "\n",
    "plt.subplot(1,2,2)\n",
    "plt.plot(history.history['accuracy'])\n",
    "plt.title('Accuracy')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4c29204b",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "# 모델 평가"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 272,
   "id": "ef62b269",
   "metadata": {},
   "outputs": [],
   "source": [
    "def decoder_inference(sentence):\n",
    "    sentence = preprocess_sentence(sentence)\n",
    "\n",
    "    # 입력된 문장을 정수 인코딩 후, 시작 토큰과 종료 토큰을 앞뒤로 추가.\n",
    "    # ex) Where have you been? → [[8331   86   30    5 1059    7 8332]]\n",
    "    sentence = tf.expand_dims(\n",
    "        START_TOKEN + tokenizer.encode(sentence) + END_TOKEN, axis=0)\n",
    "\n",
    "    # 디코더의 현재까지의 예측한 출력 시퀀스가 지속적으로 저장되는 변수.\n",
    "    # 처음에는 예측한 내용이 없음으로 시작 토큰만 별도 저장. ex) 8331\n",
    "    output_sequence = tf.expand_dims(START_TOKEN, 0)\n",
    "\n",
    "    # 디코더의 인퍼런스 단계\n",
    "    for i in range(MAX_LENGTH):\n",
    "        # 디코더는 최대 MAX_LENGTH의 길이만큼 다음 단어 예측을 반복합니다.\n",
    "        predictions = model(inputs=[sentence, output_sequence], training=False)\n",
    "        predictions = predictions[:, -1:, :]\n",
    "\n",
    "        # 현재 예측한 단어의 정수??\n",
    "        predicted_id = tf.cast(tf.argmax(predictions, axis=-1), tf.int32)\n",
    "\n",
    "        # 만약 현재 예측한 단어가 종료 토큰이라면 for문을 종료\n",
    "        if tf.equal(predicted_id, END_TOKEN[0]):\n",
    "            break\n",
    "\n",
    "        # 예측한 단어들은 지속적으로 output_sequence에 추가됩니다.\n",
    "        # 이 output_sequence는 다시 디코더의 입력이 됩니다.\n",
    "        output_sequence = tf.concat([output_sequence, predicted_id], axis=-1)\n",
    "\n",
    "    return tf.squeeze(output_sequence, axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 273,
   "id": "79145d15",
   "metadata": {},
   "outputs": [],
   "source": [
    "def sentence_generation(sentence):\n",
    "    # 입력 문장에 대해서 디코더를 동작 시켜 예측된 정수 시퀀스를 리턴받습니다.\n",
    "    prediction = decoder_inference(sentence)\n",
    "\n",
    "    # 정수 시퀀스를 다시 텍스트 시퀀스로 변환합니다.\n",
    "    predicted_sentence = tokenizer.decode(\n",
    "      [i for i in prediction if i < tokenizer.vocab_size])\n",
    "\n",
    "    print('입력 : {}'.format(sentence))\n",
    "    print('출력 : {}'.format(predicted_sentence))\n",
    "\n",
    "    return predicted_sentence"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6372be43",
   "metadata": {},
   "source": [
    "### 어울리는 답변들"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 286,
   "id": "4b63e27f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "입력 : 뭐 먹을까?\n",
      "출력 : 좀 먹어도 괜찮아요 .\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'좀 먹어도 괜찮아요 .'"
      ]
     },
     "execution_count": 286,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sentence_generation(\"뭐 먹을까?\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 292,
   "id": "86654d60",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "입력 : 영화 추천해줘\n",
      "출력 : 최신 영화가 좋을 것 같아요 .\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'최신 영화가 좋을 것 같아요 .'"
      ]
     },
     "execution_count": 292,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sentence_generation(\"영화 추천해줘\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 276,
   "id": "d66247e5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "입력 : 사랑이 뭘까?\n",
      "출력 : 사랑은 알 수 없어요 . 단지 느껴질 뿐 .\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'사랑은 알 수 없어요 . 단지 느껴질 뿐 .'"
      ]
     },
     "execution_count": 276,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sentence_generation(\"사랑이 뭘까?\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 278,
   "id": "0669a349",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "입력 : 영화 보고싶어\n",
      "출력 : 그럴 때가 있어요 .\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'그럴 때가 있어요 .'"
      ]
     },
     "execution_count": 278,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sentence_generation(\"영화 보고싶어\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 279,
   "id": "3bf73826",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "입력 : 너 이름이 뭐야?\n",
      "출력 : 위로봇이요 .\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'위로봇이요 .'"
      ]
     },
     "execution_count": 279,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sentence_generation(\"너 이름이 뭐야?\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8101a429",
   "metadata": {},
   "source": [
    "### 이상한 답변들"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 280,
   "id": "017d4147",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "입력 : 내일 날씨는 어때?\n",
      "출력 : 맛있는 거 드세요 .\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'맛있는 거 드세요 .'"
      ]
     },
     "execution_count": 280,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sentence_generation(\"내일 날씨는 어때?\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 277,
   "id": "fa8004e3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "입력 : 존똑이야\n",
      "출력 : 잘 지냈답니다 .\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'잘 지냈답니다 .'"
      ]
     },
     "execution_count": 277,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sentence_generation(\"존똑이야\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 281,
   "id": "41c80494",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "입력 : 오늘 많이 힘들었어\n",
      "출력 : 차라리 잘 된 일이네요 .\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'차라리 잘 된 일이네요 .'"
      ]
     },
     "execution_count": 281,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sentence_generation('오늘 많이 힘들었어')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 282,
   "id": "f5ad0c26",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "입력 : 지금 몇시야?\n",
      "출력 : 잘 맞춰가면 돼요 .\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'잘 맞춰가면 돼요 .'"
      ]
     },
     "execution_count": 282,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sentence_generation('지금 몇시야?')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "602781c0",
   "metadata": {},
   "source": [
    "### 이상하게 던진 질문에 대한 답변들"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 283,
   "id": "6195ad85",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "입력 : ㅋㅋㅋㅋㅋㅋㅋㅋ\n",
      "출력 : 좋은 연락이었길 바랍니다 .\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'좋은 연락이었길 바랍니다 .'"
      ]
     },
     "execution_count": 283,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sentence_generation('ㅋㅋㅋㅋㅋㅋㅋㅋ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 284,
   "id": "23d2b9c8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "입력 : 222222\n",
      "출력 : 저는 위로해드리는 로봇이에요 .\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'저는 위로해드리는 로봇이에요 .'"
      ]
     },
     "execution_count": 284,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sentence_generation('222222')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 293,
   "id": "e1192d35",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "입력 : ???\n",
      "출력 : 상대방이 알 거예요 .\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'상대방이 알 거예요 .'"
      ]
     },
     "execution_count": 293,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sentence_generation('???')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b27fba41",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "# 회고\n",
    "\n",
    "### 개선점\n",
    "\n",
    "1. 정규표현식에 한국어 전처리를 변경 적용 (ㄱ-ㅎ, 가-힣 을 추가)\n",
    "\n",
    "2. 문장 최대 길이 분포를 확인하고, 한국어에 맞춰 최대 길이를 조정했습니다.\n",
    "\n",
    "\n",
    "### 챗봇 테스트 결과\n",
    "\n",
    "1. loss, accuracy 시각화를 통해 점차 성능이 안정적으로 좋아지는 것을 확인할 수 있었습니다.\n",
    "2. 답변은 대체적으로 적절한 답변과 이상한 답변 모두 도출하고 있습니다.\n",
    "3. 이상한 질문에 대해서 답변을 하긴 하지만 적절하지 않습니다.\n",
    "4. 영어를 제외했을 땐 답변이 빈 문자열이었습니다. 학습되지 않은 문장에 대해서는 답변하지 못한다는 점을 알 수 있었습니다.\n",
    "\n",
    "### 느낀 점\n",
    "- 확실히 더 좋은 답변을 위해서는 더 많은 데이터가 필요하다고 생각합니다."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}