【问题标题】:Most efficient way to forward-fill NaN values in numpy array在 numpy 数组中前向填充 NaN 值的最有效方法
【发布时间】:2017-05-02 15:09:13
【问题描述】:

示例问题

作为一个简单的例子,考虑如下定义的numpy数组arr

import numpy as np
arr = np.array([[5, np.nan, np.nan, 7, 2],
                [3, np.nan, 1, 8, np.nan],
                [4, 9, 6, np.nan, np.nan]])

arr 在控制台输出中如下所示:

array([[  5.,  nan,  nan,   7.,   2.],
       [  3.,  nan,   1.,   8.,  nan],
       [  4.,   9.,   6.,  nan,  nan]])

我现在想逐行“向前填充”数组arr 中的nan 值。我的意思是用左边最接近的有效值替换每个nan 值。期望的结果如下所示:

array([[  5.,   5.,   5.,  7.,  2.],
       [  3.,   3.,   1.,  8.,  8.],
       [  4.,   9.,   6.,  6.,  6.]])

到目前为止尝试过

我尝试过使用 for 循环:

for row_idx in range(arr.shape[0]):
    for col_idx in range(arr.shape[1]):
        if np.isnan(arr[row_idx][col_idx]):
            arr[row_idx][col_idx] = arr[row_idx][col_idx - 1]

我也尝试使用 pandas 数据框作为中间步骤(因为 pandas 数据框有一个非常简洁的内置方法用于前向填充):

import pandas as pd
df = pd.DataFrame(arr)
df.fillna(method='ffill', axis=1, inplace=True)
arr = df.as_matrix()

上述两种策略都产生了预期的结果,但我一直在想:仅使用 numpy 矢量化操作的策略不是最有效的策略吗?


总结

还有另一种更有效的方法来“向前填充”numpy 数组中的nan 值吗? (例如,通过使用 numpy 向量化操作)


更新:解决方案比较

到目前为止,我已尝试对所有解决方案进行计时。这是我的设置脚本:

import numba as nb
import numpy as np
import pandas as pd

def random_array():
    choices = [1, 2, 3, 4, 5, 6, 7, 8, 9, np.nan]
    out = np.random.choice(choices, size=(1000, 10))
    return out

def loops_fill(arr):
    out = arr.copy()
    for row_idx in range(out.shape[0]):
        for col_idx in range(1, out.shape[1]):
            if np.isnan(out[row_idx, col_idx]):
                out[row_idx, col_idx] = out[row_idx, col_idx - 1]
    return out

@nb.jit
def numba_loops_fill(arr):
    '''Numba decorator solution provided by shx2.'''
    out = arr.copy()
    for row_idx in range(out.shape[0]):
        for col_idx in range(1, out.shape[1]):
            if np.isnan(out[row_idx, col_idx]):
                out[row_idx, col_idx] = out[row_idx, col_idx - 1]
    return out

def pandas_fill(arr):
    df = pd.DataFrame(arr)
    df.fillna(method='ffill', axis=1, inplace=True)
    out = df.as_matrix()
    return out

def numpy_fill(arr):
    '''Solution provided by Divakar.'''
    mask = np.isnan(arr)
    idx = np.where(~mask,np.arange(mask.shape[1]),0)
    np.maximum.accumulate(idx,axis=1, out=idx)
    out = arr[np.arange(idx.shape[0])[:,None], idx]
    return out

随后是此控制台输入:

%timeit -n 1000 loops_fill(random_array())
%timeit -n 1000 numba_loops_fill(random_array())
%timeit -n 1000 pandas_fill(random_array())
%timeit -n 1000 numpy_fill(random_array())

导致此控制台输出:

1000 loops, best of 3: 9.64 ms per loop
1000 loops, best of 3: 377 µs per loop
1000 loops, best of 3: 455 µs per loop
1000 loops, best of 3: 351 µs per loop

【问题讨论】:

  • 如果一行中的第一个元素是nan会发生什么?
  • @TadhgMcDonald-Jensen 在这种情况下,pandas 保持NaN 不变。我会假设 OP 需要相同的行为以保持一致性。
  • 啊,好问题。在我的用例中,输入数组的第一列不应该包含任何 nan 值。因此,当代码(在第一列中遇到 nan 时)引发异常或将 nan 留在原处时,我可以接受。
  • 顺便说一句,甚至不需要打电话给as_matrix():原来的arr被改变了。

