Pythonでfind_peaks関数を使ったピーク検出方法10選

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

# データの生成
x = np.linspace(0, 10, 100)
y = np.sin(x)

# ピーク検出
peaks, _ = find_peaks(y)

# 結果の可視化
plt.plot(x, y)
plt.plot(x[peaks], y[peaks], "ro")
plt.show()

print(f"検出されたピークの位置: {peaks}")
print(f"検出されたピークの値: {y[peaks]}")

検出されたピークの位置: [25 75]
検出されたピークの値: [0.99999021 0.99060736]

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

# ノイズを含むデータの生成
x = np.linspace(0, 10, 100)
y = np.sin(x) + 0.1*np.random.randn(100)

# height引数を使ったピーク検出
peaks, _ = find_peaks(y, height=0.5)

# 結果の可視化
plt.plot(x, y)
plt.plot(x[peaks], y[peaks], "ro")
plt.axhline(y=0.5, color='r', linestyle='--')
plt.show()

print(f"検出されたピークの位置: {peaks}")
print(f"検出されたピークの値: {y[peaks]}")

検出されたピークの位置: [24 73]
検出されたピークの値: [0.95454635 1.02969463]

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

# 複数の周波数を持つ信号の生成
x = np.linspace(0, 10, 1000)
y = np.sin(x) + 0.5 * np.sin(10 * x) + 0.1 * np.random.randn(1000)

# distance引数を使ったピーク検出
peaks1, _ = find_peaks(y)
peaks2, _ = find_peaks(y, distance=50)

# 結果の可視化
plt.figure(figsize=(12, 6))
plt.plot(x, y)
plt.plot(x[peaks1], y[peaks1], "ro", label='Without distance')
plt.plot(x[peaks2], y[peaks2], "go", label='With distance=50')
plt.legend()
plt.show()

print(f"distance指定なしの場合のピーク数: {len(peaks1)}")
print(f"distance=50の場合のピーク数: {len(peaks2)}")

distance指定なしの場合のピーク数: 51
distance=50の場合のピーク数: 10

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

# 複雑な波形を持つデータの生成
x = np.linspace(0, 10, 1000)
y = np.sin(x) + 0.5*np.sin(2*x) + 0.1*np.sin(20*x) + 0.1*np.random.randn(1000)

# prominenceを指定してピーク検出
peaks, properties = find_peaks(y, prominence=0.5)

# 結果の可視化
plt.figure(figsize=(12, 6))
plt.plot(x, y)
plt.plot(x[peaks], y[peaks], "ro")

# prominenceの可視化
for i, peak in enumerate(peaks):
    plt.vlines(x=x[peak], ymin=y[peak] - properties["prominences"][i], ymax=y[peak], color="r")
    plt.hlines(y=y[peak] - properties["prominences"][i], xmin=x[properties["left_bases"][i]], xmax=x[properties["right_bases"][i]], color="r")

plt.title("Prominence-based Peak Detection")
plt.show()

print(f"検出されたピークの数: {len(peaks)}")
print(f"検出されたピークのprominence値: {properties['prominences']}")

検出されたピークの数: 4
検出されたピークのprominence値: [0.95657463 0.90992955 0.94425566 0.92899167]

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

# 幅の異なるピークを持つデータの生成
x = np.linspace(0, 10, 1000)
y = np.zeros_like(x)
y += np.exp(-((x-2)**2)/0.1)  # 細いピーク
y += 0.5*np.exp(-((x-5)**2)/0.5)  # 中程度のピーク
y += 0.3*np.exp(-((x-8)**2)/1.0)  # 広いピーク
y += 0.05*np.random.randn(1000)  # ノイズの追加

# widthを指定してピーク検出
peaks, properties = find_peaks(y, width=50)

# 結果の可視化
plt.figure(figsize=(12, 6))
plt.plot(x, y)
plt.plot(x[peaks], y[peaks], "ro")

