Question

我有一个稀疏矩阵，我需要为每个索引创建一个新的邻居矩阵。

下面，我将数据的表示形式保留在NxM矩阵中。对于矩阵的每个元素，我需要在KxK的一部分中获取邻居。有了这些信息，它将生成一个NMxKK矩阵，该矩阵在每一行中都包含该元素的相邻KK的索引。

不久前，我问过类似的question，但是不同的是，现在数据已经结构化了，所以我可以不用KdTree。

此新矩阵用于计算非零邻居的距离，并将这些距离与每个邻居的权重相关联，最终将所需值估计为邻居的weighted average。

谢谢！

更新

我有图像中的数据（通过功能generate_data生成），我需要执行以下操作。

给出一个过滤器/内核/ NxN矩阵，其中N是我定义的内核大小，请为非零值计算相对于中心像素的距离。以在图像位置20中的值(1, 8)为例。取5x5的矩阵，感兴趣的非零值为40（在(0, 6)中），37（在(1, 6)中）和25（在(3, 10)中，距离分别为2.23606798，2和2.82842712（获得索引之间的欧几里得范数）。

我需要在此步骤中得到的矩阵res：

[[0.         2.23606798 2.         0.         0.        ]
 [0.         0.         0.         0.         0.        ]
 [0.         0.         1.         0.         0.        ]
 [0.         0.         0.         0.         0.        ]
 [0.         0.         0.         0.         2.82842712]]

我还需要获取矩阵中心的1.，以考虑到我所站立的位置（其与自身的距离为0.）。

使用这些值，我得到具有非零值的蒙版，并根据高斯分布计算权重：

import scipy.stats as st 
mask = 0 < res
gauss = st.norm.pdf(res) # or st.norm.pdf(mask * kernel(5))

[[0.        , 0.03274718, 0.05399097, 0.        , 0.        ],
 [0.        , 0.        , 0.        , 0.        , 0.        ],
 [0.        , 0.        , 0.39894228, 0.        , 0.        ],
 [0.        , 0.        , 0.        , 0.        , 0.        ],
 [0.        , 0.        , 0.        , 0.        , 0.00730688]])

total = gauss.sum() # 0.4929873057962355

最后，使用这些权重，通过对值进行插值来计算权重和像素的最终值。

val[1, 8] = 0.03274718 * 40 / total + 0.05399097 * 37 / total + 0.39894228 * 20 / total + 0.00730688 * 25 / total

我必须对每个像素执行相同的操作（我想我必须添加kernel_size padding // 2才能使用整个数组）。

这是我的剧本

import matplotlib.pylab as plt
import numpy as np
import scipy.stats as st

from scipy import sparse


def generate_data(m, n, density):
    s = 64 * sparse.random(m, n, density=density).A
    return s.astype(np.int8)


def plot_matrix(matrix):
    for (j, i), label in np.ndenumerate(s):
        plt.text(i, j, label, ha='center', va='center')

    plt.imshow(matrix)
    plt.show()


def kernel(n):
    n = n if n % 2 != 0 else n + 1
    mid = n // 2

    m = np.ndarray((n, n, 2))
    for i in range(n):
        for j in range(n):
            m[i, j] = np.array([i, j])

    return np.linalg.norm(m - [mid, mid], axis=2)


s = generate_data(10, 14, 0.25)
plot_matrix(s)

Answer 1

这真的很简单，尽管可能不是很有效。我要做的是两个卷积：

首先，它是高斯核与矩阵的卷积

conv_1 = convolve2d（m * mask_clean，k_gauss）
第二个是带掩码的高斯核

conv_2 = convolve2d（mask_clean，k_gauss）

在每个位置，conv_1将使每个值的总和乘以高斯核的相应因子。 conv_2在每个位置将具有所有非零值的总和。剩下要做的就是将它们除以得到最终结果

# m have the data
mask_clean = (0 < m) & (m_mean - 3*m_std < m) & (m < m_mean + 3*m_std)

# Custom function to create a gaussian kernel
k = gkern(kernlen=5, std=5//2)
k_gauss = st.norm.pdf(k)

conv_1 = convolve2d(m * mask_clean, k_gauss)
conv_2 = convolve2d(mask_clean, k_gauss)
final = conv_1 / conv_2

创建邻居矩阵

1 个答案: