Interpoluj wartości NaN w tablicy numpy

Wymyśliłem ten kod:

import numpy as np
nan = np.nan

A = np.array([1, nan, nan, 2, 2, nan, 0])

ok = -np.isnan(A)
xp = ok.ravel().nonzero()[0]
fp = A[-np.isnan(A)]
x  = np.isnan(A).ravel().nonzero()[0]

A[np.isnan(A)] = np.interp(x, xp, fp)

print A

Drukuje

 [ 1.          1.33333333  1.66666667  2.          2.          1.          0.        ]

Wystarczy użyć numpy logical and there where, aby zastosować interpolację 1D.

import numpy as np
from scipy import interpolate

def fill_nan(A):
    '''
    interpolate to fill nan values
    '''
    inds = np.arange(A.shape[0])
    good = np.where(np.isfinite(A))
    f = interpolate.interp1d(inds[good], A[good],bounds_error=False)
    B = np.where(np.isfinite(A),A,f(inds))
    return B

Może być łatwiej zmienić sposób generowania danych, ale jeśli nie:

bad_indexes = np.isnan(data)

Tworzenie tablicy logicznej wskazującej gdzie są Nan

good_indexes = np.logical_not(bad_indexes)

Utwórz tablicę logiczną wskazującą, gdzie znajduje się obszar dobrych wartości

good_data = data[good_indexes]

Ograniczona wersja oryginalnych danych z wyłączeniem Nan

interpolated = np.interp(bad_indexes.nonzero(), good_indexes.nonzero(), good_data)

Uruchom wszystkie złe indeksy przez interpolację

data[bad_indexes] = interpolated

Zastąp oryginalne dane wartościami interpolowanymi.

Lub bazując na odpowiedzi Winstona

def pad(data):
    bad_indexes = np.isnan(data)
    good_indexes = np.logical_not(bad_indexes)
    good_data = data[good_indexes]
    interpolated = np.interp(bad_indexes.nonzero()[0], good_indexes.nonzero()[0], good_data)
    data[bad_indexes] = interpolated
    return data

A = np.array([[1, 20, 300],
              [nan, nan, nan],
              [3, 40, 500]])

A = np.apply_along_axis(pad, 0, A)
print A

Wynik

[[   1.   20.  300.]
 [   2.   30.  400.]
 [   3.   40.  500.]]

Dla danych dwuwymiarowych, SciPy griddata działa dość dobrze dla mnie:

>>> import numpy as np
>>> from scipy.interpolate import griddata
>>>
>>> # SETUP
>>> a = np.arange(25).reshape((5, 5)).astype(float)
>>> a
array([[  0.,   1.,   2.,   3.,   4.],
       [  5.,   6.,   7.,   8.,   9.],
       [ 10.,  11.,  12.,  13.,  14.],
       [ 15.,  16.,  17.,  18.,  19.],
       [ 20.,  21.,  22.,  23.,  24.]])
>>> a[np.random.randint(2, size=(5, 5)).astype(bool)] = np.NaN
>>> a
array([[ nan,  nan,  nan,   3.,   4.],
       [ nan,   6.,   7.,  nan,  nan],
       [ 10.,  nan,  nan,  13.,  nan],
       [ 15.,  16.,  17.,  nan,  19.],
       [ nan,  nan,  22.,  23.,  nan]])
>>>
>>> # THE INTERPOLATION
>>> x, y = np.indices(a.shape)
>>> interp = np.array(a)
>>> interp[np.isnan(interp)] = griddata(
...     (x[~np.isnan(a)], y[~np.isnan(a)]), # points we know
...     a[~np.isnan(a)],                    # values we know
...     (x[np.isnan(a)], y[np.isnan(a)]))   # points to interpolate
>>> interp
array([[ nan,  nan,  nan,   3.,   4.],
       [ nan,   6.,   7.,   8.,   9.],
       [ 10.,  11.,  12.,  13.,  14.],
       [ 15.,  16.,  17.,  18.,  19.],
       [ nan,  nan,  22.,  23.,  nan]])

Używam go na obrazach 3D, operując na plasterkach 2D (4000 plasterków 350x350). Cała operacja trwa jeszcze około godziny : /

Bazując na odpowiedzi autorstwa Bryana Woodsa , zmodyfikowałem jego kod, aby również konwertować listy składające się tylko z NaN na listę zer:

def fill_nan(A):
    '''
    interpolate to fill nan values
    '''
    inds = np.arange(A.shape[0])
    good = np.where(np.isfinite(A))
    if len(good[0]) == 0:
        return np.nan_to_num(A)
    f = interp1d(inds[good], A[good], bounds_error=False)
    B = np.where(np.isfinite(A), A, f(inds))
    return B

Prosty dodatek, mam nadzieję, że komuś się przyda.

Potrzebowałem podejścia, które również wypełniłoby NaN na początku końca danych, czego główna odpowiedź nie wydaje się robić.

Funkcja, którą wymyśliłem, wykorzystuje regresję liniową do wypełnienia NaN. to rozwiązuje mój problem:

import numpy as np

def linearly_interpolate_nans(y):
    # Fit a linear regression to the non-nan y values

    # Create X matrix for linreg with an intercept and an index
    X = np.vstack((np.ones(len(y)), np.arange(len(y))))

    # Get the non-NaN values of X and y
    X_fit = X[:, ~np.isnan(y)]
    y_fit = y[~np.isnan(y)].reshape(-1, 1)

    # Estimate the coefficients of the linear regression
    beta = np.linalg.lstsq(X_fit.T, y_fit)[0]

    # Fill in all the nan values using the predicted coefficients
    y.flat[np.isnan(y)] = np.dot(X[:, np.isnan(y)].T, beta)
    return y

Oto przykładowy przypadek użycia:

# Make an array according to some linear function
y = np.arange(12) * 1.5 + 10.

# First and last value are NaN
y[0] = np.nan
y[-1] = np.nan

# 30% of other values are NaN
for i in range(len(y)):
    if np.random.rand() > 0.7:
        y[i] = np.nan

# NaN's are filled in!
print y
print linearly_interpolate_nans(y)