def forward(self, x):
out = self.body(x)
# FPN
fpn = self.fpn(out)
# SSH
feature1 = self.ssh1(fpn[0])
feature2 = self.ssh2(fpn[1])
feature3 = self.ssh3(fpn[2])
features = [feature1, feature2, feature3]
bbox_regressions = flops_counter.cat(
[self.BboxHead[i](feature) for i, feature in enumerate(features)],
dim=1)
classifications = flops_counter.cat(
[self.ClassHead[i](feature) for i, feature in enumerate(features)],
dim=1)
ldm_regressions = flops_counter.cat([
self.LandmarkHead[i](feature) for i, feature in enumerate(features)
],
dim=1)
output = (bbox_regressions, self.softmax(classifications),
ldm_regressions)
return output
def forward(self, x):
detection_sources = list()
loc = list()
conf = list()
x = self.conv1(x)
x = self.maxpool1(x)
x = self.conv2(x)
x = self.maxpool2(x)
x = self.inception1(x)
x = self.inception2(x)
x = self.inception3(x)
detection_sources.append(x)
x = self.conv3_1(x)
x = self.conv3_2(x)
detection_sources.append(x)
x = self.conv4_1(x)
x = self.conv4_2(x)
detection_sources.append(x)
for (x, l, c) in zip(detection_sources, self.loc, self.conf):
loc.append(l(x).permute(0, 2, 3, 1))
conf.append(c(x).permute(0, 2, 3, 1))
loc = flops_counter.cat([o.view(o.size(0), -1) for o in loc], 1)
conf = flops_counter.cat([o.view(o.size(0), -1) for o in conf], 1)
output = (loc.view(loc.size(0), -1, 4),
self.softmax(conf.view(conf.size(0), -1, self.num_classes)))
return output
def forward(self, x):
confidences = []
locations = []
start_layer_index = 0
header_index = 0
end_layer_index = 0
for end_layer_index in self.source_layer_indexes:
for layer in self.backbone[start_layer_index: end_layer_index]:
x = layer(x)
y = x
start_layer_index = end_layer_index
confidence, location = self.compute_header(header_index, y)
header_index += 1
confidences.append(confidence)
locations.append(location)
for layer in self.backbone[end_layer_index:]:
x = layer(x)
layer = self.extras
x = layer(x)
confidence, location = self.compute_header(header_index, x)
header_index += 1
confidences.append(confidence)
locations.append(location)
confidences = flops_counter.cat(confidences, 1)
locations = flops_counter.cat(locations, 1)
confidences = self.softmax(confidences)
return locations, confidences
def forward(self, x):
loc = list()
conf = list()
conv1_x = self.inception1(self.conv1(x))
conv2_x = self.inception2(self.maxpool1(conv1_x))
conv3_x = self.inception3(self.conv3(conv2_x))
conv4_x = self.inception4(self.maxpool2(conv3_x))
conv5_x = self.conv5_2(self.conv5_1(conv4_x))
conv6_x = self.conv6_2(self.conv6_1(conv5_x))
# fpn
conv6_x = self.latlayer6(conv6_x)
conv5_x = self.latlayer5(conv5_x)
conv4_x = self.latlayer4(conv4_x)
conv3_x = self.latlayer3(conv3_x)
conv2_x = self.latlayer2(conv2_x)
conv1_x = self.latlayer1(conv1_x)
conv4_x_up = self.upsample(conv4_x)
if conv4_x_up.value[2] != conv3_x.value[2] or conv4_x_up.value[3] != conv3_x.value[3]:
pad = (0, conv3_x.value[3] - conv4_x_up.value[3], 0, conv3_x.value[2] - conv4_x_up.value[2])
conv4_x_up = F.pad(conv4_x_up, pad)
conv3_x = self.smooth3(self.eltmul(conv4_x_up , conv3_x))
conv3_x_up = self.upsample(conv2_x)
if conv3_x_up.value[2] != conv2_x.value[2] or conv3_x_up.value[3] != conv2_x.value[3]:
pad = (0, conv2_x.value[3] - conv3_x_up.value[3], 0, conv2_x.value[2] - conv3_x_up.value[2])
conv3_x_up = F.pad(conv3_x_up, pad)
conv2_x = self.smooth2(self.eltmul(conv3_x_up , conv2_x))
conv2_x_up = self.upsample(conv2_x)
if conv2_x_up.value[2] != conv1_x.value[2] or conv2_x_up.value[3] != conv1_x.value[3]:
pad = (0, conv1_x.value[3] - conv2_x_up.value[3], 0, conv1_x.value[2] - conv2_x_up.value[2])
conv2_x_up = F.pad(conv2_x_up, pad)
conv1_x = self.smooth1(self.eltmul(conv2_x_up , conv1_x))
sources = [conv1_x, conv2_x, conv3_x, conv4_x, conv5_x, conv6_x]
# cpm
sources[0] = self.cpm1(sources[0])
sources[1] = self.cpm2(sources[1])
sources[2] = self.cpm3(sources[2])
sources[3] = self.cpm4(sources[3])
sources[4] = self.cpm5(sources[4])
sources[5] = self.cpm6(sources[5])
# head
featuremap_size = []
for (x, l, c) in zip(sources, self.loc, self.conf):
featuremap_size.append([x.size(2), x.size(3)])
loc.append(l(x).permute(0, 2, 3, 1))
conf.append(c(x).permute(0, 2, 3, 1))
face_loc = flops_counter.cat([o.view(o.size(0), -1) for o in loc], 1)
face_conf = flops_counter.cat([o.view(o.size(0), -1) for o in conf], 1)
return face_loc.view(face_loc.size(0), -1, 4), self.softmax(face_conf.view(face_conf.size(0), -1, 2))
def forward(self, x):
x1_1 = self.relu1(self.cpm1(x))
x1_2 = self.relu2(self.cpm2(x))
x2_1 = self.relu3(self.cpm3(x1_2))
x2_2 = self.relu4(self.cpm4(x1_2))
x3_1 = self.relu5(self.cpm5(x2_2))
return flops_counter.cat([x1_1, x2_1, x3_1], 1)
def forward(self, x):
x = self.conv(x)
x = self.bn(x)
x = flops_counter.cat([x, -x], 1)
# x = F.relu(x, inplace=True)
x = self.relu(x)
return x
def forward(self, x):
detection_sources = list()
loc_data = list()
conf_data = list()
x = self.model1(x)
# x = F.max_pool2d(x, 2)
x = self.pool1(x)
x = self.model2(x)
# x = F.max_pool2d(x, 2)
x = self.pool2(x)
x = self.model3(x)
detection_sources.append(x)
# x = F.max_pool2d(x, 2)
x = self.pool3(x)
x = self.model4(x)
detection_sources.append(x)
# x = F.max_pool2d(x, 2)
x = self.pool4(x)
x = self.model5(x)
detection_sources.append(x)
# x = F.max_pool2d(x, 2)
x = self.pool5(x)
x = self.model6(x)
detection_sources.append(x)
for (x, l, c) in zip(detection_sources, self.loc, self.conf):
# loc_data.append(l(x).permute(0, 2, 3, 1).contiguous())
# conf_data.append(c(x).permute(0, 2, 3, 1).contiguous())
loc_data.append(l(x).permute(0, 2, 3, 1))
conf_data.append(c(x).permute(0, 2, 3, 1))
loc_data = flops_counter.cat([o.view(o.size(0), -1) for o in loc_data], 1)
conf_data = flops_counter.cat([o.view(o.size(0), -1) for o in conf_data], 1)
output = (loc_data.view(loc_data.size(0), -1, 14),
self.softmax(conf_data.view(conf_data.size(0), -1, self.num_classes)))
return output
def forward(self, x):
ssh_3x3_f = self.ssh_3x3(x)
ssh_dimred_f = self.ssh_dimred(x)
ssh_5x5_f = self.ssh_5x5(ssh_dimred_f)
ssh_7x7_f = self.ssh_7x7(ssh_dimred_f)
return self.out_relu(flops_counter.cat([ssh_3x3_f, ssh_5x5_f, ssh_7x7_f], 1))
def forward(self, x):
x0 = self.branch0(x)
x1 = self.branch1(x)
x2 = self.branch2(x)
x3 = self.branch3(x)
out = flops_counter.cat((x0, x1, x2, x3), 1)
out = self.cated_conv(out)
out = self.eltadd(out, x)
return out
def forward(self, x):
x0 = self.branch0(x)
x1 = self.branch1(x)
x2 = self.branch2(x)
out = flops_counter.cat((x0, x1, x2), 1)
out = self.ConvLinear(out)
short = self.shortcut(x)
# out = out * self.scale + short
out = self.eltadd(out * self.scale, short)
out = self.relu(out)
return out
def forward(self, input):
conv3X3 = self.conv3X3(input)
conv5X5_1 = self.conv5X5_1(input)
conv5X5 = self.conv5X5_2(conv5X5_1)
conv7X7_2 = self.conv7X7_2(conv5X5_1)
conv7X7 = self.conv7x7_3(conv7X7_2)
out = flops_counter.cat([conv3X3, conv5X5, conv7X7], dim=1)
# out = F.relu(out)
out = self.relu(out)
return out
def forward(self, x):
x = self.conv1(x)
x = self.conv2(x)
x = self.conv3(x)
conv4_3 = self.conv4(x)
# branch 1
conv5_3 = self.conv5(self.pool4(conv4_3))
conv5_256 = self.conv5_256(conv5_3)
conv5_256_up = self.conv5_256_up(conv5_256)
# branch 2
conv4_256 = self.conv4_256(conv4_3)
# fuse(conv5_256_up, conv4_256)
if conv5_256_up.value[2] != conv4_256.value[3] or conv5_256_up.value[
3] != conv4_256.value[3]:
pad = (0, conv4_256.value[3] - conv5_256_up.value[3], 0,
conv4_256.value[2] - conv5_256_up.value[2])
conv5_256_up = F.pad(conv5_256_up, pad)
conv4_fuse = flops_counter.cat([conv5_256_up, conv4_256], 1)
conv4_fuse_final_dim_red = self.conv4_fuse_final_dim_red(
self.conv4_fuse_final(conv4_fuse))
head1_f = self.head1(conv4_fuse_final_dim_red)
head2_f = self.head2(conv4_fuse_final_dim_red)
head4_f = self.head4(conv4_fuse_final_dim_red)
outs = [head1_f, head2_f, head4_f]
loc = []
conf = []
for i, o in enumerate(outs):
loc += [self.bbox_head[i](o)]
conf += [self.cls_head[i](o)]
loc_cat = flops_counter.cat(loc, 1)
conf_cat = self.softmax(flops_counter.cat(conf, 2))
return loc_cat, conf_cat
def forward(self, x):
ssh_3x3 = self.ssh_3x3(x)
ssh_dimred = self.ssh_dimred(x)
ssh_dimred_relu = self.ssh_dimred_relu(ssh_dimred)
ssh_5x5 = self.ssh_5x5(ssh_dimred_relu)
ssh_7x7_1 = self.ssh_7x7_1(ssh_dimred_relu)
ssh_7x7_1_relu = self.ssh_7x7_1_relu(ssh_7x7_1)
ssh_7x7 = self.ssh_7x7(ssh_7x7_1_relu)
# merge
ssh_output = flops_counter.cat([ssh_3x3, ssh_5x5, ssh_7x7], 1)
ssh_output_relu = self.ssh_output_relu(ssh_output)
return ssh_output_relu
def forward(self, x):
branch1x1 = self.branch1x1(x)
# branch1x1_pool = F.avg_pool2d(x, kernel_size=3, stride=1, padding=1)
branch1x1_pool = self.branch1x1_pool(x)
branch1x1_2 = self.branch1x1_2(branch1x1_pool)
branch3x3_reduce = self.branch3x3_reduce(x)
branch3x3 = self.branch3x3(branch3x3_reduce)
branch3x3_reduce_2 = self.branch3x3_reduce_2(x)
branch3x3_2 = self.branch3x3_2(branch3x3_reduce_2)
branch3x3_3 = self.branch3x3_3(branch3x3_2)
outputs = [branch1x1, branch1x1_2, branch3x3, branch3x3_3]
return flops_counter.cat(outputs, 1)
def forward(self, x):
# x_1 = x[:, :self.inp, :, :]
# x_2 = x[:, self.inp:, :, :]
b, c, h, w = x.value
x_1 = flops_counter.TensorSize([b, self.inp, h, w])
x_2 = flops_counter.TensorSize([b, c - self.inp, h, w])
a_1 = self.conv1x1_1(x_1)
# g_1 = F.sigmoid(self.gate_1(x_1))
g_1 = self.sigmoid1(self.gate_1(x_1))
a_2 = self.conv1x1_2(x_2)
# g_2 = F.sigmoid(self.gate_2(x_2))
g_2 = self.sigmoid2(self.gate_2(x_2))
ret = flops_counter.cat(
(self.eltmul1(a_1, g_1), self.eltmul2(a_2, g_2)), 1)
return ret
def forward(self, x):
# residual
branch1 = self.branch1(x)
branch2a = self.branch2a(x)
branch2b = self.branch2b(branch2a)
branch2c = self.branch2c(branch2b)
branch_sum = self.eltadd(branch1, branch2c)
rescomb = self.rescomb_relu(branch_sum)
# ssh
ssh_1 = self.ssh_1_conv(rescomb)
ssh_dimred = self.ssh_dimred_conv(rescomb)
ssh_dimred = self.ssh_dimred_relu(ssh_dimred)
ssh_2 = self.ssh_2_conv(ssh_dimred)
ssh_3a = self.ssh_3a_conv(ssh_dimred)
ssh_3a = self.ssh_3a_relu(ssh_3a)
ssh_3b = self.ssh_3b_conv(ssh_3a)
ssh_concat = flops_counter.cat([ssh_1, ssh_2, ssh_3b], 1)
ssh_concat = self.concat_relu(ssh_concat)
return ssh_concat
def forward(self, x):
# base
out = self.base_conv(x)
out = self.base_bn(out)
out = self.base_relu(out)
out = self.base_maxpooling(out)
# layer1
out = self.layer1_bottleneck0(out)
out = self.layer1_bottleneck1(out)
out = self.layer1_bottleneck2(out)
# layer2
out = self.layer2_bottleneck0(out)
out = self.layer2_bottleneck1(out)
out = self.layer2_bottleneck2(out)
stage3 = self.layer2_bottleneck3(out)
# layer3
out = self.layer3_bottleneck0(stage3)
out = self.layer3_bottleneck1(out)
out = self.layer3_bottleneck2(out)
out = self.layer3_bottleneck3(out)
out = self.layer3_bottleneck4(out)
stage4 = self.layer3_bottleneck5(out)
# layer4
out = self.layer4_bottleneck0(stage4)
out = self.layer4_bottleneck1(out)
stage5 = self.layer4_bottleneck2(out)
# pn_deconv
p3up = self.p3up_trconv(stage3)
p4up = self.p4up_trconv(stage4)
p5up = self.p5up_trconv(stage5)
# l2norm
p3up = self.p3up_l2norm(p3up)
p4up = self.p4up_l2norm(p4up)
p5up = self.p5up_l2norm(p5up)
# concat
conc = flops_counter.cat((p3up, p4up, p5up), 1)
# detection head - feat
feat = self.feat_conv(conc)
feat = self.feat_bn(feat)
feat = self.feat_relu(feat)
# detection head - class
x_class = self.class_conv(feat)
x_class = self.class_sigmoid(x_class)
# detection head - regr
x_regr = self.regr_conv(feat)
x_regr = self.regr_relu(x_regr)
# detection head - offset
x_offset = self.offset_conv(feat)
x_offset = self.offset_relu(x_offset)
return x_class, x_regr, x_offset
def forward(self, x):
sources = list()
loc = list()
conf = list()
end = 8 if self.model_type == 32 else 6
for k in range(end):
x = self.base[k](x)
s1 = x # (640, 640) -> (320, 320)
for k in range(2, end):
x = self.base[k](x)
s2 = x # (160, 160) -> (80, 80)
for k in range(2, end):
x = self.base[k](x)
s3 = x # (80, 80) -> (40, 40)
for k in range(2, end):
x = self.base[k](x)
s4 = x # (40, 40) -> (20, 20)
for k in range(2, end):
x = self.base[k](x)
s5 = x # (20, 20) -> (10, 10)
for k in range(2, end):
x = self.base[k](x)
s6 = x # (10, 10) -> (5, 5)
sources.append(s6)
# def upsample_add(seq, source, target, up_handle, add_handle):
u1 = upsample_add(self.upfeat[0], s6, s5, self.upsample, self.eltadd)
sources.append(u1)
u2 = upsample_add(self.upfeat[0], u1, s4, self.upsample, self.eltadd)
sources.append(u2)
u3 = upsample_add(self.upfeat[0], u2, s3, self.upsample, self.eltadd)
sources.append(u3)
u4 = upsample_add(self.upfeat[0], u3, s2, self.upsample, self.eltadd)
sources.append(u4)
u5 = upsample_add(self.upfeat[0], u4, s1, self.upsample, self.eltadd)
sources.append(u5)
sources = sources[::-1]
loc_x = self.loc[0](sources[0])
conf_x = self.conf[0](sources[0])
conf_x_b, conf_x_c, conf_x_h, conf_x_w = conf_x.value
conf_x = flops_counter.TensorSize([conf_x_b, 2, conf_x_h, conf_x_w])
loc.append(loc_x.permute(0, 2, 3, 1))
conf.append(conf_x.permute(0, 2, 3, 1))
for i in range(1, len(sources)):
x = sources[i]
conf.append(self.conf[i](x).permute(0, 2, 3, 1))
loc.append(self.loc[i](x).permute(0, 2, 3, 1))
loc = flops_counter.cat([o.view(o.size(0), -1) for o in loc], 1)
conf = flops_counter.cat([o.view(o.size(0), -1) for o in conf], 1)
return loc.view(loc.size(0), -1,
4), self.softmax(conf.view(conf.size(0), -1, 2))
def forward(self, x):
conv1, pool1 = self.layer1(x)
conv2, pool2 = self.layer2(pool1)
conv3, pool3 = self.layer3(pool2)
conv4, pool4 = self.layer4(pool3)
conv5, pool5 = self.layer5(pool4)
conv6 = self.layer6(pool5)
conv7 = self.layer7(conv6)
conv8 = self.layer8(conv7)
lfpn2_on_conv5 = self.lfpn2_on_conv5(conv6, conv5)
lfpn1_on_conv4 = self.lfpn1_on_conv4(lfpn2_on_conv5, conv4)
lfpn0_on_conv3 = self.lfpn0_on_conv3(lfpn1_on_conv4, conv3)
ssh_conv3 = self.ssh_conv3(lfpn0_on_conv3)
ssh_conv4 = self.ssh_conv4(lfpn1_on_conv4)
ssh_conv5 = self.ssh_conv5(lfpn2_on_conv5)
ssh_conv6 = self.ssh_conv6(conv6)
ssh_conv7 = self.ssh_conv7(conv7)
ssh_conv8 = self.ssh_conv8(conv8)
ssh_conv3_l2norm = self.ssh_conv3_l2norm(ssh_conv3)
ssh_conv4_l2norm = self.ssh_conv4_l2norm(ssh_conv4)
ssh_conv5_l2norm = self.ssh_conv5_l2norm(ssh_conv5)
inputs = [
ssh_conv3_l2norm, ssh_conv4_l2norm, ssh_conv5_l2norm, ssh_conv6,
ssh_conv7, ssh_conv8
]
face_confs = []
head_confs = []
for i, feat in enumerate(inputs):
mbox_loc = self.mbox_loc[i](feat)
# print(mbox_loc)
if i == 0:
temp_conf = self.mbox_conf[i](feat)
# face_conf3 = temp_conf[:, 0:3, :, :]
face_conf3 = [x for x in temp_conf.value]
face_conf3[1] = 3
face_conf3 = flops_counter.TensorSize(face_conf3)
# face_conf1 = temp_conf[:, 3:4, :, :]
face_conf1 = [x for x in temp_conf.value]
face_conf1[1] = 1
face_conf1 = flops_counter.TensorSize(face_conf1)
# head_conf3 = temp_conf[:, 4:7, :, :]
head_conf3 = [x for x in temp_conf.value]
head_conf3[1] = 3
head_conf3 = flops_counter.TensorSize(head_conf3)
# head_conf1 = temp_conf[:, 7:, :, :]
head_conf1 = [x for x in temp_conf.value]
head_conf1[1] = 1
head_conf1 = flops_counter.TensorSize(head_conf1)
# face conf
face_conf3_maxin = face_conf3.max(1, keepdim=True)
face_confs.append(
flops_counter.cat([face_conf3_maxin, face_conf1],
1).permute(0, 2, 3, 1))
# head conf
head_conf3_maxin = head_conf3.max(1, keepdim=True)
head_confs.append(
flops_counter.cat([head_conf3_maxin, head_conf1],
1).permute(0, 2, 3, 1))
else:
temp_conf = self.mbox_conf[i](feat)
# face_conf1 = temp_conf[:, 0:1, :, :]
face_conf1 = [x for x in temp_conf.value]
face_conf1[1] = 1
face_conf1 = flops_counter.TensorSize(face_conf1)
# face_conf3 = temp_conf[:, 1:4, :, :]
face_conf3 = [x for x in temp_conf.value]
face_conf3[1] = 3
face_conf3 = flops_counter.TensorSize(face_conf3)
# head_conf = temp_conf[:, 4:, :, :]
head_conf1 = [x for x in temp_conf.value]
head_conf1[1] = 4
head_conf1 = flops_counter.TensorSize(head_conf1)
# face conf
face_conf3_maxin = face_conf3.max(1, keepdim=True)
face_confs.append(
flops_counter.cat([face_conf1, face_conf3_maxin],
1).permute(0, 2, 3, 1))
# head conf
head_confs.append(head_conf1.permute(0, 2, 3, 1))
# print(temp_conf)
face_conf = flops_counter.cat(
[o.view(o.value[0], -1) for o in face_confs], 1)
head_conf = flops_counter.cat(
[o.view(o.value[0], -1) for o in head_confs], 1)
face_conf_softmax = self.softmax(
face_conf.view(face_conf.value[0], -1, 2))
return face_conf_softmax
def forward(self, x):
loc = list()
conf = list()
######
# Backbone
######
conv3_3_x = self.layer1(x)
conv4_3_x = self.layer2(conv3_3_x)
conv5_3_x = self.layer3(conv4_3_x)
fc7_x = self.layer4(conv5_3_x)
conv6_2_x = self.layer5(fc7_x)
conv7_2_x = self.layer6(conv6_2_x)
######
# dsfd specific layers
######
# fpn
lfpn3_fc7_x_up = self.upsample(self.latlayer3(fc7_x))
lfpn3_conv5_3_x = self.smooth3(conv5_3_x)
if lfpn3_fc7_x_up.value[2] != lfpn3_conv5_3_x.value[
2] or lfpn3_fc7_x_up.value[3] != lfpn3_conv5_3_x.value[3]:
pad = (0, lfpn3_conv5_3_x.value[3] - lfpn3_fc7_x_up.value[3], 0,
lfpn3_conv5_3_x.value[2] - lfpn3_fc7_x_up.value[2])
lfpn3_fc7_x_up = F.pad(lfpn3_fc7_x_up, pad)
lfpn3 = self.eltmul(lfpn3_fc7_x_up, lfpn3_conv5_3_x)
lfpn2_lfpn3_up = self.upsample(self.latlayer2(lfpn3))
lfpn2_conv4_3_x = self.smooth2(conv4_3_x)
if lfpn2_lfpn3_up.value[2] != lfpn2_conv4_3_x.value[
2] or lfpn2_lfpn3_up.value[3] != lfpn2_conv4_3_x.value[3]:
pad = (0, lfpn2_conv4_3_x.value[3] - lfpn2_lfpn3_up.value[3], 0,
lfpn2_conv4_3_x.value[2] - lfpn2_lfpn3_up.value[2])
lfpn2_lfpn3_up = F.pad(lfpn2_lfpn3_up, pad)
lfpn2 = self.eltmul(lfpn2_lfpn3_up, lfpn2_conv4_3_x)
lfpn1_lfpn2_up = self.upsample(self.latlayer1(lfpn2))
lfpn1_conv3_3_x = self.smooth1(conv3_3_x)
if lfpn1_lfpn2_up.value[2] != lfpn1_conv3_3_x.value[
2] or lfpn1_lfpn2_up.value[3] != lfpn1_conv3_3_x.value[3]:
pad = (0, lfpn1_conv3_3_x.value[3] - lfpn1_lfpn2_up.value[3], 0,
lfpn1_conv3_3_x.value[2] - lfpn1_lfpn2_up.value[2])
lfpn1_lfpn2_up = F.pad(lfpn1_lfpn2_up, pad)
lfpn1 = self.eltmul(lfpn1_lfpn2_up, lfpn1_conv3_3_x)
conv5_3_x = lfpn3
conv4_3_x = lfpn2
conv3_3_x = lfpn1
# fem
sources = [
conv3_3_x, conv4_3_x, conv5_3_x, fc7_x, conv6_2_x, conv7_2_x
]
sources[0] = self.cpm3_3(sources[0])
sources[1] = self.cpm4_3(sources[1])
sources[2] = self.cpm5_3(sources[2])
sources[3] = self.cpm7(sources[3])
sources[4] = self.cpm6_2(sources[4])
sources[5] = self.cpm7_2(sources[5])
# apply multibox head to source layers
loc = list()
conf = list()
for x, l, c in zip(sources, self.loc, self.conf):
# l(x)
loc.append(l(x).permute(0, 2, 3, 1))
# mio: max_in_out
conf.append(c(x).permute(0, 2, 3, 1))
# face_conf = flops_counter.cat([flops_counter.view([o[1], o[2], 2], (1, -1)) for o in conf], 1)
# output = self.softmax(flops_counter.view(face_conf, (1, -1, 2)))
face_confs = list()
for o in conf:
dst = [i for i in o.value]
dst[-1] = 2
face_confs.append(flops_counter.TensorSize(dst))
face_conf = flops_counter.cat(
[o.view(o.value[0], -1) for o in face_confs], 1)
output = self.softmax(face_conf.view(face_conf.value[0], -1, 2))
return output
def forward(self, x):
out = x
# get conv3_3
for k in range(16):
out = self.vgg16[k](out)
conv3_3 = out # channels = 256
conv3_3_norm = self.l2norm_conv3_3(conv3_3)
# get conv4_3
for k in range(16, 23):
out = self.vgg16[k](out)
conv4_3 = out # channels = 512
conv4_3_norm = self.l2norm_conv4_3(conv4_3)
# get conv5_3
for k in range(23, 30):
out = self.vgg16[k](out)
conv5_3 = out # channels = 512
conv5_3_norm = self.l2norm_conv5_3(conv5_3)
out = self.vgg16[30](out)
# get conv_fc7
out = self.conv_fc6(out)
out = self.relu_fc6(out)
out = self.conv_fc7(out)
out = self.relu_fc7(out)
conv_fc7 = out
# get conv6_2
out = self.conv6_1(out)
out = self.relu_conv6_1(out)
out = self.conv6_2(out)
out = self.relu_conv6_2(out)
conv6_2 = out
# get conv7_2
out = self.conv7_1(out)
out = self.relu_conv7_1(out)
out = self.conv7_2(out)
out = self.relu_conv7_2(out)
conv7_2 = out
# Detection Head - mbox_loc
mbox_loc_inputs = [
self.mbox_loc_conv3_3_norm(conv3_3_norm),
self.mbox_loc_conv4_3_norm(conv4_3_norm),
self.mbox_loc_conv5_3_norm(conv5_3_norm),
self.mbox_loc_conv_fc7(conv_fc7),
self.mbox_loc_conv6_2(conv6_2),
self.mbox_loc_conv7_2(conv7_2)
]
mbox_loc = flops_counter.cat(
[o.permute(0, 2, 3, 1).view(1, -1, 4) for o in mbox_loc_inputs], 1)
# Detection Head - mbox_conf
mbox_conf_conv3_3_norm = self.mbox_conf_conv3_3_norm(conv3_3_norm)
conf1 = [i for i in mbox_conf_conv3_3_norm.value]
conf1[1] = 1
conf1 = flops_counter.TensorSize(conf1)
conf234 = [i for i in mbox_conf_conv3_3_norm.value]
conf234[1] = 3
conf234 = flops_counter.TensorSize(conf234)
conf234 = conf234.max(1, keepdim=True)
mbox_conf_conv3_3_norm = flops_counter.cat([conf1, conf234], 1)
mbox_conf_inputs = [
mbox_conf_conv3_3_norm,
self.mbox_conf_conv4_3_norm(conv4_3_norm),
self.mbox_conf_conv5_3_norm(conv5_3_norm),
self.mbox_conf_conv_fc7(conv_fc7),
self.mbox_conf_conv6_2(conv6_2),
self.mbox_conf_conv7_2(conv7_2)
]
mbox_conf = flops_counter.cat(
[o.permute(0, 2, 3, 1).view(1, -1, 2) for o in mbox_conf_inputs],
1)
mbox_conf = self.softmax(mbox_conf)
return mbox_loc, mbox_conf