From c75e8201073ef11c0ca1c56f5c0bf36093116cd3 Mon Sep 17 00:00:00 2001 From: fierval Date: Tue, 2 Jul 2019 17:23:56 -0700 Subject: [PATCH] ssd vgg --- .../Finetune VGG SSD-checkpoint.ipynb | 423 +++++++++++ .../notebooks/Deploy Accelerated.ipynb | 633 +++++++++++++++++ .../notebooks/Finetune VGG SSD.ipynb | 423 +++++++++++ .../finetune-ssd-vgg/notebooks/config.json | 5 + .../finetune-ssd-vgg/notebooks/sample.jpg | Bin 0 -> 84889 bytes .../finetune-ssd-vgg/notebooks/sample.xml | 26 + .../finetune-ssd-vgg/tfssd/__init__.py | 0 .../tfssd/anchors/.__init__.py | 0 .../tfssd/anchors/generate_anchors.py | 92 +++ .../tfssd/dataprep/dataset_utils.py | 114 +++ .../tfssd/dataprep/pascalvoc_common.py | 112 +++ .../tfssd/dataprep/pascalvoc_to_tfrecords.py | 223 ++++++ .../tfssd/datautil/__init__.py | 0 .../finetune-ssd-vgg/tfssd/datautil/parser.py | 65 ++ .../tfssd/datautil/ssd_vgg_preprocessing.py | 397 +++++++++++ .../tfssd/datautil/tf_image.py | 306 ++++++++ .../tfssd/finetune/__init__.py | 0 .../finetune-ssd-vgg/tfssd/finetune/eval.py | 159 +++++ .../tfssd/finetune/inference.py | 95 +++ .../tfssd/finetune/metrics.py | 0 .../tfssd/finetune/model_saver.py | 57 ++ .../finetune-ssd-vgg/tfssd/finetune/train.py | 144 ++++ .../tfssd/finetune/train_eval_base.py | 125 ++++ .../finetune-ssd-vgg/tfssd/model/__init__.py | 0 .../tfssd/model/custom_layers.py | 164 +++++ .../tfssd/model/np_methods.py | 252 +++++++ .../tfssd/model/ssd_common.py | 408 +++++++++++ .../tfssd/model/ssd_vgg_300.py | 660 ++++++++++++++++++ .../tfssd/tfextended/__init__.py | 24 + .../tfssd/tfextended/bboxes.py | 508 ++++++++++++++ .../tfssd/tfextended/image.py | 0 .../finetune-ssd-vgg/tfssd/tfextended/math.py | 63 ++ .../tfssd/tfextended/metrics.py | 397 +++++++++++ .../tfssd/tfextended/tensors.py | 95 +++ .../finetune-ssd-vgg/tfssd/tfutil/__init__.py | 0 .../tfssd/tfutil/endpoints.py | 20 + .../finetune-ssd-vgg/tfssd/tfutil/tf_utils.py | 158 +++++ .../tfssd/tfutil/visualization.py | 114 +++ 38 files changed, 6262 insertions(+) create mode 100644 how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/notebooks/.ipynb_checkpoints/Finetune VGG SSD-checkpoint.ipynb create mode 100644 how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/notebooks/Deploy Accelerated.ipynb create mode 100644 how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/notebooks/Finetune VGG SSD.ipynb create mode 100644 how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/notebooks/config.json create mode 100644 how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/notebooks/sample.jpg create mode 100644 how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/notebooks/sample.xml create mode 100644 how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/__init__.py create mode 100644 how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/anchors/.__init__.py create mode 100644 how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/anchors/generate_anchors.py create mode 100644 how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/dataprep/dataset_utils.py create mode 100644 how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/dataprep/pascalvoc_common.py create mode 100644 how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/dataprep/pascalvoc_to_tfrecords.py create mode 100644 how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/datautil/__init__.py create mode 100644 how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/datautil/parser.py create mode 100644 how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/datautil/ssd_vgg_preprocessing.py create mode 100644 how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/datautil/tf_image.py create mode 100644 how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/finetune/__init__.py create mode 100644 how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/finetune/eval.py create mode 100644 how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/finetune/inference.py create mode 100644 how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/finetune/metrics.py create mode 100644 how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/finetune/model_saver.py create mode 100644 how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/finetune/train.py create mode 100644 how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/finetune/train_eval_base.py create mode 100644 how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/model/__init__.py create mode 100644 how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/model/custom_layers.py create mode 100644 how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/model/np_methods.py create mode 100644 how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/model/ssd_common.py create mode 100644 how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/model/ssd_vgg_300.py create mode 100644 how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/tfextended/__init__.py create mode 100644 how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/tfextended/bboxes.py create mode 100644 how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/tfextended/image.py create mode 100644 how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/tfextended/math.py create mode 100644 how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/tfextended/metrics.py create mode 100644 how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/tfextended/tensors.py create mode 100644 how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/tfutil/__init__.py create mode 100644 how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/tfutil/endpoints.py create mode 100644 how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/tfutil/tf_utils.py create mode 100644 how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/tfutil/visualization.py diff --git a/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/notebooks/.ipynb_checkpoints/Finetune VGG SSD-checkpoint.ipynb b/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/notebooks/.ipynb_checkpoints/Finetune VGG SSD-checkpoint.ipynb new file mode 100644 index 00000000..075b4ce9 --- /dev/null +++ b/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/notebooks/.ipynb_checkpoints/Finetune VGG SSD-checkpoint.ipynb @@ -0,0 +1,423 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Finetuning VGG-SSD Object Detection Model" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Prerequisits for Local Training\n", + "\n", + "* CUDA 10.0, cuDNN 7.4\n", + "* Recent Anaconda environment\n", + "* Tensorflow 1.12+" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# install supported FPGA ML models, including VGG SSD\n", + "# skip if already installed\n", + "!pip install azureml-accel-models\n", + "!pip install -U --ignore-installed tensorflow-gpu==1.13.1" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2\n", + "import os, sys, glob\n", + "import tensorflow as tf\n", + "\n", + "# Tensorflow Finetuning Package\n", + "sys.path.insert(0, os.path.abspath('../tfssd/'))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Import Training / Validation Data\n", + "\n", + "Images are .jpg files and annotations - .xml files in PASCAL VOC format.\n", + "Each image file has a matching annotations file\n", + "\n", + "In this notebook we are looking for gaps on the shelves stocked with different products:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import cv2\n", + "plt.rcParams['figure.figsize'] = 10, 10\n", + "img = cv2.imread('sample.jpg')\n", + "\n", + "img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)\n", + "plt.imshow(img)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "779 images found and 779 matching annotations found.\n" + ] + } + ], + "source": [ + "from dataprep import dataset_utils, pascalvoc_to_tfrecords\n", + "\n", + "data_dir = r'x:\\data\\grocery\\source'\n", + "data_dir_images = os.path.join(data_dir, \"JPEGImages\")\n", + "data_dir_annotations = os.path.join(data_dir, \"Annotations\")\n", + "classes = [\"stockout\"]\n", + "\n", + "images = glob.glob(os.path.join(data_dir_images, \"*.jpg\"))\n", + "annotations = glob.glob(os.path.join(data_dir_annotations, \"*.xml\"))\n", + "\n", + "# check for image and annotations files matching each other\n", + "images, annotations = dataset_utils.check_labelmatch(images, annotations)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Split Into Training and Validation and Create TFRecord Datasets" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + ">> Converting image 1/623WARNING:tensorflow:From C:\\git\\neal\\AzureFork\\MachineLearningNotebooks\\how-to-use-azureml\\deployment\\accelerated-models\\finetune-ssd-vgg\\tfssd\\dataprep\\pascalvoc_to_tfrecords.py:78: FastGFile.__init__ (from tensorflow.python.platform.gfile) is deprecated and will be removed in a future version.\n", + "Instructions for updating:\n", + "Use tf.gfile.GFile.\n", + ">> Converting image 623/623\n", + "Finished converting the Pascal VOC dataset!\n", + ">> Converting image 156/156\n", + "Finished converting the Pascal VOC dataset!\n", + "['test_0000.tfrecord', 'test_0001.tfrecord', 'train_0000.tfrecord', 'train_0001.tfrecord', 'train_0002.tfrecord', 'train_0003.tfrecord', 'train_0004.tfrecord', 'train_0005.tfrecord', 'train_0006.tfrecord']\n" + ] + } + ], + "source": [ + "from sklearn.model_selection import train_test_split\n", + "\n", + "train_images, test_images, \\\n", + " train_annotations, test_annotations = train_test_split(images, annotations, test_size = .2, random_state = 40)\n", + "\n", + "data_output_dir = os.path.join(data_dir, \"../tfrec\")\n", + "\n", + "pascalvoc_to_tfrecords.run(data_output_dir, classes, train_images, train_annotations, \"train\")\n", + "pascalvoc_to_tfrecords.run(data_output_dir, classes, test_images, test_annotations, \"test\")\n", + "\n", + "print(os.listdir(data_output_dir))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Setup and Run Training/Validation Loops" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Setup Training Data, Import the Model" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "from finetune.train import TrainVggSsd\n", + "from finetune.eval import EvalVggSsd\n", + "\n", + "root_dir = r'x:\\grocery\\azml_ssd_vgg'\n", + "# this is the directory where the original model to be\n", + "# fine-tuned will be delivered and models saved as the training loop runs\n", + "ckpt_dir = root_dir\n", + "\n", + "# get .tfrecord files created in the previous step\n", + "train_files = glob.glob(os.path.join(data_output_dir, \"train_*.tfrecord\"))\n", + "validation_files = glob.glob(os.path.join(data_output_dir, \"test_*.tfrecord\"))\n", + "\n", + "# run for these epochs\n", + "n_epochs = 6" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Training Parameters" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# steps per training epoch\n", + "num_train_steps=3000\n", + "# batch size. \n", + "batch_size = 2\n", + "# steps to save as a checkpoint\n", + "steps_to_save=3000\n", + "# using Adam optimizer. These are the configurable parameters\n", + "learning_rate = 1e-4\n", + "learning_rate_decay_steps=3000\n", + "learning_rate_decay_value=0.96" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Validation Parameters" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "num_eval_steps=156\n", + "# number of classes. Includes the \"none\" (background) class\n", + "# cannot be more than 21\n", + "num_classes=2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Run Training Loop" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "WARNING:tensorflow:From C:\\git\\neal\\AzureFork\\MachineLearningNotebooks\\how-to-use-azureml\\deployment\\accelerated-models\\finetune-ssd-vgg\\tfssd\\datautil\\ssd_vgg_preprocessing.py:213: sample_distorted_bounding_box (from tensorflow.python.ops.image_ops_impl) is deprecated and will be removed in a future version.\n", + "Instructions for updating:\n", + "`seed2` arg is deprecated.Use sample_distorted_bounding_box_v2 instead.\n", + "WARNING:tensorflow:From C:\\Anaconda3\\envs\\brain\\lib\\site-packages\\tensorflow\\python\\ops\\control_flow_ops.py:423: colocate_with (from tensorflow.python.framework.ops) is deprecated and will be removed in a future version.\n", + "Instructions for updating:\n", + "Colocations handled automatically by placer.\n", + "WARNING:tensorflow:From C:\\Anaconda3\\envs\\brain\\lib\\site-packages\\tensorflow\\python\\util\\tf_should_use.py:193: initialize_variables (from tensorflow.python.ops.variables) is deprecated and will be removed after 2017-03-02.\n", + "Instructions for updating:\n", + "Use `tf.variables_initializer` instead.\n", + "WARNING:tensorflow:From C:\\Anaconda3\\envs\\brain\\lib\\site-packages\\tensorflow\\python\\training\\saver.py:1266: checkpoint_exists (from tensorflow.python.training.checkpoint_management) is deprecated and will be removed in a future version.\n", + "Instructions for updating:\n", + "Use standard file APIs to check for files with this prefix.\n", + "INFO:tensorflow:Restoring parameters from x:\\grocery\\azml_ssd_vgg\\vggssd\\1.1.3\\ssd_vgg_bw\n", + "INFO:tensorflow:Starting training for 3000 steps\n", + "3000: loss: 44.949, avg per step: 0.048 secc\n", + "\n", + "INFO:tensorflow:Restoring parameters from x:\\grocery\\azml_ssd_vgg\\vggssd\\1.1.3\\ssd_vgg_bw-3000\n", + "INFO:tensorflow:Starting evaluation for 156 steps\n", + "Evaluation step: 156\n", + "mAP: 0.8393\n", + "INFO:tensorflow:Restoring parameters from x:\\grocery\\azml_ssd_vgg\\vggssd\\1.1.3\\ssd_vgg_bw-3000\n", + "INFO:tensorflow:Starting training for 3000 steps\n", + "6000: loss: 16.735, avg per step: 0.054 secc\n", + "\n", + "INFO:tensorflow:Restoring parameters from x:\\grocery\\azml_ssd_vgg\\vggssd\\1.1.3\\ssd_vgg_bw-6000\n", + "INFO:tensorflow:Starting evaluation for 156 steps\n", + "Evaluation step: 156\n", + "mAP: 0.8477\n", + "INFO:tensorflow:Restoring parameters from x:\\grocery\\azml_ssd_vgg\\vggssd\\1.1.3\\ssd_vgg_bw-6000\n", + "INFO:tensorflow:Starting training for 3000 steps\n", + "9000: loss: 17.331, avg per step: 0.048 secc\n", + "\n", + "INFO:tensorflow:Restoring parameters from x:\\grocery\\azml_ssd_vgg\\vggssd\\1.1.3\\ssd_vgg_bw-9000\n", + "INFO:tensorflow:Starting evaluation for 156 steps\n", + "Evaluation step: 156\n", + "mAP: 0.8689\n", + "INFO:tensorflow:Restoring parameters from x:\\grocery\\azml_ssd_vgg\\vggssd\\1.1.3\\ssd_vgg_bw-9000\n", + "INFO:tensorflow:Starting training for 3000 steps\n", + "12000: loss: 28.185, avg per step: 0.048 secc\n", + "\n", + "INFO:tensorflow:Restoring parameters from x:\\grocery\\azml_ssd_vgg\\vggssd\\1.1.3\\ssd_vgg_bw-12000\n", + "INFO:tensorflow:Starting evaluation for 156 steps\n", + "Evaluation step: 156\n", + "mAP: 0.8711\n", + "INFO:tensorflow:Restoring parameters from x:\\grocery\\azml_ssd_vgg\\vggssd\\1.1.3\\ssd_vgg_bw-12000\n", + "INFO:tensorflow:Starting training for 3000 steps\n", + "15000: loss: 38.361, avg per step: 0.051 secc\n", + "\n", + "INFO:tensorflow:Restoring parameters from x:\\grocery\\azml_ssd_vgg\\vggssd\\1.1.3\\ssd_vgg_bw-15000\n", + "INFO:tensorflow:Starting evaluation for 156 steps\n", + "Evaluation step: 156\n", + "mAP: 0.8753\n", + "INFO:tensorflow:Restoring parameters from x:\\grocery\\azml_ssd_vgg\\vggssd\\1.1.3\\ssd_vgg_bw-15000\n", + "INFO:tensorflow:Starting training for 3000 steps\n", + "18000: loss: 43.066, avg per step: 0.051 secc\n", + "\n", + "INFO:tensorflow:Restoring parameters from x:\\grocery\\azml_ssd_vgg\\vggssd\\1.1.3\\ssd_vgg_bw-18000\n", + "INFO:tensorflow:Starting evaluation for 156 steps\n", + "Evaluation step: 156\n", + "mAP: 0.8769\n" + ] + } + ], + "source": [ + "for _ in range(n_epochs):\n", + "\n", + " with TrainVggSsd(ckpt_dir, train_files, \n", + " num_steps=num_train_steps, \n", + " steps_to_save=steps_to_save, \n", + " batch_size = batch_size,\n", + " learning_rate=learning_rate,\n", + " learning_rate_decay_steps=learning_rate_decay_steps, \n", + " learning_rate_decay_value=learning_rate_decay_value) as trainer:\n", + " trainer.train()\n", + "\n", + " with EvalVggSsd(ckpt_dir, validation_files, \n", + " num_steps=num_eval_steps, \n", + " num_classes=num_classes) as evaluator:\n", + " evaluator.eval() " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Visualize Training Results" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "INFO:tensorflow:Restoring parameters from x:\\grocery\\azml_ssd_vgg\\vggssd\\1.1.3\\ssd_vgg_bw-18000\n" + ] + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "from finetune.inference import InferVggSsd\n", + "\n", + "plt.rcParams[\"figure.figsize\"] = 15, 15\n", + "path = 'X:/data/grocery/dataset/test/JPEGImages'\n", + "image_names = sorted(os.listdir(path))\n", + "infer = InferVggSsd(ckpt_dir, gpu=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Wall time: 695 ms\n" + ] + } + ], + "source": [ + "%%time\n", + "classes, scores, boxes = infer.infer_file(os.path.join(path, image_names[-21]), visualize=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "infer.close()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.7" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/notebooks/Deploy Accelerated.ipynb b/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/notebooks/Deploy Accelerated.ipynb new file mode 100644 index 00000000..93313f7a --- /dev/null +++ b/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/notebooks/Deploy Accelerated.ipynb @@ -0,0 +1,633 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Deploy Vgg Ssd Model" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2\n", + "\n", + "import os, sys\n", + "import tensorflow as tf\n", + "\n", + "import warnings\n", + "warnings.filterwarnings('ignore')\n", + "\n", + "sys.path.insert(0, os.path.abspath(\"../tfssd\"))\n", + "from tfutil import endpoints\n", + "from finetune.model_saver import SaverVggSsd" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Restore the AzureML workspace" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "brainwave\n", + "MSRBrainwave\n", + "westus2\n", + "93177b32-3f08-4530-a61e-d1775d2480ad\n" + ] + } + ], + "source": [ + "from azureml.core import Workspace\n", + "\n", + "ws = Workspace.from_config(path=\"./config.json\")\n", + "print(ws.name, ws.resource_group, ws.location, ws.subscription_id, sep = '\\n')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Create Accellerated Container Image" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from azureml.core.model import Model\n", + "from azureml.core.image import Image\n", + "from azureml.accel import AccelOnnxConverter\n", + "from azureml.accel import AccelContainerImage\n", + "\n", + "model_ckpt_dir = r'/datadrive/Dropbox/neal/kroger/azml_ssd_vgg/'\n", + "model_name = r'ssdvgg'\n", + "model_save_path = os.path.join(model_ckpt_dir, model_name)\n", + "\n", + "# model_save_path should NOT exist prior to saving the model\n", + "not os.path.exists(model_save_path)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "WARNING:tensorflow:From /data/anaconda/envs/bw/lib/python3.6/site-packages/tensorflow/python/ops/tensor_array_ops.py:162: colocate_with (from tensorflow.python.framework.ops) is deprecated and will be removed in a future version.\n", + "Instructions for updating:\n", + "Colocations handled automatically by placer.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING - From /data/anaconda/envs/bw/lib/python3.6/site-packages/tensorflow/python/ops/tensor_array_ops.py:162: colocate_with (from tensorflow.python.framework.ops) is deprecated and will be removed in a future version.\n", + "Instructions for updating:\n", + "Colocations handled automatically by placer.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "WARNING:tensorflow:From /data/anaconda/envs/bw/lib/python3.6/site-packages/azureml/accel/models/utils.py:55: to_float (from tensorflow.python.ops.math_ops) is deprecated and will be removed in a future version.\n", + "Instructions for updating:\n", + "Use tf.cast instead.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING - From /data/anaconda/envs/bw/lib/python3.6/site-packages/azureml/accel/models/utils.py:55: to_float (from tensorflow.python.ops.math_ops) is deprecated and will be removed in a future version.\n", + "Instructions for updating:\n", + "Use tf.cast instead.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "WARNING:tensorflow:From /data/anaconda/envs/bw/lib/python3.6/site-packages/tensorflow/python/training/saver.py:1266: checkpoint_exists (from tensorflow.python.training.checkpoint_management) is deprecated and will be removed in a future version.\n", + "Instructions for updating:\n", + "Use standard file APIs to check for files with this prefix.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING - From /data/anaconda/envs/bw/lib/python3.6/site-packages/tensorflow/python/training/saver.py:1266: checkpoint_exists (from tensorflow.python.training.checkpoint_management) is deprecated and will be removed in a future version.\n", + "Instructions for updating:\n", + "Use standard file APIs to check for files with this prefix.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "INFO:tensorflow:Restoring parameters from /datadrive/Dropbox/neal/kroger/azml_ssd_vgg/vggssd/1.1.3/ssd_vgg_bw-18000\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO - Restoring parameters from /datadrive/Dropbox/neal/kroger/azml_ssd_vgg/vggssd/1.1.3/ssd_vgg_bw-18000\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "WARNING:tensorflow:From /data/home/boris/git/neal/Brainwave-Open-Source/tfssd/finetune/model_saver.py:60: simple_save (from tensorflow.python.saved_model.simple_save) is deprecated and will be removed in a future version.\n", + "Instructions for updating:\n", + "This function will only be available through the v1 compatibility library as tf.compat.v1.saved_model.simple_save.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING - From /data/home/boris/git/neal/Brainwave-Open-Source/tfssd/finetune/model_saver.py:60: simple_save (from tensorflow.python.saved_model.simple_save) is deprecated and will be removed in a future version.\n", + "Instructions for updating:\n", + "This function will only be available through the v1 compatibility library as tf.compat.v1.saved_model.simple_save.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "WARNING:tensorflow:From /data/anaconda/envs/bw/lib/python3.6/site-packages/tensorflow/python/saved_model/signature_def_utils_impl.py:205: build_tensor_info (from tensorflow.python.saved_model.utils_impl) is deprecated and will be removed in a future version.\n", + "Instructions for updating:\n", + "This function will only be available through the v1 compatibility library as tf.compat.v1.saved_model.utils.build_tensor_info or tf.compat.v1.saved_model.build_tensor_info.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING - From /data/anaconda/envs/bw/lib/python3.6/site-packages/tensorflow/python/saved_model/signature_def_utils_impl.py:205: build_tensor_info (from tensorflow.python.saved_model.utils_impl) is deprecated and will be removed in a future version.\n", + "Instructions for updating:\n", + "This function will only be available through the v1 compatibility library as tf.compat.v1.saved_model.utils.build_tensor_info or tf.compat.v1.saved_model.build_tensor_info.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "INFO:tensorflow:Assets added to graph.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO - Assets added to graph.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "INFO:tensorflow:No assets to write.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO - No assets to write.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "INFO:tensorflow:SavedModel written to: /datadrive/Dropbox/neal/kroger/azml_ssd_vgg/ssdvgg/saved_model.pb\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO - SavedModel written to: /datadrive/Dropbox/neal/kroger/azml_ssd_vgg/ssdvgg/saved_model.pb\n" + ] + } + ], + "source": [ + "with SaverVggSsd(model_ckpt_dir) as saver:\n", + " saver.save_for_deployment(model_save_path)\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Registering model ssdvgg\n", + "Successfully registered: \tssdvgg\tNone\t8\t\n", + "\n", + "Running..............\n", + "Succeeded\n", + "Operation c0325e8b-db6e-4c55-8467-f95e66756447 completed, operation state \"Succeeded\"\n", + "sas url to download model conversion logs https://brainwave2118624577.blob.core.windows.net/azureml/LocalUpload/e1dfae56cd184146bd84bf7f81b9f310/conversion_log?sv=2018-03-28&sr=b&sig=iSjWt3MJ3po%2FcmmvbMevqr0TmaGVzXLveJMdOECwg1k%3D&st=2019-06-28T22%3A50%3A07Z&se=2019-06-29T07%3A00%3A07Z&sp=r\n", + "[2019-06-28 22:58:57Z]: Starting model conversion process\n", + "[2019-06-28 22:58:57Z]: Downloading model for conversion\n", + "[2019-06-28 22:59:01Z]: Converting model\n", + "[2019-06-28 22:59:04Z]: converter std: 2019-06-28 22:59:04,064 [INFO ] Parsing conversion options\n", + "[2019-06-28 22:59:04Z]: converter std: 2019-06-28 22:59:04,064 [DEBUG] Options: {'toolVersion': '1.0', 'toolName': 'fpga', 'input_node_names': 'Placeholder:0', 'output_node_names': 'ssd_300_vgg/block4_box/Reshape_1:0,ssd_300_vgg/block7_box/Reshape_1:0,ssd_300_vgg/block8_box/Reshape_1:0,ssd_300_vgg/block9_box/Reshape_1:0,ssd_300_vgg/block10_box/Reshape_1:0,ssd_300_vgg/block11_box/Reshape_1:0,ssd_300_vgg/block4_box/Reshape:0,ssd_300_vgg/block7_box/Reshape:0,ssd_300_vgg/block8_box/Reshape:0,ssd_300_vgg/block9_box/Reshape:0,ssd_300_vgg/block10_box/Reshape:0,ssd_300_vgg/block11_box/Reshape:0', 'require_fpga_conversion': 'True', 'sourceModelFlavor': 'tf', 'targetModelFlavor': 'accelonnx', 'unpack': 'true'}\n", + "[2019-06-28 22:59:04Z]: converter std: 2019-06-28 22:59:04,065 [INFO ] Begin splitting graph ...\n", + "[2019-06-28 22:59:04Z]: converter std: 2019-06-28 22:59:04,065 [INFO ] input path => /tmp/4tij54cf.rue/input\n", + "[2019-06-28 22:59:04Z]: converter std: 2019-06-28 22:59:04,065 [INFO ] output path => /tmp/tmpdw6oebvf\n", + "[2019-06-28 22:59:04Z]: converter std: 2019-06-28 22:59:04,065 [INFO ] Splitting requires FPGA only\n", + "[2019-06-28 22:59:04Z]: converter std: 2019-06-28 22:59:04,065 [DEBUG] Descending into /tmp/4tij54cf.rue/input/ssdvgg\n", + "[2019-06-28 22:59:04Z]: converter std: 2019-06-28 22:59:04,066 [INFO ] Found model dir /tmp/4tij54cf.rue/input/ssdvgg\n", + "[2019-06-28 22:59:04Z]: converter std: 2019-06-28 22:59:04,066 [INFO ] Trying to load input directory with SavedModelLoader\n", + "[2019-06-28 22:59:04Z]: converter err: 2019-06-28 22:59:04.083268: I tensorflow/core/platform/cpu_feature_guard.cc:141] Your CPU supports instructions that this TensorFlow binary was not compiled to use: AVX2 FMA\n", + "[2019-06-28 22:59:04Z]: converter std: 2019-06-28 22:59:04,380 [INFO ] Restoring parameters from /tmp/4tij54cf.rue/input/ssdvgg/variables/variables\n", + "[2019-06-28 22:59:04Z]: converter err: /usr/lib/python3/dist-packages/h5py/__init__.py:36: FutureWarning: Conversion of the second argument of issubdtype from `float` to `np.floating` is deprecated. In future, it will be treated as `np.float64 == np.dtype(float).type`.\n", + "[2019-06-28 22:59:04Z]: converter err: from ._conv import register_converters as _register_converters\n", + "[2019-06-28 22:59:04Z]: converter err: INFO:tensorflow:Restoring parameters from /tmp/4tij54cf.rue/input/ssdvgg/variables/variables\n", + "[2019-06-28 22:59:04Z]: converter std: 2019-06-28 22:59:04,589 [INFO ] Attempt splitting into ONNX FPGA Graph\n", + "[2019-06-28 22:59:04Z]: converter std: 2019-06-28 22:59:04,590 [INFO ] Splitting into 3 stage pipeline\n", + "[2019-06-28 22:59:04Z]: converter std: 2019-06-28 22:59:04,591 [INFO ] Found brainwave model of type BrainwaveModel.Ssd_Vgg\n", + "[2019-06-28 22:59:04Z]: converter std: 2019-06-28 22:59:04,621 [INFO ] Adding stage TensorFlow Placeholder:0 --> brainwave_ssd_vgg_1_Version_0.1_input_1\n", + "[2019-06-28 22:59:04Z]: converter std: 2019-06-28 22:59:04,622 [INFO ] Adding stage Brainwave brainwave_ssd_vgg_1_Version_0.1_input_1 --> ssd_300_vgg/conv4/conv4_3/Relu\n", + "[2019-06-28 22:59:04Z]: converter std: 2019-06-28 22:59:04,622 [INFO ] Adding stage TensorFlow ssd_300_vgg/conv4/conv4_3/Relu --> ssd_300_vgg/block4_box/Reshape_1:0,ssd_300_vgg/block7_box/Reshape_1:0,ssd_300_vgg/block8_box/Reshape_1:0,ssd_300_vgg/block9_box/Reshape_1:0,ssd_300_vgg/block10_box/Reshape_1:0,ssd_300_vgg/block11_box/Reshape_1:0,ssd_300_vgg/block4_box/Reshape:0,ssd_300_vgg/block7_box/Reshape:0,ssd_300_vgg/block8_box/Reshape:0,ssd_300_vgg/block9_box/Reshape:0,ssd_300_vgg/block10_box/Reshape:0,ssd_300_vgg/block11_box/Reshape:0\n", + "[2019-06-28 22:59:04Z]: converter err: INFO:tensorflow:Froze 0 variables.\n", + "[2019-06-28 22:59:04Z]: converter std: 2019-06-28 22:59:04,642 [INFO ] Froze 0 variables.\n", + "[2019-06-28 22:59:04Z]: converter err: 2019-06-28 22:59:04.705279: W tensorflow/core/graph/graph_constructor.cc:1265] Importing a graph with a lower producer version 26 into an existing graph with producer version 27. Shape inference will have run different parts of the graph with different producer versions.\n", + "[2019-06-28 22:59:04Z]: converter std: Converted 0 variables to const ops.\n", + "[2019-06-28 22:59:04Z]: converter std: 2019-06-28 22:59:04,847 [INFO ] There are 71 variable names in original BW graph\n", + "[2019-06-28 22:59:04Z]: converter std: 2019-06-28 22:59:04,847 [INFO ] Found 71 matching variables in existing session\n", + "[2019-06-28 22:59:05Z]: converter err: INFO:tensorflow:Restoring parameters from /tmp/tmpdw6oebvf/bw_checkpoints/ssd_vgg\n", + "[2019-06-28 22:59:05Z]: converter std: 2019-06-28 22:59:05,276 [INFO ] Restoring parameters from /tmp/tmpdw6oebvf/bw_checkpoints/ssd_vgg\n", + "[2019-06-28 22:59:05Z]: converter err: INFO:tensorflow:Froze 20 variables.\n", + "[2019-06-28 22:59:05Z]: converter std: 2019-06-28 22:59:05,486 [INFO ] Froze 20 variables.\n", + "[2019-06-28 22:59:05Z]: converter std: Converted 20 variables to const ops.\n", + "[2019-06-28 22:59:05Z]: converter err: INFO:tensorflow:Froze 51 variables.\n", + "[2019-06-28 22:59:05Z]: converter std: 2019-06-28 22:59:05,671 [INFO ] Froze 51 variables.\n", + "[2019-06-28 22:59:05Z]: converter std: Converted 51 variables to const ops.\n", + "[2019-06-28 22:59:05Z]: converter std: 2019-06-28 22:59:05,851 [INFO ] Parse manifest file generated by splitter\n", + "[2019-06-28 22:59:05Z]: converter std: 2019-06-28 22:59:05,852 [INFO ] Processing tensorflow stage\n", + "[2019-06-28 22:59:05Z]: converter std: 2019-06-28 22:59:05,852 [INFO ] Processing brainwave stage\n", + "[2019-06-28 22:59:05Z]: converter std: 2019-06-28 22:59:05,852 [INFO ] Invoking python3 /converter/external/brainwave/tensorflow_params_to_caffe.py -n VGG -c /data/models/ssd_vgg/model.prototxt -t /tmp/tmpdw6oebvf/bw_checkpoints/ssd_vgg -o /tmp/tmpc1hitvmk/model_caffe.out -p ssd_300_vgg\n", + "[2019-06-28 22:59:10Z]: converter std: 2019-06-28 22:59:10,280 [INFO ] Brainwave compiler output:\n", + "[2019-06-28 22:59:10Z]: converter std: [2019-06-28 22:59:08.369659] Execution started.\n", + "[2019-06-28 22:59:10Z]: converter std: 2019-06-28 22:59:08.391148: I tensorflow/core/platform/cpu_feature_guard.cc:141] Your CPU supports instructions that this TensorFlow binary was not compiled to use: AVX2 FMA\n", + "[2019-06-28 22:59:10Z]: converter std: [2019-06-28 22:59:08.397032] Importing tensorflow graph... Done.\n", + "[2019-06-28 22:59:10Z]: converter std: [2019-06-28 22:59:08.669752] Restoring variables... Done.\n", + "[2019-06-28 22:59:10Z]: converter std: [2019-06-28 22:59:08.840631] Converting to Caffe... Done.\n", + "[2019-06-28 22:59:10Z]: converter std: [2019-06-28 22:59:09.844696] Serializing protocol buffer output... Done.\n", + "[2019-06-28 22:59:10Z]: converter std: [2019-06-28 22:59:10.037971] Execution finished. Execution took 1.668296 seconds\n", + "[2019-06-28 22:59:10Z]: converter std: /usr/lib/python3/dist-packages/h5py/__init__.py:36: FutureWarning: Conversion of the second argument of issubdtype from `float` to `np.floating` is deprecated. In future, it will be treated as `np.float64 == np.dtype(float).type`.\n", + "[2019-06-28 22:59:10Z]: converter std: from ._conv import register_converters as _register_converters\n", + "[2019-06-28 22:59:10Z]: converter std: 2019-06-28 22:59:10,281 [INFO ] Invoking python3 /converter/external/brainwave/generate_firmware.py --output_format=code -i /data/models/ssd_vgg/model.prototxt -mp /tmp/tmpc1hitvmk/model_caffe.out -if /tmp/tmpc1hitvmk/subgraph.graphir -o /tmp/tmpc1hitvmk/firmware.c -off --v3_isa --double_buffer_parameters --back_propagate_strides --prefetch_matrices --super_prefetch_MRF --super_prefetch_MRF_lookahead=2 --spatial_pool_interleave=3 --use_genericConvolution --use_expander --min_zeros=226 --ivrf_size=12999 --asvrf1_size=5100 --merge_large_layers --allow_interleaved_output\n", + "[2019-06-28 22:59:33Z]: converter std: 2019-06-28 22:59:33,517 [INFO ] Brainslice firmware generator output:\n", + "[2019-06-28 22:59:33Z]: converter std: error:\n", + "[2019-06-28 22:59:33Z]: converter std: WARNING: Logging before InitGoogleLogging() is written to STDERR\n", + "[2019-06-28 22:59:33Z]: converter std: W0628 22:59:17.475265 416 upgrade_proto.cpp:72] Note that future Caffe releases will only support input layers and not input fields.\n", + "[2019-06-28 22:59:33Z]: converter std: 2019-06-28 22:59:32.348985: I tensorflow/core/platform/cpu_feature_guard.cc:141] Your CPU supports instructions that this TensorFlow binary was not compiled to use: AVX2 FMA\n", + "[2019-06-28 22:59:33Z]: converter std: /converter/external/brainwave/output_printer.py:4200: SyntaxWarning: assertion is always true, perhaps remove parentheses?\n", + "[2019-06-28 22:59:33Z]: converter std: assert(len(sp)==2, \"Shape is expected as 2D\")\n", + "[2019-06-28 22:59:33Z]: converter std: /converter/external/brainwave/output_printer.py:4222: SyntaxWarning: assertion is always true, perhaps remove parentheses?\n", + "[2019-06-28 22:59:33Z]: converter std: assert(len(sp)==1, \"Shape is expected as 1D\")\n", + "[2019-06-28 22:59:33Z]: converter std: /converter/external/brainwave/output_printer.py:4284: SyntaxWarning: assertion is always true, perhaps remove parentheses?\n", + "[2019-06-28 22:59:33Z]: converter std: assert(len(outputVal[1])==1, \"Shape is expected as 1D\")\n", + "[2019-06-28 22:59:33Z]: converter std: /usr/lib/python3/dist-packages/h5py/__init__.py:36: FutureWarning: Conversion of the second argument of issubdtype from `float` to `np.floating` is deprecated. In future, it will be treated as `np.float64 == np.dtype(float).type`.\n", + "[2019-06-28 22:59:33Z]: converter std: from ._conv import register_converters as _register_converters\n", + "[2019-06-28 22:59:33Z]: converter std: 2019-06-28 22:59:33,518 [INFO ] Invoking python3 /converter/external/tf2onnx/tf2onnx/convert.py --input /tmp/tmpdw6oebvf/bw_checkpoints/ssd_vgg.frozen.pb --inputs brainwave_ssd_vgg_1_Version_0.1_input_1:0 --output /tmp/tmpc1hitvmk/ssd_vgg.onnx --outputs ssd_300_vgg/conv4/conv4_3/Relu:0 --continue_on_error --custom-rewriter BrainSlice --rewriter-config /data/models/ssd_vgg/converter.json --weight-path /tmp/tmpc1hitvmk --firmware-path /data/firmware/brainslice-v3-3.0.4/ssd_vgg\n", + "[2019-06-28 22:59:35Z]: converter std: 2019-06-28 22:59:35,679 [INFO ] Onnx converter output:\n", + "[2019-06-28 22:59:35Z]: converter std: 2019-06-28 22:59:35.115539: I tensorflow/tools/graph_transforms/transform_graph.cc:317] Applying fold_batch_norms\n", + "[2019-06-28 22:59:35Z]: converter std: 2019-06-28 22:59:35.143892: I tensorflow/tools/graph_transforms/transform_graph.cc:317] Applying fold_old_batch_norms\n", + "[2019-06-28 22:59:35Z]: converter std: 2019-06-28 22:59:35.248886: I tensorflow/core/platform/cpu_feature_guard.cc:141] Your CPU supports instructions that this TensorFlow binary was not compiled to use: AVX2 FMA\n", + "[2019-06-28 22:59:35Z]: converter std: /usr/lib/python3/dist-packages/h5py/__init__.py:36: FutureWarning: Conversion of the second argument of issubdtype from `float` to `np.floating` is deprecated. In future, it will be treated as `np.float64 == np.dtype(float).type`.\n", + "[2019-06-28 22:59:35Z]: converter std: from ._conv import register_converters as _register_converters\n", + "[2019-06-28 22:59:35Z]: converter std: /usr/lib/python3.6/re.py:212: FutureWarning: split() requires a non-empty pattern match.\n", + "[2019-06-28 22:59:35Z]: converter std: return _compile(pattern, flags).split(string, maxsplit)\n", + "[2019-06-28 22:59:35Z]: converter std: INFO:tf2onnx.optimizer.transpose_optimizer: 0 transpose op(s) left, ops diff after transpose optimization: Counter({'Const': 0, 'Placeholder': 0, 'Pad': 0, 'BrainSlice': 0, 'Relu': 0, 'Identity': 0})\n", + "[2019-06-28 22:59:35Z]: converter std: using tensorflow=1.12.0, onnx=1.3.0, opset=7, tfonnx=0.4.0.fork/6bf11d\n", + "[2019-06-28 22:59:35Z]: converter std: Complete successfully, the onnx model is generated at /tmp/tmpc1hitvmk/ssd_vgg.onnx\n", + "[2019-06-28 22:59:35Z]: converter std: 2019-06-28 22:59:35,679 [INFO ] Moving /tmp/tmpc1hitvmk/ssd_vgg.onnx ==> /tmp/4tij54cf.rue/output/ssd_vgg.onnx\n", + "[2019-06-28 22:59:35Z]: converter std: 2019-06-28 22:59:35,755 [INFO ] Renaming the file /tmp/4tij54cf.rue/output/brainwave.cab ==> /tmp/4tij54cf.rue/output/brainwave.cab\n", + "[2019-06-28 22:59:35Z]: converter std: 2019-06-28 22:59:35,755 [INFO ] Processing tensorflow stage\n", + "[2019-06-28 22:59:35Z]: converter std: 2019-06-28 22:59:35,860 [INFO ] Saving conversion status\n", + "[2019-06-28 22:59:35Z]: converter std: 2019-06-28 22:59:35,860 [INFO ] Conversion completed\n", + "[2019-06-28 22:59:36Z]: Uploading conversion results\n", + "[2019-06-28 22:59:47Z]: Conversion completed with result Success\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Successfully converted: ssdvgg.8.accelonnx aml://asset/73aa8bf040694c34b2c40d0d9b602f9c 1 ssdvgg.8.accelonnx:1 2019-06-28 23:00:06.480438+00:00 \n", + "\n" + ] + } + ], + "source": [ + "registered_model = Model.register(workspace = ws,\n", + " model_path = model_save_path,\n", + " model_name = model_name)\n", + "print(\"Successfully registered: \", registered_model.name, registered_model.description, registered_model.version, '\\n', sep = '\\t')\n", + "\n", + "input_tensor = saver.input_name_str\n", + "output_tensors_str = \",\".join(saver.output_names)\n", + "\n", + "# Convert model\n", + "convert_request = AccelOnnxConverter.convert_tf_model(ws, registered_model, input_tensor, output_tensors_str)\n", + "# If it fails, you can run wait_for_completion again with show_output=True.\n", + "convert_request.wait_for_completion(show_output=True)\n", + "converted_model = convert_request.result\n", + "print(\"\\nSuccessfully converted: \", converted_model.name, converted_model.url, converted_model.version, \n", + " converted_model.id, converted_model.created_time, '\\n')" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Creating image\n", + "Running..............\n", + "Succeeded\n", + "Image creation operation finished for image ssdvgg-image:3, operation \"Succeeded\"\n", + "Created AccelContainerImage: ssdvgg-image Succeeded brainwave56a8d7eb.azurecr.io/ssdvgg-image:3\n", + "\n" + ] + } + ], + "source": [ + "# Package into AccelContainerImage\n", + "image_config = AccelContainerImage.image_configuration()\n", + "# Image name must be lowercase\n", + "image_name = \"{}-image\".format(model_name)\n", + "image = Image.create(name = image_name,\n", + " models = [converted_model],\n", + " image_config = image_config, \n", + " workspace = ws)\n", + "image.wait_for_creation(show_output=True)\n", + "print(\"Created AccelContainerImage: {} {} {}\\n\".format(image.name, image.creation_state, image.image_location))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Deploy to AKS Cluster" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "from azureml.core.compute import AksCompute, ComputeTarget\n", + "\n", + "# Uses the specific FPGA enabled VM (sku: Standard_PB6s)\n", + "# Standard_PB6s are available in: eastus, westus2, westeurope, southeastasia\n", + "prov_config = AksCompute.provisioning_configuration(vm_size = \"Standard_PB6s\",\n", + " agent_count = 1, \n", + " location = \"westus2\")\n", + "\n", + "aks_name = 'aks-pb6-obj2'\n", + "# Create the cluster\n", + "aks_target = ComputeTarget.create(workspace = ws, \n", + " name = aks_name, \n", + " provisioning_configuration = prov_config)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Creating....................................................................................................................................................................................................\n", + "SucceededProvisioning operation finished, operation \"Succeeded\"\n", + "Succeeded\n", + "None\n" + ] + } + ], + "source": [ + "aks_target.wait_for_completion(show_output=True)\n", + "print(aks_target.provisioning_state)\n", + "print(aks_target.provisioning_errors)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Deploy AccelContainerImage to AKS ComputeTarget" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Creating service\n", + "Running................................\n", + "SucceededAKS service creation operation finished, operation \"Succeeded\"\n" + ] + } + ], + "source": [ + "from azureml.core.webservice import Webservice, AksWebservice\n", + "\n", + "# Set the web service configuration (for creating a test service, we don't want autoscale enabled)\n", + "# Authentication is enabled by default, but for testing we specify False\n", + "aks_config = AksWebservice.deploy_configuration(autoscale_enabled=False,\n", + " num_replicas=1,\n", + " auth_enabled = False)\n", + "\n", + "aks_service_name ='my-aks-service'\n", + "\n", + "aks_service = Webservice.deploy_from_image(workspace = ws,\n", + " name = aks_service_name,\n", + " image = image,\n", + " deployment_config = aks_config,\n", + " deployment_target = aks_target)\n", + "aks_service.wait_for_deployment(show_output = True)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "# Using the grpc client in AzureML Accelerated Models SDK\n", + "from azureml.accel import PredictionClient" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "address=52.247.236.16, port=80, ssl=False, name=my-aks-service\n" + ] + } + ], + "source": [ + "address = aks_service.scoring_uri\n", + "ssl_enabled = address.startswith(\"https\")\n", + "address = address[address.find('/')+2:].strip('/')\n", + "port = 443 if ssl_enabled else 80\n", + "print(f\"address={address}, port={port}, ssl={ssl_enabled}, name={aks_service.name}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "# Initialize AzureML Accelerated Models client\n", + "client = PredictionClient(address=address,\n", + " port=port,\n", + " use_ssl=ssl_enabled,\n", + " service_name=aks_service.name)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "from tfutil import visualization\n", + "output_tensors = saver.output_names" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import glob\n", + "\n", + "image_dir = r'/datadrive/Dropbox/neal/data/kroger/dataset/test/JPEGImages/'\n", + "im_files = glob.glob(os.path.join(image_dir, '*.jpg'))\n", + "im_file = im_files[-21]\n", + "\n", + "import azureml.accel._external.ssdvgg_utils as ssdvgg_utils\n", + "\n", + "result = client.score_file(path=im_file, input_name=saver.input_name_str, outputs=output_tensors)\n", + "classes, scores, bboxes = ssdvgg_utils.postprocess(result, select_threshold=0.5)\n", + "\n", + "plt.rcParams['figure.figsize'] = 15, 15\n", + "img = cv2.imread(im_file)\n", + "img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)\n", + "visualization.plt_bboxes(img, classes, scores, bboxes)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": false + }, + "outputs": [], + "source": [ + "result" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.7" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/notebooks/Finetune VGG SSD.ipynb b/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/notebooks/Finetune VGG SSD.ipynb new file mode 100644 index 00000000..075b4ce9 --- /dev/null +++ b/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/notebooks/Finetune VGG SSD.ipynb @@ -0,0 +1,423 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Finetuning VGG-SSD Object Detection Model" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Prerequisits for Local Training\n", + "\n", + "* CUDA 10.0, cuDNN 7.4\n", + "* Recent Anaconda environment\n", + "* Tensorflow 1.12+" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# install supported FPGA ML models, including VGG SSD\n", + "# skip if already installed\n", + "!pip install azureml-accel-models\n", + "!pip install -U --ignore-installed tensorflow-gpu==1.13.1" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2\n", + "import os, sys, glob\n", + "import tensorflow as tf\n", + "\n", + "# Tensorflow Finetuning Package\n", + "sys.path.insert(0, os.path.abspath('../tfssd/'))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Import Training / Validation Data\n", + "\n", + "Images are .jpg files and annotations - .xml files in PASCAL VOC format.\n", + "Each image file has a matching annotations file\n", + "\n", + "In this notebook we are looking for gaps on the shelves stocked with different products:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import cv2\n", + "plt.rcParams['figure.figsize'] = 10, 10\n", + "img = cv2.imread('sample.jpg')\n", + "\n", + "img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)\n", + "plt.imshow(img)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "779 images found and 779 matching annotations found.\n" + ] + } + ], + "source": [ + "from dataprep import dataset_utils, pascalvoc_to_tfrecords\n", + "\n", + "data_dir = r'x:\\data\\grocery\\source'\n", + "data_dir_images = os.path.join(data_dir, \"JPEGImages\")\n", + "data_dir_annotations = os.path.join(data_dir, \"Annotations\")\n", + "classes = [\"stockout\"]\n", + "\n", + "images = glob.glob(os.path.join(data_dir_images, \"*.jpg\"))\n", + "annotations = glob.glob(os.path.join(data_dir_annotations, \"*.xml\"))\n", + "\n", + "# check for image and annotations files matching each other\n", + "images, annotations = dataset_utils.check_labelmatch(images, annotations)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Split Into Training and Validation and Create TFRecord Datasets" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + ">> Converting image 1/623WARNING:tensorflow:From C:\\git\\neal\\AzureFork\\MachineLearningNotebooks\\how-to-use-azureml\\deployment\\accelerated-models\\finetune-ssd-vgg\\tfssd\\dataprep\\pascalvoc_to_tfrecords.py:78: FastGFile.__init__ (from tensorflow.python.platform.gfile) is deprecated and will be removed in a future version.\n", + "Instructions for updating:\n", + "Use tf.gfile.GFile.\n", + ">> Converting image 623/623\n", + "Finished converting the Pascal VOC dataset!\n", + ">> Converting image 156/156\n", + "Finished converting the Pascal VOC dataset!\n", + "['test_0000.tfrecord', 'test_0001.tfrecord', 'train_0000.tfrecord', 'train_0001.tfrecord', 'train_0002.tfrecord', 'train_0003.tfrecord', 'train_0004.tfrecord', 'train_0005.tfrecord', 'train_0006.tfrecord']\n" + ] + } + ], + "source": [ + "from sklearn.model_selection import train_test_split\n", + "\n", + "train_images, test_images, \\\n", + " train_annotations, test_annotations = train_test_split(images, annotations, test_size = .2, random_state = 40)\n", + "\n", + "data_output_dir = os.path.join(data_dir, \"../tfrec\")\n", + "\n", + "pascalvoc_to_tfrecords.run(data_output_dir, classes, train_images, train_annotations, \"train\")\n", + "pascalvoc_to_tfrecords.run(data_output_dir, classes, test_images, test_annotations, \"test\")\n", + "\n", + "print(os.listdir(data_output_dir))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Setup and Run Training/Validation Loops" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Setup Training Data, Import the Model" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "from finetune.train import TrainVggSsd\n", + "from finetune.eval import EvalVggSsd\n", + "\n", + "root_dir = r'x:\\grocery\\azml_ssd_vgg'\n", + "# this is the directory where the original model to be\n", + "# fine-tuned will be delivered and models saved as the training loop runs\n", + "ckpt_dir = root_dir\n", + "\n", + "# get .tfrecord files created in the previous step\n", + "train_files = glob.glob(os.path.join(data_output_dir, \"train_*.tfrecord\"))\n", + "validation_files = glob.glob(os.path.join(data_output_dir, \"test_*.tfrecord\"))\n", + "\n", + "# run for these epochs\n", + "n_epochs = 6" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Training Parameters" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# steps per training epoch\n", + "num_train_steps=3000\n", + "# batch size. \n", + "batch_size = 2\n", + "# steps to save as a checkpoint\n", + "steps_to_save=3000\n", + "# using Adam optimizer. These are the configurable parameters\n", + "learning_rate = 1e-4\n", + "learning_rate_decay_steps=3000\n", + "learning_rate_decay_value=0.96" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Validation Parameters" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "num_eval_steps=156\n", + "# number of classes. Includes the \"none\" (background) class\n", + "# cannot be more than 21\n", + "num_classes=2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Run Training Loop" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "WARNING:tensorflow:From C:\\git\\neal\\AzureFork\\MachineLearningNotebooks\\how-to-use-azureml\\deployment\\accelerated-models\\finetune-ssd-vgg\\tfssd\\datautil\\ssd_vgg_preprocessing.py:213: sample_distorted_bounding_box (from tensorflow.python.ops.image_ops_impl) is deprecated and will be removed in a future version.\n", + "Instructions for updating:\n", + "`seed2` arg is deprecated.Use sample_distorted_bounding_box_v2 instead.\n", + "WARNING:tensorflow:From C:\\Anaconda3\\envs\\brain\\lib\\site-packages\\tensorflow\\python\\ops\\control_flow_ops.py:423: colocate_with (from tensorflow.python.framework.ops) is deprecated and will be removed in a future version.\n", + "Instructions for updating:\n", + "Colocations handled automatically by placer.\n", + "WARNING:tensorflow:From C:\\Anaconda3\\envs\\brain\\lib\\site-packages\\tensorflow\\python\\util\\tf_should_use.py:193: initialize_variables (from tensorflow.python.ops.variables) is deprecated and will be removed after 2017-03-02.\n", + "Instructions for updating:\n", + "Use `tf.variables_initializer` instead.\n", + "WARNING:tensorflow:From C:\\Anaconda3\\envs\\brain\\lib\\site-packages\\tensorflow\\python\\training\\saver.py:1266: checkpoint_exists (from tensorflow.python.training.checkpoint_management) is deprecated and will be removed in a future version.\n", + "Instructions for updating:\n", + "Use standard file APIs to check for files with this prefix.\n", + "INFO:tensorflow:Restoring parameters from x:\\grocery\\azml_ssd_vgg\\vggssd\\1.1.3\\ssd_vgg_bw\n", + "INFO:tensorflow:Starting training for 3000 steps\n", + "3000: loss: 44.949, avg per step: 0.048 secc\n", + "\n", + "INFO:tensorflow:Restoring parameters from x:\\grocery\\azml_ssd_vgg\\vggssd\\1.1.3\\ssd_vgg_bw-3000\n", + "INFO:tensorflow:Starting evaluation for 156 steps\n", + "Evaluation step: 156\n", + "mAP: 0.8393\n", + "INFO:tensorflow:Restoring parameters from x:\\grocery\\azml_ssd_vgg\\vggssd\\1.1.3\\ssd_vgg_bw-3000\n", + "INFO:tensorflow:Starting training for 3000 steps\n", + "6000: loss: 16.735, avg per step: 0.054 secc\n", + "\n", + "INFO:tensorflow:Restoring parameters from x:\\grocery\\azml_ssd_vgg\\vggssd\\1.1.3\\ssd_vgg_bw-6000\n", + "INFO:tensorflow:Starting evaluation for 156 steps\n", + "Evaluation step: 156\n", + "mAP: 0.8477\n", + "INFO:tensorflow:Restoring parameters from x:\\grocery\\azml_ssd_vgg\\vggssd\\1.1.3\\ssd_vgg_bw-6000\n", + "INFO:tensorflow:Starting training for 3000 steps\n", + "9000: loss: 17.331, avg per step: 0.048 secc\n", + "\n", + "INFO:tensorflow:Restoring parameters from x:\\grocery\\azml_ssd_vgg\\vggssd\\1.1.3\\ssd_vgg_bw-9000\n", + "INFO:tensorflow:Starting evaluation for 156 steps\n", + "Evaluation step: 156\n", + "mAP: 0.8689\n", + "INFO:tensorflow:Restoring parameters from x:\\grocery\\azml_ssd_vgg\\vggssd\\1.1.3\\ssd_vgg_bw-9000\n", + "INFO:tensorflow:Starting training for 3000 steps\n", + "12000: loss: 28.185, avg per step: 0.048 secc\n", + "\n", + "INFO:tensorflow:Restoring parameters from x:\\grocery\\azml_ssd_vgg\\vggssd\\1.1.3\\ssd_vgg_bw-12000\n", + "INFO:tensorflow:Starting evaluation for 156 steps\n", + "Evaluation step: 156\n", + "mAP: 0.8711\n", + "INFO:tensorflow:Restoring parameters from x:\\grocery\\azml_ssd_vgg\\vggssd\\1.1.3\\ssd_vgg_bw-12000\n", + "INFO:tensorflow:Starting training for 3000 steps\n", + "15000: loss: 38.361, avg per step: 0.051 secc\n", + "\n", + "INFO:tensorflow:Restoring parameters from x:\\grocery\\azml_ssd_vgg\\vggssd\\1.1.3\\ssd_vgg_bw-15000\n", + "INFO:tensorflow:Starting evaluation for 156 steps\n", + "Evaluation step: 156\n", + "mAP: 0.8753\n", + "INFO:tensorflow:Restoring parameters from x:\\grocery\\azml_ssd_vgg\\vggssd\\1.1.3\\ssd_vgg_bw-15000\n", + "INFO:tensorflow:Starting training for 3000 steps\n", + "18000: loss: 43.066, avg per step: 0.051 secc\n", + "\n", + "INFO:tensorflow:Restoring parameters from x:\\grocery\\azml_ssd_vgg\\vggssd\\1.1.3\\ssd_vgg_bw-18000\n", + "INFO:tensorflow:Starting evaluation for 156 steps\n", + "Evaluation step: 156\n", + "mAP: 0.8769\n" + ] + } + ], + "source": [ + "for _ in range(n_epochs):\n", + "\n", + " with TrainVggSsd(ckpt_dir, train_files, \n", + " num_steps=num_train_steps, \n", + " steps_to_save=steps_to_save, \n", + " batch_size = batch_size,\n", + " learning_rate=learning_rate,\n", + " learning_rate_decay_steps=learning_rate_decay_steps, \n", + " learning_rate_decay_value=learning_rate_decay_value) as trainer:\n", + " trainer.train()\n", + "\n", + " with EvalVggSsd(ckpt_dir, validation_files, \n", + " num_steps=num_eval_steps, \n", + " num_classes=num_classes) as evaluator:\n", + " evaluator.eval() " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Visualize Training Results" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "INFO:tensorflow:Restoring parameters from x:\\grocery\\azml_ssd_vgg\\vggssd\\1.1.3\\ssd_vgg_bw-18000\n" + ] + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "from finetune.inference import InferVggSsd\n", + "\n", + "plt.rcParams[\"figure.figsize\"] = 15, 15\n", + "path = 'X:/data/grocery/dataset/test/JPEGImages'\n", + "image_names = sorted(os.listdir(path))\n", + "infer = InferVggSsd(ckpt_dir, gpu=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Wall time: 695 ms\n" + ] + } + ], + "source": [ + "%%time\n", + "classes, scores, boxes = infer.infer_file(os.path.join(path, image_names[-21]), visualize=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "infer.close()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.7" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/notebooks/config.json b/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/notebooks/config.json new file mode 100644 index 00000000..01a6b095 --- /dev/null +++ b/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/notebooks/config.json @@ -0,0 +1,5 @@ +{ + "subscription_id": "93177b32-3f08-4530-a61e-d1775d2480ad", + "resource_group": "MSRBrainwave", + "workspace_name": "brainwave" +} \ No newline at end of file diff --git a/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/notebooks/sample.jpg b/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/notebooks/sample.jpg new file mode 100644 index 0000000000000000000000000000000000000000..9d0ab04daef7fc0c649b61d190257ebac44764b0 GIT binary patch literal 84889 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 z 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

