Endereço Git: https://github.com/Tramac/awesome-semantic-segmentation-pytorch
incluir:
FCN
ENet
PSPNet
ICNet
DeepLabv3
DeepLabv3+
DenseASPP
EncNet
BiSeNet
PSANet
DANet
OCNet
CGNet
ESPNetv2
CCNet
DUNet(DUpsampling)
FastFCN(JPU)
LEDNet
Fast-SCNN
LightSeg
DFANetQuase inclui o código-fonte principal da segmentação semântica. Depurar um não é ruim
Veja o que você precisa escolher.
Vários pontos-chave da teoria ICNET:
1. Ideia central:
Divida a imagem em três camadas: alta, média e baixa. A razão fundamental para a melhoria significativa de desempenho é permitir que imagens de baixa e baixa resolução passem pela rede de segmentação semântica para produzir resultados de segmentação aproximados; em seguida, a unidade híbrida de cascata de recursos (orientação de rótulo em cascata) e a estratégia de orientação de rótulo em cascata (cascata A integração de recursos de alta velocidade e alta resolução otimiza gradualmente os resultados de segmentação aproximados gerados anteriormente.
2. Diagrama de rede:
De baixo para cima, de alta para baixa resolução. Os resultados de baixa resolução são combinados com os resultados de resolução média para gerar quadrados azuis, e os resultados de resolução média e quadrados azuis são fundidos com os mapas de recursos de alta resolução por meio do método CFF. Finalmente, o resultado é amostrado para obter a saída final.
3.CFF ：
Cascade Feature Fusion,
Primeiro, execute a interpolação bilinear em F1 e faça upsample em 2 vezes para torná-lo do mesmo tamanho que F2
Em seguida, use C3X3, uma convolução de buraco com uma taxa de amostragem de 2 para aumentar a amostragem F1. O tamanho da imagem gerada é o mesmo que F2. A convolução de buraco combina as informações de recursos dos pixels vizinhos originais e o campo receptivo é o mesmo que F2. A quantidade de cálculo é menor que a deconvolução. Marcado como A
Use a convolução CX1X1 para o recurso F2 para torná-lo o mesmo que o canal F1 (equivalente à dimensão ascendente). Denotado como B
Use a camada BN para padronizar as duas camadas de feições processadas AB .
Adicione os dois e use a ativação relu para obter o recurso de fusão F2 'que é do mesmo tamanho que F2.
4. Orientação da etiqueta da cascata
A parte do círculo vermelho 4, que é usado durante o treinamento, corresponde à parte x_24_cls do código abaixo. Existem três dessas posições. Para ser franco, é o lugar para cascatear com antecedência, as informações de anotação do mapa de anotação em diferentes resoluções
x_cff_24, x_24_cls = self.cff_24(x_sub4, x_sub2)
5. Desempenho:
Desejo principalmente usar segmentação semântica em tempo real. Basta escolher um teste ICNET. O tempo de previsão da GPU de previsão de imagem de 2048 * 1024 é de cerca de 190 ms. Se você alterar o tamanho da imagem, os parâmetros de rede podem ser compactados um pouco mais rápido
6. Código:
Nota 1: A rede de backbone que selecionei para teste é resnet50, e você precisa olhar as seguintes notas para esta rede. Pode ficar claro à primeira vista O papel da rede de backbone é extrair recursos. Outras redes de backbone são semelhantes, principalmente para ver o fluxo de implementação de ICNET.
Nota 2: há um local pouco claro na parte CascadeFeatureFusion do código. Olha o papel
Deve corresponder à fig.3. Consistente com o meu entendimento, deve ser diretamente após o upsampling da imagem baixa, tomando diretamente o upsampling como entrada e o número de categorias como o canal de saída para a subconvolução. Então fiz algumas mudanças, ainda não terminei o treinamento, então vamos esperar o treinamento para ver o efeito.
class CascadeFeatureFusion(nn.Module):
"""CFF Unit"""
self.conv_low_cls = nn.Conv2d(low_channels, nclass, 1, bias=False)
x_low = F.interpolate(x_low, size=x_high.size()[2:], mode='bilinear', align_corners=True)
x_low1 = x_low
x_low_cls = self.conv_low_cls(x_low1)
return x, x_low_clsCódigo completo:
"""Image Cascade Network"""
import torch
import torch.nn as nn
import torch.nn.functional as F
from .segbase import SegBaseModel
__all__ = ['ICNet', 'get_icnet', 'get_icnet_resnet50_citys',
'get_icnet_resnet101_citys', 'get_icnet_resnet152_citys']
class ICNet(SegBaseModel):
"""Image Cascade Network"""
def __init__(self, nclass, backbone='resnet50', aux=False, jpu=False, pretrained_base=False, **kwargs):
super(ICNet, self).__init__(nclass, aux, backbone, pretrained_base=pretrained_base, **kwargs)
self.conv_sub1 = nn.Sequential(
_ConvBNReLU(3, 32, 3, 2, **kwargs),#ksize 3 stride 2
_ConvBNReLU(32, 32, 3, 2, **kwargs),
_ConvBNReLU(32, 64, 3, 2, **kwargs)
)
self.ppm = PyramidPoolingModule()
self.head = _ICHead(nclass, **kwargs)
self.__setattr__('exclusive', ['conv_sub1', 'head'])
def forward(self, x):
# sub 1 原图做普通卷积 BN RL 对应fig.2的 红圈1 例如 x shape [20, 3, 480, 480]
x_sub1 = self.conv_sub1(x) #图像变为原图 1/8 x_sub1 shape [20, 64, 60, 60]
# sub 2 x_sub2是将原图缩放到 1/2 x_sub2 shape [20, 3, 240, 240]
x_sub2 = F.interpolate(x, scale_factor=0.5, mode='bilinear', align_corners=True)
#过主干网络 例如resnet之类。 对x_sub2做特征提取 对应fig.2的 红圈2 看取值是取的layer2 大小变为 1 / 16
# x_sub2 shape [20, 512, 30, 30]
_, x_sub2, _, _ = self.base_forward(x_sub2)
# sub 4 x_sub4 原图缩放到 1 / 4 x_sub4 shape [20, 3, 120, 120]
x_sub4 = F.interpolate(x, scale_factor=0.25, mode='bilinear', align_corners=True)#双线性插值将为 原图 1/4
#过主干网络 对x_sub4做特征提取 对应fig.2 的红圈3 看取值是取的layer4 1/32
# x_sub4 shape [20, 2048, 15, 15]
_, _, _, x_sub4 = self.base_forward(x_sub4)
# add PyramidPoolingModule
# x_sub4作为输出 就是加上全局池化后的信息了 x_sub4 shape [20, 2048, 15, 15]
x_sub4 = self.ppm(x_sub4)
#上采样部分 x_sub1 [20, 64, 60, 60] x_sub2 [20, 512, 30, 30] x_sub4 [20, 2048, 15, 15]
outputs = self.head(x_sub1, x_sub2, x_sub4)
return tuple(outputs)
#类似PPM结构
class PyramidPoolingModule(nn.Module):
def __init__(self, pyramids=[1,2,3,6]):
super(PyramidPoolingModule, self).__init__()
self.pyramids = pyramids
def forward(self, input):
feat = input
height, width = input.shape[2:]
for bin_size in self.pyramids:
#池化 x的尺寸分别为 1*1 2*2 3*3 6*6 通道数不变 与输入特征图一致
#这么做点目的是保留全局信息，防止大块的目标中出现空洞，大目标检测不好 例如 马路 例如 天空
x = F.adaptive_avg_pool2d(input, output_size=bin_size)
# 将池化结果插值回原图大小
x = F.interpolate(x, size=(height, width), mode='bilinear', align_corners=True)
# 输入特征图与插值图像叠加
feat = feat + x
return feat
class _ICHead(nn.Module):
def __init__(self, nclass, norm_layer=nn.BatchNorm2d, **kwargs):
super(_ICHead, self).__init__()
self.cff_12 = CascadeFeatureFusion(512, 64, 128, nclass, norm_layer, **kwargs)
#self.cff_12 = CascadeFeatureFusion(128, 64, 128, nclass, norm_layer, **kwargs)
self.cff_24 = CascadeFeatureFusion(2048, 512, 128, nclass, norm_layer, **kwargs)
self.conv_cls = nn.Conv2d(128, nclass, 1, bias=False)
def forward(self, x_sub1, x_sub2, x_sub4):
outputs = list()
# cff_24是论文中的CFF部分实现代码 这个是做最小和次小的特征融合呢
# x_cff_24 shape [20, 128, 30, 30] x_24_cls shape [20, 19, 30, 30]
x_cff_24, x_24_cls = self.cff_24(x_sub4, x_sub2)
outputs.append(x_24_cls)
#x_cff_12, x_12_cls = self.cff_12(x_sub2, x_sub1)
# 论文中的CFF部分实现代码 这个是做次小和最大的特征融合呢
# # x_cff_12 shape [20, 128, 60, 60] x_12_cls shape [20, 19, 60, 60]
x_cff_12, x_12_cls = self.cff_12(x_cff_24, x_sub1)
outputs.append(x_12_cls)
# x_cff_12 上采样一次 up_x2 shape [20, 128, 120, 120]
up_x2 = F.interpolate(x_cff_12, scale_factor=2, mode='bilinear', align_corners=True)
# 做一次loss函数需要的卷积 up_x2 shape [20, 19, 120, 120]
up_x2 = self.conv_cls(up_x2)
outputs.append(up_x2)
# up_x2 再做一次上采样 直接放大到原图大小
# x_cff_12 上采样一次 up_x2 shape [20, 19, 480, 480]
up_x8 = F.interpolate(up_x2, scale_factor=4, mode='bilinear', align_corners=True)
outputs.append(up_x8)
# 1 -> 1/4 -> 1/8 -> 1/16 将list反序
outputs.reverse()
# outputs 依次存放{[20, 19, 480, 480], [20, 19, 120, 120], [20, 19, 60, 60], [20, 19, 30, 30]}
return outputs
class _ConvBNReLU(nn.Module):
def __init__(self, in_channels, out_channels, kernel_size=3, stride=1, padding=1, dilation=1,
groups=1, norm_layer=nn.BatchNorm2d, bias=False, **kwargs):
super(_ConvBNReLU, self).__init__()
self.conv = nn.Conv2d(in_channels, out_channels, kernel_size, stride, padding, dilation, groups, bias)
self.bn = norm_layer(out_channels)
self.relu = nn.ReLU(True)
def forward(self, x):
x = self.conv(x)
x = self.bn(x)
x = self.relu(x)
return x
class CascadeFeatureFusion(nn.Module):
"""CFF Unit"""
def __init__(self, low_channels, high_channels, out_channels, nclass, norm_layer=nn.BatchNorm2d, **kwargs):
super(CascadeFeatureFusion, self).__init__()
self.conv_low = nn.Sequential(
nn.Conv2d(low_channels, out_channels, 3, padding=2, dilation=2, bias=False),
norm_layer(out_channels)
)
self.conv_high = nn.Sequential(
nn.Conv2d(high_channels, out_channels, 1, bias=False),
norm_layer(out_channels)
)
self.conv_low_cls = nn.Conv2d(out_channels, nclass, 1, bias=False)
# 对应论文fig.3
def forward(self, x_low, x_high):
# 先将 x_low特征图做双线性插值上采样 对应fig.3 图中框1
# 例如对于cff_24 x_low 输入为[20, 2048, 15, 15] 输出为[20, 2048, 30, 30]
x_low = F.interpolate(x_low, size=x_high.size()[2:], mode='bilinear', align_corners=True)
# 再对x_low特征图做空洞卷积 结果通道为128 对应fig.3 图中框2
# 例如对于cff_24 x_low 输入为[20, 2048, 30, 30] 输出为[20, 128, 30, 30]
x_low = self.conv_low(x_low)
# 对x_high特征图做 1*1的卷积 结果通道为128 对应fig.3 图中框3
# 例如对于cff_24 x_high 输入为[20, 512, 30, 30] 输出为[20, 128, 30, 30]
x_high = self.conv_high(x_high)
# 求和做relu 作为输出数据之一 对应fig.3 图中框4
x = x_low + x_high
x = F.relu(x, inplace=True)
# 对空洞x_low特征图做直接做卷积并做BatchNorm2d 结果通道数为类别维度 用来算损失函数的 对应fig.3 图中 框5
# 代码与论文图对应不上了 按理应该是双线性插值的结果作为输入才对
# 例如对于cff_24 x_low 输入为[20, 128, 30, 30] 输出为[20, 19, 30, 30]
# 按论文画的图 应该为 x_low 输入为[20, 2048, 30, 30] 输出为[20, 19, 30, 30]才对 改了训练一次看看效果 这块是
# 这个代码我没看懂的地方之一
x_low_cls = self.conv_low_cls(x_low)
return x, x_low_cls
def get_icnet(dataset='citys', backbone='resnet50', pretrained=False, root='~/.torch/models',
pretrained_base=False, **kwargs):
acronyms = {
'pascal_voc': 'pascal_voc',
'pascal_aug': 'pascal_aug',
'ade20k': 'ade',
'coco': 'coco',
'citys': 'citys',
}
from ..data.dataloader import datasets
model = ICNet(datasets[dataset].NUM_CLASS, backbone=backbone, pretrained_base=pretrained_base, **kwargs)
path = '/home/yuany/awesome-semantic-segmentation-pytorch-master/scripts/models/best.pth'
pretrained = True
if pretrained:
from .model_store import get_model_file
#device = torch.device(kwargs['local_rank'])
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
#model.load_state_dict(torch.load(get_model_file('icnet_%s_%s' % (backbone, acronyms[dataset]), root=root),
# map_location=device))
model.load_state_dict(torch.load(path,
map_location=device))
return model
def get_icnet_resnet50_citys(**kwargs):
return get_icnet('citys', 'resnet50', **kwargs)
def get_icnet_resnet101_citys(**kwargs):
return get_icnet('citys', 'resnet101', **kwargs)
def get_icnet_resnet152_citys(**kwargs):
return get_icnet('citys', 'resnet152', **kwargs)
if __name__ == '__main__':
img = torch.randn(1, 3, 256, 256)
model = get_icnet_resnet50_citys()
outputs = model(img)
Grave um novo e mais rápido. Primeiro salve a imagem e siga o código para ver o papel
Etapas completas: Eu quero fazer segmentação semântica principalmente na estrada, e o conjunto de dados selecionado são paisagens urbanas.
1. Prepare as paisagens urbanas do conjunto de dados. Basta descompactar o pacote compactado que precisa ser descompactado
2. Prepare o código, o link no github https://github.com/Tramac/awesome-semantic-segmentation-pytorch
3. Após descompactar, entre na pasta de scripts, dentro, há um arquivo de trem. A pasta principal armazena o modelo. Todos os tipos de modelos de segmentação semântica estão nele, e os itens de seleção podem ser vistos na lista de parâmetros do trem.
4. Modifique o caminho em cityscapes.py: coloque diretamente as paisagens urbanas do conjunto de dados sob o caminho dos conjuntos de dados ../ datasets / cityscapes
5. Também alterei o arquivo citys em conjuntos de dados e coloquei o caminho. Por exemplo, meu caminho é; / home / yuany / awesome-semantic-segmentation-pytorch-master / datasets / cityscapes. Não prestei atenção em qual dos esses dois caminhos funcionam.
6. Em seguida, insira o comando train. Por exemplo, meu modelo escolhe a rede de backbone icnet para escolher resnet50, o conjunto de dados escolhe as cidades, a taxa de aprendizado inicial é 0,01, o número de iterações é 30000, então o comando é o seguinte:
python train.py --model icnet --backbone resnet50 --dataset citys --lr 0,01 --epochs 30000
7. O modelo treinado está na pasta de modelos, lá está um dos melhores e um dos mais recentes
8. Use: pressione diretamente demo para usar, defina o caminho da imagem a ser dividida. Apenas dividir, eu defino o caminho para carregar o modelo no icnt, o que é conveniente para a imagem