Comment trouver les minima locaux de la lisse d'un tableau multidimensionnel dans NumPy efficacement?

Dire que j'ai un tableau NumPy contenant des évaluations continues de fonction dérivable, et je veux trouver les minima locaux. Il n'y a pas de bruit, de sorte que chaque point dont la valeur est inférieure aux valeurs de l'ensemble de ses voisins répond à mes critère d'un minimum local.

J'ai la liste suivante de compréhension de ce qui fonctionne pour un tableau à deux dimensions, en ignorant le potentiel des minima sur les limites:

import numpy as N
def local_minima(array2d):
local_minima = [ index 
for index in N.ndindex(array2d.shape)
if index[0] > 0
if index[1] > 0
if index[0] < array2d.shape[0] - 1
if index[1] < array2d.shape[1] - 1
if array2d[index] < array2d[index[0] - 1, index[1] - 1]
if array2d[index] < array2d[index[0] - 1, index[1]]
if array2d[index] < array2d[index[0] - 1, index[1] + 1]
if array2d[index] < array2d[index[0], index[1] - 1]
if array2d[index] < array2d[index[0], index[1] + 1]
if array2d[index] < array2d[index[0] + 1, index[1] - 1]
if array2d[index] < array2d[index[0] + 1, index[1]]
if array2d[index] < array2d[index[0] + 1, index[1] + 1]
]
return local_minima

Cependant, c'est assez lent. Je tiens également à obtenir que cela fonctionne pour un nombre quelconque de dimensions. Par exemple, est-il un moyen facile d'obtenir tous les voisins d'un point dans un tableau de toutes les dimensions? Ou suis-je aborder ce problème à l'envers? Dois-je utiliser numpy.gradient() à la place?

Trouver le mondial maxima: stackoverflow.com/questions/3584243/...

OriginalL'auteur ptomato | 2010-10-21

  1. 16

    L'emplacement des minima locaux peuvent être trouvés pour une matrice de dimension arbitraire
    à l'aide de Ivan's detect_peaks fonction, avec des modifications mineures:

    import numpy as np
import scipy.ndimage.filters as filters
import scipy.ndimage.morphology as morphology
def detect_local_minima(arr):
# https://stackoverflow.com/questions/3684484/peak-detection-in-a-2d-array/3689710#3689710
"""
Takes an array and detects the troughs using the local maximum filter.
Returns a boolean mask of the troughs (i.e. 1 when
the pixel's value is the neighborhood maximum, 0 otherwise)
"""
# define an connected neighborhood
# http://www.scipy.org/doc/api_docs/SciPy.ndimage.morphology.html#generate_binary_structure
neighborhood = morphology.generate_binary_structure(len(arr.shape),2)
# apply the local minimum filter; all locations of minimum value 
# in their neighborhood are set to 1
# http://www.scipy.org/doc/api_docs/SciPy.ndimage.filters.html#minimum_filter
local_min = (filters.minimum_filter(arr, footprint=neighborhood)==arr)
# local_min is a mask that contains the peaks we are 
# looking for, but also the background.
# In order to isolate the peaks we must remove the background from the mask.
# 
# we create the mask of the background
background = (arr==0)
# 
# a little technicality: we must erode the background in order to 
# successfully subtract it from local_min, otherwise a line will 
# appear along the background border (artifact of the local minimum filter)
# http://www.scipy.org/doc/api_docs/SciPy.ndimage.morphology.html#binary_erosion
eroded_background = morphology.binary_erosion(
background, structure=neighborhood, border_value=1)
# 
# we obtain the final mask, containing only peaks, 
# by removing the background from the local_min mask
detected_minima = local_min - eroded_background
return np.where(detected_minima)

    que vous pouvez utiliser comme ceci:

    arr=np.array([[[0,0,0,-1],[0,0,0,0],[0,0,0,0],[0,0,0,0],[-1,0,0,0]],
[[0,0,0,0],[0,-1,0,0],[0,0,0,0],[0,0,0,-1],[0,0,0,0]]])
local_minima_locations = detect_local_minima(arr)
print(arr)
# [[[ 0  0  0 -1]
#   [ 0  0  0  0]
#   [ 0  0  0  0]
#   [ 0  0  0  0]
#   [-1  0  0  0]]
#  [[ 0  0  0  0]
#   [ 0 -1  0  0]
#   [ 0  0  0  0]
#   [ 0  0  0 -1]
#   [ 0  0  0  0]]]

    Cela dit les minima se produisent à des indices [0,0,3], [0,4,0], [1,1,1] et [1,3,3]:

    print(local_minima_locations)
# (array([0, 0, 1, 1]), array([0, 4, 1, 3]), array([3, 0, 1, 3]))
print(arr[local_minima_locations])
# [-1 -1 -1 -1]
    Nice! Il fonctionne environ 65 fois plus vite que mon original, et travaille pour un nombre quelconque de dimensions.

    OriginalL'auteur unutbu

  2. 4

    Essayez ceci pour la 2D:

    import numpy as N
def local_minima(array2d):
return ((array2d <= N.roll(array2d,  1, 0)) &
(array2d <= N.roll(array2d, -1, 0)) &
(array2d <= N.roll(array2d,  1, 1)) &
(array2d <= N.roll(array2d, -1, 1)))

    Revenir un array2d tableau avec des Vrai/Faux, où les minima locaux (quatre voisins) sont situés.

    Eh bien, ce trouve effectivement les maxima locaux, et les besoins &'s au lieu de &&'s, et nécessite des parenthèses autour de l'comparaisons, mais il va à trente fois plus rapide que mon original.
    vous avez raison, maintenant corrigé, merci.
    ce qui se passe ici?
    ses comparant un élément dans le tableau les éléments ci-dessus, ci-dessous, à gauche et à droite. si sa plus petite de toutes, elle remplace l'élément à "True" pour laisser vous savez qu'il y est un minimum local.

    OriginalL'auteur eumiro