用SVM对自己的数据分类

最新推荐文章于 2024-06-01 15:33:20 发布
最新推荐文章于 2024-06-01 15:33:20 发布
阅读量8.6k 收藏 12
点赞数
分类专栏： OpenCV Basises ML 文章标签： 模式识别 svm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wd1603926823/article/details/51698755
版权

参考http://blog.csdn.net/carson2005/article/details/6547250  数据和标签格式还是和上一篇Adaboost一样的

用的LINEAR线性的核类型

#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/ml/ml.hpp>
#include "opencv2/imgproc/imgproc.hpp"  
#include <iostream>  
#include<algorithm>
#include<opencv2/opencv.hpp>
#include "time.h" 
using namespace std;
using namespace cv;
int main()
{
//开始计时
clock_t start, finish;
double duration;
start = clock();
// 样本
CvMLData cvmlprimer;
cvmlprimer.read_csv("featurewet.csv");
cv::Mat cvml = cv::Mat(cvmlprimer.get_values(), true);
CvMLData resprimer;
resprimer.read_csv("labelwet.csv");
cv::Mat res = cv::Mat(resprimer.get_values(), true);

//打乱顺序结果在stonevec[]和kuangvec[]两个数组里 图像标号
const int uselesssample = 358, usefulsample = 192, allsample = usefulsample + uselesssample, featurecol = 1000;
//打乱顺序 前uselesssample个为废石  后usefulsample个为矿
int stonevec[uselesssample], kuangvec[usefulsample];
for (int i = 0; i < uselesssample; i++)
stonevec[i] = i;
for (int i = 0; i <usefulsample; i++)
kuangvec[i] = uselesssample + i;
random_shuffle(stonevec, stonevec + uselesssample);
random_shuffle(kuangvec, kuangvec + usefulsample);
/saperate into trainset randomly
const float rate = 0.8;
int trainnum = int(uselesssample*rate) + int(usefulsample*rate), testnum = allsample - trainnum;
Mat traindata = Mat::zeros(trainnum, featurecol, cvml.type()), testdata = Mat::zeros(testnum, featurecol, cvml.type()), trainlabel = Mat::zeros(trainnum, 1, res.type()), testlabel = Mat::zeros(testnum, 1, res.type());
for (int i = 0; i <int(uselesssample*rate); i++)
{
float* newrow = traindata.ptr<float>(i);
int currentrow = stonevec[i];
float* primerow = cvml.ptr<float>(currentrow);
for (int j = 0; j < featurecol; j++)
newrow[j] = primerow[j];
float* newlabelrow = trainlabel.ptr<float>(i);
float* primerlabelrow = res.ptr<float>(currentrow);
newlabelrow[0] = primerlabelrow[0];
}
for (int i = int(uselesssample*rate); i <trainnum; i++)
{
float* newrow = traindata.ptr<float>(i);
int ii = i - int(uselesssample*rate);
int currentrow = kuangvec[ii];
float* primerow = cvml.ptr<float>(currentrow);
for (int j = 0; j < featurecol; j++)
newrow[j] = primerow[j];
float* newlabelrow = trainlabel.ptr<float>(i);
float* primerlabelrow = res.ptr<float>(currentrow);
newlabelrow[0] = primerlabelrow[0];
}
//saperate into testset 
for (int i = 0; i <uselesssample - int(uselesssample*rate); i++)
{
float* newrow = testdata.ptr<float>(i);
int iii = i + int(uselesssample*rate);
int currentrow = stonevec[iii];
float* primerow = cvml.ptr<float>(currentrow);
for (int j = 0; j < featurecol; j++)
newrow[j] = primerow[j];
float* newlabelrow = testlabel.ptr<float>(i);
float* primerlabelrow = res.ptr<float>(currentrow);
newlabelrow[0] = primerlabelrow[0];
}
for (int i = uselesssample - int(uselesssample*rate); i <testnum; i++)
{
int ii = int(usefulsample*rate) + i - (uselesssample - int(uselesssample*rate));
float* newrow = testdata.ptr<float>(i);
int currentrow = kuangvec[ii];
float* primerow = cvml.ptr<float>(currentrow);
for (int j = 0; j < featurecol; j++)
newrow[j] = primerow[j];
float* newlabelrow = testlabel.ptr<float>(i);
float* primerlabelrow = res.ptr<float>(currentrow);
newlabelrow[0] = primerlabelrow[0];
}
/train
cout << "Ready for Training ... " << endl;
// 设置SVM参数
CvSVMParams params;
params.svm_type = CvSVM::C_SVC;
//params.kernel_type = CvSVM::RBF;
//params.kernel_type = CvSVM::SIGMOID;
params.kernel_type = CvSVM::LINEAR;
//params.C= 0.1;  
params.term_crit = cvTermCriteria(CV_TERMCRIT_ITER, 100, 1e-6);
// 对SVM进行训练
CvSVM SVM;
SVM.train(traindata, trainlabel, Mat(), Mat(), params);
cout << "training done!!!prepare for test..." << endl;
test
const int numfortest = testdata.rows;
Mat currentsample;
currentsample.create(1, featurecol, testdata.type());
float* outputlabels = new float[numfortest];   //动态数组可以避免必须写明确维度的麻烦  记得delete
for (int i = 0; i < numfortest; i++)
{
float* currentrow = testdata.ptr<float>(i);
for (int j = 0; j < featurecol; j++)
currentsample.at<float>(0, j) = currentrow[j];
float currentoutputs = SVM.predict(currentsample);//必须一个一个样本的进行测试
outputlabels[i] = currentoutputs;
//cout << currentoutputs << endl;
}
cout << "test done!!!prepare for calculating the accurency..." << endl << endl;
/calculate whole error 
int correct = 0;
float accurency;
for (int i = 0; i < testlabel.rows; ++i)
{
float* p = testlabel.ptr<float>(i);
cout << "true label= " << p[0] << " output label= " << outputlabels[i] << endl;
if (p[0] == outputlabels[i])
++correct;
}
cout << endl;
accurency = (float)correct / testlabel.rows;
cout << "whole accurency= " << accurency << endl;
/calculate the positive sample error and negative sample error
int alluseless = 0, uselesserror = 0, alluseful = 0, usefulerror = 0;
float stoneerror = 0, kuangerror = 0;
//stone error
for (int i = 0; i < testlabel.rows; ++i)
{
float* p = testlabel.ptr<float>(i);
if (p[0] == (float)1)
{
++alluseless;
if (p[0] != outputlabels[i])
++uselesserror;
}
}
cout << alluseless << "  " << uselesserror << endl;
stoneerror = (float)uselesserror / alluseless;
cout << " stone error= " << stoneerror << endl;
//kuang  error
for (int i = 0; i <testlabel.rows; ++i)
{
float* p = testlabel.ptr<float>(i);
if (p[0] == (float)2)
{
++alluseful;
if (p[0] != outputlabels[i])
++usefulerror;
}
}
cout << alluseful << "  " << usefulerror << endl;
kuangerror = (float)usefulerror / alluseful;
cout << " kuang error= " << kuangerror << endl;

delete[] outputlabels;
//结束计时  
finish = clock();
duration = (double)(finish - start) / CLOCKS_PER_SEC;
cout << "训练过程结束,共耗时：" << duration << "秒" << endl;
return 0;
}

