Skip to content
🔥 pure tensorflow Implement of YOLOv3 with support to train your own dataset
Branch: master
Clone or download
Latest commit db31ef7 Aug 18, 2019
Type Name Latest commit message Commit time
Failed to load latest commit information.
checkpoint I hate tensorflow May 21, 2019
core Update Jul 13, 2019
data I hate tensorflow May 21, 2019
docs I hate tensorflow May 14, 2019
mAP I hate tensorflow May 14, 2019
scripts I hate tensorflow May 28, 2019
.gitignore add demo Dec 1, 2018
LICENSE I hate tensorflow May 14, 2019
LICENSE.fuck just do it Jun 17, 2019 Update Aug 18, 2019 I hate tensorflow May 20, 2019 I hate tensorflow May 14, 2019 I hate tensorflow May 14, 2019 deprecated Jul 19, 2019 I hate tensorflow May 20, 2019 deprecated Jul 19, 2019


Please install tensorflow-gpu 1.11.0 ! Since Tensorflow is fucking ridiculous !

part 1. Introduction [代码剖析]

Implementation of YOLO v3 object detector in Tensorflow. The full details are in this paper. In this project we cover several segments as follows:

YOLO paper is quick hard to understand, along side that paper. This repo enables you to have a quick understanding of YOLO Algorithmn.

part 2. Quick start

  1. Clone this file
$ git clone
  1. You are supposed to install some dependencies before getting out hands with these codes.
$ cd tensorflow-yolov3
$ pip install -r ./docs/requirements.txt
  1. Exporting loaded COCO weights as TF checkpoint(yolov3_coco.ckpt)
$ cd checkpoint
$ wget
$ tar -xvf yolov3_coco.tar.gz
$ cd ..
$ python
$ python
  1. Then you will get some .pb files in the root path., and run the demo script
$ python
$ python # if use camera, set video_path = 0


part 3. Train on your own dataset

Two files are required as follows:

xxx/xxx.jpg 18.19,6.32,424.13,421.83,20 323.86,2.65,640.0,421.94,20 
xxx/xxx.jpg 48,240,195,371,11 8,12,352,498,14
# image_path x_min, y_min, x_max, y_max, class_id  x_min, y_min ,..., class_id 

3.1 Train VOC dataset

To help you understand my training process, I made this demo of training VOC PASCAL dataset

how to train it ?

Download VOC PASCAL trainval and test data

$ wget
$ wget
$ wget

Extract all of these tars into one directory and rename them, which should have the following basic structure.

VOC           # path:  /home/yang/test/VOC/
├── test
|    └──VOCdevkit
|       └──VOC2007 (from VOCtest_06-Nov-2007.tar)
└── train
             └──VOC2007 (from VOCtrainval_06-Nov-2007.tar)
                     └──VOC2012 (from VOCtrainval_11-May-2012.tar)
$ python scripts/ --data_path /home/yang/test/VOC

Then edit your ./core/ to make some necessary configurations

__C.YOLO.CLASSES                = "./data/classes/voc.names"
__C.TRAIN.ANNOT_PATH            = "./data/dataset/voc_train.txt"
__C.TEST.ANNOT_PATH             = "./data/dataset/voc_test.txt"

Here are two kinds of training method:

(1) train from scratch:
$ python
$ tensorboard --logdir ./data
(2) train from COCO weights(recommend):
$ cd checkpoint
$ wget
$ tar -xvf yolov3_coco.tar.gz
$ cd ..
$ python --train_from_coco
$ python

how to test and evaluate it ?

$ python
$ cd mAP
$ python -na

if you are still unfamiliar with training pipline, you can join here to discuss with us.

3.2 Train other dataset

Download COCO trainval and test data

$ wget
$ wget
$ wget
$ wget 

part 4. Why it is so magical ?

YOLO stands for You Only Look Once. It's an object detector that uses features learned by a deep convolutional neural network to detect an object. Although we has successfully run these codes, we must understand how YOLO works.

4.1 Anchors clustering

The paper suggests to use clustering on bounding box shape to find the good anchor box specialization suited for the data. more details see here image

4.2 Architercutre details

In this project, I use the pretrained weights, where we have 80 trained yolo classes (COCO dataset), for recognition. And the class label is represented as c and it's integer from 1 to 80, each number represents the class label accordingly. If c=3, then the classified object is a car. The image features learned by the deep convolutional layers are passed onto a classifier and regressor which makes the detection prediction.(coordinates of the bounding boxes, the class label.. etc).details also see in the below picture. (thanks Levio for your great image!) image

4.3 Neural network io:

  • input : [None, 416, 416, 3]
  • output : confidece of an object being present in the rectangle, list of rectangles position and sizes and classes of the objects begin detected. Each bounding box is represented by 6 numbers (Rx, Ry, Rw, Rh, Pc, C1..Cn) as explained above. In this case n=80, which means we have c as 80-dimensional vector, and the final size of representing the bounding box is 85.The first number Pc is the confidence of an project, The second four number bx, by, bw, bh represents the information of bounding boxes. The last 80 number each is the output probability of corresponding-index class.

4.4 Filtering with score threshold

The output result may contain several rectangles that are false positives or overlap, if your input image size of [416, 416, 3], you will get (52X52+26X26+13X13)x3=10647 boxes since YOLO v3 totally uses 9 anchor boxes. (Three for each scale). So It is time to find a way to reduce them. The first attempt to reduce these rectangles is to filter them by score threshold.

Input arguments:

  • boxes: tensor of shape [10647, 4]
  • scores: tensor of shape [10647, 80] containing the detection scores for 80 classes.
  • score_thresh: float value , then get rid of whose boxes with low score
# Step 1: Create a filtering mask based on "box_class_scores" by using "threshold".
mask = tf.greater_equal(scores, tf.constant(score_thresh))

4.5 Do non-maximum suppression

Even after yolo filtering by thresholding over, we still have a lot of overlapping boxes. Second approach and filtering is Non-Maximum suppression algorithm.

  • Discard all boxes with Pc <= 0.4
  • While there are any remaining boxes :
    • Pick the box with the largest Pc
    • Output that as a prediction
    • Discard any remaining boxes with IOU>=0.5 with the box output in the previous step

In tensorflow, we can simply implement non maximum suppression algorithm like this. more details see here

for i in range(num_classes):
    tf.image.non_max_suppression(boxes, score[:,i], iou_threshold=0.5) 

Non-max suppression uses the very important function called "Intersection over Union", or IoU. Here is an exmaple of non maximum suppression algorithm: on input the aglorithm receive 4 overlapping bounding boxes, and the output returns only one


If you want more details, read the fucking source code and original paper or contact with me

part 5. Other Implementations


- Implementing YOLO v3 in Tensorflow (TF-Slim)

- YOLOv3_TensorFlow

- Object Detection using YOLOv2 on Pascal VOC2012

-Understanding YOLO

You can’t perform that action at this time.