Numpy: NEP-18の実装に関する追跡の問題（__array_function__）

一部の注目度の高い関数の予備的な「すべてのパブリックNumPy関数を@array_function_dispatchで装飾する」をマージし、プロトコルのダウンストリームコンシューマーに試してみるように要求することをお勧めします。

https://github.com/numpy/numpy/pull/12099をマージすると、 numpy.coreほとんどにディスパッチデコレータを追加する別のPRの準備が整います。 物事を仕上げるのはかなり簡単です-これはまとめるのに1時間もかかりませんでした。

cc @ eric-wieser @mrocklin @mhvk @hameerabbasi

Pythonラッパーを使用して関数にすべての「簡単な」オーバーライドを実装するブランチについては、 https：//github.com/shoyer/numpy/tree/array-function-easy-implを参照してnp.block 、 np.einsum 、および完全にCで記述された少数のマルチアレイ関数です（例： np.concatenate ）。 ＃12099が完了したら、これを一連のPRに分割します。

個々の関数のオーバーライドのテストを作成していないことに注意してください。 完了したら、いくつかの統合テストを追加したいと思います（たとえば、適用されたすべての操作をログに記録するduck配列）が、個々の関数ごとにディスパッチングテストを作成するのは生産的ではないと思います。 ＃12099のチェックは、ディスパッチャーで最も一般的なエラーをキャッチする必要があり、ディスパッチャー関数のコードのすべての行は、既存のテストによって実行される必要があります。

@ shoyer-テストについては、それぞれのテストを作成することは特に有用ではないことに同意します。 代わりに、numpy内で、 MaskedArray比較的迅速にオーバーライドの使用を開始するのが最も理にかなっている場合があります。

@mhvkは私には良さそうですが、MaskedArrayを使用/知っている他の誰かに主導権を握らせます。

https://github.com/numpy/numpy/pull/12115、https://github.com/numpy/numpy/pull/12116、＃12119およびhttps://github.com/numpy/numpy/pull/を参照してくださいPythonで定義された関数に__array_function__サポートを実装するPRの場合は12117 。

@ shoyer-いくつかの実装を見て、私は2つの心配があります：

• reshapeなどの一部の関数では、元の関数は、 reshapeメソッドを定義することにより、それをオーバーライドする方法をすでに提供しています。 __array_function__を定義するすべてのクラスについて、これを事実上非推奨にしています。
• np.medianなどの他の関数の場合、 np.asanyarrayとufuncsを注意深く使用することで、サブクラスがすでにそれらを使用できるようになりました。 ただし、その機能に直接アクセスすることはできなくなりました。

インターフェースを簡素化し、純粋なndarray最適化された実装を作成できるため、全体としてこれら2つのことはおそらく利点だと思います。後者はndarray.__array_function__がリストの変換などを引き継ぐべきであることを示唆しています。実装がその部分をスキップできるように、 ndarrayに）。 それでも、作業量とパフォーマンスへの影響の可能性の両方の点で、これをQuantity実装するのが思ったよりも少し怖いので、注意したいと思いました。

ただし、後者は、実装がその部分をスキップできるように、ndarray .__ array_function__がリストなどのndarrayへの変換を引き継ぐ必要があることを示唆しています）。

ここをフォローするかどうかはわかりません。

reshapeやmeanような関数をオーバーライドする古い方法は実際に非推奨になっていますが、古い方法はまだNumPyのAPIの不完全な実装をサポートしています。

ここをフォローするかどうかはわかりません。

問題は、単一の関数に対しても__array_function__を実装すると、以前のメカニズムが完全に機能しなくなり、フェイルオーバーする方法がないことだと思います。 そのため、 NotImplementedButCoercible提案を再検討することを提案します。

@ hameerabbasi-はい、それが問題です。 ここでは、ダクトテープの解決策に頼りやすくすることに注意する必要がありますが、実際には取り除く必要があります...（これが、私の「問題」が実際にメリットになる可能性があることを上に書いた理由です...） 。 たぶん、1.16のように試してから、「この場合は__array_function__を無視する」というフォールバックを提供するかどうかを実際の経験で決定する場合があります。

Re：ディスパッチャのスタイリング：スタイルに関する私の好みは、メモリ/インポート時間の考慮事項と冗長性に基づいています。 非常に簡単に言えば、署名が同じままである可​​能性が高いディスパッチャをマージします。 このようにして、作成するオブジェクトの量を最小限に抑え、キャッシュヒットも高くなります。

そうは言っても、私はラムダスタイルにあまり反対していません。

ディスパッチャ関数を作成するためのスタイルが、いくつかのPRで登場しました。 NumPy全体で一貫した選択をするのは良いことです。

いくつかのオプションがあります。

オプション1 ：関数ごとに個別のディスパッチャーを作成します。例：

def _sin_dispatcher(a):
    return (a,)


@array_function_dispatch(_sin_dispatcher)
def sin(a):
     ...


def _cos_dispatcher(a):
    return (a,)


@array_function_dispatch(_cos_dispatcher)
def cos(a):
    ...

利点：

• 非常に読みやすい
• ディスパッチャ関数の定義を簡単に見つける
• sin(x=1) -> TypeError: _sin_dispatcher() got an unexpected keyword argument 'x' 、間違った引数を指定するとエラーメッセージがクリアされます。

短所：

• モジュール内の多くの関数がまったく同じシグニチャを持っている場合でも、多くの繰り返し。

オプション2 ：モジュール内のディスパッチャ関数を再利用します。

def _unary_dispatcher(a):
    return (a,)


@array_function_dispatch(_unary_dispatcher)
def sin(a):
     ...


@array_function_dispatch(_unary_dispatcher)
def cos(a):
    ...

利点：

• 繰り返しが少ない
• 読みやすい

短所：

• ディスパッチャ関数の定義を見つけるのが少し難しい場合があります
• sin(x=1) -> TypeError: _unary_dispatcher() got an unexpected keyword argument 'x'など、不正な引数に対するエラーメッセージが少しわかりにくくなります

オプション3 ：ディスパッチャ定義が1行に収まる場合は、 lambda関数を使用します。

# inline style (shorter)
@array_function_dispatch(lambda a: (a,))
def sin(a):
     ...


@array_function_dispatch(lambda a, n=None, axis=None, norm=None: (a,))
def fft(a, n=None, axis=-1, norm=None):
     ...

