Numpy: बतख सरणी बलात्कार का समर्थन

प्रस्तावित कार्यान्वयन कुछ इस तरह दिखेगा:

import numpy as np

# hypothetical np.duckarray() function
def duckarray(array_like):
  if hasattr(array_like, '__duckarray__'):
    # return an object that can be substituted for np.ndarray
    return array_like.__duckarray__()
  return np.asarray(array_like)

उदाहरण का उपयोग:

class SparseArray:
  def __duckarray__(self):
    return self
  def __array__(self):
    raise TypeError

np.duckarray(SparseArray())  # returns a SparseArray object
np.array(SparseArray())  # raises TypeError

यहाँ मैंने प्लेसहोल्डर्स के रूप में np.duckarray और __duckarray__ किया है, लेकिन हम शायद इन नामों के लिए बेहतर कर सकते हैं। एनईपी 22 से शब्दावली देखें:

"डक एरे" अब के लिए प्लेसहोल्डर के रूप में ठीक काम करता है, लेकिन यह बहुत सुंदर है और नए उपयोगकर्ताओं को भ्रमित कर सकता है, इसलिए हम वास्तविक एपीआई कार्यों के लिए कुछ और चुनना चाहते हैं। दुर्भाग्य से, "एरे-लाइक" पहले से ही "कुछ भी है कि एक सरणी में coerced किया जा सकता है" की अवधारणा के लिए लिया जाता है (उदाहरण सूची वस्तुओं सहित), और "anyarray" पहले से ही "कुछ है जो ndarray के कार्यान्वयन साझा करता है, की अवधारणा के लिए लिया जाता है, लेकिन अलग शब्दार्थ "है, जो एक बतख सरणी के विपरीत है (उदाहरण के लिए, np.matrix एक" anyarray "है, लेकिन" बतख सरणी "नहीं है)। यह एक क्लासिक बाइक-शेड है इसलिए अब तक हम केवल "बतख सरणी" का उपयोग कर रहे हैं। हालांकि कुछ संभावित विकल्प में शामिल हैं: सरणी, छद्मश्रेय, नाममात्र, ersatzarray, arraymimic, ...

कुछ अन्य नाम विचार: np.array_compatible() , np.array_api() ....

np.array_compatible काम कर सकता है, हालांकि मुझे यकीन नहीं है कि मुझे यह duckarray से बेहतर है। np.array_api मुझे पसंद नहीं है, गलत विचार imho देता है।

चूंकि लंबे समय के बाद हम एक बेहतर नाम के साथ नहीं आए हैं, शायद हमें "बतख-सरणी" नाम को आशीर्वाद देना चाहिए ......

मुझे संगत शब्द पसंद है, शायद हम उस रेखा के साथ-साथ as_compatible_array (कुछ अर्थ यह है कि सभी संगत वस्तुएं सरणियाँ हैं) के साथ भिन्नता के बारे में सोच सकते हैं। as शायद कष्टप्रद है (आंशिक रूप से क्योंकि सभी as कार्यों का कोई स्थान नहीं है)। "बतख" पुस्तकालयों में अच्छा लगता है, लेकिन मुझे लगता है कि यादृच्छिक लोगों के लिए इसे देखना थोड़ा अजीब है। इसलिए मुझे लगता है कि मैं "बत्तख" को नापसंद करता हूं अगर और केवल अगर हम डाउनस्ट्रीम उपयोगकर्ताओं को इसका उपयोग करना चाहते हैं (यानी तब भी जब मैं खुद के लिए एक छोटा उपकरण लिखना शुरू करूं / एक छोटी प्रयोगशाला)।

शायद quack_array :)

विषय पर थोड़ा विस्तार करने के लिए, एक और मामला है जो np.duckarray साथ कवर नहीं किया गया है, जो कि मौजूदा प्रकार के आधार पर एक प्रकार के साथ नए सरणियों का निर्माण है, जो np.empty_like जैसे कार्यों के समान है

>>> import numpy as np, cupy as cp
>>> a  = cp.array([1, 2])
>>> b = np.ones_like(a)
>>> type(b)
<class 'cupy.core.core.ndarray'>

दूसरी ओर, यदि हमारे पास array_like है, तो हम NumPy के API के माध्यम से एक CuPy सरणी बनाना चाहेंगे, यह संभव नहीं है। मुझे लगता है कि ऐसा कुछ करना उपयोगी होगा:

import numpy as np, cupy as cp
a  = cp.array([1, 2])
b = [1, 2]
c = np.asarray(b, like=a)

इस पर कोई विचार / सुझाव?

शायद np.copy_like? हम ध्यान से परिभाषित करना चाहेंगे कि कौन से गुण हैं
(जैसे, dtype या नहीं सहित) को दूसरे ऐरे से कॉपी किया जाता है।

सोम, जुलाई 1, 2019 को 5:40 पूर्वाह्न पीटर एंड्रियास एन्टशेव <
सूचनाएं@github.com> ने लिखा:

विषय पर थोड़ा विस्तार करने के लिए, एक अन्य मामला है जो कवर नहीं किया गया है
np.duckarray के साथ, जो एक प्रकार के साथ नए सरणियों का निर्माण है
मौजूदा प्रकार पर, np.empty_like जैसे कार्यों के समान।
वर्तमान में हम इस तरह की चीजें कर सकते हैं:

