Numpy: बग: numpy.percentile आउटपुट सॉर्ट नहीं किया गया है

आप इसे छाँटने की अपेक्षा क्यों करेंगे? Percentile एलिमेंटिव है - आउटपुट इनपुट के क्रम में हैं।

नमस्ते !
दरअसल, प्रतिशतक elmenet- वार है - जब q पर विचार करते हैं, जो हमारे मामले में है
np.arange(0, 1, 0.01) * 100 ।
मुझे उम्मीद है कि आउटपुट को सॉर्ट किया जाएगा क्योंकि q सॉर्ट किया गया है।

एक एकल ULP के भीतर कुछ संख्यात्मक त्रुटियां हैं, जो एक ही आउटपुट मान के साथ अलग-अलग इनपुट के लिए भिन्न होती हैं। मुझे संदेह है कि इस बारे में कुछ किया जाना है।

थोड़ा कम असफल मामला:

In [40]: np.percentile(np.array([0, 1, 1, 2, 2, 3, 3 , 4, 5, 5, 1, 1, 9, 9 ,9, 8, 8, 7]) * 0.1, [89, 90, 95, 96, 98, 99])
Out[40]: array([0.9, 0.9, 0.9, 0.9, 0.9, 0.9])

In [41]: np.diff(_)
Out[41]:
array([-1.11022302e-16,  2.22044605e-16, -1.11022302e-16,  1.11022302e-16,
       -1.11022302e-16])

यहाँ अंतर के माध्यम से गैर-सॉर्ट-नेस दिखा रहा है।

मुझे लगता है कि शायद इस बारे में हम कुछ कर सकते हैं। मुझे लगता है कि यह इन पंक्तियों की स्थिरता के लिए नीचे आता है, जो एक lerp संचालन (अनिवार्य रूप से add(v_below*weights_below, v_above*weights_above) ) करते हैं:

https://github.com/numpy/numpy/blob/b9fa88eec62e34e90668940809696bb2450830d9a/numpy/lib/function_base.py/L3907 -L3908

https://github.com/numpy/numpy/blob/b9fa88eec62e34e90668940809696bb2450830d9a/numpy/lib/function_base.py/L3928 -L3929

https://github.com/numpy/numpy/blob/b9fa88eec62e34e90668940809696bb2450830d9a/numpy/lib/function_base.py/L3939 -L3942

ट्रेडऑफ़ का एक गुच्छा बनाया जा सकता है जब रैखिक रूप से फ़्लोटिंग पॉइंट मानों को प्रक्षेपित किया जाता है, लेकिन मुझे संदेह है कि यहां "सही" विकल्प है, और हमने अभी इसे नहीं बनाया है।

कुछ और पृष्ठभूमि यहाँ: https://math.stackexchange.com/questions/907327/accurate-floating-point-linear-interpolation

हाँ, मैं सहमत हूँ, +1 परिचालन को पुनर्गठित करने पर ताकि यह कड़ाई से मोनोटोनिक (संख्यात्मक रूप से) हो। अच्छा होगा यदि यह भी बदतर नहीं है, या कम से कम लगभग समान सटीक बुद्धिमान है। मुझे यकीन है कि हमें वास्तव में यहां कुछ अतिरिक्त संचालन / गति के बारे में चिंता करने की आवश्यकता नहीं है।

EDIT: पहले अच्छे अंक के रूप में चिह्नित। लेकिन उसके बाद, यह शायद अजगर कोड के भीतर एक काफी सीधे आगे पुनर्गठन है।

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

