【机器学习笔记】——逻辑回归 & 交叉熵

目 录

• 1 二分类逻辑回归模型
• 2 梯度下降
• 3 *多分类问题
• 4 模型的正则化
• 5 交叉熵
• 6 编程练习
  • 6.1 练习Ⅰ
  • 6.2 练习Ⅱ（正则化的逻辑回归）
  • 6.3 练习Ⅲ（使用scikit-learn）

1.逻辑回归模型

1.1 逻辑回归模型

  我们将因变量(dependant variable)可能属于的两个类分别称为负向类（negative class）和 正向类（positive class），因变量$Y \in \{0, \ +1\}$Y∈{0, +1}，其中0表示负向类，1表示正向类。 为了使模型的输出在0和1之间，需要引进一个新的模型，即逻辑回归模型。

  模型假设：
$h_\theta (x) = g(\theta^T x)$hθ​(x)=g(θTx)

  其中$x \in \mathbf{R}^n$x∈Rn是输入，$g(z) = \frac{1}{1 + e^{-z}}$g(z)=1+e−z1​ 是Sigmoid函数，逻辑函数的一种，函数图像如下：

  因此模型可以表示为
$h_\theta (x) = \frac{1}{1 + e^{-\theta^T x}}$hθ​(x)=1+e−θTx1​

  $h_\theta (X)$hθ​(X)给出了给定输入$x$x时，结果为1的概率，$h_\theta (x) = P(Y = 1 | x, \theta)$hθ​(x)=P(Y=1∣x,θ)，即当$h_\theta (x) \ge 0.5$hθ​(x)≥0.5时预测$Y = 1$Y=1，当$h_\theta (x) \lt 0.5$hθ​(x)<0.5时预测$Y = 0$Y=0，参照Sigmoid函数，即当$\theta^T x \ge 0$θTx≥0时预测$Y = 1$Y=1，当$\theta^T x \lt 0$θTx<0时预测$Y = 0$Y=0。

  这时逻辑回归模型为：
$P(Y = 1 | x) = \frac{1}{1 + e^{-\theta^T x}}$P(Y=1∣x)=1+e−θTx1​

$P(Y = 0 | x) = \frac{e^{-\theta^T x}}{1 + e^{-\theta^T x}}$P(Y=0∣x)=1+e−θTxe−θTx​

  于是我们只需要得到参数$\theta$θ就可以确定我们的模型。

1.2 模型的推导1——直接使用极大似然

  对于给定的训练集$T = \{ (x_1, y_1),(x_1, y_1),\cdots ,(x_N, y_N) \}$T={(x1​,y1​),(x1​,y1​),⋯,(xN​,yN​)}，其中$x_i = (0, x_i^{(1)}, x_i^{(2)}, \cdots , x_i^{(n)}) \in \mathbf{R}^{n + 1}$xi​=(0,xi(1)​,xi(2)​,⋯,xi(n)​)∈Rn+1，$y_i \in \{0, \ +1\}$yi​∈{0, +1}，可以使用极大似然估计法估计参数模型（从最优化的观点看，似然函数是光滑的凸函数，因此多种最优化的方法都适用，能保证找到全局最优解），从而得到逻辑回归模型。

  设：
$P(Y = 1 | x, \theta) = h_{\theta} (x), \quad P(Y = 0 | x, \theta) = 1 - h_{\theta} (x)$P(Y=1∣x,θ)=hθ​(x),P(Y=0∣x,θ)=1−hθ​(x)

其中$\theta = (\theta_0, \theta_1, \theta_2, \cdots, \theta_n)$θ=(θ0​,θ1​,θ2​,⋯,θn​)。

  似然函数为：
$L(\theta) = \prod_{i = 1}^N h_{\theta} (x)^{y_i}(1 - h_{\theta} (x))^{1 - y_i}$L(θ)=i=1∏N​hθ​(x)yi​(1−hθ​(x))1−yi​

  对数似然函数为：
$\begin{aligned} l(\theta) &amp; = \sum_{i = 1}^N y_i\log h_{\theta} (x) + (1 - y_i) \log (1 - h_{\theta} (x)) \\ &amp; = \sum_{i = 1}^N y_i\log \frac{1}{1 + e^{-\theta^T x}} + (1 - y_i) \log \frac{e^{-\theta^T x}}{1 + e^{-\theta^T x}} \\ &amp; = \sum_{i = 1}^N (y_i - 1) \theta^T x - \log (1 + e^{-\theta^T x}) \end{aligned}$l(θ)​=i=1∑N​yi​loghθ​(x)+(1−yi​)log(1−hθ​(x))=i=1∑N​yi​log1+e−θTx1​+(1−yi​)log1+e−θTxe−θTx​=i=1∑N​(yi​−1)θTx−log(1+e−θTx)​
  对似然函数求极大值，得到$\theta$θ的估计，对$\theta$θ求导：
$\frac{\partial l(\theta)}{\partial \theta_j} = \sum_{i = 1}^N (y_i - \frac{1}{1 + e^{-\theta^T x}}) x_i^{(j)}$∂θj​∂l(θ)​=i=1∑N​(yi​−1+e−θTx1​)xi(j)​

  假设得到的$\theta$θ的极大似然估计值为$\hat{\theta}$θ^，那么学到的逻辑回归模型就是：
$P(Y = 1 | x) = \frac{1}{1 + e^{-\hat{\theta}^T x}}$P(Y=1∣x)=1+e−θ^Tx1​

$P(Y = 0 | x) = \frac{e^{-\hat{\theta}^T x}}{1 + e^{-\hat{\theta}^T x}}$P(Y=0∣x)=1+e−θ^Txe−θ^Tx​

  求似然函数的最大值，我们可以梯度上升（梯度的解释见第2节）的方法：
$\theta_j = \theta_j + \alpha \frac{\partial l(\theta)}{\partial \theta_j} = \theta_j + \alpha \sum_{i = 1}^N (y_i - \frac{1}{1 + e^{-\theta^T x}}) x_i^{(j)}$θj​=θj​+α∂θj​∂l(θ)​=θj​+αi=1∑N​(yi​−1+e−θTx1​)xi(j)​

其中$\alpha$α为学习率，我们也可以用梯度下降的方法，但是需要对似然函数进行适当处理，令$J(\theta) = - \frac{1}{N}l(\theta)$J(θ)=−N1​l(θ)，于是有：
$J(\theta) = -\frac{1}{N} \sum_{i = 1}^N [y_i\log h_{\theta} (x) + (1 - y_i) \log (1 - h_{\theta} (x))]$J(θ)=−N1​i=1∑N​[yi​loghθ​(x)+(1−yi​)log(1−hθ​(x))]

