逻辑回归(理论)
目录
- 一、概论
 - 1、何为逻辑回归
 - 2、映射函数的引入
 - 3、伯努利分布
 
- 二、损失函数的推导
 - 三、用逻辑回归实现多分类
 - 1、间接法:HardMax
 - 2、直接法:SoftMax
 - Ⅰ SoftMax的引入
 - Ⅱ SoftMax的计算
 - Ⅲ 引入SoftMax后的损失函数:交叉熵
 
- 四、实战部分(正在研究中...)
 
一、概论
1、何为逻辑回归
逻辑回归(Logistic Regression)是一种分类方法,主要用于二分类问题(即输出只有两个结果:是与不是)。因此,其与线性回归的不同之处仅在最终的输出结果上。若以贷款事件为例,则可将两者在最后进行预测时的执行流程归纳如下:

线性回归
 ◦ 输入:一组指定数据集的输入向量,如: x(3) = [ 1, 4000, 20 ]𝑇;
 ◦ 处理:对该模型构建的预测函数: ℎ𝜃(x(𝑖)) = 𝜃𝑇x(𝑖);
 ◦ 输出:表示对输入数据的反馈,如经过上预测函数可能会得到 ℎ𝜃(x(3)) = 49995,表示该分类器认为:输入向量 x(3) 的贷款限额为 49995 (银行对杰克马进行资产评估后,认为可对其放贷 49995)。
逻辑回归
 ◦ 输入:一组指定数据集的输入向量,如: x(3) = [ 1, 4000, 20 ]𝑇;
 ◦ 处理:对该模型构建的预测函数: 𝑔𝜃(x(𝑖));
 ◦ 输出:表示对输入数据的反馈,如经过上预测函数可能会得到 
    
     
      
       
        
         𝑔
        
        
         θ
        
       
       
        
         (
        
        
         
          x
         
         
          
           (
          
          
           3
          
          
           )
          
         
        
        
         )
        
       
       
        =
       
       
        1
       
      
      
       𝑔_\theta \left( \text{x}^{(3)} \right)=1
      
     
    gθ(x(3))=1 (或 
    
     
      
       
        
         𝑔
        
        
         θ
        
       
       
        
         (
        
        
         
          x
         
         
          
           (
          
          
           3
          
          
           )
          
         
        
        
         )
        
       
       
        =
       
       
        0
       
      
      
       𝑔_\theta \left( \text{x}^{(3)} \right)=0
      
     
    gθ(x(3))=0 ),表示该分类器认为:对于向量 x(3) 提出的贷款申请可批准(或不可批准)。即银行对杰克马进行资产评估后,认为可对其放贷(或不可对其放贷)。
从两者的执行流程看,逻辑回归相较于线性回归而言仅仅是在最终的输出结果上有所不同。
 那要如何实现逻辑回归呢?
2、映射函数的引入
一种很直接的办法是:
 找到一种映射方式(假设该函数为 𝑔(𝑧) ),使得对于任意的输入,都能将结果映射到两个固定值上。
 于是乎,很自然地我们会想到一个函数——阶跃函数:
