深度学习入门教程（三）- 线性代数教程

1. 特征值、特征向量基础概念

1.1 什么是特征向量和特征值

理论： 对于一个方阵A，如果存在非零向量v和标量λ，使得Av = λv，那么v称为A的特征向量，λ称为对应的特征值。

数学案例：

矩阵 A = [[3, 1], [0, 2]]，向量 v = [1, 0]

计算：Av = [[3, 1], [0, 2]] × [1, 0] = [3, 0] = 3 × [1, 0] = 3v

因此，v = [1, 0] 是特征向量，λ = 3 是特征值。

物理意义： 特征向量表示矩阵变换中"方向不变"的向量，特征值表示该方向上的缩放倍数。

案例：

在人脸识别中，特征向量代表主要面部特征方向
在数据压缩中，特征值大的方向保留更多信息
在机器学习中，PCA主成分分析就是基于特征值分解

1.2 特征向量的几何理解

理论： 当矩阵作用在向量上时，大多数向量的方向会发生改变，但特征向量只是被拉伸或压缩，方向保持不变。

数学案例：

矩阵 A = [[2, 1], [1, 2]]

普通向量 u = [1, 2]：Au = [4, 5]（方向改变）
特征向量 v = [1, 1]：Av = [3, 3] = 3[1, 1]（方向不变，只是缩放）

案例： 想象一个椭圆变换：

红色向量：方向和大小都改变 - 不是特征向量
绿色向量：只改变大小，方向不变 - 是特征向量

2. 标量运算

2.1 标量基础

理论： 标量是只有大小、没有方向的量，是0维张量。

数学案例：

标量 a = 5, b = 3

加法：a + b = 5 + 3 = 8
乘法：a × b = 5 × 3 = 15
除法：a ÷ b = 5 ÷ 3 = 1.67

案例： 温度、重量、价格等都是标量。

python 复制代码

import torch
x = torch.tensor([3.0])
y = torch.tensor([2.0])
print(x + y)  # 加法
print(x * y)  # 乘法
print(x / y)  # 除法
print(x ** y) # 幂运算

输出：

复制代码

tensor([5.])
tensor([6.])
tensor([1.5000])
tensor([9.])

应用场景： 学习率、损失函数值、准确率等都是标量。

3. 向量运算

3.1 向量基础概念

理论： 向量是具有大小和方向的量，是1维张量。向量可以表示为有序的标量序列。

数学案例：

向量 v = [3, 4]

长度：|v| = √(3² + 4²) = √(9 + 16) = √25 = 5
方向：从原点(0,0)指向点(3,4)
单位向量：v/|v| = [3/5, 4/5] = [0.6, 0.8]

几何意义： 向量可以看作从原点指向某个点的箭头。

案例：

物理：力、速度、加速度
机器学习：特征向量、词向量、梯度向量

3.2 向量的标量倍数

理论： 向量与标量相乘，结果是一个与原向量方向相同（或相反）的向量，长度发生改变。

数学表示： c = αb，其中α是标量，b是向量

数学案例：

向量 b = [2, 3]，标量 α = 2.5

结果：c = 2.5 × [2, 3] = [5, 7.5]
原向量长度：|b| = √(2² + 3²) = √13 ≈ 3.6
新向量长度：|c| = √(5² + 7.5²) = √81.25 ≈ 9.0 = 2.5 × 3.6

案例：

α > 1：向量拉长
0 < α < 1：向量缩短
α < 0：向量反向

4. 矩阵运算

4.1 矩阵基础概念

理论： 矩阵是二维数组，可以看作是向量的向量。矩阵用于表示线性变换。

数学案例：

矩阵 A = [[1, 2], [3, 4]]

行向量：第1行 = [1, 2]，第2行 = [3, 4]
列向量：第1列 = [1, 3]，第2列 = [2, 4]
元素：A[1,2] = 2，A[2,1] = 3

应用场景：

