【深度学习】S2 数学基础 P1 线性代数（上）

基本数学对象

基本数学对象包含：

0维：标量与变量；
1维：向量；
2维：矩阵；

标量与变量

一个简单的温度转换计算表达式，
$\frac 5 9 (f-52)$

其中 c 代表摄氏度，而 f 代表华氏度。
而这个计算表达式中，数值 5、9、52 是标量值，而未知的标量值，即自变量 f 与因变量 c，都是变量值。

标量与变量在张量中，由只有一个元素的张量来表示。

import torch
# 实例化两个标量
x = torch.tensor(3.0)
y = torch.tensor(2.0)

# 执行算数运算
print("x+y=", x+y, "\nx*y=", x*y, '\nx/y=', x/y, '\nx**y=', x**y)

x+y= tensor(5.) 
x*y= tensor(6.) 
x/y= tensor(1.5000) 
x**y= tensor(9.)

P.S. 在线性代数中，标量与变量通常用小写不加粗的字母表示， $a$

向量

向量可以视为由一系列标量值组成的列表，这些标量值被称为向量的元素或者分量。当使用向量来表示数据集中的样本时，它们通常具有一定的现实意义。例如一个用于表征用户个人信息的样本可以使用向量表示用户的年龄、性别、收入等标量信息。

使用张量表示向量，通常使用一维张量；

import torch

x = torch.arange(4)
print(x)

tensor([0, 1, 2, 3])

索引： 访问向量中的元素，可以直接通过索引值来访问；

print(x[-1])

长度： 所谓向量的长度，指的是向量中标量的个数，通过 len() 函数获取；

print(len(x))

形状： 通过 .shape 属性访问向量的形状。形状是一个元素组，列出张量沿每个轴的长度（维数）。而对于只有一个轴的张量，其形状只有一个元素。

print(x.shape)

P.S. 在线性代数中，向量通常使用粗体小写字母表示： $\mathbf{a}$

矩阵

正如向量是将标量从零阶推广到一阶，矩阵则是将向量从一阶推广到二阶。矩阵 $\mathbf{A_{mn}}$ 由 $m$ 行 $n$ 列标量组成，其中每个元素 $a_{ij}$ 是矩阵中第 $i$ 行 $j$ 列元素。

使用张量表示矩阵，使用二维张量；

import torch

x = torch.arange(20).reshape(5, 4)
print(x)

tensor([[ 0,  1,  2,  3],
        [ 4,  5,  6,  7],
        [ 8,  9, 10, 11],
        [12, 13, 14, 15],
        [16, 17, 18, 19]])

索引： 访问矩阵中元素，通过行索引（ $i$ ）和列索引（ $j$ ）来访问矩阵中的标量元素 $a_{ij}$

# 访问第二行第三个元素
print(x[1][2])

转置： 交换矩阵的行和列称为矩阵的转置（ $\mathbf{A^T}$ ）。对于 $\mathbf{B}=\mathbf{A^T}$ ，有 $b_{ij}=a_{ji}$

print(x.T)

tensor([[ 0,  4,  8, 12, 16],
        [ 1,  5,  9, 13, 17],
        [ 2,  6, 10, 14, 18],
        [ 3,  7, 11, 15, 19]])

对称矩阵： 对称矩阵是特殊的方阵，方阵是特殊的矩阵。对于矩阵 $\mathbf{A_{mn}}$ ，有方阵（ $m = n$ ），对称矩阵（ $\mathbf{A}=\mathbf{A^T}$ ）

B = torch.tensor([[1, 2, 3],
                  [2, 0, 4],
                  [3, 4, 5]])

print(B == B.T)

tensor([[True, True, True],
        [True, True, True],
        [True, True, True]])

矩阵是很有用的数据结构，其中的行可对应于不同的数据样本，列对应着不同的属性。

张量

现实世界并非是单纯的二维世界。图片，通常由 RGB 三个颜色通道构成，这就需要一个三维的数据结构来表示。而张量，可以用来表示任意维度数的数据结构。例如：向量是一阶张量，矩阵是二阶张量。

张量算法有两个基本性质：

按元素运算： 两个张量按元素运算，要求其形状 shape 必须相同，张量中对应位置的标量将进行运算操作。

import torch

x = torch.tensor([1.0, 2, 4, 8])
y = torch.tensor([2, 2, 2, 2])
print("x=", x)
print("y=", y)
print("x+y=", x+y)

x= tensor([1., 2., 4., 8.])
y= tensor([2, 2, 2, 2])
x+y= tensor([ 3.,  4.,  6., 10.])

广播机制： 张量的广播机制用于将张量扩展，要求两个向量要分别满足形状（ $x$ , $y$ ）与（ $y$ , $z$ ）方才可以进行运算。

import torch

a = torch.arange(3).reshape(3, 1)
b = torch.arange(2).reshape(1, 2)

print("a=", a)
print("b=", b)
print("a*b=", a*b)

a= tensor([[0],
        [1],
        [2]])
b= tensor([[0, 1]])
a*b= tensor([[0, 0],
        [0, 1],
        [0, 2]])

更多关于张量的操作博文，请移步：【深度学习】S1 预备知识 P1 张量

降维求和

对于一个张量，我们可以使用函数 sum() 进行简答求和；

