精华内容
下载资源
问答
  • [PyTorch]PyTorch反卷积的用法

    千次阅读 2018-12-12 23:56:00
    [PyTorch]PyTorch反卷积的用法 文章来源:https://www.jianshu.com/p/01577e86e506 pytorch 2D 卷积层 和 2D 反卷积层 函数分别如下: class torch.nn.Conv2d(in_channels, out_channels, ...

    [PyTorch]PyTorch中反卷积的用法

    文章来源:https://www.jianshu.com/p/01577e86e506

    pytorch中的 2D 卷积层 和 2D 反卷积层 函数分别如下:

     class torch.nn.Conv2d(in_channels, out_channels, kernel_size, stride=1, padding=0, groups=1, bias=True)
    class torch.nn.ConvTranspose2d(in_channels, out_channels, kernel_size, stride=1, padding=0, output_padding=0, bias=True)

    我不禁有疑问:

    • 问题1: 两个函数的参数为什么几乎一致呢?
    • 问题2: 反卷积层中的 output_padding是什么意思呢?
    • 问题3: 反卷积层如何计算input和output的形状关系呢?
      看了中文文档后,我得不出答案,看了英文文档,才弄明白了。花费了一个下午的时间去研究这个问题,值得用此文纪录一下。

    我们知道,在卷积层中,输入输出的形状关系为:

    o = [ (i + 2p - k)/s ] +1 (1)

    其中:

    • O : 为 output size
    • i: 为 input size
    • p: 为 padding size
    • k: 为kernel size
    • s: 为 stride size
    • [] 为下取整运算

    (1) 当 S=1 时

    若 s等于1,则公式(1)中的取整符号消失,o 与 i 为 一一对应 的关系。 我们有结论:
    如果卷积层函数和反卷积层函数的 kernel_size, padding size参数相同(且 stride= 1),设反卷基层的输入输出形状为 i' 和 o', 卷积层的输入输出形状i和o, 则它们为 交叉对应 的关系,即:

    i = o'
    o = i'

    为回答问题3, 我们将上述关系代入公式中,即:

    i' = o' + 2p - k +1

    已知 i', 即可推出 o':

    o' = i' - 2p + k - 1 (2)

    摘两个例子:
    1450389-20181213000110152-558555683.png

    (2) 当 S>1 时

    若 S>1 , 则公式(1)中的取整符号不能消去,o 与 i 为 多对1 的关系。 效仿 S=1时的情形, 我们有结论:
    如果卷积层函数和反卷积层函数的 kernel_size, padding size参数相同(且 stride>1),设反卷基层的输入输出形状为 i' 和 o', 卷积层的输入输出形状i和o,

    i' = [ (o' + 2p - k)/s ] +1

    已知 i', 我们可以得出 s 个 o' 解:

    o'(0) = ( i' - 1) x s + k - 2p
    o'(1) = o'(1) + 1
    o'(2) = o'(1) + 2
    ...
    o'(s-1) = o'(1) + s-1

    即:

    o'(n) =o'(1) + n = ( i' - 1) x s + k - 2p + n,
    n = {0, 1, 2...s-1}

    为了确定唯一的 o' 解, 我们用反卷积层函数中的ouput padding参数指定公式中的 n 值。这样,我们就回答了问题(2)。

    摘一个简单的例子:
    1450389-20181213000244182-1569330603.png

    (3) 实验验证

    给出一小段测试代码,改变各个参数值,运行比较来验证上面得出的结论,have fun~.

    from torch import nn
    from torch.nn import init
    from torch.autograd import Variable
    
    dconv = nn.ConvTranspose2d(in_channels=1, out_channels= 1,  kernel_size=2, stride=2, padding=1,output_padding=0, bias= False)
    init.constant(dconv.weight, 1)
    print(dconv.weight)
    
    input = Variable(torch.ones(1, 1, 2, 2))
    print(input)
    print(dconv(input))
    
    posted @ 2018-12-12 23:56 向前奔跑的少年 阅读(...) 评论(...) 编辑 收藏
    展开全文
  • pytorch 2D 卷积层 和 2D 卷积层 函数分别如下: class torch.nn.Conv2d(in_channels, out_channels, kernel_size, stride=1, padding=0, groups=1, bias=True) class torch.nn.ConvTranspose2d(in_channels...
  • 转载自: https://zhuanlan.zhihu.com/p/39240159 pytorch反卷积的函数为: class torch.nn.ConvTranspose2d(in_channels, out_channels, kernel_size, stride=1, padding=0, ...

    转载自:

    https://zhuanlan.zhihu.com/p/39240159

     

    pytorch中反卷积的函数为:

    class torch.nn.ConvTranspose2d(in_channels, out_channels, kernel_size, stride=1, padding=0, 
                                                           output_padding=0, groups=1, bias=True, dilation=1)

    参数的含义如下:

    • in_channels(int) – 输入信号的通道数
    • out_channels(int) – 卷积产生的通道数
    • kerner_size(int or tuple) - 卷积核的大小
    • stride(int or tuple,optional) - 卷积步长,即要将输入扩大的倍数。
    • padding(int or tuple, optional) - 输入的每一条边补充0的层数,高宽都增加2*padding
    • output_padding(int or tuple, optional) - 输出边补充0的层数,高宽都增加padding
    • groups(int, optional) – 从输入通道到输出通道的阻塞连接数
    • bias(bool, optional) - 如果bias=True,添加偏置
    • dilation(int or tuple, optional) – 卷积核元素之间的间距

    对于每一条边输入输出的尺寸的公式如下:

    output = (input - 1)*stride+outputpadding - 2*padding+kernelsize

    展开全文
  • PyTorch反卷积的用法

    千次阅读 2019-05-29 22:03:49
    pytorch 2D 卷积层 和 2D 卷积层 函数分别如下: class torch.nn.Conv2d(in_channels, out_channels, kernel_size, stride=1, padding=0, groups=1, bias=True) class torch.nn.ConvTranspose2d(in_channels,...

    pytorch中的 2D 卷积层 和 2D 反卷积层 函数分别如下:

     class torch.nn.Conv2d(in_channels, out_channels, kernel_size, stride=1, padding=0, groups=1, bias=True)
    class torch.nn.ConvTranspose2d(in_channels, out_channels, kernel_size, stride=1, padding=0, output_padding=0, bias=True)
    

    我不禁有疑问:

    问题1: 两个函数的参数为什么几乎一致呢?
    问题2: 反卷积层中的 output_padding是什么意思呢?
    问题3: 反卷积层如何计算input和output的形状关系呢?
    看了中文文档后,我得不出答案,看了英文文档,才弄明白了。花费了一个下午的时间去研究这个问题,值得用此文纪录一下。
    我们知道,在卷积层中,输入输出的形状关系为:

    o = [ (i + 2p - k)/s ] +1 (1)
    

    其中:

    O : 为 output size
    i: 为 input size
    p: 为 padding size
    k: 为kernel size
    s: 为 stride size
    [] 为下取整运算
    (1) 当 S=1 时
    若 s等于1,则公式(1)中的取整符号消失,o 与 i 为 一一对应 的关系。 我们有结论:
    如果卷积层函数和反卷积层函数的 kernel_size, padding size参数相同(且 stride= 1),设反卷基层的输入输出形状为 i’ 和 o’, 卷积层的输入输出形状i和o, 则它们为 交叉对应 的关系,即:

    i = o'
    o = i'
    

    为回答问题3, 我们将上述关系代入公式中,即:

    i' = o' + 2p - k +1
    

    已知 i’, 即可推出 o’:

    o' = i' - 2p + k - 1 (2)
    

    摘两个例子:
    在这里插入图片描述

    (2) 当 S>1 时
    若 S>1 , 则公式(1)中的取整符号不能消去,o 与 i 为 多对1 的关系。 效仿 S=1时的情形, 我们有结论:
    如果卷积层函数和反卷积层函数的 kernel_size, padding size参数相同(且 stride>1),设反卷基层的输入输出形状为 i’ 和 o’, 卷积层的输入输出形状i和o,

      i' = [ (o' + 2p - k)/s ] +1
    

    已知 i’, 我们可以得出 s 个 o’ 解:

      o'(0) = ( i' - 1) x s + k - 2p
            o'(1) = o'(1) + 1
            o'(2) = o'(1) + 2
    
    ...
          o'(s-1) = o'(1) + s-1
    

    即:

    o'(n) =o'(1) + n = ( i' - 1) x s + k - 2p + n,
    n = {0, 1, 2...s-1}
    

    为了确定唯一的 o’ 解, 我们用反卷积层函数中的ouput padding参数指定公式中的 n 值。这样,我们就回答了问题(2)。

    摘一个简单的例子:
    在这里插入图片描述

    (3) 实验验证
    给出一小段测试代码,改变各个参数值,运行比较来验证上面得出的结论,have fun~.

    from torch import nn
    from torch.nn import init
    from torch.autograd import Variable
    
    dconv = nn.ConvTranspose2d(in_channels=1, out_channels= 1,  kernel_size=2, stride=2, padding=1,output_padding=0, bias= False)
    init.constant(dconv.weight, 1)
    print(dconv.weight)
    
    input = Variable(torch.ones(1, 1, 2, 2))
    print(input)
    print(dconv(input))
    

    这里是第二篇,更容易懂的
    在这里插入图片描述

    反卷积(Deconvolution)的概念第一次出现是Zeiler在2010年发表的论文Deconvolutional networks中,但是并没有指定反卷积这个名字,反卷积这个术语正式的使用是在其之后的工作中(Adaptive deconvolutional networks for mid and high level feature learning)。随着反卷积在神经网络可视化上的成功应用,其被越来越多的工作所采纳比如:场景分割、生成模型等。其中反卷积(Deconvolution)也有很多其他的叫法,比如:Transposed Convolution,Fractional Strided Convolution等等。

    这篇文章的目的主要有两方面:

    1. 解释卷积层和反卷积层之间的关系;
    2. 弄清楚反卷积层输入特征大小和输出特征大小之间的关系。

    卷积层

    卷积层大家应该都很熟悉了,为了方便说明,定义如下:
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    我们再把4×4的输入特征展成[16,1]的矩阵X ,那么Y = CX则是一个[4,1]的输出特征矩阵,把它重新排列2×2的输出特征就得到最终的结果,从上述分析可以看出卷积层的计算其实是可以转化成矩阵相乘的。值得注意的是,在一些深度学习网络的开源框架中并不是通过这种这个转换方法来计算卷积的,因为这个转换会存在很多无用的0乘操作,Caffe中具体实现卷积计算的方法可参考Implementing convolution as a matrix multiplication。

    通过上述的分析,我们已经知道卷积层的前向操作可以表示为和矩阵C相乘,那么 我们很容易得到卷积层的反向传播就是和C的转置相乘。
    

    反卷积和卷积的关系

    在这里插入图片描述
    在这里插入图片描述

    Fractionally Strided Convolution
    在这里插入图片描述

    在这里插入图片描述

    由上式可得,p=[s(i-1)+k-o]/2,然后向上取整, 由于向上取整了,所以最终的输出o‘可能还会小于我们要的输出o,则用out_padding = o - o’
    最后给出torch.nn.ConvTranspose2d的参数
    ConvTranspose2d(1, 3, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), output_padding=(1, 1))

    展开全文
  • 转置卷积又被称为反卷积和逆卷积,但是转置卷积才是最正规和主流叫法,在主流深度学习框架中,转置卷积的函数名都是conv_transpose 因为转置卷积运算过程很容易让人误解,举一个例子,一个4*4输入经过3*3...

    前言

    转置卷积又被称为反卷积和逆卷积,但是转置卷积才是最正规和主流的叫法,在主流的深度学习框架中,转置卷积的函数名都是conv_transpose
    因为转置卷积的运算过程很容易让人误解,举一个例子,一个4*4的输入经过3*3的卷积核(stride=1,padding=0)输出为2*2,而转置卷积将这个输出当作输入,即一个2*2的输入经过3*3的转置卷积核输出为4*4,看起来很像是卷积的逆操作,但事实并不是一个逆过程的概念

    转置卷积

    用公式可以更好的说明转置卷积与逆卷积的不同
    卷积运算可以这么表示:
    y=Cx y = Cx
    如果按照线性代数中的逆矩阵的概念,逆卷积的公式应该是这样:
    x=C1y x = C^{-1}y
    但是转置卷积的真实公式是:
    x=CTy x = C^{T}y
    参考https://zhuanlan.zhihu.com/p/79680474给出的用Numpy实现转置卷积,可以更直观的理解

    from torch import nn
    import numpy as np
    import torch
    batch_size = 1
    stride = 1
    padding = "VALID"
    input_channel = 1
    input_size = 5
    output_channel = 1
    filter_size = 3
    output_size = 3
    
    input_np = np.reshape(np.arange(input_size*input_size, dtype="float32"),newshape=[input_size,input_size])
    print(f"input_np = {input_np}")
    print("input_up.shape = %s" % str(input_np.shape))
    
    input_np_flattern = np.reshape(input_np, newshape=[input_size*input_size, 1])
    print(f"input_np_flattern = {input_np_flattern}")
    print("input_np_flattern = %s" % str(input_np_flattern.shape))
    
    filter_np = np.reshape(np.arange(filter_size*filter_size, dtype="float32"),newshape=[filter_size,filter_size])
    print(f"filter_np = {filter_np}")
    print("filter_np.shape = %s" % str(filter_np.shape))
    
    filter_np_matrix = np.zeros((output_size,output_size,input_size,input_size))
    print(filter_np_matrix.shape)
    # 卷积
    for h in range(output_size):
        for w in range(output_size):
            start_h = h*stride
            start_w = w*stride
            end_h = start_h + filter_size
            end_w = start_w + filter_size
            filter_np_matrix[h, w, start_h:end_h, start_w:end_w] = filter_np
    filter_np_matrix = np.reshape(filter_np_matrix,newshape=[output_size*output_size, input_size*input_size])
    print(f"filter_np_matrix = {filter_np_matrix}")
    print("filter_np_matrix.shape = %s" % str(filter_np_matrix.shape))
    # 相乘
    output_np = np.dot(filter_np_matrix, input_np_flattern)
    output_np = np.reshape(output_np, newshape=[output_size, output_size])
    print(f"output_np = {output_np}")
    print("output_np.shape = %s" % str(output_np.shape))
    
    # 反卷积
    output_np_flattern = np.reshape(output_np, newshape=[output_size*output_size, 1])
    output_np_transpose = np.dot(filter_np_matrix.T, output_np_flattern)
    output_np_transpose = np.reshape(output_np_transpose, newshape=[input_size,input_size])
    print(f"output_np_transpose = {output_np_transpose}")
    print("output_np_transpose.shape = %s" % str(output_np_transpose.shape))
    

    用PyTorch实现转置卷积

    仿照沐神的动手深度学习一书,用PyTorch重写了下

    # 初始化权重
    conv_weight = torch.arange(1,17,dtype=torch.float32).reshape((1,1,4,4))
    conv_input = torch.arange(1,10,dtype=torch.float32).reshape((1,1,3,3))
    conv = nn.Conv2d(in_channels=1, out_channels=1, kernel_size=3, padding=0)
    print(conv.weight)
    
    conv.weight = torch.nn.Parameter(conv_weight)
    print(conv.weight)
    print(conv.forward(conv_input))
    # 用矩阵乘法实现卷积运算
    W, k = torch.zeros((4,16)) , torch.zeros(11)
    k[:3], k[4:7], k[8:] = conv_input[0, 0, 0, :], conv_input[0, 0, 1, :], conv_input[0, 0, 2, :]
    W[0, 0:11], W[1, 1:12], W[2, 4:15], W[3, 5:16] = k, k, k, k
    print(torch.mm(W,conv_input.reshape(16,-1)).reshape((1,1,2,2)))
    
    # conv2d
    conv = nn.Conv2d(in_channels=3, out_channels=10, kernel_size=4, padding=1, stride=2)
    conv_weight = torch.arange(0,480,dtype=torch.float32).reshape((10,3,4,4))
    conv.weight = torch.nn.Parameter(conv_weight)   # 初始化conv
    
    print(f"conv_weight_shape={conv_weight.shape}")
    print(conv)
    conv_input = torch.randn((1,3,64,64),dtype=torch.float32)
    conv_output = conv.forward(conv_input)
    print(f"conv_output={conv_output.shape}")  # 经过conv2d之后,原图尺寸缩小了两倍
    # transpose conv
    conv_trans = nn.ConvTranspose2d(in_channels=10,out_channels=3,kernel_size=4,padding=1,stride=2)
    conv_trans_weight = torch.arange(0,480,dtype=torch.float32).reshape((3,10,4,4))
    conv_trans_weight.weight = torch.nn.Parameter(conv_trans_weight)   # 初始化conv
    print(f"conv_trans_weight_shape={conv_trans_weight.shape}")
    print(f"conv_trans_output={conv_trans.forward(conv_output).shape}")
    
    
    展开全文
  • Pytorch卷积与反卷积详解(conv2d和convTranspose2d)

    千次阅读 多人点赞 2020-04-26 09:28:38
    Pytorch卷积与反卷积详解(conv2d和convTranspose2d) 卷积和反卷积是图片计算在深度学习中常用上采样和下采样操作。相比其他采样操作,卷积计算不仅可以保存参数梯度传递(适用用BP),还可以改变图片通道以更...
  • #卷积步长,就是卷积操作时每次移动格子数 padding=0, #原图周围需要填充格子行(列)数 output_padding=0, #输出特征图边缘需要填充行(列)数,一般不设置 groups=1, #分组卷积的组数,一般默认设置为1,...
  • 本博文为本人学习笔记。参考材料为《深度学习入门之——PyTorchpytorch中文网:https://www.pytorchtutorial.com/  ...关于卷积和反卷积函数参数——“dilation(int or tuple, opt...
  • ps之前写过反卷积(Deconvolution)、上采样(UNSampling)与上池化(UnPooling)加入自己思考(一),不过那是东拼西凑出来别人东西就是稍微加入点自己理解。今天在看代码时候又出现上池化和反卷积这两个选项。...
  • ps:最近在做分割在github上找代码看模型时老发现尺度从小到大那部分,有是采用上采样(双线性插值)+卷积,有反卷积。为什么不相同能,我查阅相关资料发现这位知乎大神根据外网大佬文章总结原因。知乎地址:...
  • 转置卷积/反卷积

    2019-03-27 16:04:31
    pytorch反卷积的函数为: class torch.nn.ConvTranspose2d(in_channels, out_channels, kernel_size, stride=1, padding=0, output_padding=0, groups=1, bias=True, dilation=1) 参数含义如下: ...
  • 因为对卷积运算有基础,就不从0开始写了,下面概括地介绍相关概念后,重点放在卷积层在PyTorch的实现上。 卷积运算:卷积核在输入信号(图像)上滑动,相应位置上进行乘加。网上有很多图例,清晰地介绍了卷积运算的...
  • pytorch反卷积函数的说明:FCN中一个很重要的部分—反卷积 图片通过卷积层降低分辨率,提取特征,而反卷积则是把图片重新放大的一个结构。 在语义分割中,必须对反卷积的反卷积核进行参数初...
  • 转置卷积(反卷积

    2021-06-15 20:49:37
    在主流深度学习框架之中,如Tensorflow,Pytorch,Kreas中的函数名都是conv_transpose 将一个4 * 4输入通过3 * 3的卷积核核进行普通卷积后(无padding,stride=1),将得到2 * 2输出。而转置卷积将一个2 * 2...
  • 反卷积原理与参数设置 ConvTranspose2d

    千次阅读 2019-11-19 09:14:35
    PyTorch中 nn.Conv2d与nn.ConvTranspose2d函数的用法 反卷积的具体过程和原理在引文《》中说很清楚了。 这里着重说一下反卷积参数output_padding:输出边补充0个数,高宽都增加output_padding。 即如果没有使用...
  • 卷积神经网络之上采样-pytorch

    千次阅读 2019-01-22 14:59:42
    利用卷积神经网络进行图像处理(图像超分、图像编码、风格...pytorch的双线性上采样函数torch.nn.Upsample(scale_factor=scale_factor, mode='bilinear'),参数model为选择的上采样插值算法。  2、反卷积。pyto...
  • 发现存在deconvolutional反卷积网络。 在使用cfg进行训练时反卷积网络无法识别,进行修改时发现反卷积后缺少上采样模块(被注释了),取消注释后,进行训练到反卷积那层时出现错误&#...
  • Environment OS: macOS Mojave ...本文记录一下使用 PyTorch 建立神经网络模型中各种层定义方法,包括卷积层(卷积、转置卷积)、池化层(平均池化、最大池化、池化)、全连接层、激活函数层。这里主要记录对于二
  • Pytorch中torch.nn.ConvTranspose2d函数详解

    千次阅读 2019-10-11 14:17:10
    ConvTranspose,即反卷积,通过卷积形式,利用图像特征“恢复”到原图像。 当然,此处卷积核权重参数与前面下采样卷积核参数互相独立,且可更新。 也就是说“反”卷积不是之前逆过程,无法保证完全恢复。 ...
  • 如这种形式,反卷积方法在conv1d_transpose中定义,在训练时候,model.parameters()会为空,在__init__()中加一部分带参数方法即可; 报错为:raise ValueError("optimizer got an empty parameter list") ...
  • 本节学习池化层,全连接层和激活函数层,在池化层中有正常的最大值池化,均值池化,还有图像分割任务中常用的反池化——MaxUnpool,在激活函数中会学习Sigmoid,Tanh和Relu,以及Relu的各种变体,如LeakyReLU,PReLU...
  • 任务名称:学习网络层中的卷积层,池化层,全连接层和激活函数层 ...本节第二部分学习池化层,全连接层和激活函数层,在池化层中有正常的最大值池化,均值池化,还有图像分割任务中常用的反池化——
  • 任务名称:学习网络层中的卷积层,池化层,全连接层和激活函数层 ...本节第二部分学习池化层,全连接层和激活函数层,在池化层中有正常的最大值池化,均值池化,还有图像分割任务中常用的反池化——MaxUn
  • 转置卷积学习笔记

    2020-04-13 17:58:29
    转置卷积最全博客链接 (最下面) 这一份足够了!!!因为连我这个学渣都看懂了 deconv / transposed conv ...在主流深度学习框架中,如TensorFlow,Pytorch,Keras中的函数名都是conv_transpose。 一开始困惑地...
  • 在阅读本博文之前,最好熟悉卷积神经网络基本组件,例如卷积、反卷积、batch_normalization、激活函数、dropout、图像插值等。 U-Net模型架构 上图为15年Ronneberger提出网络模型U-Net,本文将介绍Res_U-Net,...
  • 在主流深度学习框架之中,如Tensorflow,Pytorch,Kreas中的函数名都是conv_transpose。卷积的动态图解可以点此链接查看。 将一个4X4输入通过3X3的卷积核核进行普通卷积后(无padding,stride=1),将得到2X2输出...
  • 任务简介: 学习网络模型中采用的神经...本节第二部分学习池化层,全连接层和激活函数层,在池化层中有正常的最大值池化,均值池化,还有图像分割任务中常用的反池化——MaxUnpool,在激活函数中会学习Sigmoid,Tanh

空空如也

空空如也

1 2
收藏数 34
精华内容 13
关键字:

pytorch的反卷积函数