def cl_loss_from_embedding(self,embedded,return_intermediate=False):
self.reshape_input = tf.concat([tf.reshape(self.input_data,[-1,self.args.word_dim]),tf.constant(np.zeros((1,self.args.word_dim),dtype=np.float32))],0)
input_f1 = tf.nn.l2_normalize(tf.reduce_sum(tf.nn.embedding_lookup(self.reshape_input,self.entMentIndex),1),1)
print 'input_f1:',input_f1
input_f2,_,_ =self.layers['BiLSTM'](tf.nn.embedding_lookup(self.reshape_input,self.entCtxLeftIndex))
input_f2 = tf.nn.l2_normalize(tf.reduce_sum(input_f2,1),1)
print 'input_f2:',input_f2
input_f3,_,_ = self.layers['BiLSTM'](tf.nn.embedding_lookup(self.reshape_input,self.entCtxRightIndex))
input_f3 = tf.nn.l2_normalize(tf.reduce_sum(input_f3,1),1)
print 'input_f2:',input_f3
self.input_total = tf.nn.sigmoid(tf.concat([input_f1,input_f2,input_f3],1))
if self.args.dropout:
self.input_total = tf.nn.dropout(self.input_total,self.keep_prob)
prediction =self.layers['fullyConnect'](self.input_total,tf.nn.sigmoid)
loss = tf.reduce_mean(layers_lib.classification_loss('figer',self.dense_outputdata,prediction))
return prediction,loss
def cl_loss_from_embedding(self,
embedded,
inputs=None,
return_intermediates=False):
"""Compute classification loss from embedding.
Args:
embedded: 3-D float Tensor [batch_size, num_timesteps, embedding_dim]
inputs: VatxtInput, defaults to self.cl_inputs.
return_intermediates: bool, whether to return intermediate tensors or only
the final loss.
Returns:
If return_intermediates is True:
lstm_out, next_state, logits, loss
Else:
loss
"""
if inputs is None:
inputs = self.cl_inputs
lstm_out, next_state = self.layers['lstm'](embedded, inputs.state,
inputs.length)
logits = self.layers['cl_logits'](lstm_out)
loss = layers_lib.classification_loss(logits, inputs.labels, inputs.weights)
if return_intermediates:
return lstm_out, next_state, logits, loss
else:
return loss
def cl_loss_from_embedding(self,embedded,return_intermediate=False):
with tf.device('/gpu:0'):
output = tf.concat([tf.reshape(self.input_data,[-1,self.args.word_dim]),tf.constant(np.zeros((1,self.args.word_dim),dtype=np.float32))],0)
self.input_f1 = tf.nn.embedding_lookup(output,self.entMentIndex)
self.input_f2 = tf.nn.embedding_lookup(output,self.entCtxLeftIndex)
self.input_f3 = tf.nn.embedding_lookup(output,self.entCtxRightIndex)
self.input_f1 = tf.concat([self.input_f1,self.pos_f1],-1)
print 'input_f1:',self.input_f1
self.input_f2 = tf.concat([self.input_f2,self.pos_f2],-1)
print 'input_f2:',self.input_f2
self.input_f3 = tf.concat([self.input_f3,self.pos_f3],-1)
self.h_pool_f1 = self.layers['CNN'](tf.expand_dims(self.input_f1,-1),5)
print 'h_pool_f1:',self.h_pool_f1
self.h_pool_f2 = self.layers['CNN'](tf.expand_dims(self.input_f2,-1),10)
print 'h_pool_f2:',self.h_pool_f2
self.h_pool_f3 = self.layers['CNN'](tf.expand_dims(self.input_f3,-1),10)
print 'h_pool_f3:',self.h_pool_f3
if self.args.dropout:
self.h_pool_f1 = tf.nn.dropout(self.h_pool_f1,self.keep_prob)
self.h_pool_f2 = tf.nn.dropout(self.h_pool_f2,self.keep_prob)
self.h_pool_f3 = tf.nn.dropout(self.h_pool_f3,self.keep_prob)
'''
@final results
'''
self.ctx_input = tf.concat([self.h_pool_f2,self.h_pool_f3],1)
prediction_ctx = self.layers['fullyConnect_ctx'](self.ctx_input,activation_fn=tf.nn.relu) #utilize the relu activative function
prediction_ment = self.layers['fullyConnect_ment'](tf.nn.l2_normalize(self.h_pool_f1,1),activation_fn=tf.nn.relu)
prediction = prediction_ctx + prediction_ment
loss = tf.reduce_mean(layers_lib.classification_loss('figer',self.dense_outputdata,prediction)) #rerank the entities
return prediction,loss
def cl_loss_from_embedding(self,
embedded,
inputs=None,
return_intermediates=False):
"""Compute classification loss from embedding.
Args:
embedded: Length 2 tuple of 3-D float Tensor
[batch_size, num_timesteps, embedding_dim].
inputs: Length 2 tuple of VatxtInput, defaults to self.cl_inputs.
return_intermediates: bool, whether to return intermediate tensors or only
the final loss.
Returns:
If return_intermediates is True:
lstm_out, next_states, logits, loss
Else:
loss
"""
if inputs is None:
inputs = self.cl_inputs
out = []
for (layer_name, emb, inp) in zip(['lstm', 'lstm_reverse'], embedded,
inputs):
out.append(self.layers[layer_name](emb, inp.state, inp.length))
lstm_outs, next_states = zip(*out)
# Concatenate output of forward and reverse LSTMs
lstm_out = tf.concat(lstm_outs, 1)
logits = self.layers['cl_logits'](lstm_out)
f_inputs, _ = inputs # pylint: disable=unpacking-non-sequence
loss = layers_lib.classification_loss(logits, f_inputs.labels,
f_inputs.weights)
if return_intermediates:
return lstm_out, next_states, logits, loss
else:
return loss
def cl_loss_from_embedding(self,
embedded,
inputs=None,
return_intermediates=False):
"""Compute classification loss from embedding.
Args:
embedded: Length 2 tuple of 3-D float Tensor
[batch_size, num_timesteps, embedding_dim].
inputs: Length 2 tuple of VatxtInput, defaults to self.cl_inputs.
return_intermediates: bool, whether to return intermediate tensors or only
the final loss.
Returns:
If return_intermediates is True:
lstm_out, next_states, logits, loss
Else:
loss
"""
if inputs is None:
inputs = self.cl_inputs
out = []
for (layer_name, emb, inp) in zip(['lstm', 'lstm_reverse'], embedded,
inputs):
out.append(self.layers[layer_name](emb, inp.state, inp.length))
lstm_outs, next_states = zip(*out)
# Concatenate output of forward and reverse LSTMs
lstm_out = tf.concat(lstm_outs, 1)
logits = self.layers['cl_logits'](lstm_out)
f_inputs, _ = inputs # pylint: disable=unpacking-non-sequence
loss = layers_lib.classification_loss(logits, f_inputs.labels,
f_inputs.weights)
if return_intermediates:
return lstm_out, next_states, logits, loss
else:
return loss
def cl_loss_from_embedding(self,
embedded,
inputs=None,
return_intermediates=False):
"""Compute classification loss from embedding.
Args:
embedded: 3-D float Tensor [batch_size, num_timesteps, embedding_dim]
inputs: VatxtInput, defaults to self.cl_inputs.
return_intermediates: bool, whether to return intermediate tensors or only
the final loss.
Returns:
If return_intermediates is True:
lstm_out, next_state, logits, loss
Else:
loss
"""
if inputs is None:
inputs = self.cl_inputs
lstm_out, next_state = self.layers['naive_lstm'](embedded,
inputs.state,
inputs.length)
if FLAGS.single_label:
indices = tf.stack([tf.range(FLAGS.batch_size), inputs.length - 1],
1)
lstm_out = tf.expand_dims(tf.gather_nd(lstm_out, indices), 1)
labels = tf.expand_dims(tf.gather_nd(inputs.labels, indices), 1)
weights = tf.expand_dims(tf.gather_nd(inputs.weights, indices), 1)
else:
labels = inputs.labels
weights = inputs.weights
logits = self.layers['cl_logits'](lstm_out)
loss = layers_lib.classification_loss(logits, labels, weights)
if return_intermediates:
return lstm_out, next_state, logits, loss
else:
return loss
def cl_loss_from_embedding(self,embedded,return_intermediate=False):
with tf.device('/gpu:1'):
output,_ = self.layers['BiLSTM'](embedded)
output = tf.concat([tf.reshape(output,[-1,2*self.args.rnn_size]),tf.constant(np.zeros((1,2*self.args.rnn_size),dtype=np.float32))],0)
input_f1 =tf.nn.l2_normalize(tf.reduce_sum(tf.nn.embedding_lookup(output,self.entMentIndex),1),1)
#input_f2 =tf.nn.l2_normalize(tf.reduce_sum(tf.nn.embedding_lookup(output,self.entCtxLeftIndex),1),1)
#input_f3 =tf.nn.l2_normalize(tf.reduce_sum(tf.nn.embedding_lookup(output,self.entCtxRightIndex),1),1)
f2_temp = tf.nn.embedding_lookup(output,self.entCtxLeftIndex)
f3_temp = tf.nn.embedding_lookup(output,self.entCtxRightIndex)
f2_atten = tf.nn.softmax(tf.einsum('aij,ajk->aik', f2_temp, tf.expand_dims(input_f1,-1)),-1) #Batch matrix multiplication
f3_atten = tf.nn.softmax(tf.einsum('aij,ajk->aik', f3_temp, tf.expand_dims(input_f1,-1)),-1)
input_f2 = tf.einsum('aij,ajk->aik',tf.transpose(f2_temp,[0,2,1]),f2_atten)[:,:,0]
input_f3 = tf.einsum('aij,ajk->aik',tf.transpose(f3_temp,[0,2,1]),f3_atten)[:,:,0]
print 'f2_input:',input_f2
print 'f3_input:',input_f3
input_ctx = tf.concat([input_f2,input_f3],1)
if self.args.dropout: #dropout position is here!
input_f1 = tf.nn.dropout(input_f1,self.keep_prob)
input_ctx = tf.nn.dropout(input_ctx,self.keep_prob)
prediction_l1_ment = self.layers['fullyConnect_ment'](input_f1,activation_fn=None)
prediction_ment = tf.matmul(prediction_l1_ment,self.hier)
print 'ment:',prediction_ment
prediction_ctx = self.layers['fullyConnect_ctx'](input_ctx,activation_fn=None)
print 'ctx:',prediction_ctx
prediction = tf.nn.sigmoid(prediction_ment + prediction_ctx)
loss = tf.reduce_mean(layers_lib.classification_loss('figer',self.dense_outputdata,prediction))
return prediction,loss
def cl_loss_from_embedding(self,
embedded,
inputs=None,
return_intermediates=False):
"""Compute classification loss from embedding.
Args:
embedded: 3-D float Tensor [batch_size, num_timesteps, embedding_dim]
inputs: VatxtInput, defaults to self.cl_inputs.
return_intermediates: bool, whether to return intermediate tensors or only
the final loss.
Returns:
If return_intermediates is True:
lstm_out, next_state, logits, loss
Else:
loss
"""
if inputs is None:
inputs = self.cl_inputs
lstm_out, next_state = self.layers['lstm'](embedded, inputs.state,
inputs.length)
if FLAGS.single_label:
indices = tf.stack([tf.range(FLAGS.batch_size), inputs.length - 1], 1)
lstm_out = tf.expand_dims(tf.gather_nd(lstm_out, indices), 1)
labels = tf.expand_dims(tf.gather_nd(inputs.labels, indices), 1)
weights = tf.expand_dims(tf.gather_nd(inputs.weights, indices), 1)
else:
labels = inputs.labels
weights = inputs.weights
logits = self.layers['cl_logits'](lstm_out)
loss = layers_lib.classification_loss(logits, labels, weights)
if return_intermediates:
return lstm_out, next_state, logits, loss
else:
return loss
