C++实现支持向量机模型

代码如下

#include <iostream>
#include <vector>
#include <cmath>

// 定义支持向量机的数据结构
struct SVM {
    int n;                  // 数据维度
    double C;               // 惩罚参数
    std::vector<double> w;  // 权重向量
    double b;               // 偏置项
};

// 计算向量x和y的内积
double dot(const std::vector<double>& x, const std::vector<double>& y) {
    double res = 0.0;
    for (int i = 0; i < x.size(); i++) {
        res += x[i] * y[i];
    }
    return res;
}

// 计算SVM的损失函数
double loss(const SVM& svm, const std::vector<std::vector<double>>& X, const std::vector<int>& y) {
    double res = 0.0;
    for (int i = 0; i < X.size(); i++) {
        res += std::max(0.0, 1 - y[i] * (dot(svm.w, X[i]) + svm.b));
    }
    return 0.5 * dot(svm.w, svm.w) + svm.C * res;
}

// 计算SVM的梯度
std::vector<double> gradient(const SVM& svm, const std::vector<std::vector<double>>& X, const std::vector<int>& y) {
    std::vector<double> grad(svm.n, 0.0);
    for (int i = 0; i < X.size(); i++) {
        if (y[i] * (dot(svm.w, X[i]) + svm.b) < 1) {
            for (int j = 0; j < svm.n; j++) {
                grad[j] += -y[i] * X[i][j];
            }
        }
    }
    for (int j = 0; j < svm.n; j++) {
        grad[j] = svm.w[j] + svm.C * grad[j];
    }
    return grad;
}

// 训练SVM模型
SVM train(const std::vector<std::vector<double>>& X, const std::vector<int>& y, double C, double learning_rate, int epochs) {
    SVM svm;
    svm.n = X[0].size();
    svm.C = C;
    svm.w = std::vector<double>(svm.n, 0.0);
    svm.b = 0.0;
    for (int epoch = 0; epoch < epochs; epoch++) {
        std::vector<double> grad = gradient(svm, X, y);
        for (int j = 0; j < svm.n; j++) {
            svm.w[j] -= learning_rate * grad[j];
        }
        double sum_grad_b = 0.0;
        for (int i = 0; i < X.size(); i++) {
            if (y[i] * (dot(svm.w, X[i]) + svm.b) < 1) {
                sum_grad_b += -y[i];
            }
        }
        svm.b -= learning_rate * svm.C * sum_grad_b;
        double l = loss(svm, X, y);
        std::cout << "Epoch " << epoch << ", Loss: " << l << std::endl;
    }
    return svm;
}

// 对单个样本进行预测
int predict(const SVM& svm, const std::vector<double>& x) {
    double y_pred = dot(svm.w, x) + svm.b;
    return y_pred >= 0 ? 1 : -1;
}

// 对多个样本进行预测
std::vector<int> predict(const SVM& svm, const std::vector<std::vector<double>>& X) {
    std::vector<int> y_pred;
    for (int i = 0; i < X.size(); i++) {
        y_pred.push_back(predict(svm, X[i]));
    }
    return y_pred;
}

int main() {
    // 构造样本数据
    std::vector<std::vector<double>> X = {{1, 2}, {2, 3}, {3, 1}, {4, 2}};
    std::vector<int> y = {1, 1, -1, -1};

    // 训练SVM模型
    double C = 1.0;
    double learning_rate = 0.01;
    int epochs = 100;
    SVM svm = train(X, y, C, learning_rate, epochs);

    // 对新样本进行预测
    std::vector<std::vector<double>> X_test = {{1, 1}, {3, 3}};
    std::vector<int> y_pred = predict(svm, X_test);
    for (int i = 0; i < y_pred.size(); i++) {
        std::cout << "Sample " << i << ": " << y_pred[i] << std::endl;
    }

    return 0;
}

上述代码实现了一个简单的线性支持向量机（Linear SVM），使用梯度下降法（Gradient Descent）进行训练。在训练过程中，需要计算SVM的损失函数和梯度，并使用学习率（learning_rate）和惩罚参数（C）对权重向量和偏置项进行更新。在训练完成后，可以使用训练好的SVM模型对新的样本进行预测。

需要注意的是，SVM算法有很多变体，例如核函数SVM（Kernel SVM）等，实现方法和细节也有所不同。上述代码仅提供了一个简单的实现示例，具体实现方式需根据具体问题进行调整。