def my_model():
# prep layers
inp = layers.Input(shape=(32, 32, 3))
x = layers.Conv2D(64, 3, padding='same')(inp)
x = layers.BatchNormalization(momentum=0.8)(x)
x = layers.LeakyReLU(alpha=0.1)(x)
# layer1
x = layers.Conv2D(128, 3, padding='same')(x)
x = layers.MaxPool2D()(x)
x = layers.BatchNormalization(momentum=0.8)(x)
x = layers.LeakyReLU(alpha=0.1)(x)
x = layers.Add()([x, residual(x, 128)])
# layer2
x = layers.Conv2D(256, 3, padding='same')(x)
x = layers.MaxPool2D()(x)
x = layers.BatchNormalization(momentum=0.8)(x)
x = layers.LeakyReLU(alpha=0.1)(x)
# layer3
x = layers.Conv2D(512, 3, padding='same')(x)
x = layers.MaxPool2D()(x)
x = layers.BatchNormalization(momentum=0.8)(x)
x = layers.LeakyReLU(alpha=0.1)(x)
x = layers.Add()([x, residual(x, 512)])
# layers4
x = layers.GlobalMaxPool2D()(x)
x = layers.Flatten()(x)
x = layers.Dense(10)(x)
x = layers.Activation('softmax', dtype='float32')(x)
model = tf.keras.Model(inputs=inp, outputs=x)
return model
def SplitAttentionConv2D(x,
filters,
kernel_size,
stride=1,
padding=(0, 0),
groups=1,
use_bias=True,
radix=2,
name=None):
bn_axis = 3 if backend.image_data_format() == 'channels_last' else 1
reduction_factor = 4
inter_filters = max(filters * radix // reduction_factor, 32)
x = layers.ZeroPadding2D((padding, padding), name=name + '_splat_pad')(x)
x = layers.Conv2D(filters * radix,
kernel_size=kernel_size,
strides=stride,
groups=groups * radix,
use_bias=use_bias,
name=name + '_0_splat_conv')(x)
x = layers.BatchNormalization(axis=bn_axis,
epsilon=1.001e-5,
name=name + '_0_splat_bn')(x)
x = layers.Activation('relu', name=name + '_0_splat_relu')(x)
splits = layers.Lambda(lambda x: tf.split(x, radix, bn_axis),
name=name + '_0_splat_split')(x)
x = layers.Add(name=name + '_0_splat_add')(splits)
x = layers.GlobalAveragePooling2D(name=name + '_0_splat_pool')(x)
shape = (1, 1, filters) if bn_axis == 3 else (filters, 1, 1)
x = layers.Reshape(shape, name=name + '_0_splat_reshape')(x)
x = layers.Conv2D(inter_filters,
kernel_size=1,
groups=groups,
name=name + '_1_splat_conv')(x)
x = layers.BatchNormalization(axis=bn_axis,
epsilon=1.001e-5,
name=name + '_1_splat_bn')(x)
x = layers.Activation('relu', name=name + '_1_splat_relu')(x)
# Attention
x = layers.Conv2D(filters * radix,
kernel_size=1,
groups=groups,
name=name + '_2_splat_conv')(x)
x = RSoftmax(x, filters * radix, radix, groups, name=name)
x = layers.Lambda(lambda x: tf.split(x, radix, bn_axis),
name=name + '_1_splat_split')(x)
x = layers.Lambda(
lambda x: [tf.stack(x[0], axis=bn_axis),
tf.stack(x[1], axis=bn_axis)],
name=name + '_splat_stack')([splits, x])
x = layers.Multiply(name=name + '_splat_mult')(x)
x = layers.Lambda(lambda x: tf.unstack(x, axis=bn_axis),
name=name + '_splat_unstack')(x)
x = layers.Add(name=name + '_splat_add')(x)
return x
def RetinaNet(input_shape, num_classes, num_anchor=9):
"""Creates the RetinaNet.
RetinaNet is composed of an FPN, a classification sub-network and a localization regression sub-network.
Args:
input_shape (tuple): shape of input image.
num_classes (int): number of classes.
num_anchor (int, optional): number of anchor boxes. Defaults to 9.
Returns:
'Model' object: RetinaNet.
"""
inputs = tf.keras.Input(shape=input_shape)
# FPN
resnet50 = tf.keras.applications.ResNet50(weights="imagenet", include_top=False, input_tensor=inputs, pooling=None)
assert resnet50.layers[80].name == "conv3_block4_out"
C3 = resnet50.layers[80].output
assert resnet50.layers[142].name == "conv4_block6_out"
C4 = resnet50.layers[142].output
assert resnet50.layers[-1].name == "conv5_block3_out"
C5 = resnet50.layers[-1].output
P5 = layers.Conv2D(256, kernel_size=1, strides=1, padding='same')(C5)
P5_upsampling = layers.UpSampling2D()(P5)
P4 = layers.Conv2D(256, kernel_size=1, strides=1, padding='same')(C4)
P4 = layers.Add()([P5_upsampling, P4])
P4_upsampling = layers.UpSampling2D()(P4)
P3 = layers.Conv2D(256, kernel_size=1, strides=1, padding='same')(C3)
P3 = layers.Add()([P4_upsampling, P3])
P6 = layers.Conv2D(256, kernel_size=3, strides=2, padding='same', name="P6")(C5)
P7 = layers.Activation('relu')(P6)
P7 = layers.Conv2D(256, kernel_size=3, strides=2, padding='same', name="P7")(P7)
P5 = layers.Conv2D(256, kernel_size=3, strides=1, padding='same', name="P5")(P5)
P4 = layers.Conv2D(256, kernel_size=3, strides=1, padding='same', name="P4")(P4)
P3 = layers.Conv2D(256, kernel_size=3, strides=1, padding='same', name="P3")(P3)
# classification subnet
cls_subnet = classification_sub_net(num_classes=num_classes, num_anchor=num_anchor)
P3_cls = cls_subnet(P3)
P4_cls = cls_subnet(P4)
P5_cls = cls_subnet(P5)
P6_cls = cls_subnet(P6)
P7_cls = cls_subnet(P7)
cls_output = layers.Concatenate(axis=-2)([P3_cls, P4_cls, P5_cls, P6_cls, P7_cls])
# localization subnet
loc_subnet = regression_sub_net(num_anchor=num_anchor)
P3_loc = loc_subnet(P3)
P4_loc = loc_subnet(P4)
P5_loc = loc_subnet(P5)
P6_loc = loc_subnet(P6)
P7_loc = loc_subnet(P7)
loc_output = layers.Concatenate(axis=-2)([P3_loc, P4_loc, P5_loc, P6_loc, P7_loc])
return tf.keras.Model(inputs=inputs, outputs=[cls_output, loc_output])
def ResNet9(input_size: Tuple[int, int, int] = (32, 32, 3),
classes: int = 10) -> tf.keras.Model:
"""A small 9-layer ResNet Tensorflow model for cifar10 image classification.
The model architecture is from https://github.com/davidcpage/cifar10-fast
Args:
input_size: The size of the input tensor (height, width, channels).
classes: The number of outputs the model should generate.
Raises:
ValueError: Length of `input_size` is not 3.
ValueError: `input_size`[0] or `input_size`[1] is not a multiple of 16.
Returns:
A TensorFlow ResNet9 model.
"""
_check_input_size(input_size)
# prep layers
inp = layers.Input(shape=input_size)
x = layers.Conv2D(64, 3, padding='same')(inp)
x = layers.BatchNormalization(momentum=0.8)(x)
x = layers.LeakyReLU(alpha=0.1)(x)
# layer1
x = layers.Conv2D(128, 3, padding='same')(x)
x = layers.MaxPool2D()(x)
x = layers.BatchNormalization(momentum=0.8)(x)
x = layers.LeakyReLU(alpha=0.1)(x)
x = layers.Add()([x, residual(x, 128)])
# layer2
x = layers.Conv2D(256, 3, padding='same')(x)
x = layers.MaxPool2D()(x)
x = layers.BatchNormalization(momentum=0.8)(x)
x = layers.LeakyReLU(alpha=0.1)(x)
# layer3
x = layers.Conv2D(512, 3, padding='same')(x)
x = layers.MaxPool2D()(x)
x = layers.BatchNormalization(momentum=0.8)(x)
x = layers.LeakyReLU(alpha=0.1)(x)
x = layers.Add()([x, residual(x, 512)])
# layers4
x = layers.GlobalMaxPool2D()(x)
x = layers.Flatten()(x)
x = layers.Dense(classes)(x)
x = layers.Activation('softmax', dtype='float32')(x)
model = tf.keras.Model(inputs=inp, outputs=x)
return model
def block2(x,
filters,
kernel_size=3,
stride=1,
conv_shortcut=False,
name=None):
"""A residual block.
Arguments:
x: input tensor.
filters: integer, filters of the bottleneck layer.
kernel_size: default 3, kernel size of the bottleneck layer.
stride: default 1, stride of the first layer.
conv_shortcut: default False, use convolution shortcut if True,
otherwise identity shortcut.
name: string, block label.
Returns:
Output tensor for the residual block.
"""
bn_axis = 3 if backend.image_data_format() == 'channels_last' else 1
preact = layers.BatchNormalization(axis=bn_axis,
epsilon=1.001e-5,
name=name + '_preact_bn')(x)
preact = layers.Activation('relu', name=name + '_preact_relu')(preact)
if conv_shortcut:
shortcut = layers.Conv2D(4 * filters,
1,
strides=stride,
name=name + '_0_conv')(preact)
else:
shortcut = layers.MaxPooling2D(1,
strides=stride)(x) if stride > 1 else x
x = layers.Conv2D(filters,
1,
strides=1,
use_bias=False,
name=name + '_1_conv')(preact)
x = layers.BatchNormalization(axis=bn_axis,
epsilon=1.001e-5,
name=name + '_1_bn')(x)
x = layers.Activation('relu', name=name + '_1_relu')(x)
x = layers.ZeroPadding2D(padding=((1, 1), (1, 1)), name=name + '_2_pad')(x)
x = layers.Conv2D(filters,
kernel_size,
strides=stride,
use_bias=False,
name=name + '_2_conv')(x)
x = layers.BatchNormalization(axis=bn_axis,
epsilon=1.001e-5,
name=name + '_2_bn')(x)
x = layers.Activation('relu', name=name + '_2_relu')(x)
x = layers.Conv2D(4 * filters, 1, name=name + '_3_conv')(x)
x = layers.Add(name=name + '_out')([shortcut, x])
return x
def _inverted_res_block(inputs, expansion, stride, alpha, filters, block_id):
channel_axis = 1 if backend.image_data_format() == 'channels_first' else -1
in_channels = backend.int_shape(inputs)[channel_axis]
pointwise_conv_filters = int(filters * alpha)
pointwise_filters = _make_divisible(pointwise_conv_filters, 8)
x = inputs
prefix = 'block_{}_'.format(block_id)
if block_id:
# Expand
x = layers.Conv2D(round(expansion * in_channels),
kernel_size=1,
padding='same',
use_bias=False,
activation=None,
kernel_regularizer=regularizers.l2(l2_reg),
name=prefix + 'expand')(x)
x = layers.BatchNormalization(axis=channel_axis,
epsilon=1e-3,
momentum=0.999,
name=prefix + 'expand_BN')(x)
x = layers.ReLU(6., name=prefix + 'expand_relu')(x)
else:
prefix = 'expanded_conv_'
# Depthwise
if stride == 2:
x = layers.ZeroPadding2D(padding=correct_pad(backend, x, 3),
name=prefix + 'pad')(x)
x = layers.DepthwiseConv2D(kernel_size=3,
strides=stride,
activation=None,
use_bias=False,
depthwise_regularizer=regularizers.l2(l2_reg),
padding='same' if stride == 1 else 'valid',
name=prefix + 'depthwise')(x)
x = layers.BatchNormalization(axis=channel_axis,
epsilon=1e-3,
momentum=0.999,
name=prefix + 'depthwise_BN')(x)
x = layers.ReLU(6., name=prefix + 'depthwise_relu')(x)
# Project
x = layers.Conv2D(pointwise_filters,
kernel_size=1,
padding='same',
use_bias=False,
activation=None,
kernel_regularizer=regularizers.l2(l2_reg),
name=prefix + 'project')(x)
x = layers.BatchNormalization(axis=channel_axis,
epsilon=1e-3,
momentum=0.999,
name=prefix + 'project_BN')(x)
if in_channels == pointwise_filters and stride == 1:
return layers.Add(name=prefix + 'add')([inputs, x])
return x
def __init__(self, F, scale_f, *args, **kwargs):
super(_ResBlock, self).__init__(*args, **kwargs)
self.conv1 = layers.Conv2D(F, (3, 3),
padding="same",
activation='relu')
self.conv2 = layers.Conv2D(F, (3, 3), padding="same")
self.scale = layers.Lambda(lambda x: scale_f * x, name="scale")
self.add = layers.Add(name="add")
def stem(x, filters, kernel_size=kernel_size, padding="same", strides=1):
conv = layers.Conv2D(filters, kernel_size, padding=padding, strides=strides)(x)
conv = conv_block(conv, filters, kernel_size=kernel_size, padding=padding, strides=strides, dilation_rate= dilation_rate)
shortcut = layers.Conv2D(filters, kernel_size=(1, 1), padding=padding, strides=strides, dilation_rate= dilation_rate)(x)
shortcut = bn_act(shortcut, act=False)
output = layers.Add()([conv, shortcut])
return output
def residual_block(x, filters, kernel_size=(3, 3), padding="same", strides=1):# image dimensions are divided by the strides number
res = conv_block(x, filters, kernel_size=kernel_size, padding=padding, strides=strides)
res = conv_block(res, filters, kernel_size=kernel_size, padding=padding, strides=1)
shortcut = layers.Conv2D(filters, kernel_size=(1, 1), padding=padding, strides=strides)(x)
shortcut = bn_act(shortcut, act=False)
output = layers.Add()([shortcut, res])
return output
def resblock_body(x, num_filters, num_blocks):
'''A series of resblocks starting with a downsampling Convolution2D'''
# Darknet uses left and top padding instead of 'same' mode
x = kl.ZeroPadding2D(((1, 0), (1, 0)))(x)
x = DarknetConv2D_BN_Leaky(num_filters, (3, 3), strides=(2, 2))(x)
for i in range(num_blocks):
y = compose(DarknetConv2D_BN_Leaky(num_filters // 2, (1, 1)),
DarknetConv2D_BN_Leaky(num_filters, (3, 3)))(x)
x = kl.Add()([x, y])
return x
def identity_block(input_tensor,
kernel_size,
filters,
stage,
block,
use_bias=True,
norm_use="bn",
train_bn=True):
"""The identity_block is the block that has no conv layer at shortcut
# Arguments
input_tensor: input tensor
kernel_size: defualt 3, the kernel size of middle conv layer at main path
filters: list of integers, the nb_filters of 3 conv layer at main path
stage: integer, current stage label, used for generating layer names
block: 'a','b'..., current block label, used for generating layer names
use_bias: Boolean. To use or not use a bias in conv layers.
train_bn: Boolean. Train or freeze Batch Norm layres
"""
nb_filter1, nb_filter2, nb_filter3 = filters
conv_name_base = 'res' + str(stage) + block + '_branch'
norm_name_base = str(stage) + block + "_branch"
x = KL.Conv2D(nb_filter1, (1, 1),
name=conv_name_base + '2a',
kernel_initializer='he_normal',
use_bias=use_bias)(input_tensor)
x = normalize_layer(x,
name=norm_name_base + "2a",
norm_use=norm_use,
train_bn=train_bn)
x = KL.Activation('relu')(x)
x = KL.Conv2D(nb_filter2, (kernel_size, kernel_size),
padding='same',
kernel_initializer='he_normal',
name=conv_name_base + '2b',
use_bias=use_bias)(x)
x = normalize_layer(x,
name=norm_name_base + "2b",
norm_use=norm_use,
train_bn=train_bn)
x = KL.Activation('relu')(x)
x = KL.Conv2D(nb_filter3, (1, 1),
name=conv_name_base + '2c',
kernel_initializer='he_normal',
use_bias=use_bias)(x)
x = normalize_layer(x,
name=norm_name_base + "2c",
norm_use=norm_use,
train_bn=train_bn)
x = KL.Add()([x, input_tensor])
x = KL.Activation('relu', name='res' + str(stage) + block + '_out')(x)
return x
def resblock(input_tensor, num_channels):
"""
returns the basic unit of the ResNet network - the residual block
"""
conv1 = layers.Conv2D(num_channels, kernel_size=(3, 3),
padding='same')(input_tensor)
act = layers.Activation('relu')(conv1)
conv2 = layers.Conv2D(num_channels, kernel_size=(3, 3),
padding='same')(act)
add = layers.Add()([conv2, input_tensor])
return layers.Activation('relu')(add)
def _context_module(self,
num_filters,
inputs,
dropout_rate=0.3,
strides=(1, 1)):
conv_0 = self._conv_block(num_filters, inputs, strides=strides)
conv_1 = self._conv_block(num_filters, conv_0)
dropout = layers.SpatialDropout2D(rate=dropout_rate)(conv_1)
conv_2 = self._conv_block(num_filters, dropout)
sum_output = layers.Add()([conv_0, conv_2])
return sum_output
def ResidualBlock(input, num_filters):
# x = res_seq(num_filters)(input)
x = layers.Conv2D(num_filters, (1, 1))(input)
x = layers.BatchNormalization()(x)
x = layers.Activation('relu')(x)
x = layers.Conv2D(num_filters, (3, 3), padding='same')(x)
x = layers.BatchNormalization()(x)
x = layers.Activation('relu')(x)
x = layers.Conv2D(num_filters, (1, 1))(x)
x = layers.BatchNormalization()(x)
x = layers.Add()([x, input])
return layers.Activation('relu')(x)
def identity_block(x, **kwargs):
"""The identity block is the block that has no conv layer at shortcut.
# Arguments
input_tensor: input tensor
kernel_size: defualt 3, the kernel size of middle conv layer at main path
filters: list of integers, the filterss of 3 conv layer at main path
stage: integer, current stage label, used for generating layer names
block: 'a','b'..., current block label, used for generating layer names
# Returns
Output tensor for the block.
"""
kernel_size = get_varargin(kwargs, 'kernel_size', 3)
strides = get_varargin(kwargs, 'strides', (1,1))
stage = get_varargin(kwargs, 'stage', 2)
conv_block = get_varargin(kwargs, 'conv_block', False)
block_id = get_varargin(kwargs, 'block_id', 1)
if stage == 2:
filters = config.MODEL.RESNET.FILTERS_C2
elif stage == 3:
filters = config.MODEL.RESNET.FILTERS_C3
elif stage == 4:
filters = config.MODEL.RESNET.FILTERS_C4
else:
filters = config.MODEL.RESNET.FILTERS_C5
filters1, filters2, filters3 = filters
bn_axis = 3 # Channel last, tensorflow backend
prefix_blockname = 'C{}_branch2_blk{}_'.format(stage, block_id)
fx = KL.Conv2D(filters1, (1, 1), strides = strides, name = '{}Conv1'.format(prefix_blockname))(x)
fx = KL.BatchNormalization(axis=bn_axis, name = '{}Bnorm1'.format(prefix_blockname))(fx) #bn: batchnorm
fx = KL.Activation('relu', name = '{}Act1'.format(prefix_blockname))(fx)
fx = KL.Conv2D(filters2, kernel_size,padding='same', name = '{}Conv2'.format(prefix_blockname))(fx)
fx = KL.BatchNormalization(axis = bn_axis, name = '{}Bnorm2'.format(prefix_blockname))(fx)
fx = KL.Activation('relu', name = '{}Act2'.format(prefix_blockname))(fx)
fx = KL.Conv2D(filters3, (1, 1), name = '{}Conv3'.format(prefix_blockname))(fx)
fx = KL.BatchNormalization(axis=bn_axis, name = '{}Bnorm3'.format(prefix_blockname))(fx)
prefix_blockname = 'C{}_branch1_blk{}_'.format(stage, block_id)
#Shortcut branch
if conv_block is True:
shortcut = KL.Conv2D(filters3, (1, 1), strides = strides, name = '{}Conv1'.format(prefix_blockname))(x)
shortcut = KL.BatchNormalization(axis=bn_axis, name = '{}Bnorm1'.format(prefix_blockname))(shortcut)
else:
shortcut = x
# Merge
fx = KL.Add()([fx, shortcut])
fx = KL.Activation('relu')(fx)
return fx
def _resblock(x0, num_filter=256, kernel_size=3):
x = ReflectionPadding2D()(x0)
x = layers.Conv2D(filters=num_filter, kernel_size=kernel_size, kernel_initializer=RandomNormal(mean=0,
stddev=0.02))(x)
x = InstanceNormalization()(x)
x = layers.ReLU()(x)
x = ReflectionPadding2D()(x)
x = layers.Conv2D(filters=num_filter, kernel_size=kernel_size, kernel_initializer=RandomNormal(mean=0,
stddev=0.02))(x)
x = InstanceNormalization()(x)
x = layers.Add()([x, x0])
return x
def build_nn_model(height, width, num_channels, num_res_blocks):
"""
returns the complete Neural-Network model
"""
in1 = layers.Input(shape=(height, width, 1))
conv1 = layers.Conv2D(num_channels, kernel_size=(3, 3),
padding='same')(in1)
act = layers.Activation('relu')(conv1)
for i in range(num_res_blocks):
act = resblock(act, num_channels)
conv2 = layers.Conv2D(1, kernel_size=(3, 3), padding='same')(act)
add = layers.Add()([conv2, in1])
return models.Model(inputs=in1, outputs=add)
def layer(input_tensor):
x = input_tensor
residual = input_tensor
# bottleneck
x = layers.Conv2D(filters // 2, (1, 1),
kernel_initializer='he_uniform',
use_bias=False)(x)
x = layers.BatchNormalization(**bn_params)(x)
x = layers.Activation('relu')(x)
x = layers.ZeroPadding2D(1)(x)
x = GroupConv2D(filters, (3, 3),
strides=strides,
groups=groups,
kernel_initializer='he_uniform',
use_bias=False,
**kwargs)(x)
x = layers.BatchNormalization(**bn_params)(x)
x = layers.Activation('relu')(x)
x = layers.Conv2D(filters, (1, 1),
kernel_initializer='he_uniform',
use_bias=False)(x)
x = layers.BatchNormalization(**bn_params)(x)
# if number of filters or spatial dimensions changed
# make same manipulations with residual connection
x_channels = get_num_channels(x)
r_channels = get_num_channels(residual)
if strides != 1 or x_channels != r_channels:
if padding:
residual = layers.ZeroPadding2D(1)(residual)
residual = layers.Conv2D(x_channels,
downsample_kernel_size,
strides=strides,
kernel_initializer='he_uniform',
use_bias=False)(residual)
residual = layers.BatchNormalization(**bn_params)(residual)
# apply attention module
x = ChannelSE(reduction=reduction, **kwargs)(x)
# add residual connection
x = layers.Add()([x, residual])
x = layers.Activation('relu')(x)
return x
def _inverted_res_block(x, expansion, filters, kernel_size, stride, se_ratio,
activation, block_id):
channel_axis = 1 if backend.image_data_format() == 'channels_first' else -1
shortcut = x
prefix = 'expanded_conv/'
infilters = backend.int_shape(x)[channel_axis]
if block_id:
# Expand
prefix = 'expanded_conv_{}/'.format(block_id)
x = layers.Conv2D(_depth(infilters * expansion),
kernel_size=1,
padding='same',
use_bias=False,
name=prefix + 'expand')(x)
x = layers.BatchNormalization(axis=channel_axis,
epsilon=1e-3,
momentum=0.999,
name=prefix + 'expand/BatchNorm')(x)
x = activation(x)
if stride == 2:
x = layers.ZeroPadding2D(padding=imagenet_utils.correct_pad(
x, kernel_size),
name=prefix + 'depthwise/pad')(x)
x = layers.DepthwiseConv2D(kernel_size,
strides=stride,
padding='same' if stride == 1 else 'valid',
use_bias=False,
name=prefix + 'depthwise')(x)
x = layers.BatchNormalization(axis=channel_axis,
epsilon=1e-3,
momentum=0.999,
name=prefix + 'depthwise/BatchNorm')(x)
x = activation(x)
if se_ratio:
x = _se_block(x, _depth(infilters * expansion), se_ratio, prefix)
x = layers.Conv2D(filters,
kernel_size=1,
padding='same',
use_bias=False,
name=prefix + 'project')(x)
x = layers.BatchNormalization(axis=channel_axis,
epsilon=1e-3,
momentum=0.999,
name=prefix + 'project/BatchNorm')(x)
if stride == 1 and infilters == filters:
x = layers.Add(name=prefix + 'Add')([shortcut, x])
return x
def block1(x, filters, kernel_size=3, stride=1, conv_shortcut=True, name=None):
"""A residual block.
Arguments:
x: input tensor.
filters: integer, filters of the bottleneck layer.
kernel_size: default 3, kernel size of the bottleneck layer.
stride: default 1, stride of the first layer.
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 backend.image_data_format() == 'channels_last' else 1
if conv_shortcut:
shortcut = layers.Conv2D(4 * filters,
1,
strides=stride,
name=name + '_0_conv')(x)
shortcut = layers.BatchNormalization(axis=bn_axis,
epsilon=1.001e-5,
name=name + '_0_bn')(shortcut)
else:
shortcut = x
x = layers.Conv2D(filters, 1, strides=stride, name=name + '_1_conv')(x)
x = layers.BatchNormalization(axis=bn_axis,
epsilon=1.001e-5,
name=name + '_1_bn')(x)
x = layers.Activation('relu', name=name + '_1_relu')(x)
x = layers.Conv2D(filters,
kernel_size,
padding='SAME',
name=name + '_2_conv')(x)
x = layers.BatchNormalization(axis=bn_axis,
epsilon=1.001e-5,
name=name + '_2_bn')(x)
x = layers.Activation('relu', name=name + '_2_relu')(x)
x = layers.Conv2D(4 * filters, 1, name=name + '_3_conv')(x)
x = layers.BatchNormalization(axis=bn_axis,
epsilon=1.001e-5,
name=name + '_3_bn')(x)
x = layers.Add(name=name + '_add')([shortcut, x])
x = layers.Activation('relu', name=name + '_out')(x)
return x
def block(inputs):
if block_args.expand_ratio != 1:
x = KL.Conv2D(filters,
kernel_size=[1, 1],
strides=[1, 1],
kernel_initializer=conv_kernel_initializer,
padding='same',
use_bias=False)(inputs)
x = KL.BatchNormalization(axis=channel_axis,
momentum=batch_norm_momentum,
epsilon=batch_norm_epsilon)(x)
x = Swish()(x)
else:
x = inputs
x = KL.DepthwiseConv2D([kernel_size, kernel_size],
strides=block_args.strides,
depthwise_initializer=conv_kernel_initializer,
padding='same',
use_bias=False)(x)
x = KL.BatchNormalization(axis=channel_axis,
momentum=batch_norm_momentum,
epsilon=batch_norm_epsilon)(x)
x = Swish()(x)
if has_se:
x = SEBlock(block_args, global_params)(x)
# output phase
x = KL.Conv2D(block_args.output_filters,
kernel_size=[1, 1],
strides=[1, 1],
kernel_initializer=conv_kernel_initializer,
padding='same',
use_bias=False)(x)
x = KL.BatchNormalization(axis=channel_axis,
momentum=batch_norm_momentum,
epsilon=batch_norm_epsilon)(x)
if block_args.id_skip:
if all(s == 1 for s in block_args.strides
) and block_args.input_filters == block_args.output_filters:
# only apply drop_connect if skip presents.
if drop_connect_rate:
x = DropConnect(drop_connect_rate)(x)
x = KL.Add()([x, inputs])
return x
def build(self):
inputs = layers.Input(self.input_size)
output0 = self._context_module(16, inputs, strides=(1, 1))
output1 = self._context_module(32, output0, strides=(2, 2))
output2 = self._context_module(64, output1, strides=(2, 2))
output3 = self._context_module(128, output2, strides=(2, 2))
output4 = self._context_module(256, output3, strides=(2, 2))
decoder0 = self._decoder_block(128, [output3, output4])
decoder1 = self._decoder_block(64, [output2, decoder0])
decoder2 = self._decoder_block(32, [output1, decoder1])
decoder3 = self._decoder_block_last(16, [output0, decoder2])
output0 = layers.Conv2D(self.num_class, (1, 1))(decoder3)
output1 = layers.Conv2D(self.num_class, (1, 1))(decoder2)
output2_up = layers.UpSampling2D(size=(2, 2))(layers.Conv2D(
self.num_class, (1, 1))(decoder1))
output_sum = layers.Add()([output2_up, output1])
output_sum = layers.UpSampling2D(size=(2, 2))(output_sum)
output_sum = layers.Add()([output_sum, output0])
output = layers.Softmax()(output_sum)
return models.Model(inputs=[inputs], outputs=[output])
def net():
input_x = layers.Input(shape=(3, ), name="input_x")
input_z = layers.Input(shape=(2, ), name="input_z")
dense_1_x = layers.Dense(25, activation="relu")(input_x)
dense_1_z = layers.Dense(25, activation="relu")(input_z)
add = layers.Add()([dense_1_x, dense_1_z])
dense_2 = layers.Dense(10, activation="relu")(add)
dense_3 = layers.Dense(10, activation="relu")(dense_2)
output_cls = layers.Dense(3, activation="softmax",
name="classification")(dense_3)
output_reg = layers.Dense(2, activation="linear",
name="regression")(dense_3)
return Model(inputs=[input_x, input_z], outputs=[output_reg, output_cls])
def block2(x,
filters,
kernel_size=3,
stride=1,
conv_shortcut=False,
name=None):
bn_axis = 3 if backend.image_data_format() == 'channels_last' else 1
preact = layers.BatchNormalization(axis=bn_axis,
epsilon=1.001e-5,
name=name + '_preact_bn')(x)
preact = layers.Activation('relu', name=name + '_preact_relu')(preact)
if conv_shortcut:
shortcut = layers.Conv2D(4 * filters,
1,
strides=stride,
name=name + '_0_conv')(preact)
else:
shortcut = layers.MaxPooling2D(1,
strides=stride)(x) if stride > 1 else x
x = layers.Conv2D(filters,
1,
strides=1,
use_bias=False,
name=name + '_1_conv')(preact)
x = layers.BatchNormalization(axis=bn_axis,
epsilon=1.001e-5,
name=name + '_1_bn')(x)
x = layers.Activation('relu', name=name + '_1_relu')(x)
x = layers.ZeroPadding2D(padding=((1, 1), (1, 1)), name=name + '_2_pad')(x)
x = layers.Conv2D(filters,
kernel_size,
strides=stride,
use_bias=False,
name=name + '_2_conv')(x)
x = layers.BatchNormalization(axis=bn_axis,
epsilon=1.001e-5,
name=name + '_2_bn')(x)
x = layers.Activation('relu', name=name + '_2_relu')(x)
x = layers.Conv2D(4 * filters, 1, name=name + '_3_conv')(x)
x = layers.Add(name=name + '_out')([shortcut, x])
return x
def block1(x,
filters,
bottleneck=False,
stride=1,
expansion=1,
activation='relu',
bn_sync=BN_SYNC,
name=None):
"""A basic residual block.
Arguments:
x: input tensor.
filters: integer, filters of the bottleneck layer.
stride: default 1, stride of the first layer.
conv_shortcut: default True, use convolution shortcut if True,
otherwise identity shortcut.
name: string, block label.
Returns:
Output tensor for the residual block.
"""
conv_shortcut = (stride != 1) or (expansion*filters != x.shape[3])
if conv_shortcut:
shortcut = conv1x1(x, filters=expansion*filters, strides=stride,
name=name+'_0_conv')
shortcut = batchnorm(shortcut, bn_sync=bn_sync, name=name+'_0_bn')
else:
shortcut = x
# First conv.
if bottleneck:
x = conv1x1(x, filters=filters, strides=1, name=name+'_1_conv')
x = batchnorm(x, bn_sync=bn_sync, name=name+'_1_bn')
x = nonlinearity(x, layer_activation=activation, name=name+'_1_'+activation)
# Second conv.
idx = 2 if bottleneck else 1
x = conv3x3(x, filters=filters, strides=stride, name=name+'_%d_conv' %idx)
x = batchnorm(x, bn_sync=bn_sync, name=name+'_%d_bn' %idx)
x = nonlinearity(x, layer_activation=activation, name=name+'_%d_%s' %(idx, activation))
# Last conv.
last_conv = conv1x1 if bottleneck else conv3x3
x = last_conv(x, filters=expansion*filters, strides=1, name=name+'_%d_conv' %(idx+1))
x = batchnorm(x, bn_sync=bn_sync, name=name+'_%d_bn' %(idx+1))
# Skip connection.
x = layers.Add(name=name+'_add')([shortcut, x])
x = nonlinearity(x, layer_activation=activation, name=name+'_out_'+activation)
return x
def EDSR_func(inp, scale, F, nb_res, res_scale_f):
x = MeanShift(-1)(inp)
x = layers.Conv2D(F, (3, 3), padding="same")(inp)
conv1 = x
for i in range(nb_res):
x = _ResBlock(F, res_scale_f, name="res%d" % i)(x)
x = layers.Conv2D(F, (3, 3), padding="same")(x)
x = layers.Add()([conv1, x])
if scale == 2 or scale == 3:
x = SubpixelLayer(scale=scale, out_channel=F, kernel_size=3)(x)
elif scale == 4:
x = SubpixelLayer(scale=2, out_channel=F, kernel_size=3)(x)
x = SubpixelLayer(scale=2, out_channel=F, kernel_size=3)(x)
else:
raise ValueError("Wrong value of scale factor.")
out = layers.Conv2D(3, (3, 3), padding="same")(x)
out = MeanShift(1)(out)
return out
def shortcut(x, residual):
'''shortcut connection を作成する。
'''
x_shape = backend.int_shape(x)
residual_shape = backend.int_shape(residual)
if x_shape == residual_shape:
# x と residual の形状が同じ場合、なにもしない。
shortcut = x
else:
# x と residual の形状が異なる場合、線形変換を行い、形状を一致させる。
stride_w = int(round(x_shape[1] / residual_shape[1]))
stride_h = int(round(x_shape[2] / residual_shape[2]))
shortcut = layers.Conv2D(filters=residual_shape[3],
kernel_size=(1, 1),
strides=(stride_w, stride_h),
kernel_initializer='he_normal',
kernel_regularizer=regularizers.l2(1.e-4))(x)
return layers.Add()([shortcut, residual])
def build_model(self):
"""Build a critic (value) network that maps (state, action) pairs -> Q-values."""
# Define input layers
states = layers.Input(shape=(self.state_size, ), name='states')
actions = layers.Input(shape=(self.action_size, ), name='actions')
# Add hidden layer(s) for state pathway
net_states = layers.Dense(units=32, activation='relu')(states)
net_states = layers.Dropout(0.8)(net_states)
net_states = layers.Dense(units=64, activation='relu')(net_states)
net_states = layers.Dropout(0.8)(net_states)
# Add hidden layer(s) for action pathway
net_actions = layers.Dense(units=32, activation='relu')(actions)
net_actions = layers.Dense(units=64, activation='relu')(net_actions)
# Try different layer sizes, activations, add batch normalization, regularizers, etc.
# Combine state and action pathways
net = layers.Add()([net_states, net_actions])
net = layers.Activation('relu')(net)
# Add more layers to the combined network if needed
# Add final output layer to prduce action values (Q values)
Q_values = layers.Dense(units=1, name='q_values')(net)
# Create Keras model
self.model = models.Model(inputs=[states, actions], outputs=Q_values)
# Define optimizer and compile model for training with built-in loss function
optimizer = optimizers.Adam(lr=0.0001)
self.model.compile(optimizer=optimizer, loss='mse')
# Compute action gradients (derivative of Q values w.r.t. to actions)
action_gradients = K.gradients(Q_values, actions)
# Define an additional function to fetch action gradients (to be used by actor model)
self.get_action_gradients = K.function(
inputs=[*self.model.input, K.learning_phase()],
outputs=action_gradients)
def __init__(self, filter_num, channel, stride=1, reduction=16):
super().__init__()
self.conv1 = layers.Conv1D(filter_num,
3,
strides=stride,
padding='same')
self.bn1 = layers.BatchNormalization()
self.relu = layers.Activation('relu')
self.conv2 = layers.Conv1D(filter_num, 3, strides=1, padding='same')
self.bn2 = layers.BatchNormalization()
self.add = layers.Add()
self.se = SELayer(channel, reduction)
self.se2 = SELayer(channel, reduction)
if stride != 1:
self.downsample = Sequential()
self.downsample.add(layers.Conv1D(filter_num, 1, strides=stride))
self.downsample.add(layers.BatchNormalization())
else:
self.downsample = lambda x: x
def block3(x,
filters,
bottleneck=False,
stride=1,
expansion=1,
activation='leaky_relu',
bn_sync=BN_SYNC,
conv_shortcut=False,
use_bias=False,
name=None):
""" A residual block.
"""
preact = batchnorm(x, bn_mom=0.999, bn_eps=0.001, bn_sync=bn_sync, name=name+'_preact_bn')
preact = nonlinearity(preact, layer_activation=activation,
name=name+'_preact_'+activation)
shortcut = preact if conv_shortcut else x
if shortcut.shape[3] != expansion*filters:
shortcut = conv1x1(shortcut, filters=expansion*filters, strides=stride,
use_bias=use_bias, name=name+'_0_conv')
# First conv.
if bottleneck:
x = conv1x1(preact, filters=filters, strides=1,
use_bias=use_bias, name=name+'_1_conv')
x = batchnorm(x, bn_mom=0.999, bn_eps=0.001, bn_sync=bn_sync, name=name+'_1_bn')
x = nonlinearity(x, layer_activation=activation, name=name+'_1_'+activation)
# Second conv.
idx = 2 if bottleneck else 1
x = conv3x3(x if bottleneck else preact, filters=filters, strides=stride,
use_bias=use_bias, name=name+'_%d_conv' %idx)
x = batchnorm(x, bn_mom=0.999, bn_eps=0.001, bn_sync=bn_sync, name=name+'_%d_bn' %idx)
x = nonlinearity(x, layer_activation=activation, name=name+'_%d_%s' %(idx, activation))
# Second conv.
last_conv = conv1x1 if bottleneck else conv3x3
x = last_conv(x, filters=expansion*filters, strides=1,
use_bias=use_bias, name=name+'_%d_conv' %(idx+1))
# Skip connection.
x = layers.Add(name=name+'_add')([shortcut, x])
return x