图像处理：图像是像素矩阵
神经网络：权重矩阵
数据分析：数据表格

4.2 矩阵范数

理论： 矩阵的范数用于衡量矩阵的"大小"或"长度"，是矩阵元素的某种度量。

数学案例：

矩阵 A = [[3, 4], [0, 5]]

F范数：||A||_F = √(3² + 4² + 0² + 5²) = √(9 + 16 + 0 + 25) = √50 ≈ 7.07
L1范数：||A||_1 = |3| + |4| + |0| + |5| = 12
L2范数：||A||_2 = √(3² + 4² + 0² + 5²) = √50 ≈ 7.07

重要性： 在机器学习中，范数常用于正则化，防止过拟合。

案例：

L1范数：权重稀疏化
L2范数：权重平滑化
F范数：整体矩阵大小度量

5. 线性代数PyTorch实现

5.1 标量操作

理论： 标量由只有一个元素的张量表示。

数学案例：

标量 x = 3.0, y = 2.0

加法：x + y = 3.0 + 2.0 = 5.0
乘法：x * y = 3.0 * 2.0 = 6.0
除法：x / y = 3.0 / 2.0 = 1.5
幂运算：x ** y = 3.0 ** 2.0 = 9.0

实际应用： 损失函数计算、学习率设置、阈值判断。

python 复制代码

import torch
x = torch.tensor([3.0])
y = torch.tensor([2.0])
print(x + y)
print(x * y)
print(x / y)
print(x ** y)

5.2 向量操作

5.2.1 创建向量

理论： 可以将向量视为标量值组成的列表。

数学案例：

向量 x = [0, 1, 2, 3]

包含4个元素
第1个元素：x[0] = 0
第4个元素：x[3] = 3
向量长度：4

案例： 创建特征向量、标签向量、权重向量等。

python 复制代码

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

输出：

复制代码

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

5.2.2 访问向量元素

理论： 通过索引访问向量中的特定元素。

数学案例：

向量 x = [10, 20, 30, 40]

访问第1个元素：x[0] = 10
访问第3个元素：x[2] = 30
访问最后一个元素：x[3] = 40
索引从0开始计数

实际应用： 提取特定特征、获取预测结果、调试模型参数。

python 复制代码

import torch
x = torch.arange(4)
print(x[3])  # 索引从0开始

输出：

复制代码

tensor(3)

5.2.3 向量长度

理论： 向量的长度表示向量中元素的个数。

数学案例：

向量 x = [1, 2, 3, 4, 5]

向量长度：len(x) = 5
表示这个向量有5个元素
注意：这里的"长度"是元素个数，不是向量的几何长度

应用： 确定特征维数、批处理大小、序列长度。

python 复制代码

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

输出：

复制代码

5.2.4 向量维度

理论： 向量的shape属性显示其维度信息。

数学案例：

向量 x = [1, 2, 3, 4]

形状：x.shape = (4,)
表示这是一个4维向量（4个元素）
括号中的逗号表示这是一个1维张量

重要性： 在深度学习中，维度匹配是关键，防止维度不匹配错误。

python 复制代码

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

输出：

复制代码

torch.Size([4])

5.3 矩阵操作

5.3.1 创建矩阵

理论： 通过指定行数m和列数n创建m×n矩阵。

数学案例：

创建3×4矩阵：

A = [[0, 1, 2, 3],

4, 5, 6, 7\], \[8, 9, 10, 11\]

3行4列，共12个元素
元素按行优先顺序排列：0到11

应用场景： 创建权重矩阵、数据批次、图像矩阵。

python 复制代码

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

输出：

复制代码

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

5.3.2 矩阵转置

理论： 矩阵转置是将矩阵的行和列互换。

数学表示： A^T，其中(AT){ij} = A{ji}

数学案例：

矩阵 A = [[1, 2, 3], [4, 5, 6]]

转置 A^T = [[1, 4], [2, 5], [3, 6]]

