深度学习--第7篇: Pytorch自动求导与逻辑回归

1. 自动求导 torch.autograd

1.1 torch.autograd.backward

# torch.autograd.backward()  功能：自动求取梯度
参数:
 - tensors：用于求导的张量，如loss
 - retain_graph：保存计算图
 - create_graph：创建导数计算图，用于高阶求导
 - grad_tensors：多梯度权重

• 实例展示

x = torch.tensor([2.], requires_grad=True)  # 创建原始数据,叶子节点
w = torch.tensor([1.], requires_grad=True)

# a = torch.add(x, w)
a = x + w
a.retain_grad()  # 保留a的梯度,用于可视化,实际上a的梯度会在计算后释放

# b = torch.add(w,1)
b = w + 1

# y = torch.mul(a, b)
y = a * b

torch.autograd.backward(y, retain_graph=True)  # 保存计算图,以便于下面再次求导时使用
# y.backward()   # 反向传播,计算梯度 ,与上式效果一样

# 如果上式没有注释,则会由于进行了两次求导,而且梯度没有清0,梯度会累加

1.2 torch.aurograd.grad

# torch.aurograd.grad()  功能：求取梯度
参数:
 - outputs：用于求导的张量  ----- y, loss
 - inputs：需要梯度的张量  ----- w, x
 - create_graph：创建导数计算图，用于高阶求导
 - retain_graph：保存计算图
 - grad_outputs：多梯度权重

小贴士:
 - 梯度不自动清零, 需要手动进行 w.grad.zero_()等;
 - 依赖于叶子结点的结点，requires_grad默认为True;
 - 叶子结点不可执行in-place操作;
 - 带有下划线的操作,如sub_(),add_(),表示原地操作,即会在原始数据上进行改变;

2. 逻辑回归(线性二分类模型)

逻辑回归是线性的二分类模型
模型表达式： y = f(WX + b)
 f(x) = 1/(1+eˆ(-x))    
 f(x)称为Sigmoid函数，也称为Logistic函数.
 class={0，0.5>y ; 1，0.5<y)

线性回归和逻辑回归之间的区别:
 - 线性回归是分析自变量x与因变量y（标量）之间关系的方法
 - 逻辑回归是分析自变量x与因变量y（概率）之间关系的方法

3. 机器学习模型训练步骤

机器学习模型训练步骤:
 - 数据
 - 模型
 - 损失函数
 - 优化器
 - 迭代训练

• 逻辑回归实例

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

torch.manual_seed(10)    # 设置随机数种子,保证每次随机初始化相同

# 创建数据
mean_value = 2.     # 均值
var_value = 1.      # 方差,方差越大,数据越分散
bais = 1.0          # 偏置

x0 = torch.normal(mean_value, var_value, [100,2]) + bais   # 定义数据x0 [100,2] 类别0
y0 = torch.zeros([100,1])                                  # 定义标签y0 [100,1] 类别0

x1 = torch.normal(-mean_value, var_value, [100,2]) + bais  # 定义数据x1 [100,2] 类别1
y1 = torch.ones([100,1])                                   # 定义标签y1 [100,1] 类别1

train_x = torch.cat([x0, x1], dim=0)  # 合并待训练数据 [200,2]
lable_y = torch.cat([y0, y1], dim=0)  # 合并标签真值   [200,1]

# 构建模型
class LR(nn.Module):
    def __init__(self):
        super(LR, self).__init__()
        self.features = nn.Linear(2, 1)   # 输入数据的大小, 输出数据的大小
        self.sigmoid = nn.Sigmoid()       # 将原始数据映射到0-1之间

    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)   # SGD优化器

for iter in range(1000):

    # 前向传播
    y_pred = lr_net(train_x)

    # 计算loss
    # .squeeze将数据转换为1维张量,去除掉原始张量中为1的轴, lable_y[200,1]-->[200]
    loss = loss_fn(y_pred.squeeze(), lable_y.squeeze())   

    # 反向传播
    loss.backward()

    # 更新参数
    optimizer.step()
    
    # 清空梯度
    optimizer.zero_grad()

    # 输出损失函数的值,以及分类准确率
    if iter % 100 == 0:

        #将预测值中大于0.5转换为True,小于0.5转换为False, 将bool类型转换为float,即0.,1.的形式,并去除为1的轴
        mask = y_pred.ge(0.5).float().squeeze()
        # 比较预测值与真实标签是否一致,并利用sum统计一致的个数,利用item()将张量转换为数字   
        correct = (mask == lable_y.squeeze()).sum().item() 
        # 计算分类正确率
        acc = correct / lable_y.size(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: {}\nw0:{:.2f} w1:{:.2f} b: {:.2f} accuracy:{:.2%}".format(iter, w0, w1, plot_b, acc))
        plt.legend()

        plt.show()
        plt.pause(0.5)

        print("Loss=%.4f" % loss, "accuraty=%.4f" % acc)

        if acc > 0.99:
            break

# 最终结果如下:
Loss=0.0425 accuraty=0.9950