# multiline style (more readable?)
@array_function_dispatch(
    lambda a: (a,)
)
def sin(a):
     ...


@array_function_dispatch(
    lambda a, n=None, axis=None, norm=None: (a,)
)
def fft(a, n=None, axis=-1, norm=None):
     ...

利点：

• ディスパッチャの定義を探す必要はありません。ディスパッチャの定義はすぐそこにあります。
• 文字数とコード行数が少なくなります。
• 短い場合（たとえば、1つの引数）、特にラムダが関数名よりも短い場合に非常に見栄えがします。

短所：

• オプション2よりも繰り返されるコード。
• 引数が少なすぎるとかなり雑然と見えます
• また、明確でないエラーメッセージがあります（ TypeError: <lambda>() got an unexpected keyword argument 'x' ）

@shoyer ：「コード行」の側面をより現実的にするために2行のPEP8間隔を追加するように編集されました

エラーメッセージの問題は、コードオブジェクトを再構築することで修正できることに注意してください。ただし、インポートには多少のコストがかかります。 おそらく調査し、 @ nschloeのマグロを分解していくつかのオプションを比較する価値があります。

はい、デコレータモジュールは関数定義の生成にも使用できます（コード生成には少し異なるアプローチを使用します。 exec()使用するという点でnamedtupleに少し似ています）。

エラーが解決されない限り、明確な名前を持つディスパッチャでオプションに固執する必要があると思います。 メモリ上の理由からディスパッチャを少しバンドルします（2）が、エラーメッセージを非常に念頭に置いているので、ディスパッチャを_dispatch_on_xように呼び出すことをお勧めします。

エラーを変更できれば、状況は変わります。 たとえば、例外をキャッチし、 <lambda>を例外テキストの関数名に置き換えてから、再度発生させるのと同じくらい簡単な場合があります。 （または、そのチェーンは最近のものですか？）

エラーメッセージは明確である必要があり、理想的にはまったく変更されるべきではないことに同意します。

さて、今のところ、何らかのコード生成が機能しない限り、 lambda使用を控えるのが最善だと思います。

https://github.com/numpy/numpy/pull/12175は、Pythonラッパーアプローチを採用した場合にマルチアレイ関数（Cで記述）のオーバーライドがどのように見えるかについてのドラフトを追加しています。

@mattip matmulをufuncとして実装するのはどこですか？ これらすべての__array_function__オーバーライドを完了したら、それがNumPyのパブリックAPIを完全にオーバーロード可能にするために必要な最後のことだと思います。 NumPy1.16の準備がすべて整っていると便利です。

NEP 20を実装するPR＃11175は、ゆっくりと進んでいます。 これは、matmulループコードを持つPR＃11133のブロッカーです。 それでも更新して、ベンチマークを介して新しいコードが古いコードより遅くないことを確認する必要があります。

オーバーライドの完全なセットを完了する必要があるレビュー用の4つのPRがあります。 __array_function__テストを本格的に開始できるように、最終レビュー/サインオフ/マージをいただければ幸いです。 https://github.com/numpy/numpy/pull/12154 、 https://github.com/numpy/numpy/pull/12163 、 https://github.com/numpy/numpy/pull/12119 、 HTTPS： //github.com/numpy/numpy/pull/12175

np.coreオーバーライドを追加すると、いくつかのパンダテストが失敗しました（https://github.com/pandas-dev/pandas/issues/23172）。 何が起こっているのかはまだよくわかりませんが、リリースする前に確実に把握する必要があります。

これがdask / pandasでテストの失敗を引き起こしている理由についての私の最善の推測については、 https：//github.com/numpy/numpy/issues/12225を参照して

インポート時間のいくつかのベンチマーク（ソリッドステートドライブを搭載した私のmacbook proで）：

• NumPy 1.15.2：152.451ミリ秒
• NumPyマスター：156.5745ミリ秒
• decorator.decorate （＃12226）の使用：183.694ミリ秒

私のベンチマークスクリプト

import numpy as np
import subprocess

times = []
for _ in range(100):
    result = subprocess.run("python -X importtime -c 'import numpy'",
                            shell=True, capture_output=True)
    last_line = result.stderr.rstrip().split(b'\n')[-1]
    time = float(last_line.decode('ascii')[-15:-7].strip().rstrip())
    times.append(time)

print(np.median(times) / 1e3)

メモリ使用量（前/後）について何か考えはありますか？ これは、特にIoTアプリケーションにとっても便利です。

モジュールのメモリ使用量を確実に測定する方法を知っていますか？
6:56 Hameerアッバースィーの土曜、2018年10月20日には[email protected]
書きました：

メモリ使用量（前/後）について何か考えはありますか？ それは一種の便利です
特にIoTアプリケーションの場合はそうです。

—
あなたが言及されたのであなたはこれを受け取っています。
このメールに直接返信し、GitHubで表示してください
https://github.com/numpy/numpy/issues/12028#issuecomment-431584123 、またはミュート
スレッド
https://github.com/notifications/unsubscribe-auth/ABKS1k_IkrJ2YmYReaDrnkNvcH2X0-ZCks5umyuogaJpZM4W3kSC
。

import numpy as npを含むスクリプトを作成し、スリープステートメントを追加し、プロセスメモリを追跡するだけで十分だと思います。 https://superuser.com/questions/581108/how-can-i-track-and-log-cpu-and-memory-usage-on-a-mac

他のコア開発者は、 https：//github.com/numpy/numpy/pull/12163で簡単に調べたいと思っています（実際には、2つの関数しか含まれていません！） array_function_dispatchを追加する最後のPRです。

参考までに、 __array_function__無効にしたときに表示されるパフォーマンスの違いは次のとおりです。

       before           after         ratio
     [45718fd7]       [4e5aa2cd]
     <master>         <disable-array-function>
