def _make_deconv_layer(self, num_layers, num_filters, num_kernels):
assert num_layers == len(num_filters), \
'ERROR: num_deconv_layers is different len(num_deconv_filters)'
assert num_layers == len(num_kernels), \
'ERROR: num_deconv_layers is different len(num_deconv_filters)'
layers = []
for i in range(num_layers):
kernel, padding, output_padding = \
self._get_deconv_cfg(num_kernels[i], i)
planes = num_filters[i]
fc = DCN(self.inplanes, planes,
kernel_size=3, stride=1,
padding=1, dilation=1, deformable_groups=1)
up = nn.ConvTranspose2d(in_channels=planes,
out_channels=planes,
kernel_size=kernel,
stride=2,
padding=padding,
output_padding=output_padding,
bias=self.deconv_with_bias)
fill_up_weights(up)
layers.append(fc)
layers.append(nn.ReLU(inplace=True))
layers.append(nn.BatchNorm2d(planes, momentum=BN_MOMENTUM))
layers.append(up)
layers.append(nn.ReLU(inplace=True))
layers.append(nn.BatchNorm2d(planes, momentum=BN_MOMENTUM))
self.inplanes = planes
return nn.Sequential(*layers)
def __init__(self, inplanes, head_conv, outplanes):
super(VotingModule, self).__init__()
self.input_conv = nn.Sequential(
nn.Conv2d(inplanes, head_conv, kernel_size=3, padding=1,
bias=True), nn.ReLU(inplace=True),
DCN(head_conv,
head_conv,
kernel_size=3,
stride=1,
padding=1,
dilation=1,
deformable_groups=1), nn.ReLU(inplace=True),
nn.Conv2d(head_conv,
head_conv,
kernel_size=3,
padding=1,
bias=True))
self.votes_conv = nn.Sequential(
nn.Conv2d(head_conv,
head_conv,
kernel_size=3,
padding=1,
bias=True), nn.ReLU(inplace=True),
nn.Conv2d(head_conv,
outplanes,
kernel_size=1,
padding=0,
bias=True))
fill_fc_weights(self.input_conv)
fill_fc_weights(self.votes_conv)
def __init__(self, chi, cho):
super(DeformConv, self).__init__()
self.actf = nn.Sequential(
nn.BatchNorm2d(cho, momentum=BN_MOMENTUM),
nn.ReLU(inplace=True)
)
self.conv = DCN(chi, cho, kernel_size=3, stride=1, padding=1, dilation=1, deformable_groups=1)
def __init__(self, block, layers, head_conv, num_classes, num_codes, num_votes=121):
self.inplanes = 64
self.deconv_with_bias = False
self.num_classes = num_classes
self.num_codes = num_codes
super(PoseResNet, self).__init__()
self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3, bias=False)
self.bn1 = nn.BatchNorm2d(64, momentum=BN_MOMENTUM)
self.relu = nn.ReLU(inplace=True)
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=2)
# used for deconv layers
self.deconv_layers = self._make_deconv_layer(3, [256, 128, 64], [4, 4, 4])
self.amodal_conv = nn.Sequential(nn.Conv2d(head_conv, head_conv * 2, kernel_size=3, padding=1, bias=True),
nn.BatchNorm2d(head_conv * 2),
nn.ReLU(inplace=True),
nn.Conv2d(head_conv * 2, head_conv * 2, kernel_size=3, padding=1, bias=True),
nn.BatchNorm2d(head_conv * 2),
nn.ReLU(inplace=True))
self.inmodal_conv = nn.Sequential(nn.Conv2d(head_conv, head_conv * 2, kernel_size=3, padding=1, bias=True),
nn.BatchNorm2d(head_conv * 2),
nn.ReLU(inplace=True),
nn.Conv2d(head_conv * 2, head_conv * 2, kernel_size=3, padding=1, bias=True),
nn.BatchNorm2d(head_conv * 2),
nn.ReLU(inplace=True))
if head_conv > 0:
# heatmap layers
self.hmap = nn.Sequential(nn.Conv2d(head_conv * 2, head_conv * 2, kernel_size=3, padding=1, bias=True),
nn.ReLU(inplace=True),
nn.Conv2d(head_conv * 2, num_classes, kernel_size=1, bias=True))
self.hmap[-1].bias.data.fill_(-2.19)
# regression layers
self.regs = nn.Sequential(nn.Conv2d(head_conv * 2, head_conv * 2, kernel_size=3, padding=1, bias=True),
nn.ReLU(inplace=True),
nn.Conv2d(head_conv * 2, 2, kernel_size=1, bias=True))
self.w_h_ = nn.Sequential(nn.Conv2d(head_conv * 2, head_conv * 2, kernel_size=3, padding=1, bias=True),
nn.ReLU(inplace=True),
nn.Conv2d(head_conv * 2, 2, kernel_size=1, bias=True))
self.offsets = nn.Sequential(nn.Conv2d(head_conv * 2, head_conv * 2, kernel_size=3, padding=1, bias=True),
nn.ReLU(inplace=True),
nn.Conv2d(head_conv * 2, 2, kernel_size=1, bias=True))
self.votes = nn.Sequential(nn.Conv2d(head_conv * 2, head_conv * 2, kernel_size=3, padding=1, bias=True),
nn.ReLU(inplace=True),
nn.Conv2d(head_conv * 2, num_votes, kernel_size=1, bias=True))
# -------- inmodal features
self.occ = nn.Sequential(nn.Conv2d(head_conv * 2, head_conv * 2, kernel_size=3, padding=1, bias=True),
nn.BatchNorm2d(head_conv * 2),
nn.ReLU(inplace=True),
DCN(head_conv * 2, head_conv * 2, kernel_size=3, stride=1, padding=1, dilation=1, deformable_groups=1),
nn.BatchNorm2d(head_conv * 2),
nn.ReLU(inplace=True),
nn.Conv2d(head_conv * 2, head_conv * 2, kernel_size=3, padding=1, bias=True),
nn.BatchNorm2d(head_conv * 2),
nn.ReLU(inplace=True))
self.codes = nn.Sequential(nn.Conv2d(head_conv * 2, head_conv * 2, kernel_size=3, padding=1, bias=True),
nn.ReLU(inplace=True),
nn.Conv2d(head_conv * 2, num_codes, kernel_size=1, bias=True))
self.voted_hmap = VotingModule(num_votes, num_classes, num_classes)
self.voted_codes = VotingModule(num_votes, num_codes, num_codes)
fill_fc_weights(self.regs)
fill_fc_weights(self.w_h_)
fill_fc_weights(self.occ)
fill_fc_weights(self.offsets)
fill_fc_weights(self.inmodal_conv)
fill_fc_weights(self.amodal_conv)
fill_fc_weights(self.votes)
fill_fc_weights(self.codes)
