4-图像分割之SegNet＆DeconvNet

最新推荐文章于 2024-07-08 18:26:23 发布
最新推荐文章于 2024-07-08 18:26:23 发布
阅读量904 收藏 8
点赞数
分类专栏： # 从零开始图像分割 文章标签： 深度学习 机器学习 神经网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40073354/article/details/120156599
版权
本文介绍了编码器-解码器架构在图像分割任务中的重要性，如SegNet和DeconvNet。SegNet通过重用最大池化索引实现精确分割，而DeconvNet则采用反卷积和反池化，两者都在减少过拟合的同时恢复图像的细节。PyTorch实现展示了这两个模型的结构和前向传播过程，强调了特征图尺寸管理和信息恢复的重要性。
摘要由CSDN通过智能技术生成

1.预备知识

编码器和解码器：

编码器结构:
编码器部分主要由普通卷积层和下采样层将特征图尺寸缩小，使其成为更低维的表征。目的是尽可能多的提取低级特征和高级特征，从而利用提取到的空间信息和全局信息精确分割。
解码器结构:
解码器部分主要由普通卷积、上采样层和融合层组成。利用上采样操作逐步恢复空间维度，融合编码过程中提取到的特征，在尽可能减少信息损失的前提下完成同尺寸输入输出。

随机丢弃层：

当一个复杂的前馈神经网络被训练在小的数据集时，容易造成过拟合。为了防止过拟合，可以通过阻止特征检测器的共同作用来提高神经网络的性能。Dropout可以作为训练深度神经网络的一种技巧供选择。在每个训练批次中，通过忽略一半的特征检测器(让一半的隐层节点值为0)，可以明显地减少过拟合现象。这种方式可以减少特征检测器（隐层节点)间的相互作用。
 

 反池化：

上采样通常是两种方式，一种是通过插值的方式实现，另外一种是通过反卷积实现。这里引入第三种实现方式：反池化。

编码器中的每一个最大池化层的索引都存储了起来，用于之后在解码器中使用那些存储的索引来对相应特征图进行去池化操作。这有助于保持高频信息的完整性，但当对低分辨率的特征图进行反池化时，它也会忽略邻近的信息。
 

 2.研究成果及意义

SegNet:

  • 在内存（参数）和准确率之间找到了很好地平衡点
  • 将编码解码结构普适化
  • 在多个场景数据集中均取得了很好的结果

Segnet包含编码器和解码器，解码器上采样会利用编码期间用到的池化信息。Segnet在camvid数据上达到60.10的miou值，目前65-70算是尚可的模型，论文中有关实验的部分非常饱满。

个人概括SegNet要点：

  • 编码解码结构
  • 重用max_polling indices（池化索引）

网络结构：

 

由图可知，网络是完全对称的，输入图片经过五次卷积池化，然后是五次上采样卷积，值得注意的是利用了下采样池化过程中的信息，从而映射回上采样的过程中。 

DeconvNet:

提出深度反卷积网络，编码部分使用vgg16，解码器使用反卷积和反池化，训练是把图像一块一块区域的进行输入，需要一定人为的干预。

网络结构：

 同样也是经过不断的卷积池化，然后上采样。与Segnet所不同的有两点：

  • 中间加入了两个全卷积（现在看来是不太可取，一方面增加了参数量，另一方面将原来二维的分割变成了一维的向量）
  • 在上采样的过程中采用了反卷积而不是卷积（这里反卷积经过设计并不会扩大特征图的尺寸，而且作者认为反卷积能够生成更密集的特征图）
  • 论文写法逻辑经典

3.Pytorch实现SegNet＆DeconvNet

SegNet.py

import torch
from torch import nn
import torch.nn.functional as F
import torchvision.models as models
import warnings
warnings.filterwarnings("ignore")

vgg16_pretrained = models.vgg16(pretrained=True)  # 加载预训练权重


