Python 一時変数を挟むことでどれほど計算時間に影響するか

Question

def crop_01(img):
    cropped = img[0:100, 0:100]
    return np.count_nonzero(cropped)

def crop_02(img):
    return np.count_nonzero(img[0:100, 0:100])

例えば画像を切り出してnp.count_nonzero()関数に突っ込むものがあったとします。
01の方が一時変数を利用していますが、02の方はダイレクトに引数に突っ込んでいます。
10000000回繰り返して01と02で速度に差は出るのでしょうか？
当方で速度差を計測しましたが実行順番によって偏りが出てしまい、正確な計測ができませんでした。
何か計測方法等のアドバイスや理論的な面からの議論があれば教えて欲しいです。

Answer 1

バイトコードディスアセンブラで見てみます。

>>> def crop_01(img):
...     cropped = img[0:100, 0:100]
...     return np.count_nonzero(cropped)
... 
>>> def crop_02(img):
...     return np.count_nonzero(img[0:100, 0:100])
... 
>>> import dis
>>> dis.dis(crop_01)
  2           0 LOAD_FAST                0 (img)
              3 LOAD_CONST               1 (0)
              6 LOAD_CONST               2 (100)
              9 BUILD_SLICE              2
             12 LOAD_CONST               1 (0)
             15 LOAD_CONST               2 (100)
             18 BUILD_SLICE              2
             21 BUILD_TUPLE              2
             24 BINARY_SUBSCR
             25 STORE_FAST               1 (cropped)

  3          28 LOAD_GLOBAL              0 (np)
             31 LOAD_ATTR                1 (count_nonzero)
             34 LOAD_FAST                1 (cropped)
             37 CALL_FUNCTION            1 (1 positional, 0 keyword pair)
             40 RETURN_VALUE
>>> dis.dis(crop_02)
  2           0 LOAD_GLOBAL              0 (np)
              3 LOAD_ATTR                1 (count_nonzero)
              6 LOAD_FAST                0 (img)
              9 LOAD_CONST               1 (0)
             12 LOAD_CONST               2 (100)
             15 BUILD_SLICE              2
             18 LOAD_CONST               1 (0)
             21 LOAD_CONST               2 (100)
             24 BUILD_SLICE              2
             27 BUILD_TUPLE              2
             30 BINARY_SUBSCR
             31 CALL_FUNCTION            1 (1 positional, 0 keyword pair)
             34 RETURN_VALUE

32.12. dis — Python バイトコードの逆アセンブラ — Python 3.6.5 ドキュメント

違うといえば違うし、crop_02の方が命令数が少ないので恐らく速いのだと思いますが……

単純な代入はたぶんpythonで一番速い処理なので、気にする必要はないです。スライスとnp.count_nonzeroが相対的に遅いので埋もれるということです。

追記

一応代入の有無による違いを確認しておきます。

passするだけの関数と、ローカル変数に代入して参照するだけの関数を動かします。

import timeit

import numpy as np
from scipy import stats

def f1():
    pass

def f2():
    x = None
    x

a = []
b = []
for i in range(20):
    a.append(timeit.timeit(f1))
    b.append(timeit.timeit(f2))

print(np.mean(a), np.mean(b))
print(stats.ttest_ind(a, b, equal_var = False))

""" 無駄に検定=>
0.08295731854450424 0.09186851899430622
Ttest_indResult(statistic=-2.9737127732440825, pvalue=0.005209074456296565)
"""

検定すれば確かに有意差はあるんですが、timeit.timeitはデフォルトで10^6回回して所要時間を測ります。

ということは、一回の代入＆参照によって生じている差はわずか約9*10^-9[sec]。たった10ナノ秒弱の違いです。

やっぱり、気にする必要はないです。

Comments

[_Victorique__]

disというモジュールの存在を知りませんでした。有り難うございます。
質問とは関係ありませんが、np.count_nonzeroより早い別の方法は存在するのでしょうか？

[hayataka2049]

ないとは言い切れませんが、np.count_nonzeroは普通に速い部類の処理であるはずです

Answer 2

IPythonで%timeitを使うと簡易的なベンチマークが取れます。

In [1]: import numpy as np
In [2]: def crop_01(img):
    ...:     cropped = img[0:100, 0:100]
    ...:     return np.count_nonzero(cropped)
    ...:
    ...: def crop_02(img):
    ...:     return np.count_nonzero(img[0:100, 0:100])
    ...:

In [3]: img = np.random.random(size=(400, 600))

In [4]: %timeit crop_01(img)
41.1 µs ± 583 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)

In [5]: %timeit crop_02(img)
41 µs ± 404 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)

ほとんどパフォーマンスにほとんど差が出てないですね。NumPyのスライスcropped = img[0:100, 0:100]はメモリーへの参照を返すだけでコピーは発生しません。もちろん参照を保持する変数を確保する分だけオーバーヘッドがありますが、コピーに比べて参照を作るのは非常に高速なので今回のようなベンチマークでは差は計測できないでしょうね。

numpy.ndarray.view

Comments

[_Victorique__]

> NumPyのスライスcropped = img[0:100, 0:100]はメモリーへの参照を返すだけでコピーは発生しません。
これはとっても重要なことですね。貴重な情報有難うございます。
まだまだ知らないことばかりで勉強不足ですね。

Answer 3

計測に関して言うとウォームアップとして大量の計算を繰り返してから本計測に入ると実行順によるブレは出にくい可能性はあります。
が、おそらく差はないと思います。