web-dev-qa-db-ja.com

Pythonネストされたforループのベクトル化

入れ子になったforループで次の配列操作を最適化するPythonの方法を見つけて理解する上で助けていただければ幸いです。

def _func(a, b, radius):
    "Return 0 if a>b, otherwise return 1"
    if distance.euclidean(a, b) < radius:
        return 1
    else:
        return 0

def _make_mask(volume, roi, radius):
    mask = numpy.zeros(volume.shape)
    for x in range(volume.shape[0]):
        for y in range(volume.shape[1]):
            for z in range(volume.shape[2]):
                mask[x, y, z] = _func((x, y, z), roi, radius)
    return mask

どこ volume.shape（182、218、200）およびroi.shape（3、）は両方ともndarrayタイプです。 radiusはintです

pythonnumpyfor-loopoptimizationvectorization
34
Kambiz

アプローチ＃1

これがベクトル化されたアプローチです-

m,n,r = volume.shape
x,y,z = np.mgrid[0:m,0:n,0:r]
X = x - roi[0]
Y = y - roi[1]
Z = z - roi[2]
mask = X**2 + Y**2 + Z**2 < radius**2

可能な改善：おそらくnumexprモジュールで最後のステップを高速化できます-

import numexpr as ne

mask = ne.evaluate('X**2 + Y**2 + Z**2 < radius**2')

アプローチ＃2

また、形状パラメーターに対応する3つの範囲を徐々に構築し、np.mgridで以前に行ったように実際にメッシュを作成せずに、roiの3つの要素に対してその場で減算を実行できます。これは、効率化のために broadcasting を使用することでメリットが得られます。実装は次のようになります-

m,n,r = volume.shape
vals = ((np.arange(m)-roi[0])**2)[:,None,None] + \
       ((np.arange(n)-roi[1])**2)[:,None] + ((np.arange(r)-roi[2])**2)
mask = vals < radius**2

簡易版：np.ogridを使用してこれらの操作をもう少し簡潔に実行できるため、ここで改善を提案してくれた@Bi Ricoに感謝します-

m,n,r = volume.shape    
x,y,z = np.ogrid[0:m,0:n,0:r]-roi
mask = (x**2+y**2+z**2) < radius**2

実行時テスト

関数定義-

def vectorized_app1(volume, roi, radius):
    m,n,r = volume.shape
    x,y,z = np.mgrid[0:m,0:n,0:r]
    X = x - roi[0]
    Y = y - roi[1]
    Z = z - roi[2]
    return X**2 + Y**2 + Z**2 < radius**2

def vectorized_app1_improved(volume, roi, radius):
    m,n,r = volume.shape
    x,y,z = np.mgrid[0:m,0:n,0:r]
    X = x - roi[0]
    Y = y - roi[1]
    Z = z - roi[2]
    return ne.evaluate('X**2 + Y**2 + Z**2 < radius**2')

def vectorized_app2(volume, roi, radius):
    m,n,r = volume.shape
    vals = ((np.arange(m)-roi[0])**2)[:,None,None] + \
           ((np.arange(n)-roi[1])**2)[:,None] + ((np.arange(r)-roi[2])**2)
    return vals < radius**2

def vectorized_app2_simplified(volume, roi, radius):
    m,n,r = volume.shape    
    x,y,z = np.ogrid[0:m,0:n,0:r]-roi
    return (x**2+y**2+z**2) < radius**2

タイミング-

In [106]: # Setup input arrays  
     ...: volume = np.random.Rand(90,110,100) # Half of original input sizes 
     ...: roi = np.random.Rand(3)
     ...: radius = 3.4
     ...: 

In [107]: %timeit _make_mask(volume, roi, radius)
1 loops, best of 3: 41.4 s per loop

In [108]: %timeit vectorized_app1(volume, roi, radius)
10 loops, best of 3: 62.3 ms per loop

In [109]: %timeit vectorized_app1_improved(volume, roi, radius)
10 loops, best of 3: 47 ms per loop

In [110]: %timeit vectorized_app2(volume, roi, radius)
100 loops, best of 3: 4.26 ms per loop

In [139]: %timeit vectorized_app2_simplified(volume, roi, radius)
100 loops, best of 3: 4.36 ms per loop

したがって、いつものように、broadcastingは狂ったほとんど10,000xの魔法を示し、元のコードと10xオンザフライブロードキャスト操作を使用してメッシュを作成するよりも優れています。

61
Divakar

最初にxyzy配列を作成するとします：

import itertools

xyz = [np.array(p) for p in itertools.product(range(volume.shape[0]), range(volume.shape[1]), range(volume.shape[2]))]

次に、 numpy.linalg.norm 、

np.linalg.norm(xyz - roi, axis=1) < radius

roiからの各Tupleの距離がradiusより小さいかどうかをチェックします。

最後に、必要な次元の結果をreshapeするだけです。

7
Ami Tavory