Numpy: NEP-18 के कार्यान्वयन के लिए ट्रैकिंग मुद्दा (__array_function__)

कुछ हाई-प्रोफाइल फ़ंक्शंस के लिए एक प्रारंभिक "सभी सार्वजनिक NumPy कार्यों को @array_function_dispatch" के साथ मर्ज करना अच्छा होगा और प्रोटोकॉल के डाउनस्ट्रीम उपभोक्ताओं से इसे आज़माने का अनुरोध करें

एक बार जब हम https://github.com/numpy/numpy/pull/12099 को मर्ज करते हैं, तो मेरे पास एक और पीआर तैयार है जो अधिकांश numpy.core लिए प्रेषण सज्जाकारों को जोड़ देगा। चीजों को खत्म करना बहुत आसान होगा - यह एक साथ रखने के लिए एक घंटे से भी कम समय लेता है।

cc @ eric-wieser @mrocklin @mhvk @hameerabbasi

मेरी शाखा के लिए https://github.com/shoyer/numpy/tree/array-function-easy-impl देखें जो पायथन रैपर के साथ कार्यों पर सभी "आसान" ओवरराइड को लागू करते हैं। बचे हुए भाग np.block , np.einsum और पूरी तरह से C (जैसे, np.concatenate ) में पूरी तरह से लिखे गए हैं। हम # 12099 के साथ एक बार पीआर के एक समूह में विभाजित कर देंगे।

ध्यान दें कि मैंने प्रत्येक व्यक्तिगत फ़ंक्शन पर ओवरराइड के लिए परीक्षण नहीं लिखा है। जब हम कर रहे हैं तो मैं कुछ एकीकरण परीक्षण जोड़ना चाहूंगा (जैसे, एक बतख सरणी जो सभी लागू कार्यों को लॉग करता है), लेकिन मुझे नहीं लगता कि प्रत्येक व्यक्तिगत फ़ंक्शन के लिए डिस्पैचिंग परीक्षण लिखना उत्पादक होगा। # 12099 में चेकों को डिस्पैचर्स पर सबसे आम त्रुटियों को पकड़ना चाहिए, और डिस्पैचर कार्यों में कोड की प्रत्येक पंक्ति को मौजूदा परीक्षणों द्वारा निष्पादित किया जाना चाहिए।

@shoyer - परीक्षणों पर, मैं मानता हूं कि प्रत्येक के लिए परीक्षण लिखना विशेष रूप से उपयोगी नहीं है; इसके बजाय, सुन्न के भीतर, यह MaskedArray में अपेक्षाकृत जल्दी ओवरराइड्स का उपयोग शुरू करने के लिए सबसे अधिक समझदार हो सकता है।

@ mhvk मुझे अच्छा लगता है, हालांकि मैं किसी और को इस्तेमाल करने देता / जानता हूं जो मास्कसेर्रे का उपयोग करता है।

Https://github.com/numpy/numpy/pull/12115 , https://github.com/numpy/numpy/pull/12116 , # 12119 और https://github.com/numpy/numpy/null/ देखें 12117 पायथन में परिभाषित कार्यों पर __array_function__ समर्थन को लागू करने वाले पीआरएस के लिए।

@ शायर - कुछ कार्यान्वयनों को देखते हुए, मुझे दो चिंताएँ हैं:

• कुछ कार्यों के लिए, 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__ को अनदेखा करना चाहते हैं।

पुन :: डिस्पैचर स्टाइलिंग: शैली पर मेरी प्राथमिकताएं स्मृति / आयात समय के विचार, और वाचालता पर आधारित हैं। काफी बस, उन डिस्पैचर को मर्ज करें जहां हस्ताक्षर समान रहने की संभावना है। इस तरह, हम कम से कम वस्तुओं का निर्माण करते हैं और कैश हिट भी अधिक होगा।

उस ने कहा, मैं भी लंबोदर शैली का विरोध नहीं कर रहा हूं।

डिस्पैचर फ़ंक्शन लिखने की शैली अब कुछ पीआर में आ गई है। 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 : "लाइनों की कोड" पहलू को अधिक यथार्थवादी बनाने के लिए दो-पंक्ति PEP8 रिक्ति जोड़ने के लिए संपादित किया गया

ध्यान दें कि त्रुटि संदेश समस्याओं को कोड ऑब्जेक्ट को संगठित करके तय किया जा सकता है, हालांकि यह कुछ आयात-समय लागत के साथ आएगा। शायद जांच के लायक है, और कुछ विकल्पों की तुलना करने के लिए @nschloe के टूना को

