java实现支持向量机

最新推荐文章于 2024-04-30 13:58:33 发布
最新推荐文章于 2024-04-30 13:58:33 发布
阅读量1.2k 收藏 4
点赞数 2
分类专栏： 机器学习 文章标签： SVM 支持向量机
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34661106/article/details/103371568
版权

用到国家地表水 水质自动监测实时数据发布系统爬取的数据，其中Ⅰ- Ⅲ数据作为正常数据，赋予1标签，Ⅳ-Ⅴ数据作为异常数据，赋予-1标签，经测试，使用线性核函树和高斯核函最好的准确率均为95%，但是因为该实现没有使用KKT条件作为停机条件，不能保证每个乘子满足约束和KKT条件，故具有准确率具有一定的随机性和波动，在此条件下，高斯核函数相比于线性核函数波动稍微小一点。

在本实现中，矩阵相乘什么的都用的最笨的方法，可以尝试去优化。

另外乘子的停机条件中Σαy = 0 和 当  0< α < C时，y*g(x) = 1 感觉始终满足不了，有老哥弄出来的可以交流一波

[数据]

链接：https://pan.baidu.com/s/1YrKc_XfnJzw6uYSDNeTv7A 
提取码：k9su 

[代码]

package SVM;

import org.ejml.data.DenseMatrix64F;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;

public class SVMByKKT {
    List<double[][]> xs;
    List<Double> ys;
    double[] a;
    double b;
    double C = 0.6;
    Random random = new Random();
    DenseMatrix64F cache;


    public SVMByKKT(String filepath) throws IOException {
        init(filepath);
    }

    public void load_File(String filePath) throws IOException {
        BufferedReader bufferedReader = new BufferedReader(new FileReader(filePath));
        String line = null;
        xs = new ArrayList<double[][]>();
        ys = new ArrayList<Double>();
        while ((line = bufferedReader.readLine())!= null){
            String[] strings = line.split(",");
            double x[][] = new double[5][1];
            for(int i = 0; i < 5; i++){
                x[i][0] = Double.parseDouble(strings[i]);
            }
            xs.add(x);
            ys.add(Double.parseDouble(strings[5]));
        }

    }

    public void init(String filepath) throws IOException {
        load_File(filepath);
        int size = xs.size();
        a = new double[size];

        for(int i = 0;i < size;i++){
            a[i] = 0;
        }

        cache = new DenseMatrix64F(a.length,2);
        cache.zero();

        b = 0;
    }

    public double calcgx(double[][] x){
        double result = 0;
        for(int i=0;i<xs.size();i++){
            double kernel = rbfKernel(xs.get(i),x);
            result += a[i] * ys.get(i) * kernel;
        }

        return result + b;
    }

    public double calcE(int index){
        double[][] xi = xs.get(index);
        double e = calcgx(xi) - ys.get(index);
        return e;
    }

    public double kernel(double[][] x1,double[][] x2){
        double[][] transposeX1 = transpose(x1);
        double[][] matrixMul = matrixMul(transposeX1, x2);
        double result = matrixMul[0][0];
        double kernelResult = Math.pow(result,2);

        return kernelResult;
    }

    public double linearKernel(double[][] x1,double[][] x2){
        double[][] result = matrixMul(transpose(x1), x2);
        return result[0][0];
    }

    public double rbfKernel(double[][] x1,double[][] x2){
        double[][] sub = subForVec(x1, x2);
        double gamma = 0.2;
        double expo = -(gamma * vector2Norm(sub)/2*Math.pow(getStd(sub),2));
        double exp = Math.exp(expo);
        return exp;
    }

    public double rbfKernel2(double[][] x1,double[][] x2){
        double[][] sub = subForVec(x1, x2);
        double norm2 = vector2Norm(sub);
        double gamma = 0.2;

        double result = Math.exp(gamma * Math.pow(norm2,2));

        return result;
    }