该式即为交叉熵损失函数或者交叉熵公式。

  对$\theta_j$θj​求偏导：

$\begin{aligned} \frac{\partial J(\theta)}{\partial \theta_j} &amp; = \frac{1}{N} \sum_{i = 1}^{N} (h_{\theta}(x_i) - y_i)x_i^{(j)} \\ &amp; = - \frac{1}{N} \sum_{i = 1}^N (y_i - \frac{1}{1 + e^{-\theta^T x}}) x_i^{(j)} \end{aligned}$∂θj​∂J(θ)​​=N1​i=1∑N​(hθ​(xi​)−yi​)xi(j)​=−N1​i=1∑N​(yi​−1+e−θTx1​)xi(j)​​

  这样就可以用梯度下降发逼近参数$\theta$θ：
$\theta_j = \theta_j - \alpha \frac{\partial J(\theta)}{\partial \theta_j} = \theta_j - \alpha \frac{1}{N} \sum_{i = 1}^N (y_i - \frac{1}{1 + e^{-\theta^T x}}) x_i^{(j)}$θj​=θj​−α∂θj​∂J(θ)​=θj​−αN1​i=1∑N​(yi​−1+e−θTx1​)xi(j)​

1.3 模型的推导2——不似然的似然

  沿用前面的假设，对于第i个样本：
$P(\hat{y_i} = 1 | x_i, \theta) = h_{\theta} (x_i)$P(yi​^​=1∣xi​,θ)=hθ​(xi​)

$P(\hat{y_i} = 0 | x_i, \theta) = 1 - h_{\theta} (x_i)$P(yi​^​=0∣xi​,θ)=1−hθ​(xi​)

  如果不考虑似然函数。我们可以先对概率取对数（因为 $\log$log 运算并不会影响函数本身的单调性）：
$\log P(\hat{y_i} = 1 | x_i, \theta) = \log h_{\theta} (x_i)$logP(yi​^​=1∣xi​,θ)=loghθ​(xi​)

$\log P(\hat{y_i} = 0 | x_i, \theta) = \log (1 - h_{\theta} (x_i))$logP(yi​^​=0∣xi​,θ)=log(1−hθ​(xi​))

  于是$\hat{y_i}$yi​^​是正确的对数概率为：

\begin{align}
& I(y_i = 1)\log P(\hat{y_i} = 1 | x_i, \theta) + I(y_i = 0)\log P(\hat{y_i} = 0 | x_i, \theta) \
& = y_i \log P(\hat{y_i} = 1 | x_i, \theta) + (1 - y_i) \log P(\hat{y_i} = 0 | x_i, \theta) \
& = y_i \log h_{\theta} (x_i) + (1 - y_i) \log (1 - h_{\theta} (x_i))
\end{align}

  我们当然希望这个概率越大越好，那么只需取负即可，这样我们得到了单样本的代价函数：

$Cost(\hat{y_i}, y_i) = Cost(h_{\theta} (x_i), y_i) = - [y_i \log h_{\theta} (x_i) + (1 - y_i) \log (1 - h_{\theta} (x_i))]$Cost(yi​^​,yi​)=Cost(hθ​(xi​),yi​)=−[yi​loghθ​(xi​)+(1−yi​)log(1−hθ​(xi​))]

  于是总的代价函数为：

$J(\theta) = \frac{1}{N} \sum_{i = 1}^N Cost(h_{\theta}(x_i) , y_i)) = - \frac{1}{N} \sum_{i = 1}^N [y_i \log (h_{\theta}(x_i)) + (1 - y_i)\log (1 - h_{\theta}(x_i))]$J(θ)=N1​i=1∑N​Cost(hθ​(xi​),yi​))=−N1​i=1∑N​[yi​log(hθ​(xi​))+(1−yi​)log(1−hθ​(xi​))]

1.4 模型的推导3——使用代价函数

  对于线性回归模型，我们使用误差平方和作为代价函数，因此我们先考虑也用这个函数作为逻辑回归的代价函数，于是有：
$J(\theta) = \frac{1}{N} \sum_{i = 1}^N \frac{1}{2} (h_{\theta}(x_i) - y_i)^2$J(θ)=N1​i=1∑N​21​(hθ​(xi​)−yi​)2

这样的$J(\theta)$J(θ)是一个非凸函数，存在很多局部最小值，这会影响梯度下降算法寻找全局最小值，所以我们需要重新选择逻辑回归的代价函数。

  考虑
$Cost(h_{\theta}(x) , y)) = \begin{cases} -\log (h_{\theta}(x)) &amp; \text{if }y = 1 \\ -\log (1 - h_{\theta}(x)) &amp; \text{if }y = 0 \end{cases}$Cost(hθ​(x),y))={−log(hθ​(x))−log(1−hθ​(x))​if y=1if y=0​

这样当$y$y确实为1时，$h_{\theta}(x)$hθ​(x)越接近1，代价越接近0，$h_{\theta}(x)$hθ​(x)越接近0，代价越大；当$y$y确实为0时，$h_{\theta}(x)$hθ​(x)越接近0，代价越接近0，$h_{\theta}(x)$hθ​(x)越接近1，代价越大。取负号是为了让代价为正。代价函数的选择涉及到了交叉熵的知识，具体参考第5节的内容。进一步可以把$Cost(h_{\theta}(x) , y))$Cost(hθ​(x),y))整理为：
$Cost(h_{\theta}(x) ,y)) = - y \log (h_{\theta}(x)) - (1 - y)\log (1 - h_{\theta}(x))$Cost(hθ​(x),y))=−ylog(hθ​(x))−(1−y)log(1−hθ​(x))

  于是得到新的代价函数：
$J(\theta) = \frac{1}{N} \sum_{i = 1}^N Cost(h_{\theta}(x_i) , y_i)) = - \frac{1}{N} \sum_{i = 1}^N [y_i \log (h_{\theta}(x_i)) + (1 - y_i)\log (1 - h_{\theta}(x_i))]$J(θ)=N1​i=1∑N​Cost(hθ​(xi​),yi​))=−N1​i=1∑N​[yi​log(hθ​(xi​))+(1−yi​)log(1−hθ​(xi​))]

  在得到这样一个代价函数以后，我们便可以用梯度下降算法来求得能使代价函数最小的参数了：
$\theta_j = \theta_j - \alpha \frac{\partial J(\theta)}{\partial \theta_j} = \theta_j - \alpha \frac{1}{N} \sum_{i = 1}^N (y_i - \frac{1}{1 + e^{-\theta^T x}}) x_i^{(j)}$θj​=θj​−α∂θj​∂J(θ)​=θj​−αN1​i=1∑N​(yi​−1+e−θTx1​)xi(j)​