+        72.5±2ms         132±20ms     1.82  bench_io.LoadtxtCSVdtypes.time_loadtxt_dtypes_csv('complex128', 10000)
-        44.9±2μs       40.8±0.6μs     0.91  bench_ma.Concatenate.time_it('ndarray', 2)
-      15.3±0.3μs       13.3±0.7μs     0.87  bench_core.CountNonzero.time_count_nonzero_multi_axis(2, 100, <type 'object'>)
-        38.4±1μs         32.7±2μs     0.85  bench_linalg.Linalg.time_op('norm', 'longfloat')
-        68.7±3μs         56.5±3μs     0.82  bench_linalg.Linalg.time_op('norm', 'complex256')
-        80.6±4μs         65.9±1μs     0.82  bench_function_base.Median.time_even
-        82.4±2μs         66.8±3μs     0.81  bench_shape_base.Block.time_no_lists(100)
-        73.5±3μs         59.3±3μs     0.81  bench_function_base.Median.time_even_inplace
-      15.2±0.3μs       12.2±0.6μs     0.80  bench_core.CountNonzero.time_count_nonzero_multi_axis(3, 100, <type 'str'>)
-      2.20±0.1ms      1.76±0.04ms     0.80  bench_shape_base.Block2D.time_block2d((1024, 1024), 'uint64', (4, 4))
-        388±20μs         310±10μs     0.80  bench_lib.Pad.time_pad((10, 10, 10), 3, 'linear_ramp')
-        659±20μs         524±20μs     0.80  bench_linalg.Linalg.time_op('det', 'float32')
-      22.9±0.7μs       18.2±0.8μs     0.79  bench_function_base.Where.time_1
-        980±50μs         775±20μs     0.79  bench_shape_base.Block2D.time_block2d((1024, 1024), 'uint32', (4, 4))
-        36.6±1μs         29.0±1μs     0.79  bench_ma.Concatenate.time_it('unmasked', 2)
-      16.4±0.7μs       12.9±0.6μs     0.79  bench_core.CountNonzero.time_count_nonzero_axis(3, 100, <type 'str'>)
-      16.4±0.5μs       12.9±0.4μs     0.79  bench_core.CountNonzero.time_count_nonzero_axis(2, 100, <type 'object'>)
-         141±5μs          110±4μs     0.78  bench_lib.Pad.time_pad((10, 100), (0, 5), 'linear_ramp')
-      18.0±0.6μs       14.1±0.6μs     0.78  bench_core.CountNonzero.time_count_nonzero_axis(3, 100, <type 'object'>)
-      11.9±0.6μs       9.28±0.5μs     0.78  bench_core.CountNonzero.time_count_nonzero_axis(1, 100, <type 'int'>)
-        54.6±3μs         42.4±2μs     0.78  bench_function_base.Median.time_odd_small
-        317±10μs          246±7μs     0.78  bench_lib.Pad.time_pad((10, 10, 10), 1, 'linear_ramp')
-      13.8±0.5μs       10.7±0.7μs     0.77  bench_reduce.MinMax.time_min(<type 'numpy.float64'>)
-        73.3±6μs         56.6±4μs     0.77  bench_lib.Pad.time_pad((1000,), (0, 5), 'mean')
-      14.7±0.7μs       11.4±0.3μs     0.77  bench_core.CountNonzero.time_count_nonzero_axis(2, 100, <type 'str'>)
-        21.5±2μs       16.5±0.6μs     0.77  bench_reduce.MinMax.time_min(<type 'numpy.int64'>)
-         117±4μs         89.2±3μs     0.76  bench_lib.Pad.time_pad((1000,), 3, 'linear_ramp')
-        43.7±1μs         33.4±1μs     0.76  bench_linalg.Linalg.time_op('norm', 'complex128')
-      12.6±0.6μs       9.55±0.2μs     0.76  bench_core.CountNonzero.time_count_nonzero_multi_axis(2, 100, <type 'int'>)
-        636±20μs         482±20μs     0.76  bench_ma.MA.time_masked_array_l100
-        86.6±4μs         65.6±4μs     0.76  bench_lib.Pad.time_pad((1000,), (0, 5), 'linear_ramp')
-         120±4μs         90.4±2μs     0.75  bench_lib.Pad.time_pad((1000,), 1, 'linear_ramp')
-         160±5μs          119±8μs     0.74  bench_ma.Concatenate.time_it('ndarray+masked', 100)
-      14.4±0.6μs       10.7±0.3μs     0.74  bench_core.CountNonzero.time_count_nonzero_multi_axis(1, 100, <type 'str'>)
-      15.7±0.4μs       11.7±0.6μs     0.74  bench_core.CountNonzero.time_count_nonzero_multi_axis(2, 100, <type 'str'>)
-        21.8±2μs       16.1±0.7μs     0.74  bench_reduce.MinMax.time_max(<type 'numpy.int64'>)
-      11.9±0.6μs       8.79±0.3μs     0.74  bench_core.CountNonzero.time_count_nonzero_axis(2, 100, <type 'bool'>)
-        53.8±3μs         39.4±2μs     0.73  bench_function_base.Median.time_even_small
-        106±20μs         76.7±4μs     0.73  bench_function_base.Select.time_select
-        168±10μs          122±4μs     0.72  bench_shape_base.Block2D.time_block2d((512, 512), 'uint32', (2, 2))
-      12.5±0.5μs       8.96±0.4μs     0.72  bench_core.CountNonzero.time_count_nonzero_multi_axis(1, 100, <type 'int'>)
-        162±10μs          115±5μs     0.71  bench_function_base.Percentile.time_percentile
-        12.9±1μs       9.12±0.4μs     0.71  bench_random.Random.time_rng('normal')
-      9.71±0.4μs       6.88±0.3μs     0.71  bench_core.CorrConv.time_convolve(1000, 10, 'full')
-      15.1±0.8μs       10.7±0.4μs     0.71  bench_reduce.MinMax.time_max(<type 'numpy.float64'>)
-         153±9μs          108±7μs     0.71  bench_shape_base.Block2D.time_block2d((1024, 1024), 'uint8', (2, 2))
-         109±5μs         76.9±5μs     0.71  bench_ma.Concatenate.time_it('ndarray+masked', 2)
-        34.3±1μs       24.2±0.6μs     0.71  bench_linalg.Linalg.time_op('norm', 'complex64')
-      9.80±0.2μs       6.84±0.5μs     0.70  bench_core.CorrConv.time_convolve(1000, 10, 'same')
-        27.4±6μs         19.1±2μs     0.70  bench_core.CountNonzero.time_count_nonzero_axis(1, 10000, <type 'bool'>)
-      9.35±0.4μs       6.50±0.3μs     0.70  bench_core.CorrConv.time_convolve(50, 100, 'full')
-        65.2±4μs         45.2±1μs     0.69  bench_shape_base.Block.time_block_simple_row_wise(100)
-        12.9±1μs       8.89±0.3μs     0.69  bench_core.CountNonzero.time_count_nonzero_axis(3, 100, <type 'bool'>)
-        19.6±3μs       13.5±0.4μs     0.69  bench_core.CountNonzero.time_count_nonzero_multi_axis(3, 100, <type 'object'>)
-        75.6±2μs         52.1±3μs     0.69  bench_lib.Pad.time_pad((10, 10, 10), (0, 5), 'reflect')
-        12.4±1μs       8.51±0.4μs     0.69  bench_core.CountNonzero.time_count_nonzero_multi_axis(3, 100, <type 'bool'>)
-        172±30μs          117±4μs     0.68  bench_ma.Concatenate.time_it('unmasked+masked', 100)
-      23.1±0.5μs       15.8±0.9μs     0.68  bench_linalg.Linalg.time_op('norm', 'int16')
-      8.18±0.9μs       5.57±0.1μs     0.68  bench_core.CorrConv.time_correlate(1000, 10, 'full')
-         153±5μs          103±3μs     0.68  bench_function_base.Percentile.time_quartile
-       758±100μs         512±20μs     0.68  bench_linalg.Linalg.time_op('det', 'int16')
-        55.4±6μs         37.4±1μs     0.68  bench_ma.Concatenate.time_it('masked', 2)
-        234±30μs          157±5μs     0.67  bench_shape_base.Block.time_nested(100)
-         103±4μs         69.3±3μs     0.67  bench_linalg.Eindot.time_dot_d_dot_b_c
-      19.2±0.4μs       12.9±0.6μs     0.67  bench_core.Core.time_tril_l10x10
-         122±7μs         81.7±4μs     0.67  bench_lib.Pad.time_pad((10, 10, 10), 3, 'edge')
-        22.9±1μs       15.3±0.5μs     0.67  bench_linalg.Linalg.time_op('norm', 'int32')
-        16.6±2μs       11.0±0.3μs     0.66  bench_core.CountNonzero.time_count_nonzero_multi_axis(1, 100, <type 'object'>)
-      9.98±0.3μs       6.58±0.1μs     0.66  bench_core.CorrConv.time_convolve(1000, 10, 'valid')
-         118±6μs         77.9±4μs     0.66  bench_shape_base.Block2D.time_block2d((512, 512), 'uint16', (2, 2))
-        212±50μs          140±8μs     0.66  bench_lib.Pad.time_pad((10, 10, 10), (0, 5), 'mean')
-      21.9±0.7μs       14.4±0.5μs     0.66  bench_linalg.Linalg.time_op('norm', 'int64')
-         131±5μs         85.9±5μs     0.65  bench_lib.Pad.time_pad((10, 10, 10), 3, 'constant')
-        56.8±2μs         37.0±3μs     0.65  bench_lib.Pad.time_pad((1000,), (0, 5), 'constant')
-        58.9±3μs         38.1±1μs     0.65  bench_lib.Pad.time_pad((10, 100), (0, 5), 'reflect')
-        72.1±2μs         46.5±3μs     0.64  bench_lib.Pad.time_pad((10, 100), (0, 5), 'constant')
-      8.66±0.3μs       5.58±0.2μs     0.64  bench_core.CorrConv.time_correlate(50, 100, 'full')
-        300±30μs         193±10μs     0.64  bench_shape_base.Block2D.time_block2d((1024, 1024), 'uint8', (4, 4))
-        15.9±5μs       10.2±0.3μs     0.64  bench_core.CountNonzero.time_count_nonzero_axis(3, 100, <type 'int'>)
-      13.7±0.5μs       8.80±0.1μs     0.64  bench_random.Random.time_rng('uniform')
-      8.60±0.5μs       5.50±0.2μs     0.64  bench_core.CorrConv.time_correlate(1000, 10, 'same')
-        44.7±2μs       28.5±0.7μs     0.64  bench_lib.Pad.time_pad((1000,), 1, 'reflect')
-        72.7±3μs         46.2±2μs     0.64  bench_lib.Pad.time_pad((10, 10, 10), 3, 'wrap')
-        567±50μs         360±40μs     0.63  bench_shape_base.Block2D.time_block2d((512, 512), 'uint64', (2, 2))
-        58.0±3μs         36.7±2μs     0.63  bench_lib.Pad.time_pad((10, 100), 3, 'reflect')
-        219±30μs          138±7μs     0.63  bench_lib.Pad.time_pad((10, 100), 1, 'mean')
-        261±60μs         164±10μs     0.63  bench_lib.Pad.time_pad((10, 100), 1, 'linear_ramp')
-       825±100μs         519±30μs     0.63  bench_shape_base.Block2D.time_block2d((512, 512), 'uint64', (4, 4))
-         121±5μs         75.7±2μs     0.63  bench_lib.Pad.time_pad((10, 10, 10), 1, 'constant')
-      8.16±0.2μs       5.08±0.4μs     0.62  bench_core.CorrConv.time_convolve(50, 100, 'same')
-        66.6±3μs         41.3±2μs     0.62  bench_lib.Pad.time_pad((1000,), 3, 'constant')
-        53.1±3μs       32.9±0.8μs     0.62  bench_lib.Pad.time_pad((10, 100), 3, 'wrap')
-        285±60μs         177±10μs     0.62  bench_lib.Pad.time_pad((10, 10, 10), (0, 5), 'linear_ramp')
-      8.30±0.9μs       5.14±0.1μs     0.62  bench_core.CorrConv.time_correlate(1000, 10, 'valid')
-         115±3μs         71.2±3μs     0.62  bench_shape_base.Block2D.time_block2d((256, 256), 'uint64', (2, 2))
-      19.1±0.5μs       11.8±0.6μs     0.62  bench_linalg.Linalg.time_op('norm', 'float64')
-        95.3±5μs         58.6±2μs     0.62  bench_lib.Pad.time_pad((10, 100), 1, 'constant')
-        44.6±1μs       27.2±0.9μs     0.61  bench_lib.Pad.time_pad((1000,), (0, 5), 'edge')
-        447±20μs         270±10μs     0.61  bench_shape_base.Block2D.time_block2d((1024, 1024), 'uint16', (4, 4))
-        53.9±2μs         32.6±2μs     0.60  bench_lib.Pad.time_pad((10, 100), 1, 'wrap')
-        11.6±1μs       6.97±0.4μs     0.60  bench_reduce.MinMax.time_max(<type 'numpy.float32'>)
-        95.9±5μs         57.7±2μs     0.60  bench_lib.Pad.time_pad((10, 100), 3, 'constant')
-        47.2±2μs         28.2±2μs     0.60  bench_lib.Pad.time_pad((1000,), (0, 5), 'reflect')
-      5.51±0.2μs      3.27±0.07μs     0.59  bench_core.CountNonzero.time_count_nonzero(3, 100, <type 'object'>)
-        74.3±3μs         44.0±2μs     0.59  bench_lib.Pad.time_pad((10, 10, 10), (0, 5), 'wrap')
-        76.2±3μs       45.0±0.8μs     0.59  bench_lib.Pad.time_pad((10, 10, 10), 1, 'reflect')
-        57.1±1μs         33.5±2μs     0.59  bench_lib.Pad.time_pad((10, 100), (0, 5), 'wrap')
-        52.0±2μs         30.4±1μs     0.58  bench_lib.Pad.time_pad((1000,), 1, 'edge')
-        42.6±2μs       24.9±0.9μs     0.58  bench_lib.Pad.time_pad((1000,), 3, 'wrap')
-        15.0±3μs       8.73±0.3μs     0.58  bench_core.CountNonzero.time_count_nonzero_multi_axis(1, 100, <type 'bool'>)
-        16.0±3μs       9.29±0.3μs     0.58  bench_core.CountNonzero.time_count_nonzero_multi_axis(3, 100, <type 'int'>)
-        53.1±1μs         30.9±2μs     0.58  bench_lib.Pad.time_pad((1000,), 3, 'edge')
-        88.0±8μs         51.1±3μs     0.58  bench_lib.Pad.time_pad((10, 10, 10), 3, 'reflect')
-        44.6±2μs         25.9±1μs     0.58  bench_lib.Pad.time_pad((1000,), (0, 5), 'wrap')
-        90.3±5μs         51.9±1μs     0.57  bench_shape_base.Block2D.time_block2d((512, 512), 'uint8', (2, 2))
-      15.6±0.5μs       8.93±0.3μs     0.57  bench_linalg.Linalg.time_op('norm', 'float32')
-         102±6μs       58.3±0.9μs     0.57  bench_lib.Pad.time_pad((10, 10, 10), 1, 'edge')
-        80.1±4μs         45.6±3μs     0.57  bench_lib.Pad.time_pad((10, 100), 3, 'edge')
-        44.2±2μs         24.9±1μs     0.56  bench_lib.Pad.time_pad((1000,), 1, 'wrap')
-        71.6±8μs         39.5±1μs     0.55  bench_lib.Pad.time_pad((10, 10, 10), 1, 'wrap')
-       81.7±10μs         44.8±2μs     0.55  bench_lib.Pad.time_pad((10, 100), 1, 'edge')
-        420±90μs         230±10μs     0.55  bench_shape_base.Block.time_3d(10, 'block')
-        114±20μs         62.3±2μs     0.55  bench_lib.Pad.time_pad((10, 10, 10), (0, 5), 'constant')
-      5.76±0.1μs      3.13±0.08μs     0.54  bench_core.CorrConv.time_convolve(50, 10, 'same')
-      5.30±0.1μs      2.84±0.08μs     0.54  bench_core.CorrConv.time_correlate(50, 100, 'valid')
-        92.5±4μs         49.3±1μs     0.53  bench_shape_base.Block2D.time_block2d((256, 256), 'uint32', (2, 2))
-        13.5±3μs       7.07±0.2μs     0.52  bench_reduce.MinMax.time_min(<type 'numpy.float32'>)
-        7.66±1μs       3.88±0.2μs     0.51  bench_core.CorrConv.time_convolve(50, 100, 'valid')
-        29.0±3μs       14.5±0.8μs     0.50  bench_shape_base.Block.time_no_lists(10)
-      6.62±0.3μs       3.30±0.2μs     0.50  bench_core.CorrConv.time_convolve(1000, 1000, 'valid')
-        74.2±7μs       36.2±0.9μs     0.49  bench_shape_base.Block2D.time_block2d((256, 256), 'uint16', (2, 2))
-      5.55±0.3μs       2.70±0.2μs     0.49  bench_core.CorrConv.time_convolve(50, 10, 'valid')
-       73.9±20μs         35.8±2μs     0.48  bench_lib.Pad.time_pad((10, 100), 1, 'reflect')
-        224±20μs          107±7μs     0.48  bench_shape_base.Block2D.time_block2d((256, 256), 'uint64', (4, 4))
-      3.87±0.1μs      1.83±0.06μs     0.47  bench_core.CountNonzero.time_count_nonzero(2, 100, <type 'str'>)
-        109±30μs         51.5±3μs     0.47  bench_lib.Pad.time_pad((10, 10, 10), (0, 5), 'edge')
-        240±20μs          112±4μs     0.47  bench_shape_base.Block2D.time_block2d((512, 512), 'uint16', (4, 4))
-        337±40μs          158±7μs     0.47  bench_shape_base.Block2D.time_block2d((512, 512), 'uint32', (4, 4))
-         188±8μs         88.0±2μs     0.47  bench_shape_base.Block2D.time_block2d((512, 512), 'uint8', (4, 4))
-      4.39±0.2μs      2.04±0.09μs     0.47  bench_core.CountNonzero.time_count_nonzero(3, 10000, <type 'bool'>)
-        73.2±4μs       33.9±0.5μs     0.46  bench_shape_base.Block2D.time_block2d((128, 128), 'uint64', (2, 2))
-        5.48±1μs       2.44±0.1μs     0.45  bench_core.CountNonzero.time_count_nonzero(2, 100, <type 'object'>)
-      4.46±0.1μs      1.97±0.08μs     0.44  bench_core.CorrConv.time_correlate(50, 10, 'full')
-        30.4±9μs       13.3±0.3μs     0.44  bench_shape_base.Block.time_no_lists(1)
-      7.05±0.2μs      3.05±0.06μs     0.43  bench_reduce.SmallReduction.time_small
-        7.35±1μs       3.12±0.2μs     0.42  bench_core.CorrConv.time_convolve(50, 10, 'full')
-      4.36±0.1μs      1.84±0.07μs     0.42  bench_core.CorrConv.time_correlate(50, 10, 'same')
-      3.51±0.2μs      1.46±0.05μs     0.42  bench_core.CountNonzero.time_count_nonzero(1, 100, <type 'object'>)
-     4.03±0.05μs       1.66±0.1μs     0.41  bench_core.CorrConv.time_correlate(1000, 1000, 'valid')
-        199±10μs         80.1±3μs     0.40  bench_shape_base.Block2D.time_block2d((256, 256), 'uint32', (4, 4))
-      3.98±0.2μs      1.60±0.08μs     0.40  bench_core.CountNonzero.time_count_nonzero(2, 10000, <type 'bool'>)
-        61.8±2μs         24.8±1μs     0.40  bench_shape_base.Block2D.time_block2d((256, 256), 'uint8', (2, 2))
-      4.13±0.1μs      1.62±0.05μs     0.39  bench_core.CorrConv.time_correlate(50, 10, 'valid')
-        61.6±2μs         23.9±1μs     0.39  bench_shape_base.Block2D.time_block2d((128, 128), 'uint32', (2, 2))
-        184±10μs         70.5±3μs     0.38  bench_shape_base.Block2D.time_block2d((256, 256), 'uint16', (4, 4))
-        56.1±4μs       21.0±0.9μs     0.38  bench_shape_base.Block2D.time_block2d((64, 64), 'uint64', (2, 2))
-        40.0±2μs       15.0±0.6μs     0.37  bench_shape_base.Block.time_block_simple_column_wise(10)
-         121±2μs         45.1±2μs     0.37  bench_shape_base.Block.time_nested(1)
-         179±4μs         66.1±4μs     0.37  bench_shape_base.Block2D.time_block2d((128, 128), 'uint64', (4, 4))
-        59.8±2μs         22.0±1μs     0.37  bench_shape_base.Block2D.time_block2d((128, 128), 'uint16', (2, 2))
-     3.19±0.05μs      1.17±0.02μs     0.37  bench_core.CountNonzero.time_count_nonzero(1, 100, <type 'str'>)
-        54.0±3μs         19.7±1μs     0.37  bench_shape_base.Block2D.time_block2d((32, 32), 'uint64', (2, 2))
-        56.9±1μs       20.7±0.7μs     0.36  bench_shape_base.Block2D.time_block2d((64, 64), 'uint32', (2, 2))
-      3.14±0.1μs      1.14±0.04μs     0.36  bench_core.CountNonzero.time_count_nonzero(1, 10000, <type 'bool'>)
-        92.7±2μs         33.7±2μs     0.36  bench_shape_base.Block.time_block_complicated(1)
-         104±4μs         37.8±1μs     0.36  bench_shape_base.Block.time_block_complicated(10)
-         128±5μs         45.5±2μs     0.36  bench_shape_base.Block.time_nested(10)
-       196±100μs         69.4±3μs     0.35  bench_ma.Concatenate.time_it('unmasked+masked', 2)
-         153±5μs         53.9±2μs     0.35  bench_shape_base.Block2D.time_block2d((128, 128), 'uint16', (4, 4))
-        39.4±2μs       13.8±0.5μs     0.35  bench_shape_base.Block.time_block_simple_column_wise(1)
-        53.5±2μs         18.7±1μs     0.35  bench_shape_base.Block2D.time_block2d((32, 32), 'uint8', (2, 2))
-        55.2±2μs       19.3±0.6μs     0.35  bench_shape_base.Block2D.time_block2d((32, 32), 'uint16', (2, 2))
-        16.9±1μs       5.89±0.5μs     0.35  bench_core.Core.time_dstack_l
-        60.6±3μs       21.1±0.6μs     0.35  bench_shape_base.Block2D.time_block2d((128, 128), 'uint8', (2, 2))
-      25.5±0.2μs       8.88±0.3μs     0.35  bench_shape_base.Block.time_block_simple_row_wise(10)
-        54.6±3μs       19.0±0.6μs     0.35  bench_shape_base.Block2D.time_block2d((16, 16), 'uint64', (2, 2))
-        52.6±2μs       18.2±0.7μs     0.35  bench_shape_base.Block2D.time_block2d((16, 16), 'uint16', (2, 2))
-        6.57±2μs      2.25±0.08μs     0.34  bench_core.CountNonzero.time_count_nonzero(3, 100, <type 'str'>)
-        24.3±1μs       8.30±0.6μs     0.34  bench_shape_base.Block.time_block_simple_row_wise(1)
-         148±3μs         50.0±3μs     0.34  bench_shape_base.Block2D.time_block2d((16, 16), 'uint32', (4, 4))
-         171±8μs         57.9±4μs     0.34  bench_shape_base.Block2D.time_block2d((256, 256), 'uint8', (4, 4))
-         159±5μs         53.8±1μs     0.34  bench_shape_base.Block2D.time_block2d((64, 64), 'uint64', (4, 4))
-        171±20μs         57.7±2μs     0.34  bench_shape_base.Block2D.time_block2d((128, 128), 'uint32', (4, 4))
-      3.15±0.3μs      1.06±0.03μs     0.34  bench_core.CountNonzero.time_count_nonzero(3, 100, <type 'int'>)
-        55.7±5μs       18.7±0.2μs     0.34  bench_shape_base.Block2D.time_block2d((16, 16), 'uint8', (2, 2))
-         158±7μs         52.6±3μs     0.33  bench_shape_base.Block2D.time_block2d((128, 128), 'uint8', (4, 4))
-         153±4μs         50.7±1μs     0.33  bench_shape_base.Block2D.time_block2d((32, 32), 'uint64', (4, 4))
-         152±7μs         50.3±1μs     0.33  bench_shape_base.Block2D.time_block2d((16, 16), 'uint8', (4, 4))
-        53.6±3μs       17.7±0.4μs     0.33  bench_shape_base.Block2D.time_block2d((16, 16), 'uint32', (2, 2))
-         156±4μs         51.4±3μs     0.33  bench_shape_base.Block2D.time_block2d((64, 64), 'uint8', (4, 4))
-         148±3μs         48.2±2μs     0.33  bench_shape_base.Block2D.time_block2d((16, 16), 'uint16', (4, 4))
-        160±10μs         52.0±1μs     0.33  bench_shape_base.Block2D.time_block2d((64, 64), 'uint32', (4, 4))
-         159±8μs         51.4±3μs     0.32  bench_shape_base.Block2D.time_block2d((64, 64), 'uint16', (4, 4))
-        59.8±3μs         19.3±1μs     0.32  bench_shape_base.Block2D.time_block2d((32, 32), 'uint32', (2, 2))
-         153±4μs         49.4±2μs     0.32  bench_shape_base.Block2D.time_block2d((32, 32), 'uint32', (4, 4))
-      15.6±0.6μs       5.03±0.3μs     0.32  bench_core.Core.time_vstack_l
-         154±7μs         49.7±2μs     0.32  bench_shape_base.Block2D.time_block2d((32, 32), 'uint8', (4, 4))
-        59.6±6μs       19.1±0.8μs     0.32  bench_shape_base.Block2D.time_block2d((64, 64), 'uint8', (2, 2))
-      3.03±0.4μs         969±30ns     0.32  bench_core.CountNonzero.time_count_nonzero(2, 100, <type 'int'>)
-        120±10μs         38.4±2μs     0.32  bench_shape_base.Block.time_3d(1, 'block')
-         156±5μs         49.3±1μs     0.32  bench_shape_base.Block2D.time_block2d((16, 16), 'uint64', (4, 4))
-        164±10μs         49.3±2μs     0.30  bench_shape_base.Block2D.time_block2d((32, 32), 'uint16', (4, 4))
-       65.7±10μs       19.6±0.7μs     0.30  bench_shape_base.Block2D.time_block2d((64, 64), 'uint16', (2, 2))
-     2.82±0.08μs         732±30ns     0.26  bench_core.CountNonzero.time_count_nonzero(1, 100, <type 'int'>)
-     2.77±0.07μs         664±30ns     0.24  bench_core.CountNonzero.time_count_nonzero(2, 100, <type 'bool'>)
-      2.61±0.1μs         624±20ns     0.24  bench_core.CountNonzero.time_count_nonzero(1, 100, <type 'bool'>)
-        16.8±3μs       3.97±0.2μs     0.24  bench_core.Core.time_hstack_l
-      2.78±0.1μs         637±20ns     0.23  bench_core.CountNonzero.time_count_nonzero(3, 100, <type 'bool'>)
-      2.36±0.2μs          207±5ns     0.09  bench_overrides.ArrayFunction.time_mock_broadcast_to_numpy
-      2.68±0.1μs          221±7ns     0.08  bench_overrides.ArrayFunction.time_mock_concatenate_numpy
-      2.58±0.1μs         201±10ns     0.08  bench_overrides.ArrayFunction.time_mock_broadcast_to_duck
-      3.02±0.2μs          222±6ns     0.07  bench_overrides.ArrayFunction.time_mock_concatenate_duck
-      4.29±0.3μs          216±6ns     0.05  bench_overrides.ArrayFunction.time_mock_concatenate_mixed
-        142±20μs          213±8ns     0.00  bench_overrides.ArrayFunction.time_mock_concatenate_many

