1. 简单二分类

clear,clc

%% 二分类
%训练数据20×2,20行代表20个训练样本点，第一列代表横坐标，第二列纵坐标
Train_Data =[-3 0;4 0;4 -2;3 -3;-3 -2;1 -4;-3 -4;0 1;-1 0;2 2;3 3;-2 -1;-4.5 -4;2 -1;5 -4;-2 2;-2 -3;0 2;1 -2;2 0];
%Group 20 x 1,20行代表训练数据对应点属于哪一类(1类,-1类)
Train_labels =[1 -1 -1 -1 1 -1 1 1 1 -1 -1 1 1 -1 -1 1 1 1 -1 -1]';
TestData = [3 -1;3 1;-2 1;-1 -2;2 -3;-3 -3];%测试数据
classifier  = fitcsvm(Train_Data,Train_labels); %train
test_labels  = predict(classifier ,TestData); % test

这里 test_labels 就是最后的分类结果啦，大家可以按照这个格式对自己的数据进行修改

2. 多分类（不调用工具箱）

因为

%% 多分类
TrainingSet=[ 1 10;2 20;3 30;4 40;5 50;6 66;3 30;4.1 42];%训练数据
TestSet=[3 34; 1 14; 2.2 25; 6.2 63];%测试数据
GroupTrain=[1;1;2;2;3;3;2;2];%训练标签
results =my_MultiSvm(TrainingSet, GroupTrain, TestSet);
disp('multi class problem');
disp(results);

results为最终的分类结果，上述中有用到 my_MultiSvm.m() 函数，以下是my_MultiSvm.m函数的全部内容

function [y_predict,models] = my_MultiSvm(X_train, y_train, X_test)
% multi svm
% one vs all 模型
% Input:
% X_train: n*m矩阵 n为训练集样本数 m为特征数
% y_train: n*1向量 为训练集label，支持任意多种类
% X_test: n*m矩阵 n为测试集样本数 m为特征数
% Output:
% y_predict: n*1向量 测试集的预测结果
% 
% Copyright(c) lihaoyang 2020
%

    y_labels = unique(y_train);
    n_class = size(y_labels, 1);
    models = cell(n_class, 1);
    % 训练n个模型
    for i = 1:n_class
        class_i_place = find(y_train == y_labels(i));
        svm_train_x = X_train(class_i_place,:);
        sample_num = numel(class_i_place);
        class_others = find(y_train ~= y_labels(i));
        randp = randperm(numel(class_others));
        svm_train_minus = randp(1:sample_num)';
        svm_train_x = [svm_train_x; X_train(svm_train_minus,:)];
        svm_train_y = [ones(sample_num, 1); -1*ones(sample_num, 1)];
        disp(['生成模型：', num2str(i)])
        models{i} = fitcsvm(svm_train_x, svm_train_y);
    end
    test_num = size(X_test, 1);
    y_predict = zeros(test_num, 1);
    % 对每条数据，n个模型分别进行预测，选择label为1且概率最大的一个作为预测类别
    for i = 1:test_num
        if mod(i, 100) == 0
            disp(['预测个数：', num2str(i)])
        end
        bagging = zeros(n_class, 1);
        for j = 1:n_class
            model = models{j};
            [label, rat] = predict(model, X_test(i,:));
            bagging(j) = bagging(j) + rat(2);
        end
        [maxn, maxp] = max(bagging);
        y_predict(i) = y_labels(maxp);
    end
end

3.多分类(调用libsvm工具箱)

以下代码是调用matlab工具箱libsvm的一种方法

TrainingSet=[ 1 10;2 20;3 30;4 40;5 50;6 66;3 30;4.1 42];%训练数据
TestSet=[3 34; 1 14; 2.2 25; 6.2 63];%测试数据
GroupTrain=[1;1;2;2;3;3;2;2];%训练标签
GroupTest=[1;2;1;3];%测试标签

%svm分类
model = svmtrain(GroupTrain,TrainingSet);
% SVM网络预测
[predict_label] = svmpredict(GroupTest,TestSet,model);

之所以放到最后，是因为需要在matlab安装libsvm的工具箱，具体方法可参看此链接在Matlab中安装LibSVM工具箱

利用MATLAB实现SVM分类

