pytorch学习笔记5-autograd自动求导系统

最新推荐文章于 2023-11-18 17:08:23 发布

berry丶

最新推荐文章于 2023-11-18 17:08:23 发布

阅读量425

点赞数

分类专栏： pytorch学习

本文链接：https://blog.csdn.net/zbr794866300/article/details/111029657

版权

pytorch学习专栏收录该内容

8 篇文章 2 订阅

订阅专栏

本文介绍了PyTorch中的自动梯度机制，包括torch.autograd.backward和torch.autograd.grad的使用，以及注意事项。同时，通过实例展示了逻辑回归模型的搭建、损失函数、优化器的选择和模型训练过程，最后用代码实现了一个简单的二分类问题的逻辑回归模型训练，并绘制了决策边界。

摘要由CSDN通过智能技术生成

1.autograd

（1）torch.autograd.backward

功能：自动求取梯度

参数：

tensors:用于求导的张量，如loss

retain_graph:保存计算图（每次反向传播后，计算图都会释放调）

create_graph:创建导数计算图，用于高阶求导

grad_tensors:多梯度权重，多个loss需要计算时，可以调节各个loss的权重

# retain_grad 保存非叶子节点计算图
flag = True
# flag = False
if flag:
    w = torch.tensor([1.], requires_grad=True)
    x = torch.tensor([2.], requires_grad=True)

    a = torch.add(w, x)
    b = torch.add(w, 1)
    y = torch.mul(a, b)

    y.backward(retain_graph=True)  # retain+graph参数设置为true可以多次运行反向传播，否则只能运行一次

    print("w.grad: {}  x.grad: {}  b.grad: {}".format(w.grad, x.grad, b.grad))
    y.backward()

以学习笔记4中的y=(x+w)*(w+1),

y对w的梯度如下所示：

$\partial y/\partial w=\partial y/\partial a*\partial a/\partial w+\partial y/\partial b*\partial b/\partial w$

# flag = True
flag = False
if flag:
    w = torch.tensor([1.], requires_grad=True)
    x = torch.tensor([2.], requires_grad=True)

    a = torch.add(w, x)
    b = torch.add(w, 1)

    y0 = torch.mul(a, b)
    y1 = torch.add(a, b)  # y1=2W+X+1   dy/dw=2

    loss = torch.cat([y0, y1], dim=0)
    grad_tensors = torch.tensor([1., 1.]) # y0对w的梯度×所对应的权重1+y1对w梯度×所对应的权重1

    loss.backward(gradient=grad_tensors)
    print(w.grad)

（2）torch.autograd.grad

功能：求取梯度

参数：

outputs:用于求导的张量，如loss

input：需要求取梯度的张量

create_graph:创建导数计算图，用于高阶求导

retain_graph:保存计算图

grad_outputs:多梯度权重

# flag = True
flag = False
if flag:
    x = torch.tensor([3.], requires_grad=True)
    y = torch.pow(x, 2)

    grad_1 = torch.autograd.grad(y, x, create_graph=True)  # grad_1=dy/dx=2x=2*3=6
    print(grad_1)

    grad_2 = torch.autograd.grad(grad_1[0], x)  # y的二阶导 grad_2=d(dy/dx)/dx=2
    print(grad_2)

autograd注意事项：

1.梯度不会自动清零，多次运行求导需要grad.zero_()清零

# flag = True
flag = False
if flag:
    w = torch.tensor([1.], requires_grad=True)
    x = torch.tensor([2.], requires_grad=True)

    for i in range(4):
        a = torch.add(w, x)
        b = torch.add(w, 1)
        y = torch.mul(a, b)

        y.backward()
        print(w.grad)

        w.grad.zero_() # 每次执行完对w的梯度清零，否则会叠加

2.依赖于叶子节点的节点，requires_grad默认为True

# flag = True
flag = False
if flag:
    w = torch.tensor([1.], requires_grad=True)
    x = torch.tensor([2.], requires_grad=True)

    a = torch.add(w, x)
    b = torch.add(w, 1)
    y = torch.mul(a, b)

    print(a.requires_grad, b.requires_grad, y.requires_grad)

a,b,y均为true

3.叶子节点不能进行in_place操作（原位操作：原始地址上直接进行改变。）

2.逻辑回归

逻辑回归是线性的二分类模型

模型表达式：

y=f(wx+b)

