PyTorch 卷积层的使用

最新推荐文章于 2025-05-08 22:18:06 发布

峡谷的小鱼

最新推荐文章于 2025-05-08 22:18:06 发布

阅读量350

点赞数

CC 4.0 BY-SA版权

分类专栏： PyTorch使用文章标签：机器学习 pytorch 深度学习 python 数据分析

本文链接：https://blog.youkuaiyun.com/weixin_43276033/article/details/124487133

PyTorch使用专栏收录该内容

21 篇文章

订阅专栏

本文详细介绍了PyTorch中一维、二维和三维卷积层的结构、输入输出尺寸计算公式，以及卷积运算过程。重点展示了如何使用Conv1d、Conv2d和Conv3d类进行卷积操作，适合深度学习初学者和开发者参考。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

PyTorch 卷积

1. 一维卷积层

卷积层输入：(N, C, L)
N: batch的样本数量
C: 样本的通道数
L: 样本通道的尺寸大小
$⋆\star$ : 卷积运算

如果卷积层的输入尺寸为：(N, C_in, L_in)，则输出尺寸 (N, C_out, L_out) 的计算为：
$Lout=⌊Lin+2×padding−dilation×(kernel_size−1)−1stride+1⌋ L_{out} = \left\lfloor\frac{L_{in} + 2 \times \text{padding} - \text{dilation} \times (\text{kernel\_size} - 1) - 1}{\text{stride}} + 1\right\rfloor$
卷积层运算：
$\text{out}(N_i, C_{\text{out}_j}) = \text{bias}(C_{\text{out}_j}) + | \sum_{k = 0}^{C_{in} - 1} \text{weight}(C_{\text{out}_j}, k) | \star \text{input}(N_i, k)$

class Conv1d(_ConvNd):
    r"""
    一维卷积层
    
    Method resolution order:
        Conv1d
        _ConvNd
        torch.nn.modules.module.Module
        builtins.object
    """
    
    def __init__(
        self, 
        in_channels, 
        out_channels, 
        kernel_size, 
        stride=1, 
        padding=0, 
        dilation=1, 
        groups=1, 
        bias=True):
        r"""
        parameters:
            in_channels: int, 输入图片的通道数
            out_channels: int, 卷积生成的输出通道数
            kernel_size: int or tuple, 卷积核的大小
            stride: int or tuple, optional, 卷积的步幅
            padding: int or tuple, optional, 添加到输入边缘的填充
            dilation: int or tuple, optional, 核元素之间的间距
            groups: int, optional, 从输入通道到输出通道的blocked连接数
            bias: bool, optional, 如果为True，为输出添加一个可学习的bias
            
        attributes:
            weight: tensor, size(out_channels, in_channels/groups, kernel_size), 卷积的权重
            bias: tensor, size(out_channels), 卷积的偏置系数
        """
        ... ...
        
    def __call__(self, input, output):
        r"""
        parameters:
            input: size(N, C_in, L_in)
            output: size(N, C_out, L_out)
        """

2. 二维卷积层

卷积层输入：(N, C, H, W)
N: batch的样本数量
C: 样本的通道数
H: 输入样本的高(像素单位)
W：输入样本的宽(像素单位)
$⋆\star$ : 卷积运算

如果卷积层的输入尺寸为：(N, C_in, H_in, W_in)，则输出尺寸 (N, C_out, H_out, W_out) 的计算为：
$Hout=⌊Hin+2×padding[0]−dilation[0]×(kernel_size[0]−1)−1stride[0]+1⌋ H_{out} = \left\lfloor\frac{H_{in} + 2 \times \text{padding}[0] - \text{dilation}[0] \times (\text{kernel\_size}[0] - 1) - 1}{\text{stride}[0]} + 1\right\rfloor$
$Wout=⌊Win+2×padding[1]−dilation[1]×(kernel_size[1]−1)−1stride[1]+1⌋ W_{out} = \left\lfloor\frac{W_{in} + 2 \times \text{padding}[1] - \text{dilation}[1] \times (\text{kernel\_size}[1] - 1) - 1}{\text{stride}[1]} + 1\right\rfloor$
卷积层运算：
$\text{out}(N_i, C_{\text{out}_j}) = \text{bias}(C_{\text{out}_j}) + \sum_{k = 0}^{C_{\text{in}} - 1} \text{weight}(C_{\text{out}_j}, k) \star \text{input}(N_i, k)$

