Numpy: पुनर्गठन प्रतिशतक विधियाँ

मुझे लगता है कि यह पहले से मौजूद है? विकिपीडिया उदाहरण का उपयोग करना:

>>> np.percentile(15, 20, 35, 40, 50], [5, 30, 40, 50, 100], interpolation='lower')
array([15, 20, 20, 35, 50])

ऐसा नहीं होता। उदाहरण 2 विकिपीडिया पृष्ठ में देखें:

>>> np.percentile([3, 6, 7, 8, 8, 10, 13, 15, 16, 20], [25,50,75,100], interpolation='lower')
array([ 7,  8, 13, 20])

जब यह [7,8,15,20] होना चाहिए

यह इसी तरह तीसरे उदाहरण में विफल रहता है

निकटतम "बहुत पास" जैसा लगता है? हालांकि हमेशा एक और बिंदु होता है कि सीमाएं कैसे काम करती हैं।
संपादित करें: यह है, जहां वास्तव में 0 और 100 माना जाता है, डेटापेट पर या डेटा पॉइंट से पहले? (वह आईआईआरसी है, वैसे भी यहां बहुत कष्टप्रद जटिलताएं हैं)

इसे नहीं पढ़ना चाहते हैं, मुझे लगता है कि अंतर सी पैरामीटर नीचे हो सकता है, इसलिए यदि कोई ऐसा व्यक्ति जानता है जो इसे जोड़ना चाहता है ...।

सच कहूं, मुझे लगता है कि सी पैरामीटर को जोड़ने की संभावना वास्तव में अच्छी होगी। लेकिन ज्यादातर बेहतर प्रलेखन अच्छा होगा, और कोई है जो वास्तव में जानता है कि इस सामान की आवश्यकता है ...।

मुझे नहीं पता कि इसका सी-पैरामीटर से कोई लेना-देना है, हालांकि मैं मानता हूं कि इसे चुनने का विकल्प वांछनीय हो सकता है।

मुझे एक और धागा मिला है जो संयोगवश इस मुद्दे को उठाता है (Dec 2016)। ऐसा लगता है कि मैं जिस एल्गोरिथ्म की तलाश कर रहा हूं (और जिसे विकिपीडिया निकटतम रैंक कहता है) ह्यंडमान-फैन (एचएंडएफ) द्वारा इस सामान्य रूप से उद्धृत

यहाँ यह है कि सुपी द्वारा प्रदान किए गए अन्य विकल्पों के मुकाबले यह कैसे दिखेगा कि सहज रूप से एक समान चीज़ की गणना करने के लिए लगता है (जैसे, 'कम', 'निकटतम'):

मेरे लिए यह पहली नजर में सी पैरामीटर की तरह दिखता है, निकटतम वक्र अधिक फैला हुआ है फिर एच एंड एफ वक्र, जो कि अपेक्षित है क्योंकि संख्यात्मक उपयोग 1 और जाहिरा तौर पर एच एंड एफ 0 का उपयोग करता है।

अगर आप प्रमाण चाहते हैं। 1000 बार दोहराए गए समान मूल्यों के साथ पूरी बात दोहराएं, मेरा अनुमान है कि वे अभिसरण करेंगे।
संपादित करें: या शायद नहीं, वास्तव में इसके बारे में सोचने के लिए धैर्य या समय नहीं है। लेकिन मुझे अभी भी लगता है कि यह सी पैरामीटर विकिपीडिया का उल्लेख है, इसलिए कृपया मुझे गलत सबूत दें :)

इस तरह का एक ग्राफ प्रतिशत डॉक्स के लिए एक महान अतिरिक्त होगा

संपादित करें: अधिमानतः डिसकंटिनिटी के खुले / बंद होने को दर्शाता है

पाठकों पर ध्यान दें: इस सूत्र को प्रबंधनीय रखने के लिए, मैंने इस आलेख को "हल" के रूप में डॉक्स में जोड़ने के बारे में नीचे सभी चर्चाओं को चिह्नित किया है। ग्राफ अब https://numpy.org/devdocs/reference/generated/numpy.percentage.html के निचले भाग पर है

@ eric-wieser मुझे वह ग्राफ बनाने में कोई आपत्ति नहीं है। मैं आज कुछ बाद में वापस आऊंगा, क्या मुझे इसे यहां पोस्ट करना चाहिए?

@seberg मैं यहां ईमानदार

मुझे नहीं पता कि क्या कोई इंटरपोलेशन पैरामीटर है जो हमेशा उसी एल्गोरिदम के समान परिणाम देता है जिसकी मुझे दिलचस्पी है।

यहां तक ​​कि अगर वहाँ हैं, तो क्या इसे पाने के लिए इस्तेमाल किया जाना चाहिए? प्रतिशतक की सबसे सामान्य परिभाषा प्राप्त करने के लिए एक 'अजीब' पैरामीटर बदलना, इसे लागू करने का सबसे अच्छा तरीका नहीं लगता है।

@ ricardoV94 , हो सकता है, लेकिन आप सिर्फ चूक को बदल नहीं सकते, चाहे वे कितने भी बुरे हों। हम दोनों मापदंडों को एक ही बार में ओवरराइड करने के लिए विधि = "एच एंड के" की तरह कुछ भी उजागर कर सकते हैं।

C पैरामीटर वह जगह है जहां आप डेटा पॉइंट्स के संबंध में 0% और 100% परिभाषित करते हैं (डेटा बिंदु पर या नहीं, आदि)। विकिपीडिया पर पैरामीटर C में, यह अच्छी तरह से केवल प्रक्षेप के लिए हो सकता है, लेकिन एक ही मुद्दा यहां अंतर का कारण बनता है जो मुझे यकीन है। C निश्चित रूप से संदिग्ध है, एक उचित नाम रेंज = 'न्यूनतम-अधिकतम' या श्रेणी = 'एक्सट्रपलेटेड' या शायद पूरी तरह से कुछ अलग जैसा हो सकता है। जैसा कि मैंने कहा, कई सारे डेटापॉइंट्स (संभवतः छोटे शोर के साथ) के साथ प्लॉटों को फिर से करें, और मुझे लगता है कि आप उन्हें अभिसरण देखेंगे, क्योंकि रेंज की परिभाषा कम स्पष्ट हो जाती है।

@बर्ग मैं विधि = "एच एंड के" या शायद विधि = "क्लासिक" के साथ ठीक हूं। प्रक्षेप = "कोई नहीं" भी समझ में आ सकता है।

मुझे यकीन नहीं है कि डॉक्स में छवियों को शामिल करने के लिए तंत्र क्या है, या यदि ऐसा करने के लिए कोई मिसाल है।

मुझे पता है कि आप डॉक्लोप्लिब कोड को डॉक्स के भीतर चला सकते हैं, जो कि हम इसे कहीं और करते हैं - जो यह सुनिश्चित करता है कि यह वास्तविकता के साथ समन्वयित रहे।

ठीक है, मैं उस मामले में सर्वश्रेष्ठ कोड-छवि के बारे में सोचूंगा।

सबसे अधिक समस्याग्रस्त भाग डिसकंटिनिटी के लिए खुले, बंद मार्कर हैं, क्योंकि मैटलपोटलिब में उस (afaik) के लिए एक अंतर्निहित फ़ंक्शन नहीं है। हार्ड-कोडिंग से उन्हें उस मामले में थोड़ी समझ होगी।

शायद अब के लिए उन लोगों को छोड़ दें। यह अच्छा होगा यदि matplotlib को उन लोगों के लिए कुछ स्वचालित समर्थन मिले।

उम्मीद है कि किसी के पास एक बेहतर सुझाव होगा, जो अभी भी असंतोष के बारे में सुरुचिपूर्ण है।

import matplotlib.pyplot as plt

a = [0,1,2,3]
p = np.arange(101)

plt.step(p, np.percentile(a, p, interpolation='linear'), label='linear')
plt.step(p, np.percentile(a, p, interpolation='higher'), label='higher', linestyle='--')
plt.step(p, np.percentile(a, p, interpolation='lower'), label='lower', linestyle='--')
plt.step(p, np.percentile(a, p, interpolation='nearest'), label='nearest', linestyle='-.',)
plt.step(p, np.percentile(a, p, interpolation='midpoint'), label='midpoint', linestyle='-.',)

plt.title('Interpolation methods for list: ' + str(a))
plt.xlabel('Percentile')
plt.ylabel('List item returned')
plt.yticks(a)
plt.legend()

मुझे लगता है कि interpolation = 'linear' एक नियमित रूप से चरणबद्ध रेखा नहीं होनी चाहिए, लेकिन अन्यथा अच्छी लगती है। क्या आप डॉक्स को जोड़ने वाला PR बना सकते हैं?

वास्तव में, step आम तौर पर भ्रामक कलाकृतियों का कारण बन रहे हैं, इसलिए मैं इससे बचने के लिए इच्छुक हूं। linspace(0, 100, 60) अधिक सटीक मध्यवर्ती निर्देशांक भी उत्पन्न करेगा

मुझे कोई अंदाजा नहीं है कि पीआर कैसे बनाया जाता है।

सुझाए गए परिवर्तनों को जोड़ने या चर्चा करने के लिए इसे अपने खाते के साथ करने के लिए स्वतंत्र महसूस करें।

मुझे लगता है कि आप C को इस तरह से बदल सकते हैं (किसी चीज़ पर इसका परीक्षण कर सकते हैं)। अपने प्रतिशतक पर फ़ंक्शन को कॉल करें, फिर इसे सुपीरियर संस्करण में प्लग करें (जो C = 1 का उपयोग करता है, जो कि अभी तक बाध्य प्रतिशत में से सही को छोड़कर एक नो-ऑप है):

def scale_percentiles(p, num, C=0):
     """
     p : float
          percentiles to be used (within 0 and 100 inclusive)
     num : int
         number of data points.
     C : float
         parameter C, should be 0, 0.5 or 1. Numpy uses 1, matlab 0.5, H&K is 0.
     """
     p = np.asarray(p)
     fact = (num-1.+2*C)/(num-1)
     p *= fact
     p -= 0.5 * (fact-1) * 100
     p[p < 0] = 0
     p[p > 100] = 100
     return p

और वोइला, "निकटतम" के साथ आपको अपना "एच एंड एफ" मिलेगा और रैखिक के साथ आपको विकिपीडिया से प्लॉट मिलेगा। (लंबित है कि मुझे कुछ गलत मिला है, लेकिन मुझे पूरा यकीन है कि मैं सही हूं)।

जैसा कि मैंने कहा, अंतर यह है कि आप अंतिम बिंदु के संबंध में 0-100 (समान रूप से) से डेटा बिंदुओं को रखते हैं। C = 1 के लिए आप 0 वें प्रतिशत पर मिनट (डेटा) डालते हैं, मुझे "क्या अधिक समझ में आता है" के बारे में कोई सुराग नहीं है, यह संभवतः सामान्य दृश्य के लिए थोड़ा मायने रखता है। 1 के लिए समावेशी नाम और 0 के लिए अनन्य, मुझे लगता है कि थोड़ा अनुमान लगाता है (जब आप प्रतिशत की कुल सीमा के बारे में सोचते हैं, क्योंकि अनन्य संभव डेटा श्रेणी के बाहर है)। C = 1/2 भी इस अर्थ में अनन्य है।

मैं सी पैरामीटर को जोड़ने के लिए होगा, लेकिन मैं चाहता हूं कि कोई व्यक्ति वर्णनात्मक नाम के साथ आ सके। मैं एक "विधि" या ऐसा कुछ भी बुरा नहीं मानूंगा ताकि सबसे अच्छी चूक को स्पष्ट किया जा सके (प्रक्षेप + सी का संयोजन)। या, आप मूल रूप से यह तय करते हैं कि अधिकांश संयोजनों का उपयोग कभी नहीं किया जाता है और उपयोगी नहीं है, ठीक है ...।

अंत में मेरी समस्या यह है: मैं एक सांख्यिकीविद् चाहता हूं कि मुझे बताएं कि किन विधियों में आम सहमति है (आर में कुछ सामान है, लेकिन पिछली बार जब कोई व्यक्ति यहां आया था तो यह आर डॉक या इसी तरह का एक प्रतिलिपि अतीत था जो इसे बिना किसी संदर्भ में निर्धारित किए सभी, यह कहने के लिए बेकार है, यह एक सामान्य दर्शकों के लिए बेकार था, कागजों का हवाला देते हुए और अधिक सहायक होगा)।

मैं उस H & F पेपर को नहीं पढ़ना चाहता (ईमानदारी से यह पढ़ने में बहुत धीमा नहीं लगता), लेकिन मुझे लगता है कि आप इसे समर्थन के दृष्टिकोण से भी देख सकते हैं। सुन्न "निकटतम" (या किसी अन्य) संस्करण में प्रत्येक डेटा बिंदु के लिए समान समर्थन (प्रतिशत में) नहीं है, एच एंड एफ को "निकटतम" के लिए समान समर्थन है और शायद मिडपॉइंट के लिए यह C = 1/2 होगा, निश्चित नहीं है।
मैं खुद को दोहराता रहता हूं, मुझे नहीं पता कि इस तरह के समर्थन तर्क (सी = 1 के खिलाफ जैसे कि खतना का उपयोग करता है), वास्तव में एक वास्तविक कारण है।

EDIT: मिडपॉइंट का समान समर्थन है (डेटा बिंदुओं के बीच के क्षेत्र के लिए, बिंदु के लिए ही नहीं), खस्ता में, इसलिए "= 1" के साथ

@seberg यह मेरे साथ काम करने के लिए नहीं लगता है। क्या आप अपना कोड काम करते हुए दिखा सकते हैं?