具体的推导过程参考1.2节。其实两者的不同主要在似然函数是上凸的，而代价函数是下凸的，两者也只是差了一个系数。

1.5 *思考——如果分类标签是｛-1，+1｝

  按照极大似然的推导方法有：

$P(Y = 1 | x, \theta) = h_{\theta} (x), \quad P(Y = -1 | x, \theta) = 1 - h_{\theta} (x)$P(Y=1∣x,θ)=hθ​(x),P(Y=−1∣x,θ)=1−hθ​(x)

  似然函数为：
$L(\theta) = \prod_{i = 1}^N h_{\theta} (x)^{y_i}(1 - h_{\theta} (x))^{2 - y_i}$L(θ)=i=1∏N​hθ​(x)yi​(1−hθ​(x))2−yi​

注意这里的上标为$2 - y_i$2−yi​

  对数似然函数对$\theta$θ求导：
$\frac{\partial l(\theta)}{\partial \theta_j} = \sum_{i = 1}^N (y_i -1 - \frac{1}{1 + e^{-\theta^T x}}) x_i^{(j)}$∂θj​∂l(θ)​=i=1∑N​(yi​−1−1+e−θTx1​)xi(j)​

  更新梯度：
$\theta_j = \theta_j + \alpha \frac{\partial l(\theta)}{\partial \theta_j} = \theta_j + \alpha \sum_{i = 1}^N (y_i - 1- \frac{1}{1 + e^{-\theta^T x}}) x_i^{(j)}$θj​=θj​+α∂θj​∂l(θ)​=θj​+αi=1∑N​(yi​−1−1+e−θTx1​)xi(j)​

  我们也可以换一种思路，考虑到sigmoid函数的一种特殊性质$g(z) = 1 - g(-z)$g(z)=1−g(−z)，以及y取值为$+1$+1或$-1$−1，我们得到：
$P(Y = 1 | x, \theta) = h_{\theta} (x) = h_{\theta} (yx)$P(Y=1∣x,θ)=hθ​(x)=hθ​(yx)

$P(Y = -1 | x, \theta) = 1 - h_{\theta} (x) = h_{\theta}(-x) = h_{\theta} (yx)$P(Y=−1∣x,θ)=1−hθ​(x)=hθ​(−x)=hθ​(yx)

  于是似然函数为：
$L(\theta) = \prod_{i = 1}^N h_{\theta} (yx)^{y_i}$L(θ)=i=1∏N​hθ​(yx)yi​

  对数似然函数对$\theta$θ求导：
$\frac{\partial l(\theta)}{\partial \theta_j} = \sum_{i = 1}^N (y_i^2 \frac{e^{-\theta^T yx}}{1 + e^{-\theta^T yx}}) x_i^{(j)}$∂θj​∂l(θ)​=i=1∑N​(yi2​1+e−θTyxe−θTyx​)xi(j)​

  更新梯度：
$\theta_j = \theta_j + \alpha \frac{\partial l(\theta)}{\partial \theta_j} = \theta_j + \alpha \sum_{i = 1}^N (y_i^2 \frac{e^{-\theta^T yx}}{1 + e^{-\theta^T yx}}) x_i^{(j)}$θj​=θj​+α∂θj​∂l(θ)​=θj​+αi=1∑N​(yi2​1+e−θTyxe−θTyx​)xi(j)​

2 梯度下降公式

  梯度下降是求最优解的一种方法，因为当数据维度较高时，我们很难通过令导数为0的方法进行求解，甚至有时候根本无法求解。考虑一个下凸函数$J(\theta) = \theta^2$J(θ)=θ2（这里如果是上凸函数，更新就会相反，参考1.2节对似然函数使用梯度上升的算法），我们要找到$J(\theta)$J(θ)最小时$\theta$θ的值。

  (1).随便取一个初始值，比如$\theta = -2$θ=−2

  (2).现在有两个方向可以对$\theta$θ进行更新：$\theta + 1$θ+1或者$\theta - 1$θ−1，显然$\theta + 1$θ+1是我们想要的，也就是说我们应该确定每次更新的方向。注意到当$\theta = 2$θ=2时，该点的导数$\frac{\partial J(\theta)}{\partial \theta} = -4 \lt 0$∂θ∂J(θ)​=−4<0，所以$-\frac{\partial J(\theta)}{\partial \theta}$−∂θ∂J(θ)​和我们的更新方向一致，也就是负梯度方向。因此我们对$\theta$θ进行更新：$\theta = \theta - \alpha \frac{\partial J(\theta)}{\partial \theta}$θ=θ−α∂θ∂J(θ)​，其中$\alpha$α为学习率

  (3).重复(1)和(2)直到$\theta$θ收敛

  再来看逻辑回归中得梯度下降算法
$\theta_j = \theta_j - \alpha \frac{1}{N} \sum_{i = 1}^N (y_i - \frac{1}{1 + e^{-\theta^T x}}) x_i^{(j)}$θj​=θj​−αN1​i=1∑N​(yi​−1+e−θTx1​)xi(j)​

  (1).其中N为样本总数，也就是说这里使用了全部样本对参数进行更新，这种方法称为批量梯度下降(Batch Gradient Descent, BGD)，这种方法的特点是很容易求得全局最优解，但是当样本数目很多时，训练过程会很慢。当样本数量很少的时候可以使用它

  (2).若只选择一个样本进行更新，即$\theta_j = \theta_j - \alpha (y_i - \frac{1}{1 + e^{-\theta^T x}}) x_i^{(j)}$θj​=θj​−α(yi​−1+e−θTx1​)xi(j)​，这样的方法称为随机梯度下降(Stochastic Gradient Descent, SGD)，这种方法的特点是训练速度快，但是准确度下降，容易受到单个数据的影响，如果单个样本是离群点或噪声，SGD算法也依然会得到更新，这使得SGD算法的每次更新迭代有可能不朝全局最优解方向走，也可能导致不收敛

  (3).那么容易想到使用部分数据的方法，称为小批量梯度下降(Mini-batch Gradient Descent, MBGD)

2.2 高级优化

  对于梯度下降算法，我们需要编写程序来计算$\frac{\partial J(\theta)}{\partial \theta_j}$∂θj​∂J(θ)​，如果需要监控$J(\theta)$J(θ)的收敛性，也可以同时计算出$J(\theta)$J(θ)

  除了梯度下降算法以外，还有一些常被用来令代价函数最小的算法，这些算法更加复杂和优越，而且通常不需要人工选择学习率，通常比梯度下降算法要更加快速。这些算法有：共轭梯度（Conjugate Gradient），局部优化法(Broyden fletcher goldfarb shann,BFGS)和有限内存局部优化法(LBFGS)。这些算法内部有一个线性搜索(line search)算法，可以自动选择一个好的学习率$\alpha$α，甚至在每一次迭代时都重新选择一个学习率$\alpha$α。因此它们往往比梯度下降收敛得更快。当然缺点也是显而易见的，复杂难懂，不过不了解内部的细节仍然不影响我们使用这些算法。

