【动手学深度学习PyTorch】线性代数

飞Link

650人浏览 · 2025-09-29 10:16:15

飞Link · 2025-09-29 10:16:15 发布

线性代数

一、标量

严格来说，仅包含一个数值被称为标量（scalar）。

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

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.))

二、向量

1. 向量

[向量可以被视为标量值组成的列表]。
这些标量值被称为向量的元素（element）或分量（component）。

x = torch.arange(4)
x

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

我们可以使用下标来引用向量的任一元素，例如可以通过 $x_i$ 来引用第 $i$ 个元素。
在数学中，向量 $x\mathbf{x}$ 可以写为：

$x=[x1x2⋮xn],\mathbf{x} =\begin{bmatrix}x_{1} \\x_{2} \\ \vdots \\x_{n}\end{bmatrix},$

其中 $x1,…,xnx_1,\ldots,x_n$ 是向量的元素。在代码中，我们(通过张量的索引来访问任一元素)。

x[3]

tensor(3)

2. 长度、维度和形状

向量的长度通常称为向量的维度（dimension）。

与普通的Python数组一样，我们可以通过调用Python的内置len()函数来[访问张量的长度]。

len(x)

当用张量表示一个向量（只有一个轴）时，我们也可以通过.shape属性访问向量的长度。
形状（shape）是一个元素组，列出了张量沿每个轴的长度（维数）。
对于(只有一个轴的张量，形状只有一个元素。)

x.shape

torch.Size([4])

三、矩阵

矩阵，在代码中表示为具有两个轴的张量。

数学表示法使用 $A∈Rm×n\mathbf{A} \in \mathbb{R}^{m \times n}$ 来表示矩阵 $A\mathbf{A}$ ，其由 $m$ 行和 $n$ 列的实值标量组成。
我们可以将任意矩阵 $A∈Rm×n\mathbf{A} \in \mathbb{R}^{m \times n}$ 视为一个表格，其中每个元素 $a_{ij}$ 属于第 $i$ 行第 $j$ 列：

$A=[a11a12⋯a1na21a22⋯a2n⋮⋮⋱⋮am1am2⋯amn].\mathbf{A}=\begin{bmatrix} a_{11} & a_{12} & \cdots & a_{1n} \\ a_{21} & a_{22} & \cdots & a_{2n} \\ \vdots & \vdots & \ddots & \vdots \\ a_{m1} & a_{m2} & \cdots & a_{mn} \\ \end{bmatrix}.$

当矩阵具有相同数量的行和列时，其形状将变为正方形；因此，它被称为方阵（square matrix）。

[通过指定两个分量 $m$ 和 $n$ 来创建一个形状为 $\times 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]])

交换矩阵的行和列时，结果称为矩阵的转置（transpose）。通常用 $a⊤\mathbf{a}^\top$ 来表示矩阵的转置，如果 $B=A⊤\mathbf{B}=\mathbf{A}^\top$ ，则对于任意 $i$ 和 $j$ ，都有 $b_{ij}=a_{ji}$ 。
$\mathbf{A}^\top = \begin{bmatrix} a_{11} & a_{21} & \dots & a_{m1} \\ a_{12} & a_{22} & \dots & a_{m2} \\ \vdots & \vdots & \ddots & \vdots \\ a_{1n} & a_{2n} & \dots & a_{mn} \end{bmatrix}.$

矩阵的转置

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\mathbf{A}$ 等于其转置： $A=A⊤\mathbf{A} = \mathbf{A}^\top$

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

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

现在我们将B与它的转置进行比较。

B == B.T

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

四、张量

张量是描述具有任意数量轴的 $n$ 维数组的通用方法。

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积（Hadamard product）（数学符号 $⊙\odot$ ）]
矩阵和 $B\mathbf{B}$ 的Hadamard积为：
$\mathbf{A} \odot \mathbf{B} = \begin{bmatrix} a_{11} b_{11} & a_{12} b_{12} & \dots & a_{1n} b_{1n} \\ a_{21} b_{21} & a_{22} b_{22} & \dots & a_{2n} b_{2n} \\ \vdots & \vdots & \ddots & \vdots \\ a_{m1} b_{m1} & a_{m2} b_{m2} & \dots & a_{mn} b_{mn} \end{bmatrix}.$

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.))

[指定张量沿哪一个轴来通过求和降低维度]。
以矩阵为例，为了通过求和所有行的元素来降维（轴0），可以在调用函数时指定axis=0。
由于输入矩阵沿0轴降维以生成输出向量，因此输入轴0的维数在输出形状中消失。

A_sum_axis0 = A.sum(axis=0)
A_sum_axis0, A_sum_axis0.shape

(tensor([40., 45., 50., 55.]), torch.Size([4]))

指定axis=1将通过汇总所有列的元素降维（轴1）。因此，输入轴1的维数在输出形状中消失。

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.)

[计算张量的平均值]

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.]])

由于sum_A在对每行进行求和后仍保持两个轴，我们可以(通过广播将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元素的累积总和]
比如axis=0（按行计算），可以调用cumsum函数。
此函数不会沿任何轴降低输入张量的维度。

