Numpy: 0이 아닌 첫 번째 요소(Trac #1673)

_trac 사용자 tom3118이 2010-11-13에 작성했습니다_

관련 사용 사례는 다음과 같습니다.
filter(test,A)[0]
A 가 길거나 test 가 비쌉니다.

__@rgommers 는 2011-03-24에 작성했습니다.

0이 아닌 첫 번째 값일 필요는 없으며 먼저 모든 값이 유용할 것입니다.

__@rgommers 는 2011-03-24에 작성했습니다.

#2333에서 언급했듯이 1-D에 대한 의미는 명확합니다. >1-D의 경우 의미론이 논의 대상입니다.

아마도 축에 대한 반복 순서를 결정하는 키워드가 작동할 것입니다. 또는 >1-D에 대해 단순히 정의되지 않을 수 있습니다.

_trac 사용자 lcampagn이 2011-07-09에 작성했습니다.

numpy에서 find_first에 대한 많은 요청을 보았지만 이러한 요청의 대부분은 "x보다 작은 첫 번째 값 찾기" 또는 "0이 아닌 첫 번째 값 찾기"와 같이 미묘하게 다른(호환되지 않는) 요구 사항이 있습니다. 다음 기능 사양을 제안합니다.

  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

요전에 이 기능이 필요했기 때문에 이에 대해 잘 살펴보았고 적절하게 빠른 결과를 얻으려면 C 솔루션이 필요하다고 확신했지만 파이썬으로 작성된 청크 접근 방식은 적절하게 빠르고 많은 내 경우에는 부팅하기에 더 유연합니다.

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

나는 이것을 개발자 메일링 리스트에 올릴 것이지만, 충분한 관심이 있다면 그것을 PR로 바꿀 만큼 충분히 기쁠 것입니다.

건배,

나는 이것이 3 년 늦었다는 것을 알고 있지만 이것이 지금 numpy에 포함되어 있습니까? Matlab 배경에서 나온 이 기능은 저에게 정말 중요한 것 같습니다. PR은 높이 평가될 것입니다(임시 개발자 중 한 명이 아님).

나도 이것에 관심이 있을 것이다.

어쩌면 당연하지만 언급되지 않았기 때문에 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에 대한 참조를 놓쳤습니다.)

나는 꽤 오랫동안 이 문제의 효율적인 솔루션을 찾고 있었고 이 기능을 지원할 구체적인 계획이 없는 것 같아서 api가 제안한 것처럼 완전하지 않고 다용도가 아닌 솔루션을 찾으려고 노력했습니다. 위에서 (특히 현재로서는 1D 배열만 지원함) C로 완전히 작성된다는 이점이 있으므로 오히려 효율적으로 보입니다.

출처와 세부 정보는 다음에서 찾을 수 있습니다.

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

구현에 대한 모든 의견, 특히 부울 배열을 전달하고 해당 PyPi 페이지에 설명된 첫 번째 참 값을 검색할 때 다소 놀라운 성능 문제에 대한 질문에 감사드립니다.

70,000번 이상 조회된 이 기능을 찾고 있는 stackexchange 게시물 에서 이것을 찾았습니다. @roebel 이에 대한 피드백을 받은 적이 있습니까? 더 많은 관심을 끌 수 있는 기능에 대한 PR을 넣을 수 있습니까?

피드백을 받은 적은 없지만 몇몇 사람들은 분명히 문제 없이 패키지를 사용했습니다.
BTW, 나는 아나콘다 설치 프로그램을 만들었습니다.

https://anaconda.org/roebel/py_find_1st

PR과 관련하여 numpy에 쉽게 병합될 수 있도록 이를 조정하는 데 필요한 노력을 조사해야 합니다. API 변경 및 확장에 대해 토론할 시간이 없습니다.

" priority:normal "을 제거하면 이 중요한 기능에 대한 관심이 줄어들까요?

우선 순위는 레이블 없이 여전히 "보통"입니다. 이 문제는 실제로 PR을 만들고 문서화 및 벤치마크를 포함한 승인 프로세스를 통해 푸시할 챔피언이 필요합니다.

