PyTorch深度学习入门深度学习基础 2.4 逻辑回归

今天药忘吃喽~ 2024-03-22 13:15 85阅读 0赞

#### PyTorch深度学习入门 ####

#### 文章目录 ####

*   *   *  PyTorch深度学习入门
         *   *  深度学习基础
             *  2.4 逻辑回归
             *   *  1. sigmoid函数
                 *  2. 伯努利概型
                 *  3. 最大概似法与交叉熵
                 *  4. 逻辑回归示例

![在这里插入图片描述][49956402921b42558d7d802eebad914d.png_pic_center]

##### 深度学习基础 #####

##### 2.4 逻辑回归 #####

###### 1. sigmoid函数 ######

如下图，线性神经元的输入为  x ⃗ ⋅ w ⃗ \\vec\{x\} \\cdot \\vec\{w\} x⋅w

![在这里插入图片描述][958e86f6deab48ff95384ef85f7a2573.png_pic_center]

随后经过一个非线性的sigmoid函数，sigmoid 函数的定义域为  ( − ∞ , + ∞ ) (-\\infty,+\\infty) (−∞,\+∞), 值域为  ( 0 , 1 ) (0,1) (0,1)，图像如下：

![在这里插入图片描述][c483364922134ca9affd104ffc8499a6.png_pic_center]

这样一来, 输人  x ⃗ \\vec\{x\} x 经过神经网络, 最后通过  sigm ⁡ ( x ⃗ ⋅ w ⃗ ) \\operatorname\{sigm\}(\\vec\{x\} \\cdot \\vec\{w\}) sigm(x⋅w) 映射为集合  ( 0 , 1 ) (0,1) (0,1) 中的一个实数, 即我们可以将最终的输出当作  y = 1 y=1 y=1 的概率  P ( y = 1 , w ⃗ , x ⃗ ) P(y=1, \\vec\{w\}, \\vec\{x\}) P(y=1,w,x) 。

在线性的二元分类问题中, 我们的目标是找到一条直线将数据样本分成两类。如下图所示, 上述问题可以简化成求  P ( y = 1 , w ⃗ , x ⃗ ) = 1 2 P(y=1, \\vec\{w\}, \\vec\{x\})=\\frac\{1\}\{2\} P(y=1,w,x)=21 时的权重  w ⃗ \\vec\{w\} w 。

![在这里插入图片描述][0b6dd80d458c45f3a2fe700c8961d031.png_pic_center]

###### 2. 伯努利概型 ######

伯努利概型最典型的栗子 —— 抛硬币。

假设硬币正面为1，反面为0。一般情况下抛一次硬币得到正面或者反面的概率各占一半，即0.5 。

假设这个概率不一样，正面概率为  θ \\theta θ ，则反面的概率是  1 − θ 1-\\theta 1−θ

这样就得到了伯努利概型的通用公式：

