def model(self, X, is_training, keep_prob):
# mask = (X + 1) / 2
# CONV L1
X = conv2d(X, scope="CONV_1", filter=32, kernel_size=3, strides=1,
padding="same", batch_norm=True, activation=tf.nn.relu, is_training=is_training)
X = tf.layers.max_pooling2d(X, pool_size=3, strides=2, padding="same")
# mask = tf.layers.average_pooling2d(mask, pool_size=3, strides=2, padding="same")
# mask = tf.where(mask>0.1, mask, tf.zeros_like(mask))
# X = tf.cast(tf.greater(mask, 0), tf.float32) * X
# INCEPTION L2
Res = conv2d(X, scope="CONV_res_2", filter=64,
kernel_size=1, strides=2, padding="same")
X = inception_v2(input=X, scope="INCEPTION_2a", filters=64,
batch_norm=True, activation=tf.nn.relu, is_training=is_training)
X = inception_v2(input=X, scope="INCEPTION_2b", filters=64,
batch_norm=True, activation=None, is_training=is_training)
X = tf.layers.max_pooling2d(X, pool_size=3, strides=2, padding="same")
# mask = tf.layers.max_pooling2d(mask, pool_size=3, strides=2, padding="same")
# X = tf.cast(tf.greater(mask, 0), tf.float32) * X
X = X + Res
# INCEPTION L3
Res = conv2d(X, scope="CONV_res_3", filter=128,
kernel_size=1, strides=2, padding="same")
X = tf.nn.relu(X)
X = inception_v2(input=X, scope="INCEPTION_3a", filters=128,
batch_norm=True, activation=tf.nn.relu, is_training=is_training)
X = inception_v2(input=X, scope="INCEPTION_3b", filters=128,
batch_norm=True, activation=None, is_training=is_training)
X = tf.layers.max_pooling2d(X, pool_size=3, strides=2, padding="same")
# mask = tf.layers.max_pooling2d(mask, pool_size=3, strides=2, padding="same")
# X = tf.cast(tf.greater(mask, 0), tf.float32) * X
X = X + Res
# INCEPTION L4
Res = conv2d(X, scope="CONV_res_4", filter=256,
kernel_size=1, strides=2, padding="same")
X = tf.nn.relu(X)
X = inception_v2(input=X, scope="INCEPTION_4a", filters=256,
batch_norm=True, activation=tf.nn.relu, is_training=is_training)
X = inception_v2(input=X, scope="INCEPTION_4b", filters=256,
batch_norm=True, activation=tf.nn.relu, is_training=is_training)
X = inception_v2(input=X, scope="INCEPTION_4c", filters=256,
batch_norm=True, activation=None, is_training=is_training)
X = tf.layers.max_pooling2d(X, pool_size=3, strides=2, padding="same")
X = X + Res
X = maxout(X, num_units=128)
# dw conv
X = deepwise_conv2d(X, scope="dw_conv", kernel_size=(
X.shape[1], X.shape[2]), strides=1, padding="valid")
# flatten
X = tf.layers.flatten(X)
# Output
X = tf.nn.l2_normalize(X, axis=-1)
return X
def __build_ssd_layers(self):
with tf.variable_scope('ssd_layer'):
conv6_2_pw_stop = tf.stop_gradient(self.base.conv6_2_pw)
self.ssd_conv7_1 = conv2d('sdd_conv7_1', conv6_2_pw_stop,
num_filters=256, kernel_size=(1, 1),
padding='SAME', stride=(1, 1), activation=tf.nn.relu,
batchnorm_enabled=self.args.batchnorm_enabled,
l2_strength=self.args.l2_strength,
is_training=self.is_training, bias=self.args.bias)
self.ssd_conv7_2 = conv2d('sdd_conv7_2', self.ssd_conv7_1,
num_filters=512, kernel_size=(3, 3),
padding='SAME', stride=(2, 2), activation=tf.nn.relu,
batchnorm_enabled=self.args.batchnorm_enabled,
l2_strength=self.args.l2_strength,
is_training=self.is_training, bias=self.args.bias)
self.ssd_conv8_1 = conv2d('sdd_conv8_1', self.ssd_conv7_2,
num_filters=128, kernel_size=(1, 1),
padding='SAME', stride=(1, 1), activation=tf.nn.relu,
batchnorm_enabled=self.args.batchnorm_enabled,
l2_strength=self.args.l2_strength,
is_training=self.is_training, bias=self.args.bias)
self.ssd_conv8_2 = conv2d('sdd_conv8_2', self.ssd_conv8_1,
num_filters=256, kernel_size=(3, 3),
padding='VALID', stride=(2, 2), activation=tf.nn.relu,
batchnorm_enabled=self.args.batchnorm_enabled,
l2_strength=self.args.l2_strength,
is_training=self.is_training, bias=self.args.bias)
def bottleneck_unet_block(
inputs, filters, data_format='NCHW', is_training=True, conv2d_hparams=None, block_name='bottleneck_block'
):
with tf.variable_scope(block_name):
net = layers.conv2d(
inputs,
n_channels=filters,
kernel_size=(3, 3),
strides=(1, 1),
padding='same',
data_format=data_format,
use_bias=True,
trainable=is_training,
kernel_initializer=conv2d_hparams.kernel_initializer,
bias_initializer=conv2d_hparams.bias_initializer,
)
net = blocks.activation_block(
inputs=net, act_fn=conv2d_hparams.activation_fn, trainable=is_training, block_name='act1'
)
net = layers.conv2d(
net,
n_channels=filters,
kernel_size=(3, 3),
strides=(1, 1),
padding='same',
data_format=data_format,
use_bias=True,
trainable=is_training,
kernel_initializer=conv2d_hparams.kernel_initializer,
bias_initializer=conv2d_hparams.bias_initializer,
)
net = blocks.activation_block(
inputs=net, act_fn=conv2d_hparams.activation_fn, trainable=is_training, block_name='act2'
)
net = layers.deconv2d(
net,
n_channels=filters / 2,
kernel_size=(2, 2),
padding='same',
data_format=data_format,
use_bias=True,
trainable=is_training,
kernel_initializer=conv2d_hparams.kernel_initializer,
bias_initializer=conv2d_hparams.bias_initializer,
)
net = blocks.activation_block(
inputs=net, act_fn=conv2d_hparams.activation_fn, trainable=is_training, block_name='act3'
)
return net
def __create_detector(self, x, depth, mapsize, name, l2_strength):
x = conv2d(name, x, num_filters=depth, kernel_size=(3, 3),
padding='SAME', stride=(1, 1), activation=tf.nn.relu,
batchnorm_enabled=self.args.batchnorm_enabled,
l2_strength=self.args.l2_strength,
is_training=self.is_training, bias=self.args.bias)
x = tf.reshape(x, [-1, mapsize.w*mapsize.h, depth])
return x
def conv2d_block(inputs,
n_channels,
kernel_size=(3, 3),
strides=(2, 2),
mode='SAME',
use_batch_norm=True,
activation='relu',
is_training=True,
data_format='NHWC',
conv2d_hparams=None,
batch_norm_hparams=None,
name='conv2d'):
if not isinstance(conv2d_hparams, tf.contrib.training.HParams):
raise ValueError(
"The paramater `conv2d_hparams` is not of type `HParams`")
if not isinstance(batch_norm_hparams,
tf.contrib.training.HParams) and use_batch_norm:
raise ValueError(
"The paramater `conv2d_hparams` is not of type `HParams`")
with tf.variable_scope(name):
if mode != 'SAME_RESNET':
net = layers.conv2d(
inputs,
n_channels=n_channels,
kernel_size=kernel_size,
strides=strides,
padding=mode,
data_format=data_format,
use_bias=not use_batch_norm,
trainable=is_training,
kernel_initializer=conv2d_hparams.kernel_initializer,
bias_initializer=conv2d_hparams.bias_initializer,
)
else: # Special padding mode for ResNet models
if strides == (1, 1):
net = layers.conv2d(
inputs,
n_channels=n_channels,
kernel_size=kernel_size,
strides=strides,
padding='SAME',
data_format=data_format,
use_bias=not use_batch_norm,
trainable=is_training,
kernel_initializer=conv2d_hparams.kernel_initializer,
bias_initializer=conv2d_hparams.bias_initializer,
)
else:
rate = 1 # Unused (for 'a trous' convolutions)
kernel_height_effective = kernel_size[0] + (kernel_size[0] -
1) * (rate - 1)
pad_h_beg = (kernel_height_effective - 1) // 2
pad_h_end = kernel_height_effective - 1 - pad_h_beg
kernel_width_effective = kernel_size[1] + (kernel_size[1] -
1) * (rate - 1)
pad_w_beg = (kernel_width_effective - 1) // 2
pad_w_end = kernel_width_effective - 1 - pad_w_beg
padding = [[0, 0], [pad_h_beg, pad_h_end],
[pad_w_beg, pad_w_end], [0, 0]]
if data_format == 'NCHW':
padding = [padding[0], padding[3], padding[1], padding[2]]
padded_inputs = tf.pad(inputs, padding)
net = layers.conv2d(
padded_inputs, # inputs,
n_channels=n_channels,
kernel_size=kernel_size,
strides=strides,
padding='VALID',
data_format=data_format,
use_bias=not use_batch_norm,
trainable=is_training,
kernel_initializer=conv2d_hparams.kernel_initializer,
bias_initializer=conv2d_hparams.bias_initializer,
)
if use_batch_norm:
net = layers.batch_norm(
net,
decay=batch_norm_hparams.decay,
epsilon=batch_norm_hparams.epsilon,
scale=batch_norm_hparams.scale,
center=batch_norm_hparams.center,
is_training=is_training,
data_format=data_format,
param_initializers=batch_norm_hparams.param_initializers)
if activation == 'relu':
net = layers.relu(net, name='relu')
elif activation == 'tanh':
net = layers.tanh(net, name='tanh')
elif activation != 'linear' and activation is not None:
raise KeyError('Invalid activation type: `%s`' % activation)
return net
def build_model(self,
inputs,
training=True,
reuse=False,
use_final_conv=False):
with var_storage.model_variable_scope(self.model_hparams.model_name,
reuse=reuse,
dtype=self.model_hparams.dtype):
with tf.variable_scope("input_reshape"):
if self.model_hparams.input_format == 'NHWC' and self.model_hparams.compute_format == 'NCHW':
# Reshape inputs: NHWC => NCHW
inputs = tf.transpose(inputs, [0, 3, 1, 2])
elif self.model_hparams.input_format == 'NCHW' and self.model_hparams.compute_format == 'NHWC':
# Reshape inputs: NCHW => NHWC
inputs = tf.transpose(inputs, [0, 2, 3, 1])
if self.model_hparams.dtype != inputs.dtype:
inputs = tf.cast(inputs, self.model_hparams.dtype)
net = blocks.conv2d_block(
inputs,
n_channels=64,
kernel_size=(7, 7),
strides=(2, 2),
mode='SAME',
use_batch_norm=True,
activation='relu',
is_training=training,
data_format=self.model_hparams.compute_format,
conv2d_hparams=self.conv2d_hparams,
batch_norm_hparams=self.batch_norm_hparams,
name='conv2d')
net = layers.max_pooling2d(
net,
pool_size=(3, 3),
strides=(2, 2),
padding='SAME',
data_format=self.model_hparams.compute_format,
name="max_pooling2d",
)
model_bottlenecks = self.model_hparams.layers_depth
for block_id, block_bottleneck in enumerate(model_bottlenecks):
for layer_id in range(
self.model_hparams.layers_count[block_id]):
stride = 2 if (layer_id == 0 and block_id != 0) else 1
net = blocks.bottleneck_block(
inputs=net,
depth=block_bottleneck * self.model_hparams.expansions,
depth_bottleneck=block_bottleneck,
cardinality=self.model_hparams.cardinality,
stride=stride,
training=training,
data_format=self.model_hparams.compute_format,
conv2d_hparams=self.conv2d_hparams,
batch_norm_hparams=self.batch_norm_hparams,
block_name="btlnck_block_%d_%d" % (block_id, layer_id),
use_se=self.model_hparams.use_se,
ratio=self.model_hparams.se_ratio)
with tf.variable_scope("output"):
net = layers.reduce_mean(
net,
keepdims=False,
data_format=self.model_hparams.compute_format,
name='spatial_mean')
if use_final_conv:
logits = layers.conv2d(
net,
n_channels=self.model_hparams.n_classes,
kernel_size=(1, 1),
strides=(1, 1),
padding='SAME',
data_format=self.model_hparams.compute_format,
dilation_rate=(1, 1),
use_bias=True,
kernel_initializer=self.dense_hparams.
kernel_initializer,
bias_initializer=self.dense_hparams.bias_initializer,
trainable=training,
name='dense')
else:
logits = layers.dense(
inputs=net,
units=self.model_hparams.n_classes,
use_bias=True,
trainable=training,
kernel_initializer=self.dense_hparams.
kernel_initializer,
bias_initializer=self.dense_hparams.bias_initializer)
if logits.dtype != tf.float32:
logits = tf.cast(logits, tf.float32)
axis = 3 if self.model_hparams.compute_format == "NHWC" and use_final_conv else 1
probs = layers.softmax(logits, name="softmax", axis=axis)
return probs, logits
def deconv2d(inputs,
n_channels=8,
kernel_size=(3, 3),
padding='VALID',
data_format='NHWC',
use_bias=True,
kernel_initializer=tf.variance_scaling_initializer(),
bias_initializer=tf.zeros_initializer(),
trainable=True,
use_upscale_conv=True):
padding = padding.upper() # Enforce capital letters for the padding mode
if data_format not in ['NHWC', 'NCHW']:
raise ValueError(
"Unknown data format: `%s` (accepted: ['NHWC', 'NCHW'])" %
data_format)
if padding not in ['SAME', 'VALID']:
raise ValueError(
"Unknown padding: `%s` (accepted: ['SAME', 'VALID'])" % padding)
with tf.variable_scope("deconv2d"):
if use_upscale_conv:
layer = layers.upscale_2d(
inputs,
size=(2, 2),
method=tf.image.ResizeMethod.
NEAREST_NEIGHBOR, # [BILINEAR, NEAREST_NEIGHBOR, BICUBIC, AREA]
align_corners=True,
is_scale=True,
data_format=data_format)
layer = layers.conv2d(layer,
n_channels=n_channels,
kernel_size=kernel_size,
strides=(1, 1),
padding=padding,
data_format=data_format,
use_bias=use_bias,
trainable=trainable,
kernel_initializer=kernel_initializer,
bias_initializer=bias_initializer)
else:
input_shape = inputs.get_shape()
layer = tf.layers.conv2d_transpose(
inputs=inputs,
filters=n_channels,
kernel_size=kernel_size,
strides=(2, 2),
padding=padding,
data_format='channels_first'
if data_format == "NCHW" else "channels_last",
use_bias=use_bias,
trainable=trainable,
kernel_initializer=kernel_initializer,
bias_initializer=bias_initializer)
_log_hparams(classname='Conv2DTranspose',
layername=layer.name,
n_channels=n_channels,
kernel_size=kernel_size,
strides=(2, 2),
padding=padding,
data_format=data_format,
use_bias=use_bias,
trainable=trainable,
input_shape=str(input_shape),
out_shape=str(layer.get_shape()),
out_dtype=layer.dtype)
return layer
def model(self, X, is_training, keep_prob):
# CONV L1
X = conv2d(X, scope="CONV_1", filter=32, kernel_size=3, strides=1,
padding="same", batch_norm=True, activation=tf.nn.relu, is_training=is_training)
X = tf.layers.max_pooling2d(X, pool_size=3, strides=2, padding="same")
# XCEPTION L2
Res = conv2d(X, scope="CONV_res_2", filter=128,
kernel_size=1, strides=2, padding="same")
X = separable_conv2d(X, scope="XCEPTION_2a", filter=64, kernel_size=3, strides=1,
padding="same", batch_norm=True, activation=tf.nn.relu, is_training=is_training)
X = separable_conv2d(X, scope="XCEPTION_2b", filter=128, kernel_size=3, strides=1,
padding="same", batch_norm=True, activation=None, is_training=is_training)
X = tf.layers.max_pooling2d(X, pool_size=3, strides=2, padding="same")
X = X + Res
# XCEPTION L3
Res = X
X = tf.nn.relu(X)
X = separable_conv2d(X, scope="XCEPTION_3a", filter=128, kernel_size=3, strides=1,
padding="same", batch_norm=True, activation=tf.nn.relu, is_training=is_training)
X = separable_conv2d(X, scope="XCEPTION_3b", filter=128, kernel_size=3, strides=1,
padding="same", batch_norm=True, activation=tf.nn.relu, is_training=is_training)
X = separable_conv2d(X, scope="XCEPTION_3c", filter=128, kernel_size=3, strides=1,
padding="same", batch_norm=True, activation=None, is_training=is_training)
X = X + Res
# XCEPTION L4
Res = conv2d(X, scope="CONV_res_4", filter=128,
kernel_size=1, strides=2, padding="same")
X = tf.nn.relu(X)
X = separable_conv2d(X, scope="XCEPTION_4a", filter=128, kernel_size=3, strides=1,
padding="same", batch_norm=True, activation=tf.nn.relu, is_training=is_training)
X = separable_conv2d(X, scope="XCEPTION_4b", filter=128, kernel_size=3, strides=1,
padding="same", batch_norm=True, activation=None, is_training=is_training)
X = tf.layers.max_pooling2d(X, pool_size=3, strides=2, padding="same")
X = X + Res
# XCEPTION L5
Res = conv2d(X, scope="CONV_res_5", filter=256,
kernel_size=1, strides=2, padding="same")
X = tf.nn.relu(X)
X = separable_conv2d(X, scope="XCEPTION_5a", filter=256, kernel_size=3, strides=1,
padding="same", batch_norm=True, activation=tf.nn.relu, is_training=is_training)
X = separable_conv2d(X, scope="XCEPTION_5b", filter=256, kernel_size=3, strides=1,
padding="same", batch_norm=True, activation=None, is_training=is_training)
X = tf.layers.max_pooling2d(X, pool_size=3, strides=2, padding="same")
X = X + Res
X = maxout(X, num_units=128)
# dw conv to 1x1
X = deepwise_conv2d(X, scope="dw_conv_to_1_1", kernel_size=(
X.shape[1], X.shape[2]), strides=1, padding="valid")
# flatten
X = tf.layers.flatten(X)
# Output
X = tf.nn.l2_normalize(X, axis=-1)
return X
def model(self, X, is_training, keep_prob):
# CONV L1
X = conv2d(X, scope="CONV_1", filter=16, kernel_size=3, strides=1,
padding="same", batch_norm=True, activation=tf.nn.relu, is_training=is_training)
X = tf.layers.max_pooling2d(X, pool_size=3, strides=2, padding="same")
# XCEPTION L2
Res = conv2d(X, scope="CONV_res_2", filter=128,
kernel_size=1, strides=2, padding="same")
X = separable_conv2d(X, scope="XCEPTION_2a", filter=64, kernel_size=3, strides=1,
padding="same", batch_norm=True, activation=tf.nn.relu, is_training=is_training)
X = separable_conv2d(X, scope="XCEPTION_2b", filter=128, kernel_size=3, strides=1,
padding="same", batch_norm=True, activation=None, is_training=is_training)
X = tf.layers.max_pooling2d(X, pool_size=3, strides=2, padding="same")
X = X + Res
# XCEPTION L3-L6
for i in range(3, 7):
Res = X
X = tf.nn.relu(X)
X = separable_conv2d(X, scope="XCEPTION_{}a".format(i), filter=128, kernel_size=3,
strides=1, padding="same", batch_norm=True, activation=tf.nn.relu, is_training=is_training)
X = separable_conv2d(X, scope="XCEPTION_{}b".format(i), filter=128, kernel_size=3,
strides=1, padding="same", batch_norm=True, activation=tf.nn.relu, is_training=is_training)
X = separable_conv2d(X, scope="XCEPTION_{}c".format(i), filter=128, kernel_size=3,
strides=1, padding="same", batch_norm=True, activation=None, is_training=is_training)
X = X + Res
# XCEPTION L7
Res = conv2d(X, scope="CONV_res_7", filter=256,
kernel_size=1, strides=2, padding="same")
X = tf.nn.relu(X)
X = separable_conv2d(X, scope="XCEPTION_7a", filter=128, kernel_size=3, strides=1,
padding="same", batch_norm=True, activation=tf.nn.relu, is_training=is_training)
X = separable_conv2d(X, scope="XCEPTION_7b", filter=256, kernel_size=3, strides=1,
padding="same", batch_norm=True, activation=None, is_training=is_training)
X = tf.layers.max_pooling2d(X, pool_size=3, strides=2, padding="same")
X = X + Res
# XCEPTION L8-L11
for i in range(8, 12):
Res = X
X = tf.nn.relu(X)
X = separable_conv2d(X, scope="XCEPTION_{}a".format(i), filter=256, kernel_size=3,
strides=1, padding="same", batch_norm=True, activation=tf.nn.relu, is_training=is_training)
X = separable_conv2d(X, scope="XCEPTION_{}b".format(i), filter=256, kernel_size=3,
strides=1, padding="same", batch_norm=True, activation=tf.nn.relu, is_training=is_training)
X = separable_conv2d(X, scope="XCEPTION_{}c".format(i), filter=256, kernel_size=3,
strides=1, padding="same", batch_norm=True, activation=None, is_training=is_training)
X = X + Res
# XCEPTION L12
Res = conv2d(X, scope="CONV_res_12", filter=256,
kernel_size=1, strides=2, padding="same")
X = tf.nn.relu(X)
X = separable_conv2d(X, scope="XCEPTION_12a", filter=256, kernel_size=3, strides=1,
padding="same", batch_norm=True, activation=tf.nn.relu, is_training=is_training)
X = separable_conv2d(X, scope="XCEPTION_12b", filter=256, kernel_size=3, strides=1,
padding="same", batch_norm=True, activation=None, is_training=is_training)
X = tf.layers.max_pooling2d(X, pool_size=3, strides=2, padding="same")
X = X + Res
# XCEPTION L13-L20
for i in range(13, 21):
Res = X
X = tf.nn.relu(X)
X = separable_conv2d(X, scope="XCEPTION_{}a".format(i), filter=256, kernel_size=3,
strides=1, padding="same", batch_norm=True, activation=tf.nn.relu, is_training=is_training)
X = separable_conv2d(X, scope="XCEPTION_{}b".format(i), filter=256, kernel_size=3,
strides=1, padding="same", batch_norm=True, activation=tf.nn.relu, is_training=is_training)
X = separable_conv2d(X, scope="XCEPTION_{}c".format(i), filter=256, kernel_size=3,
strides=1, padding="same", batch_norm=True, activation=None, is_training=is_training)
X = X + Res
# XCEPTION L21
Res = conv2d(X, scope="CONV_res_21", filter=512,
kernel_size=1, strides=2, padding="same")
X = tf.nn.relu(X)
X = separable_conv2d(X, scope="XCEPTION_21a", filter=256, kernel_size=3, strides=1,
padding="same", batch_norm=True, activation=tf.nn.relu, is_training=is_training)
X = separable_conv2d(X, scope="XCEPTION_21b", filter=512, kernel_size=3, strides=1,
padding="same", batch_norm=True, activation=None, is_training=is_training)
X = tf.layers.max_pooling2d(X, pool_size=3, strides=2, padding="same")
X = X + Res
# XCEPTION L22
X = separable_conv2d(X, scope="XCEPTION_22", filter=128, kernel_size=3, strides=1,
padding="same", batch_norm=True, activation=tf.nn.relu, is_training=is_training)
# dw conv to 1x1
X = deepwise_conv2d(X, scope="dw_conv_to_1_1", kernel_size=(
X.shape[1], X.shape[2]), strides=1, padding="valid")
# flatten
X = tf.layers.flatten(X)
# Output
X = tf.nn.l2_normalize(X, axis=-1)
return X
def generator(img_shape, spectr_norm=False, gen_out=None):
input_layer = Input(shape=img_shape)
# Part 1. Feature Extraction Network
filter_outputs = [
64, 54, 48, 43, 39, 35, 31, 28, 25, 22, 18, 16, 24, 8, 8, 32, 16
]
fe_layers = []
for i in range(12):
if i == 0:
fe = conv2d(input_layer,
filters=filter_outputs[i],
kernel_size=3,
stride=2,
padding='same',
sn=spectr_norm)
fe = LeakyReLU(0.1)(fe)
fe = Dropout(0.2)(fe)
else:
fe = conv2d(fe,
filters=filter_outputs[i],
kernel_size=3,
stride=1,
padding='same',
sn=spectr_norm)
fe = LeakyReLU(0.1)(fe)
fe = Dropout(0.2)(fe)
fe_layers.append(fe)
fe_final_layer = Concatenate()(fe_layers)
# Part 2.1 Reconstruction Network
a1 = conv2d(fe_final_layer,
filters=filter_outputs[12],
kernel_size=1,
stride=1,
padding='same',
sn=spectr_norm)
a1 = LeakyReLU(0.1)(a1)
a1 = Dropout(0.2)(a1)
b1 = conv2d(fe_final_layer,
filters=filter_outputs[13],
kernel_size=1,
stride=1,
padding='same',
sn=spectr_norm)
b1 = LeakyReLU(0.1)(b1)
b1 = Dropout(0.2)(b1)
b2 = conv2d(b1,
filters=filter_outputs[14],
kernel_size=3,
stride=1,
padding='same',
sn=spectr_norm)
b2 = LeakyReLU(0.1)(b2)
b2 = Dropout(0.2)(b2)
reconstructed = Concatenate()([a1, b2])
# Part 2.2 Upsampling
c1 = conv2d(reconstructed,
filters=filter_outputs[15],
kernel_size=3,
stride=1,
padding='same',
sn=spectr_norm)
c1 = LeakyReLU(0.1)(c1)
c2 = upsample(c1,
filters=filter_outputs[16],
kernel_size=4,
stride=2,
padding='same')
c2 = LeakyReLU(0.1)(c2)
output = conv2d(c2,
filters=1,
kernel_size=3,
stride=1,
padding='same',
bias=False,
activation=gen_out)
return Model(input_layer, output)
def sft_generator(img_shape, hu_min, hu_max, spectr_norm=False, gen_out=None):
input_layer = Input(shape=img_shape)
# Part 1. Feature Extraction Network
filter_outputs = [
64, 54, 48, 43, 39, 35, 31, 28, 25, 22, 18, 16, 24, 8, 8, 32, 16
]
fe_layers = []
for i in range(12):
if i == 0:
# segmentation map
indices = tf.histogram_fixed_width_bins(
input_layer, [float(hu_min), float(hu_max)], 10)
seg_map = tf.one_hot(indices, 10)
seg_map = tf.squeeze(seg_map, axis=3)
sm = condition()(seg_map)
# feature map
fe = conv2d(input_layer,
filters=filter_outputs[i],
kernel_size=3,
stride=2,
padding='same',
sn=spectr_norm)
fe = LeakyReLU(0.1)(fe)
fe = Dropout(0.2)(fe)
else:
fe = sft(units=[32, fe.shape[-1]])([fe, sm])
fe = conv2d(fe,
filters=filter_outputs[i],
kernel_size=3,
stride=1,
padding='same',
sn=spectr_norm)
fe = LeakyReLU(0.1)(fe)
fe = Dropout(0.2)(fe)
fe_layers.append(fe)
fe_final_layer = Concatenate()(fe_layers)
# Part 2.1 Reconstruction Network
a1 = sft(units=[32, fe_final_layer.shape[-1]])([fe_final_layer, sm])
a1 = conv2d(a1,
filters=filter_outputs[12],
kernel_size=1,
stride=1,
padding='same',
sn=spectr_norm)
a1 = LeakyReLU(0.1)(a1)
a1 = Dropout(0.2)(a1)
b1 = sft(units=[32, fe_final_layer.shape[-1]])([fe_final_layer, sm])
b1 = conv2d(fe_final_layer,
filters=filter_outputs[13],
kernel_size=1,
stride=1,
padding='same',
sn=spectr_norm)
b1 = LeakyReLU(0.1)(b1)
b1 = Dropout(0.2)(b1)
b2 = sft(units=[32, b1.shape[-1]])([b1, sm])
b2 = conv2d(b1,
filters=filter_outputs[14],
kernel_size=3,
stride=1,
padding='same',
sn=spectr_norm)
b2 = LeakyReLU(0.1)(b2)
b2 = Dropout(0.2)(b2)
reconstructed = Concatenate()([a1, b2])
# Part 2.2 Upsampling
c1 = conv2d(reconstructed,
filters=filter_outputs[15],
kernel_size=3,
stride=1,
padding='same',
sn=spectr_norm)
c1 = LeakyReLU(0.1)(c1)
c2 = upsample(c1,
filters=filter_outputs[16],
kernel_size=4,
stride=2,
padding='same')
c2 = LeakyReLU(0.1)(c2)
output = conv2d(c2,
filters=1,
kernel_size=3,
stride=1,
padding='same',
bias=False,
activation=gen_out)
return Model(input_layer, output)
def discriminator(img_shape, spectr_norm=False):
filters = 64
input_layer = Input(shape=img_shape)
y = conv2d(input_layer,
filters=filters,
kernel_size=4,
stride=1,
padding='same',
sn=spectr_norm)
y = InstanceNormalization(axis=-1, center=True, scale=True)(y)
y = LeakyReLU(0.1)(y)
y = conv2d(y,
filters=filters,
kernel_size=4,
stride=1,
padding='same',
sn=spectr_norm)
y = InstanceNormalization(axis=-1, center=True, scale=True)(y)
y = LeakyReLU(0.1)(y)
y = conv2d(y,
filters=filters * 2,
kernel_size=4,
stride=1,
padding='same',
sn=spectr_norm)
y = InstanceNormalization(axis=-1, center=True, scale=True)(y)
y = LeakyReLU(0.1)(y)
y = conv2d(y,
filters=filters * 2,
kernel_size=4,
stride=1,
padding='same',
sn=spectr_norm)
y = InstanceNormalization(axis=-1, center=True, scale=True)(y)
y = LeakyReLU(0.1)(y)
y = conv2d(y,
filters=filters * 4,
kernel_size=4,
stride=1,
padding='same',
sn=spectr_norm)
y = InstanceNormalization(axis=-1, center=True, scale=True)(y)
y = LeakyReLU(0.1)(y)
y = conv2d(y,
filters=filters * 4,
kernel_size=4,
stride=1,
padding='same',
sn=spectr_norm)
y = InstanceNormalization(axis=-1, center=True, scale=True)(y)
y = LeakyReLU(0.1)(y)
# y = conv2d(y, filters=filters*8, kernel_size=4,
# stride=1, padding='same')
# y = InstanceNormalization(axis=-1, center=True, scale=True)(y)
# y = LeakyReLU(0.1)(y)
# y = conv2d(y, filters=filters*8, kernel_size=4,
# stride=2, padding='same')
y = SpatialPyramidPooling2D(bins=[1, 2, 3], data_format='channels_last')(y)
y = Dense(1024)(y)
y = LeakyReLU(0.1)(y)
output = Dense(1)(y)
return Model(input_layer, output)
def output_unet_block(inputs,
residual_input,
filters,
n_output_channels,
data_format='NCHW',
is_training=True,
conv2d_hparams=None,
block_name='output_block'):
with tf.variable_scope(block_name):
net = layers.concat([inputs, residual_input],
axis=1 if data_format == 'NCHW' else 3)
net = layers.conv2d(
net,
n_channels=filters,
kernel_size=(3, 3),
strides=(1, 1),
padding='same',
data_format=data_format,
use_bias=True,
trainable=is_training,
kernel_initializer=conv2d_hparams.kernel_initializer,
bias_initializer=conv2d_hparams.bias_initializer,
)
net = blocks.activation_block(inputs=net,
act_fn=conv2d_hparams.activation_fn,
trainable=is_training,
block_name='act1')
net = layers.conv2d(
net,
n_channels=filters,
kernel_size=(3, 3),
strides=(1, 1),
padding='same',
data_format=data_format,
use_bias=True,
trainable=is_training,
kernel_initializer=conv2d_hparams.kernel_initializer,
bias_initializer=conv2d_hparams.bias_initializer,
)
net = blocks.activation_block(inputs=net,
act_fn=conv2d_hparams.activation_fn,
trainable=is_training,
block_name='act2')
net = layers.conv2d(
net,
n_channels=n_output_channels,
kernel_size=(1, 1),
strides=(1, 1),
padding='same',
data_format=data_format,
use_bias=True,
trainable=is_training,
kernel_initializer=conv2d_hparams.kernel_initializer,
bias_initializer=conv2d_hparams.bias_initializer,
)
return net
def conv2d_block(
inputs,
n_channels,
kernel_size=(3, 3),
strides=(2, 2),
mode='SAME',
use_batch_norm=True,
activation='relu',
is_training=True,
data_format='NHWC',
conv2d_hparams=None,
batch_norm_hparams=None,
name='conv2d',
cardinality=1,
):
if not isinstance(conv2d_hparams, tf.contrib.training.HParams):
raise ValueError(
"The paramater `conv2d_hparams` is not of type `HParams`")
if not isinstance(batch_norm_hparams,
tf.contrib.training.HParams) and use_batch_norm:
raise ValueError(
"The paramater `conv2d_hparams` is not of type `HParams`")
with tf.variable_scope(name):
if cardinality == 1:
net = layers.conv2d(
inputs,
n_channels=n_channels,
kernel_size=kernel_size,
strides=strides,
padding=mode,
data_format=data_format,
use_bias=not use_batch_norm,
trainable=is_training,
kernel_initializer=conv2d_hparams.kernel_initializer,
bias_initializer=conv2d_hparams.bias_initializer)
else:
group_filter = tf.get_variable(
name=name + 'group_filter',
shape=[3, 3, n_channels // cardinality, n_channels],
trainable=is_training,
dtype=tf.float32)
net = tf.nn.conv2d(inputs,
group_filter,
strides=strides,
padding='SAME',
data_format=data_format)
if use_batch_norm:
net = layers.batch_norm(
net,
decay=batch_norm_hparams.decay,
epsilon=batch_norm_hparams.epsilon,
scale=batch_norm_hparams.scale,
center=batch_norm_hparams.center,
is_training=is_training,
data_format=data_format,
param_initializers=batch_norm_hparams.param_initializers)
if activation == 'relu':
net = layers.relu(net, name='relu')
elif activation == 'tanh':
net = layers.tanh(net, name='tanh')
elif activation != 'linear' and activation is not None:
raise KeyError('Invalid activation type: `%s`' % activation)
return net
def __init_network(self):
with tf.variable_scope('mobilenet_base'):
# Preprocessing as done in the paper
with tf.name_scope('pre_processing'):
preprocessed_input = (self.X - self.mean_img) / 255.0
# Model is here!
conv1_1 = conv2d('conv_1', zero_pad(preprocessed_input), num_filters=int(round(32 * self.args.width_multiplier)),
kernel_size=(3, 3),
padding='VALID', stride=(2, 2), activation=tf.nn.relu6,
batchnorm_enabled=self.args.batchnorm_enabled,
is_training=self.is_training, l2_strength=self.args.l2_strength, bias=self.args.bias)
self.__add_to_nodes([conv1_1])
############################################################################################
conv2_1_dw, conv2_1_pw = depthwise_separable_conv2d('conv_ds_2', zero_pad(conv1_1),
width_multiplier=self.args.width_multiplier,
num_filters=64, kernel_size=(3, 3), padding='VALID',
stride=(1, 1),
batchnorm_enabled=self.args.batchnorm_enabled,
activation=tf.nn.relu6,
is_training=self.is_training,
l2_strength=self.args.l2_strength,
biases=(self.args.bias, self.args.bias))
self.__add_to_nodes([conv2_1_dw, conv2_1_pw])
conv2_2_dw, conv2_2_pw = depthwise_separable_conv2d('conv_ds_3', zero_pad(conv2_1_pw),
width_multiplier=self.args.width_multiplier,
num_filters=128, kernel_size=(3, 3), padding='VALID',
stride=(2, 2),
batchnorm_enabled=self.args.batchnorm_enabled,
activation=tf.nn.relu6,
is_training=self.is_training,
l2_strength=self.args.l2_strength,
biases=(self.args.bias, self.args.bias))
self.__add_to_nodes([conv2_2_dw, conv2_2_pw])
############################################################################################
conv3_1_dw, self.conv3_1_pw = depthwise_separable_conv2d('conv_ds_4', zero_pad(conv2_2_pw),
width_multiplier=self.args.width_multiplier,
num_filters=128, kernel_size=(3, 3), padding='VALID',
stride=(1, 1),
batchnorm_enabled=self.args.batchnorm_enabled,
activation=tf.nn.relu6,
is_training=self.is_training,
l2_strength=self.args.l2_strength,
biases=(self.args.bias, self.args.bias))
self.__add_to_nodes([conv3_1_dw, self.conv3_1_pw])
conv3_2_dw, conv3_2_pw = depthwise_separable_conv2d('conv_ds_5', zero_pad(self.conv3_1_pw),
width_multiplier=self.args.width_multiplier,
num_filters=256, kernel_size=(3, 3), padding='VALID',
stride=(2, 2),
batchnorm_enabled=self.args.batchnorm_enabled,
activation=tf.nn.relu6,
is_training=self.is_training,
l2_strength=self.args.l2_strength,
biases=(self.args.bias, self.args.bias))
self.__add_to_nodes([conv3_2_dw, conv3_2_pw])
############################################################################################
conv4_1_dw, self.conv4_1_pw = depthwise_separable_conv2d('conv_ds_6', zero_pad(conv3_2_pw),
width_multiplier=self.args.width_multiplier,
num_filters=256, kernel_size=(3, 3), padding='VALID',
stride=(1, 1),
batchnorm_enabled=self.args.batchnorm_enabled,
activation=tf.nn.relu6,
is_training=self.is_training,
l2_strength=self.args.l2_strength,
biases=(self.args.bias, self.args.bias))
self.__add_to_nodes([conv4_1_dw, self.conv4_1_pw])
conv4_2_dw, conv4_2_pw = depthwise_separable_conv2d('conv_ds_7', zero_pad(self.conv4_1_pw),
width_multiplier=self.args.width_multiplier,
num_filters=512, kernel_size=(3, 3), padding='VALID',
stride=(2, 2),
batchnorm_enabled=self.args.batchnorm_enabled,
activation=tf.nn.relu6,
is_training=self.is_training,
l2_strength=self.args.l2_strength,
biases=(self.args.bias, self.args.bias))
self.__add_to_nodes([conv4_2_dw, conv4_2_pw])
############################################################################################
conv5_1_dw, conv5_1_pw = depthwise_separable_conv2d('conv_ds_8', zero_pad(conv4_2_pw),
width_multiplier=self.args.width_multiplier,
num_filters=512, kernel_size=(3, 3), padding='VALID',
stride=(1, 1),
batchnorm_enabled=self.args.batchnorm_enabled,
activation=tf.nn.relu6,
is_training=self.is_training,
l2_strength=self.args.l2_strength,
biases=(self.args.bias, self.args.bias))
self.__add_to_nodes([conv5_1_dw, conv5_1_pw])
conv5_2_dw, self.conv5_2_pw = depthwise_separable_conv2d('conv_ds_9', zero_pad(conv5_1_pw),
width_multiplier=self.args.width_multiplier,
num_filters=512, kernel_size=(3, 3), padding='VALID',
stride=(1, 1),
batchnorm_enabled=self.args.batchnorm_enabled,
activation=tf.nn.relu6,
is_training=self.is_training,
l2_strength=self.args.l2_strength,
biases=(self.args.bias, self.args.bias))
self.__add_to_nodes([conv5_2_dw, self.conv5_2_pw])
############################################################################################
conv6_1_dw, conv6_1_pw = depthwise_separable_conv2d('conv_ds_10', zero_pad(self.conv5_2_pw),
width_multiplier=self.args.width_multiplier,
num_filters=1024, kernel_size=(3, 3), padding='VALID',
stride=(2, 2),
batchnorm_enabled=self.args.batchnorm_enabled,
activation=tf.nn.relu6,
is_training=self.is_training,
l2_strength=self.args.l2_strength,
biases=(self.args.bias, self.args.bias))
self.__add_to_nodes([conv6_1_dw, conv6_1_pw])
conv6_2_dw, self.conv6_2_pw = depthwise_separable_conv2d('conv_ds_11', zero_pad(conv6_1_pw),
width_multiplier=self.args.width_multiplier,
num_filters=1024, kernel_size=(3, 3), padding='VALID',
stride=(1, 1),
batchnorm_enabled=self.args.batchnorm_enabled,
activation=tf.nn.relu6,
is_training=self.is_training,
l2_strength=self.args.l2_strength,
biases=(self.args.bias, self.args.bias))
self.__add_to_nodes([conv6_2_dw, self.conv6_2_pw])