class Conv2d(_ConvNd):
    r"""
    二维卷积层
    
    Method resolution order:
        Conv2d
        _ConvNd
        torch.nn.modules.module.Module
        builtins.object
    """
    
    def __init__(
        self, 
        in_channels, 
        out_channels, 
        kernel_size, 
        stride=1, 
        padding=0, 
        dilation=1, 
        groups=1, 
        bias=True):
        r"""
        parameters:
            in_channels: int, 输入图片的通道数
            out_channels: int, 卷积生成的输出通道数
            kernel_size: int or tuple, 卷积核的大小
            stride: int or tuple, optional, 卷积的步幅
            padding: int or tuple, optional, 添加到输入边缘的填充
            dilation: int or tuple, optional, 核元素之间的间距
            groups: int, optional, 从输入通道到输出通道的blocked连接数
            bias: bool, optional, 如果为True，为输出添加一个可学习的bias
            
        attributes:
            weight: tensor, size(out_channels, in_channels/groups, kernel_size), 卷积的权重
            bias: tensor, size(out_channels), 卷积的偏置系数
        """
        ... ...
        
    def __call__(self, input, output):
        r"""
        parameters:
            input: size(N, C_in, H_in, W_in)
            output: size(N, C_out, H_out, W_out)
        """

3. 三维卷积层

卷积层输入：(N, C, D, H, W)
N: batch的样本数量
C: 样本的通道数
D: 输入样本的深度
H: 输入样本的高(像素单位)
W：输入样本的宽(像素单位)
$⋆\star$ : 卷积运算

如果卷积层的输入尺寸为：(N, C_in, D_in, H_in, W_in)，则输出尺寸 (N, C_out, D_out, H_out, W_out) 的计算为：
$Dout=⌊Din+2×padding[0]−dilation[0]×(kernel_size[0]−1)−1stride[0]+1⌋ D_{out} = \left\lfloor\frac{D_{in} + 2 \times \text{padding}[0] - \text{dilation}[0] \times (\text{kernel\_size}[0] - 1) - 1}{\text{stride}[0]} + 1\right\rfloor$
$Hout=⌊Hin+2×padding[1]−dilation[1]×(kernel_size[1]−1)−1stride[1]+1⌋ H_{out} = \left\lfloor\frac{H_{in} + 2 \times \text{padding}[1] - \text{dilation}[1] \times (\text{kernel\_size}[1] - 1) - 1}{\text{stride}[1]} + 1\right\rfloor$
$Wout=⌊Win+2×padding[2]−dilation[2]×(kernel_size[2]−1)−1stride[2]+1⌋ W_{out} = \left\lfloor\frac{W_{in} + 2 \times \text{padding}[2] - \text{dilation}[2] \times (\text{kernel\_size}[2] - 1) - 1}{\text{stride}[2]} + 1\right\rfloor$
卷积层运算：
$out(N_i, C_{out_j}) = bias(C_{out_j}) + \sum_{k = 0}^{C_{in} - 1} weight(C_{out_j}, k) \star input(N_i, k)$

class Conv3d(_ConvNd):
    r"""
    三维卷积层
    
    Method resolution order:
        Conv3d
        _ConvNd
        torch.nn.modules.module.Module
        builtins.object
    """
    
    def __init__(
        self, 
        in_channels, 
        out_channels, 
        kernel_size, 
        stride=1, 
        padding=0, 
        dilation=1, 
        groups=1, 
        bias=True):
        r"""
        parameters:
            in_channels: int, 输入图片的通道数
            out_channels: int, 卷积生成的输出通道数
            kernel_size: int or tuple, 卷积核的大小
            stride: int or tuple, optional, 卷积的步幅
            padding: int or tuple, optional, 添加到输入边缘的填充
            dilation: int or tuple, optional, 核元素之间的间距
            groups: int, optional, 从输入通道到输出通道的blocked连接数
            bias: bool, optional, 如果为True，为输出添加一个可学习的bias
            
        attributes:
            weight: tensor, size(out_channels, in_channels/groups, kernel_size), 卷积的权重
            bias: tensor, size(out_channels), 卷积的偏置系数
        """
        ... ...
        
    def __call__(self, input, output):
        r"""
        parameters:
            input: size(N, C_in, D_in, H_in, W_in)
            output: size(N, C_out, D_out, H_out, W_out)
        """