ठीक है, मुझे साइन अप गलत मिला, उस कोड में वहाँ था, इसलिए यह विपरीत था (सी = 0 एक नो-ऑप न सी = 1:

def scale_percentiles(p, num, C=0):
     """
     p : float
          percentiles to be used (within 0 and 100 inclusive)
     num : int
         number of data points.
     C : float
         parameter C, should be 0, 0.5 or 1. Numpy uses 1, matlab 0.5, H&F is 0.
     """
     p = np.asarray(p)
     fact = (num+1.-2*C)/(num-1)
     p *= fact
     p -= 0.5 * (fact-1) * 100
     p[p < 0] = 0
     p[p > 100] = 100
     return p
plt.figure()
plt.plot(np.percentile([0, 1, 2, 3], scale_percentiles(np.linspace(0, 100, 101), 5, C=0), interpolation='nearest'))
plt.plot(np.percentile([0, 1, 2, 3], scale_percentiles(np.linspace(0, 100, 101), 5, C=1), interpolation='nearest'))
plt.figure()
plt.plot(np.percentile([15, 20, 35, 40, 50], scale_percentiles(np.linspace(0, 100, 101), 5, C=1), interpolation='linear'))
plt.plot(np.percentile([15, 20, 35, 40, 50], scale_percentiles(np.linspace(0, 100, 101), 5, C=0.5), interpolation='linear'))
plt.plot(np.percentile([15, 20, 35, 40, 50], scale_percentiles(np.linspace(0, 100, 101), 5, C=0), interpolation='linear'))

@seberg करीब है, लेकिन अभी तक वहाँ नहीं। a = [0,1,2,3] और percentiles = [25, 50, 75, 100] , np.percentile (a, scale_percentiles(percentiles, len(a), C=0), interpolation='nearest) [0, 2, 3, 3] , जब इसे [0,1,2,3] वापस करना चाहिए।

मुझे सूची को dtype=np.float या आपका कार्य त्रुटि देगा, लेकिन मुझे नहीं लगता कि यह मुद्दा है।

शास्त्रीय विधि के लिए कार्य सरल है:
प्रतिशत / 100 * N -> यदि यह पूरी संख्या है जो सूचकांक है, यदि नहीं, तो छत को सूचकांक के रूप में उपयोग करें।

इसके बावजूद, सी तर्क उम्मीद के मुताबिक काम कर रहा है, इसलिए इसे लागू किया जा सकता है अगर लोग इसे प्रक्षेप के लिए उपयोग करना चाहते हैं। मैं अभी भी एक विधि = 'क्लासिक' या इंटरपोलेशन = 'कोई नहीं' चाहूंगा जो कि विकिपीडिया के रूप में काम करेगा।

डिबगिंग के लिए, यह मेरी गैर-शास्त्रीय विधि का गैर-खस्ता कार्यान्वयन है:

def percentile (arr, p):
    arr = sorted(arr)

    index = p /100 * len(arr)

    # If index is a whole number, and larger than zero, subtract one unit (due to 0-based indexing)
    if index%1 < 0.0001 and index//1 > 0:
        index -= 1

    return arr[int(index)]

और एक अधिक संख्या में एक:

def indexes_classic(percentiles, set_size):
    percentiles = np.asarray(percentiles)

    indexes = percentiles / 100* set_size
    indexes[np.isclose(indexes%1, 0)] -= 1
    indexes = np.asarray(indexes, dtype=np.int)
    indexes[indexes < 0] = 0
    indexes[indexes > 100] = 100

    return indexes

फ़्लोटिंग पॉइंट / राउंडिंग इश्यूज़ (जो आप हैं, जैसे वे अंतर ध्वनि करते हैं
पता लगता है), और शायद C = 0 के साथ मेरा अनुमान गलत था और आप चाहते हैं
सी = 0.5।
मेरा कहना यह था कि अंतर कहाँ से आता है ("सी पैरामीटर"
आईएमओ, हालांकि कई को नापसंद करने के अच्छे कारण हैं
संयोजन)। यह आपको वर्कअराउंड देने / लागू करने के लिए नहीं था।

"शास्त्रीय" पद्धति के अनुसार, मैं स्पष्ट रूप से इस बात की परवाह नहीं करता हूं कि शास्त्रीय क्या है
ऐसा माना जाता है। सभी के लिए मुझे पता है कि शास्त्रीय का अर्थ है "काफी कुछ
लोग इसका उपयोग करते हैं ”।

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

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

इसलिए, मेरी धारणा गोल और सटीक के साथ संभावित समस्याओं के साथ है
प्रतिशतक मैच) हमारे पास (शायद बहुत) कई "प्रक्षेप" विकल्प हैं
और "सी पैरामीटर" या जो भी आप इसे कॉल करना चाहते हैं, उसकी आवश्यकता होगी
लगभग कुछ भी करने में सक्षम हो।
और मुझे वास्तव में खुशी होगी अगर कोई मुझे बता सकता है कि सभी कैसे
(सामान्य) "विधियाँ" उन श्रेणियों में आती हैं, ऐसा लगता है
और फिर C = 0,0.5,1 भी मौजूद है, और शायद कुछ उन लोगों के बाहर भी
विकल्प ....

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

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

आपको ऐसा करने की आवश्यकता नहीं है, लेकिन अगर हम एक नई विधि जोड़ना चाहते हैं, तो हमें इसकी आवश्यकता है
इसे जोड़ने का तरीका जो हर किसी को और अधिक भ्रमित नहीं करता है और स्पष्ट है!

मुझे इसे संक्षेप में बताने दें:

1) अभी सुन्न केवल एक उपयोगी विधि प्रदान करता है: प्रक्षेप = 'रैखिक', और अन्य इसके चारों ओर केवल छोटे बदलाव हैं जो वास्तव में किसी के द्वारा उपयोग नहीं किए जाते हैं। अन्य पैकेजों में कई और अधिक प्रासंगिक विकल्प हैं।

2) C = 0 या C = 0.5 के लिए अन्य मान जोड़ना, मेरे लिए समझ में आता है। सभी प्रक्षेप विधियां उनके साथ संयोजन में काम कर सकती हैं, हालांकि फिर से वे शायद कभी भी उपयोग करने वाले नहीं हैं।

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

4) अगर कॉम्बो में से कोई भी समान परिणाम प्राप्त नहीं करता है, तो मुझे लगता है कि एक अलग विधि समझ में आएगी। संभवतः प्रक्षेप कहा जाता है = 'कोई नहीं' कम भ्रामक होगा।

