深度学习线性代数简明教程

 作者：Vihar Kurama

编译：weakish

编者按：Python软件基金会成员（Contibuting Member）Vihar Kurama简要介绍了深度学习算法背后的数学。

深度学习（Deep Learning）是机器学习的子领域。而线性代数（linear algebra）是有关连续值的数学。许多计算机科学家在此方面经验不足（传统上计算机科学更偏重离散数学）。想要理解和使用许多机器学习算法，特别是深度学习算法，对线性代数的良好理解是不可或缺的。

为什么要学数学？

线性代数、概率论和微积分是确切地表达机器学习的“语言”。学习这些主题有助于形成对机器学习算法底层机制的深入理解，也有助于开发新的算法。

如果我们查看的尺度足够小，那么深度学习背后的一切都是数学。所以在开始深度学习之前，有必要理解基本的线性代数。

标量、向量、矩阵、张量；图片来源：hadrienj.github.io

深度学习背后的核心数据结构是标量（Scalar）、向量（Vector）、矩阵（Matrix）、张量（Tensor）。让我们通过编程，使用这些数据结构求解基本的线性代数问题。

标量

标量是单个数字，或者说，0阶（0th-order）张量。x ∈ ℝ表示x是一个属于实数集ℝ的标量。

在深度学习中，有不同的数字集合。ℕ表示正整数集（1,2,3,…）。ℤ表示整数集，包括正数、负数和零。ℚ表示有理数集（可以表达为两个整数之比的数）。

在Python中有几个内置的标量类型：int、float、complex、bytes、Unicode。Numpy又增加了二十多个新的标量类型。

import numpy as np
np.ScalarType

返回：

(int,
 float,
 complex,
 int,
 bool,
 bytes,
 str,
 memoryview,
 numpy.bool_,
 numpy.int8,
 numpy.uint8,
 numpy.int16,
 numpy.uint16,
 numpy.int32,
 numpy.uint32,
 numpy.int64,
 numpy.uint64,
 numpy.int64,
 numpy.uint64,
 numpy.float16,
 numpy.float32,
 numpy.float64,
 numpy.float128,
 numpy.complex64,
 numpy.complex128,
 numpy.complex256,
 numpy.object_,
 numpy.bytes_,
 numpy.str_,
 numpy.void,
 numpy.datetime64,
 numpy.timedelta64)

其中，以下划线（_）结尾的数据类型和对应的Python内置类型基本上是等价的。

在Python中定义标量和一些运算

下面的代码演示了一些张量的算术运算。

a = 5
b = 7.5
print(type(a))
print(type(b))
print(a + b)
print(a - b)
print(a * b)
print(a / b)

输出：

<class 'int'>
<class 'float'>
12.5
-2.5
37.5
0.6666666666666666

下面的代码段检查给定的变量是否是标量：

import numpy as np
def isscalar(num):
    if isinstance(num, generic):
        return True
    else:
        return False
print(np.isscalar(3.1))
print(np.isscalar([3.1]))
print(np.isscalar(False))

输出：

True
False
True

向量

向量是由单个数字组成的有序数组，或者说，1阶张量。向量是向量空间这一对象的组成部分。向量空间是特定长度（又叫维度）的所有可能的向量的整个集合。三维实数向量空间（ℝ3）常用于表示现实世界中的三维空间。

为了指明向量的分量（component），向量的第i个标量元素记为x[i]。

在深度学习中，向量通常用来表示特征向量。

在Python中定义向量和一些运算

声明向量：

x = [1, 2, 3]
y = [4, 5, 6]
print(type(x))

输出：

<class 'list'>

+并不表示向量的加法，而是列表的连接：

print(x + y)

输出：

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

需要使用Numpy进行向量加法：

z = np.add(x, y)
print(z)
print(type(z))

输出：

[5 7 9]
<class 'numpy.ndarray'>

向量的叉积（cross product）

两个向量的叉积向量，大小等于以这两个向量为邻边的平行四边形面积，方向与这两个向量所在平面垂直：

图片来源：维基百科

np.cross(x, y)

返回：

[-3  6 -3]

向量的点积（dot product）

向量的点积为标量，对于给定长度但方向不同的两个向量而言，方向差异越大，点积越小。

图片来源：betterexplained.com

np.dot(x, y)

返回：

32

矩阵

矩阵是由数字组成的矩形数组，或者说，2阶张量。如果m和n为正整数，即，m, n ∈ ℕ，那么，一个m x n矩阵包含m * n个数字，m行n列。

m x n可表示为以下形式：

有时简写为：

在Python中定义矩阵和一些运算

在Python中，我们使用numpy库创建n维数组，也就是矩阵。我们将列表传入matrix方法，以定义矩阵。

x = np.matrix([[1,2],[3,4]])
x

返回：

matrix([[1, 2],
        [3, 4]])

矩阵第0轴的元素均值：

x.mean(0)

返回：

matrix([[2., 3.]]) # (1+3)/2, (3+4)/2

矩阵第1轴的元素均值：

x.mean(1)

返回：

z = x.mean(1)
z

返回：

matrix([[1.5],   # (1+2)/2
        [3.5]])  # (3+4)/2

shape属性返回矩阵的形状：

z.shape

返回：

(2, 1)

所以，矩阵z有2行1列。

顺便提下，向量的shape属性返回由单个数字（向量的长度）组成的元组：

np.shape([1, 2, 3])

返回：

(3,)