可以是可以  可是准确率太低了  调参是门技术

参考http://blog.csdn.net/computerme/article/details/38677599自动寻优参数：

RBF核函数 自动寻参数最优哎。。。。。。。。。调参是门技术









另一个SVM程序：

#include<opencv2\opencv.hpp>
#include<opencv2\imgproc\imgproc.hpp>
#include<opencv2\highgui\highgui.hpp>
#include<fstream>
using namespace cv;
using namespace std;
#define cvQueryHistValue_1D( hist, idx0 )    ((float)cvGetReal1D( (hist)->bins, (idx0)))

Mat mypredone(IplImage* srcipl,vector<Mat> bgrimgs)
{
	//找轮廓
	Mat img(srcipl, 0);
	split(img, bgrimgs);
	Mat bimg(img.size(), CV_8UC1, cv::Scalar(0));
	bgrimgs[0].copyTo(bimg);
	threshold(bimg, bimg, 12, 255, CV_THRESH_BINARY/*|CV_THRESH_OTSU*/);
	Mat element(4, 4, CV_8U, cv::Scalar(1));
	morphologyEx(bimg, bimg, cv::MORPH_OPEN, element);
	for (int i = 0; i < 20; i++)
	{
		uchar* data = bimg.ptr<uchar>(i);
		for (int j = 0; j < bimg.size().width; j++)
			data[j] = 0;
	}
	//for (int i = bimg.size().height - 19; i < bimg.size().height; i++)
	//{
	//	uchar* data = bimg.ptr<uchar>(i);
	//	for (int j = 0; j < bimg.size().width; j++)
	//		data[j] = 0;
	//}
	return bimg;
}

