卷积 nn.Conv1d()与 nn.Conv2d()

比眉伴天荒 2023-07-07 12:46 56阅读 0赞

卷积的数据输入格式：\[**batch\_size,in\_channels,height,width**\]，如果是一维卷积，则只输入width，即只在宽度方向上卷积。

### 1. nn.Conv1d(in\_channels,out\_channels,kernel\_size,stride,padding,dilation,groups,bias) ###

*  一维卷积，这里的一维不仅代表在一个维度上进行卷积，而且代表卷积的方向为一维

接口内的参数：

*  in\_channels：NLP任务中代表词向量的维度
 *  out\_channels：卷积产生的通道数，out\_channels==卷积核的数量
 *  kernel\_size：卷积核尺寸，卷积核大小==(k,in\_channels)，这里卷积核的第二维度等于in\_channels
 *  padding：输入的每一条边，补充0的层数

还是参考大家都在用的例子，加深一下理解：

import torch.nn as nn
    
    conv1=nn.Conv1d(in_channels=256,out_channels=100,kernel_size=2)
    input=t.randn(32,35,256)    # 32--batch_size，35--sentence_length,256--embedding_dim
    input=input.permute(0,2,1) # 一维卷积方向，只在宽度上卷积（高度是字向量维度），交换最后两个维度
    out=conv1(input)    # 32 x 100 x (35-2+1)
    print(out.size())
    
    #输出
    torch.Size([32, 100, 34])

**注意：卷积操作后，维度计算公式**：![\\frac \{n+2p-f\}\{s\}][frac _n_2p-f_s]

其中，**n**表示输入维度的原始大小，**p**表示padding，**f**表示卷积核大小，**s**表示步长stride。

### 2. nn.Conv2d(in\_channels,out\_channels,kernel\_size,stride=1,padding=0,dilation=1,groups=1,bias=True) ###

通常二维卷积用于图像（NLP任务中也可以进行二维卷积）数据，对宽度和高度进行卷积。

需要注意随着卷积的层数变化，卷积核参数也可能随着变化，还有池化参数。

直接看个例子，共定义两层卷积，每一层卷积都是经过了卷积-->非线性激活-->池化，这个过程，两层卷积之后是三层全连接网络，看到这里你可能会想到了，没错就是论文里的经典TextCNN模型结构：

import torch.nn as nn
    import torch.nn.functional as F
    
    class CNN(nn.Module):
        def __init__(self):
            super(CNN, self).__init__()
            # 初始化参数
            self.conv1=nn.Conv2d(in_channels=1,out_channels=6,kernel_size=5)
            self.conv2=nn.Conv2d(in_channels=6,out_channels=16,kernel_size=5)
            self.fc1=nn.Linear(5*5*16,120)  # 5*5*16的由来是最后一层卷积的输出结果
            self.fc2=nn.Linear(120,84)
            self.fc3=nn.Linear(84,10)
    
        def forward(self, x):   #重写父类方法
            # 未处理之前数据结构为：32*32*1
            #第一层卷积
            x=self.conv1(x)     #(32-5+1)=28，所以卷积结果：28*28*6
            x=F.relu(x)
            x=F.max_pool2d(x,2) #28/2=14，池化结果：14*14*6
            #第二层卷积
            x=self.conv2(x)     #14-5+1=10,所以卷积结果：10*10*16
            x=F.relu(x)
            x=F.max_pool2d(x,2) #10/2=5，池化结果：5*5*16
            #三层全连接网络
            x=x.view(x.size()[0],-1)# 5*5*16=400，-1的作用是新扩展的维度默认设置为1，view之后结果：400*1
            x=F.relu(self.fc1(x))
            x=F.relu(self.fc2(x))
            x=self.fc3(x)
            return x
    
    cnn=CNN()
    print(cnn)
    
    #输出：
    CNN(
      (conv1): Conv2d(1, 6, kernel_size=(5, 5), stride=(1, 1))
      (conv2): Conv2d(6, 16, kernel_size=(5, 5), stride=(1, 1))
      (fc1): Linear(in_features=400, out_features=120, bias=True)
      (fc2): Linear(in_features=120, out_features=84, bias=True)
      (fc3): Linear(in_features=84, out_features=10, bias=True)
    )

[frac _n_2p-f_s]: https://private.codecogs.com/gif.latex?%5Cdpi%7B100%7D%20%5Cfrac%20%7Bn&plus;2p-f%7D%7Bs%7D