R-深度学习入门指南-一-R 深度学习入门指南（一）一、深度学习简介随着硬件的进步和大数据的出现，更先进的计算方法变

R 深度学习入门指南（一）

原文：Introduction to Deep Learning Using R

协议：CC BY-NC-SA 4.0

一、深度学习简介

随着硬件的进步和大数据的出现，更先进的计算方法变得越来越受欢迎。消费者对更好产品的需求不断增加，企业寻求更有效地利用资源，这也是推动这一趋势的主要原因。为了应对这些市场力量，我们最近看到了对机器学习领域的新的广泛关注。在统计学、数学和计算机科学的交叉领域，机器学习是指创建和研究算法的科学，这些算法通过设计以迭代的方式改善自己的行为。最初，该领域致力于开发人工智能，但由于当时存在的理论和技术的限制，将这些算法集中在特定任务上变得更符合逻辑。现有的大多数机器学习算法都专注于函数优化，产生的解决方案并不总是解释数据中的潜在趋势，也没有提供人工智能试图接近的推理能力。因此，使用机器学习算法经常成为一个重复的试错过程，其中跨问题的算法选择会产生不同的性能结果。这在某些情况下没问题，但是在语言建模和计算机视觉的情况下，这就成问题了。

为了应对机器学习的一些缺点，以及我们今天可支配的理论和技术能力的重大进步，深度学习已经出现，并正在迅速扩展为最令人兴奋的科学领域之一。它正被用于自动驾驶汽车、社交媒体平台上的图像识别以及从一种语言到另一种语言的文本翻译等技术。深度学习是机器学习的子领域，致力于构建算法，解释和学习传统机器学习算法通常无法实现的高层次和低层次的数据抽象。深度学习中的模型通常受到许多知识来源的启发，如博弈论和神经科学，许多模型通常模仿人类神经系统的基本结构。随着该领域的发展，许多研究人员设想了一个世界，在这个世界中，软件不像今天经常需要的那样被硬编码，从而允许更健壮、更通用的解决问题的解决方案。

虽然它最初是在类似于机器学习的空间中开始的，其中主要关注的是对不同复杂程度的约束满足，但深度学习现在已经发展到包含更广泛的算法定义，这些算法能够理解对应于不同复杂层次的数据的多级表示。换句话说，算法不仅具有预测和分类能力，而且能够学习不同程度的复杂性。这方面的一个例子是在图像识别中发现的，在图像识别中，神经网络建立在识别睫毛、脸、人等等的基础上。这其中的力量是显而易见的:我们可以达到创建智能软件所需的复杂程度。我们目前在自动更正等功能中看到这一点，该功能针对每个人的词汇，对观察到的语音模式的建议更正进行建模。

深度学习模型的结构通常是这样的，它们具有处理数据的非线性单元或神经元的层，并且这些模型中的多个层处理数据的不同抽象级别。图 1-1 显示了神经网络层的可视化。

图 1-1。

Deep neural network

深度神经网络的区别在于具有许多隐藏层，这些隐藏层被称为“隐藏的”，因为除了知道它们是前一层的输出之外，我们不一定看到这些神经元的输入和输出是什么。层的增加，以及这些层的神经元内部的功能，是将一个单独的架构与另一个架构区分开来，并建立给定模型的不同用例的原因。

更具体地说，这些模型的较低层解释“如何”，而较高层的神经网络处理“为什么”。这些层中使用的函数取决于用例，但通常可由用户定制，这使得它们比通常用于分类和回归的一般机器学习模型更加健壮。深度学习模型的基本假设是，被解释的数据是由分层组织的不同因素的相互作用产生的。因此，拥有多个层允许模型处理数据，以便从简单的方面到更大的结构建立理解。这些模型的目标是在没有许多机器学习算法需要的相同程度的显式指令的情况下执行任务。关于如何使用这些模型，一个主要的好处是当应用于无监督学习问题时，或者在执行实验之前我们不知道响应变量 y 应该给定一组解释变量 x 的问题时，它们表现出的前景。一个例子是图像识别，特别是在模型已经根据给定的数据集训练之后。假设我们在测试阶段输入一张狗的图片，这意味着我们没有告诉模型这张图片是什么。神经网络将首先识别鼻子之前的睫毛，然后识别狗的头部形状，等等，直到它将图像分类为狗的图像。

深度学习模型

既然我们已经建立了深度学习的简要概述，那么讨论一下你在本书中将会学到什么，以及描述我们将在这里讨论的模型将会很有用。

本文假设你对数学和统计学有一定的了解。尽管如此，我们将简要回顾理解线性代数、优化和机器学习所需的所有概念，以便我们将形成掌握深度学习所需的坚实知识基础。虽然它确实有助于准确理解所有这些技术信息，但那些对更高级的数学感到不舒服的人不必担心。如果需要的话，这份正文以这样的方式被写，给读者进一步研究它所必需的所有背景信息。然而，本文的主要目标是向读者展示如何应用机器学习和深度学习模型，而不是对所有讨论的理论概念进行冗长的学术论述。

在我们充分回顾了所有必要的数学和机器学习概念之后，我们将进一步详细讨论机器学习模型。本节描述并举例说明深度学习模型。

单层感知器模型(SLP)

单层感知器(SLP)模型是最简单的神经网络形式，也是深度学习中开发的更高级模型的基础。通常，我们在分类问题中使用 SLP，在分类问题中，我们需要基于输入给出数据观察标签(二元或多项式)。输入图层中的值在乘以权重并在累积和中添加偏差后，直接发送到输出图层。然后，这个累积和被放入一个激活函数中，这个函数就是定义输出的函数。当该输出高于或低于用户确定的阈值时，确定最终输出。研究人员麦卡洛克-皮茨神经元在 20 世纪 40 年代描述了一个类似的模型(见图 1-2 )。

图 1-2。

Single layer perceptron network

多层感知器模型(MLP)

与 SLP 非常相似，多层感知器(MLP)模型具有多个层，这些层以这样一种方式相互连接，从而形成一个前馈神经网络。一层中的每个神经元都与另一层的神经元有直接连接。该模型和单层感知器模型的关键区别因素之一是反向传播算法，这是训练神经网络的一种常用方法。反向传播将从输出层计算的误差传递到输入层，这样我们可以看到每一层对误差的影响，并相应地改变网络。这里，我们使用梯度下降算法来确定每次迭代时权重应该改变的程度。梯度下降(Gradient descent)是另一种流行的机器学习/优化算法，它只是一个函数的导数，这样我们就可以找到一个指向最大动量方向的标量值(一个以大小为唯一属性的数字)。通过减去梯度，我们会得到一个比当前更优的解，直到达到全局最优(见图 1-3 )。

图 1-3。

MultiLayer perceptron network

卷积神经网络

卷积神经网络(CNN)是最常用于图像处理和计算机视觉的模型。它们被设计成模仿动物视觉皮层的结构。具体来说，CNN 具有三维排列的神经元:宽度、高度和深度。给定层中的神经元仅连接到前一层的一小部分区域。CNN 模型最常用于图像处理和计算机视觉(见图 1-4 )。

图 1-4。

Convolutional neural network

循环神经网络

循环神经网络(RNNs)是人工神经网络(ann)的模型，其中单元之间的连接形成有向循环。具体来说，有向循环是一个序列，其中沿着顶点和边的行走完全由所使用的边集决定，因此具有某种特定顺序的外观。rnn 通常专门用于语音和手写识别(参见图 1-5 )。

图 1-5。

Recurrent neural network

受限玻尔兹曼机

受限玻尔兹曼机是一种具有独特架构的二进制马尔可夫模型，使得存在多层隐藏随机变量和对称耦合的随机二进制单元的网络。DBMs 由一组可见单元和一系列隐藏单元层组成。然而，同一层的单元之间没有连接。DMBs 可以在对象或语音识别等任务中学习复杂和抽象的内部表征(见图 1-6 )。

图 1-6。

Restricted Boltzmann machine

深度信念网络

深度信任网络类似于 RBM，除了每个子网的隐藏层实际上是下一个子网的可见层。dbn 是广义的生成图形模型，由多层潜在变量组成，各层之间有联系，但各层单元之间没有联系(见图 1-7 )。

图 1-7。

Deep belief networks

讨论的其他主题

在涵盖了所有关于模型的信息之后，我们将转向理解数据科学的实践。为了有助于这项工作，本节涵盖了其他感兴趣的主题。

试验设计

这篇文章的重点最终是让读者对深度学习模型有一个理论上的理解，这样他们就能舒服地应用它们。因此，重要的是讨论实验设计的特征，以帮助读者理解构建其研究的适当方法，从而得出可操作的见解，而不是浪费时间和/或精力。在很大程度上，鉴于深度学习经常遇到的问题，除了定义最佳实践之外，我还将借鉴 Fisher 的原则。

特征选择

作为实验设计的一部分，但最终完全是研究的一个子课题，我将介绍变量选择的概念和数据科学家处理高维数据集经常使用的多种方法。具体来说，我将深入谈论主成分分析以及遗传算法。所有讨论的算法都可以在开源包的 R 统计语言中找到。对于那些想进一步研究这个领域的人，我会参考与这个主题相关的论文。从深度学习的角度来看，我们将深入讨论每个模型如何通过层架构的设计来执行其自己的特定特征选择方法，以及解决该领域的最新发现。

应用机器学习和深度学习

对于文本的最后一部分，我将带领读者使用 R 语言的包来进行机器学习和深度学习模型，以解决专业和学术设置中常见的问题。希望从这些例子中，读者将被激励在他们的专业和/或学术追求中应用机器学习和深度学习。所有例子、实验和研究的代码都使用 R 编程语言，并将通过 GitHub 提供给所有读者(更多信息请参见附录)。讨论的主题包括使用深度学习模型的回归、分类和图像识别。

深度学习的历史

现在，我们已经涵盖了文本的大致轮廓，除了读者在此期间预计要学习的内容，我们将看到该领域如何发展到这一阶段，并了解它今天寻求的方向。虽然深度学习是一个相对较新的领域，但它有着丰富而充满活力的历史，充满了今天仍在进行的发现。至于这个领域最清晰的起源在哪里，讨论把我们带到了 20 世纪 60 年代。

第一个经常与深度学习模型相关联的工作学习算法是由 Ivakhenenko 和帕拉开发的。1965 年，他们在一篇名为“数据处理小组方法(GMDH)训练的网络”的论文中发表了他们的发现。这些是第一批前馈多层感知器类型的深度学习系统。前馈网络描述了单元之间的连接不形成循环的模型，就像在循环神经网络中一样。该模型以多项式激活函数为特征，并且通过回归分析对层进行增量增长和训练。它们随后在单独的验证集的帮助下被修剪，其中正则化被用来剔除多余的单元。

20 世纪 80 年代，福岛国浩推出了新克隆体。它是一种多层人工神经网络，主要用于手写字符识别和需要模式识别的类似任务。它的模式识别能力给了卷积神经网络灵感。不管怎样，新认知神经的灵感来自神经生理学家 Hubel 和 Wiesel 提出的一个模型。也是在这十年间，Yann LeCun 等人将反向传播算法应用于深度神经网络。这样做的最初目的是让美国电话电报公司识别邮件上手写的邮政编码。这项技术的优势是显著的，尤其是在互联网及其商业化于 20 世纪 90 年代末和 21 世纪初出现之前。

在 20 世纪 90 年代，深度学习领域见证了循环神经网络的发展，该网络需要在 RNN 中及时展开超过 1000 层，并且发现可以使用所谓的唤醒-睡眠算法来训练包含六个完全连接的层和数百个隐藏单元的网络。启发式算法，或我们应用于另一个单个或一组算法的算法，唤醒-睡眠算法是一种无监督的方法，它允许算法以输出最佳密度估计值的方式调整参数。“唤醒”阶段描述了神经元从输入到输出的放电过程。来自输入和输出的连接被修改，以增加它们在当前层之下的层中复制正确活动的可能性。“睡眠”阶段与觉醒阶段相反，因此神经元被连接激活，同时识别被修改。

正如该领域在 2000 年代初和 2010 年代取得的进展一样，当前向前发展的时期被描述为深度学习的分水岭时刻。现在，我们看到了深度学习在众多行业和领域的应用，以及用于这些模型的硬件的非常投入的改进。在未来，预计深度学习所涵盖的进步将有助于让技术在人类今天经常做的事情和传统机器学习算法表现不佳的情况下做出行动。虽然肯定还有进步，但许多公司和大学为加速进步所做的投资是显而易见的，并对世界产生了重大影响。

摘要

对于读者来说，重要的是最终要理解，无论我们在这里描述的任何模型是多么复杂，无论它可能提供多么有趣和强大的用途，在使用这些模型的领域中，没有什么可以替代足够的领域知识。对于高级和初级从业者来说，很容易陷入这样的陷阱:完全相信深度学习模型的输出，而不认真评估它们使用的环境。虽然看起来不言自明，但强调仔细检查结果的重要性是很重要的，更重要的是，在错误风险最有限的情况下做出可操作的推断。我希望给读者留下深刻印象的不仅仅是他们可以在哪里应用这些模型的知识，还有当今存在的技术和研究的合理限制。

这在机器学习和深度学习中尤其重要，因为尽管这些模型中的许多都很强大，并且能够达到手工几乎不可能达到的适当解决方案，但我们还没有确定为什么总是如此。例如，我们知道反向传播算法是如何工作的，但我们看不到它是如何工作的，我们也不知道到底发生了什么才能得出这样的结论。这种情况产生的主要问题是，当一个流程中断时，我们不一定总是知道为什么会中断。尽管已经创建了尝试和跟踪神经元及其激活顺序的方法，但神经网络的决策过程并不总是一致的，尤其是在不同的问题上。我希望读者在前进时记住这一点，并在必要时适当地评估这一点。

二、数学回顾

在讨论机器学习之前，有必要简要概述一下统计学。广义而言，统计是对定量数据的分析和收集，最终目标是对这些数据进行可操作的洞察。也就是说，虽然机器学习和统计学不是同一个领域，但它们密切相关。本章简要概述了与本书后面的讨论相关的术语。

统计概念

如果不先讨论概率的概念，任何关于统计学或机器学习的讨论都是不合适的。

可能性

概率是对事件发生的可能性的度量。虽然许多机器学习模型倾向于确定性的(基于算法规则)而不是概率性的，但是概率的概念除了在更复杂的深度学习架构(如循环神经网络和卷积神经网络)中引用之外，还特别在诸如期望最大化算法的算法中引用。数学上，这个算法定义如下:

$Probability\ of\ Event\ A = \frac{number\ of\ times\ event\ A\ occurs}{all\ possible\ event s}$

这种计算概率的方法代表了频率主义者对概率的观点，在这种观点中，概率基本上是由下面的公式推导出来的。然而，另一个概率学派，贝叶斯，采取了不同的方法。贝叶斯概率理论是基于概率是有条件的假设。换句话说，事件发生的可能性受到当前存在的条件或之前发生的事件的影响。我们在下面的等式中定义条件概率。假设事件 B 已经发生，事件 A 的概率等于:

$P\left( A\Big| B\right)=\frac{P\left( A{\displaystyle \cap } B\right)}{P(B)},$

$Provided\ P(B) > 0\.$

在这个等式中，我们将 $P\left( A\Big| B\right)$ 读作“给定 B 的概率”， $P\left( A{\displaystyle \cap } B\right)$ 读作“A 和 B 的概率。”

也就是说，计算概率并不像看起来那么简单，因为必须经常评估依赖性和独立性。举个简单的例子，假设我们正在评估两个事件 A 和 B 的概率，我们还假设事件 B 发生的概率依赖于 A 的发生。因此，如果 A 不发生，B 发生的概率为 0。数学上，我们将两个事件 A 和 B 的依赖性与独立性定义如下:

$P\left( A\Big| B\right) = P(A)$

$P\left( B\Big| A\right)= P(B)$

$P\left( A{\displaystyle \cap } B\right) = P(A) P(B)$

在图 2-1 中，我们可以把事件 A 和 B 想象成两个集合，A 和 B 的并集是两个圆的交点:

图 2-1。

Representation of two events (A,B)

如果这个等式在给定的环境中不成立，事件 A 和事件 B 被称为是相关的。

And vs. Or

通常，当谈到概率时，例如，当评估两个事件 A 和 B 时，通常在“A 和 B 的概率”或“A 或 B 的概率”的上下文中讨论概率。直观地说，我们将这些概率定义为两个不同的事件，因此它们的数学推导是不同的。简单地说，或表示事件概率的相加，而和意味着事件概率的相乘。以下是所需的方程式:

和(概率的乘法定律)是两个事件 A 和 B 相交的概率:

$P\left( A{\displaystyle \cap } B\right) = P(A) P\left( B\Big| A\right)$

$= P(B) P\left( A\Big| B\right)$

如果事件是独立的，那么

$P\left( A{\displaystyle \cap } B\right)= P(A) P(B)$

或者(p 可加性法则)是两个事件 A 和 B 并的概率:

$P\left( A{\displaystyle \cup } B\right) = P(A) + P(B)- P\left( A{\displaystyle \cap } B\right)$

符号 $P\left( A{\displaystyle \cup } B\right)$ 的意思是“A 或 b 的概率”

图 2-2 说明了这一点。

图 2-2。

Representation of events A,B and set S

A 和 B 的概率仅仅是它们各自球面上不相交的部分，而 A 或 B 的概率是这两个部分加上交点的和。我们将 S 定义为我们在给定问题中考虑的所有集合加上这些集合之外的空间的总和。因此，S 的概率总是 1。

话虽如此，A 和 B 之外的空间代表了这些事件的反面。例如，假设 A 和 B 分别代表母亲下午 5 点回家和父亲下午 5 点回家的概率。空白代表他们俩都不会在下午 5 点回家的概率

贝叶斯定理

如上所述，贝叶斯统计在机器学习和深度学习领域不断获得赞赏。尽管这些技术通常需要大量的硬编码，但它们的强大之处在于相对简单的理论基础，同时功能强大，适用于各种环境。贝叶斯定理建立在条件概率的概念上，是一个事件 A 的概率与其他类似事件的概率相关的概念:

$P\left({B}_j\Big| A\right)=\frac{P\left( A\Big|{B}_j\right) P\left({B}_j\right)}{\varSigma_i^k P\left( A\Big|{B}_i\right) P\left({B}_i\right)}$

在后面的章节中提到，贝叶斯分类器是建立在这个公式以及期望最大化算法的基础上的。

随机变量

通常，当分析事件的概率时，我们在一组随机变量内进行。我们将随机变量定义为一个量，其值取决于一组可能的随机事件，每个事件都有相关的概率。它的值在被绘制之前是已知的，但是它也可以被定义为从概率空间映射的函数。通常，我们通过一种叫做随机抽样的方法来抽取这些随机变量。从总体中随机抽样，当每个观察值都以这样的方式被选择，即它和总体中的其他观察值一样有可能被选择时，就说是随机的。

广义地说，读者可能会遇到两种类型的随机变量:离散随机变量和连续随机变量。前者指的是只能取有限个不同值的变量，而后者指的是有无限个可能变量的变量。一个例子是车库里的汽车数量与股票价格百分比变化的理论变化。当分析这些随机变量时，我们通常依赖于读者可能会经常看到的各种统计数据。但是这些统计数据通常直接用于算法中，或者在各个步骤中，或者在评估给定的机器学习或深度学习模型的过程中。

例如，算术平均值直接用于 K-means 聚类等算法，同时也是均方差等模型评估统计的理论基础(本章后面会提到)。直观地说，我们将算术平均值定义为一组离散数字的集中趋势，具体来说，就是这些值的总和除以这些值的个数。数学上，这个等式由下面给出:

$\overline{x}=\frac{1}{N}{\displaystyle \sum_{i=1}^N}{x}_i$

广义地说，算术平均值代表随机变量中一组值的最可能值。然而，这不是我们可以用来理解随机变量的唯一一种均值。几何平均值也是一种描述数字序列集中趋势的统计量，但它是通过使用值的乘积而不是总和来获得的。这通常在比较一个序列中的不同项目时使用，尤其是当它们分别具有多个属性时。几何平均值的方程式如下:

${\left({\displaystyle \prod_{i=1}^n}{x}_i\right)}^{\frac{1}{n}}=\kern0.5em {\left({x}_1*\ {x}_2* \dots *\ {x}_n\right)}^{\frac{1}{n}}$