    public double[][] getW(){
        double[][] w = new double[xs.get(0).length][1];
        for(int i = 0;i<a.length;i++){
            for(int j = 0;j < xs.get(i).length;j++){
                for(int k = 0; k< xs.get(i)[j].length;k++){
                    w[j][k] += a[i] * ys.get(i) * xs.get(i)[j][k];
                }
            }
        }

        return w;
    }

    public EijStorage selectSecondVariable(int index,double Ei){
        int maxK = -1;
        double maxDeltaE = 0;
        double Ej = 0;

        //cache里面存储的是已经被优化的乘子
        cache.set(index,0,1);
        cache.set(index,1,Ei);

        List<Integer> validList = nonzero(cache, 0);
        //存储Ej和j
        EijStorage eijStorage = new EijStorage();


        if(validList.size() > 1){
            for(int i = 0;i < validList.size();i++){
                if(validList.get(i) == index){
                    continue;
                }
                double Ek = calcE(validList.get(i));
                double delataE = Math.abs(Ei - Ek);
                if(delataE >= maxDeltaE){
                    maxDeltaE = delataE;
                    maxK = validList.get(i);
                    Ej = Ek;
                }
            }

            eijStorage.setEj(Ej);
            eijStorage.setJ(maxK);
        }
        else {

            eijStorage.setJ(selectRandmJ(index));
            eijStorage.setEj(calcE(eijStorage.getJ()));
        }


        return eijStorage;

    }

    public int selectRandmJ(int index){
        int j = index;
        while (j == index){
            j = random.nextInt(a.length);
        }
        return j;
    }

    public double getStd(double[][] x){
        double mean = getMean(x);
        double tmp = 0;
        double length = x.length;

        for(double[] d : x){
            for (double d1 : d){
                tmp += Math.pow(d1 - mean,2);
            }
        }

        return tmp / length;
    }

    public double getMean(double[][] x){
        double tmp = 0;
        double length = x.length;

        for(double[] d : x){
            for (double d1 : d){
                tmp += d1;
            }
        }

        return  tmp/length;
    }

    public void setAppropriateEj(double Ei,int j){
        if(Ei >= 0){
            double min = 0;
            for(int i = 0; i < cache.numRows;i++){
                if(cache.get(i,1) < min){
                    min = cache.get(i,1);
                }
            }

            cache.set(j,1,min);
        }
        else {
            double max = 0;
            for(int i = 0; i < cache.numRows;i++){
                if(cache.get(i,1) > max){
                    max = cache.get(i,1);
                }
            }

            cache.set(j,1,max);
        }
    }

    public void updateCache(int j){
        cache.set(j,0,1);
        cache.set(j,1,calcE(j));
    }

