检测数字列表中的峰值并记录其位置

Question

我试图创建一些代码来返回数值数组的“峰值”（或局部极大值）的位置和值。在

例如，列表arr = [0, 1, 2, 5, 1, 0]在位置3有一个峰值，值为5（因为arr[3]等于5）。在

数组的第一个和最后一个元素不会被视为峰值（在数学函数的上下文中，您不知道在后面和之前是什么，因此，您不知道它是否是峰值）。在

def pick_peaks(arr):
    print(arr)
    posPeaks = {
        "pos": [],
        "peaks": [],
    }
    startFound = False
    n = 0
    while startFound == False:
        if arr[n] == arr[n+1]:
            n += 1
        else:
            startFound = True

    endFound = False
    m = len(arr) - 1
    while endFound == False:
        if arr[m] == arr[m-1]:
            m -= 1
        else:
            endFound = True

    for i in range(n+1, m):
        if arr[i] == arr[i-1]:
            None
        elif arr[i] >= arr[i-1] and arr[i] >= arr[i+1]:
            posPeaks["pos"].append(i)
            posPeaks["peaks"].append(arr[i])

    return posPeaks

我的问题是高原。[1, 2, 2, 2, 1]有峰值，而{}没有。当一个平台是一个峰值时，记录该平台的第一个位置。在

感谢任何帮助。在

Answer 1

我知道我可能会迟到一点，但我想分享一下我使用NumPy阵列的解决方案：

def get_level_peaks(v):
    peaks = []

    i = 1
    while i < v.size-1:
        pos_left = i
        pos_right = i

        while v[pos_left] == v[i] and pos_left > 0:
            pos_left -= 1

        while v[pos_right] == v[i] and pos_right < v.size-1:
            pos_right += 1

        is_lower_peak = v[pos_left] > v[i] and v[i] < v[pos_right]
        is_upper_peak = v[pos_left] < v[i] and v[i] > v[pos_right]

        if is_upper_peak or is_lower_peak:
            peaks.append(i)

        i = pos_right

    peaks = np.array(peaks)

    """
    # uncomment this part of the code
    # to include first and last positions

    first_pos, last_pos = 0, v.size-1
    peaks = np.append([first_pos], peaks)
    peaks = np.append(peaks, [last_pos])
    """

    return peaks

• 例1（see graph）：

^{pr2}$

• 例2（see graph）：

v = np.array([8, 2, 1, 0, 1, 2, 2, 5, 9, 3])
p = get_peaks(v)
print(v)        # [8 2 1 0 1 2 2 5 9 3]
print(p)        # [0 3 8 9] (peak indexes)
print(v[p])     # [8 0 9 3] (peak elements)

• 例3（see graph）：

v = np.array([9, 8, 8, 8, 0, 8, 9, 9, 9, 6])
p = get_peaks(v)
print(v)        # [9 8 8 8 0 8 9 9 9 6]
print(p)        # [0 4 6 9] (peak indexes)
print(v[p])     # [9 0 9 6] (peak elements)

---

在示例3中，我们有一个从索引6到索引8的平坦的上限。在这种情况下，索引将始终指示平台的最左侧位置。如果要指明中间位置或最右侧位置，只需更改代码的以下部分：

        ...

        if is_upper_peak or is_lower_peak:
            peaks.append(i)

        ...

为此：

        ...

        # middle position
        if is_upper_peak or is_lower_peak:
            peaks.append((pos_left + pos_right) // 2)

        ...

        ...

        # rightmost position
        if is_upper_peak or is_lower_peak:
            peaks.append(pos_right)

        ...

Answer 2

如果可以对数据进行预处理以删除重复的数字，并且只保留1个唯一的数字，那么也可以对平台使用相同的算法。因此，您可以将示例[1, 2, 2, 2, 1]转换为[1, 2, 1]，并应用相同的算法。在

编辑： 代码：

from itertools import groupby

def process_data(data):
    return [list(val for num in group) for val, group in groupby(data)]


def peaks(arr):
    #print(arr)
    posPeaks = {
    "pos": [],
    "peaks": [],
    }
    startFound = False
    n = 0
    while startFound == False:
        if arr[n][0] == arr[n+1][0]:
            n += 1
        else:
            startFound = True

    endFound = False
    m = len(arr) - 1
    while endFound == False:
        if arr[m][0] == arr[m-1][0]:
            m -= 1
        else:
            endFound = True

    for i in range(n+1, m):
        if arr[i][0] == arr[i-1][0]:
            None
        elif arr[i][0] >= arr[i-1][0] and arr[i][0] >= arr[i+1][0]:
            pos = sum([len(arr[idx]) for idx in range(i)])
            posPeaks["pos"].append(pos) #.append(i)
            posPeaks["peaks"].append(arr[i][0])
    return posPeaks



print(peaks(process_data([0, 1, 2, 5, 1, 0])))
print(peaks(process_data([1, 2, 2, 2, 1])))
print(peaks(process_data([1, 2, 2, 2, 3])))

输出：

^{pr2}$

Answer 3

我建议您使用groupby对连续相等的值进行分组，然后为每个组存储第一个位置，例如[1, 2, 2, 2, 1]它创建了以下列表，下面是元组列表[(1, 0), (2, 1), (1, 4)]，将所有这些放在一起：

from itertools import groupby


def peaks(data):
    start = 0
    sequence = []
    for key, group in groupby(data):
        sequence.append((key, start))
        start += sum(1 for _ in group)

    for (b, bi), (m, mi), (a, ai) in zip(sequence, sequence[1:], sequence[2:]):
        if b < m and a < m:
            yield m, mi


print(list(peaks([0, 1, 2, 5, 1, 0])))
print(list(peaks([1, 2, 2, 2, 1])))
print(list(peaks([1, 2, 2, 2, 3])))

输出

^{pr2}$