%% LibSVM
clc;clear;close all;
%% 加载文件
[Iris1,Iris2,Iris3,Iris4,IrisClass]=textread('iris.data','%f%f%f%f%s','delimiter',','); 
Wine=load('wine.data'); % 仅读数字
Abalone=importdata('abalone.data');%既可以读取数据又可以读取字符
%% 数据预处理
% Iris数据预处理
Iris_all=[Iris1,Iris2,Iris3,Iris4];
Iris_class = zeros(1, 150);
for i = 1: size(IrisClass,1)
             if (strcmp(IrisClass(i), 'Iris-setosa' ))
               Iris_class(1,i) = 1;     
            elseif(strcmp(IrisClass(i), 'Iris-versicolor') )
               Iris_class(1,i) = 2;
            else
               Iris_class(1,i) = 3;  
             end 
end
Iris_class=Iris_class(:);
%------数据类别放在第一列-----%
Iris=[Iris_class Iris_all];
% Wine数据预处理
Wine_class=Wine(:,1);
Wine_data=Wine(:,2:14);
% Abalone数据预处理
Abalone_gendar = zeros(1, 4177);
for i = 1: size(Abalone.textdata,1)
             if (strcmp(Abalone.textdata(i), 'F' ))
               Abalone_gendar(1,i) = 1;     
            elseif(strcmp(Abalone.textdata(i), 'M') )
               Abalone_gendar(1,i) = 2;
            else
               Abalone_gendar(1,i) = 3;  
             end 
end
Abalone_gendar = Abalone_gendar(:);
Abalone_Data=Abalone.data(:,1:8);
Abalone_class=Abalone_gendar;
Abalone_all=[Abalone_class Abalone_Data];
% 分割部分
times=2;
%% -----Iris样本的选取-----
% 随机选取
Data = Iris;%创建随机矩阵样本
indices = crossvalind('Kfold', size(Data,1), times);%将数据样本随机分割为3部分
for i = 1:times %循环3次，分别取出第i部分作为测试样本，其余两部分作为训练样本
    test = (indices == i);
    train = ~test;
    trainData = Data(train, :);
    testData = Data(test, :);
end
train_1=trainData(:,2:5);
train_label=trainData(:,1);
test_1=testData(:,2:5);
test_label=testData(:,1);
% 分类选取(先分类再随机再组合)
Data = Iris;%创建随机矩阵样本
% 第一类数据
Iris_Index1=logical(Iris(:,1)==1);
Iris_class1=Data(Iris_Index1==1,:);
indices = crossvalind('Kfold', size(Iris_class1,1), times);
for i = 1:times 
    test = (indices == i);
    train = ~test;
    trainData1 = Iris_class1(train, :);
    testData1 = Iris_class1(test, :);
end
% 第二类数据
Iris_Index2=logical(Iris(:,1)==2);
Iris_class2=Data(Iris_Index2==1,:);
indices = crossvalind('Kfold', size(Iris_class2,1), times);
for i = 1:times 
    test = (indices == i);
    train = ~test;
    trainData2 = Iris_class2(train, :);
    testData2 = Iris_class2(test, :);
end
% 第三类数据
Iris_Index3=logical(Iris(:,1)==3);
Iris_class3=Data(Iris_Index3==1,:);
indices = crossvalind('Kfold', size(Iris_class3,1), times);
for i = 1:times 
    test = (indices == i);
    train = ~test;
    trainData3 = Iris_class3(train, :);
    testData3 = Iris_class3(test, :);
end
trainData_all=[trainData1;trainData2;trainData3];
testData_all=[testData1;testData2;testData3];
train_cross=trainData_all(:,2:5);
train_label_cross=trainData_all(:,1);
test_cross=testData_all(:,2:5);
test_label_cross=testData_all(:,1);
%% -------Wine样本的选取------
% 随机选取
times=10;
Data = Wine;%创建随机矩阵样本
indices = crossvalind('Kfold', size(Data,1), times);
for i = 1:times 
    test = (indices == i);
    train = ~test;
    trainData = Data(train, :);
    testData = Data(test, :);
