【D L-梯度下降与随机梯度下降算法-course 03 04】

于 2022-06-09 15:30:14 发布
阅读量133 收藏
点赞数 2
分类专栏： 深度学习基础-基于河工大 文章标签： 算法 机器学习 深度学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/zjusteel/article/details/125195329
版权

D L-梯度下降与随机梯度下降算法-course 03 04

D L-梯度下降与随机梯度下降算法-course 03 04

一、梯度下降与随机梯度下降

基本概念

1.凸函数

首先介绍凸函数的概念：
凸函数最简单的概念就是，可以求得全局的最优解
数学的表达就是，连接函数的两个点，函数上的点都在直线的下方。
在这里插入图片描述

2.梯度下降算法（Gradient Descent Algorithm）

目前为止，我们不怎么使用梯度下降算法，常用的是随机梯度下降算法
1.我们在梯度下降算法用的是数据集的平均损失
2.权重的更新方向公式如下所示：朝着梯度下降的方向更新。
缺点是： 会找到局部最优值，就不会继续更新； 并且当陷入鞍点（此时梯度为0），那么由于导数是0，权重不会继续更新，程序终止
在这里插入图片描述

在这里插入图片描述

进一步的，我们求出平均损失对权重的倒数，带入更新公式中：
在这里插入图片描述

3.随机梯度下降算法(Stochastic Gradient Descend )

随机梯度下降是：选择当前x对应的损失loss，从而更新权重w。
在这里插入图片描述

二、梯度下降与随机梯度下降程序

1. 梯度下降代码

# 梯度下降-神经网络基本用的是随机梯度下降，本文是传统梯度下降
# 绘图包
import numpy as np
import matplotlib.pyplot as plt

# Training set
x_data=[1.0,2.0,3.0]
y_data=[2.0,4.0,6.0]
#初始估计一个权重，然后后面梯度下降迭代
w=1.0
def forward(x):
    return x*w

# 求平均损失函数 输入为两个set x y
def cost(xs,ys):
    cost=0
    for x,y in zip(xs,ys):
        y_pred=forward(x)
        cost=cost+(y_pred-y)**2
    return cost/len(xs)
# 定义梯度函数 权重的下降速率 w=w-gradient*学习率
def gradient(xs,ys):
    grad=0
    for x,y in zip(xs,ys):
        grad=grad+2*x*(x*w-y)
        return grad/len(xs)

print('prodict (before training)',4,forward(4))

costarr=[]
warr=[]

# epoch 是进行训练的次数，我们进行100次训练，也就对w进行100次迭代
for epoch in range(100):
    cost_val=cost(x_data,y_data)
    warr.append(round(w,2))  # round函数 round（数，要保留的小数位数）
    costarr.append(round(cost_val,2))
    grad_val=gradient(x_data,y_data)
    # 更新权重 学习率为0.01
    w=w-0.1*grad_val
    print('Epoch=',epoch,'权重w=',w,'loss=',cost_val)
print('prodict (after training)',4,forward(4))


plt.plot(warr,costarr)
plt.ylabel('Loss')
plt.xlabel('Weight')
plt.show()
output： prodict (after training) 4 7.9959659836547035

在这里插入图片描述

2. 随机梯度下降代码

很明显我们发现，损失函数选取当前数据集的x,y进行计算，权重的更新基于每一个点对应的损失函数进行。

 随机梯度下降
# 绘图包
import numpy as np
import matplotlib.pyplot as plt

# Training set
x_data=[1.0,2.0,3.0]
y_data=[2.0,4.0,6.0]
#初始估计一个权重，然后后面梯度下降迭代
w=1.0
def forward(x):
    return x*w

# 随机梯度下降只需要求损失函数不需要求平均
def lost(xs,ys):
    y_pred=forward(xs)
    return (y_pred-ys)**2

# 定义梯度函数 权重的下降速率 w=w-gradient*学习率
def gradient(xs,ys):
    return 2*(w*xs-ys)*xs

print('prodict (before training)',4,forward(4))

lostarr=[]
warr=[]

