语义分割技巧

选择模型

使用小尺寸图片选择模型，因为小尺寸图片可以有大的batchsize，使得选择模型过程消耗的时间较少。而大尺寸图片和小尺寸图片训练相同的次数，loss下降的效果几乎相同。小尺寸约256x256.

先确定合适的参数，如学习率、损失函数参数等，参数一样的情况下，训练不同的模型。好的模型前期会下降较快，在小尺寸图片下预训练尤其有效。大尺寸图片训练反而下降不快，看出不下降趋势。

确定模型参数量，对于有些网络，模型参数量太大会导致loss曲线奇异。这一般是由于下采样过多、或attention通道数过多造成的，可以减少模型的参数量，确定合适的模型参数量。

训练模型

使用粗略的损失函数参数训练到底后，可以稍微改变损失函数参数，如改变bwloss和dloss的比例，对于测试集精度可能会有提升。

对于语义分割，focalloss等损失函数属于辅助损失函数，在训练前期起到加速训练的效果，在总损失函数中占比例较低，一般低于0.2的比例，约0.1。diceloss是主要损失函数，对于小前景分割有效果，能直接提升测试集精度，一般最后精训练只用diceloss损失，预训练是focalloss+diceloss。

先使用小尺寸图片(约256x256)预训练，再使用中尺寸图片(约512x512)训练，最后使用大尺寸图片(约1024x1024)精训练。小尺寸图片可以有很大的batchsize，且使用小尺寸图片训练相同的次数收敛更快，估计小尺寸图片收敛速度为中尺寸图片的两倍，大尺寸最慢，大尺寸图片通常batchsize只能取1，无法直接训练，且收敛效果很差，一般用于精训练。（使用不同尺寸图片训练是语义分割任务的优点，像目标检测等任务一般很难这样做，所以输入尺寸只能很小）

模型改进

maxpool可以增强抗噪能力。avgpool或convstridepool可以保留位置信息。

运用跨层连接结构可以不影响模型容量下加速训练。这些结构通常被封装成一个模块。现有大量的模型都是使用了优美的跨层连接结构，训练更容易，如DFANet。

有时瓶颈结构会有更好的效果，猜测可能起到编码器-解码器的作用，起到降噪的作用。如卷积从inch->outch//2;outch//2->outch//2;outch//2->outch这样，其中outch//2可能小于inch，但这样同样有效。

使用大量的分离卷积，模型参数会更小，容量会很大。分离卷积效果比非对称卷积、大卷积要好，非对称卷积一般是用在很小尺寸(约32x32)的经过下采样的图片上，而大卷积一般是用在网络一开始输入的地方。对于unet的结构，网络深度不是很深，因此使用大卷积可能较好。对于fcn式，网络可以堆叠很深，因此使用分离卷积效果较好。

在语义分割中，attention的本质是降噪。让不需要的信息（噪声）置为零，跟relu的作用一样，所以relu在语义分割中尤为有效。使用attention模块能更好的开发一个模型的潜能，能更快收敛，可以用在模块block的后面，跟BN一样。而且用很多也不会有副作用。attention模块主要有通道型和空间型两种，通道型的attention可能会导致loss训练很难（异常），带空间型的可以缓解这种现象，使得训练容易。常用的有SE-module或CBAM模块。

在编码器-解码器的网络中，主要工作都是由编码器做的，编码器参数要很大，相反，解码器要尽量简单，参数量要很小，如通常的无偏置1x1卷积来聚合编码器信息，或使用无参数的双线性插值来放大图片。使用反卷积等技术上采样反而训练更困难，因为其加大了解码器的参数量。

理解

神经网络可以看成是降噪，即不断精炼信息的过程，这意味着需要不断去除冗余信息或噪声。attention、bn、relu等手段一定程度上可以看成是去除噪声的手段，因此bottleneck结构有效，因为它在瓶颈处精炼出有用信息然后处理这些有用信息。3x3卷积的作用是处理信息，那么1x1卷积的作用就是降维精炼信息，因此1x1升维=>3x3处理=>1x1精炼也是一种有效结构。

ottleneck结构本质是降噪。bottleneck结构一般用在网络前面较好，且bottle处卷积参数初始化为正，使用torch.nn.init.uniform_(conv.weight, a=0, b=1)初始化权重和nn.init.zeros_(conv.bias)置偏置为零。原因为在瓶颈处降噪的效果好。

1x1卷积的主要作用是复制图片（增加通道数）给3x3卷积处理，因此增加通道数可以使用1x1卷积而不是3x3卷积，3x3卷积用于处理图片，只需要分离卷积即可。1x1卷积还可以将多张图片（多通道）合并成更少的图片（降通道），即将处理的结果组合起来。

########## DFANET模型定义 ################################################## DFANET模型定义 ####################################

# 纯粹的卷积，如Conv2d

class SeparableConv2d(nn.Module):

    def __init__(self, in_ch, out_ch, stride=1, bottle=False):

        super(SeparableConv2d, self).__init__()

        self.sconv = nn.Sequential(

            nn.Conv2d(in_ch, in_ch, kernel_size=5, padding=2, groups=in_ch, stride=stride),

            Attention(in_ch),

            nn.Conv2d(in_ch, out_ch, kernel_size=1, bias=False),

        )

        if bottle:

            torch.nn.init.uniform_(self.sconv[0].weight, a=0, b=1)

            torch.nn.init.uniform_(self.sconv[2].weight, a=0, b=1)

            nn.init.zeros_(self.sconv[0].bias)

    def forward(self, x):

        return self.sconv(x)

# bottleneck结构

