Machine-Learning-Mastery-线性代数教程-二-

Machine Learning Mastery 线性代数教程（二）

原文：Machine Learning Mastery

协议：CC BY-NC-SA 4.0

线性代数的温和介绍

原文： machinelearningmastery.com/gentle-introduction-linear-algebra/

什么是线性代数？

线性代数是一个数学领域，普遍认为它是更深入理解机器学习的先决条件。

虽然线性代数是一个具有许多深奥理论和发现的大型领域，但从该领域获得的螺母和螺栓工具和符号对于机器学习从业者来说是实用的。凭借线性代数的坚实基础，可以专注于良好或相关的部分。

在本教程中，您将从机器学习的角度发现究竟线性代数是什么。

完成本教程后，您将了解：

• 线性代数是数据的数学。
• 线性代数对统计学领域产生了显着影响。
• 线性代数是许多实用数学工具的基础，例如傅里叶级数和计算机图形学。

让我们开始吧。

线性代数的温和介绍 Steve Corey 的照片，保留一些权利。

教程概述

本教程分为 4 个部分;他们是：

1. 线性代数
2. 数值线性代数
3. 线性代数与统计
4. 线性代数的应用

线性代数

线性代数是数学的一个分支，但事实是线性代数是数学的数学。矩阵和向量是数据的语言。

线性代数是线性组合。也就是说，对称为向量的数字列和称为矩阵的数字数组使用算术，以创建新的列和数字数组。线性代数是线性变换所需的线和平面，向量空间和映射的研究。

这是一个相对年轻的研究领域，最初在 19 世纪正式化，以便在线性方程组中找到未知数。线性方程只是一系列术语和数学运算，其中一些术语是未知的;例如：

y = 4 * x + 1

像这样的方程是线性的，因为它们描述了二维图上的线。该线来自于将不同的值插入到未知 x 中，以找出等式或模型对 y 值的影响。

我们可以将具有两个或更多未知数的相同形式的方程组排列在一起;例如：

y = 0.1 * x1 + 0.4 * x2
y = 0.3 * x1 + 0.9 * x2
y = 0.2 * x1 + 0.3 * x2
...

y 值列可以作为等式的输出的列向量。两列浮点值是数据列，比如 a1 和 a2，可以作为矩阵 A.两个未知值 x1 和 x2 可以作为等式的系数，一起形成未知数的向量 b 待解决。我们可以使用线性代数表示法紧凑地编写这个：

y = A . b

这种形式的问题通常难以解决，因为有更多的未知数（这里我们有 2 个）比要求解的方程（这里我们有 3 个）。此外，通常没有单行可以无错误地满足所有方程。描述我们经常感兴趣的问题的系统（例如线性回归）可以具有无限数量的解决方案。

这给了我们作为机器学习从业者感兴趣的线性代数的核心品味。其余大部分操作都是关于解决这个问题以及更容易理解和解决的问题。

数值线性代数

线性代数在计算机中的应用通常被称为数值线性代数。

“数值”线性代数实际应用于线性代数。

• Page ix，数值线性代数，1997。

它不仅仅是代码库中线性代数运算的实现;它还包括仔细处理应用数学问题，例如使用数字计算机的有限浮点精度。

计算机擅长执行线性代数计算，而现代机器学习方法（如深度学习）对图形处理单元（GPU）的依赖很大程度上是因为它们能够快速计算线性代数运算。

向量和矩阵运算的有效实现最初是在 20 世纪 70 年代和 80 年代的 FORTRAN 编程语言中实现的，许多代码或从这些实现移植的代码是使用现代编程语言（如 Python）执行的大部分线性代数的基础。

实现这些功能的三个流行的开源数值线性代数库是：

• 线性代数包，或 LAPACK。
• 基本线性代数子程序，或 BLAS（线性代数库的标准）。
• 自动调谐线性代数软件，或 ATLAS。

通常，当您通过高阶算法直接或间接计算线性代数运算时，您的代码很可能会使用其中一个或类似的线性代数库。如果您已安装或编译任何 Python 的数字库（如 SciPy 和 NumPy），则您可能很熟悉这些底层库中的一个的名称。

线性代数与统计

线性代数是其他数学分支中的一个有价值的工具，尤其是统计学。

通常，学习统计学的学生预计至少会在本科阶段看到一个学期的线性代数（或应用代数）。

• 第 xv 页，线性代数和统计矩阵分析，2014 年。

考虑到两个领域与应用机器学习领域的基础关系，线性代数的影响是重要的考虑因素。

线性代数在统计和统计方法上的一些清晰指纹包括：

• 使用向量和矩阵表示法，尤其是多变量统计。
• 最小二乘和加权最小二乘的解，例如线性回归。
• 估计数据矩阵的均值和方差。
• 协方差矩阵在多项高斯分布中起关键作用。
• 数据减少的主成分分析将许多这些元素结合在一起。

如您所见，现代统计和数据分析，至少就机器学习从业者的兴趣而言，取决于线性代数的理解和工具。

线性代数的应用

由于线性代数是数据的数学，线性代数的工具被用于许多领域。

在他关于题为“线性代数导论”主题的经典着作中，Gilbert Strang 提供了一章专门讨论线性代数的应用。在其中，他展示了植根于线性代数的特定数学工具。简而言之，他们是：

• 工程中的矩阵，例如一系列弹簧。
• 图形和网络，例如分析网络。
• 马尔可夫矩阵，人口和经济学，如人口增长。
• 线性规划，单纯形优化方法。
• 傅立叶级数：用于函数的线性代数，广泛用于信号处理。
• 用于统计和概率的线性代数，例如回归的最小二乘法。
• 计算机图形学，例如图像的各种翻译，重新缩放和旋转。

线性代数的另一个有趣的应用是它是阿尔伯特爱因斯坦在他的相对论部分中使用的数学类型。特别是张量和张量微积分。他还介绍了一种新的线性代数符号，称为爱因斯坦符号或爱因斯坦求和惯例。

扩展

本节列出了一些扩展您可能希望探索的教程的想法。

• 搜索书籍和网络以获得定义线性代数领域的 5 种语录。
• 研究并列出 5 个应用或线性代数在场概率和统计中的应用。
• 列出并编写线性代数描述中使用的 10 个术语的简短定义。

如果你探索任何这些扩展，我很想知道。

进一步阅读

如果您希望深入了解，本节将提供有关该主题的更多资源。

图书

• 线性代数简介，2016 年。
• 数值线性代数，1997。
• 线性代数和统计矩阵分析，2014。

用品

• 维基百科上的线性代数
• 维基百科上的线性代数类别
• 线性代数维基百科上的主题列表
• 维基百科上的 LAPACK
• 维基百科上的基本线性代数子程序
• 维基百科上的自动调谐线性代数软件
• 维基百科上的爱因斯坦符号
• 维基百科上的广义相对论数学

相关文章

• 用于机器学习的线性代数

摘要

在本教程中，您从机器学习的角度发现了对线性代数的温和介绍。

具体来说，你学到了：

• 线性代数是数据的数学。
• 线性代数对统计学领域产生了显着影响。
• 线性代数是许多实用数学工具的基础，例如傅里叶级数和计算机图形学。

你有任何问题吗？ 在下面的评论中提出您的问题，我会尽力回答。

Python NumPy 的 N 维数组的温和介绍

原文： machinelearningmastery.com/gentle-introduction-n-dimensional-arrays-python-numpy/

数组是机器学习中使用的主要数据结构。

在 Python 中，来自 NumPy 库的数组（称为 N 维数组或 ndarray）被用作表示数据的主要数据结构。

在本教程中，您将发现 NumPy 中的 N 维数组，用于表示 Python 中的数值和操作数据。

完成本教程后，您将了解：

• 什么是 ndarray 以及如何在 Python 中创建和检查数组。
• 用于创建具有默认值的新空数组和数组的关键函数。
• 如何组合现有数组以创建新数组。

让我们开始吧。

使用 NumPy 在 Python 中对 N 维数组的简要介绍 patrickkavanagh ，保留一些权利。

教程概述

本教程分为 3 个部分;他们是：

1. NumPy N 维数组
2. 创建数组的函数
3. 结合数组

NumPy N 维数组

NumPy 是一个 Python 库，可用于科学和数字应用程序，是用于线性代数运算的工具。

NumPy 中的主要数据结构是 ndarray，它是 N 维数组的简写名称。使用 NumPy 时，ndarray 中的数据简称为数组。

它是内存中固定大小的数组，包含相同类型的数据，例如整数或浮点值。

可以通过数组上的“dtype”属性访问数组支持的数据类型。可以通过“shape”属性访问数组的维度，该属性返回描述每个维度长度的元组。还有许多其他属性。在这里了解更多：

• N 维数组

从数据或简单的 Python 数据结构（如列表）创建数组的简单方法是使用 array（）函数。

下面的示例创建一个包含 3 个浮点值的 Python 列表，然后从列表中创建一个 ndarray 并访问数组的形状和数据类型。

# create array
from numpy import array
l = [1.0, 2.0, 3.0]
a = array(l)
print(a)
print(a.shape)
print(a.dtype)

