KLucenの启示录

人工智能发展史#

治学先治史，我们简单回顾一下人工智能发展史上的里程碑事件，对于比较久远的历史，我们只简单提一些重要的时间节点，我们把重点放在最近几年的重大事件上。

说明：上图来自于AMiner网站，按照该网站的要求，在引用上图需要引用下面的论文。需要高清原图的，也可以在该网站上获取。

Jie Tang, Jing Zhang, Limin Yao, Juanzi Li, Li Zhang, and Zhong Su. ArnetMiner: Extraction and Mining of Academic Social Networks. In Proceedings of the Fourteenth ACM SIGKDD International Conference on Knowledge Discovery and Data Mining (SIGKDD’2008). pp.990-998.

1. 1950年，艾伦·图灵发表了一篇划时代的论文，文中预言了创造出具有智能的机器的可能性并提出了著名的图灵测试。图灵测试旨在通过计算机与人类进行对话，如果计算机能够使人类无法区分回答问题的是机器还是人类，就认为该计算机具有智能。
2. 1956年，达特茅斯会议召开，该会议被认为是人工智能的诞生标志。会议上约翰·麦卡锡、马文·明斯基、克劳德·香农等人提出了人工智能的研究议程。达特茅斯会议的几位主要参与者也被后人誉为“人工智能七侠”，包括约翰·麦卡锡、马文·明斯基、阿伦·纽厄尔、赫伯特·西蒙、克劳德·香农、奥利弗·塞尔弗里奇和内森·罗切斯特，他们为人工智能的发展奠定了基础，其中有五个人获得了图灵奖。
3. 1957年，弗兰克·罗森布拉特提出了感知机模型，这是最早的神经网络模型之一，用于解决二分类问题。
4. 1958年，约翰·麦卡锡开发了 LISP 编程语言，这种语言特别适合于符号处理，成为早期 AI 研究的主要编程语言。
5. 1980年，卡内基梅隆大学为 DEC 公司设计了一个名为 XCON 的专家系统，每年为公司省下约四千万美元的开销。由于专家系统在 DEC 公司取得了巨大的成功，全世界有很多公司都开始研发和应用专家系统。
6. 1982年，物理学家约翰·霍普菲尔德证明一种新型的神经网络（后被称为“Hopfield网络”）能够用一种全新的方式学习和处理信息。
7. 1986年，杰弗里·辛顿及其团队提出了反向传播算法，解决了训练深层神经网络的难题，神经网络相关的方法论再次受到关注。这一突破使得神经网络在各类任务中表现优异，成为机器学习的重要工具。
8. 1997年，IBM 开发的国际象棋程序 Deep Blue 战胜了国际象棋世界冠军传奇棋手卡斯帕罗夫。
9. 2011年，IBM 开发的能够使用自然语言来回答问题的人工智能系统在综艺节目《危险边缘》中打败了最高奖金得主布拉德·鲁特尔和连胜纪录保持者肯·詹宁斯，赢得了100万美元的奖金。
10. 2012年，杰弗里·辛顿和他的学生在 ImageNet 竞赛中使用深度卷积神经网络（CNN）获得了巨大成功，标志着深度学习的兴起。随后，深度学习在图像识别、语音识别、自然语言处理等领域取得了显著进展。
11. 2016年，谷歌 DeepMind开发的 AlphaGo 战胜了围棋世界冠军李世乭，展示了深度学习和蒙特卡洛树搜索技术的强大能力。
12. 2017年，谷歌的研究人员提出了 Transformer 模型，彻底改变了自然语言处理领域。Transformer 模型基于自注意力机制，大大提高了序列建模的效率和效果。后面的 BERT、GPT 等模型都是基于 Transformer 架构。
13. 2018年，OpenAI 开发的 AI 系统 OpenAI Five 在多人在线战术竞技游戏《Dota 2》中击败了半专业和专业玩家团队。
14. 2019年，OpenAI 发布了 GPT-2，一个具有15亿参数的语言模型，展示了生成高质量自然语言文本的能力。同年，DeepMind 开发的 AlphaStar 在实时战略游戏《星际争霸II》中击败了人类顶级选手。
15. 2020年，OpenAI 发布了 GPT-3，一个具有1750亿参数的语言模型，是当时最大的语言模型，GPT-3 在生成自然语言文本、翻译、编写代码等任务中表现出色，推动了自然语言处理和生成模型的进一步发展。同年，DeepMind 的 AlphaFold 2 在蛋白质结构预测的 CASP 竞赛中取得了突破性成果，预测精度达到了实验级别，这一成就被认为是生物学领域的重大突破，有望推动药物研发和生物学研究的进步。
16. 2021年，OpenAI 发布了 DALL-E，这个模型能够根据文本描述生成图像，展示了生成模型在多模态学习和图像生成中的潜力。同年，OpenAI 发布了 Codex，一个可以理解和生成代码的语言模型，是 Copilot 的核心技术。
17. 2023年，OpenAI 推出了基于 GPT-4 的 ChatGPT，可以进行更自然、更流畅的对话。随后，国内外行业巨头纷纷入局大模型，各种各样的大模型应用遍地开花。
18. 2024年，OpenAI 在 DALL-E 的基础上推出了 Sora，一个可以通过文本描述生成视频的人工智能模型。几天后，一家名为 Cognition AI 的初创公司推出了第一位 AI 软件工程师 Devin。

人工智能自图灵测试和达特茅斯会议以来，经历了多次的高潮和低谷。目前，受益于由于计算机运算和存储能力的飞速提升，从前很多难以实现的技术都成为了现实，而人工智能也又一次被推到了风口浪尖。从早期的专家系统到今天的大模型，AI 技术还在不断的演进和突破。无论是 AlphaGo 攻占了人类智慧的最后高地，还是自动驾驶技术的逐渐普及，又或是人工智能内容生成（AIGC）的广泛应用，你可以清楚的感受到，人工智能正在改变我们的生活。

什么是机器学习#

人类通过记忆和归纳这两种方式进行学习，通过记忆可以积累单个事实，使用归纳可以从旧的事实推导出新的事实。机器学习是赋予机器从数据中学习知识的能力，这个过程并不需要人类的帮助（给出明确的规则），也就是说机器学习关注的是从数据中学习一种模式（pattern），即便数据本身存在问题（噪声），这也是机器学习算法和传统算法最根本的区别。传统的算法需要计算机被告知如何从复杂系统中找到答案，算法利用计算机的运算能力去寻找最佳结果。传统算法最大的缺点就是人类必须首先知道最佳的解决方案是什么，而机器学习算法并不需要人类告诉模型最佳解决方案，取而代之的是，我们提供和问题相关的示例数据。

我们可以把需要计算机解决的问题分为四类，分类的依据一方面是输入是精确的还是模糊的，另一方面是输出是最优的还是满意的，我们可以制作出如下所示的表格。可以看出，传统算法擅长解决的只有第一类问题，而机器学习比较擅长解决第三类和第四类问题；第二类问题基本属于 NP 问题（非确定性多项式时间问题），包括旅行经销商问题、图着色问题、集合覆盖问题等，我们通常会采用启发式算法（如模拟退火算法、遗传算法等）或近似算法来解决这类问题，当然机器学习算法也可以为这类问题提供满意解。

