Transfer learning, active learning using tensorflow object detection api

Transfer learning,
Active learning
using tensorflow object detection
api

Tensorflow Object detection api
Google released the tensorflow-based object detection API in June 2017.
By offering models with various speeds and accuracy, the general public can easily detect objects.

This announcement describes only object detection.
The more you go back, the harder the detection will be.
The object detection API supports both box and mask types.
Object detection
Detection of various objects in a single box is generally called object detection.
Although not mentioned in this announcement, it is called object sementatin that detects an object according to a shape rather than a box shape.
There are various types of image detection.
image classification is simply a determination of what the image is.
You can also localize from the image classification to the exact location of the object

Make
tfrecord
Re train Export Test
Evaluate
Loop
Optional
The most basic flow of the tensorflow object detection api.
All functions are provided to process the data to api, train this data, export the model to a usable form, and test this model.
You can also evaluate ongoing or completed models.

Make
tfrecord
Evaluate

Make tfrecord
python generate_tfRecord.py
--csv_input=data/train.csv
--output_path=data/train.record
The data type for using object detection api is tfrecord.
The source for creating this tfrecord file is provided, below is how to use it.
Set the csv file containing the image information and the output directory.

Finally, we need four numeric values to tell where each object is located in the image.
xmin, ymin, xmax, ymax values. With this value, you can create a box in which the object is located.
There can be multiple objects in an image.
Make tfrecord
Image
Label
Xmin , Ymin
Xmax , Ymax
The data needed to create the tfrecord file is as follows:
First, you need the original image file.
Next, we need a label for each object in the image.

Make tfrecord
LabelImg
https://github.com/tzutalin/labelImg
It is difficult to manually determine the location point of an object.
There are various programs that do this automatically.
I used the most widely known labelimg.

Make tfrecord
When you use labelimg, an xml file is created that contains the label of each object and the values of xmin, ymin, xmax, and ymax.

Make tfrecord
If we have an image to train, xml, and a labelmap that stores the id for each class, we can generate a tfrecord file.

Make tfrecord tfgenerator ( custom )
The default code is train and test.
Since this is a troublesome task, I have created a program that will do this automatically.
When executed, each class is distributed according to the ratio of train, validate, and a log is generated.

Re train Transfer learning
python object_detection/train.py
--logtostderr
--pipeline_config_path=pipeline.config
--train_dir=train
object detection api python base code related to train.
Set up the model you want to train, and set the training output directory.
There are many other options.

ssd_mobilenet_v1_coco stands for ssd_mobilenet, which trained Coco Dataset.
Pre-trained datasets include COCO, Kitti, and Open Images datasets.
Re train Object detection API model zoo
ssd_mobilenet_v1_coco
Dataset : COCO dataset, Kitti dataset, Open Images dataset.
It provides various pre-trained models for object detection of tensorflow.
Each model has different speed and accuracy.
The first part of the model name is the algorithm, and the second part is the data set.

Re train What you want to detect
COCO dataset Instance
If the class you want to detect is an instance already in coco, kitty, or open image dataset, you do not need to train.
Just use the built-in model and select it.

Re train What you want to detect
?
However, if you want to classify dinosaurs such as Tyrannosaurus and Triceratops as shown in the picture, we need to train on the above classes.
Here we have two choices.
Create models with completely new layers, or leverage existing models.

Re train Make own model
It is known that the depth of the neural network and the wider the layer, the higher the accuracy.
The picture is google inception v2 model.
Deep networks require exponential computing resources.

Re train Make own model
google TPU 2.0
45 TFLOPS
Titan v
15 TFLOPS
gtx 1080
9 TFLOPS
gtx 970
4 TFLOPS
This time I released tpu 3.0 on Google i / o 2018.
To simplify the quantification of the flops power of tpu 2.0 and other graphics cards: Perhaps the maximum gpu that a non-enterprise user can have is titan.
Google uses a tpu pot that contains 64 tpu. Google may take weeks or even months to do the work for an hour.

