Press "Enter" to skip to content

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

本站内容均来自兴趣收集,如不慎侵害的您的相关权益,请留言告知,我们将尽快删除.谢谢.

深度学习(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 npnp.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 = 5b = 7.5print(type(a))print(type(b))print(a + b)print(a - b)print(a * b)print(a / b)

输出:

<class 'int'><class 'float'>12.5-2.537.50.6666666666666666

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

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

输出:

TrueFalseTrue

向量

向量是由单个数字组成的有序数组,或者说,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 npt = 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.]]

Be First to Comment

发表评论

电子邮件地址不会被公开。 必填项已用*标注