3. *多分类问题

  对于多分类，我们的数据集可能是这样的：

  我们可以通过一个叫做"一对多" (one-vs-all) 的分类算法来处理这样的问题。

  我们先从用三角形代表的类别 1 开始，实际上我们可以创建一个，新的"伪"训练集，正方形代表的类别 2 和圆形代表的类别 3 定为负类，类别 1 定为正类，我们创建一个新的训练集，如下图所示的那样，我们要训练出一个合适的分类器。

  这里红色图形为正样本，值为1，蓝色图形为负样本，值为0。于是我们可以训练一个标准的逻辑回归分类器$h_{\theta}^{(1)}(x)$hθ(1)​(x)。接着，类似地第我们选择另一个类标记（圆形样本）为正向类（y=2），再将其它类都标记为负向类，将这个模型记作 $h_{\theta}^{(2)}(x)$hθ(2)​(x),依此类推。最后我们得到一系列的模型简记为： $h_{\theta}^{(i)}(x)$hθ(i)​(x)，其中：$i = 1, 2, \cdots, k$i=1,2,⋯,k

  最后，为了做出预测，我们输入一个新的 x 值，用这个做预测。我们要做的就是在我们三个分类器里面输入 x，然后我们选择一个让$h_{\theta}^{(i)}(x)$hθ(i)​(x)最大的 i，即$\max\limits_{i} h_{\theta}^{(i)}(x)$imax​hθ(i)​(x)

4. 模型的正则化

4.1 正则化

  下图展示了一个分类的模型，左边的模型欠拟合(under fit)，中间的模型几乎是正确的，而右边的模型发生了过拟合(overfitting)。

  如果我们发现了过拟合问题，应该如何处理？

1. 丢弃一些不能帮助我们正确预测的特征。可以是手工选择保留哪些特征，或者使用一些特征选择的算法来帮忙（例如 PCA）
2. 正则化(regularization)。保留所有的特征，但是减少参数的大小（magnitude）。

  再来看一个线性回归模型：

  对于右边的过拟合模型：$h_{\theta}(x) = \theta_0 + \theta_1x + \theta_2x^2 + \theta_3x^3 + \theta_4x^4$hθ​(x)=θ0​+θ1​x+θ2​x2+θ3​x3+θ4​x4，可以看出，正是那些高次项导致了过拟合的产生，所以如果我们能让这些高次项的系数接近于 0 的话，我们就能很好的拟合了。所以我们要做的就是在一定程度上减小这些参数$\theta$θ的值，这就是正则化的基本方法。

  我们决定要减少 $\theta_3$θ3​ 和 $\theta_4$θ4​ 的大小，我们要做的便是修改代价函数，在其中对 $\theta_3$θ3​ 和 $\theta_4$θ4​ 设置一点惩罚。这样做的话，我们在尝试最小化代价时也需要将这个惩罚纳入考虑中，并最终导致选择较小一些的 $\theta_3$θ3​ 和 $\theta_4$θ4​ 。修改后的代价函数如下：
$Cost(h_{\theta}(x), y) = \frac{1}{2N} [\sum_{i = 1}^{N} (h_{\theta}(x_i) - y_i)^2 + 1000\theta_3^2 + 10000\theta_4^2]$Cost(hθ​(x),y)=2N1​[i=1∑N​(hθ​(xi​)−yi​)2+1000θ32​+10000θ42​]

  通过最小化这样的代价函数选择出的 $\theta_3$θ3​ 和 $\theta_4$θ4​ 对预测结果的影响就比之前要小许多。假如我们有非常多的特征，我们并不知道其中哪些特征我们要惩罚，我们将对所有的特征进行惩罚，并且让代价函数最优化的软件来选择这些惩罚的程度。这样的结果是得到了一个较为简单的能防止过拟合问题的假设：
$J(\theta) = \frac{1}{2N} [\sum_{i = 1}^{N} (h_{\theta}(x_i) - y_i)^2 + \lambda \sum_{j = 1}^{n}\theta_j^2]$J(θ)=2N1​[i=1∑N​(hθ​(xi​)−yi​)2+λj=1∑n​θj2​]

其中 $\lambda$λ 又称为正则化参数(Regularization Parameter)。 注：根据惯例，我们不对 $\lambda_0$λ0​ 进行惩罚。

  经过正则化处理的模型与原模型的可能对比如下图所示:

  如果选择的正则化参数 $\lambda$λ 过大，为了使代价函数减小，则会把所有的参数都最小化甚至趋于 0 ，导致模型变成 $h_{\theta}(x) = \theta_0$hθ​(x)=θ0​ ，也就是上图中红色直线所示的情况，造成欠拟合。所以对于正则化，我们要取一个合理的 $\lambda$λ 的值，这样才能更好的应用正则化。

4.2 正则化的逻辑回归模型

  对于正则化的逻辑回归模型，我们对代价函数增加惩罚项：
$J(\theta) = - \frac{1}{N} \sum_{i = 1}^N [y_i \log (h_{\theta}(x_i)) + (1 - y_i)\log (1 - h_{\theta}(x_i))] + \frac{\lambda}{2N} \sum_{j = 1}^{n} \theta_j^2$J(θ)=−N1​i=1∑N​[yi​log(hθ​(xi​))+(1−yi​)log(1−hθ​(xi​))]+2Nλ​j=1∑n​θj2​

  通过求导得出梯度下降算法为：
$\theta_0 = \theta_0 - \alpha \frac{1}{N} \sum_{i = 1}^N (y_i - \frac{1}{1 + e^{-\theta^T x}}) x_i^{(0)}$θ0​=θ0​−αN1​i=1∑N​(yi​−1+e−θTx1​)xi(0)​

$\theta_j = \theta_j - \alpha [\frac{1}{N} \sum_{i = 1}^N (y_i - \frac{1}{1 + e^{-\theta^T x}}) x_i^{(j)} + \frac{\lambda}{N}\theta_j] \quad j = 1, 2, \cdots, n$θj​=θj​−α[N1​i=1∑N​(yi​−1+e−θTx1​)xi(j)​+Nλ​θj​]j=1,2,⋯,n

5. 理解交叉熵

可以参考这两篇博客：
https://blog.csdn.net/tsyccnh/article/details/79163834
https://blog.csdn.net/rtygbwwwerr/article/details/50778098