原矩阵：2×3矩阵
转置后：3×2矩阵
验证：A[1,3] = 3，A^T[3,1] = 3

应用： 神经网络中的权重转置、协方差矩阵计算。

python 复制代码

import torch
A = torch.arange(20).reshape(5,4)
print(A)
print(A.T)  # 矩阵转置

输出：

复制代码

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

5.3.3 对称矩阵

理论： 对称矩阵等于其转置，即A = A^T。

数学案例：

对称矩阵 A = [[2, 1, 3], [1, 4, 2], [3, 2, 5]]

转置 A^T = [[2, 1, 3], [1, 4, 2], [3, 2, 5]]
验证：A = A^T，A[1,2] = A[2,1] = 1，A[1,3] = A[3,1] = 3

重要性： 在机器学习中，许多矩阵（如协方差矩阵、核矩阵）都是对称的。

特性： 对称矩阵的特征值都是实数，特征向量相互正交。

python 复制代码

import torch
B = torch.tensor([[1,2,3],[2,0,4],[3,4,5]])
print(B)
print(B.T)
print(B == B.T)  # 检查是否对称

输出：

复制代码

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

5.3.4 多维张量

理论： 就像向量是标量的推广，矩阵是向量的推广一样，可以构建更多轴的数据结构。

数学案例：

3维张量 X = [[[1, 2], [3, 4]], [[5, 6], [7, 8]]]

形状：(2, 2, 2) - 2个2×2的矩阵
访问元素：X[0,1,0] = 3，X[1,0,1] = 6
可以理解为2张2×2的图像或特征图

应用：

3维：批处理的图像数据 (批次×高×宽)
4维：彩色图像批次 (批次×通道×高×宽)
5维：视频数据 (批次×时间×通道×高×宽)

python 复制代码

import torch
X = torch.arange(24).reshape(2,3,4)
print(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]]])

5.3.5 矩阵克隆

理论： 克隆创建矩阵的独立副本，修改副本不会影响原矩阵。

数学案例：

原矩阵 A = [[1, 2], [3, 4]]

克隆矩阵 B = A.clone() = [[1, 2], [3, 4]]

修改B[0,0] = 10 → B = [[10, 2], [3, 4]]
原矩阵A不变：A = [[1, 2], [3, 4]]

重要性： 在深度学习中，避免意外修改原始数据或模型参数。

python 复制代码

import torch
A = torch.arange(20,dtype=torch.float32).reshape(5,4)
B = A.clone()  # 创建独立副本
print(A)
print(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.]])

5.3.6 哈达玛积（逐元素相乘）

理论： 两个矩阵的逐元素相乘，也称为哈达玛积，符号为⊙。

数学案例：

矩阵 A = [[1, 2], [3, 4]]，矩阵 B = [[5, 6], [7, 8]]

哈达玛积：A⊙B = [[1×5, 2×6], [3×7, 4×8]] = [[5, 12], [21, 32]]

对应位置元素相乘：A[i,j] × B[i,j] = C[i,j]

应用：

注意力机制中的权重应用
特征选择和屏蔽
激活函数的逐元素操作

python 复制代码

import torch
A = torch.arange(20,dtype=torch.float32).reshape(5,4)
B = A.clone()
print(A)
print(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.,   1.,   4.,   9.],
        [ 16.,  25.,  36.,  49.],
        [ 64.,  81., 100., 121.],
        [144., 169., 196., 225.],
        [256., 289., 324., 361.]])

5.3.7 广播机制

理论： 广播允许不同形状的张量进行运算，自动扩展较小的张量。

数学案例：

矩阵 A = [[1, 2], [3, 4]]，标量 b = 5

广播相加：A + b = [[1+5, 2+5], [3+5, 4+5]] = [[6, 7], [8, 9]]

标量5自动扩展为 [[5, 5], [5, 5]] 参与运算

应用：

为整个矩阵添加偏置
标准化操作
节省内存和计算资源

python 复制代码

import torch
a = 2
X = torch.arange(24).reshape(2,3,4)
print(a + X)
print((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])

5.4 求和与平均值操作

5.4.1 向量求和

理论： 计算向量中所有元素的和。

数学案例：

向量 x = [1, 2, 3, 4]

求和：sum(x) = 1 + 2 + 3 + 4 = 10

这是一个标量结果

应用： 损失函数计算、统计分析、特征聚合。

python 复制代码

import torch
X = torch.arange(4,dtype=torch.float32)
print(X)
print(X.sum())

输出：

复制代码

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

5.4.2 矩阵求和

理论： 计算任意形状张量的所有元素和。

数学案例：

矩阵 A = [[1, 2], [3, 4]]

矩阵求和：sum(A) = 1 + 2 + 3 + 4 = 10

把所有元素加起来得到单个标量值

应用： 计算总损失、数据统计、模型评估。

python 复制代码

import torch
A = torch.arange(20*2).reshape(2,5,4)
print(A.shape)
print(A.sum())

输出：

复制代码

torch.Size([2, 5, 4])
tensor(780)

5.4.3 按轴求和（降维）

理论： 指定轴进行求和，会减少该轴的维度。

重要概念：

axis=0：对第一个维度求和
axis=1：对第二个维度求和
axis=[0,1]：对多个维度求和

数学案例：

矩阵 A = [[1, 2], [3, 4]]

axis=0求和：[1+3, 2+4] = [4, 6]（按列求和）
axis=1求和：[1+2, 3+4] = [3, 7]（按行求和）
全部求和：1+2+3+4 = 10

应用：

计算每个特征的总和
数据聚合
注意力权重归一化

python 复制代码

import torch
A = torch.arange(20*2).reshape(2,5,4)
print(A)
A_sum_axis0 = A.sum(axis=0)  # 对第一个维度求和
print(A_sum_axis0)
print(A_sum_axis0.shape)

输出：

复制代码

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],
         [24, 25, 26, 27],
         [28, 29, 30, 31],
         [32, 33, 34, 35],
         [36, 37, 38, 39]]])
tensor([[20, 22, 24, 26],
        [28, 30, 32, 34],
        [36, 38, 40, 42],
        [44, 46, 48, 50],
        [52, 54, 56, 58]])
torch.Size([5, 4])

5.4.4 平均值计算

理论： 平均值等于元素和除以元素个数。

数学案例：

矩阵 A = [[1, 2], [3, 4]]

总平均值：(1+2+3+4)/4 = 10/4 = 2.5
按列平均：[(1+3)/2, (2+4)/2] = [2, 3]
按行平均：[(1+2)/2, (3+4)/2] = [1.5, 3.5]

应用：

数据标准化
性能指标计算
特征统计

python 复制代码

import torch
A = torch.arange(20, dtype=torch.float32).reshape(5, 4)
print(A.mean())
print(A.numel())
print(A.sum()/A.numel())

输出：

复制代码

tensor(9.5000)
20
tensor(9.5000)

5.4.5 保持维度的求和

理论： 使用keepdims=True保持原始维度，便于后续广播操作。

数学案例：

矩阵 A = [[1, 2], [3, 4]]

普通按行求和：[1+2, 3+4] = [3, 7]（形状：[2]）
保持维度求和：[[1+2], [3+4]] = [[3], [7]]（形状：[2,1]）
便于后续广播：A/sum_A 可以直接进行

重要性： 在深度学习中，维度一致性非常重要，特别是在归一化和注意力机制中。

python 复制代码

import torch
A = torch.arange(20, dtype=torch.float32).reshape(5, 4)
sum_A = A.sum(axis=1, keepdims=True)
print(sum_A)
print(sum_A.shape)

输出：

复制代码

tensor([[ 6.],
        [22.],
        [38.],
        [54.],
        [70.]])
