https://blog.ans20xx.com/tags/%E6%95%B0%E5%AD%A6/Recent content in 数学 on 安橙的博客Hugo -- 0.161.1zhTue, 05 May 2026 00:00:00 +0000https://blog.ans20xx.com/posts/ai/ai-%E6%B6%89%E5%8F%8A%E7%9A%84%E6%95%B0%E5%AD%A6%E7%9F%A5%E8%AF%86/Tue, 05 May 2026 00:00:00 +0000https://blog.ans20xx.com/posts/ai/ai-%E6%B6%89%E5%8F%8A%E7%9A%84%E6%95%B0%E5%AD%A6%E7%9F%A5%E8%AF%86/<h1 id="线性代数">线性代数</h1> <h2 id="向量与向量空间">向量与向量空间</h2> <div class="mindmap-container" id="mindmap-51326487" style="width:100%; height:860px; min-height: 860px;" ></div> <textarea id="mindmap-data-51326487" style="display:none;"> - 向量与向量空间 - 什么是向量 - 向量是一个有方向的量 - 几何视角：空间中从原点出发的一支箭头，方向和长度都有意义 - 代数视角：一组有序的数字 - 示例 -  - 这是一个三维向量，每个数字对应一个坐标轴上的分量。 - 词嵌入 - 一个词（token）会被映射成一个几百甚至几千维的向量 - 比如 &#34;猫&#34; 这个词可能被表示成一个 768 维的向量——你可以把它想象成 768 个坐标轴上的一个点 - 语义相近的词在这个空间里位置接近 - 向量的基本运算 - 向量加法 - 两个向量相加，对应分量分别相加 -  - 几何意义: 把 $\vec{b}$ 的起点接到 $\vec{a}$ 的终点，结果是合向量。 - 在 LLM 里的例子：有研究发现，词向量之间存在近似的语义关系 - vec(&#34;国王&#34;)−vec(&#34;男人&#34;)&#43;vec(&#34;女人&#34;)≈vec(&#34;女王&#34;) - 标量乘法 - 用一个数（标量）乘以向量，每个分量都乘以这个数 -  - 几何意义：把向量拉伸或压缩 - 点积 - 定义 - 两个同维度向量的点积 -  - 示例 -  - 几何意义 - 点积有另一种等价写法 -  - 其中 $\theta$ 是两向量之间的夹角 - 关键洞察 - 点积可以衡量两个向量&#34;有多相似&#34;。 - 这正是 Attention 机制里 Query 和 Key 做点积的本质——算两个向量的相关程度 - 向量范数(Norm) - 范数衡量向量的&#34;长度&#34;或&#34;大小&#34; - L2 范数（最常用） -  - 就是我们熟悉的欧几里得距离 -  - L1 范数 -  - 各分量绝对值之和，在正则化（防止过拟合）中常用。 - 余弦相似度 - 把点积和范数组合起来，就得到余弦相似度——LLM 里衡量语义相似性的核心工具 -  -  - 余弦相似度只关心方向，不关心长度 - 两个词的向量可能长度不同，但如果方向相同，说明它们在语义上是一致的 - 向量空间 - 满足以下条件的集合叫向量空间 - 元素（向量）之间可以相加，可以被标量乘 - 在这个集合里做加法和乘法，结果还在这个集合里 - 最关键的概念是维度（Dimension）：向量空间需要多少个基向量来描述其中所有的点 - GPT-2 用 768 维的向量空间来表示词义，GPT-3 用 12288 维。维度越高，理论上能编码的信息越丰富 - Numpy 代码 - ```python import numpy as np # ─── 1. 创建向量 ─────────────────────────────────────── a = np.array([1, 2, 3], dtype=float) b = np.array([4, -1, 2], dtype=float) print(&#34;向量 a:&#34;, a) print(&#34;向量 b:&#34;, b) # ─── 2. 向量加法与标量乘法 ───────────────────────────── print(&#34;\n向量加法 a &#43; b:&#34;, a &#43; b) print(&#34;标量乘法 2 * a:&#34;, 2 * a) # ─── 3. 点积 ────────────────────────────────────────── dot_product = np.dot(a, b) print(&#34;\n点积 a · b:&#34;, dot_product) # 手动验证 manual_dot = sum(a[i] * b[i] for i in range(len(a))) print(&#34;手动计算点积:&#34;, manual_dot) # ─── 4. L2 范数 ──────────────────────────────────────── norm_a = np.linalg.norm(a) norm_b = np.linalg.norm(b) print(&#34;\n‖a‖₂ =&#34;, norm_a) print(&#34;‖b‖₂ =&#34;, norm_b) # ─── 5. 余弦相似度 ───────────────────────────────────── cos_sim = dot_product / (norm_a * norm_b) print(&#34;\n余弦相似度(a, b):&#34;, cos_sim) # ─── 6. 模拟词嵌入：哪个词和&#34;猫&#34;最相似？ ────────────── # 用随机向量模拟（实际中是模型学习出来的） np.random.seed(42) embedding_dim = 8 # 简化为 8 维演示 word_vectors = { &#34;猫&#34;: np.random.randn(embedding_dim), &#34;狗&#34;: np.random.randn(embedding_dim), &#34;汽车&#34;: np.random.randn(embedding_dim), &#34;小猫&#34;: np.random.randn(embedding_dim), } # 手动让&#34;猫&#34;和&#34;小猫&#34;更相似 word_vectors[&#34;小猫&#34;] = word_vectors[&#34;猫&#34;] &#43; np.random.randn(embedding_dim) * 0.3 def cosine_similarity(v1, v2): return np.dot(v1, v2) / (np.linalg.norm(v1) * np.linalg.norm(v2)) query = word_vectors[&#34;猫&#34;] print(&#34;\n与&#34;猫&#34;的余弦相似度：&#34;) for word, vec in word_vectors.items(): if word != &#34;猫&#34;: sim = cosine_similarity(query, vec) print(f&#34; {word}: {sim:.4f}&#34;) ``` </textarea> <h2 id="矩阵基本运算">矩阵基本运算</h2> <div class="mindmap-container" id="mindmap-18523476" style="width:100%; height:860px; min-height: 860px;" ></div> <textarea id="mindmap-data-18523476" style="display:none;"> - 矩阵基本运算 - 矩阵是什么 - 是数字排列成的二维表格，用行数 x 列数描述它的形状（称为&#34;维度&#34;或&#34;shape&#34;） -  - 这是一个 2×3 矩阵（2 行 3 列）。用 $A_{ij}$​ 表示第 i 行第 j 列的元素，比如 $A_{12} = 2$ - 矩阵的本质是线性变换。 - 描述的是&#34;把一个向量变成另一个向量&#34;的规则。 - 矩阵与向量的乘法 - 计算规则 - 矩阵 $A(m \times n)$ 乘以向量 $\vec{x}$（n 维），结果是一个 m 维向量 -  - 结果的每一行，就是矩阵那一行与向量做点积。 - 具体例子 -  - 一个 3×2 的矩阵，把一个 2 维向量变成了 3 维向量。 - 维度变了——这正是&#34;变换&#34;的含义。 - 几何直觉 -  - 该矩阵可以把任意 2D 向量逆时针旋转 90 度 -  - 原来朝右的向量，变成了朝上的向量。矩阵就是这样编码变换规则的。 - 矩阵 A 乘以向量 $\vec{x}$ 等于把 $\vec{x}$ 所在的空间拉伸、旋转、投影到另一个空间。 - LLM 中的应用 - Transformer 里，每个 token 的向量 $\vec{x}$ 乘以权重矩阵 $W_Q$​，得到 Query 向量 - $\vec{q} = W_Q\vec{x}$ - 这就是一次线性变换——把输入向量投影到&#34;Query 空间&#34; - 矩阵乘法 - 计算规则 - 两个矩阵相乘：$A(m\times k) \times B (k\times n) = C(m\times n)$ - 关键约束 - A 的列数必须等于 B 的行数（都是 k）。 - 结果矩阵 C 的第 i 行第 j 列 -  - 即 A 的第 i 行与 B 的第 j 列做点积。 - 具体例子 -  - 矩阵乘法的本质：变换的复合 - 单独看计算规则很枯燥。真正重要的是它的意义 - 矩阵 AB 表示&#34;先做变换 B，再做变换 A&#34;。 - 就像函数复合 $f(g(x))$，矩阵乘法是在组合两个线性变换。 - 神经网络的多层结构，本质上就是多个矩阵变换串联在一起，每一层都对数据做一次变换。 - 矩阵乘法的重要性质 - 不满足交换律 - $AB \neq BA$（大多数情况下） - 先旋转再缩放，和先缩放再旋转，结果不同——顺序很重要。 - 满足结合律 - $(AB)C=A(BC)$ - 这让我们可以灵活选择计算顺序（影响效率，不影响结果） - 转置 - 把矩阵的行和列互换，记作 $A^T$ -  - $A_{ij}^T=A_{ji}$ - 转置的重要性质 - $(AB)^T=B^TA^T$ - $(\vec{a}^T\vec{b}) = \vec{a}\cdot \vec{b}$ - 转置把向量点积统一进了矩阵符号 - LLM 的直接应用 - Attention 公式里的 $QK^T$ 就是对 K 做转置后再和 Q 相乘，目的是让每个 Query 向量和每个 Key 向量都算一次点积，得到注意力分数矩阵。 - 逆矩阵 - 对于方阵(行数=列数) A，如果存在矩阵 $A^{-1}$ 使得 $AA^{-1}=A{-1}A=I$ - 其中 I 是单位矩阵，对角线全是 1，其余是 0，那么 $A^{-1}$ 叫做 A 的逆矩阵 -  - 单位矩阵就像数字里的 1，乘以任何矩阵都不改变它：$AI=IA=A$ - 几何直觉：A 把空间做了某种变换，$A^{-1}$ 就是吧这个变换撤销，还原回去 - 注意：不是所有方阵都有逆矩阵。如果矩阵把空间&#34;压扁&#34;了（比如把三维压成二维），就无法恢复，这样的矩阵不可逆 - 在 LLM 里，矩阵是怎么用的 - Transformer 输入是一个序列，比如 4 个 token，每个 token 用 8 维向量表示，整体表示成矩阵 X，形状（4x8） - 要生成 Query、Key、Value，分别乘以三个权重矩阵 -  - 这三个矩阵乘法，就是在把输入向量投影到三个不同的子空间，分别用于&#34;我在找什么&#34;（Q）、&#34;我有什么&#34;（K）、&#34;我的内容是什么&#34;（V）。 - 注意力分数：$score=QK^T$ - Q 是 $4\times d_k$，$K^T$ 是 $d_k\times 4$，结果是 $4\times 4$ 的矩阵 - 结果是每个 token 和其他每个 token 的相关程度 - 整条公式 $QK^T$ 的每一个元素，就是一对 Query 和 Key 向量的点积 - Numpy 实战 - ```python import numpy as np # ─── 1. 矩阵与向量的乘法 ────────────────────────────── A = np.array([[1, 2], [3, 4], [5, 6]]) # 3×2 矩阵 x = np.array([1, -1]) # 2 维向量 result = A @ x # @ 是矩阵乘法运算符 print(&#34;A @ x =&#34;, result) # 应得 [-1, -1, -1] # ─── 2. 矩阵乘法 ────────────────────────────────────── B = np.array([[1, 2], [3, 4]]) C = np.array([[5, 6], [7, 8]]) print(&#34;\nB @ C =\n&#34;, B @ C) print(&#34;C @ B =\n&#34;, C @ B) print(&#34;交换律不成立:&#34;, np.allclose(B @ C, C @ B)) # False # ─── 3. 转置 ────────────────────────────────────────── M = np.array([[1, 2, 3], [4, 5, 6]]) print(&#34;\n原矩阵 shape:&#34;, M.shape) # (2, 3) print(&#34;转置后 shape:&#34;, M.T.shape) # (3, 2) print(&#34;转置:\n&#34;, M.T) # ─── 4. 模拟 Attention 里的 QK^T ────────────────────── np.random.seed(0) seq_len = 4 # 4 个 token d_model = 8 # 每个 token 8 维 d_k = 4 # Query/Key 的维度 # 输入序列矩阵：4 个 token，每个 8 维 X = np.random.randn(seq_len, d_model) # 权重矩阵（实际中是训练得到的） W_Q = np.random.randn(d_model, d_k) W_K = np.random.randn(d_model, d_k) # 计算 Q 和 K Q = X @ W_Q # shape: (4, 4) K = X @ W_K # shape: (4, 4) # 计算注意力分数矩阵 scores = Q @ K.T # shape: (4, 4) print(&#34;\nQ shape:&#34;, Q.shape) print(&#34;K^T shape:&#34;, K.T.shape) print(&#34;注意力分数矩阵 shape:&#34;, scores.shape) print(&#34;注意力分数矩阵:\n&#34;, scores.round(2)) # 每个元素 scores[i][j] 就是第 i 个 token 对第 j 个 token 的注意力分数 print(&#34;\ntoken 0 对所有 token 的注意力分数:&#34;, scores[0].round(2)) ``` </textarea> <h2 id="线性变换的几何直觉">线性变换的几何直觉</h2> <div class="mindmap-container" id="mindmap-24817356" style="width:100%; height:860px; min-height: 860px;" ></div> <textarea id="mindmap-data-24817356" style="display:none;"> - 线性变换的几何直觉 - 核心洞察：矩阵的列=基向量的去向 - 什么是基向量 - 二维平面最自然的一组基向量 -  - 任何 2D 向量都可以写成基向量的组合 -  - 矩阵的读法 -  - $\hat{i}$ 经过 A 变换后，落在 $\begin{bmatrix} 2 \\ 1 \end{bmatrix}$ - $\hat{j}$ 经过 A 变换后，落在 $\begin{bmatrix} -1 \\ 3 \end{bmatrix}$ - 线性变换有一个神奇的性质：它保留了向量加法和数乘。 - 只要你知道基向量被变到哪里，整个空间所有向量的去向就都确定了 - 这就是矩阵能用一组数字描述整个变换的原因 - 矩阵×向量，本质是用向量的分量作为系数，对矩阵的列做线性组合 -  - 几种常见的线性变换 - 缩放 -  - $\hat{i}$ 拉到 [2,0], $\hat{j}$ 拉到 [0,2]，整个空间被均匀放大 2 倍 -  - 不均匀缩放，横向拉伸 3 倍，纵向不变。 - 旋转 - 逆时针旋转角度 $\theta$ -  - 错切 (Shear) -  - $\hat{i}$ 不动，$\hat{j}$ 从 [0,1] 移动到 [1,1]。整个空间像被协推的扑克牌 - 投影 (Projection) -  - $\hat{i}$ 不动，$\hat{j}$ 压扁到原点，整个 2D 平面被投影到 $x$ 轴，降了一维 - 这个变换是不可逆的，一旦把平面压扁成一条线，无法恢复 - 反射 (Reflection) -  - $\hat{i}$ 翻到 [-1,0]，整个空间沿 y 轴镜像翻转 - 行列式：变换的缩放因子 - 行列式 $det(A)$ 是一个数 - 这个变换把单位面积或体积放大缩小了多少倍 - 几何意义 - $\hat{i}$ 和 $\hat{j}$ 围成的单位正方形，面积是 1 - 变换后，这两个向量会围成一个平行四边形，这个平行四边形的面积就是 $|det(A)|$ - 二阶行列式公式 -  -  - det(A) = 0 -&gt; 矩阵不可逆 -&gt; 变换降低了维度 - 秩 (Rank)：变换后的输出维度 - 秩 (rank(A)) 是另外一个数 - 回答：变换后，所有向量落到的空间有几维 - 直观理解 -  - [2,4] = 2x[1,2]，两列共线，无论 $\hat{i}$ 和 $\hat{j}$ 落到哪里，它们都在一条直线上 - 整个 2d 平面被压成了一条 1D 直线，rank(A) = 1 - 如果两列线性无关（不共线），秩为 2，变换后仍然是 2D 平面，满秩 - 满秩 vs 不满秩 -  - 秩的另一种表述 - rank(A) = A 的列向量中线性无关的最大个数 - 也等于行向量中线性无关的最大个数，行秩=列秩 - 线性相关与无关 - 一组向量是线性相关的，意味着其中某个向量可以由其他向量的线性组合得到 - n 个线性无关的向量，才能&#34;撑起&#34;一个 n 维空间 - 如果你有 100 个向量，但它们都共线（线性相关），实际上只描述了一条 1D 直线 - 连接到 LLM - 为什么 LLM 用高维向量 - GPT-3 用 12288 维的词向量 - 维度越高，能容纳的&#34;线性无关方向&#34;越多，理论上能编码越丰富的语义特征 - 情感、词性、领域、时态、语气……每个特征可以是一个独立的方向。 - 低秩的危险 - 如果训练出的某个权重矩阵秩很低，意味着它实际上只在少数几个方向上有效，浪费了表达能力 - 这是&#34;模型坍缩&#34;的一种数学表现 - LoRA 的精妙之处 - LoRA（Low-Rank Adaptation）微调的核心思想：微调时新增的参数变化矩阵 $\delta W$ 通常是低秩的 - 如果 $\delta W$ 是 1024x1024 的矩阵，参数量是约 100 万。但如果它的秩只有 8，可以分解成：$\delta W = A\cdot B$ - 其中 A 是 1024 x 8，B 是 8 x 1024，参数量降到约 1.6 万 - Attention 的几何意义 - $Q=XW_Q$，这是在用矩阵 $W_Q$ 把输入向量变换到 Query 空间 - $W_Q$ 的秩决定了 Query 空间的自由度—能从输入里提取多少个独立的&#34;问题&#34;。 - 可视化代码 - ```python import numpy as np import matplotlib.pyplot as plt def plot_transformation(matrix, title): &#34;&#34;&#34;可视化一个 2x2 矩阵的变换效果&#34;&#34;&#34; # 原始基向量 i_hat = np.array([1, 0]) j_hat = np.array([0, 1]) # 变换后 i_new = matrix @ i_hat j_new = matrix @ j_hat # 画一个网格点 x = np.linspace(-2, 2, 9) y = np.linspace(-2, 2, 9) X, Y = np.meshgrid(x, y) points = np.stack([X.ravel(), Y.ravel()]) transformed = matrix @ points fig, axes = plt.subplots(1, 2, figsize=(10, 5)) # 原空间 axes[0].scatter(points[0], points[1], c=&#39;lightblue&#39;, s=10) axes[0].arrow(0, 0, *i_hat, head_width=0.1, color=&#39;red&#39;, label=&#39;i_hat&#39;) axes[0].arrow(0, 0, *j_hat, head_width=0.1, color=&#39;green&#39;, label=&#39;j_hat&#39;) axes[0].set_title(&#34;变换前&#34;) axes[0].set_xlim(-3, 3); axes[0].set_ylim(-3, 3) axes[0].grid(True); axes[0].axhline(0); axes[0].axvline(0) axes[0].set_aspect(&#39;equal&#39;) # 变换后空间 axes[1].scatter(transformed[0], transformed[1], c=&#39;lightcoral&#39;, s=10) axes[1].arrow(0, 0, *i_new, head_width=0.1, color=&#39;red&#39;) axes[1].arrow(0, 0, *j_new, head_width=0.1, color=&#39;green&#39;) axes[1].set_title(f&#34;变换后\ndet={np.linalg.det(matrix):.2f}, &#34; f&#34;rank={np.linalg.matrix_rank(matrix)}&#34;) axes[1].set_xlim(-5, 5); axes[1].set_ylim(-5, 5) axes[1].grid(True); axes[1].axhline(0); axes[1].axvline(0) axes[1].set_aspect(&#39;equal&#39;) plt.suptitle(title); plt.tight_layout(); plt.show() # ─── 试试不同的变换 ─────────────────────────────── # 1. 缩放 plot_transformation(np.array([[2, 0], [0, 1.5]]), &#34;缩放：x 方向 2 倍，y 方向 1.5 倍&#34;) # 2. 旋转 45 度 theta = np.pi / 4 plot_transformation( np.array([[np.cos(theta), -np.sin(theta)], [np.sin(theta), np.cos(theta)]]), &#34;旋转 45 度&#34; ) # 3. 错切 plot_transformation(np.array([[1, 1], [0, 1]]), &#34;错切&#34;) # 4. 投影到 x 轴（注意 det=0, rank=1） plot_transformation(np.array([[1, 0], [0, 0]]), &#34;投影到 x 轴（降维！）&#34;) # 5. 反射 plot_transformation(np.array([[-1, 0], [0, 1]]), &#34;沿 y 轴反射&#34;) ``` </textarea> <h2 id="特征值与特征向量">特征值与特征向量</h2> <div class="mindmap-container" id="mindmap-43876251" style="width:100%; height:860px; min-height: 860px;" ></div> <textarea id="mindmap-data-43876251" style="display:none;"> - 特征值与特征向量 - 变换中不变的方向 - 一个矩阵作用于空间，所有向量都被旋转、拉伸、扭曲。绝大多数向量变换后，方向都改变了 - 但有些特殊的向量——它们经过变换后，方向不变，只是被拉长或缩短 - 这种&#34;在变换中保持方向&#34;的向量，就叫做特征向量（eigenvector）。它被拉伸的倍数，叫做特征值（eigenvalue） - 形式化定义 - 特征值方程 - $A\vec{v}=\lambda\vec{v}$ - 矩阵 A 作用在向量 $\vec{v}$ 上，结果等于把 $\vec{v}$ 缩放 $\lamda$ 倍 - $\lamda$ 是特征值（一个标量，可以是正、负、零，甚至复数） - 几何含义 -  - 关键洞察：特征向量给出的是矩阵变换的&#34;主轴&#34;。沿着这些主轴，复杂的矩阵变换简化成了简单的&#34;拉伸&#34; - 怎么求特征值 - 推导 -  - 行列式为 0 意味着矩阵把空间压扁了，存在一些非零向量被压成了零向量——那些被压扁的方向就是特征方向 - 实际计算 - 求特征值 -  - 求特征向量 -  - 特征分解 - 如果 $n\times n$ 矩阵 A 有 n 个线性无关的特征向量，可以写成 $A=PDP^{-1}$ - 公式解析 - $P$ 是把特征向量按列排起来的矩阵 - $D$ 是对角矩阵，对角线上是对应的特征值 - $P^{-1}$ 是 $P$ 的逆矩阵 - 几何含义 - 任何复杂的线性变换 A，都可以分解成三步简单操作： - $P^{-1}$: 把空间转一下，让特征方向对齐到坐标轴 - $D$: 沿坐标轴各方向独立缩放（因为 D 是对角矩阵） - $P$: 把空间转回来 - 整个复杂变换，本质上就是沿着特征方向的简单缩放 - 矩阵的 n 次幂 -  - 计算量从 100 次矩阵乘法降到 n 次标量幂运算 - 这是 PageRank、马尔可夫链稳态分析的核心计算技巧 - PCA：特征值的经典应用 - PCA（主成分分析，Principal Component Analysis）是降维最常用的算法。它的数学本质就是特征分解 - 问题背景 - 假设你有 1000 个数据点，每个是 768 维向量 - 可视化、分析都很困难 - 能不能找到 2 个最重要的&#34;方向&#34;，把数据投影到这两个方向上，保留尽可能多的信息 - PCA 的答案：找数据协方差矩阵的特征向量，按特征值大小排序，取前 k 个 - 为什么有效 - 协方差矩阵 C 描述了数据在各维度的&#34;散布情况&#34; - 它的特征向量给出了数据散布最大的方向——这些就是&#34;主成分&#34; - 特征值越大，说明数据沿那个方向变化越剧烈，包含的信息越多 - 如果你的 1000 个数据点几乎都集中在一条直线附近 - 那条直线就是第一主成分（最大特征值对应的特征向量） - 用它一个维度就能描述大部分信息 - PCA 的步骤 - 把数据矩阵 X 中心化：每一列减去该列均值 - 计算协方差矩阵：$C=\frac 1{n-1}X^TX$ - 对 C 做特征分解：$C=PDP^{-1}$ - 选 D 中最大的 k 个特征值对应的特征向量，组成投影矩阵 W - 降维后的数据: $X_{new}=XW$ - 连接到 LLM - 词嵌入的可视化 - GPT 的 768 维词向量没法直接看。 - 用 PCA 把它降到 2D 或 3D，就能在散点图上观察 - &#34;国王&#34;&#34;女王&#34;&#34;公主&#34;这些词是否聚在一起？ - 这是分析模型语义的常用手段。 - 模型权重分析 - Transformer 的注意力矩阵分析中，研究者会看注意力权重矩阵的特征值分布 - 如果特征值过于集中（少数几个特征值很大，其他都很小） - 说明模型在过度关注某些方向，可能存在退化现象。 - RoPE 位置编码的内在结构 - 旋转位置编码（RoPE）本质上是用一组旋转矩阵作用在 Query 和 Key 上 - 这些旋转矩阵的特征值（在复数域）正是 $e^{i\theta}$，对应频率的位置信息 - 模型压缩的根基 - 特征分解的更一般形式 SVD是各种模型压缩、剪枝、低秩近似的数学基础 - Numpy 代码实现 - ```python import numpy as np import matplotlib.pyplot as plt # ─── 1. 求特征值和特征向量 ──────────────────────────── A = np.array([[3, 1], [0, 2]], dtype=float) eigenvalues, eigenvectors = np.linalg.eig(A) print(&#34;特征值:&#34;, eigenvalues) # [3., 2.] print(&#34;特征向量（按列）:\n&#34;, eigenvectors) # 验证 A v = λ v v0 = eigenvectors[:, 0] # 第一个特征向量 λ0 = eigenvalues[0] print(&#34;\nA @ v0 =&#34;, A @ v0) print(&#34;λ0 * v0 =&#34;, λ0 * v0) print(&#34;两者相等:&#34;, np.allclose(A @ v0, λ0 * v0)) # ─── 2. 验证特征分解 A = P D P^(-1) ──────────────── P = eigenvectors D = np.diag(eigenvalues) A_reconstructed = P @ D @ np.linalg.inv(P) print(&#34;\n重构 A:\n&#34;, A_reconstructed) print(&#34;与原 A 相等:&#34;, np.allclose(A, A_reconstructed)) # ─── 3. 用特征分解快速算 A^10 ────────────────────── A10_naive = np.linalg.matrix_power(A, 10) A10_eigen = P @ np.diag(eigenvalues**10) @ np.linalg.inv(P) print(&#34;\n两种方法算 A^10 是否一致:&#34;, np.allclose(A10_naive, A10_eigen)) # ─── 4. 手写 PCA 并可视化 ─────────────────────────── np.random.seed(42) # 生成一些 2D 数据：长椭圆形分布 n = 200 mean = [0, 0] cov = [[3, 2], [2, 2]] data = np.random.multivariate_normal(mean, cov, n) # Step 1: 中心化 data_centered = data - data.mean(axis=0) # Step 2: 协方差矩阵 C = (data_centered.T @ data_centered) / (n - 1) # Step 3: 特征分解 eigvals, eigvecs = np.linalg.eigh(C) # eigh 用于对称矩阵，更稳定 # Step 4: 按特征值从大到小排序 idx = np.argsort(eigvals)[::-1] eigvals = eigvals[idx] eigvecs = eigvecs[:, idx] print(&#34;\n协方差矩阵的特征值:&#34;, eigvals) print(&#34;第一主成分（最大特征值方向）:&#34;, eigvecs[:, 0]) print(&#34;第二主成分:&#34;, eigvecs[:, 1]) # 可视化：原数据 &#43; 两个主成分方向 plt.figure(figsize=(8, 8)) plt.scatter(data[:, 0], data[:, 1], alpha=0.5, label=&#39;数据&#39;) # 画两个主成分方向（用特征值缩放表示重要程度） origin = data.mean(axis=0) for i, (val, vec) in enumerate(zip(eigvals, eigvecs.T)): plt.arrow(*origin, *(vec * np.sqrt(val) * 2), head_width=0.15, color=[&#39;red&#39;, &#39;green&#39;][i], label=f&#39;PC{i&#43;1} (λ={val:.2f})&#39;, linewidth=2) plt.axis(&#39;equal&#39;) plt.grid(True) plt.legend() plt.title(&#34;PCA：特征向量指出数据散布最大的方向&#34;) plt.show() # ─── 5. 降维：把 2D 数据投影到 1D ───────────────── # 只用第一主成分 W = eigvecs[:, 0:1] # shape (2, 1) data_1d = data_centered @ W print(f&#34;\n降维前 shape: {data.shape}&#34;) print(f&#34;降维后 shape: {data_1d.shape}&#34;) # 计算保留的&#34;信息比例&#34; info_kept = eigvals[0] / eigvals.sum() print(f&#34;用 1 维保留了 {info_kept:.1%} 的信息&#34;) ``` </textarea> <h2 id="svd-奇异值分解">SVD (奇异值分解)</h2> <div class="mindmap-container" id="mindmap-16347852" style="width:100%; height:860px; min-height: 860px;" ></div> <textarea id="mindmap-data-16347852" style="display:none;"> - SVD (奇异值分解) - 为什么需要 SVD - 特征分解 $A = PDP^{-1}$ 有两个限制 - 只能用于方阵（行数=列数） - 不是所有的方阵都能分解（要求有 n 个线性无关的特征向量） - 任何 $m\times n$ 的矩阵都能做 SVD 分解，没有任何限制 - SVD 公式 - 对任意矩阵 $A$ ($m\times n$) $A=U\Sigma V^T$ -  - 奇异值通常按从大到小排列：$\sigma_1 \ge \sigma_2 \ge ... \ge \sigma _r \ge 0$, r 是矩阵的秩 - 几何解释 - 矩阵代表线性变换。SVD 说的是——任何线性变换，都可以分解成&#34;旋转 → 缩放 → 旋转&#34;三步 - 把向量 $\vec{x}$ 应用矩阵 $A$: $A\vec{x} = U\Sigma V^T\vec{x}$ - $V^T\vec{x}$: 对 $\vec{x}$ 做 一次旋转/反射 - $\Sigma(\cdot)$: 沿坐标轴各方向独立缩放(缩放倍数=奇异值) - $U(\cdot)$: 再做一次旋转/反射 - 与特征分解的对比 -  - 奇异值的含义 - 衡量矩阵的重要方向 - 最大的奇异值 $\sigma_1$ 对应矩阵最&#34;主要&#34;的变换方向；后面的奇异值一次描述次要方向。 - 决定矩阵的秩 - 非零奇异值的个数 = 矩阵的秩 - 衡量矩阵的&#34;信息含量&#34; - 如果一个矩阵的奇异值快速衰减，说明矩阵的信息几乎全在前两个方向上，后面的方向可以安全丢弃 - SVD 与 LoRA - 问题背景 - 微调一个 7B 参数的 LLM，要更新所有参数代价极大 - LoRA 的观察：微调时的参数变化 $\Delta W$ 通常是低秩的——也就是说，虽然 $\Delta W$ 是个大矩阵，它真正有效的&#34;主方向&#34;很少 - LoRA 的做法 - 不直接学习 $\Delta W$，而是学习两个小矩阵 A 和 B $\Delta W \approx BA$ - 如果 $\Delta W$ 是 4096x4096，参数量是 1700 万 - 如果用 LoRA 设秩为 8，则 A 是 8x4096，B 是 4096x8，参数量约 6.5 万，减少 250 倍 - SVD 在 LLM 中的其他应用 - 词嵌入分析 - 对一个 $50000\times 768$ 的词嵌入矩阵做 SVD，看奇异值衰减情况，可以判断词嵌入空间的有效维度 - Attention 矩阵分析 - 研究 Transformer 注意力权重矩阵的奇异值分布，可以诊断模型是否出现&#34;注意力坍缩&#34;——所有注意力都集中在少数几个 token 上 - 模型压缩 - 把训练好的权重矩阵做 SVD，丢弃小奇异值，用低秩矩阵替代，可以压缩模型大小 - 推荐系统的根基 - 经典的协同过滤推荐算法，本质就是对&#34;用户-物品评分矩阵&#34;做 SVD 低秩近似 - NumPy 代码实战 - ```python import numpy as np import matplotlib.pyplot as plt # ─── 1. 基本 SVD 分解 ───────────────────────────────── np.random.seed(42) A = np.random.randn(5, 3) # 一个 5x3 的非方阵 U, sigma, VT = np.linalg.svd(A, full_matrices=False) print(&#34;A shape:&#34;, A.shape) print(&#34;U shape:&#34;, U.shape) # (5, 3) print(&#34;奇异值:&#34;, sigma) # 长度为 3 的数组 print(&#34;V^T shape:&#34;, VT.shape) # (3, 3) # 验证 A = U Σ V^T A_reconstructed = U @ np.diag(sigma) @ VT print(&#34;\n重构误差:&#34;, np.linalg.norm(A - A_reconstructed)) # ─── 2. 验证 U 和 V 是正交矩阵 ──────────────────────── print(&#34;\nU^T @ U =\n&#34;, (U.T @ U).round(4)) # 应近似为单位矩阵 print(&#34;\nV @ V^T =\n&#34;, (VT @ VT.T).round(4)) # 应近似为单位矩阵 # ─── 3. 低秩近似：用 SVD 压缩图像 ───────────────────── # 创建一个简单的&#34;图像&#34;（一个矩阵） np.random.seed(0) image = np.zeros((50, 50)) # 加几个明显的结构 image[10:20, 10:40] = 1 image[25:35, 15:35] = 0.7 image[40:48, 5:45] = 0.5 image &#43;= np.random.randn(50, 50) * 0.1 # 对图像做 SVD U, sigma, VT = np.linalg.svd(image) # 用不同 k 值重构 fig, axes = plt.subplots(1, 5, figsize=(15, 3)) axes[0].imshow(image, cmap=&#39;gray&#39;) axes[0].set_title(f&#34;原图\n所有 50 个奇异值&#34;) axes[0].axis(&#39;off&#39;) for i, k in enumerate([1, 3, 10, 30]): image_k = U[:, :k] @ np.diag(sigma[:k]) @ VT[:k, :] axes[i&#43;1].imshow(image_k, cmap=&#39;gray&#39;) info_kept = (sigma[:k]**2).sum() / (sigma**2).sum() axes[i&#43;1].set_title(f&#34;k={k}\n信息保留 {info_kept:.1%}&#34;) axes[i&#43;1].axis(&#39;off&#39;) plt.suptitle(&#34;SVD 低秩近似：用前 k 个奇异值还原矩阵&#34;) plt.tight_layout() plt.show() # ─── 4. 奇异值衰减图 ────────────────────────────────── plt.figure(figsize=(8, 4)) plt.plot(sigma, &#39;o-&#39;) plt.yscale(&#39;log&#39;) plt.xlabel(&#39;奇异值序号&#39;) plt.ylabel(&#39;奇异值大小（对数尺度）&#39;) plt.title(&#39;奇异值衰减情况&#39;) plt.grid(True) plt.show() # ─── 5. 模拟 LoRA：用低秩分解近似一个权重矩阵 ─────── # 假设原始权重矩阵 W = np.random.randn(1024, 1024) * 0.01 # 假设这是&#34;微调后的变化&#34;——故意构造成低秩的 np.random.seed(1) B_true = np.random.randn(1024, 8) A_true = np.random.randn(8, 1024) delta_W_true = B_true @ A_true # 真实秩为 8 的变化 # 用 SVD 提取最佳秩-8 近似 U, sigma, VT = np.linalg.svd(delta_W_true) k = 8 delta_W_approx = U[:, :k] @ np.diag(sigma[:k]) @ VT[:k, :] print(&#34;\n--- LoRA 模拟 ---&#34;) print(f&#34;原始 ΔW 参数量: {1024 * 1024:,}&#34;) print(f&#34;LoRA 形式 (B &#43; A) 参数量: {1024 * k &#43; k * 1024:,}&#34;) print(f&#34;压缩比: {1024 * 1024 / (1024 * k &#43; k * 1024):.1f}x&#34;) print(f&#34;近似误差: {np.linalg.norm(delta_W_true - delta_W_approx):.6f}&#34;) ``` - SVD vs 特征分解 vs PCA 总结 -  - 有趣的关系 - 对对称正定矩阵，特征分解和 SVD 等价 - PCA 可以通过对中心化数据矩阵 X 直接做 SVD 实现，比先算协方差矩阵更稳定 </textarea>https://blog.ans20xx.com/posts/ai/%E6%A6%82%E7%8E%87%E7%BB%9F%E8%AE%A1/Sun, 03 Aug 2025 00:00:00 +0000https://blog.ans20xx.com/posts/ai/%E6%A6%82%E7%8E%87%E7%BB%9F%E8%AE%A1/程序员需要知道的数学知识-概率统计篇