初始PyTorch（一）：梯度下降

最新推荐文章于 2023-09-16 10:15:22 发布

nooobme

最新推荐文章于 2023-09-16 10:15:22 发布

阅读量378

点赞数 1

分类专栏：深度学习初始PyTorch

本文链接：https://blog.csdn.net/sleepinghm/article/details/105046342

版权

深度学习同时被 2 个专栏收录

30 篇文章 8 订阅

订阅专栏

初始PyTorch

15 篇文章 1 订阅

订阅专栏

一、批量梯度下降Batch Gradient Descent：

普通的BGD算法是每次迭代把所有样本都过一遍，每训练一组样本就把梯度更新一次。
简单的一元二次方程：y=wx+b，有时加入噪声 $\varepsilon$ 。损失函数 $loss=\frac{1}{n}*(wx+b-y)^{2}$

def loss(b, w, points):
    totalError = 0
    for i in range(0, len(points)):
        x = points[i, 0]
        y = points[i, 1]
        totalError += (y - (w * x + b)) ** 2
    return totalError / float(len(points))

利用梯度下降法求损失函数的最小的那个点：

对 $loss=\frac{1}{n}*(wx+b-y)^{2}$ 求[w,b]的偏导，其中 $\frac{\Delta loss}{\Delta b}= 2*\frac{1}{n}*(wx+b-y)$ , $\frac{\Delta loss}{\Delta w}= 2*\frac{1}{n}*x*(wx+b-y)$ 。

优化函数：x=x-lr*x'

其中执行一次：

def step_gradient(b_current, w_current, points, learningRate):
    b_gradient = 0
    w_gradient = 0
    N = float(len(points))
    for i in range(0, len(points)):
        x = points[i, 0]
        y = points[i, 1]
        b_gradient += -(2/N) * (y - ((w_current * x) + b_current))
        w_gradient += -(2/N) * x * (y - ((w_current * x) + b_current))
    new_b = b_current - (learningRate * b_gradient)
    new_m = w_current - (learningRate * w_gradient)
    return [new_b, new_m]

执行N次：

def gradient_descent_runner(points, starting_b, starting_m, learning_rate, num_iterations):
    b = starting_b
    m = starting_m
    for i in range(num_iterations):
        b, m = step_gradient(b, m, np.array(points), learning_rate)
    return [b, m]

运行：

def run():
#设置lr为0.0001,bm初始值为0，迭代1000次，points导入csv。
    learning_rate = 0.0001
    initial_b = 0 
    initial_m = 0 
    num_iterations = 1000

    [b, m] = gradient_descent_runner(points, initial_b, initial_m, learning_rate, num_iterations)

Gradient API:

autograd.grad自动求梯度

#求w的梯度 αloss/αw
w=torch.tensor([1.],require_regred=True)  #w.requires_grad_()
mse=F.mse_loss(y_pred,w*x+b)
torch.autograd.grad(mse,[w])#[W1,W2...Wn]

loss.backward求梯度

mse=F.mse_loss(y_pred,y)
mse.backward()
w.grad
#w.grad.norm()是对w梯度求二范式

随机梯度下降Stochastic Gradient Descent

函数： $H(\Theta)=\sum \Theta_{j} *x_{j}=\Theta_{0}+\Theta_{1}*x_{1}+...$ ，损失函数：

最小化损失函数，参数θ按其负梯度方向来更新：

SGD算法是从样本中随机抽出一组，训练后按梯度更新一次，然后再抽取一组，再更新一次，在样本量及其大的情况下，可能不用训练完所有的样本就可以获得一个损失值在可接受范围之内的模型了。

optimizer = optim.SGD(model.parameters(), lr = 0.01, momentum=0.9) #w=w'-lr*w'

待扩展

pytorch中使用torch.optim优化神经网络以及优化器的选择

torch.optim

各种优化方法总结比较

Adam...

optimizer = optim.Adam([var1, var2], lr = 0.0001)

x = torch.tensor([-4., 0.], requires_grad=True)
optimizer = torch.optim.Adam([x], lr=1e-3) #x=x-x'*lr,y=y-y'*lr
for step in range(20000):

    pred = himmelblau(x)

    optimizer.zero_grad()
    pred.backward()
    optimizer.step()

    if step % 2000 == 0:
        print ('step {}: x = {}, f(x) = {}'
               .format(step, x.tolist(), pred.item()))