神经网络基础原理-使用梯度下降训练二次函数模型简单示例

一、导数和偏导数

二、梯度下降算法整体代码

python 复制代码

import math
import sys

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


# y =  2 * x ** 2 + 3 * x + 4
#给模型一组数字，这组数字是 y =  2 * x ** 2 + 3 * x + 4 根据这个公式计算的x和y , 然后通过梯度下降算法求出模型参数
X = [0.0, 0.01, 0.02, 0.03, 0.04, 0.05, 0.06, 0.07, 0.08, 0.09, 0.1, 0.11, 0.12, 0.13, 0.14, 0.15, 0.16, 0.17, 0.18, 0.19, 0.2, 0.21, 0.22, 0.23, 0.24, 0.25, 0.26, 0.27, 0.28, 0.29, 0.3, 0.31, 0.32, 0.33, 0.34, 0.35000000000000003, 0.36, 0.37, 0.38, 0.39, 0.4, 0.41000000000000003, 0.42, 0.43, 0.44, 0.45, 0.46, 0.47000000000000003, 0.48, 0.49, 0.5, 0.51, 0.52, 0.53, 0.54, 0.55, 0.56, 0.5700000000000001, 0.58, 0.59, 0.6, 0.61, 0.62, 0.63, 0.64, 0.65, 0.66, 0.67, 0.68, 0.6900000000000001, 0.7000000000000001, 0.71, 0.72, 0.73, 0.74, 0.75, 0.76, 0.77, 0.78, 0.79, 0.8, 0.81, 0.8200000000000001, 0.8300000000000001, 0.84, 0.85, 0.86, 0.87, 0.88, 0.89, 0.9, 0.91, 0.92, 0.93, 0.94, 0.95, 0.96, 0.97, 0.98, 0.99]
Y = [4.0, 4.0302, 4.0608, 4.0918, 4.1232, 4.155, 4.1872, 4.2198, 4.2528, 4.2862, 4.32, 4.3542, 4.3888, 4.4238, 4.4592, 4.495, 4.5312, 4.5678, 4.6048, 4.6422, 4.68, 4.7181999999999995, 4.7568, 4.7958, 4.8352, 4.875, 4.9152000000000005, 4.9558, 4.9968, 5.0382, 5.08, 5.122199999999999, 5.1648, 5.2078, 5.2512, 5.295, 5.3392, 5.3838, 5.4288, 5.4742, 5.5200000000000005, 5.5662, 5.6128, 5.6598, 5.7072, 5.755, 5.8032, 5.851800000000001, 5.9008, 5.9502, 6.0, 6.0502, 6.1008, 6.1518, 6.203200000000001, 6.255000000000001, 6.3072, 6.3598, 6.4128, 6.4662, 6.52, 6.5742, 6.6288, 6.6838, 6.7392, 6.795, 6.8512, 6.9078, 6.9648, 7.022200000000001, 7.08, 7.138199999999999, 7.1968, 7.2558, 7.3152, 7.375, 7.4352, 7.4958, 7.5568, 7.6182, 7.680000000000001, 7.7422, 7.8048, 7.867800000000001, 7.9312, 7.994999999999999, 8.0592, 8.1238, 8.1888, 8.2542, 8.32, 8.3862, 8.4528, 8.5198, 8.587200000000001, 8.655000000000001, 8.7232, 8.7918, 8.8608, 8.9302]    

# 我们实际的w1是2，w2是3，w3是4。现在我们根据样本数据X和Y,根据梯度下降算法去求出w1,w2,w3
def func(x):
    y = w1 * x ** 2 + w2 * x + w3 
    return y

def loss(y_pred, y_true):
    return (y_pred - y_true) ** 2


# 权重随机初始化
w1, w2, w3 = 1,0,-1

# 学习率设置
lr = 0.1

#batch size
batch_size = 1

# 训练过程
for epoch in range(1000):
    epoch_loss = 0
    grad_w1 = 0
    grad_w2 = 0
    grad_w3 = 0
    counter = 0
    print("第%d轮训练开始" %(epoch))
    print("更新前权重:w1:%f w2:%f w3:%f" %(w1, w2, w3))
    for x, y_true in zip(X, Y):
        y_pred = func(x)
        # 计算loss
        epoch_loss += loss(y_pred, y_true)
        counter += 1
        #梯度计算
        grad_w1 += 2 * (y_pred - y_true) * x ** 2
        grad_w2 += 2 * (y_pred - y_true) * x 
        grad_w3 += 2 * (y_pred - y_true) 
        if counter == batch_size:
            #权重更新
            w1 = w1 - lr * grad_w1/batch_size   #sgd 
            w2 = w2 - lr * grad_w2/batch_size
            w3 = w3 - lr * grad_w3/batch_size
            counter = 0
            #梯度清零
            grad_w1 = 0
            grad_w2 = 0
            grad_w3 = 0
    epoch_loss =  epoch_loss/len(X)
    print("第%d轮训练loss:%f" %(epoch, epoch_loss))
    print("更新后权重:w1:%f w2:%f w3:%f" %(w1, w2, w3))
    print("--------------------------------------------------")
    if epoch_loss < 0.00001:
        break

print(f"训练后权重:w1:{w1} w2:{w2} w3:{w3}")

#使用训练后模型输出预测值
Yp = [func(i) for i in X] 
print('yp',Yp)

# 求导说明：
# 对损失函数 ：(y_pred  - y_true) ** 2，求w1的梯度
# 链式法则
# 令 u = y_pred  - y_true， 即损失函数为 = u ** 2
# 所以根据链式法则，w1的导函数为 = 2u * du/dw1 （对w1的偏导数）
# 因为 u = y_pred  - y_true = w1 * x**2 +  w2 *x + w3 - y_true
# 所以 du/dw1 = x ** 2  (除w1外，其他字母都看做常数，常数导数为0)
# 所以导函数 = 2u * x ** 2
# 同理可得w2,w3的导函数
# 所以梯度 = [2u * x ** 2, 2u * x, 2u]

1. 为什么要对损失函数求梯度？

因为我们的目标是让损失函数最小化，而不是让模型输出本身最小化。

损失函数衡量的是模型预测值与真实值之间的差距（这里是均方误差）

我们希望通过调整权重 w1,w2,w3，使得这个差距尽可能小

梯度方向是损失函数增长最快的方向，梯度的反方向就是下降最快的方向

所以：

对损失函数求梯度 → 找到损失下降最快的方向 → 沿反方向更新权重 → 损失逐渐减小

2. 为什么不是对模型函数求梯度？

但这只是模型输出对权重的变化率，并没有告诉我们如何让模型更接近真实值。

总结一句话：梯度下降的核心是最小化损失，所以必须对损失函数求梯度，而不是对模型本身求梯度。模型只是工具，损失才是目标。

3、为什么梯度是偏导数？

4.对损失函数求梯度的过程

L是LOSS损失函数的意思