?1`<=>*wbi}tr@2SnoMJ@AmXG4(@g-<;(#MG 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 PuXe}n2b1~HKp+3v*l?_? literal 0 HcmV?d00001 diff --git a/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/notebooks/sample.xml b/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/notebooks/sample.xml new file mode 100644 index 00000000..319a36d4 --- /dev/null +++ b/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/notebooks/sample.xml @@ -0,0 +1,26 @@ + + runeightft1 + 1555394321.8154433.jpg + E:/Image grocerydemostills/runeightft1/1555394321.8154433.jpg + + Unknown + + + 852 + 506 + 3 + + 0 + + stockout + Unspecified + 0 + 0 + + 660 + 201 + 712 + 294 + + + diff --git a/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/__init__.py b/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/anchors/.__init__.py b/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/anchors/.__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/anchors/generate_anchors.py b/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/anchors/generate_anchors.py new file mode 100644 index 00000000..740fb3c5 --- /dev/null +++ b/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/anchors/generate_anchors.py @@ -0,0 +1,92 @@ +import numpy as np +import math +from model.ssd_vgg_300 import SSDNet, SSDParams + +_R_MEAN = 123. +_G_MEAN = 117. +_B_MEAN = 104. +EVAL_SIZE = (300, 300) + +defaults = SSDNet.default_params + +img_shape = defaults.img_shape +num_classes = defaults.num_classes +feat_layers = defaults.feat_layers +feat_shapes = defaults.feat_shapes +anchor_size_bounds = defaults.anchor_size_bounds +anchor_sizes = defaults.anchor_sizes +anchor_ratios = defaults.anchor_ratios +anchor_steps = defaults.anchor_steps +anchor_offset = defaults.anchor_offset +normalizations = defaults.normalizations +prior_scaling = defaults.prior_scaling + +def ssd_anchor_one_layer(img_shape, + feat_shape, + sizes, + ratios, + step, + offset=0.5, + dtype=np.float32): + """Computer SSD default anchor boxes for one feature layer. + + Determine the relative position grid of the centers, and the relative + width and height. + + Arguments: + feat_shape: Feature shape, used for computing relative position grids; + size: Absolute reference sizes; + ratios: Ratios to use on these features; + img_shape: Image shape, used for computing height, width relatively to the + former; + offset: Grid offset. + + Return: + y, x, h, w: Relative x and y grids, and height and width. + """ + # Compute the position grid: simple way. + # y, x = np.mgrid[0:feat_shape[0], 0:feat_shape[1]] + # y = (y.astype(dtype) + offset) / feat_shape[0] + # x = (x.astype(dtype) + offset) / feat_shape[1] + # Weird SSD-Caffe computation using steps values... + y, x = np.mgrid[0:feat_shape[0], 0:feat_shape[1]] + y = (y.astype(dtype) + offset) * step / img_shape[0] + x = (x.astype(dtype) + offset) * step / img_shape[1] + + # Expand dims to support easy broadcasting. + y = np.expand_dims(y, axis=-1) + x = np.expand_dims(x, axis=-1) + + # Compute relative height and width. + # Tries to follow the original implementation of SSD for the order. + num_anchors = len(sizes) + len(ratios) + h = np.zeros((num_anchors, ), dtype=dtype) + w = np.zeros((num_anchors, ), dtype=dtype) + # Add first anchor boxes with ratio=1. + h[0] = sizes[0] / img_shape[0] + w[0] = sizes[0] / img_shape[1] + di = 1 + if len(sizes) > 1: + h[1] = math.sqrt(sizes[0] * sizes[1]) / img_shape[0] + w[1] = math.sqrt(sizes[0] * sizes[1]) / img_shape[1] + di += 1 + for i, r in enumerate(ratios): + h[i+di] = sizes[0] / img_shape[0] / math.sqrt(r) + w[i+di] = sizes[0] / img_shape[1] * math.sqrt(r) + return y, x, h, w + + +def ssd_anchors_all_layers(img_shape = img_shape, + offset=0.5, + dtype=np.float32): + """Compute anchor boxes for all feature layers. + """ + layers_anchors = [] + for i, s in enumerate(feat_shapes): + anchor_bboxes = ssd_anchor_one_layer(img_shape, s, + anchor_sizes[i], + anchor_ratios[i], + anchor_steps[i], + offset=offset, dtype=dtype) + layers_anchors.append(anchor_bboxes) + return layers_anchors diff --git a/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/dataprep/dataset_utils.py b/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/dataprep/dataset_utils.py new file mode 100644 index 00000000..5d1cee2b --- /dev/null +++ b/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/dataprep/dataset_utils.py @@ -0,0 +1,114 @@ +import os +import sys +import tarfile + +from six.moves import urllib +import tensorflow as tf + +LABELS_FILENAME = 'labels.txt' + +import shutil +from os import path + +def check_labelmatch(images, annotations): + data_dir_images = os.path.split(images[0])[0] + data_dir_annot = os.path.split(annotations[0])[0] + + im_files = {os.path.splitext(os.path.split(f)[1])[0] for f in images} + annot_files = {os.path.splitext(os.path.split(f)[1])[0] for f in annotations} + + extra_ims = im_files.difference(annot_files) + extra_annots = annot_files.difference(im_files) + mismatch = len(extra_ims) > 0 or len(extra_annots) > 0 + + if mismatch: + print(f"The following files will be removed from the training process:") + + if len(extra_ims) > 0: + print(f"images without annotations: {extra_ims}") + + if len(extra_annots) > 0: + print(f"annotations without images: {extra_annots}") + + if not mismatch: + print(str(len(images)) + ' images found and ' + str(len(annotations)) + ' matching annotations found.' ) + return (images, annotations) + + im_files = im_files.difference(extra_ims) + annot_files = annot_files.difference(extra_annots) + + im_files = [os.path.join(data_dir_images, f+".jpg") for f in im_files] + annot_files = [os.path.join(data_dir_annot, f+".xml") for f in annot_files] + + return(im_files, annot_files) + +def create_dir(path): + try: + path_annotations = path + '/Annotations' + path_images = path + '/JPEGImages' + + os.makedirs(path_annotations) + os.makedirs(path_images) + + except OSError: + print("Creation of folders in directory %s failed. Folder may already exist." % path) + else: + print("Successfully created images and annotations folders at %s" % path) + +def move_images(data_dir, train_images, train_annotations, + test_images, test_annotations): + + source = data_dir + '/' + + for image in train_images: + image = data_dir + '/' + image + dst = source + 'train/' + '/JPEGImages' + + if path.exists(image): + shutil.copy(image, dst) + + for image in test_images: + image = data_dir + '/' + image + dst = source + 'test/' + '/JPEGImages' + + if path.exists(image): + shutil.copy(image, dst) + + for annot in train_annotations: + annot = data_dir + '/' + annot + dst = source + 'train/' + '/Annotations' + + if path.exists(annot): + shutil.copy(annot, dst) + + for annot in test_annotations: + annot = data_dir + '/' + annot + dst = source + 'test/' + '/Annotations' + + if path.exists(annot): + shutil.copy(annot, dst) + + print('Images and annotations have been copied to directories: ' + source + 'train' + ' and ' + source + 'test') + +def int64_feature(value): + """Wrapper for inserting int64 features into Example proto. + """ + if not isinstance(value, list): + value = [value] + return tf.train.Feature(int64_list=tf.train.Int64List(value=value)) + + +def float_feature(value): + """Wrapper for inserting float features into Example proto. + """ + if not isinstance(value, list): + value = [value] + return tf.train.Feature(float_list=tf.train.FloatList(value=value)) + + +def bytes_feature(value): + """Wrapper for inserting bytes features into Example proto. + """ + if not isinstance(value, list): + value = [value] + return tf.train.Feature(bytes_list=tf.train.BytesList(value=value)) \ No newline at end of file diff --git a/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/dataprep/pascalvoc_common.py b/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/dataprep/pascalvoc_common.py new file mode 100644 index 00000000..61bca57d --- /dev/null +++ b/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/dataprep/pascalvoc_common.py @@ -0,0 +1,112 @@ +# Copyright 2015 Paul Balanca. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ============================================================================== +"""Provides data for the Pascal VOC Dataset (images + annotations). +""" +import os + +import tensorflow as tf +from dataprep import dataset_utils + +slim = tf.contrib.slim + +VOC_LABELS = { + 'none': (0, 'Background'), + 'aeroplane': (1, 'Vehicle'), + 'bicycle': (2, 'Vehicle'), + 'bird': (3, 'Animal'), + 'boat': (4, 'Vehicle'), + 'bottle': (5, 'Indoor'), + 'bus': (6, 'Vehicle'), + 'car': (7, 'Vehicle'), + 'cat': (8, 'Animal'), + 'chair': (9, 'Indoor'), + 'cow': (10, 'Animal'), + 'diningtable': (11, 'Indoor'), + 'dog': (12, 'Animal'), + 'horse': (13, 'Animal'), + 'motorbike': (14, 'Vehicle'), + 'person': (15, 'Person'), + 'pottedplant': (16, 'Indoor'), + 'sheep': (17, 'Animal'), + 'sofa': (18, 'Indoor'), + 'train': (19, 'Vehicle'), + 'tvmonitor': (20, 'Indoor'), +} + +def get_split(split_name, dataset_dir, file_pattern, reader, + split_to_sizes, items_to_descriptions, num_classes): + """Gets a dataset tuple with instructions for reading Pascal VOC dataset. + + Args: + split_name: A train/test split name. + dataset_dir: The base directory of the dataset sources. + file_pattern: The file pattern to use when matching the dataset sources. + It is assumed that the pattern contains a '%s' string so that the split + name can be inserted. + reader: The TensorFlow reader type. + + Returns: + A `Dataset` namedtuple. + + Raises: + ValueError: if `split_name` is not a valid train/test split. + """ + if split_name not in split_to_sizes: + raise ValueError('split name %s was not recognized.' % split_name) + file_pattern = os.path.join(dataset_dir, file_pattern % split_name) + + # Allowing None in the signature so that dataset_factory can use the default. + if reader is None: + reader = tf.TFRecordReader + # Features in Pascal VOC TFRecords. + keys_to_features = { + 'image/encoded': tf.FixedLenFeature((), tf.string, default_value=''), + 'image/format': tf.FixedLenFeature((), tf.string, default_value='jpeg'), + 'image/height': tf.FixedLenFeature([1], tf.int64), + 'image/width': tf.FixedLenFeature([1], tf.int64), + 'image/channels': tf.FixedLenFeature([1], tf.int64), + 'image/shape': tf.FixedLenFeature([3], tf.int64), + 'image/object/bbox/xmin': tf.VarLenFeature(dtype=tf.float32), + 'image/object/bbox/ymin': tf.VarLenFeature(dtype=tf.float32), + 'image/object/bbox/xmax': tf.VarLenFeature(dtype=tf.float32), + 'image/object/bbox/ymax': tf.VarLenFeature(dtype=tf.float32), + 'image/object/bbox/label': tf.VarLenFeature(dtype=tf.int64), + 'image/object/bbox/difficult': tf.VarLenFeature(dtype=tf.int64), + 'image/object/bbox/truncated': tf.VarLenFeature(dtype=tf.int64), + } + items_to_handlers = { + 'image': slim.tfexample_decoder.Image('image/encoded', 'image/format'), + 'shape': slim.tfexample_decoder.Tensor('image/shape'), + 'object/bbox': slim.tfexample_decoder.BoundingBox( + ['ymin', 'xmin', 'ymax', 'xmax'], 'image/object/bbox/'), + 'object/label': slim.tfexample_decoder.Tensor('image/object/bbox/label'), + 'object/difficult': slim.tfexample_decoder.Tensor('image/object/bbox/difficult'), + 'object/truncated': slim.tfexample_decoder.Tensor('image/object/bbox/truncated'), + } + decoder = slim.tfexample_decoder.TFExampleDecoder( + keys_to_features, items_to_handlers) + + labels_to_names = None + if dataset_utils.has_labels(dataset_dir): + labels_to_names = dataset_utils.read_label_file(dataset_dir) + + return slim.dataset.Dataset( + data_sources=file_pattern, + reader=reader, + decoder=decoder, + num_samples=split_to_sizes[split_name], + items_to_descriptions=items_to_descriptions, + num_classes=num_classes, + labels_to_names=labels_to_names) diff --git a/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/dataprep/pascalvoc_to_tfrecords.py b/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/dataprep/pascalvoc_to_tfrecords.py new file mode 100644 index 00000000..52112c97 --- /dev/null +++ b/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/dataprep/pascalvoc_to_tfrecords.py @@ -0,0 +1,223 @@ +# Copyright 2015 Paul Balanca. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ============================================================================== +"""Converts Pascal VOC data to TFRecords file format with Example protos. + +The raw Pascal VOC data set is expected to reside in JPEG files located in the +directory 'JPEGImages'. Similarly, bounding box annotations are supposed to be +stored in the 'Annotation directory' + +This TensorFlow script converts the training and evaluation data into +a sharded data set consisting of 1024 and 128 TFRecord files, respectively. + +Each validation TFRecord file contains ~500 records. Each training TFREcord +file contains ~1000 records. Each record within the TFRecord file is a +serialized Example proto. The Example proto contains the following fields: + + image/encoded: string containing JPEG encoded image in RGB colorspace + image/height: integer, image height in pixels + image/width: integer, image width in pixels + image/channels: integer, specifying the number of channels, always 3 + image/format: string, specifying the format, always'JPEG' + + + image/object/bbox/xmin: list of float specifying the 0+ human annotated + bounding boxes + image/object/bbox/xmax: list of float specifying the 0+ human annotated + bounding boxes + image/object/bbox/ymin: list of float specifying the 0+ human annotated + bounding boxes + image/object/bbox/ymax: list of float specifying the 0+ human annotated + bounding boxes + image/object/bbox/label: list of integer specifying the classification index. + image/object/bbox/label_text: list of string descriptions. + +Note that the length of xmin is identical to the length of xmax, ymin and ymax +for each example. +""" +import os +import sys +import random + +import numpy as np +import tensorflow as tf + +import xml.etree.ElementTree as ET + +from dataprep.dataset_utils import int64_feature, float_feature, bytes_feature + +# TFRecords conversion parameters. +RANDOM_SEED = 4242 +SAMPLES_PER_FILES = 100 + +def _set_voc_labels_map(class_list): + return dict(**{'none': 0}, **{cl: i + 1 for i, cl in enumerate(class_list)}) + +def _process_image(img_name, annot_name, class_list): + """Process a image and annotation file. + + Args: + img_name: string, path to an image file e.g., '/path/to/example.JPG'. + Returns: + image_buffer: string, JPEG encoding of RGB image. + height: integer, image height in pixels. + width: integer, image width in pixels. + """ + # Read the image file. + image_data = tf.gfile.FastGFile(img_name, 'rb').read() + class_dict = _set_voc_labels_map(class_list) + + # Read the XML annotation file. + filename = annot_name + tree = ET.parse(filename) + root = tree.getroot() + + # Image shape. + size = root.find('size') + shape = [int(size.find('height').text), + int(size.find('width').text), + int(size.find('depth').text)] + # Find annotations. + bboxes = [] + labels = [] + labels_text = [] + difficult = [] + truncated = [] + for obj in root.findall('object'): + label = obj.find('name').text + labels.append(class_dict[label]) + labels_text.append(label.encode('ascii')) + + if obj.find('difficult'): + difficult.append(int(obj.find('difficult').text)) + else: + difficult.append(0) + if obj.find('truncated'): + truncated.append(int(obj.find('truncated').text)) + else: + truncated.append(0) + + bbox = obj.find('bndbox') + bboxes.append((to_valid_range(float(bbox.find('ymin').text) / shape[0]), + to_valid_range(float(bbox.find('xmin').text) / shape[1]), + to_valid_range(float(bbox.find('ymax').text) / shape[0]), + to_valid_range(float(bbox.find('xmax').text) / shape[1]) + )) + return image_data, shape, np.clip(bboxes, a_min=0., a_max=1.), labels, labels_text, difficult, truncated + +def to_valid_range(v): + if v < 0.0: + return 0.0 + if v > 1.0: + return 1.0 + return v + + +def _convert_to_example(image_data, labels, labels_text, bboxes, shape, + difficult, truncated): + """Build an Example proto for an image example. + + Args: + image_data: string, JPEG encoding of RGB image; + labels: list of integers, identifier for the ground truth; + labels_text: list of strings, human-readable labels; + bboxes: list of bounding boxes; each box is a list of integers; + specifying [xmin, ymin, xmax, ymax]. All boxes are assumed to belong + to the same label as the image label. + shape: 3 integers, image shapes in pixels. + Returns: + Example proto + """ + xmin = [] + ymin = [] + xmax = [] + ymax = [] + for b in bboxes: + assert len(b) == 4 + # pylint: disable=expression-not-assigned + [l.append(point) for l, point in zip([ymin, xmin, ymax, xmax], b)] + # pylint: enable=expression-not-assigned + + image_format = b'JPEG' + example = tf.train.Example(features=tf.train.Features(feature={ + 'image/height': int64_feature(shape[0]), + 'image/width': int64_feature(shape[1]), + 'image/channels': int64_feature(shape[2]), + 'image/shape': int64_feature(shape), + 'image/object/bbox/xmin': float_feature(xmin), + 'image/object/bbox/xmax': float_feature(xmax), + 'image/object/bbox/ymin': float_feature(ymin), + 'image/object/bbox/ymax': float_feature(ymax), + 'image/object/bbox/label': int64_feature(labels), + 'image/object/bbox/label_text': bytes_feature(labels_text), + 'image/object/bbox/difficult': int64_feature(difficult), + 'image/object/bbox/truncated': int64_feature(truncated), + 'image/format': bytes_feature(image_format), + 'image/encoded': bytes_feature(image_data)})) + return example + + +def _add_to_tfrecord(img_name, annot_name, class_list, tfrecord_writer): + """Loads data from image and annotations files and add them to a TFRecord. + + Args: + dataset_dir: Dataset directory; + name: Image name to add to the TFRecord; + tfrecord_writer: The TFRecord writer to use for writing. + """ + image_data, shape, bboxes, labels, labels_text, difficult, truncated = \ + _process_image(img_name, annot_name, class_list) + + example = _convert_to_example(image_data, labels, labels_text, + bboxes, shape, difficult, truncated) + tfrecord_writer.write(example.SerializeToString()) + + +def _get_output_filename(output_dir, name, idx): + return os.path.join(output_dir, f"{name}_{idx:04d}.tfrecord") + +def run(output_dir, classes_list, images_list, annotations_list, output_name): + """Runs the conversion operation. + + Args: + output_dir: Output directory. + """ + + if not tf.gfile.Exists(output_dir): + tf.gfile.MakeDirs(output_dir) + + if(len(images_list) != len(annotations_list)): + raise ValueError("Images and annotations lists are of different legnths!") + + # Process dataset files. + fidx = 0 + i = 0 + im_annot = list(zip(images_list, annotations_list)) + + while i < len(im_annot): + # Open new TFRecord file. + tf_filename = _get_output_filename(output_dir, output_name, fidx) + with tf.python_io.TFRecordWriter(tf_filename) as tfrecord_writer: + j = 0 + while i < len(im_annot) and j < SAMPLES_PER_FILES: + sys.stdout.write('\r>> Converting image %d/%d' % (i+1, len(im_annot))) + sys.stdout.flush() + + img_name, annot_name = im_annot[i] + _add_to_tfrecord(img_name, annot_name, classes_list, tfrecord_writer) + i += 1 + j += 1 + fidx += 1 + + print('\nFinished converting the Pascal VOC dataset!') diff --git a/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/datautil/__init__.py b/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/datautil/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/datautil/parser.py b/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/datautil/parser.py new file mode 100644 index 00000000..daa56a65 --- /dev/null +++ b/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/datautil/parser.py @@ -0,0 +1,65 @@ +import tensorflow as tf +import numpy as np +import os + +from datautil.ssd_vgg_preprocessing import preprocess_for_train, preprocess_for_eval +from model import ssd_common +from tfutil import tf_utils + +features = { + 'image/encoded': tf.FixedLenFeature((), tf.string, default_value=''), + 'image/format': tf.FixedLenFeature((), tf.string, default_value='jpeg'), + 'image/height': tf.FixedLenFeature([1], tf.int64), + 'image/width': tf.FixedLenFeature([1], tf.int64), + 'image/channels': tf.FixedLenFeature([1], tf.int64), + 'image/shape': tf.FixedLenFeature([3], tf.int64), + 'image/object/bbox/xmin': tf.VarLenFeature(dtype=tf.float32), + 'image/object/bbox/ymin': tf.VarLenFeature(dtype=tf.float32), + 'image/object/bbox/xmax': tf.VarLenFeature(dtype=tf.float32), + 'image/object/bbox/ymax': tf.VarLenFeature(dtype=tf.float32), + 'image/object/bbox/label': tf.VarLenFeature(dtype=tf.int64), + 'image/object/bbox/difficult': tf.VarLenFeature(dtype=tf.int64), + 'image/object/bbox/truncated': tf.VarLenFeature(dtype=tf.int64), +} + + +def get_parser_func(anchors, num_classes, is_training, var_scope): + ''' + Dataset parser function for training and evaluation + + Arguments: + preprocess_fn - function that does preprocesing + ''' + + preprocess_fn = preprocess_for_train if is_training else preprocess_for_eval + + def parse_tfrec_data(example_proto): + with tf.variable_scope(var_scope): + parsed_features = tf.parse_single_example(example_proto, features) + + image_string = parsed_features['image/encoded'] + image_decoded = tf.image.decode_jpeg(image_string) + + labels = tf.sparse.to_dense(parsed_features['image/object/bbox/label']) + + xmin = tf.sparse.to_dense(parsed_features['image/object/bbox/xmin']) + xmax = tf.sparse.to_dense(parsed_features['image/object/bbox/xmax']) + ymin = tf.sparse.to_dense(parsed_features['image/object/bbox/ymin']) + ymax = tf.sparse.to_dense(parsed_features['image/object/bbox/ymax']) + bboxes = tf.stack([ymin, xmin, ymax, xmax], axis=1) + + if is_training: + image, labels, bboxes = preprocess_fn(image_decoded, labels, bboxes) + else: + image, labels, bboxes, _ = preprocess_fn(image_decoded, labels, bboxes) + + # ground truth encoding + # each of the returns is a litst of tensors + if is_training: + classes, localisations, scores = \ + ssd_common.tf_ssd_bboxes_encode(labels, bboxes, anchors, num_classes) + return tf_utils.reshape_list([image, classes, localisations, scores]) + else: + return tf_utils.reshape_list([image, labels, bboxes]) + + return parse_tfrec_data \ No newline at end of file diff --git a/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/datautil/ssd_vgg_preprocessing.py b/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/datautil/ssd_vgg_preprocessing.py new file mode 100644 index 00000000..a0cf0249 --- /dev/null +++ b/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/datautil/ssd_vgg_preprocessing.py @@ -0,0 +1,397 @@ +# Copyright 2015 Paul Balanca. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ============================================================================== +"""Pre-processing images for SSD-type networks. +""" +from enum import Enum, IntEnum +import numpy as np + +import tensorflow as tf + +from tensorflow.python.ops import control_flow_ops + +import tfextended as tfe +from datautil import tf_image + +# Resizing strategies. +Resize = IntEnum('Resize', ('NONE', # Nothing! + 'CENTRAL_CROP', # Crop (and pad if necessary). + 'PAD_AND_RESIZE', # Pad, and resize to output shape. + 'WARP_RESIZE')) # Warp resize. + +# VGG mean parameters. +_R_MEAN = 123. +_G_MEAN = 117. +_B_MEAN = 104. + +# Some training pre-processing parameters. +BBOX_CROP_OVERLAP = 0.5 # Minimum overlap to keep a bbox after cropping. +MIN_OBJECT_COVERED = 0.25 +CROP_RATIO_RANGE = (0.6, 1.67) # Distortion ratio during cropping. +EVAL_SIZE = (300, 300) + + +def tf_image_whitened(image, means=[_R_MEAN, _G_MEAN, _B_MEAN]): + """Subtracts the given means from each image channel. + + Returns: + the centered image. + """ + if image.get_shape().ndims != 3: + raise ValueError('Input must be of size [height, width, C>0]') + + mean = tf.constant(means, dtype=image.dtype) + image = image - mean + return image + + +def tf_image_unwhitened(image, means=[_R_MEAN, _G_MEAN, _B_MEAN], to_int=True): + """Re-convert to original image distribution, and convert to int if + necessary. + + Returns: + Centered image. + """ + mean = tf.constant(means, dtype=image.dtype) + image = image + mean + if to_int: + image = tf.cast(image, tf.int32) + return image + + +def np_image_unwhitened(image, means=[_R_MEAN, _G_MEAN, _B_MEAN], to_int=True): + """Re-convert to original image distribution, and convert to int if + necessary. Numpy version. + + Returns: + Centered image. + """ + img = np.copy(image) + img += np.array(means, dtype=img.dtype) + if to_int: + img = img.astype(np.uint8) + return img + + +def tf_summary_image(image, bboxes, name='image', unwhitened=False): + """Add image with bounding boxes to summary. + """ + if unwhitened: + image = tf_image_unwhitened(image) + image = tf.expand_dims(image, 0) + bboxes = tf.expand_dims(bboxes, 0) + image_with_box = tf.image.draw_bounding_boxes(image, bboxes) + tf.summary.image(name, image_with_box) + + +def apply_with_random_selector(x, func, num_cases): + """Computes func(x, sel), with sel sampled from [0...num_cases-1]. + + Args: + x: input Tensor. + func: Python function to apply. + num_cases: Python int32, number of cases to sample sel from. + + Returns: + The result of func(x, sel), where func receives the value of the + selector as a python integer, but sel is sampled dynamically. + """ + sel = tf.random_uniform([], maxval=num_cases, dtype=tf.int32) + # Pass the real x only to one of the func calls. + return control_flow_ops.merge([ + func(control_flow_ops.switch(x, tf.equal(sel, case))[1], case) + for case in range(num_cases)])[0] + + +def distort_color(image, color_ordering=0, fast_mode=True, scope=None): + """Distort the color of a Tensor image. + + Each color distortion is non-commutative and thus ordering of the color ops + matters. Ideally we would randomly permute the ordering of the color ops. + Rather then adding that level of complication, we select a distinct ordering + of color ops for each preprocessing thread. + + Args: + image: 3-D Tensor containing single image in [0, 1]. + color_ordering: Python int, a type of distortion (valid values: 0-3). + fast_mode: Avoids slower ops (random_hue and random_contrast) + scope: Optional scope for name_scope. + Returns: + 3-D Tensor color-distorted image on range [0, 1] + Raises: + ValueError: if color_ordering not in [0, 3] + """ + with tf.name_scope(scope, 'distort_color', [image]): + if fast_mode: + if color_ordering == 0: + image = tf.image.random_brightness(image, max_delta=32. / 255.) + image = tf.image.random_saturation(image, lower=0.5, upper=1.5) + else: + image = tf.image.random_saturation(image, lower=0.5, upper=1.5) + image = tf.image.random_brightness(image, max_delta=32. / 255.) + else: + if color_ordering == 0: + image = tf.image.random_brightness(image, max_delta=32. / 255.) + image = tf.image.random_saturation(image, lower=0.5, upper=1.5) + image = tf.image.random_hue(image, max_delta=0.2) + image = tf.image.random_contrast(image, lower=0.5, upper=1.5) + elif color_ordering == 1: + image = tf.image.random_saturation(image, lower=0.5, upper=1.5) + image = tf.image.random_brightness(image, max_delta=32. / 255.) + image = tf.image.random_contrast(image, lower=0.5, upper=1.5) + image = tf.image.random_hue(image, max_delta=0.2) + elif color_ordering == 2: + image = tf.image.random_contrast(image, lower=0.5, upper=1.5) + image = tf.image.random_hue(image, max_delta=0.2) + image = tf.image.random_brightness(image, max_delta=32. / 255.) + image = tf.image.random_saturation(image, lower=0.5, upper=1.5) + elif color_ordering == 3: + image = tf.image.random_hue(image, max_delta=0.2) + image = tf.image.random_saturation(image, lower=0.5, upper=1.5) + image = tf.image.random_contrast(image, lower=0.5, upper=1.5) + image = tf.image.random_brightness(image, max_delta=32. / 255.) + else: + raise ValueError('color_ordering must be in [0, 3]') + # The random_* ops do not necessarily clamp. + return tf.clip_by_value(image, 0.0, 1.0) + + +def distorted_bounding_box_crop(image, + labels, + bboxes, + min_object_covered=0.3, + aspect_ratio_range=(0.9, 1.1), + area_range=(0.1, 1.0), + max_attempts=200, + clip_bboxes=True, + scope=None): + """Generates cropped_image using a one of the bboxes randomly distorted. + + See `tf.image.sample_distorted_bounding_box` for more documentation. + + Args: + image: 3-D Tensor of image (it will be converted to floats in [0, 1]). + bbox: 3-D float Tensor of bounding boxes arranged [1, num_boxes, coords] + where each coordinate is [0, 1) and the coordinates are arranged + as [ymin, xmin, ymax, xmax]. If num_boxes is 0 then it would use the whole + image. + min_object_covered: An optional `float`. Defaults to `0.1`. The cropped + area of the image must contain at least this fraction of any bounding box + supplied. + aspect_ratio_range: An optional list of `floats`. The cropped area of the + image must have an aspect ratio = width / height within this range. + area_range: An optional list of `floats`. The cropped area of the image + must contain a fraction of the supplied image within in this range. + max_attempts: An optional `int`. Number of attempts at generating a cropped + region of the image of the specified constraints. After `max_attempts` + failures, return the entire image. + scope: Optional scope for name_scope. + Returns: + A tuple, a 3-D Tensor cropped_image and the distorted bbox + """ + with tf.name_scope(scope, 'distorted_bounding_box_crop', [image, bboxes]): + # Each bounding box has shape [1, num_boxes, box coords] and + # the coordinates are ordered [ymin, xmin, ymax, xmax]. + bbox_begin, bbox_size, distort_bbox = tf.image.sample_distorted_bounding_box( + tf.shape(image), + bounding_boxes=tf.expand_dims(bboxes, 0), + min_object_covered=min_object_covered, + aspect_ratio_range=aspect_ratio_range, + area_range=area_range, + max_attempts=max_attempts, + use_image_if_no_bounding_boxes=True) + distort_bbox = distort_bbox[0, 0] + + # Crop the image to the specified bounding box. + cropped_image = tf.slice(image, bbox_begin, bbox_size) + # Restore the shape since the dynamic slice loses 3rd dimension. + cropped_image.set_shape([None, None, 3]) + + # Update bounding boxes: resize and filter out. + bboxes = tfe.bboxes_resize(distort_bbox, bboxes) + labels, bboxes = tfe.bboxes_filter_overlap(labels, bboxes, + threshold=BBOX_CROP_OVERLAP, + assign_negative=False) + return cropped_image, labels, bboxes, distort_bbox + + +def preprocess_for_train(image, labels, bboxes, + out_shape = (300, 300), data_format='NHWC', + scope='ssd_preprocessing_train'): + """Preprocesses the given image for training. + + Note that the actual resizing scale is sampled from + [`resize_size_min`, `resize_size_max`]. + + Args: + image: A `Tensor` representing an image of arbitrary size. + output_height: The height of the image after preprocessing. + output_width: The width of the image after preprocessing. + resize_side_min: The lower bound for the smallest side of the image for + aspect-preserving resizing. + resize_side_max: The upper bound for the smallest side of the image for + aspect-preserving resizing. + + Returns: + A preprocessed image. + """ + fast_mode = False + with tf.name_scope(scope, 'ssd_preprocessing_train', [image, labels, bboxes]): + if image.get_shape().ndims != 3: + raise ValueError('Input must be of size [height, width, C>0]') + # Convert to float scaled [0, 1]. + if image.dtype != tf.float32: + image = tf.image.convert_image_dtype(image, dtype=tf.float32) + tf_summary_image(image, bboxes, 'image_with_bboxes') + + # # Remove DontCare labels. + # labels, bboxes = ssd_common.tf_bboxes_filter_labels(out_label, + # labels, + # bboxes) + + # Distort image and bounding boxes. + dst_image = image + dst_image, labels, bboxes, distort_bbox = \ + distorted_bounding_box_crop(image, labels, bboxes, + min_object_covered=MIN_OBJECT_COVERED, + aspect_ratio_range=CROP_RATIO_RANGE) + # Resize image to output size. + dst_image = tf_image.resize_image(dst_image, out_shape, + method=tf.image.ResizeMethod.BILINEAR, + align_corners=False) + tf_summary_image(dst_image, bboxes, 'image_shape_distorted') + + # Randomly flip the image horizontally. + dst_image, bboxes = tf_image.random_flip_left_right(dst_image, bboxes) + + # Randomly distort the colors. There are 4 ways to do it. + dst_image = apply_with_random_selector( + dst_image, + lambda x, ordering: distort_color(x, ordering, fast_mode), + num_cases=4) + tf_summary_image(dst_image, bboxes, 'image_color_distorted') + + # Rescale to VGG input scale. + image = dst_image * 255. + image = tf_image_whitened(image, [_R_MEAN, _G_MEAN, _B_MEAN]) + # Image data format. + if data_format == 'NCHW': + image = tf.transpose(image, perm=(2, 0, 1)) + return image, labels, bboxes + + +def preprocess_for_eval(image, labels, bboxes, + out_shape=EVAL_SIZE, data_format='NHWC', + difficults=None, resize=Resize.WARP_RESIZE, + scope='ssd_preprocessing_train'): + """Preprocess an image for evaluation. + + Args: + image: A `Tensor` representing an image of arbitrary size. + out_shape: Output shape after pre-processing (if resize != None) + resize: Resize strategy. + + Returns: + A preprocessed image. + """ + with tf.name_scope(scope): + if image.get_shape().ndims != 3: + raise ValueError('Input must be of size [height, width, C>0]') + + image = tf.cast(image, tf.float32) + image = tf_image_whitened(image, [_R_MEAN, _G_MEAN, _B_MEAN]) + + # Add image rectangle to bboxes. + bbox_img = tf.constant([[0., 0., 1., 1.]]) + if bboxes is None: + bboxes = bbox_img + else: + bboxes = tf.concat([bbox_img, bboxes], axis=0) + + if resize == Resize.NONE: + # No resizing... + pass + elif resize == Resize.CENTRAL_CROP: + # Central cropping of the image. + image, bboxes = tf_image.resize_image_bboxes_with_crop_or_pad( + image, bboxes, out_shape[0], out_shape[1]) + elif resize == Resize.PAD_AND_RESIZE: + # Resize image first: find the correct factor... + shape = tf.shape(image) + factor = tf.minimum(tf.to_double(1.0), + tf.minimum(tf.to_double(out_shape[0] / shape[0]), + tf.to_double(out_shape[1] / shape[1]))) + resize_shape = factor * tf.to_double(shape[0:2]) + resize_shape = tf.cast(tf.floor(resize_shape), tf.int32) + + image = tf_image.resize_image(image, resize_shape, + method=tf.image.ResizeMethod.BILINEAR, + align_corners=False) + # Pad to expected size. + image, bboxes = tf_image.resize_image_bboxes_with_crop_or_pad( + image, bboxes, out_shape[0], out_shape[1]) + elif resize == Resize.WARP_RESIZE: + # Warp resize of the image. + image = tf_image.resize_image(image, out_shape, + method=tf.image.ResizeMethod.BILINEAR, + align_corners=False) + + # Split back bounding boxes. + bbox_img = bboxes[0] + bboxes = bboxes[1:] + # Remove difficult boxes. + if difficults is not None: + mask = tf.logical_not(tf.cast(difficults, tf.bool)) + labels = tf.boolean_mask(labels, mask) + bboxes = tf.boolean_mask(bboxes, mask) + # Image data format. + if data_format == 'NCHW': + image = tf.transpose(image, perm=(2, 0, 1)) + return image, labels, bboxes, bbox_img + +def preprocess_image(image, + labels, + bboxes, + out_shape, + data_format, + is_training=False, + **kwargs): + """Pre-process an given image. + + Args: + image: A `Tensor` representing an image of arbitrary size. + output_height: The height of the image after preprocessing. + output_width: The width of the image after preprocessing. + is_training: `True` if we're preprocessing the image for training and + `False` otherwise. + resize_side_min: The lower bound for the smallest side of the image for + aspect-preserving resizing. If `is_training` is `False`, then this value + is used for rescaling. + resize_side_max: The upper bound for the smallest side of the image for + aspect-preserving resizing. If `is_training` is `False`, this value is + ignored. Otherwise, the resize side is sampled from + [resize_size_min, resize_size_max]. + + Returns: + A preprocessed image. + """ + if is_training: + return preprocess_for_train(image, labels, bboxes, + out_shape=out_shape, + data_format=data_format) + else: + return preprocess_for_eval(image, labels, bboxes, + out_shape=out_shape, + data_format=data_format, + **kwargs) diff --git a/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/datautil/tf_image.py b/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/datautil/tf_image.py new file mode 100644 index 00000000..a9626266 --- /dev/null +++ b/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/datautil/tf_image.py @@ -0,0 +1,306 @@ +# Copyright 2015 The TensorFlow Authors and Paul Balanca. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ============================================================================== +"""Custom image operations. +Most of the following methods extend TensorFlow image library, and part of +the code is shameless copy-paste of the former! +""" +import tensorflow as tf + +from tensorflow.python.framework import constant_op +from tensorflow.python.framework import dtypes +from tensorflow.python.framework import ops +from tensorflow.python.framework import tensor_shape +from tensorflow.python.framework import tensor_util +from tensorflow.python.ops import array_ops +from tensorflow.python.ops import check_ops +from tensorflow.python.ops import clip_ops +from tensorflow.python.ops import control_flow_ops +from tensorflow.python.ops import gen_image_ops +from tensorflow.python.ops import gen_nn_ops +from tensorflow.python.ops import string_ops +from tensorflow.python.ops import math_ops +from tensorflow.python.ops import random_ops +from tensorflow.python.ops import variables + + +# =========================================================================== # +# Modification of TensorFlow image routines. +# =========================================================================== # +def _assert(cond, ex_type, msg): + """A polymorphic assert, works with tensors and boolean expressions. + If `cond` is not a tensor, behave like an ordinary assert statement, except + that a empty list is returned. If `cond` is a tensor, return a list + containing a single TensorFlow assert op. + Args: + cond: Something evaluates to a boolean value. May be a tensor. + ex_type: The exception class to use. + msg: The error message. + Returns: + A list, containing at most one assert op. + """ + if _is_tensor(cond): + return [control_flow_ops.Assert(cond, [msg])] + else: + if not cond: + raise ex_type(msg) + else: + return [] + + +def _is_tensor(x): + """Returns `True` if `x` is a symbolic tensor-like object. + Args: + x: A python object to check. + Returns: + `True` if `x` is a `tf.Tensor` or `tf.Variable`, otherwise `False`. + """ + return isinstance(x, (ops.Tensor, variables.Variable)) + + +def _ImageDimensions(image): + """Returns the dimensions of an image tensor. + Args: + image: A 3-D Tensor of shape `[height, width, channels]`. + Returns: + A list of `[height, width, channels]` corresponding to the dimensions of the + input image. Dimensions that are statically known are python integers, + otherwise they are integer scalar tensors. + """ + if image.get_shape().is_fully_defined(): + return image.get_shape().as_list() + else: + static_shape = image.get_shape().with_rank(3).as_list() + dynamic_shape = array_ops.unstack(array_ops.shape(image), 3) + return [s if s is not None else d + for s, d in zip(static_shape, dynamic_shape)] + + +def _Check3DImage(image, require_static=True): + """Assert that we are working with properly shaped image. + Args: + image: 3-D Tensor of shape [height, width, channels] + require_static: If `True`, requires that all dimensions of `image` are + known and non-zero. + Raises: + ValueError: if `image.shape` is not a 3-vector. + Returns: + An empty list, if `image` has fully defined dimensions. Otherwise, a list + containing an assert op is returned. + """ + try: + image_shape = image.get_shape().with_rank(3) + except ValueError: + raise ValueError("'image' must be three-dimensional.") + if require_static and not image_shape.is_fully_defined(): + raise ValueError("'image' must be fully defined.") + if any(x == 0 for x in image_shape): + raise ValueError("all dims of 'image.shape' must be > 0: %s" % + image_shape) + if not image_shape.is_fully_defined(): + return [check_ops.assert_positive(array_ops.shape(image), + ["all dims of 'image.shape' " + "must be > 0."])] + else: + return [] + + +def fix_image_flip_shape(image, result): + """Set the shape to 3 dimensional if we don't know anything else. + Args: + image: original image size + result: flipped or transformed image + Returns: + An image whose shape is at least None,None,None. + """ + image_shape = image.get_shape() + if image_shape == tensor_shape.unknown_shape(): + result.set_shape([None, None, None]) + else: + result.set_shape(image_shape) + return result + + +# =========================================================================== # +# Image + BBoxes methods: cropping, resizing, flipping, ... +# =========================================================================== # +def bboxes_crop_or_pad(bboxes, + height, width, + offset_y, offset_x, + target_height, target_width): + """Adapt bounding boxes to crop or pad operations. + Coordinates are always supposed to be relative to the image. + + Arguments: + bboxes: Tensor Nx4 with bboxes coordinates [y_min, x_min, y_max, x_max]; + height, width: Original image dimension; + offset_y, offset_x: Offset to apply, + negative if cropping, positive if padding; + target_height, target_width: Target dimension after cropping / padding. + """ + with tf.name_scope('bboxes_crop_or_pad'): + # Rescale bounding boxes in pixels. + scale = tf.cast(tf.stack([height, width, height, width]), bboxes.dtype) + bboxes = bboxes * scale + # Add offset. + offset = tf.cast(tf.stack([offset_y, offset_x, offset_y, offset_x]), bboxes.dtype) + bboxes = bboxes + offset + # Rescale to target dimension. + scale = tf.cast(tf.stack([target_height, target_width, + target_height, target_width]), bboxes.dtype) + bboxes = bboxes / scale + return bboxes + + +def resize_image_bboxes_with_crop_or_pad(image, bboxes, + target_height, target_width): + """Crops and/or pads an image to a target width and height. + Resizes an image to a target width and height by either centrally + cropping the image or padding it evenly with zeros. + + If `width` or `height` is greater than the specified `target_width` or + `target_height` respectively, this op centrally crops along that dimension. + If `width` or `height` is smaller than the specified `target_width` or + `target_height` respectively, this op centrally pads with 0 along that + dimension. + Args: + image: 3-D tensor of shape `[height, width, channels]` + target_height: Target height. + target_width: Target width. + Raises: + ValueError: if `target_height` or `target_width` are zero or negative. + Returns: + Cropped and/or padded image of shape + `[target_height, target_width, channels]` + """ + with tf.name_scope('resize_with_crop_or_pad'): + image = ops.convert_to_tensor(image, name='image') + + assert_ops = [] + assert_ops += _Check3DImage(image, require_static=False) + assert_ops += _assert(target_width > 0, ValueError, + 'target_width must be > 0.') + assert_ops += _assert(target_height > 0, ValueError, + 'target_height must be > 0.') + + image = control_flow_ops.with_dependencies(assert_ops, image) + # `crop_to_bounding_box` and `pad_to_bounding_box` have their own checks. + # Make sure our checks come first, so that error messages are clearer. + if _is_tensor(target_height): + target_height = control_flow_ops.with_dependencies( + assert_ops, target_height) + if _is_tensor(target_width): + target_width = control_flow_ops.with_dependencies(assert_ops, target_width) + + def max_(x, y): + if _is_tensor(x) or _is_tensor(y): + return math_ops.maximum(x, y) + else: + return max(x, y) + + def min_(x, y): + if _is_tensor(x) or _is_tensor(y): + return math_ops.minimum(x, y) + else: + return min(x, y) + + def equal_(x, y): + if _is_tensor(x) or _is_tensor(y): + return math_ops.equal(x, y) + else: + return x == y + + height, width, _ = _ImageDimensions(image) + width_diff = target_width - width + offset_crop_width = max_(-width_diff // 2, 0) + offset_pad_width = max_(width_diff // 2, 0) + + height_diff = target_height - height + offset_crop_height = max_(-height_diff // 2, 0) + offset_pad_height = max_(height_diff // 2, 0) + + # Maybe crop if needed. + height_crop = min_(target_height, height) + width_crop = min_(target_width, width) + cropped = tf.image.crop_to_bounding_box(image, offset_crop_height, offset_crop_width, + height_crop, width_crop) + bboxes = bboxes_crop_or_pad(bboxes, + height, width, + -offset_crop_height, -offset_crop_width, + height_crop, width_crop) + # Maybe pad if needed. + resized = tf.image.pad_to_bounding_box(cropped, offset_pad_height, offset_pad_width, + target_height, target_width) + bboxes = bboxes_crop_or_pad(bboxes, + height_crop, width_crop, + offset_pad_height, offset_pad_width, + target_height, target_width) + + # In theory all the checks below are redundant. + if resized.get_shape().ndims is None: + raise ValueError('resized contains no shape.') + + resized_height, resized_width, _ = _ImageDimensions(resized) + + assert_ops = [] + assert_ops += _assert(equal_(resized_height, target_height), ValueError, + 'resized height is not correct.') + assert_ops += _assert(equal_(resized_width, target_width), ValueError, + 'resized width is not correct.') + + resized = control_flow_ops.with_dependencies(assert_ops, resized) + return resized, bboxes + + +def resize_image(image, size, + method=tf.image.ResizeMethod.BILINEAR, + align_corners=False): + """Resize an image and bounding boxes. + """ + # Resize image. + with tf.name_scope('resize_image'): + height, width, channels = _ImageDimensions(image) + image = tf.expand_dims(image, 0) + image = tf.image.resize_images(image, size, + method, align_corners) + image = tf.reshape(image, tf.stack([size[0], size[1], channels])) + return image + + +def random_flip_left_right(image, bboxes, seed=None): + """Random flip left-right of an image and its bounding boxes. + """ + def flip_bboxes(bboxes): + """Flip bounding boxes coordinates. + """ + bboxes = tf.stack([bboxes[:, 0], 1 - bboxes[:, 3], + bboxes[:, 2], 1 - bboxes[:, 1]], axis=-1) + return bboxes + + # Random flip. Tensorflow implementation. + with tf.name_scope('random_flip_left_right'): + image = ops.convert_to_tensor(image, name='image') + _Check3DImage(image, require_static=False) + uniform_random = random_ops.random_uniform([], 0, 1.0, seed=seed) + mirror_cond = math_ops.less(uniform_random, .5) + # Flip image. + result = control_flow_ops.cond(mirror_cond, + lambda: array_ops.reverse_v2(image, [1]), + lambda: image) + # Flip bboxes. + bboxes = control_flow_ops.cond(mirror_cond, + lambda: flip_bboxes(bboxes), + lambda: bboxes) + return fix_image_flip_shape(image, result), bboxes + diff --git a/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/finetune/__init__.py b/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/finetune/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/finetune/eval.py b/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/finetune/eval.py new file mode 100644 index 00000000..6771ed54 --- /dev/null +++ b/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/finetune/eval.py @@ -0,0 +1,159 @@ +import tensorflow as tf +import numpy as np + +import os, sys, time + +from anchors import generate_anchors +from model import ssd_common, ssd_vgg_300 +from datautil.parser import get_parser_func +from datautil.ssd_vgg_preprocessing import preprocess_for_eval, preprocess_for_train +from tfutil import endpoints, tf_utils +import tfextended as tfe +from finetune.train_eval_base import TrainerBase + +class EvalVggSsd(TrainerBase): + ''' + Run fine-tuning + Have training and validation recordset files + ''' + + def __init__(self, ckpt_dir, validation_recordset_files, steps_to_save = 1000, num_steps = 1000, num_classes = 21, print_steps = 10): + + ''' + ckpt_dir - directory of checkpoint metagraph + train_recordset_files - list of files represetnting the recordset for training + validation_recordset_files - list of files representing validation recordset + ''' + super().__init__(ckpt_dir, validation_recordset_files, steps_to_save, num_steps, num_classes, print_steps, 1, is_training=False) + self.eval_classes = num_classes + + def get_eval_ops(self, b_labels, b_bboxes, predictions, localizations): + ''' + Create evaluation operation + ''' + b_difficults = tf.zeros(tf.shape(b_labels), dtype=tf.int64) + + # Performing post-processing on CPU: loop-intensive, usually more efficient. + with tf.device('/device:CPU:0'): + # Detected objects from SSD output. + detected_localizations = self.ssd_net.bboxes_decode(localizations, self.anchors) + + rscores, rbboxes = \ + self.ssd_net.detected_bboxes(predictions, detected_localizations, + select_threshold=0.01, + nms_threshold=0.45, + clipping_bbox=None, + top_k=400, + keep_top_k=20) + + # Compute TP and FP statistics. + num_gbboxes, tp, fp, rscores = \ + tfe.bboxes_matching_batch(rscores.keys(), rscores, rbboxes, + b_labels, b_bboxes, b_difficults, + matching_threshold=0.5) + + # =================================================================== # + # Evaluation metrics. + # =================================================================== # + dict_metrics = {} + metrics_scope = 'ssd_metrics_scope' + + # First add all losses. + for loss in tf.get_collection(tf.GraphKeys.LOSSES): + dict_metrics[loss.op.name] = tf.metrics.mean(loss, name=metrics_scope) + # Extra losses as well. + for loss in tf.get_collection('EXTRA_LOSSES'): + dict_metrics[loss.op.name] = tf.metrics.mean(loss, name=metrics_scope) + + # Add metrics to summaries and Print on screen. + for name, metric in dict_metrics.items(): + # summary_name = 'eval/%s' % name + summary_name = name + tf.summary.scalar(summary_name, metric[0]) + + # FP and TP metrics. + tp_fp_metric = tfe.streaming_tp_fp_arrays(num_gbboxes, tp, fp, rscores, name=metrics_scope) + + for c in tp_fp_metric[0].keys(): + dict_metrics['tp_fp_%s' % c] = (tp_fp_metric[0][c], + tp_fp_metric[1][c]) + + # Add to summaries precision/recall values. + aps_voc12 = {} + # TODO: We cut it short by the actual number of classes we have + for c in list(tp_fp_metric[0].keys())[:self.eval_classes - 1]: + # Precison and recall values. + prec, rec = tfe.precision_recall(*tp_fp_metric[0][c]) + + # Average precision VOC12. + v = tfe.average_precision_voc12(prec, rec) + summary_name = 'AP_VOC12/%s' % c + tf.summary.scalar(summary_name, v) + + aps_voc12[c] = v + + # Mean average precision VOC12. + summary_name = 'AP_VOC12/mAP' + mAP = tf.add_n(list(aps_voc12.values())) / len(aps_voc12) + tf.summary.scalar(summary_name, mAP) + + names_to_values, names_to_updates = tf.contrib.metrics.aggregate_metric_map(dict_metrics) + + # Split into values and updates ops. + return (names_to_values, names_to_updates, mAP) + + def eval(self): + + tf.logging.set_verbosity(tf.logging.INFO) + + # shorthand + sess = self.sess + + sess.run(self.iterator.initializer) + batch_data = self.iterator.get_next() + + # image, classes, scores, ground_truths are neatly packed into a flat list + # this is how we will slice it to extract the data we need: + # we will convert the flat list into a list of lists, where each sub-list + # is as long as each slice dimension + slice_shape = [1] * 3 + + b_image, b_labels, b_bboxes = tf_utils.reshape_list(batch_data, slice_shape) + + # network endpoints + predictions, localizations, _, _ = self.get_output_tensors(b_image) + + # branch to create evaluation operation + _, names_to_updates, mAP = \ + self.get_eval_ops(b_labels, b_bboxes, predictions, localizations) + + eval_update_ops = tf_utils.reshape_list(list(names_to_updates.values())) + + # summaries + summary_op = tf.summary.merge_all() + saver = tf.train.Saver() + + eval_writer = tf.summary.FileWriter(self.ckpt_dir + '/eval') + + # initialize globals + sess.run(tf.global_variables_initializer()) + + saver.restore(self.sess, self.ckpt_file) + sess.run(tf.local_variables_initializer()) + + tf.logging.info(f"Starting evaluation for {self.num_steps} steps") + cur_step = self.latest_ckpt_step + + for step in range(self.num_steps): + print(f"Evaluation step: {step + 1}", end='\r', flush=True) + _, summary = sess.run([eval_update_ops, summary_op]) + + if (step + 1) % self.print_steps == 0 or step == self.num_steps: + eval_writer.add_summary(summary, cur_step + step + 1) + + summary_final, mAP_val = sess.run([summary_op, mAP]) + + print(f"\nmAP: {mAP_val:.4f}") + + if (step + 1) % self.print_steps != 0: + eval_writer.add_summary(summary_final, self.num_steps + cur_step) \ No newline at end of file diff --git a/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/finetune/inference.py b/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/finetune/inference.py new file mode 100644 index 00000000..d56bafea --- /dev/null +++ b/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/finetune/inference.py @@ -0,0 +1,95 @@ +import tensorflow as tf + +import os, time + +from anchors import generate_anchors +from model import np_methods +from tfutil import endpoints, tf_utils +from datautil.ssd_vgg_preprocessing import preprocess_for_eval +import tfextended as tfe +from azureml.accel.models import SsdVgg + +class InferVggSsd: + ''' + Run fine-tuning + Have training and validation recordset files + ''' + + def __init__(self, ckpt_dir, ckpt_file=None, gpu=True): + + ''' + ckpt_dir - directory of checkpoint metagraph + ''' + + if gpu: + gpu_options = tf.GPUOptions(allow_growth=True) + config = tf.ConfigProto(log_device_placement=False, gpu_options=gpu_options) + else: + config = tf.ConfigProto(log_device_placement=False, device_count={'GPU': 0}) + + self.sess = tf.Session(config=config) + + ssd_net_graph = SsdVgg(ckpt_dir) + self.ckpt_dir = ssd_net_graph.model_path + + self.img_input = tf.placeholder(tf.uint8, shape=(None, None, 3)) + + # Evaluation pre-processing: resize to SSD net shape. + image_pre, _, _, self.bbox_img = preprocess_for_eval( + self.img_input, None, None, generate_anchors.img_shape, "NHWC") + self.image_4d = tf.expand_dims(image_pre, 0) + + # import the graph + ssd_net_graph.import_graph_def(self.image_4d, is_training=False) + + graph = tf.get_default_graph() + self.localizations = [graph.get_tensor_by_name(tensor_name) for tensor_name in endpoints.localizations_names] + self.predictions = [graph.get_tensor_by_name(tensor_name) for tensor_name in endpoints.predictions_names] + + # Restore SSD model. + self.sess.run(tf.global_variables_initializer()) + + if ckpt_file is None: + ssd_net_graph.restore_weights(self.sess) + else: + saver = tf.train.Saver() + saver.restore(self.sess, os.path.join(self.ckpt_dir, ckpt_file)) + + # SSD default anchor boxes. + self.ssd_anchors = generate_anchors.ssd_anchors_all_layers() + + + def close(self): + self.sess.close() + tf.reset_default_graph() + + def process_image(self, img, select_threshold=0.4, nms_threshold=.45, net_shape=(300, 300)): + # Run SSD network. + rpredictions, rlocalisations, rbbox_img = \ + self.sess.run([self.predictions, self.localizations, self.bbox_img], + feed_dict={self.img_input: img}) + # Get classes and bboxes from the net outputs. + rclasses, rscores, rbboxes = np_methods.ssd_bboxes_select( + rpredictions, rlocalisations, self.ssd_anchors, + select_threshold=select_threshold, img_shape=net_shape, num_classes=21, decode=True) + + rbboxes = np_methods.bboxes_clip(rbbox_img, rbboxes) + rclasses, rscores, rbboxes = np_methods.bboxes_sort(rclasses, rscores, rbboxes, top_k=400) + rclasses, rscores, rbboxes = np_methods.bboxes_nms(rclasses, rscores, rbboxes, nms_threshold=nms_threshold) + return rclasses, rscores, rbboxes + + def infer(self, img, visualize): + rclasses, rscores, rbboxes = self.process_image(img) + + if visualize: + from tfutil import visualization + visualization.plt_bboxes(img, rclasses, rscores, rbboxes) + + return rclasses, rscores, rbboxes + + def infer_file(self, im_file, visualize=False): + import cv2 + + img = cv2.imread(im_file) + img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) + return self.infer(img, visualize) \ No newline at end of file diff --git a/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/finetune/metrics.py b/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/finetune/metrics.py new file mode 100644 index 00000000..e69de29b diff --git a/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/finetune/model_saver.py b/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/finetune/model_saver.py new file mode 100644 index 00000000..2a172046 --- /dev/null +++ b/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/finetune/model_saver.py @@ -0,0 +1,57 @@ +import tensorflow as tf + +import os, time + +from azureml.accel.models import SsdVgg +import azureml.accel.models.utils as utils + +class SaverVggSsd: + ''' + Run fine-tuning + Have training and validation recordset files + ''' + + def __init__(self, ckpt_dir): + + ''' + ckpt_dir - directory of checkpoint metagraph + ''' + + config = tf.ConfigProto(log_device_placement=False, device_count={'GPU': 0}) + + self.sess = tf.Session(config=config) + + ssd_net_graph = SsdVgg(ckpt_dir, is_frozen=True) + self.ckpt_dir = ssd_net_graph.model_path + + self.in_images = tf.placeholder(tf.string) + self.image_tensors = utils.preprocess_array(self.in_images, output_width=300, output_height=300, + preserve_aspect_ratio=False) + + self.output_tensors = ssd_net_graph.import_graph_def(self.image_tensors, is_training=False) + + self.output_names = ssd_net_graph.output_tensor_list + self.input_name_str = self.in_images.name + + # Restore SSD model. + ssd_net_graph.restore_weights(self.sess) + + + def __enter__(self): + return self + + def __exit__(self, exc_type, exc_val, exc_tb): + self.close() + + def close(self): + self.sess.close() + tf.reset_default_graph() + + def save_for_deployment(self, saved_path): + + output_map = {'out_{}'.format(i): output for i, output in enumerate(self.output_tensors)} + + tf.saved_model.simple_save(self.sess, + saved_path, + inputs={"images": self.in_images}, + outputs=output_map) \ No newline at end of file diff --git a/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/finetune/train.py b/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/finetune/train.py new file mode 100644 index 00000000..b9b4e402 --- /dev/null +++ b/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/finetune/train.py @@ -0,0 +1,144 @@ +import tensorflow as tf +import numpy as np + +import os, sys, time, re + +from anchors import generate_anchors +from model import ssd_common, ssd_vgg_300 +from datautil.parser import get_parser_func +from datautil.ssd_vgg_preprocessing import preprocess_for_eval, preprocess_for_train +from tfutil import endpoints, tf_utils +import tfextended as tfe +from finetune.train_eval_base import TrainerBase + +class TrainVggSsd(TrainerBase): + ''' + Run fine-tuning + Have training and validation recordset files + ''' + + def __init__(self, ckpt_dir, train_recordset_files, + steps_to_save = 1000, num_steps = 1000, num_classes = 21, + print_steps = 10, batch_size = 2, + learning_rate = 1e-4, learning_rate_decay_steps=None, learning_rate_decay_value = None, + adam_beta1 = 0.9, adam_beta2 = 0.999, adam_epsilon = 1e-8): + + ''' + ckpt_dir - directory of checkpoint metagraph + train_recordset_files - list of files represetnting the recordset for training + validation_recordset_files - list of files representing validation recordset + ''' + + super().__init__(ckpt_dir, train_recordset_files, steps_to_save, num_steps, num_classes, print_steps, batch_size) + + # optimizer parameters + self.learning_rate = learning_rate + self.learning_rate_decay_steps = learning_rate_decay_steps + self.learning_rate_decay_value = learning_rate_decay_value + + if self.learning_rate <= 0 \ + or (self.learning_rate_decay_value is not None and self.learning_rate_decay_value <= 0) \ + or (self.learning_rate_decay_steps is not None and self.learning_rate_decay_steps <= 0) \ + or (self.learning_rate_decay_steps is None and self.learning_rate_decay_value is not None) \ + or (self.learning_rate_decay_steps is not None and self.learning_rate_decay_value is None): + raise ValueError("learning rate, learning rate steps, learning rate decay must be positive, \ + learning decay steps and value must be both present or both absent") + + self.adam_beta1 = adam_beta1 + self.adam_beta2 = adam_beta2 + self.adam_epsilon = adam_epsilon + + def get_optimizer(self, learning_rate): + optimizer = tf.train.AdamOptimizer( + learning_rate, + beta1=self.adam_beta1, + beta2=self.adam_beta2, + epsilon=self.adam_epsilon) + return optimizer + + def get_learning_rate(self, global_step): + ''' + Configure learning rate based on decay specifications + ''' + if self.learning_rate_decay_steps is None: + return tf.constant(self.learning_rate, name = 'fixed_learning_rate') + else: + return tf.train.exponential_decay(self.learning_rate, global_step, \ + self.learning_rate_decay_steps, self.learning_rate_decay_value, \ + staircase=True, name="exponential_decay_learning_rate") + + def train(self): + + tf.logging.set_verbosity(tf.logging.INFO) + + # shorthand + sess = self.sess + + batch_data = self.iterator.get_next() + + # image, classes, scores, ground_truths are neatly packed into a flat list + # this is how we will slice it to extract the data we need: + # we will convert the flat list into a list of lists, where each sub-list + # is as long as each slice dimension + slice_shape = [1] + [len(self.anchors)] * 3 + + b_image, b_classes, b_localizations, b_scores = tf_utils.reshape_list(batch_data, slice_shape) + # network endpoints + _, localizations, logits, bw_saver = self.get_output_tensors(b_image) + + variables_to_train = tf.trainable_variables() + sess.run(tf.initialize_variables(variables_to_train)) + + # add losses + total_loss = self.ssd_net.losses(logits, localizations, b_classes, b_localizations, b_scores) + tf.summary.scalar("total_loss", total_loss) + + global_step = tf.train.get_or_create_global_step() + learning_rate = self.get_learning_rate(global_step) + + # configure learning rate now that we have the global step + # add optimizer + optimizer = self.get_optimizer(learning_rate) + + tf.summary.scalar("learning_rate", learning_rate) + + grads_and_vars = optimizer.compute_gradients(total_loss, var_list=variables_to_train) + grad_updates = optimizer.apply_gradients(grads_and_vars, global_step=global_step) + + # initialize all the variables we should initialize + # weights will be restored right after + sess.run(tf.global_variables_initializer()) + + # after the first restore, we want global step in our checkpoint + saver = tf.train.Saver(variables_to_train + [global_step]) + if self.latest_ckpt_step == 0: + bw_saver.restore(sess, self.ckpt_file) + else: + saver.restore(sess, self.ckpt_file) + self.ckpt_file = os.path.join(self.ckpt_dir, self.ckpt_prefix) + + # summaries + train_summary_op = tf.summary.merge_all() + train_writer = tf.summary.FileWriter(self.ckpt_dir + '/train', tf.get_default_graph()) + + tf.logging.info(f"Starting training for {self.num_steps} steps") + + sess.run(self.iterator.initializer) + + # training loop + start = time.time() + + for _ in range(self.num_steps): + + loss, _, cur_step, summary = sess.run([total_loss, grad_updates, global_step, train_summary_op]) + cur_step += 1 + + if cur_step % self.print_steps == 0: + + print(f"{cur_step}: loss: {loss:.3f}, avg per step: {(time.time() - start) / self.print_steps:.3f} sec", end='\r', flush=True) + train_writer.add_summary(summary, cur_step + 1) + start = time.time() + + if cur_step % self.steps_to_save == 0: + saver.save(sess, self.ckpt_file, global_step=global_step) + print("\n") \ No newline at end of file diff --git a/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/finetune/train_eval_base.py b/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/finetune/train_eval_base.py new file mode 100644 index 00000000..340bd3e1 --- /dev/null +++ b/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/finetune/train_eval_base.py @@ -0,0 +1,125 @@ +import tensorflow as tf +import numpy as np + +import os, sys, time, glob, re + +from anchors import generate_anchors +from model import ssd_common, ssd_vgg_300 +from datautil.parser import get_parser_func +from datautil.ssd_vgg_preprocessing import preprocess_for_eval, preprocess_for_train +from tfutil import endpoints, tf_utils +import tfextended as tfe +from azureml.accel.models import SsdVgg + +slim = tf.contrib.slim + +class TrainerBase: + ''' + Run fine-tuning + Have training and validation recordset files + ''' + + def __init__(self, ckpt_dir, recordset_files, + steps_to_save = 1000, num_steps = 1000, num_classes = 21, print_steps = 10, batch_size=2, is_training=True): + + ''' + ckpt_dir - directory of checkpoint metagraph + recordset_files - list of files represetnting the recordset for training + validation_recordset_files - list of files representing validation recordset + ''' + + self.is_training = is_training + + # This will pull the model with its weights + # And seed the checkpoint + self.ssd_net_graph = SsdVgg(ckpt_dir) + self.ckpt_dir = self.ssd_net_graph.model_path + self.ckpt_file = tf.train.latest_checkpoint(self.ssd_net_graph.model_path) + + try: + self.latest_ckpt_step = int(re.findall("-[0-9]+$", self.ckpt_file)[0][1:]) + except: + self.latest_ckpt_step = 0 + + self.recordset = recordset_files + self.ckpt_prefix = os.path.split(self.ssd_net_graph.model_ref + "_bw")[1] + + self.pb_graph_path = os.path.join(self.ckpt_dir, self.ckpt_prefix + ".graph.pb") + #if self.is_training: + self.graph_file = os.path.join(self.ckpt_dir, self.ckpt_prefix + ".meta") + #else: + # self.graph_file = self.ckpt_file + ".meta" + + # anchors + self.anchors = generate_anchors.ssd_anchors_all_layers() + + # shuffle + self.n_shuffle = 1000 + self.num_steps = num_steps + + # num of classes + # REVIEW: this has to be 21! + self.num_classes = 21 + + # initialize data pipeline + self.batch_size = batch_size + self.iterator = None + self.prep_dataset_and_iterator() + + self.steps_to_save = steps_to_save + + self.print_steps = print_steps + # for losses etc + self.ssd_net = ssd_vgg_300.SSDNet() + + # input placeholder + self.input_tensor_name = self.ssd_net_graph.input_tensor_list[0] + + + def __enter__(self): + gpu_options = tf.GPUOptions(allow_growth=True) + config = tf.ConfigProto(log_device_placement=False, gpu_options=gpu_options) + + self.sess = tf.Session(config=config) + + return self + + def __exit__(self, exc_type, exc_val, exc_tb): + self.sess.close() + tf.reset_default_graph() + + def prep_dataset_and_iterator(self): + ''' + Create datasets for training or validation + ''' + + var_scope = "training" if self.is_training else "eval" + + parse_func = get_parser_func(self.anchors, self.num_classes, self.is_training, var_scope) + + with tf.variable_scope(var_scope): + # data pipeline + dataset = tf.data.TFRecordDataset(self.recordset) + if self.is_training: + dataset = dataset.shuffle(self.n_shuffle) + dataset = dataset.map(parse_func) + dataset = dataset.repeat() + dataset = dataset.batch(self.batch_size) + dataset = dataset.prefetch(1) + + self.iterator = dataset.make_initializable_iterator() + + def get_output_tensors(self, image): + + is_training = tf.constant(self.is_training, dtype=tf.bool, shape=()) + input_map = {self.input_tensor_name: image, "is_training": is_training} + + saver = tf.train.import_meta_graph(self.graph_file, input_map=input_map) + graph = tf.get_default_graph() + + logits = [graph.get_tensor_by_name(tensor_name) for tensor_name in endpoints.logit_names] + localizations = [graph.get_tensor_by_name(tensor_name) for tensor_name in endpoints.localizations_names] + predictions = [graph.get_tensor_by_name(tensor_name) for tensor_name in endpoints.predictions_names] + + return predictions, localizations, logits, saver + diff --git a/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/model/__init__.py b/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/model/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/model/custom_layers.py b/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/model/custom_layers.py new file mode 100644 index 00000000..4939c872 --- /dev/null +++ b/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/model/custom_layers.py @@ -0,0 +1,164 @@ +# Copyright 2015 Paul Balanca. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ============================================================================== +"""Implement some custom layers, not provided by TensorFlow. + +Trying to follow as much as possible the style/standards used in +tf.contrib.layers +""" +import tensorflow as tf + +from tensorflow.contrib.framework.python.ops import add_arg_scope +from tensorflow.contrib.layers.python.layers import initializers +from tensorflow.contrib.framework.python.ops import variables +from tensorflow.contrib.layers.python.layers import utils +from tensorflow.python.ops import nn +from tensorflow.python.ops import init_ops +from tensorflow.python.ops import variable_scope + + +def abs_smooth(x): + """Smoothed absolute function. Useful to compute an L1 smooth error. + + Define as: + x^2 / 2 if abs(x) < 1 + abs(x) - 0.5 if abs(x) > 1 + We use here a differentiable definition using min(x) and abs(x). Clearly + not optimal, but good enough for our purpose! + """ + absx = tf.abs(x) + minx = tf.minimum(absx, 1) + r = 0.5 * ((absx - 1) * minx + absx) + return r + + +@add_arg_scope +def l2_normalization( + inputs, + scaling=False, + scale_initializer=init_ops.ones_initializer(), + reuse=None, + variables_collections=None, + outputs_collections=None, + data_format='NHWC', + trainable=True, + scope=None): + """Implement L2 normalization on every feature (i.e. spatial normalization). + + Should be extended in some near future to other dimensions, providing a more + flexible normalization framework. + + Args: + inputs: a 4-D tensor with dimensions [batch_size, height, width, channels]. + scaling: whether or not to add a post scaling operation along the dimensions + which have been normalized. + scale_initializer: An initializer for the weights. + reuse: whether or not the layer and its variables should be reused. To be + able to reuse the layer scope must be given. + variables_collections: optional list of collections for all the variables or + a dictionary containing a different list of collection per variable. + outputs_collections: collection to add the outputs. + data_format: NHWC or NCHW data format. + trainable: If `True` also add variables to the graph collection + `GraphKeys.TRAINABLE_VARIABLES` (see tf.Variable). + scope: Optional scope for `variable_scope`. + Returns: + A `Tensor` representing the output of the operation. + """ + + with variable_scope.variable_scope( + scope, 'L2Normalization', [inputs], reuse=reuse) as sc: + inputs_shape = inputs.get_shape() + inputs_rank = inputs_shape.ndims + dtype = inputs.dtype.base_dtype + if data_format == 'NHWC': + # norm_dim = tf.range(1, inputs_rank-1) + norm_dim = tf.range(inputs_rank-1, inputs_rank) + params_shape = inputs_shape[-1:] + elif data_format == 'NCHW': + # norm_dim = tf.range(2, inputs_rank) + norm_dim = tf.range(1, 2) + params_shape = (inputs_shape[1]) + + # Normalize along spatial dimensions. + outputs = nn.l2_normalize(inputs, norm_dim, epsilon=1e-12) + # Additional scaling. + if scaling: + scale_collections = utils.get_variable_collections( + variables_collections, 'scale') + scale = variables.model_variable('gamma', + shape=params_shape, + dtype=dtype, + initializer=scale_initializer, + collections=scale_collections, + trainable=trainable) + if data_format == 'NHWC': + outputs = tf.multiply(outputs, scale) + elif data_format == 'NCHW': + scale = tf.expand_dims(scale, axis=-1) + scale = tf.expand_dims(scale, axis=-1) + outputs = tf.multiply(outputs, scale) + # outputs = tf.transpose(outputs, perm=(0, 2, 3, 1)) + + return utils.collect_named_outputs(outputs_collections, + sc.original_name_scope, outputs) + + +@add_arg_scope +def pad2d(inputs, + pad=(0, 0), + mode='CONSTANT', + data_format='NHWC', + trainable=True, + scope=None): + """2D Padding layer, adding a symmetric padding to H and W dimensions. + + Aims to mimic padding in Caffe and MXNet, helping the port of models to + TensorFlow. Tries to follow the naming convention of `tf.contrib.layers`. + + Args: + inputs: 4D input Tensor; + pad: 2-Tuple with padding values for H and W dimensions; + mode: Padding mode. C.f. `tf.pad` + data_format: NHWC or NCHW data format. + """ + with tf.name_scope(scope, 'pad2d', [inputs]): + # Padding shape. + if data_format == 'NHWC': + paddings = [[0, 0], [pad[0], pad[0]], [pad[1], pad[1]], [0, 0]] + elif data_format == 'NCHW': + paddings = [[0, 0], [0, 0], [pad[0], pad[0]], [pad[1], pad[1]]] + net = tf.pad(inputs, paddings, mode=mode) + return net + + +@add_arg_scope +def channel_to_last(inputs, + data_format='NHWC', + scope=None): + """Move the channel axis to the last dimension. Allows to + provide a single output format whatever the input data format. + + Args: + inputs: Input Tensor; + data_format: NHWC or NCHW. + Return: + Input in NHWC format. + """ + with tf.name_scope(scope, 'channel_to_last', [inputs]): + if data_format == 'NHWC': + net = inputs + elif data_format == 'NCHW': + net = tf.transpose(inputs, perm=(0, 2, 3, 1)) + return net diff --git a/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/model/np_methods.py b/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/model/np_methods.py new file mode 100644 index 00000000..7a021aa4 --- /dev/null +++ b/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/model/np_methods.py @@ -0,0 +1,252 @@ +# Copyright 2017 Paul Balanca. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ============================================================================== +"""Additional Numpy methods. Big mess of many things! +""" +import numpy as np + + +# =========================================================================== # +# Numpy implementations of SSD boxes functions. +# =========================================================================== # +def ssd_bboxes_decode(feat_localizations, + anchor_bboxes, + prior_scaling=[0.1, 0.1, 0.2, 0.2]): + """Compute the relative bounding boxes from the layer features and + reference anchor bounding boxes. + + Return: + numpy array Nx4: ymin, xmin, ymax, xmax + """ + # Reshape for easier broadcasting. + l_shape = feat_localizations.shape + feat_localizations = np.reshape(feat_localizations, + (-1, l_shape[-2], l_shape[-1])) + yref, xref, href, wref = anchor_bboxes + xref = np.reshape(xref, [-1, 1]) + yref = np.reshape(yref, [-1, 1]) + + # Compute center, height and width + cx = feat_localizations[:, :, 0] * wref * prior_scaling[0] + xref + cy = feat_localizations[:, :, 1] * href * prior_scaling[1] + yref + w = wref * np.exp(feat_localizations[:, :, 2] * prior_scaling[2]) + h = href * np.exp(feat_localizations[:, :, 3] * prior_scaling[3]) + # bboxes: ymin, xmin, xmax, ymax. + bboxes = np.zeros_like(feat_localizations) + bboxes[:, :, 0] = cy - h / 2. + bboxes[:, :, 1] = cx - w / 2. + bboxes[:, :, 2] = cy + h / 2. + bboxes[:, :, 3] = cx + w / 2. + # Back to original shape. + bboxes = np.reshape(bboxes, l_shape) + return bboxes + + +def ssd_bboxes_select_layer(predictions_layer, + localizations_layer, + anchors_layer, + select_threshold=0.5, + img_shape=(300, 300), + num_classes=21, + decode=True): + """Extract classes, scores and bounding boxes from features in one layer. + + Return: + classes, scores, bboxes: Numpy arrays... + """ + # First decode localizations features if necessary. + if decode: + localizations_layer = ssd_bboxes_decode(localizations_layer, anchors_layer) + + # Reshape features to: Batches x N x N_labels | 4. + p_shape = predictions_layer.shape + batch_size = p_shape[0] if len(p_shape) == 5 else 1 + predictions_layer = np.reshape(predictions_layer, + (batch_size, -1, p_shape[-1])) + l_shape = localizations_layer.shape + localizations_layer = np.reshape(localizations_layer, + (batch_size, -1, l_shape[-1])) + + # Boxes selection: use threshold or score > no-label criteria. + if select_threshold is None or select_threshold == 0: + # Class prediction and scores: assign 0. to 0-class + classes = np.argmax(predictions_layer, axis=2) + scores = np.amax(predictions_layer, axis=2) + mask = (classes > 0) + classes = classes[mask] + scores = scores[mask] + bboxes = localizations_layer[mask] + else: + sub_predictions = predictions_layer[:, :, 1:] + idxes = np.where(sub_predictions > select_threshold) + classes = idxes[-1]+1 + scores = sub_predictions[idxes] + bboxes = localizations_layer[idxes[:-1]] + + return classes, scores, bboxes + + +def ssd_bboxes_select(predictions_net, + localizations_net, + anchors_net, + select_threshold=0.5, + img_shape=(300, 300), + num_classes=21, + decode=True): + """Extract classes, scores and bounding boxes from network output layers. + + Return: + classes, scores, bboxes: Numpy arrays... + """ + l_classes = [] + l_scores = [] + l_bboxes = [] + # l_layers = [] + # l_idxes = [] + for i in range(len(predictions_net)): + classes, scores, bboxes = ssd_bboxes_select_layer( + predictions_net[i], localizations_net[i], anchors_net[i], + select_threshold, img_shape, num_classes, decode) + l_classes.append(classes) + l_scores.append(scores) + l_bboxes.append(bboxes) + # Debug information. + # l_layers.append(i) + # l_idxes.append((i, idxes)) + + classes = np.concatenate(l_classes, 0) + scores = np.concatenate(l_scores, 0) + bboxes = np.concatenate(l_bboxes, 0) + return classes, scores, bboxes + + +# =========================================================================== # +# Common functions for bboxes handling and selection. +# =========================================================================== # +def bboxes_sort(classes, scores, bboxes, top_k=400): + """Sort bounding boxes by decreasing order and keep only the top_k + """ + # if priority_inside: + # inside = (bboxes[:, 0] > margin) & (bboxes[:, 1] > margin) & \ + # (bboxes[:, 2] < 1-margin) & (bboxes[:, 3] < 1-margin) + # idxes = np.argsort(-scores) + # inside = inside[idxes] + # idxes = np.concatenate([idxes[inside], idxes[~inside]]) + idxes = np.argsort(-scores) + classes = classes[idxes][:top_k] + scores = scores[idxes][:top_k] + bboxes = bboxes[idxes][:top_k] + return classes, scores, bboxes + + +def bboxes_clip(bbox_ref, bboxes): + """Clip bounding boxes with respect to reference bbox. + """ + bboxes = np.copy(bboxes) + bboxes = np.transpose(bboxes) + bbox_ref = np.transpose(bbox_ref) + bboxes[0] = np.maximum(bboxes[0], bbox_ref[0]) + bboxes[1] = np.maximum(bboxes[1], bbox_ref[1]) + bboxes[2] = np.minimum(bboxes[2], bbox_ref[2]) + bboxes[3] = np.minimum(bboxes[3], bbox_ref[3]) + bboxes = np.transpose(bboxes) + return bboxes + + +def bboxes_resize(bbox_ref, bboxes): + """Resize bounding boxes based on a reference bounding box, + assuming that the latter is [0, 0, 1, 1] after transform. + """ + bboxes = np.copy(bboxes) + # Translate. + bboxes[:, 0] -= bbox_ref[0] + bboxes[:, 1] -= bbox_ref[1] + bboxes[:, 2] -= bbox_ref[0] + bboxes[:, 3] -= bbox_ref[1] + # Resize. + resize = [bbox_ref[2] - bbox_ref[0], bbox_ref[3] - bbox_ref[1]] + bboxes[:, 0] /= resize[0] + bboxes[:, 1] /= resize[1] + bboxes[:, 2] /= resize[0] + bboxes[:, 3] /= resize[1] + return bboxes + + +def bboxes_jaccard(bboxes1, bboxes2): + """Computing jaccard index between bboxes1 and bboxes2. + Note: bboxes1 and bboxes2 can be multi-dimensional, but should broacastable. + """ + bboxes1 = np.transpose(bboxes1) + bboxes2 = np.transpose(bboxes2) + # Intersection bbox and volume. + int_ymin = np.maximum(bboxes1[0], bboxes2[0]) + int_xmin = np.maximum(bboxes1[1], bboxes2[1]) + int_ymax = np.minimum(bboxes1[2], bboxes2[2]) + int_xmax = np.minimum(bboxes1[3], bboxes2[3]) + + int_h = np.maximum(int_ymax - int_ymin, 0.) + int_w = np.maximum(int_xmax - int_xmin, 0.) + int_vol = int_h * int_w + # Union volume. + vol1 = (bboxes1[2] - bboxes1[0]) * (bboxes1[3] - bboxes1[1]) + vol2 = (bboxes2[2] - bboxes2[0]) * (bboxes2[3] - bboxes2[1]) + jaccard = int_vol / (vol1 + vol2 - int_vol) + return jaccard + + +def bboxes_intersection(bboxes_ref, bboxes2): + """Computing jaccard index between bboxes1 and bboxes2. + Note: bboxes1 and bboxes2 can be multi-dimensional, but should broacastable. + """ + bboxes_ref = np.transpose(bboxes_ref) + bboxes2 = np.transpose(bboxes2) + # Intersection bbox and volume. + int_ymin = np.maximum(bboxes_ref[0], bboxes2[0]) + int_xmin = np.maximum(bboxes_ref[1], bboxes2[1]) + int_ymax = np.minimum(bboxes_ref[2], bboxes2[2]) + int_xmax = np.minimum(bboxes_ref[3], bboxes2[3]) + + int_h = np.maximum(int_ymax - int_ymin, 0.) + int_w = np.maximum(int_xmax - int_xmin, 0.) + int_vol = int_h * int_w + # Union volume. + vol = (bboxes_ref[2] - bboxes_ref[0]) * (bboxes_ref[3] - bboxes_ref[1]) + score = int_vol / vol + return score + + +def bboxes_nms(classes, scores, bboxes, nms_threshold=0.45): + """Apply non-maximum selection to bounding boxes. + """ + keep_bboxes = np.ones(scores.shape, dtype=np.bool) + for i in range(scores.size-1): + if keep_bboxes[i]: + # Computer overlap with bboxes which are following. + overlap = bboxes_jaccard(bboxes[i], bboxes[(i+1):]) + # Overlap threshold for keeping + checking part of the same class + keep_overlap = np.logical_or(overlap < nms_threshold, classes[(i+1):] != classes[i]) + keep_bboxes[(i+1):] = np.logical_and(keep_bboxes[(i+1):], keep_overlap) + + idxes = np.where(keep_bboxes) + return classes[idxes], scores[idxes], bboxes[idxes] + + +def bboxes_nms_fast(classes, scores, bboxes, threshold=0.45): + """Apply non-maximum selection to bounding boxes. + """ + pass + + + + diff --git a/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/model/ssd_common.py b/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/model/ssd_common.py new file mode 100644 index 00000000..80896452 --- /dev/null +++ b/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/model/ssd_common.py @@ -0,0 +1,408 @@ +# Copyright 2015 Paul Balanca. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ============================================================================== +"""Shared function between different SSD implementations. +""" +import numpy as np +import tensorflow as tf +import tfextended as tfe + + +# =========================================================================== # +# TensorFlow implementation of boxes SSD encoding / decoding. +# =========================================================================== # +def tf_ssd_bboxes_encode_layer(labels, + bboxes, + anchors_layer, + num_classes, + ignore_threshold=0.5, + prior_scaling=[0.1, 0.1, 0.2, 0.2], + dtype=tf.float32): + """Encode groundtruth labels and bounding boxes using SSD anchors from + one layer. + + Arguments: + labels: 1D Tensor(int64) containing groundtruth labels; + bboxes: Nx4 Tensor(float) with bboxes relative coordinates; + anchors_layer: Numpy array with layer anchors; + matching_threshold: Threshold for positive match with groundtruth bboxes; + prior_scaling: Scaling of encoded coordinates. + + Return: + (target_labels, target_localizations, target_scores): Target Tensors. + """ + # Anchors coordinates and volume. + yref, xref, href, wref = anchors_layer + ymin = yref - href / 2. + xmin = xref - wref / 2. + ymax = yref + href / 2. + xmax = xref + wref / 2. + vol_anchors = (xmax - xmin) * (ymax - ymin) + + # Initialize tensors... + shape = (yref.shape[0], yref.shape[1], href.size) + feat_labels = tf.zeros(shape, dtype=tf.int64) + feat_scores = tf.zeros(shape, dtype=dtype) + + feat_ymin = tf.zeros(shape, dtype=dtype) + feat_xmin = tf.zeros(shape, dtype=dtype) + feat_ymax = tf.ones(shape, dtype=dtype) + feat_xmax = tf.ones(shape, dtype=dtype) + + def jaccard_with_anchors(bbox): + """Compute jaccard score between a box and the anchors. + """ + int_ymin = tf.maximum(ymin, bbox[0]) + int_xmin = tf.maximum(xmin, bbox[1]) + int_ymax = tf.minimum(ymax, bbox[2]) + int_xmax = tf.minimum(xmax, bbox[3]) + h = tf.maximum(int_ymax - int_ymin, 0.) + w = tf.maximum(int_xmax - int_xmin, 0.) + # Volumes. + inter_vol = h * w + union_vol = vol_anchors - inter_vol \ + + (bbox[2] - bbox[0]) * (bbox[3] - bbox[1]) + jaccard = tf.divide(inter_vol, union_vol) + return jaccard + + def intersection_with_anchors(bbox): + """Compute intersection between score a box and the anchors. + """ + int_ymin = tf.maximum(ymin, bbox[0]) + int_xmin = tf.maximum(xmin, bbox[1]) + int_ymax = tf.minimum(ymax, bbox[2]) + int_xmax = tf.minimum(xmax, bbox[3]) + h = tf.maximum(int_ymax - int_ymin, 0.) + w = tf.maximum(int_xmax - int_xmin, 0.) + inter_vol = h * w + scores = tf.divide(inter_vol, vol_anchors) + return scores + + def condition(i, feat_labels, feat_scores, + feat_ymin, feat_xmin, feat_ymax, feat_xmax): + """Condition: check label index. + """ + r = tf.less(i, tf.shape(labels)) + return r[0] + + def body(i, feat_labels, feat_scores, + feat_ymin, feat_xmin, feat_ymax, feat_xmax): + """Body: update feature labels, scores and bboxes. + Follow the original SSD paper for that purpose: + - assign values when jaccard > 0.5; + - only update if beat the score of other bboxes. + """ + # Jaccard score. + label = labels[i] + bbox = bboxes[i] + jaccard = jaccard_with_anchors(bbox) + # Mask: check threshold + scores + no annotations + num_classes. + mask = tf.greater(jaccard, feat_scores) + # mask = tf.logical_and(mask, tf.greater(jaccard, matching_threshold)) + mask = tf.logical_and(mask, feat_scores > -0.5) + mask = tf.logical_and(mask, label < num_classes) + imask = tf.cast(mask, tf.int64) + fmask = tf.cast(mask, dtype) + # Update values using mask. + feat_labels = imask * label + (1 - imask) * feat_labels + feat_scores = tf.where(mask, jaccard, feat_scores) + + feat_ymin = fmask * bbox[0] + (1 - fmask) * feat_ymin + feat_xmin = fmask * bbox[1] + (1 - fmask) * feat_xmin + feat_ymax = fmask * bbox[2] + (1 - fmask) * feat_ymax + feat_xmax = fmask * bbox[3] + (1 - fmask) * feat_xmax + + # Check no annotation label: ignore these anchors... + # interscts = intersection_with_anchors(bbox) + # mask = tf.logical_and(interscts > ignore_threshold, + # label == no_annotation_label) + # # Replace scores by -1. + # feat_scores = tf.where(mask, -tf.cast(mask, dtype), feat_scores) + + return [i+1, feat_labels, feat_scores, + feat_ymin, feat_xmin, feat_ymax, feat_xmax] + # Main loop definition. + i = 0 + [i, feat_labels, feat_scores, + feat_ymin, feat_xmin, + feat_ymax, feat_xmax] = tf.while_loop(condition, body, + [i, feat_labels, feat_scores, + feat_ymin, feat_xmin, + feat_ymax, feat_xmax]) + # Transform to center / size. + feat_cy = (feat_ymax + feat_ymin) / 2. + feat_cx = (feat_xmax + feat_xmin) / 2. + feat_h = feat_ymax - feat_ymin + feat_w = feat_xmax - feat_xmin + # Encode features. + feat_cy = (feat_cy - yref) / href / prior_scaling[0] + feat_cx = (feat_cx - xref) / wref / prior_scaling[1] + feat_h = tf.log(feat_h / href) / prior_scaling[2] + feat_w = tf.log(feat_w / wref) / prior_scaling[3] + # Use SSD ordering: x / y / w / h instead of ours. + feat_localizations = tf.stack([feat_cx, feat_cy, feat_w, feat_h], axis=-1) + return feat_labels, feat_localizations, feat_scores + + +def tf_ssd_bboxes_encode(labels, + bboxes, + anchors, + num_classes, + ignore_threshold=0.5, + prior_scaling=[0.1, 0.1, 0.2, 0.2], + dtype=tf.float32, + scope='ssd_bboxes_encode'): + """Encode groundtruth labels and bounding boxes using SSD net anchors. + Encoding boxes for all feature layers. + + Arguments: + labels: 1D Tensor(int64) containing groundtruth labels; + bboxes: Nx4 Tensor(float) with bboxes relative coordinates; + anchors: List of Numpy array with layer anchors; + matching_threshold: Threshold for positive match with groundtruth bboxes; + prior_scaling: Scaling of encoded coordinates. + + Return: + (target_labels, target_localizations, target_scores): + Each element is a list of target Tensors. + """ + with tf.name_scope(scope): + target_labels = [] + target_localizations = [] + target_scores = [] + for i, anchors_layer in enumerate(anchors): + with tf.name_scope('bboxes_encode_block_%i' % i): + t_labels, t_loc, t_scores = \ + tf_ssd_bboxes_encode_layer(labels, bboxes, anchors_layer, + num_classes, + ignore_threshold, + prior_scaling, dtype) + target_labels.append(t_labels) + target_localizations.append(t_loc) + target_scores.append(t_scores) + return target_labels, target_localizations, target_scores + + +def tf_ssd_bboxes_decode_layer(feat_localizations, + anchors_layer, + prior_scaling=[0.1, 0.1, 0.2, 0.2]): + """Compute the relative bounding boxes from the layer features and + reference anchor bounding boxes. + + Arguments: + feat_localizations: Tensor containing localization features. + anchors: List of numpy array containing anchor boxes. + + Return: + Tensor Nx4: ymin, xmin, ymax, xmax + """ + yref, xref, href, wref = anchors_layer + + # Compute center, height and width + cx = feat_localizations[:, :, :, :, 0] * wref * prior_scaling[0] + xref + cy = feat_localizations[:, :, :, :, 1] * href * prior_scaling[1] + yref + w = wref * tf.exp(feat_localizations[:, :, :, :, 2] * prior_scaling[2]) + h = href * tf.exp(feat_localizations[:, :, :, :, 3] * prior_scaling[3]) + # Boxes coordinates. + ymin = cy - h / 2. + xmin = cx - w / 2. + ymax = cy + h / 2. + xmax = cx + w / 2. + bboxes = tf.stack([ymin, xmin, ymax, xmax], axis=-1) + return bboxes + + +def tf_ssd_bboxes_decode(feat_localizations, + anchors, + prior_scaling=[0.1, 0.1, 0.2, 0.2], + scope='ssd_bboxes_decode'): + """Compute the relative bounding boxes from the SSD net features and + reference anchors bounding boxes. + + Arguments: + feat_localizations: List of Tensors containing localization features. + anchors: List of numpy array containing anchor boxes. + + Return: + List of Tensors Nx4: ymin, xmin, ymax, xmax + """ + with tf.name_scope(scope): + bboxes = [] + for i, anchors_layer in enumerate(anchors): + bboxes.append( + tf_ssd_bboxes_decode_layer(feat_localizations[i], + anchors_layer, + prior_scaling)) + return bboxes + + +# =========================================================================== # +# SSD boxes selection. +# =========================================================================== # +def tf_ssd_bboxes_select_layer(predictions_layer, localizations_layer, + select_threshold=None, + num_classes=21, + ignore_class=0, + scope=None): + """Extract classes, scores and bounding boxes from features in one layer. + Batch-compatible: inputs are supposed to have batch-type shapes. + + Args: + predictions_layer: A SSD prediction layer; + localizations_layer: A SSD localization layer; + select_threshold: Classification threshold for selecting a box. All boxes + under the threshold are set to 'zero'. If None, no threshold applied. + Return: + d_scores, d_bboxes: Dictionary of scores and bboxes Tensors of + size Batches X N x 1 | 4. Each key corresponding to a class. + """ + select_threshold = 0.0 if select_threshold is None else select_threshold + with tf.name_scope(scope, 'ssd_bboxes_select_layer', + [predictions_layer, localizations_layer]): + # Reshape features: Batches x N x N_labels | 4 + p_shape = tfe.get_shape(predictions_layer) + predictions_layer = tf.reshape(predictions_layer, + tf.stack([p_shape[0], -1, p_shape[-1]])) + l_shape = tfe.get_shape(localizations_layer) + localizations_layer = tf.reshape(localizations_layer, + tf.stack([l_shape[0], -1, l_shape[-1]])) + + d_scores = {} + d_bboxes = {} + for c in range(0, num_classes): + if c != ignore_class: + # Remove boxes under the threshold. + scores = predictions_layer[:, :, c] + fmask = tf.cast(tf.greater_equal(scores, select_threshold), scores.dtype) + scores = scores * fmask + bboxes = localizations_layer * tf.expand_dims(fmask, axis=-1) + # Append to dictionary. + d_scores[c] = scores + d_bboxes[c] = bboxes + + return d_scores, d_bboxes + + +def tf_ssd_bboxes_select(predictions_net, localizations_net, + select_threshold=None, + num_classes=21, + ignore_class=0, + scope=None): + """Extract classes, scores and bounding boxes from network output layers. + Batch-compatible: inputs are supposed to have batch-type shapes. + + Args: + predictions_net: List of SSD prediction layers; + localizations_net: List of localization layers; + select_threshold: Classification threshold for selecting a box. All boxes + under the threshold are set to 'zero'. If None, no threshold applied. + Return: + d_scores, d_bboxes: Dictionary of scores and bboxes Tensors of + size Batches X N x 1 | 4. Each key corresponding to a class. + """ + with tf.name_scope(scope, 'ssd_bboxes_select', + [predictions_net, localizations_net]): + l_scores = [] + l_bboxes = [] + for i in range(len(predictions_net)): + scores, bboxes = tf_ssd_bboxes_select_layer(predictions_net[i], + localizations_net[i], + select_threshold, + num_classes, + ignore_class) + l_scores.append(scores) + l_bboxes.append(bboxes) + # Concat results. + d_scores = {} + d_bboxes = {} + for c in l_scores[0].keys(): + ls = [s[c] for s in l_scores] + lb = [b[c] for b in l_bboxes] + d_scores[c] = tf.concat(ls, axis=1) + d_bboxes[c] = tf.concat(lb, axis=1) + return d_scores, d_bboxes + + +def tf_ssd_bboxes_select_layer_all_classes(predictions_layer, localizations_layer, + select_threshold=None): + """Extract classes, scores and bounding boxes from features in one layer. + Batch-compatible: inputs are supposed to have batch-type shapes. + + Args: + predictions_layer: A SSD prediction layer; + localizations_layer: A SSD localization layer; + select_threshold: Classification threshold for selecting a box. If None, + select boxes whose classification score is higher than 'no class'. + Return: + classes, scores, bboxes: Input Tensors. + """ + # Reshape features: Batches x N x N_labels | 4 + p_shape = tfe.get_shape(predictions_layer) + predictions_layer = tf.reshape(predictions_layer, + tf.stack([p_shape[0], -1, p_shape[-1]])) + l_shape = tfe.get_shape(localizations_layer) + localizations_layer = tf.reshape(localizations_layer, + tf.stack([l_shape[0], -1, l_shape[-1]])) + # Boxes selection: use threshold or score > no-label criteria. + if select_threshold is None or select_threshold == 0: + # Class prediction and scores: assign 0. to 0-class + classes = tf.argmax(predictions_layer, axis=2) + scores = tf.reduce_max(predictions_layer, axis=2) + scores = scores * tf.cast(classes > 0, scores.dtype) + else: + sub_predictions = predictions_layer[:, :, 1:] + classes = tf.argmax(sub_predictions, axis=2) + 1 + scores = tf.reduce_max(sub_predictions, axis=2) + # Only keep predictions higher than threshold. + mask = tf.greater(scores, select_threshold) + classes = classes * tf.cast(mask, classes.dtype) + scores = scores * tf.cast(mask, scores.dtype) + # Assume localization layer already decoded. + bboxes = localizations_layer + return classes, scores, bboxes + + +def tf_ssd_bboxes_select_all_classes(predictions_net, localizations_net, + select_threshold=None, + scope=None): + """Extract classes, scores and bounding boxes from network output layers. + Batch-compatible: inputs are supposed to have batch-type shapes. + + Args: + predictions_net: List of SSD prediction layers; + localizations_net: List of localization layers; + select_threshold: Classification threshold for selecting a box. If None, + select boxes whose classification score is higher than 'no class'. + Return: + classes, scores, bboxes: Tensors. + """ + with tf.name_scope(scope, 'ssd_bboxes_select', + [predictions_net, localizations_net]): + l_classes = [] + l_scores = [] + l_bboxes = [] + for i in range(len(predictions_net)): + classes, scores, bboxes = \ + tf_ssd_bboxes_select_layer_all_classes(predictions_net[i], + localizations_net[i], + select_threshold) + l_classes.append(classes) + l_scores.append(scores) + l_bboxes.append(bboxes) + + classes = tf.concat(l_classes, axis=1) + scores = tf.concat(l_scores, axis=1) + bboxes = tf.concat(l_bboxes, axis=1) + return classes, scores, bboxes + diff --git a/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/model/ssd_vgg_300.py b/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/model/ssd_vgg_300.py new file mode 100644 index 00000000..0b5d63ef --- /dev/null +++ b/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/model/ssd_vgg_300.py @@ -0,0 +1,660 @@ +# Copyright 2016 Paul Balanca. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ============================================================================== +"""Definition of 300 VGG-based SSD network. + +This model was initially introduced in: +SSD: Single Shot MultiBox Detector +Wei Liu, Dragomir Anguelov, Dumitru Erhan, Christian Szegedy, Scott Reed, +Cheng-Yang Fu, Alexander C. Berg +https://arxiv.org/abs/1512.02325 + +Two variants of the model are defined: the 300x300 and 512x512 models, the +latter obtaining a slightly better accuracy on Pascal VOC. + +Usage: + with slim.arg_scope(ssd_vgg.ssd_vgg()): + outputs, end_points = ssd_vgg.ssd_vgg(inputs) + +This network port of the original Caffe model. The padding in TF and Caffe +is slightly different, and can lead to severe accuracy drop if not taken care +in a correct way! + +In Caffe, the output size of convolution and pooling layers are computing as +following: h_o = (h_i + 2 * pad_h - kernel_h) / stride_h + 1 + +Nevertheless, there is a subtle difference between both for stride > 1. In +the case of convolution: + top_size = floor((bottom_size + 2*pad - kernel_size) / stride) + 1 +whereas for pooling: + top_size = ceil((bottom_size + 2*pad - kernel_size) / stride) + 1 +Hence implicitely allowing some additional padding even if pad = 0. This +behaviour explains why pooling with stride and kernel of size 2 are behaving +the same way in TensorFlow and Caffe. + +Nevertheless, this is not the case anymore for other kernel sizes, hence +motivating the use of special padding layer for controlling these side-effects. + +@@ssd_vgg_300 +""" +import math +from collections import namedtuple + +import numpy as np +import tensorflow as tf + +import tfextended as tfe +from model import custom_layers, ssd_common + +slim = tf.contrib.slim + + +# =========================================================================== # +# SSD class definition. +# =========================================================================== # +SSDParams = namedtuple('SSDParameters', ['img_shape', + 'num_classes', + 'no_annotation_label', + 'feat_layers', + 'feat_shapes', + 'anchor_size_bounds', + 'anchor_sizes', + 'anchor_ratios', + 'anchor_steps', + 'anchor_offset', + 'normalizations', + 'prior_scaling' + ]) + + +class SSDNet(object): + """Implementation of the SSD VGG-based 300 network. + + The default features layers with 300x300 image input are: + conv4 ==> 38 x 38 + conv7 ==> 19 x 19 + conv8 ==> 10 x 10 + conv9 ==> 5 x 5 + conv10 ==> 3 x 3 + conv11 ==> 1 x 1 + The default image size used to train this network is 300x300. + """ + default_params = SSDParams( + img_shape=(300, 300), + num_classes=21, + no_annotation_label=21, + feat_layers=['block4', 'block7', 'block8', 'block9', 'block10', 'block11'], + feat_shapes=[(37, 37), (19, 19), (10, 10), (5, 5), (3, 3), (1, 1)], + anchor_size_bounds=[0.15, 0.90], + # anchor_size_bounds=[0.20, 0.90], + anchor_sizes=[(21., 45.), + (45., 99.), + (99., 153.), + (153., 207.), + (207., 261.), + (261., 315.)], + # anchor_sizes=[(30., 60.), + # (60., 111.), + # (111., 162.), + # (162., 213.), + # (213., 264.), + # (264., 315.)], + anchor_ratios=[[2, .5], + [2, .5, 3, 1./3], + [2, .5, 3, 1./3], + [2, .5, 3, 1./3], + [2, .5], + [2, .5]], + anchor_steps=[8, 16, 32, 64, 100, 300], + anchor_offset=0.5, + normalizations=[20, -1, -1, -1, -1, -1], + prior_scaling=[0.1, 0.1, 0.2, 0.2] + ) + + def __init__(self, params=None): + """Init the SSD net with some parameters. Use the default ones + if none provided. + """ + if isinstance(params, SSDParams): + self.params = params + else: + self.params = SSDNet.default_params + + # ======================================================================= # + def net(self, inputs, + is_training=True, + update_feat_shapes=True, + dropout_keep_prob=0.5, + prediction_fn=slim.softmax, + reuse=None, + scope='ssd_300_vgg'): + """SSD network definition. + """ + r = ssd_net(inputs, + num_classes=self.params.num_classes, + feat_layers=self.params.feat_layers, + anchor_sizes=self.params.anchor_sizes, + anchor_ratios=self.params.anchor_ratios, + normalizations=self.params.normalizations, + is_training=is_training, + dropout_keep_prob=dropout_keep_prob, + prediction_fn=prediction_fn, + reuse=reuse, + scope=scope) + # Update feature shapes (try at least!) + if update_feat_shapes: + shapes = ssd_feat_shapes_from_net(r[0], self.params.feat_shapes) + self.params = self.params._replace(feat_shapes=shapes) + return r + + def arg_scope(self, weight_decay=0.0005, data_format='NHWC'): + """Network arg_scope. + """ + return ssd_arg_scope(weight_decay, data_format=data_format) + + def arg_scope_caffe(self, caffe_scope): + """Caffe arg_scope used for weights importing. + """ + return ssd_arg_scope_caffe(caffe_scope) + + # ======================================================================= # + def update_feature_shapes(self, predictions): + """Update feature shapes from predictions collection (Tensor or Numpy + array). + """ + shapes = ssd_feat_shapes_from_net(predictions, self.params.feat_shapes) + self.params = self.params._replace(feat_shapes=shapes) + + def anchors(self, img_shape, dtype=np.float32): + """Compute the default anchor boxes, given an image shape. + """ + return ssd_anchors_all_layers(img_shape, + self.params.feat_shapes, + self.params.anchor_sizes, + self.params.anchor_ratios, + self.params.anchor_steps, + self.params.anchor_offset, + dtype) + + def bboxes_encode(self, labels, bboxes, anchors, + scope=None): + """Encode labels and bounding boxes. + """ + return ssd_common.tf_ssd_bboxes_encode( + labels, bboxes, anchors, + self.params.num_classes, + ignore_threshold=0.5, + prior_scaling=self.params.prior_scaling, + scope=scope) + + def bboxes_decode(self, feat_localizations, anchors, + scope='ssd_bboxes_decode'): + """Encode labels and bounding boxes. + """ + return ssd_common.tf_ssd_bboxes_decode( + feat_localizations, anchors, + prior_scaling=self.params.prior_scaling, + scope=scope) + + def detected_bboxes(self, predictions, localisations, + select_threshold=None, nms_threshold=0.5, + clipping_bbox=None, top_k=400, keep_top_k=200): + """Get the detected bounding boxes from the SSD network output. + """ + # Select top_k bboxes from predictions, and clip + rscores, rbboxes = \ + ssd_common.tf_ssd_bboxes_select(predictions, localisations, + select_threshold=select_threshold, + num_classes=self.params.num_classes) + rscores, rbboxes = \ + tfe.bboxes_sort(rscores, rbboxes, top_k=top_k) + # Apply NMS algorithm. + rscores, rbboxes = \ + tfe.bboxes_nms_batch(rscores, rbboxes, + nms_threshold=nms_threshold, + keep_top_k=keep_top_k) + if clipping_bbox is not None: + rbboxes = tfe.bboxes_clip(clipping_bbox, rbboxes) + return rscores, rbboxes + + def losses(self, logits, localisations, + gclasses, glocalisations, gscores, + match_threshold=0.5, + negative_ratio=3., + alpha=1., + label_smoothing=0., + scope='ssd_losses'): + """Define the SSD network losses. + """ + return ssd_losses(logits, localisations, + gclasses, glocalisations, gscores, + match_threshold=match_threshold, + negative_ratio=negative_ratio, + alpha=alpha, + label_smoothing=label_smoothing, + scope=scope) + + +# =========================================================================== # +# SSD tools... +# =========================================================================== # +def ssd_size_bounds_to_values(size_bounds, + n_feat_layers, + img_shape=(300, 300)): + """Compute the reference sizes of the anchor boxes from relative bounds. + The absolute values are measured in pixels, based on the network + default size (300 pixels). + + This function follows the computation performed in the original + implementation of SSD in Caffe. + + Return: + list of list containing the absolute sizes at each scale. For each scale, + the ratios only apply to the first value. + """ + assert img_shape[0] == img_shape[1] + + img_size = img_shape[0] + min_ratio = int(size_bounds[0] * 100) + max_ratio = int(size_bounds[1] * 100) + step = int(math.floor((max_ratio - min_ratio) / (n_feat_layers - 2))) + # Start with the following smallest sizes. + sizes = [[img_size * size_bounds[0] / 2, img_size * size_bounds[0]]] + for ratio in range(min_ratio, max_ratio + 1, step): + sizes.append((img_size * ratio / 100., + img_size * (ratio + step) / 100.)) + return sizes + + +def ssd_feat_shapes_from_net(predictions, default_shapes=None): + """Try to obtain the feature shapes from the prediction layers. The latter + can be either a Tensor or Numpy ndarray. + + Return: + list of feature shapes. Default values if predictions shape not fully + determined. + """ + feat_shapes = [] + for l in predictions: + # Get the shape, from either a np array or a tensor. + if isinstance(l, np.ndarray): + shape = l.shape + else: + shape = l.get_shape().as_list() + shape = shape[1:4] + # Problem: undetermined shape... + if None in shape: + return default_shapes + else: + feat_shapes.append(shape) + return feat_shapes + + +def ssd_anchor_one_layer(img_shape, + feat_shape, + sizes, + ratios, + step, + offset=0.5, + dtype=np.float32): + """Computer SSD default anchor boxes for one feature layer. + + Determine the relative position grid of the centers, and the relative + width and height. + + Arguments: + feat_shape: Feature shape, used for computing relative position grids; + size: Absolute reference sizes; + ratios: Ratios to use on these features; + img_shape: Image shape, used for computing height, width relatively to the + former; + offset: Grid offset. + + Return: + y, x, h, w: Relative x and y grids, and height and width. + """ + # Compute the position grid: simple way. + # y, x = np.mgrid[0:feat_shape[0], 0:feat_shape[1]] + # y = (y.astype(dtype) + offset) / feat_shape[0] + # x = (x.astype(dtype) + offset) / feat_shape[1] + # Weird SSD-Caffe computation using steps values... + y, x = np.mgrid[0:feat_shape[0], 0:feat_shape[1]] + y = (y.astype(dtype) + offset) * step / img_shape[0] + x = (x.astype(dtype) + offset) * step / img_shape[1] + + # Expand dims to support easy broadcasting. + y = np.expand_dims(y, axis=-1) + x = np.expand_dims(x, axis=-1) + + # Compute relative height and width. + # Tries to follow the original implementation of SSD for the order. + num_anchors = len(sizes) + len(ratios) + h = np.zeros((num_anchors, ), dtype=dtype) + w = np.zeros((num_anchors, ), dtype=dtype) + # Add first anchor boxes with ratio=1. + h[0] = sizes[0] / img_shape[0] + w[0] = sizes[0] / img_shape[1] + di = 1 + if len(sizes) > 1: + h[1] = math.sqrt(sizes[0] * sizes[1]) / img_shape[0] + w[1] = math.sqrt(sizes[0] * sizes[1]) / img_shape[1] + di += 1 + for i, r in enumerate(ratios): + h[i+di] = sizes[0] / img_shape[0] / math.sqrt(r) + w[i+di] = sizes[0] / img_shape[1] * math.sqrt(r) + return y, x, h, w + + +def ssd_anchors_all_layers(img_shape, + layers_shape, + anchor_sizes, + anchor_ratios, + anchor_steps, + offset=0.5, + dtype=np.float32): + """Compute anchor boxes for all feature layers. + """ + layers_anchors = [] + for i, s in enumerate(layers_shape): + anchor_bboxes = ssd_anchor_one_layer(img_shape, s, + anchor_sizes[i], + anchor_ratios[i], + anchor_steps[i], + offset=offset, dtype=dtype) + layers_anchors.append(anchor_bboxes) + return layers_anchors + + +# =========================================================================== # +# Functional definition of VGG-based SSD 300. +# =========================================================================== # +def tensor_shape(x, rank=3): + """Returns the dimensions of a tensor. + Args: + image: A N-D Tensor of shape. + Returns: + A list of dimensions. Dimensions that are statically known are python + integers,otherwise they are integer scalar tensors. + """ + if x.get_shape().is_fully_defined(): + return x.get_shape().as_list() + else: + static_shape = x.get_shape().with_rank(rank).as_list() + dynamic_shape = tf.unstack(tf.shape(x), rank) + return [s if s is not None else d + for s, d in zip(static_shape, dynamic_shape)] + + +def ssd_multibox_layer(inputs, + num_classes, + sizes, + ratios=[1], + normalization=-1, + bn_normalization=False): + """Construct a multibox layer, return a class and localization predictions. + """ + net = inputs + if normalization > 0: + net = custom_layers.l2_normalization(net, scaling=True) + # Number of anchors. + num_anchors = len(sizes) + len(ratios) + + # Location. + num_loc_pred = num_anchors * 4 + loc_pred = slim.conv2d(net, num_loc_pred, [3, 3], activation_fn=None, + scope='conv_loc') + loc_pred = custom_layers.channel_to_last(loc_pred) + loc_pred = tf.reshape(loc_pred, + tensor_shape(loc_pred, 4)[:-1]+[num_anchors, 4]) + # Class prediction. + num_cls_pred = num_anchors * num_classes + cls_pred = slim.conv2d(net, num_cls_pred, [3, 3], activation_fn=None, + scope='conv_cls') + cls_pred = custom_layers.channel_to_last(cls_pred) + cls_pred = tf.reshape(cls_pred, + tensor_shape(cls_pred, 4)[:-1]+[num_anchors, num_classes]) + return cls_pred, loc_pred + + +def ssd_net(inputs, + num_classes=SSDNet.default_params.num_classes, + feat_layers=SSDNet.default_params.feat_layers, + anchor_sizes=SSDNet.default_params.anchor_sizes, + anchor_ratios=SSDNet.default_params.anchor_ratios, + normalizations=SSDNet.default_params.normalizations, + is_training=True, + dropout_keep_prob=0.5, + prediction_fn=slim.softmax, + reuse=None, + scope='ssd_300_vgg'): + """SSD net definition. + """ + # if data_format == 'NCHW': + # inputs = tf.transpose(inputs, perm=(0, 3, 1, 2)) + + # End_points collect relevant activations for external use. + end_points = {} + with tf.variable_scope(scope, 'ssd_300_vgg', [inputs], reuse=reuse): + # Original VGG-16 blocks. + net = slim.repeat(inputs, 2, slim.conv2d, 64, [3, 3], scope='conv1') + end_points['block1'] = net + net = slim.max_pool2d(net, [2, 2], scope='pool1') + # Block 2. + net = slim.repeat(net, 2, slim.conv2d, 128, [3, 3], scope='conv2') + end_points['block2'] = net + net = slim.max_pool2d(net, [2, 2], scope='pool2') + # Block 3. + net = slim.repeat(net, 3, slim.conv2d, 256, [3, 3], scope='conv3') + end_points['block3'] = net + net = slim.max_pool2d(net, [2, 2], scope='pool3') + # Block 4. + net = slim.repeat(net, 3, slim.conv2d, 512, [3, 3], scope='conv4') + end_points['block4'] = net + net = slim.max_pool2d(net, [2, 2], scope='pool4') + # Block 5. + net = slim.repeat(net, 3, slim.conv2d, 512, [3, 3], scope='conv5') + end_points['block5'] = net + net = slim.max_pool2d(net, [3, 3], stride=1, scope='pool5') + + # Additional SSD blocks. + # Block 6: let's dilate the hell out of it! + net = slim.conv2d(net, 1024, [3, 3], rate=6, scope='conv6') + end_points['block6'] = net + net = tf.layers.dropout(net, rate=dropout_keep_prob, training=is_training) + # Block 7: 1x1 conv. Because the fuck. + net = slim.conv2d(net, 1024, [1, 1], scope='conv7') + end_points['block7'] = net + net = tf.layers.dropout(net, rate=dropout_keep_prob, training=is_training) + + # Block 8/9/10/11: 1x1 and 3x3 convolutions stride 2 (except lasts). + end_point = 'block8' + with tf.variable_scope(end_point): + net = slim.conv2d(net, 256, [1, 1], scope='conv1x1') + net = custom_layers.pad2d(net, pad=(1, 1)) + net = slim.conv2d(net, 512, [3, 3], stride=2, scope='conv3x3', padding='VALID') + end_points[end_point] = net + end_point = 'block9' + with tf.variable_scope(end_point): + net = slim.conv2d(net, 128, [1, 1], scope='conv1x1') + net = custom_layers.pad2d(net, pad=(1, 1)) + net = slim.conv2d(net, 256, [3, 3], stride=2, scope='conv3x3', padding='VALID') + end_points[end_point] = net + end_point = 'block10' + with tf.variable_scope(end_point): + net = slim.conv2d(net, 128, [1, 1], scope='conv1x1') + net = slim.conv2d(net, 256, [3, 3], scope='conv3x3', padding='VALID') + end_points[end_point] = net + end_point = 'block11' + with tf.variable_scope(end_point): + net = slim.conv2d(net, 128, [1, 1], scope='conv1x1') + net = slim.conv2d(net, 256, [3, 3], scope='conv3x3', padding='VALID') + end_points[end_point] = net + + # Prediction and localisations layers. + predictions = [] + logits = [] + localisations = [] + for i, layer in enumerate(feat_layers): + with tf.variable_scope(layer + '_box'): + p, l = ssd_multibox_layer(end_points[layer], + num_classes, + anchor_sizes[i], + anchor_ratios[i], + normalizations[i]) + predictions.append(prediction_fn(p)) + logits.append(p) + localisations.append(l) + + return predictions, localisations, logits, end_points +ssd_net.default_image_size = 300 + + +def ssd_arg_scope(weight_decay=0.0005, data_format='NHWC'): + """Defines the VGG arg scope. + + Args: + weight_decay: The l2 regularization coefficient. + + Returns: + An arg_scope. + """ + with slim.arg_scope([slim.conv2d, slim.fully_connected], + activation_fn=tf.nn.relu, + weights_regularizer=slim.l2_regularizer(weight_decay), + weights_initializer=tf.contrib.layers.xavier_initializer(), + biases_initializer=tf.zeros_initializer()): + with slim.arg_scope([slim.conv2d, slim.max_pool2d], + padding='SAME', + data_format=data_format): + with slim.arg_scope([custom_layers.pad2d, + custom_layers.l2_normalization, + custom_layers.channel_to_last], + data_format=data_format) as sc: + return sc + + +# =========================================================================== # +# Caffe scope: importing weights at initialization. +# =========================================================================== # +def ssd_arg_scope_caffe(caffe_scope): + """Caffe scope definition. + + Args: + caffe_scope: Caffe scope object with loaded weights. + + Returns: + An arg_scope. + """ + # Default network arg scope. + with slim.arg_scope([slim.conv2d], + activation_fn=tf.nn.relu, + weights_initializer=caffe_scope.conv_weights_init(), + biases_initializer=caffe_scope.conv_biases_init()): + with slim.arg_scope([slim.fully_connected], + activation_fn=tf.nn.relu): + with slim.arg_scope([custom_layers.l2_normalization], + scale_initializer=caffe_scope.l2_norm_scale_init()): + with slim.arg_scope([slim.conv2d, slim.max_pool2d], + padding='SAME') as sc: + return sc + + +# =========================================================================== # +# SSD loss function. +# =========================================================================== # +def ssd_losses(logits, localisations, + gclasses, glocalisations, gscores, + match_threshold=0.5, + negative_ratio=3., + alpha=1., + label_smoothing=0., + device='/cpu:0', + scope=None): + with tf.name_scope(scope, 'ssd_losses'): + lshape = tfe.get_shape(logits[0], 5) + num_classes = lshape[-1] + batch_size = lshape[0] + + # Flatten out all vectors! + flogits = [] + fgclasses = [] + fgscores = [] + flocalisations = [] + fglocalisations = [] + for i in range(len(logits)): + flogits.append(tf.reshape(logits[i], [-1, num_classes])) + fgclasses.append(tf.reshape(gclasses[i], [-1])) + fgscores.append(tf.reshape(gscores[i], [-1])) + flocalisations.append(tf.reshape(localisations[i], [-1, 4])) + fglocalisations.append(tf.reshape(glocalisations[i], [-1, 4])) + # And concat the crap! + logits = tf.concat(flogits, axis=0) + gclasses = tf.concat(fgclasses, axis=0) + gscores = tf.concat(fgscores, axis=0) + localisations = tf.concat(flocalisations, axis=0) + glocalisations = tf.concat(fglocalisations, axis=0) + dtype = logits.dtype + + # Compute positive matching mask... + pmask = gscores > match_threshold + fpmask = tf.cast(pmask, dtype) + n_positives = tf.reduce_sum(fpmask) + + # Hard negative mining... + no_classes = tf.cast(pmask, tf.int32) + predictions = slim.softmax(logits) + nmask = tf.logical_and(tf.logical_not(pmask), + gscores > -0.5) + fnmask = tf.cast(nmask, dtype) + nvalues = tf.where(nmask, + predictions[:, 0], + 1. - fnmask) + nvalues_flat = tf.reshape(nvalues, [-1]) + # Number of negative entries to select. + max_neg_entries = tf.cast(tf.reduce_sum(fnmask), tf.int32) + n_neg = tf.cast(negative_ratio * n_positives, tf.int32) + batch_size + n_neg = tf.minimum(n_neg, max_neg_entries) + + val, idxes = tf.nn.top_k(-nvalues_flat, k=n_neg) + max_hard_pred = -val[-1] + # Final negative mask. + nmask = tf.logical_and(nmask, nvalues < max_hard_pred) + fnmask = tf.cast(nmask, dtype) + + batch_float = tf.cast(batch_size, tf.float32) + + # Add cross-entropy loss. + with tf.name_scope('cross_entropy_pos'): + cross_entropy_pos_loss = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=logits, + labels=gclasses) + cross_entropy_pos_loss = tf.divide(tf.reduce_sum(cross_entropy_pos_loss * fpmask), batch_float, name='value') + tf.losses.add_loss(cross_entropy_pos_loss) + + with tf.name_scope('cross_entropy_neg'): + cross_entropy_neg_loss = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=logits, + labels=no_classes) + cross_entropy_neg_loss = tf.divide(tf.reduce_sum(cross_entropy_neg_loss * fnmask), batch_float, name='value') + tf.losses.add_loss(cross_entropy_neg_loss) + + # Add localization loss: smooth L1, L2, ... + with tf.name_scope('localization'): + # Weights Tensor: positive mask + random negative. + weights = tf.expand_dims(alpha * fpmask, axis=-1) + localization_loss = custom_layers.abs_smooth(localisations - glocalisations) + localization_loss = tf.divide(tf.reduce_sum(localization_loss * weights), batch_float, name='value') + tf.losses.add_loss(localization_loss) + + regularization_losses = tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES) + all_losses = [cross_entropy_neg_loss, cross_entropy_pos_loss, localization_loss] + (regularization_losses if regularization_losses else []) + return tf.add_n(all_losses) \ No newline at end of file diff --git a/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/tfextended/__init__.py b/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/tfextended/__init__.py new file mode 100644 index 00000000..3ba75b6a --- /dev/null +++ b/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/tfextended/__init__.py @@ -0,0 +1,24 @@ +# Copyright 2017 Paul Balanca. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ============================================================================== +"""TF Extended: additional metrics. +""" + +# pylint: disable=unused-import,line-too-long,g-importing-member,wildcard-import +from tfextended.metrics import * +from tfextended.tensors import * +from tfextended.bboxes import * +from tfextended.image import * +from tfextended.math import * + diff --git a/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/tfextended/bboxes.py b/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/tfextended/bboxes.py new file mode 100644 index 00000000..0689b295 --- /dev/null +++ b/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/tfextended/bboxes.py @@ -0,0 +1,508 @@ +# Copyright 2017 Paul Balanca. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ============================================================================== +"""TF Extended: additional bounding boxes methods. +""" +import numpy as np +import tensorflow as tf + +from tfextended import tensors as tfe_tensors +from tfextended import math as tfe_math + + +# =========================================================================== # +# Standard boxes algorithms. +# =========================================================================== # +def bboxes_sort_all_classes(classes, scores, bboxes, top_k=400, scope=None): + """Sort bounding boxes by decreasing order and keep only the top_k. + Assume the input Tensors mix-up objects with different classes. + Assume a batch-type input. + + Args: + classes: Batch x N Tensor containing integer classes. + scores: Batch x N Tensor containing float scores. + bboxes: Batch x N x 4 Tensor containing boxes coordinates. + top_k: Top_k boxes to keep. + Return: + classes, scores, bboxes: Sorted tensors of shape Batch x Top_k. + """ + with tf.name_scope(scope, 'bboxes_sort', [classes, scores, bboxes]): + scores, idxes = tf.nn.top_k(scores, k=top_k, sorted=True) + + # Trick to be able to use tf.gather: map for each element in the batch. + def fn_gather(classes, bboxes, idxes): + cl = tf.gather(classes, idxes) + bb = tf.gather(bboxes, idxes) + return [cl, bb] + r = tf.map_fn(lambda x: fn_gather(x[0], x[1], x[2]), + [classes, bboxes, idxes], + dtype=[classes.dtype, bboxes.dtype], + parallel_iterations=10, + back_prop=False, + swap_memory=False, + infer_shape=True) + classes = r[0] + bboxes = r[1] + return classes, scores, bboxes + + +def bboxes_sort(scores, bboxes, top_k=400, scope=None): + """Sort bounding boxes by decreasing order and keep only the top_k. + If inputs are dictionnaries, assume every key is a different class. + Assume a batch-type input. + + Args: + scores: Batch x N Tensor/Dictionary containing float scores. + bboxes: Batch x N x 4 Tensor/Dictionary containing boxes coordinates. + top_k: Top_k boxes to keep. + Return: + scores, bboxes: Sorted Tensors/Dictionaries of shape Batch x Top_k x 1|4. + """ + # Dictionaries as inputs. + if isinstance(scores, dict) or isinstance(bboxes, dict): + with tf.name_scope(scope, 'bboxes_sort_dict'): + d_scores = {} + d_bboxes = {} + for c in scores.keys(): + s, b = bboxes_sort(scores[c], bboxes[c], top_k=top_k) + d_scores[c] = s + d_bboxes[c] = b + return d_scores, d_bboxes + + # Tensors inputs. + with tf.name_scope(scope, 'bboxes_sort', [scores, bboxes]): + # Sort scores... + scores, idxes = tf.nn.top_k(scores, k=top_k, sorted=True) + + # Trick to be able to use tf.gather: map for each element in the first dim. + def fn_gather(bboxes, idxes): + bb = tf.gather(bboxes, idxes) + return [bb] + r = tf.map_fn(lambda x: fn_gather(x[0], x[1]), + [bboxes, idxes], + dtype=[bboxes.dtype], + parallel_iterations=10, + back_prop=False, + swap_memory=False, + infer_shape=True) + bboxes = r[0] + return scores, bboxes + + +def bboxes_clip(bbox_ref, bboxes, scope=None): + """Clip bounding boxes to a reference box. + Batch-compatible if the first dimension of `bbox_ref` and `bboxes` + can be broadcasted. + + Args: + bbox_ref: Reference bounding box. Nx4 or 4 shaped-Tensor; + bboxes: Bounding boxes to clip. Nx4 or 4 shaped-Tensor or dictionary. + Return: + Clipped bboxes. + """ + # Bboxes is dictionary. + if isinstance(bboxes, dict): + with tf.name_scope(scope, 'bboxes_clip_dict'): + d_bboxes = {} + for c in bboxes.keys(): + d_bboxes[c] = bboxes_clip(bbox_ref, bboxes[c]) + return d_bboxes + + # Tensors inputs. + with tf.name_scope(scope, 'bboxes_clip'): + # Easier with transposed bboxes. Especially for broadcasting. + bbox_ref = tf.transpose(bbox_ref) + bboxes = tf.transpose(bboxes) + # Intersection bboxes and reference bbox. + ymin = tf.maximum(bboxes[0], bbox_ref[0]) + xmin = tf.maximum(bboxes[1], bbox_ref[1]) + ymax = tf.minimum(bboxes[2], bbox_ref[2]) + xmax = tf.minimum(bboxes[3], bbox_ref[3]) + # Double check! Empty boxes when no-intersection. + ymin = tf.minimum(ymin, ymax) + xmin = tf.minimum(xmin, xmax) + bboxes = tf.transpose(tf.stack([ymin, xmin, ymax, xmax], axis=0)) + return bboxes + + +def bboxes_resize(bbox_ref, bboxes, name=None): + """Resize bounding boxes based on a reference bounding box, + assuming that the latter is [0, 0, 1, 1] after transform. Useful for + updating a collection of boxes after cropping an image. + """ + # Bboxes is dictionary. + if isinstance(bboxes, dict): + with tf.name_scope(name, 'bboxes_resize_dict'): + d_bboxes = {} + for c in bboxes.keys(): + d_bboxes[c] = bboxes_resize(bbox_ref, bboxes[c]) + return d_bboxes + + # Tensors inputs. + with tf.name_scope(name, 'bboxes_resize'): + # Translate. + v = tf.stack([bbox_ref[0], bbox_ref[1], bbox_ref[0], bbox_ref[1]]) + bboxes = bboxes - v + # Scale. + s = tf.stack([bbox_ref[2] - bbox_ref[0], + bbox_ref[3] - bbox_ref[1], + bbox_ref[2] - bbox_ref[0], + bbox_ref[3] - bbox_ref[1]]) + bboxes = bboxes / s + return bboxes + + +def bboxes_nms(scores, bboxes, nms_threshold=0.5, keep_top_k=200, scope=None): + """Apply non-maximum selection to bounding boxes. In comparison to TF + implementation, use classes information for matching. + Should only be used on single-entries. Use batch version otherwise. + + Args: + scores: N Tensor containing float scores. + bboxes: N x 4 Tensor containing boxes coordinates. + nms_threshold: Matching threshold in NMS algorithm; + keep_top_k: Number of total object to keep after NMS. + Return: + classes, scores, bboxes Tensors, sorted by score. + Padded with zero if necessary. + """ + with tf.name_scope(scope, 'bboxes_nms_single', [scores, bboxes]): + # Apply NMS algorithm. + idxes = tf.image.non_max_suppression(bboxes, scores, + keep_top_k, nms_threshold) + scores = tf.gather(scores, idxes) + bboxes = tf.gather(bboxes, idxes) + # Pad results. + scores = tfe_tensors.pad_axis(scores, 0, keep_top_k, axis=0) + bboxes = tfe_tensors.pad_axis(bboxes, 0, keep_top_k, axis=0) + return scores, bboxes + + +def bboxes_nms_batch(scores, bboxes, nms_threshold=0.5, keep_top_k=200, + scope=None): + """Apply non-maximum selection to bounding boxes. In comparison to TF + implementation, use classes information for matching. + Use only on batched-inputs. Use zero-padding in order to batch output + results. + + Args: + scores: Batch x N Tensor/Dictionary containing float scores. + bboxes: Batch x N x 4 Tensor/Dictionary containing boxes coordinates. + nms_threshold: Matching threshold in NMS algorithm; + keep_top_k: Number of total object to keep after NMS. + Return: + scores, bboxes Tensors/Dictionaries, sorted by score. + Padded with zero if necessary. + """ + # Dictionaries as inputs. + if isinstance(scores, dict) or isinstance(bboxes, dict): + with tf.name_scope(scope, 'bboxes_nms_batch_dict'): + d_scores = {} + d_bboxes = {} + for c in scores.keys(): + s, b = bboxes_nms_batch(scores[c], bboxes[c], + nms_threshold=nms_threshold, + keep_top_k=keep_top_k) + d_scores[c] = s + d_bboxes[c] = b + return d_scores, d_bboxes + + # Tensors inputs. + with tf.name_scope(scope, 'bboxes_nms_batch'): + r = tf.map_fn(lambda x: bboxes_nms(x[0], x[1], + nms_threshold, keep_top_k), + (scores, bboxes), + dtype=(scores.dtype, bboxes.dtype), + parallel_iterations=10, + back_prop=False, + swap_memory=False, + infer_shape=True) + scores, bboxes = r + return scores, bboxes + + +# def bboxes_fast_nms(classes, scores, bboxes, +# nms_threshold=0.5, eta=3., num_classes=21, +# pad_output=True, scope=None): +# with tf.name_scope(scope, 'bboxes_fast_nms', +# [classes, scores, bboxes]): + +# nms_classes = tf.zeros((0,), dtype=classes.dtype) +# nms_scores = tf.zeros((0,), dtype=scores.dtype) +# nms_bboxes = tf.zeros((0, 4), dtype=bboxes.dtype) + + +def bboxes_matching(label, scores, bboxes, + glabels, gbboxes, gdifficults, + matching_threshold=0.5, scope=None): + """Matching a collection of detected boxes with groundtruth values. + Does not accept batched-inputs. + The algorithm goes as follows: for every detected box, check + if one grountruth box is matching. If none, then considered as False Positive. + If the grountruth box is already matched with another one, it also counts + as a False Positive. We refer the Pascal VOC documentation for the details. + + Args: + rclasses, rscores, rbboxes: N(x4) Tensors. Detected objects, sorted by score; + glabels, gbboxes: Groundtruth bounding boxes. May be zero padded, hence + zero-class objects are ignored. + matching_threshold: Threshold for a positive match. + Return: Tuple of: + n_gbboxes: Scalar Tensor with number of groundtruth boxes (may difer from + size because of zero padding). + tp_match: (N,)-shaped boolean Tensor containing with True Positives. + fp_match: (N,)-shaped boolean Tensor containing with False Positives. + """ + with tf.name_scope(scope, 'bboxes_matching_single', + [scores, bboxes, glabels, gbboxes]): + rsize = tf.size(scores) + rshape = tf.shape(scores) + rlabel = tf.cast(label, glabels.dtype) + # Number of groundtruth boxes. + gdifficults = tf.cast(gdifficults, tf.bool) + n_gbboxes = tf.count_nonzero(tf.logical_and(tf.equal(glabels, label), + tf.logical_not(gdifficults))) + # Grountruth matching arrays. + gmatch = tf.zeros(tf.shape(glabels), dtype=tf.bool) + grange = tf.range(tf.size(glabels), dtype=tf.int32) + # True/False positive matching TensorArrays. + sdtype = tf.bool + ta_tp_bool = tf.TensorArray(sdtype, size=rsize, dynamic_size=False, infer_shape=True) + ta_fp_bool = tf.TensorArray(sdtype, size=rsize, dynamic_size=False, infer_shape=True) + + # Loop over returned objects. + def m_condition(i, ta_tp, ta_fp, gmatch): + r = tf.less(i, rsize) + return r + + def m_body(i, ta_tp, ta_fp, gmatch): + # Jaccard score with groundtruth bboxes. + rbbox = bboxes[i] + jaccard = bboxes_jaccard(rbbox, gbboxes) + jaccard = jaccard * tf.cast(tf.equal(glabels, rlabel), dtype=jaccard.dtype) + + # Best fit, checking it's above threshold. + idxmax = tf.cast(tf.argmax(jaccard, axis=0), tf.int32) + jcdmax = jaccard[idxmax] + match = jcdmax > matching_threshold + existing_match = gmatch[idxmax] + not_difficult = tf.logical_not(gdifficults[idxmax]) + + # TP: match & no previous match and FP: previous match | no match. + # If difficult: no record, i.e FP=False and TP=False. + tp = tf.logical_and(not_difficult, + tf.logical_and(match, tf.logical_not(existing_match))) + ta_tp = ta_tp.write(i, tp) + fp = tf.logical_and(not_difficult, + tf.logical_or(existing_match, tf.logical_not(match))) + ta_fp = ta_fp.write(i, fp) + # Update grountruth match. + mask = tf.logical_and(tf.equal(grange, idxmax), + tf.logical_and(not_difficult, match)) + gmatch = tf.logical_or(gmatch, mask) + + return [i+1, ta_tp, ta_fp, gmatch] + # Main loop definition. + i = 0 + [i, ta_tp_bool, ta_fp_bool, gmatch] = \ + tf.while_loop(m_condition, m_body, + [i, ta_tp_bool, ta_fp_bool, gmatch], + parallel_iterations=1, + back_prop=False) + # TensorArrays to Tensors and reshape. + tp_match = tf.reshape(ta_tp_bool.stack(), rshape) + fp_match = tf.reshape(ta_fp_bool.stack(), rshape) + + # Some debugging information... + # tp_match = tf.Print(tp_match, + # [n_gbboxes, + # tf.reduce_sum(tf.cast(tp_match, tf.int64)), + # tf.reduce_sum(tf.cast(fp_match, tf.int64)), + # tf.reduce_sum(tf.cast(gmatch, tf.int64))], + # 'Matching (NG, TP, FP, GM): ') + return n_gbboxes, tp_match, fp_match + + +def bboxes_matching_batch(labels, scores, bboxes, + glabels, gbboxes, gdifficults, + matching_threshold=0.5, scope=None): + """Matching a collection of detected boxes with groundtruth values. + Batched-inputs version. + + Args: + rclasses, rscores, rbboxes: BxN(x4) Tensors. Detected objects, sorted by score; + glabels, gbboxes: Groundtruth bounding boxes. May be zero padded, hence + zero-class objects are ignored. + matching_threshold: Threshold for a positive match. + Return: Tuple or Dictionaries with: + n_gbboxes: Scalar Tensor with number of groundtruth boxes (may difer from + size because of zero padding). + tp: (B, N)-shaped boolean Tensor containing with True Positives. + fp: (B, N)-shaped boolean Tensor containing with False Positives. + """ + # Dictionaries as inputs. + if isinstance(scores, dict) or isinstance(bboxes, dict): + with tf.name_scope(scope, 'bboxes_matching_batch_dict'): + d_n_gbboxes = {} + d_tp = {} + d_fp = {} + for c in labels: + n, tp, fp, _ = bboxes_matching_batch(c, scores[c], bboxes[c], + glabels, gbboxes, gdifficults, + matching_threshold) + d_n_gbboxes[c] = n + d_tp[c] = tp + d_fp[c] = fp + return d_n_gbboxes, d_tp, d_fp, scores + + with tf.name_scope(scope, 'bboxes_matching_batch', + [scores, bboxes, glabels, gbboxes]): + r = tf.map_fn(lambda x: bboxes_matching(labels, x[0], x[1], + x[2], x[3], x[4], + matching_threshold), + (scores, bboxes, glabels, gbboxes, gdifficults), + dtype=(tf.int64, tf.bool, tf.bool), + parallel_iterations=10, + back_prop=False, + swap_memory=True, + infer_shape=True) + return r[0], r[1], r[2], scores + + +# =========================================================================== # +# Some filteting methods. +# =========================================================================== # +def bboxes_filter_center(labels, bboxes, margins=[0., 0., 0., 0.], + scope=None): + """Filter out bounding boxes whose center are not in + the rectangle [0, 0, 1, 1] + margins. The margin Tensor + can be used to enforce or loosen this condition. + + Return: + labels, bboxes: Filtered elements. + """ + with tf.name_scope(scope, 'bboxes_filter', [labels, bboxes]): + cy = (bboxes[:, 0] + bboxes[:, 2]) / 2. + cx = (bboxes[:, 1] + bboxes[:, 3]) / 2. + mask = tf.greater(cy, margins[0]) + mask = tf.logical_and(mask, tf.greater(cx, margins[1])) + mask = tf.logical_and(mask, tf.less(cx, 1. + margins[2])) + mask = tf.logical_and(mask, tf.less(cx, 1. + margins[3])) + # Boolean masking... + labels = tf.boolean_mask(labels, mask) + bboxes = tf.boolean_mask(bboxes, mask) + return labels, bboxes + + +def bboxes_filter_overlap(labels, bboxes, + threshold=0.5, assign_negative=False, + scope=None): + """Filter out bounding boxes based on (relative )overlap with reference + box [0, 0, 1, 1]. Remove completely bounding boxes, or assign negative + labels to the one outside (useful for latter processing...). + + Return: + labels, bboxes: Filtered (or newly assigned) elements. + """ + with tf.name_scope(scope, 'bboxes_filter', [labels, bboxes]): + scores = bboxes_intersection(tf.constant([0, 0, 1, 1], bboxes.dtype), + bboxes) + mask = scores > threshold + if assign_negative: + labels = tf.where(mask, labels, -labels) + # bboxes = tf.where(mask, bboxes, bboxes) + else: + labels = tf.boolean_mask(labels, mask) + bboxes = tf.boolean_mask(bboxes, mask) + return labels, bboxes + + +def bboxes_filter_labels(labels, bboxes, + out_labels=[], num_classes=np.inf, + scope=None): + """Filter out labels from a collection. Typically used to get + of DontCare elements. Also remove elements based on the number of classes. + + Return: + labels, bboxes: Filtered elements. + """ + with tf.name_scope(scope, 'bboxes_filter_labels', [labels, bboxes]): + mask = tf.greater_equal(labels, num_classes) + for l in labels: + mask = tf.logical_and(mask, tf.not_equal(labels, l)) + labels = tf.boolean_mask(labels, mask) + bboxes = tf.boolean_mask(bboxes, mask) + return labels, bboxes + + +# =========================================================================== # +# Standard boxes computation. +# =========================================================================== # +def bboxes_jaccard(bbox_ref, bboxes, name=None): + """Compute jaccard score between a reference box and a collection + of bounding boxes. + + Args: + bbox_ref: (N, 4) or (4,) Tensor with reference bounding box(es). + bboxes: (N, 4) Tensor, collection of bounding boxes. + Return: + (N,) Tensor with Jaccard scores. + """ + with tf.name_scope(name, 'bboxes_jaccard'): + # Should be more efficient to first transpose. + bboxes = tf.transpose(bboxes) + bbox_ref = tf.transpose(bbox_ref) + # Intersection bbox and volume. + int_ymin = tf.maximum(bboxes[0], bbox_ref[0]) + int_xmin = tf.maximum(bboxes[1], bbox_ref[1]) + int_ymax = tf.minimum(bboxes[2], bbox_ref[2]) + int_xmax = tf.minimum(bboxes[3], bbox_ref[3]) + h = tf.maximum(int_ymax - int_ymin, 0.) + w = tf.maximum(int_xmax - int_xmin, 0.) + # Volumes. + inter_vol = h * w + union_vol = -inter_vol \ + + (bboxes[2] - bboxes[0]) * (bboxes[3] - bboxes[1]) \ + + (bbox_ref[2] - bbox_ref[0]) * (bbox_ref[3] - bbox_ref[1]) + jaccard = tfe_math.safe_divide(inter_vol, union_vol, 'jaccard') + return jaccard + + +def bboxes_intersection(bbox_ref, bboxes, name=None): + """Compute relative intersection between a reference box and a + collection of bounding boxes. Namely, compute the quotient between + intersection area and box area. + + Args: + bbox_ref: (N, 4) or (4,) Tensor with reference bounding box(es). + bboxes: (N, 4) Tensor, collection of bounding boxes. + Return: + (N,) Tensor with relative intersection. + """ + with tf.name_scope(name, 'bboxes_intersection'): + # Should be more efficient to first transpose. + bboxes = tf.transpose(bboxes) + bbox_ref = tf.transpose(bbox_ref) + # Intersection bbox and volume. + int_ymin = tf.maximum(bboxes[0], bbox_ref[0]) + int_xmin = tf.maximum(bboxes[1], bbox_ref[1]) + int_ymax = tf.minimum(bboxes[2], bbox_ref[2]) + int_xmax = tf.minimum(bboxes[3], bbox_ref[3]) + h = tf.maximum(int_ymax - int_ymin, 0.) + w = tf.maximum(int_xmax - int_xmin, 0.) + # Volumes. + inter_vol = h * w + bboxes_vol = (bboxes[2] - bboxes[0]) * (bboxes[3] - bboxes[1]) + scores = tfe_math.safe_divide(inter_vol, bboxes_vol, 'intersection') + return scores diff --git a/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/tfextended/image.py b/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/tfextended/image.py new file mode 100644 index 00000000..e69de29b diff --git a/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/tfextended/math.py b/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/tfextended/math.py new file mode 100644 index 00000000..2e5359c5 --- /dev/null +++ b/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/tfextended/math.py @@ -0,0 +1,63 @@ +# Copyright 2017 Paul Balanca. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ============================================================================== +"""TF Extended: additional math functions. +""" +import tensorflow as tf + +from tensorflow.python.framework import ops + +def safe_divide(numerator, denominator, name): + """Divides two values, returning 0 if the denominator is <= 0. + Args: + numerator: A real `Tensor`. + denominator: A real `Tensor`, with dtype matching `numerator`. + name: Name for the returned op. + Returns: + 0 if `denominator` <= 0, else `numerator` / `denominator` + """ + return tf.where( + tf.greater(denominator, 0), + tf.divide(numerator, denominator), + tf.zeros_like(numerator), + name=name) + + +def cummax(x, reverse=False, name=None): + """Compute the cumulative maximum of the tensor `x` along `axis`. This + operation is similar to the more classic `cumsum`. Only support 1D Tensor + for now. + + Args: + x: A `Tensor`. Must be one of the following types: `float32`, `float64`, + `int64`, `int32`, `uint8`, `uint16`, `int16`, `int8`, `complex64`, + `complex128`, `qint8`, `quint8`, `qint32`, `half`. + axis: A `Tensor` of type `int32` (default: 0). + reverse: A `bool` (default: False). + name: A name for the operation (optional). + Returns: + A `Tensor`. Has the same type as `x`. + """ + with ops.name_scope(name, "Cummax", [x]) as name: + x = ops.convert_to_tensor(x, name="x") + # Not very optimal: should directly integrate reverse into tf.scan. + if reverse: + x = tf.reverse(x, axis=[0]) + # 'Accumlating' maximum: ensure it is always increasing. + cmax = tf.scan(tf.maximum, x, + initializer=None, parallel_iterations=1, + back_prop=False, swap_memory=False) + if reverse: + cmax = tf.reverse(cmax, axis=[0]) + return cmax diff --git a/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/tfextended/metrics.py b/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/tfextended/metrics.py new file mode 100644 index 00000000..42895291 --- /dev/null +++ b/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/tfextended/metrics.py @@ -0,0 +1,397 @@ +# Copyright 2017 Paul Balanca. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ============================================================================== +"""TF Extended: additional metrics. +""" +import tensorflow as tf +import numpy as np + +from tensorflow.contrib.framework.python.ops import variables as contrib_variables +from tensorflow.python.framework import dtypes +from tensorflow.python.framework import ops +from tensorflow.python.ops import array_ops +from tensorflow.python.ops import math_ops +from tensorflow.python.ops import nn +from tensorflow.python.ops import state_ops +from tensorflow.python.ops import variable_scope +from tensorflow.python.ops import variables + +from tfextended import math as tfe_math + + +# =========================================================================== # +# TensorFlow utils +# =========================================================================== # +def _create_local(name, shape, collections=None, validate_shape=False, + dtype=dtypes.float32): + """Creates a new local variable. + Args: + name: The name of the new or existing variable. + shape: Shape of the new or existing variable. + collections: A list of collection names to which the Variable will be added. + validate_shape: Whether to validate the shape of the variable. + dtype: Data type of the variables. + Returns: + The created variable. + """ + # Make sure local variables are added to tf.GraphKeys.LOCAL_VARIABLES + collections = list(collections or []) + collections += [ops.GraphKeys.LOCAL_VARIABLES] + return tf.Variable( + initial_value=array_ops.zeros(shape, dtype=dtype), + name=name, + trainable=False, + collections=collections, + validate_shape=validate_shape) + + +def _safe_div(numerator, denominator, name): + """Divides two values, returning 0 if the denominator is <= 0. + Args: + numerator: A real `Tensor`. + denominator: A real `Tensor`, with dtype matching `numerator`. + name: Name for the returned op. + Returns: + 0 if `denominator` <= 0, else `numerator` / `denominator` + """ + return tf.where( + tf.math.greater(denominator, 0), + tf.math.divide(numerator, denominator), + tf.zeros_like(numerator), + name=name) + + +def _broadcast_weights(weights, values): + """Broadcast `weights` to the same shape as `values`. + This returns a version of `weights` following the same broadcast rules as + `mul(weights, values)`. When computing a weighted average, use this function + to broadcast `weights` before summing them; e.g., + `reduce_sum(w * v) / reduce_sum(_broadcast_weights(w, v))`. + Args: + weights: `Tensor` whose shape is broadcastable to `values`. + values: `Tensor` of any shape. + Returns: + `weights` broadcast to `values` shape. + """ + weights_shape = weights.get_shape() + values_shape = values.get_shape() + if(weights_shape.is_fully_defined() and + values_shape.is_fully_defined() and + weights_shape.is_compatible_with(values_shape)): + return weights + return tf.math.multiply( + weights, array_ops.ones_like(values), name='broadcast_weights') + + +# =========================================================================== # +# TF Extended metrics: TP and FP arrays. +# =========================================================================== # +def precision_recall(num_gbboxes, num_detections, tp, fp, scores, + dtype=tf.float64, scope=None): + """Compute precision and recall from scores, true positives and false + positives booleans arrays + """ + # Input dictionaries: dict outputs as streaming metrics. + if isinstance(scores, dict): + d_precision = {} + d_recall = {} + for c in num_gbboxes.keys(): + scope = 'precision_recall_%s' % c + p, r = precision_recall(num_gbboxes[c], num_detections[c], + tp[c], fp[c], scores[c], + dtype, scope) + d_precision[c] = p + d_recall[c] = r + return d_precision, d_recall + + # Sort by score. + with tf.name_scope(scope, 'precision_recall', + [num_gbboxes, num_detections, tp, fp, scores]): + # Sort detections by score. + scores, idxes = tf.nn.top_k(scores, k=num_detections, sorted=True) + tp = tf.gather(tp, idxes) + fp = tf.gather(fp, idxes) + # Computer recall and precision. + tp = tf.cumsum(tf.cast(tp, dtype), axis=0) + fp = tf.cumsum(tf.cast(fp, dtype), axis=0) + recall = _safe_div(tp, tf.cast(num_gbboxes, dtype), 'recall') + precision = _safe_div(tp, tp + fp, 'precision') + return tf.tuple([precision, recall]) + + +def streaming_tp_fp_arrays(num_gbboxes, tp, fp, scores, + remove_zero_scores=True, + metrics_collections=None, + updates_collections=None, + name=None): + """Streaming computation of True and False Positive arrays. This metrics + also keeps track of scores and number of grountruth objects. + """ + # Input dictionaries: dict outputs as streaming metrics. + if isinstance(scores, dict) or isinstance(fp, dict): + d_values = {} + d_update_ops = {} + for c in num_gbboxes.keys(): + scope = 'streaming_tp_fp_%s' % c + v, up = streaming_tp_fp_arrays(num_gbboxes[c], tp[c], fp[c], scores[c], + remove_zero_scores, + metrics_collections, + updates_collections, + name=scope) + d_values[c] = v + d_update_ops[c] = up + return d_values, d_update_ops + + # Input Tensors... + with variable_scope.variable_scope(name, 'streaming_tp_fp', + [num_gbboxes, tp, fp, scores]): + num_gbboxes = tf.cast(num_gbboxes, dtype=tf.int64) + scores = tf.cast(scores, dtype=tf.float32) + stype = tf.bool + tp = tf.cast(tp, stype) + fp = tf.cast(fp, stype) + # Reshape TP and FP tensors and clean away 0 class values. + scores = tf.reshape(scores, [-1]) + tp = tf.reshape(tp, [-1]) + fp = tf.reshape(fp, [-1]) + # Remove TP and FP both false. + mask = tf.logical_or(tp, fp) + if remove_zero_scores: + rm_threshold = 1e-4 + mask = tf.logical_and(mask, tf.greater(scores, rm_threshold)) + scores = tf.boolean_mask(scores, mask) + tp = tf.boolean_mask(tp, mask) + fp = tf.boolean_mask(fp, mask) + + # Local variables accumlating information over batches. + v_nobjects = _create_local('v_num_gbboxes', shape=[], dtype=tf.int64) + v_ndetections = _create_local('v_num_detections', shape=[], dtype=tf.int32) + v_scores = _create_local('v_scores', shape=[0, ]) + v_tp = _create_local('v_tp', shape=[0, ], dtype=stype) + v_fp = _create_local('v_fp', shape=[0, ], dtype=stype) + + # Update operations. + nobjects_op = state_ops.assign_add(v_nobjects, + tf.reduce_sum(num_gbboxes)) + ndetections_op = state_ops.assign_add(v_ndetections, + tf.size(scores, out_type=tf.int32)) + scores_op = state_ops.assign(v_scores, tf.concat([v_scores, scores], axis=0), + validate_shape=False) + tp_op = state_ops.assign(v_tp, tf.concat([v_tp, tp], axis=0), + validate_shape=False) + fp_op = state_ops.assign(v_fp, tf.concat([v_fp, fp], axis=0), + validate_shape=False) + + # Value and update ops. + val = (v_nobjects, v_ndetections, v_tp, v_fp, v_scores) + with ops.control_dependencies([nobjects_op, ndetections_op, + scores_op, tp_op, fp_op]): + update_op = (nobjects_op, ndetections_op, tp_op, fp_op, scores_op) + + if metrics_collections: + ops.add_to_collections(metrics_collections, val) + if updates_collections: + ops.add_to_collections(updates_collections, update_op) + return val, update_op + + +# =========================================================================== # +# Average precision computations. +# =========================================================================== # +def average_precision_voc12(precision, recall, name=None): + """Compute (interpolated) average precision from precision and recall Tensors. + + The implementation follows Pascal 2012 and ILSVRC guidelines. + See also: https://sanchom.wordpress.com/tag/average-precision/ + """ + with tf.name_scope(name, 'average_precision_voc12', [precision, recall]): + # Convert to float64 to decrease error on Riemann sums. + precision = tf.cast(precision, dtype=tf.float64) + recall = tf.cast(recall, dtype=tf.float64) + + # Add bounds values to precision and recall. + precision = tf.concat([[0.], precision, [0.]], axis=0) + recall = tf.concat([[0.], recall, [1.]], axis=0) + # Ensures precision is increasing in reverse order. + precision = tfe_math.cummax(precision, reverse=True) + + # Riemann sums for estimating the integral. + # mean_pre = (precision[1:] + precision[:-1]) / 2. + mean_pre = precision[1:] + diff_rec = recall[1:] - recall[:-1] + ap = tf.reduce_sum(mean_pre * diff_rec) + return ap + + +def average_precision_voc07(precision, recall, name=None): + """Compute (interpolated) average precision from precision and recall Tensors. + + The implementation follows Pascal 2007 guidelines. + See also: https://sanchom.wordpress.com/tag/average-precision/ + """ + with tf.name_scope(name, 'average_precision_voc07', [precision, recall]): + # Convert to float64 to decrease error on cumulated sums. + precision = tf.cast(precision, dtype=tf.float64) + recall = tf.cast(recall, dtype=tf.float64) + # Add zero-limit value to avoid any boundary problem... + precision = tf.concat([precision, [0.]], axis=0) + recall = tf.concat([recall, [np.inf]], axis=0) + + # Split the integral into 10 bins. + l_aps = [] + for t in np.arange(0., 1.1, 0.1): + mask = tf.greater_equal(recall, t) + v = tf.reduce_max(tf.boolean_mask(precision, mask)) + l_aps.append(v / 11.) + ap = tf.add_n(l_aps) + return ap + + +def precision_recall_values(xvals, precision, recall, name=None): + """Compute values on the precision/recall curve. + + Args: + x: Python list of floats; + precision: 1D Tensor decreasing. + recall: 1D Tensor increasing. + Return: + list of precision values. + """ + with ops.name_scope(name, "precision_recall_values", + [precision, recall]) as name: + # Add bounds values to precision and recall. + precision = tf.concat([[0.], precision, [0.]], axis=0) + recall = tf.concat([[0.], recall, [1.]], axis=0) + precision = tfe_math.cummax(precision, reverse=True) + + prec_values = [] + for x in xvals: + mask = tf.less_equal(recall, x) + val = tf.reduce_min(tf.boolean_mask(precision, mask)) + prec_values.append(val) + return tf.tuple(prec_values) + + +# =========================================================================== # +# TF Extended metrics: old stuff! +# =========================================================================== # +def _precision_recall(n_gbboxes, n_detections, scores, tp, fp, scope=None): + """Compute precision and recall from scores, true positives and false + positives booleans arrays + """ + # Sort by score. + with tf.name_scope(scope, 'prec_rec', [n_gbboxes, scores, tp, fp]): + # Sort detections by score. + scores, idxes = tf.nn.top_k(scores, k=n_detections, sorted=True) + tp = tf.gather(tp, idxes) + fp = tf.gather(fp, idxes) + # Computer recall and precision. + dtype = tf.float64 + tp = tf.cumsum(tf.cast(tp, dtype), axis=0) + fp = tf.cumsum(tf.cast(fp, dtype), axis=0) + recall = _safe_div(tp, tf.cast(n_gbboxes, dtype), 'recall') + precision = _safe_div(tp, tp + fp, 'precision') + + return tf.tuple([precision, recall]) + + +def streaming_precision_recall_arrays(n_gbboxes, rclasses, rscores, + tp_tensor, fp_tensor, + remove_zero_labels=True, + metrics_collections=None, + updates_collections=None, + name=None): + """Streaming computation of precision / recall arrays. This metrics + keeps tracks of boolean True positives and False positives arrays. + """ + with variable_scope.variable_scope(name, 'stream_precision_recall', + [n_gbboxes, rclasses, tp_tensor, fp_tensor]): + n_gbboxes = tf.cast(n_gbboxes, tf.int64) + rclasses = tf.cast(rclasses, tf.int64) + rscores = tf.cast(rscores, tf.float) + + stype = tf.int32 + tp_tensor = tf.cast(tp_tensor, stype) + fp_tensor = tf.cast(fp_tensor, stype) + + # Reshape TP and FP tensors and clean away 0 class values. + rclasses = tf.reshape(rclasses, [-1]) + rscores = tf.reshape(rscores, [-1]) + tp_tensor = tf.reshape(tp_tensor, [-1]) + fp_tensor = tf.reshape(fp_tensor, [-1]) + if remove_zero_labels: + mask = tf.greater(rclasses, 0) + rclasses = tf.boolean_mask(rclasses, mask) + rscores = tf.boolean_mask(rscores, mask) + tp_tensor = tf.boolean_mask(tp_tensor, mask) + fp_tensor = tf.boolean_mask(fp_tensor, mask) + + # Local variables accumlating information over batches. + v_nobjects = _create_local('v_nobjects', shape=[], dtype=tf.int64) + v_ndetections = _create_local('v_ndetections', shape=[], dtype=tf.int32) + v_scores = _create_local('v_scores', shape=[0, ]) + v_tp = _create_local('v_tp', shape=[0, ], dtype=stype) + v_fp = _create_local('v_fp', shape=[0, ], dtype=stype) + + # Update operations. + nobjects_op = state_ops.assign_add(v_nobjects, + tf.reduce_sum(n_gbboxes)) + ndetections_op = state_ops.assign_add(v_ndetections, + tf.size(rscores, out_type=tf.int32)) + scores_op = state_ops.assign(v_scores, tf.concat([v_scores, rscores], axis=0), + validate_shape=False) + tp_op = state_ops.assign(v_tp, tf.concat([v_tp, tp_tensor], axis=0), + validate_shape=False) + fp_op = state_ops.assign(v_fp, tf.concat([v_fp, fp_tensor], axis=0), + validate_shape=False) + + # Precision and recall computations. + # r = _precision_recall(nobjects_op, scores_op, tp_op, fp_op, 'value') + r = _precision_recall(v_nobjects, v_ndetections, v_scores, + v_tp, v_fp, 'value') + + with ops.control_dependencies([nobjects_op, ndetections_op, + scores_op, tp_op, fp_op]): + update_op = _precision_recall(nobjects_op, ndetections_op, + scores_op, tp_op, fp_op, 'update_op') + + # update_op = tf.Print(update_op, + # [tf.reduce_sum(tf.cast(mask, tf.int64)), + # tf.reduce_sum(tf.cast(mask2, tf.int64)), + # tf.reduce_min(rscores), + # tf.reduce_sum(n_gbboxes)], + # 'Metric: ') + # Some debugging stuff! + # update_op = tf.Print(update_op, + # [tf.shape(tp_op), + # tf.reduce_sum(tf.cast(tp_op, tf.int64), axis=0)], + # 'TP and FP shape: ') + # update_op[0] = tf.Print(update_op, + # [nobjects_op], + # '# Groundtruth bboxes: ') + # update_op = tf.Print(update_op, + # [update_op[0][0], + # update_op[0][-1], + # tf.reduce_min(update_op[0]), + # tf.reduce_max(update_op[0]), + # tf.reduce_min(update_op[1]), + # tf.reduce_max(update_op[1])], + # 'Precision and recall :') + + if metrics_collections: + ops.add_to_collections(metrics_collections, r) + if updates_collections: + ops.add_to_collections(updates_collections, update_op) + return r, update_op + diff --git a/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/tfextended/tensors.py b/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/tfextended/tensors.py new file mode 100644 index 00000000..f2d561bc --- /dev/null +++ b/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/tfextended/tensors.py @@ -0,0 +1,95 @@ +# Copyright 2017 Paul Balanca. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ============================================================================== +"""TF Extended: additional tensors operations. +""" +import tensorflow as tf + +from tensorflow.contrib.framework.python.ops import variables as contrib_variables +from tensorflow.contrib.metrics.python.ops import set_ops +from tensorflow.python.framework import dtypes +from tensorflow.python.framework import ops +from tensorflow.python.framework import sparse_tensor +from tensorflow.python.ops import array_ops +from tensorflow.python.ops import check_ops +from tensorflow.python.ops import control_flow_ops +from tensorflow.python.ops import math_ops +from tensorflow.python.ops import nn +from tensorflow.python.ops import state_ops +from tensorflow.python.ops import variable_scope +from tensorflow.python.ops import variables + + +def get_shape(x, rank=None): + """Returns the dimensions of a Tensor as list of integers or scale tensors. + + Args: + x: N-d Tensor; + rank: Rank of the Tensor. If None, will try to guess it. + Returns: + A list of `[d1, d2, ..., dN]` corresponding to the dimensions of the + input tensor. Dimensions that are statically known are python integers, + otherwise they are integer scalar tensors. + """ + if x.get_shape().is_fully_defined(): + return x.get_shape().as_list() + else: + static_shape = x.get_shape() + if rank is None: + static_shape = static_shape.as_list() + rank = len(static_shape) + else: + static_shape = x.get_shape().with_rank(rank).as_list() + dynamic_shape = tf.unstack(tf.shape(x), rank) + return [s if s is not None else d + for s, d in zip(static_shape, dynamic_shape)] + + +def pad_axis(x, offset, size, axis=0, name=None): + """Pad a tensor on an axis, with a given offset and output size. + The tensor is padded with zero (i.e. CONSTANT mode). Note that the if the + `size` is smaller than existing size + `offset`, the output tensor + was the latter dimension. + + Args: + x: Tensor to pad; + offset: Offset to add on the dimension chosen; + size: Final size of the dimension. + Return: + Padded tensor whose dimension on `axis` is `size`, or greater if + the input vector was larger. + """ + with tf.name_scope(name, 'pad_axis'): + shape = get_shape(x) + rank = len(shape) + # Padding description. + new_size = tf.maximum(size-offset-shape[axis], 0) + pad1 = tf.stack([0]*axis + [offset] + [0]*(rank-axis-1)) + pad2 = tf.stack([0]*axis + [new_size] + [0]*(rank-axis-1)) + paddings = tf.stack([pad1, pad2], axis=1) + x = tf.pad(x, paddings, mode='CONSTANT') + # Reshape, to get fully defined shape if possible. + # TODO: fix with tf.slice + shape[axis] = size + x = tf.reshape(x, tf.stack(shape)) + return x + + +# def select_at_index(idx, val, t): +# """Return a tensor. +# """ +# idx = tf.expand_dims(tf.expand_dims(idx, 0), 0) +# val = tf.expand_dims(val, 0) +# t = t + tf.scatter_nd(idx, val, tf.shape(t)) +# return t diff --git a/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/tfutil/__init__.py b/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/tfutil/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/tfutil/endpoints.py b/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/tfutil/endpoints.py new file mode 100644 index 00000000..c6a46df4 --- /dev/null +++ b/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/tfutil/endpoints.py @@ -0,0 +1,20 @@ +''' +Endpoint names to look for in the graph +''' + +from anchors import generate_anchors + +feat_layers = generate_anchors.feat_layers +sub_feats = [''] +localizations_names = [f'ssd_300_vgg/{feature}_box/Reshape:0' for feature in feat_layers] + +predictions_names = ['ssd_300_vgg/softmax/Reshape_1:0'] \ + + [f'ssd_300_vgg/softmax_{n}/Reshape_1:0' for n in range(1, len(feat_layers))] + +logit_names = [f'ssd_300_vgg/{feature}_box/Reshape_1:0' for feature in feat_layers] + +endpoint_names = ['ssd_300_vgg/conv1/conv1_2/Relu:0'] \ + + [f'ssd_300_vgg/conv{n}/conv{n}_3/Relu:0' for n in range(4, 6)] \ + + [f'ssd_300_vgg/conv{n}/conv{n}_{n}/Relu:0' for n in range(2, 4)] \ + + [f'ssd_300_vgg/conv{n}/Relu:0' for n in range(6, 8)] \ + + [f'ssd_300_vgg/{feature}/conv3x3/Relu:0' for feature in feat_layers if feature != 'block4' and feature != 'block7'] \ No newline at end of file diff --git a/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/tfutil/tf_utils.py b/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/tfutil/tf_utils.py new file mode 100644 index 00000000..a17fa3c1 --- /dev/null +++ b/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/tfutil/tf_utils.py @@ -0,0 +1,158 @@ +# Copyright 2016 Paul Balanca. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ============================================================================= +"""Diverse TensorFlow utils, for training, evaluation and so on! +""" +import os + +import tensorflow as tf + +# =========================================================================== # +# General tools. +# =========================================================================== # +def reshape_list(l, shape=None): + """Reshape list of (list): 1D to 2D or the other way around. + + Args: + l: List or List of list. + shape: 1D or 2D shape. + Return + Reshaped list. + """ + r = [] + if shape is None: + # Flatten everything. + for a in l: + if isinstance(a, (list, tuple)): + r = r + list(a) + else: + r.append(a) + else: + # Reshape to list of list. + i = 0 + for s in shape: + if s == 1: + r.append(l[i]) + else: + r.append(l[i:i+s]) + i += s + return r + +def configure_learning_rate(flags, num_samples_per_epoch, global_step): + """Configures the learning rate. + + Args: + num_samples_per_epoch: The number of samples in each epoch of training. + global_step: The global_step tensor. + Returns: + A `Tensor` representing the learning rate. + """ + decay_steps = int(num_samples_per_epoch / flags.batch_size * + flags.num_epochs_per_decay) + + if flags.learning_rate_decay_type == 'exponential': + return tf.train.exponential_decay(flags.learning_rate, + global_step, + decay_steps, + flags.learning_rate_decay_factor, + staircase=True, + name='exponential_decay_learning_rate') + elif flags.learning_rate_decay_type == 'fixed': + return tf.constant(flags.learning_rate, name='fixed_learning_rate') + elif flags.learning_rate_decay_type == 'polynomial': + return tf.train.polynomial_decay(flags.learning_rate, + global_step, + decay_steps, + flags.end_learning_rate, + power=1.0, + cycle=False, + name='polynomial_decay_learning_rate') + else: + raise ValueError('learning_rate_decay_type [%s] was not recognized', + flags.learning_rate_decay_type) + + +def configure_optimizer(flags, learning_rate): + """Configures the optimizer used for training. + + Args: + learning_rate: A scalar or `Tensor` learning rate. + Returns: + An instance of an optimizer. + """ + if flags.optimizer == 'adadelta': + optimizer = tf.train.AdadeltaOptimizer( + learning_rate, + rho=flags.adadelta_rho, + epsilon=flags.opt_epsilon) + elif flags.optimizer == 'adagrad': + optimizer = tf.train.AdagradOptimizer( + learning_rate, + initial_accumulator_value=flags.adagrad_initial_accumulator_value) + elif flags.optimizer == 'adam': + optimizer = tf.train.AdamOptimizer( + learning_rate, + beta1=flags.adam_beta1, + beta2=flags.adam_beta2, + epsilon=flags.opt_epsilon) + elif flags.optimizer == 'ftrl': + optimizer = tf.train.FtrlOptimizer( + learning_rate, + learning_rate_power=flags.ftrl_learning_rate_power, + initial_accumulator_value=flags.ftrl_initial_accumulator_value, + l1_regularization_strength=flags.ftrl_l1, + l2_regularization_strength=flags.ftrl_l2) + elif flags.optimizer == 'momentum': + optimizer = tf.train.MomentumOptimizer( + learning_rate, + momentum=flags.momentum, + name='Momentum') + elif flags.optimizer == 'rmsprop': + optimizer = tf.train.RMSPropOptimizer( + learning_rate, + decay=flags.rmsprop_decay, + momentum=flags.rmsprop_momentum, + epsilon=flags.opt_epsilon) + elif flags.optimizer == 'sgd': + optimizer = tf.train.GradientDescentOptimizer(learning_rate) + else: + raise ValueError('Optimizer [%s] was not recognized', flags.optimizer) + return optimizer + + +def update_model_scope(var, ckpt_scope, new_scope): + return var.op.name.replace(new_scope,'vgg_16') + + +def get_variables_to_train(flags): + """Returns a list of variables to train. + + Returns: + A list of variables to train by the optimizer. + """ + if flags.trainable_scopes is None: + return tf.trainable_variables() + else: + scopes = [scope.strip() for scope in flags.trainable_scopes.split(',')] + + variables_to_train = [] + for scope in scopes: + variables = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope) + variables_to_train.extend(variables) + return variables_to_train + + +# =========================================================================== # +# Evaluation utils. +# =========================================================================== # diff --git a/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/tfutil/visualization.py b/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/tfutil/visualization.py new file mode 100644 index 00000000..227655d2 --- /dev/null +++ b/how-to-use-azureml/deployment/accelerated-models/finetune-ssd-vgg/tfssd/tfutil/visualization.py @@ -0,0 +1,114 @@ +# Copyright 2017 Paul Balanca. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ============================================================================== +import cv2 +import random + +import matplotlib.pyplot as plt +import matplotlib.image as mpimg +import matplotlib.cm as mpcm + + +# =========================================================================== # +# Some colormaps. +# =========================================================================== # +def colors_subselect(colors, num_classes=21): + dt = len(colors) // num_classes + sub_colors = [] + for i in range(num_classes): + color = colors[i*dt] + if isinstance(color[0], float): + sub_colors.append([int(c * 255) for c in color]) + else: + sub_colors.append([c for c in color]) + return sub_colors + +colors_plasma = colors_subselect(mpcm.plasma.colors, num_classes=21) +colors_tableau = [(255, 255, 255), (31, 119, 180), (174, 199, 232), (255, 127, 14), (255, 187, 120), + (44, 160, 44), (152, 223, 138), (214, 39, 40), (255, 152, 150), + (148, 103, 189), (197, 176, 213), (140, 86, 75), (196, 156, 148), + (227, 119, 194), (247, 182, 210), (127, 127, 127), (199, 199, 199), + (188, 189, 34), (219, 219, 141), (23, 190, 207), (158, 218, 229)] + + +# =========================================================================== # +# OpenCV drawing. +# =========================================================================== # +def draw_lines(img, lines, color=[255, 0, 0], thickness=2): + """Draw a collection of lines on an image. + """ + for line in lines: + for x1, y1, x2, y2 in line: + cv2.line(img, (x1, y1), (x2, y2), color, thickness) + + +def draw_rectangle(img, p1, p2, color=[255, 0, 0], thickness=2): + cv2.rectangle(img, p1[::-1], p2[::-1], color, thickness) + + +def draw_bbox(img, bbox, shape, label, color=[255, 0, 0], thickness=2): + p1 = (int(bbox[0] * shape[0]), int(bbox[1] * shape[1])) + p2 = (int(bbox[2] * shape[0]), int(bbox[3] * shape[1])) + cv2.rectangle(img, p1[::-1], p2[::-1], color, thickness) + p1 = (p1[0]+15, p1[1]) + cv2.putText(img, str(label), p1[::-1], cv2.FONT_HERSHEY_DUPLEX, 0.5, color, 1) + + +def bboxes_draw_on_img(img, classes, scores, bboxes, colors, thickness=2): + shape = img.shape + for i in range(bboxes.shape[0]): + bbox = bboxes[i] + color = colors[classes[i]] + # Draw bounding box... + p1 = (int(bbox[0] * shape[0]), int(bbox[1] * shape[1])) + p2 = (int(bbox[2] * shape[0]), int(bbox[3] * shape[1])) + cv2.rectangle(img, p1[::-1], p2[::-1], color, thickness) + # Draw text... + s = '%s/%.3f' % (classes[i], scores[i]) + p1 = (p1[0]-5, p1[1]) + cv2.putText(img, s, p1[::-1], cv2.FONT_HERSHEY_DUPLEX, 0.4, color, 1) + + +# =========================================================================== # +# Matplotlib show... +# =========================================================================== # +def plt_bboxes(img, classes, scores, bboxes, figsize=(10,10), linewidth=1.5): + """Visualize bounding boxes. Largely inspired by SSD-MXNET! + """ + fig = plt.figure(figsize=figsize) + plt.imshow(img) + height = img.shape[0] + width = img.shape[1] + colors = dict() + for i in range(classes.shape[0]): + cls_id = int(classes[i]) + if cls_id >= 0: + score = scores[i] + if cls_id not in colors: + colors[cls_id] = (random.random(), random.random(), random.random()) + ymin = int(bboxes[i, 0] * height) + xmin = int(bboxes[i, 1] * width) + ymax = int(bboxes[i, 2] * height) + xmax = int(bboxes[i, 3] * width) + rect = plt.Rectangle((xmin, ymin), xmax - xmin, + ymax - ymin, fill=False, + edgecolor=colors[cls_id], + linewidth=linewidth) + plt.gca().add_patch(rect) + class_name = str(cls_id) + plt.gca().text(xmin, ymin - 2, + '{:s} | {:.3f}'.format(class_name, score), + bbox=dict(facecolor=colors[cls_id], alpha=0.5), + fontsize=12, color='white') + plt.show()