def decoder(input_channel, output_chanel, num=3):  # num用来控制是3层卷积还是2层卷积
    if num == 3:
        decoder_body = nn.Sequential(
            nn.Conv2d(input_channel, input_channel, 3, padding=1),
            nn.Conv2d(input_channel, input_channel, 3, padding=1),
            nn.Conv2d(input_channel, output_chanel, 3, padding=1),
        )
    elif num == 2:
        decoder_body = nn.Sequential(
            nn.Conv2d(input_channel, input_channel, 3, padding=1),
            nn.Conv2d(input_channel, output_chanel, 3, padding=1)
        )

    return decoder_body


class VGG16_SegNet(torch.nn.Module):
    def __init__(self):
        super(VGG16_SegNet, self).__init__()

        pool_list = [4, 9, 16, 23, 30]
        for index in pool_list:
            vgg16_pretrained.features[index].return_indices = True  # 需要用到池化层的索引

        self.encoder1 = vgg16_pretrained.features[:4]
        self.pool1 = vgg16_pretrained.features[4]

        self.encoder2 = vgg16_pretrained.features[5:9]
        self.pool2 = vgg16_pretrained.features[9]

        self.encoder3 = vgg16_pretrained.features[10:16]
        self.pool3 = vgg16_pretrained.features[16]

        self.encoder4 = vgg16_pretrained.features[17:23]
        self.pool4 = vgg16_pretrained.features[23]

        self.encoder5 = vgg16_pretrained.features[24:30]
        self.pool5 = vgg16_pretrained.features[30]

        self.decoder5 = decoder(512, 512)
        self.unpool5 = nn.MaxUnpool2d(2, 2)

        self.decoder4 = decoder(512, 256)
        self.unpool4 = nn.MaxUnpool2d(2, 2)

        self.decoder3 = decoder(256, 128)
        self.unpool3 = nn.MaxUnpool2d(2, 2)

        self.decoder2 = decoder(128, 64, 2)
        self.unpool2 = nn.MaxUnpool2d(2, 2)

        self.decoder1 = decoder(64, 12, 2)
        self.unpool1 = nn.MaxUnpool2d(2, 2)

    def forward(self, x):  # 3,352,480
        print('input_image:', x.size())
        encoder1 = self.encoder1(x);print('encoder1:', encoder1.size())  # 64,352,480
        output_size1 = encoder1.size();print('output_size1:', output_size1)  # 64,352,480,保留尺寸
        pool1, indices1 = self.pool1(encoder1);print('pool1:', pool1.size());print('indices1:', indices1.size())  # 64,176,240

        encoder2 = self.encoder2(pool1);print('encoder2:', encoder2.size())  # 128,176,240
        output_size2 = encoder2.size();print('output_size2:', output_size2)  # 128,176,240,保留尺寸
        pool2, indices2 = self.pool2(encoder2);print('pool2:', pool2.size());print('indices2:', indices2.size())  # 128,88,120

        encoder3 = self.encoder3(pool2);print('encoder3:', encoder3.size())  # 256,88,120
        output_size3 = encoder3.size();print('output_size3:', output_size3)  # 256,88,120,保留尺寸
        pool3, indices3 = self.pool3(encoder3);print('pool3:', pool3.size());print('indices3:', indices3.size())  # 256,44,60

        encoder4 = self.encoder4(pool3);print('encoder4:', encoder4.size())  # 512,44,60
        output_size4 = encoder4.size();print('output_size4:', output_size4)  # 512,44,60,保留尺寸
        pool4, indices4 = self.pool4(encoder4);print('pool4:', pool4.size());print('indices4:', indices4.size())  # 512,22,30

        encoder5 = self.encoder5(pool4);print('encoder5:', encoder5.size())  # 512,22,30
        output_size5 = encoder5.size();print('output_size5:', output_size5)  # 512,22,30,保留尺寸
        pool5, indices5 = self.pool5(encoder5);print('pool5:', pool5.size());print('indices5:', indices5.size())
        # 512,11,15.pool5和indices5尺寸相同

        unpool5 = self.unpool5(input=pool5, indices=indices5, output_size=output_size5);print('unpool5:', unpool5.size())  # 512,22,30
        decoder5 = self.decoder5(unpool5);print('decoder5:', decoder5.size())  # 512,22,30

        unpool4 = self.unpool4(input=decoder5, indices=indices4, output_size=output_size4);print('unpool4:', unpool4.size())  # 512,44,60
        decoder4 = self.decoder4(unpool4);print('decoder4:', decoder4.size())  # 256,44,60

        unpool3 = self.unpool3(input=decoder4, indices=indices3, output_size=output_size3);print('unpool3:', unpool3.size())  # 256,88,120
        decoder3 = self.decoder3(unpool3);print('decoder3:', decoder3.size())  # 128,88,120

        unpool2 = self.unpool2(input=decoder3, indices=indices2, output_size=output_size2);print('unpool2:', unpool2.size())  # 128,176,240
        decoder2 = self.decoder2(unpool2);print('decoder2:', decoder2.size())  # 64,176,240

        unpool1 = self.unpool1(input=decoder2, indices=indices1, output_size=output_size1);print('unpool1:', unpool1.size())  # 64,352,480
        decoder1 = self.decoder1(unpool1);print('decoder1:', decoder1.size())  # 12,352,480

        return decoder1