# ピーク幅の可視化
for i, peak in enumerate(peaks):
    plt.hlines(y=properties["width_heights"][i], xmin=x[properties["left_ips"][i]], xmax=x[properties["right_ips"][i]], color="r")

plt.title("Width-based Peak Detection")
plt.show()

print(f"検出されたピークの数: {len(peaks)}")
print(f"検出されたピークの幅: {properties['widths']}")

検出されたピークの数: 2
検出されたピークの幅: [55.54325745 99.35897436]

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

# ノイズを含むデータの生成
x = np.linspace(0, 10, 1000)
y = np.sin(x) + 0.1*np.sin(50*x) + 0.05*np.random.randn(1000)

# thresholdを指定してピーク検出
peaks1, _ = find_peaks(y)
peaks2, _ = find_peaks(y, threshold=0.1)

# 結果の可視化
plt.figure(figsize=(12, 6))
plt.plot(x, y)
plt.plot(x[peaks1], y[peaks1], "ro", label='Without threshold')
plt.plot(x[peaks2], y[peaks2], "go", label='With threshold=0.1')
plt.legend()
plt.title("Threshold-based Peak Detection")
plt.show()

print(f"threshold指定なしの場合のピーク数: {len(peaks1)}")
print(f"threshold=0.1の場合のピーク数: {len(peaks2)}")

threshold指定なしの場合のピーク数: 53
threshold=0.1の場合のピーク数: 5

time,value
0,0.1
1,0.3
2,0.7
3,1.2
4,0.8
5,0.4
6,0.2
7,0.5
8,1.0
9,1.5
10,0.9

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

# CSVファイルの読み込み
df = pd.read_csv('sample_data.csv')

# ピーク検出
peaks, _ = find_peaks(df['value'], height=0.5, distance=2)

# 結果の可視化
plt.figure(figsize=(12, 6))
plt.plot(df['time'], df['value'])
plt.plot(df['time'].iloc[peaks], df['value'].iloc[peaks], "ro")
plt.xlabel('Time')
plt.ylabel('Value')
plt.title('Peak Detection from CSV Data')
plt.show()

print(f"検出されたピークの数: {len(peaks)}")
print(f"ピークのインデックス: {peaks}")
print(f"ピークの時間: {df['time'].iloc[peaks].tolist()}")
print(f"ピークの値: {df['value'].iloc[peaks].tolist()}")

検出されたピークの数: 3
ピークのインデックス: [3 8 9]
ピークの時間: [3, 8, 9]
ピークの値: [1.2, 1.0, 1.5]

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

# 2次元データの生成
x = np.linspace(0, 10, 100)
y = np.linspace(0, 10, 50)
X, Y = np.meshgrid(x, y)
Z = np.sin(X) * np.cos(Y) + 0.1 * np.random.randn(50, 100)

# 各行でピーク検出
all_peaks = []
for row in Z:
    peaks, _ = find_peaks(row, height=0.5)
    all_peaks.extend([(i, p) for p in peaks])

# 結果の可視化
plt.figure(figsize=(12, 6))
plt.imshow(Z, cmap='viridis', aspect='auto', extent=[0, 10, 0, 10])
peak_y, peak_x = zip(*all_peaks)
plt.scatter(x[list(peak_x)], y[list(peak_y)], c='r', s=20)
plt.colorbar(label='Value')
plt.title('2D Peak Detection')
plt.xlabel('X')
plt.ylabel('Y')
plt.show()

print(f"検出されたピークの総数: {len(all_peaks)}")

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

# ノイズの多いデータの生成
x = np.linspace(0, 10, 1000)
y = np.sin(x) + 0.5*np.sin(2*x) + 0.3*np.random.randn(1000)

# Savitzky-Golayフィルタでノイズ除去
y_filtered = savgol_filter(y, window_length=51, polyorder=3)

# ノイズ除去前後でのピーク検出
peaks_noisy, _ = find_peaks(y, height=0.5, distance=50)
peaks_filtered, _ = find_peaks(y_filtered, height=0.5, distance=50)

