Deep CNN.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "W0fp4xr40ezm"
      },
      "source": [
        "## Autoencoder\n",
        "\n",
        "An autoencoder is an unsupervised learning technique for neural networks that learns efficient data representations (encoding) by training the network to ignore signal “noise.” Autoencoders can be used for image denoising, image compression, and, in some cases, even generation of image data."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "p9lekBx91fNW"
      },
      "source": [
        "## Flow of Encoder Decoder\n",
        "\n",
        "Input Image -> Encoder -> Compressed Representation -> Decoder -> Reconstruct Input Image"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "S9KVxNq313dP"
      },
      "source": [
        "## Import Modules"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": []
    },
    {
      "cell_type": "code",
      "execution_count": 14,
      "metadata": {
        "id": "8dcyQ4LdzZ67"
      },
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "from tensorflow import keras\n",
        "from keras.layers import Dense, Conv2D, MaxPooling2D, UpSampling2D, Input, InputLayer, Flatten, Reshape, BatchNormalization\n",
        "from keras.datasets import cifar10, mnist\n",
        "from keras.models import Sequential, Model"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Zrk-gzKi3Bao"
      },
      "source": [
        "## Load the Dataset"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 15,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xzcqbkq22SzH",
        "outputId": "89e7d729-e218-42dc-cebe-bcb0e43b1e9b"
      },
      "outputs": [],
      "source": [
        "(x_train, _), (x_test, _) = cifar10.load_data()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 16,
      "metadata": {
        "id": "BIBjnr4m3Eel"
      },
      "outputs": [],
      "source": [
        "# normalize the image data\n",
        "x_train = x_train.astype('float32') / 255\n",
        "x_test= x_test.astype('float32') / 255"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9ty4-fZH3VaV",
        "outputId": "15a6be85-4805-4305-9355-6e7db0277c19"
      },
      "outputs": [],
      "source": [
        "# reshape in the input data for the model\n",
        "x_train = x_train.reshape(len(x_train), 32, 32, 3)\n",
        "x_test = x_test.reshape(len(x_test), 32, 32, 3)\n",
        "# x_train /= 255\n",
        "# np.reshape(x_train_orig, newshape=(x_train_orig.shape[0], np.prod(x_train_orig.shape[1:])))\n",
        "# x_test /= 255\n",
        "# np.reshape(x_test_orig, newshape=(x_test_orig.shape[0], np.prod(x_test_orig.shape[1:])))\n",
        "x_test.shape"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 17,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "(10000, 32, 32, 3)"
            ]
          },
          "execution_count": 17,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "x_train = x_train.reshape(len(x_train),x_train.shape[1],x_train.shape[2],3)\n",
        "x_test = x_test.reshape(len(x_test), x_test.shape[1],x_test.shape[2],3)\n",
        "# x_train = x_train.reshape(len(x_train), 28, 28, 1)\n",
        "# x_test = x_test.reshape(len(x_test), 28, 28, 1)\n",
        "x_test.shape"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6UuBLkW25p3-"
      },
      "source": [
        "## Exploratory Data Analysis"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 18,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 265
        },
        "id": "JOiKQEwy5sKJ",
        "outputId": "650c07c7-27ac-4949-97bd-294f7cd2c134"
      },
      "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": [
        "# randomly select input image\n",
        "index = np.random.randint(len(x_train))\n",
        "# plot the image\n",
        "plt.imshow(x_train[index])\n",
        "plt.gray()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 265
        },
        "id": "aVgOVNBI6Jd-",
        "outputId": "86dae652-0ea7-4cb4-a303-edda90c4ae74"
      },
      "outputs": [],
      "source": [
        "# randomly select input image\n",
        "index = np.random.randint(len(x_test))\n",
        "# plot the image\n",
        "plt.imshow(x_test[index])\n",
        "plt.gray()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 265
        },
        "id": "yZVfPgit5sIG",
        "outputId": "0276b31d-de29-40bd-fac2-db8fbcc17a37"
      },
      "outputs": [],
      "source": [
        "# randomly select input image\n",
        "index = np.random.randint(len(x_test))\n",
        "# plot the image\n",
        "plt.imshow(x_test[index].reshape(28,28))\n",
        "plt.gray()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Aa7xtFlW56v_"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1KGiURME3-qH"
      },
      "source": [
        "## Model Creation"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "def show_image(x):\n",
        "    plt.imshow(np.clip(x + 0.5, 0, 1))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "def apply_gaussian_noise(X, sigma=0.1):\n",
        "    noise = np.random.normal(loc=0.0, scale=sigma, size=X.shape)\n",
        "    return X + noise"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Y4XiApan38tv",
        "outputId": "b0d9a5da-8fef-411c-df13-ea31fcb8481f"
      },
      "outputs": [],
      "source": [
        "\n",
        "def build_autoencoder(input_img):\n",
        "    #encoder\n",
        "    encoder = Conv2D(16, kernel_size=3, activation='relu', padding='same')(input_img)\n",
        "    encoder = MaxPooling2D(2, padding='same')(encoder)\n",
        "    \n",
        "    encoder = Conv2D(8, kernel_size=3, activation='relu', padding='same')(encoder)\n",
        "    encoder = MaxPooling2D(2, padding='same')(encoder)\n",
        "    encoder = Conv2D(8, kernel_size=3, activation='relu', padding='same')(encoder)\n",
        "    encoded = MaxPooling2D(2, padding='same', name='encoder')(encoder)\n",
        "\n",
        "    #decoder\n",
        "    decoder = Conv2D(32, kernel_size=3,strides=1, activation='relu', padding='same')(encoded)\n",
        "    # decoder= BatchNormalization()\n",
        "    decoder = UpSampling2D(2)(decoder)\n",
        "    decoder = Conv2D(8, kernel_size=3,strides=1, activation='relu', padding='same')(decoder)\n",
        "    decoder = UpSampling2D(2)(decoder)\n",
        "    # decoder= BatchNormalization()\n",
        "    decoder = Conv2D(16, kernel_size=3, strides=1,activation='relu',padding='same')(decoder)\n",
        "    decoder = UpSampling2D(2)(decoder)\n",
        "    decoded = Conv2D(3, kernel_size=1,strides=1, activation='sigmoid', padding='same')(decoder)\n",
        "\n",
        "#    model.add(Conv2D(32, kernel_size=3, strides=1, padding='same', activation='relu'))      # 16x16x32\n",
        "\n",
        "# model.add(BatchNormalization())     # 16x16x32\n",
        "# model.add(UpSampling2D())\n",
        "# model.add(Conv2D(32, kernel_size=3, strides=1, padding='same', activation='relu'))      # 32x32x32\n",
        "# model.add(BatchNormalization())\n",
        "\n",
        "#     model.add(Conv2D(32, kernel_size=3, strides=1, padding='same', activation='relu', input_shape=(32, 32, 3)))\n",
        "# model.add(BatchNormalization())     # 32x32x32\n",
        "# model.add(Conv2D(32, kernel_size=3, strides=2, padding='same', activation='relu'))      # 16x16x32\n",
        "# model.add(Conv2D(32, kernel_size=3, strides=1, padding='same', activation='relu'))      # 16x16x32\n",
        "\n",
        "# model.add(BatchNormalization())     # 16x16x32\n",
        "# model.add(UpSampling2D())\n",
        "# model.add(Conv2D(32, kernel_size=3, strides=1, padding='same', activation='relu'))      # 32x32x32\n",
        "# model.add(BatchNormalization())\n",
        "# model.add(Conv2D(3,  kernel_size=1, strides=1, padding='same', activation='sigmoid'))   # 32x32x3\n",
        "\n",
        "# model.compile(optimizer='adam', metrics=['accuracy'], loss='mean_squared_error')\n",
        "# model.summary()\n",
        "\n",
        "    return encoded, decoded"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Y4XiApan38tv",
        "outputId": "b0d9a5da-8fef-411c-df13-ea31fcb8481f"
      },
      "outputs": [],
      "source": [
        "IMG_SHAPE = x_test.shape[1:]\n",
        "# inp = Input(IMG_SHAPE)\n",
        "input_img = Input(shape=(28,28,1))\n",
        "encoder, decoder = build_autoencoder(input_img)\n",
        "\n",
        "# code = encoder(input_img)\n",
        "# reconstruction = decoder(code)\n",
        "# autoencoder = Model(inp,reconstruction)\n",
        "# autoencoder.compile(optimizer='adamax', loss='mse')\n",
        "autoencoder = Model(input_img,decoder)\n",
        "autoencoder.compile(optimizer='adam', metrics=['accuracy'], loss='mean_squared_error')\n",
        "print(autoencoder.summary())\n",
        "# print(autoencoder.summary())"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "# train the model\n",
        "history = autoencoder.fit(x=x_train, y=x_train, epochs=1, batch_size=256, validation_data=(x_test, x_test))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "plt.figure(figsize=(40,4))\n",
        "for i in range(10):\n",
        "    # display original images\n",
        "    ax = plt.subplot(3, 20, i + 1)\n",
        "    plt.imshow(x_test[i].reshape(32, 32,3))\n",
        "    #plt.gray()\n",
        "    ax.get_xaxis().set_visible(False)\n",
        "    ax.get_yaxis().set_visible(False)\n",
        "    \n",
        "\n",
        "    \n",
        "    # display reconstructed images\n",
        "    ax = plt.subplot(3, 20, 2*20 +i+ 1)\n",
        "    plt.imshow(pred[i].reshape(32, 32,3))\n",
        "    #plt.gray()\n",
        "    ax.get_xaxis().set_visible(False)\n",
        "    ax.get_yaxis().set_visible(False)\n",
        "  \n",
        "    \n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "def visualize(img,encoder,decoder):\n",
        "    \"\"\"Draws original, encoded and decoded images\"\"\"\n",
        "    # img[None] will have shape of (1, 32, 32, 3) which is the same as the model input\n",
        "    code = autoencoder.predict(img[None])[0]\n",
        "    reco = autoencoder.predict(code[None])[0]\n",
        "\n",
        "    plt.subplot(1,3,1)\n",
        "    plt.title(\"Original\")\n",
        "    show_image(img)\n",
        "\n",
        "    plt.subplot(1,3,2)\n",
        "    plt.title(\"Code\")\n",
        "    plt.imshow(code.reshape([code.shape[-1]//2,-1]))\n",
        "\n",
        "    plt.subplot(1,3,3)\n",
        "    plt.title(\"Reconstructed\")\n",
        "    show_image(reco)\n",
        "    plt.show()\n",
        "\n",
        "for i in range(5):\n",
        "    img = x_test[i]\n",
        "    visualize(img,encoder,decoder)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "# for i in range(25):\n",
        "#     print(\"Epoch %i/25, Generating corrupted samples...\"%(i+1))\n",
        "#     X_train_noise = apply_gaussian_noise(x_train)\n",
        "#     X_test_noise = apply_gaussian_noise(x_test)\n",
        "#     img = X_test_noise[i]\n",
        "#     visualize(img,encoder,decoder)\n",
        "    # We continue to train our model with new noise-augmented data\n",
        "autoencoder.fit(x=x_train, y=x_train, epochs=1,\n",
        "                    validation_data=[x_train, x_test])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VNlBUXuX5YCo",
        "outputId": "e22e000c-d893-40cd-ddea-2a912cfb0211"
      },
      "outputs": [],
      "source": [
        "# train the model\n",
        "history = autoencoder.fit(x=x_train, y=x_train, epochs=1, batch_size=256, validation_data=(x_test, x_test))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "plt.plot(history.history['loss'])\n",
        "plt.plot(history.history['val_loss'])\n",
        "plt.title('model loss')\n",
        "plt.ylabel('loss')\n",
        "plt.xlabel('epoch')\n",
        "plt.legend(['train', 'test'], loc='upper left')\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nz1_i-Qx696G"
      },
      "source": [
        "## Visualize the Results"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "# predict the results from model (get compressed images)\n",
        "pred = autoencoder.predict(x_test)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 19,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Model: \"sequential_2\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " conv2d_17 (Conv2D)          (None, 32, 32, 32)        896       \n",
            "                                                                 \n",
            " batch_normalization_6 (Batc  (None, 32, 32, 32)       128       \n",
            " hNormalization)                                                 \n",
            "                                                                 \n",
            " conv2d_18 (Conv2D)          (None, 16, 16, 32)        9248      \n",
            "                                                                 \n",
            " conv2d_19 (Conv2D)          (None, 16, 16, 32)        9248      \n",
            "                                                                 \n",
            " batch_normalization_7 (Batc  (None, 16, 16, 32)       128       \n",
            " hNormalization)                                                 \n",
            "                                                                 \n",
            " up_sampling2d_5 (UpSampling  (None, 32, 32, 32)       0         \n",
            " 2D)                                                             \n",
            "                                                                 \n",
            " conv2d_20 (Conv2D)          (None, 32, 32, 32)        9248      \n",
            "                                                                 \n",
            " batch_normalization_8 (Batc  (None, 32, 32, 32)       128       \n",
            " hNormalization)                                                 \n",
            "                                                                 \n",
            " conv2d_21 (Conv2D)          (None, 32, 32, 3)         99        \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 29,123\n",
            "Trainable params: 28,931\n",
            "Non-trainable params: 192\n",
            "_________________________________________________________________\n"
          ]
        }
      ],
      "source": [
        "# model = Sequential([\n",
        "#                     # encoder network\n",
        "#                     Conv2D(32, 3, activation='relu', padding='same', input_shape=(32, 32, 3)),\n",
        "#                     MaxPooling2D(2, padding='same'),\n",
        "#                     Conv2D(16, 3, activation='relu', padding='same'),\n",
        "#                     MaxPooling2D(2, padding='same'),\n",
        "#                     # decoder network\n",
        "#                     Conv2D(16, 3, activation='relu', padding='same'),\n",
        "#                     UpSampling2D(2),\n",
        "#                     Conv2D(32, 3, activation='relu', padding='same'),\n",
        "#                     UpSampling2D(2),\n",
        "#                     # output layer\n",
        "#                     Conv2D(1, 3, activation='sigmoid', padding='same')\n",
        "# ])\n",
        "model = Sequential()\n",
        "model.add(Conv2D(32, kernel_size=3, strides=1, padding='same', activation='relu', input_shape=(32, 32, 3)))\n",
        "model.add(BatchNormalization())     # 32x32x32\n",
        "model.add(Conv2D(32, kernel_size=3, strides=2, padding='same', activation='relu'))      # 16x16x32\n",
        "model.add(Conv2D(32, kernel_size=3, strides=1, padding='same', activation='relu'))      # 16x16x32\n",
        "\n",
        "model.add(BatchNormalization())     # 16x16x32\n",
        "model.add(UpSampling2D())\n",
        "model.add(Conv2D(32, kernel_size=3, strides=1, padding='same', activation='relu'))      # 32x32x32\n",
        "model.add(BatchNormalization())\n",
        "model.add(Conv2D(3,  kernel_size=1, strides=1, padding='same', activation='sigmoid'))   # 32x32x3\n",
        "\n",
        "model.compile(optimizer='adam', metrics=['accuracy'], loss='mean_squared_error')\n",
        "model.summary()\n",
        "\n",
        "# model.compile(optimizer='adam', loss='binary_crossentropy')\n",
        "# model.summary()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 20,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "196/196 [==============================] - 111s 564ms/step - loss: 0.0077 - accuracy: 0.6695 - val_loss: 0.0260 - val_accuracy: 0.6287\n"
          ]
        }
      ],
      "source": [
        "# train the model\n",
        "historyModel = model.fit(x=x_train, y=x_train, epochs=1, batch_size=256, validation_data=(x_test, x_test))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 21,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "313/313 [==============================] - 4s 13ms/step\n"
          ]
        }
      ],
      "source": [
        "predicted = model.predict(x_test)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 23,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 2880x288 with 20 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "plt.figure(figsize=(40,4))\n",
        "for i in range(10):\n",
        "    # display original images\n",
        "    ax = plt.subplot(3, 20, i + 1)\n",
        "    plt.imshow(x_test[i].reshape(32, 32,3))\n",
        "    #plt.gray()\n",
        "    ax.get_xaxis().set_visible(False)\n",
        "    ax.get_yaxis().set_visible(False)\n",
        "    \n",
        "\n",
        "    \n",
        "    # display reconstructed images\n",
        "    ax = plt.subplot(3, 20, 2*20 +i+ 1)\n",
        "    plt.imshow(predicted[i].reshape(32, 32,3))\n",
        "    #plt.gray()\n",
        "    ax.get_xaxis().set_visible(False)\n",
        "    ax.get_yaxis().set_visible(False)\n",
        "  \n",
        "    \n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "6-abSf-97r-e"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 265
        },
        "id": "7UXekdR36ul-",
        "outputId": "0106f407-ab6f-4500-ca68-201aab89e0d6"
      },
      "outputs": [],
      "source": [
        "# randomly select input image\n",
        "index = np.random.randint(len(x_test))\n",
        "# plot the image\n",
        "plt.imshow(x_test[index])\n",
        "plt.gray()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 265
        },
        "id": "h_N4yIde7iMH",
        "outputId": "7244dea3-75e8-4b0f-caf2-de60d0b733fa"
      },
      "outputs": [],
      "source": [
        "# visualize compressed image\n",
        "plt.imshow(pred[index])\n",
        "plt.gray()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 252
        },
        "id": "I4MX_ELk77nf",
        "outputId": "78d89ed3-9536-41ee-e237-d6f056b6ef5b"
      },
      "outputs": [],
      "source": [
        "index = np.random.randint(len(x_test))\n",
        "plt.figure(figsize=(10, 4))\n",
        "# display original image\n",
        "ax = plt.subplot(1, 2, 1)\n",
        "plt.imshow(x_test[index])\n",
        "plt.gray()\n",
        "ax.get_xaxis().set_visible(False)\n",
        "ax.get_yaxis().set_visible(False)\n",
        "# display compressed image\n",
        "ax = plt.subplot(1, 2, 2)\n",
        "plt.imshow(pred[index])\n",
        "plt.gray()\n",
        "ax.get_xaxis().set_visible(False)\n",
        "ax.get_yaxis().set_visible(False)\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 252
        },
        "id": "nQdnu-eD8pzv",
        "outputId": "16cc5a00-36ab-49ce-8b9b-969cd2996f9b"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Performance Metrics\n",
        "\n",
        "Performance Metrics helps to measure the compression performances. Below are some metrics used to measure the performance of the model.   "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "from skimage.metrics import structural_similarity as ssim\n",
        "from skimage.metrics import mean_squared_error as mse\n",
        "from skimage.metrics import peak_signal_noise_ratio as psnr\n",
        "from skimage import io"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "def calculate_mse(imageA, imageB):\n",
        "\treturn mse(imageA, imageB)\n",
        "\n",
        "def calculate_psnr(imageA, imageB):\n",
        "\treturn psnr(imageA, imageB)\n",
        "\n",
        "def calculate_ssim(imageA, imageB):\n",
        "\treturn ssim(imageA, imageB)\n",
        "\n",
        "def compression_ratio(original, compressed):\n",
        "\treturn (original.size) / (compressed.size)\n",
        "\n",
        "def compare_images(original, compressed, title):\n",
        "\t# compute the mean squared error, peak signal noise ratio and structural similarity\n",
        "\n",
        "\tfig, axes = plt.subplots(nrows=1, ncols=2, figsize=(10, 4), sharex=True, sharey=True)\n",
        "\tax = axes.ravel()\n",
        "\n",
        "\t# setup the figure\n",
        "\tax[0].imshow(original, cmap=plt.cm.gray)\n",
        "\tax[0].set_xlabel(f'MSE: {calculate_mse(original,original):.3f}, SSIM: {calculate_ssim(original,original):.3f}')\n",
        "\tax[0].set_title('Original image')\n",
        "\n",
        "\tax[1].imshow(compressed, cmap=plt.cm.gray)\n",
        "\tax[1].set_xlabel(f'MSE: {calculate_mse(original,compressed):.3f}, PSNR: {calculate_psnr(original,compressed):.3f}, SSIM: {calculate_ssim(original,compressed):.3f}')\n",
        "\tax[1].set_title('Compressed image')\n",
        "\n",
        "\tplt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "# initialize the figure\n",
        "fig = plt.figure(\"Images\")\n",
        "index  = np.random.randint(len(x_test))\n",
        "original = np.squeeze(x_test[index].reshape(28,28))\n",
        "compressed = np.squeeze(pred[index].reshape(28,28))\n",
        "images = (\"Original\", original), (\"Compressed\", compressed)\n",
        "# loop over the images\n",
        "for (i, (name, image)) in enumerate(images):\n",
        "\t# show the image\n",
        "\tax = fig.add_subplot(1, 3, i + 1)\n",
        "\tax.set_title(name)\n",
        "\tplt.imshow(image, cmap = plt.cm.gray)\n",
        "\tplt.axis(\"off\")\n",
        "# show the figure\n",
        "plt.show()\n",
        "\n",
        "#compare image quality\n",
        "compare_images(original, compressed, \"Original vs. Compressed\")\n",
        "\n",
        "#calculate compression ratio\n",
        "cr = \"{:.4f}\".format(compression_ratio(original, compressed))\n",
        "print(cr)"
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "collapsed_sections": [],
      "name": "Deep CNN Autoencoder - Image Compression.ipynb",
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3.9.12 ('base')",
      "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.9.12"
    },
    "vscode": {
      "interpreter": {
        "hash": "40d3a090f54c6569ab1632332b64b2c03c39dcf918b08424e98f38b5ae0af88f"
      }
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}