एनपीपी के रूप में सुन्न आयात करें, कप के रूप में सीपीपी >>> a = cp.array ([1, 2]) >>> b = np.ones_like (a) >>> प्रकार (b)

दूसरी ओर, अगर हमारे पास array_like है जो हम बनाना चाहते हैं
NumPy के एपीआई के माध्यम से एक CuPy सरणी, यह संभव नहीं है। मुझे लगता है कि यह होगा
कुछ इस तरह से मददगार:

एनपीपी के रूप में सुन्न आयात, सीपी के रूप में कपाली
a = cp.array ([1, 2])
बी = [१, २]
c = np.asarray (b, like = a)

इस पर कोई विचार / सुझाव?

-
आप इसे प्राप्त कर रहे हैं क्योंकि आपका उल्लेख किया गया था।
इस ईमेल का उत्तर सीधे दें, इसे GitHub पर देखें
https://github.com/numpy/numpy/issues/13831?email_source=notifications&email_token=AAJJFVRCWHHHHXMHHMMH3M5H5WHYH3H8H8H3H3H8H8H8&hl=hi&hl=hi/http://shith_nok-hut-h&hl=hi&hl=hi&hl=hi
या धागा म्यूट करें
https://github.com/notifications/unsubscribe-auth/AAJJFVRSYHUYHMPWQTW2NLLP5H3LRANCNFSM4H3HQWAA
।

np.copy_like भी अच्छा लगता है। मैं मानता हूं, हमें सबसे अधिक संभावना होनी चाहिए कि dtype जैसी चीजों को नियंत्रित करें।

शुरुआत के सवाल के लिए क्षमा करें, लेकिन np.copy_like तरह कुछ NEP-22 में संशोधन होना चाहिए, क्या इसे मेलिंग सूची में चर्चा की जानी चाहिए, या इसके लिए सबसे उपयुक्त दृष्टिकोण क्या होगा?

हमारे पास वास्तव में इस बारे में कड़े नियम नहीं हैं, लेकिन मैं np.copy_like और np.duckarray (या जो भी हम इसे कहते हैं) को एक साथ एक नए NEP में जबरदस्ती / बतख सरणियाँ बनाने की दिशा में झुक जाएगा, एक यह NEP 22 की तरह "सूचनात्मक" के बजाय NEP 18 की तरह ही प्रिस्क्रिप्टिव है। इसे लंबे होने की आवश्यकता नहीं है, अधिकांश प्रेरणा NEP 18/22 को संदर्भित करने से पहले से ही स्पष्ट है।

np.copy_like() बारे में एक नोट: यह निश्चित रूप से __array_function__ (या कुछ और) के साथ प्रेषण करना चाहिए, इसलिए np.copy_like(sparse_array, like=dask_array) जैसे ऑपरेशनों को या तो सरणी प्रकार पर परिभाषित किया जा सकता है।

महान, जानकारी के लिए धन्यवाद, और मैं आपके प्रेषण प्रस्ताव से सहमत हूं। मैं दोनों np.duckarray और np.copy_like के कार्यान्वयन के लिए एक NEP पर काम करूंगा और उसके लिए इस सप्ताह PR एक मसौदा प्रस्तुत करूंगा।

बहुत बढ़िया, धन्यवाद पीटर!

सोम, जुलाई 1, 2019 को सुबह 9:29 बजे पीटर एंड्रियास एन्टशेव <
सूचनाएं@github.com> ने लिखा:

महान, जानकारी के लिए धन्यवाद, और मैं आपके प्रेषण प्रस्ताव से सहमत हूं। मैं
np.duckarray और के कार्यान्वयन के लिए एक NEP पर काम करेगा
np.copy_like और उसके लिए इस सप्ताह एक मसौदा PR सबमिट करें।

-
आप इसे प्राप्त कर रहे हैं क्योंकि आपका उल्लेख किया गया था।
इस ईमेल का उत्तर सीधे दें, इसे GitHub पर देखें
https://github.com/numpy/numpy/issues/13831?email_source=notifications&email_token=AAJJFVW2YUBNUCJUCKZJ6KJJBB5BH5HNNMMHHHWWHYHOHOHOHOHOHOHOHOHOHOHOH3H6H3H3H3&hl=hi&hl=hi
या धागा म्यूट करें
https://github.com/notifications/unsubscribe-auth/AAJJFVR2KTPAZ4JPWDYYMFLP5IWHNANCNFSM4H3HQWAA
।

मेरी खुशी, और इस काम के साथ विचारों और समर्थन के लिए बहुत बहुत धन्यवाद!

array_like और copy_like फ़ंक्शंस मुख्य नामस्थान में मेरे विचार से थोड़ा अजीब होगा, क्योंकि हम एक डिफ़ॉल्ट कार्यान्वयन नहीं कर सकते हैं (कम से कम एक ऐसा नहीं है जो सही सोच के लिए करेगा। cupy / dask / विरल / etc), सही है? ओवरराइड होने पर वे केवल उपयोगी होते हैं। या क्या मैं यहां मनमाने ढंग से गैर-खस्ताहाल सरणी वस्तुओं को बनाने का एक तरीका याद कर रहा हूं?

