Numpy: NEP-18 구현을위한 추적 문제 (__array_function__)

일부 주요 기능에 대한 예비 "모든 공용 NumPy 기능을 @array_function_dispatch로 장식"을 병합하고 프로토콜의 다운 스트림 소비자에게 시도해 보도록 요청하는 것이 좋습니다.

https://github.com/numpy/numpy/pull/12099 병합하면 numpy.core 대부분에 디스패치 데코레이터를 추가 할 또 다른 PR이 준비됩니다. 작업을 마치는 것은 꽤 쉬울 것입니다. 한 시간도 채 걸리지 않았습니다.

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- 구현 중 일부를 보면 두 가지 걱정이 있습니다.

• reshape 와 같은 일부 함수의 경우 원래 기능은 reshape 메서드를 정의하여이를 재정의하는 방법을 이미 제공했습니다. 우리는 __array_function__ 를 정의하는 모든 클래스에 대해이를 효과적으로 사용하지 않습니다.
• np.median 와 같은 다른 함수의 경우 np.asanyarray 및 ufuncs를주의 깊게 사용하면 하위 클래스에서 이미 사용할 수 있습니다. 그러나 해당 기능은 더 이상 직접 액세스 할 수 없습니다.

나는 우리가 인터페이스를 단순화하고 순수에 최적화 된 구현 할 수 있기 때문에 전체 이러한 두 가지, 아마 이점 생각 ndarray , 후자는 것을 제안하지만 - 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 : 디스패처 정의가 한 줄에 맞을 때 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):
     ...

장점 :

• 디스패처 정의를 찾을 필요가 없습니다. 바로 거기에 있습니다.
• 더 적은 수의 문자 및 코드 줄.
• 짧은 경우 (예 : 하나의 인수), 특히 람다가 함수 이름보다 짧을 때 매우 좋습니다.

단점 :

