Python 线性代数 05:矩阵乘法

矩阵乘法是线性代数和数值计算中的核心运算。它可以将矩阵作用于向量，也可以把多个线性变换组合成一个新的变换。在数据处理、图形变换、线性方程组、机器学习和神经网络中，矩阵乘法都具有重要作用。

在 Python 中，可以使用列表、循环和 zip() 实现矩阵乘法，也可以使用 NumPy 的 @ 运算符或 np.matmul() 函数完成。理解行列点积规则、尺寸条件和数组形状，是正确使用矩阵乘法的基础。

一、什么是矩阵乘法

1、从点积到矩阵乘法

矩阵乘法的基本计算单位是点积。

矩阵与向量相乘时，矩阵的每一行分别与向量做点积；两个矩阵相乘时，左矩阵的每一行分别与右矩阵的每一列做点积，得到结果矩阵中的相应元素。

因此，矩阵乘法可以概括为：

左边取行，右边取列，对应分量相乘并求和。

2、矩阵与向量相乘

设：

矩阵 A 的列数为 3，向量 v 包含 3 个分量，因此可以计算：

第一行与向量 v 做点积：

第二行与向量 v 做点积：

因此：

一般地，如果：

那么：

结果向量包含 m 个分量，每个分量对应矩阵 A 的一行与向量 v 的点积。

3、两个矩阵相乘

设：

矩阵 A 的列数等于矩阵 B 的行数，因此可以计算 AB。

一般地，如果：

那么：

尺寸关系可以写成：

(m, n) 与 (n, p) → (m, p)

中间两个维度必须相同，结果保留外侧两个维度。

4、结果矩阵中的元素

令：

矩阵 C 中第 i 行、第 j 列的元素，是矩阵 A 的第 i 行与矩阵 B 的第 j 列的点积：

对于当前示例：

因此：

二、矩阵乘法的两种理解

1、按行计算输出分量

对于矩阵与向量的乘法：

结果中的第 i 个分量为：

这表示矩阵 A 的第 i 行与向量 v 做点积。

从这种角度看，每一行规定了如何将输入向量的各个分量组合成一个输出分量。

2、按列进行线性组合

矩阵乘向量也可以从矩阵的列来理解。

设：

并且：

那么：

也可以写成：

因此，矩阵乘向量还可以理解为：用向量 v 的分量作为系数，对矩阵 A 的各列进行线性组合。

行视角说明每个输出分量如何计算，列视角说明输出向量由哪些方向组合而成。

三、使用 Python 基本语法计算矩阵乘法

1、矩阵与向量相乘

# 使用列表表示矩阵和向量A = [    [2, 1, -1],    [0, 3, 4]]v = [1, 2, -1]# 检查矩阵是否为空if not A or not A[0]:    raise ValueError("矩阵不能为空")column_count = len(A[0])# 检查矩阵各行长度是否一致if any(len(row) != column_count for row in A):    raise ValueError("矩阵的每一行必须具有相同长度")# 矩阵列数必须等于向量长度if column_count != len(v):    raise ValueError("矩阵的列数必须等于向量的长度")result = []# 矩阵的每一行分别与向量做点积for row in A:    value = sum(        matrix_value * vector_value        for matrix_value, vector_value in zip(row, v)    )    result.append(value)print(result)

输出：

[5, 2]

每次循环取出矩阵 A 的一行，再与向量 v 做点积，得到结果向量中的一个分量。

2、两个矩阵相乘

# 使用嵌套列表表示矩阵A = [    [1, 2, 3],    [4, 5, 6]]B = [    [1, 2],    [0, 1],    [2, -1]]# 检查矩阵是否为空if not A or not A[0] or not B or not B[0]:    raise ValueError("矩阵不能为空")a_column_count = len(A[0])b_column_count = len(B[0])# 检查矩阵各行长度是否一致if any(len(row) != a_column_count for row in A):    raise ValueError("矩阵 A 的每一行必须具有相同长度")if any(len(row) != b_column_count for row in B):    raise ValueError("矩阵 B 的每一行必须具有相同长度")# A 的列数必须等于 B 的行数if a_column_count != len(B):    raise ValueError("矩阵 A 的列数必须等于矩阵 B 的行数")# 将矩阵 B 的各列组合成元组B_columns = list(zip(*B))result = []# A 的每一行分别与 B 的每一列做点积for row in A:    result_row = []    for column in B_columns:        value = sum(            a_value * b_value            for a_value, b_value in zip(row, column)        )        result_row.append(value)    result.append(result_row)print(result)

输出：

[[7, 1], [16, 7]]

*B 将矩阵 B 的各行解包为多个序列，zip() 再将相同位置上的元素组合起来：

(1, 0, 2)(2, 1, -1)

它们分别对应矩阵 B 的两列。