यह सच है, ये केवल तभी उपयोगी होंगे जब आप बतख टाइपिंग का समर्थन करना चाहते हैं। लेकिन निश्चित रूप से np.duckarray और np.copy_like काम करेंगे भले ही तर्क केवल NumPy सरणियाँ हों - वे np.array / np.copy ।

सभी सरणी कार्यान्वयन में copy विधि सही है? copy_like बजाय इसका उपयोग करना चाहिए, इसलिए नया फ़ंक्शन क्यों जोड़ें?

array_like मुझे इसकी आवश्यकता दिखाई दे सकती है, लेकिन हम चर्चा कर सकते हैं कि इसे कहां रखा जाए।

np.duckarray मेरे लिए मायने रखता है।

मैं np.copy_like और np.duckarray (या जिसे हम इसे कॉल करते हैं) को एक साथ एक नया NEP में बलात्कार / बत्तख सरण बनाने पर एक साथ होगा, जो NEP 22 जैसे "सूचनात्मक" जैसे NEP 18 की तरह प्रिस्क्रिप्टिव है।

+1

array_like मैं इसकी आवश्यकता देख सकता हूं, लेकिन हम चर्चा कर सकते हैं कि इसे कहां रखा जाए।

यह वास्तव में ऐसा मामला है जिसे मैं np.copy_like जैसी किसी चीज़ से संबोधित करना चाहूंगा। मैंने परीक्षण नहीं किया है, लेकिन शायद np.copy पहले से ही सही ढंग से डिस्पैच करता है यदि सरणी नॉन-नम्पी है।

बस स्पष्ट होने के लिए, क्या आप किसी फ़ंक्शन np.array_like भी उल्लेख कर रहे हैं? मैंने जानबूझकर ऐसे नाम से परहेज किया क्योंकि मुझे लगा कि यह सभी मौजूदा संदर्भों में array_like लिए भ्रमित हो सकता है। हालाँकि, मुझे अब एहसास हुआ कि np.copy_like एक आवश्यक प्रति हो सकती है, और मुझे लगता है कि np.asarray समान व्यवहार करना अच्छा होगा, जहाँ प्रतिलिपि केवल तभी होती है जब वह पहले से ही एक NumPy न हो। सरणी। यहां चर्चा किए गए मामले में, सबसे अच्छा यह होगा कि प्रतिलिपि केवल तभी बनाई जाए जब a b जैसे कॉल np.copy_like(a, like=b) ।

मैंने परीक्षण नहीं किया है, लेकिन संभवतः np.copy पहले ही सही ढंग से भेज दिया जाता है यदि सरणी नॉन-न्यूमी है।

इसे __array_function__ का समर्थन करने के लिए सजाया जाना चाहिए।

बस स्पष्ट होने के लिए, क्या आप किसी फ़ंक्शन np.array_like भी उल्लेख कर रहे हैं? मैंने जानबूझकर इस तरह के नाम से परहेज किया क्योंकि मुझे लगा कि यह array_like-arrays के सभी मौजूदा संदर्भों को भ्रमित कर सकता है।

हाँ। और हाँ सहमत हूँ यह भ्रामक हो सकता है।

हालाँकि, मुझे अब एहसास हुआ कि np.copy_like एक आवश्यक प्रति हो सकती है,

हाँ वह नाम एक डेटा प्रति है।

एक आवश्यक प्रति लगा सकता है, और मुझे लगता है कि np.asarray समान व्यवहार करना अच्छा होगा

मैंने सोचा था कि यह np.duckarray ।

मुझे लगता है कि ऊपर पीटर का उदाहरण इसे स्पष्ट करने में मदद कर सकता है। नीचे साधा गया और सादगी के लिए np.copy_like में डूबा।

import numpy as np, cupy as cp
a  = cp.array([1, 2])
b = [1, 2]
c = np.copy_like(b, like=a)

मैंने सोचा था कि यह np.duckarray था।

वास्तव में, np.duckarray मूल रूप से कुछ नहीं करेंगे और केवल सरणी को स्वयं वापस करेंगे (यदि ओवरराइड किया गया है), अन्यथा np.asarray (एक NumPy सरणी के लिए अग्रणी) वापस करें। उदाहरण के लिए, हम पायथन सूची से एक CuPy सरणी नहीं प्राप्त कर सकते हैं। हम अभी भी एक समारोह है कि CuPy के लिए भेजा जा सकता है (या किसी अन्य की जरूरत है like= एक के लिए सरणी) array_like ।

अद्यतन उदाहरण के लिए @jakirkham धन्यवाद।

c = np.copy_like(b, like=a)

तो वह a.__array_function__ माध्यम से CuPy को भेजेगा और यदि वह विशेषता मौजूद नहीं है (तो a=<scipy.sparse matrix> काम नहीं करेगी)? ऐसा महसूस होता है कि हमें इस तरह की चीजों के लिए एक नए नामस्थान या नए अंतर-उपयोगिताओं पैकेज की आवश्यकता है। या तो इसे छोड़ दें और अधिक पूर्ण-भविष्य वाले भविष्य के प्रेषण तंत्र पर छोड़ दें जहां कोई भी सरल कार्य कर सकता है:

with cupy_backend:
   np.array(b)

मुख्य नामस्थान में नए कार्यों का परिचय देना जो __array_function__ की सीमा के आसपास काम करने के लिए NumPy के लिए कोई मतलब नहीं है,

