Введение в задачу поиска пиков на Python

Когда графики телеметрии внезапно начинают вести себя хаотично, а стандартные методы детекции аномалий сгорают в огне ложноположительных срабатываний, инженеры часто задаются вопросом: почему простой поиск максимумов превращается в квест? Анализ временных рядов, сигналов с датчиков, финансовых графиков и результатов научных экспериментов сводится к одной фундаментальной задаче — поиску локальных экстремумов. На первый взгляд, задача кажется тривиальной. В экосистеме Python есть мощнейшая библиотека SciPy, а в ней — функция scipy.signal.find_peaks, которая создана специально для этих целей. Однако разработчики и дата-саентисты регулярно сталкиваются с нюансами, когда стандартный поиск возвращает слишком много «шума» или одиночных пикселей/точек вместо широких, значимых плато и масштабных всплесков.

Особенно остро встает вопрос, когда перед инженером ставится конкретное условие: найти пики, состоящие из определенного количества точек (например, строго больше 5 точек). Функция find_peaks предлагает богатый набор параметров (prominence, height, distance, width), но прямого аргумента вроде min_points=5 у нее нет. Ширина в SciPy измеряется через параметр width, который работает в непрерывной шкале (по уровню высоты) и требует аккуратной настройки.

В этой статье мы подробно разберем, как решить проблему идентификации широких пиков (свыше 5 точек) на Python. Мы изучим тонкие настройки функции find_peaks, рассмотрим альтернативные математические подходы (скользящие окна, производные и морфологический анализ) и напишем готовый к продакшену код для фильтрации сложных сигналов.

Анатомия функции scipy.signal.find_peaks и параметр width

Прежде чем изобретать велосипед, давайте глубоко погрузимся в то, как работает scipy.signal.find_peaks. По умолчанию эта функция ищет точки, которые строго выше своих ближайших соседей (простое условие локального максимума). Но реальные данные зашумлены, и «одиночные» пики из одной-двух точек часто являются артефактами квантования или помехами.

Чтобы отсеять узкие всплески и зафиксировать только те вершины, которые удерживают вершину дольше, используется аргумент width (а также связанные с ним rel_height, plateau_size). Давайте посмотрим на базовый пример настройки:

import numpy as np
from scipy.signal import find_peaks

# Создаем тестовый сигнал с пиками разной ширины
signal = np.array([0, 1, 0, 0,  # узкий пик (2 точки)
                   2, 3, 4, 4, 3, 2,  # широкий пик (6 точек)
                   0, 1, 5, 2, 0])   # средний пик

# Ищем пики с минимальной шириной
# Важно: width в scipy измеряется в сэмплах (индексах)
peaks, properties = find_peaks(signal, width=5)

print("Индексы пиков:", peaks)
print("Ширины пиков:", properties['widths'])

Здесь кроется первая ловушка для разработчиков. В SciPy параметр width вычисляет ширину пика на определенной высоте (по умолчанию — на половине его проминиентности, то есть на rel_height=0.5). Это означает, что если ваш пик имеет общую протяженность по базовой линии в 10 точек, но сужается кверху, его ширина на уровне 0.5 может оказаться меньше 5 точек. Чтобы измерять именно физическую протяженность основания или плато, нужно использовать другие аргументы или комбинации проверок.

Если ваши пики имеют форму плоских вершин (плато), встроенный параметр plateau_size становится главным инструментом:

# Ищем пики, у которых плоская вершина длится не менее 3 точек
peaks_plateau, props = find_peaks(signal, plateau_size=3)

Однако на практике сигналы редко имеют идеальные плоские вершины. Чаще они представляют собой плавные холмы. Для жесткого ограничения на количество точек, задействованных в формировании пика (от склона до склона), стандартного width может не хватить «из коробки», если не настроить параметр rel_height=1.0 (измерение у самого основания пика).

Переходя от стандартных инструментов к более глубокому контролю, давайте посмотрим, как можно математически препарировать форму сигнала вручную, если коробочные методы начинают давать сбой.

Альтернативный подход №1: Анализ с помощью производных

Если find_peaks кажется вам черным ящиком, или логика измерения ширины в SciPy не покрывает ваши специфические требования к определению «>5 точек», на помощь приходит классическая математика — производные функции.

Идея метода проста:

  1. Первая производная сигнала (разность между соседними точками через np.gradient или np.diff) меняет знак с плюса на минус в точке максимума.
  2. Зоны роста (где производная > 0) и зоны падения (где производная < 0) позволяют точно измерить протяженность каждого холма в точках.