Teaching a dinosaur to a child can be quite challenging, but teaching a dinosaur to an adult is a lot easier.
Transfer learning is similar to teaching dinosaurs to adults.
But if you show dinosaur photos to an adult, you will see them as animals by looking at their eyes, legs and tails.
Is not that a kind of reptile based on various information such as skin texture? You will think.
If you show your baby a photo of a dinosaur, the baby probably has no idea.
Babies will not know what their eyes, tails, and feet are, and they will not even have the concept of point, line.
?
So we will use a method called transfer learning.
There are two people who do not know dinosaurs at all.
One is a very young baby and the other is an adult.

This photo is a visualization of the weights we have for each layer. Looking closer at the picture, the nearest layer to the input has a low-dimensional feature
such as a line, As you go to the output, you can see that it has more detailed high-dimensional features.
Since low dimensional features have any object, transfer learning takes it as it is.

replace custom class
For example, inception v2 model, we take only the weights of previous layers and change only the last fully connected layer to custom labels.

If you give the checkpoint file that you have trained as an input, you can use frozon_inference_graph.pd
The file is created.
We can do the prediction from anywhere with this frozon_inference_graph.pd.
Export
python object_detection/export_inference_graph.py
--input_type=image_tensor
--pipeline_config_path=pipeline.config
--trained_checkpoint_prefix=train/model.ckpt-xxxxx
--output_directory=output
train_checkpoint_prefix
output_directory
Once you train your model and reach your goal, we need to export this output to an executable file.
Below is the object detection default python export code.

Evaluate
python eval.py
--logtostderr
--pipeline_config_path=training/ssd_mobilenet_v1_coco.config
--checkpoint_dir=training/
--eval_dir=eval/
tensorboard --logdir=./
We would like to quantitatively identify how good this model is during training, or after the train is over. The api to use is evaluate.
Below is the python evaluate code provided by the object detection api.
We can visually check the evaluate result value through the tensorboard.

Evaluate Using tensorboard
This is the main screen of the evaluated tensorboard.
Let's take a quick look at each one.

First, you can see the loss value for classification or localization.
The lower the loss value, the better.

Second, you can check the accuracy of each class.
For different reasons, each character does not have the same classification accuracy.

Third, you can measure the accuracy of the entire validation data.
Accuracy measurement method is 0.5IoU.

IoU is an abbreviation of intersection of union, which is the ratio of the sum of the overlapping areas of the actual ground truth box and the area of the prediction
truth box.
As you can see in the photo, the accuracy is not 100% even though the predicted value wraps around the actual value.

Finally, on the tensorboard, we can see how the estimate of the image changes every evaluation step.

Tensorflow object detection helper tool
Make
tfrecord
Evaluate
Automation
The set of data creation, train, evaluate, and export described above must be done manually by default.
I created a program that automatically feels inconvenienced.

Since you have set all the settings to the default settings that you can run by default, you only need to select the model and enter the training step.

https://github.com/5taku/tensorflow_object_detection_helper_tool
You can check the log of the result value and the execution time of each process.

Test
It is the code that loads the file generated by export and loads it into memory.
These images are detected using the loaded graph file.
# Path to frozen detection graph. This is the actual model that is used for the object detection.
PATH_TO_CKPT = MODEL_NAME + '/frozen_inference_graph.pb'
# Load a (frozen) Tensorflow model into memory.
detection_graph = tf.Graph()
with detection_graph.as_default():
od_graph_def = tf.GraphDef()
with tf.gfile.GFile(PATH_TO_CKPT, 'rb') as fid:
serialized_graph = fid.read()
od_graph_def.ParseFromString(serialized_graph)
tf.import_graph_def(od_graph_def, name='')
https://github.com/tensorflow/models/blob/master/research/object_detection/object_detection_tutorial.ipynb

Test cloud resource ( google cloud compute engine )
16 vCPU
60gb Ram
1 x NVIDIA Tesla P100
ubuntu 16.0.4
python 2.7.12
tensorflow 1.8.0
cuda 9.0
cudnn 7.1
All the tests related to the announcement were tested on the Google cloud virtual machine.
The specifications are as follows.

Test dataset
The dataset used in the test was a simpson dataset from kaggle.

