简单来说，高级的矩阵运算可以被看作是多个低级向量运算的集合。这不仅是概念上的简化，也是硬件（如GPU）实际执行并行计算的方式。

我们用一个具体的例子，从矩阵乘法一步步分解到向量乘法。

假设我们有两个矩阵 A 和 B ，要计算 C = A * B 。

• A 是一个 2x3 矩阵
• B 是一个 3x2 矩阵
• 结果 C 将是一个 2x2 矩阵

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

B = [[10, 11],
     [20, 21],
     [30, 31]]

级别1：矩阵 x 矩阵 (Matrix-Matrix Multiplication)

这是最高级别的操作。按照定义， C 中的每个元素 C[i, j] 是由 A 的第 i 行和 B 的第 j 列的点积（Dot Product）得到的。

• C[0, 0] = (A的第0行) · (B的第0列) = (110) + (220) + (3*30) = 10 + 40 + 90 = 140
• C[0, 1] = (A的第0行) · (B的第1列) = (111) + (221) + (3*31) = 11 + 42 + 93 = 146
• C[1, 0] = (A的第1行) · (B的第1列) = (410) + (520) + (6*30) = 40 + 100 + 180 = 320
• C[1, 1] = (A的第1行) · (B的第2列) = (411) + (521) + (6*31) = 44 + 105 + 186 = 335

所以，最终结果是：

C = [[140, 146],
     [320, 335]]

级别2：简化为 矩阵 x 向量 (Matrix-Vector Multiplication)

现在，我们换个角度看 C = A * B 。我们可以把矩阵 B 看作是由两个列向量 b1 和 b2 并排组成的。

• b1 (B的第一列) = [10, 20, 30]
• b2 (B的第二列) = [11, 21, 31]

那么， A * B 的结果 C ，它的每一列其实就是 A 分别乘以 B 的每一列的结果。

计算 C 的第一列 c1 : c1 = A * b1

c1 = [[1, 2, 3],   *  [10,
      [4, 5, 6]]      20,
                       30]

这变成了一个 矩阵-向量乘法 。

• c1 的第一个元素 = (110) + (220) + (3*30) = 140
• c1 的第二个元素 = (410) + (520) + (6*30) = 320 所以， c1 = [140, 320] 。这正是 C 的第一列！

计算 C 的第二列 c2 : c2 = A * b2

c2 = [[1, 2, 3],   *  [11,
      [4, 5, 6]]      21,
                       31]

• c2 的第一个元素 = (111) + (221) + (3*31) = 146
• c2 的第二个元素 = (411) + (521) + (6*31) = 335 所以， c2 = [146, 335] 。这正是 C 的第二列！

结论 ：一个矩阵-矩阵乘法 A * B ，可以被完美地分解成一系列并行的矩阵-向量乘法。GPU就是利用这个原理，同时计算 Ab1 , Ab2 … ，从而实现大规模并行加速。

级别3：简化为 向量 x 向量 (Vector-Vector Multiplication)

现在我们再把 矩阵-向量乘法 c1 = A * b1 进行分解。这里有两种等价的视角。

视角A：点积 (Dot Product) 的集合

这是最经典的视角，也是我们刚才实际计算时用的方法。 c1 的每个元素，都是 A 的一个 行向量 和向量 b1 的 点积 。

• c1[0] = (A的第0行) · b1 = [1, 2, 3] · [10, 20, 30] = 140
• c1[1] = (A的第1行) · b1 = [4, 5, 6] · [10, 20, 30] = 320

结论 ：一个矩阵-向量乘法，可以被分解成一系列 向量-向量点积 。每个点积都是独立计算的，这又是大规模并行的基础。

视角B：列向量的线性组合 (Linear Combination)

这是另一个非常重要且直观的视角。一个矩阵乘以一个向量，等于这个矩阵所有 列向量 的 加权和 ，而权重就是那个向量里的元素。

让我们看看 c1 = A * b1 ：

c1 = [[1, 2, 3],   *  [10,
      [4, 5, 6]]      20,
                       30]

A 的列向量分别是： a_col1 = [1, 4] , a_col2 = [2, 5] , a_col3 = [3, 6] b1 的元素是 10, 20, 30 。

根据这个视角， c1 应该是： c1 = (b1的第1个元素 * A的第1列) + (b1的第2个元素 * A的第2列) + (b1的第3个元素 * A的第3列) c1 = 10 * [1, 4] + 20 * [2, 5] + 30 * [3, 6] c1 = [10, 40] + [40, 100] + [90, 180] c1 = [10+40+90, 40+100+180] c1 = [140, 320]

结果完全一样！

结论 ：这个视角告诉我们矩阵-向量乘法的几何意义。它把向量 b1 从一个坐标系（标准坐标系）转换到了由矩阵 A 的列向量所张成的新的坐标系中。

总结

• 矩阵 x 矩阵 ：可以看作是多个独立的 矩阵 x 向量 操作的集合。
• 矩阵 x 向量 ：可以看作是多个独立的 行向量 · 列向量 (点积) 操作的集合。
• 矩阵 x 向量 (另一视角)：也可以看作是矩阵的 列向量 的 线性组合 。

所以，最复杂的矩阵乘法，其最底层的基石就是 向量乘法 （主要是点积）。现代计算库（如BLAS）和硬件（如GPU）就是将上层复杂的运算，层层分解成海量的、简单的、可并行处理的向量运算，从而获得惊人的计算速度。