全卷积网络FCN

全卷积网络FCN

fcn是深度学习用于图像分割的鼻祖.后续的很多网络结构都是在此基础上演进而来.

图像分割即像素级别的分类.

语义分割的基本框架:
前端fcn(以及在此基础上的segnet,deconvnet,deeplab等) + 后端crf/mrf

FCN是分割网络的鼻祖,后面的很多网络都是在此基础上提出的.
论文地址

和传统的分类网络相比,就是将传统分类网络的全连接层用反卷积层替代.得到一个和图像大小一致的feature map。本篇文章用的网络是VGG.

主要关注两点

  • 全连接层替换成卷积层.用反卷积的方式完成上采样
  • 不同layer的输出要做相加.用以增强feature map的表达能力.

反卷积(deconvolutional)

关于反卷积(也叫转置卷积)的详细推导,可以参考:<https://blog.csdn.net/LoseInVain/article/details/81098502＞

简单滴说就是:卷积的反向操作．以4x4矩阵Ａ为例,卷积核Ｃ(3x3,stride=1),通过卷积操作得到一个2x2的矩阵B. 转置卷积即已知B,要得到A,我们要找到卷积核C,使得B相当于A通过C做正向卷积,得到B.

转置卷积是一种上采样的方法.

跳连(skip layer)

如果只用特征提取部分(也就是VGG全连接层之前的部分)得到的feature map做上采样将feature map还原到图像输入的size的话,feature不够精确.所以采用不同layer的feature map做上采样再组合起来.

代码解析

源码:https://github.com/pochih/FCN-pytorch

其中的核心代码如下:

class FCNs(nn.Module):

    def __init__(self, pretrained_net, n_class):
        super().__init__()
        self.n_class = n_class
        self.pretrained_net = pretrained_net
        self.relu    = nn.ReLU(inplace=True)
        self.deconv1 = nn.ConvTranspose2d(512, 512, kernel_size=3, stride=2, padding=1, dilation=1, output_padding=1)
        self.bn1     = nn.BatchNorm2d(512)
        self.deconv2 = nn.ConvTranspose2d(512, 256, kernel_size=3, stride=2, padding=1, dilation=1, output_padding=1)
        self.bn2     = nn.BatchNorm2d(256)
        self.deconv3 = nn.ConvTranspose2d(256, 128, kernel_size=3, stride=2, padding=1, dilation=1, output_padding=1)
        self.bn3     = nn.BatchNorm2d(128)
        self.deconv4 = nn.ConvTranspose2d(128, 64, kernel_size=3, stride=2, padding=1, dilation=1, output_padding=1)
        self.bn4     = nn.BatchNorm2d(64)
        self.deconv5 = nn.ConvTranspose2d(64, 32, kernel_size=3, stride=2, padding=1, dilation=1, output_padding=1)
        self.bn5     = nn.BatchNorm2d(32)
        self.classifier = nn.Conv2d(32, n_class, kernel_size=1)

    def forward(self, x):
        output = self.pretrained_net(x)
        x5 = output['x5']  # size=(N, 512, x.H/32, x.W/32)
        x4 = output['x4']  # size=(N, 512, x.H/16, x.W/16)
        x3 = output['x3']  # size=(N, 256, x.H/8,  x.W/8)
        x2 = output['x2']  # size=(N, 128, x.H/4,  x.W/4)
        x1 = output['x1']  # size=(N, 64, x.H/2,  x.W/2)

        score = self.bn1(self.relu(self.deconv1(x5)))     # size=(N, 512, x.H/16, x.W/16)
        score = score + x4                                # element-wise add, size=(N, 512, x.H/16, x.W/16)
        score = self.bn2(self.relu(self.deconv2(score)))  # size=(N, 256, x.H/8, x.W/8)
        score = score + x3                                # element-wise add, size=(N, 256, x.H/8, x.W/8)
        score = self.bn3(self.relu(self.deconv3(score)))  # size=(N, 128, x.H/4, x.W/4)
        score = score + x2                                # element-wise add, size=(N, 128, x.H/4, x.W/4)
        score = self.bn4(self.relu(self.deconv4(score)))  # size=(N, 64, x.H/2, x.W/2)
        score = score + x1                                # element-wise add, size=(N, 64, x.H/2, x.W/2)
        score = self.bn5(self.relu(self.deconv5(score)))  # size=(N, 32, x.H, x.W)
        score = self.classifier(score)                    # size=(N, n_class, x.H/1, x.W/1)

        return score  # size=(N, n_class, x.H/1, x.W/1)

