diff --git a/Final Task/200171_Final_Task.ipynb b/Final Task/200171_Final_Task.ipynb new file mode 100644 index 0000000..b84cdb3 --- /dev/null +++ b/Final Task/200171_Final_Task.ipynb @@ -0,0 +1,1592 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "200171_Final_Task.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": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "hNEMe7XsIjrK", + "outputId": "0a5fe144-3cb2-46f2-ba4f-02ecdef0c515" + }, + "execution_count": 2, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount(\"/content/drive\", force_remount=True).\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": 3, + "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": "3fe3505e-126a-4c80-d463-5259ec4fcd60" + }, + "execution_count": 4, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "8982\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": "efe81f50-6085-4e56-8312-c9258fd3ade1" + }, + "execution_count": 5, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "['without_mask', 'mask_weared_incorrect', '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": "7a7b662e-12d1-4311-a9df-499a8b901d04" + }, + "execution_count": 6, + "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", + "\n", + "import cv2\n", + "from google.colab.patches import cv2_imshow\n", + "for label in output_classes:\n", + " this_path=path+label\n", + " dir=pathlib.Path(this_path)\n", + " im_count=os.listdir(dir)\n", + " img_show = this_path + '/' + im_count[0]\n", + " img = cv2.imread(img_show)\n", + " cv2_imshow(img)\n", + "\n", + "# Your code" + ], + "metadata": { + "id": "HDSJ2Zk5a14s", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 401 + }, + "outputId": "b90d23eb-274a-4b3f-dfec-cfff9ee66b38" + }, + "execution_count": 7, + "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", + "\n", + "img.shape" + ], + "metadata": { + "id": "jWBEMC1FUfXS", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "c949a823-1869-489f-c214-dd742b342f35" + }, + "execution_count": 8, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(128, 128, 3)" + ] + }, + "metadata": {}, + "execution_count": 8 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Check if all the images have same shape, else you need to resize them to some common size\n", + "# The code provided as it is above in the template will help \n", + "\n", + "all_shapes = set([])\n", + "for label in output_classes:\n", + " this_path=path+label\n", + " dir=pathlib.Path(this_path)\n", + " im_count = os.listdir(dir)\n", + "\n", + " for i in im_count:\n", + " img_show = this_path + '/' + i\n", + " img = cv2.imread(img_show)\n", + " all_shapes.add(img.shape)" + ], + "metadata": { + "id": "52BhBWRab5yc" + }, + "execution_count": 12, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# If the shape is variable, reshape to a common size \n", + "# If it is same, prove it\n", + "\n", + "print(len(all_shapes))" + ], + "metadata": { + "id": "G-Atau4Rfc-x", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "4509229c-e0fa-46c2-acd5-ad21305c9acd" + }, + "execution_count": 13, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "1\n" + ] + } + ] + }, + { + "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": 14, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Choose and define base model\n", + "\n", + "IMG_HEIGHT = 128\n", + "IMG_WIDTH = 128\n", + "base_model = tf.keras.applications.inception_v3.InceptionV3(input_shape=(IMG_HEIGHT,IMG_WIDTH, 3),\n", + " include_top=False,\n", + " weights=\"imagenet\")" + ], + "metadata": { + "id": "9xWLUibHRNGj", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "9425706d-eb03-4ab3-f7ed-28ac5185254f" + }, + "execution_count": 15, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Downloading data from https://storage.googleapis.com/tensorflow/keras-applications/inception_v3/inception_v3_weights_tf_dim_ordering_tf_kernels_notop.h5\n", + "87916544/87910968 [==============================] - 3s 0us/step\n", + "87924736/87910968 [==============================] - 3s 0us/step\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Print base model summary and have a look at the layers\n", + "\n", + "base_model.summary()" + ], + "metadata": { + "id": "J3TwB_GLd7BU", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "d674226a-5e01-4be0-bb86-70f17d29b33d" + }, + "execution_count": 16, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Model: \"inception_v3\"\n", + "__________________________________________________________________________________________________\n", + " Layer (type) Output Shape Param # Connected to \n", + "==================================================================================================\n", + " input_1 (InputLayer) [(None, 128, 128, 3 0 [] \n", + " )] \n", + " \n", + " conv2d (Conv2D) (None, 63, 63, 32) 864 ['input_1[0][0]'] \n", + " \n", + " batch_normalization (BatchNorm (None, 63, 63, 32) 96 ['conv2d[0][0]'] \n", + " alization) \n", + " \n", + " activation (Activation) (None, 63, 63, 32) 0 ['batch_normalization[0][0]'] \n", + " \n", + " conv2d_1 (Conv2D) (None, 61, 61, 32) 9216 ['activation[0][0]'] \n", + " \n", + " batch_normalization_1 (BatchNo (None, 61, 61, 32) 96 ['conv2d_1[0][0]'] \n", + " rmalization) \n", + " \n", + " activation_1 (Activation) (None, 61, 61, 32) 0 ['batch_normalization_1[0][0]'] \n", + " \n", + " conv2d_2 (Conv2D) (None, 61, 61, 64) 18432 ['activation_1[0][0]'] \n", + " \n", + " batch_normalization_2 (BatchNo (None, 61, 61, 64) 192 ['conv2d_2[0][0]'] \n", + " rmalization) \n", + " \n", + " activation_2 (Activation) (None, 61, 61, 64) 0 ['batch_normalization_2[0][0]'] \n", + " \n", + " max_pooling2d (MaxPooling2D) (None, 30, 30, 64) 0 ['activation_2[0][0]'] \n", + " \n", + " conv2d_3 (Conv2D) (None, 30, 30, 80) 5120 ['max_pooling2d[0][0]'] \n", + " \n", + " batch_normalization_3 (BatchNo (None, 30, 30, 80) 240 ['conv2d_3[0][0]'] \n", + " rmalization) \n", + " \n", + " activation_3 (Activation) (None, 30, 30, 80) 0 ['batch_normalization_3[0][0]'] \n", + " \n", + " conv2d_4 (Conv2D) (None, 28, 28, 192) 138240 ['activation_3[0][0]'] \n", + " \n", + " batch_normalization_4 (BatchNo (None, 28, 28, 192) 576 ['conv2d_4[0][0]'] \n", + " rmalization) \n", + " \n", + " activation_4 (Activation) (None, 28, 28, 192) 0 ['batch_normalization_4[0][0]'] \n", + " \n", + " max_pooling2d_1 (MaxPooling2D) (None, 13, 13, 192) 0 ['activation_4[0][0]'] \n", + " \n", + " conv2d_8 (Conv2D) (None, 13, 13, 64) 12288 ['max_pooling2d_1[0][0]'] \n", + " \n", + " batch_normalization_8 (BatchNo (None, 13, 13, 64) 192 ['conv2d_8[0][0]'] \n", + " rmalization) \n", + " \n", + " activation_8 (Activation) (None, 13, 13, 64) 0 ['batch_normalization_8[0][0]'] \n", + " \n", + " conv2d_6 (Conv2D) (None, 13, 13, 48) 9216 ['max_pooling2d_1[0][0]'] \n", + " \n", + " conv2d_9 (Conv2D) (None, 13, 13, 96) 55296 ['activation_8[0][0]'] \n", + " \n", + " batch_normalization_6 (BatchNo (None, 13, 13, 48) 144 ['conv2d_6[0][0]'] \n", + " rmalization) \n", + " \n", + " batch_normalization_9 (BatchNo (None, 13, 13, 96) 288 ['conv2d_9[0][0]'] \n", + " rmalization) \n", + " \n", + " activation_6 (Activation) (None, 13, 13, 48) 0 ['batch_normalization_6[0][0]'] \n", + " \n", + " activation_9 (Activation) (None, 13, 13, 96) 0 ['batch_normalization_9[0][0]'] \n", + " \n", + " average_pooling2d (AveragePool (None, 13, 13, 192) 0 ['max_pooling2d_1[0][0]'] \n", + " ing2D) \n", + " \n", + " conv2d_5 (Conv2D) (None, 13, 13, 64) 12288 ['max_pooling2d_1[0][0]'] \n", + " \n", + " conv2d_7 (Conv2D) (None, 13, 13, 64) 76800 ['activation_6[0][0]'] \n", + " \n", + " conv2d_10 (Conv2D) (None, 13, 13, 96) 82944 ['activation_9[0][0]'] \n", + " \n", + " conv2d_11 (Conv2D) (None, 13, 13, 32) 6144 ['average_pooling2d[0][0]'] \n", + " \n", + " batch_normalization_5 (BatchNo (None, 13, 13, 64) 192 ['conv2d_5[0][0]'] \n", + " rmalization) \n", + " \n", + " batch_normalization_7 (BatchNo (None, 13, 13, 64) 192 ['conv2d_7[0][0]'] \n", + " rmalization) \n", + " \n", + " batch_normalization_10 (BatchN (None, 13, 13, 96) 288 ['conv2d_10[0][0]'] \n", + " ormalization) \n", + " \n", + " batch_normalization_11 (BatchN (None, 13, 13, 32) 96 ['conv2d_11[0][0]'] \n", + " ormalization) \n", + " \n", + " activation_5 (Activation) (None, 13, 13, 64) 0 ['batch_normalization_5[0][0]'] \n", + " \n", + " activation_7 (Activation) (None, 13, 13, 64) 0 ['batch_normalization_7[0][0]'] \n", + " \n", + " activation_10 (Activation) (None, 13, 13, 96) 0 ['batch_normalization_10[0][0]'] \n", + " \n", + " activation_11 (Activation) (None, 13, 13, 32) 0 ['batch_normalization_11[0][0]'] \n", + " \n", + " mixed0 (Concatenate) (None, 13, 13, 256) 0 ['activation_5[0][0]', \n", + " 'activation_7[0][0]', \n", + " 'activation_10[0][0]', \n", + " 'activation_11[0][0]'] \n", + " \n", + " conv2d_15 (Conv2D) (None, 13, 13, 64) 16384 ['mixed0[0][0]'] \n", + " \n", + " batch_normalization_15 (BatchN (None, 13, 13, 64) 192 ['conv2d_15[0][0]'] \n", + " ormalization) \n", + " \n", + " activation_15 (Activation) (None, 13, 13, 64) 0 ['batch_normalization_15[0][0]'] \n", + " \n", + " conv2d_13 (Conv2D) (None, 13, 13, 48) 12288 ['mixed0[0][0]'] \n", + " \n", + " conv2d_16 (Conv2D) (None, 13, 13, 96) 55296 ['activation_15[0][0]'] \n", + " \n", + " batch_normalization_13 (BatchN (None, 13, 13, 48) 144 ['conv2d_13[0][0]'] \n", + " ormalization) \n", + " \n", + " batch_normalization_16 (BatchN (None, 13, 13, 96) 288 ['conv2d_16[0][0]'] \n", + " ormalization) \n", + " \n", + " activation_13 (Activation) (None, 13, 13, 48) 0 ['batch_normalization_13[0][0]'] \n", + " \n", + " activation_16 (Activation) (None, 13, 13, 96) 0 ['batch_normalization_16[0][0]'] \n", + " \n", + " average_pooling2d_1 (AveragePo (None, 13, 13, 256) 0 ['mixed0[0][0]'] \n", + " oling2D) \n", + " \n", + " conv2d_12 (Conv2D) (None, 13, 13, 64) 16384 ['mixed0[0][0]'] \n", + " \n", + " conv2d_14 (Conv2D) (None, 13, 13, 64) 76800 ['activation_13[0][0]'] \n", + " \n", + " conv2d_17 (Conv2D) (None, 13, 13, 96) 82944 ['activation_16[0][0]'] \n", + " \n", + " conv2d_18 (Conv2D) (None, 13, 13, 64) 16384 ['average_pooling2d_1[0][0]'] \n", + " \n", + " batch_normalization_12 (BatchN (None, 13, 13, 64) 192 ['conv2d_12[0][0]'] \n", + " ormalization) \n", + " \n", + " batch_normalization_14 (BatchN (None, 13, 13, 64) 192 ['conv2d_14[0][0]'] \n", + " ormalization) \n", + " \n", + " batch_normalization_17 (BatchN (None, 13, 13, 96) 288 ['conv2d_17[0][0]'] \n", + " ormalization) \n", + " \n", + " batch_normalization_18 (BatchN (None, 13, 13, 64) 192 ['conv2d_18[0][0]'] \n", + " ormalization) \n", + " \n", + " activation_12 (Activation) (None, 13, 13, 64) 0 ['batch_normalization_12[0][0]'] \n", + " \n", + " activation_14 (Activation) (None, 13, 13, 64) 0 ['batch_normalization_14[0][0]'] \n", + " \n", + " activation_17 (Activation) (None, 13, 13, 96) 0 ['batch_normalization_17[0][0]'] \n", + " \n", + " activation_18 (Activation) (None, 13, 13, 64) 0 ['batch_normalization_18[0][0]'] \n", + " \n", + " mixed1 (Concatenate) (None, 13, 13, 288) 0 ['activation_12[0][0]', \n", + " 'activation_14[0][0]', \n", + " 'activation_17[0][0]', \n", + " 'activation_18[0][0]'] \n", + " \n", + " conv2d_22 (Conv2D) (None, 13, 13, 64) 18432 ['mixed1[0][0]'] \n", + " \n", + " batch_normalization_22 (BatchN (None, 13, 13, 64) 192 ['conv2d_22[0][0]'] \n", + " ormalization) \n", + " \n", + " activation_22 (Activation) (None, 13, 13, 64) 0 ['batch_normalization_22[0][0]'] \n", + " \n", + " conv2d_20 (Conv2D) (None, 13, 13, 48) 13824 ['mixed1[0][0]'] \n", + " \n", + " conv2d_23 (Conv2D) (None, 13, 13, 96) 55296 ['activation_22[0][0]'] \n", + " \n", + " batch_normalization_20 (BatchN (None, 13, 13, 48) 144 ['conv2d_20[0][0]'] \n", + " ormalization) \n", + " \n", + " batch_normalization_23 (BatchN (None, 13, 13, 96) 288 ['conv2d_23[0][0]'] \n", + " ormalization) \n", + " \n", + " activation_20 (Activation) (None, 13, 13, 48) 0 ['batch_normalization_20[0][0]'] \n", + " \n", + " activation_23 (Activation) (None, 13, 13, 96) 0 ['batch_normalization_23[0][0]'] \n", + " \n", + " average_pooling2d_2 (AveragePo (None, 13, 13, 288) 0 ['mixed1[0][0]'] \n", + " oling2D) \n", + " \n", + " conv2d_19 (Conv2D) (None, 13, 13, 64) 18432 ['mixed1[0][0]'] \n", + " \n", + " conv2d_21 (Conv2D) (None, 13, 13, 64) 76800 ['activation_20[0][0]'] \n", + " \n", + " conv2d_24 (Conv2D) (None, 13, 13, 96) 82944 ['activation_23[0][0]'] \n", + " \n", + " conv2d_25 (Conv2D) (None, 13, 13, 64) 18432 ['average_pooling2d_2[0][0]'] \n", + " \n", + " batch_normalization_19 (BatchN (None, 13, 13, 64) 192 ['conv2d_19[0][0]'] \n", + " ormalization) \n", + " \n", + " batch_normalization_21 (BatchN (None, 13, 13, 64) 192 ['conv2d_21[0][0]'] \n", + " ormalization) \n", + " \n", + " batch_normalization_24 (BatchN (None, 13, 13, 96) 288 ['conv2d_24[0][0]'] \n", + " ormalization) \n", + " \n", + " batch_normalization_25 (BatchN (None, 13, 13, 64) 192 ['conv2d_25[0][0]'] \n", + " ormalization) \n", + " \n", + " activation_19 (Activation) (None, 13, 13, 64) 0 ['batch_normalization_19[0][0]'] \n", + " \n", + " activation_21 (Activation) (None, 13, 13, 64) 0 ['batch_normalization_21[0][0]'] \n", + " \n", + " activation_24 (Activation) (None, 13, 13, 96) 0 ['batch_normalization_24[0][0]'] \n", + " \n", + " activation_25 (Activation) (None, 13, 13, 64) 0 ['batch_normalization_25[0][0]'] \n", + " \n", + " mixed2 (Concatenate) (None, 13, 13, 288) 0 ['activation_19[0][0]', \n", + " 'activation_21[0][0]', \n", + " 'activation_24[0][0]', \n", + " 'activation_25[0][0]'] \n", + " \n", + " conv2d_27 (Conv2D) (None, 13, 13, 64) 18432 ['mixed2[0][0]'] \n", + " \n", + " batch_normalization_27 (BatchN (None, 13, 13, 64) 192 ['conv2d_27[0][0]'] \n", + " ormalization) \n", + " \n", + " activation_27 (Activation) (None, 13, 13, 64) 0 ['batch_normalization_27[0][0]'] \n", + " \n", + " conv2d_28 (Conv2D) (None, 13, 13, 96) 55296 ['activation_27[0][0]'] \n", + " \n", + " batch_normalization_28 (BatchN (None, 13, 13, 96) 288 ['conv2d_28[0][0]'] \n", + " ormalization) \n", + " \n", + " activation_28 (Activation) (None, 13, 13, 96) 0 ['batch_normalization_28[0][0]'] \n", + " \n", + " conv2d_26 (Conv2D) (None, 6, 6, 384) 995328 ['mixed2[0][0]'] \n", + " \n", + " conv2d_29 (Conv2D) (None, 6, 6, 96) 82944 ['activation_28[0][0]'] \n", + " \n", + " batch_normalization_26 (BatchN (None, 6, 6, 384) 1152 ['conv2d_26[0][0]'] \n", + " ormalization) \n", + " \n", + " batch_normalization_29 (BatchN (None, 6, 6, 96) 288 ['conv2d_29[0][0]'] \n", + " ormalization) \n", + " \n", + " activation_26 (Activation) (None, 6, 6, 384) 0 ['batch_normalization_26[0][0]'] \n", + " \n", + " activation_29 (Activation) (None, 6, 6, 96) 0 ['batch_normalization_29[0][0]'] \n", + " \n", + " max_pooling2d_2 (MaxPooling2D) (None, 6, 6, 288) 0 ['mixed2[0][0]'] \n", + " \n", + " mixed3 (Concatenate) (None, 6, 6, 768) 0 ['activation_26[0][0]', \n", + " 'activation_29[0][0]', \n", + " 'max_pooling2d_2[0][0]'] \n", + " \n", + " conv2d_34 (Conv2D) (None, 6, 6, 128) 98304 ['mixed3[0][0]'] \n", + " \n", + " batch_normalization_34 (BatchN (None, 6, 6, 128) 384 ['conv2d_34[0][0]'] \n", + " ormalization) \n", + " \n", + " activation_34 (Activation) (None, 6, 6, 128) 0 ['batch_normalization_34[0][0]'] \n", + " \n", + " conv2d_35 (Conv2D) (None, 6, 6, 128) 114688 ['activation_34[0][0]'] \n", + " \n", + " batch_normalization_35 (BatchN (None, 6, 6, 128) 384 ['conv2d_35[0][0]'] \n", + " ormalization) \n", + " \n", + " activation_35 (Activation) (None, 6, 6, 128) 0 ['batch_normalization_35[0][0]'] \n", + " \n", + " conv2d_31 (Conv2D) (None, 6, 6, 128) 98304 ['mixed3[0][0]'] \n", + " \n", + " conv2d_36 (Conv2D) (None, 6, 6, 128) 114688 ['activation_35[0][0]'] \n", + " \n", + " batch_normalization_31 (BatchN (None, 6, 6, 128) 384 ['conv2d_31[0][0]'] \n", + " ormalization) \n", + " \n", + " batch_normalization_36 (BatchN (None, 6, 6, 128) 384 ['conv2d_36[0][0]'] \n", + " ormalization) \n", + " \n", + " activation_31 (Activation) (None, 6, 6, 128) 0 ['batch_normalization_31[0][0]'] \n", + " \n", + " activation_36 (Activation) (None, 6, 6, 128) 0 ['batch_normalization_36[0][0]'] \n", + " \n", + " conv2d_32 (Conv2D) (None, 6, 6, 128) 114688 ['activation_31[0][0]'] \n", + " \n", + " conv2d_37 (Conv2D) (None, 6, 6, 128) 114688 ['activation_36[0][0]'] \n", + " \n", + " batch_normalization_32 (BatchN (None, 6, 6, 128) 384 ['conv2d_32[0][0]'] \n", + " ormalization) \n", + " \n", + " batch_normalization_37 (BatchN (None, 6, 6, 128) 384 ['conv2d_37[0][0]'] \n", + " ormalization) \n", + " \n", + " activation_32 (Activation) (None, 6, 6, 128) 0 ['batch_normalization_32[0][0]'] \n", + " \n", + " activation_37 (Activation) (None, 6, 6, 128) 0 ['batch_normalization_37[0][0]'] \n", + " \n", + " average_pooling2d_3 (AveragePo (None, 6, 6, 768) 0 ['mixed3[0][0]'] \n", + " oling2D) \n", + " \n", + " conv2d_30 (Conv2D) (None, 6, 6, 192) 147456 ['mixed3[0][0]'] \n", + " \n", + " conv2d_33 (Conv2D) (None, 6, 6, 192) 172032 ['activation_32[0][0]'] \n", + " \n", + " conv2d_38 (Conv2D) (None, 6, 6, 192) 172032 ['activation_37[0][0]'] \n", + " \n", + " conv2d_39 (Conv2D) (None, 6, 6, 192) 147456 ['average_pooling2d_3[0][0]'] \n", + " \n", + " batch_normalization_30 (BatchN (None, 6, 6, 192) 576 ['conv2d_30[0][0]'] \n", + " ormalization) \n", + " \n", + " batch_normalization_33 (BatchN (None, 6, 6, 192) 576 ['conv2d_33[0][0]'] \n", + " ormalization) \n", + " \n", + " batch_normalization_38 (BatchN (None, 6, 6, 192) 576 ['conv2d_38[0][0]'] \n", + " ormalization) \n", + " \n", + " batch_normalization_39 (BatchN (None, 6, 6, 192) 576 ['conv2d_39[0][0]'] \n", + " ormalization) \n", + " \n", + " activation_30 (Activation) (None, 6, 6, 192) 0 ['batch_normalization_30[0][0]'] \n", + " \n", + " activation_33 (Activation) (None, 6, 6, 192) 0 ['batch_normalization_33[0][0]'] \n", + " \n", + " activation_38 (Activation) (None, 6, 6, 192) 0 ['batch_normalization_38[0][0]'] \n", + " \n", + " activation_39 (Activation) (None, 6, 6, 192) 0 ['batch_normalization_39[0][0]'] \n", + " \n", + " mixed4 (Concatenate) (None, 6, 6, 768) 0 ['activation_30[0][0]', \n", + " 'activation_33[0][0]', \n", + " 'activation_38[0][0]', \n", + " 'activation_39[0][0]'] \n", + " \n", + " conv2d_44 (Conv2D) (None, 6, 6, 160) 122880 ['mixed4[0][0]'] \n", + " \n", + " batch_normalization_44 (BatchN (None, 6, 6, 160) 480 ['conv2d_44[0][0]'] \n", + " ormalization) \n", + " \n", + " activation_44 (Activation) (None, 6, 6, 160) 0 ['batch_normalization_44[0][0]'] \n", + " \n", + " conv2d_45 (Conv2D) (None, 6, 6, 160) 179200 ['activation_44[0][0]'] \n", + " \n", + " batch_normalization_45 (BatchN (None, 6, 6, 160) 480 ['conv2d_45[0][0]'] \n", + " ormalization) \n", + " \n", + " activation_45 (Activation) (None, 6, 6, 160) 0 ['batch_normalization_45[0][0]'] \n", + " \n", + " conv2d_41 (Conv2D) (None, 6, 6, 160) 122880 ['mixed4[0][0]'] \n", + " \n", + " conv2d_46 (Conv2D) (None, 6, 6, 160) 179200 ['activation_45[0][0]'] \n", + " \n", + " batch_normalization_41 (BatchN (None, 6, 6, 160) 480 ['conv2d_41[0][0]'] \n", + " ormalization) \n", + " \n", + " batch_normalization_46 (BatchN (None, 6, 6, 160) 480 ['conv2d_46[0][0]'] \n", + " ormalization) \n", + " \n", + " activation_41 (Activation) (None, 6, 6, 160) 0 ['batch_normalization_41[0][0]'] \n", + " \n", + " activation_46 (Activation) (None, 6, 6, 160) 0 ['batch_normalization_46[0][0]'] \n", + " \n", + " conv2d_42 (Conv2D) (None, 6, 6, 160) 179200 ['activation_41[0][0]'] \n", + " \n", + " conv2d_47 (Conv2D) (None, 6, 6, 160) 179200 ['activation_46[0][0]'] \n", + " \n", + " batch_normalization_42 (BatchN (None, 6, 6, 160) 480 ['conv2d_42[0][0]'] \n", + " ormalization) \n", + " \n", + " batch_normalization_47 (BatchN (None, 6, 6, 160) 480 ['conv2d_47[0][0]'] \n", + " ormalization) \n", + " \n", + " activation_42 (Activation) (None, 6, 6, 160) 0 ['batch_normalization_42[0][0]'] \n", + " \n", + " activation_47 (Activation) (None, 6, 6, 160) 0 ['batch_normalization_47[0][0]'] \n", + " \n", + " average_pooling2d_4 (AveragePo (None, 6, 6, 768) 0 ['mixed4[0][0]'] \n", + " oling2D) \n", + " \n", + " conv2d_40 (Conv2D) (None, 6, 6, 192) 147456 ['mixed4[0][0]'] \n", + " \n", + " conv2d_43 (Conv2D) (None, 6, 6, 192) 215040 ['activation_42[0][0]'] \n", + " \n", + " conv2d_48 (Conv2D) (None, 6, 6, 192) 215040 ['activation_47[0][0]'] \n", + " \n", + " conv2d_49 (Conv2D) (None, 6, 6, 192) 147456 ['average_pooling2d_4[0][0]'] \n", + " \n", + " batch_normalization_40 (BatchN (None, 6, 6, 192) 576 ['conv2d_40[0][0]'] \n", + " ormalization) \n", + " \n", + " batch_normalization_43 (BatchN (None, 6, 6, 192) 576 ['conv2d_43[0][0]'] \n", + " ormalization) \n", + " \n", + " batch_normalization_48 (BatchN (None, 6, 6, 192) 576 ['conv2d_48[0][0]'] \n", + " ormalization) \n", + " \n", + " batch_normalization_49 (BatchN (None, 6, 6, 192) 576 ['conv2d_49[0][0]'] \n", + " ormalization) \n", + " \n", + " activation_40 (Activation) (None, 6, 6, 192) 0 ['batch_normalization_40[0][0]'] \n", + " \n", + " activation_43 (Activation) (None, 6, 6, 192) 0 ['batch_normalization_43[0][0]'] \n", + " \n", + " activation_48 (Activation) (None, 6, 6, 192) 0 ['batch_normalization_48[0][0]'] \n", + " \n", + " activation_49 (Activation) (None, 6, 6, 192) 0 ['batch_normalization_49[0][0]'] \n", + " \n", + " mixed5 (Concatenate) (None, 6, 6, 768) 0 ['activation_40[0][0]', \n", + " 'activation_43[0][0]', \n", + " 'activation_48[0][0]', \n", + " 'activation_49[0][0]'] \n", + " \n", + " conv2d_54 (Conv2D) (None, 6, 6, 160) 122880 ['mixed5[0][0]'] \n", + " \n", + " batch_normalization_54 (BatchN (None, 6, 6, 160) 480 ['conv2d_54[0][0]'] \n", + " ormalization) \n", + " \n", + " activation_54 (Activation) (None, 6, 6, 160) 0 ['batch_normalization_54[0][0]'] \n", + " \n", + " conv2d_55 (Conv2D) (None, 6, 6, 160) 179200 ['activation_54[0][0]'] \n", + " \n", + " batch_normalization_55 (BatchN (None, 6, 6, 160) 480 ['conv2d_55[0][0]'] \n", + " ormalization) \n", + " \n", + " activation_55 (Activation) (None, 6, 6, 160) 0 ['batch_normalization_55[0][0]'] \n", + " \n", + " conv2d_51 (Conv2D) (None, 6, 6, 160) 122880 ['mixed5[0][0]'] \n", + " \n", + " conv2d_56 (Conv2D) (None, 6, 6, 160) 179200 ['activation_55[0][0]'] \n", + " \n", + " batch_normalization_51 (BatchN (None, 6, 6, 160) 480 ['conv2d_51[0][0]'] \n", + " ormalization) \n", + " \n", + " batch_normalization_56 (BatchN (None, 6, 6, 160) 480 ['conv2d_56[0][0]'] \n", + " ormalization) \n", + " \n", + " activation_51 (Activation) (None, 6, 6, 160) 0 ['batch_normalization_51[0][0]'] \n", + " \n", + " activation_56 (Activation) (None, 6, 6, 160) 0 ['batch_normalization_56[0][0]'] \n", + " \n", + " conv2d_52 (Conv2D) (None, 6, 6, 160) 179200 ['activation_51[0][0]'] \n", + " \n", + " conv2d_57 (Conv2D) (None, 6, 6, 160) 179200 ['activation_56[0][0]'] \n", + " \n", + " batch_normalization_52 (BatchN (None, 6, 6, 160) 480 ['conv2d_52[0][0]'] \n", + " ormalization) \n", + " \n", + " batch_normalization_57 (BatchN (None, 6, 6, 160) 480 ['conv2d_57[0][0]'] \n", + " ormalization) \n", + " \n", + " activation_52 (Activation) (None, 6, 6, 160) 0 ['batch_normalization_52[0][0]'] \n", + " \n", + " activation_57 (Activation) (None, 6, 6, 160) 0 ['batch_normalization_57[0][0]'] \n", + " \n", + " average_pooling2d_5 (AveragePo (None, 6, 6, 768) 0 ['mixed5[0][0]'] \n", + " oling2D) \n", + " \n", + " conv2d_50 (Conv2D) (None, 6, 6, 192) 147456 ['mixed5[0][0]'] \n", + " \n", + " conv2d_53 (Conv2D) (None, 6, 6, 192) 215040 ['activation_52[0][0]'] \n", + " \n", + " conv2d_58 (Conv2D) (None, 6, 6, 192) 215040 ['activation_57[0][0]'] \n", + " \n", + " conv2d_59 (Conv2D) (None, 6, 6, 192) 147456 ['average_pooling2d_5[0][0]'] \n", + " \n", + " batch_normalization_50 (BatchN (None, 6, 6, 192) 576 ['conv2d_50[0][0]'] \n", + " ormalization) \n", + " \n", + " batch_normalization_53 (BatchN (None, 6, 6, 192) 576 ['conv2d_53[0][0]'] \n", + " ormalization) \n", + " \n", + " batch_normalization_58 (BatchN (None, 6, 6, 192) 576 ['conv2d_58[0][0]'] \n", + " ormalization) \n", + " \n", + " batch_normalization_59 (BatchN (None, 6, 6, 192) 576 ['conv2d_59[0][0]'] \n", + " ormalization) \n", + " \n", + " activation_50 (Activation) (None, 6, 6, 192) 0 ['batch_normalization_50[0][0]'] \n", + " \n", + " activation_53 (Activation) (None, 6, 6, 192) 0 ['batch_normalization_53[0][0]'] \n", + " \n", + " activation_58 (Activation) (None, 6, 6, 192) 0 ['batch_normalization_58[0][0]'] \n", + " \n", + " activation_59 (Activation) (None, 6, 6, 192) 0 ['batch_normalization_59[0][0]'] \n", + " \n", + " mixed6 (Concatenate) (None, 6, 6, 768) 0 ['activation_50[0][0]', \n", + " 'activation_53[0][0]', \n", + " 'activation_58[0][0]', \n", + " 'activation_59[0][0]'] \n", + " \n", + " conv2d_64 (Conv2D) (None, 6, 6, 192) 147456 ['mixed6[0][0]'] \n", + " \n", + " batch_normalization_64 (BatchN (None, 6, 6, 192) 576 ['conv2d_64[0][0]'] \n", + " ormalization) \n", + " \n", + " activation_64 (Activation) (None, 6, 6, 192) 0 ['batch_normalization_64[0][0]'] \n", + " \n", + " conv2d_65 (Conv2D) (None, 6, 6, 192) 258048 ['activation_64[0][0]'] \n", + " \n", + " batch_normalization_65 (BatchN (None, 6, 6, 192) 576 ['conv2d_65[0][0]'] \n", + " ormalization) \n", + " \n", + " activation_65 (Activation) (None, 6, 6, 192) 0 ['batch_normalization_65[0][0]'] \n", + " \n", + " conv2d_61 (Conv2D) (None, 6, 6, 192) 147456 ['mixed6[0][0]'] \n", + " \n", + " conv2d_66 (Conv2D) (None, 6, 6, 192) 258048 ['activation_65[0][0]'] \n", + " \n", + " batch_normalization_61 (BatchN (None, 6, 6, 192) 576 ['conv2d_61[0][0]'] \n", + " ormalization) \n", + " \n", + " batch_normalization_66 (BatchN (None, 6, 6, 192) 576 ['conv2d_66[0][0]'] \n", + " ormalization) \n", + " \n", + " activation_61 (Activation) (None, 6, 6, 192) 0 ['batch_normalization_61[0][0]'] \n", + " \n", + " activation_66 (Activation) (None, 6, 6, 192) 0 ['batch_normalization_66[0][0]'] \n", + " \n", + " conv2d_62 (Conv2D) (None, 6, 6, 192) 258048 ['activation_61[0][0]'] \n", + " \n", + " conv2d_67 (Conv2D) (None, 6, 6, 192) 258048 ['activation_66[0][0]'] \n", + " \n", + " batch_normalization_62 (BatchN (None, 6, 6, 192) 576 ['conv2d_62[0][0]'] \n", + " ormalization) \n", + " \n", + " batch_normalization_67 (BatchN (None, 6, 6, 192) 576 ['conv2d_67[0][0]'] \n", + " ormalization) \n", + " \n", + " activation_62 (Activation) (None, 6, 6, 192) 0 ['batch_normalization_62[0][0]'] \n", + " \n", + " activation_67 (Activation) (None, 6, 6, 192) 0 ['batch_normalization_67[0][0]'] \n", + " \n", + " average_pooling2d_6 (AveragePo (None, 6, 6, 768) 0 ['mixed6[0][0]'] \n", + " oling2D) \n", + " \n", + " conv2d_60 (Conv2D) (None, 6, 6, 192) 147456 ['mixed6[0][0]'] \n", + " \n", + " conv2d_63 (Conv2D) (None, 6, 6, 192) 258048 ['activation_62[0][0]'] \n", + " \n", + " conv2d_68 (Conv2D) (None, 6, 6, 192) 258048 ['activation_67[0][0]'] \n", + " \n", + " conv2d_69 (Conv2D) (None, 6, 6, 192) 147456 ['average_pooling2d_6[0][0]'] \n", + " \n", + " batch_normalization_60 (BatchN (None, 6, 6, 192) 576 ['conv2d_60[0][0]'] \n", + " ormalization) \n", + " \n", + " batch_normalization_63 (BatchN (None, 6, 6, 192) 576 ['conv2d_63[0][0]'] \n", + " ormalization) \n", + " \n", + " batch_normalization_68 (BatchN (None, 6, 6, 192) 576 ['conv2d_68[0][0]'] \n", + " ormalization) \n", + " \n", + " batch_normalization_69 (BatchN (None, 6, 6, 192) 576 ['conv2d_69[0][0]'] \n", + " ormalization) \n", + " \n", + " activation_60 (Activation) (None, 6, 6, 192) 0 ['batch_normalization_60[0][0]'] \n", + " \n", + " activation_63 (Activation) (None, 6, 6, 192) 0 ['batch_normalization_63[0][0]'] \n", + " \n", + " activation_68 (Activation) (None, 6, 6, 192) 0 ['batch_normalization_68[0][0]'] \n", + " \n", + " activation_69 (Activation) (None, 6, 6, 192) 0 ['batch_normalization_69[0][0]'] \n", + " \n", + " mixed7 (Concatenate) (None, 6, 6, 768) 0 ['activation_60[0][0]', \n", + " 'activation_63[0][0]', \n", + " 'activation_68[0][0]', \n", + " 'activation_69[0][0]'] \n", + " \n", + " conv2d_72 (Conv2D) (None, 6, 6, 192) 147456 ['mixed7[0][0]'] \n", + " \n", + " batch_normalization_72 (BatchN (None, 6, 6, 192) 576 ['conv2d_72[0][0]'] \n", + " ormalization) \n", + " \n", + " activation_72 (Activation) (None, 6, 6, 192) 0 ['batch_normalization_72[0][0]'] \n", + " \n", + " conv2d_73 (Conv2D) (None, 6, 6, 192) 258048 ['activation_72[0][0]'] \n", + " \n", + " batch_normalization_73 (BatchN (None, 6, 6, 192) 576 ['conv2d_73[0][0]'] \n", + " ormalization) \n", + " \n", + " activation_73 (Activation) (None, 6, 6, 192) 0 ['batch_normalization_73[0][0]'] \n", + " \n", + " conv2d_70 (Conv2D) (None, 6, 6, 192) 147456 ['mixed7[0][0]'] \n", + " \n", + " conv2d_74 (Conv2D) (None, 6, 6, 192) 258048 ['activation_73[0][0]'] \n", + " \n", + " batch_normalization_70 (BatchN (None, 6, 6, 192) 576 ['conv2d_70[0][0]'] \n", + " ormalization) \n", + " \n", + " batch_normalization_74 (BatchN (None, 6, 6, 192) 576 ['conv2d_74[0][0]'] \n", + " ormalization) \n", + " \n", + " activation_70 (Activation) (None, 6, 6, 192) 0 ['batch_normalization_70[0][0]'] \n", + " \n", + " activation_74 (Activation) (None, 6, 6, 192) 0 ['batch_normalization_74[0][0]'] \n", + " \n", + " conv2d_71 (Conv2D) (None, 2, 2, 320) 552960 ['activation_70[0][0]'] \n", + " \n", + " conv2d_75 (Conv2D) (None, 2, 2, 192) 331776 ['activation_74[0][0]'] \n", + " \n", + " batch_normalization_71 (BatchN (None, 2, 2, 320) 960 ['conv2d_71[0][0]'] \n", + " ormalization) \n", + " \n", + " batch_normalization_75 (BatchN (None, 2, 2, 192) 576 ['conv2d_75[0][0]'] \n", + " ormalization) \n", + " \n", + " activation_71 (Activation) (None, 2, 2, 320) 0 ['batch_normalization_71[0][0]'] \n", + " \n", + " activation_75 (Activation) (None, 2, 2, 192) 0 ['batch_normalization_75[0][0]'] \n", + " \n", + " max_pooling2d_3 (MaxPooling2D) (None, 2, 2, 768) 0 ['mixed7[0][0]'] \n", + " \n", + " mixed8 (Concatenate) (None, 2, 2, 1280) 0 ['activation_71[0][0]', \n", + " 'activation_75[0][0]', \n", + " 'max_pooling2d_3[0][0]'] \n", + " \n", + " conv2d_80 (Conv2D) (None, 2, 2, 448) 573440 ['mixed8[0][0]'] \n", + " \n", + " batch_normalization_80 (BatchN (None, 2, 2, 448) 1344 ['conv2d_80[0][0]'] \n", + " ormalization) \n", + " \n", + " activation_80 (Activation) (None, 2, 2, 448) 0 ['batch_normalization_80[0][0]'] \n", + " \n", + " conv2d_77 (Conv2D) (None, 2, 2, 384) 491520 ['mixed8[0][0]'] \n", + " \n", + " conv2d_81 (Conv2D) (None, 2, 2, 384) 1548288 ['activation_80[0][0]'] \n", + " \n", + " batch_normalization_77 (BatchN (None, 2, 2, 384) 1152 ['conv2d_77[0][0]'] \n", + " ormalization) \n", + " \n", + " batch_normalization_81 (BatchN (None, 2, 2, 384) 1152 ['conv2d_81[0][0]'] \n", + " ormalization) \n", + " \n", + " activation_77 (Activation) (None, 2, 2, 384) 0 ['batch_normalization_77[0][0]'] \n", + " \n", + " activation_81 (Activation) (None, 2, 2, 384) 0 ['batch_normalization_81[0][0]'] \n", + " \n", + " conv2d_78 (Conv2D) (None, 2, 2, 384) 442368 ['activation_77[0][0]'] \n", + " \n", + " conv2d_79 (Conv2D) (None, 2, 2, 384) 442368 ['activation_77[0][0]'] \n", + " \n", + " conv2d_82 (Conv2D) (None, 2, 2, 384) 442368 ['activation_81[0][0]'] \n", + " \n", + " conv2d_83 (Conv2D) (None, 2, 2, 384) 442368 ['activation_81[0][0]'] \n", + " \n", + " average_pooling2d_7 (AveragePo (None, 2, 2, 1280) 0 ['mixed8[0][0]'] \n", + " oling2D) \n", + " \n", + " conv2d_76 (Conv2D) (None, 2, 2, 320) 409600 ['mixed8[0][0]'] \n", + " \n", + " batch_normalization_78 (BatchN (None, 2, 2, 384) 1152 ['conv2d_78[0][0]'] \n", + " ormalization) \n", + " \n", + " batch_normalization_79 (BatchN (None, 2, 2, 384) 1152 ['conv2d_79[0][0]'] \n", + " ormalization) \n", + " \n", + " batch_normalization_82 (BatchN (None, 2, 2, 384) 1152 ['conv2d_82[0][0]'] \n", + " ormalization) \n", + " \n", + " batch_normalization_83 (BatchN (None, 2, 2, 384) 1152 ['conv2d_83[0][0]'] \n", + " ormalization) \n", + " \n", + " conv2d_84 (Conv2D) (None, 2, 2, 192) 245760 ['average_pooling2d_7[0][0]'] \n", + " \n", + " batch_normalization_76 (BatchN (None, 2, 2, 320) 960 ['conv2d_76[0][0]'] \n", + " ormalization) \n", + " \n", + " activation_78 (Activation) (None, 2, 2, 384) 0 ['batch_normalization_78[0][0]'] \n", + " \n", + " activation_79 (Activation) (None, 2, 2, 384) 0 ['batch_normalization_79[0][0]'] \n", + " \n", + " activation_82 (Activation) (None, 2, 2, 384) 0 ['batch_normalization_82[0][0]'] \n", + " \n", + " activation_83 (Activation) (None, 2, 2, 384) 0 ['batch_normalization_83[0][0]'] \n", + " \n", + " batch_normalization_84 (BatchN (None, 2, 2, 192) 576 ['conv2d_84[0][0]'] \n", + " ormalization) \n", + " \n", + " activation_76 (Activation) (None, 2, 2, 320) 0 ['batch_normalization_76[0][0]'] \n", + " \n", + " mixed9_0 (Concatenate) (None, 2, 2, 768) 0 ['activation_78[0][0]', \n", + " 'activation_79[0][0]'] \n", + " \n", + " concatenate (Concatenate) (None, 2, 2, 768) 0 ['activation_82[0][0]', \n", + " 'activation_83[0][0]'] \n", + " \n", + " activation_84 (Activation) (None, 2, 2, 192) 0 ['batch_normalization_84[0][0]'] \n", + " \n", + " mixed9 (Concatenate) (None, 2, 2, 2048) 0 ['activation_76[0][0]', \n", + " 'mixed9_0[0][0]', \n", + " 'concatenate[0][0]', \n", + " 'activation_84[0][0]'] \n", + " \n", + " conv2d_89 (Conv2D) (None, 2, 2, 448) 917504 ['mixed9[0][0]'] \n", + " \n", + " batch_normalization_89 (BatchN (None, 2, 2, 448) 1344 ['conv2d_89[0][0]'] \n", + " ormalization) \n", + " \n", + " activation_89 (Activation) (None, 2, 2, 448) 0 ['batch_normalization_89[0][0]'] \n", + " \n", + " conv2d_86 (Conv2D) (None, 2, 2, 384) 786432 ['mixed9[0][0]'] \n", + " \n", + " conv2d_90 (Conv2D) (None, 2, 2, 384) 1548288 ['activation_89[0][0]'] \n", + " \n", + " batch_normalization_86 (BatchN (None, 2, 2, 384) 1152 ['conv2d_86[0][0]'] \n", + " ormalization) \n", + " \n", + " batch_normalization_90 (BatchN (None, 2, 2, 384) 1152 ['conv2d_90[0][0]'] \n", + " ormalization) \n", + " \n", + " activation_86 (Activation) (None, 2, 2, 384) 0 ['batch_normalization_86[0][0]'] \n", + " \n", + " activation_90 (Activation) (None, 2, 2, 384) 0 ['batch_normalization_90[0][0]'] \n", + " \n", + " conv2d_87 (Conv2D) (None, 2, 2, 384) 442368 ['activation_86[0][0]'] \n", + " \n", + " conv2d_88 (Conv2D) (None, 2, 2, 384) 442368 ['activation_86[0][0]'] \n", + " \n", + " conv2d_91 (Conv2D) (None, 2, 2, 384) 442368 ['activation_90[0][0]'] \n", + " \n", + " conv2d_92 (Conv2D) (None, 2, 2, 384) 442368 ['activation_90[0][0]'] \n", + " \n", + " average_pooling2d_8 (AveragePo (None, 2, 2, 2048) 0 ['mixed9[0][0]'] \n", + " oling2D) \n", + " \n", + " conv2d_85 (Conv2D) (None, 2, 2, 320) 655360 ['mixed9[0][0]'] \n", + " \n", + " batch_normalization_87 (BatchN (None, 2, 2, 384) 1152 ['conv2d_87[0][0]'] \n", + " ormalization) \n", + " \n", + " batch_normalization_88 (BatchN (None, 2, 2, 384) 1152 ['conv2d_88[0][0]'] \n", + " ormalization) \n", + " \n", + " batch_normalization_91 (BatchN (None, 2, 2, 384) 1152 ['conv2d_91[0][0]'] \n", + " ormalization) \n", + " \n", + " batch_normalization_92 (BatchN (None, 2, 2, 384) 1152 ['conv2d_92[0][0]'] \n", + " ormalization) \n", + " \n", + " conv2d_93 (Conv2D) (None, 2, 2, 192) 393216 ['average_pooling2d_8[0][0]'] \n", + " \n", + " batch_normalization_85 (BatchN (None, 2, 2, 320) 960 ['conv2d_85[0][0]'] \n", + " ormalization) \n", + " \n", + " activation_87 (Activation) (None, 2, 2, 384) 0 ['batch_normalization_87[0][0]'] \n", + " \n", + " activation_88 (Activation) (None, 2, 2, 384) 0 ['batch_normalization_88[0][0]'] \n", + " \n", + " activation_91 (Activation) (None, 2, 2, 384) 0 ['batch_normalization_91[0][0]'] \n", + " \n", + " activation_92 (Activation) (None, 2, 2, 384) 0 ['batch_normalization_92[0][0]'] \n", + " \n", + " batch_normalization_93 (BatchN (None, 2, 2, 192) 576 ['conv2d_93[0][0]'] \n", + " ormalization) \n", + " \n", + " activation_85 (Activation) (None, 2, 2, 320) 0 ['batch_normalization_85[0][0]'] \n", + " \n", + " mixed9_1 (Concatenate) (None, 2, 2, 768) 0 ['activation_87[0][0]', \n", + " 'activation_88[0][0]'] \n", + " \n", + " concatenate_1 (Concatenate) (None, 2, 2, 768) 0 ['activation_91[0][0]', \n", + " 'activation_92[0][0]'] \n", + " \n", + " activation_93 (Activation) (None, 2, 2, 192) 0 ['batch_normalization_93[0][0]'] \n", + " \n", + " mixed10 (Concatenate) (None, 2, 2, 2048) 0 ['activation_85[0][0]', \n", + " 'mixed9_1[0][0]', \n", + " 'concatenate_1[0][0]', \n", + " 'activation_93[0][0]'] \n", + " \n", + "==================================================================================================\n", + "Total params: 21,802,784\n", + "Trainable params: 21,768,352\n", + "Non-trainable params: 34,432\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", + "\n", + "base_model.trainable=False" + ], + "metadata": { + "id": "F_Heq3C1eKd-" + }, + "execution_count": 17, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Append Fully connected/custom Conv2D/Dropout/MaxPooling layers to the base model\n", + "\n", + "model=Sequential()\n", + "model.add(base_model)\n", + "model.add(tf.keras.layers.GlobalAveragePooling2D())\n", + "model.add(Dense(512, activation='relu'))\n", + "model.add(Dense(256, activation='relu'))" + ], + "metadata": { + "id": "MKx1EtUJea6D" + }, + "execution_count": 20, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Add the final output layer\n", + "\n", + "model.add(Dense(3, activation='softmax'))" + ], + "metadata": { + "id": "q6I3oTTNgP8L" + }, + "execution_count": 21, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Print your model's summary\n", + "\n", + "model.summary()" + ], + "metadata": { + "id": "6aVQocJwgN5r", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "b0c0aba0-e5a7-428c-adaa-ca2626ceb3b2" + }, + "execution_count": 22, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Model: \"sequential_2\"\n", + "_________________________________________________________________\n", + " Layer (type) Output Shape Param # \n", + "=================================================================\n", + " inception_v3 (Functional) (None, 2, 2, 2048) 21802784 \n", + " \n", + " global_average_pooling2d (G (None, 2048) 0 \n", + " lobalAveragePooling2D) \n", + " \n", + " dense_3 (Dense) (None, 512) 1049088 \n", + " \n", + " dense_4 (Dense) (None, 256) 131328 \n", + " \n", + " dense_5 (Dense) (None, 3) 771 \n", + " \n", + "=================================================================\n", + "Total params: 22,983,971\n", + "Trainable params: 1,181,187\n", + "Non-trainable params: 21,802,784\n", + "_________________________________________________________________\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Compile you model (set the parameters like loss/optimizers/metrics)\n", + "\n", + "model.compile(optimizer = 'adam',\n", + " loss='categorical_crossentropy',\n", + " metrics=['accuracy'])" + ], + "metadata": { + "id": "qdC71fUBgXAg" + }, + "execution_count": 29, + "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", + "\n", + "data=ImageDataGenerator(validation_split=0.2)\n", + "# Your code " + ], + "metadata": { + "id": "DBscSsvkgn39" + }, + "execution_count": 30, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Anything else you wish to try" + ], + "metadata": { + "id": "rhyHEFXDkZr4" + }, + "execution_count": null, + "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", + "\n", + "train=data.flow_from_directory('/content/drive/MyDrive/Mask_Dataset/',\n", + " target_size=(224,224),\n", + " color_mode='rgb',\n", + " batch_size=64,\n", + " class_mode='categorical')\n", + "\n", + "test=data.flow_from_directory('/content/drive/MyDrive/Mask_Dataset/',\n", + " target_size=(224,224),\n", + " color_mode='rgb',\n", + " batch_size=64,\n", + " class_mode='categorical',\n", + " subset='validation')" + ], + "metadata": { + "id": "sB7hb3ybkJRq", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "d972b592-0bfc-42e0-c0dd-ab9e2c1abe8c" + }, + "execution_count": 31, + "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", + "# ModelCheckpoint is helpful to save the model giving best results (brownie points)\n", + "\n", + "check = ModelCheckpoint('best.h5', monitor='val_accuracy', mode='max', verbose=1, save_best_only=True)\n", + "model_history=model.fit(train, validation_data=test, epochs=10, callbacks=[check])" + ], + "metadata": { + "id": "Gs2X14MBmu7W", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "293de47d-8e3c-432e-83b4-9061db40ef7a" + }, + "execution_count": 34, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Epoch 1/10\n", + "141/141 [==============================] - ETA: 0s - loss: 2.7941 - accuracy: 0.7276\n", + "Epoch 1: val_accuracy improved from -inf to 0.82219, saving model to best.h5\n", + "141/141 [==============================] - 54s 269ms/step - loss: 2.7941 - accuracy: 0.7276 - val_loss: 0.4306 - val_accuracy: 0.8222\n", + "Epoch 2/10\n", + "141/141 [==============================] - ETA: 0s - loss: 0.4706 - accuracy: 0.8362\n", + "Epoch 2: val_accuracy improved from 0.82219 to 0.90468, saving model to best.h5\n", + "141/141 [==============================] - 34s 240ms/step - loss: 0.4706 - accuracy: 0.8362 - val_loss: 0.2813 - val_accuracy: 0.9047\n", + "Epoch 3/10\n", + "141/141 [==============================] - ETA: 0s - loss: 0.4316 - accuracy: 0.8530\n", + "Epoch 3: val_accuracy did not improve from 0.90468\n", + "141/141 [==============================] - 34s 241ms/step - loss: 0.4316 - accuracy: 0.8530 - val_loss: 0.4309 - val_accuracy: 0.8724\n", + "Epoch 4/10\n", + "141/141 [==============================] - ETA: 0s - loss: 0.3015 - accuracy: 0.8951\n", + "Epoch 4: val_accuracy improved from 0.90468 to 0.93367, saving model to best.h5\n", + "141/141 [==============================] - 34s 238ms/step - loss: 0.3015 - accuracy: 0.8951 - val_loss: 0.2100 - val_accuracy: 0.9337\n", + "Epoch 5/10\n", + "141/141 [==============================] - ETA: 0s - loss: 0.2935 - accuracy: 0.8978\n", + "Epoch 5: val_accuracy did not improve from 0.93367\n", + "141/141 [==============================] - 34s 240ms/step - loss: 0.2935 - accuracy: 0.8978 - val_loss: 0.2281 - val_accuracy: 0.9164\n", + "Epoch 6/10\n", + "141/141 [==============================] - ETA: 0s - loss: 0.2376 - accuracy: 0.9144\n", + "Epoch 6: val_accuracy improved from 0.93367 to 0.93645, saving model to best.h5\n", + "141/141 [==============================] - 33s 236ms/step - loss: 0.2376 - accuracy: 0.9144 - val_loss: 0.1711 - val_accuracy: 0.9365\n", + "Epoch 7/10\n", + "141/141 [==============================] - ETA: 0s - loss: 0.2658 - accuracy: 0.9038\n", + "Epoch 7: val_accuracy improved from 0.93645 to 0.93924, saving model to best.h5\n", + "141/141 [==============================] - 34s 238ms/step - loss: 0.2658 - accuracy: 0.9038 - val_loss: 0.1602 - val_accuracy: 0.9392\n", + "Epoch 8/10\n", + "141/141 [==============================] - ETA: 0s - loss: 0.2094 - accuracy: 0.9253\n", + "Epoch 8: val_accuracy did not improve from 0.93924\n", + "141/141 [==============================] - 35s 244ms/step - loss: 0.2094 - accuracy: 0.9253 - val_loss: 0.1750 - val_accuracy: 0.9365\n", + "Epoch 9/10\n", + "141/141 [==============================] - ETA: 0s - loss: 0.1846 - accuracy: 0.9329\n", + "Epoch 9: val_accuracy did not improve from 0.93924\n", + "141/141 [==============================] - 33s 237ms/step - loss: 0.1846 - accuracy: 0.9329 - val_loss: 0.1834 - val_accuracy: 0.9298\n", + "Epoch 10/10\n", + "141/141 [==============================] - ETA: 0s - loss: 0.1780 - accuracy: 0.9372\n", + "Epoch 10: val_accuracy improved from 0.93924 to 0.95206, saving model to best.h5\n", + "141/141 [==============================] - 34s 238ms/step - loss: 0.1780 - accuracy: 0.9372 - val_loss: 0.1367 - val_accuracy: 0.9521\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "### Evaluate the performance" + ], + "metadata": { + "id": "FTvRa1FXri4R" + } + }, + { + "cell_type": "code", + "source": [ + "# Plot training & validation loss/accuracy values\n", + "\n", + "plt.plot(model_history.history['val_accuracy'])\n", + "plt.plot(model_history.history['accuracy'])\n", + "plt.title('Model Accuracy')\n", + "plt.ylabel('Accuracy')\n", + "plt.xlabel('Epoch')\n", + "plt.legend(['Train', 'Test'], loc='upper left')\n", + "plt.show()\n", + "\n", + "plt.plot(model_history.history['loss'])\n", + "plt.plot(model_history.history['val_loss'])\n", + "plt.title('Model Loss')\n", + "plt.ylabel('Loss')\n", + "plt.xlabel('Epoch')\n", + "plt.legend(['train', 'test'], loc='upper left')\n", + "plt.show()" + ], + "metadata": { + "id": "cTH6flzcrck0", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 573 + }, + "outputId": "9dcb6426-338f-471f-eb93-f6a0fc50edb0" + }, + "execution_count": 39, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + }, + { + "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", + "\n", + "# print classification report" + ], + "metadata": { + "id": "fJ-ZtU84r66Z" + }, + "execution_count": 47, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Use the classification report to print precision, recall, f1-score for the three classes(optional, brownie points)\n", + "\n", + "from sklearn.metrics import classification_report, confusion_matrix\n", + "\n", + "predictions=model.predict(test)\n", + "\n", + "Y_pred = model.predict_generator(test, 1794 // 64+1)\n", + "y_pred = np.argmax(Y_pred, axis=1)\n", + "target_names = ['mask_weared_incorrect', 'with_mask', 'without_mask']\n", + "print(classification_report(test.classes, y_pred, target_names=target_names))" + ], + "metadata": { + "id": "VytDxkswrvXw", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "303ab16d-3964-46fe-9c2c-6edfdd2aa58d" + }, + "execution_count": 44, + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + "/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py:8: UserWarning: `Model.predict_generator` is deprecated and will be removed in a future version. Please use `Model.predict`, which supports generators.\n", + " \n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " precision recall f1-score support\n", + "\n", + "mask_weared_incorrect 0.33 0.33 0.33 598\n", + " with_mask 0.31 0.33 0.32 598\n", + " without_mask 0.30 0.28 0.29 598\n", + "\n", + " accuracy 0.31 1794\n", + " macro avg 0.31 0.31 0.31 1794\n", + " weighted avg 0.31 0.31 0.31 1794\n", + "\n" + ] + } + ] + } + ] +} \ No newline at end of file