Xception for DeepLab V3+(含超详细代码注解及论文原图)

import torch
import torchvision.models as models
from torch import nn


# 深度可分离卷积
class SeparableConv2d_same(nn.Module):
    def __init__(self, inplanes, planes, kernel_size=3, stride=1, dilation=1, bias=False):
        super(SeparableConv2d_same, self).__init__()
        # 深度卷积
        self.conv1 = nn.Conv2d(inplanes, inplanes, kernel_size, stride, 0, dilation,
                               groups=inplanes, bias=bias)
        # 逐点卷积
        self.pointwise = nn.Conv2d(inplanes, planes, 1, 1, 0, 1, 1, bias=bias)

    def forward(self, x):
        # 深度卷积
        x = self.conv1(x)
        # 逐点卷积
        x = self.pointwise(x)
        return x


# xception 20个block外加5个散装(开始两个,结束三个)
class Block(nn.Module):
    # (输入通道,输出通道,同种conv数量,步长,空洞率,是否在从relu开始,是否为最后(20)模块)
    def __init__(self, inplanes, planes, reps, stride=1
                 , dilation=1, start_with_rule=True, grow_first=True, is_last=False):
        super(Block, self).__init__()
        # 区别block1-3与block4-19
        # 满足条件为block1-3,定义1X1卷积和卷积后的bn层
        if planes != inplanes or stride != 1:
            # 1X1卷积,步长为2,(跳跃连接前的)卷积下采样结构
            self.skip = nn.Conv2d(
                inplanes, planes, 1, stride=stride, bias=False
            )
            # batch_normal
            self.skipbn = nn.BatchNorm2d(planes)
        # 不满足条件为block4-19,不定义skip
        else:
            self.skip = None
        # 定义relu层
        # inplace = True ,会改变输入数据的值,节省反复申请与释放内存的空间与时间,只是将原来的地址传递,效率更好
        self.relu = nn.ReLU(inplace=True)
        # 定义rep
        rep = []
        filters = inplanes  # 记录输入通道数
        # 如果是每个组开始,则先定义一个由relu-sepconv-bn组成的可分离卷积块
        if grow_first:
            rep.append(self.relu)  # 第一层relu
            rep.append(SeparableConv2d_same(
                filters, planes, 3, stride=1, dilation=dilation
            ))  # 第二层3X3可分离卷积层
            rep.append(nn.BatchNorm2d(planes))  # 第三层bn层
            filters = planes  # filters更新为输出通道数
        # 定义rsp-1个由relu-sepconv-bn组成的可分离卷积块
        for i in range(reps - 1):
            rep.append(self.relu)  # 第一层relu
            rep.append(SeparableConv2d_same(
                filters, filters, 3, stride=1, dilation=dilation
            ))  # 第二层3X3可分离卷积层
            rep.append(nn.BatchNorm2d(filters))
        # 如果不是每个组开始,定义一个由relu-sepconv-bn组成的可分离卷积块
        if not grow_first:
            rep.append(self.relu)  # 第一层relu
            rep.append(SeparableConv2d_same(
                inplanes, planes, 3, stride=1, dilation=dilation
            ))  # 第二层3X3可分离卷积层
            rep.append(nn.BatchNorm2d(planes))  # 第三层bn层
        # 是否保留块开始的RELU()
        if not start_with_rule:
            rep = rep[1:]
        # 判断是否是block1-3
        if stride != 1:
            rep.append(SeparableConv2d_same(planes,
                                            planes, 3, stride=2))  # 定义3X3下采样可分离卷积层
        # 改写原来的stride=1为=2
        if stride == 1 and is_last:
            self.rep = nn.Sequential(*rep)

    def forward(self, input):
        # 输入值放入rep中
        x = self.rep(input)
        # 判断是否产生skip(逻辑结构为32-41行)
        # 如果产生,证明在block1-3中,这时候需要把skip和bn实例化出来
        if self.skip is not None:
            skip = self.skip(input)
            skip = self.skipbn(skip)
        else:
            skip = input
        # skip
        x += skip
        return x