当然，机器学习算法并非完美到无懈可击。在通过数据训练模型时，我们需要使用预处理和清洗后的数据，如果数据本身质量非常糟糕，我们也很难训练出一个好的模型，这也是我们经常说到的 GIGO（Garbage In Garbage Out）。如果要使用机器学习，我们还得确定变量之间是否存在某种关系，机器学习无法处理不存在任何关系的数据。大多数时候，机器学习模型输出的是一系列的数字和指标，需要人类解读这些数字和指标并做出决策，判定模型的好坏并决定模型如何在实际的业务场景中落地。通常，我们用来训练模型的数据会存在噪声数据（noisy data），很多机器学习模型对噪声都非常敏感，如果不能处理好这些噪声数据，我们就不太容易得到好的模型。

机器学习的应用领域#

即使对于机器学习这个概念不那么熟悉，但是机器学习的成果已经广泛渗透到了生产生活的各个领域，下面的这些场景对于你来说一定不陌生。

场景1：搜索引擎会根据搜索和使用习惯，优化下一次搜索的结果。

场景2：电商网站会根据你的访问历史自动推荐你可能感兴趣的商品。

场景3：金融类产品会通过你最近的金融活动信息综合评定你的贷款申请。

场景4：视频和直播平台会自动识别图片和视频中有没有不和谐的内容。

场景5：智能家电和智能汽车会根据你的语音指令做出相应的动作。

简单的总结一下，机器学习可以应用到但不限于以下领域：

机器学习的分类#

机器学习模型可以按照不同的标准进行分类，主要包括以下几种：

按照学习方式分类#

1. 监督学习（Supervised Learning）

   • 回归（Regression）：用于预测连续值的模型，例如线性回归、Ridge 回归、Lasso 回归等。
   • 分类（Classification）：用于预测离散类别的模型，例如逻辑回归、支持向量机、决策树、随机森林、k近邻、朴素贝叶斯等。

2. 无监督学习（Unsupervised Learning）

   • 聚类（Clustering）：用于将数据分组的模型，例如K均值聚类、层次聚类、DBSCAN 等。
   • 降维（Dimensionality Reduction）：用于减少特征数量的模型，例如主成分分析（PCA）、线性判别分析（LDA）、t分布随机近邻嵌入（t-SNE）等。
   • 关联规则学习（Association Rule Learning）：用于发现数据集中项之间关系的模型，例如 Apriori 算法、Eclat 算法等。

3. 半监督学习（Semi-Supervised Learning）

   • 结合了监督学习和无监督学习的方法，使用大量未标记的数据和少量标记的数据来构建模型。

4. 强化学习（Reinforcement Learning）

   • 基于奖励机制的学习方法，例如Q-Learning、深度Q网络（DQN）、策略梯度方法等。

机器学习的步骤#

机器学习的实施步骤通常分为多个阶段，从问题定义、数据准备到模型部署和维护，每个步骤都非常重要，具体如下所示。

1. 定义问题。首先我们需要做业务理解，明确问题的性质和类型，这个会直接影响到后续的数据收集、特征工程、选择算法以及评估指标的确定。

2. 数据收集。机器学习模型的训练需要大量的数据，这些数据可能包含结构化数据（数据库、Excel 电子表格等）、非结构化数据（文本、图像、音频、视频等）、其他类型的数据集。

3. 数据清洗。数据清洗要确保数据质量高且适合模型训练，具体包括：缺失值和异常值处理、数据标准化和归一化、特殊编码、特征工程等。

4. 数据划分。为了评估机器学习模型的泛化能力，需要将数据划分为训练集和测试集。除此以外，还可能使用交叉验证的方式将数据分成多个子集，每个子集轮流作为验证集，从而对模型的超参数进行调整。

5. 模型选择。针对分类问题、回归问题、聚类问题、深度学习，我们选择的机器学习算法或模型是不一样的。

6. 模型训练。使用训练集对模型进行训练，使模型能够学习到输入特征与目标之间的关系。此外，每个机器学习算法都有超参数，这些参数需要根据数据和任务来调优。

7. 模型评估。模型评估主要的目标是确定模型在新数据（测试集）上的表现，确保模型没有出现过拟合（overfitting）或欠拟合（underfitting），如下图所示。欠拟合会导致模型的预测效果糟糕，而过拟合会导致模型缺乏泛化能力，即在测试集和新数据上表现欠佳。当然，为了提高模型的性能或适应性，可能还要通过正则化、集成学习、算法调整等方式进行调优。

   

8. 模型部署。当你对模型的性能感到满意时，可以将模型部署到生产环境中，进行实时预测或批量预测。我们通过监控模型在实际应用中的表现，确保其持续保持较好的预测效果。如果模型性能下降，可能需要重新训练或调整。

9. 模型维护。机器学习模型不是一成不变的，随着时间的推移，模型可能需要通过重新训练、增量学习等方式来维持其性能。

说明：如果对上面出现的概念不是很理解，可以先跳过去，我们会在遇到这些问题的时候展开讲解。

第一次机器学习#

下面，我们用一个极为简单的例子带大家开启第一次机器学习之旅。当然，作为本课的第一个案例，我们并没有严格执行上面提到的机器学习的实施步骤，我们只想通过这个例子对机器学习有一个感性的认知，消除机器学习在很多人心中的“神秘感”。为了研究某城市某类消费者每月收入和每月网购支出的关系，我们收集到了50条样本数据（后面我们统称为历史数据），分别保存在两个列表中，如下所示。

1
# 每月收入
2
x = [9558, 8835, 9313, 14990, 5564, 11227, 11806, 10242, 11999, 11630,
3
     6906, 13850, 7483, 8090, 9465, 9938, 11414, 3200, 10731, 19880,
4
     15500, 10343, 11100, 10020, 7587, 6120, 5386, 12038, 13360, 10885,
5
     17010, 9247, 13050, 6691, 7890, 9070, 16899, 8975, 8650, 9100,
6
     10990, 9184, 4811, 14890, 11313, 12547, 8300, 12400, 9853, 12890]
7
# 每月网购支出
8
y = [3171, 2183, 3091, 5928, 182, 4373, 5297, 3788, 5282, 4166,
9
     1674, 5045, 1617, 1707, 3096, 3407, 4674, 361, 3599, 6584,
10
     6356, 3859, 4519, 3352, 1634, 1032, 1106, 4951, 5309, 3800,
11
     5672, 2901, 5439, 1478, 1424, 2777, 5682, 2554, 2117, 2845,
12
     3867, 2962,  882, 5435, 4174, 4948, 2376, 4987, 3329, 5002]

我们假设月收入和月网购支出都来自于正态总体，接下来我们可以通过计算皮尔逊相关系数来判定两组数据是否存在相关性，代码如下所示。如果对相关性和相关系数不理解，可以移步到我的《数据思维和统计思维》专栏看看。

1
import numpy as np
2

3
np.corrcoef(x, y)

输出：

1
array([[1.        , 0.94862936],
2
       [0.94862936, 1.        ]])

可以看出该城市该类人群的月收入和月网购支出之间存在强正相关性（相关系数为0.94862936）。当然，计算皮尔逊相关系数也可以使用 scipy 中的stats.pearsonr函数，该函数在计算相关系数的同时，还会给出统计检验的 P 值，我们可以根据 P 值来判定相关性是否显著，代码如下所示。

1
from scipy import stats
2

3
stats.pearsonr(x, y)

输出：

1
PearsonRResult(statistic=0.9486293572644154, pvalue=1.2349851929268588e-25)

上面，我们已经确认了月收入和月网购支出之间存在强相关性，那么一个很自然的想法就是通过某人的月收入来预测他的月网购支出，反过来当然也是可以的。为了做到这一点，可以充分利用我们收集到的历史数据，让计算机通过对数据的“学习”获得相应的知识，从而实现对未知状况的预测。我们可以将上述数据中的 $\small{X}$ 称为自变量或特征（feature），将 $\small{y}$ 称为因变量或目标值（target），机器学习的关键就是要通过历史数据掌握如何实现从特征到目标值的映射。

