精华内容
下载资源
问答
  • flattened-cnn, 平坦卷积神经网络( Torch nn的一维卷积模块) 平卷积神经网络这个包有 1D 个卷积模块,在( http://arxiv.org/abs/1412.5474 ) 中使用,我们把平坦的卷积层表示为所有 3D 个方向的一个一维过滤器序列。...
  • torch.nn.Conv1d及一维卷积详解

    万次阅读 多人点赞 2019-11-06 16:25:09
    近日在搞wavenet,期间遇到了一维卷积,在这里对一维卷积以及其pytorch中的API进行总结,方便下次使用 之前对二维卷积是比较熟悉的,在初次接触一维卷积的时候,我以为是一个一维的卷积核在一条线上做卷积,但是这种...

    近日在搞wavenet,期间遇到了一维卷积,在这里对一维卷积以及其pytorch中的API进行总结,方便下次使用

    之前对二维卷积是比较熟悉的,在初次接触一维卷积的时候,我以为是一个一维的卷积核在一条线上做卷积,但是这种理解是错的,一维卷积不代表卷积核只有一维,也不代表被卷积的feature也是一维。一维的意思是说卷积的方向是一维的。

    下边首先看一个简单的一维卷积的例子(batchsize是1,也只有一个kernel):

    输入:

    一个长度为35的序列,序列中的每个元素有256维特征,故输入可以看作(35,256)
    卷积核: size = (k,) , (k = 2)

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-aUj1VA0m-1573028650763)(https://ranchofromxgd.github.io/_posts/assets/2019-11-06-16-16-37.png)]

    这幅图只说明了只有一个数据的情况,如果将数据打包成batch,可以用代码表示如下:

        from torch.autograd import Variable
        conv1 = nn.Conv1d(in_channels=256,out_channels = 100, kernel_size = 2)
        input = torch.randn(32, 35, 256)
        # batch_size x text_len x embedding_size -> batch_size x embedding_size x text_len
        input = input.permute(0, 2, 1)
        input = Variable(input)
        out = conv1(input)
        print(out.size())
    

    输出:

    torch.Size([32, 100, 34])
    

    在分析这个结果之前先来看一下nn.Conv1d的官方文档

    // 可以理解为特征的维度
    in_channels – Number of channels in the input image 
    //输出的通道数,可以理解为卷积核的数量
    out_channels – Number of channels produced by the convolution
    // 卷积核的大小,只需要指定卷积方向的大小(因为是一维的)
    kernel_size – Size of the convolving kernel
    stride – Stride of the convolution
    padding – Zero-padding added to both sides of the input
    dilation – Spacing between kernel elements
    groups – Number of blocked connections from input channels to output channels
    bias – If True, adds a learnable bias to the output
    

    再来看输出:torch.Size([32, 100, 34])

    输入数据第一维表示batchsize,后边两维和前边的例子一样,不同的是输出,长度变为了34(卷积核大小为2),由于有100个卷积核,故生成了100个feature map

    可能还会有一个疑惑,就是感觉100和34位置反过来了,这是因为nn.Conv1d对输入数据的最后一维进行一维卷积,为了将卷积方向设置正确,我们需要将输入序列长度这一维放到最后,即使用permute函数,这样就可以实现一维卷积。

    展开全文
  • 一维卷积不代表卷积核只有一维,也不代表被卷积的feature也是一维。一维的意思是说卷积的方向是一维的。 class torch.nn.Conv1d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups...

    一维卷积不代表卷积核只有一维,也不代表被卷积的feature也是一维。一维的意思是说卷积的方向是一维的。

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

    • in_channels(int) – 输入信号的通道。在文本分类中,即为词向量的维度
    • out_channels(int) – 卷积产生的通道。有多少个out_channels,就需要多少个1维卷积
    • kernel_size(int or tuple) - 卷积核的尺寸,卷积核的大小为(k,),第二个维度是由in_channels来决定的,所以实际上卷积大小为kernel_size*in_channels
    • stride(int or tupleoptional) - 卷积步长
    • padding (int or tupleoptional)- 输入的每一条边补充0的层数
    • dilation(int or tuple, `optional``) – 卷积核元素之间的间距
    • groups(intoptional) – 从输入通道到输出通道的阻塞连接数
    • bias(booloptional) - 如果bias=True,添加偏置

    下面通过具体例子说明参数的设置和用法。

    代码如下:

    import torch
    import torch.nn as nn

    # 卷积大小为kernel_size*in_channels, 此处也即 3 * 4, 每个卷积核产生一维的输出数据,长度与输入数据的长度和stride有关,根据ouotput可知是3,第二个参数2也就卷积核的数量
    m = nn.Conv1d(4, 2, 3, stride=2)

    # 第一个参数理解为batch的大小,输入是4 * 9格式 
    input = torch.randn(1, 4, 9)
    print(input)
    output = m(input)
    print(output)
    print(output.size())

    输出如下:

    tensor([[[-0.2105, -1.0958,  0.7299,  1.1003,  2.3175,  0.8186, -1.7510,  -0.1925,  0.8591],
             [ 1.0991, -0.3016,  1.5633,  0.6162,  0.3150,  1.0413,  1.0571,  -0.7014,  0.2239],
             [-0.0658,  0.4755, -0.6653, -0.0696,  0.3483, -0.0360, -0.4665,   1.2606,  1.3365],
             [-0.0186, -1.1802, -0.8835, -1.1813, -0.5145, -0.0534, -1.2568,   0.3211, -2.4793]]])
    tensor([[[-0.8012,  0.0589,  0.1576, -0.8222],
             [-0.8231, -0.4233,  0.7178, -0.6621]]], grad_fn=<SqueezeBackward1>)
    torch.Size([1, 2, 4])

    第一个卷积核进行如下操作:

    得到输出1*4的输出:

    [-0.8012, 0.0589, 0.1576, -0.8222]

    第二个卷积核进行类似操作:

    得到输出1*4的输出:

    [-0.8231, -0.4233, 0.7178, -0.6621]

    合并得到最后的2*4的结果:

    输入的input为 4 * 9 ,输出为 2 * 4

    展开全文
  • 声明(本文转载自博客《torch.nn.Conv1d及一维卷积详解》)

    声明(本文转载自博客《torch.nn.Conv1d及一维卷积详解》

    展开全文
  • 一维卷积是施加于两个数列(一个输入,一个核)的一种计算,过程可简单描述为:首先将两行数字左对齐,上下对应的数字分别相乘然后取和,得到一个新值;接着将核依照步长(stride)向右滑动,再次分别相乘取和得到新...

    torch.nn.Conv1d

    torch.nn.Conv1d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True,padding_mode= ‘zeros’)

    • in_channels:输入通道数
    • out_channels:输出通道数(同卷积核个数)
    • kernel_size:卷积核“长度”,其另一维度值与输入的通道数相同,所以卷积核尺寸为kernel_size*in_channels
    • stride:滑动步长,默认为1
    • padding:补充0的个数,默认为0。例:当padding=1,则在输入的每一通道的数列的左右两端各补一个0
    • dilation:核的元素之间的间隔。 默认为1。(1应该是指元素间距,1即紧邻)
    • groups:分组数。例如,当groups=1,则所有输入都卷积到输出;groups=2时,这个操作就相当于有两个conv层并排,每个conv层作用于一半的输入通道,产生一半的输出通道,然后两者串联起来;groups= in_channels时,每个输入通道都用它自己的一组滤波器进行卷积,这些滤波器的大小为⌊in_channels/out_channels⌋

    一维卷积过程

    一维卷积是施加于两个数列(一个输入,一个核)的一种计算,过程可简单描述为:首先将两行数字左对齐,上下对应的数字分别相乘然后取和,得到一个新值;接着将核依照步长(stride)向右滑动,再次对应相乘取和得到新值;继续该滑动和计算过程,直到核的右端超出输入数组,此时不再计算,结束。例:

    a=np.array([i for i in range(7)]).reshape(1,7,1)
    conv1 = nn.Conv1d(in_channels=1,out_channels=1,kernel_size=2)
    input = torch.Tensor(a) # shape (1,7,1) # in_channels=1
    input = input.permute(0,2,1)    # shape (1,1,7) # in_channels=1
    print(input)
    
    nn.init.constant_(conv1.weight, 1)	# 将核的元素值初始化为全1
    nn.init.constant_(conv1.bias, 0)	# 偏置值为0
    print(conv1.weight)
    
    out = conv1(input)
    print(out.size())
    print(out)
    # 结果:
    # tensor([[[0., 1., 2., 3., 4., 5., 6.]]])
    # Parameter containing:
    # tensor([[[1., 1.]]], requires_grad=True)
    # torch.Size([1, 1, 6])
    # tensor([[[ 1.,  3.,  5.,  7.,  9., 11.]]], grad_fn=<SqueezeBackward1>)
    

    输入的形状(1,7,1),数值分别对应batch大小、数列(或文本分类中句子)的长度、通道数,即数列的个数(或文本分类中组成句子的单词的最大长度)。
    nn.Conv1d的参数in_channels为输入的通道数,此例中1,即只有一个数列(或理解为该句子中每个单词仅一个字母),out_channels为输出的通道数(后面再具体说),kernel_size为核的长度。
    permute函数将输入的形状进行了变换,以对应所生成的核的形状。
    核的值被初始化为[1,1],卷积过程:01+11=1,11+21=3…51+61=11,得[1,3,5,7,9,11],结果为1个数列,即out_channels=1

    上述为输入为一维的情况。当输入为二维,且第二个维度(通道数)值c>1,即有c个数列时,核也需要是二维(多通道),且第二个维度值(通道数)同样为c。例:(c=5)

    a=np.array([i for i in range(35)]).reshape(1,7,5)
    conv1 = nn.Conv1d(in_channels=5,out_channels=1,kernel_size=2)
    input = torch.Tensor(a) # shape (1,7,5) # in_channels=5
    input = input.permute(0,2,1)    # shape (1,5,7) # in_channels=5
    print(input)
    
    nn.init.constant_(conv1.weight, 1)	# 将核的元素值初始化为全1
    nn.init.constant_(conv1.bias, 0)	# 偏置值为0
    print(conv1.weight)
    
    out = conv1(input)
    print(out.size())
    print(out)
    # 结果
    # tensor([[[ 0.,  5., 10., 15., 20., 25., 30.],
    #          [ 1.,  6., 11., 16., 21., 26., 31.],
    #          [ 2.,  7., 12., 17., 22., 27., 32.],
    #          [ 3.,  8., 13., 18., 23., 28., 33.],
    #          [ 4.,  9., 14., 19., 24., 29., 34.]]])
    # Parameter containing:
    # tensor([[[1., 1.],
    #          [1., 1.],
    #          [1., 1.],
    #          [1., 1.],
    #          [1., 1.]]], requires_grad=True)
    # torch.Size([1, 1, 6])
    # tensor([[[ 45.,  95., 145., 195., 245., 295.]]], grad_fn=<SqueezeBackward1>)
    

    输入的通道数为5,即5个数列。第一行的数列与第一行的[1,1]进行卷积操作得到[5,15,25,35,45,55],第二行的数列与第二行的[1,1]进行卷积操作得到[7,17,27,37,47,57],同理,得到:

    [5,15,25,35,45,55]
    [7,17,27,37,47,57]
    [9,19,29,39,49,59]
    [11,21,31,41,51,61]
    [13,23,33,43,53,63]
    

    将五个结果的对应元素分别取和,得最终结果[ 45,95,145,195,245,295],out_channels仍为1。
    可以看出,每个卷积核产生一个通道值,即out_channels=卷积核个数,当需要改变out_channels时,就需要增加卷积核个数,且每个卷积核的通道数=输入的通道数

    展开全文
  • 所谓的一维卷积,也就是卷积核是一维的。原理和2D Conv类似,只不过1D Conv的卷积核移动方向只有一个。 而且每组卷积核个数也等于输入人间的通道数。 实际操作中,以点云文件为例:包含nx3的数据,进行卷积前...
  • 一维卷积神经网络在维度S上进行卷积 如下,设置一维卷积网络的输入通道为16维,输出通道为33维,卷积核大小为3,步长为2 # in_channels: 16 # out_channels: 33 # kernel_size: 3 m = nn.Conv1d(16, 33, 3, ...
  • 一维卷积 torch.nn.Conv1d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True, padding_mode=‘zeros’) 这个函数用来对输入张量做一维卷积 in_channel和out_...
  • 去年,师兄使用一维卷积和单位矩阵的特殊性质,使用pytorch实现傅里叶变换,并且可以追溯到三年前,有人已经实现了这种算法。https://github.com/pseeth/torch-stft​github.com我的研究方向也是语音前端,反复碰到...
  • 一维卷积默认的输入格式是:input = (batch_size,channel,vector_dim) 看下面一个简单的例子: # max_sent_len=35, batch_size=50, embedding_size=300 conv1 = nn.Conv1d(in_channels=300, out_channels=100, ...
  • 卷积神经网络基础我们介绍卷积神经网络的卷积层和池化层,并解释填充、步幅、输入通道和输出通道的含义。import torch from torch.autograd import Variable a=Variable(torch.FloatTensor([[2.,4.]]),requires_grad...
  • 维卷积nn.Conv2d

    2020-05-29 11:07:05
    维卷积nn.Conv2d 一般来说,二维卷积nn.Conv2d用于图像数据,对宽度和高度都进行卷积。 定义 class torch.nn.Conv2d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=...
  • PyTorch——二维卷积

    2021-03-07 12:39:00
    参考链接 ... 二互相关计算 虽然卷积层得名于卷积(convolution)运算...在二卷积层中,个二输入数组和个二维核(kernel)数组通过互相关运算输出个二数组。 def corr2d(X, K): h, w = K.shape Y = torch
  • Pytorch中二维卷积nn.Conv2d的理解

    千次阅读 2019-09-07 16:40:13
    目录函数定义例子第卷积 函数定义 class torch.nn.Conv2d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True) 例子 以MNIST数据集手写数字识别为例,网络定义...
  • Torch.nn模块学习-卷积

    2021-02-24 18:37:20
    Pytorch的nn模块中有针对一维数据、二维数据和三维数据的卷积操作和转置卷积操作,转置卷积操作可以理解为上采样,不过本次学习的目的以学习基础为主,主要学习卷积,常用的卷积操作如下: 对应的类 功能作用 ...
  • 本专业使用了大量的卷积运算,最近学习python,python里面的库比较多,不同的库中有不同的运算,现在将一维的总结如下,之后累计可能更新。 2010年1月16对比的函数如下:-----------...
  • pytorch方法测试——卷积一维

    千次阅读 2018-06-12 19:22:48
    import torch import torch.nn as nn m = nn.Conv1d(2, 5, 2, stride=2) print(m) input = torch.randn(2,2, 5) print(input) output = m(input) print(m.weight) print(m.bias) print(output) print(output.size()...
  • 从至少个数据集上进行实验,同理,这里我选取了车辆分类数据集(后面的实验都是用的车辆分类数据集),主要在之前利用torch.nn实现二维卷积的基础上,为解决感受野比较的问题,将普通的卷积修改为空洞卷积,并且卷...
  • pytorch 卷积 分组卷积 及其深度卷积

    千次阅读 2018-11-15 20:49:05
    先来看看pytorch二维卷积的操作API                                           现在继续讲讲几个卷积是如何操作的。 . 普通卷积 torch.nn.Conv2d(in_channels, out...
  • torch.nn.functional 涉及了所有 torch.nn 需要 类 和 方法 ,torch.nn 构建的模块通常就是调用 torch.nn.functional 里...L:一维数据的长度 下标 $i, k, o $ 分别表示输入、卷积核、输出 1 卷积 ###1.1 torch.nn.fu.
  • torch.nn.Conv1d图文解析

    2021-04-13 09:15:36
    nn.Conv1d 一维卷积解析 对于一维卷积,我们可能以为是一个一维的卷积核在一条线上做卷积,但是这种理解是错的,一维卷积不代表卷积核只有一维,也不代表被卷积的feature也是一维。一维的意思是说卷积的方向是一维的...
  • Conv1d()函数就是利用指定大小的一维卷积核对输入的多通道一维输入信号进行一维卷积操作的卷积层。 因为卷积神经网络一般用来处理图片数据,常使用torch.nn.Conv2d,所以torch.nn.Conv1d不太常见,但事实上卷积神经...

空空如也

空空如也

1 2 3 4 5 6
收藏数 108
精华内容 43
关键字:

torch一维卷积