标签: python arrays performance pandas numpy


【解决方案1】:

这是一种方法 -

mask = np.isnan(arr)
idx = np.where(~mask,np.arange(mask.shape[1]),0)
np.maximum.accumulate(idx,axis=1, out=idx)
out = arr[np.arange(idx.shape[0])[:,None], idx]

如果您不想创建另一个数组而只是在 arr 本身中填充 NaN,请将最后一步替换为 -

arr[mask] = arr[np.nonzero(mask)[0], idx[mask]]

样本输入、输出-

In [179]: arr
Out[179]: 
array([[  5.,  nan,  nan,   7.,   2.,   6.,   5.],
       [  3.,  nan,   1.,   8.,  nan,   5.,  nan],
       [  4.,   9.,   6.,  nan,  nan,  nan,   7.]])

In [180]: out
Out[180]: 
array([[ 5.,  5.,  5.,  7.,  2.,  6.,  5.],
       [ 3.,  3.,  1.,  8.,  8.,  5.,  5.],
       [ 4.,  9.,  6.,  6.,  6.,  6.,  7.]])

【讨论】:

  • 一个矢量化的 numpy-only 解决方案,很好。谢谢!此解决方案确实似乎比基于循环和基于 pandas 的解决方案更快(请参阅更新问题中的时间)。
  • @Xukrao 是的,我刚看到这些,感谢您添加这些计时结果!很高兴看到那里有一些加速!
  • 如果 arr 是 一维 numpy 数组,您如何调整此解决方案?喜欢numpy.array([0.83, 0.83, 0.83, 0.83, nan, nan, nan])
  • @user189035 将mask.shape[1] 替换为mask.size 并删除axis=1 并将最后一行替换为out = arr[idx]
  • 我有一个案例,我为想要前向填充的内容构建了第二个矩阵。在最后一行,我刚刚将arr 替换为fillMatrix。我的案例是降低时间序列数据的分辨率,所以我转发了最近的条目
【解决方案2】:

更新:正如金融物理学家在 cmets 中指出的那样,我最初提出的解决方案可以简单地与反转数组上的ffill 交换,然后反转结果。没有相关的性能损失。根据%timeit,我的初始解决方案似乎快了 2% 或 3%。我更新了下面的代码示例,但保留了我的初始文本。


对于那些来这里寻找 NaN 值的反向填充的人,我修改了 the solution provided by Divakar above 来做到这一点。诀窍是您必须使用除最大值之外的最小值对反转数组进行累加。

代码如下:


# ffill along axis 1, as provided in the answer by Divakar
def ffill(arr):
    mask = np.isnan(arr)
    idx = np.where(~mask, np.arange(mask.shape[1]), 0)
    np.maximum.accumulate(idx, axis=1, out=idx)
    out = arr[np.arange(idx.shape[0])[:,None], idx]
    return out

# Simple solution for bfill provided by financial_physician in comment below
def bfill(arr): 
    return ffill(arr[:, ::-1])[:, ::-1]

# My outdated modification of Divakar's answer to do a backward-fill
def bfill_old(arr):
    mask = np.isnan(arr)
    idx = np.where(~mask, np.arange(mask.shape[1]), mask.shape[1] - 1)
    idx = np.minimum.accumulate(idx[:, ::-1], axis=1)[:, ::-1]
    out = arr[np.arange(idx.shape[0])[:,None], idx]
    return out


# Test both functions
arr = np.array([[5, np.nan, np.nan, 7, 2],
                [3, np.nan, 1, 8, np.nan],
                [4, 9, 6, np.nan, np.nan]])
print('Array:')
print(arr)

print('\nffill')
print(ffill(arr))

print('\nbfill')
print(bfill(arr))

输出:

Array:
[[ 5. nan nan  7.  2.]
 [ 3. nan  1.  8. nan]
 [ 4.  9.  6. nan nan]]

ffill
[[5. 5. 5. 7. 2.]
 [3. 3. 1. 8. 8.]
 [4. 9. 6. 6. 6.]]

bfill
[[ 5.  7.  7.  7.  2.]
 [ 3.  1.  1.  8. nan]
 [ 4.  9.  6. nan nan]]