# epoch 是进行训练的次数，我们进行100次训练，也就对w进行100次迭代
for epoch in range(100):
    for x,y in zip(x_data,y_data):
        # 梯度为随机值，与此时x，y的取值有关

        grad=gradient(x,y)
        # 更新权重 0.01为学习率
        w=w-0.01*grad
        print('\t',x,y,grad)
        warr.append(w)
        # 此时的损失为：
        l=lost(x,y)
        lostarr.append(l)

print('prodict (after training)',4,forward(4))


plt.plot(warr,lostarr)
plt.ylabel('Loss')
plt.xlabel('Weight')
plt.show()

output：prodict (after training) 4 7.9999999999996945

在这里插入图片描述

3. 对比分析

1.从结果来看：

梯度output： prodict (after training) 4 7.9959659836547035
随机梯度output：prodict (after training) 4 7.9999999999996945

预测很接近真实值
2.从L-W更新图像来看：
随机梯度下降引入了随机的更新权重，最后也趋于收敛

4. 收敛问题

曲线出现上升段就是不收敛，发散
学习率比较大的时候可能也会出现不收敛
在这里插入图片描述

三、神经网络与反向传播

1.基础概念

1.1 神经网络的构建过程：

就是 y=wx+b 获得的估计y 不断地作为下一层的x ，实现深度学习
在这里插入图片描述
在这里插入图片描述

1.2 用一次函数构建面临的问题：

在老师的例子中 y=wx+b进行构建模型，实际上，当你两层网络的时候，会发现，基本没区别，因此我们一般需要sigmod函数进行转变，这在本次文章未涉及
在这里插入图片描述
在这里插入图片描述

1.3 反向传播是什么

反向传播就是获取了损失之后，反过来求沿途的导数，最终用链式法则组合所有的倒数求得
L/W的导数，从而更新W。这就是反向传播的本质
在这里插入图片描述

在这里插入图片描述

2. pytorch 基础部分1

2.0 torch初始运行失败的代码添加

我电脑上 pytorch 报错
OMP: Error #15: Initializing libiomp5md.dll, but found libiomp5md.dll already initialized
下面两行代码放到程序最上面


# 下面两行代码放到程序最上面
import os
os.environ['KMP_DUPLICATE_LIB_OK']='True'

2.1 tensor的概念

W这个tensor本质上包含了 权重本身和梯度，因此我们在读取数据的时候最好使用w.data，这样不会构建计算图，直接获取数据
在这里插入图片描述

2.2 梯度的计算

遇到 w.requires_grad 开始进行梯度计算
在这里插入图片描述
遇到l.backward 找到计算的终点，那么读取梯度就是：w.grad 就是 loss对w的梯度
在这里插入图片描述

2.3 数据的提取

提取标量数据我们一般用 item（）
对于向量以上数据我们用 data（）
这两个操作不会构建计算图，不会计算梯度，不会影响当前计算梯度

2.4 散点图的绘制

在下节 3.2 介绍 scatter 绘制散点图

3. pytorch 代码部分

3.1 线性模型-单权重-回归分析

模型用： y=w x
回归分析

# 我电脑上pytorch报错，OMP: Error #15: Initializing libiomp5md.dll, but found libiomp5md.dll already initialized
# 下面两行代码放到程序最上面
import os
os.environ['KMP_DUPLICATE_LIB_OK']='True'
import torch
import matplotlib.pyplot as plt
import numpy as np
# 简单的数据集
x_data=[1.0,2.0,3.0]
y_data=[2.0,4.0,6.0]

# 存入tensor，开始计算梯度
# 初始给定w 一个初值 1.0 w=1.0
w=torch.Tensor([1.0])
w.requires_grad=True

# 定义 带估计函数 和 损失函数//基于随机梯度下降 ，求当前的损失就行，不需要平均损失
def forward(x):
    return x*w

def loss(x,y):
    y_pred=forward(x)
    return (y_pred-y)**2

