def __init__(self, num_classes=80, compound_coef=0, load_weights=False, **kwargs):
super(EfficientDetBackbone, self).__init__()
self.compound_coef = compound_coef
self.backbone_compound_coef = [0, 1, 2, 3, 4, 5, 6, 6]
self.fpn_num_filters = [64, 88, 112, 160, 224, 288, 384, 384]
self.fpn_cell_repeats = [3, 4, 5, 6, 7, 7, 8, 8]
self.input_sizes = [512, 640, 768, 896, 1024, 1280, 1280, 1536]
self.box_class_repeats = [3, 3, 3, 4, 4, 4, 5, 5]
self.anchor_scale = [4., 4., 4., 4., 4., 4., 4., 5.]
self.aspect_ratios = kwargs.get('ratios', [(1.0, 1.0), (1.4, 0.7), (0.7, 1.4)])
self.num_scales = len(kwargs.get('scales', [2 ** 0, 2 ** (1.0 / 3.0), 2 ** (2.0 / 3.0)]))
conv_channel_coef = {
# the channels of P3/P4/P5.
0: [40, 112, 320],
1: [40, 112, 320],
2: [48, 120, 352],
3: [48, 136, 384],
4: [56, 160, 448],
5: [64, 176, 512],
6: [72, 200, 576],
7: [72, 200, 576],
}
self.num_classes = num_classes
# num_anchors = len(self.aspect_ratios) * self.num_scales
self.backbone_net = EfficientNet(self.backbone_compound_coef[compound_coef], load_weights)
self.bifpn = nn.Sequential(
*[BiFPN(self.fpn_num_filters[self.compound_coef],
conv_channel_coef[compound_coef],
True if _ == 0 else False,
attention=True if compound_coef < 6 else False)
for _ in range(self.fpn_cell_repeats[compound_coef])])
self.head = DetHead(self.num_classes, self.fpn_num_filters[compound_coef])
def __init__(self,
num_anchors=9,
num_classes=80,
compound_coef=0,
load_weights=False,
**kwargs):
super(EfficientDetBackbone, self).__init__()
self.compound_coef = compound_coef
self.fpn_num_filters = [64, 88, 112, 160, 224, 288, 384, 384]
self.fpn_cell_repeats = [3, 4, 5, 6, 7, 7, 8, 8]
self.input_sizes = [512, 640, 768, 896, 1024, 1280, 1280, 1536]
self.box_class_repeats = [3, 3, 3, 4, 4, 4, 5, 5]
self.anchor_scale = [4., 4., 4., 4., 4., 4., 4., 5.]
self.aspect_ratios = [(1.0, 1.0), (1.4, 0.7), (0.7, 1.4)]
self.num_scales = 3
conv_channel_coef = {
# the channels of P3/P4/P5.
0: [40, 112, 320],
1: [40, 112, 320],
2: [48, 120, 352],
3: [48, 136, 384],
4: [56, 160, 448],
5: [64, 176, 512],
6: [72, 200, 576],
}
num_anchors = len(self.aspect_ratios) * self.num_scales
self.bifpn = nn.Sequential(*[
BiFPN(self.fpn_num_filters[self.compound_coef],
conv_channel_coef[compound_coef],
True if _ == 0 else False,
attention=True if compound_coef < 6 else False)
for _ in range(self.fpn_cell_repeats[compound_coef])
])
self.num_classes = num_classes
self.regressor = Regressor(
in_channels=self.fpn_num_filters[self.compound_coef],
num_anchors=num_anchors,
num_layers=self.box_class_repeats[self.compound_coef])
self.classifier = Classifier(
in_channels=self.fpn_num_filters[self.compound_coef],
num_anchors=num_anchors,
num_classes=num_classes,
num_layers=self.box_class_repeats[self.compound_coef])
self.anchors = Anchors(anchor_scale=self.anchor_scale[compound_coef],
**kwargs)
for m in self.modules():
if isinstance(m, nn.Conv2d):
n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
m.weight.data.normal_(0, math.sqrt(2. / n))
elif isinstance(m, nn.BatchNorm2d):
m.weight.data.fill_(1)
m.bias.data.zero_()
self.backbone_net = EfficientNet(compound_coef, load_weights)
def __init__(self,
num_classes=80,
compound_coef=0,
load_weights=False,
**kwargs):
super(EfficientDetBackbone, self).__init__()
self.compound_coef = compound_coef
self.backbone_compound_coef = [0, 1, 2, 3, 4, 5, 6, 6, 7]
self.fpn_num_filters = [64, 88, 112, 160, 224, 288, 384, 384, 384]
self.fpn_cell_repeats = [3, 4, 5, 6, 7, 7, 8, 8, 8]
self.input_sizes = [512, 640, 768, 896, 1024, 1280, 1280, 1536, 1536]
self.box_class_repeats = [3, 3, 3, 4, 4, 4, 5, 5, 5]
self.pyramid_levels = [5, 5, 5, 5, 5, 5, 5, 5, 6]
# self.anchor_scale不同Stride级别的金字塔尺度,都是两倍两倍缩放
self.anchor_scale = [4., 4., 4., 4., 4., 4., 4., 5., 4.]
self.aspect_ratios = kwargs.get('ratios', [(1.0, 1.0), (1.4, 0.7),
(0.7, 1.4)])
# 同一个金字塔尺度上再分3个小尺度3个小比例
self.num_scales = len(
kwargs.get('scales', [2**0, 2**(1.0 / 3.0), 2**(2.0 / 3.0)]))
conv_channel_coef = {
# the channels of P3/P4/P5.
0: [40, 112, 320],
1: [40, 112, 320],
2: [48, 120, 352],
3: [48, 136, 384],
4: [56, 160, 448],
5: [64, 176, 512],
6: [72, 200, 576],
7: [72, 200, 576],
8: [80, 224, 640],
}
num_anchors = len(self.aspect_ratios) * self.num_scales
# print(len(self.aspect_ratios))
# print(self.num_scales)
# exit()
self.bifpn = nn.Sequential(*[
BiFPN(self.fpn_num_filters[self.compound_coef],
conv_channel_coef[compound_coef],
True if _ == 0 else False,
attention=True if compound_coef < 6 else False,
use_p8=compound_coef > 7)
for _ in range(self.fpn_cell_repeats[compound_coef])
])
self.num_classes = num_classes
self.regressor = Regressor(
in_channels=self.fpn_num_filters[self.compound_coef],
num_anchors=num_anchors,
num_layers=self.box_class_repeats[self.compound_coef],
pyramid_levels=self.pyramid_levels[self.compound_coef])
self.classifier = Classifier(
in_channels=self.fpn_num_filters[self.compound_coef],
num_anchors=num_anchors,
num_classes=num_classes,
num_layers=self.box_class_repeats[self.compound_coef],
pyramid_levels=self.pyramid_levels[self.compound_coef])
self.anchors = Anchors(
anchor_scale=self.anchor_scale[compound_coef],
pyramid_levels=(
torch.arange(self.pyramid_levels[self.compound_coef]) +
3).tolist(),
**kwargs)
self.backbone_net = EfficientNet(
self.backbone_compound_coef[compound_coef], load_weights)
def __init__(self,
num_classes=80,
compound_coef=0,
load_weights=False,
onnx_export=False,
train_mode=False,
batch_size=1,
**kwargs):
super(EfficientDetBackbone, self).__init__()
self.compound_coef = compound_coef
self.backbone_compound_coef = [0, 1, 2, 3, 4, 5, 6, 6]
self.fpn_num_filters = [64, 88, 112, 160, 224, 288, 384, 384]
self.fpn_cell_repeats = [3, 4, 5, 6, 7, 7, 8, 8]
self.input_sizes = [512, 640, 768, 896, 1024, 1280, 1280, 1536]
self.box_class_repeats = [3, 3, 3, 4, 4, 4, 5, 5]
self.anchor_scale = [4., 4., 4., 4., 4., 4., 4., 5.]
self.aspect_ratios = kwargs.get('ratios', [(1.0, 1.0), (1.4, 0.7),
(0.7, 1.4)])
self.num_scales = len(
kwargs.get('scales', [2**0, 2**(1.0 / 3.0), 2**(2.0 / 3.0)]))
conv_channel_coef = {
# the channels of P3/P4/P5.
0: [40, 112, 320],
1: [40, 112, 320],
2: [48, 120, 352],
3: [48, 136, 384],
4: [56, 160, 448],
5: [64, 176, 512],
6: [72, 200, 576],
7: [72, 200, 576],
}
num_anchors = len(self.aspect_ratios) * self.num_scales
head_image_size = calculate_output_image_size(
self.input_sizes[compound_coef], 8)
if train_mode:
self.bifpn = nn.Sequential(*[
BiFPN(self.fpn_num_filters[self.compound_coef],
conv_channel_coef[compound_coef],
True if _ == 0 else False,
onnx_export=onnx_export,
attention=True if compound_coef < 6 else False,
image_size=head_image_size)
for _ in range(self.fpn_cell_repeats[compound_coef])
])
else:
self.bifpn = nn.Sequential(*[
BiFPN_infer(self.fpn_num_filters[self.compound_coef],
conv_channel_coef[compound_coef],
True if _ == 0 else False,
index=idx,
onnx_export=onnx_export,
attention=True if compound_coef < 6 else False,
image_size=head_image_size)
for idx, _ in enumerate(
range(self.fpn_cell_repeats[compound_coef]))
])
self.num_classes = num_classes
self.regressor = Regressor(
in_channels=self.fpn_num_filters[self.compound_coef],
num_anchors=num_anchors,
num_layers=self.box_class_repeats[self.compound_coef],
onnx_export=onnx_export,
image_size=head_image_size,
compound_coef=compound_coef,
batch_size=batch_size)
self.classifier = Classifier(
in_channels=self.fpn_num_filters[self.compound_coef],
num_anchors=num_anchors,
num_classes=num_classes,
num_layers=self.box_class_repeats[self.compound_coef],
onnx_export=onnx_export,
image_size=head_image_size,
compound_coef=compound_coef,
batch_size=batch_size)
self.anchors = Anchors(anchor_scale=self.anchor_scale[compound_coef],
**kwargs)
self.backbone_net = EfficientNet(
self.backbone_compound_coef[compound_coef], load_weights)
def __init__(self,
num_classes=80,
compound_coef=0,
load_weights=False,
onnx_export=False,
**kwargs):
super(EfficientDetBackbone, self).__init__()
self.compound_coef = compound_coef
self.backbone_compound_coef = [0, 1, 2, 3, 4, 5, 6, 6]
self.fpn_num_filters = [64, 88, 112, 160, 224, 288, 384, 384]
self.fpn_cell_repeats = [3, 4, 5, 6, 7, 7, 8, 8]
self.input_sizes = [512, 640, 768, 896, 1024, 1280, 1280, 1536]
self.box_class_repeats = [3, 3, 3, 4, 4, 4, 5, 5]
self.anchor_scale = [4., 4., 4., 4., 4., 4., 4., 5.]
self.aspect_ratios = kwargs.get('ratios', [(1.0, 1.0), (1.4, 0.7),
(0.7, 1.4)])
self.num_scales = len(
kwargs.get('scales', [2**0, 2**(1.0 / 3.0), 2**(2.0 / 3.0)]))
conv_channel_coef = {
# the channels of P3/P4/P5.
0: [40, 112, 320],
1: [40, 112, 320],
2: [48, 120, 352],
3: [48, 136, 384],
4: [56, 160, 448],
5: [64, 176, 512],
6: [72, 200, 576],
7: [72, 200, 576],
}
num_anchors = len(self.aspect_ratios) * self.num_scales
self.bifpn = nn.Sequential(*[
BiFPN(self.fpn_num_filters[self.compound_coef],
conv_channel_coef[compound_coef],
True if _ == 0 else False,
onnx_export=onnx_export,
attention=True if compound_coef < 6 else False)
for _ in range(self.fpn_cell_repeats[compound_coef])
])
self.num_classes = num_classes
self.regressor = Regressor(
in_channels=self.fpn_num_filters[self.compound_coef],
num_anchors=num_anchors,
num_layers=self.box_class_repeats[self.compound_coef],
onnx_export=onnx_export)
self.classifier = Classifier(
in_channels=self.fpn_num_filters[self.compound_coef],
num_anchors=num_anchors,
num_classes=num_classes,
num_layers=self.box_class_repeats[self.compound_coef],
onnx_export=onnx_export)
self.anchors = Anchors(anchor_scale=self.anchor_scale[compound_coef],
**kwargs)
self.backbone_net = EfficientNet(
self.backbone_compound_coef[compound_coef], load_weights)
print("Input size is {}".format(self.input_sizes[self.compound_coef]))
self.forward_anchors = self.anchors(
(self.input_sizes[self.compound_coef],
self.input_sizes[self.compound_coef]))
self.anchor_data = transform_anchors(
self.forward_anchors) / self.input_sizes[self.compound_coef]
self.total_anchors = self.anchor_data.shape[0]