一、SVM介绍

分类器

分类器是一种计算机程序。

他的设计目标是在通过学习后，可自动将数据分到已知类别。

平面线性分类器

一个简单的分类问题，如图有一些圆圈和一些正方形，如何找一条最优的直线将他们分开？

A seperation example

我们可以找到很多种方法画出这条直线，但怎样的直线才是最优的呢？

距离样本太近的直线不是最优的，因为这样的直线对噪声敏感度高，泛化性较差。因此我们的目标是找到一条直线，离最近的点距离最远。

怎么寻找距离最远的直线？枚举所有直线，然后计算其样本最小距离？这样显然不是一个好办法，这将产生大量的计算开销。

我们利用另一种方法，对直线的正负偏移量1，这样就产生了一个区域（下图的Maximum margin覆盖的区域），区域边界上的点到直线的距离是固定的，现在的问题是最近的点是否刚好在边界上或者在边界外。

The Optimal hyperplane

还记得点到线的公式么？

对于直线Ax＋By＋C＝0，点（x₀, y₀）到直线的距离：

　　distance = |Ax₀+By₀+C| / (A² + B²)^1/2

那么区域边缘到直线的距离：

　　distance = (|Ax+By+C| + 1)/ (A² + B²)^1/2 = 1/ (A² + B²)^1/2。

并需要满足对于所有样本类别y_i满足：yi (Ax+By+C) > = 1，也就是所有样本都不在该区域以内。

于是我们可以找到适当的A、B、C，从而得到：

　　Maximum margin = 2/ (A² + B²)^1/2。

超平面推广

同理，我们将这一定理推广到任意维度。其超平面表达式为：

　　　　 $f(x) = \beta_{0} + \beta^{T} x,$

一维是线、二维是面、三维是体……四维呢？五维呢？好吧统称超平面吧……

其中 $\beta$ 叫做 权重向量 ， $\beta_{0}$ 叫做 偏置向量。

用这种表达式来表达线Ax+By+C = 0的话，可以这么表示：

　　　　f(x) = (C, 0) + (A, B)^T (x, y);

其中(C, 0) 是偏置向量 $\beta_{0}$ ，(A, B)是权重向量 $\beta$ 。

由于最优超平面可以有很多种表达方式，我们定义：

　　　　β₀+ β^Tx = 0，

为最优超平面表达式。于是我们可以得到他的Maximum margin区域边界表达式应该为：

　　　　 $|\beta_{0} + \beta^{T} x| = 1$

我们称在这边界上的点为：支持向量（Supper Vector）。

因为点到超平面距离公式为：

　　　　 $\mathrm{distance} = \frac{|\beta_{0} + \beta^{T} x|}{||\beta||}.$

在边界上，即支持向量到超平面距离：

　　　　 $\mathrm{distance}_{\text{ support vectors}} = \frac{|\beta_{0} + \beta^{T} x|}{||\beta||} = \frac{1}{||\beta||}.$

所以Maximum margin为两倍距离，即：

　　　　 $M = \frac{2}{||\beta||}$

将M求倒数1/M 则可将求最大转换成求最小。于是有：

　　　　 $\min_{\beta, \beta_{0}} L(\beta) = \frac{1}{2}||\beta||^{2} \text{ subject to } y_{i}(\beta^{T} x_{i} + \beta_{0}) \geq 1 \text{ } \forall i,$

其中 $y_{i}$ 表示样本的类别标记。

这是一个拉格朗日优化问题，可以通过拉格朗日乘数法得到最优超平面的权重向量 $\beta$ 和偏置 $\beta_{0}$ 。

什么是SVM

支持向量机 (SVM) 是一个类分类器，正式的定义是一个能够将不同类样本在样本空间分隔的超平面。换句话说，给定一些标记好的训练样本（监督式学习），SVM算法输出一个最优化的分隔超平面。

1995年Cortes和Vapnik于首先提出SVM，它在解决小样本、非线性及高维模式识别中表现出许多特有的优势，并能够推广应用到函数拟合等其他机器学习问题中。

使用SVM

#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/ml/ml.hpp>

using namespace cv;