print('predict before training',4,forward(4).item())
# 重中之重的 item方法 获取标量tensor的数值  而一旦tensor是向量我们用 data获取数据，这两个方法不会构建计算图，可以放心提取数据
warr=[]
lossarr=[]
# 进行循环，训练100次
for epoch in range(100):
    for x,y in zip(x_data,y_data):
        l=loss(x,y)
        warr.append(w.item())
        lossarr.append(l.item())
        # 获取损失后反向传播
        l.backward()
        # w.grad 获取的是  损失对w的梯度
        print('\tgrad:',x,y,w.grad.item())
        # 更新我的权重，不额外构建计算图，因此用data
        w.data=w.data-0.01*w.grad.data
        # 梯度归零
        w.grad.data.zero_()
    print('progress',epoch,l.item())
print('predict after training',4,forward(4).item())

plt.plot(warr,lossarr)
plt.ylabel('Loss')
plt.xlabel('Weight')
plt.show()

output：predict after training 4 7.999998569488525

在这里插入图片描述

3.2 二次模型-多权重-回归分析

模型用： y=w 1 * x^2+ w 2 * x + b 三个参数
回归分析

# 我电脑上pytorch报错，OMP: Error #15: Initializing libiomp5md.dll, but found libiomp5md.dll already initialized
# 下面两行代码放到程序最上面
import os
os.environ['KMP_DUPLICATE_LIB_OK']='True'
import torch
import matplotlib.pyplot as plt
import numpy as np

# 训练集
x_data=[1.0,2.0,3.0]
y_data=[4.0,9.0,16.0]

# 初始给定w 一个初值 1.0 w=1.0
w1=torch.tensor([1.0])
w1.requires_grad=True

w2=torch.tensor([1.0])
w2.requires_grad=True

b=torch.tensor([1.0])
b.requires_grad=True


# 定义# 定义 带估计函数 和 损失函数//基于随机梯度下降 ，求当前的损失就行，不需要平均损失
# 平方模型forward y=w1*x**2+w2*x+b
def forward(x):
    return w1*x**2+w2*x+b

def loss(x,y):
    y_pred=forward(x)
    return (y-y_pred)**2

print('predict before training',4,forward(4).item())

w1arr=[]
w2arr=[]
barr=[]
lossarr=[]

# 进行循环，训练100次
for epoch in range(100):
    for x,y in zip(x_data,y_data):
        l=loss(x,y)
        w1arr.append(w1.item())
        w2arr.append(w2.item())
        barr.append(b.item())
        lossarr.append(l.item())
        # 反向传播
        l.backward()
        print('\tgrad of w1,w2,b :', x, y, w1.grad.item(),w2.grad.item(),b.grad.item())
        # 多参数更新权重 每个参数都向着loss最小的方向
        w1.data=w1.data-0.0001*w1.grad.data
        w2.data=w2.data-0.0001*w2.grad.data
        b.data=b.data-0.0001*b.grad.data
        # 梯度归零
        w1.grad.data.zero_()
        w2.grad.data.zero_()
        b.grad.data.zero_()
    print('progress', epoch, l.item())
print('predict after training', 4, forward(4).item())

plt.plot(w1arr,lossarr)
plt.ylabel('Loss')
plt.xlabel('Weight-1')
plt.show()

plt.plot(w2arr,lossarr)
plt.ylabel('Loss')
plt.xlabel('Weight-2')
plt.show()

plt.plot(barr,lossarr)
plt.ylabel('Loss')
plt.xlabel('B-weight')
plt.show()

# 绘制散点图像
for i in range (len(x_data)):
    plt.scatter(x_data[i],y_data[i],c='blue')

# 生成训练图像
xplot=[i for i in np.arange(0,5,0.1)]
yplot=[]
for k in range(0,len(xplot)):
    yplotnow=w1arr[-1]*xplot[k]**2+w2arr[-1]*xplot[k]+barr[-1]
    yplot.append(yplotnow)
plt.scatter(4.0,forward(4).item(),c='red',label='Predict point')
plt.plot(xplot,yplot,label='Regression line')
plt.legend()
plt.show()
output： predict after training 4 26.02387237548828

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
蓝色的点是数据集，红色的点是预测点

四、参考文献

https://www.bilibili.com/video/BV1Y7411d7Ys?p=4
感谢大佬

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值