而标量的shape属性返回一个空元祖：

np.shape(1)

返回：

()

矩阵加法和乘法

矩阵可以和标量及其他矩阵相加、相乘。这些运算在数学上都有精确的定义。机器学习和深度学习经常使用这些运算，所以有必要熟悉这些运算。

对矩阵求和：

x = np.matrix([[1, 2], [4, 3]])
x.sum()

返回：

10

矩阵-标量加法

在矩阵的每个元素上加上给定标量：

x = np.matrix([[1, 2], [4, 3]])
x + 1

返回：

matrix([[2, 3],
        [5, 4]])

矩阵-标量乘法

类似地，矩阵-标量乘法就是在矩阵的每个元素上乘以给定标量：

x * 3

返回：

matrix([[ 3,  6],
        [12,  9]])

矩阵-矩阵加法

形状相同的矩阵才能相加。两个矩阵对应位置的元素之和作为新矩阵的元素，而新矩阵的形状和原本两个矩阵一样。

x = np.matrix([[1, 2], [4, 3]])
y = np.matrix([[3, 4], [3, 10]])

x和y的形状均为(2, 2)。

x + y

返回：

matrix([[ 4,  6],
        [ 7, 13]])

矩阵-矩阵乘法

形状为m x n的矩阵与形状为n x p的矩阵相乘，得到形状为m x p的矩阵。

图片来源：hadrienj.github.io

从编程的角度，矩阵乘法的一个直观解释是，一个矩阵是数据，另一个矩阵是即将应用于数据的函数（操作）：

图片来源：betterexplained.com

x = np.matrix([[1, 2], [3, 4], [5, 6]])
y = np.matrix([[7], [13]]
x * y

返回：

matrix([[ 33],
        [ 73],
        [113]])

上面的代码中，矩阵x的形状为(3, 2)，矩阵y的形状为(2, 1)，故所得矩阵的形状为(3, 1)。如果x的列数不等于y的行数，则x和y不能相乘，强行相乘会报错shapes not aligned。

矩阵转置

矩阵转置交换原矩阵的行和列（行变为列，列变为行），即：

x = np.matrix([[1, 2], [3, 4], [5, 6]])
x

返回：

matrix([[1, 2],
        [3, 4],
        [5, 6]])

使用numpy提供的transpose()方法转置矩阵：

x.transpose()

返回：

matrix([[1, 3, 5],
        [2, 4, 6]])

张量

比标量、向量、矩阵更通用的是张量概念。在物理科学和机器学习中，有时有必要使用超过二阶的张量（还记得吗？标量、向量、矩阵分别可以视为0、1、2阶张量。）

图片来源：refactored.ai

在Python中定义张量和一些运算

张量当然也可以用numpy表示（超过二阶的张量不过是超过二维的数组）：

import numpy as np
t = np.array([
  [[1,2,3], [4,5,6], [7,8,9]],
  [[11,12,13], [14,15,16], [17,18,19]],
  [[21,22,23], [24,25,26], [27,28,29]],
  ])
t.shape

返回：

(3, 3, 3)

张量加法

s = np.array([
  [[1,2,3], [4,5,6], [7,8,9]],
  [[10, 11, 12], [13, 14, 15], [16, 17, 18]],
  [[19, 20, 21], [22, 23, 24], [25, 26, 27]],
])
s + t

返回：

array([[[ 2,  4,  6],
        [ 8, 10, 12],
        [14, 16, 18]],
       [[21, 23, 25],
        [27, 29, 31],
        [33, 35, 37]],
       [[40, 42, 44],
        [46, 48, 50],
        [52, 54, 56]]])

张量乘法

s * t得到的是阿达马乘积（Hadamard Product），也就是分素相乘（element-wise multiplication），将张量s和t中的每个元素相乘，所得乘积为结果张量对应位置的元素。

s * t

返回：

array([[[  1,   4,   9],
        [ 16,  25,  36],
        [ 49,  64,  81]],
       [[110, 132, 156],
        [182, 210, 240],
        [272, 306, 342]],
       [[399, 440, 483],
        [528, 575, 624],
        [675, 728, 783]]])

张量积（Tensor Product）需要使用numpy的tensordot方法计算。

图片来源：维基百科

计算s ⊗ t：

s = np.array([[[1, 2], [3, 4]]])
t = np.array([[[5, 6], [7, 8]]])
np.tensordot(s, t, 0)

返回：

array([[[[[[ 5,  6],
           [ 7,  8]]],
         [[[10, 12],
           [14, 16]]]],
        [[[[15, 18],
           [21, 24]]],
         [[[20, 24],
           [28, 32]]]]]])

其中，最后一个参数0表示求张量积。当该参数为1时，表示求张量的点积（tensor dot product），这一运算可以视为向量点积概念的推广；当该参数为2时，表示求张量的缩并（tensor double contraction），这一运算可以视为矩阵乘法概念的推广。

当然，由于张量常用于深度学习，因此我们也经常直接使用深度学习框架表达张量。比如，在PyTorch中，创建一个形状为(5, 5)的张量，然后用浮点数1填充该张量：

torch.ones(5, 5)

返回：

tensor([[ 1.,  1.,  1.,  1.,  1.],
        [ 1.,  1.,  1.,  1.,  1.],
        [ 1.,  1.,  1.,  1.,  1.],
        [ 1.,  1.,  1.,  1.,  1.],
        [ 1.,  1.,  1.,  1.,  1.]])