这里没有创建 NumPy 数组的转置，只是重新组合了嵌套列表中的元素。对于各行长度一致的二维列表，得到的排列与转置后的行结构相同。

四、使用 NumPy 计算矩阵乘法

1、使用 @ 运算符

NumPy 使用 @ 运算符表示矩阵乘法。对于一维和二维数组，主要有以下几种情况。

（1）两个一维数组

import numpy as npa = np.array([1, 2, 3])b = np.array([4, 5, 6])result = a @ bprint(result)print(np.shape(result))

输出：

32()

对于两个一维数组，a @ b 计算对应元素乘积之和：

形状关系为：

(n,) 与 (n,) → ()

结果是 NumPy 标量，其形状表示为 ()。

对于实数一维数组：

a @ b

与：

np.dot(a, b)

得到相同结果。

（2）二维数组与一维数组

import numpy as npA = np.array([    [1, 2, 3],    [4, 5, 6]])v = np.array([1, 0, -1])result = A @ vprint(result)print(A.shape)print(v.shape)print(result.shape)

输出：

[-2 -2](2, 3)(3,)(2,)

形状关系为：

(m, n) 与 (n,) → (m,)

结果的数值与数学中的列向量结果相同，但 NumPy 返回形状为 (m,) 的一维数组，而不是形状为 (m, 1) 的二维列结构。

（3）两个二维数组

import numpy as npA = np.array([    [1, 2, 3],    [4, 5, 6]])B = np.array([    [1, 2],    [0, 1],    [2, -1]])C = A @ Bprint(C)print(A.shape)print(B.shape)print(C.shape)

输出：

[[ 7  1] [16  7]](2, 3)(3, 2)(2, 2)

形状关系为：

(m, n) 与 (n, p) → (m, p)

两个二维数组使用 @ 时，执行标准矩阵乘法。

2、二维行向量与列向量

NumPy 一维数组没有明确的行列方向。需要二维行结构或列结构时，可以使用：

v = np.array([1, 2, 3])row_vector = v.reshape(1, -1)column_vector = v.reshape(-1, 1)print(row_vector.shape)print(column_vector.shape)

输出：

(1, 3)(3, 1)

二维行向量乘二维列向量：

(1, n) 与 (n, 1) → (1, 1)

结果是形状为 (1, 1) 的二维数组，其唯一元素是两个向量的点积。

二维列向量乘二维行向量：

(n, 1) 与 (1, p) → (n, p)

结果是外积矩阵。外积的定义与 NumPy 实现已在前文单独讨论，这里不再展开。

3、使用 np.matmul()

相同的矩阵乘法可以使用 np.matmul()：

import numpy as npA = np.array([    [1, 2, 3],    [4, 5, 6]])B = np.array([    [1, 2],    [0, 1],    [2, -1]])C = np.matmul(A, B)print(C)

输出：

[[ 7  1] [16  7]]

对于 NumPy 数组，A @ B 与 np.matmul(A, B) 使用相同的矩阵乘法规则。@ 更接近数学中的矩阵乘法符号，通常也更简洁。

4、np.dot() 与矩阵乘法

对于一维和二维数组：

两个一维数组：np.dot() 计算点积；

两个二维数组：np.dot() 计算矩阵乘法。

对于更高维数组，np.dot() 和 np.matmul() 的轴处理规则不同。

因此，表达矩阵乘法和批量矩阵乘法时，通常优先使用：

A @ B

或者：

np.matmul(A, B)

五、矩阵乘法与逐元素乘法

NumPy 中的 * 和 @ 表示的是不同运算。

设：

逐元素乘法为：

对应 NumPy 表达式：

A * B

矩阵乘法为：

对应 NumPy 表达式：

A @ B

逐元素乘法要求形状相同或能够广播；矩阵乘法要求内侧维度匹配。二者的计算规则和数学意义都不同。

六、批量矩阵乘法

实际计算中，常需要同时处理多组矩阵。

设数组 A 的形状为：

(batch, m, n)

数组 B 的形状为：

(batch, n, p)

执行：

C = A @ B

会按照相同的批次位置分别进行矩阵乘法。

结果形状为：

(batch, m, p)

形状关系为：

(batch, m, n) 与 (batch, n, p) → (batch, m, p)

最后两个轴参与矩阵乘法，前面的轴作为批次轴。

例如：

import numpy as npA = np.array([    [        [1, 2],        [3, 4]    ],    [        [2, 0],        [1, 3]    ]])B = np.array([    [        [1, 0],        [0, 1]    ],    [        [1, 2],        [0, 1]    ]])C = A @ Bprint("A 的形状：", A.shape)print("B 的形状：", B.shape)print("C 的形状：", C.shape)print(C)

输出：

A 的形状： (2, 2, 2)B 的形状： (2, 2, 2)C 的形状： (2, 2, 2)[[[1 2]  [3 4]] [[2 4]  [1 5]]]