int main()
{
    // 用于保存可视化数据的矩阵
    int width = 512, height = 512;
    Mat image = Mat::zeros(height, width, CV_8UC3);

    // 创建一些训练样本
    float labels[4] = {1.0, -1.0, -1.0, -1.0};
    Mat labelsMat(3, 1, CV_32FC1, labels);

    float trainingData[4][2] = { {501, 10}, {255, 10}, {501, 255}, {10, 501} };
    Mat trainingDataMat(3, 2, CV_32FC1, trainingData);

    // 设置SVM参数
    CvSVMParams params;
    params.svm_type    = CvSVM::C_SVC;
    params.kernel_type = CvSVM::LINEAR;
    params.term_crit   = cvTermCriteria(CV_TERMCRIT_ITER, 100, 1e-6);

    // 对SVM进行训练
    CvSVM SVM;
    SVM.train(trainingDataMat, labelsMat, Mat(), Mat(), params);
    
    Vec3b green(0,255,0), blue (255,0,0);
    // 将SVM断定的分划区域绘制出来
    for (int i = 0; i < image.rows; ++i)
        for (int j = 0; j < image.cols; ++j)
        {
            Mat sampleMat = (Mat_<float>(1,2) << i,j);
            float response = SVM.predict(sampleMat);

            if (response == 1)
                image.at<Vec3b>(j, i)  = green;
            else if (response == -1) 
                image.at<Vec3b>(j, i)  = blue;
        }

    // 绘制训练数据点
    int thickness = -1;
    int lineType = 8;
    circle( image, Point(501,  10), 5, Scalar(  0,   0,   0), thickness, lineType);
    circle( image, Point(255,  10), 5, Scalar(255, 255, 255), thickness, lineType);
    circle( image, Point(501, 255), 5, Scalar(255, 255, 255), thickness, lineType);
    circle( image, Point( 10, 501), 5, Scalar(255, 255, 255), thickness, lineType);

    // 绘制支持向量
    thickness = 2;
    lineType  = 8;
    int c     = SVM.get_support_vector_count();

    for (int i = 0; i < c; ++i)
    {
        const float* v = SVM.get_support_vector(i);
        circle( image,  Point( (int) v[0], (int) v[1]),   6,  Scalar(128, 128, 128), thickness, lineType);
    }

    imwrite("result.png", image);       

    imshow("简单SVM分类", image); 
    waitKey(0);

}

建立训练样本

这里通过Mat构造函数，建立了一个简单的训练样本。

//建立一个标签矩阵
float labels[4] = {1.0, -1.0, -1.0, -1.0};
Mat labelsMat(3, 1, CV_32FC1, labels);

//建立一个训练样本矩阵
float trainingData[4][2] = { {501, 10}, {255, 10}, {501, 255}, {10, 501} };
Mat trainingDataMat(3, 2, CV_32FC1, trainingData);

由于CvSVM::train 要求样本数据存储在float 类型的Mat中，所以建立了float类型的Mat样本。

设置SVM参数

struct CvSVMParams

SVM 训练参数结构。

该结构必须被初始化后，传给CvSVM。

CvSVMParams::CvSVMParams

构造函数

C++: CvSVMParams::CvSVMParams()
C++: CvSVMParams::CvSVMParams(int svm_type, int kernel_type, double degree, double gamma, double coef0, double Cvalue, double nu, double p, CvMat* class_weights, CvTermCriteria term_crit)

参数

svm_type –
指定SVM的类型，下面是可能的取值：

CvSVM::C_SVC C类支持向量分类机。 n类分组 (n $\geq$ 2)，允许用异常值惩罚因子C进行不完全分类。

CvSVM::NU_SVC $\nu$ 类支持向量分类机。n类似然不完全分类的分类器。参数为 $\nu$ 取代C（其值在区间【0，1】中，nu越大，决策边界越平滑）。

CvSVM::ONE_CLASS 单分类器，所有的训练数据提取自同一个类里，然后SVM建立了一个分界线以分割该类在特征空间中所占区域和其它类在特征空间中所占区域。

CvSVM::EPS_SVR $\epsilon$ 类支持向量回归机。训练集中的特征向量和拟合出来的超平面的距离需要小于p。异常值惩罚因子C被采用。

CvSVM::NU_SVR $\nu$ 类支持向量回归机。 $\nu$ 代替了 p。

可从 [LibSVM] 获取更多细节。

kernel_type –
SVM的内核类型，下面是可能的取值：

CvSVM::LINEAR 线性内核。没有任何向映射至高维空间，线性区分（或回归）在原始特征空间中被完成，这是最快的选择。 $K(x_i, x_j) = x_i^T x_j$ .

CvSVM::POLY 多项式内核： $K(x_i, x_j) = (\gamma x_i^T x_j + coef0)^{degree}, \gamma > 0$ .

CvSVM::RBF 基于径向的函数，对于大多数情况都是一个较好的选择： $K(x_i, x_j) = e^{-\gamma ||x_i - x_j||^2}, \gamma > 0$ .

CvSVM::SIGMOID Sigmoid函数内核： $K(x_i, x_j) = \tanh(\gamma x_i^T x_j + coef0)$ .

degree – 内核函数（POLY）的参数degree。

gamma – 内核函数（POLY/ RBF/ SIGMOID）的参数 $\gamma$ 。

coef0 – 内核函数（POLY/ SIGMOID）的参数coef0。

Cvalue – SVM类型（C_SVC/ EPS_SVR/ NU_SVR）的参数C。

