如何在Python 3.10+NumPy中高效实现高斯平滑？

一、问题根源 #

你当前的实现是逐个数据点构建缓冲区和高斯核，本质还是Python层面的循环操作——哪怕用了NumPy，这种逐点处理的模式也没法发挥NumPy的向量化计算优势，这就是性能拉胯的核心原因。

二、现成的高性能替代函数 #

直接用成熟库的实现比自己手写高效得多，推荐两个靠谱方案：

1. SciPy的gaussian_filter1d #

这是专门针对一维数据的高斯平滑函数，底层是C实现，性能拉满。直接传入你的Y数组、高斯核标准差（sigma）就能得到平滑结果，窗口大小可以自动适配（也可手动指定）。

示例代码：

import numpy as np
from scipy.ndimage import gaussian_filter1d
import matplotlib.pyplot as plt

def main():
    # 参数设置
    sigma = 2.0  # 高斯核标准差
    num_points = 10000

    # 生成测试数据
    x = np.linspace(0, 100, num_points)
    y = np.random.randn(num_points) + 5 * np.sin(x/10)

    # 高斯平滑
    y_smoothed = gaussian_filter1d(y, sigma=sigma)

    # 绘图对比
    plt.plot(x, y, label='原始数据', alpha=0.5)
    plt.plot(x, y_smoothed, label='平滑后数据', linewidth=2)
    plt.legend()
    plt.show()

if __name__ == "__main__":
    main()

处理10000个点基本是毫秒级完成，完全解决你的性能问题。

2. Pandas滚动窗口+高斯权重 #

如果需要更灵活的窗口控制（比如自定义窗口内的高斯权重分布），可以用Pandas的滚动窗口配合权重计算：

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

def gaussian_weights(window_size, sigma):
    # 生成归一化的高斯权重数组
    x = np.linspace(-window_size//2, window_size//2, window_size)
    weights = np.exp(-x**2/(2*sigma**2))
    return weights / weights.sum()

def main():
    sigma = 2.0
    window_size = int(6*sigma + 1)  # 覆盖99.7%高斯分布的常用窗口大小
    num_points = 10000

    x = np.linspace(0, 100, num_points)
    y = np.random.randn(num_points) + 5 * np.sin(x/10)

    # 应用滚动平滑
    weights = gaussian_weights(window_size, sigma)
    y_smoothed = pd.Series(y).rolling(window=window_size, center=True).apply(lambda w: np.dot(w, weights), raw=True)

    plt.plot(x, y, label='原始数据', alpha=0.5)
    plt.plot(x, y_smoothed, label='平滑后数据', linewidth=2)
    plt.legend()
    plt.show()

if __name__ == "__main__":
    main()

这个方案比纯Python循环快很多，性能略逊于SciPy的实现，但胜在灵活可控。

三、自己实现的优化方向（不想用第三方库的话） #

如果必须自己写，核心是用向量化操作替代逐点循环：

1. 预先生成完整的高斯核，不要每个点都重新生成
2. 用NumPy的卷积操作np.convolve完成整个数组的平滑，而非逐个点计算

示例代码：

import numpy as np
import matplotlib.pyplot as plt

def gaussian_kernel(sigma, window_size=None):
    if window_size is None:
        window_size = int(6*sigma + 1)
    if window_size % 2 == 0:
        window_size += 1  # 确保窗口为奇数，实现中心对齐
    x = np.linspace(-window_size//2, window_size//2, window_size)
    kernel = np.exp(-x**2/(2*sigma**2))
    return kernel / kernel.sum()  # 归一化权重

def vectorized_gaussian_smooth(y, sigma):
    kernel = gaussian_kernel(sigma)
    # mode='same'保证输出和输入长度一致
    return np.convolve(y, kernel, mode='same')

def main():
    sigma = 2.0
    num_points = 10000

    x = np.linspace(0, 100, num_points)
    y = np.random.randn(num_points) + 5 * np.sin(x/10)

    y_smoothed = vectorized_gaussian_smooth(y, sigma)

    plt.plot(x, y, label='原始数据', alpha=0.5)
    plt.plot(x, y_smoothed, label='平滑后数据', linewidth=2)
    plt.legend()
    plt.show()

if __name__ == "__main__":
    main()

这个实现利用了NumPy的卷积优化，性能比你原来的逐点处理提升几个数量级，处理10000个点同样能在毫秒级完成。

关键注意点 #

• 不管用哪种方案，绝对避免在Python循环里逐个处理数据点，尽量用向量化操作或底层C实现的函数
• 高斯核的窗口大小一般取6*sigma +1，既保证平滑效果，又不会浪费计算资源

内容的提问来源于stack exchange，提问作者Runsva