def run_imt_server(models, processors=None, port=5007): # Note: servers use a special .yaml config format-- maps language pairs to NMT configuration files # the server instantiates a predictor for each config, and hashes them by language pair tuples -- i.e. (en,fr) # Caller passes in a dict of predictors, keys are tuples (source_lang, target_lang) if processors is None: app.processors = {k: None for k in models.keys()} else: app.processors = processors app.models = models app.decoders = {k: create_constrained_decoder(v) for k, v in models.items()} logger.info('Server starting on port: {}'.format(port)) # logger.info('navigate to: http://localhost:{}/neural_MT_demo to see the system demo'.format(port)) # app.run(debug=True, port=port, host='127.0.0.1', threaded=True) app.run(debug=False, port=port, host='127.0.0.1', threaded=False)
def main(args): tf.logging.set_verbosity(tf.logging.INFO) # Load configs model_cls_list = [transformer.Transformer for model in args.models] params_list = [default_parameters() for _ in range(len(model_cls_list))] params_list = [ merge_parameters(params, model_cls.get_parameters()) for params, model_cls in zip(params_list, model_cls_list) ] params_list = [ import_params(args.checkpoints[i], args.models[i], params_list[i]) for i in range(len(args.checkpoints)) ] params_list = [ override_parameters(params_list[i], args) for i in range(len(model_cls_list)) ] # Build Graph with tf.Graph().as_default(): model_var_lists = [] # Load checkpoints for i, checkpoint in enumerate(args.checkpoints): tf.logging.info("Loading %s" % checkpoint) var_list = tf.train.list_variables(checkpoint) values = {} reader = tf.train.load_checkpoint(checkpoint) for (name, shape) in var_list: if not name.startswith(model_cls_list[i].get_name()): continue if name.find("losses_avg") >= 0: continue tensor = reader.get_tensor(name) values[name] = tensor model_var_lists.append(values) # Build models model_fns = [] for i in range(len(args.checkpoints)): name = model_cls_list[i].get_name() model = model_cls_list[i](params_list[i], name + "_%d" % i) model_fn = model.get_rerank_inference_func() model_fns.append(model_fn) params = params_list[0] # Read input file with open(args.input, "r") as encoded_file: sorted_keys = cPickle.load(encoded_file) decoder_input_list = cPickle.load(encoded_file) encoder_output_list = cPickle.load(encoded_file) state_placeholders = [] for i in range(len(params.device_list)): decode_state = { "encoder": tf.placeholder(tf.float32, [None, None, params.hidden_size], "encoder_%d" % i), #"encoder_weight": we doesn't need encoder weight "source": tf.placeholder(tf.int32, [None, None], "source_%d" % i), "source_length": tf.placeholder(tf.int32, [None], "source_length_%d" % i), # [bos_id, ...] => [..., 0] "target": tf.placeholder(tf.int32, [None, None], "target_%d" % i), #"target_length": tf.placeholder(tf.int32, [None, ], "target_length_%d" % i) } #需要这些值,以进行增量式解码 for j in range(params.num_decoder_layers): decode_state["decoder_layer_%d_key" % j] = tf.placeholder( tf.float32, [None, None, params.hidden_size], "decoder_layer_%d_key_%d" % (j, i)) decode_state["decoder_layer_%d_value" % j] = tf.placeholder( tf.float32, [None, None, params.hidden_size], "decoder_layer_%d_value_%d" % (j, i)) # layer and GPU # we only need the return value of this # decode_state["decoder_layer_%d_att_weight" % j] = tf.placeholder(tf.float32, [None, None, None, None], # # N Head T S inference的时候,T总是为1,表示1步 # "decoder_layer_%d_att_weight" % j), state_placeholders.append(decode_state) def decoding_fn(s): _decoding_fn = model_fns[0][1] #split s to state and feature, and 转换为嵌套的结构,以满足transformer模型 state = { "encoder": s["encoder"], "decoder": { "layer_%d" % j: { "key": s["decoder_layer_%d_key" % j], "value": s["decoder_layer_%d_value" % j], } for j in range(params.num_decoder_layers) } } inputs = s["target"] #inputs = tf.Print(inputs, [inputs], "before target", 100, 10000) feature = { "source": s["source"], "source_length": s["source_length"], # [bos_id, ...] => [..., 0] # "target": tf.pad(inputs[:,1:], [[0, 0], [0, 1]]) #"target": tf.pad(inputs, [[0, 0], [0, 1]]), # 前面没有bos_id,因此直接补上0,这是为了和decode_graph中的补bos相配合 "target": inputs, "target_length": tf.fill([tf.shape(inputs)[0]], tf.shape(inputs)[1]) } #feature["target"] = tf.Print(feature["target"], [feature["target"]], "target", 100,10000) ret = _decoding_fn(feature, state, params) return ret decoder_op = parallel.data_parallelism(params.device_list, lambda s: decoding_fn(s), state_placeholders) #batch = tf.shape(encoder_output)[0] # Create assign ops assign_ops = [] all_var_list = tf.trainable_variables() for i in range(len(args.checkpoints)): un_init_var_list = [] name = model_cls_list[i].get_name() for v in all_var_list: if v.name.startswith(name + "_%d" % i): un_init_var_list.append(v) ops = set_variables(un_init_var_list, model_var_lists[i], name + "_%d" % i) assign_ops.extend(ops) assign_op = tf.group(*assign_ops) results = [] sen_decode_time = [] grid_hyps = [] #存放每个句子中每个grid中的hyps,以便后期分析和统计 # Create session with tf.Session(config=session_config(params)) as sess: # from tensorflow.python import debug as tf_debug # sess = tf_debug.LocalCLIDebugWrapperSession(sess,ui_type='curses')#readline # Restore variables sess.run(assign_op) #startpoint=320 for i, (decode_input, encoder_output) in enumerate( zip(decoder_input_list, encoder_output_list)): # if i < startpoint: # continue # if i == startpoint: # break # print(input["source"]) # print(input["constraints"]) ################# # create constraint translation related model # build ensembled TM thumt_tm = ThumtTranslationModel(sess, decoder_op, encoder_output, state_placeholders, decode_input, params) # Build GBS search cons_decoder = create_constrained_decoder(thumt_tm) ################## max_length = decode_input["source_length"][ 0] + params.decode_length beam_size = params.beam_size # top_beams = params.top_beams top_beams = 1 start_time = time.time() best_output, search_grid = decode(encoder_output, sess, decoder_op, state_placeholders, params, cons_decoder, thumt_tm, decode_input, top_beams, max_hyp_len=max_length, beam_size=beam_size, return_alignments=True, length_norm=False) sen_decode_time.append(time.time() - start_time) hyps_num = {k: len(search_grid[k]) for k in search_grid.keys()} grid_hyps.append(hyps_num) # output_beams = [search_grid[k] for k in search_grid.keys() if k[1] == top_row] # output_hyps = [h for beam in output_beams for h in beam] # constraints=input_constraints, # return_alignments=return_alignments, # length_norm=length_norm) results.append(best_output) message = "Finished decoding sentences index: %d" % (i) tf.logging.log(tf.logging.INFO, message) # Convert to plain text vocab = params.vocabulary["target"] outputs = [] scores = [] mask_ratio = [] best_alignment = [] for result in results: sub_result = zip(*result[0]) outputs.extend(sub_result[0]) scores.extend(sub_result[1]) best_alignment.extend(result[1]) # for sub_result in result: # 每次解码结果可能有多个bestscore # outputs.append(sub_result[0][0][1:]) # seqs # scores.append(sub_result[0][1]) # score # mask_ratio.append(0) # best_alignment.extend(sub_result[1]) new_outputs = [] for s in outputs: new_outputs.append(s[1:]) outputs = new_outputs for s, score in zip(outputs, scores): s1 = [] for idx in s: if idx == params.mapping["target"][params.eos]: break s1.append(vocab[idx]) s1 = " ".join(s1) #print("%s" % s1) print("%f %s" % (score, s1)) restored_inputs = [] restored_outputs = [] restored_scores = [] restored_constraints = [] restored_alignment = [] restored_sen_decode_time = [] restored_grid_hyps = [] for index in range(len(sorted_keys)): restored_outputs.append(outputs[sorted_keys[index]]) restored_scores.append(scores[sorted_keys[index]]) #restored_constraints.append(sorted_constraints[sorted_keys[index]]) restored_alignment.append(best_alignment[sorted_keys[index]]) restored_sen_decode_time.append( sen_decode_time[sorted_keys[index]]) restored_grid_hyps.append(grid_hyps[sorted_keys[index]]) # restored_outputs = outputs # restored_scores = scores # restored_alignment = best_alignment # restored_sen_decode_time = sen_decode_time # restored_grid_hyps = grid_hyps # Write to file with open(args.output, "w") as outfile: count = 0 for output, score, de_time in zip(restored_outputs, restored_scores, restored_sen_decode_time): decoded = [] for idx in output: if idx == params.mapping["target"][params.eos]: break decoded.append(vocab[idx]) decoded = " ".join(decoded) if not args.verbose: outfile.write("%s\n" % decoded) else: pattern = "%d |%s |%f |%f \n" # cons = restored_constraints[count] # cons_token_num = 0 # for cons_item in cons: # cons_token_num += cons_item["tgt_len"] values = (count, decoded, score, de_time) outfile.write(pattern % values) count += 1 with open(args.output + ".alignment", "w") as outfile: count = 0 for alignment in restored_alignment: outfile.write("%d\n" % count) cPickle.dump(alignment, outfile) count += 1 # 保存解码时间和grid中的hyps,以便进行分析 with open(args.output + ".time_hyps", "w") as outfile: cPickle.dump(restored_sen_decode_time, outfile) cPickle.dump(restored_grid_hyps, outfile) with open(args.output + ".time", "w") as outfile: time_sen = np.asarray(restored_sen_decode_time) ave = np.average(time_sen) outfile.write("average time:%f\n" % ave) cPickle.dump(restored_sen_decode_time, outfile)
def run(input_files, constraints_file, output, models, configs, weights, n_best=1, length_factor=1.3, beam_size=5, mert_nbest=False, write_alignments=None, length_norm=True): if configs is not None: assert len(models) == len( configs), 'Number of models differs from numer of config files' if weights is not None: assert len(models) == len( weights ), 'If you specify weights, there must be one for each model' return_alignments = False if write_alignments is not None: return_alignments = True try: os.remove(write_alignments) except OSError: pass # remember Nematus needs _encoded_ utf8 if configs is not None: configs = [load_config(f) for f in configs] # build ensembled TM nematus_tm = NematusTranslationModel(models, configs, model_weights=weights) # Build GBS search decoder = create_constrained_decoder(nematus_tm) constraints = None if constraints_file is not None: constraints = json.loads( codecs.open(constraints_file, encoding='utf8').read()) if output.name != '<stdout>': output = codecs.open(output.name, 'w', encoding='utf8') input_iters = [] for input_file in input_files: input_iters.append(codecs.open(input_file, encoding='utf8')) for idx, inputs in enumerate(itertools.izip(*input_iters)): input_constraints = [] if constraints is not None: input_constraints = constraints[idx] # Note: the length_factor is used with the length of the first model input of the ensemble # in case the users constraints will go beyond the max length according to length_factor max_hyp_len = int(round(len(inputs[0].split()) * length_factor)) if len(input_constraints) > 0: num_constraint_tokens = sum(1 for c in input_constraints for _ in c) if num_constraint_tokens >= max_hyp_len: logger.warn('The number of tokens in the constraints are greater than max_len*length_factor, ' + \ 'autoscaling the maximum hypothesis length...') max_hyp_len = num_constraint_tokens + int( round(max_hyp_len / 2)) best_output = decode(decoder, nematus_tm, inputs, n_best, max_hyp_len=max_hyp_len, beam_size=beam_size, constraints=input_constraints, return_alignments=return_alignments, length_norm=length_norm) if return_alignments: # decoding returned a tuple with 2 items best_output, best_alignments = best_output if n_best > 1: if mert_nbest: # format each n-best entry in the mert format translations, scores, model_scores = zip(*best_output) # start from idx 1 to cut off `None` at the beginning of the sequence translations = [u' '.join(s[1:]) for s in translations] # create dummy feature names model_names = [ u'M{}'.format(m_i) for m_i in range(len(model_scores[0])) ] #Note: we make model scores and logprob negative for MERT optimization to work model_score_strings = [ u' '.join([ u'{}= {}'.format(model_name, -s_i) for model_name, s_i in zip(model_names, m_scores) ]) for m_scores in model_scores ] nbest_output_strings = [ u'{} ||| {} ||| {} ||| {}'.format(idx, translation, feature_scores, -logprob) for translation, feature_scores, logprob in zip( translations, model_score_strings, scores) ] decoder_output = u'\n'.join(nbest_output_strings) + u'\n' else: # start from idx 1 to cut off `None` at the beginning of the sequence # separate each n-best list with newline decoder_output = u'\n'.join( [u' '.join(s[0][1:]) for s in best_output]) + u'\n\n' if output.name == '<stdout>': output.write(decoder_output.encode('utf8')) else: output.write(decoder_output) else: # start from idx 1 to cut off `None` at the beginning of the sequence decoder_output = u' '.join(best_output[0][1:]) if output.name == '<stdout>': output.write((decoder_output + u'\n').encode('utf8')) else: output.write(decoder_output + u'\n') # Note alignments are always an n-best list (may be n=1) if write_alignments is not None: with codecs.open(write_alignments, 'a+', encoding='utf8') as align_out: align_out.write( json.dumps([a.tolist() for a in best_alignments]) + u'\n') if (idx + 1) % 10 == 0: logger.info('Wrote {} translations to {}'.format( idx + 1, output.name))
def run(input_files, constraints_file, output, models, configs, weights, n_best=1, length_factor=1.3, beam_size=5, mert_nbest=False, write_alignments=None, length_norm=True): assert len(models) == len( configs), 'We need one config file for every model' if weights is not None: assert len(models) == len( weights ), 'If you specify weights, there must be one for each model' if write_alignments is not None: try: os.remove(write_alignments) except OSError: pass # remember Nematus needs _encoded_ utf8 configs = [load_config(f) for f in configs] # build ensembled TM nematus_tm = NematusTranslationModel(models, configs, model_weights=weights) # Build GBS search decoder = create_constrained_decoder(nematus_tm) constraints = None if constraints_file is not None: constraints = json.loads( codecs.open(constraints_file, encoding='utf8').read()) if output.name != '<stdout>': output = codecs.open(output.name, 'w', encoding='utf8') input_iters = [] for input_file in input_files: input_iters.append(codecs.open(input_file, encoding='utf8')) for idx, inputs in enumerate(itertools.izip(*input_iters)): mapped_inputs = nematus_tm.map_inputs(inputs) input_constraints = [] if constraints is not None: input_constraints = nematus_tm.map_constraints(constraints[idx]) start_hyp = nematus_tm.start_hypothesis(mapped_inputs, input_constraints) # Note: the length_factor is used with the length of the first model input of the ensemble search_grid = decoder.search( start_hyp=start_hyp, constraints=input_constraints, max_hyp_len=int(round(len(mapped_inputs[0][0]) * length_factor)), beam_size=beam_size) best_output, best_alignments = decoder.best_n( search_grid, nematus_tm.eos_token, n_best=n_best, return_model_scores=mert_nbest, return_alignments=True, length_normalization=length_norm) if n_best > 1: if mert_nbest: # format each n-best entry in the mert format translations, scores, model_scores = zip(*best_output) # start from idx 1 to cut off `None` at the beginning of the sequence translations = [u' '.join(s[1:]) for s in translations] # create dummy feature names model_names = [ u'M{}'.format(m_i) for m_i in range(len(model_scores[0])) ] #Note: we make model scores and logprob negative for MERT optimization to work model_score_strings = [ u' '.join([ u'{}= {}'.format(model_name, -s_i) for model_name, s_i in zip(model_names, m_scores) ]) for m_scores in model_scores ] nbest_output_strings = [ u'{} ||| {} ||| {} ||| {}'.format(idx, translation, feature_scores, -logprob) for translation, feature_scores, logprob in zip( translations, model_score_strings, scores) ] decoder_output = u'\n'.join(nbest_output_strings) + u'\n' else: # start from idx 1 to cut off `None` at the beginning of the sequence # separate each n-best list with newline decoder_output = u'\n'.join( [u' '.join(s[0][1:]) for s in best_output]) + u'\n\n' if output.name == '<stdout>': output.write(decoder_output.encode('utf8')) else: output.write(decoder_output) else: # start from idx 1 to cut off `None` at the beginning of the sequence decoder_output = u' '.join(best_output[0][1:]) if output.name == '<stdout>': output.write((decoder_output + u'\n').encode('utf8')) else: output.write(decoder_output + u'\n') # Note alignments are always an n-best list (may be n=1) if write_alignments is not None: with codecs.open(write_alignments, 'a+', encoding='utf8') as align_out: align_out.write( json.dumps([a.tolist() for a in best_alignments]) + u'\n') if (idx + 1) % 10 == 0: logger.info('Wrote {} translations to {}'.format( idx + 1, output.name))
def main(args): tf.logging.set_verbosity(tf.logging.INFO) # Load configs model_cls_list = [transformer.Transformer for model in args.models] params_list = [default_parameters() for _ in range(len(model_cls_list))] params_list = [ merge_parameters(params, model_cls.get_parameters()) for params, model_cls in zip(params_list, model_cls_list) ] params_list = [ import_params(args.checkpoints[i], args.models[i], params_list[i]) for i in range(len(args.checkpoints)) ] params_list = [ override_parameters(params_list[i], args) for i in range(len(model_cls_list)) ] # Build Graph with tf.Graph().as_default(): model_var_lists = [] # Load checkpoints for i, checkpoint in enumerate(args.checkpoints): tf.logging.info("Loading %s" % checkpoint) var_list = tf.train.list_variables(checkpoint) values = {} reader = tf.train.load_checkpoint(checkpoint) for (name, shape) in var_list: if not name.startswith(model_cls_list[i].get_name()): continue if name.find("losses_avg") >= 0: continue tensor = reader.get_tensor(name) values[name] = tensor model_var_lists.append(values) # Build models model_fns = [] for i in range(len(args.checkpoints)): name = model_cls_list[i].get_name() model = model_cls_list[i](params_list[i], name + "_%d" % i) model_fn = model.get_rerank_inference_func() model_fns.append(model_fn) params = params_list[0] # Read input file sorted_keys, sorted_inputs, sorted_constraints = \ src_cons_dataset.sort_input_src_cons(args.input, args.constraints) # Build input queue features = src_cons_dataset.get_input_with_src_constraints( sorted_inputs, sorted_constraints, params) print(sorted_keys) #Create placeholder placeholders = [] for i in range(len(params.device_list)): placeholders.append({ "source": tf.placeholder(tf.int32, [None, None], "source_%d" % i), "source_length": tf.placeholder(tf.int32, [None], "source_length_%d" % i), "constraints_src_pos": tf.placeholder(tf.int32, [None, None, None], "constraints_src_pos_%d" % i), "constraints": tf.placeholder(tf.int32, [None, None, None], "constraints_%d" % i), "constraints_len": tf.placeholder(tf.int32, [None, None], "constraints_len_%d" % i) }) encoding_fn = model_fns[0][0] encoder_op = parallel.data_parallelism( params.device_list, lambda f: encoding_fn(f, params), placeholders) state_placeholders = [] for i in range(len(params.device_list)): decode_state = { "encoder": tf.placeholder(tf.float32, [None, None, params.hidden_size], "encoder_%d" % i), #"encoder_weight": we doesn't need encoder weight "source": tf.placeholder(tf.int32, [None, None], "source_%d" % i), "source_length": tf.placeholder(tf.int32, [None], "source_length_%d" % i), # [bos_id, ...] => [..., 0] "target": tf.placeholder(tf.int32, [None, None], "target_%d" % i), #"target_length": tf.placeholder(tf.int32, [None, ], "target_length_%d" % i) } #需要这些值,以进行增量式解码 for j in range(params.num_decoder_layers): decode_state["decoder_layer_%d_key" % j] = tf.placeholder( tf.float32, [None, None, params.hidden_size], "decoder_layer_%d_key_%d" % (j, i)) decode_state["decoder_layer_%d_value" % j] = tf.placeholder( tf.float32, [None, None, params.hidden_size], "decoder_layer_%d_value_%d" % (j, i)) # layer and GPU # we only need the return value of this # decode_state["decoder_layer_%d_att_weight" % j] = tf.placeholder(tf.float32, [None, None, None, None], # # N Head T S inference的时候,T总是为1,表示1步 # "decoder_layer_%d_att_weight" % j), state_placeholders.append(decode_state) def decoding_fn(s): _decoding_fn = model_fns[0][1] #split s to state and feature, and 转换为嵌套的结构,以满足transformer模型 state = { "encoder": s["encoder"], "decoder": { "layer_%d" % j: { "key": s["decoder_layer_%d_key" % j], "value": s["decoder_layer_%d_value" % j], } for j in range(params.num_decoder_layers) } } inputs = s["target"] #inputs = tf.Print(inputs, [inputs], "before target", 100, 10000) feature = { "source": s["source"], "source_length": s["source_length"], # [bos_id, ...] => [..., 0] # "target": tf.pad(inputs[:,1:], [[0, 0], [0, 1]]) #"target": tf.pad(inputs, [[0, 0], [0, 1]]), # 前面没有bos_id,因此直接补上0,这是为了和decode_graph中的补bos相配合 "target": inputs, "target_length": tf.fill([tf.shape(inputs)[0]], tf.shape(inputs)[1]) } #feature["target"] = tf.Print(feature["target"], [feature["target"]], "target", 100,10000) ret = _decoding_fn(feature, state, params) return ret decoder_op = parallel.data_parallelism(params.device_list, lambda s: decoding_fn(s), state_placeholders) #batch = tf.shape(encoder_output)[0] # Create assign ops assign_ops = [] all_var_list = tf.trainable_variables() for i in range(len(args.checkpoints)): un_init_var_list = [] name = model_cls_list[i].get_name() for v in all_var_list: if v.name.startswith(name + "_%d" % i): un_init_var_list.append(v) ops = set_variables(un_init_var_list, model_var_lists[i], name + "_%d" % i) assign_ops.extend(ops) assign_op = tf.group(*assign_ops) results = [] # Create session with tf.Session(config=session_config(params)) as sess: # from tensorflow.python import debug as tf_debug # sess = tf_debug.LocalCLIDebugWrapperSession(sess,ui_type='curses')#readline # Restore variables sess.run(assign_op) sess.run(tf.tables_initializer()) # pad_id = params.mapping["target"][params.pad] # bos_id = params.mapping["target"][params.bos] # eos_id = params.mapping["target"][params.eos] while True: try: feats = sess.run(features) encoder_op, feed_dict = shard_features( feats, placeholders, encoder_op) #print("encoding %d" % i) encoder_state = sess.run(encoder_op, feed_dict=feed_dict) decoder_input_list = [] encoder_output_list = [] for j in range(len(feats["source"])): decoder_input_item = { "source": [feats["source"][j]], "source_length": [feats["source_length"][j]], "constraints_src_pos": feats["constraints_src_pos"][j], "constraints": feats["constraints"][j], "constraints_len": feats["constraints_len"][j], } decoder_input_list.append(decoder_input_item) # 不能简单的用GPU数量来循环,要用实际的输出来循环,因为有时候会空出GPU,比如最后一句或几句,无法凑够给1个GPU for i in range(len(encoder_state[0])): # gpu state_len = len(encoder_state[0][i]) # for j in range(state_len): encoder_output_item = { "encoder": encoder_state[0][i][j:j + 1], "encoder_weight": encoder_state[1][i][j:j + 1] } encoder_output_list.append(encoder_output_item) for input, encoder_output in zip(decoder_input_list, encoder_output_list): # print(input["source"]) # print(input["constraints"]) ################# # create constraint translation related model # build ensembled TM thumt_tm = ThumtTranslationModel( sess, decoder_op, encoder_output, state_placeholders, input, params) # Build GBS search cons_decoder = create_constrained_decoder(thumt_tm) ################## max_length = input["source_length"][ 0] + params.decode_length beam_size = params.beam_size # top_beams = params.top_beams top_beams = 1 best_output = decode(encoder_output, sess, decoder_op, state_placeholders, params, cons_decoder, thumt_tm, input, top_beams, max_hyp_len=max_length, beam_size=beam_size, return_alignments=True, length_norm=False) # constraints=input_constraints, # return_alignments=return_alignments, # length_norm=length_norm) results.append(best_output) message = "Finished sentences: %d" % len(results) tf.logging.log(tf.logging.INFO, message) except tf.errors.OutOfRangeError: break # Convert to plain text vocab = params.vocabulary["target"] outputs = [] scores = [] mask_ratio = [] best_alignment = [] # for result in results: # outputs.append(result) # scores.append(0) # mask_ratio.append(0) for result in results: # print(result[0]) # #outputs.append(result[0][0][1:]) sub_result = zip(*result[0]) outputs.extend(sub_result[0]) scores.extend(sub_result[1]) mask_ratio.extend([0] * len(sub_result[1])) #放入假的ratio best_alignment.extend(result[1]) # for sub_result in result: # 每次解码结果可能有多个bestscore # outputs.append(sub_result[0][0][1:]) # seqs # scores.append(sub_result[0][1]) # score # mask_ratio.append(0) # best_alignment.extend(sub_result[1]) new_outputs = [] for s in outputs: new_outputs.append(s[1:]) outputs = new_outputs for s, score in zip(outputs, scores): s1 = [] for idx in s: if idx == params.mapping["target"][params.eos]: break s1.append(vocab[idx]) s1 = " ".join(s1) #print("%s" % s1) print("%f %s" % (score, s1)) restored_inputs = [] restored_outputs = [] restored_scores = [] restored_ratio = [] restored_constraints = [] restored_alignment = [] for index in range(len(sorted_inputs)): restored_inputs.append(sorted_inputs[sorted_keys[index]]) restored_outputs.append(outputs[sorted_keys[index]]) restored_scores.append(scores[sorted_keys[index]]) restored_ratio.append(mask_ratio[sorted_keys[index]]) restored_constraints.append(sorted_constraints[sorted_keys[index]]) restored_alignment.append(best_alignment[sorted_keys[index]]) # Write to file with open(args.output, "w") as outfile: count = 0 for output, score, ratio in zip(restored_outputs, restored_scores, restored_ratio): decoded = [] for idx in output: if idx == params.mapping["target"][params.eos]: break decoded.append(vocab[idx]) decoded = " ".join(decoded) if not args.verbose: outfile.write("%s\n" % decoded) else: pattern = "%d ||| %s ||| %s ||| %f ||| %f ||| %d\n" source = restored_inputs[count] cons = restored_constraints[count] cons_token_num = 0 for cons_item in cons: cons_token_num += cons_item["tgt_len"] values = (count, source, decoded, score, ratios[0], cons_token_num) outfile.write(pattern % values) count += 1 with open(args.output + ".alignment", "w") as outfile: count = 0 for alignment in restored_alignment: outfile.write("%d\n" % count) cPickle.dump(alignment, outfile) count += 1