Test dataset
name total bounding_box
Homer Simpson 2246 612
Ned Flanders 1454 595
Moe Szyslak 1452 215
Lisa Simpson 1354 562
Bart Simpson 1342 554
Marge Simpson 1291 557
Krusty The Clown 1206 226
Principal Skinner 1194 506
Charles Montgomery Burns 1193 650
Milhouse Van Houten 1079 210
Chief Wiggum 986 209
Abraham Grampa Simpson 913 595
Sideshow Bob 877 203
Apu Nahasapeemapetilon 623 206
Kent Brockman 498 213
Comic Book Guy 469 208
Edna Krabappel 457 212
Nelson Muntz 358 219
Each character is fully labeled. (300 to 2000)
Some of them have box data. (200 to 600)
The number of data is not constant for each character.

Train , Evaluate , Export
model = faster rcnn resnet 50
training step = 140,000
training : validate rate = 8 : 2
I have trained 140,000 faster rcnn resnet 50 pre-train models with my tool.
Performs evaluation every 10,000 times.
Total training time is approximately 6 hours and 30 minutes.

Test tensor board result
The overall iou value was 0.67, which did not perform well.
IoU for each character is also inferior in performance.

Test handmade check
I did not touch the figures well, so I decided to check the image by inserting the actual image.
Twenty images per character were predialized. There are a few errors that I see in my eyes :(
The criteria for each T F N are as follows. (If multiple labels are detected on one object, the highest accuracy is T.)
True ( T ) False ( F ) None ( N )

Improved accuracy
1. Change Model
2. Increase data
a. Data augmentation
b. Labelling
c. Active learning
3. etc….
The result of training 6,000 data for 140,000 times is not satisfactory.
How can I improve my accuracy?
There are many ways to increase accuracy.

Improved accuracy change model
Model name
Speed
(ms)
COCO
mAP[^1]
Size
Training
time
Outputs
ssd_mobilenet_v1_coco 30 21 86M 9m 44s Boxes
ssd_mobilenet_v2_coco 31 22 201M 11m 12s Boxes
ssd_inception_v2_coco 42 24 295M 8m 43s Boxes
faster_rcnn_inception_v2_coco 58 28 167M 4m 43s Boxes
faster_rcnn_resnet50_coco 89 30 405M 4m 28s Boxes
faster_rcnn_resnet50_lowproposals_coco 64 405M 4m 30s Boxes
rfcn_resnet101_coco 92 30 685M 6m 19s Boxes
faster_rcnn_resnet101_coco 106 32 624M 6m 13s Boxes
faster_rcnn_resnet101_lowproposals_coco 82 624M 6m 13s Boxes
faster_rcnn_inception_resnet_v2_atrous_coco 620 37 712M 18m 6s Boxes
faster_rcnn_inception_resnet_v2_atrous_lowproposals_coco 241 712M Boxes
faster_rcnn_nas 1833 43 1.2G 47m 49s Boxes
faster_rcnn_nas_lowproposals_coco 540 1.2G Boxes
In choosing a model, tensorflow already offers several models.
We only need to select the model considering the accuracy, prediction speed, and training speed.
In the tests I've done, resnet50, inception v2 has guaranteed the best performance.

Improved accuracy Data augmentation
original
size up
size down
brightness up
brightness down
Rotating, zooming in and out using a single image is a widely used method of increasing data.
However, if you change the size of the image, you have to change the box position as well, which will be quite cumbersome.

Improved accuracy labelling
Too Expensive COST!!!
Another way to increase data is to manually create one object box boundary.
Manual labeling results in many labeling costs.

Active learning
Introducing Active learning, which allows labeling of images at low cost.
The basic concept is to use the data obtained by predicting the candidate data with the model made by using a small amount of data, and to use the result as
the training data again. Of course, the predicted result is verified by the person or machine named oracle.

Active learning
Training
labeled
data
unlabeled
data pool
Prediction
Query
if detection label == image label
an oracle
Simpson dataset is an ideal data set for active learning because each unboxed image is labeled.
The resnet 50 algorithm is trained 20,000 times with 6,000 box data provided initially.
Then, 12,000 unboxed images are predicted, and if the prediction result matches the image label, it is moved to the train dataset.

Active learning
The number of images adopted in the training set is as follows.
At the first prediction, two times the image was adopted, and since then the number has been reduced, but it has been adopted as a steady train set.
ID NAME 1 step 2 step 3 step 4 step 5 step 6 step 7 step
1 homer_simpson 626 1830 1980 2018 2050 2061 2066
2 ned_flanders 607 1214 1335 1355 1381 1387 1388
3 moe_szyslak 215 692 945 1121 1170 1238 1246
4 lisa_simpson 578 1116 1217 1234 1271 1271 1271
5 bart_simpson 571 1133 1243 1256 1256 1265 1272
6 marge_simpson 568 1229 1244 1248 1248 1250 1250
7 krusty_the_clown 239 558 1002 1139 1145 1147 1147
8 principal_skinner 519 1054 1110 1114 1116 1119 1122
9 charles_montgomery_burns 663 1058 1085 1099 1104 1105 1107
10 milhouse_van_houten 223 776 897 925 952 954 965
11 chief_wiggum 206 561 788 837 858 863 867
12 abraham_grampa_simpson 608 844 875 878 878 878 878
13 sideshow_bob 202 217 420 651 733 760 772
14 apu_nahasapeemapetilon 223 537 570 581 588 588 590
15 kent_brockman 217 250 270 324 371 415 415
16 comic_book_guy 224 351 387 395 398 403 403
17 edna_krabappel 226 227 327 370 384 386 390
18 nelson_muntz 217 284 287 288 297 297 299
Total 6932 13931 15982 16833 17200 17387 17448
Increase rate 6999 2051 851 367 187 61

train , evaluate , export
The first and seventh data split ratios.
Because the number of images per character differs a lot, the number of training is uneven.
However, the number of training data in all classes increased by 30% ~ 300%.

train , evaluate , export
Because there is a process of predicting 11,000 images, it took 21 hours for a task that took 6 hours and 30 minutes to work with active learning.

When the localization loss value was learned from the existing 6900 chapters, it decreased from 0.115 to 0.06 after applying active learning.

Accuracy for each class has also gradually decreased.
In active learning, the initial graph value is suddenly suddenly the train data is suddenly increased, but it is not certain.

0.66
0.87
IOU accuracy for the entire class has been increased from 0.66 to 0.87.

Active learning
As data increases, the accuracy of each test case increases.
Accuracy increases rapidly in the early days and continues to increase in the future.

Active learning
Data 17,448
0 to 140,000
0 to 140,000
active learning every 20,000
Data 6,932
0 to 140,000
The first picture is the result of learning 6,932 pieces of data 140,000 times.
The second picture is the result of learning 140,000 times while adding training data to active learning every 20,000 times.
The last picture is the result of learning 140,400 data from the beginning of 17,448 data from the last result of active learning.

Active learning
Data 17,448
0 to 140,000
0 to 140,000
active learning every 20,000
Data 6,932
0 to 140,000
Looking at the results, some characters seem to show little increase in accuracy.
This is because the distribution of the entire dataset per class is so small that even if active learning is used, the percentage of the character in the entire data
set is rather lower.
comic_book_guy : 3.23 %
edna_krabappel : 3.26 %
nelson_muntz : 3.13 %
comic_book_guy : 2.30 %
edna_krabappel : 2.23 %
nelson_muntz : 1.71 %

Active learning
For kent brockman, the accuracy is fairly high, even though the data rate is 2.37%.
Though the test data may be luckily well-detected, I think that the characteristic white hair represents different classes and salient features.
kent_brockman : 2.37 %

Thank you!
1. Tensorflow Object detection API
2. Transfer learning
3. Object detection API helper tool
4. Active learning ( with test result )
Today we looked at the entire Tensorflow object detection API.
I also had a brief introduction to the concepts of tranfer learning and active learning and the helper tool I created.
We have confirmed that the accuracy of actual data is increased by active learning with low labeling cost.

Transfer learning, active learning using tensorflow object detection api

More Related Content

What's hot (20)

Similar to Transfer learning, active learning using tensorflow object detection api (20)

Recently uploaded (20)

Transfer learning, active learning using tensorflow object detection api

Editor's Notes