nu – SVM类型（NU_SVC/ ONE_CLASS/ NU_SVR）的参数 $\nu$ 。

p – SVM类型（EPS_SVR）的参数 $\epsilon$ 。

class_weights – C_SVC中的可选权重，赋给指定的类，乘以C以后变成 $class\_weights_i * C$ 。所以这些权重影响不同类别的错误分类惩罚项。权重越大，某一类别的误分类数据的惩罚项就越大。

term_crit – SVM的迭代训练过程的中止条件，解决部分受约束二次最优问题。您可以指定的公差和/或最大迭代次数。

默认的构造函数初始化有以下值：
CvSVMParams::CvSVMParams() :
    svm_type(CvSVM::C_SVC), kernel_type(CvSVM::RBF), degree(0),
    gamma(1), coef0(0), C(1), nu(0), p(0), class_weights(0)
{
    term_crit = cvTermCriteria( CV_TERMCRIT_ITER+CV_TERMCRIT_EPS, 1000, FLT_EPSILON );
}

参数	svm_type – 指定SVM的类型，下面是可能的取值： CvSVM::C_SVC C类支持向量分类机。 n类分组 (`n` $\geq$ 2)，允许用异常值惩罚因子C进行不完全分类。 CvSVM::NU_SVC $\nu$ 类支持向量分类机。n类似然不完全分类的分类器。参数为 $\nu$ 取代C（其值在区间【0，1】中，nu越大，决策边界越平滑）。 CvSVM::ONE_CLASS 单分类器，所有的训练数据提取自同一个类里，然后SVM建立了一个分界线以分割该类在特征空间中所占区域和其它类在特征空间中所占区域。 CvSVM::EPS_SVR $\epsilon$ 类支持向量回归机。训练集中的特征向量和拟合出来的超平面的距离需要小于p。异常值惩罚因子C被采用。 CvSVM::NU_SVR $\nu$ 类支持向量回归机。 $\nu$ 代替了 `p`。可从 [LibSVM] 获取更多细节。 kernel_type – SVM的内核类型，下面是可能的取值： CvSVM::LINEAR 线性内核。没有任何向映射至高维空间，线性区分（或回归）在原始特征空间中被完成，这是最快的选择。 $K(x_i, x_j) = x_i^T x_j$ . CvSVM::POLY 多项式内核： $K(x_i, x_j) = (\gamma x_i^T x_j + coef0)^{degree}, \gamma > 0$ . CvSVM::RBF 基于径向的函数，对于大多数情况都是一个较好的选择： $K(x_i, x_j) = e^{-\gamma \|\|x_i - x_j\|\|^2}, \gamma > 0$ . CvSVM::SIGMOID Sigmoid函数内核： $K(x_i, x_j) = \tanh(\gamma x_i^T x_j + coef0)$ . degree – 内核函数（POLY）的参数degree。 gamma – 内核函数（POLY/ RBF/ SIGMOID）的参数 $\gamma$ 。 coef0 – 内核函数（POLY/ SIGMOID）的参数`coef0`。 Cvalue – SVM类型（C_SVC/ EPS_SVR/ NU_SVR）的参数`C`。 nu – SVM类型（NU_SVC/ ONE_CLASS/ NU_SVR）的参数 $\nu$ 。 p – SVM类型（EPS_SVR）的参数 $\epsilon$ 。 class_weights – C_SVC中的可选权重，赋给指定的类，乘以C以后变成 $class\_weights_i * C$ 。所以这些权重影响不同类别的错误分类惩罚项。权重越大，某一类别的误分类数据的惩罚项就越大。 term_crit – SVM的迭代训练过程的中止条件，解决部分受约束二次最优问题。您可以指定的公差和/或最大迭代次数。

OpenCV的SVM

class CvSVM

向量支持机

CvSVM::CvSVM

训练构造函数。

C++: CvSVM::CvSVM()
C++: CvSVM::CvSVM(const Mat& trainData, const Mat& responses, const Mat& varIdx=Mat(), const Mat& sampleIdx=Mat(), CvSVMParamsparams=CvSVMParams() )
C++: CvSVM::CvSVM(const CvMat* trainData, const CvMat* responses, const CvMat* varIdx=0, const CvMat* sampleIdx=0, CvSVMParamsparams=CvSVMParams() )

参数

trainData — 训练数据，必须是CV_32FC1 （32位浮点类型，单通道）。数据必须是CV_ROW_SAMPLE的，即特征向量以行来存储。

responses — 响应数据，通常是1D向量存储在CV_32SC1 （仅仅用在分类问题上）或者CV_32FC1格式。

varIdx — 指定感兴趣的特征。可以是整数(32sC1)向量，例如以0为开始的索引，或者8位(8uC1)的使用的特征或者样本的掩码。用户也可以传入NULL指针，用来表示训练中使用所有变量／样本。