NumPy 分别计算：

不同批次中的矩阵不会彼此交叉相乘。

当批次轴的形状相同或满足广播条件时，NumPy 也可以完成相应的批量矩阵乘法。

七、矩阵乘法的顺序与基本性质

1、矩阵乘法通常不可交换

普通数的乘法满足交换律，但矩阵乘法通常不满足：

例如：

计算 AB：

计算 BA：

因此：

Python 验证：

import numpy as npA = np.array([    [1, 2],    [0, 1]])B = np.array([    [2, 0],    [1, 3]])print(A @ B)print(B @ A)

2、矩阵顺序表示变换顺序

设向量 v 先经过矩阵 B 的变换，再经过矩阵 A 的变换：

根据结合律：

因此，组合矩阵是 AB。

虽然写作 AB，但实际作用顺序是先 B、后 A。交换矩阵顺序，通常会改变变换顺序和最终结果。

3、结合律

只要尺寸满足乘法条件：

结合律允许改变矩阵连乘的分组，但不能改变矩阵顺序。

不同分组的数学结果相同，但计算量可能不同。在大规模数值计算中，选择合适的分组方式可以减少运算量和内存占用。

4、分配律

矩阵乘法对矩阵加法满足分配律：

以及：

这些等式要求相关矩阵的尺寸同时满足加法和乘法条件。

5、单位矩阵

设：

Iₘ 和 Iₙ 分别表示 m 阶和 n 阶单位矩阵，则：

二阶单位矩阵为：

单位矩阵在矩阵乘法中的作用类似于普通数乘法中的 1。

6、乘积的转置

矩阵乘积的转置满足：

转置后，矩阵的顺序需要反转。

7、零矩阵

只要尺寸满足：

需要注意，即使：

也不一定有 A = 0 或 B = 0。矩阵乘法可能存在非零矩阵相乘得到零矩阵的情况。

八、矩阵乘法在 AI 编程中的典型应用

1、批量样本的线性计算

在机器学习中，通常将多个样本按行组成数据矩阵：

其中：

m 表示样本数量；

n 表示每个样本的特征数量。

设权重矩阵为：

则：

矩阵乘法可以同时为 m 个样本计算 p 个输出。

2、线性层与偏置

设：

偏置向量为：

先计算：

再将偏置加到每个样本的输出中：

在 NumPy 中，一维偏置数组的形状为 (p,)，可以通过广播加到结果矩阵的每一行。

import numpy as npX = np.array([    [1, 2, 1],    [0, 1, 3]])W = np.array([    [2, 1],    [-1, 0],    [1, 3]])b = np.array([1, -1])if X.shape[1] != W.shape[0]:    raise ValueError("X 的列数必须等于 W 的行数")Z = X @ WY = Z + bprint("XW：")print(Z)print("XW + b：")print(Y)

输出：

XW：[[1 4] [2 9]]XW + b：[[2 3] [3 8]]

线性回归、多分类模型和神经网络全连接层的线性部分都可以写成：

矩阵乘法负责组合输入特征，偏置向量则通过广播加到每个样本的输出中。

九、常见问题及使用建议

1、内侧维度必须相同

如果：

由于：

因此不能计算 AB。

对于两个二维 NumPy 数组，可以检查：

if A.shape[1] != B.shape[0]:    raise ValueError("A 的列数必须等于 B 的行数")

2、区分 * 与 @

在 NumPy 中：

* 表示逐元素乘法；

@ 或 np.matmul() 表示矩阵乘法。

二者的尺寸条件、计算规则和结果含义不同，不能相互替代。

3、注意一维数组的形状

NumPy 一维数组没有明确的行列方向。

需要二维行结构或列结构时，应转换为 (1, n) 或 (n, 1)。

判断矩阵运算结果时，应同时检查数值和 shape。

4、不能随意交换矩阵顺序

矩阵乘法通常不满足交换律。即使 AB 和 BA 都有定义，它们的数值和形状也可能不同。

5、标量乘法应使用 *

标量与矩阵相乘属于数乘：

result = 3 * A

不能写成：

result = 3 @ A

标量没有参与矩阵乘法所需的轴结构。

6、批量计算时检查最后两个轴

对于高维数组，@ 和 np.matmul() 使用最后两个轴进行矩阵乘法，其余轴作为批次轴并按照广播规则处理。

调试批量矩阵乘法时，应重点检查：

print(A.shape)print(B.shape)print((A @ B).shape)

📘 小结

矩阵乘法按照“左矩阵的行与右矩阵的列做点积”的规则计算，也可以理解为对左矩阵各列进行线性组合。只有左矩阵列数等于右矩阵行数时，乘法才有定义。NumPy 中，@ 和 np.matmul() 表示矩阵乘法，* 表示逐元素乘法；实际计算还需要注意数组形状、矩阵顺序和批次维度。