• 옵션 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를 완전히 오버로드 할 수 있도록 만드는 데 필요한 마지막 작업이라고 생각합니다. NumPy 1.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 에 재정의를 추가하면 몇 가지 Pandas 테스트가 실패했습니다 (https://github.com/pandas-dev/pandas/issues/23172). 아직 무슨 일이 일어나고 있는지 확실하지 않지만 출시하기 전에 확실히 파악해야합니다.

이것이 dask / pandas에서 테스트 실패를 일으키는 이유를 가장 잘 추측 하려면 https://github.com/numpy/numpy/issues/12225 를 참조

수입 시간의 일부 벤치 마크 (솔리드 스테이트 드라이브가있는 MacBook Pro에서) :

• NumPy 1.15.2 : 152.451ms
• NumPy 마스터 : 156.5745ms
• decorator.decorate (# 12226) : 183.694ms

내 벤치 마크 스크립트

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 애플리케이션에 유용합니다.

모듈의 메모리 사용량을 안정적으로 측정하는 방법을 알고 있습니까?
2018 년 10 월 20 일 토요일 오전 6:56 Hameer Abbasi [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 포함하는 스크립트를 작성하고 sleep 문을 추가하고 프로세스 메모리를 추적하는 것만으로도 충분하다고 생각합니다. 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 에서 빠르게 살펴보고 싶어합니다 (실제로 두 가지 기능 만 포함되어 있습니다!) 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 구현을 가져야했지만, 그 동안 나는 단지 하나의 일반적인 경우를 위해 약간의 시간을 삭감하는 약간의 변경으로 PR을 만들었다. 유형 및 유일한 유형이 ndarray . # 12321을 참조하십시오.

@shoyer- 메일 링리스트에서 두 가지 문제를 제기했습니다.

1. 모든 고유 한 유형의 배열 유사 인수가 types 합니까? (단지 재정의를 제공하는 인수보다는) 구현에 대해 아는 것이 도움이 될 것 같습니다. (# 12327 참조).
2. ndarray.__array_function__ 구현은 __array_function__ 를 재정의하더라도 하위 클래스를 허용해야합니까? 이것은 Liskov 대체 원칙을 고려할 때 합리적이며 하위 클래스가 이미 보석금을 낼 기회가 있다는 점을 감안할 때 합리적입니다. 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 : 함수와 이름이 같은 각 함수에 대해 별도의 디스패처를 작성합니다.

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와 같은 함수에 대한 사용자 지정 발송을 정의 할 수 있으면 좋을 것입니다.

한 가지 옵션은 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 empty_like shape )로 충분하지 않은 사용 사례가 있습니까?

내가 생각할 수있는 다른 경우는 np.random.RandomState 메서드에 대한 size 인수이지만 현재는 이러한 메서드를 전혀 지원하지 않습니다. http://www.numpy.org/ 참조 neps / nep-0018-array-function-protocol.html # callable -objects-generated-at-runtime

배열을 템플릿으로 사용하는 경우 (예 : empty_like with shape)가 충분하지 않은 사용 사례가 있습니까?

NumPy에 의존하는 기존 API를 사용하고 기존 소스 코드를 변경하지 않고 다른 백엔드에서 투명하게 작동하도록하려는 경우.

예를 들어, 즉시 실행되는 대신 호출 그래프를 작성하는 NP와 같은 배열로 scipy.optimize.differential_evolution 를 호출하려고한다고 가정 해 보겠습니다.

여기에 전달 된 입력이 심볼릭 인 경우 기본 numpy 배열 대신 심볼릭 배열을 만들기 위해 np.full 를 변경할 수 있다면 도움이 될 것입니다.

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처럼 작동하지만 원하는 방식으로 작동하는 새 모듈을 제공합니다. 사용자가 가져 오기를 변경해야합니다.
• 소스를 조사하여 동작을 이해하십시오. ala numba 또는 tangent.

두 옵션 모두 특정 경우에 필요할 수 있지만 (예 : 사용자가 np.full 호출하고 현재 기호화 된 결과를 반환하도록 허용), 내가 올바르게 이해한다면 NEP-18의 목표는 이러한 옵션이 필요한시기를 제한하는 것입니다. 더 많은 경우에 사람들이 원래 NumPy를 사용하도록합니다.

여기에 성능 / 복잡성 트레이드 오프가 있음을 이해하고 이것이이를 구현하지 않는 좋은 이유 일 수 있습니다. 그러나 사용자가 원하는 유연성을 얻기 위해 다른 방법을 모색해야 할 수도 있습니다.

이런 종류의 변경에 대한 제안이 있습니까? 아니면 np.array 파견 지원이 정말 힘들어서 100 % 지원을받을 수 없다고 말씀하시는 건가요?

NEP 22 에는 여기에서 옵션에 대한 몇 가지 논의가 있습니다. numpy.ndarray 객체 이외의 다른 것을 반환하기 위해 np.asarray() 의 의미를 안전하게 변경할 수 있다고 생각하지 않습니다.이를 위해 새 프로토콜이 필요합니다.

문제는이다 np.asarray() 현재 용도가 정확히 일치 할 것으로 예상 할 수있는 NumPy와 배열 객체에 캐스팅의 관용적 방법입니다 numpy.ndarray 아래로 메모리 레이아웃으로, 예를 들어,.

이것이 사실이 아닌 많은 사용 사례가 있지만이 동작을 전환하면 많은 다운 스트림 코드가 손상되므로 시작하지 않습니다. 다운 스트림 프로젝트는 최소한 배열 덕 타이핑의 이러한 측면을 선택해야합니다.

여기에 성능 / 복잡성 트레이드 오프가 있음을 이해하고 이것이이를 구현하지 않는 좋은 이유 일 수 있습니다. 그러나 사용자가 원하는 유연성을 얻기 위해 다른 방법을 모색해야 할 수도 있습니다.

예. NEP 18은 드롭 인 NumPy 대안을위한 완전한 솔루션이 아니라 그 방향으로 나아가는 단계입니다.

__numpy_implementation__ 속성을 추가하기 위해 NEP-18에 대한 개정 본을 작성했습니다.
https://github.com/numpy/numpy/pull/13305

우리가 numpy.testing 의 함수를 왜곡하는 것을 잊었다는 생각이 듭니다 : https://github.com/numpy/numpy/issues/13588

잠시만 요 ...

NEP에 대해보고 싶은 수정 사항이 하나 있습니다. 특히 NEP-18이 하위 클래스 작성자에게 제공하는 내용을 명확히하기 위해 https://github.com/numpy/numpy/pull/13633

gh-13329가 수정 된 이후로 사용성 작업이 완료된 것으로 표시했습니다. 우리는 1.17이 출시 될 때까지 기다릴 수 있다고 결정했습니다. 이로 인해 문서 개선 및 arange gh-12379가 여전히 1.17에 포함될 수 있습니다.

또한 # 13728- histogram[2d]d 에 대한 디스패처의 버그

이로 인해 문서 개선 및 범위 gh-12379가 여전히 1.17에 포함될 수 있습니다.

문서에 대한 문제가 없어서 gh-13844를 열었습니다. 나는 문서가 arange 공개 문제보다 훨씬 더 중요하다고 생각합니다.

@shoyer 이거 닫아도 될까요?