def batch_generate_multiword_morph_simple_inv(self,
tagged_information_list,
triple_counts):
print('Running: batch_generate_multiword_morph_simple_inv')
orchestrator = self.orchestrator
save_path = self.config['save_path_generate']
tinput_list = []
tstring_list = []
all_tag_maps = []
all_modified_tag_triples = []
all_tagged_triples = []
debug_file = open(
save_path + '/debug_generate_multiword_morph_simple.txt', 'w')
for tagged_information in tagged_information_list:
tagged_triples = tagged_information['tagged_triples']
modified_tag_triples = tagged_information['modified_tag_triples']
tag_maps = tagged_information['tag_maps']
all_tag_maps.extend(tag_maps)
all_modified_tag_triples.extend(modified_tag_triples)
all_tagged_triples.extend(tagged_triples)
for tt in tagged_triples:
inv_t = list(reversed(tt))
tstring = ' '.join(inv_t)
tstring_list.append(tstring)
tinput = simple.transform_input(tstring, ner=False)
tinput_list.append(tinput)
debug_file.write(tinput.rstrip() + '\n')
debug_file.write('####'.join(tinput_list) + '\n')
generated_list = orchestrator.generate_multiword_morph_simple(
'####'.join(tinput_list))
debug_file.write(generated_list)
generated_list = generated_list.split('####')
print('Len generated_list', len(generated_list))
final_generated_outputs = []
ofile = open(
save_path + '/out_batch_generate_multiword_morph_simple_inv.txt',
'w')
print(len(tstring_list), len(generated_list), len(all_tag_maps),
len(all_tagged_triples))
for tstring, g, tm, tt in zip(tstring_list, generated_list,
all_tag_maps, all_tagged_triples):
inv_tm = list(reversed(tm))
inv_t = list(reversed(tt))
norm_g = simple.normalize_string(tstring, g)
appos_g = orchestrator.add_apostrophe(inv_t, norm_g[1])
g = orchestrator.replaceTokens(g, inv_tm)
final_generated_outputs.append(g)
ofile.write(g + '\n')
ofile.close()
print('len final_generated_outputs ', len(final_generated_outputs))
splitted_final_generated_outputs = self.split_by_count(
final_generated_outputs, triple_counts, True)
return splitted_final_generated_outputs
def generate_multiple(self, texts, use_string_match, use_multi, debug, use_compounding, use_coref):
self.debug = debug
self.return_logs = ''
texts = texts.split('\n')
generated_tag_map = {}
try:
stuplelist = []
sdictlist = []
triples = self.getTriple(texts)
tagged_triples, modified_tag_triples, class_labels, tag_maps = self.tag_triples(triples)
print('######################')
self.log_something('tagged_triples ', tagged_triples)
self.log_something('modified_tag_triples ', modified_tag_triples)
self.log_something('class_labels ', class_labels)
print('######################')
count = 0
for t, tt, mtt, cl, tm in zip(triples, tagged_triples, modified_tag_triples, class_labels, tag_maps):
print(t, tt, mtt, cl, tm)
mtts = ' '.join(mtt)
tts = ' '.join(tt)
output_dict = {}
self.log_something(':######################', count)
count += 1
self.log_something('Triple: ', t)
self.log_something('Tagged Triple: ', tt)
self.log_something('Modified Tagged triple ', mtts)
#generated_knn = self.knnModel.generate(tt, False)
generated_knn = []
knn_outputs = []
for g in generated_knn:
gg = postprocess(g[0], self.nlp)
tagged_generated_version = gg
gg = self.replaceTokens(gg, tm)
generated_tag_map[gg] = tagged_generated_version
knn_outputs.append(gg)
self.log_something('knn_outputs ', knn_outputs)
output_dict['knn'] = knn_outputs
wikirelations_generated_unm = self.get_wiki_outputs(tt)
wikirelations_generated = self.get_wiki_outputs(mtt)
wikirelations_generated_unm , _ = self.lmscorer.rank_kenlm(wikirelations_generated_unm, 5)
wikirelations_generated , _ = self.lmscorer.rank_kenlm(wikirelations_generated, 5)
wikioutputs = []
for o in wikirelations_generated:
oo = self.replaceTokens(o, tm)
wikioutputs.append(oo)
generated_tag_map[oo] = o
wikioutputs_um = []
for o in wikirelations_generated_unm:
oo = self.replaceTokens(o, tm)
wikioutputs.append(oo)
generated_tag_map[oo] = o
logfile.write('Generated from wikirelations ' + str(wikioutputs_um) + '\n')
logfile.write('Generated from wikirelations modified ' + str(wikioutputs) + '\n')
self.log_something(' Generated from wikirelations ', wikioutputs_um)
self.log_something(' Generated from wikirelations modified ', wikioutputs)
output_dict['wikioutputs'] = wikioutputs
output_dict['knn'] = knn_outputs
# tstring = ' '.join(t)
tstring = ' '.join(tt)
tinput = simple.transform_input(tstring, ner=False)
self.log_something('input to s2s multi_morph_simple', tinput)
g = self.generate_multiword_morph_simple(tinput)
self.log_something('generate_from_s2s_multi_morph_simple', g)
norm_g = simple.normalize_string(tstring,g)
self.log_something('verbs generate_from_s2s_multi_morph_simple', norm_g[1])
# g = simple.replace_entities(tstring, norm_g[0])[1]
g = self.add_apostrophe(tt, norm_g[1])
g = self.replaceTokens(g, tm)
iscorrect = is_correct_pattern(g, tt)
# g = self.add_apostrophe(t,g)
g = self.add_apostrophe_preranker(tm, g)
self.log_something('ents generate_from_s2s_multi_morph_simple', g)
output_dict['s2s_multi_morph_simple'] = [g]
generated_tag_map[g] = norm_g[1]
# inv_t = list(reversed(t))
inv_t = list(reversed(tt))
inv_tm = list(reversed(tm))
tstring = ' '.join(inv_t)
tinput = simple.transform_input(tstring, ner=False)
self.log_something('input to s2s multi_morph_simple INV', tinput)
g = self.generate_multiword_morph_simple(tinput)
self.log_something('generate_from_s2s_multi_morph_simple INV', g)
norm_g = simple.normalize_string(tstring,g)
self.log_something('verbs generate_from_s2s_multi_morph_simple INV', norm_g[1])
# g = simple.replace_entities(tstring, norm_g[0])[1]
g = self.add_apostrophe(inv_t,norm_g[1])
g = self.replaceTokens(g, inv_tm)
iscorrect = is_correct_pattern(g, tt, inverse=True)
g = self.add_apostrophe_preranker(tm, g)
self.log_something('ents generate_from_s2s_multi_morph_simple INV', g)
output_dict['s2s_multi_morph_simple_inv'] = [g]
generated_tag_map[g] = norm_g[1]
# tstring = ' '.join(t)
tstring = ' '.join(tt)
tinput = merge.transform_input(tstring, ner=False)
self.log_something('input to s2s morph_merge', tinput[0])
g = self.generate_multiword_morph_merge(tinput[0])
self.log_something('generate_from_s2s_morph_merge', g)
norm_g = merge.normalize_string(tstring, g)
self.log_something('verbs generate_from_s2s_morph_merge', norm_g[1])
# g = merge.replace_entities(tstring, tinput[1], norm_g[0])[1]
# g = self.add_apostrophe(t,g)
g = self.add_apostrophe(tt, norm_g[1])
g = self.replaceTokens(g, tm)
iscorrect = is_correct_pattern(g, tt)
g = self.add_apostrophe_preranker(tm, g)
self.log_something('ents generate_from_s2s_morph_merge', g)
output_dict['s2s_morph_merge'] = [g]
generated_tag_map[g] = norm_g[1]
# inv_t = list(reversed(t))
inv_t = list(reversed(tt))
inv_tm = list(reversed(tm))
tstring = ' '.join(inv_t)
tinput = merge.transform_input(tstring, ner=False)
self.log_something('input to s2s morph_merge INV', tinput[0])
g = self.generate_multiword_morph_merge(tinput[0])
self.log_something('generate_from_s2s_morph_merge INV', g)
norm_g = merge.normalize_string(tstring, g)
self.log_something('verbs generate_from_s2s_morph_merge INV', norm_g[1])
# g = merge.replace_entities(tstring, tinput[1], norm_g[0])[1]
g = self.add_apostrophe(inv_t,norm_g[1])
g = self.replaceTokens(g, inv_tm)
iscorrect = is_correct_pattern(g, tt, inverse=True)
g = self.add_apostrophe_preranker(tm, g)
self.log_something('ents generate_from_s2s_morph_merge INV', g)
output_dict['s2s_morph_merge_inv'] = [g]
generated_tag_map[g] = norm_g[1]
g = self.generate_from_s2s_with_classifier(mtts, cl)
self.log_something('generate_from_s2s_with_classifier ', g)
g = postprocess(g, self.nlp)
tagged_generated_version = g
self.log_something('pp generate_from_s2s_with_classifier ', g)
g = self.replaceTokens(g, tm)
g = self.add_apostrophe(mtt,g)
g = self.add_apostrophe_preranker(tm, g)
self.log_something('rt generate_from_s2s_with_classifier ', g)
output_dict['s2s_classifier'] = [g]
generated_tag_map[g] = tagged_generated_version
g = self.generate_from_s2s_without_classifier(mtts)
self.log_something('generate_from_s2s_without_classifier ', g)
g = postprocess(g, self.nlp)
tagged_generated_version = g
self.log_something('pp generate_from_s2s_without_classifier ', g)
g = self.replaceTokens(g, tm)
g = self.add_apostrophe(mtt,g)
g = self.add_apostrophe_preranker(tm, g)
self.log_something('rt generate_from_s2s_without_classifier ', g)
output_dict['s2s_no_classifier'] = [g]
generated_tag_map[g] = tagged_generated_version
g = self.generate_from_smt(mtts, cl)
self.log_something('generate_from_smt ', g)
g = postprocess(g, self.nlp)
tagged_generated_version = g
self.log_something('pp generate_from_smt ', g)
g = self.replaceTokens(g, tm)
g = self.add_apostrophe(mtt,g)
g = self.add_apostrophe_preranker(tm, g)
self.log_something('rt generate_from_smt ', g)
output_dict['smt_classifier'] = [g]
generated_tag_map[g] = tagged_generated_version
g = self.generate_from_smt_no_class(mtts)
self.log_something('generate_from_smt_no_class ', g)
g = postprocess(g, self.nlp)
tagged_generated_version = g
self.log_something('pp generate_from_smt_no_class ', g)
g = self.replaceTokens(g, tm)
g = self.add_apostrophe(mtt,g)
g = self.add_apostrophe_preranker(tm, g)
self.log_something('rt generate_from_smt_no_class ', g)
output_dict['smt_no_classifier'] = [g]
generated_tag_map[g] = tagged_generated_version
r = mtt[1]
print('******************', len(r.split()), use_multi)
if len(r.split()) > 1 and use_multi:
self.log_something(' ', 'trying multi')
g = self.generate_with_multiword(' || '.join(mtt))
tagged_generated_version = g
self.log_something('generate_with_multiword ', g)
#g = postprocess(g, self.nlp)
#self.log_something('pp generate_with_multiword ', g)
g = self.replaceTokens(g, tm)
g = self.add_apostrophe(mtt, g)
g = self.add_apostrophe_preranker(tm, g)
self.log_something('rt generate_with_multiword ', g)
output_dict['s2s_mw'] = [g]
generated_tag_map[g] = tagged_generated_version
g = self.generate_from_smt_multi(mtts)
tagged_generated_version = g
self.log_something('generate_from_smt_multi ', g)
#g = postprocess(g, self.nlp)
#self.log_something('pp generate_from_smt_multi ', g)
g = self.replaceTokens(g, tm)
g = self.add_apostrophe(mtt,g)
g = self.add_apostrophe_preranker(tm, g)
self.log_something('rt generate_from_smt_multi ', g)
output_dict['smt_mw'] = [g]
generated_tag_map[g] = tagged_generated_version
elif len(r.split()) == 1:
self.log_something(' ', 'trying single s2s')
g = self.generate_with_singleword(mtts)
tagged_generated_version = g
self.log_something('generate_with_singleword ', g)
g = self.replaceTokens(g, tm)
g = self.add_apostrophe(mtt, g)
g = self.add_apostrophe_preranker(tm, g)
self.log_something('rt generate_with_singleword ', g)
output_dict['s2s_sw'] = [g]
generated_tag_map[g] = tagged_generated_version
inp_original = t[0] + '\t' + tt[1] + '\t' + t[2]
inp_modified = t[0] + '\t' + mtt[1] + '\t' + t[2]
inp = [inp_original, inp_modified]
self.log_something('*** Input to ranker ', inp)
self.log_something('output_dict ', output_dict)
o= find_best(inp, output_dict, self.doc_sim, self.nlp, self.lmscorer)
[best_sent,system_tag,max_score] = o
self.log_something('****************************** OUTPUT ***********', '')
self.log_something('output list ', o)
self.log_something('generated_tag_map', generated_tag_map)
tagged_o = generated_tag_map[o[0]]
stuplelist.append((tagged_o, o[0]))
if "inv" in system_tag:
sdictlist.append((reversed(tm), o[0]))
else:
sdictlist.append((tm, o[0]))
self.log_something('sdictlist ', sdictlist)
#oo = stuplelist
#oo = merge_sentences(stuplelist, punctProcess=True)
return_output = ''
if use_compounding:
oo = merge_sentences(sdictlist, punctProcess=True)
sentlist = [e[1] for e in oo]
self.log_something('Merged ', sentlist)
if debug:
return_output = str('\n'.join(sentlist)) + '\n\n\n' + self.return_logs
else:
return_output = str('\n'.join(sentlist))
"""
#out = json.dumps(out, indent=4, sort_keys=True)
"""
if use_coref:
coref_out = [' '.join(self.gendermodel.replace_pronoun(e[0], tag_maps)) for e in oo]
self.log_something('Coreference resolution \n', coref_out)
if debug:
return_output = str('\n'.join(coref_out)) + '\n\n\n' + self.return_logs
else:
return_output = str('\n'.join(coref_out))
return return_output
except Exception, error:
print(str(error))
s = traceback.format_exc()
print(s)
o = self.return_logs + '\n\n' + str(s)
return o
def generate_multiple(self, save_path, texts, use_string_match, use_multi,
debug, use_compounding, use_coref):
self.debug = debug
self.return_logs = ''
#Now text is already a list, this split is required for UI
#texts = texts.split('\n')
generated_tag_map = {}
try:
stuplelist = []
sdictlist = []
triples = self.getTriple(texts)
tagged_triples, modified_tag_triples, class_labels, tag_maps = self.tag_triples(
triples)
'''
print('######################')
self.log_something('tagged_triples ', tagged_triples)
self.log_something('modified_tag_triples ', modified_tag_triples)
self.log_something('class_labels ', class_labels)
print('######################')
'''
count = 0
all_outputs = {}
all_outputs['s2s_multi_morph_simple'] = []
all_outputs['s2s_multi_morph_simple_inv'] = []
all_outputs['s2s_morph_merge'] = []
all_outputs['s2s_morph_merge_inv'] = []
all_outputs['s2s_no_classifier'] = []
all_outputs['s2s_classifier'] = []
all_outputs['smt_classifier'] = []
all_outputs['smt_no_classifier'] = []
all_outputs['s2s_mw'] = []
all_outputs['smt_mw'] = []
all_inputs = []
all_tag_maps = []
for t, tt, mtt, cl, tm in zip(triples, tagged_triples,
modified_tag_triples, class_labels,
tag_maps):
print(t, tt, mtt, cl, tm)
mtts = ' '.join(mtt)
tts = ' '.join(tt)
output_dict = {}
self.log_something(':######################', count)
count += 1
self.log_something('Triple: ', t)
self.log_something('Tagged Triple: ', tt)
self.log_something('Modified Tagged triple ', mtts)
tick33 = time.time()
# tstring = ' '.join(t)
tstring = ' '.join(tt)
tinput = simple.transform_input(tstring, ner=False)
self.log_something('input to s2s multi_morph_simple', tinput)
t1 = time.time()
print(t1 - tick33)
g = self.generate_multiword_morph_simple(tinput)
t2 = time.time()
print(t2 - t1)
self.log_something('generate_from_s2s_multi_morph_simple', g)
norm_g = simple.normalize_string(tstring, g)
t3 = time.time()
print(t3 - t2)
self.log_something(
'verbs generate_from_s2s_multi_morph_simple', norm_g[1])
# g = simple.replace_entities(tstring, norm_g[0])[1]
g = self.add_apostrophe(tt, norm_g[1])
t4 = time.time()
print(t4 - t3)
g = self.replaceTokens(g, tm)
t5 = time.time()
print(t5 - t4)
# g = self.add_apostrophe(t,g)
self.log_something('ents generate_from_s2s_multi_morph_simple',
g)
output_dict['s2s_multi_morph_simple'] = [g]
all_outputs['s2s_multi_morph_simple'].append(g)
generated_tag_map[g] = norm_g[1]
tick34 = time.time()
print('^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^')
print(tick34 - t5)
return 0
# inv_t = list(reversed(t))
inv_t = list(reversed(tt))
inv_tm = list(reversed(tm))
tstring = ' '.join(inv_t)
tinput = simple.transform_input(tstring, ner=False)
self.log_something('input to s2s multi_morph_simple INV',
tinput)
g = self.generate_multiword_morph_simple(tinput)
self.log_something('generate_from_s2s_multi_morph_simple INV',
g)
norm_g = simple.normalize_string(tstring, g)
self.log_something(
'verbs generate_from_s2s_multi_morph_simple INV',
norm_g[1])
# g = simple.replace_entities(tstring, norm_g[0])[1]
g = self.add_apostrophe(inv_t, norm_g[1])
g = self.replaceTokens(g, inv_tm)
self.log_something(
'ents generate_from_s2s_multi_morph_simple INV', g)
output_dict['s2s_multi_morph_simple_inv'] = [g]
all_outputs['s2s_multi_morph_simple_inv'].append(g)
generated_tag_map[g] = norm_g[1]
# tstring = ' '.join(t)
tstring = ' '.join(tt)
tinput = merge.transform_input(tstring, ner=False)
self.log_something('input to s2s morph_merge', tinput[0])
g = self.generate_multiword_morph_merge(tinput[0])
self.log_something('generate_from_s2s_morph_merge', g)
norm_g = merge.normalize_string(tstring, g)
self.log_something('verbs generate_from_s2s_morph_merge',
norm_g[1])
# g = merge.replace_entities(tstring, tinput[1], norm_g[0])[1]
# g = self.add_apostrophe(t,g)
g = self.add_apostrophe(tt, norm_g[1])
g = self.replaceTokens(g, tm)
self.log_something('ents generate_from_s2s_morph_merge', g)
output_dict['s2s_morph_merge'] = [g]
all_outputs['s2s_morph_merge'].append(g)
generated_tag_map[g] = norm_g[1]
# inv_t = list(reversed(t))
inv_t = list(reversed(tt))
inv_tm = list(reversed(tm))
tstring = ' '.join(inv_t)
tinput = merge.transform_input(tstring, ner=False)
self.log_something('input to s2s morph_merge INV', tinput[0])
g = self.generate_multiword_morph_merge(tinput[0])
self.log_something('generate_from_s2s_morph_merge INV', g)
norm_g = merge.normalize_string(tstring, g)
self.log_something('verbs generate_from_s2s_morph_merge INV',
norm_g[1])
# g = merge.replace_entities(tstring, tinput[1], norm_g[0])[1]
g = self.add_apostrophe(inv_t, norm_g[1])
g = self.replaceTokens(g, inv_tm)
self.log_something('ents generate_from_s2s_morph_merge INV', g)
output_dict['s2s_morph_merge_inv'] = [g]
all_outputs['s2s_morph_merge_inv'].append(g)
generated_tag_map[g] = norm_g[1]
g = self.generate_from_s2s_with_classifier(mtts, cl)
self.log_something('generate_from_s2s_with_classifier ', g)
g = postprocess(g, nlp)
tagged_generated_version = g
self.log_something('pp generate_from_s2s_with_classifier ', g)
g = self.replaceTokens(g, tm)
g = self.add_apostrophe(mtt, g)
self.log_something('rt generate_from_s2s_with_classifier ', g)
output_dict['s2s_classifier'] = [g]
all_outputs['s2s_classifier'].append(g)
generated_tag_map[g] = tagged_generated_version
g = self.generate_from_s2s_without_classifier(mtts)
self.log_something('generate_from_s2s_without_classifier ', g)
g = postprocess(g, nlp)
tagged_generated_version = g
self.log_something('pp generate_from_s2s_without_classifier ',
g)
g = self.replaceTokens(g, tm)
g = self.add_apostrophe(mtt, g)
self.log_something('rt generate_from_s2s_without_classifier ',
g)
output_dict['s2s_no_classifier'] = [g]
all_outputs['s2s_no_classifier'].append(g)
generated_tag_map[g] = tagged_generated_version
g = self.generate_from_smt(mtts, cl)
self.log_something('generate_from_smt ', g)
g = postprocess(g, nlp)
tagged_generated_version = g
self.log_something('pp generate_from_smt ', g)
g = self.replaceTokens(g, tm)
g = self.add_apostrophe(mtt, g)
self.log_something('rt generate_from_smt ', g)
output_dict['smt_classifier'] = [g]
all_outputs['smt_classifier'].append(g)
generated_tag_map[g] = tagged_generated_version
g = self.generate_from_smt_no_class(mtts)
self.log_something('generate_from_smt_no_class ', g)
g = postprocess(g, nlp)
tagged_generated_version = g
self.log_something('pp generate_from_smt_no_class ', g)
g = self.replaceTokens(g, tm)
g = self.add_apostrophe(mtt, g)
self.log_something('rt generate_from_smt_no_class ', g)
output_dict['smt_no_classifier'] = [g]
all_outputs['smt_no_classifier'].append(g)
generated_tag_map[g] = tagged_generated_version
r = mtt[1]
print('******************', len(r.split()), use_multi)
if True: #len(r.split()) > 1 and use_multi:
self.log_something(' ', 'trying multi')
g = self.generate_with_multiword(' || '.join(mtt))
tagged_generated_version = g
self.log_something('generate_with_multiword ', g)
#g = postprocess(g, nlp)
#self.log_something('pp generate_with_multiword ', g)
g = self.replaceTokens(g, tm)
g = self.add_apostrophe(mtt, g)
self.log_something('rt generate_with_multiword ', g)
output_dict['s2s_mw'] = [g]
all_outputs['s2s_mw'].append(g)
generated_tag_map[g] = tagged_generated_version
g = self.generate_from_smt_multi(mtts)
tagged_generated_version = g
self.log_something('generate_from_smt_multi ', g)
#g = postprocess(g, nlp)
#self.log_something('pp generate_from_smt_multi ', g)
g = self.replaceTokens(g, tm)
g = self.add_apostrophe(mtt, g)
self.log_something('rt generate_from_smt_multi ', g)
output_dict['smt_mw'] = [g]
all_outputs['smt_mw'].append(g)
generated_tag_map[g] = tagged_generated_version
inp_original = t[0] + ' ' + tt[1] + ' ' + t[2]
inp_modified = t[0] + ' ' + mtt[1] + ' ' + t[2]
inp = [inp_original, inp_modified]
all_inputs.append([inp_original, inp_modified])
self.log_something('*** Input to ranker ', inp)
self.log_something('output_dict ', output_dict)
o = find_best(inp, output_dict, self.doc_sim, self.lmscorer)
[best_sent, system_tag, max_score] = o
self.log_something(
'****************************** OUTPUT ***********', '')
self.log_something('output list ', o)
self.log_something('generated_tag_map', generated_tag_map)
tagged_o = generated_tag_map[o[0]]
stuplelist.append((tagged_o, o[0]))
sdictlist.append((tm, o[0]))
all_tag_maps.append(tm)
self.log_something('sdictlist ', sdictlist)
#oo = stuplelist
#oo = merge_sentences(stuplelist, punctProcess=True)
return_output = ''
output_files = {}
if use_compounding:
oo = merge_sentences(sdictlist, punctProcess=True)
sentlist = [e[1] for e in oo]
for idxs, s in enumerate(sentlist):
filename = save_path + '/compounding' + '_' + str(
idxs) + '.txt'
if filename in output_files:
outfile = output_files[filename]
else:
outfile = open(filename, 'a')
output_files[filename] = outfile
outfile.write(s.rstrip() + '\n')
self.log_something('Merged ', sentlist)
if debug:
return_output = str(
'\n'.join(sentlist)) + '\n\n\n' + self.return_logs
else:
return_output = str('\n'.join(sentlist))
"""
#out = json.dumps(out, indent=4, sort_keys=True)
"""
if use_coref:
coref_out = [
' '.join(self.gendermodel.replace_pronoun(e[0], tag_maps))
for e in oo
]
for idxs, s in enumerate(coref_out):
filename = save_path + '/coref' + '_' + str(idxs) + '.txt'
if filename in output_files:
outfile = output_files[filename]
else:
outfile = open(filename, 'a')
output_files[filename] = outfile
outfile.write(s.rstrip() + '\n')
self.log_something('Coreference resolution \n', coref_out)
if debug:
return_output = str(
'\n'.join(coref_out)) + '\n\n\n' + self.return_logs
else:
return_output = str('\n'.join(coref_out))
keys = all_outputs.keys()
print('Keys', keys)
for kidx, k in enumerate(keys):
generated_sententes = all_outputs[k]
print(
'************************************************System name: ',
k)
temp_sdictlist = []
for idx, s in enumerate(generated_sententes):
print(idx)
tm = all_tag_maps[idx]
temp_sdictlist.append((tm, s))
oo = merge_sentences(temp_sdictlist)
self.log_something(
k +
'\n******************************************Merged\n ',
oo)
for idxs, s in enumerate([e[1] for e in oo]):
filename = save_path + '/' + k + '_' + str(idxs) + '.txt'
if filename in output_files:
outfile = output_files[filename]
else:
outfile = open(filename, 'a')
output_files[filename] = outfile
outfile.write(s.rstrip() + '\n')
self.log_something('out :: ', s)
for key, value in output_files.iteritems():
print('Closing file: ', key)
value.close()
return return_output
except Exception, error:
print(str(error))
s = traceback.format_exc()
print(s)
o = self.return_logs + '\n\n' + str(s)
return o