包裝np.arrays __pow__方法

Question

我只是重新審視我的一些代碼，以提高性能和stumpled了一些奇怪的事情：

a = np.linspace(10,1000,1000000).reshape(1000,1000) 

%timeit np.square(a) 
100 loops, best of 3: 8.07 ms per loop 

%timeit a*a 
100 loops, best of 3: 8.18 ms per loop 

%timeit a**2 
100 loops, best of 3: 8.32 ms per loop 

好它似乎有使用電運營商時，一些開銷（**）但除此之外，他們似乎是相同的（我猜NumPy的是這樣做），但是它得到了奇怪：

In [46]: %timeit np.power(a, 2) 
10 loops, best of 3: 121 ms per loop 

所以沒有問題，但它似乎有點不一致有神奇的戰俘回退，但不是爲UFUNC 。但後來我有了興趣，因爲我使用的第三大國了很多：

%timeit a*a*a 
100 loops, best of 3: 18.1 ms per loop 

%timeit a**3 
10 loops, best of 3: 121 ms per loop 

%timeit np.power(a, 3) 
10 loops, best of 3: 121 ms per loop 

似乎是在第三功率和UFUNC和「magic-POW」沒有「捷徑」的工作方式相同（對於至少性能）。

但是這不是很好，因爲我想要一個在我的代碼中使用權力的一致方法，我不太確定如何包裝numpy的__pow__。

所以去的地步，我的問題是：

有沒有一種方法，我可以包裝numpys __pow__方法？因爲我想要在我的腳本中編寫權力的一致方式不寫a**2和另一個地方power(a, 3)。簡單地寫a**3，並重定向到我的電源功能，將是首選（但爲此，我需要以某種方式包裝ndarrays __pow__或？）。 目前我使用的快捷方式，但是這不是那個漂亮（我甚至不得不宣佈指數== 2的情況下，因爲np.power執行不是最優的存在）：

def power(array, exponent): 
    if exponent == 2: #catch this, or it calls the slow np.power(array, exponent) 
     return np.square(array) 
    if exponent == 3: 
     return array * array * array 
    #As soon as np.cbrt is avaiable catch the exponent 4/3 here too 
    return np.power(array, exponent) 

%timeit power(a, 3) 
100 loops, best of 3: 17.8 ms per loop 
%timeit a**3 
10 loops, best of 3: 121 ms per loop 

我使用NumPy的v1.9.3，我不只是爲了包裝__pow__方法而子類np.ndarray。 :-)

編輯：我重寫了我得到我的問題的部分。澄清一下：我不是在問爲什麼NumPy會這樣做 - 這只是爲了解釋爲什麼我會問這個問題。

Answer 1

這是一個很好的結果。我也想知道爲什麼是這種行爲。但要簡明扼要回答這個問題，我只想做：

def mypower(array, exponent): 
    return reduce(lambda x,y: x*y, [array for _ in range(exponent)]) 


%timeit mypower(a,2) 
100 loops, best of 3: 3.68 ms per loop 

%timeit mypower(a,3) 
100 loops, best of 3: 8.09 ms per loop 

%timeit mypower(a,4) 
100 loops, best of 3: 12.6 ms per loop 

Obsviouly與指數的開銷增加，但對於那些低優於10倍的時間。

注意，這是從原始numpy的實施這是不特異於數字指數並支持指數作爲第二個參數（check it out here）的陣列不同。

重載操作

做你想要的東西的方式是ndarray繼承和使用的意見。請參閱以下示例：

import numexpr 
import numpy as np 
​ 
class MyArray(np.ndarray): 
    def __pow__(self, other): 
     return reduce(lambda x,y: x*y, [self for _ in range(other)]) 
​ 
class NumExprArray(np.ndarray): 
    def __pow__(self, other): 
     return numexpr.evaluate("self**%f" % other) 
     #This implies extra overhead, is as much as 4x slower: 
     #return numexpr.evaluate("self**other") 

a = np.linspace(10,1000,1000000).reshape(1000,1000).view(MyArray) 
na = np.linspace(10,1000,1000000).reshape(1000,1000).view(NumExprArray) 
​ 
%timeit a**2 
1000 loops, best of 3: 1.2 ms per loop 

%timeit na**2 
1000 loops, best of 3: 1.14 ms per loop 

%timeit a**3 
100 loops, best of 3: 4.69 ms per loop 

%timeit na**3 
100 loops, best of 3: 2.36 ms per loop 

%timeit a**4 
100 loops, best of 3: 6.59 ms per loop 

%timeit na**4 
100 loops, best of 3: 2.4 ms per loop 

有關此方法的更多信息，請參閱此link。另一種方法是使用custom infix operator，但出於可讀性目的不太好。正如人們所看到的，數字應該是要走的路。

Answer 2

如果我正確閱讀source，當numpy執行電源時，它會檢查指數的數值是否是特殊情況之一（-0.5,0,0.5,1和2）。如果是這樣，則使用特殊例程完成操作。指數的所有其他數值都被認爲是「一般」的，並且將被饋送到通用冪函數中，這可能會很慢（特別是如果指數被提升爲浮點類型，但我不確定這是否是與a ** 3的情況）。