sampleIdx — 指定感兴趣的样本。描述同上。

params — SVM参数。

CvSVM::train

训练一个SVM。

C++: bool CvSVM::train(const Mat& trainData, const Mat& responses, const Mat& varIdx=Mat(), const Mat& sampleIdx=Mat(), CvSVMParamsparams=CvSVMParams() )
C++: bool CvSVM::train(const CvMat* trainData, const CvMat* responses, const CvMat* varIdx=0, const CvMat* sampleIdx=0, CvSVMParamsparams=CvSVMParams() )

参数参考构造函数。

CvSVM::train_auto

根据可选参数训练一个SVM。

C++: bool CvSVM::train_auto(const Mat& trainData, const Mat& responses, const Mat& varIdx, const Mat& sampleIdx, CvSVMParamsparams, int k_fold=10, CvParamGrid Cgrid=CvSVM::get_default_grid(CvSVM::C), CvParamGridgammaGrid=CvSVM::get_default_grid(CvSVM::GAMMA), CvParamGrid pGrid=CvSVM::get_default_grid(CvSVM::P), CvParamGridnuGrid=CvSVM::get_default_grid(CvSVM::NU), CvParamGrid coeffGrid=CvSVM::get_default_grid(CvSVM::COEF), CvParamGriddegreeGrid=CvSVM::get_default_grid(CvSVM::DEGREE), bool balanced=false)
C++: bool CvSVM::train_auto(const CvMat* trainData, const CvMat* responses, const CvMat* varIdx, const CvMat* sampleIdx, CvSVMParams params, int kfold=10, CvParamGrid Cgrid=get_default_grid(CvSVM::C), CvParamGrid gammaGrid=get_default_grid(CvSVM::GAMMA), CvParamGrid pGrid=get_default_grid(CvSVM::P), CvParamGrid nuGrid=get_default_grid(CvSVM::NU), CvParamGridcoeffGrid=get_default_grid(CvSVM::COEF), CvParamGrid degreeGrid=get_default_grid(CvSVM::DEGREE), bool balanced=false )

参数

k_fold – 交叉验证参数。训练集被分成k_fold的自子集。其中一个子集是用来测试模型，其他子集则成为训练集。所以，SVM算法复杂度是执行k_fold的次数。

*Grid – 对应的SVM迭代网格参数。

balanced – 如果是true则这是一个2类分类问题。这将会创建更多的平衡交叉验证子集。

这个方法根据CvSVMParams中的最佳参数C, gamma, p, nu, coef0, degree自动训练SVM模型。参数被认为是最佳的交叉验证，其测试集预估错误最小。

如果没有需要优化的参数，相应的网格步骤应该被设置为小于或等于1的值。例如，为了避免gamma的优化，设置gamma_grid.step = 0，gamma_grid.min_val， gamma_grid.max_val 为任意数值。所以params.gamma 由gamma得出。

最后，如果参数优化是必需的，但是相应的网格却不确定，你可能需要调用函数CvSVM::get_default_grid()，创建一个网格。例如，对于gamma，调用CvSVM::get_default_grid(CvSVM::GAMMA)。

该函数为分类运行 (params.svm_type=CvSVM::C_SVC 或者 params.svm_type=CvSVM::NU_SVC) 和为回归运行 (params.svm_type=CvSVM::EPS_SVR 或者 params.svm_type=CvSVM::NU_SVR)效果一样好。如果params.svm_type=CvSVM::ONE_CLASS，没有优化，并指定执行一般的SVM。

CvSVM::predict

预测样本的相应数据。

C++: float CvSVM::predict(const Mat& sample, bool returnDFVal=false ) const
C++: float CvSVM::predict(const CvMat* sample, bool returnDFVal=false ) const
C++: float CvSVM::predict(const CvMat* samples, CvMat* results) const

参数

sample – 需要预测的输入样本。

samples – 需要预测的输入样本们。

returnDFVal – 指定返回值类型。如果值是true，则是一个2类分类问题，该方法返回的决策函数值是边缘的符号距离。

results – 相应的样本输出预测的响应。

这个函数用来预测一个新样本的响应数据(response)。在分类问题中，这个函数返回类别编号；在回归问题中，返回函数值。输入的样本必须与传给trainData的训练样本同样大小。如果训练中使用了varIdx参数，一定记住在predict函数中使用跟训练特征一致的特征。

后缀const是说预测不会影响模型的内部状态，所以这个函数可以很安全地从不同的线程调用。

CvSVM::get_default_grid

生成一个SVM网格参数。

C++: CvParamGrid CvSVM::get_default_grid(int param_id)

参数

param_id –
SVM参数的IDs必须是下列中的一个：

CvSVM::C

CvSVM::GAMMA

CvSVM::P

CvSVM::NU

CvSVM::COEF

CvSVM::DEGREE

网格参数将根据这个ID生成。