1
sample_data = {key: value for key, value in zip(x, y)}

1
import heapq
2
import statistics
3

4

5
def predict_by_knn(history_data, param_in, k=5):
6
    """用kNN算法做预测
7
    :param history_data: 历史数据
8
    :param param_in: 模型的输入
9
    :param k: 邻居数量（默认值为5）
10
    :return: 模型的输出（预测值）
11
    """
12
    neighbors = heapq.nsmallest(k, history_data, key=lambda x: (x - param_in) ** 2)
13
    return statistics.mean([history_data[neighbor] for neighbor in neighbors])

1
incomes = [1800, 3500, 5200, 6600, 13400, 17800, 20000, 30000]
2
for income in incomes:
3
    print(f'月收入: {income:>5d}元, 月网购支出: {predict_by_knn(sample_data, income):>6.1f}元')

1
月收入:  1800元, 月网购支出:  712.6元
2
月收入:  3500元, 月网购支出:  712.6元
3
月收入:  5200元, 月网购支出:  936.0元
4
月收入:  6600元, 月网购支出: 1487.0元
5
月收入: 13400元, 月网购支出: 5148.6元
6
月收入: 17800元, 月网购支出: 6044.4元
7
月收入: 20000元, 月网购支出: 6044.4元
8
月收入: 30000元, 月网购支出: 6044.4元

回归模型#

我们换一种思路来预测网购支出，我们将月收入和月网购支出分别作为横纵坐标来绘制散点图。既然网购支出跟月收入之间存在强正相关，这就意味着可以找一条直线来拟合这些历史数据点，我们把这条直线的方程 $\small{y = aX + b}$ 称为回归方程或回归模型，如下图所示。

现在，我们的问题就变成了如何利用收集到的历史数据计算出回归模型的斜率 $\small{a}$ 和截距 $\small{b}$ 。为了评价回归模型的好坏，也就是我们计算出的斜率和截距是否理想，我们可以先定义评判标准，一个简单且直观的评判标准就是我们将月收入 $\small{X}$ 带入回归模型，计算出月网购支出的预测值 $\small{\hat{y}}$ ，预测值 $\small{\hat{y}}$ 和真实值 $\small{y}$ 之间的误差越小，说明我们的回归模型越理想。之前我们提到过，计算误差的地方通常都需要取绝对值或者求平方，我们可以用误差平方的均值来作为评判标准，通常称之为均方误差（MSE），如下所示。

$$MSE = \frac{1}{n}{\sum_{i=1}^{n}(y_{i} - \hat{y_{i}})^{2}}$$

根据上面的公式，我们可以写出计算均方误差的函数，通常称之为损失函数。

1
import statistics
2

3

4
def get_loss(X_, y_, a_, b_):
5
    """损失函数
6
    :param X_: 回归模型的自变量
7
    :param y_: 回归模型的因变量
8
    :param a_: 回归模型的斜率
9
    :param b_: 回归模型的截距
10
    :return: MSE（均方误差）
11
    """
12
    y_hat = [a_ * x + b_ for x in X_]
13
    return statistics.mean([(v1 - v2) ** 2 for v1, v2 in zip(y_, y_hat)])

能让 MSE 达到最小的 $\small{a}$ 和 $\small{b}$ ，我们称之为回归方程的最小二乘解，接下来的工作就是要找到这个最小二乘解。简单的说，我们要将可能的 $\small{a}$ 和 $\small{b}$ 带入损失函数，看看什么样的 $\small{a}$ 和 $\small{b}$ 能让损失函数取到最小值。如果对 $\small{a}$ 和 $\small{b}$ 的取值一无所知，我们可以通过不断产生随机数的方式来寻找 $\small{a}$ 和 $\small{b}$ ，这种方法称为蒙特卡洛模拟，通俗点说就是随机瞎蒙，代码如下所示。

1
import random
2

3
# 先将最小损失定义为一个很大的值
4
min_loss, a, b = 1e12, 0, 0
5

6
for _ in range(100000):
7
    # 通过产生随机数的方式获得斜率和截距
8
    _a, _b = random.random(), random.uniform(-2000, 2000)
9
    # 带入损失函数计算回归模型的MSE
10
    curr_loss = get_loss(x, y, _a, _b)
11
    if curr_loss < min_loss:
12
        # 找到更小的MSE就记为最小损失
13
        min_loss = curr_loss
14
        # 记录下当前最小损失对应的a和b
15
        a, b = _a, _b
16

17
print(f'MSE = {min_loss}')
18
print(f'{a = }, {b = }')

上面的代码进行了100000次的模拟， $\small{a}$ 的值在 $\small[0, 1)$ 范围随机选择，$\small{b}$ 的值在 $\small{[-2000, 2000)}$ 范围随机选择的，下面是在我的电脑上跑出来的结果。大家可以把自己蒙特卡罗模拟的结果分享到评论区，看看谁的运气更好，找到了让误差更小的 $\small{a}$ 和 $\small{b}$ 。

1
MSE = 270690.1419424315
2
a = 0.4824040159203802, b = -1515.0162977046068

对于数学知识比较丰富的小伙伴，我们可以将回归模型带入损失函数，由于 $\small{X}$ 和 $\small{y}$ 是已知的历史数据，那么损失函数其实是一个关于 $\small{a}$ 和 $\small{b}$ 的二元函数，如下所示。

$$MSE = f(a, b) = \frac{1}{n}{\sum_{i=1}^{n}(y_{i} - (ax_{i} + b))^{2}}$$

根据微积分的极值定理，我们可以对 $\small{f(a, b)}$ 求偏导数，并令其等于0，这样我们就可以计算让 $\small{f(a, b)}$ 取到最小值的 $\small{a}$ 和 $\small{b}$ 分别是多少，即：

$$\frac{\partial{f(a, b)}}{\partial{a}} = -\frac{2}{n}\sum_{i=1}^{n}x_{i}(y_{i} - x_{i}a - b) = 0$$$$\frac{\partial{f(a, b)}}{\partial{b}} = -\frac{2}{n}\sum_{i=1}^{n}(y_i - x_{i}a - b) = 0$$

求解上面的方程组可以得到：

$$a = \frac{\sum(x_{i} - \bar{x})(y_{i} - \bar{y})}{\sum(x_{i} - \bar{x})^{2}}$$$$b = \bar{y} - a\bar{x}$$

需要说明的是，如果回归模型本身比较复杂，不像线性模型 $\small{y = aX + b}$ 这么简单，可能没有办法像上面那样直接求解方程，而是要通过其他的方式来找寻极值点，这个我们会在后续的内容中会为大家讲解。回到刚才的问题，我们可以通过上面的公式计算出 $\small{a}$ 和 $\small{b}$ 的值，为了运算方便，下面直接使用了 NumPy 中的函数，因为 NumPy 中的运算都是矢量化的，通常不需要我们自己写循环结构，对 NumPy 不熟悉的小伙伴，可以移步到我的《基于Python的数据分析》专栏。

1
import numpy as np
2

3
x_bar, y_bar = np.mean(x), np.mean(y)
4
a = np.dot((x - x_bar), (y - y_bar)) / np.sum((x - x_bar) ** 2)
5
b = y_bar - a * x_bar
6
print(f'{a = }, {b = }')

输出：

1
a = 0.482084452824066, b = -1515.2028590756745

