def model(is_training, reuse):
common_args = common_layer_args(is_training, reuse)
fc_args = make_args(activation=relu, **common_args)
logit_args = make_args(activation=None, **common_args)
x = input((None, height * width), **common_args)
x = fully_connected(x, n_output=100, name='fc1', **fc_args)
logits = fully_connected(x, n_output=10, name="logits", **logit_args)
predictions = softmax(logits, name='predictions', **common_args)
return end_points(is_training)
def encoder(inputs, is_training, reuse, z_dim=512):
common_args = common_layer_args(is_training, reuse)
conv_args = make_args(batch_norm=True,
activation=lrelu,
w_init=initz.he_normal(scale=1),
untie_biases=False,
**common_args)
conv_args_1st = make_args(batch_norm=None,
activation=lrelu,
w_init=initz.he_normal(scale=1),
untie_biases=False,
**common_args)
logits_args = make_args(activation=None,
w_init=initz.he_normal(scale=1),
**common_args)
pool_args = make_args(padding='SAME', **common_args)
end_points = {}
x = inputs
end_points['inputs'] = x
x = dropout(x, drop_p=0.2, name="input_dropout1", **common_args)
x = conv2d(x,
96,
filter_size=(5, 5),
stride=(2, 2),
name="e_conv1_1",
**conv_args_1st)
end_points['e_conv1_1'] = x
x = conv2d(x, 96, name="e_conv1_2", **conv_args)
end_points['e_conv1_2'] = x
x = conv2d(x, 96, stride=(2, 2), name="e_conv1_3", **conv_args)
end_points['e_conv1_3'] = x
x = dropout(x, drop_p=0.2, name="dropout1", **common_args)
x = conv2d(x, 192, name="e_conv2_1", **conv_args)
end_points['e_conv2_1'] = x
x = conv2d(x, 192, name="e_conv2_2", **conv_args)
end_points['e_conv2_2'] = x
# x = conv2d(x, 192, stride=(2, 2), name="e_conv2_3", **conv_args)
# end_points['e_conv2_3'] = x
x = dropout(x, drop_p=0.2, name="dropout2", **common_args)
# x = conv2d(x, 192, stride=(2, 2), name="e_conv3_1", **conv_args)
# end_points['e_conv3_1'] = x
x = conv2d(x, 192, filter_size=(1, 1), name="e_conv4_1", **conv_args)
end_points['e_conv4_1'] = x
x = conv2d(x, 192, filter_size=(1, 1), name="e_conv4_2", **conv_args)
end_points['e_conv4_2'] = x
x = global_avg_pool(x, name="global_pool")
end_points['global_pool'] = x
logits1 = fully_connected(x, z_dim, name="e_logits1", **logits_args)
logits2 = fully_connected(x, z_dim, name="e_logits2", **logits_args)
logits2 = tf.tanh(logits2, name='e_logits2_tanh')
end_points['e_logits1'] = logits1
end_points['e_logits2'] = logits2
return end_points
def model(x, is_training, reuse, num_classes=10, **kwargs):
common_args = common_layer_args(is_training, reuse)
fc_args = make_args(activation=relu, **common_args)
logit_args = make_args(activation=None, **common_args)
x = fully_connected(x, n_output=100, name='fc1', **fc_args)
logits = fully_connected(x,
n_output=num_classes,
name="logits",
**logit_args)
predictions = softmax(logits, name='predictions', **common_args)
return end_points(is_training)
def model(is_training, reuse):
common_args = common_layer_args(is_training, reuse)
x = input((None, 7, 7, 512), **common_args)
# x = batch_norm_tf(x, **common_args)
x = fully_connected(x, 512, activation=relu, name='fc1', **common_args)
x = dropout(x, drop_p=0.5, name='dropout1', **common_args)
logits = fully_connected(x,
6,
activation=None,
name='logits',
**common_args)
predictions = softmax(logits, name='predictions', **common_args)
return end_points(is_training)
def model(is_training, resue, num_classes=5):
common_args = common_layer_args(is_training, reuse)
conv_args = make_args(
untie_biases=True, batch_norm=batch_norm, **common_args)
logit_args = make_args(activation=prelu, **common_args)
inputs = input((None, crop_size[1], crop_size[0], 3), **common_args)
net = conv2d(inputs, 32, filter_size=(3, 3), stride=(
2, 2), name='conv1', **conv_params)
net = conv2d(net, 64, name='conv2', **conv_params)
net = bottleneck_v1(net, num_unit=128, name='block_v1_1', **conv_args)
net = bottleneck_v1(net, num_unit=256, name='block_v1_2', **conv_args)
net = bottleneck_v1(net, num_unit=728, name='block_v1_3', **conv_args)
for i in range(8):
prefix = 'block_v2_' + str(i + 5)
net = bottleneck_v2(net, num_unit=728, name=prefix, **kwargs)
net = bottleneck_v1(net, num_unit=1024, name='block_v1_4', **conv_args)
net = separable_conv2d(net, 1536, filter_size=(3, 3), stride=(1, 1),
name='sconv1', **kwargs)
net = separable_conv2d(net, 2048, filter_size=(3, 3), stride=(1, 1),
name='sconv2', **kwargs)
with tf.variable_scope('Logits'):
net = avg_pool_2d(net, net.get_shape()[1:3], name='AvgPool_1a')
net = dropout(
net, is_training, drop_p=1 - dropout_keep_prob, name='Dropout_1b')
logits = fully_connected(net, num_classes,
name='logits', **logit_args)
predictions = softmax(logits, name='predictions', **common_args)
return end_points(is_training)
def decoder(tau, logits_y, K, N): y = tf.reshape(gumbel_softmax(logits_y, tau, hard=False), [-1, N, K]) # generative model p(x|y), i.e. the decoder (shape=(batch_size,200)) net = stack(flatten(y), fully_connected, [256, 512], True, None, name='fcdecoder') logits_x = fully_connected(net, 784, True, None, activation=None, name='logitsdecoder') # (shape=(batch_size,784)) p_x = Bernoulli(logits=logits_x) return p_x
def model(is_training, reuse):
common_args = common_layer_args(is_training, reuse)
conv_args = make_args(batch_norm=None, activation=prelu, **common_args)
fc_args = make_args(activation=prelu, **common_args)
logit_args = make_args(activation=None, **common_args)
x = input((None, crop_size[1], crop_size[0], 1), **common_args)
x = conv2d(x, 32, name='conv1_1', **conv_args)
x = conv2d(x, 32, name='conv1_2', **conv_args)
x = max_pool(x, name='pool1', **common_args)
x = dropout(x, drop_p=0.25, name='dropout1', **common_args)
x = fully_connected(x, n_output=128, name='fc1', **fc_args)
x = dropout(x, drop_p=0.5, name='dropout2', **common_args)
logits = fully_connected(x, n_output=36, name="logits", **logit_args)
predictions = softmax(logits, name='predictions', **common_args)
return end_points(is_training)
def generator(z_shape, is_training, reuse, batch_size=32):
common_args = common_layer_args(is_training, reuse)
conv_args = make_args(batch_norm=True,
activation=lrelu,
w_init=initz.he_normal(scale=1),
untie_biases=False,
**common_args)
conv_args_1st = make_args(batch_norm=None,
activation=lrelu,
w_init=initz.he_normal(scale=1),
untie_biases=False,
**common_args)
fc_args = make_args(activation=lrelu,
w_init=initz.he_normal(scale=1),
**common_args)
pool_args = make_args(padding='SAME', **common_args)
# project `z` and reshape
# TODO think about phase again
end_points = {}
z = get_z(z_shape, reuse)
end_points['z'] = z
z_fc = fully_connected(z, 4 * 4 * 512, name="g_fc", **fc_args)
end_points['g_fc'] = z_fc
x = tf.reshape(z_fc, [batch_size, 4, 4, 512])
end_points['g_reshaped'] = x
x = upsample2d(x, [batch_size, 8, 8, 256],
name="g_deconv2d_1",
**conv_args)
end_points['g_deconv2d_1'] = x
x = upsample2d(x, [batch_size, 16, 16, 128],
name="g_deconv2d_2",
**conv_args)
end_points['g_deconv2d_2'] = x
# x = upsample2d(x, [batch_size, 32, 32, 16 * 3],
# name="g_deconv2d_3", **conv_args)
# end_points['g_deconv2d_3'] = x
# for now lets examine cifar
# x = subpixel2d(x, 4, name='z_subpixel1')
# x shape[batch_size, 128, 128, 3]
# end_points['subpixel1'] = x
x = upsample2d(x, [batch_size, 32, 32, 64],
name="g_deconv2d_3",
**conv_args)
end_points['g_deconv2d_3'] = x
x = upsample2d(x, [batch_size, 64, 64, 32],
name="g_deconv2d_4",
**conv_args)
end_points['g_deconv2d_4'] = x
x = upsample2d(x, [batch_size, 128, 128, 3],
name="g_deconv2d_5",
**conv_args_1st)
end_points['g_deconv2d_5'] = x
end_points['softmax'] = tf.nn.tanh(x)
return end_points
def model(is_training, reuse):
common_args = common_layer_args(is_training, reuse)
conv_args = make_args(activation=relu, **common_args)
pool_args = make_args(filter_size=(2, 2), **common_args)
fc_args = make_args(activation=relu, **common_args)
logit_args = make_args(activation=None, **common_args)
x = input((None, crop_size[1], crop_size[0], 3), **common_args)
x = conv2d(x, 64, name='conv1_1', **conv_args)
x = conv2d(x, 64, name='conv1_2', **conv_args)
x = max_pool(x, name='maxpool1', **pool_args)
x = conv2d(x, 128, name='conv2_1', **conv_args)
x = conv2d(x, 128, name='conv2_2', **conv_args)
x = max_pool(x, name='maxpool2', **pool_args)
x = conv2d(x, 256, name='conv3_1', **conv_args)
x = conv2d(x, 256, name='conv3_2', **conv_args)
x = conv2d(x, 256, name='conv3_3', **conv_args)
x = max_pool(x, name='maxpool3', **pool_args)
x = conv2d(x, 512, name='conv4_1', **conv_args)
x = conv2d(x, 512, name='conv4_2', **conv_args)
x = conv2d(x, 512, name='conv4_3', **conv_args)
x = max_pool(x, name='maxpool4', **pool_args)
x = conv2d(x, 512, name='conv5_1', **conv_args)
x = conv2d(x, 512, name='conv5_2', **conv_args)
x = conv2d(x, 512, name='conv5_3', **conv_args)
x = max_pool(x, name='maxpool5', **pool_args)
x = fully_connected(x, n_output=4096, name='fc6', **fc_args)
x = dropout(x, drop_p=0.5, name='dropout1', **common_args)
x = fully_connected(x, n_output=4096, name='fc7', **fc_args)
x = dropout(x, drop_p=0.5, name='dropout2', **common_args)
logits = fully_connected(x, n_output=1000, name="logits", **logit_args)
predictions = softmax(logits, name='predictions', **common_args)
return end_points(is_training)
def encoder(x, K=10, N=30):
# variational posterior q(y|x), i.e. the encoder (shape=(batch_size,200))
net = stack(x, fully_connected, [512, 256], True, None, name='fcencoder')
# unnormalized logits for N separate K-categorical distributions
# (shape=(batch_size*N,K))
logits_y = tf.reshape(
fully_connected(net, K * N, True, None, activation=None, name='logitsencoder'), [-1, K])
q_y = tf.nn.softmax(logits_y)
log_q_y = tf.log(q_y + 1e-20)
return logits_y, q_y, log_q_y
def test_trainable_false():
x = tf.placeholder(tf.float32, [1, 10, 10, 3])
x = fully_connected(x,
15,
is_training=True,
reuse=False,
name='fc1',
trainable=False)
trainable_vars = [v.name for v in tf.trainable_variables()]
assert 'fc1/W:0' not in trainable_vars
assert 'fc1/b:0' not in trainable_vars
def discriminator(inputs, is_training, reuse, num_classes=1):
common_args = common_layer_args(is_training, reuse)
conv_args = make_args(batch_norm=True,
activation=lrelu,
w_init=initz.he_normal(scale=1),
untie_biases=False,
**common_args)
conv_args_1st = make_args(batch_norm=None,
activation=lrelu,
w_init=initz.he_normal(scale=1),
untie_biases=False,
**common_args)
logits_args = make_args(activation=None,
w_init=initz.he_normal(scale=1),
**common_args)
pool_args = make_args(padding='SAME', **common_args)
end_points = {}
x = inputs
end_points['inputs'] = x
x = dropout(x, drop_p=0.2, name="input_dropout1", **common_args)
x = conv2d(x,
96,
filter_size=(5, 5),
stride=(2, 2),
name="d_conv1_1",
**conv_args_1st)
end_points['d_conv1_1'] = x
x = conv2d(x, 96, name="d_conv1_2", **conv_args)
end_points['d_conv1_2'] = x
x = conv2d(x, 96, stride=(2, 2), name="d_conv1_3", **conv_args)
end_points['d_conv1_3'] = x
x = dropout(x, drop_p=0.2, name="dropout1", **common_args)
x = conv2d(x, 192, name="d_conv2_1", **conv_args)
end_points['d_conv2_1'] = x
x = conv2d(x, 192, name="d_conv2_2", **conv_args)
end_points['d_conv2_2'] = x
# x = conv2d(x, 192, stride=(2, 2), name="d_conv2_3", **conv_args)
# end_points['d_conv2_3'] = x
x = dropout(x, drop_p=0.2, name="dropout2", **common_args)
# x = conv2d(x, 192, stride=(2, 2), name="d_conv3_1", **conv_args)
# end_points['d_conv3_1'] = x
x = conv2d(x, 192, filter_size=(1, 1), name="d_conv4_1", **conv_args)
end_points['d_conv4_1'] = x
x = conv2d(x, 192, filter_size=(1, 1), name="d_conv4_2", **conv_args)
end_points['d_conv4_2'] = x
x = global_avg_pool(x, name="global_pool")
end_points['global_pool'] = x
logits = fully_connected(x, num_classes, name="d_logits", **logits_args)
end_points['logits'] = logits
end_points['predictions'] = softmax(logits,
name='predictions',
**common_args)
return end_points
def test_trainable_false():
x = tf.placeholder(tf.float32, [1, 10, 10, 3])
x = fully_connected(x, 15, is_training=True, reuse=False, name='fc1', trainable=False)
all_vars = set(tf.global_variables())
trainable_vars = set(tf.trainable_variables())
non_trainable_vars = all_vars.difference(trainable_vars)
trainable_vars = [v.name for v in trainable_vars]
non_trainable_vars = [v.name for v in non_trainable_vars]
assert 'fc1/weights:0' not in trainable_vars
assert 'fc1/biases:0' not in trainable_vars
assert 'fc1/weights:0' in non_trainable_vars
assert 'fc1/biases:0' in non_trainable_vars
def model(x, is_training, reuse, num_classes=10, **config):
common_args = common_layer_args(is_training, reuse)
logit_args = make_args(activation=None, **common_args)
if config['max_conv_layers']>0:
for i in range(1, config['n_conv_layers']+1):
activation, size, maxpool = layer_config(config, i, layer_type='conv')
conv_args = make_args(batch_norm=bool(config['batch_norm']), activation=prelu, **common_args)
x = conv2d(x, size, name='conv{}'.format(i), **conv_args)
if maxpool:
x = max_pool(x, name='pool{}'.format(i), **common_args)
if config['max_fc_layers']>0:
for i in range(1, config['n_fc_layers']+1):
activation, size, _dropout = layer_config(config, i, layer_type='fc')
fc_args = make_args(activation=prelu, **common_args)
x = fully_connected(x, n_output=size, name='fc{}'.format(i), **fc_args)
x = dropout(x, drop_p=np.round(_dropout, 2), name='dropout{}'.format(i), **common_args)
logits = fully_connected(x, n_output=num_classes, name="logits", **logit_args)
predictions = softmax(logits, name='predictions', **common_args)
return end_points(is_training)
def model(inputs,
is_training,
reuse,
input_size=image_size[0],
drop_p_conv=0.0,
drop_p_trans=0.0,
n_filters=64,
n_layers=[1, 2, 2, 3],
num_classes=5, **kwargs):
common_args = common_layer_args(is_training, reuse)
conv_args = make_args(
batch_norm=True,
activation=prelu,
w_init=initz.he_normal(scale=1),
untie_biases=True,
**common_args)
fc_args = make_args(activation=prelu, w_init=initz.he_normal(scale=1), **common_args)
logit_args = make_args(activation=None, w_init=initz.he_normal(scale=1), **common_args)
pred_args = make_args(activation=prelu, w_init=initz.he_normal(scale=1), **common_args)
pool_args = make_args(padding='SAME', filter_size=(2, 2), stride=(2, 2), **common_args)
x = conv2d(inputs, 48, filter_size=(7, 7), name="conv1", **conv_args)
x = max_pool(x, name='pool1', **pool_args)
x = conv2d(x, 64, name="conv2_1", **conv_args)
x = conv2d(x, 64, name="conv2_2", **conv_args)
x = max_pool(x, name='pool2', **pool_args)
# 112
for block_idx in range(3):
x, n_filters = dense_block(
x,
n_filters,
num_layers=n_layers[block_idx],
drop_p=drop_p_conv,
block_name='dense_' + str(block_idx),
**conv_args)
x = trans_block(
x, n_filters, drop_p=drop_p_trans, block_name='trans_' + str(block_idx), **conv_args)
x, n_filters = dense_block(
x, n_filters, num_layers=n_layers[3], drop_p=drop_p_trans, block_name='dense_3', **conv_args)
# 8
x = global_avg_pool(x, name='avgpool_1a_8x8')
logits = fully_connected(x, n_output=num_classes, name="logits", **logit_args)
predictions = softmax(logits, name='predictions', **common_args)
return end_points(is_training)
def model(inputs,
is_training,
reuse,
num_classes=5,
drop_prob=0.2,
name='InceptionResnetV2'):
common_args = common_layer_args(is_training, reuse)
rest_conv_params = make_args(use_bias=False,
batch_norm=batch_norm,
activation=relu,
**common_args)
conv_params_no_bias = make_args(use_bias=False,
batch_norm=batch_norm,
activation=relu,
**common_args)
conv_params = make_args(use_bias=True,
batch_norm=batch_norm,
activation=None,
**common_args)
rest_logit_params = make_args(activation=None, **common_args)
rest_pool_params = make_args(padding='SAME', **common_args)
rest_dropout_params = make_args(drop_p=drop_prob, **common_args)
# inputs = input((None, crop_size[1], crop_size[0], 3), **common_args)
with tf.variable_scope(name, 'InceptionResnetV2'):
net = conv2d(inputs,
32,
stride=(2, 2),
name='Conv2d_1a_3x3',
**conv_params_no_bias)
net = conv2d(net, 32, name='Conv2d_2a_3x3', **conv_params_no_bias)
# 112 x 112
net = conv2d(net, 64, name='Conv2d_2b_3x3', **rest_conv_params)
# 112 x 112
net = max_pool(net, name='MaxPool_3a_3x3', **rest_pool_params)
# 64 x 64
net = conv2d(net,
80,
filter_size=(1, 1),
name='Conv2d_3b_1x1',
**rest_conv_params)
# 64 x 64
net = conv2d(net, 192, name='Conv2d_4a_3x3', **rest_conv_params)
# 64 x 64
net = max_pool(net,
stride=(2, 2),
name='maxpool_5a_3x3',
**rest_pool_params)
# 32 x 32
with tf.variable_scope('Mixed_5b'):
with tf.variable_scope('Branch_0'):
tower_conv = conv2d(net,
96,
filter_size=(1, 1),
name='Conv2d_1x1',
**rest_conv_params)
with tf.variable_scope('Branch_1'):
tower_conv1_0 = conv2d(net,
48,
filter_size=(1, 1),
name='Conv2d_0a_1x1',
**rest_conv_params)
tower_conv1_1 = conv2d(tower_conv1_0,
64,
filter_size=(5, 5),
name='Conv2d_0b_5x5',
**rest_conv_params)
with tf.variable_scope('Branch_2'):
tower_conv2_0 = conv2d(net,
64,
filter_size=(1, 1),
name='Conv2d_0a_1x1',
**rest_conv_params)
tower_conv2_1 = conv2d(tower_conv2_0,
96,
name='Conv2d_0b_3x3',
**rest_conv_params)
tower_conv2_2 = conv2d(tower_conv2_1,
96,
name='Conv2d_0c_3x3',
**rest_conv_params)
with tf.variable_scope('Branch_3'):
tower_pool = avg_pool_2d(net,
stride=(1, 1),
name='avgpool_0a_3x3',
**rest_pool_params)
tower_pool_1 = conv2d(tower_pool,
64,
filter_size=(1, 1),
name='Conv2d_0b_1x1',
**rest_conv_params)
net = tf.concat(
[tower_conv, tower_conv1_1, tower_conv2_2, tower_pool_1], 3)
with tf.variable_scope('Repeat'):
for i in range(1, 11):
net = block35(net,
name='block35_' + str(i),
scale=0.17,
**conv_params_no_bias)
# 32 x 32
with tf.variable_scope('Mixed_6a'):
with tf.variable_scope('Branch_0'):
tower_conv = conv2d(net,
384,
stride=(2, 2),
name='Conv2d_1a_3x3',
**rest_conv_params)
with tf.variable_scope('Branch_1'):
tower_conv1_0 = conv2d(net,
256,
filter_size=(1, 1),
name='Conv2d_0a_1x1',
**rest_conv_params)
tower_conv1_1 = conv2d(tower_conv1_0,
256,
name='Conv2d_0b_3x3',
**rest_conv_params)
tower_conv1_2 = conv2d(tower_conv1_1,
384,
stride=(2, 2),
name='Conv2d_1a_3x3',
**rest_conv_params)
with tf.variable_scope('Branch_2'):
tower_pool = max_pool(net,
name='maxpool_1a_3x3',
**rest_pool_params)
net = tf.concat([tower_conv, tower_conv1_2, tower_pool], 3)
with tf.variable_scope('Repeat_1'):
for i in range(1, 21):
net = block17(net,
name='block17_' + str(i),
scale=0.10,
**conv_params_no_bias)
with tf.variable_scope('Mixed_7a'):
with tf.variable_scope('Branch_0'):
tower_conv = conv2d(net,
256,
filter_size=(1, 1),
name='Conv2d_0a_1x1',
**rest_conv_params)
tower_conv_1 = conv2d(tower_conv,
384,
stride=(2, 2),
name='Conv2d_1a_3x3',
**rest_conv_params)
with tf.variable_scope('Branch_1'):
tower_conv1 = conv2d(net,
256,
filter_size=(1, 1),
name='Conv2d_0a_1x1',
**rest_conv_params)
tower_conv1_1 = conv2d(tower_conv1,
288,
stride=(2, 2),
name='Conv2d_1a_3x3',
**rest_conv_params)
with tf.variable_scope('Branch_2'):
tower_conv2 = conv2d(net,
256,
filter_size=(1, 1),
name='Conv2d_0a_1x1',
**rest_conv_params)
tower_conv2_1 = conv2d(tower_conv2,
288,
name='Conv2d_0b_3x3',
**rest_conv_params)
tower_conv2_2 = conv2d(tower_conv2_1,
320,
stride=(2, 2),
name='Conv2d_1a_3x3',
**rest_conv_params)
with tf.variable_scope('Branch_3'):
tower_pool = max_pool(net,
name='maxpool_1a_3x3',
**rest_pool_params)
net = tf.concat(
[tower_conv_1, tower_conv1_1, tower_conv2_2, tower_pool], 3)
# 8 x 8
with tf.variable_scope('Repeat_2'):
for i in range(1, 10):
net = block8(net,
name='block8_' + str(i),
scale=0.20,
**conv_params_no_bias)
net = block8(net, name='Block8', **conv_params_no_bias)
net = conv2d(net,
1536,
filter_size=(1, 1),
name='Conv2d_7b_1x1',
**rest_conv_params)
with tf.variable_scope('Logits'):
net = global_avg_pool(net, name='avgpool_1a_8x8')
net = dropout(net, name='dropout', **rest_dropout_params)
logits = fully_connected(net,
num_classes,
name='Logits',
**rest_logit_params)
predictions = softmax(logits, name='Predictions', **common_args)
return end_points(is_training)
def bottleneck_se(inputs,
depth,
depth_bottleneck,
stride,
rate=1,
name=None,
**kwargs):
"""SE Bottleneck residual unit variant with BN before convolutions.
This is the full preactivation residual unit variant proposed in [2]. See
Fig. 1(b) of [2] for its definition. Note that we use here the bottleneck
variant which has an extra bottleneck layer.
When putting together two consecutive ResNet blocks that use this unit, one
should use stride = 2 in the last unit of the first block.
Args:
inputs: A tensor of size [batch, height, width, channels].
depth: The depth of the ResNet unit output.
depth_bottleneck: The depth of the bottleneck layers.
stride: The ResNet unit's stride. Determines the amount of downsampling of
the units output compared to its input.
rate: An integer, rate for atrous convolution.
outputs_collections: Collection to add the ResNet unit output.
name: Optional variable_scope.
Returns:
The ResNet unit's output.
"""
is_training = kwargs.get('is_training')
reuse = kwargs.get('reuse')
with tf.variable_scope(name, 'bottleneck_se', [inputs]):
depth_in = util.last_dimension(inputs.get_shape(), min_rank=4)
preact = batch_norm(inputs,
activation_fn=tf.nn.relu,
name='preact',
is_training=is_training,
reuse=reuse)
if depth * 4 == depth_in:
shortcut = subsample(preact, stride, 'shortcut')
else:
shortcut = conv2d(preact,
depth * 4,
is_training,
reuse,
filter_size=(1, 1),
stride=(stride, stride),
batch_norm=None,
activation=None,
name='shortcut')
residual = conv2d(preact,
depth,
filter_size=(1, 1),
stride=(1, 1),
name='conv1',
**kwargs)
residual = conv2d(residual,
depth,
filter_size=(3, 3),
stride=(stride, stride),
name='conv2',
**kwargs)
residual = conv2d(residual,
depth * 4,
is_training,
reuse,
filter_size=(1, 1),
stride=(1, 1),
batch_norm=None,
activation=None,
name='conv3')
squeeze = global_avg_pool(residual, name='se_global_avg_pool')
squeeze = fully_connected(squeeze,
depth // 4,
is_training,
reuse,
name='fc1')
squeeze = fully_connected(squeeze,
depth * 4,
is_training,
reuse,
name='fc2')
squeeze = tf.nn.sigmoid(squeeze, name='se_fc_sigmoid')
residual = residual * tf.reshape(squeeze, [-1, 1, 1, depth * 4])
return residual + shortcut
def discriminator(inputs, is_training, reuse, num_classes=11, batch_size=32):
common_args = common_layer_args(is_training, reuse)
conv_args = make_args(batch_norm=True,
activation=lrelu,
w_init=initz.he_normal(scale=1),
untie_biases=False,
**common_args)
conv_args_1st = make_args(batch_norm=None,
activation=lrelu,
w_init=initz.he_normal(scale=1),
untie_biases=False,
**common_args)
logits_args = make_args(activation=None,
w_init=initz.he_normal(scale=1),
**common_args)
pool_args = make_args(padding='SAME', **common_args)
end_points = {}
x = inputs
end_points['inputs'] = x
x = dropout(x, drop_p=0.2, name="input_dropout1", **common_args)
x = conv2d(x,
96,
filter_size=(5, 5),
stride=(2, 2),
name="d_conv1_1",
**conv_args_1st)
end_points['d_conv1_1'] = x
x = conv2d(x, 96, name="d_conv1_2", **conv_args)
end_points['d_conv1_2'] = x
x = conv2d(x, 96, stride=(2, 2), name="d_conv1_3", **conv_args)
end_points['d_conv1_3'] = x
x = dropout(x, drop_p=0.2, name="dropout1", **common_args)
x = conv2d(x, 192, name="d_conv2_1", **conv_args)
end_points['d_conv2_1'] = x
x = conv2d(x, 192, name="d_conv2_2", **conv_args)
end_points['d_conv2_2'] = x
x = conv2d(x, 192, stride=(2, 2), name="d_conv2_3", **conv_args)
end_points['d_conv2_3'] = x
x = dropout(x, drop_p=0.2, name="dropout2", **common_args)
x = conv2d(x, 192, stride=(2, 2), name="d_conv3_1", **conv_args)
end_points['d_conv3_1'] = x
x = conv2d(x, 192, filter_size=(1, 1), name="d_conv4_1", **conv_args)
end_points['d_conv4_1'] = x
x = conv2d(x, 192, filter_size=(1, 1), name="d_conv4_2", **conv_args)
end_points['d_conv4_2'] = x
x = global_avg_pool(x, name="global_pool")
end_points['global_pool'] = x
logits = fully_connected(x, num_classes, name="d_logits", **logits_args)
end_points['logits'] = logits
end_points['predictions'] = softmax(logits,
name='predictions',
**common_args)
if is_training:
batch_size = 2 * batch_size
generated_class_logits = tf.squeeze(
tf.slice(logits, [0, num_classes - 1], [batch_size, 1]))
end_points['generated_class_logits'] = generated_class_logits
positive_class_logits = tf.slice(logits, [0, 0],
[batch_size, num_classes - 1])
end_points['positive_class_logits'] = positive_class_logits
max_ = tf.reduce_max(positive_class_logits, 1, keep_dims=True)
safe_pos_class_logits = positive_class_logits - max_
end_points['safe_pos_class_logits'] = safe_pos_class_logits
gan_logits = tf.log(
tf.reduce_sum(tf.exp(safe_pos_class_logits),
1)) + tf.squeeze(max_) - generated_class_logits
end_points['gan_logits'] = gan_logits
assert len(gan_logits.get_shape()) == 1
probs = tf.nn.sigmoid(gan_logits)
end_points['probs'] = probs
class_logits = tf.slice(logits, [0, 0], [batch_size / 2, num_classes])
end_points['class_logits'] = class_logits
D_on_data = tf.slice(probs, [0], [batch_size / 2])
end_points['D_on_data'] = D_on_data
D_on_data_logits = tf.slice(gan_logits, [0], [batch_size / 2])
end_points['D_on_data_logits'] = D_on_data_logits
D_on_G = tf.slice(probs, [batch_size / 2], [batch_size / 2])
end_points['D_on_G'] = D_on_G
D_on_G_logits = tf.slice(gan_logits, [batch_size / 2],
[batch_size / 2])
end_points['D_on_G_logits'] = D_on_G_logits
return end_points
else:
return end_points
def model(is_training, reuse):
common_trainable_args = common_layer_args(is_training,
reuse,
trainable=True)
common_frozen_args = common_layer_args(is_training, reuse, trainable=False)
conv_args = make_conv_args(activation=relu, **common_frozen_args)
logit_args = make_args(activation=None, **common_trainable_args)
common_args = common_frozen_args
net = input((None, crop_size[1], crop_size[0], 3), **common_args)
with tf.variable_scope('resnet_v1_50', reuse=reuse):
mean_rgb = tf.get_variable(name='mean_rgb',
initializer=tf.truncated_normal(shape=[3]),
trainable=False)
net = net - mean_rgb
net = conv2d_same(net, 64, 7, stride=2, scope='conv1', **conv_args)
net = max_pool(net,
filter_size=(3, 3),
stride=(2, 2),
padding='SAME',
name='pool1')
with tf.variable_scope('block1') as sc:
with tf.variable_scope('unit_1'):
net = bottleneck(net, 256, 64, 1, **common_args)
with tf.variable_scope('unit_2'):
net = bottleneck(net, 256, 64, 1, **common_args)
with tf.variable_scope('unit_3'):
net = bottleneck(net, 256, 64, 2, **common_args)
net = _collect_named_outputs(common_args['outputs_collections'],
sc.name, net)
with tf.variable_scope('block2') as sc:
with tf.variable_scope('unit_1'):
net = bottleneck(net, 512, 128, 1, **common_args)
with tf.variable_scope('unit_2'):
net = bottleneck(net, 512, 128, 1, **common_args)
with tf.variable_scope('unit_3'):
net = bottleneck(net, 512, 128, 1, **common_args)
with tf.variable_scope('unit_4'):
net = bottleneck(net, 512, 128, 2, **common_args)
net = _collect_named_outputs(common_args['outputs_collections'],
sc.name, net)
with tf.variable_scope('block3') as sc:
with tf.variable_scope('unit_1'):
net = bottleneck(net, 1024, 256, 1, **common_args)
with tf.variable_scope('unit_2'):
net = bottleneck(net, 1024, 256, 1, **common_args)
with tf.variable_scope('unit_3'):
net = bottleneck(net, 1024, 256, 1, **common_args)
with tf.variable_scope('unit_4'):
net = bottleneck(net, 1024, 256, 1, **common_args)
with tf.variable_scope('unit_5'):
net = bottleneck(net, 1024, 256, 1, **common_args)
with tf.variable_scope('unit_6'):
net = bottleneck(net, 1024, 256, 2, **common_args)
net = _collect_named_outputs(common_args['outputs_collections'],
sc.name, net)
common_args = common_trainable_args
with tf.variable_scope('block4') as sc:
with tf.variable_scope('unit_1'):
net = bottleneck(net, 2048, 512, 1, **common_args)
with tf.variable_scope('unit_2'):
net = bottleneck(net, 2048, 512, 1, **common_args)
with tf.variable_scope('unit_3'):
net = bottleneck(net, 2048, 512, 1, **common_args)
net = _collect_named_outputs(common_args['outputs_collections'],
sc.name, net)
net = tf.reduce_mean(net, [1, 2], name='pool5', keep_dims=True)
logits = fully_connected(net, 2, name='logits', **logit_args)
predictions = softmax(logits, name='predictions', **common_args)
return end_points(common_args['is_training'])
