mninst_digit_recog.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "mninst_digit_recog.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "code",
      "source": [
        "# Install tensorflowjs for download model\n",
        "!pip install tensorflowjs"
      ],
      "metadata": {
        "id": "MeyInzspbra2"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Declare constants\n",
        "EPOCHS: int = 15\n",
        "BATCH_SIZE: int = 128\n",
        "TEST_SIZE: float = 0.1\n",
        "TEST_BATCH_SIZE: int = 64\n",
        "RANDOM_STATE: int = 42\n",
        "NUM_CLASSES: int = 10\n",
        "IMAGE_SHAPE: tuple = (28, 28, 1)"
      ],
      "metadata": {
        "id": "PP-SH1bnh4Wf"
      },
      "execution_count": 138,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from keras.datasets import mnist\n",
        "\n",
        "# Load dataset\n",
        "(x_train, y_train), (x_test, y_test) = mnist.load_data()"
      ],
      "metadata": {
        "id": "ECIezCQPA5uW"
      },
      "execution_count": 133,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "from keras.utils.np_utils import to_categorical\n",
        "from sklearn.model_selection import train_test_split\n",
        "\n",
        "# Normalize images\n",
        "x_train = x_train.astype('float32') / 255.0\n",
        "x_test = x_test.astype('float32') / 255.0\n",
        "\n",
        "# Label encoding\n",
        "y_train = to_categorical(y_train, num_classes=NUM_CLASSES)\n",
        "y_test = to_categorical(y_test, num_classes=NUM_CLASSES)\n",
        "\n",
        "# Split data for validation\n",
        "x_train, x_val, y_train, y_val = train_test_split(x_train,\n",
        "                                                  y_train,\n",
        "                                                  test_size=TEST_SIZE,\n",
        "                                                  random_state=RANDOM_STATE)\n",
        "x_test_copy = np.array(x_test, copy=True)  "
      ],
      "metadata": {
        "id": "pf2yDWrKimAL"
      },
      "execution_count": 134,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Reshape input images (n_samples, w, h, 1)\n",
        "x_train = x_train.reshape(x_train.shape[0], 28, 28, 1)\n",
        "x_val = x_val.reshape(x_val.shape[0], 28, 28, 1)\n",
        "x_test = x_test.reshape(x_test.shape[0], 28, 28, 1)\n",
        "\n",
        "print('|==== Shapes ====|', '\\n')\n",
        "\n",
        "print(f'x_train shape: {x_train.shape}')\n",
        "print(f'y_train shape: {y_train.shape}', '\\n')\n",
        "\n",
        "print(f'x_val shape: {x_val.shape}')\n",
        "print(f'y_val shape: {y_val.shape}', '\\n')\n",
        "\n",
        "print(f'x_test shape: {x_test.shape}')\n",
        "print(f'y_test shape: {y_test.shape}', '\\n')\n",
        "\n",
        "print('|==== Samples ====|', '\\n')\n",
        "\n",
        "print(f'train samples: {x_train.shape[0]}')\n",
        "print(f'validation samples: {x_val.shape[0]}')\n",
        "print(f'test samples: {x_test.shape[0]}', '\\n')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bPCs0W3OkQy4",
        "outputId": "faf73f63-ed6f-472a-d35d-c62ddd6fadbd"
      },
      "execution_count": 135,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "|==== Shapes ====| \n",
            "\n",
            "x_train shape: (54000, 28, 28, 1)\n",
            "y_train shape: (54000, 10) \n",
            "\n",
            "x_val shape: (6000, 28, 28, 1)\n",
            "y_val shape: (6000, 10) \n",
            "\n",
            "x_test shape: (10000, 28, 28, 1)\n",
            "y_test shape: (10000, 10) \n",
            "\n",
            "|==== Samples ====| \n",
            "\n",
            "train samples: 54000\n",
            "validation samples: 6000\n",
            "test samples: 10000 \n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Build the FC model\n",
        "\n",
        "from tensorflow.keras import Input, Sequential, layers\n",
        "\n",
        "print('|==== Building the model... ====|', '\\n')\n",
        "model = Sequential([\n",
        "                    layers.Conv2D(32, kernel_size=(3, 3), activation='relu', input_shape=IMAGE_SHAPE),\n",
        "                    layers.Conv2D(64, (3, 3), activation='relu'),\n",
        "                    layers.MaxPool2D(pool_size=(2, 2)),\n",
        "                    layers.Dropout(0.25),\n",
        "                    layers.Flatten(),\n",
        "                    layers.Dense(128, activation='relu'),\n",
        "                    layers.Dropout(0.5),\n",
        "                    layers.Dense(10, activation='softmax')\n",
        "])\n",
        "\n",
        "model.summary()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YA6cJIgaA_TI",
        "outputId": "1caab5ba-88d6-4461-ee78-2073e1ae6c90"
      },
      "execution_count": 139,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "|==== Building the model... ====| \n",
            "\n",
            "Model: \"sequential_31\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " conv2d_10 (Conv2D)          (None, 26, 26, 32)        320       \n",
            "                                                                 \n",
            " conv2d_11 (Conv2D)          (None, 24, 24, 64)        18496     \n",
            "                                                                 \n",
            " max_pooling2d_6 (MaxPooling  (None, 12, 12, 64)       0         \n",
            " 2D)                                                             \n",
            "                                                                 \n",
            " dropout_23 (Dropout)        (None, 12, 12, 64)        0         \n",
            "                                                                 \n",
            " flatten_6 (Flatten)         (None, 9216)              0         \n",
            "                                                                 \n",
            " dense_24 (Dense)            (None, 128)               1179776   \n",
            "                                                                 \n",
            " dropout_24 (Dropout)        (None, 128)               0         \n",
            "                                                                 \n",
            " dense_25 (Dense)            (None, 10)                1290      \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 1,199,882\n",
            "Trainable params: 1,199,882\n",
            "Non-trainable params: 0\n",
            "_________________________________________________________________\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Train the model\n",
        "\n",
        "from tensorflow.keras.optimizers import Adam\n",
        "\n",
        "adam = Adam()\n",
        "model.compile(loss='categorical_crossentropy',\n",
        "              optimizer=adam, metrics=['accuracy'])\n",
        "\n",
        "print('|==== Training the model... ====|', '\\n')\n",
        "history = model.fit(x_train,\n",
        "                    y_train,\n",
        "                    validation_data=(x_val, y_val),\n",
        "                    epochs=EPOCHS,\n",
        "                    batch_size=BATCH_SIZE)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Iz2aHKlIF7i2",
        "outputId": "dd4c385f-51d4-4a64-dab5-02c4293185bb"
      },
      "execution_count": 140,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "|==== Training the model... ====| \n",
            "\n",
            "Epoch 1/15\n",
            "422/422 [==============================] - 132s 311ms/step - loss: 0.2574 - accuracy: 0.9217 - val_loss: 0.0622 - val_accuracy: 0.9802\n",
            "Epoch 2/15\n",
            "422/422 [==============================] - 131s 311ms/step - loss: 0.0915 - accuracy: 0.9725 - val_loss: 0.0466 - val_accuracy: 0.9857\n",
            "Epoch 3/15\n",
            "422/422 [==============================] - 131s 311ms/step - loss: 0.0681 - accuracy: 0.9796 - val_loss: 0.0374 - val_accuracy: 0.9890\n",
            "Epoch 4/15\n",
            "422/422 [==============================] - 131s 311ms/step - loss: 0.0547 - accuracy: 0.9830 - val_loss: 0.0354 - val_accuracy: 0.9895\n",
            "Epoch 5/15\n",
            "422/422 [==============================] - 132s 313ms/step - loss: 0.0450 - accuracy: 0.9863 - val_loss: 0.0334 - val_accuracy: 0.9898\n",
            "Epoch 6/15\n",
            "422/422 [==============================] - 131s 310ms/step - loss: 0.0410 - accuracy: 0.9870 - val_loss: 0.0336 - val_accuracy: 0.9908\n",
            "Epoch 7/15\n",
            "422/422 [==============================] - 131s 309ms/step - loss: 0.0364 - accuracy: 0.9883 - val_loss: 0.0334 - val_accuracy: 0.9898\n",
            "Epoch 8/15\n",
            "422/422 [==============================] - 130s 308ms/step - loss: 0.0331 - accuracy: 0.9895 - val_loss: 0.0354 - val_accuracy: 0.9912\n",
            "Epoch 9/15\n",
            "422/422 [==============================] - 130s 307ms/step - loss: 0.0290 - accuracy: 0.9906 - val_loss: 0.0303 - val_accuracy: 0.9913\n",
            "Epoch 10/15\n",
            "422/422 [==============================] - 130s 308ms/step - loss: 0.0266 - accuracy: 0.9910 - val_loss: 0.0306 - val_accuracy: 0.9915\n",
            "Epoch 11/15\n",
            "422/422 [==============================] - 130s 307ms/step - loss: 0.0237 - accuracy: 0.9916 - val_loss: 0.0313 - val_accuracy: 0.9922\n",
            "Epoch 12/15\n",
            "422/422 [==============================] - 130s 308ms/step - loss: 0.0213 - accuracy: 0.9929 - val_loss: 0.0319 - val_accuracy: 0.9933\n",
            "Epoch 13/15\n",
            "422/422 [==============================] - 130s 308ms/step - loss: 0.0214 - accuracy: 0.9934 - val_loss: 0.0323 - val_accuracy: 0.9927\n",
            "Epoch 14/15\n",
            "422/422 [==============================] - 130s 308ms/step - loss: 0.0194 - accuracy: 0.9937 - val_loss: 0.0387 - val_accuracy: 0.9918\n",
            "Epoch 15/15\n",
            "422/422 [==============================] - 130s 307ms/step - loss: 0.0174 - accuracy: 0.9937 - val_loss: 0.0388 - val_accuracy: 0.9915\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Evaluate the model\n",
        "\n",
        "from sklearn.metrics import classification_report\n",
        "\n",
        "print('|==== Evaluating the model... ====|', '\\n')\n",
        "\n",
        "target_names = [str(label) for label in range(NUM_CLASSES)]\n",
        "predictions = model.predict(x_test, batch_size=TEST_BATCH_SIZE)\n",
        "report = classification_report(y_test.argmax(axis=1),\n",
        "                               predictions.argmax(axis=1),\n",
        "                               target_names=target_names)\n",
        "print(report, '\\n')\n",
        "\n",
        "scores = model.evaluate(x_test, y_test, verbose=0)\n",
        "print(\"Test accuracy: {:.4f}\".format(scores[1]))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WH7ZBUWJGooD",
        "outputId": "7e47216c-5b56-4e3e-fa15-85f1050a29b8"
      },
      "execution_count": 141,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "|==== Evaluating the model... ====| \n",
            "\n",
            "              precision    recall  f1-score   support\n",
            "\n",
            "           0       0.99      0.99      0.99       980\n",
            "           1       0.99      0.99      0.99      1135\n",
            "           2       0.99      1.00      0.99      1032\n",
            "           3       0.99      1.00      1.00      1010\n",
            "           4       0.99      0.99      0.99       982\n",
            "           5       0.99      0.99      0.99       892\n",
            "           6       0.99      0.99      0.99       958\n",
            "           7       0.99      0.99      0.99      1028\n",
            "           8       0.99      0.99      0.99       974\n",
            "           9       0.99      0.99      0.99      1009\n",
            "\n",
            "    accuracy                           0.99     10000\n",
            "   macro avg       0.99      0.99      0.99     10000\n",
            "weighted avg       0.99      0.99      0.99     10000\n",
            " \n",
            "\n",
            "Test accuracy: 0.9925\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Plot model cost function iterations in training session\n",
        "\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "plt.style.use('ggplot')\n",
        "plt.figure()\n",
        "\n",
        "epoch_values = list(range(EPOCHS))\n",
        "plt.plot(epoch_values, history.history['loss'], label='Cost function at training')\n",
        "plt.plot(epoch_values, history.history['val_loss'], label='Cost function at validation')\n",
        "plt.plot(epoch_values, history.history['accuracy'], label='Accuracy at training')\n",
        "plt.plot(epoch_values, history.history['val_accuracy'], label='Accuracy at validation')\n",
        "\n",
        "plt.title('Training history')\n",
        "plt.xlabel('Epoch N.')\n",
        "plt.ylabel('Loss/accuracy')\n",
        "plt.legend()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 316
        },
        "id": "Vqnqti2fUxlp",
        "outputId": "f25f760c-fe74-45cd-803f-23f807157cd7"
      },
      "execution_count": 142,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.legend.Legend at 0x7f2912ceb990>"
            ]
          },
          "metadata": {},
          "execution_count": 142
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Plot the images in a grid\n",
        "size = 32\n",
        "rows = 4\n",
        "f = plt.figure(figsize=(size // rows, rows + 1))\n",
        "plt.suptitle(\"Test dataset recognition\", fontsize=10)\n",
        "for i in range(size):\n",
        "    sp = f.add_subplot(rows, -(-size // rows), i + 1)\n",
        "    sp.axis('Off')\n",
        "    plt.imshow(x_test_copy[i][:,:], cmap='gray_r')\n",
        "    sp.set_title(predictions[i].argmax(), fontsize=16)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 333
        },
        "id": "tiQflpgfa1jH",
        "outputId": "d51ecd82-3670-4947-db7b-f832ad24152e"
      },
      "execution_count": 144,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 576x360 with 32 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "%rm keras.h5\n",
        "model.save('keras.h5')"
      ],
      "metadata": {
        "id": "AKQMPDk6bI6P"
      },
      "execution_count": 146,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "%rm -r model\n",
        "%mkdir model\n",
        "\n",
        "!tensorflowjs_converter --input_format keras keras.h5 model/"
      ],
      "metadata": {
        "id": "3IUP2u6wbgQA"
      },
      "execution_count": 147,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Download model\n",
        "from google.colab import files\n",
        "!zip -r model.zip model\n",
        "files.download('model.zip')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 86
        },
        "id": "AuepXgg3bh4o",
        "outputId": "fec791c0-6b0b-48d4-ee75-7e6039f55062"
      },
      "execution_count": 148,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "updating: model/ (stored 0%)\n",
            "updating: model/model.json (deflated 78%)\n",
            "  adding: model/group1-shard2of2.bin (deflated 7%)\n",
            "  adding: model/group1-shard1of2.bin (deflated 7%)\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ],
            "application/javascript": [
              "\n",
              "    async function download(id, filename, size) {\n",
              "      if (!google.colab.kernel.accessAllowed) {\n",
              "        return;\n",
              "      }\n",
              "      const div = document.createElement('div');\n",
              "      const label = document.createElement('label');\n",
              "      label.textContent = `Downloading \"${filename}\": `;\n",
              "      div.appendChild(label);\n",
              "      const progress = document.createElement('progress');\n",
              "      progress.max = size;\n",
              "      div.appendChild(progress);\n",
              "      document.body.appendChild(div);\n",
              "\n",
              "      const buffers = [];\n",
              "      let downloaded = 0;\n",
              "\n",
              "      const channel = await google.colab.kernel.comms.open(id);\n",
              "      // Send a message to notify the kernel that we're ready.\n",
              "      channel.send({})\n",
              "\n",
              "      for await (const message of channel.messages) {\n",
              "        // Send a message to notify the kernel that we're ready.\n",
              "        channel.send({})\n",
              "        if (message.buffers) {\n",
              "          for (const buffer of message.buffers) {\n",
              "            buffers.push(buffer);\n",
              "            downloaded += buffer.byteLength;\n",
              "            progress.value = downloaded;\n",
              "          }\n",
              "        }\n",
              "      }\n",
              "      const blob = new Blob(buffers, {type: 'application/binary'});\n",
              "      const a = document.createElement('a');\n",
              "      a.href = window.URL.createObjectURL(blob);\n",
              "      a.download = filename;\n",
              "      div.appendChild(a);\n",
              "      a.click();\n",
              "      div.remove();\n",
              "    }\n",
              "  "
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ],
            "application/javascript": [
              "download(\"download_2ad663f3-5208-45cb-b19e-27d6818fbcd7\", \"model.zip\", 6950250)"
            ]
          },
          "metadata": {}
        }
      ]
    }
  ]
}