第3章从零认识逻辑回归（附高清PDF和PPT）

各位朋友大家好，欢迎来到月来客栈，我是掌柜空字符。

在第2章中，笔者详细的介绍了线性回归模型，那么本章开始将继续介绍下一个经典的机器学习算法逻辑回归（Logistics Regression）。如图3-1所示为逻辑回归模型学习的大致路线，其同样也分为三个阶段。在第一个阶段结束后，我们也就大致掌握了逻辑回归的基本原理。下面就开始正式进入逻辑回归模型的学习。

图 3-1 逻辑回归学习路线图

以下所有完整实现代码（包括作图）均可从仓库 https://github.com/moon-hotel/MachineLearningWithMe 中获取！公众号后台回复“跟我一起机器学习”即可获得本文高清PDF内容与教学PPT！

3.1模型的建立与求解

3.1.1理解逻辑回归模型

通常来讲，一个新算法的诞生要么用来改善已有的算法模型，要么就是首次提出用来解决一个新的问题。而逻辑回归模型恰恰属于后者，它是用来解决一类新的问题——分类（Classification）。那什么又是分类问题呢？

现在有两堆样本点，需要建立一个模型来对新输入的样本进行预测，判断其应该属于那个类别，即二分类问题（Binary Classification），如图3-2所示。

图3-2 分类任务图

对于这个问题的描述用线性回归来解决肯定是不行的，因为两者本就属于不同类型的问题。退一步讲，即使是用线性回归来建模得到的估计也就是一条向右倾斜的直线，而我们这里需要的却是一条向左倾斜的且位于两堆样本点之间的直线。同时，回归模型的预测值都位于预测曲的线附近，而无法做到区分直线两边的东西。那既然用已有的线性回归解决不了，那我们可不可以在此基础上做一点改进以实现分类的目的呢？答案是当然可以。

3.1.2建立逻辑回归模型

$p$ $p>0.5$ 那我们就可以认为该样本点属于这个类别，这样就能解决上述的二分类问题。可该怎么建立这个模型呢？

$h(x)=wx+b$ $g(z)$ $h(x)$ 映射至[0,1]的范围即可。由此，便得到了逻辑回归中的预测模型

\hat{y}=h(x)=g(wx+b)\;\;\;\;\;\;\;(3.1)

$w,b$ $h(x)$ $h(x)$ $x$ $wx+b=0$ $w,b$ 后，也就意味着得到了这个分类模型。

注意：回归模型一般来说都是指对连续值进行预测的一类模型，而分类模型都是指对离散值（类标）预测的一类模型。但是由于历史的原因虽然逻辑回归被称为回归，但它却是一个分类模型，这算是一个例外。

3.1.3求解逻辑回归模型

$w,b$ 。

同样，笔者先给出逻辑回归中的目标函数（第二阶段再讲来历）：

\begin{aligned} & J(w,b)=-\frac{1}{m}\left[ \sum\limits_{i=1}^{m}{{{y}^{(i)}}}\log h({{x}^{(i)}})+(1-{{y}^{(i)}})\log (1-h({{x}^{(i)}})) \right] \\ & h({{x}^{(i)}})=g(w{{x}^{(i)}}+b) \end{aligned}\;\;\;\;\;\;\;(3.2)

$m$ ${{x}^{(i)}}$ $i$ ${{y}^{(i)}}$ $i$ $h({{x}^{(i)}})$ $i$ 个样本为正类的预测概率。

$(3.1)$ $J(w,b)$ $\hat{w},\hat{b}$ $J(w,b)$ $h(x)$ $J(w,b)$ 的问题。

至此，对逻辑回归算法第一阶段核心内容的学习也就只差一步之遥了，那就是评价指标以及通过开源的框架来建模并进行预测。

3.1.4逻辑回归示例代码

首先，为了便于后续的可视化过程以及了解分类的实质，笔者这里首先采用人为的方式来构造一个数据集进行模型的训练；然后再通过sklearn中的LogisticRegression来完成模型的求解。完整代码见Chapter03/01_decision_boundary.py文件。

1) 构造数据集

这里需要用到sklearn中的make_blobs方法来构造数据集，代码如下：


xxxxxxxxxx
8
1
1 from sklearn.datasets import make_blobs
2
2 def make_data():
3
3     centers = [[1, 1], [2, 2]]  # 指定中心
4
4     x, y = make_blobs(n_samples=200, centers=centers,
5
5                       cluster_std=0.2, random_state=np.random.seed(10))
6
6     index_pos, index_neg = (y == 1), (y == 0)
7
7     x_pos, x_neg = x[index_pos], x[index_neg]
8
8     return x, y

在上述代码中，第2行用来指定生成两个样本堆的中心；第3-4行则是根据指定的中心点生成两个不同类别的样本堆，其中n_samples表示样本的数量，cluster_std表示样本间的标准差（值越小样本点分布越集中），random_state表示用来指定一个固定的随机种子，以使得每次产生相同的样本点。

在这之后，就能生成一个数据集，如图3-3所示。

图3-3 二分类数据集可视化图

2) 训练模型

接着通过LogisticRegression来完成模型的训练和预测，代码如下：


xxxxxxxxxx
7
1
1 from sklearn.linear_model import LogisticRegression
2
2 def decision_boundary(x, y):
3
3     model = LogisticRegression()
4
4     model.fit(x, y)
5
5     pred = model.predict([[1, 0.5], [3, 1.5]])
6
6     print("样本点(1,0.5)所属的类标为{}\n"
7
7             "样本点(3,1.5)所属的类标为{}".format(pred[0], pred[1]))

在完成模型的训练之后，便可以绘制出模型所训练得到的决策面，用于样本点的分类，如图3-4所示。

图3-4 二分类决策边界图

3.1.5小结

在本节中，笔者首先通过一个例子引入了什么是分类，然后介绍了为什么不能用线性回归模型进行建模的原因；其次，通过对线性回归的改进得到逻辑回归模型，并直接的给出了逻辑回归模型的目标函数；最后通过开源的sklearn框架搭建了一个简单的逻辑回归模型，并对决策面进行了可视化。虽然内容不多，也不复杂但却包含了逻辑回归算法的核心思想。同时，余下的内容也会在后续的章节中进行介绍。

3.2多变量与多分类

3.2.1多变量逻辑回归

如同多变量线性回归一样，所谓多变量逻辑回归其实就是一个样本点有多个特征属性，然后通过建立一个多变量的逻辑回归模型来完成分类的任务。实际上在现实情况中，几乎没有一个模型是单变量的，即每个样本点都有多个特征。由于这是刚入门学习的第2个机器学习算法，所以在这里再对多变量进行一次说明。在后续的算法介绍中，将不再单独提及“多变量模型”这一叫法，所有模型的输入都是一个向量（Vector）。

\hat{y}=h(x)=g({{w}_{1}}{{x}_{1}}+{{w}_{2}}{{x}_{2}}+\cdots +{{w}_{n}}{{x}_{n}}+b)\;\;\;\;\;\;(3.3)

$(3.3)$ 所示便为一个多变量逻辑回归模型的假设函数，其后续的所有步骤（求解、预测等）并没有任何的变化与不同，仅仅只是有了更多的特征属性。

3.2.2多分类逻辑回归

在3.1节中对于逻辑回归的介绍都仅仅局限在二分类任务中。但是在实际任务里，更多则是多分类的任务场景，也就是说最终的分类结果中类别数会大于2。那对于这样的问题该如何解决呢？

通常情况下在用逻辑回归处理多分类任务时，都会采样一种称为One-vs-all（也叫做 One-vs-rest）的方法，两者的缩写分别为'ova'与'ovr'。这种策略的核心思想就是每次将其中一个类和剩余其他的类看作是一个二分类任务进行训练，最后在预测过程中选择输出概率值最大那个类标作为该样本点所属的类别。

如图3-5所示为一个可视化的数据集，它一共包含有3个类别。

图3-5 多分类问题图

当利用One-vs-all的分类思想来解决图3-5中的多分类问题时，可以将可视化成如图3-6所示的情况。

图3-6 One-vs-all思想图

$h_0(x)$ $h_1(x)$ $h_2(x)$ $x$ 属于第0，1，2三个类别的概率；最后在预测的时候只要选择概率最大时分类模型所对应的类别即可。

3.2.3多分类示例代码

在sklearn中，可以借助LogisticRegression类中的multi_class='ovr'参数来完成整个多分类的建模任务，完整代码见Chapter03/02_one_vs_all_train.py文件。

1) 载入数据集

在这里，笔者同样也使用sklearn中内置的一个分类数据集iris来进行示例。首先需要载入这个数据集，代码如下：


xxxxxxxxxx
5
1
1 from sklearn.datasets import load_iris
2
2 def load_data():
3
3     data = load_iris()
4
4     x, y = data.data, data.target
5
5     return x, y

iris数据集一共包含有3个类别，每个类别中有50个样本，并且每个样本的有4个特征维度。同时，sklearn中也内置了很多丰富的其它数据集来方便初学者使用，具体信息可以参见官网[1]。

2) 训练模型

在数据集载入完成后，便可以通过sklearn中的LogisticRegression来完成整个建模求解过程，代码如下：


xxxxxxxxxx
5
1
1 def train(x, y): 
2
2     model = LogisticRegression(multi_class='ovr')
3
3     model.fit(x,y)
4
4     print("得分: ", model.score(x, y))
5
5 # 得分：0.95

到此，对于多变量逻辑回归的分类方法与建模过程就介绍完了。不过细心的读者可能发现，上面代码中的最后一行输出了一个0.95的得分，它表示什么含义呢？这里的0.95其实指的模型分类的准确率，意思是指有95%的样本都被模型分类正确了，具体计算原理可见3.3节内容。

3.2.4小结

在本节内容中，笔者首先介绍了什么是多变量逻辑回归，同时还提到对于“多变量”这个说法在以后均不会刻意提及，因为在现实中几乎不存在一个只包含一个变量的任务场景；其次，笔者还以图示的方式介绍了如何用One-vs-all的思想来用逻辑回归模型解决多分类的任务场景；最后，借助开源库skleanr也完成了整个建模过程的示例。接下来，我们将开始学习分类模型中的常见评估指标。

3.3常见的分类评估指标

$F$ $F_{score}$ ），其中应用最为广泛的就是准确率，接着是召回率。为了能够使读者更容易的理解与运用这4种评价指标，下面笔者将会由浅入深地从二分类到多分类的场景来对这4种指标进行介绍。

3.3.1二分类场景

