【opencv-ml】非线性可分数据的支持向量机

最新推荐文章于 2024-05-16 14:07:07 发布

十年一梦实验室

最新推荐文章于 2024-05-16 14:07:07 发布

阅读量3.2k

点赞数

文章标签： python 计算机视觉机器学习人工智能深度学习

本文链接：https://blog.csdn.net/cxyhjl/article/details/124011403

版权

Support Vector Machines forNon-Linearly Separable Data

非线性可分数据的支持向量机

Goal

在本教程中，您将学习如何：

当无法线性分离训练数据时，定义 SVM 的优化问题。

如何配置参数以使您的 SVM 适应此类问题。

Motivation

为什么扩展 SVM 优化问题以处理非线性可分训练数据很有趣？在计算机视觉中使用 SVM 的大多数应用都需要比简单的线性分类器更强大的工具。这源于这样一个事实，即在这些任务中，训练数据很少可以使用超平面分离。

考虑其中一项任务，例如人脸检测。在这种情况下，训练数据由一组人脸图像和另一组非人脸图像（世界上除人脸之外的所有其他事物）组成。该训练数据过于复杂，以至于无法找到每个样本（特征向量）的表示，该表示可以使整组人脸与整组非人脸线性分离。

Extension of theOptimization Problem

请记住，使用 SVM，我们获得了一个分离的超平面。因此，由于训练数据现在是非线性可分的，我们必须承认找到的超平面会对一些样本进行错误分类。这种错误分类是优化中必须考虑的一个新变量。新模型必须既包括找到提供最大余量的超平面的旧要求，又包括通过不允许太多分类错误正确概括训练数据的新要求。

我们从寻找最大化边际（maximizes the margin）的超平面的优化问题的公式开始（这在上一个教程（支持向量机简介）中进行了解释：

可以通过多种方式修改此模型，因此它考虑了误分类误差。例如，可以考虑最小化相同的数量加上训练数据中误分类误差数量的常数倍，即：

one could think of minimizingthe same quantity plus a constant times thenumber of misclassification errors in the training data,

然而，这不是一个很好的解决方案，因为除其他一些原因外，我们不区分误分类的样本到它们适当的决策区域的距离很小的样本或没有误分类的样本。因此，更好的解决方案将考虑误分类样本到其正确决策区域的距离，即：

对于训练数据的每个样本，定义了一个新参数 ξi。这些参数中的每一个都包含从其对应的训练样本到其正确决策区域的距离。下图显示了来自两个类的非线性可分离训练数据，一个分离的超平面以及到误分类样本的正确区域的距离。

注意：

图片中只显示了被错误分类的样本的距离。其余样本的距离为零，因为它们已经位于正确的决策区域中。

图片上出现的红线和蓝线是每个决策区域的边距。认识到每个 ξi 为从一个错误分类的训练样本到其正确区域的边缘是非常重要的。

最后，优化问题的新公式为：

应该如何选择参数 C？ 很明显，这个问题的答案取决于训练数据的分布方式。尽管没有通用答案，但考虑以下规则是有用的：

较大的 C 值给出的解决方案具有较少的误分类误差但较小的边际。考虑到在这种情况下，误分类误差的代价是昂贵的。由于优化的目的是最小化参数，因此允许的误分类误差很少。less misclassification errors but a smallermargin.
较小的 C 值给出具有较大边距和更多分类误差（classification errors）的解决方案。在这种情况下，最小化并没有考虑太多的总和项，因此它更多地关注于找到一个具有大边距的超平面。 bigger margin and moreclassification errors

Source Code

您还可以在 OpenCV 源库的samples/cpp/tutorial_code/ml/non_linear_svms 文件夹中找到源代码，或从此处下载。https://github.com/opencv/opencv/tree/4.x/samples/cpp/tutorial_code/ml/non_linear_svms/non_linear_svms.cpp

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


using namespace cv;
using namespace cv::ml;
using namespace std;


static void help()
{
    cout<< "\n--------------------------------------------------------------------------" << endl
        << "This program shows Support Vector Machines for Non-Linearly Separable Data. " << endl
        << "--------------------------------------------------------------------------"   << endl
        << endl;
}