对于那些经常使用时间序列的领域来说，几何平均对于获取特定时间间隔(小时、月、年等)内的变化度量是有用的。也就是说，随机变量的集中趋势并不是描述数据的唯一有用的统计数据。通常，我们希望分析数据围绕最可能值的分散程度。从逻辑上讲，这将我们引向方差和标准差的讨论。这两种统计数据高度相关，但它们有一些关键的区别:方差是标准差的平方值，在各个领域中，标准差通常比方差更有参考价值。在处理后一个区别时，这是因为方差很难直观地描述，而且方差的单位是模糊的。标准偏差以被分析的随机变量为单位，易于可视化。

例如，当评估给定机器学习算法的效率时，我们可以从几个时期得出均方误差。收集这些变量的样本统计数据可能会有所帮助，这样我们就可以了解这些统计数据的离差。数学上，我们将方差和标准差定义如下

变化

${\sigma}²=\frac{\varSigma {\left( X - \mu \right)}²}{N}$

$V a r(X) = E\left[\right( X- E{\left(\left[ X\right]\right)}²\Big]$

$= E\Big[{X}²-2 X E\left[ X\right]+{\left( E\left[ X\right]\right)}²$

$= E\left[{X}²\right] - 2 E\left[ X\right]\kern0.5em E\left[ X\right]+{\left( E\left[ X\right]\right)}²$

$= E\left[{X}²\right]-2 E\left[ X\right] E\left[ X\right]+{\left( E\left[ X\right]\right)}²$

标准偏差

$\sigma =\sqrt{\left(\frac{{\displaystyle {\sum}_i^n}{\left({x}_i-\overline{x}\right)}²}{n-1}\right)}$

此外，协方差可用于测量一个特征的变化对另一个特征的影响程度。数学上，我们定义协方差如下:

$c o v\left( X, Y\right)=\frac{1}{n}{\displaystyle \sum_{i=1}^n}\left({x}_i-\overline{x}\right)\Big({y}_i-\overline{y\Big)}$

尽管深度学习在建模具有非线性相关性的变量之间的关系方面取得了重大进展，但一些用于更简单任务的估计器需要这一点作为初步假设。例如，线性回归要求这是一个假设，尽管许多机器学习算法可以对复杂数据进行建模，但有些算法比其他算法更擅长。因此，建议在选择估计量特征之前，使用这些先验统计量检查它们之间的关系。因此，这就引出了对相关系数的讨论，相关系数用来衡量变量之间线性相关的程度。数学上，我们这样定义:

$correlation=\rho =\frac{1}{n}{\displaystyle \sum_{i=1}^n}\frac{\left({x}_i-\overline{x}\right)\left({y}_i-\overline{y\Big)}\right)}{\sqrt{{\left({x}_i-\overline{x}\right)}²{\left({y}_i-\overline{y\Big)}\right)}²}}$

相关系数的值可以低至–1，高至 1，下限代表相反的相关性，上限代表完全的相关性。从统计学上讲，相关系数为 0 表示完全没有相关性。在评估机器学习模型时，特别是那些执行回归的模型，我们通常会参考决定系数(R 平方)和均方误差(MSE)。我们认为 R 平方是模型的估计回归线与数据分布拟合程度的度量。因此，我们可以说，这个统计量最广为人知的是给定模型的适合度。MSE 测量从模型预测到观察数据的偏差的平方误差的平均值。我们将两者分别定义如下:

决定系数(R 的平方)

${R}²=1-{\displaystyle \sum_i^n}\frac{{\left({\widehat{y}}_i- y\right)}²}{{\left({\widehat{y}}_i-\overline{y}\right)}²}$

均方误差

$M S E=\frac{1}{n}{\displaystyle \sum_{i=1}^n}{\left({y}_i-\overline{y}\right)}²$

关于这些值应该是什么，我将在本文后面详细讨论。简而言之，我们通常寻求比其他估计量具有更高的 R 平方值和更低的 MSE 值的模型。

线性代数

线性代数的概念在机器学习、数据科学和计算机科学中被大量使用。虽然这不是一个详尽的综述，但所有读者至少应该熟悉以下概念。

标量和向量

标量是只有一个属性的值:量值。标量的集合，称为向量，可以有大小和方向。如果在一个给定的向量中有一个以上的标量，我们称之为向量空间的元素。向量空间的区别在于，它是标量序列，可以相加和相乘，并且可以对其执行其他数值运算。向量被定义为 n 个数字的列向量。当我们提到向量的索引时，我们将 I 描述为索引值。比如我们有一个向量 x，那么 x ₁ 指的是向量 x 中的第一个值，直观的说，把向量想象成一个类似于文件柜内文件的物体。这个向量中的值是单张纸，向量本身是保存所有这些值的文件夹。

向量是本文中讨论的许多概念的主要构件之一(见图 2-3 )。例如，在深度学习模型(如 Doc2Vec 和 Word2Vec)中，我们通常将单词和文本文档表示为向量。这种表示允许我们将大量数据压缩成一种易于输入神经网络进行计算的格式。从这种大规模降维中，我们可以确定一个文档与另一个文档的相似度或相异度，或者我们可以获得比简单贝叶斯推理更好的同义词理解。对于已经是数字的数据，向量提供了一种简单的方法来“存储”这些数据，并将其输入到用于相同目的的算法中。向量(和矩阵)的属性，特别是关于数学运算的属性，允许对大量数据进行相对快速的计算，也提供了对数据集中的每个单独值进行手动运算的计算优势。

图 2-3。

Representation of a vector

向量的性质

向量维数通常由ℝ ⁿ 或ℝ ^m 表示，其中 n 和 m 是给定向量中值的数量。例如， $x\in {\mathrm{\mathbb{R}}}⁵$ 表示具有实分量的 5 个向量的集合。虽然我到目前为止只讨论了一个列向量，但是我们也可以有一个行向量。也可以执行将列向量转换为行向量的转换，称为转置。转置是矩阵/向量 X 的变换，使得 X 的行被写成 X ^T 的列，X 的列被写成 X ^T 的行。

添加

让我们定义两个向量 $d={\left[{d}_1,\ {d}_2, \dots,\ {d}_n\right]}^T$ 和 $e={\left[{e}_1,{e}_2,\dots,\ {e}_n\right]}^T$ 其中

${d}_n={e}_n,\ f o r\ i=1,\ 2, \dots,\ n$

因此，矢量之和如下:

$d+ e={\left[\left({d}_1+{e}_1\right),\ \left({e}_2+{d}_2\right), \dots,\ \left({d}_n+{e}_n\right)\right]}^T$

减法

假设前一个例子中的假设没有改变，向量 d 和 e 之间的差异如下:

$d- e={\left[\left({d}_1 - {e}_1\right),\ \left({e}_2 - {d}_2\right), \dots,\ \left({d}_n - {e}_n\right)\right]}^T$

逐元素乘法

假设前一个例子中的假设没有改变，向量 d 和 e 的乘积如下:

$d* e={\left[\left({d}_1*{e}_1\right),\ \left({e}_2*{d}_2\right), \dots,\ \left({d}_n*{e}_n\right)\right]}^T$

公理

设 A、b 和 x 是集合 A 中的一组向量，e 和 d 是 b 中的标量。如果某物是向量空间，则下列公理必须成立:

关联属性

关联属性是指给定表达式中括号的重新排列不会改变最终值:

$x+\left( a+ b\right)=\left( x+ a\right) + b$

交换性质

交换性是指改变给定表达式中操作数的顺序不会改变最终值:

a + b= b+ a

加法的单位元

$a + 0= a,\ f o r\ a ll\ a\in A$

哪里 $0\in A$ 。在这种情况下，0 是零向量，或零向量。

加法的逆元素

在这种情况下，对于每个 a := A，存在一个元素–A:= A，我们将其标记为 a:

$a+\left(- a\right) = 0$

的加法逆

标量乘法的单位元

(1) a= a

标量乘法关于向量加法的分配性

$e\left( a+ b\right) = e a+ e b$

标量乘法关于场加法的分配性

$\left( a+ b\right) d= ad+ b d$

子空间

向量空间的子空间是满足向量空间要求的非空子集，特别是线性组合留在子空间中。这个子集在加法和标量乘法下是“封闭的”。最值得注意的是，零向量将属于每个子空间。例如，由支持向量回归产生的超平面之间的空间就是子空间的一个例子，支持向量回归是一种机器学习算法，我将在后面介绍。在这个子空间中是响应变量的可接受值。

矩阵

矩阵是我们数学复习中线性代数的另一个基本概念。简单地说，矩阵是以行和列排列的数字、符号或表达式的矩形阵列。矩阵有多种用途，但特别是经常用于存储数字数据。例如，当使用卷积神经网络执行图像识别时，我们将照片中的像素表示为三维矩阵中的数字，该矩阵表示由彩色照片组成的红色、绿色和蓝色照片的矩阵。通常，我们将一个单独的像素取为 256 个单独的值，通过这种数学解释，一种难以理解的数据表示成为可能。关于向量和标量，矩阵包含每个单独值的标量，由行和列向量组成。当我们索引一个给定的矩阵 A 时，我们将使用符号 A _ij 。我们也称之为 $A={a}_{ij,\kern0.5em }\ A\in {\mathrm{\mathbb{R}}}^{m\ x\ n}$ 。

矩阵属性

根据矩阵是向量的组合的定义，矩阵本身具有许多与向量相同的基本性质。但是，有一些重要的关键差异，特别是关于矩阵乘法。例如，矩阵乘法是理解普通最小二乘回归如何工作的关键特征，也是从根本上理解为什么我们在执行线性回归时会对使用梯度下降感兴趣。也就是说，矩阵的性质将在本节的其余部分讨论。

添加

假设 A 和 B 都是 m×n 维矩阵:

$A+ B=\left({A}_{ij}+{B}_{ij}\right),\ f o r\ i=1,2,\dots,\ n$

纯量乘法

让我们假设 A 和 B 都是 m×n 维矩阵

$AB=\left({A}_{ij}*{B}_{ij}\right),\ f o r\ i=1,2,\dots,\ n$

调换

${A}_{ij}^T={A}_{ji}$

矩阵的类型

矩阵有多种形式，通常用它们呈现的形状来表示。虽然矩阵可以有多个维度，但有许多维度通常会被引用。其中最简单的是方阵，它的区别在于它有相等数量的行和列:

$\mathbf{A} = \left[\begin{array}{ccc}\hfill {a}_{1,1\ }\hfill & \hfill {a}_{1,2}\kern0.5em {a}_{1,3}\cdots \hfill & \hfill {a}_{1, n}\hfill \\ {}\hfill \vdots \hfill & \hfill \ddots \hfill & \hfill \vdots \hfill \\ {}\hfill {a}_{n,1}\hfill & \hfill {a}_{n,2}{a}_{n,3} \cdot s \hfill & \hfill {a}_{n, n}\hfill \end{array}\right]$

一般来说，读者不太可能碰到正方形矩阵，但是矩阵性质的含义使得讨论它是必要的。也就是说，这使我们讨论不同类型的矩阵，如对角矩阵和单位矩阵。对角矩阵是这样一种矩阵，其中不沿着矩阵的主对角线(从左上角到右下角)的所有条目都是零，由下面给出:

$A=\kern0.75em \begin{array}{ccc}\hfill 5\hfill & \hfill 0\hfill & \hfill 0\hfill \\ {}\hfill 0\hfill & \hfill 4\hfill & \hfill 0\hfill \\ {}\hfill 0\hfill & \hfill 0\hfill & \hfill 3\hfill \end{array}$

类似于对角矩阵，单位矩阵也具有沿着除矩阵对角线之外的所有条目的值的零。然而，这里的关键区别在于对角矩阵中的所有元素都是 1。这个矩阵由下图给出:

${I}_n=\kern1.25em \begin{array}{ccc}\hfill 1\hfill & \hfill 0\hfill & \hfill 0\hfill \\ {}\hfill 0\hfill & \hfill 1\hfill & \hfill 0\hfill \\ {}\hfill 0\hfill & \hfill 0\hfill & \hfill 1\hfill \end{array}$

另一个你可能看不到，但从理论角度来看很重要的矩阵是对称矩阵，它的转置等于非变换矩阵。我将在本章中描述转置，但它可以简单地理解为将行转换成列，反之亦然。

我将定义的矩阵的最终类型，特别是牛顿法(第三章描述的一种优化方法)中提到的，是正定和半正定矩阵。如果所有元素都大于零，则称对称矩阵为正定矩阵。但是如果所有的值都是非负的，这个矩阵叫做正半定。尽管在下一章中会有更详细的描述，但这对于理解一个问题是否有全局最优解(以及牛顿法是否可以用来寻找这个全局最优解)是很重要的。

矩阵乘法

与向量不同，矩阵乘法包含独特的规则，这将有助于计划应用这些知识的读者，尤其是那些使用编程语言的读者。例如，假设我们有两个矩阵，A 和 B，我们想把它们相乘。这些矩阵只有在 A 中的列数与 b 中的行数相同的条件下才能相乘。我们称这个矩阵乘积为矩阵 A 和 b 的点积。下面几节讨论矩阵乘法及其乘积的例子。

纯量乘法

假设我们有一个矩阵 A，我们想用它乘以标量值σ。该操作的结果如下图所示:

$\sigma A=\sigma \left[\begin{array}{ccc}\hfill {A}_{1,1}\hfill & \hfill {A}_{1,2\ }\kern0.5em \cdots \hfill & \hfill {A}_{1, m}\hfill \\ {}\hfill \vdots \hfill & \hfill \ddots \hfill & \hfill \vdots \hfill \\ {}\hfill {A}_{n,1}\hfill & \hfill {A}_{n,2}\kern0.75em \cdots \hfill & \hfill {A}_{n, m}\hfill \end{array}\right]=\left[\begin{array}{ccc}\hfill \sigma {A}_{1,1}\hfill & \hfill \sigma {A}_{1,2}\kern0.75em \cdots \hfill & \hfill \sigma {A}_{1, m}\hfill \\ {}\hfill \vdots \hfill & \hfill \ddots \hfill & \hfill \vdots \hfill \\ {}\hfill \sigma {A}_{n,1}\hfill & \hfill \sigma {A}_{n,2}\kern0.75em \cdots \hfill & \hfill \sigma {A}_{n, m}\hfill \end{array}\right]$

矩阵中的每个值乘以随后产生的新矩阵中的标量。具体来说，我们可以看到这种关系显示在以下与本征分解相关的方程中。

矩阵乘矩阵乘法

矩阵乘法用于几种回归方法，特别是 OLS、岭回归和 LASSO。这是一种高效而简单的方式来表示独立数据集上的数学运算。在下面的例子中，设 D 是一个 n×m 矩阵，E 是一个 m×p 矩阵，这样当我们将它们相乘时，我们得到如下:

$D = \left[\begin{array}{ccc}\hfill {D}_{1,1}\hfill & \hfill {D}_{1,2\ }\kern0.5em \cdots \hfill & \hfill {D}_{1, m}\hfill \\ {}\hfill \vdots \hfill & \hfill \ddots \hfill & \hfill \vdots \hfill \\ {}\hfill {D}_{n,1}\hfill & \hfill {D}_{n,2}\kern0.75em \cdots \hfill & \hfill {D}_{n, m}\hfill \end{array}\right],\ E = \left[\begin{array}{ccc}\hfill {E}_{1,1}\hfill & \hfill {E}_{1,2\ }\kern0.5em \cdots \hfill & \hfill {E}_{1, p}\hfill \\ {}\hfill \vdots \hfill & \hfill \ddots \hfill & \hfill \vdots \hfill \\ {}\hfill {E}_{m,1}\hfill & \hfill {E}_{n,2}\kern0.75em \cdots \hfill & \hfill {E}_{m, p}\hfill \end{array}\right]$

$D E = \left[\begin{array}{ccc}\hfill D{E}_{1,1}\hfill & \hfill D{E}_{1,2}\kern0.5em \cdots \hfill & \hfill D{E}_{1, p}\hfill \\ {}\hfill \vdots \hfill & \hfill \ddots \hfill & \hfill \vdots \hfill \\ {}\hfill D{E}_{n,1}\hfill & \hfill D{E}_{n,2}\cdots \hfill & \hfill D{E}_{n, p}\hfill \end{array}\right]$

假设维数相等，一个矩阵中的每个元素乘以另一个元素的相应元素，得到一个新矩阵。尽管浏览这些例子似乎毫无意义，但它实际上比看起来更重要——特别是因为所有的操作都将由计算机执行。如果只是为了调试代码中的错误，读者应该熟悉矩阵乘法的乘积。我们将看到不同的矩阵运算，它们也将在以后不同的上下文中出现。

行列向量乘法

对于那些想知道矩阵乘法如何精确地产生单个标量值的人，下一节将对此进行进一步的阐述。如果

$\boldsymbol{X}=\left(\begin{array}{ccc}\hfill \boldsymbol{x}\hfill & \hfill \boldsymbol{y}\hfill & \hfill \boldsymbol{z}\hfill \end{array}\right),\kern1em \boldsymbol{Y} = \begin{array}{c}\hfill \boldsymbol{d}\hfill \\ {}\hfill \boldsymbol{e}\hfill \\ {}\hfill \boldsymbol{f}\hfill \end{array}$

那么它们的矩阵乘积由下面给出:

$\boldsymbol{X}\boldsymbol{Y}=\left(\begin{array}{ccc}\hfill \boldsymbol{x}\hfill & \hfill \boldsymbol{y}\hfill & \hfill \boldsymbol{z}\hfill \end{array}\right)\begin{array}{c}\hfill \boldsymbol{d}\hfill \\ {}\hfill \boldsymbol{e}\hfill \\ {}\hfill \boldsymbol{f}\hfill \end{array}$

$\boldsymbol{X}\boldsymbol{Y}=\boldsymbol{x}\boldsymbol{d} + \boldsymbol{y}\boldsymbol{e}+\boldsymbol{z}\boldsymbol{f}$

对比:

$\boldsymbol{Y}\boldsymbol{X} = \begin{array}{c}\hfill \boldsymbol{d}\hfill \\ {}\hfill \boldsymbol{e}\hfill \\ {}\hfill \boldsymbol{f}\hfill \end{array}\left(\begin{array}{ccc}\hfill \boldsymbol{x}\hfill & \hfill \boldsymbol{y}\hfill & \hfill \boldsymbol{z}\hfill \end{array}\right)$

$\boldsymbol{Y}\boldsymbol{X} = \begin{array}{ccc}\hfill \boldsymbol{dx}\hfill & \hfill \boldsymbol{dy}\hfill & \hfill \boldsymbol{dz}\hfill \\ {}\hfill \boldsymbol{ex}\hfill & \hfill \boldsymbol{ey}\hfill & \hfill \boldsymbol{ez}\hfill \\ {}\hfill \boldsymbol{fx}\hfill & \hfill \boldsymbol{fy}\hfill & \hfill \boldsymbol{fz}\hfill \end{array}$

列向量和方阵

在某些情况下，我们需要用整个矩阵乘以一个列向量。在这个实例中，以下成立:

$\boldsymbol{B}=\begin{array}{ccc}\hfill 1\hfill & \hfill 2\hfill & \hfill 3\hfill \\ {}\hfill 4\hfill & \hfill 5\hfill & \hfill 6\hfill \\ {}\hfill 7\hfill & \hfill 8\hfill & \hfill 9\hfill \end{array},\kern1em \boldsymbol{C} = \begin{array}{c}\hfill \boldsymbol{d}\hfill \\ {}\hfill \boldsymbol{e}\hfill \\ {}\hfill \boldsymbol{f}\hfill \end{array}$

B 和 C 的矩阵乘积由下式给出:

$\boldsymbol{Y}\boldsymbol{X} = \begin{array}{ccc}\hfill 1\boldsymbol{d}\hfill & \hfill 2\boldsymbol{d}\hfill & \hfill 3\boldsymbol{d}\hfill \\ {}\hfill 4\boldsymbol{e}\hfill & \hfill 5\boldsymbol{e}\hfill & \hfill 6\boldsymbol{e}\hfill \\ {}\hfill 7\boldsymbol{f}\hfill & \hfill 8\boldsymbol{f}\hfill & \hfill 9\boldsymbol{f}\hfill \end{array}$

正方形矩阵