संक्षेप में: numpy.percentile के वर्तमान विकल्प दोनों भ्रामक और सीमित हैं। ऊपर वर्णित कागज अन्य उपयोगी तरीकों का एक अच्छा अवलोकन प्रदान करता है। विकिपीडिया पृष्ठ के साथ मिलकर, वे numpy.percentile के लिए अधिक विस्तृत और उपयोगी विकल्पों के सेट के डिजाइन के लिए एक प्रारंभिक बिंदु के रूप में काम कर सकते हैं। उम्मीद है कि कोई इस कार्य को करना चाहेगा।

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

कॉम्बो बेकार हैं जब तक कि वे समझने योग्य नहीं होते हैं और आमतौर पर आसानी से उपयोग किया जाता है, इसलिए मुझे संदेह है। प्रक्षेप के लिए कई विकल्प मौजूद हैं (उदाहरण के लिए http://mathworld.wolfram.com/Quantile.html Q4 से Q9, मुझे लगता है कि R दस्तावेज़ीकरण व्यावहारिक रूप से समान है, लेकिन मुझे लगता है कि यह संभवतः पूर्ण नहीं है, उदाहरण के लिए matlab ...) मेरे पास कोई सुराग नहीं है अगर वे वास्तव में सभी समझ में आते हैं;)।

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

तब मैं भी एग्रेसिवली सब कुछ (शायद रेखीय को छोड़कर) को अपग्रेड करना पसंद करूंगा।

लेकिन, अगर हम विरोध करते है, मैं यह 100% सही प्राप्त करना चाहते हैं, और कहा कि क्या मौजूद है के रूप में थोड़ा अधिक स्पष्टता की जरूरत हो सकती है, जो मौजूद होना चाहिए और क्या निश्चित रूप से मौजूद नहीं चाहिए।

मैं आपसे पूरी तरह सहमत हूं

@ ricardoV94 : क्या आपके पास # 9211 पर प्रस्तावित भारित मात्रात्मक मामले के लिए linear की परिभाषाओं पर कोई राय है? वहाँ कुछ रेखांकन उसी शैली में हैं।

शायद @ ricardoV94 इस पर टिप्पणी कर सकता है (यह अच्छा होगा), लेकिन मुझे लगता है कि यह मुद्दा बहुत ओर्थोगोनल है। वेट्स शायद फ़्रीक्वेंसी टाइप वेट हैं, यह मानते हुए कि पर्सेंटाइल के लिए कोई अन्य निर्धारित वज़न नहीं हैं (मुझे नहीं पता कि कैसे), उन्हें लागू करते समय कोई अस्पष्टता नहीं होनी चाहिए, लेकिन मुझे यकीन है कि पता नहीं है।

आप उस PR पर josef-pkt को पिंग करने की भी कोशिश कर सकते हैं और आशा करते हैं कि उन्हें एक त्वरित टिप्पणी है कि क्या उन्हें लगता है कि यह एक अच्छा विचार है / सही है।

अगर कोई इसे यहाँ से ले जाना चाहता है, तो मैंने एक गैर-अनुकूलित फ़ंक्शन लिखा है जो गणना करता है
Hyndman और Fan (1996) द्वारा वर्णित 9 प्रतिशत / मात्रात्मक आकलन विधियां और आर में भी इस्तेमाल किया गया।

विधि 1 विकिपीडिया में चर्चा के अनुसार 'शास्त्रीय निकटतम रैंक विधि' से मेल खाती है। विधि 7 वर्तमान Numpy कार्यान्वयन (प्रक्षेप = 'रैखिक') के बराबर है। Numpy प्रक्षेप के शेष तरीकों को शामिल नहीं किया गया है (और वे वैसे भी उपयोगी नहीं लगते हैं)।

def percentile(x, p, method=7):
    '''
    Compute the qth percentile of the data.

    Returns the qth percentile(s) of the array elements.

    Parameters
    ----------
    x : array_like
        Input array or object that can be converted to an array.
    p : float in range of [0,100] (or sequence of floats)
        Percentile to compute, which must be between 0 and 100 inclusive.
    method : integer in range of [1,9]
        This optional parameter specifies one of the nine sampling methods 
        discussed in Hyndman and Fan (1996). 

        Methods 1 to 3 are discontinuous:
        * Method 1: Inverse of empirical distribution function (oldest
        and most studied method).
        * Method 2: Similar to type 1 but with averaging at discontinuities.
        * Method 3: SAS definition: nearest even order statistic.

        Methods 4 to 9 are continuous and equivalent to a linear interpolation 
        between the points (pk,xk) where xk is the kth order statistic. 
        Specific expressions for pk are given below:
        * Method 4: pk=kn. Linear interpolation of the empirical cdf.
        * Method 5: pk=(k−0.5)/n. Piecewise linear function where the knots 
        are the values midway through the steps of the empirical cdf 
        (Popular amongst hydrologists, used by Mathematica?).
        * Method 6: pk=k/(n+1), thus pk=E[F(xk)]. The sample space is divided
        in n+1 regions, each with probability of 1/(n+1) on average
        (Used by Minitab and SPSS).
        * Method 7: pk=(k−1)/(n−1), thus pk=mode[F(xk)]. The sample space
        is divided into n-1 regions (This is the default method of 
        Numpy, R, S, and MS Excell).
        * Method 8: pk=(k−1/3)/(n+1/3), thus pk≈median[F(xk)]. The resulting
        estimates are approximately median-unbiased regardless of the
        distribution of x (Recommended by Hyndman and Fan (1996)).
        * Method 9: k=(k−3/8)/(n+1/4), thus pk≈F[E(xk)]if x is normal (?).
        The resulting estimates are approximately unbiased for the expected 
        order statistics if x is normally distributed (Used for normal QQ plots).

        References:
        Hyndman, R. J. and Fan, Y. (1996) Sample quantiles in statistical packages, 
        American Statistician 50, 361--365.
        Schoonjans, F., De Bacquer, D., & Schmid, P. (2011). Estimation of population
        percentiles. Epidemiology (Cambridge, Mass.), 22(5), 750.

        '''

    method = method-1    
    x = np.asarray(x)
    x.sort()
    p = np.array(p)/100

    n = x.size  
    m = [0, 0, -0.5, 0, 0.5, p, 1-p, (p+1)/3, p/4+3/8][method]

    npm = n*p+m
    j = np.floor(npm).astype(np.int)
    g = npm-j

    # Discontinuous functions
    if method < 3:
        yg0 = [0, 0.5, 0][method]
        y = np.ones(p.size)
        if method < 2:
            y[g==0] = yg0
        else:
            y[(g==0) & (j%2 == 0)] = yg0      
    # Continuous functions
    else:
        y = g

    # Adjust indexes to work with Python
    j_ = j.copy()
    j[j<=0] = 1
    j[j > n] = n
    j_[j_ < 0] = 0
    j_[j_ >= n] = n-1 

    return (1-y)* x[j-1] + y*x[j_]

निरंतर तरीकों को भी इस तरह अधिक कुशलता से लागू किया जा सकता है।

def percentile_continuous(x, p, method=7):
    '''
    Compute the qth percentile of the data.

    Returns the qth percentile(s) of the array elements.

    Parameters
    ----------
    x : array_like
        Input array or object that can be converted to an array.
    p : float in range of [0,100] (or sequence of floats)
        Percentile to compute, which must be between 0 and 100 inclusive.
    method : integer in range of [4,9]
        This optional parameter specifies one of the 5 continuous sampling
        methods discussed in Hyndman and Fan (1996). 
        '''

    x = np.asarray(x)
    x.sort()
    p = np.asarray(p)/100
    n = x.size

    if method == 4:
        r = p * n
    elif method == 5:
        r = p * n + .5
    elif method == 6:
        r = p * (n+1)
    elif method == 7:
        r = p * (n-1) + 1
    elif method == 8:
        r = p * (n+1/3) + 1/3
    elif method == 9:
        r = p * (n+1/4) + 3/8

    index = np.floor(r).astype(np.int)

    # Adjust indexes to work with Python
    index_ = index.copy()
    index[index_ <= 0] = 1
    index[index_  > n] = n
    index_[index_ < 0] = 0
    index_[index_ >= n] = n-1

    i = x[index - 1]
    j = x[index_]

    return i + r%1* (j-i)

कोई इसे यहाँ से ले जाना चाहता है? मैं ऐसा करने के लिए योग्य नहीं हूं।

जैसा कि पिछले पोस्ट में उल्लेख किया गया है, ऐसा लगता है कि मात्रा के वर्तमान डिफ़ॉल्ट कार्यान्वयन का अनुमान है कि R ।

R :

> quantile(c(15, 20, 35, 40, 50), probs=c(0.05, 0.3, 0.4, 0.5, 1))
  5%  30%  40%  50% 100% 
  16   23   29   35   50 
> quantile(c(3, 6, 7, 8, 8, 10, 13, 15, 16, 20), probs=c(0.25, 0.5, 0.75, 1))
  25%   50%   75%  100% 
 7.25  9.00 14.50 20.00
> quantile(c(3, 6, 7, 8, 8, 9, 10, 13, 15, 16, 20), probs=c(0.25, 0.5, 0.75, 1))
 25%  50%  75% 100% 
 7.5  9.0 14.0 20.0 

np.quantile :

>>> np.quantile([15, 20, 35, 40, 50], q=[0.05, 0.3, 0.4, 0.5, 1])
array([16., 23., 29., 35., 50.])
>>> np.quantile([3, 6, 7, 8, 8, 10, 13, 15, 16, 20], q=[0.25, 0.5, 0.75, 1])
array([ 7.25,  9.  , 14.5 , 20.  ])
>>> np.quantile([3, 6, 7, 8, 8, 9, 10, 13, 15, 16, 20], q=[0.25, 0.5, 0.75, 1])
array([ 7.5,  9. , 14. , 20. ])

बेशक जो विकिपीडिया में दिए गए उदाहरणों को पुन: पेश नहीं करता है:
https://en.wikipedia.org/wiki/Percentile

वास्तव में, यदि आप quantile https://www.rdocumentation.org/packages/stats/versions/3.5.0/topics/quantile के लिए R मदद पृष्ठ पर जाते हैं
आप देखेंगे कि R डिफ़ॉल्ट विधि (टाइप 7) सीमा की स्थिति के समान सेट करती है कि np.quantile इसे कैसे सेट करें: p_k = (k-1) / (n-1) , जहां n नमूना आकार है, और k = 1 सबसे छोटा दर्शाता है मान, जबकि k = n सबसे बड़ा। इसका मतलब है कि सॉर्ट किए गए ऐरे में सबसे छोटा मान क्वांटाइल = 0 पर पिन किया गया है, और सबसे बड़ा क्वांटाइल = 1 पर पिन किया गया है।

जैसा कि पिछली पोस्ट में बताया गया है, आप विकिपीडिया में टाइप 1 के साथ 3 उदाहरण प्रस्तुत कर सकते हैं:

> quantile(c(15, 20, 35, 40, 50), probs=c(0.05, 0.3, 0.4, 0.5, 1), type=1)
  5%  30%  40%  50% 100% 
  15   20   20   35   50 
> quantile(c(3, 6, 7, 8, 8, 10, 13, 15, 16, 20), probs=c(0.25, 0.5, 0.75, 1), type=1)
 25%  50%  75% 100% 
   7    8   15   20 
> quantile(c(3, 6, 7, 8, 8, 9, 10, 13, 15, 16, 20), probs=c(0.25, 0.5, 0.75, 1), type=1)
 25%  50%  75% 100% 
   7    9   15   20 

यह कुछ दिलचस्प सवाल उठाता है:

1.) n.p.quantile का डिफ़ॉल्ट ट्रैक R.quantile का डिफ़ॉल्ट ट्रैक होना चाहिए?
2.) टाइप 1 एल्गोरिथ्म के लिए np.quantile स्विच करना चाहिए?