हां, डेकोरेटर मॉड्यूल का उपयोग फ़ंक्शन परिभाषा उत्पन्न करने के लिए भी किया जा सकता है (यह कोड जनरेशन के लिए थोड़ा अलग दृष्टिकोण का उपयोग करता है, नामटूपल की तरह थोड़ा अधिक है कि यह exec() का उपयोग करता है)।

जब तक त्रुटि हल नहीं होती है, मुझे लगता है कि हमें एक डिस्पैचर के साथ विकल्पों पर छड़ी करने की आवश्यकता है जिसका एक स्पष्ट नाम है। मैं स्मृति कारणों से एक साथ (2) डिस्पैचर को बंडल करना चाहूंगा, हालांकि तब त्रुटि संदेश बहुत ध्यान में रखेगा, इसलिए डिस्पैचर को _dispatch_on_x तरह कॉल करने का सुझाव देगा।

हालांकि अगर हम त्रुटि को बदल सकते हैं, तो चीजें बदल जाती हैं। उदाहरण के लिए, यह अपवाद को पकड़ने के रूप में सरल हो सकता है, अपवाद पाठ में फ़ंक्शन नाम के साथ <lambda> जगह ले सकता है, और फिर फिर से बढ़ा सकता है। (या वह चेन इन दिनों बात करता है?)

मैं मानता हूं कि त्रुटि संदेश स्पष्ट होना चाहिए, आदर्श रूप से बिल्कुल भी नहीं बदलना चाहिए।

ठीक है, अब के लिए मुझे लगता है कि lambda का उपयोग करना बंद करना सबसे अच्छा है, जब तक कि हमें किसी प्रकार की कोड जनरेशन काम न मिले।

https://github.com/numpy/numpy/pull/12175 मल्टीएरे फ़ंक्शंस के लिए जो ओवरराइड करता है, उसका एक ड्राफ्ट जोड़ता है (सी में लिखा है) ऐसा लग सकता है जैसे हम पायथन रैपर दृष्टिकोण लेते हैं।

@ मैट्टिप हम matmul को एक ufunc के रूप में लागू करने पर कहाँ हैं? एक बार जब हम इन सभी __array_function__ ओवरराइड को पूरा कर लेते हैं, तो मुझे लगता है कि हमें NumPy के सार्वजनिक API को पूरी तरह से अधिभार योग्य बनाने की अंतिम आवश्यकता है। यह अच्छा होगा कि यह सभी NumPy 1.16 के लिए तैयार हो जाए!

PR # 11175, जो NEP 20 को लागू करता है, धीमी गति से प्रगति कर रहा है। यह PR # 11133 के लिए एक अवरोधक है, जिसमें matmul लूप कोड है। उस एक को अभी भी अद्यतन करने की आवश्यकता है और फिर बेंचमार्क के माध्यम से सत्यापित किया जाता है कि नया कोड पुराने की तुलना में धीमा नहीं है।

मेरे पास समीक्षा के लिए चार पीआरएस हैं जो ओवरराइड के पूर्ण सेट को पूरा करना चाहिए। अंतिम समीक्षा / साइनऑफ़ / मर्ज की सराहना की जाएगी ताकि हम बयाना में __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)। हम अभी तक निश्चित नहीं हैं कि क्या चल रहा है लेकिन हमें इसे जारी करने से पहले निश्चित रूप से पता लगाना चाहिए।

Https://github.com/numpy/numpy/issues/12225 पर मेरे सबसे अच्छे अनुमान के लिए देखें कि यह डस्क / पांडा में परीक्षण विफलताओं का कारण क्यों बन रहा है।

आयात समय के कुछ मानदंड (मेरी मैकबुक प्रो पर एक ठोस राज्य ड्राइव के साथ):

• NumPy 1.15.2: 152.451 एमएस
• न्यूम्पी मास्टर: 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 अनुप्रयोगों के लिए भी उपयोगी है।

क्या आप जानते हैं कि किसी मॉड्यूल के लिए मेमोरी उपयोग को मज़बूती से कैसे मापें?
सत, 20 अक्टूबर, 2018 को सुबह 6:56 बजे हमीर अब्बासी नोटिफिकेशन @github.com
लिखा था:

स्मृति उपयोग का कोई विचार (पहले / बाद)? यह उपयोगी है
अच्छी तरह से, विशेष रूप से 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 पर यह अंतिम पीआर है जो आंतरिक सुन्न कार्यों के लिए array_function_dispatch जोड़ रहा है।

संदर्भ के लिए, यहां __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 भी