int main()
{
    help();


    const int NTRAINING_SAMPLES = 100;         // 每类训练样本数
    const float FRAC_LINEAR_SEP = 0.9f;        // 组成线性可分部分的样本 分数 Fraction of samples which compose the linear separable part


    // 可视化数据
    const int WIDTH = 512, HEIGHT = 512;
    Mat I = Mat::zeros(HEIGHT, WIDTH, CV_8UC3);//512x512


    //--------------------- 1. 随机设置训练数据---------------------------------------
    Mat trainData(2*NTRAINING_SAMPLES, 2, CV_32F);//
    Mat labels   (2*NTRAINING_SAMPLES, 1, CV_32S);


    RNG rng(100); // 随机值生成类


    //设置训练数据的线性可分部分 Set up the linearly separable part of the training data
    int nLinearSamples = (int) (FRAC_LINEAR_SEP * NTRAINING_SAMPLES);


    //! [setup1]
    // 为类 1 生成随机点
    Mat trainClass = trainData.rowRange(0, nLinearSamples);//前 nLinearSamples行Mat指针
    // 点的 x 坐标在 [0, 0.4)
    Mat c = trainClass.colRange(0, 1);//第1列指针  该函数包括左边界，但是不包括右边界。
    rng.fill(c, RNG::UNIFORM, Scalar(0), Scalar(0.4 * WIDTH));//均匀分布 从0到0.4 
    // 点的 y 坐标在 [0, 1)
    c = trainClass.colRange(1,2);//第二列指针 
    rng.fill(c, RNG::UNIFORM, Scalar(0), Scalar(HEIGHT));//均匀分布 从0到1


    // 为类 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(0), Scalar(HEIGHT));
    //! [setup1]


    //------------------ 设置训练数据的非线性可分部分---------------
    //! [setup2]
    // 为类 1 和 2 生成随机点 Generate random points for the classes 1 and 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(0), Scalar(HEIGHT));
    //! [setup2]


    //------------------------- 为类设置标签 ---------------------------------
    labels.rowRange(                0,   NTRAINING_SAMPLES).setTo(1);  // Class 1
    labels.rowRange(NTRAINING_SAMPLES, 2*NTRAINING_SAMPLES).setTo(2);  // Class 2


    //------------------------ 2. 设置支持向量机参数 --------------------
    cout << "Starting training process" << endl;
    //! [init]
    Ptr<SVM> svm = SVM::create();
    svm->setType(SVM::C_SVC);
    svm->setC(0.1);//较大的c 具有较少的误分类误差但较小的边际 ; 较小的 C 值给出具有较大边距和更多分类误差（classification errors）
    svm->setKernel(SVM::LINEAR);
    svm->setTermCriteria(TermCriteria(TermCriteria::MAX_ITER, (int)1e7, 1e-6));
    //! [init]


    //------------------------ 3. 训练svm ----------------------------------------------------
    //! [train]
    svm->train(trainData, ROW_SAMPLE, labels);//行样本
    //! [train]
    cout << "Finished training process" << endl;


    //------------------------ 4. 显示决策区域decision regions ------------------------------
    //! [show]
    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) << j, i);//像素坐标x,y  取值范围 0~512
            float response = svm->predict(sampleMat);//预测


            if      (response == 1) I.at<Vec3b>(i,j) = green;//第一类深绿色
            else if (response == 2) I.at<Vec3b>(i,j) = blue;//第二类 深蓝色
        }
    }
    //! [show]


    //----------------------- 5. 显示训练数据 --------------------------------------------
    //! [show_data]
    int thick = -1;
    float px, py;
    // 第一类
    for (int i = 0; i < NTRAINING_SAMPLES; i++)//遍历第一类样本点
    {
        px = trainData.at<float>(i,0);//点的x坐标
        py = trainData.at<float>(i,1);//点的y坐标
        circle(I, Point( (int) px,  (int) py ), 3, Scalar(0, 255, 0), thick);//浅绿色圆点
    }
    // 第二类
    for (int i = NTRAINING_SAMPLES; i <2*NTRAINING_SAMPLES; i++)//遍历第2类样本点
    {
    {
        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);//浅蓝色圆点 半径3
    }
    //! [show_data]


    //------------------------- 6. 显示支持向量 --------------------------------------------
    //! [show_vectors]
    thick = 2;
    Mat sv = svm->getUncompressedSupportVectors();//获取支持向量


    for (int i = 0; i < sv.rows; i++)
    {
        const float* v = sv.ptr<float>(i);//第i个支持向量的指针
        circle(I,  Point( (int) v[0], (int) v[1]), 6, Scalar(128, 128, 128), thick);//圆圈半径6 线宽2
    }
    //! [show_vectors]


    imwrite("result.png", I);                      // 保存图像
    imshow("SVM for Non-Linear Training Data", I); // 显示图像
    waitKey();
    return 0;
}

Explanation

1. 设置训练数据

本练习的训练数据由一组标记的 2D 点组成，这些点属于两个不同类别之一。为了使练习更具吸引力，训练数据是使用统一概率密度函数 (PDF) 随机生成的。

我们将训练数据的生成分为两个主要部分。

在第一部分，我们为两个类生成线性可分的数据。

// Generate random points for the class 1
    Mat trainClass = trainData.rowRange(0, nLinearSamples);
    // The x coordinate of the points is in [0, 0.4)
    Mat c = trainClass.colRange(0, 1);
    rng.fill(c, RNG::UNIFORM, Scalar(0), Scalar(0.4 * WIDTH));
    // The y coordinate of the points is in [0, 1)
    c = trainClass.colRange(1,2);
    rng.fill(c, RNG::UNIFORM, Scalar(0), Scalar(HEIGHT));
    // Generate random points for the class 2
    trainClass = trainData.rowRange(2*NTRAINING_SAMPLES-nLinearSamples, 2*NTRAINING_SAMPLES);
    // The x coordinate of the points is in [0.6, 1]
    c = trainClass.colRange(0 , 1);
    rng.fill(c, RNG::UNIFORM, Scalar(0.6*WIDTH), Scalar(WIDTH));
    // The y coordinate of the points is in [0, 1)
    c = trainClass.colRange(1,2);
    rng.fill(c, RNG::UNIFORM, Scalar(0), Scalar(HEIGHT));

