├── README.md ├── darknet.cpp ├── main.cpp └── qt5-opencv3-app.pro /README.md: -------------------------------------------------------------------------------- 1 | # qt5-opencv3-darknet 2 | Qt5 + Darknet/Yolo + OpenCV3 3 | 4 | Requires https://github.com/prabindh/darknet/tree/v3.75, with shared library build of darknet (make darknet-cpp-shared) -------------------------------------------------------------------------------- /darknet.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | #include "parser.h" 6 | #include "utils.h" 7 | #include "cuda.h" 8 | #include "blas.h" 9 | #include "connected_layer.h" 10 | 11 | #ifdef OPENCV 12 | #include "opencv2/highgui/highgui_c.h" 13 | #endif 14 | 15 | extern void predict_classifier(char *datacfg, char *cfgfile, char *weightfile, char *filename, int top); 16 | extern void test_detector(char *datacfg, char *cfgfile, char *weightfile, char *filename, float thresh, float hier_thresh); 17 | extern void run_voxel(int argc, char **argv); 18 | extern void run_yolo(int argc, char **argv); 19 | extern void run_detector(int argc, char **argv); 20 | extern void run_coco(int argc, char **argv); 21 | extern void run_writing(int argc, char **argv); 22 | extern void run_captcha(int argc, char **argv); 23 | extern void run_nightmare(int argc, char **argv); 24 | extern void run_dice(int argc, char **argv); 25 | extern void run_compare(int argc, char **argv); 26 | extern void run_classifier(int argc, char **argv); 27 | extern void run_char_rnn(int argc, char **argv); 28 | extern void run_vid_rnn(int argc, char **argv); 29 | extern void run_tag(int argc, char **argv); 30 | extern void run_cifar(int argc, char **argv); 31 | extern void run_go(int argc, char **argv); 32 | extern void run_art(int argc, char **argv); 33 | extern void run_super(int argc, char **argv); 34 | 35 | void average(int argc, char *argv[]) 36 | { 37 | char *cfgfile = argv[2]; 38 | char *outfile = argv[3]; 39 | gpu_index = -1; 40 | network net = parse_network_cfg(cfgfile); 41 | network sum = parse_network_cfg(cfgfile); 42 | 43 | char *weightfile = argv[4]; 44 | load_weights(&sum, weightfile); 45 | 46 | int i, j; 47 | int n = argc - 5; 48 | for(i = 0; i < n; ++i){ 49 | weightfile = argv[i+5]; 50 | load_weights(&net, weightfile); 51 | for(j = 0; j < net.n; ++j){ 52 | layer l = net.layers[j]; 53 | layer out = sum.layers[j]; 54 | if(l.type == CONVOLUTIONAL){ 55 | int num = l.n*l.c*l.size*l.size; 56 | axpy_cpu(l.n, 1, l.biases, 1, out.biases, 1); 57 | axpy_cpu(num, 1, l.weights, 1, out.weights, 1); 58 | if(l.batch_normalize){ 59 | axpy_cpu(l.n, 1, l.scales, 1, out.scales, 1); 60 | axpy_cpu(l.n, 1, l.rolling_mean, 1, out.rolling_mean, 1); 61 | axpy_cpu(l.n, 1, l.rolling_variance, 1, out.rolling_variance, 1); 62 | } 63 | } 64 | if(l.type == CONNECTED){ 65 | axpy_cpu(l.outputs, 1, l.biases, 1, out.biases, 1); 66 | axpy_cpu(l.outputs*l.inputs, 1, l.weights, 1, out.weights, 1); 67 | } 68 | } 69 | } 70 | n = n+1; 71 | for(j = 0; j < net.n; ++j){ 72 | layer l = sum.layers[j]; 73 | if(l.type == CONVOLUTIONAL){ 74 | int num = l.n*l.c*l.size*l.size; 75 | scal_cpu(l.n, 1./n, l.biases, 1); 76 | scal_cpu(num, 1./n, l.weights, 1); 77 | if(l.batch_normalize){ 78 | scal_cpu(l.n, 1./n, l.scales, 1); 79 | scal_cpu(l.n, 1./n, l.rolling_mean, 1); 80 | scal_cpu(l.n, 1./n, l.rolling_variance, 1); 81 | } 82 | } 83 | if(l.type == CONNECTED){ 84 | scal_cpu(l.outputs, 1./n, l.biases, 1); 85 | scal_cpu(l.outputs*l.inputs, 1./n, l.weights, 1); 86 | } 87 | } 88 | save_weights(sum, outfile); 89 | } 90 | 91 | void speed(char *cfgfile, int tics) 92 | { 93 | if (tics == 0) tics = 1000; 94 | network net = parse_network_cfg(cfgfile); 95 | set_batch_network(&net, 1); 96 | int i; 97 | time_t start = time(0); 98 | image im = make_image(net.w, net.h, net.c); 99 | for(i = 0; i < tics; ++i){ 100 | network_predict(net, im.data); 101 | } 102 | double t = difftime(time(0), start); 103 | printf("\n%d evals, %f Seconds\n", tics, t); 104 | printf("Speed: %f sec/eval\n", t/tics); 105 | printf("Speed: %f Hz\n", tics/t); 106 | } 107 | 108 | void operations(char *cfgfile) 109 | { 110 | gpu_index = -1; 111 | network net = parse_network_cfg(cfgfile); 112 | int i; 113 | long ops = 0; 114 | for(i = 0; i < net.n; ++i){ 115 | layer l = net.layers[i]; 116 | if(l.type == CONVOLUTIONAL){ 117 | ops += 2l * l.n * l.size*l.size*l.c * l.out_h*l.out_w; 118 | } else if(l.type == CONNECTED){ 119 | ops += 2l * l.inputs * l.outputs; 120 | } 121 | } 122 | printf("Floating Point Operations: %ld\n", ops); 123 | printf("Floating Point Operations: %.2f Bn\n", (float)ops/1000000000.); 124 | } 125 | 126 | void oneoff(char *cfgfile, char *weightfile, char *outfile) 127 | { 128 | gpu_index = -1; 129 | network net = parse_network_cfg(cfgfile); 130 | int oldn = net.layers[net.n - 2].n; 131 | int c = net.layers[net.n - 2].c; 132 | scal_cpu(oldn*c, .1, net.layers[net.n - 2].weights, 1); 133 | scal_cpu(oldn, 0, net.layers[net.n - 2].biases, 1); 134 | net.layers[net.n - 2].n = 9418; 135 | net.layers[net.n - 2].biases += 5; 136 | net.layers[net.n - 2].weights += 5*c; 137 | if(weightfile){ 138 | load_weights(&net, weightfile); 139 | } 140 | net.layers[net.n - 2].biases -= 5; 141 | net.layers[net.n - 2].weights -= 5*c; 142 | net.layers[net.n - 2].n = oldn; 143 | printf("%d\n", oldn); 144 | layer l = net.layers[net.n - 2]; 145 | copy_cpu(l.n/3, l.biases, 1, l.biases + l.n/3, 1); 146 | copy_cpu(l.n/3, l.biases, 1, l.biases + 2*l.n/3, 1); 147 | copy_cpu(l.n/3*l.c, l.weights, 1, l.weights + l.n/3*l.c, 1); 148 | copy_cpu(l.n/3*l.c, l.weights, 1, l.weights + 2*l.n/3*l.c, 1); 149 | *net.seen = 0; 150 | save_weights(net, outfile); 151 | } 152 | 153 | void partial(char *cfgfile, char *weightfile, char *outfile, int max) 154 | { 155 | gpu_index = -1; 156 | network net = parse_network_cfg(cfgfile); 157 | if(weightfile){ 158 | load_weights_upto(&net, weightfile, max); 159 | } 160 | *net.seen = 0; 161 | save_weights_upto(net, outfile, max); 162 | } 163 | 164 | #include "convolutional_layer.h" 165 | void rescale_net(char *cfgfile, char *weightfile, char *outfile) 166 | { 167 | gpu_index = -1; 168 | network net = parse_network_cfg(cfgfile); 169 | if(weightfile){ 170 | load_weights(&net, weightfile); 171 | } 172 | int i; 173 | for(i = 0; i < net.n; ++i){ 174 | layer l = net.layers[i]; 175 | if(l.type == CONVOLUTIONAL){ 176 | rescale_weights(l, 2, -.5); 177 | break; 178 | } 179 | } 180 | save_weights(net, outfile); 181 | } 182 | 183 | void rgbgr_net(char *cfgfile, char *weightfile, char *outfile) 184 | { 185 | gpu_index = -1; 186 | network net = parse_network_cfg(cfgfile); 187 | if(weightfile){ 188 | load_weights(&net, weightfile); 189 | } 190 | int i; 191 | for(i = 0; i < net.n; ++i){ 192 | layer l = net.layers[i]; 193 | if(l.type == CONVOLUTIONAL){ 194 | rgbgr_weights(l); 195 | break; 196 | } 197 | } 198 | save_weights(net, outfile); 199 | } 200 | 201 | void reset_normalize_net(char *cfgfile, char *weightfile, char *outfile) 202 | { 203 | gpu_index = -1; 204 | network net = parse_network_cfg(cfgfile); 205 | if (weightfile) { 206 | load_weights(&net, weightfile); 207 | } 208 | int i; 209 | for (i = 0; i < net.n; ++i) { 210 | layer l = net.layers[i]; 211 | if (l.type == CONVOLUTIONAL && l.batch_normalize) { 212 | denormalize_convolutional_layer(l); 213 | } 214 | if (l.type == CONNECTED && l.batch_normalize) { 215 | denormalize_connected_layer(l); 216 | } 217 | if (l.type == GRU && l.batch_normalize) { 218 | denormalize_connected_layer(*l.input_z_layer); 219 | denormalize_connected_layer(*l.input_r_layer); 220 | denormalize_connected_layer(*l.input_h_layer); 221 | denormalize_connected_layer(*l.state_z_layer); 222 | denormalize_connected_layer(*l.state_r_layer); 223 | denormalize_connected_layer(*l.state_h_layer); 224 | } 225 | } 226 | save_weights(net, outfile); 227 | } 228 | 229 | layer normalize_layer(layer l, int n) 230 | { 231 | int j; 232 | l.batch_normalize=1; 233 | l.scales = (float*)calloc(n, sizeof(float)); 234 | for(j = 0; j < n; ++j){ 235 | l.scales[j] = 1; 236 | } 237 | l.rolling_mean = (float*)calloc(n, sizeof(float)); 238 | l.rolling_variance = (float*)calloc(n, sizeof(float)); 239 | return l; 240 | } 241 | 242 | void normalize_net(char *cfgfile, char *weightfile, char *outfile) 243 | { 244 | gpu_index = -1; 245 | network net = parse_network_cfg(cfgfile); 246 | if(weightfile){ 247 | load_weights(&net, weightfile); 248 | } 249 | int i; 250 | for(i = 0; i < net.n; ++i){ 251 | layer l = net.layers[i]; 252 | if(l.type == CONVOLUTIONAL && !l.batch_normalize){ 253 | net.layers[i] = normalize_layer(l, l.n); 254 | } 255 | if (l.type == CONNECTED && !l.batch_normalize) { 256 | net.layers[i] = normalize_layer(l, l.outputs); 257 | } 258 | if (l.type == GRU && l.batch_normalize) { 259 | *l.input_z_layer = normalize_layer(*l.input_z_layer, l.input_z_layer->outputs); 260 | *l.input_r_layer = normalize_layer(*l.input_r_layer, l.input_r_layer->outputs); 261 | *l.input_h_layer = normalize_layer(*l.input_h_layer, l.input_h_layer->outputs); 262 | *l.state_z_layer = normalize_layer(*l.state_z_layer, l.state_z_layer->outputs); 263 | *l.state_r_layer = normalize_layer(*l.state_r_layer, l.state_r_layer->outputs); 264 | *l.state_h_layer = normalize_layer(*l.state_h_layer, l.state_h_layer->outputs); 265 | net.layers[i].batch_normalize=1; 266 | } 267 | } 268 | save_weights(net, outfile); 269 | } 270 | 271 | void statistics_net(char *cfgfile, char *weightfile) 272 | { 273 | gpu_index = -1; 274 | network net = parse_network_cfg(cfgfile); 275 | if (weightfile) { 276 | load_weights(&net, weightfile); 277 | } 278 | int i; 279 | for (i = 0; i < net.n; ++i) { 280 | layer l = net.layers[i]; 281 | if (l.type == CONNECTED && l.batch_normalize) { 282 | printf("Connected Layer %d\n", i); 283 | statistics_connected_layer(l); 284 | } 285 | if (l.type == GRU && l.batch_normalize) { 286 | printf("GRU Layer %d\n", i); 287 | printf("Input Z\n"); 288 | statistics_connected_layer(*l.input_z_layer); 289 | printf("Input R\n"); 290 | statistics_connected_layer(*l.input_r_layer); 291 | printf("Input H\n"); 292 | statistics_connected_layer(*l.input_h_layer); 293 | printf("State Z\n"); 294 | statistics_connected_layer(*l.state_z_layer); 295 | printf("State R\n"); 296 | statistics_connected_layer(*l.state_r_layer); 297 | printf("State H\n"); 298 | statistics_connected_layer(*l.state_h_layer); 299 | } 300 | printf("\n"); 301 | } 302 | } 303 | 304 | void denormalize_net(char *cfgfile, char *weightfile, char *outfile) 305 | { 306 | gpu_index = -1; 307 | network net = parse_network_cfg(cfgfile); 308 | if (weightfile) { 309 | load_weights(&net, weightfile); 310 | } 311 | int i; 312 | for (i = 0; i < net.n; ++i) { 313 | layer l = net.layers[i]; 314 | if (l.type == CONVOLUTIONAL && l.batch_normalize) { 315 | denormalize_convolutional_layer(l); 316 | net.layers[i].batch_normalize=0; 317 | } 318 | if (l.type == CONNECTED && l.batch_normalize) { 319 | denormalize_connected_layer(l); 320 | net.layers[i].batch_normalize=0; 321 | } 322 | if (l.type == GRU && l.batch_normalize) { 323 | denormalize_connected_layer(*l.input_z_layer); 324 | denormalize_connected_layer(*l.input_r_layer); 325 | denormalize_connected_layer(*l.input_h_layer); 326 | denormalize_connected_layer(*l.state_z_layer); 327 | denormalize_connected_layer(*l.state_r_layer); 328 | denormalize_connected_layer(*l.state_h_layer); 329 | l.input_z_layer->batch_normalize = 0; 330 | l.input_r_layer->batch_normalize = 0; 331 | l.input_h_layer->batch_normalize = 0; 332 | l.state_z_layer->batch_normalize = 0; 333 | l.state_r_layer->batch_normalize = 0; 334 | l.state_h_layer->batch_normalize = 0; 335 | net.layers[i].batch_normalize=0; 336 | } 337 | } 338 | save_weights(net, outfile); 339 | } 340 | 341 | void visualize(char *cfgfile, char *weightfile) 342 | { 343 | network net = parse_network_cfg(cfgfile); 344 | if(weightfile){ 345 | load_weights(&net, weightfile); 346 | } 347 | visualize_network(net); 348 | #ifdef OPENCV 349 | cvWaitKey(0); 350 | #endif 351 | } 352 | 353 | int main(int argc, char **argv) 354 | { 355 | //test_resize("data/bad.jpg"); 356 | //test_box(); 357 | //test_convolutional_layer(); 358 | if(argc < 2){ 359 | fprintf(stderr, "usage: %s \n", argv[0]); 360 | return 0; 361 | } 362 | gpu_index = find_int_arg(argc, argv, "-i", 0); 363 | if(find_arg(argc, argv, "-nogpu")) { 364 | gpu_index = -1; 365 | } 366 | 367 | #ifndef GPU 368 | gpu_index = -1; 369 | #else 370 | if(gpu_index >= 0){ 371 | cuda_set_device(gpu_index); 372 | } 373 | #endif 374 | 375 | if (0 == strcmp(argv[1], "average")){ 376 | average(argc, argv); 377 | } else if (0 == strcmp(argv[1], "yolo")){ 378 | run_yolo(argc, argv); 379 | } else if (0 == strcmp(argv[1], "voxel")){ 380 | run_voxel(argc, argv); 381 | } else if (0 == strcmp(argv[1], "super")){ 382 | run_super(argc, argv); 383 | } else if (0 == strcmp(argv[1], "detector")){ 384 | run_detector(argc, argv); 385 | } else if (0 == strcmp(argv[1], "detect")){ 386 | float thresh = find_float_arg(argc, argv, "-thresh", .24); 387 | char *filename = (argc > 4) ? argv[4]: 0; 388 | test_detector("cfg/coco.data", argv[2], argv[3], filename, thresh, .5); 389 | } else if (0 == strcmp(argv[1], "cifar")){ 390 | run_cifar(argc, argv); 391 | } else if (0 == strcmp(argv[1], "go")){ 392 | run_go(argc, argv); 393 | } else if (0 == strcmp(argv[1], "rnn")){ 394 | run_char_rnn(argc, argv); 395 | } else if (0 == strcmp(argv[1], "vid")){ 396 | run_vid_rnn(argc, argv); 397 | } else if (0 == strcmp(argv[1], "coco")){ 398 | run_coco(argc, argv); 399 | } else if (0 == strcmp(argv[1], "classify")){ 400 | predict_classifier("cfg/imagenet1k.data", argv[2], argv[3], argv[4], 5); 401 | } else if (0 == strcmp(argv[1], "classifier")){ 402 | run_classifier(argc, argv); 403 | } else if (0 == strcmp(argv[1], "art")){ 404 | run_art(argc, argv); 405 | } else if (0 == strcmp(argv[1], "tag")){ 406 | run_tag(argc, argv); 407 | } else if (0 == strcmp(argv[1], "compare")){ 408 | run_compare(argc, argv); 409 | } else if (0 == strcmp(argv[1], "dice")){ 410 | run_dice(argc, argv); 411 | } else if (0 == strcmp(argv[1], "writing")){ 412 | run_writing(argc, argv); 413 | } else if (0 == strcmp(argv[1], "3d")){ 414 | composite_3d(argv[2], argv[3], argv[4], (argc > 5) ? atof(argv[5]) : 0); 415 | } else if (0 == strcmp(argv[1], "test")){ 416 | test_resize(argv[2]); 417 | } else if (0 == strcmp(argv[1], "captcha")){ 418 | run_captcha(argc, argv); 419 | } else if (0 == strcmp(argv[1], "nightmare")){ 420 | run_nightmare(argc, argv); 421 | } else if (0 == strcmp(argv[1], "rgbgr")){ 422 | rgbgr_net(argv[2], argv[3], argv[4]); 423 | } else if (0 == strcmp(argv[1], "reset")){ 424 | reset_normalize_net(argv[2], argv[3], argv[4]); 425 | } else if (0 == strcmp(argv[1], "denormalize")){ 426 | denormalize_net(argv[2], argv[3], argv[4]); 427 | } else if (0 == strcmp(argv[1], "statistics")){ 428 | statistics_net(argv[2], argv[3]); 429 | } else if (0 == strcmp(argv[1], "normalize")){ 430 | normalize_net(argv[2], argv[3], argv[4]); 431 | } else if (0 == strcmp(argv[1], "rescale")){ 432 | rescale_net(argv[2], argv[3], argv[4]); 433 | } else if (0 == strcmp(argv[1], "ops")){ 434 | operations(argv[2]); 435 | } else if (0 == strcmp(argv[1], "speed")){ 436 | speed(argv[2], (argc > 3 && argv[3]) ? atoi(argv[3]) : 0); 437 | } else if (0 == strcmp(argv[1], "oneoff")){ 438 | oneoff(argv[2], argv[3], argv[4]); 439 | } else if (0 == strcmp(argv[1], "partial")){ 440 | partial(argv[2], argv[3], argv[4], atoi(argv[5])); 441 | } else if (0 == strcmp(argv[1], "average")){ 442 | average(argc, argv); 443 | } else if (0 == strcmp(argv[1], "visualize")){ 444 | visualize(argv[2], (argc > 3) ? argv[3] : 0); 445 | } else if (0 == strcmp(argv[1], "imtest")){ 446 | test_resize(argv[2]); 447 | } else { 448 | fprintf(stderr, "Not an option: %s\n", argv[1]); 449 | } 450 | return 0; 451 | } 452 | 453 | -------------------------------------------------------------------------------- /main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "opencv2/imgproc.hpp" 4 | #include 5 | 6 | using namespace cv; 7 | using namespace std; 8 | 9 | int main( ) 10 | { 11 | Mat image; 12 | image = imread("/home/prabindh/Downloads/InvitationMoT.jpg", CV_LOAD_IMAGE_COLOR); 13 | 14 | if(! image.data ) 15 | { 16 | cout << "Could not open or find the image" << std::endl ; 17 | return -1; 18 | } 19 | 20 | namedWindow( "Display window", WINDOW_AUTOSIZE );// Create a window for display. 21 | imshow( "Display window", image ); 22 | 23 | waitKey(0); 24 | return 0; 25 | } 26 | -------------------------------------------------------------------------------- /qt5-opencv3-app.pro: -------------------------------------------------------------------------------- 1 | ############################################################################# 2 | ## 3 | ## Makefile to integrate 3 key pieces of a typical system 4 | ## 5 | ## 1. Darknet/Yolo 6 | ## 2. Opencv3 7 | ## 3. Qt5 8 | ## 9 | ## Requires darknet-cpp port (atleast tag 3.75) 10 | ## https://github.com/prabindh/darknet/tree/v3.75 11 | ## 12 | ## Note: Darknet core is to be built as a shared lib (libdarknet-cpp-shared.so) 13 | ## 14 | ############################################################################### 15 | 16 | QT += core 17 | QT -= gui 18 | 19 | CONFIG += c++11 20 | 21 | TARGET = qt5_opencv3_darknet 22 | CONFIG += console 23 | CONFIG -= app_bundle 24 | 25 | INCLUDEPATH += /home/prabindh/work-2016/darknet-cpp/darknet/src/ 26 | 27 | LIBS += \ 28 | -L/usr/local/lib \ 29 | -lopencv_cudabgsegm -lopencv_cudaobjdetect -lopencv_cudastereo -lopencv_shape -lopencv_stitching -lopencv_cudafeatures2d -lopencv_superres -lopencv_cudacodec -lopencv_videostab -lopencv_cudaoptflow -lopencv_cudalegacy -lopencv_calib3d -lopencv_features2d -lopencv_objdetect -lopencv_highgui -lopencv_videoio -lopencv_photo -lopencv_imgcodecs -lopencv_cudawarping -lopencv_cudaimgproc -lopencv_cudafilters -lopencv_video -lopencv_ml -lopencv_imgproc -lopencv_flann -lopencv_cudaarithm -lopencv_viz -lopencv_core -lopencv_cudev \ 30 | -L/home/prabindh/work-2016/darknet-cpp/darknet -ldarknet-cpp-shared \ 31 | -L/usr/local/cuda/lib64 -lcuda -lcudart -lcublas -lcurand 32 | 33 | 34 | TEMPLATE = app 35 | 36 | SOURCES += darknet.cpp 37 | --------------------------------------------------------------------------------