【卷积】Conv与Depthwise Seperable Conv

最新推荐文章于 2023-08-17 22:03:35 发布
最新推荐文章于 2023-08-17 22:03:35 发布
阅读量1.6k 收藏 14
点赞数 4
分类专栏： TensorFlow Conv Python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010637291/article/details/114269279
版权
TensorFlow 同时被 3 个专栏收录
21 篇文章 7 订阅
订阅专栏
Python
21 篇文章 2 订阅
订阅专栏
Conv
3 篇文章 0 订阅
订阅专栏

文章目录

参考

卷积计算方式：https://zhuanlan.zhihu.com/p/268179286

Depthwise卷积与Pointwise卷积：https://zhuanlan.zhihu.com/p/80041030

1. 卷积（计算过程、输入输出、参数个数、乘法次数）

ref: https://zhuanlan.zhihu.com/p/268179286

卷积，本质上是矩阵点乘和加法。
如下图所示，输入为蓝色部分即7x7的矩阵，卷积核为蓝色阴影部分即3x3的矩阵。卷积计算即在输入中依次选取和卷积核大小相等的矩阵，与卷积核依次进行矩阵点乘（对应位置进行相乘，并将结果累和），最后再加一个偏置项。所以，输出为绿色部分即5x5的矩阵。

在这里插入图片描述

单通道与多通道：输入可能是单通道如上图所示，实际应用中可能有单通道语音；也可能是多通道，如图像中的红蓝绿三个通道、语音中的多通道语音识别。

单卷积核与多卷积核：卷积核个数还可以是多个，那我们为什么需要多个卷积核进行卷积呢？对于一个卷积核，可以认为其具有识别某一类元素（特征）的能力；而对于一些复杂的数据来说，仅仅只是通过一类特征来进行辨识往往是不够的。因此，通常来说我们都会通过多个不同的卷积核来对输入进行特征提取得到多个特征图，然再输入到后续的网络中。

1.1 单通道单卷积核

单通道输入、单卷积核

输入：现有一张形状为[5,5,1]的单通道灰度图

卷积核：一个卷积核为[3,3]的矩阵，和偏置项
在这里插入图片描述

卷积计算过程

卷积计算过程如下：
在这里插入图片描述

即：
在这里插入图片描述
则：

输出、参数个数、乘法次数

输出：为单通道，矩阵大小为[3, 3]

参数个数：即单卷积核参数个数加偏置项，即3x3 + 1 = 10

乘法次数：
每次矩阵点乘的乘法次数为：卷积核大小即 3x3 = 9
总共乘法次数为：9 * 9 = 81
总共加法次数为：9

1.2 单通道多卷积核

单通道输入、多卷积核

输入：现有一张形状为[5,5,1]的单通道灰度图

2个卷积核：2个卷积核为[3,3]的矩阵，和2个偏置项：

其实可以看出，有几个偏置项就有几个卷积核（在use_bias=True的情况下）。
在这里插入图片描述

卷积计算过程

每个通道的卷积计算和单通道单卷积核计算过程一样：
在这里插入图片描述

那么，多通道单卷积核就有多个单通道单卷积核计算过程：

在这里插入图片描述

输出、参数个数、乘法次数

输出：为多通道，矩阵大小为[3, 3, 2]

参数个数：
即多卷积核参数个数加偏置项，即2 * ( 3 x 3 + 1) = 20

乘法次数：
每次矩阵点乘的乘法次数为：卷积核大小即 3x3 = 9
总共乘法次数为：2 * 9 * 9 = 162
总共加法次数为：9 * 2 = 18

1.3 多通道单卷积核

多通道输入、单卷积核

输入：现有一张形状为[5,5,3]的多通道红蓝绿三色图

单卷积核：1个卷积核为[3,3, 3]的矩阵，和1个偏置项

注：此时的单卷积核和单通道单卷积核中的单卷积核不同，维度由[3, 3] 变为了 [3, 3, 3]，即变为了多通道的单卷积核；但偏置项个数为1，即还是一个单卷积核。
在这里插入图片描述

