利用Hog特征和SVM分类器进行行人检测

最新推荐文章于 2023-05-01 15:41:12 发布
最新推荐文章于 2023-05-01 15:41:12 发布
阅读量3.3k 收藏 5
点赞数
文章标签： training float vector null string path

利用Hog特征和SVM分类器进行行人检测

分类： CV相关 2012-08-08 00:11 442人阅读 评论(9) 收藏 举报

之前介绍过Hog特征(http://blog.csdn.net/carson2005/article/details/7782726)，也介绍过SVM分类器（http://blog.csdn.net/carson2005/article/details/6453502 ）；而本文的目的在于介绍利用Hog特征和SVM分类器来进行行人检测。

在2005年CVPR上，来自法国的研究人员Navneet Dalal 和Bill Triggs提出利用Hog进行特征提取，利用线性SVM作为分类器，从而实现行人检测。而这两位也通过大量的测试发现，Hog+SVM是速度和效果综合平衡性能较好的一种行人检测方法。后来，虽然很多研究人员也提出了很多改进的行人检测算法，但基本都以该算法为基础框架。因此，Hog+SVM也成为一个里程表式的算法被写入到OpenCV中。在OpenCV2.0之后的版本，都有Hog特征描述算子的API，而至于SVM，早在OpenCV1.0版本就已经集成进去了；OpenCV虽然提供了Hog和SVM的API，也提供了行人检测的sample，遗憾的是，OpenCV并没有提供样本训练的sample。这也就意味着，很多人只能用OpenCV自带的已经训练好的分类器来进行行人检测。然而，OpenCV自带的分类器是利用Navneet Dalal和Bill Triggs提供的样本进行训练的，不见得能适用于你的应用场合。因此，针对你的特定应用场景，很有必要进行重新训练得到适合你的分类器。本文的目的，正在于此。

重新训练行人检测的流程：

（1）准备训练样本集合；包括正样本集和负样本集；根据机器学习的基础知识我们知道，要利用机器学习算法进行样本训练，从而得到一个性能优良的分类器，训练样本应该是无限多的，而且训练样本应该覆盖实际应用过程中可能发生的各种情况。（很多朋友，用10来个正样本，10来个负样本进行训练，之后，就进行测试，发现效果没有想象中的那么好，就开始发牢骚，抱怨。。。对于这些人，我只能抱歉的说，对于机器学习、模式识别的认识，你还处于没有入门的阶段）；实际应用过程中，训练样本不可能无限多，但无论如何，三五千个正样本，三五千个负样本，应该不是什么难事吧？（如果连这个都做不到，建议你别搞机器学习，模式识别了；训练素材都没有，怎么让机器学习到足够的信息呢？）

（2）收集到足够的训练样本之后，你需要手动裁剪样本。例如，你想用Hog+SVM来对商业步行街的监控画面中进行行人检测，那么，你就应该用收集到的训练样本集合，手动裁剪画面中的行人（可以写个简单程序，只需要鼠标框选一下，就将框选区域保存下来）。

（3）裁剪得到训练样本之后，将所有正样本放在一个文件夹中；将所有负样本放在另一个文件夹中；并将所有训练样本缩放到同样的尺寸大小。OpenCV自带的例子在训练时，就是将样本缩放为64*128进行训练的；

（4）提取所有正样本的Hog特征；

（5）提取所有负样本的Hog特征；

（6）对所有正负样本赋予样本标签；例如，所有正样本标记为1，所有负样本标记为0；

（7）将正负样本的Hog特征，正负样本的标签，都输入到SVM中进行训练；Dalal在论文中考虑到速度问题，建议采用线性SVM进行训练。这里，不妨也采用线性SVM；

（8）SVM训练之后，将结果保存为文本文件。

（9）线性SVM进行训练之后得到的文本文件里面，有一个数组，叫做support vector，还有一个数组，叫做alpha,有一个浮点数，叫做rho;将alpha矩阵同support vector相乘，注意，alpha*supportVector,将得到一个列向量。之后，再该列向量的最后添加一个元素rho。如此，变得到了一个分类器，利用该分类器，直接替换opencv中行人检测默认的那个分类器（cv::HOGDescriptor::setSVMDetector()），就可以利用你的训练样本训练出来的分类器进行行人检测了。

下面给出样本训练的参考代码：

[cpp] view plain copy print ?
  1. class Mysvm: public CvSVM
  2. {
  3. public:
  4. int get_alpha_count()
  5. {
  6. return this->sv_total;
  7. }
  9. int get_sv_dim()
  10. {
  11. return this->var_all;
  12. }
  14. int get_sv_count()
  15. {
  16. return this->decision_func->sv_count;
  17. }
  19. double* get_alpha()
  20. {
  21. return this->decision_func->alpha;
  22. }
  24. float** get_sv()
  25. {
  26. return this->sv;
  27. }
  29. float get_rho()
  30. {
  31. return this->decision_func->rho;
  32. }
  33. };
  35. void Train()
  36. {
  37. char classifierSavePath[256] = "c:/pedestrianDetect-peopleFlow.txt";
  39. string positivePath = "E:\\pictures\\train1\\pos\\";
  40. string negativePath = "E:\\pictures\\train1\\neg\\";
  42. int positiveSampleCount = 4900;
  43. int negativeSampleCount = 6192;
  44. int totalSampleCount = positiveSampleCount + negativeSampleCount;
  46. cout<<"//"<<endl;
  47. cout<<"totalSampleCount: "<<totalSampleCount<<endl;
  48. cout<<"positiveSampleCount: "<<positiveSampleCount<<endl;
  49. cout<<"negativeSampleCount: "<<negativeSampleCount<<endl;
  51. CvMat *sampleFeaturesMat = cvCreateMat(totalSampleCount , 1764, CV_32FC1);
  52. //64*128的训练样本，该矩阵将是totalSample*3780,64*64的训练样本，该矩阵将是totalSample*1764
  53. cvSetZero(sampleFeaturesMat);
  54. CvMat *sampleLabelMat = cvCreateMat(totalSampleCount, 1, CV_32FC1);//样本标识
  55. cvSetZero(sampleLabelMat);
  57. cout<<"************************************************************"<<endl;
  58. cout<<"start to training positive samples..."<<endl;
  60. char positiveImgName[256];
  61. string path;
  62. for(int i=0; i<positiveSampleCount; i++)
  63. {
  64. memset(positiveImgName, '\0', 256*sizeof(char));
  65. sprintf(positiveImgName, "%d.jpg", i);
  66. int len = strlen(positiveImgName);
  67. string tempStr = positiveImgName;
  68. path = positivePath + tempStr;
  70. cv::Mat img = cv::imread(path);
  71. if( img.data == NULL )
  72. {
  73. cout<<"positive image sample load error: "<<i<<" "<<path<<endl;
  74. system("pause");
  75. continue;
  76. }
  78. cv::HOGDescriptor hog(cv::Size(64,64), cv::Size(16,16), cv::Size(8,8), cv::Size(8,8), 9);
  79. vector<float> featureVec;
  81. hog.compute(img, featureVec, cv::Size(8,8));
  82. int featureVecSize = featureVec.size();
  84. for (int j=0; j<featureVecSize; j++)
  85. {
  86. CV_MAT_ELEM( *sampleFeaturesMat, float, i, j ) = featureVec[j];
  87. }
  88. sampleLabelMat->data.fl[i] = 1;
  89. }
  90. cout<<"end of training for positive samples..."<<endl;
  92. cout<<"*********************************************************"<<endl;
  93. cout<<"start to train negative samples..."<<endl;
  95. char negativeImgName[256];
  96. for (int i=0; i<negativeSampleCount; i++)
  97. {
  98. memset(negativeImgName, '\0', 256*sizeof(char));
  99. sprintf(negativeImgName, "%d.jpg", i);
  100. path = negativePath + negativeImgName;
  101. cv::Mat img = cv::imread(path);
  102. if(img.data == NULL)
  103. {
  104. cout<<"negative image sample load error: "<<path<<endl;
  105. continue;
  106. }
  108. cv::HOGDescriptor hog(cv::Size(64,64), cv::Size(16,16), cv::Size(8,8), cv::Size(8,8), 9);
  109. vector<float> featureVec;
  111. hog.compute(img,featureVec,cv::Size(8,8));//计算HOG特征
  112. int featureVecSize = featureVec.size();
  114. for ( int j=0; j<featureVecSize; j ++)
  115. {
  116. CV_MAT_ELEM( *sampleFeaturesMat, float, i + positiveSampleCount, j ) = featureVec[ j ];
  117. }
  119. sampleLabelMat->data.fl[ i + positiveSampleCount ] = -1;
  120. }
  122. cout<<"end of training for negative samples..."<<endl;
  123. cout<<"********************************************************"<<endl;
  124. cout<<"start to train for SVM classifier..."<<endl;
  126. CvSVMParams params;
  127. params.svm_type = CvSVM::C_SVC;
  128. params.kernel_type = CvSVM::LINEAR;
  129. params.term_crit = cvTermCriteria(CV_TERMCRIT_ITER, 1000, FLT_EPSILON);
  130. params.C = 0.01;
  132. Mysvm svm;
  133. svm.train( sampleFeaturesMat, sampleLabelMat, NULL, NULL, params ); //用SVM线性分类器训练
  134. svm.save(classifierSavePath);
  136. cvReleaseMat(&sampleFeaturesMat);
  137. cvReleaseMat(&sampleLabelMat);
  139. int supportVectorSize = svm.get_support_vector_count();
  140. cout<<"support vector size of SVM："<<supportVectorSize<<endl;
  141. cout<<"************************ end of training for SVM ******************"<<endl;
  143. CvMat *sv,*alp,*re;//所有样本特征向量
  144. sv = cvCreateMat(supportVectorSize , 1764, CV_32FC1);
  145. alp = cvCreateMat(1 , supportVectorSize, CV_32FC1);
  146. re = cvCreateMat(1 , 1764, CV_32FC1);
  147. CvMat *res = cvCreateMat(1 , 1, CV_32FC1);
  149. cvSetZero(sv);
  150. cvSetZero(re);
  152. for(int i=0; i<supportVectorSize; i++)
  153. {
  154. memcpy( (float*)(sv->data.fl+i*1764), svm.get_support_vector(i), 1764*sizeof(float));
  155. }
  157. double* alphaArr = svm.get_alpha();
  158. int alphaCount = svm.get_alpha_count();
  160. for(int i=0; i<supportVectorSize; i++)
  161. {
  162. alp->data.fl[i] = alphaArr[i];
  163. }
  164. cvMatMul(alp, sv, re);
  166. int posCount = 0;
  167. for (int i=0; i<1764; i++)
  168. {
  169. re->data.fl[i] *= -1;
  170. }
  172. FILE* fp = fopen("c:/hogSVMDetector-peopleFlow.txt","wb");
  173. if( NULL == fp )
  174. {
  175. return 1;
  176. }
  177. for(int i=0; i<1764; i++)
  178. {
  179. fprintf(fp,"%f \n",re->data.fl[i]);
  180. }
  181. float rho = svm.get_rho();
  182. fprintf(fp, "%f", rho);
  183. cout<<"c:/hogSVMDetector.txt 保存完毕"<<endl;//保存HOG能识别的分类器
  184. fclose(fp);
  186. return 1;
  187. } 
class Mysvm: public CvSVM
{
public:
	int get_alpha_count()
	{
		return this->sv_total;
	}

	int get_sv_dim()
	{
		return this->var_all;
	}

	int get_sv_count()
	{
		return this->decision_func->sv_count;
	}

	double* get_alpha()
	{
		return this->decision_func->alpha;
	}

	float** get_sv()
	{
		return this->sv;
	}

	float get_rho()
	{
		return this->decision_func->rho;
	}
};

void Train()
{
	char classifierSavePath[256] = "c:/pedestrianDetect-peopleFlow.txt";

	string positivePath = "E:\\pictures\\train1\\pos\\";
	string negativePath = "E:\\pictures\\train1\\neg\\";

	int positiveSampleCount = 4900;
	int negativeSampleCount = 6192;
	int totalSampleCount = positiveSampleCount + negativeSampleCount;

	cout<<"//"<<endl;
	cout<<"totalSampleCount: "<<totalSampleCount<<endl;
	cout<<"positiveSampleCount: "<<positiveSampleCount<<endl;
	cout<<"negativeSampleCount: "<<negativeSampleCount<<endl;

	CvMat *sampleFeaturesMat = cvCreateMat(totalSampleCount , 1764, CV_32FC1);
	//64*128的训练样本，该矩阵将是totalSample*3780,64*64的训练样本，该矩阵将是totalSample*1764
	cvSetZero(sampleFeaturesMat);  
	CvMat *sampleLabelMat = cvCreateMat(totalSampleCount, 1, CV_32FC1);//样本标识  
	cvSetZero(sampleLabelMat);  

	cout<<"************************************************************"<<endl;
	cout<<"start to training positive samples..."<<endl;

	char positiveImgName[256];
	string path;
	for(int i=0; i<positiveSampleCount; i++)  
	{  
		memset(positiveImgName, '\0', 256*sizeof(char));
		sprintf(positiveImgName, "%d.jpg", i);
		int len = strlen(positiveImgName);
		string tempStr = positiveImgName;
		path = positivePath + tempStr;

		cv::Mat img = cv::imread(path);
		if( img.data == NULL )
		{
			cout<<"positive image sample load error: "<<i<<" "<<path<<endl;
			system("pause");
			continue;
		}

		cv::HOGDescriptor hog(cv::Size(64,64), cv::Size(16,16), cv::Size(8,8), cv::Size(8,8), 9);
		vector<float> featureVec; 

		hog.compute(img, featureVec, cv::Size(8,8));  
		int featureVecSize = featureVec.size();

		for (int j=0; j<featureVecSize; j++)  
		{  		
			CV_MAT_ELEM( *sampleFeaturesMat, float, i, j ) = featureVec[j]; 
		}  
		sampleLabelMat->data.fl[i] = 1;
	}
	cout<<"end of training for positive samples..."<<endl;

	cout<<"*********************************************************"<<endl;
	cout<<"start to train negative samples..."<<endl;

	char negativeImgName[256];
	for (int i=0; i<negativeSampleCount; i++)
	{  
		memset(negativeImgName, '\0', 256*sizeof(char));
		sprintf(negativeImgName, "%d.jpg", i);
		path = negativePath + negativeImgName;
		cv::Mat img = cv::imread(path);
		if(img.data == NULL)
		{
			cout<<"negative image sample load error: "<<path<<endl;
			continue;
		}

		cv::HOGDescriptor hog(cv::Size(64,64), cv::Size(16,16), cv::Size(8,8), cv::Size(8,8), 9);  
		vector<float> featureVec; 

		hog.compute(img,featureVec,cv::Size(8,8));//计算HOG特征
		int featureVecSize = featureVec.size();  

		for ( int j=0; j<featureVecSize; j ++)  
		{  
			CV_MAT_ELEM( *sampleFeaturesMat, float, i + positiveSampleCount, j ) = featureVec[ j ];
		}  

		sampleLabelMat->data.fl[ i + positiveSampleCount ] = -1;
	}  

	cout<<"end of training for negative samples..."<<endl;
	cout<<"********************************************************"<<endl;
	cout<<"start to train for SVM classifier..."<<endl;

	CvSVMParams params;  
	params.svm_type = CvSVM::C_SVC;  
	params.kernel_type = CvSVM::LINEAR;  
	params.term_crit = cvTermCriteria(CV_TERMCRIT_ITER, 1000, FLT_EPSILON);
	params.C = 0.01;

	Mysvm svm;
	svm.train( sampleFeaturesMat, sampleLabelMat, NULL, NULL, params ); //用SVM线性分类器训练
	svm.save(classifierSavePath);

	cvReleaseMat(&sampleFeaturesMat);
	cvReleaseMat(&sampleLabelMat);

	int supportVectorSize = svm.get_support_vector_count();
	cout<<"support vector size of SVM："<<supportVectorSize<<endl;
	cout<<"************************ end of training for SVM ******************"<<endl;

	CvMat *sv,*alp,*re;//所有样本特征向量 
	sv  = cvCreateMat(supportVectorSize , 1764, CV_32FC1);
	alp = cvCreateMat(1 , supportVectorSize, CV_32FC1);
	re  = cvCreateMat(1 , 1764, CV_32FC1);
	CvMat *res  = cvCreateMat(1 , 1, CV_32FC1);

	cvSetZero(sv);
	cvSetZero(re);
  
	for(int i=0; i<supportVectorSize; i++)
	{
		memcpy( (float*)(sv->data.fl+i*1764), svm.get_support_vector(i), 1764*sizeof(float));	
	}

	double* alphaArr = svm.get_alpha();
	int alphaCount = svm.get_alpha_count();

	for(int i=0; i<supportVectorSize; i++)
	{
        alp->data.fl[i] = alphaArr[i];
	}
	cvMatMul(alp, sv, re);

	int posCount = 0;
	for (int i=0; i<1764; i++)
	{
		re->data.fl[i] *= -1;
	}

	FILE* fp = fopen("c:/hogSVMDetector-peopleFlow.txt","wb");
	if( NULL == fp )
	{
		return 1;
	}
	for(int i=0; i<1764; i++)
	{
		fprintf(fp,"%f \n",re->data.fl[i]);
	}
	float rho = svm.get_rho();
	fprintf(fp, "%f", rho);
	cout<<"c:/hogSVMDetector.txt 保存完毕"<<endl;//保存HOG能识别的分类器
	fclose(fp);

	return 1;
}
接着，再给出利用训练好的分类器进行行人检测的参考代码：

[cpp] view plain copy print ?
  1. void Detect()
  2. {
  3. CvCapture* cap = cvCreateFileCapture("E:\\02.avi");
  4. if (!cap)
  5. {
  6. cout<<"avi file load error..."<<endl;
  7. system("pause");
  8. exit(-1);
  9. }
  11. vector<float> x;
  12. ifstream fileIn("c:/hogSVMDetector-peopleFlow.txt", ios::in);
  13. float val = 0.0f;
  14. while(!fileIn.eof())
  15. {
  16. fileIn>>val;
  17. x.push_back(val);
  18. }
  19. fileIn.close();
  21. vector<cv::Rect> found;
  22. cv::HOGDescriptor hog(cv::Size(64,64), cv::Size(16,16), cv::Size(8,8), cv::Size(8,8), 9);
  23. hog.setSVMDetector(x);
  25. IplImage* img = NULL;
  26. cvNamedWindow("img", 0);
  27. while(img=cvQueryFrame(cap))
  28. {
  29. hog.detectMultiScale(img, found, 0, cv::Size(8,8), cv::Size(32,32), 1.05, 2);
  30. if (found.size() > 0)
  31. {
  33. for (int i=0; i<found.size(); i++)
  34. {
  35. CvRect tempRect = cvRect(found[i].x, found[i].y, found[i].width, found[i].height);
  37. cvRectangle(img, cvPoint(tempRect.x,tempRect.y),
  38. cvPoint(tempRect.x+tempRect.width,tempRect.y+tempRect.height),CV_RGB(255,0,0), 2);
  39. }
  40. }
  41. }
  42. cvReleaseCapture(&cap);
  43. }
sunanger_wang
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
hog+svm行人检测分类器训练
03-31
4. 训练SVM：使用提取的HOG特征和对应的标签训练SVM分类器，可以选择不同的核函数（如线性、多项式或RBF），调整参数以优化性能。 5. 交叉验证：通过划分训练集和验证集，评估模型的性能，防止过拟合。 6. 测试模型...
hog+svm行人检测算法实例源码下载
03-27
这个利用行人HOG特征通过SVM分类器进行分类的代码。程序运行环境为VS2013+OpenCV2.20。程序内可以选择Opencv自带的行人检测算法，也可以自己训练HOG特征进行检测。如果自己训练的话，需要在D盘建立一个文件（具体文件名程序中有）里面存在训练的正负样本，和测试样本。具体D盘的这个文件夹在本人自愿中已上传，需要请自行下载。
【机器学习】HOG+SVM实现行人检测
qaqwqaqwq的博客
05-01 5039
HOG的全称是方向梯度直方图（Histogram of Oriented Gradient），它是计算机视觉中用于物体检测的一种特征描述子（Feature Descriptor）。特征描述子的作用是提取有用的信息，抛弃冗余的信息。对于一个物体而言，能够区分它的特征的往往是它的形状——也就是它的边界。而在边界处灰度一般有突变，所以我们考察图像的梯度就可以知道边界在什么地方。现在我们把一个图片利用HOG特征转化成了一个向量，接下来就可以利用SVM分类了。
目标检测（五）基于SVM的目标分类
qq_40959462的博客
06-12 3210
支持向量机（support vector machines, SVM）是一种二分类模型，它的基本模型是定义在特征空间上的间隔最大的线性分类器，间隔最大使它有别于感知机；SVM 还包括核技巧，这使它成为实质上的非线性分类器。SVM 的的学习策略就是间隔最大化，可形式化为一个求解凸二次规划的问题，也等价于正则化的合页损失函数的最小化问题。SVM 的的学习算法就是求解凸二次规划的最优化算法。...
opencv-python学习笔记（十一）：HOG+SVM进行行人检测全过程
submarineas的博客
05-10 6138
引言 本次是接着python-opencv学习笔记（七）：滑动窗口与图像金字塔 一起在实验楼所做实验，为啥中间隔了四篇才接着发出来，主因是我发文比较随意（懒），当时这部分并没有总结完，至少我感觉我看的相关资料还不够多，整体理解不深，另外就是项目需求，在做很多其它的东西，图像能见度就是当时一个指标，搞了几天，最后看起来效果一般，目前没有上线只是自己测试反馈不多，所以就接着做其它适配任务去了，现在这篇是算结束吧，赶紧总结完，复习去了。 实验流程 使用图像金字塔将图片按一定缩放比例生成不同尺寸图片（下图序号 1
使用MATLAB语言_利用HOG特征和svm分类器来实现行人的检测_matlab
04-01
资源名：使用MATLAB语言_利用HOG特征和svm分类器来实现行人的检测_matlab 资源类型：matlab项目全套源码 源码说明： 全部项目源码都是经过测试校正后百分百成功运行的，如果您下载后不能运行可联系我进行指导或者...
本解决方案完成了使用HOG特征和SVM分类器.zip
12-28
本解决方案完成了使用HOG特征和SVM分类器 本解决方案完成了使用HOG特征和SVM分类器 本解决方案完成了使用HOG特征和SVM分类器 本解决方案完成了使用HOG特征和SVM分类器 本解决方案完成了使用HOG特征和SVM分类器 本...
基于matlab实现的利用HOG特征和svm分类器来实现行人的检测.rar
最新发布
05-06
总结，这个项目展示了如何使用MATLAB结合HOG特征和SVM分类器来实现行人检测。通过对图像的预处理、特征提取、模型训练和预测，能够有效地识别和定位图像中的行人。这种技术在智能交通、监控系统等领域有着广泛的应用...
OPENCV HOG特征+SVM分类器行人识别（从训练到识别）
07-11
OpenCV中的HOG特征（Histogram of Oriented Gradients，方向梯度直方图）与SVM...通过阅读和理解这些代码，初学者可以深入掌握HOG特征提取和SVM分类器在行人检测中的应用，从而为进一步的计算机视觉项目打下基础。
训练SVM分类器进行HOG行人检测
04-18
训练SVM分类器进行HOG行人检测. 环境为VS2010 + OpenCV2.4.4. 使用时请自行修改工程的include目录和lib目录配置。 正样本来源是INRIA数据集中的96*160大小的人体图片，使用时上下左右都去掉16个像素，截取中间的64*...
Hog特征结合SVM分类器
03-12
总结起来，这个项目涉及到了计算机视觉、机器学习以及软件开发等多个方面的知识，旨在利用HOG特征和SVM分类器实现高效的行人检测。通过阅读和理解提供的代码，可以深入学习这些技术的实践应用。
基于C++的通过HOG+SVM训练进行行人检测算法代码实现
04-19
2. SVM分类器： SVM是一种监督学习模型，用于二分类问题。在行人检测中，SVM通过学习HOG特征来区分行人与非行人。其核心思想是找到一个最优超平面，最大化两类样本的距离。主要步骤： - **训练集准备**：收集包含...
Opencv3.0 手写数字识别（Hog特征+SVM分类器）
06-01
5. **预测**：对于测试集中的每个手写数字，提取HOG特征并用训练好的SVM分类器进行分类。 6. **评估**：通过计算准确率、召回率等指标评估模型性能。 在提供的压缩包文件中，"新建文件夹"可能包含了训练和测试图片...
自己训练SVM分类器进行HOG行人检测
11-13
自己训练SVM分类器进行HOG行人检测. 环境为VS2010 + OpenCV2.4.4. 使用时请自行修改工程的include目录和lib目录配置。 正样本来源是INRIA数据集中的96*160大小的人体图片，使用时上下左右都去掉16个像素，截取中间的...
特征提取学习之HOG原理讲解
weixin_30871701的博客
05-07 968
本篇文章来自于http://blog.csdn.net/liulina603/article/details/8291093 1、HOG特征： 方向梯度直方图（Histogram of Oriented Gradient, HOG）特征是一种在计算机视觉和图像处理中用来进行物体检测的特征描述子。它通过计算和统计图像局部区域的梯度方向直方图来构成特征。Hog特征结合SVM分类器已...
HOGDescriptor::SetSVMDetector()
lcmssd
04-09 2868
HOGDescriptor::SetSVMDetector()有些限制 1. linear kernel only 2. imgsize == winsize
OpenCV中基于HOG+SVM行人检测
a87105222的博客
10-11 2782
使用HOGDescriptor类 HOGDescriptor hog; hog.setSVMDetector(HOGDescriptor::getDefaultPeopleDetector());  另有HOGDescriptor::getDaimlerPeopleDetector()，此时hog.winSize = Size(48, 96); The reason is that
人脸表情识别——Hog特征+基本分类算法（svm,knn,朴素贝叶斯，随机森林等）python实现
热门推荐
qq_41703793的博客
06-14 1万+
机器学习分类算法层出不穷，作为初学者有几类算法都是必须掌握，熟练使用的，本文就介绍了Hog特征的提取，SVM、KNN、随机森林等的实践使用，读者若要实现相关功能，只需修改添加即可
HOG特征与SVM分类器详解
HOG能够有效地捕捉物体边缘和形状信息，而SVM则擅长在大量特征中找到最佳分类器。这种组合在计算机视觉中被广泛应用，尤其是在行人检测和其他特定物体识别任务中。通过调整HOG参数（如细胞大小、块大小、方向bin数等...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值