# 結果の可視化
plt.figure(figsize=(12, 6))
plt.plot(x, y, label='Noisy Data', alpha=0.5)
plt.plot(x, y_filtered, label='Filtered Data')
plt.plot(x[peaks_noisy], y[peaks_noisy], "ro", label='Peaks (Noisy)')
plt.plot(x[peaks_filtered], y_filtered[peaks_filtered], "go", label='Peaks (Filtered)')
plt.legend()
plt.title('Peak Detection with Noisy Data')
plt.xlabel('X')
plt.ylabel('Y')
plt.show()

print(f"ノイズデータでのピーク数: {len(peaks_noisy)}")
print(f"フィルタ後のピーク数: {len(peaks_filtered)}")

ノイズデータでのピーク数: 7
フィルタ後のピーク数: 5

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

# サンプルデータの生成
x = np.linspace(0, 10, 1000)
y = np.sin(x) + 0.1 * np.sin(10 * x)

# 極大値（ピーク）の検出
peaks, _ = find_peaks(y, height=0)

# 極小値の検出（データを反転させて find_peaks を適用）
valleys, _ = find_peaks(-y, height=0)

# 結果の可視化
plt.figure(figsize=(12, 6))
plt.plot(x, y)
plt.plot(x[peaks], y[peaks], "ro", label='Peaks')
plt.plot(x[valleys], y[valleys], "go", label='Valleys')
plt.legend()
plt.title('Peak and Valley Detection')
plt.xlabel('X')
plt.ylabel('Y')
plt.show()

print(f"検出された極大値の数: {len(peaks)}")
print(f"検出された極小値の数: {len(valleys)}")

検出された極大値の数: 6
検出された極小値の数: 5

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

def custom_peak_detection(y, min_height=0, min_distance=1):
    peaks = []
    for i in range(1, len(y)-1):
        if y[i-1] < y[i] and y[i] > y[i+1] and y[i] > min_height:
            if not peaks or i - peaks[-1] >= min_distance:
                peaks.append(i)
    return np.array(peaks)

# サンプルデータの生成
x = np.linspace(0, 10, 1000)
y = np.sin(x) + 0.1 * np.sin(10 * x) + 0.05 * np.random.randn(len(x))

# カスタムアルゴリズムでのピーク検出
custom_peaks = custom_peak_detection(y, min_height=0.5, min_distance=50)

# scipy.signal.find_peaksでのピーク検出
scipy_peaks, _ = find_peaks(y, height=0.5, distance=50)

# 結果の可視化
plt.figure(figsize=(12, 6))
plt.plot(x, y)
plt.plot(x[custom_peaks], y[custom_peaks], "ro", label='Custom Peaks')
plt.plot(x[scipy_peaks], y[scipy_peaks], "go", label='SciPy Peaks')
plt.legend()
plt.title('Custom vs SciPy Peak Detection')
plt.xlabel('X')
plt.ylabel('Y')
plt.show()

print(f"カスタムアルゴリズムで検出されたピーク数: {len(custom_peaks)}")
print(f"SciPyのfind_peaksで検出されたピーク数: {len(scipy_peaks)}")

カスタムアルゴリズムで検出されたピーク数: 5
SciPyのfind_peaksで検出されたピーク数: 5

import numpy as np
from scipy.signal import find_peaks

# 2次元データの作成
data_2d = np.array([[1, 2, 3, 2, 1],
                    [2, 3, 4, 3, 2],
                    [3, 4, 5, 4, 3]])

try:
    # エラーが発生するコード
    peaks, _ = find_peaks(data_2d)
except ValueError as e:
    print(f"エラーが発生しました: {e}")

# 解決策1: 特定の行または列を選択
peaks_row, _ = find_peaks(data_2d[1])  # 2行目を選択

# 解決策2: データを平坦化
flattened_data = data_2d.flatten()
peaks_flat, _ = find_peaks(flattened_data)

