一文分享Python中三种降噪算法实现方法实测

def smooth_slow(signal, window=11):
    n = len(signal)
    result = np.zeros(n)
    half = window // 2

    for i in range(half, n - half):
        s = 0
        for j in range(i - half, i + half + 1):
            s += signal[j]
        result[i] = s / window

    return result

# 测试
import time
np.random.seed(42)
signal = np.random.randn(200) + 1000  # 模拟200点传感器数据

start = time.time()
for _ in range(1000):
    _ = smooth_slow(signal)
print(f"for循环: {time.time() - start:.2f}s")
# for循环: 45.23s

def smooth_numpy(signal, window=11):
    kernel = np.ones(window) / window
    return np.convolve(signal, kernel, mode='same')

start = time.time()
for _ in range(1000):
    _ = smooth_numpy(signal)
print(f"NumPy: {time.time() - start:.2f}s")
# NumPy: 3.09s

from scipy.signal import savgol_filter

start = time.time()
for _ in range(1000):
    _ = savgol_filter(signal, 11, 3)
print(f"Sav-Gol: {time.time() - start:.2f}s")
# Sav-Gol: 2.85s

import numpy as np
from scipy.signal import savgol_filter, find_peaks
from scipy.ndimage import gaussian_filter1d

# 生成测试数据
np.random.seed(42)
x = np.arange(380, 782, 2)
n = len(x)

baseline = 1000 + 50 * np.sin((x - 380) / 100)
p1 = 800 * np.exp(-((x - 450) / 15) ** 2)
p2 = 600 * np.exp(-((x - 550) / 20) ** 2)
p3 = 400 * np.exp(-((x - 680) / 25) ** 2)
true_signal = baseline + p1 + p2 + p3
raw = true_signal + np.random.normal(0, 30, n)

# 三种方法
ma = np.convolve(raw, np.ones(11)/11, mode='same')
gauss = gaussian_filter1d(raw, sigma=2)
sg = savgol_filter(raw, 11, 3)

# 看峰位误差
def peak_error(filtered, true):
    pf, _ = find_peaks(filtered, height=1200, distance=20)
    pt, _ = find_peaks(true, height=1200, distance=20)
    if len(pf) != len(pt): return 999, 999
    wl_err = np.mean(np.abs(x[pf] - x[pt]))
    int_err = np.mean(np.abs(filtered[pf] - true[pt]) / true[pt]) * 100
    return wl_err, int_err

print(f"移动平均 : 峰位误差 {peak_error(ma, true_signal)[0]:.2f}nm, 峰高误差 {peak_error(ma, true_signal)[1]:.1f}%")
print(f"高斯平滑 : 峰位误差 {peak_error(gauss, true_signal)[0]:.2f}nm, 峰高误差 {peak_error(gauss, true_signal)[1]:.1f}%")
print(f"Sav-Gol  : 峰位误差 {peak_error(sg, true_signal)[0]:.2f}nm, 峰高误差 {peak_error(sg, true_signal)[1]:.1f}%")

from scipy.signal import savgol_filter, find_peaks
import numpy as np

class FastProcessor:
    def __init__(self, x_axis):
        self.x = np.array(x_axis)

    def process(self, raw):
        # 降噪
        filtered = savgol_filter(raw, 11, 3)

        # 寻峰
        peaks, _ = find_peaks(filtered, height=np.mean(filtered)*1.5, distance=20)

        return {
            'filtered': filtered,
            'peaks': peaks,
            'peak_x': self.x[peaks],
            'peak_y': filtered[peaks]
        }

    def benchmark(self, raw, n=1000):
        import time
        _ = self.process(raw)  # 预热
        t0 = time.time()
        for _ in range(n):
            _ = self.process(raw)
        return (time.time() - t0) / n * 1000  # ms/次

# 用
proc = FastProcessor(np.arange(380, 782, 2))
result = proc.process(raw)
print(f"检测到 {len(result['peaks'])} 个峰")
print(f"单次处理: {proc.benchmark(raw):.2f}ms")