चूंकि विकिपीडिया स्वयं भी सहमत है कि प्रतिशतता की कोई मानक परिभाषा नहीं है, मुझे लगता है कि जब तक एल्गोरिथम ध्वनि है और उपयोगकर्ता को पता है कि यह कैसे काम करता है, न तो (1) या (2) उतना ही मायने रखता है। मैं (1) के पक्ष में अधिक हूं क्योंकि पायथन और आर दो सबसे लोकप्रिय डेटा एनालिटिक्स प्लेटफॉर्म हैं, और यह अच्छा होगा यदि वे एक दूसरे को वीटी कर सकते हैं। यह देखते हुए, मुझे लगता है कि (2) अनावश्यक है।

हां, R और Numpy दोनों 7 विधि के लिए डिफ़ॉल्ट हैं और इसे उसी तरह रखा जाना चाहिए। सवाल अन्य तरीकों को जोड़ने के बारे में है या नहीं।

अगर किसी को दिलचस्पी है, तो मैं 9 प्रतिशत तरीकों के साथ एक स्वतंत्र मॉड्यूल रखता हूं, यहां । यदि आप जानते हैं कि इसका उपयोग करने के लिए या Numpy के लिए स्वतंत्र महसूस करें।

साभार @ ricardoV94

तो, सिर्फ किक के लिए, मैंने आर उपयोगकर्ताओं पर काम पर एक सर्वेक्षण किया। जिन 20 लोगों ने प्रतिक्रिया दी, उनमें से 20 quantile में केवल डिफ़ॉल्ट विधि का उपयोग करते हैं। वे सार्वजनिक स्वास्थ्य में मास्टर्स के छात्रों को सांख्यिकी में पीएचडी शोधकर्ताओं से लेकर हैं।

