pytorch（06）autograd与逻辑回归

autograd与逻辑回归

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

torch.autograd.backward and torch.autograd.grad

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

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

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

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

torch.autograd.backward

1. 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

1. 梯度不会自动清零

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.])

1. 依赖于叶子结点的结点，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

1. 叶子结点不可执行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