def model(x, is_train, reuse):
with tf.variable_scope("STN", reuse=reuse):
nin = InputLayer(x, name='in')
## 1. Localisation network
# use MLP as the localisation net
nt = FlattenLayer(nin, name='flatten')
nt = DenseLayer(nt, n_units=20, act=tf.nn.tanh, name='dense1')
nt = DropoutLayer(nt, 0.8, True, is_train, name='drop1')
# you can also use CNN instead for MLP as the localisation net
# nt = Conv2d(nin, 16, (3, 3), (2, 2), act=tf.nn.relu, padding='SAME', name='tc1')
# nt = Conv2d(nt, 8, (3, 3), (2, 2), act=tf.nn.relu, padding='SAME', name='tc2')
## 2. Spatial transformer module (sampler)
n = SpatialTransformer2dAffineLayer(nin,
nt,
out_size=[40, 40],
name='spatial')
s = n
## 3. Classifier
n = Conv2d(n,
16, (3, 3), (2, 2),
act=tf.nn.relu,
padding='SAME',
name='conv1')
n = Conv2d(n,
16, (3, 3), (2, 2),
act=tf.nn.relu,
padding='SAME',
name='conv2')
n = FlattenLayer(n, name='flatten2')
n = DenseLayer(n, n_units=1024, act=tf.nn.relu, name='out1')
n = DenseLayer(n, n_units=10, act=tf.identity, name='out2')
return n, s
def discriminator(inputs, is_train=True, reuse=False):
df_dim = 64 # Dimension of discrim filters in first conv layer. [64]
w_init = tf.glorot_normal_initializer()
gamma_init = tf.random_normal_initializer(1., 0.02)
with tf.variable_scope("discriminator", reuse=reuse):
net_in = InputLayer(inputs, name='d/in')
net_h0 = Conv2d(net_in,
df_dim, (5, 5), (2, 2),
act=tf.nn.leaky_relu,
padding='SAME',
W_init=w_init,
name='d/h0/conv2d')
net_h1 = Conv2d(net_h0,
df_dim * 2, (5, 5), (2, 2),
act=None,
padding='SAME',
W_init=w_init,
name='d/h1/conv2d')
net_h1 = BatchNormLayer(net_h1,
act=tf.nn.leaky_relu,
is_train=is_train,
gamma_init=gamma_init,
name='d/h1/batch_norm')
net_h2 = Conv2d(net_h1,
df_dim * 4, (5, 5), (2, 2),
act=None,
padding='SAME',
W_init=w_init,
name='d/h2/conv2d')
net_h2 = BatchNormLayer(net_h2,
act=tf.nn.leaky_relu,
is_train=is_train,
gamma_init=gamma_init,
name='d/h2/batch_norm')
net_h3 = Conv2d(net_h2,
df_dim * 8, (5, 5), (2, 2),
act=None,
padding='SAME',
W_init=w_init,
name='d/h3/conv2d')
net_h3 = BatchNormLayer(net_h3,
act=tf.nn.leaky_relu,
is_train=is_train,
gamma_init=gamma_init,
name='d/h3/batch_norm')
net_h4 = FlattenLayer(net_h3, name='d/h4/flatten')
net_h4 = DenseLayer(net_h4,
n_units=1,
act=tf.identity,
W_init=w_init,
name='d/h4/lin_sigmoid')
logits = net_h4.outputs
net_h4.outputs = tf.nn.sigmoid(net_h4.outputs)
return net_h4, logits
def discriminator1(inputs, is_train=True, reuse=False):
df_dim = 32 # Dimension of discrim filters in first conv layer. [64]
w_init = tf.glorot_normal_initializer()
gamma_init = tf.random_normal_initializer(1., 0.02)
lrelu = lambda x : tf.nn.leaky_relu(x, 0.2)
with tf.name_scope("DISCRIMINATOR1"):
with tf.variable_scope("discriminator", reuse=reuse):
with tf.name_scope("net_in"):
net_in = InputLayer(inputs, name='d/in')
with tf.name_scope("layer0"):
net_h0 = Conv2d(net_in, df_dim, (3, 3), (3, 3), act=lrelu,
padding='SAME', W_init=w_init, name='d/h0/conv2d')
with tf.name_scope("layer1"):
net_h1 = Conv2d(net_h0, df_dim*2, (3, 3), (3, 3), act=None,
padding='SAME', W_init=w_init, name='d/h1/conv2d')
net_h1 = BatchNormLayer(net_h1, decay=0.9, act=lrelu,
is_train=is_train, gamma_init=gamma_init, name='d/h1/batch_norm')
with tf.name_scope("layer2"):
net_h2 = Conv2d(net_h1, df_dim*4, (3, 3), (3, 3), act=None,
padding='SAME', W_init=w_init, name='d/h2/conv2d')
net_h2 = BatchNormLayer(net_h2, decay=0.9, act=lrelu,
is_train=is_train, gamma_init=gamma_init, name='d/h2/batch_norm')
with tf.name_scope("layer3"):
net_h3 = Conv2d(net_h2, df_dim*8, (3, 3), (3, 3), act=None,
padding='SAME', W_init=w_init, name='d/h3/conv2d')
net_h3 = BatchNormLayer(net_h3, decay=0.9, act=lrelu,
is_train=is_train, gamma_init=gamma_init, name='d/h3/batch_norm')
with tf.name_scope("layer4"):
net_h4 = FlattenLayer(net_h3, name='d/h4/flatten')
net_h4 = DenseLayer(net_h4, n_units=df_dim*8, act=tf.identity,
W_init = w_init, name='d/h4/lin_sigmoid')
with tf.name_scope("layer5"):
net_h5 = FlattenLayer(net_h4, name='d/h5/flatten')
net_h5 = DenseLayer(net_h5, n_units=df_dim*8, act=tf.identity,
W_init = w_init, name='d/h5/lin_sigmoid')
#net_h6 = FlattenLayer(net_h5, name='d/h6/flatten')
with tf.name_scope("layer6"):
net_h6= DenseLayer(net_h5, n_units=2, act=tf.identity,
W_init = w_init, name='d/h6/lin_sigmoid')
logits1 = net_h6.outputs
net_h6.outputs = tf.nn.softplus(net_h6.outputs)
return net_h6, logits1
def mobilenet(x, is_train=True, reuse=False):
with tf.variable_scope("mobilenet", reuse=reuse):
n = InputLayer(x)
n = conv_block(n, 32, strides=(2, 2), is_train=is_train, name="conv")
n = depthwise_conv_block(n, 64, is_train=is_train, name="depth1")
n = depthwise_conv_block(n, 128, strides=(2, 2), is_train=is_train, name="depth2")
n = depthwise_conv_block(n, 128, is_train=is_train, name="depth3")
n = depthwise_conv_block(n, 256, strides=(2, 2), is_train=is_train, name="depth4")
n = depthwise_conv_block(n, 256, is_train=is_train, name="depth5")
n = depthwise_conv_block(n, 512, strides=(2, 2), is_train=is_train, name="depth6")
n = depthwise_conv_block(n, 512, is_train=is_train, name="depth7")
n = depthwise_conv_block(n, 512, is_train=is_train, name="depth8")
n = depthwise_conv_block(n, 512, is_train=is_train, name="depth9")
n = depthwise_conv_block(n, 512, is_train=is_train, name="depth10")
n = depthwise_conv_block(n, 512, is_train=is_train, name="depth11")
n = depthwise_conv_block(n, 1024, strides=(2, 2), is_train=is_train, name="depth12")
n = depthwise_conv_block(n, 1024, is_train=is_train, name="depth13")
n = GlobalMeanPool2d(n)
# n = DropoutLayer(n, 1-1e-3, True, is_train, name='drop')
# n = DenseLayer(n, 1000, act=tf.identity, name='output') # equal
n = ReshapeLayer(n, [-1, 1, 1, 1024])
n = Conv2d(n, 1000, (1, 1), (1, 1), name='out')
n = FlattenLayer(n)
return n
def model(x, is_train):
with tf.variable_scope("model", reuse=tf.AUTO_REUSE):
net = InputLayer(x, name='input')
net = Conv2d(net,
64, (5, 5), (1, 1),
padding='SAME',
b_init=None,
name='cnn1')
net = BatchNormLayer(net,
decay=0.99,
is_train=is_train,
act=tf.nn.relu,
name='batch1')
net = MaxPool2d(net, (3, 3), (2, 2), padding='SAME', name='pool1')
net = Conv2d(net,
64, (5, 5), (1, 1),
padding='SAME',
b_init=None,
name='cnn2')
net = BatchNormLayer(net,
decay=0.99,
is_train=is_train,
act=tf.nn.relu,
name='batch2')
net = MaxPool2d(net, (3, 3), (2, 2), padding='SAME', name='pool2')
net = FlattenLayer(net, name='flatten')
net = DenseLayer(net, 384, act=tf.nn.relu, name='d1relu')
net = DenseLayer(net, 192, act=tf.nn.relu, name='d2relu')
net = DenseLayer(net, 10, act=None, name='output')
return net
def model_batch_norm(x_crop, y_, is_train, reuse):
W_init = tf.truncated_normal_initializer(stddev=5e-2)
W_init2 = tf.truncated_normal_initializer(stddev=0.04)
b_init2 = tf.constant_initializer(value=0.1)
with tf.variable_scope("model", reuse=reuse):
net = InputLayer(x_crop, name='input')
net = Conv2d(net, 64, (5, 5), (1, 1), padding='SAME', W_init=W_init, b_init=None, name='cnn1')
net = BatchNormLayer(net, decay=0.99, is_train=is_train, act=tf.nn.relu, name='batch1')
net = MaxPool2d(net, (3, 3), (2, 2), padding='SAME', name='pool1')
net = Conv2d(net, 64, (5, 5), (1, 1), padding='SAME', W_init=W_init, b_init=None, name='cnn2')
net = BatchNormLayer(net, decay=0.99, is_train=is_train, act=tf.nn.relu, name='batch2')
net = MaxPool2d(net, (3, 3), (2, 2), padding='SAME', name='pool2')
net = FlattenLayer(net, name='flatten')
net = DenseLayer(net, 384, act=tf.nn.relu, W_init=W_init2, b_init=b_init2, name='d1relu')
net = DenseLayer(net, 192, act=tf.nn.relu, W_init=W_init2, b_init=b_init2, name='d2relu')
net = DenseLayer(net, n_units=10, act=None, W_init=W_init2, name='output')
y = net.outputs
ce = tl.cost.cross_entropy(y, y_, name='cost')
# L2 for the MLP, without this, the accuracy will be reduced by 15%.
L2 = 0
for p in tl.layers.get_variables_with_name('relu/W', True, True):
L2 += tf.contrib.layers.l2_regularizer(0.004)(p)
cost = ce + L2
correct_prediction = tf.equal(tf.cast(tf.argmax(y, 1), tf.int32), y_)
acc = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
return net, cost, acc
def build_classifier(self, im, inf_norm, reuse=False):
with tf.variable_scope("C", reuse=reuse) as vs:
x = tf.reshape(im, [-1, 64, 64, 3])
xmin = tf.clip_by_value(x - inf_norm, 0., 1.)
xmax = tf.clip_by_value(x + inf_norm, 0., 1.)
x = tf.random_uniform(tf.shape(x), xmin, xmax, dtype=tf.float32)
#x = tf.map_fn(lambda frame: tf.image.per_image_standardization(frame), x)
net = InputLayer(x)
n_filters = 3
for i in range(2):
net = Conv2dLayer(net, \
act=tf.nn.relu, \
shape=[5,5,n_filters,64], \
name="conv_" + str(i))
net = MaxPool2d(net, \
filter_size=(3,3), \
strides=(2,2), \
name="mpool_" + str(i))
net = LocalResponseNormLayer(net, \
depth_radius=4, \
bias=1.0, \
alpha=0.001 / 9.0, \
beta=0.75, \
name="lrn_" + str(i))
n_filters = 64
net = FlattenLayer(net)
net = DenseLayer(net, n_units=384, act=tf.nn.relu, name="d1")
net = DenseLayer(net, n_units=192, act=tf.nn.relu, name="d2")
net = DenseLayer(net, n_units=2, act=tf.identity, name="final")
cla_vars = tf.contrib.framework.get_variables(vs)
return net.outputs, cla_vars
def celebA_classifier(ims, reuse):
with tf.variable_scope("C", reuse=reuse) as vs:
net = InputLayer(ims)
n_filters = 3
for i in range(2):
net = Conv2dLayer(net, \
act=tf.nn.relu, \
shape=[5,5,n_filters,64], \
name="conv_" + str(i))
net = MaxPool2d(net, \
filter_size=(3,3), \
strides=(2,2), \
name="mpool_" + str(i))
net = LocalResponseNormLayer(net, \
depth_radius=4, \
bias=1.0, \
alpha=0.001 / 9.0, \
beta=0.75, \
name="lrn_" + str(i))
n_filters = 64
net = FlattenLayer(net)
net = DenseLayer(net, n_units=384, act=tf.nn.relu, name="d1")
net = DenseLayer(net, n_units=192, act=tf.nn.relu, name="d2")
net = DenseLayer(net, n_units=2, act=tf.identity, name="final")
cla_vars = tf.contrib.framework.get_variables(vs)
if not reuse:
return net.outputs, tf.argmax(net.outputs, axis=1), cla_vars
return net.outputs, tf.argmax(net.outputs, axis=1)
def discriminator(inputs, is_train=True):
with tf.variable_scope("discriminator", reuse=tf.AUTO_REUSE):
net_in = InputLayer(inputs, name='din')
#Conv2d is tf.nn.conv2d + tf.nn.relu
dnet_c0 = Conv2d(net_in,
64, (8, 8), (2, 2),
act=tf.nn.relu,
padding='SAME',
name='dnet_c0')
#Conv2d is tf.nn.conv2d
#BatchNormLayer is tf.nn.batch_normalization + tf.nn.relu
dnet_c1 = Conv2d(dnet_c0,
128, (8, 8), (2, 2),
act=None,
padding='SAME',
name='dnet_c1')
dnet_b1 = BatchNormLayer(dnet_c1,
decay=0.9,
act=tf.nn.relu,
is_train=is_train,
name='dnet_b1')
# dnet_p1 = MaxPool2d(dnet_b1, (2, 2), name='pool2') #Don't use pool layer, it is not good. But you can try.
dnet_c2 = Conv2d(dnet_b1,
256, (8, 8), (2, 2),
act=None,
padding='SAME',
name='dnet_c2')
dnet_b2 = BatchNormLayer(dnet_c2,
decay=0.9,
act=tf.nn.relu,
is_train=is_train,
name='dnet_b2')
dnet_c3 = Conv2d(dnet_b2,
512, (8, 8), (2, 2),
act=None,
padding='SAME',
name='dnet_c3')
dnet_b3 = BatchNormLayer(dnet_c3,
decay=0.9,
act=tf.nn.relu,
is_train=is_train,
name='dnet_b3')
#FlattenLayer is tf.reshape
dnet_f1 = FlattenLayer(dnet_b3, name='dnet_f1')
#DenseLayer is tf.layers.dense, the full-connected
dnet_d1 = DenseLayer(dnet_f1,
n_units=1,
act=tf.identity,
name='dnet_h4')
logits = dnet_d1.outputs
dnet_d1.outputs = tf.nn.sigmoid(dnet_d1.outputs)
return dnet_d1, logits
def build_classifier(self, im, inf_norm, reuse=False):
with tf.variable_scope('C', reuse=reuse) as vs:
tensorlayer.layers.set_name_reuse(reuse)
x = tf.reshape(im, [-1, 3, 32, 32])
x = tf.transpose(x, [0, 2, 3, 1])
xmin = tf.clip_by_value(x - inf_norm, 0., 1.)
xmax = tf.clip_by_value(x + inf_norm, 0., 1.)
x = tf.random_uniform(tf.shape(x), xmin, xmax, dtype=tf.float32)
# Crop the central [height, width] of the image.
# x = tf.image.resize_image_with_crop_or_pad(x, 24, 24)
x = tf.map_fn(lambda frame: tf.image.per_image_standardization(frame), x)
net = InputLayer(x)
net = Conv2dLayer(net, \
act=tf.nn.relu, \
shape=[5,5,3,64], \
name="conv1")
net = MaxPool2d(net, \
filter_size=(3,3), \
strides=(2,2), \
name="pool1")
net = LocalResponseNormLayer(net, \
depth_radius=4, \
bias=1.0, \
alpha = 0.001/9.0, \
beta = 0.75, \
name="norm1")
net = Conv2dLayer(net, \
act=tf.nn.relu, \
shape=[5,5,64,64], \
name="conv2")
net = LocalResponseNormLayer(net, \
depth_radius=4, \
bias=1.0, \
alpha=0.001/9.0, \
beta = 0.75, \
name="norm2")
net = MaxPool2d(net, \
filter_size=(3,3), \
strides=(2,2), \
name="pool2")
net = FlattenLayer(net, name="flatten_1")
net = DenseLayer(net, n_units=384, name="local3", act=tf.nn.relu)
net = DenseLayer(net, n_units=192, name="local4", act=tf.nn.relu)
net = DenseLayer(net, n_units=10, name="softmax_linear", act=tf.identity)
cla_vars = tf.contrib.framework.get_variables(vs)
def name_fixer(var):
return var.op.name.replace("W", "weights") \
.replace("b", "biases") \
.replace("weights_conv2d", "weights") \
.replace("biases_conv2d", "biases")
cla_vars = {name_fixer(var): var for var in cla_vars}
return net.outputs, cla_vars
def discriminator(inputs, is_train=True, reuse=False):
dfs = 64
gamma_init = tf.random_normal_initializer(1., 0.02)
W_init = tf.random_normal_initializer(stddev=0.02)
with tf.variable_scope('discriminator', reuse=reuse):
tl.layers.set_name_reuse(reuse)
d = InputLayer(inputs, name='d/inputs')
d = Conv2d(d,
dfs, (5, 5), (2, 2),
W_init=W_init,
act=lambda x: tl.act.lrelu(x, 0.2),
name='d/conv1')
d = Conv2d(d,
dfs * 2, (5, 5), (2, 2),
W_init=W_init,
act=None,
name='d/conv2')
d = BatchNormLayer(d,
act=lambda x: tl.act.lrelu(x, 0.2),
is_train=is_train,
gamma_init=gamma_init,
name='d/bn3')
d = Conv2d(d,
dfs * 4, (5, 5), (2, 2),
W_init=W_init,
act=None,
name='d/conv4')
d = BatchNormLayer(d,
act=lambda x: tl.act.lrelu(x, 0.2),
is_train=is_train,
gamma_init=gamma_init,
name='d/bn5')
d = Conv2d(d,
dfs * 8, (5, 5), (2, 2),
W_init=W_init,
act=None,
name='d/conv6')
d = BatchNormLayer(d,
act=lambda x: tl.act.lrelu(x, 0.2),
is_train=is_train,
gamma_init=gamma_init,
name='d/bn7')
d = FlattenLayer(d, name='d/flt8')
d = DenseLayer(d,
1,
act=tl.act.identity,
W_init=W_init,
name='d/output')
logits = d.outputs
d.outputs = tf.nn.sigmoid(d.outputs)
return d, logits
def model(x, y_, reuse, is_train=False):
W_init = tf.truncated_normal_initializer(stddev=5e-2)
W_init2 = tf.truncated_normal_initializer(stddev=0.04)
b_init2 = tf.constant_initializer(value=0.1)
with tf.variable_scope("model", reuse=reuse):
tl.layers.set_name_reuse(reuse)
net = InputLayer(x, name='input')
net = Conv2d(net,
32, (3, 3), (1, 1),
act=tf.nn.relu,
padding='SAME',
W_init=W_init,
name='cnn1')
net = Conv2d(net,
32, (3, 3), (1, 1),
act=tf.nn.relu,
W_init=W_init,
name='cnn2',
padding="VALID")
net = MaxPool2d(net, name='pool1', padding="VALID")
net = DropoutLayer(net, keep=0.75, is_train=is_train, name='drop1')
net = Conv2d(net,
64, (3, 3), (1, 1),
act=tf.nn.relu,
padding='SAME',
W_init=W_init,
name='cnn3')
net = Conv2d(net,
64, (3, 3), (1, 1),
act=tf.nn.relu,
W_init=W_init,
name='cnn4',
padding="VALID")
net = MaxPool2d(net, name='pool2', padding="VALID")
net = DropoutLayer(net, keep=0.75, is_train=is_train, name='drop2')
net = FlattenLayer(net, name='flatten')
net = DenseLayer(net,
n_units=512,
act=tf.nn.relu,
W_init=W_init2,
b_init=b_init2,
name='d1relu')
net = DenseLayer(net,
n_units=10,
act=tf.identity,
W_init=tf.truncated_normal_initializer(stddev=1 /
192.0),
name='output') # output: (batch_size, 10)
y = net.outputs
loss = tl.cost.cross_entropy(y, y_, name='cost')
correct_prediction = tf.equal(tf.argmax(y, 1), y_)
acc = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
return net, loss, acc
def cifar10_classifier(im, reuse):
with tf.variable_scope('C', reuse=reuse) as vs:
net = InputLayer(im)
net = Conv2dLayer(net, \
act=tf.nn.relu, \
shape=[5,5,3,64], \
name="conv1")
net = MaxPool2d(net, \
filter_size=(3,3), \
strides=(2,2), \
name="pool1")
net = LocalResponseNormLayer(net, \
depth_radius=4, \
bias=1.0, \
alpha = 0.001/9.0, \
beta = 0.75, \
name="norm1")
net = Conv2dLayer(net, \
act=tf.nn.relu, \
shape=[5,5,64,64], \
name="conv2")
net = LocalResponseNormLayer(net, \
depth_radius=4, \
bias=1.0, \
alpha=0.001/9.0, \
beta = 0.75, \
name="norm2")
net = MaxPool2d(net, \
filter_size=(3,3), \
strides=(2,2), \
name="pool2")
net = FlattenLayer(net, name="flatten_1")
net = DenseLayer(net, n_units=384, name="local3", act=tf.nn.relu)
net = DenseLayer(net, n_units=192, name="local4", act=tf.nn.relu)
net = DenseLayer(net,
n_units=10,
name="softmax_linear",
act=tf.identity)
cla_vars = tf.contrib.framework.get_variables(vs)
def name_fixer(var):
return var.op.name.replace("W", "weights") \
.replace("b", "biases") \
.replace("weights_conv2d", "weights") \
.replace("biases_conv2d", "biases")
cla_vars = {name_fixer(var): var for var in cla_vars}
if not reuse:
return net.outputs, tf.argmax(net.outputs, axis=1), cla_vars
return net.outputs, tf.argmax(net.outputs, axis=1)
def mobilenetv1(self, x, end_with='out', is_train=False, reuse=None):
with tf.variable_scope("mobilenetv1", reuse=reuse):
n = InputLayer(x)
n = self.conv_block(n, 32, strides=(2, 2), is_train=is_train, name="conv")
if end_with in n.outputs.name: return n
n = self.depthwise_conv_block(n, 64, is_train=is_train, name="depth1")
if end_with in n.outputs.name: return n
n = self.depthwise_conv_block(n, 128, strides=(2, 2), is_train=is_train, name="depth2")
if end_with in n.outputs.name: return n
n = self.depthwise_conv_block(n, 128, is_train=is_train, name="depth3")
if end_with in n.outputs.name: return n
n = self.depthwise_conv_block(n, 256, strides=(2, 2), is_train=is_train, name="depth4")
if end_with in n.outputs.name: return n
n = self.depthwise_conv_block(n, 256, is_train=is_train, name="depth5")
if end_with in n.outputs.name: return n
n = self.depthwise_conv_block(n, 512, strides=(2, 2), is_train=is_train, name="depth6")
if end_with in n.outputs.name: return n
n = self.depthwise_conv_block(n, 512, is_train=is_train, name="depth7")
if end_with in n.outputs.name: return n
n = self.depthwise_conv_block(n, 512, is_train=is_train, name="depth8")
if end_with in n.outputs.name: return n
n = self.depthwise_conv_block(n, 512, is_train=is_train, name="depth9")
if end_with in n.outputs.name: return n
n = self.depthwise_conv_block(n, 512, is_train=is_train, name="depth10")
if end_with in n.outputs.name: return n
n = self.depthwise_conv_block(n, 512, is_train=is_train, name="depth11")
if end_with in n.outputs.name: return n
n = self.depthwise_conv_block(n, 1024, strides=(2, 2), is_train=is_train, name="depth12")
if end_with in n.outputs.name: return n
n = self.depthwise_conv_block(n, 1024, is_train=is_train, name="depth13")
if end_with in n.outputs.name: return n
n = GlobalMeanPool2d(n, name='globalmeanpool')
if end_with in n.outputs.name: return n
# n = DropoutLayer(n, 1-1e-3, True, is_train, name='drop')
# n = DenseLayer(n, 1000, act=tf.identity, name='output') # equal
n = ReshapeLayer(n, [-1, 1, 1, 1024], name='reshape')
if end_with in n.outputs.name: return n
n = Conv2d(n, 1000, (1, 1), (1, 1), name='out')
n = FlattenLayer(n, name='flatten')
if end_with == 'out': return n
raise Exception("end_with : conv, depth1, depth2 ... depth13, globalmeanpool, out")
def vgg16_net(net_in,alpha1,alpha2):
with tf.name_scope('preprocess') as scope:
# 减去全局均值，做归一化
net_in.outputs = net_in.outputs * 255.0
mean = tf.constant([123.68, 116.779, 103.939], dtype=tf.float32, shape=[1, 1, 1, 3], name='img_mean')
net_in.outputs = net_in.outputs - mean
"""conv1"""
network= Conv2d(net_in, n_filter=64, filter_size=(3, 3), strides=(1, 1), act=tf.nn.relu, padding='SAME', name='conv1_1')
network= Conv2d(network, n_filter=64, filter_size=(3, 3), strides=(1, 1), act=tf.nn.relu, padding='SAME', name='conv1_2')
network= MaxPool2d(network, filter_size=(2, 2), strides=(2, 2), padding='SAME', name='pool1')
"""conv2"""
network = Conv2d(network, n_filter=128, filter_size=(3, 3), strides=(1, 1), act=tf.nn.relu, padding='SAME',name='conv2_1')
network_1 = Conv2d(network, n_filter=128, filter_size=(3, 3), strides=(1, 1), act=tf.nn.relu, padding='SAME',name='conv2_2')
network = MaxPool2d(network_1, filter_size=(2, 2), strides=(2, 2), padding='SAME', name='pool2')
"""conv3"""
network = Conv2d(network, n_filter=256, filter_size=(3, 3), strides=(1, 1), act=tf.nn.relu, padding='SAME',name='conv3_1')
network = Conv2d(network, n_filter=256, filter_size=(3, 3), strides=(1, 1), act=tf.nn.relu, padding='SAME',name='conv3_2')
network = Conv2d(network, n_filter=256, filter_size=(3, 3), strides=(1, 1), act=tf.nn.relu, padding='SAME',name='conv3_3')
"""特征谱融合模块区——底层特征融合"""
network_1=tf.nn.dilation2d(network_1,filter=256,strides=[1,1,1,1],rates=[1,3,3,1],padding='SAME',name='dilation1')
network_1=MaxPool2d(network_1,filter_size=(2,2),strides=(2,2),padding='SAME',name='Pool6_1')
#代替caffe框架中的scale层
network_1=alpha1*tf.divide(network_1,tf.norm(network_1,ord='euclidean'))
#主分支的特征加低层特征处理后的特征谱图作为下一层输入
network=tf.add(network,network_1,name='Eltwise1')
network = MaxPool2d(network, filter_size=(2, 2), strides=(2, 2), padding='SAME', name='pool3')
"""conv4"""
network = Conv2d(network, n_filter=512, filter_size=(3, 3), strides=(1, 1), act=tf.nn.relu, padding='SAME',name='conv4_1')
network = Conv2d(network, n_filter=512, filter_size=(3, 3), strides=(1, 1), act=tf.nn.relu, padding='SAME',name='conv4_2')
network_1 = Conv2d(network, n_filter=512, filter_size=(3, 3), strides=(1, 1), act=tf.nn.relu, padding='SAME',name='conv4_3')
network = MaxPool2d(network_1, filter_size=(2, 2), strides=(2, 2), padding='SAME', name='pool4')
"""conv5"""
network = Conv2d(network, n_filter=512, filter_size=(3, 3), strides=(1, 1), act=tf.nn.relu, padding='SAME',name='conv5_1')
network = Conv2d(network, n_filter=512, filter_size=(3, 3), strides=(1, 1), act=tf.nn.relu, padding='SAME',name='conv5_2')
network = Conv2d(network, n_filter=512, filter_size=(3, 3), strides=(1, 1), act=tf.nn.relu, padding='SAME',name='conv5_3')
"""特征谱融合模块区——高层特征融合"""
network_1= tf.nn.dilation2d(network_1, filter=512, strides=[1, 1, 1, 1], rates=[1, 3, 3, 1], padding='SAME',name='dilation2')
network = MaxPool2d(network, filter_size=(2, 2), strides=(2, 2), padding='SAME', name='pool5')
"""fc_layer"""
network=FlattenLayer(network,name='flatten')
network=DenseLayer(network,n_units=4096,act=tf.nn.relu,name='fc1_relu')
network = DenseLayer(network, n_units=4096, act=tf.nn.relu, name='fc2_relu')
network = DenseLayer(network, n_units=1000, act=tf.identity, name='fc3_relu')
return network
def discriminator(self, inputs, is_train=True, reuse=False):
df_dim = image_size = self.images_size # Dimension of discrim filters in first conv layer. [64]
w_init = tf.glorot_normal_initializer()
gamma_init = tf.random_normal_initializer(1., 0.02)
lrelu = lambda x : tf.nn.leaky_relu(x, 0.2)
with tf.variable_scope("discriminator", reuse=reuse):
net_in = InputLayer(inputs, name='d/in')
net_h0 = Conv2d(net_in, df_dim, (5, 5), (2, 2), act=lrelu,
padding='SAME', W_init=w_init, name='d/h0/conv2d')
net_h1 = Conv2d(net_h0, df_dim*2, (5, 5), (2, 2), act=None,
padding='SAME', W_init=w_init, name='d/h1/conv2d')
net_h1 = BatchNormLayer(net_h1, decay=0.9, act=lrelu,
is_train=is_train, gamma_init=gamma_init, name='d/h1/batch_norm')
net_h2 = Conv2d(net_h1, df_dim*4, (5, 5), (2, 2), act=None,
padding='SAME', W_init=w_init, name='d/h2/conv2d')
net_h2 = BatchNormLayer(net_h2, decay=0.9, act=lrelu,
is_train=is_train, gamma_init=gamma_init, name='d/h2/batch_norm')
net_h3 = Conv2d(net_h2, df_dim*8, (5, 5), (2, 2), act=None,
padding='SAME', W_init=w_init, name='d/h3/conv2d')
net_h3 = BatchNormLayer(net_h3, decay=0.9, act=lrelu,
is_train=is_train, gamma_init=gamma_init, name='d/h3/batch_norm')
net_h4 = FlattenLayer(net_h3, name='d/h4/flatten')
# real or fake binary loss
net_h4_1 = DenseLayer(net_h4, n_units=1, act=tf.identity,
W_init = w_init, name='d/h4_1/lin_sigmoid')
# category loss
net_h4_2 = DenseLayer(net_h4, n_units=self.class_num, act=tf.identity,
W_init = w_init, name='d/h4_2/lin_sigmoid')
net_h4_1_logits = net_h4_1.outputs
net_h4_2_logits = net_h4_2.outputs
net_h4_1.outputs = tf.nn.sigmoid(net_h4_1.outputs)
net_h4_2.outputs = tf.nn.sigmoid(net_h4_2.outputs)
return net_h4_1, net_h4_1_logits, net_h4_2, net_h4_2_logits
def _build_net(self, is_train=True, reuse=None):
with tf.variable_scope(self.name, reuse=reuse):
n = InputLayer(self.x / 255, name='in')
n = Conv2d(n, 32, (3, 3), (1, 1), tf.nn.relu, "VALID", name='c1/1')
n = Conv2d(n, 32, (3, 3), (1, 1), tf.nn.relu, "VALID", name='c1/2')
n = MaxPool2d(n, (2, 2), (2, 2), 'VALID', name='max1')
n = DropoutLayer(n,
0.75,
is_fix=True,
is_train=is_train,
name='drop1')
n = Conv2d(n, 64, (3, 3), (1, 1), tf.nn.relu, "VALID", name='c2/1')
n = Conv2d(n, 64, (3, 3), (1, 1), tf.nn.relu, "VALID", name='c2/2')
n = MaxPool2d(n, (2, 2), (2, 2), 'VALID', name='max2')
n = DropoutLayer(n,
0.75,
is_fix=True,
is_train=is_train,
name='drop2')
n = FlattenLayer(n, name='f')
n = DenseLayer(n, 512, tf.nn.relu, name='dense1')
n = DropoutLayer(n,
0.5,
is_fix=True,
is_train=is_train,
name='drop3')
n = DenseLayer(n, n_action, tf.nn.tanh, name='o')
if is_train:
self.n_train = n
else:
self.n_test = n
def my_net(net_in,y_,reuse,is_train):
x1 = tf.image.central_crop(net_in, 0.5)
x2 = net_in
# x2 = imresize(x2, (448, 448))
# x2 = tf.cast(net_in, tf.uint8)
# x2 = tf.reshape(x2,[448,448,3])
# x2 = tf.cast(x2, tf.float32)
network1 = Model_base.partnetwork(x1)
network2 = Model_base.partnetwork(x2)
network = tf.add(network1,network2,name='Eltwise3')
"""fc_layer"""
network = FlattenLayer(network,name='flatten')
network = DenseLayer(network,n_units=4096,act=tf.nn.relu,name='fc1_relu')
network = DenseLayer(network, n_units=4096, act=tf.nn.relu, name='fc2_relu')
network = DenseLayer(network, n_units=5, act=tf.identity, name='fc3_relu')
# network.partnet1=network1
# network.partnet2=network2
# network.all_layers=list(network.all_layers)+list(network.partnet1.all_layers)
y=network.outputs
ce=tl.cost.cross_entropy(y,y_,name='cost')
L2=0
for p in tl.layers.get_variables_with_name('relu/W',True,True):
L2+=Model_base.l2_regularizer(0.004)(p)
cost=ce+L2
correct=tf.equal(tf.cast(tf.arg_max(y,1),tf.int32),y_)
acc=tf.reduce_mean(tf.cast(correct,tf.float32))
return network,cost,acc
def SRGAN_d(input_images, is_train=True, reuse=False):
'''
Build the discriminator
'''
w_init = tf.random_normal_initializer(stddev=0.02)
b_init = tf.constant_initializer(value=0.0)
gamma_init = tf.random_normal_initializer(1., 0.02)
df_dim = 64
lrelu = lambda x: tl.act.lrelu(x, 0.2)
with tf.variable_scope("SRGAN_d", reuse=reuse):
tl.layers.set_name_reuse(reuse)
net_in = InputLayer(input_images, name='input/images')
net_h0 = Conv2d(net_in,
df_dim, (4, 4), (2, 2),
act=lrelu,
padding='SAME',
W_init=w_init,
name='h0/c')
net_h1 = Conv2d(net_h0,
df_dim * 2, (4, 4), (2, 2),
act=None,
padding='SAME',
W_init=w_init,
b_init=b_init,
name='h1/c')
net_h1 = BatchNormLayer(net_h1,
act=lrelu,
is_train=is_train,
gamma_init=gamma_init,
name='h1/bn')
net_h2 = Conv2d(net_h1,
df_dim * 4, (4, 4), (2, 2),
act=None,
padding='SAME',
W_init=w_init,
b_init=b_init,
name='h2/c')
net_h2 = BatchNormLayer(net_h2,
act=lrelu,
is_train=is_train,
gamma_init=gamma_init,
name='h2/bn')
net_h3 = Conv2d(net_h2,
df_dim * 8, (4, 4), (2, 2),
act=None,
padding='SAME',
W_init=w_init,
b_init=b_init,
name='h3/c')
net_h3 = BatchNormLayer(net_h3,
act=lrelu,
is_train=is_train,
gamma_init=gamma_init,
name='h3/bn')
net_h4 = Conv2d(net_h3,
df_dim * 16, (4, 4), (2, 2),
act=None,
padding='SAME',
W_init=w_init,
b_init=b_init,
name='h4/c')
net_h4 = BatchNormLayer(net_h4,
act=lrelu,
is_train=is_train,
gamma_init=gamma_init,
name='h4/bn')
net_h5 = Conv2d(net_h4,
df_dim * 32, (4, 4), (2, 2),
act=None,
padding='SAME',
W_init=w_init,
b_init=b_init,
name='h5/c')
net_h5 = BatchNormLayer(net_h5,
act=lrelu,
is_train=is_train,
gamma_init=gamma_init,
name='h5/bn')
net_h6 = Conv2d(net_h5,
df_dim * 16, (1, 1), (1, 1),
act=None,
padding='SAME',
W_init=w_init,
b_init=b_init,
name='h6/c')
net_h6 = BatchNormLayer(net_h6,
act=lrelu,
is_train=is_train,
gamma_init=gamma_init,
name='h6/bn')
net_h7 = Conv2d(net_h6,
df_dim * 8, (1, 1), (1, 1),
act=None,
padding='SAME',
W_init=w_init,
b_init=b_init,
name='h7/c')
net_h7 = BatchNormLayer(net_h7,
is_train=is_train,
gamma_init=gamma_init,
name='h7/bn')
net = Conv2d(net_h7,
df_dim * 2, (1, 1), (1, 1),
act=None,
padding='SAME',
W_init=w_init,
b_init=b_init,
name='res/c')
net = BatchNormLayer(net,
act=lrelu,
is_train=is_train,
gamma_init=gamma_init,
name='res/bn')
net = Conv2d(net,
df_dim * 2, (3, 3), (1, 1),
act=None,
padding='SAME',
W_init=w_init,
b_init=b_init,
name='res/c2')
net = BatchNormLayer(net,
act=lrelu,
is_train=is_train,
gamma_init=gamma_init,
name='res/bn2')
net = Conv2d(net,
df_dim * 8, (3, 3), (1, 1),
act=None,
padding='SAME',
W_init=w_init,
b_init=b_init,
name='res/c3')
net = BatchNormLayer(net,
is_train=is_train,
gamma_init=gamma_init,
name='res/bn3')
net_h8 = ElementwiseLayer([net_h7, net],
combine_fn=tf.add,
name='res/add')
net_h8.outputs = tl.act.lrelu(net_h8.outputs, 0.2)
net_ho = FlattenLayer(net_h8, name='ho/flatten')
net_ho = DenseLayer(net_ho,
n_units=1,
act=tf.identity,
W_init=w_init,
name='ho/dense')
logits = net_ho.outputs
net_ho.outputs = tf.nn.sigmoid(net_ho.outputs)
return net_ho, logits
def __get_network__(self,
encode_seq,
neighbour_seq,
decode_seq,
is_train=True,
reuse=False):
w_init = tf.random_normal_initializer(stddev=0.02)
g_init = tf.random_normal_initializer(1., 0.02)
with tf.variable_scope(self.model_name, reuse=reuse) as vs:
tl.layers.set_name_reuse(reuse)
inputs_x_root = InputLayer(encode_seq, name='in_root')
inputs_x_nbor = InputLayer(neighbour_seq, name="in_neighbour")
# encoding neighbour graph information
n = ReshapeLayer(inputs_x_nbor,
(config.batch_size * config.in_seq_length,
config.num_neighbour), "reshape1")
n.outputs = tf.expand_dims(n.outputs, axis=-1)
n = Conv1d(n,
4,
4,
1,
act=tf.identity,
padding='SAME',
W_init=w_init,
name='conv1')
n = BatchNormLayer(n,
act=tf.nn.relu,
is_train=is_train,
gamma_init=g_init,
name='bn1')
n = MaxPool1d(n, 2, 2, padding='valid', name='maxpool1')
n = FlattenLayer(n, name="flatten1")
n = ReshapeLayer(n, (config.batch_size, config.in_seq_length, -1),
name="reshape1_back")
net_encode = ConcatLayer([inputs_x_root, n],
concat_dim=-1,
name="encode")
net_decode = InputLayer(decode_seq, name="decode")
net_rnn = Seq2Seq(
net_encode,
net_decode,
cell_fn=tf.contrib.rnn.BasicLSTMCell,
n_hidden=config.dim_hidden,
initializer=tf.random_uniform_initializer(-0.1, 0.1),
encode_sequence_length=tl.layers.retrieve_seq_length_op(
net_encode.outputs),
decode_sequence_length=tl.layers.retrieve_seq_length_op(
net_decode.outputs),
initial_state_encode=None,
# dropout=(0.8 if is_train else None),
dropout=None,
n_layer=1,
return_seq_2d=True,
name='seq2seq')
# net_out = DenseLayer(net_rnn, n_units=64, act=tf.identity, name='dense1')
net_out = DenseLayer(net_rnn,
n_units=1,
act=tf.identity,
name='dense2')
if is_train:
net_out = ReshapeLayer(
net_out, (config.batch_size, config.out_seq_length + 1, 1),
name="reshape_out")
else:
net_out = ReshapeLayer(net_out, (config.batch_size, 1, 1),
name="reshape_out")
self.net_rnn = net_rnn
return net_out
def vgg_net_model_bn(x, y_correct, reuse, is_train):
""" Batch normalization should be placed before rectifier. """
w_init = tf.truncated_normal_initializer(stddev=5e-2)
w_init2 = tf.truncated_normal_initializer(stddev=0.04)
b_init2 = tf.constant_initializer(value=0.1)
with tf.variable_scope("vgg_net_model_fn", reuse=reuse):
input_layer = InputLayer(x, name="input")
# 卷积层组 1
conv_1_1 = Conv2d(input_layer,
64, (3, 3), (1, 1),
act=tf.nn.relu,
padding='SAME',
W_init=w_init,
name='conv_1_1')
conv_1_2 = Conv2d(conv_1_1,
64, (3, 3), (1, 1),
act=tf.nn.relu,
padding='SAME',
W_init=w_init,
name='conv_1_2')
bn_1 = BatchNormLayer(conv_1_2, is_train, act=tf.nn.relu, name='bn_1')
# 池化 1
pool_1 = MaxPool2d(bn_1, (3, 3), (2, 2), padding='SAME', name='lrn_1')
# 卷积层组 2
conv_2_1 = Conv2d(pool_1,
128, (3, 3), (1, 1),
act=tf.nn.relu,
padding='SAME',
W_init=w_init,
name='conv_2_1')
conv_2_2 = Conv2d(conv_2_1,
128, (3, 3), (1, 1),
act=tf.nn.relu,
padding='SAME',
W_init=w_init,
name='conv_2_2')
bn_2 = BatchNormLayer(conv_2_2, is_train, act=tf.nn.relu, name='bn_2')
# 池化 2
pool_2 = MaxPool2d(bn_2, (3, 3), (2, 2), padding='SAME', name='pool_2')
# 卷积层组 3
conv_3_1 = Conv2d(pool_2,
256, (3, 3), (1, 1),
act=tf.nn.relu,
padding='SAME',
W_init=w_init,
name='conv_3_1')
conv_3_2 = Conv2d(conv_3_1,
256, (3, 3), (1, 1),
act=tf.nn.relu,
padding='SAME',
W_init=w_init,
name='conv_3_2')
conv_3_3 = Conv2d(conv_3_2,
256, (3, 3), (1, 1),
act=tf.nn.relu,
padding='SAME',
W_init=w_init,
name='conv_3_3')
bn_3 = BatchNormLayer(conv_3_3, is_train, act=tf.nn.relu, name='bn_3')
# 池化 3
pool_3 = MaxPool2d(bn_3, (3, 3), (2, 2), padding='SAME', name='pool_3')
# 卷积层组 4
conv_4_1 = Conv2d(pool_3,
512, (3, 3), (1, 1),
act=tf.nn.relu,
padding='SAME',
W_init=w_init,
name='conv_4_1')
conv_4_2 = Conv2d(conv_4_1,
512, (3, 3), (1, 1),
act=tf.nn.relu,
padding='SAME',
W_init=w_init,
name='conv_4_2')
conv_4_3 = Conv2d(conv_4_2,
512, (3, 3), (1, 1),
act=tf.nn.relu,
padding='SAME',
W_init=w_init,
name='conv_4_3')
bn_4 = BatchNormLayer(conv_4_3, is_train, act=tf.nn.relu, name='bn_4')
# 池化 4
pool_4 = MaxPool2d(bn_4, (3, 3), (2, 2), padding='SAME', name='pool_4')
# 卷积层组 4
conv_5_1 = Conv2d(pool_4,
512, (3, 3), (1, 1),
act=tf.nn.relu,
padding='SAME',
W_init=w_init,
name='conv_5_1')
conv_5_2 = Conv2d(conv_5_1,
512, (3, 3), (1, 1),
act=tf.nn.relu,
padding='SAME',
W_init=w_init,
name='conv_5_2')
conv_5_3 = Conv2d(conv_5_2,
512, (3, 3), (1, 1),
act=tf.nn.relu,
padding='SAME',
W_init=w_init,
name='conv_5_3')
bn_5 = BatchNormLayer(conv_5_3, is_train, act=tf.nn.relu, name='bn_5')
# 池化 5
pool_5 = MaxPool2d(bn_5, (3, 3), (2, 2), padding='SAME', name='pool_5')
# 全连接层
flatten_layer = FlattenLayer(pool_5, name='flatten')
fc1 = DenseLayer(flatten_layer,
4096,
act=tf.nn.relu,
W_init=w_init2,
b_init=b_init2,
name='fc1')
fc2 = DenseLayer(fc1,
4096,
act=tf.nn.relu,
W_init=w_init2,
b_init=b_init2,
name='fc2')
fc3 = DenseLayer(fc2,
1000,
act=tf.nn.relu,
W_init=w_init2,
b_init=b_init2,
name='fc3')
model = DenseLayer(fc3,
CLASSES_NUM,
act=None,
W_init=w_init2,
name='output')
y_pred = model.outputs
ce = tl.cost.cross_entropy(y_pred, y_correct, name='_cost')
# l2 for the MLP, without this, the ACCURACY will be reduced by 15%.
l2 = 0
for p in tl.layers.get_variables_with_name('relu/W', True, True):
l2 += tf.contrib.layers.l2_regularizer(0.004)(p)
cost = ce + l2
correct_prediction = tf.equal(tf.argmax(y_pred, 1), y_correct)
accurary = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
return model, cost, accurary
def __get_network__(self,
encode_seq,
neighbour_seq,
decode_seq,
features,
features_full,
is_train=True,
reuse=False):
w_init = tf.random_normal_initializer(stddev=0.02)
g_init = tf.random_normal_initializer(1., 0.02)
with tf.variable_scope(self.model_name + "_spatial",
reuse=reuse) as vs:
tl.layers.set_name_reuse(reuse)
inputs_x_root = InputLayer(encode_seq, name='in_root')
inputs_x_nbor = InputLayer(neighbour_seq, name="in_neighbour")
# encoding neighbour graph information
n = ReshapeLayer(inputs_x_nbor,
(config.batch_size * config.in_seq_length,
config.num_neighbour), "reshape1")
n.outputs = tf.expand_dims(n.outputs, axis=-1)
n = Conv1d(n,
4,
4,
1,
act=tf.identity,
padding='SAME',
W_init=w_init,
name='conv1')
n = BatchNormLayer(n,
act=tf.nn.relu,
is_train=is_train,
gamma_init=g_init,
name='bn1')
n = MaxPool1d(n, 2, 2, padding='valid', name='maxpool1')
n = FlattenLayer(n, name="flatten1")
n = ReshapeLayer(n, (config.batch_size, config.in_seq_length, -1),
name="reshape1_back")
net_encode = ConcatLayer([inputs_x_root, n],
concat_dim=-1,
name="encode")
net_decode = InputLayer(decode_seq, name="decode")
net_rnn = Seq2Seq(
net_encode,
net_decode,
cell_fn=tf.contrib.rnn.BasicLSTMCell,
n_hidden=config.dim_hidden,
initializer=tf.random_uniform_initializer(-0.1, 0.1),
encode_sequence_length=tl.layers.retrieve_seq_length_op(
net_encode.outputs),
decode_sequence_length=tl.layers.retrieve_seq_length_op(
net_decode.outputs),
initial_state_encode=None,
# dropout=(0.8 if is_train else None),
dropout=None,
n_layer=1,
return_seq_2d=True,
name='seq2seq')
net_rnn_seq2seq = net_rnn
net_spatial_out = DenseLayer(net_rnn,
n_units=1,
act=tf.identity,
name='dense2')
if is_train:
net_spatial_out = ReshapeLayer(
net_spatial_out,
(config.batch_size, config.out_seq_length + 1, 1),
name="reshape_out")
else:
net_spatial_out = ReshapeLayer(net_spatial_out,
(config.batch_size, 1, 1),
name="reshape_out")
with tf.variable_scope(self.model_name + "_wide", reuse=reuse) as vs:
tl.layers.set_name_reuse(reuse)
# Features
net_features = InputLayer(features, name="in_features")
net_features_full = InputLayer(features_full,
name="in_features_full")
net_features_full = ReshapeLayer(
net_features_full,
(config.batch_size *
(config.out_seq_length + 1), config.dim_features),
name="reshape_feature_full_1")
if is_train:
net_features = ReshapeLayer(
net_features,
(config.batch_size *
(config.out_seq_length + 1), config.dim_features),
name="reshape_feature_1")
else:
net_features = ReshapeLayer(net_features,
(config.batch_size *
(1), config.dim_features),
name="reshape_feature_1")
self.net_features_dim = 32
net_features = DenseLayer(net_features,
n_units=self.net_features_dim,
act=tf.nn.relu,
name='dense_features')
net_features_full = DenseLayer(net_features_full,
n_units=self.net_features_dim,
act=tf.nn.relu,
name='dense_features_full')
# self.net_features = net_features
net_wide_out = ConcatLayer([net_rnn_seq2seq, net_features],
concat_dim=-1,
name="concat_features")
net_wide_out = DenseLayer(net_wide_out,
n_units=1,
act=tf.identity,
name='dense2')
if is_train:
net_wide_out = ReshapeLayer(
net_wide_out,
(config.batch_size, config.out_seq_length + 1, 1),
name="reshape_out")
else:
net_wide_out = ReshapeLayer(net_wide_out,
(config.batch_size, 1, 1),
name="reshape_out")
with tf.variable_scope(self.model_name + "_query", reuse=reuse) as vs:
tl.layers.set_name_reuse(reuse)
net_decode_query = InputLayer(self.query_decode_seq,
name="decode_query")
net_rnn_query = RNNLayer(
net_decode_query,
cell_fn=tf.contrib.rnn.BasicLSTMCell,
cell_init_args={"forget_bias": 1.0},
n_hidden=config.query_dim_hidden,
initializer=tf.random_uniform_initializer(-0.1, 0.1),
n_steps=config.out_seq_length,
return_last=True,
# return_last=False,
# return_seq_2d=True,
name="rnn_query")
'''
net_rnn_query = DynamicRNNLayer(
net_decode_query,
cell_fn=tf.contrib.rnn.BasicLSTMCell,
cell_init_args={"forget_bias": 1.0},
# n_hidden=config.query_dim_hidden,
n_hidden=32,
initializer=tf.random_uniform_initializer(-0.1, 0.1),
return_last=True,
# dropout=0.8,
sequence_length=tl.layers.retrieve_seq_length_op(net_decode_query.outputs),
# return_last=False,
# return_seq_2d=True,
name="rnn_query_dynamic"
)
'''
net_rnn_query = ExpandDimsLayer(net_rnn_query,
axis=1,
name="rnn_query_expand")
net_rnn_query = TileLayer(net_rnn_query,
[1, config.out_seq_length, 1],
name="rnn_query_tile")
net_rnn_query = ReshapeLayer(
net_rnn_query, (config.batch_size * config.out_seq_length,
config.query_dim_hidden),
name="rnn_query_reshape")
# net_rnn_query = ReshapeLayer(net_rnn_query, (config.batch_size * config.out_seq_length, 32), name="rnn_query_reshape")
# self.net_rnn_query = net_rnn_query
net_traffic_state = InputLayer(self.traffic_state,
name="in_traffic_state")
'''
if is_train:
net_rnn_traffic = ReshapeLayer(net_rnn_seq2seq, (config.batch_size, config.out_seq_length + 1, config.dim_hidden), name="reshape_traffic_q1")
net_rnn_traffic.outputs = tf.slice(net_rnn_traffic.outputs, [0, 0, 0], [config.batch_size, config.out_seq_length, config.dim_hidden], name="slice_traffic_q")
net_rnn_traffic = ReshapeLayer(net_rnn_traffic, (config.batch_size * config.out_seq_length, config.dim_hidden), name="reshape_traffic_q2")
net_features_traffic = ReshapeLayer(net_features, (config.batch_size, config.out_seq_length + 1, self.net_features_dim), name="reshape_features_q1")
net_features_traffic.outputs = tf.slice(net_features_traffic.outputs, [0, 0, 0], [config.batch_size, config.out_seq_length, self.net_features_dim], name="slice_features_q")
net_features_traffic = ReshapeLayer(net_features_traffic, (config.batch_size * config.out_seq_length, self.net_features_dim), name="reshape_features_q2")
net_query_out = ConcatLayer([net_rnn_traffic, net_features_traffic, net_rnn_query], concat_dim=-1, name="concat_traffic_query1")
# net_query_out = ConcatLayer([net_rnn_traffic, net_rnn_query], concat_dim=-1, name="concat_traffic_query1")
else:
'''
net_features_traffic = ReshapeLayer(
net_features_full,
(config.batch_size, config.out_seq_length + 1,
self.net_features_dim),
name="reshape_features_q1")
net_features_traffic.outputs = tf.slice(
net_features_traffic.outputs, [0, 0, 0], [
config.batch_size, config.out_seq_length,
self.net_features_dim
],
name="slice_features_q")
net_features_traffic = ReshapeLayer(
net_features_traffic,
(config.batch_size * config.out_seq_length,
self.net_features_dim),
name="reshape_features_q2")
net_query_out = ConcatLayer(
[net_traffic_state, net_features_traffic, net_rnn_query],
concat_dim=-1,
name="concat_traffic_query1")
# net_rnn_traffic = ReshapeLayer(net_rnn_seq2seq, (config.batch_size, config.out_seq_length + 1, config.dim_hidden), name="reshape_traffic_q1")
# net_rnn_traffic.outputs = tf.slice(net_rnn_traffic.outputs, [0, 0, 0], [config.batch_size, config.out_seq_length, config.dim_hidden], name="slice_traffic_q")
# net_rnn_traffic = ReshapeLayer(net_rnn_traffic, (config.batch_size * config.out_seq_length, config.dim_hidden), name="reshape_traffic_q2")
# net_query_out = ConcatLayer([net_rnn_traffic, net_features_traffic, net_rnn_query], concat_dim=-1, name="concat_traffic_query1")
# net_out = DenseLayer(net_out, n_units=128, act=tf.nn.relu, name="dense_query1")
# net_out = DenseLayer(net_out, n_units=64, act=tf.nn.relu, name="dense_query2")
# net_query_out = DropoutLayer(net_query_out, keep=0.8, is_fix=True, is_train=is_train, name='drop_query3')
net_query_out = DenseLayer(net_query_out,
n_units=1,
act=tf.identity,
name="dense_query3")
# net_out = ReshapeLayer(net_out, (config.batch_size, config.out_seq_length + 1, 1), name="reshape_out")
# if is_train:
net_query_out = ReshapeLayer(
net_query_out, (config.batch_size, config.out_seq_length, 1),
name="reshape_out")
# else:
# net_out = ReshapeLayer(net_out, (config.batch_size, 1, 1), name="reshape_out")
# TODO residual net
'''
if is_train:
net_query_out.outputs = tf.add(
net_query_out.outputs,
tf.slice(net_wide_out.outputs, [0, 0, 0], [config.batch_size, config.out_seq_length, 1]),
name="res_add"
)
else:
'''
net_base_pred = InputLayer(self.base_pred, name="in_net_base_pred")
net_query_out.outputs = tf.add(net_query_out.outputs,
net_base_pred.outputs,
name="res_add")
return net_rnn_seq2seq, net_spatial_out, net_wide_out, net_rnn_query, net_query_out
def vgg19_simple_api(net_in, end_with):
with tf.name_scope('preprocess'):
# Notice that we include a preprocessing layer that takes the RGB image
# with pixels values in the range of 0-255 and subtracts the mean image
# values (calculated over the entire ImageNet training set).
# Rescale the input tensor with pixels values in the range of 0-255
net_in.outputs = net_in.outputs * 255.0
mean = tf.constant([103.939, 116.779, 123.68],
dtype=tf.float32,
shape=[1, 1, 1, 3],
name='img_mean')
net_in.outputs = net_in.outputs - mean
layers = [
# conv1
lambda net: Conv2d(net_in,
n_filter=64,
filter_size=(3, 3),
strides=(1, 1),
act=tf.nn.relu,
padding='SAME',
name='conv1_1'),
lambda net: Conv2d(net,
n_filter=64,
filter_size=(3, 3),
strides=(1, 1),
act=tf.nn.relu,
padding='SAME',
name='conv1_2'),
lambda net: MaxPool2d(net,
filter_size=(2, 2),
strides=(2, 2),
padding='SAME',
name='pool1'),
# conv2
lambda net: Conv2d(net,
n_filter=128,
filter_size=(3, 3),
strides=(1, 1),
act=tf.nn.relu,
padding='SAME',
name='conv2_1'),
lambda net: Conv2d(net,
n_filter=128,
filter_size=(3, 3),
strides=(1, 1),
act=tf.nn.relu,
padding='SAME',
name='conv2_2'),
lambda net: MaxPool2d(net,
filter_size=(2, 2),
strides=(2, 2),
padding='SAME',
name='pool2'),
# conv3
lambda net: Conv2d(net,
n_filter=256,
filter_size=(3, 3),
strides=(1, 1),
act=tf.nn.relu,
padding='SAME',
name='conv3_1'),
lambda net: Conv2d(net,
n_filter=256,
filter_size=(3, 3),
strides=(1, 1),
act=tf.nn.relu,
padding='SAME',
name='conv3_2'),
lambda net: Conv2d(net,
n_filter=256,
filter_size=(3, 3),
strides=(1, 1),
act=tf.nn.relu,
padding='SAME',
name='conv3_3'),
lambda net: Conv2d(net,
n_filter=256,
filter_size=(3, 3),
strides=(1, 1),
act=tf.nn.relu,
padding='SAME',
name='conv3_4'),
lambda net: MaxPool2d(net,
filter_size=(2, 2),
strides=(2, 2),
padding='SAME',
name='pool3'),
# conv4
lambda net: Conv2d(net,
n_filter=512,
filter_size=(3, 3),
strides=(1, 1),
act=tf.nn.relu,
padding='SAME',
name='conv4_1'),
lambda net: Conv2d(net,
n_filter=512,
filter_size=(3, 3),
strides=(1, 1),
act=tf.nn.relu,
padding='SAME',
name='conv4_2'),
lambda net: Conv2d(net,
n_filter=512,
filter_size=(3, 3),
strides=(1, 1),
act=tf.nn.relu,
padding='SAME',
name='conv4_3'),
lambda net: Conv2d(net,
n_filter=512,
filter_size=(3, 3),
strides=(1, 1),
act=tf.nn.relu,
padding='SAME',
name='conv4_4'),
lambda net: MaxPool2d(net,
filter_size=(2, 2),
strides=(2, 2),
padding='SAME',
name='pool4'),
# conv5
lambda net: Conv2d(net,
n_filter=512,
filter_size=(3, 3),
strides=(1, 1),
act=tf.nn.relu,
padding='SAME',
name='conv5_1'),
lambda net: Conv2d(net,
n_filter=512,
filter_size=(3, 3),
strides=(1, 1),
act=tf.nn.relu,
padding='SAME',
name='conv5_2'),
lambda net: Conv2d(net,
n_filter=512,
filter_size=(3, 3),
strides=(1, 1),
act=tf.nn.relu,
padding='SAME',
name='conv5_3'),
lambda net: Conv2d(net,
n_filter=512,
filter_size=(3, 3),
strides=(1, 1),
act=tf.nn.relu,
padding='SAME',
name='conv5_4'),
lambda net: MaxPool2d(net,
filter_size=(2, 2),
strides=(2, 2),
padding='SAME',
name='pool5'),
lambda net: FlattenLayer(net, name='flatten'),
lambda net: DenseLayer(
net, n_units=4096, act=tf.nn.relu, name='fc1_relu'),
lambda net: DenseLayer(
net, n_units=4096, act=tf.nn.relu, name='fc2_relu'),
lambda net: DenseLayer(
net, n_units=1000, act=tf.identity, name='fc3_relu'),
]
net = net_in
for l in layers:
net = l(net)
# if end_with in net.name:
if net.name.endswith(end_with):
return net
raise Exception("unknown layer name (end_with): {}".format(end_with))
def discriminator(input_placeholder,
train_mode,
reuse=False,
classes_num=10,
return_previous=False):
filters_num = 64
w_init = tf.random_normal_initializer(stddev=0.02)
gamma_init = tf.random_normal_initializer(1., 0.02)
def conv(in_layer, filt_num, name, stride=1):
return Conv2d(in_layer,
n_filter=filt_num,
filter_size=(3, 3),
strides=(stride, stride),
act=None,
padding='SAME',
name=name,
W_init=w_init)
def bn(in_layer, name):
return BatchNormLayer(in_layer,
act=lambda x: tl.act.lrelu(x, 0.2),
is_train=train_mode,
gamma_init=gamma_init,
name=name)
with tf.variable_scope("discriminator", reuse=reuse):
tl.layers.set_name_reuse(reuse)
input_layer = InputLayer(input_placeholder, name="discr/in")
conv1_layer = bn(conv(input_layer, filters_num, 'discr/conv1'),
'discr/bn1')
conv2_layer = bn(conv(conv1_layer, filters_num, 'discr/conv2'),
'discr/bn2')
conv3_layer = bn(conv(conv2_layer, filters_num, 'discr/conv3', 2),
'discr/bn3')
conv4_layer = bn(conv(conv3_layer, filters_num * 3, 'discr/conv4'),
'discr/bn4')
conv5_layer = bn(conv(conv4_layer, filters_num * 3, 'discr/conv5'),
'discr/bn5')
conv6_layer = bn(conv(conv5_layer, filters_num * 3, 'discr/conv6', 2),
'discr/bn6')
conv7_layer = bn(conv(conv6_layer, filters_num * 3, 'discr/conv7'),
'discr/bn7')
flat_layer = FlattenLayer(conv7_layer, name='discr/flatten')
out_layer = DenseLayer(flat_layer,
n_units=classes_num,
act=tf.identity,
name='discr/out')
logits = out_layer.outputs
out_layer.outputs = tf.nn.softmax(logits)
if not return_previous:
return out_layer, logits
else:
return out_layer, logits, [
flat_layer, conv7_layer, conv6_layer, conv5_layer, conv4_layer,
conv3_layer, conv2_layer, conv1_layer
]
def encoder(input_placeholder,
z_dim,
train_mode,
conv_filters_num=32,
reuse=False):
w_init = tf.random_normal_initializer(stddev=0.02)
gamma_init = tf.random_normal_initializer(1., 0.02)
with tf.variable_scope("encoder", reuse=reuse):
tl.layers.set_name_reuse(reuse)
input_layer = InputLayer(input_placeholder, name='enc/input')
conv1_layer = Conv2d(input_layer,
n_filter=conv_filters_num,
filter_size=(4, 4),
strides=(2, 2),
act=None,
padding='SAME',
name='enc/conv1')
bn1_layer = BatchNormLayer(conv1_layer,
act=lambda x: tl.act.lrelu(x, 0.02),
is_train=train_mode,
gamma_init=gamma_init,
name='enc/bn1')
conv2_layer = Conv2d(bn1_layer,
n_filter=2 * conv_filters_num,
filter_size=(4, 4),
strides=(2, 2),
act=None,
padding='SAME',
name='enc/conv2')
bn2_layer = BatchNormLayer(conv2_layer,
act=lambda x: tl.act.lrelu(x, 0.02),
is_train=train_mode,
gamma_init=gamma_init,
name='enc/bn2')
conv3_layer = Conv2d(bn2_layer,
n_filter=4 * conv_filters_num,
filter_size=(4, 4),
strides=(2, 2),
act=None,
padding='SAME',
name='enc/conv3')
bn3_layer = BatchNormLayer(conv3_layer,
act=lambda x: tl.act.lrelu(x, 0.02),
is_train=train_mode,
gamma_init=gamma_init,
name='enc/bn3')
# mean of Z
mean_flat_layer = FlattenLayer(bn3_layer, name='enc/mean_flatten')
mean_out = DenseLayer(mean_flat_layer,
n_units=z_dim,
act=tf.identity,
W_init=w_init,
name='enc/mean_out_lin')
mean_out = BatchNormLayer(mean_out,
act=tf.identity,
is_train=train_mode,
gamma_init=gamma_init,
name='enc/mean_out')
# covariance of Z
cov_flat_layer = FlattenLayer(bn3_layer, name='enc/cov_flatten')
cov_out = DenseLayer(cov_flat_layer,
n_units=z_dim,
act=tf.identity,
W_init=w_init,
name='enc/cov_out_lin')
cov_out = BatchNormLayer(cov_out,
act=tf.identity,
is_train=train_mode,
gamma_init=gamma_init,
name='enc/cov_out')
z_mean, z_cov = mean_out.outputs, cov_out.outputs + 1e-6
return mean_out, cov_out, z_mean, z_cov
def fc_layers(net):
net = FlattenLayer(net, name='flatten')
net = DenseLayer(net, n_units=4096, act=tf.nn.relu, name='fc1_relu')
net = DenseLayer(net, n_units=4096, act=tf.nn.relu, name='fc2_relu')
net = DenseLayer(net, n_units=1000, name='fc3_relu')
return net
def vgg19_simple_api(rgb, reuse):
"""
Build the VGG 19 Model
Parameters
-----------
:param rgb:
rgb image placeholder [batch, height, width, 3] values scaled [0, 1]
:param reuse:
whether to reuse the vgg network
"""
VGG_MEAN = [103.939, 116.779, 123.68]
with tf.variable_scope("VGG19", reuse=reuse) as vs:
start_time = time.time()
logger.info("build vgg model started")
rgb_scaled = rgb * 255.0
# Convert RGB to BGR
if tf.__version__ <= '0.11':
red, green, blue = tf.split(3, 3, rgb_scaled)
else: # TF 1.0
# print(rgb_scaled)
red, green, blue = tf.split(rgb_scaled, 3, 3)
assert red.get_shape().as_list()[1:] == [224, 224, 1]
assert green.get_shape().as_list()[1:] == [224, 224, 1]
assert blue.get_shape().as_list()[1:] == [224, 224, 1]
if tf.__version__ <= '0.11':
bgr = tf.concat(3, [
blue - VGG_MEAN[0],
green - VGG_MEAN[1],
red - VGG_MEAN[2],
])
else:
bgr = tf.concat([
blue - VGG_MEAN[0],
green - VGG_MEAN[1],
red - VGG_MEAN[2],
],
axis=3)
assert bgr.get_shape().as_list()[1:] == [224, 224, 3]
""" input layer """
net_in = InputLayer(bgr, name='input')
""" conv1 """
network = Conv2d(net_in,
n_filter=64,
filter_size=(3, 3),
strides=(1, 1),
act=tf.nn.relu,
padding='SAME',
name='conv1_1')
network = Conv2d(network,
n_filter=64,
filter_size=(3, 3),
strides=(1, 1),
act=tf.nn.relu,
padding='SAME',
name='conv1_2')
network = MaxPool2d(network,
filter_size=(2, 2),
strides=(2, 2),
padding='SAME',
name='pool1')
""" conv2 """
network = Conv2d(network,
n_filter=128,
filter_size=(3, 3),
strides=(1, 1),
act=tf.nn.relu,
padding='SAME',
name='conv2_1')
network = Conv2d(network,
n_filter=128,
filter_size=(3, 3),
strides=(1, 1),
act=tf.nn.relu,
padding='SAME',
name='conv2_2')
network = MaxPool2d(network,
filter_size=(2, 2),
strides=(2, 2),
padding='SAME',
name='pool2')
""" conv3 """
network = Conv2d(network,
n_filter=256,
filter_size=(3, 3),
strides=(1, 1),
act=tf.nn.relu,
padding='SAME',
name='conv3_1')
network = Conv2d(network,
n_filter=256,
filter_size=(3, 3),
strides=(1, 1),
act=tf.nn.relu,
padding='SAME',
name='conv3_2')
network = Conv2d(network,
n_filter=256,
filter_size=(3, 3),
strides=(1, 1),
act=tf.nn.relu,
padding='SAME',
name='conv3_3')
network = Conv2d(network,
n_filter=256,
filter_size=(3, 3),
strides=(1, 1),
act=tf.nn.relu,
padding='SAME',
name='conv3_4')
network = MaxPool2d(network,
filter_size=(2, 2),
strides=(2, 2),
padding='SAME',
name='pool3')
""" conv4 """
network = Conv2d(network,
n_filter=512,
filter_size=(3, 3),
strides=(1, 1),
act=tf.nn.relu,
padding='SAME',
name='conv4_1')
network = Conv2d(network,
n_filter=512,
filter_size=(3, 3),
strides=(1, 1),
act=tf.nn.relu,
padding='SAME',
name='conv4_2')
network = Conv2d(network,
n_filter=512,
filter_size=(3, 3),
strides=(1, 1),
act=tf.nn.relu,
padding='SAME',
name='conv4_3')
network = Conv2d(network,
n_filter=512,
filter_size=(3, 3),
strides=(1, 1),
act=tf.nn.relu,
padding='SAME',
name='conv4_4')
conv4_4 = network
network = MaxPool2d(network,
filter_size=(2, 2),
strides=(2, 2),
padding='SAME',
name='pool4') # (batch_size, 14, 14, 512)
""" conv5 """
network = Conv2d(network,
n_filter=512,
filter_size=(3, 3),
strides=(1, 1),
act=tf.nn.relu,
padding='SAME',
name='conv5_1')
network = Conv2d(network,
n_filter=512,
filter_size=(3, 3),
strides=(1, 1),
act=tf.nn.relu,
padding='SAME',
name='conv5_2')
network = Conv2d(network,
n_filter=512,
filter_size=(3, 3),
strides=(1, 1),
act=tf.nn.relu,
padding='SAME',
name='conv5_3')
network = Conv2d(network,
n_filter=512,
filter_size=(3, 3),
strides=(1, 1),
act=tf.nn.relu,
padding='SAME',
name='conv5_4')
network = MaxPool2d(network,
filter_size=(2, 2),
strides=(2, 2),
padding='SAME',
name='pool5') # (batch_size, 7, 7, 512)
""" fc 6~8 """
network = FlattenLayer(network, name='flatten')
network = DenseLayer(network, n_units=4096, act=tf.nn.relu, name='fc6')
network = DenseLayer(network, n_units=4096, act=tf.nn.relu, name='fc7')
# discriminator, swap the sigmoid activation function with the linear activation
network = DenseLayer(network,
n_units=1000,
act=tf.identity,
name='fc8')
logger.info("build vgg model finished: %fs" %
(time.time() - start_time))
return network, conv4_4
def discriminator(input, is_train=False, reuse=False):
"""
Cartoon GAN discriminator neural network
:param input: TF Tensor
input tensor
:param is_train: boolean
train or test flag
:param reuse: boolean
whether to reuse the discriminator neural network
:return:
"""
w_init = tf.random_normal_initializer(stddev=0.02)
gamma_init = tf.random_normal_initializer(1.0, stddev=0.02)
leaky_relu = lambda x: tl.act.lrelu(x, 0.2)
with tf.variable_scope('CartoonGAN_D', reuse=reuse):
tl.layers.set_name_reuse(reuse)
n = InputLayer(input, name='d_input')
n = Conv2d(n,
32, (3, 3), (1, 1),
act=leaky_relu,
padding='SAME',
W_init=w_init,
name='block1/c')
n = Conv2d(n,
64, (3, 3), (2, 2),
act=leaky_relu,
padding='SAME',
W_init=w_init,
name='block2/c1')
n = Conv2d(n,
128, (3, 3), (1, 1),
act=None,
padding='SAME',
W_init=w_init,
name='block2/c2')
n = BatchNormLayer(n,
act=leaky_relu,
is_train=is_train,
gamma_init=gamma_init,
name='block2/b')
n = Conv2d(n,
128, (3, 3), (2, 2),
act=leaky_relu,
padding='SAME',
W_init=w_init,
name='block3/c1')
n = Conv2d(n,
256, (3, 3), (1, 1),
act=None,
padding='SAME',
W_init=w_init,
name='block3/c2')
n = BatchNormLayer(n,
act=leaky_relu,
is_train=is_train,
gamma_init=gamma_init,
name='block3/b')
n = Conv2d(n,
256, (3, 3), (1, 1),
act=None,
padding='SAME',
W_init=w_init,
name='block4/c')
n = BatchNormLayer(n,
act=leaky_relu,
is_train=is_train,
gamma_init=gamma_init,
name='block4/b')
n = Conv2d(n,
1, (3, 3), (1, 1),
act=None,
padding='SAME',
W_init=w_init,
name='d_output')
n = FlattenLayer(n)
n = DenseLayer(n, n_units=1, name='d_output')
logits = n.outputs
n.outputs = tf.nn.sigmoid(n.outputs)
return n, logits, n.outputs
def discriminator(input_placeholder, train_mode, reuse=False):
filters_num = 64
w_init = tf.random_normal_initializer(stddev=0.02)
gamma_init = tf.random_normal_initializer(1., 0.02)
with tf.variable_scope("discriminator", reuse=reuse):
tl.layers.set_name_reuse(reuse)
input_layer = InputLayer(input_placeholder, name="discr/in")
conv1_layer = Conv2d(input_layer,
n_filter=filters_num,
filter_size=(5, 5),
strides=(2, 2),
act=lambda x: tl.act.lrelu(x, 0.2),
padding='SAME',
name='discr/conv1',
W_init=w_init)
conv2_layer = Conv2d(conv1_layer,
n_filter=filters_num * 2,
filter_size=(5, 5),
strides=(2, 2),
act=None,
padding='SAME',
name='discr/conv2',
W_init=w_init)
bn2_layer = BatchNormLayer(conv2_layer,
act=lambda x: tl.act.lrelu(x, 0.2),
is_train=train_mode,
gamma_init=gamma_init,
name='discr/bn2')
conv3_layer = Conv2d(bn2_layer,
n_filter=filters_num * 4,
filter_size=(5, 5),
strides=(2, 2),
act=None,
padding='SAME',
name='discr/conv3',
W_init=w_init)
bn3_layer = BatchNormLayer(conv3_layer,
act=lambda x: tl.act.lrelu(x, 0.2),
is_train=train_mode,
gamma_init=gamma_init,
name='discr/bn3')
conv4_layer = Conv2d(bn3_layer,
n_filter=filters_num * 8,
filter_size=(5, 5),
strides=(2, 2),
act=None,
padding='SAME',
name='discr/conv4',
W_init=w_init)
bn4_layer = BatchNormLayer(conv4_layer,
act=lambda x: tl.act.lrelu(x, 0.2),
is_train=train_mode,
gamma_init=gamma_init,
name='discr/bn4')
flat_layer = FlattenLayer(bn4_layer, name='discr/flatten')
out_layer = DenseLayer(flat_layer,
n_units=1,
W_init=w_init,
act=tf.identity,
name='discr/out')
logits = out_layer.outputs
out_layer.outputs = tf.nn.sigmoid(out_layer.outputs)
return out_layer, logits
def Vgg19_simple_api(rgb, reuse):
'''
Build the VGG19 model
'''
VGG_MEAN = [103.939, 116.779, 123.68]
with tf.variable_scope("VGG19", reuse=reuse) as vs:
rgb_scaled = rgb * 255.0
# Convert RGB to BGR
red, green, blue = tf.split(rgb_scaled, 3, 3)
bgr = tf.concat([
blue - VGG_MEAN[0],
green - VGG_MEAN[1],
red - VGG_MEAN[2],
],
axis=3)
''' input layer '''
net_in = InputLayer(bgr, name='input')
''' conv1 '''
network = Conv2d(net_in,
n_filter=64,
filter_size=(3, 3),
strides=(1, 1),
act=tf.nn.relu,
padding='SAME',
name='conv1_1')
network = Conv2d(network,
n_filter=64,
filter_size=(3, 3),
strides=(1, 1),
act=tf.nn.relu,
padding='SAME',
name='conv1_2')
network = MaxPool2d(network,
filter_size=(2, 2),
strides=(2, 2),
padding='SAME',
name='pool1')
''' conv2 '''
network = Conv2d(network,
n_filter=128,
filter_size=(3, 3),
strides=(1, 1),
act=tf.nn.relu,
padding='SAME',
name='conv2_1')
network = Conv2d(network,
n_filter=128,
filter_size=(3, 3),
strides=(1, 1),
act=tf.nn.relu,
padding='SAME',
name='conv2_2')
network = MaxPool2d(network,
filter_size=(2, 2),
strides=(2, 2),
padding='SAME',
name='pool2')
''' conv3 '''
network = Conv2d(network,
n_filter=256,
filter_size=(3, 3),
strides=(1, 1),
act=tf.nn.relu,
padding='SAME',
name='conv3_1')
network = Conv2d(network,
n_filter=256,
filter_size=(3, 3),
strides=(1, 1),
act=tf.nn.relu,
padding='SAME',
name='conv3_2')
network = Conv2d(network,
n_filter=256,
filter_size=(3, 3),
strides=(1, 1),
act=tf.nn.relu,
padding='SAME',
name='conv3_3')
network = Conv2d(network,
n_filter=256,
filter_size=(3, 3),
strides=(1, 1),
act=tf.nn.relu,
padding='SAME',
name='conv3_4')
network = MaxPool2d(network,
filter_size=(2, 2),
strides=(2, 2),
padding='SAME',
name='pool3')
''' conv4 '''
network = Conv2d(network,
n_filter=512,
filter_size=(3, 3),
strides=(1, 1),
act=tf.nn.relu,
padding='SAME',
name='conv4_1')
network = Conv2d(network,
n_filter=512,
filter_size=(3, 3),
strides=(1, 1),
act=tf.nn.relu,
padding='SAME',
name='conv4_2')
network = Conv2d(network,
n_filter=512,
filter_size=(3, 3),
strides=(1, 1),
act=tf.nn.relu,
padding='SAME',
name='conv4_3')
network = Conv2d(network,
n_filter=512,
filter_size=(3, 3),
strides=(1, 1),
act=tf.nn.relu,
padding='SAME',
name='conv4_4')
network = MaxPool2d(network,
filter_size=(2, 2),
strides=(2, 2),
padding='SAME',
name='pool4') # (batch_size, 14, 14, 512)
conv = network
''' conv5 '''
network = Conv2d(network,
n_filter=512,
filter_size=(3, 3),
strides=(1, 1),
act=tf.nn.relu,
padding='SAME',
name='conv5_1')
network = Conv2d(network,
n_filter=512,
filter_size=(3, 3),
strides=(1, 1),
act=tf.nn.relu,
padding='SAME',
name='conv5_2')
network = Conv2d(network,
n_filter=512,
filter_size=(3, 3),
strides=(1, 1),
act=tf.nn.relu,
padding='SAME',
name='conv5_3')
network = Conv2d(network,
n_filter=512,
filter_size=(3, 3),
strides=(1, 1),
act=tf.nn.relu,
padding='SAME',
name='conv5_4')
network = MaxPool2d(network,
filter_size=(2, 2),
strides=(2, 2),
padding='SAME',
name='pool5') # (batch_size, 7, 7, 512)
''' fc6~8 '''
network = FlattenLayer(network, name='flatten')
network = DenseLayer(network, n_units=4096, act=tf.nn.relu, name='fc6')
network = DenseLayer(network, n_units=4096, act=tf.nn.relu, name='fc7')
network = DenseLayer(network,
n_units=1000,
act=tf.identity,
name='fc8')
return network, conv