AlexeyAB
commented
6 years ago - Did you get IoU using
darknet mapordarknet recallcommand? - What width= height= params do you use in the cfg-file?
- What learning_rate, steps, scales and decay do you use?
-
You can use
small_object=1andrandom=1this params doesn't decrease speed:random=1increase mAP +1%, it does not affect the speed of detection, but it deacrease speed of trainingsmall_object=1is required only for objects with size less than 1%x1% i.e. smaller than 5x5 pixels (if you use width=416 height=416)- also you can try to train using pre-trained
tiny-yolo-voc.conv.13instead ofdarknet19_448.conv.23that you can get using command:darknet.exe partial cfg/tiny-yolo-voc.cfg tiny-yolo-voc.weights tiny-yolo-voc.conv.13 13
-
By default Yolo uses square network 416x416, and any image is resized to this square resolution 416x416 automatically, so you shouldn't do it. But there are several approaches for keeping aspect ration, so you can do pre-processing of images, as in the original darknet, or as in the OpenCV-dnn-Yolo: https://github.com/AlexeyAB/darknet/issues/232#issuecomment-336955485 But there are positive and negative points here.
-
For default networks (Yolo, Tiny-yolo) and default threshold=0.24, the IoU is the best accuracy metric. But if you use your own model (DenseNet-Yolo, ResNet-Yolo), that requires a different optimal threshold, then the best metric is mAP. Yes, the higher the network resolution, the slower it works, but the more accurately it detects (especially small objects).
3.1. Also, if all of your images (training and detection) have the same size 640x360, then you can try to change your network size
width=640 height=352and train withrandom=0 -
You can try to implement it in the source code in this function: https://github.com/AlexeyAB/darknet/blob/3ff4797b4cfd845c7115421e68ae2d584c289a24/src/region_layer.c#L333-L384
For example add this code at the end of the function, before this line: https://github.com/AlexeyAB/darknet/blob/3ff4797b4cfd845c7115421e68ae2d584c289a24/src/region_layer.c#L384
float max_prob = 0;
int max_index = 0, max_j = 0;
int i,j,n;
for (i = 0; i < l.w*l.h; ++i){
int row = i / l.w;
int col = i % l.w;
for(n = 0; n < l.n; ++n){
int index = i*l.n + n;
for(j = 0; j < l.classes; ++j){
if(probs[index][j] > max_prob) {
max_prob = probs[index][j];
max_index = index;
max_j = j;
}
}
}
}
for (i = 0; i < l.w*l.h; ++i){
int row = i / l.w;
int col = i % l.w;
for(n = 0; n < l.n; ++n){
int index = i*l.n + n;
for(j = 0; j < l.classes; ++j){
if(index != max_index || j != max_j) probs[index][j] = 0;
}
}
}- Also you can re-generate anchors for your dataset:
- Just download Python 2.7: https://www.python.org/downloads/release/python-2714/
- insteall numpy if it required: C:\Python27\Scripts\pip install numpy
- calculate your anchors
C:\Python27\python.exe gen_anchors.py -filelist data/train.txt -output_dir data/anchors -num_clusters 5using this script: https://github.com/AlexeyAB/darknet/blob/master/build/darknet/x64/gen_anchors.py - and change anchors in cfg-file to your: https://github.com/AlexeyAB/darknet/blob/master/cfg/tiny-yolo-voc.cfg#L118
MyVanitar
saihv
I am currently working on object detection on a custom dataset, where a close to real time implementation on a Jetson TX2 is the final goal. Hence, I am trying to achieve a performance of ~30 fps (20-30 would be acceptable too as long as accuracy is not too bad) as well as a decent IoU.
As of now, I am using Tiny YOLO as my framework through Darknet, compiled with GPU and CUDNN support. The images are 640x360 in dimensions and I have about 100000 of them with around 10 classes of objects in total. I've trained tiny YOLO for about 80000 iterations and on an average, this has given me IoUs of around 50% on the test dataset with a performance of around 18 fps on the Jetson TX2: I am currently looking to improve these numbers while not affecting the performance too much. I was hoping to get some suggestions regarding this:
(I see in the README two points relating to this: parameters
small_object=1andrandom=1. Do these affect the performance adversely at the cost of increased accuracy?)Does YOLO have a performance boost when working on square images? i.e., is there any noticeable improvement in resizing the images to square?
Is IoU the best metric to check when trying to increase or derease network-resolution (width and height)? I gather from the README that these values create an accuracy vs speed trade-off, how should I pick the best values for my application?
When performing training or inference, in my application, each image has only one class of object in it. Can I somehow exploit this fact to improve the performance a little (somehow tell YOLO that the maximum number of objects it needs to finally detect is just one)?
Any other general comments aimed at improving accuracy or speed are very welcome too. Thanks!