卷积计算过程

可看出输入和卷积核均为多个通道，此时即将每个通道的输入和卷积核进行点乘，累和后，与其他通道的累和结果进行相加，最后再加上偏置项：
在这里插入图片描述
即：
在这里插入图片描述

输出、参数个数、乘法次数

输出：为单通道，矩阵大小为[3, 3]

参数个数：即单卷积核参数个数加偏置项，即3x3x3 + 1 = 28

乘法次数：
每次矩阵点乘的乘法次数为：卷积核大小即 3x3 = 9
总共乘法次数为：9 * 3个通道 * 9个输出参数个数 = 243
总共加法次数为：9

1.4 多通道多卷积核

多通道输入、多卷积核

输入：现有一张形状为[5,5,3]的多通道红蓝绿三色图

多卷积核：2个卷积核为[3, 3, 3]的矩阵，和2个偏置项

在这里插入图片描述

卷积计算过程

可看出多通道多卷积核与多通道单卷积核计算过程类似（而不是单通道多卷积核），因为此时卷积核的“通道个数”为3。

所以卷积计算过程即为多个 多通道单卷积核计算过程：

在这里插入图片描述

输出、参数个数、乘法次数

输出：为多通道，矩阵大小为[3, 3, 2]

参数个数：
即多个卷积核参数个数加偏置项，即2 x (3x3x3 + 1) = 56

乘法次数：
每次矩阵点乘的乘法次数为：卷积核大小即 3x3 = 9
总共乘法次数为：2个通道*（9 * 3个通道 * 9个feature个数 ）= 486
总共加法次数为：9* 2个通道 = 18

2. 实现示例

2.1 单通道单卷积核

单通道输入：[1, 34, 13, 1]的单通道矩阵，即输入的batch_size = 1，width = 34, height = 13, channels = 1

单卷积核：
filters=1,
kernel_size=[10, 4]
use_bias=True：一个偏置项
strides=[3, 2]：卷积移动步长
padding=“VALID”：不进行padding

def cnn_model():
    from tensorflow import keras

    inputs = keras.Input(shape=(34, 13, 1))
    net = keras.layers.Conv2D(filters=1, kernel_size=(10, 4), strides=(3, 2), padding='VALID', 
                              dilation_rate=(1, 1), use_bias=True, name='conv_1')(inputs)
    net = keras.layers.BatchNormalization()(net)
    outputs = keras.layers.ReLU()(net)

    model = keras.Model(inputs=inputs, outputs=outputs)
    model.compile(
        loss=keras.losses.categorical_crossentropy,
        optimizer=keras.optimizers.Adadelta(),
        metrics=['accuracy']
    )

    model.summary()
    keras.utils.plot_model(model, 'cnn.png', show_shapes=True)

    convert_keras_to_tflite_dynamic_range(model, filename_tflite="./tflite/cnn.tflite")

    return model

def convert_keras_to_tflite_dynamic_range(model, filename_tflite="./tflite/cnn.tflite"):
    converter = tf.lite.TFLiteConverter.from_keras_model(model)
    converter.optimizations = [tf.lite.Optimize.DEFAULT]
    tflite_model = converter.convert()
    open(filename_tflite, "wb").write(tflite_model)

在这里插入图片描述

在这里插入图片描述
则：
输出：ceil((34-10+1)/3)=9, ceil((13-4+1)/2)=5
即[1, 9, 5, 1]: batch_size=1, width=9, height=5, channels=1

参数个数：10 * 4 + 1 = 41。注：当use_bias=False时，参数个数为40：
在这里插入图片描述

乘法次数：10 * 4 * （9 * 5）= 1800
加法次数：9 * 5 = 45

2.2 单通道多卷积核

单通道输入：[1, 34, 13, 1]的单通道矩阵，即输入的batch_size = 1，width = 34, height = 13, channels = 1

多卷积核：
filters=128, 128个卷积核
kernel_size=[10, 4]
use_bias=True：一个偏置项
strides=[3, 2]：卷积移动步长
padding=“VALID”：不进行padding