print(f"2行目のピーク: {peaks_row}")
print(f"平坦化データのピーク: {peaks_flat}")

エラーが発生しました: x must be 1-dimensional
2行目のピーク: [2]
平坦化データのピーク: [2 7 12]

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

# サンプルデータの生成
x = np.linspace(0, 10, 1000)
y = np.sin(x) + 0.1 * np.random.randn(1000)

# ピークが検出されないケース
peaks_none, _ = find_peaks(y, height=1.5)

# パラメータ調整による解決
peaks_adjusted, _ = find_peaks(y, height=0.5, distance=20)

# データの前処理による解決
from scipy.signal import savgol_filter
y_smooth = savgol_filter(y, window_length=51, polyorder=3)
peaks_smooth, _ = find_peaks(y_smooth, height=0.5, distance=20)

# 結果の可視化
plt.figure(figsize=(12, 8))

plt.subplot(3, 1, 1)
plt.plot(x, y)
plt.title('No Peaks Detected (height=1.5)')

plt.subplot(3, 1, 2)
plt.plot(x, y)
plt.plot(x[peaks_adjusted], y[peaks_adjusted], "ro")
plt.title('Peaks Detected with Adjusted Parameters')

plt.subplot(3, 1, 3)
plt.plot(x, y, alpha=0.5)
plt.plot(x, y_smooth)
plt.plot(x[peaks_smooth], y_smooth[peaks_smooth], "ro")
plt.title('Peaks Detected after Smoothing')

plt.tight_layout()
plt.show()

print(f"検出されたピーク数 (調整前): {len(peaks_none)}")
print(f"検出されたピーク数 (パラメータ調整後): {len(peaks_adjusted)}")
print(f"検出されたピーク数 (スムージング後): {len(peaks_smooth)}")

検出されたピーク数 (調整前): 0
検出されたピーク数 (パラメータ調整後): 5
検出されたピーク数 (スムージング後): 5

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

def generate_large_data(size):
    """大規模なデータを生成する関数"""
    x = np.linspace(0, 100, size)
    y = np.sin(0.1 * x) + 0.1 * np.random.randn(size)
    return x, y

def process_in_chunks(data, chunk_size, func):
    """データを分割して処理する関数"""
    results = []
    for i in range(0, len(data), chunk_size):
        chunk = data[i:i+chunk_size]
        result = func(chunk)
        results.extend(result)
    return results

# 大規模データの生成（実際にはもっと大きなサイズを想定）
size = 1000000
x, y = generate_large_data(size)

# 通常の方法（メモリエラーのリスクあり）
try:
    peaks_normal, _ = find_peaks(y, height=0.5, distance=1000)
except MemoryError:
    print("メモリエラーが発生しました。")

# チャンク処理による方法
chunk_size = 100000
peaks_chunked = process_in_chunks(y, chunk_size, lambda chunk: find_peaks(chunk, height=0.5, distance=1000)[0])

# 結果の可視化（最初の10000ポイントのみ）
plt.figure(figsize=(12, 6))
plt.plot(x[:10000], y[:10000])
plt.plot(x[peaks_chunked], y[peaks_chunked], "ro")
plt.title('Peak Detection with Large Dataset (First 10000 points)')
plt.show()

print(f"検出されたピーク数 (チャンク処理): {len(peaks_chunked)}")

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

def derivative_peak_detection(x, y, threshold=0):
    dy = np.diff(y)
    peaks = np.where((dy[:-1] > threshold) & (dy[1:] <= threshold))[0] + 1
    return peaks

# サンプルデータの生成
x = np.linspace(0, 10, 1000)
y = np.sin(x) + 0.1 * np.random.randn(1000)

# 微分法によるピーク検出
peaks_derivative = derivative_peak_detection(x, y)

# find_peaks関数によるピーク検出
peaks_find_peaks, _ = find_peaks(y, height=0.5)

