def __init__(self, config, anchors, num_cls, growth_rate=32, block_config=(6, 12, 24, 16), num_init_features=64, bn_size=4, drop_rate=0):
nn.Module.__init__(self)
# First convolution
self.layers = nn.Sequential(OrderedDict([
('conv0', nn.Conv2d(3, num_init_features, kernel_size=7, stride=2, padding=3, bias=False)),
('norm0', nn.BatchNorm2d(num_init_features)),
('relu0', nn.ReLU(inplace=True)),
('pool0', nn.MaxPool2d(kernel_size=3, stride=2, padding=1)),
]))
# Each denseblock
num_features = num_init_features
for i, num_layers in enumerate(block_config):
block = _DenseBlock(num_layers=num_layers, num_input_features=num_features, bn_size=bn_size, growth_rate=growth_rate, drop_rate=drop_rate)
self.layers.add_module('denseblock%d' % (i + 1), block)
num_features = num_features + num_layers * growth_rate
if i != len(block_config) - 1:
trans = _Transition(num_input_features=num_features, num_output_features=num_features // 2)
self.layers.add_module('transition%d' % (i + 1), trans)
num_features = num_features // 2
# Final batch norm
self.layers.add_module('norm5', nn.BatchNorm2d(num_features))
self.layers.add_module('conv', nn.Conv2d(num_features, model.output_channels(len(anchors), num_cls), 1))
def __init__(self, config, anchors, num_cls):
nn.Module.__init__(self)
self.layers = nn.Sequential(
BasicConv2d(3, 32, kernel_size=3, stride=2),
BasicConv2d(32, 32, kernel_size=3, stride=1),
BasicConv2d(32, 64, kernel_size=3, stride=1, padding=1),
Mixed_3a(),
Mixed_4a(),
Mixed_5a(),
Inception_A(),
Inception_A(),
Inception_A(),
Inception_A(),
Reduction_A(), # Mixed_6a
Inception_B(),
Inception_B(),
Inception_B(),
Inception_B(),
Inception_B(),
Inception_B(),
Inception_B(),
Reduction_B(), # Mixed_7a
Inception_C(),
Inception_C(),
Inception_C(),
nn.Conv2d(1536, model.output_channels(len(anchors), num_cls), 1),
)
def __init__(self, config_channels, anchors, num_cls, growth_rate=32, block_config=(6, 12, 24, 16), num_init_features=64, bn_size=4, drop_rate=0):
nn.Module.__init__(self)
# First convolution
self.features = nn.Sequential(OrderedDict([
('conv0', nn.Conv2d(3, num_init_features, kernel_size=7, stride=2, padding=3, bias=False)),
('norm0', nn.BatchNorm2d(num_init_features)),
('relu0', nn.ReLU(inplace=True)),
('pool0', nn.MaxPool2d(kernel_size=3, stride=2, padding=1)),
]))
# Each denseblock
num_features = num_init_features
for i, num_layers in enumerate(block_config):
block = _DenseBlock(num_layers=num_layers, num_input_features=num_features, bn_size=bn_size, growth_rate=growth_rate, drop_rate=drop_rate)
self.features.add_module('denseblock%d' % (i + 1), block)
num_features = num_features + num_layers * growth_rate
if i != len(block_config) - 1:
trans = _Transition(num_input_features=num_features, num_output_features=num_features // 2)
self.features.add_module('transition%d' % (i + 1), trans)
num_features = num_features // 2
# Final batch norm
self.features.add_module('norm5', nn.BatchNorm2d(num_features))
self.features.add_module('conv', nn.Conv2d(num_features, model.output_channels(len(anchors), num_cls), 1))
# init
for m in self.modules():
if isinstance(m, nn.Conv2d):
m.weight = nn.init.kaiming_normal(m.weight)
elif isinstance(m, nn.BatchNorm2d):
m.weight.data.fill_(1)
m.bias.data.zero_()
def __init__(self, config_channels, anchors, num_cls):
nn.Module.__init__(self)
self.layers = nn.Sequential(
conv_bn( 3, 32, 2),
conv_unit(32, 64, 1),
conv_unit(64, 128, 2),
conv_unit(128, 128, 1),
conv_unit(128, 256, 2),
conv_unit(256, 256, 1),
conv_unit(256, 512, 2),
conv_unit(512, 512, 1),
conv_unit(512, 512, 1),
conv_unit(512, 512, 1),
conv_unit(512, 512, 1),
conv_unit(512, 512, 1),
conv_unit(512, 1024, 2),
conv_unit(1024, 1024, 1),
nn.Conv2d(1024, model.output_channels(len(anchors), num_cls), 1)
)
for m in self.modules():
if isinstance(m, nn.Conv2d):
m.weight = nn.init.kaiming_normal(m.weight)
elif isinstance(m, nn.BatchNorm2d):
m.weight.data.fill_(1)
m.bias.data.zero_()
def __init__(self, config_channels, anchors, num_cls):
nn.Module.__init__(self)
layers = []
layers.append(conv_bn(config_channels.channels, config_channels(32, 'layers.%d.conv.weight' % len(layers)), 2))
layers.append(conv_unit(config_channels.channels, config_channels(64, 'layers.%d.pw.conv.weight' % len(layers)), 1))
layers.append(conv_unit(config_channels.channels, config_channels(128, 'layers.%d.pw.conv.weight' % len(layers)), 2))
layers.append(conv_unit(config_channels.channels, config_channels(128, 'layers.%d.pw.conv.weight' % len(layers)), 1))
layers.append(conv_unit(config_channels.channels, config_channels(256, 'layers.%d.pw.conv.weight' % len(layers)), 2))
layers.append(conv_unit(config_channels.channels, config_channels(256, 'layers.%d.pw.conv.weight' % len(layers)), 1))
layers.append(conv_unit(config_channels.channels, config_channels(512, 'layers.%d.pw.conv.weight' % len(layers)), 2))
layers.append(conv_unit(config_channels.channels, config_channels(512, 'layers.%d.pw.conv.weight' % len(layers)), 1))
layers.append(conv_unit(config_channels.channels, config_channels(512, 'layers.%d.pw.conv.weight' % len(layers)), 1))
layers.append(conv_unit(config_channels.channels, config_channels(512, 'layers.%d.pw.conv.weight' % len(layers)), 1))
layers.append(conv_unit(config_channels.channels, config_channels(512, 'layers.%d.pw.conv.weight' % len(layers)), 1))
layers.append(conv_unit(config_channels.channels, config_channels(512, 'layers.%d.pw.conv.weight' % len(layers)), 1))
layers.append(conv_unit(config_channels.channels, config_channels(1024, 'layers.%d.pw.conv.weight' % len(layers)), 2))
layers.append(conv_unit(config_channels.channels, config_channels(1024, 'layers.%d.pw.conv.weight' % len(layers)), 1))
layers.append(nn.Conv2d(config_channels.channels, model.output_channels(len(anchors), num_cls), 1))
self.layers = nn.Sequential(*layers)
for m in self.modules():
if isinstance(m, nn.Conv2d):
m.weight = nn.init.kaiming_normal(m.weight)
elif isinstance(m, nn.BatchNorm2d):
m.weight.data.fill_(1)
m.bias.data.zero_()
def __init__(self, config_channels, anchors, num_cls):
nn.Module.__init__(self)
channels = 16
layers = []
for _ in range(5):
layers.append(Conv2d_BatchNorm(config_channels.channels, config_channels(channels, 'layers.%d.conv.weight' % len(layers)), 3, same_padding=True))
layers.append(nn.MaxPool2d(kernel_size=2))
channels *= 2
layers.append(Conv2d_BatchNorm(config_channels.channels, config_channels(channels, 'layers.%d.conv.weight' % len(layers)), 3, same_padding=True))
layers.append(nn.ConstantPad2d((0, 1, 0, 1), float(np.finfo(np.float32).min)))
layers.append(nn.MaxPool2d(kernel_size=2, stride=1))
channels *= 2
for _ in range(2):
layers.append(Conv2d_BatchNorm(config_channels.channels, config_channels(channels, 'layers.%d.conv.weight' % len(layers)), 3, same_padding=True))
layers.append(Conv2d(config_channels.channels, model.output_channels(len(anchors), num_cls), 1, act=False))
self.layers = nn.Sequential(*layers)
# init
for m in self.modules():
if isinstance(m, nn.Conv2d):
m.weight = nn.init.xavier_normal(m.weight)
elif isinstance(m, nn.BatchNorm2d):
m.weight.data.fill_(1)
m.bias.data.zero_()
def __init__(self, config_channels, anchors, num_cls, ratio=1):
nn.Module.__init__(self)
features = []
bn = config_channels.config.getboolean('batch_norm', 'enable')
features.append(Conv2d(config_channels.channels, config_channels(32, 'features.%d.conv.weight' % len(features)), kernel_size=3, stride=2, bn=bn))
features.append(Conv2d(config_channels.channels, config_channels(32, 'features.%d.conv.weight' % len(features)), kernel_size=3, stride=1, bn=bn))
features.append(Conv2d(config_channels.channels, config_channels(64, 'features.%d.conv.weight' % len(features)), kernel_size=3, stride=1, padding=1, bn=bn))
features.append(Mixed_3a(config_channels, 'features.%d' % len(features), bn=bn, ratio=ratio))
features.append(Mixed_4a(config_channels, 'features.%d' % len(features), bn=bn, ratio=ratio))
features.append(Mixed_5a(config_channels, 'features.%d' % len(features), bn=bn, ratio=ratio))
features.append(Inception_A(config_channels, 'features.%d' % len(features), bn=bn, ratio=ratio))
features.append(Inception_A(config_channels, 'features.%d' % len(features), bn=bn, ratio=ratio))
features.append(Inception_A(config_channels, 'features.%d' % len(features), bn=bn, ratio=ratio))
features.append(Inception_A(config_channels, 'features.%d' % len(features), bn=bn, ratio=ratio))
features.append(Reduction_A(config_channels, 'features.%d' % len(features), bn=bn, ratio=ratio)) # Mixed_6a
features.append(Inception_B(config_channels, 'features.%d' % len(features), bn=bn, ratio=ratio))
features.append(Inception_B(config_channels, 'features.%d' % len(features), bn=bn, ratio=ratio))
features.append(Inception_B(config_channels, 'features.%d' % len(features), bn=bn, ratio=ratio))
features.append(Inception_B(config_channels, 'features.%d' % len(features), bn=bn, ratio=ratio))
features.append(Inception_B(config_channels, 'features.%d' % len(features), bn=bn, ratio=ratio))
features.append(Inception_B(config_channels, 'features.%d' % len(features), bn=bn, ratio=ratio))
features.append(Inception_B(config_channels, 'features.%d' % len(features), bn=bn, ratio=ratio))
features.append(Reduction_B(config_channels, 'features.%d' % len(features), bn=bn, ratio=ratio)) # Mixed_7a
features.append(Inception_C(config_channels, 'features.%d' % len(features), bn=bn, ratio=ratio))
features.append(Inception_C(config_channels, 'features.%d' % len(features), bn=bn, ratio=ratio))
features.append(Inception_C(config_channels, 'features.%d' % len(features), bn=bn, ratio=ratio))
features.append(nn.Conv2d(config_channels.channels, model.output_channels(len(anchors), num_cls), 1))
self.features = nn.Sequential(*features)
self.init(config_channels)
def __init__(self, config, anchors, num_cls, transform_input=False):
nn.Module.__init__(self)
self.transform_input = transform_input
self.Conv2d_1a_3x3 = BasicConv2d(3, 32, kernel_size=3, stride=2)
self.Conv2d_2a_3x3 = BasicConv2d(32, 32, kernel_size=3)
self.Conv2d_2b_3x3 = BasicConv2d(32, 64, kernel_size=3, padding=1)
self.Conv2d_3b_1x1 = BasicConv2d(64, 80, kernel_size=1)
self.Conv2d_4a_3x3 = BasicConv2d(80, 192, kernel_size=3)
self.Mixed_5b = InceptionA(192, pool_features=32)
self.Mixed_5c = InceptionA(256, pool_features=64)
self.Mixed_5d = InceptionA(288, pool_features=64)
self.Mixed_6a = InceptionB(288)
self.Mixed_6b = InceptionC(768, channels_7x7=128)
self.Mixed_6c = InceptionC(768, channels_7x7=160)
self.Mixed_6d = InceptionC(768, channels_7x7=160)
self.Mixed_6e = InceptionC(768, channels_7x7=192)
# aux_logits
self.Mixed_7a = InceptionD(768)
self.Mixed_7b = InceptionE(1280)
self.Mixed_7c = InceptionE(2048)
self.conv = nn.Conv2d(2048, model.output_channels(len(anchors), num_cls), 1)
for m in self.modules():
if isinstance(m, nn.Conv2d) or isinstance(m, nn.Linear):
stddev = m.stddev if hasattr(m, 'stddev') else 0.1
X = stats.truncnorm(-2, 2, scale=stddev)
values = torch.Tensor(X.rvs(m.weight.data.numel()))
m.weight.data.copy_(values)
elif isinstance(m, nn.BatchNorm2d):
m.weight.data.fill_(1)
m.bias.data.zero_()
def __init__(self, config, anchors, num_cls, block, layers):
self.inplanes = 64
nn.Module.__init__(self)
self.conv1 = nn.Conv2d(3,
64,
kernel_size=7,
stride=2,
padding=3,
bias=False)
self.bn1 = nn.BatchNorm2d(64)
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)
self.conv = nn.Conv2d(512,
model.output_channels(len(anchors), num_cls), 1)
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_()
def __init__(self, config_channels, anchors, num_cls, stride=2):
nn.Module.__init__(self)
self.stride = stride
channels = 32
layers = []
# layers1
for _ in range(2):
layers.append(Conv2d_BatchNorm(config_channels.channels, config_channels(channels, 'layers1.%d.conv.weight' % len(layers)), 3, same_padding=True))
layers.append(nn.MaxPool2d(kernel_size=2))
channels *= 2
# down 4
for _ in range(2):
layers.append(Conv2d_BatchNorm(config_channels.channels, config_channels(channels, 'layers1.%d.conv.weight' % len(layers)), 3, same_padding=True))
layers.append(Conv2d_BatchNorm(config_channels.channels, config_channels(channels // 2, 'layers1.%d.conv.weight' % len(layers)), 1))
layers.append(Conv2d_BatchNorm(config_channels.channels, config_channels(channels, 'layers1.%d.conv.weight' % len(layers)), 3, same_padding=True))
layers.append(nn.MaxPool2d(kernel_size=2))
channels *= 2
# down 16
for _ in range(2):
layers.append(Conv2d_BatchNorm(config_channels.channels, config_channels(channels, 'layers1.%d.conv.weight' % len(layers)), 3, same_padding=True))
layers.append(Conv2d_BatchNorm(config_channels.channels, config_channels(channels // 2, 'layers1.%d.conv.weight' % len(layers)), 1))
layers.append(Conv2d_BatchNorm(config_channels.channels, config_channels(channels, 'layers1.%d.conv.weight' % len(layers)), 3, same_padding=True))
self.layers1 = nn.Sequential(*layers)
# layers2
layers = []
layers.append(nn.MaxPool2d(kernel_size=2))
channels *= 2
# down 32
for _ in range(2):
layers.append(Conv2d_BatchNorm(config_channels.channels, config_channels(channels, 'layers2.%d.conv.weight' % len(layers)), 3, same_padding=True))
layers.append(Conv2d_BatchNorm(config_channels.channels, config_channels(channels // 2, 'layers2.%d.conv.weight' % len(layers)), 1))
for _ in range(3):
layers.append(Conv2d_BatchNorm(config_channels.channels, config_channels(channels, 'layers2.%d.conv.weight' % len(layers)), 3, same_padding=True))
self.layers2 = nn.Sequential(*layers)
self.passthrough = Conv2d_BatchNorm(self.layers1[-1].conv.weight.size(0), config_channels(64, 'passthrough.conv.weight'), 1)
# layers3
layers = []
layers.append(Conv2d_BatchNorm(self.passthrough.conv.weight.size(0) * self.stride * self.stride + self.layers2[-1].conv.weight.size(0), config_channels(1024, 'layers3.%d.conv.weight' % len(layers)), 3, same_padding=True))
layers.append(Conv2d(config_channels.channels, model.output_channels(len(anchors), num_cls), 1, act=False))
self.layers3 = nn.Sequential(*layers)
# init
for m in self.modules():
if isinstance(m, nn.Conv2d):
m.weight = nn.init.kaiming_normal(m.weight)
elif isinstance(m, nn.BatchNorm2d):
m.weight.data.fill_(1)
m.bias.data.zero_()
def __init__(self, config_channels, anchors, num_cls, stride=2):
nn.Module.__init__(self)
self.stride = stride
channels = 32
layers = []
# layers1
for _ in range(2):
layers.append(Conv2d_BatchNorm(config_channels.channels, config_channels(channels, 'layers1.%d.conv.weight' % len(layers)), 3, same_padding=True))
layers.append(nn.MaxPool2d(kernel_size=2))
channels *= 2
# down 4
for _ in range(2):
layers.append(Conv2d_BatchNorm(config_channels.channels, config_channels(channels, 'layers1.%d.conv.weight' % len(layers)), 3, same_padding=True))
layers.append(Conv2d_BatchNorm(config_channels.channels, config_channels(channels // 2, 'layers1.%d.conv.weight' % len(layers)), 1))
layers.append(Conv2d_BatchNorm(config_channels.channels, config_channels(channels, 'layers1.%d.conv.weight' % len(layers)), 3, same_padding=True))
layers.append(nn.MaxPool2d(kernel_size=2))
channels *= 2
# down 16
for _ in range(2):
layers.append(Conv2d_BatchNorm(config_channels.channels, config_channels(channels, 'layers1.%d.conv.weight' % len(layers)), 3, same_padding=True))
layers.append(Conv2d_BatchNorm(config_channels.channels, config_channels(channels // 2, 'layers1.%d.conv.weight' % len(layers)), 1))
layers.append(Conv2d_BatchNorm(config_channels.channels, config_channels(channels, 'layers1.%d.conv.weight' % len(layers)), 3, same_padding=True))
self.layers1 = nn.Sequential(*layers)
# layers2
layers = []
layers.append(nn.MaxPool2d(kernel_size=2))
channels *= 2
# down 32
for _ in range(2):
layers.append(Conv2d_BatchNorm(config_channels.channels, config_channels(channels, 'layers2.%d.conv.weight' % len(layers)), 3, same_padding=True))
layers.append(Conv2d_BatchNorm(config_channels.channels, config_channels(channels // 2, 'layers2.%d.conv.weight' % len(layers)), 1))
for _ in range(3):
layers.append(Conv2d_BatchNorm(config_channels.channels, config_channels(channels, 'layers2.%d.conv.weight' % len(layers)), 3, same_padding=True))
self.layers2 = nn.Sequential(*layers)
self.passthrough = Conv2d_BatchNorm(self.layers1[-1].conv.weight.size(0), config_channels(64, 'passthrough.conv.weight'), 1)
# layers3
layers = []
layers.append(Conv2d_BatchNorm(self.passthrough.conv.weight.size(0) * self.stride * self.stride + self.layers2[-1].conv.weight.size(0), config_channels(1024, 'layers3.%d.conv.weight' % len(layers)), 3, same_padding=True))
layers.append(Conv2d(config_channels.channels, model.output_channels(len(anchors), num_cls), 1, act=False))
self.layers3 = nn.Sequential(*layers)
# init
for m in self.modules():
if isinstance(m, nn.Conv2d):
m.weight = nn.init.kaiming_normal(m.weight)
elif isinstance(m, nn.BatchNorm2d):
m.weight.data.fill_(1)
m.bias.data.zero_()
def __init__(self, config_channels, anchors, num_cls):
nn.Module.__init__(self)
channels = 16
layers = []
for _ in range(5):
layers.append(
Conv2d_BatchNorm(config_channels.channels,
config_channels(
channels,
'layers.%d.conv.weight' % len(layers)),
3,
same_padding=True))
layers.append(nn.MaxPool2d(kernel_size=2))
channels *= 2
layers.append(
Conv2d_BatchNorm(config_channels.channels,
config_channels(
channels,
'layers.%d.conv.weight' % len(layers)),
3,
same_padding=True))
layers.append(
nn.ConstantPad2d((0, 1, 0, 1), float(np.finfo(np.float32).min)))
layers.append(nn.MaxPool2d(kernel_size=2, stride=1))
channels *= 2
for _ in range(2):
layers.append(
Conv2d_BatchNorm(config_channels.channels,
config_channels(
channels,
'layers.%d.conv.weight' % len(layers)),
3,
same_padding=True))
layers.append(
Conv2d(config_channels.channels,
model.output_channels(len(anchors), num_cls),
1,
act=False))
self.layers = nn.Sequential(*layers)
# init
for m in self.modules():
if isinstance(m, nn.Conv2d):
m.weight = nn.init.xavier_normal(m.weight)
elif isinstance(m, nn.BatchNorm2d):
m.weight.data.fill_(1)
m.bias.data.zero_()
def __init__(self, config, anchors, num_cls):
nn.Module.__init__(self)
self.layers = nn.Sequential(
conv_bn(3, 32, 2), conv_unit(32, 64, 1), conv_unit(64, 128, 2),
conv_unit(128, 128, 1), conv_unit(128, 256, 2),
conv_unit(256, 256, 1), conv_unit(256, 512, 2),
conv_unit(512, 512, 1), conv_unit(512, 512, 1),
conv_unit(512, 512, 1), conv_unit(512, 512, 1),
conv_unit(512, 512, 1), conv_unit(512, 1024, 2),
conv_unit(1024, 1024, 1),
nn.Conv2d(1024, model.output_channels(len(anchors), num_cls), 1))
for m in self.modules():
if isinstance(m, nn.Conv2d):
m.weight = nn.init.kaiming_normal(m.weight)
def __init__(self, config, anchors, num_cls):
nn.Module.__init__(self)
self.features = nn.Sequential(
BasicConv2d(3, 32, kernel_size=3, stride=2),
BasicConv2d(32, 32, kernel_size=3, stride=1),
BasicConv2d(32, 64, kernel_size=3, stride=1, padding=1),
Mixed_3a(),
Mixed_4a(),
Mixed_5a(),
Inception_A(),
Inception_A(),
Inception_A(),
Inception_A(),
Reduction_A(), # Mixed_6a
Inception_B(),
Inception_B(),
Inception_B(),
Inception_B(),
Inception_B(),
Inception_B(),
Inception_B(),
Reduction_B(), # Mixed_7a
Inception_C(),
Inception_C(),
Inception_C(),
nn.Conv2d(1536, model.output_channels(len(anchors), num_cls), 1),
)
gamma = config.getboolean('batch_norm', 'gamma')
beta = config.getboolean('batch_norm', 'beta')
for m in self.modules():
if isinstance(m, nn.Conv2d):
m.weight = nn.init.kaiming_normal(m.weight)
elif isinstance(m, nn.BatchNorm2d):
m.weight.data.fill_(1)
m.bias.data.zero_()
m.weight.requires_grad = gamma
m.bias.requires_grad = beta
if config.getboolean('model', 'pretrained'):
settings = pretrained_settings['inceptionv4'][config.get('inception4', 'pretrained')]
logging.info('use pretrained model: ' + str(settings))
state_dict = self.state_dict()
for key, value in torch.utils.model_zoo.load_url(settings['url']).items():
if key in state_dict:
state_dict[key] = value
self.load_state_dict(state_dict)
def __init__(self, config_channels, anchors, num_cls, stride=2, ratio=1):
nn.Module.__init__(self)
self.stride = stride
channels = int(32 * ratio)
layers = []
bn = config_channels.config.getboolean('batch_norm', 'enable')
# layers1
for _ in range(2):
layers.append(Conv2d(config_channels.channels, config_channels(channels, 'layers1.%d.conv.weight' % len(layers)), 3, bn=bn, padding=True))
layers.append(nn.MaxPool2d(kernel_size=2))
channels *= 2
# down 4
for _ in range(2):
layers.append(Conv2d(config_channels.channels, config_channels(channels, 'layers1.%d.conv.weight' % len(layers)), 3, bn=bn, padding=True))
layers.append(Conv2d(config_channels.channels, config_channels(channels // 2, 'layers1.%d.conv.weight' % len(layers)), 1, bn=bn))
layers.append(Conv2d(config_channels.channels, config_channels(channels, 'layers1.%d.conv.weight' % len(layers)), 3, bn=bn, padding=True))
layers.append(nn.MaxPool2d(kernel_size=2))
channels *= 2
# down 16
for _ in range(2):
layers.append(Conv2d(config_channels.channels, config_channels(channels, 'layers1.%d.conv.weight' % len(layers)), 3, bn=bn, padding=True))
layers.append(Conv2d(config_channels.channels, config_channels(channels // 2, 'layers1.%d.conv.weight' % len(layers)), 1, bn=bn))
layers.append(Conv2d(config_channels.channels, config_channels(channels, 'layers1.%d.conv.weight' % len(layers)), 3, bn=bn, padding=True))
self.layers1 = nn.Sequential(*layers)
# layers2
layers = []
layers.append(nn.MaxPool2d(kernel_size=2))
channels *= 2
# down 32
for _ in range(2):
layers.append(Conv2d(config_channels.channels, config_channels(channels, 'layers2.%d.conv.weight' % len(layers)), 3, bn=bn, padding=True))
layers.append(Conv2d(config_channels.channels, config_channels(channels // 2, 'layers2.%d.conv.weight' % len(layers)), 1, bn=bn))
for _ in range(3):
layers.append(Conv2d(config_channels.channels, config_channels(channels, 'layers2.%d.conv.weight' % len(layers)), 3, bn=bn, padding=True))
self.layers2 = nn.Sequential(*layers)
self.passthrough = Conv2d(self.layers1[-1].conv.weight.size(0), config_channels(int(64 * ratio), 'passthrough.conv.weight'), 1, bn=bn)
# layers3
layers = []
layers.append(Conv2d(self.passthrough.conv.weight.size(0) * self.stride * self.stride + self.layers2[-1].conv.weight.size(0), config_channels(int(1024 * ratio), 'layers3.%d.conv.weight' % len(layers)), 3, bn=bn, padding=True))
layers.append(Conv2d(config_channels.channels, model.output_channels(len(anchors), num_cls), 1, bn=False, act=False))
self.layers3 = nn.Sequential(*layers)
self.init()
def __init__(self, config_channels, anchors, num_cls):
nn.Module.__init__(self)
self.features = nn.Sequential(
BasicConv2d(3, 32, kernel_size=3, stride=2),
BasicConv2d(32, 32, kernel_size=3, stride=1),
BasicConv2d(32, 64, kernel_size=3, stride=1, padding=1),
Mixed_3a(),
Mixed_4a(),
Mixed_5a(),
Inception_A(),
Inception_A(),
Inception_A(),
Inception_A(),
Reduction_A(), # Mixed_6a
Inception_B(),
Inception_B(),
Inception_B(),
Inception_B(),
Inception_B(),
Inception_B(),
Inception_B(),
Reduction_B(), # Mixed_7a
Inception_C(),
Inception_C(),
Inception_C(),
nn.Conv2d(1536, model.output_channels(len(anchors), num_cls), 1),
)
gamma = config_channels.config.getboolean('batch_norm', 'gamma')
beta = config_channels.config.getboolean('batch_norm', 'beta')
for m in self.modules():
if isinstance(m, nn.Conv2d):
m.weight = nn.init.kaiming_normal(m.weight)
elif isinstance(m, nn.BatchNorm2d):
m.weight.data.fill_(1)
m.bias.data.zero_()
m.weight.requires_grad = gamma
m.bias.requires_grad = beta
if config_channels.config.getboolean('model', 'pretrained'):
settings = pretrained_settings['inceptionv4'][config_channels.config.get('inception4', 'pretrained')]
logging.info('use pretrained model: ' + str(settings))
state_dict = self.state_dict()
for key, value in torch.utils.model_zoo.load_url(settings['url']).items():
if key in state_dict:
state_dict[key] = value
self.load_state_dict(state_dict)
def __init__(self,
config_channels,
anchors,
num_cls,
transform_input=False):
nn.Module.__init__(self)
self.transform_input = transform_input
self.Conv2d_1a_3x3 = BasicConv2d(3, 32, kernel_size=3, stride=2)
self.Conv2d_2a_3x3 = BasicConv2d(32, 32, kernel_size=3)
self.Conv2d_2b_3x3 = BasicConv2d(32, 64, kernel_size=3, padding=1)
self.Conv2d_3b_1x1 = BasicConv2d(64, 80, kernel_size=1)
self.Conv2d_4a_3x3 = BasicConv2d(80, 192, kernel_size=3)
self.Mixed_5b = InceptionA(192, pool_features=32)
self.Mixed_5c = InceptionA(256, pool_features=64)
self.Mixed_5d = InceptionA(288, pool_features=64)
self.Mixed_6a = InceptionB(288)
self.Mixed_6b = InceptionC(768, channels_7x7=128)
self.Mixed_6c = InceptionC(768, channels_7x7=160)
self.Mixed_6d = InceptionC(768, channels_7x7=160)
self.Mixed_6e = InceptionC(768, channels_7x7=192)
# aux_logits
self.Mixed_7a = InceptionD(768)
self.Mixed_7b = InceptionE(1280)
self.Mixed_7c = InceptionE(2048)
self.conv = nn.Conv2d(2048,
model.output_channels(len(anchors), num_cls), 1)
for m in self.modules():
if isinstance(m, nn.Conv2d) or isinstance(m, nn.Linear):
stddev = m.stddev if hasattr(m, 'stddev') else 0.1
X = stats.truncnorm(-2, 2, scale=stddev)
values = torch.Tensor(X.rvs(m.weight.data.numel()))
m.weight.data.copy_(values)
elif isinstance(m, nn.BatchNorm2d):
m.weight.data.fill_(1)
m.bias.data.zero_()
if config_channels.config.getboolean('model', 'pretrained'):
url = _model.model_urls['inception_v3_google']
logging.info('use pretrained model: ' + url)
state_dict = self.state_dict()
for key, value in torch.utils.model_zoo.load_url(url).items():
if key in state_dict:
state_dict[key] = value
self.load_state_dict(state_dict)
def __init__(self, config_channels, anchors, num_cls, block, layers):
nn.Module.__init__(self)
self.conv1 = nn.Conv2d(config_channels.channels, config_channels(64, 'conv1.weight'), kernel_size=7, stride=2, padding=3, bias=False)
self.bn1 = nn.BatchNorm2d(config_channels.channels)
self.relu = nn.ReLU(inplace=True)
self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
self.layer1 = self._make_layer(config_channels, 'layer1', block, 64, layers[0])
self.layer2 = self._make_layer(config_channels, 'layer2', block, 128, layers[1], stride=2)
self.layer3 = self._make_layer(config_channels, 'layer3', block, 256, layers[2], stride=2)
self.layer4 = self._make_layer(config_channels, 'layer4', block, 512, layers[3], stride=2)
self.conv = nn.Conv2d(config_channels.channels, model.output_channels(len(anchors), num_cls), 1)
for m in self.modules():
if isinstance(m, nn.Conv2d):
m.weight = nn.init.kaiming_normal(m.weight)
elif isinstance(m, nn.BatchNorm2d):
m.weight.data.fill_(1)
m.bias.data.zero_()
def __init__(self, config_channels, anchors, num_cls, channels=16):
nn.Module.__init__(self)
layers = []
bn = config_channels.config.getboolean('batch_norm', 'enable')
for _ in range(5):
layers.append(
Conv2d(config_channels.channels,
config_channels(channels,
'layers.%d.conv.weight' % len(layers)),
3,
bn=bn,
padding=True))
layers.append(nn.MaxPool2d(kernel_size=2))
channels *= 2
layers.append(
Conv2d(config_channels.channels,
config_channels(channels,
'layers.%d.conv.weight' % len(layers)),
3,
bn=bn,
padding=True))
layers.append(
nn.ConstantPad2d((0, 1, 0, 1), float(np.finfo(np.float32).min)))
layers.append(nn.MaxPool2d(kernel_size=2, stride=1))
channels *= 2
for _ in range(2):
layers.append(
Conv2d(config_channels.channels,
config_channels(channels,
'layers.%d.conv.weight' % len(layers)),
3,
bn=bn,
padding=True))
layers.append(
Conv2d(config_channels.channels,
model.output_channels(len(anchors), num_cls),
1,
bn=False,
act=False))
self.layers = nn.Sequential(*layers)
self.init()
def __init__(self, config_channels, anchors, num_cls, block, layers):
self.inplanes = 64
nn.Module.__init__(self)
self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3, bias=False)
self.bn1 = nn.BatchNorm2d(64)
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)
self.conv = nn.Conv2d(512, model.output_channels(len(anchors), num_cls), 1)
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_()
def __init__(self, config_channels, anchors, num_cls, transform_input=False):
nn.Module.__init__(self)
self.transform_input = transform_input
self.Conv2d_1a_3x3 = BasicConv2d(3, 32, kernel_size=3, stride=2)
self.Conv2d_2a_3x3 = BasicConv2d(32, 32, kernel_size=3)
self.Conv2d_2b_3x3 = BasicConv2d(32, 64, kernel_size=3, padding=1)
self.Conv2d_3b_1x1 = BasicConv2d(64, 80, kernel_size=1)
self.Conv2d_4a_3x3 = BasicConv2d(80, 192, kernel_size=3)
self.Mixed_5b = InceptionA(192, pool_features=32)
self.Mixed_5c = InceptionA(256, pool_features=64)
self.Mixed_5d = InceptionA(288, pool_features=64)
self.Mixed_6a = InceptionB(288)
self.Mixed_6b = InceptionC(768, channels_7x7=128)
self.Mixed_6c = InceptionC(768, channels_7x7=160)
self.Mixed_6d = InceptionC(768, channels_7x7=160)
self.Mixed_6e = InceptionC(768, channels_7x7=192)
# aux_logits
self.Mixed_7a = InceptionD(768)
self.Mixed_7b = InceptionE(1280)
self.Mixed_7c = InceptionE(2048)
self.conv = nn.Conv2d(2048, model.output_channels(len(anchors), num_cls), 1)
for m in self.modules():
if isinstance(m, nn.Conv2d) or isinstance(m, nn.Linear):
stddev = m.stddev if hasattr(m, 'stddev') else 0.1
X = stats.truncnorm(-2, 2, scale=stddev)
values = torch.Tensor(X.rvs(m.weight.data.numel()))
m.weight.data.copy_(values)
elif isinstance(m, nn.BatchNorm2d):
m.weight.data.fill_(1)
m.bias.data.zero_()
if config_channels.config.getboolean('model', 'pretrained'):
url = _model.model_urls['inception_v3_google']
logging.info('use pretrained model: ' + url)
state_dict = self.state_dict()
for key, value in torch.utils.model_zoo.load_url(url).items():
if key in state_dict:
state_dict[key] = value
self.load_state_dict(state_dict)
def __init__(self, config, anchors, num_cls):
nn.Module.__init__(self)
channels_in = 3
channels_out = 16
layers = []
for _ in range(5):
layers.append(
Conv2d_BatchNorm(channels_in,
channels_out,
3,
same_padding=True))
channels_in = layers[-1].conv.weight.size(0)
layers.append(nn.MaxPool2d(kernel_size=2))
channels_out *= 2
layers.append(
Conv2d_BatchNorm(channels_in, channels_out, 3, same_padding=True))
channels_in = layers[-1].conv.weight.size(0)
layers.append(
nn.ConstantPad2d((0, 1, 0, 1), float(np.finfo(np.float32).min)))
layers.append(nn.MaxPool2d(kernel_size=2, stride=1))
channels_out *= 2
for _ in range(2):
layers.append(
Conv2d_BatchNorm(channels_in,
channels_out,
3,
same_padding=True))
channels_in = layers[-1].conv.weight.size(0)
layers.append(
Conv2d(channels_in,
model.output_channels(len(anchors), num_cls),
1,
act=False))
self.layers = nn.Sequential(*layers)
for m in self.modules():
if isinstance(m, nn.Conv2d):
m.weight = nn.init.xavier_normal(m.weight)
def __init__(self, config_channels, anchors, num_cls, features):
nn.Module.__init__(self)
self.features = features
self.conv = nn.Conv2d(config_channels.channels,
model.output_channels(len(anchors), num_cls), 1)
self._initialize_weights()
def __init__(self, config, anchors, num_cls, stride=2):
nn.Module.__init__(self)
self.stride = stride
channels_in = 3
channels_out = 32
layers = []
# layers1
for _ in range(2):
layers.append(
Conv2d_BatchNorm(channels_in,
channels_out,
3,
same_padding=True))
channels_in = layers[-1].conv.weight.size(0)
layers.append(nn.MaxPool2d(kernel_size=2))
channels_out *= 2
# down 4
for _ in range(2):
layers.append(
Conv2d_BatchNorm(channels_in,
channels_out,
3,
same_padding=True))
channels_in = layers[-1].conv.weight.size(0)
layers.append(Conv2d_BatchNorm(channels_in, channels_out // 2, 1))
channels_in = layers[-1].conv.weight.size(0)
layers.append(
Conv2d_BatchNorm(channels_in,
channels_out,
3,
same_padding=True))
channels_in = layers[-1].conv.weight.size(0)
layers.append(nn.MaxPool2d(kernel_size=2))
channels_out *= 2
# down 16
for _ in range(2):
layers.append(
Conv2d_BatchNorm(channels_in,
channels_out,
3,
same_padding=True))
channels_in = layers[-1].conv.weight.size(0)
layers.append(Conv2d_BatchNorm(channels_in, channels_out // 2, 1))
channels_in = layers[-1].conv.weight.size(0)
layers.append(
Conv2d_BatchNorm(channels_in, channels_out, 3, same_padding=True))
channels_in = layers[-1].conv.weight.size(0)
self.layers1 = nn.Sequential(*layers)
# layers2
layers = []
layers.append(nn.MaxPool2d(kernel_size=2))
channels_out *= 2
# down 32
for _ in range(2):
layers.append(
Conv2d_BatchNorm(channels_in,
channels_out,
3,
same_padding=True))
channels_in = layers[-1].conv.weight.size(0)
layers.append(Conv2d_BatchNorm(channels_in, channels_out // 2, 1))
channels_in = layers[-1].conv.weight.size(0)
for _ in range(3):
layers.append(
Conv2d_BatchNorm(channels_in,
channels_out,
3,
same_padding=True))
channels_in = layers[-1].conv.weight.size(0)
self.layers2 = nn.Sequential(*layers)
self.passthrough = Conv2d_BatchNorm(
self.layers1[-1].conv.weight.size(0), 64, 1)
# layers3
layers = []
channels_in += self.passthrough.conv.weight.size(
0) * self.stride * self.stride # reorg
layers.append(Conv2d_BatchNorm(channels_in, 1024, 3,
same_padding=True))
channels_in = layers[-1].conv.weight.size(0)
layers.append(
Conv2d(channels_in,
model.output_channels(len(anchors), num_cls),
1,
act=False))
self.layers3 = nn.Sequential(*layers)
# init
for m in self.modules():
if isinstance(m, nn.Conv2d):
m.weight = nn.init.xavier_normal(m.weight)
def __init__(self, config_channels, anchors, num_cls):
nn.Module.__init__(self)
features = []
features.append(
BasicConv2d(config_channels.channels,
config_channels(
32, 'features.%d.conv.weight' % len(features)),
kernel_size=3,
stride=2))
features.append(
BasicConv2d(config_channels.channels,
config_channels(
32, 'features.%d.conv.weight' % len(features)),
kernel_size=3,
stride=1))
features.append(
BasicConv2d(config_channels.channels,
config_channels(
64, 'features.%d.conv.weight' % len(features)),
kernel_size=3,
stride=1,
padding=1))
features.append(
Mixed_3a(config_channels, 'features.%d' % len(features)))
features.append(
Mixed_4a(config_channels, 'features.%d' % len(features)))
features.append(
Mixed_5a(config_channels, 'features.%d' % len(features)))
features.append(
Inception_A(config_channels, 'features.%d' % len(features)))
features.append(
Inception_A(config_channels, 'features.%d' % len(features)))
features.append(
Inception_A(config_channels, 'features.%d' % len(features)))
features.append(
Inception_A(config_channels, 'features.%d' % len(features)))
features.append(
Reduction_A(config_channels,
'features.%d' % len(features))) # Mixed_6a
features.append(
Inception_B(config_channels, 'features.%d' % len(features)))
features.append(
Inception_B(config_channels, 'features.%d' % len(features)))
features.append(
Inception_B(config_channels, 'features.%d' % len(features)))
features.append(
Inception_B(config_channels, 'features.%d' % len(features)))
features.append(
Inception_B(config_channels, 'features.%d' % len(features)))
features.append(
Inception_B(config_channels, 'features.%d' % len(features)))
features.append(
Inception_B(config_channels, 'features.%d' % len(features)))
features.append(
Reduction_B(config_channels,
'features.%d' % len(features))) # Mixed_7a
features.append(
Inception_C(config_channels, 'features.%d' % len(features)))
features.append(
Inception_C(config_channels, 'features.%d' % len(features)))
features.append(
Inception_C(config_channels, 'features.%d' % len(features)))
features.append(
nn.Conv2d(config_channels.channels,
model.output_channels(len(anchors), num_cls), 1))
self.features = nn.Sequential(*features)
try:
gamma = config_channels.config.getboolean('batch_norm', 'gamma')
except (configparser.NoSectionError, configparser.NoOptionError):
gamma = True
try:
beta = config_channels.config.getboolean('batch_norm', 'beta')
except (configparser.NoSectionError, configparser.NoOptionError):
beta = True
for m in self.modules():
if isinstance(m, nn.Conv2d):
m.weight = nn.init.kaiming_normal(m.weight)
elif isinstance(m, nn.BatchNorm2d):
m.weight.data.fill_(1)
m.bias.data.zero_()
m.weight.requires_grad = gamma
m.bias.requires_grad = beta
try:
if config_channels.config.getboolean('model', 'pretrained'):
settings = pretrained_settings['inceptionv4'][
config_channels.config.get('inception4', 'pretrained')]
logging.info('use pretrained model: ' + str(settings))
state_dict = self.state_dict()
for key, value in torch.utils.model_zoo.load_url(
settings['url']).items():
if key in state_dict:
state_dict[key] = value
self.load_state_dict(state_dict)
except (configparser.NoSectionError, configparser.NoOptionError):
pass