其中最简单的矩阵运算是当我们处理两个方阵时，如下:

$\boldsymbol{B}=\begin{array}{ccc}\hfill 1\hfill & \hfill 2\hfill & \hfill 3\hfill \\ {}\hfill 4\hfill & \hfill 5\hfill & \hfill 6\hfill \\ {}\hfill 7\hfill & \hfill 8\hfill & \hfill 9\hfill \end{array}, \kern0.5em \boldsymbol{D}=\begin{array}{ccc}\hfill 9\hfill & \hfill 8\hfill & \hfill 7\hfill \\ {}\hfill 6\hfill & \hfill 5\hfill & \hfill 4\hfill \\ {}\hfill 3\hfill & \hfill 2\hfill & \hfill 1\hfill \end{array}$

$\boldsymbol{B}\boldsymbol{D}=\begin{array}{ccc}\hfill 1\hfill & \hfill 2\hfill & \hfill 3\hfill \\ {}\hfill 4\hfill & \hfill 5\hfill & \hfill 6\hfill \\ {}\hfill 7\hfill & \hfill 8\hfill & \hfill 9\hfill \end{array}\kern0.75em \boldsymbol{x}\kern0.75em \begin{array}{ccc}\hfill 9\hfill & \hfill 8\hfill & \hfill 7\hfill \\ {}\hfill 6\hfill & \hfill 5\hfill & \hfill 4\hfill \\ {}\hfill 3\hfill & \hfill 2\hfill & \hfill 1\hfill \end{array}$

$=\kern0.75em \begin{array}{ccc}\hfill \left(1*9\right)+\left(2*6\right)+\left(3*3\right)\hfill & \hfill \left(1*8\right)+\left(2*5\right)+\left(3*2\right)\hfill & \hfill \left(1*7\right)+\left(2*4\right)+\left(3*1\right)\hfill \\ {}\hfill \left(4*9\right)+\left(5*6\right)+\left(6*3\right)\hfill & \hfill \left(4*8\right)+\left(5*5\right)+6*2\Big)\hfill & \hfill \left(4*7\right)+\left(5*4\right)+\left(6*1\right)\hfill \\ {}\hfill \left(7*9\right)+\left(8*6\right)+\left(9*3\right)\hfill & \hfill \left(7*8\right)+\left(8*5\right)+\left(9*2\right)\hfill & \hfill \left(7*7\right)+\left(8*4\right)+\left(9*1\right)\hfill \end{array}$

$\boldsymbol{B}\boldsymbol{D}=\begin{array}{ccc}\hfill 30\hfill & \hfill 24\hfill & \hfill 18\hfill \\ {}\hfill 84\hfill & \hfill 69\hfill & \hfill 54\hfill \\ {}\hfill 138\hfill & \hfill 114\hfill & \hfill 90\hfill \end{array}$

按此逻辑:

$\boldsymbol{D}\boldsymbol{B} = \begin{array}{ccc}\hfill 90\hfill & \hfill 114\hfill & \hfill 138\hfill \\ {}\hfill 54\hfill & \hfill 69\hfill & \hfill 84\hfill \\ {}\hfill 18\hfill & \hfill 24\hfill & \hfill 30\hfill \end{array}$

行向量、方阵和列向量

在其他情况下，我们将对每个具有不同形状的矩阵/向量执行操作:

$\mathbf{A}\kern0.5em =\begin{array}{ccc}\hfill 9\hfill & \hfill 8\hfill & \hfill 7\hfill \\ {}\hfill 6\hfill & \hfill 5\hfill & \hfill 4\hfill \\ {}\hfill 3\hfill & \hfill 2\hfill & \hfill 1\hfill \end{array},\kern0.5em \mathbf{B} = \begin{array}{ccc}\hfill 1\hfill & \hfill 2\hfill & \hfill 3\hfill \end{array}, \kern0.75em \mathbf{C} = \begin{array}{c}\hfill 4\hfill \\ {}\hfill 5\hfill \\ {}\hfill 6\hfill \end{array}$

$\mathbf{A}\mathbf{B}\mathbf{C} = \begin{array}{ccc}\hfill 9\hfill & \hfill 8\hfill & \hfill 7\hfill \\ {}\hfill 6\hfill & \hfill 5\hfill & \hfill 4\hfill \\ {}\hfill 3\hfill & \hfill 2\hfill & \hfill 1\hfill \end{array} x\begin{array}{ccc}\hfill \kern0.5em 1\hfill & \hfill 2\hfill & \hfill 3\hfill \end{array} x\begin{array}{c}\hfill 4\hfill \\ {}\hfill 5\hfill \\ {}\hfill 6\hfill \end{array}$

$\begin{array}{ccc}\hfill 9\hfill & \hfill 8\hfill & \hfill 7\hfill \\ {}\hfill 6\hfill & \hfill 5\hfill & \hfill 4\hfill \\ {}\hfill 3\hfill & \hfill 2\hfill & \hfill 1\hfill \end{array}\ \mathbf{X}\kern0.75em \begin{array}{ccc}\hfill \kern0.5em 4\hfill & \hfill 10\hfill & \hfill 18\hfill \end{array}$

$\boldsymbol{A}\boldsymbol{B}\boldsymbol{C} = \begin{array}{ccc}\hfill 36\hfill & \hfill 32\hfill & \hfill 28\hfill \\ {}\hfill 60\hfill & \hfill 50\hfill & \hfill 40\hfill \\ {}\hfill 54\hfill & \hfill 36\hfill & \hfill 18\hfill \end{array}$

矩形矩阵

我们最后的例子处理矩形矩阵。对于这个例子，我们有两个矩阵 Z 和 Y，例如:

$\mathbf{Z}\kern0.75em =\begin{array}{ccc}\hfill 1\hfill & \hfill 2\hfill & \hfill 3\hfill \\ {}\hfill 4\hfill & \hfill 5\hfill & \hfill 6\hfill \end{array}\kern0.75em ,\kern1em \mathbf{Y}=\kern0.75em \begin{array}{cc}\hfill 9\hfill & \hfill 8\hfill \\ {}\hfill 7\hfill & \hfill 6\hfill \\ {}\hfill 5\hfill & \hfill 4\hfill \end{array}$

$\mathbf{Z}\mathbf{Y}=\begin{array}{ccc}\hfill 1\hfill & \hfill 2\hfill & \hfill 3\hfill \\ {}\hfill 4\hfill & \hfill 5\hfill & \hfill 6\hfill \end{array} x\begin{array}{cc}\hfill 9\hfill & \hfill 8\hfill \\ {}\hfill 7\hfill & \hfill 6\hfill \\ {}\hfill 5\hfill & \hfill 4\hfill \end{array}$

$=\kern0.75em \begin{array}{cc}\hfill 9\hfill & \hfill 40\hfill \\ {}\hfill 28\hfill & \hfill 18\hfill \\ {}\hfill 10\hfill & \hfill 240\hfill \end{array}$

矩阵乘法属性(两个矩阵)

不可交换

一般情况下，给定两个矩阵 A 和 B，AB ≠ BA，AB 和 BA 可能不同时定义，即使同时定义，也仍然可能不相等。这与普通的数字乘法相反。例如，要口头指定矩阵乘法的顺序，A 与 B 前乘意味着 BA，而 A 与 C 后乘意味着 AC。只要矩阵的元素来自一个有单位元且 n > 1 的环，则该环上存在一对 n×n 非交换矩阵。一个显著的例外是单位矩阵，因为它与每个方阵互换。

分配超矩阵加法

矩阵中的分配性遵循与向量中相同的逻辑。因此，以下公理成立:

左分配性:

$A\left( B+ C\right) = AB+ B C$

右分配性:

$\left( A+ B\right) C= AC+ B C$

这些操作的指标符号分别如下:

${\varSigma}_k{A}_{ik}\left({B}_{k j}+{C}_{k j}\right)={\varSigma}_k{A}_{ik}{B}_{k j}+{\varSigma}_k{A}_{ik}{C}_{k j}$

${\varSigma}_k\left({A}_{ik}+{B}_{ik}\right){C}_{k j}={\varSigma}_k{A}_{ik}{C}_{k j}+{\varSigma}_k{B}_{ik}{C}_{k j}$

标量乘法与矩阵乘法兼容

根据我们前面关于矩阵的标量乘法的讨论，我们在这里看到矩阵的标量乘法的分配性也成立。例如，我们有下面的等式，它是这样证明的:

$\lambda (AB)=\left(\lambda A\right) B$

$(AB)\lambda = A\left( B\lambda \right)$

λ是标量。如果矩阵的元素是实数或复数，那么所有四个量都相等。更一般地，如果λ属于矩阵的元素环的中心，则所有四个都相等，因为在这种情况下 $\lambda X= X\lambda$ 。

这是如下的索引符号:

$\lambda {\varSigma}_K\left({A}_{ik}{B}_{k j}\right)={\varSigma}_k\left(\lambda {A}_{ik}\right){B}_{k j}=\varSigma {A}_{ik}\left(\lambda {B}_{k j}\right)$

${\varSigma}_k\left({A}_{ik}{B}_{k j}\right)\lambda =\varSigma \left({A}_{ik}\lambda \right){B}_{k j}={\varSigma}_k{A}_{ik}\left({B}_{k j}\lambda \right)$

移项

如前所述，矩阵的转置是对矩阵的操作，其中该变换的乘积是新矩阵，其中新矩阵的行是原始矩阵的列，新矩阵的列是原始矩阵的行。给定两个矩阵 A 和 B

${(AB)}^T=\kern0.5em {B}^T{A}^T$

，下面的等式显示了我们如何表示这种变换

其中 T 表示转置，即矩阵中第 I 行与第 I 列的互换。这个恒等式适用于交换环上的任何矩阵，但不适用于一般的所有环。注意 A 和 B 是颠倒的。

指数表示法: ${\left[{(AB)}^T\right]}_{ij}={(AB)}_{ji}$

$={\varSigma}_K{(A)}_{jk}{(B)}_{ki}$

$={\left[\left({B}^T\right)\left({A}^T\right)\right]}_{ij}$

微量

乘积 AB 的迹与 A 和 b 的阶无关，迹也可以认为是一个矩阵的对角线:

t r(AB) = t r(BA)

指数表示法: $t r(AB)={\varSigma}_i{\varSigma}_k{A}_{i k}{B}_{i k}$

$={\varSigma}_k{\varSigma}_i{B}_{k i}{A}_{i k}$

= t r(BA)

规范

范数是为向量空间中的每个向量分配严格正的长度或大小的函数。在机器学习中，你会遇到许多不同的规范，除了增加分类模型的准确性之外，它们在减少回归模型的 MSE 方面也起着至关重要的作用。例如，岭回归使用 L2 范数在高度多重共线性期间缩小回归系数，而 LASSO 使用 L1 范数将某些回归系数缩小为零。我将在第三章详细回顾这两个回归模型。

在深度学习的背景下，在深度神经网络中添加不同层的实验(其中规范用于对数据执行维度缩减)在一些任务中被证明是成功的。例如，在卷积神经网络中使用 L2 范数层。但是这也可以用作多层感知器中的相异/损失度量，而不是传统的梯度函数。

欧几里得范数

这描述了在ℝ ⁿ 的欧几里得空间中一个向量的距离。让我们假设 $x=\left({x}_1,{x}_2,\dots,\ {x}_n\right)$ 。

L2 常模

这给出了向量内原点到 x 内最后一点的距离，通常称为 L2 范数:

${\left|\left| x\right|\right|}_2²=\sqrt{x_1² + {x}_2²+\dots +{x}_n²}$

L1 常模

这和 L2 范数是一样的，除了标量不是平方的:

$\left|\left| x\right|\right| = \sqrt{x_1+{x}_2+\dots +{x}_n}$

L1 和 L2 标准的形状如图 2-4 所示。

图 2-4。

L1 and L2 norm shapes

注意，在 L1 范数下，我们观察到的是正方形(或立方体)，而在 L2 范数下，我们观察到的是圆形(或球形)。在某些情况下，最好在执行回归分析的同时使用 L1 范数来执行变量选择，但是这个问题并不总是存在，我将在第八章中进一步详细讨论。

使用 L1 范数的优势是显而易见的，因为您可以在执行回归的同时执行特征选择。然而，应该注意，在数据集的缩减已经发生之后执行特征选择会鼓励过拟合。第八章更广泛地回顾了构建稳健模型的策略和一般实践，但通常建议读者在将数据拟合到模型之前，在很少或没有进行特征选择的情况下使用 L1 规范。

对于那些对车辆路线问题感兴趣的人来说，出租车(曼哈顿)规范与那些想要关注与运输和/或递送或包裹/人员相关的领域的人相关。出租车定额描述了出租车沿给定城市街区行驶的距离:

$\left|\left| x\right|\right|={\varSigma}_i\left|{x}_i\right|,\ f o r\ i=1,2, \dots,\ n$

绝对值范数是由实数或复数形成的一维向量空间上的范数。绝对值范数已被用来代替其他损失函数或相异函数:

p-范数

设 p ≥ 1 为实数:

${\left|\left| x\right|\right|}_p=\varSigma {\left({\left|{x}_i\right|}^p\right)}^{\frac{1}{p}}$

该定额的形状如图 2-5 所示。

图 2-5。

P-norm

对于 p=1 ,我们得到出租车范数，对于 p=2, ,我们得到欧几里德范数，对于 $p\to \infty$ ,我们得到无穷范数或最大范数。p-范数与广义均值或幂均值相关。然而当 0< p<1 时，我们没有得到离散定义的范数，因为它违反了三角形不等式。三角形不等式表明，三角形的任何一条边都必须小于或等于其他两条边之和。

矩阵范数

矩阵范数是来自 ${\mathrm{\mathbb{R}}}^{nxn}\to \mathrm{\mathbb{R}}$ 的函数，它满足给定数量的属性，用||A||表示，给定矩阵 A。

这些属性如下:

$\left|\left| A\right|\right| > 0\kern0.5em f o r\ all\ M\in {\mathrm{\mathbb{R}}}^{nxn}\ and\ also\ \left|\left| A\right|\right| = 0\ i i f\ A=0$
$\left|\left| a M\right|\right|=\left| a\right|*\left|\left| M\right|\right|\kern0.5em f o r\ a ll\ a\in {\mathrm{\mathbb{R}}}^n$
$\left|\left| M+ N\right|\right|\le \left|\left| M\right|\right|+\left|\left| N\right|\right|$
$\left|\left| M N\right|\right|\le \left|\left| M\right|\right|*\ \left|\left| N\right|\right|$

内部产品

机器学习文献中经常提到的一种重要的向量空间是内积。向量空间的这个元素允许某人知道向量的长度或者两个向量之间的角度。此外，还可以从内积中确定赋范向量空间。具体地，内积是在支持向量机的内核中使用的函数，用于计算支持向量机从输入空间放入特征空间的数据的图像。的内积空间是一个函数〈.,.〉定义如下，其中 u 和 v 是矢量， $u=\left[{u}_1,{u}_2, \dots,\ {u}_n\left],\ v=\right[{v}_1,{v}_2,\dots,\ {v}_n\right]$ :

$\left\langle u, v\right\rangle ={u}_1{v}_1+{u}_2{v}_2+\dots +{u}_n{v}_n\kern0.5em f o r\ i=1,2, \dots,\ n$

对于要成为内积的函数，它必须满足三个公理:

共轭对称:

$\left\langle u, v\right\rangle = \left\langle v, u\right\rangle$

第一个自变量中的线性:

$\left\langle au+ b v, w\right\rangle = a\left\langle u, w\right\rangle + b\left\langle v, w\right\rangle$

正定性:

$F o r\ any\ u\in V,\ \left\langle u, u\right\rangle \ge 0; and\ \left\langle u, u\right\rangle =0\ o nly\ if\ u=0$

内积空间上的范数

内积空间自然具有定义的范数，该范数基于空间本身的范数，由以下给出:

$\left|\left| x\right|\right|=\sqrt{x}$

直接从公理出发，我们可以证明如下:柯西-施瓦茨不等式陈述对于一个内积空间的所有向量 u 和 v，以下为真:

${\left|\left|\left\langle u, v\right\rangle \right|\right|}²\le\ \left\langle u, u\right\rangle *\left\langle v, v\right\rangle$

只有当且仅当 u 和 v 线性相关时，两边才被视为相等，这意味着它们必须平行，其中一个向量的大小为零，或者一个向量是另一个向量的标量乘数。

证明

第一个证明:展开括号并收集相同的项得到下面的等式:

${\varSigma}_i^n{\varSigma}_j^n{\left({a}_i{b}_j-{a}_j{b}_i\right)}²=\left({\varSigma}_i^n{a}_i²\right){\varSigma}_j^n{b}_j² + \left({\varSigma}_i^n{b}_i²\right){\varSigma}_j^n{a}_j²-2\left(\varSigma {a}_i{b}_i\right){\varSigma}_j^n{b}_j{a}_j$

$=2\left({\varSigma}_i^n{a}_i²\right)\left({\varSigma}_i^n{b}_i²\right)-2{\left({\varSigma}_i^n{a}_i{b}_i\right)}²$

因为等式的左边是实数的平方和，所以它大于或等于零。照此，以下必然成立:

$\left({\varSigma}_i^n{a}_i²\right)\left({\varSigma}_i^n{b}_i²\right)\ge\ {\left({\varSigma}_i^n{a}_i{b}_i\right)}²$

第二个证明:考虑以下二次多项式方程:

$f(x)=\left({\varSigma}_i^n{a}_i²\right){x}²-2\left({\varSigma}_i^n{a}_i{b}_i\right) x+{\varSigma}_i^n{b}_i²=\varSigma {\left({a}_i x-{b}_i\right)}²$

因为 $f(x)\ge\ 0\ f o r\ \mathrm{any}\ x\in \mathrm{\mathbb{R}},$ 接下来 f(x)的判别式是负的，因此下面的情况一定是:

${\left({\varSigma}_i^n{a}_i{b}_i\right)}²-\left({\varSigma}_i^n{a}_i²\right)\left({\varSigma}_i^n{b}_i²\right)\le\ 0$

第三个证明:考虑下面两个欧几里德范数 A 和 B:

$Let\ A = \sqrt{a_1²+{a}_2²+\dots +{a}_n²},\kern0.75em B = \sqrt{b_1²+{b}_2²+\dots +{b}_n²}$

由算术-几何平均不等式，我们得到

$\frac{\varSigma_i^n\left({a}_i{b}_i\right)}{ A B}\le {\varSigma}_i^n\left(\frac{1}{2}\right)\left(\left(\frac{a_i²}{A²}\right)+\left(\frac{b_i²}{B²}\right)\right) = 1,$

如

$\varSigma {a}_i{b}_i\le AB = \sqrt{a_1²+{a}_2²+\dots +{a}_n²}\sqrt{b_1²+{b}_2²+\dots +{b}_n²}$

于是，就产生了下面的:

${\left(\varSigma {a}_i{b}_i\right)}²\le \left({\varSigma}_i^n{a}_i²\right)\left({\varSigma}_i^n{b}_i²\right)$

正交性

正交性被描述为不相关性的度量或程度。例如，向量的正交变换产生一个向量，使得它与我们变换的向量无关。内积在角度和长度方面的几何解释激发了我们在这些空间中使用的许多术语。事实上，柯西-施瓦茨不等式的一个直接结果是，它证明了定义两个非零向量之间的角度是正确的:

$\mathrm{Angle}\left(\mathrm{x},\mathrm{y}\right)= \arccos \frac{x, y}{\left|\left| x\right|\right|*\left|\left| y\right|\right|}$

外部产品

两个向量的张量积与前面定义的内积略有关系。张量积是一种创建类似于整数乘法的新向量空间的方式:

$\mathrm{Let}\ \mathrm{u}\ \mathrm{and}\ \mathrm{v}\ \mathrm{equal}\ \mathrm{two}\ \mathrm{v}\mathrm{ectors}\ \mathrm{where}\ \mathrm{x}=\left[{x}_1,{x}_2,{x}_3\right],\kern0.5em y={\left[{y}_1,\ {y}_2,{y}_3\right]}^T$

