2.6 `scipy.sparse`：稀疏矩阵

文档摘要

2.6 ：稀疏矩阵 2.6 : 稀疏矩阵在科学计算中，我们经常遇到大型矩阵，但其中绝大多数元素为零。这种矩阵称为稀疏矩阵。存储和操作这些矩阵的传统方法效率低下，因为它们会浪费大量内存并进行不必要的计算。模块提供了一系列高效的稀疏矩阵类，用于存储和操作这些矩阵。 2.6.1 稀疏矩阵的优势节省内存: 仅存储非零元素及其索引，显著减少内存占用。提高计算效率: 避免对零元素进行计算，加速矩阵运算。适用于大规模数据: 能够处理传统方法无法处理的大型稀疏矩阵。 2.6.2 稀疏矩阵格式提供了多种稀疏矩阵格式，每种格式都有其特定的优势，适用于不同的应用场景。常见的格式包括： CSR (Compressed Sparse Row): 按行压缩的稀疏矩阵。适合行切片、矩阵向量乘法等操作。

2.6 `scipy.sparse`：稀疏矩阵

2.6 `scipy.sparse`: 稀疏矩阵

在科学计算中，我们经常遇到大型矩阵，但其中绝大多数元素为零。这种矩阵称为稀疏矩阵。存储和操作这些矩阵的传统方法效率低下，因为它们会浪费大量内存并进行不必要的计算。scipy.sparse 模块提供了一系列高效的稀疏矩阵类，用于存储和操作这些矩阵。

2.6.1 稀疏矩阵的优势

节省内存: 仅存储非零元素及其索引，显著减少内存占用。
提高计算效率: 避免对零元素进行计算，加速矩阵运算。
适用于大规模数据: 能够处理传统方法无法处理的大型稀疏矩阵。

2.6.2 稀疏矩阵格式

scipy.sparse 提供了多种稀疏矩阵格式，每种格式都有其特定的优势，适用于不同的应用场景。常见的格式包括：

CSR (Compressed Sparse Row): 按行压缩的稀疏矩阵。适合行切片、矩阵向量乘法等操作。
CSC (Compressed Sparse Column): 按列压缩的稀疏矩阵。适合列切片、矩阵向量乘法等操作。
COO (Coordinate Format): 坐标格式，存储非零元素的行、列索引和值。适合构建稀疏矩阵。
LIL (List of Lists): 基于列表的稀疏矩阵。适合增量构建稀疏矩阵，但算术运算效率较低。
DIA (Diagonal Format): 对角线格式，存储对角线上的元素。适合表示对角矩阵或近似对角矩阵。
BSR (Block Sparse Row): 块稀疏行格式，将矩阵分成块，并以 CSR 格式存储非零块。适合具有块结构的稀疏矩阵。

以下 Mermaid 图表展示了这些格式之间的关系：

2.6.3 创建稀疏矩阵

可以使用以下方法创建稀疏矩阵：

从密集矩阵转换:


import numpy as np
from scipy.sparse import csr_matrix
dense_matrix = np.array([[1, 0, 2], [0, 0, 3], [4, 0, 5]])
sparse_matrix = csr_matrix(dense_matrix)
print(sparse_matrix)

输出：


  (0, 0)        1
  (0, 2)        2
  (1, 2)        3
  (2, 0)        4
  (2, 2)        5

使用 COO 格式:


from scipy.sparse import coo_matrix
row = np.array([0, 0, 1, 2, 2, 2])
col = np.array([0, 2, 2, 0, 1, 2])
data = np.array([1, 2, 3, 4, 5, 6])
sparse_matrix = coo_matrix((data, (row, col)), shape=(3, 3))
print(sparse_matrix)

输出：


  (0, 0)        1
  (0, 2)        2
  (1, 2)        3
  (2, 0)        4
  (2, 1)        5
  (2, 2)        6

使用 sparse.eye() 创建对角矩阵:


from scipy.sparse import eye
sparse_matrix = eye(5) # 创建一个 5x5 的单位稀疏矩阵
print(sparse_matrix)

输出：


  (0, 0)        1.0
  (1, 1)        1.0
  (2, 2)        1.0
  (3, 3)        1.0
  (4, 4)        1.0

2.6.4 稀疏矩阵的运算

scipy.sparse 模块支持多种稀疏矩阵运算，包括：

加法和减法:


from scipy.sparse import csr_matrix
A = csr_matrix([[1, 0, 2], [0, 0, 3], [4, 0, 5]])
B = csr_matrix([[0, 0, 1], [2, 0, 0], [0, 3, 0]])
C = A + B
D = A - B
print("A + B:\n", C)
print("A - B:\n", D)

输出：


A + B:
  (0, 0)        1
  (0, 2)        3
  (1, 0)        2
  (1, 2)        3
  (2, 0)        4
  (2, 2)        5
  (2, 1)        3
A - B:
  (0, 0)        1
  (0, 2)        1
  (1, 2)        3
  (1, 0)        -2
  (2, 0)        4
  (2, 2)        5
  (2, 1)        -3

矩阵乘法:


from scipy.sparse import csr_matrix
A = csr_matrix([[1, 0, 2], [0, 0, 3]])
B = csr_matrix([[4, 0], [0, 5], [6, 0]])
C = A.dot(B)  # 或者 C = A @ B
print("A * B:\n", C)

输出：


A * B:
  (0, 0)        16
  (1, 0)        18