P ( y ∣ θ ) = \{ θ , y = 1 1 − θ , y = 0 P(y \\mid \\theta)= \\begin\{cases\}\\theta, & y=1 \\\\ 1-\\theta, & y=0\\end\{cases\} P(y∣θ)=\{ θ,1−θ,y=1y=0

也可以写成：

P ( y ∣ θ ) = θ y ( 1 − θ ) 1 − y P(y \\mid \\theta)=\\theta^y(1-\\theta)^\{1-y\} P(y∣θ)=θy(1−θ)1−y

###### 3. 最大概似法与交叉熵 ######

最大概似法是统计学中的一个方法，该方法的核心原理很简单。

假如抛一枚形状不规则的硬币，正面概率  θ \\theta θ ，反面概率为  1 − θ 1-\\theta 1−θ

将每次拋硬币都看作独立的事件, 相互不受影响, 则每次抛硬币大自然都会给出概率尽可能高的结果, 那么将每次抛出的样本结果出现的概率累计起来, 应该会趋向最大, 这就是最大概似法的核心原理。

假设我们抛硬币 100 次, 得到包含有 100 个样本的样本集  \{ y 1 , y 2 , ⋯   , y 100 \} \\left\\\{y^1, y^2, \\cdots, y^\{100\}\\right\\\} \{ y1,y2,⋯,y100\}, 定义似然度, 即每个样本结果概率的乘积：  
 P ( y ⃗ ) = P ( y 1 ) P ( y 2 ) ⋯ P ( y 100 ) = ∏ i = 1 100 P ( y i ) P(\\vec\{y\})=P\\left(y^1\\right) P\\left(y^2\\right) \\cdots P\\left(y^\{100\}\\right)=\\prod\_\{i=1\}^\{100\} P\\left(y^i\\right) P(y)=P(y1)P(y2)⋯P(y100)=i=1∏100P(yi)  
根据伯努利的概率公式得：  
 P ( y ⃗ ) = ∏ i = 1 100 θ y i ( 1 − θ ) 1 − y i P(\\vec\{y\})=\\prod\_\{i=1\}^\{100\} \\theta^\{y^i\}(1-\\theta)^\{1-y^i\} P(y)=i=1∏100θyi(1−θ)1−yi  
接着按照世界的运作规律, 似然度必然会趋向最大。因此,  θ \\theta θ 需要进行调整以达到最大的似然度:  
 θ = max ⁡ θ P ( y ⃗ ) = max ⁡ θ ∏ i = 1 100 θ y i ( 1 − θ ) 1 − y i \\theta=\\max \_\\theta P(\\vec\{y\})=\\max \_\\theta \\prod\_\{i=1\}^\{100\} \\theta^\{y^i\}(1-\\theta)^\{1-y^i\} θ=θmaxP(y)=θmaxi=1∏100θyi(1−θ)1−yi  
之前我们已经知道:【sigmoid函数】  
 P ( y i ) = sigm ⁡ ( x ⃗ i ⋅ w ⃗ ) = 1 1 + e − x ⃗ i ⋅ w ⃗ = θ P\\left(y^i\\right)=\\operatorname\{sigm\}\\left(\\vec\{x\}^i \\cdot \\vec\{w\}\\right)=\\frac\{1\}\{1+\\mathrm\{e\}^\{-\\vec\{x\}^i \\cdot \\vec\{w\}\}\}=\\theta P(yi)=sigm(xi⋅w)=1\+e−xi⋅w1=θ  
那么似然度就可以写成:  
 P ( y ⃗ ∣ X , w ⃗ ) = ∏ i = 1 100 sigm ⁡ ( x ⃗ i ⋅ w ⃗ ) y i ( 1 − sigm ⁡ ( x ⃗ i ⋅ w ⃗ ) ) 1 − y i P(\\vec\{y\} \\mid \\boldsymbol\{X\}, \\vec\{w\})=\\prod\_\{i=1\}^\{100\} \\operatorname\{sigm\}\\left(\\vec\{x\}^i \\cdot \\vec\{w\}\\right)^\{y^i\}\\left(1-\\operatorname\{sigm\}\\left(\\vec\{x\}^i \\cdot \\vec\{w\}\\right)\\right)^\{1-y^i\} P(y∣X,w)=i=1∏100sigm(xi⋅w)yi(1−sigm(xi⋅w))1−yi  
我们的目的是得到一种新的损失函数, 帮助我们训练神经网络。因为我们优化的过程实际上就是最小化损失函数的过程。

因此, 我们需要将上面的似然度公式进行改造。添加一个负号, 让最大化似然度的过程变成最小化。为了更容易计算, 我们在似然度的等式两边同时取对数, 将乘法变成 了加法：  
 − log ⁡ P ( y ⃗ ∣ X , w ⃗ ) = − ∑ i = 1 100 \[ y i log ⁡ sigm ⁡ ( x ⃗ i ⋅ w ⃗ ) + ( 1 − y i ) log ⁡ ( 1 − sigm ⁡ ( x ⃗ i ⋅ w ⃗ ) ) \] -\\log P(\\vec\{y\} \\mid \\boldsymbol\{X\}, \\vec\{w\})=-\\sum\_\{i=1\}^\{100\}\\left\[y^i \\log \\operatorname\{sigm\}\\left(\\vec\{x\}^i \\cdot \\vec\{w\}\\right)+\\left(1-y^i\\right) \\log \\left(1-\\operatorname\{sigm\}\\left(\\vec\{x\}^i \\cdot \\vec\{w\}\\right)\\right)\\right\] −logP(y∣X,w)=−i=1∑100\[yilogsigm(xi⋅w)\+(1−yi)log(1−sigm(xi⋅w))\]

令  L ( w ⃗ ) = − log ⁡ P ( y ⃗ ∣ X , w ⃗ ) L(\\vec\{w\})=-\\log P(\\vec\{y\} \\mid \\boldsymbol\{X\}, \\vec\{w\}) L(w)=−logP(y∣X,w), 则  L ( w ⃗ ) L(\\vec\{w\}) L(w) 就是我们的损失函数。

实际上, 我们让似然度  P ( y ⃗ ∣ X , w ⃗ ) P(\\vec\{y\} \\mid \\boldsymbol\{X\}, \\vec\{w\}) P(y∣X,w) 最大就是让损失函数 L ( w ⃗ ) L(\\vec\{w\}) L(w) 最小。

这样目标就清晰了，通过梯度下降法，我们就能训练出合适的  w ⃗ \\vec\{w\} w 。

像这样利用最大概似法得到的损失函数，称为交叉熵。交叉熵损失函数是分类问题中常用的损失函数。

当然，PyTorch 也已经实现了 nn.CrossEntropyLoss()

###### 4. 逻辑回归示例 ######

下面我们用PyTorch 整一个逻辑回归的程序。

用程序自动生成一批数据样本，并分为两类，每一类500 个数据样本：

import torch
    import matplotlib.pyplot as plt
    
    cluster = torch.ones(500, 2)  # 这是500x2 的元素为1 的样本
    data0 = torch.normal(4 * cluster, 2)  # 以4为期望值、2为标准差生成一批随机数, 500个
    data1 = torch.normal(-4 * cluster, 2)  # 以-4为期望值、2为标准差生成一批随机数, 500个
    
    label0 = torch.zeros(500)  # 生成类别对应标签0
    label1 = torch.ones(500)  # 生成类别对应标签1
    
    # 将两类数据合并在一起
    x = torch.cat((data0, data1), ).type(torch.FloatTensor)
    y = torch.cat((label0, label1), ).type(torch.LongTensor)
    
    plt.scatter(x.numpy()[:, 0], x.numpy()[:, 1], c=y.numpy(), s=10, lw=0, cmap='RdYlGn')
    plt.show()

运行结果

![在这里插入图片描述][07f1e019cca64ace83d37d0c0c1b57eb.png_pic_center]

*  红色标签为0
 *  绿色标签为1

接下来定义神经网络的类Net：

from torch import nn
    
    
    class Net(nn.Module):
        def __init__(self):
            super(Net, self).__init__()
            self.linear = nn.Linear(2, 2)
    
        def forward(self, x):
            x = self.linear(x)
            x = torch.sigmoid(x)
            return x
    
    
    CUDA = torch.cuda.is_available()
    if CUDA:
        net = Net().cuda()
        inputs = x.cuda()
        target = y.cuda()
    else:
        net = Net()
        inputs = x
        target = y

因为栗子简单，可以直接使用线性模型

![在这里插入图片描述][771df5024eb247e49e84be653a7737dd.png_pic_center]

nn.Linear(2, 2) 的输入包含两个特征的  x ⃗ = ( x 1 , x 2 ) \\vec\{x\} = (x\_1,x\_2) x=(x1,x2) ， x 1 和 x 2 x\_1 和 x\_2 x1和x2 分别代表横轴和纵轴。

输出的是两个类的“得分” 情况，假设哪一类得分高，就属于那一类。

> torch.sigmoid() 函数：
> 
> ![在这里插入图片描述][a11d637309c84097a31027f743321f20.png_pic_center]
> 
> 这个函数可以将输入的Tensor 输出成(0,1 )之间的数。

我们这里采用的优化器为随机梯度下降(Stochastic Gradient Descent,SGD),其中的学习率设置为0.02。

随机梯度下降算法每次只随机选择一个数据样本来计算梯度并更新模型参数，因此不会占用过多的内存，且每次的学习速度非常快。

由于这是一个分类问题，所以使用交叉熵作为损失函数，PyTorch预设好了交叉熵函数CrossEntropyLoss():

from torch import optim, nn
    
    optimizer = optim.SGD(net.parameters(), lr=0.02)
    criterion = nn.CrossEntropyLoss()

OK， 定义绘图和train函数：

def draw(output):
        if CUDA:
            output = output.cpu()
    
        plt.cla()
        output = torch.max((output), 1)[1]
        pred_y = output.data.numpy().squeeze()
        target_y = y.numpy()
        plt.scatter(x.numpy()[:, 0], x.numpy()[:, 1], c=pred_y, s=10, lw=0, cmap='RdYlGn')
        accuracy = sum(pred_y == target_y) / 1000.0
        plt.text(1.5, -4, 'Accuracy = %s' % (accuracy), fontdict={
        'size': 20, 'color': 'red'})
        plt.pause(0.1)
    
    
    def train(model, criterion, optimizer, epochs):
        for epoch in range(epochs):
            output = model(inputs)
            loss = criterion(output, target)
    
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()
    
            if (epoch + 1) % 1000 == 0:
                draw(output)

criterion就是交叉熵，CrossEntropyLoss() 函数要求同时输入模型计算输出的output 和 目标值 target，它们两者的Tensor 形状均为"样本数 x n"，其中n 为分类的种数，二分类就是2.

这里笔者当训练完第1000 次的时候打印图像。

这里使用torch.max() 函数，该函数会返回选定维度中的最大值和序列号。

![在这里插入图片描述][e02b5089b0ed435abd3302e0a5dc4f01.png_pic_center]

torch.max()函数会返回output中概率最大的一组数值与该类别的标签，我们从output中提取出类别标签的列表并将其与目标类别标签进行比对，累计相同的部分并将其除以总数据量，求得正确率Accuracy。

训练1000次

train(net, criterion, optimizer, 1000)

![在这里插入图片描述][65081c4a35d140a0a0f857a2a575c541.png_pic_center]

没毛病。

[49956402921b42558d7d802eebad914d.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/0d3fe48625c841818da3fa966d2e23ea.png
[958e86f6deab48ff95384ef85f7a2573.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/bbea4e58b9b9459dbd039f35d53a69dd.png
[c483364922134ca9affd104ffc8499a6.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/d99b80fed235484eb61ceefd3f08343d.png
[0b6dd80d458c45f3a2fe700c8961d031.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/da8913f785a64da092184079e5553404.png
[07f1e019cca64ace83d37d0c0c1b57eb.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/8e7faedb2bd949668b8a348b3e298876.png
[771df5024eb247e49e84be653a7737dd.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/2983648cab5d4cb89c774010c1bbeaf2.png
[a11d637309c84097a31027f743321f20.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/6c2f87635b4a495791a5ece81848af82.png
[e02b5089b0ed435abd3302e0a5dc4f01.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/18d2a02e111f41bea340007f58902d53.png
[65081c4a35d140a0a0f857a2a575c541.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/27ed8bc18b554d209c5d09cf329ee2d4.png