def cnn_model():
    from tensorflow import keras

    inputs = keras.Input(shape=(34, 13, 1))
    net = keras.layers.Conv2D(filters=128, kernel_size=(10, 4), strides=(3, 2), padding='VALID',
                              dilation_rate=(1, 1), use_bias=False, name='conv_1')(inputs)
    net = keras.layers.BatchNormalization()(net)
    outputs = keras.layers.ReLU()(net)

    model = keras.Model(inputs=inputs, outputs=outputs)
    model.compile(
        loss=keras.losses.categorical_crossentropy,
        optimizer=keras.optimizers.Adadelta(),
        metrics=['accuracy']
    )

    model.summary()
    keras.utils.plot_model(model, 'cnn.png', show_shapes=True)

    convert_keras_to_tflite_dynamic_range(model, filename_tflite="./tflite/cnn.tflite")

    return model

def convert_keras_to_tflite_dynamic_range(model, filename_tflite="./tflite/cnn.tflite"):
    converter = tf.lite.TFLiteConverter.from_keras_model(model)
    converter.optimizations = [tf.lite.Optimize.DEFAULT]
    tflite_model = converter.convert()
    open(filename_tflite, "wb").write(tflite_model)

在这里插入图片描述

在这里插入图片描述

则：
输出：ceil((34-10+1)/3)=9, ceil((13-4+1)/2)=5
即[1, 9, 5, 128]: batch_size=1, width=9, height=5, channels=128

参数个数：（10 * 4 + 1 ）* 128 = 5248。注：当use_bias=False时，参数个数为10 * 4 * 128 = 5120：

在这里插入图片描述

乘法次数：10 * 4 * （9 * 5）*128 = 921600
加法次数：9 * 5 * 128 = 5760

2.3 多通道单卷积核

多通道输入：[1, 9, 5, 128]的多通道矩阵，即输入的batch_size = 1，width = 9, height = 5, channels = 128

单卷积核：
filters=1, 1个卷积核
kernel_size=[3, 3]：其实是[3, 3, 128]
use_bias=True：一个偏置项
strides=[1, 1]：卷积移动步长
padding=“VALID”：不进行padding

def cnn_model():
    from tensorflow import keras

    inputs = keras.Input(shape=(34, 13, 1))
    net = keras.layers.Conv2D(filters=128, kernel_size=(10, 4), strides=(3, 2), padding='VALID',
                              dilation_rate=(1, 1), use_bias=True, name='conv_1')(inputs)
    net = keras.layers.BatchNormalization()(net)
    outputs = keras.layers.ReLU()(net)

	## HERE：filters=1
    net = keras.layers.Conv2D(filters=1, kernel_size=(3, 3), strides=(1, 1), padding='VALID',
                              dilation_rate=(1, 1), use_bias=True, name='conv_2')(net)
    net = keras.layers.BatchNormalization()(net)
    outputs = keras.layers.ReLU()(net)

    model = keras.Model(inputs=inputs, outputs=outputs)
    model.compile(
        loss=keras.losses.categorical_crossentropy,
        optimizer=keras.optimizers.Adadelta(),
        metrics=['accuracy']
    )

    model.summary()
    keras.utils.plot_model(model, 'cnn.png', show_shapes=True)

    convert_keras_to_tflite_dynamic_range(model, filename_tflite="./tflite/cnn.tflite")

    return model

def convert_keras_to_tflite_dynamic_range(model, filename_tflite="./tflite/cnn.tflite"):
    converter = tf.lite.TFLiteConverter.from_keras_model(model)
    converter.optimizations = [tf.lite.Optimize.DEFAULT]
    tflite_model = converter.convert()
    open(filename_tflite, "wb").write(tflite_model)

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

则：
输出：ceil((9-3+1)/1)=7, ceil((5-3+1)/1)=3
即[1, 7, 3, 1]: batch_size=1, width=9, height=5, channels=1

