it-swarm.com.de

numpy array: Ersetzen Sie nan Werte durch den Mittelwert der Spalten

Ich habe ein numpy-Array, das hauptsächlich mit reellen Zahlen gefüllt ist, aber es gibt auch ein paar nan-Werte.

Wie kann ich die nans durch die Durchschnittswerte der Spalten ersetzen, wo sie sind?

31
piokuc

Keine Schleifen erforderlich:

print(a)
[[ 0.93230948         nan  0.47773439  0.76998063]
 [ 0.94460779  0.87882456  0.79615838  0.56282885]
 [ 0.94272934  0.48615268  0.06196785         nan]
 [ 0.64940216  0.74414127         nan         nan]]

#Obtain mean of columns as you need, nanmean is just convenient.
col_mean = np.nanmean(a, axis=0)
print(col_mean)
[ 0.86726219  0.7030395   0.44528687  0.66640474]

#Find indicies that you need to replace
inds = np.where(np.isnan(a))

#Place column means in the indices. Align the arrays using take
a[inds] = np.take(col_mean, inds[1])

print(a)
[[ 0.93230948  0.7030395   0.47773439  0.76998063]
 [ 0.94460779  0.87882456  0.79615838  0.56282885]
 [ 0.94272934  0.48615268  0.06196785  0.66640474]
 [ 0.64940216  0.74414127  0.44528687  0.66640474]]
51
Daniel

Verwenden maskierter Arrays

Die Standardmethode, bei der nur numpy verwendet wird, ist die Verwendung des Moduls masked array .

Scipy ist ein recht umfangreiches Paket, das auf externen Bibliotheken beruht. Es lohnt sich also, eine reine Numpy-Methode zu verwenden. Dies geht aus der Antwort von @ DonaldHobson hervor.

Edit:np.nanmean ist jetzt eine numpy-Funktion. Es behandelt jedoch keine All-Nan-Säulen ...

Angenommen, Sie haben ein Array a:

>>> a
array([[  0.,  nan,  10.,  nan],
       [  1.,   6.,  nan,  nan],
       [  2.,   7.,  12.,  nan],
       [  3.,   8.,  nan,  nan],
       [ nan,   9.,  14.,  nan]])

>>> import numpy.ma as ma
>>> np.where(np.isnan(a), ma.array(a, mask=np.isnan(a)).mean(axis=0), a)    
array([[  0. ,   7.5,  10. ,   0. ],
       [  1. ,   6. ,  12. ,   0. ],
       [  2. ,   7. ,  12. ,   0. ],
       [  3. ,   8. ,  12. ,   0. ],
       [  1.5,   9. ,  14. ,   0. ]])

Beachten Sie, dass der Mittelwert des maskierten Arrays nicht dieselbe Form wie a haben muss, da wir die impliziten broadcasting over-Zeilen nutzen.

Beachten Sie auch, wie die All-Nan-Säule gut gehandhabt wird. Der Mittelwert ist Null, da Sie den Mittelwert von Nullelementen verwenden. Die Methode, die nanmean verwendet, verarbeitet keine All-Nan-Spalten:

>>> col_mean = np.nanmean(a, axis=0)
/home/praveen/.virtualenvs/numpy3-mkl/lib/python3.4/site-packages/numpy/lib/nanfunctions.py:675: RuntimeWarning: Mean of empty slice
  warnings.warn("Mean of empty slice", RuntimeWarning)
>>> inds = np.where(np.isnan(a))
>>> a[inds] = np.take(col_mean, inds[1])
>>> a
array([[  0. ,   7.5,  10. ,   nan],
       [  1. ,   6. ,  12. ,   nan],
       [  2. ,   7. ,  12. ,   nan],
       [  3. ,   8. ,  12. ,   nan],
       [  1.5,   9. ,  14. ,   nan]])

Erklärung

Das Konvertieren von a in ein maskiertes Array liefert Ihnen

>>> ma.array(a, mask=np.isnan(a))
masked_array(data =
 [[0.0 --  10.0 --]
  [1.0 6.0 --   --]
  [2.0 7.0 12.0 --]
  [3.0 8.0 --   --]
  [--  9.0 14.0 --]],
             mask =
 [[False  True False  True]
 [False False  True  True]
 [False False False  True]
 [False False  True  True]
 [ True False False  True]],
       fill_value = 1e+20)

Wenn Sie den Mittelwert über die Spalten nehmen, erhalten Sie die Antwort richtig und normalisieren nur die nicht maskierten Werte:

>>> ma.array(a, mask=np.isnan(a)).mean(axis=0)
masked_array(data = [1.5 7.5 12.0 --],
             mask = [False False False  True],
       fill_value = 1e+20)

Beachten Sie außerdem, wie die Maske die Spalte mit all-nan!

Schließlich erledigt np.where die Ersetzung.


Reihenweise gemeint

Um nan-Werte durch ein zeilenweises Mittel anstelle eines spaltenweisen Mittelwerts zu ersetzen, ist eine kleine Änderung erforderlich, damit das Broadcasting gut in Kraft treten kann:

>>> a
array([[  0.,   1.,   2.,   3.,  nan],
       [ nan,   6.,   7.,   8.,   9.],
       [ 10.,  nan,  12.,  nan,  14.],
       [ nan,  nan,  nan,  nan,  nan]])