तो वह a.__array_function__ माध्यम से CuPy को भेजेगा और यदि वह विशेषता मौजूद नहीं है (जैसे a=<scipy.sparse matrix> काम नहीं करेगी)?

मैं यह नहीं कहूंगा कि यह आवश्यक रूप से विफल है। हम उदाहरण के लिए, NumPy को डिफॉल्ट कर सकते हैं और चेतावनी दे सकते हैं (या बिल्कुल नहीं बढ़ा सकते)।

ऐसा महसूस होता है कि हमें इस तरह की चीजों के लिए एक नए नामस्थान या नए अंतर-उपयोगिताओं पैकेज की आवश्यकता है। या तो यह है कि यह एक और अधिक पूर्ण-भविष्य के लिए भेजने वाले तंत्र को छोड़ दें

निश्चित रूप से पूर्ण-प्रेषण प्रेषण तंत्र के लिए अच्छा होगा, लेकिन मुझे लगता है कि इसकी जटिलता और पीछे की संगतता के मुद्दों के कारण पहले ऐसा नहीं किया गया था? जब चर्चाएँ हुईं तो मैं आसपास नहीं था, इसलिए सिर्फ अनुमान लगा रहा था।

मुख्य नामस्थान में नए कार्यों का परिचय देना जो __array_function__ की सीमा के आसपास काम करने में सहायता के लिए खुद NumPy के लिए कोई मतलब नहीं है, थोड़ा अस्वस्थ लगता है ...।

मैं निश्चित रूप से आपकी बात देख रहा हूं, लेकिन मुझे यह भी लगता है कि अगर हम कई चीजों को मुख्य नाम स्थान से दूर ले जाते हैं, तो यह उपयोगकर्ताओं को डरा सकता है। शायद मैं गलत हूं और यह सिर्फ एक धारणा है। किसी भी तरह से, मैं उन कार्यों को लागू करने का प्रस्ताव नहीं कर रहा हूं जो NumPy के साथ काम नहीं करेंगे, लेकिन शायद केवल खुद द्वारा NumPy का उपयोग करते समय बिल्कुल आवश्यक नहीं है।

मुख्य नामस्थान में नए कार्यों का परिचय देना जो __array_function__ की सीमा के आसपास काम करने में सहायता के लिए खुद NumPy के लिए कोई मतलब नहीं है, थोड़ा अस्वस्थ लगता है ...।

वास्तव में, इस अर्थ में, np.duckarray मुख्य नामस्थान में नहीं होंगे।

वास्तव में, इस अर्थ में, np.duckarray मुख्य नामस्थान में नहीं होंगे।

मुझे लगता है कि एक और अधिक रक्षात्मक है ( asarray अनुरूप) और यह मूल रूप से जांच करेगा "क्या यह हमारी ndarray जैसी बतख प्रकार की परिभाषा को पूरा करता है"), लेकिन हाँ। यदि हम array_function_dispatch का पर्दाफाश करना चाहते हैं, और हमारे पास np.lib.mixins.NDArrayOperatorsMixin और अधिक मिक्सिंस लिखने पर योजना बनाते हैं, तो संबंधित सभी चीजों के लिए एक समझदार नया सबमॉड्यूल संबंधित अंतर समझ में आ सकता है।

निश्चित रूप से पूर्ण-प्रेषण प्रेषण तंत्र के लिए अच्छा होगा, लेकिन मुझे लगता है कि इसकी जटिलता और पीछे की संगतता के मुद्दों के कारण पहले ऐसा नहीं किया गया था? जब चर्चाएँ हुईं तो मैं आसपास नहीं था, इसलिए सिर्फ अनुमान लगा रहा था।

मुझे लगता है कि कई कारण हैं। __array_function__ उन चीजों के समान है जो हमारे पास पहले से थी, इसलिए इसके बारे में तर्क करना आसान है। यह कम ओवरहेड है। इसे ~ 6 महीने के समय पर डिजाइन और कार्यान्वित किया जा सकता था, और @shoyer ने एक मजबूत मामला बनाया जिसकी हमें आवश्यकता थी। और हमारे पास कोई ठोस विकल्प नहीं था।

सभी चीजों के लिए समझदार नए सबमॉड्यूल से संबंधित अंतर समझ में आ सकता है।

मेरी ओर से कोई वास्तविक आपत्ति नहीं, मुझे लगता है कि कहीं न कहीं इसकी कार्यक्षमता बेहतर है। :)

मुझे लगता है कि कई कारण हैं। __array_function__ हमारे पास पहले से मौजूद चीजों के समान है, इसलिए इसके बारे में तर्क करना आसान है। यह कम ओवरहेड है। इसे ~ 6 महीने के समय पर डिजाइन और कार्यान्वित किया जा सकता था, और @shoyer ने एक मजबूत मामला बनाया जिसकी हमें आवश्यकता थी। और हमारे पास कोई ठोस विकल्प नहीं था।

लेकिन अगर हम मोटे तौर पर __array_function__ का लाभ उठाना चाहते हैं, तो क्या अब हमारे पास np.duckarray और np.copy_like (या जो भी हम इसे कॉल करने का फैसला करेंगे) जैसी चीजों को लागू करने के लिए अन्य विकल्प हैं? मैं सभी विकल्पों के लिए खुला हूं, लेकिन अभी मुझे पूर्ण-सुविधा प्रेषण मार्ग पर जाने के बजाय, कोई भी दिखाई नहीं देता है, जो संभवत: एक लंबा समय लेने वाला है और __array_function__ के दायरे को सीमित करता है।