if __name__ == "__main__":
    import torch as t

    rgb = t.randn(1, 3, 352, 480)
    net = VGG16_SegNet()
    out = net(rgb)
    print(out.shape)

 DeconvNet.py

import torch
import torchvision.models as models
from torch import nn
from PIL import Image
vgg16_pretrained = models.vgg16(pretrained=True)
import warnings
warnings.filterwarnings("ignore")

def decoder(input_channel, output_channel, num=3):
    if num == 3:
        decoder_body = nn.Sequential(
            nn.ConvTranspose2d(input_channel, input_channel, 3, padding=1),
            nn.ConvTranspose2d(input_channel, input_channel, 3, padding=1),
            nn.ConvTranspose2d(input_channel, output_channel, 3, padding=1))
    elif num == 2:
        decoder_body = nn.Sequential(
            nn.ConvTranspose2d(input_channel, input_channel, 3, padding=1),
            nn.ConvTranspose2d(input_channel, output_channel, 3, padding=1))

    return decoder_body


class VGG16_DeconvNet(torch.nn.Module):
    def __init__(self):
        super(VGG16_DeconvNet, self).__init__()

        pool_list = [4, 9, 16, 23, 30]
        for index in pool_list:
            vgg16_pretrained.features[index].return_indices = True

        self.encoder1 = vgg16_pretrained.features[:4]
        self.pool1 = vgg16_pretrained.features[4]

        self.encoder2 = vgg16_pretrained.features[5:9]
        self.pool2 = vgg16_pretrained.features[9]

        self.encoder3 = vgg16_pretrained.features[10:16]
        self.pool3 = vgg16_pretrained.features[16]

        self.encoder4 = vgg16_pretrained.features[17:23]
        self.pool4 = vgg16_pretrained.features[23]

        self.encoder5 = vgg16_pretrained.features[24:30]
        self.pool5 = vgg16_pretrained.features[30]

        self.classifier = nn.Sequential(
            torch.nn.Linear(512 * 11 * 15, 4096),
            torch.nn.ReLU(),
            torch.nn.Linear(4096, 512 * 11 * 15),
            torch.nn.ReLU(),
        )

        self.decoder5 = decoder(512, 512)
        self.unpool5 = nn.MaxUnpool2d(2, 2)

        self.decoder4 = decoder(512, 256)
        self.unpool4 = nn.MaxUnpool2d(2, 2)

        self.decoder3 = decoder(256, 128)
        self.unpool3 = nn.MaxUnpool2d(2, 2)

        self.decoder2 = decoder(128, 64, 2)
        self.unpool2 = nn.MaxUnpool2d(2, 2)

        self.decoder1 = decoder(64, 12, 2)
        self.unpool1 = nn.MaxUnpool2d(2, 2)

    def forward(self, x):
        encoder1 = self.encoder1(x)
        output_size1 = encoder1.size()
        pool1, indices1 = self.pool1(encoder1)

        encoder2 = self.encoder2(pool1)
        output_size2 = encoder2.size()
        pool2, indices2 = self.pool2(encoder2)

        encoder3 = self.encoder3(pool2)
        output_size3 = encoder3.size()
        pool3, indices3 = self.pool3(encoder3)

        encoder4 = self.encoder4(pool3)
        output_size4 = encoder4.size()
        pool4, indices4 = self.pool4(encoder4)

        encoder5 = self.encoder5(pool4)
        output_size5 = encoder5.size()
        pool5, indices5 = self.pool5(encoder5)
        print('pool5:', pool5.size())

        pool5=pool5.view(pool5.size(0),-1)
        print('pool5-view:', pool5.size())
        fc=self.classifier(pool5)
        print('fc1:', fc.size())
        fc=fc.reshape(1,512,11,15)
        print('fc2:', fc.size())

        unpool5 = self.unpool5(input=fc, indices=indices5, output_size=output_size5);
        #print('unpool5:', unpool5.size())  # 512,22,30
        decoder5 = self.decoder5(unpool5);
        #print('decoder5:', decoder5.size())  # 512,22,30

        unpool4 = self.unpool4(input=decoder5, indices=indices4, output_size=output_size4);
        #print('unpool4:', unpool4.size())  # 512,44,60
        decoder4 = self.decoder4(unpool4);
        #print('decoder4:', decoder4.size())  # 256,44,60

        unpool3 = self.unpool3(input=decoder4, indices=indices3, output_size=output_size3);
        #print('unpool3:', unpool3.size())  # 256,88,120
        decoder3 = self.decoder3(unpool3);
        #print('decoder3:', decoder3.size())  # 128,88,120

        unpool2 = self.unpool2(input=decoder3, indices=indices2, output_size=output_size2);
        #print('unpool2:', unpool2.size())  # 128,176,240
        decoder2 = self.decoder2(unpool2);
        #print('decoder2:', decoder2.size())  # 64,176,240

        unpool1 = self.unpool1(input=decoder2, indices=indices1, output_size=output_size1);
        #print('unpool1:', unpool1.size())  # 64,352,480
        decoder1 = self.decoder1(unpool1);
        #print('decoder1:', decoder1.size())  # 12,352,480

        return decoder1
