SVM训练方法之SMO算法

已于 2022-03-29 10:11:20 修改
阅读量214 收藏
点赞数 1
文章标签： SVM SMO算法
于 2017-04-17 16:57:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jdnie/article/details/70213293
版权

研究了下SVM，神经网络的训练方法是梯度下降法，SVM的训练方法貌似说的最多的就是SMO算法

#include "opencv2/core/core_c.h"
#include "opencv2/core/core.hpp"
#include "opencv2/flann/miniflann.hpp"
#include "opencv2/imgproc/imgproc_c.h"
#include "opencv2/imgproc/imgproc.hpp"
#include "opencv2/photo/photo.hpp"
#include "opencv2/video/video.hpp"
#include "opencv2/features2d/features2d.hpp"
#include "opencv2/objdetect/objdetect.hpp"
#include "opencv2/calib3d/calib3d.hpp"
#include "opencv2/ml/ml.hpp"
#include "opencv2/highgui/highgui_c.h"
#include "opencv2/highgui/highgui.hpp"
#include "opencv2/contrib/contrib.hpp"


#include <cctype>
#include <iostream>
#include <iterator>
#include <stdio.h>
#include <map>
#include <cmath>

using namespace std;
using namespace cv;

static float calc_inner_product(float *x, int dims, int i, int j)
{
    float sum = 0;
    for (int k=0; k<dims; k++)
    {
        sum += x[i*dims+k] * x[j*dims+k];
    }
    return sum;
}


static float calc_ui(float *x, float *y, float *a, float b, int dims, int nums, int C, int i)
{
    float ui = b;
    for (int j=0; j<nums; j++)
    {
        if (a[j] == C)
            continue;
        ui += y[j]*a[j]*calc_inner_product(x, dims, i, j);
    }
    return ui;
}


#define ABS(x)          ((x) >= 0 ? (x) : (-(x)))
#define MAX(x,y)        ((x)>(y) ? (x):(y))
#define MIN(x,y)        ((x)<(y) ? (x):(y))
#define MIN_MAX(min, x, max)   (MAX((min), MIN((max), (x))))


/* 输入特征数据，训练得到分类器 */
int train(float *x, float *y, float *w, float *b, float *a, int dims, int nums, int C)
{
    int i, j, k;
    //int C = 1;      /* 松弛因子 */
    int iter = 0;   /* 迭代次数 */
    float tol = 0.0001;
    float ui, uj, ei, ej, max_ej, old_ai, old_aj, L, H, eta, bi, bj;


    /* 初始化 */
    for (i=0; i<nums; i++)
    {
        a[i] = 0;
    }
    *b = 0;


    while (iter < 100000)
    {
        int adjust_nums = 0;
        for (i=0; i<nums; i++)
        {
            /* 找出不符合KKT条件的a[i] */
            ui = calc_ui((float *)x, (float *)y, a, *b, dims, nums, C, i);
            if (((y[i]*ui < 1) && (a[i] < C)) ||
                ((y[i]*ui > 1) && (a[i] > 0)) ||
                ((y[i]*ui == 1) && ((a[i] == 0) || (a[i] == C))))
            {
                ei = ui - y[i];


                /* 寻找误差最大的a[j]，在支持变量上找 */
                max_ej = ei;
                for (j=0; j<nums; j++)
                {
                    if (i == j)
                        continue;
                    if ((a[j] == 0) || (a[j] == C))
                        continue;
                    uj = calc_ui((float *)x, (float *)y, a, *b, dims, nums, C, j);
                    ej = uj - y[j];
                    if (ABS(ej - ei) > ABS(max_ej - ei))
                    {
                        k = j;
                        max_ej = ej;
                    }
                }


                /* 如果支持变量上没找到，在其他里面找误差最大的a[j] */
                if (max_ej == ei)
                {
                    for (j=0; j<nums; j++)
                    {
                        if (i == j)
                            continue;
                        if ((a[j] > 0) && (a[j] < C))
                            continue;
                        uj = calc_ui((float *)x, (float *)y, a, *b, dims, nums, C, j);
                        ej = uj - y[j];
                        if (ABS(ej - ei) > ABS(max_ej - ei))
                        {
                            k = j;
                            max_ej = ej;
                        }
                    }
                }
                j = k;
                ej = max_ej;


                /* 保存原来的ai和aj */
                old_ai = a[i];
                old_aj = a[j];


                /* 计算上界和下界 */
                if (y[i] != y[j])
                {
                    L = MAX(0, old_aj - old_ai);
                    H = MIN(C, C + old_aj - old_ai);
                }
                else
                {
                    L = MAX(0, old_aj + old_ai - C);
                    H = MIN(C, old_aj + old_ai);
                }


                /* 计算新的aj */
                eta = calc_inner_product((float *)x, dims, i, i) +
                    calc_inner_product((float *)x, dims, j, j) -
                    2 * calc_inner_product((float *)x, dims, i, j);


                a[j] = old_aj + y[j]*(ei - ej)/eta;
                a[j] = MIN_MAX(L, a[j], H);


                /* 计算新的ai, 重新保持Σai yi = 0 */
                a[i] = old_ai + y[i]*y[j]*(old_aj - a[j]);


                /* 重新计算b */
                bi = *b - ei - y[i]*(a[i]-old_ai)*calc_inner_product((float *)x, dims, i, i)
                    - y[j]*(a[j]-old_aj)*calc_inner_product((float *)x, dims, i, j);
                bj = *b - ej - y[i]*(a[i]-old_ai)*calc_inner_product((float *)x, dims, i, j)
                    - y[j]*(a[j]-old_aj)*calc_inner_product((float *)x, dims, j, j);
                if (0 < a[i] && a[i] < C)
                      *b = bi;
                    else if (0 < a[j] && a[j] < C)
                      *b = bj;
                    else 
                        *b = (bi + bj) / 2;


                adjust_nums++;
            }
        }


        if (adjust_nums < nums * 0.01)
            break;
        iter++;
    }
    cout << "iter:" << iter << endl;


    cout << "w: ";
    for (i=0; i<dims; i++)
    {
        w[i] = 0;
        for (j=0; j<nums; j++)
        {
            if (a[j] == C)
                continue;
            w[i] += y[j] * a[j] * x[j*dims + i];
        }
        cout << w[i] << ",";
    }
    cout << endl << "b: " << *b << endl;


    cout << "alpha vector:";
    for (j=0; j<nums; j++)
    {
        cout << a[j] << ",";
    }
    cout << endl;


    return 0;
}


