Datasets:

code-philia
/

mtpnet_image_models

License:

Dataset card Files Files and versions

xet

Community

mtpnet_image_models / SENet-CIFAR10 /Classification-noisy /scripts /model.py

RRFRRF2

ADD SENet-CIFAR10

c52fe89 over 1 year ago

Raw History Blame Contribute Delete

8.55 kB

'''
SENet (Squeeze-and-Excitation Networks) in PyTorch.
SENet通过引入SE模块来自适应地重新校准通道特征响应。SE模块可以集成到现有的网络架构中，
通过显式建模通道之间的相互依赖关系，自适应地重新校准通道特征响应。
主要特点:
1. 引入Squeeze-and-Excitation(SE)模块，增强特征的表示能力
2. SE模块包含squeeze操作(全局平均池化)和excitation操作(两个FC层)
3. 通过attention机制来增强重要通道的权重，抑制不重要通道
4. 几乎可以嵌入到任何现有的网络结构中
Reference:
[1] Jie Hu, Li Shen, Samuel Albanie, Gang Sun, Enhua Wu
    Squeeze-and-Excitation Networks. CVPR 2018.
'''
import torch
import torch.nn as nn
import torch.nn.functional as F


class BasicBlock(nn.Module):
    """基础残差块+SE模块
    
    结构:
    x -> Conv -> BN -> ReLU -> Conv -> BN -> SE -> (+) -> ReLU
         |------------------------------------------|
         
    Args:
        in_channels: 输入通道数
        channels: 输出通道数
        stride: 步长,用于下采样,默认为1
    """
    def __init__(self, in_channels, channels, stride=1):
        super(BasicBlock, self).__init__()
        self.conv1 = nn.Conv2d(in_channels, channels, kernel_size=3, stride=stride, padding=1, bias=False)
        self.bn1 = nn.BatchNorm2d(channels)
        self.conv2 = nn.Conv2d(channels, channels, kernel_size=3, stride=1, padding=1, bias=False)
        self.bn2 = nn.BatchNorm2d(channels)

        # 残差连接
        self.shortcut = nn.Sequential()
        if stride != 1 or in_channels != channels:
            self.shortcut = nn.Sequential(
                nn.Conv2d(in_channels, channels, kernel_size=1, stride=stride, bias=False),
                nn.BatchNorm2d(channels)
            )

        # SE模块
        self.squeeze = nn.AdaptiveAvgPool2d(1)  # 全局平均池化
        self.excitation = nn.Sequential(
            nn.Conv2d(channels, channels//16, kernel_size=1),  # 通道降维
            nn.ReLU(inplace=True),
            nn.Conv2d(channels//16, channels, kernel_size=1),  # 通道升维
            nn.Sigmoid()  # 归一化到[0,1]
        )

    def forward(self, x):
        # 主分支
        out = F.relu(self.bn1(self.conv1(x)))
        out = self.bn2(self.conv2(out))
        
        # SE模块
        w = self.squeeze(out)  # Squeeze
        w = self.excitation(w)  # Excitation
        out = out * w  # 特征重标定
        
        # 残差连接
        out += self.shortcut(x)
        out = F.relu(out)
        return out


class PreActBlock(nn.Module):
    """Pre-activation版本的基础块+SE模块
    
    结构:
    x -> BN -> ReLU -> Conv -> BN -> ReLU -> Conv -> SE -> (+)
         |-------------------------------------------|
         
    Args:
        in_channels: 输入通道数
        channels: 输出通道数
        stride: 步长,用于下采样,默认为1
    """
    def __init__(self, in_channels, channels, stride=1):
        super(PreActBlock, self).__init__()
        self.bn1 = nn.BatchNorm2d(in_channels)
        self.conv1 = nn.Conv2d(in_channels, channels, kernel_size=3, stride=stride, padding=1, bias=False)
        self.bn2 = nn.BatchNorm2d(channels)
        self.conv2 = nn.Conv2d(channels, channels, kernel_size=3, stride=1, padding=1, bias=False)

        # 残差连接
        if stride != 1 or in_channels != channels:
            self.shortcut = nn.Sequential(
                nn.Conv2d(in_channels, channels, kernel_size=1, stride=stride, bias=False)
            )

        # SE模块
        self.squeeze = nn.AdaptiveAvgPool2d(1)
        self.excitation = nn.Sequential(
            nn.Conv2d(channels, channels//16, kernel_size=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(channels//16, channels, kernel_size=1),
            nn.Sigmoid()
        )

    def forward(self, x):
        # Pre-activation
        out = F.relu(self.bn1(x))
        shortcut = self.shortcut(out) if hasattr(self, 'shortcut') else x
        
        # 主分支
        out = self.conv1(out)
        out = self.conv2(F.relu(self.bn2(out)))

        # SE模块
        w = self.squeeze(out)
        w = self.excitation(w)
        out = out * w

        # 残差连接
        out += shortcut
        return out


class SENet(nn.Module):
    """SENet模型
    
    网络结构:
    1. 一个卷积层进行特征提取
    2. 四个残差层,每层包含多个带SE模块的残差块
    3. 平均池化和全连接层进行分类
    
    Args:
        block: 残差块类型(BasicBlock或PreActBlock)
        num_blocks: 每层残差块数量的列表
        num_classes: 分类数量,默认为10
    """
    def __init__(self, block, num_blocks, num_classes=10):
        super(SENet, self).__init__()
        self.in_channels = 64

        # 第一层卷积
        self.conv1 = nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1, bias=False)
        self.bn1 = nn.BatchNorm2d(64)
        
        # 四个残差层
        self.layer1 = self._make_layer(block,  64, num_blocks[0], stride=1)
        self.layer2 = self._make_layer(block, 128, num_blocks[1], stride=2)
        self.layer3 = self._make_layer(block, 256, num_blocks[2], stride=2)
        self.layer4 = self._make_layer(block, 512, num_blocks[3], stride=2)
        
        # 分类层
        self.avg_pool = nn.AdaptiveAvgPool2d(1)
        self.classifier = nn.Linear(512, num_classes)
        
        # 初始化权重
        self._initialize_weights()

    def _make_layer(self, block, channels, num_blocks, stride):
        """构建残差层
        
        Args:
            block: 残差块类型
            channels: 输出通道数
            num_blocks: 残差块数量
            stride: 第一个残差块的步长(用于下采样)
            
        Returns:
            nn.Sequential: 残差层
        """
        strides = [stride] + [1]*(num_blocks-1)
        layers = []
        for stride in strides:
            layers.append(block(self.in_channels, channels, stride))
            self.in_channels = channels
        return nn.Sequential(*layers)

    def forward(self, x):
        """前向传播
        
        Args:
            x: 输入张量,[N,3,32,32]
            
        Returns:
            out: 输出张量,[N,num_classes]
        """
        # 特征提取
        out = F.relu(self.bn1(self.conv1(x)))
        
        # 残差层
        out = self.layer1(out)
        out = self.layer2(out)
        out = self.layer3(out)
        out = self.layer4(out)
        
        # 分类
        out = self.avg_pool(out)
        out = out.view(out.size(0), -1)
        out = self.classifier(out)
        return out
    
    def feature(self, x):
        """提取特征"""
        out = F.relu(self.bn1(self.conv1(x)))
        out = self.layer1(out)
        out = self.layer2(out)
        out = self.layer3(out)
        out = self.layer4(out)
        out = self.avg_pool(out)
        return out

    def prediction(self, out):
        out = out.view(out.size(0), -1)
        out = self.classifier(out)
        return out

    def _initialize_weights(self):
        """初始化模型权重
        
        采用kaiming初始化方法:
        - 卷积层权重采用kaiming_normal_初始化
        - BN层参数采用常数初始化
        - 线性层采用正态分布初始化
        """
        for m in self.modules():
            if isinstance(m, nn.Conv2d):
                nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
                if m.bias is not None:
                    nn.init.constant_(m.bias, 0)
            elif isinstance(m, nn.BatchNorm2d):
                nn.init.constant_(m.weight, 1)
                nn.init.constant_(m.bias, 0)
            elif isinstance(m, nn.Linear):
                nn.init.normal_(m.weight, 0, 0.01)
                nn.init.constant_(m.bias, 0)


def SENet18(num_classes=10):
    """SENet-18模型"""
    return SENet(PreActBlock, [2,2,2,2], num_classes=num_classes)


def test():
    """测试函数"""
    # 创建模型
    net = SENet18()
    print('Model Structure:')
    print(net)
    
    # 测试前向传播
    x = torch.randn(1,3,32,32)
    y = net(x)
    print('\nInput Shape:', x.shape)
    print('Output Shape:', y.shape)
    
    # 打印模型信息
    from torchinfo import summary
    device = 'cuda' if torch.cuda.is_available() else 'cpu'
    net = net.to(device)
    summary(net, (1,3,32,32))


if __name__ == '__main__':
    test()

	'''
	SENet (Squeeze-and-Excitation Networks) in PyTorch.

	SENet通过引入SE模块来自适应地重新校准通道特征响应。SE模块可以集成到现有的网络架构中，
	通过显式建模通道之间的相互依赖关系，自适应地重新校准通道特征响应。

	主要特点:
	1. 引入Squeeze-and-Excitation(SE)模块，增强特征的表示能力
	2. SE模块包含squeeze操作(全局平均池化)和excitation操作(两个FC层)
	3. 通过attention机制来增强重要通道的权重，抑制不重要通道
	4. 几乎可以嵌入到任何现有的网络结构中

	Reference:
	[1] Jie Hu, Li Shen, Samuel Albanie, Gang Sun, Enhua Wu
	Squeeze-and-Excitation Networks. CVPR 2018.
	'''
	import torch
	import torch.nn as nn
	import torch.nn.functional as F


	class BasicBlock(nn.Module):
	"""基础残差块+SE模块

	结构:
	x -> Conv -> BN -> ReLU -> Conv -> BN -> SE -> (+) -> ReLU
	\|------------------------------------------\|

	Args:
	in_channels: 输入通道数
	channels: 输出通道数
	stride: 步长,用于下采样,默认为1
	"""
	def __init__(self, in_channels, channels, stride=1):
	super(BasicBlock, self).__init__()
	self.conv1 = nn.Conv2d(in_channels, channels, kernel_size=3, stride=stride, padding=1, bias=False)
	self.bn1 = nn.BatchNorm2d(channels)
	self.conv2 = nn.Conv2d(channels, channels, kernel_size=3, stride=1, padding=1, bias=False)
	self.bn2 = nn.BatchNorm2d(channels)

	# 残差连接
	self.shortcut = nn.Sequential()
	if stride != 1 or in_channels != channels:
	self.shortcut = nn.Sequential(
	nn.Conv2d(in_channels, channels, kernel_size=1, stride=stride, bias=False),
	nn.BatchNorm2d(channels)
	)

	# SE模块
	self.squeeze = nn.AdaptiveAvgPool2d(1) # 全局平均池化
	self.excitation = nn.Sequential(
	nn.Conv2d(channels, channels//16, kernel_size=1), # 通道降维
	nn.ReLU(inplace=True),
	nn.Conv2d(channels//16, channels, kernel_size=1), # 通道升维
	nn.Sigmoid() # 归一化到[0,1]
	)

	def forward(self, x):
	# 主分支
	out = F.relu(self.bn1(self.conv1(x)))
	out = self.bn2(self.conv2(out))

	# SE模块
	w = self.squeeze(out) # Squeeze
	w = self.excitation(w) # Excitation
	out = out * w # 特征重标定

	# 残差连接
	out += self.shortcut(x)
	out = F.relu(out)
	return out


	class PreActBlock(nn.Module):
	"""Pre-activation版本的基础块+SE模块

	结构:
	x -> BN -> ReLU -> Conv -> BN -> ReLU -> Conv -> SE -> (+)
	\|-------------------------------------------\|

	Args:
	in_channels: 输入通道数
	channels: 输出通道数
	stride: 步长,用于下采样,默认为1
	"""
	def __init__(self, in_channels, channels, stride=1):
	super(PreActBlock, self).__init__()
	self.bn1 = nn.BatchNorm2d(in_channels)
	self.conv1 = nn.Conv2d(in_channels, channels, kernel_size=3, stride=stride, padding=1, bias=False)
	self.bn2 = nn.BatchNorm2d(channels)
	self.conv2 = nn.Conv2d(channels, channels, kernel_size=3, stride=1, padding=1, bias=False)

	# 残差连接
	if stride != 1 or in_channels != channels:
	self.shortcut = nn.Sequential(
	nn.Conv2d(in_channels, channels, kernel_size=1, stride=stride, bias=False)
	)

	# SE模块
	self.squeeze = nn.AdaptiveAvgPool2d(1)
	self.excitation = nn.Sequential(
	nn.Conv2d(channels, channels//16, kernel_size=1),
	nn.ReLU(inplace=True),
	nn.Conv2d(channels//16, channels, kernel_size=1),
	nn.Sigmoid()
	)

	def forward(self, x):
	# Pre-activation
	out = F.relu(self.bn1(x))
	shortcut = self.shortcut(out) if hasattr(self, 'shortcut') else x

	# 主分支
	out = self.conv1(out)
	out = self.conv2(F.relu(self.bn2(out)))

	# SE模块
	w = self.squeeze(out)
	w = self.excitation(w)
	out = out * w

	# 残差连接
	out += shortcut
	return out


	class SENet(nn.Module):
	"""SENet模型

	网络结构:
	1. 一个卷积层进行特征提取
	2. 四个残差层,每层包含多个带SE模块的残差块
	3. 平均池化和全连接层进行分类

	Args:
	block: 残差块类型(BasicBlock或PreActBlock)
	num_blocks: 每层残差块数量的列表
	num_classes: 分类数量,默认为10
	"""
	def __init__(self, block, num_blocks, num_classes=10):
	super(SENet, self).__init__()
	self.in_channels = 64

	# 第一层卷积
	self.conv1 = nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1, bias=False)
	self.bn1 = nn.BatchNorm2d(64)

	# 四个残差层
	self.layer1 = self._make_layer(block, 64, num_blocks[0], stride=1)
	self.layer2 = self._make_layer(block, 128, num_blocks[1], stride=2)
	self.layer3 = self._make_layer(block, 256, num_blocks[2], stride=2)
	self.layer4 = self._make_layer(block, 512, num_blocks[3], stride=2)

	# 分类层
	self.avg_pool = nn.AdaptiveAvgPool2d(1)
	self.classifier = nn.Linear(512, num_classes)

	# 初始化权重
	self._initialize_weights()

	def _make_layer(self, block, channels, num_blocks, stride):
	"""构建残差层

	Args:
	block: 残差块类型
	channels: 输出通道数
	num_blocks: 残差块数量
	stride: 第一个残差块的步长(用于下采样)

	Returns:
	nn.Sequential: 残差层
	"""
	strides = [stride] + [1]*(num_blocks-1)
	layers = []
	for stride in strides:
	layers.append(block(self.in_channels, channels, stride))
	self.in_channels = channels
	return nn.Sequential(*layers)

	def forward(self, x):
	"""前向传播

	Args:
	x: 输入张量,[N,3,32,32]

	Returns:
	out: 输出张量,[N,num_classes]
	"""
	# 特征提取
	out = F.relu(self.bn1(self.conv1(x)))

	# 残差层
	out = self.layer1(out)
	out = self.layer2(out)
	out = self.layer3(out)
	out = self.layer4(out)

	# 分类
	out = self.avg_pool(out)
	out = out.view(out.size(0), -1)
	out = self.classifier(out)
	return out

	def feature(self, x):
	"""提取特征"""
	out = F.relu(self.bn1(self.conv1(x)))
	out = self.layer1(out)
	out = self.layer2(out)
	out = self.layer3(out)
	out = self.layer4(out)
	out = self.avg_pool(out)
	return out

	def prediction(self, out):
	out = out.view(out.size(0), -1)
	out = self.classifier(out)
	return out

	def _initialize_weights(self):
	"""初始化模型权重

	采用kaiming初始化方法:
	- 卷积层权重采用kaiming_normal_初始化
	- BN层参数采用常数初始化
	- 线性层采用正态分布初始化
	"""
	for m in self.modules():
	if isinstance(m, nn.Conv2d):
	nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
	if m.bias is not None:
	nn.init.constant_(m.bias, 0)
	elif isinstance(m, nn.BatchNorm2d):
	nn.init.constant_(m.weight, 1)
	nn.init.constant_(m.bias, 0)
	elif isinstance(m, nn.Linear):
	nn.init.normal_(m.weight, 0, 0.01)
	nn.init.constant_(m.bias, 0)


	def SENet18(num_classes=10):
	"""SENet-18模型"""
	return SENet(PreActBlock, [2,2,2,2], num_classes=num_classes)


	def test():
	"""测试函数"""
	# 创建模型
	net = SENet18()
	print('Model Structure:')
	print(net)

	# 测试前向传播
	x = torch.randn(1,3,32,32)
	y = net(x)
	print('\nInput Shape:', x.shape)
	print('Output Shape:', y.shape)

	# 打印模型信息
	from torchinfo import summary
	device = 'cuda' if torch.cuda.is_available() else 'cpu'
	net = net.to(device)
	summary(net, (1,3,32,32))


	if __name__ == '__main__':
	test()