torch.Size([5, 1])

5.4.6 广播应用示例

理论： 利用keepdims保持的维度进行广播操作。

数学案例：

矩阵 A = [[1, 2], [3, 4]]，行和 sum_A = [[3], [7]]

广播除法：A/sum_A = [[1/3, 2/3], [3/7, 4/7]] = [[0.33, 0.67], [0.43, 0.57]]

每行都除以该行的总和，实现行归一化

应用：

行归一化
列归一化
概率分布归一化

python 复制代码

import torch
A = torch.arange(20, dtype=torch.float32).reshape(5, 4)
sum_A = A.sum(axis=1, keepdims=True)
print(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]])

5.4.7 累积求和

理论： 计算某个轴上的累积和，保持原始形状。

数学案例：

矩阵 A = [[1, 2], [3, 4]]

按行累积和（axis=0）：

第1行：[1, 2]
第2行：[1+3, 2+4] = [4, 6]
结果：[[1, 2], [4, 6]]

应用：

时间序列的累积统计
前缀和计算
渐进式数据分析

python 复制代码

import torch
A = torch.arange(20, dtype=torch.float32).reshape(5, 4)
print(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.]])

5.5 向量和矩阵的乘积运算

5.5.1 向量点积

理论： 点积是两个向量对应元素相乘后求和的结果。

数学表示： x·y = Σ(x_i * y_i)

数学案例：

向量 x = [1, 2, 3]，向量 y = [4, 5, 6]

点积：x·y = 1×4 + 2×5 + 3×6 = 4 + 10 + 18 = 32

几何验证：|x| = √14 ≈ 3.74，|y| = √77 ≈ 8.77
夹角：cos(θ) = 32/(3.74×8.77) ≈ 0.976

几何意义： 点积等于两向量长度的乘积再乘以夹角的余弦值。

应用：

相似度计算
投影长度计算
神经网络中的线性变换

python 复制代码

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

输出：

复制代码

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

等价计算：

python 复制代码

import torch
x = torch.arange(4,dtype=torch.float32)
y = torch.ones(4, dtype=torch.float32)
print(torch.sum(x*y))  # 等价于点积

输出：

复制代码

tensor(6.)

5.5.2 矩阵-向量乘积

理论： 矩阵A(m×n)与向量x(n×1)的乘积得到向量(m×1)。

计算方式： 结果的第i个元素是A的第i行与向量x的点积。

数学案例：

矩阵 A = [[1, 2], [3, 4]]，向量 x = [2, 1]

矩阵-向量乘积：Ax = [[1×2 + 2×1], [3×2 + 4×1]] = [[4], [10]]

第1行：[1, 2]·[2, 1] = 1×2 + 2×1 = 4
第2行：[3, 4]·[2, 1] = 3×2 + 4×1 = 10

应用：

线性变换
神经网络的前向传播
线性回归预测

python 复制代码

import torch
A = torch.arange(20, dtype=torch.float32).reshape(5, 4)
x = torch.arange(4,dtype=torch.float32)
print(A.shape)
print(x.shape)
print(torch.mv(A,x))  # 矩阵-向量乘积

输出：

复制代码

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

5.5.3 矩阵-矩阵乘积

理论： 矩阵乘法是线性代数的核心操作，A(m×k)乘以B(k×n)得到C(m×n)。

计算规则： C[i,j] = Σ(A[i,k] * B[k,j])

数学案例：

矩阵 A = [[1, 2], [3, 4]]，矩阵 B = [[5, 6], [7, 8]]

矩阵乘积：C = A×B = [[1×5+2×7, 1×6+2×8], [3×5+4×7, 3×6+4×8]]

= [[5+14, 6+16], [15+28, 18+32]]

= [[19, 22], [43, 50]]

应用：

多层神经网络的权重组合
数据变换
图像处理中的卷积操作

python 复制代码

