【论文阅读】SegNet算法详解

已于 2025-02-18 11:36:48 修改
阅读量1.4w 收藏 126
点赞数 14
分类专栏： # 语义分割 论文阅读 文章标签： 算法 深度学习 神经网络
于 2021-12-31 11:31:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42735631/article/details/122252894
版权
本文详细介绍了SegNet深度全卷积神经网络的结构和工作原理，该模型由编码器、解码器和像素级分类层组成。编码器使用卷积、批量归一化和ReLU激活函数，而解码器利用编码器的池化索引进行非线性上采样，减少了参数和计算量。Pytorch实现中，定义了Encoder和Decoder类，分别对应编码和解码过程，最后通过像素级分类层输出每个像素的类别概率。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

SegNet论文详解

SegNet算法Pytorch实现：https://github.com/codecat0/CV/tree/main/Semantic_Segmentation/SegNet

本文提出了一种用于语义分割的深度全卷积神经网络结构SegNet，其核心由一个编码器网络和一个对应的解码器网络以及一个像素级分类层组成。

本文的创新在于：
解码器使用在对应编码器的最大池化步骤中计算的池化索引来执行非线性上采样，这与反卷积相比，减少了参数量和运算量，而且消除了学习上采样的需要。
在这里插入图片描述

1. 网络结构

在这里插入图片描述

1.1 编码器

  1. Conv层
    • 通过卷积提取特征，其中使用的是same padding的卷积，不会改变特征图的尺寸
  2. BN层
    • 起到归一化的作用
  3. ReLU层
    • 起到激活函数的作用
  4. Pooling层
    • max pooling层，同时会记录最大值的索引位置

1.2 解码器

  1. Upsampling层
    在这里插入图片描述

    • 对输入的特征图放大两倍，然后把输入特征图的数据根据编码器pooling层的索引位置放入，其他位置为0

  2. Conv层

    • 通过卷积提取特征，其中使用的是same padding的卷积，不会改变特征图的尺寸

  3. BN层

    • 起到归一化的作用

  4. ReLU层

    • 起到激活函数的作用

1.3 像素级分类层

输出每一个像素点在所有类别概率，其中最大的概率类别为该像素的预测值

2. Pytorch实现

import torch
import torch.nn as nn
import torch.nn.functional as F


class Encoder(nn.Module):
    def __init__(self, in_channels):
        super(Encoder, self).__init__()

        batchNorm_momentum = 0.1

        self.encode1 = nn.Sequential(
            nn.Conv2d(in_channels, 64, kernel_size=3, stride=1, padding=1, bias=False),
            nn.BatchNorm2d(64, momentum=batchNorm_momentum),
            nn.ReLU(inplace=True),

            nn.Conv2d(64, 64, kernel_size=3, stride=1, padding=1, bias=False),
            nn.BatchNorm2d(64, momentum=batchNorm_momentum),
            nn.ReLU(inplace=True),
        )

        self.encode2 = nn.Sequential(
            nn.Conv2d(64, 128, kernel_size=3, stride=1, padding=1, bias=False),
            nn.BatchNorm2d(128, momentum=batchNorm_momentum),
            nn.ReLU(inplace=True),

            nn.Conv2d(128, 128, kernel_size=3, stride=1, padding=1, bias=False),
            nn.BatchNorm2d(128, momentum=batchNorm_momentum),
            nn.ReLU(inplace=True),
        )

        self.encode3 = nn.Sequential(
            nn.Conv2d(128, 256, kernel_size=3, stride=1, padding=1, bias=False),
            nn.BatchNorm2d(256, momentum=batchNorm_momentum),
            nn.ReLU(inplace=True),

            nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1, bias=False),
            nn.BatchNorm2d(256, momentum=batchNorm_momentum),
            nn.ReLU(inplace=True),
            
            nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1, bias=False),
            nn.BatchNorm2d(256, momentum=batchNorm_momentum),
            nn.ReLU(inplace=True),
        )

        self.encode4 = nn.Sequential(
            nn.Conv2d(256, 512, kernel_size=3, stride=1, padding=1, bias=False),
            nn.BatchNorm2d(512, momentum=batchNorm_momentum),
            nn.ReLU(inplace=True),

            nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1, bias=False),
            nn.BatchNorm2d(512, momentum=batchNorm_momentum),
            nn.ReLU(inplace=True),
            
			nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1, bias=False),
            nn.BatchNorm2d(512, momentum=batchNorm_momentum),
            nn.ReLU(inplace=True),
        )

        self.encode5 = nn.Sequential(
            nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1, bias=False),
            nn.BatchNorm2d(512, momentum=batchNorm_momentum),
            nn.ReLU(inplace=True),

            nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1, bias=False),
            nn.BatchNorm2d(512, momentum=batchNorm_momentum),
            nn.ReLU(inplace=True),
            
            nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1, bias=False),
            nn.BatchNorm2d(512, momentum=batchNorm_momentum),
            nn.ReLU(inplace=True),
        )

    def forward(self, x):
        idx = []

        x = self.encode1(x)
        x, id1 = F.max_pool2d_with_indices(x, kernel_size=2, stride=2, return_indices=True)
        idx.append(id1)

        x = self.encode2(x)
        x, id2 = F.max_pool2d_with_indices(x, kernel_size=2, stride=2, return_indices=True)
        idx.append(id2)

        x = self.encode3(x)
        x, id3 = F.max_pool2d_with_indices(x, kernel_size=2, stride=2, return_indices=True)
        idx.append(id3)

        x = self.encode4(x)
        x, id4 = F.max_pool2d_with_indices(x, kernel_size=2, stride=2, return_indices=True)
        idx.append(id4)

        x = self.encode5(x)
        x, id5 = F.max_pool2d_with_indices(x, kernel_size=2, stride=2, return_indices=True)
        idx.append(id5)

        return x, idx


class Decoder(nn.Module):
    def __init__(self, out_channels):
        super(Decoder, self).__init__()

        batchNorm_momentum = 0.1

        self.decode1 = nn.Sequential(
            nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1, bias=False),
            nn.BatchNorm2d(512, momentum=batchNorm_momentum),
            nn.ReLU(inplace=True),

            nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1, bias=False),
            nn.BatchNorm2d(512, momentum=batchNorm_momentum),
            nn.ReLU(inplace=True),
            
            nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1, bias=False),
            nn.BatchNorm2d(512, momentum=batchNorm_momentum),
            nn.ReLU(inplace=True),
        )

        self.decode2 = nn.Sequential(
            nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1, bias=False),
            nn.BatchNorm2d(512, momentum=batchNorm_momentum),
            nn.ReLU(inplace=True),
            
            nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1, bias=False),
            nn.BatchNorm2d(512, momentum=batchNorm_momentum),
            nn.ReLU(inplace=True),

            nn.Conv2d(512, 256, kernel_size=3, stride=1, padding=1, bias=False),
            nn.BatchNorm2d(256, momentum=batchNorm_momentum),
            nn.ReLU(inplace=True)
        )

        self.decode3 = nn.Sequential(
            nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1, bias=False),
            nn.BatchNorm2d(256, momentum=batchNorm_momentum),
            nn.ReLU(inplace=True),
            
            nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1, bias=False),
            nn.BatchNorm2d(256, momentum=batchNorm_momentum),
            nn.ReLU(inplace=True),

            nn.Conv2d(256, 128, kernel_size=3, stride=1, padding=1, bias=False),
            nn.BatchNorm2d(128, momentum=batchNorm_momentum),
            nn.ReLU(inplace=True)
        )

        self.decode4 = nn.Sequential(
            nn.Conv2d(128, 128, kernel_size=3, stride=1, padding=1, bias=False),
            nn.BatchNorm2d(128, momentum=batchNorm_momentum),
            nn.ReLU(inplace=True),

            nn.Conv2d(128, 64, kernel_size=3, stride=1, padding=1, bias=False),
            nn.BatchNorm2d(64, momentum=batchNorm_momentum),
            nn.ReLU(inplace=True)
        )

        self.decode5 = nn.Sequential(
            nn.Conv2d(64, 64, kernel_size=3, stride=1, padding=1, bias=False),
            nn.BatchNorm2d(64, momentum=batchNorm_momentum),
            nn.ReLU(inplace=True),

            nn.Conv2d(64, out_channels, kernel_size=3, stride=1, padding=1)
        )

    def forward(self, x, idx):
        x = F.max_unpool2d(x, idx[4], kernel_size=2, stride=2)

        x = self.decode1(x)
        x = F.max_unpool2d(x, idx[3], kernel_size=2, stride=2)

        x = self.decode2(x)
        x = F.max_unpool2d(x, idx[2], kernel_size=2, stride=2)

        x = self.decode3(x)
        x = F.max_unpool2d(x, idx[1], kernel_size=2, stride=2)

        x = self.decode4(x)
        x = F.max_unpool2d(x, idx[0], kernel_size=2, stride=2)

        x = self.decode5(x)

        return x


