diff --git a/Final Task/A4_200064.ipynb b/Final Task/A4_200064.ipynb new file mode 100644 index 0000000..70a0522 --- /dev/null +++ b/Final Task/A4_200064.ipynb @@ -0,0 +1,1574 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "Copy_of_ICG_CVwTF_Final_Task (2).ipynb", + "provenance": [], + "collapsed_sections": [] + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + }, + "accelerator": "GPU", + "gpuClass": "standard" + }, + "cells": [ + { + "cell_type": "markdown", + "source": [ + "## Final Task:\n", + "This is your final evaluation for the project. As decided, we will be predicting images of people into three classes: `without_mask`, `mask_weared_incorrect` and `with_mask`. " + ], + "metadata": { + "id": "rtI19Rt-H7Uc" + } + }, + { + "cell_type": "code", + "source": [ + "import tensorflow as tf" + ], + "metadata": { + "id": "c2CiXcHQTbX8" + }, + "execution_count": 1, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "### Loading the dataset\n", + "Make a copy of the dataset given to you in your Google Drive (keep it outside, don't put it in any folder to avoid inconvenience). Ensure it is named as `Mask_Dataset` or change the path (the variable `data_dir`) accordingly." + ], + "metadata": { + "id": "QKDPyiZTIm1c" + } + }, + { + "cell_type": "code", + "source": [ + "# Mount Google Drive\n", + "from google.colab import drive\n", + "drive.mount('/content/drive')" + ], + "metadata": { + "id": "hNEMe7XsIjrK", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "88e1b860-a82a-4e61-858d-691a64d6b43a" + }, + "execution_count": 2, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Mounted at /content/drive\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "import pathlib\n", + "\n", + "path='/content/drive/MyDrive/Mask_Dataset/'\n", + "data_dir = pathlib.Path(path)" + ], + "metadata": { + "id": "8CXzo4MOJOl8" + }, + "execution_count": 9, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "### Know the Dataset\n", + "Most of the code is written for you as you aren't used to these libraries. You are to go through the documentation for your benefit." + ], + "metadata": { + "id": "YHPHkGyDKscK" + } + }, + { + "cell_type": "code", + "source": [ + "# Print image count\n", + "image_count = len(list(data_dir.glob('*/*.png')))\n", + "print(image_count)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "PzbSy-vXKjD-", + "outputId": "e1f3fbc8-0f3c-45ae-8913-2faf16f630a7" + }, + "execution_count": 10, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "0\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Print Output Labels\n", + "import os\n", + "output_classes = os.listdir(data_dir)\n", + "print(output_classes)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "rFHWFYj5NCVm", + "outputId": "45594403-4d40-456d-8850-99d8c3db7ded" + }, + "execution_count": 11, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "['mask_weared_incorrect', 'without_mask', 'with_mask']\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Plot count of each ouput label\n", + "import matplotlib.pyplot as plt\n", + "\n", + "count=[]\n", + "for label in output_classes:\n", + " this_path=path+label\n", + " dir=pathlib.Path(this_path)\n", + " im_count=os.listdir(dir)\n", + " count.append(len(im_count))\n", + "\n", + "print(count)\n", + "\n", + "plt.bar(output_classes,count)\n", + "plt.title(\"Statistics\")\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 299 + }, + "id": "fESyMw90KaxN", + "outputId": "60c5281a-4e96-4fe4-f306-94bf692121f5" + }, + "execution_count": 12, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "[2994, 2994, 2994]\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Check some sample images (Use of cv2)\n", + "import cv2\n", + "from google.colab.patches import cv2_imshow\n", + "img1=cv2.imread(str(list(data_dir.glob('without_mask/*'))[0]))\n", + "cv2_imshow(img1)\n", + "img2=cv2.imread(str(list(data_dir.glob('mask_weared_incorrect/*'))[2]))\n", + "cv2_imshow(img2)\n", + "img3=cv2.imread(str(list(data_dir.glob('with_mask/*'))[5]))\n", + "cv2_imshow(img3)\n", + "cv2.waitKey(0)\n", + "cv2.destroyAllWindows()\n", + "# Your code" + ], + "metadata": { + "id": "HDSJ2Zk5a14s", + "outputId": "7d175f5c-f555-4800-9ebf-9efc3cc85c5f", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 401 + } + }, + "execution_count": 13, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Check shape of the images in your dataset. This will be helpful while specifying input_shape in your Transfer Learning Model\n", + "print(img1.shape)\n", + "print(img2.shape)\n", + "print(img3.shape)" + ], + "metadata": { + "id": "jWBEMC1FUfXS", + "outputId": "bb6cd935-c321-40fc-9d3f-976afd9ea736", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "execution_count": 14, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(128, 128, 3)\n", + "(128, 128, 3)\n", + "(128, 128, 3)\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Check if all the images have same shape, else you need to resize them to some common size\n", + "x=img1.shape\n", + "cases=(\n", + " list(data_dir.glob('without_mask/*')),\n", + " list(data_dir.glob('mask_weared_incorrect/*')),\n", + " list(data_dir.glob('with_mask/*'))\n", + ")\n", + "for i in cases:\n", + " for j in range(2994):\n", + " img=cv2.imread(str(i[j]))\n", + " y=img.shape\n", + " if(x!=y):\n", + " print(\"different\")\n", + " break\n", + "print(\"same\")\n", + "\n", + "# The code provided as it is above in the template will help \n" + ], + "metadata": { + "id": "52BhBWRab5yc", + "outputId": "8449abcf-c973-4c4b-e64a-63adb255635d", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "execution_count": 16, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "same\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# If the shape is variable, reshape to a common size \n", + "\n", + "# If it is same, prove it" + ], + "metadata": { + "id": "G-Atau4Rfc-x" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Anything else you want to plot/experiment" + ], + "metadata": { + "id": "F0XHxMo2RVQd" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "### Model Definition\n", + "Choose a model for Transfer Learning (You may also experment with multiple models and keep all of them in this notebook)" + ], + "metadata": { + "id": "zSoUXS1cRbnu" + } + }, + { + "cell_type": "code", + "source": [ + "from tensorflow.keras.layers import Input, Lambda, Dense, Flatten\n", + "from tensorflow.keras.models import Model\n", + "from tensorflow.keras.preprocessing import image\n", + "from tensorflow.keras.models import Sequential" + ], + "metadata": { + "id": "QKZmIgXMTHfy" + }, + "execution_count": 50, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Choose and define base model\n", + "base_model=tf.keras.applications.MobileNetV2(\n", + " include_top=False,\n", + " weights='imagenet',\n", + " input_tensor=None,\n", + " input_shape=(128,128,3),\n", + ")" + ], + "metadata": { + "id": "9xWLUibHRNGj" + }, + "execution_count": 51, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Print base model summary and have a look at the layers\n", + "base_model.summary()" + ], + "metadata": { + "id": "J3TwB_GLd7BU", + "outputId": "1fd7d007-b7a9-4431-b080-79134e6586e9", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "execution_count": 52, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Model: \"mobilenetv2_1.00_128\"\n", + "__________________________________________________________________________________________________\n", + " Layer (type) Output Shape Param # Connected to \n", + "==================================================================================================\n", + " input_4 (InputLayer) [(None, 128, 128, 3 0 [] \n", + " )] \n", + " \n", + " Conv1 (Conv2D) (None, 64, 64, 32) 864 ['input_4[0][0]'] \n", + " \n", + " bn_Conv1 (BatchNormalization) (None, 64, 64, 32) 128 ['Conv1[0][0]'] \n", + " \n", + " Conv1_relu (ReLU) (None, 64, 64, 32) 0 ['bn_Conv1[0][0]'] \n", + " \n", + " expanded_conv_depthwise (Depth (None, 64, 64, 32) 288 ['Conv1_relu[0][0]'] \n", + " wiseConv2D) \n", + " \n", + " expanded_conv_depthwise_BN (Ba (None, 64, 64, 32) 128 ['expanded_conv_depthwise[0][0]']\n", + " tchNormalization) \n", + " \n", + " expanded_conv_depthwise_relu ( (None, 64, 64, 32) 0 ['expanded_conv_depthwise_BN[0][0\n", + " ReLU) ]'] \n", + " \n", + " expanded_conv_project (Conv2D) (None, 64, 64, 16) 512 ['expanded_conv_depthwise_relu[0]\n", + " [0]'] \n", + " \n", + " expanded_conv_project_BN (Batc (None, 64, 64, 16) 64 ['expanded_conv_project[0][0]'] \n", + " hNormalization) \n", + " \n", + " block_1_expand (Conv2D) (None, 64, 64, 96) 1536 ['expanded_conv_project_BN[0][0]'\n", + " ] \n", + " \n", + " block_1_expand_BN (BatchNormal (None, 64, 64, 96) 384 ['block_1_expand[0][0]'] \n", + " ization) \n", + " \n", + " block_1_expand_relu (ReLU) (None, 64, 64, 96) 0 ['block_1_expand_BN[0][0]'] \n", + " \n", + " block_1_pad (ZeroPadding2D) (None, 65, 65, 96) 0 ['block_1_expand_relu[0][0]'] \n", + " \n", + " block_1_depthwise (DepthwiseCo (None, 32, 32, 96) 864 ['block_1_pad[0][0]'] \n", + " nv2D) \n", + " \n", + " block_1_depthwise_BN (BatchNor (None, 32, 32, 96) 384 ['block_1_depthwise[0][0]'] \n", + " malization) \n", + " \n", + " block_1_depthwise_relu (ReLU) (None, 32, 32, 96) 0 ['block_1_depthwise_BN[0][0]'] \n", + " \n", + " block_1_project (Conv2D) (None, 32, 32, 24) 2304 ['block_1_depthwise_relu[0][0]'] \n", + " \n", + " block_1_project_BN (BatchNorma (None, 32, 32, 24) 96 ['block_1_project[0][0]'] \n", + " lization) \n", + " \n", + " block_2_expand (Conv2D) (None, 32, 32, 144) 3456 ['block_1_project_BN[0][0]'] \n", + " \n", + " block_2_expand_BN (BatchNormal (None, 32, 32, 144) 576 ['block_2_expand[0][0]'] \n", + " ization) \n", + " \n", + " block_2_expand_relu (ReLU) (None, 32, 32, 144) 0 ['block_2_expand_BN[0][0]'] \n", + " \n", + " block_2_depthwise (DepthwiseCo (None, 32, 32, 144) 1296 ['block_2_expand_relu[0][0]'] \n", + " nv2D) \n", + " \n", + " block_2_depthwise_BN (BatchNor (None, 32, 32, 144) 576 ['block_2_depthwise[0][0]'] \n", + " malization) \n", + " \n", + " block_2_depthwise_relu (ReLU) (None, 32, 32, 144) 0 ['block_2_depthwise_BN[0][0]'] \n", + " \n", + " block_2_project (Conv2D) (None, 32, 32, 24) 3456 ['block_2_depthwise_relu[0][0]'] \n", + " \n", + " block_2_project_BN (BatchNorma (None, 32, 32, 24) 96 ['block_2_project[0][0]'] \n", + " lization) \n", + " \n", + " block_2_add (Add) (None, 32, 32, 24) 0 ['block_1_project_BN[0][0]', \n", + " 'block_2_project_BN[0][0]'] \n", + " \n", + " block_3_expand (Conv2D) (None, 32, 32, 144) 3456 ['block_2_add[0][0]'] \n", + " \n", + " block_3_expand_BN (BatchNormal (None, 32, 32, 144) 576 ['block_3_expand[0][0]'] \n", + " ization) \n", + " \n", + " block_3_expand_relu (ReLU) (None, 32, 32, 144) 0 ['block_3_expand_BN[0][0]'] \n", + " \n", + " block_3_pad (ZeroPadding2D) (None, 33, 33, 144) 0 ['block_3_expand_relu[0][0]'] \n", + " \n", + " block_3_depthwise (DepthwiseCo (None, 16, 16, 144) 1296 ['block_3_pad[0][0]'] \n", + " nv2D) \n", + " \n", + " block_3_depthwise_BN (BatchNor (None, 16, 16, 144) 576 ['block_3_depthwise[0][0]'] \n", + " malization) \n", + " \n", + " block_3_depthwise_relu (ReLU) (None, 16, 16, 144) 0 ['block_3_depthwise_BN[0][0]'] \n", + " \n", + " block_3_project (Conv2D) (None, 16, 16, 32) 4608 ['block_3_depthwise_relu[0][0]'] \n", + " \n", + " block_3_project_BN (BatchNorma (None, 16, 16, 32) 128 ['block_3_project[0][0]'] \n", + " lization) \n", + " \n", + " block_4_expand (Conv2D) (None, 16, 16, 192) 6144 ['block_3_project_BN[0][0]'] \n", + " \n", + " block_4_expand_BN (BatchNormal (None, 16, 16, 192) 768 ['block_4_expand[0][0]'] \n", + " ization) \n", + " \n", + " block_4_expand_relu (ReLU) (None, 16, 16, 192) 0 ['block_4_expand_BN[0][0]'] \n", + " \n", + " block_4_depthwise (DepthwiseCo (None, 16, 16, 192) 1728 ['block_4_expand_relu[0][0]'] \n", + " nv2D) \n", + " \n", + " block_4_depthwise_BN (BatchNor (None, 16, 16, 192) 768 ['block_4_depthwise[0][0]'] \n", + " malization) \n", + " \n", + " block_4_depthwise_relu (ReLU) (None, 16, 16, 192) 0 ['block_4_depthwise_BN[0][0]'] \n", + " \n", + " block_4_project (Conv2D) (None, 16, 16, 32) 6144 ['block_4_depthwise_relu[0][0]'] \n", + " \n", + " block_4_project_BN (BatchNorma (None, 16, 16, 32) 128 ['block_4_project[0][0]'] \n", + " lization) \n", + " \n", + " block_4_add (Add) (None, 16, 16, 32) 0 ['block_3_project_BN[0][0]', \n", + " 'block_4_project_BN[0][0]'] \n", + " \n", + " block_5_expand (Conv2D) (None, 16, 16, 192) 6144 ['block_4_add[0][0]'] \n", + " \n", + " block_5_expand_BN (BatchNormal (None, 16, 16, 192) 768 ['block_5_expand[0][0]'] \n", + " ization) \n", + " \n", + " block_5_expand_relu (ReLU) (None, 16, 16, 192) 0 ['block_5_expand_BN[0][0]'] \n", + " \n", + " block_5_depthwise (DepthwiseCo (None, 16, 16, 192) 1728 ['block_5_expand_relu[0][0]'] \n", + " nv2D) \n", + " \n", + " block_5_depthwise_BN (BatchNor (None, 16, 16, 192) 768 ['block_5_depthwise[0][0]'] \n", + " malization) \n", + " \n", + " block_5_depthwise_relu (ReLU) (None, 16, 16, 192) 0 ['block_5_depthwise_BN[0][0]'] \n", + " \n", + " block_5_project (Conv2D) (None, 16, 16, 32) 6144 ['block_5_depthwise_relu[0][0]'] \n", + " \n", + " block_5_project_BN (BatchNorma (None, 16, 16, 32) 128 ['block_5_project[0][0]'] \n", + " lization) \n", + " \n", + " block_5_add (Add) (None, 16, 16, 32) 0 ['block_4_add[0][0]', \n", + " 'block_5_project_BN[0][0]'] \n", + " \n", + " block_6_expand (Conv2D) (None, 16, 16, 192) 6144 ['block_5_add[0][0]'] \n", + " \n", + " block_6_expand_BN (BatchNormal (None, 16, 16, 192) 768 ['block_6_expand[0][0]'] \n", + " ization) \n", + " \n", + " block_6_expand_relu (ReLU) (None, 16, 16, 192) 0 ['block_6_expand_BN[0][0]'] \n", + " \n", + " block_6_pad (ZeroPadding2D) (None, 17, 17, 192) 0 ['block_6_expand_relu[0][0]'] \n", + " \n", + " block_6_depthwise (DepthwiseCo (None, 8, 8, 192) 1728 ['block_6_pad[0][0]'] \n", + " nv2D) \n", + " \n", + " block_6_depthwise_BN (BatchNor (None, 8, 8, 192) 768 ['block_6_depthwise[0][0]'] \n", + " malization) \n", + " \n", + " block_6_depthwise_relu (ReLU) (None, 8, 8, 192) 0 ['block_6_depthwise_BN[0][0]'] \n", + " \n", + " block_6_project (Conv2D) (None, 8, 8, 64) 12288 ['block_6_depthwise_relu[0][0]'] \n", + " \n", + " block_6_project_BN (BatchNorma (None, 8, 8, 64) 256 ['block_6_project[0][0]'] \n", + " lization) \n", + " \n", + " block_7_expand (Conv2D) (None, 8, 8, 384) 24576 ['block_6_project_BN[0][0]'] \n", + " \n", + " block_7_expand_BN (BatchNormal (None, 8, 8, 384) 1536 ['block_7_expand[0][0]'] \n", + " ization) \n", + " \n", + " block_7_expand_relu (ReLU) (None, 8, 8, 384) 0 ['block_7_expand_BN[0][0]'] \n", + " \n", + " block_7_depthwise (DepthwiseCo (None, 8, 8, 384) 3456 ['block_7_expand_relu[0][0]'] \n", + " nv2D) \n", + " \n", + " block_7_depthwise_BN (BatchNor (None, 8, 8, 384) 1536 ['block_7_depthwise[0][0]'] \n", + " malization) \n", + " \n", + " block_7_depthwise_relu (ReLU) (None, 8, 8, 384) 0 ['block_7_depthwise_BN[0][0]'] \n", + " \n", + " block_7_project (Conv2D) (None, 8, 8, 64) 24576 ['block_7_depthwise_relu[0][0]'] \n", + " \n", + " block_7_project_BN (BatchNorma (None, 8, 8, 64) 256 ['block_7_project[0][0]'] \n", + " lization) \n", + " \n", + " block_7_add (Add) (None, 8, 8, 64) 0 ['block_6_project_BN[0][0]', \n", + " 'block_7_project_BN[0][0]'] \n", + " \n", + " block_8_expand (Conv2D) (None, 8, 8, 384) 24576 ['block_7_add[0][0]'] \n", + " \n", + " block_8_expand_BN (BatchNormal (None, 8, 8, 384) 1536 ['block_8_expand[0][0]'] \n", + " ization) \n", + " \n", + " block_8_expand_relu (ReLU) (None, 8, 8, 384) 0 ['block_8_expand_BN[0][0]'] \n", + " \n", + " block_8_depthwise (DepthwiseCo (None, 8, 8, 384) 3456 ['block_8_expand_relu[0][0]'] \n", + " nv2D) \n", + " \n", + " block_8_depthwise_BN (BatchNor (None, 8, 8, 384) 1536 ['block_8_depthwise[0][0]'] \n", + " malization) \n", + " \n", + " block_8_depthwise_relu (ReLU) (None, 8, 8, 384) 0 ['block_8_depthwise_BN[0][0]'] \n", + " \n", + " block_8_project (Conv2D) (None, 8, 8, 64) 24576 ['block_8_depthwise_relu[0][0]'] \n", + " \n", + " block_8_project_BN (BatchNorma (None, 8, 8, 64) 256 ['block_8_project[0][0]'] \n", + " lization) \n", + " \n", + " block_8_add (Add) (None, 8, 8, 64) 0 ['block_7_add[0][0]', \n", + " 'block_8_project_BN[0][0]'] \n", + " \n", + " block_9_expand (Conv2D) (None, 8, 8, 384) 24576 ['block_8_add[0][0]'] \n", + " \n", + " block_9_expand_BN (BatchNormal (None, 8, 8, 384) 1536 ['block_9_expand[0][0]'] \n", + " ization) \n", + " \n", + " block_9_expand_relu (ReLU) (None, 8, 8, 384) 0 ['block_9_expand_BN[0][0]'] \n", + " \n", + " block_9_depthwise (DepthwiseCo (None, 8, 8, 384) 3456 ['block_9_expand_relu[0][0]'] \n", + " nv2D) \n", + " \n", + " block_9_depthwise_BN (BatchNor (None, 8, 8, 384) 1536 ['block_9_depthwise[0][0]'] \n", + " malization) \n", + " \n", + " block_9_depthwise_relu (ReLU) (None, 8, 8, 384) 0 ['block_9_depthwise_BN[0][0]'] \n", + " \n", + " block_9_project (Conv2D) (None, 8, 8, 64) 24576 ['block_9_depthwise_relu[0][0]'] \n", + " \n", + " block_9_project_BN (BatchNorma (None, 8, 8, 64) 256 ['block_9_project[0][0]'] \n", + " lization) \n", + " \n", + " block_9_add (Add) (None, 8, 8, 64) 0 ['block_8_add[0][0]', \n", + " 'block_9_project_BN[0][0]'] \n", + " \n", + " block_10_expand (Conv2D) (None, 8, 8, 384) 24576 ['block_9_add[0][0]'] \n", + " \n", + " block_10_expand_BN (BatchNorma (None, 8, 8, 384) 1536 ['block_10_expand[0][0]'] \n", + " lization) \n", + " \n", + " block_10_expand_relu (ReLU) (None, 8, 8, 384) 0 ['block_10_expand_BN[0][0]'] \n", + " \n", + " block_10_depthwise (DepthwiseC (None, 8, 8, 384) 3456 ['block_10_expand_relu[0][0]'] \n", + " onv2D) \n", + " \n", + " block_10_depthwise_BN (BatchNo (None, 8, 8, 384) 1536 ['block_10_depthwise[0][0]'] \n", + " rmalization) \n", + " \n", + " block_10_depthwise_relu (ReLU) (None, 8, 8, 384) 0 ['block_10_depthwise_BN[0][0]'] \n", + " \n", + " block_10_project (Conv2D) (None, 8, 8, 96) 36864 ['block_10_depthwise_relu[0][0]']\n", + " \n", + " block_10_project_BN (BatchNorm (None, 8, 8, 96) 384 ['block_10_project[0][0]'] \n", + " alization) \n", + " \n", + " block_11_expand (Conv2D) (None, 8, 8, 576) 55296 ['block_10_project_BN[0][0]'] \n", + " \n", + " block_11_expand_BN (BatchNorma (None, 8, 8, 576) 2304 ['block_11_expand[0][0]'] \n", + " lization) \n", + " \n", + " block_11_expand_relu (ReLU) (None, 8, 8, 576) 0 ['block_11_expand_BN[0][0]'] \n", + " \n", + " block_11_depthwise (DepthwiseC (None, 8, 8, 576) 5184 ['block_11_expand_relu[0][0]'] \n", + " onv2D) \n", + " \n", + " block_11_depthwise_BN (BatchNo (None, 8, 8, 576) 2304 ['block_11_depthwise[0][0]'] \n", + " rmalization) \n", + " \n", + " block_11_depthwise_relu (ReLU) (None, 8, 8, 576) 0 ['block_11_depthwise_BN[0][0]'] \n", + " \n", + " block_11_project (Conv2D) (None, 8, 8, 96) 55296 ['block_11_depthwise_relu[0][0]']\n", + " \n", + " block_11_project_BN (BatchNorm (None, 8, 8, 96) 384 ['block_11_project[0][0]'] \n", + " alization) \n", + " \n", + " block_11_add (Add) (None, 8, 8, 96) 0 ['block_10_project_BN[0][0]', \n", + " 'block_11_project_BN[0][0]'] \n", + " \n", + " block_12_expand (Conv2D) (None, 8, 8, 576) 55296 ['block_11_add[0][0]'] \n", + " \n", + " block_12_expand_BN (BatchNorma (None, 8, 8, 576) 2304 ['block_12_expand[0][0]'] \n", + " lization) \n", + " \n", + " block_12_expand_relu (ReLU) (None, 8, 8, 576) 0 ['block_12_expand_BN[0][0]'] \n", + " \n", + " block_12_depthwise (DepthwiseC (None, 8, 8, 576) 5184 ['block_12_expand_relu[0][0]'] \n", + " onv2D) \n", + " \n", + " block_12_depthwise_BN (BatchNo (None, 8, 8, 576) 2304 ['block_12_depthwise[0][0]'] \n", + " rmalization) \n", + " \n", + " block_12_depthwise_relu (ReLU) (None, 8, 8, 576) 0 ['block_12_depthwise_BN[0][0]'] \n", + " \n", + " block_12_project (Conv2D) (None, 8, 8, 96) 55296 ['block_12_depthwise_relu[0][0]']\n", + " \n", + " block_12_project_BN (BatchNorm (None, 8, 8, 96) 384 ['block_12_project[0][0]'] \n", + " alization) \n", + " \n", + " block_12_add (Add) (None, 8, 8, 96) 0 ['block_11_add[0][0]', \n", + " 'block_12_project_BN[0][0]'] \n", + " \n", + " block_13_expand (Conv2D) (None, 8, 8, 576) 55296 ['block_12_add[0][0]'] \n", + " \n", + " block_13_expand_BN (BatchNorma (None, 8, 8, 576) 2304 ['block_13_expand[0][0]'] \n", + " lization) \n", + " \n", + " block_13_expand_relu (ReLU) (None, 8, 8, 576) 0 ['block_13_expand_BN[0][0]'] \n", + " \n", + " block_13_pad (ZeroPadding2D) (None, 9, 9, 576) 0 ['block_13_expand_relu[0][0]'] \n", + " \n", + " block_13_depthwise (DepthwiseC (None, 4, 4, 576) 5184 ['block_13_pad[0][0]'] \n", + " onv2D) \n", + " \n", + " block_13_depthwise_BN (BatchNo (None, 4, 4, 576) 2304 ['block_13_depthwise[0][0]'] \n", + " rmalization) \n", + " \n", + " block_13_depthwise_relu (ReLU) (None, 4, 4, 576) 0 ['block_13_depthwise_BN[0][0]'] \n", + " \n", + " block_13_project (Conv2D) (None, 4, 4, 160) 92160 ['block_13_depthwise_relu[0][0]']\n", + " \n", + " block_13_project_BN (BatchNorm (None, 4, 4, 160) 640 ['block_13_project[0][0]'] \n", + " alization) \n", + " \n", + " block_14_expand (Conv2D) (None, 4, 4, 960) 153600 ['block_13_project_BN[0][0]'] \n", + " \n", + " block_14_expand_BN (BatchNorma (None, 4, 4, 960) 3840 ['block_14_expand[0][0]'] \n", + " lization) \n", + " \n", + " block_14_expand_relu (ReLU) (None, 4, 4, 960) 0 ['block_14_expand_BN[0][0]'] \n", + " \n", + " block_14_depthwise (DepthwiseC (None, 4, 4, 960) 8640 ['block_14_expand_relu[0][0]'] \n", + " onv2D) \n", + " \n", + " block_14_depthwise_BN (BatchNo (None, 4, 4, 960) 3840 ['block_14_depthwise[0][0]'] \n", + " rmalization) \n", + " \n", + " block_14_depthwise_relu (ReLU) (None, 4, 4, 960) 0 ['block_14_depthwise_BN[0][0]'] \n", + " \n", + " block_14_project (Conv2D) (None, 4, 4, 160) 153600 ['block_14_depthwise_relu[0][0]']\n", + " \n", + " block_14_project_BN (BatchNorm (None, 4, 4, 160) 640 ['block_14_project[0][0]'] \n", + " alization) \n", + " \n", + " block_14_add (Add) (None, 4, 4, 160) 0 ['block_13_project_BN[0][0]', \n", + " 'block_14_project_BN[0][0]'] \n", + " \n", + " block_15_expand (Conv2D) (None, 4, 4, 960) 153600 ['block_14_add[0][0]'] \n", + " \n", + " block_15_expand_BN (BatchNorma (None, 4, 4, 960) 3840 ['block_15_expand[0][0]'] \n", + " lization) \n", + " \n", + " block_15_expand_relu (ReLU) (None, 4, 4, 960) 0 ['block_15_expand_BN[0][0]'] \n", + " \n", + " block_15_depthwise (DepthwiseC (None, 4, 4, 960) 8640 ['block_15_expand_relu[0][0]'] \n", + " onv2D) \n", + " \n", + " block_15_depthwise_BN (BatchNo (None, 4, 4, 960) 3840 ['block_15_depthwise[0][0]'] \n", + " rmalization) \n", + " \n", + " block_15_depthwise_relu (ReLU) (None, 4, 4, 960) 0 ['block_15_depthwise_BN[0][0]'] \n", + " \n", + " block_15_project (Conv2D) (None, 4, 4, 160) 153600 ['block_15_depthwise_relu[0][0]']\n", + " \n", + " block_15_project_BN (BatchNorm (None, 4, 4, 160) 640 ['block_15_project[0][0]'] \n", + " alization) \n", + " \n", + " block_15_add (Add) (None, 4, 4, 160) 0 ['block_14_add[0][0]', \n", + " 'block_15_project_BN[0][0]'] \n", + " \n", + " block_16_expand (Conv2D) (None, 4, 4, 960) 153600 ['block_15_add[0][0]'] \n", + " \n", + " block_16_expand_BN (BatchNorma (None, 4, 4, 960) 3840 ['block_16_expand[0][0]'] \n", + " lization) \n", + " \n", + " block_16_expand_relu (ReLU) (None, 4, 4, 960) 0 ['block_16_expand_BN[0][0]'] \n", + " \n", + " block_16_depthwise (DepthwiseC (None, 4, 4, 960) 8640 ['block_16_expand_relu[0][0]'] \n", + " onv2D) \n", + " \n", + " block_16_depthwise_BN (BatchNo (None, 4, 4, 960) 3840 ['block_16_depthwise[0][0]'] \n", + " rmalization) \n", + " \n", + " block_16_depthwise_relu (ReLU) (None, 4, 4, 960) 0 ['block_16_depthwise_BN[0][0]'] \n", + " \n", + " block_16_project (Conv2D) (None, 4, 4, 320) 307200 ['block_16_depthwise_relu[0][0]']\n", + " \n", + " block_16_project_BN (BatchNorm (None, 4, 4, 320) 1280 ['block_16_project[0][0]'] \n", + " alization) \n", + " \n", + " Conv_1 (Conv2D) (None, 4, 4, 1280) 409600 ['block_16_project_BN[0][0]'] \n", + " \n", + " Conv_1_bn (BatchNormalization) (None, 4, 4, 1280) 5120 ['Conv_1[0][0]'] \n", + " \n", + " out_relu (ReLU) (None, 4, 4, 1280) 0 ['Conv_1_bn[0][0]'] \n", + " \n", + "==================================================================================================\n", + "Total params: 2,257,984\n", + "Trainable params: 2,223,872\n", + "Non-trainable params: 34,112\n", + "__________________________________________________________________________________________________\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# As we're using Transfer Learning, you do not need to train all the layers. Freeze all of the layers or train some layers (experiment)\n", + "base_model.trainable=False\n", + "base_model.summary()" + ], + "metadata": { + "id": "F_Heq3C1eKd-", + "outputId": "cf91636a-dc90-4d73-ed36-fadb1bca4ed2", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "execution_count": 53, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Model: \"mobilenetv2_1.00_128\"\n", + "__________________________________________________________________________________________________\n", + " Layer (type) Output Shape Param # Connected to \n", + "==================================================================================================\n", + " input_4 (InputLayer) [(None, 128, 128, 3 0 [] \n", + " )] \n", + " \n", + " Conv1 (Conv2D) (None, 64, 64, 32) 864 ['input_4[0][0]'] \n", + " \n", + " bn_Conv1 (BatchNormalization) (None, 64, 64, 32) 128 ['Conv1[0][0]'] \n", + " \n", + " Conv1_relu (ReLU) (None, 64, 64, 32) 0 ['bn_Conv1[0][0]'] \n", + " \n", + " expanded_conv_depthwise (Depth (None, 64, 64, 32) 288 ['Conv1_relu[0][0]'] \n", + " wiseConv2D) \n", + " \n", + " expanded_conv_depthwise_BN (Ba (None, 64, 64, 32) 128 ['expanded_conv_depthwise[0][0]']\n", + " tchNormalization) \n", + " \n", + " expanded_conv_depthwise_relu ( (None, 64, 64, 32) 0 ['expanded_conv_depthwise_BN[0][0\n", + " ReLU) ]'] \n", + " \n", + " expanded_conv_project (Conv2D) (None, 64, 64, 16) 512 ['expanded_conv_depthwise_relu[0]\n", + " [0]'] \n", + " \n", + " expanded_conv_project_BN (Batc (None, 64, 64, 16) 64 ['expanded_conv_project[0][0]'] \n", + " hNormalization) \n", + " \n", + " block_1_expand (Conv2D) (None, 64, 64, 96) 1536 ['expanded_conv_project_BN[0][0]'\n", + " ] \n", + " \n", + " block_1_expand_BN (BatchNormal (None, 64, 64, 96) 384 ['block_1_expand[0][0]'] \n", + " ization) \n", + " \n", + " block_1_expand_relu (ReLU) (None, 64, 64, 96) 0 ['block_1_expand_BN[0][0]'] \n", + " \n", + " block_1_pad (ZeroPadding2D) (None, 65, 65, 96) 0 ['block_1_expand_relu[0][0]'] \n", + " \n", + " block_1_depthwise (DepthwiseCo (None, 32, 32, 96) 864 ['block_1_pad[0][0]'] \n", + " nv2D) \n", + " \n", + " block_1_depthwise_BN (BatchNor (None, 32, 32, 96) 384 ['block_1_depthwise[0][0]'] \n", + " malization) \n", + " \n", + " block_1_depthwise_relu (ReLU) (None, 32, 32, 96) 0 ['block_1_depthwise_BN[0][0]'] \n", + " \n", + " block_1_project (Conv2D) (None, 32, 32, 24) 2304 ['block_1_depthwise_relu[0][0]'] \n", + " \n", + " block_1_project_BN (BatchNorma (None, 32, 32, 24) 96 ['block_1_project[0][0]'] \n", + " lization) \n", + " \n", + " block_2_expand (Conv2D) (None, 32, 32, 144) 3456 ['block_1_project_BN[0][0]'] \n", + " \n", + " block_2_expand_BN (BatchNormal (None, 32, 32, 144) 576 ['block_2_expand[0][0]'] \n", + " ization) \n", + " \n", + " block_2_expand_relu (ReLU) (None, 32, 32, 144) 0 ['block_2_expand_BN[0][0]'] \n", + " \n", + " block_2_depthwise (DepthwiseCo (None, 32, 32, 144) 1296 ['block_2_expand_relu[0][0]'] \n", + " nv2D) \n", + " \n", + " block_2_depthwise_BN (BatchNor (None, 32, 32, 144) 576 ['block_2_depthwise[0][0]'] \n", + " malization) \n", + " \n", + " block_2_depthwise_relu (ReLU) (None, 32, 32, 144) 0 ['block_2_depthwise_BN[0][0]'] \n", + " \n", + " block_2_project (Conv2D) (None, 32, 32, 24) 3456 ['block_2_depthwise_relu[0][0]'] \n", + " \n", + " block_2_project_BN (BatchNorma (None, 32, 32, 24) 96 ['block_2_project[0][0]'] \n", + " lization) \n", + " \n", + " block_2_add (Add) (None, 32, 32, 24) 0 ['block_1_project_BN[0][0]', \n", + " 'block_2_project_BN[0][0]'] \n", + " \n", + " block_3_expand (Conv2D) (None, 32, 32, 144) 3456 ['block_2_add[0][0]'] \n", + " \n", + " block_3_expand_BN (BatchNormal (None, 32, 32, 144) 576 ['block_3_expand[0][0]'] \n", + " ization) \n", + " \n", + " block_3_expand_relu (ReLU) (None, 32, 32, 144) 0 ['block_3_expand_BN[0][0]'] \n", + " \n", + " block_3_pad (ZeroPadding2D) (None, 33, 33, 144) 0 ['block_3_expand_relu[0][0]'] \n", + " \n", + " block_3_depthwise (DepthwiseCo (None, 16, 16, 144) 1296 ['block_3_pad[0][0]'] \n", + " nv2D) \n", + " \n", + " block_3_depthwise_BN (BatchNor (None, 16, 16, 144) 576 ['block_3_depthwise[0][0]'] \n", + " malization) \n", + " \n", + " block_3_depthwise_relu (ReLU) (None, 16, 16, 144) 0 ['block_3_depthwise_BN[0][0]'] \n", + " \n", + " block_3_project (Conv2D) (None, 16, 16, 32) 4608 ['block_3_depthwise_relu[0][0]'] \n", + " \n", + " block_3_project_BN (BatchNorma (None, 16, 16, 32) 128 ['block_3_project[0][0]'] \n", + " lization) \n", + " \n", + " block_4_expand (Conv2D) (None, 16, 16, 192) 6144 ['block_3_project_BN[0][0]'] \n", + " \n", + " block_4_expand_BN (BatchNormal (None, 16, 16, 192) 768 ['block_4_expand[0][0]'] \n", + " ization) \n", + " \n", + " block_4_expand_relu (ReLU) (None, 16, 16, 192) 0 ['block_4_expand_BN[0][0]'] \n", + " \n", + " block_4_depthwise (DepthwiseCo (None, 16, 16, 192) 1728 ['block_4_expand_relu[0][0]'] \n", + " nv2D) \n", + " \n", + " block_4_depthwise_BN (BatchNor (None, 16, 16, 192) 768 ['block_4_depthwise[0][0]'] \n", + " malization) \n", + " \n", + " block_4_depthwise_relu (ReLU) (None, 16, 16, 192) 0 ['block_4_depthwise_BN[0][0]'] \n", + " \n", + " block_4_project (Conv2D) (None, 16, 16, 32) 6144 ['block_4_depthwise_relu[0][0]'] \n", + " \n", + " block_4_project_BN (BatchNorma (None, 16, 16, 32) 128 ['block_4_project[0][0]'] \n", + " lization) \n", + " \n", + " block_4_add (Add) (None, 16, 16, 32) 0 ['block_3_project_BN[0][0]', \n", + " 'block_4_project_BN[0][0]'] \n", + " \n", + " block_5_expand (Conv2D) (None, 16, 16, 192) 6144 ['block_4_add[0][0]'] \n", + " \n", + " block_5_expand_BN (BatchNormal (None, 16, 16, 192) 768 ['block_5_expand[0][0]'] \n", + " ization) \n", + " \n", + " block_5_expand_relu (ReLU) (None, 16, 16, 192) 0 ['block_5_expand_BN[0][0]'] \n", + " \n", + " block_5_depthwise (DepthwiseCo (None, 16, 16, 192) 1728 ['block_5_expand_relu[0][0]'] \n", + " nv2D) \n", + " \n", + " block_5_depthwise_BN (BatchNor (None, 16, 16, 192) 768 ['block_5_depthwise[0][0]'] \n", + " malization) \n", + " \n", + " block_5_depthwise_relu (ReLU) (None, 16, 16, 192) 0 ['block_5_depthwise_BN[0][0]'] \n", + " \n", + " block_5_project (Conv2D) (None, 16, 16, 32) 6144 ['block_5_depthwise_relu[0][0]'] \n", + " \n", + " block_5_project_BN (BatchNorma (None, 16, 16, 32) 128 ['block_5_project[0][0]'] \n", + " lization) \n", + " \n", + " block_5_add (Add) (None, 16, 16, 32) 0 ['block_4_add[0][0]', \n", + " 'block_5_project_BN[0][0]'] \n", + " \n", + " block_6_expand (Conv2D) (None, 16, 16, 192) 6144 ['block_5_add[0][0]'] \n", + " \n", + " block_6_expand_BN (BatchNormal (None, 16, 16, 192) 768 ['block_6_expand[0][0]'] \n", + " ization) \n", + " \n", + " block_6_expand_relu (ReLU) (None, 16, 16, 192) 0 ['block_6_expand_BN[0][0]'] \n", + " \n", + " block_6_pad (ZeroPadding2D) (None, 17, 17, 192) 0 ['block_6_expand_relu[0][0]'] \n", + " \n", + " block_6_depthwise (DepthwiseCo (None, 8, 8, 192) 1728 ['block_6_pad[0][0]'] \n", + " nv2D) \n", + " \n", + " block_6_depthwise_BN (BatchNor (None, 8, 8, 192) 768 ['block_6_depthwise[0][0]'] \n", + " malization) \n", + " \n", + " block_6_depthwise_relu (ReLU) (None, 8, 8, 192) 0 ['block_6_depthwise_BN[0][0]'] \n", + " \n", + " block_6_project (Conv2D) (None, 8, 8, 64) 12288 ['block_6_depthwise_relu[0][0]'] \n", + " \n", + " block_6_project_BN (BatchNorma (None, 8, 8, 64) 256 ['block_6_project[0][0]'] \n", + " lization) \n", + " \n", + " block_7_expand (Conv2D) (None, 8, 8, 384) 24576 ['block_6_project_BN[0][0]'] \n", + " \n", + " block_7_expand_BN (BatchNormal (None, 8, 8, 384) 1536 ['block_7_expand[0][0]'] \n", + " ization) \n", + " \n", + " block_7_expand_relu (ReLU) (None, 8, 8, 384) 0 ['block_7_expand_BN[0][0]'] \n", + " \n", + " block_7_depthwise (DepthwiseCo (None, 8, 8, 384) 3456 ['block_7_expand_relu[0][0]'] \n", + " nv2D) \n", + " \n", + " block_7_depthwise_BN (BatchNor (None, 8, 8, 384) 1536 ['block_7_depthwise[0][0]'] \n", + " malization) \n", + " \n", + " block_7_depthwise_relu (ReLU) (None, 8, 8, 384) 0 ['block_7_depthwise_BN[0][0]'] \n", + " \n", + " block_7_project (Conv2D) (None, 8, 8, 64) 24576 ['block_7_depthwise_relu[0][0]'] \n", + " \n", + " block_7_project_BN (BatchNorma (None, 8, 8, 64) 256 ['block_7_project[0][0]'] \n", + " lization) \n", + " \n", + " block_7_add (Add) (None, 8, 8, 64) 0 ['block_6_project_BN[0][0]', \n", + " 'block_7_project_BN[0][0]'] \n", + " \n", + " block_8_expand (Conv2D) (None, 8, 8, 384) 24576 ['block_7_add[0][0]'] \n", + " \n", + " block_8_expand_BN (BatchNormal (None, 8, 8, 384) 1536 ['block_8_expand[0][0]'] \n", + " ization) \n", + " \n", + " block_8_expand_relu (ReLU) (None, 8, 8, 384) 0 ['block_8_expand_BN[0][0]'] \n", + " \n", + " block_8_depthwise (DepthwiseCo (None, 8, 8, 384) 3456 ['block_8_expand_relu[0][0]'] \n", + " nv2D) \n", + " \n", + " block_8_depthwise_BN (BatchNor (None, 8, 8, 384) 1536 ['block_8_depthwise[0][0]'] \n", + " malization) \n", + " \n", + " block_8_depthwise_relu (ReLU) (None, 8, 8, 384) 0 ['block_8_depthwise_BN[0][0]'] \n", + " \n", + " block_8_project (Conv2D) (None, 8, 8, 64) 24576 ['block_8_depthwise_relu[0][0]'] \n", + " \n", + " block_8_project_BN (BatchNorma (None, 8, 8, 64) 256 ['block_8_project[0][0]'] \n", + " lization) \n", + " \n", + " block_8_add (Add) (None, 8, 8, 64) 0 ['block_7_add[0][0]', \n", + " 'block_8_project_BN[0][0]'] \n", + " \n", + " block_9_expand (Conv2D) (None, 8, 8, 384) 24576 ['block_8_add[0][0]'] \n", + " \n", + " block_9_expand_BN (BatchNormal (None, 8, 8, 384) 1536 ['block_9_expand[0][0]'] \n", + " ization) \n", + " \n", + " block_9_expand_relu (ReLU) (None, 8, 8, 384) 0 ['block_9_expand_BN[0][0]'] \n", + " \n", + " block_9_depthwise (DepthwiseCo (None, 8, 8, 384) 3456 ['block_9_expand_relu[0][0]'] \n", + " nv2D) \n", + " \n", + " block_9_depthwise_BN (BatchNor (None, 8, 8, 384) 1536 ['block_9_depthwise[0][0]'] \n", + " malization) \n", + " \n", + " block_9_depthwise_relu (ReLU) (None, 8, 8, 384) 0 ['block_9_depthwise_BN[0][0]'] \n", + " \n", + " block_9_project (Conv2D) (None, 8, 8, 64) 24576 ['block_9_depthwise_relu[0][0]'] \n", + " \n", + " block_9_project_BN (BatchNorma (None, 8, 8, 64) 256 ['block_9_project[0][0]'] \n", + " lization) \n", + " \n", + " block_9_add (Add) (None, 8, 8, 64) 0 ['block_8_add[0][0]', \n", + " 'block_9_project_BN[0][0]'] \n", + " \n", + " block_10_expand (Conv2D) (None, 8, 8, 384) 24576 ['block_9_add[0][0]'] \n", + " \n", + " block_10_expand_BN (BatchNorma (None, 8, 8, 384) 1536 ['block_10_expand[0][0]'] \n", + " lization) \n", + " \n", + " block_10_expand_relu (ReLU) (None, 8, 8, 384) 0 ['block_10_expand_BN[0][0]'] \n", + " \n", + " block_10_depthwise (DepthwiseC (None, 8, 8, 384) 3456 ['block_10_expand_relu[0][0]'] \n", + " onv2D) \n", + " \n", + " block_10_depthwise_BN (BatchNo (None, 8, 8, 384) 1536 ['block_10_depthwise[0][0]'] \n", + " rmalization) \n", + " \n", + " block_10_depthwise_relu (ReLU) (None, 8, 8, 384) 0 ['block_10_depthwise_BN[0][0]'] \n", + " \n", + " block_10_project (Conv2D) (None, 8, 8, 96) 36864 ['block_10_depthwise_relu[0][0]']\n", + " \n", + " block_10_project_BN (BatchNorm (None, 8, 8, 96) 384 ['block_10_project[0][0]'] \n", + " alization) \n", + " \n", + " block_11_expand (Conv2D) (None, 8, 8, 576) 55296 ['block_10_project_BN[0][0]'] \n", + " \n", + " block_11_expand_BN (BatchNorma (None, 8, 8, 576) 2304 ['block_11_expand[0][0]'] \n", + " lization) \n", + " \n", + " block_11_expand_relu (ReLU) (None, 8, 8, 576) 0 ['block_11_expand_BN[0][0]'] \n", + " \n", + " block_11_depthwise (DepthwiseC (None, 8, 8, 576) 5184 ['block_11_expand_relu[0][0]'] \n", + " onv2D) \n", + " \n", + " block_11_depthwise_BN (BatchNo (None, 8, 8, 576) 2304 ['block_11_depthwise[0][0]'] \n", + " rmalization) \n", + " \n", + " block_11_depthwise_relu (ReLU) (None, 8, 8, 576) 0 ['block_11_depthwise_BN[0][0]'] \n", + " \n", + " block_11_project (Conv2D) (None, 8, 8, 96) 55296 ['block_11_depthwise_relu[0][0]']\n", + " \n", + " block_11_project_BN (BatchNorm (None, 8, 8, 96) 384 ['block_11_project[0][0]'] \n", + " alization) \n", + " \n", + " block_11_add (Add) (None, 8, 8, 96) 0 ['block_10_project_BN[0][0]', \n", + " 'block_11_project_BN[0][0]'] \n", + " \n", + " block_12_expand (Conv2D) (None, 8, 8, 576) 55296 ['block_11_add[0][0]'] \n", + " \n", + " block_12_expand_BN (BatchNorma (None, 8, 8, 576) 2304 ['block_12_expand[0][0]'] \n", + " lization) \n", + " \n", + " block_12_expand_relu (ReLU) (None, 8, 8, 576) 0 ['block_12_expand_BN[0][0]'] \n", + " \n", + " block_12_depthwise (DepthwiseC (None, 8, 8, 576) 5184 ['block_12_expand_relu[0][0]'] \n", + " onv2D) \n", + " \n", + " block_12_depthwise_BN (BatchNo (None, 8, 8, 576) 2304 ['block_12_depthwise[0][0]'] \n", + " rmalization) \n", + " \n", + " block_12_depthwise_relu (ReLU) (None, 8, 8, 576) 0 ['block_12_depthwise_BN[0][0]'] \n", + " \n", + " block_12_project (Conv2D) (None, 8, 8, 96) 55296 ['block_12_depthwise_relu[0][0]']\n", + " \n", + " block_12_project_BN (BatchNorm (None, 8, 8, 96) 384 ['block_12_project[0][0]'] \n", + " alization) \n", + " \n", + " block_12_add (Add) (None, 8, 8, 96) 0 ['block_11_add[0][0]', \n", + " 'block_12_project_BN[0][0]'] \n", + " \n", + " block_13_expand (Conv2D) (None, 8, 8, 576) 55296 ['block_12_add[0][0]'] \n", + " \n", + " block_13_expand_BN (BatchNorma (None, 8, 8, 576) 2304 ['block_13_expand[0][0]'] \n", + " lization) \n", + " \n", + " block_13_expand_relu (ReLU) (None, 8, 8, 576) 0 ['block_13_expand_BN[0][0]'] \n", + " \n", + " block_13_pad (ZeroPadding2D) (None, 9, 9, 576) 0 ['block_13_expand_relu[0][0]'] \n", + " \n", + " block_13_depthwise (DepthwiseC (None, 4, 4, 576) 5184 ['block_13_pad[0][0]'] \n", + " onv2D) \n", + " \n", + " block_13_depthwise_BN (BatchNo (None, 4, 4, 576) 2304 ['block_13_depthwise[0][0]'] \n", + " rmalization) \n", + " \n", + " block_13_depthwise_relu (ReLU) (None, 4, 4, 576) 0 ['block_13_depthwise_BN[0][0]'] \n", + " \n", + " block_13_project (Conv2D) (None, 4, 4, 160) 92160 ['block_13_depthwise_relu[0][0]']\n", + " \n", + " block_13_project_BN (BatchNorm (None, 4, 4, 160) 640 ['block_13_project[0][0]'] \n", + " alization) \n", + " \n", + " block_14_expand (Conv2D) (None, 4, 4, 960) 153600 ['block_13_project_BN[0][0]'] \n", + " \n", + " block_14_expand_BN (BatchNorma (None, 4, 4, 960) 3840 ['block_14_expand[0][0]'] \n", + " lization) \n", + " \n", + " block_14_expand_relu (ReLU) (None, 4, 4, 960) 0 ['block_14_expand_BN[0][0]'] \n", + " \n", + " block_14_depthwise (DepthwiseC (None, 4, 4, 960) 8640 ['block_14_expand_relu[0][0]'] \n", + " onv2D) \n", + " \n", + " block_14_depthwise_BN (BatchNo (None, 4, 4, 960) 3840 ['block_14_depthwise[0][0]'] \n", + " rmalization) \n", + " \n", + " block_14_depthwise_relu (ReLU) (None, 4, 4, 960) 0 ['block_14_depthwise_BN[0][0]'] \n", + " \n", + " block_14_project (Conv2D) (None, 4, 4, 160) 153600 ['block_14_depthwise_relu[0][0]']\n", + " \n", + " block_14_project_BN (BatchNorm (None, 4, 4, 160) 640 ['block_14_project[0][0]'] \n", + " alization) \n", + " \n", + " block_14_add (Add) (None, 4, 4, 160) 0 ['block_13_project_BN[0][0]', \n", + " 'block_14_project_BN[0][0]'] \n", + " \n", + " block_15_expand (Conv2D) (None, 4, 4, 960) 153600 ['block_14_add[0][0]'] \n", + " \n", + " block_15_expand_BN (BatchNorma (None, 4, 4, 960) 3840 ['block_15_expand[0][0]'] \n", + " lization) \n", + " \n", + " block_15_expand_relu (ReLU) (None, 4, 4, 960) 0 ['block_15_expand_BN[0][0]'] \n", + " \n", + " block_15_depthwise (DepthwiseC (None, 4, 4, 960) 8640 ['block_15_expand_relu[0][0]'] \n", + " onv2D) \n", + " \n", + " block_15_depthwise_BN (BatchNo (None, 4, 4, 960) 3840 ['block_15_depthwise[0][0]'] \n", + " rmalization) \n", + " \n", + " block_15_depthwise_relu (ReLU) (None, 4, 4, 960) 0 ['block_15_depthwise_BN[0][0]'] \n", + " \n", + " block_15_project (Conv2D) (None, 4, 4, 160) 153600 ['block_15_depthwise_relu[0][0]']\n", + " \n", + " block_15_project_BN (BatchNorm (None, 4, 4, 160) 640 ['block_15_project[0][0]'] \n", + " alization) \n", + " \n", + " block_15_add (Add) (None, 4, 4, 160) 0 ['block_14_add[0][0]', \n", + " 'block_15_project_BN[0][0]'] \n", + " \n", + " block_16_expand (Conv2D) (None, 4, 4, 960) 153600 ['block_15_add[0][0]'] \n", + " \n", + " block_16_expand_BN (BatchNorma (None, 4, 4, 960) 3840 ['block_16_expand[0][0]'] \n", + " lization) \n", + " \n", + " block_16_expand_relu (ReLU) (None, 4, 4, 960) 0 ['block_16_expand_BN[0][0]'] \n", + " \n", + " block_16_depthwise (DepthwiseC (None, 4, 4, 960) 8640 ['block_16_expand_relu[0][0]'] \n", + " onv2D) \n", + " \n", + " block_16_depthwise_BN (BatchNo (None, 4, 4, 960) 3840 ['block_16_depthwise[0][0]'] \n", + " rmalization) \n", + " \n", + " block_16_depthwise_relu (ReLU) (None, 4, 4, 960) 0 ['block_16_depthwise_BN[0][0]'] \n", + " \n", + " block_16_project (Conv2D) (None, 4, 4, 320) 307200 ['block_16_depthwise_relu[0][0]']\n", + " \n", + " block_16_project_BN (BatchNorm (None, 4, 4, 320) 1280 ['block_16_project[0][0]'] \n", + " alization) \n", + " \n", + " Conv_1 (Conv2D) (None, 4, 4, 1280) 409600 ['block_16_project_BN[0][0]'] \n", + " \n", + " Conv_1_bn (BatchNormalization) (None, 4, 4, 1280) 5120 ['Conv_1[0][0]'] \n", + " \n", + " out_relu (ReLU) (None, 4, 4, 1280) 0 ['Conv_1_bn[0][0]'] \n", + " \n", + "==================================================================================================\n", + "Total params: 2,257,984\n", + "Trainable params: 0\n", + "Non-trainable params: 2,257,984\n", + "__________________________________________________________________________________________________\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Append Fully connected/custom Conv2D/Dropout/MaxPooling layers to the base model\n", + "from tensorflow import keras\n", + "from keras import layers\n", + "model=keras.Sequential([base_model,layers.Flatten(),\n", + " layers.Dense(128,activation='relu'),\n", + " layers.Dropout(0.5),\n", + " layers.Dense(64,activation='relu'),\n", + " ])" + ], + "metadata": { + "id": "MKx1EtUJea6D" + }, + "execution_count": 54, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Add the final output layer\n", + "model.add(layers.Dense(3,activation='softmax'))\n" + ], + "metadata": { + "id": "q6I3oTTNgP8L" + }, + "execution_count": 55, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Print your model's summary\n", + "model.summary()" + ], + "metadata": { + "id": "6aVQocJwgN5r", + "outputId": "1114c5f3-5ed6-4f51-c0ad-2bec1d87cf2a", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "execution_count": 56, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Model: \"sequential_3\"\n", + "_________________________________________________________________\n", + " Layer (type) Output Shape Param # \n", + "=================================================================\n", + " mobilenetv2_1.00_128 (Funct (None, 4, 4, 1280) 2257984 \n", + " ional) \n", + " \n", + " flatten_3 (Flatten) (None, 20480) 0 \n", + " \n", + " dense_9 (Dense) (None, 128) 2621568 \n", + " \n", + " dropout_3 (Dropout) (None, 128) 0 \n", + " \n", + " dense_10 (Dense) (None, 64) 8256 \n", + " \n", + " dense_11 (Dense) (None, 3) 195 \n", + " \n", + "=================================================================\n", + "Total params: 4,888,003\n", + "Trainable params: 2,630,019\n", + "Non-trainable params: 2,257,984\n", + "_________________________________________________________________\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Compile you model (set the parameters like loss/optimizers/metrics)\n", + "model.compile(optimizer = \"adam\", loss = \"categorical_crossentropy\", metrics = \"accuracy\")" + ], + "metadata": { + "id": "qdC71fUBgXAg" + }, + "execution_count": 57, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "### Data Augmentation and Pre-processing\n", + "Augment the data. You may also try dyanamic augmentation using [`tf.keras.preprocessing.image.ImageDataGenerator `](https://www.tensorflow.org/api_docs/python/tf/keras/preprocessing/image/ImageDataGenerator). \n", + "You may use [`tf.keras.applications.vgg16.preprocess_input`](https://www.tensorflow.org/api_docs/python/tf/keras/applications/vgg16/preprocess_input)(or some other base model's utility) for pre-processing (can also be passed as a parameter to `ImageDataGenerator`)" + ], + "metadata": { + "id": "RdUSMLggifex" + } + }, + { + "cell_type": "code", + "source": [ + "from keras.applications.vgg16 import preprocess_input # Change according to your base model\n", + "from tensorflow.keras.preprocessing.image import ImageDataGenerator\n", + "datagen = ImageDataGenerator(\n", + " rescale=1./255,\n", + " rotation_range=20,\n", + " width_shift_range=0.2,\n", + " height_shift_range=0.2,\n", + " horizontal_flip=True,\n", + " validation_split=0.2)\n", + "# Your code " + ], + "metadata": { + "id": "DBscSsvkgn39" + }, + "execution_count": 58, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "### Training and Validation Dataset \n", + "Split the dataset into training and validation (We'll be looking for your validation accuracy, assume we are using complete dataset for now). \n", + "\n", + "Hint: `flow_from_directory` used with `ImageDataGenerator` will simplify things for you." + ], + "metadata": { + "id": "IcKPxCpOkcuG" + } + }, + { + "cell_type": "code", + "source": [ + "# Your code\n", + "train=datagen.flow_from_directory(path,\n", + " target_size=(128,128),\n", + " color_mode='rgb',\n", + " batch_size=64,\n", + " class_mode='categorical')\n", + "\n", + "validate=datagen.flow_from_directory(path,\n", + " target_size=(128,128),\n", + " color_mode='rgb',\n", + " batch_size=64,\n", + " class_mode='categorical',\n", + " subset='validation')" + ], + "metadata": { + "id": "sB7hb3ybkJRq", + "outputId": "bba90145-1365-46e3-f648-cb02a394972b", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "execution_count": 59, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Found 8982 images belonging to 3 classes.\n", + "Found 1794 images belonging to 3 classes.\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "### Training \n", + "Train your model for some epochs and plot the graph. Try and save your best model. Experiment with the parameters of `model.fit`" + ], + "metadata": { + "id": "ZZPsjpT1mp3z" + } + }, + { + "cell_type": "code", + "source": [ + "from keras.callbacks import ModelCheckpoint\n", + "history= model.fit(train,validation_data=validate,epochs=10)\n", + "# ModelCheckpoint is helpful to save the model giving best results (brownie points)" + ], + "metadata": { + "id": "Gs2X14MBmu7W", + "outputId": "a46cf5b1-5ebc-407a-9e17-01f23b317290", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "execution_count": 60, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Epoch 1/10\n", + "141/141 [==============================] - 124s 438ms/step - loss: 0.5609 - accuracy: 0.8346 - val_loss: 0.1984 - val_accuracy: 0.9359\n", + "Epoch 2/10\n", + "141/141 [==============================] - 59s 420ms/step - loss: 0.2512 - accuracy: 0.9110 - val_loss: 0.1714 - val_accuracy: 0.9348\n", + "Epoch 3/10\n", + "141/141 [==============================] - 60s 428ms/step - loss: 0.2354 - accuracy: 0.9163 - val_loss: 0.1710 - val_accuracy: 0.9387\n", + "Epoch 4/10\n", + "141/141 [==============================] - 60s 426ms/step - loss: 0.2045 - accuracy: 0.9247 - val_loss: 0.1627 - val_accuracy: 0.9504\n", + "Epoch 5/10\n", + "141/141 [==============================] - 59s 421ms/step - loss: 0.2040 - accuracy: 0.9272 - val_loss: 0.1511 - val_accuracy: 0.9493\n", + "Epoch 6/10\n", + "141/141 [==============================] - 60s 425ms/step - loss: 0.1970 - accuracy: 0.9306 - val_loss: 0.1412 - val_accuracy: 0.9465\n", + "Epoch 7/10\n", + "141/141 [==============================] - 60s 426ms/step - loss: 0.1806 - accuracy: 0.9329 - val_loss: 0.1322 - val_accuracy: 0.9565\n", + "Epoch 8/10\n", + "141/141 [==============================] - 60s 427ms/step - loss: 0.1621 - accuracy: 0.9437 - val_loss: 0.1246 - val_accuracy: 0.9610\n", + "Epoch 9/10\n", + "141/141 [==============================] - 59s 416ms/step - loss: 0.1618 - accuracy: 0.9410 - val_loss: 0.1117 - val_accuracy: 0.9638\n", + "Epoch 10/10\n", + "141/141 [==============================] - 60s 427ms/step - loss: 0.1669 - accuracy: 0.9408 - val_loss: 0.1091 - val_accuracy: 0.9660\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "### Evaluate the performance" + ], + "metadata": { + "id": "FTvRa1FXri4R" + } + }, + { + "cell_type": "code", + "source": [ + "# Plot training & validation loss/accuracy values\n", + "acc = history.history['accuracy']\n", + "val_acc = history.history['val_accuracy']\n", + "\n", + "loss = history.history['loss']\n", + "val_loss = history.history['val_loss']\n", + "\n", + "plt.figure(figsize=(8, 8))\n", + "plt.subplot(2, 1, 1)\n", + "plt.plot(acc, label='Training Accuracy')\n", + "plt.plot(val_acc, label='Validation Accuracy')\n", + "plt.legend(loc='lower right')\n", + "plt.ylabel('Accuracy')\n", + "plt.ylim([min(plt.ylim()),1])\n", + "plt.title('Training and Validation Accuracy')\n", + "\n", + "plt.subplot(2, 1, 2)\n", + "plt.plot(loss, label='Training Loss')\n", + "plt.plot(val_loss, label='Validation Loss')\n", + "plt.legend(loc='upper right')\n", + "plt.ylabel('Cross Entropy')\n", + "plt.ylim([0,1.0])\n", + "plt.title('Training and Validation Loss')\n", + "plt.xlabel('epoch')\n", + "plt.show()" + ], + "metadata": { + "id": "cTH6flzcrck0", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 513 + }, + "outputId": "21ce5db8-89b4-4181-a63f-4ee55aefb996" + }, + "execution_count": 61, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "code", + "source": [ + "from sklearn.metrics import classification_report, confusion_matrix\n", + "import numpy as np\n", + "validation_classes = []\n", + "validation_images = []\n", + "for i in range( -(-validate.samples // validate.batch_size)):\n", + " batch = validate.next()\n", + " expected = np.argmax(batch[1], axis=1)\n", + " validation_classes.extend(expected)\n", + " validation_images.extend(batch[0])\n", + "validation_classes = np.array(validation_classes)\n", + "validation_images = np.array(validation_images)\n", + "y_pred = np.argmax(model.predict(validation_images), axis=1)\n", + "print(classification_report(validation_classes, y_pred,target_names = ['without_mask', 'mask_weared_incorrect', 'with_mask']))\n", + "# print classification report" + ], + "metadata": { + "id": "fJ-ZtU84r66Z", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "1f7e9a68-abdd-45a6-83ad-461f43f3d402" + }, + "execution_count": 62, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + " precision recall f1-score support\n", + "\n", + " without_mask 0.97 0.98 0.98 598\n", + "mask_weared_incorrect 0.95 0.98 0.96 598\n", + " with_mask 0.99 0.95 0.97 598\n", + "\n", + " accuracy 0.97 1794\n", + " macro avg 0.97 0.97 0.97 1794\n", + " weighted avg 0.97 0.97 0.97 1794\n", + "\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "" + ], + "metadata": { + "id": "I9WN1LWZV1Rz" + }, + "execution_count": null, + "outputs": [] + } + ] +} \ No newline at end of file