import torch
A = torch.arange(20, dtype=torch.float32).reshape(5, 4)
B = torch.ones(4,3)
print(A)
print(B)
print(torch.mm(A,B))  # 矩阵-矩阵乘积

输出：

复制代码

tensor([[ 0.,  1.,  2.,  3.],
        [ 4.,  5.,  6.,  7.],
        [ 8.,  9., 10., 11.],
        [12., 13., 14., 15.],
        [16., 17., 18., 19.]])
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.]])

5.6 向量和矩阵的范数

5.6.1 L2范数（欧几里得范数）

理论： L2范数是向量元素平方和的平方根。

数学表示： ||x||₂ = √(Σx²ᵢ)

数学案例：

向量 x = [3, 4, 5]

L2范数：||x||₂ = √(3² + 4² + 5²) = √(9 + 16 + 25) = √50 ≈ 7.07

这表示向量x的长度约为7.07个单位

几何意义： 表示向量的长度或距离。

应用：

梯度裁剪
权重衰减
距离度量

python 复制代码

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

输出：

复制代码

tensor(5.)

5.6.2 L1范数（曼哈顿范数）

理论： L1范数是向量元素绝对值的和。

数学表示： ||x||₁ = Σ|xᵢ|

数学案例：

向量 x = [3, -4, 5]

L1范数：||x||₁ = |3| + |-4| + |5| = 3 + 4 + 5 = 12

这表示从原点到目标点，沿坐标轴走的最短距离为12个单位

几何意义： 表示沿坐标轴的"城市街区"距离。

应用：

稀疏性正则化
特征选择
鲁棒性统计

python 复制代码

import torch
u = torch.tensor([3.0,-4.0])
print(torch.abs(u).sum())  # L1范数

输出：

复制代码

tensor(7.)

5.6.3 弗罗贝尼乌斯范数

理论： 矩阵的弗罗贝尼乌斯范数是所有元素平方和的平方根。

数学表示： ||X||_F = √(ΣΣx²ᵢⱼ)

数学案例：

矩阵 X = [[1, 2], [3, 4]]

弗罗贝尼乌斯范数：||X||_F = √(1² + 2² + 3² + 4²) = √(1 + 4 + 9 + 16) = √30 ≈ 5.48

这相当于把矩阵展开成向量[1, 2, 3, 4]再计算L2范数

应用：

矩阵相似度度量
矩阵正则化
低秩近似误差评估

python 复制代码

import torch
print(torch.norm(torch.ones((4,9))))  # 弗罗贝尼乌斯范数

输出：

复制代码

tensor(6.)

6. 线性代数在机器学习中的应用

6.1 数据表示

向量化：

文本：词向量、句子向量
图像：像素向量、特征向量
用户行为：行为向量、偏好向量

6.2 模型参数

权重矩阵：

神经网络：每层的权重矩阵
线性回归：系数向量
支持向量机：权重向量

6.3 优化算法

梯度向量：

梯度下降：使用梯度向量更新参数
反向传播：计算损失函数的梯度
正则化：使用范数约束参数

6.4 数据处理

矩阵运算：

数据标准化：使用均值和标准差矩阵
特征工程：特征变换矩阵
降维：PCA变换矩阵

6.5 深度学习应用

核心操作：

线性层：矩阵-向量乘积
批处理：矩阵-矩阵乘积
注意力机制：点积计算相似度
归一化：使用范数标准化

总结

线性代数是机器学习和深度学习的数学基础，掌握以下核心概念至关重要：

基本概念：标量、向量、矩阵、张量的定义和性质
运算规则：加法、乘法、转置、求和、范数等操作
特殊矩阵：对称矩阵、单位矩阵、零矩阵等
实际应用：在数据处理、模型训练、优化算法中的具体应用

通过PyTorch等深度学习框架，我们可以高效地实现这些线性代数操作，为构建复杂的机器学习模型奠定坚实基础。