Mat my_contour(IplImage* dst, IplImage bimgipl)
{
	cvZero(dst);
	CvMemStorage *storage = cvCreateMemStorage();
	CvSeq *contour = NULL, *hull = NULL;
	vector<CvPoint> allpoints;
	CvContourScanner scanner = cvStartFindContours(&bimgipl, storage);
	while ((contour = cvFindNextContour(scanner)) != NULL)
	{
		cvDrawContours(dst, contour, cv::Scalar(255), cv::Scalar(255), 0);
		hull = cvConvexHull2(contour, 0, CV_CLOCKWISE, 0);
		CvPoint pt0 = **(CvPoint**)cvGetSeqElem(hull, hull->total - 1);
		allpoints.push_back(pt0);
		for (int i = 0; i < hull->total; ++i)
		{
			CvPoint pt1 = **(CvPoint**)cvGetSeqElem(hull, i);
			allpoints.push_back(pt1);
			cvLine(dst, pt0, pt1, cv::Scalar(255));
			pt0 = pt1;
		}
	}
	//上面是第一次寻找 可能有多个凸包 下面存储每个凸包的凸点到容器中 方便我连线画图再寻找一次 也是最后的
	Mat dstmat(dst, 0);
	std::vector<std::vector<cv::Point>> myown_contours;
	cv::findContours(dstmat, myown_contours, CV_RETR_EXTERNAL, CV_CHAIN_APPROX_NONE);
	//cout << myown_contours.size() << endl;
	if (myown_contours.size() > 1)
	{
		for (int i = 0; i < allpoints.size() - 1; i++)
		{
			CvPoint firstdot = allpoints[i];
			CvPoint secdot = allpoints[i + 1];
			cvLine(dst, firstdot, secdot, cv::Scalar(255), 2);
		}
		CvContourScanner scanner2 = cvStartFindContours(dst, storage);
		while ((contour = cvFindNextContour(scanner2)) != NULL)
		{
			cvDrawContours(dst, contour, cv::Scalar(255), cv::Scalar(255), 0);
			hull = cvConvexHull2(contour, 0, CV_CLOCKWISE, 0);
			CvPoint pt0 = **(CvPoint**)cvGetSeqElem(hull, hull->total - 1);
			for (int i = 0; i < hull->total; ++i)
			{
				CvPoint pt1 = **(CvPoint**)cvGetSeqElem(hull, i);
				cvLine(dst, pt0, pt1, cv::Scalar(255));
				pt0 = pt1;
			}
		}
	}
	Mat bimgdst(dst, 0);
	std::vector<std::vector<cv::Point>> contours;
	cv::findContours(bimgdst, contours, CV_RETR_EXTERNAL, CV_CHAIN_APPROX_NONE);
	Mat contoursimg(bimgdst.size(), CV_8UC1, cv::Scalar(0));
	drawContours(contoursimg, contours, -1, Scalar(255), CV_FILLED);
	return contoursimg;
}