@ ngonzo95 इसे प्राप्त करने के लिए प्रक्षेप के अंकगणित को अलग-अलग तरीके से वर्तनी करने का एक तरीका होना चाहिए, अर्थात गणना के लिए उपयोग किए जाने वाले सूत्र को बदलें / पुनर्व्यवस्थित करें (ताकि यह गणितीय रूप से समान हो, लेकिन संख्यात्मक रूप से गारंटी देता है। कोई टुकड़ा गणना आवश्यक नहीं होनी चाहिए।

कोई टुकड़ा गणना आवश्यक नहीं होनी चाहिए।

यह निर्भर करता है कि lerp पर आपकी आवश्यकताएं क्या हैं। कुछ जिनकी हम परवाह कर सकते हैं या नहीं कर सकते हैं:

• मोनोटोनिक ( (lerp(a, b, t1) - lerp(a, b, t0)) * (b - a) * (t1 - t0) >= 0 )
• बाउंडेड ( a <= lerp(a, b, t) <= b )
• सममित ( lerp(a, b, t) == lerp(b, a, 1-t) )

( 0 <= t <= 1 )

ओह ठीक है, मुझे उम्मीद नहीं थी कि टुकड़ा-टुकड़ा आवश्यक होगा, लेकिन मुझे इस बारे में अच्छी तरह से पता नहीं है कि मुझे कितना अच्छा लगता है।

इसे और अधिक देखने पर मुझे पता चला कि फ़ंक्शन a + (ba) * t में दोनों मोनोटोनिक (ऊपर उल्लिखित परिभाषा) और सुसंगत (lerp (a, t) = a) होने का गुण है। मेरा मानना ​​है कि यह कार्य आवश्यकताओं के लिए पर्याप्त होना चाहिए। ऐसा लगता है कि इस समारोह के मुख्य ड्रा बैक में से एक यह है कि lerp (ए, बी, 1)! = बी। हालाँकि मुझे लगता है कि जिस तरह से हम वजन की गणना कर रहे हैं वह यह सुनिश्चित करता है कि 0 <= t <1।

ऐसा लगता है कि इस समारोह के मुख्य ड्रा बैक में से एक यह है कि lerp (ए, बी, 1)! = बी। हालाँकि मुझे लगता है कि जिस तरह से हम वजन की गणना कर रहे हैं वह यह सुनिश्चित करता है कि 0 <= t <1।

ध्यान दें कि दुर्भाग्य से lerp(a, b. 1-eps) > b) उस सूत्रीकरण के साथ संभव है।

खुले स्रोत के लिए नया।
मेरे पहले अच्छे मुद्दे के रूप में इसे हल करना चाहता था। मैं कैसे योगदान कर सकता हूं? क्या कोई पूर्वापेक्षाएँ हैं?

मैं कुछ असफल मामलों को देख रहा था और देखा कि वे सभी एक ही संख्या के बीच रैखिक रूप से प्रक्षेप करते थे

Scikit-learn में, हमने हाल ही में इस अंक में ठोकर खाई: https://github.com/scikit-learn/scikit-learn/issues/15733

चूंकि हम q की सख्ती से वृद्धि की उम्मीद करते हैं, हम सरणी में np.maximum.accumulate पुनः लागू कर सकते हैं। हालाँकि, अगर हम सीधे NumPy में इस मुद्दे को हल कर सकते हैं, तो यह बहुत अच्छा होगा। वहाँ कहीं भी है कि हम एक अच्छा तय करने के लिए खुदाई कर सकते हैं?

@glemaitre : मेरी टिप्पणी में उपर्युक्त सभी प्रासंगिक पंक्तियाँ मेरी टिप्पणी से जुड़ी हैं, https://github.com/numpy/numpy/issues/14685#issuecomment -541467915

अरे, एक अच्छा वैकल्पिक प्रक्षेप के साथ @ eric-wieser द्वारा प्रदान किए गए स्टेक्सएक्सचेंज उत्तरों में से एक को अपडेट किया गया है।
धागे में एकरसता का प्रमाण शामिल है, और प्रस्तावित फिक्स्ड सभी मुद्दों को संबोधित करने के लिए प्रकट होता है।
यदि यह इस मुद्दे के लिए समझ में आता है, तो मैं इसे पहली प्रतिबद्धता के रूप में लागू करने के लिए तैयार रहूंगा, या कोई और इसे आजमा सकता है।

ध्यान दें कि quantile() में lerp के साथ एक और समस्या है: inf मान सही तरीके से हैंडल नहीं किए गए हैं, # 12282 देखें।