PyTorch中的9种常见梯度下降算法与案例

最新推荐文章于 2024-05-07 18:07:46 发布
最新推荐文章于 2024-05-07 18:07:46 发布
阅读量1.4k 收藏 25
点赞数 2
分类专栏： python_算法学习 文章标签： pytorch 算法 python
原创作品，共同进步！
本文链接：https://blog.csdn.net/AdamCY888/article/details/129793347
版权

PyTorch中的9种常见梯度下降算法

本文将介绍PyTorch中的几种常见梯度下降算法，并提供相应的Python案例。

1. 批量梯度下降（Batch Gradient Descent）

批量梯度下降是最基础的梯度下降算法，通过使用全部训练数据计算损失函数的梯度来更新参数。在PyTorch中，可以通过定义损失函数和优化器来实现批量梯度下降。

例如，在简单线性回归问题中使用批量梯度下降：

import torch
import matplotlib.pyplot as plt

# 定义训练数据
X = torch.tensor([1, 2, 3, 4], dtype=torch.float32)
Y = torch.tensor([2, 4, 6, 8], dtype=torch.float32)

# 初始化模型参数
w = torch.tensor(0.0, requires_grad=True)
b = torch.tensor(0.0, requires_grad=True)

# 定义损失函数
loss_fn = torch.nn.MSELoss()

# 定义优化器和超参数
optimizer = torch.optim.SGD([w, b], lr=0.01)
epochs = 100

# 批量梯度下降
for epoch in range(epochs):
    # 前向传播
    Y_pred = w * X + b
    # 计算损失
    loss = loss_fn(Y_pred, Y)
    # 反向传播
    loss.backward()
    # 更新参数
    optimizer.step()
    # 清空梯度
    optimizer.zero_grad()

# 输出结果
print(f"w = {w.item()}, b = {b.item()}")

# 绘制拟合直线
plt.scatter(X.numpy(), Y.numpy())
plt.plot(X.numpy(), (w * X + b).detach().numpy(), 'r')
plt.show()

输出：

w = 1.9999034404754639, b = 0.00041007260753999686

绘制的拟合直线如下图所示：

在这里插入图片描述

2. 随机梯度下降（Stochastic Gradient Descent）

随机梯度下降是一种在每次更新时随机选择一个样本进行梯度计算和参数更新的梯度下降算法。相比批量梯度下降，随机梯度下降具有更快的收敛速度，但更新过程较为不稳定。在PyTorch中，可以通过定义DataLoader来实现随机梯度下降。

例如，在简单线性回归问题中使用随机梯度下降：

import torch
import matplotlib.pyplot as plt

# 定义训练数据
X = torch.tensor([1, 2, 3, 4], dtype=torch.float32)
Y = torch.tensor([2, 4, 6, 8], dtype=torch.float32)

# 初始化模型参数
w = torch.tensor(0.0, requires_grad=True)
b = torch.tensor(0.0, requires_grad=True)

# 定义损失函数和优化器
loss_fn = torch.nn.MSELoss()
optimizer = torch.optim.SGD([w, b], lr=0.01)

# 定义超参数
batch_size = 1
epochs = 100

# 随机梯度下降
for epoch in range(epochs):
    # 创建DataLoader
    loader = torch.utils.data.DataLoader(torch.utils.data.TensorDataset(X, Y), batch_size=batch_size, shuffle=True)
    for x_batch, y_batch in loader:
        # 前向传播
        y_pred = w * x_batch + b
        # 计算损失
        loss = loss_fn(y_pred, y_batch)
        # 反向传播
        loss.backward()
        # 更新参数
        optimizer.step()
        # 清空梯度
        optimizer.zero_grad()


# 输出结果

print(f"w = {w.item()}, b = {b.item()}")

# 绘制拟合直线
plt.scatter(X.numpy(), Y.numpy())
plt.plot(X.numpy(), (w * X + b).detach().numpy(), 'r')
plt.show()

输出：

w = 2.0002050399780273, b = -0.0005163848866038325

绘制的拟合直线如下图所示：