आश्चर्य की बात नहीं, सबसे बड़ा प्रदर्शन अंतर उन कार्यों के लिए है जो अन्य सुन्न कार्यों को आंतरिक रूप से कई बार कहते हैं, उदाहरण के लिए, np.block() ।

@shoyer - अतिरिक्त समय ndarray । # 12321 देखें।

@shoyer - मैंने मेलिंग सूची में दो मुद्दे उठाए हैं जो शायद यहां भी

1. क्या सभी प्रकार के सरणी-प्रकार के तर्कों को types में शामिल किया जाना चाहिए? (केवल उन तर्कों के बजाय जो ओवरराइड प्रदान करते हैं।) यह कार्यान्वयन के लिए जानना उपयोगी होगा। (देखें # 12327)।
2. क्या ndarray.__array_function__ क्रियान्वयन उपवर्गों को स्वीकार कर सकता है, भले ही वे __array_function__ ओवरराइड करें? यह उचित होगा कि लिस्कोव को प्रतिस्थापन सिद्धांत दिया जाए और यह दिया जाए कि उपवर्ग के पास पहले से ही जमानत का मौका है। यह ndarray.__array_function__ अंदर सार्वजनिक फ़ंक्शन के बजाय कार्यान्वयन को कॉल करेगा। (और में कुछ इसी तरह __array_ufunc__ ...) के लिए एक परीक्षण के लिए # 12,328 देखें __array_function__ केवल।

@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):
    ...

लाभ:

• पायथन अब हमेशा त्रुटि संदेश में सही फ़ंक्शन नाम की आपूर्ति करता है।

नुकसान:

• अधिक कोड पुनरावृत्ति
• अधिक अप्रत्यक्षता - यह अब स्पष्ट नहीं है कि कौन सा फ़ंक्शन नाम pad गलत तर्क प्राप्त करता है (लेकिन हमारे पास यह सत्यापित करने के लिए परीक्षण हैं कि उन्हें सिंक में रखा गया है)।

मुझे लगता है कि वर्तमान कोड को काम करने के लिए, वास्तविक फ़ंक्शन को _after_ dispatcher आना चाहिए।

सही है, लेकिन हम इसे डिस्पैचर के समान नाम दे सकते हैं। प्रेषणकर्ता नाम अधिलेखित हो जाएगा।

यह np.arange या np.empty जैसे फ़ंक्शन के लिए कस्टम प्रेषण को परिभाषित करने में सक्षम होने के लिए बहुत अच्छा है।

मुझे लगता है कि एक विकल्प NumPy के लिए स्केलर के साथ-साथ सरणियों पर भेजने के लिए होगा। क्या यह एनईपी के साथ असंगत है? क्या इस बदलाव से कुछ टूटेगा?

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 विधियों के हैं, लेकिन ध्यान दें कि वर्तमान में हम उन सभी का समर्थन नहीं करते हैं - http://www.numpy.org/ देखें # callable -objects-generate-at-runtime

क्या आपके पास ऐसे उपयोग-मामले हैं जहां एक सरणी को टेम्पलेट के रूप में उपयोग करना (जैसे कि आकार के साथ खाली_ जैसा) पर्याप्त नहीं होगा?

यदि हम मौजूदा API ले रहे हैं जो NumPy पर निर्भर करता है और मौजूदा स्रोत कोड को बदले बिना पारदर्शी रूप से एक अलग बैकएंड पर काम करना चाहेगा।

उदाहरण के लिए, मान लें कि हम एनपी जैसे सरणियों के साथ scipy.optimize.differential_evolution कॉल करने का प्रयास कर रहे थे, जो तुरंत निष्पादित करने के बजाय कॉल ग्राफ़ बनाते हैं।

आप देख सकते हैं यहाँ यह मददगार होगा अगर हम बदल सकता है np.full , एक डिफ़ॉल्ट numpy सरणी के बजाय एक प्रतीकात्मक सरणी बनाने के लिए करता है, तो इनपुट पारित कर में यह भी प्रतीक चिन्ह है।

यदि हम मौजूदा API ले रहे हैं जो NumPy पर निर्भर करता है और मौजूदा स्रोत कोड को बदले बिना पारदर्शी रूप से एक अलग बैकएंड पर काम करना चाहेगा।

यह सामान्य रूप से संभव नहीं है। np.array() तरह स्पष्ट सरणी निर्माण निश्चित रूप से बतख टाइपिंग के साथ संगत होने के लिए फिर से लिखे जाने की आवश्यकता है।

इस मामले में, energies = np.full(num_members, np.inf) से energies = np.full_like(population, np.inf, shape=num_members) बदलना एक आसान और पठनीय परिवर्तन जैसा लगता है।