5.1 信息量

  假设$X$X是一个离散型随机变量，其取值集合为$\mathcal{X}$X，概率分布函数为$p(x)=Pr(X=x)$p(x)=Pr(X=x)， $x \in \mathcal{X}$x∈X，我们定义事件$X=x_0$X=x0​的信息量为：

$I(x_0)=−\log(p(x_0))$I(x0​)=−log(p(x0​))

  可以理解为一个事件发生的概率越大，则它所携带的信息量就越小，而当$p(x_0)=1$p(x0​)=1时，$I(x_0)$I(x0​)等于0，也就是说该事件的发生不会导致任何信息量的增加。举个例子，小明平时不爱学习，考试经常不及格，而小王是个勤奋学习的好学生，经常得满分，所以我们可以做如下假设：

  事件A：小明考试及格，对应的概率$P(x_A)=0.1$P(xA​)=0.1，信息量为$I(x_A)=−\log(0.1)=3.3219$I(xA​)=−log(0.1)=3.3219

  事件B：小王考试及格，对应的概率$P(x_B)=0.999$P(xB​)=0.999，信息量为$I(x_B)=−log(0.999)=0.0014$I(xB​)=−log(0.999)=0.0014

  可以看出，结果非常符合直观：小明及格的可能性很低(十次考试只有一次及格)，因此如果某次考试及格了（大家都会说：XXX竟然及格了！），必然会引入较大的信息量。而对于小王而言，考试及格是大概率事件，在事件B发生前，大家普遍认为事件B的发生几乎是确定的，因此当某次考试小王及格这个事件发生时并不会引入太多的信息量。

5.2 熵

  那么什么又是熵呢？还是通过上边的例子来说明，假设小明的考试结果是一个0-1分布$X_A$XA​只有两个取值{0：不及格，1：及格}，在某次考试结果公布前，小明的考试结果有多大的不确定度呢？你肯定会说：十有八九不及格！因为根据先验知识，小明及格的概率仅有0.1，90%的可能都是不及格的。怎么来度量这个不确定度？求期望！不错，我们对所有可能结果带来的额外信息量求取均值（期望），其结果不就能够衡量出小明考试成绩的不确定度了吗。
即：

$H_A(x)=−[p(x_A)\log(p(x_A))+(1−p(x_A))\log(1−p(x_A))]=0.4690$HA​(x)=−[p(xA​)log(p(xA​))+(1−p(xA​))log(1−p(xA​))]=0.4690

  对应小王的熵：

$H_B(x)=−[p(x_B)\log(p(x_B))+(1−p(x_B))\log(1−p(x_B))]=0.0114$HB​(x)=−[p(xB​)log(p(xB​))+(1−p(xB​))log(1−p(xB​))]=0.0114

  虽然小明考试结果的不确定性较低，毕竟十次有9次都不及格，但是也比不上小王（1000次考试只有一次才可能不及格，结果相当的确定）

  我们再假设一个成绩相对普通的学生小东，他及格的概率是P(xC)=0.5P(xC)=0.5,即及格与否的概率是一样的，对应的熵：

$H_C(x)=−[p(x_C)\log(p(x_C))+(1−p(x_C))\log(1−p(x_C))]=1$HC​(x)=−[p(xC​)log(p(xC​))+(1−p(xC​))log(1−p(xC​))]=1

  其熵为1，他的不确定性比前边两位同学要高很多，在成绩公布之前，很难准确猜测出他的考试结果。

  可以看出，熵其实是信息量的期望值，它是一个随机变量的确定性的度量。熵越大，变量的取值越不确定，反之就越确定。对于一个随机变量$X$X而言，它的所有可能取值的信息量的期望$E_x [I(x)]$Ex​[I(x)]就称为熵。$X$X的熵定义为：

$H(X)=E_p\log\frac{1}{p(x)}=−\sum_{x \in \mathcal{X}}p(x)\log(p(x))$H(X)=Ep​logp(x)1​=−x∈X∑​p(x)log(p(x))

  如果$p(x)$p(x)是连续型随机变量的pdf，则熵定义为：

$H(X)=−\int_{x \in \mathcal{X}}p(x)\log(p(x))\, dx$H(X)=−∫x∈X​p(x)log(p(x))dx

为了保证有效性，这里约定当$p(x)\to 0$p(x)→0时,有$p(x)\log(p(x))\to 0$p(x)log(p(x))→0

  当$X$X为0-1分布时，熵与概率$p$p的关系如下图：

可以看出，当两种取值的可能性相等时，不确定度最大（此时没有任何先验知识），这个结论可以推广到多种取值的情况。在图中也可以看出，当$p=0$p=0或$1$1时，熵为0，即此时$X$X完全确定。

  熵的单位随着公式中$\log$log运算的底数而变化，当底数为2时，单位为“比特”(bit)，底数为e时，单位为“奈特”(nat)，当底数为10时，单位为“哈托特”(hat)。

5.3 *相对熵

  相对熵(relative entropy)又称为KL散度（Kullback-Leibler divergence），KL距离，是两个随机分布间距离的度量。记为$D_{KL}(p||q)$DKL​(p∣∣q)。它度量当真实分布为$p$p时，假设分布$q$q的无效性。

$\begin{aligned} D_{KL}(p||q) &amp; = E_p \log(\frac{p(x)}{q(x)}) \\ &amp; = \sum_{x\in \mathcal{X}} p(x) \log(\frac{p(x)}{q(x)}) \\ &amp; = \sum_{x\in \mathcal{X}} [p(x) \log(p(x)) - p(x) \log(q(x))] \\ &amp; = \sum_{x\in \mathcal{X}} p(x) \log(p(x)) - \sum_{x\in \mathcal{X}} p(x) \log(q(x)) \\ &amp; = -H(p)- \sum_{x\in \mathcal{X}} p(x) \log(q(x)) \\ &amp; = -H(p) + H_p (q) \end{aligned}$DKL​(p∣∣q)​=Ep​log(q(x)p(x)​)=x∈X∑​p(x)log(q(x)p(x)​)=x∈X∑​[p(x)log(p(x))−p(x)log(q(x))]=x∈X∑​p(x)log(p(x))−x∈X∑​p(x)log(q(x))=−H(p)−x∈X∑​p(x)log(q(x))=−H(p)+Hp​(q)​

并且为了保证连续性，做如下约定：$0\log \frac{0}{0}=0，0\log\frac{0}{q}=0，p\log\frac{p}{0}=\infty$0log00​=0，0logq0​=0，plog0p​=∞

  显然，当$p=q$p=q时,两者之间的相对熵$D_{KL}(p||q)=0$DKL​(p∣∣q)=0

  上式最后的$H_p(q)$Hp​(q)表示在$p$p分布下，使用$q$q进行编码需要的bit数，而$H(p)$H(p)表示对真实分布$p$p所需要的最小编码bit数。基于此，相对熵的意义就很明确了：$D_{KL}(p||q)$DKL​(p∣∣q)表示在真实分布为$p$p的前提下，使用$q$q分布进行编码相对于使用真实分布$p$p进行编码（即最优编码）所多出来的bit数。实际上，$H_p(q)$Hp​(q)即是我们将要讲到的交叉熵。

