理论与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) * X
   d(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 y
	freopen("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;
}

训练效果

和pytorch的训练效果对比