Pytorch实战语义分割（VOC2012）

杨利霞

& t* E$ Q! [( T' p9 g+ h
  G; Y/ d8 l! v8 T' i, N9 \Pytorch实战语义分割（VOC2012）
; h1 F5 i- F, |) X3 q% Q本文参照了《动手深度学习》的9.9、9.10章节，原书使用的是 mxnet 框架，本文改成了pytorch代码。
语义分割（semantic segmentation）问题，它关注如何将图像分割成属于不同语义类别的区域。值得一提的是，这些语义区域的标注和预测都是像素级的。
: ^3 `8 P: L0 J: [3 @: x( a9 V
- s: M6 s$ h" f: |5 @
语义分割中图像有关狗、猫和背景的标签
# o( ^# \, D" _4 x$ E& \文章目录

/ n; g% o- M! O+ V$ S* _' _& h1 图像分割和实例分割
+ b' M5 S# Z8 N# Z$ g2 Pascal VOC2012语义分割数据集
( ~$ ~0 j# D; N7 W6 M2.1 导入模块
2.2 下载数据集
2.3 可视化数据
2 t* O% u- f% T  J2 J) X2 w  A; G4 e2.4 预处理数据
3 自定义数据集类
3.1 数据集类
3.2 读取数据集
4 构造模型
" b2 Z, ]0 [$ m- a* J# f: Z6 g4.1 预训练模型
0 N! h( r( }+ |  p* h4.2 修改成FCN
4.3 初始化转置卷积层
: E" G  z6 E7 E0 T6 c! j$ \5 训练模型
5 z* I( e1 @7 |+ `6 ]6 测试模型
9 @- q9 N% U3 s# b6 J; ~6.1 通用型
6.2 不通用
8 f5 f/ c6 U- }; {& ]' C" d7 结语
1 图像分割和实例分割
2 c2 s5 g. \/ h& b* H# ^
" N, _4 G8 Z9 [- x/ g2 I( x计算机视觉领域还有2个与语义分割相似的重要问题，即图像分割（image segmentation）和实例分割（instance segmentation）：
) Z. ]# u$ Q7 [# [' A& B3 b
+ L! k8 _* {3 v$ Z图像分割将图像分割成若干组成区域。这类问题的方法通常利用图像中像素之间的相关性。它在训练时不需要有关图像像素的标签信息，在预测时也无法保证分割出的区域具有我们希望得到的语义。以上图的图像为输入，图像分割可能将狗分割成两个区域：一个覆盖以黑色为主的嘴巴和眼睛，而另一个覆盖以黄色为主的其余部分身体。
$ i1 l. t7 W5 ?' Y" o& n实例分割又叫同时检测并分割（simultaneous detection and segmentation）。它研究如何识别图像中各个目标实例的像素级区域。与语义分割有所不同，实例分割不仅需要区分语义，还要区分不同的目标实例。如果图像中有两只狗，实例分割需要区分像素属于这两只狗中的哪一只。

4 _* ?% o9 I% d% m/ e9 B2 Pascal VOC2012语义分割数据集

: q5 V$ E- F4 M2.1 导入模块
import time
8 c2 e7 K: r3 g4 `1 M3 \import copy
# f( D; B0 l, `* p; V, O6 Mimport torch
from torch import optim, nn
: X5 }( U; i" @/ R& `- Y% Gimport torch.nn.functional as F
import torchvision
1 ^* `7 a* [3 H+ Ffrom torchvision import transforms
% ~. ^; f5 ?6 t2 l& cfrom torchvision.models import resnet18
import numpy as np
# I5 |# e8 w# K0 xfrom matplotlib import pyplot as plt
from PIL import Image
. O! B/ k" {6 s/ limport sys
( b. N! F' u- l9 j- O! m  z. c- b7 bsys.path.append("..")
1 }( N. o# o* @1 z& r1 yfrom IPython import display
1 r" v# J# m0 K3 Zfrom tqdm import tqdm
" l# Y( Q. s9 \/ f$ s# u% O, K1 kimport warnings
% L5 _4 }, @* M' |/ _: J' fwarnings.filterwarnings("ignore")

2.2 下载数据集

语义分割的一个重要数据集叫作Pascal VOC2012，点击下载这个数据集的压缩包，大小是2 GB左右，所以下载需要一定时间。下载后解压得到VOCdevkit/VOC2012文件夹，然后将其放置在data文件夹下，VOC2012文件目录是这样的：


ImageSets/Segmentation路径包含了指定训练和测试样本的文本文件
JPEGImages和SegmentationClass路径下分别包含了样本的输入图像和标签。这里的标签也是图像格式，其尺寸和它所标注的输入图像的尺寸相同。标签中颜色相同的像素属于同一个语义类别。
- \- r+ h% K0 E' N" A' F7 T2.3 可视化数据
! b1 @" F6 C) K% F, F; o' \% F! V
定义read_voc_images函数将输入图像和标签读进内存。
- c$ M) {: o5 D* s
* ?* Z+ t3 Q, r% r0 A/ k. ]def read_voc_images(root="../../data/VOCdevkit/VOC2012", is_train=True, max_num=None):
2 x$ ]7 M* O' h# C    txt_fname = '%s/ImageSets/Segmentation/%s' % (root, 'train.txt' if is_train else 'val.txt')
* j6 j- }4 j* `0 W: Q& k- R0 X    with open(txt_fname, 'r') as f:
9 U& N# h0 Q+ m8 U        images = f.read().split() # 拆分成一个个名字组成list
# d3 j, M, I+ Q% ~' N2 O    if max_num is not None:
        images = images[:min(max_num, len(images))]
5 X( b/ G4 l! P% a& ]3 x8 Y    features, labels = [None] * len(images), [None] * len(images)
    for i, fname in tqdm(enumerate(images)):
2 b  n) H: L& K% \' h* C( d        # 读入数据并且转为RGB的 PIL image
        features = Image.open('%s/JPEGImages/%s.jpg' % (root, fname)).convert("RGB")
) a4 A% F7 u% ]5 ?% }  E        labels = Image.open('%s/SegmentationClass/%s.png' % (root, fname)).convert("RGB")
5 ?: Q3 u3 ~* Q9 W7 q    return features, labels # PIL image 0-255
" \/ Z& n5 ?2 f0 H  S0 I. T" `
' I' o; ~+ {1 ^) f5 ?定义可视化数据集的函数show_images
3 h; @2 J& \, s+ B0 q, V
# 这个函数可以不需要
def set_figsize(figsize=(3.5, 2.5)):
    """在jupyter使用svg显示"""
    display.set_matplotlib_formats('svg')
    # 设置图的尺寸
8 H7 O6 b7 \3 y/ t- j4 ^    plt.rcParams['figure.figsize'] = figsize
# g6 W2 ]) \& l# h0 G: A
def show_images(imgs, num_rows, num_cols, scale=2):
    # a_img = np.asarray(imgs)
    figsize = (num_cols * scale, num_rows * scale)
- a% Z' w  q+ r0 D    _, axes = plt.subplots(num_rows, num_cols, figsize=figsize)
    for i in range(num_rows):
        for j in range(num_cols):
            axes[j].imshow(imgs[i * num_cols + j])
' l, M6 Q- l  V+ a$ B            axes[j].axes.get_xaxis().set_visible(False)
% c( @5 O+ q; ?' ?7 W- y# ~            axes[j].axes.get_yaxis().set_visible(False)
    plt.show()
* g" R0 p* R) o5 g    return axes
: Z+ L& ^) w$ S4 T' R
定义可视化数据集的函数show_images。

! u: S' Y& Y" r% b* _; ^. G# 这个函数可以不需要
def set_figsize(figsize=(3.5, 2.5)):
    """在jupyter使用svg显示"""
4 x1 O3 v- ^+ B- Z    display.set_matplotlib_formats('svg')
    # 设置图的尺寸
    plt.rcParams['figure.figsize'] = figsize

def show_images(imgs, num_rows, num_cols, scale=2):
5 |$ k; A- }9 C& C- ~" M    # a_img = np.asarray(imgs)
* _1 C5 z: Z8 f    figsize = (num_cols * scale, num_rows * scale)
    _, axes = plt.subplots(num_rows, num_cols, figsize=figsize)
    for i in range(num_rows):
        for j in range(num_cols):
0 Y0 E! x+ g( b            axes[j].imshow(imgs[i * num_cols + j])
* A% B% u( e  h3 P1 w" M            axes[j].axes.get_xaxis().set_visible(False)
& W2 ]% h2 d+ A            axes[j].axes.get_yaxis().set_visible(False)
" L: M, Q+ b8 I; G6 A    plt.show()
    return axes
画出前5张输入图像和它们的标签。在标签图像中，白色和黑色分别代表边框和背景，而其他不同的颜色则对应不同的类别。
4 q# S$ h1 }6 f
% N; g! }) b1 i1 o1 {1 N+ j! u# 根据自己存放数据集的路径修改voc_dir
voc_dir = r"[local]\VOCdevkit\VOC2012"
train_features, train_labels = read_voc_images(voc_dir, max_num=10)
3 N# [) g* |" ]6 s1 |$ e8 Xn = 5 # 展示几张图像
imgs = train_features[0:n] + train_labels[0:n] # PIL image
  @* ^8 O% j3 ^7 ashow_images(imgs, 2, n)
* n* o8 W% Q7 R% K# x5 E0 e


, o, T7 v1 G% s* T( @+ ?* Z列出标签中每个RGB颜色的值及其标注的类别。
# 标签中每个RGB颜色的值
VOC_COLORMAP = [[0, 0, 0], [128, 0, 0], [0, 128, 0], [128, 128, 0],
! V: F8 X. j. p  h: U6 W9 n8 O                [0, 0, 128], [128, 0, 128], [0, 128, 128], [128, 128, 128],
" b+ Q8 c8 W/ \4 R4 F                [64, 0, 0], [192, 0, 0], [64, 128, 0], [192, 128, 0],
                [64, 0, 128], [192, 0, 128], [64, 128, 128], [192, 128, 128],
6 e' S! i8 f9 f: e# M$ a                [0, 64, 0], [128, 64, 0], [0, 192, 0], [128, 192, 0],
, l8 r+ P. j+ e( J; R3 G5 r                [0, 64, 128]]
7 o" {% C" X- V/ \) u1 l# 标签其标注的类别
# _" ?# x  A6 _, \VOC_CLASSES = ['background', 'aeroplane', 'bicycle', 'bird', 'boat',
9 L1 z4 d* F; u               'bottle', 'bus', 'car', 'cat', 'chair', 'cow',
* {9 j" o/ M9 l               'diningtable', 'dog', 'horse', 'motorbike', 'person',
               'potted plant', 'sheep', 'sofa', 'train', 'tv/monitor']
; ?& `7 y2 w3 H: a9 v3 e有了上面定义的两个常量以后，我们可以很容易地查找标签中每个像素的类别索引，voc_label_indices是根据colormap2label把标签里的 rgb 颜色对应上面的VOC_COLORMAP中的下标给取出来，当作 label 。
, u5 Z5 |* F2 s- f; ^( g
有了上面定义的两个常量以后，我们可以很容易地查找标签中每个像素的类别索引，voc_label_indices是根据colormap2label把标签里的 rgb 颜色对应上面的VOC_COLORMAP中的下标给取出来，当作 label 。
  D0 r# n+ T8 q9 Kcolormap2label = torch.zeros(256**3, dtype=torch.uint8) # torch.Size([16777216])
, q9 I( {# G! rfor i, colormap in enumerate(VOC_COLORMAP):
# K& u0 _5 S: P7 ~: \    # 每个通道的进制是256，这样可以保证每个 rgb 对应一个下标 i
    colormap2label[(colormap[0] * 256 + colormap[1]) * 256 + colormap[2]] = i

# 构造标签矩阵
6 ]$ G' E$ R1 \& \8 |9 tdef voc_label_indices(colormap, colormap2label):
    colormap = np.array(colormap.convert("RGB")).astype('int32')
/ P- ^+ Q* G0 ^* ?# ~    idx = ((colormap[:, :, 0] * 256 + colormap[:, :, 1]) * 256 + colormap[:, :, 2])
    return colormap2label[idx] # colormap 映射 到colormaplabel中计算的下标

- H  @" m; q/ D7 u! b$ H9 J7 Q可以打印一下结果
' N8 y( Q+ _8 J4 C  {/ A
y = voc_label_indices(train_labels[0], colormap2label)
print(y[100:110, 130:140]) #打印结果是一个int型tensor，tensor中的每个元素i表示该像素的类别是VOC_CLASSES

2.4 预处理数据

# }" H* V' q% y2 E$ h; |6 }在语义分割里，如果使用缩放图像使其符合模型的输入形状的话，需要将预测的像素类别重新映射回原始尺寸的输入图像，这样的映射难以做到精确，尤其是在不同语义的分割区域。所以选择将图像裁剪成固定尺寸而不是缩放。具体来说，我们使用图像增广里的随机裁剪，并对输入图像和标签裁剪相同区域。

1 h% v2 F0 |7 t4 E% ?0 H4 O6 _
def voc_rand_crop(feature, label, height, width):
4 c/ d/ ?% z2 c: {* o7 q% S    """
3 K. B1 s/ E0 p    随机裁剪feature(PIL image) 和 label(PIL image).
" @& a2 k) T- y, Y/ b1 l    为了使裁剪的区域相同，不能直接使用RandomCrop，而要像下面这样做
0 g" ?9 F6 f9 L# Y1 F    Get parameters for ``crop`` for a random crop.
    Args:
        img (PIL Image): Image to be cropped.
        output_size (tuple): Expected output size of the crop.
    Returns:
        tuple: params (i, j, h, w) to be passed to ``crop`` for random crop.
    """
    i,j,h,w = torchvision.transforms.RandomCrop.get_params(feature, output_size=(height, width))
- o& z, p" L* L2 r! S3 @0 ^+ A( L- {    feature = torchvision.transforms.functional.crop(feature, i, j, h, w)
    label = torchvision.transforms.functional.crop(label, i, j, h, w)
    return feature, label
3 X+ \" t  g; P0 b! t
# 显示n张随机裁剪的图像和标签，前面的n是5
imgs = []
% B' @* k( n- S. |2 kfor _ in range(n):
& N4 p3 N( N' o5 X8 q    imgs += voc_rand_crop(train_features[0], train_labels[0], 200, 300)
9 v# H' M& i% A" i- }show_images(imgs[::2] + imgs[1::2], 2, n);
% P; F. K: D' |: s) A

# a* e* U: }8 H1 P8 q. G" W$ V7 @5 p

4 _: L/ J/ t& e. u1 ?% W

3 自定义数据集类
2 Q2 P. d: \( d3 [  x3 h
; W- G" @/ L; J# \! W# a3.1 数据集类
0 u6 T+ M5 J  J% z  x1 [, Y
3 x: c- ^, p( |0 {6 \* wtorch.utils.data.Dataset是表示数据集的抽象类，因此自定义数据集应继承Dataset并覆盖以下方法

__len__ 实现 len(dataset) 返还数据集的尺寸。
__getitem__用来获取一些索引数据，例如 dataset[idx] 中的(idx)。
由于数据集中有些图像的尺寸可能小于随机裁剪所指定的输出尺寸，这些样本需要通过自定义的filter函数所移除。此外，因为之后会用到预训练模型来做特征提取器，所以我们还对输入图像的 RGB 三个通道的值分别做标准化。

) a  I- o4 R, j) m% [' qclass VOCSegDataset(torch.utils.data.Dataset):
0 d4 }* Y& g+ U    def __init__(self, is_train, crop_size, voc_dir, colormap2label, max_num=None):
; ^4 j4 L- R! X. w        """
1 Y0 u4 s, r6 s# x0 ^        crop_size: (h, w)
2 ]( g" B+ e: j9 Z. Z! Y+ Z        """
        # 对输入图像的RGB三个通道的值分别做标准化
" _6 E9 M4 M* w        self.rgb_mean = np.array([0.485, 0.456, 0.406])
        self.rgb_std = np.array([0.229, 0.224, 0.225])
8 C5 b+ p: F9 L* F3 i        self.tsf = torchvision.transforms.Compose([
            torchvision.transforms.ToTensor(),
( x' r, z7 _: F' k4 {3 n# W            torchvision.transforms.Normalize(mean=self.rgb_mean, std=self.rgb_std)])
        self.crop_size = crop_size # (h, w)
$ H* l" t) w, z# w' l4 u  u6 z1 p        features, labels = read_voc_images(root=voc_dir, is_train=is_train,  max_num=max_num)
# 由于数据集中有些图像的尺寸可能小于随机裁剪所指定的输出尺寸，这些样本需要通过自定义的filter函数所移除
        self.features = self.filter(features) # PIL image
        self.labels = self.filter(labels)     # PIL image
% h3 b7 a* a. m1 l; ^7 K$ g        self.colormap2label = colormap2label
4 [3 h) l# O+ Z' }  q        print('read ' + str(len(self.features)) + ' valid examples')
: P8 W  V% V$ N7 W$ x( s* b
3 N" j: ]6 R" |9 l    def filter(self, imgs):
" }% d8 s8 T( W' \% L  {3 C1 i( @% D# E        return [img for img in imgs if (
            img.size[1] >= self.crop_size[0] and img.size[0] >= self.crop_size[1])]
: r' A8 N3 t2 @1 P& Z- w$ N
( F! v- l' |# k/ L. u; W0 F9 i. a    def __getitem__(self, idx):
        feature, label = voc_rand_crop(self.features[idx], self.labels[idx], *self.crop_size)
* ^1 j+ \% u6 s/ E& S7 [+ `                                # float32 tensor           uint8 tensor (b,h,w)
        return (self.tsf(feature), voc_label_indices(label, self.colormap2label))
$ [" S" c  z; t/ a: n
  A- I5 v3 T4 S* }  y    def __len__(self):
# ?$ \; x6 G9 S8 K9 M. i( n+ Z        return len(self.features)
3.2 读取数据集
! R  D$ D$ }$ x, V& p7 A4 C
5 g& f/ l9 e2 [6 q. ^通过自定义的VOCSegDataset类来分别创建训练集和测试集的实例。因为待会用的是全卷积网络，所以随机裁剪的输出图像的形状可以自己指定，这里指定为320×480​ 320\times 480​320×480​。
4 k& ~1 h0 z& B7 \/ w5 {) Y
0 G: }! R1 d7 }, Q" y# ^; abatch_size = 32 # 实际上我的小笔记本不允许我这么做！哭了（大家根据自己电脑内存改吧）
crop_size = (320, 480) # 指定随机裁剪的输出图像的形状为(320,480)
# S( u. [+ S5 ~2 P6 ]6 omax_num = 20000 # 最多从本地读多少张图片，我指定的这个尺寸过滤完不合适的图像之后也就只有1175张~
# z( d8 G  q7 t" R
# 创建训练集和测试集的实例
voc_train = VOCSegDataset(True, crop_size, voc_dir, colormap2label, max_num)
) J8 m* d; b$ [/ g8 W# Nvoc_test = VOCSegDataset(False, crop_size, voc_dir, colormap2label, max_num)

7 v# J) G" B" {# 设批量大小为32，分别定义【训练集】和【测试集】的数据迭代器
7 G. V3 V! i% L& Nnum_workers = 0 if sys.platform.startswith('win32') else 4
# s% Y! ~" W' e# V' n: I# {# Etrain_iter = torch.utils.data.DataLoader(voc_train, batch_size, shuffle=True,
! g' B: H$ P7 u! z, z                              drop_last=True, num_workers=num_workers)
test_iter = torch.utils.data.DataLoader(voc_test, batch_size, drop_last=True,
                             num_workers=num_workers)
, E& D: @% A7 l' E, w+ B
# 方便封装，把训练集和验证集保存在dict里
dataloaders = {'train':train_iter, 'val':test_iter}
dataset_sizes = {'train':len(voc_train), 'val':len(voc_test)}

" N% `) K' N2 m& w6 X8 W. M. w4 构造模型4.1 预训练模型

下⾯我们使⽤⼀个基于 ImageNet 数据集预训练的 ResNet-18 模型来抽取图像特征。

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
2 _" j+ P" u6 j0 _
num_classes = 21 # 21分类，1个背景，20个物体
+ a" A' s& S0 v  r; V5 \& H1 s8 Dmodel_ft = resnet18(pretrained=True) # 设置True，表明要加载使用训练好的参数
5 z* ?! Q/ P; ~+ M6 ~9 ]0 ]3 n
# 特征提取器
for param in model_ft.parameters():
    param.requires_grad = False
4.2 修改成FCN
! X/ F. b- T# L' _' S2 {2 i
全卷积⽹络（顾名思义全部都是卷积层）先使⽤卷积神经⽹络抽取图像特征，然后通过 1×1​ 1\times 1​1×1​ 卷积层将通道数变换为类别个数，最后通过转置卷积层将特征图的⾼和宽变换为输⼊图像的尺⼨。模型输出与输⼊图像的⾼和宽相同，并在空间位置上⼀⼀对应：
最终输出的通道包含了该空间位置像素的类别预测。
' f6 S/ F: e/ g' [
. @- _) \; \* F& \  m2 |; @, R对于转置卷积层，如果步幅为 S​ S​S​、填充为 S/2​ S/2​S/2​ （假设为整数）、卷积核的⾼和宽为 2S​ 2S​2S​，转置卷积核将输⼊的⾼和宽分别放⼤ S​ S​S​ 倍。
' i$ c  u  r$ D* R: s0 V# g# A
可以先打印model_ft，可见 ResNet-18 的最后两层分别是全局最⼤池化层GlobalAvgPool2D 和 全连接层。全卷积⽹络不需要使⽤这些层。通过测试，当输入图像的 size 是(batch,3,320,480) (batch,3,320,480)(batch,3,320,480) 时，通过除最后两层的预训练网络后输出的大小是 (batch,512,10,15) (batch,512,10,15)(batch,512,10,15)，也就是 feature featurefeature 的宽高比输入缩小了 32 3232 倍，只需要用转置卷积层将其放大 32 3232 倍即可。

9 V0 z+ A" {- K4 K+ U4 Z4 d: Ymodel_ft = nn.Sequential(*list(model_ft.children())[:-2], # 去掉最后两层
              nn.Conv2d(512,num_classes,kernel_size=1), # 用大小为1的卷积层改变输出通道为num_class
4 n+ n7 F* ^1 Q9 v, A$ H( T& X              nn.ConvTranspose2d(num_classes,num_classes, kernel_size=64, padding=16, stride=32)).to(device) # 转置卷积层使图像变为输入图像的大小

- R. L$ p0 m8 p5 r$ f/ M# 对model_ft做一个测试
x = torch.rand((2,3,320,480), device=device) # 构造随机的输入数据
# |: [8 E/ K) T: h/ Hprint(net(x).shape) # 输出依然是 torch.Size([2, 21, 320, 480])
! [2 f- R# E1 \8 s! s( B+ T, u
# 打印第一个小批量的类型和形状。不同于图像分类和目标识别，这里的标签是一个三维数组
# for X, Y in train_iter:
! z, U" ~- L! E#     print(X.dtype, X.shape)
1 F0 R8 G; X6 k! ^: `/ T* V5 c#     print(Y.dtype, Y.shape)
#     break
& n+ m' O0 ^) n  \: I/ r$ O2 e
' a& \. S8 ^7 h2 E7 F6 Q4 a
4.3 初始化转置卷积层

  i$ e  R. F* q. F( ?1 V在图像处理中，我们有时需要将图像放⼤，即上采样（upsample）。上采样的⽅法有很多，常⽤的有双线性插值。简单来说，为了得到输出图像
在坐标 (x,y) (x, y)(x,y)上的像素，先将该坐标映射到输⼊图像的坐标 (x',y') (x′, y′ )(x′,y′)。例如，根据输⼊与输出的尺⼨之⽐来映射。映射后的 x' x′x′ 和 y' y′y′ 通常是实数。然后，在输⼊图像上找到与坐标 (x',y') (x′, y′ )(x′,y′)最近的 4 44 个像素。最后，输出图像在坐标 (x,y) (x, y)(x,y)上的像素依据输⼊图像上这4 44个像素及其与 (x',y') (x′, y′ )(x′,y′)的相对距离来计算。双线性插值的上采样可以通过由以下bilinear_kernel函数构造的卷积核的转置卷积层来实现。
7 E6 Z6 f* }  E6 U& b  P# T$ b: D) ?
* [- Q/ f: ~; g5 B0 @& R& r
# 双线性插值的上采样，用来初始化转置卷积层的卷积核
def bilinear_kernel(in_channels, out_channels, kernel_size):
    factor = (kernel_size+1)//2
    if kernel_size%2 == 1:
        center = factor-1
    else:
1 E: {3 y" ~& f- Q, c! v& s        center = factor-0.5
, a9 R. z3 o' c    og = np.ogrid[:kernel_size, :kernel_size]
- h$ c# I  F4 A1 A8 b2 V! L. ]    filt = (1-abs(og[0]-center)/factor) * (1-abs(og[1]-center)/factor)
    weight = np.zeros((in_channels,out_channels, kernel_size,kernel_size), dtype='float32')
    weight[range(in_channels), range(out_channels), :, :] = filt
    weight = torch.Tensor(weight)
    weight.requires_grad = True
; M7 n: Z  j- \    return weight
; o+ A0 [7 w& A8 s0 [

- l$ V6 ^4 C. y4 E6 L在全卷积⽹络中，将转置卷积层初始化为双线性插值的上采样。对于1×1 1\times 11×1卷积层，采⽤Xavier XavierXavier随机初始化。

nn.init.xavier_normal_(model_ft[-2].weight.data, gain=1)
model_ft[-1].weight.data = bilinear_kernel(num_classes, num_classes, 64).to(device)



5 训练模型

现在可以开始训练模型了。这⾥的损失函数和准确率计算与图像分类中的并没有本质上的不同。有一个 blog 我认为说的很详细，图也画得很好：https://blog.csdn.net/Fcc_bd_stars/article/details/105158215

def train_model(model:nn.Module, criterion, optimizer, scheduler, num_epochs=20):
    since = time.time()
& F, D( w6 {0 G* Z. }    best_model_wts = copy.deepcopy(model.state_dict())
5 W. |$ }! ]( e; g( L" n    best_acc = 0.0
& Z3 [- h- P& S% S$ k    # 每个epoch都有一个训练和验证阶段
    for epoch in range(num_epochs):
        print('Epoch {}/{}'.format(epoch, num_epochs-1))
" z1 w# _0 ~( K+ K        print('-'*10)
5 [- v7 i. E  ?6 H6 h        for phase in ['train', 'val']:
( t  P0 B" W& ~            if phase == 'train':
                scheduler.step()
) N9 K7 J0 y! q* d                model.train()
            else:
  v# ~: k  X' B                model.eval()
5 ^# r5 y) N% l: m1 _2 ]6 U: }            runing_loss = 0.0
  q  X# M: T) p2 ^+ p" P2 m            runing_corrects = 0.0
            # 迭代一个epoch
            for inputs, labels in dataloaders[phase]:
# }/ J  Z9 @' o: y' o8 I' Q                inputs, labels = inputs.to(device), labels.to(device)
                optimizer.zero_grad() # 零参数梯度
                                # 前向，只在训练时跟踪参数
                with torch.set_grad_enabled(phase=='train'):
2 W9 Z- N6 F! h# Q( P                    logits = model(inputs)  # [5, 21, 320, 480]
. T4 Q2 H4 a$ |6 g7 P                    loss = criteon(logits, labels.long())
, W3 R- x% Y6 ~                    # 后向，只在训练阶段进行优化
+ _% {4 Z- a( l3 A                    if phase=='train':
; _7 P: x" r  B2 q5 s1 a9 W2 S                        loss.backward()
1 h; v( N  x, ~8 Q                        optimizer.step()
+ c* H  Y5 Q9 u- u                                # 统计loss和correct
; I5 l( }+ I* C* L- e! Q                runing_loss += loss.item()*inputs.size(0)
                runing_corrects += torch.sum((torch.argmax(logits.data,1))==labels.data)/(480*320)
: j# j! a- p' w! D4 w9 a& y! P; N; f
            epoch_loss = runing_loss / dataset_sizes[phase]
/ N: V5 K5 S- U- I1 r  E            epoch_acc = runing_corrects.double() / dataset_sizes[phase]
            print('{} Loss: {:.4f} Acc: {:.4f}'.format(phase, epoch_loss, epoch_acc))
                        # 深度复制model参数
1 R9 l0 S& U/ X0 ^# m- V            if phase=='val' and epoch_acc>best_acc:
6 z7 A) o0 S6 P6 g                best_acc = epoch_acc
' r# Z/ R4 O' j0 ~                best_model_wts = copy.deepcopy(model.state_dict())
        print()
3 z4 L( i6 f) X% U# c8 w    time_elapsed = time.time() - since;
. i/ q/ m. [6 o! I# Y; T    print('Training complete in {:.0f}m {:.0f}s'.format(time_elapsed//60, time_elapsed%60))
) ~8 j* Q0 I$ _! D+ W; s7 Q6 @    # 加载最佳模型权重
    model.load_state_dict(best_model_wts)
; Z" G7 E) f7 _9 ]5 L% e    return model
' v  c6 E2 @* ^
5 m" {1 A  t0 t2 b* o$ Y8 P  P下面定义train_model要用到的参数，开始训练

! n- p1 f  c5 _5 I( Q# ]" `% U" Xepochs = 5 # 训练5个epoch
criteon = nn.CrossEntropyLoss()
: w$ D) L  b. C4 t5 A8 @3 Q; S7 uoptimizer = optim.SGD(model_ft.parameters(), lr=0.001, weight_decay=1e-4, momentum=0.9)
# 每3个epochs衰减LR通过设置gamma=0.1
exp_lr_scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=3, gamma=0.1)

# 开始训练
model_ft = train_model(model_ft, criteon, optimizer, exp_lr_scheduler, num_epochs=epochs)

6 测试模型

为了可视化每个像素的预测类别，我们将预测类别映射回它们在数据集中的标注颜⾊。

def label2image(pred):
    # pred: [320,480]
( b! M6 `1 p6 K: t7 N    colormap = torch.tensor(VOC_COLORMAP,device=device,dtype=int)
    x = pred.long()
* g( E+ M. x2 ~. G6 T! U# p    return (colormap[x,:]).data.cpu().numpy()
9 B& p, X4 L; G* k
3 A, ~1 o' R; L7 H5 |

下面这里提供了两种测试形式

6.1 通用型

其实如果要用于测试其它数据集，也是要改动一下的 : ) 😃

mean=torch.tensor([0.485, 0.456, 0.406]).reshape(3,1,1).to(device)
std=torch.tensor([0.229, 0.224, 0.225]).reshape(3,1,1).to(device)
def visualize_model(model:nn.Module, num_images=4):
    was_training = model.training
    model.eval()
    images_so_far = 0
    n, imgs = num_images, []
& M+ E9 t/ N* Y5 S    with torch.no_grad():
' V. D: I3 l' G        for i, (inputs, labels) in enumerate(dataloaders['val']):
            inputs, labels = inputs.to(device), labels.to(device) # [b,3,320,480]
            outputs = model(inputs)
$ V- O0 u1 y. P; G7 C) S            pred = torch.argmax(outputs, dim=1) # [b,320,480]
            inputs_nd = (inputs*std+mean).permute(0,2,3,1)*255 # 记得要变回去哦
6 p5 l6 r( c, f& B
            for j in range(num_images):
                images_so_far += 1
                pred1 = label2image(pred[j]) # numpy.ndarray (320, 480, 3)
                imgs += [inputs_nd[j].data.int().cpu().numpy(), pred1, label2image(labels[j])]
                if images_so_far == num_images:
                    model.train(mode=was_training)
                    # 我已经固定了每次只显示4张图了，大家可以自己修改
                    show_images(imgs[::3] + imgs[1::3] + imgs[2::3], 3, n)
                    return model.train(mode=was_training)
! }" ^% d, p7 R; }
% i( g4 X( k6 B# 开始验证
visualize_model(model_ft)
7 n. ^' l3 e8 V( @6.2 不通用

在预测时，我们需要将输⼊图像在各个通道做标准化，并转成卷积神经⽹络所需要的四维输⼊格式。

# 预测前将图像标准化，并转换成(b,c,h,w)的tensor
& R8 y+ w! N" D& Xdef predict(img, model):
    tsf = transforms.Compose([
3 }- e- `& z! A6 Z. T            transforms.ToTensor(), # 好像会自动转换channel
3 M0 ]  B7 C3 J            transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])])
    x = tsf(img).unsqueeze(0).to(device) # (3,320,480) -> (1,3,320,480)
' Q$ x& G, U- P$ }( y) ~$ R* Y& {    pred = torch.argmax(model(x), dim=1) # 每个通道选择概率最大的那个像素点 -> (1,320,480)
% w( s5 r! f; l' o1 [5 h    return pred.reshape(pred.shape[1],pred.shape[2]) # reshape成(320,480)

% E, A& ?; Z- M1 n7 e: Ddef evaluate(model:nn.Module):
, F% T& r1 Q- `    model.eval()
    test_images, test_labels = read_voc_images(voc_dir, is_train=False, max_num=10)
' w, z" o* @9 ^% A  ~3 t8 x/ |    n, imgs = 4, []
    for i in range(n):
        xi, yi = voc_rand_crop(test_images, test_labels, 320, 480) # Image
        pred = label2image(predict(xi, model))
        imgs += [xi, pred, yi]
* }% Q) A/ O% v, v; P% n& t: f+ W1 f9 D5 y    show_images(imgs[::3] + imgs[1::3] + imgs[2::3], 3, n)
; P3 f9 T9 t+ d
# 开始测试
evaluate(model_ft)

7 结语

我只训练了3个epoch，下面是训练输出

% l5 O6 n; [/ E. A$ p* T0 W+ b0 qEpoch 0/2
----------
train Loss: 1.7844 Acc: 0.5835
& R) E4 p4 ~" F$ ^3 W$ b3 U1 Dval Loss: 1.1669 Acc: 0.6456

" M1 \3 g+ M, c4 d. `* l3 s* F7 `' cEpoch 1/2
----------
train Loss: 1.1288 Acc: 0.6535
val Loss: 0.9012 Acc: 0.6929
: G0 ]# s& P- f( a% D3 _2 }1 |
Epoch 2/2
+ k  V- z. P1 _, D9 P----------
8 P% n/ n$ ?* c7 q8 x/ strain Loss: 0.9578 Acc: 0.6706
4 _: y4 N: ?3 S0 [val Loss: 0.8088 Acc: 0.6948
: Y5 U# n: J5 ]
Training complete in 6m 37s
1 D3 P6 S* Y( v7 d! f+ ^# f! R) M6 c



当 epochs = 5 时，训练集的精度在 89 8989% 左右，测试集的精度可以达到 86​ 86​86​ %。
( e; l! k' G* `  e# d
  m; H' ?2 k  h* t6 c" p对于这个模型用 ResNet-50 作特征提取器会有更好的效果，不过训练的时间也会更长。还有超参数lr, weight_decay, momentum, step_size, gamma 以及1×1 1×11×1卷积层和转置卷积层的初始化方式也可以继续调。


语义分割还有很多可用的模型，本文用的是 FCN，在其它一些模型上会有更好的表现：
0 ^+ a. t) s: f7 T6 Z0 k8 z
Deeplab V3+ 具有可分离卷积的编码器/解码器，用于语义图像分割[论文]
4 }  W5 @1 j1 K' y6 [+ rGCN 通过全局卷积网络改进语义分割[论文]
UperNet 统一感知解析
ENet 用于实时语义分割的深度神经网络体系结构[论文]
U-Net 用于生物医学图像分割的卷积网络
+ |4 w# t( L8 l, w0 kSegNet 用于图像分段的深度卷积编码器-解码器架构。
  \+ _" ]7 {# D- e还有（DUC，HDC）、PSPNet等。
$ Y' F1 F, g0 N* h% ?" j
' q* v! q* ?# e: b常用的语义分割数据集也有很多：Pascal VOC、CityScapes、ADE20K、COCO Stuff等。

对于损失函数，除了交叉熵误差，也可以用这些：

) \; Y4 F5 L1 h! B* [' ~Dice-Loss 可以测试两个样本之间的重叠度量，可以更好地反映训练目标，但该损失函数具有很强的非凸性，很难优化。
( D& p6 p6 Y5 f- v3 T& v& O% ^CE Dice loss Dice 损失与 CE 的总和，CE 提供了平滑的优化，而 Dice 损失则很好地表明了分割结果的质量。
Focal Loss CE 的另一种版本，用于避免类别不平衡而降低了置信度的情况。
Lovasz Softmax 查看论文：Lovasz - softmax损失。
; t) ?9 e# N% n


6 A6 T( g; F8 `5 l9 m  |. Y- m) |
) S& b. D( |, H% q$ S) L$ V
# f4 x# n9 ^, c& a, S  C, ~————————————————
版权声明：本文为CSDN博主「小红不吃糖」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
, E& F# V" o( {" x原文链接：https://blog.csdn.net/qq_43280818/article/details/105916507



! M4 m. I3 f/ I5 N- w, x& y