5.4 交叉熵

  假设有两个分布$p$p，$q$q，则它们在给定样本集上的交叉熵定义如下：

$CEH(p,q)=E_p[-\log q]=−\sum_{x \in \mathcal{X}}p(x)\log q(x)=H(p)+D_{KL}(p||q)$CEH(p,q)=Ep​[−logq]=−x∈X∑​p(x)logq(x)=H(p)+DKL​(p∣∣q)

  可以看出，交叉熵与上一节定义的相对熵仅相差了$H(p)$H(p)，当$p$p已知时，可以把$H(p)$H(p)看做一个常数，此时交叉熵与KL距离在行为上是等价的，都反映了分布$p$p，$q$q的相似程度。交叉熵越大，相似度越小。因此，要想让预测的标签的分布与真实的标签分布最接近，就需要最小化交叉熵。最小化交叉熵等于最小化KL距离。它们都将在$p=q$p=q时取得最小值，因此有的工程文献中将最小化KL距离的方法称为Principle of Minimum Cross-Entropy (MCE)或Minxent方法。

  特别的，在逻辑回归中，

  $p$p:真实样本分布，服从参数为$y$y的0-1分布，即$X∼B(1,y)$X∼B(1,y)

  $q$q:待估计的模型，服从参数为$h_{\theta}(x)$hθ​(x)的0-1分布，即$X∼B(1,h_{\theta}(x))$X∼B(1,hθ​(x))

  两者的交叉熵为：

$\begin{aligned} CEH(p,q) &amp; = −\sum_{x \in \mathcal{X}}p(x)\log q(x) \\ &amp; = −[p\log q+(1−p)\log(1−q)] \\ &amp; =−[y\log h_{\theta}(x)+(1−y)\log (1−h_{\theta}(x))] \end{aligned}$CEH(p,q)​=−x∈X∑​p(x)logq(x)=−[plogq+(1−p)log(1−q)]=−[yloghθ​(x)+(1−y)log(1−hθ​(x))]​

  对所有训练样本取均值得：

$- \frac{1}{N} \sum_{i = 1}^N [y_i \log (h_{\theta}(x_i)) + (1 - y_i)\log (1 - h_{\theta}(x_i))]$−N1​i=1∑N​[yi​log(hθ​(xi​))+(1−yi​)log(1−hθ​(xi​))]

这个结果与我们前面推导的逻辑回归模型相一致。

6 编程练习

6.1 练习Ⅰ

ex2data1.txt：https://github.com/fengdu78/Coursera-ML-AndrewNg-Notes/blob/master/code/ex2-logistic regression/ex2data1.txt

  设想你是大学相关部分的管理者，想通过申请学生两次测试的评分，来决定他们是否被录取。现在你拥有之前申请学生的可以用于训练逻辑回归的训练样本集。对于每一个训练样本，你有他们两次测试的评分和最后是被录取的结果。为了完成这个预测任务，我们准备构建一个可以基于两次测试评分来评估录取可能性的分类模型。

准备数据

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

data = pd.read_csv('file/ex2data1.txt', header=None, names=['Exam 1', 'Exam 2', 'Admitted'])
data.head()

  创建两个分数的散点图，并使用颜色编码来可视化，如果样本是正的（被接纳）或负的（未被接纳）

positive = data[data['Admitted'].isin([1])]
negative = data[data['Admitted'].isin([0])]

fig, ax = plt.subplots(figsize=(12,8))
ax.scatter(positive['Exam 1'], positive['Exam 2'], s=50, c='b', marker='o', label='Admitted')
ax.scatter(negative['Exam 1'], negative['Exam 2'], s=50, c='r', marker='x', label='Not Admitted')
ax.legend()
ax.set_xlabel('Exam 1 Score')
ax.set_ylabel('Exam 2 Score')
plt.show()

  看起来在两类间，有一个清晰的决策边界。现在我们需要实现逻辑回归，那样就可以训练一个模型来预测结果

# 提取特征
def get_X(df):
    theta_0 = pd.DataFrame({'Theta_0': np.ones(len(df))})
    data = pd.concat([theta_0, df], axis=1)    # 这两步可以用 df.insert(0, 'Ones', 1)，但是这样写会修改最初的数据，可能会影响二次使用
    return np.array(data.iloc[:, :-1])    # 返回一个 ndarray，也可以用data.iloc[:, :-1].values

# 提取标签
def get_y(df):
    return np.array(df.iloc[:, -1])

# 特征标准化
def normalize_feature(df):
    return df.apply(lambda column: (column - column.mean()) / column.std())    # 这里返回的是一个 dataframe

X = get_X(data)
y = get_y(data)
theta = np.zeros(3)    # 参数初始化为(0, 0, 0)

  让我们来检查矩阵的维度来确保一切良好。

X.shape, theta.shape, y.shape

((100, 3), (3,), (100,))

定义sigmoid函数

$g\left( z \right)=\frac{1}{1+{{e}^{-z}}}$g(z)=1+e−z1​

${{h}_{\theta }}\left( x \right)=\frac{1}{1+{{e}^{-{{\theta }^{T}}X}}}$hθ​(x)=1+e−θTX1​

def sigmoid(z):
    return 1 / (1 + np.exp(-z))

  让我们做一个快速的检查，来确保它可以工作。

nums = np.arange(-10, 10, step=0.01)

fig, ax = plt.subplots(figsize=(8, 6))
ax.plot(nums, sigmoid(nums))
ax.set_ylim((-0.1,1.1))
ax.set_xlabel('z', fontsize=18)
ax.set_ylabel('g(z)', fontsize=18)
ax.set_title('sigmoid function', fontsize=18)
plt.show()

定义代价函数

$J(\theta) = -\frac{1}{N} \sum_{i = 1}^N [y_i\log h_{\theta} (x) + (1 - y_i) \log (1 - h_{\theta} (x))]$J(θ)=−N1​i=1∑N​[yi​loghθ​(x)+(1−yi​)log(1−hθ​(x))]

def cost(theta, X, y):
    return -np.mean(y * np.log(sigmoid(X.dot(theta))) + (1 - y) * np.log(1 - sigmoid(X.dot(theta))))    
    # X.dot(theta)等价于X @ theta， 或者X * theta.T，但是X * theta.T需要先用np.matrix()转化为矩阵

  让我们计算初始化参数的代价函数（ $\theta$θ为$(0, 0, 0)^T$(0,0,0)T ）