在这里插入图片描述

3. 小批量梯度下降（Mini-batch Gradient Descent）

小批量梯度下降是介于批量梯度下降和随机梯度下降之间的梯度下降算法，即每次更新时选取一定数量的样本进行梯度计算和参数更新。在PyTorch中，可以通过定义DataLoader来实现小批量梯度下降。

例如，在简单线性回归问题中使用小批量梯度下降：

import torch
import matplotlib.pyplot as plt

# 定义训练数据
X = torch.tensor([1, 2, 3, 4], dtype=torch.float32)
Y = torch.tensor([2, 4, 6, 8], dtype=torch.float32)

# 初始化模型参数
w = torch.tensor(0.0, requires_grad=True)
b = torch.tensor(0.0, requires_grad=True)

# 定义损失函数和优化器
loss_fn = torch.nn.MSELoss()
optimizer = torch.optim.SGD([w, b], lr=0.01)

# 定义超参数
batch_size = 2
epochs = 100

# 小批量梯度下降
for epoch in range(epochs):
    # 创建DataLoader
    loader = torch.utils.data.DataLoader(torch.utils.data.TensorDataset(X, Y), batch_size=batch_size, shuffle=True)
    for x_batch, y_batch in loader:
        # 前向传播
        y_pred = w * x_batch + b
        # 计算损失
        loss = loss_fn(y_pred, y_batch)
        # 反向传播
        loss.backward()
        # 更新参数
        optimizer.step()
        # 清空梯度
        optimizer.zero_grad()

# 输出结果
print(f"w = {w.item()}, b = {b.item()}")

# 绘制拟合直线
plt.scatter(X.numpy(), Y.numpy())
plt.plot(X.numpy(), (w * X + b).detach().numpy(), 'r')
plt.show()

输出：

w = 1.9998304843902588, b = -0.00010240276428798664

绘制的拟合直线如下图所示：

在这里插入图片描述

4. 动量梯度下降（Momentum Gradient Descent）

动量梯度下降是一种在梯度下降更新过程中加入动量项的优化算法，可以加速收敛并减少震荡。在PyTorch中，可以通过设置momentum参数实现动量梯度下降。

例如，在简单线性回归问题中使用动量梯度下降：

import torch
import matplotlib.pyplot as plt

# 定义训练数据
X = torch.tensor([1, 2, 3, 4], dtype=torch.float32)
Y = torch.tensor([2, 4, 6, 8], dtype=torch.float32)

# 初始化模型参数和动量
w = torch.tensor(0.0, requires_grad=True)
b = torch.tensor(0.0, requires_grad=True)
momentum = 0.9

# 定义损失函数和优化器
loss_fn = torch.nn.MSELoss()
optimizer = torch.optim.SGD([w, b], lr=0.01, momentum=momentum)



# 定义超参数
epochs = 100

# 动量梯度下降
for epoch in range(epochs):
    # 前向传播
    y_pred = w * X + b
    # 计算损失
    loss = loss_fn(y_pred, Y)
    # 反向传播
    loss.backward()
    # 更新参数
    optimizer.step()
    # 清空梯度
    optimizer.zero_grad()

# 输出结果
print(f"w = {w.item()}, b = {b.item()}")

# 绘制拟合直线
plt.scatter(X.numpy(), Y.numpy())
plt.plot(X.numpy(), (w * X + b).detach().numpy(), 'r')
plt.show()

输出：

w = 1.9999991655349731, b = -3.718109681471333e-05

绘制的拟合直线如下图所示：

在这里插入图片描述

5. AdaGrad

AdaGrad是一种自适应学习率的优化算法，在更新参数时根据历史梯度信息来动态调整每个参数的学习率。在PyTorch中，可以通过设置optim.Adagrad()来使用该优化器。

例如，在简单线性回归问题中使用AdaGrad：

import torch
import matplotlib.pyplot as plt

# 定义训练数据
X = torch.tensor([1, 2, 3, 4], dtype=torch.float32)
Y = torch.tensor([2, 4, 6, 8], dtype=torch.float32)