首先以一个猫狗图片识别的任务场景为例，假设现在有一个猫狗图片分类器对100张图片进行分类，分类结果显示有38张图片是猫，62张图片是狗。经过与真实标签对比后发现，38张猫的图片中有20张是分类正确的，62张狗的图片中有57张是分类正确的。

根据上述这一情景，便能得到一张如下图3-7所示的矩阵，称之为混淆矩阵（Confusion Matrix）。

图3-7 二分类混淆矩阵图

如何来读这个混淆矩阵呢？读的时候首先横向看，然后再纵向看。例如读TP的时候，首先横向表示真实的正样本，其次是纵向表示预测的正样本，因此TP表示的就是将正样本预测为正样本的个数，即预测正确。因此，同理有

True Positive（TP）：表示将正样本预测为正样本，即预测正确；
False Negative（FN）：表示将正样本预测为负样本，即预测错误；
False Positive（FP）：表示将负样本预测为正样本，即预测错误；
True Negative（TN）：表示将负样本预测为负样本，即预测正确

那如果此时突然问FP表示什么含义，又该怎么迅速的反映出来呢？我们知道FP（False Positive）从字面意思来看表示的是错误的正类，也就是说实际上它并不是正类，而是错误的正类，即实际上为负类。因此，FP表示的就是将负样本预测为正样本的含义。再看一个FN，其字面意思为错误的负类，也就是说实际上它表示的是正类，因此FN的含义就是将正样本预测为负样本。

$(3.4)$ 所示。

\begin{aligned} & Accurcay=\frac{TP+TN}{TP+FP+FN+TN} \\ & Precision=\frac{TP}{TP+FP} \\ & Recall=\frac{TP}{TP+FN} \\ & {{F}_{score}}=(1+{{\beta }^{2}})\frac{Precision\cdot Recall}{{{\beta }^{2}}\cdot Precision+Recall} \end{aligned} \;\;\;\;\;\;\;\;(3.4)

注意： ${{F}_{score}}$ $\beta=1$ $F_1$ $F_1$ $F_{score}$ 评价指标。

$F_{score}$ 则是精确率与召回率的调和平均。但值得注意的是，通常在绝大多数任务中并不会明确哪一类别是正样本，哪一类别又是负样本，所以对于每个类别来说都可以计算其各项指标（但是准确率只有一个）。

$(3.4)$ 中各项评价指标的计算公式后，便可以分别计算出3.3.1节一开始的示例场景中，猫狗分类模型的各项评估值。

1) 准确率

Accuracy=\frac{20+57}{20+18+5+57}=0.77\;\;\;\;\;\;\;(3.5)

$F$ 值

对于类别猫来说
$\begin{aligned} & Precision=\frac{20}{20+18}=0.53 \\ & Recall=\frac{20}{20+5}=0.8 \\ & {{F}_{1}}=\frac{2\times 0.53\times 0.8}{0.53+0.8}=0.63 \end{aligned}\;\;\;\;\;\;\;(3.6)$
对于类别狗来说
$\begin{aligned} & Precision=\frac{57}{57+5}=0.92 \\ & Recall=\frac{57}{57+18}=0.76 \\ & {{F}_{1}}=\frac{2\times 0.92\times 0.76}{0.92+0.76}=0.83 \end{aligned}\;\;\;\;\;\;\;\;(3.7)$
$F$ 值又该怎么处理呢？对于分类结果整体的评估值，常见的做法有两种：第一种是取算术平均；第二种是加权平均[2]

1) 算术平均

$F_1$ 值分别为

\begin{aligned} & Precision=\frac{1}{2}\times 0.53+\frac{1}{2}\times 0.92=0.725 \\ & Recall=\frac{1}{2}\times 0.8+\frac{1}{2}\times 0.76=0.78 \\ & {{F}_{1}}=\frac{1}{2}\times 0.63+\frac{1}{2}\times 0.83=0.73 \end{aligned}\;\;\;\;\;\;\;(3.8)

2) 加权平均

${{F}_{1}}$ 值分别为

\begin{aligned} & Precision=\frac{25}{100}\times 0.53+\frac{75}{100}\times 0.92=0.82 \\ & Recall=\frac{25}{100}\times 0.8+\frac{75}{100}\times 0.76=0.77 \\ & {{F}_{1}}=\frac{25}{100}\times 0.63+\frac{75}{100}\times 0.83=0.78 \end{aligned}\;\;\;\;\;\;\;(3.9)

3.3.2二分类指标示例代码

$(3.4)$ 可知，计算各项评估指标的关键就在于如何从分类结果中构造一个混淆矩阵。对于评估矩阵的构造，这里可以借助sklearn中提供的confusion_matrix方法来进行实现。完整代码见Chapter03/03_confusion_matrix.py文件。

1) 载入数据集

在这里，同样也使用sklearn中内置的一个分类数据集breast_cancer进行示例。首先需要载入这个数据集，代码如下：


xxxxxxxxxx
5
1
1 from sklearn.datasets import load_breast_cancer
2
2 def load_data():
3
3     data = load_breast_cancer()
4
4     x, y = data.data, data.target
5
5     return x, y

breast_cancer数据集一共包含有2个类别（正样本与负样本），其中负样本212个，正样本357个，并且每个样本的有30个特征维度。

2) 指标计算

根据前面介绍的计算原理，可以实现各项指标的计算过程，代码如下：


xxxxxxxxxx
12
1
 1 def get_acc_rec_pre_f(y_true, y_pred, beta=1.0):
