Есть ли простой способ, например, функция, чтобы найти ближайшее значение в массиве?
Пример:
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]
value = 0.5
print(find_nearest(array, value))
# 0.568743859261
return np.abs(array-value).min()
дает неправильный ответ. Это дает вам минимум абсолютного значения расстояния, и каким-то образом нам нужно вернуть фактическое значение массива. Мы могли бы добавитьvalue
и приблизиться, но абсолютное значение бросаетFutureWarning: 'argmin' is deprecated. Use 'idxmin' instead. The behavior of 'argmin' will be corrected to return the positional minimum in the future. Use 'series.values.argmin' to get the position of the minimum now.
Использованиеidxmin
вместоargmin
меня работает с решением выше. (v3.6.4)Если ваш массив отсортирован и он очень большой, это гораздо более быстрое решение:
Это масштабируется до очень больших массивов. Вы можете легко изменить вышеупомянутое для сортировки в методе, если вы не можете предположить, что массив уже отсортирован. Для маленьких массивов это излишне, но как только они становятся большими, это намного быстрее.
источник
np.searchsorted
занимает около 2 мкс для моего тестового набора, вся функция около 10 мкс. Использованиеnp.abs
становится еще хуже. Понятия не имею, что там делает питон.math
процедуры, см. Этот ответ .if/else
должно быть заменено наidx = idx - (np.abs(value - array[idx-1]) < np.abs(value - array[idx])); return array[idx]
value
больше, чемarray
самый большой элемент. Я изменилif
заявление, чтобыif idx == len(array) or math.fabs(value - array[idx - 1]) < math.fabs(value - array[idx])
оно работало на меня!if idx > 0 and (idx == len(array) or math.fabs(value - array[idx-1]) < math.fabs(value - array[idx])):
С небольшой модификацией ответ выше работает с массивами произвольной размерности (1d, 2d, 3d, ...):
Или написано в одну строку:
источник
a[np.abs(a-a0).argmin)]
работает отлично.a[np.sum(np.square(np.abs(a-a0)),1).argmin()]
.Краткое изложение ответа : если у вас есть сортировка,
array
то код деления пополам (приведенный ниже) работает быстрее всего. ~ 100-1000 раз быстрее для больших массивов и ~ 2-100 раз быстрее для маленьких массивов. Это также не требует NumPy. Если у вас есть несортированный,array
то, еслиarray
он большой, следует сначала рассмотреть использование сортировки O (n logn), а затем разделить пополам, а еслиarray
он мал, то метод 2 кажется самым быстрым.Сначала вы должны уточнить, что вы подразумеваете под ближайшим значением . Часто нужно, чтобы интервал в абсциссе, например, массив = [0,0.7,2.1], значение = 1,95, ответом будет idx = 1. Я подозреваю, что это именно тот случай (в противном случае следующее очень легко можно изменить с помощью условного оператора последующего действия, когда вы найдете интервал). Я отмечу, что оптимальный способ сделать это - разделить пополам (что я предоставлю первым - заметьте, что он вообще не требует numpy и работает быстрее, чем использование numpy функций, поскольку они выполняют избыточные операции). Затем я приведу сравнение времени с другими, представленными здесь другими пользователями.
Bisection:
Теперь я определю код из других ответов, каждый из которых возвращает индекс:
Теперь я определю время кодов: обратите внимание, методы 1,2,4,5 не дают правильный интервал. Методы 1,2,4 округляют до ближайшей точки в массиве (например,> = 1,5 -> 2), а метод 5 всегда округляет (например, 1,45 -> 2). Только методы 3, 6 и, конечно, деление пополам дают правильный интервал.
Для большого массива бисекция дает 4us по сравнению со следующими лучшими 180us и самой длинной 1,21 мс (~ 100 - 1000 раз быстрее). Для меньших массивов это в 2-100 раз быстрее.
источник
array
мало, то метод 2 кажется самым быстрым». как мало ты имел в виду @JoshAlbert?Вот расширение, чтобы найти ближайший вектор в массиве векторов.
источник
norm(..., axis=-1)
должно быть быстрее, чем извлекатьx,y
значения через итерацию Python. Кроме того,x,y
здесь скаляры? Тогдаnorm(x+y)
это ошибка, так как, например, расстояние(+1, -1)
будет рассматриваться как 0.idx = np.array([np.linalg.norm(x+y) for (x,y) in abs(array-value)]).argmin()
Если вы не хотите использовать numpy, это сделает это:
источник
Вот версия, которая будет обрабатывать нескалярный массив «значений»:
Или версия, которая возвращает числовой тип (например, int, float), если ввод скалярный:
источник
outer
метод ufunc прежде, я думаю, что буду использовать его больше в будущем.array[indices]
Кстати, первая функция должна вернуться .np.subtract.outer
будет генерировать всю матрицу внешнего продукта, которая действительно медленная и требует много памяти, еслиarray
и / илиvalues
очень велика.Вот версия со scipy для @Ari Onasafari, ответьте « найти ближайший вектор в массиве векторов »
источник
Вот быстрая векторизованная версия решения @ Dimitri, если у вас есть много
values
для поиска (values
может быть многомерный массив):Ориентиры
> В 100 раз быстрее, чем использование
for
цикла с решением @ Demitri`источник
idx = np.searchsorted(array, values)
затем:idx[array[idx] - values>np.diff(array).mean()*0.5]-=1
и наконецreturn array[idx]
Для больших массивов (превосходный) ответ, данный @Demitri, намного быстрее, чем ответ, который в настоящее время помечен как лучший. Я адаптировал его точный алгоритм следующими двумя способами:
Функция ниже работает независимо от того, отсортирован ли входной массив.
Функция ниже возвращает индекс входного массива, соответствующий ближайшему значению, которое является несколько более общим.
Обратите внимание, что нижеприведенная функция также обрабатывает определенный край, который может привести к ошибке в исходной функции, написанной @Demitri В остальном мой алгоритм идентичен его.
источник
x = np.array([2038, 1758, 1721, 1637, 2097, 2047, 2205, 1787, 2287, 1940, 2311, 2054, 2406, 1471, 1460])
, Сfind_nearest(x, 1739.5)
(ближайшее значение к первому квантилю), я получаю1637
(разумно) и1
(ошибка?).Это векторизованная версия ответа unutbu :
источник
Я думаю, что самый питонический способ будет:
Это основной код. Вы можете использовать его как функцию, если хотите
источник
Все ответы полезны для сбора информации для написания эффективного кода. Тем не менее, я написал небольшой скрипт на Python для оптимизации под различные случаи. Это будет лучший случай, если предоставленный массив отсортирован. При поиске по индексу ближайшей точки заданного значения
bisect
модуль наиболее эффективен по времени. Когда один поиск индексов соответствует массиву,numpy searchsorted
это наиболее эффективно.В [63]:% time bisect.bisect_left (xlist, 0.3) Время ЦП: пользователь 0 нс, sys: 0 нс, всего: 0 нс Время стены: 22,2 мкс
В [64]:% time np.searchsorted (xar, 0.3, side = "left") Время ЦП: пользователь 0 нс, sys: 0 нс, всего: 0 нс Время стены: 98,9 мкс
% time np.searchsorted (xar, randpts, side = "left") Время ЦП: пользователь 4 мс, sys: 0 нс, всего: 4 мс Время ожидания: 1,2 мс
Если мы следуем мультипликативному правилу, тогда numpy должен занять ~ 100 мс, что означает ~ 83X быстрее.
источник
Для двумерного массива определить позицию i, j ближайшего элемента:
источник
источник
Может быть полезно для
ndarrays
:источник