class Block(nn.Module):

    def __init__(self, in_ch, out_ch, stride=1, reduction = 2, bottle=False):

        super(Block, self).__init__()

        self.block = nn.Sequential(

            SeparableConv2d(in_ch, out_ch//reduction, stride=stride),

            nn.BatchNorm2d(out_ch//reduction),

            nn.ReLU(inplace=True),

            SeparableConv2d(out_ch//reduction, out_ch//reduction, bottle=bottle),

            nn.BatchNorm2d(out_ch//reduction),

            nn.ReLU(inplace=True),

            SeparableConv2d(out_ch//reduction, out_ch),

            nn.BatchNorm2d(out_ch),

            nn.ReLU(inplace=True),

        )

        self.proj = nn.Sequential(

            nn.MaxPool2d(stride, stride=stride),

            nn.Conv2d(in_ch, out_ch, 1, bias=False)

        )

    def forward(self, x):

        out = self.block(x)

        identity = self.proj(x)

        return out + identity

class enc(nn.Module):

    def __init__(self, in_ch, out_ch):

        super(enc, self).__init__()

        self.encblocks = nn.Sequential(

            Block(in_ch, out_ch, stride=2),

            Block(out_ch, out_ch),

            Block(out_ch, out_ch),

            nn.BatchNorm2d(out_ch),

            nn.ReLU(inplace=True),

            Attention(out_ch),

        )

    def forward(self, x):

        return self.encblocks(x)

class Attention(nn.Module):

    def __init__(self, channels):

        super(Attention, self).__init__()

        mid_channels = int((channels/2)**0.5) # 1 4 9

        self.avg_pool = nn.AdaptiveAvgPool2d(1)

        self.sharedMLP = nn.Sequential(

            nn.Conv2d(channels, mid_channels, kernel_size=1),

            nn.ReLU(inplace=True),

            nn.Conv2d(mid_channels, mid_channels, kernel_size=1),

            nn.ReLU(inplace=True),

            nn.Conv2d(mid_channels, channels, kernel_size=1),

        )

    def forward(self, x):

        avg = self.sharedMLP(self.avg_pool(x))

        x = x * torch.sigmoid(avg)

        return x

class SubBranch(nn.Module):

    def __init__(self, in_ch, chs, branch_index):

        super(SubBranch,self).__init__()

        self.encs = nn.ModuleList()

        current_ch = in_ch

        for i, ch in enumerate(chs):

            self.encs.append(enc(current_ch, ch))

            if branch_index != 0 and i < len(chs)-2:

                current_ch = chs[i]+chs[i+1]

            else:

                current_ch = ch

        self.branch_index = branch_index

    def forward(self, x0, *args):

        retlist = []

        if self.branch_index == 0:

            for i, enc in enumerate(self.encs):

                retlist.append(enc(x0 if i==0 else retlist[-1]))

        else:

            for i, enc in enumerate(self.encs):

                if i == 0:

                    retlist.append(enc(x0))

                elif i-1 < len(args):

                    retlist.append(enc(torch.cat([retlist[-1], args[i-1]], 1)))

                else:

                    retlist.append(enc(retlist[-1]))

        return retlist

class DFA_Encoder(nn.Module):

    def __init__(self, chs, m): # m个subbranch

        super(DFA_Encoder,self).__init__()

        self.branchs = nn.ModuleList()

        for i in range(m):

            current_inch = chs[0] if i==0 else chs[1]+chs[-1]

            self.branchs.append(SubBranch(current_inch, chs[1:], branch_index=i))

        self.n = len(chs) - 1

        self.m = m 

    def forward(self, x):

        lowfeatures = [None]*self.m

        highfeatures = [None]*self.m

        lastvariables = [None]*(self.n-2)# -2

        lasthighfeaturelist = []

        for i, branch in enumerate(self.branchs):

            tem = torch.cat([x if i==0 else lowfeatures[i-1]]+lasthighfeaturelist, 1)

            lowfeatures[i], *lastvariables, highfeatures[i] = branch(tem, *lastvariables)

            if i != self.m-1:

                lasthighfeaturelist = [F.interpolate(highfeatures[i], size=lowfeatures[i].shape[2:], mode='bilinear', align_corners=True)]

        return lowfeatures, highfeatures

class DFA_Decoder(nn.Module):

    def __init__(self, chs, out_ch, m):

        super(DFA_Decoder,self).__init__()

        self.lowconv = nn.Sequential(

            nn.Conv2d(chs[1], chs[0], kernel_size=1, bias=False),

            nn.BatchNorm2d(chs[0]),

        )

        self.highconv = nn.Sequential(

            nn.Conv2d(chs[-1], chs[0], kernel_size=1, bias=False),

            nn.BatchNorm2d(chs[0]),

        )

        self.shuffleconv = nn.Conv2d(chs[0], out_ch, kernel_size=1, bias=True)

        self.m = m

    def forward(self, lows, highs, proj):# proj没什么用

        for i in range(1, self.m):

            lows[i] = F.interpolate(lows[i], size=lows[i-1].shape[2:], mode='bilinear', align_corners=True)

        for i in range(self.m):

            highs[i] = F.interpolate(highs[i], size=lows[0].shape[2:], mode='bilinear', align_corners=True)

        x_low = self.lowconv(sum(lows))

        x_high = self.highconv(sum(highs))

        x_sf = self.shuffleconv(x_low + x_high)

        return F.interpolate(x_sf, scale_factor=2, mode='bilinear', align_corners=True) # 没有有效的上采样方式

################################# PreModule ########################################

class PreModule(nn.Module):

    def __init__(self, in_ch, out_ch):

        super(PreModule, self).__init__()

        self.conv = nn.Sequential(

            nn.Conv2d(in_ch, out_ch, kernel_size=7, padding=3, bias=False),

            nn.BatchNorm2d(out_ch),

            nn.ReLU(inplace=True),

        )

        self.block = Block(out_ch, out_ch, reduction=8, bottle=True) # 若下采样，val有极限0.53

    def forward(self, x):

        out = self.conv(x)

        return self.block(out)

class DFANet(nn.Module):

    def __init__(self, chs, in_ch, out_ch, m): # 改成chs=[32, 64, 128]

        super(DFANet, self).__init__()

        self.premodule = PreModule(in_ch, chs[0]) 

        self.encoder = DFA_Encoder(chs, m)

        self.decoder = DFA_Decoder(chs, out_ch, m)

    def forward(self, x):

        x = self.premodule(x)

        lows, highs = self.encoder(x)

        y = self.decoder(lows, highs, x)

        return torch.softmax(y, dim=1)