2
 2      (tn, fp), (fn, tp) = confusion_matrix(y_true, y_pred)
3
 3     p1, p2 = tp / (tp + fp), tn / (tn + fn) 
4
 4     r1, r2 = tp / (tp + fn), tn / (tn + fp) 
5
 5     f_beta1 = (1 + beta ** 2) * p1 * r1 / (beta ** 2 * p1 + r1) 
6
 6     f_beta2 = (1 + beta ** 2) * p2 * r2 / (beta ** 2 * p2 + r2)
7
 7     m_p, m_r, m_f = 0.5 * (p1+p2), 0.5 * (r1+r2), 0.5 * (f_beta1 + f_beta2) 
8
 8     count = np.bincount(y_true)
9
 9     w1, w2 = count[1]/sum(count), count[0]/sum(count)# 计算加权平均
10
10     w_p, w_r,w_f=w1 * p1+w2 * p2, w1 * r1+w2 * r2, w1 *f_beta1+w2 * f_beta2
11
11     print(f"算术平均： 精确率：{m_p},召回率：{m_r},F值：{m_f}")
12
12     print(f"加权平均：精确率：{w_p},召回率：{w_r},F值：{w_f}")

在上述代码中，第2行用来构造混淆矩阵；第3-4行分别用来计算两种类别各自的精确率和召回率；第5-6行分别用来计算两种类别的F值；第7行用来计算各个指标的算术平均；第8-10行用来计算各个指标的加权平均。

3) 训练模型

在完成上面两个步骤后，便可以通过LogisticRegression来完成整个建模求解过程，并输出对应的评价指标，代码如下：


xxxxxxxxxx
6
1
1 def train(x, y):
2
2     model = LogisticRegression()
3
3     model.fit(x, y)
4
4     y_pred = model.predict(x)
5
5     print("准确率: ", model.score(x, y))
6
6     get_acc_rec_pre_f(y, y_pred)

经过上述代码后，便能够得到如下所示的评估结果，如下：


xxxxxxxxxx
3
1
1 准确率:  0.95
2
2 算术平均: 精确率:0.95,召回率:0.94,F值0.94
3
3 加权平均: 精确率:0.95,召回率:0.95,F值0.95

3.3.3多分类场景

在3.3.1节中，笔者详细的介绍了在二分类场景下各种评价指标的计算方法。但是在现实场情况里更多的便是多分类场景，并且通常也会采用召回率、精确率或者F值来作为评价指标。那此时各个指标又该怎么计算呢？在接下来的这节内容中，笔者将会针对多分类的任务场景来介绍这些指标的计算方法。

假设有如下三分类任务的预测值与真实值，如下代码所示：


xxxxxxxxxx
2
1
1 y_true = [1, 1, 1, 0, 0, 0, 2, 2, 2, 2]
2
2 y_pred = [1, 0, 0, 0, 2, 1, 0, 0, 2, 2]

根据这一结果，便可以得到一个混淆矩阵，如图3-8所示。

图3-8 多分类混淆矩阵图

如图3-8所示，由于是多分类所以也就不止正样本和负样本两个类别，那这个表该怎么读呢？方法还是同3.3.1节中的一样，先横向看再纵向看。例如第1行灰色单元格中的1表示的就是将真实值0预测为0的个数（预测正确）；接着右边的1表示的就是将真实值0预测为1的个数；第2行灰色单元格中的1表示的就是将真实值1预测为1的个数；第3行灰色单元格中的2表示的就是将真实值2预测为2的个数。也就是说只有这个对角线上的值才表示模型预测正确的样本的数量。接下来就开始对每个类别的各项指标进行一个计算。

1) 对于类别0来说

在上面笔者介绍到，精确率计算的是预测对的正样本在整个预测为正样本中的比重。根据图3-8可知，对于类别0来说，预测对的正样本（类别0）数量为1，而整个预测为正样本的数量为5。因此，类别0对应的精确率为

Precision=\frac{1}{1+2+2}=0.2\;\;\;\;\;\;\;\;(3.10)

同时，召回率计算的是预测对的正样本在整个真实正样本中的比重。根据图3-8可知，对于类别0来说，预测对的正样本（类别0）数量为1，而整个真实正样本0的个数为3（图3-8中第2行的3个1）。因此，对于类别0来说其召回率为

Recall=\frac{1}{1+1+1}=0.33\;\;\;\;\;\;\;\;(3.11)

$F_1$ 值为

{{F}_{1}}=\frac{2\times 0.2\times 0.33}{0.2+0.33}=0.25\;\;\;\;\;\;\;\;(3.12)

2) 对于类别1来说

对于类别1来说，预测对的正样本（类别1）的数量为1，而整个预测为类别1的样本数量为2。因此，其精确率为

Precision=\frac{1}{1+1+0}=0.5\;\;\;\;\;\;\;\;(3.13)

$F_1$ 值分别为

\begin{aligned} & Recall=\frac{1}{1+2}=0.33 \\ & {{F}_{1}}=\frac{2\times 0.5\times 0.33}{0.5+0.33}=0.40 \end{aligned}\;\;\;\;\;\;\;(3.14)

3) 对于类别2来说

