def get_extras(source_out_channels,
use_depthwise=False,
layers=(),
activation={
'name': 'ReLU',
'args': {
'inplace': True
}
},
initializer={'name': 'xavier_normal_'},
batch_norm={}):
extras = nn.ModuleList()
in_channels = source_out_channels[-1]
extra_layers = layers
for type_, out_channels in extra_layers:
layers = []
if type_ == 'm':
out_channels = in_channels
layers.append(nn.MaxPool2d(kernel_size=3, stride=2, padding=1))
elif type_ == 's':
layers.append(
conv.Conv2dBn(in_channels,
out_channels // 2,
kernel_size=1,
bias=False,
activation_params=activation,
use_bn=True,
batch_norm_params=batch_norm))
in_channels = out_channels // 2
if use_depthwise:
layers.append(
conv.DepthwiseConv2dBn(in_channels,
out_channels,
kernel_size=3,
stride=2,
padding=1,
bias=False,
activation_params=activation,
use_bn=True,
batch_norm_params=batch_norm))
else:
layers.append(
conv.Conv2dBn(in_channels,
out_channels,
kernel_size=3,
stride=2,
padding=1,
bias=False,
activation_params=activation,
use_bn=True,
batch_norm_params=batch_norm))
elif type_ == '':
layers.append(
conv.Conv2dBn(in_channels,
out_channels // 2,
kernel_size=1,
bias=False,
activation_params=activation,
use_bn=True,
batch_norm_params=batch_norm))
in_channels = out_channels // 2
if use_depthwise:
layers.append(
conv.DepthwiseConv2dBn(in_channels,
out_channels,
kernel_size=3,
bias=False,
activation_params=activation,
use_bn=True,
batch_norm_params=batch_norm))
else:
layers.append(
conv.Conv2dBn(in_channels,
out_channels,
kernel_size=3,
bias=False,
activation_params=activation,
use_bn=True,
batch_norm_params=batch_norm))
else:
raise ValueError(f'Unknown layer type: {type_}')
source_out_channels.append(out_channels)
extras.append(nn.Sequential(*layers))
in_channels = out_channels
initializer_ = functools.partial(getattr(nn.init, initializer['name']),
**initializer.get('args', {}))
def _init_extras(layer):
if isinstance(layer, nn.Conv2d):
initializer_(layer.weight)
layer.bias is not None and nn.init.zeros_(layer.bias)
extras.apply(_init_extras)
return extras
def get_predictor(source_out_channels,
num_boxes,
num_classes,
use_depthwise=False,
num_layers=0,
num_channels=256,
kernel_size=3,
batch_norm={},
activation={
'name': 'ReLU',
'args': {
'inplace': True
}
},
initializer={
'name': 'normal_',
'args': {
'mean': 0,
'std': 0.01
}
},
class_head_bias_init=0):
if num_layers > 0:
assert len(set(source_out_channels)) == 1
predictor = nn.ModuleDict()
norms = nn.ModuleDict()
for head in ['class', 'loc']:
in_channels = source_out_channels[0]
layers = nn.ModuleList()
norms[head] = nn.ModuleList()
for _ in range(num_layers):
if use_depthwise:
layers.append(
conv.DepthwiseConv2dBn(in_channels,
num_channels,
kernel_size=kernel_size,
padding=1,
bias=True,
activation_params=None,
use_bn=False))
else:
layers.append(
conv.Conv2dBn(in_channels,
num_channels,
kernel_size=kernel_size,
padding=1,
bias=True,
activation_params=None,
use_bn=False))
layer_norms = nn.ModuleList()
for _ in source_out_channels:
layer_norms.append(nn.BatchNorm2d(num_channels, **batch_norm))
norms[head].append(layer_norms)
in_channels = num_channels
predictor[head] = layers
activation_ = getattr(nn, activation['name'])(**activation.get('args', {}))
if num_layers > 0:
out_channels = [num_channels] * len(source_out_channels)
else:
out_channels = source_out_channels
initializer_ = functools.partial(getattr(nn.init, initializer['name']),
**initializer.get('args', {}))
def _init_predictor(layer):
if isinstance(layer, nn.Conv2d):
initializer_(layer.weight)
nn.init.zeros_(layer.bias)
predictor.apply(_init_predictor)
def _init_class_head(layer):
initializer_(layer.weight)
nn.init.constant_(layer.bias, class_head_bias_init)
heads = nn.ModuleList()
for in_channels, num_boxes in zip(out_channels, num_boxes):
class_head = nn.Conv2d(in_channels,
num_boxes * num_classes,
kernel_size=3,
padding=1,
bias=True)
loc_head = nn.Conv2d(in_channels,
num_boxes * 4,
kernel_size=3,
padding=1,
bias=True)
class_head.apply(_init_class_head)
loc_head.apply(_init_predictor)
heads.append(nn.ModuleDict({'class': class_head, 'loc': loc_head}))
return (predictor, activation_, norms), heads
def __init__(self,
base,
out_layers,
pyramid_layers,
pyramid_channels,
interpolation_mode='nearest',
activation={
'name': 'ReLU',
'args': {
'inplace': True
}
},
initializer={'name': 'xavier_normal_'},
**kwargs):
super(DepthwiseFeaturePyramid, self).__init__(base, out_layers,
**kwargs)
self.pyramid_layers = pyramid_layers
self.pyramid_channels = pyramid_channels
self.interpolation_mode = interpolation_mode
self.pyramid_lateral = nn.ModuleList()
self.downsample = nn.ModuleList()
self.up_conv = nn.ModuleList()
self.num_outputs = pyramid_layers
base_out_channels = super(DepthwiseFeaturePyramid,
self).get_out_channels()
for in_channels in base_out_channels:
self.pyramid_lateral.append(
nn.Conv2d(in_channels, pyramid_channels, kernel_size=1))
for _ in range(pyramid_layers - len(out_layers)):
paths = nn.ModuleList()
paths.append(
nn.Sequential(
nn.MaxPool2d(kernel_size=2),
conv.Conv2dBn(pyramid_channels,
pyramid_channels // 2,
kernel_size=1,
activation_params=activation)))
paths.append(
conv.DepthwiseConv2dBn(pyramid_channels,
pyramid_channels // 2,
kernel_size=3,
stride=2,
padding=1,
activation_params=activation))
self.downsample.append(paths)
for _ in range(pyramid_layers - 1):
self.up_conv.append(
conv.Conv2dBn(pyramid_channels,
pyramid_channels,
kernel_size=3,
padding=1,
groups=pyramid_channels,
activation_params=activation))
self.pyramid_lateral.apply(self.init_layer)
self.downsample.apply(self.init_layer)
self.up_conv.apply(self.init_layer)
def __init__(self,
base,
out_layers,
num_scales,
num_tums,
base_reduced_channels=[256, 512],
reduced_channels=128,
interpolation_mode='nearest',
use_depthwise=False,
activation={
'name': 'ReLU',
'args': {
'inplace': True
}
},
initializer={'name': 'xavier_normal_'},
tum={
'inner_channels': 256,
'out_channels': 128
},
sfam={'reduction_ratio': 16},
**kwargs):
super(MultilevelFeaturePyramid, self).__init__(base, out_layers,
**kwargs)
assert len(out_layers) == len(base_reduced_channels)
assert num_tums > 0
self.num_outputs = num_scales
self.num_tums = num_tums
self.interpolation_mode = interpolation_mode
self.base_reducers = nn.ModuleList()
base_out_channels = super(MultilevelFeaturePyramid,
self).get_out_channels()
for in_channels, out_channels in zip(base_out_channels,
base_reduced_channels):
self.base_reducers.append(
conv.Conv2dBn(in_channels,
out_channels,
kernel_size=1,
activation_params=activation))
tum.update({'num_scales': num_scales})
update_existing(
tum, {
'interpolation_mode': interpolation_mode,
'use_depthwise': use_depthwise,
'activation': activation
})
self.tum_out_channels = tum['out_channels']
self.tums = nn.ModuleList()
self.reducers = nn.ModuleList()
self.tums.append(
ThinnedUshapeModule(in_channels=sum(base_reduced_channels), **tum))
for i in range(1, num_tums):
self.tums.append(
ThinnedUshapeModule(in_channels=reduced_channels +
self.tum_out_channels,
**tum))
self.reducers.append(
conv.Conv2dBn(sum(base_reduced_channels),
reduced_channels,
kernel_size=1,
activation_params=activation))
sfam.update({
'num_channels': self.tum_out_channels * self.num_tums,
'num_scales': num_scales
})
self.sfam = ScalewiseFeatureAggregationModule(**sfam)
self.base_reducers.apply(self.init_layer)
self.tums.apply(self.init_layer)
self.reducers.apply(self.init_layer)
self.sfam.apply(self.init_layer)
def __init__(self,
source_out_channels,
num_boxes,
num_classes,
use_depthwise,
num_layers=0,
num_channels=256,
kernel_size=3,
batch_norm={},
activation={
'name': 'ReLU',
'args': {
'inplace': True
}
},
initializer={
'name': 'normal_',
'args': {
'mean': 0,
'std': 0.01
}
}):
super(SharedConvPredictor, self).__init__()
if num_layers > 0:
assert len(set(source_out_channels)) == 1
self.convs = nn.ModuleDict()
self.norms = nn.ModuleDict()
for head in ['score', 'loc']:
in_channels = source_out_channels[0]
layers = nn.ModuleList()
self.norms[head] = nn.ModuleList()
for _ in range(num_layers):
if use_depthwise:
layers.append(
conv.DepthwiseConv2dBn(in_channels,
num_channels,
kernel_size=kernel_size,
padding=1,
bias=True,
activation_params=None,
use_bn=False))
else:
layers.append(
conv.Conv2dBn(in_channels,
num_channels,
kernel_size=kernel_size,
padding=1,
bias=True,
activation_params=None,
use_bn=False))
layer_norms = nn.ModuleList()
for _ in source_out_channels:
layer_norms.append(
nn.BatchNorm2d(num_channels, **batch_norm))
self.norms[head].append(layer_norms)
in_channels = num_channels
self.convs[head] = layers
self.activation = getattr(
nn, activation['name'])(**activation.get('args', {}))
self.out_channels = [num_channels] * len(source_out_channels)
initializer_ = functools.partial(getattr(nn.init, initializer['name']),
**initializer.get('args', {}))
def _init_predictor(layer):
if isinstance(layer, nn.Conv2d):
initializer_(layer.weight)
nn.init.zeros_(layer.bias)
self.convs.apply(_init_predictor)