class SegNet(nn.Module):
    # https://arxiv.org/abs/1511.00561
    def __init__(self, num_classes):
        super(SegNet, self).__init__()

        self.encode = Encoder(in_channels=3)
        self.decode = Decoder(out_channels=num_classes)

    def forward(self, x):
        x, idx = self.encode(x)
        x = self.decode(x, idx)
        return x


if __name__ == '__main__':
    input = torch.randn(1, 3, 384, 544)
    model = SegNet(num_classes=2)
    output = model(input)
    print(output.shape)
SegNet原理与代码实例讲解
AI天才研究院
07-28 441
SegNet原理与代码实例讲解 作者：禅与计算机程序设计艺术 / Zen and the Art of Computer Programming 关键词：卷积神经网络，深度学习，图像处理，特征提取，下采样，上采样，金字塔结构
TensorFlow2深度学习实战（十三）： 语义分割算法 SegNet 实战
热门推荐
不积跬步，无以至千里！
07-14 1万+
SeNet语义分割网络，对自制数据集下的场景进行目标分割！
Segnet网络结构
10-26
Segnet网络结构
SegNet: A Deep Convolutional Encoder-Decoder Architecture for Image Segmentation
qq_52684249的博客
01-18 1036
SegNet是在FCN网络模型的基础上，修改VGG-16网络得到的语义分割网络，通过存储最大池化索引以保留边界信息、去掉全连接层并使用批量归一化等手段，解决了边界划分不清、计算量大等问题，降低了内存和存储需求，加快了推理速度，提升了像素级分类精度，实现了高内存效率、轻量模型、高分割精度和快速推理。在CamVid数据集上准确率超83%，在遥感图像建筑物分割等任务中性能更优，满足实时性检测需求。
课程4. 图像处理算法与卷积神经网络
最新发布
Eric005的博客
03-17 1237
卷积层从输入图像中提取特定类别的某些特征模式（猫头、狗头、飞机尾巴、车身等）。在神经网络中，那些经过训练的过滤器被激活，以对图像中存在的模式类型做出反应。
图像分割入门-SegNet理论与实践
qq_45831510的博客
07-08 1415
SegNet 作为一种高效且精确的图像语义分割网络，通过其独特的结构和流程，成功地解决了许多复杂的图像分割问题，并在实际应用中取得了广泛的成功。随着深度学习技术的进一步发展，SegNet 和其衍生算法有望在未来继续推动图像分割技术的进步，为各种应用场景提供更加智能和精确的解决方案。
通俗易懂理解SegNet语义分割模型
IT菜鸟
01-24 2220
通俗易懂理解SegNet语义分割模型
深度学习之 SegNet
weixin_43775295的博客
11-26 757
解码网络使用保存的最大池化索引上采样，得到稀疏的特征图，将特征图与可训练的解码滤波器族卷积得到致密的特征图。图3中右边是FCN的解码技术，FCN对编码的特征图进行降维，降维后输入到解码网络，解码网络中，上采样使用反卷积实现，上采样的特征图与降维的编码图进行element-wise add得到最终的解码特征图。可训练的图像分割引擎，包含一个encoder网络，一个对应的decoder网络，衔接像素级分类层，解码网络与VGG16的13层卷积层相同。上采样得到的稀疏图与可训练的滤波器卷积得到致密的特征图。
SegNet 论文解析
qq_43205656的博客
08-22 2692
SegNet-----论文分析（个人理解） 1. 概述： SegNet之前，语义分割的许多方法都是直接采用设计图像分类的方法去解决，虽然有时获得的结果还说得过去，但总体来说比较粗糙。其实很容易理解为什么，在图像分类的过程中，我们都是将特征图进行多次卷积与max pooling，并进行展开为全连接层，最终依赖softmax等函数进行概率的计算，在此过程中，图像经过一系列下采样早已经失去了边界信息，边界信息的丢失对于图像分类没有什么影响，但是图像分割就不一样了，它需要根据边界来细致的将某个物体分割出来。基于这个
DL之SegNet：SegNet图像分割/语义分割算法的简介(论文介绍)、架构详解、案例应用等配图集合之详细攻略
头部AI社区如有邀博主AI主题演讲请私信—心比天高，仗剑走天涯，保持热爱，奔赴向梦想！低调，专注，谦虚，自律，反思，成长，还算比较正能量的博主，公益免费传播…内心特别想在AI界做出一些可以推进历史进程影响力的技术(兴趣使然，有点小情怀，也有点使命感呀
04-28 9833
DL之SegNet：SegNet图像分割/语义分割算法的简介(论文介绍)、架构详解、案例应用等配图集合之详细攻略 导读 基于CNN的神经网络SegNet算法可进行高精度地识别行驶环境。 目录 SegNet图像分割算法的简介(论文介绍) 0、实验结果 1、SegNet算法的关键思路 SegNet图像分割算法的架构详解 SegNet图像分割算法的案例应用 ...
SegNet论文理解
qq_39333636的博客
01-17 4436
加入自己的一些理解，共同学习一起进步。
SegNet-论文笔记-理解
Maple__Boy
11-01 2203
Segnet: 一种用于图像分割的深度卷积编码－解码架构 摘要 我们展示了一种新奇的有实践意义的深度全卷积神经网络结构，用于逐个像素的语义分割，并命名为SegNet.核心的可训练的分割引擎包含一个编码网络，和一个对应的解码网络，并跟随着一个像素级别的分类层.编码器网络的架构在拓扑上与VGG16网络中的13个卷积层相同.解码网络的角色是映射低分辨率的编码后的特征图到输入分辨率的特征图.具体地，解码器使用在相应编码器的最大合并步骤中计算的池化索引来执行非线性上采样.这消除了上采样的学习需要.上采样后的图是稀疏的
S4-SegNet 论文解读
l2181265的博客
02-16 1433
SegNet SegNet是基于FCN，修改VGG-16网络得到的语义分割网络，有两种版本的SegNet，分别为SegNet与Bayesian SegNet，同时SegNet作者根据网络的深度提供了一个basic版（4层的浅网络）。 1、SegNet网络框架： SegNet由encoder，decoder和softmax分类层组成。SegNet和FCN类似，只是在Decoder(Upsampli...
segnet和unet区别_SegNet图像分割网络直观详解
weixin_39776344的博客
12-19 7721
简介SegNet是一个由剑桥大学团队开发的图像分割的开源项目，该项目可以对图像中的物体所在区域进行分割，例如车，马路，行人等，并且精确到像素级别。图像分割的实现由一个卷积神经网络构成，该网络主要有两部分组成：encoder与decoder。encoder是一个沿用VGG16的网络模型，主要对物体信息进行解析。decoder将解析后的信息对应成最终的图像形式，即每个像素都用对应其物体信息的颜色(或者...
论文阅读|Lite-HRNet
weixin_45782047的博客
04-04 3627
人体姿态估计|Lite-HRNet
SegNet
易之阴阳，量子纠缠，道之一体，缘起性空
04-29 758
SegNet 是一种深度学习模型，主要用于图像语义分割任务。SegNet 的设计基于全卷积网络（Fully Convolutional Network, FCN）的理念，并引入了独特的编码器-解码器结构和上采样机制，使其在保持高效计算的同时，能够对输入图像进行像素级别的细粒度分类。尽管随着深度学习技术的发展，出现了许多更为先进的分割模型，但SegNet的设计理念和关键技术仍然对后续研究产生了深远影响，并在特定应用场景中展现出良好的性能和实用性。
论文阅读：SegNet: A Deep Convolutional Encoder-Decoder Architecture for Image Segmentation
漩涡小林的博客
02-14 1920
文章目录1 摘要2 亮点2.1 网络结构2.1.1 编码器结构2.1.2 解码器结构3 效果4 结论5 参考资料 1 摘要 本文提出一种可用于端到端训练的语义分割网络结构——SegNet，它是一种编码器—解码器结构。编码器结构类似于VGG16的前13层，而本文的重点介绍在于解码器部分，其创新性地使用了一种池化索引的上采样方法，不仅消耗更小的内存，而且在上采样部分避免了学习。该网络主要运用于道路场景...
深度学习论文精读[3]：SegNet
weixin_37737254的博客
07-13 1307
在场景理解（Scene understanding）和自动驾驶（Autonomous driving）等应用领域，仅关注分割精度并不能满足应用需要，更应该关注模型推理速度和内存占用等性能。在编解码分割框架上，不同的方法在编码器上一般都是大同小异，但在上采样解码器上各有不同。来自剑桥的研究团队认为，在内存不受限和实时性要求不高的情况下，UNet将编码器中的特征图全部连接到解...
论文翻译（五）：SegNet: A Deep Convolutional Encoder-Decoder Architecture for Image Segmentation
ting的博客
07-15 2020
【论文翻译】：SegNet: A Deep Convolutional Encoder-Decoder Architecture for Image Segmentation
segnet
03-10
### SegNet 架构概述 SegNet 是一种专为图像分割设计的深度卷积神经网络架构，其独特之处在于利用最大池化索引进行上采样，从而有效保留并恢复输入图像的空间信息[^1]。 #### 编码器-解码器结构 SegNet 的整体框架由两部分组成：编码器（Encoder）和解码器（Decoder）。编码器负责提取特征图中的高层次抽象表示；而解码器则通过逐步放大这些特征图来重建原始分辨率下的像素级分类结果。这种对称式的编解码机制有助于保持空间位置的一致性和准确性[^3]。 #### 特征映射与反向传播 在网络训练过程中，编码阶段会记录下每次执行最大池化的精确位置信息作为索引表，在后续解码环节中依据此索引来指导相应的逆运算——即非线性插值过程。这种方法不仅减少了参数量还提高了计算效率，同时也增强了模型对于细粒度物体边界的捕捉能力。 ```python import torch.nn as nn class SegNet(nn.Module): def __init__(self, input_channels=3, output_channels=32): super(SegNet, self).__init__() # Encoder layers with max pooling indices recording self.encoder = ... # Decoder layers using recorded indices for upsampling self.decoder = ... def forward(self, x): pool_indices = [] # Forward pass through encoder saving indices during MaxPool operations encoded_features, pool_indices = self.encoder(x) # Use saved indices within decoder path for precise unpooling steps decoded_output = self.decoder(encoded_features, pool_indices) return decoded_output ``` #### 应用领域 得益于上述特性，SegNet 已经被广泛应用于多个计算机视觉任务当中，尤其是在城市街景解析、医学影像分析等领域表现尤为突出。例如，在自动驾驶辅助系统里可以用来识别道路标志物以及行人车辆等目标对象；而在医疗成像方面可用于肿瘤检测或者器官轮廓勾勒等工作[^2]。
评论 16
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值