$y \otimes x= y{x}^T = \begin{array}{c}\hfill {y}_1\hfill \\ {}\hfill {y}_2\hfill \\ {}\hfill {y}_3\hfill \end{array}*\kern0.5em \begin{array}{ccc}\hfill {x}_1\hfill & \hfill {x}_2\hfill & \hfill {x}_3\hfill \end{array}\kern0.5em = \begin{array}{ccc}\hfill {y}_1{x}_1\hfill & \hfill {y}_1{x}_2\hfill & \hfill {y}_1{x}_3\hfill \\ {}\hfill {y}_2{x}_1\hfill & \hfill {y}_2{x}_2\hfill & \hfill {y}_2{x}_3\hfill \\ {}\hfill {y}_3{x}_1\hfill & \hfill {y}_3{x}_2\hfill & \hfill {y}_3{x}_3\hfill \end{array}$

特征值和特征向量

特征值是从方阵中导出的数，对应于特定的特征向量，也与方阵相关联。它们一起“提供了矩阵的特征分解”简单地说，矩阵的特征分解仅仅以特征向量及其相应的特征值的形式提供矩阵。特征分解很重要，因为它是一种“我们可以找到包含矩阵的函数的最大值(或最小值)的方法。”

特征分解:

$A u=\lambda u$

$\left( A-\lambda I\right) u=0$

其中 A =方阵，u =矩阵 A 的特征向量(如果向量乘以 A 后长度改变):

$\uplambda =\mathrm{eigenvalue}\ \mathrm{t}\mathrm{o}\ \mathrm{corresponding}\ \mathrm{eigenvecvtor}\ \mathrm{u}$

假设以下也成立:

$A = \left(\begin{array}{cc}\hfill 2\hfill & \hfill 3\hfill \\ {}\hfill 2\hfill & \hfill 1\hfill \end{array}\right)$

因此:

${u}_1=\left(\frac{3}{2}\right),\kern0.5em {u}_2=\left(-\frac{1}{1}\right),\kern0.5em {\lambda}_1=4,\kern0.5em {\lambda}_2 = -1$

对于大多数应用，特征向量被归一化为单位向量，如下:

${u}^T u=1$

此外，a 的特征向量放在矩阵 u 中。u 的每一列是 a 的特征向量。特征值存储在对角矩阵^中，其中矩阵的迹或对角线给出特征值。由此我们相应地改写第一个方程:

AU= U A

$A= U\wedge {U}^{-1}$

$=\left[\begin{array}{cc}\hfill 3\hfill & \hfill -1\hfill \\ {}\hfill 2\hfill & \hfill 1\hfill \end{array}\right]\left[\begin{array}{cc}\hfill 4\hfill & \hfill 0\hfill \\ {}\hfill 0\hfill & \hfill -1\hfill \end{array}\right]\left[\begin{array}{cc}\hfill 2\hfill & \hfill 2\hfill \\ {}\hfill -4\hfill & \hfill 6\hfill \end{array}\right]$

$= \left[\begin{array}{cc}\hfill 2\hfill & \hfill 3\hfill \\ {}\hfill 2\hfill & \hfill 1\hfill \end{array}\right]$

图 2-6 给出了特征向量的图示。

图 2-6。

Visulaization of eigenvectors

本征向量和本征值成为理解一种技术不可或缺的一部分，这种技术将在我们后面关于称为主成分分析(PCA)的变量选择技术的讨论中讨论。对称半正定矩阵的特征分解产生特征向量的正交基，每个特征向量具有非负特征值。PCA 研究变量之间的线性关系，并对输入数据集的协方差矩阵或相关矩阵执行。对于协方差或相关矩阵，特征向量对应于主分量，特征值对应于由主分量解释的方差。相关矩阵的主分量分析为观测数据的空间提供了标准正交本征基:在该基中，最大的本征值对应于与包含观测数据集的最大协变性相关联的主分量。

线性变换

线性变换是两个模块之间的映射 $\mathrm{V}\to \mathrm{W}$ ,它保留加法和标量乘法的操作。当 V = W 时，我们称之为 V 的线性算子，或自同态，线性变换总是将线性子空间映射到线性子空间上，有时这可以在一个较低的维数上。这些线性映射可以表示为矩阵，例如旋转和反射。使用线性变换的一个例子是 PCA。稍后将详细讨论，PCA 是数据集中的特征到不相关主分量的正交线性变换，因此对于 K 个特征，我们有 K 个主分量。我将在下面的小节中详细讨论正交性，但是现在我将重点放在 PCA 的更广泛的方面。每个主成分保留了原始数据集的方差，但给出了它的表示，这样我们可以根据方差对数据集的贡献来推断给定主成分的重要性。当将其转换为原始数据集时，我们可以从数据集中删除我们认为没有显著差异的特征。

如果以下条件成立，函数 $\mathrm{\mathcal{L}}:{\mathrm{\mathbb{R}}}^n\to {\mathrm{\mathbb{R}}}^m$ 称为线性变换:

$\mathrm{\mathcal{L}}(ax) = a\mathrm{\mathcal{L}}(x) f o r\ every\ x\in {\mathrm{\mathbb{R}}}^n a nd\ a\in \mathrm{\mathbb{R}}$

$\mathrm{\mathcal{L}}\left( x+ y\right) = \mathrm{\mathcal{L}}(x) + \mathrm{\mathcal{L}}(y) f o r\ every\ x,\ y,\ \in\ {\mathrm{\mathbb{R}}}^n$

当我们固定ℝ ⁿ 和ℝ ^m 的基时，线性变换ℒ可以用矩阵 a 来表示。具体地，存在 $A\in {\mathrm{\mathbb{R}}}^{mxn}$ 使得下面的表示成立。假设 $x\in {\mathrm{\mathbb{R}}}^n$ 是给定的向量，x’是 x 相对于ℝ ^m 的给定基的代表。如果 $y=\mathrm{\mathcal{L}}(x)$ 和 y’是 y 相对于ℝ ^m 给定基的代表，则

