MLP with MNIST.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# MLP\n",
    "\n",
    "In this tutorial, we will use Keras and MNIST dataset.\n",
    "  \n",
    "  \n",
    "MNIST dataset is a opensource dataset for hand writing.\n",
    "Each image is in size 28 x 28 pixel.\n",
    "  \n",
    "\n",
    "Before we start get into Keras, let's prepare some visualize methods."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "from IPython.display import Image\n",
    "\n",
    "def show_images(images: list) -> None:\n",
    "    n: int = len(images)\n",
    "    f = plt.figure()\n",
    "    for i in range(n):        \n",
    "        f.add_subplot(1, n, i + 1)\n",
    "        plt.imshow(images[i], cmap='gray')\n",
    "    plt.show(block=True)\n",
    "    \n",
    "def show_image(image) -> None:\n",
    "    plt.imshow(image, cmap='gray')\n",
    "    plt.show(block=True)\n",
    "    \n",
    "def show_online_image(target_url):\n",
    "    # Image(url= \"https://gluon.mxnet.io/_images/dcgan.png\")\n",
    "    Image(url= target_url)\n",
    "    \n",
    "def plot_images_labels_prediction(images,labels,prediction,idx,num=10):\n",
    "    fig=plt.gcf()\n",
    "    fig.set_size_inches(12, 14)\n",
    "    if num > 25: num=25\n",
    "    for i in range(0, num):\n",
    "        ax=plt.subplot(5, 5, i+1)\n",
    "        ax.imshow(images[idx], cmap='binary')\n",
    "        title=\"label=\" + str(labels[idx])\n",
    "        if len(prediction) > 0:\n",
    "            title += \",predict=\" + str(prediction[idx])\n",
    "        ax.set_title(title, fontsize=10)\n",
    "        ax.set_xticks([]);\n",
    "        ax.set_yticks([]);\n",
    "        idx += 1\n",
    "    plt.show()\n",
    "    \n",
    "def show_train_history(train_history):\n",
    "    fig=plt.gcf()\n",
    "    fig.set_size_inches(16, 6)\n",
    "    plt.subplot(121)\n",
    "    print(train_history.history.keys())\n",
    "    \n",
    "    if \"accuracy\" in train_history.history.keys():\n",
    "        plt.plot(train_history.history[\"accuracy\"])\n",
    "    \n",
    "    if \"val_accuracy\" in train_history.history.keys():\n",
    "        plt.plot(train_history.history[\"val_accuracy\"])\n",
    "        \n",
    "    plt.title(\"Train History\")\n",
    "    plt.xlabel(\"Epoch\")\n",
    "    plt.ylabel(\"Accuracy\")\n",
    "    plt.legend([\"train\", \"validation\"], loc=\"upper left\")\n",
    "    plt.subplot(122)\n",
    "    \n",
    "    if \"loss\" in train_history.history.keys():\n",
    "        plt.plot(train_history.history[\"loss\"])\n",
    "        \n",
    "    if \"val_loss\" in train_history.history.keys():\n",
    "        plt.plot(train_history.history[\"val_loss\"])\n",
    "        \n",
    "    plt.title(\"Train History\")\n",
    "    plt.xlabel(\"Epoch\")\n",
    "    plt.ylabel(\"Loss\")\n",
    "    plt.legend([\"train\", \"validation\"], loc=\"upper left\")\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Load and check your datas\n",
    "You can load your dataset from Keras directly.\n",
    "Let's check how it looks like."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 10 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "number of training images: 60000\n",
      "number of test images: 10000\n"
     ]
    }
   ],
   "source": [
    "from tensorflow import keras\n",
    "from keras.datasets import mnist\n",
    "\n",
    "(x_train, y_train), (x_test, y_test) = mnist.load_data()\n",
    "\n",
    "# print out first 10 images in our training data\n",
    "imgplot = show_images(x_train[0:10])\n",
    "\n",
    "# check the size of our dataset\n",
    "print(\"number of training images:\",x_train.shape[0])\n",
    "print(\"number of test images:\",y_test.shape[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we know the how many images we have in training data, and we know the structure of MLP.  \n",
    "  \n",
    "**How to make image into MLP input?**    \n",
    "Simply, we make it into a vector."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "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": [
    "sample = x_train[0]\n",
    "\n",
    "# origin image\n",
    "show_image(sample)\n",
    "\n",
    "# input of MLP, a images were transfer into a vector\n",
    "show_image(sample.reshape(1, 28 * 28))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# update all the training, testing dataset.\n",
    "x_train = x_train.reshape(60000, 28*28)\n",
    "x_test = x_test.reshape(10000, 28*28)\n",
    "x_train = x_train.astype('float32')\n",
    "x_test = x_test.astype('float32')\n",
    "\n",
    "# normalize them into range [0, 1]\n",
    "x_train /= 255\n",
    "x_test /= 255"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Why Normalize need to divide by 255 for image?**  \n",
    "\n",
    "In computer vision, the color space were \n",
    "R \\[0,255\\]\n",
    "G \\[0,255\\]\n",
    "B \\[0,255\\]\n",
    "\n",
    "While we use gray images, the color space of R G B were same.  \n",
    "We can take color space \\[3, High, Weight\\] of an image as\n",
    "\\[1, High, Weight\\].  \n",
    "Same as \\[H, W\\]  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Prepare your first model  \n",
    "  \n",
    "In Keras, you can create model layers like a Queue.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential_1\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "dense_3 (Dense)              (None, 256)               200960    \n",
      "_________________________________________________________________\n",
      "dense_4 (Dense)              (None, 256)               65792     \n",
      "_________________________________________________________________\n",
      "dense_5 (Dense)              (None, 10)                2570      \n",
      "=================================================================\n",
      "Total params: 269,322\n",
      "Trainable params: 269,322\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "from tensorflow.keras import layers\n",
    "\n",
    "num_classes = 10\n",
    "\n",
    "# create a Sequential model\n",
    "model = keras.Sequential(\n",
    "    [\n",
    "        # input layer. input data with size 28*28 and output size 256\n",
    "        # 256 means you set up your modul with 256 NN in this layer. This value is up to you.\n",
    "        layers.Dense(256, input_shape=(28*28,), activation='relu'), \n",
    "        \n",
    "        # hidden layer. input data with size 256, which were same to output of input layer.\n",
    "        # output size 256, we set up 256 NN again in this hidden layer.\n",
    "        # no need to give input size here because keras already know.\n",
    "        layers.Dense(256, activation='relu'),\n",
    "        \n",
    "        # output layer. the number of output should be your number of classification\n",
    "        layers.Dense(num_classes, activation='softmax')\n",
    "    ]\n",
    ");\n",
    "\n",
    "# print out model structure\n",
    "model.summary()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**What we have in our model is:**  \n",
    "input layer: input size = 28*28+1, output size = 256.  we have totally (28*28+1)* 256 = 200960 parameters.  \n",
    "hidden layer: input size = 256 + 1, output size = 256. we have totally (256+1)* 256   = 65792 parameters.  \n",
    "output layer:input size = 256 + 1, output size = 10.   we have totally (256+1)* 10    = 2570 parameters.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Compile your model\n",
    "We can now move on to compile our model.  \n",
    "Here are the parameters:  \n",
    "- optimizer : how to optimize your weights.\n",
    "- loss : loss function.\n",
    "- metrics : how to evaluate your model.\n",
    "\n",
    "we don't disscuss how to select your optimizer and loss here. :)  \n",
    "Let's introduce 2 important setting in Machine Learning.\n",
    "- Batch : there are 2 ways to update your weights in model  \n",
    "    - update everytime after watching **an** input.\n",
    "    - update once after watching **batch** of inputs.  \n",
    "      \n",
    "    here we update once for 1000 inputs.  \n",
    "- Epochs : how many times you want to look overwhole your datas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 48000 samples, validate on 12000 samples\n",
      "Epoch 1/10\n",
      "48000/48000 [==============================] - 6s 129us/sample - loss: 0.2197 - accuracy: 0.9340 - val_loss: 0.1113 - val_accuracy: 0.9671\n",
      "Epoch 2/10\n",
      "48000/48000 [==============================] - 6s 119us/sample - loss: 0.0888 - accuracy: 0.9728 - val_loss: 0.0903 - val_accuracy: 0.9742\n",
      "Epoch 3/10\n",
      "48000/48000 [==============================] - 6s 119us/sample - loss: 0.0626 - accuracy: 0.9797 - val_loss: 0.0935 - val_accuracy: 0.9731\n",
      "Epoch 4/10\n",
      "48000/48000 [==============================] - 6s 118us/sample - loss: 0.0467 - accuracy: 0.9851 - val_loss: 0.0906 - val_accuracy: 0.9749\n",
      "Epoch 5/10\n",
      "48000/48000 [==============================] - 6s 122us/sample - loss: 0.0351 - accuracy: 0.9888 - val_loss: 0.0929 - val_accuracy: 0.9764\n",
      "Epoch 6/10\n",
      "48000/48000 [==============================] - 7s 139us/sample - loss: 0.0291 - accuracy: 0.9905 - val_loss: 0.1253 - val_accuracy: 0.9694\n",
      "Epoch 7/10\n",
      "48000/48000 [==============================] - 6s 126us/sample - loss: 0.0240 - accuracy: 0.9916 - val_loss: 0.1389 - val_accuracy: 0.9701\n",
      "Epoch 8/10\n",
      "48000/48000 [==============================] - 6s 126us/sample - loss: 0.0215 - accuracy: 0.9931 - val_loss: 0.1377 - val_accuracy: 0.9694\n",
      "Epoch 9/10\n",
      "48000/48000 [==============================] - 6s 129us/sample - loss: 0.0207 - accuracy: 0.9932 - val_loss: 0.1080 - val_accuracy: 0.9775\n",
      "Epoch 10/10\n",
      "48000/48000 [==============================] - 6s 128us/sample - loss: 0.0182 - accuracy: 0.9943 - val_loss: 0.1445 - val_accuracy: 0.9706\n"
     ]
    }
   ],
   "source": [
    "model.compile(optimizer='adam', \n",
    "              loss='sparse_categorical_crossentropy', \n",
    "              metrics=['accuracy'])\n",
    "\n",
    "batch_size = 256\n",
    "epochs = 10\n",
    "history = model.fit(x_train, y_train,\n",
    "                    epochs=epochs,\n",
    "                    validation_split=0.2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Check result of model\n",
    "\n",
    "How it works on testing data?  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test loss: 0.10330415646746806\n",
      "Test accuracy: 0.9756\n"
     ]
    }
   ],
   "source": [
    "scores, acc = model.evaluate(x_test, y_test, verbose=0)\n",
    "print('Test loss:', scores)\n",
    "print('Test accuracy:', acc)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "  \n",
    "It looks nice!   \n",
    "  \n",
    "Let's visualize our result by printing out 25 images of label and predict result."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test prediction: [7 2 1 ... 4 5 6]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x1008 with 25 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "prediction = model.predict_classes(x_test)\n",
    "print('Test prediction:', prediction)\n",
    "\n",
    "i = 0  # start from 0\n",
    "j = 25 # end at 25\n",
    "\n",
    "(_, _), (x_test_image, y_test_label) = mnist.load_data()\n",
    "plot_images_labels_prediction(x_test_image,y_test_label,prediction,i,j)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys(['loss', 'accuracy', 'val_loss', 'val_accuracy'])\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x432 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#show train history\n",
    "show_train_history(history)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th>predict</th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "      <th>3</th>\n",
       "      <th>4</th>\n",
       "      <th>5</th>\n",
       "      <th>6</th>\n",
       "      <th>7</th>\n",
       "      <th>8</th>\n",
       "      <th>9</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>label</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>969</td>\n",
       "      <td>0</td>\n",
       "      <td>2</td>\n",
       "      <td>2</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>4</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>5</td>\n",
       "      <td>1115</td>\n",
       "      <td>4</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>5</td>\n",
       "      <td>0</td>\n",
       "      <td>4</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1024</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>4</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>5</td>\n",
       "      <td>996</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>4</td>\n",
       "      <td>3</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>935</td>\n",
       "      <td>0</td>\n",
       "      <td>8</td>\n",
       "      <td>2</td>\n",
       "      <td>5</td>\n",
       "      <td>28</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>2</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>23</td>\n",
       "      <td>0</td>\n",
       "      <td>855</td>\n",
       "      <td>6</td>\n",
       "      <td>0</td>\n",
       "      <td>2</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>2</td>\n",
       "      <td>2</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "      <td>950</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>2</td>\n",
       "      <td>4</td>\n",
       "      <td>15</td>\n",
       "      <td>5</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>989</td>\n",
       "      <td>3</td>\n",
       "      <td>9</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>2</td>\n",
       "      <td>0</td>\n",
       "      <td>10</td>\n",
       "      <td>12</td>\n",
       "      <td>0</td>\n",
       "      <td>4</td>\n",
       "      <td>3</td>\n",
       "      <td>2</td>\n",
       "      <td>939</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>3</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>8</td>\n",
       "      <td>3</td>\n",
       "      <td>2</td>\n",
       "      <td>3</td>\n",
       "      <td>0</td>\n",
       "      <td>5</td>\n",
       "      <td>984</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "predict    0     1     2    3    4    5    6    7    8    9\n",
       "label                                                      \n",
       "0        969     0     2    2    0    1    4    1    1    0\n",
       "1          5  1115     4    1    0    0    5    0    4    1\n",
       "2          0     0  1024    1    1    0    1    1    4    0\n",
       "3          0     0     5  996    0    0    0    4    3    2\n",
       "4          1     2     1    0  935    0    8    2    5   28\n",
       "5          2     0     0   23    0  855    6    0    2    4\n",
       "6          2     2     0    1    1    2  950    0    0    0\n",
       "7          2     4    15    5    1    0    0  989    3    9\n",
       "8          2     0    10   12    0    4    3    2  939    2\n",
       "9          3     1     0    8    3    2    3    0    5  984"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "\n",
    "# create confusion matrix\n",
    "pd.crosstab(y_test_label, prediction, rownames=['label'],colnames=['predict'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[jovian] Saving notebook..\n"
     ]
    },
    {
     "data": {
      "application/javascript": [
       "window.require && require([\"base/js/namespace\"],function(Jupyter){Jupyter.notebook.save_checkpoint()})"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[jovian] Updating notebook \"a3852a58642848449cc8fe84bb745c52\" on https://jvn.io\n",
      "[jovian] Uploading notebook..\n",
      "[jovian] Capturing environment..\n",
      "[jovian] Committed successfully! https://jvn.io/littlenine/a3852a58642848449cc8fe84bb745c52\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[jovian] Error: Failed to read Anaconda environment using command: \"conda env export -n base --no-builds\"\n"
     ]
    }
   ],
   "source": [
    "import jovian\n",
    "jovian.commit()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}