参数个数：3 * 3 * 128 + 1 = 1153。注：当use_bias=False时，参数个数为1152。

乘法次数： 3 * 3 * （7 * 3）* 128 = 24192
加法次数：7 * 3 = 21

2.4 多通道多卷积核

多通道输入：[1, 9, 5, 128]的多通道矩阵，即输入的batch_size = 1，width = 9, height = 5, channels = 128

多卷积核：
filters=128, 128个卷积核
kernel_size=[3, 3]：其实是[3, 3, 128]
use_bias=True：一个偏置项
strides=[1, 1]：卷积移动步长
padding=“VALID”：不进行padding

def cnn_model():
    from tensorflow import keras

    inputs = keras.Input(shape=(34, 13, 1))
    net = keras.layers.Conv2D(filters=128, kernel_size=(10, 4), strides=(3, 2), padding='VALID',
                              dilation_rate=(1, 1), use_bias=True, name='conv_1')(inputs)
    net = keras.layers.BatchNormalization()(net)
    outputs = keras.layers.ReLU()(net)

	## HERE：filters=128
    net = keras.layers.Conv2D(filters=128, kernel_size=(3, 3), strides=(1, 1), padding='VALID',
                              dilation_rate=(1, 1), use_bias=True, name='conv_2')(net)
    net = keras.layers.BatchNormalization()(net)
    outputs = keras.layers.ReLU()(net)

    model = keras.Model(inputs=inputs, outputs=outputs)
    model.compile(
        loss=keras.losses.categorical_crossentropy,
        optimizer=keras.optimizers.Adadelta(),
        metrics=['accuracy']
    )

    model.summary()
    keras.utils.plot_model(model, 'cnn.png', show_shapes=True)

    convert_keras_to_tflite_dynamic_range(model, filename_tflite="./tflite/cnn.tflite")

    return model

def convert_keras_to_tflite_dynamic_range(model, filename_tflite="./tflite/cnn.tflite"):
    converter = tf.lite.TFLiteConverter.from_keras_model(model)
    converter.optimizations = [tf.lite.Optimize.DEFAULT]
    tflite_model = converter.convert()
    open(filename_tflite, "wb").write(tflite_model)

在这里插入图片描述

在这里插入图片描述

则：
输出：ceil((9-3+1)/1)=7, ceil((5-3+1)/1)=3
即[1, 7, 3, 128]: batch_size=1, width=9, height=5, channels=128

参数个数：（3 * 3 * 128 + 1 ）* 128 = 147584 。注：当use_bias=False时，参数个数为（3 * 3 * 128 ）* 128 = 147456 。

乘法次数： 3 * 3 * （7 * 3）* 128 * 128 = 3096576
加法次数：7 * 3 * 128 = 2688

3. Depthwise Seperable Conv（多通道多卷积核）

ref: https://zhuanlan.zhihu.com/p/80041030

多通道多卷积核的卷积操作应该是：

输入: [batch_size, width, height, channels],
卷积核个数：filters
卷积核尺寸：[kernel_width, kernel_height]
则：
卷积核shape： [kernel_width, kernel_height, channels, filters]

如上面的多通道多卷积核 的实现示例中：

输入: [batch_size, width, height, channels]=[1, 9, 5, 128]
卷积核个数：filters=128
卷积核尺寸：[kernel_width, kernel_height]=[3, 3]
卷积核shape： [kernel_width, kernel_height, channels, filters]=[3, 3, 128, 128]

该多通道多卷积核的卷积操作，可分为多个多通道单卷积核的卷积操作，即：
[width, height, channels]矩阵与[kernel_width, kernel_height, channels]矩阵的卷积。

Depthwise Separable Convolution是将一个完整的卷积运算分解为两步进行，即Depthwise Convolution与Pointwise Convolution。

3.1 Depthwise Convolution

Depthwise Convolution即将多个通道的输入数据（[width, height, channels]）与多个单卷积核（[kernel_width, kernel_height, channels]）进行依次矩阵点乘，即：

