为何OpenCV的sepFilter2D比filter2D慢，且二者均不及连续应用1D滤波器？

我希望在Python中实现大图像的快速2D卷积/相关计算，所用滤波器可分离，但会产生额外计算成本。目前我发现最快的实现方式是使用OpenCV，但其中的分离滤波函数sepFilter2D反而比非分离的filter2D更慢。以下是我在4核笔记本上得到的计时结果：

import cv2
import numpy as np
import timeit
M = 2048
N = 8192
K = 25
A = np.random.randn(M, N).astype('float32')
b = np.random.randn(1, K).astype('float32')
c = np.random.randn(K, 1).astype('float32')
bc = c*b
X = cv2.filter2D(A, -1, bc, borderType=cv2.BORDER_CONSTANT)
Y = cv2.sepFilter2D(A, -1, b, c, borderType=cv2.BORDER_CONSTANT)
Z = cv2.filter2D(cv2.filter2D(A, -1, b, borderType=cv2.BORDER_CONSTANT), -1, c, borderType=cv2.BORDER_CONSTANT)

# 验证结果一致性
assert np.linalg.norm(X-Y)/np.linalg.norm(X) < 1e-6
assert np.linalg.norm(X-Z)/np.linalg.norm(X) < 1e-6

%timeit cv2.filter2D(A, -1, bc, borderType=cv2.BORDER_CONSTANT)
%timeit cv2.sepFilter2D(A, -1, b, c, borderType=cv2.BORDER_CONSTANT)
%timeit cv2.filter2D(cv2.filter2D(A, -1, b, borderType=cv2.BORDER_CONSTANT), -1, c, borderType=cv2.BORDER_CONSTANT)

计时结果：

• filter2D（非分离）：309 ms ± 8.34 ms per loop（7次运行，每次1循环）
• sepFilter2D：445 ms ± 21.2 ms per loop（7次运行，每次1循环）
• 连续两次filter2D（1D+1D）：123 ms ± 1.02 ms per loop（7次运行，每次10循环）

我尝试连续应用两个1D滤波器，发现这种方式比前两种方法更快，请问这是为什么？此外，我还希望能从分离滤波器获得更大性能提升，有没有更快的分离滤波器2D卷积实现方式？

回答 #

为什么连续两次1D滤波更快？ #

• 内存访问效率更高：sepFilter2D内部可能存在额外开销，比如重复的边界处理、数据格式转换，或者没有针对你的4核CPU做针对性优化。而两次filter2D处理1D卷积时，行方向滤波按连续内存块读取，列方向同理，缓存命中率更高，大幅减少了内存等待时间。
• 计算量优势充分发挥：分离卷积的理论计算量是2*M*N*K，而非分离卷积是M*N*K²。当K=25时，前者计算量仅为后者的约8%（50/625），理论上速度差应该很大。你的测试结果符合这个理论，而sepFilter2D没体现出优势，说明它的实现没充分利用计算量优势，反而被内部冗余操作拖慢。
• 并行化效率更好：两次filter2D调用可能各自更好地利用了CPU多核并行，而sepFilter2D的并行策略可能不够高效，内部同步开销更大。

更快的分离卷积实现方式 #

• 用NumPy组合一维卷积：通过np.convolve结合apply_along_axis分别处理行和列，手动匹配边界条件：

  # 行方向卷积（匹配BORDER_CONSTANT）
  padded_rows = np.pad(A, ((0,0), (K//2, K//2)), mode='constant')
  row_conv = np.apply_along_axis(lambda x: np.convolve(x, b.flatten(), mode='valid'), axis=1, arr=padded_rows)
  # 列方向卷积
  padded_cols = np.pad(row_conv, ((K//2, K//2), (0,0)), mode='constant')
  final = np.apply_along_axis(lambda x: np.convolve(x, c.flatten(), mode='valid'), axis=0, arr=padded_cols)
  

• 使用SciPy的separable_filter：SciPy的该函数专门针对分离滤波器优化，底层实现更高效：

  from scipy.ndimage import separable_filter
  result = separable_filter(A, weights=(c.flatten(), b.flatten()))
  

• 手动优化边界填充：提前用np.pad按需求补边，再调用cv2.filter2D处理1D核，避免函数内部边界处理的额外开销：

  # 行方向滤波
  padded_A = np.pad(A, ((0,0), (K//2, K//2)), mode='constant')
  row_filtered = cv2.filter2D(padded_A, -1, b, borderType=cv2.BORDER_CONSTANT)[:, K:-K]
  # 列方向滤波
  padded_row = np.pad(row_filtered, ((K//2, K//2), (0,0)), mode='constant')
  final = cv2.filter2D(padded_row, -1, c, borderType=cv2.BORDER_CONSTANT)[K:-K, :]
  

• 优化OpenCV线程数：通过cv2.setNumThreads(4)设置线程数等于CPU核心数，进一步提升两次filter2D的并行效率。
• GPU加速（若有硬件）：用PyTorch/TensorFlow等框架的GPU卷积实现，能获得数量级的性能提升：

  import torch
  # 转成GPU张量
  A_tensor = torch.tensor(A, dtype=torch.float32).unsqueeze(0).unsqueeze(0).cuda()
  b_tensor = torch.tensor(b.flatten(), dtype=torch.float32).unsqueeze(0).unsqueeze(0).cuda()
  c_tensor = torch.tensor(c.flatten(), dtype=torch.float32).unsqueeze(0).unsqueeze(0).cuda()
  # 行卷积（padding匹配BORDER_CONSTANT）
  row_conv = torch.nn.functional.conv2d(A_tensor, b_tensor, padding=(0, K//2))
  # 列卷积（转置核实现列方向）
  col_conv = torch.nn.functional.conv2d(row_conv, c_tensor.permute(0,1,3,2), padding=(K//2, 0))
  # 转回numpy数组
  result = col_conv.squeeze().cpu().numpy()
  

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