CvSVM::get_params

返回当前SVM的参数。

C++: CvSVMParams CvSVM::get_params() const

这个函数主要是在使用CvSVM::train_auto()时去获得最佳参数。

CvSVM::get_support_vector

检索一定数量的支持向量和特定的向量。

C++: int CvSVM::get_support_vector_count() const
C++: const float* CvSVM::get_support_vector(int i) const

参数 i – 指定支持向量的索引。

该方法可以用于检索一组支持向量。

CvSVM::get_var_count

返回变量的个数。

C++: int CvSVM::get_var_count() const

参数	trainData — 训练数据，必须是`CV_32FC1` （32位浮点类型，单通道）。数据必须是CV_ROW_SAMPLE的，即特征向量以行来存储。 responses — 响应数据，通常是1D向量存储在CV_32SC1 （仅仅用在分类问题上）或者CV_32FC1格式。 varIdx — 指定感兴趣的特征。可以是整数(32sC1)向量，例如以0为开始的索引，或者8位(8uC1)的使用的特征或者样本的掩码。用户也可以传入NULL指针，用来表示训练中使用所有变量／样本。 sampleIdx — 指定感兴趣的样本。描述同上。 params — SVM参数。

参数	k_fold – 交叉验证参数。训练集被分成k_fold的自子集。其中一个子集是用来测试模型，其他子集则成为训练集。所以，SVM算法复杂度是执行k_fold的次数。 Grid – 对应的SVM迭代网格参数。 balanced* – 如果是true则这是一个2类分类问题。这将会创建更多的平衡交叉验证子集。

参数	sample – 需要预测的输入样本。 samples – 需要预测的输入样本们。 returnDFVal – 指定返回值类型。如果值是true，则是一个2类分类问题，该方法返回的决策函数值是边缘的符号距离。 results – 相应的样本输出预测的响应。

参数	param_id – SVM参数的IDs必须是下列中的一个： CvSVM::C CvSVM::GAMMA CvSVM::P CvSVM::NU CvSVM::COEF CvSVM::DEGREE 网格参数将根据这个ID生成。

参数	i – 指定支持向量的索引。

分割结果

程序创建了一张图像，在其中显示了训练样本，其中一个类显示为白色圆圈，另一个类显示为黑色圆圈。
训练得到SVM，并将图像的每一个像素分类。分类的结果将图像分为蓝绿两部分，中间线就是最优分割超平面。
最后支持向量通过灰色边框加重显示。

The seperated planes

OpenCV的SVM是基于台湾大学林智仁开发的LIBSVM开发包的。如果你还不过瘾可以看看下面林智仁的演示程序（需要JAVA支持）：

　　http://www.csie.ntu.edu.tw/~cjlin/libsvm/

在这个实验中，我们成功让机器找到了区分样品的线性划分，并将其支持向量显示出来。

被山寨的原文

Introduction to Support Vector Machines . OpenCV.org

Support Vector Machines API . OpenCV.org

二、SVM线性不可分问题

目的

实际事物模型中，并非所有东西都是线性可分的。

需要寻找一种方法对线性不可分数据进行划分。

原理

上一篇文章，我们推导出对于线性可分数据，最佳划分超平面应满足：

　　　　 $\min_{\beta, \beta_{0}} L(\beta) = \frac{1}{2}||\beta||^{2} \text{ subject to } y_{i}(\beta^{T} x_{i} + \beta_{0}) \geq 1 \text{ } \forall i,$

现在我们想引入一些东西，来表示那些被错分的数据点（比如噪点），对划分的影响。

如何来表示这些影响呢？

被错分的点，离自己应当存在的区域越远，就代表了，这个点“错”得越严重。

所以我们引入 $\xi_{i}$ ，为对应样本离同类区域的距离。

Samples misclassified and their distances to their correct regions

接下来的问题是，如何将这种错的程度，转换为和原模型相同的度量呢？

我们再引入一个常量C，表示 $\xi_{i}$ 和原模型度量的转换关系，用C对 $\xi_{i}$ 进行加权和，来表征错分点对原模型的影响，这样我们得到新的最优化问题模型：

　　　　 $\min_{\beta, \beta_{0}} L(\beta) = ||\beta||^{2} + C \sum_{i} {\xi_{i}} \text{ subject to } y_{i}(\beta^{T} x_{i} + \beta_{0}) \geq 1 - \xi_{i} \text{ and } \xi_{i} \geq 0 \text{ } \forall i$

关于参数C的选择，明显的取决于训练样本的分布情况。尽管并不存在一个普遍的答案，但是记住下面几点规则还是有用的：

C比较大时分类错误率较小，但是间隔也较小。在这种情形下，错分类对模型函数产生较大的影响，既然优化的目的是为了最小化这个模型函数，那么错分类的情形必然会受到抑制。
C比较小时间隔较大，但是分类错误率也较大。在这种情形下，模型函数中错分类之和这一项对优化过程的影响变小，优化过程将更加关注于寻找到一个能产生较大间隔的超平面。

