быстрый python numpy, где функциональность?

Question

Я использую numpy, где функция много раз внутри нескольких контуров for, но она становится слишком медленной. Есть ли способы быстрее выполнять эту функцию? Я читал, что вы должны пытаться делать строки в циклах, а также создавать локальные переменные для функций перед циклами for, но ничто не улучшает скорость на много (< 1%). len(UNIQ_IDS) ~ 800. emiss_data и obj_data - numpy ndarrays с формой = (2600,5200). Я использовал import profile, чтобы получить ручку, где расположены узкие места, а where в for петлях - большая.

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

Разве вы не можете просто сделать

emiss_data[obj_data == i] 

? Я не уверен, почему вы используете where.

Answer 2

Назначение кортежа выполняется намного быстрее, чем назначение списка в соответствии с Are tuples more efficient than lists in Python?, поэтому, возможно, просто создав кортеж вместо списка, это повысит эффективность.

Answer 3

Оказывается, что чистый цикл Python может быть намного быстрее, чем индексирование NumPy (или вызовы np.where) в этом случае.

Рассмотрим следующие варианты:

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() 

Вот ориентиры, с 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 

Таким образом using_loop (чистый Python) оказывается больше, чем 11x быстрее, чем using_where.

Я не совсем уверен, почему чистый Python быстрее, чем NumPy здесь. Я предполагаю, что чистая версия Python zips (да, каламбур) через оба массива один раз. Он использует тот факт, что, несмотря на все причудливое индексирование, , мы действительно просто хотим посетить каждое значение после. Таким образом, он борется с тем, что нужно точно определить, в какую группу попало каждое значение в emiss_data. Но это просто расплывчатая спекуляция. Я не знал, что это будет быстрее, пока я не сравню их.

Answer 4

Можно использовать np.unique с 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 

Используя ответ @ unutbu в качестве основы для 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

Я считаю, что самый быстрый способ для достижения этой цели является использование groupby() операций в pandas упаковка. По сравнению с @using_sort() функции Офиона, в панде составляет около фактора 10 быстрее:

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

Если obj_data состоит из относительно небольших целых чисел, вы можете использовать numpy.maximum.at (с 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]