# 初始化模型参数
w = torch.tensor(0.0, requires_grad=True)
b = torch.tensor(0.0, requires_grad=True)

# 定义损失函数和优化器
loss_fn = torch.nn.MSELoss()
optimizer = torch.optim.Adagrad([w, b], lr=0.1)

# 定义超参数
epochs = 100

# AdaGrad
for epoch in range(epochs):
    # 前向传播
    y_pred = w * X + b
    # 计算损失
    loss = loss_fn(y_pred, Y)
    # 反向传播
    loss.backward()
    # 更新参数
    optimizer.step()
    # 清空梯度
    optimizer.zero_grad()

# 输出结果
print(f"w = {w.item()}, b = {b.item()}")

# 绘制拟合直线
plt.scatter(X.numpy(), Y.numpy())
plt.plot(X.numpy(), (w * X + b).detach().numpy(), 'r')
plt.show()

输出：

w = 1.999985694885254, b = -0.0010528544095081096

绘制的拟合直线如下图所示：

在这里插入图片描述

6. RMSprop

RMSprop是一种自适应学习率的优化算法，在更新参数时根据历史梯度平方的加权平均来动态调整每个参数的学习率。在PyTorch中，可以通过设置optim.RMSprop()来使用该优化器。

例如，在简单线性回归问题中使用RMSprop：

import torch
import matplotlib.pyplot as plt

# 定义训练数据
X = torch.tensor([1, 2, 3, 4], dtype=torch.float32)
Y = torch.tensor([2, 4, 6, 8], dtype=torch.float32)

# 初始化模型参数
w = torch.tensor(0.0, requires_grad=True)
b = torch.tensor(0.0, requires_grad=True)

# 定义损失函数和优化器
loss_fn = torch.nn.MSELoss()
optimizer = torch.optim.RMSprop([w, b], lr=0.01)

# 定义超参数
epochs = 100

# RMSprop
for epoch in range(epochs):
    # 前向传播
    y_pred = w * X + b
    # 计算损失
    loss = loss_fn(y_pred, Y)
    # 反向传播
    loss.backward()
    # 更新参数
    optimizer.step()
    # 清空梯度
    optimizer.zero_grad()

# 输出结果
print(f"w = {w.item()}, b = {b.item()}")

# 绘制拟合直线
plt.scatter(X.numpy(), Y.numpy())
plt.plot(X.numpy(), (w * X + b).detach().numpy(), 'r')
plt.show()

输出：

w = 2.000011920928955, b = -0.00020079404229614145

绘制的拟合直线如下图所示：

在这里插入图片描述

7. Adam

Adam是一种融合了动量梯度下降和自适应学习率的优化算法，在更新参数时既考虑历史梯度的加权平均又考虑历史梯度平方的加权平均。在PyTorch中，可以通过设置optim.Adam()来使用该优化器。

例如，在简单线性回归问题中使用Adam：

import torch
import matplotlib.pyplot as plt

# 定义训练数据
X = torch.tensor([1, 2, 3, 4], dtype=torch.float32)
Y = torch.tensor([2, 4, 6, 8], dtype=torch.float32)

# 初始化模型参数
w = torch.tensor(0.0, requires_grad=True)
b = torch.tensor(0.0, requires_grad=True)

# 定义损失函数和优化器
loss_fn = torch.nn.MSELoss()
optimizer = torch.optim.Adam([w, b], lr=0.01)

# 定义超参数
epochs = 100

# Adam
for epoch in range(epochs):
    # 前向传播
    y_pred = w * X + b
    # 计算损失
    loss = loss_fn(y_pred, Y)
    # 反向传播
    loss.backward()
    # 更新参数
    optimizer.step()
    # 清空梯度
    optimizer.zero_grad()

# 输出结果
print(f"w = {w.item()}, b = {b.item()}")

# 绘制拟合直线
plt.scatter(X.numpy(), Y.numpy())
plt.plot(X.numpy(), (w * X + b).detach().numpy(), 'r')
plt.show()

输出：

