Numpy: पहला गैर-शून्य तत्व (Trac #1673)

_trac उपयोगकर्ता tom3118 ने 2010-11-13_ को लिखा

एक संबंधित उपयोग मामला है:
filter(test,A)[0]
जिसमें या तो A लंबा है या test महंगा है।

_@rgommers ने 2011-03-24_ को लिखा

केवल पहले गैर-शून्य होना जरूरी नहीं है, पहले कोई भी मूल्य उपयोगी होगा।

_@rgommers ने 2011-03-24_ को लिखा

जैसा कि #2333 में उल्लेख किया गया है, 1-डी के लिए अर्थ स्पष्ट है। >1-डी शब्दार्थ चर्चा के लिए तैयार हैं।

शायद एक कीवर्ड जो कुल्हाड़ियों पर चलने के क्रम को निर्धारित करता है। या इसे केवल>1-डी के लिए अपरिभाषित किया जा सकता है।

_trac उपयोगकर्ता lcampagn ने 2011-07-09_ को लिखा

मैंने numpy में find_first के लिए कई अनुरोध देखे हैं, लेकिन इनमें से अधिकांश अनुरोधों में सूक्ष्म रूप से भिन्न (और असंगत) आवश्यकताएं हैं जैसे "x से कम का पहला मान ढूंढें" या "पहला गैर-शून्य मान ढूंढें"। मैं निम्नलिखित फ़ंक्शन विनिर्देश का सुझाव देता हूं:

  ind = array.find(x, testOp='eq', arrayOp='all', axis=0, test=None)
  arguments:
    x       -> value to search for
    testOp  -> condition to test for ('eq', 'ne', 'gt', 'lt', 'ge', 'le')
    arrayOp -> method for joining multiple comparisons ('any' or 'all')
    axis    -> the axis over which to search
    test    -> for convenience, this may specify a function to call to perform
               the test. This is not expected to be efficient.
  returns: 
    first index where condition is true (or test returns true, if given)
    or None if the condition was never met

यदि सरणी में ndim> 1 है, तो सामान्य प्रसारण नियमों का उपयोग करके परीक्षण किए जाते हैं।
तो उदाहरण के लिए, यदि मेरे पास आकार (2,3) वाला सरणी है, तो निम्नलिखित मान्य होगा:

  ## find first row with all values=0
  array.find(0, testOp='eq', arrayOp='all', axis=0)
  ## equivalent to:
  for i in range(array.shape[axis]):
    if (array[i] == 0).all():
      return i

  ## find first column with any element greater than its corresponding element in col
  col = array([1,2])
  array.find(col, testOp='gt', arrayOp='any', axis=1)
  ## equivalent to:
  for i in range(array.shape[axis]):
    if (array[:,i] == col.any():
      return i

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

import numpy as np
from itertools import chain, izip


def find(a, predicate, chunk_size=1024):
    """
    Find the indices of array elements that match the predicate.

    Parameters
    ----------
    a : array_like
        Input data, must be 1D.

    predicate : function
        A function which operates on sections of the given array, returning
        element-wise True or False for each data value.

    chunk_size : integer
        The length of the chunks to use when searching for matching indices.
        For high probability predicates, a smaller number will make this
        function quicker, similarly choose a larger number for low
        probabilities.

    Returns
    -------
    index_generator : generator
        A generator of (indices, data value) tuples which make the predicate
        True.

    See Also
    --------
    where, nonzero

    Notes
    -----
    This function is best used for finding the first, or first few, data values
    which match the predicate.

    Examples
    --------
    >>> a = np.sin(np.linspace(0, np.pi, 200))
    >>> result = find(a, lambda arr: arr > 0.9)
    >>> next(result)
    ((71, ), 0.900479032457)
    >>> np.where(a > 0.9)[0][0]
    71


    """
    if a.ndim != 1:
        raise ValueError('The array must be 1D, not {}.'.format(a.ndim))

    i0 = 0
    chunk_inds = chain(xrange(chunk_size, a.size, chunk_size), 
                 [None])

    for i1 in chunk_inds:
        chunk = a[i0:i1]
        for inds in izip(*predicate(chunk).nonzero()):
            yield (inds[0] + i0, ), chunk[inds]
        i0 = i1

In [1]: from np_utils import find

In [2]: import numpy as np

In [3]: import numpy.random    

In [4]: np.random.seed(1)

In [5]: a = np.random.randn(1e8)

In [6]: a.min(), a.max()
Out[6]: (-6.1194900990552776, 5.9632246301166321)

In [7]: next(find(a, lambda a: np.abs(a) > 6))
Out[7]: ((33105441,), -6.1194900990552776)

In [8]: (np.abs(a) > 6).nonzero()
Out[8]: (array([33105441]),)

In [9]: %timeit (np.abs(a) > 6).nonzero()
1 loops, best of 3: 1.51 s per loop

In [10]: %timeit next(find(a, lambda a: np.abs(a) > 6))
1 loops, best of 3: 912 ms per loop

In [11]: %timeit next(find(a, lambda a: np.abs(a) > 6, chunk_size=100000))
1 loops, best of 3: 470 ms per loop

In [12]: %timeit next(find(a, lambda a: np.abs(a) > 6, chunk_size=1000000))
1 loops, best of 3: 483 ms per loop

मैं इसे देव-मेलिंग सूची में डाल दूंगा, लेकिन अगर पर्याप्त रुचि है तो मुझे इसे पीआर में बदलने में काफी खुशी होगी।

चीयर्स,

मुझे पता है कि यह 3 साल देर हो चुकी है, लेकिन क्या यह अब numpy में शामिल है? मैटलैब पृष्ठभूमि से आ रहा है यह कार्य मेरे लिए वास्तव में महत्वपूर्ण लगता है। एक पीआर की अत्यधिक सराहना की जाएगी (ऐसा नहीं है कि मैं डेवलपर्स में से एक हूं)।

मुझे इसमें भी दिलचस्पी होगी।

शायद यह स्पष्ट है, लेकिन चूंकि इसका उल्लेख नहीं किया गया था: आलसी बनाने के लिए np.all() और np.any() शायद और भी आसान (और आयाम> 1 के लिए स्पष्ट) होगा। वर्तमान में...

In [2]: zz = np.zeros(shape=10000000)

In [3]: zz[0] = 1

In [4]: %timeit -r 1 -n 1 any(zz)
1 loop, best of 1: 3.52 µs per loop

In [5]: %timeit -r 1 -n 1 np.any(zz)
1 loop, best of 1: 16.7 ms per loop

(क्षमा करें, मैं #3446 का रेफरी चूक गया था)

जैसा कि मैं काफी समय से इस समस्या का एक कुशल समाधान खोज रहा हूं और जैसा कि इस सुविधा का समर्थन करने की कोई ठोस योजना नहीं है, मैंने एक ऐसे समाधान के साथ आने की कोशिश की है जो पूरी तरह से पूर्ण और बहुमुखी नहीं है जैसा कि एपीआई ने सुझाव दिया था। ऊपर (विशेष रूप से केवल 1D सरणियों के लिए समर्थन), लेकिन इसका पूरी तरह से C में लिखे जाने का लाभ है और इसलिए यह कुशल लगता है।

आपको स्रोत और विवरण यहां मिलते हैं:

https://pypi.python.org/pypi?name=py_find_1st& :action=display

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

मुझे यह एक स्टैकएक्सचेंज पोस्ट से मिला है जो इस सुविधा की तलाश में है, जिसे 70k से अधिक बार देखा जा चुका है। @roebel क्या आपको कभी इस पर कोई प्रतिक्रिया मिली? क्या आप सुविधा के लिए केवल एक पीआर डाल सकते हैं, जिस पर अधिक ध्यान दिया जा सकता है?

नहीं, मुझे कभी कोई प्रतिक्रिया नहीं मिली, लेकिन कुछ लोगों ने स्पष्ट रूप से बिना किसी समस्या के पैकेज का उपयोग किया।
बीटीडब्ल्यू, एनाकोंडा लिनक्स और मैकोज़ के लिए मैंने एनाकोंडा इंस्टॉलर बनाया है

https://anaconda.org/roebel/py_find_1st

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

क्या " प्राथमिकता: सामान्य " को हटाने का मतलब यह है कि इस महत्वपूर्ण विशेषता पर किसी तरह कम ध्यान दिया जाएगा?

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

संभवत: यहां #8528 को इंगित करने के लिए उपयोगी है, जो नाममात्र रूप से लगभग all_equal है लेकिन इसे इसके कार्यान्वयन भागों के रूप में देखा जा सकता है। दरअसल, https://github.com/numpy/numpy/pull/8528#issuecomment -365358119 में, @ahaldane स्पष्ट रूप से एक नए gufunc all_equal के बजाय सभी तुलना ऑपरेटरों पर first कमी विधि लागू करने का सुझाव देता है all_equal ।

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

इस मुद्दे को (कम से कम) 2012 से जाना जाता है। nonzero(A)[0][0] को सभी A की खोज से रोकने के तरीके पर कोई अपडेट?

क्या यह तथाकथित पाइथोनिक तरीका है जो हमेशा सभी तत्वों को स्कैन करता है?

@yunyoulu : यह ufunc तरीका है। आइए एक कदम पीछे हटें और एक बहु-चरणीय गणना की सामान्य प्रक्रिया को numpy में देखें, और इसमें कितने पास होते हैं:

1. np.argwhere(x)[0] - डेटा का 1 पास करता है
2. np.argwhere(f(x))[0] - डेटा के 2 पास करता है
3. np.argwhere(f(g(x)))[0] - डेटा के 3 पास करता है

एक विकल्प यह होगा कि एक np.first फ़ंक्शन या इसी तरह का परिचय दिया जाए - जो तब निम्न जैसा दिखेगा, जहां k <= 1 इस पर निर्भर करता है कि पहला तत्व कहां है:

1. np.first(x)[0] - डेटा का 0+k पास करता है
2. np.first(f(x))[0] - डेटा का 1+k पास करता है
3. np.first(f(g(x)))[0] - डेटा के 2+k पास करता है

यहां पूछने का सवाल है - क्या यह बचत वास्तव में इतनी मूल्यवान है? Numpy मूल रूप से एक आलसी कंप्यूटिंग प्लेटफॉर्म नहीं है, और गणना के अंतिम चरण को आलसी बनाना विशेष रूप से मूल्यवान नहीं है यदि पिछले सभी चरण नहीं थे।

@ एरिक-वाइसर

मुझे नहीं लगता कि यह बिल्कुल सही कहा गया है। अगर किसी समस्या के लिए k = 10 , तो यह 1+10=11 के डेटा का पास नहीं है np.first(f(x))[0]

(संक्षिप्तता के लिए @ eric-wieser द्वारा संपादित, यह बातचीत पहले से ही बहुत लंबी है)

उपयोग का मामला जहां मुझे इस कार्यक्षमता की सबसे अधिक आवश्यकता है, जब A एक बड़ा टेंसर है A.shape = (n_1, n_2, ..., n_m) । ऐसे मामले में, np.first(A) को n_1*n_2*...*n_m (एक संभावित महत्वपूर्ण बचत) के बजाय A के केवल k तत्वों को देखने की आवश्यकता होगी।

मुझे सबसे अधिक इस कार्यक्षमता की आवश्यकता तब दिखाई देती है जब A एक बड़ा टेंसर होता है

संभावित रूप से इस मामले में आप पहले से ही डेटा का कम से कम एक पूर्ण पास कर चुके हैं - इसलिए सबसे अच्छा आपको कोड मिल रहा है जो दो बार तेजी से चलता है।

यहां पूछने का सवाल है - क्या यह बचत वास्तव में इतनी मूल्यवान है? Numpy मूल रूप से एक आलसी कंप्यूटिंग प्लेटफॉर्म नहीं है, और गणना के अंतिम चरण को आलसी बनाना विशेष रूप से मूल्यवान नहीं है यदि पिछले सभी चरण नहीं थे।

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

साथ ही, अंतःक्रियात्मक रूप से काम करते समय (जुपिटर इत्यादि), अक्सर आप अलग-अलग कोशिकाओं में डेटा के "पास" करते हैं, ताकि आप पूरे सेल को भी तेज कर सकें।

np.first(f(x))[0] - डेटा का 1+k पास करता है

@ eric-wieser वास्तव में जब मैंने 2017 में इस मुद्दे को देखा तो मैं वास्तव में उम्मीद कर रहा था कि यह एक तरह का पहला कदम होगा np.firstwhere(x, array_or_value_to_compare) , जो वास्तव में एक विशिष्ट मामला है - लेकिन मेरे अनुभव में महत्वपूर्ण - f(x) का

@toobaz : मुझे लगता है कि उस उदाहरण में आपके पास f = lambda x: x == value_to_compare है।

यही कारण है कि मैं इस रास्ते पर जाने से बिल्कुल भी सावधान हूं (cc @bersbersbers)। यदि आप सावधान नहीं हैं, तो हम (वर्तनी सट्टा) के साथ समाप्त होते हैं:

1. np.first(x) - एक पास बनाम गैर-शून्य सहेजें
2. np.first_equal(x, v) - एक पास सेव करें बनाम first(np.equal(x, v))
3. np.first_square_equal(x*x, v) - एक पास सेव करें बनाम first_equal(np.square(x), v)

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

np.first के पक्ष में एक तर्क - यदि हम इसे लागू करते हैं, तो numba विशेष मामले में ऐसा हो सकता है कि np.first(x*x == v) _एक सुंबा संदर्भ के भीतर_ वास्तव में _does_ एक ही पास करते हैं।

वैसे भी यह जानना अच्छा है कि आलसी चीजों को numpy में करना असंभव है, जो इस मुद्दे की वर्तमान स्थिति को स्पष्ट करता है।

हालाँकि, मैं सहज महसूस नहीं करता जब प्रदर्शन ट्वीक को केवल मापनीयता में माना जाता है।

आइए एक सरल प्रश्न पूछें: क्या आज पर्सनल कंप्यूटर का विस्तार हो रहा है? उत्तर निश्चित रूप से नहीं है। तीन साल पहले जब आप एक मानक लैपटॉप खरीदते हैं, तो वे 8GB मेमोरी से लैस होते हैं; और अब भी आपको बाजार में 8GB मिलेगा। हालाँकि, प्रत्येक सॉफ़्टवेयर पहले की तुलना में 2x या 4x अधिक मेमोरी का उपयोग कर रहा है। कम से कम वर्कस्टेशन उसी तरह स्केलिंग नहीं कर रहे हैं जैसे क्लस्टर हैं।

किसी फ़ंक्शन को उसकी जटिलता को बिल्कुल भी बदले बिना 10x धीमा बनाना एक डेटा वैज्ञानिक को पागल करने के लिए पर्याप्त है। इससे भी बुरी बात यह है कि प्रोफाइलिंग के माध्यम से अड़चन का पता चलने पर भी वह कुछ भी सुंदर नहीं कर सकता।

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

@toobaz : मुझे लगता है कि उस उदाहरण में आपके पास f = lambda x: x == value_to_compare है।

सही

यही कारण है कि मैं इस रास्ते पर जाने से बिल्कुल भी सावधान हूं (cc @bersbersbers)। यदि आप सावधान नहीं हैं, तो हम (वर्तनी सट्टा) के साथ समाप्त होते हैं:

1. `np.first(x)` - save a pass vs nonzero

2. `np.first_equal(x, v)` - save a pass vs `first(np.equal(x, v))`

3. `np.first_square_equal(x*x, v)` - save a pass vs `first_equal(np.square(x), v)`

मैं आपकी चिंता को समझता हूं, लेकिन मैं कभी भी np.first_square_equal नहीं मांगूंगा, ठीक वैसे ही जैसे मैं कभी नहीं पूछूंगा (और कोई नहीं, मुझे आशा है, पूछा) np.square_where के लिए। और हां, मुझे लगता है कि इसका मतलब है कि यदि आप 3 करते हैं तो डेटा का पूरा पास बनाना है। लेकिन v एक बार बनाया जाता है, और मुझे इसके ऊपर x के कई अलग-अलग मूल्यों को देखने की आवश्यकता हो सकती है। . उदाहरण के लिए (उदाहरण के लिए सरलता के लिए वापस आना 2.), मैं यह सत्यापित करना चाहता हूं कि मेरी सभी 30 संभावित श्रेणियां मेरे 10 ^ 9 आइटम सरणी में दिखाई देती हैं - और मुझे दृढ़ता से संदेह है कि वे सभी पहले 10 ^ 3 तत्वों में दिखाई देते हैं।

तो पहले मुझे अपनी पिछली टिप्पणी को स्पष्ट करने दें: मैं np.firstwhere(x, array_or_value_to_compare) को एक फ़ंक्शन के रूप में चाहता हूं जो मेरे अंतर्ज्ञान को पूरा करता है, लेकिन 2017 में मेरे पास जो कम्प्यूटेशनल मुद्दे थे, वे np.first के साथ भी हल हो गए होंगे।

दूसरा, मुद्दा यह है - मुझे लगता है - सिर्फ एक कॉल के चलने का समय नहीं। यह सच है कि मुझे 2 और 3 करने के लिए वैसे भी डेटा का पूरा पास बनाने की आवश्यकता है ... बार-बार होने वाला ऑपरेशन।

मैं आपका बिंदु देखता हूं कि np.first वास्तव में मानक numpy दृष्टिकोण से विचलित हो जाता है, मुझे लगता है कि यह अच्छी तरह से लागू करने के लिए गैर-तुच्छ हो सकता है ... जो मैं नहीं देखता वह यह है कि यह बाकी एपीआई को "संक्रमित" कैसे करेगा, या खुद का एक बड़ा एपीआई विकसित करें।

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

नमस्कार पॉल,

मैंने आपके समाधान की तुलना np.flatnonzero और मेरे py_find_1st एक्सटेंशन से करते हुए एक छोटा बेंचमार्क बनाया है।

आप बेंचमार्क संलग्न पाते हैं।

यहां परिणाम

(आधार) m3088.roebel: (परीक्षण) (g:मास्टर)514> ./benchmark.py
utf1st.find_1st(rr, सीमा, utf1st.cmp_equal)::
रनटाइम 0.131s
np.flatnonzero(rr==limit)[0]::
रनटाइम 2.121s
अगला ((द्वितीय के लिए, वीवी गणना में (आरआर) अगर वीवी == सीमा))::
रनटाइम 1.612s

इसलिए जबकि आपका प्रस्तावित समाधान फ्लैटनोनजेरो की तुलना में 25% तेज है क्योंकि इसकी आवश्यकता नहीं है
परिणाम सरणी बनाना, यह अभी भी py_find_1st.find_1st से ~12धीमा है।

श्रेष्ठ
एक्सेल

संपादित करें:
ऐसा प्रतीत होता है कि जिस संदेश का मैंने मेल द्वारा उत्तर दिया था वह गायब हो गया है, और मेरे मेल से जुड़ा बेंचमार्क भी गायब हो गया है। बेंचमार्क यहाँ है

https://github.com/roebel/py_find_1st/blob/master/test/benchmark.py

शोर के लिए खेद है।

15/05/2020 17:33 को पीके ने लिखा:

कैसे के बारे में |next(i for i, v in enumerate(x) if v)|?

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