cost(theta, X, y)

0.6931471805599453

梯度下降

• 这是批量梯度下降（batch gradient descent）

• 转化为向量化计算： $\frac{1}{m} X^T( Sigmoid(X\theta) - y )$m1​XT(Sigmoid(Xθ)−y)
  $\frac{\partial J\left( \theta \right)}{\partial {{\theta }_{j}}}=\frac{1}{N}\sum\limits_{i=1}^{N}{({{h}_{\theta }}\left( {{x}_{i}} \right)-{{y}_{i}})x_{i}^{(j)}}$∂θj​∂J(θ)​=N1​i=1∑N​(hθ​(xi​)−yi​)xi(j)​

• 这里对$\theta$θ的所有分量是同时更新的

def gradient(theta, X, y):
    return (1 / len(X)) * X.T.dot((sigmoid(X.dot(theta)) - y))    # 默认学习率为1，如果是其他的学习率可以增加一个系数

  注意，我们实际上没有在这个函数中执行梯度下降，我们仅仅在计算一个梯度步长。

  我们看看用我们的数据和初始参数为0的梯度下降法的结果。

gradient(theta, X, y)

array([ -0.1 , -12.00921659, -11.26284221])

最优化参数

  可以用SciPy’s truncated newton（TNC）实现寻找最优参数。

import scipy.optimize as opt

result1 = opt.fmin_tnc(func=cost, x0=theta, fprime=gradient, args=(X, y))
result1

(array([-25.16131854, 0.20623159, 0.20147149]), 36, 0)

  我们可以利用前面定义的代价函数来查看在这个参数下的代价是多少

cost(result1[0], X, y)

0.20349770158947492

  还可以使用 scipy.optimize.minimize 去寻找参数并获得更加详细的信息

result2 = opt.minimize(fun=cost, x0=theta, args=(X, y), method='Newton-CG', jac=gradient)
result2

预测和验证

当${{h}_{\theta }}$hθ​大于等于0.5时，预测 y=1

当${{h}_{\theta }}$hθ​小于0.5时，预测 y=0

def predict1(theta, X):
    probability = sigmoid(X.dot(theta.T))
    return [1 if x >= 0.5 else 0 for x in probability]

def cal_acc(predictions, y):
    correct = [1 if a == b else 0 for (a, b) in zip(predictions, y)]
    accuracy = sum(correct) % len(correct)
    print('accuracy = {0}%'.format(accuracy))

final_theta = result1[0]
cal_acc(predict1(final_theta, X), y)

accuracy = 89%

  还可以用 sklearn.metrics.classification_report 获得更详细的评价报告

from sklearn.metrics import classification_report 

def predict2(x, theta):
    prob = sigmoid(x @ theta)
    return (prob >= 0.5).astype(int)

final_theta = result2.x
y_pred = predict2(X, final_theta)

print(classification_report(y, y_pred))

决策边界

  首先考虑一个问题：逻辑回归可以看作是没有隐藏层的神经网络，那么为什么逻辑回归是线性分类器而神经网络是非线性分类器？首先逻辑回归的输出可以写为$h_\theta (x) = \frac{1}{1 + e^{-\theta^T x}}$hθ​(x)=1+e−θTx1​，说明预测是$x$x的线性函数，更确切地说，预测的对数几率(log-odds)是$x$x的线性函数，同时神经网络的输出不可能表示为$x$x的线性函数。另一方面对于逻辑回归，它的决策边界$\{x:\hat{p}=0.5\}${x:p^​=0.5}是线性的，是$\theta^T x=0$θTx=0的解，而神经网络的决策边界不是线性的。.

coef = -(final_theta / final_theta[2])
print(coef)

x = np.arange(130, step=0.1)
y = coef[0] + coef[1]*x    # 注意这里的 x 和 y 只是为了作图需要，而不是输入和输出值

[124.88803588 -1.02363461 -1. ]

fig, ax = plt.subplots(figsize=(12,8))
ax.scatter(positive['Exam 1'], positive['Exam 2'], s=50, c='b', marker='o', label='Admitted')
ax.scatter(negative['Exam 1'], negative['Exam 2'], s=50, c='r', marker='x', label='Not Admitted')
ax.legend()
ax.plot(x, y, 'grey')
ax.set_xlabel('Exam 1 Score')
ax.set_ylabel('Exam 2 Score')
ax.set_title('Decision Boundary', fontsize=18)
plt.show()

6.2 练习Ⅱ（正则化的逻辑回归）

ex2data2.txt：https://github.com/fengdu78/Coursera-ML-AndrewNg-Notes/blob/master/code/ex2-logistic regression/ex2data2.txt

  设想你是工厂的生产主管，你有一些芯片在两次测试中的测试结果。对于这两次测试，你想决定是否芯片要被接受或抛弃。为了帮助你做出艰难的决定，你拥有过去芯片的测试数据集，从其中你可以构建一个逻辑回归模型。

准备数据

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns

data = pd.read_csv('file/ex2data2.txt', header = None, names=['Test 1', 'Test 2', 'Accepted'])
data.head()

sns.set(context="notebook", style="ticks", font_scale=1.5)

sns.lmplot('Test 1', 'Test 2', hue='Accepted', data=data, 
           height=6, 
           fit_reg=False, 
           scatter_kws={"s": 100}
          )

plt.title('Regularized Logistic Regression')
plt.show()

  这个数据看起来可比练习Ⅰ复杂得多。特别地，注意到其没有线性决策边界来良好的分开两类数据。一个方法是用像逻辑回归这样的线性技术来构造从原始特征的多项式中得到的特征。让我们通过创建一组多项式特征入手吧。

特征映射

  把$x_1^i x_2^j$x1i​x2j​映射到新特征$Fij$Fij，$power = i + j$power=i+j最高次可以任意设定

# 特征映射
def feature_mapping(x1, x2, power, as_ndarray=False):
    # as_ndarray控制返回数据的类型
    data = {"f{}{}".format(i - p, p): np.power(x1, i - p) * np.power(x2, p)
                for i in np.arange(power + 1)
                for p in np.arange(i + 1)
            }

    if as_ndarray:
        return pd.DataFrame(data).values
    else:
        return pd.DataFrame(data)

power = 4
x1 = data['Test 1']
x2 = data['Test 2']

newdata = feature_mapping(x1, x2, power)
print(newdata.shape)
newdata.head()

  现在，我们需要修改第1部分的代价函数和梯度函数，包括正则化项。

def sigmoid(z):
    return 1 / (1 + np.exp(-z))

正则化代价函数