${y}^{\prime } = Ax\hbox{'}$

我们称 a 为ℒ关于ℝ ⁿ 和ℝ ^m 的给定基的矩阵表示。

二次型

二次型是多个变量的二次齐次多项式，在机器学习中有应用。具体来说，我们寻求优化的两次可微的函数可以使用牛顿法进行优化。这其中的力量在于，如果一个函数是两次可微的，我们知道我们可以达到一个客观的最小值。

二次型 $f:\ {\mathrm{\mathbb{R}}}^n\to {\mathrm{\mathbb{R}}}^m$ 是一个函数，使得以下成立:

$F(x) = {x}^T Q x$

其中 Q 是一个 n×n 实矩阵。假设 Q 是对称的——即 $Q={Q}^T$ ,不失一般性

矩阵 Q 的子矩阵是通过连续地从 Q 中移除行和列而获得的矩阵的行列式。主要子矩阵是 detQ 本身以及通过移除第 I 行和第 I 列而获得的矩阵的行列式。

西尔威斯特标准

Sylvester 准则是判定矩阵是否半正定的充要条件。简单地说，它说明了一个矩阵是半正定的，所有的主要子矩阵都必须是正的。

证明:如果实对称矩阵 A 有正的非负特征值，称为正定。当特征值恰好非负时，称 A 是正半定的。

一个实对称矩阵 A 有非负的特征值当且仅当 A 可以分解为 $A={B}^T B$ 并且所有的特征值都是正的当且仅当 B 是非奇异的。

前向含义:如果 $A\in {R}^{nxn}$ 是对称的，那么有一个正交矩阵 P 使得 $A= P D{P}^T$ 其中 $\mathrm{D}=\mathrm{diag}\left({\uplambda}_1{\uplambda}_2,\dots,\ {\uplambda}_{\mathrm{n}}\right)$ 是一个实对角矩阵，其元素使得它的列是 a 的特征向量。如果 ${\lambda}_i\ge 0$ 对于每个 I， ${D}^{\frac{1}{2}}$ 存在。

反向蕴涵:如果 a 可以因式分解为 A = B^TB，那么 a 的所有特征值都是非负的，因为对于任何特征对(x，λ)

$\lambda =\left(\frac{x^T Ax}{x^{T x}}\right)=\left(\frac{x^T{B}^T Bx}{x^T x}\right)=\left(\frac{{\left|\left| Bx\right|\right|}²}{{\left|\left| x\right|\right|}²}\right)\ge 0$

正交投影

投影是从向量空间到其自身的线性变换 P，使得 {P}²= P 直观地，这意味着每当 P 被应用于任何值两次时，它给出与它被应用一次时相同的结果。它的图像是不变的，而且这个定义推广了图形投影的概念。 $\mathcal{V}$ 是 ${\mathrm{\mathbb{R}}}^n\ \mathrm{if}\ {\mathrm{x}}_1,{\mathrm{x}}_2\in \mathcal{V}\to \alpha {x}_1+\beta {x}_2\in \mathcal{V}\ \mathrm{f}\mathrm{o}\mathrm{r}\ \mathrm{all}\ \upalpha, \upbeta \in \mathrm{\mathbb{R}}.$ 的子空间，这个子空间的维数也等于 $\mathcal{V}$ 中线性无关向量的最大数目如果 $\mathcal{V}$ 是ℝ ⁿ 的子空间，则 $\mathcal{V}$ 降级的 ${\mathcal{V}}^{\perp }$ 的正交补由与 $\mathcal{V}$ 中的每个向量正交的所有向量组成，因此，以下为真:

${\mathcal{V}}^{\perp }=\left\{ x:{v}^T x=0\ for\ all\ v\in\ \mathcal{V}\right\}$

$\mathcal{V}$ 的正交补也是子空间。总之， $\mathcal{V}\ \mathrm{and}\ {\mathcal{V}}^{\perp }$ 跨越ℝ ⁿ ，在这个意义上，每个向量 $x\in\ {\mathrm{\mathbb{R}}}^n$ 都可以表示为

$x={x}_1+{x}_2$

其中 ${x}_1\in \mathcal{V}\ \mathrm{and}\ {x}_2\in {\mathcal{V}}^{\perp }.$ 我们称上面的表示为 x 关于 $\mathcal{V}$ 的正交分解，我们说 x ₁ 和 x ₂ 分别是 x 到子空间 $\mathcal{V}$ 和 ${\mathcal{V}}^{\perp }$ 的正交投影。我们写 ${\mathrm{\mathbb{R}}}^n = \mathcal{V} \otimes {\mathcal{V}}^{\perp }$ 并且说ℝ ⁿ 是 $\mathcal{V}$ 和 ${\mathcal{V}}^{\perp }.$ 的直和，我们说 p 的线性变换是到 $\mathcal{V}$ 的正交投影，对于所有的 $x\in {\mathrm{\mathbb{R}}}^n$ 我们有 $P x\in \mathcal{V}\ \mathrm{and}\ x- P x\in {\mathcal{V}}^{\perp }$

矩阵的值域

矩阵的值域定义了它包含的列向量的数量。

设 A 的值域或图像写为:

$\mathrm{\mathcal{R}}(A)\triangleq\ \left\{ Ax\ : x\in {\mathrm{\mathbb{R}}}^n\right\}$

矩阵的零空间

两个向量空间之间的线性映射 $\mathrm{\mathcal{L}}:\mathcal{V}\to\ \mathcal{W}$ 的零空间是 $v\kern0.5em \mathrm{of}\ \mathcal{V}$ 的所有元素的集合，其中 $\mathrm{\mathcal{L}}(v) = 0$ 中的零表示 $\mathcal{W}$ 中的零向量

A 的零空间，或者说内核，写作如下:

$\mathcal{N}(A)\ \triangleq\ \left\{ x\in\ {\mathrm{\mathbb{R}}}^n\ : Ax=0\right\}$

超平面

前面我提到了支持向量机和超平面的重要性。在回归问题的上下文中，超平面内的观察值作为响应变量解是可接受的。在分类问题的背景下，超平面形成了不同观察类之间的边界(如图 2-7 所示)。

图 2-7。

Visualization of hyperplane

我们将超平面定义为比其周围空间小一个维度的子空间，或者称为围绕对象的特征空间。

设 $u=\left[{u}_1,{u}_2, \dots,\ {u}_n\right],\kern0.5em \mathrm{u}\in \mathrm{\mathbb{R}}$ ，其中 u _i 中至少有一个是非零的。满足线性方程

${u}_1{x}_1+{u}_2{x}_2+\dots +{u}_n{x}_n= v$

的所有点 $x={\left[{x}_1,{x}_2, \dots,\ {x}_n\right]}^T$ 的集合

称为空间ℝ ⁿ 的超平面。我们可以用下面的等式来描述超平面:

$\left\{ x\in {\mathrm{\mathbb{R}}}^n\ :{u}^T x= v\right\}$

超平面不一定是ℝ ⁿ 的子空间，因为一般来说，它不包含原点。对于 n = 2，超平面的方程具有形式 ${u}_1{x}_1+{u}_2{x}_2= v$ ，它是一条直线的方程。因此，直线是ℝ ² 中的超平面。在ℝ ³ 中，超平面就是普通平面。超平面 h 将ℝ ⁿ 分成两个半空间，表示如下:

${H}_{+} = \left\{ x\in\ {\mathrm{\mathbb{R}}}^n\ :{u}^T x\ge 0\right\},$

${H}_{-} = \left\{ x\in {\mathrm{\mathbb{R}}}^n\ :{u}^T x\le 0\right\}\ .$

这里 ${H}_{+}$ 是正半空间， ${H}_{-}$ 是负半空间。超平面 H 本身由 $\left\langle u, x- a\right\rangle =0$ 的点组成，其中 $a={\left[{a}_1,{a}_2, \dots,\ {a}_n\right]}^T$ 是超平面的任意点。简单地说，超平面 H 是向量 u 和 x–a 彼此正交的所有点 x。

顺序

实数序列是一个函数，其定义域是自然数 1，2，…，k 的集合，值域包含在ℝ.内因此，一个实数序列可以看作一组数{x ₁ ，x ₂ ，…，x _k }，通常也表示为{x _k }。

序列的性质

序列的长度被定义为其中元素的数量。有限长度 n 的序列也称为 n 元组。有限序列也包括空序列或没有元素的序列。无限序列是指在一个方向上无限的序列。因此，它被描述为具有第一个元素，但没有最后一个元素。既没有第一个元素也没有最后一个元素的序列称为双向无限序列或双无限序列。

此外，如果每一项都大于或等于前一项，则称一个序列是单调递增的。例如，序列 an(n) = 1 是单调递增的，如果且仅如果对于所有的 ${a}_{n+1}\ \ge {a}_n$ ，术语非递减和非递增经常用于代替递增和递减，以避免分别与严格递增和严格递减的任何可能的混淆。

如果实数序列的所有项都小于某个实数，则称该序列从上有界。这意味着存在 M 使得对于所有 n，a _n ≤ M ${a}_n\le M$ 。任何这样的 M 称为一个上界。同样，如果，对于某个实数 m， ${a}_n\ge m$ 对于所有大于某个 N 的 N，那么序列从下有界，任何这样的 m 称为下界。

限制

极限是当输入或索引接近某个值时，函数或序列接近的值。一个数 ${x}^{*}\in \mathrm{\mathbb{R}}$ 称为数列的极限，如果对于任何正ϵ都有一个数 k，使得对于所有的 $k> K,\ \left| xk-{x}^{*}\right|<\epsilon$ :

${x}^{*}=\underset{k\to \infty }{ \lim } x k$

有极限的序列称为收敛序列。非正式地说，一个单无限序列有一个极限，当 n 变得很大时，如果它接近某个值 L，称为极限。如果它向某个极限收敛，那么它就是收敛的。否则就是发散。图 2-8 显示了一个收敛于极限的序列。

图 2-8。

A function converging upon 0 as x increases

我们通常在机器学习和深度学习的背景下谈论收敛，以达到最佳解决方案。这是我们所有算法的最终目标，但随着读者遇到更困难的用例，这变得更加模糊。不是每个解决方案都有单一的全局最优解，相反，它可能有局部最优解。避免这些局部最优的方法将在后面的章节中详细讨论。通常这需要机器学习和深度学习算法的参数调整，这是算法训练过程中最困难的部分。

导数和可微性

可微性成为机器学习和深度学习的重要组成部分，特别是为了参数更新。这可以通过用于训练多层感知器的反向传播算法以及卷积神经网络和循环神经网络的参数更新来看出。函数的导数衡量一个量相对于另一个量的变化程度。衍生产品最常见的例子之一是斜率(y 随 x 的变化)，或股票回报(价格百分比随时间的变化)。这是微积分的基本工具，但也是我们将在本书后半部分学习的许多模型的基础。

如果存在一个线性函数 $\mathrm{\mathcal{L}}:\ {\mathrm{\mathbb{R}}}^n\to {\mathrm{\mathbb{R}}}^m$ 和一个向量 $y\in\ {\mathrm{\mathbb{R}}}^m$ ，使得

$A(x) = \mathrm{\mathcal{L}}(x) + y$

，则认为该函数是仿射的

对于每一个 $x\in {\mathrm{\mathbb{R}}}^n$ ,考虑一个函数 $f:\ {\mathrm{\mathbb{R}}}^n\to\ {\mathrm{\mathbb{R}}}^m$ 和一个点 ${x}_0\in\ {\mathrm{\mathbb{R}}}^n.$ ,我们想要找到一个仿射函数 A，它在点 x0 附近逼近 f。第一，很自然的强加这个条件:

$A\left({x}_0\right) = f\left({x}_0\right)$

我们通过ℒ、

$\mathrm{\mathcal{L}}+ y = \mathrm{\mathcal{L}}(x) - \mathrm{\mathcal{L}}\left({x}_0\right)+ f\left({x}_0\right) = \mathrm{\mathcal{L}}\left( x-{x}_0\right) + f\left({x}_0\right)$

$A(x) = \mathrm{\mathcal{L}}\left( x-{x}_0\right) + f\left({x}_0\right)$

的线性度得到 $y= f\left({x}_0\right)-\mathrm{\mathcal{L}}\left({x}_0\right).$

我们还要求 A(x)接近 f(x)的速度要比 x 接近 x ₀ 的速度快。

偏导数和梯度

偏导数也在各种机器学习推导中大量使用。它类似于导数，只是我们只对函数中的一个变量求导，而其他变量保持不变，而在全微分中，所有变量都要计算。梯度下降算法在第三章中讨论，但是我们现在可以讨论梯度本身的更广泛的概念。当应用于几个变量的函数时，梯度是导数概念的概括。梯度代表函数中增长率最大的点，其大小是图形在该方向的斜率。这是一个向量场，它在一个坐标系中的分量会在从一个坐标系到另一个坐标系时发生变换:

$\nabla f(x)= grad\ f(x) = \frac{df(x)}{dx}$

海森矩阵

函数可以不止一次可微，这就引出了海森矩阵的概念。Hessian 是一个标量值函数的二阶偏导数的方阵，或者标量场:

$\mathbf{H}=\left(\begin{array}{ccc}\hfill \frac{\partial² f}{\partial {x}_1²}\hfill & \hfill \frac{\partial² f}{\partial {x}_1\partial {x}_2} \cdot s \hfill & \hfill \frac{\partial² f}{\partial {x}_1\partial {x}_n}\hfill \\ {}\hfill \vdots \hfill & \hfill \ddots \hfill & \hfill \vdots \hfill \\ {}\hfill \frac{\partial² f}{\partial {x}_n\partial {x}_1}\hfill & \hfill \frac{\partial² f}{\partial {x}_n\partial {x}_2} \cdot s \hfill & \hfill \frac{\partial² f}{\partial {x}_n²}\hfill \end{array}\right)$

如果函数的梯度在某点 x 为零，那么 f 在 x 处有一个临界点，那么在 x 处的 Hessian 行列式称为判别式。如果这个行列式为零，则称 x 为 f 的退化临界点，或者 f 的非 Morse 临界点，否则为非退化临界点。

雅可比矩阵是向量值函数的一阶偏导数的矩阵。当这是一个方阵时，这个矩阵及其行列式都称为雅可比矩阵:

$\mathbf{J}=\frac{\mathrm{df}}{\mathrm{dx}}=\left[\frac{\partial f}{\partial {x}_1}\dots \frac{\partial f}{\partial {x}_n}\right] = \left[\begin{array}{ccc}\hfill \frac{\partial f1}{\partial {x}_1}\hfill & \hfill \cdots \hfill & \hfill \frac{\partial {f}_1}{\partial {x}_n}\hfill \\ {}\hfill \vdots \hfill & \hfill \ddots \hfill & \hfill \vdots \hfill \\ {}\hfill \frac{\partial {f}_m}{\partial {x}_1}\hfill & \hfill \cdots \hfill & \hfill \frac{\partial {f}_m}{\partial {x}_n}\hfill \end{array}\right]$

摘要

这使我们得出了基本统计学和数学概念的结论，这些将在后面的章节中引用。当读者对后面章节中的任何内容不确定时，应该鼓励他们回头再看这一章。接下来，我们将讨论为机器学习算法提供动力的更高级的优化技术，以及那些形成了我们随后将处理的深度学习方法的灵感的相同机器学习算法。

三、最优化和机器学习综述

在我们深入研究深度学习的模型和组件之前，重要的是要解决它所适合的更广泛的领域，即机器学习。但在此之前，我想简单地讨论一下优化。优化是指从一组可用的备选方案中选择最佳元素。大多数机器学习算法的目标是在给定一个函数和一些输入集的情况下找到最优解。正如已经提到的，这通常属于监督学习问题或无监督学习问题的概念，尽管过程大致相同。

无约束最优化

无约束最优化指的是一个我们很难找到最优解的问题。与约束优化相反，我们选择的 x 值是有约束的，这允许我们从更多的途径接近解决方案。无约束最优化问题的一个例子是下面的玩具问题:

$\mathrm{Minimize}\ \mathrm{f}\left(\mathrm{x}\right),\kern0.5em \mathrm{where}\ \mathrm{f}\left(\mathrm{x}\right) = {\mathrm{x}}²,\ \mathrm{x}\in \left[-100,100\right]$

图 3-1 显示了该功能。

图 3-1。

Visualization of f(x)

在这个问题中，因为没有约束，所以我们可以在定义的范围内选择 x 的任意值。给定我们寻求最小化的等式，x 的答案是 100。我们可以看到，当我们选择 x 时，我们全局最小化 f(x)的值。因此，我们声明 x = 100 = x*，这是 f(x)的全局极小值。相比之下，这里有一个约束优化问题:

$\mathrm{Minimize}\ \mathrm{f}\left(\mathrm{x}\right),\kern0.5em \mathrm{s}.\mathrm{t}.\left(\mathrm{subject}\ \mathrm{to}\right)\ \mathrm{x}\in \Omega$

$\mathrm{where}\ \mathrm{f}\left(\mathrm{x}\right) = {\mathrm{x}}²\ \mathrm{Subject}\ \mathrm{t}\mathrm{o}\ \mathrm{x}\in \Omega$

我们想要最小化的函数 $f:\ {\mathrm{\mathbb{R}}}^{\mathrm{n}}\to \mathrm{\mathbb{R}}$ 是一个实值函数，称为目标/成本函数。向量 x 是由独立变量组成的长度为 n 的向量，其中 $\mathrm{x}={\left[{\mathrm{x}}_1,\ {x}_2,\dots,\ {x}_n\right]}^T\in {\mathrm{\mathbb{R}}}^n$ 。这个向量中的变量通常被称为决策变量。集合ω是ℝ的子集，称为约束/可行集。我们说，前面的优化问题是一个决策问题，其中我们必须找到 x 的最佳向量，以满足目标主体的约束。这里，x 的最佳向量将导致目标函数的最小化。在这个函数中，因为我们有一个约束，我们称之为约束优化问题。 $\mathrm{x}\in \Omega$ 被称为集合约束。通常，这采取

$\Omega = \left\{\mathrm{x}\ :\mathrm{h}\left(\mathrm{x}\right)=0,\ \mathrm{g}\left(\mathrm{x}\right)\le 0\right\}$

的形式

其中 h 和 g 是一些给定的函数。h 和 g 被称为功能约束。

假设我们仍然在查看图 3-1 中显示的同一个函数，只是我们的可行集是ω。为简单起见，我们假设 h(x)和 g (x)等于如下:

$\mathrm{h}\left(\mathrm{x}\right)=\mathrm{g}\left(\mathrm{x}\right)=10- x$

因此，约束优化问题的答案将是 x = 10，因为这最接近 f(x)的全局极小值，x = 100，同时还满足ω中列出的函数约束。正如我们所看到的，约束集限制了我们选择解决方案的能力，因此必须做出妥协。我们每天都会遇到实际意义上的约束优化。例如，假设一个企业主正试图将他们工厂的生产成本降到最低。这将是一个受约束的优化问题，因为如果企业所有者不希望对他们的业务产生负面影响(并且仍然继续生产)，他们可能会受到产量约束，从而限制了他们可能的选择。

读者将会遇到的大多数机器学习问题都在约束优化问题的范围内，并且该约束通常是被分析的数据集的函数。其原因通常是因为在深度学习模型开发之前，这是我们可以接近人工智能的最接近的方法。概括地说，大多数专注于回归的机器学习算法都是约束优化问题，其目标是在给定的模型内最小化精度损失。正如我们在前面的玩具问题中简要讨论的，有两种极小值:局部极小值和全局极小值。

局部最小值

假设 $f:\ {\mathrm{\mathbb{R}}}^n\to\ {\mathrm{\mathbb{R}}}^m$ 是定义在某个集合 $\Omega \in\ {\mathrm{\mathbb{R}}}^{\mathrm{n}}$ 上的实值函数。对于所有的 $\mathrm{x}\in \Omega$ ，点 x*是ω $f(x)\ge\ f\left({x}^{*}\right)$ 上 f 的局部极小值。

全局最小化器

假设相同的函数 f 及其三级性质，点 x*是 f 在ω上的全局极小点，如果 $f(x)\ge f\left({x}^{*}\right)$ 对于所有 $\mathrm{x}\in \Omega .$

一般来说，在一个给定的问题中可以有多个局部极小值，但是如果有全局极小值，也只能有一个。在图 3-2 中，我们可以看到这与一个函数的映射有关。

图 3-2。

Local versus global minima

根据我们在给定时刻评估的函数的多少，我们可以选择大量的局部最小值。但是如果我们评估这个函数的整个范围，我们可以看到只有一个全局最小值。现在讨论一下我们如何确切地知道我们得出的解决方案，从数学上来说，是最优的，这是很有用的。

局部最小值的条件

在这一节中，我们导出了点 x*成为局部极小点的条件。我们用函数的导数 $f:\ {\mathrm{\mathbb{R}}}^n\to \mathrm{\mathbb{R}}.$ 回忆一下，f 的一阶导数，记为 Df 是

$D f\triangleq \left[\frac{\partial f}{\partial {x}_1},\frac{\partial f}{\partial {x}_2}, \dots, \frac{\partial f}{\partial {x}_n}\right]$

f 的梯度只是 Df 的转置。二阶导数，或 f 的黑森，是

$F(x)\triangleq {D}² f(x)=\left(\begin{array}{ccc}\hfill \frac{\partial² f(x)}{\partial {x}_1²}\hfill & \hfill \cdots \hfill & \hfill \frac{\partial² f(x)}{\partial {x}_n\partial {x}_{1\kern0.5em }}\hfill \\ {}\hfill \vdots \hfill & \hfill \ddots \hfill & \hfill \vdots \hfill \\ {}\hfill \frac{\partial² f(x)}{\partial {x}_1{x}_n}\hfill & \hfill \cdots \hfill & \hfill \frac{\partial² f(x)}{\partial {x}_n²}\hfill \end{array}\right)$

一阶导数/梯度给出了函数 f 在特定点的近似值的方向。二阶导数，或 Hessian，给了我们 f 在一点的二次近似。Hessian 和梯度都可以用来寻找最优化问题的局部解。如前所述，梯度用于参数更新，例如在通过梯度下降的线性回归中。然而，Hessian 也可以用于深度学习环境中的参数更新。我将在后面详细讨论这一点，但循环神经网络通常用于对时序或文本段等序列中出现的数据进行建模。具体而言，循环神经网络通常难以通过具有长期数据依赖性的某些数据序列的乘积来训练。在训练其他深度学习架构时，由于权重数量非常大，我们会遇到训练问题。这产生了一个大的海森矩阵，实际上使牛顿的方法失效。

Hessian-free 优化专注于最小化目标函数，其中我们计算矩阵向量乘积，而不是计算 Hessian。假设 Hessian 矩阵是正定的，我们收敛到一个解。通过解下面的方程，我们可以有效地用牛顿法对权重矩阵训练一个网络

${H}_p=\underset{\epsilon \to 0}{ \lim}\frac{\nabla f\left(\theta +\epsilon d\right)-\nabla f\left(\theta \right)}{\epsilon}$

其中 H _p 是矩阵矢量积，θ是某个参数(在本例中是权重)，d 是用户确定的值。

在 Hessian 矩阵不是正定的情况下，不能保证收敛于一个解，并导致完全不同的结果。然而，我们可以使用黑森矩阵的高斯-牛顿近似来近似黑森矩阵，于是黑森矩阵等于

$H={J}^T J$

其中 J 是参数的雅可比矩阵。

这产生了一个有保证的正定矩阵，因此验证了保证收敛所必需的假设。从回归向前，我想讨论分类算法的数学基础之一:邻域。

附近

邻域是分类算法范例中的一个重要概念。例如，使用这个概念的优秀算法是 K-最近邻。用户定义的 K 参数是最简单的算法之一，它决定了用于最终将对象分类为一类点的相邻数据点的数量。我们将一个点的邻域定义为包含上述点而不离开该集合的点集。考虑一点 $x\ \in {\mathrm{\mathbb{R}}}^n$ 。这个集合的一个邻域将是方程

$\left\{\ y\in\ {\mathrm{\mathbb{R}}}^n\ :\left|\left| y- x\right|\right|<\epsilon\ \right\}$

其中ϵ是在给定上下文中定义的某个正数。ϵ表示定义给定邻域大小的界限。视觉上，我们可以把一个邻域看作一个球体，或者两个半空间之间的空间，以 x 为中心，以ϵ为半径，如图 3-3 所示。

图 3-3。

Visualization of a neighborhood of a point x

这对于理解任何使用ε密集损失来定义观测分离的算法是很重要的。ε密集损失尤其用于支持向量机的情况，但是 K-最近邻广泛地利用邻域的概念来定义给定类内的观察值。

内部和边界点

如果集合 S 包含 x 的某个邻域，则称点 $x\ \in S$ 为集合 S 的内点。如果 x 的某个邻域内的所有点都在 S 中，则称 S 的所有内点的集合为 S 的内部。如果 x 的每个邻域都包含 S 中的一个点和不在 S 中的一个点，则称点 x 为集合 S 的边界点。类似地，S 的所有边界点都命名为边界。如果一个集合包含它的每个点的邻域，或者没有边界点，那么这个集合就是开的。如果一个集合包含它的边界，那么它就是闭的。如果一个集合既闭又有界，那么它就是紧的。

我们现在已经完成了对优化的回顾。现在，我们已经解决了必要的先决信息，我们可以深入讨论机器学习，并掌握这种范式中算法的更广泛的含义。

机器学习方法:监督学习

机器学习可以分为两大类:监督学习和非监督学习。监督学习的区别在于，在拟合模型之前，我们知道标签/响应变量 Y 是什么。因此，我们可以有效地评估模型的功效。在无监督学习中，我们没有这些信息，这不允许我们确定我们正确的程度。在讨论这两种范式的挑战之前，讨论一下这个领域的发展是合理的

机器学习的历史

机器学习是在 20 世纪 50 年代中期开发出来创造人工智能的。它的重点转移到创建程序，这些程序在迭代的基础上得到改进，但是专门用来完成一个任务，并且通常可以被看作是一种函数优化的方法。人工智能最终开始成为自己的领域，随着 20 世纪末的到来，机器学习开始成为一门更加发达和成熟的科学。机器学习从许多领域获得贡献和灵感，如统计学和计算机科学，重叠是如此之多，以至于许多统计程序经常包括并鼓励他们的学生精通这些技术。接下来的章节将讨论一些最常见的机器学习算法，包括一些为以下章节中描述的深度学习模型提供灵感的算法。

什么是算法？

在这之前，我偶尔会提到算法。简单地说，算法是我们为了完成某项任务而创建的过程。在接下来的章节中，在处理深度学习模型之前，我们将回顾除了在数据科学的一般实践中有用的算法之外，将在深度学习模型中使用的重要机器学习算法。

回归模型

回归指的是我们试图预测特定值的一系列问题。这些可能是房价、雇员的工资或者花瓣的长度。更重要的是，回归也可以用来衡量解释变量 x 影响响应变量 y 的程度。

线性回归

假设我们试图预测一个给定节目的电视收视率。根据之前的研究，我们知道这个节目最受欢迎的人群是 25-50 岁的人。我们还看到这两个变量之间有很强的线性相关性。因此，我们决定将此视为我们的解释变量或 x 变量，将评级视为我们的响应变量或 Y 变量。我们到底该如何进行？简单的线性回归是最合理的方法。简单线性回归利用相对基本的概念将解释变量 x 建模为响应变量 y

$E(Y)={\beta}_0 + {\beta}_1{x}_1+\dots + {\beta}_k{x}_k$ ，

其中β ₀ 为 y 截距，β ₁ 至β _k 为每个解释变量 x ₁ 至 x _k 对应的偏斜率，其中 k = 1，2，…，m，m =解释变量的个数。这就是所谓的线性概率模型，因为我们对 Y 的期望值建模是基于这样的假设，即 Y 位于普通最小二乘预测的可能点分布中的某个位置。

普通最小二乘法(OLS)

普通最小二乘法是线性回归的最基本形式。我们选择特定点 x 处的特定 E(Y)值的直觉是，我们希望找到一个 E(Y)值，使实际值和预测值之间的平方差最小。当在给定的实验中满足上述假设时，我们发现 OLS 方法会产生 Y 的最小方差和无偏估计值，同时也是 Y 的最大似然估计值

该模型的基本假设如下:

误差项呈正态分布。
当观察误差项时，存在恒定的方差。
数据的观测值是独立同分布的。
解释变量之间没有多重共线性。

我们选择特定点 x 处的特定 E(Y)值的直觉是，我们希望找到一个 E(Y)值，使实际 Y 值和预测 Y 值之间的平方差最小。在给定的实验中，当满足上述假设时，我们发现 OLS 方法会产生 Y 值的最小方差和无偏估计值，同时也是 Y 值的最大似然估计值。假设我们有一个 xy 图，类似于图 3-4 所示的图。

图 3-4。

Plotting of the response variable x

理论上，我们可以绘制无限多的 E(Y)线图。然而，只有一个解产生最佳解，使 E(Y)和 Y 之间的误差最小。假设只有一个解释变量，我们得出回归系数如下:

$\widehat{\beta}=\left(\frac{{\displaystyle {\sum}_{i=1}^n}{x}_i{y}_i-\frac{1}{n}\left({\displaystyle {\sum}_{i=1}^n}{x}_i\right)\left({\displaystyle {\sum}_{i=1}^n}{y}_i\right)\ }{{\displaystyle {\sum}_{i=1}^n}{x}_i²-\frac{1}{n}{\left({\displaystyle {\sum}_{i=1}^n}{x}_i\right)}²}\right)$

或者，回归系数方程可以写成

$\widehat{\beta}= \arg\ \underset{\beta}{ \min}\left|\left| y- x\beta \right|\right|$

$\widehat{\beta}={\left({X}^T X\right)}^{-1}{X}^T y$ 给予】

我们在这里所做的目的是最小化回归系数的大小，以便当我们将它乘以 x 时，简单地说，我们试图在数据和回归线之间找到一条最佳拟合线，以便最小化预测和实际数据点之间的平均误差。在我们推导出回归系数后，我们可以找到 y 截距，或 x = 0 时 y 的值，如下:

${\beta}_0=\overline{y}-\overline{x}\beta$

由此，我们有了 E(Y)方程的所有组成部分，现在可以对数据进行建模。

也就是说，使用 OLS 来寻找解决方案并不总是最佳的方法。对于相对小而简单的数据，利用 OLS 并不是一个特别的问题。当数据复杂且庞大，并且我们不满足 OLS 回归的假设时，利用梯度下降法可能更有效。

梯度下降算法

如前所述，函数的梯度代表函数中增长率最大的点，其大小是图中该方向的斜率。考虑到这一点，我们如何将梯度的概念应用到算法中，以便迭代地改进它呢？梯度下降是一种迭代算法，在这种算法中，根据您定义的某个阈值或一定次数的迭代，通过梯度的负值来更新参数。梯度通常乘以学习率，学习率决定了函数向最优解收敛的速度。

在线性回归的情况下，我们的目标是最小化 y^和 y 之间的残差值，称为误差函数，由

$J\left({\theta}_0,\ {\theta}_1\right)=\frac{1}{2 m}{\displaystyle \sum_{i=1}^m}{\left({h}_{\theta}\left({x}^i\right)-{y}^i\right)}²$

给出

其中 h _θ (x ⁱ 是预测的 y 值。

如果我们的目标是尽可能快地最小化成本函数，并且梯度是指向最陡方向的向量，则我们想要获取成本函数的梯度。梯度由以下给出:

$\frac{d}{d{\theta}_0}\left({\theta}_0,\ {\theta}_1\right)=\frac{1}{m}{\displaystyle \sum_{i=1}^m}\left({h}_{\theta}\left({x}^i\right)-{y}^i\right)$

$\frac{d}{d{\theta}_1}\left({\theta}_0,\ {\theta}_1\right) = \frac{1}{m}{\displaystyle \sum_{i=1}^m}\left({h}_{\theta}\left({x}^i\right)-{y}^i\right)\left({x}_j\right)$

为了更新参数，包括 y 轴截距和回归系数，我们计算如下，直到算法收敛于最优解:

${\theta}_0:={\theta}_0-\alpha \frac{d}{d{\theta}_0}\left({\theta}_0,\ {\theta}_1\right)$

${\theta}_1:={\theta}_1-\alpha \frac{d}{d{\theta}_1}\left({\theta}_0,\ {\theta}_1\right)$

通过梯度下降的多元线性回归

通过梯度下降的多元线性回归背后的直觉与简单线性回归相同——只有一个修改来适应在每次迭代时被调整的多个部分斜率:

${\theta}_0:={\theta}_0-\alpha \frac{d}{d{\theta}_0}\left({\theta}_0,\ {\theta}_1, \dots,\ {\theta}_n\right)$

${\theta}_j:={\theta}_j-\alpha \frac{d}{d{\theta}_j}\left({\theta}_0,\ {\theta}_1, \dots,\ {\theta}_n\right)$

学习率

要讨论的最后一个方面是学习率，表示为α，它实际上是梯度下降算法最重要的方面之一。学习率决定了梯度下降算法收敛到最优解的速度。通常，学习率被初始化为一个相对较小的值，通常为 0.01 或更小。也就是说，选择一个最佳的学习率并不总是显而易见的，不这样做可能会影响“解决方案”的产生。通常，梯度下降算法有两个停止条件:1)找到了最优解，2)达到了允许的最大迭代次数。以下与较差算法性能相关的问题是由以下情况引起的:

学习率太小:在我们选择一个太小的学习率的例子中，算法给出的解实际上不是最优解，我们达到最优解是由于第二个停止条件。有些人可能会说，避免这种情况的方法是通过选择学习率来增加迭代次数，但这很可能会破坏这种方法的目的，即其计算效率。
学习率太大:如果我们选择一个比需要的学习率大得多的学习率，我们也可能永远达不到一个最优解，尽管这是由于一个不同的原因。当学习率太大时，我们发现每次迭代的成本函数可能会过校正，并给出太小或太大的系数的更新值。因此，我们达成解决方案是靠运气，而且在大多数情况下，我们最终会达成最大的解决方案。

选择合适的学习速度

既然我们已经了解了与选择不正确的学习率相关的问题是什么，我们需要找出如何选择一个学习率。一个可能的解决方案是硬编码各种梯度，并观察算法在每次迭代中的表现。在下面的方法中，我们在梯度下降算法的每次迭代中更新步长。

粗体驱动方法将最近的梯度值与根据先前迭代导出的梯度值进行比较。如果误差已经减小，则适度增加学习速率。如果误差增加，将学习率降低 50%。