事实上，NumPy 库中还有封装好的函数可以帮我们完成参数拟合，你可以使用linalg模块的lstsq函数来计算最小二乘解，也可以使用polyfit函数或Polynomial类型的fit方法来获得最小二乘解，代码如下所示。大家可以看看，跟上面求偏导数找极值点获得的结果是否相同。

1
a, b = np.polyfit(x, y, deg=1)
2
print(f'{a = }, {b = }')

或

1
from numpy.polynomial import Polynomial
2

3
b, a = Polynomial.fit(x, y, deg=1).convert().coef
4
print(f'{a = }, {b = }')

说明：上面代码中的deg参数代表多项式的最高次项是几次项，deg=1说明我们使用的是线性回归模型。

小结#

首先，希望本篇内容能对大家了解机器学习有那么一点点帮助；其次，希望通过本章向大家传达一个理念，自己手撕机器学习的代码比直接调用三方库弄出一个结果来其实更有意思，它会让你对算法原理、应用场景、利弊情况等都有一个更好的认知。

距离的度量#

我们可以用距离（distance）来衡量特征空间中两个实例之间的相似度，常用的距离度量包括闵氏距离、马氏距离、余弦距离、编辑距离等。闵氏距离全称闵可夫斯基距离（Minkowski Distance），对于两个 $\small{n}$ 维向量 $\small{\mathbf{x}=(x_{1}, x_{2}, \cdots, x_{n})}$ 和 $\small{\mathbf{y}=(y_{1}, y_{2}, \cdots, y_{n})}$ ，它们之间的距离可以定义为：

其中， $\small{p \ge 1}$ ，虽然 $\small{p \lt 1}$ 可以计算，但不再严格满足距离的定义，通常不被视为真正的距离。

当 $\small{p = 1}$ 时，闵氏距离即曼哈顿距离：

当 $\small{p = 2}$ 时，闵氏距离即欧几里得距离：

当 $\small{p \to \infty}$ 时，闵氏距离即切比雪夫距离：

其他的距离度量方式我们等用到的时候再为大家介绍。在使用 k 最近邻算法做分类时，我们的数据集通常都是数值型数据，此时直接使用欧几里得距离是一个不错的选择。

数据集介绍#

接下来为大家隆重介绍一下我们后续会使用到的一个重要的数据集——鸢尾花数据集（iris dataset）。鸢尾花数据集是机器学习领域中最著名、最经典的数据集之一，由植物学家 Edgar S. Anderson 在加拿大魁北克加斯帕半岛采集，由英国统计学家 Ronald A. Fisher 于 1936 年在他的论文*《The Use of Multiple Measurements in Taxonomic Problems》*中首次引入，被广泛用于机器学习算法的入门和实验。

鸢尾花数据集共有 150 条样本，其中包含 3 种类型的鸢尾花，分别是山鸢尾（Iris setosa）、多彩鸢尾（Iris versicolor）和为吉尼亚鸢尾（Iris virginica），如上图所示，每种各有50条样本。样本数据包含了 4 个特征（features）和 1 个类别标签（class label），4 个特征分别是花萼长度（Sepal length）、花萼宽度（Sepal width）、花瓣长度（Petal length）、花瓣宽度（Petal width），都是以厘米为单位的正数，数据集中的类别标签有 0、1、2 三个值，对应上面提到的三种鸢尾花类型。

数据集的加载#

我们可以通过著名的 Python 机器学习库 scikit-learn 来加载这个数据集，scikit-learn 包含了各种分类、回归、聚类算法，同时还提供了多层感知机、支持向量机、随机森林等模型，覆盖了从数据预处理、特征工程到模型训练、模型评估和参数调优等各项功能，如下图所示。我们推荐大家使用这个库来完成机器学习中的各种操作，scikit-learn 的官方网站上面还提供了用户指南、API 文档和案例等内容，有兴趣的读者可以自行访问。

由于我们后续的课程基本都会用到这个库，大家可以先通过下面的命令安装这个库。

1
pip install scikit-learn

如果你已经打开了 IPython 或 Jupyter 但尚未安装 scikit-learn，可以通过下面的魔法指令来安装这个库。

1
%pip install scikit-learn

在安装完成之后，我们可以通过下面的代码加载鸢尾花数据集并查看该数据集的介绍。

1
from sklearn.datasets import load_iris
2

3
# 加载鸢尾花数据集
4
iris = load_iris()
5
# 查看数据集的介绍
6
print(iris.DESCR)

接下来，我们可以获得数据集中的特征和标签，代码如下所示。

1
# 特征（150行4列的二维数组，分别是花萼长、花萼宽、花瓣长、花瓣宽）
2
X = iris.data
3
# 标签（150个元素的一维数组，包含0、1、2三个值分别代表三种鸢尾花）
4
y = iris.target

如果希望更直观的查看鸢尾花数据集，我们可以用上面获得的特征和标签来创建一个 DataFrame 对象，有兴趣的读者可以自己试一试。

1
# 将特征和标签堆叠到同一个数组中
2
data = np.hstack((X, y.reshape(-1, 1)))
3
# 通过随机乱序函数将原始数据打乱
4
np.random.shuffle(data)
5
# 选择80%的数据作为训练集
6
train_size = int(y.size * 0.8)
7
train, test = data[:train_size], data[train_size:]
8
X_train, y_train = train[:, :-1], train[:, -1]
9
X_test, y_test = test[:, :-1], test[:, -1]

1
from sklearn.model_selection import train_test_split
2

3
X_train, X_test, y_train, y_test = train_test_split(X, y, train_size=0.8, random_state=3)

kNN分类的实现#

下面我们先不用 scikit-learn 而是用基础的数据科学库 NumPy 和 SciPy 来实现 kNN 算法，这样做的目的是帮助大家更好的理解算法原理，在此基础上我们再感受 scikit-learn 的强大并明白其中类、函数、参数等为什么要如此设定。

1
import numpy as np
2

3

4
def euclidean_distance(u, v):
5
    """计算两个n维向量的欧式距离"""
6
    return np.sqrt(np.sum(np.abs(u - v) ** 2))

1
from scipy import stats
2

3

4
def make_label(X_train, y_train, X_one, k):
5
    """
6
    根据历史数据中k个最近邻为新数据生成标签
7
    :param X_train: 训练集中的特征
8
    :param y_train: 训练集中的标签
9
    :param X_one: 待预测的样本（新数据）特征
10
    :param k: 邻居的数量
11
    :return: 为待预测样本生成的标签（邻居标签的众数）
12
    """
13
    # 计算x跟每个训练样本的距离
14
    distes = [euclidean_distance(X_one, X_i) for X_i in X_train]
15
    # 通过一次划分找到k个最小距离对应的索引并获取到相应的标签
16
    labels = y_train[np.argpartition(distes, k - 1)[:k]]
17
    # 获取标签的众数
18
    return stats.mode(labels).mode

1
def predict_by_knn(X_train, y_train, X_new, k=5):
2
    """
3
    KNN算法
4
    :param X_train: 训练集中的特征
5
    :param y_train: 训练集中的标签
6
    :param X_new: 待预测的样本构成的数组
7
    :param k: 邻居的数量（默认值为5）
8
    :return: 保存预测结果（标签）的数组
9
    """
10
    return np.array([make_label(X_train, y_train, X, k) for X in X_new])

1
y_pred = predict_by_knn(X_train, y_train, X_test)
2
y_pred == y_test

1
array([ True,  True,  True,  True,  True,  True,  True,  True,  True,
2
        True,  True,  True,  True,  True,  True,  True, False,  True,
3
        True,  True,  True,  True,  True,  True,  True,  True,  True,
4
        True,  True,  True])

