知识点

标量

简单操作：

$c = a + b$
$c = a \cdot b$
$c = sin a$

长度：

∣ a ∣ = {a, - a, a \geq 0 a < 0

$∣ a + b ∣ \leq ∣ a ∣ + ∣ b ∣$
$∣ a \cdot b ∣ = ∣ a ∣ \cdot ∣ b ∣$

向量

简单操作：

$c = a + b w h ere c_{i} = a_{i} + b_{i}$
$c = α \cdot b w h ere c_{i} = α b_{i}$
$c = sin a w h ere c_{i} = sin a_{i}$

长度：

∣∣ a ∣ ∣_{2} = i = 1 \sum n a_{i}^{2}

$∣∣ a ∣∣ \geq 0 f or a ll a$
$∣∣ a + b ∣∣ \leq ∣∣ a ∣∣ + ∣∣ b ∣∣$
$∣∣ α \cdot b ∣∣ = ∣ α ∣ \cdot ∣∣ b ∣∣$

直观理解：

数学家的“数学家的并行 for loop”

点乘：

a^{T} b = i \sum a_{i} b_{i}

正交时点乘等于 0：

a^{T} b = i \sum a_{i} b_{i} = 0

矩阵

简单操作：

$C = A + B w h ere C_{ij} = A_{ij} + B_{ij}$
$C = α \cdot B w h ere C_{ij} = α B_{ij}$
$C = sin A w h ere C_{ij} = sin A_{ij}$

矩阵乘以向量：

C = A b w h ere c_{i} = j \sum A_{ij} b_{j}

矩阵乘法在几何上就是空间扭曲：将一个向量扭曲到另一个地方

矩阵乘以矩阵：

C = A B w h ere C_{ik} = j \sum A_{ij} B_{jk}

范数：

c = A \cdot b h e n ce ∣∣ c ∣∣ \leq ∣∣ A ∣∣ \cdot ∣∣ b ∣∣

取决于如何衡量 b 和 c 的长度，常见范数：

矩阵范数：最小的满足的上面公式的值
Frobenius 范数

∣∣ A ∣ ∣_{F ro b} = ij \sum A_{ij}^{2}

特殊矩阵

对称和反对称：

对称： $A_{ij} = A ji$
反对称： $A_{ij} = - A ji$

正定：正定矩阵乘任何一个列向量和一个行向量，都大于等于 0

∣∣ x ∣ ∣^{2} = x^{T} x \geq 0 g e n er a l i zes t o x^{T} A x \geq 0

正交矩阵：

所以行都相互正交
所有行都有单位长度： $U w i t h \sum_{j} U_{ij} U_{kj} = δ_{ik}$
可以写成 $U U^{T} = 1$

置换矩阵：

P w h ere P_{ij} = 1 i f an d o n l y i f j = π (i)

置换矩阵是正交矩阵

特征向量和特征值：

不被矩阵改变方向的向量（方向不变，大小可变）
对称矩阵总是可以找到特征向量

代码

标量

标量由只有一个元素的张量表示

import torch
 
x = torch.tensor(3.0)
y = torch.tensor(2.0)
 
x + y, x * y, x / y, x**y
'''
(tensor(5.), tensor(6.), tensor(1.5000), tensor(9.))
'''

向量

向量可以被视为标量值组成的列表

x = torch.arange(4)
x
'''
tensor([0, 1, 2, 3])
'''

通过张量的索引来访问任一元素

x[3]
'''
tensor(3)
'''

访问张量的长度

len(x)
'''
4
'''

只有一个轴的张量，形状只有一个元素

x.shape
'''
torch.Size([4])
'''

矩阵

通过指定两个分量和来创建一个形状为 m x n 的矩阵

A = torch.arange(20).reshape(5, 4)
A
'''
tensor([[ 0,  1,  2,  3],
        [ 4,  5,  6,  7],
        [ 8,  9, 10, 11],
        [12, 13, 14, 15],
        [16, 17, 18, 19]])
'''

矩阵的转置

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

对称矩阵（symmetric matrix） $A$ 等于其转置： $A = A^{⊤}$

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

张量

就像向量是标量的推广，矩阵是向量的推广一样，我们可以构建具有更多轴的数据结构

X = torch.arange(24).reshape(2, 3, 4)
X
'''
tensor([[[ 0,  1,  2,  3],
         [ 4,  5,  6,  7],
         [ 8,  9, 10, 11]],
 
        [[12, 13, 14, 15],
         [16, 17, 18, 19],
         [20, 21, 22, 23]]])
'''

给定具有相同形状的任意两个张量，任何按元素二元运算的结果都将是相同形状的张量

A = torch.arange(20, dtype=torch.float32).reshape(5, 4)
B = A.clone()  # 通过分配新内存，将 A 的一个副本分配给 B
A, A + B
'''
(tensor([[ 0.,  1.,  2.,  3.],
         [ 4.,  5.,  6.,  7.],
         [ 8.,  9., 10., 11.],
         [12., 13., 14., 15.],
         [16., 17., 18., 19.]]),
 tensor([[ 0.,  2.,  4.,  6.],
         [ 8., 10., 12., 14.],
         [16., 18., 20., 22.],
         [24., 26., 28., 30.],
         [32., 34., 36., 38.]]))
'''

两个矩阵的按元素乘法称为 哈达玛积（Hadamard product），数学符号为 $⊙$

A * B
'''
tensor([[  0.,   1.,   4.,   9.],
        [ 16.,  25.,  36.,  49.],
        [ 64.,  81., 100., 121.],
        [144., 169., 196., 225.],
        [256., 289., 324., 361.]])
'''

将张量乘以或加上一个标量不会改变张量的形状，其中张量的每个元素都将与标量相加或相乘

a = 2
X = torch.arange(24).reshape(2, 3, 4)
a + X, (a * X).shape
'''
(tensor([[[ 2,  3,  4,  5],
          [ 6,  7,  8,  9],
          [10, 11, 12, 13]],
 
         [[14, 15, 16, 17],
          [18, 19, 20, 21],
          [22, 23, 24, 25]]]),
 torch.Size([2, 3, 4]))
'''

降维

计算其元素的和

x = torch.arange(4, dtype=torch.float32)
x, x.sum()
'''
(tensor([0., 1., 2., 3.]), tensor(6.))
'''

表示任意形状张量的元素和

A.shape, A.sum()
'''
(torch.Size([5, 4]), tensor(190.))
'''

指定张量沿哪一个轴来通过求和降低维度

A_sum_axis0 = A.sum(axis=0)
A_sum_axis0, A_sum_axis0.shape
'''
(tensor([40., 45., 50., 55.]), torch.Size([4]))
'''

A_sum_axis1 = A.sum(axis=1)
A_sum_axis1, A_sum_axis1.shape
'''
(tensor([ 6., 22., 38., 54., 70.]), torch.Size([5]))
'''

A.sum(axis=[0, 1])  # 结果和 A.sum() 相同
'''
tensor(190.)
'''

一个与求和相关的量是平均值（mean 或 average）

A.mean(), A.sum() / A.numel()
'''
(tensor(9.5000), tensor(9.5000))
'''

同样，计算平均值的函数也可以沿指定轴降低张量的维度

A.mean(axis=0), A.sum(axis=0) / A.shape[0]
'''
(tensor([ 8.,  9., 10., 11.]), tensor([ 8.,  9., 10., 11.]))
'''

非降维求和

计算总和或均值时保持轴数不变

sum_A = A.sum(axis=1, keepdims=True)
sum_A
'''
tensor([[ 6.],
        [22.],
        [38.],
        [54.],
        [70.]])
'''

通过广播将 A 除以 sum_A

A / sum_A
'''
tensor([[0.0000, 0.1667, 0.3333, 0.5000],
        [0.1818, 0.2273, 0.2727, 0.3182],
        [0.2105, 0.2368, 0.2632, 0.2895],
        [0.2222, 0.2407, 0.2593, 0.2778],
        [0.2286, 0.2429, 0.2571, 0.2714]])
'''

某个轴计算 A 元素的累积总和

A, A.cumsum(axis=0)
'''
(tensor([[ 0.,  1.,  2.,  3.],
         [ 4.,  5.,  6.,  7.],
         [ 8.,  9., 10., 11.],
         [12., 13., 14., 15.],
         [16., 17., 18., 19.]]),
 tensor([[ 0.,  1.,  2.,  3.],
         [ 4.,  6.,  8., 10.],
         [12., 15., 18., 21.],
         [24., 28., 32., 36.],
         [40., 45., 50., 55.]]))
'''

图解

Transclude of 按特定轴求和.excalidraw

A.sum(axis=n) 就消除掉第 n 维：

shape：[2, 5, 4]
axis=1：[2, 4]
axis=2：[2, 5]
axis=[1, 2]：[2]

A.sum(axis=n, , keepdims=True) 就把第 n 维变成 1：

shape：[2, 5, 4]
axis=1：[2, 1, 4]
axis=2：[2, 5, 1]
axis=[1, 2]：[2, 1, 1]

向量点积（Dot Product）

向量点积是相同位置的按元素乘积的和

y = torch.ones(4, dtype = torch.float32)
x, y, torch.dot(x, y), x @ y
'''
(tensor([0., 1., 2., 3.]), tensor([1., 1., 1., 1.]), tensor(6.), tensor(6.))
'''

可以通过执行按元素乘法，然后进行求和来表示两个向量的点积

torch.sum(x * y)
'''
tensor(6.)
'''

矩阵-向量点积

A.shape, x.shape, torch.mv(A, x), A @ x
'''
(torch.Size([5, 4]),
 torch.Size([4]),
 tensor([ 14.,  38.,  62.,  86., 110.]),
 tensor([ 14.,  38.,  62.,  86., 110.]))
'''

矩阵点积

或者叫矩阵乘法

B = torch.ones(4, 3)
torch.mm(A, B), A @ B
'''
(tensor([[ 6.,  6.,  6.],
         [22., 22., 22.],
         [38., 38., 38.],
         [54., 54., 54.],
         [70., 70., 70.]]),
 tensor([[ 6.,  6.,  6.],
         [22., 22., 22.],
         [38., 38., 38.],
         [54., 54., 54.],
         [70., 70., 70.]]))
'''

范数

$L_{2}$ 范数是向量元素平方和的平方根

∥ x ∥_{2} = i = 1 \sum n x_{i}^{2}

在 $L_{2}$ 范数中常常省略下标 $2$ ，也就是说 $∥ x ∥$ 等同于 $∥ x ∥_{2}$

u = torch.tensor([3.0, -4.0])
torch.norm(u)
'''
tensor(5.)
'''

$L_{1}$ 范数，它表示为向量元素的绝对值之和

∥ x ∥_{1} = i = 1 \sum n ∣ x_{i} ∣

torch.abs(u).sum()
'''
tensor(7.)
'''

矩阵 $X \in R^{m \times n}$ 的 Frobenius 范数（Frobenius norm）是矩阵元素平方和的平方根

∥ X ∥_{F} = i = 1 \sum m j = 1 \sum n x_{ij}^{2}

torch.norm(torch.ones((4, 9)))
'''
tensor(6.)
'''

My-Notes

全部文章

005.线性代数

知识点

标量

向量

矩阵

特殊矩阵

代码

标量

向量

矩阵

张量

降维

非降维求和

图解

向量点积（Dot Product）

矩阵-向量点积

矩阵点积

范数

目录

关系图谱