def __init__(self, cfg, **kwargs):
super(RetinaNetHead, self).__init__(cfg, **kwargs)
self.box_shared_convs = [
build_convolution(convolution=cfg.head.convolution,
filters=cfg.head.feat_dims,
kernel_size=(3, 3),
strides=(1, 1),
padding="same",
use_bias=cfg.head.normalization is None
or cfg.head.convolution == "separable_conv2d",
kernel_regularizer=self.kernel_regularizer,
name="box_net/box-%d" % i)
for i in range(cfg.head.repeats)
]
self.class_shared_convs = [
build_convolution(convolution=cfg.head.convolution,
filters=cfg.head.feat_dims,
kernel_size=(3, 3),
strides=(1, 1),
padding="same",
use_bias=cfg.head.normalization is None
or cfg.head.convolution == "separable_conv2d",
kernel_regularizer=self.kernel_regularizer,
name="class_net/class-%d" % i)
for i in range(cfg.head.repeats)
]
self.classifier = build_convolution(
cfg.head.convolution,
filters=cfg.head.num_classes * cfg.head.num_anchors,
kernel_size=(3, 3),
strides=(1, 1),
padding="same",
use_bias=True,
bias_initializer=tf.keras.initializers.Constant(-math.log(
(1. - cfg.head.prior) / cfg.head.prior)),
name="class_net/class-predict")
self.regressor = build_convolution(cfg.head.convolution,
filters=4 * cfg.head.num_anchors,
kernel_size=(3, 3),
strides=(1, 1),
padding="same",
use_bias=True,
name="box_net/box-predict")
self.delta2box = Delta2Box(mean=cfg.bbox_decoder.bbox_mean,
std=cfg.bbox_decoder.bbox_std)
self.box2delta = Box2Delta(mean=cfg.bbox_decoder.bbox_mean,
std=cfg.bbox_decoder.bbox_std)
self._use_iou_loss = "iou" in cfg.loss.bbox_loss.loss
self.bbox_loss_func = build_loss(**cfg.loss.bbox_loss.as_dict())
self.label_loss_func = build_loss(**cfg.loss.label_loss.as_dict())
self.sampler = build_sampler(**cfg.sampler.as_dict())
self.cfg = cfg
def __init__(self,
convolution,
filters,
strides=1,
dilation_rate=1,
normalization="group_norm",
group=16,
activation="relu",
weight_decay=0.,
use_conv_shortcut=False,
**kwargs):
super(BasicBlock, self).__init__(**kwargs)
axis = 3 if tf.keras.backend.image_data_format(
) == "channels_last" else 1
self.conv1 = build_convolution(
convolution,
filters=filters,
kernel_size=3,
strides=strides,
padding="same",
dilation_rate=dilation_rate if strides == 1 else 1,
kernel_regularizer=tf.keras.regularizers.l2(weight_decay),
use_bias=False)
self.norm1 = build_normalization(normalization, axis=axis, group=group)
self.act = tf.keras.layers.Activation(activation)
self.conv2 = build_convolution(
convolution,
filters=filters,
kernel_size=3,
strides=1,
padding="same",
dilation_rate=dilation_rate,
kernel_regularizer=tf.keras.regularizers.l2(weight_decay),
use_bias=False)
self.norm2 = build_normalization(normalization, axis=axis, group=group)
if use_conv_shortcut:
if strides >= 2:
self.avg_pool = tf.keras.layers.AvgPool2D(2, strides, "same")
self.conv3 = build_convolution(
convolution,
filters=filters,
kernel_size=1,
strides=1,
padding="same",
kernel_regularizer=tf.keras.regularizers.l2(weight_decay))
self.norm3 = build_normalization(normalization,
axis=axis,
group=group)
self.use_conv_shortcut = use_conv_shortcut
def __init__(self,
convolution="conv2d",
normalization=dict(normalization="batch_norm",
momentum=0.9,
epsilon=1e-3,
axis=-1,
trainable=True),
activation=dict(activation="swish"),
feat_dims=64,
conv_bn_act_pattern=False,
data_format="channels_last",
name='op_after_combine'):
super(OpAfterCombine, self).__init__(name=name)
self.feat_dims = feat_dims
self.data_format = data_format
self.conv_bn_act_pattern = conv_bn_act_pattern
self.conv_op = build_convolution(convolution=convolution,
filters=feat_dims,
kernel_size=(3, 3),
padding='same',
use_bias=not self.conv_bn_act_pattern,
data_format=self.data_format,
name='conv')
self.bn = build_normalization(**normalization, name='bn')
self.act = build_activation(**activation)
def transition_block(self, x, reduction, strides, trainable, name):
"""A transition block.
Args:
x: input tensor.
reduction: float, compression rate at transition layers.
strides: integer, stride in pool layer.
trainable: bool, does freeze this block.
name: string, block label.
Returns:
output tensor for the block.
"""
bn_axis = 3 if tf.keras.backend.image_data_format(
) == "channels_last" else 1
x = build_normalization(**self.normalization, name=name + "_bn")(x)
x = tf.keras.layers.Activation(**self.activation,
name=name + "_relu")(x)
preact = x
x = build_convolution(
self.convolution,
filters=int(tf.keras.backend.int_shape(x)[bn_axis] * reduction),
kernel_size=1,
use_bias=False,
trainable=trainable,
name=name + "_conv")(x)
x = tf.keras.layers.AvgPool2D(2, strides=strides,
name=name + "_pool")(x)
return preact, x
def resnet(self):
trainable = 0 not in self.frozen_stages
inputs = tf.keras.layers.Lambda(
function=lambda inp: inp - [123.68, 116.78, 103.94],
name="mean_subtraction")(self.img_input)
x = tf.keras.layers.ZeroPadding2D(((3, 3), (3, 3)),
name="conv1_pad")(inputs)
x = build_convolution(self.convolution,
filters=64,
kernel_size=(7, 7),
strides=self.strides[0],
padding="valid",
dilation_rate=self.dilation_rates[0],
use_bias=True,
trainable=trainable,
kernel_initializer="he_normal",
kernel_regularizer=tf.keras.regularizers.l2(
self.weight_decay),
name="conv1_conv")(x)
x = build_normalization(**self.normalization, name="conv1_bn")(x)
x1 = build_activation(**self.activation, name="conv1_relu")(x)
x = tf.keras.layers.ZeroPadding2D(padding=((1, 1), (1, 1)),
name="pool1_pad")(x1)
x = tf.keras.layers.MaxPool2D((3, 3),
self.strides[1],
"valid",
name="pool1_pool")(x)
trainable = 2 not in self.frozen_stages
x2 = self.stack(x, 64, 1, self.dilation_rates[1], trainable,
self.blocks[0], "conv2")
trainable = 3 not in self.frozen_stages
x3 = self.stack(x2, 128, self.strides[2], self.dilation_rates[2],
trainable, self.blocks[1], "conv3")
trainable = 4 not in self.frozen_stages
x4 = self.stack(x3, 256, self.strides[3], self.dilation_rates[3],
trainable, self.blocks[2], "conv4")
trainable = 5 not in self.frozen_stages
x5 = self.stack(x4, 512, self.strides[4], self.dilation_rates[4],
trainable, self.blocks[3], "conv5")
if self._is_classifier:
x = tf.keras.layers.GlobalAvgPool2D(name="avg_pool")(x5)
x = tf.keras.layers.Dropout(rate=self.drop_rate)(x)
outputs = tf.keras.layers.Dense(self.num_classes,
activation="softmax",
name="probs")(x)
return tf.keras.Model(inputs=self.img_input,
outputs=outputs,
name=self.name)
else:
outputs = [
o for i, o in enumerate([x1, x2, x3, x4, x5])
if i + 1 in self.output_indices
]
return outputs
def _make_shared_convs(self):
self.box_shared_convs = [
build_convolution(convolution=self.cfg.convolution,
filters=self.cfg.feat_dims,
kernel_size=(3, 3),
strides=(1, 1),
padding="same",
use_bias=self.cfg.normalization is None
or self.cfg.convolution == "separable_conv2d",
name="box_net/box-%d" % i)
for i in range(self.cfg.repeats)
]
if self.cfg.normalization:
self.box_norm_layers = {
"level%d" % level: [
build_normalization(**self.cfg.normalization.as_dict(),
name="box_net/box-%d-bn-%d" %
(i, level))
for i in range(self.cfg.repeats)
]
for level in range(self.min_level, self.max_level + 1)
}
self.class_shared_convs = [
build_convolution(convolution=self.cfg.convolution,
filters=self.cfg.feat_dims,
kernel_size=(3, 3),
strides=(1, 1),
padding="same",
use_bias=self.cfg.normalization is None
or self.cfg.convolution == "separable_conv2d",
name="class_net/class-%d" % i)
for i in range(self.cfg.repeats)
]
if self.cfg.normalization:
self.class_norm_layers = {
"level%d" % level: [
build_normalization(**self.cfg.normalization.as_dict(),
name="class_net/class-%d-bn-%d" %
(i, level))
for i in range(self.cfg.repeats)
]
for level in range(self.min_level, self.max_level + 1)
}
self.act_fn = build_activation(**self.cfg.activation.as_dict())
def _make_init_layer(self):
self.classifier = build_convolution(
self.cfg.convolution,
filters=self._label_dims * self.num_anchors,
kernel_size=(3, 3),
strides=(1, 1),
padding="same",
use_bias=True,
bias_initializer=tf.keras.initializers.Constant(-math.log(
(1. - self.cfg.prior) / self.cfg.prior)),
name="class_net/class-predict")
self.regressor = build_convolution(self.cfg.convolution,
filters=4 * self.num_anchors,
kernel_size=(3, 3),
strides=(1, 1),
padding="same",
use_bias=True,
name="box_net/box-predict")
def conv_block(self, x, growth_rate, dilation_rate, drop_rate, trainable,
name):
"""A building block for a dense block.
Args:
x: input tensor.
growth_rate: float, growth rate at dense layers.
dilation_rate: integer, dilation rate.
drop_rate: float, the dropout rate.
trainable: bool, does freeze this block
name: string, block label.
Returns:
Output tensor for the block.
"""
bn_axis = 3 if tf.keras.backend.image_data_format(
) == "channels_last" else 1
x1 = build_normalization(**self.normalization, name=name + "_0_bn")(x)
x1 = tf.keras.layers.Activation(**self.activation,
name=name + "_0_relu")(x1)
x1 = build_convolution(self.convolution,
filters=4 * growth_rate,
kernel_size=1,
use_bias=False,
trainable=trainable,
name=name + "_1_conv")(x1)
x1 = build_normalization(**self.normalization, name=name + "_1_bn")(x1)
x1 = tf.keras.layers.Activation(**self.activation,
name=name + "_1_relu")(x1)
x1 = build_convolution(self.convolution,
filters=growth_rate,
kernel_size=3,
padding="same",
dilation_rate=dilation_rate,
use_bias=False,
trainable=trainable,
name=name + "_2_conv")(x1)
x1 = tf.keras.layers.Dropout(rate=drop_rate)(x1)
x = tf.keras.layers.Concatenate(axis=bn_axis,
name=name + "_concat")([x, x1])
return x
def resnet_v2(self):
trainable = 0 not in self.frozen_stages
x = tf.keras.layers.Lambda(function=lambda inp: inp / 127.5 - 1.,
name="mean_subtraction")(self.img_input)
x = tf.keras.layers.ZeroPadding2D(padding=((3, 3), (3, 3)),
name="conv1_pad")(x)
x1 = build_convolution(self.convolution,
filters=64,
kernel_size=7,
strides=self.strides[0],
padding="valid",
dilation_rate=self.dilation_rates[0],
trainable=trainable,
kernel_regularizer=tf.keras.regularizers.l2(
self.weight_decay),
use_bias=True,
name="conv1_conv")(x)
x = tf.keras.layers.ZeroPadding2D(padding=((1, 1), (1, 1)),
name="pool1_pad")(x1)
x = tf.keras.layers.MaxPool2D((3, 3),
strides=self.strides[1],
padding="valid",
name="pool1_pool")(x)
trainable = 1 not in self.frozen_stages
x, _ = self.stack(x, 64, self.strides[2], self.dilation_rates[1],
trainable, self.blocks[0], "conv2")
trainable = 2 not in self.frozen_stages
x, preact2 = self.stack(x, 128, self.strides[3],
self.dilation_rates[2], trainable,
self.blocks[1], "conv3")
trainable = 3 not in self.frozen_stages
x, preact3 = self.stack(x, 256, self.strides[4],
self.dilation_rates[3], trainable,
self.blocks[2], "conv4")
trainable = 4 not in self.frozen_stages
x, preact4 = self.stack(x, 512, 1, self.dilation_rates[4], trainable,
self.blocks[3], "conv5")
x = build_normalization(**self.normalization, name="post_bn")(x)
x5 = tf.keras.layers.Activation(**self.activation, name="post_relu")(x)
if self._is_classifier:
x = tf.keras.layers.GlobalAvgPool2D(name="avg_pool")(x5)
x = tf.keras.layers.Dropout(rate=self.drop_rate)(x)
x = tf.keras.layers.Dense(self.num_classes,
activation="softmax",
name="probs")(x)
return tf.keras.Model(inputs=self.img_input,
outputs=x,
name="resnet" + str(self.depth) + "v2")
outputs = [
o for i, o in enumerate([x1, preact2, preact3, preact4, x5])
if i in self.output_indices
]
return outputs
def resample_feature_map(feat,
target_width,
target_num_channels,
convolution="separable_conv2d",
normalization=dict(normalization="batch_norm",
momentum=0.9,
epsilon=1e-3,
axis=-1,
trainable=True),
activation=dict(activation="swish"),
pool_type=None,
apply_bn=True,
name="resample"):
"""Resample input feature map to have target number of channels and width."""
_, _, width, num_channels = tf.keras.backend.int_shape(feat)
if width > target_width:
if num_channels != target_num_channels:
feat = build_convolution("conv2d",
filters=target_num_channels,
kernel_size=(1, 1),
padding="same",
name=name + "/conv2d")(feat)
if apply_bn:
feat = build_normalization(**normalization,
name=name + "/bn")(feat)
strides = int(width // target_width)
# if strides >= 2:
# feat = tf.keras.layers.ZeroPadding2D(
# padding=imagenet_utils.correct_pad(feat, strides + 1),
# name=name + '/stem/conv_pad')(feat)
# pad = "valid"
# else:
# pad = "same"
if pool_type == "max" or pool_type is None:
feat = tf.keras.layers.MaxPool2D(pool_size=strides + 1,
strides=[strides, strides],
padding="same",
name=name + "/max_pool")(feat)
elif pool_type == "avg":
feat = tf.keras.layers.AvgPool2D(pool_size=strides + 1,
strides=[strides, strides],
padding="same",
name=name + "/avg_pool")(feat)
else:
raise ValueError("Unknown pooling type: {}".format(pool_type))
else:
if num_channels != target_num_channels:
feat = build_convolution("conv2d",
filters=target_num_channels,
kernel_size=(1, 1),
padding="same",
name=name + "/conv2d")(feat)
if apply_bn:
feat = build_normalization(**normalization,
name=name + "/bn")(feat)
if width < target_width:
scale = target_width // width
feat = NearestUpsampling2D(scale=scale,
name=name + "/nearest_upsampling")(feat)
return feat
def build_bifpn_layer(feats,
input_size,
feat_dims,
convolution="separable_conv2d",
normalization=dict(normalization="batch_norm",
momentum=0.9,
epsilon=1e-3,
axis=-1,
trainable=True),
activation=dict(activation="swish"),
min_level=3,
max_level=7,
pool_type=None,
apply_bn=True,
fusion_type="weighted_sum",
name="fpn_cells",
**kwargs):
F = lambda x: 1.0 / (2**x) # Resolution size for a given feature level.
node_configs = [
{
"width_ratio": F(6),
"inputs_offsets": [3, 4]
},
{
"width_ratio": F(5),
"inputs_offsets": [2, 5]
},
{
"width_ratio": F(4),
"inputs_offsets": [1, 6]
},
{
"width_ratio": F(3),
"inputs_offsets": [0, 7]
},
{
"width_ratio": F(4),
"inputs_offsets": [1, 7, 8]
},
{
"width_ratio": F(5),
"inputs_offsets": [2, 6, 9]
},
{
"width_ratio": F(6),
"inputs_offsets": [3, 5, 10]
},
{
"width_ratio": F(7),
"inputs_offsets": [4, 11]
},
]
num_output_connections = [0 for _ in feats]
for i, fnode in enumerate(node_configs):
nodes = []
node_name = name + "/fnode{}".format(i)
new_node_width = int(fnode["width_ratio"] * input_size[1])
for idx, input_offset in enumerate(fnode["inputs_offsets"]):
input_node = feats[input_offset]
num_output_connections[input_offset] += 1
input_node = resample_feature_map(
input_node,
new_node_width,
feat_dims,
convolution=convolution,
normalization=normalization,
activation=activation,
pool_type=pool_type,
apply_bn=apply_bn,
name=node_name +
"/resample_{}_{}_{}".format(idx, input_offset, len(feats)))
nodes.append(input_node)
if fusion_type == "weighted_sum":
if len(fnode["inputs_offsets"]) == 2:
new_node = WeightedFusion2(name=node_name)(nodes)
if len(fnode["inputs_offsets"]) == 3:
new_node = WeightedFusion3(name=node_name)(nodes)
elif fusion_type == "sum":
new_node = tf.keras.layers.Add(name=node_name)(nodes)
else:
raise ValueError("Unknown fusion type: {}".format(fusion_type))
new_node_name = node_name + "/op_after_combine{}".format(len(feats))
new_node = build_activation(**activation,
name=new_node_name + "/" +
activation["activation"])(new_node)
new_node = build_convolution(convolution,
filters=feat_dims,
kernel_size=(3, 3),
padding="same",
name=new_node_name + "/conv")(new_node)
new_node = build_normalization(**normalization,
name=new_node_name + "/bn")(new_node)
# new_node = build_activation(
# **activation, name=new_node_name + "/" + activation["activation"] + "_1")(new_node)
feats.append(new_node)
num_output_connections.append(0)
outputs = []
for level in range(min_level, max_level + 1):
for i, fnode in enumerate(reversed(node_configs)):
if fnode["width_ratio"] == F(level):
outputs.append(feats[-1 - i])
break
return outputs
def bottleneck_v1(x,
convolution,
filters,
strides=1,
dilation_rate=1,
normalization=dict(normalization="batch_norm",
momentum=0.9,
epsilon=1e-5,
axis=-1,
trainable=True),
activation=dict(activation="relu"),
trainable=True,
weight_decay=0.,
dropblock=None,
use_conv_shortcut=True,
name=None):
"""A residual block.
Args:
x: input tensor.
filters: integer, filters of the bottleneck layer.
convolution: The convolution type.
strides: default 1, stride of the first layer.
dilation_rate: default 1, dilation rate in 3x3 convolution.
activation: the activation layer name.
trainable: does this block is trainable.
normalization: the normalization, e.g. "batch_norm", "group_norm" etc.
weight_decay: weight decay.
dropblock: the arguments in DropBlock2D
use_conv_shortcut: default True, use convolution shortcut if True,
otherwise identity shortcut.
name: string, block label.
Returns:
Output tensor for the residual block.
"""
if use_conv_shortcut is True:
shortcut = build_convolution(
convolution,
filters=4 * filters,
kernel_size=1,
strides=strides,
trainable=trainable,
kernel_regularizer=tf.keras.regularizers.l2(weight_decay),
name=name + "_0_conv")(x)
shortcut = build_normalization(**normalization,
name=name + "_0_bn")(shortcut)
else:
shortcut = x
if dropblock is not None:
shortcut = DropBlock2D(**dropblock,
name=name + "_0_dropblock")(shortcut)
x = build_convolution(
convolution,
filters=filters,
kernel_size=1,
strides=strides,
trainable=trainable,
kernel_regularizer=tf.keras.regularizers.l2(weight_decay),
name=name + "_1_conv")(x)
x = build_normalization(**normalization, name=name + "_1_bn")(x)
x = tf.keras.layers.Activation(**activation, name=name + "_1_relu")(x)
if dropblock is not None:
x = DropBlock2D(**dropblock, name=name + "_1_dropblock")(x)
x = build_convolution(
convolution,
filters=filters,
kernel_size=3,
strides=1,
padding="SAME",
dilation_rate=dilation_rate,
trainable=trainable,
kernel_regularizer=tf.keras.regularizers.l2(weight_decay),
name=name + "_2_conv")(x)
x = build_normalization(**normalization, name=name + "_2_bn")(x)
x = tf.keras.layers.Activation(**activation, name=name + "_2_relu")(x)
if dropblock is not None:
x = DropBlock2D(**dropblock, name=name + "_2_dropblock")(x)
x = build_convolution(
convolution,
filters=4 * filters,
kernel_size=1,
trainable=trainable,
kernel_regularizer=tf.keras.regularizers.l2(weight_decay),
name=name + "_3_conv")(x)
x = build_normalization(**normalization, name=name + "_3_bn")(x)
if dropblock is not None:
x = DropBlock2D(**dropblock, name=name + "_3_dropblock")(x)
x = tf.keras.layers.Add(name=name + "_add")([shortcut, x])
x = tf.keras.layers.Activation(**activation, name=name + "_out")(x)
return x
def bottleneckx(x,
convolution,
filters,
strides=1,
dilation_rate=1,
cardinality=32,
normalization=dict(normalization="batch_norm",
momentum=0.9,
epsilon=1e-5,
axis=-1,
trainable=True),
activation=dict(activation="relu"),
trainable=True,
weight_decay=0.,
use_conv_shortcut=True,
name=None):
"""A residual block.
Args:
x: input tensor.
filters: integer, filters of the bottleneck layer.
convolution: The convolution type.
strides: default 1, stride of the first layer.
dilation_rate: default 1, dilation rate in 3x3 convolution.
cardinality: default 32, the cardinality in resnext.
activation: the activation layer name.
trainable: does this block is trainable.
normalization: the normalization, e.g. "batch_norm", "group_norm" etc.
weight_decay: the weight decay.
use_conv_shortcut: default True, use convolution shortcut if True,
otherwise identity shortcut.
name: string, block label.
Returns:
Output tensor for the residual block.
"""
bn_axis = 3 if tf.keras.backend.image_data_format(
) == "channels_last" else 1
if use_conv_shortcut:
shortcut = build_convolution(
convolution,
filters=(64 // cardinality) * filters,
kernel_size=1,
strides=strides,
use_bias=False,
trainable=trainable,
kernel_regularizer=tf.keras.regularizers.l2(weight_decay),
name=name + "_0_conv")(x)
shortcut = build_normalization(**normalization,
name=name + "_0_bn")(shortcut)
else:
shortcut = x
x = tf.keras.layers.Conv2D(filters,
1,
use_bias=False,
trainable=trainable,
name=name + "_1_conv")(x)
x = build_normalization(**normalization, name=name + "_1_bn")(x)
x = tf.keras.layers.Activation(activation, name=name + "_1_relu")(x)
c = filters // cardinality
x = tf.keras.layers.ZeroPadding2D(padding=((1, 1), (1, 1)),
name=name + "_2_pad")(x)
x = tf.keras.layers.DepthwiseConv2D(3,
strides=strides,
depth_multiplier=c,
dilation_rate=dilation_rate,
use_bias=False,
trainable=trainable,
name=name + "_2_conv")(x)
kernel = np.zeros((1, 1, filters * c, filters), dtype=np.float32)
for i in range(filters):
start = (i // c) * c * c + i % c
end = start + c * c
kernel[:, :, start:end:c, i] = 1.
x = tf.keras.layers.Conv2D(filters,
1,
use_bias=False,
trainable=False,
kernel_initializer={
"class_name": "Constant",
"config": {
"value": kernel
}
},
name=name + "_2_gconv")(x)
x = build_normalization(**normalization, name=name + "_2_bn")(x)
x = tf.keras.layers.Activation("relu", name=name + "_2_relu")(x)
x = tf.keras.layers.Conv2D((64 // cardinality) * filters,
1,
use_bias=False,
trainable=trainable,
name=name + "_3_conv")(x)
x = build_normalization(**normalization, name=name + "_3_bn")(x)
x = tf.keras.layers.Add(name=name + "_add")([shortcut, x])
x = tf.keras.layers.Activation("relu", name=name + "_out")(x)
return x
def build_model(self):
trainable = 0 not in self.frozen_stages
def _norm(inp):
inp = tf.image.convert_image_dtype(inp, tf.float32)
inp = inp / 127.5 - 1.
return inp
x = tf.keras.layers.Lambda(function=_norm,
name="norm_input")(self.img_input)
x = tf.keras.layers.ZeroPadding2D(padding=((3, 3), (3, 3)),
name="conv1_pad")(x)
x1 = build_convolution(self.convolution,
filters=64,
kernel_size=7,
strides=self.strides[0],
padding="valid",
dilation_rate=self.dilation_rates[0],
trainable=trainable,
use_bias=True,
name="conv1_conv")(x)
x = tf.keras.layers.ZeroPadding2D(padding=((1, 1), (1, 1)),
name="pool1_pad")(x1)
x = tf.keras.layers.MaxPool2D((3, 3),
strides=self.strides[1],
padding="valid",
name="pool1_pool")(x)
trainable = 1 not in self.frozen_stages
x, _ = self.stack(x, 64, self.strides[2], self.dilation_rates[1],
trainable, self.blocks[0], "conv2")
trainable = 2 not in self.frozen_stages
x, preact2 = self.stack(x, 128, self.strides[3],
self.dilation_rates[2], trainable,
self.blocks[1], "conv3")
trainable = 3 not in self.frozen_stages
x, preact3 = self.stack(x, 256, self.strides[4],
self.dilation_rates[3], trainable,
self.blocks[2], "conv4")
trainable = 4 not in self.frozen_stages
x, preact4 = self.stack(x, 512, 1, self.dilation_rates[4], trainable,
self.blocks[3], "conv5")
x = build_normalization(**self.normalization, name="post_bn")(x)
x5 = tf.keras.layers.Activation(**self.activation, name="post_relu")(x)
if -1 in self.output_indices:
x = tf.keras.layers.GlobalAvgPool2D(name="avg_pool")(x5)
x = tf.keras.layers.Dropout(rate=self.drop_rate)(x)
outputs = tf.keras.layers.Dense(self.num_classes, name="probs")(x)
else:
outputs = [
o for i, o in enumerate([x1, preact2, preact3, preact4, x5])
if i in self.output_indices
]
return tf.keras.Model(inputs=self.img_input,
outputs=outputs,
name=self.name)
def build_model(self):
inputs = tf.keras.layers.Input((None, None, 3))
trainable = 1 not in self.frozen_stages
x = tf.keras.layers.Lambda(function=lambda inp: (
(inp * (1. / 255.)) - self._rgb_mean) / self._rgb_std)(inputs)
x = tf.keras.layers.ZeroPadding2D(padding=((3, 3), (3, 3)))(x)
x = build_convolution(self.convolution,
filters=64,
kernel_size=7,
strides=self.strides[0],
use_bias=False,
trainable=trainable,
name="conv1/conv")(x)
x = build_normalization(**self.normalization, name="conv1/bn")(x)
x1 = tf.keras.layers.Activation(**self.activation,
name="conv1/relu")(x)
trainable = 2 not in self.frozen_stages
x = tf.keras.layers.ZeroPadding2D(padding=((1, 1), (1, 1)))(x)
x = tf.keras.layers.MaxPool2D(3, strides=self.strides[1],
name="pool1")(x)
x = self.dense_block(x,
blocks=self.blocks[0],
dilation_rate=self.dilation_rates[1],
drop_rate=self.drop_rate,
trainable=trainable,
name="conv2")
trainable = 3 not in self.frozen_stages
preact2, x = self.transition_block(x, 0.5, self.strides[2], trainable,
"pool2")
x = self.dense_block(x,
blocks=self.blocks[1],
dilation_rate=self.dilation_rates[2],
drop_rate=self.drop_rate,
trainable=trainable,
name="conv3")
trainable = 4 not in self.frozen_stages
preact3, x = self.transition_block(x, 0.5, self.strides[3], trainable,
"pool3")
x = self.dense_block(x,
blocks=self.blocks[2],
dilation_rate=self.dilation_rates[3],
drop_rate=self.drop_rate,
trainable=trainable,
name="conv4")
trainable = 5 not in self.frozen_stages
preact4, x = self.transition_block(x, 0.5, self.strides[4], trainable,
"pool4")
x = self.dense_block(x,
blocks=self.blocks[3],
dilation_rate=self.dilation_rates[4],
drop_rate=self.drop_rate,
trainable=trainable,
name="conv5")
x = build_normalization(**self.normalization, name="bn")(x)
x5 = tf.keras.layers.Activation(**self.activation, name="relu")(x)
if self._is_classifier:
x = tf.keras.layers.GlobalAvgPool2D(name="avg_pool")(x5)
x = tf.keras.layers.Dense(self.num_classes, name="fc1000")(x)
return tf.keras.Model(inputs=inputs, outputs=x)
else:
outputs = [
o for i, o in enumerate([x1, preact2, preact3, preact4, x5])
if i + 1 in self.output_indices
]
return tf.keras.Model(inputs=inputs,
outputs=outputs,
name=self.name)
def build_model(self):
outputs = []
x = tf.keras.layers.Lambda(function=lambda inp: inp - [self._r_mean, self._b_mean, self._g_mean])(self.img_input)
x = tf.keras.Sequential([
build_convolution(self.convolution,
filters=64,
kernel_size=(3, 3),
strides=(1, 1),
padding="same",
dilation_rate=self.dilation_rates[0],
activation=self.activation,
name="conv1_%d" % (i+1))
for i in range(VGG.BLOCKS[self.depth][0])], name="conv1")(x)
x= tf.keras.layers.MaxPool2D((2, 2), self.strides[0], "same", name="pool1")(x)
x = tf.keras.Sequential([
build_convolution(self.convolution,
filters=128,
kernel_size=(3, 3),
strides=(1, 1),
padding="same",
dilation_rate=self.dilation_rates[1],
activation=self.activation,
name="conv2_%d" % (i+1))
for i in range(VGG.BLOCKS[self.depth][1])], name="conv2")(x)
outputs.append(x)
x= tf.keras.layers.MaxPool2D((2, 2), self.strides[1], "same", name="pool2")(x)
x = tf.keras.Sequential([
build_convolution(self.convolution,
filters=256,
kernel_size=(3, 3),
strides=(1, 1),
padding="same",
dilation_rate=self.dilation_rates[2],
activation=self.activation,
name="conv3_%d" % (i+1))
for i in range(VGG.BLOCKS[self.depth][2])], name="conv3")(x)
outputs.append(x)
x = tf.keras.layers.MaxPool2D((2, 2), self.strides[2], "same", name="pool3")(x)
x = tf.keras.Sequential([
build_convolution(self.convolution,
filters=512,
kernel_size=(3, 3),
strides=(1, 1),
padding="same",
dilation_rate=self.dilation_rates[2],
activation=self.activation,
name="conv4_%d" % (i + 1))
for i in range(VGG.BLOCKS[self.depth][3])], name="conv4")(x)
outputs.append(x)
x = tf.keras.layers.MaxPool2D((2, 2), self.strides[3], "same", name="pool4")(x)
x = tf.keras.Sequential([
build_convolution(self.convolution,
filters=512,
kernel_size=(3, 3),
strides=(1, 1),
padding="same",
dilation_rate=self.dilation_rates[2],
activation=self.activation,
name="conv5_%d" % (i + 1))
for i in range(VGG.BLOCKS[self.depth][4])], name="conv5")(x)
outputs.append(x)
if -1 not in self.output_indices:
return (outputs[i-1] for i in self.output_indices)
x = tf.keras.layers.MaxPool2D((2, 2), self.strides[4], "same", name="pool5")(x)
x = build_convolution(self.convolution,
filters=4096,
kernel_size=(7, 7),
strides=(1, 1),
padding="valid",
activation=self.activation,
name="fc6")(x)
x = tf.keras.layers.Dropout(rate=self.drop_rate)(x)
x = build_convolution(self.convolution,
filters=4096,
kernel_size=(1, 1),
strides=(1, 1),
padding="same",
activation=self.activation,
name="fc7")(x)
x = tf.keras.layers.Lambda(
function=lambda inp: tf.reduce_mean(inp, [1, 2], keepdims=True),
name="global_pool")(x)
x = tf.keras.layers.Dropout(rate=self.drop_rate)(x)
x = build_convolution(self.convolution,
filters=self.num_classes,
kernel_size=(1, 1),
strides=(1, 1),
padding="same",
kernel_initializer="he_normal",
name="fc8")(x)
x = tf.keras.layers.Lambda(function=lambda inp: tf.squeeze(inp, axis=[1, 2]), name="squeeze")(x)
return tf.keras.Model(inputs=self.img_input, outputs=x, name=self.name)
def __init__(self,
convolution="conv2d",
normalization="batch_norm",
activation="relu",
output_indices=(-1, ),
strides=(2, 2, 2, 2, 2),
dilation_rates=(1, 1, 1, 1, 1),
freezing_stages=(-1, ),
freezing_batch_normalization=False,
group=32,
weight_decay=0.):
super(NewResNet18, self).__init__(
convolution=convolution,
normalization=normalization,
activation=activation,
output_indices=output_indices,
strides=strides,
dilation_rates=dilation_rates,
freezing_stages=freezing_stages,
freezing_batch_normalization=freezing_batch_normalization,
weight_decay=weight_decay)
axis = 3 if tf.keras.backend.image_data_format(
) == "channels_last" else 1
self.conv1_1 = tf.keras.Sequential([
build_convolution(
convolution,
filters=16,
kernsl_size=7,
padding="same",
dilation_rate=dilation_rates[0],
kernel_regularizer=tf.keras.regularizers.l2(weight_decay),
use_bias=False),
build_normalization(normalization, asix=axis, group=group),
tf.keras.layers.Activation(activation)
])
self.conv1_2 = BasicBlock(convolution=convolution,
filters=16,
strides=1,
dilation_rate=dilation_rates[0],
normalization=normalization,
group=16,
activation=activation,
weight_decay=weight_decay,
use_conv_shortcut=False)
self.conv1_3 = BasicBlock(convolution=convolution,
filters=32,
strides=strides[0],
dilation_rate=dilation_rates[0],
normalization=normalization,
group=16,
activation=activation,
weight_decay=weight_decay,
use_conv_shortcut=True)
self.conv2_1 = BasicBlock(convolution=convolution,
filters=64,
strides=strides[1],
dilation_rate=dilation_rates[1],
normalization=normalization,
group=16,
activation=activation,
weight_decay=weight_decay,
use_conv_shortcut=True)
self.conv2_2 = BasicBlock(convolution=convolution,
filters=64,
strides=1,
dilation_rate=dilation_rates[1],
normalization=normalization,
group=16,
activation=activation,
weight_decay=weight_decay,
use_conv_shortcut=False)
self.conv3_1 = BasicBlock(convolution=convolution,
filters=128,
strides=strides[2],
dilation_rate=dilation_rates[2],
normalization=normalization,
group=16,
activation=activation,
weight_decay=weight_decay,
use_conv_shortcut=True)
self.conv3_2 = BasicBlock(convolution=convolution,
filters=128,
strides=1,
dilation_rate=dilation_rates[2],
normalization=normalization,
group=16,
activation=activation,
weight_decay=weight_decay,
use_conv_shortcut=False)
self.conv4_1 = BasicBlock(convolution=convolution,
filters=256,
strides=strides[3],
dilation_rate=dilation_rates[3],
normalization=normalization,
group=16,
activation=activation,
weight_decay=weight_decay,
use_conv_shortcut=True)
self.conv4_2 = BasicBlock(convolution=convolution,
filters=256,
strides=1,
dilation_rate=dilation_rates[3],
normalization=normalization,
group=16,
activation=activation,
weight_decay=weight_decay,
use_conv_shortcut=False)
self.conv5_1 = BasicBlock(convolution=convolution,
filters=512,
strides=strides[4],
dilation_rate=dilation_rates[4],
normalization=normalization,
group=16,
activation=activation,
weight_decay=weight_decay,
use_conv_shortcut=True)
self.conv5_2 = BasicBlock(convolution=convolution,
filters=512,
strides=1,
dilation_rate=dilation_rates[4],
normalization=normalization,
group=16,
activation=activation,
weight_decay=weight_decay,
use_conv_shortcut=False)
def bottleneck_v2(x,
convolution,
filters,
strides=1,
dilation_rate=1,
normalization=dict(normalization="batch_norm",
momentum=0.9,
epsilon=1e-5,
axis=-1,
trainable=True),
activation=dict(activation="relu"),
trainable=True,
weight_decay=0.,
dropblock=None,
use_conv_shortcut=True,
name=None):
"""A residual block.
Args:
x: input tensor.
filters: integer, filters of the bottleneck layer.
convolution: The convolution type.
strides: default 1, stride of the first layer.
dilation_rate: default 1, dilation rate in 3x3 convolution.
activation: the activation layer name.
trainable: does this block is trainable.
normalization: the normalization, e.g. "batch_norm", "group_norm" etc.
weight_decay: weight decay.
dropblock: the arguments in DropBlock2D.
use_conv_shortcut: default True, use convolution shortcut if True,
otherwise identity shortcut.
name: string, block label.
Returns:
Output tensor for the residual block.
"""
bn_axis = 3 if tf.keras.backend.image_data_format(
) == "channels_last" else 1
preact = build_normalization(**normalization, name=name + "_preact_bn")(x)
preact = tf.keras.layers.Activation(**activation,
name=name + "_preact_relu")(preact)
if use_conv_shortcut is True:
shortcut = build_convolution(
convolution,
filters=4 * filters,
kernel_size=1,
strides=strides,
trainable=trainable,
kernel_regularizer=tf.keras.regularizers.l2(weight_decay),
name=name + "_0_conv")(preact)
else:
shortcut = tf.keras.layers.MaxPooling2D(
1, strides=strides)(x) if strides > 1 else x
if dropblock is not None:
shortcut = DropBlock2D(**dropblock,
name=name + "_0_dropblock")(shortcut)
x = build_convolution(
convolution,
filters=filters,
kernel_size=1,
strides=1,
use_bias=False,
trainable=trainable,
kernel_regularizer=tf.keras.regularizers.l2(weight_decay),
name=name + "_1_conv")(preact)
x = build_normalization(**normalization, name=name + "_1_bn")(x)
x = tf.keras.layers.Activation(**activation, name=name + "_1_relu")(x)
if dropblock is not None:
x = DropBlock2D(**dropblock, name=name + "_1_dropblock")(x)
x = tf.keras.layers.ZeroPadding2D(padding=((1, 1), (1, 1)),
name=name + "_2_pad")(x)
x = build_convolution(
convolution,
filters=filters,
kernel_size=3,
strides=strides,
dilation_rate=1 if strides > 1 else dilation_rate,
use_bias=False,
trainable=trainable,
kernel_regularizer=tf.keras.regularizers.l2(weight_decay),
name=name + "_2_conv")(x)
x = build_normalization(**normalization, name=name + "_2_bn")(x)
x = tf.keras.layers.Activation(**activation, name=name + "_2_relu")(x)
if dropblock is not None:
x = DropBlock2D(**dropblock)(x)
x = build_convolution(
convolution,
filters=4 * filters,
kernel_size=1,
trainable=trainable,
kernel_regularizer=tf.keras.regularizers.l2(weight_decay),
name=name + "_3_conv")(x)
if dropblock is not None:
x = DropBlock2D(**dropblock, name=name + "_2_dropblock")(x)
x = tf.keras.layers.Add(name=name + "_out")([shortcut, x])
return x, preact
