def predict(self, word_indices, char_indices, task_id, train=False):
"""
predict tags for a sentence represented as char+word embeddings
"""
pycnn.renew_cg() # new graph
char_emb = []
rev_char_emb = []
# get representation for words
for chars_of_token in char_indices:
# use last state as word representation
last_state = self.char_rnn.predict_sequence([self.cembeds[c] for c in chars_of_token])[-1]
rev_last_state = self.char_rnn.predict_sequence([self.cembeds[c] for c in reversed(chars_of_token)])[-1]
char_emb.append(last_state)
rev_char_emb.append(rev_last_state)
wfeatures = [self.wembeds[w] for w in word_indices]
features = [pycnn.concatenate([w,c,rev_c]) for w,c,rev_c in zip(wfeatures,char_emb,reversed(rev_char_emb))]
if train: # only do at training time
features = [pycnn.noise(fe,self.noise_sigma) for fe in features]
output_expected_at_layer = self.predictors["task_expected_at"][task_id]
output_expected_at_layer -=1
# go through layers
# input is now combination of w + char emb
prev = features
num_layers = self.h_layers
# for i in range(0,num_layers-1):
for i in range(0,num_layers):
predictor = self.predictors["inner"][i]
forward_sequence, backward_sequence = predictor.predict_sequence(prev)
if i > 0 and self.activation:
# activation between LSTM layers
forward_sequence = [self.activation(s) for s in forward_sequence]
backward_sequence = [self.activation(s) for s in backward_sequence]
if i == output_expected_at_layer:
output_predictor = self.predictors["output_layers_dict"][task_id]
concat_layer = [pycnn.concatenate([f, b]) for f, b in zip(forward_sequence,reversed(backward_sequence))]
if train and self.noise_sigma > 0.0:
concat_layer = [pycnn.noise(fe,self.noise_sigma) for fe in concat_layer]
output = output_predictor.predict_sequence(concat_layer)
return output
prev = forward_sequence
prev_rev = backward_sequence # not used
raise "oops should not be here"
return None
def build_tagging_graph(word_indices, model, builder):
"""
build the computational graph
:param word_indices: list of indices
:param model: current model to access parameters
:param builder: builder to create state combinations
:return: forward and backward sequence
"""
pycnn.renew_cg()
f_init = builder.initial_state()
# retrieve embeddings from the model and add noise
word_embeddings = [pycnn.lookup(model["word_lookup"], w) for w in word_indices]
word_embeddings = [pycnn.noise(we, args.noise) for we in word_embeddings]
# compute the expressions for the forward pass
forward_sequence = [x.output() for x in f_init.add_inputs(word_embeddings)]
return forward_sequence
def build_tagging_graph(words, model, builders):
"""
build the computational graph
:param words: list of indices
:param model: current model to access parameters
:param builders: builder to create state combinations
:return: forward and backward sequence
"""
pycnn.renew_cg()
f_init, b_init = [b.initial_state() for b in builders]
# retrieve embeddings from the model and add noise
word_embeddings = [pycnn.lookup(model["lookup"], w) for w in words]
word_embeddings = [pycnn.noise(we, 0.1) for we in word_embeddings]
# compute the expressions for the forward and backward pass
forward_sequence = [x.output() for x in f_init.add_inputs(word_embeddings)]
backward_sequence = [x.output() for x in b_init.add_inputs(reversed(word_embeddings))]
return list(zip(forward_sequence, reversed(backward_sequence)))