svr支持向量机回归 c++代码

以下是使用C语言实现的SVR（支持向量机回归）代码：

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>

#define MAX_LINE_LENGTH 1024
#define MAX_FEATURES 1000
#define MAX_SAMPLES 1000
#define MAX_ITERATIONS 10000
#define TOLERANCE 0.001

typedef struct {
    double alpha;
    double b;
} svm_model;

typedef struct {
    double* x;
    double y;
} sample;

int num_samples, num_features;
sample samples[MAX_SAMPLES];
double kernel[MAX_SAMPLES][MAX_SAMPLES];
double eps = 0.0001;

double kernel_function(double* x1, double* x2) {
    double result = 0.0;
    for (int i = 0; i < num_features; i++) {
        result += (x1[i] - x2[i]) * (x1[i] - x2[i]);
    }
    return exp(-result / (2.0 * eps * eps));
}

void calculate_kernel() {
    for (int i = 0; i < num_samples; i++) {
        for (int j = 0; j < num_samples; j++) {
            kernel[i][j] = kernel_function(samples[i].x, samples[j].x);
        }
    }
}

double predict(double* x, svm_model* model) {
    double result = 0.0;
    for (int i = 0; i < num_samples; i++) {
        result += model->alpha * samples[i].y * kernel_function(x, samples[i].x);
    }
    return result - model->b;
}

double calculate_error(int index, svm_model* model) {
    double result = 0.0;
    for (int i = 0; i < num_samples; i++) {
        result += model->alpha * samples[i].y * kernel[i][index];
    }
    return result - samples[index].y;
}

void train_svr(svm_model* model) {
    double alpha[num_samples];
    memset(alpha, 0, sizeof(alpha));

    double b = 0.0;
    double error[num_samples];
    memset(error, 0, sizeof(error));

    int iterations = 0;
    double alpha_diff = 0.0;
    do {
        alpha_diff = 0.0;
        for (int i = 0; i < num_samples; i++) {
            error[i] = calculate_error(i, model);
            double old_alpha = alpha[i];
            alpha[i] = fmin(fmax(alpha[i] + (samples[i].y - error[i]) / kernel[i][i], 0.0), 1.0);
            alpha_diff += fabs(alpha[i] - old_alpha);
        }

        iterations++;
        if (iterations >= MAX_ITERATIONS) {
            printf("Maximum iterations reached. Exiting...\n");
            exit(1);
        }
    } while (alpha_diff > TOLERANCE);

    for (int i = 0; i < num_samples; i++) {
        b += samples[i].y - error[i] - alpha[i] * kernel[i][i];
    }
    b /= num_samples;

    model->b = b;
    for (int i = 0; i < num_samples; i++) {
        model->alpha += alpha[i] * samples[i].y;
    }
}

int main(int argc, char* argv[]) {
    if (argc < 2) {
        printf("Usage: %s <data_file>\n", argv[0]);
        exit(1);
    }

    FILE* fp = fopen(argv[1], "r");
    if (!fp) {
        printf("Failed to open file: %s\n", argv[1]);
        exit(1);
    }

    char line[MAX_LINE_LENGTH];
    int line_num = 0;
    while (fgets(line, MAX_LINE_LENGTH, fp)) {
        char* token = strtok(line, ",");
        int feature_num = 0;
        double* features = (double*) malloc(sizeof(double) * MAX_FEATURES);
        while (token) {
            if (feature_num == num_features) {
                printf("Too many features in line %d. Exiting...\n", line_num);
                exit(1);
            }
            features[feature_num++] = atof(token);
            token = strtok(NULL, ",");
        }

        if (feature_num == 0) {
            printf("Empty line %d. Exiting...\n", line_num);
            exit(1);
        } else if (feature_num == 1) {
            printf("Only one feature in line %d. Exiting...\n", line_num);
            exit(1);
        }

        samples[line_num].x = features;
        samples[line_num].y = features[feature_num - 1];
        num_features = feature_num - 1;
        line_num++;
    }
    num_samples = line_num;

    printf("Number of samples: %d\n", num_samples);
    printf("Number of features: %d\n", num_features);

    calculate_kernel();

    svm_model model = {0.0, 0.0};
    train_svr(&model);

    printf("Trained model: alpha=%f, b=%f\n", model.alpha, model.b);

    double test[MAX_FEATURES] = {0.5, 0.6, 0.7};
    printf("Prediction: %f\n", predict(test, &model));

    return 0;
}

这是一个简单的SVR实现，可以从数据文件中读取样本数据，计算并保存核矩阵，通过训练SVR模型来预测新的样本。代码中使用了高斯核函数，可以根据需要修改。需要注意的是，该实现中使用了简化版的SMO算法进行训练，不保证在所有情况下都能得到最优解。