import torch

x = torch.arange(12).reshape(3, -1)
print(x)
print(x.sum())

tensor([[ 0,  1,  2,  3],
        [ 4,  5,  6,  7],
        [ 8,  9, 10, 11]])
tensor(66)

在默认情况下，调用求和函数会降低张量的维度直到变成一个标量。但是我们也可以通过 sum() 函数中的变量 axis= 来指定张量沿哪一个轴来进行求和操作。比如；

print(x.sum(axis=0))

tensor([[ 0,  1,  2,  3],
        [ 4,  5,  6,  7],
        [ 8,  9, 10, 11]])
tensor([12, 15, 18, 21])

通过在函数 sum() 中设置 axis= 参数，我们可以沿着二维张量的横坐标将其合并成一维的张量向量。

另外，针对多维张量，我们还可以通过将 axis 参数设置为一个数组，来实现同时降低多个维度到指定的维度。

print(x.sum(axis=[0, 1]))

tensor(66)

观察结果可知，数据维度降至默认的标量形式。

非降维求和

然而，在某些情况下，我们可能希望保留计算出的和的结果的原始维度，此时，在 sum(axis=) 函数中需要增加设置 keepdims 参数；

print(x.sum(axis=0))
print(x.sum(axis=0, keepdims=True))
# 打印维度信息
print((x.sum(axis=0)).shape)
print((x.sum(axis=0, keepdims=True)).shape)

tensor([12, 15, 18, 21])
tensor([[12, 15, 18, 21]])
# 维度信息
torch.Size([4])
torch.Size([1, 4])

观察两个结果的对比，明显可以看出它们的维度存在差异。

累计求和

使用 cumsum() 函数，可以实现张量在某一维度上的累加求和操作。

import torch

x = torch.arange(12).reshape(3, -1)
print(x)
print(x.cumsum(axis=0))

tensor([[ 0,  1,  2,  3],
        [ 4,  5,  6,  7],
        [ 8,  9, 10, 11]])
tensor([[ 0,  1,  2,  3],
        [ 4,  6,  8, 10],
        [12, 15, 18, 21]])

可以观察到，张量在其维度上进行逐层累加求和。如上，便是 cumsum() 函数。

点积与向量积

点积

点积（也称为内积）是指两个张量在对应位置上元素相乘后的和。

import torch

x = torch.arange(4, dtype=torch.float32)
y = torch.ones(4, dtype=torch.float32)
print("x=", x)
print("y=", y)
print(torch.dot(x, y))

x= tensor([0., 1., 2., 3.])
y= tensor([1., 1., 1., 1.])
tensor(6.)

上述结果： $6 = 0 * 1 + 1 * 1 + 2 * 1 + 3 * 1$

矩阵-向量积

矩阵向量积，指的是矩阵与向量的乘法，也就是将矩阵与向量相乘得到一个新的向量。

$e . g .$ 假设我们有矩阵 $\mathbf{A}$ 和向量 $\mathbf{v}$ ，其中 $\mathbf{A}$ 是一个 $m * n$ 矩阵， $\mathbf{v}$ 是一个 $n$ 维向量，那么它们的向量积 $\mathbf{Av}$ 是一个 $m$ 维向量；

在这里插入图片描述

读者可以借助以下张量的示例来增进理解。

在张量中，通过 mv() 函数来实现矩阵向量积；其中 $m$ 意味着矩阵 matrix， $v$ 意味着向量 vector；

import torch

x = torch.arange(20, dtype=torch.float32).reshape(5, 4)
y = torch.ones(4, dtype=torch.float32)
print("x=", x)
print("y=", y)
print(torch.mv(x, y))

x= tensor([[ 0.,  1.,  2.,  3.],
        [ 4.,  5.,  6.,  7.],
        [ 8.,  9., 10., 11.],
        [12., 13., 14., 15.],
        [16., 17., 18., 19.]])
y= tensor([1., 1., 1., 1.])
tensor([ 6., 22., 38., 54., 70.])

矩阵-矩阵乘法

矩阵与矩阵乘法，可以看作简单地执行多次矩阵-向量积，并将结果拼接在一起形成矩阵。假设有两个矩阵 $\mathbf{A}$ 和 $\mathbf{B}$ ，其中 $\mathbf{A}$ 是一个 $m \times n$ 的矩阵， $\mathbf{B}$ 是一个 $n \times p$ 的矩阵，那么它们的乘积 $C = A \times B$ 是一个 $m \times p$ 的矩阵。

在这里插入图片描述

$e . g .$ 矩阵-矩阵乘法使用 mm() 函数实现；

import torch

x = torch.arange(20, dtype=torch.float32).reshape(5, 4)
y = torch.ones(12, dtype=torch.float32).reshape(4, 3)
print("x=", x)
print("y=", y)
print(torch.mm(x, y))

x= tensor([[ 0.,  1.,  2.,  3.],
        [ 4.,  5.,  6.,  7.],
        [ 8.,  9., 10., 11.],
        [12., 13., 14., 15.],
        [16., 17., 18., 19.]])
y= tensor([[1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.]])
tensor([[ 6.,  6.,  6.],
        [22., 22., 22.],
        [38., 38., 38.],
        [54., 54., 54.],
        [70., 70., 70.]])