说白了，C的大小表征了，错分数据对原模型的影响程度。于是C越大，优化时越关注错分问题。反之越关注能否产生一个较大间隔的超平面。

开始使用

#include <iostream>
#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/ml/ml.hpp>

#define NTRAINING_SAMPLES   100         // 每类训练样本的数量
#define FRAC_LINEAR_SEP     0.9f        // 线性可分部分的样本组成比例

using namespace cv;
using namespace std;

int main(){
    // 用于显示的数据
    const int WIDTH = 512, HEIGHT = 512;
    Mat I = Mat::zeros(HEIGHT, WIDTH, CV_8UC3);

    /* 1. 随即产生训练数据 */
    Mat trainData(2*NTRAINING_SAMPLES, 2, CV_32FC1);
    Mat labels   (2*NTRAINING_SAMPLES, 1, CV_32FC1);
    
    RNG rng(100); // 生成随即数

    // 设置线性可分的训练数据
    int nLinearSamples = (int) (FRAC_LINEAR_SEP * NTRAINING_SAMPLES);

    // 生成分类1的随机点
    Mat trainClass = trainData.rowRange(0, nLinearSamples);
    // 点的x坐标在[0, 0.4)之间
    Mat c = trainClass.colRange(0, 1);
    rng.fill(c, RNG::UNIFORM, Scalar(1), Scalar(0.4 * WIDTH));
    // 点的y坐标在[0, 1)之间
    c = trainClass.colRange(1,2);
    rng.fill(c, RNG::UNIFORM, Scalar(1), Scalar(HEIGHT));

    // 生成分类2的随机点
    trainClass = trainData.rowRange(2*NTRAINING_SAMPLES-nLinearSamples, 2*NTRAINING_SAMPLES);
    // 点的x坐标在[0.6, 1]之间
    c = trainClass.colRange(0 , 1); 
    rng.fill(c, RNG::UNIFORM, Scalar(0.6*WIDTH), Scalar(WIDTH));
    // 点的y坐标在[0, 1)之间
    c = trainClass.colRange(1,2);
    rng.fill(c, RNG::UNIFORM, Scalar(1), Scalar(HEIGHT));

    /* 设置非线性可分的训练数据 */

    // 生成分类1和分类2的随机点
    trainClass = trainData.rowRange(  nLinearSamples, 2*NTRAINING_SAMPLES-nLinearSamples);
    // 点的x坐标在[0.4, 0.6)之间
    c = trainClass.colRange(0,1);
    rng.fill(c, RNG::UNIFORM, Scalar(0.4*WIDTH), Scalar(0.6*WIDTH)); 
    // 点的y坐标在[0, 1)之间
    c = trainClass.colRange(1,2);
    rng.fill(c, RNG::UNIFORM, Scalar(1), Scalar(HEIGHT));
    
    /* 设置分类标签 */
    labels.rowRange(                0,   NTRAINING_SAMPLES).setTo(1);  // Class 1
    labels.rowRange(NTRAINING_SAMPLES, 2*NTRAINING_SAMPLES).setTo(2);  // Class 2

    /* 设置支持向量机参数 */
    CvSVMParams params;
    params.svm_type    = SVM::C_SVC;
    params.C           = 0.1;
    params.kernel_type = SVM::LINEAR;
    params.term_crit   = TermCriteria(CV_TERMCRIT_ITER, (int)1e7, 1e-6);

    /* 3. 训练支持向量机 */
    cout << "Starting training process" << endl;
    CvSVM svm;
    svm.train(trainData, labels, Mat(), Mat(), params);
    cout << "Finished training process" << endl;
    
    /* 4. 显示划分区域 */
    Vec3b green(0,100,0), blue (100,0,0);
    for (int i = 0; i < I.rows; ++i)
        for (int j = 0; j < I.cols; ++j){
            Mat sampleMat = (Mat_<float>(1,2) << i, j);
            float response = svm.predict(sampleMat);

            if      (response == 1)    I.at<Vec3b>(j, i)  = green;
            else if (response == 2)    I.at<Vec3b>(j, i)  = blue;
        }

    /* 5. 显示训练数据 */
    int thick = -1;
    int lineType = 8;
    float px, py;
    // 分类1
    for (int i = 0; i < NTRAINING_SAMPLES; ++i){
        px = trainData.at<float>(i,0);
        py = trainData.at<float>(i,1);
        circle(I, Point( (int) px,  (int) py ), 3, Scalar(0, 255, 0), thick, lineType);
    }
    // 分类2
    for (int i = NTRAINING_SAMPLES; i <2*NTRAINING_SAMPLES; ++i){
        px = trainData.at<float>(i,0);
        py = trainData.at<float>(i,1);
        circle(I, Point( (int) px, (int) py ), 3, Scalar(255, 0, 0), thick, lineType);
    }

    /* 6. 显示支持向量 */
    thick = 2;
    lineType  = 8;
    int x     = svm.get_support_vector_count();

    for (int i = 0; i < x; ++i)
    {
        const float* v = svm.get_support_vector(i);
        circle( I,  Point( (int) v[0], (int) v[1]), 6, Scalar(128, 128, 128), thick, lineType);
    }

    imwrite("result.png", I);                      // 保存图片
    imshow("SVM线性不可分数据划分", I); // 显示给用户
    waitKey(0);
}