SOME BENCHMARKS HAVE CHANGED SIGNIFICANTLY.

スプレッドシートについては、 https：//docs.google.com/spreadsheets/d/15-AFI_cmZqfkU6mo2p1znsQF2E52PEXpF68QqYqEar4/edit#gid = 0も参照して

当然のことながら、最大のパフォーマンスの違いは、他のnumpy関数を内部で何度も呼び出す関数、たとえばnp.block()です。

@ shoyer-余分な時間がかかったことに少し戸惑いました...おそらく、実際にはCを実装する必要がありますが、その間に、1つだけの一般的なケースで時間を削るいくつかの小さな変更を加えてPRを行いましたタイプ、およびタイプがndarrayのみの場合。 ＃12321を参照してください。

@ shoyer-私はメーリングリストで2つの問題を提起しましたが、おそらくここでも述べておくとよいでしょう。

1. 配列のような引数のすべての一意のタイプをtypes含める必要がありますか？ （オーバーライドを提供する引数だけでなく。）実装について知っておくと役立つように思われます。 （＃12327を参照）。
2. __array_function__をオーバーライドする場合でも、 ndarray.__array_function__実装はサブクラスを受け入れる必要がありますか？ これは、リスコフの置換原則と、サブクラスがすでに保釈される機会があったことを考えると、合理的です。 これは、 ndarray.__array_function__内のパブリック関数ではなく、実装を呼び出すことを意味します。 （そして__array_ufunc__似たようなもの...） __array_function__のみの試用版については＃12328を参照してください。

