我要先声明一下，系统是Ubuntu18.04，我的机器已经装好了opencv4.1.1 和 cuda10.0 的，过程可参考我另一篇博客，这部分不再说明
IDE使用qtcreator
1.下载Darknet
Github链接
官网链接
这个不用多讲，直接git clone，网不好不管
git clone https://github.com/pjreddie/darknet
还要下载预训练权重darknet53.conv.74
这个先放一边，一会拿它组成训练文件夹
下载完成后进入darknet文件夹
2.配置Makefile
为了方便修改代码，使用VSCode打开darknet所在的文件夹
找到Makefile文件，打开，前5行是配置的参数，OPENCV、GPU、CUDNN全部打开
GPU=0
CUDNN=0
OPENCV=0
OPENMP=0
DEBUG=0
修改完就是这样的
GPU=1
CUDNN=1
OPENCV=1
OPENMP=0
DEBUG=0
关于后面的显卡计算能力配置这个参考别的博客，我不修改没有遇到问题
ARCH= -gencode arch=compute_30,code=sm_30 \
-gencode arch=compute_35,code=sm_35 \
-gencode arch=compute_50,code=[sm_50,compute_50] \
-gencode arch=compute_52,code=[sm_52,compute_52]
找到第42行，修改pkg-congif的包名称，opencv4的名称就是opencv4，两处都改
ifeq ($(OPENCV), 1)
COMMON+= -DOPENCV
CFLAGS+= -DOPENCV
LDFLAGS+= `pkg-config --libs opencv` -lstdc++
COMMON+= `pkg-config --cflags opencv`
endif
这样，其他的不用动
ifeq ($(OPENCV), 1)
COMMON+= -DOPENCV
CFLAGS+= -DOPENCV
LDFLAGS+= `pkg-config --libs opencv4` -lstdc++
COMMON+= `pkg-config --cflags opencv4`
endif
下面紧接着是cuda的库，检查一下是否和自己的路径相符，我的默认就好
ifeq ($(GPU), 1)
COMMON+= -DGPU -I/usr/local/cuda/include/
CFLAGS+= -DGPU
LDFLAGS+= -L/usr/local/cuda/lib64 -lcuda -lcudart -lcublas -lcurand
endif
到此Makefile配置完成
3.编译，并修改一些错误
按快捷键Ctrl+shift+P打开VSCode的命令，搜索C/C++，打开编辑配置(UI)，不用UI的随便
- 找到包含路径，添加opencv的包含路径和cuda的包含路径，为了后面修改代码方便
查看opencv的包含地址用pkg-config就行了，例如我的写/usr/local/include/opencv4/**让它自己找就行了
cuda的找不到，一般在/usr/local/cuda/include里面，我的添加完如下
${workspaceFolder}/**
/usr/local/cuda/include/
/usr/local/include/opencv4/**
- 添加全局，就在下面的格里，配置参数打开啥就填上啥，我的是这样
OPENCV
CUDNN
GPU
do{
make;
if(编译出错){
修改;
continue;
}
else break;
}while(1);
其实很简单按Ctrl+shift+`打开VSCode的终端，执行make
然后报错
./src/image_opencv.cpp:12:1: error: ‘IplImage’ does not name a type; did you mean ‘image’?
IplImage *image_to_ipl(image im)
^~~~~~~~
这是因为他原来写的是opencv3的结构和命名，4的有些变动
按住Ctrl，鼠标点击./src/image_opencv.cpp:12:1直接转到这个位置，这是我用VSCode的一大原因
在最上面添加一个头文件
#include "opencv2/imgproc/imgproc_c.h"
这个错误就解决了
然后是
./src/image_opencv.cpp:76:20: error: ‘CV_CAP_PROP_FRAME_WIDTH’ was not declared in this scope
if(w) cap->set(CV_CAP_PROP_FRAME_WIDTH, w);
这个就是命名变化的，此类的把前面的CV_去掉就行，这个错误都在image_opencv.cpp里面，这个文件以后有用，请记住它，改完错误就能完成编译。
4.制作自己的数据集
先建一个文件夹，名字任意，不要带中文，你懂的然后以下都是在这里面操作
darknet YoloV3的数据集格式是文本文档，结构简单
一个JPEGImages文件夹，里面放图片，都是JPG格式的，不是的话可以用opencv自己写程序自动转换
另一个labels文件夹，存放标记文件也是txt格式是文本文档
标记文件具体的格式是，文件名和对应的JPG文件名保证相同
2 0.341624 0.582733 0.00729167 0.0175926
1 0.433048 0.624979 0.0286458 0.062963
4 0.265383 0.666638 0.0776042 0.125926
然后两个文件夹一定放在一起，darknet似乎是直接自动找相对于图片文件的../labels/xxxxxx.txt来找标记文件的
再建一个backup文件夹，用来存放训练权重文件的备份
weigits文件夹，用来存放训练完成要保留的权重文件，这个自愿
ImageSets文件夹，用来存图片集在里面再建两个文本文档，就是图片集了
一个名叫train.txt就是用来训练的图片集，里面存JPG图片的路径，推荐绝对路径，一行一个路径
另一个val.txt用来验证格式相同
出ImageSets文件夹，
新建一个voc.names文本文档里面写你的目标的标签，例如
car
people
bicycle
bird
boat
一行一个我已5个目标为例
新建一个voc.data文本文档里面有5行
classes= 你的目标数量
train = /...../你的训练集文件夹/ImageSets/train.txt
valid = /...../你的训练集文件夹/ImageSets/val.txt
names = /...../你的训练集文件夹/voc.names
backup = /...../你的训练集文件夹/backup
还有一个最重要的cfg文件，从cfg/yolov3-voc.cfg里面复制一个，到你的文件夹里，可以重命名，后缀保留（其实应该没关系）然后修改
前几行[net]下面
[net]
# Testing
batch=1 #batch是多少张图片迭代一次训练，调大能快速收敛，但是这个超级吃显存
subdivisions=1 #subdivisions是分多少步去计算一个batch的图片
#最终同时在显存里的就是batch/subdivisions，可以达到既能收敛又能省显存的目的
# Training
# batch=64
# subdivisions=16
width=416 #width和height还有channels是网络入口的大小，通道一般不变，宽高在速度和精度之间衡量
height=416
channels=3
momentum=0.9
decay=0.0005
angle=0
saturation = 1.5
exposure = 1.5
hue=.1
learning_rate=0.001 #学习率，不变就好
burn_in=1000
max_batches = 50200 #最大迭代次数
policy=steps #下面三行都是学习率衰减策略，如果这项不动的话就
steps=40000,45000 #是在迭代40000次时学习率乘0.1,45000次时再乘0.1
scales=.1,.1 #要根据你的最大迭代次数改，可以逗号分隔再往后填
然后在下面找[yolo]项，一共有3个，在608行，692行，776行
拿一个为例，其他三个一样
[convolutional]
size=1
stride=1
pad=1
filters=10 #这个一定要改，和目标数量有关，就是3*（目标数量+5），否则在构建网络的时候报错
activation=linear
[yolo]
mask = 0,1,2
anchors = 10,13, 16,30, 33,23, 30,61, 62,45, 59,119, 116,90, 156,198, 373,326
classes=20 #类的数量
num=9
jitter=.3
ignore_thresh = .5
truth_thresh = 1
random=1 #多尺度训练，能让大图片准，小图片快，代价就是显存
#如果输入的图片大小固定应该没啥用，可以关掉
再加上一开始下载的预训练权重，这样就配置完成了
最终的文件夹结构
你的训练集文件夹
╞backup
╞ImageSets
║ └train.txt val.txt
╞JPEGImages
║ └你的图片
╟labels
║ └你的标签
╟weigits
╟voc.names
╟voc.data
╟yolov3-voc.cfg
└darknet53.conv.74
关于训练集标签和图片集的生成，我想大家都是撸代码的，偷懒办法不可能想不出来吧
4.1来一点自动化工具
本来能直接开始训练了，但是本人比较懒，嫌命令太长，然后就有了这个
DARKNET_PATH=你的darknet路径
LOCAT=${PWD}
classes=5
TRAIN_PATH=${LOCAT}/ImageSets/train.txt
VALID_PATH=${LOCAT}/ImageSets/val.txt
NAMES_PATH=${LOCAT}/voc.names
BACKUP_PATH=${LOCAT}/backup
DATA_PATH=${LOCAT}/voc.data
CFG_PATH=${LOCAT}/yolov3-voc.cfg
MODEL_PATH=${LOCAT}/darknet53.conv.74
cat>${DATA_PATH}<<EOF
classes= ${classes}
train = ${TRAIN_PATH}
valid = ${VALID_PATH}
names = ${NAMES_PATH}
backup = ${BACKUP_PATH}
EOF
cd ${DARKNET_PATH}
if [ "$1" = "train" ];then
if [ "$2" = "" ];then
./darknet detector train ${DATA_PATH} ${CFG_PATH} darknet53.conv.74 -gpus 0
else
if [ "$2" = "goon" ];then
WEIGHT=${BACKUP_PATH}/yolov3-voc.backup
./darknet detector train ${DATA_PATH} ${CFG_PATH} ${WEIGHT} -gpus 0
else
./darknet detector train ${DATA_PATH} ${CFG_PATH} $2 -gpus 0
fi
fi
fi
if [ "$1" = "test" ];then
WEIGHT=${BACKUP_PATH}/yolov3-voc.backup
if [ "$3" = "" ];then
./darknet detector test ${DATA_PATH} ${CFG_PATH} ${WEIGHT} -gpus 0 $2
else
./darknet detector test ${DATA_PATH} ${CFG_PATH} $3 $2 -gpus 0
fi
fi
前面的都简单，使用方法就是
./xxxx.sh train 是训练（默认使用darknet53.conv.74训练）
./xxxx.sh train goon是继续上一次权重训练（默认使用backup/yolov3-voc.backup训练）
./xxxx.sh train 另一个权重文件的路径 就是在另一个权重文件基础上训练
./xxxx.sh test JPG文件路径就是使用那个图片测试
./xxxx.sh test JPG文件路径 权重文件的路径就是使用那个图片和权重文件测试
把这个脚本也放进你的训练集文件夹里就行了
5.开始训练
配置好上一步的前几行变量就可以./xxxx.sh train了
想要预览效果可以./xxxx.sh test JPG文件路径
6.C++调用
首先将darknet目录下include/darknet.h和libdarknet.so复制到其他的安全的地方（比如在/usr/local下面新建一个文件夹）然后把那个共享库加到系统里
cd /etc/ld.so.conf.d/
sudo vim darknet.conf
sudo ldconfig
新建一个qtcreator的项目（拿qtcreator举例，操作都可以在其他平台上复现）
在pro文件里添加opencv（这个就不详细说了）
添加darknet.h的引用目录，添加cuda的引用目录，前面提到了一般在/usr/local/cuda/include里面
添加darknet和cuda的库路径，添加OPENCV那几个在VSCode里面添加过的宏
完事就是这样的
INCLUDEPATH += /usr/local/darknet /usr/local/cuda/include
LIBS += -L/usr/local/darknet/lib -L/usr/local/cuda/lib64 -lcuda -lcudart -lcublas -lcurand -lcudnn -ldarknet
DEFINES += GPU OPENCV CUDNN
回到VSCode里，读一下darknet的源码
找到examples/darknet.c，里面包含main函数，可以顺着找到函数，调用肯定是和测试差不多的，找到识别detector命令的地方
} else if (0 == strcmp(argv[1], "detector")){
run_detector(argc, argv);
就是这个函数，到定义
if(0==strcmp(argv[2], "test")) test_detector(datacfg, cfg, weights, filename, thresh, hier_thresh, outfile, fullscreen);
else if(0==strcmp(argv[2], "train")) train_detector(datacfg, cfg, weights, gpus, ngpus, clear);
能找到test命令和train命令，到定义test_detector
void test_detector(char *datacfg, char *cfgfile, char *weightfile, char *filename, float thresh, float hier_thresh, char *outfile, int fullscreen)
{
list *options = read_data_cfg(datacfg);
char *name_list = option_find_str(options, "names", "data/names.list");
char **names = get_labels(name_list);
image **alphabet = load_alphabet();
network *net = load_network(cfgfile, weightfile, 0);
set_batch_network(net, 1);
srand(2222222);
double time;
char buff[256];
char *input = buff;
float nms=.45;
while(1){
if(filename){
strncpy(input, filename, 256);
} else {
printf("Enter Image Path: ");
fflush(stdout);
input = fgets(input, 256, stdin);
if(!input) return;
strtok(input, "\n");
}
image im = load_image_color(input,0,0);
image sized = letterbox_image(im, net->w, net->h);
layer l = net->layers[net->n-1];
float *X = sized.data;
time=what_time_is_it_now();
network_predict(net, X);
printf("%s: Predicted in %f seconds.\n", input, what_time_is_it_now()-time);
int nboxes = 0;
detection *dets = get_network_boxes(net, im.w, im.h, thresh, hier_thresh, 0, 1, &nboxes);
if (nms) do_nms_sort(dets, nboxes, l.classes, nms);
draw_detections(im, dets, nboxes, thresh, names, alphabet, l.classes);
free_detections(dets, nboxes);
if(outfile){
save_image(im, outfile);
}
else{
save_image(im, "predictions");
#ifdef OPENCV
make_window("predictions", 512, 512, 0);
show_image(im, "predictions", 0);
#endif
}
free_image(im);
free_image(sized);
if (filename) break;
}
}
这就是最好的例程了,其中$结尾的是必须的步骤
如果想要使用opencv读取图像,找到src/image_opencv.cpp
里面的mat_to_image是将opencv的Mat转换为Yolo接受的格式是函数,ipl_to_image和rgbgr_image就在旁边,需要啥就复制出来
image mat_to_image(Mat m)
{
IplImage ipl = m;
image im = ipl_to_image(&ipl);
rgbgr_image(im);
return im;
}
关于detection结构体说明，有些我也没看懂，但是这些够用
typedef struct
{
float x, y, w, h;
} box;
typedef struct detection
{
boxbbox;
int classes;
float *prob;
float *mask;
float objectness;
int sort_class;
} detection;
最后送上例程一份
#include<iostream>
#include<opencv2/opencv.hpp>
#include <opencv2/imgproc/imgproc_c.h>
#include<darknet.hpp>
using namespace std;
using namespace cv;
#define datacfg "/home/yao/Documents/yoloV3/darknet/VOCdevkit/VOC2007/voc.data"
#define cfgfile "/home/yao/Documents/yoloV3/darknet/VOCdevkit/VOC2007/yolov3-voc.cfg"
#define weightfile "/home/yao/Documents/yoloV3/darknet/VOCdevkit/VOC2007/weigits/640_480_3K_5.23.weights"
#define videosrc "/home/yao/Videos/0.mp4"
#define SavePAYH "/home/yao/Videos/640_480_3K_5.23.avi"
#define PicturePATH "/home/yao/Downloads/qq-files/1790931015/file_recv/BL}A~RL7L3Y0({BI0[}JGRT.png"
#define SaveVideo 1
#define USE_Picture 0
void drawBox(Mat& Src, const Scalar& color, box Box, const char* name, float prob);
Scalar get_Scalar(int index, int classes);
image cvmat_to_image(cv::Mat m);
int main()
{
list *options = read_data_cfg(datacfg);
char *name_list = option_find_str(options, "names", NULL);
char **names = get_labels(name_list);
int classes = option_find_int(options, "classes", 2);
network *net = load_network(cfgfile, weightfile, 0);
set_batch_network(net, 1);
#if (USE_Picture == 0)
VideoCapture CAP(videosrc);
#endif
#if(SaveVideo == 1)
VideoWriter Writer(SavePAYH, VideoWriter::fourcc('M', 'J', 'P', 'G'), 30, Size(1920, 1080));
if(!Writer.isOpened())
{
cout << "Writer Error" << endl;
exit(-1);
}
#endif
Mat Src, Dst;
int nboxes = 0;
namedWindow("Video", WINDOW_NORMAL);
resizeWindow("Video", 1280, 720);
#if (USE_Picture == 0)
double time1 = 0;
double time2 = 0;
char buff[100] = { 0 };
if(CAP.isOpened())
{
while(CAP.read(Src))
{
time1 = (double)getCPUTickCount();
#else
Src = imread(PicturePATH);
#endif
resize(Src, Dst, Size(net->w,net->h));
image im = cvmat_to_image(Dst);
network_predict(net, im.data);
detection *dets = get_network_boxes(net, im.w, im.h, 0.5, 0.5, 0, 1, &nboxes);
cout << nboxes << endl;
for(int i = 0; i < nboxes; ++i)
{
float probmax = dets[i].prob[0];
int index = 0;
for(int j = 0; j < dets->classes; ++j)
{
if(probmax < dets[i].prob[j])
{
probmax = dets[i].prob[j];
index = j;
}
}
if(probmax < 0.5)
{
cout << "throw" << endl;
continue;
}
drawBox(Src, get_Scalar(index, classes), dets[i].bbox, names[index], probmax);
}
#if (USE_Picture == 0)
#if(SaveVideo == 1)
time2 = (double)getCPUTickCount();
double usetime = (time2 - time1) / getTickFrequency();
sprintf(buff, "Time = %4.3lfms FPS = %2.2lf BoxConut = %d", usetime * 1000.0, 1.0 / usetime, nboxes);
cout << buff << endl;
putText(Src, buff, Point(25, 100), FONT_ITALIC, 1, Scalar(0, 255, 0), 2);
putText(Src, weightfile, Point(25, 50), FONT_ITALIC, 1, Scalar(0, 255, 0), 2);
imshow("Video", Src);
Writer.write(Src);
#endif
waitKey(1);
#else
imshow("Video", Src);
waitKey(100000);
#endif
free_image(im);
free_detections(dets, nboxes);
#if (USE_Picture == 0)
}
}
else
{
cout << "CAP Error" << endl;
}
#endif
free_network(net);
free_ptrs((void**)names, classes);
free_list(options);
cout << "Done!" << endl;
}
void drawBox(Mat& Src, const Scalar& color, box Box, const char* name, float prob)
{
int left = (Box.x-Box.w/2.)*Src.cols;
int right = (Box.x+Box.w/2.)*Src.cols;
int top = (Box.y-Box.h/2.)*Src.rows;
int bot = (Box.y+Box.h/2.)*Src.rows;
if(left < 0) left = 0;
if(right > Src.cols-1) right = Src.cols-1;
if(top < 0) top = 0;
if(bot > Src.rows-1) bot = Src.rows-1;
Point p1(left, top);
Point p2(right, bot);
putText(Src, name + to_string(prob * 100) + "%", p1 - Point(0, 3), FONT_HERSHEY_PLAIN, 1, color);
rectangle(Src, p1, p2, color, 2);
}
float get_color(int c, int x, int max)
{
float colors[6][3] = { {1,0,1}, {0,0,1},{0,1,1},{0,1,0},{1,1,0},{1,0,0} };
float ratio = ((float)x / max) * 5;
int i = floor(ratio);
int j = ceil(ratio);
ratio -= i;
float r = (1-ratio) * colors[i][c] + ratio*colors[j][c];
return r;
}
Scalar get_Scalar(int index, int classes)
{
int offset = index * 123457 % classes;
int red = get_color(0, offset, classes) * 255;
int green = get_color(1, offset, classes) * 255;
int blue = get_color(2, offset, classes) * 255;
return Scalar(blue, green, red);
}
image cvipl_to_image(IplImage *src)
{
int h = src->height;
int w = src->width;
int c = src->nChannels;
image im = make_image(w, h, c);
unsigned char *data = (unsigned char *)src->imageData;
int step = src->widthStep;
int i, j, k;
for (i = 0; i < h; ++i)
{
for (k = 0; k < c; ++k)
{
for (j = 0; j < w; ++j)
{
im.data[k * w * h + i * w + j] = data[i * step + j * c + k] / 255.;
}
}
}
return im;
}
image cvmat_to_image(cv::Mat m)
{
IplImage ipl = m;
image im = cvipl_to_image(&ipl);
rgbgr_image(im);
return im;
}
都到这份上了别再想着白嫖我了
本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)