设置SVM参数

这里的参数设置可以参考一下上一篇文章的API。

CvSVMParams params;
params.svm_type    = SVM::C_SVC;
params.C              = 0.1;
params.kernel_type = SVM::LINEAR;
params.term_crit   = TermCriteria(CV_TERMCRIT_ITER, (int)1e7, 1e-6);

可以看到，这次使用的是C类支持向量分类机。其参数C的值为0.1。

结果

程序创建了一张图像，在其中显示了训练样本，其中一个类显示为浅绿色圆圈，另一个类显示为浅蓝色圆圈。
训练得到SVM，并将图像的每一个像素分类。分类的结果将图像分为蓝绿两部分，中间线就是最优分割超平面。由于样本非线性可分，自然就有一些被错分类的样本。一些绿色点被划分到蓝色区域，一些蓝色点被划分到绿色区域。
最后支持向量通过灰色边框加重显示。

Training data and decision regions given by the SVM

被山寨的原文

Support Vector Machines for Non-Linearly Separable Data . OpenCV.org

三、SVM文字识别

预备知识

下面两个都不是必备知识，但是如果你想了解更多内容，可参考这两篇文章。

OpenCV 2.4+ C++ SVM介绍

OpenCV 2.4+ C++ SVM线性不可分处理

SVM划分的意义

到此，我们已经对SVM有一定的了解了。可是这有什么用呢？回到上一篇文章结果图：

Training data and decision regions given by the SVM

这个结果图的意义在于，他成功从二维划分了分类的区域。于是如果以后，有一个新的样本在绿色区域，那么我们就可以把他当成是绿色的点。

由于这可以像更高维度推广，所以如果我们能对样品映射成高维度空间的点，当有足够多的样品时，我们同样可以找到一个高维度的超平面划分，使得同一类样品的映射点在同一区域，于是当有新样品落在这些区域是，我们可以把它当成是这一类型的样本。

通俗一点

可能我们能更加通俗一点。比如我们来识别男性和女性。

我们发现男性和女性可能头发长度不一样，可能胸围不一样，于是我们对样本个体产生这样的一种映射：

　　　　人 —> （头发长度, 胸围）

于是我们将每个样品映射到二维平面，其中“头发的长度”和“胸围的长度”分别是x轴和y轴。我们把这些样品丢给SVM学习，则他会寻找出一个合理的x和y的区域来划分男性和女性。

当然，也有可能有些男的头发比女的还长，有的男性的胸围比女性还大，这些就是错分点，它们也影响着划分。

最后，当我们把一个人映射到这个二维空间时，SVM就可以根据以往的学习，猜一猜这个人到底是什么性别。

我们学到了什么呢？

好吧，特征要找准一点，否则可能遇到下面的悲剧……

如果这是老板，你就可死翘翘了……

简单的文字识别

当然计算机没那么厉害能看出你的胸围或者头发长短。他需要一些他能读懂的东西，特别计算机通常“看到”的是下面的这种东东……

A matrix of the mirror of a car

我们需要对文字找到他的特征，来映射到高维空间。

还记得小学时候练字的米字格么？这似乎暗示了我们，虽然每个人写的字千差万别，但是他们却具有一定的特点。

我们尝试这样做，取一个字，选取一个包含该字的正方形区域，将这个正方形区域分割成8*8个小格，统计每个小格中像素的数量，以这些数量为维度进行映射。

OK，明白了原理让我们开始吧。

样本获取

由于通常文字样本都是白底黑字的，而手写也可以直接获取写入的数据而无视背景，所以我们并不需要对样本进行提取，但我们需要对他定位，并弄成合适的大小。

比如，你没法避免有人这么写字……

坑爹啊，好好的那么大地方你就躲在左上角……

开始定位

void getROI(Mat& src, Mat& dst){
    int left, right, top, bottom;
    left = src.cols;
    right = 0;
    top = src.rows;
    bottom = 0;

    //得到区域
    for(int i=0; i<src.rows; i++)
    {
        for(int j=0; j<src.cols; j++)
        {
            if(src.at<uchar>(i, j) > 0)
            {
                if(j<left) left = j;
                if(j>right) right = j;
                if(i<top) top = i;
                if(i>bottom) bottom = i;
            }
        }
    }

    int width = right - left;
    int height = bottom - top;

    //创建存储矩阵
    dst = Mat::zeros(width, height, CV_8UC1);

    Rect dstRect(left, top, width, height);
    dst(dstRect);
}