编辑:根据MS_的评论更新

【讨论】:

  • idx = np.where(~mask, np.arange(mask.shape[1]), mask.shape[0] + 1) in bfill 应该是 idx = np.where(~mask, np.arange(mask.shape[1]), mask.shape[1] - 1)
  • 不是翻转 O(n) 并且您要进行两次翻转,因此使用前向填充然后取消翻转不会与使用原始数组的 bfill 方法一样快吗?
  • 谢谢!这确实是一个非常好的观点。我确实使用%%timeit 为您的解决方案和我的解决方案计时,只有一个微不足道但一致的差异,10.3 µs(您的解决方案)与 9.95 µs(我的解决方案)。我会相应地更新我的回复。
【解决方案3】:

使用Numba。这应该会显着加快速度:

import numba
@numba.jit
def loops_fill(arr):
    ...

【讨论】:

  • Numba 是否只会加速基于循环的解决方案?或者它会加快其他解决方案的速度吗?
  • 对循环有好处。它不会加速在 numpy/pandas 中实现的功能。
  • 谢谢!我已将此解决方案包含在时间比较中(请参阅更新的问题)。看起来向基于循环的解决方案添加 numba 装饰器将其运行时间减少了一个数量级。
【解决方案4】:

我喜欢 Divakar 关于纯 numpy 的回答。 这是一个用于 n 维数组的通用函数:

def np_ffill(arr, axis):
    idx_shape = tuple([slice(None)] + [np.newaxis] * (len(arr.shape) - axis - 1))
    idx = np.where(~np.isnan(arr), np.arange(arr.shape[axis])[idx_shape], 0)
    np.maximum.accumulate(idx, axis=axis, out=idx)
    slc = [np.arange(k)[tuple([slice(None) if dim==i else np.newaxis
        for dim in range(len(arr.shape))])]
        for i, k in enumerate(arr.shape)]
    slc[axis] = idx
    return arr[tuple(slc)]

AFIK pandas 只能处理二维,尽管有多个索引来弥补它。实现此目的的唯一方法是展平 DataFrame,取消堆叠所需级别,重新堆叠,最后重塑为原始数据。这种拆分/重新堆叠/重新整形,涉及到 pandas 排序,只是实现相同结果的不必要开销。

测试:

def random_array(shape):
    choices = [1, 2, 3, 4, np.nan]
    out = np.random.choice(choices, size=shape)
    return out

ra = random_array((2, 4, 8))
print('arr')
print(ra)
print('\nffull')
print(np_ffill(ra, 1))
raise SystemExit

输出:

arr
[[[ 3. nan  4.  1.  4.  2.  2.  3.]
  [ 2. nan  1.  3. nan  4.  4.  3.]
  [ 3.  2. nan  4. nan nan  3.  4.]
  [ 2.  2.  2. nan  1.  1. nan  2.]]

 [[ 2.  3.  2. nan  3.  3.  3.  3.]
  [ 3.  3.  1.  4.  1.  4.  1. nan]
  [ 4.  2. nan  4.  4.  3. nan  4.]
  [ 2.  4.  2.  1.  4.  1.  3. nan]]]

ffull
[[[ 3. nan  4.  1.  4.  2.  2.  3.]
  [ 2. nan  1.  3.  4.  4.  4.  3.]
  [ 3.  2.  1.  4.  4.  4.  3.  4.]
  [ 2.  2.  2.  4.  1.  1.  3.  2.]]

 [[ 2.  3.  2. nan  3.  3.  3.  3.]
  [ 3.  3.  1.  4.  1.  4.  1.  3.]
  [ 4.  2.  1.  4.  4.  3.  1.  4.]
  [ 2.  4.  2.  1.  4.  1.  3.  4.]]]

