webentwicklung-frage-antwort-db.com.de

NumPy: Berechnen Sie die Durchschnitte mit entfernten NaNs

Wie kann ich Matrixmittelwerte entlang einer Matrix berechnen, aber nan-Werte aus der Berechnung entfernen? (Für R-Leute denke na.rm = TRUE).

Hier ist mein [nicht] Arbeitsbeispiel:

import numpy as np
dat = np.array([[1, 2, 3],
                [4, 5, np.nan],
                [np.nan, 6, np.nan],
                [np.nan, np.nan, np.nan]])
print(dat)
print(dat.mean(1))  # [  2.  nan  nan  nan]

Wenn NaNs entfernt wurden, wäre meine erwartete Ausgabe:

array([ 2.,  4.5,  6.,  nan])
pythonnumpynan
39
Mike T

Ich denke, was Sie wollen, ist ein maskiertes Array:

dat = np.array([[1,2,3], [4,5,nan], [nan,6,nan], [nan,nan,nan]])
mdat = np.ma.masked_array(dat,np.isnan(dat))
mm = np.mean(mdat,axis=1)
print mm.filled(np.nan) # the desired answer

Edit: Alle Timing-Daten zusammenfassen

   from timeit import Timer

    setupstr="""
import numpy as np
from scipy.stats.stats import nanmean    
dat = np.random.normal(size=(1000,1000))
ii = np.ix_(np.random.randint(0,99,size=50),np.random.randint(0,99,size=50))
dat[ii] = np.nan
"""  

    method1="""
mdat = np.ma.masked_array(dat,np.isnan(dat))
mm = np.mean(mdat,axis=1)
mm.filled(np.nan)    
"""

    N = 2
    t1 = Timer(method1, setupstr).timeit(N)
    t2 = Timer("[np.mean([l for l in d if not np.isnan(l)]) for d in dat]", setupstr).timeit(N)
    t3 = Timer("np.array([r[np.isfinite(r)].mean() for r in dat])", setupstr).timeit(N)
    t4 = Timer("np.ma.masked_invalid(dat).mean(axis=1)", setupstr).timeit(N)
    t5 = Timer("nanmean(dat,axis=1)", setupstr).timeit(N)

    print 'Time: %f\tRatio: %f' % (t1,t1/t1 )
    print 'Time: %f\tRatio: %f' % (t2,t2/t1 )
    print 'Time: %f\tRatio: %f' % (t3,t3/t1 )
    print 'Time: %f\tRatio: %f' % (t4,t4/t1 )
    print 'Time: %f\tRatio: %f' % (t5,t5/t1 )

Kehrt zurück:

Time: 0.045454  Ratio: 1.000000
Time: 8.179479  Ratio: 179.950595
Time: 0.060988  Ratio: 1.341755
Time: 0.070955  Ratio: 1.561029
Time: 0.065152  Ratio: 1.433364
34
JoshAdel

Wenn es auf die Leistung ankommt, sollten Sie stattdessen bottleneck.nanmean() verwenden:

http://pypi.python.org/pypi/Bottleneck

18
deprecated

Vorausgesetzt, Sie haben auch SciPy installiert:

http://www.scipy.org/doc/api_docs/SciPy.stats.stats.html#nanmean

12
Shaun Dubuque

Ein maskiertes Array mit herausgefilterten Nans kann auch im laufenden Betrieb erstellt werden:

print np.ma.masked_invalid(dat).mean(1)
8
Sven Marnach

Sie können immer eine Problemumgehung finden in:

numpy.nansum(dat, axis=1) / numpy.sum(numpy.isfinite(dat), axis=1)

Numpy 2.0s numpy.mean hat eine skipna-Option, die sich darum kümmern sollte.

8
Benjamin

Dies basiert auf der von JoshAdel vorgeschlagenen Lösung.

Definieren Sie folgende Funktion:

def nanmean(data, **args):
    return numpy.ma.filled(numpy.ma.masked_array(data,numpy.isnan(data)).mean(**args), fill_value=numpy.nan)

Anwendungsbeispiel:

data = [[0, 1, numpy.nan], [8, 5, 1]]
data = numpy.array(data)
print data
print nanmean(data)
print nanmean(data, axis=0)
print nanmean(data, axis=1)

