Edit zum Hinzufügen von: Ich denke nicht, dass die Numba-Benchmarks fair sin

Ich versuche, verschiedene Ansätze zur numerischen Verarbeitung von Daten für den folgenden Anwendungsfall zu vergleichen:

Ziemlich großer Datensatz (über 100.000 Datensätze) 100 + Zeilen ziemlich einfachen Codes (z = x + y) Müssen nicht sortieren oder indizieren

it anderen Worten, die vollständige Allgemeinheit von Serien und Datenrahmen wird nicht benötigt, obwohl sie hier b / c enthalten sind. Sie sind immer noch bequeme Möglichkeiten, die Daten zu kapseln, und es gibt häufig Vor- oder Nachbearbeitungen, die die Allgemeinheit von Pandas erfordern über numpy Arrays.

Frag: Sind basierend auf diesem Anwendungsfall die folgenden Benchmarks angemessen und wenn nicht, wie kann ich sie verbessern?

# importing pandas, numpy, Series, DataFrame in standard way
from numba import jit
nobs = 10000
nlines = 100

def proc_df():
   df = DataFrame({ 'x': np.random.randn(nobs),
                    'y': np.random.randn(nobs) })
   for i in range(nlines):
      df['z'] = df.x + df.y
   return df.z

def proc_ser():
   x = Series(np.random.randn(nobs))
   y = Series(np.random.randn(nobs))
   for i in range(nlines):
      z = x + y
   return z

def proc_arr():
   x = np.random.randn(nobs)
   y = np.random.randn(nobs)
   for i in range(nlines):
      z = x + y
   return z

@jit
def proc_numba():
   xx = np.random.randn(nobs)
   yy = np.random.randn(nobs)
   zz = np.zeros(nobs)
   for j in range(nobs):
      x, y = xx[j], yy[j]
      for i in range(nlines):
         z = x + y
      zz[j] = z
   return zz

Ergebnisse (Win 7, 3 Jahre alte Xeon-Workstation (Quad-Core). Standard- und aktuelle Anaconda-Distribution oder sehr nah.)

In [1251]: %timeit proc_df()
10 loops, best of 3: 46.6 ms per loop

In [1252]: %timeit proc_ser()
100 loops, best of 3: 15.8 ms per loop

In [1253]: %timeit proc_arr()
100 loops, best of 3: 2.02 ms per loop

In [1254]: %timeit proc_numba()
1000 loops, best of 3: 1.04 ms per loop   # may not be valid result (see note below)

Edit zum Hinzufügen von (Antwort auf jeff) Alternative Ergebnisse aus der Übergabe von df / series / array an Funktionen, anstatt sie innerhalb von Funktionen zu erstellen (d. h. Verschieben der Codezeilen, die 'randn' enthalten, von der inneren Funktion zur äußeren Funktion):

10 loops, best of 3: 45.1 ms per loop
100 loops, best of 3: 15.1 ms per loop
1000 loops, best of 3: 1.07 ms per loop
100000 loops, best of 3: 17.9 µs per loop   # may not be valid result (see note below)

Note on numba Ergebnisse: Ich denke, der Numba-Compiler muss die for-Schleife optimieren und die for-Schleife auf eine einzige Iteration reduzieren. Das weiß ich nicht, aber es ist die einzige Erklärung, die ich finden kann, denn es könnte nicht 50x schneller sein als ein Schwachsinn, oder? Folgefrage hier:Warum ist numba hier schneller als numpy?