Lasso正则化逻辑回归C++实现

特征X是nxd个元素的一维数组，标签Y是nx1个元素的一维数组，模型参数w是dx1个元素的一维数组，正则化参数lambda，阈值参数t

#include <iostream>
#include <cmath>

// 定义软阈值函数
double softThreshold(double x, double t) {
    if (x > t)
        return x - t;
    else if (x < -t)
        return x + t;
    else
        return 0.0;
}

// Lasso 正则化逻辑回归的训练函数
void logistics_regression_Lasso(double* X, double* Y, double* w, double lambda, double t, int n, int d, int maxIter) {
    for (int iter = 0; iter < maxIter; iter++) {
        double* gradient = new double[d]();  // 梯度初始化为零向量
        double loss = 0.0;

        // 计算梯度和损失
        for (int i = 0; i < n; i++) {
            double wx = 0.0;
            for (int j = 0; j < d; j++) {
                wx += X[i * d + j] * w[j];
            }
            double p = 1.0 / (1.0 + exp(-wx));
            loss += -Y[i] * log(p) - (1.0 - Y[i]) * log(1.0 - p);
            for (int j = 0; j < d; j++) {
                gradient[j] += X[i * d + j] * (p - Y[i]);
            }
        }

        // 更新权重向量 w
        for (int j = 0; j < d; j++) {
            w[j] -= gradient[j] / n;
            w[j] = softThreshold(w[j], lambda * t);
        }

        // 输出每轮迭代的损失
        std::cout << "Iteration " << iter << ", Loss: " << loss << std::endl;

        delete[] gradient;  // 释放梯度数组的内存
    }
}

int main() {
    // 示例用法
    int n = /* 样本数量 */;
    int d = /* 特征维度 */;

    // 创建输入特征 X 的一维数组
    double* X = new double[n * d];
    // 将 X 的元素赋值为相应的特征值

    // 创建标签 Y 的一维数组
    double* Y = new double[n];
    // 将 Y 的元素赋值为相应的标签值

    // 创建初始化的模型参数 w 的一维数组
    double* w = new double[d];
    // 将 w 的元素赋值为初始化的参数值

    double lambda = 0.1;  // 正则化参数 lambda
    double t = 0.01;  // 阈值参数 t
    int maxIter = 100;  // 最大迭代次数

    // 调用训练函数
    logistics_regression_Lasso(X, Y, w, lambda, t, n, d, maxIter);

    // 释放内存
    delete[] X;
    delete[] Y;
    delete[] w;

    return 0;
}