class Xception(nn.Module):
    def __init__(self, inplanes=3):
        super(Xception, self).__init__()
        entry_block3_stride = 2  # block1-3中最下层步长
        middle_block_dilation = 1  # block4-19中空洞率
        exit_block_dilations = (1, 2)  # block20中空洞率
        
        # block1-3
        self.conv1 = nn.Conv2d(inplanes, 32, 3, stride=2, padding=1, bias=False)
        self.bn1 = nn.BatchNorm2d(32)
        self.relu = nn.ReLU(inplace=True)

        self.conv2 = nn.Conv2d(32, 64, 3, stride=1, padding=1, bias=False)
        self.bn2 = nn.BatchNorm2d(64)
        self.block1 = Block(64, 128, reps=2, stride=2, start_with_relu=False)
        self.block2 = Block(128, 256, reps=2, stride=2, start_with_relu=True, grow_first=True)
        self.block3 = Block(256, 728, reps=2, stride=entry_block3_stride, start_with_relu=True, grow_first=True,
                            is_last=True)
        # block4-19
        self.block4 = Block(728, 728, reps=3, stride=1, dilation=middle_block_dilation, start_with_relu=True,
                            grow_first=True)
        self.block5 = Block(728, 728, reps=3, stride=1, dilation=middle_block_dilation, start_with_relu=True,
                            grow_first=True)
        self.block6 = Block(728, 728, reps=3, stride=1, dilation=middle_block_dilation, start_with_relu=True,
                            grow_first=True)
        self.block7 = Block(728, 728, reps=3, stride=1, dilation=middle_block_dilation, start_with_relu=True,
                            grow_first=True)
        self.block8 = Block(728, 728, reps=3, stride=1, dilation=middle_block_dilation, start_with_relu=True,
                            grow_first=True)
        self.block9 = Block(728, 728, reps=3, stride=1, dilation=middle_block_dilation, start_with_relu=True,
                            grow_first=True)
        self.block10 = Block(728, 728, reps=3, stride=1, dilation=middle_block_dilation, start_with_relu=True,
                             grow_first=True)
        self.block11 = Block(728, 728, reps=3, stride=1, dilation=middle_block_dilation, start_with_relu=True,
                             grow_first=True)
        self.block12 = Block(728, 728, reps=3, stride=1, dilation=middle_block_dilation, start_with_relu=True,
                             grow_first=True)
        self.block13 = Block(728, 728, reps=3, stride=1, dilation=middle_block_dilation, start_with_relu=True,
                             grow_first=True)
        self.block14 = Block(728, 728, reps=3, stride=1, dilation=middle_block_dilation, start_with_relu=True,
                             grow_first=True)
        self.block15 = Block(728, 728, reps=3, stride=1, dilation=middle_block_dilation, start_with_relu=True,
                             grow_first=True)
        self.block16 = Block(728, 728, reps=3, stride=1, dilation=middle_block_dilation, start_with_relu=True,
                             grow_first=True)
        self.block17 = Block(728, 728, reps=3, stride=1, dilation=middle_block_dilation, start_with_relu=True,
                             grow_first=True)
        self.block18 = Block(728, 728, reps=3, stride=1, dilation=middle_block_dilation, start_with_relu=True,
                             grow_first=True)
        self.block19 = Block(728, 728, reps=3, stride=1, dilation=middle_block_dilation, start_with_relu=True,
                             grow_first=True)

        # block20
        self.block20 = Block(728, 1024, reps=2, stride=1, dilation=exit_block_dilations[0],
                             start_with_relu=True, grow_first=False, is_last=True)

        self.conv3 = SeparableConv2d_same(1024, 1536, 3, stride=1, dilation=exit_block_dilations[1])
        self.bn3 = nn.BatchNorm2d(1536)

        self.conv4 = SeparableConv2d_same(1536, 1536, 3, stride=1, dilation=exit_block_dilations[1])
        self.bn4 = nn.BatchNorm2d(1536)

        self.conv5 = SeparableConv2d_same(1536, 2048, 3, stride=1, dilation=exit_block_dilations[1])
        self.bn5 = nn.BatchNorm2d(2048)
        
    def forward(self, x):
        # Entry flow
        x = self.conv1(x)
        x = self.bn1(x)
        x = self.relu(x)

        x = self.conv2(x)
        x = self.bn2(x)
        x = self.relu(x)

        x = self.block1(x)
        low_level_feat = x  # 四分之一大小
        x = self.block2(x)
        x = self.block3(x)

        # Middle flow
        x = self.block4(x)
        x = self.block5(x)
        x = self.block6(x)
        x = self.block7(x)
        x = self.block8(x)
        x = self.block9(x)
        x = self.block10(x)
        x = self.block11(x)
        x = self.block12(x)
        x = self.block13(x)
        x = self.block14(x)
        x = self.block15(x)
        x = self.block16(x)
        x = self.block17(x)
        x = self.block18(x)
        x = self.block19(x)

        # Exit flow
        x = self.block20(x)
        x = self.conv3(x)
        x = self.bn3(x)
        x = self.relu(x)

        x = self.conv4(x)
        x = self.bn4(x)
        x = self.relu(x)

        x = self.conv5(x)
        x = self.bn5(x)
        x = self.relu(x)

        return x, low_level_feat