运行该示例打印 ndarray 的内容，形状是具有 3 个元素的一维数组，以及数据类型，即 64 位浮点。

[ 1\. 2\. 3.]
(3,)
float64

创建数组的函数

有更多便利功能可用于创建您可能遇到或需要使用的固定大小的数组。

我们来看几个。您可以在此处查看完整列表：

• 数组创建例程

空

empty（）函数将创建指定形状的新数组。

函数的参数是一个数组或元组，它指定要创建的数组的每个维度的长度。创建的数组的值或内容将是随机的，需要在使用前进行分配。

下面的示例创建一个空的 3×3 二维数组。

# create empty array
from numpy import empty
a = empty([3,3])
print(a)

运行该示例将打印空数组的内容。您的具体数组内容会有所不同。

[[ 0.00000000e+000 0.00000000e+000 2.20802703e-314]
[ 2.20803350e-314 2.20803353e-314 2.20803356e-314]
[ 2.20803359e-314 2.20803362e-314 2.20803366e-314]]

零

zeros（）函数将创建一个指定大小的新数组，其内容填充零值。

函数的参数是一个数组或元组，它指定要创建的数组的每个维度的长度。

下面的示例创建一个 3×5 零二维数组。

# create zero array
from numpy import zeros
a = zeros([3,5])
print(a)

运行该示例将打印创建的零数组的内容。

[[ 0\. 0\. 0\. 0\. 0.]
[ 0\. 0\. 0\. 0\. 0.]
[ 0\. 0\. 0\. 0\. 0.]]

那些

ones（）函数将创建一个指定大小的新数组，其内容填充一个值。

The argument to the function is an array or tuple that specifies the length of each dimension of the array to create.

下面的示例创建一个 5 元素的一维数组。

# create one array
from numpy import ones
a = ones([5])
print(a)

运行该示例将打印创建的 one 数组的内容。

[ 1\. 1\. 1\. 1\. 1.]

结合数组

NumPy 提供了许多函数来从现有数组创建新数组。

让我们来看看您可能需要或遇到的两个最流行的功能。

垂直栈

给定两个或更多现有数组，您可以使用 vstack（）函数垂直堆叠它们。

例如，给定两个一维数组，您可以通过垂直堆叠它们来创建一个包含两行的新二维数组。

这在以下示例中进行了演示。

# vstack
from numpy import array
from numpy import vstack
a1 = array([1,2,3])
print(a1)
a2 = array([4,5,6])
print(a2)
a3 = vstack((a1, a2))
print(a3)
print(a3.shape)

首先运行该示例打印两个单独定义的一维数组。数组垂直堆叠，形成一个新的 2×3 数组，其内容和形状被打印出来。

[1 2 3]

[4 5 6]

[[1 2 3]
[4 5 6]]

(2, 3)

水平栈

给定两个或更多现有数组，您可以使用 hstack（）函数水平栈它们。

例如，给定两个一维数组，您可以创建一个新的一维数组或一行，第一个和第二个数组的列连接在一起。

This is demonstrated in the example below.

# hstack
from numpy import array
from numpy import hstack
a1 = array([1,2,3])
print(a1)
a2 = array([4,5,6])
print(a2)
a3 = hstack((a1, a2))
print(a3)
print(a3.shape)

首先运行该示例打印两个单独定义的一维数组。然后水平堆叠数组，产生具有 6 个元素的新的一维数组，其内容和形状被打印。

[1 2 3]

[4 5 6]

[1 2 3 4 5 6]

(6,)

扩展

本节列出了一些扩展您可能希望探索的教程的想法。

• 尝试使用不同的方法创建数组到您自己的大小或新数据。
• 找到并开发另外 3 个用于创建数组的 NumPy 函数的示例。
• 找到并开发另外 3 个用于组合数组的 NumPy 函数的示例。

如果你探索任何这些扩展，我很想知道。

进一步阅读

如果您希望深入了解，本节将提供有关该主题的更多资源。

图书

• Python for Data Analysis ，2017。
• 优雅的 SciPy ，2017。
• NumPy 指南，2015 年。

参考

• NumPy 参考
• N 维数组
• 数组创建例程

API

• numpy.array（）API
• numpy.empty（）API
• numpy.zeros（）API
• numpy.ones（）API
• numpy.vstack（）API
• numpy.hstack（）API

摘要

在本教程中，您在 NumPy 中发现了 N 维数组，用于表示 Python 中的数值和操作数据。

具体来说，你学到了：

• 什么是 ndarray 以及如何在 Python 中创建和检查数组。
• 用于创建具有默认值的新空数组和数组的关键函数。
• 如何组合现有数组以创建新数组。

你有任何问题吗？ 在下面的评论中提出您的问题，我会尽力回答。

机器学习向量的温和介绍

原文： machinelearningmastery.com/gentle-introduction-vectors-machine-learning/

向量是线性代数的基本元素。

在训练算法时，在算法和过程（例如目标变量（y））的描述中，在整个机器学习领域中使用向量。

在本教程中，您将发现用于机器学习的线性代数向量。

完成本教程后，您将了解：

• 什么是向量以及如何使用 NumPy 在 Python 中定义一个向量。
• 如何执行加法，减法，乘法和除法等向量运算。
• 如何使用标量执行点积和乘法等附加操作。

让我们开始吧。

机器学习向量的温和介绍 Lachlan Donald 的照片，保留一些权利。

教程概述

本教程分为 5 个部分;他们是：

1. 什么是向量？
2. 定义向量
3. 向量算术
4. 向量点产品
5. 向量标量乘法

什么是向量？

向量是一个或多个称为标量的值的元组。

向量由组件构建，组件是普通数字。您可以将向量视为数字列表，将向量代数视为对列表中的数字执行的操作。

• 第 69 页，无线性代数废话指南，2017 年

向量通常用小写字符表示，例如“v”;例如：

v = (v1, v2, v3)

其中 v1，v2，v3 是标量值，通常是实数值。

向量也使用垂直表示或列显示;例如：

      v1
v = ( v2 )
      v3

在描述机器学习算法的训练时，通常将目标变量表示为具有小写“y”的向量。

通常使用几何类比引入向量，其中向量表示 n 维空间中的点或坐标，其中 n 是维数的数量，例如 2。

向量也可以被认为是来自向量空间的原点的线，具有方向和幅度。

这些类比作为一个起点很好，但不应该太紧，因为我们经常考虑机器学习中非常高的维度向量。我发现向量坐标是机器学习中最引人注目的类比。

现在我们知道了一个向量是什么，让我们来看看如何在 Python 中定义一个向量。

定义向量

我们可以将 Python 中的向量表示为 NumPy 数组。

可以从数字列表创建 NumPy 数组。例如，下面我们定义一个长度为 3 且整数值为 1,2 和 3 的向量。

# create a vector
from numpy import array
v = array([1, 2, 3])
print(v)

该示例定义了具有 3 个元素的向量。

运行该示例将打印定义的向量。

[1 2 3]

向量算术

在本节中将演示简单的向量向量算法，其中所有操作在两个相等长度的向量之间以元素方式执行，以产生具有相同长度的新向量

向量加法

可以将两个相等长度的向量相加在一起以创建新的第三向量。

c = a + b

新向量与其他两个向量具有相同的长度。新向量的每个元素被计算为在相同索引处添加其他向量的元素;例如：

a + b = (a1 + b1, a2 + b2, a3 + b3)

或者，换句话说：

c[0] = a[0] + b[0]
c[1] = a[1] + b[1]
c[2] = a[2] + b[2]

我们可以通过添加 NumPy 数组直接在 Python 中添加向量。

# add vectors
from numpy import array
a = array([1, 2, 3])
print(a)
b = array([1, 2, 3])
print(b)
c = a + b
print(c)

该示例定义了两个向量，每个向量具有三个元素，然后将它们相加。

首先运行该示例打印两个父向量然后打印一个新向量，该向量是两个向量的相加。

[1 2 3]

[1 2 3]

[2 4 6]

向量减法

可以从另一个相等长度的向量中减去一个向量以创建新的第三向量。

c = a - b

与加法一样，新向量具有与父向量相同的长度，并且新向量的每个元素被计算为相同索引处的元素的减法。

a - b = (a1 - b1, a2 - b2, a3 - b3)

Or, put another way:

c[0] = a[0] - b[0]
c[1] = a[1] - b[1]
c[2] = a[2] - b[2]

可以在 Python 中直接减去 NumPy 数组。

# subtract vectors
from numpy import array
a = array([1, 2, 3])
print(a)
b = array([0.5, 0.5, 0.5])
print(b)
c = a - b
print(c)

该示例定义了两个向量，每个向量包含三个元素，然后从第二个向量中减去第一个向量。

首先运行该示例打印两个父向量，然后打印第一个减去第二个的新向量。

[1 2 3]

[ 0.5 0.5 0.5]

[ 0.5 1.5 2.5]

向量乘法

两个相等长度的向量可以相乘。

c = a * b

与加法和减法一样，该操作以元素方式执行以产生相同长度的新向量。

a * b = (a1 * b1, a2 * b2, a3 * b3)

要么

ab = (a1b1, a2b2, a3b3)

Or, put another way:

c[0] = a[0] * b[0]
c[1] = a[1] * b[1]
c[2] = a[2] * b[2]

我们可以直接在 NumPy 中执行此操作。

# multiply vectors
from numpy import array
a = array([1, 2, 3])
print(a)
b = array([1, 2, 3])
print(b)
c = a * b
print(c)

该示例定义了两个向量，每个向量具有三个元素，然后将向量相乘。

首先运行该示例打印两个父向量，然后打印新向量。

[1 2 3]

[1 2 3]

[1 4 9]

向量分部

可以划分两个相等长度的向量。

c = a / b

与其他算术运算一样，此操作以元素方式执行，以产生相同长度的新向量。

a / b = (a1 / b1, a2 / b2, a3 / b3)

or

a / b = (a1b1, a2b2, a3b3)

Or, put another way:

c[0] = a[0] / b[0]
c[1] = a[1] / b[1]
c[2] = a[2] / b[2]

We can perform this operation directly in NumPy.

# divide vectors
from numpy import array
a = array([1, 2, 3])
print(a)
b = array([1, 2, 3])
print(b)
c = a / b
print(c)

该示例定义了两个向量，每个向量具有三个元素，然后将第一个除以第二个。

首先运行该示例打印两个父向量，然后是向量分割的结果。

[1 2 3]

[1 2 3]

[ 1\. 1\. 1.]

向量点产品

我们可以计算两个相同长度向量的相乘元素之和，得到一个标量。

这称为点积，由于在描述操作时使用的点运算符而命名。

点积是计算向量投影，向量分解和确定正交性的关键工具。名称点积来自用于表示它的符号。

• 第 110 页，无线性代数废话指南，2017 年

c = a . b

该操作可用于机器学习以计算向量的加权和。

点积计算如下：

a . b = (a1 * b1 + a2 * b2 + a3 * b3)

or

a . b = (a1b1 + a2b2 + a3b3)

我们可以使用 NumPy 数组上的 dot（）函数计算 Python 中两个向量之间的点积。

# dot product vectors
from numpy import array
a = array([1, 2, 3])
print(a)
b = array([1, 2, 3])
print(b)
c = a.dot(b)
print(c)

该示例定义了两个向量，每个向量包含三个元素，然后计算点积。

运行该示例首先打印两个父向量，然后打印标量点积。

[1 2 3]

[1 2 3]

14

向量标量乘法

向量可以乘以标量，实际上缩放向量的大小。

为了使符号简单，我们将使用小写“s”来表示标量值。

c = s * v

or

c = sv

对向量的每个元素执行乘法，以产生相同长度的新缩放向量。

s * v = (s * v1, s * v2, s * v3)

Or, put another way:

c[0] = a[0] * s
c[1] = a[1] * s
c[2] = a[2] * s

我们可以直接使用 NumPy 数组执行此操作。

# vector-scalar multiplication
from numpy import array
a = array([1, 2, 3])
print(a)
s = 0.5
print(s)
c = s * a
print(c)

该示例首先定义向量，然后标量将向量乘以标量。

首先运行示例打印父向量，然后打印标量，然后将两者相乘的结果。

[1 2 3]

0.5

[ 0.5 1\. 1.5]

类似地，向量标量加法，减法和除法可以以相同的方式执行。

扩展

本节列出了一些扩展您可能希望探索的教程的想法。

• 使用您自己的数据使用每个操作创建 5 个示例。
• 为定义为列表的向量手动实现每个向量操作。
• 搜索机器学习论文并找到每个正在使用的操作的示例。

如果你探索任何这些扩展，我很想知道。

进一步阅读

如果您希望深入了解，本节将提供有关该主题的更多资源。

图书

• 第 1.15 节，向量。 线性代数无废话指南，2017 年。
• 第 2.2 节，向量运算。 线性代数无废话指南，2017 年。
• 线性代数简介，2016 年。
• 第二章，线性代数，深度学习，2016。

API

• numpy.array（）API
• numpy.dot（）API

用品

• 维基百科上的向量空间
• 维基百科上的 Dot 产品

摘要

在本教程中，您发现了用于机器学习的线性代数向量。

具体来说，你学到了：

• 什么是向量以及如何使用 NumPy 在 Python 中定义一个向量。
• 如何执行加法，减法，乘法和除法等向量运算。
• 如何使用标量执行点积和乘法等附加操作。

你有任何问题吗？ 在下面的评论中提出您的问题，我会尽力回答。

如何在 Python 中为机器学习索引，切片和重塑 NumPy 数组

原文： machinelearningmastery.com/index-slice-reshape-numpy-arrays-machine-learning-python/

机器学习数据表示为数组。

在 Python 中，数据几乎普遍表示为 NumPy 数组。

如果您是 Python 的新手，您可能会对某些 pythonic 访问数据的方式感到困惑，例如负索引和数组切片。

在本教程中，您将了解如何在 NumPy 数组中正确操作和访问数据。

完成本教程后，您将了解：

• 如何将列表数据转换为 NumPy 数组。
• 如何使用 Pythonic 索引和切片访问数据。
• 如何调整数据大小以满足某些机器学习 API 的期望。

让我们开始吧。

如何在 Python 中为机器学习索引，切片和重塑 NumPy 数组 BjörnSöderqvist的照片，保留一些权利。

教程概述

本教程分为 4 个部分;他们是：

1. 从列表到数组
2. 数组索引
3. 数组切片
4. 数组重塑

1.从列表到数组

通常，我建议使用 Pandas 甚至 NumPy 函数从文件加载数据。

例如，请看帖子：

• 如何在 Python 中加载机器学习数据

本节假定您已通过其他方式加载或生成数据，现在使用 Python 列表表示它。

我们来看看将列表中的数据转换为 NumPy 数组。

一维列表到数组

您可以加载数据或生成数据，并以列表形式访问它。

您可以通过调用 array（）NumPy 函数将一维数据列表转换为数组。

# one dimensional example
from numpy import array
# list of data
data = [11, 22, 33, 44, 55]
# array of data
data = array(data)
print(data)
print(type(data))

运行该示例将一维列表转换为 NumPy 数组。

[11 22 33 44 55]
<class 'numpy.ndarray'>

数组列表的二维列表

在机器学习中，你更有可能拥有二维数据。

这是一个数据表，其中每一行代表一个新观察，每一列代表一个新特征。

也许您使用自定义代码生成数据或加载数据，现在您有一个列表列表。每个列表代表一个新观察。

您可以通过调用 array（）函数将列表列表转换为 NumPy 数组，方法与上面相同。

# two dimensional example
from numpy import array
# list of data
data = [[11, 22],
		[33, 44],
		[55, 66]]
# array of data
data = array(data)
print(data)
print(type(data))

运行该示例显示已成功转换的数据。

[[11 22]
 [33 44]
 [55 66]]
<class 'numpy.ndarray'>

2.数组索引

使用 NumPy 数组表示数据后，可以使用索引访问它。

我们来看一些通过索引访问数据的例子。

一维索引

通常，索引的工作方式与您对其他编程语言（如 Java，C＃和 C ++）的体验一样。

例如，您可以使用括号运算符[]访问元素，为要检索的值指定零偏移索引。

# simple indexing
from numpy import array
# define array
data = array([11, 22, 33, 44, 55])
# index data
print(data[0])
print(data[4])

运行该示例将打印数组中的第一个和最后一个值。

11
55

指定对于数组边界而言太大的整数将导致错误。

# simple indexing
from numpy import array
# define array
data = array([11, 22, 33, 44, 55])
# index data
print(data[5])

运行该示例将显示以下错误：

IndexError: index 5 is out of bounds for axis 0 with size 5

一个关键的区别是您可以使用负索引来检索从数组末尾偏移的值。

例如，索引-1 指的是数组中的最后一项。对于当前示例中的第一个项，索引-2 将第二个最后一项返回到-5。

# simple indexing
from numpy import array
# define array
data = array([11, 22, 33, 44, 55])
# index data
print(data[-1])
print(data[-5])

运行该示例将打印数组中的最后一项和第一项。

55
11

二维索引

索引二维数据类似于索引一维数据，除了使用逗号分隔每个维度的索引。

data[0,0]

这与基于 C 的语言不同，其中每个维度使用单独的括号运算符。

data[0][0]

例如，我们可以访问第一行和第一列，如下所示：

# 2d indexing
from numpy import array
# define array
data = array([[11, 22], [33, 44], [55, 66]])
# index data
print(data[0,0])

运行该示例将打印数据集中的第一个项目。

11

如果我们对第一行中的所有项目感兴趣，我们可以将第二个维度索引留空，例如：

# 2d indexing
from numpy import array
# define array
data = array([[11, 22], [33, 44], [55, 66]])
# index data
print(data[0,])

这将打印第一行数据。

[11 22]

3.数组切片

到现在为止还挺好;创建和索引数组看起来很熟悉。

现在我们来到数组切片，这是一个导致 Python 和 NumPy 数组初学者出现问题的功能。

像列表和 NumPy 数组这样的结构可以被切片。这意味着可以索引和检索结构的子序列。

在指定输入变量和输出变量或从测试行中分割训练行时，这在机器学习中最有用。