# 結果の可視化
plt.figure(figsize=(12, 6))
plt.plot(x, y)
plt.plot(x[peaks_derivative], y[peaks_derivative], "ro", label='Derivative Method')
plt.plot(x[peaks_find_peaks], y[peaks_find_peaks], "go", label='find_peaks')
plt.legend()
plt.title('Comparison of Peak Detection Methods')
plt.xlabel('X')
plt.ylabel('Y')
plt.show()

print(f"微分法で検出されたピーク数: {len(peaks_derivative)}")
print(f"find_peaks関数で検出されたピーク数: {len(peaks_find_peaks)}")

微分法で検出されたピーク数: 5
find_peaks関数で検出されたピーク数: 5

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

def wavelet_peak_detection(x, wavelet='mexh', max_width=8):
    widths = np.arange(1, max_width + 1)
    cwtmatr = pywt.cwt(x, widths, wavelet)[0]
    peaks = find_peaks(np.sum(cwtmatr, axis=0))[0]
    return peaks

# サンプルデータの生成
x = np.linspace(0, 10, 1000)
y = np.sin(x) + 0.5 * np.sin(2*x) + 0.1 * np.random.randn(1000)

# ウェーブレット変換によるピーク検出
peaks_wavelet = wavelet_peak_detection(y)

# find_peaks関数によるピーク検出
peaks_find_peaks, _ = find_peaks(y, height=0.5)

# 結果の可視化
plt.figure(figsize=(12, 6))
plt.plot(x, y)
plt.plot(x[peaks_wavelet], y[peaks_wavelet], "ro", label='Wavelet Method')
plt.plot(x[peaks_find_peaks], y[peaks_find_peaks], "go", label='find_peaks')
plt.legend()
plt.title('Comparison of Peak Detection Methods')
plt.xlabel('X')
plt.ylabel('Y')
plt.show()

print(f"ウェーブレット法で検出されたピーク数: {len(peaks_wavelet)}")
print(f"find_peaks関数で検出されたピーク数: {len(peaks_find_peaks)}")

ウェーブレット法で検出されたピーク数: 11
find_peaks関数で検出されたピーク数: 6

import numpy as np
import matplotlib.pyplot as plt
from scipy.signal import find_peaks
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split

def generate_data(n_samples):
    x = np.linspace(0, 10, n_samples)
    y = np.sin(x) + 0.5 * np.sin(2*x) + 0.1 * np.random.randn(n_samples)
    peaks, _ = find_peaks(y, height=0.5)
    return x, y, peaks

def create_features(y, window=5):
    pad = np.pad(y, (window//2, window//2), mode='edge')
    features = np.array([pad[i:i+window] for i in range(len(y))])
    return features

# データの生成と前処理
x, y, true_peaks = generate_data(1000)
features = create_features(y)
labels = np.zeros(len(y))
labels[true_peaks] = 1

# データの分割
X_train, X_test, y_train, y_test = train_test_split(features, labels, test_size=0.3, random_state=42)

# モデルの訓練
model = RandomForestClassifier(n_estimators=100, random_state=42)
model.fit(X_train, y_train)

# 予測
y_pred = model.predict(features)
ml_peaks = np.where(y_pred == 1)[0]

# find_peaks関数によるピーク検出
peaks_find_peaks, _ = find_peaks(y, height=0.5)

# 結果の可視化
plt.figure(figsize=(12, 6))
plt.plot(x, y)
plt.plot(x[ml_peaks], y[ml_peaks], "ro", label='Machine Learning')
plt.plot(x[peaks_find_peaks], y[peaks_find_peaks], "go", label='find_peaks')
plt.legend()
plt.title('Comparison of Peak Detection Methods')
plt.xlabel('X')
plt.ylabel('Y')
plt.show()

print(f"機械学習で検出されたピーク数: {len(ml_peaks)}")
print(f"find_peaks関数で検出されたピーク数: {len(peaks_find_peaks)}")

機械学習で検出されたピーク数: 54
find_peaks関数で検出されたピーク数: 6