end
train_1=trainData(:,2:14);
train_label=trainData(:,1);
test_1=testData(:,2:14);
test_label=testData(:,1);
% 分类选取(先分类再随机再组合)
Data = Wine;%创建随机矩阵样本
% 第一类数据
Wine_Index1=logical(Wine(:,1)==1);
Wine_class1=Data(Wine_Index1==1,:);
indices = crossvalind('Kfold', size(Wine_class1,1), times);
for i = 1:times 
    test = (indices == i);
    train = ~test;
    trainData1 = Wine_class1(train, :);
    testData1 = Wine_class1(test, :);
end
% 第二类数据
Wine_Index2=logical(Wine(:,1)==2);
Wine_class2=Data(Wine_Index2==1,:);
indices = crossvalind('Kfold', size(Wine_class2,1), times);
for i = 1:times 
    test = (indices == i);
    train = ~test;
    trainData2 = Wine_class2(train, :);
    testData2 = Wine_class2(test, :);
end
% 第三类数据
Wine_Index3=logical(Wine(:,1)==3);
Wine_class3=Data(Wine_Index3==1,:);
indices = crossvalind('Kfold', size(Wine_class3,1), times);
for i = 1:times 
    test = (indices == i);
    train = ~test;
    trainData3 = Wine_class3(train, :);
    testData3 = Wine_class3(test, :);
end
trainData_all=[trainData1;trainData2;trainData3];
testData_all=[testData1;testData2;testData3];
train_cross=trainData_all(:,2:14);
train_label_cross=trainData_all(:,1);
test_cross=testData_all(:,2:14);
test_label_cross=testData_all(:,1);
% 训练
% 随机分类训练
cmd1 =['-t  1']; %线性核函数
cmd2 =['-t  1 –c  100']; %线性核函数
model = svmtrain(train_label, train_1, cmd2);
svmpredict(test_label,test_1,model);
% 按类别随机分类训练
cmd1 =['-t  1']; %线性核函数
cmd2 =['-t  1 –c  100']; %线性核函数
model = svmtrain(train_label_cross, train_cross, cmd1);
svmpredict(test_label_cross,test_cross,model);
% 换核函数
cmd1 =['-t  1']; %线性核函数
cmd2 =['-t  1 –c  100']; %线性核函数
model = svmtrain(train_label_cross, train_cross, cmd2);
svmpredict(test_label_cross,test_cross,model);
%% -----Abalone样本的选取-----
% 对于分布不均匀样本的随机选取方法
% 随机选取
times=10;
Data = Abalone_all;%创建随机矩阵样本
indices = crossvalind('Kfold', size(Data,1), times);
for i = 1:times 
    test = (indices == i);
    train = ~test;
    trainData = Data(train, :);
    testData = Data(test, :);
end
train_1=trainData(:,2:9);
train_label=trainData(:,1);
test_1=testData(:,2:9);
test_label=testData(:,1);
% 分类选取(先分类再随机再组合)
Data = Abalone_all;%创建随机矩阵样本
% 第一类数据
Abalone_Index1=logical(Abalone_all(:,1)==1);
Abalone_class1=Data(Abalone_Index1==1,:);
indices = crossvalind('Kfold', size(Abalone_class1,1),times);
for i = 1:times 
    test = (indices == i);
    train = ~test;
    trainData1 = Abalone_class1(train, :);
    testData1 = Abalone_class1(test, :);
end
% 第二类数据
Abalone_Index2=logical(Abalone_all(:,1)==2);
Abalone_class2=Data(Abalone_Index2==1,:);
indices = crossvalind('Kfold', size(Abalone_class2,1), times);
for i = 1:times 
    test = (indices == i);
    train = ~test;
    trainData2 = Abalone_class2(train, :);
    testData2 = Abalone_class2(test, :);
end
% 第三类数据
Abalone_Index3=logical(Abalone_all(:,1)==3);
Abalone_class3=Data(Abalone_Index3==1,:);
indices = crossvalind('Kfold', size(Abalone_class3,1), times);
for i = 1:times 
    test = (indices == i);
    train = ~test;
    trainData3 = Abalone_class3(train, :);
    testData3 = Abalone_class3(test, :);