व्यक्तिगत रूप से, मुझे यकीन नहीं है कि यह मात्रात्मक गणना करने के लिए 9 अलग-अलग तरीकों का समर्थन करने के लिए सुन्न के प्रयास के लायक है। मुझे लगता है कि अधिकांश उपयोगकर्ता केवल डिफ़ॉल्ट का उपयोग करेंगे।

इसके लिए जो मूल्य है वह scipy.stats.mstats.mquantiles फ़ंक्शन है जो 9 विधियों में से 6 का उपयोग करता है (निरंतर वाले) और

@albertcthomas आह, यह जानना अच्छा है। हालांकि, मुझे लगता है कि आदर्श रूप से हम इस जटिलता को थोड़ा खामियों में छिपाएंगे। और हमें ज्यादातर गैर-सन्निहित संस्करणों IIRC को ठीक करने की आवश्यकता है। क्योंकि वे मूल रूप से सबसे सामान्य तरीके नहीं देते हैं।

हाँ, वास्तव में, खस्ता जरूरी नहीं है कि वे इन तरीकों का समर्थन करें यदि वे स्किपी सांख्यिकी मॉड्यूल में लागू किए जाते हैं।

व्यक्तिगत रूप से मैं संचयी वितरण समारोह के सामान्यीकृत व्युत्क्रम से क्वांटाइल की गणना करने वाली विधि के पक्ष में होगा। तथ्य यह है कि इस तरह की विधि उपलब्ध नहीं है मुझे इस मुद्दे के लिए नेतृत्व :)।

@albertcthomas यदि आपके पास इस बारे में कोई संकेत / ज्ञान है, तो कृपया कहें! हम स्पष्टता की कमी के कारण थोड़ा फंस गए हैं कि वास्तव में अच्छा डिफ़ॉल्ट क्या है। और मुझे लगता है कि यह एक बहुत कष्टप्रद मुद्दा है।