@ shoyer- （1）の簡単な実装については＃12327を参照してください-このルートに行く場合は、NEPも調整する必要があると思います。

そして、（2）のトライアルのための＃12328、主にそれがどのように見えるかを見るために。

私はここで両方の変更で+1しています。

エラーメッセージのディスパッチャ関数の名前がhttps://github.com/numpy/numpy/pull/12789に再び表示され、誰かがTypeError: _pad_dispatcher missing 1 required positional argumentを見て驚いた

上記で概説した代替案https://github.com/numpy/numpy/issues/12028#issuecomment-429377396 （現在2を使用）に加えて、4番目のオプションを追加します。

オプション4 ：関数と同じ名前で、関数ごとに個別のディスパッチャーを記述します。

def sin(a):
    return (a,)


@array_function_dispatch(sin)
def sin(a):
     ...


def cos(a):
    return (a,)


@array_function_dispatch(cos)
def cos(a):
    ...

利点：

• Pythonは、エラーメッセージで常に正しい関数名を提供するようになりました。

短所：

• より多くのコードの繰り返し
• より間接的な-どの関数名padが間違った引数を受け取ったかはもはや明確ではありません（ただし、それらが同期されていることを確認するためのテストがあります）。

現在のコードを機能させ続けるためには、実際の関数はディスパッチャの_後に_来る必要があると思います。