在下面的代码示例中，我们正在修改虹膜数据集。这个数据集可以追溯到罗纳德·费雪；他用它做了一系列初步实验。当显示各种统计和机器学习算法的基本方面时，它很受欢迎。这里，我们采用 iris 数据集的第一列，并针对 X 变量(仅仅是长度)进行建模，这样显示的数据就形成了一个线性模式。这只是一个展示 OLS 线性回归机制的例子。在下面的代码中，我们通过lm()函数将数据拟合到 OLS 回归中。然后，我们计算残差平方和，在输出中表示为Cost。然后，我们从lm()函数中提取该模型的回归系数，然后在数据框中输出这两个属性:

#Modifying Data From Iris Data Set
data(iris)
Y <-  matrix(iris[,1])
X <-  matrix(seq(0,149, 1))

olsExample <- function(y = Y, x = X){
y_h <- lm(y ∼ x)(1)
  y_hf <- y_h$fitted.values
  error <- sum((y_hf - y)²) (2)
  coefs <- y_h$coefficients (3)
  output <- list("Cost" = error, "Coefficients" = coefs)
  return(output)
}

当我们运行代码时，我们观察到如图 3-5 所示的结果。

图 3-5。

Output of OLS regression function

Cost是平方和，因此Coefficients被列为 y 截距，后跟 x 变量的部分斜率。我们将以此为基准，通过梯度下降来比较线性回归的性能。同样，本说明的目的是展示梯度下降算法复制简单 OLS 回归结果的效率和能力:

#Gradient Descent Without Adaptive Step
gradientDescent <- function(y = Y, x = X, alpha = .0001, epsilon = .000001, maxiter = 300000){
  #Intializing Parameters
  theta0 <-  0
  theta1 <-  0
  cost <- sum(((theta0 + theta1*x) - y)²)
  converged <- FALSE
  iterations <- 1

接下来，我们定义一个通过梯度下降实现线性回归的函数。这种梯度下降算法具有恒定的学习速率，但是如果您选择在其他数据集上使用这种实现，您可以改变该参数以及损失容限。我们已经将最大迭代次数定义为 300，000 次，如果在此之前没有达到最优解，将会强制算法在该解处停止。当具体分析代码时，我们首先将参数theta0和theta1初始化为 0。用户可以随意修改代码，用从正态分布中随机抽取的值初始化参数，但是应该将这些值除以 10，以确保它们不会过大。我们将cost函数初始化为 0 减去所有 y 值的 SSR，从这里我们将开始改变参数:

#Gradient Descent Algorithm
while (converged == FALSE){
  gradient0 <- as.numeric((1/length(y))*sum((theta0 + theta1*x) - y))
  gradient1 <- as.numeric((1/length(y))*sum((((theta0 + theta1*x) - y)*x)))

  t0 <- as.numeric(theta0 - (alpha*gradient0))
  t1 <- as.numeric(theta1 - (alpha*gradient1))

  theta0 <- t0
  theta1 <- t1

  error <- as.numeric(sum(((theta0 + theta1*x) - y)²))

  if (as.numeric(abs(cost - error)) <= epsilon){
    converged <- TRUE
  }
    cost <- error
    iterations <- iterations + 1
  if (iterations == maxiter){
    converged <- TRUE
  }
}

尽管我们还没有收敛到一个解决方案，或者我们还没有达到执行函数时允许的最大迭代次数，但是我们创建了gradient0和gradient1变量，它们分别对应于参数theta0和theta1。然后，我们使用包含在gradient0和gradient1变量中的梯度更新theta0和theta1参数。此后，我们计算误差，并从while ( converged == FALSE)继续循环，直到达到停止条件:

  output <- list("theta0" = theta0, "theta1" = theta1, "Cost" = cost, "Iterations" = iterations)
  return(output)
}

这里，我们运行一个简单的线性回归，其中y和x变量被随机初始化。当我们按照说明运行代码时，我们会得到如图 3-6 所示的结果。

图 3-6。

Output of gradient descent without adaptive step function

theta0是 y 轴截距，theta1是x变量的偏斜率，cost是平方和，iterations是执行的迭代次数。在这里，我们观察到较低的回归系数，大致相同的基线平方和误差。然而，如果我们使用一个太大的学习率，我们经常会得到一个错误，因为回归系数变得无限大。当学习率太小时，我们会注意到图 3-7 中显示的内容。

图 3-7。

Output of gradient descent with small learning rate

我们看到，该算法没有收敛到最小值，而是达到了一个可行的解决方案，并被我们设置的损失容限切断。顺便说一下，我们也接近了允许的最大迭代次数。错误选择算法的后果与应用给定算法的环境有关。但所有用户都应该谨慎评估他们在任何机器学习或深度学习算法上找到的结果。因此，在选择解决方案时，我们要尽可能地自信，这一点很重要。

在下一个示例中，我们使用自适应步长运行相同的算法来比较性能:

#Gradient Descent with Adaptive Step
adaptiveGradient <- function(y = Y, x = X, alpha = .0001, epsilon = .000001, maxiter = 300000){
  #Intializing Parameters
  theta0 <-  0
  theta1 <-  0
  cost <- sum(((theta0 + theta1*x) - y)²)
  converged <- FALSE
  iterations <- 1

  #Gradient Descent Algorithm
  while (converged == FALSE){
    gradient0 <- as.numeric((1/length(y))*sum((theta0 + theta1*x) - y))
    gradient1 <- as.numeric((1/length(y))*sum((((theta0 + theta1*x) - y)*x)))

    t0 <- as.numeric(theta0 - (alpha*gradient0))
    t1 <- as.numeric(theta1 - (alpha*gradient1))

    delta_0 <- t0 - theta0
    delta_1  <- t1 - theta1
    if (delta_0 < theta0){
      alpha <- alpha*1.10
    } else {
      alpha <- alpha*.50
    }

这里，我们应用相同的梯度下降函数，除了现在我们应用大胆的驱动方法，以便我们有一个自适应的学习率。bold driver 方法基于先前的结果，从一个单独的迭代到下一个迭代改变学习速率。简单来说，如果梯度从一次迭代到下一次迭代增加，学习率增加 10%。如果梯度降低，我们将学习率降低 50%。读者可以随意更改这些参数，对收到的结果进行实验:

    theta0 <- t0
    theta1 <- t1
    error <- as.numeric(sum(((theta0 + theta1*x) - y)²))
    if (as.numeric(abs(cost - error)) <= epsilon){
      converged <- TRUE
    }
    cost <- error
    iterations <- iterations + 1
    if (iterations == maxiter){
      converged <- TRUE
    }
  }
  output <- list("theta0" = theta0, "theta1" = theta1, "Cost" = cost, "Iterations" = iterations, "Learning.Rate" = alpha)
  return(output)
}

执行此功能后，我们会收到如图 3-8 所示的结果。

图 3-8。

Output of gradient descent with adaptive learning rate functions

在我们测试的算法中，考虑到我们的目标是最小化成本和回归系数大小，通过梯度下降和自适应步长的线性回归或 OLS 方法是可以接受的。作为一个有趣的观察，该算法收敛到这个解决方案明显快于梯度下降法与静态学习率。

牛顿方法

对于我们寻求最小化二次函数的例子，牛顿的方法经常被证明是有用的。牛顿法是一种求函数根的方法，或者 f(x)等于 0 的地方。它是由艾萨克·牛顿和约瑟夫·拉弗森发明的。为了计算一个最佳点，我们推导出方程式

${x}^{k+1} = {x}^k-\left(\frac{f^{\prime}\left({x}^k\right)}{f^{{\prime\prime}}\left({x}^k\right)}\right)$

其中 f’是给定函数的一阶导数，f”是给定函数的二阶导数。这就是所谓的割线法。如果 f’(x)> 0，牛顿方法工作得特别好，但是如果 f”(x)< 0，它可能不会收敛到全局最小值。我们知道，如果函数的 Hessian 是半正定的，牛顿函数将总是收敛到全局最优。牛顿方法的另一个缺点是，如果起始点离全局最小值相当远，就不能保证收敛。在牛顿法不收敛于全局最小值的情况下，有一种启发式方法可以用来克服这一点，这将在下一章中介绍。

勒文伯格-马夸特启发式

Levenberg-Marquardt (LM)算法最适用于函数不是二次可微或其 Hessian 矩阵不是正定的情况。这个方程由下面给出:

${x}^{k+1}={x}^k-{\left( F\left({x}^k\right)+{\mu}_k I\right)}^{-1}{g}^k$

考虑一个非正定的方阵 F。这个矩阵的特征值可能不是正的，但都是实数。考虑一个矩阵

$G= F+\mu I$

其中 $\mu \ge 0\.$ G 的特征向量为 $\lambda + \mu$ 。因此，以下必然成立:

$G{v}_i=\left( F+\mu I\right){v}_i$

$= F{v}_i+\mu I{v}_i$

$={\lambda}_i{v}_i+\mu {v}_i$

$=\left({\lambda}_i+\mu \right){v}_i,$

通过这种修改，G 的所有特征值都是正的，那么 G 必须是正定的。如果μ也足够大，我们可以确定牛顿算法选择的方向将总是朝着最陡下降的方向。对算法的最后修改将是增加一个步长:

${x}^{k+1}={x}^k-\alpha {\left( F\left({x}^k\right)+{\mu}_k I\right)}^{-1}{g}^k$

什么是多重共线性？

多重共线性是许多数据科学家在解决问题时都会遇到的问题。在这种情况下，解释变量与其他变量几乎完全相关。在这种情况下，通过 OLS 或梯度下降使用线性回归变得很困难，因为该技术不能精确地估计回归系数，经常导致这些参数的值被夸大。这是因为很难区分一个解释变量对另一个解释变量的影响，以及随后每个解释变量对响应变量的影响。作为多重共线性的产物，我们观察到每次初始化线性回归算法时，回归系数的值都会发生变化，有时变化幅度很大。最终，这使得传统的线性回归成为处理显示这些类型模式的数据的不太可取的方法。

多重共线性测试

非常高的正回归系数是多重共线性的第一个迹象。除此之外，我们还应该计算所有解释变量之间的相关性。相关系数 $.95\le \rho \le 1$ 也应该引起数据科学家的警惕。不过，具体来说，我们可以使用一个统计数据来确定我们的数据集中是否绝对存在多重共线性，该统计数据称为方差膨胀因子。

差异通货膨胀系数(VIF)

VIF 统计是在从 $0\le V I F\le \infty$ 开始的范围内计算的。通常，经验法则是任何 VIF 分数为> 5 表示多重共线性，任何超过 10 的分数表示严重多重共线性。统计数据的计算方法是将一个给定的解释变量与其他变量进行回归，然后使用结果来计算决定系数，得出以下结果:

$V I{F}_j = \frac{1}{1-{R}_j²}\kern0.75em ,\mathrm{Where}\ j = 1, \dots,\ k$

里脊回归

为了解决多重共线性问题，岭回归被开发出来，并且是一种有用的技术。与我们之前对规范的讨论(L1 对 L2)相关，岭回归使用 L2 规范来获得最优解。岭回归方程如下:

$\arg \underset{\beta}{ \min }{\left|\left| y- X\beta \right|\right|}_2²+\lambda {\left|\left|\beta \right|\right|}_2$

岭回归的关键区别之一是调整参数λ，它决定了回归系数收缩的程度。由于 L2 范数形成了一个球形或圆形区域，其中回归系数的最优解沿着该形状的“脊”选择，因此该技术被命名为脊。从视觉上看，这通常类似于图 3-9 。

图 3-9。

Ridge regression OLS estimates

最小绝对收缩和选择算子(LASSO)

Lasso 与岭回归非常相似，只是 LASSO 在回归解释变量和响应变量时执行变量选择。LASSO 和岭回归之间的主要区别在于，LASSO 使用 L1 范数而不是 L2 范数，根据数据的维度为选择区域提供正方形或立方体形状。在图 3-10 的中，我们可以看到拉索 OLS 估计:

$\arg \underset{\beta}{ \min}\left|\left| y- X\beta \right|\right|+\lambda \left|\left|\beta \right|\right|$

图 3-10。

LASSO regression

比较岭回归和 LASSO

这两种方法在数据存在多重共线性的情况下都非常有用，但在试图像简单线性回归那样拟合数据的情况下，应避免使用这两种方法，而应使用之前给出的梯度法和 OLS 法。如果你没有一个以上的解释变量，这些方法将不会对你有用。尽管这在大多数情况下不太可能发生，但是记住这一点还是很重要的。

评估回归模型

除了构建回归模型之外，我们还需要找到一种方法来确定模型得出的结果有多准确，并最终根据具体情况选择最佳模型。在回归的情况下，评估机器学习模型的有用方法是通过自举。通常，bootstrapping 涉及使用比原始数据集更小的数据集和随机排列的原始观察值在多次迭代中运行不同的回归模型，然后对几个统计数据进行采样，并将它们的值与其他模型的值进行比较。流程如下:

建立几个模型。
收集样本统计数据，我们在 N 次实验迭代中使用这些数据作为每个模型的评估者。
对每个评估者进行采样，并在每次迭代时收集统计数据，例如:
1. 平均
2. 标准偏差
3. 最大
4. 福建话
评估结果，并根据您的目标和情况选择最有效的模型。

本节的其余部分将介绍在引导过程中应该选择的赋值器。

