helmet_classification_for_tinyMLproject_part2.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "helmet_classification_for_tinyMLproject_part2.ipynb",
      "provenance": [],
      "private_outputs": true,
      "collapsed_sections": [],
      "toc_visible": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VxbyIP98UOoz",
        "colab_type": "text"
      },
      "source": [
        "# Helmet Classification For TinyML Project\n",
        "\n",
        "> 이 notebook 은 open source 컨트리뷰톤 2020 - tinyML (Tensorflow Lite Project) Mobility Team 의 오픈소스 프로젝트를 위해 만들어졌습니다. \n",
        "\n",
        "- 모빌리티 팀 (멘토 맹윤호)\n",
        "- 최예진(팀장), 이민우, 전수민, 이장후, 이경환, 조승현\n",
        "- **.ipynb 제작 - 이장후. 2020/08/29**\n",
        "- **.ipynb 수정자 -**\n",
        "\n",
        "<br>\n",
        "\n",
        "- Target Github Repository : [TinyML : Tensorflow lite for microcontroller](https://github.com/yunho0130/tensorflow-lite)\n",
        "- Team Github Repository : [TinyML-Mobility](https://github.com/orgs/tinyml-mobility/teams)\n",
        "\n",
        "<br>\n",
        "\n",
        "## Before We Start\n",
        "- 런타임 -> GPU 로 변경 하셨나요?\n",
        "\n",
        "<br>\n",
        "\n",
        "## This Time\n",
        "- keras 내장 모델인 mobilenet v2 를 불러오지 말고, 직접 mobilenet v2 를 구현해 봅시다.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8yC8JXqNghoE",
        "colab_type": "text"
      },
      "source": [
        "# Google Drive\n",
        "\n",
        "- 학습을 시키기 전 데이터가 있는 google Drive 와 연동을 해야 합니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XZfIohGzavab",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/gdrive')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RRqsMIdWgm6A",
        "colab_type": "text"
      },
      "source": [
        "## Include Library"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "G3kyAsKGbKfZ",
        "colab_type": "text"
      },
      "source": [
        "- 이 노트북의 소스코드는 tensorflow 2.0 이상과 호환되지 않습니다.\n",
        "- Google colab 에서는 %tensorflow_version 을 통해, 원하는 버전의 tensorflow 를 쉽게 불러올 수 있습니다"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FcV5KCk6a5Ey",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "try:\n",
        "  # This %tensorflow_version magic only works in Colab.\n",
        "  %tensorflow_version 1.x\n",
        "except Exception:\n",
        "  pass\n",
        "\n",
        "# For your non-Colab code, be sure you have tensorflow==1.15\n",
        "import tensorflow as tf\n",
        "assert tf.__version__.startswith('1')\n",
        "\n",
        "import os\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bD2Q4nwnbGmw",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "tf.__version__"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zi1C99JBgves",
        "colab_type": "text"
      },
      "source": [
        "## Hyper Parameters\n",
        "- 하이퍼파라미터들을 위에 모아서 정의해두는 습관\n",
        "- google colab 에서는 아까 언급했던 % magic 을 이용해서 tensorboard 를 쉽게 사용할 수 있도록 만들어 두었습니다. (그런데 잘 돌아가지는 않음)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NsqrbpKteFLC",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "%load_ext tensorboard"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TKf4BLAFbcz7",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "%cd /content/gdrive/\"My Drive\"/data/\n",
        "\n",
        "# 데이터가 존재하는 경로 ( /content/gdrive/\"My Drive\"/data/helmetclassification ) 를 data_dir 변수에 저장합니다.\n",
        "data_dir = os.path.join(os.getcwd(), 'helmetclassification')\n",
        "print(data_dir)\n",
        "\n",
        "# input 이미지의 크기는 224 by 224 by 3 이 모델이 제안하는 기본값입니다. \n",
        "# 하지만 지난번 예제와 같이, 조금 줄일 수도 있는데, 우리가 데이터로 가지고 있는 이미지의 해상도가 충분히 좋다면,\n",
        "# input 이미지의 기본 크기를 크게 잡아 주어도 됩니다. 즉, 상황에 따라 다르게 조정해 줄 수 있습니다.\n",
        "# 그 이유는, 모든 resize 를 끝내고, 찌그러지거나 강제로 확장된 이미지가 네트워크를 통과하게 되는 원리이기 때문입니다.\n",
        "# 저희의 경우, input image 의 해상도가 높으면 안 될 수 있기 때문에, 지난번과 마찬가지로 size 를 약간 줄이도록 하겠습니다. \n",
        "IMG_WIDTH = 128\n",
        "IMG_HEIGHT = 128\n",
        "IMG_CHANNEL = 3 # 채널은 RGB 이므로, 3 입니다.\n",
        "IMG_SHAPE = (IMG_WIDTH, IMG_HEIGHT, IMG_CHANNEL)\n",
        "\n",
        "# 연산 처리 단위 (배치) 는 이미지 16장, 그리고 Learning Rate, optimizer, 에폭 등을 설정합니다.\n",
        "# *참고* : Optimizer 에서 SGD 는 최근 잘 사용하지 않지만, 안정적인 수렴을 위해 특정 경우에 사용합니다. \n",
        "BATCH_SIZE = 32\n",
        "LEARNING_RATE_SGD = 0.001\n",
        "LEARNING_RATE_ADAM = 0.0001\n",
        "TRAINING_OPTIMIZER_SGD  = tf.keras.optimizers.SGD(learning_rate=LEARNING_RATE_SGD, momentum=0.0)\n",
        "TRAINING_OPTIMIZER_ADAM = tf.keras.optimizers.Adam(learning_rate=LEARNING_RATE_ADAM)\n",
        "EPOCHS = 50\n",
        "\n",
        "# 우리는 checkpoint 를 설정해서, 각 epoch 마다 가중치를 저장할 것입니다.\n",
        "CKPT_DIR = os.path.join(data_dir, 'checkpoint')\n",
        "\n",
        "# 우리는 h5 file 을 tflite 파일로 전환할 것입니다. 이름을 미리 정해 둡시다.\n",
        "SAVED_KERAS_MODEL_NAME = 'helmet_classification_model_handmaded_mobilenet.h5'\n",
        "\n",
        "# 우리는 잠시 후에 라벨 파일을 만들어낼 것인데, 라벨 파일의 이름을 미리 정의해 둡시다.\n",
        "LABEL_FILE_NAME = 'ishelmetlabel.txt'"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GemJq1CujkU9",
        "colab_type": "text"
      },
      "source": [
        "## Generator\n",
        "- python 에는 '제네레이터' 라는 것이 존재합니다.\n",
        "- 그 때 그 때, 상황에 맞는 데이터를 만들어 주는 역할을 수행합니다.\n",
        "- keras 에서는, 이를 이용하여, 우리가 가지고 있는 image data 들을 정갈하게 정리해서 하나씩 하나씩 필요에 맞게 넘겨 주는 함수를 만들어 두었습니다. \n",
        "\n",
        "<br>\n",
        "\n",
        "### ImageDataGenerator : Data Augmentation\n",
        "- Data Augmentation 은 말 그대로 데이터를 증폭시켜주는 역할을 합니다.\n",
        "- 고양이 사진이 있을 때, 고양이 머리만 있어도 고양이이고, 몸통만 있어도 고양이이며, 형광등 아래의 고양이도 고양이고, 백열등 아래의 고양이도 고양이입니다.\n",
        "- 우리가 가지고 있는 이미지를 인위적으로 변형한 뒤에도, 올바르게 추론할 수 있도록 이미지 데이터를 다양한 방법으로 변형시켜줄 수 있도록 돕는 함수가 Keras 의 ImageDataGenerator 입니다.\n",
        "- Train 할 때는 이미지를 변형해서 forward-pass 시켜주지만, test 를 할 때에는 이미지를 변형해서 네트워크를 통과시키면 안 되겠지요. 따라서 Augmentation 은 Training Set Data Generator 에 적용할 ImageDataGenerator 에만 만들어 줍니다.\n",
        "- 다만, Train 이나 Test 시에는 Network 의 사양에 맞추어서 0~1 의 범위로 input 을 정규화 시켜 주어야 합니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kvEQ8ZedbJLg",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "train_datagen = tf.keras.preprocessing.image.ImageDataGenerator(\n",
        "    shear_range=0.4,\n",
        "    zoom_range=0.5,\n",
        "    rescale=1./255,\n",
        "    dtype='float',\n",
        "    fill_mode=\"constant\",\n",
        "    horizontal_flip=True,\n",
        "    channel_shift_range=150, \n",
        "    rotation_range=20,\n",
        "    brightness_range=[0.5, 1.2],\n",
        "    )\n",
        "\n",
        "# 추가 tip : 이러한 전처리 과정이 길어질수록, 학습 시 시간이 오래 걸리게 됩니다.\n",
        "# mini batch 를 만들어내기 위해서는 cpu 가 사용되고, 학습에는 gpu 에서 연산을 수행하게 되는데, cpu 에서 mini batch 를 만들 때까지 gpu 는 기다리고 있어야 하기 때문입니다.\n",
        "\n",
        "test_datagen = tf.keras.preprocessing.image.ImageDataGenerator(\n",
        "    rescale=1./255,\n",
        "    dtype='float',\n",
        "    validation_split=0.5\n",
        "    )"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ev4I_wG7KkdO",
        "colab_type": "text"
      },
      "source": [
        "### Debug Generator\n",
        "- Generator 에서 어떤 Augmented image 가 생성되고 있는지 조사하는 것은 굉장히 중요한 과정입니다.\n",
        "- 우리의 augmented image 가 어떻게 만들어지고 있는지 한번 확인해보도록 합시다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UZo-wMklDdSK",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "img = tf.keras.preprocessing.image.load_img(os.path.join(data_dir, \"train\", \"helmet\", '3162_0.png'))\n",
        "x = tf.keras.preprocessing.image.img_to_array(img)\n",
        "x = x.reshape((1,) + x.shape)  # (1, w, h, 3) 크기의 NumPy 배열\n",
        "print(x.shape)\n",
        "\n",
        "# imagedatagenerator 에 flow 함수를 실행하면 generator 이라는 것이 return 됩니다.\n",
        "# 이 generator 에 대해서는 다른 학습자료를 참고하세요.\n",
        "it = train_datagen.flow(x)\n",
        "import matplotlib.pyplot as plt\n",
        "plt.figure(figsize = [15, 15])\n",
        "for i in range(9):\n",
        "\t# define subplot\n",
        "\tplt.subplot(330 + 1 + i)\n",
        "\t# generate batch of images\n",
        "\tbatch = it.next()\n",
        "\t# convert to unsigned integers for viewing\n",
        "\timage = batch[0]\n",
        "\t# plot raw pixel data\n",
        "\tplt.imshow(image)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kGAQB7iNiZS2",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "%cd /content/gdrive/\"My Drive\"/data/helmetclassification/\n",
        "!mkdir 'checkpoint'"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qWuBA7K_kkVN",
        "colab_type": "text"
      },
      "source": [
        "## Check Directory\n",
        "- 잘 정리되었나 확인해 봅시다\n",
        "- train, test 폴더만 남아 있어야 합니다.\n",
        "- 각 디렉터리에 이미지 개수들이 적절히 잡혀야 합니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JRWf-EcZkfXJ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import os\n",
        "%cd /content/gdrive/\"My Drive\"/data/helmetclassification/\n",
        "!ls"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NeFJcjprUwOZ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# helmet\n",
        "%cd /content/gdrive/\"My Drive\"/data/helmetclassification/train/helmet/\n",
        "file_list = os.listdir(os.getcwd())\n",
        "print('count of train helmet file :', len(file_list))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2yTuT7chUwdv",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# helmet\n",
        "%cd /content/gdrive/\"My Drive\"/data/helmetclassification/test/helmet/\n",
        "file_list = os.listdir(os.getcwd())\n",
        "print('count of test helmet file :', len(file_list))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bOjwIXR3Uwo0",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# non_helmet\n",
        "%cd /content/gdrive/\"My Drive\"/data/helmetclassification/train/non_helmet/\n",
        "file_list = os.listdir(os.getcwd())\n",
        "print('Count of train non_helmet file :', len(file_list))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "M-f1Ot_zUwy9",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# non_helmet\n",
        "%cd /content/gdrive/\"My Drive\"/data/helmetclassification/test/non_helmet/\n",
        "file_list = os.listdir(os.getcwd())\n",
        "print('Count of test non_helmet file :', len(file_list))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XRCJMSXjqaZW",
        "colab_type": "text"
      },
      "source": [
        "## Data Generator Flow From Directory\n",
        "- Keras 는 Directory 이름과 해당 폴더로부터 알아서 클래스를 구분해주고, 쉽게 training 시킬 수 있도록 API 를 제공합니다.\n",
        "- train_generator : generator 로써, next() 수행 시 하나의 tensor 를 만들어냅니다.\n",
        "  - 한 번에 만들어내는 tensor 은 (image tensor, label tensor) 이고, 그 shape 은 (batch_size, 224, 224, 3)  (batch_size, 2 - 클래스가 2개이므로) 입니다.\n",
        "- val_generator : generator 로써, 이하동문.\n",
        "  - 한 번에 만들어내는 tensor 은 (image tensor, label tensor) 이고, 그 shape 은 (1, 224, 224, 3)  (1, 2) 입니다.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bZD0OId0gqQW",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "print('Training data generator during training session')\n",
        "train_generator = train_datagen.flow_from_directory(\n",
        "    data_dir+'/train',\n",
        "    color_mode=\"rgb\",\n",
        "    target_size=(IMG_WIDTH, IMG_HEIGHT),\n",
        "    batch_size=BATCH_SIZE,\n",
        "    )\n",
        "\n",
        "print('\\nValidation data generator during training session')\n",
        "val_generator = test_datagen.flow_from_directory(\n",
        "    data_dir+'/test',\n",
        "    color_mode=\"rgb\",\n",
        "    target_size=(IMG_WIDTH, IMG_HEIGHT),\n",
        "    batch_size=BATCH_SIZE,\n",
        "    subset=\"training\"\n",
        "    )\n",
        "\n",
        "print('\\nTest data generator when the end of training session')\n",
        "test_generator = test_datagen.flow_from_directory(\n",
        "    data_dir+'/test',\n",
        "    color_mode=\"rgb\",\n",
        "    target_size=(IMG_WIDTH, IMG_HEIGHT),\n",
        "    batch_size=1,\n",
        "    subset=\"validation\"\n",
        "    )"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Mu9c78aFjwml",
        "colab_type": "text"
      },
      "source": [
        "# Model For training\n",
        "- 이제 모델을 만들고, 훈련을 시켜 보도록 합시다."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uJvbokNJS4zr",
        "colab_type": "text"
      },
      "source": [
        "### Model 직접 쌓아보기\n",
        "- Part1 에서는 기본으로 제공되는 모델인 mobilenet v2 를 사용했습니다.\n",
        "- 이번에는 mobilenet v2 를 직접 작성해 보도록 합시다.\n",
        "\n",
        "*주의 : 직접 작성하는 모델과 직접 훈련시키는 가중치는, 기본으로 제공되는 모델과 가중치보다 성능이 떨어집니다.\n",
        "\n",
        "\n",
        "### Mobilenet v2 의 구조\n",
        "- mobilenet 에 대해서 모든 내용을 설명할 수 없습니다. 아래 링크를 통해 알아보고, 네트워크에 대해서 익숙하지 않으신 분들은, 아 이렇게 모델을 만드는 것과 학습이 연결이 되는구나 정도만 이해해도 좋을 것 같습니다.\n",
        "- mobilenet v1 에 대한 설명 https://gaussian37.github.io/dl-concept-mobilenet/\n",
        "- depth-separable convolution 에 대한 설명 https://gaussian37.github.io/dl-concept-dwsconv/\n",
        "- mobilenet v2 에 대한 설명 https://gaussian37.github.io/dl-concept-mobilenet_v2/\n",
        "\n",
        "\n",
        "```\n",
        "base_model = tf.keras.applications.MobileNetV2(input_shape=IMG_SHAPE, include_top=False)\n",
        "base_model.trainable = True\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WsNkhBXJUsY_",
        "colab_type": "text"
      },
      "source": [
        "### 재료\n",
        "- mobilenet v2 는 다음과 같은 operator 들로 이루어져 있습니다.\n",
        "- operator 이라고 한 것은, 하나의 모듈이라고 생각하면 됩니다.\n",
        "  - convolution x 1\n",
        "  - inverted residual x 5\n",
        "  - convolution x 1\n",
        "  - global average pooling layer x 1\n",
        "  - convolution layer x 1 (fully connected layer 역할의 레이어)\n",
        "- 우선 convolution operator 부터 만들어 볼까요?\n",
        "  - mobilenet 에서 말하는 convolution 모듈 이란, 우리가 평소 생각하는 그냥 convolution 연산만 하는 것을 의미하는 것이 아니라, 아래 셋을 모두 포함하고 있는 모듈입니다.\n",
        "    - 3 by 3 커널의 n stride 의 convolution 레이어\n",
        "    - 배치 정규화 레이어\n",
        "    - relu6 activation 레이어\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "y8eciMIMdhgb",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def _conv_block(inputs, filters, kernel, strides, name = None):\n",
        "    \"\"\"Convolution Block\n",
        "    This function defines a 2D convolution operation with BN and relu6.\n",
        "    # Arguments\n",
        "        inputs: Tensor, input tensor of conv layer.\n",
        "        filters: Integer, the dimensionality of the output space.\n",
        "        kernel: An integer or tuple/list of 2 integers, specifying the\n",
        "            width and height of the 2D convolution window.\n",
        "        strides: An integer or tuple/list of 2 integers,\n",
        "            specifying the strides of the convolution along the width and height.\n",
        "            Can be a single integer to specify the same value for\n",
        "            all spatial dimensions.\n",
        "    # Returns\n",
        "        Output tensor.\n",
        "    \"\"\"\n",
        "\n",
        "    # tensorflow \n",
        "    channel_axis = 1 if tf.keras.backend.image_data_format() == 'channels_first' else -1\n",
        "\n",
        "    if name is not None :\n",
        "      x = tf.keras.layers.Conv2D(filters, kernel, padding='same', strides=strides, name = name)(inputs)\n",
        "    else :\n",
        "      x = tf.keras.layers.Conv2D(filters, kernel, padding='same', strides=strides)(inputs)\n",
        "    x = tf.keras.layers.BatchNormalization(axis=channel_axis)(x)\n",
        "    return tf.keras.layers.Activation(relu6)(x)\n",
        "\n",
        "from functools import wraps\n",
        "@wraps(tf.keras.backend.relu)\n",
        "def relu6(x):\n",
        "    \"\"\"Relu 6\n",
        "    \"\"\"\n",
        "    return tf.keras.backend.relu(x, max_value=6.0)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "F6_VIW4u697T",
        "colab_type": "text"
      },
      "source": [
        "![image.png](data:image/png;base64,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)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dCe_TOPYS09C",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def _make_divisible(v, divisor, min_value=None):\n",
        "    if min_value is None:\n",
        "        min_value = divisor\n",
        "    new_v = max(min_value, int(v + divisor / 2) // divisor * divisor)\n",
        "    # Make sure that round down does not go down by more than 10%.\n",
        "    if new_v < 0.9 * v:\n",
        "        new_v += divisor\n",
        "    return new_v\n",
        "\n",
        "def _bottleneck(inputs, filters, kernel, t, width_multiplier, s, r=False):\n",
        "    \"\"\"Bottleneck\n",
        "    This function defines a basic bottleneck structure.\n",
        "    # Arguments\n",
        "        inputs: Tensor, input tensor of conv layer.\n",
        "        filters: Integer, the dimensionality of the output space.\n",
        "        kernel: An integer or tuple/list of 2 integers, specifying the\n",
        "            width and height of the 2D convolution window.\n",
        "        t: Integer, expansion factor.\n",
        "            t is always applied to the input size.\n",
        "        s: An integer or tuple/list of 2 integers,specifying the strides\n",
        "            of the convolution along the width and height.Can be a single\n",
        "            integer to specify the same value for all spatial dimensions.\n",
        "        width_multiplier: Integer, width multiplier.\n",
        "        r: Boolean, Whether to use the residuals.\n",
        "    # Returns\n",
        "        Output tensor.\n",
        "    \"\"\"\n",
        "\n",
        "    channel_axis = 1 if tf.keras.backend.image_data_format() == 'channels_first' else -1\n",
        "    \n",
        "    # Depth\n",
        "    tchannel = tf.keras.backend.int_shape(inputs)[channel_axis] * t\n",
        "\n",
        "    # Width\n",
        "    cchannel = int(filters * width_multiplier)\n",
        "\n",
        "    x = _conv_block(inputs, tchannel, (1, 1), (1, 1))\n",
        "\n",
        "    x = tf.keras.layers.DepthwiseConv2D(kernel, strides=(s, s), depth_multiplier=1, padding='same')(x)\n",
        "    x = tf.keras.layers.BatchNormalization(axis=channel_axis)(x)\n",
        "    x = tf.keras.layers.Activation(relu6)(x)\n",
        "\n",
        "    x = tf.keras.layers.Conv2D(cchannel, (1, 1), strides=(1, 1), padding='same')(x)\n",
        "    x = tf.keras.layers.BatchNormalization(axis=channel_axis)(x)\n",
        "\n",
        "    if r:\n",
        "        x = tf.keras.layers.Add()([x, inputs])\n",
        "\n",
        "    return x\n",
        "\n",
        "# n 번 반복\n",
        "def _inverted_residual_block(inputs, filters, kernel, t, width_multiplier, strides, n):\n",
        "    \"\"\"Inverted Residual Block\n",
        "    This function defines a sequence of 1 or more identical layers.\n",
        "    # Arguments\n",
        "        inputs: Tensor, input tensor of conv layer.\n",
        "        filters: Integer, the dimensionality of the output space.\n",
        "        kernel: An integer or tuple/list of 2 integers, specifying the\n",
        "            width and height of the 2D convolution window.\n",
        "        t: Integer, expansion factor.\n",
        "            t is always applied to the input size.\n",
        "        width_multiplier: Integer, width multiplier.\n",
        "        s: An integer or tuple/list of 2 integers,specifying the strides\n",
        "            of the convolution along the width and height.Can be a single\n",
        "            integer to specify the same value for all spatial dimensions.\n",
        "        n: Integer, layer repeat times.\n",
        "    # Returns\n",
        "        Output tensor.\n",
        "    \"\"\"\n",
        "\n",
        "    x = _bottleneck(inputs, filters, kernel, t, width_multiplier, strides)\n",
        "\n",
        "    for i in range(1, n):\n",
        "        x = _bottleneck(x, filters, kernel, t, width_multiplier, 1, True)\n",
        "\n",
        "    return x"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HXoB82LAfvhF",
        "colab_type": "text"
      },
      "source": [
        "이렇게 재료 함수들을 모두 만들었습니다.\n",
        "- 하지만 원래 mobilenet 을 그대로 만들어 버린다면, 우리가 추론하고자 하는 것에 비해 모델이 너무 강력합니다! \n",
        "- 우리는 이 모델을 조금 더 단순화할 필요가 있습니다. 원래 상태보다 조금 더 간단하고 정보를 보존하는 모델로 개량해 보도록 해요."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "x-GI9cKQfuu7",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def MobileNetv2(input_shape, k, width_multiplier=1.0):\n",
        "    \"\"\"MobileNetv2\n",
        "    This function defines a MobileNetv2 architectures.\n",
        "    # Arguments\n",
        "        input_shape: An integer or tuple/list of 3 integers, shape\n",
        "            of input tensor.\n",
        "        k: Integer, number of classes.\n",
        "        width_multiplier: Integer, width multiplier, better in [0.35, 0.50, 0.75, 1.0, 1.3, 1.4].\n",
        "    # Returns\n",
        "        MobileNetv2 model.\n",
        "    \"\"\"\n",
        "\n",
        "    inputs = tf.keras.layers.Input(shape=input_shape)\n",
        "    x = tf.keras.layers.GaussianNoise(0.1)(inputs)       # 원래 mobilenet 에는 들어있지 않지만, 우리가 가지고 있는 데이터셋의 해상도가 너무 큰 차이를 보이기 때문에 사용합니다. \n",
        "    first_filters = _make_divisible(32 * width_multiplier, 8) # 그냥 잘 나누어떨어지게 하는 친구. mobilenet v2 은 모든 채널이 8의 배수로 나누어떨어짐.\n",
        "    x = _conv_block(x, first_filters, (3, 3), strides=(2, 2))\n",
        "    x = _inverted_residual_block(x, 16, (3, 3), t=1, width_multiplier=width_multiplier, strides=1, n=1)\n",
        "    x = _inverted_residual_block(x, 24, (3, 3), t=6, width_multiplier=width_multiplier, strides=2, n=2)\n",
        "    x = _inverted_residual_block(x, 32, (3, 3), t=6, width_multiplier=width_multiplier, strides=1, n=2) # 원래 stride = 2, n = 3 입니다.\n",
        "    x = _inverted_residual_block(x, 64, (3, 3), t=6, width_multiplier=width_multiplier, strides=2, n=2) # 원래 n = 4 입니다.\n",
        "    x = _inverted_residual_block(x, 96, (3, 3), t=6, width_multiplier=width_multiplier, strides=1, n=2) # 원래 n = 3 입니다.\n",
        "    x = _inverted_residual_block(x, 160, (3, 3), t=6, width_multiplier=width_multiplier, strides=2, n=2) # 원래 n = 3 입니다.\n",
        "    # x = _inverted_residual_block(x, 320, (3, 3), t=6, width_multiplier=width_multiplier, strides=1, n=1)\n",
        "\n",
        "    if width_multiplier > 1.0:\n",
        "        last_filters = _make_divisible(320 * width_multiplier, 8) # 원래 channel : 1280 * width_multiplier 입니다.\n",
        "    else:\n",
        "        last_filters = 1280\n",
        "\n",
        "    x = _conv_block(x, last_filters, (1, 1), strides=(1, 1), name='final_conv')\n",
        "    x = tf.keras.layers.GlobalAveragePooling2D()(x)\n",
        "    x = tf.keras.layers.Dense(k, activation=\"sigmoid\")(x) # Convolution2D 와 사실상 같은 역할을 하는 layer 입니다.\n",
        "    output = tf.keras.layers.Softmax()(x) \n",
        "\n",
        "    model = tf.keras.models.Model(inputs, output)\n",
        "\n",
        "    return model"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jjPns3g7XOep",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "tf.keras.backend.clear_session()\n",
        "full_model = MobileNetv2(IMG_SHAPE, 2, 1.0)\n",
        "full_model.summary()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LYdqDWwSd2Be",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "full_model.compile(optimizer=TRAINING_OPTIMIZER_ADAM, \n",
        "              loss='categorical_crossentropy', \n",
        "              metrics=['accuracy'])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qpgtpT6Tj0rl",
        "colab_type": "text"
      },
      "source": [
        "## Train\n",
        "- 모델을 다 만들었으니 이제 훈련을 시킬 차례입니다.\n",
        "- 그런데 훈련을 시작하게 되면, 개입이 불가능해집니다.\n",
        "- 따라서 특정 타이밍(예를 들어, 1에폭마다) 적절히 호출되는 콜백 함수를 미리 등록시켜 두고, 훈련을 시작하는 것이 바람직합니다.\n",
        "  - 중간중간 모델의 가중치를 세이브하는 기능\n",
        "  - 텐서보드로 로그를 전송하는 기능\n",
        "- 일반적으로 이 두 가지 기능을 callback 으로 등록시켜 두곤 합니다.\n",
        "- keras_model.fit_generator() 함수가 호출되면 Training 이 시작됩니다.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZOvaEY-RSp9g",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# 이렇게 직접 제작한 callback 을 만들수도 있습니다. 우리 예제에서는 사용하지 않습니다.\n",
        "class CustomCallback(tf.keras.callbacks.Callback):\n",
        "    def on_epoch_begin(self, epoch, logs=None):\n",
        "        keys = list(logs.keys())\n",
        "        print(\"Start epoch {} of training; got log keys: {}\".format(epoch, keys))\n",
        "\n",
        "    def on_epoch_end(self, epoch, logs=None):\n",
        "        keys = list(logs.keys())\n",
        "        print(\"End epoch {} of training; got log keys: {}\".format(epoch, keys))\n",
        "\n",
        "    def on_test_batch_begin(self, batch, logs=None):\n",
        "        keys = list(logs.keys())\n",
        "        data = val_generator.next()\n",
        "        shape1 = data[0].shape\n",
        "        answer_shape1 = data[1].shape\n",
        "        dtype1 = data[0].dtype\n",
        "        print(\"...Evaluating: start of batch {}; shape {} - dtype {}, {}; got log keys: {}\\n\".format(batch, shape1, dtype1, answer_shape1, keys))\n",
        "\n",
        "    def on_predict_batch_begin(self, batch, logs=None):\n",
        "        keys = list(logs.keys())\n",
        "        print(\"...Predicting: start of batch {}; got log keys: {}\".format(batch, keys))\n",
        "\n",
        "    def on_predict_batch_end(self, batch, logs=None):\n",
        "        keys = list(logs.keys())\n",
        "        print(\"...Predicting: end of batch {}; got log keys: {}\".format(batch, keys))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DMEksCp_Xc0O",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# checkpoint 를 저장합니다. checkpoint 파일은 cp-<저장하는 시간>-<에폭에 해당하는 네자리수>.ckpt 라는 이름으로 지정합니다.\n",
        "# 본인이 알아보기 편한 형식으로 지정하면 되지만, checkpoint 별로 이게 몇 에폭을 학습한 결과인지, 언제 저장한 결과인지 정도는 저장이 되어 있어야 하기 때문에, 저는 이런 형식으로 지정했습니다.\n",
        "import datetime\n",
        "checkpoint_callback = tf.keras.callbacks.ModelCheckpoint(\n",
        "    os.path.join(CKPT_DIR, \"cp-\" + str(datetime.datetime.now().strftime(\"%Y%m%d-%H%M%S\")) + \"-{epoch:04d}.ckpt\"), monitor='val_loss', verbose=0, save_best_only=False,\n",
        "    save_weights_only=False, mode='auto', save_freq='epoch', options=None,\n",
        ")\n",
        "\n",
        "# 최근 저장했던 checkpoint 가 존재한다면, 저장되어 있는 checkpoint 들 중에서 최근의 checkpoint 를 불러와야 하겠지요.\n",
        "\n",
        "'''\n",
        "final_checkpoint_name = \"cp-20200912-192225-0010.ckpt\"\n",
        "full_model.load_weights(os.path.join(CKPT_DIR, final_checkpoint_name))\n",
        "EPOCHS = 30 # 이어서 학습하는 것이라면 epoch 를 조절해 주어야겠지요.\n",
        "'''"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oym2hQx8f2XQ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# 저장할 로그 파일의 이름을 준비합니다. 로그 파일이 존재해야 tensorboard 를 불러올 수 있습니다.\n",
        "%cd /content/gdrive/\"My Drive\"/data/helmetclassification\n",
        "!mkdir logs\n",
        "log_dir = os.path.join(os.getcwd(), os.path.join(\"logs\", datetime.datetime.now().strftime(\"%Y%m%d-%H%M%S\")))\n",
        "tensorboard_callback = tf.keras.callbacks.TensorBoard(log_dir=log_dir,     # 저장할 로그파일의 이름을 지정합니다.\n",
        "                                                      )"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "I2O2iVs31z-G",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "%cd /content/gdrive/\"My Drive\"/data/helmetclassification\n",
        "%tensorboard --logdir ./logs"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FZf5lLymd73I",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "%cd /content/gdrive/\"My Drive\"/data/helmetclassification\n",
        "\n",
        "# 학습 시작. 변수 history 는 학습을 마친 뒤 학습중 있었던 일들을 볼 수 있도록 keras 에서 제공하는 객체입니다.\n",
        "# 이 history 변수를 활용해서 학습을 마친 후 그래프를 그려보는 등 결과를 확인해볼 수 있습니다.\n",
        "history = full_model.fit_generator(train_generator, \n",
        "                    epochs=EPOCHS, \n",
        "                    validation_data=val_generator,\n",
        "                    callbacks=[\n",
        "                               tensorboard_callback, \n",
        "                               checkpoint_callback,\n",
        "                               # CustomCallback(),\n",
        "                               ],\n",
        "                    )"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yYSL68SZj3q6",
        "colab_type": "text"
      },
      "source": [
        "## Estimate\n",
        "- train 의 과정과 결과를 보는 방법은, tensorboard 를 활용하는 방법도 있고, history 객체를 이용하는 방법도 있습니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eDgJ0p8veNOs",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# history 객체 이용\n",
        "acc = history.history['acc']\n",
        "val_acc = history.history['val_acc']\n",
        "loss = history.history['loss']\n",
        "val_loss = history.history['val_loss']\n",
        "\n",
        "plt.figure(figsize=(19, 8))\n",
        "plt.subplot(1, 2, 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(1, 2, 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()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "i_lm_nzHLZKX",
        "colab_type": "text"
      },
      "source": [
        "### Train : 부록\n",
        "- 이 과정이 꼭 필요한 과정은 아니나, 일부 레이어만 학습시킬 수 있도록 keras 는 layer 마다 간단하게 얼릴 (freeze) 할 수 있는 방법을 제공합니다.\n",
        "- 아래 코드는, 맨 마지막 두 개 레이어의 가중치만 학습하고, 나머지 가중치들은 학습되지 않도록 trainable 을 False 로 만드는 과정입니다.\n",
        "- 보통 우리가 넣은 input image 들은 잘 훈련된 Convolution Layer 들을 거치면서 압축된 Feature (특징) 을 추출하고, 이를 바탕으로 분류기가 분류하는데, 이 특징들은 그대로 활용하되 분류기를 개선할 때 이러한 기법을 사용합니다.\n",
        "- 5에폭 정도만 Fine-Tuning 해 보도록 합시다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Dq3Gf1ctF6iy",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "'''Important note about compile() and trainable\n",
        "Calling compile() on a model is meant to \"freeze\" the behavior of that model. This implies that the trainable attribute values at the time the model is compiled should be preserved throughout the lifetime of that model, until compile is called again. Hence, if you change any trainable value, make sure to call compile() again on your model for your changes to be taken into account.\n",
        "'''\n",
        "\n",
        "for layer_idx in range(len(full_model.layers)):\n",
        "  if layer_idx < len(full_model.layers)-2 :\n",
        "    print(full_model.layers[layer_idx].name)\n",
        "    full_model.get_layer(full_model.layers[layer_idx].name).trainable = False\n",
        "\n",
        "# 모델을 변경했으니, 다시 컴파일하는 과정을 거칩니다.\n",
        "full_model.compile(optimizer=TRAINING_OPTIMIZER_ADAM, \n",
        "              loss='categorical_crossentropy', \n",
        "              metrics=['accuracy'])\n",
        "full_model.summary()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "o0IjzGn5H63R",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "history = full_model.fit_generator(train_generator, \n",
        "                    epochs=5, \n",
        "                    validation_data=val_generator,\n",
        "                    callbacks=[\n",
        "                               tensorboard_callback, \n",
        "                               checkpoint_callback,\n",
        "                               # CustomCallback(),\n",
        "                               ],\n",
        "                    )"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0rUGp3sTjIBS",
        "colab_type": "text"
      },
      "source": [
        "### Estimate with Testset\n",
        "- 학습 과정에서의 변화를 관찰했다면, 이제 우리가 아직 사용하지 않은 test set 을 활용해서 학습 결과를 관찰해 보도록 합시다.\n",
        "- 제네레이터에서 제공되는 샘플로 평가할 때는 evaluate_generator 함수를 사용합니다.\n",
        "- metric 은 accuracy 입니다. *Accuracy 는 완벽한 평가척도가 아닙니다!"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CBgB97fPjHTT",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "print('[헬멧쓴것 맞추는 정확도, 안쓰는것 맞추는 정확도]')\n",
        "\n",
        "scores  = tf.keras.Model.evaluate_generator( \n",
        "  full_model,\n",
        "  train_generator,   \n",
        "  steps = 30,\n",
        "  workers = 4,\n",
        "  callbacks = None\n",
        ")\n",
        "print(scores, \" % Accuracy - training set 기준\")\n",
        "\n",
        "scores  = tf.keras.Model.evaluate_generator( \n",
        "  full_model,\n",
        "  val_generator,  \n",
        "  steps = 30,      \n",
        "  workers = 4,\n",
        "  callbacks = None\n",
        ")\n",
        "print(scores, \" % Accuracy - validation set 기준\")\n",
        "\n",
        "\n",
        "scores  = tf.keras.Model.evaluate_generator( \n",
        "  full_model,\n",
        "  test_generator,         # test_generator 은 batch size 가 1 입니다.\n",
        "  steps = 30*BATCH_SIZE,  # 따라서 동일한 양을 테스트해보기 위해 BATCH_SIZE 를 곱해 주었습니다.\n",
        "  workers = 4,\n",
        "  callbacks = None\n",
        ")\n",
        "print(scores, \" % Accuracy - test set 기준\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "96KE9XT7M_GB",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class_name = \"helmet\"\n",
        "#class_name = \"non_helmet\"\n",
        "im = tf.keras.preprocessing.image.load_img(\n",
        "     os.path.join(data_dir, \"test\", class_name, random.choice(os.listdir(os.path.join(data_dir, \"test\", class_name)))),\n",
        "     target_size=(IMG_WIDTH, IMG_HEIGHT),\n",
        ")\n",
        "imarr = tf.keras.preprocessing.image.img_to_array(im)\n",
        "imarr = np.expand_dims(imarr, axis=0)\n",
        "predictions = full_model.predict(imarr)\n",
        "plt.imshow(imarr[0]/255)\n",
        "print(predictions)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dkemHKX_jCde",
        "colab_type": "text"
      },
      "source": [
        "# Save Weights\n",
        "- 이 정도로 충분하다고 느껴진다면, 이제 모델의 가중치를 저장할 차례입니다.\n",
        "- keras 는 다시 keras 를 이용해서 쉽게 모델을 불러올 수 있도록 저장하는 API 를 가지고 있습니다.\n",
        "- 확장자는 h5 입니다.\n",
        "- 저장합시다!"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KEfYMSrYjCBq",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "%cd /content/gdrive/\"My Drive\"/data/helmetclassification\n",
        "full_model.save(SAVED_KERAS_MODEL_NAME)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "I9hFqjeBmN5N",
        "colab_type": "text"
      },
      "source": [
        "# Next Time (part3)\n",
        "수고했습니다! 다음에는 이런 내용을 진행해 보도록 합시다.\n",
        "- 생성된 h5 모델을 불러들여 tflite 파일로 변환해 봅시다.\n",
        "- 구현된 모델을 조금 수정하면서, Class Activation Map* 을 한번 visualization 해 봅시다.\n",
        "\n",
        "*Class Activation Map 이란, Helmet 클래스로 판단하는 데 어떤 부분을 가장 주목해서 보았는지와 같이, 어떤 클래스로 판단하는 것의 근거를 Visualization 한 이미지를 의미합니다. \n"
      ]
    }
  ]
}