Python:矩阵乘法

矩阵乘法中的行列计算规则可以用点积来理解。

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

2、矩阵与向量相乘

设：

在数学表示中，A 是一个 2 × 3 矩阵，x 是一个三维列向量，可写成 3 × 1 的形式。

A 的列数等于 x 的分量数，因此二者可以相乘：

结果向量中的每个元素，都是矩阵 A 的一行与向量 x 的点积。

第一行与向量 x 做点积：

第二行与向量 x 做点积：

因此：

矩阵与向量相乘时，矩阵的每一行都会与输入向量做一次点积，从而得到结果向量中的一个元素。

3、两个矩阵相乘

设：

（1）判断能否相乘

矩阵 A 的尺寸为 2 × 3，矩阵 B 的尺寸为 3 × 2。

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

一般地，设：

只有左矩阵的列数等于右矩阵的行数时，矩阵乘法才有定义。

结果矩阵的尺寸为：

也就是：

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

（2）计算结果矩阵中的元素

令：

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

也就是：

对于当前示例：

计算过程及结果是：

矩阵乘法的计算过程可以概括为：先检查矩阵的尺寸是否满足乘法条件，再让左矩阵的每一行分别与右矩阵的每一列做点积。

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

1、矩阵与向量相乘

仍使用前面的矩阵和向量：

使用 Python 基本语法实现：

# 使用列表表示矩阵和向量A = [    [2, 1, -1],    [0, 3, 4]]x = [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(x):    raise ValueError("矩阵的列数必须等于向量的长度")result = []# 矩阵的每一行分别与向量做点积for row in A:    value = sum(a_ij * x_j for a_ij, x_j in zip(row, x))    result.append(value)print(result)

输出：

[5, 2]

每次循环都会取出矩阵 A 的一行，再与向量 x 做点积，得到结果向量中的一个元素。

2、两个矩阵相乘

仍使用前面的两个矩阵：

使用 Python 基本语法实现：

# 使用嵌套列表表示矩阵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]]

zip(*B) 会把嵌套列表 B 中相同位置的元素组合起来，从而得到 B 的各列：

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

其中，*B 会先将 B 的各行分别传给 zip()；zip() 再将各行中位置相同的元素组合起来。

严格来说，这里并没有创建 NumPy 数组的转置，而是重新组合了嵌套列表中的元素。对于各行长度一致的二维列表，其排列结果等同于转置。

随后，矩阵 A 的每一行分别与这些列做点积。

三、使用 NumPy 计算矩阵乘法

NumPy 是 Python 中常用的数值计算库。使用 NumPy 可以直接处理向量、矩阵和更高维数组，比手动编写嵌套循环更加简洁。

1、使用 @ 运算符

NumPy 使用 @ 运算符表示矩阵乘法。不过，@ 的具体结果会受到数组维数的影响。对于常见的一维数组和二维数组，主要有以下几种情况。

（1）两个一维数组相乘

设两个 NumPy 一维数组为：

import numpy as npa = np.array([1, 2, 3])b = np.array([4, 5, 6])

两个实数一维数组使用 @ 运算时，NumPy 会计算对应元素乘积之和。

Python 实现为：

result = a @ bprint(result)            # 32print(np.shape(result))  # ()

结果是一个标量 32，形状为 ()。形状变化可以写成：

需要注意，NumPy 一维数组只有一个轴，没有明确的行向量或列向量方向。对于实数一维数组，NumPy 会将 a @ b 计算为对应元素乘积之和，其结果等于 a 与 b 的点积。即，等价于 np.dot(a, b)。

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

设矩阵 A 和向量 x 为：

数学上：

使用 NumPy 表示：

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

输出：

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

当二维数组 A 与一维数组 x 相乘时，NumPy 会让 A 的每一行分别与 x 做点积。

形状变化可以写成：

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

（3）两个二维数组相乘

仍使用前面的两个矩阵：

使用 NumPy 可以写成：

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)

两个二维数组使用 @ 运算时，执行标准的矩阵乘法。形状变化为：

左矩阵的列数必须等于右矩阵的行数，结果保留左矩阵的行数和右矩阵的列数。

补充说明：将一维数组转换为二维行向量或列向量

NumPy 一维数组的形状为 (n,)，没有明确的行列方向。

对一维数组使用 .T 也不会改变其形状，因为一维数组只有一个轴，没有两个轴可以交换。

需要明确表示二维行向量时，可以写成：

x_row = x.reshape(1, -1)

其形状为：

(1, 3)

需要明确表示二维列向量时，可以写成：

x_column = x.reshape(-1, 1)

其形状为：

(3, 1)

