在numpy数组中向前填充NaN值的最有效方法

80

示例问题

作为一个简单的例子,考虑下面定义的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值替换为它左边最近的有效值。期望的结果如下:

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

4
如果一行中的第一个元素是 nan,应该发生什么? - Tadhg McDonald-Jensen
在这种情况下,pandas不会改变NaN。我认为OP希望保持一致的行为。 - DYZ
4
将 1 维 numpy 数组中的零值替换为最后一个非零值。将 1 维 numpy 数组中的零值用最后一个非零值填充。 - blacksite
1
顺便提一下,甚至不需要调用 as_matrix():原始的 arr 已经被更改了。 - DYZ
我正在寻找三维数组的解决方案,对于二维数组来说,最愚蠢的方法是先将其转换为df,然后使用fillna。 - Tommy Yu
显示剩余5条评论
13个回答

77

这里有一种方法 -

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中填充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.]])

3
一个纯粹使用NumPy向量化的解决方案,很不错。谢谢!这个解决方案似乎比基于循环和基于pandas的解决方案更快(请参见更新问题中的计时)。 - Xukrao
@Xukrao 是的,我刚刚看到了那些,谢谢你添加了这些时间结果!很高兴看到有一些加速! - Divakar
3
如何将此解决方案适用于 arr 是一个 一维 的 numpy 数组的情况?例如:numpy.array([0.83, 0.83, 0.83, 0.83, nan, nan, nan]) - user189035
4
请将mask.shape[1]替换为mask.size,删除axis=1,并将最后一行替换为out = arr[idx] - C8H10N4O2
我曾经遇到这样一个情况,我建立了第二个矩阵来进行前向填充。在最后一行中,我只需将“arr”替换为“fillMatrix”。我的情况是针对时间序列数据降低分辨率,因此我使用最近的条目进行前向填充。 - financial_physician
@Xukrao 这种方法在很多情况下都不起作用。请看我的回答,我放了一个它无法处理的例子! - LearnToGrow

8

我喜欢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)]

据我所知,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.]]]

7

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


对于那些寻找NaN值后向填充的人,我修改了Divakar提供的解决方案(在此处),以实现该目的。诀窍是您必须使用最小值除最大值外,在反转数组上进行累加。以下是代码:

# 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_ 的评论进行更新


1
idx = np.where(~mask, np.arange(mask.shape[1]), mask.shape[0] + 1) in bfill should be idx = np.where(~mask, np.arange(mask.shape[1]), mask.shape[1] - 1) - MS_
1
翻转操作的时间复杂度不是O(n)吗?而你现在要进行两次翻转,所以使用翻转、前向填充,再翻转回去的方法,速度应该和你用原始数组进行bfill操作的方法一样快,对吧? - financial_physician
谢谢!这确实是一个非常好的观点。我使用%%timeit测试了你的解决方案和我的解决方案,只有微不足道但一致的差异,10.3微秒(你的解决方案)与9.95微秒(我的解决方案)。我会相应地更新我的回答。 - cchwala

5
bottleneck push function” 是向前填充的一个良好选择。它通常用于像Xarray这样的包内部,比其他替代方案更快,并且该包还有一组基准测试
示例:
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.]])

4

使用Numba. 这将会显著提升速度:

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

Numba只会加速基于循环的解决方案吗?还是它也会加速其他解决方案? - Xukrao
它对于循环非常有效,但不会加速在numpy/pandas中实现的功能。 - shx2
1
谢谢!我已经将这个解决方案包含在时间比较中(请参见更新的问题)。看起来,将numba装饰器添加到基于循环的解决方案中可以将其运行时间减少一个数量级。 - Xukrao

3

我喜欢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.nan(无论是在开头还是中间),只需多次重复此操作即可。例如,如果数组有连续的5个np.nan,则以下代码将用这些np.nan之前的数字“向前填充”它们:

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

3
使用瓶颈模块,它与pandas或numpy模块一起提供,因此无需单独安装。
以下代码应该给您所需的结果。
import bottleneck as bn
bn.push(arr,axis=1)

2

对于那些对于前向填充后出现引导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的问题”是指什么? - Xukrao
2
在本帖的示例数组中,每个条目都以非NaN值开头。有些人可能会发现自己处理的数据集需要向后填充,因为向前填充会使第一个条目保持不变。因此,我认为在这个帖子中提供一个解决方案可能会很有用。 - christian_bock

1

一句话概括:

result = np.where(np.isnan(arr), 0, arr)

在一个强制使用浮点数的函数中(在我的情况下需要这样做,因为我使用了dtype=object)。
def fillna(arr):
    arr = np.array(arr,dtype=float)
    out = np.where(np.isnan(arr), 0, arr)
    return out
arr = np.array([[5, np.nan, np.nan, 7, 2],
                [3, np.nan, 1, 8, np.nan],
                [4, 9, 6, np.nan, np.nan]])


result = fillna(arr)
print(result)
# result
# array([[5., 0., 0., 7., 2.],
#        [3., 0., 1., 8., 0.],
#        [4., 9., 6., 0., 0.]])


但这只是填充了0。问题是关于向前填充(即使用左侧的值)。 - tdy

1

网页内容由stack overflow 提供, 点击上面的
可以查看英文原文,
原文链接