if __name__ == "__main__":
    import torch as t

    rgb = t.randn(1, 3, 352, 480)
    net = VGG16_DeconvNet()
    out = net(rgb)
    print(out.shape)

DeconvNet里面用到了全连接层，在特征图的尺寸方面需要注意，参见下面这段代码

import torch

x = torch.randn(2, 84480)  # 输入的维度是（2，84480）
print('x:', x.size())

m1 = torch.nn.Linear(512 * 11 * 15, 4096)
output1 = m1(x)
print('output1:', output1.size())

m2 = torch.nn.Linear(4096, 512 * 11 * 15)
output2 = m2(output1)
print('output2:', output2.size())
output2=output2.reshape(2,512,11,15)
print('output2:', output2.size())

（2,84480） 对应的是pool5.view之后的特征图尺寸，不能直接把pool5之后的特征图送入nn.linear()，会报尺寸不匹配的错误，因为nn.linear()接受的是二维张量，pool5之后的特征图是四维张量，另外in_features输入的应该是size而不是batch_size*size,例如上面的（[2,84480]），对应输入到全连接层in_features应该是512 * 11 * 15，经过m1层之后尺寸变为（[2,4096]），再经过m2又变成([2, 84480])。

 参考：

B站深度之眼

PyTorch的nn.Linear()详解 - douzujun - 博客园