决定系数(R ²

如第二章所述，决定系数是我们用来评估模型通过 x 的可变性解释 y 的可变性的准确程度。R ² 值越高越好。也就是说，一般来说，“好”的 R ² 值应该在以下范围内:. 70 ≤ R ^{2 ≤ .95。任何低于 0.70 的都应被视为一般不可接受，任何高于 0.95 的都应被检查，以查看模型中是否存在过度拟合。虽然这在给定的迭代中不会有很大的变化，但是我们仍然应该在模型中客观地评估这一点。}

均方误差

MSE 测量 y 的给定预测值与实际响应变量的平均值之间的距离。我们对任何回归模型的目标都是尽可能地最小化这个统计量，所以我们希望选择相对于其他模型具有最低 MSE 的模型。这将是显示跨模型的最大差异的评估器，并且应该是在我们应该选择哪个模型方面给我们最大推理能力的评估器。

标准误差

在回归模型的情况下，我们可能会测量给定模型的标准误差。我们的目标应该是标准误差尽可能接近 0。高度负的或高度正的标准误差值通常是不期望的。

分类

超越预测特定值的情况，我们的数据观察通常属于我们想要给它们贴上标签的某个类别。我们将这种问题范式称为分类问题。为了向读者介绍这些类型的问题，我们从解决这些算法中最基本的问题开始:逻辑回归。

逻辑回归

除了回归，机器学习的一个重要任务是对观察值进行分类。尽管有多项分类算法，我们将从检查二元分类器开始，这种方法通常用作剩余分类器的基线。逻辑回归的名字来源于为其提供动力的函数，即逻辑函数，如图 3-11 所示。

图 3-11。

Visualization of logistic function

函数本身是这样写的:

$f(x)=\left(\frac{1}{1+{e}^{- x}}\right)$

我们如何对观测值进行分类的直觉很简单:我们为给定的 f(x)值设置一个阈值，如果它达到或超过该阈值，则将其分类为 1，否则分类为 0。在许多情况下，x 变量将被线性回归公式所取代，在该公式中，我们对数据进行建模。因此，f(x)的方程式，或对数几率，将是

$\pi =\frac{1}{1+{e}^{-\left({\beta}_0+{\beta}_1 X\right)}}$

其中，π =对数概率，π*是给定阈值。至于我们建立的阈值，这取决于我们想要最大化什么:准确性、敏感性或特异性。

Sensitivity/recall: The ability of a binary classifier to detect true positives:

$True\ Positive\ Rate=\frac{True\ Positive s}{Positives}=\frac{True\ Positive s}{True\ Positive+ False\ Negatives}$
Specificity: The ability of a binary classifier to detect true negatives:

$Specificity=\frac{True\ Negative}{Negatives}=\frac{True Negative s}{True\ Negative s+ False\ Positives}$
Accuracy: The ability of a binary classifier to accurately classify both positives and negatives:

$Accuracy=\frac{True\ Positives+ True\ Negatives}{Positives+ Negatives}$

在某些情况下，放大这些统计数据可能更有利，但这都是相对于这些算法的应用场合而言的。例如，如果您正在测试手机电池燃烧的可能性，您可能希望确保尽可能减少误报。但是，如果你试图检测某人在约会网站上找到匹配的概率，你可能会想最大化真正的积极因素。使用 ROC 曲线最容易说明这些预测能力之间的权衡关系，该曲线显示了改变π*的值如何影响模型的分类统计。

受试者工作特性曲线

ROC 曲线最初在第二次世界大战期间用于雷达探测的目的，但它的用途很快被考虑到其他领域，统计学就是其中之一。ROC 曲线显示了二元分类器准确检测真阳性并同时通过显示其假阳性率来检查其不准确程度的能力。如图 3-12 所示。

图 3-12。

Example ROC curve plot

在逻辑回归的情况下，给定π的特定阈值，任何特定模型的评估最终由曲线下面积或 AUC 决定。该图的顶点是. 50 AUC 分数，这表明该模型，如果它的分数是这样的话，在分类上并不比随机猜测好。理想情况下，这个 AUC 分数应该接近 1，但是我们通常接受任何≥ .70 的分数。

混淆矩阵

评估分类模型的另一种方法是混淆矩阵，它是分类器预测与给定观察值的实际标签的图形表示。从这个可视化中，我们得到了前面列出的统计值，这些值最终帮助我们准确地评估分类模型的性能。图 3-13 显示了混淆矩阵的可视化示例。

图 3-13。

Confusion matrix

解释混淆矩阵中的值通常是一项由读者决定的主观任务。在某些情况下，误报，比如确定用户是否应该购买某个产品，对于解决手头的问题并没有那么有害。在其他情况下，例如确定汽车发动机是否有故障，假阳性实际上可能是有害的。读者应该意识到他们正在执行的任务，并相应地调整模型以限制假阳性和/或假阴性。

逻辑回归的局限性

逻辑回归只能预测离散的结果。它需要普通线性回归所必需的许多假设，并且数据的过度拟合会变得非常普遍。除此之外，当我们有明显可分的数据时，用逻辑回归分类效果最好。出于这些原因，除了有更复杂的技术可用这一事实之外，一种常见的建模实践是将逻辑回归模型视为基线，通过它我们可以并列其他分类方法并观察其细微差别。

接下来，我们将看一个使用逻辑回归的简单例子。对于那些对该模型生产过程感兴趣的人来说，该数据集将在后面的章节以及第十章中详细引用。：

#Code Redacted, please check github!
#Logistic Regression Model
lr1  <- glm(data[,1] ∼ data[,2] + data[,3] + data[,4] + data[,5] + data[,6] + data[,7],
            family = binomial(link = "logit"), data = data)

#Building Random Threshold
y_h <- ifelse(lr1$fitted.values >= .40, 1, 0)

#Construct ROC Curve
roc(response = data[,1], predictor = y_h, plot=TRUE, las=TRUE,    legacy.axes=TRUE, lwd=5, main="ROC for Speed Dating Analysis", cex.main=1.6, cex.axis=1.3, cex.lab=1.3)

我们模型的 ROC 曲线如图 3-14 所示。

图 3-14。

ROC curve for logistic regression example

使用前面的代码，我们得到了. 7353 曲线下的面积。考虑到我们之前设置的阈值，该模型的性能可以接受，但可能需要进行更多的调整。

支持向量机(SVM)

在可用的更复杂的机器学习模型中，支持向量机是一种二进制分类方法，它比逻辑回归模型更灵活，因为它们可以执行非线性分类。这是通过其核函数来执行的，核函数是将数据正交投影到新特征空间的方程，对象的分类是作为由范数构造的两个超平面的产物来执行的(参见第二章)。

在线性支持向量机的情况下，我们将响应变量 Y 和解释变量 x 作为输入。我们将这些数据正交投影到特征空间，从而形成分离数据点的超平面。这些超平面的大小由权重的欧几里德范数或 w 确定，向量除了上界和下界之外，分别表示为:

w x+ b=1

w x+ b=-1

我们不断重复这个过程，直到我们达到一个范数 w，使两个类之间的分离最大化。通过最小化||w||，类的分离被最大化，因为超平面的大小由下面给出:

$\frac{2}{\left|\left| w\right|\right|}$

以下约束也阻止我们允许观察值落在两个超平面之间:

$w x+ b\ge 1,\kern0.5em \mathrm{if}\ \mathrm{y}=1$

$w x+ b\le -1,\kern0.5em \mathrm{if}\ \mathrm{y} = -1$

最终落在超平面边界上的观察是最重要的，因为它们是定义分类之间的分离的“支持向量”。这种转变如图 3-15 所示。

图 3-15。

Orthogonal transformation of data via kernel function

除了 SVM 的目标之外，由这些约束形成的优化问题由下面给出:

$\mathrm{Minimize}\ \left|\left|\mathrm{w}\right|\right|\mathrm{subject}\ \mathrm{t}\mathrm{o}\ {y}_i\left( wx+ b\right)\ge\ 1,\kern0.5em \mathrm{f}\mathrm{o}\mathrm{r}\ \mathrm{i}=1, \dots,\ \mathrm{n}$

内核的类型

为了扩展支持向量机的灵活性，已经开发了不同的内核。其中包括以下内容:

多项式
高斯径向基函数
双曲正切

次梯度法在支持向量机中的应用

函数的次梯度被定义为导数对不可微函数的推广。简单来说，就是经过函数导数，但落在导数以下的直线的斜率。当处理不仅仅具有 10⁵ 特征和 10⁵ 观测值的数据时，对 SVM 算法的现代修改已经产生了性能更好的分类模型。我们将优化问题定义为

$f\left( w, b\right)=\left[\frac{1}{n}{\displaystyle \sum_{i = 1}^n} \max \left(0,1-{y}_i\left( w x+ b\right)\right)\right]+\lambda {\left|\left| w\right|\right|}²$

其中 f 是 w 和 b 的凸函数。此外，这允许我们使用梯度下降方法，因为它们在凸集上特别有效。给定一个成本函数 C(w)，定义为实际分类减去预测分类，我们使用梯度下降公式因此如下:

$\underset{w\in {\mathrm{\mathbb{R}}}^d}{ \min}\mathcal{C}{\displaystyle \sum_{i=1}^n} \max \left(0,1-{y}_i f\left({x}_i\right)\right)+{\left|\left| w\right|\right|}²$

$\underset{w}{ \min}\mathcal{C}(w)=\frac{\lambda}{2}{\left|\left| w\right|\right|}²+\frac{1}{n}{\displaystyle \sum_{i=1}^n} \max \left(0,1-{y}_i f\left({x}_i\right)\right)$

次梯度步长选择方法类似于本章前面描述的 bold driver 方法。一如既往，算法应用的环境应该最终决定使用哪种方法，而不仅仅是哪种方法执行得更好。

支持向量机的扩展

Vladimir Vapnik，Harris Druck，Christopher Burges，Linda Kaugman 和 Alexander Smola 在 1996 年提出的回归方法是支持向量机的更流行的扩展。不同的是，在 SVR 中，我们不关心落在超平面内的观测值。相反，我们只修改超平面的形状来响应落在损失容差区域之外的点，目标是最小化落在该区域之外的这些点的数量。所执行的回归类型可以通过前面列出的相同内核函数再次改变。除此之外，K-均值聚类的一种替代方法是使用高斯核作为正交投影的激活函数。这里，该算法搜索生成超平面，使得包围数据图像的最小球体定义给定的聚类。聚类算法将在本章后面介绍。

与支持向量机相关的限制

支持向量机的主要问题来自于它们为什么如此强大的关键:内核函数。确定使用合适的内核通常被认为是这种技术的最大缺点。当深入研究算法训练的这个方面时，具体地说，损失参数和高斯核的宽度参数的选择并不明显，并且高度受制于使用算法的环境。第二，尽管支持向量机在大型数据集上表现良好，但它们是一种计算昂贵的方法，并且在应用于行业设置时需要足够好的硬件。因此，在研究之外的环境中，或者在任何需要分析实时数据的环境中，使用支持向量机并不总是有意义的。

以下是在 iris 数据集上使用的支持向量机的快速示例:

#Code Redacted, please check github!
require(LiblineaR)
require(e1071)

#SVM Classification
output  <- LiblineaR(data=s, target=y_train, type = 3, cost = heuristicC(s))

#Predicted Y Values
y_h <- predict(output, s, decisionValues = TRUE)$predictions

#Confusion Matrix
confusion_matrix <- table(y_h, y_train)
print(confusion_matrix)

当执行我们的代码时，它会产生如图 3-16 所示的混淆矩阵。

图 3-16。

Confusion matrix for support vector machine

机器学习方法:无监督学习

超越我们知道我们试图预测的答案的范式，是深度学习中更模糊的部分，我们试图根据我们的算法进行推理。这个特定的问题子集被称为无监督学习的一部分，或者我们事先不知道答案应该是什么的问题。

k 均值聚类

到目前为止，我们主要谈论了监督学习，但机器学习的另一个重要方面是在无监督学习情况下算法的使用。通常，无监督学习可以作为探索性的研究方法来进行，或者作为实验的主要部分之前的预备步骤来进行。无监督学习的最好例子之一是 K-means 聚类算法。该算法背后的动机是基于它们远离聚类中心的距离来寻找相似的观察值。

分配步骤

这里，我们取数据的观察值，通过计算数据中三个随机观察值的平均值，给出一组初始的 k 平均值。从这一点，我们将每个观察值分配给聚类中心，基于哪一个分配产生最小的聚类平方和，由观察值的平均值和聚类中心平均值

${S}_i^t=\left\{{x}_p:{\left|\left|{x}_p-{m}_i^t\right|\right|}²\le {\left|\left|{x}_p-{m}_j^t\right|\right|}²\ \forall j,\ 1\le j\le k\right\}$

之间的欧几里德范数确定

其中 S =聚类中心，x _p 是观察平均值。

更新步骤

然后，我们通过取中心内观察值的平均值来重新计算聚类平均值，然后重复这两步，直到重新分配停止:

${m}_i^{t+1}=\frac{1}{\left|{S}_i^t\right|}\underset{x_j\in {S}_i^t}{\varSigma}{x}_j$

K 均值聚类的局限性

K-means 聚类的主要问题是所得到的解通常依赖于均值的初始化位置，因此不能保证收敛到全局最小值。此外，根据所选 K 均值的变化，收敛所需的时间也可能不是特别快。

下面是 K 均值聚类的一个简单示例:

#Upload data
data  <- read.table("http://statweb.stanford.edu/∼tibs/ElemStatLearn/datasets/nci.data", sep ="", header = FALSE)
data <- t(data)
k_means  <- c()
k  <-  seq(2, 10, 1)
for (i in k){
  k_means[i]  <- kmeans(data, i, iter.max = 100, nstart = i)$tot.withinss
}

clus <- kmeans(data, 10)$cluster
summ  <- table(clus)
#Removing NA Values
k_means  <- k_means[!is.na(k_means)]
#Plotting Sum of Squares over K
plot(k, k_means,  main ="Sum of Squares Over K-Clusters", xlab = "K Clusters", ylab= "Sum of Squares",
     type = "b", col = "red")

通常，当执行 K-means 聚类时，最困难的部分是确定我们应该选择 K 的哪个值。通常，一个人拥有的聚类越多，其观察值和聚类中心之间的平方和就越低。然而，存在的聚类越多，这些聚类的信息量就越少。因此，挑战变成了 K 个聚类的平方和与尽可能少的聚类之间的权衡，以使观察值合理地可区分。图 3-17 显示了一个帮助我们努力的图。

图 3-17。

Within cluster sum of squares over K clusters

在图 3-17 的曲线图中，我们注意到我们的平方和在开始时急剧下降，但是我们看到值在接近结束时逐渐变小。因此，我们选择一个介于 6 和 8 之间的值是合理的，如果不是，最好接近 6。这遵循上一段中列出的目标，并将为我们提供可操作的见解，或者为包含分类或回归算法要检测的显著差异的数据视图创建一个特征。

期望最大化算法

EM 算法在无监督学习的范例中很流行，可以用于多种目的，例如分类或回归。对用户来说，最具体的用途是，它可以用来估算数据集中缺失的值。我们将在第十一章中展示这种能力。无论如何，EM 算法是一个概率模型，这使它区别于许多机器学习模型，后者往往是确定性的。该算法使用对数似然函数来估计参数，然后最大化找到的期望对数似然。

期望步骤

考虑一组未知值 Z，它是数据集 x 的子集。我们根据给定 x 的 Z 的条件分布来计算参数的对数似然。下面的等式得出参数的最大似然估计的期望值:

$L\left(\theta; X\right) = p\left( X\Big|\theta \right)={\varSigma}_z p\left( X,\ Z\Big|\theta \right)$

$Q\left(\theta \Big|{\theta}^t\right)={E}_{\left( Z\Big| X,{\theta}^t\right)}\left[ \log L\left(\theta; X,\ Z\right)\right]$

最大化步骤

在这一步，我们寻求最大化我们正在分析的给定参数的概率。这个方程由下面给出:

${\theta}^{t+1} = \underset{\theta}{ \arg\ \max } Q\left(\theta \Big|{\theta}^t\right)$

期望值最大化算法的局限性

EM 算法也趋向于非常缓慢地收敛，并且不产生 MLE 的渐近方差-协方差矩阵。除此之外——类似于朴素贝叶斯分类器的相同限制，因为 MLE 估计器假设特征独立——如果被分析的特征实际上不独立，则不建议使用这种方法。以下是用于通过聚类进行分类的 EM 算法的示例:

#Expectation-Maximization Algorithm for Clustering
require(MASS)
require(mclust)
y_h <- Mclust(x_train, G = 3)$classification
print(table(y_h, y_train))
plot(Mclust(x_train, G = 3), what = c("classification"), dimens=c(1,3))

当执行我们的代码时，它会产生如图 3-18 所示的图。

图 3-18。

Iris data clusters from EM algorithm clustering

决策树学习

决策树通常用于各种领域的数据挖掘，提供了一种相对简单的方法来揭示隐藏在数据表面下的洞察力。广义上有两种类型的决策树，它们通常用于回归和分类。决策树是通过创建确定决策流向的规则来构建的。想法是你使用一个漏斗方法，其中第一个规则是最广泛的，你把问题分解成子集，直到最后的“叶子”是确定的最细粒度的方面。

通常与决策树相关的好处是，总的来说，它们相对容易理解，并且通常非常有效。此外，决策树可以比一些机器算法更好地处理缺失数据，而无需替换或更改数据(我们可以只对值或分类进行平均)，并且相对于其他建模技术，它们可以快速计算最终值。最重要的是，有各种各样的方法可以用来帮助树有效地学习，当传统的回归方法不能时，它们可以很好地模拟数据。

分类树

分类树类似于回归树。分割通常由二进制变量决定，但它们可以是数字的，也可以是分类的。除此之外，分类树可以进行两种类型的预测:1)点预测，简单地表示类别，以及 2)分布预测，给出每个类别的概率。对于概率预测，树中的每个终端节点产生类别分布。如果叶子对应于答案的序列，由 A = a，B = b，… Q = q 给出，那么下面的等式产生概率:

$\Pr \left( Y= y\Big| A= a,\ B= b, \dots,\ Q= q\right)$

为了评估分类树，使用前面描述的评估不同分类模型的相同方法。但是我们也引入了平均损失的概念。简单地说，一些错误可能会对准确达到正确的分类造成更大的“损害”。平均损失公式如下:

$\mathrm{Loss}\left(\mathrm{Y}=\mathrm{j}\Big|\mathrm{X}=\mathrm{x}\right)={\varSigma}_i{L}_{i j} \Pr \left( Y= i\Big| X= x\right)$

除此之外，我们可以使用归一化负对数似然来确定模型在不确定或不确定的情况下是否做出了错误的分类。它的公式由

$L\left( data,\ Q\right) = -\frac{1}{n}{\varSigma}_i^n logQ\left( Y={y}_i\Big| X={x}_i\right)$

给出

其中 Q(Y = y|X = x)是模型预测的条件概率。在这种情况下，L 也被称为交叉熵。如果完美的分类是可能的，我会是 0。如果分类中存在某种不可约的不确定性，则最佳可能分类器将给出 L = H[Y|X]，即给定 X 时 Y 的条件熵。下面是一个分类树的示例:

require(rpart)
#Classification Tree
classification_tree <- rpart(y_train ∼ x_train[,1] + x_train[,2] + x_train[,3] + x_train[,4]
                             +x_train[,5] + x_train[,6], method = "class")
pruned_tree <- prune(classification_tree, cp = .01)

#Data Plot
plot(pruned_tree, uniform = TRUE, branch  = .7, margin = .1, cex = .08)
text(pruned_tree, all = TRUE, use.n = TRUE)

当执行我们的代码时，我们产生了如图 3-19 所示的图。

图 3-19。

Classification tree splits based on Classification tree model fitted above

伴随该模型的混淆矩阵如图 3-20 所示。

图 3-20。

Confusion matrix for classification tree

回归树

该模型的主要目标是最大化作为被分析变量的产物落在给定叶子上的概率。我们寻求最大化我们得到的关于响应变量的信息。这是仿照

$I\left[ C: Y\right]$

其中 I 是信息，C 是决定我们走向的叶子的变量，Y 是响应变量

$I\left[ Y; A\right]={\varSigma}_a \Pr \left( A= a\right) I\left[ Y; A= a\right]$

$I\left[ Y; A= a\right] = H\left[ Y\right] - H\left[ Y\Big| A= a\right]$ 哪里，

其中

$H(X)= E\left[ I(X)\right]= E\left[- \ln \left( P(X)\right)\right]$

不管我们看的是连续变量还是离散变量，我们计算平方和的方式都是一样的

$S\kern0.5em = \underset{x\in leaves(T)}{\Sigma}\underset{i\in c}{\Sigma}{\left({y}_i-{m}_c\right)}²$

其中 ${m}_c=\frac{1}{n_c}\varSigma {y}_i,\ i\in c,$ 为叶 c 的预测。

使用回归树进行预测的不确定性，类似于在分类树中看到的不确定性，是使用这些模型时值得考虑的问题。首先，这些不确定性是对条件概率的不精确估计。该树也随着响应值的变化而主动变化。如果我们从同一个分布中抽取不同的样本，我们会很理想地想要一个树会有多不同的度量。这可以使用非参数自举来估计。假设数据(x ₁ ，y ₁ )，(x ₂ ，y ₂ )，…，(x _n ，y _n )，我们从数字 1:n 中独立均匀地抽取一组随机整数 J ₁ ，J ₂ ，…，J _n ，并进行替换。然后我们设定

$\left({X}_i^{\hbox{'}},\ {Y}_i^{\hbox{'}}\right)=\left({x}_{J_i},\ {y}_{J_i}\right)$

在这里，我们像对待原始数据一样对待这个自举样本，并为其拟合一棵树。经过多次迭代，我们得到了树的 bootstrap 抽样分布。这接近回归树的实际抽样分布。我们的自举树的预测在原始树周围的分布表明了这种分布。

决策树的局限性

通常，构建决策树最困难的部分是选择创建最佳决策树的规则，并选择不太复杂的树大小，这将导致训练集中的过度拟合，或者根本不会产生任何可操作的见解。更糟糕的是，仅仅从训练错误中很难判断出过度拟合的确切时间。为了减轻这些问题，通常鼓励决策树具有足够的训练样本大小。理想情况下，模型与数据吻合得相当好，用于确定方向分裂的规则不应过于复杂。停止标准最终决定了我们何时到达一片叶子。经常使用的规则的例子是当产生的信息减少到低于某个用户确定的阈值时，或者当“父”节点的“子”产生足够小的一组数据点时停止。然而，从这一点向前发展，决策树是相对简单的模型，对于回归问题，它并不总是在复杂数据上表现得很好，对于每个类别有多个级别的分类数据，它也表现得不好。

集成方法和其他启发式方法

对于标准机器学习算法失败的情况，可以通过实际上是多种算法组合的算法来实现精确度的显著提高。我们称之为系综方法。

梯度推进

梯度推进最初由 Leo Breiman 开发，是一种用于回归和分类问题的技术，目的是从较弱的模型中产生较好的模型。它迭代建立模型，优化问题是最小化这个函数的梯度。让我们以模型 F 为例，我们期望它预测值 y _h ，目标是最小化平方误差。设 M 是我们想要进行的提升迭代的次数，其中 1 ≤ m ≤ M。我们假设在我们的实验开始时，我们将有一个模型 F _m ，我们试图改进它。因此:

$F{(x)}_{m+1} = F{(x)}_m+ h(x) = y$

$h(x) = y- F{(x)}_m$

梯度提升旨在使 ${F}_{m+1}$ 比之前的模型更加正确。已经提出的其他损失函数是由

$h(x)=\frac{1}{2 n}\varSigma {\left({h}_{\theta_x}^i - {y}^i\right)}²$

给出的平方误差损失函数

其中

$\nabla h(x)=\frac{1}{n}\varSigma \left({h}_{\theta_x}^i- y\right)$

其中 n =数据集 x 内的观察次数。

梯度推进算法

Define the optimization problem as

