numpy 배열에서 가장 가까운 값 찾기
numpy 배열에서 가장 가까운 값을 찾으려면 어떻게 해야 합니까?예:
np.find_nearest(array, value)
import numpy as np
def find_nearest(array, value):
array = np.asarray(array)
idx = (np.abs(array - value)).argmin()
return array[idx]
사용 예:
array = np.random.random(10)
print(array)
# [ 0.21069679 0.61290182 0.63425412 0.84635244 0.91599191 0.00213826
# 0.17104965 0.56874386 0.57319379 0.28719469]
print(find_nearest(array, value=0.5))
# 0.568743859261
어레이가 정렬되어 있고 규모가 매우 큰 경우에는 다음과 같은 솔루션이 훨씬 더 빠릅니다.
def find_nearest(array,value):
idx = np.searchsorted(array, value, side="left")
if idx > 0 and (idx == len(array) or math.fabs(value - array[idx-1]) < math.fabs(value - array[idx])):
return array[idx-1]
else:
return array[idx]
이것은 매우 큰 어레이로 확장됩니다.배열이 이미 정렬되었다고 가정할 수 없는 경우 위의 내용을 쉽게 수정하여 메서드로 정렬할 수 있습니다.스몰 어레이에는 과잉이지만, 일단 크기가 커지면 훨씬 더 빨라집니다.
약간 수정하면 위의 답변은 임의의 치수(1d, 2d, 3d, ...)의 어레이에서 작동합니다.
def find_nearest(a, a0):
"Element in nd array `a` closest to the scalar value `a0`"
idx = np.abs(a - a0).argmin()
return a.flat[idx]
또는 한 줄로 표기:
a.flat[np.abs(a - a0).argmin()]
답변 요약: 정렬된 경우array다음으로 이등분 코드(아래 참조)가 가장 빠르게 수행됩니다.대규모 어레이의 경우 최대 100~1000배, 소규모 어레이의 경우 최대 2~100배 고속입니다.는 필요하지 않습니다.되어 있지 않은 arrayarrayn한 후 (n logn)의 경우는 O(n logn)로 분할하는 것을 해 주십시오.array2번입니다.
먼저 가장 가까운 값이 무엇을 의미하는지 명확히 해야 합니다.흔히 array=[0,0.7,2.1], value=1.95와 같이 Abscissa의 간격을 원하는 경우가 많습니다. 답은 idx=1입니다.이것이 당신이 필요하다고 생각되는 경우입니다(그렇지 않은 경우, 간격을 찾으면 후속 조건문을 사용하여 다음을 매우 쉽게 수정할 수 있습니다).이 작업을 수행하는 최적의 방법은 이등분(먼저 제공하겠습니다.numpy는 전혀 필요하지 않고 numpy 함수를 사용하는 것보다 더 빠릅니다.numpy 함수는 중복 작업을 수행하기 때문입니다).그럼, 다른 유저와 타이밍을 비교해 보겠습니다.
양분:
def bisection(array,value):
'''Given an ``array`` , and given a ``value`` , returns an index j such that ``value`` is between array[j]
and array[j+1]. ``array`` must be monotonic increasing. j=-1 or j=len(array) is returned
to indicate that ``value`` is out of range below and above respectively.'''
n = len(array)
if (value < array[0]):
return -1
elif (value > array[n-1]):
return n
jl = 0# Initialize lower
ju = n-1# and upper limits.
while (ju-jl > 1):# If we are not yet done,
jm=(ju+jl) >> 1# compute a midpoint with a bitshift
if (value >= array[jm]):
jl=jm# and replace either the lower limit
else:
ju=jm# or the upper limit, as appropriate.
# Repeat until the test condition is satisfied.
if (value == array[0]):# edge cases at bottom
return 0
elif (value == array[n-1]):# and top
return n-1
else:
return jl
이제 다른 답변에서 코드를 정의하면 각각 인덱스를 반환합니다.
import math
import numpy as np
def find_nearest1(array,value):
idx,val = min(enumerate(array), key=lambda x: abs(x[1]-value))
return idx
def find_nearest2(array, values):
indices = np.abs(np.subtract.outer(array, values)).argmin(0)
return indices
def find_nearest3(array, values):
values = np.atleast_1d(values)
indices = np.abs(np.int64(np.subtract.outer(array, values))).argmin(0)
out = array[indices]
return indices
def find_nearest4(array,value):
idx = (np.abs(array-value)).argmin()
return idx
def find_nearest5(array, value):
idx_sorted = np.argsort(array)
sorted_array = np.array(array[idx_sorted])
idx = np.searchsorted(sorted_array, value, side="left")
if idx >= len(array):
idx_nearest = idx_sorted[len(array)-1]
elif idx == 0:
idx_nearest = idx_sorted[0]
else:
if abs(value - sorted_array[idx-1]) < abs(value - sorted_array[idx]):
idx_nearest = idx_sorted[idx-1]
else:
idx_nearest = idx_sorted[idx]
return idx_nearest
def find_nearest6(array,value):
xi = np.argmin(np.abs(np.ceil(array[None].T - value)),axis=0)
return xi
이제 코드 시간을 재보겠습니다.메서드 1, 2, 4, 5는 인터벌을 올바르게 제공하지 않습니다.방법 1, 2, 4는 배열의 가장 가까운 점으로 반올림하고(예: > = 1.5 - > 2) 방법 5는 항상 반올림합니다(예: 1.45 - > 2).메서드 3, 6, 그리고 물론 이등분만이 적절한 간격을 제공합니다.
array = np.arange(100000)
val = array[50000]+0.55
print( bisection(array,val))
%timeit bisection(array,val)
print( find_nearest1(array,val))
%timeit find_nearest1(array,val)
print( find_nearest2(array,val))
%timeit find_nearest2(array,val)
print( find_nearest3(array,val))
%timeit find_nearest3(array,val)
print( find_nearest4(array,val))
%timeit find_nearest4(array,val)
print( find_nearest5(array,val))
%timeit find_nearest5(array,val)
print( find_nearest6(array,val))
%timeit find_nearest6(array,val)
(50000, 50000)
100000 loops, best of 3: 4.4 µs per loop
50001
1 loop, best of 3: 180 ms per loop
50001
1000 loops, best of 3: 267 µs per loop
[50000]
1000 loops, best of 3: 390 µs per loop
50001
1000 loops, best of 3: 259 µs per loop
50001
1000 loops, best of 3: 1.21 ms per loop
[50000]
1000 loops, best of 3: 746 µs per loop
대규모 어레이의 경우 이등분할은 차상위 180us 및 최장 1.21ms와 비교하여 4us입니다(~100~1000배 빠릅니다).소규모 어레이의 경우 최대 2~100배 고속입니다.
@Dimitri가입니다.valuesvalues다차원 배열 가능):
# `values` should be sorted
def get_closest(array, values):
# make sure array is a numpy array
array = np.array(array)
# get insert positions
idxs = np.searchsorted(array, values, side="left")
# find indexes where previous index is closer
prev_idx_is_less = ((idxs == len(array))|(np.fabs(values - array[np.maximum(idxs-1, 0)]) < np.fabs(values - array[np.minimum(idxs, len(array)-1)])))
idxs[prev_idx_is_less] -= 1
return array[idxs]
벤치마크
하는 것보다 for@ solutionDemitri'로
>>> %timeit ar=get_closest(np.linspace(1, 1000, 100), np.random.randint(0, 1050, (1000, 1000)))
139 ms ± 4.04 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
>>> %timeit ar=[find_nearest(np.linspace(1, 1000, 100), value) for value in np.random.randint(0, 1050, 1000*1000)]
took 21.4 seconds
벡터 배열에서 가장 가까운 벡터를 찾기 위한 확장입니다.
import numpy as np
def find_nearest_vector(array, value):
idx = np.array([np.linalg.norm(x+y) for (x,y) in array-value]).argmin()
return array[idx]
A = np.random.random((10,2))*100
""" A = array([[ 34.19762933, 43.14534123],
[ 48.79558706, 47.79243283],
[ 38.42774411, 84.87155478],
[ 63.64371943, 50.7722317 ],
[ 73.56362857, 27.87895698],
[ 96.67790593, 77.76150486],
[ 68.86202147, 21.38735169],
[ 5.21796467, 59.17051276],
[ 82.92389467, 99.90387851],
[ 6.76626539, 30.50661753]])"""
pt = [6, 30]
print find_nearest_vector(A,pt)
# array([ 6.76626539, 30.50661753])
numpy를 사용하지 않으려면 다음과 같이 하십시오.
def find_nearest(array, value):
n = [abs(i-value) for i in array]
idx = n.index(min(n))
return array[idx]
다음은 비스칼라 "값" 배열을 처리하는 버전입니다.
import numpy as np
def find_nearest(array, values):
indices = np.abs(np.subtract.outer(array, values)).argmin(0)
return array[indices]
또는 입력이 스칼라일 경우 숫자 유형(예: int, float)을 반환하는 버전:
def find_nearest(array, values):
values = np.atleast_1d(values)
indices = np.abs(np.subtract.outer(array, values)).argmin(0)
out = array[indices]
return out if len(out) > 1 else out[0]
여기 @Ari Onasafari용 스키피가 있는 버전이 있습니다. "벡터 배열에서 가장 가까운 벡터를 찾으려면" 이라고 대답하십시오.
In [1]: from scipy import spatial
In [2]: import numpy as np
In [3]: A = np.random.random((10,2))*100
In [4]: A
Out[4]:
array([[ 68.83402637, 38.07632221],
[ 76.84704074, 24.9395109 ],
[ 16.26715795, 98.52763827],
[ 70.99411985, 67.31740151],
[ 71.72452181, 24.13516764],
[ 17.22707611, 20.65425362],
[ 43.85122458, 21.50624882],
[ 76.71987125, 44.95031274],
[ 63.77341073, 78.87417774],
[ 8.45828909, 30.18426696]])
In [5]: pt = [6, 30] # <-- the point to find
In [6]: A[spatial.KDTree(A).query(pt)[1]] # <-- the nearest point
Out[6]: array([ 8.45828909, 30.18426696])
#how it works!
In [7]: distance,index = spatial.KDTree(A).query(pt)
In [8]: distance # <-- The distances to the nearest neighbors
Out[8]: 2.4651855048258393
In [9]: index # <-- The locations of the neighbors
Out[9]: 9
#then
In [10]: A[index]
Out[10]: array([ 8.45828909, 30.18426696])
대규모 어레이의 경우 @Demitri가 제시한 (탁월한) 답변은 현재 best로 표시된 답변보다 훨씬 빠릅니다.그의 정확한 알고리즘을 다음 두 가지 방법으로 적용했습니다.
다음 함수는 입력 배열 정렬 여부에 관계없이 작동합니다.
아래 함수는 가장 가까운 값에 해당하는 입력 배열의 인덱스를 반환합니다. 이 값은 좀 더 일반적인 값입니다.
아래 함수는 @Demitri에 의해 작성된 원래 함수에 버그가 발생할 수 있는 특정 에지 케이스도 처리합니다.그렇지 않으면, 내 알고리즘은 그의 알고리즘과 같아.
def find_idx_nearest_val(array, value):
idx_sorted = np.argsort(array)
sorted_array = np.array(array[idx_sorted])
idx = np.searchsorted(sorted_array, value, side="left")
if idx >= len(array):
idx_nearest = idx_sorted[len(array)-1]
elif idx == 0:
idx_nearest = idx_sorted[0]
else:
if abs(value - sorted_array[idx-1]) < abs(value - sorted_array[idx]):
idx_nearest = idx_sorted[idx-1]
else:
idx_nearest = idx_sorted[idx]
return idx_nearest
모든 답은 효율적인 코드를 작성하기 위해 정보를 수집하는 데 도움이 됩니다.다만, 다양한 케이스에 최적화하기 위해 작은 Python 스크립트를 작성했습니다.제공된 어레이를 정렬하는 것이 가장 좋은 경우입니다.값의 의 인덱스를 하면, 「」가 .bisect모듈이 가장 시간 효율적입니다..numpy searchsorted장장효효 효다다다다다
import numpy as np
import bisect
xarr = np.random.rand(int(1e7))
srt_ind = xarr.argsort()
xar = xarr.copy()[srt_ind]
xlist = xar.tolist()
bisect.bisect_left(xlist, 0.3)
[63]에서: %time bisect.bisect_left(xlist, 0.3) CPU 시간: 사용자 0 ns, 시스템: 0 ns, 합계: 0 ns 벽면 시간: 22.2 µs
np.searchsorted(xar, 0.3, side="left")
입력 [64]: %time np.searchsorted(xar, 0.3, side="left") CPU 시간: 사용자 0ns, 시스템: 0ns, 총: 0ns 벽면 시간: 98.9µs
randpts = np.random.rand(1000)
np.searchsorted(xar, randpts, side="left")
%time np.searchsorted(xar, randpts, side="left") CPU 시간: 사용자 4ms, 시스템: 0ns, 총: 4ms 벽면 시간: 1.2ms
곱셈 규칙을 따르면 numpy는 최대 100ms가 소요됩니다. 이는 최대 83배 더 빠릅니다.
내 생각에 가장 버마적인 방법은 다음과 같다.
num = 65 # Input number
array = np.random.random((10))*100 # Given array
nearest_idx = np.where(abs(array-num)==abs(array-num).min())[0] # If you want the index of the element of array (array) nearest to the the given number (num)
nearest_val = array[abs(array-num)==abs(array-num).min()] # If you directly want the element of array (array) nearest to the given number (num)
이게 기본 코드입니다.원한다면 기능으로 사용할 수 있습니다.
다음은 unutbu의 답변을 벡터화한 버전입니다.
def find_nearest(array, values):
array = np.asarray(array)
# the last dim must be 1 to broadcast in (array - values) below.
values = np.expand_dims(values, axis=-1)
indices = np.abs(array - values).argmin(axis=-1)
return array[indices]
image = plt.imread('example_3_band_image.jpg')
print(image.shape) # should be (nrows, ncols, 3)
quantiles = np.linspace(0, 255, num=2 ** 2, dtype=np.uint8)
quantiled_image = find_nearest(quantiles, image)
print(quantiled_image.shape) # should be (nrows, ncols, 3)
에 도움이 될 수 있습니다.ndarrays:
def find_nearest(X, value):
return X[np.unravel_index(np.argmin(np.abs(X - value)), X.shape)]
2D 배열의 경우 가장 가까운 요소의 i, j 위치를 결정하려면:
import numpy as np
def find_nearest(a, a0):
idx = (np.abs(a - a0)).argmin()
w = a.shape[1]
i = idx // w
j = idx - i * w
return a[i,j], i, j
다음은 2D 어레이와 연동되는 버전입니다.사용자가 있으면 Scipy의 cdist 기능을 사용하고 없으면 보다 간단한 거리 계산을 사용합니다.
기본적으로는 출력은 입력한 값에 가장 가까운 인덱스가 됩니다.단, 이 인덱스는 를 사용하여 변경할 수 있습니다.output하나가 되는 키워드'index','value', 또는'both',어디에'value'출력array[index]그리고.'both'출력index, array[index].
대규모 어레이의 경우는,kind='euclidean'기본 scipy cdist 함수는 메모리가 부족할 수 있습니다.
이것이 가장 빠른 해결책은 아닐지 모르지만 상당히 근접해 있습니다.
def find_nearest_2d(array, value, kind='cdist', output='index'):
# 'array' must be a 2D array
# 'value' must be a 1D array with 2 elements
# 'kind' defines what method to use to calculate the distances. Can choose one
# of 'cdist' (default) or 'euclidean'. Choose 'euclidean' for very large
# arrays. Otherwise, cdist is much faster.
# 'output' defines what the output should be. Can be 'index' (default) to return
# the index of the array that is closest to the value, 'value' to return the
# value that is closest, or 'both' to return index,value
import numpy as np
if kind == 'cdist':
try: from scipy.spatial.distance import cdist
except ImportError:
print("Warning (find_nearest_2d): Could not import cdist. Reverting to simpler distance calculation")
kind = 'euclidean'
index = np.where(array == value)[0] # Make sure the value isn't in the array
if index.size == 0:
if kind == 'cdist': index = np.argmin(cdist([value],array)[0])
elif kind == 'euclidean': index = np.argmin(np.sum((np.array(array)-np.array(value))**2.,axis=1))
else: raise ValueError("Keyword 'kind' must be one of 'cdist' or 'euclidean'")
if output == 'index': return index
elif output == 'value': return array[index]
elif output == 'both': return index,array[index]
else: raise ValueError("Keyword 'output' must be one of 'index', 'value', or 'both'")
가장 가까운 여러 개를 찾는 사용자의 경우 수락된 답변을 수정합니다.
import numpy as np
def find_nearest(array, value, k):
array = np.asarray(array)
idx = np.argsort(abs(array - value))[:k]
return array[idx]
참조: https://stackoverflow.com/a/66937734/11671779
import numpy as np
def find_nearest(array, value):
array = np.array(array)
z=np.abs(array-value)
y= np.where(z == z.min())
m=np.array(y)
x=m[0,0]
y=m[1,0]
near_value=array[x,y]
return near_value
array =np.array([[60,200,30],[3,30,50],[20,1,-50],[20,-500,11]])
print(array)
value = 0
print(find_nearest(array, value))
이것은 numpy search sorted를 사용하여 임의의 수의 쿼리를 처리하므로 입력 배열을 정렬한 후 동일한 속도로 처리할 수 있습니다.일반 그리드에서도 2D, 3D로 작동합니다.
#!/usr/bin/env python3
# keywords: nearest-neighbor regular-grid python numpy searchsorted Voronoi
import numpy as np
#...............................................................................
class Near_rgrid( object ):
""" nearest neighbors on a Manhattan aka regular grid
1d:
near = Near_rgrid( x: sorted 1d array )
nearix = near.query( q: 1d ) -> indices of the points x_i nearest each q_i
x[nearix[0]] is the nearest to q[0]
x[nearix[1]] is the nearest to q[1] ...
nearpoints = x[nearix] is near q
If A is an array of e.g. colors at x[0] x[1] ...,
A[nearix] are the values near q[0] q[1] ...
Query points < x[0] snap to x[0], similarly > x[-1].
2d: on a Manhattan aka regular grid,
streets running east-west at y_i, avenues north-south at x_j,
near = Near_rgrid( y, x: sorted 1d arrays, e.g. latitide longitude )
I, J = near.query( q: nq × 2 array, columns qy qx )
-> nq × 2 indices of the gridpoints y_i x_j nearest each query point
gridpoints = np.column_stack(( y[I], x[J] )) # e.g. street corners
diff = gridpoints - querypoints
distances = norm( diff, axis=1, ord= )
Values at an array A definded at the gridpoints y_i x_j nearest q: A[I,J]
3d: Near_rgrid( z, y, x: 1d axis arrays ) .query( q: nq × 3 array )
See Howitworks below, and the plot Voronoi-random-regular-grid.
"""
def __init__( self, *axes: "1d arrays" ):
axarrays = []
for ax in axes:
axarray = np.asarray( ax ).squeeze()
assert axarray.ndim == 1, "each axis should be 1d, not %s " % (
str( axarray.shape ))
axarrays += [axarray]
self.midpoints = [_midpoints( ax ) for ax in axarrays]
self.axes = axarrays
self.ndim = len(axes)
def query( self, queries: "nq × dim points" ) -> "nq × dim indices":
""" -> the indices of the nearest points in the grid """
queries = np.asarray( queries ).squeeze() # or list x y z ?
if self.ndim == 1:
assert queries.ndim <= 1, queries.shape
return np.searchsorted( self.midpoints[0], queries ) # scalar, 0d ?
queries = np.atleast_2d( queries )
assert queries.shape[1] == self.ndim, [
queries.shape, self.ndim]
return [np.searchsorted( mid, q ) # parallel: k axes, k processors
for mid, q in zip( self.midpoints, queries.T )]
def snaptogrid( self, queries: "nq × dim points" ):
""" -> the nearest points in the grid, 2d [[y_j x_i] ...] """
ix = self.query( queries )
if self.ndim == 1:
return self.axes[0][ix]
else:
axix = [ax[j] for ax, j in zip( self.axes, ix )]
return np.array( axix )
def _midpoints( points: "array-like 1d, *must be sorted*" ) -> "1d":
points = np.asarray( points ).squeeze()
assert points.ndim == 1, points.shape
diffs = np.diff( points )
assert np.nanmin( diffs ) > 0, "the input array must be sorted, not %s " % (
points.round( 2 ))
return (points[:-1] + points[1:]) / 2 # floats
#...............................................................................
Howitworks = \
"""
How Near_rgrid works in 1d:
Consider the midpoints halfway between fenceposts | | |
The interval [left midpoint .. | .. right midpoint] is what's nearest each post --
| | | | points
| . | . | . | midpoints
^^^^^^ . nearest points[1]
^^^^^^^^^^^^^^^ nearest points[2] etc.
2d:
I, J = Near_rgrid( y, x ).query( q )
I = nearest in `x`
J = nearest in `y` independently / in parallel.
The points nearest [yi xj] in a regular grid (its Voronoi cell)
form a rectangle [left mid x .. right mid x] × [left mid y .. right mid y]
(in any norm ?)
See the plot Voronoi-random-regular-grid.
Notes
-----
If a query point is exactly halfway between two data points,
e.g. on a grid of ints, the lines (x + 1/2) U (y + 1/2),
which "nearest" you get is implementation-dependent, unpredictable.
"""
Murky = \
""" NaNs in points, in queries ?
"""
__version__ = "2021-10-25 oct denis-bz-py"
언급URL : https://stackoverflow.com/questions/2566412/find-nearest-value-in-numpy-array
'programing' 카테고리의 다른 글
| fragment를 액티비티 그룹 내의 다른 fragment로 대체 (0) | 2022.09.24 |
|---|---|
| 방금 실행한 mysql 문을 취소하려면 어떻게 해야 하나요? (0) | 2022.09.24 |
| 이름 값 컬렉션으로의 URI 문자열 해석 (0) | 2022.09.24 |
| 오프라인 개발을 위해 Maven을 설정하려면 어떻게 해야 합니까? (0) | 2022.09.24 |
| 태그 열기/닫기 및 퍼포먼스 (0) | 2022.09.24 |