matlab

Question

में क्वांटाइल के लिए समतुल्य पायथन कमांड मैं मैटलैब में अपने कुछ कोड को पाइथन में दोहराने की कोशिश कर रहा हूं। मुझे पता चला कि मैटलैब में क्वांटाइल फ़ंक्शन में "बिल्कुल" पायथन में एक समान नहीं है। जो मुझे सबसे ज्यादा मिला वह पाइथन की मैक्वेंटाइल है। जैसे

matlab के लिए

:

quantile([ 8.60789925e-05, 1.98989354e-05 , 1.68308882e-04, 1.69379370e-04], 0.8) 

देता है: 0.00016958

अजगर के लिए

:

scipy.stats.mstats.mquantiles([8.60789925e-05, 1.98989354e-05, 1.68308882e-04, 1.69379370e-04], 0.8) 

0.00016912

किसी को है किस matlab के quantile को दोहराने के लिए देता है? बहुत बहुत धन्यवाद।

Answer 1

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

Answer 2

documentation for quantile (अधिक के बारे में => एल्गोरिदम अनुभाग के तहत) सटीक एल्गोरिदम का उपयोग किया जाता है। यहाँ कुछ अजगर कोड है कि यह एक फ्लैट सरणी के लिए एक एकल quantile के लिए करता है, bottleneck का उपयोग कर आंशिक रूप से क्रमबद्ध करना है:

import numpy as np 
import botteleneck as bn 

def quantile(a, prob): 
    """ 
    Estimates the prob'th quantile of the values in a data array. 

    Uses the algorithm of matlab's quantile(), namely: 
     - Remove any nan values 
     - Take the sorted data as the (.5/n), (1.5/n), ..., (1-.5/n) quantiles. 
     - Use linear interpolation for values between (.5/n) and (1 - .5/n). 
     - Use the minimum or maximum for quantiles outside that range. 

    See also: scipy.stats.mstats.mquantiles 
    """ 
    a = np.asanyarray(a) 
    a = a[np.logical_not(np.isnan(a))].ravel() 
    n = a.size 

    if prob >= 1 - .5/n: 
     return a.max() 
    elif prob <= .5/n: 
     return a.min() 

    # find the two bounds we're interpreting between: 
    # that is, find i such that (i+.5)/n <= prob <= (i+1.5)/n 
    t = n * prob - .5 
    i = np.floor(t) 

    # partial sort so that the ith element is at position i, with bigger ones 
    # to the right and smaller to the left 
    a = bn.partsort(a, i) 

    if i == t: # did we luck out and get an integer index? 
     return a[i] 
    else: 
     # we'll linearly interpolate between this and the next index 
     smaller = a[i] 
     larger = a[i+1:].min() 
     if np.isinf(smaller): 
      return smaller # avoid inf - inf 
     return smaller + (larger - smaller) * (t - i) 

मैं केवल एकल quantile, 1 दिन मामला किया क्योंकि वह सब मैं की जरूरत है। यदि आप कई क्वांटाइल चाहते हैं, तो शायद यह पूरी तरह से करने के लायक है; प्रति-अक्ष करने के लिए और पता था कि आपके पास कोई नैन नहीं है, आपको बस इतना करना होगा कि क्रम में अक्ष तर्क जोड़ें और रैखिक इंटरपोलेशन बिट को सदिश करें। नैन के साथ प्रति-अक्ष करना यह थोड़ा सा ट्रिकियर होगा।

इस कोड को देता है:

>>> quantile([ 8.60789925e-05, 1.98989354e-05 , 1.68308882e-04, 1.69379370e-04], 0.8) 
0.00016905822360000001 

और matlab कोड 0.00016905822359999999 दिया, अंतर 3e-20 है। थोड़ा देर से

Answer 3

(जो मशीन परिशुद्धता से भी कम है), लेकिन:

mquantiles बहुत लचीला है। आपको बस अल्फाप और betap पैरामीटर प्रदान करने की आवश्यकता है। यहां, चूंकि MATLAB एक रैखिक इंटरपोलेशन करता है, इसलिए आपको पैरामीटर (0.5,0.5) पर सेट करने की आवश्यकता होती है।

In [9]: scipy.stats.mstats.mquantiles([8.60789925e-05, 1.98989354e-05, 1.68308882e-04, 1.69379370e-04], 0.8, alphap=0.5, betap=0.5) 

संपादित करें: MATLAB कहना है कि यह रैखिक प्रक्षेप करता है, लेकिन ऐसा लगता है कि यह टुकड़ा वार रैखिक प्रक्षेप के माध्यम से quantile, जो 5 आर में quantile प्रकार के बराबर है की गणना करता है, और (0.5, 0.5) scipy में।