【实践】使用pytorch训练一个逻辑回归

本站原创文章，转载请说明来自《老饼讲解-深度学习》www.bbbdata.com

逻辑回归是一个简单经典的模型，它的训练较为简单

由于pytorch可以自动求解梯度，它使得逻辑回归的训练在实现时更加简单

本文展示如何借助pytorch的自动计算梯度来训练一个逻辑回归，

以此来展示用pytorch训练一个普通模型的流程及感受pytorch的便利性

    01. 逻辑回归简单回顾   

本节简单回顾逻辑回归的模型、损失函数以及训练流程

      逻辑回归模型与损失函数    

逻辑回归模型主要用于做二分类，是一个简单有效且经典的模型
 下面我们简单回顾逻辑回归的模型与损失函数
 
 逻辑回归模型
 逻辑回归模型输出样本属于类别1的概率
 逻辑回归模型的表达式如下：
                      
             其中          
  

 逻辑回归的损失函数
 逻辑回归模型采用交叉熵损失函数作为损失函数
 逻辑回归的损失函数表达式如下：
           
           其中，为样本个数

      逻辑回归的训练流程     

逻辑回归可以使用梯度下降算法进行训练
 梯度下降法求解逻辑回归的流程如下：
         👉1. 初始化w,b                                             
         👉2. 按损失函数L(w,b)的负梯度方向调整w,b
     重复2，直接满足终止条件                   

   02. 使用pytorch训练一个逻辑回归   

本节展示如何使用pytorch训练逻辑回归的代码实现

     使用pytorch训练一个逻辑回归     

直接使用python实现梯度下降法求解逻辑回归，需要求出w、b的梯度的显式表达式，
但使用pytorch则不需要，它可以自动计算梯度，下面我们展示如何使用pytorch来训练一个逻辑回归
使用pytorch实现梯度下降法训练逻辑回归的代码如下：

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

# ------训练数据----------------
X = np.array([[2.5, 1.3, 6.2, 1.3, 5.4, 6 ,4.3, 8.2]
                ,[-1.2,2.5,3.6,4,3.4,2.3,7.2,3.9]]).T                   # 样本的输入数据
Y = [0,0,1,0,1,1,1,1]                                                   # 样本的标签
x = torch.tensor(X)                                                     # 将训练数据X转为tensor
y = torch.tensor(Y)                                                     # 将训练数据y转为tensor

#-----------训练模型------------------------
w  = torch.tensor([2,2],dtype=(float),requires_grad=True)               # 初始化模型系数w
b  = torch.tensor([1],dtype=(float),requires_grad=True)                 # 初始化模型系数b
lr = 0.01                                                               # 学习率
for i in range(1000):
    L = (torch.log(1+torch.exp(x@w+b)) -y*(x@w+b)).sum()                # 损失函数
    print('第',str(i),'轮：',L)                                         # 打印当前损失函数值
    L.backward()                                                        # 用损失函数更新模型系数的梯度
    w.data=w.data-w.grad*lr                                             # 更新模型系数w
    b.data=b.data-b.grad*lr                                             # 更新模型系数b
    w.grad.zero_()                                                      # 清空w的梯度,以便下次backward
    b.grad.zero_()                                                      # 清空b的梯度,以便下次backward
    
# --------------------画出结果----------------
print('--------最终结果-------')
W  = w.detach().numpy()                                                 # 模型的系数,先转回numpy
B  = b.item()                                                           # 模型的阈值,先转回数值
print('W:',W)                                                           # 打印模型系数W
print('B:',B)                                                           # 打印模型系数B
x1 = X[:,0]                                                             # 绘制分割平面的x轴
x2 = (-B - W[0]*x1)/W[1]                                                # 绘制分割平面的y轴
plt.scatter(X[:, 0], X[:, 1],c=Y)                                       # 绘制样本
plt.plot(x1,x2)                                                         # 绘制分割平面             
plt.axis([min(X[:,0])-1,max(X[:,0])+1,min(X[:,1])-1,max(X[:,1])+1])     # 设置坐标范围
plt.show()                                                              # 展示图象     

     运行结果    

运行结果如下：
 ........
第 996 轮： tensor(0.4923, dtype=torch.float64, grad_fn=<SumBackward0>)
第 997 轮： tensor(0.4918, dtype=torch.float64, grad_fn=<SumBackward0>)
第 998 轮： tensor(0.4913, dtype=torch.float64, grad_fn=<SumBackward0>)
第 999 轮： tensor(0.4908, dtype=torch.float64, grad_fn=<SumBackward0>)
--------最终结果-------
W: [1.30352664 0.3015996 ]                                                                               
B: -4.817742837478265                                                                                     

  
从结果中可以看到，逻辑回归模型已经成功分开两类样本
说明模型的训练是有效的

 End