सबसे महत्वपूर्ण बात हमें कुछ अच्छे डिफॉल्ट की जरूरत है। और इसका मतलब है कि 2-3 तरीकों को लागू करना (गैर-सन्निहित लोगों को पूरी तरह से सुधारना)। मैं अधिक या अधिक जटिल सामान का समर्थन करने के साथ ठीक हूं, लेकिन मुझे अच्छा लगेगा अगर हम कुछ "विशिष्ट / अच्छे" पर निर्णय ले सकें।

मैं कहूंगा कि लीनियर मेथड (करंट डिफॉल्ट) और कम्युलेटिव डिस्ट्रीब्यूशन फंक्शन का उलटा (जो मैं इस इश्यू को @albertcthomas अगर मैं सही तरीके से

और वर्तमान में लागू किए गए अन्य विकल्पों को निश्चित रूप से हटा दिया जाना चाहिए।

संचयी वितरण फ़ंक्शन का व्युत्क्रम निश्चित रूप से जोड़ा जाना चाहिए। यह आँकड़ों में टिप्पणियों के दिए गए नमूने से एक मात्रात्मक के सबसे लोकप्रिय अनुमानकों में से एक है।

और वर्तमान में लागू किए गए अन्य विकल्पों को निश्चित रूप से हटा दिया जाना चाहिए।

@ ricardoV94 आप ऐसा इसलिए कह रहे हैं क्योंकि विकिपीडिया में किसी भी विकल्प को संदर्भित नहीं किया गया है और न ही हयंडमैन एंड फैन के पेपर को?

हां, किसी भी अन्य पैकेज में लागू नहीं किया गया है।

मैं नहीं देखता कि कोई भी उन तरीकों का उपयोग क्यों करना चाहेगा, और उनके नाम हैं
संभावित रूप से भ्रामक भी।

अल्बर्ट थॉमस सूचनाएं @github.com escreveu no dia quarta, 2/01/2019
à (s) 14:18:

और वर्तमान में लागू अन्य विकल्प निश्चित रूप से होने चाहिए
हटा दिया।

@ ricardoV94 https://github.com/ricardoV94 क्या आप ऐसा इसलिए कह रहे हैं
विकिपीडिया में कोई भी विकल्प संदर्भित नहीं है और न ही Hyndman और
फैन का पेपर?

-
आप इसे प्राप्त कर रहे हैं क्योंकि आपका उल्लेख किया गया था।
इस ईमेल का उत्तर सीधे दें, इसे GitHub पर देखें
https://github.com/numpy/numpy/issues/10736#issuecomment-450861068 , या म्यूट
सूत्र
https://github.com/notifications/unsubscribe-auth/AbpAmfUoJNk3YHOSHNeVN03Va5wtvkHQks5u_LGugaJpZM4SnVpE
।

धन्यवाद! Np.percentile में उपलब्ध विधि के रूप में संचयी वितरण के व्युत्क्रम को जोड़ने के लिए PR को क्यों नहीं खोलें? इस मुद्दे को खोलते समय यदि हम विकल्पों के बारे में चर्चा करते रहना चाहते हैं (वर्तमान डिफ़ॉल्ट को छोड़कर जो डिफ़ॉल्ट रहना चाहिए)। कैसे खस्ताहाल संभाला है?

यहाँ कुछ और जानकारी - पायथन 3.8 ने statistics.quantiles जोड़ा - हमें np.quantile समतुल्य मोड को जोड़ना चाहिए।

यहाँ आगे का तरीका शायद method kwarg का है, जो statistics एक को दिखाता है, और 0-2 और जोड़ना संभव है (जिस स्थिति में मूल लेखकों को अजगर पर पिंग करना अच्छा होगा ।

मुझे यकीन नहीं है कि अगर चूक हमारे और उनके बीच मेल खाती है, जो कि अगर वे नहीं करते हैं तो शर्म की बात होगी, लेकिन यह अभी भी सबसे अच्छा विचार जैसा लगता है (और वैसे भी जो हमारे मन में था)। साथ ही जोड़ने के लिए 0-2 नए "तरीके" ठीक होंगे। किस मामले में अजगर के लोगों को वास्तविक नामों पर पिंग करना अच्छा होगा ...

पीआरएस बहुत स्वागत करते हैं, मैं चाहूंगा कि यह आगे बढ़े, लेकिन मैं तत्काल भविष्य में ऐसा नहीं करूंगा।

@ eric-wieser मैं ध्यान देता हूं कि आपके पास संबंधित पीआर के कुछ जोड़े बकाया हैं, क्या उनमें से कोई भी इससे निपटता है?

मैं इसे 1.19 से आगे बढ़ाने जा रहा हूं, इसलिए यह अवरोधक नहीं है। लेकिन इसका मतलब यह नहीं है कि यह 1.18 के लिए तय नहीं किया जा सकता है :)

@charris : आपके पास कौन से

मुझे नहीं लगता कि दुर्भाग्यवश इस दिशा में अभी तक कोई बात हुई है।