精华内容
下载资源
问答
  • 今天在用keras添加卷积层的时候,发现了kernel_size这个参数不知怎么理解,keras中文文档是这样描述的: kernel_size: 一个整数,或者单个整数表示的元组或列表, 指明 1D 卷积窗口的长度。 又经过多方查找,大体...
  • 关于Pytorch中kernel_size的输入值

    千次阅读 2021-04-15 10:21:42
    关于Pytorch中kernel_size的输入值 kernel_size可以输入一个整数值或者一个数组。当输入整数值时,比如x,会被脚本转成(x,x)形式。

    关于Pytorch中kernel_size的输入值

    kernel_size可以输入一个整数值或者一个数组。当输入整数值时,比如x,会被脚本转成(x,x)形式。

    展开全文
  • kernel_size

    千次阅读 2018-04-19 13:18:00
    kernel_size=(1,3)[flag] if flag==True:kernel_size=3 else: kernel_size=1 转载于:https://www.cnblogs.com/573177885qq/p/8882003.html

    kernel_size=(1,3)[flag]

    if flag==True:kernel_size=3

    else: kernel_size=1

    转载于:https://www.cnblogs.com/573177885qq/p/8882003.html

    展开全文
  • torch.nn.Conv2d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True) kernel_size:卷积核尺寸,可以设为1个int型数或者一个(int, int)型的元组。例如(2,3)是高2宽3...

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

    kernel_size:卷积核尺寸,可以设为1个int型数或者一个(int, int)型的元组。例如(2,3)是高2宽3卷积核

    kernel_size=(1, 3)[flag]
    if flag == False: kernel_size = 3 else: kernel_size = 1

    展开全文
  • PyTorch实现MLP的两种方法,以及nn.Conv1d, kernel_size=1和nn.Linear的区别MLP(Multi-layer perceptron)实现MLP结构方法1:nn.Linear方法2:nn.Conv1d & kernel_size=1nn.Conv1d, kernel_size=1与nn.Linear不同...

    MLP(Multi-layer perceptron,多层感知机)实现

    最近在看PointNet论文,其主要思想为利用MLP结构学习点云特征,并进行全局池化(构造一个对称函数,symmetric function),实现无序点集输入时特征提取的不变性。

    转到代码实现时,原以为用nn.LinearPyTorch)这个方法创建网络结构(因为结构上CNN中的全连层FC Layer就是一个MLP,而其实现用的就是nn.Linear),但实际上用的是nn.Conv1d(注意kernel_size=1)实现的,一下就有些疑问了,nn.Conv1d也能实现MLP结构?

    答案是肯定的,但输入数据形式存在不同

    MLP结构

    MLP应该是最简单的神经网络结构,下图(由NN-SVG生成)所示为一个输入层4节点隐含层8节点输出层3节点MLP
    MLP结构
    每一层的每个节点与前一层的所有节点进行连接(也即CNN中全连接的来由),节点的个数表示该层的特征维度,通过设置网络层数和节点个数,学习到输入数据的不同维度特征信息。

    具体到数据处理形式上,MLP计算如下:
    X = [ x 1 , x 2 , . . . , x m ] T X = [x_{1}, x_{2}, ..., x_{m}]^{T} X=[x1,x2,...,xm]T
    Y = [ y 1 , y 2 , . . . , y n ] T Y=[y_{1}, y_{2}, ..., y_{n}]^{T} Y=[y1,y2,...,yn]T
    h j = ∑ i = 1 m w i j x i h_{j}=\sum\limits_{i=1}^{m}w_{ij}x_{i} hj=i=1mwijxi
    y j = g ( h j ) = g ( ∑ i = 1 m w i j x i ) y_{j}=g(h_j)=g(\sum\limits_{i=1}^{m}w_{ij}x_{i}) yj=g(hj)=g(i=1mwijxi)
    其中:

    • X X X:输入层向量, m m m个维度/节点, Y Y Y:输出层向量, n n n个维度/节点,注意:此处输入层输出层指的是相邻两层前一层为输入层后一层为输出层与MLP的输入层和输出层概念不同
    • w w w:权重系数, w i j w_{ij} wij:输入层第 i i i个节点至输出层第 j j j个节点的权重
    • h j h_{j} hj:输出层第 j j j个节点的所有输入层节点加权之和
    • g ( ) g() g():激活函数
    • i = 1 , 2 , . . . , m i=1, 2, ..., m i=1,2,...,m j = 1 , 2 , . . . , n j=1, 2, ..., n j=1,2,...,n

    需要注意的是,上述表示的是以向量Tensor维度为1)作为输入的计算过程,对于由多个向量构成的多维矩阵Tensor维度大于等于2),计算过程类似,保持向量的组合尺寸,只对向量的不同特征维度进行加权计算

    例如,对于一个长度为100的点云100×3,tensor)进行MLP处理,经过一个3输入-10输出Layer计算后,输出结果仍为一个二维tensor100×10,tensor);同样,对于一个batch size为4,长度为100的点云数据包4×100×3,tensor),经过同样的Layer计算,输出为一个三维tensor4×100×10,tensor),如下图所示
    计算数据流

    方法1:nn.Linear

    PyTorch官方文档中nn.Linear的描述如下:
    nn.Linear介绍
    对输入数据 x x x进行一个线性变化,与上文中 h h h的计算方式一致,具体含义:

    • in_features:每个输入样本的大小,对应MLP中当前层的输入节点数/特征维度
    • out_features:每个输出样本的大小,对应MLP中当前层的输出节点数/特征维度
    • 输入数据形式:形状为[N, *, in_features]的tensor,N为batch size,这个参数是PyTorch各个数据操作中都具备的,相似的,输出数据形式为[N, *, out_features]

    需要注意的是输入输出数据形式中的*参数,其表示为任意维度,对于单个向量,*为空

    代码A:利用nn.Linear对单个点云数据(向量)进行Layer计算

    import torch
    import torch.nn as nn
    import torch.nn.functional as F
    
    x = torch.randn(1, 3)		# 创建batch_size=1的单个点云
    layer = nn.Linear(3, 10)	# 构造一个输入节点为3,输出节点为10的网络层
    y = F.sigmoid(layer(x))		# 计算y,sigmoid激活函数
    
    print(x.size())
    print(y.size())
    '''
    >>>torch.Size([1, 3])
    >>>torch.Size([1, 10])
    '''
    

    代码B:利用nn.Linear对点云集进行Layer计算

    import torch
    import torch.nn as nn
    import torch.nn.functional as F
    
    x = torch.randn(1, 100, 3)		# 创建一个batch_size=1的点云,长度100
    layer = nn.Linear(3, 10)	    # 构造一个输入节点为3,输出节点为10的网络层
    y = F.sigmoid(layer(x))		    # 计算y,sigmoid激活函数
    
    print(x.size())
    print(y.size())
    '''
    >>>torch.Size([1, 100, 3])
    >>>torch.Size([1, 100, 10])
    '''
    

    代码C:利用nn.Linear对多批次点云集进行Layer计算

    import torch
    import torch.nn as nn
    import torch.nn.functional as F
    
    x = torch.randn(4, 100, 3)		# 创建一个batch_size=4的点云,长度100
    layer = nn.Linear(3, 10)	    # 构造一个输入节点为3,输出节点为10的网络层
    y = F.sigmoid(layer(x))		    # 计算y,sigmoid激活函数
    
    print(x.size())
    print(y.size())
    '''
    >>>torch.Size([4, 100, 3])
    >>>torch.Size([4, 100, 10])
    '''
    

    通过上述代码可以看出,nn.Linear作用在输入数据的最后一个维度上,这一点不同于以下的nn.Conv1d

    方法2:nn.Conv1d & kernel_size=1

    Pytorch官方文档中nn.Conv1d的描述如下:
    nn.Conv1d介绍
    关键参数:

    • in_channels:输入通道,MLP中决定Layer输入的节点
    • out_channels:输出通道,MLP中决定Layer输出的节点
    • kernel_size:卷积核的宽度,应用在MLP中必须为1
    • stride:每次卷积移动的步长,应用在MLP中必须为1
    • padding:序列两端补0的个数,应用在MLP中必须为0

    与图像的二维卷积(可参考该博客中gif介绍)类似,一维卷积表示对序列数据进行卷积,如下图所示:
    一维卷积示意
    每个卷积核沿着数据长度方向对核内的数据进行卷积(根据卷积核权重累加),每移动一个步长获取一个值,所有的值构成输出的一个通道/特征维度;每个卷积核计算获得一个通道/特征维度

    由nn.Conv1d的输出长度计算方式和上图示意可知:

    kernel_size=1stride=1padding=0时,每个卷积核计算后输出数据和输入数据的长度相同,并且一一对应,即 h o j = ∑ s = 1 i c k s x j s h_{oj}=\sum\limits_{s=1}^{ic}k_{s}x_{js} hoj=s=1icksxjs o j oj oj为第 o o o个卷积核第 j j j个输出值, i c ic ic为输入数据的通道/特征维度, j s js js为输入数据第 j j j个中通道 s s s的位置,与MLP的节点计算方式一样,因此可以用nn.Conv1d进行MLP计算

    代码D:利用nn.Conv1d对单个点云数据(向量)进行Layer计算

    import torch
    import torch.nn as nn
    import torch.nn.functional as F
    
    x = torch.randn(1, 3, 1)		            # 创建batch_size=1的单个点云
    layer = nn.Conv1d(3, 10, kernel_size=1)	    # 构造一个输入节点为3,输出节点为10的网络层
    y = F.sigmoid(layer(x))		                # 计算y,sigmoid激活函数
    
    print(x.size())
    print(y.size())
    '''
    >>>torch.Size([1, 3, 1])
    >>>torch.Size([1, 10, 1])
    '''
    

    代码E:利用nn.Conv1d对点云集进行Layer计算

    import torch
    import torch.nn as nn
    import torch.nn.functional as F
    
    x = torch.randn(1, 3, 100)		            # 创建一个batch_size=1的点云,长度100
    layer = nn.Conv1d(3, 10, kernel_size=1)	    # 构造一个输入节点为3,输出节点为10的网络层
    y = F.sigmoid(layer(x))		                 # 计算y,sigmoid激活函数
    
    print(x.size())
    print(y.size())
    '''
    >>>torch.Size([1, 3, 100])
    >>>torch.Size([1, 10, 100])
    '''
    

    代码F:利用nn.Conv1d对多批次点云集进行Layer计算

    import torch
    import torch.nn as nn
    import torch.nn.functional as F
    
    x = torch.randn(4, 3, 100)		            # 创建一个batch_size=4的点云,长度100
    layer = nn.Conv1d(3, 10, kernel_size=1)	    # 构造一个输入节点为3,输出节点为10的网络层
    y = F.sigmoid(layer(x))		                 # 计算y,sigmoid激活函数
    
    print(x.size())
    print(y.size())
    '''
    >>>torch.Size([4, 3, 100])
    >>>torch.Size([4, 10, 100])
    '''
    

    通过上述代码可以看出,nn.Conv1d的输入数据格式只能一个三维tensor[batch, channel, length],与nn.Linear输入数据格式不同;并且,nn.Conv1d的数据作用位置也不同,nn.Conv1d作用在第二个维度channel

    nn.Conv1d, kernel_size=1与nn.Linear不同

    从上述方法1和方法2可以看出,两者可以实现同样结构的MLP计算,但计算形式不同,具体为:

    • nn.Conv1d输入的是一个[batch, channel, length]3维tensor,而nn.Linear输入的是一个[batch, *, in_features]可变形状tensor,在进行等价计算时务必保证nn.Linear输入tensor为三维
    • nn.Conv1d作用在第二个维度位置channelnn.Linear作用在第三个维度位置in_features,对于一个 X X X,若要在两者之间进行等价计算,需要进行tensor.permute重新排列维度轴秩序

    代码G:验证nn.Conv1d, kernel_size=1nn.Linear计算结果相同,代码来自stack overflow

    import torch
    
    def count_parameters(model):
        """Count the number of parameters in a model."""
        return sum([p.numel() for p in model.parameters()])
    
    conv = torch.nn.Conv1d(8,32,1)
    print(count_parameters(conv))
    # 288
    
    linear = torch.nn.Linear(8,32)
    print(count_parameters(linear))
    # 288
    
    print(conv.weight.shape)
    # torch.Size([32, 8, 1])
    print(linear.weight.shape)
    # torch.Size([32, 8])
    
    # use same initialization
    linear.weight = torch.nn.Parameter(conv.weight.squeeze(2))
    linear.bias = torch.nn.Parameter(conv.bias)
    
    tensor = torch.randn(128,256,8)
    permuted_tensor = tensor.permute(0,2,1).clone().contiguous()	# 注意此处进行了维度重新排列
    
    out_linear = linear(tensor)
    print(out_linear.mean())
    # tensor(0.0067, grad_fn=<MeanBackward0>)
    
    out_conv = conv(permuted_tensor)
    print(out_conv.mean())
    # tensor(0.0067, grad_fn=<MeanBackward0>)
    
    展开全文
  • 1. nn.Conv2d nn.Conv2d 输入信号的形式为(N, Cin, H, W), N表示batch size,Cin​表示channel个数,H,W分别表示特征图的高和宽。 参数说明: stride(步长):控制cross-correlation的步长,可...
  • pytorch中padding=kernel_size//2

    千次阅读 2020-06-28 18:56:13
    pytorch中padding=kernel_size//2到底是实现神魔形式的padding?padding=(kernel_size-1)/2 若kernel_size是7*7,5*5,3*3,1*1常见的 则padding是 3,2 ,1 ,0 nn.Conv2d的padding是在卷积之前补0,如果愿意...
  • kernel_size=(1,3)[flag] if flag==True:kernel_size=3 else: kernel_size=1
  • 在进行卷积运算和池化的时候,对于输入图像大小为input_size,给定kernel_size、padding、stride,计算得出output_size为: output_size =1+ (input_size+2*padding-kernel_size)/stride 怎么理解这个等式?首先...
  • 看到有文章说kernel_size为1的卷积相当于全连接层的运算,这里简单地使用1维的卷积核证明一下 输入的数据用X∈R(d,n)X \in \mathbb{R}^{(d,n)}X∈R(d,n)表示,共有nnn个数据,每个数据是ddd维。 全连接层用L∈R(d,d)...
  • 今天在用keras添加卷积层的时候,发现了kernel_size这个参数不知怎么理解,keras中文文档是这样描述的: kernel_size: 一个整数,或者单个整数表示的元组或列表, 指明 1D 卷积窗口的长度。 又经过多方查找,大体...
  • https://blog.csdn.net/tigerda/article/details/78800552 ●Theano中对Max-pooling的解释 Max-poolingisusefulinvisionfortworeasons: 1、Byeliminatingnon-maximalvalues,itreducescomputationforupp...
  • 但是默认的方法plot_model(model, to_file='model_ResNet.png',show_shapes=True)并不能显示conv和pooling的kernel_size,所以需要修改一下plot_model的方法plot_model-&gt;model_to_dot。 def plot_model(mo...
  • torch.nn.Conv2d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True, padding_mode=‘zeros’) 卷积核与原图按照左上角对齐的原则进行卷积操作 stride:步幅,卷积核...
  • https://blog.csdn.net/bpp94_github/article/details/81510279
  • ref ... torch.nn.functional.avg_pool2d(input, kernel_size, stride=None, padding=0, ceil_mode=False, count_include_pad=True) → Tensor 只需要输出张量, ...
  • ValueError: It seems that you are using the Keras 2 and you are passing both `kernel_size` and `strides` as integer positional arguments. For safety reasons, this is disallowed. Pass `strides` as a ke...
  • OpenCL-2.1文档相关描述 CL_KERNEL_GLOBAL_WORK_SIZE 这段文字表明使用 cl_kernel_work_group...SIZE 可以获得在此设备执行该kernel时最大的global size(也就是clEnqueueNDRangeKernel的global_work_size参数)。 ...
  • 首先,我觉得,输入大小肯定是可以调的,只不过相应的每一层网络的参数都要做调整,调整后结果如何,没有验证,我这里验证只修改了输入size和输入层的一些参数,conv1之后的网络参数都不变。 我不要你觉得,我要我...
  • 这是一份对最基本CNN代码的很详细很详细解析,特别适合CNN刚入门的同学。
  • 前言 本文介绍kernel_entry和kernel_exit两个宏,这两个函数并不单单是从用户空间进入内核空间以及从内核空间退出到用户空间才会用到。... .macro kernel_entry, el, regsize = 64 sub sp, sp, #S_FRA...
  • long __probe_kernel_read(void *dst, const void *src, size_t size) 用于安全的在非原子环境下从用户空间copy 数据到kernel空间。 其源码分析如下: 26 long __probe_kernel_read(void *dst, const void *src, ...
  • 1.1 卷积输出尺寸计算公式 ...输入图片大小为200×200,依次经过一层卷积(kernel size 5×5,padding 1,stride 2),pooling(kernel size 3×3,padding 0,stride 1),又一层卷积(kernel size 3×3,paddi...
  • keras 自定义kernel_initializer

    千次阅读 2020-03-15 21:14:36
    一:对Dense层 from keras import backend as K def my_init(shape, dtype=None): return K.random_normal(shape, dtype=dtype) model.add(Dense(64, kernel_initializer=my_init)) ...def kernel_init(sh...
  • 内核线程函数kernel_thread解析

    千次阅读 2017-03-16 18:30:05
     int kernel_thread (int ( * fn )( void * ), void * arg, unsigned long flags);  kernel_thread函数的作用是产生一个新的线程  内核线程实际上就是一个共享父进程地址空间的进程,它有自己的系统堆栈.  ...
  • 之前一直对tensorflow的padding一知半解,直到查阅了tensorflow/core/kernels/ops_util.cc中的Get2dOutputSizeVerbose函数,才...Kernel size:K, Stride : S, 公式为 W n + 1 = ( W n + P ∗ 2 − K ) / S + 1
  • Padding,Kernel-size,stride关系公式

    千次阅读 2018-03-25 01:37:27
    记录下公式,总忘记:像素宽度W,Padding size:P,Kernel size:K,Stride : S,公式为Wn+1=(Wn+P∗2−K)/S+1

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 259,286
精华内容 103,714
关键字:

kernel_size