end
trainData_all=[trainData1;trainData2;trainData3];
testData_all=[testData1;testData2;testData3];
train_cross=trainData_all(:,2:9);
train_label_cross=trainData_all(:,1);
test_cross=testData_all(:,2:9);
test_label_cross=testData_all(:,1);
% % 随机分类训练
% cmd1 =['-t  1']; %线性核函数
% cmd2 =['-t  1 –c  100']; %线性核函数
% model = svmtrain(train_label, train_1, cmd1);
% svmpredict(test_label,test_1,model);
% 按类别随机分类训练
cmd1 =['-t  1']; %线性核函数
cmd2 =['-t  1 –c  100']; %线性核函数
model = svmtrain(train_label_cross, train_cross, cmd1);
svmpredict(test_label_cross,test_cross,model);
% 按类别随机分类训练
cmd1 =['-t  1']; %线性核函数
cmd2 =['-t  1 –c  100']; %线性核函数
model = svmtrain(train_label_cross, train_cross, cmd2);
svmpredict(test_label_cross,test_cross,model);
%% 训练
% 随机分类训练
cmd1 =['-t  1']; %线性核函数
cmd2 =['-t  1 –c  100']; %线性核函数
model = svmtrain(train_label, train_1, cmd1);
svmpredict(test_label,test_1,model);
% 按类别随机分类训练
cmd1 =['-t  1']; %线性核函数
cmd2 =['-t  1 –c  100']; %线性核函数
model = svmtrain(train_label_cross, train_cross, cmd1);
svmpredict(test_label_cross,test_cross,model);

%% 换样本进行操作

今天讲一讲支持向量机（svm）二分类的用法。

1 原理

具体的推导笔者就不说了，可以自行百度。SVM本质就是找出最小类间距离并使其最大化。分离面称作超平面。核函数本质上决定了它的分类精度，包括多项式核（polynomial kernel），径向基函数核（RBF kernel），拉普拉斯核（Laplacian kernel），Sigmoid核（Sigmoid kernel）。svm有很多类型。libsvm是其中使用最为广泛的。现在matlab有自带的svm包，但是只能用于二分类，如果需要三分类或者多分类，则要使用libsvm，必须下载其软件包。

下载链接：https://www.csie.ntu.edu.tw/~cjlin/libsvm/#matlab；

安装教程：https://blog.csdn.net/cherry4500/article/details/71257973

libsvm实例：https://blog.csdn.net/weixin_42296976/article/details/81160114

2 matlab自带的svm函数

主要是svmtrain和svmclassify函数。可以在svmtrain中选择核函数类型，曲线拟合程度（c与sigma参数的选择）等。

贴参数选择实例：https://blog.csdn.net/red_stone1/article/details/54313821

https://blog.csdn.net/weiqiwu1986/article/details/56056860

3 实例

我这个是对小麦白粉病和条锈病做分类。

function [accuracy,predict_group] =FITCSVM_classification(training,training_group,test,test_group)
%training数据行是样本数目，列是样本特征数目（维数），此处我的每个样本特征是40维。训练样本60个。
%group 分为0和1,1正例，0反例,行是样本数目，列是标签，就一列。

SVMStruct=svmtrain(training,training_group,'kernel_function','linear','showplot',true);%FITCSVM
% sigma=0.5;
% sigma=3;%sigma越小曲线越复杂，越容易过拟合，对测试集的预测越不准
% SVMStruct=svmtrain(training,training_group,'kernel_function','rbf','rbf_sigma',...
%      sigma,'showplot',true);
% C = 1;%c越大曲线越复杂，越容易过拟合，对测试集的预测越不准，也不是绝对。sigma的影响更普遍。
% SVMStruct = svmtrain(training,training_group,'kernel_function','rbf','boxconstraint',...
%     C,'showplot',true);
%样本的行是样本数目，列是样本特征数，与training数据一致
predict_group=svmclassify(SVMStruct,test,'showplot',true);%ClassificationSVM，默认是线性分类函数
accuracy = (1-sum(abs(predict_group-test_group))/length(test_group))*100;
figure(6)
a = randperm(30);%测试集30个样本
b = sort(a);
plot(b,predict_group,'r*');
hold on
plot(b,test_group,'go');%,'MarkerFaceColor','g'
title('SVM分类结果')
%加一个预测标签和测试集标签的回归分析图

%超过3维分类超平面就无法画出。
%xlswrite('output.xlsx',group)

结果图如下所示：

红色*表示预测标签，绿色圆表示真实的标签。用linear能达到93.33%的精度。