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

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

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

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

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

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

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

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

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开始计数

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

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个元素
• 注意：这里的"长度"是元素个数，不是向量的几何长度

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

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

输出：

4

5.2.4 向量维度

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

数学案例：
向量 x = [1, 2, 3, 4]

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

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

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

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

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

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

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

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

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

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维：视频数据 (批次×时间×通道×高×宽)

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

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

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]

应用：

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

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]] 参与运算

应用：

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

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

• 这是一个标量结果

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

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

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

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

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

应用：

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

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]

应用：

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

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 可以直接进行

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

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

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

应用：

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

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

应用：

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

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

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

应用：

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

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

等价计算：

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

应用：

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

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

应用：

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

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个单位

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

应用：

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

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个单位

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

应用：

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

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范数

应用：

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

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

输出：

tensor(6.)

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

6.1 数据表示

向量化：

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

6.2 模型参数

权重矩阵：

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

6.3 优化算法

梯度向量：

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

6.4 数据处理

矩阵运算：

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

6.5 深度学习应用

核心操作：

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

---

总结

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

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

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