如下图所示，3个通道的输入数据，依次与3个单卷积核进行矩阵点乘，得到一个3维矩阵。即得到[output_width, output_height, channels]的矩阵，其中

output_width = ceil((width - kernel_width + 1) / stride_width)
output_height = ceil((height - kernel_height + 1) / stride_height)
在这里插入图片描述
概述：
多通道输入：多通道数据[batch_size, width, height, channels]
多个单卷积核：[kernel_width, kernel_height, channels], 和多个偏置项

输出：多通道数据[batch_size, output_width, output_height, channels]
参数个数：(kernel_width * kernel_height + 1 ) * channels
乘法次数：kernel_width * kernel_height * （output_width * output_heigh）* channels
加法次数：output_width * output_heigh * channels

3.2 Pointwise Convolution

Pointwise Convolution则将这些Feature map进行组合生成新的Feature map。Pointwise Convolution的运算与常规卷积运算非常相似，它的卷积核的尺寸为 1×1×channels，channels为上一层的通道数。所以这里的卷积运算会将上一步的map在深度方向上进行加权组合，生成新的Feature map。有几个卷积核就有几个输出Feature map。如下图所示。

在这里插入图片描述
概述：
多通道输入：多通道数据[batch_size, width, height, channels]
多卷积核：[filters, 1, 1, channels], 和filters个偏置项

输出：多通道数据 [batch_size, width, height, channels]
参数个数：(1 * 1 * channels + 1) * filters
乘法次数：1 * 1 * channels （width * heigh） filters
加法次数：width * heigh * filters

3.3 实现示例

1）Depthwise Convolution：

多通道输入：[1, 9, 5, 128]的多通道矩阵，即输入的batch_size = 1，width = 9, height = 5, channels = 128

多个单卷积核：
多个卷积核，但是depthwise没有filters参数的设置，即默认filters=channels
kernel_size=[3, 3]：shape即[3, 3, 128]
use_bias=True：channels个偏置项
strides=[1, 1]：卷积移动步长
padding=“VALID”：不进行padding

输出：多通道数据[batch_size, output_width, output_height, channel]，即[1, 7, 3, 128]

参数个数：（kernel_width * kernel_height + 1）* channels = （3 * 3 + 1）* 128 = 1280
乘法次数：kernel_width * kernel_height * （output_width * output_heigh）* channels = 3 * 3 * 7 * 3 * 128 = 24192
加法次数：output_width * output_heigh * channels = 7 * 3 * 128 = 2688

2）Pointwise Convolution：

多通道输入：[1, 7, 3, 128]的多通道矩阵，即输入的batch_size = 1，width = 7, height = 3, channels = 128

多卷积核：
filters=128，128个卷积核
kernel_size=[1, 1]：shape即[1, 1, 128]
use_bias=True：一个偏置项
strides=[1, 1]：卷积移动步长
padding=“VALID”：不进行padding

输出：多通道数据 [batch_size, width, height, channels] = [1, 7, 3, 128]
参数个数：(1 * 1 * channels + 1) * filters = 16512
乘法次数：1 * 1 * channels （width * heigh） filters = 344064
加法次数：width * heigh * filters = 2688