$f(x)=1/1+e^{-x}$

f(x)称为Sigmoid函数，也称为Logistic函数

通常选择一个预制为0.5，大于或者小于0.5就被分成两个类。

逻辑回归与线性回归区别：

1.逻辑回归：是分析自变量x与因变量y（概率）之间关系的方法

y=f(wx+b)

$=\frac{1}{1+e^{^{1(wx+b))}}}$

$f(x)=1/1+e^{-x}$

逻辑回归可以说是在线性回归的基础上增加了一个激活函数（Sigmoid函数）

逻辑回归还有一个名字叫对数几率回归：

几率：概率取值 y/（1-y）

$ln^{y/(1-y))}=wx+b$

$y/(1-y)=e^{(wx+b)}$

$y=e^{wx+b}/(1+e^{wx+b})=1/(1+e^{-(wx+b)})$

2.线性回归：是分析自变量x与因变量y（标量）之间关系的方法

自变量：x

因变量：y

关系：y=wx+b

机器学习训练步骤：

1数据:获取数据，如数据采集、数去划分、预处理

2模型：根据任务难易程度选择合适的模型，如线性、神经网络等。

3.损失函数选择：根据不同的任务选择不同的模型，线性回归中选择的均方差损失函数，分类任务可以选择交叉熵损失函数

4.优化器：更新权值

最后再迭代训练

下面以一个二分类为例：

import torch
import torch.nn as nn
import matplotlib.pyplot as plt
import numpy as np

torch.manual_seed(10)

# 生成数据
sample_nums = 100
mean_value = 1.7
bias = 1
n_data = torch.ones(sample_nums, 2)
x0 = torch.normal(mean_value * n_data, 1) + bias
y0 = torch.zeros(sample_nums)
x1 = torch.normal(-mean_value * n_data, 1) + bias
y1 = torch.ones(sample_nums)
train_x = torch.cat((x0, x1), 0)
train_y = torch.cat((y0, y1), 0)


# 选择模型

class LR(nn.Module):
    def __init__(self):
        super(LR, self).__init__()
        self.features = nn.Linear(2, 1)
        self.sigmoid = nn.Sigmoid()

    def forward(self, x):
        x = self.features(x)
        x = self.sigmoid(x)
        return x


lr_net = LR()

# 选择损失函数
loss_fn = nn.BCELoss()  # 交叉熵

# 选择优化器
lr = 0.01
optimizer = torch.optim.SGD(lr_net.parameters(), lr=lr, momentum=0.9)

# 模型训练
for iteration in range(1000):
    # 前向传播
    y_pred = lr_net(train_x)

    # 计算loss
    loss = loss_fn(y_pred.squeeze(), train_y)

    # 反向传播
    loss.backward()

    # 更新参数
    optimizer.step()

    # 清空梯度
    optimizer.zero_grad()

    # 绘图
    if iteration % 20 == 0:
        mask = y_pred.ge(0.5).float().squeeze()  # 以0.5为阈值进行分类
        correct = (mask == train_y).sum()  # 计算正确预测的样本个数
        acc = correct.item() / train_y.size(0)  # 计算分类准确率

        # plt.scatter(x0.data.numpy()[:, 0], x0.data.numpy()[:, 1], c='r', label='class 0')
        plt.scatter(x0.data.numpy()[:, 0], x0.data.numpy()[:, 1], c='r', label='class 0')
        plt.scatter(x1.data.numpy()[:, 0], x1.data.numpy()[:, 1], c='b', label='class 1')

        w0, w1 = lr_net.features.weight[0]
        w0, w1 = float(w0.item()), float(w1.item())
        plot_b = float(lr_net.features.bias[0].item())
        plot_x = np.arange(-6, 6, 0.1)
        plot_y = (-w0 * plot_x - plot_b) / w1

        plt.xlim(-5, 7)
        plt.ylim(-7, 7)
        plt.plot(plot_x, plot_y)

        plt.text(-5, 5, 'LOSS=%.4f' % loss.data.numpy(), fontdict={'size': 20, 'color': 'red'})
        plt.title("Iteration: {}\n w0:{:.2f} w1{:.2f} b{:.2f} accuracy:{:.2%}".format(iteration, w0, w1, plot_b, acc))
        plt.legend()

        plt.show()
        plt.pause(0.5)

        if acc > 0.99:
            break