Давайте напишем кастомную функцию на чистом NumPy, которая находит пики и фильтрует их по количеству сэмплов:

import numpy as np

def find_wide_peaks_by_derivative(signal, min_points=5):
    # Находим первую производную
    diffs = np.diff(signal)
    
    # Находим границы переходов (знак производной)
    # Игнорируем нули для стабильности
    signs = np.sign(diffs)
    
    # Ищем индексы, где тренд меняется с возрастания (+1) на убывание (-1)
    # Это грубые вершины
    peak_candidates = []
    for i in range(1, len(signs)):
        if signs[i-1] > 0 and signs[i] <= 0:
            peak_candidates.append(i)
            
    valid_peaks = []
    
    for peak in peak_candidates:
        # Идем влево от пика до смены знака (начало подъема)
        left = peak
        while left > 0 and diffs[left-1] >= 0:
            left -= 1
            
        # Идем вправо от пика до смены знака (конец спуска)
        right = peak
        while right < len(diffs) and diffs[right] <= 0:
            right += 1
            
        # Общая ширина пика в точках
        total_points = right - left + 1
        
        if total_points > min_points:
            valid_peaks.append({
                'peak_index': peak,
                'left_base': left,
                'right_base': right,
                'points_count': total_points
            })
            
    return valid_peaks

# Тестируем функцию
test_signal = [0, 0, 1, 3, 5, 6, 5, 3, 1, 0, 0,  # Ширина > 5
               0, 4, 5, 4, 0]                     # Узкий пик
result = find_wide_peaks_by_derivative(test_signal, min_points=5)
print(result)

Этот метод дает полный контроль над определением ширины. Мы не зависим от абстрактных коэффициентов проминиентности SciPy; мы буквально считаем, сколько индексов занял подъем и спуск целевого объекта.

Впрочем, ручной подсчет производных бывает уязвим перед высокочастотным шумом датчиков. Чтобы сделать алгоритм неуязвимым к помехам, логично подключить методы компьютерного зрения к анализу графиков.

Альтернативный подход №2: Морфологический анализ и скользящие окна

В сфере обработки изображений (Computer Vision) и анализа сложных временных рядов часто применяются методы математической морфологии. Идея заключается в применении фильтров минимального (erosion) и максимального (dilation) значения в скользящем окне заданного размера.

Если мы ищем пики размером более 5 точек, мы можем использовать размер окна фильтрации, соразмерный этому значению. С помощью операций открытия (opening) и закрытия (closing) можно подавлять мелкие высокочастотные детали и оставлять только крупные формы.

import numpy as np
from scipy.ndimage import maximum_filter1d, minimum_filter1d

def find_peaks_morphology(signal, window_size=5):
    # Применяем фильтр максимума для сглаживания локальных ям
    # и фильтр минимума для очистки базы пика
    
    # Морфологическое "открытие" помогает выделить крупные структуры
    # Сначала сужение, потом расширение
    eroded = minimum_filter1d(signal, size=window_size)
    dilated = maximum_filter1d(eroded, size=window_size)
    
    # Разница между исходным сигналом и морфологически обработанным
    # позволяет выделить крупные всплески
    diff = signal - dilated
    
    # Альтернативно: ищем области, где локальный максимум равен исходному сигналу
    # на интервале, превышающем заданную ширину
    is_local_max = (signal == maximum_filter1d(signal, size=window_size))
    
    return is_local_max

# Пример использования встроенных средств SciPy для сглаживания
smoothed_signal = maximum_filter1d(signal, size=5)

Плюс такого подхода — устойчивость к шумам. Если в вершине пика есть небольшие провалы (шум квантования), скользящее окно сгладит их, превратив зашумленный горб в единый монолитный пик шириной более 5 точек.

Сравнение методов и выбор оптимального решения для продакшена

Каждый из рассмотренных подходов имеет право на жизнь в зависимости от характера ваших данных. Давайте сопоставим их ключевые характеристики в виде таблицы или списка:

  • SciPy find_peaks + width: Идеально оптимизирован на языке C (через Cython), работает очень быстро на больших массивах данных. Требует правильной настройки параметра rel_height=1.0, чтобы измерять ширину именно по основанию, а не посередине.
  • Кастомный алгоритм на производных (NumPy): Дает максимальную прозрачность логики. Вы сами определяете, что считать «началом» и «концом» пика. Минус — циклы на Python могут медленно работать на миллионных таймланах (требуется векторизация).
  • Морфологическая фильтрация (SciPy ndimage): Отлично справляется с зашумленными данными промышленного оборудования или IoT-датчиков, где пики имеют искаженную форму.