Wird ausgedruckt:

[[  0.   1.  nan]
 [  8.   5.   1.]]

3.0

[ 4.  3.  1.]

[ 0.5         4.66666667]
3
Eugene Yurtsev

nanmean macht ab Nummer 1.8 (veröffentlicht am 30.10.2013) genau das, was Sie brauchen:

>>> import numpy as np
>>> np.nanmean(np.array([1.5, 3.5, np.nan]))
2.5
2
Alexander

Wie wäre es mit Pandas:

import numpy as np
import pandas as pd
dat = np.array([[1, 2, 3], [4, 5, np.nan], [np.nan, 6, np.nan], [np.nan, np.nan, np.nan]])
print dat
print dat.mean(1)

df = pd.DataFrame(dat)
print df.mean(axis=1)

Gibt:

0    2.0
1    4.5
2    6.0
3    NaN
2
zbinsd

Oder Sie verwenden frisch hochgeladenes Laxarray, das unter anderem ein Wrapper für maskierte Arrays ist.

import laxarray as la
la.array(dat).mean(axis=1)

folge JoshAdels Protokoll, das ich bekomme:

Time: 0.048791  Ratio: 1.000000   
Time: 0.062242  Ratio: 1.275689   # laxarray's one-liner

Laxarray ist also etwas langsamer (müsste nachprüfen, warum es fixierbar ist), aber es ist viel einfacher zu verwenden und ermöglicht das Beschriften von Bemaßungen mit Strings. 

check out: https://github.com/perrette/laxarray

EDIT: Ich habe mit einem anderen Modul, "la", Larry, überprüft, das alle Tests schlägt:

import la
la.larry(dat).mean(axis=1)

By hand, Time: 0.049013 Ratio: 1.000000
Larry,   Time: 0.005467 Ratio: 0.111540
laxarray Time: 0.061751 Ratio: 1.259889

Beeindruckend!

1
Mahé
# I suggest you this way:
import numpy as np
dat  = np.array([[1, 2, 3], [4, 5, np.nan], [np.nan, 6, np.nan], [np.nan, np.nan, np.nan]])
dat2 = np.ma.masked_invalid(dat)
print np.mean(dat2, axis=1)
0
GiO

Noch ein Geschwindigkeitstest für alle vorgeschlagenen Ansätze:

Python 2.7.11 |Anaconda 2.4.1 (64-bit)| (default, Jan 19 2016, 12:08:31) [MSC v.1500 64 bit (AMD64)]
IPython 4.0.1 -- An enhanced Interactive Python.

import numpy as np
from scipy.stats.stats import nanmean    
dat = np.random.normal(size=(1000,1000))
ii = np.ix_(np.random.randint(0,99,size=50),np.random.randint(0,99,size=50))
dat[ii] = np.nan
In[185]: def method1():
    mdat = np.ma.masked_array(dat,np.isnan(dat))
    mm = np.mean(mdat,axis=1)
    mm.filled(np.nan) 

In[190]: %timeit method1()
100 loops, best of 3: 7.09 ms per loop
In[191]: %timeit [np.mean([l for l in d if not np.isnan(l)]) for d in dat]
1 loops, best of 3: 1.04 s per loop
In[192]: %timeit np.array([r[np.isfinite(r)].mean() for r in dat])
10 loops, best of 3: 19.6 ms per loop
In[193]: %timeit np.ma.masked_invalid(dat).mean(axis=1)
100 loops, best of 3: 11.8 ms per loop
In[194]: %timeit nanmean(dat,axis=1)
100 loops, best of 3: 6.36 ms per loop
In[195]: import bottleneck as bn
In[196]: %timeit bn.nanmean(dat,axis=1)
1000 loops, best of 3: 1.05 ms per loop
In[197]: from scipy import stats
In[198]: %timeit stats.nanmean(dat)
100 loops, best of 3: 6.19 ms per loop

Das Beste ist also "Flaschenhals.nanmean (dat, axis = 1)" "Scipy.stats.nanmean (dat)" ist nicht schneller als numpy.nanmean(dat, axis=1).

0
Sklavit