numpy实现简单训练过程

主要分为四步：前向传播，计算损失，反向传播（链式求导），梯度下降。

导入必要的库并初始化数据集和权重变量：

import numpy as np

X = [0.01 * x for x in range(100)]  # 创建输入特征X
Y = [2*x**2 + 3*x + 4 for x in X]  # 创建对应的目标输出Y

w1, w2, w3 = [0 for i in range(3)]  # 初始化模型参数
grad_w1, grad_w2, grad_w3 = [0 for i in range(3)]  # 初始化梯度值

设定训练参数 

epoch = 200  # 训练轮数
batch_size = 10  # 每个小批次的样本数量
lr = 0.1  # 学习率

开始训练模型：

for _ in range(epoch):  # 遍历每个训练轮数
    loss = 0
    for i in range(len(X)//batch_size):  # 分批次处理数据
        x = np.array(X[i*batch_size:(i+1)*batch_size])  # 获取当前批次的输入特征
        y = np.array(Y[i*batch_size:(i+1)*batch_size])  # 获取当前批次的目标输出

        y_pred = w1 * x ** 2 + w2 * x + w3  # 前向传播，计算预测输出
        loss += np.sum((y_pred - y) ** 2 / 2)  # 计算损失函数
        
        # 反向传播，计算梯度
        grad_w1 = np.sum((y_pred - y) * (x ** 2))
        grad_w2 = np.sum((y_pred - y) * (x))
        grad_w3 = np.sum((y_pred - y) * (1))
        
        # 更新权重，使用梯度下降算法
        w1 -= lr * grad_w1 / batch_size
        w2 -= lr * grad_w2 / batch_size
        w3 -= lr * grad_w3 / batch_size

    print(f"=======第{_}轮=======")
    print(f"loss: {loss/len(X)}")

输出训练结果：

print(w1, w2, w3)  # 输出训练得到的参数值

整体框架包括数据准备、模型定义、训练循环以及参数更新。在每个训练迭代中，先进行前向传播计算预测值，然后计算损失，接着利用反向传播计算梯度，最后根据梯度下降方法更新模型参数。每轮训练结束后，输出当前轮数和损失值。

完整代码如下：

import numpy as np

X = [0.01 * x for x in range(100)]
Y = [2*x**2 + 3*x + 4 for x in X]

w1, w2, w3= [0 for i in range(3)]
grad_w1, grad_w2, grad_w3 = [0 for i in range(3)]
# y_pred = w1*x**2 + w2*x + w3
epoch = 200
batch_size = 10
lr = 0.1
for _ in range(epoch):
    cnt = 0
    loss = 0
    for i in range(len(X)//batch_size):
        x = np.array(X[i*batch_size:(i+1)*batch_size])
        y = np.array(Y[i*batch_size:(i+1)*batch_size])
        y_pred = w1 * x ** 2 + w2 * x + w3 #前向传播
        loss += np.sum((y_pred - y)**2 / 2) #计算loss
        # 反向传播，求loss的导数
        grad_w1 = np.sum((y_pred - y) * (x ** 2))
        grad_w2 = np.sum((y_pred - y) * (x))
        grad_w3 = np.sum((y_pred - y) * (1))
        # 梯度下降
        w1 -= lr*grad_w1/batch_size
        w2 -= lr*grad_w2/batch_size
        w3 -= lr*grad_w3/batch_size
    print(f"=======第{_}轮=======")
    print(f"loss: {loss/len(X)}")
print(w1,w2,w3)