そうですが、ディスパッチャと同じ名前を付けることができます。 コーディネーター名は上書きされます。

np.arangeやnp.emptyなどの関数のカスタムディスパッチを定義できると便利です。

1つのオプションは、NumPyが配列だけでなくスカラーにもディスパッチすることだと思います。 これはNEPと互換性がありませんか？ この変更で何かが壊れますか？

np.arange説明についてhttps：//github.com/numpy/numpy/issues/12379を参照して

np.empty()がどのようにディスパッチできるかわかりません。ディスパッチするものはなく、形状とdtypeだけです。 しかし、確かにnp.empty_like()は、上書きされた形状でディスパッチを実行できます。これは、 https：//github.com/numpy/numpy/pull/13046がサポートしていることです。

オプション4 ：関数と同じ名前で、関数ごとに個別のディスパッチャーを記述します。

このオプションを採用することに異議はありますか？ ユーザーの観点からすると、おそらく最もフレンドリーな選択だと思います。

np.empty（）がどのようにディスパッチを実行できるかわかりません-ディスパッチするものはなく、形状とdtypeだけです

あなたはそれらのどちらかに派遣したいかもしれません。 たとえば、これはカスタムシェイプオブジェクトであり、別の方法でディスパッチしたい場合があります。

この例はあまり役に立ちませんが、形のように動作するが整数を返さず、式を返す怠惰なオブジェクトがあるという考えです。 たとえば、次のようなことができると便利です。

