python - 从不规则间隔的向量中选择近似规则的样本

Question

这是我的问题，假设我有一个像这样的向量:

import numpy as np
idxx = np.array([0.        , 0.07665982, 0.24366872, 0.49555099, 0.74743326,
       1.07871321, 1.58247775, 2.24503765, 2.58179329, 3.16221766,
       3.74811773, 4.1615332 , 4.58042437, 5.33059548])

我有兴趣仅过滤掉那些大约 0.25、0.5 和 1.0 倍数的值。让我们从 0.25 开始，演示我希望过滤器返回的内容:

np.array([0.24366872, 0.49555099, 0.74743326,
       1.07871321, 1.58247775, 2.24503765, 2.58179329,
       3.74811773, 4.58042437, 5.33059548])

此处仅保留大约为 0.25 倍数的值。实际上，我还需要保留第一个条目 0.0，但在本演示中已将其删除。

如果我使用 0.5 那么我的结果将如下所示:

np.array([0.49555099, 1.07871321, 1.58247775, 2.58179329, 4.58042437])

我最初的尝试是:

import math
for i in idxx:
    g = 0.25
    k = i % g
    if math.isclose(k, g, rel_tol=0.5):
        print('This is reasonably close: ', i, '\n\t for modulus k == ', k, '\n')

仍然需要我做大量的调整(而且我仍然无法过滤出我想要的东西)，所以我想知道是否有人有更好的方法来正确地做到这一点？

本质上，我想选择那些不规则的点(例如0.24366872)到“规则”间隔的网格(例如0.25的间距)上，但是规则间隔的网格上的每个点都有一定的容差，例如+/- 0.05，以适应实际数据中的不规则性。因此，我可以在这些规则间隔的点处找到位于该公差范围内的点。

Answer 1

你可能会稍微倒退一下。不要试图找到有效的容差(1.07871321 确实会导致问题，不是吗)，只需找到最接近网格点的点即可。

这是一种非常浪费内存的非循环方法，因为它创建了一个完整的 idxx.size-by-n 数组，其中 n 是网格的大小:

def grid_filter(idxx, spacing):
    # use idxx[0] instead of idxx.min() if idxx is sorted
    g0 = np.floor(idxx.min() / spacing) * spacing
    # use idxx[-1] instead of idxx.max() if idxx is sorted
    g1 = np.ceil(idxx.max() / spacing) * spacing
    # turn the grid into a column vector for broadcasting
    n = np.round((g1 - g0) / spacing) + 1
    grid = np.linspace(g0, g1, n).reshape(-1, 1)

    # compute the absolute distance to each point and
    # get the index of the point nearest each grid point:
    # rows are grid points, columns data points
    indices = np.abs(grid - idxx).argmin(axis=1)
    # post-process to ensure that a data point only matches one grid point
    indices = np.unique(indices)

    # apply the result
    return idxx[indices]

浪费的数组是grid - idxx。这可能不会成为问题。 grid_filter(idxx, 0.25) 的结果是:

[ 0. 0.24366872 0.49555099 0.74743326 1.07871321 1.58247775 2.24503765 2.58179329 3.16221766 3.74811773 4.1615332 4.58042437 5.33059548]

如果您对 3.16 和 4.16 进入结果不满意，您可以将容差设置为 spacing 的 1/3 或其他值类似并与之合作:

def tolerance_filter(idxx, spacing, tolerance):
    deltas = (idxx % spacing)
    deltas = np.minimum(deltas, spacing - deltas)
    candidates = deltas <  tolerance * spacing
    return idxx[candidates]

这个解决方案实际上可以满足您的需求，并且是完全矢量化的。 tolerance_filter(idxx, 0.25, 0.33) 返回

[ 0. 0.07665982 0.24366872 0.49555099 0.74743326 1.07871321 1.58247775 2.24503765 2.58179329 3.74811773 4.58042437 5.33059548]

为了进一步摆脱0.07665982，我建议结合使用这些方法:首先过滤以获得最接近每个网格点的元素，然后过滤绝对容差:

tolerance_filter(grid_filter(idxx, 0.25), 0.25, 0.33)

此时您可以做得更好:首先将每个数组元素附加到最近的网格点，如第一部分所示。然后做一些适应性的事情。例如，获取残差的标准差，并丢弃高于标称值 3-sigma 的任何值:

def sigma_filter(idxx, spacing, nsigma):
    deltas = (idxx % spacing)
    deltas[deltas > 0.5 * spacing] -= spacing
    sigma = np.std(deltas)
    candidates = (np.abs(deltas) <= nsigma * sigma)
    return idxx[candidates]