def __get_network_autoencoder__(self, model_name, encode_seqs, decode_seqs, reuse=False, is_train=True): with tf.variable_scope(model_name, reuse=reuse): tl.layers.set_name_reuse(reuse) net_encode = InputLayer( inputs=encode_seqs, name="in_word_embed_encode" ) net_decode = InputLayer( inputs=decode_seqs, name="in_word_embed_decode" ) net_seq2seq = Seq2Seq( net_encode, net_decode, cell_fn = tf.contrib.rnn.BasicLSTMCell, n_hidden = 512, initializer = tf.random_uniform_initializer(-0.1, 0.1), encode_sequence_length = retrieve_seq_length_op(encode_seqs), decode_sequence_length = retrieve_seq_length_op(decode_seqs), initial_state_encode = None, n_layer = 1, return_seq_2d = True, name = 'seq2seq' ) net_out = DenseLayer(net_seq2seq, n_units=self.vocab_size, act=tf.identity, name='output') return net_out, net_seq2seq
def create_model(encode_seqs, decode_seqs, src_vocab_size, emb_dim, is_train=True, reuse=False): with tf.variable_scope("model", reuse=reuse): # for chatbot, you can use the same embedding layer, # for translation, you may want to use 2 seperated embedding layers with tf.variable_scope("embedding") as vs: net_encode = EmbeddingInputlayer( inputs = encode_seqs, vocabulary_size = src_vocab_size, embedding_size = emb_dim, name = 'seq_embedding') vs.reuse_variables() net_decode = EmbeddingInputlayer( inputs = decode_seqs, vocabulary_size = src_vocab_size, embedding_size = emb_dim, name = 'seq_embedding') net_rnn = Seq2Seq(net_encode, net_decode, cell_fn = tf.nn.rnn_cell.LSTMCell, n_hidden = emb_dim, initializer = tf.random_uniform_initializer(-0.1, 0.1), encode_sequence_length = retrieve_seq_length_op2(encode_seqs), decode_sequence_length = retrieve_seq_length_op2(decode_seqs), initial_state_encode = None, dropout = (0.5 if is_train else None), n_layer = 1, return_seq_2d = True, name = 'seq2seq') net_out = DenseLayer(net_rnn, n_units=src_vocab_size, act=tf.identity, name='output') return net_out, net_rnn
def model(encode_seqs, decode_seqs, is_train=True, reuse=False): with tf.variable_scope("model", reuse=reuse): with tf.variable_scope("embedding") as vs: net_encode = EmbeddingInputlayer( inputs=encode_seqs, vocabulary_size=xvocab_size, embedding_size=embedding_dimension, name='seq_embedding') vs.reuse_variables() net_decode = EmbeddingInputlayer( inputs=decode_seqs, vocabulary_size=xvocab_size, embedding_size=embedding_dimension, name='seq_embedding') net_rnn = Seq2Seq( net_encode, net_decode, cell_fn=tf.contrib.rnn.BasicLSTMCell, n_hidden=embedding_dimension, initializer=tf.random_uniform_initializer(-0.1, 0.1), encode_sequence_length=retrieve_seq_length_op2(encode_seqs), decode_sequence_length=retrieve_seq_length_op2(decode_seqs), initial_state_encode=None, n_layer=3, return_seq_2d=True, name='seq2seq') net_out = DenseLayer(net_rnn, n_units=xvocab_size, act=tf.identity, name='output') return net_out, net_rnn
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 create_model_pretrained(encode_seqs, decode_seqs, src_vocab_size, emb_dim, hidden_size, pretrainedModelName, is_train=True, reuse=False): with tf.variable_scope("model", reuse=reuse): # for chatbot, you can use the same embedding layer, # for translation, you may want to use 2 seperated embedding layers word2idx, weights, vocab_size, embedding_dim = loadGloveModel( pretrainedModelName) #'glove.6B.100d.txt') with tf.variable_scope("embedding") as vs: glove_weights_initializer = tf.constant_initializer(weights) embedding_encode = EmbeddingInputlayer( inputs=encode_seqs, vocabulary_size=vocab_size, embedding_size=embedding_dim, E_init=glove_weights_initializer, name='seq_embedding') vs.reuse_variables() embedding_decode = EmbeddingInputlayer( inputs=decode_seqs, vocabulary_size=vocab_size, embedding_size=embedding_dim, E_init=glove_weights_initializer, name='seq_embedding') net_rnn = Seq2Seq( embedding_encode, embedding_decode, cell_fn=tf.nn.rnn_cell.LSTMCell, n_hidden=hidden_size, initializer=tf.random_uniform_initializer(-0.1, 0.1), encode_sequence_length=retrieve_seq_length_op2(encode_seqs), decode_sequence_length=retrieve_seq_length_op2(decode_seqs), initial_state_encode=None, dropout=(0.5 if is_train else None), n_layer=3, return_seq_2d=True, name='seq2seq') net_out = DenseLayer(net_rnn, n_units=src_vocab_size, act=tf.identity, name='output') return net_out, net_rnn
def _model(encode_seqs, decode_seqs, hypes, metadata, mode): # We add two here for start, end ids as well as unknown and pad. xvocab_size = len(metadata['idx2w']) + 2 reuse = (mode != ModeKeys.TRAIN) with tf.variable_scope("model", reuse=tf.AUTO_REUSE): # for chatbot, you can use the same embedding layer with tf.variable_scope("embedding") as vs: net_encode = EmbeddingInputlayer(inputs=encode_seqs, vocabulary_size=xvocab_size, embedding_size=hypes['emb_dim'], name='seq_embedding') vs.reuse_variables() # tl.layers.set_name_reuse(True) # remove if TL version == 1.8.0+ net_decode = EmbeddingInputlayer(inputs=decode_seqs, vocabulary_size=xvocab_size, embedding_size=hypes['emb_dim'], name='seq_embedding') cell_fn = tf.contrib.rnn.GRUCell if hypes[ 'cell_fn'] == 'GRU' else tf.contrib.rnn.BasicLSTMCell net_rnn = Seq2Seq( net_encode, net_decode, cell_fn=cell_fn, n_hidden=hypes['emb_dim'], initializer=tf.random_uniform_initializer(-0.1, 0.1), encode_sequence_length=retrieve_seq_length_op2(encode_seqs), decode_sequence_length=retrieve_seq_length_op2(decode_seqs), initial_state_encode=None, dropout=(hypes['dropout'] if mode == ModeKeys.TRAIN else None), n_layer=hypes['seq2seq']['n_layer'], return_seq_2d=True, name='seq2seq') net_out = DenseLayer(net_rnn, n_units=xvocab_size, act=tf.identity, name='output') return net_out, net_rnn
def seq2seq_model(encode_sequences, decode_sequences, vocabulary_size, embedding_dim, is_train=True, reuse=False): with tf.variable_scope("model", reuse=tf.AUTO_REUSE): tl.layers.set_name_reuse(tf.AUTO_REUSE) with tf.variable_scope("embedding"): net_encode = EmbeddingInputlayer(inputs=encode_sequences, vocabulary_size=vocabulary_size, embedding_size=embedding_dim, name='seq_embedding') net_decode = EmbeddingInputlayer(inputs=decode_sequences, vocabulary_size=vocabulary_size, embedding_size=embedding_dim, name='seq_embedding') net_rnn = Seq2Seq( net_encode, net_decode, cell_fn=tf.contrib.rnn.BasicLSTMCell, n_hidden=embedding_dim, initializer=tf.random_uniform_initializer(-0.1, 0.1), encode_sequence_length=retrieve_seq_length_op2(encode_sequences), decode_sequence_length=retrieve_seq_length_op2(decode_sequences), initial_state_encode=None, dropout=(0.5 if is_train else None), n_layer=3, return_seq_2d=True, name='seq2seq') net_out = DenseLayer(net_rnn, n_units=vocabulary_size, act=tf.identity, name='output') return net_out, net_rnn
net_encode = EmbeddingInputlayer(inputs=encode_seqs, vocabulary_size=10000, embedding_size=200, name='seq_embed') vs.reuse_variables() # tl.layers.set_name_reuse(True) net_decode = EmbeddingInputlayer(inputs=decode_seqs, vocabulary_size=10000, embedding_size=200, name='seq_embed') net = Seq2Seq(net_encode, net_decode, cell_fn=tf.contrib.rnn.BasicLSTMCell, n_hidden=200, initializer=tf.random_uniform_initializer(-0.1, 0.1), encode_sequence_length=retrieve_seq_length_op2(encode_seqs), decode_sequence_length=retrieve_seq_length_op2(decode_seqs), initial_state_encode=None, dropout=None, n_layer=2, return_seq_2d=True, name='Seq2seq') net = DenseLayer(net, n_units=10000, act=tf.identity, name='oo') e_loss = tl.cost.cross_entropy_seq_with_mask(logits=net.outputs, target_seqs=target_seqs, input_mask=target_mask, return_details=False, name='cost') y = tf.nn.softmax(net.outputs) net.print_layers() net.print_params(False)
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