$J(\theta) = - \frac{1}{N} \sum_{i = 1}^N [y_i \log (h_{\theta}(x_i)) + (1 - y_i)\log (1 - h_{\theta}(x_i))] + \frac{\lambda}{2N} \sum_{j = 1}^{n} \theta_j^2$J(θ)=−N1​i=1∑N​[yi​log(hθ​(xi​))+(1−yi​)log(1−hθ​(xi​))]+2Nλ​j=1∑n​θj2​

theta = np.zeros(newdata.shape[1])
X = newdata.values
print(X.shape)

y = np.array(data.iloc[:, -1])
print(y.shape)

(118, 15)
(118,)

# 正则化代价函数，注意不对常数项进行惩罚
def cost(theta, X, y):
    return -np.mean(y * np.log(sigmoid(X.dot(theta))) + (1 - y) * np.log(1 - sigmoid(X.dot(theta))))

def regularized_cost(theta, X, y, lambda0=1):
    # 默认正则化参数为1
    theta_j1_to_n = theta[1:]
    regularized_term = (lambda0 / (2 * len(X))) * np.power(theta_j1_to_n, 2).sum()

    return cost(theta, X, y) + regularized_term

  我们再来看看初始化参数下的代价

cost(theta, X, y)

0.6931471805599454

regularized_cost(theta, X, y)

0.6931471805599454

  两者结果相同，因为初始化参数全为0，所以惩罚项也是0

正则化梯度

$\frac{\partial J\left( \theta \right)}{\partial {{\theta }_{j}}}=\frac{1}{N}\sum\limits_{i=1}^{N}{({{h}_{\theta }}\left( {{x}_{i}} \right)-{{y}_{i}})x_{i}^{(j)}} \quad j = 0$∂θj​∂J(θ)​=N1​i=1∑N​(hθ​(xi​)−yi​)xi(j)​j=0

$\frac{\partial J(\theta)}{\partial \theta_j} = \frac{1}{N} \sum_{i = 1}^N (y_i - \frac{1}{1 + e^{-\theta^T x}}) x_i^{(j)} + \frac{\lambda}{N}\theta_j \quad j = 1, 2, \cdots, n$∂θj​∂J(θ)​=N1​i=1∑N​(yi​−1+e−θTx1​)xi(j)​+Nλ​θj​j=1,2,⋯,n

def gradient(theta, X, y):
    return (1 / len(X)) * X.T.dot((sigmoid(X.dot(theta)) - y))

def regularized_gradient(theta, X, y, lambda0=1):
    theta_j1_to_n = theta[1:]
    regularized_theta = (lambda0 / len(X)) * theta_j1_to_n

    # 注意不要忘了常数项惩罚要补0
    regularized_term = np.concatenate([np.array([0]), regularized_theta])

    return gradient(theta, X, y) + regularized_term

  再来看看初始化参数的情况下梯度下降了多少

regularized_gradient(theta, X, y)

最优化参数

import scipy.optimize as opt

  fmin_tnc方法

result1 = opt.fmin_tnc(func=regularized_cost, x0=theta, fprime=regularized_gradient, args=(X, y))
result1

  minimize方法

result2 = opt.minimize(fun=regularized_cost, x0=theta, args=(X, y), method='Newton-CG', jac=regularized_gradient)
result2

预测和验证

  沿用fmin_tnc方法得到的结果

def predict1(theta, X):
    probability = sigmoid(X.dot(theta.T))
    return [1 if x >= 0.5 else 0 for x in probability]

def cal_acc(predictions, y):
    correct = [1 if a == b else 0 for (a, b) in zip(predictions, y)]
    accuracy = sum(correct) % len(correct)
    print('accuracy = {0}%'.format(accuracy))

final_theta = result1[0]
cal_acc(predict1(final_theta, X), y)

accuracy = 97%

  沿用fmin_tnc方法得到的结果

from sklearn.metrics import classification_report 

def predict2(x, theta):
    prob = sigmoid(x.dot(theta))
    return (prob >= 0.5).astype(int)

final_theta = result2.x
y_pred = predict2(X, final_theta)

print(classification_report(y, y_pred))

  两者结果并不相同，应该和学习率有关

决策边界

def feature_mapped_logistic_regression(power, lambda0):
    # 为了比较不同power和正则化参数下的结果，对前面的回归过程进行整理
    # 准备数据
    df = pd.read_csv('file/ex2data2.txt', names=['test1', 'test2', 'accepted'])
    x1 = np.array(df.test1)
    x2 = np.array(df.test2)
    y = np.array(df.iloc[:, -1])
    
    # 特征映射
    X = feature_mapping(x1, x2, power, as_ndarray=True)
    theta = np.zeros(X.shape[1])

    # 逻辑回归
    res = opt.minimize(fun=regularized_cost,
                       x0=theta,
                       args=(X, y, lambda0),
                       method='TNC',
                       jac=regularized_gradient)
    final_theta = res.x

    return final_theta


def find_decision_boundary(density, power, theta, threshhold):
    t1 = np.linspace(-1, 1.5, density)
    t2 = np.linspace(-1, 1.5, density)

    cordinates = [(x, y) for x in t1 for y in t2]
    x_cord, y_cord = zip(*cordinates)
    mapped_cord = feature_mapping(x_cord, y_cord, power)  # this is a dataframe

    inner_product = mapped_cord.values.dot(theta)

    decision = mapped_cord[np.abs(inner_product) < threshhold]

    return decision.f10, decision.f01


def draw_boundary(power, lambda0):
    density = 1000
    threshhold = 2 * 10**-3

    final_theta = feature_mapped_logistic_regression(power, lambda0)
    x, y = find_decision_boundary(density, power, final_theta, threshhold)

    df = pd.read_csv('file/ex2data2.txt', names=['Test 1', 'Test 2', 'Accepted'])
    sns.lmplot('Test 1', 'Test 2', hue='Accepted', data=df, height=6, fit_reg=False, scatter_kws={"s": 100})

    plt.scatter(x, y, c='red', s=10)
    plt.title('Decision boundary')
    plt.show()

draw_boundary(power=7, lambda0=1)    # 正则化参数为1

draw_boundary(power=7, lambda0=0)    # 正则化参数为0，即不进行正则化

  可以看到发生了过拟合

draw_boundary(power=7, lambda0=100)    # 正则化参数为100，即加重惩罚

  可以看到发生了欠拟合

6.3 练习Ⅲ（使用scikit-learn）

from sklearn import linear_model

model = linear_model.LogisticRegression(penalty='l2', C=1.0)
model.fit(X, y.ravel())

model.score(X, y)

0.8220338983050848

  这个准确度和result1差了好多，不过请记住这个结果是使用默认参数下计算的结果。我们可能需要做一些参数的调整来获得和我们之前结果相同的精确度。