在这里插入图片描述

  • 7
    点赞
  • 8
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
### 回答1: Deeplab v3 的代码可以使用 TensorFlow 实现。首先,您需要下载 deeplab v3 的代码并安装所需的依赖项。然后,您可以在代码中定义网络结构、设置参数并进行训练。 以下是一个简单的 deeplab v3 代码示例: ``` import tensorflow as tf # 定义 Deeplab v3 网络结构 model = tf.keras.Sequential() model.add(tf.keras.layers.Conv2D(64, (3,3), activation='relu', input_shape=(256, 256, 3))) model.add(tf.keras.layers.BatchNormalization()) model.add(tf.keras.layers.MaxPooling2D((2,2))) model.add(tf.keras.layers.Conv2D(128, (3,3), activation='relu')) model.add(tf.keras.layers.BatchNormalization()) model.add(tf.keras.layers.MaxPooling2D((2,2))) model.add(tf.keras.layers.Conv2D(256, (3,3), activation='relu')) model.add(tf.keras.layers.BatchNormalization()) model.add(tf.keras.layers.Conv2D(256, (3,3), activation='relu')) model.add(tf.keras.layers.BatchNormalization()) model.add(tf.keras.layers.Conv2D(512, (3,3), activation='relu')) model.add(tf.keras.layers.BatchNormalization()) model.add(tf.keras.layers.MaxPooling2D((2,2))) model.add(tf.keras.layers.Conv2D(512, (3,3), activation='relu')) model.add(tf.keras.layers.BatchNormalization()) model.add(tf.keras.layers.Conv2D(512, (3,3), activation='relu')) model.add(tf.keras.layers.BatchNormalization()) model.add(tf.keras.layers.Conv2D(512, (3,3), activation='relu')) model.add(tf.keras.layers.BatchNormalization()) model.add(tf.keras.layers.MaxPooling2D((2,2))) model.add(tf.keras.layers.Conv2D(512, (3,3), activation='relu')) model.add(tf.keras.layers ### 回答2: DeepLab v3 是一种用于语义分割的深度学习模型,主要用于将图像中的每个像素分类为不同的语义类别。 要编写DeepLab v3的代码,需要进行以下步骤: 1. 数据准备:收集和准备用于训练和测试的图像和相应的标签。图像应该是RGB格式的,而标签应该将每个像素的类别编码为整数。 2. 构建模型:基于已有的DeepLab v3论文,使用深度学习框架(如TensorFlow、PyTorch等)创建模型。模型的基本结构是骨干网络(如ResNet、Xception等)和空洞卷积层(atrous convolution)的组合。 3. 定义损失函数:在训练过程中,需要定义一个合适的损失函数来度量模型输出与真实标签之间的差异。通常使用交叉熵损失函数来进行图像分割任务。 4. 训练模型:使用准备好的训练数据,输入图像到模型中,并通过反向传播来更新模型的权重。可以使用随机梯度下降(SGD)等优化算法来最小化损失函数。 5. 验证模型:使用准备好的测试数据,输入图像到模型中,并计算模型输出与真实标签之间的差异,以评估模型在未见过的数据上的性能。 6. 参数调优:根据验证结果,调整模型的参数(如学习率、批量大小等)以获得更好的性能。 7. 应用模型:经过训练和验证后,可以使用模型对新的图像进行语义分割,将每个像素分类为不同的语义类别。 编写DeepLab v3的代码需要掌握深度学习框架、图像处理技术和模型训练方法。此外,还需要对论文中提到的结构和原理有一定的理解。可以通过查阅相关文献、参考开源实现和参与相关课程学习来更好地掌握这个过程。 ### 回答3: DeepLab v3是一个用于语义分割的深度学习模型,其代码通常使用Python编写,借助一些深度学习框架如TensorFlow或PyTorch来实现。 首先,你需要导入所需的库和模块。对于TensorFlow,你需要导入`tensorflow`和`tf.contrib.slim`。对于PyTorch,你需要导入`torch`和`torchvision`。 接下来,你需要定义DeepLab v3的模型架构。该模型通常包括一个具有预训练的主干网络(如ResNet或Xception)和一个ASPP(Atrous Spatial Pyramid Pooling)模块。你可以使用库中提供的预训练的主干网络,如`tf.keras.applications.ResNet50`或`torchvision.models.resnet50`。 然后,你需要在模型的基础上定义自己的DeepLab v3网络。这包括修改主干网络的最后一层,添加ASPP模块和一些其他必要的操作,例如空间上采样。 接着,你需要定义损失函数。这通常是使用交叉熵损失函数,将模型的输出与真实的分割标签进行对比。 最后,你需要定义优化器和训练过程。这涉及选择一个合适的优化器(如Adam或SGD),设置学习率,迭代数据集并更新权重以最小化损失函数。 在代码的最后,你可以使用测试数据评估模型的性能,并根据需要进行进一步的微调和调整参数。 总之,DeepLab v3的代码编写涉及导入库和模块、定义模型架构、设置损失函数、定义优化器和训练过程等步骤。具体的实现取决于你使用的深度学习框架和你的任务需求。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

ZRX_GIS

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值