C2/W4/assignment/C2W4_Assignment.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/hobbang2/TensorFlowCertification/blob/main/C2/W4/assignment/C2W4_Assignment.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0l5n9ToXGbRC"
      },
      "source": [
        "# Week 4: Multi-class Classification\n",
        "\n",
        "Welcome to this assignment! In this exercise, you will get a chance to work on a multi-class classification problem. You will be using the [Sign Language MNIST](https://www.kaggle.com/datamunge/sign-language-mnist) dataset, which contains 28x28 images of hands depicting the 26 letters of the english alphabet. \n",
        "\n",
        "You will need to pre-process the data so that it can be fed into your convolutional neural network to correctly classify each image as the letter it represents.\n",
        "\n",
        "\n",
        "Let's get started!"
      ],
      "id": "0l5n9ToXGbRC"
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "2ku1p7bdFf6f",
        "outputId": "18744dc9-00ef-4c4c-94b2-8bdd713dd7c0",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Reading package lists... Done\n",
            "Building dependency tree       \n",
            "Reading state information... Done\n",
            "libcudnn8 is already the newest version (8.4.1.50-1+cuda11.6).\n",
            "The following package was automatically installed and is no longer required:\n",
            "  libnvidia-common-460\n",
            "Use 'apt autoremove' to remove it.\n",
            "0 upgraded, 0 newly installed, 0 to remove and 18 not upgraded.\n"
          ]
        }
      ],
      "source": [
        "# Install this package to use Colab's GPU for training\n",
        "!apt install --allow-change-held-packages libcudnn8=8.4.1.50-1+cuda11.6"
      ],
      "id": "2ku1p7bdFf6f"
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "wYtuKeK0dImp",
        "tags": [
          "graded"
        ]
      },
      "outputs": [],
      "source": [
        "import csv\n",
        "import string\n",
        "import numpy as np\n",
        "import tensorflow as tf\n",
        "import matplotlib.pyplot as plt\n",
        "from tensorflow.keras.preprocessing.image import ImageDataGenerator, array_to_img"
      ],
      "id": "wYtuKeK0dImp"
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-zwAPcriH40C"
      },
      "source": [
        "Download the training and test sets (the test set will actually be used as a validation set):"
      ],
      "id": "-zwAPcriH40C"
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lydsaiTvaRhI",
        "outputId": "2d643d89-1772-42cf-fd4b-39d52ae23d3f",
        "tags": []
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/gdown/cli.py:131: FutureWarning: Option `--id` was deprecated in version 4.3.1 and will be removed in 5.0. You don't need to pass it anymore to use a file ID.\n",
            "  category=FutureWarning,\n",
            "Downloading...\n",
            "From: https://drive.google.com/uc?id=1z0DkA9BytlLxO1C0BAWzknLyQmZAp0HR\n",
            "To: /content/sign_mnist_train.csv\n",
            "100% 83.3M/83.3M [00:00<00:00, 208MB/s]\n",
            "/usr/local/lib/python3.7/dist-packages/gdown/cli.py:131: FutureWarning: Option `--id` was deprecated in version 4.3.1 and will be removed in 5.0. You don't need to pass it anymore to use a file ID.\n",
            "  category=FutureWarning,\n",
            "Downloading...\n",
            "From: https://drive.google.com/uc?id=1z1BIj4qmri59GWBG4ivMNFtpZ4AXIbzg\n",
            "To: /content/sign_mnist_test.csv\n",
            "100% 21.8M/21.8M [00:00<00:00, 57.2MB/s]\n"
          ]
        }
      ],
      "source": [
        "# sign_mnist_train.csv\n",
        "!gdown --id 1z0DkA9BytlLxO1C0BAWzknLyQmZAp0HR\n",
        "# sign_mnist_test.csv\n",
        "!gdown --id 1z1BIj4qmri59GWBG4ivMNFtpZ4AXIbzg"
      ],
      "id": "lydsaiTvaRhI"
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tnVJZI96IMh0"
      },
      "source": [
        "Define some globals with the path to both files you just downloaded:"
      ],
      "id": "tnVJZI96IMh0"
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "id": "N3fQlI99JPw9",
        "tags": [
          "graded"
        ]
      },
      "outputs": [],
      "source": [
        "TRAINING_FILE = './sign_mnist_train.csv'\n",
        "VALIDATION_FILE = './sign_mnist_test.csv'"
      ],
      "id": "N3fQlI99JPw9"
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iybvOtoHISHV"
      },
      "source": [
        "Unlike previous assignments, you will not have the actual images provided, instead you will have the data serialized as `csv` files.\n",
        "\n",
        "Take a look at how the data looks like within the `csv` file:"
      ],
      "id": "iybvOtoHISHV"
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ftfeq3JYagks",
        "outputId": "26c887b1-801c-488e-9977-5bfa81e7b3b4",
        "tags": [
          "graded"
        ]
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "First line (header) looks like this:\n",
            "label,pixel1,pixel2,pixel3,pixel4,pixel5,pixel6,pixel7,pixel8,pixel9,pixel10,pixel11,pixel12,pixel13,pixel14,pixel15,pixel16,pixel17,pixel18,pixel19,pixel20,pixel21,pixel22,pixel23,pixel24,pixel25,pixel26,pixel27,pixel28,pixel29,pixel30,pixel31,pixel32,pixel33,pixel34,pixel35,pixel36,pixel37,pixel38,pixel39,pixel40,pixel41,pixel42,pixel43,pixel44,pixel45,pixel46,pixel47,pixel48,pixel49,pixel50,pixel51,pixel52,pixel53,pixel54,pixel55,pixel56,pixel57,pixel58,pixel59,pixel60,pixel61,pixel62,pixel63,pixel64,pixel65,pixel66,pixel67,pixel68,pixel69,pixel70,pixel71,pixel72,pixel73,pixel74,pixel75,pixel76,pixel77,pixel78,pixel79,pixel80,pixel81,pixel82,pixel83,pixel84,pixel85,pixel86,pixel87,pixel88,pixel89,pixel90,pixel91,pixel92,pixel93,pixel94,pixel95,pixel96,pixel97,pixel98,pixel99,pixel100,pixel101,pixel102,pixel103,pixel104,pixel105,pixel106,pixel107,pixel108,pixel109,pixel110,pixel111,pixel112,pixel113,pixel114,pixel115,pixel116,pixel117,pixel118,pixel119,pixel120,pixel121,pixel122,pixel123,pixel124,pixel125,pixel126,pixel127,pixel128,pixel129,pixel130,pixel131,pixel132,pixel133,pixel134,pixel135,pixel136,pixel137,pixel138,pixel139,pixel140,pixel141,pixel142,pixel143,pixel144,pixel145,pixel146,pixel147,pixel148,pixel149,pixel150,pixel151,pixel152,pixel153,pixel154,pixel155,pixel156,pixel157,pixel158,pixel159,pixel160,pixel161,pixel162,pixel163,pixel164,pixel165,pixel166,pixel167,pixel168,pixel169,pixel170,pixel171,pixel172,pixel173,pixel174,pixel175,pixel176,pixel177,pixel178,pixel179,pixel180,pixel181,pixel182,pixel183,pixel184,pixel185,pixel186,pixel187,pixel188,pixel189,pixel190,pixel191,pixel192,pixel193,pixel194,pixel195,pixel196,pixel197,pixel198,pixel199,pixel200,pixel201,pixel202,pixel203,pixel204,pixel205,pixel206,pixel207,pixel208,pixel209,pixel210,pixel211,pixel212,pixel213,pixel214,pixel215,pixel216,pixel217,pixel218,pixel219,pixel220,pixel221,pixel222,pixel223,pixel224,pixel225,pixel226,pixel227,pixel228,pixel229,pixel230,pixel231,pixel232,pixel233,pixel234,pixel235,pixel236,pixel237,pixel238,pixel239,pixel240,pixel241,pixel242,pixel243,pixel244,pixel245,pixel246,pixel247,pixel248,pixel249,pixel250,pixel251,pixel252,pixel253,pixel254,pixel255,pixel256,pixel257,pixel258,pixel259,pixel260,pixel261,pixel262,pixel263,pixel264,pixel265,pixel266,pixel267,pixel268,pixel269,pixel270,pixel271,pixel272,pixel273,pixel274,pixel275,pixel276,pixel277,pixel278,pixel279,pixel280,pixel281,pixel282,pixel283,pixel284,pixel285,pixel286,pixel287,pixel288,pixel289,pixel290,pixel291,pixel292,pixel293,pixel294,pixel295,pixel296,pixel297,pixel298,pixel299,pixel300,pixel301,pixel302,pixel303,pixel304,pixel305,pixel306,pixel307,pixel308,pixel309,pixel310,pixel311,pixel312,pixel313,pixel314,pixel315,pixel316,pixel317,pixel318,pixel319,pixel320,pixel321,pixel322,pixel323,pixel324,pixel325,pixel326,pixel327,pixel328,pixel329,pixel330,pixel331,pixel332,pixel333,pixel334,pixel335,pixel336,pixel337,pixel338,pixel339,pixel340,pixel341,pixel342,pixel343,pixel344,pixel345,pixel346,pixel347,pixel348,pixel349,pixel350,pixel351,pixel352,pixel353,pixel354,pixel355,pixel356,pixel357,pixel358,pixel359,pixel360,pixel361,pixel362,pixel363,pixel364,pixel365,pixel366,pixel367,pixel368,pixel369,pixel370,pixel371,pixel372,pixel373,pixel374,pixel375,pixel376,pixel377,pixel378,pixel379,pixel380,pixel381,pixel382,pixel383,pixel384,pixel385,pixel386,pixel387,pixel388,pixel389,pixel390,pixel391,pixel392,pixel393,pixel394,pixel395,pixel396,pixel397,pixel398,pixel399,pixel400,pixel401,pixel402,pixel403,pixel404,pixel405,pixel406,pixel407,pixel408,pixel409,pixel410,pixel411,pixel412,pixel413,pixel414,pixel415,pixel416,pixel417,pixel418,pixel419,pixel420,pixel421,pixel422,pixel423,pixel424,pixel425,pixel426,pixel427,pixel428,pixel429,pixel430,pixel431,pixel432,pixel433,pixel434,pixel435,pixel436,pixel437,pixel438,pixel439,pixel440,pixel441,pixel442,pixel443,pixel444,pixel445,pixel446,pixel447,pixel448,pixel449,pixel450,pixel451,pixel452,pixel453,pixel454,pixel455,pixel456,pixel457,pixel458,pixel459,pixel460,pixel461,pixel462,pixel463,pixel464,pixel465,pixel466,pixel467,pixel468,pixel469,pixel470,pixel471,pixel472,pixel473,pixel474,pixel475,pixel476,pixel477,pixel478,pixel479,pixel480,pixel481,pixel482,pixel483,pixel484,pixel485,pixel486,pixel487,pixel488,pixel489,pixel490,pixel491,pixel492,pixel493,pixel494,pixel495,pixel496,pixel497,pixel498,pixel499,pixel500,pixel501,pixel502,pixel503,pixel504,pixel505,pixel506,pixel507,pixel508,pixel509,pixel510,pixel511,pixel512,pixel513,pixel514,pixel515,pixel516,pixel517,pixel518,pixel519,pixel520,pixel521,pixel522,pixel523,pixel524,pixel525,pixel526,pixel527,pixel528,pixel529,pixel530,pixel531,pixel532,pixel533,pixel534,pixel535,pixel536,pixel537,pixel538,pixel539,pixel540,pixel541,pixel542,pixel543,pixel544,pixel545,pixel546,pixel547,pixel548,pixel549,pixel550,pixel551,pixel552,pixel553,pixel554,pixel555,pixel556,pixel557,pixel558,pixel559,pixel560,pixel561,pixel562,pixel563,pixel564,pixel565,pixel566,pixel567,pixel568,pixel569,pixel570,pixel571,pixel572,pixel573,pixel574,pixel575,pixel576,pixel577,pixel578,pixel579,pixel580,pixel581,pixel582,pixel583,pixel584,pixel585,pixel586,pixel587,pixel588,pixel589,pixel590,pixel591,pixel592,pixel593,pixel594,pixel595,pixel596,pixel597,pixel598,pixel599,pixel600,pixel601,pixel602,pixel603,pixel604,pixel605,pixel606,pixel607,pixel608,pixel609,pixel610,pixel611,pixel612,pixel613,pixel614,pixel615,pixel616,pixel617,pixel618,pixel619,pixel620,pixel621,pixel622,pixel623,pixel624,pixel625,pixel626,pixel627,pixel628,pixel629,pixel630,pixel631,pixel632,pixel633,pixel634,pixel635,pixel636,pixel637,pixel638,pixel639,pixel640,pixel641,pixel642,pixel643,pixel644,pixel645,pixel646,pixel647,pixel648,pixel649,pixel650,pixel651,pixel652,pixel653,pixel654,pixel655,pixel656,pixel657,pixel658,pixel659,pixel660,pixel661,pixel662,pixel663,pixel664,pixel665,pixel666,pixel667,pixel668,pixel669,pixel670,pixel671,pixel672,pixel673,pixel674,pixel675,pixel676,pixel677,pixel678,pixel679,pixel680,pixel681,pixel682,pixel683,pixel684,pixel685,pixel686,pixel687,pixel688,pixel689,pixel690,pixel691,pixel692,pixel693,pixel694,pixel695,pixel696,pixel697,pixel698,pixel699,pixel700,pixel701,pixel702,pixel703,pixel704,pixel705,pixel706,pixel707,pixel708,pixel709,pixel710,pixel711,pixel712,pixel713,pixel714,pixel715,pixel716,pixel717,pixel718,pixel719,pixel720,pixel721,pixel722,pixel723,pixel724,pixel725,pixel726,pixel727,pixel728,pixel729,pixel730,pixel731,pixel732,pixel733,pixel734,pixel735,pixel736,pixel737,pixel738,pixel739,pixel740,pixel741,pixel742,pixel743,pixel744,pixel745,pixel746,pixel747,pixel748,pixel749,pixel750,pixel751,pixel752,pixel753,pixel754,pixel755,pixel756,pixel757,pixel758,pixel759,pixel760,pixel761,pixel762,pixel763,pixel764,pixel765,pixel766,pixel767,pixel768,pixel769,pixel770,pixel771,pixel772,pixel773,pixel774,pixel775,pixel776,pixel777,pixel778,pixel779,pixel780,pixel781,pixel782,pixel783,pixel784\n",
            "\n",
            "Each subsequent line (data points) look like this:\n",
            "3,107,118,127,134,139,143,146,150,153,156,158,160,163,165,159,166,168,170,170,171,171,171,172,171,171,170,170,169,111,121,129,135,141,144,148,151,154,157,160,163,164,170,119,152,171,171,170,171,172,172,172,172,172,171,171,170,113,123,131,137,142,145,150,152,155,158,161,163,164,172,105,142,170,171,171,171,172,172,173,173,172,171,171,171,116,125,133,139,143,146,151,153,156,159,162,163,167,167,95,144,171,172,172,172,172,172,173,173,173,172,172,171,117,126,134,140,145,149,153,156,158,161,163,164,175,156,87,154,172,173,173,173,173,173,174,174,174,173,172,172,119,128,136,142,146,150,153,156,159,163,165,164,184,148,89,164,172,174,174,174,174,175,175,174,175,174,173,173,122,130,138,143,147,150,154,158,162,165,166,172,181,128,94,170,173,175,174,175,176,177,177,177,177,175,175,174,122,132,139,145,149,152,156,160,163,165,166,181,172,103,113,175,176,178,178,179,179,179,179,178,179,177,175,174,125,134,141,147,150,153,157,161,164,167,168,184,179,116,126,165,176,179,180,180,181,180,180,180,179,178,177,176,128,135,142,148,152,154,158,162,165,168,170,187,180,156,161,124,143,179,178,178,181,182,181,180,181,180,179,179,129,136,144,150,153,155,159,163,166,169,172,187,184,153,102,117,110,175,169,154,182,183,183,182,182,181,181,179,131,138,145,150,155,157,161,165,168,174,190,189,175,146,94,97,113,151,158,129,184,184,184,184,183,183,182,180,131,139,146,151,155,159,163,167,175,182,179,171,159,114,102,89,121,136,136,96,172,186,186,185,185,184,182,181,131,140,147,154,157,160,164,179,186,191,187,180,157,100,88,84,108,111,126,90,120,186,187,187,186,185,184,182,133,141,149,155,158,160,174,201,189,165,151,143,146,120,87,78,87,76,108,98,96,181,188,187,186,186,185,183,133,141,150,156,160,161,179,197,174,135,99,72,95,134,97,72,74,68,116,105,108,187,189,187,187,186,186,185,134,143,151,156,161,163,179,194,156,110,74,42,52,139,94,67,75,75,118,106,129,189,191,190,188,188,187,186,135,144,152,158,163,163,177,193,161,122,84,43,71,134,81,57,71,88,112,98,157,193,193,192,190,190,189,188,136,144,152,158,162,163,176,192,164,128,98,62,60,100,71,76,96,101,105,95,174,195,194,194,194,193,191,190,137,145,152,159,164,165,178,191,164,135,113,82,59,87,98,111,120,108,97,108,190,196,195,195,194,193,193,192,139,146,154,160,164,165,175,186,163,139,112,85,67,102,126,133,126,105,104,176,197,198,197,196,195,195,194,193,138,147,155,161,165,167,172,186,163,137,107,87,76,106,122,125,117,96,156,199,199,200,198,196,196,195,195,194,139,148,156,163,166,168,172,180,158,131,108,99,86,108,118,116,103,107,191,202,201,200,200,200,199,197,198,196,140,149,157,164,168,167,177,178,155,131,118,105,87,100,106,100,96,164,202,202,202,202,202,201,200,199,199,198,140,150,157,165,167,170,181,175,152,130,115,98,82,85,90,99,165,202,203,204,203,203,202,202,201,201,200,200,142,150,159,165,170,191,173,157,144,119,97,84,79,79,91,172,202,203,203,205,204,204,204,203,202,202,201,200,142,151,160,165,188,190,187,150,119,109,85,79,79,78,137,203,205,206,206,207,207,206,206,204,205,204,203,202,142,151,160,172,196,188,188,190,135,96,86,77,77,79,176,205,207,207,207,207,207,207,206,206,206,204,203,202\n",
            "\n"
          ]
        }
      ],
      "source": [
        "with open(TRAINING_FILE) as training_file:\n",
        "  line = training_file.readline()\n",
        "  print(f\"First line (header) looks like this:\\n{line}\")\n",
        "  line = training_file.readline()\n",
        "  print(f\"Each subsequent line (data points) look like this:\\n{line}\")"
      ],
      "id": "ftfeq3JYagks"
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RH23LS7RHA-U"
      },
      "source": [
        "As you can see, each file includes a header (the first line) and each subsequent data point is represented as a line that contains 785 values. \n",
        "\n",
        "The first value is the label (the numeric representation of each letter) and the other 784 values are the value of each pixel of the image. Remember that the original images have a resolution of 28x28, which sums up to 784 pixels."
      ],
      "id": "RH23LS7RHA-U"
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_Slnchp3JkCk"
      },
      "source": [
        " ## Parsing the dataset\n",
        " \n",
        " Now complete the `parse_data_from_input` below.\n",
        "\n",
        " This function should be able to read a file passed as input and return 2 numpy arrays, one containing the labels and one containing the 28x28 representation of each image within the file. These numpy arrays should have type `float64`.\n",
        "\n",
        " A couple of things to keep in mind:\n",
        " \n",
        "- The first line contains the column headers, so you should ignore it.\n",
        "\n",
        "- Each successive line contains 785 comma-separated values between 0 and 255\n",
        "  - The first value is the label\n",
        "\n",
        "  - The rest are the pixel values for that picture\n",
        "\n",
        "  \n",
        "**Hint**:\n",
        "\n",
        "You have two options to solve this function. \n",
        "  \n",
        "   - 1. One is to use `csv.reader` and create a for loop that reads from it, if you take this approach take this into consideration:\n",
        "\n",
        "        - `csv.reader` returns an iterable that returns a row of the csv file in each iteration.\n",
        "    Following this convention, row[0] has the label and row[1:] has the 784 pixel values.\n",
        "\n",
        "        - To reshape the arrays (going from 784 to 28x28), you can use functions such as [`np.array_split`](https://numpy.org/doc/stable/reference/generated/numpy.array_split.html) or [`np.reshape`](https://numpy.org/doc/stable/reference/generated/numpy.reshape.html).\n",
        "\n",
        "        - For type conversion of the numpy arrays, use the method [`np.ndarray.astype`](https://numpy.org/doc/stable/reference/generated/numpy.ndarray.astype.html).\n",
        "\n",
        "\n",
        "   - 2. The other one is to use `np.loadtxt`. You can find the documentation [here](https://numpy.org/doc/stable/reference/generated/numpy.loadtxt.html).\n",
        "   \n",
        "   \n",
        "Regardless of the method you chose, your function should finish its execution in under 1 minute. If you see that your function is taking a long time to run, try changing your implementation."
      ],
      "id": "_Slnchp3JkCk"
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "cellView": "code",
        "id": "EO3u5NIhdNgE",
        "lines_to_next_cell": 2,
        "tags": [
          "graded"
        ]
      },
      "outputs": [],
      "source": [
        "# GRADED FUNCTION: parse_data_from_input\n",
        "def parse_data_from_input(filename):\n",
        "  \"\"\"\n",
        "  Parses the images and labels from a CSV file\n",
        "  \n",
        "  Args:\n",
        "    filename (string): path to the CSV file\n",
        "    \n",
        "  Returns:\n",
        "    images, labels: tuple of numpy arrays containing the images and labels\n",
        "  \"\"\"\n",
        "  with open(filename) as file:\n",
        "    ### START CODE HERE\n",
        "\n",
        "    # Use csv.reader, passing in the appropriate delimiter\n",
        "    # Remember that csv.reader can be iterated and returns one line in each iteration\n",
        "    csv_reader = csv.reader(file, delimiter=\",\")\n",
        "    next(csv_reader, None)\n",
        "    all_lines = list(csv_reader)\n",
        "\n",
        "    labels = np.array([ row[0] for row in all_lines ]).astype(dtype='float64')\n",
        "    images = np.array([ np.array(row[1:]).reshape((28,28)) for row in all_lines ]).astype(dtype='float64')\n",
        "\n",
        "    ### END CODE HERE\n",
        "\n",
        "    return images, labels"
      ],
      "id": "EO3u5NIhdNgE"
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HeSMXBTUsnhl",
        "outputId": "2db46e29-9f33-4783-9ac4-98078477460c",
        "tags": [
          "graded"
        ]
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Training images has shape: (27455, 28, 28) and dtype: float64\n",
            "Training labels has shape: (27455,) and dtype: float64\n",
            "Validation images has shape: (7172, 28, 28) and dtype: float64\n",
            "Validation labels has shape: (7172,) and dtype: float64\n"
          ]
        }
      ],
      "source": [
        "# Test your function\n",
        "training_images, training_labels = parse_data_from_input(TRAINING_FILE)\n",
        "validation_images, validation_labels = parse_data_from_input(VALIDATION_FILE)\n",
        "\n",
        "print(f\"Training images has shape: {training_images.shape} and dtype: {training_images.dtype}\")\n",
        "print(f\"Training labels has shape: {training_labels.shape} and dtype: {training_labels.dtype}\")\n",
        "print(f\"Validation images has shape: {validation_images.shape} and dtype: {validation_images.dtype}\")\n",
        "print(f\"Validation labels has shape: {validation_labels.shape} and dtype: {validation_labels.dtype}\")"
      ],
      "id": "HeSMXBTUsnhl"
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xwqJykm1JqvK"
      },
      "source": [
        "**Expected Output:**\n",
        "```\n",
        "Training images has shape: (27455, 28, 28) and dtype: float64\n",
        "Training labels has shape: (27455,) and dtype: float64\n",
        "Validation images has shape: (7172, 28, 28) and dtype: float64\n",
        "Validation labels has shape: (7172,) and dtype: float64\n",
        "```"
      ],
      "id": "xwqJykm1JqvK"
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tURDCvUKsXIw"
      },
      "source": [
        "## Visualizing the numpy arrays\n",
        "\n",
        "Now that you have converted the initial csv data into a format that is compatible with computer vision tasks, take a moment to actually see how the images of the dataset look like:"
      ],
      "id": "tURDCvUKsXIw"
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 150
        },
        "id": "BsAH3kVWB1ye",
        "outputId": "d50abb2f-a02a-4779-d5a1-7a7a8a340725",
        "tags": []
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1152x1080 with 10 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "# Plot a sample of 10 images from the training set\n",
        "def plot_categories(training_images, training_labels):\n",
        "  fig, axes = plt.subplots(1, 10, figsize=(16, 15))\n",
        "  axes = axes.flatten()\n",
        "  letters = list(string.ascii_lowercase)\n",
        "\n",
        "  for k in range(10):\n",
        "    img = training_images[k]\n",
        "    img = np.expand_dims(img, axis=-1)\n",
        "    img = array_to_img(img)\n",
        "    ax = axes[k]\n",
        "    ax.imshow(img, cmap=\"Greys_r\")\n",
        "    ax.set_title(f\"{letters[int(training_labels[k])]}\")\n",
        "    ax.set_axis_off()\n",
        "\n",
        "  plt.tight_layout()\n",
        "  plt.show()\n",
        "\n",
        "plot_categories(training_images, training_labels)"
      ],
      "id": "BsAH3kVWB1ye"
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0QNkjIRCN5Kg"
      },
      "source": [
        "## Creating the generators for the CNN\n",
        "\n",
        "Now that you have successfully organized the data in a way that can be easily fed to Keras' `ImageDataGenerator`, it is time for you to code the generators that will yield batches of images, both for training and validation. For this complete the `train_val_generators` function below.\n",
        "\n",
        "Some important notes:\n",
        "\n",
        "- The images in this dataset come in the same resolution so you don't need to set a custom `target_size` in this case. In fact, you can't even do so because this time you will not be using the `flow_from_directory` method (as in previous assignments). Instead you will use the [`flow`](https://www.tensorflow.org/api_docs/python/tf/keras/preprocessing/image/ImageDataGenerator#flow) method.\n",
        "- You need to add the \"color\" dimension to the numpy arrays that encode the images. These are black and white images, so this new dimension should have a size of 1 (instead of 3, which is used when dealing with colored images). Take a look at the function [`np.expand_dims`](https://numpy.org/doc/stable/reference/generated/numpy.expand_dims.html) for this."
      ],
      "id": "0QNkjIRCN5Kg"
    },
    {
      "cell_type": "code",
      "execution_count": 15,
      "metadata": {
        "cellView": "code",
        "id": "9ZDIvKGtNISO",
        "lines_to_next_cell": 2,
        "tags": [
          "graded"
        ]
      },
      "outputs": [],
      "source": [
        "from tensorflow.python.ops.gen_array_ops import shape\n",
        "# GRADED FUNCTION: train_val_generators\n",
        "def train_val_generators(training_images, training_labels, validation_images, validation_labels):\n",
        "  \"\"\"\n",
        "  Creates the training and validation data generators\n",
        "  \n",
        "  Args:\n",
        "    training_images (array): parsed images from the train CSV file\n",
        "    training_labels (array): parsed labels from the train CSV file\n",
        "    validation_images (array): parsed images from the test CSV file\n",
        "    validation_labels (array): parsed labels from the test CSV file\n",
        "    \n",
        "  Returns:\n",
        "    train_generator, validation_generator - tuple containing the generators\n",
        "  \"\"\"\n",
        "  ### START CODE HERE\n",
        "\n",
        "  # In this section you will have to add another dimension to the data\n",
        "  # So, for example, if your array is (10000, 28, 28)\n",
        "  # You will need to make it (10000, 28, 28, 1)\n",
        "  # Hint: np.expand_dims\n",
        "  training_images = np.expand_dims( training_images , axis = -1 )\n",
        "  validation_images =  np.expand_dims( validation_images , axis = -1 )\n",
        "  # Instantiate the ImageDataGenerator class \n",
        "  # Don't forget to normalize pixel values \n",
        "  # and set arguments to augment the images (if desired)\n",
        "  train_datagen = ImageDataGenerator( rescale = 1.0/255.0 ,\n",
        "                                      shear_range = 0.2 , \n",
        "                                      zoom_range = 0.2 ,\n",
        "                                      fill_mode='nearest',)\n",
        "\n",
        "\n",
        "  # Pass in the appropriate arguments to the flow method\n",
        "  train_generator = train_datagen.flow(x=training_images,\n",
        "                                       y=training_labels,\n",
        "                                       batch_size=32) \n",
        "\n",
        "  \n",
        "  # Instantiate the ImageDataGenerator class (don't forget to set the rescale argument)\n",
        "  # Remember that validation data should not be augmented\n",
        "  validation_datagen = ImageDataGenerator( rescale = 1.0/255.0)\n",
        "\n",
        "  # Pass in the appropriate arguments to the flow method\n",
        "  validation_generator = validation_datagen.flow(x=validation_images,\n",
        "                                                 y=validation_labels,\n",
        "                                                 batch_size=32) \n",
        "\n",
        "  ### END CODE HERE\n",
        "\n",
        "  return train_generator, validation_generator"
      ],
      "id": "9ZDIvKGtNISO"
    },
    {
      "cell_type": "code",
      "execution_count": 16,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2oxxBZDwPozr",
        "outputId": "fbb58344-4225-49d5-9bdc-627f7da56e5a",
        "tags": [
          "graded"
        ]
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Images of training generator have shape: (27455, 28, 28, 1)\n",
            "Labels of training generator have shape: (27455,)\n",
            "Images of validation generator have shape: (7172, 28, 28, 1)\n",
            "Labels of validation generator have shape: (7172,)\n"
          ]
        }
      ],
      "source": [
        "# Test your generators\n",
        "train_generator, validation_generator = train_val_generators(training_images, training_labels, validation_images, validation_labels)\n",
        "\n",
        "print(f\"Images of training generator have shape: {train_generator.x.shape}\")\n",
        "print(f\"Labels of training generator have shape: {train_generator.y.shape}\")\n",
        "print(f\"Images of validation generator have shape: {validation_generator.x.shape}\")\n",
        "print(f\"Labels of validation generator have shape: {validation_generator.y.shape}\")"
      ],
      "id": "2oxxBZDwPozr"
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cok5oQa5Rknv"
      },
      "source": [
        "**Expected Output:**\n",
        "```\n",
        "Images of training generator have shape: (27455, 28, 28, 1)\n",
        "Labels of training generator have shape: (27455,)\n",
        "Images of validation generator have shape: (7172, 28, 28, 1)\n",
        "Labels of validation generator have shape: (7172,)\n",
        "```"
      ],
      "id": "cok5oQa5Rknv"
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CkHUj4PsP_jT"
      },
      "source": [
        "## Coding the CNN\n",
        "\n",
        "One last step before training is to define the architecture of the model that will be trained.\n",
        "\n",
        "Complete the `create_model` function below. This function should return a Keras' model that uses the `Sequential` or the `Functional` API.\n",
        "\n",
        "The last layer of your model should have a number of units that corresponds to the number of possible categories, as well as the correct activation function.\n",
        "\n",
        "Aside from defining the architecture of the model, you should also compile it so make sure to use a `loss` function that is suitable for multi-class classification.\n",
        "\n",
        "**Note that you should use no more than 2 Conv2D and 2 MaxPooling2D layers to achieve the desired performance.**"
      ],
      "id": "CkHUj4PsP_jT"
    },
    {
      "cell_type": "code",
      "execution_count": 17,
      "metadata": {
        "cellView": "code",
        "id": "Rmb7S32cgRqS",
        "tags": [
          "graded"
        ]
      },
      "outputs": [],
      "source": [
        "def create_model():\n",
        "\n",
        "  ### START CODE HERE       \n",
        "\n",
        "  # Define the model\n",
        "  # Use no more than 2 Conv2D and 2 MaxPooling2D\n",
        "  img_inputs = tf.keras.Input(shape=(28, 28, 1))\n",
        "  x = tf.keras.layers.Conv2D(kernel_size = (3,3) , filters=16 ,activation='relu')(img_inputs)\n",
        "  x = tf.keras.layers.MaxPooling2D((3,3))(x)\n",
        "  x = tf.keras.layers.Conv2D(kernel_size = (3,3) , filters=32 ,activation='relu')(img_inputs)\n",
        "  x = tf.keras.layers.MaxPooling2D((3,3))(x)\n",
        "  x = tf.keras.layers.Flatten()(x)\n",
        "  x = tf.keras.layers.Dense(512,activation='relu')(x)\n",
        "  x = tf.keras.layers.Dropout(0.2)(x)\n",
        "  predictions = tf.keras.layers.Dense( 26 , activation='softmax')(x)\n",
        "\n",
        "  model = tf.keras.Model( inputs = img_inputs , outputs = predictions )\n",
        "  \n",
        "\n",
        "  model.compile(optimizer = 'adam',\n",
        "                loss = 'sparse_categorical_crossentropy',\n",
        "                metrics=['accuracy'])\n",
        "\n",
        "  ### END CODE HERE       \n",
        "  \n",
        "  return model"
      ],
      "id": "Rmb7S32cgRqS"
    },
    {
      "cell_type": "code",
      "execution_count": 18,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-e7ywtgZS5pU",
        "lines_to_next_cell": 2,
        "outputId": "8cb0c2a4-3821-45ff-d1e7-d73cbfa252bf",
        "tags": []
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/15\n",
            "858/858 [==============================] - 9s 10ms/step - loss: 1.2904 - accuracy: 0.6219 - val_loss: 0.5412 - val_accuracy: 0.8293\n",
            "Epoch 2/15\n",
            "858/858 [==============================] - 9s 11ms/step - loss: 0.3287 - accuracy: 0.9010 - val_loss: 0.3336 - val_accuracy: 0.8949\n",
            "Epoch 3/15\n",
            "858/858 [==============================] - 9s 10ms/step - loss: 0.1557 - accuracy: 0.9570 - val_loss: 0.2593 - val_accuracy: 0.9216\n",
            "Epoch 4/15\n",
            "858/858 [==============================] - 8s 10ms/step - loss: 0.0867 - accuracy: 0.9775 - val_loss: 0.2508 - val_accuracy: 0.9297\n",
            "Epoch 5/15\n",
            "858/858 [==============================] - 9s 11ms/step - loss: 0.0557 - accuracy: 0.9869 - val_loss: 0.2688 - val_accuracy: 0.9110\n",
            "Epoch 6/15\n",
            "858/858 [==============================] - 8s 10ms/step - loss: 0.0378 - accuracy: 0.9907 - val_loss: 0.2395 - val_accuracy: 0.9335\n",
            "Epoch 7/15\n",
            "858/858 [==============================] - 8s 10ms/step - loss: 0.0296 - accuracy: 0.9928 - val_loss: 0.2614 - val_accuracy: 0.9377\n",
            "Epoch 8/15\n",
            "858/858 [==============================] - 8s 10ms/step - loss: 0.0259 - accuracy: 0.9933 - val_loss: 0.2978 - val_accuracy: 0.9327\n",
            "Epoch 9/15\n",
            "858/858 [==============================] - 8s 10ms/step - loss: 0.0190 - accuracy: 0.9952 - val_loss: 0.2646 - val_accuracy: 0.9301\n",
            "Epoch 10/15\n",
            "858/858 [==============================] - 8s 10ms/step - loss: 0.0137 - accuracy: 0.9969 - val_loss: 0.2718 - val_accuracy: 0.9373\n",
            "Epoch 11/15\n",
            "858/858 [==============================] - 8s 10ms/step - loss: 0.0156 - accuracy: 0.9961 - val_loss: 0.2745 - val_accuracy: 0.9360\n",
            "Epoch 12/15\n",
            "858/858 [==============================] - 9s 11ms/step - loss: 0.0158 - accuracy: 0.9955 - val_loss: 0.2280 - val_accuracy: 0.9481\n",
            "Epoch 13/15\n",
            "858/858 [==============================] - 8s 10ms/step - loss: 0.0093 - accuracy: 0.9975 - val_loss: 0.2896 - val_accuracy: 0.9437\n",
            "Epoch 14/15\n",
            "858/858 [==============================] - 8s 10ms/step - loss: 0.0113 - accuracy: 0.9970 - val_loss: 0.2828 - val_accuracy: 0.9420\n",
            "Epoch 15/15\n",
            "858/858 [==============================] - 8s 10ms/step - loss: 0.0107 - accuracy: 0.9969 - val_loss: 0.2297 - val_accuracy: 0.9476\n"
          ]
        }
      ],
      "source": [
        "# Save your model\n",
        "model = create_model()\n",
        "\n",
        "# Train your model\n",
        "history = model.fit(train_generator,\n",
        "                    epochs=15,\n",
        "                    validation_data=validation_generator)"
      ],
      "id": "-e7ywtgZS5pU"
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mmpadXR_WGbK"
      },
      "source": [
        "Now take a look at your training history:"
      ],
      "id": "mmpadXR_WGbK"
    },
    {
      "cell_type": "code",
      "execution_count": 19,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 545
        },
        "id": "_Q3Zpr46dsij",
        "outputId": "38db82a2-0ce5-4f71-bce0-57064d8dcf2c",
        "tags": []
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "# Plot the chart for accuracy and loss on both training and validation\n",
        "acc = history.history['accuracy']\n",
        "val_acc = history.history['val_accuracy']\n",
        "loss = history.history['loss']\n",
        "val_loss = history.history['val_loss']\n",
        "\n",
        "epochs = range(len(acc))\n",
        "\n",
        "plt.plot(epochs, acc, 'r', label='Training accuracy')\n",
        "plt.plot(epochs, val_acc, 'b', label='Validation accuracy')\n",
        "plt.title('Training and validation accuracy')\n",
        "plt.legend()\n",
        "plt.figure()\n",
        "\n",
        "plt.plot(epochs, loss, 'r', label='Training Loss')\n",
        "plt.plot(epochs, val_loss, 'b', label='Validation Loss')\n",
        "plt.title('Training and validation loss')\n",
        "plt.legend()\n",
        "\n",
        "plt.show()"
      ],
      "id": "_Q3Zpr46dsij"
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PdWizvXnXAGz"
      },
      "source": [
        "You will not be graded based on the accuracy of your model but try making it as high as possible for both training and validation, as an optional exercise, **after submitting your notebook for grading**.\n",
        "\n",
        "A reasonable benchmark is to achieve over 99% accuracy for training and over 95% accuracy for validation within 15 epochs. Try tweaking your model's architecture or the augmentation techniques to see if you can achieve these levels of accuracy."
      ],
      "id": "PdWizvXnXAGz"
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uTikUFbYTqBo"
      },
      "source": [
        "You need to submit this notebook for grading. To download it, click on the `File` tab in the upper left corner of the screen then click on `Download` -> `Download .ipynb`. You can name it anything you want as long as it is a valid `.ipynb` (jupyter notebook) file."
      ],
      "id": "uTikUFbYTqBo"
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DmHC02GaTuDg"
      },
      "source": [
        "**Congratulations on finishing this week's assignment!**\n",
        "\n",
        "You have successfully implemented a convolutional neural network that is able to perform multi-class classification tasks! Nice job!\n",
        "\n",
        "**Keep it up!**"
      ],
      "id": "DmHC02GaTuDg"
    }
  ],
  "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": {
      "provenance": [],
      "include_colab_link": true
    }
  },
  "nbformat": 4,
  "nbformat_minor": 5
}