def __init__(self, config, is_training=True):
# Maps' feature dictionary
self._map_feature_dict = get_landmark_set(self._maps['grid']) # all featureas are the same for each map
self._map_objects_dict = get_objects_set(self._maps['grid'])
self._max_encoder_unrollings = config.encoder_unrollings
self._max_decoder_unrollings = config.decoder_unrollings
self._num_actions = config.num_actions
self._vocab_size = config.vocab_size
self._y_size = 4*len(self._map_feature_dict) + len(self._map_objects_dict)
# Model parameters
self._n_hidden = config.num_nodes # same for encoder and decoder
self._embedding_world_state_size = config.embedding_world_state_size
self._init_learning_rate = tf.constant(config.learning_rate)
self._learning_rate = self._init_learning_rate
self._learning_rate_decay_factor = config.learning_rate_decay_factor
self._max_gradient_norm = config.max_gradient_norm/3.0
# debug parameters
self._train_dir = "tmp/" # dir where checkpoint files will be saves
# merging and writing vars
self._writer = None
# Dropout rate
keep_prob = config.dropout_rate
## TRAINING Placeholders
self._encoder_inputs = []
self._encoder_unrollings = tf.placeholder('int64')
self._decoder_outputs = []
self._decoder_unrollings = tf.placeholder('int64')
self._world_state_vectors = [] # original sample structure, containing complete path, start_pos, end_pos, and map name
for i in xrange(self._max_encoder_unrollings):
self._encoder_inputs.append( tf.placeholder(tf.float32,shape=[1,self._vocab_size], name='x') )
for i in xrange(self._max_decoder_unrollings):
self._decoder_outputs.append( tf.placeholder(tf.int32,shape=[1], name='actions') )
self._world_state_vectors.append( tf.placeholder(tf.float32,shape=[1,self._y_size], name='world_vect') )
## TESTING / VALIDATION Placeholders
self._test_st = tf.placeholder(tf.float32, [1, self._n_hidden], name='test_st')
self._test_ct = tf.placeholder(tf.float32, [1, self._n_hidden], name='test_ct')
self._test_yt = tf.placeholder(tf.float32, [1, self._y_size], name='test_yt')
self._test_decoder_output = tf.placeholder(tf.float32,shape=[1,self._num_actions], name='test_action')
with tf.variable_scope('Weights',reuse=(not is_training)) as scope:
# Encoder - decoder transition
#w_trans = tf.Variable(weight_initializer((2*self._n_hidden, 2*self._n_hidden)), name='w_trans')
#b_trans = tf.Variable(tf.zeros([1,2*self._n_hidden ]), name='b_trans')
# LSTM to softmax layer.
wo = tf.get_variable('wo',shape=(self._n_hidden , self._num_actions),initializer=weight_initializer)
bo = tf.get_variable('bo',shape=(1 , self._num_actions),initializer=weight_initializer)
#######################################################################################################################
with tf.variable_scope('Encoder',reuse=(not is_training)) as scope:
## Encoder
enc_cell = CustomLSTMCell(self._n_hidden, forget_bias=1.0, input_size=self._vocab_size)
enc_cell_dp = tf.nn.rnn_cell.DropoutWrapper(enc_cell,output_keep_prob=keep_prob)
hs,last_state = tf.nn.rnn( enc_cell_dp,
self._encoder_inputs,
initial_state=weight_initializer((1,2*self._n_hidden)),
dtype=tf.float32,
sequence_length = self._encoder_unrollings*tf.ones([1],tf.int64),
scope=scope # cell scope: Encoder/BasicLSTMCell/...
)
#END-ENCODER-SCOPE
#######################################################################################################################
# transition
#with tf.variable_scope('Transition') as scope:
#init_state = tf.matmul(last_state,w_trans)+b_trans
#######################################################################################################################
## Decoder loop
with tf.variable_scope('Decoder',reuse=(not is_training)) as scope:
# Definition of the cell computation.
dec_cell = CustomLSTMCell(self._n_hidden, forget_bias=1.0, input_size=self._y_size)
dec_cell_dp = tf.nn.rnn_cell.DropoutWrapper(dec_cell,output_keep_prob=keep_prob)
logits = []
dec_outs,_ = tf.nn.rnn(dec_cell_dp,
inputs = self._world_state_vectors,
#initial_state=init_state,
initial_state=last_state,
dtype=tf.float32,
sequence_length = self._decoder_unrollings*tf.ones([1],tf.int64),
scope=scope # cell scope: Decoder/BasicLSTMCell/...
)
self._train_predictions = []
for out in dec_outs:
logit = tf.matmul(out,wo)+bo
logits.append(logit)
self._train_predictions.append( tf.nn.softmax(logit,name='prediction') )
#for _ in range(len(dec_outs),self._max_decoder_unrollings):
# logits.append(tf.zeros([1,self._num_actions]))
# Loss definition
nopad_dec_outputs = self._decoder_outputs[:len(dec_outs)]
self._loss = tf.nn.seq2seq.sequence_loss(logits,
targets=nopad_dec_outputs,
weights=[tf.ones([1],dtype=tf.float32)]*self._max_decoder_unrollings,
name='train_loss')
#scope.reuse_variables()
#END-DECODER-SCOPE
###################################################################################################################
# TESTING
# Decode one step at a time, the world state vector is defined externally
with tf.variable_scope('Encoder',reuse=True) as scope:
test_hs,test_last_st = tf.nn.rnn( enc_cell,
self._encoder_inputs,
initial_state=weight_initializer((1,2*self._n_hidden)),
dtype=tf.float32,
sequence_length = self._encoder_unrollings*tf.ones([1],tf.int64),
scope=scope
)
#test_c_last, test_h_last = tf.split(1, 2, test_last_st)
self._test_c0, self._test_s0 = tf.split(1, 2, test_last_st)
#self._test_s0 = tf.tanh( tf.matmul(test_h_last,w_trans_s)+b_trans_s , name='test_s0')
#self._test_c0 = tf.tanh( tf.matmul(test_c_last,w_trans_c)+b_trans_c , name='test_c0')
with tf.variable_scope('Decoder',reuse=True) as scope:
_,temp = dec_cell(self._test_yt,tf.concat(1, [self._test_ct, self._test_st]),scope="CustomLSTMCell") # joins scopes -> Decoder/BasicLSTMCell
self._next_ct,self._next_st = tf.split(1, 2, temp)
# softmax layer,
logit = tf.matmul(self._next_st,wo) + bo
self._test_prediction = tf.nn.softmax(logit,name='inf_prediction')
# Loss definition
self._test_loss = tf.nn.softmax_cross_entropy_with_logits(logit,self._test_decoder_output, name="test_loss")
with tf.variable_scope('Optimization') as scope:
# Optimizer setup
self._global_step = tf.Variable(0,trainable=False)
self._learning_rate = tf.train.exponential_decay(self._init_learning_rate,
self._global_step,
80000,
self._learning_rate_decay_factor,
staircase=True)
#params = tf.trainable_variables()
#optimizer = tf.train.GradientDescentOptimizer(self._learning_rate)
optimizer = tf.train.AdamOptimizer(learning_rate=self._init_learning_rate,
epsilon=1e-1)
# Gradient clipping
#gradients = tf.gradients(self._loss,params)
gradients,params = zip(*optimizer.compute_gradients(self._loss))
self._clipped_gradients, self._global_norm = tf.clip_by_global_norm(gradients, self._max_gradient_norm)
# Apply clipped gradients
self._optimizer = optimizer.apply_gradients( zip(self._clipped_gradients, params), global_step=self._global_step )
#########################################################################################################
if is_training:
with tf.name_scope('Summaries') as scope:
### Summaries
clipped_resh = [tf.reshape(tensor,[-1]) for tensor in self._clipped_gradients if tensor]
clipped_resh = tf.concat(0,clipped_resh)
# weight summaries
temp = tf.trainable_variables()
ow = [tf.reshape(tensor,[-1]) for tensor in temp[:2]]
ow = tf.concat(0,ow)
encw = [tf.reshape(tensor,[-1]) for tensor in temp[2:4]]
encw = tf.concat(0,encw)
decw = [tf.reshape(tensor,[-1]) for tensor in temp[4:6]]
decw = tf.concat(0,decw)
# sum strings
_ = tf.scalar_summary("loss",self._loss)
_ = tf.scalar_summary('global_norm',self._global_norm)
_ = tf.scalar_summary('learning rate',self._learning_rate)
_ = tf.histogram_summary('clipped_gradients', clipped_resh)
_ = tf.histogram_summary('output weights', ow)
_ = tf.histogram_summary('encoder w', encw)
_ = tf.histogram_summary('decoder w', decw)
self._merged = tf.merge_all_summaries()
# include accuracies as summaries
self._train_acc = tf.placeholder(tf.float32,name='train_accuracy')
self._val_acc = tf.placeholder(tf.float32,name='val_accuracy')
self._train_acc_sum = tf.scalar_summary("Training accuracy",self._train_acc)
self._val_acc_sum = tf.scalar_summary("Validation accuracy",self._val_acc)
# checkpoint saver
#self.saver = tf.train.Saver(tf.all_variables())
self.vars_to_init = set(tf.all_variables()) - set(tf.trainable_variables())
self.saver = tf.train.Saver(tf.trainable_variables())
self.kk=0
def __init__(self, config):
# Maps' feature dictionary
self._map_feature_dict = get_landmark_set(self._maps['grid']) # all featureas are the same for each map
self._map_objects_dict = get_objects_set(self._maps['grid'])
self._batch_size = config.batch_size
self._encoder_unrollings = config.encoder_unrollings
self._decoder_unrollings = config.decoder_unrollings
self._num_actions = config.num_actions
self._vocab_size = config.vocab_size
self._y_size = 4*len(self._map_feature_dict) + len(self._map_objects_dict)
# Model parameters
self._n_hidden = config.num_nodes # same for encoder and decoder
self._embedding_world_state_size = config.embedding_world_state_size
self._init_learning_rate = tf.constant(config.learning_rate)
self._learning_rate = self._init_learning_rate
self._learning_rate_decay_factor = config.learning_rate_decay_factor
self._max_gradient_norm = config.max_gradient_norm
# debug parameters
self._train_dir = "tmp/" # dir where checkpoint files will be saves
# merging and writing vars
self._writer = None
# Dropout rate
keep_prob = config.dropout_rate
## TRAINING Placeholders
self._encoder_inputs = []
self._decoder_outputs = []
self._world_state_vectors = [] # original sample structure, containing complete path, start_pos, end_pos, and map name
for i in xrange(self._encoder_unrollings):
self._encoder_inputs.append( tf.placeholder(tf.float32,shape=[self._batch_size,self._vocab_size], name='x') )
for i in xrange(self._decoder_unrollings):
self._decoder_outputs.append( tf.placeholder(tf.int32,shape=[self._batch_size], name='actions') )
self._world_state_vectors.append( tf.placeholder(tf.float32,shape=[self._batch_size,self._y_size], name='world_vect') )
## TESTING / VALIDATION Placeholders
self._test_encoder_inputs = []
for i in xrange(self._encoder_unrollings):
self._test_encoder_inputs.append( tf.placeholder(tf.float32,shape=[1,self._vocab_size], name='test_x') )
self._test_decoder_output = tf.placeholder(tf.float32,shape=[1,self._num_actions], name='test_action_t')
self._test_st = tf.placeholder(tf.float32, [1, self._n_hidden], name='test_st')
self._test_ct = tf.placeholder(tf.float32, [1, self._n_hidden], name='test_ct')
self._test_yt = tf.placeholder(tf.float32, [1, self._y_size], name='test_yt')
with tf.name_scope('Weights') as scope:
# Alignment model weights
W_a = tf.Variable(tf.truncated_normal([self._n_hidden , self._n_hidden], -0.1, 0.1), name='W_a')
U_a = tf.Variable(tf.truncated_normal([self._vocab_size, self._n_hidden], -0.1, 0.1), name='U_a')
V_a = tf.Variable(tf.truncated_normal([2*self._n_hidden, self._n_hidden], -0.1, 0.1), name='V_a')
v_a = tf.Variable(tf.truncated_normal([self._n_hidden ,1], -0.1, 0.1), name='v_a')
tanh_bias_a = tf.Variable(tf.truncated_normal([1,1], -0.1, 0.1), name='tanh_bias_a')
bias_a = tf.Variable(tf.zeros([1, self._n_hidden]), name='linear_bias_a')
## Decoder variables
# Input gate: input, previous output, context vector, and bias.
ix = tf.Variable(tf.truncated_normal([self._embedding_world_state_size , self._n_hidden], -0.1, 0.1), name='ix')
im = tf.Variable(tf.truncated_normal([self._n_hidden , self._n_hidden], -0.1, 0.1), name='ih')
iz = tf.Variable(tf.truncated_normal([2*self._n_hidden + self._vocab_size, self._n_hidden], -0.1, 0.1), name='iz')
ib = tf.Variable(tf.zeros([1, self._n_hidden]), name='ib')
# Forget gate: input, previous output, context vector, and bias.
fx = tf.Variable(tf.truncated_normal([self._embedding_world_state_size , self._n_hidden], -0.1, 0.1), name='fx')
fm = tf.Variable(tf.truncated_normal([self._n_hidden , self._n_hidden], -0.1, 0.1), name='fh')
fz = tf.Variable(tf.truncated_normal([2*self._n_hidden + self._vocab_size, self._n_hidden], -0.1, 0.1), name='fz')
fb = tf.Variable(tf.zeros([1, self._n_hidden]), name='fb')
# Memory cell: input, state, context vector, and bias.
gx = tf.Variable(tf.truncated_normal([self._embedding_world_state_size , self._n_hidden], -0.1, 0.1), name='cx')
gm = tf.Variable(tf.truncated_normal([self._n_hidden , self._n_hidden], -0.1, 0.1), name='cc')
gz = tf.Variable(tf.truncated_normal([2*self._n_hidden + self._vocab_size, self._n_hidden], -0.1, 0.1), name='cz')
gb = tf.Variable(tf.zeros([1, self._n_hidden]), name='cb')
# Output gate: input, previous output, context vector, and bias.
ox = tf.Variable(tf.truncated_normal([self._embedding_world_state_size , self._n_hidden], -0.1, 0.1), name='ox')
om = tf.Variable(tf.truncated_normal([self._n_hidden , self._n_hidden], -0.1, 0.1), name='oh')
oz = tf.Variable(tf.truncated_normal([2*self._n_hidden + self._vocab_size, self._n_hidden], -0.1, 0.1), name='oz')
ob = tf.Variable(tf.zeros([1, self._n_hidden]), name='ob')
# Embedding weight
w_emby = tf.Variable(tf.truncated_normal([self._y_size,self._embedding_world_state_size], -0.1, 0.1), name='Ey_w')
b_emby = tf.Variable(tf.zeros([1, self._embedding_world_state_size]), name='Ey_b')
# Encoder - decoder transition
w_trans_s = tf.Variable(tf.truncated_normal([self._n_hidden, self._n_hidden], -0.1, 0.1), name='w_trans_s')
b_trans_s = tf.Variable(tf.zeros([1,self._n_hidden ]), name='b_trans_s')
w_trans_c = tf.Variable(tf.truncated_normal([self._n_hidden, self._n_hidden], -0.1, 0.1), name='w_trans_c')
b_trans_c = tf.Variable(tf.zeros([1,self._n_hidden ]), name='b_trans_c')
# Action Classifier weights and biases.
ws = tf.Variable(tf.truncated_normal([self._n_hidden , self._embedding_world_state_size ], -0.1, 0.1), name='ws')
wz = tf.Variable(tf.truncated_normal([2*self._n_hidden + self._vocab_size, self._embedding_world_state_size ], -0.1, 0.1), name='wz')
wo = tf.Variable(tf.truncated_normal([self._embedding_world_state_size , self._num_actions ], -0.1, 0.1), name='wo')
b_q = tf.Variable(tf.zeros([1,self._embedding_world_state_size ]), name='bq')
b_o = tf.Variable(tf.zeros([1,self._num_actions ]), name='bo')
#######################################################################################################################
## Encoder
with tf.name_scope('Encoder') as scope:
lstm_fw_cell = tf.nn.rnn_cell.BasicLSTMCell(self._n_hidden, forget_bias=1.0, input_size=self._vocab_size)
lstm_bw_cell = tf.nn.rnn_cell.BasicLSTMCell(self._n_hidden, forget_bias=1.0, input_size=self._vocab_size)
def encoder(encoder_inputs, batch_size=self._batch_size, is_training=True):
fw_cell = lstm_fw_cell
bw_cell = lstm_bw_cell
if is_training and keep_prob < 1.0:
fw_cell = tf.nn.rnn_cell.DropoutWrapper(
fw_cell, output_keep_prob=keep_prob)
bw_cell = tf.nn.rnn_cell.DropoutWrapper(
bw_cell, output_keep_prob=keep_prob)
h,c1,h1 = bidirectional_rnn(fw_cell,bw_cell,
encoder_inputs,
dtype=tf.float32,
sequence_length = self._encoder_unrollings * tf.ones([batch_size],tf.int64)
)
return h,c1,h1
def decoder_cell(i, o, z, c_prev):
input_gate = tf.sigmoid(tf.matmul(i, ix) + tf.matmul(o, im) + tf.matmul(z,iz) + ib)
forget_gate = tf.sigmoid(tf.matmul(i, fx) + tf.matmul(o, fm) + tf.matmul(z,fz) + fb)
output_gate = tf.sigmoid(tf.matmul(i, ox) + tf.matmul(o, om) + tf.matmul(z,oz) + ob)
# gt
update = tf.tanh(tf.matmul(i, gx) + tf.matmul(o, gm) + tf.matmul(z,gz) + gb)
# ct
c_t = forget_gate * c_prev + input_gate * update
s_t = output_gate * tf.tanh(c_t)
return s_t, c_t
# Alignment model
with tf.name_scope('Aligner') as scope:
def context_vector(s_prev,h_encoder,ux_vh,encoder_inputs,batch_size):
# alignment model
beta = [tf.matmul(tf.tanh(tf.matmul(s_prev,W_a) + u_v + bias_a),v_a) + tanh_bias_a for u_v in ux_vh]
beta = tf.concat(1,beta, name='beta')
# weights of each (xj,hj)
alpha = tf.nn.softmax(beta) # shape: batch_size x encoder_unroll
alpha = tf.split(1,self._encoder_unrollings,alpha, name='alpha') # list of unrolling, each elmt of shape [batch_size x 1]
z_t = tf.Variable(tf.zeros([batch_size , 2*self._n_hidden + self._vocab_size]), name='z_t')
for j in xrange(self._encoder_unrollings):
xh = tf.concat(1,[encoder_inputs[j],h_encoder[j]], name='xhj') # (x_j, h_j)
z_t += alpha[j] * xh
return z_t
def precalc_Ux_Vh(encoder_inputs,h_enc):
ux_vh = []
for i in xrange(self._encoder_unrollings):
ux_vh.append( tf.matmul(encoder_inputs[i],U_a) + tf.matmul(h_enc[i],V_a) )
return ux_vh
#######################################################################################################################
def model_encoder_decoder(encoder_inputs, world_state_vectors, batch_size):
h_encoder,c1,h1 = encoder(encoder_inputs)
U_V_precalc = precalc_Ux_Vh(encoder_inputs,h_encoder)
## Decoder loop
with tf.name_scope('Decoder') as scope:
# Initial states
s_t = tf.tanh( tf.matmul(h1,w_trans_s)+b_trans_s , name='s_0')
c_t = tf.tanh( tf.matmul(c1,w_trans_c)+b_trans_c , name='c_0')
# Definition of the cell computation.
logits = [] # logits per rolling
predictions = []
for i in xrange(self._decoder_unrollings):
# world state vector at step i
y_t = world_state_vectors[i] # batch_size x num_local_feats (feat_id format)
# embeed world vector | relu nodes
ey = tf.nn.relu(tf.matmul(y_t,w_emby) + b_emby, name='Ey')
# context vector
z_t = context_vector(s_t,h_encoder,U_V_precalc,encoder_inputs,batch_size)
# Dropout
ey = tf.nn.dropout(ey, keep_prob)
s_t,c_t = decoder_cell(ey,s_t,z_t,c_t)
s_t = tf.nn.dropout(s_t, keep_prob)
# Hidden linear layer before output, proyects z_t,y_t, and s_t to an embeeding-size layer
hq = ey + tf.matmul(s_t,ws) + tf.matmul(z_t,wz) + b_q
# Output layer
logit = tf.matmul(hq,wo) + b_o
prediction = tf.nn.softmax(logit,name='prediction')
logits.append(logit)
predictions.append(prediction)
#END-FOR-DECODER-UNROLLING
#END-DECODER-SCOPE
return logits,predictions
#END-MODEL
with tf.variable_scope('Train_test_pipeline') as scope:
logits,self._train_predictions = model_encoder_decoder(self._encoder_inputs,
self._world_state_vectors,
batch_size=self._batch_size)
scope.reuse_variables()
self._loss = tf.nn.seq2seq.sequence_loss(logits,
targets=self._decoder_outputs,
weights=[tf.ones(shape=[self._batch_size],dtype=tf.float32)
for _ in range(self._decoder_unrollings)],
name='train_loss')
# Optimizer setup
self._global_step = tf.Variable(0,trainable=False)
"""
self._learning_rate = tf.train.exponential_decay(self._init_learning_rate,
self._global_step,
5000,
self._learning_rate_decay_factor,
staircase=True)
"""
# debug variables
params = tf.trainable_variables()
#optimizer = tf.train.GradientDescentOptimizer(self._learning_rate)
optimizer = tf.train.AdamOptimizer(learning_rate=self._init_learning_rate,
epsilon=1e-4)
# Gradient clipping
gradients, v = zip(*optimizer.compute_gradients(self._loss,params))
self._clipped_gradients, self._global_norm = tf.clip_by_global_norm(gradients, self._max_gradient_norm)
# Apply clipped gradients
self._optimizer = optimizer.apply_gradients( zip(self._clipped_gradients, v), global_step=self._global_step )
##############################################################################################################
## Testing
test_h,c1,h1 = encoder(self._test_encoder_inputs,1,False)
self._test_s0 = tf.tanh( tf.matmul(h1,w_trans_s) , name='test_s0')
self._test_c0 = tf.tanh( tf.matmul(c1,w_trans_c)+b_trans_c , name='test_c0')
test_ux_vh = precalc_Ux_Vh(self._test_encoder_inputs,test_h)
# embeed world vector | relu nodes
ey = tf.nn.relu(tf.matmul(self._test_yt,w_emby) + b_emby, name='Ey_test')
# context vector
z_t = context_vector(self._test_st,test_h,test_ux_vh,self._test_encoder_inputs,1)
self._next_st,self._next_ct = decoder_cell(ey, self._test_st, z_t, self._test_ct)
# Hidden linear layer before output, proyects z_t,y_t, and s_t to an embeeding-size layer
hq = ey + tf.matmul(self._next_st,ws) + tf.matmul(z_t,wz) + b_q
logit = tf.matmul(hq,wo) + b_o
self._test_prediction = tf.nn.softmax(logit,name='inf_prediction')
self._test_loss = tf.nn.softmax_cross_entropy_with_logits(logit,self._test_decoder_output, name="test_loss")
# Summaries
clipped_resh = [tf.reshape(tensor,[-1]) for tensor in self._clipped_gradients]
clipped_resh = tf.concat(0,clipped_resh)
_ = tf.scalar_summary("loss",self._loss)
_ = tf.scalar_summary('global_norm',self._global_norm)
_ = tf.scalar_summary('learning rate',self._learning_rate)
_ = tf.histogram_summary('clipped_gradients', clipped_resh)
# checkpoint saver
#self.saver = tf.train.Saver(tf.all_variables())
self._merged = tf.merge_all_summaries()
def __init__(self, config, is_training=True):
# Maps' feature dictionary
self._map_feature_dict = get_landmark_set(
self._maps['grid']) # all featureas are the same for each map
self._map_objects_dict = get_objects_set(self._maps['grid'])
self._max_encoder_unrollings = config.encoder_unrollings
self._max_decoder_unrollings = config.decoder_unrollings
self._num_actions = config.num_actions
self._vocab_size = config.vocab_size
self._y_size = 4 * len(self._map_feature_dict) + len(
self._map_objects_dict)
# Model parameters
self._n_hidden = config.num_nodes # same for encoder and decoder
self._embedding_world_state_size = config.embedding_world_state_size
self._init_learning_rate = tf.constant(config.learning_rate)
self._learning_rate = self._init_learning_rate
self._learning_rate_decay_factor = config.learning_rate_decay_factor
self._max_gradient_norm = config.max_gradient_norm
# debug parameters
self._train_dir = "tmp/" # dir where checkpoint files will be saves
# merging and writing vars
self._writer = None
# Dropout rate
keep_prob = config.dropout_rate
## TRAINING Placeholders
self._encoder_inputs = []
self._encoder_unrollings = tf.placeholder('int64')
self._decoder_outputs = []
self._decoder_unrollings = tf.placeholder('int64')
self._world_state_vectors = [
] # original sample structure, containing complete path, start_pos, end_pos, and map name
for i in xrange(self._max_encoder_unrollings):
self._encoder_inputs.append(
tf.placeholder(tf.float32,
shape=[1, self._vocab_size],
name='x'))
for i in xrange(self._max_decoder_unrollings):
self._decoder_outputs.append(
tf.placeholder(tf.int32, shape=[1], name='actions'))
self._world_state_vectors.append(
tf.placeholder(tf.float32,
shape=[1, self._y_size],
name='world_vect'))
## TESTING / VALIDATION Placeholders
self._test_st = tf.placeholder(tf.float32, [1, self._n_hidden],
name='test_st')
self._test_ct = tf.placeholder(tf.float32, [1, self._n_hidden],
name='test_ct')
self._test_yt = tf.placeholder(tf.float32, [1, self._y_size],
name='test_yt')
self._test_decoder_output = tf.placeholder(
tf.float32, shape=[1, self._num_actions], name='test_action')
with tf.name_scope('Weights') as scope:
# Alignment model weights
W_a = tf.Variable(weight_initializer(
[self._n_hidden, self._n_hidden]),
name='W_a')
U_a = tf.Variable(weight_initializer(
[self._vocab_size, self._n_hidden]),
name='U_a')
V_a = tf.Variable(weight_initializer(
[2 * self._n_hidden, self._n_hidden]),
name='V_a')
v_a = tf.Variable(weight_initializer([self._n_hidden, 1]),
name='v_a')
tanh_bias_a = tf.Variable(weight_initializer([1, 1]),
name='tanh_bias_a')
bias_a = tf.Variable(tf.zeros([1, self._n_hidden]),
name='linear_bias_a')
# Embedding weight
w_emby = tf.Variable(weight_initializer(
[self._y_size, self._embedding_world_state_size]),
name='Ey_w')
b_emby = tf.Variable(tf.zeros(
[1, self._embedding_world_state_size]),
name='Ey_b')
"""
# Encoder - decoder transition
w_trans_s = tf.Variable(tf.truncated_normal([self._n_hidden, self._n_hidden], -0.1, 0.1), name='w_trans_s')
b_trans_s = tf.Variable(tf.zeros([1,self._n_hidden ]), name='b_trans_s')
w_trans_c = tf.Variable(tf.truncated_normal([self._n_hidden, self._n_hidden], -0.1, 0.1), name='w_trans_c')
b_trans_c = tf.Variable(tf.zeros([1,self._n_hidden ]), name='b_trans_c')
"""
# Action Classifier weights and biases.
ws = tf.Variable(weight_initializer(
[self._n_hidden, self._embedding_world_state_size]),
name='ws')
wz = tf.Variable(weight_initializer([
2 * self._n_hidden + self._vocab_size,
self._embedding_world_state_size
]),
name='wz')
wo = tf.Variable(weight_initializer(
[self._embedding_world_state_size, self._num_actions]),
name='wo')
b_q = tf.Variable(tf.zeros([1, self._embedding_world_state_size]),
name='bq')
b_o = tf.Variable(tf.zeros([1, self._num_actions]), name='bo')
#######################################################################################################################
## Encoder
with tf.variable_scope('Encoder') as scope:
fw_cell = CustomLSTMCell(self._n_hidden,
forget_bias=1.0,
input_size=self._vocab_size)
bw_cell = CustomLSTMCell(self._n_hidden,
forget_bias=1.0,
input_size=self._vocab_size)
fw_cell_dp = tf.nn.rnn_cell.DropoutWrapper(
fw_cell, output_keep_prob=keep_prob)
bw_cell_dp = tf.nn.rnn_cell.DropoutWrapper(
bw_cell, output_keep_prob=keep_prob)
h_encoder, c1h1 = bidirectional_rnn(
fw_cell_dp,
bw_cell_dp,
self._encoder_inputs,
dtype=tf.float32,
sequence_length=self._encoder_unrollings *
tf.ones([1], tf.int64),
scope='Encoder')
#END-ENCODER-SCOPE
#######################################################################################################################
# Alignment model
with tf.name_scope('Aligner') as scope:
def context_vector(s_prev, h_encoder, ux_vh, encoder_inputs):
# alignment model
beta = []
for i in xrange(self._max_encoder_unrollings):
beta.append(
tf.cond(
tf.less(tf.constant(i, dtype=tf.int64),
self._encoder_unrollings),
lambda: tf.matmul(
tf.tanh(
tf.matmul(s_prev, W_a) + ux_vh[i] + bias_a
), v_a) + tanh_bias_a,
lambda: tf.zeros([1, 1])))
beta = tf.concat(1, beta, name='beta')
# weights of each (xj,hj)
alpha = tf.nn.softmax(
beta) # shape: batch_size x encoder_unroll
alpha = tf.split(
1, self._max_encoder_unrollings, alpha, name='alpha'
) # list of unrolling, each elmt of shape [batch_size x 1]
z_t = tf.zeros([1, 2 * self._n_hidden + self._vocab_size])
for j in xrange(self._max_encoder_unrollings):
xh = tf.cond(
tf.less(tf.constant(j, dtype=tf.int64),
self._encoder_unrollings),
lambda: tf.concat(1, [encoder_inputs[j], h_encoder[j]],
name='xhj'), # (x_j, h_j)
lambda: tf.zeros(
[1, 2 * self._n_hidden + self._vocab_size]))
z_t += alpha[j] * xh
return z_t
def precalc_Ux_Vh(encoder_inputs, h_enc):
ux_vh = []
for i in xrange(self._max_encoder_unrollings):
ux_vh.append(
tf.cond(
tf.less(tf.constant(i, dtype=tf.int64),
self._encoder_unrollings),
lambda: tf.matmul(encoder_inputs[i], U_a
) + tf.matmul(h_enc[i], V_a),
lambda: tf.zeros([1, self._n_hidden])))
return ux_vh
U_V_precalc = precalc_Ux_Vh(self._encoder_inputs, h_encoder)
#######################################################################################################################
## Decoder loop
with tf.variable_scope('Decoder') as scope:
dec_cell = CustomLSTMCell(self._n_hidden,
forget_bias=1.0,
input_size=self._vocab_size)
dec_cell_dp = tf.nn.rnn_cell.DropoutWrapper(
dec_cell, output_keep_prob=keep_prob)
# Initial states
#s_t = tf.tanh( tf.matmul(h1,w_trans_s)+b_trans_s , name='s_0')
#c_t = tf.tanh( tf.matmul(c1,w_trans_c)+b_trans_c , name='c_0')
c_t, s_t = tf.split(1, 2, c1h1)
state = c1h1
logits = [] # logits per rolling
self._train_predictions = []
for i in xrange(self._max_decoder_unrollings):
if i > 0: tf.get_variable_scope().reuse_variables()
# world state vector at step i
y_t = tf.cond(
tf.less(tf.constant(i, dtype=tf.int64),
self._decoder_unrollings),
lambda: self._world_state_vectors[
i], # batch_size x num_local_feats (feat_id format)
lambda: tf.zeros([1, self._y_size]))
# embeed world vector | relu nodes
ey = tf.nn.relu(tf.matmul(y_t, w_emby) + b_emby, name='Ey')
# run attention mechanism
z_t = context_vector(s_t, h_encoder, U_V_precalc,
self._encoder_inputs)
# merge inputs and attention prev state
dec_input = tf.concat(1, [ey, z_t])
s_t, state = dec_cell_dp(dec_input,
state,
scope="CustomLSTMCell")
# Hidden linear layer before output, proyects z_t,y_t, and s_t to an embeeding-size layer
hq = ey + tf.matmul(s_t, ws) + tf.matmul(z_t, wz) + b_q
# Output layer
logit = tf.matmul(hq, wo) + b_o
fill_pred = tf.constant([[0., 0., 0., 0.,
1.]]) # one-hot vector for PAD
prediction = tf.cond(
tf.less(tf.constant(i, dtype=tf.int64),
self._decoder_unrollings),
lambda: tf.nn.softmax(logit, name='prediction'),
lambda: fill_pred)
logits.append(logit)
self._train_predictions.append(prediction)
#END-FOR-DECODER-UNROLLING
# Loss definition
reshaped_dec_outputs = []
for i in xrange(self._max_decoder_unrollings):
out = tf.cond(
tf.less(tf.constant(i, dtype=tf.int64),
self._decoder_unrollings),
lambda: self._decoder_outputs[i],
lambda: 4 * tf.ones([1], dtype=tf.int32))
reshaped_dec_outputs.append(out)
self._loss = tf.nn.seq2seq.sequence_loss(
logits,
targets=reshaped_dec_outputs,
weights=[tf.ones([1], dtype=tf.float32)] *
self._max_decoder_unrollings,
#np.ones(shape=(self._max_decoder_unrollings,1),dtype=np.float32),
name='train_loss')
###################################################################################################################
# TESTING
with tf.variable_scope('Encoder', reuse=True) as scope:
test_h, c1h1 = bidirectional_rnn(
fw_cell,
bw_cell,
self._encoder_inputs,
dtype=tf.float32,
sequence_length=self._encoder_unrollings *
tf.ones([1], tf.int64),
scope='Encoder')
#self._test_s0 = tf.tanh( tf.matmul(h1,w_trans_s)+b_trans_s, name='test_s0')
#self._test_c0 = tf.tanh( tf.matmul(c1,w_trans_c)+b_trans_c, name='test_c0')
self._test_c0, self._test_s0 = tf.split(1, 2, c1h1)
test_ux_vh = precalc_Ux_Vh(self._encoder_inputs, test_h)
with tf.variable_scope('Decoder', reuse=True) as scope:
# embeed world vector | relu nodes
ey = tf.nn.relu(tf.matmul(self._test_yt, w_emby) + b_emby,
name='Ey_test')
# context vector
z_t = context_vector(self._test_st, test_h, test_ux_vh,
self._encoder_inputs)
state = tf.concat(1, [self._test_ct, self._test_st])
dec_input = tf.concat(1, [ey, z_t])
_, temp = dec_cell(dec_input, state, scope="CustomLSTMCell")
self._next_ct, self._next_st = tf.split(1, 2, temp)
# Hidden linear layer before output, proyects z_t,y_t, and s_t to an embeeding-size layer
hq = ey + tf.matmul(self._next_st, ws) + tf.matmul(z_t, wz) + b_q
logit = tf.matmul(hq, wo) + b_o
self._test_prediction = tf.nn.softmax(logit, name='inf_prediction')
# Loss definition
self._test_loss = tf.nn.softmax_cross_entropy_with_logits(
logit, self._test_decoder_output, name="test_loss")
#END-DECODER-SCOPE
with tf.variable_scope('Optimization') as scope:
# Optimizer setup
self._global_step = tf.Variable(0, trainable=False)
self._learning_rate = tf.train.exponential_decay(
self._init_learning_rate,
self._global_step,
80000,
self._learning_rate_decay_factor,
staircase=True)
#optimizer = tf.train.GradientDescentOptimizer(self._learning_rate)
optimizer = tf.train.AdamOptimizer(
learning_rate=self._learning_rate, epsilon=1e-1)
# Gradient clipping
#gradients = tf.gradients(self._loss,params)
gradients, params = zip(*optimizer.compute_gradients(self._loss))
self._clipped_gradients, self._global_norm = tf.clip_by_global_norm(
gradients, self._max_gradient_norm)
# Apply clipped gradients
self._optimizer = optimizer.apply_gradients(
zip(self._clipped_gradients, params),
global_step=self._global_step)
with tf.name_scope('Summaries') as scope:
# Summaries
clipped_resh = [
tf.reshape(tensor, [-1]) for tensor in self._clipped_gradients
if tensor
]
clipped_resh = tf.concat(0, clipped_resh)
# weight summaries
temp = tf.trainable_variables()
alignw = [tf.reshape(tensor, [-1]) for tensor in temp[:6]]
alignw = tf.concat(0, alignw)
eyw = [tf.reshape(tensor, [-1]) for tensor in temp[6:8]]
eyw = tf.concat(0, eyw)
how = [tf.reshape(tensor, [-1]) for tensor in temp[8:10]]
how = tf.concat(0, how)
ow = [tf.reshape(tensor, [-1]) for tensor in temp[10:13]]
ow = tf.concat(0, ow)
encw = [tf.reshape(tensor, [-1]) for tensor in temp[13:17]]
encw = tf.concat(0, encw)
decw = [tf.reshape(tensor, [-1]) for tensor in temp[17:19]]
decw = tf.concat(0, decw)
# sum strings
_ = tf.scalar_summary("loss", self._loss)
_ = tf.scalar_summary('global_norm', self._global_norm)
_ = tf.scalar_summary('learning rate', self._learning_rate)
_ = tf.histogram_summary('clipped_gradients', clipped_resh)
_ = tf.histogram_summary('aligner', alignw)
_ = tf.histogram_summary('Y embedding', eyw)
_ = tf.histogram_summary('hidden output layer', how)
_ = tf.histogram_summary('output layer', ow)
_ = tf.histogram_summary('encoder w', encw)
_ = tf.histogram_summary('decoder w', decw)
self._merged = tf.merge_all_summaries()
# include accuracies as summaries
self._train_acc = tf.placeholder(tf.float32, name='train_accuracy')
self._val_acc = tf.placeholder(tf.float32, name='val_accuracy')
self._train_acc_sum = tf.scalar_summary("Training accuracy",
self._train_acc)
self._val_acc_sum = tf.scalar_summary("Validation accuracy",
self._val_acc)
# checkpoint saver
self.saver = tf.train.Saver(tf.all_variables())
self.vars_to_init = set(tf.all_variables()) - set(
tf.trainable_variables())
self.saver = tf.train.Saver(tf.trainable_variables())
def __init__(self, config):
# Maps' feature dictionary
self._map_feature_dict = get_landmark_set(
self._maps['grid']) # all featureas are the same for each map
self._map_objects_dict = get_objects_set(self._maps['grid'])
self._batch_size = config.batch_size
self._encoder_unrollings = config.encoder_unrollings
self._decoder_unrollings = config.decoder_unrollings
self._num_actions = config.num_actions
self._vocab_size = config.vocab_size
self._y_size = 4 * len(self._map_feature_dict) + len(
self._map_objects_dict)
# Model parameters
self._n_hidden = config.num_nodes # same for encoder and decoder
self._embedding_world_state_size = config.embedding_world_state_size
self._init_learning_rate = tf.constant(config.learning_rate)
self._learning_rate = self._init_learning_rate
self._learning_rate_decay_factor = config.learning_rate_decay_factor
self._max_gradient_norm = config.max_gradient_norm
# debug parameters
self._train_dir = "tmp/" # dir where checkpoint files will be saves
# merging and writing vars
self._writer = None
# Dropout rate
keep_prob = config.dropout_rate
## TRAINING Placeholders
self._encoder_inputs = []
self._decoder_outputs = []
self._world_state_vectors = [
] # original sample structure, containing complete path, start_pos, end_pos, and map name
for i in xrange(self._encoder_unrollings):
self._encoder_inputs.append(
tf.placeholder(tf.float32,
shape=[self._batch_size, self._vocab_size],
name='x'))
for i in xrange(self._decoder_unrollings):
self._decoder_outputs.append(
tf.placeholder(tf.int32,
shape=[self._batch_size],
name='actions'))
self._world_state_vectors.append(
tf.placeholder(tf.float32,
shape=[self._batch_size, self._y_size],
name='world_vect'))
## TESTING / VALIDATION Placeholders
self._test_encoder_inputs = []
for i in xrange(self._encoder_unrollings):
self._test_encoder_inputs.append(
tf.placeholder(tf.float32,
shape=[1, self._vocab_size],
name='test_x'))
self._test_decoder_output = tf.placeholder(
tf.float32, shape=[1, self._num_actions], name='test_action_t')
self._test_st = tf.placeholder(tf.float32, [1, self._n_hidden],
name='test_st')
self._test_ct = tf.placeholder(tf.float32, [1, self._n_hidden],
name='test_ct')
self._test_yt = tf.placeholder(tf.float32, [1, self._y_size],
name='test_yt')
with tf.name_scope('Weights') as scope:
# Alignment model weights
W_a = tf.Variable(tf.truncated_normal(
[self._n_hidden, self._n_hidden], -0.1, 0.1),
name='W_a')
U_a = tf.Variable(tf.truncated_normal(
[self._vocab_size, self._n_hidden], -0.1, 0.1),
name='U_a')
V_a = tf.Variable(tf.truncated_normal(
[2 * self._n_hidden, self._n_hidden], -0.1, 0.1),
name='V_a')
v_a = tf.Variable(tf.truncated_normal([self._n_hidden, 1], -0.1,
0.1),
name='v_a')
tanh_bias_a = tf.Variable(tf.truncated_normal([1, 1], -0.1, 0.1),
name='tanh_bias_a')
bias_a = tf.Variable(tf.zeros([1, self._n_hidden]),
name='linear_bias_a')
## Decoder variables
# Input gate: input, previous output, context vector, and bias.
ix = tf.Variable(tf.truncated_normal(
[self._embedding_world_state_size, self._n_hidden], -0.1, 0.1),
name='ix')
im = tf.Variable(tf.truncated_normal(
[self._n_hidden, self._n_hidden], -0.1, 0.1),
name='ih')
iz = tf.Variable(tf.truncated_normal(
[2 * self._n_hidden + self._vocab_size, self._n_hidden], -0.1,
0.1),
name='iz')
ib = tf.Variable(tf.zeros([1, self._n_hidden]), name='ib')
# Forget gate: input, previous output, context vector, and bias.
fx = tf.Variable(tf.truncated_normal(
[self._embedding_world_state_size, self._n_hidden], -0.1, 0.1),
name='fx')
fm = tf.Variable(tf.truncated_normal(
[self._n_hidden, self._n_hidden], -0.1, 0.1),
name='fh')
fz = tf.Variable(tf.truncated_normal(
[2 * self._n_hidden + self._vocab_size, self._n_hidden], -0.1,
0.1),
name='fz')
fb = tf.Variable(tf.zeros([1, self._n_hidden]), name='fb')
# Memory cell: input, state, context vector, and bias.
gx = tf.Variable(tf.truncated_normal(
[self._embedding_world_state_size, self._n_hidden], -0.1, 0.1),
name='cx')
gm = tf.Variable(tf.truncated_normal(
[self._n_hidden, self._n_hidden], -0.1, 0.1),
name='cc')
gz = tf.Variable(tf.truncated_normal(
[2 * self._n_hidden + self._vocab_size, self._n_hidden], -0.1,
0.1),
name='cz')
gb = tf.Variable(tf.zeros([1, self._n_hidden]), name='cb')
# Output gate: input, previous output, context vector, and bias.
ox = tf.Variable(tf.truncated_normal(
[self._embedding_world_state_size, self._n_hidden], -0.1, 0.1),
name='ox')
om = tf.Variable(tf.truncated_normal(
[self._n_hidden, self._n_hidden], -0.1, 0.1),
name='oh')
oz = tf.Variable(tf.truncated_normal(
[2 * self._n_hidden + self._vocab_size, self._n_hidden], -0.1,
0.1),
name='oz')
ob = tf.Variable(tf.zeros([1, self._n_hidden]), name='ob')
# Embedding weight
w_emby = tf.Variable(tf.truncated_normal(
[self._y_size, self._embedding_world_state_size], -0.1, 0.1),
name='Ey_w')
b_emby = tf.Variable(tf.zeros(
[1, self._embedding_world_state_size]),
name='Ey_b')
# Encoder - decoder transition
w_trans_s = tf.Variable(tf.truncated_normal(
[self._n_hidden, self._n_hidden], -0.1, 0.1),
name='w_trans_s')
b_trans_s = tf.Variable(tf.zeros([1, self._n_hidden]),
name='b_trans_s')
w_trans_c = tf.Variable(tf.truncated_normal(
[self._n_hidden, self._n_hidden], -0.1, 0.1),
name='w_trans_c')
b_trans_c = tf.Variable(tf.zeros([1, self._n_hidden]),
name='b_trans_c')
# Action Classifier weights and biases.
ws = tf.Variable(tf.truncated_normal(
[self._n_hidden, self._embedding_world_state_size], -0.1, 0.1),
name='ws')
wz = tf.Variable(tf.truncated_normal([
2 * self._n_hidden + self._vocab_size,
self._embedding_world_state_size
], -0.1, 0.1),
name='wz')
wo = tf.Variable(tf.truncated_normal(
[self._embedding_world_state_size, self._num_actions], -0.1,
0.1),
name='wo')
b_q = tf.Variable(tf.zeros([1, self._embedding_world_state_size]),
name='bq')
b_o = tf.Variable(tf.zeros([1, self._num_actions]), name='bo')
#######################################################################################################################
## Encoder
with tf.name_scope('Encoder') as scope:
lstm_fw_cell = tf.nn.rnn_cell.BasicLSTMCell(
self._n_hidden, forget_bias=1.0, input_size=self._vocab_size)
lstm_bw_cell = tf.nn.rnn_cell.BasicLSTMCell(
self._n_hidden, forget_bias=1.0, input_size=self._vocab_size)
def encoder(encoder_inputs,
batch_size=self._batch_size,
is_training=True):
fw_cell = lstm_fw_cell
bw_cell = lstm_bw_cell
if is_training and keep_prob < 1.0:
fw_cell = tf.nn.rnn_cell.DropoutWrapper(
fw_cell, output_keep_prob=keep_prob)
bw_cell = tf.nn.rnn_cell.DropoutWrapper(
bw_cell, output_keep_prob=keep_prob)
h, c1, h1 = bidirectional_rnn(
fw_cell,
bw_cell,
encoder_inputs,
dtype=tf.float32,
sequence_length=self._encoder_unrollings *
tf.ones([batch_size], tf.int64))
return h, c1, h1
def decoder_cell(i, o, z, c_prev):
input_gate = tf.sigmoid(
tf.matmul(i, ix) + tf.matmul(o, im) + tf.matmul(z, iz) + ib)
forget_gate = tf.sigmoid(
tf.matmul(i, fx) + tf.matmul(o, fm) + tf.matmul(z, fz) + fb)
output_gate = tf.sigmoid(
tf.matmul(i, ox) + tf.matmul(o, om) + tf.matmul(z, oz) + ob)
# gt
update = tf.tanh(
tf.matmul(i, gx) + tf.matmul(o, gm) + tf.matmul(z, gz) + gb)
# ct
c_t = forget_gate * c_prev + input_gate * update
s_t = output_gate * tf.tanh(c_t)
return s_t, c_t
# Alignment model
with tf.name_scope('Aligner') as scope:
def context_vector(s_prev, h_encoder, ux_vh, encoder_inputs,
batch_size):
# alignment model
beta = [
tf.matmul(tf.tanh(tf.matmul(s_prev, W_a) + u_v + bias_a),
v_a) + tanh_bias_a for u_v in ux_vh
]
beta = tf.concat(1, beta, name='beta')
# weights of each (xj,hj)
alpha = tf.nn.softmax(
beta) # shape: batch_size x encoder_unroll
alpha = tf.split(
1, self._encoder_unrollings, alpha, name='alpha'
) # list of unrolling, each elmt of shape [batch_size x 1]
z_t = tf.Variable(tf.zeros(
[batch_size, 2 * self._n_hidden + self._vocab_size]),
name='z_t')
for j in xrange(self._encoder_unrollings):
xh = tf.concat(1, [encoder_inputs[j], h_encoder[j]],
name='xhj') # (x_j, h_j)
z_t += alpha[j] * xh
return z_t
def precalc_Ux_Vh(encoder_inputs, h_enc):
ux_vh = []
for i in xrange(self._encoder_unrollings):
ux_vh.append(
tf.matmul(encoder_inputs[i], U_a) +
tf.matmul(h_enc[i], V_a))
return ux_vh
#######################################################################################################################
def model_encoder_decoder(encoder_inputs, world_state_vectors,
batch_size):
h_encoder, c1, h1 = encoder(encoder_inputs)
U_V_precalc = precalc_Ux_Vh(encoder_inputs, h_encoder)
## Decoder loop
with tf.name_scope('Decoder') as scope:
# Initial states
s_t = tf.tanh(tf.matmul(h1, w_trans_s) + b_trans_s, name='s_0')
c_t = tf.tanh(tf.matmul(c1, w_trans_c) + b_trans_c, name='c_0')
# Definition of the cell computation.
logits = [] # logits per rolling
predictions = []
for i in xrange(self._decoder_unrollings):
# world state vector at step i
y_t = world_state_vectors[
i] # batch_size x num_local_feats (feat_id format)
# embeed world vector | relu nodes
ey = tf.nn.relu(tf.matmul(y_t, w_emby) + b_emby, name='Ey')
# context vector
z_t = context_vector(s_t, h_encoder, U_V_precalc,
encoder_inputs, batch_size)
# Dropout
ey = tf.nn.dropout(ey, keep_prob)
s_t, c_t = decoder_cell(ey, s_t, z_t, c_t)
s_t = tf.nn.dropout(s_t, keep_prob)
# Hidden linear layer before output, proyects z_t,y_t, and s_t to an embeeding-size layer
hq = ey + tf.matmul(s_t, ws) + tf.matmul(z_t, wz) + b_q
# Output layer
logit = tf.matmul(hq, wo) + b_o
prediction = tf.nn.softmax(logit, name='prediction')
logits.append(logit)
predictions.append(prediction)
#END-FOR-DECODER-UNROLLING
#END-DECODER-SCOPE
return logits, predictions
#END-MODEL
with tf.variable_scope('Train_test_pipeline') as scope:
logits, self._train_predictions = model_encoder_decoder(
self._encoder_inputs,
self._world_state_vectors,
batch_size=self._batch_size)
scope.reuse_variables()
self._loss = tf.nn.seq2seq.sequence_loss(
logits,
targets=self._decoder_outputs,
weights=[
tf.ones(shape=[self._batch_size], dtype=tf.float32)
for _ in range(self._decoder_unrollings)
],
name='train_loss')
# Optimizer setup
self._global_step = tf.Variable(0, trainable=False)
"""
self._learning_rate = tf.train.exponential_decay(self._init_learning_rate,
self._global_step,
5000,
self._learning_rate_decay_factor,
staircase=True)
"""
# debug variables
params = tf.trainable_variables()
#optimizer = tf.train.GradientDescentOptimizer(self._learning_rate)
optimizer = tf.train.AdamOptimizer(
learning_rate=self._init_learning_rate, epsilon=1e-4)
# Gradient clipping
gradients, v = zip(
*optimizer.compute_gradients(self._loss, params))
self._clipped_gradients, self._global_norm = tf.clip_by_global_norm(
gradients, self._max_gradient_norm)
# Apply clipped gradients
self._optimizer = optimizer.apply_gradients(
zip(self._clipped_gradients, v), global_step=self._global_step)
##############################################################################################################
## Testing
test_h, c1, h1 = encoder(self._test_encoder_inputs, 1, False)
self._test_s0 = tf.tanh(tf.matmul(h1, w_trans_s), name='test_s0')
self._test_c0 = tf.tanh(tf.matmul(c1, w_trans_c) + b_trans_c,
name='test_c0')
test_ux_vh = precalc_Ux_Vh(self._test_encoder_inputs, test_h)
# embeed world vector | relu nodes
ey = tf.nn.relu(tf.matmul(self._test_yt, w_emby) + b_emby,
name='Ey_test')
# context vector
z_t = context_vector(self._test_st, test_h, test_ux_vh,
self._test_encoder_inputs, 1)
self._next_st, self._next_ct = decoder_cell(
ey, self._test_st, z_t, self._test_ct)
# Hidden linear layer before output, proyects z_t,y_t, and s_t to an embeeding-size layer
hq = ey + tf.matmul(self._next_st, ws) + tf.matmul(z_t, wz) + b_q
logit = tf.matmul(hq, wo) + b_o
self._test_prediction = tf.nn.softmax(logit, name='inf_prediction')
self._test_loss = tf.nn.softmax_cross_entropy_with_logits(
logit, self._test_decoder_output, name="test_loss")
# Summaries
clipped_resh = [
tf.reshape(tensor, [-1]) for tensor in self._clipped_gradients
]
clipped_resh = tf.concat(0, clipped_resh)
_ = tf.scalar_summary("loss", self._loss)
_ = tf.scalar_summary('global_norm', self._global_norm)
_ = tf.scalar_summary('learning rate', self._learning_rate)
_ = tf.histogram_summary('clipped_gradients', clipped_resh)
# checkpoint saver
#self.saver = tf.train.Saver(tf.all_variables())
self._merged = tf.merge_all_summaries()
def __init__(self, config, is_training=True):
# Maps' feature dictionary
self._map_feature_dict = get_landmark_set(self._maps['grid']) # all featureas are the same for each map
self._map_objects_dict = get_objects_set(self._maps['grid'])
self._max_encoder_unrollings = config.encoder_unrollings
self._max_decoder_unrollings = config.decoder_unrollings
self._num_actions = config.num_actions
self._vocab_size = config.vocab_size
self._y_size = 4*len(self._map_feature_dict) + len(self._map_objects_dict)
# Model parameters
self._n_hidden = config.num_nodes # same for encoder and decoder
self._embedding_world_state_size = config.embedding_world_state_size
self._init_learning_rate = tf.constant(config.learning_rate)
self._learning_rate = self._init_learning_rate
self._learning_rate_decay_factor = config.learning_rate_decay_factor
self._max_gradient_norm = config.max_gradient_norm
# debug parameters
self._train_dir = "tmp/" # dir where checkpoint files will be saves
# merging and writing vars
self._writer = None
# Dropout rate
keep_prob = config.dropout_rate
## TRAINING Placeholders
self._encoder_inputs = []
self._encoder_unrollings = tf.placeholder('int64')
self._decoder_outputs = []
self._decoder_unrollings = tf.placeholder('int64')
self._world_state_vectors = [] # original sample structure, containing complete path, start_pos, end_pos, and map name
for i in xrange(self._max_encoder_unrollings):
self._encoder_inputs.append( tf.placeholder(tf.float32,shape=[1,self._vocab_size], name='x') )
for i in xrange(self._max_decoder_unrollings):
self._decoder_outputs.append( tf.placeholder(tf.int32,shape=[1], name='actions') )
self._world_state_vectors.append( tf.placeholder(tf.float32,shape=[1,self._y_size], name='world_vect') )
## TESTING / VALIDATION Placeholders
self._test_st = tf.placeholder(tf.float32, [1, self._n_hidden], name='test_st')
self._test_ct = tf.placeholder(tf.float32, [1, self._n_hidden], name='test_ct')
self._test_yt = tf.placeholder(tf.float32, [1, self._y_size], name='test_yt')
self._test_decoder_output = tf.placeholder(tf.float32,shape=[1,self._num_actions], name='test_action')
with tf.name_scope('Weights') as scope:
# Alignment model weights
W_a = tf.Variable(weight_initializer([self._n_hidden , self._n_hidden]), name='W_a')
U_a = tf.Variable(weight_initializer([self._vocab_size, self._n_hidden]), name='U_a')
V_a = tf.Variable(weight_initializer([2*self._n_hidden, self._n_hidden]), name='V_a')
v_a = tf.Variable(weight_initializer([self._n_hidden ,1]), name='v_a')
tanh_bias_a = tf.Variable(weight_initializer([1,1]), name='tanh_bias_a')
bias_a = tf.Variable(tf.zeros([1, self._n_hidden]), name='linear_bias_a')
# Embedding weight
w_emby = tf.Variable(weight_initializer([self._y_size,self._embedding_world_state_size]), name='Ey_w')
b_emby = tf.Variable(tf.zeros([1, self._embedding_world_state_size]), name='Ey_b')
"""
# Encoder - decoder transition
w_trans_s = tf.Variable(tf.truncated_normal([self._n_hidden, self._n_hidden], -0.1, 0.1), name='w_trans_s')
b_trans_s = tf.Variable(tf.zeros([1,self._n_hidden ]), name='b_trans_s')
w_trans_c = tf.Variable(tf.truncated_normal([self._n_hidden, self._n_hidden], -0.1, 0.1), name='w_trans_c')
b_trans_c = tf.Variable(tf.zeros([1,self._n_hidden ]), name='b_trans_c')
"""
# Action Classifier weights and biases.
ws = tf.Variable(weight_initializer([self._n_hidden , self._embedding_world_state_size]), name='ws')
wz = tf.Variable(weight_initializer([2*self._n_hidden + self._vocab_size, self._embedding_world_state_size]), name='wz')
wo = tf.Variable(weight_initializer([self._embedding_world_state_size , self._num_actions ]), name='wo')
b_q = tf.Variable(tf.zeros([1,self._embedding_world_state_size ]), name='bq')
b_o = tf.Variable(tf.zeros([1,self._num_actions ]), name='bo')
#######################################################################################################################
## Encoder
with tf.variable_scope('Encoder') as scope:
fw_cell = CustomLSTMCell(self._n_hidden, forget_bias=1.0, input_size=self._vocab_size)
bw_cell = CustomLSTMCell(self._n_hidden, forget_bias=1.0, input_size=self._vocab_size)
fw_cell_dp = tf.nn.rnn_cell.DropoutWrapper(
fw_cell, output_keep_prob=keep_prob)
bw_cell_dp = tf.nn.rnn_cell.DropoutWrapper(
bw_cell, output_keep_prob=keep_prob)
h_encoder,c1h1 = bidirectional_rnn(fw_cell_dp,bw_cell_dp,
self._encoder_inputs,
dtype=tf.float32,
sequence_length = self._encoder_unrollings*tf.ones([1],tf.int64),
scope='Encoder'
)
#END-ENCODER-SCOPE
#######################################################################################################################
# Alignment model
with tf.name_scope('Aligner') as scope:
def context_vector(s_prev,h_encoder,ux_vh,encoder_inputs):
# alignment model
beta = []
for i in xrange(self._max_encoder_unrollings):
beta.append( tf.cond( tf.less(tf.constant(i,dtype=tf.int64),self._encoder_unrollings),
lambda: tf.matmul(tf.tanh(tf.matmul(s_prev,W_a) + ux_vh[i] + bias_a),v_a) + tanh_bias_a,
lambda: tf.zeros([1,1])
)
)
beta = tf.concat(1,beta, name='beta')
# weights of each (xj,hj)
alpha = tf.nn.softmax(beta) # shape: batch_size x encoder_unroll
alpha = tf.split(1,self._max_encoder_unrollings,alpha, name='alpha') # list of unrolling, each elmt of shape [batch_size x 1]
z_t = tf.zeros([1 , 2*self._n_hidden + self._vocab_size])
for j in xrange(self._max_encoder_unrollings):
xh = tf.cond( tf.less(tf.constant(j,dtype=tf.int64),self._encoder_unrollings),
lambda: tf.concat(1,[encoder_inputs[j],h_encoder[j]], name='xhj'), # (x_j, h_j)
lambda: tf.zeros([1,2*self._n_hidden + self._vocab_size])
)
z_t += alpha[j] * xh
return z_t
def precalc_Ux_Vh(encoder_inputs,h_enc):
ux_vh = []
for i in xrange(self._max_encoder_unrollings):
ux_vh.append( tf.cond( tf.less(tf.constant(i,dtype=tf.int64),self._encoder_unrollings),
lambda: tf.matmul(encoder_inputs[i],U_a) + tf.matmul(h_enc[i],V_a),
lambda: tf.zeros([1,self._n_hidden])
)
)
return ux_vh
U_V_precalc = precalc_Ux_Vh(self._encoder_inputs,h_encoder)
#######################################################################################################################
## Decoder loop
with tf.variable_scope('Decoder') as scope:
dec_cell = CustomLSTMCell(self._n_hidden, forget_bias=1.0, input_size=self._vocab_size)
dec_cell_dp = tf.nn.rnn_cell.DropoutWrapper(
dec_cell, output_keep_prob=keep_prob)
# Initial states
#s_t = tf.tanh( tf.matmul(h1,w_trans_s)+b_trans_s , name='s_0')
#c_t = tf.tanh( tf.matmul(c1,w_trans_c)+b_trans_c , name='c_0')
c_t,s_t = tf.split(1,2,c1h1)
state = c1h1
logits = [] # logits per rolling
self._train_predictions = []
for i in xrange(self._max_decoder_unrollings):
if i > 0: tf.get_variable_scope().reuse_variables()
# world state vector at step i
y_t = tf.cond( tf.less(tf.constant(i,dtype=tf.int64),self._decoder_unrollings),
lambda: self._world_state_vectors[i], # batch_size x num_local_feats (feat_id format)
lambda: tf.zeros([1,self._y_size])
)
# embeed world vector | relu nodes
ey = tf.nn.relu(tf.matmul(y_t,w_emby) + b_emby, name='Ey')
# run attention mechanism
z_t = context_vector(s_t,h_encoder,U_V_precalc,self._encoder_inputs)
# merge inputs and attention prev state
dec_input = tf.concat(1,[ey,z_t])
s_t,state = dec_cell_dp(dec_input,state,scope="CustomLSTMCell")
# Hidden linear layer before output, proyects z_t,y_t, and s_t to an embeeding-size layer
hq = ey + tf.matmul(s_t,ws) + tf.matmul(z_t,wz) + b_q
# Output layer
logit = tf.matmul(hq,wo) + b_o
fill_pred = tf.constant([[0.,0.,0.,0.,1.]]) # one-hot vector for PAD
prediction = tf.cond( tf.less(tf.constant(i,dtype=tf.int64),self._decoder_unrollings),
lambda: tf.nn.softmax(logit,name='prediction'),
lambda: fill_pred
)
logits.append(logit)
self._train_predictions.append(prediction)
#END-FOR-DECODER-UNROLLING
# Loss definition
reshaped_dec_outputs = []
for i in xrange(self._max_decoder_unrollings):
out = tf.cond( tf.less(tf.constant(i,dtype=tf.int64),self._decoder_unrollings),
lambda: self._decoder_outputs[i],
lambda: 4*tf.ones([1],dtype=tf.int32)
)
reshaped_dec_outputs.append(out)
self._loss = tf.nn.seq2seq.sequence_loss(logits,
targets=reshaped_dec_outputs,
weights=[tf.ones([1],dtype=tf.float32)]*self._max_decoder_unrollings,
#np.ones(shape=(self._max_decoder_unrollings,1),dtype=np.float32),
name='train_loss')
###################################################################################################################
# TESTING
with tf.variable_scope('Encoder',reuse=True) as scope:
test_h,c1h1 = bidirectional_rnn(fw_cell,bw_cell,
self._encoder_inputs,
dtype=tf.float32,
sequence_length = self._encoder_unrollings*tf.ones([1],tf.int64),
scope='Encoder'
)
#self._test_s0 = tf.tanh( tf.matmul(h1,w_trans_s)+b_trans_s, name='test_s0')
#self._test_c0 = tf.tanh( tf.matmul(c1,w_trans_c)+b_trans_c, name='test_c0')
self._test_c0,self._test_s0 = tf.split(1,2,c1h1)
test_ux_vh = precalc_Ux_Vh(self._encoder_inputs,test_h)
with tf.variable_scope('Decoder',reuse=True) as scope:
# embeed world vector | relu nodes
ey = tf.nn.relu(tf.matmul(self._test_yt,w_emby) + b_emby, name='Ey_test')
# context vector
z_t = context_vector(self._test_st,test_h,test_ux_vh,self._encoder_inputs)
state = tf.concat(1,[self._test_ct,self._test_st])
dec_input = tf.concat(1,[ey,z_t])
_,temp = dec_cell(dec_input, state,scope="CustomLSTMCell")
self._next_ct,self._next_st = tf.split(1,2,temp)
# Hidden linear layer before output, proyects z_t,y_t, and s_t to an embeeding-size layer
hq = ey + tf.matmul(self._next_st,ws) + tf.matmul(z_t,wz) + b_q
logit = tf.matmul(hq,wo) + b_o
self._test_prediction = tf.nn.softmax(logit,name='inf_prediction')
# Loss definition
self._test_loss = tf.nn.softmax_cross_entropy_with_logits(logit,self._test_decoder_output, name="test_loss")
#END-DECODER-SCOPE
with tf.variable_scope('Optimization') as scope:
# Optimizer setup
self._global_step = tf.Variable(0,trainable=False)
self._learning_rate = tf.train.exponential_decay(self._init_learning_rate,
self._global_step,
80000,
self._learning_rate_decay_factor,
staircase=True)
#optimizer = tf.train.GradientDescentOptimizer(self._learning_rate)
optimizer = tf.train.AdamOptimizer(learning_rate=self._learning_rate,
epsilon=1e-1)
# Gradient clipping
#gradients = tf.gradients(self._loss,params)
gradients,params = zip(*optimizer.compute_gradients(self._loss))
self._clipped_gradients, self._global_norm = tf.clip_by_global_norm(gradients, self._max_gradient_norm)
# Apply clipped gradients
self._optimizer = optimizer.apply_gradients( zip(self._clipped_gradients, params) , global_step=self._global_step )
with tf.name_scope('Summaries') as scope:
# Summaries
clipped_resh = [tf.reshape(tensor,[-1]) for tensor in self._clipped_gradients if tensor]
clipped_resh = tf.concat(0,clipped_resh)
# weight summaries
temp = tf.trainable_variables()
alignw = [tf.reshape(tensor,[-1]) for tensor in temp[:6]]
alignw = tf.concat(0,alignw)
eyw = [tf.reshape(tensor,[-1]) for tensor in temp[6:8]]
eyw = tf.concat(0,eyw)
how = [tf.reshape(tensor,[-1]) for tensor in temp[8:10]]
how = tf.concat(0,how)
ow = [tf.reshape(tensor,[-1]) for tensor in temp[10:13]]
ow = tf.concat(0,ow)
encw = [tf.reshape(tensor,[-1]) for tensor in temp[13:17]]
encw = tf.concat(0,encw)
decw = [tf.reshape(tensor,[-1]) for tensor in temp[17:19]]
decw = tf.concat(0,decw)
# sum strings
_ = tf.scalar_summary("loss",self._loss)
_ = tf.scalar_summary('global_norm',self._global_norm)
_ = tf.scalar_summary('learning rate',self._learning_rate)
_ = tf.histogram_summary('clipped_gradients', clipped_resh)
_ = tf.histogram_summary('aligner', alignw)
_ = tf.histogram_summary('Y embedding', eyw)
_ = tf.histogram_summary('hidden output layer', how)
_ = tf.histogram_summary('output layer', ow)
_ = tf.histogram_summary('encoder w', encw)
_ = tf.histogram_summary('decoder w', decw)
self._merged = tf.merge_all_summaries()
# include accuracies as summaries
self._train_acc = tf.placeholder(tf.float32,name='train_accuracy')
self._val_acc = tf.placeholder(tf.float32,name='val_accuracy')
self._train_acc_sum = tf.scalar_summary("Training accuracy",self._train_acc)
self._val_acc_sum = tf.scalar_summary("Validation accuracy",self._val_acc)
# checkpoint saver
self.saver = tf.train.Saver(tf.all_variables())
self.vars_to_init = set(tf.all_variables()) - set(tf.trainable_variables())
self.saver = tf.train.Saver(tf.trainable_variables())