def cnn_model():
    from tensorflow import keras

    inputs = keras.Input(shape=(34, 13, 1))
    net = keras.layers.Conv2D(filters=128, kernel_size=(10, 4), strides=(3, 2), padding='VALID',
                              dilation_rate=(1, 1), use_bias=True, name='conv_1')(inputs)
    net = keras.layers.BatchNormalization()(net)
    outputs = keras.layers.ReLU()(net)

    # # Conv2D
    # net = keras.layers.Conv2D(filters=128, kernel_size=(3, 3), strides=(1, 1), padding='VALID',
    #                           dilation_rate=(1, 1), use_bias=True, name='conv_2')(net)
    # net = keras.layers.BatchNormalization()(net)
    # outputs = keras.layers.ReLU()(net)

    # Depthwise convolution
    net = keras.layers.DepthwiseConv2D(kernel_size=(3, 3), strides=(1, 1), padding='VALID',
                                       dilation_rate=(1, 1), use_bias=True, name='conv_depthwise')(net)
    net = keras.layers.BatchNormalization()(net)
    outputs = keras.layers.ReLU()(net)

    # Pointwise convolution
    net = keras.layers.Conv2D(filters=128, kernel_size=(1, 1), strides=(1, 1), padding='VALID',
                              dilation_rate=(1, 1), use_bias=True, name='conv_pointwise')(net)
    net = keras.layers.BatchNormalization()(net)
    outputs = keras.layers.ReLU()(net)

    model = keras.Model(inputs=inputs, outputs=outputs)
    model.compile(
        loss=keras.losses.categorical_crossentropy,
        optimizer=keras.optimizers.Adadelta(),
        metrics=['accuracy']
    )

    model.summary()
    keras.utils.plot_model(model, 'cnn.png', show_shapes=True)

    convert_keras_to_tflite_dynamic_range(model, filename_tflite="./tflite/cnn.tflite")

    return model

def convert_keras_to_tflite_dynamic_range(model, filename_tflite="./tflite/cnn.tflite"):
    converter = tf.lite.TFLiteConverter.from_keras_model(model)
    converter.optimizations = [tf.lite.Optimize.DEFAULT]
    tflite_model = converter.convert()
    open(filename_tflite, "wb").write(tflite_model)

在这里插入图片描述

在这里插入图片描述

3.4 Depthwise Seperable Conv 与Conv 对比

参数个数

Conv2D: 147584
在这里插入图片描述

Depthwise Seperable Conv : 1280 + 16512=17792
在这里插入图片描述

乘法次数

  1. Conv2D:

乘法次数： 3 * 3 * （7 * 3）* 128 * 128 = 3096576
加法次数：7 * 3 * 128 = 2688

  1. Depthwise Seperable Conv :

Depthwise conv:

乘法次数：kernel_width * kernel_height * （output_width * output_heigh）* channels = 3 * 3 * 7 * 3 * 128 = 24192
加法次数：output_width * output_heigh * channels = 7 * 3 * 128 = 2688

Pointwise conv:

乘法次数：1 * 1 * channels （width * heigh） filters = 344064
加法次数：width * heigh * filters = 2688

可看出Depthwise Seperable Conv 比普通的Conv可用更少的参数量和更少的计算量实现相同的特征学习。

