轻量化模块整理，即插即用（持续更新）
整理一些轻量化的结构，作为知识储备，可以用到后续的项目和研究中
Mobilenetv3 深度可分离卷积
MobileNetV3 是一个轻量级的深度学习模型，专为移动和边缘设备上的高效推理而设计。MobileNetV3 是在 MobileNetV1 和 MobileNetV2 的基础上进行了进一步的优化，主要包括了网络架构的搜索和修改、硬件感知网络优化、以及使用了轻量级的注意力模块 SE（Squeeze-and-Excitation）和 h-swish 激活函数等
import torch
import torch.nn as nn
import torch.nn.functional as F
class h_swish(nn.Module):
def forward(self, x):
return x * torch.sigmoid(x + 3) / 6
class SEBlock(nn.Module):
def __init__(self, in_channels, reduction=4):
super(SEBlock, self).__init__()
self.avg_pool = nn.AdaptiveAvgPool2d(1)
self.fc = nn.Sequential(
nn.Linear(in_channels, in_channels // reduction, bias=False),
nn.ReLU(inplace=True),
nn.Linear(in_channels // reduction, in_channels, bias=False),
nn.Sigmoid()
)
def forward(self, x):
b, c, _, _ = x.size()
y = self.avg_pool(x).view(b, c)
y = self.fc(y).view(b, c, 1, 1)
return x * y.expand_as(x)
class InvertedResidual(nn.Module):
def __init__(self, inp, oup, stride, expand_ratio, use_se=False):
super(InvertedResidual, self).__init__()
assert stride in [1, 2]
hidden_dim = int(round(inp * expand_ratio))
self.use_res_connect = stride == 1 and inp == oup
layers = []
if expand_ratio != 1:
# pw
layers.append(nn.Conv2d(inp, hidden_dim, 1, 1, 0, bias=False))
layers.append(nn.BatchNorm2d(hidden_dim))
layers.append(h_swish())
# dw
layers.append(nn.Conv2d(hidden_dim, hidden_dim, 3, stride, 1, groups=hidden_dim, bias=False))
layers.append(nn.BatchNorm2d(hidden_dim))
layers.append(h_swish())
if use_se:
layers.append(SEBlock(hidden_dim))
# pw-linear
layers.append(nn.Conv2d(hidden_dim, oup, 1, 1, 0, bias=False))
layers.append(nn.BatchNorm2d(oup))
self.conv = nn.Sequential(*layers)
def forward(self, x):
if self.use_res_connect:
return x + self.conv(x)
else:
return self.conv(x)
# 使用示例
# 输入通道数、输出通道数、步长、扩展比例、是否使用 SE 模块
block = InvertedResidual(inp=32, oup=16, stride=2, expand_ratio=6, use_se=True)
input_tensor = torch.randn(1, 32, 224, 224)
output_tensor = block(input_tensor)
print(output_tensor.shape) # 输出张量的形状
上述代码定义了一个简化的 MobileNetV3 基础模块，包括一个 InvertedResidual（倒置残差）块和一个可选的 SE（Squeeze-and-Excitation）块。InvertedResidual 块是 MobileNetV3 的核心组件，它首先通过 1x1 卷积进行通道扩展，然后通过 3x3 深度可分离卷积进行空间卷积，最后通过 1x1 卷积恢复到目标通道数。SE 块则用于对特征进行自适应的重新加权。h_swish 是一种轻量级的激活函数，用于替换标准的 ReLU 或 swish 激活函数。
在pytorch中简单实现dw卷积
在PyTorch中实现深度可分离卷积（Depthwise Separable Convolution）可以通过两个步骤来完成：首先执行深度卷积（Depthwise Convolution），然后执行逐点卷积（Pointwise Convolution）。
深度卷积对输入的每个通道单独应用一个卷积核，因此输出的通道数与输入的通道数相同。而逐点卷积（也被称为1x1卷积）是对深度卷积的输出进行线性组合，以改变通道数。
以下是一个简单的PyTorch实现示例：
import torch
import torch.nn as nn
import torch.nn.functional as F
class DepthwiseSeparableConv(nn.Module):
def __init__(self, in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, bias=False):
super(DepthwiseSeparableConv, self).__init__()
self.depthwise = nn.Conv2d(in_channels, in_channels, kernel_size, stride, padding, dilation, groups=in_channels, bias=bias)
self.pointwise = nn.Conv2d(in_channels, out_channels, 1, 1, 0, bias=bias)
def forward(self, x):
out = self.depthwise(x)
out = self.pointwise(out)
return out
# 使用示例
# 输入通道数、输出通道数、卷积核大小
in_channels = 3
out_channels = 16
kernel_size = 3
# 实例化深度可分离卷积层
depthwise_separable_conv = DepthwiseSeparableConv(in_channels, out_channels, kernel_size)
# 创建一个随机的输入张量
input_tensor = torch.randn(1, in_channels, 32, 32)
# 前向传播
output_tensor = depthwise_separable_conv(input_tensor)
# 打印输出张量的形状
print(output_tensor.shape) # 应该是 [1, out_channels, 32, 32]
在这个例子中，DepthwiseSeparableConv 类包含两个卷积层：depthwise（深度卷积层）和 pointwise（逐点卷积层）。在 forward 方法中，输入 x 首先通过深度卷积层，然后通过逐点卷积层。
注意，nn.Conv2d 在定义深度卷积层时使用了 groups=in_channels 参数，这表示每个输入通道都有一个独立的卷积核。这确保了深度卷积只在其自己的输入通道上进行操作。
然后，逐点卷积层（即1x1卷积）将深度卷积的输出作为输入，并输出具有所需通道数的特征图。
这种实现方法相比标准卷积更加高效，因为它减少了参数数量和计算量，特别适合在移动和嵌入式设备上使用。
在dw卷积中，增加膨胀了
在深度卷积中再实现扩张卷积（也称为空洞卷积或 Atrous Convolution）需要调整卷积层的参数来包含扩张率（dilation rate）。扩张卷积允许卷积核在输入特征图上以指定的间隔进行采样，从而在不增加参数数量的情况下增大卷积核的感受野。
在 PyTorch 中，你可以在 nn.Conv2d 中通过 dilation 参数来指定扩张率。因此，要在 DWConv 类中实现扩张卷积，你需要在初始化 nn.Conv2d 时传入一个 dilation 参数。
下面是一个修改后的 DWConv 类，参考了YOLOv5中的DWconv，另外，实现了深度卷积并带有扩张率：
import torch
import torch.nn as nn
import torch.nn.functional as F
class Conv(nn.Module):
# Standard convolution
def __init__(self, c1, c2, k, s=1, p=None, g=1, act=True, dilation=1):
super(Conv, self).__init__()
self.conv = nn.Conv2d(c1, c2, k, s, autopad(k, p), groups=g, bias=False, dilation=dilation)
self.bn = nn.BatchNorm2d(c2)
self.act = nn.Hardswish() if act else nn.Identity()
def forward(self, x):
return self.act(self.bn(self.conv(x)))
def autopad(k, p=None):
# Compute padding
if p is None:
p = k // 2
return p
class DWConv(nn.Module):
# Depthwise Separable Convolution with dilation and pointwise convolution
def __init__(self, c1, c2, k=1, s=1, act=True, dilation=1):
super(DWConv, self).__init__()
# Depthwise Convolution
self.depthwise = Conv(c1, c1, k, s, act=False, g=c1, dilation=dilation)
# Pointwise Convolution (1x1 Convolution)
self.pointwise = Conv(c1, c2, 1)
# Activation function for the final output
self.act = nn.Hardswish() if act else nn.Identity()
def forward(self, x):
# Apply depthwise convolution
x = self.depthwise(x)
# Apply pointwise convolution
x = self.pointwise(x)
# Apply activation function
return self.act(x)
# Example usage:
# Create a depthwise separable convolution layer with dilation and pointwise convolution
dw_separable_conv = DWConv(c1=64, c2=128, k=3, s=1, act=True, dilation=2)
# Create an input tensor
input_tensor = torch.randn(1, 64, 32, 32)
# Forward pass through the layer
output_tensor = dw_separable_conv(input_tensor)
在这个例子中，dw_conv_layer 是一个深度卷积层，它使用 3x3 的卷积核，步长为 1，并且有一个扩张率为 2，这意味着卷积核在输入特征图上的采样间隔为 2，从而增大了感受野。同时，由于 groups=c1，它仍然是一个深度卷积层，每个输入通道有一个独立的卷积核。
与普通卷积的对比
直接上代码
import torch
import torch.nn as nn
import torch.nn.functional as F
class Conv(nn.Module):
# Standard convolution
def __init__(self, c1, c2, k, s=1, p=None, g=1, act=True, dilation=1):
super(Conv, self).__init__()
self.conv = nn.Conv2d(c1, c2, k, s, autopad(k, p), groups=g, bias=False, dilation=dilation)
self.bn = nn.BatchNorm2d(c2)
self.act = nn.Hardswish() if act else nn.Identity()
def forward(self, x):
return self.act(self.bn(self.conv(x)))
def autopad(k, p=None):
# Compute padding
if p is None:
p = k // 2
return p
class DWConv(nn.Module):
# Depthwise Separable Convolution with dilation and pointwise convolution
def __init__(self, c1, c2, k=1, s=1, act=True, dilation=1):
super(DWConv, self).__init__()
# Depthwise Convolution
self.depthwise = Conv(c1, c1, k, s, act=False, g=c1, dilation=dilation)
# Pointwise Convolution (1x1 Convolution)
self.pointwise = Conv(c1, c2, 1)
# Activation function for the final output
self.act = nn.Hardswish() if act else nn.Identity()
def forward(self, x):
# Apply depthwise convolution
x = self.depthwise(x)
# Apply pointwise convolution
x = self.pointwise(x)
# Apply activation function
return self.act(x)
# Example usage:
# Create a depthwise separable convolution layer with dilation and pointwise convolution
dw_separable_conv = DWConv(c1=64, c2=128, k=3, s=1, act=True, dilation=2)
normal_conv = Conv(c1=64, c2=128, k=3, s=1, act=True, dilation=2)
# Create an input tensor
input_tensor = torch.randn(1, 64, 32, 32)
print(input_tensor.shape)
# Forward pass through the layer
output_tensor = dw_separable_conv(input_tensor)
print(output_tensor.shape)
print("Normal Convolution")
output_tensor = normal_conv(input_tensor)
print(output_tensor.shape)
# 计算参数量和计算量
from ptflops import get_model_complexity_info
flops,params = get_model_complexity_info(normal_conv,(64,640,640),as_strings=True,print_per_layer_stat=True)
print(" |flops: %s |params: %s" % (flops, params))
from fvcore.nn import FlopCountAnalysis
input_ = torch.randn((1, 64, 256, 256))
flops = FlopCountAnalysis(normal_conv, input_)
print("flops: ", flops.total() / 1e9)
print("DW Convolution")
# 计算参数量和计算量
from ptflops import get_model_complexity_info
flops,params = get_model_complexity_info(dw_separable_conv,(64,640,640),as_strings=True,print_per_layer_stat=True)
print(" |flops: %s |params: %s" % (flops, params))
from fvcore.nn import FlopCountAnalysis
input_ = torch.randn((1, 64, 256, 256))
flops = FlopCountAnalysis(dw_separable_conv, input_)
print("flops: ", flops.total() / 1e9)
