c++ 实现梯度下降线性回归模型

理论与python实现部分

3.1. 线性回归 — 动手学深度学习 2.0.0 documentation

c++代码

没能力实现反向传播求梯度，只能自己手动算导数了

#include <bits/stdc++.h>
#include <time.h>
using namespace std;//y_hat = X * W + b
// linreg 函数：线性回归预测  
// 参数：  
//   double** X: 输入数据的二维数组，其中 X[i][j] 表示第 i 个样本的第 j 个特征  
//   double* W: 权重向量，W[j] 表示第 j 个特征的权重  
//   double b: 偏置项  
//   int batch_size: 批量大小，即一次处理的样本数量  
//   int lenw: 权重向量的长度，即特征的数量  
// 返回值：  
//   double* y_hat: 预测值的数组，长度为 batch_size  
double* linreg(double** X, double* W, double b, int batch_size, int lenw)
{// 分配内存来存储预测值  double* y_hat = new double[batch_size];// 遍历每一个样本  for (int i=0; i<batch_size; i++){double sum=0;  // 求和计算 X * W // 遍历每一个特征  for (int j=0; j<lenw; j++){// 累加该样本的每个特征与对应权重的乘积sum += X[i][j]*W[j];}// 加上偏置项得到最终的预测值  y_hat[i] = sum+b;}// 返回预测值的数组return y_hat;
}// squared_loss 函数：计算平方损失  
// 参数：  
//   double* y_hat: 预测值的数组  
//   double* y: 实际值的数组  
//   int len: 预测值和实际值的长度（应相同）  
// 返回值：  
//   double* l: 平方损失的数组，长度为 len  
double* squared_loss(double* y_hat, double* y, int len)
{// 分配内存来存储平方损失  double* l = new double[len];// 遍历每一个预测值与实际值for (int i=0; i<len; i++){// 计算平方损失 (y_hat[i]-y[i])^2 的一半（常用在损失函数中）l[i] = 0.5 * (y_hat[i]-y[i]) * (y_hat[i]-y[i]);}// 返回平方损失的数组 return l;
}// sum 函数：计算数组的和  
// 参数：  
//   double* l: 需要求和的数组  
//   int len: 数组的长度  
// 返回值：  
//   double ans: 数组的和 
double sum(double* l, int len)
{double ans=0; // 初始化和为0  for (int i=0; i<len; i++){ans += l[i]; // 累加数组中的每一个元素  }return ans; // 返回数组的和  
}// sgd 函数：使用随机梯度下降（Stochastic Gradient Descent）算法更新权重和偏置项  
// 参数：  
//   double** X: 输入数据的二维数组，其中 X[i][j] 表示第 i 个样本的第 j 个特征  
//   double* y: 实际值的数组，与输入数据一一对应  
//   double* W: 权重向量，W[j] 表示第 j 个特征的权重  
//   double &b: 偏置项的引用，以便在函数内部修改其值  
//   int lenw: 权重向量的长度，即特征的数量  
//   double lr: 学习率（Learning Rate），用于控制权重更新的步长  
//   int batch_size: 批量大小，即一次处理的样本数量  
// 返回值：  
//   无返回值，但会直接修改 W 和 b 的值  
/*
y_hat = X * W + b
loss = 0.5 * (y_hat - y) * (y_hat - y)
d(loss)/d(y_hat) = y_hat - y
d(y_hat)/d(W) = X
d(y_hat)/d(b) = 1
∴ d(loss) / d(W) = d(loss)/d(y_hat) * d(y_hat)/d(W) = (y_hat - y) * Xd(loss) / d(b) = d(loss)/d(y_hat) * d(y_hat)/d(b) = (y_hat - y) * 1
*/ 
void sgd(double** X, double* y, double* W, double &b, int lenw, double lr, int batch_size)
{// 调用 linreg 函数获取预测值  double* y_hat = linreg(X, W, b, batch_size, lenw);// 计算每个权重的梯度 for (int i=0; i<lenw; i++){double grad=0;// 初始化当前权重的梯度为0  for (int j=0; j<batch_size; j++){// 计算梯度：每个样本的梯度为该样本的特征值与预测误差的乘积grad += X[j][i]*(y_hat[j]-y[j]);}// 更新权重：使用学习率乘以平均梯度（梯度之和 除以batch_size），并从当前权重中减去  W[i] = W[i] - lr * grad / batch_size;}// 计算偏置项的梯度  double grad=0; // 初始化偏置项的梯度为0  for (int j=0; j<batch_size; j++){// 计算梯度和：所有样本的预测误差之和 grad += (y_hat[j]-y[j]);}// 更新偏置项：使用学习率乘以平均梯度（除以batch_size），并从当前偏置项中减去  b = b - lr * grad / batch_size;// 释放预测值数组的内存delete[] y_hat;
}int main()
{// 设定真实的权重和偏置项，用于比较训练结果  const double true_w[] = {3.3, -2.4}, true_b = 11.4;// 设定权重向量的长度  const int lenw=2;// 初始化权重和偏置项  double w[lenw] = {0, 0}; // 理论上应该可以为任意值double b=0.0;// 设定样本数量 int sample_num=2000;// 分配二维数组内存用于存储特征数据  double** X = new double*[sample_num];for (int i=0; i<sample_num; i++) X[i] = new double[lenw];// 分配一维数组内存用于存储实际标签  double y[sample_num];// 打开数据文件datas.txt并读取特征数据和标签  // 单行数据格式 x1 x2 x3 ... xn yfreopen("datas.txt", "r", stdin);for (int i=0; i<sample_num; i++){for (int j=0; j<lenw; j++){scanf("%lf", &X[i][j]); // 读取特征值 }scanf("%lf", &y[i]); // 读取标签  }// 关闭数据文件，并重新打开标准输入  freopen("CON", "r", stdin);// 设定学习率、迭代次数和批量大小 double lr = 0.03;int num_epochs = 800; // 将数据集分成50个批次 int batch_size = sample_num/50;double* (*net) (double**, double*, double, int, int);double* (*loss) (double*, double*, int);net = linreg;// 函数指针，没啥实际用处loss = squared_loss;time_t st=clock();// 迭代训练模型  for (int epoch=0; epoch < num_epochs; epoch++){// 计算当前批次的预测值  double* y_hat = net(X, w, b, batch_size, lenw);// 计算当前批次的损失  double loss1 = sum(loss(y_hat, y, batch_size), batch_size);// 使用随机梯度下降更新权重和偏置项  // 如果不需要输出查看训练过程的损失，每次迭代其实只需要sgd函数就可以完成训练（即参数 w 和 b 的更新） sgd(X, y, w, b, lenw, lr, batch_size);// 计算整个数据集的预测值  double* y1_hat = linreg(X, w, b, sample_num, lenw);// 计算整个数据集的损失 double loss2 = sum(loss(y1_hat, y, sample_num), sample_num);// 每50个迭代周期打印一次训练损失if (epoch%50 == 0)printf("in epoch %d, train loss is %lf\n", epoch+1, loss2/sample_num);// 释放当前批次和整个数据集预测值的内存  delete[] y_hat;delete[] y1_hat; }// 设定测试样本数量int test_num=30;// 分配二维数组内存用于存储测试数据  double** test_X = new double*[test_num];for (int i=0; i<test_num; i++) test_X[i] = new double[lenw];// 分配一维数组内存用于存储测试标签  double test_y[test_num];// 打开测试数据文件tests.txt并读取测试数据和标签 freopen("tests.txt", "r", stdin);for (int i=0; i<test_num; i++){for (int j=0; j<lenw; j++){scanf("%lf", &test_X[i][j]); // 读取测试特征值  }scanf("%lf", &test_y[i]); // 读取测试标签  }// 关闭测试数据文件，并重新打开标准输入  freopen("CON", "r", stdin);// 计算测试集的预测值double* test_y_hat = linreg(test_X, w, b, test_num, lenw);// 计算测试数据的损失值  double loss2 = sum(squared_loss(test_y_hat, test_y, test_num), test_num);// 计算测试数据的平均损失值  double loss_mean = loss2 / test_num;printf("in test, loss is %lf\n", loss_mean);printf("w is ");for (int i=0; i<lenw; i++) printf("%lf%c", w[i], i==(lenw-1)?'\n':' ');printf("b=%lf\n", b);printf("true_w is {3.3, -2.4}, true_b is 11.4\n");time_t ed=clock();printf(" %d epoch, time %d ms\n", num_epochs, ed-st);// 注意：这里还需要释放test_X数组的内存，以及之前分配的X数组的内存  // 释放test_X数组的内存  for (int i = 0; i < test_num; i++) {  delete[] test_X[i];  }  delete[] test_X;  // 释放X数组的内存（注意：这部分代码应在前面的循环之后添加）  for (int i = 0; i < sample_num; i++) {  delete[] X[i];  }  delete[] X;
}

训练效果