def channel_shuffle(cls, x, num_groups, name='_shuffle'):
with tf.variable_scope(name):
n, h, w, c = x.outputs.get_shape()
x_reshaped = ReshapeLayer(x, (-1, h, w, num_groups, c // num_groups))# 先合并重组
x_transposed = TransposeLayer(x_reshaped, [0, 1, 2, 4, 3])# 转置
output = ReshapeLayer(x_transposed, (-1, h, w, c))# 摊平
return output
def __get_network__(self,
encode_seq,
decode_seq,
query_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)
net_encode_traffic = InputLayer(encode_seq, name='in_root_net')
net_encode_query = InputLayer(self.query_x, name="in_query_net")
net_encode = ConcatLayer([net_encode_traffic, net_encode_query],
concat_dim=-1,
name="encode")
net_decode_traffic = InputLayer(decode_seq, name="decode_root")
net_decode_query = InputLayer(query_decode_seq,
name="decode_query_net")
net_decode = ConcatLayer([net_decode_traffic, net_decode_query],
concat_dim=-1,
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 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 generator(inputs, is_train=True, reuse=False):
image_size = 128
gf_dim = 64 # Dimension of gen filters in first conv layer. [64]
c_dim = 1 # n_color 1
w_init = tf.glorot_normal_initializer()
gamma_init = tf.random_normal_initializer(1., 0.02)
with tf.name_scope("GENERATOR"):
with tf.variable_scope("generator", reuse=reuse):
with tf.name_scope("net_in"):
net_in = InputLayer(inputs, name='g/in')
#############################################################################
with tf.name_scope("layer0"):
net_h0 = DenseLayer(net_in, n_units=(gf_dim * 32 * 4 * 4), W_init=w_init,
act = tf.identity, name='g/h0/lin')
net_h0 = ReshapeLayer(net_h0, shape=[-1, 4, 4, gf_dim * 32], name='g/h0/reshape')
net_h0 = BatchNormLayer(net_h0, decay=0.9, act=tf.nn.relu, is_train=is_train,
gamma_init=gamma_init, name='g/h0/batch_norm')
with tf.name_scope("layer1"):
net_h1 = DeConv2d(net_h0, gf_dim * 8, (5, 5), strides=(2, 2),
padding='SAME', act=None, W_init=w_init, name='g/h1/decon2d')
net_h1 = BatchNormLayer(net_h1, decay=0.9, act=tf.nn.relu, is_train=is_train,
gamma_init=gamma_init, name='g/h1/batch_norm')
with tf.name_scope("layer2"):
net_h2 = DeConv2d(net_h1, gf_dim * 4, (5, 5), strides=(2, 2),
padding='SAME', act=None, W_init=w_init, name='g/h2/decon2d')
net_h2 = BatchNormLayer(net_h2, decay=0.9, act=tf.nn.relu, is_train=is_train,
gamma_init=gamma_init, name='g/h2/batch_norm')
with tf.name_scope("layer3"):
net_h3 = DeConv2d(net_h2, gf_dim*2, (5, 5), strides=(2, 2),
padding='SAME', act=None, W_init=w_init, name='g/h3/decon2d')
net_h3 = BatchNormLayer(net_h3, decay=0.9, act=tf.nn.relu, is_train=is_train,
gamma_init=gamma_init, name='g/h3/batch_norm')
with tf.name_scope("layer4"):
net_h4 = DeConv2d(net_h3, gf_dim, (5, 5), strides=(2, 2),
padding='SAME', act=None, W_init=w_init, name='g/h4/decon2d')
net_h4 = BatchNormLayer(net_h4, decay=0.9, act=tf.nn.relu, is_train=is_train,
gamma_init=gamma_init, name='g/h4/batch_norm')
with tf.name_scope("layer5"):
net_h5 = DeConv2d(net_h4, c_dim, (5, 5), strides=(2, 2),
padding='SAME', act=None, W_init=w_init, name='g/h5/decon2d')
#net_h5.outputs = tf.nn.tanh(net_h5.outputs)
net_h5.outputs = tf.nn.tanh(net_h5.outputs)
return net_h5
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 generator(self, z, label_class, is_train=True, reuse=False):
# NOTE: concate z & label might be wrong, need to test
labels_one_hot = tf.one_hot(label_class, self.class_num)
z_labels = tf.concat([z, labels_one_hot], 1)
image_size = self.images_size
s16 = image_size // 16
gf_dim = 64 # Dimension of gen filters in first conv layer. [64]
c_dim = self.channel # n_color 3
w_init = tf.glorot_normal_initializer()
gamma_init = tf.random_normal_initializer(1., 0.02)
with tf.variable_scope("generator", reuse=reuse):
net_in = InputLayer(z_labels, name='g/in')
net_h0 = DenseLayer(net_in, n_units=(gf_dim * 8 * s16 * s16), W_init=w_init,
act = tf.identity, name='g/h0/lin')
net_h0 = ReshapeLayer(net_h0, shape=[-1, s16, s16, gf_dim*8], name='g/h0/reshape')
net_h0 = BatchNormLayer(net_h0, decay=0.9, act=tf.nn.relu, is_train=is_train,
gamma_init=gamma_init, name='g/h0/batch_norm')
net_h1 = DeConv2d(net_h0, gf_dim * 4, (5, 5), strides=(2, 2),
padding='SAME', act=None, W_init=w_init, name='g/h1/decon2d')
net_h1 = BatchNormLayer(net_h1, decay=0.9, act=tf.nn.relu, is_train=is_train,
gamma_init=gamma_init, name='g/h1/batch_norm')
net_h2 = DeConv2d(net_h1, gf_dim * 2, (5, 5), strides=(2, 2),
padding='SAME', act=None, W_init=w_init, name='g/h2/decon2d')
net_h2 = BatchNormLayer(net_h2, decay=0.9, act=tf.nn.relu, is_train=is_train,
gamma_init=gamma_init, name='g/h2/batch_norm')
net_h3 = DeConv2d(net_h2, gf_dim, (5, 5), strides=(2, 2),
padding='SAME', act=None, W_init=w_init, name='g/h3/decon2d')
net_h3 = BatchNormLayer(net_h3, decay=0.9, act=tf.nn.relu, is_train=is_train,
gamma_init=gamma_init, name='g/h3/batch_norm')
net_h4 = DeConv2d(net_h3, c_dim, (5, 5), strides=(2, 2),
padding='SAME', act=None, W_init=w_init, name='g/h4/decon2d')
net_h4.outputs = tf.nn.tanh(net_h4.outputs)
return net_h4
def generator(input_placeholder, train_mode, image_size, reuse=False):
s2, s4, s8, s16 = int(image_size / 2), int(image_size / 4), int(
image_size / 8), int(image_size / 16)
gf_dim = 32
w_init = tf.random_normal_initializer(stddev=0.02)
gamma_init = tf.random_normal_initializer(1., 0.02)
with tf.variable_scope("decoder", reuse=reuse):
tl.layers.set_name_reuse(reuse)
input_layer = InputLayer(input_placeholder, name='dec/input')
lin_layer = DenseLayer(input_layer,
n_units=gf_dim * 8 * s16 * s16,
W_init=w_init,
act=tf.identity,
name='dec/lin')
# lin_layer.shape = (batch_size,256*4*4)
resh1_layer = ReshapeLayer(lin_layer,
shape=[-1, s16, s16, gf_dim * 8],
name='decoder/reshape')
# resh1_layer.shape = (batch_size, 4, 4, 256)
in_bn_layer = BatchNormLayer(resh1_layer,
act=lambda x: tl.act.lrelu(x, 0.2),
is_train=train_mode,
gamma_init=gamma_init,
name='dec/in_bn')
# upsampling
up1_layer = UpSampling2dLayer(in_bn_layer,
size=[s8, s8],
is_scale=False,
method=ResizeMethod.NEAREST_NEIGHBOR,
align_corners=False,
name='dec/up1')
conv1_layer = Conv2d(up1_layer,
gf_dim * 4, (3, 3), (1, 1),
padding='SAME',
W_init=w_init,
name='dec/conv1')
bn1_layer = BatchNormLayer(conv1_layer,
act=lambda x: tl.act.lrelu(x, 0.2),
is_train=train_mode,
gamma_init=gamma_init,
name='dec/bn1')
# bn1_layer.shape = (batch_size,8,8,128)
up2_layer = UpSampling2dLayer(bn1_layer,
size=[s4, s4],
is_scale=False,
method=ResizeMethod.NEAREST_NEIGHBOR,
align_corners=False,
name='dec/up2')
conv2_layer = Conv2d(up2_layer,
gf_dim * 2, (3, 3), (1, 1),
padding='SAME',
W_init=w_init,
name='dec/conv2')
bn2_layer = BatchNormLayer(conv2_layer,
act=lambda x: tl.act.lrelu(x, 0.2),
is_train=train_mode,
gamma_init=gamma_init,
name='dec/bn2')
# bn2_layer.shape = (batch_size,16,16,64)
up3_layer = UpSampling2dLayer(bn2_layer,
size=[s2, s2],
is_scale=False,
method=ResizeMethod.NEAREST_NEIGHBOR,
align_corners=False,
name='dec/up3')
conv3_layer = Conv2d(up3_layer,
gf_dim, (3, 3), (1, 1),
padding='SAME',
W_init=w_init,
name='dec/conv3')
bn3_layer = BatchNormLayer(conv3_layer,
act=lambda x: tl.act.lrelu(x, 0.2),
is_train=train_mode,
gamma_init=gamma_init,
name='dec/bn3_layer')
# bn3_layer.shape = (batch_size,32,32,32)
# no BN on last deconv
up4_layer = UpSampling2dLayer(bn3_layer,
size=[image_size, image_size],
is_scale=False,
method=ResizeMethod.NEAREST_NEIGHBOR,
align_corners=False,
name='dec/up4')
conv4_layer = Conv2d(up4_layer,
3, (3, 3), (1, 1),
padding='SAME',
W_init=w_init,
name='dec/conv4')
# conv4_layer.shape = (batch_size,64,64,3)
logits = conv4_layer.outputs
conv4_layer.outputs = tf.nn.tanh(conv4_layer.outputs)
return conv4_layer, logits
def generator(inputs, is_train=True):
with tf.variable_scope("generator", reuse=tf.AUTO_REUSE):
net_in = InputLayer(inputs, name='gin')
gnet_d0 = DenseLayer(net_in,
n_units=(16384),
act=tf.identity,
name='gnet_d0')
gnet_r0 = ReshapeLayer(gnet_d0, shape=[-1, 4, 4, 1024], name='gnet_r0')
gnet_b0 = BatchNormLayer(gnet_r0,
decay=0.9,
act=tf.nn.relu,
is_train=is_train,
name='gnet_b0')
gnet_dc1 = DeConv2d(gnet_b0,
256, (8, 8),
strides=(2, 2),
padding='SAME',
act=None,
name='gnet_dc1')
gnet_b1 = BatchNormLayer(gnet_dc1,
decay=0.9,
act=tf.nn.relu,
is_train=is_train,
name='gnet_b1')
gnet_dc2 = DeConv2d(gnet_b1,
128, (8, 8),
strides=(2, 2),
padding='SAME',
act=None,
name='gnet_dc2')
gnet_b2 = BatchNormLayer(gnet_dc2,
decay=0.9,
act=tf.nn.relu,
is_train=is_train,
name='gnet_b2')
gnet_dc3 = DeConv2d(gnet_b2,
64, (8, 8),
strides=(2, 2),
padding='SAME',
act=None,
name='gnet_dc3')
gnet_b3 = BatchNormLayer(gnet_dc3,
decay=0.9,
act=tf.nn.relu,
is_train=is_train,
name='gnet_b3')
gnet_dc4 = DeConv2d(gnet_b3,
3, (8, 8),
strides=(2, 2),
padding='SAME',
act=None,
name='net_h4')
#Based on the paper, we need to provide non-linearity to the generated image
#TODO: Why?
gnet_dc4.outputs = tf.nn.tanh(gnet_dc4.outputs)
return gnet_dc4
def __get_network__(self, model_name, encode_seqs, class_label_seqs, kg_vector, reuse=False, is_train=True):
with tf.variable_scope(model_name, reuse=reuse):
tl.layers.set_name_reuse(reuse)
net_word_embed = InputLayer(
inputs=encode_seqs,
name="in_word_embed"
)
net_class_label_embed = InputLayer(
inputs=class_label_seqs,
name="in_class_label_embed"
)
net_kg = InputLayer(
inputs=kg_vector,
name='in_kg'
)
net_kg = ReshapeLayer(
net_kg,
shape=(-1, self.kg_embedding_dim),
name="reshape_kg_1"
)
net_kg = ReshapeLayer(
net_kg,
shape=(-1, self.max_length, self.kg_embedding_dim),
name="reshape_kg_2"
)
if config.model == "vwvcvkg":
# dbpedia and 20news
net_in = ConcatLayer(
[net_word_embed, net_class_label_embed, net_kg],
concat_dim=-1,
name='concat_vw_vwc_vc'
)
elif config.model == "vwvc":
net_in = ConcatLayer(
[net_word_embed, net_class_label_embed],
concat_dim=-1,
name='concat_vw_vc'
)
elif config.model == "vwvkg":
net_in = ConcatLayer(
[net_word_embed, net_kg],
concat_dim=-1,
name='concat_vw_vwc'
)
elif config.model == "vcvkg":
net_in = ConcatLayer(
[net_class_label_embed, net_kg],
concat_dim=-1,
name='concat_vc_vwc'
)
elif config.model == "kgonly":
net_in = ConcatLayer(
[net_kg],
concat_dim=-1,
name='concat_vwc'
)
else:
raise Exception("config.model value error")
filter_length = [2, 4, 8]
# dbpedia
n_filter = 600
# n_filter = 200
net_cnn_list = list()
for fsz in filter_length:
net_cnn = Conv1d(
net_in,
n_filter=n_filter,
filter_size=fsz,
stride=1,
act=tf.nn.relu,
name="cnn%d" % fsz
)
net_cnn.outputs = tf.reduce_max(net_cnn.outputs, axis=1, name="global_maxpool%d" % fsz)
net_cnn_list.append(net_cnn)
'''
if config.model == "vwvcvkg":
net_class_label_embed.outputs = tf.slice(
net_class_label_embed.outputs,
[0, 0, 0],
[config.batch_size, 1, self.word_embedding_dim],
name="slice_word"
)
net_class_label_embed.outputs = tf.squeeze(
net_class_label_embed.outputs,
name="squeeze_word"
)
net_cnn = ConcatLayer(net_cnn_list + [net_class_label_embed], concat_dim=-1)
else:
net_cnn = ConcatLayer(net_cnn_list, concat_dim=-1)
'''
net_cnn = ConcatLayer(net_cnn_list, concat_dim=-1)
net_fc = DropoutLayer(net_cnn, keep=0.5, is_fix=True, is_train=is_train, name='drop1')
net_fc = DenseLayer(
net_fc,
n_units=400,
act=tf.nn.relu,
name="fc_1"
)
net_fc = DropoutLayer(net_fc, keep=0.5, is_fix=True, is_train=is_train, name='drop2')
# dbpedia
net_fc = DenseLayer(
net_fc,
n_units=100,
act=tf.nn.relu,
name="fc_2"
)
net_fc = DropoutLayer(net_fc, keep=0.5, is_fix=True, is_train=is_train, name='drop3')
net_fc = DenseLayer(
net_fc,
n_units=1,
act=tf.nn.sigmoid,
name="fc_3"
)
return net_fc, net_cnn
def generator(input_placeholder,
train_mode,
image_size,
batch_size,
reuse=False,
filters_num=128):
w_init = tf.random_normal_initializer(stddev=0.02)
gamma_init = tf.random_normal_initializer(1., 0.02)
s2, s4, s8, s16 = int(image_size / 2), int(image_size / 4), int(
image_size / 8), int(image_size / 16)
with tf.variable_scope("generator", reuse=reuse):
tl.layers.set_name_reuse(reuse)
input_layer = InputLayer(input_placeholder, name='gen/in')
lin_layer = DenseLayer(input_layer,
n_units=filters_num * 8 * s16 * s16,
W_init=w_init,
act=tf.identity,
name='gen/lin')
resh1_layer = ReshapeLayer(lin_layer,
shape=[-1, s16, s16, filters_num * 8],
name='gen/reshape')
in_bn_layer = BatchNormLayer(resh1_layer,
act=tf.nn.relu,
is_train=train_mode,
gamma_init=gamma_init,
name='dec/in_bn')
# in_bn_layer.shape = (batch_size, 4, 4, 1024)
up1_layer = DeConv2d(in_bn_layer,
filters_num * 4, (5, 5),
out_size=(s8, s8),
strides=(2, 2),
padding='SAME',
batch_size=batch_size,
act=None,
W_init=w_init,
name='gen/up1')
bn1_layer = BatchNormLayer(up1_layer,
act=tf.nn.relu,
is_train=train_mode,
gamma_init=gamma_init,
name='dec/bn1')
# bn1_layer.shape = (batch_size, 8, 8, 512)
up2_layer = DeConv2d(bn1_layer,
filters_num * 2, (5, 5),
out_size=(s4, s4),
strides=(2, 2),
padding='SAME',
batch_size=batch_size,
act=None,
W_init=w_init,
name='gen/up2')
bn2_layer = BatchNormLayer(up2_layer,
act=tf.nn.relu,
is_train=train_mode,
gamma_init=gamma_init,
name='dec/bn2')
# bn2_layer.shape = (batch_size, 16, 16, 256)
up3_layer = DeConv2d(bn2_layer,
filters_num, (5, 5),
out_size=(s2, s2),
strides=(2, 2),
padding='SAME',
batch_size=batch_size,
act=None,
W_init=w_init,
name='gen/up3')
bn3_layer = BatchNormLayer(up3_layer,
act=tf.nn.relu,
is_train=train_mode,
gamma_init=gamma_init,
name='dec/bn3')
# bn3_layer.shape = (batch_size, 32, 32, 128)
up4_layer = DeConv2d(bn3_layer,
3, (5, 5),
out_size=(image_size, image_size),
strides=(2, 2),
padding='SAME',
batch_size=batch_size,
act=None,
W_init=w_init,
name='gen/up4')
up4_layer.outputs = tf.nn.tanh(up4_layer.outputs)
return up4_layer, up4_layer.outputs
def generator(inputs, is_train=True, reuse=False):
image_size = 64
s16 = image_size // 16
gf_dim = 64 # Dimension of gen filters in first conv layer. [64]
c_dim = FLAGS.c_dim # n_color 3
w_init = tf.glorot_normal_initializer()
gamma_init = tf.random_normal_initializer(1., 0.02)
with tf.variable_scope("generator", reuse=reuse):
net_in = InputLayer(inputs, name='g/in')
net_h0 = DenseLayer(net_in,
n_units=(gf_dim * 8 * s16 * s16),
W_init=w_init,
act=tf.identity,
name='g/h0/lin')
net_h0 = ReshapeLayer(net_h0,
shape=[-1, s16, s16, gf_dim * 8],
name='g/h0/reshape')
net_h0 = BatchNormLayer(net_h0,
act=tf.nn.relu,
is_train=is_train,
gamma_init=gamma_init,
name='g/h0/batch_norm')
net_h1 = DeConv2d(net_h0,
gf_dim * 4, (5, 5),
strides=(2, 2),
padding='SAME',
act=None,
W_init=w_init,
name='g/h1/decon2d')
net_h1 = BatchNormLayer(net_h1,
act=tf.nn.relu,
is_train=is_train,
gamma_init=gamma_init,
name='g/h1/batch_norm')
net_h2 = DeConv2d(net_h1,
gf_dim * 2, (5, 5),
strides=(2, 2),
padding='SAME',
act=None,
W_init=w_init,
name='g/h2/decon2d')
net_h2 = BatchNormLayer(net_h2,
act=tf.nn.relu,
is_train=is_train,
gamma_init=gamma_init,
name='g/h2/batch_norm')
net_h3 = DeConv2d(net_h2,
gf_dim, (5, 5),
strides=(2, 2),
padding='SAME',
act=None,
W_init=w_init,
name='g/h3/decon2d')
net_h3 = BatchNormLayer(net_h3,
act=tf.nn.relu,
is_train=is_train,
gamma_init=gamma_init,
name='g/h3/batch_norm')
net_h4 = DeConv2d(net_h3,
c_dim, (5, 5),
strides=(2, 2),
padding='SAME',
act=None,
W_init=w_init,
name='g/h4/decon2d')
net_h4.outputs = tf.nn.tanh(net_h4.outputs)
return net_h4
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 __get_network__(self,
encode_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("seq2seq_model", reuse=reuse) as vs:
tl.layers.set_name_reuse(reuse)
net_encode = InputLayer(encode_seq, name='in_root')
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')
# self.net_rnn_seq2seq = net_rnn
net_rnn_seq2seq = net_rnn
net_out_seq2seq = DenseLayer(net_rnn,
n_units=1,
act=tf.identity,
name='dense2')
if is_train:
net_out_seq2seq = ReshapeLayer(
net_out_seq2seq,
(config.batch_size, config.out_seq_length + 1, 1),
name="reshape_out")
else:
net_out_seq2seq = ReshapeLayer(net_out_seq2seq,
(config.batch_size, 1, 1),
name="reshape_out")
# net_out_seq2seq = net_out_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')
# net_out = ReshapeLayer(net_out, (config.batch_size, config.out_seq_length + 1, 1), name="reshape_out")
with tf.variable_scope(self.model_name, reuse=reuse) as vs:
tl.layers.set_name_reuse(reuse)
net_encode_query = InputLayer(self.query_x, name='in_root_query')
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 = 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_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_out = ConcatLayer([net_rnn_traffic, net_rnn_query],
concat_dim=-1,
name="concat_traffic_query1")
else:
net_out = ConcatLayer([net_traffic_state, net_rnn_query],
concat_dim=-1,
name="concat_traffic_query2")
# net_out = DenseLayer(net_out, n_units=128, act=tf.nn.relu, name="dense_query1")
# net_out = DenseLayer(net_out, n_units=32, act=tf.nn.relu, name="dense_query2")
net_out = DenseLayer(net_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_out = ReshapeLayer(
net_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")
return net_rnn_seq2seq, net_out_seq2seq, net_rnn_query, net_out
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 generator(inputs, is_train=True, reuse=False):
img_size = CFG.img_size
s2, s4, s8, s16 = [int(img_size / i) for i in [2, 4, 8, 16]]
gfs = 64
channels = CFG.channels
batch_size = CFG.batch_size
W_init = tf.random_normal_initializer(stddev=0.02)
gamma_init = tf.random_normal_initializer(1., 0.02)
with tf.variable_scope('generator', reuse=reuse):
tl.layers.set_name_reuse(reuse)
g = InputLayer(inputs, name='g/inputs')
g = DenseLayer(g,
gfs * 8 * s16 * s16,
W_init=W_init,
act=tl.act.identity,
name='g/fc1')
g = ReshapeLayer(g, shape=(-1, s16, s16, gfs * 8), name='g/reshape2')
g = BatchNormLayer(g,
act=tf.nn.relu,
is_train=is_train,
gamma_init=gamma_init,
name='g/bn3')
g = DeConv2d(g,
gfs * 4, (5, 5),
out_size=(s8, s8),
strides=(2, 2),
batch_size=batch_size,
act=None,
W_init=W_init,
name='g/dconv4')
g = BatchNormLayer(g,
act=tf.nn.relu,
is_train=is_train,
gamma_init=gamma_init,
name='g/bn5')
g = DeConv2d(g,
gfs * 2, (5, 5),
out_size=(s4, s4),
strides=(2, 2),
batch_size=batch_size,
act=None,
W_init=W_init,
name='g/dconv6')
g = BatchNormLayer(g,
act=tf.nn.relu,
is_train=is_train,
gamma_init=gamma_init,
name='g/bn7')
g = DeConv2d(g,
gfs, (5, 5),
out_size=(s2, s2),
strides=(2, 2),
batch_size=batch_size,
act=None,
W_init=W_init,
name='g/dconv8')
g = BatchNormLayer(g,
act=tf.nn.relu,
is_train=is_train,
gamma_init=gamma_init,
name='g/bn9')
g = DeConv2d(g,
channels, (5, 5),
out_size=(img_size, img_size),
strides=(2, 2),
batch_size=batch_size,
act=None,
W_init=W_init,
name='g/dconv10')
logits = g.outputs
g.outputs = tf.nn.tanh(g.outputs)
return g, logits
