目标检测之二(传统算法和深度学习的源码学习)

版权声明:本文为博主原创文章,遵循 CC 4.0 by-sa 版权协议,转载请附上原文出处链接和本声明。
本文链接:https://blog.csdn.net/baolinq/article/details/78582309

目标检测之二(传统算法和深度学习的源码学习)

本系列写一写关于目标检测的东西,包括传统算法和深度学习的方法都会涉及到,注重实验而不着重理论,理论相关的看论文去哈,主要依赖opencv。

  本文主要内容:简单分析下yolo9000的原理,然后使用opencv的dnn模块进行目标检测.

    接着上一篇提到的车辆检测(http://blog.csdn.net/baolinq/article/details/78579317),使用了Haar+Adaboost算法进行车辆检测,对于简单场景的检测效果还不错,但是对于稍微复杂点的场景或者由于光照等原因的影响,检测效果不尽人意,但是我们看到深度学习的检测方法,比如YOLO的检测效果仍然很好。

    YOLO9000秉承着“奥运理念”, Better, Faster, Stronger,翻译出来的意思就是检测精度更高,检测速度更快,性能更强(更鲁棒),主要原理和YOLO v1一样,YOLO9000增加了更多的深度学习的训练tricks和借鉴了其他算法的优点,


上图是YOLOv1论文(https://arxiv.org/abs/1506.02640)里面的截图,我们简单看一下它的原理:

(1) 给个一个输入图像,首先将图像划分成7 * 7的网格。

(2) 对于每个网格,每个网格预测2个boudingbox(每个box包含5个预测量)以及20个类别概率,总共输出7×7×(2*5+20)=1470个tensor

(3) 根据上一步可以预测出7 * 7 * 2 = 98个目标窗口,然后根据阈值去除可能性比较低的目标窗口,再由NMS去除冗余窗口即可。

YOLOv1使用了end-to-end的回归方法,没有regionproposal步骤,直接回归便完成了位置和类别的判定。种种原因使得YOLOv1在目标定位上不那么精准,直接导致YOLO的检测精度并不是很高。

YOLO9000用了这么多tricks,每一种提高一点点,组合起来就很强大了


    YOLO9000略有不同YOLOv2最后输出的是S * S * (B * (5 + C))维,它直接使用每个boxes进行预测,而yolov1不是这样的,它是每个cell只负责一个object。其中参数S,B,C的取值也不同:

S=13,YOLOv2对输入图像(416*416,yolov1是448*448)进行了卷积和池化等,最终输出的特征图尺寸是13 * 13。

B=5,这是由Dimension Clusters得到的。Fast-RCNN中使用3种scales和3中aspectratios(1:1,1:2,2:1)在每个位置产生了9个anchor boxes。作者认为这种手动选取的anchor不够好,虽然网络最终可以学出来,但如果我们可以给出更好的anchor,那么网络肯定更加容易训练而且效果更好。作者使用kmeans算法进行训练,使用基于IOU的度量方式d(box,centroid)=1−IOU(box,centroid)代替一般场景下的欧氏距离。作者的实验表明这种做法比手动选取的效果更好

C=20,表示object的种类,如果是用voc数据集的话,C=20。如果是coco数据集,C=80。

 

详细的原理自己去网上搜一下有一大堆,不过还是建议看下原文(https://arxiv.org/abs/1612.08242),项目主页(https://pjreddie.com/darknet/yolo/)上面有关于YOLO的详细介绍以及很多训练好的model可以使用以及yolo的源代码,作者可以说是非常良心了,点个赞。

    直接先去github上面下载YOLO的源代码(https://github.com/pjreddie/darknet),代码写的非常nice,使用darknet网络结构,几乎不用环境就可以独立运行的,当然如果你要显示窗口的话,最好还是要有一个opencv,他也会自动把运行结果保存到当前目录,不过看起来不方便。根据自己的环境编译一下,使用命令行cmd窗口就可以运行了。输入图片路径即可进行检测。

运行截图:


电脑显卡很渣,暂时使用的是no gpu版本的。

运行结果:

 

按任意键关闭窗口,即可继续输入图片路径继续进行目标检测

 

这样测试很不方便,每次只能测试一张图像,我想测试序列图像或者测试视频该怎么办呢?有两种方法,一种修改源代码,改写输入文件的类型;第二种更简单使用opencv的dnn模块(Depth neural network)。详情见opencv官方文档https://docs.opencv.org/master/d6/d0f/group__dnn.html

我以第二种方法为例,我使用的是opencv3.3。Dnn模块是opencv新推出的用于深度学习的一个模块,目前支持Caffe、TensorFlow、Torch、PyTorch、darknet等深度学习框架。我觉得这个功能真的很赞,以后训练好的模型,移植就非常方便了,用来做一些日常测试也是很不错的。


dnn::Net net=readNetFromDarknet()就可以从参数中读取darknet网络参数以及训练好的模型权重。

先把输入图像归一化一下,然后输入图像到网络中,再进行前向传播,就OK了,是不是非常的easy啊。剩下的只是怎么显示和保存数据的问题了,处理结果已经保存到detectionMat里面去了。

       //! [Prepare blob]
       Mat inputBlob = blobFromImage(resized, 1 / 255.F); //Convert Mat to batch of images
       //! [Prepare blob]
       //! [Set input blob]
       net.setInput(inputBlob, "data");               //set the network input
       //! [Set input blob]
 
       //! [Make forward pass]
       cv::Mat detectionMat = net.forward("detection_out");    //compute output
       //! [Make forward pass]

Talk is cheap,show me thecode。给出测试源码,其实也就是稍微改了一下opencv的samples。

 

#include <opencv2/dnn.hpp>
#include <opencv2/dnn/shape_utils.hpp>
#include <opencv2/imgproc.hpp>
#include <opencv2/imgcodecs.hpp>
#include <opencv2/highgui.hpp>
using namespace cv;
using namespace cv::dnn;

#include <fstream>
#include <iostream>
#include <algorithm>
#include <cstdlib>
using namespace std;

const size_t network_width = 416;
const size_t network_height = 416;

const char* about = "This sample uses You only look once (YOLO)-Detector "
"(https://arxiv.org/abs/1612.08242)"
"to detect objects on image\n"; // TODO: link

const char* params
= "{ help           | false | print usage         }"
"{ cfg            |    yolo-voc.cfg   | model configuration }"	//写入训练好的网络参数文件cfg格式
"{ model          |   yolo-voc.weights    | model weights       }"//写入训练好的模型的权重文件
"{ image          |       | image for detection }"				//测试的图片名,我没有使用
"{ min_confidence | 0.24  | min confidence      }";		//信心度阈值,低于该阈值的不输出,判断为没有检测到

vector<cv::Scalar> color = { Scalar(0,205,150),Scalar(255,0,0),Scalar(0,0,255),Scalar(200,150,0) };
int main(int argc, char** argv)
{
    cv::CommandLineParser parser(argc, argv, params);	//读入params参数文件
    
    if (parser.get<bool>("help"))
    {
        std::cout << about << std::endl;
        parser.printMessage();
        return 0;
    }
    
    //String modelConfiguration = "yolo.cfg"; // parser.get<string>("cfg");
    //String modelBinary = "yolo.weights"; //parser.get<string>("model");
	String modelConfiguration = parser.get<string>("cfg");
	String modelBinary =parser.get<string>("model");

    //! [Initialize network]
    dnn::Net net = readNetFromDarknet(modelConfiguration, modelBinary);//读取网络模型和参数,初始化
    //! [Initialize network]
    
    if (net.empty())
    {
        cerr << "Can't load network by using the following files: " << endl;
        cerr << "cfg-file:     " << modelConfiguration << endl;
        cerr << "weights-file: " << modelBinary << endl;
        cerr << "Models can be downloaded here:" << endl;
        cerr << "https://pjreddie.com/darknet/yolo/" << endl;
        exit(-1);
    }

	//  String imgpath =parser.get<string>("image")
    //cv::Mat frame = cv::imread(imgpath);

    // 检测目标种类的名称在voc.txt,读入保存到tag_names向量中
    vector<string> tag_names;
    ifstream fin;
    fin.open("voc.txt");
    string buf;
    while(fin && getline(fin, buf)) {
        tag_names.push_back(buf);
    }
	fin.close();

	//打开默认摄像头,用于检测摄像头的图像
	//VideoCapture cap(0);
	//if (!cap.isOpened())
	//	return -1;

	//图片的存放地址(相对路径),在当前目录的test_image文件夹里面
	String imgpath = "test_image/";
	vector<cv::String> imgvec;
	cv::glob(imgpath, imgvec);//保存文件名到imgvec向量中,便于批量处理
	Mat frame;
	bool stop = false;
	//while(!stop){

	int64 start = getTickCount();	//计算运行时间
	for (int imgnum = 0; (imgnum < imgvec.size())&&(!stop); ++imgnum) {
		
		//if (!cap.read(frame))
		//	break;
		frame = imread(imgvec[imgnum]);
		//imshow("原图",frame);
		//waitKey(5);
		//! [Resizing without keeping aspect ratio]
		cv::Mat resized;
		cv::resize(frame, resized, cv::Size(network_width, network_height));
		//! [Resizing without keeping aspect ratio]

		//! [Prepare blob]
		Mat inputBlob = blobFromImage(resized, 1 / 255.F); //Convert Mat to batch of images
		//! [Prepare blob]

		//! [Set input blob]输入归一化的图像
		net.setInput(inputBlob, "data");                //set the network input
		//! [Set input blob]

		//! [Make forward pass]前向传播进行计算
		cv::Mat detectionMat = net.forward("detection_out");    //compute output
		//! [Make forward pass]


		float confidenceThreshold = parser.get<float>("min_confidence");
		for (int i = 0; i < detectionMat.rows; i++)
		{
			const int probability_index = 5; //前5个参数为每一个bounding box包含5个值:x,y,w,h和confidence(置信度),置信值代表box包含一个目标的置信度
			const int probability_size = detectionMat.cols - probability_index;//后20个为voc数据集中有20个类别,每个类的概率
			float *prob_array_ptr = &detectionMat.at<float>(i, probability_index);

			size_t objectClass = std::max_element(prob_array_ptr, prob_array_ptr + probability_size) - prob_array_ptr;//选择一个概率最大的作为检测结果
			float confidence = detectionMat.at<float>(i, (int)objectClass + probability_index);

			if (confidence > confidenceThreshold)//大于信心度阈值才输出
			{
				float x = detectionMat.at<float>(i, 0);//检测的矩形框的计算,本来是中心点和长宽,这都是被归一化后的
				float y = detectionMat.at<float>(i, 1);
				float width = detectionMat.at<float>(i, 2);
				float height = detectionMat.at<float>(i, 3);
				float xLeftBottom = (x - width / 2) * frame.cols;//得到图像上的矩形框的左上角和右下角坐标,要反归一化
				float yLeftBottom = (y - height / 2) * frame.rows;
				float xRightTop = (x + width / 2) * frame.cols;
				float yRightTop = (y + height / 2) * frame.rows;

				//std::cout << "Class: " << tag_names[objectClass] << std::endl;
				//std::cout << "Confidence: " << confidence << std::endl;

				//std::cout << " " << xLeftBottom
				//	<< " " << yLeftBottom
				//	<< " " << xRightTop
				//	<< " " << yRightTop << std::endl;
				stringstream ss;
				ss << confidence;
				string str_text = tag_names[objectClass] + ": "+ss.str();//输出类别和信心度

				Rect object((int)xLeftBottom, (int)yLeftBottom,
					(int)(xRightTop - xLeftBottom),
					(int)(yRightTop - yLeftBottom));

				rectangle(frame, object, color[objectClass % 4],2);	//显示矩形框,我给了一个颜色数组,避免都是一个色的不好看
				int baseline = 0;
				Size labelSize = getTextSize(str_text, FONT_HERSHEY_SIMPLEX, 0.5,1, &baseline);//设置字体
				//int x = xLeftBottom - labelSize.width >= 0 ? xLeftBottom - labelSize.width : xLeftBottom + labelSize.width;
				int rect_y = yLeftBottom - labelSize.height >= 0 ? yLeftBottom - labelSize.height : yLeftBottom ;//避免在边界时,显示的内容看不到

				rectangle(frame, Rect(Point(xLeftBottom, rect_y),Size(labelSize.width,labelSize.height+baseline)), Scalar(0, 255, 0),CV_FILLED);
				//输出显示内容
				cv::putText(frame, str_text, Point(xLeftBottom, rect_y+labelSize.height), FONT_HERSHEY_SIMPLEX, 0.5, color[objectClass%4]);

			}
		}
		//cout << "用时: "<<1.0*(getTickCount() - start) / getTickFrequency() << endl;
		imshow("detections", frame);//显示图像
		//waitKey();
		if (waitKey(5) == 'q')
			stop = true;
	}
	//cout << "用时: " << 1.0*(getTickCount() - start) / getTickFrequency() << endl;//计算所有图片共运行的时间
    return 0;
} // main


代码上都有比较详细的注释,稍微看过论文或者看过其他人的写的论文笔记的,了解yolo的原理的都应该能看懂。我们简单分析一下网络的输出矩阵detectionMat,根据上面的分析。我们知道YOLO9000的输出是13*13*5*(5+20)维 的向量。


果然像我们分析的一样,调试时可以看到detectionMat是一个845*25维的矩阵,相当于一共845个boxes,每行表示一个boxes,每行有25列,分别表示矩形框的定位(4),该boxes的置信值(confidence score)。置信值代表box包含一个目标的置信度,以及20个类别的概率值。

知道了网络输出矩阵的意义,我们只需要分别取出来即可,每次只取类别概率最大的那一类,作为预测结果,然后跟confidenceThreshold作比较,超过阈值才认为是正确的预测,否则认为没有预测到。

 

最后就是预测框的计算了,因为作者模仿了faster-rcnn的做法,使用偏移量表示位置,而不是直接预测,实验表明这样做更容易训练,且可以提高mAP。作者就没有采用预测直接的offset的方法,而使用了预测相对于grid cell的坐标位置的办法,作者又把ground truth限制在了0到1之间,利用logistic回归函数来进行这一限制。所以最后计算出来的坐标需要去归一化,乘以图像的宽或者高。

 

最后部分的显示,我就不多说了,自己看看opencv的函数就可以了。

 

搞定收工。写的有点啰嗦,本来想和第一篇写在一起,结果写了这么多,如果你看到了这里,我只能说给你真有耐心,给你点个赞。下篇见~~

参考文献

[1] Redmon J, Farhadi A. YOLO9000: Better, Faster, Stronger[J]. 2016.

[2]http://blog.csdn.net/jesse_mx/article/details/53925356


展开阅读全文

没有更多推荐了,返回首页