使用冒号运算符'：'指定切片，分别在列之前和之后使用来自'的'_ 和'_ 到 '索引。切片从'from'索引延伸，并在'to'索引之前结束一个项目。

data[from:to]

让我们通过一些例子来解决。

一维切片

您可以通过指定没有索引的切片'：'来访问数组维度中的所有数据。

# simple slicing
from numpy import array
# define array
data = array([11, 22, 33, 44, 55])
print(data[:])

运行该示例将打印数组中的所有元素。

[11 22 33 44 55]

可以通过指定从索引 0 开始并在索引 1 结束的切片（“to”索引之前的一个项目）来切片数组的第一项。

# simple slicing
from numpy import array
# define array
data = array([11, 22, 33, 44, 55])
print(data[0:1])

运行该示例将返回带有第一个元素的子数组。

[11]

我们也可以在切片中使用负索引。例如，我们可以通过在-2 处开始切片（第二个最后一项）并且不指定'to'索引来切片列表中的最后两个项目;将切片带到维度的末尾。

# simple slicing
from numpy import array
# define array
data = array([11, 22, 33, 44, 55])
print(data[-2:])

运行该示例仅返回包含最后两个项的子数组。

[44 55]

二维切片

让我们看看你最有可能在机器学习中使用的二维切片的两个例子。

分割输入和输出功能

通常将加载的数据拆分为输入变量（X）和输出变量（y）。

我们可以通过将所有行和所有列切片到最后一列，然后分别索引最后一列来完成此操作。

对于输入要素，我们可以通过在行索引中指定'：'来选择除最后一行之外的所有行和所有列，并且在列 index 中指定-1。

X = [:, :-1]

对于输出列，我们可以使用'：'再次选择所有行，并通过指定-1 索引仅索引最后一列。

y = [:, -1]

将所有这些放在一起，我们可以将 3 列 2D 数据集分成输入和输出数据，如下所示：

# split input and output
from numpy import array
# define array
data = array([[11, 22, 33],
		[44, 55, 66],
		[77, 88, 99]])
# separate data
X, y = data[:, :-1], data[:, -1]
print(X)
print(y)

运行该示例将打印分隔的 X 和 y 元素。注意，X 是 2D 数组，y 是 1D 数组。

[[11 22]
 [44 55]
 [77 88]]
[33 66 99]

拆分训练和测试行

将加载的数据集拆分为单独的训练和测试集是很常见的。

这是行的分割，其中一些部分将用于训练模型，剩余部分将用于估计训练模型的技能。

这将涉及通过在第二个维度索引中指定“：”来切片所有列。训练数据集将是从开始到分割点的所有行。

dataset
train = data[:split, :]

测试数据集将是从拆分点到维度末尾的所有行。

test = data[split:, :]

将所有这些放在一起，我们可以将数据集拆分为 2 的设计分割点。

# split train and test
from numpy import array
# define array
data = array([[11, 22, 33],
		[44, 55, 66],
		[77, 88, 99]])
# separate data
split = 2
train,test = data[:split,:],data[split:,:]
print(train)
print(test)

运行该示例选择前两行进行训练，选择最后一行进行测试。

[[11 22 33]
[44 55 66]]
[[77 88 99]]

4.数组重塑

切片数据后，您可能需要重新整形。

例如，某些库（例如 scikit-learn）可能要求将输出变量（y）的一维数组形成为具有一列的二维数组，并且每列的结果。

一些算法，如 Keras 中的长短期记忆递归神经网络，需要将输入指定为由样本，时间步长和特征组成的三维数组。

了解如何重塑 NumPy 数组以使您的数据满足特定 Python 库的期望非常重要。我们将看看这两个例子。

数据形状

NumPy 数组具有 shape 属性，该属性返回数组每个维度长度的元组。

例如：

# array shape
from numpy import array
# define array
data = array([11, 22, 33, 44, 55])
print(data.shape)

运行该示例会打印一维的元组。

(5,)

对于二维数组，返回具有两个长度的元组。

# array shape
from numpy import array
# list of data
data = [[11, 22],
		[33, 44],
		[55, 66]]
# array of data
data = array(data)
print(data.shape)

运行该示例将返回一个包含行数和列数的元组。

(3, 2)

您可以在形状维度中使用数组维度的大小，例如指定参数。

可以像数组一样访问元组的元素，行数为第 0 个索引，列数为第 1 个索引。例如：

# array shape
from numpy import array
# list of data
data = [[11, 22],
		[33, 44],
		[55, 66]]
# array of data
data = array(data)
print('Rows: %d' % data.shape[0])
print('Cols: %d' % data.shape[1])

运行该示例可访问每个维度的特定大小。

Rows: 3
Cols: 2

重塑 1D 到 2D 数组

通常需要将一维数组重塑为具有一列和多个数组的二维数组。

NumPy 在 NumPy 数组对象上提供 reshape（）函数，可用于重塑数据。

reshape（）函数采用一个参数来指定数组的新形状。在将一维数组重新整形为具有一列的二维数组的情况下，元组将是第一维（data.shape [0]）的数组形状和第二维的 1。

data = data.reshape((data.shape[0], 1))

综上所述，我们得到以下工作示例。

# reshape 1D array
from numpy import array
from numpy import reshape
# define array
data = array([11, 22, 33, 44, 55])
print(data.shape)
# reshape
data = data.reshape((data.shape[0], 1))
print(data.shape)

运行该示例将打印一维数组的形状，将数组重新整形为包含 1 列的 5 行，然后打印此新形状。

(5,)
(5, 1)

重塑 2D 到 3D 数组

通常需要重新形成二维数据，其中每行表示序列为三维数组，用于期望一个或多个时间步长和一个或多个特征的多个样本的算法。

一个很好的例子是 Keras 深度学习库中的 LSTM 递归神经网络模型。

可以直接使用重塑功能，指定新的维度。这是清楚的，其中每个序列具有多个时间步长，每个时间步长具有一个观察（特征）。

我们可以使用数组上 shape 属性的大小来指定样本（行）和列的数量（时间步长），并将要素数量固定为 1。

data.reshape((data.shape[0], data.shape[1], 1))

Putting this all together, we get the following worked example.

# reshape 2D array
from numpy import array
# list of data
data = [[11, 22],
		[33, 44],
		[55, 66]]
# array of data
data = array(data)
print(data.shape)
# reshape
data = data.reshape((data.shape[0], data.shape[1], 1))
print(data.shape)

首先运行示例打印 2D 数组中每个维度的大小，重新整形数组，然后总结新 3D 数组的形状。

(3, 2)
(3, 2, 1)

进一步阅读

如果您要深入了解，本节将提供有关该主题的更多资源。

• Python 非正式介绍
• 在 NumPy API 中创建数组
• NumPy API 中的索引和切片
• NumPy API 中的基本索引
• NumPy 形状属性
• NumPy reshape（）函数

摘要

在本教程中，您了解了如何使用 Python 访问和重塑 NumPy 数组中的数据。

具体来说，你学到了：

• 如何将列表数据转换为 NumPy 数组。
• 如何使用 Pythonic 索引和切片访问数据。
• 如何调整数据大小以满足某些机器学习 API 的期望。

你有任何问题吗？ 在下面的评论中提出您的问题，我会尽力回答。

机器学习的矩阵和矩阵算法简介

原文： machinelearningmastery.com/introduction-matrices-machine-learning/

矩阵是线性代数的基本元素。

在训练算法时，在算法和过程（例如输入数据变量（X））的描述中，在整个机器学习领域中使用矩阵。

在本教程中，您将发现线性代数中的矩阵以及如何在 Python 中对它们进行操作。

完成本教程后，您将了解：

• 什么是矩阵以及如何使用 NumPy 在 Python 中定义矩阵。
• 如何执行元素操作，如加法，减法和 Hadamard 产品。
• 如何将矩阵相乘以及操作背后的直觉。

让我们开始吧。

机器学习矩阵的温和介绍 Maximiliano Kolus 的照片，保留一些权利。

教程概述

本教程分为 6 个部分;他们是：

1. 什么是矩阵？
2. 定义矩阵
3. 矩阵算术
4. 矩阵 - 矩阵乘法（点积）
5. 矩阵向量乘法
6. 矩阵 - 标量乘法

什么是矩阵？

矩阵是具有一个或多个列和一个或多个行的标量的二维数组。

矩阵是数字的二维数组（表）。

• 第 115 页，无线性代数废话指南，2017 年

矩阵的符号通常是大写字母，例如 A，并且条目由它们的行（i）和列（j）的二维下标引用，例如 aij。例如：

A = ((a11, a12), (a21, 22), (a31, a32))

更常见的是使用水平表示法定义矩阵。

     a11, a12
A = (a21, a22)
     a31, a32

您可能在机器学习中遇到矩阵的第一个地方是模型训练数据，该数据由许多行和列组成，并且通常使用大写字母“X”表示。

用于帮助理解向量及其某些操作的几何类比不适用于矩阵。此外，向量本身可以被认为是具有一列和多行的矩阵。

对于行数和列数，矩阵的尺寸通常表示为 m 和 n。

既然我们知道矩阵是什么，那么让我们看看在 Python 中定义矩阵。

