精华内容
下载资源
问答
  • 自己训练SVM分类器进行HOG行人检测

    千次下载 热门讨论 2013-11-13 22:25:40
    自己训练SVM分类器进行HOG行人检测. 环境为VS2010 + OpenCV2.4.4. 使用时请自行修改工程的include目录和lib目录配置。 正样本来源是INRIA数据集中的96*160大小的人体图片,使用时上下左右都去掉16个像素,截取中间的...
  • 利用hog特征训练svm分类器的...2、投入svm分类器训练,得到model 3、由model生成检测子 4、利用检测子检测负样本,得到hardexample 5、提取hardexample的hog特征并结合第一步中的特征一起投入训练,得到最终检测子。
    利用hog特征训练svm分类器的总体思路:

    1、提取正负样本hog特征

    2、投入svm分类器训练,得到model
    3、由model生成检测子

    4、利用检测子检测负样本,得到hardexample

    5、提取hardexample的hog特征并结合第一步中的特征一起投入训练,得到最终检测子。


    本文主要先介绍hog特征,以及描述子的计算。hog特征提取算法的实现过程:

    HOG特征提取方法就是将一个image(你要检测的目标或者扫描窗口):

    1)灰度化(将图像看做一个x,y,z(灰度)的三维图像);

    2)采用Gamma校正法对输入图像进行颜色空间的标准化(归一化);目的是调节图像的对比度,降低图像局部的阴影和光照变化所造成的影响,同时可以抑制噪音的干扰;

    3)计算图像每个像素的梯度(包括大小和方向);主要是为了捕获轮廓信息,同时进一步弱化光照的干扰。

    4)将图像划分成小cells(例如6*6像素/cell);

    5)统计每个cell的梯度直方图(不同梯度的个数),即可形成每个celldescriptor

    6)将每几个cell组成一个block(例如3*3cell/block),一个block内所有cell的特征descriptor串联起来便得到该blockHOG特征descriptor

    7)将图像image内的所有blockHOG特征descriptor串联起来就可以得到该image(你要检测的目标)的HOG特征descriptor了。这个就是最终的可供分类使用的特征向量了。

    Dalal提出的Hog特征提取的过程:把样本图像分割为若干个像素的单元(cell),把梯度方向平均划分为9个区间(bin),在每个单元里面对所有像素的梯度方向在各个方向区间进行直方图统计,得到一个9维的特征向量,每相邻的4个单元构成一个块(block),把一个块内的特征向量联起来得到36维的特征向量,用块对样本图像进行扫描,扫描步长为一个单元。最后将所有块的特征串联起来,就得到了人体的特征。例如,对于64*128的图像而言,8*8的像素组成一个cell,每2*2cell组成一个块,因为每个cell9个特征,所以每个块内有4*9=36个特征,以8个像素为步长,那么,水平方向将有7个扫描窗口,垂直方向将有15个扫描窗口。也就是说,64*128的图片,总共有36*7*15=3780个特征。

    特征维数n=窗口块数X块中胞元数X向量维数(bin)

    HOG Descriptor(WinSize(64.128),BlockSize(16.16),BlockStride(8.8),CellSize(8.8))

    窗口块数目:(64-16)/8+1 *(128-16)/8+1=105块


    参考:http://blog.csdn.net/masibuaa/article/details/12917961,非常优秀的同类型博客


    展开全文
  • 首先,准备素材,然后根据训练类别构建SVM模型,然后训练,保存模型参数,然后使用模型进行分类。 首先是训练模型部分,第一步进行特征提取,提取到的特征组成一个向量,稍后添加到SVM模型去。特征提取的方法有很多...

    首先,准备素材,然后根据训练类别构建SVM模型,然后训练,保存模型参数,然后使用模型进行分类。

    首先是训练模型部分,第一步进行特征提取,提取到的特征组成一个向量,稍后添加到SVM模型去。特征提取的方法有很多,这里就不说了。

    然后是训练模型,上代码

    Hlong NumFeatures = 8;
    HString KernelType = "rbf";
    double KernelParam = 0.02, Nu = 0.01;
    Hlong NumClasses = 1;
    HString Mode = "one-versus-one", Preprocessing = "normalization";
    Hlong NumComponents = 8;
    HClassSvm classSvm;
    classSvm.CreateClassSvm(NumFeatures, KernelType, KernelParam, Nu, NumClasses, Mode, Preprocessing, NumComponents);
    double Epsilon = 0.01;
    HString TrainMode = "default";
    classSvm.TrainClassSvm(Epsilon, TrainMode);
    classSvm.WriteClassSvm("SVMModel.gsc");

    至此完成训练,然后就是识别

    HTuple Class2 = fileclassSvm.ClassifyClassSvm(getAllFeats(reg, gray), Num2);

    返回值就是识别结果。

    存在问题,多类别分类不好判别置信度,就造成无论什么输入都会被判别为某一个类。

    解决方案单独训练一个类别,即可得到特征向量与超平面的距离,从而得到一个判别的依据。

    展开全文
  • 正样本来源是INRIA数据集中的96*160大小的人体图片,使用时上下左右都去掉...首先计算正负样本图像的HOG描述子,组成一个特征向量矩阵,对应的要有一个指定每个特征向量的类别的类标向量,输入SVM中进行训练训练

    正样本来源是INRIA数据集中的96*160大小的人体图片,使用时上下左右都去掉16个像素,截取中间的64*128大小的人体。

    负样本是从不包含人体的图片中随机裁取的,大小同样是64*128。

    SVM使用的是OpenCV自带的CvSVM类。

    首先计算正负样本图像的HOG描述子,组成一个特征向量矩阵,对应的要有一个指定每个特征向量的类别的类标向量,输入SVM中进行训练。

    训练好的SVM分类器保存为XML文件,然后根据其中的支持向量和参数生成OpenCV中的HOG描述子可用的检测子参数,再调用OpenCV中的多尺度检测函数进行行人检测。

    难例(Hard Example) 是指利用第一次训练的分类器在负样本原图(肯定没有人体)上进行行人检测时所有检测到的矩形框,这些矩形框区域很明显都是误报,把这些误报的矩形框保存为图片,加入到初始的负样本集合中,重新进行SVM的训练,可显著减少误报。 

    #include <iostream>
    #include <fstream>
    #include <opencv2/core/core.hpp>
    #include <opencv2/highgui/highgui.hpp>
    #include <opencv2/imgproc/imgproc.hpp>
    #include <opencv2/objdetect/objdetect.hpp>
    #include <opencv2/ml/ml.hpp>
    
    using namespace std;
    using namespace cv;
    
    #define PosSamNO 2400    //正样本个数
    #define NegSamNO 12000    //负样本个数
    
    #define TRAIN false    //是否进行训练,true表示重新训练,false表示读取xml文件中的SVM模型
    #define CENTRAL_CROP true   //true:训练时,对96*160的INRIA正样本图片剪裁出中间的64*128大小人体
    
    //HardExample:负样本个数。如果HardExampleNO大于0,表示处理完初始负样本集后,继续处理HardExample负样本集。
    //不使用HardExample时必须设置为0,因为特征向量矩阵和特征类别矩阵的维数初始化时用到这个值
    #define HardExampleNO 4435  
    
    
    //继承自CvSVM的类,因为生成setSVMDetector()中用到的检测子参数时,需要用到训练好的SVM的decision_func参数,
    //但通过查看CvSVM源码可知decision_func参数是protected类型变量,无法直接访问到,只能继承之后通过函数访问
    class MySVM : public CvSVM
    {
    public:
    	//获得SVM的决策函数中的alpha数组
    	double * get_alpha_vector()
    	{
    		return this->decision_func->alpha;
    	}
    
    	//获得SVM的决策函数中的rho参数,即偏移量
    	float get_rho()
    	{
    		return this->decision_func->rho;
    	}
    };
    
    
    
    int main()
    {
    	//检测窗口(64,128),块尺寸(16,16),块步长(8,8),cell尺寸(8,8),直方图bin个数9
    	HOGDescriptor hog(Size(64,128),Size(16,16),Size(8,8),Size(8,8),9);//HOG检测器,用来计算HOG描述子的
    	int DescriptorDim;//HOG描述子的维数,由图片大小、检测窗口大小、块大小、细胞单元中直方图bin个数决定
    	MySVM svm;//SVM分类器
    
    	//若TRAIN为true,重新训练分类器
    	if(TRAIN)
    	{
    		string ImgName;//图片名(绝对路径)
    		ifstream finPos("INRIAPerson96X160PosList.txt");//正样本图片的文件名列表
    		//ifstream finPos("PersonFromVOC2012List.txt");//正样本图片的文件名列表
    		ifstream finNeg("NoPersonFromINRIAList.txt");//负样本图片的文件名列表
    
    		Mat sampleFeatureMat;//所有训练样本的特征向量组成的矩阵,行数等于所有样本的个数,列数等于HOG描述子维数	
    		Mat sampleLabelMat;//训练样本的类别向量,行数等于所有样本的个数,列数等于1;1表示有人,-1表示无人
    
    
    		//依次读取正样本图片,生成HOG描述子
    		for(int num=0; num<PosSamNO && getline(finPos,ImgName); num++)
    		{
    			cout<<"处理:"<<ImgName<<endl;
    			//ImgName = "D:\\DataSet\\PersonFromVOC2012\\" + ImgName;//加上正样本的路径名
    			ImgName = "D:\\DataSet\\INRIAPerson\\INRIAPerson\\96X160H96\\Train\\pos\\" + ImgName;//加上正样本的路径名
    			Mat src = imread(ImgName);//读取图片
    			if(CENTRAL_CROP)
    				src = src(Rect(16,16,64,128));//将96*160的INRIA正样本图片剪裁为64*128,即剪去上下左右各16个像素
    			//resize(src,src,Size(64,128));
    
    			vector<float> descriptors;//HOG描述子向量
    			hog.compute(src,descriptors,Size(8,8));//计算HOG描述子,检测窗口移动步长(8,8)
    			//cout<<"描述子维数:"<<descriptors.size()<<endl;
    
    			//处理第一个样本时初始化特征向量矩阵和类别矩阵,因为只有知道了特征向量的维数才能初始化特征向量矩阵
    			if( 0 == num )
    			{
    				DescriptorDim = descriptors.size();//HOG描述子的维数
    				//初始化所有训练样本的特征向量组成的矩阵,行数等于所有样本的个数,列数等于HOG描述子维数sampleFeatureMat
    				sampleFeatureMat = Mat::zeros(PosSamNO+NegSamNO+HardExampleNO, DescriptorDim, CV_32FC1);
    				//初始化训练样本的类别向量,行数等于所有样本的个数,列数等于1;1表示有人,0表示无人
    				sampleLabelMat = Mat::zeros(PosSamNO+NegSamNO+HardExampleNO, 1, CV_32FC1);
    			}
    
    			//将计算好的HOG描述子复制到样本特征矩阵sampleFeatureMat
    			for(int i=0; i<DescriptorDim; i++)
    				sampleFeatureMat.at<float>(num,i) = descriptors[i];//第num个样本的特征向量中的第i个元素
    			sampleLabelMat.at<float>(num,0) = 1;//正样本类别为1,有人
    		}
    
    		//依次读取负样本图片,生成HOG描述子
    		for(int num=0; num<NegSamNO && getline(finNeg,ImgName); num++)
    		{
    			cout<<"处理:"<<ImgName<<endl;
    			ImgName = "D:\\DataSet\\NoPersonFromINRIA\\" + ImgName;//加上负样本的路径名
    			Mat src = imread(ImgName);//读取图片
    			//resize(src,img,Size(64,128));
    
    			vector<float> descriptors;//HOG描述子向量
    			hog.compute(src,descriptors,Size(8,8));//计算HOG描述子,检测窗口移动步长(8,8)
    			//cout<<"描述子维数:"<<descriptors.size()<<endl;
    
    			//将计算好的HOG描述子复制到样本特征矩阵sampleFeatureMat
    			for(int i=0; i<DescriptorDim; i++)
    				sampleFeatureMat.at<float>(num+PosSamNO,i) = descriptors[i];//第PosSamNO+num个样本的特征向量中的第i个元素
    			sampleLabelMat.at<float>(num+PosSamNO,0) = -1;//负样本类别为-1,无人
    		}
    
    		//处理HardExample负样本
    		if(HardExampleNO > 0)
    		{
    			ifstream finHardExample("HardExample_2400PosINRIA_12000NegList.txt");//HardExample负样本的文件名列表
    			//依次读取HardExample负样本图片,生成HOG描述子
    			for(int num=0; num<HardExampleNO && getline(finHardExample,ImgName); num++)
    			{
    				cout<<"处理:"<<ImgName<<endl;
    				ImgName = "D:\\DataSet\\HardExample_2400PosINRIA_12000Neg\\" + ImgName;//加上HardExample负样本的路径名
    				Mat src = imread(ImgName);//读取图片
    				//resize(src,img,Size(64,128));
    
    				vector<float> descriptors;//HOG描述子向量
    				hog.compute(src,descriptors,Size(8,8));//计算HOG描述子,检测窗口移动步长(8,8)
    				//cout<<"描述子维数:"<<descriptors.size()<<endl;
    
    				//将计算好的HOG描述子复制到样本特征矩阵sampleFeatureMat
    				for(int i=0; i<DescriptorDim; i++)
    					sampleFeatureMat.at<float>(num+PosSamNO+NegSamNO,i) = descriptors[i];//第PosSamNO+num个样本的特征向量中的第i个元素
    				sampleLabelMat.at<float>(num+PosSamNO+NegSamNO,0) = -1;//负样本类别为-1,无人
    			}
    		}
    
    		输出样本的HOG特征向量矩阵到文件
    		//ofstream fout("SampleFeatureMat.txt");
    		//for(int i=0; i<PosSamNO+NegSamNO; i++)
    		//{
    		//	fout<<i<<endl;
    		//	for(int j=0; j<DescriptorDim; j++)
    		//		fout<<sampleFeatureMat.at<float>(i,j)<<"  ";
    		//	fout<<endl;
    		//}
    
    		//训练SVM分类器
    		//迭代终止条件,当迭代满1000次或误差小于FLT_EPSILON时停止迭代
    		CvTermCriteria criteria = cvTermCriteria(CV_TERMCRIT_ITER+CV_TERMCRIT_EPS, 1000, FLT_EPSILON);
    		//SVM参数:SVM类型为C_SVC;线性核函数;松弛因子C=0.01
    		CvSVMParams param(CvSVM::C_SVC, CvSVM::LINEAR, 0, 1, 0, 0.01, 0, 0, 0, criteria);
    		cout<<"开始训练SVM分类器"<<endl;
    		svm.train(sampleFeatureMat, sampleLabelMat, Mat(), Mat(), param);//训练分类器
    		cout<<"训练完成"<<endl;
    		svm.save("SVM_HOG.xml");//将训练好的SVM模型保存为xml文件
    
    	}
    	else //若TRAIN为false,从XML文件读取训练好的分类器
    	{
    		svm.load("SVM_HOG_2400PosINRIA_12000Neg_HardExample(误报少了漏检多了).xml");//从XML文件读取训练好的SVM模型
    	}
    
    
    	/*************************************************************************************************
    	线性SVM训练完成后得到的XML文件里面,有一个数组,叫做support vector,还有一个数组,叫做alpha,有一个浮点数,叫做rho;
    	将alpha矩阵同support vector相乘,注意,alpha*supportVector,将得到一个列向量。之后,再该列向量的最后添加一个元素rho。
    	如此,变得到了一个分类器,利用该分类器,直接替换opencv中行人检测默认的那个分类器(cv::HOGDescriptor::setSVMDetector()),
    	就可以利用你的训练样本训练出来的分类器进行行人检测了。
    	***************************************************************************************************/
    	DescriptorDim = svm.get_var_count();//特征向量的维数,即HOG描述子的维数
    	int supportVectorNum = svm.get_support_vector_count();//支持向量的个数
    	cout<<"支持向量个数:"<<supportVectorNum<<endl;
    
    	Mat alphaMat = Mat::zeros(1, supportVectorNum, CV_32FC1);//alpha向量,长度等于支持向量个数
    	Mat supportVectorMat = Mat::zeros(supportVectorNum, DescriptorDim, CV_32FC1);//支持向量矩阵
    	Mat resultMat = Mat::zeros(1, DescriptorDim, CV_32FC1);//alpha向量乘以支持向量矩阵的结果
    
    	//将支持向量的数据复制到supportVectorMat矩阵中
    	for(int i=0; i<supportVectorNum; i++)
    	{
    		const float * pSVData = svm.get_support_vector(i);//返回第i个支持向量的数据指针
    		for(int j=0; j<DescriptorDim; j++)
    		{
    			//cout<<pData[j]<<" ";
    			supportVectorMat.at<float>(i,j) = pSVData[j];
    		}
    	}
    
    	//将alpha向量的数据复制到alphaMat中
    	double * pAlphaData = svm.get_alpha_vector();//返回SVM的决策函数中的alpha向量
    	for(int i=0; i<supportVectorNum; i++)
    	{
    		alphaMat.at<float>(0,i) = pAlphaData[i];
    	}
    
    	//计算-(alphaMat * supportVectorMat),结果放到resultMat中
    	//gemm(alphaMat, supportVectorMat, -1, 0, 1, resultMat);//不知道为什么加负号?
    	resultMat = -1 * alphaMat * supportVectorMat;
    
    	//得到最终的setSVMDetector(const vector<float>& detector)参数中可用的检测子
    	vector<float> myDetector;
    	//将resultMat中的数据复制到数组myDetector中
    	for(int i=0; i<DescriptorDim; i++)
    	{
    		myDetector.push_back(resultMat.at<float>(0,i));
    	}
    	//最后添加偏移量rho,得到检测子
    	myDetector.push_back(svm.get_rho());
    	cout<<"检测子维数:"<<myDetector.size()<<endl;
    	//设置HOGDescriptor的检测子
    	HOGDescriptor myHOG;
    	myHOG.setSVMDetector(myDetector);
    	//myHOG.setSVMDetector(HOGDescriptor::getDefaultPeopleDetector());
    
    	//保存检测子参数到文件
    	ofstream fout("HOGDetectorForOpenCV.txt");
    	for(int i=0; i<myDetector.size(); i++)
    	{
    		fout<<myDetector[i]<<endl;
    	}
    
    
    	/**************读入图片进行HOG行人检测******************/
    	//Mat src = imread("00000.jpg");
    	//Mat src = imread("2007_000423.jpg");
    	Mat src = imread("1.png");
    	vector<Rect> found, found_filtered;//矩形框数组
    	cout<<"进行多尺度HOG人体检测"<<endl;
    	myHOG.detectMultiScale(src, found, 0, Size(8,8), Size(32,32), 1.05, 2);//对图片进行多尺度行人检测
    	cout<<"找到的矩形框个数:"<<found.size()<<endl;
    
    	//找出所有没有嵌套的矩形框r,并放入found_filtered中,如果有嵌套的话,则取外面最大的那个矩形框放入found_filtered中
    	for(int i=0; i < found.size(); i++)
    	{
    		Rect r = found[i];
    		int j=0;
    		for(; j < found.size(); j++)
    			if(j != i && (r & found[j]) == r)
    				break;
    		if( j == found.size())
    			found_filtered.push_back(r);
    	}
    
    	//画矩形框,因为hog检测出的矩形框比实际人体框要稍微大些,所以这里需要做一些调整
    	for(int i=0; i<found_filtered.size(); i++)
    	{
    		Rect r = found_filtered[i];
    		r.x += cvRound(r.width*0.1);
    		r.width = cvRound(r.width*0.8);
    		r.y += cvRound(r.height*0.07);
    		r.height = cvRound(r.height*0.8);
    		rectangle(src, r.tl(), r.br(), Scalar(0,255,0), 3);
    	}
    
    	imwrite("ImgProcessed.jpg",src);
    	namedWindow("src",0);
    	imshow("src",src);
    	waitKey();//注意:imshow之后必须加waitKey,否则无法显示图像
    	
    
    	/******************读入单个64*128的测试图并对其HOG描述子进行分类*********************/
    	读取测试图片(64*128大小),并计算其HOG描述子
    	Mat testImg = imread("person014142.jpg");
    	//Mat testImg = imread("noperson000026.jpg");
    	//vector<float> descriptor;
    	//hog.compute(testImg,descriptor,Size(8,8));//计算HOG描述子,检测窗口移动步长(8,8)
    	//Mat testFeatureMat = Mat::zeros(1,3780,CV_32FC1);//测试样本的特征向量矩阵
    	将计算好的HOG描述子复制到testFeatureMat矩阵中
    	//for(int i=0; i<descriptor.size(); i++)
    	//	testFeatureMat.at<float>(0,i) = descriptor[i];
    
    	用训练好的SVM分类器对测试图片的特征向量进行分类
    	//int result = svm.predict(testFeatureMat);//返回类标
    	//cout<<"分类结果:"<<result<<endl;
    
    
    
    	system("pause");
    }

    (1) 1500个INRIA正样本,2000个负样本,结果误报太多:


    (2) 2400个INRIA正样本,12000个负样本,结果表明负样本增多后误报明显减少,但依然有不少误报:


    (3)2400个INRIA正样本,12000个负样本 + 4435个用(2)中的分类器在负样本原图上检测出来的Hard Example,

    结果误报明显减少,几乎没有误报了,但同时漏检率增加:


    上图中的两个小女孩都没有被检测出来

    (4)下面是OpenCV中HOG检测器的默认SVM参数的结果,OpenCV自带的SVM参数也是用INRIA数据集训练得到的:


    上图中的两个小女孩用OpenCV默认SVM参数也检测不出来。

    所以感觉要想效果好的话,还应该加大正样本的个数。

    参考:  http://blog.csdn.net/carson2005/article/details/7841443 

    源码下载,环境为VS2010 + OpenCV2.4.4

    http://download.csdn.net/detail/masikkk/6547973 

    展开全文
  • 1. 代码部分 此代码块为train_model.py内的代码 # USAGE # python train_model.py --...# 在提取的128维面部嵌入的基础上训练“标准”机器学习分类器(SVM,SGD分类器,随机森林等) from sklearn.preprocessing imp

    1. 代码部分

    此代码块为train_model.py内的代码

    # USAGE
    # python train_model.py --embeddings output/embeddings.pickle \
    #	--recognizer output/recognizer.pickle --le output/le.pickle
    
    # 加载必要的包
    # 在提取的128维面部嵌入的基础上训练“标准”机器学习分类器(SVM,SGD分类器,随机森林等)
    from sklearn.preprocessing import LabelEncoder
    from sklearn.svm import SVC
    import pickle
    
    def train_model():
        ## 加载序列化面部嵌入(serialized face embeddings )
        print("[INFO] loading face embeddings...")
        # 在此脚本文件中,使用函数extract_embeddings()提取的面部嵌入
        data = pickle.loads(open(r'output/embeddings.pickle', "rb").read())
        
        ## 给标签编码
        ## 将人名作为标签存储到磁盘中
        print("[INFO] encoding labels...")
        # 初始化scikit-learn的标签编码器(LabelEncoder)
        le = LabelEncoder()
        # 编码人名的标签(这一步运行完之后,标签编码器便和data字典中的names关联起来了)
        labels = le.fit_transform(data["names"])
        
        ## 训练用于识别人脸的线性支持向量机(SVM)模型
        ## 训练用于接收面部嵌入的模型,即人脸识别模型(recognizer model)
        print("[INFO] training model...")
        # 初始化SVM模型(可选用的核函数:rbf(径向基核,也就是高斯核函数),linear(线性核函数))
        recognizer = SVC(C=1.0, kernel="linear", probability=True)
        # 拟合模型(训练模型)
        recognizer.fit(data["embeddings"], labels)
        
        ## 将标签编码器写入磁盘
        f = open(r'output/le.pickle', "wb")
        f.write(pickle.dumps(le))
        f.close()
    
        ## 将人脸识别模型写入磁盘
        f = open(r'output/recognizer.pickle', "wb")
        f.write(pickle.dumps(recognizer))
        f.close()
        
    ## 测试脚本用  
    if __name__ == '__main__':
        train_model()
        
    

    2. 函数结构说明

    在这里插入图片描述

    3. 程序流程图

    在这里插入图片描述

    4. 函数图解

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    5. 使用说明

    本函数需搭配视频流人脸识别系统一起使用。
    视频流人脸识别系统的系统函数见此博客:一、视频流人脸识别系统的系统函数的构建(Python)

    展开全文
  • 如题,进行目标检测,比如在一幅图中找到一辆汽车,并将目标区域用矩形框标记,该怎样检测,如何编程呢?
  • 来加载训练好的分类器数据时,千万要注意detector的维数必须是3780,否则运行到这个语句就会报错。detector的维数即为HOG特征的维数,由样本的宽高,窗口(win)、块(block)、单元(cell)以及单元的滑移步长决定,...
  • svm分类器训练

    热门讨论 2010-03-10 18:57:02
    SVM训练器和分类器,实现分类和训练,比较常用
  • svm分类器

    千次阅读 2019-01-25 08:53:23
    SVM本身是一个二值分类器  SVM算法最初是为二值分类问题设计的,当处理多类问题时,就需要构造合适的多类分类器。  目前,构造SVM多类分类器的方法主要有两类  (1)直接法,直接在目标函数上进行修改,将多个...
  • 车辆识别(特征提取+svm分类器

    万次阅读 多人点赞 2018-07-26 19:00:33
    以下为udacity的SDCND的一个项目 ...使用openCV提取图片特征,训练svm分类器,分类车辆与非车辆。用训练好的模型识别汽车前置摄像头记录视频中的车辆。 代码github地址:yang1688899/CarND-Vehicle-Detection ...
  • Python SVM分类器 XGBOOST分类器 文本情绪分析 疫情期间网民情绪识别比赛 目录 Python SVM分类器 XGBOOST分类器 文本情绪分析 疫情期间网民情绪识别比赛 一:比赛相关事项 二:使用工具PyCharm配合Anaconda3 三...
  • 最近自己做的项目因为用到SVM分类,使用的是matlab中使用libsvm工具箱训练svm分类器,随着训练集的不断增加,训练时间明显越来越长,每次都重新训练太过于浪费时间,一直赖着没查这方面,其实SVM用的也很广泛,这...
  • opencv中应用HOG特征训练SVM分类器的一般框架
  • HOG+SVM 自己制作训练样本+训练分类器 2014年06月04日 ⁄ 综合 ⁄ 共 4388字 ⁄ 字号 小 中 大 ⁄ 评论关闭 ... 最近在做行人检测的项目,...因此想到制作训练样本,并训练SVM分类器。  步骤如下:
  • HOG人体特征提取+SVM分类器训练进行人体检测
  • 计算机视觉—人脸识别(Hog特征+SVM分类器) 一、SVM支持向量机 1、SVM原理 在机器学习,支持向量机的监督学习模型与相关的学习算法可以分析用于数据分类和回归分析。给定一组训练样例,每个训练样例被标记为属于两...
  • Matlab-SVM分类器

    万次阅读 多人点赞 2016-08-29 11:47:51
    支持向量机(Support Vector Machine,SVM),可以完成对数据的分类,包括线性可分情况和线性不可分情况。... 并用线性函数f(x)=w·x +b来构造这个分类器(如下图是一个二维分界线) 其中,w是权重向量,x为训练
  • SVM分类器原理详解

    万次阅读 多人点赞 2015-08-21 11:51:05
     支持向量机,因其英文名为support vector machine,故一般简称SVM,通俗来讲,它是一种二类分类模型,其基本模型定义为特征空间上的间隔最大的线性分类器,其学习策略便是间隔最大化,最终可转化为一个凸二次...
  • python的svm分类器

    热门讨论 2014-03-03 10:56:10
    基于python的SVM分类算法,可以直接使用,包含源代码,支持参数设定
  • opencv实战从0到N (13)—— svm分类器训练 同步个人知乎:中庸 svm 分类器训练 1,结合hog特征的svm分类器训练可以很好的对人体进行检测。HOG是一种梯度直方图特征,通过对 图像分割成小的连通域区域,再对连...
  • 比如说分别用HOG特征和LBP特征,在SVM训练两个分类器,检测的时候用两个分类器同时检测图片中的行人,容易实现吗?
  • 计算线性SVM分类器的分类面方程

    千次阅读 2018-12-26 17:37:38
    这里的正负样本不重要,只是在使用SVM原理计算时,y的值不同而已。 有两个样本点,第一个点为负样本,...第二个点为正样本,它的特征向量是(2,3),从这两个样本点组成的训练集构建一个线性SVM分类器的分类面方程是( C...
  • 机器学习--SVM分类器

    千次阅读 2016-06-08 15:22:13
    机器学习--SVM分类器

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 54,387
精华内容 21,754
关键字:

如何训练svm分类器