# ComparisonExperiment

**Repository Path**: Do_yourself_maxin/comparison-experiment

## Basic Information

- **Project Name**: ComparisonExperiment
- **Description**: 不同目标检测模型在江豚数据集上的测试对比
- **Primary Language**: Python
- **License**: MulanPSL-2.0
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2023-05-22
- **Last Updated**: 2023-05-22

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# ComparisonExperiment

#### 介绍
《基于机器学习的江豚检测跟踪与行为分析》论文2.4.2节中不同目标检测模型在江豚数据集上的测试对比

<img src="./assets/性能对比.png"></img>

#### 软件架构
- YOLOV2-YOLOV4以官方<a href="https://github.com/AlexeyAB/darknet">Darknet</a>版本（c++版本）为基准进行训练和测试。
- Fast-RCNN和Faster-RCNN以<a href="https://github.com/open-mmlab/mmdetection">mmdetection</a>框架为基准进行训练和测试。
- <a href="https://github.com/xingyizhou/CenterNet">CenterNet</a>重新编译高版本<a href="https://github.com/clearlove7-piggy/DCNv2_latest">DCN</a>，以适用于30系显卡的训练和测试。


#### 安装教程

#### 一、  Darknet安装教程
> 在Windows平台使用Cmake编译Darknet：
- 下载Visual Studio：`https://visualstudio.microsoft.com/`，操作如图所示。
<img src="./assets/vs1.png"></img>
<img src="./assets/vs2.png"></img>
- 打开下载好的`Visual Studio Installer.exe` 会弹出以下界面:
<div align="center">
<img src="./assets/vsinstaller.png" align="center"></img>
</div>

此时点击“继续”。它会开始准备 Visual Studio 安装程序。若进度卡在0不动，可更改修改本机ipv4地址的dns配置：设置->网络和Internet->更改适配器选项->双击自己的网络（网线连接选择以太网，wifi连接选择WALN）->点击属性->双击Internet协议版本4->使用下面的DNS服务器地址。修改如下：
> 首选DNS服务器：114.114.114.114 

> 备选DNS服务器：8.8.8.8

准备完成后，会跳出以下界面：
<img src="./assets/installer.jpg"></img>

勾选**使用C++的桌面开发**，然后点击安装，等待安装完成。

- 下载安装Cmake:`https://cmake.org/`，操作如图所示。
<img src="./assets/cmake.png"></img>
<img src="./assets/cmake_downloads.png"></img>
下载完成后，运行安装程序进行安装，安装过程在此不做过多赘述。

- 编译Opencv：此过程在此不做过多赘述，可参考<a href="https://www.bilibili.com/video/BV1FP4y1J7G9/?spm_id_from=333.337.search-card.all.click&vd_source=d23763d69f9aac8ccfa6e36876c9a751">Windows平台下OpenCV源码编译</a>的步骤进行编译。

- 安装CUDA和CUDNN：此过程不在此做过多赘述，可参考<a href="https://blog.csdn.net/m0_45447650/article/details/123704930">这个教程</a>的步骤进行安装。

- 克隆Darknet项目到本地
````
git clone https://github.com/AlexeyAB/darknet.git
````

- 打开Cmake配置Darknet项目并编译: 操作步骤如下图所示。
<img src="./assets/darknet.png"></img>
1. 打开Cmake程序，点击`Browse Source` 选择darknet项目所在的目录，本文的路径 `D:\MyCode\darknet` 可供参考。
2. 点击 `Browse Build` 选择编译后的文件存放的路径，本文的路径 `D:\MyCode\darknet_build` 可供参考。
3. 点击`Configure` 按钮进行配置,点击后会弹出以下界面，在`Specify the generator of this project`下拉框中根据安装的Visual Studio版本进行选择，若安装的版本是`Visual Studio 2022` 就选择 `Visual Studio 17 2022`；在`Optional platform for generator`选项中选择`x64`。
<div align="center">
<img src="./assets/configure.png"></img>
</div>
4. 点击Finish后，一般会报错，如下图所示。
<div align="center">
<img src="./assets/error.png"></img>
</div>