class ExprShape:
    def __getitem__(self, i):
        return ('getitem', self, i)
    def __len__(self):
        return ('len', self)

numpy.empty(ExprShape())

ExprArray('empty', ExprShape())ようなものを返すために、どちらをオーバーライドしたいと思いますか。

はい、原則として形状で発送することも可能です。 これにより、プロトコルがさらに複雑/オーバーヘッドになります。 配列をテンプレートとして使用する（ empty_likeとshape ）だけでは不十分なユースケースはありますか？

私が考えることができる他のケースは、 size np.random.RandomStateメソッドに対するsize引数ですが、現在、それらをまったくサポートしていないことに注意してください-http：//www.numpy.org/を参照して

配列をテンプレートとして使用する（shapeのempty_likeなど）だけでは不十分なユースケースはありますか？

NumPyに依存する既存のAPIを使用していて、既存のソースコードを変更せずに、別のバックエンドで透過的に機能させたい場合。

たとえば、配列のようなNPを使用してscipy.optimize.differential_evolutionを呼び出そうとしたとします。これにより、すぐに実行するのではなく、コールグラフが作成されます。

あなたは見ることができ、ここで、我々は変更することができれば、それは参考になるnp.fullそれに渡された入力にも象徴的だった場合、代わりにデフォルトのnumpyの配列のシンボリックな配列を作成します。