转置:


from scipy.sparse import csr_matrix
A = csr_matrix([[1, 0, 2], [0, 0, 3], [4, 0, 5]])
A_T = A.transpose()
print("A.T:\n", A_T)

输出：


A.T:
  (0, 0)        1
  (2, 0)        2
  (2, 1)        3
  (0, 2)        4
  (2, 2)        5

其他运算: scipy.sparse 还支持其他运算，如求逆（需要转换为 scipy.sparse.linalg 中的稀疏线性代数求解器）、求范数等。

2.6.5 稀疏矩阵格式之间的转换

可以使用 .tocsr(), .tocsc(), .tocoo(), .tolil(), .todia(), .tobsr() 等方法在不同的稀疏矩阵格式之间进行转换。选择合适的格式对于性能至关重要。


from scipy.sparse import coo_matrix
row = np.array([0, 0, 1, 2, 2, 2])
col = np.array([0, 2, 2, 0, 1, 2])
data = np.array([1, 2, 3, 4, 5, 6])
coo = coo_matrix((data, (row, col)), shape=(3, 3))
csr = coo.tocsr()
csc = coo.tocsc()
print("COO:\n", coo)
print("CSR:\n", csr)
print("CSC:\n", csc)

输出：


COO:
  (0, 0)        1
  (0, 2)        2
  (1, 2)        3
  (2, 0)        4
  (2, 1)        5
  (2, 2)        6
CSR:
  (0, 0)        1
  (0, 2)        2
  (1, 2)        3
  (2, 0)        4
  (2, 1)        5
  (2, 2)        6
CSC:
  (2, 0)        4
  (0, 0)        1
  (2, 1)        5
  (0, 2)        2
  (1, 2)        3
  (2, 2)        6

2.6.6 选择合适的稀疏矩阵格式

选择哪种稀疏矩阵格式取决于具体的应用场景：

CSR: 通用格式，适合大多数操作，尤其是行操作和矩阵向量乘法。
CSC: 适合列操作和矩阵向量乘法，以及某些线性代数运算。
COO: 适合从外部数据构建稀疏矩阵，但不适合进行算术运算。
LIL: 适合增量构建稀疏矩阵，但不适合进行算术运算。
DIA: 适合表示对角矩阵或近似对角矩阵，可以高效地进行对角线相关的操作。
BSR: 适合具有块结构的稀疏矩阵，可以提高存储效率和计算效率。

通常，建议使用 CSR 或 CSC 格式，因为它们在性能和通用性之间取得了良好的平衡。如果你需要频繁修改矩阵结构，LIL 格式可能更合适，但在完成构建后应转换为 CSR 或 CSC 格式以提高运算效率。

2.6.7 实际应用案例

稀疏矩阵在许多科学和工程领域都有广泛的应用，例如：

图论: 邻接矩阵通常是稀疏的。
文本挖掘: 文档-词项矩阵通常是稀疏的。
推荐系统: 用户-物品矩阵通常是稀疏的。
有限元分析: 刚度矩阵通常是稀疏的。
图像处理: 一些图像表示，如稀疏编码，会用到稀疏矩阵。

示例：使用稀疏矩阵表示社交网络

假设我们有一个小型社交网络，其中包含 5 个用户。我们可以使用稀疏矩阵来表示用户之间的连接关系，其中矩阵的行和列表示用户，非零元素表示用户之间存在连接。


import numpy as np
from scipy.sparse import csr_matrix
# 用户之间的连接关系
connections = np.array([
    [0, 1, 0, 0, 1],  # 用户 0 连接到用户 1 和 4
    [1, 0, 1, 0, 0],  # 用户 1 连接到用户 0 和 2
    [0, 1, 0, 1, 0],  # 用户 2 连接到用户 1 和 3
    [0, 0, 1, 0, 1],  # 用户 3 连接到用户 2 和 4
    [1, 0, 0, 1, 0]   # 用户 4 连接到用户 0 和 3
])
# 创建 CSR 稀疏矩阵
social_network = csr_matrix(connections)
print(social_network)
# 查找用户 0 连接到的用户
connected_users = social_network[0].nonzero()[1]
print(f"User 0 is connected to users: {connected_users}")

输出：


  (0, 1)        1
  (0, 4)        1
  (1, 0)        1
  (1, 2)        1
  (2, 1)        1
  (2, 3)        1
  (3, 2)        1
  (3, 4)        1
  (4, 0)        1
  (4, 3)        1
User 0 is connected to users: [1 4]

2.6.8 总结

scipy.sparse 模块为处理大型稀疏矩阵提供了强大的工具。通过选择合适的稀疏矩阵格式并利用其提供的各种运算，可以显著提高内存使用效率和计算速度。在处理具有稀疏结构的数据时，scipy.sparse 是一个不可或缺的工具。掌握scipy.sparse，能够让你在处理大规模数据时更加游刃有余。

作者与出处

原作者：灏天文库

来源：灏天文库

原文： https://aiknowledge.cn/collection/196-scipy%E7%A7%91%E5%AD%A6%E8%AE%A1%E7%AE%97%E5%BA%93%E5%AE%9E%E6%88%98%E6%95%99%E7%A8%8B

整理：灏天文库整理

由灏天文库平台收录，内容或由平台用户上传，仅供学习交流

2.6 `scipy.sparse`：稀疏矩阵

文档摘要