def __init__(self, num_classes):
super(Decoder_Module, self).__init__()
self.conv1 = nn.Sequential(
nn.Conv2d(512,
256,
kernel_size=1,
padding=0,
dilation=1,
bias=False), InPlaceABNSync(256))
self.conv2 = nn.Sequential(
nn.Conv2d(256,
48,
kernel_size=1,
stride=1,
padding=0,
dilation=1,
bias=False), InPlaceABNSync(48))
self.conv3 = nn.Sequential(
nn.Conv2d(768,
512,
kernel_size=1,
padding=0,
dilation=1,
bias=False), InPlaceABNSync(512))
# self.conv3 = nn.Sequential(
# nn.Conv2d(304, 256, kernel_size=3, padding=1, dilation=1, bias=False),
# InPlaceABNSync(256),
# nn.Conv2d(256, 512, kernel_size=3, padding=1, dilation=1, bias=False),
# InPlaceABNSync(512))
self.conv4 = nn.Conv2d(512,
num_classes,
kernel_size=1,
padding=0,
dilation=1,
bias=True)
def __init__(self, in_channels, out_channels):
super(DPCModule, self).__init__()
inter_channels = in_channels // 4
self.conv1 = nn.Sequential(
nn.Conv2d(in_channels, inter_channels, 3, padding=1, bias=False),
InPlaceABNSync(inter_channels), nn.ReLU())
self.pa = PAModule(inter_channels)
self.ca = CAModule(inter_channels)
self.conv_red_1 = nn.Sequential(nn.Dropout2d(0.1, False),
nn.Conv2d(512, out_channels, 1))
self.conv_red_2 = nn.Sequential(nn.Dropout2d(0.1, False),
nn.Conv2d(512, out_channels, 1))
self.conv_red_3 = nn.Sequential(nn.Dropout2d(0.1, False),
nn.Conv2d(512, out_channels, 1))
self.bottlneck = nn.Sequential(
nn.Conv2d(inter_channels * 3 + in_channels,
out_channels,
kernel_size=3,
padding=1,
dilation=1,
bias=False), InPlaceABNSync(out_channels),
nn.Dropout2d(0.1))
def __init__(self, in_channels, out_channels, num_classes):
super(RCCAModule, self).__init__()
inter_channels = in_channels // 4
self.conva = nn.Sequential(
nn.Conv2d(in_channels, inter_channels, 3, padding=1, bias=False),
InPlaceABNSync(inter_channels))
self.cca = CrissCrossAttention(inter_channels)
self.convb = nn.Sequential(
nn.Conv2d(inter_channels, inter_channels, 3, padding=1,
bias=False), InPlaceABNSync(inter_channels))
self.bottleneck = nn.Sequential(
nn.Conv2d(in_channels + inter_channels,
out_channels,
kernel_size=3,
padding=1,
dilation=1,
bias=False), InPlaceABNSync(out_channels),
nn.Dropout2d(0.1),
nn.Conv2d(512,
num_classes,
kernel_size=1,
stride=1,
padding=0,
bias=True))
def __init__(self, in_channels, out_channels, num_classes, type='seg_nl'):
super(GCBModule, self).__init__()
assert type in ['baseline', 'seg_nl']
inter_channels = in_channels // 4
self.conva = nn.Sequential(
nn.Conv2d(in_channels, inter_channels, 3, padding=1, bias=False),
InPlaceABNSync(inter_channels))
if type == 'seg_nl':
self.ctb = SegNonLocal2d(inplanes=inter_channels,
planes=inter_channels // 2,
downsample=False,
k_seg=True,
q_seg=False)
elif type == 'baseline':
self.ctb = None
self.convb = nn.Sequential(
nn.Conv2d(inter_channels, inter_channels, 3, padding=1,
bias=False), InPlaceABNSync(inter_channels))
self.bottleneck = nn.Sequential(
nn.Conv2d(in_channels + inter_channels,
out_channels,
kernel_size=3,
padding=1,
dilation=1,
bias=False), InPlaceABNSync(out_channels),
nn.Dropout2d(0.1),
nn.Conv2d(512,
num_classes,
kernel_size=1,
stride=1,
padding=0,
bias=True))
def __init__(self,
num_heatmap,
num_pafs,
num_refinement_stages=5,
in_fea=[512, 2048],
mid_fea=256):
super().__init__()
self.conv1 = nn.Sequential(
nn.Conv2d(in_fea[0],
mid_fea,
kernel_size=1,
padding=0,
dilation=1,
bias=False), InPlaceABNSync(mid_fea))
self.conv2 = nn.Sequential(
nn.Conv2d(in_fea[1],
mid_fea,
kernel_size=1,
padding=0,
dilation=1,
bias=False), InPlaceABNSync(mid_fea))
self.cpm = Cpm(512, 128)
self.initial_stage = InitialStage(128, num_heatmap, num_pafs)
self.refinement_stages = nn.ModuleList()
for idx in range(num_refinement_stages):
self.refinement_stages.append(
RefinementStage(128 + num_heatmap + num_pafs, 128, num_heatmap,
num_pafs))
def __init__(self, block, layers, num_classes):
self.inplanes = 128
super(ResNet, self).__init__()
self.conv1 = conv3x3(3, 64, stride=2)
self.bn1 = BatchNorm2d(64)
self.relu1 = nn.ReLU(inplace=False)
self.conv2 = conv3x3(64, 64)
self.bn2 = BatchNorm2d(64)
self.relu2 = nn.ReLU(inplace=False)
self.conv3 = conv3x3(64, 128)
self.bn3 = BatchNorm2d(128)
self.relu3 = nn.ReLU(inplace=False)
self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
self.relu = nn.ReLU(inplace=False)
self.maxpool = nn.MaxPool2d(kernel_size=3,
stride=2,
padding=1,
ceil_mode=True) # change
self.layer1 = self._make_layer(block, 64, layers[0])
self.layer2 = self._make_layer(block, 128, layers[1], stride=2)
self.layer3 = self._make_layer(block,
256,
layers[2],
stride=1,
dilation=2)
self.layer4 = self._make_layer(block,
512,
layers[3],
stride=1,
dilation=4,
multi_grid=(1, 1, 1))
self.head = nn.Sequential(
nn.Conv2d(2048, 512, kernel_size=3, stride=1, padding=0,
bias=True), InPlaceABNSync(512),
nn.Conv2d(512,
num_classes,
kernel_size=1,
stride=1,
padding=0,
bias=True))
self.dsn = nn.Sequential(
nn.Conv2d(1024, 512, kernel_size=3, stride=1, padding=1),
InPlaceABNSync(512), nn.Dropout2d(0.1),
nn.Conv2d(512,
num_classes,
kernel_size=1,
stride=1,
padding=0,
bias=True))
def _make_stage(self, features, out_features, size):
#pool input to (size, size)
prior = nn.AdaptiveAvgPool2d(output_size=(size, size))
# conv 1x1 to reduce channels
conv = nn.Conv2d(features, out_features, kernel_size=1, bias=False)
bn = InPlaceABNSync(out_features)
return nn.Sequential(prior, conv, bn)
def __init__(self,
in_planes,
out_planes,
ksize,
stride,
pad,
dilation=1,
groups=1,
has_bn=True,
bn_eps=1e-5,
has_relu=True,
inplace=True,
has_bias=False):
super(ConvBnRelu, self).__init__()
self.conv = nn.Conv2d(in_planes,
out_planes,
kernel_size=ksize,
stride=stride,
padding=pad,
dilation=dilation,
groups=groups,
bias=has_bias)
self.has_bn = has_bn
self.has_relu = has_relu
if self.has_bn and self.has_relu:
self.bn = InPlaceABNSync(out_planes)
else:
if self.has_bn:
self.bn = BatchNorm2d(out_planes)
if self.has_relu:
self.relu = nn.ReLU()
def __init__(self, block, layers, num_classes):
self.inplanes = 128
super(ResNet, self).__init__()
self.conv1 = conv3x3(3, 64, stride=2)
self.bn1 = BatchNorm2d(64)
self.relu1 = nn.ReLU(inplace=False)
self.conv2 = conv3x3(64, 64)
self.bn2 = BatchNorm2d(64)
self.relu2 = nn.ReLU(inplace=False)
self.conv3 = conv3x3(64, 128)
self.bn3 = BatchNorm2d(128)
self.relu3 = nn.ReLU(inplace=False)
self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
self.layer1 = self._make_layer(block, 64, layers[0])
self.layer2 = self._make_layer(block, 128, layers[1], stride=2)
self.layer3 = self._make_layer(block, 256, layers[2], stride=2)
self.layer4 = self._make_layer(block, 512, layers[3], stride=1, dilation=2, multi_grid=(1,1,1))
self.layer5 = PSPModule(2048,512)
self.edge_layer = Edge_Module()
self.layer6 = Decoder_Module(num_classes)
self.layer7 = nn.Sequential(
nn.Conv2d(1024, 256, kernel_size=1, padding=0, dilation=1, bias=False),
InPlaceABNSync(256),
nn.Dropout2d(0.1),
nn.Conv2d(256, num_classes, kernel_size=1, padding=0, dilation=1, bias=True)
)
def __init__(self, in_channels, n_filters):
super(DecoderBlock, self).__init__()
self.conv1 = nn.Conv2d(in_channels, in_channels // 4, 1)
self.norm1 = InPlaceABNSync(in_channels // 4)
self.deconv2 = nn.ConvTranspose2d(in_channels // 4,
in_channels // 4,
3,
stride=2,
padding=1,
output_padding=1)
self.norm2 = InPlaceABNSync(in_channels // 4)
self.conv3 = nn.Conv2d(in_channels // 4, n_filters, 1)
self.norm3 = InPlaceABNSync(n_filters)
def __init__(self,
in_planes,
out_planes,
ksize,
stride,
pad,
out_pad,
groups=1,
has_bn=True,
bn_eps=1e-5,
has_relu=True,
inplace=True,
has_bias=False):
super(DeConvBnRelu, self).__init__()
self.deconv = nn.ConvTranspose2d(in_channels=in_planes,
out_channels=out_planes,
kernel_size=ksize,
stride=stride,
padding=pad,
output_padding=out_pad,
bias=has_bias)
self.has_bn = has_bn
self.has_relu = has_relu
if self.has_bn and self.has_relu:
self.bn = InPlaceABNSync(out_planes)
else:
if self.has_bn:
self.bn = BatchNorm2d(out_planes)
if self.has_relu:
self.relu = nn.ReLU()
def __init__(self, block, layers, num_classes, cfg):
self.inplanes = 128
super(ResNet, self).__init__()
self.conv1 = conv3x3(3, 64, stride=2)
self.bn1 = BatchNorm2d(64)
self.relu1 = nn.ReLU(inplace=False)
self.conv2 = conv3x3(64, 64)
self.bn2 = BatchNorm2d(64)
self.relu2 = nn.ReLU(inplace=False)
self.conv3 = conv3x3(64, 128)
self.bn3 = BatchNorm2d(128)
self.relu3 = nn.ReLU(inplace=False)
self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
with_att = cfg.att.with_att
att = cfg.att.type
att_stage = cfg.att.att_stage
att_pos = cfg.att.att_pos
att_location = cfg.att.att_location
self.relu = nn.ReLU(inplace=False)
self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1, ceil_mode=True) # change
self.layer1 = self._make_layer(block, 64, layers[0], with_att=with_att*att_stage[0], att=att, att_pos=att_pos, att_loc=att_location[0])
self.layer2 = self._make_layer(block, 128, layers[1], stride=2, with_att=with_att*att_stage[1], att=att, att_pos=att_pos, att_loc=att_location[1])
self.layer3 = self._make_layer(block, 256, layers[2], stride=1, dilation=2, with_att=with_att*att_stage[2], att=att, att_pos=att_pos, att_loc=att_location[2])
self.layer4 = self._make_layer(block, 512, layers[3], stride=1, dilation=4, multi_grid=(1,1,1), with_att=with_att*att_stage[3], att=att, att_pos=att_pos, att_loc=att_location[3])
#self.layer5 = PSPModule(2048, 512)
self.head = GCBModule(2048, 512, num_classes, cfg.module)
self.dsn = nn.Sequential(
nn.Conv2d(1024, 512, kernel_size=3, stride=1, padding=1),
InPlaceABNSync(512),
nn.Dropout2d(0.1),
nn.Conv2d(512, num_classes, kernel_size=1, stride=1, padding=0, bias=True)
)
def __init__(self,in_fea=[256,512,1024], mid_fea=256, out_fea=2):
super(Edge_Module, self).__init__()
self.conv1 = nn.Sequential(
nn.Conv2d(in_fea[0], mid_fea, kernel_size=1, padding=0, dilation=1, bias=False),
InPlaceABNSync(mid_fea)
)
self.conv2 = nn.Sequential(
nn.Conv2d(in_fea[1], mid_fea, kernel_size=1, padding=0, dilation=1, bias=False),
InPlaceABNSync(mid_fea)
)
self.conv3 = nn.Sequential(
nn.Conv2d(in_fea[2], mid_fea, kernel_size=1, padding=0, dilation=1, bias=False),
InPlaceABNSync(mid_fea)
)
self.conv4 = nn.Conv2d(mid_fea,out_fea, kernel_size=3, padding=1, dilation=1, bias=True)
self.conv5 = nn.Conv2d(out_fea*3,out_fea, kernel_size=1, padding=0, dilation=1, bias=True)
def conv(inplanes, outplanes, kernel=3, stride=1, padding=1):
conv = nn.Sequential(
nn.Conv2d(inplanes,
outplanes,
kernel_size=kernel,
stride=stride,
padding=padding), InPlaceABNSync(outplanes))
return conv
def __init__(self, block, layers, num_classes):
self.inplanes = 128
super(ResNet, self).__init__()
print ('Model: ASP_OCNet')
self.conv1 = conv3x3(3, 64, stride=2)
self.bn1 = BatchNorm2d(64)
self.relu1 = nn.ReLU(inplace=False)
self.conv2 = conv3x3(64, 64)
self.bn2 = BatchNorm2d(64)
self.relu2 = nn.ReLU(inplace=False)
self.conv3 = conv3x3(64, 128)
self.bn3 = BatchNorm2d(128)
self.relu3 = nn.ReLU(inplace=False)
self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
self.relu = nn.ReLU(inplace=False)
self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1, ceil_mode=True) # change
self.layer1 = self._make_layer(block, 64, layers[0])
self.layer2 = self._make_layer(block, 128, layers[1], stride=2)
self.layer3 = self._make_layer(block, 256, layers[2], stride=1, dilation=2)
#######
# for p in self.parameters():
# p.requires_grad = False
# print ('----Lock before Layer4----')
#######
self.layer4 = self._make_layer(block, 512, layers[3], stride=1, dilation=4, multi_grid=(1,1,1))
# extra added layers
# old
self.lastChannel = 256 # 512 for old code, 256 for new code
# self.context = nn.Sequential(
# ASP_OC_Module(2048, self.lastChannel),
# )
# new
self.context = nn.Sequential(
nn.Conv2d(2048, 512, kernel_size=3, stride=1, padding=1),
InPlaceABNSync(512),
ASP_OC_Module(512, self.lastChannel)
)
self.cls = nn.Conv2d(self.lastChannel, num_classes, kernel_size=1, stride=1, padding=0, bias=True)
self.dsn = nn.Sequential(
nn.Conv2d(1024, 512, kernel_size=3, stride=1, padding=1),
InPlaceABNSync(512),
nn.Dropout2d(0.10),
nn.Conv2d(512, num_classes, kernel_size=1, stride=1, padding=0, bias=True)
)
def __init__(self, features, out_features=512, sizes=(1, 2, 3)):
super(PSPModule, self).__init__()
self.stages = []
self.stages = nn.ModuleList([self._make_stage(features, out_features, size) for size in sizes])
self.bottleneck = nn.Sequential(
nn.Conv2d(features+len(sizes)*out_features, out_features, kernel_size=3, padding=1, dilation=1, bias=False),
InPlaceABNSync(out_features),
)
def __init__(self, in_channels, out_channels, key_channels, value_channels, dropout, sizes=([1])):
super(BaseOC_Context_Module, self).__init__()
self.stages = []
self.stages = nn.ModuleList(
[self._make_stage(in_channels, out_channels, key_channels, value_channels, size) for size in sizes])
self.conv_bn_dropout = nn.Sequential(
nn.Conv2d(in_channels, out_channels, kernel_size=1, padding=0),
InPlaceABNSync(out_channels),
)
def __init__(self, inplanes, planes, stride=1, downsample=None):
super(Bottleneck, self).__init__()
self.conv1 = nn.Conv2d(inplanes, planes, kernel_size=1, bias=False)
self.bn1 = InPlaceABNSync(planes)
self.conv2 = nn.Conv2d(planes,
planes,
kernel_size=3,
stride=stride,
padding=1,
bias=False)
self.bn2 = InPlaceABNSync(planes)
self.conv3 = nn.Conv2d(planes,
planes * self.expansion,
kernel_size=1,
bias=False)
self.bn3 = nn.BatchNorm2d(planes * self.expansion)
self.relu = nn.ReLU(inplace=True)
self.downsample = downsample
self.stride = stride
def __init__(self, inplanes, planes, stride=1, downsample=None):
super(BasicBlock, self).__init__()
self.conv1 = conv3x3(inplanes, planes, stride)
self.bn1 = InPlaceABNSync(planes)
self.relu = nn.ReLU(inplace=True)
self.conv2 = conv3x3(planes, planes)
self.bn2 = nn.BatchNorm2d(planes)
self.downsample = downsample
self.stride = stride
def _make_fuse_layers(self):
if self.num_branches == 1:
return None
num_branches = self.num_branches
num_inchannels = self.num_inchannels
fuse_layers = []
for i in range(num_branches if self.multi_scale_output else 1):
fuse_layer = []
for j in range(num_branches):
if j > i:
fuse_layer.append(
nn.Sequential(
nn.Conv2d(num_inchannels[j],
num_inchannels[i],
1,
1,
0,
bias=False),
BatchNorm2d(num_inchannels[i]),
nn.Upsample(scale_factor=2**(j - i),
mode='nearest')))
elif j == i:
fuse_layer.append(None)
else:
conv3x3s = []
for k in range(i - j):
if k == i - j - 1:
num_outchannels_conv3x3 = num_inchannels[i]
conv3x3s.append(
nn.Sequential(
nn.Conv2d(num_inchannels[j],
num_outchannels_conv3x3,
3,
2,
1,
bias=False),
BatchNorm2d(num_outchannels_conv3x3)))
else:
num_outchannels_conv3x3 = num_inchannels[j]
conv3x3s.append(
nn.Sequential(
nn.Conv2d(num_inchannels[j],
num_outchannels_conv3x3,
3,
2,
1,
bias=False),
InPlaceABNSync(num_outchannels_conv3x3)))
fuse_layer.append(nn.Sequential(*conv3x3s))
fuse_layers.append(nn.ModuleList(fuse_layer))
return nn.ModuleList(fuse_layers)
def __init__(self, num_classes):
super(Decoder_Module, self).__init__()
#xt/psp features has depth 256
self.conv1 = nn.Sequential(
nn.Conv2d(512,
256,
kernel_size=1,
padding=0,
dilation=1,
bias=False), InPlaceABNSync(256))
#xl/conv2 feature has depth 256 --> 48
self.conv2 = nn.Sequential(
nn.Conv2d(256,
48,
kernel_size=1,
stride=1,
padding=0,
dilation=1,
bias=False), InPlaceABNSync(48))
self.conv4 = nn.Sequential(
nn.Conv2d(304,
256,
kernel_size=1,
padding=0,
dilation=1,
bias=False), InPlaceABNSync(256),
nn.Conv2d(256,
256,
kernel_size=1,
padding=0,
dilation=1,
bias=False), InPlaceABNSync(256))
# self.RC1 = Residual_Covolution(512, 1024, num_classes)
# self.RC2 = Residual_Covolution(512, 1024, num_classes)
# self.RC3 = Residual_Covolution(512, 1024, num_classes)
self.conv5 = nn.Conv2d(256,
num_classes,
kernel_size=1,
padding=0,
dilation=1,
bias=True)
def deconv(in_channels,
out_channels,
kernel_size=4,
stride=2,
padding=1,
output_padding=0):
deconv = nn.Sequential(
nn.ConvTranspose2d(in_channels, out_channels, kernel_size, stride,
padding, output_padding),
InPlaceABNSync(out_channels))
return deconv
def __init__(self, in_channels, out_channels, num_classes, type='nl'):
super(GCBModule, self).__init__()
assert type in ['gcb', 'nl', 'nl_bn', 'multi', 'multi_spatial']
inter_channels = in_channels // 4
self.conva = nn.Sequential(
nn.Conv2d(in_channels, inter_channels, 3, padding=1, bias=False),
InPlaceABNSync(inter_channels))
if type == 'gcb':
self.ctb = ContextBlock(inter_channels, ratio=1. / 4)
elif type == 'nl':
self.ctb = NonLocal2d(inter_channels, inter_channels // 2)
elif type == 'nl_bn':
self.ctb = NonLocal2d_bn(inter_channels, inter_channels // 2)
elif type == 'multi':
self.ctb = MultiheadBlock(inter_channels, ratio=1. / 4, head_num=8)
elif type == 'multi_spatial':
self.ctb = MultiheadSpatialBlock(inter_channels,
ratio=1. / 4,
head_num=16)
else:
self.ctb = None
self.convb = nn.Sequential(
nn.Conv2d(inter_channels, inter_channels, 3, padding=1,
bias=False), InPlaceABNSync(inter_channels))
self.bottleneck = nn.Sequential(
nn.Conv2d(in_channels + inter_channels,
out_channels,
kernel_size=3,
padding=1,
dilation=1,
bias=False), InPlaceABNSync(out_channels),
nn.Dropout2d(0.1),
nn.Conv2d(512,
num_classes,
kernel_size=1,
stride=1,
padding=0,
bias=True))
def __init__(self, in_channels, out_channels):
super(RCCAModule, self).__init__()
inter_channels = in_channels // 4
self.channels = in_channels // 4
self.conva = nn.Sequential(
nn.Conv2d(in_channels, inter_channels, 3, padding=1, bias=False),
InPlaceABNSync(inter_channels))
self.cca = PAM_Module(inter_channels)
self.convb = nn.Sequential(
nn.Conv2d(inter_channels, inter_channels, 3, padding=1,
bias=False), InPlaceABNSync(inter_channels))
self.bottleneck = nn.Sequential(
nn.Conv2d(in_channels + inter_channels,
out_channels,
kernel_size=3,
padding=1,
dilation=1,
bias=False), InPlaceABNSync(out_channels))
def _make_transition_layer(self, num_channels_pre_layer,
num_channels_cur_layer):
num_branches_cur = len(num_channels_cur_layer)
num_branches_pre = len(num_channels_pre_layer)
transition_layers = []
for i in range(num_branches_cur):
if i < num_branches_pre:
if num_channels_cur_layer[i] != num_channels_pre_layer[i]:
transition_layers.append(
nn.Sequential(
nn.Conv2d(num_channels_pre_layer[i],
num_channels_cur_layer[i],
3,
1,
1,
bias=False),
InPlaceABNSync(num_channels_cur_layer[i])))
else:
transition_layers.append(None)
else:
conv3x3s = []
for j in range(i + 1 - num_branches_pre):
inchannels = num_channels_pre_layer[-1]
outchannels = num_channels_cur_layer[i] \
if j == i-num_branches_pre else inchannels
conv3x3s.append(
nn.Sequential(
nn.Conv2d(inchannels,
outchannels,
3,
2,
1,
bias=False),
InPlaceABNSync(outchannels)))
transition_layers.append(nn.Sequential(*conv3x3s))
return nn.ModuleList(transition_layers)
def __init__(self, in_channels, out_channels):
super(DANetHead, self).__init__()
inter_channels = in_channels // 4
self.conv5a = nn.Sequential(
nn.Conv2d(in_channels, inter_channels, 3, padding=1, bias=False),
InPlaceABNSync(inter_channels), nn.ReLU())
self.conv5c = nn.Sequential(
nn.Conv2d(in_channels, inter_channels, 3, padding=1, bias=False),
InPlaceABNSync(inter_channels), nn.ReLU())
self.sa = PAM_Module(inter_channels)
self.sc = CAM_Module(inter_channels)
self.conv51 = nn.Sequential(
nn.Conv2d(inter_channels, inter_channels, 3, padding=1,
bias=False), InPlaceABNSync(inter_channels), nn.ReLU())
self.conv52 = nn.Sequential(
nn.Conv2d(inter_channels, inter_channels, 3, padding=1,
bias=False), InPlaceABNSync(inter_channels), nn.ReLU())
self.conv6 = nn.Sequential(nn.Dropout2d(0.1, False),
nn.Conv2d(512, out_channels, 1))
self.conv7 = nn.Sequential(nn.Dropout2d(0.1, False),
nn.Conv2d(512, out_channels, 1))
self.conv8 = nn.Sequential(nn.Dropout2d(0.1, False),
nn.Conv2d(512, out_channels, 1))
self.bottleneck = nn.Sequential(
nn.Conv2d(inter_channels * 3,
out_channels,
kernel_size=3,
padding=1,
dilation=1,
bias=False), InPlaceABNSync(out_channels),
nn.Dropout2d(0.1))
def __init__(self, num_classes, pose_classes, pafs_num):
super(Decoder_Module, self).__init__()
self.conv1 = nn.Sequential(
nn.Conv2d(512,
256,
kernel_size=1,
padding=0,
dilation=1,
bias=False), InPlaceABNSync(256))
self.conv2 = nn.Sequential(
nn.Conv2d(256,
48,
kernel_size=1,
stride=1,
padding=0,
dilation=1,
bias=False), InPlaceABNSync(48))
self.conv3 = nn.Sequential(
nn.Conv2d(304 + pose_classes + pafs_num + 128,
256,
kernel_size=1,
padding=0,
dilation=1,
bias=False), InPlaceABNSync(256),
nn.Conv2d(256,
256,
kernel_size=1,
padding=0,
dilation=1,
bias=False), InPlaceABNSync(256))
self.conv4 = nn.Conv2d(256,
num_classes,
kernel_size=1,
padding=0,
dilation=1,
bias=True)
def __init__(self, block, layers, num_classes, npoints):
self.inplanes = 128
super(ResNet, self).__init__()
self.conv1 = conv3x3(3, 64, stride=2)
self.bn1 = BatchNorm2d(64)
self.relu1 = nn.ReLU(inplace=False)
self.conv2 = conv3x3(64, 64)
self.bn2 = BatchNorm2d(64)
self.relu2 = nn.ReLU(inplace=False)
self.conv3 = conv3x3(64, 128)
self.bn3 = BatchNorm2d(128)
self.relu3 = nn.ReLU(inplace=False)
self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
self.layer1 = self._make_layer(block, 64, layers[0])
self.layer2 = self._make_layer(block, 128, layers[1], stride=2)
self.layer3 = self._make_layer(block, 256, layers[2], stride=2)
self.layer4 = self._make_layer(block,
512,
layers[3],
stride=1,
dilation=2,
multi_grid=(1, 1, 1))
self.layer5 = ASPPModule(features=2048,
inner_features=256,
out_features=512)
self.module_list = []
self.edge_layer = Edge_Module()
self.pose_layer = get_pose_net(npoints, is_train=True)
self.layer6 = Decoder_Module(num_classes)
self.module_list.append(self.edge_layer)
self.module_list.append(self.pose_layer)
self.out_layer = nn.Conv2d(512,
num_classes,
kernel_size=1,
padding=0,
bias=True)
self.conv_fuse = nn.Sequential(
nn.Conv2d(1536, 512, kernel_size=1, padding=0, bias=False),
InPlaceABNSync(512))
self.nl_SEP = NONLocalBlock2D(in_channels=512, sub_sample=True)
def __init__(self, features, out_features=512, dilations=(12, 24, 36)):
super(ASP_OC_Module, self).__init__()
self.context = nn.Sequential(
nn.Conv2d(features,
out_features,
kernel_size=3,
padding=1,
dilation=1,
bias=True), InPlaceABNSync(out_features),
BaseOC_Context_Module(in_channels=out_features,
out_channels=out_features,
key_channels=out_features // 2,
value_channels=out_features,
dropout=0,
sizes=([1])))
self.conv2 = nn.Sequential(
nn.Conv2d(features,
out_features,
kernel_size=1,
padding=0,
dilation=1,
bias=False), InPlaceABNSync(out_features))
self.conv3 = nn.Sequential(
nn.Conv2d(features,
out_features,
kernel_size=3,
padding=dilations[0],
dilation=dilations[0],
bias=False), InPlaceABNSync(out_features))
self.conv4 = nn.Sequential(
nn.Conv2d(features,
out_features,
kernel_size=3,
padding=dilations[1],
dilation=dilations[1],
bias=False), InPlaceABNSync(out_features))
self.conv5 = nn.Sequential(
nn.Conv2d(features,
out_features,
kernel_size=3,
padding=dilations[2],
dilation=dilations[2],
bias=False), InPlaceABNSync(out_features))
self.conv_bn_dropout = nn.Sequential(
nn.Conv2d(out_features * 5,
out_features,
kernel_size=1,
padding=0,
dilation=1,
bias=False), InPlaceABNSync(out_features),
nn.Dropout2d(0.1))
def __init__(self,
features,
inner_features=256,
out_features=512,
dilations=(12, 24, 36)):
super(ASPPModule, self).__init__()
self.conv1 = nn.Sequential(
nn.AdaptiveAvgPool2d((1, 1)),
nn.Conv2d(features,
inner_features,
kernel_size=1,
padding=0,
dilation=1,
bias=False), InPlaceABNSync(inner_features))
self.conv2 = nn.Sequential(
nn.Conv2d(features,
inner_features,
kernel_size=1,
padding=0,
dilation=1,
bias=False), InPlaceABNSync(inner_features))
self.conv3 = nn.Sequential(
nn.Conv2d(features,
inner_features,
kernel_size=3,
padding=dilations[0],
dilation=dilations[0],
bias=False), InPlaceABNSync(inner_features))
self.conv4 = nn.Sequential(
nn.Conv2d(features,
inner_features,
kernel_size=3,
padding=dilations[1],
dilation=dilations[1],
bias=False), InPlaceABNSync(inner_features))
self.conv5 = nn.Sequential(
nn.Conv2d(features,
inner_features,
kernel_size=3,
padding=dilations[2],
dilation=dilations[2],
bias=False), InPlaceABNSync(inner_features))
self.bottleneck = nn.Sequential(
nn.Conv2d(inner_features * 5,
out_features,
kernel_size=1,
padding=0,
dilation=1,
bias=False), InPlaceABNSync(out_features),
nn.Dropout2d(0.1))
