generative_rnn.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/dany/.local/share/virtualenvs/cuba-digital-lang-9Kd57kqM/lib/python3.9/site-packages/tqdm/auto.py:22: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
      "  from .autonotebook import tqdm as notebook_tqdm\n"
     ]
    }
   ],
   "source": [
    "from data_mining import get_all_text, fb\n",
    "from tokenizer_digital_language.custom_tokenizer import SpacyCustomTokenizer\n",
    "import os\n",
    "from script_to_data_analysis.tools import get_progressbar\n",
    "\n",
    "texts = get_all_text(f'{os.getcwd()}/data_mining/')\n",
    "nlp = SpacyCustomTokenizer()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[#################################################] 289419 Tokenizer texts 100%\n"
     ]
    }
   ],
   "source": [
    "text_tokens = []\n",
    "super_text = []\n",
    "vocabulary = set('$END')\n",
    "bar = get_progressbar(len(texts), f' {len(texts)} Tokenizer texts ')\n",
    "bar.start()\n",
    "for i, tupl in enumerate(texts):\n",
    "    text, _ = tupl\n",
    "    temp = []\n",
    "    for token in nlp(text):\n",
    "        vocabulary.add(token.text)\n",
    "        temp.append(token.text)\n",
    "    text_tokens.append(temp)\n",
    "    super_text += temp + ['$END']\n",
    "    bar.update(i+1)\n",
    "bar.finish()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "253077"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vocabulary = sorted(vocabulary)\n",
    "len(vocabulary)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tensorflow (Structure Data Set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "from keras.layers import StringLookup\n",
    "from tensorflow.strings import reduce_join\n",
    "from tensorflow.data import Dataset, experimental\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-06-09 00:11:51.327511: I tensorflow/core/common_runtime/pluggable_device/pluggable_device_factory.cc:305] Could not identify NUMA node of platform GPU ID 0, defaulting to 0. Your kernel may not have been built with NUMA support.\n",
      "2022-06-09 00:11:51.331173: I tensorflow/core/common_runtime/pluggable_device/pluggable_device_factory.cc:271] Created TensorFlow device (/job:localhost/replica:0/task:0/device:GPU:0 with 0 MB memory) -> physical PluggableDevice (device: 0, name: METAL, pci bus id: <undefined>)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Metal device set to: Apple M1\n",
      "\n",
      "systemMemory: 8.00 GB\n",
      "maxCacheSize: 2.67 GB\n",
      "\n"
     ]
    }
   ],
   "source": [
    "ids_from_words = StringLookup(\n",
    "    vocabulary=list(vocabulary), mask_token=None)\n",
    "\n",
    "words_from_ids = StringLookup(\n",
    "    vocabulary=ids_from_words.get_vocabulary(), invert=True, mask_token=None)\n",
    "\n",
    "\n",
    "def text_from_ids(ids):\n",
    "  return reduce_join(words_from_ids(ids), axis=-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "idx_text = ids_from_words(super_text)\n",
    "ids_dataset = Dataset.from_tensor_slices(idx_text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "seq_length = 15\n",
    "sequences = ids_dataset.batch(seq_length+1, drop_remainder=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def split_input_target(sequence):\n",
    "    return sequence[:-1],sequence[-1]\n",
    "\n",
    "dataset = sequences.map(split_input_target)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Total Batches Data Set: 13435\n",
      "Training: 9404\n",
      "Validation: 2015\n",
      "Test: 2015\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Batch size\n",
    "BATCH_SIZE = 50\n",
    "# Buffer size to shuffle the dataset\n",
    "# (TF data is designed to work with possibly infinite sequences,\n",
    "# so it doesn't attempt to shuffle the entire sequence in memory. Instead,\n",
    "# it maintains a buffer in which it shuffles elements).\n",
    "BUFFER_SIZE = 10000\n",
    "\n",
    "full_dataset = (\n",
    "    dataset\n",
    "    .shuffle(BUFFER_SIZE)\n",
    "    .batch(BATCH_SIZE, drop_remainder=True)\n",
    "    .prefetch(experimental.AUTOTUNE))\n",
    "\n",
    "DATASET_SIZE = len(full_dataset)\n",
    "train_size = int(0.7 * DATASET_SIZE)\n",
    "val_size = int(0.15 * DATASET_SIZE)\n",
    "test_size = int(0.15 * DATASET_SIZE)\n",
    "\n",
    "train_dataset = full_dataset.take(train_size)\n",
    "test_dataset = full_dataset.skip(train_size)\n",
    "val_dataset = test_dataset.skip(test_size)\n",
    "test_dataset = test_dataset.take(test_size)\n",
    "\n",
    "print(f\"\"\"\n",
    "Total Batches Data Set: {DATASET_SIZE}\n",
    "Training: {train_size}\n",
    "Validation: {val_size}\n",
    "Test: {test_size}\n",
    "\"\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tensorflow (Model Def and Training)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow.keras import Model\n",
    "from keras.layers import Embedding, LSTM, GRU, Dense, Dropout, Input\n",
    "from tensorflow.keras.utils import plot_model\n",
    "from tensorflow import squeeze, random, losses, metrics, exp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:Layer lstm will not use cuDNN kernels since it doesn't meet the criteria. It will use a generic GPU kernel as fallback when running on GPU.\n",
      "WARNING:tensorflow:Layer lstm_1 will not use cuDNN kernels since it doesn't meet the criteria. It will use a generic GPU kernel as fallback when running on GPU.\n",
      "WARNING:tensorflow:Layer lstm_2 will not use cuDNN kernels since it doesn't meet the criteria. It will use a generic GPU kernel as fallback when running on GPU.\n"
     ]
    }
   ],
   "source": [
    "embedding_dim = 8\n",
    "rnn_units = seq_length * embedding_dim\n",
    "lstm_layers = 3\n",
    "\n",
    "embedding = Embedding(len(vocabulary), embedding_dim)\n",
    "lstm_list =[  LSTM(rnn_units, \n",
    "    input_shape=(BATCH_SIZE, seq_length, embedding_dim),\n",
    "    dropout=0.2,\n",
    "    recurrent_dropout=0.2,\n",
    "    return_state=True,\n",
    "    return_sequences=True\n",
    ") for _ in range(lstm_layers -1)]\n",
    "\n",
    "lstm_final = LSTM(rnn_units, dropout=0.2, recurrent_dropout=0.2)\n",
    "dense =  Dense(len(vocabulary), activation='softmax')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"rnn\"\n",
      "__________________________________________________________________________________________________\n",
      " Layer (type)                   Output Shape         Param #     Connected to                     \n",
      "==================================================================================================\n",
      " input_1 (InputLayer)           [(50, 15)]           0           []                               \n",
      "                                                                                                  \n",
      " embedding (Embedding)          (50, 15, 8)          2024616     ['input_1[0][0]']                \n",
      "                                                                                                  \n",
      " lstm (LSTM)                    [(50, 15, 120),      61920       ['embedding[0][0]']              \n",
      "                                 (50, 120),                                                       \n",
      "                                 (50, 120)]                                                       \n",
      "                                                                                                  \n",
      " lstm_1 (LSTM)                  [(50, 15, 120),      115680      ['lstm[0][0]',                   \n",
      "                                 (50, 120),                       'lstm[0][1]',                   \n",
      "                                 (50, 120)]                       'lstm[0][2]']                   \n",
      "                                                                                                  \n",
      " lstm_2 (LSTM)                  (50, 120)            115680      ['lstm_1[0][0]',                 \n",
      "                                                                  'lstm_1[0][1]',                 \n",
      "                                                                  'lstm_1[0][2]']                 \n",
      "                                                                                                  \n",
      " dense (Dense)                  (50, 253077)         30622317    ['lstm_2[0][0]']                 \n",
      "                                                                                                  \n",
      "==================================================================================================\n",
      "Total params: 32,940,213\n",
      "Trainable params: 32,940,213\n",
      "Non-trainable params: 0\n",
      "__________________________________________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "seq_input = Input((seq_length,), batch_size=BATCH_SIZE)\n",
    "x = embedding (seq_input)\n",
    "for i, lstm in enumerate(lstm_list):\n",
    "  if i == 0:\n",
    "    x, state_h, state_c = lstm (x)\n",
    "  else: \n",
    "    x, state_h, state_c = lstm (x, initial_state=[state_h, state_c])  \n",
    "x = lstm_final (x, initial_state=[state_h, state_c])\n",
    "output = dense(x)\n",
    "\n",
    "model = Model(inputs=seq_input, outputs=output, name=\"rnn\")\n",
    "model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plot_model(model, \"my_first_model.png\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# for input_example_batch, target_example_batch in train_dataset.take(1):\n",
    "#     example_batch_predictions = model(input_example_batch)\n",
    "#     print(example_batch_predictions.shape, \"# (batch_size, sequence_length, vocab_size)\")\n",
    "#     print(example_batch_predictions)\n",
    "#     print(target_example_batch)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# sampled_indices = random.categorical(example_batch_predictions, num_samples=1)\n",
    "# sampled_indices = squeeze(sampled_indices, axis=-1).numpy()\n",
    "# sampled_indices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# print(\"Input:\\n\", words_from_ids(input_example_batch[0]))\n",
    "# print()\n",
    "# print(\"Next Char Predictions:\\n\", words_from_ids(sampled_indices))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "loss = losses.SparseCategoricalCrossentropy(from_logits=True)\n",
    "# loss = tf.losses.BinaryCrossentropy(from_logits=True)\n",
    "metric = metrics.SparseCategoricalAccuracy(name='accuracy')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# example_batch_mean_loss = loss(target_example_batch, example_batch_predictions)\n",
    "# print(\"Prediction shape: \", example_batch_predictions.shape, \" # (batch_size, sequence_length, vocab_size)\")\n",
    "# print(\"Mean loss:        \", example_batch_mean_loss)\n",
    "# exp(example_batch_mean_loss).numpy()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tensorflow (Training)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "from keras.callbacks import ModelCheckpoint\n",
    "from tensorflow import train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.compile(optimizer='adam', loss=loss, metrics=metric)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Directory where the checkpoints will be saved\n",
    "checkpoint_dir = './training_checkpoints'\n",
    "# Name of the checkpoint files\n",
    "checkpoint_prefix = os.path.join(checkpoint_dir, \"ckpt_{epoch}\")\n",
    "\n",
    "checkpoint_callback = ModelCheckpoint(\n",
    "    filepath=checkpoint_prefix,\n",
    "    save_weights_only=True)\n",
    "\n",
    "         "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tensorflow.python.training.tracking.util.CheckpointLoadStatus at 0x2eabc1cd0>"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "latest = train.latest_checkpoint(checkpoint_dir)\n",
    "model.load_weights(latest)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/4\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/dany/.local/share/virtualenvs/cuba-digital-lang-9Kd57kqM/lib/python3.9/site-packages/tensorflow/python/util/dispatch.py:1082: UserWarning: \"`sparse_categorical_crossentropy` received `from_logits=True`, but the `output` argument was produced by a sigmoid or softmax activation and thus does not represent logits. Was this intended?\"\n",
      "  return dispatch_target(*args, **kwargs)\n",
      "2022-06-09 00:12:36.534297: W tensorflow/core/platform/profile_utils/cpu_utils.cc:128] Failed to get CPU frequency: 0 Hz\n",
      "2022-06-09 00:12:36.538920: I tensorflow/core/grappler/optimizers/custom_graph_optimizer_registry.cc:113] Plugin optimizer for device_type GPU is enabled.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9404/9404 [==============================] - ETA: 0s - loss: 4.0291 - accuracy: 0.3254"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-06-09 04:16:10.442053: I tensorflow/core/grappler/optimizers/custom_graph_optimizer_registry.cc:113] Plugin optimizer for device_type GPU is enabled.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9404/9404 [==============================] - 14918s 2s/step - loss: 4.0291 - accuracy: 0.3254 - val_loss: 6.3637 - val_accuracy: 0.1960\n",
      "Epoch 2/4\n",
      "7757/9404 [=======================>......] - ETA: 42:55 - loss: 3.6919 - accuracy: 0.3638"
     ]
    }
   ],
   "source": [
    "history = model.fit(\n",
    "    train_dataset, \n",
    "    epochs=4, \n",
    "    callbacks=[checkpoint_callback], \n",
    "    validation_data=val_dataset\n",
    ")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'model' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m/Users/dany/src/school/cuba-digital-lang/generative_rnn.ipynb Cell 27'\u001b[0m in \u001b[0;36m<cell line: 1>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> <a href='vscode-notebook-cell:/Users/dany/src/school/cuba-digital-lang/generative_rnn.ipynb#ch0000026?line=0'>1</a>\u001b[0m loss, accuracy \u001b[39m=\u001b[39m model\u001b[39m.\u001b[39mevaluate(test_dataset)\n\u001b[1;32m      <a href='vscode-notebook-cell:/Users/dany/src/school/cuba-digital-lang/generative_rnn.ipynb#ch0000026?line=2'>3</a>\u001b[0m \u001b[39mprint\u001b[39m(\u001b[39m\"\u001b[39m\u001b[39mLoss: \u001b[39m\u001b[39m\"\u001b[39m, loss)\n\u001b[1;32m      <a href='vscode-notebook-cell:/Users/dany/src/school/cuba-digital-lang/generative_rnn.ipynb#ch0000026?line=3'>4</a>\u001b[0m \u001b[39mprint\u001b[39m(\u001b[39m\"\u001b[39m\u001b[39mAccuracy: \u001b[39m\u001b[39m\"\u001b[39m, accuracy)\n",
      "\u001b[0;31mNameError\u001b[0m: name 'model' is not defined"
     ]
    }
   ],
   "source": [
    "loss, accuracy = model.evaluate(test_dataset)\n",
    "\n",
    "print(\"Loss: \", loss)\n",
    "print(\"Accuracy: \", accuracy)\n",
    "\n",
    "history_dict = history.history\n",
    "history_dict.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "acc = history_dict['accuracy']\n",
    "val_acc = history_dict['val_accuracy']\n",
    "loss = history_dict['loss']\n",
    "val_loss = history_dict['val_loss']\n",
    "\n",
    "epochs = range(1, len(acc) + 1)\n",
    "\n",
    "plt.plot(epochs, loss, 'b', label='Training loss')\n",
    "plt.plot(epochs, val_loss, 'r', label='Validation loss')\n",
    "plt.title('Training and validation loss')\n",
    "plt.xlabel('Epochs')\n",
    "plt.ylabel('Loss')\n",
    "plt.legend()\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(epochs, acc, 'b', label='Training acc')\n",
    "plt.plot(epochs, val_acc, 'r', label='Validation acc')\n",
    "plt.title('Training and validation accuracy')\n",
    "plt.xlabel('Epochs')\n",
    "plt.ylabel('Accuracy')\n",
    "plt.legend(loc='lower right')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "cuba-digital-lang",
   "language": "python",
   "name": "cuba-digital-lang"
  },
  "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.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}