1
from sklearn.neighbors import KNeighborsClassifier
2

3
# 创建模型
4
model = KNeighborsClassifier()
5
# 训练模型
6
model.fit(X_train, y_train)
7
# 预测结果
8
y_pred = model.predict(X_test)

1
y_pred == y_test

1
array([ True,  True,  True,  True,  True,  True,  True,  True,  True,
2
        True,  True,  True,  True,  True,  True,  True, False,  True,
3
        True,  True,  True,  True,  True,  True,  True,  True,  True,
4
        True,  True,  True])

1
model.score(X_test, y_test)

1
0.9666666666666667

模型评估#

当然，评价一个分类器的预测效果是否良好，不能只简单的看一下准确率，因为在类别不平衡的情况下，准确率很可能会误导你的判断。例如，我们的测试数据中维吉尼亚鸢尾花的样本数量非常小，那么即便我们的模型根本无法判断维吉尼亚鸢尾花，模型也会表现出很高的准确率。所以，我们还要考察查准率（精确率）、查全率（召回率）、F1 分数等指标，而混淆矩阵则是用于详细展示分类模型性能的工具，适用于二分类和多分类任务，二分类问题的混淆矩阵如下所示。

我们举一个例子来说明如何使用混淆矩阵并计算出分类模型的评估指标。假设某种医学检测系统的目标预测是否患有某种疾病，类别“正类”表示“患病”，类别“负类”表示“未患病”，1000个样本的测试结果如下所示。

1. 准确率（Accuracy）。

上面的例子，模型预测的准确率为： $\frac{80 + 870}{80 + 30 + 20 + 870} = \frac{950}{1000} = 0.95$ 。

2. 精确率（Precesion）。精确率用于衡量在所有被预测为正类的样本中，实际上属于正类的比例，通常也被称为查准率。

上面的例子，模型预测的精确率为： $\frac{80}{80 + 30} = \frac{80}{110} = 0.73$ 。

3. 召回率（Recall）。召回率用于衡量在所有实际为正类的样本中，被模型正确预测为正类的比例，通常也被称为查全率或真正例率（True Positive Rate）。

上面的例子，模型预测的召回率为： $\frac{80}{80 + 20} = \frac{80}{100} = 0.8$ 。

4. F1 分数（F1 Score）。F1 分数是精确率和召回率的调和平均数，它在精确率和召回率之间寻求一个平衡，尤其适用于在两者之间有权衡的情况。

上面的例子，模型预测的F1 分数为： $2 \times \frac{0.7273 * 0.8}{0.7273 + 0.8} = 0.76$ 。

5. 特异度（Specificity）和假正例率（False Positive Rate，简称 FPR）。特异度用于衡量的是在所有实际为负类的样本中，被模型正确预测为负类的比例，类似于召回率，只不过针对的是负类样本。

上面的例子，模型预测的特异度为： $\frac{870}{870 + 30} = \frac{870}{900} = 0.97$ 。

6. ROC 和 AUC。

   • ROC（Receiver Operating Characteristic Curve）绘制了召回率与假正例率的关系，如下图所示。

     

   • AUC（Area Under the Curve）是 ROC 曲线下的面积，衡量模型区分正类和负类的能力。AUC 值的范围是 $\small[0, 1]$ ，值越接近 1，表示模型区分正负类的能力越强。0.5 < AUC < 1，说明我们的模型优于随机猜测，只要这个分类器（模型）妥善设置阈值的话，就有预测价值。AUC = 0.5，说明我们的模型跟随机猜测一样，模型没有预测价值。AUC < 0.5，模型比随机猜测还差，但只要总能反向预测，它的实际效果就优于随机猜测。

对于多分类问题，混淆矩阵的行数和列数都等于类别数，混淆矩阵是一个方阵，也就是说如果有 $\small{n}$ 个类别，那么混淆矩阵就是一个 $\small{n \times n}$ 的方阵。根据上面我们得到的鸢尾花数据集的预测结果，我们先输出真实值和预测值，然后制作对应的混淆矩阵，如下所示。

1
print(y_test)
2
print(y_pred)

输出：

1
[0 0 0 0 0 2 1 0 2 1 1 0 1 1 2 0 1 2 2 0 2 2 2 1 0 2 2 1 1 1]
2
[0 0 0 0 0 2 1 0 2 1 1 0 1 1 2 0 2 2 2 0 2 2 2 1 0 2 2 1 1 1]

我们可以用 scikit-learn 中的confusion_matrix和classification_report函数来输出混淆矩阵和评估报告，代码如下所示。

1
from sklearn.metrics import classification_report, confusion_matrix
2

3
# 输出分类模型混淆矩阵
4
print('混淆矩阵: ')
5
print(confusion_matrix(y_test, y_pred))
6
# 输出分类模型评估报告
7
print('评估报告: ')
8
print(classification_report(y_test, y_pred))

输出：

1
混淆矩阵:
2
[[10  0  0]
3
 [ 0  9  1]
4
 [ 0  0 10]]
5
评估报告:
6
              precision    recall  f1-score   support
7

8
           0       1.00      1.00      1.00        10
9
           1       1.00      0.90      0.95        10
10
           2       0.91      1.00      0.95        10
11

12
    accuracy                           0.97        30
13
   macro avg       0.97      0.97      0.97        30
14
weighted avg       0.97      0.97      0.97        30

如果希望用可视化的方式输出混淆矩阵，可以使用如下所示的代码。

1
import matplotlib.pyplot as plt
2
from sklearn.metrics import ConfusionMatrixDisplay
3

4
# 创建混淆矩阵显示对象
5
cm_display_obj = ConfusionMatrixDisplay(confusion_matrix(y_test, y_pred), display_labels=iris.target_names)
6
# 绘制并显示混淆矩阵
7
cm_display_obj.plot(cmap=plt.cm.Reds)
8
plt.show()

说明：其中的iris.target_names就是类别标签0、1、2对应的三种鸢尾花的英文名。

对于二分类问题，如果想要绘制出 ROC 曲线并显示 AUC 值，可以使用如下所示的代码。

1
from sklearn.metrics import roc_curve, auc
2
from sklearn.metrics import RocCurveDisplay
3

4
# 手动构造一组真实值和对应的预测值
5
y_test_ex = np.array([0, 0, 0, 1, 1, 0, 1, 1, 1, 0])
6
y_pred_ex = np.array([1, 0, 0, 1, 1, 0, 1, 1, 0, 1])
7
# 通过roc_curve函数计算出FPR（假正例率）和TPR（真正例率）
8
fpr, tpr, _ = roc_curve(y_test_ex, y_pred_ex)
9
# 通过auc函数计算出AUC值并通过RocCurveDisplay类绘制图形
10
RocCurveDisplay(fpr=fpr, tpr=tpr, roc_auc=auc(fpr, tpr)).plot()
11
plt.show()

参数调优#

之前我们说过，kNN 算法有两个关键问题，一是距离的度量，二是 k 值的选择。我们使用 scikit-learn 的KNeighborsClassifier创建分类器模型时，可以对模型的超参数进行设置，这里有几个比较重要的参数：