\begin{aligned} & Precision=\frac{2}{1+0+2}=0.67 \\ & Recall=\frac{2}{2+0+2}=0.50 \\ & {{F}_{1}}=\frac{2\times 0.67\times 0.50}{0.67+0.50}=0.57 \end{aligned}\;\;\;\;\;\;\;\;\;(3.15)

$F_1$ 值分别为

(1) 算术平均

\begin{aligned} & Precision=\frac{1}{3}\times \left( 0.20+0.50+0.67 \right)=0.46 \\ & Recall=\frac{1}{3}\times \left( 0.33+0.33+0.50 \right)=0.39 \\ & {{F}_{1}}=\frac{1}{3}\times \left( 0.25+0.40+0.57 \right)=0.41 \end{aligned}\;\;\;\;\;\;\;\;(3.16)

(2) 加权平均

\begin{aligned} & Precision=\frac{3}{10}\times 0.2+\frac{3}{10}\times 0.50+\frac{4}{10}\times 0.67=0.48 \\ & Recall=\frac{3}{10}\times 0.33+\frac{3}{10}\times 0.33+\frac{4}{10}\times 0.50=0.40 \\ & {{F}_{1}}=\frac{3}{10}\times 0.25+\frac{3}{10}\times 0.40+\frac{4}{10}\times 0.57=0.42 \end{aligned}\;\;\;\;\;\;\;\;(3.17)

3.3.4多分类指标示例代码

对于这部分的代码实现，从上面的计算过程可以发现，最重要的依旧是要计算得到这个混淆矩阵。但是对于多分类任务来说，后续实现代码也略显繁杂，不过各位读者依旧可以仿照第3.3.2节中的代码自己来编码实现。不过这里，我们可以直接借助sklearn中的classification_report模块[2]来完成所有的计算过程，代码如下：


xxxxxxxxxx
4
1
1 from sklearn.metrics import classification_report
2
2 y_true = [1, 1, 1, 0, 0, 0, 2, 2, 2, 2]
3
3 y_pred = [1, 0, 0, 0, 2, 1, 0, 0, 2, 2]
4
4 print(classification_report(y_true, y_pred))

在运行上述代码后，便能得到如下所示的结果：


xxxxxxxxxx
7
1
1               precision    recall  f1-score   support #分别表示精确、召回率、F值
2
2            0       0.20      0.33      0.25         3
3
3            1       0.50      0.33      0.40         3
4
4            2       0.67      0.50      0.57         4
5
5     accuracy                           0.40        10  #模型准确率
6
6     macro avg       0.46     0.39      0.41        10  #算术平均（宏平均）
7
7 weighted avg       0.48      0.40      0.42        10  #加权平均

3.3.5小结

在本节中，笔者首先介绍了二分类任务场景下混淆矩阵的构造以及对应的含义；接着介绍了如何通过混淆矩阵来计算分类模型中的各项评估指标；其次是介绍了在多分类任务下混淆矩阵的构造以及对应各项指标的计算方法；最后还通过sklearn中的confusion_matrix和classification_report模块来示例完成了所有的计算过程。接下来让我们开始学习逻辑回归模型中最后两个阶段的内容。

3.4目标函数推导

$g(z)$ 长什么样？逻辑回归的目标函数怎么来的？如何自己求解实现逻辑回归？只有在这3个问题解决后，整个逻辑回归算法的主要内容才算是学习完了。

3.4.1映射函数

$g(z)$ $z=Wx+b$ $g(z)$ $g(z)$ 的函数图像，其同时也被称为Sigmoid函数。

图3-9 Sigmoid函数图

Sigmoid函数的数学定义如下

g(z)=\frac{1}{1+{{e}^{-z}}}\;\;\;\;\;\;\;(3.18)

$z\in [-\infty ,+\infty ]$ $(0,0.5)$ $g^{\prime}(z)=g(z)(1-g(z))$ 。

$(3.18)$ 可以得出其实现代码如下：


xxxxxxxxxx
2
1
1 def g(z):
2
2     return 1 / (1 + np.exp(-z))

可以看到对于Sigmoid的实现也非常简单，1行代码就能完成。

3.4.2概率表示

在介绍完Sigmoid函数后就需要弄清楚逻辑回归中的目标函数到底是怎么来的。此时，可以设

\begin{aligned} & P(y=1|x;W,b)=h(x) \\ & P(y=0|x;W,b)=1-h(x) \\ & h(x)=g(z)=g({{W}^{T}}x+b) \\ \end{aligned}\;\;\;\;\;\;\;\;(3.19)

$W,x$ $P(y=1|x;W,b)=h(x)$ $W,b$ $x$ $y=1$ $h(x)$ 。此时可以发现，对于每个样本来说都需要前面两个等式来衡量每一个样本所属类别的概率，为了更加方便的表示每个样本所属类别的概率，可以改写为如下形式

p(y|x;W,b)={{(h(x))}^{y}}{{(1-h(x))}^{1-y}}\;\;\;\;\;\;\;\;(3.20)

$x$ 属于哪个类别，都可以通过式来进行概率计算。

$({{x}^{(i)}},{{y}^{(i)}})$ $W,b$ ${{x}^{(i)}}$ ${{y}^{(i)}}$ ${{y}^{(i)}}$ $W,b$ ${{y}^{(1)}},{{y}^{(2)}},\cdots ,{{y}^{(m)}}$ $W,b$ ${{x}^{(1)}},{{x}^{(2)}},\cdots ,{{x}^{(m)}}$ $m$ ${{y}^{(1)}},{{y}^{(2)}},\cdots ,{{y}^{(m)}}$ 这一结果？

