This assumes the module is already installed. Please refer to their documentation if not.
Disclaimer
This answer is not meant to be the right or only way of training the object detection module. This is simply I sharing my experience and what has worked for me. I'm open to suggestions and learning more about this as I am still new to ML in general.
TL;DR
- Create your own PASCAL VOC format dataset
- Generate TFRecords from it
- Configure a pipeline
- Visualize
Each section of this answer consists of a corresponding Edit (see below). After reading each section, please read its Edit as well for clarifications. Corrections and tips were added for each section.
Tools used
LabelImg: A tool for creating PASCAL VOC format annotations.
1. Create your own PASCAL VOC dataset
PS: For simplicity, the folder naming convention of my answer follows that of Pascal VOC 2012
A peek into the May 2012 dataset, you'll notice the folder as having the following structure
+VOCdevkit
+VOC2012
+Annotations
+ImageSets
+Action
+Layout
+Main
+Segmentation
+JPEGImages
+SegmentationClass
+SegmentationObject
For the time being, amendments were made to the following folders:
Annotations: This is were all the images' corresponding XML files will be placed in. Use the suggested tool above to create the annotations. Do not worry about <truncated> and <difficulty> tags as they will be ignored by the training and eval binaries.
JPEGImages: Location of your actual images. Make sure they are of type JPEG because that's what is currently supported in order to create TFRecords using their provided script.
ImageSets->Main: This simply consists of text files. For each class, there exists a corresponding train.txt, trainval.txt and val.txt. Below is a sample of the contents of the aeroplane_train.txt in the VOC 2012 folder
2008_000008 -1
2008_000015 -1
2008_000019 -1
2008_000023 -1
2008_000028 -1
2008_000033 1
The structure is basically image name followed by a boolean saying whether the corresponding object exists in that image or not. Take for example image 2008_000008 does not consist of an aeroplane hence marked with a -1 but image 2008_000033 does.
I wrote a small Python script to generate these text files. Simply iterate through the image names and assign a 1 or -1 next to them for object existence. I added some randomness among my text files by shuffling the image names.
The {classname}_val.txt files consist of the testing validation datasets. Think of this as the test data during training. You want to divide your dataset into training and validation. More info can be found here. The format of these files is similar to that of training.
At this point, your folder structure should be
+VOCdevkit
+VOC2012
+Annotations
--(for each image, generated annotation)
+ImageSets
+Main
--(for each class, generated *classname*_train.txt and *classname*_val.txt)
+JPEGImages
--(a bunch of JPEG images)
1.1 Generating label map
With the dataset prepared, we need to create the corresponding label maps.
Navigate to models/object_detection/data and open pascal_label_map.pbtxt.
This file consists of a JSON that assigns an ID and name to each item. Make amendments to this file to reflect your desired objects.
2. Generate TFRecords
If you look into their code especially this line, they explicitly grab the aeroplane_train.txt only. For curios minds, here's why. Change this file name to any of your class train text file.
Make sure VOCdevkit is inside models/object_detection then you can go ahead and generate the TFRecords.
Please go through their code first should you run into any problems. It is self explanatory and well documented.
3. Pipeline Configuration
The instructions should be self explanatory to cover this segment. Sample configs can be found in object_detection/samples/configs.
For those looking to train from scratch as I did, just make sure to remove the fine_tune_checkpoint and from_detection_checkpoint nodes. Here's what my config file looked like for reference.
From here on you can continue with the tutorial and run the training process.
4. Visualize
Be sure to run the eval in parallel to the training in order to be able to visualize the learning process. To quote Jonathan Huang
the best way is to just run the eval.py binary. We typically run this
binary in parallel to training, pointing it at the directory holding
the checkpoint that is being trained. The eval.py binary will write
logs to an eval_dir that you specify which you can then point to
with Tensorboard.
You want to see that the mAP has "lifted off" in the first few hours,
and then you want to see when it converges. It's hard to tell without
looking at these plots how many steps you need.
EDIT I (28 July '17):
I never expected my response to get this much attention so I decided to come back and review it.
Tools
For my fellow Apple users, you could actually use RectLabel for annotations.
Pascal VOC
After digging around, I finally realized that trainval.txt is actually the union of training and validation datasets.
Please look at their official development kit to understand the format even better.
Label Map Generation
At the time of my writing, ID 0 represents none_of_the_above. It is recommended that your IDs start from 1.
Visualize
After running your evaluation and directed tensorboard to your Eval directory, it'll show you the mAP of each category along with each category's performance. This is good but I like seeing my training data as well in parallel with Eval.
To do this, run tensorboard on a different port and point it to your train directory
tensorboard --logdir=${PATH_TO_TRAIN} --port=${DESIRED_NUMBER}