void myfeatures(IplImage* srcipl,IplImage myresultipl,float features[])
{
	cvCvtColor(srcipl, srcipl, CV_BGR2Lab);
	IplImage* limg = cvCreateImage(cvGetSize(srcipl), srcipl->depth, 1);
	IplImage* aimg = cvCreateImage(cvGetSize(srcipl), srcipl->depth, 1);
	IplImage* bbimg = cvCreateImage(cvGetSize(srcipl), srcipl->depth, 1);
	cvSplit(srcipl, limg, aimg, bbimg, 0);
	//cvAnd(limg, &myresultipl, limg);
	cvAnd(aimg, &myresultipl, aimg);
	cvAnd(bbimg, &myresultipl, bbimg);
	//cvShowImage("a", aimg);
	//waitKey(0);
	/A B的直方图
	int histsize = 256;
	float range[] = { 0, histsize };
	float *ranges[] = { range };
	CvHistogram* hista = cvCreateHist(1, &histsize, CV_HIST_ARRAY, ranges, 1);
	cvCalcHist(&aimg, hista, 0, 0);
	cvNormalizeHist(hista, 1.0);
	CvHistogram* histb = cvCreateHist(1, &histsize, CV_HIST_ARRAY, ranges, 1);
	cvCalcHist(&bbimg, histb, 0, 0);
	cvNormalizeHist(histb, 1.0);
	//my features
	//float features[256*2];
	for (int i = 0; i < histsize; i++)
		features[i] = cvQueryHistValue_1D(hista, i);
	for (int i = histsize; i < 2 * histsize; i++)
		features[i] = cvQueryHistValue_1D(histb, i - histsize);
	//show hist img
	/*
	int scale= 2,height=256;
	IplImage* hist_img= cvCreateImage(cvSize(histsize* scale, height), 8, 3);
	cvZero(hist_img);
	float max_value= 0;
	cvGetMinMaxHistValue(histb, 0, &max_value, 0, 0);
	for (int i = 0; i < histsize; i++)
	{
	float bin_val = cvQueryHistValue_1D(histb, i);
	int intensity = cvRound(bin_val* height / max_value);
	cvRectangle(hist_img, cvPoint(i* scale, height - 1),
	cvPoint((i + 1)* scale - 1, height - intensity), cv::Scalar(255, 255, 255));
	}
	cvShowImage("aimg hist", hist_img);
	waitKey(0);
	*/
	/return features;
}

char filename[100];