    public int inner(int i){
        double Ei = calcE(i);
//        System.out.println("Ei is " + Ei);
        if (((ys.get(i) * Ei < -0.001) && (a[i] < C)) || ((ys.get(i) * Ei > 0.001) && (a[i] > 0))) {
            EijStorage eijStorage = selectSecondVariable(i,Ei);
            int j = eijStorage.getJ();
            double Ej = eijStorage.getEj();

            double old_a1 = a[i];
            double old_a2 = a[eijStorage.getJ()];

            double L;
            double H;

            if(ys.get(i) != ys.get(eijStorage.getJ())){
                L = Math.max(0,old_a2-old_a1);
                H = Math.min(C,C+old_a2 - old_a1);
            }
            else {
                L = Math.max(0,old_a2 + old_a1 - C);
                H = Math.min(C,old_a2 + old_a1);
            }

            if(L == H){
                return 0;
            }

            double eta =  2*rbfKernel(xs.get(i),xs.get(eijStorage.getJ())) - rbfKernel(xs.get(i),xs.get(i)) - rbfKernel(xs.get(eijStorage.getJ()),xs.get(eijStorage.getJ()));
            if(eta >= 0){
                return 0;
            }

            double new_a2;
//            double unc_a2 = old_a2 + (ys.get(eijStorage.getJ()) * (Ei - eijStorage.getEj())) / eta;
            double unc_a2 = -(old_a2 + (ys.get(j) * (Ei - Ej))) / eta;
            if(unc_a2 > H){
                new_a2 = H;
            }
            else if(unc_a2 < L){
                new_a2 = L;
            }
            else
            {
                new_a2 = unc_a2;
            }

            a[eijStorage.getJ()] = new_a2;
            updateCache(j);


            if(Math.abs(new_a2 - old_a2) < 0.00001){
                return 0;
            }

            double new_a1 = old_a1 + ys.get(i) * ys.get(eijStorage.getJ()) * (old_a2 - new_a2);
            a[i] = new_a1;
//            double new_Ei = calcE(i);
//            setAppropriateEj(Ei,eijStorage.getJ());
            updateCache(i);
            double new_b1 = b - Ei - ys.get(i) * rbfKernel(xs.get(i),xs.get(i)) * (new_a1 - old_a1) -
                    ys.get(j) * rbfKernel(xs.get(i),xs.get(j)) * (new_a2 - old_a2);

//            double new_b2 = -eijStorage.getEj() - ys.get(i) * linearKernel(xs.get(i),xs.get(eijStorage.getJ())) * (new_a1 - old_a1) -
//                    ys.get(eijStorage.getJ()) * linearKernel(xs.get(eijStorage.getJ()),xs.get(eijStorage.getJ())) * (new_a2 - old_a2) + b;

            double new_b2 = b - Ej - ys.get(i) * rbfKernel(xs.get(i),xs.get(j)) * (new_a1 - old_a1) -
                    ys.get(j) * rbfKernel(xs.get(j),xs.get(j)) * (new_a2 - old_a2);

            if(a[i] > 0 && a[i] < C){
                b = new_b1;
            }
            else if(a[eijStorage.getJ()] > 0 && a[eijStorage.getJ()] < C){
                b = new_b2;
            }
            else {
                b = (new_b1 + new_b2) / 2.0;
            }

            double new_Ei = calcE(i);
            cache.set(i,1,new_Ei);

            return 1;
        }
        else {
            return 0;
        }

    }

    public void train(){
        int iter = 0;
        int maxIt = 1000;
        int pair_changed = 0;
        boolean entireSet = true;
        //外循环停机条件
        //1.iter < maxIt
        //2.所有乘子对停止更新
        //3.entireSet是否遍历整个数据集
        //外层循环首先遍历间隔边界上的支持向量点，检查其是否满足KKT条件，如果这些样本都满足KKT条件，则遍历整个数据集
        //在此的逻辑是第一次遍历整个数据集，若有变量被优化，切换为false，即去遍历间隔区间上的支持向量点，若没有遍历被优化
        //依然遍历整个数据集
        while ((iter < maxIt) && ((pair_changed > 0) || entireSet)){
            pair_changed = 0;
            if(entireSet){
                for(int i=0; i < a.length;i++) {
                    int inner = inner(i);
                    pair_changed += inner;
                }
                iter += 1;
            }
            else {
                List<Integer> validAs = getABetween0C();
                for(Integer validA : validAs){
                    pair_changed += inner(validA);
                }
                iter += 1;
            }

            if(entireSet){
                entireSet = false;
            }
            else if(pair_changed == 0){
                entireSet = true;
            }

        }
    }

    public List<Integer> getABetween0C(){
        List<Integer> list = new ArrayList<Integer>();

        for(int i = 0;i< a.length;i++){
            if(a[i] > 0 && a[i] < C){
                list.add(i);
            }
        }

        return list;
    }

    public List<Integer> nonzero(DenseMatrix64F cache,int col){
        List<Integer> list = new ArrayList<Integer>();

        for (int i=0;i<cache.numRows;i++){
            if(cache.get(i,col) != 0){
                list.add(i);
            }
        }

        return list;
    }