定义矩阵

我们可以使用二维 NumPy 数组在 Python 中表示矩阵。

可以在给定列表列表的情况下构造 NumPy 数组。例如，下面是 3 行，2 列矩阵。

# create matrix
from numpy import array
A = array([[1, 2, 3], [4, 5, 6]])
print(A)

运行该示例将打印显示预期结构的创建矩阵。

[[1 2 3]
 [4 5 6]]

矩阵算术

在本节中将演示简单的矩阵 - 矩阵算法，其中所有操作在相同大小的两个矩阵之间以元素方式执行，以产生具有相同大小的新矩阵。

矩阵加法

可以将具有相同尺寸的两个矩阵相加在一起以创建新的第三矩阵。

C = A + B

所得矩阵中的标量元素被计算为添加的每个矩阵中元素的相加。

         a11 + b11, a12 + b12
A + B = (a21 + b21, a22 + b22)
         a31 + b31, a32 + b32

或者，换句话说：

C[0,0] = A[0,0] + B[0,0]
C[1,0] = A[1,0] + B[1,0]
C[2,0] = A[2,0] + B[2,0]
C[0,1] = A[0,1] + B[0,1]
C[1,1] = A[1,1] + B[1,1]
C[2,1] = A[2,1] + B[2,1]

我们可以在 python 中使用 plus 运算符直接在两个 NumPy 数组上实现它。

# add matrices
from numpy import array
A = array([[1, 2, 3], [4, 5, 6]])
print(A)
B = array([[1, 2, 3], [4, 5, 6]])
print(B)
C = A + B
print(C)

该示例首先定义两个 2×3 矩阵，然后将它们相加。

运行该示例首先打印两个父矩阵，然后将它们添加到一起。

[[1 2 3]
 [4 5 6]]

[[1 2 3]
 [4 5 6]]

[[ 2  4  6]
 [ 8 10 12]]

矩阵减法

类似地，可以从具有相同尺寸的另一个矩阵中减去一个矩阵。

C = A - B

计算得到的矩阵中的标量元素，作为每个矩阵中元素的减法。

         a11 - b11, a12 - b12
A - B = (a21 - b21, a22 - b22)
         a31 - b31, a32 - b32

Or, put another way:

C[0,0] = A[0,0] - B[0,0]
C[1,0] = A[1,0] - B[1,0]
C[2,0] = A[2,0] - B[2,0]
C[0,1] = A[0,1] - B[0,1]
C[1,1] = A[1,1] - B[1,1]
C[2,1] = A[2,1] - B[2,1]

我们可以在 python 中使用 minus 运算符直接在两个 NumPy 数组上实现它。

# subtract matrices
from numpy import array
A = array([[1, 2, 3], [4, 5, 6]])
print(A)
B = array([[0.5, 0.5, 0.5], [0.5, 0.5, 0.5]])
print(B)
C = A - B
print(C)

该示例首先定义两个 2×3 矩阵，然后从另一个中减去一个。

运行该示例首先打印两个父矩阵，然后从第二个矩阵中减去第一个矩阵。

[[1 2 3]
 [4 5 6]]

[[ 0.5  0.5  0.5]
 [ 0.5  0.5  0.5]]

[[ 0.5  1.5  2.5]
 [ 3.5  4.5  5.5]]

矩阵乘法（Hadamard 产品）

具有相同大小的两个矩阵可以相乘，这通常称为逐元素矩阵乘法或 Hadamard 乘积。

当提到矩阵乘法时，这不是典型的操作，因此经常使用不同的算子，例如圆圈“o”。

C = A o B

与逐元素减法和加法一样，逐元素乘法涉及从每个父矩阵乘以元素以计算新矩阵中的值。

         a11 * b11, a12 * b12
A o B = (a21 * b21, a22 * b22)
         a31 * b31, a32 * b32

Or, put another way:

C[0,0] = A[0,0] * B[0,0]
C[1,0] = A[1,0] * B[1,0]
C[2,0] = A[2,0] * B[2,0]
C[0,1] = A[0,1] * B[0,1]
C[1,1] = A[1,1] * B[1,1]
C[2,1] = A[2,1] * B[2,1]

我们可以在 python 中使用 star 运算符直接在两个 NumPy 数组上实现它。

# element-wise multiply matrices
from numpy import array
A = array([[1, 2, 3], [4, 5, 6]])
print(A)
B = array([[1, 2, 3], [4, 5, 6]])
print(B)
C = A * B
print(C)

该示例首先定义两个 2×3 矩阵，然后将它们相乘。

运行该示例首先打印两个父矩阵，然后将它们与 Hadamard 产品相乘。

[[1 2 3]
 [4 5 6]]

[[1 2 3]
 [4 5 6]]

[[ 1  4  9]
 [16 25 36]]

矩阵分部

一个矩阵可以被具有相同尺寸的另一个矩阵划分。

C = A / B

得到的矩阵中的标量元素被计算为每个矩阵中元素的划分。

         a11 / b11, a12 / b12
A / B = (a21 / b21, a22 / b22)
         a31 / b31, a32 / b32

Or, put another way:

C[0,0] = A[0,0] / B[0,0]
C[1,0] = A[1,0] / B[1,0]
C[2,0] = A[2,0] / B[2,0]
C[0,1] = A[0,1] / B[0,1]
C[1,1] = A[1,1] / B[1,1]
C[2,1] = A[2,1] / B[2,1]

我们可以直接在两个 NumPy 数组上使用除法运算符在 python 中实现它。

# divide matrices
from numpy import array
A = array([[1, 2, 3], [4, 5, 6]])
print(A)
B = array([[1, 2, 3], [4, 5, 6]])
print(B)
C = A / B
print(C)

该示例首先定义两个 2×3 矩阵，然后将第一个与第二个矩阵相除。

首先运行该示例打印两个父矩阵，然后将第一个矩阵除以第二个矩阵。

[[1 2 3]
 [4 5 6]]

[[1 2 3]
 [4 5 6]]

[[ 1\.  1\.  1.]
 [ 1\.  1\.  1.]]

矩阵 - 矩阵乘法（点积）

矩阵乘法（也称为矩阵点乘积）比先前的操作更复杂，并且涉及规则，因为并非所有矩阵都可以相乘。

C = A * B

要么

C = AB

矩阵乘法的规则如下：

• 第一矩阵（A）中的列数（n）必须等于第二矩阵（B）中的行数（m）。

例如，矩阵 A 的尺寸为 m 行 n 列，矩阵 B 的尺寸为 n 和 k。 A 行和 n 行 b 中的 n 列相等。结果是一个 m 行和 k 列的新矩阵。

C(m,k) = A(m,n) * B(n,k)

此规则适用于矩阵乘法链，其中链中一个矩阵中的列数必须与链中下一个矩阵中的行数匹配。

涉及矩阵的最重要的操作之一是两个矩阵的乘法。矩阵 A 和 B 的矩阵乘积是第三矩阵 C.为了定义该乘积，A 必须具有与 B 具有行相同的列数。如果 A 的形状为 m×n 且 B 的形状为 n×p，则 C 的形状为 m×p。

• 第 34 页，深度学习，2016 年。

矩阵乘法的直觉是我们计算矩阵 A 中每一行与矩阵 B 中每列之间的点积。例如，我们可以逐步降低 A 列的行数并将每一行乘以 B 中的第 1 列来给出标量 C 列第 1 列中的值

使用以下图像可以清楚地看到这一点。

矩阵乘法的描述，取自 Wikipedia ，保留一些权利。

下面描述使用矩阵表示法的矩阵乘法。

     a11, a12
A = (a21, a22)
     a31, a32

     b11, b12
B = (b21, b22)

     a11 * b11 + a12 * b21, a11 * b12 + a12 * b22
C = (a21 * b11 + a22 * b21, a21 * b12 + a22 * b22)
     a31 * b11 + a32 * b21, a31 * b12 + a32 * b22

通过删除乘法符号可以简化这一点：

     a11b11 + a12b21, a11b12 + a12b22
C = (a21b11 + a22b21, a21b12 + a22b22)
     a31b11 + a32b21, a31b12 + a32b22

我们可以使用数组表示法描述矩阵乘法运算。

C[0,0] = A[0,0] * B[0,0] + A[0,1] * B[1,0]
C[1,0] = A[1,0] * B[0,0] + A[1,1] * B[1,0]
C[2,0] = A[2,0] * B[0,0] + A[2,1] * B[1,0]
C[0,1] = A[0,0] * B[0,1] + A[0,1] * B[1,1]
C[1,1] = A[1,0] * B[0,1] + A[1,1] * B[1,1]
C[2,1] = A[2,0] * B[0,1] + A[2,1] * B[1,1]

矩阵乘法运算可以使用 dot（）函数在 NumPy 中实现。

# matrix dot product
from numpy import array
A = array([[1, 2], [3, 4], [5, 6]])
print(A)
B = array([[1, 2], [3, 4]])
print(B)
C = A.dot(B)
print(C)

该示例首先定义两个 2×3 矩阵，然后计算它们的点积。

运行该示例首先打印两个父矩阵，然后打印点积的结果。

[[1 2]
 [3 4]
 [5 6]]