s g n ( x ) = { − 1 x < 0 0 x = 0 1 x > 0 sgn(x)=\begin{cases} -1 & x<0 \\ 0 & x=0 \\ 1 & x>0 \end{cases} sgn(x)=⎩ ⎨ ⎧−101x<0x=0x>0
其图像如下:

此时,对于任意输入的特征向量,我们仍然可用线性回归的方式来先算出该向量的预测值 ℎ𝜃(x(𝑖)) ,然后再将该预测值作为阶跃函数 s𝑔𝑛(𝑥) 的输入,最终由阶跃函数的输出值作为逻辑回归的最终结果(即:
    
     
      
       
        
         g
        
        
         θ
        
       
       
        
         (
        
        
         
          x
         
         
          
           (
          
          
           i
          
          
           )
          
         
        
        
         )
        
       
       
        =
       
       
        s
       
       
        g
       
       
        n
       
       
        
         (
        
        
         
          h
         
         
          θ
         
        
        
         
          (
         
         
          
           x
          
          
           
            (
           
           
            i
           
           
            )
           
          
         
         
          )
         
        
        
         )
        
       
      
      
       g_\theta \left( \text{x}^{(i)} \right)=sgn \left( h_\theta \left( \text{x}^{(i)} \right) \right)
      
     
    gθ(x(i))=sgn(hθ(x(i))) )。此时,当测值大于零时就判为正例;小于零则判为反例;预测值为临界值 0 时则任意判别。
 但是阶跃函数有一个缺点,不连续。于是我们希望找到一个能在一定程度上近似阶跃函数的替代函数,并希望它单调可微。基于此,Logistic 函数(或称为 Sigmoid 函数)便派上了用场。
Sigmoid 函数的定义如下:
 
     
      
       
        
         σ
        
        
         (
        
        
         z
        
        
         )
        
        
         =
        
        
         
          1
         
         
          
           1
          
          
           +
          
          
           
            e
           
           
            
             −
            
            
             z
            
           
          
         
        
       
       
         \sigma(z)=\frac{1}{1+e^{-z}} 
       
      
     σ(z)=1+e−z1
 它是一个定义域为 (−∞, +∞) ,值域为 (0,1) 的严格单调递增函数,其图像如下图所示。

引入 Sigmoid 函数的好处是使得映射函数具备了单调可微的优良数学特性。但是,此时再将在线性回归中得到的预测值传入映射函数中时(即:
    
     
      
       
        
         g
        
        
         θ
        
       
       
        
         (
        
        
         
          x
         
         
          
           (
          
          
           i
          
          
           )
          
         
        
        
         )
        
       
       
        =
       
       
        s
       
       
        g
       
       
        n
       
       
        
         (
        
        
         
          h
         
         
          θ
         
        
        
         
          (
         
         
          
           x
          
          
           
            (
           
           
            i
           
           
            )
           
          
         
         
          )
         
        
        
         )
        
       
      
      
       g_\theta \left( \text{x}^{(i)} \right)=sgn \left( h_\theta \left( \text{x}^{(i)} \right) \right)
      
     
    gθ(x(i))=sgn(hθ(x(i))) ),得到的将不再是离散型的预测结果(True / False),而是取值在 0,1 间的实数。因此,我们必须使用某种数学手段来完成从连续性变量到离散型变量的转换。
 一个比较直观的方法是:设置一个阈值 𝜇 以将原始值域区间 (0,1) 划分为两个连续区间 (0, 𝜇) 和 (𝜇, 1) ,然后分别在各区间中设置对应的输出结果。这样的思路实际上是利用了逻辑回归主要用于二分类问题的这一特性。此时,可将“某个向量属于正例(或反例)”视为一个事件,则对向量的预测就转变为对事件概率的估计(这一过程利用了 Sigmoid 函数,因为概率的取值范围正好也是 [0,1] )。比如,可取 
    
     
      
       
        μ
       
       
        =
       
       
        
         1
        
        
         2
        
       
      
      
       \mu=\frac{1}{2}
      
     
    μ=21 。此时,当通过 Sigmoid 函数求得的值小于等于 0.5 时,则认为其属于负例;反之,则属于正例。
现在,让我们通过 Sigmoid 函数来完整梳理下逻辑回归最终的分类过程:
 ◦ Ⅰ 获取输入向量:如 x(3) = [ 1, 4000, 20 ]𝑇;
 ◦ Ⅱ 调用预测函数: 
    
     
      
       
        
         g
        
        
         θ
        
       
       
        
         (
        
        
         
          x
         
         
          
           (
          
          
           i
          
          
           )
          
         
        
        
         )
        
       
       
        =
       
       
        σ
       
       
        
         (
        
        
         
          h
         
         
          θ
         
        
        
         
          (
         
         
          
           x
          
          
           
            (
           
           
            i
           
           
            )
           
          
         
         
          )
         
        
        
         )
        
       
       
        ∈
       
       
        (
       
       
        0
       
       
        ,
       
       
        1
       
       
        )
       
      
      
       g_\theta \left( \text{x}^{(i)} \right)=\sigma \left( h_\theta \left( \text{x}^{(i)} \right) \right) ∈ (0,1)
      
     
    gθ(x(i))=σ(hθ(x(i)))∈(0,1) 。这一步首先会计算出 ℎ𝜃(x(3)) = 49995 ,然后将该值作为输入,带进 𝜎 (·) 中计算得到 
    
     
      
       
        
         g
        
        
         θ
        
       
       
        
         (
        
        
         
          x
         
         
          
           (
          
          
           3
          
          
           )
          
         
        
        
         )
        
       
       
        =
       
       
        σ
       
       
        (
       
       
        49995
       
       
        )
       
       
        =
       
       
        
         1
        
        
         
          1
         
         
          +
         
         
          
           e
          
          
           
            −
           
           
            49995
           
          
         
        
       
       
        ≈
       
       
        1
       
      
      
       g_\theta \left( \text{x}^{(3)} \right)=\sigma(49995)=\frac{1}{1+e^{-49995}}≈1
      
     
    gθ(x(3))=σ(49995)=1+e−499951≈1。
 ◦ Ⅲ 得到预测结果:若设事件“银行会贷款给杰克马”,则由Ⅱ得到的结果可知:当输入向量 x 取 [ 1, 4000, 20 ]𝑇 ,预测函数为 𝑔𝜃(x(𝑖)) 时,原事件发生的概率为 1。与之对应的,事件“银行不会贷款给杰克马”的概率则为 1 − 1 = 0 。
注:在上面的案例中,预测函数 𝑔𝜃(x(𝑖)) 得到的概率为 1,这是比较理想的数据。但大多数时候,得到的可能是 0, 1 之间的任何实数,如 0.57、0.78。此时,“银行是否贷款给杰克马”这个分类任务便转换为“银行会贷款给杰克马的概率为多少?”。
 现在,若将事件“银行会贷款给杰克马”标记为 y = 1 ,其对立事件“银行不会贷款给杰克马”标记为 y = 0,则可将这两个事件的概率归结为如下两式:
 ◦ 银行会贷款给杰克马的概率:𝑃(𝑦 = 1 | 𝑥; 𝜃) = 𝑔𝜃(𝑥);
 ◦ 银行不会贷款给杰克马的概率:𝑃(𝑦 = 0 | 𝑥; 𝜃) = 1 − 𝑔𝜃(𝑥);
3、伯努利分布
为了能以数学的方式来归纳逻辑回归在任意情况下的概率(以便后面构建损失函数),需要用到概率论中的伯努利分布。
 伯努利分布指的是对随机变量 𝑥 ,有参数 𝑝(0 < 𝑝 < 1),使得它分别以概率 𝑝 和 1 − 𝑝 取到 1 和 0 的值(因此,伯努利分布也被称为 0-1分布)。伯努利分布是一个离散型概率分布,是 𝑛 = 1 时二项分布的特殊情况。若令 𝑞 = 1 − 𝑝 ,则 𝑥 的概率函数为:
 
     
      
       
        
         f
        
        
         (
        
        
         x
        
        
         ∣
        
        
         p
        
        
         )
        
        
         =
        
        
         
          {
         
         
          
           
            
             
              
               
                p
               
               
                x
               
              
              
               
                q
               
               
                
                 1
                
                
                 −
                
                
                 x
                
               
              
             
            
           
           
            
             
              
               x
              
              
               =
              
              
               0
              
              
               ,
              
              
               1
              
             
            
           
          
          
           
            
             
              0
             
            
           
           
            
             
              其他
             
            
           
          
         
        
       
       
         f(x|p)=\begin{cases} p^xq^{1-x} & x=0,1 \\ 0 & 其他 \\ \end{cases} 
       
      
     f(x∣p)={pxq1−x0x=0,1其他
 对于逻辑回归而言,其最终的结果正好是两类。因此,基于伯努利概型,可将任意二分类任务整合为:
 
     
      
       
        
         p
        
        
         (
        
        
         y
        
        
         ∣
        
        
         x
        
        
         ;
        
        
         θ
        
        
         )
        
        
         =
        
        
         
          g
         
         
          θ
         
        
        
         (
        
        
         x
        
        
         
          )
         
         
          y
         
        
        
         
          
           (
          
          
           1
          
          
           −
          
          
           
            g
           
           
            θ
           
          
          
           (
          
          
           x
          
          
           )
          
          
           )
          
         
         
          
           1
          
          
           −
          
          
           y
          
         
        
       
       
        p(y|x;\theta)=g_\theta(x)^y\left(1-g_\theta(x) \right)^{1-y}
       
      
     p(y∣x;θ)=gθ(x)y(1−gθ(x))1−y
 此时,若欲知“某向量被分为正例”或“某事件会发生”,则可得到其概率为:
 
     
      
       
        
         p
        
        
         (
        
        
         y
        
        
         =
        
        
         1
        
        
         ∣
        
        
         x
        
        
         ;
        
        
         θ
        
        
         )
        
        
         =
        
        
         
          g
         
         
          θ
         
        
        
         (
        
        
         x
        
        
         
          )
         
         
          1
         
        
        
         
          
           (
          
          
           1
          
          
           −
          
          
           
            g
           
           
            θ
           
          
          
           (
          
          
           x
          
          
           )
          
          
           )
          
         
         
          
           1
          
          
           −
          
          
           1
          
         
        
        
         =
        
        
         
          g
         
         
          θ
         
        
        
         (
        
        
         x
        
        
         )
        
       
       
        p(y=1|x;\theta)=g_\theta(x)^1\left(1-g_\theta(x) \right)^{1-1}=g_\theta(x)
       
      
     p(y=1∣x;θ)=gθ(x)1(1−gθ(x))1−1=gθ(x)
 若欲知“某向量被分为负例”或“某事件不会发生”,则可得到其概率为:
 
     
      
       
        
         p
        
        
         (
        
        
         y
        
        
         =
        
        
         0
        
        
         ∣
        
        
         x
        
        
         ;
        
        
         θ
        
        
         )
        
        
         =
        
        
         
          g
         
         
          θ
         
        
        
         (
        
        
         x
        
        
         
          )
         
         
          0
         
        
        
         
          
           (
          
          
           1
          
          
           −
          
          
           
            g
           
           
            θ
           
          
          
           (
          
          
           x
          
          
           )
          
          
           )
          
         
         
          
           1
          
          
           −
          
          
           0
          
         
        
        
         =
        
        
         1
        
        
         −
        
        
         
          g
         
         
          θ
         
        
        
         (
        
        
         x
        
        
         )
        
       
       
        p(y=0|x;\theta)=g_\theta(x)^0\left(1-g_\theta(x) \right)^{1-0}=1-g_\theta(x)
       
      
     p(y=0∣x;θ)=gθ(x)0(1−gθ(x))1−0=1−gθ(x)
 这与我们在前面所作出的归结是一致的。
二、损失函数的推导
除去最终的预测结果,逻辑回归和线性回归一样,其本质均是寻找一个能尽可能拟合真实情况的回归方程(即求出 𝜃 向量),因此也要用到极大似然估法。在前面我们已经得到了对某次试验 𝑥(𝑖) 的概率分布函数为 𝑃(𝑦 | 𝑥(𝑖) ;𝜃) ,若考虑全部的数据集,则可以得到其联合概率密度为 
    
     
      
       
        
         ∏
        
        
         
          i
         
         
          =
         
         
          1
         
        
        
         n
        
       
       
        p
       
       
        
         (
        
        
         
          y
         
         
          
           (
          
          
           i
          
          
           )
          
         
        
        
         ∣
        
        
         
          x
         
         
          
           (
          
          
           i
          
          
           )
          
         
        
        
         ;
        
        
         θ
        
        
         )
        
       
      
      
       \prod_{i=1}^np\left( \text{y}^{(i)} | \text{x}^{(i)} ;\theta \right)
      
     
    ∏i=1np(y(i)∣x(i);θ) ,于是根据极大似然估法,可得似然函数为:
 
     
      
       
        
         L
        
        
         (
        
        
         θ
        
        
         )
        
        
         =
        
        
         
          ∏
         
         
          
           i
          
          
           =
          
          
           1
          
         
         
          n
         
        
        
         p
        
        
         
          (
         
         
          
           y
          
          
           
            (
           
           
            i
           
           
            )
           
          
         
         
          ∣
         
         
          
           x
          
          
           
            (
           
           
            i
           
           
            )
           
          
         
         
          ;
         
         
          θ
         
         
          )
         
        
        
         =
        
        
         
          ∏
         
         
          
           i
          
          
           =
          
          
           1
          
         
         
          n
         
        
        
         
          g
         
         
          θ
         
        
        
         
          
           (
          
          
           
            x
           
           
            
             (
            
            
             i
            
            
             )
            
           
          
          
           )
          
         
         
          
           y
          
          
           
            (
           
           
            i
           
           
            )
           
          
         
        
        
         
          
           (
          
          
           1
          
          
           −
          
          
           
            g
           
           
            θ
           
          
          
           
            (
           
           
            
             x
            
            
             
              (
             
             
              i
             
             
              )
             
            
           
           
            )
           
          
          
           )
          
         
         
          
           1
          
          
           −
          
          
           
            y
           
           
            
             (
            
            
             i
            
            
             )
            
           
          
         
        
       
       
         L(\theta)=\prod_{i=1}^np\left( \text{y}^{(i)} | \text{x}^{(i)} ;\theta \right)=\prod_{i=1}^ng_\theta \left( \text{x}^{(i)} \right)^{\text{y}^{(i)}} \left( 1-g_\theta \left( x^{(i)} \right) \right)^{1-\text{y}^{(i)}} 
       
      
     L(θ)=i=1∏np(y(i)∣x(i);θ)=i=1∏ngθ(x(i))y(i)(1−gθ(x(i)))1−y(i)
 同样地,由于我们的任务是求出 𝜃 向量(即求极值点而非极值),因此为了简化计算进行对数处理:
 
     
      
       
        
         ln
        
        
         L
        
        
         (
        
        
         θ
        
        
         )
        
        
         =
        
        
         ln
        
        
         
          ∏
         
         
          
           i
          
          
           =
          
          
           1
          
         
         
          n
         
        
        
         
          g
         
         
          θ
         
        
        
         
          
           (
          
          
           
            x
           
           
            
             (
            
            
             i
            
            
             )
            
           
          
          
           )
          
         
         
          
           y
          
          
           
            (
           
           
            i
           
           
            )
           
          
         
        
        
         
          
           (
          
          
           1
          
          
           −
          
          
           
            g
           
           
            θ
           
          
          
           
            (
           
           
            
             x
            
            
             
              (
             
             
              i
             
             
              )
             
            
           
           
            )
           
          
          
           )
          
         
         
          
           1
          
          
           −
          
          
           
            y
           
           
            
             (
            
            
             i
            
            
             )
            
           
          
         
        
        
         =
        
        
         
          ∑
         
         
          
           i
          
          
           =
          
          
           1
          
         
         
          n
         
        
        
         
          (
         
         
          
           y
          
          
           
            (
           
           
            i
           
           
            )
           
          
         
         
          ln
         
         
          
           g
          
          
           θ
          
         
         
          (
         
         
          
           x
          
          
           
            (
           
           
            i
           
           
            )
           
          
         
         
          )
         
         
          +
         
         
          (
         
         
          1
         
         
          −
         
         
          
           y
          
          
           
            (
           
           
            i
           
           
            )
           
          
         
         
          )
         
         
          ln
         
         
          
           (
          
          
           1
          
          
           −
          
          
           
            g
           
           
            θ
           
          
          
           (
          
          
           
            x
           
           
            
             (
            
            
             i
            
            
             )
            
           
          
          
           )
          
          
           )
          
         
         
          )
         
        
       
       
         \text{ln} L(\theta)=\text{ln} \prod_{i=1}^ng_\theta \left( \text{x}^{(i)} \right)^{\text{y}^{(i)}} \left( 1-g_\theta \left( x^{(i)} \right) \right)^{1-\text{y}^{(i)}}=\sum_{i=1}^n \left( \text{y}^{(i)}\text{ln}g_\theta ( \text{x}^{(i)} ) + (1-\text{y}^{(i)})\text{ln}\left( 1-g_\theta ( \text{x}^{(i)}) \right) \right) 
       
      
     lnL(θ)=lni=1∏ngθ(x(i))y(i)(1−gθ(x(i)))1−y(i)=i=1∑n(y(i)lngθ(x(i))+(1−y(i))ln(1−gθ(x(i))))
 对于上式,我们希望其尽可能满足真实数据的分布,即该似然函数的值越大越好,因此这需要用到梯度上升。但是在现实世界做最优化处理时,我们通常习惯求最小值。于是可以设损失函数为:
 
     
      
       
        
         J
        
        
         (
        
        
         θ
        
        
         )
        
        
         =
        
        
         −
        
        
         
          1
         
         
          n
         
        
        
         ln
        
        
         L
        
        
         (
        
        
         θ
        
        
         )
        
        
         =
        
        
         −
        
        
         
          1
         
         
          n
         
        
        
         
          ∑
         
         
          
           i
          
          
           =
          
          
           1
          
         
         
          n
         
        
        
         (
        
        
         
          y
         
         
          
           (
          
          
           i
          
          
           )
          
         
        
        
         ln
        
        
         
          g
         
         
          θ
         
        
        
         (
        
        
         
          x
         
         
          
           (
          
          
           i
          
          
           )
          
         
        
        
         )
        
        
         +
        
        
         (
        
        
         1
        
        
         −
        
        
         
          y
         
         
          
           (
          
          
           i
          
          
           )
          
         
        
        
         )
        
        
         ln
        
        
         (
        
        
         1
        
        
         −
        
        
         
          g
         
         
          θ
         
        
        
         (
        
        
         
          x
         
         
          
           (
          
          
           i
          
          
           )
          
         
        
        
         )
        
        
         )
        
        
         )
        
       
       
         J(\theta)=-\frac1n \text{ln}L(\theta)=-\frac1n \sum_{i=1}^n \Big( \text{y}^{(i)} \text{ln}g_\theta ( \text{x}^{(i)} ) + (1-\text{y}^{(i)}) \text{ln} \big( 1-g_\theta ( \text{x}^{(i)}) \big) \Big) 
       
      
     J(θ)=−n1lnL(θ)=−n1i=1∑n(y(i)lngθ(x(i))+(1−y(i))ln(1−gθ(x(i))))
 来将梯度上升转化为梯度下降问题。
接下来对损失函数求导以求出极值点:

将该极值点作为梯度,便可得到用于梯度下降的参数更新公式为(其中 𝛼 为迭代的步长):
 
     
      
       
        
         
          θ
         
         
          j
         
        
        
         =
        
        
         
          θ
         
         
          j
         
        
        
         −
        
        
         
          α
         
         
          n
         
        
        
         
          ∑
         
         
          
           i
          
          
           =
          
          
           1
          
         
         
          n
         
        
        
         
          (
         
         
          
           g
          
          
           θ
          
         
         
          (
         
         
          
           x
          
          
           
            (
           
           
            i
           
           
            )
           
          
         
         
          )
         
         
          −
         
         
          
           y
          
          
           
            (
           
           
            i
           
           
            )
           
          
         
         
          )
         
        
        
         
          x
         
         
          j
         
         
          
           (
          
          
           i
          
          
           )
          
         
        
       
       
         \theta_j=\theta_j-\frac{\alpha}{n}\sum_{i=1}^n\left( g_\theta(\text{x}^{(i)}) - \text{y}^{(i)} \right) \text{x}_j^{(i)} 
       
      
     θj=θj−nαi=1∑n(gθ(x(i))−y(i))xj(i)
三、用逻辑回归实现多分类
将逻辑回归应用到多分类问题,主要有两种解决思路:
 ◦ Ⅰ 间接法:将多分类问题视为二类分类问题,即在每次分类时保留其中一类,剩下的作为另一类。
 ◦ Ⅱ 直接法:考虑待分类数据的所有类别,常用手段是 softmax。
1、间接法:HardMax
对于输入样本,每次分类都将目标类与其他类视为两种不同种类。
 这就要求对于每一个类别 𝑖 而言,都需要单独训练出一个逻辑回归模型的分类器 
    
     
      
       
        
         g
        
        
         θ
        
        
         
          (
         
         
          i
         
         
          )
         
        
       
       
        (
       
       
        x
       
       
        )
       
      
      
       g_\theta^{(i)}(\text x)
      
     
    gθ(i)(x) 。接下来在预测时,对于任意输入向量
 x 都需要预测出其在每个类上的概率,并在最终取概率最大的那个类作为分类结果。

2、直接法:SoftMax
Ⅰ SoftMax的引入
对如下多分类例子:
 
 假设基于逻辑回归的各分类器对其中的灰色菱形做出如下预测:

其中, g θ ( h θ ( x ( i ) ) ) = g θ ( θ j T x ( i ) ) = σ ( θ j T x ( i ) ) = 1 1 + e − θ j T x ( i ) g_\theta \left( h_\theta(\text{x}^{(i)}) \right)=g_\theta(\theta_j^T \text{x}^{(i)})=\sigma(\theta_j^T \text{x}^{(i)})=\frac{1}{1+e^{-\theta_j^T \text{x}^{(i)}}} gθ(hθ(x(i)))=gθ(θjTx(i))=σ(θjTx(i))=1+e−θjTx(i)1。
则根据“HardMax”的决策思维:概率值最大的即为正确的。于是有:
𝐶𝑙𝑎𝑠𝑠 = 𝑚𝑎𝑥𝑉𝑎𝑙𝑢𝑒(𝑃𝑟𝑜𝑏𝑎𝑏𝑖𝑙𝑖𝑡𝑦𝑆𝑒𝑡) = max{0.75, 0.40, 0.59}= 0.75 → 红色
但这样的分类策略过于绝对,它曲解了概率的真正内涵。实际上,概率本身表达的是一种可能性(或称待估目标在指定情况下发生的频数),它并不是说概率值大的就“一定是”,而是“发生的可能性更大”(或“出现的频数更高”)。上表中,尽管分类器认为待估目标属于蓝色的概率值仅有 0.40,是所有预测中最低的。但在现实中,待估目标有可能就是属于蓝色。
 并且从另一个角度来看,“属于蓝色”的概率值 + “属于绿色”的概率值 = 0.4 + 0.59 = 0.99 > 0.75。那我们也有理由相信:“灰色菱形不属于红色圆形”的可能性是大于“灰色菱形是属于红色圆形”的。因此,仅考察预测结果中的最大值作为正确分类是不大合适的。基于此,便引入了“SoftMax”。
Ⅱ SoftMax的计算
softmax 是个较为常用且比较重要的函数,其计算方式如下:
 
     
      
       
        
         
          g
         
         
          θ
         
        
        
         (
        
        
         
          x
         
         
          
           (
          
          
           i
          
          
           )
          
         
        
        
         )
        
        
         =
        
        
         
          [
         
         
          
           
            
             
              
               p
              
              
               (
              
              
               
                y
               
               
                
                 (
                
                
                 i
                
                
                 )
                
               
              
              
               =
              
              
               1
              
              
               ∣
              
              
               
                x
               
               
                
                 (
                
                
                 i
                
                
                 )
                
               
              
              
               ;
              
              
               θ
              
              
               )
              
             
            
           
          
          
           
            
             
              
               p
              
              
               (
              
              
               
                y
               
               
                
                 (
                
                
                 i
                
                
                 )
                
               
              
              
               =
              
              
               2
              
              
               ∣
              
              
               
                x
               
               
                
                 (
                
                
                 i
                
                
                 )
                
               
              
              
               ;
              
              
               θ
              
              
               )
              
             
            
           
          
          
           
            
             
              …
             
            
           
          
          
           
            
             
              
               p
              
              
               (
              
              
               
                y
               
               
                
                 (
                
                
                 i
                
                
                 )
                
               
              
              
               =
              
              
               k
              
              
               ∣
              
              
               
                x
               
               
                
                 (
                
                
                 i
                
                
                 )
                
               
              
              
               ;
              
              
               θ
              
              
               )
              
             
            
           
          
         
         
          ]
         
        
        
         =
        
        
         
          1
         
         
          
           
            ∑
           
           
            
             j
            
            
             =
            
            
             1
            
           
           
            k
           
          
          
           
            e
           
           
            
             
              θ
             
             
              j
             
             
              T
             
            
            
             
              x
             
             
              
               (
              
              
               i
              
              
               )
              
             
            
           
          
         
        
        
         
          [
         
         
          
           
            
             
              
               e
              
              
               
                
                 θ
                
                
                 1
                
                
                 T
                
               
               
                
                 x
                
                
                 
                  (
                 
                 
                  i
                 
                 
                  )
                 
                
               
              
             
            
           
          
          
           
            
             
              
               e
              
              
               
                
                 θ
                
                
                 2
                
                
                 T
                
               
               
                
                 x
                
                
                 
                  (
                 
                 
                  i
                 
                 
                  )
                 
                
               
              
             
            
           
          
          
           
            
             
              …
             
            
           
          
          
           
            
             
              
               e
              
              
               
                
                 θ
                
                
                 k
                
                
                 T
                
               
               
                
                 x
                
                
                 
                  (
                 
                 
                  i
                 
                 
                  )
                 
                
               
              
             
            
           
          
         
         
          ]
         
        
        
          
        
       
       
         g_\theta(\text{x}^{(i)})=\left[ \begin{matrix} p(\text{y}^{(i)}=1|\text{x}^{(i)};\theta) \\ p(\text{y}^{(i)}=2|\text{x}^{(i)};\theta) \\ … \\ p(\text{y}^{(i)}=k|\text{x}^{(i)};\theta) \end{matrix} \right]= \frac{1}{\sum_{j=1}^k e^{\theta_j^T\text{x}^{(i)}}} \left[ \begin{matrix} e^{\theta_1^T\text{x}^{(i)}} \\ e^{\theta_2^T\text{x}^{(i)}} \\ … \\ e^{\theta_k^T\text{x}^{(i)}} \end{matrix} \right] \ 
       
      
     gθ(x(i))=
              p(y(i)=1∣x(i);θ)p(y(i)=2∣x(i);θ)…p(y(i)=k∣x(i);θ)
              =∑j=1keθjTx(i)1
              eθ1Tx(i)eθ2Tx(i)…eθkTx(i)
               
 他的作用是将一系列输入映射到范围为 0, 1 之间的值,并保证这些值的总和为 1(因为多分类的概率之和也刚好为 1)。接下来,对于每个输入的值,都将其与总和的比值作为“将该目标归类到此输入所代表的类”的概率。经过这样的处理,对于待预测目标而言,我们便得到了其取到每个分类的概率。这个概率相较于最初算出的概率而言,它最大的特点是进行了归一化处理(即所有概率之和为1)。这样一来,对于最终的预测结果,我们并不显式地给出一个分类,而是依概率随机地返回这个归一化列表中的某个类。由此,便实现了“希望分值大的那一项被经常取到,而分值较小的那一项也有一定的概率偶尔被取到”这一较为合理的决策方式。这种不给出“是与否”,而是指出在各类情况下的发生可能性的决策思维体现出“SoftMax”。
接下来应用 Softmax 的思想,再对下图的菱形进行分类。

第一步仍然是基于逻辑回归算出该目标在各类别上的概率,但是此时仅需要算到
 
    
     
      
       
        
         h
        
        
         θ
        
       
       
        (
       
       
        
         x
        
        
         
          (
         
         
          i
         
         
          )
         
        
       
       
        )
       
       
        =
       
       
        
         θ
        
        
         j
        
        
         T
        
       
       
        
         x
        
        
         
          (
         
         
          i
         
         
          )
         
        
       
      
      
       h_\theta(\text{x}^{(i)})=\theta_j^T\text{x}^{(i)}
      
     
    hθ(x(i))=θjTx(i) 即可,不必再传入 Sigmoid 函数,即:

接着,便开始进行 Softmax 操作以算出待预测目标在各类别上的归一化概率:
     
      
       
        
         
          g
         
         
          θ
         
        
        
         (
        
        
         
          x
         
         
          
           (
          
          
           i
          
          
           )
          
         
        
        
         )
        
        
         =
        
        
         
          [
         
         
          
           
            
             
              
               p
              
              
               (
              
              
               
                y
               
               
                
                 (
                
                
                 i
                
                
                 )
                
               
              
              
               =
              
              
               红
              
              
               ∣
              
              
               
                x
               
               
                
                 (
                
                
                 i
                
                
                 )
                
               
              
              
               ;
              
              
               θ
              
              
               )
              
             
            
           
          
          
           
            
             
              
               p
              
              
               (
              
              
               
                y
               
               
                
                 (
                
                
                 i
                
                
                 )
                
               
              
              
               =
              
              
               蓝
              
              
               ∣
              
              
               
                x
               
               
                
                 (
                
                
                 i
                
                
                 )
                
               
              
              
               ;
              
              
               θ
              
              
               )
              
             
            
           
          
          
           
            
             
              
               p
              
              
               (
              
              
               
                y
               
               
                
                 (
                
                
                 i
                
                
                 )
                
               
              
              
               =
              
              
               绿
              
              
               ∣
              
              
               
                x
               
               
                
                 (
                
                
                 i
                
                
                 )
                
               
              
              
               ;
              
              
               θ
              
              
               )
              
             
            
           
          
         
         
          ]
         
        
        
         =
        
        
         
          1
         
         
          
           
            ∑
           
           
            
             j
            
            
             =
            
            
             1
            
           
           
            k
           
          
          
           
            e
           
           
            
             
              θ
             
             
              j
             
             
              T
             
            
            
             
              x
             
             
              
               (
              
              
               i
              
              
               )
              
             
            
           
          
         
        
        
         
          [
         
         
          
           
            
             
              
               e
              
              
               
                
                 θ
                
                
                 1
                
                
                 T
                
               
               
                
                 x
                
                
                 
                  (
                 
                 
                  i
                 
                 
                  )
                 
                
               
              
             
            
           
          
          
           
            
             
              
               e
              
              
               
                
                 θ
                
                
                 2
                
                
                 T
                
               
               
                
                 x
                
                
                 
                  (
                 
                 
                  i
                 
                 
                  )
                 
                
               
              
             
            
           
          
          
           
            
             
              
               e
              
              
               
                
                 θ
                
                
                 3
                
                
                 T
                
               
               
                
                 x
                
                
                 
                  (
                 
                 
                  i
                 
                 
                  )
                 
                
               
              
             
            
           
          
         
         
          ]
         
        
        
         =
        
        
         
          1
         
         
          
           
            e
           
           
            1
           
          
          
           +
          
          
           
            e
           
           
            
             −
            
            
             0.4
            
           
          
          
           +
          
          
           
            e
           
           
            0.4
           
          
         
        
        
         
          [
         
         
          
           
            
             
              
               e
              
              
               1
              
             
            
           
          
          
           
            
             
              
               e
              
              
               
                −
               
               
                0.4
               
              
             
            
           
          
          
           
            
             
              
               e
              
              
               0.4
              
             
            
           
          
         
         
          ]
         
        
        
         =
        
        
         
          1
         
         
          
           2.72
          
          
           +
          
          
           0.67
          
          
           +
          
          
           1.49
          
         
        
        
         
          [
         
         
          
           
            
             
              2.72
             
            
           
          
          
           
            
             
              0.67
             
            
           
          
          
           
            
             
              1.49
             
            
           
          
         
         
          ]
         
        
        
         =
        
        
         
          [
         
         
          
           
            
             
              0.55
             
            
           
          
          
           
            
             
              0.14
             
            
           
          
          
           
            
             
              0.31
             
            
           
          
         
         
          ]
         
        
        
          
        
       
       
         g_\theta(\text{x}^{(i)})=\left[ \begin{matrix} p(\text{y}^{(i)}=红|\text{x}^{(i)};\theta) \\ p(\text{y}^{(i)}=蓝|\text{x}^{(i)};\theta) \\ p(\text{y}^{(i)}=绿|\text{x}^{(i)};\theta) \end{matrix} \right]= \frac{1}{\sum_{j=1}^k e^{\theta_j^T\text{x}^{(i)}}} \left[ \begin{matrix} e^{\theta_1^T\text{x}^{(i)}} \\ e^{\theta_2^T\text{x}^{(i)}} \\ e^{\theta_3^T\text{x}^{(i)}} \end{matrix} \right] = \frac{1}{e^1+e^{-0.4}+e^{0.4}} \left[ \begin{matrix} e^1 \\ e^{-0.4} \\ e^{0.4} \end{matrix} \right]= \frac{1}{2.72+0.67+1.49} \left[ \begin{matrix} 2.72 \\ 0.67 \\ 1.49 \end{matrix} \right]= \left[ \begin{matrix} 0.55 \\ 0.14 \\ 0.31 \end{matrix} \right] \ 
       
      
     gθ(x(i))=
              p(y(i)=红∣x(i);θ)p(y(i)=蓝∣x(i);θ)p(y(i)=绿∣x(i);θ)
              =∑j=1keθjTx(i)1
              eθ1Tx(i)eθ2Tx(i)eθ3Tx(i)
              =e1+e−0.4+e0.41
              e1e−0.4e0.4
              =2.72+0.67+1.491
              2.720.671.49
              =
              0.550.140.31
               
 可以看出,基于 softmax 进行多分类时,输出的是取到每个分类的概率。这样的决策思维更符合概率本身的含义,因此在进行逻辑回归的多分类任务时更为常用。
相较于“HardMax”的做法,“SoftMax”主要有以下两点改进:
 ◦ 1. 放大了数值间的差异。假设有得分为:10、11、12的三个数值,在比较孰优孰劣时其实很难抉择,因为他们之间的差距并不大。基于此,“SoftMax”通过指数函数来放大了这些数据的差异。e12 ≈ 162754 ≫ e11 ≈ 59874 ≫ e10 ≈ 22026。
 ◦ 2. 进行归一化处理。将众多数据映射到 0, 1 之间,使其具有概率的含义,从而便于分类工作。
Ⅲ 引入SoftMax后的损失函数:交叉熵
在利用 softmax 进行多分类时,其损失函数采用的是交叉熵。下面对该损失函数进行一个简单的分析:
 
     
      
       
        
         J
        
        
         (
        
        
         θ
        
        
         )
        
        
         =
        
        
         −
        
        
         
          1
         
         
          n
         
        
        
         
          ∑
         
         
          
           i
          
          
           =
          
          
           1
          
         
         
          n
         
        
        
         
          ∑
         
         
          
           k
          
          
           =
          
          
           1
          
         
         
          K
         
        
        
         
          y
         
         
          k
         
         
          
           (
          
          
           i
          
          
           )
          
         
        
        
         l
        
        
         o
        
        
         g
        
        
         (
        
        
         
          
           p
          
          
           ^
          
         
         
          k
         
         
          
           (
          
          
           i
          
          
           )
          
         
        
        
         )
        
       
       
         J(\theta)=-\frac1n \sum_{i=1}^n \sum_{k=1}^K \text{y}_k^{(i)}log(\hat p_k^{(i)}) 
       
      
     J(θ)=−n1i=1∑nk=1∑Kyk(i)log(p^k(i))
 上式中, 
    
     
      
       
        
         y
        
        
         k
        
        
         
          (
         
         
          i
         
         
          )
         
        
       
      
      
       \text{y}_k^{(i)}
      
     
    yk(i) 只有在分类正确时(即 𝑦(𝑖) == 𝑘 )才非 0,此时 
    
     
      
       
        
         
          p
         
         
          ^
         
        
        
         k
        
        
         
          (
         
         
          i
         
         
          )
         
        
       
      
      
       \hat p_k^{(i)}
      
     
    p^k(i) 表示的是“分类正确”的概率,此概率值的取值范围为 (0,1] (取值为 0 的概率 𝑝(𝑗) = 0 (即分类错误)将因 
    
     
      
       
        
         y
        
        
         k
        
        
         
          (
         
         
          j
         
         
          )
         
        
       
       
        =
       
       
        0
       
      
      
       \text{y}_k^{(j)}=0
      
     
    yk(j)=0 的存在而使得其在该项的值为 0:
    
     
      
       
        0
       
       
        ×
       
       
        ∞
       
       
        =
       
       
        0
       
      
      
       0×\infty=0
      
     
    0×∞=0),其余情况下 
    
     
      
       
        
         y
        
        
         k
        
        
         
          (
         
         
          j
         
         
          )
         
        
       
      
      
       \text{y}_k^{(j)}
      
     
    yk(j) 都为一恒定值,如 1。所以,当分类正确时 
    
     
      
       
        
         y
        
        
         k
        
        
         
          (
         
         
          i
         
         
          )
         
        
       
       
        l
       
       
        o
       
       
        g
       
       
        (
       
       
        
         
          p
         
         
          ^
         
        
        
         k
        
        
         
          (
         
         
          i
         
         
          )
         
        
       
       
        )
       
       
        =
       
       
        l
       
       
        o
       
       
        g
       
       
        (
       
       
        
         
          p
         
         
          ^
         
        
        
         k
        
        
         
          (
         
         
          i
         
         
          )
         
        
       
       
        )
       
      
      
       \text{y}_k^{(i)}log(\hat p_k^{(i)})=log(\hat p_k^{(i)})
      
     
    yk(i)log(p^k(i))=log(p^k(i)) 。

由于 𝑓(𝑥) = 𝑙𝑜𝑔(𝑥) 是定义域为 
    
     
      
       
        (
       
       
        0
       
       
        ,
       
       
        +
       
       
        ∞
       
       
        )
       
      
      
       (0,+\infty)
      
     
    (0,+∞) 的严格单调递增函数,在 
    
     
      
       
        𝑥
       
       
        ∈
       
       
        (
       
       
        0
       
       
        ,
       
       
        1
       
       
        ]
       
      
      
       𝑥 ∈ (0,1]
      
     
    x∈(0,1] 时,其值域为 
    
     
      
       
        (
       
       
        −
       
       
        ∞
       
       
        ,
       
       
        0
       
       
        ]
       
      
      
       (−∞, 0]
      
     
    (−∞,0] 。因此,利用对数函数 𝑙𝑜𝑔(𝑥) 可以对取值范围为 
    
     
      
       
        (
       
       
        0
       
       
        ,
       
       
        1
       
       
        ]
       
      
      
       (0,1]
      
     
    (0,1] 的概率值进行映射,以将不同概率之间的差异也放大。由于映射后得到的值为负数,而通常进行最优化时我们都习惯去求解最小值,因此在 
    
     
      
       
        
         y
        
        
         k
        
        
         
          (
         
         
          i
         
         
          )
         
        
       
       
        l
       
       
        o
       
       
        g
       
       
        (
       
       
        
         
          p
         
         
          ^
         
        
        
         k
        
        
         
          (
         
         
          i
         
         
          )
         
        
       
       
        )
       
      
      
       \text{y}_k^{(i)}log(\hat p_k^{(i)})
      
     
    yk(i)log(p^k(i)) 前添加了一个负号,以将优化过程变为求解最小值。至此,便将“评估分类正确与否”这个任务完美地转换至一个简单的数学模型——使得 𝐽(𝜃) 尽可能小。如:当所有分类均正确时,有
 
     
      
       
        
         J
        
        
         (
        
        
         θ
        
        
         )
        
        
         =
        
        
         −
        
        
         
          1
         
         
          n
         
        
        
         
          ∑
         
         
          
           i
          
          
           =
          
          
           1
          
         
         
          n
         
        
        
         
          ∑
         
         
          
           k
          
          
           =
          
          
           1
          
         
         
          K
         
        
        
         
          y
         
         
          k
         
         
          
           (
          
          
           i
          
          
           )
          
         
        
        
         l
        
        
         o
        
        
         g
        
        
         (
        
        
         
          
           p
          
          
           ^
          
         
         
          k
         
         
          
           (
          
          
           i
          
          
           )
          
         
        
        
         )
        
        
         =
        
        
         −
        
        
         
          1
         
         
          n
         
        
        
         (
        
        
         1
        
        
         ×
        
        
         l
        
        
         o
        
        
         g
        
        
         1
        
        
         +
        
        
         1
        
        
         ×
        
        
         l
        
        
         o
        
        
         g
        
        
         1
        
        
         +
        
        
         …
        
        
         +
        
        
         1
        
        
         ×
        
        
         l
        
        
         o
        
        
         g
        
        
         1
        
        
         )
        
        
         =
        
        
         −
        
        
         
          1
         
         
          n
         
        
        
         (
        
        
         0
        
        
         +
        
        
         0
        
        
         +
        
        
         …
        
        
         +
        
        
         0
        
        
         )
        
        
         =
        
        
         0
        
       
       
         J(\theta)=-\frac1n \sum_{i=1}^n \sum_{k=1}^K \text{y}_k^{(i)}log(\hat p_k^{(i)})=-\frac1n(1×log1+1×log1+…+1×log1)=-\frac1n(0+0+…+0)=0 
       
      
     J(θ)=−n1i=1∑nk=1∑Kyk(i)log(p^k(i))=−n1(1×log1+1×log1+…+1×log1)=−n1(0+0+…+0)=0



