लेकिन अगर हम मोटे तौर पर __array_function__ का लाभ उठाना चाहते हैं, तो क्या अब हमारे पास np.duckarray और np.copy_like (या जो भी हम इसे कॉल करने का फैसला करेंगे) जैसी चीजों को लागू करने के लिए अन्य विकल्प हैं?

मुझे लगता है कि आपको वास्तव में उपयोगिता सुविधाओं के एक सेट की आवश्यकता है, उपयोग मामलों के कुछ अंश को कवर करने से> 80% उपयोग के मामलों में जाने के लिए। मुझे नहीं लगता कि इसके आसपास कोई रास्ता है। मैं सिर्फ मुख्य नाम स्थान को अव्यवस्थित करना पसंद नहीं करता, इसलिए उन लोगों के लिए एक बेहतर जगह खोजने का प्रस्ताव करता हूं।

मैं सभी विकल्पों के लिए खुला हूं, लेकिन अभी मुझे पूर्ण-सुविधा प्रेषण मार्ग पर जाने के बजाय, कोई भी दिखाई नहीं देता है, जो संभवत: एक लंबा समय लेने वाला है और __array_function__ के दायरे को सीमित करता है।

मेरा मतलब है, हम सिर्फ कुछ स्पष्ट छेद प्लग कर रहे हैं? हम कभी भी "अधिक जटिल मामलों" को कवर नहीं करेंगे। मान लीजिए कि आप np.errstate या np.dtype ओवरराइड करना चाहते हैं, तो यह केवल प्रोटोकॉल-आधारित दृष्टिकोण के साथ नहीं होने वाला है।

विकल्प के रूप में, यार्रे अभी तक वहाँ नहीं है और मुझे अभी तक यकीन नहीं है कि ओवरहेड को नीचे गिरा दिया जाएगा, जो कि scipy.fft बनाने की कोशिश करने वाले हैं https://github.com/Quansight-Labs/uarray-tree/master/unumpy

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

कृपया इस टिप्पणी को विवरण के लिए देखें। यह स्पष्ट नहीं है कि यह संबोधित किया गया है (हालांकि अगर मुझे कुछ याद आया है तो कृपया मुझे सुधारें)।

मुझे लगता है कि पिछले सप्ताह के बदलावों का समाधान है, लेकिन निश्चित नहीं है - चलो एक और धागे के लिए छोड़ दें।

मैं SciPy पर दूसरों के साथ काम करने में दिलचस्पी लेना चाहूंगा और इस समस्या को हल करूँगा।

मैं वहाँ रहूँगा, आपको व्यक्तिगत रूप से मिलने के लिए बहुत अच्छा होगा।

हो सकता है कि np.coerce_like() या np.cast_like() copy_like तुलना में बेहतर नाम हों, ताकि यह स्पष्ट हो कि प्रतियां आवश्यक नहीं हैं। वांछित कार्यक्षमता वास्तव में .cast() पद्धति के समान है, सिवाय इसके कि हम सरणी प्रकारों के साथ-साथ dtypes में कनवर्ट करना चाहते हैं, और यह एक प्रोटोकॉल के बजाय एक फ़ंक्शन होना चाहिए ताकि इसे या तो तर्क द्वारा लागू किया जा सके।

यूरेर के साथ प्रेषण दृष्टिकोण निश्चित रूप से दिलचस्प है। हालांकि मैं अभी भी चिंतित हूं कि हम मेटा-सरणियों (जैसे डस्क, ज़ार्रे, आदि) को कैसे संभालते हैं।

uarray को कई बैकेंड के लिए समर्थन है, इसलिए इस तरह से कुछ काम करना चाहिए

with ua.set_backend(inner_array_backend), ua.set_backend(outer_array_backend):
  s = unumpy.sum(meta_array)

यह मेटा-एरे कॉल ua.skip_backend इसके कार्यान्वयन के अंदर होने से किया जा सकता है, या यदि मेटा-एरे का बैकेंड NotImplemented प्रकार के बेमेल पर देता है।

cc: @hameerabbasi

मैं इस पर विस्तार करूंगा: एक सामान्य नियम के रूप में, dask.array , da साथ कुछ भी Skip_backend के बिना लिखा जाएगा। NumPy के साथ कुछ भी एक Skip_backend की आवश्यकता होगी।

या da आप हमेशा प्रेषण छोड़ सकते हैं और अपने स्वयं के कार्यान्वयन को सीधे कॉल कर सकते हैं और हर जगह skip_backend(dask.array) ।

प्रेषण कार्यों के लिए, जिसमें एक सरणी संलग्न नहीं है, जैसे ones , cast , आप बस एक बैकएंड सेट करेंगे और किया जाएगा। np.errstate और np.dtype । np.ufunc में unumpy np.ufunc को कवर करने वाला एक उदाहरण है।

मूल मुद्दे के लिए, uarray __ua_convert__ प्रोटोकॉल प्रदान करता है, जो ठीक यही करता है। एक विकल्प बैकएंड के लिए asarray सीधे ओवरराइड करना होगा।