3.4.3极大似然估计

${{y}^{(1)}},{{y}^{(2)}},\cdots ,{{y}^{(m)}}$ 这样一个结果最容易出现，应该最大化如下似然函数[3]

L(W,b)=\prod\limits_{i=1}^{m}{p}({{y}^{(i)}}|{{x}^{(i)}};W,b)=\prod\limits_{i=1}^{m}{(h(}{{x}^{(i)}}){{)}^{{{y}^{(i)}}}}{{(1-h(x))}^{1-{{y}^{(i)}}}}\;\;\;\;\;\;\;\;(3.21)

$(3.21)$ 两边同时取自然对数有

\ell (W,b)\text{ }=\log L(W,b)=\sum\limits_{i=1}^{m}{\left[ {{y}^{(i)}}\log h({{x}^{(i)}})+(1-{{y}^{(i)}})\log (1-h({{x}^{(i)}})) \right]}\;\;\;\;\;\;\;\;(3.22)

注意： $\log {{a}^{b}}{{c}^{d}}=\log {{a}^{b}}+\log {{c}^{d}}=b\log a+d\log c$

$(3.21)$ $(3.22)$ $(3.22)$ $W,b$ 就是逻辑回归模型需要求解的参数。由此便得到了逻辑回归算法的目标函数

J(W,b)=-\frac{1}{m}\sum\limits_{i=1}^{m}{\left[ {{y}^{(i)}}\log h({{x}^{(i)}})+(1-{{y}^{(i)}})\log (1-h({{x}^{(i)}})) \right]}\;\;\;\;\;\;\;\;(3.23)

$(3.23)$ $(3.23)$ 。

3.4.4求解梯度

$(3.23)$ ，则必须先计算得到其关于各个参数的梯度。所以接下来就需要求解得到目标函数关于各个参数的梯度。

$J(W,b)$ $W_j$ 的梯度为

\begin{aligned} & \frac{\partial J}{\partial {{W}_{j}}}=-\frac{\partial }{\partial {{W}_{j}}}\frac{1}{m}\sum\limits_{i=1}^{m}{\left[ {{y}^{(i)}}\log h({{x}^{(i)}})+(1-{{y}^{(i)}})\log (1-h({{x}^{(i)}})) \right]} \\ & =-\frac{1}{m}\sum\limits_{i=1}^{m}{\left[ {{y}^{(i)}}\frac{{{h}^{\prime }}({{x}^{(i)}})}{h({{x}^{(i)}})}+(1-{{y}^{(i)}})\frac{-{{h}^{\prime }}({{x}^{(i)}})}{1-h({{x}^{(i)}})} \right]} \\ & =-\frac{1}{m}\sum\limits_{i=1}^{m}{\left[ {{y}^{(i)}}\frac{g({{z}^{(i)}})(1-g({{z}^{(i)}}))}{g({{z}^{(i)}})}x_{j}^{(i)}-(1-{{y}^{(i)}})\frac{g({{z}^{(i)}})(1-g({{z}^{(i)}}))}{1-g({{z}^{(i)}})}x_{j}^{(i)} \right]} \\ & =-\frac{1}{m}\sum\limits_{i=1}^{m}{\left[ {{y}^{(i)}}(1-g({{z}^{(i)}}))-(1-{{y}^{(i)}})g({{z}^{(i)}}) \right]}x_{j}^{(i)} \\ & =-\frac{1}{m}\sum\limits_{i=1}^{m}{\left[ {{y}^{(i)}}-h({{x}^{(i)}}) \right]}x_{j}^{(i)} \end{aligned}\;\;\;\;\;\;\;\;(3.24)

$J(W,b)$ $b$ 的梯度为

\begin{aligned} & \frac{\partial J}{\partial b}=-\frac{\partial }{\partial b}\frac{1}{m}\sum\limits_{i=1}^{m}{\left[ {{y}^{(i)}}\log h({{x}^{(i)}})+(1-{{y}^{(i)}})\log (1-h({{x}^{(i)}})) \right]} \\ & =-\frac{1}{m}\sum\limits_{i=1}^{m}{\left[ {{y}^{(i)}}\frac{{{h}^{\prime }}({{x}^{(i)}})}{h({{x}^{(i)}})}+(1-{{y}^{(i)}})\frac{-{{h}^{\prime }}({{x}^{(i)}})}{1-h({{x}^{(i)}})} \right]} \\ & =-\frac{1}{m}\sum\limits_{i=1}^{m}{\left[ {{y}^{(i)}}\frac{g({{z}^{(i)}})(1-g({{z}^{(i)}}))}{g({{z}^{(i)}})}-(1-{{y}^{(i)}})\frac{g({{z}^{(i)}})(1-g({{z}^{(i)}}))}{1-g({{z}^{(i)}})} \right]} \\ & =-\frac{1}{m}\sum\limits_{i=1}^{m}{\left[ {{y}^{(i)}}(1-g({{z}^{(i)}}))-(1-{{y}^{(i)}})g({{z}^{(i)}}) \right]} \\ & =-\frac{1}{m}\sum\limits_{i=1}^{m}{\left[ {{y}^{(i)}}-h({{x}^{(i)}}) \right]} \end{aligned}\;\;\;\;\;\;\;\;(3.25)