1. n_neighbors：近邻的数量，就是 kNN 算法中 k 的值。
2. weights：可以选择uniform或distance，前者表示所有样本的权重相同，后者表示距离越近权重越高，默认值是uniform。当然，我们也可以通过传入自定义的函数来确定每个样本的权重。
3. algorithm：有auto、ball_tree、kd_tree、brute四个选项，默认值为auto。其中ball_tree是一种树形结构，基于球体划分的方法将数据点分配到层次化的树结构中，在高维数据和稀疏数据场景下有较好的性能；kd_tree也是一种树形结构，通过选择一个维度将空间划分为若干个子区域再进行搜索，从而避免跟所有的邻居进行比较，对于低维度和空间分布均匀的数据，后者有较好的效果，在高维空间中会遇到的维度灾难问题；auto选项是根据输入数据的维度自动选择ball_tree或kd_tree；brute选项则是使用暴力搜索算法（穷举法），再处理小数据集时，它是一个简单且有效的选择。
4. leaf_size：使用ball_tree或kd_tree算法时，该参数用于限制树结构叶子节点最大样本数量，默认值为30，该参数会影响树的构建和节点查找的性能。
5. p：闵可夫斯基距离公式中的p，默认值为2，计算欧氏距离。

我们可以使用网格搜索（Grid Search）和交叉验证（Cross Validation）的方式对模型的超参数进行调整，评估模型的泛化能力，提升模型的预测效果。网格搜索就是通过穷举法遍历给定的超参数空间，找到最优的超参数组合；交叉验证则是将训练集分成多个子集，通过在不同的训练集和验证集上进行多次训练和评估，对模型的预测效果进行综合评判。K-Fold交叉验证是最常用的交叉验证方法，通过将数据集划分为 K 个子集，每次选取其中一个子集作为验证集，剩下的 K-1 个子集作为训练集，对每个子集重复这个过程，完成 K 次训练和评估并将平均值作为模型的最终性能评估，如下图所示。

下面的代码了 scikit-learn 库中的GridSearchCV来做网格搜索和交叉验证，通过这种方式找到针对鸢尾花数据集实施 kNN 算法的最优参数。

1
from sklearn.model_selection import GridSearchCV
2

3
# 网格搜索交叉验证
4
gs = GridSearchCV(
5
    estimator=KNeighborsClassifier(),
6
    param_grid={
7
        'n_neighbors': [1, 3, 5, 7, 9, 11, 13, 15],
8
        'weights': ['uniform', 'distance'],
9
        'p': [1, 2]
10
    },
11
    cv=5
12
)
13
gs.fit(X_train, y_train)

可以通过下面的代码获得最优参数及其评分。

1
print('最优参数:', gs.best_params_)
2
print('评分:', gs.best_score_)

输出：

1
最优参数: {'n_neighbors': 5, 'p': 2, 'weights': 'uniform'}
2
评分: 0.9666666666666666

如果需要使用训练好的最优模型进行预测，可以按照如下所示的代码进行操作。

1
gs.predict(X_test)

kNN回归#

kNN 算法通常用于解决分类问题，当然它也可以用于解决回归问题，其基本思想也是通过找出跟新实例最近的 k 个邻居，然后根据这 k 个邻居的标签（在回归问题中我们通常称之为目标值）来预测新实例的目标值。由于我们需要预测的不是类别标签而是一个数值，所以通常会使用平均或加权平均的方式来处理 k 个邻居的目标值，从而获得对新实例目标值的预测。让我们回到上一课用月收入预测网购支出的那个例子，然后使用 scikit-learn 中的KNeighborsRegressor来构建回归模型，我们先做一些准备工作，代码如下所示。

1
# 每月收入
2
incomes = np.array([
3
    9558, 8835, 9313, 14990, 5564, 11227, 11806, 10242, 11999, 11630,
4
    6906, 13850, 7483, 8090, 9465, 9938, 11414, 3200, 10731, 19880,
5
    15500, 10343, 11100, 10020, 7587, 6120, 5386, 12038, 13360, 10885,
6
    17010, 9247, 13050, 6691, 7890, 9070, 16899, 8975, 8650, 9100,
7
    10990, 9184, 4811, 14890, 11313, 12547, 8300, 12400, 9853, 12890
8
])
9
# 每月网购支出
10
outcomes = np.array([
11
    3171, 2183, 3091, 5928, 182, 4373, 5297, 3788, 5282, 4166,
12
    1674, 5045, 1617, 1707, 3096, 3407, 4674, 361, 3599, 6584,
13
    6356, 3859, 4519, 3352, 1634, 1032, 1106, 4951, 5309, 3800,
14
    5672, 2901, 5439, 1478, 1424, 2777, 5682, 2554, 2117, 2845,
15
    3867, 2962,  882, 5435, 4174, 4948, 2376, 4987, 3329, 5002
16
])
17
X = np.sort(incomes).reshape(-1, 1)  # 将收入排序后处理成二维数组
18
y = outcomes[np.argsort(incomes)]    # 将网购支出按照收入进行排序

说明：即便只有一个特征，我们也需要将自变量处理二维数组的形式，因为我们训练模型时使用的fit方法并不能接受一维数组作为它的第一个参数。这里提前对 X 和 y 排序是为了待会绘制散点图和折线图的时候根据 X 的值从小到大依次绘制。

接下来，我们创建 kNN 回归模型。

1
from sklearn.neighbors import KNeighborsRegressor
2

3
# 创建模型
4
model = KNeighborsRegressor()
5
# 训练模型
6
model.fit(X, y)
7
# 预测结果
8
y_pred = model.predict(X)

上面我们直接用所有的历史数据进行模型训练，然后通过绘制下面的图形来看看预测效果到底如何。

1
# 原始数据散点图
2
plt.scatter(X, y, color='navy')
3
# 预测结果折线图
4
plt.plot(X, y_pred, color='coral')
5
plt.show()

kNN 回归模型计算复杂度较高，而且对噪声数据非常敏感，在很多时候它可能并不是一个很好的选择。当然，如何评估一个回归模型的效果，这个问题我们留到后续的章节再为大家进行讲解。

总结#

kNN 算法是一种简单但不失强大的机器学习算法，适用于小数据集上的分类和回归任务，它的优点是简单易懂，没有显示的训练过程，不依赖于对数据分布的假设，可以适应复杂的数据模式。当然，kNN 算法的缺点也非常明显，最大的问题在于计算效率，所以在数据集较大时可能并不是最好的选择。除此以外，kNN 算法对噪声非常敏感，同时预测结果依赖于 k 的取值和样本是否均衡（各个类别的样本数量是否大致相等），k 值过小可能导致过拟合，k值过大又可能导致欠拟合，而不均衡的样本可能会导致类别偏倚（Class Imbalance Bias），也就是说，如果大部分训练样本都属于类别 A，而类别 B 样本较少，那么在分类时，KNN 更容易将测试样本预测为类别 A。

决策树的构建#

1
import numpy as np
2

3

4
def entropy(y):
5
    """
6
    计算信息熵
7
    :param y: 数据集的目标值
8
    :return: 信息熵
9
    """
10
    _, counts = np.unique(y, return_counts=True)
11
    prob = counts / y.size
12
    return -np.sum(prob * np.log2(prob))
13

14

15
def info_gain(x, y):
16
    """
17
    计算信息增益
18
    :param x: 给定的特征
19
    :param y: 数据集的目标值
20
    :return: 信息增益
21
    """
22
    values, counts = np.unique(x, return_counts=True)
23
    new_entropy = 0
24
    for i, value in enumerate(values):
25
        prob = counts[i] / x.size
26
        new_entropy += prob * entropy(y[x == value])
27
    return entropy(y) - new_entropy

1
from sklearn.datasets import load_iris
2
from sklearn.model_selection import train_test_split
3

4
iris = load_iris()
5
X, y = iris.data, iris.target
6
X_train, X_test, y_train, y_test = train_test_split(X, y, train_size=0.8, random_state=3)
7
print(f'H(D)    = {entropy(y_train)}')
8
print(f'g(D,A0) = {info_gain(X_train[:, 0], y_train)}')
9
print(f'g(D,A1) = {info_gain(X_train[:, 1], y_train)}')
10
print(f'g(D,A2) = {info_gain(X_train[:, 2], y_train)}')
11
print(f'g(D,A3) = {info_gain(X_train[:, 3], y_train)}')