void main()
{
	TickMeter tm;
	tm.start();

	/*   1 img test
	IplImage* src_ipl = cvLoadImage("1.bmp");
	vector<Mat> bgrimgs;
	Mat bimg = mypredone(src_ipl, bgrimgs);
	///
	IplImage mybimgipl = bimg;
	IplImage *mydst = cvCreateImage(cvGetSize(src_ipl), 8, 1);
	Mat myresult(mydst, 0);
	myresult = my_contour(mydst, mybimgipl);
	IplImage my_resultipl = myresult;
	/上面是找轮廓得到掩模 
	float myfeature[256 * 2];
	myfeatures(src_ipl, my_resultipl, myfeature);
	*/

	Mat featuremat(1657,256*2, CV_32FC1, cv::Scalar(0));
	//float* finalfeatures[1657];
	for (int i = 1; i <= 1657; i++)
	{
		sprintf(filename, "正常图_压缩\\%d.bmp", i);
		
		IplImage* src_ipl = cvLoadImage(filename);
		vector<Mat> bgrimgs;
		Mat bimg = mypredone(src_ipl, bgrimgs);
		///找轮廓得到掩模 
		IplImage mybimgipl = bimg;
		IplImage *mydst = cvCreateImage(cvGetSize(src_ipl), 8, 1);
		Mat myresult(mydst, 0);
		myresult = my_contour(mydst, mybimgipl);
		IplImage my_resultipl = myresult;
		//LAB图像与掩模与操作 得到掩模中的图像 特征
		float myfeature[256 * 2];
		myfeatures(src_ipl, my_resultipl, myfeature);
		//                          
		//finalfeatures[i - 1] = myfeature;   //每个图片的特征向量的指针放在这个数组中
	    //特征保存为mat   featuremat
		float* datarow = featuremat.ptr<float>(i - 1);
		for (int j = 0; j < featuremat.cols; j++)
			datarow[j] = float(myfeature[j]);
	}
	//label:res
	CvMLData resprimer;
	resprimer.read_csv("label.csv");
	cv::Mat label = cv::Mat(resprimer.get_values(), true);
	//saperate train and test data
	float rate = 0.6;
	Mat traindata = Mat::zeros(int(rate * 1657), 256 * 2, featuremat.type());
	//Mat traindata(int(rate * 1657), 256 * 2, CV_32FC1, cv::Scalar(0));
	Mat trainlabel = Mat::zeros(int(rate * 1657),1, label.type());
	//Mat trainlabel(int(rate * 1657), 1, CV_32SC1, cv::Scalar(0));
	//Mat testdata(1657 - int(rate * 1657), 256 * 2, CV_32FC1, cv::Scalar(0));
	Mat testdata = Mat::zeros(1657 - int(rate * 1657), 256 * 2, featuremat.type());
	//Mat testlabel(1657 - int(rate * 1657), 1, CV_32SC1, cv::Scalar(0));
	Mat testlabel = Mat::zeros(1657 - int(rate * 1657), 1, label.type());
	for (int i = 0; i < featuremat.rows; i++)
	{
		float* datarow = featuremat.ptr<float>(i);
		int* labelrow = label.ptr<int>(i);
		
		if (i < traindata.rows)
		{
			int* trainlabelrow = trainlabel.ptr<int>(i);
			trainlabelrow[0] = int(labelrow[0]);
			float* traindatarow = traindata.ptr<float>(i);
			for (int j = 0; j < featuremat.cols; j++)
				traindatarow[j] = datarow[j];
		}
		else
		{
			int newi = i - traindata.rows;
			int* testlabelrow = testlabel.ptr<int>(newi);
			testlabelrow[0] = labelrow[0];
			float* testdatarow = testdata.ptr<float>(newi);
			for (int j = 0; j < featuremat.cols; j++)
				testdatarow[j] = datarow[j];
		}
	}
	
	cout << "Ready for Training ... " << endl;
	CvSVMParams params;
	params.svm_type = CvSVM::C_SVC;
	CvSVM SVM;
	//
	//params.kernel_type = CvSVM::SIGMOID;
	//params.kernel_type = CvSVM::LINEAR;
	//params.C= 0.1;  
	//params.term_crit = cvTermCriteria(CV_TERMCRIT_ITER, 100, 1e-6);
	//SVM.train(traindata, trainlabel, Mat(), Mat(), params);
	
	params.kernel_type = CvSVM::RBF;
	params.C = 0.1;  //给参数赋初始值  
	params.gamma = 0.01;  //给参数赋初始值  
	params.term_crit = cvTermCriteria(CV_TERMCRIT_ITER, 100, 1e-6);
	//对不用的参数step设为0  
	CvParamGrid p = CvParamGrid(1, 1, 0.0);
	CvParamGrid nuGrid = CvParamGrid(1, 1, 0.0);
	CvParamGrid coeffGrid = CvParamGrid(1, 1, 0.0);
	CvParamGrid degreeGrid = CvParamGrid(1, 1, 0.0);
	CvMat traindata2 = traindata, trainlabel2 = trainlabel;
	CvMat* traindata3 = cvCreateMat(traindata2.rows, traindata2.cols, traindata2.type);
	cvCopy(&traindata2, traindata3);
	CvMat* trainlabel3 = cvCreateMat(trainlabel2.rows, trainlabel2.cols, trainlabel2.type);
	cvCopy(&trainlabel2, trainlabel3);
	SVM.train_auto(traindata3, trainlabel3, NULL, NULL, params, 10, SVM.get_default_grid(CvSVM::C), SVM.get_default_grid(CvSVM::GAMMA), p, nuGrid, coeffGrid, degreeGrid);
	CvSVMParams params_re = SVM.get_params();
	//SVM.save("auto_training_arguments.xml");
	float C = params_re.C;
	float gamma = params_re.gamma;
	printf("\nBest Parms: P=%f, gamma=%f \n", C, gamma);

	///
	cout << "training done!!!prepare for test..." << endl;
	test
	const int numfortest = testdata.rows;
	Mat currentsample;
	currentsample.create(1, 256*2, testdata.type());
	float* outputlabels = new float[numfortest];   //记得delete
	for (int i = 0; i < numfortest; i++)
	{
		float* currentrow = testdata.ptr<float>(i);
		for (int j = 0; j < 256*2; j++)
			currentsample.at<float>(0, j) = currentrow[j];
		float currentoutputs = SVM.predict(currentsample);//必须一个一个样本的进行测试
		outputlabels[i] = currentoutputs;
		//cout << currentoutputs << endl;
	}
	cout << "test done!!!prepare for calculating the accurency..." << endl << endl;
	/calculate whole error 
	int correct = 0;
	float accurency;
	for (int i = 0; i < testlabel.rows; ++i)
	{
		float* p = testlabel.ptr<float>(i);
		//cout << "true label= " << p[0] << " output label= " << outputlabels[i] << endl;
		if (p[0] == outputlabels[i])
			++correct;
	}
	cout << endl;
	accurency = (float)correct / testlabel.rows;
	cout << "whole accurency= " << accurency << endl;
	/calculate the positive sample error and negative sample error
	int alluseless = 0, uselesserror = 0, alluseful = 0, usefulerror = 0;
	float stoneerror = 0, kuangerror = 0;
	//stone error
	for (int i = 0; i < testlabel.rows; ++i)
	{
		float* p = testlabel.ptr<float>(i);
		if (p[0] == (float)0)
		{
			++alluseless;
			if (p[0] != outputlabels[i])
				++uselesserror;
		}
	}
	cout << "alluseless=" << alluseless << "  " << "uselesserror="<< uselesserror << endl;
	stoneerror = (float)uselesserror / alluseless;
	cout << " stone error= " << stoneerror << endl;
	//kuang  error
	for (int i = 0; i <testlabel.rows; ++i)
	{
		float* p = testlabel.ptr<float>(i);
		if (p[0] == (float)1)
		{
			++alluseful;
			if (p[0] != outputlabels[i])
				++usefulerror;
		}
	}
	cout << " alluseful=" << alluseful << "  " << "usefulerror=" << usefulerror << endl;
	kuangerror = (float)usefulerror / alluseful;
	cout << " kuang error= " << kuangerror << endl;
	
	delete[] outputlabels;
	
	
	tm.stop();
	cout << "count=" << tm.getCounter() << ",process time=" << tm.getTimeMilli() << endl;
}
整体是：

 首先提取轮廓 作为一个掩模 得到原图掩模处的图像 转化为Lab空间 求其a和b图的直方图 统计 作为这幅图的特征 然后用分类器去判别  我用的是svm RBF核 自动寻优参数 994张训练 663张测试 然而准确率只有63,.8%  。。。。。。。。