[[1 2]
 [3 4]]

[[ 7 10]
 [15 22]
 [23 34]]

矩阵向量乘法

只要观察到矩阵乘法的规则，矩阵和向量就可以相乘。

具体而言，矩阵中的列数必须等于向量中的项数。与矩阵乘法一样，可以使用点表示法编写操作。因为向量只有一列，所以结果总是一个向量。

c = A . v

或者没有紧凑形式的圆点。

c = Av

结果是一个与父矩阵具有相同行数的向量。

     a11, a12
A = (a21, a22)
     a31, a32

     v1
v = (v2)

     a11 * v1 + a12 * v2
c = (a21 * v1 + a22 * v2)
     a31 * v1 + a32 * v2

或者，更紧凑。

     a11v1 + a12v2
c = (a21v1 + a22v2)
     a31v1 + a32v2

矩阵向量乘法可以使用 dot（）函数在 NumPy 中实现。

# matrix-vector multiplication
from numpy import array
A = array([[1, 2], [3, 4], [5, 6]])
print(A)
B = array([0.5, 0.5])
print(B)
C = A.dot(B)
print(C)

该示例首先定义 2×3 矩阵和 2 元素向量，然后将它们相乘。

首先运行示例打印父矩阵和向量，然后将它们相乘的结果打印出来。

[[1 2]
 [3 4]
 [5 6]]

[ 0.5  0.5]

[ 1.5  3.5  5.5]

矩阵 - 标量乘法

矩阵可以乘以标量。

这可以使用矩阵和标量之间的点表示法来表示。

C = A . b

或者没有点符号。

C = Ab

结果是具有与父矩阵相同大小的矩阵，其中矩阵的每个元素乘以标量值。

     a11, a12
A = (a21, a22)
     a31, a32

b

     a11 * b, a12 * b
C = (a21 * b, a22 * b)
     a31 * b, a32 * b

or

     a11b, a12b
C = (a21b, a22b)
     a31b, a32b

我们也可以用数组表示法来表示它。

C[0,0] = A[0,0] * b
C[1,0] = A[1,0] * b
C[2,0] = A[2,0] * b
C[0,1] = A[0,1] * b
C[1,1] = A[1,1] * b
C[2,1] = A[2,1] * b

这可以使用乘法运算符直接在 NumPy 中实现。

# matrix-scalar multiplication
from numpy import array
A = array([[1, 2], [3, 4], [5, 6]])
print(A)
b = 0.5
print(b)
C = A * b
print(C)

该示例首先定义 2×3 矩阵和标量，然后将它们相乘。

首先运行示例打印父矩阵和标量，然后将它们相乘的结果打印出来。

[[1 2]
 [3 4]
 [5 6]]

0.5

[[ 0.5  1\. ]
 [ 1.5  2\. ]
 [ 2.5  3\. ]]

扩展

本节列出了一些扩展您可能希望探索的教程的想法。

• 使用您自己的数据使用每个操作创建 5 个示例。
• 为定义为列表列表的矩阵手动实现每个矩阵操作。
• 搜索机器学习论文并找到每个正在使用的操作的示例。

如果你探索任何这些扩展，我很想知道。

进一步阅读

如果您希望深入了解，本节将提供有关该主题的更多资源。

图书

• 第 2.3 节，矩阵运算。 线性代数无废话指南，2017 年。
• 第 3.3 节，矩阵乘法。 线性代数无废话指南，2017 年。
• 第 1.3 节矩阵，线性代数简介，第五版，2016 年。
• 第 2.4 节矩阵运算规则，线性代数导论，第五版，2016 年。
• 第 2.1 节标量，向量，矩阵和张量，深度学习，2016 年。
• 第 2.2 节乘以矩阵和向量，深度学习，2016。

API

• numpy.array（）API
• numpy.dot（）API

用品

• 矩阵（数学）
• 维基百科上的矩阵乘法
• 维基百科上的 Hadamard 产品（矩阵）
• 维基百科上的 Dot 产品

摘要

在本教程中，您发现了线性代数中的矩阵以及如何在 Python 中对它们进行操作。

具体来说，你学到了：

• 什么是矩阵以及如何使用 NumPy 在 Python 中定义矩阵。
• 如何执行元素操作，如加法，减法和 Hadamard 产品。
• 如何将矩阵相乘以及操作背后的直觉。

你有任何问题吗？ 在下面的评论中提出您的问题，我会尽力回答。

机器学习中的特征分解，特征值和特征向量的温和介绍

原文： machinelearningmastery.com/introduction-to-eigendecomposition-eigenvalues-and-eigenvectors/

矩阵分解是用于将矩阵减少到其组成部分的有用工具，以简化一系列更复杂的操作。

也许最常用的矩阵分解类型是特征分解，它将矩阵分解为特征向量和特征值。这种分解也在机器学习中使用的方法中起作用，例如在主成分分析方法或 PCA 中。

在本教程中，您将发现线性代数中的特征分解，特征向量和特征值。

完成本教程后，您将了解：

• 特征分解是什么以及特征向量和特征值的作用。
• 如何使用 NumPy 在 Python 中计算特征分解。
• 如何确定向量是一个特征向量，以及如何从特征向量和特征值重建矩阵。

让我们开始吧。

用于机器学习的特征分解，特征值和特征向量的温和介绍 照片由 Mathias Appel 拍摄，保留一些权利。

教程概述

本教程分为 5 个部分;他们是：

1. 矩阵的特征分解
2. 特征向量和特征值
3. 特征分解的计算
4. 确认特征向量和特征值
5. 重建原始矩阵

矩阵的特征分解

矩阵的特征分解是一种分解，其涉及将方阵分解为一组特征向量和特征值。

最广泛使用的一种矩阵分解称为特征分解，其中我们将矩阵分解为一组特征向量和特征值。

• 第 42 页，深度学习，2016 年。

如果向量满足以下等式，则向量是矩阵的特征向量。

A . v = lambda . v

这称为特征值方程，其中 A 是我们正在分解的父方矩阵，v 是矩阵的特征向量，lambda 是小写的希腊字母，表示特征值标量。

或者没有点符号。

Av = lambdav

对于父矩阵的每个维度，矩阵可以具有一个特征向量和特征值。并非所有的方形矩阵都可以分解为特征向量和特征值，有些只能以需要复数的方式进行分解。可以将父矩阵显示为特征向量和特征值的乘积。

A = Q . diag(V) . Q^-1

或者，没有点符号。

A = Qdiag(V)Q^-1

其中 Q 是由特征向量组成的矩阵，diag（V）是由沿对角线的特征值（有时用大写λ表示）组成的对角矩阵，并且 Q ^ -1 是由特征向量组成的矩阵的逆。

但是，我们经常希望将矩阵分解为它们的特征值和特征向量。这样做可以帮助我们分析矩阵的某些属性，就像将整数分解为其素因子一样可以帮助我们理解该整数的行为。

• 第 43 页，深度学习，2016 年。

Eigen 不是名称，例如该方法不以“Eigen”命名; eigen（发音为 eye-gan）是德语单词，意思是“拥有”或“先天”，如属于父矩阵。

分解操作不会导致矩阵的压缩;相反，它将其分解为组成部分，以使矩阵上的某些操作更容易执行。与其他矩阵分解方法一样，特征分解用作元素以简化其他更复杂的矩阵运算的计算。

当它们乘以 A 时，几乎所有向量都会改变方向。某些特殊向量 x 与 Ax 的方向相同。那些是“特征向量”。将特征向量乘以 A，向量 Ax 是原始 x 的λ倍。 [...]特征值 lambda 告诉特殊向量 x 是否被拉伸或收缩或反转或保持不变 - 当它乘以 A.

• 第 289 页，线性代数导论，第五版，2016 年。

特征分解也可用于计算主成分分析方法或 PCA 中矩阵的主成分，可用于减少机器学习中数据的维数。

特征向量和特征值

特征向量是单位向量，这意味着它们的长度或幅度等于 1.0。它们通常被称为右向量，其仅表示列向量（与行向量或左向量相对）。右向量是我们理解它们的向量。

特征值是应用于特征向量的系数，其赋予向量其长度或幅度。例如，负特征值可以反转特征向量的方向作为缩放它的一部分。

仅具有正特征值的矩阵被称为正定矩阵，而如果特征值都是负的，则其被称为负定矩阵。

根据矩阵的特征值及其特征向量分解矩阵，可以对矩阵的属性进行有价值的分析。当我们使用矩阵的特征分解时，某些矩阵计算（如计算矩阵的幂）变得更加容易。

• 第 262 页，无线性代数废话指南，2017 年

特征分解的计算

使用有效的迭代算法在方阵上计算特征分解，我们不会详细讨论。

通常首先找到特征值，然后找到特征向量以将该方程求解为一组系数。

可以使用 eig（）函数在 NumPy 中计算特征分解。

以下示例首先定义 3×3 方阵。在返回特征值和特征向量的矩阵上计算特征分解。

# eigendecomposition
from numpy import array
from numpy.linalg import eig
# define matrix
A = array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(A)
# calculate eigendecomposition
values, vectors = eig(A)
print(values)
print(vectors)