>>> np.where(np.isnan(a), ma.array(a, mask=np.isnan(a)).mean(axis=1), a)
ValueError: operands could not be broadcast together with shapes (4,5) (4,) (4,5)

>>> np.where(np.isnan(a), ma.array(a, mask=np.isnan(a)).mean(axis=1)[:, np.newaxis], a)
array([[  0. ,   1. ,   2. ,   3. ,   1.5],
       [  7.5,   6. ,   7. ,   8. ,   9. ],
       [ 10. ,  12. ,  12. ,  12. ,  14. ],
       [  0. ,   0. ,   0. ,   0. ,   0. ]])
10
Praveen

Wenn partial Ihre Originaldaten sind und replace ein Array derselben Form ist, das gemittelte Werte enthält, verwendet dieser Code den Wert von partial, falls vorhanden.

Complete= np.where(np.isnan(partial),replace,partial)
4
Donald Hobson

Alternative : Ersetzen von NaNs durch Interpolation von Spalten.

def interpolate_nans(X):
    """Overwrite NaNs with column value interpolations."""
    for j in range(X.shape[1]):
        mask_j = np.isnan(X[:,j])
        X[mask_j,j] = np.interp(np.flatnonzero(mask_j), np.flatnonzero(~mask_j), X[~mask_j,j])
    return X

Anwendungsbeispiel:

X_incomplete = np.array([[10,     20,     30    ],
                         [np.nan, 30,     np.nan],
                         [np.nan, np.nan, 50    ],
                         [40,     50,     np.nan    ]])

X_complete = interpolate_nans(X_incomplete)

print X_complete
[[10,     20,     30    ],
 [20,     30,     40    ],
 [30,     40,     50    ],
 [40,     50,     50    ]]

Ich benutze dieses Codebit insbesondere für Zeitreihendaten, wobei Spalten Attribute und Zeilen zeitlich geordnete Abtastwerte sind.

3
Ulf Aslak

Dies ist nicht sehr sauber, aber ich kann mir keine andere Möglichkeit vorstellen, als zu iterieren

#example
a = np.arange(16, dtype = float).reshape(4,4)
a[2,2] = np.nan
a[3,3] = np.nan

indices = np.where(np.isnan(a)) #returns an array of rows and column indices
for row, col in Zip(*indices):
    a[row,col] = np.mean(a[~np.isnan(a[:,col]), col])
2
Hammer

Um Donalds Antwort zu erweitern, gebe ich ein minimales Beispiel. Nehmen wir an, a ist ein ndarray und wir möchten seine Nullwerte durch den Mittelwert der Spalte ersetzen.

In [231]: a
Out[231]: 
array([[0, 3, 6],
       [2, 0, 0]])


In [232]: col_mean = np.nanmean(a, axis=0)
Out[232]: array([ 1. ,  1.5,  3. ])

In [228]: np.where(np.equal(a, 0), col_mean, a)
Out[228]: 
array([[ 1. ,  3. ,  6. ],
       [ 2. ,  1.5,  3. ]])
1
LetsPlayYahtzee

Verwenden einfacher Funktionen mit Schleifen: 

a=[[0.93230948, np.nan, 0.47773439, 0.76998063],
  [0.94460779, 0.87882456, 0.79615838, 0.56282885],
  [0.94272934, 0.48615268, 0.06196785, np.nan],
  [0.64940216, 0.74414127, np.nan, np.nan],
  [0.64940216, 0.74414127, np.nan, np.nan]]

print("------- original array -----")
for aa in a:
    print(aa)

# GET COLUMN MEANS: 
ta = np.array(a).T.tolist()                         # transpose the array; 
col_means = list(map(lambda x: np.nanmean(x), ta))  # get means; 
print("column means:", col_means)

# REPLACE NAN ENTRIES WITH COLUMN MEANS: 
nrows = len(a); ncols = len(a[0]) # get number of rows & columns; 
for r in range(nrows):
    for c in range(ncols):
        if np.isnan(a[r][c]):
            a[r][c] = col_means[c]

print("------- means added -----")
for aa in a:
    print(aa)

Ausgabe:

------- original array -----
[0.93230948, nan, 0.47773439, 0.76998063]
[0.94460779, 0.87882456, 0.79615838, 0.56282885]
[0.94272934, 0.48615268, 0.06196785, nan]
[0.64940216, 0.74414127, nan, nan]
[0.64940216, 0.74414127, nan, nan]

column means: [0.82369018599999999, 0.71331494500000003, 0.44528687333333333, 0.66640474000000005]

------- means added -----
[0.93230948, 0.71331494500000003, 0.47773439, 0.76998063]
[0.94460779, 0.87882456, 0.79615838, 0.56282885]
[0.94272934, 0.48615268, 0.06196785, 0.66640474000000005]
[0.64940216, 0.74414127, 0.44528687333333333, 0.66640474000000005]
[0.64940216, 0.74414127, 0.44528687333333333, 0.66640474000000005]

Die for-Schleifen können auch mit Listenverständnis geschrieben werden: 

new_a = [[col_means[c] if np.isnan(a[r][c]) else a[r][c] 
            for c in range(ncols) ]
        for r in range(nrows) ]
0
rnso