यह सामान्य रूप से संभव नहीं है। Np.array () की तरह स्पष्ट सरणी निर्माण निश्चित रूप से बतख टाइपिंग के साथ संगत होने के लिए फिर से लिखे जाने की आवश्यकता है।

क्या इस प्रकार का परिवर्तन करने के आसपास कोई प्रस्ताव है या आप कह रहे हैं कि np.array का डिस्पैचिंग का समर्थन करना वास्तव में कठिन होगा और इसलिए हम कभी भी 100% समर्थन प्राप्त नहीं कर सकते हैं?

इस मामले में, ऊर्जा = np.full (num_members, np.inf) को ऊर्जा = np.full_like (जनसंख्या, np.inf, आकार = num_members) पर स्विच करना एक आसान और पठनीय परिवर्तन जैसा लगता है।

निश्चित रूप से। लेकिन ऐसे कई मामले हैं जहां या तो आप स्रोत कोड को नियंत्रित नहीं करते हैं, या आप उन कार्यों का उपयोग करने में उपयोगकर्ताओं का समर्थन करना चाहते हैं जो वे जानते हैं और जितना संभव हो उतना प्यार करते हैं।

उस अनुभव के साथ उपयोगकर्ताओं को प्रदान करने के अन्य तरीके हैं:

• एक नया मॉड्यूल प्रदान करना जो सुन्न की तरह काम करता है लेकिन व्यवहार करता है कि आप कैसे चाहते हैं। उपयोगकर्ताओं को अपने आयात को बदलने की आवश्यकता है
• व्यवहार को समझने के लिए स्रोत का निरीक्षण करें। ala सुंबा या स्पर्शरेखा।

उन दोनों विकल्पों की कुछ मामलों में आवश्यकता हो सकती है (जैसे उपयोगकर्ताओं को np.full कॉल करना और वर्तमान में एक प्रतीकात्मक परिणाम देना), लेकिन अगर मैं सही ढंग से समझता हूं, तो NEP-18 का लक्ष्य उन लोगों को सीमित करने की कोशिश करना है, जब उनकी आवश्यकता होती है और लोगों को अधिक मामलों में मूल NumPy का उपयोग करने दें।

मैं समझता हूं कि यहां एक प्रदर्शन / जटिलता ट्रेडऑफ है और इसे लागू नहीं करने का एक अच्छा कारण हो सकता है। लेकिन यह उपयोगकर्ताओं को उनकी इच्छा के अनुसार लचीलापन पाने के लिए अन्य साधनों का पता लगाने के लिए मजबूर कर सकता है।

क्या इस प्रकार का परिवर्तन करने के आसपास कोई प्रस्ताव है या आप कह रहे हैं कि np.array का डिस्पैचिंग का समर्थन करना वास्तव में कठिन होगा और इसलिए हम कभी भी 100% समर्थन प्राप्त नहीं कर सकते हैं?

एनईपी 22 में यहां विकल्पों की कुछ चर्चा है। मुझे नहीं लगता कि हम numpy.ndarray ऑब्जेक्ट के अलावा कुछ भी वापस करने के लिए np.asarray() के शब्दार्थ को सुरक्षित रूप से बदल सकते हैं - हमें इसके लिए एक नए प्रोटोकॉल की आवश्यकता होगी।

समस्या यह है कि np.asarray() वर्तमान में एक संख्यात्मक सरणी ऑब्जेक्ट के लिए कास्टिंग करने का मुहावरेदार तरीका है, जो मेमोरी लेआउट के नीचे 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-18 की क्या गारंटी देता है: https://github.com/numpy/numpy/pull/13633

जब मैंने gh-13329 को ठीक किया गया था, तब मैंने प्रयोज्य कार्यों को पूरा किया। हमने निर्णय लिया- # 13588 1.17 की रिलीज के बाद तक इंतजार कर सकता है। यह दस्तावेज़ीकरण सुधार और arange gh-12379 अभी भी 1.17 में शामिल करने के लिए खुला छोड़ देता है।

# 13728 भी है - डिस्पैचर में histogram[2d]d लिए एक बग

यह दस्तावेज़ीकरण सुधार और ahh-12379 को अभी भी 1.17 में शामिल करने के लिए खुला छोड़ देता है।

प्रलेखन के लिए एक मुद्दा गायब था, इसलिए मैंने gh-13844 खोला। मुझे लगता है कि डॉक्स arange खुले मुद्दे की तुलना में बहुत अधिक महत्वपूर्ण हैं।

@shoyer क्या हम इसे बंद कर सकते हैं?