【讨论】:

    【解决方案5】:

    我喜欢 Divakar 的回答,但它不适用于行以 np.nan 开头的边缘情况,例如下面的 arr

    arr = np.array([[9, np.nan, 4, np.nan, 6, 6, 7, 2, 3, np.nan],
    [ np.nan, 5, 5, 6, 5, 3, 2, 1, np.nan, 10]])
    

    使用 Divakar 代码的输出将是:

    [[ 9.  9.  4.  4.  6.  6.  7.  2.  3.  3.]
     [nan  4.  5.  6.  5.  3.  2.  1.  1. 10.]]
    

    Divakar的代码可以简化一点,简化版同时解决了这个问题:

    arr[np.isnan(arr)] = arr[np.nonzero(np.isnan(arr))[0], np.nonzero(np.isnan(arr))[1]-1]
    
    

    如果连续有多个np.nans(无论是在开头还是在中间),只需重复此操作几次即可。例如,如果数组有 5 个连续的np.nans,下面的代码将用这些np.nans 之前的数字“前向填充”它们:

    for i in range(0, 5):
       value[np.isnan(value)] = value[np.nonzero(np.isnan(value))[0], np.nonzero(np.isnan(value))[1]-1]
    

    【讨论】:

      【解决方案6】:

      对于那些对前向填充后有前导np.nan的问题感兴趣的人,以下工作:

      mask = np.isnan(arr)
      first_non_zero_idx = (~mask!=0).argmax(axis=1) #Get indices of first non-zero values
      arr = [ np.hstack([
                   [arr[i,first_nonzero]]*(first_nonzero), 
                   arr[i,first_nonzero:]])
                   for i, first_nonzero in enumerate(first_non_zero_idx) ]
      

      【讨论】:

      • 我不确定我是否理解这段代码的目的。 “前向填充后出现领先的 np.nan 问题”到底是什么意思?
      • 在威胁开头的示例数组中,每个条目都以非 nan 开头。有些人可能会发现自己正在处理需要反向填充的数据集,因为正向填充会使第一个条目保持不变。因此,我认为在这种威胁中提出解决方案可能会很有用。
      【解决方案7】:

      如果你愿意使用 Pandas/xarray:让axis为你希望填充/填充的方向,如下图,

      xr.DataArray(arr).ffill(f'dim_{axis}').values
      xr.DataArray(arr).bfill(f'dim_{axis}').values
      

      更多信息: http://xarray.pydata.org/en/stable/generated/xarray.DataArray.ffill.html https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.ffill.html

      【讨论】:

        【解决方案8】:

        bottleneck push function 是向前填充的好选择。它通常在 Xarray 等软件包内部使用,它应该比其他替代品更快,并且该软件包还有一组 benchmarks

        例子:

        import numpy as np
        
        from bottleneck import push
        
        a = np.array(
            [
                [1, np.nan, 3],
                [np.nan, 3, 2],
                [2, np.nan, np.nan]
            ]
        )
        push(a, axis=0)
        array([[ 1., nan,  3.],
               [ 1.,  3.,  2.],
               [ 2.,  3.,  2.]])
        

        【讨论】:

          【解决方案9】:

          除非我错过了什么,否则解决方案不适用于任何示例:

          arr  = np.array([[ 3.],
           [ 8.],
           [np.nan],
           [ 7.],
           [np.nan],
           [ 1.],
           [np.nan],
           [ 3.],
           [ 8.],
           [ 8.]])
          print("A:::: \n", arr)
          
          print("numpy_fill::: \n ",  numpy_fill(arr))
          print("loop_fill",  loops_fill(arr))
          
          A:::: 
           [[ 3.]
           [ 8.]
           [nan]
           [ 7.]
           [nan]
           [ 1.]
           [nan]
           [ 3.]
           [ 8.]
           [ 8.]]
          numpy_fill::: 
            [[ 3.]
           [ 8.]
           [nan]
           [ 7.]
           [nan]
           [ 1.]
           [nan]
           [ 3.]
           [ 8.]
           [ 8.]]
          loop_fill [[ 3.]
           [ 8.]
           [nan]
           [ 7.]
           [nan]
           [ 1.]
           [nan]
           [ 3.]
           [ 8.]
           [ 8.]]
          
          Comments ??
          

          【讨论】:

            【解决方案10】:

            我用过 np.nan_to_num 示例:

            data = np.nan_to_num(data, data.mean())
            

            参考:Numpy document

            【讨论】:

              猜你喜欢
              • 2022-01-20
              • 1970-01-01
              • 2020-09-14
              • 2021-09-12
              • 1970-01-01
              • 2011-04-19
              • 1970-01-01
              • 1970-01-01
              • 2021-06-03
              相关资源
              最近更新 更多