首先运行该示例打印定义的矩阵，然后是特征值和特征向量。更具体地，特征向量是右侧特征向量并且被归一化为单位长度。

[[1 2 3]
 [4 5 6]
 [7 8 9]]

[  1.61168440e+01  -1.11684397e+00  -9.75918483e-16]

[[-0.23197069 -0.78583024  0.40824829]
 [-0.52532209 -0.08675134 -0.81649658]
 [-0.8186735   0.61232756  0.40824829]]

确认特征向量和特征值

我们可以确认向量确实是矩阵的特征向量。

我们通过将候选特征向量乘以特征向量并将结果与​​特征值进行比较来做到这一点。

首先，我们将定义一个矩阵，然后计算特征值和特征向量。然后，我们将测试第一个向量和值是否实际上是矩阵的特征值和特征向量。我们知道它们是，但这是一个很好的练习。

特征向量作为矩阵返回，其具有与父矩阵相同的维度，其中每列是特征向量，例如，第一个特征向量是向量[：，0]。特征值作为列表返回，其中返回数组中的值索引通过列索引与特征向量配对，例如，值[0]的第一个特征值与向量[：，0]处的第一个特征向量配对。

# confirm eigenvector
from numpy import array
from numpy.linalg import eig
# define matrix
A = array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
# calculate eigendecomposition
values, vectors = eig(A)
# confirm first eigenvector
B = A.dot(vectors[:, 0])
print(B)
C = vectors[:, 0] * values[0]
print(C)

该示例将原始矩阵与第一个特征向量相乘，并将其与第一个特征向量乘以第一个特征值进行比较。

运行该示例将打印这两个乘法的结果，这些乘法显示相同的结果向量，正如我们所期望的那样。

[ -3.73863537  -8.46653421 -13.19443305]

[ -3.73863537  -8.46653421 -13.19443305]

重建原始矩阵

我们可以反转过程并仅在给定特征向量和特征值的情况下重建原始矩阵。

首先，必须将特征向量列表转换为矩阵，其中每个向量成为一行。特征值需要排列成对角矩阵。 NumPy diag（）函数可用于此目的。

接下来，我们需要计算特征向量矩阵的逆，我们可以使用 inv（）NumPy 函数来实现。最后，这些元素需要与 dot（）函数相乘。

# reconstruct matrix
from numpy import diag
from numpy import dot
from numpy.linalg import inv
from numpy import array
from numpy.linalg import eig
# define matrix
A = array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(A)
# calculate eigenvectors and eigenvalues
values, vectors = eig(A)
# create matrix from eigenvectors
Q = vectors
# create inverse of eigenvectors matrix
R = inv(Q)
# create diagonal matrix from eigenvalues
L = diag(values)
# reconstruct the original matrix
B = Q.dot(L).dot(R)
print(B)

该示例再次计算特征值和特征向量，并使用它们来重建原始矩阵。

首先运行该示例打印原始矩阵，然后从与原始矩阵匹配的特征值和特征向量重建矩阵。

[[1 2 3]
 [4 5 6]
 [7 8 9]]

[[ 1\.  2\.  3.]
 [ 4\.  5\.  6.]
 [ 7\.  8\.  9.]]

扩展

本节列出了一些扩展您可能希望探索的教程的想法。

• 使用您自己的数据使用每个操作创建 5 个示例。
• 为定义为列表列表的矩阵手动实现每个矩阵操作。
• 搜索机器学习论文并找到每个正在使用的操作的示例。

如果你探索任何这些扩展，我很想知道。

进一步阅读

如果您希望深入了解，本节将提供有关该主题的更多资源。

图书

• 第 6.1 节特征值和特征向量。 线性代数无废话指南，2017 年。
• 第六章特征值和特征向量，线性代数导论，第 5 版，2016 年。
• 第 2.7 节特征分解，深度学习，2016 年。
• 第五章特征值，特征向量和不变子空间，线性代数完成权，第三版，2015 年。
• 第 24 讲，特征值问题，数值线性代数，1997。

API

• numpy.linalg.eig（）API
• numpy.diag（）API
• numpy.dot（）API
• numpy.linalg.inv（）API

用品

• eigen on Wiktionary
• 特征值和特征向量
• 矩阵的特征分解
• 特征值算法
• 矩阵分解

摘要

在本教程中，您发现了线性代数中的特征分解，特征向量和特征值。

具体来说，你学到了：

• 特征分解是什么以及特征向量和特征值的作用。
• 如何使用 NumPy 在 Python 中计算特征分解。
• 如何确定向量是一个特征向量，以及如何从特征向量和特征值重建矩阵。

你有任何问题吗？ 在下面的评论中提出您的问题，我会尽力回答。

NumPy 期望值，方差和协方差的简要介绍

原文： machinelearningmastery.com/introduction-to-expected-value-variance-and-covariance/

基础统计量是应用机器学习中的有用工具，可以更好地理解您的数据。

它们也是为更先进的线性代数运算和机器学习方法提供基础的工具，例如协方差矩阵和主成分分析。因此，在线性代数符号的背景下强调基本统计是非常重要的。

在本教程中，您将了解基本统计操作如何工作以及如何使用 NumPy 以及线性代数中的符号和术语来实现它们。

完成本教程后，您将了解：

• 预期值，平均值和平均值是什么以及如何计算它们。
• 方差和标准偏差是什么以及如何计算它们。
• 协方差，相关性和协方差矩阵是什么以及如何计算它们。

让我们开始吧。

• 更新于 Mar / 2018 ：修复了向量方差示例中的小错字。谢谢鲍勃。

NumPy 照片由 Robyn Jay 对期望值，方差和协方差的温和介绍，保留一些权利。

教程概述

本教程分为 4 个部分;他们是：

1. 期望值
2. 方差
3. 协方差
4. 协方差矩阵

期望值

在概率上，某个随机变量 X 的平均值称为期望值或期望值。

期望值使用符号 E 和变量名称周围的方括号;例如：

E[X]

它被计算为可以绘制的值的概率加权和。

E[X] = sum(x1 * p1, x2 * p2, x3 * p3, ..., xn * pn)

在简单的情况下，例如掷硬币或掷骰子，每次事件的概率都是可能的。因此，可以将期望值计算为所有值的总和乘以值的倒数。

E[X] = sum(x1, x2, x3, ..., xn) . 1/n

在统计学中，可以从从域中抽取的示例的样本来估计平均值，或者更具技术性地，算术平均值或样本均值。这很混乱，因为平均值，平均值和期望值可以互换使用。

在摘要中，均值由小写希腊字母 mu 表示，并且是根据观察样本计算的，而不是所有可能的值。

mu = sum(x1, x2, x3, ..., xn) . 1/n

或者，写得更紧凑：

mu = sum(x . P(x))

其中 x 是观测向量，P（x）是每个值的计算概率。

当计算特定变量（例如 x）时，均值表示为小写变量名称，上面有一行，称为 x-bar。

_
x = sum from 1 to n (xi) . 1/n

可以使用 mean（）函数计算 NumPy 中的向量或矩阵的算术平均值。

下面的示例定义了 6 个元素的向量并计算平均值。

from numpy import array
from numpy import mean
v = array([1,2,3,4,5,6])
print(v)
result = mean(v)
print(result)

首先运行该示例打印定义的向量和向量中的值的平均值。

[1 2 3 4 5 6]

3.5

均值函数可以通过分别指定轴参数和值 0 或 1 来计算矩阵的行或列均值。

下面的示例定义了一个 2×6 矩阵，并计算列和行均值。

from numpy import array
from numpy import mean
M = array([[1,2,3,4,5,6],[1,2,3,4,5,6]])
print(M)
col_mean = mean(M, axis=0)
print(col_mean)
row_mean = mean(M, axis=1)
print(row_mean)

首先运行示例打印定义的矩阵，然后打印计算的列和行平均值。

[[1 2 3 4 5 6]
 [1 2 3 4 5 6]]

[ 1\.  2\.  3\.  4\.  5\.  6.]

[ 3.5  3.5]

方差

在概率上，一些随机变量 X 的方差是分布中平均值相对于平均值变化的量度。

方差表示为变量上的函数 Var（）。

Var[X]

方差计算为分布中每个值与预期值的平均平方差。或者与预期值的预期平方差异。

Var[X] = E[(X - E[X])²]

假设已经计算了变量的期望值（E [X]），则可以将随机变量的方差计算为每个示例的平方差与期望值乘以该值的概率之和。

Var[X] = sum (p(x1) . (x1 - E[X])², p(x2) . (x2 - E[X])², ..., p(x1) . (xn - E[X])²)

如果分布中每个示例的概率相等，则方差计算可以降低个体概率，并将平方差的总和乘以分布中的示例数的倒数。

Var[X] = sum ((x1 - E[X])², (x2 - E[X])², ...,(xn - E[X])²) . 1/n

在统计中，可以从从域中抽取的示例的样本来估计方差。

在摘要中，样本方差由小写西格玛表示，其中 2 上标表示单位是平方的，而不是必须对最终值求平方。将平方差的总和乘以实例数的倒数减 1 以校正偏差。

sigma² = sum from 1 to n ( (xi - mu)² ) . 1 / (n - 1)

在 NumPy 中，可以使用 var（）函数计算向量或矩阵的方差。默认情况下，var（）函数计算总体方差。要计算样本方差，必须将 ddof 参数设置为值 1。

下面的示例定义了 6 个元素的向量并计算了样本方差。

from numpy import array
from numpy import var
v = array([1,2,3,4,5,6])
print(v)
result = var(v, ddof=1)
print(result)

首先运行该示例打印定义的向量，然后打印向量中值的计算样本方差。

[1 2 3 4 5 6]

3.5

var 函数可以通过分别指定 axis 参数和值 0 或 1 来计算矩阵的行或列方差，与上面的平均函数相同。

下面的示例定义了一个 2×6 矩阵，并计算了列和行样本方差。

from numpy import array
from numpy import var
M = array([[1,2,3,4,5,6],[1,2,3,4,5,6]])
print(M)
col_mean = var(M, ddof=1, axis=0)
print(col_mean)
row_mean = var(M, ddof=1, axis=1)
print(row_mean)

首先运行示例打印定义的矩阵，然后打印列和行样本方差值。

[[1 2 3 4 5 6]
 [1 2 3 4 5 6]]

[ 0\.  0\.  0\.  0\.  0\.  0.]

[ 3.5  3.5]

标准偏差计算为方差的平方根，并表示为小写“s”。

s = sqrt(sigma²)

为了保持这种表示法，有时方差表示为 s ^ 2，其中 2 表示为上标，再次表明单位是平方的。

NumPy 还提供直接通过 std（）函数计算标准偏差的功能。与 var（）函数一样，ddof 参数必须设置为 1 才能计算无偏样本标准差，并且可以通过将 axis 参数分别设置为 0 和 1 来计算列和行标准偏差。

下面的示例演示了如何计算矩阵的行和列的样本标准偏差。

from numpy import array
from numpy import std
M = array([[1,2,3,4,5,6],[1,2,3,4,5,6]])
print(M)
col_mean = std(M, ddof=1, axis=0)
print(col_mean)
row_mean = std(M, ddof=1, axis=1)
print(row_mean)

首先运行示例打印定义的矩阵，然后打印列和行样本标准偏差值。

[[1 2 3 4 5 6]
 [1 2 3 4 5 6]]

[ 0\.  0\.  0\.  0\.  0\.  0.]

[ 1.87082869  1.87082869]

协方差

在概率上，协方差是两个随机变量的联合概率的度量。它描述了两个变量如何一起变化。

它表示为函数 cov（X，Y），其中 X 和 Y 是要考虑的两个随机变量。

cov(X,Y)

协方差计算为每个随机变量与其预期值的差异的乘积的预期值或平均值，其中 E [X]是 X 的期望值，E [Y]是 y 的期望值。

cov(X, Y) = E[(X - E[X] . (Y - E[Y])]

假设已计算出 X 和 Y 的预期值，则协方差可以计算为 x 值与其预期值的差值之和乘以 y 值与其预期值的差值乘以其数量的倒数。人口中的例子。

cov(X, Y) = sum (x - E[X]) * (y - E[Y]) * 1/n

在统计学中，样本协方差可以以相同的方式计算，尽管具有偏差校正，与方差相同。

cov(X, Y) = sum (x - E[X]) * (y - E[Y]) * 1/(n - 1)

协方差的符号可以解释为两个变量是一起增加（正）还是一起减少（负）。协方差的大小不容易解释。协方差值为零表示两个变量完全独立。

NumPy 没有直接计算两个变量之间协方差的函数。相反，它具有计算称为 cov（）的协方差矩阵的函数，我们可以使用它来检索协方差。默认情况下，cov（）函数将计算所提供的随机变量之间的无偏或样本协方差。

下面的例子定义了两个相等长度的向量，一个增加，一个减少。我们预计这些变量之间的协方差是负的。

我们只访问两个变量的协方差，因为返回了方差协方差矩阵的[0,1]元素。

from numpy import array
from numpy import cov
x = array([1,2,3,4,5,6,7,8,9])
print(x)
y = array([9,8,7,6,5,4,3,2,1])
print(y)
Sigma = cov(x,y)[0,1]
print(Sigma)

首先运行该示例打印两个向量，然后是两个向量中的值的协方差。正如我们预期的那样，价值是负的。

[1 2 3 4 5 6 7 8 9]
[9 8 7 6 5 4 3 2 1]

-7.5

可以将协方差归一化为-1 和 1 之间的分数，以通过将其除以 X 和 Y 的标准偏差来解释幅度。结果称为变量的相关性，也称为 Pearson 相关系数，命名为该方法的开发者。

r = cov(X, Y) / sX sY

其中 r 是 X 和 Y 的相关系数，cov（X，Y）是 X 和 Y 的样本协方差，sX​​和 sY 分别是 X 和 Y 的标准偏差。

NumPy 提供了 corrcoef（）函数，用于直接计算两个变量之间的相关性。与 cov（）一样，它返回一个矩阵，在本例中是一个相关矩阵。与 cov（）的结果一样，我们只能从返回的平方矩阵的[0,1]值中获取感兴趣的相关性。

from numpy import array
from numpy import corrcoef
x = array([1,2,3,4,5,6,7,8,9])
print(x)
y = array([9,8,7,6,5,4,3,2,1])
print(y)
Sigma = corrcoef(x,y)
print(Sigma)

首先运行该示例打印两个定义的向量，然后打印相关系数。我们可以看到，向量与我们设计的最大负相关。

[1 2 3 4 5 6 7 8 9]
[9 8 7 6 5 4 3 2 1]

-1.0

协方差矩阵

协方差矩阵是方形和对称矩阵，其描述两个或更多个随机变量之间的协方差。

协方差矩阵的对角线是每个随机变量的方差。

协方差矩阵是两个变量的协方差的推广，并且捕获数据集中的所有变量可以一起改变的方式。

协方差矩阵表示为大写希腊字母 Sigma。如上计算每对随机变量的协方差。

Sigma = E[(X - E[X] . (Y - E[Y])]

哪里：

Sigma(ij) = cov(Xi, Xj)

X 是一个矩阵，每列代表一个随机变量。

协方差矩阵为分离随机变量矩阵中的结构关系提供了有用的工具。这可以用于解相关变量或作为变换应用于其他变量。它是主成分分析数据简化方法中使用的关键元素，简称 PCA。

可以使用 cov（）函数在 NumPy 中计算协方差矩阵。默认情况下，此函数将计算样本协方差矩阵。

可以使用包含用于计算协方差矩阵的列的单个矩阵来调用 cov（）函数，或者使用两个数组（例如每个变量一个数组）来调用 cov（）函数。

下面是一个定义两个 9 元素向量并从中计算无偏协方差矩阵的示例。

from numpy import array
from numpy import cov
x = array([1,2,3,4,5,6,7,8,9])
print(x)
y = array([9,8,7,6,5,4,3,2,1])
print(y)
Sigma = cov(x,y)
print(Sigma)

首先运行该示例打印两个向量，然后打印计算的协方差矩阵。

设计数组的值使得当一个变量增加时，另一个变量减少。我们期望在这两个变量的协方差上看到负号，这就是我们在协方差矩阵中看到的。

[1 2 3 4 5 6 7 8 9]

[9 8 7 6 5 4 3 2 1]

[[ 7.5 -7.5]
 [-7.5  7.5]]

协方差矩阵广泛用于线性代数和线性代数与统计的交集，称为多变量分析。我们在这篇文章中只有一点点品味。

扩展

本节列出了一些扩展您可能希望探索的教程的想法。

• 使用您自己的小型人为数据探索每个示例。
• 从 CSV 文件加载数据并将每个操作应用于数据列。
• 编写自己的函数来实现每个统计操作。

如果你探索任何这些扩展，我很想知道。

进一步阅读

如果您希望深入了解，本节将提供有关该主题的更多资源。

图书

• 应用多变量统计分析，2012。
• 应用多变量统计分析，2015 年。
• 第十二章概率中的线性代数＆amp;统计学，线性代数导论，第五版，2016 年。
• 第三章，概率论和信息论，深度学习，2016 年。

API

• NumPy 统计函数
• numpy.mean（）API
• numpy.var（）API
• numpy.std（）API
• numpy.cov（）API
• numpy.corrcoef（）API

用品

• 维基百科的期望值
• 维基百科上的意思
• 维基百科上的差异
• 维基百科的标准偏差
• 维基百科上的协方差
• 样本均值和协方差
• Pearson 相关系数
• 维基百科上的协方差矩阵
• 维基百科上协方差矩阵的估计

帖子

• 什么是协方差矩阵？ ，2016 年
• 协方差矩阵的几何解释，2014。

摘要

在本教程中，您了解了基本的统计操作如何工作以及如何使用 NumPy 以及线性代数中的符号和术语来实现它们。

具体来说，你学到了：

• 那么期望值，平均值和平均值以及如何计算。
• 方差和标准偏差是什么以及如何计算它们。
• 协方差，相关性和协方差矩阵是什么以及如何计算它们。

你有任何问题吗？ 在下面的评论中提出您的问题，我会尽力回答。