元气少女缘结神
关注
  • 0
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
SVM(支持向量机)实现数据的三分类
01-12
SVM(支持向量机)是模式识别和机器学习中的重要的数据分类的方法.本代码可以实现三分类.
自己训练SVM分类器进行HOG行人检测
热门推荐
Why So Serious?
11-13 5万+
正样本来源是INRIA数据集中的96*160大小的人体图片，使用时上下左右都去掉16个像素，截取中间的64*128大小的人体。 负样本是从不包含人体的图片中随机裁取的，大小同样是64*128。 SVM使用的是OpenCV自带的CvSVM类。 首先计算正负样本图像的HOG描述子，组成一个特征向量矩阵，对应的要有一个指定每个特征向量的类别的类标向量，输入SVM中进行训练。 训练好的SVM分类器保存为XML文件，然后根据其中的支持向量和参数生成OpenCV中的HOG描述子可用的检测子参数，再调用OpenCV中的多
手写支持向量机(SVM)实例之——鸢尾花卉数据集分割
最新发布
weixin_42973210的博客
06-01 236
鸢尾花（iris）是单子叶百合目花卉，是一种比较常见的花，可能不经意间你就能在某个公园里碰见它，而且鸢尾花的品种较多。该数据集是机器学习领域相当经典的一个小数据集，仅有150行，5列。该数据集的四个特征属性的取值都是数值型的，他们具有相同的量纲，不需要你做任何标准化的处理，第五列为通过前面四列所确定的鸢尾花所属的类别名称。
SVM 用于将数据分类为两分类或多分类（Matlab代码实现）
weixin_46039719的博客
12-04 6509
本文旨在帮助可视化学习的分类器，在训练非线性 C-SVM 以将二维数据（2 个特征）分类为 2 个或更多类时。C = Inf 给出硬边距分类器，而 C < Inf 给出 1 范数软边距分类器的情况。MATLAB 的 quadprog 用于求解对偶变量 a。求解器设置为使用内点方法。高斯径向基函数 （RBF） 核用于生成非线性边界。在二进制分类文件 （SVMtrial.m） 中：有 6 个不同的训练集可供使用。输出是分类器的 3D 网格图和支持向量的数量。二元分类的数据集：（1） 典型。
SVM分类
Ray_Songaaa的博客
05-19 2073
SVM分类1.LDA+鸢尾花2.LDA+月亮3.K-means+鸢尾花4.K-means+月亮5.SVM+鸢尾花6.SVM+月亮 对鸢尾花数据集和月亮数据集，分别采用线性LDA、k-means和SVM算法进行二分类可视化分析。 1.LDA+鸢尾花 import numpy as np import matplotlib.pyplot as plt from sklearn import datasets def LDA(X, y): #根据y等于0或1分类 X1 = np.array([X[
数据挖掘实验：关于SVM的数据分类算法（Python实现）
ljn1124的博客
06-25 1万+
目录 前言 一、思路 二、实现代码 1.安装sklearn库 2.引入库 3.具体代码 三、实验结果 总结 前言 本文是有关SVM（支持向量机）的数据分类算法，使用python实现，基于sklearn库。 一、思路 老师给的数据是690维的带标签的高维数据，标签为0和1，分别代表正负标签。首先需要处理一下数据集，将训练集、测试集的数据和标签分别存在列表中。然后导入sklearn库，调用其中svm函数，定义模型，训练、测试，计算一些反映结果的指标（recall、precision）。.
Iris_svm分类iris_iris_python_SVM_数据分析_
10-03
在本项目中，我们主要探讨的是使用Python编程语言对经典的鸢尾花数据集（Iris dataset）进行分析，特别是利用支持向量机（SVM，Support Vector Machine）进行线性分类。鸢尾花数据集是机器学习领域常用的一个多类...
SVM算法对MNIST数据集分类
12-24
代码使用matlab编写，压缩包中包含MNIST数据集及其读取函数、SVM算法实现和ReadMe.txt。 SVM算法中使用了PCA降维处理数据减少运行时间，但是由于使用的SMO算法较为原始，运行速度仍然较慢。由于实现未经过任何优化，...
SVM分类_SVM二分类_SVM分类_SVM数据分类_
10-02
在本场景中，我们将重点讨论SVM在二分类问题中的应用，以及如何利用SVM对数据进行有效分类。 一、SVM基本概念 SVM的核心思想是找到一个最优超平面，这个超平面能够最大程度地将两类样本分开。超平面可以看作是特征...
基于SVM鸢尾花分类数据集
06-16
一组鸢尾花数据，每一行数据由 4 个特征值及一个目标值组成。4 个特征值分别为：萼片长度、萼片宽度、花瓣长度、花瓣宽度。目标值为三种不同类别的鸢尾，分别为：Iris Setosa、Iris Versicolour、Iris Virginica
SVM.zip_SVM分类_数据识别svm
09-23
在这个章节中，用户可能会学到如何加载和预处理人脸数据，设置SVM的参数（如核函数类型、C值、γ值等），以及如何评估模型性能（如准确率、召回率、F1分数等）。 在实际使用这个SVM分类器时，需要注意以下几点： 1....
基于svm的图像分类数据集
04-17
SVM是用来解决分类问题的，如果解决两个变量的分类问题，可以理解成用一条直线把点给分开，完成分类
基于SVM的数据分类预测——意大利葡萄酒种类识别
06-23
matlab程序，基于SVM的数据分类预测——意大利葡萄酒种类识别，里面一个.m文件，一个.mat数据集，直接可以使用。
SVM实现MNIST数据集分类
01-19
本代码为matlab实现的支持向量机模式识别算法，对MNIST数据集进行三种样本分类，如果电脑内存够大，可以实现更多的类别分类，另外exclass是对随机的两个样本分类，也可以参考，exmuticlassall为对MNIST数据集分类，注释掉的代码也可以实现随即三样本分类并作图。
基于颜色直方图采用libsvm进行分类
09-10
题目基本要求是对图像能进行自动分类，先构建图库，在百度上搜索就行，但是要注意维数，别太高，否则一般的笔记本受不了。然后对图像进行特征提取，提取颜色直方图特征。再将特征转换为多维数组 然后按照libsvm的各种要求进行设置就基本ok，在论文中有详细的论述。
SVM分类算法
words8的博客
08-28 1万+
1.基本概念 支持向量机（SVM）的基本模型是在特征空间上找到最佳的分离超平面使得训练集上正负样本间隔最大。SVM是用来解决二分类问题的有监督学习算法，在引入了核方法之后SVM也可以用来解决非线性问题。 实际应用中一般要解决觉得是多分类问题，SVM也可以用了来解决多分类，可以通过多个二类支持向量机的组合来解决。主要有一对多组合模式、一对一组合模式等。 一般SVM有下面三种： 硬间隔支持向量机（线性可分支持向量机）：当训练数据线性可分时，可通过硬间隔最大化学得一个线性可分支持向量机。 软间隔支持向量机：当训
分类问题常用算法——SVM概述
qq_38100666的博客
02-08 2253
SVM（支持向量机）是一种分类模型，作为机器学习中很基础的一个知识点，本文将对其进行一个较简洁并且容易理解的描述，也是自己的一个复习，若有疏漏，请多指正。
python使用svm支持向量机对数据进行分类
LDC，公众号【轻松学编程】
10-30 598
python 使用svm支持向量机对数据进行分类
SVM自动分类的简单使用
vsdvscs的博客
05-11 928
svm自动分类器的简单版使用 今天老师布置了一个简单的数据预测方法的学习在这里记录一下（感觉网上现在缺少一些这些很基础的简单文本预测希望能帮到大家dogimag,dogimag） 1.老师首先给了我们两个csv文件一个是学习数据，一个是需要预测的数据： 需要预测的数据： 需要进行学习的数据： 声明（这里使用python实现不得不说python做这种预测使得高级是真的蛮有趣的） 首先一开始整个人是懵掉的（因为在之前老师只是讲了一些方法，大家都知道上课总会有忍不住拿手机的冲动） 所以先根据
作业09a:使用svm对iris数据集分类
05-15
SVM（支持向量机）是一种基于统计学习理论的二元分类模型，其主要思想是通过构造一个超平面，将不同类别的数据点分开。数字化的iris鸢尾花数据集包含三个类别的花，每个类别分别有50个样本。我们可以使用SVM算法来预测花的类别。 在使用SVM对iris数据集分类的过程中，我们需要先进行数据的预处理。我们可以将花的特征值分别放到不同的矩阵中，然后将花的类别转化为数字，方便训练模型。接着，我们可以将数据集分为训练集和测试集，用训练集训练SVM模型，得出决策边界和支持向量等信息。最后，我们可以使用测试集进行测试，评估模型预测性能。 在实际应用中，我们可以通过调整SVM算法中的参数，如C值、核函数等来优化模型的预测性能。此外，对于多种算法，我们可以使用交叉验证等方法来选择最佳的分类算法。 总之，使用SVM分类iris数据集是一个典型的机器学习问题，通过对数据的预处理、模型训练和测试等步骤，我们可以得到较为准确的分类结果。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

元气少女缘结神

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值