$(3.23)(3.24)(3.25)$ 矢量化可得


xxxxxxxxxx
3
1
1 J(W,b)=-1/m * np.sum(y * np.log(h_x) + (1 - y) * np.log(1 - h_x)) 
2
2 grad_w = (1 / m) * np.matmul(X.T, (h_x - y))  # [n,m] @ [m,1]
3
3 grad_b = (1 / m) * np.sum(h_x - y)

3.4.5从零实现二分类逻辑回归

这里依旧以breast_cancer这个二分类数据集为例来建立逻辑回归模型，完整代码见Chapter03/04_implementation.py文件。

1) 预测函数

在实现整个逻辑回归的建模与求解过程前，首先需要完成假设函数和预测函数的编码，代码如下：


xxxxxxxxxx
4
1
1 def hypothesis(X, W, bias):
2
2     z = np.matmul(X, W) + bias
3
3     h_x = sigmoid(z)
4
4     return h_x

如上代码便是假设函数的实现，其中第2行代码是样本和权重的线性组合；第3行代码是通过映射函数将线性组合后的结果映射到[0,1]之间的概率值。接着便是根据一个阈值（这里默认设置为0.5，也可以是其它）将概率值转化未具体对应的类别，代码如下：


xxxxxxxxxx
4
1
1 def prediction(X, W, bias, thre=0.5):
2
2     h_x = hypothesis(X, W, bias)
3
3     y_pre = (h_x > thre) * 1#将大于阈值的True和False结果转换为1和0的标签结果
4
4     return y_pre

2) 目标函数

为了更好的观察目标函数的收敛，同样需要计算每次参数更新后的损失值，具体实现代码如下：


xxxxxxxxxx
5
1
1 def cost_function(X, y, W, bias):
2
2     m, n = X.shape
3
3     h_x = hypothesis(X, W, bias)
4
4     cost = np.sum(y * np.log(h_x) + (1 - y) * np.log(1 - h_x))
5
5     return -cost / m

3) 梯度下降

为了对整个模型进行求解，因此需要编程实现整个梯度下降的计算过程，代码如下：


xxxxxxxxxx
8
1
1 def gradient_descent(X, y, W, bias, alpha):
2
2     m, n = X.shape
3
3     h_x = hypothesis(X, W, bias)
4
4     grad_w = (1 / m) * np.matmul(X.T, (h_x - y))  # [n,m] @ [m,1]
5
5     grad_b = (1 / m) * np.sum(h_x - y)
6
6     W = W - alpha * grad_w  # 梯度下降
7
7     bias = bias - alpha * grad_b # 梯度下降
8
8     return W, bias

在上述代码中，第6-7行便是用来执行梯度下降的过程。

4) 训练模型

在完成上述各个部分函数的实现后便可以用来实现整个模型的训练过程，代码如下：


xxxxxxxxxx
9
1
1 def train(X, y, ite=200):
2
2     m, n = X.shape  # 506,13
3
3     W = np.random.uniform(-0.1, 0.1, n).reshape(n, 1)
4
4     b, alpha, costs = 0.1, 0.08, []
5
5     for i in range(ite):
6
6         costs.append(cost_function(X, y, W, b))
7
7         W, b = gradient_descent(X, y, W, b, alpha)
8
8     y_pre = prediction(X, W, b)
9
9     return costs

在上述代码中，第2行用来随机初始化权重参数, 然后通过梯度下降来进行迭代更新；第6行用来保存了参数每一次迭代更新后计算出来的损失值，并进行了返回。最后，该模型经过200次的迭代后，准确率能够在0.98左右。

根据返回后的损失值，还能画出整个训练过程中模型的收敛情况，如图3-10所示。

图3-10 逻辑回归损失函数收敛图

3.4.6从零实现多分类逻辑回归

在3.4.5节内容中，笔者从零开始实现了整个二分类逻辑回归的建模与求解过程。在接下来的这一小节中，笔者将继续介绍如何从零开始实现一个多分类的逻辑回归模型。完整代码见Chapter03/05_implementation_multi_class.py文件。

1) 载入数据集

由于是多分类任务，所以这里使用的是sklearn中的一个3分类数据集iris，具体信息在3.2.6节中已经介绍过，这里就不再赘述，载入代码如下：


xxxxxxxxxx
5
1
1 from sklearn.datasets import load_iris
2
2 def load_data():
3
3     data = load_iris()
4
4     x, y = data.data, data.target
5
5     return x, y

2) 定义二分类器

根据3.2.2节的内容可知，One-vs-all的本质就是训练多个二分类器，然后用每一个二分类器来对样本进行分类。因此这里需要定义一个函数来完成二分类器的训练，最后通过多次调用这个函数来实现多个二分类模型的训练，代码如下：


xxxxxxxxxx
8
1
1 def train_binary(X, y, iter=200):
2
2     m, n = X.shape  # 506,13
3
3     W = np.random.randn(n, 1)
4
4     b,alpha,costs = 0.3,0.5,[]
5
5     for i in range(iter):
6
6          costs.append(cost_function(X, y, W, b))
7
7          W, b = gradient_descent(X, y, W, b, alpha)
8
8     return costs, W, b

从上述代码可以看出，其整体上同3.4.5中训练模型部分的代码一致，只是这里还额外的返回了训练好的参数。

3) 训练多分类模型

在完成上述两部分的代码后就可以进行整个多分类模型的训练了，代码如下：


