Machine Learning - 机器学习笔记

文章目录

• [1. 机器学习简介](#1. 机器学习简介)
• • [1.1 机器学习是什么？](#1.1 机器学习是什么？)
• [2. 机器学习分类](#2. 机器学习分类)
• • [2.1 监督学习](#2.1 监督学习)
  • [2.2 无监督学习](#2.2 无监督学习)
• [3. 初识机器学习](#3. 初识机器学习)
• • [3.1 线性回归模型](#3.1 线性回归模型)
  • [3.2 代价函数](#3.2 代价函数)
  • • [3.2.1 代价函数公式](#3.2.1 代价函数公式)
    • [3.2.2 理解代价函数](#3.2.2 理解代价函数)
• [4. 了解梯度下降算法](#4. 了解梯度下降算法)
• • [4.1 梯度下降](#4.1 梯度下降)
  • [4.2 梯度下降的实现](#4.2 梯度下降的实现)
  • [4.3 理解梯度下降](#4.3 理解梯度下降)
  • [4.4 学习率](#4.4 学习率)
  • [4.5 用于线性回归的梯度下降](#4.5 用于线性回归的梯度下降)
  • [4.6 运行梯度下降](#4.6 运行梯度下降)
• [5. 了解特征](#5. 了解特征)
• • [5.1 多维特征](#5.1 多维特征)
  • [5.2 向量化](#5.2 向量化)
  • [5.3 用于多元线性回归的梯度下降法](#5.3 用于多元线性回归的梯度下降法)
  • [5.4 特征缩放](#5.4 特征缩放)
  • [5.5 判断梯度下降是否收敛](#5.5 判断梯度下降是否收敛)
  • [5.6 如何设置学习率](#5.6 如何设置学习率)
  • [5.7 特征工程](#5.7 特征工程)
  • [5.8 多项式回归](#5.8 多项式回归)
• [6. 逻辑回归](#6. 逻辑回归)
• • [6.1 动机与目的](#6.1 动机与目的)
  • [6.2 逻辑回归](#6.2 逻辑回归)
  • [6.3 决策边界](#6.3 决策边界)
  • [6.4 逻辑回归中的代价函数](#6.4 逻辑回归中的代价函数)
  • [6.5 简化逻辑回归代价函数](#6.5 简化逻辑回归代价函数)
  • [6.6 实现梯度下降](#6.6 实现梯度下降)
• [7. 过拟合问题与正则化](#7. 过拟合问题与正则化)
• • [7.1 过拟合](#7.1 过拟合)
  • [7.2 解决过拟合问题](#7.2 解决过拟合问题)
  • [7.3 正则化](#7.3 正则化)
  • [7.4 用于线性回归的正则方法](#7.4 用于线性回归的正则方法)
  • [7.5 用于逻辑回归的正则方法](#7.5 用于逻辑回归的正则方法)
• [8. 了解深度学习](#8. 了解深度学习)
• • [8.1 神经元和大脑](#8.1 神经元和大脑)
  • [8.2 神经网络工作流程](#8.2 神经网络工作流程)
  • [8.3 神经网络的结构](#8.3 神经网络的结构)
  • [8.4 神经网络的前向传播](#8.4 神经网络的前向传播)
  • [8.5 代码实现推理](#8.5 代码实现推理)
  • [8.6 Tensorflow中数据形式](#8.6 Tensorflow中数据形式)
  • [8.7 搭建一个神经网络](#8.7 搭建一个神经网络)
• [9. 前向传播](#9. 前向传播)
• • [9.1 单个网络层上的前向传播](#9.1 单个网络层上的前向传播)
  • [9.2 前向传播的一般实现](#9.2 前向传播的一般实现)
• [10. 强人工智能 AGI](#10. 强人工智能 AGI)
• [11. Tensorflow实现](#11. Tensorflow实现)
• [12. 激活函数](#12. 激活函数)
• • [12.1 sigmoid激活函数的替代方案](#12.1 sigmoid激活函数的替代方案)
  • [12.2 选择激活函数](#12.2 选择激活函数)
• [13. 多分类问题](#13. 多分类问题)
• • [13.1 多分类问题概述](#13.1 多分类问题概述)
  • [13.2 Softmax](#13.2 Softmax)
  • [13.3 神经网络的Softmax输出](#13.3 神经网络的Softmax输出)
  • [13.4 多标签分类](#13.4 多标签分类)
• [14. 高级优化](#14. 高级优化)
• • [14.1 高级优化方法](#14.1 高级优化方法)
  • [14.2 其他的网络层类型](#14.2 其他的网络层类型)
• [15. 模型评估与选择](#15. 模型评估与选择)
• • [15.1 决定下一步做什么](#15.1 决定下一步做什么)
  • [15.2 模型评估](#15.2 模型评估)
  • [15.3 模型选择及交叉验证测试集的训练方法](#15.3 模型选择及交叉验证测试集的训练方法)
• [16. 诊断与改进](#16. 诊断与改进)
• • [16.1 通过偏差与方差进行诊断](#16.1 通过偏差与方差进行诊断)
  • [16.2 正则化、偏差、方差](#16.2 正则化、偏差、方差)
  • [16.3 制定一个用于性能评估的基准](#16.3 制定一个用于性能评估的基准)
  • [16.4 学习曲线](#16.4 学习曲线)
  • [16.5 方差与偏差](#16.5 方差与偏差)
• [17. 机器学习系统开发过程](#17. 机器学习系统开发过程)
• • [17.1 误差分析过程](#17.1 误差分析过程)
  • [17.2 添加更多数据](#17.2 添加更多数据)
  • [17.3 迁移学习](#17.3 迁移学习)
  • [17.4 机器学习项目完整周期](#17.4 机器学习项目完整周期)
  • [17.5 倾斜数据集的误差指标](#17.5 倾斜数据集的误差指标)
  • [17.6 精确率与召回率的权衡](#17.6 精确率与召回率的权衡)
• [18. 决策树](#18. 决策树)
• • [18.1 决策树模型简介](#18.1 决策树模型简介)
  • [18.2 决策树学习过程](#18.2 决策树学习过程)
  • [18.3 纯度](#18.3 纯度)
  • [18.4 选择拆分信息增益](#18.4 选择拆分信息增益)
  • [18.5 整合](#18.5 整合)
  • [18.6 独热编码One-hot](#18.6 独热编码One-hot)
  • [18.7 连续有价值的特征](#18.7 连续有价值的特征)
  • [18.8 回归树](#18.8 回归树)
  • [18.9 使用多个决策树](#18.9 使用多个决策树)
  • [18.10 有放回抽样](#18.10 有放回抽样)
  • [18.11 随机森林](#18.11 随机森林)
  • [18.12 XGBoost](#18.12 XGBoost)
  • [18.13 何时使用决策树](#18.13 何时使用决策树)

1. 机器学习简介

1.1 机器学习是什么？

机器学习是研究计算机模仿人类学习的过程，利用新的数据改善自身的性能，是人工智能的核心。

机器学习，人工智能，深度学习之间的关系：

机器学习是实现人工智能的一种方法；深度学习是实现机器学习的一种技术。概念包含关系上：人工智能>机器学习>深度学习。

机器学习很常见，如谷歌搜索（搜出的网站排序算法）、邮箱的垃圾站（无监督）。

任务：T，性能度量：P，经验：E

机器学习主要包括：监督学习和无监督学习，另外也包括强化学习（Reinforcement Learning）和推荐系统（Recommender Systems）。

---

2. 机器学习分类

2.1 监督学习

监督学习：Supervised Learning

回归问题和分类问题。

1. 简单的房价预测（回归问题）

   

   回归：想要预测连续的数值输出，在这里也就是价格，价格能够进行很细的划分，因此价格是一个离散值，不同的房间面积（Size）都会对应一个价格（Price）。

   回归（个人理解）：给出一定的数据集，然后这些数据集可以构建出一个函数模型，通过构建出来的函数模型，可以带入新的自变量，来得出自己想要的结果。

2. 肿瘤是否恶性的判断（分类问题）

   

   

   处理多种甚至无限种特征给肿瘤分类。预测的值只有少数的离散值，所以这个是分类问题。

   分类问题（个人理解）：给定一定的数据集，每个数据都标明不同的分类，通过数据集构建出一个模型，将新的自变量带入，可以得到一个新的结果，该结果是类别中的一种，结果是非连续的。

   

2.2 无监督学习

无监督学习：Unsupervised Learning

不同于监督学习的数据，无监督学习的数据没有告诉学习算法"正确答案"，就是一个普通的数据集，无监督学习算法可以把这些数据集分成两个不同的簇（聚类算法）。

录音声音分离：

通过Octave语言可以很简单的实现！！

---

3. 初识机器学习

3.1 线性回归模型

将一条直线拟合到数据中，线性回归(Linear regression)。

x x x：输入变量、特征、输入特征

y y y：输出变量、目标变量

m m m：指代训练样本的总数

( x , y ) (x,y) (x,y)：一个训练实例 x x x， y y y

( x ( i ) , y ( i ) ) (x^{(i)},y^{(i)}) (x(i),y(i))：表示特定训练示例，第 i i i个。注意：这里的右上标不是次方，而是代表训练集的索引。

f f f：函数，称为模型，获取一个新的输入 x x x，输出并估计或者预测 y ^ \hat{y} y^，称为y-hat，是对 y y y的估计或预测，当符号只为 y y y时，是指目标，是训练集中实际的真实的值。相反，y-hat是一个估计值，它可能是，也可能不是实际的真实值。

关键问题是，如何表示函数 f   f\, f？换句话说， f   f\, f的数学公式是什么

现在，我们坚持 f   f\, f是一条直线

函数可以写为 f w , b ( x ) = w x + b f_{w,b}(x)=wx+b fw,b(x)=wx+b，这样我们就要去确定 w    b   w\;b\, wb的值，这将决定基于输入特征 x   x\, x的预测 y ^ \hat{y} y^。

或者直接写成 f ( x ) = w x + b f(x)=wx+b f(x)=wx+b

只有一个输入变量 x   x\, x的线性回归模型，也可以称为单变量线性回归(Univariate linear regression)。

3.2 代价函数

3.2.1 代价函数公式

为了实现线性回归，第一个关键步骤是首先定义一个叫做代价函数的东西。

损失函数(Loss function)：计算的是一个样本的误差。

损失函数是定义在单个训练样本上的，也就是就算一个样本的误差，比如我们想要分类，就是预测的类别和实际类别的区别，是一个样本的哦，用L表示。

代价函数(Cost function)：也称成本函数，整个训练集上所有样本误差的平均。

代价函数是定义在整个训练集上面的，也就是所有样本的误差的总和的平均，也就是损失函数的总和的平均，有没有这个平均其实不会影响最后的参数的求解结果。

目标函数：代价函数 + 正则化项

在    f w , b ( x ) = w x + b    \;f_{w,b}(x)=wx+b\; fw,b(x)=wx+b中， w b    w \ b\; w b称为模型的参数，或称为系数或权重。

在机器学习中，模型的参数自己可以调整的变量，训练以改进模型。

y ^ ( i ) = f w , b ( x ( i ) ) = w x ( i ) + b \hat{y}^{(i)}=f_{w,b}(x^{(i)})=wx^{(i)}+b y^(i)=fw,b(x(i))=wx(i)+b

目前问题，如何找到    w b    \;w \ b\; w b的值，以便来预测 y ^ \hat{y} y^

首先来看如何衡量一条线与训练数据的拟合程度，为此，我们将构建一个成本函数。

成本函数采用预测$\ \hat{y} \ ，并通过将 ，并通过将 ，并通过将\ \hat{y}\ 减去 减去 减去\ y\ 将其与目标 将其与目标 将其与目标\ y\ 进行比较，这种差异称为误差，然后对误差进行取平方，将训练集每个训练示例的误差平方求和，最后除以训练示例的数量 进行比较，这种差异称为误差，然后对误差进行取平方，将训练集每个训练示例的误差平方求和，最后除以训练示例的数量 进行比较，这种差异称为误差，然后对误差进行取平方，将训练集每个训练示例的误差平方求和，最后除以训练示例的数量\ m\ $，取得平均平方误差，即

1 m ∑ i = 1 m ( y ^ ( i ) − y ( i ) ) 2 \frac{1}{m}\sum\limits_{i=1}^m(\hat{y}^{(i)}-y^{(i)})^2 m1i=1∑m(y^(i)−y(i))2

$\ m\ $为训练示例的数量

按照惯例，在机器学习中，人们是使用的成本函数实际上是除以2倍的$\ m\ ，额外除以 ，额外除以 ，额外除以\ 2\ 只是为了是一些我们后面的计算看起来更整洁，但是无论是否包括这个除以 只是为了是一些我们后面的计算看起来更整洁，但是无论是否包括这个除以 只是为了是一些我们后面的计算看起来更整洁，但是无论是否包括这个除以\ 2\ ，这个表达式就是 ∗ 成本函数 ，这个表达式就是*成本函数 ，这个表达式就是∗成本函数\ J(w,b)\ $，也称为平方误差成本函数*，我们写做：

J ( w , b ) = 1 2 m ∑ i = 1 m ( y ^ ( i ) − y ( i ) ) 2 J(w,b)=\frac{1}{2m}\sum\limits_{i=1}^m(\hat{y}^{(i)}-y^{(i)})^2 J(w,b)=2m1i=1∑m(y^(i)−y(i))2

或

J ( w , b ) = 1 2 m ∑ i = 1 m ( f w , b ( x ( i ) ) − y ( i ) ) 2 J(w,b)=\frac{1}{2m}\sum\limits_{i=1}^m(f_{w,b}(x^{(i)})-y^{(i)})^2 J(w,b)=2m1i=1∑m(fw,b(x(i))−y(i))2

在机器学习中，不同的人 ，对于不同的应用程序，会采用不同的成本函数。平方误差成本函数通常用于线性回归。

综上，最终我们要找到使成本函数变小的$\ w\ b\ $的值。

3.2.2 理解代价函数

在暂不考虑参数$\ b\ 的情况下（令 的情况下（令 的情况下（令\ b=0\ ），分析函数 ），分析函数 ），分析函数\ f_w(x)\ 和代价函数 和代价函数 和代价函数\ J(w)\ $之间的关系

根据$\ w\ 取值的不同，会得到不同的成本函数的图像，我们要找到成本函数的尽可能低的点，即成本函数取尽可能小值时的 取值的不同，会得到不同的成本函数的图像，我们要找到成本函数的尽可能低的点，即成本函数取尽可能小值时的 取值的不同，会得到不同的成本函数的图像，我们要找到成本函数的尽可能低的点，即成本函数取尽可能小值时的\ w\ $的值，如

通常情况下，我们有$\ w\ b\ 两个参数，所以我们要找到时 两个参数，所以我们要找到时 两个参数，所以我们要找到时\ J(w,b)\ 最小的 最小的 最小的\ w\ b\ $的值。

下面，我们分析函数$\ f_{w,b}(x)\ 和代价函数 和代价函数 和代价函数\ J(w,b)\ 之间的关系，不再将 之间的关系，不再将 之间的关系，不再将\ b\ 的值设置为 的值设置为 的值设置为\ 0\ $

另一种可视化成本函数的方法，不是使用这种3D图，取3D图的切面，形成等高线图的方法。

---

4. 了解梯度下降算法

4.1 梯度下降

梯度下降不仅用于线性回归，而且用于训练最先进的神经网络模型（深度学习模型）。

梯度下降是一种可以用来尝试最小化任何函数的算法，而且不仅仅是线性回归的成本函数。

事实证明，梯度下降适用于更一般的函数，包括具有两个以上参数的模型一起使用的其他成本函数。

假设我们有一个成本函数$\ J(w_1,w_2,w_3,...,w_n,b)\ ，我们的目标是在 ，我们的目标是在 ，我们的目标是在\ w_1\ 到 到 到\ w_n\ 和 和 和\ b\ 上最小化 上最小化 上最小化\ J\ $

我们要做的只是从对$\ w\ 和 和 和\ b\ 的一些初步猜测开始，在线性回归中，初始值是多少并不重要，所以一个常见的选择是将他们都设置为 的一些初步猜测开始，在线性回归中，初始值是多少并不重要，所以一个常见的选择是将他们都设置为 的一些初步猜测开始，在线性回归中，初始值是多少并不重要，所以一个常见的选择是将他们都设置为\ 0\ $，例如，

• 我们将设$\ w=0\ \ \ \ b=0\ $
• 继续每次更改参数$\ w\ 和 和 和\ b\ 的取值，来降低 的取值，来降低 的取值，来降低\ w\ 和 和 和\ b\ 的成本 的成本 的成本\ j\ ，直到希望 ，直到希望 ，直到希望\ j\ $达到或接近最小值

对于某些可能不是弓形或者吊床形的函数$\ J\ $，可能存在不止一个可能的最小值，如

个人理解，梯度算法有点贪心算法的思想，追求局部最优。

每次站到最新的$\ w\ 和 和 和\ b\ 的最优取值的角度，选择下一个 的最优取值的角度，选择下一个 的最优取值的角度，选择下一个\ w\ 和 和 和\ b\ $的最优取值，以此找到最优解

4.2 梯度下降的实现

在参数$\ w\ 之后，取当前值 之后，取当前值 之后，取当前值\ w\ $并对其进行少量调整

w = w − α ∂ J ( w , b ) ∂ w w=w-\alpha\frac{\partial J(w,b)}{\partial w} w=w−α∂w∂J(w,b)

$\ \alpha\ ：学习率（ L e a r i n i n g r a t e ），学习率 ∗ ∗ 通常 ∗ ∗ 介于 ：学习率（Learining rate），学习率**通常**介于 ：学习率（Leariningrate），学习率∗∗通常∗∗介于\ 0\ 和 和 和\ 1\ 之间的一个小的正数， 之间的一个小的正数， 之间的一个小的正数，\ \alpha\ 所做的是，它控制梯度下降每一次步长的大小。如果 所做的是，它控制梯度下降每一次步长的大小。如果 所做的是，它控制梯度下降每一次步长的大小。如果\ \alpha\ 非常大，则对应于一个非常激进的梯度下降过程，即试图在下坡时迈出一大步，如果 非常大，则对应于一个非常激进的梯度下降过程，即试图在下坡时迈出一大步，如果 非常大，则对应于一个非常激进的梯度下降过程，即试图在下坡时迈出一大步，如果\ \alpha\ $非常小，那么在下坡时将迈出小步下坡。

∂ J ( w , b ) ∂ w \frac{\partial J(w,b)}{\partial w} ∂w∂J(w,b)：代价函数$\ J(w,b)\ 的导数项，决定要朝哪个方向迈出，结合学习率 的导数项，决定要朝哪个方向迈出，结合学习率 的导数项，决定要朝哪个方向迈出，结合学习率\ \alpha\ $，也决定了大小。

同时，在参数$\ w\ 变化的同时，我们也不能忽略了参数 变化的同时，我们也不能忽略了参数 变化的同时，我们也不能忽略了参数\ b\ $的变化。

b = b − α ∂ J ( w , b ) ∂ b b=b-\alpha\frac{\partial J(w,b)}{\partial b} b=b−α∂b∂J(w,b)

对于梯度下降算法，我们将重复这两个对参数$\ w\ 和参数 和参数 和参数\ b\ $的更新步骤，知道算法收敛，即达到一个局部最小值的点。

对于参数$\ w\ 和参数 和参数 和参数\ b\ $，我们要对两个参数进行同时的计算更新。

正确方法：用一个中间变量先进行接受，然后再赋值

如果不同时进行更新，则再计算完参数$\ w\ ，并将新的值赋值给参数 ，并将新的值赋值给参数 ，并将新的值赋值给参数\ w\ ，则会影响对参数 ，则会影响对参数 ，则会影响对参数\ b\ $值的计算。

错误做法（不同时对参数进行更新）：

4.3 理解梯度下降

w = w − α ∂ J ( w , b ) ∂ w b = b − α ∂ J ( w , b ) ∂ b w=w-\alpha\frac{\partial J(w,b)}{\partial w}\ \ \ \ \ b=b-\alpha\frac{\partial J(w,b)}{\partial b} w=w−α∂w∂J(w,b) b=b−α∂b∂J(w,b)

对代价函数的导数，可以保证参数$\ w\ 和参数 和参数 和参数\ b\ 朝着代价函数 朝着代价函数 朝着代价函数\ J(w,b)\ 的值变小的方向进行变化。而变量 的值变小的方向进行变化。而变量 的值变小的方向进行变化。而变量\ \alpha\ $则决定了每次变化的大小。

4.4 学习率

w = w − α ∂ J ( w , b ) ∂ w b = b − α ∂ J ( w , b ) ∂ b w=w-\alpha\frac{\partial J(w,b)}{\partial w}\ \ \ \ \ b=b-\alpha\frac{\partial J(w,b)}{\partial b} w=w−α∂w∂J(w,b) b=b−α∂b∂J(w,b)

学习率$\ \alpha\ 对实现梯度下降的效率产生巨大的影响。如果学习率 对实现梯度下降的效率产生巨大的影响。如果学习率 对实现梯度下降的效率产生巨大的影响。如果学习率\ \alpha\ $选择的不好，下降率甚至可能根本不起作用。

如果学习率太小，则每次进行梯度下降的步伐会很小。如果选择了过于小的学习率，会降低代价函数的值，梯度下降会起作用，但是速度非常慢。

如果学习率太大，则每次进行梯度下降的步伐会很大，可能会超过并且永远不会到达最小值。另一种说法，学习率太大，肯能无法使代价函数的值收敛，甚至会发散。

另一个问题，我们可能想知道自己的参数$\ w\ 现在所处的位置是否取得代价函数 现在所处的位置是否取得代价函数 现在所处的位置是否取得代价函数\ J\ $的局部最小值。如果已经到达了最小值，是否会继续进行梯度下降。

假设我们有一个成本函数$\ J(w)\ ，但是这个成本函数不是平法误差成本函数，这个成本函数有两个据不最小值。假设我们经过一些梯度下降步骤后，我们的参数 ，但是这个成本函数不是平法误差成本函数，这个成本函数有两个据不最小值。假设我们经过一些梯度下降步骤后，我们的参数 ，但是这个成本函数不是平法误差成本函数，这个成本函数有两个据不最小值。假设我们经过一些梯度下降步骤后，我们的参数\ w\ 等于 等于 等于\ 5\ ，这就是参数 ，这就是参数 ，这就是参数\ w\ 当前的值，这意味此时我们处于成本函数 当前的值，这意味此时我们处于成本函数 当前的值，这意味此时我们处于成本函数\ J\ 上的一个局部最小值，此时斜率几乎为 上的一个局部最小值，此时斜率几乎为 上的一个局部最小值，此时斜率几乎为\ 0\ ，因此导数项也几乎等于 ，因此导数项也几乎等于 ，因此导数项也几乎等于\ 0\ $，此时

w = w − α ⋅ 0 w=w-\alpha·0\ w=w−α⋅0

参数$\ w\ 值不再变化，即 值不再变化，即 值不再变化，即\ w=w\ ，此时则意味着我们已经处于局部最小值，梯度下降使 ，此时则意味着我们已经处于局部最小值，梯度下降使 ，此时则意味着我们已经处于局部最小值，梯度下降使\ w\ $保持不变，则不会再继续进行梯度下降。

随着梯度下降过程的进行，每一次的下降的步长也会自动变化，因为这个下降的步长是和导数项也有关系的，导数项是不断变化的，因此变化的步长是不断变化的。即使学习率是一个固定值，变化的步长也是不断变化的。

4.5 用于线性回归的梯度下降

将梯度下降中的导数计算后，得出：

r e p e a t { w = w − α 1 m ∑ i = 1 m ( f w , b ( x ( i ) ) − y ( i ) ) x ( i ) b = b − α 1 m ∑ i = 1 m ( f w , b ( x ( i ) ) − y ( i ) ) } s i m u l t a n e o u s u p d a t e repeat \{\qquad\qquad\qquad\qquad\qquad\qquad\qquad\qquad \\ w=w-\alpha\frac1m\sum\limits_{i=1}^m(f_{w,b}(x^{(i)})-y^{(i)})x^{(i)}\\b=b-\alpha\frac1m\sum\limits_{i=1}^m(f_{w,b}(x^{(i)})-y^{(i)})\\ \}simultaneous\ \ update\qquad\qquad\qquad\qquad repeat{w=w−αm1i=1∑m(fw,b(x(i))−y(i))x(i)b=b−αm1i=1∑m(fw,b(x(i))−y(i))}simultaneous update

梯度下降可以得到局部最小值，而不是全局的最小值，即可以得到极小值。

4.6 运行梯度下降

---

5. 了解特征

5.1 多维特征

在预测房价的例子中，引入房间数量，房龄等特征，形成了多维特征，这些特征共同作为变量。

$x_j\ 表示第 表示第 表示第\ j\ $列

$\ n\ $表示特征个数

$\ \vec{x}^{(i)}\ 表示第 表示第 表示第\ i\ $行的向量组

$\ \vec{x}^{i}_j\ 表示第 表示第 表示第\ i\ 行，第 行，第 行，第\ j\ $列

多维向量对应的模型：

我们之前定义的模型：$\ f_{w,b} = wx+b\ ， ， ，\ x\ $是单个特征

而现在的多维向量定义模型为：$\ f_{w,b} = w_1x_1+w_2x_2+w_3x_3+w_4x_4+...+w_nx_n+b \ $

w ⃗ = [ w 1 , w 2 , w 3 , . . . , w n ] \vec{w} = [w_1,w_2,w_3,...,w_n] w =[w1,w2,w3,...,wn]

x ⃗ = [ x 1 , x 2 , x 3 , . . . x n ] \vec{x} = [x_1,x_2,x_3,...x_n] x =[x1,x2,x3,...xn]

同时，我们可以将这个式子简写为： f w ⃗ , b ( x ⃗ ) = w ⃗ ⋅ x ⃗ + b = w 1 x 1 + w 2 x 2 + w 3 x 3 + w 4 x 4 + . . . + w n x n + b \ f_{\vec{w},b}(\vec{x}) = \vec{w}·\vec{x}+b = w_1x_1+w_2x_2+w_3x_3+w_4x_4+...+w_nx_n+b fw ,b(x )=w ⋅x +b=w1x1+w2x2+w3x3+w4x4+...+wnxn+b

这里为向量的点积 ，我们将这个算法称为多元线性回归（multiple linear regression）。

5.2 向量化

当我们学习算法时，使用向量化都会使我们的代码更短，也使它运行更有效。

numpy中的*dot()*方法实现了向量的点积运算（内积）。

使用向量化的优点：

• 代码更简洁
• 运行速度更高

没有进行向量化时，代码是串行。进行了向量化后，多个计算是并行进行的。

5.3 用于多元线性回归的梯度下降法

我们可以将模型定义为：$\ f_{\vec{w},b}(\vec{x})=\vec{w}·\vec{x}+b \ $

成本函数可以定义为：$\ J(w_1,w_2,...,w_n,b)=J(\vec{w},b) \ $

梯度下降算法：

w j = w j − α ∂ ∂ w j J ( w 1 , . . . , w n , b ) w_j=w_j-\alpha\frac{\partial}{\partial{w_j}}J(w_1,...,w_n,b) wj=wj−α∂wj∂J(w1,...,wn,b)

$\ b=b-\alpha\frac{\partial}{\partial{b}}J(w_1,...,w_n,b) \ $

也可以写为：

w j = w j − α ∂ ∂ w j J ( w ⃗ , b ) w_j=w_j-\alpha\frac{\partial}{\partial{w_j}}J(\vec{w},b) wj=wj−α∂wj∂J(w ,b)

$\ b=b-\alpha\frac{\partial}{\partial{b}}J(\vec{w},b) \ $

多元线性回归的梯度下降中导数：（这是对$\ w_1\ $的导数）

$\frac{\partial}{\partial{w_1}}J(\vec{w},b)=\ \frac{1}{m}\sum\limits_{i=1}^m(f_{\vec{w},b}(\vec{x}^{(i)}-y^{(i)}))x_1^{(i)} \ $

$\ w_1=w_1-\alpha\frac{1}{m}\sum\limits_{i=1}^m(f_{\vec{w},b}(\vec{x}^{(i)}-y^{(i)}))x_1^{(i)} \ $

所以我们要更新参数从$\ w_1\ 到 到 到\ w_n\ 和参数 和参数 和参数\ b\ $

正规方程（Normal equation） ，梯度下降是最小化成本函数，而正规方程法只适用于线性回归，这种方法不需要迭代梯度下降算法，可以使用一个高级线性代数库，无需迭代即可在一个目标中求解$\ w\ 和 和 和\ b\ $。

正规方程法的缺点：

• 没有推广到其他学习算法
• 如果特征数量很大，正规方程方法也很慢

5.4 特征缩放

特征缩放的方法：

• 最大最小值归一化（min-max normalization）
• 均值归一化（Mean normalization）
• 标准化/Z值归一化（Z-score normalization）
• 最大绝对值归一化（max abs normalization）

该技术将使梯度下降运行得更快。

当一个特征的可能值范围很大时，一个好的模型更有可能学会选择一个相对较小的参数值。同样，当特征的可能值很小时，那么一个合理的值它的参数会比较大。

当因为轮廓是如此之高和瘦，梯度下降最终可能来回弹跳，很长一段时间，它才能最终找到通往全球最低点的道路。在这种情况下，要做的一件有用的事情是缩放特征。

这意味着对我们的训练数据进行一些转换，以便\\ x_1\\ 的范围现在可能从 0 到 1 ，而 的范围现在可能从0到1，而 的范围现在可能从0到1，而\\ x_2\\ 的范围也可能从 0 到 1 。如果我们在成本函数上运行梯度下降来找到这个，使用这个转换后的数据重新缩放 的范围也可能从0到1。如果我们在成本函数上运行梯度下降来找到这个，使用这个转换后的数据重新缩放 的范围也可能从0到1。如果我们在成本函数上运行梯度下降来找到这个，使用这个转换后的数据重新缩放x_1 和 和 和x_2，那么轮廓看起来更像圆圈，不会那么高大和瘦。梯度下降可以找到一条更直接的通往全局最小值的路径

可以让我们的样本数据除以样本数据可能取到的最大值，来进行特征值的缩小。

除了除以最大值之外，我们还可以执行所谓的均值归一化。 我们从原始特征开始，然后我们重新缩放它们，使两者其中以0为中心，以前它们只有大于0的值，现在它们既有负值也有正值，这通常可能在负一和正一之间。

如，要计算$\ x_1\ 的均值归一化，首先求均值，也称为训练集上 的均值归一化，首先求均值，也称为训练集上 的均值归一化，首先求均值，也称为训练集上\ x_1\ 的均值，我们称其为均值 的均值，我们称其为均值 的均值，我们称其为均值\ M_1\ $。

我们曲每个$\ x_1\ 减去平均 减去平均 减去平均\ M_1\ ，然后我们除以差值（最大值 − 最小值），这样我们就得到标准化的 ，然后我们除以差值（最大值-最小值） ，这样我们就得到标准化的 ，然后我们除以差值（最大值−最小值），这样我们就得到标准化的\ x_1\ $。

另外一个常见的重新缩放方法调用Z-score标准化，为了实现Z-score归一化 ，我们需要计算每个特征的标准差$\ \sigma \ 。我们首先计算平均值 。 我们首先计算平均值 。我们首先计算平均值\ \mu\ 以及标准差 以及标准差 以及标准差\ \sigma \ 。然后进行 Z − s c o r e 归一化，取每个 。然后进行Z-score归一化，取每个 。然后进行Z−score归一化，取每个\ x_1\ 减去 减去 减去\ \mu_1 \ ，然后除以标准差 ，然后除以标准差 ，然后除以标准差\ \sigma_1 \ $。这样我们已经实现了Z-score标准化。

那么，何时需要进行特征缩放？

5.5 判断梯度下降是否收敛

梯度下降的关键选择之一是学习率$\ \alpha \ $的选择

学习曲线：

如果梯度下降正常，那么成本$\ J\ 应该每次迭代后减少，如果 应该每次迭代后减少，如果 应该每次迭代后减少，如果\ J\ 在一次迭代后增加，这意味着 在一次迭代后增加，这意味着 在一次迭代后增加，这意味着\ \alpha \ 选择不当，这通常意味着 选择不当，这通常意味着 选择不当，这通常意味着\ \alpha \ $太大，或则代码中可能存在错误。

如图，在迭代次数达到300次后，成本$\ J \ $函数的图像已经基本不再下降，梯度下降已经收敛了。

此外，梯度下降的迭代次数在不同的应用程序之间进行转换可能会有很大差异。

确定模型何时完成训练的另一种方法是使用自动收敛测试 。如果在一次迭代中成本$\ J\ 减少幅度小于这个数字 减少幅度小于这个数字 减少幅度小于这个数字\ \epsilon\ （一个很小的数字，例如 0.001 ），如果在一次迭代中成本 （一个很小的数字，例如0.001），如果在一次迭代中成本 （一个很小的数字，例如0.001），如果在一次迭代中成本\ J \ 减少的幅度小于这个数字 减少的幅度小于这个数字 减少的幅度小于这个数字\ \epsilon \ $，那么我们可以在我们看到的曲线的平坦部分左边，声明收敛。

通常，发现正确的阈值$\ \epsilon \ $是非常困难的。

5.6 如何设置学习率

如果学习率太小，则会运行很慢，如果太大，甚至可能不会收敛。

如果我们绘制多次迭代的成本，并注意到成本有时会上升，有时会下降，我们应该将其视为梯度下降无法正常工作的明显迹象，这可能意味着代码中存在错误，或者有时可能意味着我们选择的学习率太大。

要解决此问题，我们可以选择使用较小的学习率。

有时我们会看到每次迭代后成本不断增加，这也可能是由于学习率太大引起的，并且可以通过选择较小的学习率进行解决。但是像这样的学习率也可能是代码被破坏的迹象。

正确实现梯度下降的一个调试技巧是在足够小的学习率下，成本函数应该每次迭代都会减少。

如果即使将$\ \alpha \ 设置为非常小的数字， 设置为非常小的数字， 设置为非常小的数字，\ J\ $不会在每次迭代中减少，而是有时会增加，那么这通常意味着代码中某个地方存在着错误。

但是，如果学习率太小的话，梯度下降可能需要很多次迭代才能收敛。

所以，当运行梯度下降时，我们应该尝试学习率一系列的值(... 0.001 0.01 0.1 1 ...)

5.7 特征工程

许多实际应用，选择或输入正确的特征是使算法运行良好的关键步骤。

我们可以在其中使用我们对问题的知识或直觉来设计新特征，通常通过变换或组合原始特征问题以使学习算法更容易做出准确的预测。

根据我们对应用程序有哪些见解，而不是仅仅采用我们碰巧拥有的特征，有时通过定义新特征，我们可以获得更好的模型。这就是特征工程。

5.8 多项式回归

通过使用特征工程和多项式函数，我们可以为我们的数据提供更好的模型。

在上述例子中，我们可以选择二次函数，也可以选择三次函数等，那我们如何决定使用哪一种呢？（后面会解答）

---

6. 逻辑回归

6.1 动机与目的

binary classification 二元分类

0：false，negative class

1：true，positive class

当在右侧添加一个示例时，分界线也称为决策边界会向右移动。

6.2 逻辑回归

罗辑回归算法用于分类问题。输出值始终介于0和1之间。

为了构建逻辑回归算法，可以使用一个重要的数学函数，称为 S i g m o i d Sigmoid Sigmoid函数，有时也可以称为逻辑函数 l o g i s t i c f u c n t i o n logistic fucntion logisticfucntion

S i g m o i d Sigmoid Sigmoid函数的输出值介于0和1之间，该函数可以表示为：
g ( z ) = 1 1 + e − z 0 < g ( z ) < 1 g(z)=\frac{1}{1+e^{-z}}\ \ \ \ \ \ 0<g(z)<1 g(z)=1+e−z1 0<g(z)<1

e约等于2.7。

使用 S i g m o i d f u n c t i o n Sigmoid\ function Sigmoid function构建逻辑回归算法：

1. 像线性回归一样，定义一个直线函数 z = w ⃗ ⋅ x ⃗ + b z = \vec{w}·\vec{x}+b z=w ⋅x +b

2. 获取 z z z的值，并将其传递给 S i g m o i d Sigmoid Sigmoid函数，也称为逻辑函数 g g g，然后输出有 g ( z ) g(z) g(z)函数计算得出的值

3. 将函数 z ( x ) z(x) z(x)与函数 g ( z ) g(z) g(z)放在一起，我们便会得到变量 x x x的逻辑回归模型 f w ⃗ , b ( x ⃗ ) = g ( w ⃗ ⋅ x ⃗ + b ) = 1 1 + e − ( w ⃗ ⋅ x ⃗ + b ) f_{\vec{w},b}(\vec{x})=g(\vec{w}·\vec{x}+b)=\frac{1}{1+e^{-(\vec{w}·\vec{x}+b)}} fw ,b(x )=g(w ⋅x +b)=1+e−(w ⋅x +b)1，这就是逻辑回归模型，它的作用是输入特征或集合x，并输出一个介于0和1之间的数字。

   

假设x是肿瘤的大小，y的值为0或1。 0：非恶性，1：恶性

基于该模型，输入x，模型得到的值假设为0.7。这意味着模型认为存在该患者标签为1的概率为70%。换句话说，该模型告诉我们，该患者肿瘤为恶性的概率为70%。

因此，结果y为0的概率为30%。

在阅读文献时，我们可能会遇到上诉的这种公式，其含义为，输入特征x和带有参数w和b。这里的分号用来表示的只是w和b是影响y等于1的计算参数。

6.3 决策边界

如果我们想预测y的值是0还是1，我们需要做的一件事就是要设置一个阀值，高于阀值时y为1，低于阀值时y为0。

一个常见的选择时选择一个阀值为0.5。

因此如果 f w ⃗ , b ( x ⃗ ) ≥ 0.5 f_{\vec{w},b}(\vec{x})\geq0.5 fw ,b(x )≥0.5，则预测y为1，我们会写成 y ^ = 1 \hat{y}=1 y^=1，如果 f w ⃗ , b ( x ⃗ < 0.5 f_{\vec{w},b}(\vec{x}<0.5 fw ,b(x <0.5，则预测y为0，我们会写成 y ^ = 0 \hat{y}=0 y^=0。

那么 f w ⃗ , b ( x ⃗ ) f_{\vec{w},b}(\vec{x}) fw ,b(x )何时大于等于0.5呢？
f w ⃗ , b ( x ⃗ ) = g ( w ⃗ ⋅ x ⃗ + b ) = 1 1 + e − ( w ⃗ ⋅ x ⃗ + b ) f_{\vec{w},b}(\vec{x})=g(\vec{w}·\vec{x}+b)=\frac{1}{1+e^{-(\vec{w}·\vec{x}+b)}} fw ,b(x )=g(w ⋅x +b)=1+e−(w ⋅x +b)1

根据该图像可知，当 z ≥ 0 z\geq0 z≥0时， f w ⃗ , b ( x ⃗ ) ≥ 0.5 f_{\vec{w},b}(\vec{x})\geq0.5 fw ,b(x )≥0.5，即当 w ⃗ ⋅ x ⃗ + b ≥ 0 \vec{w}·\vec{x}+b\geq0 w ⋅x +b≥0时， f w ⃗ , b ( x ⃗ ) ≥ 0.5 f_{\vec{w},b}(\vec{x})\geq0.5 fw ,b(x )≥0.5。

假设我们有两个特征 x 1 x_{1} x1和 x 2 x_{2} x2

上图为一个训练集，红色为正例，蓝色为反例。

红色对应y等于1，蓝色对应y等于0。

逻辑回归模型将使用此函数 f w ⃗ , b ( x ⃗ ) = g ( z ) f_{\vec{w},b}(\vec{x})=g(z) fw ,b(x )=g(z)进行预测，其中 z = w 1 x 1 + w 2 x 2 + b z=w_{1}x_{1}+w_{2}x_{2}+b z=w1x1+w2x2+b。

对于这个例子，我们假设参数的值是 w 1 = 1 , w 2 = 1 , b = − 3 w_{1}=1,w_{2}=1,b=-3 w1=1,w2=1,b=−3。

使用逻辑回归进行预测，首先我们要弄清楚 w 1 x 1 + w 2 x 2 + b w_{1}x_{1}+w_{2}x_{2}+b w1x1+w2x2+b何时大于0以及何时小于0。为了弄清楚这一点，存在着一条非常特别的线，就是 w 1 x 1 + w 2 x 2 + b w_{1}x_{1}+w_{2}x_{2}+b w1x1+w2x2+b正好等于0的时候，这条线也称为决策边界(Decision boundary)。

对于上面我们假设的参数，决策边界就是 z = x 1 + x 2 − 3 z=x_{1}+x_{2}-3 z=x1+x2−3等于0时。那么 z = x 1 + x 2 − 3 z=x_{1}+x_{2}-3 z=x1+x2−3什么时候等于0呢？

我们可以由 x 1 + x 2 − 3 = 0 x_{1}+x_{2}-3=0 x1+x2−3=0得出 x 1 + x 2 = 3 x_{1}+x_{2}=3 x1+x2=3，即下图由紫色所表示的直线，这条线便是决策边界。

在这条直线的右侧，模型将预测为1。在这条直线的左侧，模型将预测为0。

在下图，这个复杂的例子中，决策边界不再是一条直线。和我们之前定义的一样，红色y值为1，蓝色y值为0。

我们将设置 z = w 1 x 1 2 + w 2 x 2 2 + b z=w_{1}x^2_{1}+w_{2}x^2_{2}+b z=w1x12+w2x22+b，通过这种特征选择，多项式特征变为逻辑回归。

即
f w ⃗ , b ( x ⃗ ) = g ( z ) = g ( w 1 x 1 2 + w 2 x 2 2 + b ) f_{\vec{w},b}(\vec{x})=g(z)=g(w_{1}x^2_{1}+w_{2}x^2_{2}+b) fw ,b(x )=g(z)=g(w1x12+w2x22+b)

我们选择 w 1 , w 2 = 1 , b = − 1 w_{1},w_{2}=1,b=-1 w1,w2=1,b=−1。即 z = x 1 2 + x 2 2 − 1 z=x^2_{1}+x^2_{2}-1 z=x12+x22−1，要找到决策边界，即 z = 0 z=0 z=0，则 x 1 2 + x 2 2 − 1 = 0 x^2_{1}+x^2_{2}-1=0 x12+x22−1=0，即 x 1 2 + x 2 2 = 1 x^2_{1}+x^2_{2}=1 x12+x22=1

所得决策边界，如下图绿色曲线所示。

6.4 逻辑回归中的代价函数

成本函数为我们提供了一种方法来衡量一组特定的参数适合训练数据，从而为我们提供了一种尝试选择更好参数的方法。

上图为逻辑回归模型的训练集的样子。使用m表示训练示例的数量。每个训练样本都有一个或者多个特征，共有n个特征。由于这是一个二元分类任务，目标标签y只取两个值0或1。

逻辑回归模型由该方程定义：
f w ⃗ , b ( x ⃗ ) = 1 1 + e − ( w ⃗ ⋅ x ⃗ + b ) f_{\vec{w},b}(\vec{x})=\frac{1}{1+e^{-(\vec{w}·\vec{x}+b)}} fw ,b(x )=1+e−(w ⋅x +b)1

那么，给定上诉训练集，我们应该如何选择参数 w ⃗ \vec{w} w 和参数 b b b？

在线性回归中，误差函数为 J ( w , b ⃗ ) = 1 2 m ∑ i = 1 m ( f w ⃗ , b ( x ⃗ ( i ) − y ( i ) ) ) 2 J(\vec{w,b})=\frac{1}{2m}\sum\limits_{i=1}^{m}(f_{\vec{w},b}(\vec{x}^{(i)}-y^{(i)}))^2 J(w,b )=2m1i=1∑m(fw ,b(x (i)−y(i)))2，在这里，我们对该误差函数做一点小改动，改动为 J ( w , b ⃗ ) = 1 m ∑ i = 1 m 1 2 ( f w ⃗ , b ( x ⃗ ( i ) ) − y ( i ) ) 2 J(\vec{w,b})=\frac{1}{m}\sum\limits_{i=1}^{m}\frac{1}{2}(f_{\vec{w},b}(\vec{x}^{(i)})-y^{(i)})^2 J(w,b )=m1i=1∑m21(fw ,b(x (i))−y(i))2，将 1 2 \frac{1}{2} 21移动到了求和里面，这样使我们的数学计算更简单一些。

然而对于逻辑回归，上诉误差函数并不是一个好的选择。

为了建立一个新的代价函数，我们将用于逻辑回归。

我们可以将， L ( f w ⃗ , b ( x ⃗ ( i ) ) , y ( i ) ) L(f_{\vec{w},b}(\vec{x}^{(i)}),y^{(i)}) L(fw ,b(x (i)),y(i))看作为单个训练示例的损失。

通过上述损失函数的选择，整体代价函数将是凸的，因此我们可以放心的使用梯度下降将其求的最小值。

6.5 简化逻辑回归代价函数

这是我们定义的损失函数：
L ( f w ⃗ , b ( x ⃗ ( i ) ) , y ( i ) ) = { − l o g ( f w ⃗ , b ( x ⃗ ( i ) ) ) i f y ( i ) = 1 − l o g ( 1 − f w ⃗ , b ( x ⃗ ( i ) ) ) i f y ( i ) = 0 L(f_{\vec{w},b}(\vec{x}^{(i)}),y^{(i)})= \begin{cases} -log(f_{\vec{w},b}(\vec{x}^{(i)}))\ \ \ \ if\ y^{(i)}=1 \\ -log(1-f_{\vec{w},b}(\vec{x}^{(i)}))\ \ \ \ if\ y^{(i)}=0 \end{cases} L(fw ,b(x (i)),y(i))={−log(fw ,b(x (i))) if y(i)=1−log(1−fw ,b(x (i))) if y(i)=0

我们可以将损失函数写成：
L ( f w ⃗ , b ( x ⃗ ( i ) ) , y ( i ) ) = − y ( i ) l o g ( f w ⃗ , b ( x ⃗ ( i ) ) ) − ( 1 − y ( i ) ) l o g ( 1 − f w ⃗ , b ( x ⃗ ( i ) ) ) L(f_{\vec{w},b}(\vec{x}^{(i)}),y^{(i)})=-y^{(i)}log(f_{\vec{w},b}(\vec{x}^{(i)}))-(1-y^{(i)})log(1-f_{\vec{w},b}(\vec{x}^{(i)})) L(fw ,b(x (i)),y(i))=−y(i)log(fw ,b(x (i)))−(1−y(i))log(1−fw ,b(x (i)))

故，代价函数可以写为：
J ( w ⃗ , b ) = 1 m ∑ i = 1 m [ L ( f w ⃗ , b ( x ⃗ ( i ) ) , y ( i ) ) ] J(\vec{w},b)=\frac{1}{m}\sum\limits_{i=1}^{m}[L(f_{\vec{w},b}(\vec{x}^{(i)}),y^{(i)})] J(w ,b)=m1i=1∑m[L(fw ,b(x (i)),y(i))]

即
J ( w ⃗ , b ) = − 1 m ∑ i = 1 m [ y ( i ) l o g ( f w ⃗ , b ( x ⃗ ( i ) ) ) + ( 1 − y ( i ) ) l o g ( 1 − f w ⃗ , b ( x ⃗ ( i ) ) ) ] J(\vec{w},b)=-\frac{1}{m}\sum\limits_{i=1}^{m}[y^{(i)}log(f_{\vec{w},b}(\vec{x}^{(i)}))+(1-y^{(i)})log(1-f_{\vec{w},b}(\vec{x}^{(i )}))] J(w ,b)=−m1i=1∑m[y(i)log(fw ,b(x (i)))+(1−y(i))log(1−fw ,b(x (i)))]

上诉函数便是我们得到的代价函数。

6.6 实现梯度下降

梯度下降：

r e p e a t { w j = w j − α ∂ ∂ w j J ( w ⃗ , b ) b = b − α ∂ ∂ b J ( w ⃗ , b ) } s i m u l t a n e o u s u p d a t e repeat\{ \\w_j=w_j-\alpha\frac{\partial}{\partial w_j}J(\vec{w},b) \\ b=b-\alpha\frac{\partial}{\partial b}J(\vec{w},b)\\ \}simultaneous\ \ update repeat{wj=wj−α∂wj∂J(w ,b)b=b−α∂b∂J(w ,b)}simultaneous update

对于导数：

7. 过拟合问题与正则化

7.1 过拟合

与过拟合（具有高方差）相反的称为欠拟合（具有高偏差）。

有一种解决过拟合问题的方法称为正则化。

过拟合（overfitting）是指学习时选择的模型所包含的参数过多（即模型容量很大），以至于出现这一模型对已知数据预测得很好，但对未知数据预测得很差的现象。

过拟合是指为了得到一致假设而使假设变得过度严格。

同样，过拟合和欠拟合问题也会存在于分类问题中。

7.2 解决过拟合问题

方法一

我们可以用来防止过度拟合第一个方法是获取更多的训练数据。

方法二

解决过拟合的第二个方法是查看是否可以使用更少的特征，即减少使用特征的数量。

事实证明，如果我们拥有太多的特征，但是没有足够的训练数据，那我们的算法可能会过度拟合我们的训练集。

选择要使用的最合适的一组特征，有时也称为特征选择。

可能所有这些特征，全部都适用于算法模型，我们不想对特征进行舍弃，我们可以使用一些方法进行自动选择最合适的一组特征。

方法三

解决过拟合问题的一种技术称为正则化。正则化是一种更温和的减少某些特征的影响，而无需做像彻底消除掉某些特征。

正则化的所用是鼓励学习算法缩小参数，而不必要求将参数设置为0（删除某些特征）。

正则化保留了所有的特征，但是同时防止特征产生过大的影响，这有时会导致过度拟合。

7.3 正则化

如图，对这个数据拟合一个二次函数，它会给出一个很好的拟合。

但是如果拟合一个非常高阶的多项式，我们会得到一个过度拟合的曲线。现在考虑以下情况，如果我们有办法使参数 w 3 , w 4 w_3,w_4 w3,w4变得非常非常小，接近于0，那么变可以解决这个问题。

假设不是最小化这个目标函数，而是线性回归的成本函数。我们对成本函数进行修改（这里给参数 w 4 , w 3 w_4,w_3 w4,w3加上了参数1000，这个参数可以随意，但是要添加较大的参数值），这样实际上我们可能会得到一个惩罚模型，即：
min ⁡ w ⃗ , b 1 2 m ∑ i = 1 m ( f w ⃗ , b ( x ⃗ ( i ) ) − y ( i ) ) 2 + 1000 w 3 2 + 1000 w 4 2 \min_{\vec{w},b}\frac{1}{2m}\sum_{i=1}^{m}(f_{\vec{w},b}(\vec{x}^{(i)})-y^{(i)})^{2}+1000w_3^2+1000w_4^2 w ,bmin2m1i=1∑m(fw ,b(x (i))−y(i))2+1000w32+1000w42

我们想最小化这个函数，必须要做的是保证 w 3 , w 4 w_3,w_4 w3,w4都要变得很小。当我们最小化这个函数时，我们最终会得到 w 3 ， w 4 w_3，w_4 w3，w4都接近于0。因此，我们实际上几乎抵消了 x 3 , x 4 x^3,x^4 x3,x4两项的影响。我们这么做的话，我们最终会拟合出更接近二次函数的数据。

个人理解：将特征的权值降低 ≈ \approx ≈将特征去除

当我们在不知道哪个特征是重要的或者不重要的时候，我们无法对特征根据不重要性进行删除，这时应该使用正则化

而对于我们可以自主判断出哪些是不重要的特征，我们可以选择直接去除那些不重要的特征

正则化的实现，往往是在我们有很多特征时，我们可能不知道哪个是最重要的特征以及要惩罚的特征，因此，实现正则化的方式是惩罚所有特征，或者更准确的说，惩罚所有 w j w_j wj的参数，这通常会导致拟合更加平滑，更加简单，且不易过度拟合。

对于示例，我们的数据包含每个房屋的100个特征，我们很难提前选择要包含哪些特征以及要排除哪些特征。因此，让我们构建一个使用所有100个特征的模型。

我们有参数 w 1 , w 2 , . . . , w 100 , b w_1,w_2,...,w_{100},b w1,w2,...,w100,b，因为我们不知道这些参数中哪一个是重要的，所以让我们惩罚一下它们，即
J ( w ⃗ , b ) = 1 2 m ∑ i = 1 m ( f w ⃗ , b ( x ⃗ ( i ) ) − y ( i ) ) 2 + λ 2 m ∑ j = 1 n w j 2 J(\vec{w},b)=\frac{1}{2m}\sum_{i=1}^m(f_{\vec{w},b}(\vec{x}^{(i)})-y^{(i)})^2+\frac{\lambda}{2m}\sum_{j=1}^nw_j^2 J(w ,b)=2m1i=1∑m(fw ,b(x (i))−y(i))2+2mλj=1∑nwj2
λ \lambda λ：正则化参数

α \alpha α：学习率

第二项，即 λ 2 m ∑ j = 1 n w j 2 \frac{\lambda}{2m}\sum\limits_{j=1}^{n}w_j^2 2mλj=1∑nwj2称为正则化项。

我们必须为 λ \lambda λ选择一个数字，且 λ > 0 \lambda>0 λ>0

事实证明，通过以相同的方式缩放这两个式子，为 λ \lambda λ选择一个好的值变得更容易一些。

按照惯例，我们不会因为参数 b b b太大而惩罚它。在实践中，我们是否惩罚参数b，基本上没有什么区别。如果需要惩罚参数 b b b，则额外增加一项，即：
J ( w ⃗ , b ) = 1 2 m ∑ i = 1 m ( f w ⃗ , b ( x ⃗ ( i ) ) − y ( i ) ) 2 + λ 2 m ∑ j = 1 n w j 2 + λ 2 m b 2 J(\vec{w},b)=\frac{1}{2m}\sum_{i=1}^m(f_{\vec{w},b}(\vec{x}^{(i)})-y^{(i)})^2+\frac{\lambda}{2m}\sum_{j=1}^nw_j^2+\frac{\lambda}{2m}b^2 J(w ,b)=2m1i=1∑m(fw ,b(x (i))−y(i))2+2mλj=1∑nwj2+2mλb2

我们选择的 λ \lambda λ值制定了相对重要性或相对权衡或我们如何在式子第一项和第二项之间取得平衡。

不同 λ \lambda λ值对算法模型的影响：

• $ \lambda=0 $，正则化项不存在

• λ \lambda λ取一个非常大的数字， λ = 1 0 10 \lambda=10^{10} λ=1010，这说明我们对正则化项非常重视，这种情况下，要实现最小化，唯一方法是保证w的所有值都非常接近于0，所以会得到 f w ⃗ , b ( x ⃗ ) ≈ b f_{\vec{w},b}(\vec{x})\approx{b} fw ,b(x )≈b，这种会使模型欠拟合。

7.4 用于线性回归的正则方法

线性回归目标函数：
f w ⃗ , b ( x ⃗ ) = w ⃗ ⋅ x ⃗ + b f_{\vec{w},b}(\vec{x})=\vec{w}·\vec{x}+b fw ,b(x )=w ⋅x +b

线性回归代价函数：
J ( w ⃗ , b ) = 1 2 m ∑ i = 1 n ( f w ⃗ , b ( x ⃗ ( i ) ) − y ( i ) ) 2 J(\vec{w},b)=\frac{1}{2m}\sum\limits_{i=1}^{n}(f_{\vec{w},b}(\vec{x}^{(i)})-y^{(i)})^2 J(w ,b)=2m1i=1∑n(fw ,b(x (i))−y(i))2

线性回归梯度下降：
r e p e a t { w j = w j − α ∂ J ( w ⃗ , b ) ∂ w j b = b − α ∂ J ( w ⃗ , b ) ∂ b } s i m u l t a n e o u s u p d a t e repeat\{\qquad\qquad\qquad\qquad \\w_j=w_j-\alpha\frac{\partial J(\vec{w},b)}{\partial w_j}\\b=b-\alpha\frac{\partial J(\vec{w},b)}{\partial b}\\ \}simultaneous\ \ update repeat{wj=wj−α∂wj∂J(w ,b)b=b−α∂b∂J(w ,b)}simultaneous update

含正则项的线性回归代价函数：
J ( w ⃗ , b ) = 1 2 m ∑ i = 1 m ( f w ⃗ , b ( x ⃗ ( i ) ) − y ( i ) ) 2 + λ 2 m ∑ j = 1 n w j 2 J(\vec{w},b)=\frac{1}{2m}\sum_{i=1}^m(f_{\vec{w},b}(\vec{x}^{(i)})-y^{(i)})^2+\frac{\lambda}{2m}\sum_{j=1}^nw_j^2 J(w ,b)=2m1i=1∑m(fw ,b(x (i))−y(i))2+2mλj=1∑nwj2

含正则项的线性回归梯度下降：
r e p e a t { w j = w j − α ∂ J ( w ⃗ , b ) ∂ w j = w j − α [ 1 m ∑ i = 1 m [ ( f w ⃗ , b ( x ⃗ ( i ) ) − y ( i ) ) x j ( i ) ] + λ m w j ] b = b − α ∂ J ( w ⃗ , b ) ∂ b = b − α 1 m ∑ i = 1 m ( f w ⃗ , b ( x ⃗ ( i ) ) − y ( i ) ) } s i m u l t a n e o u s u p d a t e repeat\{ \\w_j=w_j-\alpha\frac{\partial J(\vec{w},b)}{\partial w_j}=w_j-\alpha[\frac{1}{m}\sum\limits_{i=1}^{m}[(f_{\vec{w},b}(\vec{x}^{(i)})-y^{(i)})x_{j}^{(i)}]+\frac{\lambda}mw_j] \\ b=b-\alpha\frac{\partial J(\vec{w},b)}{\partial b}=b-\alpha\frac{1}{m}\sum\limits_{i=1}^{m}(f_{\vec{w},b}(\vec{x}^{(i)})-y^{(i)}) \\ \}simultaneous\ \ update\qquad\qquad\qquad\qquad\qquad\qquad\qquad\qquad\qquad\qquad\quad repeat{wj=wj−α∂wj∂J(w ,b)=wj−α[m1i=1∑m[(fw ,b(x (i))−y(i))xj(i)]+mλwj]b=b−α∂b∂J(w ,b)=b−αm1i=1∑m(fw ,b(x (i))−y(i))}simultaneous update

因为我们没有对参数 b b b进行正则化处理，所以对于 b b b对梯度下降并没有变化。

7.5 用于逻辑回归的正则方法

逻辑回归目标函数：
f w ⃗ , b ( x ⃗ ) = g ( w ⃗ ⋅ x ⃗ + b ) = 1 1 + e − ( w ⃗ ⋅ x ⃗ + b ) f_{\vec{w},b}(\vec{x})=g(\vec{w}·\vec{x}+b)=\frac{1}{1+e^{-(\vec{w}·\vec{x}+b)}} fw ,b(x )=g(w ⋅x +b)=1+e−(w ⋅x +b)1

逻辑回归代价函数：
J ( w ⃗ , b ) = − 1 m ∑ i = 1 m [ y ( i ) l o g ( f w ⃗ , b ( x ⃗ ( i ) ) ) + ( 1 − y ( i ) ) l o g ( 1 − f w ⃗ , b ( x ⃗ ( i ) ) ) ] J(\vec{w},b)=-\frac{1}{m}\sum\limits_{i=1}^{m}[y^{(i)}log(f_{\vec{w},b}(\vec{x}^{(i)}))+(1-y^{(i)})log(1-f_{\vec{w},b}(\vec{x}^{(i )}))] J(w ,b)=−m1i=1∑m[y(i)log(fw ,b(x (i)))+(1−y(i))log(1−fw ,b(x (i)))]

逻辑回归梯度下降：
r e p e a t { w j = w j − α ∂ ∂ w j J ( w ⃗ , b ) b = b − α ∂ ∂ b J ( w ⃗ , b ) } s i m u l t a n e o u s u p d a t e repeat\{\qquad\qquad\qquad\qquad \\w_j=w_j-\alpha\frac{\partial}{\partial w_j}J(\vec{w},b) \\ b=b-\alpha\frac{\partial}{\partial b}J(\vec{w},b) \\ \}simultaneous\ \ update repeat{wj=wj−α∂wj∂J(w ,b)b=b−α∂b∂J(w ,b)}simultaneous update

含正则项的逻辑回归代价函数：
J ( w ⃗ , b ) = − 1 m ∑ i = 1 m [ y ( i ) l o g ( f w ⃗ , b ( x ⃗ ( i ) ) ) + ( 1 − y ( i ) ) l o g ( 1 − f w ⃗ , b ( x ⃗ ( i ) ) ) ] + λ 2 m ∑ j = 1 n w j 2 J(\vec{w},b)=-\frac{1}{m}\sum\limits_{i=1}^{m}[y^{(i)}log(f_{\vec{w},b}(\vec{x}^{(i)}))+(1-y^{(i)})log(1-f_{\vec{w},b}(\vec{x}^{(i )}))]+\frac{\lambda}{2m}\sum\limits_{j=1}^nw_j^2 J(w ,b)=−m1i=1∑m[y(i)log(fw ,b(x (i)))+(1−y(i))log(1−fw ,b(x (i)))]+2mλj=1∑nwj2

含正则项的逻辑回归梯度下降：
r e p e a t { w j = w j − α ∂ J ( w ⃗ , b ) ∂ w j = w j − α [ 1 m ∑ i = 1 m [ ( f w ⃗ , b ( x ⃗ ( i ) ) − y ( i ) ) x j ( i ) ] + λ m w j ] b = b − α ∂ J ( w ⃗ , b ) ∂ b = b − α 1 m ∑ i = 1 m ( f w ⃗ , b ( x ⃗ ( i ) ) − y ( i ) ) } s i m u l t a n e o u s u p d a t e repeat\{\qquad \\w_j=w_j-\alpha\frac{\partial J(\vec{w},b)}{\partial w_j}=w_j-\alpha[\frac{1}{m}\sum\limits_{i=1}^{m}[(f_{\vec{w},b}(\vec{x}^{(i)})-y^{(i)})x_{j}^{(i)}]+\frac{\lambda}mw_j] \\ b=b-\alpha\frac{\partial J(\vec{w},b)}{\partial b}=b-\alpha\frac{1}{m}\sum\limits_{i=1}^{m}(f_{\vec{w},b}(\vec{x}^{(i)})-y^{(i)}) \\ \}simultaneous\ \ update\qquad\qquad\qquad\qquad\qquad\qquad\qquad\qquad\qquad\qquad\quad repeat{wj=wj−α∂wj∂J(w ,b)=wj−α[m1i=1∑m[(fw ,b(x (i))−y(i))xj(i)]+mλwj]b=b−α∂b∂J(w ,b)=b−αm1i=1∑m(fw ,b(x (i))−y(i))}simultaneous update

---

8. 了解深度学习

8.1 神经元和大脑

神经网络开始的动机是试图建立模拟大脑的软件。

生物神经元简化图：

8.2 神经网络工作流程

在下面例子中，我们有4个特征，预测一件T恤是否畅销。特征是T恤的价格、运费、特定T恤的营销量、材料质量。

我们要做的是创建一个人工神经元来尝试估计这件T恤被认为非常实惠的概率。

支付能力主要是价格和运费的函数，因为支付的总额是价格加上运费的一部分。

我们将在这里使用一个小神经元，一个逻辑回归单元来输入价格和运输成本，并预测人们是否认为这是负担得起的。

其次，我们再使用一个人工神经元来估计一下，人们是否对该T恤有很高的认识。在这种认识下，知名度主要是T恤的营销功能。

最后，在创建一个神经元来估计人们是否认为该T恤是高质量的，这可能主要是T恤价格和材料质量的函数。价格是这里的一个因素，因为幸运或者不幸，如果有一件价格非常高的T恤，人们有时会认为它是高质量的，因为它比人们认为的高质量贵的多。

鉴于这些对可负担性、意识和感知质量的估计，我们然后将这三个神经元的输出连接到右侧的另一个神经元，然后有另一个逻辑回归单元。最后输入这三个数字并输出这件T恤成为畅销商品的概率。

在神经网络的术语中，我们将把这三个神经元组合在一起，形成所谓的层。层是一组神经元，它们将相同或相似的特征作为输入，然后一起输出一些数字。

一层可以有多个神经元，也可以只有一个神经元。

左边的这三个神经元形成一层，这就是我将它们画在彼此之上的原因，右边的这个单个神经元，也是一层。右边的这一层也称为输出层 ，因为这个最终神经元的输出是神经网络预测的输出概率。左边包含四个数字的这一层也称为输入层 。中间层的名字叫做隐藏层。

在神经网络术语中，我们还将这个例子中的购买能力、意识和感知质量称为激活。激活一词来源于生物神经元，它指的是生物神经元向其下游的其他神经元发送高输出值或发送许多点脉冲的程度。

这些关于可负担性、意识和感知质量的数字是该层中这三个神经元的激活。而且这个输出概率是右侧显示的这个神经元的激活。

因此，这个特定的神经网络执行以下计算：

1. 它输如四个数字，然后神经网络的这一层使用这四个数字来计算新数字，新的数字也称为激活值。
2. 然后是最后一层，神经网络的输出层使用这三个数字来计算一个数字

现在，对神经网络做一个简化：

到目前为止，我们所描述的方式是，我们必须一次一个的检查神经元，并决定它将从前一层获取哪些输入。例如，我们说负担能力只是价格和运输成本的函数，认知度是营销的函数等等，但如果我们正在构建一个大型神经网络，那么需要我们进行大量工作并手动决定哪些神经元应该将哪些特征作为输入。

神经网络在实践中实现特定层中每个神经元的方式，比如说中间的这一层，将可以访问每个特征，从上一层，从输入层访问每个值。

如果我们试图预测支付能力并且知道运费和材料的价格是多少，我们可能学会忽略营销和材料质量，只是通过适当的设置参数来找出只关注的子集与支付能力最相关的因素。

为了进一步简化啊这个神经网络的符号和描述，我们将采用这四个输入特征并将它们写成一个向量 x ⃗ \vec{x} x ，我们将把神经网络视为具有构成这个特征向量x的四个特征。该特征向量被馈送到中间的这一层，然后计算三个激活值。也就是说，这些数字和这三个激活值依次变成另一个向量，该向量被馈送到这个最终输出层，最终输出这件T恤成为畅销品的概率。

含有多个隐藏层的例子：

在当我们构建自己的神经网络时，我们需要做出的决定之一是我们想要多少个隐藏层，以及我们希望每个隐藏层有多少个神经元，这属于神经网络的架构问题。对隐藏层层数和每层神经元数量的选择，会对学习算法的性能产生影响。

具有多层的神经网络，称为多层感知器（多层感知机）。

多层感知器（MLP，Multilayer Perceptron）是一种前馈人工神经网络模型，将输入的多个数据集映射到单一的输出的数据集上。

8.3 神经网络的结构

对于我们在上面的例子中，预测一件T恤是否畅销。我们将其隐藏层放大来看，以查看其计算：

这个隐藏层输入四个数字，这四个数字是三个神经元中每一个的输入。这三个神经元中的每一个都只是在实现一个小逻辑回归单元或一个小逻辑回归函数。

以第一个神经元为例，它有两个参数 w ⃗ , b \vec{w},b w ,b。事实上，为了表示这是第一个隐藏单元，我们为其添加下标，写为 w ⃗ 1 , b 1 \vec{w}_1,b_1 w 1,b1。它所做的是将输出一些激活值a，为了表示这是第一个神经元，我们要为激活值a添加下标， a 1 = g ( w ⃗ 1 ⋅ x ⃗ + b 1 ) a_1=g(\vec{w}_1·\vec{x}+b_1) a1=g(w 1⋅x +b1)。假设输出的这个数字是0.3，这就是第一个神经元的激活值a。即有0.3的可能性，人们认为该T恤是实惠的。

对于第二个神经元，有参数 w ⃗ 2 , b 2 \vec{w}_2,b_2 w 2,b2，这些参数就是第二个逻辑单元的参数。它计算 a 2 = g ( w ⃗ 2 ⋅ x ⃗ + b 2 ) a_2=g(\vec{w}_2·\vec{x}+b_2) a2=g(w 2⋅x +b2)，我们假设其结果为0.7。即有0.7的可能人们知道这件T恤。

对于第三个神经元，有参数 w ⃗ 3 , b 3 \vec{w}_3,b_3 w 3,b3，它计算激活值 a 3 = g ( w ⃗ 3 ⋅ x ⃗ + b 3 ) a_3=g(\vec{w}_3·\vec{x}+b_3) a3=g(w 3⋅x +b3)，假设它的结果是0.2。

上面的三个激活值构成激活向量 a ⃗ = ( a 1 a 2 a 3 ) \vec{a}={\left(\begin {array}{c} a_1 \\ a_2 \\ a_3 \\ \end{array}\right)} a = a1a2a3 ，然后传递到这个神经网络的最终输出层。

在当我们构建具有多层的神经网络时，为各层指定不同的数字会很有用。在本例子中，我们将中间层，即隐藏层称为神经网络的第1层，输出层称为神经网络的第二层。输入层有时也曾为第0层。

为了引入符号来帮助我们区分不同的层，我们将使用上标方括号来索引到不同的层。 即 a ⃗ [ 1 ] = ( a 1 a 2 a 3 ) \vec{a}^{[1]}={\left(\begin {array}{c} a_1 \\ a_2 \\ a_3 \\ \end{array}\right)} a [1]= a1a2a3 。这里的 w ⃗ 1 , b 1 \vec{w}_1,b_1 w 1,b1是第一个单元
a 1 [ 1 ] = g ( w ⃗ 1 [ 1 ] ⋅ x ⃗ + b 1 [ 1 ] ) a 2 [ 1 ] = g ( w ⃗ 2 [ 1 ] ⋅ x ⃗ + b 2 [ 1 ] ) a 3 [ 1 ] = g ( w ⃗ 3 [ 1 ] ⋅ x ⃗ + b 3 [ 1 ] ) a_1^{[1]}=g(\vec{w}_1^{[1]}·\vec{x}+b_1^{[1]})\\ a_2^{[1]}=g(\vec{w}_2^{[1]}·\vec{x}+b_2^{[1]})\\ a_3^{[1]}=g(\vec{w}_3^{[1]}·\vec{x}+b_3^{[1]}) a1[1]=g(w 1[1]⋅x +b1[1])a2[1]=g(w 2[1]⋅x +b2[1])a3[1]=g(w 3[1]⋅x +b3[1])

下面，放大神经网络的第2层，即输出层，来查看其计算：

第二层的输入是第一层的输出，因此 a ⃗ [ 1 ] \vec{a}^{[1]} a [1]是我们刚刚假设的值 a ⃗ [ 1 ] = ( 0.3 0.7 0.2 ) \vec{a}^{[1]}={\left(\begin {array}{c} 0.3 \\ 0.7 \\ 0.2 \\ \end{array}\right)} a [1]= 0.30.70.2 。

因为输出层只有一个神经元，所以它所做的只是计算 a 1 a_1 a1，这是唯一一个神经元的输出， a 1 = g ( w ⃗ 1 ⋅ a ⃗ [ 1 ] + b 1 ) a_1=g(\vec{w}_1·\vec{a}^{[1]}+b_1) a1=g(w 1⋅a [1]+b1)。 我们假设结果为0.84。

按照之前的约定，我们应该为结果和参数加上上标，因为这是在神经网络第2层，所以上标为2，即 a 1 [ 2 ] = g ( w ⃗ 1 [ 2 ] ⋅ a ⃗ [ 1 ] + b 1 [ 2 ] ) a_1^{[2]}=g(\vec{w}_1^{[2]}·\vec{a}^{[1]}+b_1^{[2]}) a1[2]=g(w 1[2]⋅a [1]+b1[2])。

神经网络计算出结果后，我们可以选择执行或者不执行最后一个可选步骤，即我们是否想要进行二进制预测，1或0，这是畅销产品吗？

8.4 神经网络的前向传播

让我们把我们学到的东西组合成一个算法，让我们的神经网络进行推理或预测。 这将是一种称作向前传播的算法。

这里引入一个手写数字识别的例子， 为了简单起见，我们只识 别数字0和数字1。所以这是一个二进制分类问题。对于手写示例，我们采用8×8的图像。 因此这个手写数字图像是一个64像素的图像。255表示明亮的白色像素。0表示黑色像素。

鉴于64个输入特征，我们使用具有两个隐藏层的神经网络。 其中第一个隐藏层有25个神经元，第二个隐藏层有15个神经元 ，最后是输出层对是1或者是0的概率进行输出。

第一个计算是从 x ⃗ \vec{x} x 到 a ⃗ [ 1 ] \vec{a}^{[1]} a [1]，这就是第一个隐藏层做的。

上面，我们只计算了 a ⃗ [ 1 ] \vec{a}^{[1]} a [1]，下一步，即第二个隐藏层计算 a ⃗ [ 2 ] \vec{a}{[2]} a [2]。

现在我们计算了 a ⃗ [ 2 ] \vec{a}^{[2]} a [2]， 最后一步是计算 a ⃗ [ 3 ] \vec{a}^{[3]} a [3]。 因为 a ⃗ [ 3 ] \vec{a}^{[3]} a [3]只有一个数字，所以 a [ 3 ] a^{[3]} a[3]是一个标量。

最后，我们可以为 a ⃗ [ 3 ] \vec{a}^{[3]} a [3]设置阀值0.5，以得出二进制分类标签。

因为神经网络中的整个计算是从左到右进行的，所以我们从 x x x开始计算 a [ 1 ] a^{[1]} a[1]，然后 a [ 2 ] a^{[2]} a[2]，再是 a [ 3 ] a^{[3]} a[3]。

所以这个也叫做前向传播，因为我们在传播神经元的激活。这与用于学习的反向传播或反向传播的不同算法形成对比。

这种类型的神经网络架构，最初有更多的隐藏单元，然后随着离输出层越来越近，隐藏单元的数量会减少。

在选择神经网络架构时，还有一个非常典型的选择。

8.5 代码实现推理

Tensorflow是实施深度学习算法的领先框架之一。 另一个流行的框架是Pytorch。

下面使用Tensorflow实现推理代码。

神经网络的一个显著特点是可以将相同的算法应用于许多不同的应用程序。

下面有一个例子，让学习算法来帮助我们优化从烘培过程中得到的咖啡豆的质量。

当我们在烘培时， 我们需要控制的两个参数是温度及时长。 在这个稍微简化的示例中，我们创建了不同温度及不同持续时间的数据集，以及显示我们烘培的咖啡豆是否是美味咖啡的标签。

红色代表好的咖啡豆，蓝色代表差的咖啡豆。

该任务被赋予一个具有温度和持续时间的特征向量 x ⃗ \vec{x} x ，比如200摄氏度持续17分钟 ，我们如何在神经网络中进行推理以让它告诉我们这个温度和持续时间设置是否会产生好咖啡。

我们将x设置为两个数字的数组，输入具有200摄氏度和17分钟。 然后创建第1层作为第一个隐藏层，units=3指这里的一个隐藏层包含三个神经单元，activation=sigmoid至激活函数为 sigmoid函数。 这里的Dense 只是这一层的名称。随着我们对神经网络的了解，我们也会了解其他类型的层。接下来，我们使 用第一层来计算 a ⃗ [ 1 ] \vec{a}^{[1]} a [1]。

x = np.array([200.0,17.0])
layer_1 = Dense(units=3,activation='sigmoid')
a1 = layer_1(x)

这就是我们如何得到 a ⃗ [ 1 ] \vec{a}^{[1]} a [1]，它是一个包含三个数字的列表，因为第一层有三个单位。所以这里的 a ⃗ [ 1 ] \vec{a}^{[1]} a [1]为了说明起见，可以取0.2，0.7，0.3。

接下来，对于第二个隐藏层，它只有一个神经元， 同时sigmoid作为激活函数，我们在第二层隐藏层应用激活值 a ⃗ [ 1 ] \vec{a}^{[1]} a [1]来计算 a ⃗ [ 2 ] \vec{a}^{[2]} a [2]。 为了说明起见，我们假设其值为0.8。

layer_2 = Dense(units=1,activation='sigmoid')
a2 = layer_2(a1)

最后，如果我们希望将其阀值设置为0.5，那么我们可以只测试 a ⃗ [ 2 ] \vec{a}^{[2]} a [2]是否大于0.5，并相应的将 y ^ \hat{y} y^设置为1或者0。

8.6 Tensorflow中数据形式

numpy和tensorflow中的数据表示方式存在一些不一致。

在我们之前处理线性回归和逻辑回归时，我们习惯使用一维向量来表示输入特征X。而对于Tensorflow的惯例是使用矩阵来表示数据。

TensorFlow旨在处理非常大的数据集，并且通过在矩阵而不是一维数组中表示数据，它让Tensorflow在内部的计算效率更高一些。

Numpy数据传入TensorFlow中进行处理时，数据会被转化为张量tensor。

8.7 搭建一个神经网络

张量tensor流有不同的方式来实现向前传播。

使用TensorFlow不需要我们手动获取数据并将数据传递到第一层，然后将第一层激活传递到第二层。

相反，我们可以告诉张量流，我们希望它采用第一层和第二层并将它们串在一起形成一个神经网络。这就是TensorFlow顺序函数所做的。

---

9. 前向传播

9.1 单个网络层上的前向传播

9.2 前向传播的一般实现

可以编写一个函数来实现密集层，即神经网络的单层。

定义密集函数，将前一层的激活以及给定层中神经元的参数 w w w和 b b b作为输入。

---

10. 强人工智能 AGI

即通用人工智能。

人工智能可以分为弱人工智能(Artificial Narrow Intelligence，简称ANI)、强人工智能(Artificial General Intelligence简称AGI，也称为通用人工智能)、人工智能(Artificial Superintelligence简称ASI)三个等级。

---

11. Tensorflow实现

如果给我们一组包含图像x多训练集，以及真实标签Y，我们将如何训练该神经网络的参数呢？

在Tensorflow中用于训练此网络的代码：

要求Tensorflow编译模型的关键步骤是指定要使用的损失函数。这里我们使用二元交叉熵损失函数。

训练模型：

• 第一步是指定模型，告诉Tensorflow如何计算推理
• 第二步使用特定的损失函数编译模型
• 第三步是训练模型

---

12. 激活函数

12.1 sigmoid激活函数的替代方案

sigmoid函数也叫Logistic函数，用于隐层神经元输出，取值范围为(0,1)，它可以将一个实数映射到(0,1)的区间，可以用来做二分类。在特征相差比较复杂或是相差不是特别大时效果比较好。

线性整流函数（ReLU），,又称修正线性单元 , 是一种人工神经网络中常用的激活函数，通常指代以斜坡函数及其变种为代表的非线性函数。

ReLU：
g ( z ) = m a x ( 0 , z ) g(z) = max(0,z) g(z)=max(0,z)

12.2 选择激活函数

事实证明，根据目标标签或真实标签Y是什么，输出层的激活函数会有一个相当自然的选择。

1. 输出层

如果是处理二元分类问题，我们可以在输出层使用sigmoid函数。

如果我们要解决回归问题，则可以选择使用线性激活函数。

如果y只能取非负值，那么最自然的选择就是ReLU函数。

2. 隐藏层

事实证明，ReLU激活函数是迄今为止许多从业者训练神经网络的最常见的选择。

ReLU的计算速度要优于Sigmoid函数。

如果有二分类问题，则建议使用sigmoid函数。

如果y可以取正值或负值，再或者y只能取正值和零，则使用ReLU。

对于隐藏层，建议使用ReLU作为默认激活函数。在Tensorflow中，这就是它的实现方式。

---

13. 多分类问题

13.1 多分类问题概述

多分类是指分类问题，其中我们可以有两个以上可能的输出标签，而不仅仅是0或1。例如，手写数字识别分类问题。

13.2 Softmax

softmax回归算法是逻辑回归算法的推广，使用它我们将可以执行多类分类问题。

softmax回归 (softmax regression)其实是 logistic 回归的一般形式，logistic 回归用于二分类，而 softmax 回归用于多分类。

逻辑回归，二分类，两种结果的概率相加之和要为1。

现在，让我们将其推广到softmax回归，我们可以通过一个具体示例来说明何时y可以采用四种可能的输出，因此y可以采用值1，2，3，4。

主要公式：
z j = w j ⃗ ⋅ x ⃗ + b j j = 1 , 2 , . . . , N a j = e z j ∑ k = 1 N e z k = P ( y = j ∣ x ⃗ ) z_j = \vec{w_j}·\vec{x}+b_j\ \ \ \ \ j=1,2,...,N \\ a_j = \frac{e^{z_j}}{\sum_{k=1}^Ne^{z_k}}=P(y=j|\vec{x}) zj=wj ⋅x +bj j=1,2,...,Naj=∑k=1Nezkezj=P(y=j∣x )

注意：由上述公式得到 a 1 a 2 . . . a N a_1\ a_2\ ...\ a_N a1 a2 ... aN有 a 1 + a 2 + . . . + a N = 1 a_1+a_2+...+a_N=1 a1+a2+...+aN=1

定义了softmax回归函数后，下面了解如果指定softmax回归的成本函数。

对于逻辑回归的成本函数：

对于softmax回归的成本函数：

13.3 神经网络的Softmax输出

如果我们现在想用10个类别进行手写数字分类，所有数字都从0到9，那么我们将把这个神经网络改为有10个输出单元。

这个新的输出层，将是一个softmax输出层。所以有时我们会说这个神经网络有一个softmax输出，或者这个上层是一个softmax层。

13.4 多标签分类

有一种不同类型的分类问题称为多标签分类问题，其中每个图像的关联，它们可能是多个标签。

上图是一个多标签分类问题的示例，因为与单个输入相关联的图像X是三个不同的标签，对应于图像中是否有任何汽车、公共汽车或者行人。

注意：不可以将多标签分类和多分类问题相混淆！

---

14. 高级优化

14.1 高级优化方法

梯度下降是一种广泛用于机器学习的优化算法，是线性回归和逻辑回归等许多算法以及神经网络早期实现的基础。

但事实证明，现在有一些其他优化算法可以最小化成本函数，甚至比梯度下降更好。

如上图，我们进行梯度下降，我们回注意到梯度下降的每一步几乎都在同一个方向上，当看到这种情况时，我们会想，为什么我们不把Alpha变大，我们能不能拥有一个算法自动增加Alpha？这样就可以采取更大的步长并更快的达到最小值。

有一种Adam算法可以做到这一点。

当学习率较大时，Adam算法也可以自动将学习率调整变小，这样就可以采用更平滑的路径走向成本函数的最小值。

Adam 是一种可以替代传统随机梯度下降过程的一阶优化算法，它能基于训练数据迭代地更新神经网络权重。

Adam 算法和传统的随机梯度下降不同。随机梯度下降保持单一的学习率 α \alpha α更新所有的权重，学习率在训练过程中并不会改变。而 Adam 通过计算梯度的一阶矩估计和二阶矩估计而为不同的参数设计独立的自适应性学习率。

adam算法并没有使用单一的全局学习率，它对模型的每个参数使用不同的学习率。

Adam算法背后的思想是，如果参数 w j w_j wj或 b b b似乎继续沿大致相同的方向移动，此时应增加该参数的学习率。

相反，如果参数不断来回振荡，此时应该减小该参数的学习率。

14.2 其他的网络层类型

到目前为止，我们所使用的神经网络层都是密集层类型，其中该层的每个神经元都从前一层获得所有激活输入。

事实证明，还有一些其他类型的层以及其他属性。

在密集层时，我们一直在使用神经元的激活，比如第二个隐藏层是前一层的每个激活的函数。

对于某些应用层序，设计神经网络的人可能会选择使用其他不同类型的层。

其中另外一种层叫做卷积层。

例子：

左边部分显示的是输入X，是一个手写数字9。我们要做的是构建一个隐藏层，它将计算不同的激活作为这个输入图像X的函数。

隐藏层中的每个神经元并不能查看这个图像中的所有像素，每个元素只能查看部分指定区域的元素。

那么，为什么要这么处理呢？为什么不让神经元查看图像的所有像素，而只查看部分像素呢？

首先，这么处理加快了计算速度。

其次，使用这种称为卷积层的神经网络，可以需要更少的训练数据，或者也不太容易过度拟合。

这种每个神经元只查看输入图像区域的层类型称为卷积层。

如果神经网络中有多个卷积层，则有时会将该神经网络称为卷积神经网络（CNN）。

模型	模型结构	特征表示能力	训练效率	模型复杂度	鲁棒性
CNN	局部连接、权值共享的卷积结构	对局部特征提取能力强，适用于图像、语音等领域	训练效率高，可并行化处理	模型结构相对简单，参数较少，不适用于处理序列数据	对数据噪声、变形等鲁棒性一般
RNN	具有循环连接的结构，如LSTM、GRU等	适用于处理序列数据，能够捕捉序列信息的演化过程	训练效率相对较低，难以并行化	模型结构相对复杂，参数较多	对数据噪声、变形等具有一定的鲁棒性
Transformer	基于自注意力机制的结构	具有较强的建模能力，适用于处理序列、图像等多种数据形式	训练效率较高，可并行化处理	模型结构较为复杂，参数较多	对数据噪声、变形等具有较强的鲁棒性

卷积神经网络举例：

---

15. 模型评估与选择

15.1 决定下一步做什么

当我们在训练模型时，发现这个模型在预测中出现了无法接受的大错误，那么接下来该尝试做些什么呢？

我们通常可以尝试许多不同的方法。

• 获取更多的训练示例
• 尝试选择较小的特征集
• 增加更多的特征
• 尝试添加多项式特征
• 增大或者减小正则化参数$\ \lambda \ $的值

15.2 模型评估

以学习预测房价函数为例。假设我们已经训练模型预测函数作为房子大小X的函数。

对于四阶多项式的模型

我们不太喜欢上面的这个模型，即使该模型已经很好的拟合了训练数据，但是我们认为它无法泛化到不存在于训练集中的新示例。

所以，当我们预测价格时，只是房子的大小这一单一特征，我们可以像这样绘制模型，但是这不是一个好的模型。

评估模型的方法：

如果我们有一个训练集，而且这是一个只有10个例子的小训练集，而不是用我们所有的数据来训练模型的参数w和b，我们可以将训练集分成两个子集，即训练集和测试集。我们在训练集的数据上来训练模型，然后在测试集的数据上测试模型的表现。

大部分数据作为训练集，一小部分数据作为测试集。

通过分别计算 J t r a i n J_{train} Jtrain和 J t e s t J_{test} Jtest，可以衡量该模型在训练集和测试集上的表现。

回归问题：

因此，为了训练模型，并对其进行评估，下面是使用具有平方误差成本的线性回归的样子。

首先通过最小化w，b的成本函数 J J J来拟合参数。

然后，计算该模型在测试集上的均方误差。不包括正则项！

然后，计算该模型在训练集上的均方误差。不包括正则项！

分类问题：

例如，我们要对0和1的手写数字进行分类，与之前一样，我们可以通过最小化成本函数来拟合参数以找到w，b。

首先通过最小化w，b的成本函数 J J J来拟合参数。

然后，计算该模型在测试集上的均方误差。不包括正则项！

然后，计算该模型在训练集上的均方误差。不包括正则项！

当将机器学习应用于分类问题时，实际上还有一种可能更常用的 J t e s t J_{test} Jtest和 J t r a i n J_{train} Jtrain的定义。不使用逻辑损失来计算测试误差，而是使用训练误差来衡量测试集的分数和算法错误分类的训练集的分数。因此，特别是在测试集上，我们可以让算法对每个测试示例做出1或0的预测。

个人理解：对于逻辑回归来说，可以通过计算误判占比的方法来代表成本函数，比如test set中误判的占比是10％，那么 J t e s t J_{test} Jtest就是0.1

15.3 模型选择及交叉验证测试集的训练方法

当模型的参数 w w w和 b b b已经适合训练集，训练误差可能不是一个很好的指标来表明算法的效果如何，他不能代表该模型对测试集的泛化能力。

如果拟合一个函数来预测房价或者其他一些回归问题，我们可能会考虑的一种模型是拟合这样的线性模型。

下面我们用 d = 1 d=1 d=1来表示拟合一阶多项式， d = 2 d=2 d=2来表示拟合二阶多项式...

我们可以查看上面所有计算出来的 J t e s t J_{test} Jtest，看看哪一个可以得到最小值。

假设我们发现 J t e s t ( w < 5 > , b < 5 > ) J_{test}(w^{<5>},b^{<5>}) Jtest(w<5>,b<5>)的值是最小的，那么我们可以认为 d = 5 d=5 d=5这个模型的效果最好，因此我们选择该模型。

但是，这个过程存在着缺陷，这样选择一个测试数据误差最小的模型，泛化误差低于实际误差，个人理解，可能会导致过拟合。

另一方面，这里的测试数据用作检测模型表现的同时，同时也用作了模型的选择。

如果我们想自动选择一个模型，比如决定使用什么次数的多项式，下面是我们如何修改训练和测试程序来进行模型选择。这里的模型选择，是指在不同的模型中进行选择。

方法：

我们将数据不再是分为两部分，即训练集和测试集。而是将我们的数据分成三个不同的子集，我们将其称为训练集、交叉验证集和测试集。如，我们可以将60%的数据作为训练集，20%的数据作为交叉验证集，20%的数据作为测试集。cv代表交叉验证集。

交叉验证集（Cross-Validation，cv）是一个额外的数据集，我们将使用它来检查或信任检查不同模型的有效性或者准确性。

交叉验证集也可以简称为验证集，或者开发集。

在训练集，交叉验证集，测试集的子集上，我们可以使用下面的公式来计算训练误差，交叉验证误差和测试误差。这些术语中，除了被称为交叉验证误差外，通常也简称为验证误差，开发集误差，或者开发误差。

有了这三种算法性能的衡量标准，我们就可以着手进行模型的选择。

和前面一样，我们采取同样的方法进行计算误差，但是在模型选择时，我们使用交叉验证集，而不再使用测试集进行计算。

然后选择 J c v J_{cv} Jcv，即交叉验证误差最小的模型，此时没有任何的参数 w w w和 b b b拟合到测试集上，我们此时再计算该模型在测试集上的误差 J t e s t J_{test} Jtest。

上述方法也适用于在其他类型的模型中进行选择，如神经网络架构中，可以帮助我们确定神经网络中有多少层以及每层应该有多少个隐藏的神经元。

训练、选择模型、测试

---

16. 诊断与改进

16.1 通过偏差与方差进行诊断

Bias 是用所有可能的训练数据集 训练出的所有模型 的输出的平均值 与真实模型的输出值之间的差异。

Variance 是不同的训练数据集训练出的模型输出值之间的差异。

欠拟合：模型不能适配训练样本，有一个很大的偏差。

过拟合：模型很好的适配训练样本，但在测试集上表现很糟，有一个很大的方差。

查看学习算法的偏差和方差可以为我们下一步尝试提供很好的指导。

理解偏差与方差

诊断方差与偏差

16.2 正则化、偏差、方差

下面，我们来看一下正则化，特别是正则化参数 λ \lambda λ如何影响偏差与方差，进而影响算法的性能。

下面的例子中，我们使用四阶多项式，同时使用正则化来拟合这个模型。

当我们取 λ = 1000 \lambda=1000 λ=1000时，此时 λ \lambda λ的值很大，导致 w 1 ≈ 0 ， w 2 ≈ 0 w_1\approx0，w_2\approx0 w1≈0，w2≈0。所以此时 f w ⃗ , b ( x ⃗ ) = b f_{\vec{w},b}(\vec{x})=b fw ,b(x )=b。

当我们取 λ = 0 \lambda=0 λ=0，此时 λ \lambda λ的值很小，相当于没有进行正则化处理，所以我们只是拟合了一个没有进行正则化的四阶多项式，我们会得到一个过度拟合的曲线。

当我们取 λ \lambda λ为一个中间合适值的时候，它会恰到好处并且适合小 J t r a i n J_{train} Jtrain和小 J c v J_{cv} Jcv的数据。如果我们想确定什么是用于正则化参数良好的 λ \lambda λ值，交叉验证是一个很好的方法。

使用交叉验证的方法，来帮助我们确定选择正则化参数 λ \lambda λ，类似于使用交叉验证选择多项式模型的过程。

分别选取不同的 λ \lambda λ的值，然后分别计算它们的代价函数，取得最优参数 w ， b w，b w，b，然后计算 J c v J_{cv} Jcv，选取 J c v J_{cv} Jcv对应最小的 λ \lambda λ的值。

16.3 制定一个用于性能评估的基准

为了判断训练误差是否高，事实证明，查看训练误差是否远高于人类的表现水平很有用。

当我们将其与人类水平的性能进行基准测试时，我们发现该算法实际上在训练集上表现相当不错，但更大的问题是交叉验证误差远高于训练误差。

基准性能水平是指我们可以合理地希望我们的学习算法最终达到的误差水平。

建立基准性能水平的一种常见方法是衡量人类在这项任务上的表现。

另一种建立基准性能水平的方法是，以其他人已经实现的算法性能最为基准性能水平。

或者我们可以根据以往的经验，来建立基准性能水平。

16.4 学习曲线

学习曲线是一种帮助理解我们的学习算法如何作为它拥有的经验量的函数的方法。这里的经验是指它拥有的训练示例的数量。

下面，绘制一个适合二阶多项式二次函数模型的学习曲线。我们将会值交叉验证误差和训练误差。

由上图，我们可以看出训练集的大小变大，我们会得到一个更好的模型，因此交叉验证误差变小。但是，训练集变大，训练误差反而也随之变大了。为什么会导致这样呢？

由上图，我们可以理解，随着训练集的增大，训练误差是增大的。但是，训练集的增大，会使模型的泛化能力提高。

下面看一下学习曲线对于具有高偏差的平均值与具有高方差的平均值的学习曲线是什么样的。

高偏差

高方差

增大数据集，可以缓解过拟合。

16.5 方差与偏差

• 增加训练集数量，有助于解决高方差、过拟合问题。
• 减少使用的特征，有助于解决高方差、过拟合问题。
• 增加额外的特征，有助于解决高偏差、欠拟合问题。
• 添加多项式特征，有助于解决高偏差、欠拟合问题。
• 降低正则化参数，有助于解决高偏差、欠拟合问题。
• 增大正则化参数，有助于解决高方差、过拟合问题。

综上所述：

• 解决高方差、过拟合问题：增大训练集、减少特征、增大正则化参数
• 解决高偏差、欠拟合问题：增加特征、添加多项式特征、降低正则化参数

高方差和高偏差都不好，因为它们会损害算法的性能。

---

17. 机器学习系统开发过程

17.1 误差分析过程

假设我们有500个交叉验证示例，并且我们的算法错误分类了这500个交叉验证示例中的100个，错误分析只是手动查看这100个示例，并试图深入了解算法出错的地方。

17.2 添加更多数据

数据增强也叫数据扩增，意思是在不实质性的增加数据的情况下，让有限的数据产生等价于更多数据的价值。

数据增强分类：

1. 数据增强可以分为，有监督 的数据增强和无监督的数据增强方法。
2. 其中有监督的数据增强又可以分为单样本 数据增强和多样本数据增强方法。
3. 无监督的数据增强分为生成新的数据 和学习增强策略两个方向。

有监督数据增强，即采用预设的数据变换规则 ，在已有数据的基础上进行数据的扩增。

它包含单样本 数据增强和多样本 数据增强。

其中单样本 又包括几何操作类 ，颜色变换类。

所谓单样本数据增强，即增强一个样本的时候，全部围绕着该样本本身进行操作，包括几何变换类，颜色变换类等。

多样本数据增强，不同于单样本数据增强，多样本数据增强方法利用多个样本来产生新的样本。

17.3 迁移学习

对于我们没有那么多数据的应用程序，迁移学习是一种很好的技术，它可以让我们使用来自不同任务的数据来帮我们的应用程序。

工作原理：

假设我们想要识别从0到9点手写数字，但是我们没有这些手写数字的那么多标记数据。假设我们找到了一个非常大的数据集，其中包含一百万张猫、狗、汽车、人等的图片，一千个类别。然后，我们可以开始在这个包含一千个不同类别的一百万张图像的大型数据集上训练神经网络，并训练算法将图像X作为输入，并学习识别这1000个不同类别中的任何一个。

要应用迁移学习，我们要做的是复制此神经网络。但是对于最后一层，我们将消除输出层，并用一个更小的输出层替换它，只有10个而不是1000个输出单元。在迁移学习中，我们可以使用前四层的参数，实际上是除最终输出层之外的所有层作为参数的起点，然后运行优化算法，例如梯度下降或Adam优化算法，使用来自该神经网络的值在顶部初始化的参数。

具体来说，如何训练此神经网络参数有两种选择：

• 只训练输出层参数，我们可以将参数 w [ 1 ] , b [ 1 ] ⃗ , w [ 2 ] , b [ 2 ] ⃗ w^{[1]},\vec{b^{[1]}},w^{[2]},\vec{b^{[2]}} w[1],b[1] ,w[2],b[2] 到 w [ 4 ] , b [ 4 ] ⃗ w^{[4]},\vec{b^{[4]}} w[4],b[4] 作为顶部的值，并固定它们然后使用随机梯度下降或Adam等算法仅更新 w [ 5 ] , b [ 5 ] ⃗ w^{[5]},\vec{b^{[5]}} w[5],b[5] 。
• 训练神经网络的所有参数，包括 w [ 1 ] , b [ 1 ] ⃗ , w [ 2 ] , b [ 2 ] ⃗ w^{[1]},\vec{b^{[1]}},w^{[2]},\vec{b^{[2]}} w[1],b[1] ,w[2],b[2] 一直到 w [ 5 ] , b [ 5 ] ⃗ w^{[5]},\vec{b^{[5]}} w[5],b[5] ，但前四层参数将使用我们在上面训练过的值。

如果我们有非常小的训练集，那么使用第一种选择会好一点，如果我们拥有一个稍微大一点的训练集，那么使用第二种选择会好一点。

这两个步骤首先在大型数据集上进行训练，然后在较小的数据集上进一步调整参数，这一步被称为监督预训练。

第二步称为微调，我们可以在其中获取已初始化或从监督预训练中获得的参数，然后进一步运行梯度下降以微调权重以适应您可能拥有的手写数字识别的特定应用。

迁移学习的一个好处是，也许我们不需要称为进行监督预训练的人。

17.4 机器学习项目完整周期

• 第一步：确定项目范围
• 第二步：收集数据
• 第三步：训练模型
• 第四部：部署项目

机器学习中，有一个不断发展的领域，叫做MLOPs（Machine Learning Operations）。主要工作为系统的构建、部署和维护机器学习系统的实践。做这些事情以确保我们的机器学习模型可靠、可扩展、具有良好的规律、受到监控。

17.5 倾斜数据集的误差指标

如果我们正在开发一个机器学习应用程序，其中正例与负例的比例非常倾斜，与50:50相差很远，那么通常错误指标（如精准度）效果会不好。

要解释清楚精确率和召回率，得先解释混淆矩阵，二分类问题的混淆矩阵由 4 个数构成。

假阴性（FN）： 算法预测为负例（N），实际上是正例（P）的个数，即算法预测错了（False）；

真阴性（TN）：算法预测为负例（N），实际上也是负例（N）的个数，即算法预测对了（True）；

假阳性（FP）：算法预测为正例（P），实际上是负例（N）的个数，即算法预测错了（False）；

真阳性（TP）：算法预测为正例（P），实际上也是正例（P）的个数，即算法预测对了（True）。

精确率：
p r e c i s i o n = T P T P + F P precision=\frac{TP}{TP+FP} precision=TP+FPTP

所以，精准率就是"预测为正例的那些数据里预测正确的数据个数"。

召回率：
r e c a l l = T P T P + F N recall = \frac{TP}{TP+FN} recall=TP+FNTP

所以，召回率就是"真实为正例的那些数据里预测正确的数据个数"。

精确率：针对预测数据来讲

召回率：针对真实数据来讲

17.6 精确率与召回率的权衡

对于预测患者是否患有某种病，高精度意味着如果患者被诊断患有这种罕见的疾病，那么该患者可能确实患有这种疾病，这是一个准确的判断。高召回率意味着如果有患者患有这种罕见疾病，算法可能会正确识别出他们确实患有这种疾病。

调和均值

精准率和召回率是此消彼长的，即精准率高了，召回率就下降，在一些场景下要兼顾精准率和召回率，就有 F1 score。

F1值是来综合评估精确率和召回率，当精确率和召回率都高时，F1也会高

F1的公式为：
2 F 1 = 1 P + 1 R \frac{2}{F_1}=\frac{1}{P}+\frac{1}{R} F12=P1+R1

有时候我们对精确率和召回率并不是一视同仁，我们用一个参数 β \beta β来度量两者之间的关系。
F β = ( 1 + β 2 ∗ P ∗ R ) β 2 ∗ P + R F_\beta=\frac{(1+\beta^2*P*R)}{\beta^2*P+R} Fβ=β2∗P+R(1+β2∗P∗R)

如果 β \beta β >1，召回率有更大的影响；

如果 β \beta β<1，精确率有更大的影响；

如果 β \beta β =1，精确率和召回率影响力相同，和 F 1 F_1 F1 形式一样；

灵敏度和特异度

灵敏度（真阳率，召回率），识别的正例占所有实际正例的比例

公式：
T P R = T P T P + F N TPR=\frac{TP}{TP+FN} TPR=TP+FNTP

特异度（假阳率），识别的假阳例占所有实际负例的比例

公式：
T P R = T P T P + F N TPR=\frac{TP}{TP+FN} TPR=TP+FNTP

---

18. 决策树

18.1 决策树模型简介

使用猫分类作为示例。假如我们正在经营一家猫收养中心，并给定了一些特征，我们想训练一个分类器来快速告诉这些动物是否为猫。

下面为10个训练示例。与这10个示例相关联，我们拥有关于动物的耳朵形状、面部形状、是否有胡须的特征，然后是我们想要预测这只动物是否为猫的真实标签。

这是一个二分类任务。目前每个特征都只有两个可能的值，后面会讨论两个以上可能值的问题以及连续值特征。

决策树是一种机器学习的方法。决策树的生成算法有ID3, C4.5和CART等。决策树是一种树形结构，其中每个内部节点表示一个属性上的判断，每个分支代表一个判断结果的输出，最后每个叶节点代表一种分类结果。

上图为刚刚看到的数据集上训练决策树学习算法后可能获得的模型的示例。这些椭圆和矩形都称为树中的一个节点。

该模型做出分类决策的方式是从树的最顶层节点开始，这称为树的根节点。

图中的所有椭圆节点都称为决策节点 。矩形称为叶子节点。

每个方框代表一个节点。每个非叶子节点有2个分支，一个是判定True，一个判定False。分别走两个不同的分支。叶子节点具有决策权。任何一个输入从root出发，总是会达到且唯一到达一个叶子节点。这就是决策树的工作原理。

18.2 决策树学习过程

下面让我们看一下构建决策树需要做的事情的全过程。

给定一个包含10个猫狗示例的训练集。

决策树学习的第一步是，我们必须决定在根节点使用什么特征，这是决策树最顶端的一个节点。

假设我们使用耳朵形状作为根节点使用的特征，我们会根据耳朵特征的值将它进行拆分。

第二步只是关注决策树的左侧部分（左侧分支），以决定将哪些节点放在那里。特别的是，我们接下来要继续使用什么特征进行拆分。假设我们在左侧分支继续使用面部形状进行拆分。

第三步，在右侧分支重复第二步的步骤。

这便是决策树的构建过程。

在构建的过程中，有几个关键的决定：

• 如何选择在每个节点上使用哪些特征进行拆分

  决策树将选择要拆分的特征以尝试最大化纯度。（纯度：想获得尽可能接近所有猫或所有狗的子集）

• 决定何时停止分裂

  • 当时一个节点100%是一个类别的时候停止分裂。

  • 或者我们可以决定在分裂时停止分裂，避免导致树超过最大深度。（最大深度是我们可以直接设定的一个参数）

    我们要限制决策树深度的一个原因是确保我们的树不会变得太大和笨重，其次，通过保持树小，它不太容易过度拟合。

  • 我们可以用来决定停止拆分的另一个标准可能是优先级分数的改进。

  • 如果一个节点的示例数量低于某个阀值，我们可以决定停止分裂。

18.3 纯度

熵，它是衡量一组数据不纯程度的指标。

给定一组这样的六个示例，我们有三只猫和三只狗，我们将定义 p 1 p_1 p1为猫的示例的分数。本例中的 p 1 p_1 p1等于 3 6 \frac{3}{6} 63。

我们将使用一个称为熵的函数来测量一组示例的不纯度，它看起来像这样。

该熵函数表示为 H ( p 1 ) H(p_1) H(p1)。其水平轴是 p 1 p_1 p1，即样本中猫的比例，垂直轴是熵的值。

定义 p 0 p_0 p0为不是猫的示例的分数。
p 0 = 1 − p 1 H ( p 1 ) = − p 1 l o g 2 ( p 1 ) − p 0 l o g 2 ( p 0 ) = − p 1 l o g 2 ( p 1 ) − ( 1 − p 1 ) l o g 2 ( 1 − p 1 ) p_0=1-p_1 \\ H(p_1)=-p_1log_2(p_1)-p_0log_2(p_0)=-p_1log_2{(p_1)}-(1-p_1)log_2(1-p_1) p0=1−p1H(p1)=−p1log2(p1)−p0log2(p0)=−p1log2(p1)−(1−p1)log2(1−p1)

18.4 选择拆分信息增益

在构建决策树时，我们决定在节点上拆分哪个特征的方式将基于哪种特征可以最大程度的减少熵或减少杂质，或最大化纯度。

在决策树的学习中，熵的减少称为信息增益。

计算信息增益，从而选择在决策树的每个节点上使用哪些特征进行拆分。

以让我们来决定在我们刚才构建的决策树的根节点使用什么特征来识别猫与非猫为例。

如上图，要对这些熵值进行比较，不如对他们进行加权平均进行比较。

我们选择拆分的方法是计算这三个数字并选择最小的一个。上面我们计算的0.28，0.03，0.12，这些被称为信息增益，它衡量的是由于分裂而导致的树中熵的减少。

事实证明，决定何时不再进一步分裂的停止标准之一是熵值的减少是否太小。

上面数据中，0.28最大，代表选择使用耳朵特征进行拆分时，熵值减少最大，所以在根节点上使用耳朵形状特征进行拆分。

计算信息增益的一般公式：

I n f o r m a t i n g a i n = H ( p 1 r o o t ) − ( w l e f t H ( p 1 l e f t ) + w r i g h t H ( p 1 r i g h t ) ) Informatin gain = H(p_1^{root})-(w^{left}H(p_1^{left})+w^{right}H(p_1^{right})) Informatingain=H(p1root)−(wleftH(p1left)+wrightH(p1right))

18.5 整合

下面是构建决策树的全过程。

• 从树的根节点处的多有训练示例开始，计算所有可能特征的信息增益，并选择要拆分的特征，从而提供最高的信息增益。
• 选择此特征后，我们将根据所选特征将数据集拆分称为两个子集，并创建树的左右分支，并将训练示例发送到左侧或右侧分支，具体取决于该特征的值。
• 然后将继续在树的左右分支上重复拆分过程。
• 停止条件是，当一个节点100%是单个类时，有的类的熵已经到达0，或者当进一步拆分节点将导致树超过我们设置的树的最大深度时，或者如果信息从额外的拆分小于阀值，或者节点中的示例数量低于阀值。

18.6 独热编码One-hot

无论我们是否拥有可以采用两个以上离散值的特征，我们将可以使用**独热编码（One-hot）**来解决此类特征。

one-hot 编码用于将离散的分类标签转换为二进制向量。

注意这里有两个关键词，第一个是离散的分类，第二个是二进制向量。

如果一个分类特征可以去K个可能的值，在我们的例子中k是三个，那么我们将通过创建k个只能取0或1的二进制特征来替换它。

使用独热编码对分类特征进行编码的想法也适用于训练神经网络。

18.7 连续有价值的特征

在前面所讲到的例子汁之上，增加一个特征，即动物的重量。

对于动物的体重特征，我们该如何进行拆分呢？

下图为根部的数据图。

分别取不同的阀值，计算信息增益，选择最大信息增益的所以对应的阀值。

18.8 回归树

在之前决策树只用于分类任务，下面将决策树运用于回归任务中。

下面例子中，使用我们之前描述的信息，使用动物猫和狗，将其耳朵形状、面部形状、胡须三个特征作为输入，来预测体重信息。

下面，我们已经为这个回归问题构建了一棵树，其根节点在耳朵形状上进行分裂，左右子树都在面部形状特征上进行分裂。

此时，如果有一个测试示例，这个测试示例具有特征尖耳朵即圆脸，那么这个动物的体重该如何预测呢？

决策树将根据此叶子节点中训练示例的平均体重进行预测，根据上图计算，则预测体重为8.35。

鉴于三个可能的特征要在根节点上进行拆分，我们该选择哪一个可以最好的预测动物的体重呢？

注意：此时不再根据信息增益进行选择！

在构建回归树时，我们不再是试图减少熵，而是尝试减少每个数据子集的值Y的体重方差。

方差计算公式：
S 2 = 1 n [ ( x 1 − x ) 2 + ( x 1 − x ) 2 + . . . + ( x n − x ) 2 ] x i   ( i = 1 , 2 , 3 , . . . ) ：各项值 x ：各项平均值 S^2=\frac{1}{n}[(x_1-x)^2+(x_1-x)^2+...+(x_n-x)^2] \ \ \ \ x_i\, (i=1,2,3,...)：各项值 \ \ \ \ x：各项平均值 S2=n1[(x1−x)2+(x1−x)2+...+(xn−x)2] xi(i=1,2,3,...)：各项值 x：各项平均值

我们拆分评估的方法是，我们将计算与之前相同的 w l e f t w_{left} wleft和 w r i g h t w_{right} wright，作为进入左右分支的示例的分数。然后计算拆分后的加权平均方差。

选择拆分的一个好方法是选择最低的加权平均方差值所对应的特征进行拆分。

就像分类问题一样，我们不只是测量平均加权熵，我们测量了熵的减少，这就是信息增益。对于回归树，我们也将类似的计算方差的减少。

我们将选择最大的加权平均方差减少所对应的特征进行拆分。

18.9 使用多个决策树

使用单个决策树的缺点之一是该决策树可能对数据中的微小变化高度敏感。

使决策树更健壮的一种解决方案是构建很多决策树，称为树集合。

如上图，更改根节点的数据集，我们左右子树中获得的数据子集会变得完全不同，从而构建出完全不同的子树。因此，只改变一个训练样本会导致在根部不同的分裂，从而产生完全不同的树，这使得该算法不那么健壮。

也就是说，如果我们不仅训练单个决策树，而是训练一大堆不同的决策树，我们会得到更准确的预测。使用多个决策树的目的就是让我们的算法更加健壮。

18.10 有放回抽样

为了构建树集成，我们需要一种称为替换采样的技术。

有放回抽样：

有放回抽样应用于构建树集成的方式如下：

我们讲构建多个随机训练集，这些训练集都与我们的原始训练集略有不同。特别的，我们将以10个猫和狗为例。我们把10个示例放入一个理论包中。我们将创建一个新的随机训练集，其中包含10个与原始数据集大小完全相同的示例。我们这样做的方式是我们正在接触并挑选一个随机样本。假设我们得到了这个训练示例，然后我们把它放回袋子里，然后再次随机挑选一个训练样本，然后重复上诉操作。

有放回抽样，让我们可以构建一个新的训练集，它与我们原来的训练集有点相似，但也有很大的不同。事实证明，这将是构建树集合的关键构建块。

18.11 随机森林

随机森林，它是一种强大的树样本算法，比使用单个决策树效果更好。

构建随机森林：

假如B为100，则我们构建了一个包含100棵不同树的集合，然后当我们尝试进行预测时，我们可以让这些树对正确的最终预测进行投票。

事实证明，将B设置的更大不会损害性能，但是超过某个点后，我们最终会得到收益递减的结果。

上诉这种树集成的特定实例创建有时也称为袋装决策树。

对这个算法进行修改，并将该算法从反向决策树更改为随机森林算法。通常这样做的方法是在每个音符上选择一个特征用于切割（如果最终特征可用）。

机器学习中有两种任务，回归和分类，而随机森林可以同时胜任这两种任务。其中分类任务是对离散值进行预测（比如将一景图像中的植被，建筑，水体等地物类型分类）；回归任务是对连续值进行预测（比如根据已有的数据预测明天的气温是多少度，预测明天某基金的价格）。

随机森林是属于集成学习，其核心思想就是集成多个弱分类器以达到三个臭皮匠赛过诸葛亮的效果。随机森林采用Bagging的思想，所谓的Bagging就是：

• 每次有放回地从训练集中取出 n 个训练样本，组成新的训练集；
• 利用新的训练集，训练得到M个子模型；
• 对于分类问题，采用投票的方法，得票最多子模型的分类类别为最终的类别；对于回归问题，采用简单的平均方法得到预测值。

下面开始构建决策树：

第一步：T中共有N个样本，有放回的随机选择N个样本。这选择好了的N个样本用来训练一个决策树，作为决策树根节点处的样本。

第二步：当每个样本有M个属性时，在决策树的每个节点需要分裂时，随机从这M个属性中选取出m个属性，满足条件m << M。然后从这m个属性中采用某种策略（比如说信息增益）来选择1个属性作为该节点的分裂属性。

第三步：决策树形成过程中每个节点都要按照步骤2来分裂，一直到不能够再分裂为止。注意整个决策树形成过程中没有进行剪枝。

第四步：按照步骤1~3建立大量的决策树，这样就构成了随机森林了。

18.12 XGBoost

目前，决策树集成或决策树最常用的方法或实现有一个名为XGBoost的算法。

1、XGboost的基本组成元素是：决策树；我们将这些决策树成为"弱学习器"，这些"弱学习器"共同组成了XGboost

2、组成XGBoost的决策树之间是有先后顺序的；后一棵决策树的生成会考虑前一棵决策树的预测结果，即将前一棵决策树的偏差考虑在内（在目标函数中有体现）

3、生成每棵决策树使用的数据集，是整个数据集。所以可以将每棵决策树的生成都看作是一个完整的决策树生成过程

一个新样本的预测：新样本依次进入XGBoost的每棵决策树。在第一棵决策树，有一个预测值；在第二棵决策树，有一个预测值，依次类推，直到进入完所有"弱学习器"（决策树）。最后，将"在每一颗决策树中的值"相加，即为最后预测结果。

XGboost还可以很好的选择默认的分裂标准和何时停止分裂的标准，并且内置了正则化以防止过度拟合。

18.13 何时使用决策树

决策树和树集成：

决策树和树集成通常适用于表格数据，也称为结构化数据。这意味着，如果我们的数据看起来像一个巨大的电子表格，那么决策树就值得考虑。

不建议在非结构化数据上使用决策树或树集成，如图像，音频等。

决策树和树集成的一大优势是它们的训练速度非常快。

小决策树可能是人类可解释的。

神经网络：

与决策树和树集成相比，它适用于所有类型的数据，包括结构化数据和非结构化数据，以及包含结构化数据和非机构化数据的混合数据。

但是不利的一面是，神经网络可能比决策树慢。

神经网络可以和迁移学习一起工作。

另外，如果我们正在构建一个由多个机器学习模型协同工作的系统，那么将多个神经网络串在一起并进行训练可能比多个决策树更容易。