#define IMG_SIZE 400
void random_features(int* w, int b, int* x,
    int dims, int nums, int noise)
{
    int i, j;
    for (i=0; i<nums; i++)
    {
        int rand_noise = randu<int>() % noise;
        int sum = rand_noise + b;
        for (j=0; j<dims-1; j++)
        {
            x[i*dims+j] = randu<unsigned int>() % IMG_SIZE;
            sum += w[j] * x[i*dims+j];
        }
        x[i*dims+j] = -sum / w[j];
    }
}


#define DIMS 2
#define NUMS 100
int main( int argc, const char** argv )
{
    Mat img = Mat::zeros(Size(IMG_SIZE, IMG_SIZE), CV_8UC3);
    int features[NUMS*2][DIMS];
    float x[NUMS*2][DIMS];
    float y[NUMS*2], a[NUMS*2];
    int pre_w[DIMS] = {1, -1}, pre_b0 = 60, pre_b1 = -60, pre_noise = 30;
    float w[DIMS], b = 0;
    int C = 1; //松弛因子


    /* 生成 x-y+60=0 的随机特征数据 */
    random_features(pre_w, pre_b0, &features[0][0], DIMS, NUMS, pre_noise);
    for (int i=0; i<NUMS; i++)
    {
        y[i] = 1;
        if (i > NUMS*9/10)  //生成错误标签
        {
            y[i] = -1;
        }
    }
    /* 生成 x-y-60=0 的随机特征数据 */
    random_features(pre_w, pre_b1, &features[NUMS][0], DIMS, NUMS, pre_noise);
    for (int i=0; i<NUMS; i++)
    {
        y[i+NUMS] = -1;
        if (i > NUMS*9/10)  //生成错误标签
        {
            y[i+NUMS] = 1;
        }
    }


    for (int i=0; i<NUMS*2; i++)
    {
        for (int j=0; j<DIMS; j++)
        {
            //x[i][j] = (float)features[i][j] / IMG_SIZE;
            x[i][j] = features[i][j];
        }
    }
    train(&x[0][0], y, w, &b, a, DIMS, NUMS*2, C);

      cvNamedWindow("test", 1);

    /* 画图 */
    int support_vector_num = 0;
    for (int i=0; i<NUMS; i++)
    {
        /* 距离远的向量 */
        if (a[i] == 0)
        {
            cv::circle(img, Point(features[i][0], features[i][1]),
                3, Scalar(0,128,0));
        }
        /* 松弛向量 */
        else if (a[i] == C)
        {
            cv::circle(img, Point(features[i][0], features[i][1]),
                3, Scalar(128,128,0));
        }
        /* 支持向量 */
        else
        {
            cv::circle(img, Point(features[i][0], features[i][1]),
                3, Scalar(0,255,0));
            support_vector_num++;
        }
        
    }
    for (int i=NUMS; i<NUMS*2; i++)
    {
        /* 距离远的向量 */
        if (a[i] == 0)
        {
            cv::circle(img, Point(features[i][0], features[i][1]),
                3, Scalar(0,0,128));
        }
        /* 松弛向量 */
        else if (a[i] == C)
        {
            cv::circle(img, Point(features[i][0], features[i][1]),
                3, Scalar(128,0,128));
        }
        /* 支持向量 */
        else
        {
            cv::circle(img, Point(features[i][0], features[i][1]),
                3, Scalar(0,0,255));
            support_vector_num++;
        }
    }
    //cout << "support vector num:" << support_vector_num << endl;
    float pt_st_x = 10, pt_st_y, pt_ed_x = 390, pt_ed_y;
    //pt_st_y = ((pt_st_x / IMG_SIZE * w[0] + b) / (-w[1])) * IMG_SIZE; 
    //pt_ed_y = ((pt_ed_x / IMG_SIZE * w[0] + b) / (-w[1])) * IMG_SIZE;
    pt_st_y = ((pt_st_x * w[0] + b) / (-w[1])); 
    pt_ed_y = ((pt_ed_x * w[0] + b) / (-w[1]));
    //cout << pt_st_x << "," << pt_st_y << "," << pt_ed_x << "," << pt_ed_y << endl;
    cv::line(img, Point(pt_st_x, pt_st_y), Point(pt_ed_x, pt_ed_y), Scalar(255,255,255));
    cv::imshow("test", img);


while (1)
{
    char c = (char)waitKey();
    if( c == 27 )
        break;
}

    cvDestroyWindow("test");
    return 0;
}





    return 0;
}