这段代码通过遍历所有图像矩阵的元素，来获取该样本的定位和大小。并把样本提取出来。

重新缩放

Mat dst = Mat::zeros(8, 8, CV_8UC1);
resize(src, dst, dst.size());

进行缩放，把所有样本变成8*8的大小。为了简便，我们把像素多少变成了像素的灰度值。

resize的API：

调整图片大小

C++: void resize(InputArray src, OutputArray dst, Size dsize, double fx=0, double fy=0, int interpolation=INTER_LINEAR )

参数

src – 输入图像。

dst – 输出图像；它有一个dsize (当其不为0时) 或者这个size由 src.size()，fx和fy算出。dst的类型和src相同。

dsize –
输出图像的大小，如果取值为0，则：

$\texttt{dsize = Size(round(fx*src.cols), round(fy*src.rows))}$

dsize或者fx和fy必须有一种大小决定方法不为0。

fx –
水平轴缩放因子，当取值为0时，则为：

$\texttt{(double)dsize.width/src.cols}$

fy –
垂直轴缩放因子，当取值为0时，则为：

$\texttt{(double)dsize.height/src.rows}$

interpolation –
插值方法

INTER_NEAREST - 最近邻值插入方法。

INTER_LINEAR - 双线性插值（默认方式）。

INTER_AREA - 使用象素关系重采样。当图像缩小时候，该方法可以避免波纹出现。当图像放大时，类似于 CV_INTER_NN 方法。

INTER_CUBIC - 立方插值。

INTER_LANCZOS4 - 8x8的Lanczos插入方法。

参数	src – 输入图像。 dst – 输出图像；它有一个`dsize` (当其不为0时) 或者这个size由 `src.size()，fx`和`fy算出`。`dst`的类型和`src相同。` dsize – 输出图像的大小，如果取值为0，则： $\texttt{dsize = Size(round(fxsrc.cols), round(fysrc.rows))}$ `dsize`或者`fx和fy`必须有一种大小决定方法不为0。 fx – 水平轴缩放因子，当取值为0时，则为： $\texttt{(double)dsize.width/src.cols}$ fy – 垂直轴缩放因子，当取值为0时，则为： $\texttt{(double)dsize.height/src.rows}$ interpolation – 插值方法 INTER_NEAREST - 最近邻值插入方法。 INTER_LINEAR - 双线性插值（默认方式）。 INTER_AREA - 使用象素关系重采样。当图像缩小时候，该方法可以避免波纹出现。当图像放大时，类似于 CV_INTER_NN 方法。 INTER_CUBIC - 立方插值。 INTER_LANCZOS4 - 8x8的Lanczos插入方法。

准备样本数据

Mat data = Mat::zeros(total, 64, CV_32FC1);    //样本数据矩阵  
Mat res = Mat::zeros(total, 1, CV_32SC1);    //样本标签矩阵

res.at<double>(k, 1) = label;    //对第k个样本添加分类标签

//对第k个样本添加数据
for(int i = 0; i<8; i++)  {  
    for(int j = 0; j<8; j++)  {  
        res.at<double>(k, i * 8 + j) = dst.at<double>(i, j);  
    }  
}

将刚刚的结果，输入样本，并加上标签。

训练

CvSVM svm = CvSVM();   
CvSVMParams param;   
CvTermCriteria criteria;  
  
criteria= cvTermCriteria(CV_TERMCRIT_EPS, 1000,  FLT_EPSILON);   
param= CvSVMParams(CvSVM::C_SVC, CvSVM::RBF, 10.0, 8.0, 1.0, 10.0, 0.5, 0.1, NULL, criteria);   
  
svm.train(data, res, Mat(), Mat(), param);  
svm.save( "SVM_DATA.xml" );

开始训练并保存训练数据。

使用

CvSVM svm = CvSVM();   
svm.load( "SVM_DATA.xml" );
svm.predict(m);        //对样本向量m检测

参考资料

使用OPENCV训练手写数字识别分类器 . firefight . 2011-05-28

posted @ 2012-11-27 10:59 孤独剑客zzy 阅读(2311) 评论(0) 编辑收藏举报

刷新页面返回顶部

【转】利用Open CV和SVM实现问题识别

CvSVMParams::CvSVMParams

CvSVM::CvSVM

CvSVM::train

CvSVM::train_auto

CvSVM::predict

CvSVM::get_default_grid

CvSVM::get_params

CvSVM::get_support_vector

CvSVM::get_var_count

公告

【转】 利用Open CV和SVM实现问题识别