szybkie python numpy gdzie funkcjonalność?

Question

Używam numpy, gdzie funkcja wiele razy wewnątrz kilku pętli for, ale staje się zbyt wolny. Czy są jakieś sposoby na szybsze wykonanie tej funkcji? Przeczytałem, że powinieneś spróbować zrobić pętlę w linii, a także utworzyć zmienne lokalne dla funkcji przed pętlami for, ale nic nie poprawia prędkości o wiele (< 1%). Numery ndarrays o kształcie = (2600.5200) są numpy ndarrays. Użyłem import profile, aby uzyskać uchwyt tam, gdzie są wąskie gardła, i where w for pętli jest duża.

import numpy as np 
max = np.max 
where = np.where 
MAX_EMISS = [max(emiss_data[where(obj_data == i)]) for i in UNIQ_IDS)] 

Answer 1

nie można po prostu zrobić

emiss_data[obj_data == i] 

? Nie wiem, dlaczego w ogóle używasz where.

Answer 2

Przypisywanie krotki jest znacznie szybsze niż przypisywanie listy, zgodnie z Are tuples more efficient than lists in Python?, więc może po prostu budowanie krotki zamiast listy poprawi efektywność.

Answer 3

Okazuje się, że czysta pętla w języku Python może być o wiele szybsza niż indeksowanie NumPy (lub wywoływanie do np.where) w tym przypadku.

Rozważmy następujące alternatywy:

import numpy as np 
import collections 
import itertools as IT 

shape = (2600,5200) 
# shape = (26,52) 
emiss_data = np.random.random(shape) 
obj_data = np.random.random_integers(1, 800, size=shape) 
UNIQ_IDS = np.unique(obj_data) 

def using_where(): 
    max = np.max 
    where = np.where 
    MAX_EMISS = [max(emiss_data[where(obj_data == i)]) for i in UNIQ_IDS] 
    return MAX_EMISS 

def using_index(): 
    max = np.max 
    MAX_EMISS = [max(emiss_data[obj_data == i]) for i in UNIQ_IDS] 
    return MAX_EMISS 

def using_max(): 
    MAX_EMISS = [(emiss_data[obj_data == i]).max() for i in UNIQ_IDS] 
    return MAX_EMISS 

def using_loop(): 
    result = collections.defaultdict(list) 
    for val, idx in IT.izip(emiss_data.ravel(), obj_data.ravel()): 
     result[idx].append(val) 
    return [max(result[idx]) for idx in UNIQ_IDS] 

def using_sort(): 
    uind = np.digitize(obj_data.ravel(), UNIQ_IDS) - 1 
    vals = uind.argsort() 
    count = np.bincount(uind) 
    start = 0 
    end = 0 
    out = np.empty(count.shape[0]) 
    for ind, x in np.ndenumerate(count): 
     end += x 
     out[ind] = np.max(np.take(emiss_data, vals[start:end])) 
     start += x 
    return out 

def using_split(): 
    uind = np.digitize(obj_data.ravel(), UNIQ_IDS) - 1 
    vals = uind.argsort() 
    count = np.bincount(uind) 
    return [np.take(emiss_data, item).max() 
      for item in np.split(vals, count.cumsum())[:-1]] 

for func in (using_index, using_max, using_loop, using_sort, using_split): 
    assert using_where() == func() 

Oto benchmarki, z shape = (2600,5200):

In [57]: %timeit using_loop() 
1 loops, best of 3: 9.15 s per loop 

In [90]: %timeit using_sort() 
1 loops, best of 3: 9.33 s per loop 

In [91]: %timeit using_split() 
1 loops, best of 3: 9.33 s per loop 

In [61]: %timeit using_index() 
1 loops, best of 3: 63.2 s per loop 

In [62]: %timeit using_max() 
1 loops, best of 3: 64.4 s per loop 

In [58]: %timeit using_where() 
1 loops, best of 3: 112 s per loop 

Zatem using_loop (czysty Python) okazuje się być ponad 11x szybciej niż using_where.

Nie jestem do końca pewien, dlaczego czysty Python jest szybszy niż NumPy. Domyślam się, że zamki w czystej wersji Pythona (tak, kalambur przeznaczone) przez jeden raz. Wykorzystuje fakt, że pomimo wszystkich wymyślnych indeksów, , naprawdę chcemy po prostu odwiedzić każdą wartość raz. W ten sposób rozwiązuje problem z koniecznością dokładnego określenia, do której grupy przypada każda wartość w emiss_data. Jest to jednak tylko niejasna spekulacja. Nie wiedziałem, że to będzie szybsze, dopóki nie będę porównywać.

Answer 4

można użyć np.unique z return_index:

def using_sort(): 
    #UNIQ_IDS,uind=np.unique(obj_data, return_inverse=True) 
    uind= np.digitize(obj_data.ravel(), UNIQ_IDS) - 1 
    vals=uind.argsort() 
    count=np.bincount(uind) 

    start=0 
    end=0 

    out=np.empty(count.shape[0]) 
    for ind,x in np.ndenumerate(count): 
     end+=x 
     out[ind]=np.max(np.take(emiss_data,vals[start:end])) 
     start+=x 
    return out 

Korzystanie odpowiedź @ unutbu jako punkt odniesienia dla shape = (2600,5200):

np.allclose(using_loop(),using_sort()) 
True 

%timeit using_loop() 
1 loops, best of 3: 12.3 s per loop 

#With np.unique inside the definition 
%timeit using_sort() 
1 loops, best of 3: 9.06 s per loop 

#With np.unique outside the definition 
%timeit using_sort() 
1 loops, best of 3: 2.75 s per loop 

#Using @Jamie's suggestion for uind 
%timeit using_sort() 
1 loops, best of 3: 6.74 s per loop 

Answer 5

wierzę najszybszym sposobem osiągnięcia tego jest użycie operacji w groupby()pandas pakiet. Porównując do @using_sort() funkcję Ophion, w Pandy jest około 10-krotnie szybciej:

import numpy as np 
import pandas as pd 

shape = (2600,5200) 
emiss_data = np.random.random(shape) 
obj_data = np.random.random_integers(1, 800, size=shape) 
UNIQ_IDS = np.unique(obj_data) 

def using_sort(): 
    #UNIQ_IDS,uind=np.unique(obj_data, return_inverse=True) 
    uind= np.digitize(obj_data.ravel(), UNIQ_IDS) - 1 
    vals=uind.argsort() 
    count=np.bincount(uind) 

    start=0 
    end=0 

    out=np.empty(count.shape[0]) 
    for ind,x in np.ndenumerate(count): 
     end+=x 
     out[ind]=np.max(np.take(emiss_data,vals[start:end])) 
     start+=x 
    return out 

def using_pandas(): 
    return pd.Series(emiss_data.ravel()).groupby(obj_data.ravel()).max() 

print('same results:', np.allclose(using_pandas(), using_sort())) 
# same results: True 

%timeit using_sort() 
# 1 loops, best of 3: 3.39 s per loop 

%timeit using_pandas() 
# 1 loops, best of 3: 397 ms per loop 

Answer 6

Jeśli obj_data składa się ze stosunkowo małych liczb całkowitych, można wykorzystać numpy.maximum.at (od v1.8.0):

def using_maximumat(): 
    n = np.max(UNIQ_IDS) + 1 
    temp = np.full(n, -np.inf) 
    np.maximum.at(temp, obj_data, emiss_data) 
    return temp[UNIQ_IDS]