也可以通过增加新轴完成转换：

x_row = x[None, :]x_column = x[:, None]

将 x 表示为二维列向量后，再与前面的矩阵 A 相乘，其形状变化可写成：

若将二维行向量乘以二维列向量，其形状变化可写成：

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

若将二维列向量乘二维行向量，其形状变化可写成：

这种运算的结果称为外积（Outer Product）。对于一维数组，也可以使用：

x = np.array([1, 2, 3])y = np.array([4, 5, 6])result = np.outer(x, y)

2、使用 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)

对于 NumPy 数组，A @ B 与 np.matmul(A, B)采用相同的矩阵乘法规则。

3、使用 np.dot()

对于两个二维数组，np.dot(A, B) 也可以完成矩阵乘法：

C = np.dot(A, B)

需要注意的是，np.dot() 的含义会随输入维度变化：

• 两个一维数组：计算点积

• 两个二维数组：计算矩阵乘法

• 更高维数组：按照特定轴组合进行计算

@ 和 np.matmul() 对矩阵乘法的表达更加明确，尤其适合处理批量矩阵，因此通常优先使用。

4、矩阵乘法与逐元素乘法的区别

NumPy 中的 * 和 @ 表示两种不同的运算：

*：逐元素乘法

@：矩阵乘法

设：

逐元素乘法将相同位置的元素分别相乘：

矩阵乘法则按照行与列做点积：

5、扩展：批量矩阵乘法

前面的矩阵乘法都只处理一组矩阵。在实际计算中，常常需要同时处理多组形状相同的矩阵，这种运算称为批量矩阵乘法（Batch Matrix Multiplication）。

设 NumPy 数组 A 的形状为：

(batch, m, n)

数组 B 的形状为：

(batch, n, p)

其中，batch 表示批次中包含的矩阵组数。每个批次中的矩阵分别为：

这里的 r 表示批次编号。

执行：

C = A @ B

NumPy 会按照相同的批次编号逐组计算：

因此，结果数组 C 的形状为：

(batch, m, p)

也就是：

例如，设批次中包含两组 2 × 2 矩阵：

将 A⁽¹⁾ 和 A⁽²⁾ 沿批次轴组合成数组 A，将 B⁽¹⁾ 和 B⁽²⁾ 沿批次轴组合成数组 B：

因此，批量矩阵乘法包含两组相互对应的计算：

第一组中，B⁽¹⁾ 是单位矩阵，因此：

第二组为：

因此，批量计算的结果可以表示为：

Python 实现为：

import numpy as np# A 中包含两个 2 × 2 矩阵A = np.array([    [        [1, 2],        [3, 4]    ],    [        [2, 0],        [1, 3]    ]])# B 中也包含两个 2 × 2 矩阵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]]]

这里，形状 (2, 2, 2) 中的第一个 2 表示批次中有两组矩阵，后两个 2 表示每个矩阵有 2 行、2 列。

因此，A @ B 并不是把批次中的所有矩阵混合相乘，而是按照批次编号分别计算：

当两个数组的批次维度相同或能够广播时，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、矩阵顺序表示变换顺序

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

根据结合律：

因此，组合矩阵是 AB。虽然写作 AB，但实际作用顺序是先 B、后 A。

交换矩阵顺序，通常意味着改变变换的先后次序，结果也会随之改变。

3、结合律

只要各矩阵的尺寸满足乘法条件：

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

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

4、分配律

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

以及：

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

5、单位矩阵

设 A 是一个 m × n 矩阵，Iₘ 和 Iₙ 分别表示 m 阶和 n 阶单位矩阵（Identity Matrix），则：

例如，二阶单位矩阵为：

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

6、乘积的转置

矩阵乘积的转置满足：

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

五、矩阵乘法在 AI 编程中的应用

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

其中：

• m 表示样本数量

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

下面采用“样本按行排列”的记号约定，并令权重矩阵 W 为 n × p 矩阵：

则：

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

设输入矩阵为：

权重矩阵为：

偏置向量为：

先按矩阵乘法计算 XW：

在 NumPy 中，表示偏置向量 b 的一维数组形状为 (p,)，它会通过广播加到 XW 的每一行，因此可以写成：

Python 实现为：

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 @ W# 将偏置加到每一行Y = Z + bprint("XW：")print(Z)print("XW + b：")print(Y)

输出：

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

在这种记号约定下，线性回归、多分类模型和神经网络全连接层的线性计算都可以写成：

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

六、常见问题

1、内侧维度不匹配

设：

由于：

内侧维度 3 和 4 不相同，因此不能计算 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

因为标量不具备参与矩阵乘法所需的行列结构。

📘 小结

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