    public double predict(double[][] x){
        double[][] w = getW();
        for(double[] d : w){
            for (double d1 : d){
                System.out.println(d1);
            }
        }
        double result = matrixMul(transpose(w),x)[0][0] + b;
        if(result >= 0){
            return 1.0;
        }
        else {
            return -1.0;
        }
    }

    public double[][] matrixMul(double[][] martrix1,double[][] martrix2){
        if(martrix1[0].length == martrix2.length){
            if(martrix1.length == 1 && martrix2[0].length == 1){
                double tmp = 0;
                for(int i = 0; i < martrix2.length; i++){
                    tmp += martrix1[0][i] * martrix2[i][0];
                }

                double[][] result = new double[1][1];
                result[0][0] = tmp;

                return result;
            }
            else {
                int row = martrix1.length;
                int col = martrix2[0].length;
                double[][] result = new double[row][col];

                for(int i = 0;i< martrix1.length;i++){
                    for(int j = 0;j< martrix2[0].length;j++){
                        for(int k = 0;k < martrix2.length;k++){
                            result[i][j] += martrix1[i][k] * martrix2[k][j];
                        }
                    }
                }
                return result;
            }
        }
        else {
            throw new IllegalArgumentException("第一矩阵的列数要等于第二个矩阵的行数");
        }
    }

    public double[][] transpose(double[][] matrix){
        int row = matrix.length;
        int col = matrix[0].length;

        double[][] transposedMatrix = new double[col][row];
        for(int i = 0; i < col; i++){
            for(int j = 0;j < row; j++){
                transposedMatrix[i][j] = matrix[j][i];
            }
        }

        return transposedMatrix;
    }

    public double vector2Norm(double[][] x){
        double result = 0;
        for(int i = 0;i<x.length;i++){
            for(int j = 0;j<x[i].length;j++){
                result += Math.pow(x[i][j],2);
            }
        }

        return Math.sqrt(result);
    }

    public double[][] subForVec(double[][] x1,double[][] x2){
        double[][] result = new double[x1.length][x1[0].length];
        for(int i = 0;i<x1.length;i++){
            for(int j = 0;j<x2[i].length;j++){
                result[i][j] = x1[i][j] - x2[i][j];
            }
        }

        return result;
    }

    public double prf(String filepath) throws IOException {
        BufferedReader bufferedReader = new BufferedReader(new FileReader(filepath));
        String line = null;
        List<double[][]> testData = new ArrayList();
        List<Double> testLabel = new ArrayList<Double>();

        while ((line = bufferedReader.readLine()) != null){
            String[] s = line.split(",");
            double xi[][] = new double[5][1];
            for(int i = 0; i < 5; i++){
                xi[i][0] = Double.parseDouble(s[i]);
            }
            testData.add(xi);

            testLabel.add(Double.parseDouble(s[5]));
        }



        double count = 0;

       for (int i = 0;i < testData.size();i++){

           double prediction = predict(testData.get(i));
           double label = testLabel.get(i);
           if(prediction == label){
               count += 1;
           }
       }

        return count/testData.size();
    }

    public static void main(String[] args) throws IOException {
//        String filepath = "C:\\Users\\dell\\Desktop\\date.txt";
        String filepath = "C:\\Users\\dell\\Desktop\\waterForSvm.txt";
//        String filepath = "D:\\Algorithm\\testSet.txt";
        SVMByKKT svmByKKT = new SVMByKKT(filepath);
        svmByKKT.train();

        String testFilePath = "C:\\Users\\dell\\Desktop\\waterForTest.txt";
        double prf = svmByKKT.prf(testFilePath);
        System.out.println("准确率为" + prf);

        double[][] x = new double[5][1];
//        7.29,3.87,0.67,5,--
//        7.7,10.38,0.19,2.1,--
//        6.12,9.17,0.8,2.84,2.505
//        7.39,6.31,0.44,8.9,--
//        7.85,8.5,0.15,1.77,--
        x[0][0] = 7.85;
        x[1][0] = 8.5;
        x[2][0] = 0.15;
        x[3][0] = 1.77;
        x[4][0] = 0;

        System.out.println(svmByKKT.predict(x));


    }
}

 

