Python中稀疏矩阵的裁剪、扁平化与拼接：scipy.sparse原生实现咨询

问题背景 #

我自己写了一段代码，通过数组和循环实现了对两个稀疏矩阵的裁剪（移除边缘）、扁平化操作，最后将它们拼接成一个新的稀疏矩阵。想请教是否可以直接用scipy.sparse的原生方法完成这些操作？

以下是我的实现代码和示例输出：

原实现代码 #

import numpy as np
from scipy import sparse as sps

# 构造两个稀疏矩阵
rng = np.random.default_rng()
S_matrix_1 = sps.random(4,5,density=0.5,random_state=rng)
S_matrix_2 = sps.random(4,5,density=0.5,random_state=rng)


# 打印矩阵
print('###########################################')

S_array_1 = S_matrix_1.toarray()
print('稀疏矩阵1: ',S_array_1.shape)
print(S_array_1)

print('###########################################')

S_array_2 = S_matrix_2.toarray()
print('稀疏矩阵2: ',S_array_2.shape)
print(S_array_2)

# 裁剪矩阵（移除边缘）
print('###########################################')

S_cut_1 = S_array_1[1:S_array_1.shape[0]-1,1:S_array_1.shape[1]-1]
print('裁剪后的稀疏矩阵1:', S_cut_1.shape)
print(S_cut_1)

print('###########################################')

S_cut_2 = S_array_2[1:S_array_2.shape[0]-1,1:S_array_2.shape[1]-1]
print('裁剪后的稀疏矩阵2:', S_cut_2.shape)
print(S_cut_2)

print('###########################################')

# 扁平化矩阵以便堆叠
S_vector_1 = S_cut_1.flatten()
S_vector_2 = S_cut_2.flatten()

col = []
data = []
row = []

# 收集列数据，使第一个矩阵位于第一行（0行）
c = 0
for i in S_vector_1:
    if i != 0:
        data.append(i)
        col.append(c)
        row.append(0)
    c += 1

# 收集列数据，使第二个矩阵位于第二行（1行）
c = 0
for i in S_vector_2:
    if i != 0:
        data.append(i)
        col.append(c)
        row.append(1)
    c += 1

print('两个扁平化稀疏矩阵组合后的行、列、数据')
print(row,col,data)

# 构造组合稀疏矩阵，每行对应一个扁平化的稀疏矩阵
sparse_matrix = sps.coo_matrix((data, (row, col)),shape=(2,np.prod(S_cut_1.shape)))

print('###########################################')
print('组合后的稀疏矩阵（每行对应一个扁平化稀疏矩阵）')
print(sparse_matrix.toarray())

示例输出 #

###########################################
稀疏矩阵1:  (4, 5)
[[0.         0.         0.68617742 0.         0.        ]
 [0.76825482 0.3582357  0.         0.0248112  0.        ]
 [0.         0.33983419 0.         0.37449198 0.        ]
 [0.         0.13352901 0.79960432 0.79339374 0.48830805]]
###########################################
稀疏矩阵2:  (4, 5)
[[0.         0.40899129 0.         0.         0.        ]
 [0.26789314 0.         0.950261   0.         0.21694661]
 [0.51039687 0.29567104 0.30580362 0.42007714 0.        ]
 [0.         0.         0.25469614 0.02599109 0.        ]]
###########################################
裁剪后的稀疏矩阵1: (2, 3)
[[0.3582357  0.         0.0248112 ]
 [0.33983419 0.         0.37449198]]
###########################################
裁剪后的稀疏矩阵2: (2, 3)
[[0.         0.950261   0.        ]
 [0.29567104 0.30580362 0.42007714]]
###########################################
两个扁平化稀疏矩阵组合后的行、列、数据
[0, 0, 0, 0, 1, 1, 1, 1] [0, 2, 3, 5, 1, 3, 4, 5] [0.3582356963462584, 0.024811195277762876, 0.33983419283389527, 0.3744919847066006, 0.9502610017191933, 0.2956710439200694, 0.30580361813501, 0.420077135385148]
###########################################
组合后的稀疏矩阵（每行对应一个扁平化稀疏矩阵）
[[0.3582357  0.         0.0248112  0.33983419 0.         0.37449198]
 [0.         0.950261   0.         0.29567104 0.30580362 0.42007714]]

解决方案：用scipy.sparse原生方法实现 #

完全可以用scipy.sparse的原生方法完成这些操作，而且全程无需转成密集数组，效率更高（尤其适合大规模稀疏矩阵）。步骤如下：

1. 直接裁剪稀疏矩阵 #

scipy.sparse的矩阵支持原生切片操作，直接对原稀疏矩阵裁剪边缘即可：

# 裁剪稀疏矩阵：移除第一行、最后一行，第一列、最后一列
S_cut_1 = S_matrix_1[1:-1, 1:-1]
S_cut_2 = S_matrix_2[1:-1, 1:-1]

2. 扁平化稀疏矩阵为行向量 #

使用reshape方法将裁剪后的稀疏矩阵直接转为行向量，保持稀疏格式：

# 将矩阵扁平化为shape=(1, N)的稀疏行向量
S_flat_1 = S_cut_1.reshape(1, -1)
S_flat_2 = S_cut_2.reshape(1, -1)

3. 垂直拼接得到目标稀疏矩阵 #

用sps.vstack方法直接拼接两个稀疏行向量，得到最终的2行稀疏矩阵：

# 垂直拼接两个行向量
final_sparse = sps.vstack([S_flat_1, S_flat_2])

完整优化代码 #

import numpy as np
from scipy import sparse as sps

# 构造两个稀疏矩阵
rng = np.random.default_rng()
S_matrix_1 = sps.random(4,5,density=0.5,random_state=rng)
S_matrix_2 = sps.random(4,5,density=0.5,random_state=rng)

# 1. 裁剪稀疏矩阵
S_cut_1 = S_matrix_1[1:-1, 1:-1]
S_cut_2 = S_matrix_2[1:-1, 1:-1]

# 2. 扁平化稀疏矩阵为行向量
S_flat_1 = S_cut_1.reshape(1, -1)
S_flat_2 = S_cut_2.reshape(1, -1)

# 3. 垂直拼接得到目标矩阵
final_sparse = sps.vstack([S_flat_1, S_flat_2])

# 验证结果
print('组合后的稀疏矩阵（每行对应一个扁平化稀疏矩阵）')
print(final_sparse.toarray())

关键优势 #

• 全程保持稀疏格式，避免密集数组转换带来的内存开销，适合处理大规模矩阵。
• 代码简洁，无需手动循环收集非零元素，原生方法实现更高效、易维护。

内容的提问来源于stack exchange，提问作者EpsilonEngineer