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