那是因为没有配置Opencv路径所导致的,此时点击OK，然后在`Search`搜索框中搜索`OpenCV_DIR`,接着双击`OpenCV_DIR`这个条目，在右侧会出现三个点的按钮，如下图所示。点击这个按钮选择Opencv编译后生成的静态库所在的路径，最后再次点击`Configure` ，直到不再报错后，点击`Generate` 再点击`Open Project` 完成Cmake中的配置。
<div align="center">
<img src="./assets/ConfigureOpencv.png"></img>
</div>

5. 在点击完`Open Project`按钮后，会弹出`Visual Studio`界面，在上方菜单栏中选择`x64`和`Release` ，然后点击生成->生成解决方案，开始编译，如下图所示。编译过程会比较耗时，只需慢慢等待编译完成即可。

<div align="center">
<img src="./assets/vsconfigure.png"></img>
</div>

> 在Linux平台编译Darknet：
- 克隆darknet项目到本地：
````
git clone https://github.com/AlexeyAB/darknet.git
````
- 安装CUDA和CUDNN：此过程不在此做过多赘述，可参考<a href="https://blog.csdn.net/weixin_45811857/article/details/124457280">Linux安装CUDA教程</a>的步骤进行安装
- 进入到项目文件夹：
`cd darknet`
- 修改Makefile：
使用`vim Makefile`命令打开Makefile文件，修改是否使用GPU、CUDNN和OPENCV（一般都使用，改为1），以及CUDA和CUDNN的头文件以及库文件路径，如下所示：
````
GPU=1
CUDNN=1
CUDNN_HALF=0
OPENCV=1
AVX=0
OPENMP=0
LIBSO=1
ZED_CAMERA=0
ZED_CAMERA_v2_8=0

ifeq ($(GPU), 1)
COMMON+= -DGPU -I/mnt/sdb/mx/cuda-11.1/include/ #此处为cuda的头文件路径，默认为/usr/local/cuda/include/ 可根据自身情况进行修改
CFLAGS+= -DGPU
ifeq ($(OS),Darwin) #MAC
LDFLAGS+= -L/usr/local/cuda/lib -lcuda -lcudart -lcublas -lcurand
else
LDFLAGS+= -L/mnt/sdb/mx/cuda-11.1/lib64 -lcuda -lcudart -lcublas -lcurand #此处为cuda的库路径，默认为/usr/local/cuda/lib64 -lcuda -lcudart -lcublas -lcurand 可根据自身情况修改
endif
endif

ifeq ($(CUDNN), 1)
COMMON+= -DCUDNN
ifeq ($(OS),Darwin) #MAC
CFLAGS+= -DCUDNN -I/usr/local/cuda/include
LDFLAGS+= -L/usr/local/cuda/lib -lcudnn
else
CFLAGS+= -DCUDNN -I/mnt/sdb/mx/cuda-1.1/include #此处为CUDNN的头文件路径，默认为/usr/local/cudnn/include 可根据自身情况修改
LDFLAGS+= -L/mnt/sdb/mx/cuda-11.1/lib64 -lcudnn #此处为CUDNN的库文件路径，默认为/usr/local/cudnn/lib64 可根据自身情况修改
endif
endif
````
本文CUDA版本为**11.1**，路径位于`/mnt/sdb/mx/cuda-11.1` ，本文所做修改可供参考，如下图所示。
<div align="center">
<img src="./assets/darknet_linux1.png"></img>
</div>
<div align="center">
<img src="./assets/darknet_linux2.png"></img>
</div>

- 修改完Makefile文件后， 在终端输入`make`命令进行编译。

#### 二、  训练并测试YOLOV2-YOLOV4（推荐在服务器也就是Linux平台进行训练）
训练YOLOV4：