xxxxxxxxxx
12
1
 1 def train(x, y, iter=1000):
2
 2     class_type = np.unique(y)
3
 3     costs, W, b = [], [], []
4
 4     for c in class_type:      
5
 5          label = (y == c) * 1
6
 6          tmp = train_binary(x, label, iter=iter)
7
 7          costs.append(tmp[0])  
8
 8          W.append(tmp[1])      
9
 9          b.append(tmp[2])
10
10     y_pre = prediction(x, W, b)
11
11     print(classification_report(y, y_pre))
12
12     return costs

在上述代码中，第2行用来判断数据集中一共有多少个类别，即需要训练多少个二分类器；第4行用来循环训练多个二分类器；第7-9行用来记录每个模型训练后的损失值和对应的权重参数。待整个模型训练完成后，便能够得到如图3-11所示的模型收敛图。

图3-11 多分类模型收敛图

从图3-11可以看出，整个模型大约在第400次迭代后就进入了收敛状态，最终也得到了0.96的准确率。

公众号后台回复“跟我一起机器学习”即可获得本文高清PDF内容与教学PPT！

3.4.7小结

在本节中，笔者首先介绍了逻辑回归中的映射函数（即Sigmoid函数）和样本分类时的概率表示；接着介绍了如何通过极大似然估计来推导得到逻辑回归模型的目标函数；然后介绍了如何根据得到的目标函数来推导各个参数关于目标函数的梯度；最后，分别从零开始介绍了如何实现二分类模型和多分类逻辑回归模型。

总结一下，如图3-12所示，在本章中笔者首先通过一个示例引入了什么是分类模型，并通过在线性回归的基础上一步步的引出了什么是逻辑回归模型；然后笔者介绍了逻辑回归从建模到利用开源库进行求解的整个过程；接着介绍了如何通过逻辑回归来完成多分类任务以及分类任务中常见的4种评价指标，并完成了阶段一的学习。最后，笔者通过本节的内容详细介绍了逻辑回归算法目标函的推导以及梯度的迭代公式等，还动手从零开始实现了逻辑回归的分类代码，进一步完成了后面两个阶段的学习。到此，对于逻辑回归的主要内容也就介绍完毕了。

图3-12 学习层次图

不过尽管如此，仍旧还有一些提升模型性能的方法（例如数据集划分、正则化等）没有阐述，这些内容笔者将在第4章中进行详细的介绍。

本次内容就到此结束，感谢您的阅读！如果你觉得上述内容对你有所帮助，欢迎分享至一位你的朋友！若有任何疑问与建议，请添加笔者微信'nulls8'或加群进行交流。青山不改，绿水长流，我们月来客栈见！

引用

[1]https://scikit-learn.org/stable.

[2]Scikit-learn: Machine Learning in Python, Pedregosa et al., JMLR 12, pp. 2825-2830, 2011.

[3]Andrew Ng, Machine Learning, Stanford University, CS229, Spring 2019.

[4]示例代码 https://github.com/moon-hotel/MachineLearningWithMe

第3章从零认识逻辑回归（附高清PDF和PPT）

于2021年11月13日2021年11月13日由空字符发布

3.1模型的建立与求解

3.1.1理解逻辑回归模型

3.1.2建立逻辑回归模型

3.1.3求解逻辑回归模型

3.1.4逻辑回归示例代码

3.1.5小结

3.2多变量与多分类

3.2.1多变量逻辑回归

3.2.2多分类逻辑回归

3.2.3多分类示例代码

3.2.4小结

3.3常见的分类评估指标

3.3.1二分类场景

3.3.2二分类指标示例代码

3.3.3多分类场景

3.3.4多分类指标示例代码

3.3.5小结

3.4目标函数推导

3.4.1映射函数

3.4.2概率表示

3.4.3极大似然估计

3.4.4求解梯度

3.4.5从零实现二分类逻辑回归

3.4.6从零实现多分类逻辑回归

3.4.7小结

引用

Sklearn学习指南

详解机器学习中的Precision-Recall曲线

Sklearn学习指南

集成学习与随机森林

机器学习

CART生成与剪枝算法

第3章 从零认识逻辑回归（附高清PDF和PPT）

于2021年11月13日2021年11月13日由 空字符 发布

3.1模型的建立与求解

3.1.1理解逻辑回归模型

3.1.2建立逻辑回归模型

3.1.3求解逻辑回归模型

3.1.4逻辑回归示例代码

3.1.5小结

3.2多变量与多分类

3.2.1多变量逻辑回归

3.2.2多分类逻辑回归

3.2.3多分类示例代码

3.2.4小结

3.3常见的分类评估指标

3.3.1二分类场景

3.3.2二分类指标示例代码

3.3.3多分类场景

3.3.4多分类指标示例代码

3.3.5小结

3.4目标函数推导

3.4.1映射函数

3.4.2概率表示

3.4.3极大似然估计

3.4.4求解梯度

3.4.5从零实现二分类逻辑回归

3.4.6从零实现多分类逻辑回归

3.4.7小结

引用

相关文章

Sklearn学习指南

详解机器学习中的Precision-Recall曲线

Sklearn学习指南

集成学习与随机森林

机器学习

CART生成与剪枝算法

第3章从零认识逻辑回归（附高清PDF和PPT）

于2021年11月13日2021年11月13日由空字符发布