darknet_ros加速--使用GPU和CUDA

 更改darknet_ros文件里面的Makefile编译文件

参考教程：ubuntu下darknet的gpu配置(包含ros下的)当然这个是不完整的，不然我也没有必要重新写一份了。还有这个教程：darknet_ros +yolov3+Basler camera 实时目标检测环境配置（Ubuntu16.04+ROS kinetic），后面我会大致的讲一下。

第一处:更改Makefile前两行GPU和CUDNN的配置：

把0改成1 这里需要说明一下：ros-kinetic版本自带的opencv是3.3.1版本的，而darknet网络模型使用的yolov3要求版本在3.4.2以上，也就是说需要安装别的版本的opencv，但是实际用的是哪个版本的opencv我暂时还没有弄清楚。 

第二处:更改CUDA的路径：

在这里改成自己对应的本地路径

第三处:23行，修改NVCC的路径

第四处：更改第7行的ARCH，改成自己显卡的算力，这里我在官网上查询的算力为6.1,另外算力表也可以百度查查看，没有新的显卡用，我没怎么关注了。。。唉

修改完成后编译：在darknet_ros/darknet文件夹下编译输入make

~/ros1_ws/src/darknet_ros/darknet$ make

当然你会报错的，就像我一样，但是不要紧，有解决的办法：如何解决pjreddie版darknet不能使用cudnn8编译的问题 

大致原因就是，只支持到cudnn7.x，也就是说我们需要把8的内容添加一些，对于本小白还是有点担心的，只能上了。

打开报错文件的路径：/home/groot/ros1_ws/src/darknet_ros/darknet/src/convolutional_layer.c

添加这两行命令：

#include <stdio.h>
#include <time.h>
//下面是添加的命令
#define PRINT_CUDNN_ALGO 0
#define MEMORY_LIMIT 2000000000
 
#ifdef AI2
#include "xnor_layer.h"
#endif

然后大段的代码复制粘贴在这个位置：

#ifdef GPU
 #ifdef CUDNN
 void cudnn_convolutional_setup(layer *l)
 {
     ...
 
     #if CUDNN_MAJOR >= 7
     cudnnSetConvolutionGroupCount(l->convDesc, l->groups);
     #else
     if(l->groups > 1){
         error("CUDNN < 7 doesn't support groups, please upgrade!");
     }
     #endif

 //注意下面是需要添加的代码，一直到底
    #if CUDNN_MAJOR >= 8
    int returnedAlgoCount;
    cudnnConvolutionFwdAlgoPerf_t       fw_results[2 * CUDNN_CONVOLUTION_FWD_ALGO_COUNT];
    cudnnConvolutionBwdDataAlgoPerf_t   bd_results[2 * CUDNN_CONVOLUTION_BWD_DATA_ALGO_COUNT];
    cudnnConvolutionBwdFilterAlgoPerf_t bf_results[2 * CUDNN_CONVOLUTION_BWD_FILTER_ALGO_COUNT];
 
    cudnnFindConvolutionForwardAlgorithm(cudnn_handle(),
            l->srcTensorDesc,
            l->weightDesc,
            l->convDesc,
            l->dstTensorDesc,
            CUDNN_CONVOLUTION_FWD_ALGO_COUNT,
            &returnedAlgoCount,
	    fw_results);
    for(int algoIndex = 0; algoIndex < returnedAlgoCount; ++algoIndex){
        #if PRINT_CUDNN_ALGO > 0
        printf("^^^^ %s for Algo %d: %f time requiring %llu memory\n",
               cudnnGetErrorString(fw_results[algoIndex].status),
               fw_results[algoIndex].algo, fw_results[algoIndex].time,
               (unsigned long long)fw_results[algoIndex].memory);
        #endif
        if( fw_results[algoIndex].memory < MEMORY_LIMIT ){
            l->fw_algo = fw_results[algoIndex].algo;
            break;
	}
    }
 
    cudnnFindConvolutionBackwardDataAlgorithm(cudnn_handle(),
            l->weightDesc,
            l->ddstTensorDesc,
            l->convDesc,
            l->dsrcTensorDesc,
            CUDNN_CONVOLUTION_BWD_DATA_ALGO_COUNT,
            &returnedAlgoCount,
            bd_results);
    for(int algoIndex = 0; algoIndex < returnedAlgoCount; ++algoIndex){
        #if PRINT_CUDNN_ALGO > 0
        printf("^^^^ %s for Algo %d: %f time requiring %llu memory\n",
               cudnnGetErrorString(bd_results[algoIndex].status),
               bd_results[algoIndex].algo, bd_results[algoIndex].time,
               (unsigned long long)bd_results[algoIndex].memory);
        #endif
        if( bd_results[algoIndex].memory < MEMORY_LIMIT ){
            l->bd_algo = bd_results[algoIndex].algo;
            break;
        }
    }
 
    cudnnFindConvolutionBackwardFilterAlgorithm(cudnn_handle(),
            l->srcTensorDesc,
            l->ddstTensorDesc,
            l->convDesc,
            l->dweightDesc,
            CUDNN_CONVOLUTION_BWD_FILTER_ALGO_COUNT,
            &returnedAlgoCount,
            bf_results);
    for(int algoIndex = 0; algoIndex < returnedAlgoCount; ++algoIndex){
        #if PRINT_CUDNN_ALGO > 0
        printf("^^^^ %s for Algo %d: %f time requiring %llu memory\n",
               cudnnGetErrorString(bf_results[algoIndex].status),
               bf_results[algoIndex].algo, bf_results[algoIndex].time,
               (unsigned long long)bf_results[algoIndex].memory);
        #endif
        if( bf_results[algoIndex].memory < MEMORY_LIMIT ){
            l->bf_algo = bf_results[algoIndex].algo;
            break;
        }
    }
 
    #else
    
     cudnnGetConvolutionForwardAlgorithm(cudnn_handle(),
             l->srcTensorDesc,
             l->weightDesc,
             l->convDesc,
             l->dstTensorDesc,
             CUDNN_CONVOLUTION_FWD_SPECIFY_WORKSPACE_LIMIT,
             2000000000,
             &l->fw_algo);
     cudnnGetConvolutionBackwardDataAlgorithm(cudnn_handle(),
             l->weightDesc,
             l->ddstTensorDesc,
             l->convDesc,
             l->dsrcTensorDesc,
             CUDNN_CONVOLUTION_BWD_DATA_SPECIFY_WORKSPACE_LIMIT,
             2000000000,
             &l->bd_algo);
     cudnnGetConvolutionBackwardFilterAlgorithm(cudnn_handle(),
             l->srcTensorDesc,
             l->ddstTensorDesc,
             l->convDesc,
             l->dweightDesc,
             CUDNN_CONVOLUTION_BWD_FILTER_SPECIFY_WORKSPACE_LIMIT,
             2000000000,
             &l->bf_algo);
    
    #endif

后面结束的样子

然后再编译，这个问题就解决了。

在工作空间编译darknet_ros

catkin_make -DCMAKE_BUILD_TYPE=Release

此时会开始编译整个项目，编译完成后会检查{catkin_ws}/darknet_ros/darknet_ros/yolo_network_config/weights文件下有没有yolov2-tiny.weights和yolov3.weights两个模型文件，默认下载好的代码里面为了节省体积是不带这两个模型文件的。因此编译之后会自动开始下载模型文件，此时又是一段漫长的等待时间。
如果刚好你之前已经下载好了模型文件，那就好了，在开始编译之前就把模型文件拷贝到上述文件夹下，就不会再次下载了。

让我们开始检测吧～

相比之前的1帧，现在FPS已经达到了18.8,我基本满意了。