![ ${F}^{*}= \arg \underset{F}{ \min }{E}_{x, y}\Big L\left( y,\ F(x)\right)$

where L(y, F(x)) is some differentiation loss function, such as the gradient of the squared loss as shown earlier.
Calculate the residuals as given by the following equation for m = 1, …, M:

${r}_{i m} = -{\left[\frac{\partial L\left({y}_i,\ F\left({x}_i\right)\right)}{\partial F\left({x}_i\right)}\right]}_{F(x)= F{(x)}_{m-1}}$
使用具有训练集的初始模型来迭代地提高性能。
Calculate γ _m via the following equation:

${\gamma}_m \arg \underset{\gamma}{ \min }{\varSigma}_i^n L\left({y}_i,\ F{\left({x}_i\right)}_{m-1}+\gamma {h}_m\left({x}_i\right)\right)$
重复 2–4 直到收敛。

随机森林

我将在这一章中讲述的最后一个系综方法是随机森林。简而言之，随机森林是几个决策树的组合，使得每个决策树在给定分支评估的特征方面可以被认为是与其他决策树不同的。尽管这些树的长度是同质的，但是每棵树的决策都是相互独立的。我们为给定观测值选择的值通常是回归情况下所有树的平均值，或者是分类中所有树的平均(或最普遍)观测值。

随机森林的限制

随机森林的主要局限性在于，与组成它们的树木相似，它们有过度适应的倾向。我推荐在决策树上使用的相同技术，例如修剪和抢先限制增长，应该在这里使用，以限制树过度拟合的可能性。

贝叶斯学习

贝叶斯学习建立在贝叶斯定理的基础上，并最终在许多机器学习和自然语言处理模型中使用，它通过有向图使用随机变量及其条件依赖的表示。贝叶斯学习用于这样的情况，例如在给定单词所处的上下文的情况下确定该单词的情感，以及基于通常在测试集中规定的性别找到名字是女性还是男性的概率。

朴素贝叶斯分类器

贝叶斯定理的一个简单应用是分类。朴素贝叶斯分类器使用条件概率来确定事件的可能性。假设我们有一个向量 $z=\left[{z}_1,\ {z}_1,\dots,\ {z}_3\right]$ ，我们想要确定事件 a 的概率。我们将这个方程建模为

$P\left( A\Big| z\right)=\frac{P\left( z\Big| A\right) P(A)}{P(z)}$

其中 P(A|Z)定义为后验概率，P(z|A)是先验概率，P(A)是似然性，P(z)是实例发生的概率(这个几乎总是可以忽略)。现在我们想用这个公式来正确地对观察结果进行分类。对此，我们把这变成一个优化问题，由下面的等式给出:

$\widehat{y}= \arg \underset{k\in \left\{1, \dots,\ K\right\}}{ \max } P\left({A}_k\right){\displaystyle \prod } P\left({z}_i\Big|{A}_k\right)$

我们根据使某个事件 a 的概率最大化的值为 y 赋值。虽然这不是使用朴素贝叶斯分类器的唯一方法，但它是将贝叶斯定理应用于分类的一种更常见方法的示例。

贝叶斯分类器的局限性

贝叶斯分类器最大的局限性在于它假设了特征的独立性，这在我们分析数据的许多环境中并不总是如此。一旦确定特征独立性不存在，我们根本不能使用这个分类器:

#Bayesian Classifier
require(e1071)

#Fitting Model
bayes_classifier <- naiveBayes(y = y_train, x = x_train , data = x_train)
y_h <- predict(bayes_classifier, x_train, type = c("class"))

#Evaluating Model
confusion_matrix <- table(y_h, y_train)
print(confusion_matrix)

执行前面的代码时，会产生如图 3-21 所示的混淆矩阵。

图 3-21。

Confusion matrix for Bayesian classifier example

关于调整机器学习算法的最后评论

实践机器学习算法的更困难的部分之一是参数调整的概念，我还没有解决这个问题。可以调整的参数数量取决于所采用的算法，但尽管如此，这仍然是整个学科都面临的挑战。我们已经讨论了为什么确保不发生过度拟合非常重要，这样我们才能获得尽可能稳健的解决方案。一般来说，稳健性通过从一个数据集到下一个数据集的预测能力的稳定性来反映，而过度拟合通过从一个数据集到下一个数据集的预测能力的明显下降来反映。现在，我将在接下来的小节中讨论如何通过方法实现这种健壮性。

50/25/25 交叉验证

用户应该使用一个验证集来进行参数调整，验证集应该是总数据集大小的 50%。然后，用户应该创建两个训练集:一个将用于训练他们调整的算法，另一个用于测试鲁棒性程度/检查过度拟合。可以检查其他百分比分割，以了解性能差异。

一次调整一个参数

如果读者使用的是软件包，而不是算法的自定义实现，可能会有一些参数被设置为默认值。试图一次改变一个以上的参数是困难的，这不仅是为了及时产生算法的结果，而且是因为很难将特定参数的贡献与输出中的变化程度分开。例如，随机森林从单棵树的巨大以及给定模型中允许的树的数量中获得大量的能量。同时增加这两个因素会扭曲我们可以从整体上适当调整算法的能力，最终会导致欠拟合或过拟合。

使用搜索算法调整机器学习参数

希望采用更高级方法的读者被建议密切关注第八章，其中我们深入讨论了可用于选择机器学习算法的搜索算法。尽管仍是一个发展中的研究领域，但通过降低回归算法的误差统计或增加分类算法产生的 AUC 分数，使用 GridSearch 和其他局部搜索算法来选择更好的算法已经取得了显著的成功。

强化学习

强化学习与监督学习的不同之处在于，在监督学习问题中，我们所针对的标签是永远不会给出的。相反，我们关注于在利用模型中的现有知识和我们希望模型从未知环境中找到的知识之间找到适当的平衡。强化学习领域不可或缺的是概率论的这个副主题。在这些类型的问题中，我们假设在一组吃角子老虎机附近有一个游戏者，他必须决定玩哪些机器，每台机器玩多少次，以及以什么顺序玩机器。当玩时，每台机器从特定于给定机器的概率分布中提供随机奖励。目标是最大化游戏者在这个游戏周期中获得的钱数。向前看，我们通常可以把强化学习问题描述为一个需要对环境进行智能探索的问题，参考多臂赌徒方法中描述的相同目标。

区分强化学习与监督和非监督方法的事实是，我们采取的行动会显著影响我们获得的后续信息，因此强调在给定算法的每次迭代中做出最佳决策。基本算法描述如下:

代理人
1. 执行给定的操作
2. 观察某种结果
3. 获得奖励，通常以标量的形式建模
环境
1. 接收代理执行的操作
2. 输出一个观察和一个标量奖励

我们将历史定义为相对于代理人和给定环境发生的观察、奖励和行动的序列，记为 ${H}_t={O}_1,\ {R}_1,\ {A}_1, \dots,\ {O}_{t-1},{R}_{t-1},\ {A}_{t-1}$ 。所有随后的观察、奖励和行动都受到历史的影响，因为它存在于给定的实验中。这就是我们定义的状态，表示为 ${S}_t=\kern0.5em f\left({H}_t\right)$ 。环境的状态对代理来说是不可见的，所以它不允许代理可能选择的动作有偏差。相反，代理的状态是内部的。信息也有一个状态，它被描述为马尔可夫过程。需要注意的是，由于这是一本深度学习的入门书籍，所以强化学习的应用不会像更高级的书籍那样深入。也就是说，我希望通过阅读这本书，那些目前发现强化学习问题难以解决的人将能够在对本文过程中提出的概念有了坚实的理解后解决这些问题。

摘要

我们现在已经结束了对优化和机器学习的必要组成部分的回顾。这一章，以及前一章，应该作为理解一些更复杂的算法的参考点，我们将在后面的章节中讨论。现在，我们将继续讨论深度学习范式中最简单的模型:单层感知器。

四、单层和多层感知器模型

有了足够的背景知识，是时候开始讨论神经网络了。我们将从两个最常见和最简单的神经网络开始，它们的用例围绕着分类和回归。

单层感知器(SLP)模型

最简单的神经网络模型 SLP 是由研究人员麦卡洛克和皮茨设计的。在许多机器学习科学家的眼中，SLP 被视为人工智能的开端，并为开发其他神经网络模型和机器学习模型提供了灵感。SLP 的架构是这样的，单个神经元由许多突触连接，每个突触都包含一个权重(如图 4-1 所示)。

图 4-1。

Visualization of single perceptron model

权重影响神经元的输出，这在示例模型中将是分类问题。然后，乘以输入的权重的合计值在神经元内被求和，然后被馈入激活函数，标准函数是逻辑函数:

设输入向量 $x={\left[{x}_1,{x}_2,\dots,\ {x}_n\right]}^T$ 和权重向量 $w=\left[{w}_1,\ {w}_2,\dots,\ {w}_n\right]$ 。

函数的输出由

$y= f\left( x,{w}^T\right)$

给出

当使用逻辑函数时，激活函数如下:

$f(x)=\frac{1}{1+{e}^{- x}}$

训练感知器模型

我们通过用从正态分布中随机采样的值初始化所有权重来开始训练过程。我们可以使用梯度下降方法来训练模型，目标是最小化误差函数。我们将感知器模型描述为

$\widehat{y}= f\left( x,{w}^T\right)=\sigma \left({\displaystyle \sum_i^n}{x}_i{w}_i\right)$

其中

$\sigma =\frac{1}{1+{e}^{- x}},$

$\widehat{y}=\left\{\begin{array}{c}\hfill 1\kern1.5em if\ y\ge {\pi}^{*},\kern0.5em \hfill \\ {}\hfill 0\kern0.75em elsewhere\kern0.5em \hfill \end{array}\right.$

其中π* =对数概率的阈值，如第三章中逻辑回归所述。

WH 算法

该算法由 Bernard Widrow 和 Macron Hoff 在 20 世纪 50 年代末开发，用于训练 SLP 模型。虽然类似于用于训练神经网络的梯度方法(如前所述)，但 WH 算法使用所谓的瞬时算法，由

${w}_i\left( k+1\right)={w}_i(k)-\eta \left(\frac{\partial E}{\partial {w}_i}\right)1$

$\frac{\partial E}{\partial {w}_i}=\frac{1}{2}{\displaystyle \sum_{m=1}^M}1\left({h}_{\theta_x}- y(k)\right)\left(-\frac{\partial y(k)}{\partial {w}_i}\right)$

$= {\displaystyle \sum_{m=1}^M}\left({h}_{\theta_x}- y(k)\right)\left(-{x}_i(k)\right)$

$= {\displaystyle \sum_{m=1}^M}\delta (k){x}_i(k)$

给出

其中

$\delta (k) = \left({h}_{\theta_x}- y(k)\right)$

因此，我们可以将前面的方程式总结如下:

${w}_i\left( k+1\right) = {w}_i(k)+\eta \delta (x){x}_i(k)$

以这种方式，我们有同样的优化问题，我们会在任何传统的梯度方法。我们的目标是通过梯度下降调整应用于数据输入的权重来最小化模型的误差。考虑到分类问题，让我们使用逻辑回归作为我们的基线指标，同时使用 WH 算法将其与固定速率感知器指标和 bold 驾驶员自适应梯度进行比较。

单一感知器模型的局限性

导致后来神经网络模型发展的 SLP 模型的主要限制是，感知器模型只有在处理明显线性可分的数据时才是准确的。这显然在数据更加密集和复杂的情况下变得困难，并且有效地消除了这种技术在实际环境中遇到的分类问题中的有用性。这方面的一个例子是异或问题。假设我们有两个输入，x ₁ 和 x ₂ ，对于这两个输入，给定了响应 y，使得以下为真:

| | x ₁ | x2y | | --- | --- | --- | | Zero | Zero | Zero | | one | Zero | one | | Zero | one | one | | one | one | Zero |

从下面的例子中，我们可以看到，当任一解释变量等于 1 时，响应变量等于 1，但当两个解释变量彼此相等时，响应变量等于 0。这种情况如图 4-2 所示。

图 4-2。

XOR problem

现在，让我们来看一个使用 SLP 的例子，其中的数据不是严格线性可分的，以了解该模型的表现。对于这个例子，我已经创建了一个简单的单层感知器模型的示例函数。对于误差函数，我使用 1 减去 AUC 分数，因为这将给我们一个数字量，这样我们可以通过使用梯度下降的反向传播来训练权重矩阵。读者可以随意使用下一个函数以及更改参数。

我们首先设置一些与通过梯度下降执行的线性回归算法相同的参数。(如果您需要复习梯度下降的细节以及如何将其应用于参数更新，请复习第三章。)这里唯一的区别是，我们使用的误差函数不同于回归中使用的均方误差:

singleLayerPerceptron <- function(x = x_train, y = y_train, max_iter = 1000, tol = .001){
#Initializing weights and other parameters
  weights <- matrix(rnorm(ncol(x_train)))
  x <- as.matrix(x_train)
  cost <- 0
  iter <- 1
  converged <- FALSE

这里，我们为单层感知器定义一个函数，通过第三章中定义的梯度下降算法，设置类似于线性回归的参数。像往常一样，我们在每次迭代时交叉验证(这部分代码被编辑，请查看 GitHub)我们的数据，以防止权重过度拟合。在下面的代码中，我们为上一节中描述的 SLP 定义了算法:

  while(converged == FALSE){
        #Our Log Odds Threshold here is the Average Log Odds
      weighted_sum <- 1/(1 + exp(-(x%*%weights)))
      y_h <- ifelse(weighted_sum <= mean(weighted_sum), 1, 0)
      error <- 1 - roc(as.factor(y_h), y_train)$auc
}

最后，我们使用梯度下降训练我们的算法，误差定义为 1–AUC。在下面的代码中，我们定义了重复的过程，直到我们收敛到最优解或允许的最大迭代次数:

#Weight Updates using Gradient Descent
#Error Statistic := 1 - AUC
if (abs(cost - error) > tol | iter < max_iter){
        cost <- error
        iter <-  iter + 1
        gradient <- matrix(ncol = ncol(weights), nrow = nrow(weights))
        for(i in 1:nrow(gradient)){
          gradient[i,1] <- (1/length(y_h))*(0.01*error)*(weights[i,1])
        }
(Next section redacted, please check github!)

和往常一样，读者评估他们的实验结果是有用的。图 4-3 显示了除最后一次 AUC 评分之外的 AUC 评分汇总统计数据，并绘制了各自的 ROC 曲线:

图 4-3。

ROC curve

  #Performance Statistics
  cat("The AUC of the Trained Model is ", roc(as.factor(y_h), y_train)$auc)
  cat("\nTotal number of iterations: ", iter)
  curve <- roc(as.factor(y_h), y_train)
  plot(curve, main = "ROC Curve for Single Layer Perceptron")
}

汇总统计数据

       Mean    Std.Dev       Min       Max     Range
1 0.4994949 0.03061466 0.3973214 0.6205357 0.2232143

请注意，AUC 分数相当差，平均评级比猜测好不了多少。有时，这里的算法会达到稍微好一点的结果，但是这对于部署来说仍然是不够的。这可能是由于类的线性可分性不是很明显，导致了错误分类，每次迭代时都会更新权重矩阵。

现在我们已经看到了 SLP 的局限性，让我们继续这个模型的继任者，多层感知器，或 MLP。

多层感知器(MLP)模型

MLP 与 SLP 的区别在于存在影响模型输出的隐藏层。这个显著的因素也恰好是它们的优势，因为它允许它们更好地处理 XOR 问题。这个模型中的每一个神经元都接收来自一个神经元的输入，或者在输入神经元的情况下接收来自环境的输入。每个神经元由一个突触连接，突触上附着一个类似 SLP 的重物。在引入一个隐藏层后，我们可以让模型表示一个布尔函数，而引入两个层则允许网络表示一个任意的决策空间。

一旦我们超越了 SLP 模型，一个更困难且不太明显的问题就变成了 MLP 的实际架构应该是什么，以及这如何影响模型性能。本节讨论了读者应该记住的一些问题。

收敛于全局最优

根据模型的设计，MLP 模型不是线性的，因此寻找最优解远不像 OLS 回归那么简单。在 MLP 模型中，用于训练的标准算法是反向传播算法，这是早先描述的 Widrow-Hoff 算法的扩展。它最初是由鲁梅尔哈特和麦克莱兰在 20 世纪 80 年代提出的，被认为是训练 MLP 网络的第一个实用方法。这是使用梯度下降训练 MLP 模型的原始方法之一。设 E 为多层网络的误差函数，其中

$E(k)=\frac{1}{2}{\displaystyle \sum_{i=1}^M}{\left( h{(k)}_{\theta_i}-{y}_i(k)\right)}²$

我们用下面的公式表示输入到隐藏层的单个神经元的加权和值:

$s{(k)}_{h, j} = {\displaystyle \sum_{i=1}^M}{w}_{h, j, i}{x}_i(k)$

同样，我们把从隐藏层到输出层的输出表示如下:

$s{(k)}_{o, j} = {\displaystyle \sum_{i=1}^H}{w}_{o, j, i}{o}_{h, i}(k)$

用下面的权重表示:

${w}_{ij}\left( k+1\right)={w}_{ij}(k)-\eta \frac{\partial E(k)}{\partial {w}_{ij}}$

MLP 模型的反向传播算法；

通过从正态分布中取样来初始化所有权重。
输入数据，然后通过隐藏层将数据传递到输出层。
计算梯度并相应地更新权重。
重复步骤 2 和 3，直到算法收敛于可容忍的丢失阈值或达到最大迭代次数。

在概念上回顾了这个模型之后，让我们看一个玩具例子。对多层感知器在实际问题中的应用感兴趣的读者应该特别注意第十章。在下面的代码段中，我们生成新的数据并显示在下面的图中(如图 4-4 ):

图 4-4。

Plotting generated data sequence

#Generating New Data
x <- as.matrix(seq(-10, 10, length = 100))
y <- logistic(x) + rnorm(100, sd = 0.2)

#Plotting Data
plot(x, y)
lines(x, logistic(x), lwd = 10, col = "gray")

本质上，我们有一个逻辑函数，数据围绕它分布，因此围绕这个逻辑函数存在方差。然后，我们定义包含 MLP 模型权重的变量。我使用的是打包的 monmlp，但用户也可以自由地尝试其他包中的实现，如 RSNSS 和 h2o。第十章在从框架访问深度学习模型的背景下简要介绍了 h2o:

#Loading Required Packages
require(ggplot2)
require(lattice)
require(nnet)
require(pROC)
require(ROCR)
require(monmlp)

#Fitting Model
mlpModel <- monmlp.fit(x = x, y = y, hidden1 = 3, monotone = 1,
                    n.ensemble = 15, bag = TRUE)
mlpModel <- monmlp.predict(x = x, weights = mlpModel)

#Plotting predicted value over actual values
for(i in 1:15){
  lines(x, attr(mlpModel, "ensemble")[[i]], col = "red")
}

当绘制 MLP 模型的预测图时，我们看到的结果如图 4-5 所示。

图 4-5。

Predicted lines laying over function representing data

如您所见，在某些情况下，模型会捕捉到一些噪声，这可以从与逻辑函数形状的任何偏差中得到证明。但是所有生成的行总体上都是数据模式下逻辑函数的良好概括。这是 MLP 模型处理非线性函数能力的一个简单展示。虽然是一个玩具例子，但这个概念在实际例子中也是成立的。

MLP 模型的局限性和注意事项

当使用误差是权重的函数的反向传播算法时，收敛到全局最优可能难以实现，这通常是一个问题。如前所述，当我们试图优化非线性函数时，许多局部最小值掩盖了全局最小值。因此，我们可能会被欺骗，认为我们已经找到了一个可以有效解决问题的模型，而实际上我们选择了一个不能有效地达到全局最小值的解决方案(见图 4-6 )。

图 4-6。

Error over weight plot

为了减轻这种情况，应用共轭梯度算法。共轭梯度算法不同于传统的梯度下降法，它的学习速率是在每次迭代时调整的。已经发展了许多类型的共轭梯度法，但是它们都有相同的动机。在 MLP 网络的背景下，我们试图找到最小化误差函数的权重。为了做到这一点，我们朝着最陡下降的方向移动，但是我们以这样的方式改变步长，使得在搜索全局最优时最小化任何可能的“失误”。让我们举一个简单的例子，在这里我们试图解决

Ax= b

其中 x 是未知向量，或 MLP 网络中的权重向量，A 是解释变量的矩阵，b 是响应变量。现在看二次函数

$f(x)=\frac{1}{2}{x}^T Ax-{b}^T+ c$

其中 c 是常数标量。当考虑一个例子，其中 A 是正定的，最小化 f(x)的最优解是计算梯度时的 Ax= b 的解，我们发现 ${f}^{\prime }(x)= Ax- b,$ 意味着最陡下降的方向将等于 b- Ax 因此，我们想用下面的等式调整权重向量 x:

${x}_k={x}_{k-1}-\eta \left( b- Ax\right)$

该方法的操作部分是学习速率η的变换。根据定义，当函数相对于学习率的方向导数等于零时，η最小化该函数。根据链式法则:

$\frac{d f(x)}{d\eta}={f}^{\prime }{(x)}^T\left(- AE\right),\kern0.5em E= y-\widehat{y}$

最后，我们确定学习率如下:

要用多少隐藏层，里面有多少神经元

我们通常只在数据不可线性分离的情况下选择使用隐藏层。每当使用阶跃函数、重侧函数或阈值激活函数时，通常建议使用两个隐藏层。至于使用一个以上的隐藏层，这在很大程度上是不必要的，因为在大多数情况下，使用两个或两个以上的隐藏层所带来的性能提升可以忽略不计。在可能不是这种情况的情况下，通过观察隐藏层数的 RMSE 或另一个统计指标的实验应该被用作决定的方法。通常，当向神经网络模型添加一个层时，这将是简单的编辑函数中的参数，或者在 mxnet(在后面的章节中介绍)等一些深度学习框架的情况下，通过一个全新的函数传递前一层的值。关于在给定的隐藏层中应该有多少神经元，这必须以最小化训练误差为目标进行测试。有人建议它必须在输入和输出层大小之间，永远不要超过输入数量的两倍，捕捉初始数据集的. 70-.90 方差-或者使用下面的公式: $\#\ Hidden\ Units=\left(\#\ inputs+\#\ outputs\right)*\ \frac{2}{3}$ 。

简而言之，让我们用下面的代码来看看共轭梯度训练方法和使用 R 中的 RNSS 包的传统梯度下降之间的区别:

#Conjugate Gradient Trained NN
conGradMLP <- mlp(x = x, y = y,
size = (2/3)*nrow(x)*2,
                  maxit = 200,
                  learnFunc = "SCG")
#Predicted Values
y_h <- predict(conGradMLP, x)

我们首先使用mlp()函数定义神经网络，其中我们特别将learnFunc参数表示为 SCG(比例共轭梯度)。我们还使用前面提到的 2/3 规则来选择size参数(神经网络中神经元的数量)。

现在，让我们比较之前显示的 MLP 模型和我们刚刚构建的这个模型的 MSE:

共轭梯度下降训练模型的 MSE:0.03533956
梯度下降训练模型的 MSE:0.03356279

虽然在这种情况下只有微小的差别，但我们可以看到，在这种情况下，共轭梯度法产生的 MSE 值比传统的梯度下降法稍差。因此，考虑到保持一致性的趋势，选择梯度下降训练方法将是明智的。

摘要

这一章是对神经网络世界的介绍。接下来，我们将讨论为任务开发的模型，这些任务通常超出了 SLP 和 MLP 模型的适用范围。具体来说，在第五章中，我们将研究用于图像识别的卷积神经网络以及用于时间序列预测的循环神经网络。建议对本章讨论的概念还不太熟悉的读者在继续阅读第五章之前，再次回顾第 2 到第四章，因为第五章中提到的许多概念在这些章节中都有详细介绍。