Course 4/Week 2/Week2_Assignment.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "accelerator": "GPU",
    "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.7.4"
    },
    "colab": {
      "name": "Copy of C4W2_Assignment.ipynb",
      "private_outputs": true,
      "provenance": [],
      "collapsed_sections": [],
      "toc_visible": true
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "L6S2HVAkSt0p"
      },
      "source": [
        "# Week 2 Assignment: CIFAR-10 Autoencoder\n",
        "\n",
        "For this week, you will create a convolutional autoencoder for the [CIFAR10](https://www.tensorflow.org/datasets/catalog/cifar10) dataset. You are free to choose the architecture of your autoencoder provided that the output image has the same dimensions as the input image.\n",
        "\n",
        "After training, your model should meet loss and accuracy requirements when evaluated with the test dataset. You will then download the model and upload it in the classroom for grading. \n",
        "\n",
        "Let's begin!"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6r4iPr2jyisR"
      },
      "source": [
        "***Important:*** *This colab notebook has read-only access so you won't be able to save your changes. If you want to save your work periodically, please click `File -> Save a Copy in Drive` to create a copy in your account, then work from there.*  "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "g1mzy2J8_nc1"
      },
      "source": [
        "## Imports"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3EXwoz-KHtWO"
      },
      "source": [
        "try:\n",
        "  # %tensorflow_version only exists in Colab.\n",
        "  %tensorflow_version 2.x\n",
        "except Exception:\n",
        "  pass\n",
        "\n",
        "import tensorflow as tf\n",
        "import tensorflow_datasets as tfds\n",
        "\n",
        "from keras.models import Sequential"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "n2Gs6Lyc_pd0"
      },
      "source": [
        "## Load and prepare the dataset\n",
        "\n",
        "The [CIFAR 10](https://www.tensorflow.org/datasets/catalog/cifar10) dataset already has train and test splits and you can use those in this exercise. Here are the general steps:\n",
        "\n",
        "* Load the train/test split from TFDS. Set `as_supervised` to `True` so it will be convenient to use the preprocessing function we provided.\n",
        "* Normalize the pixel values to the range [0,1], then return `image, image` pairs for training instead of `image, label`. This is because you will check if the output image is successfully regenerated after going through your autoencoder.\n",
        "* Shuffle and batch the train set. Batch the test set (no need to shuffle).\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "t9F7YsCNIKSA"
      },
      "source": [
        "# preprocessing function\n",
        "def map_image(image, label):\n",
        "  image = tf.cast(image, dtype=tf.float32)\n",
        "  image = image / 255.0\n",
        "\n",
        "  return image, image # dataset label is not used. replaced with the same image input.\n",
        "\n",
        "# parameters\n",
        "BATCH_SIZE = 128\n",
        "SHUFFLE_BUFFER_SIZE = 1024\n",
        "\n",
        "\n",
        "### START CODE HERE (Replace instances of `None` with your code) ###\n",
        "\n",
        "# use tfds.load() to fetch the 'train' split of CIFAR-10\n",
        "train_dataset = tfds.load('cifar10', split='train', as_supervised=True)\n",
        "\n",
        "# preprocess the dataset with the `map_image()` function above\n",
        "train_dataset = train_dataset.map(map_image)\n",
        "\n",
        "# shuffle and batch the dataset\n",
        "train_dataset = train_dataset.shuffle(SHUFFLE_BUFFER_SIZE).batch(BATCH_SIZE)\n",
        "\n",
        "\n",
        "# use tfds.load() to fetch the 'test' split of CIFAR-10\n",
        "test_dataset = tfds.load('cifar10', split='test', as_supervised=True)\n",
        "\n",
        "# preprocess the dataset with the `map_image()` function above\n",
        "test_dataset = test_dataset.map(map_image)\n",
        "\n",
        "# batch the dataset\n",
        "test_dataset = test_dataset.batch(BATCH_SIZE)\n",
        "\n",
        "### END CODE HERE ###"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rPyOgGJs_t98"
      },
      "source": [
        "## Build the Model\n",
        "\n",
        "Create the autoencoder model. As shown in the lectures, you will want to downsample the image in the encoder layers then upsample it in the decoder path. Note that the output layer should be the same dimensions as the original image. Your input images will have the shape `(32, 32, 3)`. If you deviate from this, your model may not be recognized by the grader and may fail. \n",
        "\n",
        "We included a few hints to use the Sequential API below but feel free to remove it and use the Functional API just like in the ungraded labs if you're more comfortable with it. Another reason to use the latter is if you want to visualize the encoder output. As shown in the ungraded labs, it will be easier to indicate multiple outputs with the Functional API. That is not required for this assignment though so you can just stack layers sequentially if you want a simpler solution."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Wr-Bok3lRgA3"
      },
      "source": [
        "# suggested layers to use. feel free to add or remove as you see fit.\n",
        "from keras.layers import Conv2D, UpSampling2D\n",
        "\n",
        "# use the Sequential API (you can remove if you want to use the Functional API)\n",
        "model = Sequential()\n",
        "\n",
        "### START CODE HERE ###\n",
        "# use `model.add()` to add layers (if using the Sequential API)\n",
        "model.add(Conv2D(16, kernel_size=3, strides=1, padding='same', activation='relu', input_shape=(32, 32, 3)))\n",
        "model.add(tf.keras.layers.BatchNormalization())     \n",
        "\n",
        "model.add(Conv2D(32, kernel_size=3, strides=2, padding='same', activation='relu'))      \n",
        "\n",
        "model.add(Conv2D(32, kernel_size=3, strides=1, padding='same', activation='relu'))      \n",
        "model.add(tf.keras.layers.BatchNormalization())   \n",
        "\n",
        "model.add(UpSampling2D())\n",
        "model.add(Conv2D(16, kernel_size=3, strides=1, padding='same', activation='relu'))      \n",
        "model.add(tf.keras.layers.BatchNormalization()) \n",
        "\n",
        "model.add(Conv2D(3,  kernel_size=1, strides=1, padding='same', activation='sigmoid'))  \n",
        "\n",
        "### END CODE HERE ###\n",
        "\n",
        "model.summary()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jRWTAijKEVUC"
      },
      "source": [
        "## Configure training parameters\n",
        "\n",
        "We have already provided the optimizer, metrics, and loss in the code below."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iHIeD9eDETSk"
      },
      "source": [
        "# Please do not change the model.compile() parameters\n",
        "model.compile(optimizer='adam', metrics=['accuracy'], loss='mean_squared_error')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tLQPhm1W_8dC"
      },
      "source": [
        "## Training\n",
        "\n",
        "You can now use [model.fit()](https://keras.io/api/models/model_training_apis/#fit-method) to train your model. You will pass in the `train_dataset` and you are free to configure the other parameters. As with any training, you should see the loss generally going down and the accuracy going up with each epoch. If not, please revisit the previous sections to find possible bugs."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AMBimOnsRvg0"
      },
      "source": [
        "# parameters\n",
        "train_steps = len(train_dataset) // BATCH_SIZE \n",
        "val_steps = len(test_dataset) // BATCH_SIZE\n",
        "\n",
        "### START CODE HERE ###\n",
        "model.fit(train_dataset, validation_data=test_dataset, epochs=5)\n",
        "### END CODE HERE ###"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PT2l1c-SAaF4"
      },
      "source": [
        "## Model evaluation\n",
        "\n",
        "You can use this code to test your model locally before uploading to the grader. To pass, your model needs to satisfy these two requirements:\n",
        "\n",
        "* loss must be less than 0.01 \n",
        "* accuracy must be greater than 0.6"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vFncgqahSQhA"
      },
      "source": [
        "result = model.evaluate(test_dataset, steps=10)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "di6VOHGwIsVM"
      },
      "source": [
        "If you did some visualization like in the ungraded labs, then you might see something like the gallery below. This part is not required."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wmpI4skkIA5L"
      },
      "source": [
        "<img src=\"https://drive.google.com/uc?export=view&id=12Fy-guiP-3tTPfc9IV2nHhqLvs7LwRo6\" width=\"75%\" height=\"75%\"/>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uaRSkQPNAPT0"
      },
      "source": [
        "## Save your model\n",
        "\n",
        "Once you are satisfied with the results, you can now save your model. Please download it from the Files window on the left and go back to the Submission portal in Coursera for grading."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pLFpLP-c7rDR"
      },
      "source": [
        "model.save('mymodel.h5')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QArMiXJTDxDe"
      },
      "source": [
        "**Congratulations on completing this week's assignment!**"
      ]
    }
  ]
}