uarray , @rgommers , @ peterbell10 , @hameerabbasi पर सिर के लिए धन्यवाद।

लेकिन जैसा कि मैंने देखा, आपने _must_ की गणना शुरू करने से पहले उचित बैकएंड सेट किया, क्या यह सही है? __array_function__ के फायदों में से एक यह है कि पुस्तकालय अन्य पुस्तकालयों के पूरी तरह से अज्ञेय हो सकते हैं, जैसे कि Dask को CuPy के अस्तित्व के बारे में जानने की आवश्यकता नहीं है, उदाहरण के लिए।

@pentschev यह हाल ही में तब तक था, जब हमने एक बैकएंड को "रजिस्टर" करने की क्षमता जोड़ी थी, लेकिन हम केवल NumPy (या एक संदर्भ कार्यान्वयन) की सलाह देते हैं। तब Dask का उपयोग करने वाले उपयोगकर्ताओं को केवल एक ही set_backend की आवश्यकता होगी।

समझे यह, मुझे लगता है यह है कि क्या में उल्लेख किया @rgommers है https://github.com/numpy/numpy/issues/13831#issuecomment -+५०,७४,३२,३११, में बैकेंड की ओर इशारा करते https://github.com/Quansight-Labs/uarray / पेड़ / मास्टर / unumpy।

इतने सारे सवालों के लिए क्षमा करें, लेकिन क्या होगा यदि कुछ काल्पनिक अनुप्रयोग विभिन्न बैकएंड पर निर्भर करता है, उदाहरण के लिए, NumPy और Sparse दोनों, जहां उपयोगकर्ता इनपुट के आधार पर, शायद सब कुछ NumPy-only, Sparse-only या दोनों का मिश्रण होगा। @ peterbell10 ने बताया कि कई बैकएंड का समर्थन किया गया है https://github.com/numpy/numpy/issues/13831#issuecomment -507458331, लेकिन बैकएंड का चयन स्वचालित किया जा सकता है या तीन मामलों को अलग से संभालने की आवश्यकता होगी?

इसलिए, इस मामले के लिए, आप आदर्श रूप से NumPy को पंजीकृत करेंगे, Sparse के लिए एक संदर्भ प्रबंधक का उपयोग करें, और उपयुक्त होने पर NotImplemented को Sparse से लौटाएं, जो NumPy में कुछ गिरावट दर्ज करेगा।

SciPy @rgommers , @danielballan पर , और खुद इस मुद्दे पर बात की। हमने यह निष्कर्ष निकाला कि duckarray (उस नाम का उपयोग करके) के साथ आगे बढ़ना मूल्यवान होगा। उस ने कहा, यह लग रहा था कि यह 1.18 के लिए स्लेट किया जाएगा। हालांकि अगर मैंने चीजों को गलत समझा तो कृपया मुझे सही करें। यह देखते हुए, एक पीआर शुरू करने के लिए ठीक हो जाएगा?

हमने यह निष्कर्ष निकाला कि duckarray (उस नाम का उपयोग करके) के साथ आगे बढ़ना मूल्यवान होगा। उस ने कहा, यह लग रहा था कि यह 1.18 के लिए स्लेट किया जाएगा। हालांकि अगर मैंने चीजों को गलत समझा तो कृपया मुझे सही करें। यह देखते हुए, एक पीआर शुरू करने के लिए ठीक हो जाएगा?

यह सब मेरे लिए बहुत अच्छा लगता है, लेकिन सटीक प्रस्ताव के साथ संक्षिप्त एनईपी वर्तनी के साथ शुरुआत करना अच्छा होगा। Https://github.com/numpy/numpy/issues/13831#issuecomment -507334210 देखें

यकीन है कि समझ में आता है। 🙂

जैसा कि पहले लाया गया है कि नकल बिंदु के लिए, मैं उत्सुक हूँ अगर यह मौजूदा तंत्र के माध्यम से हल नहीं है। विशेष रूप से इन पंक्तियों के बारे में क्या?

a2 = np.empty_like(a1)
a2[...] = a1[...]

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

हमने निष्कर्ष निकाला कि डकार्रे (उस नाम का उपयोग करके) को जोड़ने के लिए आगे बढ़ना मूल्यवान होगा।

यह सब मेरे लिए बहुत अच्छा लगता है, लेकिन सटीक प्रस्ताव के साथ संक्षिप्त एनईपी वर्तनी के साथ शुरुआत करना अच्छा होगा। # 13831 देखें