冰冻之瓜非一日之寒
关注
专栏目录
语义分割(semantic segmentation) 常用神经网络介绍对比-FCN SegNet U-net DeconvNet
jacke121的专栏
06-18 2882
语义分割(semantic segmentation) 常用神经网络介绍对比-FCN SegNet U-net DeconvNethttp://blog.csdn.net/u012931582/article/details/70314859在这里,先介绍几个概念,也是图像处理当中的最常见任务.语义分割(semantic segmentation)目标检测(object detection)目标识...
语义分割 - SegNet / DeconvNet
Bro_Jun的博客
09-22 922
这里写目录标题论文精读先验知识编码器 - 解码器结构（Encoder - Decoder frame）随机丢弃层（Dropout）反池化（unpooling）SegNet本文创新点算法架构DeconvNet本文创新点算法架构算法实现SegNet.py导入包解码器中的卷积部分的定义构建网络DeconvNet.py导入包解码器中反卷积的部分的定义构建网络 论文精读 先验知识 编码器 - 解码器结构（Encoder - Decoder frame） 编码器结构： 由普通卷积层和下采样层将特征图尺寸缩小 解码器结构
卷积神经网络CNN（4）—— SegNet
热门推荐
Fate_fjh的博客
12-05 4万+
Introduction自己制作国内高速label，使用SegNet训练自己的模型，测试效果 参考：http://mi.eng.cam.ac.uk/projects/segnet/tutorial.html SegNet是Cambridge提出旨在解决自动驾驶或者智能机器人的图像语义分割深度网络，开放源码，基于caffe框架。SegNet基于FCN，修改VGG-16网络得到的语义分割网络，有两种
图像分割--SegNet
zk_ken的博客
05-25 3019
理解参考：https://blog.csdn.net/tuzixini/article/details/78760158SegNet结构：这样的对称结构有种自编码器的感觉在里面，先编码再解码。这样的结构主要使用了反卷积和上池化。即：                                                                          SegNet和FCN...
图像分割“SegNet”
cv_family_z的博客
06-07 1万+
可训练的图像分割引擎，包含一个encoder网络，一个对应的decoder网络，衔接像素级分类层，解码网络与VGG16的13层卷积层相同。解码网络是将低分辨率的编码特征图映射到全分辨率的特征图。解码网络使用最大池化层的池化索引进行非线性上采样，上采样过程就不需要学习。上采样得到的稀疏图与可训练的滤波器卷积得到致密的特征图。使用池化层索引进行上采样的优势：1）提升边缘刻画度；2）减少训练的参数；3）这
图像分割之segnet
zhangjunp3的博客
12-04 5674
一、算法介绍 SegNet网络结构如下图所示，Input为输入图片，Output为输出分割的图像，不同颜色代表不同的分类。语义分割的重要性就在于不仅告诉你图片中某个东西是什么，而且告知你他在图片的位置。我们可以看到是一个对称网络，由中间绿色pooling层与红色upsampling层作为分割，左边是卷积提取高维特征，并通过pooling使图片变小，SegNet作者称为Encoder，右边是反卷积...
图像分割semantic segmentation SegNet详解+tensorflow代码使用【附下载】
AI前行之路
04-14 2万+
原论文链接：SegNet ResNet传送门：Resnet-cifar10 Inceptionv3传送门：inceptionv3     逐像素的semantic segmentation是目前比较活跃的一个研究热点。在深度网络出现之前，效果比较好的方法有随机数，boosting等。而目前比较热门的语义分割结构有：U-Net、SegNet、DeepLab、FCN、ENet、LinkNet等等...
基于深度学习方法的图像分割（含语义分割、实例分割、全景分割）
最新发布
07-12
【作品名称】：基于深度学习方法的图像分割（含语义分割、实例分割、全景分割） 【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。 ...
SegNet_神经网络图像_分割_segnet分割_segnet_
10-04
segnet图像分割神经网络，根据这个网络可以搭建模型，训练图像，预测分割结构
图像语义分割网络：SegNet
09-28
发表SegNet网络的论文为：Badrinarayanan V, Kendall A, Cipolla R.SegNet: A Deep Convolutional Encoder-Decoder Architecture for SceneSegmentation[J]. IEEE Transactions on Pattern Analysis & MachineIntelligence, 2017, PP(99):1-1。 来源于美国加州大学伯克利分校的这项工作为语义分割引入了端到端的全卷积网络，在构建的网络结构中，重新利用ImageNet的预训练网络用于语义分割，并使用了反卷积层进行上采样并且引入跳跃连接来改善上采样粗糙的像素定位。
SegNet:高效而精准的图像语义分割网络
DXCAWMM的博客
03-08 5434
本文基于《SegNet: A Deep Convolutional Encoder-Decoder Architecture for Image Segmentation》论文，详细解读SegNet网络模型及其设计理念，并从基准测试的角度入手，对比其与其它典型分割模型的差别。
深度学习之图像分割（二）：SegNet
water_93的博客
11-23 1215
2、SegNet/DeconvNet：修改VGG网络，基于解码的方法     编码器-解码器结构：池化-上池化实现       编码器采用最大池化层逐渐缩小输入数据的空间维度，解码器采用上池化逐步恢复目标细节和相应的空间维度。上池化的实现主要在于池化时记住输出值的位置，在上池化时再将这个值填回原来的位置，其他位置填0即OK。  ...
第92步 深度学习图像分割：SegNet建模
qq_30452897的博客
11-15 1719
第92步 深度学习图像分割：SegNet建模
图像语义分割（2）- SegNet
zizi7的专栏
08-15 4075
SegNet【1】是FCN 的一个改进版，由 Cambridge 提出，旨在解决自动驾驶或智能机器人的图像语义分割
深度学习之图像分割—— SegNet基本思想和网络结构以及论文补充
qq_44832832的博客
02-18 8318
也就是每次Pooling，都会保存通过max选出的权值在2x2 filter中的相对位置，对于上图的6来说，6在粉色2x2 filter中的位置为(1，1)(index从0开始），黄色的3的index为(0，0)。，即卷积后保持图像原始尺寸；在网络框架中，SegNet，最后一个卷积层会输出所有的类别（包括other类），网络最后加上一个softmax层，由于是end to end， 所以softmax需要求出所有每一个像素在所有类别最大的概率，最为该像素的label，最终完成图像像素级别的分类。
深度学习（十九）——FCN, SegNet, DeconvNet, DeepLab, ENet, GCN
antkillerfarm的专栏
03-12 1万+
前DL时代的语义分割（续） Grab cut Grab cut是微软剑桥研究院于2004年提出的著名交互式图像语义分割方法。与N-cut一样，grab cut同样也是基于图划分，不过grab cut是其改进版本，可以看作迭代式的语义分割算法。Grab cut利用了图像中的纹理（颜色）信息和边界（反差）信息，只要少量的用户交互操作即可得到比较好的前后背景分割结果。 在Grab cut中，R...
探秘TensorFlow-SegNet：深度学习图像分割的高效工具
gitblog_00043的博客
04-27 447
探秘TensorFlow-SegNet：深度学习图像分割的高效工具 项目地址:https://gitcode.com/gh_mirrors/te/Tensorflow-SegNet 是一个基于TensorFlow实现的SegNet模型，它专注于图像语义分割任务，为研究者和开发者提供了强大的工具。在这篇文章中，我们将深入了解此项目的原理、应用及其特色，以期激发您在图像处理领域的创新潜力。 什么是图像...
图像分割入门-SegNet理论与实践
qq_45831510的博客
07-08 1094
SegNet 作为一种高效且精确的图像语义分割网络，通过其独特的结构和流程，成功地解决了许多复杂的图像分割问题，并在实际应用中取得了广泛的成功。随着深度学习技术的进一步发展，SegNet 和其衍生算法有望在未来继续推动图像分割技术的进步，为各种应用场景提供更加智能和精确的解决方案。
SegNet:深度学习图像分割神经网络的应用
资源摘要信息:"SegNet是一种用于图像分割的卷积神经网络。它是由剑桥大学计算机实验室的研究人员开发的，目的是在各种应用中提供高效的像素级分类。SegNet的关键特点包括其编码器-解码器架构，这种架构使得网络能够...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值