1
H(D)    = 1.584962500721156
2
g(D,A0) = 0.9430813063736728
3
g(D,A1) = 0.5692093930591595
4
g(D,A2) = 1.4475439590905472
5
g(D,A3) = 1.4420095891994646

1
def info_gain_ratio(x, y):
2
    """
3
    计算信息增益比
4
    :param x: 给定的特征
5
    :param y: 数据集的目标值
6
    :return: 信息增益比
7
    """
8
    return info_gain(x, y) / entropy(x)
9

10

11
print(f'R(D,A0) = {info_gain_ratio(X_train[:, 0], y_train)}')
12
print(f'R(D,A1) = {info_gain_ratio(X_train[:, 1], y_train)}')
13
print(f'R(D,A2) = {info_gain_ratio(X_train[:, 2], y_train)}')
14
print(f'R(D,A3) = {info_gain_ratio(X_train[:, 3], y_train)}')

1
R(D,A0) = 0.19687406476459068
2
R(D,A1) = 0.14319788821311977
3
R(D,A2) = 0.28837763858461984
4
R(D,A3) = 0.35550822529855447

1
def gini_index(y):
2
    """
3
    计算基尼指数
4
    :param y: 数据集的目标值
5
    :return: 基尼指数
6
    """
7
    _, counts = np.unique(y, return_counts=True)
8
    return 1 - np.sum((counts / y.size) ** 2)
9

10

11
def gini_with_feature(x, y):
12
    """
13
    计算给定特征后的基尼指数
14
    :param x: 给定的特征
15
    :param y: 数据集的目标值
16
    :return: 给定特征后的基尼指数
17
    """
18
    values, counts = np.unique(x, return_counts=True)
19
    gini = 0
20
    for value in values:
21
        prob = x[x == value].size / x.size
22
        gini += prob * gini_index(y[x == value])
23
    return gini
24

25

26
print(f'G(D)    = {gini_index(y_train)}')
27
print(f'G(D,A0) = {gini_with_feature(X_train[:, 0], y_train)}')
28
print(f'G(D,A1) = {gini_with_feature(X_train[:, 1], y_train)}')
29
print(f'G(D,A2) = {gini_with_feature(X_train[:, 2], y_train)}')
30
print(f'G(D,A3) = {gini_with_feature(X_train[:, 3], y_train)}')

1
G(D,A0) = 0.29187830687830685
2
G(D,A1) = 0.44222582972582963
3
G(D,A2) = 0.06081349206349207
4
G(D,A3) = 0.06249999999999998

实现决策树模型#

我们可以使用 scikit-learn 中tree模块的DecisionTreeClassifier和DecisionTreeRegressor来实现用于分类和回归的决策树，这里我们重点讨论用于解决分类问题的决策树模型，有兴趣的读者可以自行研究用于解决回归问题的决策树模型。

1
from sklearn.tree import DecisionTreeClassifier
2

3
# 创建模型
4
model = DecisionTreeClassifier()
5
# 训练模型
6
model.fit(X_train, y_train)
7
# 预测结果
8
y_pred = model.predict(X_test)

下面，我们对比一下预测值和真实值并看看模型的评估报告。

1
from sklearn.metrics import classification_report
2

3
print(y_test)
4
print(y_pred)
5
print(classification_report(y_test, y_pred))

输出：

1
[0 0 0 0 0 2 1 0 2 1 1 0 1 1 2 0 1 2 2 0 2 2 2 1 0 2 2 1 1 1]
2
[0 0 0 0 0 2 1 0 2 1 1 0 1 1 2 0 1 2 2 0 2 2 2 1 0 2 2 1 2 1]
3
              precision    recall  f1-score   support
4

5
           0       1.00      1.00      1.00        10
6
           1       1.00      0.90      0.95        10
7
           2       0.91      1.00      0.95        10
8

9
    accuracy                           0.97        30
10
   macro avg       0.97      0.97      0.97        30
11
weighted avg       0.97      0.97      0.97        30

说明：大家运行上面的代码看到的输出可能跟我这里并不相同，因为在创建DecisionTreeClassifier时有一个控制随机性的参数random_state，如果为该参数提供一个确定的整数值，就可以确保你的运行结果是可重复的。

我们可以通过下面的代码来可视化决策树，相信可视化的方式会帮助大家对决策树模型有一个更好的理解。

1
import matplotlib.pyplot as plt
2
from sklearn.tree import plot_tree
3

4
plt.figure(figsize=(12, 10))
5
plot_tree(
6
    decision_tree=model,               # 决策树模型
7
    feature_names=iris.feature_names,  # 特征的名称
8
    class_names=iris.target_names,     # 标签的名称
9
    filled=True                        # 用颜色填充
10
)
11
plt.show()

输出：

注意：上图中树的根结点的基尼指数跟我们之前计算的数据集的基尼指数完全一致。

我们调整一下DecisionTreeClassifier的参数重新创建决策树并对模型进行可视化。

1
# 创建模型
2
model = DecisionTreeClassifier(
3
    criterion='entropy',
4
    ccp_alpha=0.01,
5

6
)
7
# 训练模型
8
model.fit(X_train, y_train)
9
# 可视化
10
plt.figure(figsize=(12, 10))
11
plot_tree(
12
    decision_tree=model,               # 决策树模型
13
    feature_names=iris.feature_names,  # 特征的名称
14
    class_names=iris.target_names,     # 标签的名称
15
    filled=True                        # 用颜色填充
16
)
17
plt.show()

输出：

注意：上图中树的根结点的信息熵跟我们之前计算的数据集的信息熵完全一致。

由此可见，创建DecisionTreeClassifier对象时参数不同，生成的决策树也会存在差异。DecisionTreeClassifier构造函数的参数就是决策树模型的超参数，其中有几个非常重要的超参数：

1. criterion：特征选择（数据分裂质量评估）的标准，可以选择'gini'或'entropy'，前者代表基尼指数，也是默认值，后者代表信息增益。
2. max_depth：树的最大深度，默认值为None，如果不设置该参数，会存在过拟合风险。
3. min_samples_split：一个内部结点再次分裂所需的最小样本数，默认值为2。这个参数可以设置为整数表示最小样本数，也可以设置为浮点数，表示占总样本数的比例。
4. min_samples_leaf：叶结点所需的最小样本数，默认值为1。将该参数设置为较大的值可以平滑模型，降低过拟合风险。这个参数也可以设置为整数或浮点数，道理同上。
5. max_features：用于最佳分裂的特征数，默认值为None。这个参数可以设置为整数，表示选择固定数量的特征；可以设置为浮点数，表示选择特征的比例；可以设置为字符串，'auto'和'sqrt'表示将总的特征数量求平方根，用平方根的值作为选择特征的数量，'log2'表示将总的特征数量求对数，用对数值作为选择特征的数量。
6. class_weight：指定类别的权重，用于处理类别不平衡问题，默认值为None。可以用字典的方式手动设置每个类别的权重，也可以使用'balanced'让模型自动调整。
7. splitter：选择分裂结点的策略，默认值为'best'，表示最佳分裂，还有一个取值是'random'，表示随机分裂。
8. max_leaf_nodes：限制叶结点的最大数量，可以防止树结构过于复杂。
9. min_impurity_decrease：结点分裂所需的最小不纯度降低值，任何结点只有在不纯度减少超过此值时才会进行分裂。
10. ccp_alpha：成本复杂度剪枝中的$\small{\alpha}$参数值。这个参数用于控制后剪枝中成本复杂度计算公式中$\small{\alpha}$的值。较小的$\small{\alpha}$值允许更复杂的树，而较大的$\small{\alpha}$值倾向于选择更简单的树。通过调整$\small{\alpha}$，可以找到一个最佳的复杂度和误差之间的平衡点。

