基于SciPy实现指定重叠度的数组拼接并保留稀疏结构

初始矩阵与块对角矩阵示例 #

首先定义两个3x3的NumPy矩阵：

import numpy as np
A = np.linspace(1,9,9).reshape(3,3)
B = np.linspace(10,18,9).reshape(3,3)

使用scipy.linalg.block_diag可以将它们组合为块对角矩阵：

from scipy.linalg import block_diag
block_diag(A,B)

输出结果为：

array([[ 1.,  2.,  3.,  0.,  0.,  0.],
       [ 4.,  5.,  6.,  0.,  0.,  0.],
       [ 7.,  8.,  9.,  0.,  0.,  0.],
       [ 0.,  0.,  0., 10., 11., 12.],
       [ 0.,  0.,  0., 13., 14., 15.],
       [ 0.,  0.,  0., 16., 17., 18.]])

需求说明 #

需要生成重叠度为2的矩阵：重叠区域的元素取两个矩阵对应位置的平均值，同时保留稀疏结构（避免生成完整稠密数组）。目标矩阵如下：

array([[ 1.,      2.,         3.,       0.],
       [ 4.,  (10.+5.)/2,  (6.+11.)/2,  12.],
       [ 7.,  (13.+8.)/2,  (14.+9.)/2,  15.],
       [ 0.,      16.,       17.,      18.]])

稀疏矩阵实现方案 #

利用scipy.sparse的工具可以高效构建这类带重叠的稀疏矩阵，全程避免生成中间稠密数组：

步骤1：导入依赖库 #

import numpy as np
from scipy.sparse import bmat, csr_matrix

步骤2：定义矩阵与重叠参数 #

A = np.linspace(1,9,9).reshape(3,3)
B = np.linspace(10,18,9).reshape(3,3)
overlap = 2  # 重叠度

步骤3：拆分并构建稀疏块 #

将两个矩阵拆分为非重叠区域、重叠区域（取平均），再用bmat组合成稀疏矩阵：

# 拆分各区域并转换为稀疏矩阵
top_left = csr_matrix(A[:-overlap, :-overlap])
top_mid = csr_matrix(A[:-overlap, -overlap:])
top_right = csr_matrix((A.shape[0]-overlap, B.shape[1]-overlap))  # 零块

mid_left = csr_matrix(A[-overlap:, :-overlap])
mid_mid = csr_matrix((A[-overlap:, -overlap:] + B[:overlap, :overlap]) / 2)
mid_right = csr_matrix(B[:overlap, overlap:])

bot_left = csr_matrix((B.shape[0]-overlap, A.shape[1]-overlap))  # 零块
bot_mid = csr_matrix(B[overlap:, :overlap])
bot_right = csr_matrix(B[overlap:, overlap:])

# 组合为稀疏矩阵
sparse_result = bmat([
    [top_left, top_mid, top_right],
    [mid_left, mid_mid, mid_right],
    [bot_left, bot_mid, bot_right]
], format='csr')

步骤4：查看结果 #

转换为稠密数组验证：

print(sparse_result.toarray())

输出：

array([[ 1. ,  2. ,  3. ,  0. ],
       [ 4. ,  7.5,  8.5, 12. ],
       [ 7. , 10.5, 11.5, 15. ],
       [ 0. , 16. , 17. , 18. ]])

通用封装函数 #

如果需要支持任意合法重叠度（不超过矩阵最小维度），可以封装为函数：

def sparse_overlap_block(A, B, overlap):
    if overlap > min(A.shape) or overlap > min(B.shape):
        raise ValueError("重叠度不能超过矩阵的最小维度")
    
    # 构建各稀疏块
    block_top_left = csr_matrix(A[:-overlap, :-overlap])
    block_top_mid = csr_matrix(A[:-overlap, -overlap:])
    block_top_right = csr_matrix((A.shape[0]-overlap, B.shape[1]-overlap))
    
    block_mid_left = csr_matrix(A[-overlap:, :-overlap])
    block_mid_mid = csr_matrix((A[-overlap:, -overlap:] + B[:overlap, :overlap])/2)
    block_mid_right = csr_matrix(B[:overlap, overlap:])
    
    block_bot_left = csr_matrix((B.shape[0]-overlap, A.shape[1]-overlap))
    block_bot_mid = csr_matrix(B[overlap:, :overlap])
    block_bot_right = csr_matrix(B[overlap:, overlap:])
    
    return bmat([
        [block_top_left, block_top_mid, block_top_right],
        [block_mid_left, block_mid_mid, block_mid_right],
        [block_bot_left, block_bot_mid, block_bot_right]
    ], format='csr')

# 使用示例
result = sparse_overlap_block(A, B, overlap=2)
print(result.toarray())

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