Wie finden Sie die lokalen minima der glatten mehrdimensionales array, in NumPy effizient?

Sagen, ich habe ein array in NumPy enthält Auswertungen der eine kontinuierliche differenzierbare Funktion, und ich möchten, finden Sie die lokalen minima. Es gibt keine Geräusche, so dass jeder Punkt, dessen Wert niedriger ist als die Werte, die von allen seinen Nachbarn erfüllt mein Kriterium für ein lokales minimum.

Habe ich die folgende Liste Verständnis, die arbeiten für ein zwei-dimensionales array, ignorieren von potentiellen minima auf die Grenzen:

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

Jedoch ist dies ziemlich langsam. Ich würde auch gerne diese arbeiten für eine beliebige Anzahl von Dimensionen. Zum Beispiel, gibt es einen einfachen Weg, um alle Nachbarn eines Punktes in einem array von beliebigen Dimensionen? Oder bin ich an dieses problem der falsche Weg insgesamt? Soll ich mich mit numpy.gradient() statt?

InformationsquelleAutor ptomato | 2010-10-21
  1. 17

    Die Lage der lokalen minima können gefunden werden für ein array beliebiger dimension
    mit Ivan's detect_peaks Funktion, mit geringfügigen änderungen:

    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)

    die Sie verwenden können, wie diese:

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

    Sagt die minima treten bei Indizes [0,0,3], [0,4,0], [1,1,1] und [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]
    • Schön! Es läuft etwa 65-mal so schnell wie mein original, und funktioniert für eine beliebige Anzahl von Dimensionen.
    InformationsquelleAutor unutbu
  2. 4

    Versuchen, diese für 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)))

    Diese werden Sie wieder ein array2d-wie-array mit True/False, wo lokale minima (vier Nachbarn) befinden.

    • Gut, dieser findet tatsächlich die lokalen maxima und Bedürfnisse &'s statt &&'s, und erfordert Klammern um die Vergleiche, es läuft aber dreißig mal schneller als mein original.
    • du hast Recht, jetzt korrigiert, danke.
    • was ist hier passiert?
    • Ihr vergleicht ein element im array für die Elemente oben, unten, Links und rechts. wenn Ihre kleiner als alle, es ersetzt das element mit "True" zu lassen, Sie wissen, gibt es ein lokales minimum gibt.
    InformationsquelleAutor eumiro
Schreibe einen Kommentar