[E-04]LyricsWriter.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "637b621d",
   "metadata": {},
   "outputs": [],
   "source": [
    "import glob\n",
    "import os\n",
    "import re\n",
    "import tensorflow as tf\n",
    "from sklearn.model_selection import train_test_split"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9c9a37f5",
   "metadata": {},
   "source": [
    "# 데이터 다운로드"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "568048c8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "데이터 크기: 187088\n",
      "Examples:\n",
      " [\"Now I've heard there was a secret chord\", 'That David played, and it pleased the Lord', \"But you don't really care for music, do you?\"]\n"
     ]
    }
   ],
   "source": [
    "txt_file_path = os.getenv('HOME')+'/aiffel/lyricist/data/lyrics/*'\n",
    "\n",
    "txt_list = glob.glob(txt_file_path)\n",
    "\n",
    "raw_corpus = []\n",
    "\n",
    "# 여러개의 txt 파일을 모두 읽어서 raw_corpus 에 담습니다.\n",
    "for txt_file in txt_list:\n",
    "    with open(txt_file, \"r\") as f:\n",
    "        raw = f.read().splitlines()\n",
    "        raw_corpus.extend(raw)\n",
    "\n",
    "print(\"데이터 크기:\", len(raw_corpus))\n",
    "print(\"Examples:\\n\", raw_corpus[:3])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d1b69e0c",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d8eae8d7",
   "metadata": {},
   "source": [
    "# 데이터 정제"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "3abe5613",
   "metadata": {},
   "outputs": [],
   "source": [
    "def preprocess_sentence(sentence):\n",
    "    sentence = sentence.lower().strip()\n",
    "    sentence = re.sub(r\"([?.!,¿])\", r\" \\1 \", sentence)\n",
    "    sentence = re.sub(r'[\" \"]+', \" \", sentence)\n",
    "    sentence = re.sub(r\"[^a-zA-Z0-9?.!,¿]+\", \" \", sentence)\n",
    "    sentence = re.sub(r\"([()])\", r\"\", sentence)\n",
    "    sentence = sentence.strip()\n",
    "    sentence = '<start> ' + sentence + ' <end>'\n",
    "    return sentence"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "bbfca191",
   "metadata": {},
   "outputs": [],
   "source": [
    "corpus = []\n",
    "\n",
    "for sentence in raw_corpus:\n",
    "    if len(sentence) == 0: continue\n",
    "\n",
    "    preprocessed_sentence = preprocess_sentence(sentence)\n",
    "\n",
    "    # 단어 개수가 15개를 넘어가면 학습 데이터에서 제외\n",
    "    if len(preprocessed_sentence.split()) > 15:\n",
    "        continue\n",
    "        \n",
    "    corpus.append(preprocessed_sentence)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "f5c2a62e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "156064"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(corpus)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "68b828d1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[   2   50    4 ...    0    0    0]\n",
      " [   2   15 2983 ...    0    0    0]\n",
      " [   2   33    7 ...   46    3    0]\n",
      " ...\n",
      " [   2    4  117 ...    0    0    0]\n",
      " [   2  259  195 ...   12    3    0]\n",
      " [   2    7   34 ...    0    0    0]] <keras_preprocessing.text.Tokenizer object at 0x7fbeec3a6460>\n"
     ]
    }
   ],
   "source": [
    "def tokenize(corpus, num_words=12000):\n",
    "    tokenizer = tf.keras.preprocessing.text.Tokenizer(\n",
    "        num_words=num_words, \n",
    "        filters=' ',\n",
    "        oov_token=\"<unk>\"\n",
    "    )\n",
    "    tokenizer.fit_on_texts(corpus)\n",
    "    tensor = tokenizer.texts_to_sequences(corpus)   \n",
    "    tensor = tf.keras.preprocessing.sequence.pad_sequences(tensor, padding='post')  \n",
    "    \n",
    "    print(tensor,tokenizer)\n",
    "    return tensor, tokenizer\n",
    "\n",
    "tensor, tokenizer = tokenize(corpus)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "2639b877",
   "metadata": {},
   "outputs": [],
   "source": [
    "src_input = tensor[:, :-1]\n",
    "tgt_input = tensor[:, 1:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "8ad99178",
   "metadata": {},
   "outputs": [],
   "source": [
    "enc_train, enc_validation, dec_train, dec_validation = train_test_split(src_input,\n",
    "                                                          tgt_input,\n",
    "                                                          test_size=0.2,\n",
    "                                                          shuffle=True,\n",
    "                                                          random_state=7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "3304b585",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Source Train: (124851, 14)\n",
      "Target Train: (124851, 14)\n"
     ]
    }
   ],
   "source": [
    "print(\"Source Train:\", enc_train.shape)\n",
    "print(\"Target Train:\", dec_train.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0fe44f6c",
   "metadata": {},
   "source": [
    "# 모델 만들기"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "89a71bb9",
   "metadata": {},
   "source": [
    "### 데이터셋 (train & validation)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "34d63754",
   "metadata": {},
   "outputs": [],
   "source": [
    "BUFFER_SIZE = len(enc_train)\n",
    "BATCH_SIZE = 256\n",
    "steps_per_epoch = len(enc_train) // BATCH_SIZE\n",
    "\n",
    "train_dataset = tf.data.Dataset.from_tensor_slices((enc_train, dec_train))\n",
    "train_dataset = train_dataset.shuffle(BUFFER_SIZE)\n",
    "train_dataset = train_dataset.batch(BATCH_SIZE, drop_remainder=False)\n",
    "\n",
    "validation_dataset = tf.data.Dataset.from_tensor_slices((enc_validation, dec_validation))\n",
    "validation_dataset = validation_dataset.batch(BATCH_SIZE, drop_remainder=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3f6e1776",
   "metadata": {},
   "source": [
    "### model 작성"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "66f26229",
   "metadata": {},
   "outputs": [],
   "source": [
    "class TextGenerator(tf.keras.Model):\n",
    "    def __init__(self, vocab_size, embedding_size, hidden_size):\n",
    "        super().__init__()\n",
    "        \n",
    "        self.embedding = tf.keras.layers.Embedding(vocab_size, embedding_size)\n",
    "        self.rnn_1 = tf.keras.layers.LSTM(hidden_size, return_sequences=True)\n",
    "        self.rnn_2 = tf.keras.layers.LSTM(hidden_size, return_sequences=True)\n",
    "        self.linear = tf.keras.layers.Dense(vocab_size)\n",
    "        \n",
    "    def call(self, x):\n",
    "        out = self.embedding(x)\n",
    "        out = self.rnn_1(out)\n",
    "        out = self.rnn_2(out)\n",
    "        out = self.linear(out)\n",
    "        \n",
    "        return out"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cf1253c5",
   "metadata": {},
   "source": [
    "### model 컴파일"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "4d98a17b",
   "metadata": {},
   "outputs": [],
   "source": [
    "embedding_size = 512 # 워드 벡터의 차원수 (추상적인 특징을 표현하는 크기) \n",
    "hidden_size = 2048 # 일꾼\n",
    "model = TextGenerator(tokenizer.num_words + 1, embedding_size , hidden_size)\n",
    "\n",
    "optimizer = tf.keras.optimizers.Adam()\n",
    "loss = tf.keras.losses.SparseCategoricalCrossentropy(\n",
    "    from_logits=True, reduction='none')\n",
    "\n",
    "model.compile(loss=loss, optimizer=optimizer)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6fe59da7",
   "metadata": {},
   "source": [
    "### model 학습시키기"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "d6924fc6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/10\n",
      "488/488 [==============================] - 273s 521ms/step - loss: 3.3180 - val_loss: 2.9314\n",
      "Epoch 2/10\n",
      "488/488 [==============================] - 255s 522ms/step - loss: 2.7860 - val_loss: 2.6976\n",
      "Epoch 3/10\n",
      "488/488 [==============================] - 255s 522ms/step - loss: 2.5031 - val_loss: 2.5279\n",
      "Epoch 4/10\n",
      "488/488 [==============================] - 254s 521ms/step - loss: 2.2235 - val_loss: 2.3917\n",
      "Epoch 5/10\n",
      "488/488 [==============================] - 255s 522ms/step - loss: 1.9507 - val_loss: 2.2888\n",
      "Epoch 6/10\n",
      "488/488 [==============================] - 255s 523ms/step - loss: 1.6988 - val_loss: 2.2183\n",
      "Epoch 7/10\n",
      "488/488 [==============================] - 255s 522ms/step - loss: 1.4810 - val_loss: 2.1725\n",
      "Epoch 8/10\n",
      "488/488 [==============================] - 254s 521ms/step - loss: 1.3012 - val_loss: 2.1491\n",
      "Epoch 9/10\n",
      "488/488 [==============================] - 255s 521ms/step - loss: 1.1644 - val_loss: 2.1541\n",
      "Epoch 10/10\n",
      "488/488 [==============================] - 255s 522ms/step - loss: 1.0704 - val_loss: 2.1690\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<keras.callbacks.History at 0x7fbd94f24700>"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.fit(train_dataset,\n",
    "          epochs=10,\n",
    "          validation_data=validation_dataset)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "86e27f8c",
   "metadata": {},
   "source": [
    "### model 평가"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "0ed08aa0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20/20 [==============================] - 3s 169ms/step - loss: 2.1941\n",
      "2.1941232681274414\n"
     ]
    }
   ],
   "source": [
    "validation_steps = 20\n",
    "result = model.evaluate(validation_dataset, steps=validation_steps)\n",
    "\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cce31486",
   "metadata": {},
   "source": [
    "### model 테스트 - 예측돌리기"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "28575f49",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'<start> i need you to hurry up now <end> '"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def generate_text(model, tokenizer, init_sentence=\"<start>\", max_len=20):\n",
    "    test_input = tokenizer.texts_to_sequences([init_sentence])\n",
    "    test_tensor = tf.convert_to_tensor(test_input, dtype=tf.int64)\n",
    "    end_token = tokenizer.word_index[\"<end>\"]\n",
    "\n",
    "    while True:\n",
    "        predict = model(test_tensor) \n",
    "        predict_word = tf.argmax(tf.nn.softmax(predict, axis=-1), axis=-1)[:, -1]\n",
    "        test_tensor = tf.concat([test_tensor, tf.expand_dims(predict_word, axis=0)], axis=-1)\n",
    "        if predict_word.numpy()[0] == end_token: break\n",
    "        if test_tensor.shape[1] >= max_len: break\n",
    "\n",
    "    generated = \"\"\n",
    "    for word_index in test_tensor[0].numpy():\n",
    "        generated += tokenizer.index_word[word_index] + \" \"\n",
    "\n",
    "    return generated\n",
    "\n",
    "generate_text(model, tokenizer, init_sentence=\"<start> i need\", max_len=20)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7a1e3296",
   "metadata": {},
   "source": [
    "# 회고\n",
    "\n",
    "### 1. 어려웠던 점\n",
    "- 모델을 학습시키는데 적절한 하이퍼 파라미터를 찾는 것이 어려웠습니다.\n",
    "- 데이터의 shape이 이해가 잘 안돼서 어떻게 배치, 토큰, 확률값 등이 연결되는지 어려웠습니다. \n",
    "\n",
    "\n",
    "### 3. 시도한 것들\n",
    "- BatchDataset과 TakeDataset, 그리고 학습에 적용된 데이터셋, shape와 배치사이즈를 print하면서 이해했습니다. \n",
    "    - 원래 전체 데이터 shape : (24015, 20)\n",
    "    - 배치 사이즈 : 256\n",
    "    - 학습 도는 횟수 : 93\n",
    "    - model(dataset.take(1)) shape : (256, 20, 7001)\n",
    "        - 256 : 배치 사이즈\n",
    "        - 20 : 문장 길이(단어 갯수)\n",
    "        - 7001 : 특정 단어에 대해 단어장의 7001개 단어들의 연관성 확률이 가장 높은지 모델링해서 나온 차원\n",
    "- 데이터셋이 배치 사이즈만큼 나뉘어 학습을 돌 때, 남는데이터셋에 대해서 제거되어 실제 데이터가 원본보다 적어지는 것을 발견했습니다. 데이터가 누락되지 않도록 dataset.batch 함수의 drop_remainder=False로 하고 돌렸더니 정상적으로 모든 데이터에 대해 처리되는 것을 확인할 수 있었습니다.\n",
    "- validation loss 값을 낮추기 위해, embedding_size(256 -> 512)와 hidden_size(1024 -> 2048)를 늘려서 돌렸습니다.\n",
    "\n",
    "\n",
    "### 5. 자기 다짐\n",
    "- model 학습의 val_loss를 줄이는것에 집중하다가, 그간 뭘했는지 기억이 도통 나질 않았습니다. 회고는 그렇다 쳐도... 돌이켜보면 어제 배운걸 또 까먹고 지난주에 배운걸 또 까먹고 있습니다. 매일 수업 전, 전날 배운걸 빠르게 복습해야겠다고 다짐하게 됐습니다. 회고도 가능하면 그날 바로 작성해야겠습니다."
   ]
  }
 ],
 "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}