«Прежде чем писать сложный кастомный код для фильтрации пиков по ширине, всегда пробуйте выжать максимум из аргументов width и plateau_size в связке с prominence в scipy.signal.find_peaks. В 90% случаев комбинация этих параметров решает задачу „из коробки“, экономя часы на отладку краевых эффектов».

Пора объединить теорию с практикой и посмотреть, как эти инструменты отрабатывают на реальных зашумленных данных промышленного или финансового характера.

Практический пример: Обработка реального зашумленного сигнала

Давайте соберем все знания воедино и напишем комплексный пайплайн. Представим, что у нас есть зашумленный сигнал с промышленного датчика температуры, в котором нужно отловить перегрев агрегата — стабильные пики шириной > 5 точек, отбросив случайные электромагнитные помехи.

import numpy as np
import matplotlib.pyplot as plt
from scipy.signal import find_peaks

def robust_peak_detection(signal):
    # Шаг 1: Первичный поиск с помощью find_peaks
    # Задаем минимальную высоту и проминентность для отсечения слабого шума
    initial_peaks, properties = find_peaks(
        signal, 
        height=1.0, 
        prominence=0.5
    )
    
    filtered_peaks = []
    final_widths = []
    
    # Шаг 2: Проверяем реальную ширину каждого найденного пика по основанию (rel_height=1.0)
    # Пересчитываем ширины с максимальной точностью
    detailed_widths, width_heights, left_ips, right_ips = scipy.signal.peak_widths(
        signal, 
        initial_peaks, 
        rel_height=1.0
    )
    
    for i, peak in enumerate(initial_peaks):
        # Ширина в точках — это разница между правым и левым индексом пересечения уровня
        points_span = right_ips[i] - left_ips[i]
        
        # Фильтруем строго по нашему условию: > 5 точек
        if points_span > 5:
            filtered_peaks.append(peak)
            final_widths.append(points_span)
            
    return filtered_peaks, final_widths

# Генерируем синтетический датасет для демонстрации
np.random.seed(42)
x = np.linspace(0, 50, 500)
base_signal = np.sin(x) * 3
# Добавляем широкий пик
base_signal[200:215] += 4 
# Добавляем узкий шумовой пик (который должен отсеяться)
base_signal[100:103] += 3 
# Добавляем случайный шум
noisy_signal = base_signal + np.random.normal(0, 0.2, len(x))

# Импортируем scipy.signal целиком для peak_widths
import scipy.signal

valid_peaks, widths = robust_peak_detection(noisy_signal)
print(f"Найдено стабильных пиков шириной > 5 точек: {len(valid_peaks)}")
print(f"Индексы пиков: {valid_peaks}")
print(f"Их ширина в точках: {widths}")

Обратите внимание на использование функции scipy.signal.peak_widths в паре с find_peaks. Это самый профессиональный и идиоматичный подход в экосистеме Python SciPy. Функция peak_widths принимает уже найденные индексы пиков и позволяет с высочайшей точностью рассчитать их ширину на абсолютно любом уровне высоты (благодаря аргументу rel_height, где 1.0 означает самое основание пика, а 0.5 — середину).

Заключение

Идентификация пиков шириной более 5 точек на Python — задача, с которой рано или поздно сталкивается каждый разработчик аналитического ПО. Хотя стандартная функция scipy.signal.find_peaks не имеет простого параметра min_points, она предоставляет всю необходимую экосистему для решения этой проблемы.

Мы выяснили, что:

  • Комбинация find_peaks и специализированной функции peak_widths(..., rel_height=1.0) позволяет точно измерять физическую протяженность пика по его основанию в точках.
  • Для нестандартных форм сигналов можно успешно применять анализ производных на базе NumPy или морфологические фильтры из scipy.ndimage.
  • Правильная предварительная фильтрация шумов гарантирует, что алгоритм не примет случайные колебания за широкий целевой объект.

Попробуйте внедрить связку find_peaks и peak_widths в свой следующий пайплайн анализа данных — это избавит код от громоздких циклов и поднимет точность детекции на новый уровень. Если статья оказалась полезной, поделитесь ею с коллегами по цеху!