我们可以通过之前讲到的网格搜索和交叉验证的方式来对超参数进行调优，有兴趣的读者可以参考下面的代码。

1
from sklearn.model_selection import GridSearchCV
2

3
gs = GridSearchCV(
4
    estimator=DecisionTreeClassifier(),
5
    param_grid={
6
        'criterion': ['gini', 'entropy'],
7
        'max_depth': np.arange(5, 10),
8
        'max_features': [None, 'sqrt', 'log2'],
9
        'min_samples_leaf': np.arange(1, 11),
10
        'max_leaf_nodes': np.arange(5, 15)
11
    },
12
    cv=5
13
)
14
gs.fit(X_train, y_train)

随机森林概述#

随机森林是基于决策树的集成学习算法，所谓集成学习就是通过组合多个模型的预测结果来提高整体模型的性能，其核心思想就是多个模型的组合往往比单个模型更有效，通过不同的模型捕捉到数据的不同特征，从而降低模型的过拟合风险（提升模型的泛化能力）。随机森林通过构建多个决策树并将它们的预测结果进行投票（分类）或平均（回归），来提高模型的准确性和鲁棒性，如下图所示。

随机森林的基本工作流程如下：

1. Bootstrap 抽样：从原始训练数据集中随机抽取若干个样本（有放回抽样），形成多个不同的子集，每个子集用于训练一棵决策树。
2. 构建决策树：对于每棵树在进行结点分裂时，不必考虑所有特征，而是随机选择一部分特征实现数据分裂。通过这种方式，随机森林增加了模型的多样性，减少了树之间的相关性。
3. 集成学习：对于分类任务，随机森林通过投票的方式（即多数表决）来决定最终分类的结果；对于回归任务，通常可以对每棵树的预测结果求均值作为最终的预测结果。

随机森林的主要优点体现在：

1. 通过集成多个决策树，能够有效提高模型的准确性。
2. 由于引入了随机性，随机森林通常比单棵决策树更不容易过拟合。
3. 随机森林可以提供特征的重要性评分，帮助理解模型。
4. 能够处理大规模数据集和高维数据。

当然，因为要构建多个决策树，随机森林模型通常比较复杂，在训练模型时对计算资源、内存资源和时间成本的消耗都是更大的。我们可以通过 scikit-learn 库ensemble模块的RandomForestClassifier类来构造随机森林模型，这里我们仍然使用网格搜索交叉验证的方式来对超参数进行调优，代码如下所示。

1
from sklearn.ensemble import RandomForestClassifier
2

3
gs = GridSearchCV(
4
    estimator=RandomForestClassifier(n_jobs=-1),
5
    param_grid={
6
        'n_estimators': [50, 100, 150],
7
        'criterion': ['gini', 'entropy'],
8
        'max_depth': np.arange(5, 10),
9
        'max_features': ['sqrt', 'log2'],
10
        'min_samples_leaf': np.arange(1, 11),
11
        'max_leaf_nodes': np.arange(5, 15)
12
    },
13
    cv=5
14
)
15
gs.fit(X_train, y_train)

提示：上面的代码可能会运行非常长的时间。

随机森林模型的超参数很多跟决策树类似，需要说明的有以下几个超参数：

1. estimator：森林中树的数量，简单的说就是用多少个决策树来构造森林。更多的树通常会带来更好的预测效果，但也会增加计算成本。
2. boostrap：是否使用 Bootstrap 抽样，默认值为True，表示在构建每棵树时使用有放回抽样。
3. n_jobs：用于并行运行的任务数，默认值为None，表示使用单个处理器核心；设置为-1，则可以使用所有可用的处理器核心。

总结#

决策树是简单有效且易于理解的预测模型，适用于分类和回归任务，但容易发生过拟合且对噪声数据敏感；随机森林通过集成多个决策树提高了泛化能力且对噪声数据不敏感，适合解决复杂问题。在解决实际问题时，可以根据具体场景选择合适的模型，通过调节相关超参数来获得最佳效果，二者的对比如下表所示：

贝叶斯定理#

贝叶斯定理是概率论中的一个重要定理，它描述了如何从主观经验或已知事实出发，通过收集到的样本数据（证据）来更新对事件发生概率的认知（信念）。贝叶斯定理的数学表达式为：

其中， $\small{P(A)}$ 是事件 $\small{A}$ 发生的先验概率，我们可以理解为已知事实或主观经验（主观概率）； $\small{P(B \vert A)}$ 是在事件 $\small{A}$ 发生的条件下事件 $\small{B}$ 发生的 条件概率，通常也称之为似然性（likelihood）， $\small{P(B)}$ 是事件 $\small{B}$ 发生的（全）概率，这两个概率可以通过我们收集到的样本数据（证据）获得； $\small{P(A \vert B)}$ 是在事件 $\small{B}$ 发生的条件下事件 $\small{A}$ 发生的条件概率，即收集到样本数据后对事件 $\small{A}$ 发生概率的重新认知，称之为后验概率。贝叶斯定理告诉我们一个重要的事实：可以从已知的事实或主观经验出发，通过收集到的证据来更新我们对某个事件发生概率的认知，简单的说就是可以通过已知的事实和收集的证据来推断出未知的真相。

回到上面李女士购买飞机延误险的例子，假设本次航班是从成都双流国际机场飞往北京首都国际机场，执飞的航空公司是四川航空，起飞地天气为雨天（小雨），温度为8°C，东北风2级，降落地天气为晴天，温度4°C，西北风2级。为了更简单的让大家理解贝叶斯定理，我们对这里的条件稍作简化，只保留天气中的降水信息，暂不考虑温度和风速等其他因素，对应到上面的贝叶斯定理有：

上面公式等号左边就是李女士想知道的当前航班延误的概率，等号右边的部分其实就是历史数据和当前信息，计算这个概率的关键在于计算出似然性，即 $\small{P(起飞机场=双流,到达机场=首都,起飞天气=小雨,降落天气=晴天,执飞航司=川航 \vert 延误)}$ 到底是多少，那么这个条件概率又该如何计算呢？

朴素贝叶斯#

朴素贝叶斯算法是基于贝叶斯定理和特征条件独立性假设的分类算法，因其简单高效而受到广泛应用。朴素贝叶斯算法的关键在于“朴素”二字，就是刚才我们说到特征条件独立性假设，条件独立性假设是说用于分类的特征在类确定的条件下都是独立的，该假设使得朴素贝叶斯的学习成为可能。

假设我们有一个特征集合 $\small{X = \{x_1, x_2, \ldots, x_n\}}$ 和一个类别 $\small{C}$ ，朴素贝叶斯算法假设：

这个假设大大简化了计算复杂性，使得我们可以只计算每个特征在给定类别下的概率，而不需要考虑特征之间的相互作用，对应到上面购买飞机延误险的例子，我们可以用下面的方式来计算似然性：

算法原理#

1
from sklearn.datasets import load_iris
2
from sklearn.model_selection import train_test_split
3

4
iris = load_iris()
5
X, y = iris.data, iris.target
6
X_train, X_test, y_train, y_test = train_test_split(X, y, train_size=0.8, random_state=3)