Lab12/Lab12_1_JoongHoonKim.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "18234af5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.5.0\n"
     ]
    }
   ],
   "source": [
    "# setup\n",
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "import matplotlib.pyplot as plt\n",
    "from tensorflow import keras\n",
    "from tensorflow.keras import layers\n",
    "from tensorflow.keras import Sequential, Model\n",
    "from tensorflow.keras.preprocessing.sequence import pad_sequences\n",
    "%matplotlib inline\n",
    "\n",
    "print(tf.__version__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "bee43e5d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['<pad>', ' ', 'a', 'b', 'd', 'e', 'g', 'o', 'r', 's', 'w']\n",
      "{0: '<pad>', 1: ' ', 2: 'a', 3: 'b', 4: 'd', 5: 'e', 6: 'g', 7: 'o', 8: 'r', 9: 's', 10: 'w'}\n",
      "{'<pad>': 0, ' ': 1, 'a': 2, 'b': 3, 'd': 4, 'e': 5, 'g': 6, 'o': 7, 'r': 8, 's': 9, 'w': 10}\n"
     ]
    }
   ],
   "source": [
    "# example data\n",
    "words = ['good', 'bad', 'worse', 'so good']\n",
    "y_data = [1,0,0,1]\n",
    "\n",
    "# creating a token dictionary\n",
    "char_set = ['<pad>'] + sorted(list(set(''.join(words))))\n",
    "idx2char = {idx : char for idx, char in enumerate(char_set)}\n",
    "char2idx = {char : idx for idx, char in enumerate(char_set)}\n",
    "\n",
    "print(char_set)\n",
    "print(idx2char)\n",
    "print(char2idx)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "000c6339",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[6, 7, 7, 4], [3, 2, 4], [10, 7, 8, 9, 5], [9, 7, 1, 6, 7, 7, 4]]\n",
      "[4, 3, 5, 7]\n"
     ]
    }
   ],
   "source": [
    "# converting sequence of tokens to sequence of indices\n",
    "x_data = list(map(lambda word : [char2idx.get(char) for char in word], words))\n",
    "x_data_len = list(map(lambda word : len(word), x_data))\n",
    "\n",
    "print(x_data)\n",
    "print(x_data_len)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "d75991d3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 6  7  7  4  0  0  0  0  0  0]\n",
      " [ 3  2  4  0  0  0  0  0  0  0]\n",
      " [10  7  8  9  5  0  0  0  0  0]\n",
      " [ 9  7  1  6  7  7  4  0  0  0]]\n",
      "[4, 3, 5, 7]\n",
      "[1, 0, 0, 1]\n"
     ]
    }
   ],
   "source": [
    "# padding the sequence of indices\n",
    "max_sequence = 10\n",
    "x_data = pad_sequences(sequences = x_data, maxlen = max_sequence,\n",
    "                       padding = 'post', truncating = 'post')\n",
    "\n",
    "# checking data\n",
    "print(x_data)\n",
    "print(x_data_len)\n",
    "print(y_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "af7cc7b2",
   "metadata": {},
   "outputs": [],
   "source": [
    "# creating simple rnn for \"many to one\" classification\n",
    "input_dim = len(char2idx)\n",
    "output_dim = len(char2idx)\n",
    "one_hot = np.eye(len(char2idx))\n",
    "hidden_size = 10\n",
    "num_classes = 2\n",
    "\n",
    "model = Sequential()\n",
    "model.add(layers.Embedding(input_dim=input_dim, output_dim=output_dim,\n",
    "                           trainable=False, mask_zero=True, input_length=max_sequence,\n",
    "                           embeddings_initializer=keras.initializers.Constant(one_hot)))\n",
    "model.add(layers.SimpleRNN(units=hidden_size))\n",
    "model.add(layers.Dense(units=num_classes))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "6508c305",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "embedding (Embedding)        (None, 10, 11)            121       \n",
      "_________________________________________________________________\n",
      "simple_rnn (SimpleRNN)       (None, 10)                220       \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 2)                 22        \n",
      "=================================================================\n",
      "Total params: 363\n",
      "Trainable params: 242\n",
      "Non-trainable params: 121\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "d95fd0d7",
   "metadata": {},
   "outputs": [],
   "source": [
    "# creating loss function\n",
    "def loss_fn(model, x, y):\n",
    "    return tf.reduce_mean(tf.keras.losses.sparse_categorical_crossentropy(\n",
    "        y_true=y, y_pred=model(x), from_logits=True))\n",
    "\n",
    "# creating an optimizer\n",
    "lr = .01\n",
    "epochs = 30\n",
    "batch_size = 2\n",
    "opt = tf.keras.optimizers.Adam(learning_rate = lr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "fc47af56",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<BatchDataset shapes: ((None, 10), (None,)), types: (tf.int32, tf.int32)>\n"
     ]
    }
   ],
   "source": [
    "# generating data pipeline\n",
    "tr_dataset = tf.data.Dataset.from_tensor_slices((x_data, y_data))\n",
    "tr_dataset = tr_dataset.shuffle(buffer_size = 4)\n",
    "tr_dataset = tr_dataset.batch(batch_size = batch_size)\n",
    "\n",
    "print(tr_dataset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "6eea8b4d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch :   5, tr_loss : 0.266\n",
      "epoch :  10, tr_loss : 0.043\n",
      "epoch :  15, tr_loss : 0.011\n",
      "epoch :  20, tr_loss : 0.005\n",
      "epoch :  25, tr_loss : 0.003\n",
      "epoch :  30, tr_loss : 0.002\n"
     ]
    }
   ],
   "source": [
    "# training\n",
    "tr_loss_hist = []\n",
    "\n",
    "for epoch in range(epochs):\n",
    "    avg_tr_loss = 0\n",
    "    tr_step = 0\n",
    "    \n",
    "    for x_mb, y_mb in tr_dataset:\n",
    "        with tf.GradientTape() as tape:\n",
    "            tr_loss = loss_fn(model, x=x_mb, y=y_mb)\n",
    "        grads = tape.gradient(target=tr_loss, sources=model.variables)\n",
    "        opt.apply_gradients(grads_and_vars=zip(grads, model.variables))\n",
    "        avg_tr_loss += tr_loss\n",
    "        tr_step += 1\n",
    "    else:\n",
    "        avg_tr_loss /= tr_step\n",
    "        tr_loss_hist.append(avg_tr_loss)\n",
    "    \n",
    "    if (epoch + 1) % 5 ==0:        \n",
    "        print('epoch : {:3}, tr_loss : {:.3f}'.format(epoch + 1, avg_tr_loss.numpy()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "fbec8062",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "acc : 100.00%\n"
     ]
    }
   ],
   "source": [
    "yhat = model.predict(x_data)\n",
    "yhat = np.argmax(yhat, axis=-1)\n",
    "print('acc : {:.2%}'.format(np.mean(yhat == y_data)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "59e66d37",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x1d12fd051f0>]"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "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": [
    "plt.plot(tr_loss_hist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d70ffeff",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "py38tensorflow",
   "language": "python",
   "name": "py38tensorflow"
  },
  "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.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}