मैंने पहले ही लिखना शुरू कर दिया है, हालांकि अभी तक इसे पूरा नहीं कर पाया है (क्षमा करें मेरी खराब योजना https://github.com/numpy/numpy/issues/13831#issuecomment-507336302)।

जैसा कि पहले लाया गया है कि नकल बिंदु के लिए, मैं उत्सुक हूँ अगर यह मौजूदा तंत्र के माध्यम से हल नहीं है। विशेष रूप से इन पंक्तियों के बारे में क्या?

a2 = np.empty_like(a1)
a2[...] = a1[...]

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

आप ऐसा कर सकते हैं, लेकिन इसके लिए विशेष नकल तर्क की आवश्यकता हो सकती है (जैसे CuPy https://github.com/cupy/cupy/pull/2079)।

इस प्रकार अतिरिक्त कोड को आवश्यक होने से बचाने के लिए, एक कॉपी फ़ंक्शन सबसे अच्छा हो सकता है।

दूसरी ओर, यह asarray बदले की तरह होगा। इसलिए मैं सोच रहा था कि क्या copy_like नए फ़ंक्शन के बजाय, हम इसके बजाय NEP-18 द्वारा सुझाए गए विचार पर फिर से

इन्हें अपने स्वयं के प्रोटोकॉल की आवश्यकता होगी:
...
व्यूह और असारे, क्योंकि वे स्पष्ट रूप से वास्तविक संख्या के लिए जबरदस्ती करने के लिए अभिप्रेत हैं। वस्तु वस्तु।

अगर कोई मौका है तो हम उस पर फिर से विचार करना चाहेंगे, शायद एक नया सूत्र शुरू करना बेहतर होगा। कोई विचार, सुझाव, आपत्ति?

बस ऊपर मेरी टिप्पणी पर स्पष्ट होने के लिए, मैं खुद नहीं जानता कि क्या एक नया प्रोटोकॉल एक महान विचार है (शायद कई बोझिल विवरण जो मुझे शामिल नहीं हैं), वास्तव में बस सोच रहा था कि क्या यह एक विचार है जिस पर हमें फिर से विचार करना चाहिए और चर्चा करनी चाहिए ।

विज्ञान सभा में देव बैठक और स्प्रिंट से सर्वसम्मति थी: चलो 1.17.0 दरवाजे से बाहर निकलते हैं और कोई भी अगला कदम उठाने से पहले इसके साथ कुछ वास्तविक दुनिया का अनुभव प्राप्त करते हैं।

वास्तव में बस सोच रहा था कि यह एक विचार है जिस पर हमें फिर से विचार करना चाहिए और चर्चा करनी चाहिए।

शायद हाँ, लेकिन कुछ महीनों में।

शायद हाँ, लेकिन कुछ महीनों में।

ठीक है, जवाब के लिए धन्यवाद!

जैसा कि पहले लाया गया है कि नकल बिंदु के लिए, मैं उत्सुक हूँ अगर यह मौजूदा तंत्र के माध्यम से हल नहीं है। विशेष रूप से इन पंक्तियों के बारे में क्या?

a2 = np.empty_like(a1)
a2[...] = a1[...]

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

इसके साथ मेरा मुख्य मुद्दा यह है कि यह बतख सरणियों के लिए काम नहीं करेगा जो अपरिवर्तनीय हैं, जो बहुत असामान्य नहीं है। इसके अलावा, एक सरणी आवंटित करने और फिर इसे भरने की अतिरिक्त लागत के लिए NumPy के लिए लगभग शून्य हो सकता है, लेकिन मुझे यकीन नहीं है कि सभी बतख सरणियों के लिए यह सच है।

जैसा कि पहले लाया गया है कि नकल बिंदु के लिए, मैं उत्सुक हूँ अगर यह मौजूदा तंत्र के माध्यम से हल नहीं है। विशेष रूप से इन पंक्तियों के बारे में क्या?

a2 = np.empty_like(a1)
a2[...] = a1[...]

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

आप ऐसा कर सकते हैं, लेकिन इसके लिए विशेष प्रतिलिपि तर्क (जैसे CuPy cupy / cupy # 2079 ) की आवश्यकता हो सकती है।

इस प्रकार अतिरिक्त कोड को आवश्यक होने से बचाने के लिए, एक कॉपी फ़ंक्शन सबसे अच्छा हो सकता है।

दूसरी ओर, यह asarray बदले की तरह होगा। इसलिए मैं सोच रहा था कि क्या copy_like नए फ़ंक्शन के बजाय, हम इसके बजाय NEP-18 द्वारा सुझाए गए विचार पर फिर से

इन्हें अपने स्वयं के प्रोटोकॉल की आवश्यकता होगी:
...
व्यूह और असारे, क्योंकि वे स्पष्ट रूप से वास्तविक संख्या के लिए जबरदस्ती करने के लिए अभिप्रेत हैं। वस्तु वस्तु।

अगर कोई मौका है तो हम उस पर फिर से विचार करना चाहेंगे, शायद एक नया सूत्र शुरू करना बेहतर होगा। कोई विचार, सुझाव, आपत्ति?

मुझे नहीं लगता कि एक नए प्रोटोकॉल के साथ np.array या np.asarray का व्यवहार बदलना एक अच्छा विचार है। उनका स्थापित अर्थ NumPy सरणियों में डालना है, जो कि मूल रूप से हमें np.duckarray

उस ने कहा, हम like तर्क को duckarray जोड़ने पर विचार कर सकते हैं। उपरोक्त सरलीकृत प्रस्ताव से प्रोटोकॉल बदलने की आवश्यकता होगी - शायद __array_function__ जैसे समर्पित प्रोटोकॉल के बजाय __duckarray__ ? मैं वास्तव में इस के माध्यम से नहीं सोचा है।

जैसा कि पहले लाया गया है कि नकल बिंदु के लिए, मैं उत्सुक हूँ अगर यह मौजूदा तंत्र के माध्यम से हल नहीं है। विशेष रूप से इन पंक्तियों के बारे में क्या?

a2 = np.empty_like(a1)
a2[...] = a1[...]

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

इसके साथ मेरा मुख्य मुद्दा यह है कि यह बतख सरणियों के लिए काम नहीं करेगा जो अपरिवर्तनीय हैं, जो बहुत असामान्य नहीं है। इसके अलावा, एक सरणी आवंटित करने और फिर इसे भरने की अतिरिक्त लागत के लिए NumPy के लिए लगभग शून्य हो सकता है, लेकिन मुझे यकीन नहीं है कि सभी बतख सरणियों के लिए यह सच है।

सही है। वास्तव में हम पहले से ही चीजों को सरल बना सकते हैं। उदाहरण के लिए यह आज CuPy और Sparse के साथ काम करता है।

a2 = np.copy(a1)

सही है। वास्तव में हम पहले से ही चीजों को सरल बना सकते हैं। उदाहरण के लिए यह आज CuPy और Sparse के साथ काम करता है।

a2 = np.copy(a1)

हां, लेकिन हम यह भी चाहते हैं कि "इस बतख-सरणी को इस अन्य बतख-सरणी के प्रकार में कॉपी करें"

मुझे नहीं लगता कि एक नए प्रोटोकॉल के साथ np.array या np.asarray के व्यवहार को बदलना एक अच्छा विचार है। उनका स्थापित अर्थ NumPy सरणियों में डालना है, जो कि मूल रूप से हमें np.duckarray

मैं इसके बारे में भी अनिश्चित हूँ, और मैं इस प्रश्न को उठाने के लिए अनिच्छुक था, यही कारण है कि मैं आज तक नहीं था।

उस ने कहा, हम डकारे की तरह एक तर्क जोड़ने पर विचार कर सकते हैं। ऊपर दिए गए सरलीकृत प्रस्ताव से प्रोटोकॉल बदलने की आवश्यकता होगी - शायद __duckarray__ जैसे समर्पित प्रोटोकॉल के बजाय __array_function__ का उपयोग करें? मैं वास्तव में इस के माध्यम से नहीं सोचा है।

मुझे नहीं पता कि उसके साथ कोई जटिलता होगी या नहीं, हमें शायद कुछ सावधानियों की आवश्यकता है, लेकिन मुझे यह विचार पसंद है। यह विभिन्न स्तरों में निरर्थक प्रतीत होगा, लेकिन शायद मौजूदा पैटर्न का पालन करने के बजाय, एक like पैरामीटर जोड़ने के बजाय हम duckarray और duckarray_like ?

हां, लेकिन हम यह भी चाहते हैं कि "इस बतख-सरणी को इस अन्य बतख-सरणी के प्रकार में कॉपी करें"

np.copyto आसपास इस के बारे में क्या?

np.copyto आसपास इस के बारे में क्या?

अगर मैं गलत हूं तो मुझे सुधारने के लिए स्वतंत्र महसूस करें, लेकिन मैं मान रहा हूं कि आप कुछ इस तरह हैं:

np.copyto(cupy_array, numpy_array)

यह काम कर सकता है, यह मानते हुए कि NumPy वर्तमान व्यवहार को बदलने के लिए तैयार है, उदाहरण के लिए, asarray अर्थ है गंतव्य एक NumPy सरणी है, क्या copyto समान धारणा बनाते हैं?

np.copyto पहले से ही __array_function__ साथ भेजने का समर्थन कर रहा है, लेकिन यह लगभग इसके बराबर है:

def copyto(dst, src):
    dst[...] = src

हम इसके समकक्ष चाहते हैं:

def copylike(src, like):
    dst = np.empty_like(like)
    dst[...] = src
    return dst

np.copyto पहले से ही __array_function__ साथ भेजने का समर्थन कर रहा है, लेकिन यह लगभग इसके बराबर है:

def copyto(dst, src):
    dst[...] = src

हम इसके समकक्ष चाहते हैं:

def copylike(src, like):
    dst = np.empty_like(like)
    dst[...] = src
    return dst

सही, यही हम चाहते हैं। copyto प्रेषण और काम करता है यदि स्रोत और गंतव्य एक ही प्रकार के हैं, तो हमें कुछ ऐसा चाहिए जो गंतव्य सरणी के पुस्तकालय में भेजने की अनुमति देता है।

खैर copyto अभी भी समझ में आ सकता है कि हम इसके बारे में कैसे सोचते हैं। उदाहरण के लिए निम्न उपयोग के मामले को लें।

np.copyto(cp.ndarray, np.random.random((3,)))

जैसा कि हमने चर्चा की है, डेटा को आवंटित और कॉपी करने जैसे कुछ में अनुवाद कर सकता है। यदि हम इस मामले में dst ( cp.ndarray ) के आसपास भेजते हैं, तो अपरिवर्तनीय सरणियों वाले पुस्तकालय इसे उपयुक्त तरीके से भी लागू कर सकते हैं। यह हमें एक नया API जोड़ने से भी बचाता है (जो कि NumPy केवल प्रदान करता है, लेकिन उपयोग नहीं करता है), जो एक चिंता का विषय था।

बस एक और विचार करने के लिए, जो मुझे हाल ही में हुआ था, यह सोचकर चिंता हो रही है कि ये एपीआई अन्य पुस्तकालयों (उदाहरण के लिए कैसे Dask और Xarray बातचीत) के बीच बहाव का मतलब होगा।