这是我参与2022首次更文挑战的第4天,活动详情查看:2022首次更文挑战 。
前言
大家好,这里是 Codeman 。这是本文的第二次修订,在前文的基础之上,这次我增加了很多公式的推导,从数学原理到代码实现,本文提供了一站式服务,希望能帮助读者从根上理解逻辑回归,一劳永逸地解决问题!
多次修订,只源于我精益求精的人生态度。写博客,我是认真的!如果你觉得本文确实对你有帮助,请点个赞支持我一下吧 🌹
正文
逻辑回归在社会和自然科学中应用非常广泛,它其实是一种统计学习方法,因为它的底层方法就是线性回归。它们不同的地方在于:线性回归适用于解决回归问题,而逻辑回归适用于解决分类问题。这是为什么呢?别急,看完本文你就懂了。因此,我们可以说逻辑回归是基于回归的伪回归算法!
在自然语言处理中,逻辑回归是用于分类的基线监督机器学习算法,它与神经网络也有非常密切的关系,神经网络可以被视为一系列堆叠在一起的逻辑回归分类器。
由于后文涉及到很多数学公式的推导,因此我们先做一个符号约定:
符号 含义 𝑚 𝑚 m 训练集中样本的数量 𝑛 𝑛 n 特征的数量 𝑥 𝑥 x 特征/输入变量 𝑦 𝑦 y 目标变量/输出变量 ( 𝑥 , 𝑦 ) (𝑥,𝑦) ( x , y ) 训练集中的样本 ( 𝑥 ( 𝑖 ) , 𝑦 ( 𝑖 ) ) (𝑥^{(𝑖)},𝑦^{(𝑖)}) ( x ( i ) , y ( i ) ) 第 𝑖 𝑖 i 个观察样本 𝑥 j ( i ) 𝑥_j^{(i)} x j ( i ) 第 𝑖 𝑖 i 个观察样本的第 j j j 个特征 h ℎ h 学习算法的解决方案或函数,也称为假设(hypothesis) 𝑦 ^ = h ( 𝑥 ) \widehat{𝑦}=ℎ(𝑥) y = h ( x ) 预测值
我们先从线性回归开始讲起,一步一步地领略逻辑回归的全貌。
1.线性回归
线性回归是一种使用特征属性的线性组合来预测响应的方法。它的目标是找到一个线性函数,以尽可能准确地描述特征或自变量(x x x )与响应值(y y y )之间的关系,使得预测值与真实值之间的误差最小化。
1.1 数学定义
在数学上,线性回归要找的这个线性函数叫回归方程,其定义如下:
h ( x ( i ) ) = β 0 + β 1 x ( i ) (1.1) h(x^{(i)})=\beta_0+\beta_1x^{(i)}\tag{1.1} h ( x ( i ) ) = β 0 + β 1 x ( i ) ( 1.1 )
其中,h ( x ( i ) ) h(x^{(i)}) h ( x ( i ) ) 表示第 i i i 个样本的预测响应值。b 0 b_0 b 0 和 b 1 b_1 b 1 是回归系数,分别代表回归线的 y y y 轴截距和斜率。这种形式通常见于特征只有单个属性的时候,也就是一元线性回归,我们初高中所学的就是这种。
在机器学习中,通常每个样本都有 n n n 个特征属性,每个特征 x i x_i x i 都有一个对应的权值 w i w_i w i ,此时我们需要的就是多元线性回归:
h ( 𝑥 ) = 𝑤 0 x 0 + 𝑤 1 𝑥 1 + 𝑤 2 𝑥 2 + . . . + 𝑤 𝑛 𝑥 𝑛 = w T X (1.2) ℎ(𝑥)=𝑤_0x_0 +𝑤_1𝑥_1 +𝑤_2𝑥_2 +...+𝑤_𝑛𝑥_𝑛=w^TX\tag{1.2} h ( x ) = w 0 x 0 + w 1 x 1 + w 2 x 2 + ... + w n x n = w T X ( 1.2 )
其中,x 0 = 1 x_0=1 x 0 = 1 没有实义,只是为了方便写成矩阵的形式,w 0 w_0 w 0 则等价于式 (1.1) 中的 β 0 \beta_0 β 0 ,把 β 0 \beta_0 β 0 融入矩阵中,不仅为了看起来简洁,也是为了方便计算。
若损失函数 采用平方和损失:
𝑙 ( 𝑥 ( 𝑖 ) ) = 1 2 ( h ( 𝑥 ( 𝑖 ) ) − 𝑦 ( 𝑖 ) ) 2 (1.3) 𝑙(𝑥^{(𝑖)})=\frac{1}{2}(ℎ(𝑥^{(𝑖)})−𝑦^{(𝑖)})^2\tag{1.3} l ( x ( i ) ) = 2 1 ( h ( x ( i ) ) − y ( i ) ) 2 ( 1.3 )
则代价函数 定义如下:
J ( w ) = 1 2 ∑ 𝑖 = 1 𝑚 ( h ( 𝑥 ( 𝑖 ) ) − 𝑦 ( 𝑖 ) ) 2 (1.4) J(w)=\frac{1}{2}\sum_{𝑖=1}^𝑚(ℎ(𝑥^{(𝑖)})−𝑦^{(𝑖)})^2\tag{1.4} J ( w ) = 2 1 i = 1 ∑ m ( h ( x ( i ) ) − y ( i ) ) 2 ( 1.4 )
损失函数(Loss Function)度量单样本 预测的误差,代价函数(Cost Function)度量全部样本 的平均误差。常用的代价函数有均方误差、均方根误差、平均绝对误差等。
损失函数的系数 1/2 是为了便于计算,使对平方项求导后的常数系数为 1。
我们的目标是要找到一组 𝑤 ( 𝑤 0 , 𝑤 1 , 𝑤 2 , . . . , 𝑤 𝑛 ) 𝑤(𝑤_0,𝑤_1,𝑤_2,...,𝑤_𝑛) w ( w 0 , w 1 , w 2 , ... , w n ) ,使得代价函数 J ( w ) J(w) J ( w ) 最小,即最小化 ∂ 𝐽 ( 𝑤 ) ∂ 𝑤 \frac{\partial {𝐽(𝑤)}}{\partial 𝑤} ∂ w ∂ J ( w ) 。
下面我们将详细描述用最小二乘法求 𝑤 𝑤 w 的推导过程。
1.2 最小二乘法
为了方便叙述,我们将J ( w ) J(w) J ( w ) 用矩阵形式表达,即:
J ( 𝑤 ) = 1 2 ( 𝑋 𝑤 − 𝑌 ) 2 = 1 2 ( 𝑋 𝑤 − 𝑌 ) 𝑇 ( 𝑋 𝑤 − 𝑌 ) (1.5) J(𝑤)=\frac{1}{2}(𝑋𝑤−𝑌)^2=\frac{1}{2}(𝑋𝑤−𝑌)^𝑇(𝑋𝑤−𝑌)\tag{1.5} J ( w ) = 2 1 ( Xw − Y ) 2 = 2 1 ( Xw − Y ) T ( Xw − Y ) ( 1.5 )
其中,𝑋 𝑋 X 为 𝑚 𝑚 m 行 𝑛 + 1 𝑛+1 n + 1 列的矩阵(第一列全为 1 1 1 ,即式 (1.2) 中的 x 0 x_0 x 0 ),𝑤 𝑤 w 为 𝑛 + 1 𝑛+1 n + 1 行 1 1 1 列的矩阵(包含了 𝑤 0 𝑤_0 w 0 ),𝑌 𝑌 Y 为 𝑚 𝑚 m 行 1 1 1 列的矩阵。
X = [ 1 x 1 ( 1 ) x 2 ( 1 ) x 3 ( 1 ) … x n ( 1 ) 1 x 1 ( 2 ) x 2 ( 2 ) x 3 ( 2 ) … x n ( 2 ) ⋮ ⋮ ⋮ ⋮ ⋮ ⋮ 1 x 1 ( m ) x 2 ( m ) x 3 ( m ) … x n ( m ) ] , w = [ w 0 w 2 ⋮ w n ] , Y = [ y ( 1 ) y ( 2 ) ⋮ y ( m ) ] X=\left[\begin{array}{cccccc}
1 & x_{1}^{(1)} & x_{2}^{(1)} & x_{3}^{(1)} & \ldots & x_{n}^{(1)} \\
1 & x_{1}^{(2)} & x_{2}^{(2)} & x_{3}^{(2)} & \ldots & x_{n}^{(2)} \\
\vdots & \vdots & \vdots & \vdots & \vdots & \vdots \\
1 & x_{1}^{(m)} & x_{2}^{(m)} & x_{3}^{(m)} & \ldots & x_{n}^{(m)}
\end{array}\right],\quad w=\left[\begin{array}{c}w_0\\w_2\\\vdots \\w_n
\end{array}\right],\quad Y=\left[\begin{array}{c}y^{(1)} \\y^{(2)} \\\vdots \\y^{(m)}\end{array}\right] X = ⎣ ⎡ 1 1 ⋮ 1 x 1 ( 1 ) x 1 ( 2 ) ⋮ x 1 ( m ) x 2 ( 1 ) x 2 ( 2 ) ⋮ x 2 ( m ) x 3 ( 1 ) x 3 ( 2 ) ⋮ x 3 ( m ) … … ⋮ … x n ( 1 ) x n ( 2 ) ⋮ x n ( m ) ⎦ ⎤ , w = ⎣ ⎡ w 0 w 2 ⋮ w n ⎦ ⎤ , Y = ⎣ ⎡ y ( 1 ) y ( 2 ) ⋮ y ( m ) ⎦ ⎤
对式 (1.5) 求导,可得:
∂ 𝐽 ( 𝑤 ) ∂ 𝑤 = 1 2 ∂ ∂ 𝑤 ( w T X T X w − Y T X w − w T X T Y + Y T Y ) (1.6) \frac{\partial {𝐽(𝑤)}}{\partial 𝑤}=\frac{1}{2}\frac{\partial}{\partial 𝑤}(w^TX^TXw-Y^TXw-w^TX^TY+Y^TY)\tag{1.6} ∂ w ∂ J ( w ) = 2 1 ∂ w ∂ ( w T X T Xw − Y T Xw − w T X T Y + Y T Y ) ( 1.6 )
又 Y T X w = ( w T X T Y ) T Y^TXw=(w^TX^TY)^T Y T Xw = ( w T X T Y ) T ,𝑑 𝑋 𝑇 𝑋 𝑑 𝑋 = 2 𝑋 \frac{𝑑𝑋^𝑇𝑋}{𝑑𝑋}=2𝑋 d X d X T X = 2 X ,所以
∂ 𝐽 ( 𝑤 ) ∂ 𝑤 = 1 2 ∂ ∂ 𝑤 ( w T X T X w − 2 w T X T Y + Y T Y ) = 1 2 ( 2 X T X w − 2 X T Y + 0 ) = X T X w − X T Y (1.7) \begin{aligned}
\frac{\partial {𝐽(𝑤)}}{\partial 𝑤}
&=\frac{1}{2}\frac{\partial}{\partial 𝑤}(w^TX^TXw-2w^TX^TY+Y^TY)\\
&=\frac{1}{2}(2X^TXw-2X^TY+0)\\
&=X^TXw-X^TY
\end{aligned}\tag{1.7} ∂ w ∂ J ( w ) = 2 1 ∂ w ∂ ( w T X T Xw − 2 w T X T Y + Y T Y ) = 2 1 ( 2 X T Xw − 2 X T Y + 0 ) = X T Xw − X T Y ( 1.7 )
令∂ 𝐽 ( 𝑤 ) ∂ 𝑤 = 0 \frac{\partial {𝐽(𝑤)}}{\partial 𝑤}=0 ∂ w ∂ J ( w ) = 0 ,则:
𝑤 = ( 𝑋 𝑇 𝑋 ) − 1 𝑋 𝑇 𝑌 (1.8) 𝑤=(𝑋^𝑇𝑋)^{−1}𝑋^𝑇𝑌\tag{1.8} w = ( X T X ) − 1 X T Y ( 1.8 )
由上式可知,最小二乘法需要计算( 𝑋 𝑇 𝑋 ) − 1 (𝑋^𝑇𝑋)^{−1} ( X T X ) − 1 ,但是矩阵求逆的时间复杂度为 𝑂 ( 𝑛 3 ) 𝑂(𝑛3) O ( n 3 ) ,因此当特征数量 𝑛 𝑛 n 较大时,其运算代价非常大。所以这种方法只适用于特征数量较少的线性模型,不适用于其他模型。
现代机器学习中常用的参数更新方法是梯度下降法。
1.3 梯度下降法
根据梯度下降的每一步中用到的样本数量,可以将梯度下降法分为以下三类:
类别 样本数量 公式 批量梯度下降(Batch Gradient Descent,BGD) 所有 w j : = w j − α 1 m ∑ i = 1 m ( ( h ( x ( i ) ) − y ( i ) ) ⋅ x j ( i ) ) w_{j}:=w_{j}-\alpha \frac{1}{m} \sum_{i=1}^{m}\left(\left(h\left(x^{(i)}\right)-y^{(i)}\right) \cdot x_{j}^{(i)}\right) w j := w j − α m 1 ∑ i = 1 m ( ( h ( x ( i ) ) − y ( i ) ) ⋅ x j ( i ) ) 随机梯度下降(Stochastic Gradient Descent,SGD) 一个 w j : = w j − α ( h ( x ( i ) ) − y ( i ) ) ⋅ x j ( i ) w_{j}:=w_{j}-\alpha\left(h\left(x^{(i)}\right)-y^{(i)}\right) \cdot x_{j}^{(i)} w j := w j − α ( h ( x ( i ) ) − y ( i ) ) ⋅ x j ( i ) 小批量梯度下降(Mini-Batch Gradient Descent,MBGD) 部分 w j : = w j − α 1 b ∑ k = i i + b − 1 ( h ( x ( k ) ) − y ( k ) ) x j ( k ) w_{j}:=w_{j}-\alpha \frac{1}{b} \sum_{k=i}^{i+b-1}\left(h\left(x^{(k)}\right)-y^{(k)}\right) x_{j}^{(k)} w j := w j − α b 1 ∑ k = i i + b − 1 ( h ( x ( k ) ) − y ( k ) ) x j ( k )
其中,α \alpha α 称为学习率。根据公式,不难看出,BGD 和 SGD 其实是 MBGD 的 b b b 取值为 m m m 和 1 1 1 时的特殊情况。我们以 SGD 为例,推导一遍参数的更新过程。
∂ ∂ w j J ( w ) = ∂ ∂ w j 1 2 ( h ( x ( i ) ) − y ( i ) ) 2 = 2 ⋅ 1 2 ( h ( x ( i ) ) − y ( i ) ) ⋅ ∂ ∂ w j ( h ( x ( i ) ) − y ( i ) ) = ( h ( x ( i ) ) − y ( i ) ) ⋅ ∂ ∂ w j ( ∑ i = 0 n ( w i x i ( i ) − y ( i ) ) ) = ( h ( x ( i ) ) − y ( i ) ) x j ( i ) (1.9) \begin{aligned}
\frac{\partial}{\partial w_{j}} J(w) &=\frac{\partial}{\partial w_{j}} \frac{1}{2}\left(h\left(x^{(i)}\right)-y^{(i)}\right)^{2}\\
&=2 \cdot \frac{1}{2}\left(h\left(x^{(i)}\right)-y^{(i)}\right) \cdot \frac{\partial}{\partial w_{j}}\left(h\left(x^{(i)}\right)-y^{(i)}\right) \\
&=\left(h\left(x^{(i)}\right)-y^{(i)}\right) \cdot \frac{\partial}{\partial w_{j}}\left(\sum_{i=0}^{n}\left(w_{i} x_{i}^{(i)}-y^{(i)}\right)\right) \\
&=\left(h\left(x^{(i)}\right)-y^{(i)}\right) x_{j}^{(i)}
\end{aligned}\tag{1.9} ∂ w j ∂ J ( w ) = ∂ w j ∂ 2 1 ( h ( x ( i ) ) − y ( i ) ) 2 = 2 ⋅ 2 1 ( h ( x ( i ) ) − y ( i ) ) ⋅ ∂ w j ∂ ( h ( x ( i ) ) − y ( i ) ) = ( h ( x ( i ) ) − y ( i ) ) ⋅ ∂ w j ∂ ( i = 0 ∑ n ( w i x i ( i ) − y ( i ) ) ) = ( h ( x ( i ) ) − y ( i ) ) x j ( i ) ( 1.9 )
又 w j = w j − α ∂ ∂ w j J ( w ) w_j=w_j-\alpha\frac{\partial}{\partial w_{j}} J(w) w j = w j − α ∂ w j ∂ J ( w ) ,所以
w j : = w j − α ( h ( x ( i ) ) − y ( i ) ) ⋅ x j ( i ) (1.10) w_{j}:=w_{j}-\alpha\left(h\left(x^{(i)}\right)-y^{(i)}\right) \cdot x_{j}^{(i)}\tag{1.10} w j := w j − α ( h ( x ( i ) ) − y ( i ) ) ⋅ x j ( i ) ( 1.10 )
1.4 回归的评价指标
监督学习主要分回归和分类两种,二者的评价指标是截然不同的。我们先在此介绍回归的评价指标。
首先是误差要越小越好,主要是下面几种:
指标 公式 均方误差(Mean Square Error,MSE) M S E = 1 m ∑ i = 1 m ( y ( i ) − y ^ ( i ) ) 2 MSE=\frac{1}{m} \sum_{i=1}^{m}\left(y^{(i)}-\widehat{y}^{(i)}\right)^{2} MSE = m 1 ∑ i = 1 m ( y ( i ) − y ( i ) ) 2 均方根误差(Root Mean Square Error,RMSE) R M S E ( y , y ^ ) = 1 m ∑ i = 1 m ( y ( i ) − y ^ ( i ) ) 2 RMSE(y, \widehat{y})=\sqrt{\frac{1}{m} \sum_{i=1}^{m}\left(y^{(i)}-\widehat{y}^{(i)}\right)^{2}} RMSE ( y , y ) = m 1 ∑ i = 1 m ( y ( i ) − y ( i ) ) 2 平均绝对误差(Mean Absolute Error,MAE) M A E ( y , y ^ ) = 1 m ∑ i = 1 n ∥ y ( i ) − y ^ ( i ) ∥ MAE(y, \widehat{y})=\frac{1}{m} \sum_{i=1}^{n}\|y^{(i)}-\widehat{y}^{(i)}\| M A E ( y , y ) = m 1 ∑ i = 1 n ∥ y ( i ) − y ( i ) ∥
其次是 R 2 R^2 R 2 要越大越好,它越接近于 1,说明模型拟合得越好。计算公式如下:
R 2 ( y , y ^ ) = 1 − ∑ i = 0 m ( y ( i ) − y ^ ( i ) ) 2 ∑ i = 0 m ( y ( i ) − y ˉ ) 2 = 1 − S S E S S T = S S R S S T (1.11) R^{2}(y, \widehat{y})=1-\frac{\sum_{i=0}^{m}\left(y^{(i)}-\widehat{y}^{(i)}\right)^{2}}{\sum_{i=0}^{m}\left(y^{(i)}-\bar{y}\right)^{2}}=1-\frac{\mathrm{SSE}}{\mathrm{SST}}=\frac{\mathrm{SSR}}{\mathrm{SST}}\tag{1.11} R 2 ( y , y ) = 1 − ∑ i = 0 m ( y ( i ) − y ˉ ) 2 ∑ i = 0 m ( y ( i ) − y ( i ) ) 2 = 1 − SST SSE = SST SSR ( 1.11 )
其中,S S R = ∑ i = 0 m ( y ^ ( i ) − y ˉ ) 2 SSR=\sum_{i=0}^{m}\left(\widehat{y}^{(i)}-\bar{y}\right)^{2} SSR = ∑ i = 0 m ( y ( i ) − y ˉ ) 2 ,S S E = ∑ i = 0 m ( y ( i ) − y ^ ( i ) ) 2 SSE=\sum_{i=0}^{m}\left(y^{(i)}-\widehat{y}^{(i)}\right)^{2} SSE = ∑ i = 0 m ( y ( i ) − y ( i ) ) 2 ,S S T = ∑ i = 0 m ( y ( i ) − y ˉ ) 2 SST=\sum_{i=0}^{m}\left(y^{(i)}-\bar{y}\right)^{2} SST = ∑ i = 0 m ( y ( i ) − y ˉ ) 2 。
SST 是 Sum of Squares Total 的缩写,含义是总平方和。它是变量 y y y 与其平均值 y ˉ \bar{y} y ˉ 之差的平方和。我们可以将其视为对于变量 y y y 在其平均值 y ˉ \bar{y} y ˉ 周围的分散程度 的一种度量,很像描述性统计中的方差。
SSR 是 Sum of Squares Regression 的缩写,含义是回归的平方和。它是预测值 y ^ \widehat{y} y 与平均值 y ˉ \bar{y} y ˉ 之差的平方和。我们可以将其视为描述回归线与数据的拟合程度 的一种度量。
SSE 是 Sum of Squares Error 的缩写,含义是误差的平方和。它是预测值 y ^ \widehat{y} y 与观测值 y y y 之差的平方和。
从图中不难看出,三者的关系是:SST = SSR + SSE 。如果 SSR 的值等于 SST,这意味着我们的回归模型是完美的。
2.逻辑回归
我们前面说过,逻辑回归和线性回归不同的地方在于:线性回归适用于解决回归问题,而逻辑回归适用于解决分类问题。本节我们就讲讲造成这种差异的原因。
2.1 Sigmoid函数
我们知道逻辑回归的目标是训练一个分类器,该分类器可以对输入数据的类别做出决策。以二元逻辑回归为例,对于一个输入 x ( x 1 , x 2 , . . . , x n ) x(x_1,x_2,...,x_n) x ( x 1 , x 2 , ... , x n ) ,我们希望分类器能够输出 y y y 是 1(是某类的成员)或 0(不是某类的成员)。也就是说,我们想知道这个输入 x x x 是该类成员的概率 P ( y = 1 ∣ x ) P(y = 1|x) P ( y = 1∣ x ) 。
我们知道逻辑回归的底层就是线性回归,但是线性回归解决的是回归问题,那我们如何将一个回归问题转化为一个分类问题呢?为了方便讨论,我们再对式 (1.2) 做一点形式变换,即令
z = h ( 𝑥 ) = 𝑤 0 + 𝑤 1 𝑥 1 + 𝑤 2 𝑥 2 + . . . + 𝑤 𝑛 𝑥 𝑛 = w T X (2.1) z=ℎ(𝑥)=𝑤_0 +𝑤_1𝑥_1 +𝑤_2𝑥_2 +...+𝑤_𝑛𝑥_𝑛=w^TX\tag{2.1} z = h ( x ) = w 0 + w 1 x 1 + w 2 x 2 + ... + w n x n = w T X ( 2.1 )
有些地方写的是 z = 𝑤 𝑇 𝑥 + 𝑏 z=𝑤^𝑇𝑥+𝑏 z = w T x + b ,其实是一样的,因为 b b b 可以融入到 w 0 w_0 w 0 中。
我们观察式 (2.1),不难发现,z z z 的输出范围没有任何限制,即 ( − ∞ , + ∞ ) (-∞, +∞) ( − ∞ , + ∞ ) 。而作为一个分类器,我们需要输出的是位于 0 和 1 之间的合法概率值。而为了完成这一步转变,我们就需要 Sigmoid函数 σ ( z ) σ(z) σ ( z ) 。Sigmoid 函数(命名是因为它的图像呈𝑆形)也称为逻辑函数 ,逻辑回归的名称也由此而来。
Sigmoid 有许多优点,它能将任意实数映射到 [ 0 , 1 ] [0,1] [ 0 , 1 ] 范围内,而且任意阶可导 。它在 0 附近几乎是线性的,但在两端趋于平缓,它能将异常值压向 0 或 1。
σ ( z ) = 1 1 + e − z = 1 1 + exp ( − z ) (2.2) \sigma(z)=\frac{1}{1+e^{-z}}=\frac{1}{1+\exp (-z)}\tag{2.2} σ ( z ) = 1 + e − z 1 = 1 + exp ( − z ) 1 ( 2.2 )
我们将式 (2.1) 的值代入上式,就能得到一个介于 0 和 1 之间的概率。对于一个二元逻辑回归,我们只需要确保 P ( y = 1 ) + P ( y = 0 ) = 1 P(y = 1)+P(y = 0)=1 P ( y = 1 ) + P ( y = 0 ) = 1 即可。我们可以这样做:
P ( y = 1 ) = σ ( z ) = 1 1 + exp ( − z ) P ( y = 0 ) = 1 − σ ( z ) = 1 − 1 1 + exp ( − z ) = exp ( − z ) 1 + exp ( − z ) (2.3) \begin{aligned}
P(y=1) &=\sigma(z)=\frac{1}{1+\exp (-z)} \\
P(y=0) &=1-\sigma(z)=1-\frac{1}{1+\exp (-z)}=\frac{\exp (-z)}{1+\exp (-z)}
\end{aligned}\tag{2.3} P ( y = 1 ) P ( y = 0 ) = σ ( z ) = 1 + exp ( − z ) 1 = 1 − σ ( z ) = 1 − 1 + exp ( − z ) 1 = 1 + exp ( − z ) exp ( − z ) ( 2.3 )
根据 Sigmoid 函数的性质:
1 − σ ( x ) = σ ( − x ) (2.4) 1−σ(x)=σ(−x)\tag{2.4} 1 − σ ( x ) = σ ( − x ) ( 2.4 )
我们也可以将 P ( y = 0 ) P(y = 0) P ( y = 0 ) 表示为 σ ( − z ) σ(−z) σ ( − z ) 。
好了,现在我们已经有了概率值,那么概率值大于多少我们认为它是属于 1 类呢?通常,如果概率 P ( y = 1 ∣ x ) P(y = 1|x) P ( y = 1∣ x ) 大于 0.5 0.5 0.5 ,我们认为是,否则就不是。这个 0.5 被称为决策边界 。
decision ( x ) = { 1 if P ( y = 1 ∣ x ) > 0.5 0 otherwise (2.5) \operatorname{decision}(x)= \begin{cases}1 & \text { if } P(y=1 \mid x)>0.5 \\ 0 & \text { otherwise }\end{cases}\tag{2.5} decision ( x ) = { 1 0 if P ( y = 1 ∣ x ) > 0.5 otherwise ( 2.5 )
总结 :逻辑回归的总体思路就是,先用逻辑函数把线性回归的结果 (-∞,∞) 映射到 (0,1),再通过决策边界建立与分类的概率联系。
逻辑函数还有一个很好的特性就是,其导函数可以转化成本身的一个表达式,推导过程如下:
σ ′ ( z ) = ( 1 1 + e − z ) ′ = e − z ( 1 + e − z ) 2 = 1 + e − z − 1 ( 1 + e − z ) 2 = 1 ( 1 + e − z ) ( 1 − 1 ( 1 + e − z ) ) = σ ( z ) ( 1 − σ ( z ) ) (2.6) \begin{aligned}
\sigma^{\prime}(z)&=\left(\frac{1}{1+e^{-z}}\right)^{\prime} \\
&=\frac{e^{-z}}{\left(1+e^{-z}\right)^{2}} \\
&=\frac{1+e^{-z}-1}{\left(1+e^{-z}\right)^{2}} \\
&=\frac{1}{\left(1+e^{-z}\right)}\left(1-\frac{1}{\left(1+e^{-z}\right)}\right) \\
&=\sigma(z)(1-\sigma(z))
\end{aligned}\tag{2.6} σ ′ ( z ) = ( 1 + e − z 1 ) ′ = ( 1 + e − z ) 2 e − z = ( 1 + e − z ) 2 1 + e − z − 1 = ( 1 + e − z ) 1 ( 1 − ( 1 + e − z ) 1 ) = σ ( z ) ( 1 − σ ( z )) ( 2.6 )
在二分类模型中,事件发生与不发生的概率之比 𝑝 1 − 𝑝 \frac{𝑝}{1−𝑝} 1 − p p 称为事件的几率(odds) 。令σ ( z ) = p \sigma(z)=p σ ( z ) = p ,解得:
z = l o g ( p 1 − p ) (2.7) z=log(\frac{p}{1-p})\tag{2.7} z = l o g ( 1 − p p ) ( 2.7 )
也就是说,线性回归的结果(即 z z z )等于对数几率 。
2.2 代价函数
下面我们讲讲模型的参数如何更新。我们使用极大似然估计法来求解。极大似然估计法利用已知样本结果,反推最有可能导致这样结果的原因。我们的目标就是找到一组参数,使得在这组参数下,我们的样本的似然度(概率)最大。
对于一个二分类模型,已知 P ( y = 1 ) = σ ( z ) , P ( y = 0 ) = 1 − σ ( z ) P(y=1)=\sigma(z),P(y=0)=1-\sigma(z) P ( y = 1 ) = σ ( z ) , P ( y = 0 ) = 1 − σ ( z ) , 则似然函数为:
L ( w ) = ∏ i = 1 m P ( y ( i ) ∣ x ( i ) ; w ) = ∏ i = 1 m ( σ ( x ( i ) ) ) y ( i ) ( 1 − σ ( x ( i ) ) ) 1 − y ( i ) (2.8) L(w)=\prod_{i=1}^{m} P\left(y^{(i)} \mid x^{(i)} ; w\right)=\prod_{i=1}^{m}\left(\sigma\left(x^{(i)}\right)\right)^{y^{(i)}}\left(1-\sigma\left(x^{(i)}\right)\right)^{1-y^{(i)}}\tag{2.8} L ( w ) = i = 1 ∏ m P ( y ( i ) ∣ x ( i ) ; w ) = i = 1 ∏ m ( σ ( x ( i ) ) ) y ( i ) ( 1 − σ ( x ( i ) ) ) 1 − y ( i ) ( 2.8 )
等式两边同时取对数:
l ( w ) = log L ( w ) = ∑ i = 1 m ( y ( i ) log ( σ ( x ( i ) ) ) + ( 1 − y ( i ) ) log ( 1 − σ ( x ( i ) ) ) ) (2.9) l(w)=\log L(w)=\sum_{i=1}^{m}\left(y^{(i)} \log \left(\sigma\left(x^{(i)}\right)\right)+\left(1-y^{(i)}\right) \log \left(1-\sigma\left(x^{(i)}\right)\right)\right)\tag{2.9} l ( w ) = log L ( w ) = i = 1 ∑ m ( y ( i ) log ( σ ( x ( i ) ) ) + ( 1 − y ( i ) ) log ( 1 − σ ( x ( i ) ) ) ) ( 2.9 )
则代价函数为:
J ( w ) = − 1 m l ( w ) (2.10) J(w)=-\frac{1}{m} l(w)\tag{2.10} J ( w ) = − m 1 l ( w ) ( 2.10 )
其实,式(2.9)前面再加一个负号,就是我们常用的损失函数——交叉熵损失(cross-entropy loss) 。
代价函数之所以要加负号,是因为机器学习的目标是最小化损失函数 ,而极大似然估计法的目标是最大化似然函数 。那么加个负号,正好使二者等价。
2.3 梯度下降法求解
求解逻辑回归的方法有非常多,我们这里主要了解一下梯度下降法。
将式 (2.2) 代入式 (2.10),得:
∵ y ( i ) log ( σ ( x ( i ) ) ) + ( 1 − y ( i ) ) log ( 1 − σ ( x ( i ) ) ) = y ( i ) log ( 1 1 + e − w T x ( i ) ) + ( 1 − y ( i ) ) log ( 1 − 1 1 + e − w T x ( i ) ) = − y ( i ) log ( 1 + e − w T x ( i ) ) − ( 1 − y ( i ) ) log ( 1 + e w T x ( i ) ) ∴ J ( w ) = − 1 m ∑ i = 1 m ( − y ( i ) log ( 1 + e − w T x ( i ) ) − ( 1 − y ( i ) ) log ( 1 + e w T x ( i ) ) ) (2.11) \begin{aligned}
\because & y^{(i)} \log \left(\sigma\left(x^{(i)}\right)\right)+\left(1-y^{(i)}\right) \log \left(1-\sigma\left(x^{(i)}\right)\right)\\
&=y^{(i)} \log \left(\frac{1}{1+e^{-w^{T} x^{(i)}}}\right)+\left(1-y^{(i)}\right) \log \left(1-\frac{1}{1+e^{-w^{T} x^{(i)}}}\right)\\
&=-y^{(i)} \log \left(1+e^{-w^{T} x^{(i)}}\right)-\left(1-y^{(i)}\right) \log \left(1+e^{w^{T} x^{(i)}}\right)\\\therefore
J(w)&=-\frac{1}{m}\sum_{i=1}^{m}\left(-y^{(i)} \log \left(1+e^{-w^{T} x^{(i)}}\right)-\left(1-y^{(i)}\right) \log \left(1+e^{w^{T} x^{(i)}}\right)\right)
\end{aligned}\tag{2.11} ∵ ∴ J ( w ) y ( i ) log ( σ ( x ( i ) ) ) + ( 1 − y ( i ) ) log ( 1 − σ ( x ( i ) ) ) = y ( i ) log ( 1 + e − w T x ( i ) 1 ) + ( 1 − y ( i ) ) log ( 1 − 1 + e − w T x ( i ) 1 ) = − y ( i ) log ( 1 + e − w T x ( i ) ) − ( 1 − y ( i ) ) log ( 1 + e w T x ( i ) ) = − m 1 i = 1 ∑ m ( − y ( i ) log ( 1 + e − w T x ( i ) ) − ( 1 − y ( i ) ) log ( 1 + e w T x ( i ) ) ) ( 2.11 )
对 J ( w ) J(w) J ( w ) 求偏导,得:
∂ ∂ w j J ( w ) = ∂ ∂ w j ( − 1 m ∑ i = 1 m ( − y ( i ) log ( 1 + e − w T x ( i ) ) − ( 1 − y ( i ) ) log ( 1 + e w T x ( i ) ) ) ) = − 1 m ∑ i = 1 m ( − y ( i ) − x j ( i ) e − w T x ( i ) 1 + e − w T x ( i ) − ( 1 − y ( i ) ) x j ( i ) e w T x ( i ) 1 + e w T x ( i ) ) = − 1 m ∑ i = 1 m ( y ( i ) − σ ( x ( i ) ) ) x j ( i ) = 1 m ∑ i = 1 m ( σ ( x ( i ) ) − y ( i ) ) x j ( i ) (2.12) \begin{aligned}
\frac{\partial}{\partial w_{j}} J(w)&=\frac{\partial}{\partial w_{j}}\left(-\frac{1}{m} \sum_{i=1}^{m}\left(-y^{(i)} \log \left(1+e^{-w^{T} x^{(i)}}\right)-\left(1-y^{(i)}\right) \log \left(1+e^{w^{T} x^{(i)}}\right)\right)\right) \\
&=-\frac{1}{m} \sum_{i=1}^{m}\left(-y^{(i)} \frac{-x_{j}^{(i)} e^{-w^{T} x^{(i)}}}{1+e^{-w^{T} x^{(i)}}}-\left(1-y^{(i)}\right) \frac{x_{j}^{(i)} e^{w^{T} x^{(i)}}}{1+e^{w^{T} x^{(i)}}}\right) \\
&=-\frac{1}{m} \sum_{i=1}^{m}\left(y^{(i)}-\sigma\left(x^{(i)}\right)\right) x_{j}^{(i)} \\
&=\frac{1}{m} \sum_{i=1}^{m}\left(\sigma\left(x^{(i)}\right)-y^{(i)}\right) x_{j}^{(i)}
\end{aligned}\tag{2.12} ∂ w j ∂ J ( w ) = ∂ w j ∂ ( − m 1 i = 1 ∑ m ( − y ( i ) log ( 1 + e − w T x ( i ) ) − ( 1 − y ( i ) ) log ( 1 + e w T x ( i ) ) ) ) = − m 1 i = 1 ∑ m ( − y ( i ) 1 + e − w T x ( i ) − x j ( i ) e − w T x ( i ) − ( 1 − y ( i ) ) 1 + e w T x ( i ) x j ( i ) e w T x ( i ) ) = − m 1 i = 1 ∑ m ( y ( i ) − σ ( x ( i ) ) ) x j ( i ) = m 1 i = 1 ∑ m ( σ ( x ( i ) ) − y ( i ) ) x j ( i ) ( 2.12 )
所以:
w j : = w j − ∂ ∂ w j J ( w ) = w j − α 1 m ∑ i = 1 m ( σ ( x ( i ) ) − y ( i ) ) x j ( i ) (2.13) w_{j}:=w_{j}-\frac{\partial}{\partial w_{j}} J(w)=w_{j}-\alpha \frac{1}{m} \sum_{i=1}^{m}\left(\sigma\left(x^{(i)}\right)-y^{(i)}\right) x_{j}^{(i)}\tag{2.13} w j := w j − ∂ w j ∂ J ( w ) = w j − α m 1 i = 1 ∑ m ( σ ( x ( i ) ) − y ( i ) ) x j ( i ) ( 2.13 )
2.4 逻辑回归的分类
逻辑回归对特征变量(x)和分类响应变量(y)之间的关系进行建模,在给定一组预测变量的情况下,它能给出落入特定类别响应水平的概率。也就是说,你给它一组数据(特征),它告诉你这组数据属于某一类别的概率。根据分类响应变量(y)的性质,我们可以将逻辑回归分为三类:
二元逻辑回归(Binary Logistic Regression)
当分类结果只有两种可能的时候,我们就称为二元逻辑回归。例如,考试通过或未通过,回答是或否,血压高或低。
名义逻辑回归(Nominal Logistic Regression)
当存在三个或更多类别且类别之间没有自然排序时,我们就称为名义逻辑回归。例如,企业的部门有策划、销售、人力资源等,颜色有黑色、红色、蓝色、橙色等。
序数逻辑回归(Ordinal Logistic Regression)
当存在三个或更多类别且类别之间有自然排序时,我们就称为序数逻辑回归。例如,评价有好、中、差,身材有偏胖、中等、偏瘦。注意,类别的排名不一定意味着它们之间的间隔相等。
2.5 Softmax Regression
我们以上讨论都是以二元分类为前提展开的,但有时可能有两个以上的类,例如情绪分类有正面、负面或中性三种,手写数字识别有 0-9 总共十种分类。
在这种情况下,我们需要多元逻辑回归,也称为 Softmax Regression 。在多元逻辑回归中,我们假设总共有 K K K 个类,每个输入 x x x 只能属于一个类。也就是说,每个输入 x x x 的输出 y y y 将是一个长度为 K K K 的向量。如果类 c c c 是正确的类,则设置y c = 1 \mathbf{y}_c=1 y c = 1 ,其他元素设置为 0,即y c = 1 , y j = 0 ∀ j ≠ c \mathbf{y}_{c}=1,\mathbf{y}_{j}=0\quad\forall j \neq c y c = 1 , y j = 0 ∀ j = c 。这种编码方式称为 one-hot 编码 。此时,分类器的工作是产生一个估计向量。对于每个类 k k k ,产生一个概率估计 P ( y k = 1 ∣ x ) P(y_k = 1|x) P ( y k = 1∣ x ) 。
多元逻辑分类器采用 sigmoid 的泛化函数 softmax 来计算 P ( y k = 1 ∣ x ) P(y_k = 1|x) P ( y k = 1∣ x ) 。它能将 K K K 个任意值的向量 z = [ z 1 , z 2 , … , z K ] z = [z_1,z_2,\dots,z_K] z = [ z 1 , z 2 , … , z K ] 映射到 (0,1) 范围内的概率分布上,并且所有值的总和为 1 。其定义如下:
softmax ( z i ) = exp ( z i ) ∑ j = 1 K exp ( z j ) 1 ≤ i ≤ K (2.14) \operatorname{softmax}\left(\mathbf{z}_{i}\right)=\frac{\exp \left(\mathbf{z}_{i}\right)}{\sum_{j=1}^{K} \exp \left(\mathbf{z}_{j}\right)} 1 \leq i \leq K\tag{2.14} softmax ( z i ) = ∑ j = 1 K exp ( z j ) exp ( z i ) 1 ≤ i ≤ K ( 2.14 )
因此,输入向量 z = [ z 1 , z 2 , … , z K ] z = [z_1,z_2,\dots,z_K] z = [ z 1 , z 2 , … , z K ] 的 softmax输出如下:
softmax ( z ) = [ exp ( z 1 ) ∑ i = 1 K exp ( z i ) , exp ( z 2 ) ∑ i = 1 K exp ( z i ) , … , exp ( z K ) ∑ i = 1 K exp ( z i ) ] (2.15) \operatorname{softmax}(\mathbf{z})=\left[\frac{\exp \left(\mathbf{z}_{1}\right)}{\sum_{i=1}^{K} \exp \left(\mathbf{z}_{i}\right)}, \frac{\exp \left(\mathbf{z}_{2}\right)}{\sum_{i=1}^{K} \exp \left(\mathbf{z}_{i}\right)}, \ldots, \frac{\exp \left(\mathbf{z}_{K}\right)}{\sum_{i=1}^{K} \exp \left(\mathbf{z}_{i}\right)}\right]\tag{2.15} softmax ( z ) = [ ∑ i = 1 K exp ( z i ) exp ( z 1 ) , ∑ i = 1 K exp ( z i ) exp ( z 2 ) , … , ∑ i = 1 K exp ( z i ) exp ( z K ) ] ( 2.15 )
举个例子,若 z = [ 0.6 , 1.1 , − 1.5 , 1.2 , 3.2 , − 1.1 ] \mathbf{z}=[0.6,1.1,-1.5,1.2,3.2,-1.1] z = [ 0.6 , 1.1 , − 1.5 , 1.2 , 3.2 , − 1.1 ] ,则
softmax ( z ) = [ 0.055 , 0.090 , 0.006 , 0.099 , 0.74 , 0.010 ] \operatorname{softmax}(\mathbf{z})=[0.055,0.090,0.006,0.099,0.74,0.010] softmax ( z ) = [ 0.055 , 0.090 , 0.006 , 0.099 , 0.74 , 0.010 ]
与 sigmoid 一样,softmax 也具有将异常值压向 0 或 1 的特性。因此,如果其中一个输入远大于其他输入,它将倾向于将其概率推向 1,并抑制较小输入的概率。
由于现在有 K K K 个类别,而且每一个类别都有一个单独的权重向量 w k w_k w k ,则每个输出类别的概率估计 y k ^ \widehat{y_k} y k 应该这样计算:
P ( y k = 1 ∣ x ) = exp ( w k T ⋅ x ) ∑ j = 1 K exp ( w j T ⋅ x ) (2.16) P\left(\mathbf{y}_{k}=1 \mid \mathbf{x}\right)=\frac{\exp \left(\mathbf{w}_{k}^T \cdot \mathbf{x}\right)}{\sum_{j=1}^{K} \exp \left(\mathbf{w}_{j}^T \cdot \mathbf{x}\right)}\tag{2.16} P ( y k = 1 ∣ x ) = ∑ j = 1 K exp ( w j T ⋅ x ) exp ( w k T ⋅ x ) ( 2.16 )
上式看起来我们将分别每个类别计算输出。但是,我们可以将 K K K 个权重向量表示为权重矩阵 W W W 。W W W 的第 k k k 列对应于权重向量 w k w_k w k 。因此,W W W 的形状为 [ ( n + 1 ) × K ] [(n+1) \times K] [( n + 1 ) × K ] ,其中,K K K 是输出类的数量,n n n 是输入特征的数量,加 1 1 1 对应的就是偏置。这样一来,我们还是可以通过一个优雅的公式计算 y ^ \widehat{y} y :
y ^ = softmax ( W T X ) (2.17) \widehat{y}=\operatorname{softmax}{(W^TX)}\tag{2.17} y = softmax ( W T X ) ( 2.17 )
3. 代码实现(Pytorch)
class LogisticRegression (torch.nn.Module ):
def __init__ (self , num_features ):
super (LogisticRegression , self ).__init__()
self .linear = torch.nn.Linear (num_features, 1 )
self .linear.weight.detach().zero_()
self .linear.bias.detach().zero_()
def forward (self , x ):
logits = self .linear(x)
probas = torch.sigmoid(logits)
return probas
在 Pytorch 中可以通过继承torch.nn.Module
类来实现自定义模型,在__init__
中定义每一层的构造,在forward
中定义每一层的连接关系,是实现模型功能的核心,且必须重写,否则模型将由于无法找到各层的连接关系而无法执行。
torch.nn.Linear
对传入的数据做线性变换,weight
和 bias
是它的两个变量,分别代表学习的权值和偏置。
4. 鸢尾花分类
我们以鸢尾花数据的分类为例,做一个简单地用 Logistic 回归进行分类的任务。
import matplotlib.pyplot as plt
import numpy as np
from io import BytesIO
import torch
import torch.nn.functional as F
ds = np.lib.DataSource()
fp = ds.open('http://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data' )
x = np.genfromtxt(BytesIO(fp.read().encode()), delimiter=',' , usecols=range(2 ), max_rows=100 )
y = np.zeros(100 )
y[50:] = 1
np.random.seed(1)
idx = np.arange(y.shape[0 ])
np.random.shuffle(idx)
X_test, y_test = x[idx[:25 ]], y[idx[:25 ]]
X_train, y_train = x[idx[25 :]], y[idx[25 :]]
mu, std = np.mean(X_train, axis=0 ), np.std(X_train, axis=0 )
X_train, X_test = (X_train - mu) / std, (X_test - mu) / std
fig, ax = plt.subplots(1 , 2 , figsize=(7 , 2.5 ))
ax[0] .scatter(X_train[y_train == 1, 0] , X_train[y_train == 1, 1] )
ax[0] .scatter(X_train[y_train == 0, 0] , X_train[y_train == 0, 1] )
ax[1] .scatter(X_test[y_test == 1, 0] , X_test[y_test == 1, 1] )
ax[1] .scatter(X_test[y_test == 0, 0] , X_test[y_test == 0, 1] )
plt.show()
实际的数据共有152行,我们只取前100行。按照下标随机打乱之后来划分训练集和测试集。其中,训练集有75行,测试集有25行。
model = LogisticRegression (num_features=2 ).to (device)
cost_fn = torch.nn .BCELoss (reduction='sum')
optimizer = torch.optim .SGD (model.parameters(), lr=0.1 )
def custom_where (cond, x_1, x_2):
return (cond * x_1) + ((1 -cond) * x_2)
def comp_accuracy (label_var, pred_probas):
pred_labels = custom_where ((pred_probas > 0.5 ).float (), 1 , 0 ).view (-1 )
acc = torch.sum (pred_labels == label_var.view (-1 )).float () / label_var.size (0 )
return acc
num_epochs = 10
X_train_tensor = torch.tensor (X_train, dtype=torch.float32, device=device)
y_train_tensor = torch.tensor (y_train, dtype=torch.float32, device=device).view (-1 , 1 )
for epoch in range (num_epochs):
#### Compute outputs ####
out = model (X_train_tensor)
#### Compute gradients ####
cost = cost_fn (out, y_train_tensor)
optimizer.zero_grad ()
cost.backward ()
#### Update weights ####
optimizer.step ()
#### Logging ####
pred_probas = model (X_train_tensor)
acc = comp_accuracy (y_train_tensor, pred_probas)
print ('Epoch: %03d' % (epoch + 1 ), end="" )
print (' | Train ACC: %.3f' % acc, end="" )
print (' | Cost: %.3f' % cost_fn (pred_probas, y_train_tensor))
print ('\nModel parameters:' )
print (' Weights: %s' % model.linear.weight)
print (' Bias: %s' % model.linear.bias)
BCELoss
计算目标值和预测值之间的二进制交叉熵损失函数,数学公式如下:
L o s s = − w [ y l o g ( y ′ ) + ( 1 − y ) l o g ( 1 − y ′ ) ] Loss = -w[ylog(y')+(1-y)log(1-y')] L oss = − w [ y l o g ( y ′ ) + ( 1 − y ) l o g ( 1 − y ′ )]
其中,w w w 、y y y 、y ′ y' y ′ 分别表示权值、标签(target)、预测概率值(input probabilities)。reduction
取值为sum
表明对样本的损失值进行求和。
输出如下:
Epoch: 001 | Train ACC: 0.987 | Cost: 5.581
Epoch: 002 | Train ACC: 0.987 | Cost: 4.882
Epoch: 003 | Train ACC: 1.000 | Cost: 4.381
Epoch: 004 | Train ACC: 1.000 | Cost: 3.998
Epoch: 005 | Train ACC: 1.000 | Cost: 3.693
Epoch: 006 | Train ACC: 1.000 | Cost: 3.443
Epoch: 007 | Train ACC: 1.000 | Cost: 3.232
Epoch: 008 | Train ACC: 1.000 | Cost: 3.052
Epoch: 009 | Train ACC: 1.000 | Cost: 2.896
Epoch: 010 | Train ACC: 1.000 | Cost: 2.758
Model parameters:
Weights: Parameter containing:
tensor([[ 4.2267 , -2.9613 ]], requires_grad=True)
Bias: Parameter containing:
tensor([0.0994], requires_grad=True)
X_test_tensor = torch.tensor(X_test, dtype=torch.float32, device=device)
y_test_tensor = torch.tensor(y_test, dtype=torch.float32, device=device)
pred_probas = model(X_test_tensor)
test_acc = comp_accuracy(y_test_tensor, pred_probas)
print('Test set accuracy: %.2f%%' % (test_acc*100))
输出如下:
Test set accuracy: 100.00%
结语
一个非常基础的入门级的机器学习算法,但是要完全讲透还是非常困难,尤其是公式的推导部分,光用文字描述很难讲清楚,但是总体上公式的推导都没问题,只是说第一眼看不是那么容易懂,多看几遍或者自己在纸上写一写还是不难理解的。另外,也请读者发现错误后能在评论区指出 ,我看到后会及时更正。
全文写下来洋洋洒洒六千字,也花费了好几天的时间,从自己理解到写出来让别人看懂,这之间差别真的很大,可能也是我不善于表达,词不达意,也请大家见谅。
篇幅这么长,公式这么多,看完本文你可能什么也记不住,但是这两点你一定要记住:
1. Logistic回归不适用于解决回归问题,它适用于解决分类问题 。千万不要被它的名称迷惑!
2. Logistic回归 = 线性回归 + Sigmoid 函数 。当然了,如果是多元回归的话就是 softmax 函数。
例行公事😂:如果你觉得本文确实对你有帮助,请点个赞支持我一下吧 🌹