0. YOLOV4的配置文件路径是 `darknet/cfg/yolov4-custom.cfg` 需要预先下载预训练模型，预训练模型已上传至百度网盘，可点击<a href="https://pan.baidu.com/s/1bV_N1pP36JZEUXo_KgGeQw">这里</a>进行下载，提取码：`1rqp`
1. 创建名为`yolo-obj.cfg`的文件，并将`yolov4-custom.cfg`文件中的内容全部复制到`yolo-obj-.cfg`文件中，创建文件可通过`touch yolo-obj.cfg`命令进行创建,完成上述步骤后，打开`yolo-obj.cfg`文件并做如下修改：
- 将`Training`那一行前的`#`符号删除
- 将`max_batches`那一行中的`max_batches`修改为（`classes*2000`,不应该低于这个值）。例如：本文训练的江豚检测模型，类别为**1** ,`max_batches`应设置为`max_batches=2000`，不得低于2000这个值。
- 将steps那一行修改为`max_batches`的80%和90%。例如本文训练的江豚检测模型`max_batches=2000`，则steps应该修改为`steps=1600,1800`
- 将网络的输入尺寸修改为`width=416,height=416`，或者任何32的倍数（原则上不低于416，不然精度会降低），本文设置的尺寸为`width=608,height=608`
- 将`classes=80`这一行修改为，检测的类别个数。例如本文的江豚检测模型，类别为1，应设置为`classes=1`，总共需要修改3处，分别在970行、1058行和1146行附近。
- 将位于`[convolutional]`和`[yolo]`之间的`filters=255`这一行修改为`(classes+5)x3`。例如本文的江豚检测模型，类别为1，应设置为`filters=18`，共需修改3处，分别在963行、1051行和1139行附近。
2. 在`build\darknet\x64\data\`路径下创建名为`obj.names`的文件，在文件中输入检测类别的名字。例如，本文的江豚检测任务，`obj.names`文件中的内容为`Neophocaena`（江豚的英文名）
3. 在`build\darknet\x64\data\`路径下，创建名为`obj.data`的文件，文件中应包含以下内容：
````
classes = 1 #根据检测类别修改,本文为1
train  = data/train.txt #训练集路径
valid  = data/test.txt  #验证集路径
names = data/obj.names  #类别名文件路径
backup = backup/        #训练得到的模型存放的路径
````
4. 将数据集图片放到`build\darknet\x64\data\obj`下，若没有obj这个文件夹，创建一个即可。
5. 将数据集标签（txt文件）放到`build\darknet\x64\data\obj`下。
6. 训练：
- windows环境可在`cmd`命令行中输入以下命令进行训练：
````
darknet.exe detector train data/obj.data yolo-obj.cfg yolov4.conv.137
````
- Linux环境可在终端中输入以下命令进行训练：
````
./darknet detector train data/obj.data yolo-obj.cfg yolov4.conv.137
````
7. 多GPU训练：可在训练命令后加上`gpus`参数指定gpu的序号(此处假定有4张显卡)
- Windows环境：
````
darknet.exe detector train data/obj.data yolo-obj.cfg yolov4.conv.137 -gpus 0,1,2,3
````
- Linux环境：
````
./darknet detector train data/obj.data yolo-obj.cfg yolov4.conv.137 -gpus 0,1,2,3
````
8. 训练完成后会在`build\darknet\x64\backup\` 路径下生成名为`yolo-obj_final.weights`的模型权重文件。
9. 测试精度：
- Windows环境：
````
darknet.exe detector valid data/obj.data yolo-obj.cfg backup/yolo-obj_final.weights
````
- Linux环境：
````
./darknet detector valid data/obj.data yolo-obj.cfg backup/yolo-obj_final.weights
````
10. 测试FPS：
````
darknet.exe detector demo data/obj.data yolo-obj.cfg backup/yolo-obj_final.weights test.mp4 -dont_show -ext_output 
````
- Linux环境：
````
./darknet detector demo data/obj.data yolo-obj.cfg backup/yolo-obj_final.weights test.mp4 -dont_show -ext_output
````

训练YOLOV3：
0. 下载预训练模型：已上传至百度网盘，点击<a href="https://pan.baidu.com/s/1d70E1nTv3bSv4_MY_y3lQw">这里</a>进行下载，提取码：`nson`
其他步骤和训练YOLOV4步骤基本一致，只第一步中需将`darknet/cfg/yolov3.cfg`中的内容复制到自己创建的cfg文件中。

训练YOLOV2：
0. 下载预训练模型：已上传至百度网盘，点击<a href="https://pan.baidu.com/s/1sT1mgIquPyD4aoORFH9-iQ">这里</a>进行下载，提取码：`5ljd`
1. 将数据集格式从yolo格式转换为voc格式：本文一提供转换脚本，位于`src/yolo2voc.py`中。
- 可通过以下命令运行`src/yolo2voc.py`实现数据集格式的转换。
````
python yolo2voc.py --yolo_label ./labels --voc_label ./Annotations --img_path ./images --classes Neophocaena --task_id 0
                   --yolo_label yolo格式的数据集标签文件的路径，默认为./labels 根据自身情况修改
                   --voc_label 生成voc格式数据集的路径，默认为./Annotations 可随意指定
                   --img_path 数据集图片的路径，默认为./images 根据自身情况指定
                   -- classes 数据集类别名称，根据自身情况指定，本文为江豚，所以设置为Neophocaena
````
- 转换数据集格式后，可通过以下命令生成`train.txt`和`val.txt`：
````
python yolo2voc.py --main_path ./Main --task_id 1
                   --main_path 转换数据集后Main文件夹所在路径
````
2. 修改`darknet/cfg/voc.data`文件，修改内容如下：
````
classes= 1 #根据自身情况设置，本文为1
train  = <path-to voc>/train.txt # train.txt文件所在路径，根据自身情况设置
valid  = <path-to voc>/val.txt   # val.txt文件所在路径，根据自身情况设置
names = data/voc.names           # 类别名称，根据自身情况修改文件中的内容，本文为Neophocaena
backup = /home/pjreddie/backup/  # 训练好的模型存放路径，可自行设置。
````
3. 修改`darknet/cfg/yolo-voc.2.0.cfg`文件，有两处需要修改：
- `classes=N`（N为类别数，本文为1）
- 最后一个`[convolutional]`层中`filters=(classes+4+1)x5`本文设置为`filters=30`

4. 训练：
- Windows平台：
````
darknet.exe detector train cfg/voc.data yolo-voc.2.0.cfg darknet19_448.conv.23
````
- Linux平台：
````
./darknet detector train cfg/voc.data yolo-voc.2.0.cfg darknet19_448.conv.23
````
5. 多GPU训练：同上
6. 测试精度：
- Windows平台：
````
darknet.exe detector valid cfg/voc.data yolo-voc.2.0.cfg backup/yolo-voc_final.weights 
````
- Linux平台：
````
./darknet detector valid cfg/voc.data yolo-voc.2.0.cfg backup/yolo-voc_final.weights
````
7. 测试FPS：
````
darknet.exe detector demo cfg/voc.data yolo-voc.2.0.cfg backup/yolo-voc_final.weights test.mp4 -dont_show -ext_output 
````
- Linux平台：
````
./darknet detector demo cfg/voc.data yolo-voc.2.0.cfg backup/yolo-voc_final.weights test.mp4 -dont_show -ext_output
````

#### 三、  MMDetection安装教程
0. 从<a href="https://docs.conda.io/en/latest/miniconda.html">Miniconda官网</a>下载并安装Miniconda
1. 创建conda虚拟环境并激活
````
conda create --name openmmlab python=3.8 -y
conda activate openmmlab
````
2. 从<a href="https://pytorch.org/get-started/locally/">Pytoch官网</a>下载并安装Pytoch,在此不做过多赘述
3. 使用`MIM`安装`MMEngine`和`MMCV`:
````
pip install -U openmim
mim install mmengine
mim install "mmcv>=2.0.0"
````
4. 安装MMDetection：
````
git clone https://github.com/open-mmlab/mmdetection.git
cd mmdetection
pip install -v -e .
````

#### 四、  训练并测试Fast-RCNN和Faster-RCNN
训练并测试Fast-RCNN:
0. 开始训练前需将数据集格式从yolo格式转换为coco格式，本文已提供转换脚本，位于`src/yolo2coco.py`中，可通过以下命令运行，实现格式的转换：
````
python yolo2coco.py --root_dir ./data --ramdom_split 
                    --root_dir yolo格式的数据集所在的路径，需要根据自身情况修改
````
1. 格式转换过后，会在`annotations`文件夹下生成`train.json`、`val.json`、`test.json`三个文件，需将这三个文件重命名为`instances_train2017.json`、`instances_val2017.json`、`instances_test2017.json`
2. 在训练Fast-RCNN之前，需首先训练RPN，并使用RPN提取区域建议。在RPN配置文件(`configs/rpn/fast-rcnn_r50_fpn_1x_coco.py`)中将`test_evaluator`的类型更改为`DumpProposals`，以获得如下区域方案。
- 获取训练图像区域建议的配置修改如下：
````
# For training set
val_dataloader = dict(
    dataset=dict(
        ann_file='data/coco/annotations/instances_train2017.json',
        data_prefix=dict(img='val2017/')))
val_dataloader = dict(
    _delete_=True,
    type='DumpProposals',
    output_dir='data/coco/proposals/',
    proposals_file='rpn_r50_fpn_1x_train2017.pkl')
test_dataloader = val_dataloader
test_evaluator = val_dataloader
````
- 获取测试图像区域建议的配置修改如下：
````
# For validation set
val_dataloader = dict(
  _delete_=True,
  type='DumpProposals',
  output_dir='data/coco/proposals/',
  proposals_file='rpn_r50_fpn_1x_val2017.pkl')
test_evaluator = val_dataloader
````
- 可用以下命令提取区域建议：
````
./tools/dist_test.sh \
    configs/rpn_r50_fpn_1x_coco.py \
    checkpoints/rpn_r50_fpn_1x_coco_20200218-5525fa2e.pth \
    8
````
3. 修改Fast-RCNN配置文件（`configs/fast-rcnn/fast-rcnn_r50_fpn_1x_coco.py`）中`proposal_file`的路径，并使用`ProposalBroadcaster`处理真实边界框和提取的区域建议。本文修改的示例如下所示，可供参考：
````
train_pipeline = [
    dict(
        type='LoadImageFromFile',
        backend_args={{_base_.backend_args}}),
    dict(type='LoadProposals', num_max_proposals=2000),
    dict(type='LoadAnnotations', with_bbox=True),
    dict(
        type='ProposalBroadcaster',
        transforms=[
            dict(type='Resize', scale=(1333, 800), keep_ratio=True),
            dict(type='RandomFlip', prob=0.5),
        ]),
    dict(type='PackDetInputs')
]
test_pipeline = [
    dict(
        type='LoadImageFromFile',
        backend_args={{_base_.backend_args}}),
    dict(type='LoadProposals', num_max_proposals=None),
    dict(
        type='ProposalBroadcaster',
        transforms=[
            dict(type='Resize', scale=(1333, 800), keep_ratio=True),
        ]),
    dict(
        type='PackDetInputs',
        meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape',
                   'scale_factor'))
]
train_dataloader = dict(
    dataset=dict(
        proposal_file='data/coco/proposals/rpn_r50_fpn_1x_train2017.pkl',
        pipeline=train_pipeline))
val_dataloader = dict(
    dataset=dict(
        proposal_file='data/coco/proposals/rpn_r50_fpn_1x_val2017.pkl',
        pipeline=test_pipeline))
test_dataloader = val_dataloader
````
4. 训练Fast-RCNN模型
````
python tools/train.py configs/fast_rcnn/fast_rcnn_r50_fpn_1x_coco.py
````
5. 多GPU训练
````
bash ./tools/dist_train.sh \
    ${CONFIG_FILE} \
    ${GPU_NUM} \
    [optional arguments]
````
6. 测试及推理：
````
python tools/test.py configs/fast_rcnn/fast_rcnn_r50_fpn_1x_coco.py work_dirs/faster_rcnn_r50_fpn_1x_coco/latest.pth
````
7. FPS测试：
````
python -m torch.distributed.launch --nproc_per_node=1 --master_port=29500 tools/analysis_tools/benchmark.py \
       configs/faster_rcnn/fast-rcnn_r50_fpn_1x_coco.py \
       work_dirs/faster_rcnn_r50_fpn_1x_coco/latest.pth \
       --launcher pytorch
````

训练并测试Faster-RCNN: 同上。

#### 五、  训练并测试CenterNet
0. 创建虚拟环境并激活：
````
conda create --name CenterNet python=3.6
conda activate CenterNet
````
1. 安装Pytorch：此步骤在此不做过多赘述。
2. 安装COCOAPI：依次执行以下命令
````
# 本文COOCAPI的安装路径为：`mnt/sdb/mx/cocoapi` 可供参考
git clone https://github.com/cocodataset/cocoapi.git
cd cocoapi/PythonAPI
make
python setup.py install --user
````
3. 克隆CenterNet到本地：
````
git clone https://github.com/xingyizhou/CenterNet.git
````
4. 安装必要的依赖：
````
cd CenterNet
pip install -r requirements.txt
````
5. 编译可变形卷积组件：
````
cd CenterNet/src/lib/models/networks
rm -r DCNv2
git clone https://github.com/clearlove7-piggy/DCNv2_latest.git
cd DCNv2
python setup.py build develop
````
6. 编译NMS组件：
````
cd CenterNet/src/lib/external
make
````
7. 在CenterNet文件夹下创建`models`文件夹,并将下载好的预训练模型放到改文件夹下，点击<a href="https://pan.baidu.com/s/1lkdlNRfrczchK0-FOOTPiA">这里</a>下载预训练模型，提取码：`d4nc`
8. 训练CenterNet：运行以下命令训练CenterNet
````
python src/main.py ctdet --exp_id coco_dla --batch_size 32 --master_batch 15 --lr 1.25e-4  --gpus 0,1
````
9. 测试模型性能：
````
python src/test.py ctdet --exp_id coco_dla --keep_res --load_model ../models/ctdet_coco_dla_2x.pth
````

#### 五、  本文中不同目标检测模型在江豚数据集上的性能测试结果
<table align="center" style="text-align:center;">
<tr>
<th style="text-align:center">模型</th>
<th>mAP(%)</th>
<th>Recall(%)</th>
<th>FPS(帧/s)</th>
</tr>
<tr>
<td>YOLOV5</td>
<td>92.5</td>
<td><b>94.1</b></td>
<td><b>172</b></td>
</tr>
<tr>
<td>YOLOV4</td>
<td>91.7</td>
<td>91.1</td>
<td>97</td>
</tr>
<tr>
<td>YOLOV3</td>
<td>88.5</td>
<td>86.3</td>
<td>54</td>
</tr>
<tr>
<td>YOLOV2</td>
<td>83.2</td>
<td>84.1</td>
<td>46</td>
</tr>
<tr>
<td>Fast-RCNN</td>
<td>91.9</td>
<td>60.2</td>
<td>35</td>
</tr>
<tr>
<td>Faster-RCNN</td>
<td><b>96.4</b></td>
<td>72.8</td>
<td>43</td>
</tr>
<tr>
<td>CenterNet</td>
<td>92.1</td>
<td>67.3</td>
<td>56</td>
</tr>
</table>


#### 参考
> Paper: 
- <a href="https://arxiv.org/abs/1904.07850">Objects as Points</a>
- <a href="https://arxiv.org/abs/1504.08083">Fast R-CNN</a>
- <a href="https://arxiv.org/abs/1506.01497">Faster R-CNN: Towards Real-Time Object Detection with Region Proposal Networks</a>
- <a href="https://arxiv.org/abs/2004.10934">YOLOv4: Optimal Speed and Accuracy of Object Detection</a>

> Code:
- <a href="https://github.com/AlexeyAB/darknet">darknet</a>
- <a href="https://github.com/open-mmlab/mmdetection">mmdetection</a>
- <a href="https://github.com/xingyizhou/CenterNet">CenterNet</a>