阑珊珊珊
关注
专栏目录
MATLAB卷积运算（conv、conv2、convn）解释
weixin_30802273的博客
07-07 1万+
1 conv（向量卷积运算）所谓两个向量卷积，说白了就是多项式乘法。比如:p=[1 2 3],q=[1 1]是两个向量，p和q的卷积如下：把p的元素作为一个多项式的系数，多项式按升幂（或降幂）排列，比如就按升幂吧，写出对应的多项式：1+2x+3x^2;同样的，把q的元素也作为多项式的系数按升幂排列，写出对应的多项式：1+x。卷积就是“两个多项式相乘取系数”。（1+2x+3x^2）×（1+x）=1...
深度学习与CV教程(10) | 轻量化CNN架构 (SqueezeNet,ShuffleNet,MobileNet等)
虚幻私塾
06-06 730
卷积神经网络的结构优化和深度加深，带来非常显著的图像识别效果提升，但同时也带来了高计算复杂度和更长的计算时间，实际工程应用中对效率的考虑也很多，研究界与工业界近年都在努力「保持效果的情况下压缩网络复杂度」，也诞生了很多轻量化网络。在本篇内容中，ShowMeAI对常见主流轻量级网络进行展开讲解。我们先来做一点基础知识储备，本篇讲到的轻量化CNN框架，我们需要了解参数量和计算量的估测与计算方式。轻量化网络中一个著名的网络是 SqueezeNet ，它发表于ICLR 2017，它拥有与 AlexNet 相同的精度
深度学习-conv卷积
xymyeah
07-20 4609
深度学习-conv卷积 过滤器(卷积核) 传统的图像过滤器算子有以下几种: blurkernel：减少相邻像素的差异，使图像变平滑。 sobel：显示相邻元素在特定方向上的差异。 sharpen：强化相邻像素的差异，使图片看起来更生动。 outline：也称为edge kernel，相邻像素相似亮度的像素点设成黑，有较大差异的设为白。 更多可参考image-kernels在线演...
卷积Conv
yore0531的博客
06-07 359
如有小数，向下取整。
depthwise-seperate conv 深度可分离卷积解释和pytorch滤波
tony365的博客
02-01 490
主要包括depthwise conv 和 pointwise conv。
depthwise separable convolutions
wmzjzwlzs的专栏
05-05 278
转自：什么是depthwise separable convolutions_猫猫与橙子的博客-CSDN博客_depthwise Depthwise(DW)卷积与Pointwise(PW)卷积，合起来被称作Depthwise Separable Convolution(参见Google的Xception)，该结构和常规卷积操作类似，可用来提取特征，但相比于常规卷积操作，其参数量和运算成本较低。所以在一些轻量级网络中会碰到这种结构如MobileNet。常规卷积操作 对于一张5×5像素、三通道彩色输入图片（s
卷积神经网络中的Separable Convolution
heruili的博客
11-05 3402
卷积神经网络中的Separable Convolution 卷积神经网络中的Separable Convolution 卷积神经网络在图像处理中的地位已然毋庸置疑。卷积运算具备强大的特征提取能力、相比全连接又消耗更少的参数，应用在图像这样的二维结构数据中有着先天优势。然而受限于目前移动端设备硬件条件，显著降低神经网络的运算量依旧是网络结构优化的目标之一。本文所述的Separable Convolu...
【论文笔记】时空域特征学习的反思：视频分类中速度与精度的权衡
elaine_bao的专栏
10-12 4065
论文链接： rethinking spatiotemporal feature learning: speed-accuracy trade-offs in video classification Google Research & University of California San Diego 1. 文章想回答的3个问题 我们是否真的需要3d conv? 如果需要的话，哪些层我...
CNN：经典Backbone和Block
yly的博客
05-22 6052
MobileNets(2017，MobileNets: Efficient Convolutional Neural Networks for Mobile VisionApplications)，主要创新点是使用了depthwise separable convolutions。 Input feature map: FxFxM ，Output feature map: GxGxN的问题。经典的方式是使用N个KxKxM的卷积核，即KxKxM的卷积核的每个channel与FxFxM的feature map.
深度学习CV八股文
填坑
03-04 2万+
深度学习CV八股文一、深度学习中解决过拟合方法L1和L2正则化DropoutDropout正则化Inverted Dropout（反向随机失活）Dropout起到正则化效果的原因：Dropout的缺点eargstopping ( 早停法 )二、深度学习中解决欠拟合方法三、梯度消失和梯度爆炸解决梯度消失的方法解决梯度爆炸的方法四、神经网络权重初始化方法Xavier指数加权移动平均数五、梯度下降法梯度下降SGD(随机梯度下降法)Momentum(动量梯度下降)Nesterov Momentum自适应学习率算法A
深度可分离卷积（Depthwise seperable convolution）
热门推荐
冰雪棋书的博客
05-19 8万+
一、深度可分离卷积（Depthwise separable convolution） 一些轻量级的网络，如mobilenet中，会有深度可分离卷积depthwise separable convolution，由depthwise(DW)和pointwise(PW)两个部分结合起来，用来提取特征feature map。相比常规的卷积操作，其参数数量和运算成本比较低。 二、常规卷积操作 对于5x5x3的输入，如果想要得到3x3x4的feature map，那么卷积核的shape为3x3x3x4(即：)；
[cv] 卷积层conv
心宝的博客
04-25 980
参考：https://liuxiaofei.com.cn/blog/tensorflow-conv2d%E5%92%8Cmaxpool2d%E5%8E%9F%E7%90%86/ 参考：https://blog.csdn.net/quiet_girl/article/details/84579038 1、单个输入通道： 2、多个输入通道 若输入含有多个通道，则对于某个卷积核，分别对每个通道求feature map后将对应位置相加得到最终的feature map，如下图所示： 3.多个卷积核 若有多个卷积
深度可分离卷积（Depthwise Separable Convolution）
最新发布
吃葡萄不吐葡萄皮
08-17 2194
深度可分离卷积（Depthwise Separable Convolution）是一种卷积神经网络中常用的卷积操作，它在减少计算量的同时保持了较好的特征提取能力，因此被广泛用于轻量化的模型设计中。标准卷积使用一个卷积核对输入数据进行卷积，而深度可分离卷积将卷积操作分解为深度卷积和逐点卷积，从而显著减少了参数量。深度卷积只使用一个卷积核对输入通道逐通道进行卷积，逐点卷积使用1x1的卷积核进行通道之间的混合。深度卷积是在输入的每个通道上分别应用卷积核，生成相同数量的通道，然后将这些通道按通道维度进行堆叠。
Depthwise Separable convlution | 举例详细解释
东南风的博客
07-11 1万+
      下图就是depthwise separable convolution的示意图，其实就是将传统的卷积操作分成两步，假设原来是3*3的卷积，那么depthwise separable convolution就是先用M个3*3卷积核一对一卷积输入的M个feature map，不求和，生成M个结果；然后用N个1*1的卷积核正常卷积前面生成的M个结果，求和，最后生成N个结果。因此文章中将dep...