train.py中

vgg_model = VGGNet(requires_grad=True, remove_fc=True)
fcn_model = FCNs(pretrained_net=vgg_model, n_class=n_class)

这里我们重点看FCN的forward函数

    def forward(self, x):
        output = self.pretrained_net(x)
        x5 = output['x5']  # size=(N, 512, x.H/32, x.W/32)
        x4 = output['x4']  # size=(N, 512, x.H/16, x.W/16)
        x3 = output['x3']  # size=(N, 256, x.H/8,  x.W/8)
        x2 = output['x2']  # size=(N, 128, x.H/4,  x.W/4)
        x1 = output['x1']  # size=(N, 64, x.H/2,  x.W/2)

        score = self.bn1(self.relu(self.deconv1(x5)))     # size=(N, 512, x.H/16, x.W/16)
        score = score + x4                                # element-wise add, size=(N, 512, x.H/16, x.W/16)
        score = self.bn2(self.relu(self.deconv2(score)))  # size=(N, 256, x.H/8, x.W/8)
        score = score + x3                                # element-wise add, size=(N, 256, x.H/8, x.W/8)
        score = self.bn3(self.relu(self.deconv3(score)))  # size=(N, 128, x.H/4, x.W/4)
        score = score + x2                                # element-wise add, size=(N, 128, x.H/4, x.W/4)
        score = self.bn4(self.relu(self.deconv4(score)))  # size=(N, 64, x.H/2, x.W/2)
        score = score + x1                                # element-wise add, size=(N, 64, x.H/2, x.W/2)
        score = self.bn5(self.relu(self.deconv5(score)))  # size=(N, 32, x.H, x.W)
        score = self.classifier(score)                    # size=(N, n_class, x.H/1, x.W/1)

        return score  # size=(N, n_class, x.H/1, x.W/1)

可见FCN的输入为(batch_size,c,h,w),输出为(batch_size,class,h,w).
首先是经过vgg的特征提取层,可以得到feature map. 5个max_pool后的feature map的size分别为

        x5 = output['x5']  # size=(N, 512, x.H/32, x.W/32)
        x4 = output['x4']  # size=(N, 512, x.H/16, x.W/16)
        x3 = output['x3']  # size=(N, 256, x.H/8,  x.W/8)
        x2 = output['x2']  # size=(N, 128, x.H/4,  x.W/4)
        x1 = output['x1']  # size=(N, 64, x.H/2,  x.W/2)

之后每一个pool layer的feature map都经过一次2倍上采样,并与前一个pool layer的输出进行element-wise add.(resnet也有类似操作).从而使得上采样后的feature map信息更充分更精准,模型的鲁棒性会更好.
例如以输入图片尺寸为224x224为例,pool4的输出为(,512,14,14),pool5的输出为(,512,7,7),反卷积后得到(,512,14,14),再与pool4的输出做element-wise add。得到的仍然是(,512,14,14). 对这个输出做上采样得到(,256,28,28)再与pool3的输出相加. 依次类推,最终得到(,64,112,112).

此后,再做一次反卷积上采样得到(,32,224,224),之后卷积得到(,n_class,224,224)。即得到n_class张224x224的feature map。

下图显示了随着上采样的进行,得到的feature map细节越来越丰富.

损失函数

criterion = nn.BCEWithLogitsLoss()

损失函数采用二分类交叉熵.torch中有2个计算二分类交叉熵的函数

  • BCELoss()
  • BCEWithLogitsLoss()

后者只是在前者的基础上,对输入先做一个sigmoid将输入转换到0-1之间.即BCEWithLogitsLoss = Sigmoid + BCELoss

一个具体的例子可以参考:https://blog.csdn.net/qq_22210253/article/details/85222093

原文地址：https://www.cnblogs.com/sdu20112013/p/12303752.html

时间： 2024-09-30 06:05:28

全卷积网络FCN的相关文章

全卷积网络 FCN 详解

