Fine-tuning_detection_export.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "QUANWN3rpfC9"
   },
   "source": [
    "# 0. Setup Paths"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "id": "146BB11JpfDA"
   },
   "outputs": [],
   "source": [
    "import os"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# setting up our pretrain model variable\n",
    "\n",
    "#cluster model folder\n",
    "CUSTOM_MODEL_NAME = 'my_ssd_mobnet'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "#setting up the name of our pre train model, this include the name of the file from the pre train TensorFlow 2 Detection Model Zoo\n",
    "PRETRAINED_MODEL_NAME = 'ssd_mobilenet_v2_fpnlite_640x640_coco17_tpu-8'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# downloading model from the tensorflow model zoo \n",
    "PRETRAINED_MODEL_URL = 'http://download.tensorflow.org/models/object_detection/tf2/20200711/ssd_mobilenet_v2_fpnlite_640x640_coco17_tpu-8.tar.gz'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "id": "42hJEdo_pfDB"
   },
   "outputs": [],
   "source": [
    " #setting up variables\n",
    "TF_RECORD_SCRIPT_NAME = 'generate_tfrecord.py'\n",
    "LABEL_MAP_NAME = 'label_map.pbtxt'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "id": "hbPhYVy_pfDB"
   },
   "outputs": [],
   "source": [
    "#creating our path for working folder\n",
    "paths = {\n",
    "    'WORKSPACE_PATH': os.path.join('Tensorflow', 'workspace'), # high level workspace\n",
    "    'SCRIPTS_PATH': os.path.join('Tensorflow','scripts'),\n",
    "    'APIMODEL_PATH': os.path.join('Tensorflow','models'),\n",
    "    'ANNOTATION_PATH': os.path.join('Tensorflow', 'workspace','annotations'), # where TF record file will be stored\n",
    "    'IMAGE_PATH': os.path.join('Tensorflow', 'workspace','images'),\n",
    "    'MODEL_PATH': os.path.join('Tensorflow', 'workspace','models'), # folder for the selected models tested\n",
    "    'PRETRAINED_MODEL_PATH': os.path.join('Tensorflow', 'workspace','pre-trained-models'),\n",
    "    'CHECKPOINT_PATH': os.path.join('Tensorflow', 'workspace','models',CUSTOM_MODEL_NAME), # selection of the working model\n",
    "    'OUTPUT_PATH': os.path.join('Tensorflow', 'workspace','models',CUSTOM_MODEL_NAME, 'export'), \n",
    "    'TFJS_PATH':os.path.join('Tensorflow', 'workspace','models',CUSTOM_MODEL_NAME, 'tfjsexport'), \n",
    "    'TFLITE_PATH':os.path.join('Tensorflow', 'workspace','models',CUSTOM_MODEL_NAME, 'tfliteexport'), \n",
    "    'PROTOC_PATH':os.path.join('Tensorflow','protoc')\n",
    " }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "id": "LwhWZMI0pfDC"
   },
   "outputs": [],
   "source": [
    "files = {\n",
    "    'PIPELINE_CONFIG':os.path.join('Tensorflow', 'workspace','models', CUSTOM_MODEL_NAME, 'pipeline.config'),\n",
    "    'TF_RECORD_SCRIPT': os.path.join(paths['SCRIPTS_PATH'], TF_RECORD_SCRIPT_NAME), \n",
    "    'LABELMAP': os.path.join(paths['ANNOTATION_PATH'], LABEL_MAP_NAME)\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {
    "id": "HR-TfDGrpfDC"
   },
   "outputs": [],
   "source": [
    "#creating our folders\n",
    "for path in paths.values():\n",
    "    if not os.path.exists(path):\n",
    "            !mkdir {path}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "OLU-rs_ipfDE"
   },
   "source": [
    "# 1. Download TF Models Pretrained Models from Tensorflow Model Zoo and Install TFOD"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# https://www.tensorflow.org/install/source_windows"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "import wget"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!git config --global core.longpaths true"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "iA1DIq5OpfDE"
   },
   "outputs": [],
   "source": [
    "#Cloning the TensorFlow model garden (TF2) to the folder 'models'\n",
    "if not os.path.exists(os.path.join(paths['APIMODEL_PATH'], 'research', 'object_detection')):\n",
    "    !git clone https://github.com/tensorflow/models {paths['APIMODEL_PATH']}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "rJjMHbnDs3Tv"
   },
   "outputs": [],
   "source": [
    "# Install Protocol buffers\n",
    "\n",
    "url=\"https://github.com/protocolbuffers/protobuf/releases/download/v3.15.6/protoc-3.15.6-win64.zip\"\n",
    "wget.download(url)\n",
    "!move protoc-3.15.6-win64.zip {paths['PROTOC_PATH']}\n",
    "!cd {paths['PROTOC_PATH']} && tar -xf protoc-3.15.6-win64.zip\n",
    "os.environ['PATH'] += os.pathsep + os.path.abspath(os.path.join(paths['PROTOC_PATH'], 'bin'))   \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    " # Install Tensorflow Object Detection API(for windows)\n",
    "!cd Tensorflow/models/research && protoc object_detection/protos/*.proto --python_out=. && copy object_detection\\\\packages\\\\tf2\\\\setup.py setup.py && python setup.py build && python setup.py install\n",
    "!cd Tensorflow/models/research/slim && pip install -e . "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#Making path to your verification script\n",
    "VERIFICATION_SCRIPT = os.path.join(paths['APIMODEL_PATH'], 'research', 'object_detection', 'builders', 'model_builder_tf2_test.py')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Verify Installation of the tensorflow model detection API\n",
    "!python {VERIFICATION_SCRIPT}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "All modules below were required to get the 'OK' from the verification script"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!wget {PRETRAINED_MODEL_URL}\n",
    "!mv {PRETRAINED_MODEL_NAME+'.tar.gz'} {paths['PRETRAINED_MODEL_PATH']}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "csofht2npfDE",
    "outputId": "ff5471b2-bed2-43f2-959c-327a706527b6"
   },
   "outputs": [],
   "source": [
    "# downloading model\n",
    "# the model is cloned into your folder /workspace/pre-trained model\n",
    "# un-tar the file\n",
    "!cd {paths['PRETRAINED_MODEL_PATH']} && tar -zxvf {PRETRAINED_MODEL_NAME+'.tar.gz'}\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "M5KJTnkfpfDC"
   },
   "source": [
    "# 2. Create Label Map"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "id": "p1BVDWo7pfDC"
   },
   "outputs": [],
   "source": [
    "#creating a map to the label in a text file \n",
    "label_list = [{'name':'white', 'id':1}]\n",
    "\n",
    "with open(files['LABELMAP'], 'w') as f:\n",
    "    for label in label_list:\n",
    "        f.write('item { \\n')\n",
    "        f.write('\\tname:\\'{}\\'\\n'.format(label['name']))\n",
    "        f.write('\\tid:{}\\n'.format(label['id']))\n",
    "        f.write('}\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "C88zyVELpfDC"
   },
   "source": [
    "# 3. Create TF records"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "KWpb_BVUpfDD",
    "outputId": "56ce2a3f-3933-4ee6-8a9d-d5ec65f7d73c"
   },
   "outputs": [],
   "source": [
    "# creating a TF record\n",
    "# cloning the script from a github repo\n",
    "# the script will convert the image label and annotation to a file format useable by tensor flow\n",
    "if not os.path.exists(files['TF_RECORD_SCRIPT']):\n",
    "    !git clone https://github.com/nicknochnack/GenerateTFRecord {paths['SCRIPTS_PATH']}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "UPFToGZqpfDD",
    "outputId": "0ebb456f-aadc-4a1f-96e6-fbfec1923e1c"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Successfully created the TFRecord file: Tensorflow\\workspace\\annotations\\train.record\n"
     ]
    }
   ],
   "source": [
    "# Create train data:\n",
    "!python {files['TF_RECORD_SCRIPT']} -x {os.path.join(paths['IMAGE_PATH'], 'train')} -l {files['LABELMAP']} -o {os.path.join(paths['ANNOTATION_PATH'], 'train.record')} "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Successfully created the TFRecord file: Tensorflow\\workspace\\annotations\\test.record\n"
     ]
    }
   ],
   "source": [
    "# Create test data:\n",
    "!python {files['TF_RECORD_SCRIPT']} -x {os.path.join(paths['IMAGE_PATH'], 'test')} -l {files['LABELMAP']} -o {os.path.join(paths['ANNOTATION_PATH'], 'test.record')} "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {
    "id": "cOjuTFbwpfDF"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "        1 file(s) copied.\n"
     ]
    }
   ],
   "source": [
    "#Copy our model configs (from the pipeline.config file) to the training forlder\n",
    "!copy {os.path.join(paths['PRETRAINED_MODEL_PATH'], PRETRAINED_MODEL_NAME, 'pipeline.config')} {os.path.join(paths['CHECKPOINT_PATH'])}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Ga8gpNslpfDF"
   },
   "source": [
    "# 4. Configure the Training Pipeline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "id": "Z9hRrO_ppfDF",
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "from object_detection.utils import config_util\n",
    "from object_detection.protos import pipeline_pb2\n",
    "from google.protobuf import text_format"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {
    "id": "c2A0mn4ipfDF"
   },
   "outputs": [],
   "source": [
    "#We are opening up the config file for the TF model\n",
    "config = config_util.get_configs_from_pipeline_file(files['PIPELINE_CONFIG'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "uQA13-afpfDF",
    "outputId": "907496a4-a39d-4b13-8c2c-e5978ecb1f10"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'model': ssd {\n",
       "   num_classes: 90\n",
       "   image_resizer {\n",
       "     fixed_shape_resizer {\n",
       "       height: 640\n",
       "       width: 640\n",
       "     }\n",
       "   }\n",
       "   feature_extractor {\n",
       "     type: \"ssd_mobilenet_v2_fpn_keras\"\n",
       "     depth_multiplier: 1.0\n",
       "     min_depth: 16\n",
       "     conv_hyperparams {\n",
       "       regularizer {\n",
       "         l2_regularizer {\n",
       "           weight: 3.9999998989515007e-05\n",
       "         }\n",
       "       }\n",
       "       initializer {\n",
       "         random_normal_initializer {\n",
       "           mean: 0.0\n",
       "           stddev: 0.009999999776482582\n",
       "         }\n",
       "       }\n",
       "       activation: RELU_6\n",
       "       batch_norm {\n",
       "         decay: 0.996999979019165\n",
       "         scale: true\n",
       "         epsilon: 0.0010000000474974513\n",
       "       }\n",
       "     }\n",
       "     use_depthwise: true\n",
       "     override_base_feature_extractor_hyperparams: true\n",
       "     fpn {\n",
       "       min_level: 3\n",
       "       max_level: 7\n",
       "       additional_layer_depth: 128\n",
       "     }\n",
       "   }\n",
       "   box_coder {\n",
       "     faster_rcnn_box_coder {\n",
       "       y_scale: 10.0\n",
       "       x_scale: 10.0\n",
       "       height_scale: 5.0\n",
       "       width_scale: 5.0\n",
       "     }\n",
       "   }\n",
       "   matcher {\n",
       "     argmax_matcher {\n",
       "       matched_threshold: 0.5\n",
       "       unmatched_threshold: 0.5\n",
       "       ignore_thresholds: false\n",
       "       negatives_lower_than_unmatched: true\n",
       "       force_match_for_each_row: true\n",
       "       use_matmul_gather: true\n",
       "     }\n",
       "   }\n",
       "   similarity_calculator {\n",
       "     iou_similarity {\n",
       "     }\n",
       "   }\n",
       "   box_predictor {\n",
       "     weight_shared_convolutional_box_predictor {\n",
       "       conv_hyperparams {\n",
       "         regularizer {\n",
       "           l2_regularizer {\n",
       "             weight: 3.9999998989515007e-05\n",
       "           }\n",
       "         }\n",
       "         initializer {\n",
       "           random_normal_initializer {\n",
       "             mean: 0.0\n",
       "             stddev: 0.009999999776482582\n",
       "           }\n",
       "         }\n",
       "         activation: RELU_6\n",
       "         batch_norm {\n",
       "           decay: 0.996999979019165\n",
       "           scale: true\n",
       "           epsilon: 0.0010000000474974513\n",
       "         }\n",
       "       }\n",
       "       depth: 128\n",
       "       num_layers_before_predictor: 4\n",
       "       kernel_size: 3\n",
       "       class_prediction_bias_init: -4.599999904632568\n",
       "       share_prediction_tower: true\n",
       "       use_depthwise: true\n",
       "     }\n",
       "   }\n",
       "   anchor_generator {\n",
       "     multiscale_anchor_generator {\n",
       "       min_level: 3\n",
       "       max_level: 7\n",
       "       anchor_scale: 4.0\n",
       "       aspect_ratios: 1.0\n",
       "       aspect_ratios: 2.0\n",
       "       aspect_ratios: 0.5\n",
       "       scales_per_octave: 2\n",
       "     }\n",
       "   }\n",
       "   post_processing {\n",
       "     batch_non_max_suppression {\n",
       "       score_threshold: 9.99999993922529e-09\n",
       "       iou_threshold: 0.6000000238418579\n",
       "       max_detections_per_class: 100\n",
       "       max_total_detections: 100\n",
       "       use_static_shapes: false\n",
       "     }\n",
       "     score_converter: SIGMOID\n",
       "   }\n",
       "   normalize_loss_by_num_matches: true\n",
       "   loss {\n",
       "     localization_loss {\n",
       "       weighted_smooth_l1 {\n",
       "       }\n",
       "     }\n",
       "     classification_loss {\n",
       "       weighted_sigmoid_focal {\n",
       "         gamma: 2.0\n",
       "         alpha: 0.25\n",
       "       }\n",
       "     }\n",
       "     classification_weight: 1.0\n",
       "     localization_weight: 1.0\n",
       "   }\n",
       "   encode_background_as_zeros: true\n",
       "   normalize_loc_loss_by_codesize: true\n",
       "   inplace_batchnorm_update: true\n",
       "   freeze_batchnorm: false\n",
       " },\n",
       " 'train_config': batch_size: 128\n",
       " data_augmentation_options {\n",
       "   random_horizontal_flip {\n",
       "   }\n",
       " }\n",
       " data_augmentation_options {\n",
       "   random_crop_image {\n",
       "     min_object_covered: 0.0\n",
       "     min_aspect_ratio: 0.75\n",
       "     max_aspect_ratio: 3.0\n",
       "     min_area: 0.75\n",
       "     max_area: 1.0\n",
       "     overlap_thresh: 0.0\n",
       "   }\n",
       " }\n",
       " sync_replicas: true\n",
       " optimizer {\n",
       "   momentum_optimizer {\n",
       "     learning_rate {\n",
       "       cosine_decay_learning_rate {\n",
       "         learning_rate_base: 0.07999999821186066\n",
       "         total_steps: 50000\n",
       "         warmup_learning_rate: 0.026666000485420227\n",
       "         warmup_steps: 1000\n",
       "       }\n",
       "     }\n",
       "     momentum_optimizer_value: 0.8999999761581421\n",
       "   }\n",
       "   use_moving_average: false\n",
       " }\n",
       " fine_tune_checkpoint: \"PATH_TO_BE_CONFIGURED\"\n",
       " num_steps: 50000\n",
       " startup_delay_steps: 0.0\n",
       " replicas_to_aggregate: 8\n",
       " max_number_of_boxes: 100\n",
       " unpad_groundtruth_tensors: false\n",
       " fine_tune_checkpoint_type: \"classification\"\n",
       " fine_tune_checkpoint_version: V2,\n",
       " 'train_input_config': label_map_path: \"PATH_TO_BE_CONFIGURED\"\n",
       " tf_record_input_reader {\n",
       "   input_path: \"PATH_TO_BE_CONFIGURED\"\n",
       " },\n",
       " 'eval_config': metrics_set: \"coco_detection_metrics\"\n",
       " use_moving_averages: false,\n",
       " 'eval_input_configs': [label_map_path: \"PATH_TO_BE_CONFIGURED\"\n",
       " shuffle: false\n",
       " num_epochs: 1\n",
       " tf_record_input_reader {\n",
       "   input_path: \"PATH_TO_BE_CONFIGURED\"\n",
       " }\n",
       " ],\n",
       " 'eval_input_config': label_map_path: \"PATH_TO_BE_CONFIGURED\"\n",
       " shuffle: false\n",
       " num_epochs: 1\n",
       " tf_record_input_reader {\n",
       "   input_path: \"PATH_TO_BE_CONFIGURED\"\n",
       " }}"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "config"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {
    "id": "9vK5lotDpfDF"
   },
   "outputs": [],
   "source": [
    "#Using protocol buffer to process the config file\n",
    "\n",
    "#Reads config from a file containing pipeline_pb2.TrainEvalPipelineConfig.\n",
    "#Args: pipeline_config_path: Path to pipeline_pb2.TrainEvalPipeline Config text proto.\n",
    "#config_override: A pipeline_pb2.TrainEvalPipelineConfig text proto to override pipeline_config_path.\n",
    "\n",
    "#Script from: https://github.com/tensorflow/models/blob/master/research/object_detection/utils/config_util.py \n",
    "\n",
    "pipeline_config = pipeline_pb2.TrainEvalPipelineConfig()\n",
    "with tf.io.gfile.GFile(files['PIPELINE_CONFIG'], \"r\") as f:                                                                                                                                                                                                                     \n",
    "    proto_str = f.read()                                                                                                                                                                                                                                          \n",
    "    text_format.Merge(proto_str, pipeline_config)  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {
    "id": "rP43Ph0JpfDG"
   },
   "outputs": [],
   "source": [
    "#Configure  pipeline_config file\n",
    "#Dictionary of configuration objects. Keys are `model`, `train_config`, `train_input_config`, `eval_config`, `eval_input_config`. \n",
    "#Value are the corresponding config objects.\n",
    "pipeline_config.model.ssd.num_classes = len(label_list)\n",
    "pipeline_config.train_config.batch_size = 4\n",
    "pipeline_config.train_config.fine_tune_checkpoint = os.path.join(paths['PRETRAINED_MODEL_PATH'], PRETRAINED_MODEL_NAME, 'checkpoint', 'ckpt-0')\n",
    "pipeline_config.train_config.fine_tune_checkpoint_type = \"detection\"\n",
    "pipeline_config.train_input_reader.label_map_path= files['LABELMAP']\n",
    "pipeline_config.train_input_reader.tf_record_input_reader.input_path[:] = [os.path.join(paths['ANNOTATION_PATH'], 'train.record')]\n",
    "pipeline_config.eval_input_reader[0].label_map_path = files['LABELMAP']\n",
    "pipeline_config.eval_input_reader[0].tf_record_input_reader.input_path[:] = [os.path.join(paths['ANNOTATION_PATH'], 'test.record')]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {
    "id": "oJvfgwWqpfDG"
   },
   "outputs": [],
   "source": [
    "# write a new pipeline config file\n",
    "config_text = text_format.MessageToString(pipeline_config)                                                                                                                                                                                                        \n",
    "with tf.io.gfile.GFile(files['PIPELINE_CONFIG'], \"wb\") as f:   #open for writing in binary mode                                                                                                                                                                                                                   \n",
    "    f.write(config_text)   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Zr3ON7xMpfDG"
   },
   "source": [
    "# 5. Train the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "id": "B-Y2UQmQpfDG"
   },
   "outputs": [],
   "source": [
    "TRAINING_SCRIPT = os.path.join(paths['APIMODEL_PATH'], 'research', 'object_detection', 'model_main_tf2.py')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "id": "jMP2XDfQpfDH"
   },
   "outputs": [],
   "source": [
    "#running the model_main_tf2.py file\n",
    "#Passing our model directory with the pipeline_config file\n",
    "#select the number of steps\n",
    "command = \"python {} --model_dir={} --pipeline_config_path={} --num_train_steps=50000\".format(TRAINING_SCRIPT, paths['CHECKPOINT_PATH'],files['PIPELINE_CONFIG'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "A4OXXi-ApfDH",
    "outputId": "117a0e83-012b-466e-b7a6-ccaa349ac5ab"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "python Tensorflow\\models\\research\\object_detection\\model_main_tf2.py --model_dir=Tensorflow\\workspace\\models\\my_ssd_mobnet --pipeline_config_path=Tensorflow\\workspace\\models\\my_ssd_mobnet\\pipeline.config --num_train_steps=50000\n"
     ]
    }
   ],
   "source": [
    "print(command)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "i3ZsJR-qpfDH",
    "outputId": "cabec5e1-45e6-4f2f-d9cf-297d9c1d0225"
   },
   "outputs": [],
   "source": [
    "# I would recommend to run this command in the terminal (copy print above)\n",
    "!{command}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "4_YRZu7npfDH"
   },
   "source": [
    "# 6. Evaluate the Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "id": "80L7-fdPpfDH"
   },
   "outputs": [],
   "source": [
    "command = \"python {} --model_dir={} --pipeline_config_path={} --checkpoint_dir={}\".format(TRAINING_SCRIPT, paths['CHECKPOINT_PATH'],files['PIPELINE_CONFIG'], paths['CHECKPOINT_PATH'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "lYsgEPx9pfDH",
    "outputId": "8632d48b-91d2-45d9-bcb8-c1b172bf6eed"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "python Tensorflow\\models\\research\\object_detection\\model_main_tf2.py --model_dir=Tensorflow\\workspace\\models\\my_ssd_mobnet --pipeline_config_path=Tensorflow\\workspace\\models\\my_ssd_mobnet\\pipeline.config --checkpoint_dir=Tensorflow\\workspace\\models\\my_ssd_mobnet\n"
     ]
    }
   ],
   "source": [
    "print(command)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "lqTV2jGBpfDH"
   },
   "outputs": [],
   "source": [
    "!{command}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "orvRk02UpfDI"
   },
   "source": [
    "# 7. Load Train Model From Checkpoint"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "id": "8TYk4_oIpfDI"
   },
   "outputs": [],
   "source": [
    "import os\n",
    "import tensorflow as tf\n",
    "from object_detection.utils import label_map_util\n",
    "from object_detection.utils import visualization_utils as viz_utils\n",
    "from object_detection.builders import model_builder\n",
    "from object_detection.utils import config_util"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "id": "tDnQg-cYpfDI"
   },
   "outputs": [],
   "source": [
    "# Load pipeline config and build a detection model\n",
    "configs = config_util.get_configs_from_pipeline_file(files['PIPELINE_CONFIG'])\n",
    "detection_model = model_builder.build(model_config=configs['model'], is_training=False)\n",
    "\n",
    "# Restore checkpoint\n",
    "ckpt = tf.compat.v2.train.Checkpoint(model=detection_model)\n",
    "# Selecting our most train model\n",
    "ckpt.restore(os.path.join(paths['CHECKPOINT_PATH'], 'ckpt-51')).expect_partial()\n",
    "\n",
    "@tf.function\n",
    "def detect_fn(image):\n",
    "    \"\"\"Detect objects in image.\"\"\"\n",
    "    image, shapes = detection_model.preprocess(image)\n",
    "    prediction_dict = detection_model.predict(image, shapes)\n",
    "    detections = detection_model.postprocess(prediction_dict, shapes)\n",
    "    return detections"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "0EmsmbBZpfDI"
   },
   "source": [
    "# 8. Detect from an Image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "id": "Y_MKiuZ4pfDI"
   },
   "outputs": [],
   "source": [
    "import cv2 \n",
    "import numpy as np\n",
    "from matplotlib import pyplot as plt\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "id": "cBDbIhNapfDI"
   },
   "outputs": [],
   "source": [
    "# select our face label\n",
    "category_index = label_map_util.create_category_index_from_labelmap(files['LABELMAP'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "id": "Lx3crOhOzITB"
   },
   "outputs": [],
   "source": [
    "# Reset image path\n",
    "IMAGE_PATH = os.path.join(paths['IMAGE_PATH'], 'test', 'istockphoto_184359873.jpg')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 269
    },
    "id": "Tpzn1SMry1yK",
    "outputId": "c392a2c5-10fe-4fc4-9998-a1d4c7db2bd3",
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "array([0.5175824 , 0.81269383, 0.71811724, 0.9208236 ], dtype=float32)"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "# Loading image into python\n",
    "img = cv2.imread(IMAGE_PATH)\n",
    "image_np = np.array(img)\n",
    "\n",
    "# Converting image to a tensor and the detection function \n",
    "input_tensor = tf.convert_to_tensor(np.expand_dims(image_np, 0), dtype=tf.float32)\n",
    "detections = detect_fn(input_tensor)\n",
    "\n",
    "# All outputs are batches tensors.\n",
    "# Convert to numpy arrays, and take index [0] to remove the batch dimension.\n",
    "num_detections = int(detections.pop('num_detections'))\n",
    "detections = {key: value[0, :num_detections].numpy()\n",
    "              for key, value in detections.items()}\n",
    "detections['num_detections'] = num_detections\n",
    "\n",
    "# Detection_classes should be ints.\n",
    "detections['detection_classes'] = detections['detection_classes'].astype(np.int64)\n",
    "\n",
    "label_id_offset = 1\n",
    "image_np_with_detections = image_np.copy()\n",
    "\n",
    "viz_utils.visualize_boxes_and_labels_on_image_array(\n",
    "            image_np_with_detections,\n",
    "            detections['detection_boxes'],\n",
    "            detections['detection_classes']+label_id_offset,\n",
    "            detections['detection_scores'],\n",
    "            category_index,\n",
    "            use_normalized_coordinates=True,\n",
    "            max_boxes_to_draw=100,\n",
    "            min_score_thresh=.5,\n",
    "            agnostic_mode=False)\n",
    "\n",
    "\n",
    "\n",
    "plt.imshow(cv2.cvtColor(image_np_with_detections, cv2.COLOR_BGR2RGB))\n",
    "plt.show()\n",
    "\n",
    "detections['detection_boxes'][0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 9. Real Time Detections from your Webcam"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!pip uninstall opencv-python-headless -y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cap = cv2.VideoCapture(0)\n",
    "width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))\n",
    "height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))\n",
    "\n",
    "while cap.isOpened(): \n",
    "    ret, frame = cap.read()\n",
    "    image_np = np.array(frame)\n",
    "    \n",
    "    input_tensor = tf.convert_to_tensor(np.expand_dims(image_np, 0), dtype=tf.float32)\n",
    "    detections = detect_fn(input_tensor)\n",
    "    \n",
    "    num_detections = int(detections.pop('num_detections'))\n",
    "    detections = {key: value[0, :num_detections].numpy()\n",
    "                  for key, value in detections.items()}\n",
    "    detections['num_detections'] = num_detections\n",
    "\n",
    "    # detection_classes should be ints.\n",
    "    detections['detection_classes'] = detections['detection_classes'].astype(np.int64)\n",
    "\n",
    "    label_id_offset = 1\n",
    "    image_np_with_detections = image_np.copy()\n",
    "\n",
    "    viz_utils.visualize_boxes_and_labels_on_image_array(\n",
    "                image_np_with_detections,\n",
    "                detections['detection_boxes'],\n",
    "                detections['detection_classes']+label_id_offset,\n",
    "                detections['detection_scores'],\n",
    "                category_index,\n",
    "                use_normalized_coordinates=True,\n",
    "                max_boxes_to_draw=5,\n",
    "                min_score_thresh=.8,\n",
    "                agnostic_mode=False)\n",
    "\n",
    "    cv2.imshow('object detection',  cv2.resize(image_np_with_detections, (800, 600)))\n",
    "    \n",
    "    if cv2.waitKey(10) & 0xFF == ord('q'):\n",
    "        cap.release()\n",
    "        cv2.destroyAllWindows()\n",
    "        break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 10. Saving the model (Freezing the Graph)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "FREEZE_SCRIPT = os.path.join(paths['APIMODEL_PATH'], 'research', 'object_detection', 'exporter_main_v2.py ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "command = \"python {} --input_type=image_tensor --pipeline_config_path={} --trained_checkpoint_dir={} --output_directory={}\".format(FREEZE_SCRIPT ,files['PIPELINE_CONFIG'], paths['CHECKPOINT_PATH'], paths['OUTPUT_PATH'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "python Tensorflow\\models\\research\\object_detection\\exporter_main_v2.py  --input_type=image_tensor --pipeline_config_path=Tensorflow\\workspace\\models\\my_ssd_mobnet\\pipeline.config --trained_checkpoint_dir=Tensorflow\\workspace\\models\\my_ssd_mobnet --output_directory=Tensorflow\\workspace\\models\\my_ssd_mobnet\\export\n"
     ]
    }
   ],
   "source": [
    "print(command)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!{command}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 11. Conversion to TFJS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!pip install tensorflowjs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "command = \"tensorflowjs_converter --input_format=tf_saved_model --output_node_names='detection_boxes,detection_classes,detection_features,detection_multiclass_scores,detection_scores,num_detections,raw_detection_boxes,raw_detection_scores' --output_format=tfjs_graph_model --signature_name=serving_default {} {}\".format(os.path.join(paths['OUTPUT_PATH'], 'saved_model'), paths['TFJS_PATH'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(command)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "!{command}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 12. Conversion to TFLite"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "TFLITE_SCRIPT = os.path.join(paths['APIMODEL_PATH'], 'research', 'object_detection', 'export_tflite_graph_tf2.py ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "command = \"python {} --pipeline_config_path={} --trained_checkpoint_dir={} --output_directory={}\".format(TFLITE_SCRIPT ,files['PIPELINE_CONFIG'], paths['CHECKPOINT_PATH'], paths['TFLITE_PATH'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "python Tensorflow\\models\\research\\object_detection\\export_tflite_graph_tf2.py  --pipeline_config_path=Tensorflow\\workspace\\models\\my_ssd_mobnet\\pipeline.config --trained_checkpoint_dir=Tensorflow\\workspace\\models\\my_ssd_mobnet --output_directory=Tensorflow\\workspace\\models\\my_ssd_mobnet\\tfliteexport\n"
     ]
    }
   ],
   "source": [
    "print(command)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!{command}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "FROZEN_TFLITE_PATH = os.path.join(paths['TFLITE_PATH'], 'saved_model')\n",
    "TFLITE_MODEL = os.path.join(paths['TFLITE_PATH'], 'saved_model', 'detectv9b.tflite')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "command = \"tflite_convert \\\n",
    "--saved_model_dir={} \\\n",
    "--output_file={} \\\n",
    "--input_shapes=1,300,300,3 \\\n",
    "--input_arrays=normalized_input_image_tensor \\\n",
    "--output_arrays='TFLite_Detection_PostProcess','TFLite_Detection_PostProcess:1','TFLite_Detection_PostProcess:2','TFLite_Detection_PostProcess:3' \\\n",
    "--inference_type=FLOAT \\\n",
    "--allow_custom_ops\".format(FROZEN_TFLITE_PATH, TFLITE_MODEL, )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tflite_convert --saved_model_dir=Tensorflow\\workspace\\models\\my_ssd_mobnet\\tfliteexport\\saved_model --output_file=Tensorflow\\workspace\\models\\my_ssd_mobnet\\tfliteexport\\saved_model\\detectv9.tflite --input_shapes=1,300,300,3 --input_arrays=normalized_input_image_tensor --output_arrays='TFLite_Detection_PostProcess','TFLite_Detection_PostProcess:1','TFLite_Detection_PostProcess:2','TFLite_Detection_PostProcess:3' --inference_type=QUANTIZED_UINT8 --mean_values=128 --std_dev_values=127 --change_concat_input_ranges=false --allow_custom_ops\n"
     ]
    }
   ],
   "source": [
    "print(command)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "!{command}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "\n",
    "saved_model_dir = 'C:\\\\Users\\\\poopo\\\\Documents\\\\Tensor flow object detection\\\\TFODFace5\\\\Tensorflow\\\\workspace\\\\models\\\\my_ssd_mobnet\\\\tfliteexport\\\\saved_model'\n",
    "\n",
    "# Convert the model\n",
    "converter = tf.lite.TFLiteConverter.from_saved_model(saved_model_dir) # path to the SavedModel directory\n",
    "tflite_model = converter.convert()\n",
    "\n",
    "# Save the model.\n",
    "with open('model.tflite', 'wb') as f:\n",
    "  f.write(tflite_model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Convert the model\n",
    "converter = tf.lite.TFLiteConverter.from_saved_model(saved_model_dir) # path to the SavedModel directory\n",
    "\n",
    "#Post-training quantization is a conversion technique that can reduce model size while also improving CPU\n",
    "#and hardware accelerator latency, with little degradation in model accuracy.\n",
    "#To quantize the model on export, set the optimizations flag to optimize for size:\n",
    "converter.optimizations = [tf.lite.Optimize.DEFAULT]\n",
    "\n",
    "tflite_model = converter.convert()\n",
    "\n",
    "# Save the model.\n",
    "with open(TFLITE_MODEL, 'wb') as f:\n",
    "  f.write(tflite_model)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 13. Zip and Export Models "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "!tar -czf models.tar.gz {paths['CHECKPOINT_PATH']}"
   ]
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "name": "3. Training and Detection.ipynb",
   "provenance": []
  },
  "kernelspec": {
   "display_name": "tfod5",
   "language": "python",
   "name": "tfod5"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}