w = 2.0000016689300537, b = -1.788223307551633e-05

绘制的拟合直线如下图所示：

在这里插入图片描述

8. AdamW

AdamW是一种基于Adam优化算法的变体，它引入了权重衰减（weight decay）来解决Adam可能存在的参数过度拟合问题。在PyTorch中，可以通过设置optim.AdamW()来使用该优化器。

例如，在简单线性回归问题中使用AdamW：

import torch
import matplotlib.pyplot as plt

# 定义训练数据
X = torch.tensor([1, 2, 3, 4], dtype=torch.float32)
Y = torch.tensor([2, 4, 6, 8], dtype=torch.float32)

# 初始化模型参数
w = torch.tensor(0.0, requires_grad=True)
b = torch.tensor(0.0, requires_grad=True)

# 定义损失函数和优化器
loss_fn = torch.nn.MSELoss()
optimizer = torch.optim.AdamW([w, b], lr=0.01, weight_decay=0.1)

# 定义超参数
epochs = 100

# AdamW
for epoch in range(epochs):
    # 前向传播
    y_pred = w * X + b
    # 计算损失
    loss = loss_fn(y_pred, Y)
    # 反向传播
    loss.backward()
    # 更新参数
    optimizer.step()
    # 清空梯度
    optimizer.zero_grad()

# 输出结果
print(f"w = {w.item()}, b = {b.item()}")

# 绘制拟合直线
plt.scatter(X.numpy(), Y.numpy())
plt.plot(X.numpy(), (w * X + b).detach().numpy(), 'r')
plt.show()

输出：

w = 1.9564942121505737, b = 0.063056387424469

绘制的拟合直线如下图所示：

在这里插入图片描述

9. Adadelta

Adadelta是一种自适应学习率的优化算法，它与RMSprop相似，但引入了一个衰减系数来平衡历史梯度平方和目标函数变化量。在PyTorch中，可以通过设置optim.Adadelta()来使用该优化器。

例如，在简单线性回归问题中使用Adadelta：

import torch
import matplotlib.pyplot as plt

# 定义训练数据
X = torch.tensor([1, 2, 3, 4], dtype=torch.float32)
Y = torch.tensor([2, 4, 6, 8], dtype=torch.float32)

# 初始化模型参数
w = torch.tensor(0.0, requires_grad=True)
b = torch.tensor(0.0, requires_grad=True)

# 定义损失函数和优化器
loss_fn = torch.nn.MSELoss()
optimizer = torch.optim.Adadelta([w, b], lr=0.1)

# 定义超参数
epochs = 100

# Adadelta
for epoch in range(epochs):
    # 前向传播
    y_pred = w * X + b
    # 计算损失
    loss = loss_fn(y_pred, Y)
    # 反向传播
    loss.backward()
    # 更新参数
    optimizer.step()
    # 清空梯度
    optimizer.zero_grad()

# 输出结果
print(f"w = {w.item()}, b = {b.item()}")

# 绘制拟合直线
plt.scatter(X.numpy(), Y.numpy())
plt.plot(X.numpy(), (w * X + b).detach().numpy(), 'r')
plt.show()

输出：

w = 2.0000007152557373, b = 4.5047908031606675e-08

绘制的拟合直线如下图所示：

在这里插入图片描述

以上是常见的优化算法，它们在不同的场景下表现出不同的效果。除此之外，PyTorch还支持其他优化算法，如Adagrad、Adamax等，并且用户也可以自定义优化器来满足特定需求。