NumPyに依存する既存のAPIを使用していて、既存のソースコードを変更せずに、別のバックエンドで透過的に機能させたい場合。

これは一般的には不可能です。 np.array()ような明示的な配列構造は、ダックタイピングと互換性があるように間違いなく書き直す必要があります。

この場合、 energies = np.full(num_members, np.inf)をenergies = np.full_like(population, np.inf, shape=num_members)切り替えるのは、簡単で読みやすい変更のようです。

これは一般的には不可能です。 np.array（）のような明示的な配列構造は、ダックタイピングと互換性があるように間違いなく書き直す必要があります。

この種の変更を行うことに関する提案はありますか、それともnp.arrayディスパッチをサポートすることは非常に困難であり、100％のサポートを得ることができないと言っていますか？

この場合、energies = np.full（num_members、np.inf）をenergies = np.full_like（population、np.inf、shape = num_members）に切り替えると、簡単で読みやすい変更のように見えます。

間違いなく。 しかし、ソースコードを制御しない場合や、ユーザーが知っていて気に入っている機能を可能な限り使用できるようにサポートしたい場合が多くあります。

ユーザーにそのエクスペリエンスを提供する方法は他にもあります。

• numpyのように動作するが、希望どおりに動作する新しいモジュールを提供します。 ユーザーはインポートを変更する必要があります
• ソースを調べて、動作を理解します。 alanumbaまたはタンジェント。

特定の場合（ユーザーがnp.fullを呼び出して、現在シンボリックな結果を返すようにするなど）には、これらのオプションの両方が必要になる場合がありますが、私が正しく理解していれば、NEP-18の目標はそれらが必要なときに制限しようとすることですより多くの場合、元のNumPyを使用できるようにします。

ここにはパフォーマンスと複雑さのトレードオフがあることを理解しています。これは、これらを実装しない理由になる可能性があります。 しかし、それはユーザーに彼らが望む柔軟性を得るために他の手段を探求することを強いるかもしれません。

この種の変更を行うことに関する提案はありますか、それともnp.arrayディスパッチをサポートすることは非常に困難であり、100％のサポートを得ることができないと言っていますか？

NEP 22には、ここでのオプションに関するいくつかの説明があります。 np.asarray()のセマンティクスを安全に変更して、 numpy.ndarrayオブジェクト以外のものを返すことはできないと思います。これには、新しいプロトコルが必要になります。

問題は、 np.asarray()が現在、numpy配列オブジェクトにキャストする慣用的な方法であるということです。これは、たとえばメモリレイアウトに至るまで、 numpy.ndarrayと完全に一致することができます。

これが当てはまらないユースケースは確かにたくさんありますが、この動作を切り替えると多くのダウンストリームコードが破損するため、初心者ではありません。 ダウンストリームプロジェクトでは、少なくとも配列ダックタイピングのこの側面にオプトインする必要があります。

ここにはパフォーマンスと複雑さのトレードオフがあることを理解しています。これは、これらを実装しない理由になる可能性があります。 しかし、それはユーザーに彼らが望む柔軟性を得るために他の手段を探求することを強いるかもしれません。

はい。 NEP 18は、ドロップインNumPyの代替案の完全なソリューションとなることを意図したものではありませんが、その方向への一歩です。

__numpy_implementation__属性を追加するためのNEP-18の改訂版を作成しました。
https://github.com/numpy/numpy/pull/13305

numpy.testingの関数をワープするのを忘れていることに気づきました： https ：

私はすぐにそれをするつもりです...

特にNEP-18がサブクラスの作成者に提供する保証を明確にするためにNEPに確認したい改訂が1つあります： https ：

gh-13329が修正されてから、ユーザビリティタスクを完了としてマークしました。 決定しました-＃13588は1.17のリリース後まで待つことができます。 これにより、ドキュメントが改善され、 arange gh-12379は1.17に含めることができます。

＃13728もあります- histogram[2d]dディスパッチャのバグ

そのため、ドキュメントが改善され、gh-12379の範囲は1.17に含めることができます。

ドキュメントの問題が欠落していたので、gh-13844を開きました。 ドキュメントはarange未解決の問題よりもはるかに重要だと思います。

@shoyerこれを閉じることができますか？