Group conv vs. Depthwise separable conv
qq_50489856的博客
04-22 3078
本王有话说：这俩属于是做轻量化绕不开的经典工作，盘踞武林好多年，我们的目标学会并企图超越它。 分组卷积（Group conv） paper 原理 分组卷积,即ResNeXt的亮点,受Inception和AlexNet的启发产生。Inception中提到,对于卷积来说,卷积核可以看做一个三维滤波器:通道维+空间维(特指特征图的W和H),常规的卷积操作其实就是实现通道相关性和空间相关性的联合映射。Inception提出假设: 卷积层通道间的相关性和空间相关性是可以退耦合的,将它们分开映射,能达到更好的效果。具体
MATLAB卷积conv、conv2、convn详解
weixin_44601578的博客
06-11 1万+
1. conv（向量卷积运算） 向量的卷积= 多项式乘法 使用说明： w=conv（u，v） u，v为向量，其长度可以不相同。 实例1：多项式乘法 （s^2+2s+2）（s+4）（s+1） w=conv（[1,2,2]，conv（[1,4]，[1,1]）） w = 1 7 16 18 8 P=poly2str(w,'s') P = s^4 + 7 s^3 + 16 s^2 + 18 s + 8 2. conv2（二维矩阵卷积运算） 总结出full，same，valid三种卷积后图像大小的计算公式：
TensorRT 初探（2）—— group conv与depthwise_conv
魏圣颖的博客
04-19 1631
tensorrt学习——分组卷积，深度可分离卷积
conv卷积基础
weixin_38502514的博客
01-11 575
cnn基础 一维卷积 Conv1d 输入参数 输出参数 计算方法 二维卷积 Conv2d 三维卷积 Conv3d
深度可分离卷积 SeparableConv2D与DepthwiseConv2D的区别
m0_37617773的博客
05-08 2883
简单来说，SeparableConv2D是DepthwiseConv2D的升级版。通常来说深度可分离卷积分为两步，也就是在depplabv3+中，经常使用的方法。 第一步：depthwise convolution是在每个通道上独自的进行空间卷积，图a 第二步：pointwise convolution是利用1x1卷积核组合前面depthwise convolution得到的特征，图b 而Dep...
PyTorch conv2d理解：单通道与多通道卷积解析
"Pytorch.nn.conv2d的理解与验证方法，包括单通道和多通道卷积的解析" 在PyTorch的nn模块中，`Conv2d`是用于二维卷积操作的关键类。它广泛应用于深度学习，特别是图像处理任务中，用于从输入图像中提取特征。卷积层...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值