在第二部分中，我们为两个类创建非线性可分的数据，即重叠的数据。

// Generate random points for the classes 1 and 2
    trainClass = trainData.rowRange(nLinearSamples, 2*NTRAINING_SAMPLES-nLinearSamples);
    // The x coordinate of the points is in [0.4, 0.6)
    c = trainClass.colRange(0,1);
    rng.fill(c, RNG::UNIFORM, Scalar(0.4*WIDTH), Scalar(0.6*WIDTH));
    // The y coordinate of the points is in [0, 1)
    c = trainClass.colRange(1,2);
    rng.fill(c, RNG::UNIFORM, Scalar(0), Scalar(HEIGHT));

设置 SVM 的参数

注意：

在之前的教程 Introduction to Support VectorMachines 中，对我们在训练 SVM 之前在此处配置的类 cv::ml::SVM的属性进行了解释。

Ptr<SVM> svm = SVM::create();
svm->setType(SVM::C_SVC);
svm->setC(0.1);
svm->setKernel(SVM::LINEAR);
svm->setTermCriteria(TermCriteria(TermCriteria::MAX_ITER, (int)1e7, 1e-6));

我们在这里所做的配置与我们用作参考的上一教程（支持向量机简介）中所做的配置之间只有两个区别。

a). C.我们在这里选择了这个参数的一个小值，以免在优化过程中过多地惩罚错误分类错误。这样做的想法源于获得接近直觉预期的解决方案的意愿。但是，我们建议通过调整此参数来更好地了解问题。

注意：

在这种情况下，类之间的重叠区域中只有很少的点。通过为 FRAC_LINEAR_SEP赋予较小的值，可以增加点的密度，并深入探索参数 C 的影响。

b). TerminationCriteria of the algorithm. 算法的终止标准。为了正确解决具有非线性可分训练数据的问题，必须大大增加最大迭代次数。特别是，我们将这个值提高了五个数量级。

训练 SVM

我们调用方法 cv::ml::SVM::train来构建 SVM 模型。请注意，训练过程可能需要很长时间。运行程序时要有耐心。

svm->train(trainData, ROW_SAMPLE, labels);

显示决策区域Show the Decision Regions

方法 cv::ml::SVM::predict 用于使用经过训练的SVM 对输入样本进行分类。在此示例中，我们使用此方法根据 SVM 所做的预测为空间着色。换句话说，遍历图像，将其像素解释为笛卡尔平面上的点。每个点的颜色取决于 SVM 预测的类别；如果是标签为 1 的类，则为深绿色；如果是标签为 2 的类，则为深蓝色。

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) << j, i);
            float response = svm->predict(sampleMat);
            if      (response == 1) I.at<Vec3b>(i,j) = green;
            else if (response == 2) I.at<Vec3b>(i,j) = blue;
        }
    }

显示训练数据

方法 cv::circle用于显示构成训练数据的样本。标记为 1 的类别的样本以浅绿色显示，而标记为 2 的类别的样本以浅蓝色显示。

int thick = -1;
    float px, py;
    // Class 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);
    }
    // Class 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);
    }

支持向量

我们在这里使用了几种方法来获取有关支持向量的信息。 cv::ml::SVM::getSupportVectors 方法获取所有支持向量。我们在这里使用这种方法来查找作为支持向量的训练示例并突出显示它们。

thick = 2;
    Mat sv = svm->getUncompressedSupportVectors();
    for (int i = 0; i < sv.rows; i++)
    {
        const float* v = sv.ptr<float>(i);
        circle(I,  Point( (int) v[0], (int) v[1]), 6, Scalar(128, 128, 128), thick);
    }

Results

该代码会打开一个图像并显示两个类的训练示例。一类的点用浅绿色表示，浅蓝色的点用于另一类。

SVM 被训练并用于对图像的所有像素进行分类。这导致图像在蓝色区域和绿色区域中的划分。两个区域之间的边界是分离超平面。由于训练数据是非线性可分的，可以看出两个类的一些例子都被错误分类了；一些绿点位于蓝色区域，一些蓝点位于绿色区域。

最后，支持向量在训练示例周围使用灰色环显示。

您可以在此处的 YouTube https://www.youtube.com/watch?v=vFv2yPcSo-Q 上观察到它的运行时实例。

参考：

https://docs.opencv.org/4.5.5/d0/dcc/tutorial_non_linear_svms.html

https://blog.csdn.net/az9996/article/details/90071320

十年一梦实验室

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
【opencv-ml】非线性可分数据的支持向量机

Support Vector Machines forNon-Linearly Separable Data非线性可分数据的支持向量机Goal在本教程中，您将学习如何：当无法线性分离训练数据时，定义 SVM 的优化问题。如何配置参数以使您的 SVM 适应此类问题。Motivation为什么扩展 SVM 优化问题以处理非线性可分训练数据很有趣？在计算机视觉中使用 SVM 的...
复制链接

扫一扫