ConvNet Project.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "jqVbV_KSw0vL"
   },
   "source": [
    "# Assignment 4: Implementation of ConvNets (start early on this one!)\n",
    "-------------------------------------\n",
    "**Dr. Dave Wanik - OPIM 5509: Introduction to Deep Learning - University of Connecticut**\n",
    "\n",
    "Hi class, this is my first time giving a homework like this on ConvNets, but I think you will really enjoy it since it's practical ConvNet implementation vs. a simple math problem. *If you have any code problems, please post on the Discussion Board so your classmates and I can help!*\n",
    "\n",
    "Below is a great demo script that I found on how to use 'Bing image downloader' with Colab! Please clean up/update the script to download at least 200 images of any two classes you would like to predict (such as 'person wearing mask' and 'person not wearing a mask'). You may need to download a few different search queries if Bing limits you to 100 images - be creative about how you can get more data. The data will download locally onto this runtime (click the folder icon on the left), and you can move files and create new folders for train, test, validation partition. You can delete any unncessary code, of course.\n",
    "\n",
    "We haven't shown how to do this in class, but here's a code that shows you how to copy N images over from train folder to the test folder:\n",
    "* https://stackoverflow.com/questions/60090552/copying-file-from-one-directory-to-another-directory-in-google-colab\n",
    "\n",
    "If you get stuck prepping your data on the local runtime, reach out on the Discussion Board!\n",
    "\n",
    "When you submit your assignment, I should be able to run your ENTIRE script without mounting the Google Drive since everything is locally downloaded and prepared. This will take some extra coding but I think you can hack the stuff below to make it work.\n",
    "\n",
    "After your data is prepared, review my existing scripts and use the image generators to read data and fit a model like we did for Cats and Dogs! You can go as far as you want with this assignment in terms of the modeling but **you must build at least one vanilla ConvNet model and you must evaluate the model** (remember: evaluating a generator can be tricky, see my code for help.) If you want to go above and beyond, try using transfer learning or fine tuning or data augmentation. You will probably get a better fitting model!\n",
    "\n",
    "Of course, your script should be beautifully laid out with lots of subheaders and comments. When you are done with this assignment, it should be of such quality that you would be proud to share this notebook with a potential employer to demonstrate your computer vision skills.\n",
    "\n",
    "**Rubric:**\n",
    "* (10 points) Provide a nice five to ten sentence of the problem you are trying to solve with image classification (please only do binary classification for this assignment.)\n",
    "* (40 points) Image downloader code below has been adapted to work on local runtime. New directories are created for train, test and validation partition of each class.\n",
    "* (20 points) Fit a ConvNet model\n",
    "* (20 points) Evaluate the ConvNet model\n",
    "* (10 points) At least five meaningful, thoughtful bullets of what you learned in this assignment.\n",
    "\n",
    "Severe points will be deducted if the notebook does not have lots of headers, text cells, comments etc. Zero points if the code is not 'run all' in its entirety before submitting (so that I can review the code output!)\n",
    "\n",
    "Ask friends for help but do your own work. I hope you enjoy this assignment.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "iqlCLC9sHCNH"
   },
   "source": [
    "#Problem Statement\n",
    "\n",
    "My goal in this assignment is to implement a ConvNet model to classify images of pizza or ice cream. I will train the model to classify if a given image is an image of pizza or an image of ice cream. This model can be used practically for automated food recognition systems. Automated food recognition systems can be useful for things like, nutrition applications. These systems can be useful for applications that can tell you the nutrition information of your meals just from a picture."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 419,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "H_gXTAIm_aPC",
    "outputId": "d2355571-d168-4fad-a10a-fe5fb06b6965"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: bing-image-downloader in /usr/local/lib/python3.10/dist-packages (1.1.2)\n"
     ]
    }
   ],
   "source": [
    "!pip install bing-image-downloader"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 420,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "6BK5eNGLDn1I",
    "outputId": "a853d564-38cf-4002-ba04-fe94dbc5a747"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "mkdir: cannot create directory ‘images’: File exists\n"
     ]
    }
   ],
   "source": [
    "!mkdir images"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "kg7wgT0-ZLNK"
   },
   "source": [
    "#New directories"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "D0jD8k1Hwc37"
   },
   "outputs": [],
   "source": [
    "#download pizza images for modeling\n",
    "from bing_image_downloader import downloader\n",
    "downloader.download(\"pizza\", limit=200,  output_dir='images', adult_filter_off=True, force_replace=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "-KzJFBSpwheg"
   },
   "outputs": [],
   "source": [
    "#download icecream images for modeling\n",
    "downloader.download(\"icecream\", limit=200,  output_dir='images', adult_filter_off=True, force_replace=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 423,
   "metadata": {
    "id": "jpWRvzkOd1hC"
   },
   "outputs": [],
   "source": [
    "import os\n",
    "import random\n",
    "import shutil\n",
    "\n",
    "#define source directory\n",
    "source_dir = '/content/images/'\n",
    "\n",
    "#define directories for train, test, and validation sets in dataset directory\n",
    "dataset_dir = '/content/dataset/'\n",
    "train_dir = os.path.join(dataset_dir, 'train')\n",
    "test_dir = os.path.join(dataset_dir, 'test')\n",
    "val_dir = os.path.join(dataset_dir, 'validation')\n",
    "\n",
    "#define categories (pizza and icecream)\n",
    "categories = ['pizza', 'icecream']\n",
    "\n",
    "#define split percentages\n",
    "split_percentages = {'train': 0.6, 'test': 0.2, 'validation': 0.2}\n",
    "\n",
    "#copy files to target directory\n",
    "def copy_files(files, target_dir, category):\n",
    "    category_path = os.path.join(target_dir, category)\n",
    "#create category directory\n",
    "    os.makedirs(category_path, exist_ok=True)\n",
    "    for file in files:\n",
    "        src = os.path.join(source_dir, category, file)\n",
    "        if os.path.isfile(src):\n",
    "            cat = os.path.join(category_path, file)\n",
    "            shutil.copy(src, cat)\n",
    "\n",
    "#move images into directories\n",
    "for category in categories:\n",
    "    #list of images for category\n",
    "    category_images = [img for img in os.listdir(os.path.join(source_dir, category)) if os.path.isfile(os.path.join(source_dir, category, img))]\n",
    "    #shuffle images\n",
    "    random.shuffle(category_images)\n",
    "\n",
    "    #calculate split sizes\n",
    "    total_images = len(category_images)\n",
    "    train_size = int(total_images * split_percentages['train'])\n",
    "    test_size = int(total_images * split_percentages['test'])\n",
    "    val_size = total_images - train_size - test_size\n",
    "\n",
    "    #split and copy images for each category\n",
    "    copy_files(category_images[:train_size], train_dir, category)\n",
    "    copy_files(category_images[train_size:train_size + test_size], test_dir, category)\n",
    "    copy_files(category_images[train_size + test_size:], val_dir, category)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "7q7i2Ib-ZUy6"
   },
   "source": [
    "#Fit Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 424,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "OJZ5jyfy9DLu",
    "outputId": "9e9f1838-9b3d-462a-a00e-d06d4af19801"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found 411 images belonging to 2 classes.\n",
      "Found 367 images belonging to 2 classes.\n"
     ]
    }
   ],
   "source": [
    "from keras.preprocessing.image import ImageDataGenerator\n",
    "\n",
    "#all images rescaled by 1./255\n",
    "train_datagen = ImageDataGenerator(rescale=1./255)\n",
    "test_datagen = ImageDataGenerator(rescale=1./255)\n",
    "\n",
    "train_generator = train_datagen.flow_from_directory(\n",
    "\n",
    "        #target directory\n",
    "        train_dir,\n",
    "\n",
    "        #all images resized to 150x150\n",
    "        target_size=(150, 150),\n",
    "\n",
    "        #10 batch\n",
    "        batch_size=10,\n",
    "\n",
    "        #binary labels\n",
    "        class_mode='binary')\n",
    "\n",
    "validation_generator = test_datagen.flow_from_directory(\n",
    "        test_dir,\n",
    "        target_size=(150, 150),\n",
    "        batch_size=10,\n",
    "        class_mode='binary')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 425,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "o04Kjt_NCdhO",
    "outputId": "85ff1500-f7ce-4206-a9af-7b9abf0165b7"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "data batch shape: (10, 150, 150, 3)\n",
      "labels batch shape: (10,)\n"
     ]
    }
   ],
   "source": [
    "for data_batch, labels_batch in train_generator:\n",
    "\n",
    "#print shape of data in batch\n",
    "    print('data batch shape:', data_batch.shape)\n",
    "\n",
    "#print shape of labels in batch\n",
    "    print('labels batch shape:', labels_batch.shape)\n",
    "    break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 426,
   "metadata": {
    "id": "Mic6mDgBBUs3"
   },
   "outputs": [],
   "source": [
    "from keras import layers\n",
    "from keras import models\n",
    "\n",
    "#define ConvNet architecture\n",
    "model = models.Sequential()\n",
    "\n",
    "#convolutional layer and ReLU activation\n",
    "model.add(layers.Conv2D(32, (3, 3), activation='relu',\n",
    "                        input_shape=(150, 150, 3)))\n",
    "\n",
    "#max pooling layer\n",
    "model.add(layers.MaxPooling2D((2, 2)))\n",
    "model.add(layers.Conv2D(64, (3, 3), activation='relu'))\n",
    "model.add(layers.MaxPooling2D((2, 2)))\n",
    "model.add(layers.Conv2D(128, (3, 3), activation='relu'))\n",
    "model.add(layers.MaxPooling2D((2, 2)))\n",
    "model.add(layers.Conv2D(128, (3, 3), activation='relu'))\n",
    "model.add(layers.MaxPooling2D((2, 2)))\n",
    "\n",
    "#flatten layer\n",
    "model.add(layers.Flatten())\n",
    "\n",
    "#dense layer with 512 units and ReLU activation\n",
    "model.add(layers.Dense(512, activation='relu'))\n",
    "\n",
    "#output layer with 1 unit and sigmoid activation for binary classification\n",
    "model.add(layers.Dense(1, activation='sigmoid'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 427,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "-KjoY3GdBeET",
    "outputId": "dd0b34e5-d42b-49e1-99a3-540cdeea7015"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential_10\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " conv2d_40 (Conv2D)          (None, 148, 148, 32)      896       \n",
      "                                                                 \n",
      " max_pooling2d_40 (MaxPooli  (None, 74, 74, 32)        0         \n",
      " ng2D)                                                           \n",
      "                                                                 \n",
      " conv2d_41 (Conv2D)          (None, 72, 72, 64)        18496     \n",
      "                                                                 \n",
      " max_pooling2d_41 (MaxPooli  (None, 36, 36, 64)        0         \n",
      " ng2D)                                                           \n",
      "                                                                 \n",
      " conv2d_42 (Conv2D)          (None, 34, 34, 128)       73856     \n",
      "                                                                 \n",
      " max_pooling2d_42 (MaxPooli  (None, 17, 17, 128)       0         \n",
      " ng2D)                                                           \n",
      "                                                                 \n",
      " conv2d_43 (Conv2D)          (None, 15, 15, 128)       147584    \n",
      "                                                                 \n",
      " max_pooling2d_43 (MaxPooli  (None, 7, 7, 128)         0         \n",
      " ng2D)                                                           \n",
      "                                                                 \n",
      " flatten_10 (Flatten)        (None, 6272)              0         \n",
      "                                                                 \n",
      " dense_20 (Dense)            (None, 512)               3211776   \n",
      "                                                                 \n",
      " dense_21 (Dense)            (None, 1)                 513       \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 3453121 (13.17 MB)\n",
      "Trainable params: 3453121 (13.17 MB)\n",
      "Non-trainable params: 0 (0.00 Byte)\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "#summary of model architecture\n",
    "model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 428,
   "metadata": {
    "id": "iX_ClJnDBiO1"
   },
   "outputs": [],
   "source": [
    "#compile model with binary crossentropy loss, RMSprop optimizer with learning rate 1e-4, and accuracy metric\n",
    "model.compile(loss='binary_crossentropy',\n",
    "              optimizer=optimizers.RMSprop(learning_rate=1e-4),\n",
    "              metrics=['acc'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 429,
   "metadata": {
    "id": "XgB0ddkHOt5h"
   },
   "outputs": [],
   "source": [
    "#calculate number of images in train and val sets\n",
    "train_num_images = len(list(train_generator.filepaths))\n",
    "val_num_images = len(list(validation_generator.filepaths))\n",
    "\n",
    "\n",
    "#calculate steps per epoch for training and val\n",
    "train_steps_per_epoch = train_num_images // validation_generator.batch_size\n",
    "val_steps_per_epoch = val_num_images // validation_generator.batch_size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 431,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "73rP8Z95DAXs",
    "outputId": "f39e8b8d-c03d-4a56-c484-096ffe7b012f"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/10\n",
      "41/41 [==============================] - 76s 2s/step - loss: 0.4089 - acc: 0.8329 - val_loss: 0.3236 - val_acc: 0.8667\n",
      "Epoch 2/10\n",
      "41/41 [==============================] - 70s 2s/step - loss: 0.3675 - acc: 0.8379 - val_loss: 0.4135 - val_acc: 0.8194\n",
      "Epoch 3/10\n",
      "41/41 [==============================] - 83s 2s/step - loss: 0.3458 - acc: 0.8579 - val_loss: 0.2604 - val_acc: 0.8806\n",
      "Epoch 4/10\n",
      "41/41 [==============================] - 82s 2s/step - loss: 0.3110 - acc: 0.8678 - val_loss: 0.3094 - val_acc: 0.8667\n",
      "Epoch 5/10\n",
      "41/41 [==============================] - 84s 2s/step - loss: 0.2848 - acc: 0.8732 - val_loss: 0.2027 - val_acc: 0.9222\n",
      "Epoch 6/10\n",
      "41/41 [==============================] - 82s 2s/step - loss: 0.2487 - acc: 0.8953 - val_loss: 0.2702 - val_acc: 0.8944\n",
      "Epoch 7/10\n",
      "41/41 [==============================] - 68s 2s/step - loss: 0.2382 - acc: 0.9202 - val_loss: 0.1586 - val_acc: 0.9528\n",
      "Epoch 8/10\n",
      "41/41 [==============================] - 82s 2s/step - loss: 0.2151 - acc: 0.9252 - val_loss: 0.1586 - val_acc: 0.9528\n",
      "Epoch 9/10\n",
      "41/41 [==============================] - 82s 2s/step - loss: 0.1913 - acc: 0.9327 - val_loss: 0.1341 - val_acc: 0.9722\n",
      "Epoch 10/10\n",
      "41/41 [==============================] - 82s 2s/step - loss: 0.2059 - acc: 0.9152 - val_loss: 0.1100 - val_acc: 0.9806\n",
      "937.9541952610016\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "\n",
    "#start time measurement\n",
    "start = time.time()\n",
    "\n",
    "#train model\n",
    "history = model.fit(\n",
    "      train_generator,\n",
    "      steps_per_epoch=train_steps_per_epoch,\n",
    "      epochs=10,\n",
    "      validation_data=validation_generator,\n",
    "      validation_steps=val_steps_per_epoch)\n",
    "\n",
    "#end time measurement\n",
    "end = time.time()\n",
    "\n",
    "#print total time for training\n",
    "print(end - start)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "fD26PdbzYolB"
   },
   "source": [
    "#Model Evaluation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 432,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 1000
    },
    "id": "JdYfzRhqFZRY",
    "outputId": "f9cd0eed-051a-4a5e-a25f-c05041087b0b"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1400x700 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1400x700 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "acc = history.history['acc']\n",
    "val_acc = history.history['val_acc']\n",
    "loss = history.history['loss']\n",
    "val_loss = history.history['val_loss']\n",
    "\n",
    "epochs = range(len(acc))\n",
    "\n",
    "#plot training and validation accuracy\n",
    "plt.plot(epochs, acc, 'bo', label='Training acc')\n",
    "plt.plot(epochs, val_acc, 'b', label='Validation acc')\n",
    "plt.title('Training and validation accuracy')\n",
    "plt.legend()\n",
    "\n",
    "plt.figure()\n",
    "\n",
    "#plot training and validation loss\n",
    "plt.plot(epochs, loss, 'bo', 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",
    "#display\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 433,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "HjbRNOLdXYQo",
    "outputId": "184a8e05-3eba-4474-832e-533a8367cb59"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "37/37 [==============================] - 30s 806ms/step\n",
      "(367, 1)\n",
      "[[0.8988905 ]\n",
      " [0.7535102 ]\n",
      " [0.87403166]\n",
      " [0.24463664]\n",
      " [0.0164014 ]]\n",
      "(367, 1)\n",
      "[[1.]\n",
      " [1.]\n",
      " [1.]\n",
      " [0.]\n",
      " [0.]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "#preds on validation generator\n",
    "tmp = model.predict(validation_generator)\n",
    "\n",
    "#print shape\n",
    "print(tmp.shape)\n",
    "\n",
    "#print first 5 preds\n",
    "print(tmp[0:5])\n",
    "\n",
    "#round preds\n",
    "pred = np.round(tmp,0)\n",
    "\n",
    "#print shape\n",
    "print(pred.shape)\n",
    "\n",
    "#print first 5 preds\n",
    "print(pred[0:5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 434,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "OJK1O_3PXh-0",
    "outputId": "81a9d402-358d-4b5c-9ee6-864841f058d9"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
       "       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
       "       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
       "       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
       "       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
       "       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
       "       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
       "       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
       "       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "       1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "       1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "       1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "       1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "       1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "       1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "       1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "       1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], dtype=int32)"
      ]
     },
     "execution_count": 434,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#labels from validation generator\n",
    "validation_generator.labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 435,
   "metadata": {
    "id": "_k2LyTobX5ZT"
   },
   "outputs": [],
   "source": [
    "#flatten\n",
    "def flatten(l):\n",
    "    return [item for sublist in l for item in sublist]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 436,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "LJQyH1fFX-3n",
    "outputId": "a7c4bdc1-5179-46f5-f37b-a24d5577bdae"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1/1 [==============================] - 0s 353ms/step\n",
      "1/1 [==============================] - 0s 130ms/step\n",
      "1/1 [==============================] - 0s 130ms/step\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.10/dist-packages/PIL/Image.py:996: UserWarning: Palette images with Transparency expressed in bytes should be converted to RGBA images\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1/1 [==============================] - 0s 132ms/step\n",
      "1/1 [==============================] - 0s 130ms/step\n",
      "1/1 [==============================] - 0s 127ms/step\n",
      "1/1 [==============================] - 0s 131ms/step\n",
      "1/1 [==============================] - 0s 127ms/step\n",
      "1/1 [==============================] - 0s 128ms/step\n",
      "1/1 [==============================] - 0s 132ms/step\n",
      "1/1 [==============================] - 0s 126ms/step\n",
      "1/1 [==============================] - 0s 151ms/step\n",
      "1/1 [==============================] - 0s 128ms/step\n",
      "1/1 [==============================] - 0s 128ms/step\n",
      "1/1 [==============================] - 0s 127ms/step\n",
      "1/1 [==============================] - 0s 131ms/step\n",
      "1/1 [==============================] - 0s 192ms/step\n",
      "1/1 [==============================] - 0s 126ms/step\n",
      "1/1 [==============================] - 0s 128ms/step\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.10/dist-packages/PIL/Image.py:996: UserWarning: Palette images with Transparency expressed in bytes should be converted to RGBA images\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1/1 [==============================] - 0s 146ms/step\n",
      "1/1 [==============================] - 0s 132ms/step\n",
      "1/1 [==============================] - 0s 129ms/step\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.10/dist-packages/PIL/Image.py:996: UserWarning: Palette images with Transparency expressed in bytes should be converted to RGBA images\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1/1 [==============================] - 0s 132ms/step\n",
      "1/1 [==============================] - 0s 125ms/step\n",
      "1/1 [==============================] - 0s 125ms/step\n",
      "1/1 [==============================] - 0s 126ms/step\n",
      "1/1 [==============================] - 0s 130ms/step\n",
      "1/1 [==============================] - 0s 148ms/step\n",
      "1/1 [==============================] - 0s 126ms/step\n",
      "1/1 [==============================] - 0s 128ms/step\n",
      "1/1 [==============================] - 0s 219ms/step\n",
      "1/1 [==============================] - 0s 228ms/step\n",
      "1/1 [==============================] - 0s 206ms/step\n",
      "1/1 [==============================] - 0s 144ms/step\n",
      "1/1 [==============================] - 0s 127ms/step\n",
      "1/1 [==============================] - 0s 131ms/step\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "\n",
    "#store actual and predicted values\n",
    "my_results = pd.DataFrame(columns=['actual','pred'])\n",
    "batches = 0\n",
    "\n",
    "#iterate over validation generator\n",
    "for x_val, y_val in validation_generator:\n",
    "  batches=batches+1\n",
    "\n",
    "#make preds on current batch\n",
    "  y_pred = model.predict(x_val)\n",
    "#flatten preds\n",
    "  y_pred = flatten(y_pred)\n",
    "\n",
    "#create DataFrame with actual and predicted values for current batch\n",
    "  tmp = pd.DataFrame({'actual': y_val, 'pred': y_pred})\n",
    "\n",
    "#concat current batch results with main DataFrame\n",
    "  my_results = pd.concat([my_results, tmp])\n",
    "\n",
    "#check if number of batches processed equals steps per epoch for validation\n",
    "  if batches >= val_steps_per_epoch:\n",
    "\n",
    "    break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 437,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 423
    },
    "id": "v7NbsuJbYFnA",
    "outputId": "37e08f84-615f-4292-f7be-27964633b33b"
   },
   "outputs": [
    {
     "data": {
      "application/vnd.google.colaboratory.intrinsic+json": {
       "summary": "{\n  \"name\": \"my_results\",\n  \"rows\": 360,\n  \"fields\": [\n    {\n      \"column\": \"actual\",\n      \"properties\": {\n        \"dtype\": \"float32\",\n        \"num_unique_values\": 2,\n        \"samples\": [\n          0.0,\n          1.0\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"pred\",\n      \"properties\": {\n        \"dtype\": \"float32\",\n        \"num_unique_values\": 240,\n        \"samples\": [\n          0.7464166283607483,\n          0.05436982959508896\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    }\n  ]\n}",
       "type": "dataframe",
       "variable_name": "my_results"
      },
      "text/html": [
       "\n",
       "  <div id=\"df-66da6ae7-42df-420f-9454-7311e1213a0b\" class=\"colab-df-container\">\n",
       "    <div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>actual</th>\n",
       "      <th>pred</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.949874</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.0</td>\n",
       "      <td>0.005028</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.985815</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.0</td>\n",
       "      <td>0.024040</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.0</td>\n",
       "      <td>0.016767</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.960184</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>0.0</td>\n",
       "      <td>0.009576</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.934889</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.996831</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.991868</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>360 rows × 2 columns</p>\n",
       "</div>\n",
       "    <div class=\"colab-df-buttons\">\n",
       "\n",
       "  <div class=\"colab-df-container\">\n",
       "    <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-66da6ae7-42df-420f-9454-7311e1213a0b')\"\n",
       "            title=\"Convert this dataframe to an interactive table.\"\n",
       "            style=\"display:none;\">\n",
       "\n",
       "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\" viewBox=\"0 -960 960 960\">\n",
       "    <path d=\"M120-120v-720h720v720H120Zm60-500h600v-160H180v160Zm220 220h160v-160H400v160Zm0 220h160v-160H400v160ZM180-400h160v-160H180v160Zm440 0h160v-160H620v160ZM180-180h160v-160H180v160Zm440 0h160v-160H620v160Z\"/>\n",
       "  </svg>\n",
       "    </button>\n",
       "\n",
       "  <style>\n",
       "    .colab-df-container {\n",
       "      display:flex;\n",
       "      gap: 12px;\n",
       "    }\n",
       "\n",
       "    .colab-df-convert {\n",
       "      background-color: #E8F0FE;\n",
       "      border: none;\n",
       "      border-radius: 50%;\n",
       "      cursor: pointer;\n",
       "      display: none;\n",
       "      fill: #1967D2;\n",
       "      height: 32px;\n",
       "      padding: 0 0 0 0;\n",
       "      width: 32px;\n",
       "    }\n",
       "\n",
       "    .colab-df-convert:hover {\n",
       "      background-color: #E2EBFA;\n",
       "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
       "      fill: #174EA6;\n",
       "    }\n",
       "\n",
       "    .colab-df-buttons div {\n",
       "      margin-bottom: 4px;\n",
       "    }\n",
       "\n",
       "    [theme=dark] .colab-df-convert {\n",
       "      background-color: #3B4455;\n",
       "      fill: #D2E3FC;\n",
       "    }\n",
       "\n",
       "    [theme=dark] .colab-df-convert:hover {\n",
       "      background-color: #434B5C;\n",
       "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
       "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
       "      fill: #FFFFFF;\n",
       "    }\n",
       "  </style>\n",
       "\n",
       "    <script>\n",
       "      const buttonEl =\n",
       "        document.querySelector('#df-66da6ae7-42df-420f-9454-7311e1213a0b button.colab-df-convert');\n",
       "      buttonEl.style.display =\n",
       "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
       "\n",
       "      async function convertToInteractive(key) {\n",
       "        const element = document.querySelector('#df-66da6ae7-42df-420f-9454-7311e1213a0b');\n",
       "        const dataTable =\n",
       "          await google.colab.kernel.invokeFunction('convertToInteractive',\n",
       "                                                    [key], {});\n",
       "        if (!dataTable) return;\n",
       "\n",
       "        const docLinkHtml = 'Like what you see? Visit the ' +\n",
       "          '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
       "          + ' to learn more about interactive tables.';\n",
       "        element.innerHTML = '';\n",
       "        dataTable['output_type'] = 'display_data';\n",
       "        await google.colab.output.renderOutput(dataTable, element);\n",
       "        const docLink = document.createElement('div');\n",
       "        docLink.innerHTML = docLinkHtml;\n",
       "        element.appendChild(docLink);\n",
       "      }\n",
       "    </script>\n",
       "  </div>\n",
       "\n",
       "\n",
       "<div id=\"df-1beb7300-69e8-430c-89f0-d380e304fa7f\">\n",
       "  <button class=\"colab-df-quickchart\" onclick=\"quickchart('df-1beb7300-69e8-430c-89f0-d380e304fa7f')\"\n",
       "            title=\"Suggest charts\"\n",
       "            style=\"display:none;\">\n",
       "\n",
       "<svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
       "     width=\"24px\">\n",
       "    <g>\n",
       "        <path d=\"M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zM9 17H7v-7h2v7zm4 0h-2V7h2v10zm4 0h-2v-4h2v4z\"/>\n",
       "    </g>\n",
       "</svg>\n",
       "  </button>\n",
       "\n",
       "<style>\n",
       "  .colab-df-quickchart {\n",
       "      --bg-color: #E8F0FE;\n",
       "      --fill-color: #1967D2;\n",
       "      --hover-bg-color: #E2EBFA;\n",
       "      --hover-fill-color: #174EA6;\n",
       "      --disabled-fill-color: #AAA;\n",
       "      --disabled-bg-color: #DDD;\n",
       "  }\n",
       "\n",
       "  [theme=dark] .colab-df-quickchart {\n",
       "      --bg-color: #3B4455;\n",
       "      --fill-color: #D2E3FC;\n",
       "      --hover-bg-color: #434B5C;\n",
       "      --hover-fill-color: #FFFFFF;\n",
       "      --disabled-bg-color: #3B4455;\n",
       "      --disabled-fill-color: #666;\n",
       "  }\n",
       "\n",
       "  .colab-df-quickchart {\n",
       "    background-color: var(--bg-color);\n",
       "    border: none;\n",
       "    border-radius: 50%;\n",
       "    cursor: pointer;\n",
       "    display: none;\n",
       "    fill: var(--fill-color);\n",
       "    height: 32px;\n",
       "    padding: 0;\n",
       "    width: 32px;\n",
       "  }\n",
       "\n",
       "  .colab-df-quickchart:hover {\n",
       "    background-color: var(--hover-bg-color);\n",
       "    box-shadow: 0 1px 2px rgba(60, 64, 67, 0.3), 0 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
       "    fill: var(--button-hover-fill-color);\n",
       "  }\n",
       "\n",
       "  .colab-df-quickchart-complete:disabled,\n",
       "  .colab-df-quickchart-complete:disabled:hover {\n",
       "    background-color: var(--disabled-bg-color);\n",
       "    fill: var(--disabled-fill-color);\n",
       "    box-shadow: none;\n",
       "  }\n",
       "\n",
       "  .colab-df-spinner {\n",
       "    border: 2px solid var(--fill-color);\n",
       "    border-color: transparent;\n",
       "    border-bottom-color: var(--fill-color);\n",
       "    animation:\n",
       "      spin 1s steps(1) infinite;\n",
       "  }\n",
       "\n",
       "  @keyframes spin {\n",
       "    0% {\n",
       "      border-color: transparent;\n",
       "      border-bottom-color: var(--fill-color);\n",
       "      border-left-color: var(--fill-color);\n",
       "    }\n",
       "    20% {\n",
       "      border-color: transparent;\n",
       "      border-left-color: var(--fill-color);\n",
       "      border-top-color: var(--fill-color);\n",
       "    }\n",
       "    30% {\n",
       "      border-color: transparent;\n",
       "      border-left-color: var(--fill-color);\n",
       "      border-top-color: var(--fill-color);\n",
       "      border-right-color: var(--fill-color);\n",
       "    }\n",
       "    40% {\n",
       "      border-color: transparent;\n",
       "      border-right-color: var(--fill-color);\n",
       "      border-top-color: var(--fill-color);\n",
       "    }\n",
       "    60% {\n",
       "      border-color: transparent;\n",
       "      border-right-color: var(--fill-color);\n",
       "    }\n",
       "    80% {\n",
       "      border-color: transparent;\n",
       "      border-right-color: var(--fill-color);\n",
       "      border-bottom-color: var(--fill-color);\n",
       "    }\n",
       "    90% {\n",
       "      border-color: transparent;\n",
       "      border-bottom-color: var(--fill-color);\n",
       "    }\n",
       "  }\n",
       "</style>\n",
       "\n",
       "  <script>\n",
       "    async function quickchart(key) {\n",
       "      const quickchartButtonEl =\n",
       "        document.querySelector('#' + key + ' button');\n",
       "      quickchartButtonEl.disabled = true;  // To prevent multiple clicks.\n",
       "      quickchartButtonEl.classList.add('colab-df-spinner');\n",
       "      try {\n",
       "        const charts = await google.colab.kernel.invokeFunction(\n",
       "            'suggestCharts', [key], {});\n",
       "      } catch (error) {\n",
       "        console.error('Error during call to suggestCharts:', error);\n",
       "      }\n",
       "      quickchartButtonEl.classList.remove('colab-df-spinner');\n",
       "      quickchartButtonEl.classList.add('colab-df-quickchart-complete');\n",
       "    }\n",
       "    (() => {\n",
       "      let quickchartButtonEl =\n",
       "        document.querySelector('#df-1beb7300-69e8-430c-89f0-d380e304fa7f button');\n",
       "      quickchartButtonEl.style.display =\n",
       "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
       "    })();\n",
       "  </script>\n",
       "</div>\n",
       "    </div>\n",
       "  </div>\n"
      ],
      "text/plain": [
       "    actual      pred\n",
       "0      1.0  0.949874\n",
       "1      0.0  0.005028\n",
       "2      1.0  0.985815\n",
       "3      0.0  0.024040\n",
       "4      0.0  0.016767\n",
       "..     ...       ...\n",
       "5      1.0  0.960184\n",
       "6      0.0  0.009576\n",
       "7      1.0  0.934889\n",
       "8      1.0  0.996831\n",
       "9      1.0  0.991868\n",
       "\n",
       "[360 rows x 2 columns]"
      ]
     },
     "execution_count": 437,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#print results\n",
    "my_results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 438,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "6rIe4HAXYQp-",
    "outputId": "05f87108-f0a4-4e8a-9218-f992d4866019"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "         0.0       0.97      0.99      0.98       184\n",
      "         1.0       0.99      0.97      0.98       176\n",
      "\n",
      "    accuracy                           0.98       360\n",
      "   macro avg       0.98      0.98      0.98       360\n",
      "weighted avg       0.98      0.98      0.98       360\n",
      "\n"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics import classification_report\n",
    "\n",
    "#print classification report\n",
    "print(classification_report(y_true=my_results['actual'],\n",
    "                            y_pred=np.round(my_results['pred'],0)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 439,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "aiq4OIXdYYyt",
    "outputId": "5bfec904-3f48-4131-ff64-d03e853aef6f"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[182   2]\n",
      " [  5 171]]\n"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics import confusion_matrix\n",
    "\n",
    "#print confusion matrix\n",
    "print(confusion_matrix(y_true=my_results['actual'],\n",
    "                            y_pred=np.round(my_results['pred'],0)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 440,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "fadIOoSVYfXy",
    "outputId": "aec1fbe8-9b04-4a26-c068-952b1efc42c5"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.979942693409742"
      ]
     },
     "execution_count": 440,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.metrics import f1_score\n",
    "\n",
    "#print f1_score\n",
    "f1_score(my_results['actual'], np.round(my_results['pred'],0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "bkobOIeSZfav"
   },
   "source": [
    "#Reflection\n",
    "\n",
    "In this assignment, I learned how to use bing_image_downloader to download images from the web. I used these images in my ConvNet Model.\n",
    "\n",
    "I also learned how to create new directories for the train, test and validation partition of each class.\n",
    "\n",
    "I also learned how to format the data into pre-processed floating point tensors before being fed into the network.\n",
    "\n",
    "I also learned how to softcode the steps per epoch.\n",
    "\n",
    "The last thing I learned in this assignment was how to evaluate a ConvNet model."
   ]
  }
 ],
 "metadata": {
  "colab": {
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.11.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}