명목상 all_equal 정도이지만 이것의 일부를 구현하는 것으로 볼 수 있는 #8528을 가리키는 것이 여기에서 유용할 것입니다. 실제로 https://github.com/numpy/numpy/pull/8528#issuecomment -365358119에서 @ahaldane 은 새로운 gufunc all_equal 대신 모든 비교 연산자에 first 감소 방법을 구현하는 것을 명시적으로 제안합니다. all_equal .

이것은 또한 상당한 양의 구현이 적응되기를 기다리고 있음을 의미합니다(gufunc에서 새로운 축소 방법으로의 사소한 변경은 아니며 모든 ufunc에 대한 새로운 방법을 원하는지 여부에 대한 질문이 있습니다. first 는 거의 의미가 없습니다.

이 문제는 (적어도) 2012년 이후로 알려져 있습니다. nonzero(A)[0][0] 가 A 전체를 검색하지 못하도록 하는 방법에 대한 업데이트가 있습니까?

모든 요소를 ​​항상 스캔하는 이른바 Pythonic 방식입니까?

@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는 근본적으로 게으른 컴퓨팅 플랫폼이 아니며 계산의 마지막 단계를 게으른 것으로 만드는 것은 이전의 모든 단계가 그렇지 않은 경우 특히 가치가 없습니다.

@eric-wieser

저는 그 말이 옳지 않다고 생각합니다. 어떤 문제에 대해 k = 10 인 경우 np.first(f(x))[0] 에 대한 데이터 전달이 1+10=11 가 아닙니다.

(간결함을 위해 @eric-wieser가 편집했습니다. 이 대화는 이미 너무 깁니다)

이 기능의 필요성을 가장 많이 느끼는 사용 사례는 A 가 A.shape = (n_1, n_2, ..., n_m) $ 가 있는 큰 텐서일 때입니다. 이러한 경우 np.first(A) 는 n_1*n_2*...*n_m A k 요소만 확인해야 합니다(잠재적으로 상당한 절감 효과).

이 기능의 필요성은 A가 큰 텐서일 때 가장 많이 봅니다.

아마도 이 경우에 당신은 이미 데이터의 전체 패스를 한 번 이상 완료했으므로 기껏해야 두 배 빠르게 실행되는 코드를 얻을 수 있습니다.

여기서 물어볼 질문은 - 이 절약이 정말 그만한 가치가 있습니까? Numpy는 근본적으로 게으른 컴퓨팅 플랫폼이 아니며 계산의 마지막 단계를 게으른 것으로 만드는 것은 이전의 모든 단계가 그렇지 않은 경우 특히 가치가 없습니다.

이는 확립된 경우 "다른 것도 계산 중이고 여전히 느리기 때문에" 계산 성능을 개선하기 위한 거의 모든 노력을 낭비하는 것을 정당화하는 데 사용될 수 있다는 흥미로운 관점입니다. (기후변화 행동을 부정하는 사람들이 사용하는 것과 같은 주장입니다. 다른 나라가 무언가를 할 때까지 우리나라에서 무언가를 하는 것은 누구에게도 도움이 되지 않습니다.) 나는 전혀 확신하지 못합니다. k가 매우 작은 잠재적으로 매우 작은 1/k만큼 계산의 일부 속도를 높일 수 있는 기회가 있다면, 제 생각에는 그럴 가치가 있습니다.

또한 대화식으로 작업할 때(Jupyter 등) 매우 자주 별도의 셀에서 데이터 "전달"을 수행하므로 결국 전체 셀의 속도도 높일 수 있습니다.

np.first(f(x))[0] - 데이터의 1+k 패스를 수행합니다.

@eric-wieser 실제로 2017년에 이 문제를 보았을 때 np.firstwhere(x, array_or_value_to_compare) 일종의 np.firstwhere(x, array_or_value_to_compare) 를 향한 첫 번째 단계가 되기를 정말로 바랐습니다. 이는 실제로 특정 사례이지만 제 경험상 중요합니다. f(x) .

@toobaz : 그 예에서 f = lambda x: x == value_to_compare 가 있다고 가정합니다.

이것이 바로 내가 이 길을 가는 것을 조심하는 이유입니다(cc @bersbersbers). 주의하지 않으면 다음과 같이 끝납니다.

1. np.first(x) - 패스 대 0이 아닌 값 저장
2. np.first_equal(x, v) - 패스 저장 vs first(np.equal(x, v))
3. np.first_square_equal(x*x, v) - 패스 저장 vs first_equal(np.square(x), v)

이것이 전혀 확장되지 않는다는 것은 매우 분명해야 하며 어딘가에 선을 그려야 합니다. 나는 1이 허용되는 것에 약간 찬성하지만 2가 허용되는 것은 이미 API 표면적의 폭발적이며 3은 나에게 매우 현명하지 못한 것 같습니다.

np.first 에 찬성하는 한 가지 주장 - 이를 구현하면 np.first(x*x == v) _numa 컨텍스트 내에서_ 실제로는 단일 패스를 _수행_하도록 numba 를 특수 케이스로 지정할 수 있습니다.

어쨌든 문제의 현재 상태를 명확히 하는 numpy에서 게으른 작업을 수행하는 것이 불가능하다는 것을 아는 것이 좋습니다.

그러나 성능 조정이 확장성에서만 고려되는 경우에는 편안함을 느끼지 못합니다.

간단한 질문을 해보자. 오늘날 개인용 컴퓨터가 확장되고 있습니까? 대답은 확실히 NO 입니다. 3년 전 표준 노트북을 구입하면 8GB 메모리가 장착되어 있습니다. 이제 시장에서 여전히 8GB를 찾을 수 있습니다. 그러나 모든 소프트웨어는 이전보다 2배 또는 4배 더 많은 메모리를 사용하고 있습니다. 적어도 워크스테이션은 클러스터와 같은 방식으로 확장되지 않습니다.

복잡성을 전혀 변경하지 않고 함수를 10배 느리게 만드는 것은 한 데이터 과학자를 미치게 만들기에 충분합니다. 설령 프로파일링을 통해 병목 현상을 파악하더라도 그가 할 수 있는 우아한 일은 없습니다.

내가 자세히 설명하려고 하는 것은 게으른 처리를 수행할 수 있는 능력을 갖는 것이 항상 바람직하며 시스템의 응답성과 언어를 사용하는 사람들의 생산성에 중요할 수 있다는 것입니다. 라이브러리 개발의 어려움이나 작업량은 이러한 기능을 구현하지 않는 것에 대한 아주 좋은 변명이며 확실히 이해할 수 있지만 유용하지 않다고 말하지 마십시오.

@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)`

나는 당신의 우려를 이해하지만 $#$3 np.square_where #$ 에 대해 묻지 않을 것(아무도 묻지 않기를 바랍니다)처럼 정확히 np.first_square_equal 를 요구하지 않을 것입니다. 그리고 예, 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 접근 방식에서 실제로 벗어나는 당신의 요점을 보았고, 잘 구현하는 것이 중요하지 않을 수 있다는 것을 알았습니다... 내가 보지 못하는 것은 그것이 나머지 API를 "감염"시키는 방법입니다. 또는 자체적으로 대규모 API를 확장할 수 있습니다.

즉, 실제로 numpy 범위를 벗어났다고 생각한다면 대신 작은 독립 패키지의 범위가 있을 수 있습니다.

안녕하세요 폴,

귀하의 솔루션을 np.flatnonzero 및 py_find_1st 확장과 비교하는 작은 벤치마크를 만들었습니다.

벤치마크가 첨부되어 있습니다.

여기 결과

(기본) m3088.roebel: (테스트) (g:master)514> ./benchmark.py
utf1st.find_1st(rr, 제한, utf1st.cmp_equal)::
런타임 0.131초
np.flatnonzero(rr==한계)[0]::
런타임 2.121초
next((ii의 경우 ii, vv == limit)인 경우 enumerate(rr)의 vv)::
런타임 1.612초

따라서 제안된 솔루션은 필요하지 않기 때문에 flatnonzero보다 25% 빠릅니다.
결과 배열을 생성할 때 여전히 py_find_1st.find_1st보다 ~12 느립니다.

최상의
악셀

편집하다:
메일로 답장을 보낸 메시지가 사라지고 내 메일에 벤치마크도 첨부된 것 같습니다. 벤치마크는 여기

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

소음 죄송합니다.

2020-05-15 17:33에 PK는 다음과 같이 썼습니다.

|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 .