0519-85602926
语义分割技巧
选择模型
使用小尺寸图片选择模型，因为小尺寸图片可以有大的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)
