java实现SVM支持向量机（附完整源码）

以下是一个简单的Java实现SVM支持向量机的代码，仅供参考：

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

public class SVM {
    private static final double ALPHA_TOLERANCE = 0.001;
    private static final double BIAS_TOLERANCE = 0.1;
    private static final double SIGMA = 5.0;
    private static final int MAX_ITERATIONS = 1000;

    private ArrayList<Double> targets = new ArrayList<>();
    private ArrayList<ArrayList<Double>> inputs = new ArrayList<>();
    private ArrayList<Double> alphas = new ArrayList<>();
    private double bias;

    public SVM(String filename) {
        loadData(filename);
    }

    public void train() {
        int iterations = 0;
        boolean changed = true;
        while (changed && iterations < MAX_ITERATIONS) {
            changed = false;
            iterations++;

            for (int i = 0; i < inputs.size(); i++) {
                double error_i = calculateError(i);
                if ((targets.get(i) * error_i < -ALPHA_TOLERANCE && alphas.get(i) < C())
                        || (targets.get(i) * error_i > ALPHA_TOLERANCE && alphas.get(i) > 0)) {
                    int j = i;
                    while (j == i) {
                        j = (int) Math.floor(Math.random() * inputs.size());
                    }

                    double error_j = calculateError(j);
                    double alpha_i_old = alphas.get(i);
                    double alpha_j_old = alphas.get(j);

                    double L, H;
                    if (targets.get(i) != targets.get(j)) {
                        L = Math.max(0, alphas.get(j) - alphas.get(i));
                        H = Math.min(C(), C() + alphas.get(j) - alphas.get(i));
                    } else {
                        L = Math.max(0, alphas.get(i) + alphas.get(j) - C());
                        H = Math.min(C(), alphas.get(i) + alphas.get(j));
                    }

                    if (L == H) {
                        continue;
                    }

                    double eta = 2 * dot(inputs.get(i), inputs.get(j)) - dot(inputs.get(i), inputs.get(i)) - dot(inputs.get(j), inputs.get(j));
                    if (eta >= 0) {
                        continue;
                    }

                    alphas.set(j, alphas.get(j) - (targets.get(j) * (error_i - error_j)) / eta);
                    alphas.set(j, Math.min(Math.max(alphas.get(j), L), H));

                    if (Math.abs(alphas.get(j) - alpha_j_old) < ALPHA_TOLERANCE) {
                        alphas.set(j, alpha_j_old);
                        continue;
                    }

                    alphas.set(i, alphas.get(i) + targets.get(i) * targets.get(j) * (alpha_j_old - alphas.get(j)));
                    double b1 = bias - error_i - targets.get(i) * (alphas.get(i) - alpha_i_old) * dot(inputs.get(i), inputs.get(i))
                            - targets.get(j) * (alphas.get(j) - alpha_j_old) * dot(inputs.get(i), inputs.get(j));
                    double b2 = bias - error_j - targets.get(i) * (alphas.get(i) - alpha_i_old) * dot(inputs.get(i), inputs.get(j))
                            - targets.get(j) * (alphas.get(j) - alpha_j_old) * dot(inputs.get(j), inputs.get(j));

                    if (0 < alphas.get(i) && alphas.get(i) < C()) {
                        bias = b1;
                    } else if (0 < alphas.get(j) && alphas.get(j) < C()) {
                        bias = b2;
                    } else {
                        bias = (b1 + b2) / 2.0;
                    }

                    changed = true;
                }
            }
        }
    }

    public double predict(ArrayList<Double> input) {
        double sum = 0.0;
        for (int i = 0; i < inputs.size(); i++) {
            sum += alphas.get(i) * targets.get(i) * kernel(input, inputs.get(i));
        }
        return sum - bias;
    }

    private double calculateError(int i) {
        return predict(inputs.get(i)) - targets.get(i);
    }

    private double C() {
        return 1.0;
    }

    private double kernel(ArrayList<Double> x1, ArrayList<Double> x2) {
        double sum = 0.0;
        for (int i = 0; i < x1.size(); i++) {
            sum += Math.pow(x1.get(i) - x2.get(i), 2);
        }
        return Math.exp(-sum / (2.0 * Math.pow(SIGMA, 2)));
    }

    private double dot(ArrayList<Double> x1, ArrayList<Double> x2) {
        double sum = 0.0;
        for (int i = 0; i < x1.size(); i++) {
            sum += x1.get(i) * x2.get(i);
        }
        return sum;
    }

    private void loadData(String filename) {
        try {
            BufferedReader br = new BufferedReader(new FileReader(filename));
            String line;
            while ((line = br.readLine()) != null) {
                String[] parts = line.split(",");
                targets.add(Double.parseDouble(parts[0]));
                ArrayList<Double> input = new ArrayList<>();
                for (int i = 1; i < parts.length; i++) {
                    input.add(Double.parseDouble(parts[i]));
                }
                inputs.add(input);
                alphas.add(0.0);
            }
            br.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

使用方法：

SVM svm = new SVM("data.csv");
svm.train();
ArrayList<Double> input = new ArrayList<>();
input.add(0.5);
input.add(0.8);
double prediction = svm.predict(input);
System.out.println(prediction);

其中，`data.csv`是训练数据文件，每一行表示一个样本，第一列为样本的目标值，后面的列为样本的特征值。在训练过程中，使用了SMO算法进行参数优化。预测时，输入一个样本的特征值，输出其预测的目标值。