机器学习中梯度下降法的简单例子
来源于pytorch的官方学习资料的总结
y = [0.5, 14.0, 15.0, 28.0, 11.0, 8.0, 3.0, -4.0, 6.0, 13.0, 21.0]
x = [35.7, 55.9, 58.2, 81.9, 56.3, 48.9, 33.9, 21.8, 48.4, 60.4, 68.4]
现在我们有十个点，横纵坐标如上所示，再图中可以表示为：
那我们要做的就是 预测出 a 和 b 去生成一条直线。无限的拟合这十个点。
也就是 预测出 y = ax + b 中的 a 和 b
我们可以通过x 的输出来自动形成一个 a, b 生成一个我们预测出的 y’
这个 y’ 肯定和 实际的结果 y 有很大的差距。我们把这个差距定义为损失函数loss:L = (y - y')**2
这个损失函数是一个二次方程，可以画出路线图如下所示：
那么梯度也就是倒数，关于 a 和 b 的倒数：
此时 loss 可以写成
L = (y - (ax+b))**2
这个loss 中有两个变量，我们可以求两个偏导，如下图所示：L 关于 a 的偏导叫做a的梯度（Ga），L关于b的偏导叫做b的梯度（Gb）。
我们的梯度下降法就是根据这个梯度的值来更新 a 和 b 的。
那么怎么根据梯度来更新 a 和 b 的值呢？
a = a - Ga
b = b - Gb
我们只需要很简单的减法就可以实现根据梯度来更新 a 和 b，当梯度大于0的时候，我们需要减小权值降低loss,反之相反。
那么我们要根据这个梯度怎样的进行学习呢，我们更新的过程应该是缓慢的，当梯度过大的时候我们需要其他的方法来控制我们的更新速度，这个时候我们就引入了learning rate。
a = a - Ga * learning rate
b = b - Gb * learning rate
学习率决定了我们每次更新的速度。每一次迭代我们都可以根据梯度更新权值，经过几千次的更新迭代后，我们会得到如下图所示的一条拟合于这十个点的线。
pytorch的代码如下：
import torch
import numpy
from matplotlib import pyplot as plt
t_c = [0.5, 14.0, 15.0, 28.0, 11.0, 8.0, 3.0, -4.0, 6.0, 13.0, 21.0]
t_u = [35.7, 55.9, 58.2, 81.9, 56.3, 48.9, 33.9, 21.8, 48.4, 60.4, 68.4]
t_c = torch.tensor(t_c)
t_u = torch.tensor(t_u)
# t_c = w * t_u + b
"""
predicted temperatures t_p/ actual measurements t_c
loss :
1. |t_p - t_c|
2. (t_p - t_c)^2
"""
def model(t_u, w, b):
return w * t_u + b
def loss_fn(t_p, t_c):
squared_diffs = (t_p - t_c)**2
return squared_diffs.mean()
w = torch.ones(1)
b = torch.zeros(1)
t_p = model(t_u, w, b)
loss = loss_fn(t_p, t_c) # tensor(1763.8846)
delta = 0.1
loss_rate_of_change_w = \
(loss_fn(model(t_u, w+delta, b), t_c) -
loss_fn(model(t_u, w-delta, b), t_c)) / (2.0 * delta)
"""
this code is saying that in a small neighborhood of the current values of w and b,
a unit increase in w leads to do some change in the loss.If the change is negative ,
you need to increase w to minimize the loss, whereas if the change is positive,you
need to decrease w.
"""
"""
you should scale the rate of change by a typically small factor, this scaling factor
has many names, the one used in machine learning is learning_rate.
"""
learning_rate = 1e-2
w = w - learning_rate * loss_rate_of_change_w
# we can do the same with b:
loss_rate_of_change_b = \
(loss_fn(model(t_u, w, b+delta), t_c) -
loss_fn(model(t_u, w, b-delta), t_c)) / (2.0 * delta)
b = b - learning_rate * loss_rate_of_change_b
def loss_fn(t_p, t_c):
squared_diffs = (t_p - t_c) ** 2
return squared_diffs.mean()
def dloss_fn(t_p, t_c):
dsq_diffs = 2 * (t_p - t_c)
return dsq_diffs
def model(t_u, w, b):
return w * t_u + b
def dmodel_dw(t_u, w, b):
return t_u
def dmodel_db(t_u, w, b):
return 1.0
def grad_fn(t_u, t_c, t_p, w, b):
dloss_dw = dloss_fn(t_p, t_c) * dmodel_dw(t_u, w, b)
dloss_db = dloss_fn(t_p, t_c) * dmodel_db(t_u, w, b)
return torch.stack([dloss_dw.mean(), dloss_db.mean()])
def training_loop(n_epochs, learning_rate, params, t_u, t_c):
for epoch in range(1, n_epochs+1):
w, b = params
t_p = model(t_u, w, b)
loss = loss_fn(t_p, t_c)
grad = grad_fn(t_u, t_c, t_p, w, b)
params = params - learning_rate * grad
print('params : ')
print(params)
print('grads : ')
print(grad)
print('Epoch %d, Loss %f' % (epoch, float(loss)))
return params
# normalize input got the same result
# t_un = t_u/t_u.sum() * 10 # Epoch 5000, Loss 2.937128
t_un = 0.1 * t_u # Epoch 5000, Loss 2.927648
params = training_loop(
n_epochs= 5000,
learning_rate=1e-2,
params=torch.tensor([1.0, 0.0]),
t_u=t_un,
t_c=t_c)
t_p = model(t_un, *params)
print(t_p.detach())
fig = plt.figure(dpi=70)
plt.xlabel('x_label')
plt.ylabel('y_label')
# plt.plot(t_u.numpy(), t_p.detach().numpy())
plt.plot(t_u.numpy(), t_c.numpy(), 'o')
plt.show()