diff --git a/introduction_to_applying_machine_learning/README.md b/introduction_to_applying_machine_learning/README.md index 45416e7ddb..0ae87b84a5 100644 --- a/introduction_to_applying_machine_learning/README.md +++ b/introduction_to_applying_machine_learning/README.md @@ -14,3 +14,4 @@ These examples provide a gentle introduction to machine learning concepts as the - [Population Segmentation of US Census Data using PCA and Kmeans](US-census_population_segmentation_PCA_Kmeans) analyzes US census data and reduces dimensionality using PCA then clusters US counties using KMeans to identify segments of similar counties. - [Document Embedding using Object2Vec](object2vec_document_embedding) is an example to embed a large collection of documents in a common low-dimensional space, so that the semantic distances between these documents are preserved. - [Traffic violations forecasting using DeepAR](deepar_chicago_traffic_violations) is an example to use daily traffic violation data to predict pattern and seasonality to use Amazon DeepAR alogorithm. +- [Visual Inspection Automation with Pre-trained Amazon SageMaker Models](visual_object_detection) is an example for fine-tuning pre-trained Amazon Sagemaker models on a target dataset. diff --git a/introduction_to_applying_machine_learning/visual_object_detection/README.md b/introduction_to_applying_machine_learning/visual_object_detection/README.md new file mode 100644 index 0000000000..d592972b0e --- /dev/null +++ b/introduction_to_applying_machine_learning/visual_object_detection/README.md @@ -0,0 +1,145 @@ +# Visual Inspection Automation with Pre-trained Amazon SageMaker Models + +This solution detects product defects with an end-to-end Deep Learning workflow for quality control in manufacturing process. The solution takes input of product images and identifies defect regions with bounding boxes. In particular, this solution uses a pre-trained Sagemaker object detection model and fine-tune on the target dataset. + +This solution will demonstrate the immense advantage of fine-tuning a high-quality pre-trained model on the target dataset, both visually and numerically. + +### Contents +1. [Overview](#overview) + 1. [What Does the Input Data Look Like?](#input) + 2. [How to Prepare Your Data to Feed into the Model?](#preparedata) + 3. [What are the Outputs?](#output) + 4. [What is the Estimated Cost?](#cost) + 5. [What Algorithms & Models are Used?](#algorithms) + 6. [What Does the Data Flow Look Like?](#dataflow) +2. [Solution Details](#solution) + 1. [Background](#background) + 2. [What is Visual Inspection?](#inspection) + 3. [What are the Problems?](#problems) + 4. [What Does this Solution Offer?](#offer) +3. [Architecture Overview](#architecture) +4. [Cleaning up](#cleaning-up) +5. [Customization](#customization) + + +## 1. Overview + +### 1.1. What Does the Input Data Look Like? + +Input is an image of a defective / non-defective product. The training data should have relatively balanced classes, with annotations for ground truth defects (locations and defect types) per image. Here are examples of annotations used in the demo, they show some "inclusion" defects on the surface: + +!["sample2"](https://sagemaker-solutions-prod-us-east-2.s3.us-east-2.amazonaws.com/sagemaker-defect-detection/docs/sample2.png) + +The NEU surface defect database (see [references](#references)) is a *balanced* dataset which contains + +> Six kinds of typical surface defects of the hot-rolled steel strip are collected, i.e., rolled-in scale (RS), patches (Pa), crazing (Cr), pitted surface (PS), inclusion (In) and scratches (Sc). The database includes 1,800 grayscale images: 300 samples each of six different kinds of typical surface defects + +Here is a sample image of the six classes + +!["data sample"](https://sagemaker-solutions-prod-us-east-2.s3.us-east-2.amazonaws.com/sagemaker-defect-detection/docs/data.png) + +### 1.2. How to Prepare Your Data to Feed into the Model? + +There are data preparation and preprocessing steps and should be followed in the notebooks. It's critical to prepare your image annotations beforehand. +For finetuning pretrained Sagemaker models, you need to prepare either a single `annotation.json` for all data, or a `RecordIO` file for both all images and all annotations. Check the notebook for details. + +### 1.3. What are the Outputs? + +* For each image, the trained model will produce bounding boxes of detected visual defects (if any), the predicted defect type, and prediction confidence score (0~1). +* If you have a labeled test dataset, you could obtain the mean Average Precision (mAP) score for each model and compare among all the models. + * For example, the mAP scores on a test set of the NEU dataset + + | | Type1 | Type1+HPO | Type2 | Type2+HPO| + | --- | --- | --- | --- | ---| + | mAP | 0.067 | 0.226 | 0.371 | 0.375| + + +### 1.4. What is the Estimated Cost? + +* Running the notebook costs around $130~140 USD, assuming using p3.2xlarge EC2 instance in the notebook, and $3.06 on-demand hourly rate in US East. This notebook provides advanced materials, including finetuning two types of pretrained Sagemaker models **till convergence**, with and without hyperparameter optimization (HPO), and result in four models for inference. You could choose to train either one model, or all four models according to your budget and requirements. The cost and runtime for training each model are: + + | Model | Cost (USD) | Runtime (Hours) | Billable time (Hours)| + |:----------:|:---------------:|:----:|:-----:| + |Type 1| 1.5 | 0.5 | 0.5| + |Type 1 with HPO (20 jobs)| 30.6 | 1* | 10| + |Type 2| 4.6 | 1.5 | 1.5| + |Type 2 with HPO (20 jobs)| 92 | 3* | 30| + (*) HPO tasks in this solution consider 20 jobs in total and 10 jobs in parallel. So 1 actual runtime hour amounts to 10 billable cost hours. +* Please make sure you have read the cleaning up part in [Section 4](#cleaning-up) after training to avoid incurred cost from deployed models. + + + +### 1.5. What Algorithms & Models are Used? + +* The pretrained Sagemaker models include SSD models and FasterRCNN model, using either VGG, ResNet, or MobileNet as backbone, pretrained on either ImageNet, COCO, VOC, or FPN dataset. + +### 1.6. How Does the Data Flow Look Like? + +![Data flow](https://sagemaker-solutions-prod-us-east-2.s3.us-east-2.amazonaws.com/sagemaker-defect-detection/docs/data_flow.png) + +## 2. Solution Details + +### 2.1. Background + +According to the [Gartner study on the top 10 strategic tech trends for 2020](https://www.gartner.com/smarterwithgartner/gartner-top-10-strategic-technology-trends-for-2020/), hyper-automation is the number one trend in 2020 and will continue advancing in future. When it comes to manufacturing, one of the main barriers to hyper-automation is in areas where Human involvements is still struggling to be reduced and intelligent systems have hard times to become on-par with Human visual recognition abilities and become mainstream, despite great advancement of Deep Learning in Computer Vision. This is mainly due to lack of enough annotated data (or when data is sparse) in areas such as _Quality Control_ sections where trained Human eyes still dominates. + + +### 2.2. What is Visual Inspection? + +The **analysis of products on the production line for the purpose of Quality Control**. According to [Everything you need to know about Visual Inspection with AI](https://nanonets.com/blog/ai-visual-inspection/), visual inspection can also be used for internal and external assessment of the various equipment in a production facility such as storage tanks, pressure vessels, piping, and other equipment which expands to many industries from Electronics, Medical, Food and Raw Materials. + +### 2.3. What are the Problems? + +* *Human visual inspection error* is a major factor in this area. According to the report [The Role of Visual Inspection in the 21st Century](https://www.osti.gov/servlets/purl/1476816) + + > Most inspection tasks are much more complex and typically exhibit error rates of 20% to 30% (Drury & Fox, 1975) + +which directly translates to *cost*. +* Cost: according to [glassdoor estimate](https://www.glassdoor.co.in/Salaries/us-quality-control-inspector-salary-SRCH_IL.0,2_IN1_KO3,28.htm), a trained quality inspector salary varies between 29K (US) - 64K per year. + +### 2.4. What Does this Solution Offer? + +This solution offers a complete solution using high-quality pretrained Sagemaker models to finetune on the target dataset with and without hyperparameter optimization (HPO). + +The **most important** information this solution delivers, is that training a deep learning model from scratch on a small dataset can be both time-consuming and less effective, whereas finetuning a high-quality pretrained model, which was trained on large-scale dataset, could be both cost- and runtime-efficient and highly performant. Here are the sample detection results + +drawing + +## 3. Architecture Overview + +The following illustration is the architecture for the end-to-end training and deployment process + +!["Solution Architecture"](https://sagemaker-solutions-prod-us-east-2.s3.us-east-2.amazonaws.com/sagemaker-defect-detection/docs/train_arch.png) + +1. The input data located in an [Amazon S3](https://aws.amazon.com/s3/) bucket +2. The provided [SageMaker notebook](source/deep_demand_forecast.ipynb) that gets the input data and launches the later stages below +3. **Training Classifier and Detector models** and evaluating its results using Amazon SageMaker. If desired, one can deploy the trained models and create SageMaker endpoints +4. **SageMaker endpoint** created from the previous step is an [HTTPS endpoint](https://docs.aws.amazon.com/sagemaker/latest/dg/how-it-works-hosting.html) and is capable of producing predictions +5. Monitoring the training and deployed model via [Amazon CloudWatch](https://aws.amazon.com/cloudwatch/) + +## 4. Cleaning up + +If you run the notebook end-to-end, the Cleaning up section in the notebook will delete all the checkpoints and models automatically for you. If you choose to only train some of the four models in the notebook, please make sure to run corresponding code in the Cleaning up section to delete all the artifacts. + +**Caution:** You need to manually delete any extra resources that you may have created in this notebook. For examples extra Amazon S3 bucketis. + +## 5. Customization + +For using your own data, make sure it is labeled and is a *relatively* balanced dataset. Also make sure the image annotations follow the required format. + + + +### Useful Links + +* [Amazon SageMaker Getting Started](https://aws.amazon.com/sagemaker/getting-started/) +* [Amazon SageMaker Developer Guide](https://docs.aws.amazon.com/sagemaker/latest/dg/whatis.html) +* [Amazon SageMaker Python SDK Documentation](https://sagemaker.readthedocs.io/en/stable/) +* [AWS CloudFormation User Guide](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/Welcome.html) + +### References + +* K. Song and Y. Yan, “A noise robust method based on completed local binary patterns for hot-rolled steel strip surface defects,” Applied Surface Science, vol. 285, pp. 858-864, Nov. 2013. + +* Yu He, Kechen Song, Qinggang Meng, Yunhui Yan, “An End-to-end Steel Surface Defect Detection Approach via Fusing Multiple Hierarchical Features,” IEEE Transactions on Instrumentation and Measuremente, 2020,69(4),1493-1504. + +* Hongwen Dong, Kechen Song, Yu He, Jing Xu, Yunhui Yan, Qinggang Meng, “PGA-Net: Pyramid Feature Fusion and Global Context Attention Network for Automated Surface Defect Detection,” IEEE Transactions on Industrial Informatics, 2020. diff --git a/introduction_to_applying_machine_learning/visual_object_detection/numerical.png b/introduction_to_applying_machine_learning/visual_object_detection/numerical.png new file mode 100644 index 0000000000..427d7583d3 Binary files /dev/null and b/introduction_to_applying_machine_learning/visual_object_detection/numerical.png differ diff --git a/introduction_to_applying_machine_learning/visual_object_detection/patches_116.jpeg b/introduction_to_applying_machine_learning/visual_object_detection/patches_116.jpeg new file mode 100644 index 0000000000..fc2443f9df Binary files /dev/null and b/introduction_to_applying_machine_learning/visual_object_detection/patches_116.jpeg differ diff --git a/introduction_to_applying_machine_learning/visual_object_detection/src/im2rec.py b/introduction_to_applying_machine_learning/visual_object_detection/src/im2rec.py new file mode 100644 index 0000000000..16693351fc --- /dev/null +++ b/introduction_to_applying_machine_learning/visual_object_detection/src/im2rec.py @@ -0,0 +1,409 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +# Licensed to the Apache Software Foundation (ASF) under one +# or more contributor license agreements. See the NOTICE file +# distributed with this work for additional information +# regarding copyright ownership. The ASF licenses this file +# to you 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. + +from __future__ import print_function + +import argparse +import os +import random +import sys +import time +import traceback + +import cv2 +import mxnet as mx + + +curr_path = os.path.abspath(os.path.dirname(__file__)) +sys.path.append(os.path.join(curr_path, "../python")) + + + +def list_image(root, recursive, exts): + """Traverses the root of directory that contains images and generates image list iterator. + + Args: + root (str): the directory to explore + recursive (bool): whether subdirectories should be explored recursively + exts (collection[str]): the file extensions to look for + + Returns: + image iterator that contains all the image under the specified path + """ + + i = 0 + if recursive: + cat = {} + for path, dirs, files in os.walk(root, followlinks=True): + dirs.sort() + files.sort() + for fname in files: + fpath = os.path.join(path, fname) + suffix = os.path.splitext(fname)[1].lower() + if os.path.isfile(fpath) and (suffix in exts): + if path not in cat: + cat[path] = len(cat) + yield (i, os.path.relpath(fpath, root), cat[path]) + i += 1 + for k, v in sorted(cat.items(), key=lambda x: x[1]): + print(os.path.relpath(k, root), v) + else: + for fname in sorted(os.listdir(root)): + fpath = os.path.join(root, fname) + suffix = os.path.splitext(fname)[1].lower() + if os.path.isfile(fpath) and (suffix in exts): + yield (i, os.path.relpath(fpath, root), 0) + i += 1 + + +def write_list(path_out, image_list): + r"""Helper function to write image list into the file. + + The format is as below, integer_image_index \t float_label_index \t path_to_image + Note that the blank between number and tab is only used for readability. + + Args: + path_out (str): the path of the file to write to + image_list (list): objects in the images + """ + with open(path_out, "w") as fout: + for i, item in enumerate(image_list): + line = "%d\t" % item[0] + for j in item[2:]: + line += "%f\t" % j + line += "%s\n" % item[1] + fout.write(line) + + +def make_list(args): + """Generates .lst file. + + Args: + args: object that contains all the arguments + """ + image_list = list_image(args.root, args.recursive, args.exts) + image_list = list(image_list) + if args.shuffle is True: + random.seed(100) + random.shuffle(image_list) + N = len(image_list) + chunk_size = (N + args.chunks - 1) // args.chunks + for i in range(args.chunks): + chunk = image_list[i * chunk_size : (i + 1) * chunk_size] + if args.chunks > 1: + str_chunk = "_%d" % i + else: + str_chunk = "" + sep = int(chunk_size * args.train_ratio) + sep_test = int(chunk_size * args.test_ratio) + if args.train_ratio == 1.0: + write_list(args.prefix + str_chunk + ".lst", chunk) + else: + if args.test_ratio: + write_list(args.prefix + str_chunk + "_test.lst", chunk[:sep_test]) + if args.train_ratio + args.test_ratio < 1.0: + write_list(args.prefix + str_chunk + "_val.lst", chunk[sep_test + sep :]) + write_list(args.prefix + str_chunk + "_train.lst", chunk[sep_test : sep_test + sep]) + + +def read_list(path_in): + """Reads the .lst file and generates corresponding iterator. + + Args: + path_in (str) + + Returns: + item iterator that contains information in .lst file + """ + with open(path_in) as fin: + while True: + line = fin.readline() + if not line: + break + line = [i.strip() for i in line.strip().split("\t")] + line_len = len(line) + # check the data format of .lst file + if line_len < 3: + print("lst should have at least has three parts, but only has %s parts for %s" % (line_len, line)) + continue + try: + item = [int(line[0])] + [line[-1]] + [float(i) for i in line[1:-1]] + except Exception as e: + print("Parsing lst met error for %s, detail: %s" % (line, e)) + continue + yield item + + +def image_encode(args, i, item, q_out): + """Reads, preprocesses, packs the image and put it back in output queue. + + Args" + args (object): image + i (int): image index + item (list): labels + q_out (queue): collection to store the image to + """ + fullpath = os.path.join(args.root, item[1]) + + if len(item) > 3 and args.pack_label: + header = mx.recordio.IRHeader(0, item[2:], item[0], 0) + else: + header = mx.recordio.IRHeader(0, item[2], item[0], 0) + + if args.pass_through: + try: + with open(fullpath, "rb") as fin: + img = fin.read() + s = mx.recordio.pack(header, img) + q_out.put((i, s, item)) + except Exception as e: + traceback.print_exc() + print("pack_img error:", item[1], e) + q_out.put((i, None, item)) + return + + try: + img = cv2.imread(fullpath, args.color) + except Exception: + traceback.print_exc() + print("imread error trying to load file: %s " % fullpath) + q_out.put((i, None, item)) + return + if img is None: + print("imread read blank (None) image for file: %s" % fullpath) + q_out.put((i, None, item)) + return + if args.center_crop: + if img.shape[0] > img.shape[1]: + margin = (img.shape[0] - img.shape[1]) // 2 + img = img[margin : margin + img.shape[1], :] + else: + margin = (img.shape[1] - img.shape[0]) // 2 + img = img[:, margin : margin + img.shape[0]] + if args.resize: + if img.shape[0] > img.shape[1]: + newsize = (args.resize, img.shape[0] * args.resize // img.shape[1]) + else: + newsize = (img.shape[1] * args.resize // img.shape[0], args.resize) + img = cv2.resize(img, newsize) + + try: + s = mx.recordio.pack_img(header, img, quality=args.quality, img_fmt=args.encoding) + q_out.put((i, s, item)) + except Exception as e: + traceback.print_exc() + print("pack_img error on file: %s" % fullpath, e) + q_out.put((i, None, item)) + return + + +def read_worker(args, q_in, q_out): + """Function that will be spawned to fetch the image from the input queue and put it back to output queue. + + Args: + args (object): image + q_in (queue): input queue + q_out (queue): output queue + """ + while True: + deq = q_in.get() + if deq is None: + break + i, item = deq + image_encode(args, i, item, q_out) + + +def write_worker(q_out, fname, working_dir): + """Function that will be spawned to fetch processed image from the output queue and write to the .rec file. + + Args: + q_out (queue): output queue + fname (str): name of the files + working_dir (str): name of directory to write to + """ + pre_time = time.time() + count = 0 + fname = os.path.basename(fname) + fname_rec = os.path.splitext(fname)[0] + ".rec" + fname_idx = os.path.splitext(fname)[0] + ".idx" + record = mx.recordio.MXIndexedRecordIO( + os.path.join(working_dir, fname_idx), os.path.join(working_dir, fname_rec), "w" + ) + buf = {} + more = True + while more: + deq = q_out.get() + if deq is not None: + i, s, item = deq + buf[i] = (s, item) + else: + more = False + while count in buf: + s, item = buf[count] + del buf[count] + if s is not None: + record.write_idx(item[0], s) + + if count % 1000 == 0: + cur_time = time.time() + print("time:", cur_time - pre_time, " count:", count) + pre_time = cur_time + count += 1 + + +def parse_args(): + """Defines all arguments. + + Returns: + args object that contains all the params + """ + parser = argparse.ArgumentParser( + formatter_class=argparse.ArgumentDefaultsHelpFormatter, + description="Create an image list or \ + make a record database by reading from an image list", + ) + parser.add_argument("prefix", help="prefix of input/output lst and rec files.") + parser.add_argument("root", help="path to folder containing images.") + + cgroup = parser.add_argument_group("Options for creating image lists") + cgroup.add_argument( + "--list", + action="store_true", + help="If this is set im2rec will create image list(s) by traversing root folder\ + and output to .lst.\ + Otherwise im2rec will read .lst and create a database at .rec", + ) + cgroup.add_argument( + "--exts", nargs="+", default=[".jpeg", ".jpg", ".png"], help="list of acceptable image extensions." + ) + cgroup.add_argument("--chunks", type=int, default=1, help="number of chunks.") + cgroup.add_argument("--train-ratio", type=float, default=1.0, help="Ratio of images to use for training.") + cgroup.add_argument("--test-ratio", type=float, default=0, help="Ratio of images to use for testing.") + cgroup.add_argument( + "--recursive", + action="store_true", + help="If true recursively walk through subdirs and assign an unique label\ + to images in each folder. Otherwise only include images in the root folder\ + and give them label 0.", + ) + cgroup.add_argument( + "--no-shuffle", + dest="shuffle", + action="store_false", + help="If this is passed, \ + im2rec will not randomize the image order in .lst", + ) + rgroup = parser.add_argument_group("Options for creating database") + rgroup.add_argument( + "--pass-through", action="store_true", help="whether to skip transformation and save image as is" + ) + rgroup.add_argument( + "--resize", + type=int, + default=0, + help="resize the shorter edge of image to the newsize, original images will\ + be packed by default.", + ) + rgroup.add_argument( + "--center-crop", action="store_true", help="specify whether to crop the center image to make it rectangular." + ) + rgroup.add_argument( + "--quality", type=int, default=95, help="JPEG quality for encoding, 1-100; or PNG compression for encoding, 1-9" + ) + rgroup.add_argument( + "--num-thread", + type=int, + default=1, + help="number of thread to use for encoding. order of images will be different\ + from the input list if >1. the input list will be modified to match the\ + resulting order.", + ) + rgroup.add_argument( + "--color", + type=int, + default=1, + choices=[-1, 0, 1], + help="specify the color mode of the loaded image.\ + 1: Loads a color image. Any transparency of image will be neglected. It is the default flag.\ + 0: Loads image in grayscale mode.\ + -1:Loads image as such including alpha channel.", + ) + rgroup.add_argument( + "--encoding", type=str, default=".jpg", choices=[".jpg", ".png"], help="specify the encoding of the images." + ) + rgroup.add_argument( + "--pack-label", action="store_true", help="Whether to also pack multi dimensional label in the record file" + ) + args = parser.parse_args() + + args.prefix = os.path.abspath(args.prefix) + args.root = os.path.abspath(args.root) + return args + + +if __name__ == "__main__": + args = parse_args() + + # if the '--list' is used, it generates .lst file + if args.list: + make_list(args) + # otherwise read .lst file to generates .rec file + else: + if os.path.isdir(args.prefix): + working_dir = args.prefix + else: + working_dir = os.path.dirname(args.prefix) + files = [ + os.path.join(working_dir, fname) + for fname in os.listdir(working_dir) + if os.path.isfile(os.path.join(working_dir, fname)) + ] + count = 0 + for fname in files: + if fname.startswith(args.prefix) and fname.endswith(".lst"): + print("Creating .rec file from", fname, "in", working_dir) + count += 1 + image_list = read_list(fname) + # -- write_record -- # + try: + import Queue as queue + except ImportError: + import queue + q_out = queue.Queue() + fname = os.path.basename(fname) + fname_rec = os.path.splitext(fname)[0] + ".rec" + fname_idx = os.path.splitext(fname)[0] + ".idx" + record = mx.recordio.MXIndexedRecordIO( + os.path.join(working_dir, fname_idx), os.path.join(working_dir, fname_rec), "w" + ) + cnt = 0 + pre_time = time.time() + for i, item in enumerate(image_list): + image_encode(args, i, item, q_out) + if q_out.empty(): + continue + _, s, _ = q_out.get() + record.write_idx(item[0], s) + if cnt % 1000 == 0: + cur_time = time.time() + print("time:", cur_time - pre_time, " count:", cnt) + pre_time = cur_time + cnt += 1 + if not count: + print("Did not find and list file with prefix %s" % args.prefix) diff --git a/introduction_to_applying_machine_learning/visual_object_detection/src/prepare_RecordIO.py b/introduction_to_applying_machine_learning/visual_object_detection/src/prepare_RecordIO.py new file mode 100644 index 0000000000..ca3f183363 --- /dev/null +++ b/introduction_to_applying_machine_learning/visual_object_detection/src/prepare_RecordIO.py @@ -0,0 +1,160 @@ +import json +import os +import random +import argparse +import numpy as np +from collections import defaultdict +from pathlib import Path + + +def write_line(img_path, width, height, boxes, ids, idx): + """Create a line for each image with annotations, width, height and image name.""" + # for header, we use minimal length 2, plus width and height + # with A: 4, B: 5, C: width, D: height + A = 4 + B = 5 + C = width + D = height + # concat id and bboxes + labels = np.hstack((ids.reshape(-1, 1), boxes)).astype("float") + # normalized bboxes (recommanded) + labels[:, (1, 3)] /= float(width) + labels[:, (2, 4)] /= float(height) + # flatten + labels = labels.flatten().tolist() + str_idx = [str(idx)] + str_header = [str(x) for x in [A, B, C, D]] + str_labels = [str(x) for x in labels] + str_path = [img_path] + line = "\t".join(str_idx + str_header + str_labels + str_path) + "\n" + return line + + +# adapt from __main__ from im2rec.py +def write_lst(output_file, ids, images_annotations): + + all_labels = set() + image_info = {} + for entry in images_annotations['images']: + if entry["id"] in ids: + image_info[entry["id"]] = entry + annotations_info = {} # one annotation for each id (ie., image) + for entry in images_annotations['annotations']: + image_id = entry['image_id'] + if image_id in ids: + if image_id not in annotations_info: + annotations_info[image_id] = {'boxes': [], 'labels': []} + annotations_info[image_id]['boxes'].append(entry['bbox']) + annotations_info[image_id]['labels'].append(entry['category_id']) + all_labels.add(entry['category_id']) + labels_list = [label for label in all_labels] + class_to_idx_mapping = {label: idx for idx, label in enumerate(labels_list)} + with open(output_file, "w") as fw: + for i, image_id in enumerate(annotations_info): + im_info = image_info[image_id] + image_file = im_info['file_name'] + height = im_info['height'] + width = im_info['width'] + an_info = annotations_info[image_id] + boxes = np.array(an_info['boxes']) + labels = np.array([class_to_idx_mapping[label] for label in an_info['labels']]) + line = write_line(image_file, width, height, boxes, labels, i) + fw.write(line) + + +def create_lst(data_dir, args, rnd_seed=100): + """Generate an lst file based on annotations file which is used to convert the input data to .rec format.""" + with open(os.path.join(data_dir, 'annotations.json')) as f: + images_annotations = json.loads(f.read()) + + # Size of each class + class_ids = defaultdict(list) + for entry in images_annotations['images']: + cls_ = entry['file_name'].split('_')[0] + class_ids[cls_].append(entry['id']) + print('\ncategory\tnum of images') + print('---------------') + for cls_ in class_ids.keys(): + print(f"{cls_}\t{len(class_ids[cls_])}") + + random.seed(rnd_seed) + + # Split train/val/test image ids + if args.test_ratio: + test_ids = [] + if args.train_ratio + args.test_ratio < 1.0: + val_ids = [] + train_ids = [] + for cls_ in class_ids.keys(): + random.shuffle(class_ids[cls_]) + N = len(class_ids[cls_]) + ids = class_ids[cls_] + + sep = int(N * args.train_ratio) + sep_test = int(N * args.test_ratio) + if args.train_ratio == 1.0: + train_ids.extend(ids) + else: + if args.test_ratio: + test_ids.extend(ids[:sep_test]) + if args.train_ratio + args.test_ratio < 1.0: + val_ids.extend(ids[sep_test + sep:]) + train_ids.extend(ids[sep_test: sep_test + sep]) + + write_lst(args.prefix + "_train.lst", train_ids, images_annotations) + lsts = [args.prefix + "_train.lst"] + if args.test_ratio: + write_lst(args.prefix + "_test.lst", test_ids, images_annotations) + lsts.append(args.prefix + "_test.lst") + if args.train_ratio + args.test_ratio < 1.0: + write_lst(args.prefix + "_val.lst", val_ids, images_annotations) + lsts.append(args.prefix + "_val.lst") + + return lsts + + +def parse_args(): + """Defines all arguments. + + Returns: + args object that contains all the params + """ + parser = argparse.ArgumentParser( + formatter_class=argparse.ArgumentDefaultsHelpFormatter, + description="Create an image list or \ + make a record database by reading from an image list", + ) + parser.add_argument("prefix", help="prefix of input/output lst and rec files.") + parser.add_argument("root", help="path to folder containing images.") + + cgroup = parser.add_argument_group("Options for creating image lists") + cgroup.add_argument( + "--exts", nargs="+", default=[".jpeg", ".jpg", ".png"], help="list of acceptable image extensions." + ) + cgroup.add_argument("--train-ratio", type=float, default=0.8, help="Ratio of images to use for training.") + cgroup.add_argument("--test-ratio", type=float, default=0, help="Ratio of images to use for testing.") + cgroup.add_argument( + "--recursive", + action="store_true", + help="If true recursively walk through subdirs and assign an unique label\ + to images in each folder. Otherwise only include images in the root folder\ + and give them label 0.", + ) + args = parser.parse_args() + + args.prefix = os.path.abspath(args.prefix) + args.root = os.path.abspath(args.root) + return args + + +if __name__ == '__main__': + + args = parse_args() + data_dir = Path(args.root).parent + + lsts = create_lst(data_dir, args) + print() + + for lst in lsts: + os.system(f"python3 ./src/im2rec.py {lst} {os.path.join(data_dir, 'images')} --pass-through --pack-label") + print() diff --git a/introduction_to_applying_machine_learning/visual_object_detection/src/utils.py b/introduction_to_applying_machine_learning/visual_object_detection/src/utils.py new file mode 100644 index 0000000000..05d1651722 --- /dev/null +++ b/introduction_to_applying_machine_learning/visual_object_detection/src/utils.py @@ -0,0 +1,139 @@ +import numpy as np +import json +import boto3 +import copy +import matplotlib.patches as patches +from matplotlib import pyplot as plt +from PIL import Image, ImageColor + + +def query_Type2(image_file_name, endpoint_name, num_predictions=4): + + with open(image_file_name, "rb") as file: + input_img_rb = file.read() + + client = boto3.client("runtime.sagemaker") + query_response = client.invoke_endpoint( + EndpointName=endpoint_name, + ContentType="application/x-image", + Body=input_img_rb, + Accept=f'application/json;verbose;n_predictions={num_predictions}' + ) + # If we remove ';n_predictions={}' from Accept, we get all the predicted boxes. + query_response = query_response['Body'].read() + + model_predictions = json.loads(query_response) + normalized_boxes, classes, scores, labels = ( + model_predictions["normalized_boxes"], + model_predictions["classes"], + model_predictions["scores"], + model_predictions["labels"], + ) + # Substitute the classes index with the classes name + class_names = [labels[int(idx)] for idx in classes] + return normalized_boxes, class_names, scores + + +# Copied from albumentations/augmentations/functional.py +# Follow albumentations.Normalize, which is used in sagemaker_defect_detection/detector.py +def normalize(img, mean, std, max_pixel_value=255.0): + mean = np.array(mean, dtype=np.float32) + mean *= max_pixel_value + + std = np.array(std, dtype=np.float32) + std *= max_pixel_value + + denominator = np.reciprocal(std, dtype=np.float32) + + img = img.astype(np.float32) + img -= mean + img *= denominator + return img + + +def query_Type1(image_file_name, endpoint_name, num_predictions=4): + + with open(image_file_name, "rb") as file: + input_img_rb = file.read() + + client = boto3.client(service_name="runtime.sagemaker") + query_response = client.invoke_endpoint( + EndpointName=endpoint_name, + ContentType="application/x-image", + Body=input_img_rb + ) + query_response = query_response["Body"].read() + + model_predictions = json.loads(query_response)['prediction'][:num_predictions] + class_names = [int(pred[0])+1 for pred in model_predictions] # +1 for index starts from 1 + scores = [pred[1] for pred in model_predictions] + normalized_boxes = [pred[2:] for pred in model_predictions] + return normalized_boxes, class_names, scores + + +def plot_results(image, bboxes, categories, d): + # d - dictionary of endpoint responses + + colors = list(ImageColor.colormap.values()) + with Image.open(image) as im: + image_np = np.array(im) + fig = plt.figure(figsize=(20, 14)) + + n = len(d) + + # Ground truth + ax1 = fig.add_subplot(2, 3, 1) + plt.axis('off') + plt.title('Ground Truth') + + for bbox in bboxes: + left, bot, right, top = bbox['bbox'] + x, y, w, h = left, bot, right - left, top - bot + + color = colors[hash(bbox['category_id']) % len(colors)] + rect = patches.Rectangle((x, y), w, h, linewidth=3, edgecolor=color, facecolor="none") + ax1.add_patch(rect) + ax1.text(x, y, "{}".format(categories[bbox['category_id']]), + bbox=dict(facecolor="white", alpha=0.5)) + + ax1.imshow(image_np) + + # Predictions + counter = 2 + for k, v in d.items(): + axi = fig.add_subplot(2, 3, counter) + counter += 1 + + if "Type2-HPO" in k: + k = "Type2-HPO" + elif "Type2" in k: + k = "Type2" + elif "Type1-HPO" in k: + k = "Type1-HPO" + elif "Type1" in k: + k = "Type1" + else: + print("Un-recognized type") + exit() + + plt.title(f'Prediction: {k}') + plt.axis('off') + + for idx in range(len(v['normalized_boxes'])): + left, bot, right, top = v['normalized_boxes'][idx] + x, w = [val * image_np.shape[1] for val in [left, right - left]] + y, h = [val * image_np.shape[0] for val in [bot, top - bot]] + color = colors[hash(v['classes_names'][idx]) % len(colors)] + rect = patches.Rectangle((x, y), w, h, linewidth=3, edgecolor=color, facecolor="none") + axi.add_patch(rect) + axi.text(x, y, + "{} {:.0f}%".format(categories[v['classes_names'][idx]], v['confidences'][idx] * 100), + bbox=dict(facecolor="white", alpha=0.5), + ) + + axi.imshow(image_np) + + plt.tight_layout() + plt.savefig("results/"+ image.split('/')[-1]) + + plt.show() diff --git a/introduction_to_applying_machine_learning/visual_object_detection/src/xml2json.py b/introduction_to_applying_machine_learning/visual_object_detection/src/xml2json.py new file mode 100644 index 0000000000..7b40394063 --- /dev/null +++ b/introduction_to_applying_machine_learning/visual_object_detection/src/xml2json.py @@ -0,0 +1,175 @@ +# Use this script to convert annotation xmls to a single annotations.json file that will be taken by Jumpstart OD model +# Reference: XML2JSON.py https://linuxtut.com/en/e391e5e6924945b8a852/ + +import random +import xmltodict +import copy +import json +import glob +import os +from collections import defaultdict + + +categories = [ + {"id": 1, "name": "crazing"}, + {"id": 2, "name": "inclusion"}, + {"id": 3, "name": "pitted_surface"}, + {"id": 4, "name": "patches"}, + {"id": 5, "name": "rolled-in_scale"}, + {"id": 6, "name": "scratches"}, +] + + +def XML2JSON(xmlFiles, test_ratio=None, rnd_seed=100): + """ Convert all xmls to annotations.json + + If the test_ratio is not None, convert to two annotations.json files, + one for train+val, another one for test. + """ + + images = list() + annotations = list() + image_id = 1 + annotation_id = 1 + for file in xmlFiles: + annotation_path = file + image = dict() + with open(annotation_path) as fd: + doc = xmltodict.parse(fd.read(), force_list=('object')) + filename = str(doc['annotation']['filename']) + image['file_name'] = filename if filename.endswith('.jpg') else filename + '.jpg' + image['height'] = int(doc['annotation']['size']['height']) + image['width'] = int(doc['annotation']['size']['width']) + image['id'] = image_id +# print("File Name: {} and image_id {}".format(file, image_id)) + images.append(image) + if 'object' in doc['annotation']: + for obj in doc['annotation']['object']: + for value in categories: + annotation = dict() + if str(obj['name']) == value["name"]: + annotation["image_id"] = image_id + xmin = int(obj["bndbox"]["xmin"]) + ymin = int(obj["bndbox"]["ymin"]) + xmax = int(obj["bndbox"]["xmax"]) + ymax = int(obj["bndbox"]["ymax"]) + annotation["bbox"] = [xmin, ymin, xmax, ymax] + annotation["category_id"] = value["id"] + annotation["id"] = annotation_id + annotation_id += 1 + annotations.append(annotation) + + else: + print("File: {} doesn't have any object".format(file)) + + image_id += 1 + + if test_ratio is None: + attrDict = dict() + attrDict["images"] = images + attrDict["annotations"] = annotations + + jsonString = json.dumps(attrDict) + with open("annotations.json", "w") as f: + f.write(jsonString) + else: + assert test_ratio < 1.0 + + # Size of each class + category_ids = defaultdict(list) + for img in images: + category = img['file_name'].split('_')[0] + category_ids[category].append(img['id']) + print('\ncategory\tnum of images') + print('-' * 20) + + random.seed(rnd_seed) + + train_val_images = [] + test_images = [] + train_val_annotations = [] + test_annotations = [] + + for category in category_ids.keys(): + print(f"{category}:\t{len(category_ids[category])}") + + random.shuffle(category_ids[category]) + N = len(category_ids[category]) + ids = category_ids[category] + + sep = int(N * test_ratio) + + category_images = [img for img in images if img['id'] in ids[:sep]] + test_images.extend(category_images) + category_images = [img for img in images if img['id'] in ids[sep:]] + train_val_images.extend(category_images) + + category_annotations = [ann for ann in annotations if ann['image_id'] in ids[:sep]] + test_annotations.extend(category_annotations) + category_annotations = [ann for ann in annotations if ann['image_id'] in ids[sep:]] + train_val_annotations.extend(category_annotations) + + print('-' * 20) + + train_val_attrDict = dict() + train_val_attrDict["images"] = train_val_images + train_val_attrDict["annotations"] = train_val_annotations + print(f"\ntrain_val:\t{len(train_val_images)}") + + train_val_jsonString = json.dumps(train_val_attrDict) + with open("annotations.json", "w") as f: + f.write(train_val_jsonString) + + test_attDict = dict() + test_attDict["images"] = test_images + test_attDict["annotations"] = test_annotations + print(f"test:\t{len(test_images)}") + + test_jsonString = json.dumps(test_attDict) + with open("test_annotations.json", "w") as f: + f.write(test_jsonString) + + + +def convert_to_pycocotools_ground_truth(annotations_file): + """ + Given the annotation json file for the test data generated during + initial data preparatoin, convert it to the input format pycocotools + can consume. + """ + + with open(annotations_file) as f: + images_annotations = json.loads(f.read()) + + attrDict = dict() + attrDict["images"] = images_annotations["images"] + attrDict["categories"] = categories + + annotations = [] + for entry in images_annotations['annotations']: + ann = copy.deepcopy(entry) + xmin, ymin, xmax, ymax = ann["bbox"] + ann["bbox"] = [xmin, ymin, xmax-xmin, ymax-ymin] # convert to [x, y, W, H] + ann["area"] = (xmax - xmin) * (ymax - ymin) + ann["iscrowd"] = 0 + annotations.append(ann) + + attrDict["annotations"] = annotations + + jsonString = json.dumps(attrDict) + ground_truth_annotations = "results/ground_truth_annotations.json" + + with open(ground_truth_annotations, "w") as f: + f.write(jsonString) + + return ground_truth_annotations + + +if __name__ == "__main__": + data_path = '../NEU-DET/ANNOTATIONS' + xmlfiles = glob.glob(os.path.join(data_path, '*.xml')) + xmlfiles.sort() + + XML2JSON(xmlfiles, test_ratio=0.2) + + diff --git a/introduction_to_applying_machine_learning/visual_object_detection/visual_object_detection.ipynb b/introduction_to_applying_machine_learning/visual_object_detection/visual_object_detection.ipynb new file mode 100644 index 0000000000..1aa383da49 --- /dev/null +++ b/introduction_to_applying_machine_learning/visual_object_detection/visual_object_detection.ipynb @@ -0,0 +1,1997 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "papermill": { + "duration": 0.075676, + "end_time": "2022-08-05T08:10:43.854066", + "exception": false, + "start_time": "2022-08-05T08:10:43.778390", + "status": "completed" + }, + "pycharm": { + "name": "#%% md\n" + }, + "tags": [] + }, + "source": [ + "# Finetune Visual Object Detection Models Using Pre-trained Sagemaker Models\n", + "\n", + "\n", + "This notebook introduces finetuning pretrained object detection (OD) models on new dataset. \n", + "\n", + "Training a model from scratch in general is time-consuming and requires large compute resources. When the training data is small, we cannot expect to train a very performant model. A better alternative is to finetune a pretrained model on the target dataset. AWS Sagemaker provides high-quality pretrained models that were trained on very large datasets. Finetuning these models on new dataset takes only fractional training time compard to training from scratch.\n", + "\n", + "In this notebook, we demonstrate how to use two types of Amazon Sagemaker built-in OD models to finetune on the *[Steel Surface Defect](https://github.com/siddhartamukherjee/NEU-DET-Steel-Surface-Defect-Detection)* dataset, which is used in this solution. \n", + "* Type 1 (legacy): uses a built-in legacy [Object Detection algorithm](https://docs.aws.amazon.com/sagemaker/latest/dg/object-detection.html) and uses the *Single Shot multibox Detector* (SSD) model with either VGG or ResNet backbone, and was pretrained on the ImageNet dataset. \n", + "* Type 2 (latest): provides [9 pretrained OD models](https://sagemaker.readthedocs.io/en/stable/doc_utils/pretrainedmodels.html?highlight=jumpstart#built-in-algorithms-with-pre-trained-model-table), including 8 SSD models and 1 FasterRCNN model. These models use VGG, ResNet, or MobileNet as backbone, and were pretrained on COCO, VOC, or FPN datasets. \n", + "\n", + "\n", + "For each type of model, besides training with default hyperparameters, we also perform hyperparameter tuning (i.e., HPO) using [Sagemaker Automatic Model Tuning (AMT)](https://docs.aws.amazon.com/sagemaker/latest/dg/automatic-model-tuning.html) to train even better model. \n", + "\n", + "Running the whole notebook takes about 8 hours. The most time-consuming part is running HPO jobs for both types of models. You could choose to run more HPO jobs in parallel in order to reduce running time if there are more EC2 instances available.\n", + "\n", + "---\n", + "\n", + "Content\n", + "1. [Data Preparation](#1.-Data-Preparation)\n", + "2. [Training: Finetune Type 1 (Legacy) OD Model](#2.-Training:-Finetune-Type-1-(Legacy)-OD-Model)\n", + "3. [Training: Finetune Type 1 (Legacy) OD Model with HPO](#3.-Training:-Finetune-Type-1-(Legacy)-OD-model-with-HPO)\n", + "4. [Training: Finetune Type 2 (Latest) OD Model](#4.-Training:-Finetune-Type-2-(Latest)-OD-Model)\n", + "5. [Training: Finetune Type 2 (Latest) OD Model with HPO](#5.-Training:-Finetune-Type-2-(Latest)-OD-model-with-HPO)\n", + "6. [Inference and Model Comparison](#6.-Inference-and-Model-Comparison)\n", + "7. [Clean Up the Endpoints](#7.-Clean-Up-the-Endpoints)\n", + "8. [Conclusion](#8.-Conclusion)\n", + "\n", + "---\n", + "\n", + "** **ATTENTION** ** \n", + "\n", + "* Running the notebook end-to-end takes 8~9 hours. We changed some parameter values so that the notebook took much shorter time to finish, at the cost of model trainig non-convergence.\n", + "* Please change them back when you want to train till convergence. These parameters include `num_epochs=100` for training all models, and `max_jobs=20`, `max_parallel_jobs=10` for hyperparameter tuning.\n", + "* The shown results in this notebook is for fully-convergent models.\n", + "\n", + "---" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "num_epochs = 10 # change to 100\n", + "max_jobs = 3 # change to 20 or more\n", + "max_parallel_jobs = 3 # change to 5 or 10" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "papermill": { + "duration": 6.156173, + "end_time": "2022-08-05T08:10:50.082117", + "exception": false, + "start_time": "2022-08-05T08:10:43.925944", + "status": "completed" + }, + "pycharm": { + "name": "#%%\n" + }, + "scrolled": true, + "tags": [] + }, + "outputs": [], + "source": [ + "# Update to latest Sagemaker package to use Sagemaker APIs for model training and deployment\n", + "%pip install --upgrade sagemaker\n", + "%pip install pycocotools\n", + "%pip install opencv-python-headless opencv-python==4.5.5.64 mxnet xmltodict" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "papermill": { + "duration": 4.916572, + "end_time": "2022-08-05T08:10:55.088245", + "exception": false, + "start_time": "2022-08-05T08:10:50.171673", + "status": "completed" + }, + "pycharm": { + "name": "#%%\n" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "import os\n", + "import sys\n", + "import json\n", + "import glob\n", + "import boto3\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "\n", + "import sagemaker\n", + "from sagemaker import get_execution_role, image_uris, model_uris, script_uris, hyperparameters\n", + "from sagemaker.s3 import S3Downloader\n", + "from sagemaker.utils import name_from_base\n", + "from sagemaker.session import Session\n", + "from sagemaker.estimator import Estimator\n", + "from sagemaker.analytics import TrainingJobAnalytics\n", + "from sagemaker import exceptions\n", + "from sagemaker.tuner import (\n", + " HyperparameterTuner,\n", + " ContinuousParameter,\n", + " IntegerParameter,\n", + " CategoricalParameter,\n", + ")\n", + "from botocore.exceptions import ClientError\n", + "\n", + "# import helper function to convert all xmls to a json file\n", + "sys.path.append(\"./src\")\n", + "from xml2json import XML2JSON, convert_to_pycocotools_ground_truth\n", + "\n", + "sagemaker_session = sagemaker.Session()\n", + "bucket = sagemaker_session.default_bucket()\n", + "role = sagemaker.get_execution_role()\n", + "region = boto3.Session().region_name" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "# Download data for preprocessing\n", + "solution_bucket = \"sagemaker-solutions-prod\"\n", + "solution_name = \"sagemaker-defect-detection/1.4.0\"\n", + "\n", + "original_bucket = f\"s3://{solution_bucket}-{region}/{solution_name}\"\n", + "original_data_prefix = \"data/NEU-DET.zip\"\n", + "original_data = f\"{original_bucket}/{original_data_prefix}\"\n", + "print(\"original data: \")\n", + "S3Downloader.list(original_data)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "pycharm": { + "name": "#%%\n" + }, + "scrolled": true + }, + "outputs": [], + "source": [ + "RAW_DATA_PATH = !echo $PWD/raw_neu_det\n", + "RAW_DATA_PATH = RAW_DATA_PATH.n\n", + "DATA_PATH = !echo $PWD/neu_det\n", + "DATA_PATH = DATA_PATH.n\n", + "\n", + "!mkdir -p $RAW_DATA_PATH\n", + "!aws s3 cp $original_data $RAW_DATA_PATH\n", + "!mkdir -p $DATA_PATH\n", + "os.system('unzip -qq {} -d {}'.format(os.path.join(RAW_DATA_PATH, 'NEU-DET.zip'), RAW_DATA_PATH))\n", + "\n", + "# Folders for training data and output artifacts in s3\n", + "prefix = name_from_base('defect-detection')\n", + "neu_det_s3 = f\"s3://{bucket}/{prefix}\"\n", + "print(neu_det_s3)\n", + "\n", + "s3_input_train = f\"{neu_det_s3}/data\"\n", + "s3_output_location = f\"{neu_det_s3}/output\"" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "papermill": { + "duration": 0.087127, + "end_time": "2022-08-05T08:10:55.443873", + "exception": false, + "start_time": "2022-08-05T08:10:55.356746", + "status": "completed" + }, + "pycharm": { + "name": "#%% md\n" + }, + "tags": [] + }, + "source": [ + "## 1. Data Preparation\n", + "\n", + "The two types of OD models require different data formats.\n", + "The *steel surface dataset* used in this solution contains one xml file for each image as annotation. However, \n", + "neither model uses xml annotations. The Type 1 (legacy) OD model requires either RecordIO or image format in either [*file mode* or *pipe mode*](https://docs.aws.amazon.com/sagemaker/latest/dg/model-access-training-data.html). The Type 2 (latest) OD model requires the input must be a directory with a sub-directory of images and a `annotations.json` file. Please check Section 3 of this [notebook](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/jumpstart_object_detection/Amazon_JumpStart_Object_Detection.ipynb) for more explanation.\n", + "\n", + "In this notebook, we split the data to be train:val:test = 64:16:20. We allocate 20% data as test data to numerically compare all trained models in the end of the notebook. The steel surface dataset has 1800 images in 6 categories, we randomly allocate 20% images from each category to the test data.\n", + "\n", + "We provide a script to convert the remaining 80% xmls to a single `annotations.json` for training the Type 2 (latest) OD model (under the hood, the source code automatically splits the data to be train:val=80:20, equivalent to 64% of all data as train and 16% as val). We provide another script to convert the `annotations.json` and corresponding images to RecordIO data for the Type 1 (legacy) OD model. \n", + "\n", + "If your dataset follows the required input format for Type 1 (legacy) or Type 2 (latest) OD model, you do *not* need these conversions. " + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "execution": { + "iopub.execute_input": "2022-08-05T08:10:55.622902Z", + "iopub.status.busy": "2022-08-05T08:10:55.622181Z", + "iopub.status.idle": "2022-08-05T08:10:56.161298Z", + "shell.execute_reply": "2022-08-05T08:10:56.161654Z" + }, + "papermill": { + "duration": 0.630453, + "end_time": "2022-08-05T08:10:56.161790", + "exception": false, + "start_time": "2022-08-05T08:10:55.531337", + "status": "completed" + }, + "pycharm": { + "name": "#%%\n" + }, + "scrolled": true, + "tags": [] + }, + "outputs": [], + "source": [ + "# Allocate 20% data for testing different models in the end, convert\n", + "# their xmls to test_annotations.json and the remaining 80% to annotations.json\n", + "\n", + "path = \"raw_neu_det/NEU-DET/ANNOTATIONS/\"\n", + "trainXMLFiles = glob.glob(os.path.join(path, \"*.xml\"))\n", + "trainXMLFiles.sort()\n", + "XML2JSON(trainXMLFiles, test_ratio=0.2)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "execution": { + "iopub.execute_input": "2022-08-05T08:10:56.347290Z", + "iopub.status.busy": "2022-08-05T08:10:56.346807Z", + "iopub.status.idle": "2022-08-05T08:11:12.686857Z", + "shell.execute_reply": "2022-08-05T08:11:12.686343Z" + }, + "papermill": { + "duration": 16.436165, + "end_time": "2022-08-05T08:11:12.686974", + "exception": false, + "start_time": "2022-08-05T08:10:56.250809", + "status": "completed" + }, + "pycharm": { + "name": "#%%\n" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " PRE images/\n", + "2022-09-09 18:51:38 368437 annotations.json\n" + ] + } + ], + "source": [ + "# Sync the annotations.json and its corresponding train/val images to s3\n", + "os.makedirs(\"neu_det/images\", exist_ok=True)\n", + "os.makedirs(\"results\", exist_ok=True)\n", + "\n", + "src_path = \"raw_neu_det/NEU-DET/IMAGES\"\n", + "dst_path = \"neu_det/images\"\n", + "\n", + "with open(\"annotations.json\") as f:\n", + " images_annotations = json.loads(f.read())\n", + "\n", + "for entry in images_annotations[\"images\"]:\n", + " image_path = os.path.join(src_path, entry[\"file_name\"])\n", + " os.system(f\"cp {image_path} {dst_path}\")\n", + "\n", + "!mv annotations.json neu_det\n", + "!aws s3 sync neu_det $s3_input_train --quiet # remove the --quiet flag to view the sync logs\n", + "!aws s3 ls $s3_input_train/" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "papermill": { + "duration": 0.088721, + "end_time": "2022-08-05T08:11:12.865774", + "exception": false, + "start_time": "2022-08-05T08:11:12.777053", + "status": "completed" + }, + "pycharm": { + "name": "#%% md\n" + }, + "tags": [] + }, + "source": [ + "## 2. Training: Finetune Type 1 (Legacy) OD Model\n", + "\n", + "\n", + "We start from finetuning the Type 1 (legacy) OD model, which is the SSD model with ResNet as backbone, and pretrained on ImageNet. \n", + "\n", + "**Input data**: follow the [instruction](https://docs.aws.amazon.com/sagemaker/latest/dg/object-detection.html), the legacy OD model supports both RecordIO and image types for training in `file` mode, or RecordIO in `pipe` mode. In this notebook, we use RecordIO in file mode.\n", + "We provide a script for converting the `annotations.json` to RecordIO format. The [document](https://cv.gluon.ai/build/examples_datasets/detection_custom.html#lst-label-for-gluoncv-and-mxnet) and [example](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/object_detection_birds/object_detection_birds.html#Generate-RecordIO-files) provide some context for understanding the script.\n", + "\n", + "This script first splits the data to train:val = 80:20 according to the `train-ratio`. This is equivalent to use 64% of all data for training and 16% for validation. Then converts each partition, including images and annotations, to a .rec file. We use the validation data for selecting the best job in HPO training in the next section, and use the test data for numerically comparing all finetuned models. " + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "execution": { + "iopub.execute_input": "2022-08-05T08:11:13.050208Z", + "iopub.status.busy": "2022-08-05T08:11:13.049551Z", + "iopub.status.idle": "2022-08-05T08:11:20.915473Z", + "shell.execute_reply": "2022-08-05T08:11:20.915849Z" + }, + "papermill": { + "duration": 7.960309, + "end_time": "2022-08-05T08:11:20.915977", + "exception": false, + "start_time": "2022-08-05T08:11:12.955668", + "status": "completed" + }, + "pycharm": { + "name": "#%%\n" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "!python ./src/prepare_RecordIO.py ./neu_det/data ./neu_det/images --train-ratio 0.8" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# Upload the RecordIO files to train and validation channels in s3\n", + "\n", + "train_channel = f\"{prefix}/OD_Type1_train\"\n", + "validation_channel = f\"{prefix}/OD_Type1_validation\"\n", + "\n", + "s3_train_data = f\"s3://{bucket}/{train_channel}\"\n", + "s3_validation_data = f\"s3://{bucket}/{validation_channel}\"\n", + "s3_output_location = f\"s3://{bucket}/{prefix}/OD_output\"\n", + "\n", + "!aws s3 cp neu_det/data_train.rec $s3_train_data/\n", + "!aws s3 cp neu_det/data_val.rec $s3_validation_data/\n", + "!aws s3 ls $s3_train_data/\n", + "\n", + "train_data = sagemaker.inputs.TrainingInput(\n", + " s3_train_data,\n", + " distribution=\"FullyReplicated\",\n", + " content_type=\"application/x-recordio\",\n", + " s3_data_type=\"S3Prefix\",\n", + ")\n", + "validation_data = sagemaker.inputs.TrainingInput(\n", + " s3_validation_data,\n", + " distribution=\"FullyReplicated\",\n", + " content_type=\"application/x-recordio\",\n", + " s3_data_type=\"S3Prefix\",\n", + ")\n", + "\n", + "data_channels = {\"train\": train_data, \"validation\": validation_data}" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "papermill": { + "duration": 1773.804904, + "end_time": "2022-08-05T08:40:57.814014", + "exception": false, + "start_time": "2022-08-05T08:11:24.009110", + "status": "completed" + }, + "pycharm": { + "name": "#%%\n" + }, + "scrolled": true, + "tags": [] + }, + "outputs": [], + "source": [ + "# Train Type 1 (legacy) OD model\n", + "job_name_prefix = \"od-Type1\"\n", + "\n", + "\n", + "num_classes = 6\n", + "num_training_samples = 1152 # total 1800 images, use 64% for training\n", + "\n", + "train_image_uri = image_uris.retrieve(\n", + " region=sagemaker_session.boto_region_name, framework=\"object-detection\", version=\"latest\"\n", + ")\n", + "\n", + "print(\"Train Type 1 (legacy) OD model -------------------\")\n", + "\n", + "# In case one type of EC2 instance is not available and fails the training, try another EC2 instance type.\n", + "# This built-in OD algorithm only accepts GPU instances for training.\n", + "for instance in [\"ml.p3.2xlarge\", \"ml.g4dn.xlarge\", \"ml.g5.2xlarge\"]:\n", + " try:\n", + " od_model = Estimator(\n", + " train_image_uri,\n", + " role,\n", + " instance_count=1,\n", + " instance_type=instance,\n", + " volume_size=50,\n", + " max_run=360000,\n", + " input_mode=\"File\",\n", + " output_path=s3_output_location,\n", + " sagemaker_session=sagemaker_session,\n", + " base_job_name=job_name_prefix,\n", + " )\n", + "\n", + " od_model.set_hyperparameters(\n", + " base_network=\"resnet-50\",\n", + " use_pretrained_model=1,\n", + " num_classes=num_classes,\n", + " mini_batch_size=16,\n", + " epochs=num_epochs,\n", + " learning_rate=0.001,\n", + " momentum=0.9,\n", + " weight_decay=0.0005,\n", + " lr_scheduler_step=\"33,67\",\n", + " lr_scheduler_factor=0.1,\n", + " optimizer=\"sgd\",\n", + " overlap_threshold=0.5,\n", + " nms_threshold=0.45,\n", + " num_training_samples=num_training_samples,\n", + " )\n", + "\n", + " model = od_model.fit(inputs=data_channels, logs=\"All\")\n", + "\n", + " except exceptions.CapacityError as e:\n", + " print(\"Training Exception:\", e)\n", + " print(f\"{instance} is not available !!\")\n", + " continue\n", + " except exceptions.UnexpectedStatusException as e:\n", + " print(\"Training Exception:\", e)\n", + " continue\n", + " except ClientError as e:\n", + " print(\"Training Exception:\", e)\n", + " continue\n", + " else:\n", + " print(f\"Instance {instance} is available !\")\n", + " break" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "papermill": { + "duration": 0.213955, + "end_time": "2022-08-05T08:40:58.244299", + "exception": false, + "start_time": "2022-08-05T08:40:58.030344", + "status": "completed" + }, + "pycharm": { + "name": "#%% md\n" + }, + "tags": [] + }, + "source": [ + "### Visualize Training Progress\n", + "\n", + "During training, the loss function is the sum of CrossEntropy loss and SmoothL1 loss. We visualize the two losses on the training data as well as the mean Average Precision (mAP) on the validation data." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "execution": { + "iopub.execute_input": "2022-08-05T08:40:58.683010Z", + "iopub.status.busy": "2022-08-05T08:40:58.682430Z", + "iopub.status.idle": "2022-08-05T08:41:00.010425Z", + "shell.execute_reply": "2022-08-05T08:41:00.010800Z" + }, + "papermill": { + "duration": 1.552394, + "end_time": "2022-08-05T08:41:00.010926", + "exception": false, + "start_time": "2022-08-05T08:40:58.458532", + "status": "completed" + }, + "pycharm": { + "name": "#%%\n" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "job_name = od_model.latest_training_job.job_name\n", + "df = TrainingJobAnalytics(job_name).dataframe()\n", + "\n", + "OD_Type1_metrics = list(set(df.metric_name.values))\n", + "print(\"All metrics:\", OD_Type1_metrics)\n", + "num_metrics = len(OD_Type1_metrics)\n", + "\n", + "# The train:progress shows the N training epochs, use it to index x axis\n", + "epochs = df[df[\"metric_name\"] == \"train:progress\"][\"value\"].values\n", + "df = df[df[\"metric_name\"] != \"train:progress\"]\n", + "\n", + "\n", + "plt.figure(figsize=(18, 5))\n", + "cnt = 1\n", + "for m in OD_Type1_metrics:\n", + " if m != \"train:progress\":\n", + " d = df[df[\"metric_name\"] == m]\n", + "\n", + " if m == \"validation:mAP\":\n", + " v = list(d.value)[-1]\n", + " print(f\"Final validation:mAP = {v:.4f}\")\n", + " plt.subplot(1, num_metrics - 1, cnt)\n", + "\n", + " # in case length mismatch\n", + " l1, l2 = len(epochs), len(d[\"value\"])\n", + " l = min(l1, l2)\n", + " plt.plot(epochs[-l:], d[\"value\"][-l:])\n", + "\n", + " plt.title(m)\n", + " plt.xlabel(\"epoch\")\n", + " plt.ylabel(m)\n", + " cnt += 1\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "papermill": { + "duration": 0.218728, + "end_time": "2022-08-05T08:41:00.449363", + "exception": false, + "start_time": "2022-08-05T08:41:00.230635", + "status": "completed" + }, + "pycharm": { + "name": "#%% md\n" + }, + "tags": [] + }, + "source": [ + "### Deployment\n", + "\n", + "The inference will be deferred to the end of the notebook" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "execution": { + "iopub.execute_input": "2022-08-05T08:41:00.893151Z", + "iopub.status.busy": "2022-08-05T08:41:00.892688Z", + "iopub.status.idle": "2022-08-05T08:46:06.239031Z", + "shell.execute_reply": "2022-08-05T08:46:06.239410Z" + }, + "papermill": { + "duration": 305.570082, + "end_time": "2022-08-05T08:46:06.239535", + "exception": false, + "start_time": "2022-08-05T08:41:00.669453", + "status": "completed" + }, + "pycharm": { + "name": "#%%\n" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "od_type1_endpoint_name = name_from_base(\"od-Type1\")\n", + "print(od_type1_endpoint_name)\n", + "od_type1_predictor = od_model.deploy(\n", + " endpoint_name=od_type1_endpoint_name, initial_instance_count=1, instance_type=\"ml.m4.xlarge\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "papermill": { + "duration": 0.22511, + "end_time": "2022-08-05T08:46:06.693053", + "exception": false, + "start_time": "2022-08-05T08:46:06.467943", + "status": "completed" + }, + "pycharm": { + "name": "#%% md\n" + }, + "tags": [] + }, + "source": [ + "## 3. Training: Finetune Type 1 (Legacy) OD model with HPO\n", + "\n", + "Now we run HPO to find better hyperparameters which lead to better model. You could find all [finetunable hyperparameters](https://docs.aws.amazon.com/sagemaker/latest/dg/object-detection-tuning.html) for the Type 1 (legacy) OD model. In this notebook, we only finetune learning rate, momentum, and weight decay. \n", + "\n", + "We use [Sagemaker Automatic Model Tuning](https://docs.aws.amazon.com/sagemaker/latest/dg/automatic-model-tuning.html) (AMT) to run HPO. We need to provide hyperparameter ranges and objective metrics. AMT monitors the log and parses the objective metrics. For object detection, we use mean Average Precision (mAP) on the validation dataset as our metric. mAP is the standard evaluation metric used in the [COCO Challenge](https://cocodataset.org/#detection-eval) for object detection tasks. Here is a nice [blog post](https://jonathan-hui.medium.com/map-mean-average-precision-for-object-detection-45c121a31173) explaining mAP for object detection. \n", + "\n", + "We run `max_jobs=20` jobs in this HPO. You could run more jobs to find even better hyperparameters, at the cost of more compute resources and training time. This HPO job takes about 1 hour using p3.2xlarge EC2 instance and run `max_parallel_jobs=10` jobs in parallel." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "papermill": { + "duration": 3580.578995, + "end_time": "2022-08-05T09:45:47.498375", + "exception": false, + "start_time": "2022-08-05T08:46:06.919380", + "status": "completed" + }, + "pycharm": { + "name": "#%%\n" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "tuning_job_name = \"od-Type1-HPO\"\n", + "\n", + "hyperparameter_ranges = {\n", + " \"learning_rate\": ContinuousParameter(1e-4, 1e-2),\n", + " \"momentum\": ContinuousParameter(0.8, 0.99),\n", + " \"weight_decay\": ContinuousParameter(1e-4, 1e-3),\n", + "}\n", + "\n", + "objective_metric_name = \"validation:mAP\"\n", + "\n", + "print(\"Train Type 1 (legacy) OD model with HPO -------------------\")\n", + "\n", + "for instance in [\"ml.p3.2xlarge\", \"ml.g4dn.xlarge\", \"ml.g5.2xlarge\"]:\n", + " try:\n", + " od_model = Estimator(\n", + " train_image_uri,\n", + " role,\n", + " instance_count=1,\n", + " instance_type=instance,\n", + " volume_size=50,\n", + " max_run=360000,\n", + " input_mode=\"File\",\n", + " output_path=s3_output_location,\n", + " sagemaker_session=sagemaker_session,\n", + " base_job_name=job_name_prefix,\n", + " )\n", + "\n", + " od_model.set_hyperparameters(\n", + " base_network=\"resnet-50\",\n", + " use_pretrained_model=1,\n", + " num_classes=num_classes,\n", + " mini_batch_size=16,\n", + " epochs=num_epochs,\n", + " # learning_rate=0.001,\n", + " # momentum=0.9,\n", + " # weight_decay=0.0005,\n", + " lr_scheduler_step=\"33,67\",\n", + " lr_scheduler_factor=0.1,\n", + " optimizer=\"sgd\",\n", + " overlap_threshold=0.5,\n", + " nms_threshold=0.45,\n", + " num_training_samples=num_training_samples,\n", + " )\n", + "\n", + " tuner = HyperparameterTuner(\n", + " od_model,\n", + " objective_metric_name,\n", + " hyperparameter_ranges,\n", + " objective_type=\"Maximize\",\n", + " max_jobs=max_jobs, # <-- increase to 20 or more\n", + " max_parallel_jobs=max_parallel_jobs, # <- increase this number if more EC2 instances are available\n", + " base_tuning_job_name=tuning_job_name,\n", + " )\n", + "\n", + " tuner.fit(inputs=data_channels, logs=\"All\")\n", + "\n", + " except exceptions.CapacityError as e:\n", + " print(\"Training exception:\", e)\n", + " print(f\"{instance} is not available !!\")\n", + " continue\n", + " except exceptions.UnexpectedStatusException as e:\n", + " print(\"Training exception:\", e)\n", + " continue\n", + " except ClientError as e:\n", + " print(\"Training Exception:\", e)\n", + " continue\n", + " else:\n", + " print(f\"Instance {instance} is available !\")\n", + " break" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "execution": { + "iopub.execute_input": "2022-08-05T09:45:48.928117Z", + "iopub.status.busy": "2022-08-05T09:45:48.927223Z", + "iopub.status.idle": "2022-08-05T09:45:49.349450Z", + "shell.execute_reply": "2022-08-05T09:45:49.349788Z" + }, + "papermill": { + "duration": 1.141879, + "end_time": "2022-08-05T09:45:49.349908", + "exception": false, + "start_time": "2022-08-05T09:45:48.208029", + "status": "completed" + }, + "pycharm": { + "name": "#%%\n" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "tuning_job_name = tuner.latest_tuning_job.name\n", + "print(\"tuning_job_name\", tuning_job_name)\n", + "\n", + "tuner_analytics = sagemaker.HyperparameterTuningJobAnalytics(tuning_job_name)\n", + "\n", + "full_df = tuner_analytics.dataframe()\n", + "\n", + "if len(full_df) > 0:\n", + " df = full_df[full_df[\"FinalObjectiveValue\"] > -float(\"inf\")]\n", + " if len(df) > 0:\n", + " df = df.sort_values(\"FinalObjectiveValue\", ascending=False)\n", + " # filter out failed jobs.\n", + " df = df[df[\"TrainingJobStatus\"] == \"Completed\"]\n", + " print(\n", + " f\"Number of training jobs completed and with valid objective: {len(df)} / {len(full_df)}\"\n", + " )\n", + " print({\"lowest\": min(df[\"FinalObjectiveValue\"]), \"highest\": max(df[\"FinalObjectiveValue\"])})\n", + " pd.set_option(\"display.max_colwidth\", None) # Don't truncate TrainingJobName\n", + " else:\n", + " print(\"No training jobs have reported valid results yet.\")\n", + "\n", + "df" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "execution": { + "iopub.execute_input": "2022-08-05T09:45:50.790276Z", + "iopub.status.busy": "2022-08-05T09:45:50.783410Z", + "iopub.status.idle": "2022-08-05T09:45:52.368619Z", + "shell.execute_reply": "2022-08-05T09:45:52.368958Z" + }, + "papermill": { + "duration": 2.307233, + "end_time": "2022-08-05T09:45:52.369084", + "exception": false, + "start_time": "2022-08-05T09:45:50.061851", + "status": "completed" + }, + "pycharm": { + "name": "#%%\n" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "best job: sagemaker-soln-dfd-c-220805-0846-014-f4010610\n", + "best job final validation:mAP = 0.694232\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Warning: No metrics called train:throughput found\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "All metrics: ['train:progress', 'validation:mAP', 'train:smooth_l1', 'ObjectiveMetric', 'train:cross_entropy']\n", + "ObjectiveMetric is exactly the same as validation:mAP\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Visualize the training progress of the best job\n", + "best_job_name = df.iloc[0][\"TrainingJobName\"]\n", + "print(\"best job:\", best_job_name)\n", + "v = df.iloc[0][\"FinalObjectiveValue\"]\n", + "print(f\"best job final validation:mAP = {v:.6f}\")\n", + "\n", + "df_best = TrainingJobAnalytics(best_job_name).dataframe()\n", + "\n", + "OD_Type1_metrics = list(set(df_best.metric_name.values))\n", + "print(\"All metrics:\", OD_Type1_metrics)\n", + "print(\"ObjectiveMetric is exactly the same as validation:mAP\")\n", + "num_metrics = len(OD_Type1_metrics)\n", + "\n", + "# The train:progress shows the N training epochs, use it to index x axis\n", + "epochs = df_best[df_best[\"metric_name\"] == \"train:progress\"][\"value\"].values\n", + "df_best = df_best[df_best[\"metric_name\"] != \"train:progress\"]\n", + "\n", + "plt.figure(figsize=(18, 5))\n", + "cnt = 1\n", + "for m in OD_Type1_metrics:\n", + " if m != \"train:progress\" and m != \"ObjectiveMetric\":\n", + "\n", + " d = df_best[df_best[\"metric_name\"] == m]\n", + " plt.subplot(1, num_metrics - 2, cnt)\n", + "\n", + " # in case length mismatch\n", + " l1, l2 = len(epochs), len(d[\"value\"])\n", + " l = min(l1, l2)\n", + " plt.plot(epochs[-l:], d[\"value\"][-l:])\n", + "\n", + " plt.title(m)\n", + " plt.xlabel(\"epoch\")\n", + " plt.ylabel(m)\n", + " cnt += 1\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "papermill": { + "duration": 0.718616, + "end_time": "2022-08-05T09:45:53.823858", + "exception": false, + "start_time": "2022-08-05T09:45:53.105242", + "status": "completed" + }, + "pycharm": { + "name": "#%% md\n" + }, + "tags": [] + }, + "source": [ + "### Deploy the best model from HPO\n", + "\n", + "The inference will be deferred to the end of the notebook" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "execution": { + "iopub.execute_input": "2022-08-05T09:45:55.265867Z", + "iopub.status.busy": "2022-08-05T09:45:55.265381Z", + "iopub.status.idle": "2022-08-05T09:51:31.498944Z", + "shell.execute_reply": "2022-08-05T09:51:31.499325Z" + }, + "papermill": { + "duration": 336.956626, + "end_time": "2022-08-05T09:51:31.499449", + "exception": false, + "start_time": "2022-08-05T09:45:54.542823", + "status": "completed" + }, + "pycharm": { + "name": "#%%\n" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "od_type1_hpo_endpoint_name = name_from_base(\"od-Type1-HPO\")\n", + "print(od_type1_hpo_endpoint_name)\n", + "od_type1_hpo_predictor = tuner.deploy(\n", + " endpoint_name=od_type1_hpo_endpoint_name, initial_instance_count=1, instance_type=\"ml.m4.xlarge\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "papermill": { + "duration": 0.727216, + "end_time": "2022-08-05T09:51:32.950098", + "exception": false, + "start_time": "2022-08-05T09:51:32.222882", + "status": "completed" + }, + "pycharm": { + "name": "#%% md\n" + }, + "tags": [] + }, + "source": [ + "## 4. Training: Finetune Type 2 (Latest) OD Model\n", + "\n", + "For the Type 2 (latest) OD model, we follow [Fine-tune a Model and Deploy to a SageMaker Endpoint\n", + "](https://sagemaker.readthedocs.io/en/stable/overview.html#fine-tune-a-model-and-deploy-to-a-sagemaker-endpoint) and use standard Sagemaker APIs. \n", + "\n", + "You can find all finetunable Type 2 (latest) OD models in [Built-in Algorithms with pre-trained Model Table](https://sagemaker.readthedocs.io/en/stable/doc_utils/pretrainedmodels.html) by searching with keywords \"object detection\" and set `FineTunable?=True`.\n", + "Currently there are 9 finetunable OD models:\n", + "1. mxnet-od-ssd-300-vgg16-atrous-coco\n", + "2. mxnet-od-ssd-512-vgg16-atrous-voc\n", + "3. mxnet-od-ssd-512-resnet50-v1-coco\n", + "4. mxnet-od-ssd-512-mobilenet1-0-coco\n", + "5. mxnet-od-ssd-300-vgg16-atrous-voc\n", + "6. mxnet-od-ssd-512-resnet50-v1-voc\n", + "7. mxnet-od-ssd-512-mobilenet1-0-voc\n", + "8. mxnet-od-ssd-512-vgg16-atrous-coco\n", + "9. pytorch-od1-fasterrcnn-resnet50-fpn\n", + "\n", + "\n", + "There are two major differences between training the two types of OD models: \n", + "1. The entry point `transfer_learning.py` for finetuning a Type 2 (latest) OD model does not accept a validation data channel. Instead, it splits the input data provided through `estimator.fit({\"training\": s3_input_train})` to be train:val=80:20, corresponding to use 64% of total data for training and 16% for validation. Note, the train/val data are different from train/val for training Type 1 (legacy) OD model. \n", + "2. The evaluation metrics are different. While Type 1 (legacy) OD model reports mAP on the validation data, which is standard, the Type 2 (latest) OD model only reports CrossEntropy loss and SmoothL1 loss on the validation data. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "execution": { + "iopub.execute_input": "2022-08-05T09:51:34.423432Z", + "iopub.status.busy": "2022-08-05T09:51:34.422929Z", + "iopub.status.idle": "2022-08-05T11:20:33.848399Z", + "shell.execute_reply": "2022-08-05T11:20:33.848733Z" + }, + "papermill": { + "duration": 5340.169351, + "end_time": "2022-08-05T11:20:33.848883", + "exception": false, + "start_time": "2022-08-05T09:51:33.679532", + "status": "completed" + }, + "pycharm": { + "name": "#%%\n" + }, + "scrolled": true, + "tags": [] + }, + "outputs": [], + "source": [ + "job_name_prefix = \"od-Type2\"\n", + "\n", + "# Choose a pre-trained model and fine-tune on new dataset\n", + "model_id, model_version = \"mxnet-od-ssd-512-vgg16-atrous-voc\", \"*\"\n", + "\n", + "scope = \"training\"\n", + "\n", + "# Define metrics for visualization\n", + "# You can visualize in Training / Traning jobs from Sagemaker Dashboard\n", + "if model_id.startswith(\"mxnet\"):\n", + " metric_definitions = [\n", + " {\"Name\": \"CrossEntropy\", \"Regex\": \"CrossEntropy=(.*?),\"},\n", + " {\"Name\": \"SmoothL1\", \"Regex\": \"SmoothL1=(.*)\"},\n", + " {\"Name\": \"Val_CrossEntropy\", \"Regex\": \"Val_CrossEntropy=(.*?),\"},\n", + " {\"Name\": \"Val_SmoothL1\", \"Regex\": \"Val_SmoothL1=(.*)\"},\n", + " ]\n", + "elif model_id.startswith(\"pytorch\"):\n", + " metric_definitions = [\n", + " {\"Name\": \"train_loss\", \"Regex\": \"train_loss:(.*?) \\(\"},\n", + " {\"Name\": \"train_loss_classifier\", \"Regex\": \"train_loss_classifier:(.*?) \\(\"},\n", + " {\"Name\": \"train_loss_box_reg\", \"Regex\": \"train_loss_box_reg:(.*?) \\(\"},\n", + " {\"Name\": \"train_loss_objectness\", \"Regex\": \"train_loss_objectness:(.*?) \\(\"},\n", + " {\"Name\": \"train_loss_rpn_box_reg\", \"Regex\": \"train_loss_rpn_box_reg:(.*?) \\(\"},\n", + " {\"Name\": \"val_loss\", \"Regex\": \"val_loss:(.*?) \\(\"},\n", + " ]\n", + "else:\n", + " print(\"Incorrect model_id\")\n", + "\n", + "# Retrieve base model, training script, and training docker image\n", + "train_model_uri = model_uris.retrieve(\n", + " model_id=model_id, model_version=model_version, model_scope=scope\n", + ")\n", + "train_script_uri = script_uris.retrieve(\n", + " model_id=model_id, model_version=model_version, script_scope=scope\n", + ")\n", + "\n", + "# Change default hyperparameter values\n", + "hyperparameters = hyperparameters.retrieve_default(model_id=model_id, model_version=model_version)\n", + "hyperparameters[\"epochs\"] = num_epochs # 100 epochs takes 2 hours\n", + "hyperparameters[\n", + " \"batch-size\"\n", + "] = 8 # larger (e.g. 16) batch-size could lead to insufficient memory issue.\n", + "print(hyperparameters)\n", + "\n", + "print(\"Train Type 2 (latest) OD model -------------------\")\n", + "\n", + "for training_instance_type in [\"ml.p3.2xlarge\", \"ml.g4dn.xlarge\", \"ml.g5.xlarge\", \"ml.m5.4xlarge\"]:\n", + " try:\n", + " train_image_uri = image_uris.retrieve(\n", + " region=None,\n", + " framework=None,\n", + " image_scope=scope,\n", + " model_id=model_id,\n", + " model_version=model_version,\n", + " instance_type=training_instance_type,\n", + " )\n", + "\n", + " estimator = Estimator(\n", + " role=role,\n", + " image_uri=train_image_uri,\n", + " source_dir=train_script_uri,\n", + " model_uri=train_model_uri,\n", + " entry_point=\"transfer_learning.py\",\n", + " hyperparameters=hyperparameters,\n", + " instance_count=1,\n", + " instance_type=training_instance_type,\n", + " max_run=36000,\n", + " output_path=s3_output_location,\n", + " base_job_name=job_name_prefix,\n", + " metric_definitions=metric_definitions,\n", + " )\n", + "\n", + " estimator.fit({\"training\": s3_input_train}, logs=\"All\")\n", + "\n", + " except exceptions.CapacityError as e:\n", + " print(\"Training exception:\", e)\n", + " print(f\"{training_instance_type} is not available !!\")\n", + " continue\n", + " except exceptions.UnexpectedStatusException as e:\n", + " print(\"Training exception:\", e)\n", + " continue\n", + " except ClientError as e:\n", + " print(\"Training Exception:\", e)\n", + " continue\n", + " else:\n", + " print(f\"Instance {training_instance_type} is available !\")\n", + " break" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "execution": { + "iopub.execute_input": "2022-08-05T11:20:35.631189Z", + "iopub.status.busy": "2022-08-05T11:20:35.630667Z", + "iopub.status.idle": "2022-08-05T11:20:37.122568Z", + "shell.execute_reply": "2022-08-05T11:20:37.122968Z" + }, + "papermill": { + "duration": 2.388309, + "end_time": "2022-08-05T11:20:37.123101", + "exception": false, + "start_time": "2022-08-05T11:20:34.734792", + "status": "completed" + }, + "pycharm": { + "name": "#%%\n" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Visualization\n", + "job_name = estimator.latest_training_job.job_name\n", + "df = TrainingJobAnalytics(job_name).dataframe()\n", + "\n", + "metric_names = [d[\"Name\"] for d in metric_definitions]\n", + "num_metrics = len(metric_names)\n", + "\n", + "plt.figure(figsize=(16, 5))\n", + "for i in range(num_metrics):\n", + " d = df[df[\"metric_name\"] == metric_names[i]]\n", + " plt.subplot(1, num_metrics, i + 1)\n", + " plt.plot(range(len(d)), d[\"value\"])\n", + " plt.title(metric_names[i])\n", + " plt.xlabel(\"epoch\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "papermill": { + "duration": 0.929678, + "end_time": "2022-08-05T11:20:38.942516", + "exception": false, + "start_time": "2022-08-05T11:20:38.012838", + "status": "completed" + }, + "pycharm": { + "name": "#%% md\n" + }, + "tags": [] + }, + "source": [ + "### Deployment" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "execution": { + "iopub.execute_input": "2022-08-05T11:20:40.714712Z", + "iopub.status.busy": "2022-08-05T11:20:40.714197Z", + "iopub.status.idle": "2022-08-05T11:25:43.986414Z", + "shell.execute_reply": "2022-08-05T11:25:43.986817Z" + }, + "papermill": { + "duration": 304.159559, + "end_time": "2022-08-05T11:25:43.986942", + "exception": false, + "start_time": "2022-08-05T11:20:39.827383", + "status": "completed" + }, + "pycharm": { + "name": "#%%\n" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "scope = \"inference\"\n", + "inference_instance_type = \"ml.m4.xlarge\"\n", + "\n", + "# Retrieve inference docker image and inference script\n", + "deploy_script_uri = script_uris.retrieve(\n", + " model_id=model_id, model_version=model_version, script_scope=scope\n", + ")\n", + "deploy_image_uri = image_uris.retrieve(\n", + " region=None,\n", + " framework=None,\n", + " image_scope=scope,\n", + " model_id=model_id,\n", + " model_version=model_version,\n", + " instance_type=inference_instance_type,\n", + ")\n", + "\n", + "od_type2_endpoint_name = name_from_base(\"od-Type2\")\n", + "print(od_type2_endpoint_name)\n", + "\n", + "od_type2_predictor = estimator.deploy(\n", + " initial_instance_count=1,\n", + " instance_type=inference_instance_type,\n", + " entry_point=\"inference.py\", # entry point file in source_dir and present in deploy_source_uri\n", + " image_uri=deploy_image_uri,\n", + " source_dir=deploy_script_uri,\n", + " endpoint_name=od_type2_endpoint_name,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "papermill": { + "duration": 0.889437, + "end_time": "2022-08-05T11:25:45.764694", + "exception": false, + "start_time": "2022-08-05T11:25:44.875257", + "status": "completed" + }, + "pycharm": { + "name": "#%% md\n" + }, + "tags": [] + }, + "source": [ + "## 5. Training: Finetune Type 2 (Latest) OD model with HPO\n", + "\n", + "The Type 2 (latest) OD model training reports Val_CrossEntropy loss and Val_SmoothL1 loss instead of mAP on the validation dataset. Since we can only specify one evaluation metric for AMT, we choose to minimize Val_CrossEntropy. It is not the standard practice for evaluating OD models, but is the best choice for now. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "execution": { + "iopub.execute_input": "2022-08-05T11:25:47.553857Z", + "iopub.status.busy": "2022-08-05T11:25:47.553321Z", + "iopub.status.idle": "2022-08-05T14:27:21.588461Z", + "shell.execute_reply": "2022-08-05T14:27:21.588081Z" + }, + "papermill": { + "duration": 10894.93115, + "end_time": "2022-08-05T14:27:21.588568", + "exception": false, + "start_time": "2022-08-05T11:25:46.657418", + "status": "completed" + }, + "pycharm": { + "name": "#%%\n" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "tuning_job_name = \"od-Type2-HPO\"\n", + "\n", + "scope = \"training\"\n", + "\n", + "objective_metric_name = \"Val_CrossEntropy\" if model_id.startswith(\"mxnet\") else \"val_loss\"\n", + "hyperparameter_ranges = {\n", + " \"adam-learning-rate\": ContinuousParameter(1e-4, 1e-1, scaling_type=\"Logarithmic\"),\n", + "}\n", + "\n", + "print(\"Train Type 2 (latest) OD model with HPO -------------------\")\n", + "\n", + "for training_instance_type in [\"ml.p3.2xlarge\", \"ml.g4dn.xlarge\", \"ml.g5.xlarge\", \"ml.m5.2xlarge\"]:\n", + " try:\n", + " train_image_uri = image_uris.retrieve(\n", + " region=None,\n", + " framework=None,\n", + " image_scope=scope,\n", + " model_id=model_id,\n", + " model_version=model_version,\n", + " instance_type=training_instance_type,\n", + " )\n", + "\n", + " estimator = Estimator(\n", + " role=role,\n", + " image_uri=train_image_uri,\n", + " source_dir=train_script_uri,\n", + " model_uri=train_model_uri,\n", + " entry_point=\"transfer_learning.py\",\n", + " hyperparameters=hyperparameters,\n", + " instance_count=1,\n", + " instance_type=training_instance_type,\n", + " max_run=36000,\n", + " output_path=s3_output_location,\n", + " base_job_name=job_name_prefix,\n", + " metric_definitions=metric_definitions,\n", + " )\n", + "\n", + " tuner = HyperparameterTuner(\n", + " estimator,\n", + " objective_metric_name,\n", + " hyperparameter_ranges,\n", + " metric_definitions,\n", + " objective_type=\"Minimize\",\n", + " max_jobs=max_jobs,\n", + " max_parallel_jobs=max_parallel_jobs, # <- increase this number if more EC2 instances are available\n", + " base_tuning_job_name=tuning_job_name,\n", + " )\n", + "\n", + " tuner.fit({\"training\": s3_input_train}, logs=True)\n", + "\n", + " except exceptions.CapacityError as e:\n", + " print(\"Training exception:\", e)\n", + " print(f\"{training_instance_type} is not available !!\")\n", + " continue\n", + " except exceptions.UnexpectedStatusException as e:\n", + " print(\"Training exception:\", e)\n", + " continue\n", + " except ClientError as e:\n", + " print(\"Training Exception:\", e)\n", + " continue\n", + " else:\n", + " print(f\"Instance {training_instance_type} is available !\")\n", + " break" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "execution": { + "iopub.execute_input": "2022-08-05T14:27:26.353071Z", + "iopub.status.busy": "2022-08-05T14:27:26.352291Z", + "iopub.status.idle": "2022-08-05T14:27:26.717424Z", + "shell.execute_reply": "2022-08-05T14:27:26.717775Z" + }, + "papermill": { + "duration": 2.759517, + "end_time": "2022-08-05T14:27:26.717902", + "exception": false, + "start_time": "2022-08-05T14:27:23.958385", + "status": "completed" + }, + "pycharm": { + "name": "#%%\n" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "tuning_job_name = tuner.latest_tuning_job.name\n", + "print(\"tuning_job_name\", tuning_job_name)\n", + "\n", + "tuner_analytics = sagemaker.HyperparameterTuningJobAnalytics(tuning_job_name)\n", + "\n", + "full_df = tuner_analytics.dataframe()\n", + "\n", + "if len(full_df) > 0:\n", + " df = full_df[full_df[\"FinalObjectiveValue\"] > -float(\"inf\")]\n", + " if len(df) > 0:\n", + " df = df.sort_values(\"FinalObjectiveValue\", ascending=True)\n", + " # filter out failed jobs.\n", + " df = df[df[\"TrainingJobStatus\"] == \"Completed\"]\n", + " print(\n", + " f\"Number of training jobs completed and with valid objective: {len(df)} / {len(full_df)}\"\n", + " )\n", + " print({\"lowest\": min(df[\"FinalObjectiveValue\"]), \"highest\": max(df[\"FinalObjectiveValue\"])})\n", + " pd.set_option(\"display.max_colwidth\", None) # Don't truncate TrainingJobName\n", + " else:\n", + " print(\"No training jobs have reported valid results yet.\")\n", + "\n", + "df" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "execution": { + "iopub.execute_input": "2022-08-05T14:27:31.544907Z", + "iopub.status.busy": "2022-08-05T14:27:31.544413Z", + "iopub.status.idle": "2022-08-05T14:27:33.203343Z", + "shell.execute_reply": "2022-08-05T14:27:33.203701Z" + }, + "papermill": { + "duration": 4.035178, + "end_time": "2022-08-05T14:27:33.203832", + "exception": false, + "start_time": "2022-08-05T14:27:29.168654", + "status": "completed" + }, + "pycharm": { + "name": "#%%\n" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "best job: sagemaker-soln-dfd-c-220805-1125-003-3d4b78cc\n", + "best job final Val_CrossEntropy = 2.192000\n", + "All metrics: ['SmoothL1', 'Val_CrossEntropy', 'Val_SmoothL1', 'CrossEntropy', 'ObjectiveMetric']\n", + "ObjectiveMetric is exactly the same as Val_CrossEntropy\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Visualize the training progress of the best job\n", + "best_job_name = df.iloc[0][\"TrainingJobName\"]\n", + "print(\"best job:\", best_job_name)\n", + "v = df.iloc[0][\"FinalObjectiveValue\"]\n", + "print(f\"best job final Val_CrossEntropy = {v:.6f}\")\n", + "\n", + "df_best = TrainingJobAnalytics(best_job_name).dataframe()\n", + "\n", + "OD_Type2_metrics = list(set(df_best.metric_name.values))\n", + "print(\"All metrics:\", OD_Type2_metrics)\n", + "print(\"ObjectiveMetric is exactly the same as Val_CrossEntropy\")\n", + "num_metrics = len(OD_Type2_metrics)\n", + "\n", + "plt.figure(figsize=(18, 5))\n", + "cnt = 1\n", + "for m in OD_Type2_metrics:\n", + " if m != \"ObjectiveMetric\":\n", + "\n", + " d = df_best[df_best[\"metric_name\"] == m]\n", + "\n", + " plt.subplot(1, num_metrics - 1, cnt)\n", + " plt.plot(range(len(d[\"value\"])), d[\"value\"])\n", + " plt.title(m)\n", + " plt.xlabel(\"epoch\")\n", + " plt.ylabel(m)\n", + " cnt += 1\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "execution": { + "iopub.execute_input": "2022-08-05T14:27:38.045462Z", + "iopub.status.busy": "2022-08-05T14:27:38.044985Z", + "iopub.status.idle": "2022-08-05T14:32:10.664879Z", + "shell.execute_reply": "2022-08-05T14:32:10.665242Z" + }, + "papermill": { + "duration": 275.032802, + "end_time": "2022-08-05T14:32:10.665366", + "exception": false, + "start_time": "2022-08-05T14:27:35.632564", + "status": "completed" + }, + "pycharm": { + "name": "#%%\n" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "scope = \"inference\"\n", + "inference_instance_type = \"ml.m4.xlarge\"\n", + "\n", + "od_type2_hpo_endpoint_name = name_from_base(f\"od-Type2-HPO-{model_id}\")\n", + "print(od_type2_hpo_endpoint_name)\n", + "\n", + "od_type2_hpo_predictor = tuner.deploy(\n", + " initial_instance_count=1,\n", + " instance_type=inference_instance_type,\n", + " entry_point=\"inference.py\", # entry point file in source_dir and present in deploy_source_uri\n", + " image_uri=deploy_image_uri,\n", + " source_dir=deploy_script_uri,\n", + " endpoint_name=od_type2_hpo_endpoint_name,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "papermill": { + "duration": 2.366347, + "end_time": "2022-08-05T14:32:15.449523", + "exception": false, + "start_time": "2022-08-05T14:32:13.083176", + "status": "completed" + }, + "pycharm": { + "name": "#%% md\n" + }, + "tags": [] + }, + "source": [ + "## 6. Inference and Model Comparison\n", + "\n", + "We compare model performance both visually and numerically. \n", + "1. Visually, we sample images from the test data, one image from each category, and show the predicted bounding boxes, their predicted categories, and the confidence scores.\n", + "2. Numerically, we compute mAP on the pre-allocated test data. This is a fair comparison because we use the same metric and evaluate on the same test data." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "execution": { + "iopub.execute_input": "2022-08-05T14:32:20.182827Z", + "iopub.status.busy": "2022-08-05T14:32:20.182022Z", + "iopub.status.idle": "2022-08-05T14:32:20.189127Z", + "shell.execute_reply": "2022-08-05T14:32:20.188672Z" + }, + "papermill": { + "duration": 2.373644, + "end_time": "2022-08-05T14:32:20.189229", + "exception": false, + "start_time": "2022-08-05T14:32:17.815585", + "status": "completed" + }, + "pycharm": { + "name": "#%%\n" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "import matplotlib.patches as patches\n", + "from PIL import Image, ImageColor\n", + "from utils import query_Type2, query_Type1, plot_results\n", + "\n", + "categories = {\n", + " 1: \"crazing\",\n", + " 2: \"inclusion\",\n", + " 3: \"pitted_surface\",\n", + " 4: \"patches\",\n", + " 5: \"rolled-in_scale\",\n", + " 6: \"scratches\",\n", + "}\n", + "\n", + "# Obtain all images and their annotations info\n", + "with open(\"test_annotations.json\", \"r\") as f:\n", + " info = json.load(f)\n", + "\n", + "# images = {image['file_name']: image['id'] for image in info['images']}\n", + "images = info[\"images\"]\n", + "annotations = info[\"annotations\"]" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "papermill": { + "duration": 2.360117, + "end_time": "2022-08-05T14:32:24.914515", + "exception": false, + "start_time": "2022-08-05T14:32:22.554398", + "status": "completed" + }, + "pycharm": { + "name": "#%% md\n" + }, + "tags": [] + }, + "source": [ + "### Visual comparison\n" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "execution": { + "iopub.execute_input": "2022-08-05T14:32:29.650360Z", + "iopub.status.busy": "2022-08-05T14:32:29.649900Z", + "iopub.status.idle": "2022-08-05T14:32:38.995468Z", + "shell.execute_reply": "2022-08-05T14:32:38.995815Z" + }, + "papermill": { + "duration": 11.715425, + "end_time": "2022-08-05T14:32:38.995940", + "exception": false, + "start_time": "2022-08-05T14:32:27.280515", + "status": "completed" + }, + "pycharm": { + "name": "#%%\n" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "image_dir = \"raw_neu_det/NEU-DET/IMAGES/\"\n", + "\n", + "image_name = \"patches_116.jpg\"\n", + "# image_name = \"crazing_103.jpg\"\n", + "# image_name = \"inclusion_166.jpg\"\n", + "# image_name = \"pitted_surface_101.jpg\"\n", + "# image_name = \"rolled-in_scale_1.jpg\"\n", + "# image_name = \"scratches_158.jpg\"\n", + "\n", + "image = os.path.join(image_dir, image_name)\n", + "\n", + "\n", + "# Ground truth\n", + "image_info = [img for img in images if img[\"file_name\"] == image_name][0]\n", + "bboxes = [a for a in annotations if a[\"image_id\"] == image_info[\"id\"]]\n", + "\n", + "# dictionary of {endpoint_name_i: {'normalized_boxes': xxx, 'classes_names': yyy, 'confidences': zzz}, endpoint_name_2: {...}}\n", + "d = {}\n", + "\n", + "# Inference. Could find all endpoints from Inference / Endpoints in the Sagemaker Dashboard\n", + "for endpoint_name in [\n", + " od_type2_endpoint_name,\n", + " od_type2_hpo_endpoint_name,\n", + " od_type1_endpoint_name,\n", + " od_type1_hpo_endpoint_name,\n", + "]:\n", + " query_function = query_Type2 if \"Type2\" in endpoint_name else query_Type1\n", + " normalized_boxes, classes_names, confidences = query_function(\n", + " image, endpoint_name=endpoint_name, num_predictions=len(bboxes)\n", + " )\n", + " d[endpoint_name] = {\n", + " \"normalized_boxes\": normalized_boxes,\n", + " \"classes_names\": classes_names,\n", + " \"confidences\": confidences,\n", + " }\n", + "\n", + "plot_results(image, bboxes, categories, d)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "papermill": { + "duration": 2.402319, + "end_time": "2022-08-05T14:32:43.831911", + "exception": false, + "start_time": "2022-08-05T14:32:41.429592", + "status": "completed" + }, + "pycharm": { + "name": "#%% md\n" + }, + "tags": [] + }, + "source": [ + "### Numerical comparison\n" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": { + "execution": { + "iopub.execute_input": "2022-08-05T14:32:48.589043Z", + "iopub.status.busy": "2022-08-05T14:32:48.588526Z", + "iopub.status.idle": "2022-08-05T14:32:48.602304Z", + "shell.execute_reply": "2022-08-05T14:32:48.601932Z" + }, + "papermill": { + "duration": 2.401555, + "end_time": "2022-08-05T14:32:48.602406", + "exception": false, + "start_time": "2022-08-05T14:32:46.200851", + "status": "completed" + }, + "pycharm": { + "name": "#%%\n" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# 1. Convert test_annotations.json to the ground truth format that pycocotools can consume\n", + "\n", + "from pycocotools.coco import COCO\n", + "from pycocotools.cocoeval import COCOeval\n", + "\n", + "annFile = \"./test_annotations.json\"\n", + "ground_truth_annFile = convert_to_pycocotools_ground_truth(annFile)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "execution": { + "iopub.execute_input": "2022-08-05T14:32:53.357762Z", + "iopub.status.busy": "2022-08-05T14:32:53.355113Z", + "iopub.status.idle": "2022-08-05T14:36:11.116697Z", + "shell.execute_reply": "2022-08-05T14:36:11.117068Z" + }, + "papermill": { + "duration": 200.141724, + "end_time": "2022-08-05T14:36:11.117196", + "exception": false, + "start_time": "2022-08-05T14:32:50.975472", + "status": "completed" + }, + "pycharm": { + "name": "#%%\n" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "%%time\n", + "# 2. Use one endpoint to predict all test images\n", + "# run the following two cells for all endpoints\n", + "\n", + "endpoint_name = od_type1_endpoint_name\n", + "# endpoint_name = od_type1_hpo_endpoint_name\n", + "# endpoint_name = od_type2_endpoint_name\n", + "# endpoint_name = od_type2_hpo_endpoint_name\n", + "# endpoint_name = 'sagemaker-soln-...-finetuned-endpoint' # DDN model\n", + "\n", + "print(\"endpoint: \", endpoint_name)\n", + "\n", + "if \"Type2\" in endpoint_name:\n", + " query_function = query_Type2\n", + " output_file = (\n", + " \"results/type2_results.json\"\n", + " if endpoint_name == od_type2_endpoint_name\n", + " else \"results/type2_hpo_results.json\"\n", + " )\n", + "elif \"Type1\" in endpoint_name:\n", + " query_function = query_Type1\n", + " output_file = (\n", + " \"results/type1_results.json\"\n", + " if endpoint_name == od_type1_endpoint_name\n", + " else \"results/type1_hpo_results.json\"\n", + " )\n", + "else:\n", + " ValueError(\"Un-recognized endpoint\")\n", + "print(\"output file:\", output_file)\n", + "\n", + "coco_results = []\n", + "\n", + "for i, img in enumerate(images):\n", + "\n", + " if i % 50 == 0:\n", + " print(f\"{i} / {len(images)} done\")\n", + "\n", + " image_name = img[\"file_name\"]\n", + " image = os.path.join(image_dir, image_name)\n", + "\n", + " prediction_boxes, classes_names, confidences = query_function(\n", + " image, endpoint_name=endpoint_name, num_predictions=100\n", + " )\n", + "\n", + " # Rescale to original size for each bbox\n", + " image_info = [img for img in images if img[\"file_name\"] == image_name][0]\n", + " W, H = image_info[\"width\"], image_info[\"height\"]\n", + "\n", + " prediction_boxes = [\n", + " [xmin * W, ymin * H, (xmax - xmin) * W, (ymax - ymin) * H]\n", + " for (xmin, ymin, xmax, ymax) in prediction_boxes\n", + " ]\n", + "\n", + " coco_results.extend(\n", + " [\n", + " {\n", + " \"image_id\": img[\"id\"],\n", + " \"category_id\": classes_names[k],\n", + " \"bbox\": box,\n", + " \"score\": confidences[k],\n", + " }\n", + " for k, box in enumerate(prediction_boxes)\n", + " ]\n", + " )\n", + "\n", + "print(f\"Total predictions for {len(images)} images:\", len(coco_results))\n", + "\n", + "jsonString = json.dumps(coco_results)\n", + "with open(output_file, \"w\") as f:\n", + " f.write(jsonString)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "execution": { + "iopub.execute_input": "2022-08-05T14:36:15.996272Z", + "iopub.status.busy": "2022-08-05T14:36:15.995730Z", + "iopub.status.idle": "2022-08-05T14:36:18.441459Z", + "shell.execute_reply": "2022-08-05T14:36:18.441839Z" + }, + "papermill": { + "duration": 4.883117, + "end_time": "2022-08-05T14:36:18.441964", + "exception": false, + "start_time": "2022-08-05T14:36:13.558847", + "status": "completed" + }, + "pycharm": { + "name": "#%%\n" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# 3. Calculate mean Average Precision (mAP) on the test data\n", + "# CoCoeval reports a table of metric values, use the first row result to compare models\n", + "\n", + "cocoGt = COCO(ground_truth_annFile)\n", + "cocoDt = cocoGt.loadRes(output_file)\n", + "cocoEval = COCOeval(cocoGt, cocoDt, \"bbox\")\n", + "\n", + "imgIds = sorted(cocoGt.getImgIds())\n", + "cocoEval.params.imgIds = imgIds\n", + "\n", + "cocoEval.evaluate()\n", + "cocoEval.accumulate()\n", + "cocoEval.summarize()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "papermill": { + "duration": 2.391113, + "end_time": "2022-08-05T14:36:23.225219", + "exception": false, + "start_time": "2022-08-05T14:36:20.834106", + "status": "completed" + }, + "pycharm": { + "name": "#%% md\n" + }, + "tags": [] + }, + "source": [ + "\n", + "\"drawing\"\n", + "\n", + "If you predict all test images using all endpoints, you end up with this table. The pycocotools package reports more metric values. We wil focus on row 1 - the mAP averaged over all IoU thresholds, all recall thresholds, all region sizes (small, medium, large), and all numbers of predicted bbox (1, 10, and 100), and all object categories. It's the [standard practice](https://cocodataset.org/#detection-eval) to use this metric for evaluating object detection algorithms." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "papermill": { + "duration": 2.403376, + "end_time": "2022-08-05T14:36:28.020761", + "exception": false, + "start_time": "2022-08-05T14:36:25.617385", + "status": "completed" + }, + "pycharm": { + "name": "#%% md\n" + }, + "tags": [] + }, + "source": [ + "### 7. Clean Up the Endpoints\n", + "\n", + "When you are done with the endpoint, you should clean it up.\n", + "\n", + "All of the training jobs, models and endpoints we created can be viewed through the SageMaker console of your AWS account." + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": { + "execution": { + "iopub.execute_input": "2022-08-05T14:36:32.833309Z", + "iopub.status.busy": "2022-08-05T14:36:32.832838Z", + "iopub.status.idle": "2022-08-05T14:36:39.752304Z", + "shell.execute_reply": "2022-08-05T14:36:39.751877Z" + }, + "papermill": { + "duration": 9.328678, + "end_time": "2022-08-05T14:36:39.752413", + "exception": false, + "start_time": "2022-08-05T14:36:30.423735", + "status": "completed" + }, + "pycharm": { + "name": "#%%\n" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# Delete the SageMaker endpoint\n", + "od_type1_predictor.delete_model()\n", + "od_type1_predictor.delete_endpoint()\n", + "\n", + "od_type1_hpo_predictor.delete_model()\n", + "od_type1_hpo_predictor.delete_endpoint()\n", + "\n", + "od_type2_predictor.delete_model()\n", + "od_type2_predictor.delete_endpoint()\n", + "\n", + "od_type2_hpo_predictor.delete_model()\n", + "od_type2_hpo_predictor.delete_endpoint()\n", + "\n", + "# You should go to the Sagemaker console and manually delete the DDN model endpoint" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "papermill": { + "duration": 2.415178, + "end_time": "2022-08-05T14:36:44.577598", + "exception": false, + "start_time": "2022-08-05T14:36:42.162420", + "status": "completed" + }, + "pycharm": { + "name": "#%% md\n" + }, + "tags": [] + }, + "source": [ + "## 8. Conclusion\n", + "\n", + "Both visual and numerical comparison confirm that the Type 2 (latest) OD model or Type 2 (latest) OD + HPO performs the best. \n", + "\n", + "1. Training models from scratch can be very time-consuming and less effective. In this example, the target dataset is very small, consisting of only 1,800 images in 6 categories, and the training data is only 64% of this small dataset.\n", + "2. The built-in Sagemaker OD models were pre-trained on large-scale dataset, e.g., the ImageNet dataset includes 14,197,122 images for 21,841 categories, and the PASCAL VOC dataset includes 11,530 images for 20 categories. The pre-trained models have learned rich and diverse low level features, and can efficiently transfer knowledge to finetuned models and focus on learning high-level semantic features for the target dataset.\n", + "3. HPO is extremely effective, especially for models with large hyperparameter search spaces. Since we finetuned on three hyperparameters (learning rate, momentum, and weight decay) for the Type 1 (legacy) OD models and only one hyperparameter (adam learning rate) for the Type 2 (latest) OD model, there is relatively larger room for improvement for the Type 1 (legacy) OD model and we do observe larger performance enhancement. Of course, we need to trade off model performance with budget (compute resource and training time) when running HPO.\n", + "4. In terms of training time, for the steel surface dataset, training the Type 1 (legacy) OD model took 34 min, Type 2 (latest) OD model took 1 hour, and the model trained from scratch took 8+ hours. It indicates finetuning a pre-trained model is much more efficient.\n", + "5. In summary, finetuning a pretrained model is both more efficient and more performant, we suggest taking advantage of the pre-trained Sagemaker built-in models and finetune on your target datasets.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "papermill": { + "duration": 2.382722, + "end_time": "2022-08-05T14:36:49.342790", + "exception": false, + "start_time": "2022-08-05T14:36:46.960068", + "status": "completed" + }, + "pycharm": { + "name": "#%%\n" + }, + "tags": [] + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "instance_type": "ml.g4dn.xlarge", + "kernelspec": { + "display_name": "Python 3 (PyTorch 1.8 Python 3.6 CPU Optimized)", + "language": "python", + "name": "python3__SAGEMAKER_INTERNAL__arn:aws:sagemaker:us-west-2:236514542706:image/1.8.1-cpu-py36" + }, + "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.13" + }, + "papermill": { + "default_parameters": {}, + "duration": 23169.556233, + "end_time": "2022-08-05T14:36:52.361701", + "environment_variables": {}, + "exception": null, + "input_path": "4_finetune-processed.ipynb", + "output_path": "4_finetune-processed-output.ipynb", + "parameters": {}, + "start_time": "2022-08-05T08:10:42.805468", + "version": "2.3.4" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}