Numpy: अद्वितीय और NaN प्रविष्टियाँ (Trac # 1514)

_trac उपयोगकर्ता rspringuel ने 2010-06-18_ पर लिखा

ऊपर दिए गए कोड ब्लॉक का उपयोग करने के लिए शूट करें। यह केवल पैच-ओवर कोड को वास्तव में प्रभावित करता है, इसलिए मैं इसे केवल रीपोस्ट करूंगा:

def nanunique(x):
    a = numpy.unique(x)
    r = []
    for i in a:
        if i in r or (numpy.isnan(i) and numpy.any(numpy.isnan(r))):
            continue
        else:
            r.append(i)
    return numpy.array(r)

फिक्स्ड।

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

यह फ़्लोट्स के लिए ठीक करना आसान है, लेकिन मुझे जटिल या संरचित dtypes के लिए एक आसान रास्ता नहीं दिखता है। एक साथ एक त्वरित पीआर डाल देंगे और हम वहाँ विकल्पों पर चर्चा कर सकते हैं।

@jaimefrio मैं यह अद्वितीय उपयोग के लिए तय किया है

    if issubclass(aux.dtype.type, np.inexact):
        # nans always compare unequal, so encode as integers
        tmp = aux.searchsorted(aux)
    else:
        tmp = aux
    flag = np.concatenate(([True], tmp[1:] != tmp[:-1]))

लेकिन ऐसा लगता है कि अन्य सभी कार्यों में भी समस्याएं हैं। शायद हमें nan_equal, nan_not_equal ufuncs, या शायद nanfuntions में कुछ चाहिए।

Sortsearching aux अपने लिए एक स्मार्ट ट्रिक है! हालाँकि यह पता लगाना कि इसमें से _all_ थोड़ा बेकार है, आदर्श रूप से हम पहली प्रविष्टि को एक नैनो के साथ रखना चाहेंगे, शायद कुछ पंक्तियों के साथ, aux और flag रूप में सही होने के बाद, अभी कर रहे हैं :

if not aux[-1] == aux[-1]:
    nanidx = np.argmin(aux == aux)
    nanaux = aux[nanidx:].searchsorted(aux[nanidx:])
    flag[nanidx+1:] = nanaux[1:] != nanaux[:-1]

या कुछ एक के बाद एक बंद त्रुटियों को सही करने के बाद भी ऐसा ही कुछ है जो मैंने वहाँ पेश किया है।

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

In [10]: a = np.random.randn(1000)

In [11]: %timeit np.unique(a)
10000 loops, best of 3: 69.5 us per loop

In [12]: b = np.sort(a)

In [13]: %timeit b.searchsorted(b)
10000 loops, best of 3: 28.1 us per loop

यह एक 40% प्रदर्शन हिट होने वाला है, जो nanunique फ़ंक्शन के लिए ठीक हो सकता है, लेकिन संभवतः सामान्य मामले के लिए नहीं।

2019 कहा जाता है, ओपी समस्या अभी भी वैध है और कोड प्रतिलिपि प्रस्तुत करने योग्य है।

@jaimefrio हमारे पास डिफ़ॉल्ट रूप से गलत होने का विकल्प क्यों नहीं हो सकता है?

मेरा मतलब है, यह व्यवहार सबसे अच्छा भ्रमित कर रहा है, और प्रदर्शन कोई बहाना नहीं है।

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

PR # 5487 टिप्पणी करने या आगे बढ़ने के सुझाव देने के लिए एक बेहतर स्थान हो सकता है।

संपादित करें: PR नंबर ठीक करें

यह समस्या 8 साल से खुली हुई प्रतीत हो रही है, लेकिन मैं सिर्फ numpy.unique लिए डिफ़ॉल्ट व्यवहार करने के लिए +1 के साथ झंकार करना चाहता हूं क्योंकि

मैं आज उसी मुद्दे पर भागा। Np.unique रूटीन का मूल, मानों को उस सॉर्ट किए गए सरणी में परिवर्तित होने पर खोजने के लिए संख्यात्मक / lib / arraysetops.py में एक अनियंत्रित सॉर्ट किए गए सरणी पर एक मास्क की गणना कर रहा है:

mask = np.empty(aux.shape, dtype=np.bool_)
mask[:1] = True
mask[1:] = aux[1:] != aux[:-1]

इसे कुछ इस तरह से बदला जा सकता है, जो लगभग 5 साल पहले से jaimefrio की टिप्पणी की तर्ज पर बहुत अधिक है, लेकिन इस argmin कॉल से बचा जाता है:

mask = np.empty(aux.shape, dtype=np.bool_)
mask[:1] = True
if (aux.shape[0] > 0 and isinstance(aux[-1], (float, np.float16,
                                              np.float32, np.float64))
    and np.isnan(aux[-1])):
    aux_firstnan = np.searchsorted(aux, np.nan, side='left')
    mask[1:aux_firstnan] = (aux[1:aux_firstnan] != aux[:aux_firstnan-1])
    mask[aux_firstnan] = True
    mask[aux_firstnan+1:] = False
else:
    mask[1:] = aux[1:] != aux[:-1]

कुछ% timeit प्रयोगों को चलाने पर मैंने अधिकतम <10% रनटाइम पेनल्टी का अवलोकन किया यदि सरणी बड़ी है और बहुत कम NaN हैं (1 मिलियन में से 10 NaN कहते हैं), और ऐसे बड़े सरणियों के लिए यह वास्तव में तेजी से चलता है अगर बहुत सारे हैं NaN के।

दूसरी ओर, यदि सरणियाँ छोटी हैं (उदाहरण के लिए, 10 प्रविष्टियाँ) एक महत्वपूर्ण प्रदर्शन हिट है क्योंकि फ्लोट और NaN के लिए चेक अपेक्षाकृत महंगा है, और रनटाइम कई तक जा सकता है। यह तब भी लागू होता है यदि कोई NaN नहीं है क्योंकि यह जांच है जो धीमी है।

यदि सरणी में NaN होता है, तो यह NaNs के संयोजन से एक अलग परिणाम उत्पन्न करता है, जो कि यह सब है। तो उस मामले के लिए यह वास्तव में एक वांछित परिणाम प्राप्त करने का सवाल है (सभी NaN एक एकल मूल्य समूह में संयुक्त) थोड़ा धीमा बनाम एक अवांछित परिणाम प्राप्त करना (प्रत्येक NaN अपने मूल्य समूह में) थोड़ा तेज।

अंत में, ध्यान दें कि यह पैच NaNs युक्त यौगिक वस्तुओं जैसे अद्वितीय उदाहरणों को खोजने में ठीक नहीं होगा, जैसे कि इस उदाहरण में:

a = np.array([[0,1],[np.nan, 1], [np.nan, 1]])
np.unique(a, axis=0)

जो अभी भी लौटेगा

array([[ 0.,  1.],
       [nan,  1.],
       [nan,  1.]])

"अगर सरणी में NaN होता है, तो यह NaNs को मिलाकर एक अलग परिणाम तैयार करता है, जो कि यह सब है।"

+1

एक फ़ंक्शन जो बार-बार तत्वों से युक्त एक सूची देता है, _e.g._ 1 NaN से अधिक के साथ एक सूची, को "अद्वितीय" नहीं कहा जाना चाहिए। यदि NaN के मामले में बार-बार तत्वों को वांछित किया जाता है, तो यह केवल एक विशेष मामला होना चाहिए जो डिफ़ॉल्ट रूप से अक्षम हो, उदाहरण के लिए numpy.unique(..., keep_NaN=False) ।

@ufmayer submit a PR!

+1
मैं भी केवल एक बार ही NaN वापसी का समर्थन करूंगा