判别分析逐步判别 C++代码

以下是一个简单的C++实现逐步判别分析的代码示例：

#include <iostream>
#include <vector>

using namespace std;

// 定义一个结构体来存储样本数据
struct Sample {
    vector<double> features;    // 样本特征
    int label;                  // 样本标签
};

// 定义一个函数来计算样本的平均值
double calc_mean(vector<double>& samples) {
    double sum = 0.0;
    for (int i = 0; i < samples.size(); i++) {
        sum += samples[i];
    }
    return sum / samples.size();
}

// 定义一个函数来计算样本的方差
double calc_variance(vector<double>& samples, double mean) {
    double sum = 0.0;
    for (int i = 0; i < samples.size(); i++) {
        sum += pow(samples[i] - mean, 2);
    }
    return sum / (samples.size() - 1);
}

// 定义一个函数来计算样本之间的距离
double calc_distance(vector<double>& sample1, vector<double>& sample2) {
    double sum = 0.0;
    for (int i = 0; i < sample1.size(); i++) {
        sum += pow(sample1[i] - sample2[i], 2);
    }
    return sqrt(sum);
}

// 定义逐步判别分析函数
vector<double> stepwise_discriminant_analysis(vector<Sample>& samples) {
    int n_features = samples[0].features.size();   // 特征数
    int n_samples = samples.size();                 // 样本数
    vector<double> means(n_features, 0.0);          // 平均值向量
    vector<vector<double>> covariances(n_features, vector<double>(n_features, 0.0));   // 协方差矩阵
    vector<double> weights(n_features, 0.0);        // 权重向量

    // 初始化均值向量和协方差矩阵
    for (int i = 0; i < n_features; i++) {
        vector<double> feature_samples;
        for (int j = 0; j < n_samples; j++) {
            feature_samples.push_back(samples[j].features[i]);
        }
        means[i] = calc_mean(feature_samples);
        covariances[i][i] = calc_variance(feature_samples, means[i]);
    }

    // 开始迭代计算权重向量
    for (int i = 0; i < n_features; i++) {
        double max_delta = 0.0;
        int max_feature_index = 0;

        // 对于每个特征，计算它的增益并记录最大增益
        for (int j = 0; j < n_features; j++) {
            if (weights[j] != 0.0) continue;    // 如果该特征已经被选中，则跳过
            double delta = 0.0;
            for (int k = 0; k < n_samples; k++) {
                vector<double> sample1 = samples[k].features;
                sample1.erase(sample1.begin() + j);   // 去掉当前特征
                double min_distance = 1e9;
                for (int l = 0; l < n_samples; l++) {
                    if (samples[l].label != samples[k].label) continue;
                    vector<double> sample2 = samples[l].features;
                    sample2.erase(sample2.begin() + j);   // 去掉当前特征
                    double distance = calc_distance(sample1, sample2);
                    if (distance < min_distance) {
                        min_distance = distance;
                    }
                }
                delta += min_distance;
            }
            // 记录最大增益
            if (delta > max_delta) {
                max_delta = delta;
                max_feature_index = j;
            }
        }

        // 更新权重向量
        weights[max_feature_index] = 1.0;
        for (int j = 0; j < n_features; j++) {
            if (j == max_feature_index) continue;
            if (weights[j] == 0.0) continue;
            double w1 = weights[j];
            double w2 = covariances[max_feature_index][max_feature_index] / covariances[j][j];
            double r = covariances[max_feature_index][j] / sqrt(covariances[max_feature_index][max_feature_index] * covariances[j][j]);
            double delta_w = (w1 + w2 * r) / (1 - pow(r, 2));
            weights[j] = delta_w;
        }
    }

    return weights;
}

int main() {
    vector<Sample> samples = {
        {{1.0, 2.0, 3.0}, 0},
        {{2.0, 3.0, 4.0}, 0},
        {{3.0, 4.0, 5.0}, 0},
        {{5.0, 6.0, 7.0}, 1},
        {{6.0, 7.0, 8.0}, 1},
        {{7.0, 8.0, 9.0}, 1}
    };

    vector<double> weights = stepwise_discriminant_analysis(samples);

    // 输出权重向量
    for (int i = 0; i < weights.size(); i++) {
        cout << "w" << i << " = " << weights[i] << endl;
    }

    return 0;
}

这段代码实现了一个简单的逐步判别分析算法，用于计算样本数据中每个特征的权重。在这个例子中，我们使用了一个包含6个样本的数据集，每个样本有3个特征和一个标签。我们首先计算每个特征的平均值和方差，并初始化协方差矩阵。然后，我们开始迭代计算权重向量。对于每个特征，我们计算它的增益并记录最大增益，然后更新权重向量。在更新权重向量时，我们使用了上一次迭代中已经选中的特征来计算新的权重。最终，我们得到了一个包含3个元素的权重向量，用于表示每个特征的重要性。