def __init__(self,
out_planes,
criterion,
edge_criterion,
pretrained_model=None,
norm_layer=nn.BatchNorm2d):
super(MCNet, self).__init__()
self.backbone = resnet101(pretrained_model,
norm_layer=norm_layer,
bn_eps=config.bn_eps,
bn_momentum=config.bn_momentum,
deep_stem=False,
stem_width=64)
self.backbone.layer4.apply(partial(self._nostride_dilate,
dilate=4)) # output_stride=16
self.business_layer = []
self.decoder_level1 = Decoder_level1(out_planes, norm_layer=norm_layer)
self.meem = MEEM(norm_layer=norm_layer)
self.cam_1 = CAM1(norm_layer=norm_layer)
self.cmcm = CMCM()
self.decoder_layer_level2 = Decoder_level2(out_planes,
norm_layer=norm_layer)
self.business_layer.append(self.decoder_level1)
self.business_layer.append(self.meem)
self.business_layer.append(self.cam_1)
self.business_layer.append(self.decoder_layer_level2)
self.criterion = criterion
self.edge_criterion = edge_criterion
def __init__(self, out_planes, is_training,
criterion, pretrained_model=None,
norm_layer=nn.BatchNorm2d):
super(conf, self).__init__()
self.is_training = is_training
self.business_layer = []
if is_training:
self.criterion = criterion
self.encoder = resnet101(pretrained_model, norm_layer=norm_layer,
bn_eps=config.bn_eps,
bn_momentum=config.bn_momentum,
deep_stem=True, stem_width=64)
self.context_ff = AttentionFusion(1024, 2048, 128)
self.spatial_conv = ConvBnRelu(256, 128, 1, 1, 0, dilation=1,
has_bn=True, norm_layer=norm_layer,
has_relu=True, has_bias=False)
self.loc_conf = LocationConfidence(128+128, 1)
self.refine_block = RefineOutput(128, out_planes, 4)
self.spatial_refine_block = RefineOutput(128, out_planes, 4)
self.context_refine_block = RefineOutput(128, out_planes, 16)
self.business_layer.append(self.context_ff)
self.business_layer.append(self.loc_conf)
self.business_layer.append(self.spatial_conv)
self.business_layer.append(self.refine_block)
self.business_layer.append(self.spatial_refine_block)
self.business_layer.append(self.context_refine_block)
def __init__(self,
out_planes,
criterion,
inplace=True,
pretrained_model=None,
norm_layer=nn.BatchNorm2d):
super(FCN, self).__init__()
self.backbone = resnet101(pretrained_model,
inplace=inplace,
norm_layer=norm_layer,
bn_eps=config.bn_eps,
bn_momentum=config.bn_momentum,
deep_stem=True,
stem_width=64)
self.business_layer = []
self.head = _FCNHead(2048, out_planes, inplace, norm_layer=norm_layer)
self.aux_head = _FCNHead(1024,
out_planes,
inplace,
norm_layer=norm_layer)
self.business_layer.append(self.head)
self.business_layer.append(self.aux_head)
self.criterion = criterion
def __init__(self, out_planes, criterion, pretrained_model=None,
norm_layer=nn.BatchNorm2d):
super(CPNet, self).__init__()
self.backbone = resnet101(pretrained_model, norm_layer=norm_layer,
bn_eps=config.bn_eps,
bn_momentum=config.bn_momentum,
deep_stem=True, stem_width=64)
self.backbone.layer3.apply(partial(self._nostride_dilate, dilate=2))
self.backbone.layer4.apply(partial(self._nostride_dilate, dilate=4))
self.business_layer = []
self.context = ObjectContext(2048, 512, norm_layer)
self.head_layer = nn.Sequential(
ConvBnRelu(2048 + 1024, 512, 3, 1, 1,
has_bn=True,
has_relu=True, has_bias=False, norm_layer=norm_layer),
nn.Dropout2d(0.1, inplace=False),
nn.Conv2d(512, out_planes, kernel_size=1)
)
self.aux_layer = nn.Sequential(
ConvBnRelu(1024, 512, 3, 1, 1,
has_bn=True,
has_relu=True, has_bias=False, norm_layer=norm_layer),
nn.Dropout2d(0.1, inplace=False),
nn.Conv2d(512, out_planes, kernel_size=1)
)
self.business_layer.append(self.context)
self.business_layer.append(self.head_layer)
self.business_layer.append(self.aux_layer)
self.criterion = criterion
self.bce_criterion = nn.BCELoss(reduction='mean')
def __init__(self, output_shape, num_points, pretrained=True):
super(CPN, self).__init__()
self.resnet101 = base_model.resnet101(pretrained=pretrained)
self.global_net = globalNet([2048, 1024, 512, 256], output_shape,
num_points)
self.refine_net = refineNet(256, output_shape, num_points)
def __init__(self,
out_planes,
criterion,
inplace=True,
pretrained_model=None,
norm_layer=nn.BatchNorm2d):
super(Network, self).__init__()
business_channel_num = config.business_channel_num
self.backbone = resnet101(pretrained_model,
inplace=inplace,
norm_layer=norm_layer,
bn_eps=config.bn_eps,
bn_momentum=config.bn_momentum,
deep_stem=True,
stem_width=64)
block_channel_nums = self.backbone.layer_channel_nums
self.latent_layers = nn.ModuleList()
self.refine_layers = nn.ModuleList()
self.global_context = nn.Sequential(
nn.AdaptiveAvgPool2d(1),
ConvBnRelu(block_channel_nums[-1],
business_channel_num,
1,
1,
0,
has_bn=True,
has_relu=True,
has_bias=False,
norm_layer=norm_layer))
self.predict_layer = PredictHead(business_channel_num,
out_planes,
4,
norm_layer=norm_layer)
for idx, channel in enumerate(block_channel_nums[::-1]):
self.latent_layers.append(
RefineResidual(channel,
business_channel_num,
3,
norm_layer=norm_layer,
has_relu=True))
self.refine_layers.append(
RefineResidual(business_channel_num,
business_channel_num,
3,
norm_layer=norm_layer,
has_relu=True))
self.business_layers = [
self.global_context, self.latent_layers, self.refine_layers,
self.predict_layer
]
self.criterion = criterion
def __init__(self, out_planes, is_training,
criterion, pretrained_model=None,
norm_layer=nn.BatchNorm2d):
super(BiSeNet, self).__init__()
self.context_path = resnet101(pretrained_model, norm_layer=norm_layer,
bn_eps=config.bn_eps,
bn_momentum=config.bn_momentum,
deep_stem=True, stem_width=64)
self.business_layer = []
self.is_training = is_training
self.spatial_path = SpatialPath(3, 128, norm_layer)
conv_channel = 128
self.global_context = nn.Sequential(
nn.AdaptiveAvgPool2d(1),
ConvBnRelu(2048, conv_channel, 1, 1, 0,
has_bn=True,
has_relu=True, has_bias=False, norm_layer=norm_layer)
)
# stage = [512, 256, 128, 64]
arms = [AttentionRefinement(2048, conv_channel, norm_layer),
AttentionRefinement(1024, conv_channel, norm_layer)]
refines = [ConvBnRelu(conv_channel, conv_channel, 3, 1, 1,
has_bn=True, norm_layer=norm_layer,
has_relu=True, has_bias=False),
ConvBnRelu(conv_channel, conv_channel, 3, 1, 1,
has_bn=True, norm_layer=norm_layer,
has_relu=True, has_bias=False)]
heads = [BiSeNetHead(conv_channel, out_planes, 16,
True, norm_layer),
BiSeNetHead(conv_channel, out_planes, 8,
True, norm_layer),
BiSeNetHead(conv_channel * 2, out_planes, 8,
False, norm_layer)]
self.ffm = FeatureFusion(conv_channel * 2, conv_channel * 2,
1, norm_layer)
self.arms = nn.ModuleList(arms)
self.refines = nn.ModuleList(refines)
self.heads = nn.ModuleList(heads)
self.business_layer.append(self.spatial_path)
self.business_layer.append(self.global_context)
self.business_layer.append(self.arms)
self.business_layer.append(self.refines)
self.business_layer.append(self.heads)
self.business_layer.append(self.ffm)
if is_training:
self.criterion = criterion
def __init__(self, num_point):
super(CPN, self).__init__()
self.resnet101 = base_model.resnet101(pretrained=True)
#print resnet101
self.global_net = globalNet([2048, 1024, 512, 256], (64, 64),
num_point)
#print global_net
self.refine_net = refineNet(256, (64, 64), num_point)
def __init__(self,
out_planes,
criterion,
pretrained_model=None,
norm_layer=nn.BatchNorm2d):
super(CPNet, self).__init__()
self.backbone = resnet101(pretrained_model,
norm_layer=norm_layer,
bn_eps=config.bn_eps,
bn_momentum=config.bn_momentum,
deep_stem=True,
stem_width=64)
self.generate_dilation(self.backbone.layer3, dilation=2)
self.generate_dilation(self.backbone.layer4,
dilation=4,
multi_grid=[1, 2, 4])
self.business_layer = []
self.context = ObjectContext(2048, 512, norm_layer)
self.head_layer = nn.Sequential(
ConvBnRelu(2048 + 512,
512,
1,
1,
0,
has_bn=True,
has_relu=True,
has_bias=False,
norm_layer=norm_layer), nn.Dropout2d(0.1,
inplace=False),
nn.Conv2d(512, out_planes, kernel_size=1))
self.aux_layer = nn.Sequential(
ConvBnRelu(1024,
512,
1,
1,
0,
has_bn=True,
has_relu=True,
has_bias=False,
norm_layer=norm_layer), nn.Dropout2d(0.1,
inplace=False),
nn.Conv2d(512, out_planes, kernel_size=1))
self.business_layer.append(self.context)
self.business_layer.append(self.head_layer)
self.business_layer.append(self.aux_layer)
self.criterion = criterion
self.aux_criterion = PriorLoss(0.125, config.num_classes, 255)
def __init__(self, out_planes, is_training, BN2D = BatchNorm2d):
super(Network_Res101, self).__init__()
self.layers = []
self.is_training = is_training
conv_channel = 128
# use base model of resnet 101 from resnet.py
self.context = resnet101(pretrained_model=None, norm_layer=BN2D, bn_eps=config.bn_eps, bn_momentum=config.bn_momentum, deep_stem=False, stem_width=64)
self.context_refine = nn.Sequential(
nn.AdaptiveAvgPool2d(1),
ConvBnRelu(2048,conv_channel, 1, 1, 0, has_bn=True, has_relu=True, has_bias=False, norm_layer=BN2D)
)
# ARM for ResBlock 2,3,4 of resnet output
arms = [AttentionRefinement(2048, conv_channel, norm_layer=BN2D),
AttentionRefinement(1024, conv_channel, norm_layer=BN2D),
AttentionRefinement(512, conv_channel, norm_layer=BN2D)]
# Refinement of corresponding output
refines = [
ConvBnRelu(conv_channel, conv_channel, 3, 1, 1, has_bn=True, norm_layer=BN2D, has_relu=True, has_bias=False),
ConvBnRelu(conv_channel, conv_channel, 3, 1, 1, has_bn=True, norm_layer=BN2D, has_relu=True, has_bias=False),
ConvBnRelu(conv_channel, conv_channel, 3, 1, 1, has_bn=True, norm_layer=BN2D, has_relu=True, has_bias=False)]
self.arms = nn.ModuleList(arms)
self.refines = nn.ModuleList(refines)
# Refinement on first layer of resnet output
self.res_top_refine = ConvBnRelu(256, conv_channel, 3, 1, 1, has_bn=True, norm_layer=BN2D, has_relu=True, has_bias=False)
self.ffm = FeatureFusion(conv_channel*2, conv_channel, 1, BN2D)
# classifier for final output
self.class_refine = nn.Sequential(
ConvBnRelu(conv_channel, conv_channel//2, 3, 1, 1, has_bn=True, has_relu=True, has_bias=False, norm_layer=BN2D),
nn.Conv2d(conv_channel//2, out_planes, kernel_size=1, stride=1, padding=0)
)
self.layers.append(self.context)
self.layers.append(self.class_refine)
self.layers.append(self.context_refine)
self.layers.append(self.arms)
self.layers.append(self.ffm)
self.layers.append(self.refines)
self.layers.append(self.res_top_refine)
self.loss = nn.CrossEntropyLoss(reduction='mean',ignore_index=255)
def __init__(self, out_planes, criterion, pretrained_model=None,
norm_layer=nn.BatchNorm2d):
super(PSPNet, self).__init__()
self.backbone = resnet101(pretrained_model, norm_layer=norm_layer,
bn_eps=config.bn_eps,
bn_momentum=config.bn_momentum,
deep_stem=True, stem_width=64)
self.backbone.layer3.apply(partial(self._nostride_dilate, dilate=2))
self.backbone.layer4.apply(partial(self._nostride_dilate, dilate=4))
self.business_layer = []
self.psp_layer = PyramidPooling('psp', out_planes, 2048,
norm_layer=norm_layer)
self.aux_layer = nn.Sequential(
ConvBnRelu(1024, 1024, 3, 1, 1,
has_bn=True,
has_relu=True, has_bias=False, norm_layer=norm_layer),
nn.Dropout2d(0.1, inplace=False),
nn.Conv2d(1024, out_planes, kernel_size=1)
)
self.business_layer.append(self.psp_layer)
self.business_layer.append(self.aux_layer)
self.criterion = criterion
def __init__(self, out_planes, criterion, aux_criterion, alpha,
pretrained_model=None,
norm_layer=nn.BatchNorm2d):
super(DFN, self).__init__()
self.backbone = resnet101(pretrained_model, norm_layer=norm_layer,
bn_eps=config.bn_eps,
bn_momentum=config.bn_momentum,
deep_stem=False, stem_width=64)
self.business_layer = []
smooth_inner_channel = 512
self.global_context = nn.Sequential(
nn.AdaptiveAvgPool2d(1),
ConvBnRelu(2048, smooth_inner_channel, 1, 1, 0,
has_bn=True,
has_relu=True, has_bias=False, norm_layer=norm_layer)
)
self.business_layer.append(self.global_context)
stage = [2048, 1024, 512, 256]
self.smooth_pre_rrbs = []
self.cabs = []
self.smooth_aft_rrbs = []
self.smooth_heads = []
#every stage we have dfn layer output?
# top to bottom 2048 -> 256
for i, channel in enumerate(stage):
self.smooth_pre_rrbs.append(
RefineResidual(channel, smooth_inner_channel, 3, has_bias=False,
has_relu=True, norm_layer=norm_layer))
self.cabs.append(
ChannelAttention(smooth_inner_channel * 2,
smooth_inner_channel, 1))
self.smooth_aft_rrbs.append(
RefineResidual(smooth_inner_channel, smooth_inner_channel, 3,
has_bias=False,
has_relu=True, norm_layer=norm_layer))
self.smooth_heads.append(
DFNHead(smooth_inner_channel, out_planes, scale=2 ** (5 - i),
norm_layer=norm_layer))
stage.reverse()
border_inner_channel = 21
self.border_pre_rrbs = []
self.border_aft_rrbs = []
self.border_heads = []
for i, channel in enumerate(stage):
self.border_pre_rrbs.append(
RefineResidual(channel, border_inner_channel, 3, has_bias=False,
has_relu=True, norm_layer=norm_layer))
self.border_aft_rrbs.append(
RefineResidual(border_inner_channel, border_inner_channel, 3,
has_bias=False,
has_relu=True, norm_layer=norm_layer))
self.border_heads.append(
DFNHead(border_inner_channel, 1, 4, norm_layer=norm_layer))
self.smooth_pre_rrbs = nn.ModuleList(self.smooth_pre_rrbs)
self.cabs = nn.ModuleList(self.cabs)
self.smooth_aft_rrbs = nn.ModuleList(self.smooth_aft_rrbs)
self.smooth_heads = nn.ModuleList(self.smooth_heads)
self.border_pre_rrbs = nn.ModuleList(self.border_pre_rrbs)
self.border_aft_rrbs = nn.ModuleList(self.border_aft_rrbs)
self.border_heads = nn.ModuleList(self.border_heads)
#smooth model
self.business_layer.append(self.smooth_pre_rrbs)
self.business_layer.append(self.cabs)
self.business_layer.append(self.smooth_aft_rrbs)
self.business_layer.append(self.smooth_heads)
#border_layer model
self.business_layer.append(self.border_pre_rrbs)
self.business_layer.append(self.border_aft_rrbs)
self.business_layer.append(self.border_heads)
self.criterion = criterion
self.aux_criterion = aux_criterion
self.alpha = alpha
