Sign Language Multi Classification.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "wYtuKeK0dImp"
   },
   "outputs": [],
   "source": [
    "# ATTENTION: Please do not alter any of the provided code in the exercise. Only add your own code where indicated\n",
    "# ATTENTION: Please do not add or remove any cells in the exercise. The grader will check specific cells based on the cell position.\n",
    "# ATTENTION: Please use the provided epoch values when training.\n",
    "\n",
    "import csv\n",
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "from tensorflow.keras.preprocessing.image import ImageDataGenerator\n",
    "from os import getcwd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "4kxw-_rmcnVu"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(27455, 28, 28)\n",
      "(27455,)\n",
      "(7172, 28, 28)\n",
      "(7172,)\n"
     ]
    }
   ],
   "source": [
    "def get_data(filename):\n",
    "  # You will need to write code that will read the file passed\n",
    "  # into this function. The first line contains the column headers\n",
    "  # so you should ignore it\n",
    "  # Each successive line contians 785 comma separated values between 0 and 255\n",
    "  # The first value is the label\n",
    "  # The rest are the pixel values for that picture\n",
    "  # The function will return 2 np.array types. One with all the labels\n",
    "  # One with all the images\n",
    "  #\n",
    "  # Tips: \n",
    "  # If you read a full line (as 'row') then row[0] has the label\n",
    "  # and row[1:785] has the 784 pixel values\n",
    "  # Take a look at np.array_split to turn the 784 pixels into 28x28\n",
    "  # You are reading in strings, but need the values to be floats\n",
    "  # Check out np.array().astype for a conversion\n",
    "    with open(filename) as training_file:\n",
    "        csv_reader = csv.reader(training_file, delimiter=',')\n",
    "        first_line = True\n",
    "        temp_images = []\n",
    "        temp_labels = []\n",
    "        for row in csv_reader:\n",
    "            if first_line:\n",
    "                # print(\"Ignoring first line\")\n",
    "                first_line = False\n",
    "            else:\n",
    "                temp_labels.append(row[0])\n",
    "                image_data = row[1:785]\n",
    "                image_data_as_array = np.array_split(image_data, 28)\n",
    "                temp_images.append(image_data_as_array)\n",
    "        images = np.array(temp_images).astype('float')\n",
    "        labels = np.array(temp_labels).astype('float')\n",
    "    return images, labels\n",
    "\n",
    "path_sign_mnist_train = f\"{getcwd()}/../tmp2/sign_mnist_train.csv\"\n",
    "path_sign_mnist_test = f\"{getcwd()}/../tmp2/sign_mnist_test.csv\"\n",
    "training_images, training_labels = get_data(path_sign_mnist_train)\n",
    "testing_images, testing_labels = get_data(path_sign_mnist_test)\n",
    "\n",
    "# Keep these\n",
    "print(training_images.shape)\n",
    "print(training_labels.shape)\n",
    "print(testing_images.shape)\n",
    "print(testing_labels.shape)\n",
    "\n",
    "# Their output should be:\n",
    "# (27455, 28, 28)\n",
    "# (27455,)\n",
    "# (7172, 28, 28)\n",
    "# (7172,)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "awoqRpyZdQkD"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(27455, 28, 28, 1)\n",
      "(7172, 28, 28, 1)\n"
     ]
    }
   ],
   "source": [
    "# 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",
    "\n",
    "training_images = np.expand_dims(training_images, axis=3)\n",
    "testing_images = np.expand_dims(testing_images, axis=3)\n",
    "\n",
    "# Create an ImageDataGenerator and do Image Augmentation\n",
    "train_datagen = ImageDataGenerator(\n",
    "    rescale=1. / 255,\n",
    "    rotation_range=40,\n",
    "    width_shift_range=0.2,\n",
    "    height_shift_range=0.2,\n",
    "    shear_range=0.2,\n",
    "    zoom_range=0.2,\n",
    "    horizontal_flip=True,\n",
    "    fill_mode='nearest')\n",
    "    \n",
    "\n",
    "validation_datagen = ImageDataGenerator(\n",
    "    rescale=1. / 255)\n",
    "    \n",
    "# Keep These\n",
    "print(training_images.shape)\n",
    "print(testing_images.shape)\n",
    "    \n",
    "# Their output should be:\n",
    "# (27455, 28, 28, 1)\n",
    "# (7172, 28, 28, 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Rmb7S32cgRqS"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/2\n",
      "858/857 [==============================] - 72s 84ms/step - loss: 2.7745 - accuracy: 0.1629 - val_loss: 1.8656 - val_accuracy: 0.3832\n",
      "Epoch 2/2\n",
      "858/857 [==============================] - 65s 75ms/step - loss: 2.0215 - accuracy: 0.3653 - val_loss: 1.1987 - val_accuracy: 0.6011\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[205.20694635224223, 0.38190183]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Define the model\n",
    "# Use no more than 2 Conv2D and 2 MaxPooling2D\n",
    "model = tf.keras.models.Sequential([\n",
    "        tf.keras.layers.Conv2D(64, (3, 3), activation='relu', input_shape=(28, 28, 1)),\n",
    "    tf.keras.layers.MaxPooling2D(2, 2),\n",
    "    tf.keras.layers.Conv2D(64, (3, 3), activation='relu'),\n",
    "    tf.keras.layers.MaxPooling2D(2, 2),\n",
    "    tf.keras.layers.Flatten(),\n",
    "    tf.keras.layers.Dense(128, activation=tf.nn.relu),\n",
    "    tf.keras.layers.Dense(26, activation=tf.nn.softmax)])\n",
    "    \n",
    "\n",
    "# Compile Model. \n",
    "model.compile(optimizer = 'adam',\n",
    "              loss = 'sparse_categorical_crossentropy',\n",
    "              metrics=['accuracy'])\n",
    "\n",
    "# Train the Model\n",
    "history = model.fit_generator(train_datagen.flow(training_images, training_labels, batch_size=32),\n",
    "                              steps_per_epoch=len(training_images) / 32,\n",
    "                              epochs=2,\n",
    "                              validation_data=validation_datagen.flow(testing_images, testing_labels, batch_size=32),\n",
    "                              validation_steps=len(testing_images) / 32)\n",
    "\n",
    "model.evaluate(testing_images, testing_labels, verbose=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "_Q3Zpr46dsij"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot the chart for accuracy and loss on both training and validation\n",
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\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()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Submission Instructions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Now click the 'Submit Assignment' button above."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# When you're done or would like to take a break, please run the two cells below to save your work and close the Notebook. This will free up resources for your fellow learners. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%javascript\n",
    "<!-- Save the notebook -->\n",
    "IPython.notebook.save_checkpoint();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%javascript\n",
    "IPython.notebook.session.delete();\n",
    "window.onbeforeunload = null\n",
    "setTimeout(function() { window.close(); }, 1000);"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "name": "Exercise 8 - Question.ipynb",
   "provenance": []
  },
  "coursera": {
   "course_slug": "convolutional-neural-networks-tensorflow",
   "graded_item_id": "8mIh8",
   "launcher_item_id": "gg95t"
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}