背景 CNN能够对图片进行分类,可是怎么样才能识别图片中特定部分的物体,在2015年之前还是一个世界难题.神经网络大神Jonathan Long发表了<Fully Convolutional Networks for Semantic Segmentation>在图像语义分割挖了一个坑,于是无穷无尽的人往坑里面跳. 全卷积网络 Fully Convolutional Networks CNN 与 FCN 通常CNN网络在卷积层之后会接上若干个全连接层, 将卷积层产生的特征图(feature m

语义分割--全卷积网络FCN详解

语义分割--全卷积网络FCN详解 1.FCN概述 CNN做图像分类甚至做目标检测的效果已经被证明并广泛应用,图像语义分割本质上也可以认为是稠密的目标识别(需要预测每个像素点的类别). 传统的基于CNN的语义分割方法是:将像素周围一个小区域(如25*25)作为CNN输入,做训练和预测.这样做有3个问题: - 像素区域的大小如何确定 - 存储及计算量非常大 - 像素区域的大小限制了感受野的大小,从而只能提取一些局部特征 为什么需要FCN? 我们分类使用的网络通常会在最后连接几层全连接层,它会将原来二

RCNN学习笔记(8)：Fully Convolutional Networks for Semantic Segmentation(全卷积网络FCN）

[论文信息] <Fully Convolutional Networks for Semantic Segmentation> CVPR 2015 best paper Reference link: http://blog.csdn.net/tangwei2014 http://blog.csdn.net/u010025211/article/details/51209504 概览&主要贡献 提出了一种end-to-end的做semantic segmentation的方法,简称FC

R-FCN：基于区域的全卷积网络来检测物体

http://blog.csdn.net/shadow_guo/article/details/51767036 原文标题为"R-FCN: Object Detection via Region-based Fully Convolutional Networks ",作者代季峰 1,14年毕业的清华博士到微软亚洲研究院的视觉计算组,CVPR 16 两篇一作的会议主持人~ ╰(°▽°)╯ 同时公布了源码~ 2 后面主要内容为原文随便的翻译或概括.必有不紧贴原文原意之处,曲解请指出,否则

使用Caffe完成图像目标检测 和 caffe 全卷积网络

一.[用Python学习Caffe]2. 使用Caffe完成图像目标检测 标签: pythoncaffe深度学习目标检测ssd 2017-06-22 22:08 207人阅读 评论(0) 收藏 举报  分类: 机器学习(22)  深度学习(12)  版权声明:本文为博主原创文章,未经博主允许不得转载. 目录(?)[+] 2. 使用Caffe完成图像目标检测 本节将以一个快速的图像目标检测网络SSD作为例子,通过Python Caffe来进行图像目标检测. 必须安装windows-ssd版本的Ca

深度卷积网络CNN与图像语义分割

转载请注明出处: http://xiahouzuoxin.github.io/notes/ 级别1:DL快速上手 级别2:从Caffe着手实践 级别3:读paper,网络Train起来 级别3:Demo跑起来 读一些源码玩玩 熟悉Caffe接口,写Demo这是硬功夫 分析各层Layer输出特征 级别4:何不自己搭个CNN玩玩 级别5:加速吧,GPU编程 关于语义分割的一些其它工作 说好的要笔耕不缀,这开始一边实习一边找工作,还摊上了自己的一点私事困扰,这几个月的东西都没来得及总结一下.这就来记录

TCN时间卷积网络——解决LSTM的并发问题

TCN是指时间卷积网络,一种新型的可以用来解决时间序列预测的算法.在这一两年中已有多篇论文提出,但是普遍认为下篇论文是TCN的开端. 论文名称: An Empirical Evaluation of Generic Convolutional and Recurrent Networks for Sequence Modeling 作者:Shaojie Bai 1 J. Zico Kolter 2 Vladlen Koltun 3 自从TCN提出后引起了巨大反响,有人认为 时间卷积网络(TCN)

深度卷积网络

深度卷积网络 涉及问题: 1.每个图如何卷积: (1)一个图如何变成几个? (2)卷积核如何选择? 2.节点之间如何连接? 3.S2-C3如何进行分配? 4.16-120全连接如何连接? 5.最后output输出什么形式? ①各个层解释: 我们先要明确一点:每个层有多个Feature Map,每个Feature Map通过一种卷积滤波器提取输入的一种特征,然后每个Feature Map有多个神经元. C1层是一个卷积层(为什么是卷积?卷积运算一个重要的特点就是,通过卷积运算,可以使原信号特征增强

TensorFlow 中的卷积网络

TensorFlow 中的卷积网络 是时候看一下 TensorFlow 中的卷积神经网络的例子了. 网络的结构跟经典的 CNNs 结构一样,是卷积层,最大池化层和全链接层的混合. 这里你看到的代码与你在 TensorFlow 深度神经网络的代码类似,我们按 CNN 重新组织了结构. 如那一节一样,这里你将会学习如何分解一行一行的代码.你还可以下载代码自己运行. 感谢 Aymeric Damien 提供了这节课的原始 TensorFlow 模型. 现在开看下! 数据集 你从之前的课程中见过这节课的