参考文章：

http://blog.csdn.net/shuimanting520/article/details/45459803

jdnie
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
SVM 自定义函数 SMO 详细理解
unicorntatata的博客
05-01 1149
序列最小优化算法（Sequential Minimal Optimization, SMO）是一套训练SVM模型的算法，它能使SVM模型的训练来得更高效、快速和简单。它的核心在于迭代更新方程中的拉格朗日乘数，使得方程最小化，即超平面间隔最大化。终止迭代的条件为函数收敛或迭代次数以达到自定义的最高次数，此时方程已得到对应模型的最佳参数，生成模型。SMO的优势在于不需要QP（Quadratic Programming）分解器来求解，直接通过内循环启发式和外循环启发式分析求解即可，故不需要大量的空间来存储大矩阵。
利用svm进行模型训练
SmartDemo的博客
12-14 1021
1、将文本数据转换为特征向量 ： tf-idf2、使用这些特征向量训练SVM模型。
SVM模型训练与分类的OpenCV实现
weixin_50624597的博客
07-28 1646
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录数据准备一、pandas是什么？二、使用步骤1.引入库2.读入数据总结 数据准备 在OpenCV的安装路径下，搜索digits，可以得到一张图片，图片大小为10002000,有0-9的10个数字，每5行为一个数字，总共50行，共有5000个手写数字，每个数字块大小为2020。 下面将把这些数字中的0和1作为二分类的准备数据。其中0有500张，1有500张。 用下面的代码将图片准备好，在写入路径提前建立好文件夹： #include.
SVM训练（C++实现）
qq_44790423的博客
05-29 2235
在很多文献中，都把HOG和SVM结合起来使用，可以得到很不错的分类效果，SVM就不用再复习啦，就是一个线性分类器，给一个简单的图就能很好理解， 对于有标签的正样本和负样本，如果只有两个维度，也就是只有两个特征，要做的就是找到一条线，能够很好的划分为两个区域分别包含正负样本，并且这条线尽可能远离两个样本中心 （摘自上课的PPT） 但是这是针对二维的情况，如果扩展到多维，可能就无法找到一条线，即使找到了也可能有很多样本发生了错分，所以就需要在更高维度上考虑，高斯是最常用的。 目前我是打算将23维图像降为1维，
采用SMO优化算法训练SVM（实战篇）
GG_freedom
04-10 3946
算法笔记更新~ 引入   SVM（支持向量机），相信有一些机器学习基础的朋友对这个算法应该早已耳熟。SVM是现有的机器学习基础算法里较为能扛的一个。此篇文章偏向实战，对svm背后繁杂而又精致的数学知识不做展开叙述，在这一方面，笔者在学习时参考的是东大一位教授的知乎文章：零基础学习SVM，教授讲解的十分详细，引人入胜。层层递进的同时令人不禁感慨数学的美妙！如果你对svm最后的目标函数一无所知，同时又有兴趣探个究竟，强烈安利你移步上述链接。 SVM经过一番推导之后，得到的目标函数为: 对这个优化目标函数，解
SVM.zip_SMO算法分类_svm 分类_分类算法_升维
09-24
包含完整的SVM算法，下载即可使用。其中包括数据集和完整的算法结构，算法结构包括数据清理、核函数升维以及SMO优化算法，可以较好实现数据非线性分类。
机器学习算法之SVM-by-SMO算法实现.zip
最新发布
04-20
机器学习算法 机器学习算法之SVM_by_SMO算法实现
svm支持向量机SMO算法加速.py
01-11
本程序应用SVM为基础，核函数采用高斯核函数，数据为手写数字数据1和9，用smo加速算法，识别正确率达99.4%，而且我博客有讲解
svm.rar_Laplacian SVM_smo_smo算法_svm matlab两类_svm算法
09-24
两类svm算法，用SMO算法计算拉普拉斯算子
svm smo.zip_SMO SVM_SVM_matlab_smo_算法 svm
09-23
支持向量机。 包括SMO算法，用于求解alpha的值
机器学习笔记 - 支持向量机(SVM)
学以致用 知行合一
03-11 5502
支持向量机（Support Vector Machine，SVM）是一个功能强大并且全面的机器学习模型，它能够执行线性或非线性分类、回归，甚至是异常值检测任务。它是机器学习领域最受欢迎的模型之一，任何对机器学习感兴趣的人都应该在工具箱中配备一个。SVM特别适用于中小型复杂数据集的分类。 通常SVM用于二元分类问题，对于多元分类可将其分解为多个二元分类问题，再进行分类，主要的应用场景有图像分类、文本分类、面部识别、垃圾邮件检测等领域。
SVM训练样本方法总结（用于目标识别）
xw20084898的专栏
03-17 3万+
SVM样本训练步骤 1、引言 近期在做飞形体目标识别的研究，需要做SVM训练来生成识别的分类器。从网上找了大量的参考文章，但是发现很多文章都讲的比较零散。鉴于此原因，本文对SVM训练过程做一个较为系统的总结，希望对广大初学者有所帮助。 2、步骤 （1）生成SVM描述文件； 将需要训练的样本文件的路径和对应的分类类别号写入txt文档，如： plane/飞机训练正样本Normalize/0
四、训练SVM分类器(Python)(train_model.py)
sally的jerry
05-17 4801
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 imp
svm训练方法记录
j201111100523的博客
01-23 1062
1、正样本选择数目2416 2、负样本初始数目12180 3、初步训练得到分类器 4、从负样本中选择HardExample 5、把HardExample和正负样本重新训练一次 这一步结束后还是有很多误检 6、重复第四步，继续选择HardExample 这一步结束后，误检会少很多，但是会出现漏检 7、尝试加入正样本（未测试效果，后续更新）
SMO算法最通俗易懂的解释
热门推荐
Machine Learning with Tutors
06-18 7万+
SVM通常用对偶问题来求解，这样的好处有两个：1、变量只有N个（N为训练集中的样本个数），原始问题中的变量数量与样本点的特征个数相同，当样本特征非常多时，求解难度较大。2、可以方便地引入核函数，求解非线性SVM。求解对偶问题，常用的算法是SMO，彻底地理解这个算法对初学者有一定难度，本文尝试模拟算法作者发明该算法的思考过程，让大家轻轻松松理解SMO算法。文中的“我”拟指发明算法的大神。
SVM训练及预测过程
会吃狼的鳄鱼
08-15 8511
SVM训练及预测过程 http://blog.sina.com.cn/s/blog_65caa97801011fbi.html
SVM理论
heavendai的专栏
11-15 1万+
SVM入门（一）至（三）Refresh 按:之前的文章重新汇编一下,修改了一些错误和不当的说法，一起复习,然后继续SVM之旅. （一）SVM的简介 支持向量机(Support Vector  Machine)是Cortes和Vapnik于1995年首先提出的，它在解决小样本、非线性及高维模式识别中表现出许多特有的优势，并能够推广应用到函数拟合等其他机器学习问题中[10]。 支持向量机方
【机器学习实战】支持向量机SMO算法详解
lyl771857509的博客
03-03 1721
SMO算法 # 加载数据 def loadDataSet(fileName): dataMat = [];labelMat = [] fr = open(fileName) for line in fr.readlines(): lineArr = line.strip
smo算法优化svm诊断糖尿病
01-21
2. 加快训练速度：SMO算法通过将大优化问题分解为小优化问题，可以加快SVM模型的训练速度。这对于处理大规模的糖尿病数据集来说尤为重要。 3. 提高模型可解释性：SMO算法对于优化SVM模型的参数具有较好的可解释性。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值