sandalen凉鞋
关注
  • 2
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
java实现SVM支持向量机算法
04-22
通过java语言实现SVM支持向量机算法
支持向量机算法实现（Java、python、matlab）
07-20
Java、python、matlab三种语言实现svm算法，可直接运行查看结果。
支持向量机回归（概念+实例）
weixin_47151388的博客
04-30 2459
支持向量机（Support Vector Machine，SVM）是一种强大的机器学习算法，最初是用于分类问题，但后来也被扩展用于回归问题。支持向量机回归（Support Vector Regression，SVR）是一种非常有用的技术，特别适用于具有复杂特征关系的数据集。
java 实现支持向量机
weixin_33730836的博客
09-25 939
https://github.com/kevin0016/java-SVM
利用java写一个支持向量机算法
weixin_42579969的博客
02-12 258
好的，以下是一个简单的Java代码来实现支持向量机算法： ``` import java.util.ArrayList; import java.util.List; public class SVM { private List<Data> trainingData; private List<Double> alpha; private double b; privat...
svm算法 java实现,机器学习算法：SVM（支持向量机）
weixin_42600407的博客
03-27 902
SVM算法(Support Vector Machine，支持向量机)的核心思想有2点：1、如果数据线性可分，那么基于最大间隔的方式来确定超平面，以确保全局最优，使得分类器尽可能健壮；2、如果数据线性不可分，通过核函数将低维样本转化为高维样本使其线性可分。注意和AdaBoost类似，SVM只能解决二分类问题。SVM的算法在数学上实在是太复杂了，没研究明白。建议还是直接使用现成的第三方组件吧，比如l...
支持向量机的python实现
06-23
包括C++、Java、python、web、C#、EDA等项目的源码。 【适用人群】：适用于希望学习不同技术领域的初学者或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。 【附加价值】：项目具有较高的...
libsvm支持向量机回归示例
09-04
在本示例中，我们将专注于支持向量机回归（Support Vector Regression，SVR），特别是使用libsvm库进行实现。libsvm是陈嘉庚学院开发的一个开源库，它提供了多种SVM模型的实现，包括分类和回归。 首先，让我们了解...
LibSVM 支持向量机 示例程序
01-29
Eclipse项目，导入即可使用，数据使用UCI-Iris，记得导入libsvm.jar，文件夹中含有
【支持向量机】SVM（支持向量机）案例&项目源码
最新发布
06-23
本资源集合了一系列精选的SVM（支持向量机）相关案例和项目源码，专为数据科学爱好者、机器学习工程师以及在学学生设计，提供实战经验与深入理解SVM算法的机会。 支持向量机（SVM）是一种强大的监督学习模型，它...
支持向量机Java实现及使用说明
因吉的博客
12-18 1913
SVM Java代码及使用说明1 代码说明2 代码 1 代码说明   1）SVM原理介绍及Python代码：   https://blog.csdn.net/weixin_44575152/article/details/100184850   2）本代码使用需要配合SimpleTool.java，地址如下：   https://github.com/InkiInki/Java/tree/mast...
支持向量机（SVM）多分类算法实现
05-13
一般的支持向量机（SVM）只能够用作二分类，而本次上传的代码是一个四分类的支持向量机（SVM）算法实现，代码的关键部分都会有注释，适合刚入门的小白看。本代码还用到了libsvm这个工具箱，需要读者自己配置，配置方法较为简单，自己百度就能实现。数据可以用自己的也可以用压缩包里面的。
（免费）支持多分类的svm（java源码）
08-05
支持多类的svm分类器，带样例，带详细注释，大家一起交流学习吧
支持向量机SVM的java api 使用
swufer
06-20 5062
最近用LibSVM做分类实验，发现网上的资料大都是关于SVM基本原理和怎么用终端命令行使用svm-train,svm-predict等几个程序，这些其实在README文件中已经讲得很清楚了，Readme里面几乎包含了所有可以帮助你灵活使用LibSVM的信息，可以很多人都不怎么看。这里给出用JAVA调用LibSVM API最简单的示例，用JAVA进行SVM分类只需要几行程序就搞定了，前提是你已经准备
支持向量机matlab代码程序_详解支持向量机
weixin_39623355的博客
11-26 2676
介绍监督学习描述了一类问题，涉及使用模型来学习输入示例和目标变量之间的映射。如果存在分类问题，则目标变量可以是类标签，如果存在回归问题，则目标变量是连续值。一些模型可用于回归和分类。我们将在此博客中讨论的一种这样的模型是支持向量机，简称为SVM。我的目的是为你提供简单明了的SVM内部工作。假设我们正在处理二分类任务。可能有无限多的超平面可以将这两个类分开。你可以选择其中任何一个。但是这个超平面能很...
机器学习(四)：通俗理解支持向量机SVM及代码实践
caiyongji
02-15 592
上一篇文章我们介绍了使用逻辑回归来处理分类问题，本文我们讲一个更强大的分类模型。本文依旧侧重代码实践，你会发现我们解决问题的手段越来越丰富，问题处理起来越来越简单。 支持向量机(Support Vector Machine, SVM)是最受欢迎的机器学习模型之一。它特别适合处理中小型复杂数据集的分类任务。 一、什么是支持向量机 SMV在众多实例中寻找一个最优的决策边界，这个边界上的实例叫做支持向量，它们“支持”（支撑）分离开超平面，所以它叫支持向量机。 那么我们如何保证我们得到的决策边界是最优的呢？ 如上
支持向量机与最大熵的文本分类java实现
stonemusy的专栏
08-23 1052
毕业做的，具体信息可以看说明，本来还想做一些XX图片识别的~不过刚有个大概思路，就毕业了~程序可以在资源空间下载，http://download.csdn.net/user/stonemusy本来还有一些bug和可以改进的地方，比如cache，加上先验后的训练等等，结果好久没搞自己都看不懂了~工作一个月来，感触颇多，以后工作中做完一个事情，一定把总结，心得写下来~
支持向量机
这个人很懒什么都没有~
10-19 506
观察约束条件，对于任意的样本点(xi，yi)，如果αi=0，则点(xi，yi)在超平面公式f(x)中无效即对分类平面的产生不会有影响。而我们从样本集D中找到的这两个点(xi，yi=+1)和(xi，yi=-1)能够使得距离r最大，则这两个点被称为“支持向量”，找到这些样本点之后去计算得到w和b得到的超平面被称为“支持向量机”。首先分析约束条件，用α2表示α1，找出α1和α2满足的取值范围，在此范围内求解α2的最优值也即是得到α1的最优值。截距为b(原点到超平面的距离)，法向量为w(垂直于超平面的n维向量)。
java svm toy_支持向量机libsvm实战入门
weixin_28717939的博客
02-24 223
一、libsvm介绍SVM支持向量机是目前比较流行的一种数据挖掘方法，能够处理较高维度，具体介绍可参考这篇博文:LIBSVM是台湾大学林智仁(Lin Chih-Jen)教授等开发设计的一个简单、易于使用和快速有效的SVM模式识别与回归的软件包，他不但提供了编译好的可在Windows系列系统的执行文件，还提供了源代码，方便改进、修改以及在其它操作系统上应用；该软件对SVM所涉及的参数调节相对比较少，...
java 支持向量机
10-28
Java支持向量机（SVM）是一种基于统计学习理论的分类算法，它可以用于二元分类和多元分类。SVM的目标是找到一个超平面，将不同类别的数据分开。在Java中，我们可以使用开源的机器学习库，如Weka和LIBSVM，来实现SVM...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值