在 PyTorch 中加速一维卷积

Question

对于我的项目，我使用 pytorch 作为线性代数后端。对于代码的性能部分，我需要对 2 个小（长度在 2 到 9 之间）向量（一维张量）进行多次一维卷积。我的代码允许对输入进行批处理，因此我可以堆叠几个输入向量来创建可以同时进行卷积的矩阵。由于 torch.conv1d 不允许沿单一维度对 2D 输入进行卷积，因此我不得不编写自己的卷积函数 convolve。然而，这个新函数包含一个双 for 循环，因此非常非常慢。

问题：如何通过更好的代码设计使 convolve 函数执行得更快，并使其能够处理批处理输入（=2D 张量）？

部分答案：以某种方式避免双重 for 循环

下面是三个重新创建最小示例的 jupyter notebook 单元格。请注意，您需要 line_profiler 和 %%writefile 魔术命令才能完成这项工作！

%%writefile SO_CONVOLVE_QUESTION.py
import torch

def conv1d(a, v):
    padding = v.shape[-1] - 1
    return torch.conv1d(
        input=a.view(1, 1, -1), weight=v.flip(0).view(1, 1, -1), padding=padding, stride=1
    ).squeeze()

def convolve(a, v):
    if a.ndim == 1:
        a = a.view(1, -1)
        v = v.view(1, -1) 

    nrows, vcols = v.shape
    acols = a.shape[1]

    expanded = a.view((nrows, acols, 1)) * v.view((nrows, 1, vcols))
    noutdim = vcols + acols - 1
    out = torch.zeros((nrows, noutdim))
    for i in range(acols):  
        for j in range(vcols):
            out[:, i+j] += expanded[:, i, j]  
    return out.squeeze()
    
x = torch.randn(5)
y = torch.randn(7)

我将代码写入 SO_CONVOLVE_QUESTION.py，因为这是 line_profiler 所必需的，并且用作 timeit.timeit 的设置。

现在我们可以评估上述代码在非批输入 (x, y) 和批输入 (x_batch, y_batch) 上的输出和性能：

from SO_CONVOLVE_QUESTION import *
# Without batch processing
res1 = conv1d(x, y)
res = convolve(x, y)
print(torch.allclose(res1, res)) # True

# With batch processing, NB first dimension!
x_batch = torch.randn(5, 5)
y_batch = torch.randn(5, 7)

results = []
for i in range(5):
    results.append(conv1d(x_batch[i, :], y_batch[i, :]))
res1 = torch.stack(results)
res = convolve(x_batch, y_batch)
print(torch.allclose(res1, res))  # True

print(timeit.timeit('convolve(x, y)', setup=setup, number=10000)) # 4.83391789999996
print(timeit.timeit('conv1d(x, y)', setup=setup, number=10000))   # 0.2799923000000035

在上面的块中，您可以看到使用 conv1d 函数执行 5 次卷积产生与 convolve 对批处理输入相同的结果。我们还可以看到 convolve (= 4.8s) 比 conv1d (= 0.28s) 慢很多。下面我们使用 line_profiler:

评估没有批处理的 convolve 函数的慢速部分

%load_ext line_profiler
%lprun -f convolve convolve(x, y)  # evaluated without batch-processing!

输出：

Timer unit: 1e-07 s

Total time: 0.0010383 s
File: C:\python_projects\pysumo\SO_CONVOLVE_QUESTION.py
Function: convolve at line 9

Line #      Hits         Time  Per Hit   % Time  Line Contents
==============================================================
     9                                           def convolve(a, v):
    10         1         68.0     68.0      0.7      if a.ndim == 1:
    11         1        271.0    271.0      2.6          a = a.view(1, -1)
    12         1         44.0     44.0      0.4          v = v.view(1, -1) 
    13                                           
    14         1         28.0     28.0      0.3      nrows, vcols = v.shape
    15         1         12.0     12.0      0.1      acols = a.shape[1]
    16                                           
    17         1       4337.0   4337.0     41.8      expanded = a.view((nrows, acols, 1)) * v.view((nrows, 1, vcols))
    18         1         12.0     12.0      0.1      noutdim = vcols + acols - 1
    19         1        127.0    127.0      1.2      out = torch.zeros((nrows, noutdim))
    20         6         32.0      5.3      0.3      for i in range(acols):  
    21        40        209.0      5.2      2.0          for j in range(vcols):
    22        35       5194.0    148.4     50.0              out[:, i+j] += expanded[:, i, j]  
    23         1         49.0     49.0      0.5      return out.squeeze()

显然，双 for 循环和创建 expanded 张量的行是最慢的。这些部分是否可以通过更好的代码设计来避免？

Answer 1

Pytorch 有一个名为 torch.nn.functional 的批处理分析工具，你有一个 conv1d 函数（显然还有 2d 以及更多）。我们将使用 conv1d.

假设您想将 v1 中给出的 100 个向量与 v2 中给出的 1 个向量进行卷积。 v1 的维度为 (minibatch , in channels , weights) 并且默认需要 1 个通道。此外，v2 的尺寸为 * (\text{out_channels} , (out_channels,groups / in_channels,kW)*。您使用的是 1 个通道，因此 1分组所以 v1 和 v2 将由：

import torch
from torch.nn import functional as F

num_vectors = 100
len_vectors = 9
v1 = torch.rand((num_vectors, 1, len_vectors))
v2 = torch.rand(1, 1, 6)

现在我们可以通过

简单地计算必要的填充

padding = torch.min(torch.tensor([v1.shape[-1], v2.shape[-1]])).item() - 1

并且可以使用

完成卷积

conv_result = temp = F.conv1d(v1, v2, padding=padding)

我没有计时，但它应该比你最初的双 for 循环快得多。

Answer 2

事实证明，有一种方法可以不用 for-loops 通过沿维度对输入进行分组：

out = torch.conv1d(x_batch.unsqueeze(0), y_batch.unsqueeze(1).flip(2), padding=y_batch.size(1)-1, groups=x_batch.size(0))
print(torch.allclose(out, res1))  # True

在 PyTorch 中加速一维卷积

speeding up 1d convolution in PyTorch

python

pytorch

linear-algebra

convolution