高山莫衣
关注
  • 2
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
pytorch实现的在线强化学习11种常见算法代码
02-01
这个资源是一个包含了使用 PyTorch 实现的11种常见在线强化学习算法的代码集合。每个算法都有独立的文件夹，可以单独运行并测试相应算法在不同环境中的性能。以下是资源中包含的算法： 1、Q-learning 2、SARSA 3、DQN (Deep Q-Network) 4、Double-DQN 5、Dueling-DQN 6、PG (Policy Gradient) 7、AC (Actor-Critic) 8、PPO (Proximal Policy Optimization) 9、DDPG (Deep Deterministic Policy Gradient) 10、TD3 (Twin Delayed DDPG) 11、SAC (Soft Actor-Critic)
Pytorch中的自动求梯度机制和Variable类实例
12-20
自动求导机制是每一个深度学习框架中重要的性质，免去了手动计算导数，下面用代码介绍并举例说明Pytorch的自动求导机制。 首先介绍Variable，Variable是对Tensor的一个封装，操作和Tensor是一样的，但是每个Variable都有三个属性：Varibale的Tensor本身的.data，对应Tensor的梯度.grad，以及这个Variable是通过什么方式得到的.grad_fn，根据最新消息，在pytorch0.4更新后，torch和torch.autograd.Variable现在是同一类。torch.Tensor能像Variable那样追踪历史和反向传播。Variabl
pytorch中模型参数requires_grad的含义
最新发布
Vulpes corsac
05-07 118
当requires_grad = False，则不保留梯度，因此即便在optimizer中注册了参数，也没有梯度可以用来更新参数，因此参数不变。不过不影响梯度继续反向传播，即假设某一层（例如第三层）参数的requires_grad为False或True，前面层（第1或2层）参数的梯度都不变。requires_grad 表达的含义是，这一参数是否保留（或者说持有，即在前向传播完成后，是否在显存中记录这一参数的梯度，而非立即释放）梯度，等待优化器执行optim.step()更新参数。
PyTorch: 梯度下降及反向传播的实例详解
09-18
今天小编就为大家分享一篇PyTorch: 梯度下降及反向传播的实例详解，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
梯度下降详解（包含简单代码示例）
01-03
梯度下降算法详解，包括原理讲解和算法实例，简单易懂
pytorch深度学习梯度下降算法
03-19
可以很好的了解梯度下降算法，更好的帮助想要学习和了解pytorch深度学习的同学。Tensor对象及其运算 Tensor的索引和切片 PyTorch的Reduction操作 PyTorch的自动微分Autograd都是我们要学习的内容
pytorch——梯度计算
m0_51311105的博客
11-23 8162
1、梯度介绍 梯度是一个向量，是学习（参数更新的方向）。收集数据，构建机器学习模型，得到 判断模型好坏的方法： （回归损失） （分类损失） 通过调整参数，尽可能降低 随机选择一个起始点，通过调整，使得函数取得最小值。 的更新方法： ①计算的梯度（即导数）： ②更新： 其中，，意味着将增大，，意味着将减小。当小到一定的程度或者循环达到一定次数后，或停止循环。 ...
Pytorch中的梯度知识总结
梦码城博客中心
11-02 3603
你真的了解Pytorch中梯度的计算原理吗？这篇文章主要涉及Pytorch中梯度计算的知识，包括什么是叶子向量，梯度反向传播原理，参数优化过程的详细解释。
pytorch梯度的计算过程
qimo601的专栏
03-30 8114
1、基础知识: 与numpy中的基本操作相似， pytorch 的作用是引入GPU加快运算， 增加图形界面， 适合大数据运算， 尤其是deep learning gradient 梯度类似于求导， 找到梯度下降的最佳路径。 tensor 除了可以进行线性代数运算， 还可以求梯度 tensor在pytorch里面是一个n维数组。我们可以通过指定参数reuqires_grad=True来建立一个反向传播图，从而能够计算梯度。在pytorch中一般叫做dynamic computation g...
pytorch基础操作(三)梯度下降(小批量)计算线性回归
qq_44665283的博客
12-08 1612
pytorch基础操作(三)梯度下降(小批量)计算线性回归
【pytorch框架学习】4.梯度
m0_66606474的博客
02-16 979
梯度是一个向量，是由各个方向的偏导组成的向量。
pytorch中的自定义反向传播,求导实例
01-20
那么如何将自定义算法的梯度加入到pytorch的计算图中，能使用Loss.backward()操作自动求导并优化呢。下面的代码展示了这个功能` import torch import numpy as np from PIL import Image from torch.autograd ...
基于pytorch中的Sequential用法说明
09-16
`Adam` 是一种自适应学习率的优化算法，它结合了动量（Momentum）和RMSProp的特性。`Adam` 在许多深度学习任务中表现得非常优秀，因为它能够自动调整学习率，并且在处理具有稀疏梯度的数据时表现良好。 `Adam` 的...
Pytorch实现将模型的所有参数的梯度清0
09-16
这是因为深度学习中的优化算法（如SGD，Adam等）通常基于梯度更新权重，而这些梯度在不同批次之间应该被重置，以避免上一轮迭代的梯度影响下一轮的更新。 **1. 清零模型参数梯度的方法** 有两种主要方式来实现这一...
基于pytorch的神经网络优化算法研究.pdf
09-25
在实际应用中，选择哪种优化算法取决于具体任务和模型结构。通常，对于新问题，我们可以先尝试使用Adam，因为它在大多数情况下表现良好。如果遇到训练困难或者对模型性能有更高要求，可以考虑其他优化算法，如...
【深度学习】梯度下降、随机梯度下降、小批量随机梯度下降（pyTorch）
Bryce-HJ
07-22 840
Contents1 梯度下降和随机梯度下降1.1 一维梯度下降1.2 学习率1.3 多维梯度下降1.4 随机梯度下降2 小批量随机梯度下降2.1 读取数据2.2 从零开始实现2.4 小批量随机梯度下降简洁实现 1 梯度下降和随机梯度下降 1.1 一维梯度下降 %matplotlib inline import numpy as np import torch import math import sys sys.path.append('..') import d2lzh_pytorch as d2l d
梯度下降法实例
oQSA743的专栏
08-13 914
梯度下降法 不懂的可以见斯坦福大学的公开课 ：机器学习 第二课。  现有一个方程：y=1+2x 给一个训练样本    x，y= {0,1},{1,3},{2,5},{3,7},{4,9},{5,11},{6,13},{7,15}  要拟合出θ0，θ1  即y=θ0*x0+θ1 *x1； 根据课程：（训练样本中没有x0=1，初始化的时候补上） 初始步长ε=0.006555代码
具体实例理解梯度下降
Yzfranklin的博客
12-28 415
2次函数通过梯度下降法不断逼近临界值# -*- coding: utf-8 -*- """ Created on Wed Dec 27 16:46:06 2017@author: Administrator """import numpy as np import matplotlib.pyplot as plt import sympy as symdef Create_Function():
【Pytorch】梯度下降算法
宫瑞阳的博客
02-22 1672
梯度下降算法
projection pytorch
09-07
PyTorch中的projection指的是使用投影判别器的条件图像生成方法，其中通过光谱归一化对图像进行预处理。光谱归一化是一种常用的图像预处理技术，它可以将图像的频谱范围限制在固定的范围内，以减少噪声和增强图像的细节。投影判别器是一种用于条件图像生成的判别器模型，它可以根据输入的条件信息（例如类别标签）来生成更加准确和多样化的图像。这种方法在PyTorch中有相关的实现代码。 根据引用和引用的代码，可以看到在PyTorch中进行条件图像生成时，可以使用投影判别器和光谱归一化进行预处理。通过定义优化目标和使用梯度下降等优化算法，可以对生成模型进行训练，并通过迭代优化参数来生成更好的图像。在代码中，还可以看到使用MSE均方差作为损失函数进行训练，以及使用torch.optim库中的优化器进行参数更新。 此外，引用中的代码展示了一个完整的案例，其中使用PyTorch实现了Himmelblau函数的优化。该代码通过定义优化目标和使用梯度下降算法对参数进行更新，以找到函数的最小值点。整个过程中，PyTorch提供了自动求导和优化器等功能，使得优化过程更加简洁高效。 综上所述，projection pytorch指的是在PyTorch中使用投影判别器和光谱归一化进行条件图像生成的方法。这种方法可以通过优化模型参数来生成更准确和多样化的图像。<span class="em">1</span><span class="em">2</span><span class="em">3</span><span class="em">4</span>

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

高山莫衣

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值