pytorch（06）autograd与逻辑回归

autograd与逻辑回归

自动求导系统中两个常用的方法：

torch.autograd.backward and torch.autograd.grad

演示理解一阶导数、二阶导数的求导过程

理解自动求导系统，以及张量，前向传播构建计算图、计算图求取梯度

演示逻辑回归训练，学习五大模块：数据、模型、损失函数、优化器、迭代训练过程

深度学习模型的训练就是不断更新权值，权值的更新需要求解梯度。梯度时关键重要的，Pytorch就有自动求导系统，只需要搭建前向传播的计算图，通过autograd就可以得到梯度

torch.autograd.backward

autograd

torch.autograd.backward(tensors,grad_tensors=None,retain_graph=None,create_graph=False)

retain_graph用来保存计算图

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

grad_tensors多梯度权重

import torch

import numpy as np

x = torch.tensor([2.], requires_grad=True)

w = torch.tensor([1.], requires_grad=True)

a = torch.add(x,w)

# a.retain_grad()

b = torch.add(w,1)

y = torch.mul(a,b)

y.backward()# 在此行设置断点

点击step into，此时发现调用的是tensor.py中的

torch.autograd.backward(self, gradient, retain_graph, create_graph)

import torch

import numpy as np

x = torch.tensor([2.], requires_grad=True)

w = torch.tensor([1.], requires_grad=True)

a = torch.add(x,w)

# a.retain_grad()

b = torch.add(w,1)

y = torch.mul(a,b)

y.backward()

y.backward()

RuntimeError: Trying to backward through the graph a second time, but the saved intermediate results have already been freed. Specify retain_graph=True when calling backward the first time.

报错信息表示我们想进行两次的backward运算，但是保存的结果已经释放掉了，如果我们想要运算的话，应该指定retain_graph=True

y.backward(retain_graph=True)

y.backward()

grad_tensors

用于设置多个梯度之间的权重。

torch.autograd

torch.autograd.grad(outputs,inputs,grad_outputs=None,retain_grph=None,create_graph=False)

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

inputs:需要梯度的张量

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

retain_graph:保存计算图

grad_outputs:多梯度权重

flag = True

# flag = False

if flag:

    x = torch.tensor([3.], requires_grad=True)

    y = torch.pow(x, 2)

    y1 = torch.autograd.grad(y,x,create_graph=True)

    y2 = torch.autograd.grad(y1[0],x)# 二次求导对元组里的元素进行求导

    y.backward()

    print(x.grad)

    print(y1)

    print(y2)

tensor([6.])

(tensor([6.], grad_fn=<MulBackward0>),)

(tensor([2.]),)

tips

梯度不会自动清零

flag = True

# flag = False

if flag:

    x = torch.tensor([3.], requires_grad=True)

    y = torch.tensor([4.], requires_grad=True)

    for i in range(10):

        t = torch.mul(x,y)

        t.backward()

        x.grad.zero_()

        print(x.grad)

tensor([4.])

tensor([4.])

tensor([4.])

tensor([4.])

tensor([4.])

tensor([4.])

tensor([4.])

tensor([4.])

tensor([4.])

tensor([4.])

依赖于叶子结点的结点，requires_grad默认为True

flag = True

# flag = False

if flag:

    x = torch.tensor([3.], requires_grad=True)

    y = torch.tensor([4.], requires_grad=True)

    t = torch.mul(x,y)

    t.backward()

    print(t.requires_grad)

True

叶子结点不可执行in-place

in_place操作即原位操作，类似于x.grad.zero_().其中_就是原位操作

在查阅相关资料后，个人觉得可以直接当成覆盖操作，是否进行覆盖运算，pandas 中 inplace 参数在很多函数中都会有，它的作用是：是否在原对象基础上进行修改。 inplace = True：不创建新的对象，直接对原始对象进行修改；inplace = False：对数据进行修改，创建并返回新的对象承载其修改结果。默认是False，即创建新的对象进行修改，原对象不变，和深复制和浅复制有些类似。

inplace是在原始内存中改变这个数据，为什么叶子结点不可以inplace

逻辑回归

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

模型表达式：

\[y = f(WX+b)\\
f(x)=\frac{1}{1+e^-x}
\]

f(x)成为Sigmoid函数，也成为logistic函数

\[class =
\begin{cases}
0&,&{0.5>y}\\
1&,&{0.5 \leq y}
\end{cases}
\]

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

逻辑回归是分析自变量x与因变量y（概率）之间关系的方法，也可以说是把线性回归的基础上加上了sigmoid函数

逻辑回归=对数几率回归

\[ln\frac{y}{1-y}=WX+b
\]

对数回归

\[ln y = WX+B
\]

机器学习模型训练五个步骤

数据、模型、损失函数、优化器、迭代训练

import torch

import torch.nn as nn

import matplotlib.pyplot as plt

import numpy as np

import os

os.environ["KMP_DUPLICATE_LIB_OK"] = "TRUE"

torch.manual_seed(7)

ones = torch.ones(100, 2)

x0 = torch.normal(ones, 1) + 1

x1 = torch.normal(-ones, 1) - 0.4

# print(x0)

y0 = torch.zeros(100)

y1 = torch.ones(100)

train_x = torch.cat((x0, x1), 0)

train_y = torch.cat((y0, y1), 0)

print(train_x.shape)

print(train_y.shape)

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 i in range(1000):

    y_hats = lr_net(train_x)

    loss = loss_fn(y_hats.squeeze(), train_y)

    loss.backward()

    optimizer.step()

    optimizer.zero_grad()

    if i %10 == 0:

        mask = y_hats.ge(0.5).float().squeeze()

        masky = (mask==train_y).sum()

        # print(train_y.sum().data.numpy())

        # print(masky.data.numpy())

        print( masky.item(),train_y.size()[0])

        acc = masky.item()/train_y.size()[0]

        plt.scatter(x0.data.numpy()[:, 0], x0.data.numpy()[:, 1])

        plt.scatter(x1.data.numpy()[:, 0], x1.data.numpy()[:, 1])

        plt.xlim(-6,6)

        plt.ylim(-10,10)

        w0,w1 = lr_net.features.weight[0]

        w0,w1 = float(w0.item()),float(w1.item())

        b = float(lr_net.features.bias[0].item())

        xd = np.arange(-6,6,0.1)

        yd = w0*xd+b

        plt.plot(xd,yd)

        plt.title("the acc:{}".format(acc))

        # plt.show()

        # plt.ion()

        plt.pause(1)

        plt.clf()

        if acc > 0.95:

            break