A.cumsum(axis=0)

tensor([[ 0.,  1.,  2.,  3.],
        [ 4.,  6.,  8., 10.],
        [12., 15., 18., 21.],
        [24., 28., 32., 36.],
        [40., 45., 50., 55.]])

七、点积（Dot Product）

给定两个向量 $x,y∈Rd\mathbf{x},\mathbf{y}\in\mathbb{R}^d$ ，它们的点积（dot product） $x⊤y\mathbf{x}^\top\mathbf{y}$ （或 $⟨x,y⟩\langle\mathbf{x},\mathbf{y}\rangle$ ）
是相同位置的按元素乘积的和： $x⊤y=∑i=1dxiyi\mathbf{x}^\top \mathbf{y} = \sum_{i=1}^{d} x_i y_i$ 。

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

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

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

torch.sum(x * y)

tensor(6.)

当权重为非负数且和为1（即 $(∑i=1dwi=1)\left(\sum_{i=1}^{d}{w_i}=1\right)$ ）时，点积表示加权平均（weighted average）。
将两个向量规范化得到单位长度后，点积表示它们夹角的余弦。

八、矩阵-向量积

在代码中使用mv函数执行矩阵-向量积操作

当我们为矩阵A和向量x调用torch.mv(A, x)时，会执行矩阵-向量积。
注意，A的列维数（沿轴1的长度）必须与x的维数（其长度）相同。

A.shape, x.shape, torch.mv(A, x)

(torch.Size([5, 4]), torch.Size([4]), tensor([ 14.,  38.,  62.,  86., 110.]))

九、矩阵-矩阵乘法

在代码中使用mm函数执行矩阵-矩阵乘法操作

在A和B上执行矩阵乘法。这里的A是一个5行4列的矩阵，B是一个4行3列的矩阵。两者相乘后，我们得到了一个5行3列的矩阵。

B = torch.ones(4, 3)
torch.mm(A, B)

tensor([[ 6.,  6.,  6.],
        [22., 22., 22.],
        [38., 38., 38.],
        [54., 54., 54.],
        [70., 70., 70.]])

矩阵-矩阵乘法可以简单地称为矩阵乘法，不应与"Hadamard积"混淆。

范数

几级范数就是x的绝对值的几次方求和然后再开几次方

欧几里得距离是一个 $L_2$ 范数：
假设 $n$ 维向量 $x\mathbf{x}$ 中的元素是 $x1,…,xnx_1,\ldots,x_n$ ，其[ $L_2$ 范数是向量元素平方和的平方根：]

( $∥x∥2=∑i=1nxi2,\|\mathbf{x}\|_2 = \sqrt{\sum_{i=1}^n x_i^2},$ )

# 计算L2范数
u = torch.tensor([3.0, -4.0])
torch.norm(u)

tensor(5.)

$L_1$ 范数表示为向量元素的绝对值之和

( $∥x∥1=∑i=1n∣xi∣.\|\mathbf{x}\|_1 = \sum_{i=1}^n \left|x_i \right|.$ )

# 计算L1范数
torch.abs(u).sum()

tensor(7.)

$L_2$ 范数和 $L_1$ 范数都是更一般的 $L_p$ 范数的特例：

$∥x∥p=(∑i=1n∣xi∣p)1/p.\|\mathbf{x}\|_p = \left(\sum_{i=1}^n \left|x_i \right|^p \right)^{1/p}.$

类似于向量的 $L_2$ 范数，[矩阵] $X∈Rm×n\mathbf{X} \in \mathbb{R}^{m \times n}$ (的Frobenius范数（Frobenius norm）是矩阵元素平方和的平方根：)

( $∥X∥F=∑i=1m∑j=1nxij2.\|\mathbf{X}\|_F = \sqrt{\sum_{i=1}^m \sum_{j=1}^n x_{ij}^2}.$ )

Frobenius范数满足向量范数的所有性质，它就像是矩阵形向量的 $L_2$ 范数。

# 计算矩阵的Frobenius范数
torch.norm(torch.ones((4, 9)))

tensor(6.)

小结

标量、向量、矩阵和张量是线性代数中的基本数学对象。
向量泛化自标量，矩阵泛化自向量。
标量、向量、矩阵和张量分别具有零、一、二和任意数量的轴。
一个张量可以通过sum和mean沿指定的轴降低维度。
两个矩阵的按元素乘法被称为他们的Hadamard积。它与矩阵乘法不同。
在深度学习中，我们经常使用范数，如 $L_1$ 范数、 $L_2$ 范数和Frobenius范数。
我们可以对标量、向量、矩阵和张量执行各种操作。

内容声明
本文基于开源教材《动手学深度学习》（Dive into Deep Learning, 作者：Aston Zhang、Zachary C. Lipton、Mu Li、Alexander J. Smola 等）整理，原始项目地址：https://github.com/d2l-ai/d2l-zh。
在整理过程中对部分内容进行了删改和补充，仅用于个人学习与交流，版权归原作者所有。