def decode_Beam(FLAGS): # If in decode mode, set batch_size = beam_size # Reason: in decode mode, we decode one example at a time. # On each step, we have beam_size-many hypotheses in the beam, so we need to make a batch of these hypotheses. #if FLAGS.mode == 'decode': # FLAGS.batch_size = FLAGS.beam_size # If single_pass=True, check we're in decode mode #if FLAGS.single_pass and FLAGS.mode != 'decode': # raise Exception("The single_pass flag should only be True in decode mode") vocab_in, vocab_out = data.load_dict_data(FLAGS) FLAGS_batcher = config.retype_FLAGS() FLAGS_decode = FLAGS_batcher._asdict() FLAGS_decode["max_dec_steps"] = 1 FLAGS_decode["mode"] = "decode" FLAGS_decode = config.generate_nametuple(FLAGS_decode) # The model is configured with max_dec_steps=1 because we only ever run one step of the decoder at a time (to do beam search). Note that the batcher is initialized with max_dec_steps equal to e.g. 100 because the batches need to contain the full summaries batcher = Batcher(FLAGS.data_path, vocab_in,vocab_out, FLAGS_batcher, data_file=FLAGS.test_name) model = SummarizationModel(FLAGS_decode, vocab_in,vocab_out,batcher) decoder = BeamSearchDecoder(model, batcher, vocab_out) decoder.decode()
def calc_features(cnn_dm_train_data_path, hps, vocab, batcher, save_path): if not os.path.exists(save_path): os.makedirs(save_path) decode_model_hps = hps # This will be the hyperparameters for the decoder model model = SummarizationModel(decode_model_hps, vocab) decoder = BeamSearchDecoder(model, batcher, vocab) decoder.calc_importance_features(cnn_dm_train_data_path, hps, save_path, 1000)
def main(unused_argv): # prints a message if you've entered flags incorrectly if len(unused_argv) != 1: raise Exception("Problem with flags: %s" % unused_argv) hps, vocab = prepare_hps_vocab() generator_batcher = Batcher(FLAGS.data_path, vocab, hps, single_pass=FLAGS.single_pass) discriminator_batcher = Batcher(FLAGS.data_path, vocab, hps, single_pass=FLAGS.single_pass) if hps.mode == 'train': generator, discriminator = build_seqgan_graph(hps, vocab) setup_training(generator, discriminator, generator_batcher, discriminator_batcher) elif hps.mode == 'decode': # The model is configured with max_dec_steps=1 because we only ever run one step of # the decoder at a time (to do beam search). decode_model_hps = hps._replace(max_dec_steps=1) generator = SummarizationModel(decode_model_hps, vocab) decoder = BeamSearchDecoder(generator, generator_batcher, vocab) decoder.decode() else: raise ValueError("The 'mode' flag must be one of train/decode")
def main(args): if args.mode == 'prepare': # python3 run.py --mode prepare --pointer-gen prepare(args) elif args.mode == 'train': # python3 run.py --mode train -b 100 -o output --gpu 0 --restore train(args) elif args.mode == 'eval': # python3 run.py --mode eval --eval-model evaluate(args) elif args.mode == 'decode': # # python3 run.py --mode decode --beam-size 10 --decode-model output_big_data/model/model-250000 --decode-dir output_big_data/result --gpu 1 args.batch_size = args.beam_size vocab_encoder = Vocab(args, "encoder_vocab") vocab_decoder = Vocab(args, "decoder_vocab") vocab_user = User_Vocab(args, name="user_vocab") test_file = "./test.data" #test_file = os.path.join(args.data, 'chat_data/tmp.data') # test_file = os.path.join(args.data, 'news_train_span_50.data') batcher = TestBatcher(args, vocab_encoder, vocab_decoder, vocab_user, test_file).batcher() if args.cpu: with tf.device('/cpu:0'): model = CommentModel(args, vocab_decoder) else: model = CommentModel(args, vocab_decoder) decoder = BeamSearchDecoder(args, model, batcher, vocab_decoder) decoder.decode() elif args.mode == 'debug': debug(args) else: raise RuntimeError(f'mode {args.mode} is invalid.')
def predict(): if FLAGS.mode != "predict": print("Wrong Function") return FLAGS.batch_size = FLAGS.beam_size hps = prepare_hps() vocab = Vocab(FLAGS.vocab_path, FLAGS.vocab_size) decode_model_hps = hps._replace(max_dec_steps=1) generator = Generator(decode_model_hps, vocab) decoder = BeamSearchDecoder(generator, None, vocab) # text=" tHE PRESIDENT wILL REMAIN IN THE uNITED sTATES TO OVERSE THE AMERICAN RESPONSE TO sYRIA AND TO MONITOR DEVELOPMENTS AROUND THE WORLD. NOW YOU REMEMBER YESTERDAY THE PRESIDENT SENT OUT A SET OUT A TIMELINE OF 24 TO 48 HOURS AS TO WHEN HE MOULD HAKE HIS DECISION KNOWN AS IT RELATES TO THE us REsp ONSE TO THE CRISIS IN sYRIA SO HE COULD GET SOME MORE CLARITY ON THAT TODAY. buT sARAH sANDERS IS NOM HITTING THE FACT THAT THIS TRIP IS CANCELED ON SOME OF ThaT DECISION-MAKING cHRIS." # text=''' yOU HAVE SOME BREAKING NEHS ABOUT PRESIDENT CANCELING A SCHEDULED TRIP # # THAT HAS PLANNED LATER THIS HEEK. IET'S GO BACK TO THE WHITE hOUSE. nbc'S JEFF # # bENNETT, wHAT ARE YOU HEARING.? hEY CHRIS, PRESIDENT tRUMP HAS SET TO MAKE HIS FIRST VISIT OF HIS PRESIDENCY TO lATIN eMERICA LATER THIS HEEK. bUT HE'VE JUST LEARNED FROM WHITE hOUSE DRESS SECRETARY SARAH SANDERS THAT TRIP IS NOM CALLED OFF. # # hERE'S THE STATEMENT. SHE SENT OUT MOMENTS AGO PRESIDENT tRUMP HILL NOT ATTEND # # HE SUMMIT OF THE eMERICAS IN lIMA PERU OR TRAVEL TO bOGOTA COLOMBIA AS ORIGINALY SCHEDULED AT THE PRESIDENT'S REQUEST. tHE VICE PRESIDENT HILL TRAVEL IN INSTED''' text = "-lrb- cnn -rrb- the palestinian authority officially became the 123rd member of the international criminal court on wednesday , a step that gives the court jurisdiction over alleged crimes in palestinian territories . the formal accession was marked with a ceremony at the hague , in the netherlands , where the court is based . the palestinians signed the icc 's founding rome statute in january , when they also accepted its jurisdiction over alleged crimes committed `` in the occupied palestinian territory , including east jerusalem , since june 13 , 2014 . '' later that month , the icc opened a preliminary examination into the situation in palestinian territories , paving the way for possible war crimes investigations against israelis . as members of the court , palestinians may be subject to counter-charges as well . israel and the united states , neither of which is an icc member , opposed the palestinians ' efforts to join the body . but palestinian foreign minister riad al-malki , speaking at wednesday 's ceremony , said it was a move toward greater justice . `` as palestine formally becomes a state party to the rome statute today , the world is also a step closer to ending a long era of impunity and injustice , '' he said , according to an icc news release . `` indeed , today brings us closer to our shared goals of justice and peace . '' judge kuniko ozaki , a vice president of the icc , said acceding to the treaty was just the first step for the palestinians . `` as the rome statute today enters into force for the state of palestine , palestine acquires all the rights as well as responsibilities that come with being a state party to the statute . these are substantive commitments , which can not be taken lightly , '' she said . rights group human rights watch welcomed the development . `` governments seeking to penalize palestine for joining the icc should immediately end their pressure , and countries that support universal acceptance of the court 's treaty should speak out to welcome its membership , '' said balkees jarrah , international justice counsel for the group . `` what 's objectionable is the attempts to undermine international justice , not palestine 's decision to join a treaty to which over 100 countries around the world are members . '' in january , when the preliminary icc examination was opened , israeli prime minister benjamin netanyahu described it as an outrage , saying the court was overstepping its boundaries . the united states also said it `` strongly '' disagreed with the court 's decision . `` as we have said repeatedly , we do not believe that palestine is a state and therefore we do not believe that it is eligible to join the icc , '' the state department said in a statement . it urged the warring sides to resolve their differences through direct negotiations . `` we will continue to oppose actions against israel at the icc as counterproductive to the cause of peace , '' it said . but the icc begs to differ with the definition of a state for its purposes and refers to the territories as `` palestine . '' while a preliminary examination is not a formal investigation , it allows the court to review evidence and determine whether to investigate suspects on both sides . prosecutor fatou bensouda said her office would `` conduct its analysis in full independence and impartiality . '' the war between israel and hamas militants in gaza last summer left more than 2,000 people dead . the inquiry will include alleged war crimes committed since june . the international criminal court was set up in 2002 to prosecute genocide , crimes against humanity and war crimes . cnn 's vasco cotovio , kareem khadder and faith karimi contributed to this report ." # text="marseille , france -lrb- cnn -rrb- the french prosecutor leading an investigation into the crash of germanwings flight 9525 insisted wednesday that he was not aware of any video footage from on board the plane . marseille prosecutor brice robin told cnn that `` so far no videos were used in the crash investigation . '' he added , `` a person who has such a video needs to immediately give it to the investigators . '' robin 's comments follow claims by two magazines , german daily bild and french paris match , of a cell phone video showing the harrowing final seconds from on board germanwings flight 9525 as it crashed into the french alps . all 150 on board were killed . paris match and bild reported that the video was recovered from a phone at the wreckage site . the two publications described the supposed video , but did not post it on their websites . the publications said that they watched the video , which was found by a source close to the investigation . `` one can hear cries of ` my god ' in several languages , '' paris match reported . `` metallic banging can also be heard more than three times , perhaps of the pilot trying to open the cockpit door with a heavy object . towards the end , after a heavy shake , stronger than the others , the screaming intensifies . then nothing . '' `` it is a very disturbing scene , '' said julian reichelt , editor-in-chief of bild online . an official with france 's accident investigation agency , the bea , said the agency is not aware of any such video . lt. col. jean-marc menichini , a french gendarmerie spokesman in charge of communications on rescue efforts around the germanwings crash site , told cnn that the reports were `` completely wrong '' and `` unwarranted . '' cell phones have been collected at the site , he said , but that they `` had n't been exploited yet . '' menichini said he believed the cell phones would need to be sent to the criminal research institute in rosny sous-bois , near paris , in order to be analyzed by specialized technicians working hand-in-hand with investigators . but none of the cell phones found so far have been sent to the institute , menichini said . asked whether staff involved in the search could have leaked a memory card to the media , menichini answered with a categorical `` no . '' reichelt told `` erin burnett : outfront '' that he had watched the video and stood by the report , saying bild and paris match are `` very confident '' that the clip is real . he noted that investigators only revealed they 'd recovered cell phones from the crash site after bild and paris match published their reports . `` that is something we did not know before . ... overall we can say many things of the investigation were n't revealed by the investigation at the beginning , '' he said . what was mental state of germanwings co-pilot ? german airline lufthansa confirmed tuesday that co-pilot andreas lubitz had battled depression years before he took the controls of germanwings flight 9525 , which he 's accused of deliberately crashing last week in the french alps . lubitz told his lufthansa flight training school in 2009 that he had a `` previous episode of severe depression , '' the airline said tuesday . email correspondence between lubitz and the school discovered in an internal investigation , lufthansa said , included medical documents he submitted in connection with resuming his flight training . the announcement indicates that lufthansa , the parent company of germanwings , knew of lubitz 's battle with depression , allowed him to continue training and ultimately put him in the cockpit . lufthansa , whose ceo carsten spohr previously said lubitz was 100 % fit to fly , described its statement tuesday as a `` swift and seamless clarification '' and said it was sharing the information and documents -- including training and medical records -- with public prosecutors . spohr traveled to the crash site wednesday , where recovery teams have been working for the past week to recover human remains and plane debris scattered across a steep mountainside . he saw the crisis center set up in seyne-les-alpes , laid a wreath in the village of le vernet , closer to the crash site , where grieving families have left flowers at a simple stone memorial . menichini told cnn late tuesday that no visible human remains were left at the site but recovery teams would keep searching . french president francois hollande , speaking tuesday , said that it should be possible to identify all the victims using dna analysis by the end of the week , sooner than authorities had previously suggested . in the meantime , the recovery of the victims ' personal belongings will start wednesday , menichini said . among those personal belongings could be more cell phones belonging to the 144 passengers and six crew on board . check out the latest from our correspondents . the details about lubitz 's correspondence with the flight school during his training were among several developments as investigators continued to delve into what caused the crash and lubitz 's possible motive for downing the jet . a lufthansa spokesperson told cnn on tuesday that lubitz had a valid medical certificate , had passed all his examinations and `` held all the licenses required . '' earlier , a spokesman for the prosecutor 's office in dusseldorf , christoph kumpa , said medical records reveal lubitz suffered from suicidal tendencies at some point before his aviation career and underwent psychotherapy before he got his pilot 's license . kumpa emphasized there 's no evidence suggesting lubitz was suicidal or acting aggressively before the crash . investigators are looking into whether lubitz feared his medical condition would cause him to lose his pilot 's license , a european government official briefed on the investigation told cnn on tuesday . while flying was `` a big part of his life , '' the source said , it 's only one theory being considered . another source , a law enforcement official briefed on the investigation , also told cnn that authorities believe the primary motive for lubitz to bring down the plane was that he feared he would not be allowed to fly because of his medical problems . lubitz 's girlfriend told investigators he had seen an eye doctor and a neuropsychologist , both of whom deemed him unfit to work recently and concluded he had psychological issues , the european government official said . but no matter what details emerge about his previous mental health struggles , there 's more to the story , said brian russell , a forensic psychologist . `` psychology can explain why somebody would turn rage inward on themselves about the fact that maybe they were n't going to keep doing their job and they 're upset about that and so they 're suicidal , '' he said . `` but there is no mental illness that explains why somebody then feels entitled to also take that rage and turn it outward on 149 other people who had nothing to do with the person 's problems . '' germanwings crash compensation : what we know . who was the captain of germanwings flight 9525 ? cnn 's margot haddad reported from marseille and pamela brown from dusseldorf , while laura smith-spark wrote from london . cnn 's frederik pleitgen , pamela boykoff , antonia mortensen , sandrine amiel and anna-maja rappard contributed to this report ." data = genrate_Input(text, hps, vocab) out = decoder.predict(data) print(out)
def main(unused_argv): set_random_seeds() get_datapath() # The dataset path get_steps() # setting steps according data_size tf.logging.set_verbosity(tf.logging.INFO) print('Now the mode of this mode is {} !'.format(FLAGS.mode)) # if log_dir is not exited, create it. if not os.path.exists(FLAGS.log_dir): os.makedirs(FLAGS.log_dir) if FLAGS.mode == 'decode': FLAGS.branch_batch_size = FLAGS.beam_size # for beam search FLAGS.TS_mode = False hps = make_hps() # make a hps namedtuple # Vocabulary vocab = Vocab(hps.vocab_path, hps.vocab_size) # Train or Inference if hps.mode == 'train': batcher = Batcher(hps.data_path, vocab, hps) eval_hps = hps._replace(mode='eval') eval_batcher = Batcher(hps.eval_data_path, vocab, eval_hps) model = GSNModel(hps, vocab) train(model, batcher, eval_batcher, vocab, hps) elif hps.mode == 'decode': decode_mdl_hps = hps._replace(max_dec_steps=1) batcher = Batcher(hps.test_data_path, vocab, decode_mdl_hps) # for test model = GSNModel(decode_mdl_hps, vocab) decoder = BeamSearchDecoder(model, batcher, vocab) decoder._decode()
def run(size): # print ((unused_argv)) # if len(unused_argv) != 1: # prints a message if you've entered flags incorrectly # raise Exception("Problem with flags: %s" % unused_argv) FLAGS.min_dec_steps = size//4 FLAGS.max_dec_steps = size FLAGS.max_enc_steps = size tf.logging.set_verbosity(tf.logging.INFO) # choose what level of logging you want tf.logging.info('Starting seq2seq_attention in %s mode...', (FLAGS.mode)) # Change log_root to FLAGS.log_root/FLAGS.exp_name and create the dir if necessary FLAGS.log_root = log_path FLAGS.log_root = os.path.join(FLAGS.log_root, FLAGS.exp_name) if not os.path.exists(FLAGS.log_root): if FLAGS.mode =="train": os.makedirs(FLAGS.log_root) else: raise Exception("Logdir %s doesn't exist. Run in train mode to create it." % (FLAGS.log_root)) print("vocab path is ",FLAGS.vocab_path) vocab = Vocab(FLAGS.vocab_path, FLAGS.vocab_size) # create a vocabulary # If in decode mode, set batch_size = beam_size # Reason: in decode mode, we decode one example at a time. # On each step, we have beam_size-many hypotheses in the beam, so we need to make a batch of these hypotheses. if FLAGS.mode == 'decode': FLAGS.batch_size = FLAGS.beam_size # If single_pass=True, check we're in decode mode if FLAGS.single_pass and FLAGS.mode!='decode': raise Exception("The single_pass flag should only be True in decode mode") # Make a namedtuple hps, containing the values of the hyperparameters that the model needs hparam_list = ['mode', 'lr', 'adagrad_init_acc', 'rand_unif_init_mag', 'trunc_norm_init_std', 'max_grad_norm', 'hidden_dim', 'emb_dim', 'batch_size', 'max_dec_steps', 'max_enc_steps', 'coverage', 'cov_loss_wt', 'pointer_gen'] hps_dict = {} #print("This is FLAGS -->",FLAGS) for val in FLAGS: # for each flag // New modification for TF 1.5 if val in hparam_list: # if it's in the list hps_dict[val] = FLAGS[val].value # add it to the dict // New modification for TF 1.5 hps = namedtuple("HParams", hps_dict.keys())(**hps_dict) # Create a batcher object that will create minibatches of data batcher = Batcher(FLAGS.data_path, vocab, hps, single_pass=FLAGS.single_pass) tf.set_random_seed(111) # a seed value for randomness if hps.mode == 'train': print("creating model...") model = SummarizationModel(hps, vocab) setup_training(model, batcher) elif hps.mode == 'eval': model = SummarizationModel(hps, vocab) run_eval(model, batcher, vocab) elif hps.mode == 'decode': decode_model_hps = hps # This will be the hyperparameters for the decoder model decode_model_hps = hps._replace(max_dec_steps=1) # The model is configured with max_dec_steps=1 because we only ever run one step of the decoder at a time (to do beam search). Note that the batcher is initialized with max_dec_steps equal to e.g. 100 because the batches need to contain the full summaries model = SummarizationModel(decode_model_hps, vocab) decoder = BeamSearchDecoder(model, batcher, vocab) decoder.decode() # decode indefinitely (unless single_pass=True, in which case deocde the dataset exactly once) else: raise ValueError("The 'mode' flag must be one of train/eval/decode")
def evaluate_model_beam_search(model, src, src_test, trg, trg_test, config, beam_size=1, use_cuda=False): """ evaluate the model use beam search. :param model: :param src: :param src_test: :param trg: :param trg_test: :param config: :param beam_size: :param use_cuda: :return: """ # the test word dict use src's dict src_test['word2id'] = src['word2id'] src_test['id2word'] = src['id2word'] trg_test['word2id'] = trg['word2id'] trg_test['id2word'] = trg['id2word'] decoder = BeamSearchDecoder(config, model.state_dict(), src_test, trg_test, beam_size=beam_size, use_cuda=use_cuda) bleu_score = decoder.translate() return bleu_score
def main(): tf.logging.set_verbosity( tf.logging.INFO) # choose what level of logging you want tf.logging.info('Starting seq2seq_attention in %s mode...', (FLAGS.mode)) # Change log_root to FLAGS.log_root/FLAGS.exp_name and create the dir if necessary FLAGS.log_root = os.path.join(FLAGS.log_root, FLAGS.exp_name) vocab = Vocab(FLAGS.vocab_path, FLAGS.vocab_size) # create a vocabulary FLAGS.batch_size = FLAGS.beam_size hparam_list = [ 'mode', 'lr', 'adagrad_init_acc', 'rand_unif_init_mag', 'trunc_norm_init_std', 'max_grad_norm', 'hidden_dim', 'emb_dim', 'batch_size', 'max_dec_steps', 'max_enc_steps', 'coverage', 'cov_loss_wt', 'pointer_gen' ] hps_dict = {} for key, val in FLAGS.__flags.iteritems(): # for each flag if key in hparam_list: # if it's in the list hps_dict[key] = val # add it to the dict hps = namedtuple("HParams", hps_dict.keys())(**hps_dict) batcher = Batcher(FLAGS.data_path, vocab, hps, single_pass=FLAGS.single_pass) tf.set_random_seed(111) # a seed value for randomness decode_model_hps = hps # This will be the hyperparameters for the decoder model decode_model_hps = hps._replace( max_dec_steps=1 ) # The model is configured with max_dec_steps=1 because we only ever run one step of the decoder at a time (to do beam search). Note that the batcher is initialized with max_dec_steps equal to e.g. 100 because the batches need to contain the full summaries model = SummarizationModel(decode_model_hps, vocab) decoder = BeamSearchDecoder(model, batcher, vocab) decoder.decode( ) # decode indefinitely (unless single_pass=True, in which case deocde the dataset exactly once)
class SummaRiser: def __init__(self, vocab_path, log_path): self.pointer_gen = True self.single_pass = True self.batch_size = self.beam_size = 4 self.vocab_size = 50000 self.vocab_path = vocab_path self.log_root = log_path # Make a namedtuple hps, containing the values of the hyperparameters that the model needs hparam_list = [ 'mode', 'lr', 'adagrad_init_acc', 'rand_unif_init_mag', 'trunc_norm_init_std', 'max_grad_norm', 'hidden_dim', 'emb_dim', 'batch_size', 'max_dec_steps', 'max_enc_steps', 'coverage', 'cov_loss_wt', 'pointer_gen' ] hps_dict = { 'mode': 'decode', 'lr': 0.15, 'adagrad_init_acc': 0.1, 'rand_unif_init_mag': 0.02, 'trunc_norm_init_std': 1e-4, 'max_grad_norm': 2.0, 'hidden_dim': 256, 'emb_dim': 128, 'batch_size': self.batch_size, 'max_dec_steps': 100, 'max_enc_steps': 500, 'coverage': 1, 'cov_loss_wt': 1.0, 'pointer_gen': True, 'min_dec_steps': 35, 'beam_size': self.beam_size } self.hps = namedtuple("HParams", hps_dict.keys())(**hps_dict) self.vocab = Vocab(self.vocab_path, self.vocab_size) decode_model_hps = self.hps # This will be the hyperparameters for the decoder model decode_model_hps = self.hps._replace( max_dec_steps=1 ) # The model is configured with max_dec_steps=1 because we only ever run one step of the decoder at a time (to do beam search). Note that the batcher is initialized with max_dec_steps equal to e.g. 100 because the batches need to contain the full summaries tf.set_random_seed(111) # a seed value for randomness self.model = SummarizationModel(decode_model_hps, self.vocab) self.decoder = BeamSearchDecoder(self.model, self.vocab, True, self.hps, self.pointer_gen, self.log_root) def summarize(self, articles): self.batcher = Batcher(articles, self.vocab, self.hps, single_pass=self.single_pass) self.decoder.setBatcher(self.batcher) return self.decoder.decode( articles ) # decode indefinitely (unless single_pass=True, in which case deocde the dataset exactly once)
def main(unused_argv): if len(unused_argv) != 1: # prints a message if you've entered flags incorrectly raise Exception("Problem with flags: %s" % unused_argv) tf.logging.set_verbosity(tf.logging.INFO) # choose what level of logging you want tf.logging.info('Starting seq2seq_attention in %s mode...', (FLAGS.mode)) # Change log_root to FLAGS.log_root/FLAGS.exp_name and create the dir if necessary FLAGS.log_root = os.path.join(FLAGS.log_root, FLAGS.exp_name) if not os.path.exists(FLAGS.log_root): if FLAGS.mode=="train": os.makedirs(FLAGS.log_root) else: raise Exception("Logdir %s doesn't exist. Run in train mode to create it." % (FLAGS.log_root)) vocab = Vocab(FLAGS.vocab_path, FLAGS.vocab_size) # create a vocabulary # If in decode mode, set batch_size = beam_size # Reason: in decode mode, we decode one example at a time. # On each step, we have beam_size-many hypotheses in the beam, so we need to make a batch of these hypotheses. if FLAGS.mode == 'decode': FLAGS.batch_size = FLAGS.beam_size # If single_pass=True, check we're in decode mode if FLAGS.single_pass and FLAGS.mode!='decode': raise Exception("The single_pass flag should only be True in decode mode") # Make a namedtuple hps, containing the values of the hyperparameters that the model needs hparam_list = ['mode', 'lr', 'adagrad_init_acc', 'rand_unif_init_mag', 'trunc_norm_init_std', 'max_grad_norm', 'hidden_dim', 'emb_dim', 'batch_size', 'max_dec_steps', 'max_enc_steps', 'coverage', 'cov_loss_wt', 'pointer_gen'] hps_dict = {} for key,val in FLAGS.__flags.iteritems(): # for each flag if key in hparam_list: # if it's in the list hps_dict[key] = val # add it to the dict hps = namedtuple("HParams", hps_dict.keys())(**hps_dict) # Create a batcher object that will create minibatches of data batcher = Batcher(FLAGS.data_path, vocab, hps, single_pass=FLAGS.single_pass) tf.set_random_seed(111) # a seed value for randomness if hps.mode == 'train': print "creating model..." model = SummarizationModel(hps, vocab) setup_training(model, batcher) elif hps.mode == 'eval': model = SummarizationModel(hps, vocab) run_eval(model, batcher, vocab) elif hps.mode == 'decode': decode_model_hps = hps # This will be the hyperparameters for the decoder model decode_model_hps = hps._replace(max_dec_steps=1) # The model is configured with max_dec_steps=1 because we only ever run one step of the decoder at a time (to do beam search). Note that the batcher is initialized with max_dec_steps equal to e.g. 100 because the batches need to contain the full summaries model = SummarizationModel(decode_model_hps, vocab) decoder = BeamSearchDecoder(model, batcher, vocab) decoder.decode() # decode indefinitely (unless single_pass=True, in which case deocde the dataset exactly once) else: raise ValueError("The 'mode' flag must be one of train/eval/decode")
def __init__(self, vocab_path, log_root): self.pointer_gen = True self.single_pass = True self.batch_size = self.beam_size = 4 self.vocab_size = 50000 self.vocab_path = vocab_path self.log_root = log_root # Make a namedtuple hps, containing the values of the hyperparameters that the model needs hparam_list = [ 'mode', 'lr', 'adagrad_init_acc', 'rand_unif_init_mag', 'trunc_norm_init_std', 'max_grad_norm', 'hidden_dim', 'emb_dim', 'batch_size', 'max_dec_steps', 'max_enc_steps', 'coverage', 'cov_loss_wt', 'pointer_gen' ] hps_dict = { 'mode': 'decode', 'lr': 0.15, 'adagrad_init_acc': 0.1, 'rand_unif_init_mag': 0.02, 'trunc_norm_init_std': 1e-4, 'max_grad_norm': 2.0, 'hidden_dim': 256, 'emb_dim': 128, 'batch_size': self.batch_size, 'max_dec_steps': 100, 'max_enc_steps': 400, 'coverage': 1, 'cov_loss_wt': 1.0, 'pointer_gen': True, 'min_dec_steps': 35, 'beam_size': self.beam_size } self.hps = namedtuple("HParams", hps_dict.keys())(**hps_dict) self.vocab = Vocab(self.vocab_path, self.vocab_size) tf.logging.set_verbosity( tf.logging.INFO) # choose what level of logging you want # If in decode mode, set batch_size = beam_size # Reason: in decode mode, we decode one example at a time. # On each step, we have beam_size-many hypotheses in the beam, so we need to make a batch of these hypotheses. # decode_model_hps = self.hps # This will be the hyperparameters for the decoder model decode_model_hps = self.hps._replace( max_dec_steps=1 ) # The model is configured with max_dec_steps=1 because we only ever run one step of the decoder at a time (to do beam search). Note that the batcher is initialized with max_dec_steps equal to e.g. 100 because the batches need to contain the full summaries tf.set_random_seed(111) # a seed value for randomness self.model = SummarizationModel(decode_model_hps, self.vocab, self.log_root) self.decoder = BeamSearchDecoder(self.model, self.vocab, True, self.hps, self.pointer_gen, self.log_root)
def decode(): config = decode_config() vocab = Vocab(config['vocab_file'], config['vocab_size']) hps = namedtuple("HParams", config.keys())(**config) batcher = Batcher(FLAGS.data_path, vocab, hps, single_pass=config['single_pass']) from model import SummarizeModel from decode import BeamSearchDecoder ### Model model = SummarizeModel(**config) beamsearch_model = BeamSearchDecoder(model, batcher, vocab) beamsearch_model.decode()
def main(): tf.logging.set_verbosity( tf.logging.INFO) # choose what level of logging you want args = FLAGS # get_args() vocab = Vocab(args.vocab_path, args.vocab_size) # create a vocabulary hps = get_hps() b = json_batch(args.json_path, hps, vocab) batcher = MyBatcher(b, vocab, hps, args.single_pass) decode_model_hps = hps._replace(max_dec_steps=1) model = SummarizationModel(decode_model_hps, vocab) decoder = BeamSearchDecoder(model, batcher, vocab) decoder.decode() import pdb pdb.set_trace() pass
def main(): tf.logging.set_verbosity(tf.logging.INFO) tf.logging.info('Starting seq2seq_attention in %s mode...', (args.mode)) args.model_path = os.path.join(args.model_path, args.exp_name) if not os.path.exists(args.model_path): if args.mode == "train": os.makedirs(args.model_path) else: raise Exception( "Logdir %s doesn't exist. Run in train mode to create it." % (args.model_path)) #加载数据集 加载source的字典 src_vocab = utils.Vocab(args.src_vocab_path, args.src_vocab_size) #加载targe的单词字典# tgt_vocab = utils.Vocab(args.tgt_vocab_path, args.tgt_vocab_size) #把数据集进行batch化,同时加入并发数据队列对数据进行并发传入 batcher = Batcher(args.data_path, src_vocab, tgt_vocab, args) if args.model == "vanilla": model_class = VanillaSeq2seqModel elif args.model == "sep_dec": model_class = SeparateDecoderModel elif args.model == "shd_dec": model_class = SharedDecoderModel tf.set_random_seed(111) if args.mode == 'train': model = model_class(args, src_vocab, tgt_vocab) setup_training(model, batcher) elif args.mode == 'eval': model = model_class(args, src_vocab, tgt_vocab) run_eval(model, batcher, args.ckpt_id) elif args.mode == "decode": args.batch_size = args.beam_size args.arg_max_dec_steps = 1 args.kp_max_dec_steps = 1 model = model_class(args, src_vocab, tgt_vocab) decoder = BeamSearchDecoder(model, batcher, src_vocab, tgt_vocab, args.ckpt_id) decoder.decode() else: raise ValueError("The 'mode' flag must be one of train/eval/decode")
def main(unused_argv, sess_config=None, server_target=None): # if len(unused_argv) != 1: # prints a message if you've entered flags incorrectly # raise Exception("Problem with flags: %s" % unused_argv) vocab, hps = default_setup() if hps.inference: print "Inference Mode" batcher = RawTextBatcher(FLAGS.data_path, vocab, hps, single_pass=FLAGS.single_pass) decode_model_hps = hps # This will be the hyperparameters for the decoder model decode_model_hps = hps._replace( max_dec_steps=1 ) # The model is configured with max_dec_steps=1 because we only ever run one step of the decoder at a time (to do beam search). Note that the batcher is initialized with max_dec_steps equal to e.g. 100 because the batches need to contain the full summaries model = SummarizationModel(decode_model_hps, vocab) decoder = BeamSearchDecoder( model, batcher, vocab) if sess_config is None else BeamSearchDecoder( model, batcher, vocab, sess_config, server_target) decoder.decode( withRouge=False ) # decode indefinitely (unless single_pass=True, in which case deocde the dataset exactly once) else: # Create a batcher object that will create minibatches of data batcher = Batcher(FLAGS.data_path, vocab, hps, single_pass=FLAGS.single_pass) if hps.mode == 'train': print "creating model..." model = SummarizationModel(hps, vocab) setup_training(model, batcher) elif hps.mode == 'eval': model = SummarizationModel(hps, vocab) run_eval(model, batcher, vocab) elif hps.mode == 'decode': decode_model_hps = hps # This will be the hyperparameters for the decoder model decode_model_hps = hps._replace( max_dec_steps=1 ) # The model is configured with max_dec_steps=1 because we only ever run one step of the decoder at a time (to do beam search). Note that the batcher is initialized with max_dec_steps equal to e.g. 100 because the batches need to contain the full summaries model = SummarizationModel(decode_model_hps, vocab) decoder = BeamSearchDecoder(model, batcher, vocab) decoder.decode( ) # decode indefinitely (unless single_pass=True, in which case deocde the dataset exactly once) else: raise ValueError( "The 'mode' flag must be one of train/eval/decode")
def main(): global model global vocab global hps global decoder FLAGS.mode = 'decode' FLAGS.vocab_path = '../vocab' FLAGS.log_root = '../models' FLAGS.exp_name = 'pretrained_model_tf1.2.1' FLAGS.max_enc_steps = 400 FLAGS.max_dec_steps = 120 FLAGS.coverage = 1 FLAGS.single_pass = True tf.logging.set_verbosity(tf.logging.INFO) # choose what level of logging you want tf.logging.info('Starting seq2seq_attention in %s mode...', (FLAGS.mode)) # Change log_root to FLAGS.log_root/FLAGS.exp_name and create the dir if necessary FLAGS.log_root = os.path.join(FLAGS.log_root, FLAGS.exp_name) if not os.path.exists(FLAGS.log_root): if FLAGS.mode=="train": os.makedirs(FLAGS.log_root) else: raise Exception("Logdir %s doesn't exist. Run in train mode to create it." % (FLAGS.log_root)) vocab = Vocab(FLAGS.vocab_path, FLAGS.vocab_size) # create a vocabulary # If in decode mode, set batch_size = beam_size # Reason: in decode mode, we decode one example at a time. # On each step, we have beam_size-many hypotheses in the beam, so we need to make a batch of these hypotheses. if FLAGS.mode == 'decode': FLAGS.batch_size = FLAGS.beam_size # If single_pass=True, check we're in decode mode if FLAGS.single_pass and FLAGS.mode!='decode': raise Exception("The single_pass flag should only be True in decode mode") # Make a namedtuple hps, containing the values of the hyperparameters that the model needs hparam_list = ['mode', 'lr', 'adagrad_init_acc', 'rand_unif_init_mag', 'trunc_norm_init_std', 'max_grad_norm', 'hidden_dim', 'emb_dim', 'batch_size', 'max_dec_steps', 'max_enc_steps', 'coverage', 'cov_loss_wt', 'pointer_gen'] hps_dict = {} for key,val in FLAGS.__flags.items(): # for each flag if key in hparam_list: # if it's in the list hps_dict[key] = val # add it to the dict hps = namedtuple("HParams", hps_dict.keys())(**hps_dict) tf.set_random_seed(111) # a seed value for randomness decode_model_hps = hps # This will be the hyperparameters for the decoder model decode_model_hps = hps._replace(max_dec_steps=1) # The model is configured with max_dec_steps=1 because we only ever run one step of the decoder at a time (to do beam search). Note that the batcher is initialized with max_dec_steps equal to e.g. 100 because the batches need to contain the full summaries model = SummarizationModel(decode_model_hps, vocab) abstract = "tim ist toll" article = "tim ist toll" batcher = Batcher(FLAGS.data_path, vocab, hps, single_pass=FLAGS.single_pass, abstract=abstract, article=article) decoder = BeamSearchDecoder(model, batcher, vocab)
def loadModel(): FLAGS.batch_size = FLAGS.beam_size hps = prepare_hps() vocab = Vocab(FLAGS.vocab_path, FLAGS.vocab_size) decode_model_hps = hps._replace(max_dec_steps=1) generator = Generator(decode_model_hps, vocab) decoder = BeamSearchDecoder(generator, None, vocab) return decoder, hps, vocab
def main(unused_argv): # if len(unused_argv) != 1: # prints a message if you've entered flags incorrectly # raise Exception("Problem with flags: %s" % unused_argv) # Change log_root to FLAGS.log_root/FLAGS.exp_name and create the dir if necessary FLAGS.log_root = os.path.join(FLAGS.log_root, FLAGS.exp_name) vocab = Vocab(FLAGS.vocab_path, FLAGS.vocab_size) # create a vocabulary # If in decode mode, set batch_size = beam_size # Reason: in decode mode, we decode one example at a time. # On each step, we have beam_size-many hypotheses in the beam, so we need to make a batch of these hypotheses. if FLAGS.mode == 'decode': FLAGS.batch_size = FLAGS.beam_size # Make a namedtuple hps, containing the values of the hyperparameters that the model needs hparam_list = [ 'mode', 'lr', 'adagrad_init_acc', 'rand_unif_init_mag', 'trunc_norm_init_std', 'max_grad_norm', 'hidden_dim', 'emb_dim', 'batch_size', 'max_dec_steps', 'max_enc_steps', 'coverage', 'cov_loss_wt', 'pointer_gen' ] hps_dict = {} for key, val in FLAGS.__flags.items(): # for each flag if key in hparam_list: # if it's in the list hps_dict[key] = val # add it to the dict hps = namedtuple("HParams", hps_dict.keys())(**hps_dict) # Create a batcher object that will create minibatches of data batcher = Batcher(FLAGS.data_path, vocab, hps, single_pass=FLAGS.single_pass) tf.set_random_seed(111) # a seed value for randomness decode_model_hps = hps # This will be the hyperparameters for the decoder model decode_model_hps = hps._replace( max_dec_steps=1 ) # The model is configured with max_dec_steps=1 because we only ever run one step of the decoder at a time (to do beam search). Note that the batcher is initialized with max_dec_steps equal to e.g. 100 because the batches need to contain the full summaries model = SummarizationModel(decode_model_hps, vocab) decoder = BeamSearchDecoder(model, batcher, vocab) decoder.decode( ) # decode indefinitely (unless single_pass=True, in which case deocde the dataset exactly once)
def inference_on_flink(context, sess_config, server_target): vocab, hps = default_setup() if hps.inference: print "Inference Mode" batcher = FlinkInferenceBatcher(context, vocab, hps) writer = FlinkWriter(context) decode_model_hps = hps # This will be the hyperparameters for the decoder model decode_model_hps = hps._replace( max_dec_steps=1 ) # The model is configured with max_dec_steps=1 because we only ever run one step of the decoder at a time (to do beam search). Note that the batcher is initialized with max_dec_steps equal to e.g. 100 because the batches need to contain the full summaries model = SummarizationModel(decode_model_hps, vocab) decoder = BeamSearchDecoder( model, batcher, vocab) if sess_config is None else BeamSearchDecoder( model, batcher, vocab, sess_config, server_target, writer) decoder.decode( withRouge=False ) # decode indefinitely (unless single_pass=True, in which case deocde the dataset exactly once)
def main(unused_argv): if len(unused_argv) != 1: raise Exception("Problem with flags: %s" % unused_argv) if FLAGS.mode not in ['train', 'eval', 'decode']: raise ValueError("The 'mode' flag must be one of train/eval/decode") tf.logging.set_verbosity(tf.logging.INFO) tf.set_random_seed(FLAGS.random_seed) print('INFO: Starting seq2seq_attention model in {} mode...'.format( FLAGS.mode)) if not os.path.exists(FLAGS.log_dir): os.makedirs(FLAGS.log_dir) if FLAGS.mode == 'decode': FLAGS.batch_size = FLAGS.beam_size hparam_list = [ 'mode', 'lr', 'adagrad_acc', 'norm_unif', 'norm_trunc', 'norm_grad', 'pointer', 'hidden_dim', 'emb_dim', 'batch_size', 'max_dec_steps', 'max_enc_steps' ] hps_dict = {} for key, val in FLAGS.__flags.iteritems(): if key in hparam_list: hps_dict[key] = val hps = namedtuple("HParams", hps_dict.keys())(**hps_dict) vocab = Vocab(FLAGS.vocab_path, FLAGS.vocab_size) batcher = Batcher(FLAGS.data_path, vocab, hps, onetime=FLAGS.onetime) if hps.mode == 'train': print('INFO: creating model...') model = SummarizationModel(hps, vocab) train(model, batcher) elif hps.mode == 'eval': model = SummarizationModel(hps, vocab) cval(model, batcher, vocab) elif hps.mode == 'decode': decode_mdl_hps = hps decode_mdl_hps = hps._replace(max_dec_steps=1) model = SummarizationModel(decode_mdl_hps, vocab) decoder = BeamSearchDecoder(model, batcher, vocab) decoder._decode()
def main(args): # prints a message if you've entered flags incorrectly if len(args) != 1: raise Exception("Problem with flags: %s" % args) # If in decode mode, set batch_size = beam_size # Reason: in decode mode, we decode one example at a time. # On each step, we have beam_size-many hypotheses in the beam, so we need to make a batch of these hypotheses. if FLAGS.mode == 'decode' or FLAGS.mode == 'predict': FLAGS.batch_size = FLAGS.beam_size # If single_pass=True, check we're in decode mode if FLAGS.single_pass and FLAGS.mode != 'decode' and FLAGS.mode != 'predict': raise Exception( "The single_pass flag should only be True in decode mode") hps = prepare_hps() vocab = Vocab(FLAGS.vocab_path, FLAGS.vocab_size) generator_batcher = Batcher(FLAGS.data_path, vocab, hps, single_pass=FLAGS.single_pass) discriminator_batcher = Batcher(FLAGS.data_path, vocab, hps, single_pass=FLAGS.single_pass) if hps.mode == "pretrain" or hps.mode == "train": generator, discriminator = build_seqgan_graph(hps, vocab) setup_training(hps.mode, generator, discriminator, generator_batcher, discriminator_batcher) elif hps.mode == 'decode': # The model is configured with max_dec_steps=1 because we only ever run one step of # the decoder at a time (to do beam search). decode_model_hps = hps._replace(max_dec_steps=1) generator = Generator(decode_model_hps, vocab) decoder = BeamSearchDecoder(generator, generator_batcher, vocab) decoder.decode() else: raise ValueError( "The 'mode' flag must be one of pretrain/train/decode")
def setup_summarizer(settings): tf.logging.set_verbosity( tf.logging.INFO) # choose what level of logging you want tf.logging.info('Starting seq2seq_attention ') # Change log_root to FLAGS.log_root/FLAGS.exp_name and create the dir if necessary vocab = Vocab(settings.vocab_path, settings.vocab_size) # create a vocabulary # If in decode mode, set batch_size = beam_size # Reason: in decode mode, we decode one example at a time. # On each step, we have beam_size-many hypotheses in the beam, so we need to make a batch of these hypotheses. FLAGS.batch_size = FLAGS.beam_size # Make a namedtuple hps, containing the values of the hyperparameters that the model needs hparam_list = [ 'mode', 'lr', 'adagrad_init_acc', 'rand_unif_init_mag', 'trunc_norm_init_std', 'max_grad_norm', 'hidden_dim', 'emb_dim', 'batch_size', 'max_dec_steps', 'max_enc_steps', 'coverage', 'cov_loss_wt', 'pointer_gen' ] hps_dict = {} for key, val in FLAGS.__flags.items(): # for each flag if key in hparam_list: # if it's in the list hps_dict[key] = val # add it to the dict hps = namedtuple("HParams", list(hps_dict.keys()))(**hps_dict) tf.set_random_seed(111) # a seed value for randomness if hps.mode != 'decode': raise ValueError("The 'mode' flag must be decode for serving") decode_model_hps = hps # This will be the hyperparameters for the decoder model decode_model_hps = hps._replace( max_dec_steps=1 ) # The model is configured with max_dec_steps=1 because we only ever run one step of the decoder at a time (to do beam search). Note that the batcher is initialized with max_dec_steps equal to e.g. 100 because the batches need to contain the full summaries serving_device = '/cpu:0' model = SummarizationModel(decode_model_hps, vocab, default_device=serving_device) decoder = BeamSearchDecoder(model, None, vocab) return Summarizer(decoder, vocab=vocab, hps=hps)
def main(unused_argv): if FLAGS.placeholder: tf.logging.info('try to occupy GPU memory!') config = tf.ConfigProto(allow_soft_placement=True) config.gpu_options.per_process_gpu_memory_fraction = 0.8 placeholder_session = tf.Session(config=config) limit = placeholder_session.run( tf.contrib.memory_stats.BytesLimit()) / 1073741824 tf.logging.info('occupy GPU memory %f GB', limit) if len(unused_argv ) != 1: # prints a message if you've entered flags incorrectly raise Exception("Problem with flags: %s" % unused_argv) tf.logging.set_verbosity( tf.logging.INFO) # choose what level of logging you want tf.logging.info('Starting seq2seq_attention in %s mode...', (FLAGS.mode)) # Change log_root to FLAGS.log_root/FLAGS.exp_name and create the dir if necessary FLAGS.log_root = os.path.join(FLAGS.log_root, FLAGS.exp_name) if not os.path.exists(FLAGS.log_root): if FLAGS.mode == "train": os.makedirs(FLAGS.log_root) else: raise Exception( "Logdir %s doesn't exist. Run in train mode to create it." % (FLAGS.log_root)) vocab = Vocab(FLAGS.vocab_path, FLAGS.vocab_size) # create a vocabulary # If in decode mode, set batch_size = beam_size # Reason: in decode mode, we decode one example at a time. # On each step, we have beam_size-many hypotheses in the beam, so we need to make a batch of these hypotheses. if FLAGS.mode == 'decode' or FLAGS.mode == 'auto_decode': FLAGS.batch_size = FLAGS.beam_size # Make a namedtuple hps, containing the values of the hyperparameters that the model needs hparam_list = [ 'mode', 'lr', 'adagrad_init_acc', 'rand_unif_init_mag', 'trunc_norm_init_std', 'max_grad_norm', 'hidden_dim', 'emb_dim', 'batch_size', 'max_dec_steps', 'max_enc_steps', 'max_side_steps', 'coverage', 'cov_loss_wt', 'pointer_gen', 'epoch_num', 'current_source_code_zip', 'multi_dec_steps' ] hps_dict = {} for key, val in FLAGS.__flags.items(): # for each flag if key in hparam_list: # if it's in the list hps_dict[key] = val.value # add it to the dict hps = namedtuple("HParams", hps_dict.keys())(**hps_dict) # save python source code current_time_str = datetime.now().strftime('%m-%d-%H-%M') FLAGS.current_source_code_zip = os.path.abspath( os.path.join( FLAGS.log_root, 'source_code_bak-' + current_time_str + '-' + FLAGS.mode + '.zip')) tf.logging.info('saving source code: %s', FLAGS.current_source_code_zip) python_list = glob.glob('./*.py') zip_file = zipfile.ZipFile(FLAGS.current_source_code_zip, 'w') for d in python_list: zip_file.write(d) zip_file.close() # Create a batcher object that will create minibatches of data batcher = Batcher(FLAGS.data_path, vocab, hps, single_pass=FLAGS.single_pass) tf.set_random_seed(111) # a seed value for randomness if hps.mode == 'train': print("creating model...") model = SummarizationModel(hps, vocab) if FLAGS.placeholder: placeholder_session.close() setup_training(model, batcher) elif hps.mode == 'eval': model = SummarizationModel(hps, vocab) run_eval(model, batcher, vocab) elif hps.mode == 'decode': decode_model_hps = hps # This will be the hyperparameters for the decoder model decode_model_hps = hps._replace( max_dec_steps=1 ) # The model is configured with max_dec_steps=1 because we only ever run one step of the decoder at a time (to do beam search). Note that the batcher is initialized with max_dec_steps equal to e.g. 100 because the batches need to contain the full summaries model = SummarizationModel(decode_model_hps, vocab) decoder = BeamSearchDecoder(model, batcher, vocab) decoder.decode( ) # decode indefinitely (unless single_pass=True, in which case deocde the dataset exactly once) elif hps.mode == 'auto_decode': decode_model_hps = hps # This will be the hyperparameters for the decoder model decode_model_hps = hps._replace( max_dec_steps=1 ) # The model is configured with max_dec_steps=1 because we only ever run one step of the decoder at a time (to do beam search). Note that the batcher is initialized with max_dec_steps equal to e.g. 100 because the batches need to contain the full summaries model = SummarizationModel(decode_model_hps, vocab) decoder = BeamSearchDecoder(model, batcher, vocab, hps.epoch_num) decoder.decode() else: raise ValueError("The 'mode' flag must be one of train/eval/decode")
def main(unused_argv): if len( unused_argv) != 1: # prints a message if you've entered flags incorrectly raise Exception("Problem with flags: %s" % unused_argv) if FLAGS.dataset_name != "": FLAGS.data_path = os.path.join(FLAGS.data_root, FLAGS.dataset_name, FLAGS.dataset_split + '*') if not os.path.exists( os.path.join(FLAGS.data_root, FLAGS.dataset_name)) or len( os.listdir(os.path.join(FLAGS.data_root, FLAGS.dataset_name))) == 0: print( 'No TF example data found at %s so creating it from raw data.' % os.path.join( FLAGS.data_root, FLAGS.dataset_name)) convert_data.process_dataset(FLAGS.dataset_name) logging.set_verbosity(logging.INFO) # choose what level of logging you want logging.info('Starting seq2seq_attention in %s mode...', (FLAGS.mode)) # Change log_root to FLAGS.log_root/FLAGS.exp_name and create the dir if necessary FLAGS.exp_name = FLAGS.exp_name if FLAGS.exp_name != '' else FLAGS.dataset_name FLAGS.actual_log_root = FLAGS.log_root FLAGS.log_root = os.path.join(FLAGS.log_root, FLAGS.exp_name) vocab = Vocab(FLAGS.vocab_path, FLAGS.vocab_size) # create a vocabulary # If in decode mode, set batch_size = beam_size # Reason: in decode mode, we decode one example at a time. # On each step, we have beam_size-many hypotheses in the beam, so we need to make a batch of these hypotheses. if FLAGS.mode == 'decode': FLAGS.batch_size = FLAGS.beam_size # If single_pass=True, check we're in decode mode if FLAGS.single_pass and FLAGS.mode != 'decode': raise Exception( "The single_pass flag should only be True in decode mode") # Make a namedtuple hps, containing the values of the hyperparameters that the model needs hparam_list = ['mode', 'lr', 'adagrad_init_acc', 'rand_unif_init_mag', 'trunc_norm_init_std', 'max_grad_norm', 'hidden_dim', 'emb_dim', 'batch_size', 'max_dec_steps', 'max_enc_steps', 'coverage', 'cov_loss_wt', 'pointer_gen'] hps_dict = {} for key, val in FLAGS.__flags.iteritems(): # for each flag if key in hparam_list: # if it's in the list hps_dict[key] = val.value # add it to the dict hps = namedtuple("HParams", hps_dict.keys())(**hps_dict) if FLAGS.pg_mmr or FLAGS.pg_mmr_sim or FLAGS.pg_mmr_diff: # Fit the TFIDF vectorizer if not already fitted if FLAGS.importance_fn == 'tfidf': tfidf_model_path = os.path.join(FLAGS.actual_log_root, 'tfidf_vectorizer', FLAGS.dataset_name + '.dill') if not os.path.exists(tfidf_model_path): print( 'No TFIDF vectorizer model file found at %s, so fitting the model now.' % tfidf_model_path) tfidf_vectorizer = fit_tfidf_vectorizer(hps, vocab) with open(tfidf_model_path, 'wb') as f: dill.dump(tfidf_vectorizer, f) # Train the SVR model on the CNN validation set if not already trained if FLAGS.importance_fn == 'svr': save_path = os.path.join(FLAGS.data_root, 'svr_training_data') importance_model_path = os.path.join(FLAGS.actual_log_root, 'svr.pickle') dataset_split = 'val' if not os.path.exists(importance_model_path): if not os.path.exists(save_path) or len( os.listdir(save_path)) == 0: print( 'No importance_feature instances found at %s so creating it from raw data.' % save_path) decode_model_hps = hps._replace( max_dec_steps=1, batch_size=100, mode='calc_features') # The model is configured with max_dec_steps=1 because we only ever run one step of the decoder at a time (to do beam search). Note that the batcher is initialized with max_dec_steps equal to e.g. 100 because the batches need to contain the full summaries cnn_dm_train_data_path = os.path.join(FLAGS.data_root, FLAGS.dataset_name, dataset_split + '*') batcher = Batcher(cnn_dm_train_data_path, vocab, decode_model_hps, single_pass=FLAGS.single_pass, cnn_500_dm_500=False) calc_features(cnn_dm_train_data_path, decode_model_hps, vocab, batcher, save_path) print( 'No importance_feature SVR model found at %s so training it now.' % importance_model_path) features_list = importance_features.get_features_list(True) sent_reps = importance_features.load_data( os.path.join(save_path, dataset_split + '*'), -1) print 'Loaded %d sentences representations' % len(sent_reps) x_y = importance_features.features_to_array(sent_reps, features_list) train_x, train_y = x_y[:, :-1], x_y[:, -1] svr_model = importance_features.run_training(train_x, train_y) with open(importance_model_path, 'wb') as f: cPickle.dump(svr_model, f) # Create a batcher object that will create minibatches of data batcher = Batcher(FLAGS.data_path, vocab, hps, single_pass=FLAGS.single_pass) tf.set_random_seed(111) # a seed value for randomness # Start decoding on multi-document inputs if hps.mode == 'decode': decode_model_hps = hps._replace( max_dec_steps=1) # The model is configured with max_dec_steps=1 because we only ever run one step of the decoder at a time (to do beam search). Note that the batcher is initialized with max_dec_steps equal to e.g. 100 because the batches need to contain the full summaries model = SummarizationModel(decode_model_hps, vocab) decoder = BeamSearchDecoder(model, batcher, vocab) decoder.decode() # decode indefinitely (unless single_pass=True, in which case deocde the dataset exactly once) else: raise ValueError("The 'mode' flag must be one of train/eval/decode")
def main(unused_argv): if len(unused_argv ) != 1: # prints a message if you've entered flags incorrectly raise Exception("Problem with flags: %s" % unused_argv) extractor = 'bert' if FLAGS.use_bert else 'lambdamart' pretrained_dataset = FLAGS.dataset_name if FLAGS.dataset_name == 'duc_2004': pretrained_dataset = 'cnn_dm' if FLAGS.singles_and_pairs == 'both': FLAGS.exp_name = FLAGS.dataset_name + '_' + FLAGS.exp_name + extractor + '_both' FLAGS.pretrained_path = os.path.join(FLAGS.log_root, pretrained_dataset + '_both') dataset_articles = FLAGS.dataset_name else: FLAGS.exp_name = FLAGS.dataset_name + '_' + FLAGS.exp_name + extractor + '_singles' FLAGS.pretrained_path = os.path.join(FLAGS.log_root, pretrained_dataset + '_singles') dataset_articles = FLAGS.dataset_name + '_singles' if FLAGS.upper_bound: FLAGS.exp_name = FLAGS.exp_name + '_upperbound' ssi_list = None # this is if we are doing the upper bound evaluation (ssi_list comes straight from the groundtruth) else: my_log_dir = os.path.join( log_dir, '%s_%s_%s' % (FLAGS.dataset_name, extractor, FLAGS.singles_and_pairs)) with open(os.path.join(my_log_dir, 'ssi.pkl'), 'rb') as f: ssi_list = pickle.load(f) print('Running statistics on %s' % FLAGS.exp_name) if FLAGS.dataset_name != "": FLAGS.data_path = os.path.join(FLAGS.data_root, FLAGS.dataset_name, FLAGS.dataset_split + '*') if not os.path.exists(os.path.join( FLAGS.data_root, FLAGS.dataset_name)) or len( os.listdir(os.path.join(FLAGS.data_root, FLAGS.dataset_name))) == 0: raise Exception('No TF example data found at %s.' % os.path.join(FLAGS.data_root, FLAGS.dataset_name)) logging.set_verbosity( logging.INFO) # choose what level of logging you want logging.info('Starting seq2seq_attention in %s mode...', (FLAGS.mode)) # Change log_root to FLAGS.log_root/FLAGS.exp_name and create the dir if necessary FLAGS.exp_name = FLAGS.exp_name if FLAGS.exp_name != '' else FLAGS.dataset_name FLAGS.actual_log_root = FLAGS.log_root FLAGS.log_root = os.path.join(FLAGS.log_root, FLAGS.exp_name) print(util.bcolors.OKGREEN + "Experiment path: " + FLAGS.log_root + util.bcolors.ENDC) if FLAGS.dataset_name == 'duc_2004': vocab = Vocab(FLAGS.vocab_path + '_' + 'cnn_dm', FLAGS.vocab_size) # create a vocabulary else: vocab = Vocab(FLAGS.vocab_path + '_' + FLAGS.dataset_name, FLAGS.vocab_size) # create a vocabulary # If in decode mode, set batch_size = beam_size # Reason: in decode mode, we decode one example at a time. # On each step, we have beam_size-many hypotheses in the beam, so we need to make a batch of these hypotheses. if FLAGS.mode == 'decode': FLAGS.batch_size = FLAGS.beam_size # If single_pass=True, check we're in decode mode if FLAGS.single_pass and FLAGS.mode != 'decode': raise Exception( "The single_pass flag should only be True in decode mode") # Make a namedtuple hps, containing the values of the hyperparameters that the model needs hparam_list = [ item for item in list(FLAGS.flag_values_dict().keys()) if item != '?' ] hps_dict = {} for key, val in FLAGS.__flags.items(): # for each flag if key in hparam_list: # if it's in the list hps_dict[key] = val.value # add it to the dict hps = namedtuple("HParams", list(hps_dict.keys()))(**hps_dict) tf.set_random_seed(113) # a seed value for randomness decode_model_hps = hps._replace( max_dec_steps=1 ) # The model is configured with max_dec_steps=1 because we only ever run one step of the decoder at a time (to do beam search). Note that the batcher is initialized with max_dec_steps equal to e.g. 100 because the batches need to contain the full summaries if len(unused_argv ) != 1: # prints a message if you've entered flags incorrectly raise Exception("Problem with flags: %s" % unused_argv) start_time = time.time() np.random.seed(random_seed) source_dir = os.path.join(FLAGS.data_root, dataset_articles) source_files = sorted(glob.glob(source_dir + '/' + dataset_split + '*')) total = len( source_files ) * 1000 if 'cnn' in dataset_articles or 'xsum' in dataset_articles else len( source_files) example_generator = data.example_generator(source_dir + '/' + dataset_split + '*', True, False, should_check_valid=False) # batcher = Batcher(None, vocab, hps, single_pass=FLAGS.single_pass) model = SummarizationModel(decode_model_hps, vocab) decoder = BeamSearchDecoder(model, None, vocab) decoder.decode_iteratively(example_generator, total, names_to_types, ssi_list, hps)
def main(self, unused_argv): if len(unused_argv) != 1: # prints a message if you've entered flags incorrectly raise Exception("Problem with flags: %s" % unused_argv) FLAGS.log_root = os.path.join(FLAGS.log_root, FLAGS.exp_name) tf.logging.set_verbosity(tf.logging.INFO) # choose what level of logging you want tf.logging.info('Starting seq2seq_attention in %s mode...', (FLAGS.mode)) # Change log_root to FLAGS.log_root/FLAGS.exp_name and create the dir if necessary flags = getattr(FLAGS,"__flags") if not os.path.exists(FLAGS.log_root): if FLAGS.mode=="train": os.makedirs(FLAGS.log_root) else: raise Exception("Logdir %s doesn't exist. Run in train mode to create it." % (FLAGS.log_root)) fw = open('{}/config.txt'.format(FLAGS.log_root),'w') for k,v in flags.items(): fw.write('{}\t{}\n'.format(k,v)) fw.close() self.vocab = Vocab(FLAGS.vocab_path, FLAGS.vocab_size) # create a vocabulary # If in decode mode, set batch_size = beam_size # Reason: in decode mode, we decode one example at a time. # On each step, we have beam_size-many hypotheses in the beam, so we need to make a batch of these hypotheses. if FLAGS.mode == 'decode': FLAGS.batch_size = FLAGS.beam_size # If single_pass=True, check we're in decode mode if FLAGS.single_pass and FLAGS.mode!='decode': raise Exception("The single_pass flag should only be True in decode mode") # Make a namedtuple hps, containing the values of the hyperparameters that the model needs hparam_list = ['mode', 'lr', 'gpu_num', 'gamma', 'eta', 'zeta', 'fixed_zeta', 'zeta_clipping', 'rl_start_step', 'fixed_eta', 'reward_function', 'intradecoder', 'use_temporal_attention', 'ac_training','rl_training', 'matrix_attention', 'calculate_true_q', 'enc_hidden_dim', 'dec_hidden_dim', 'k', 'scheduled_sampling', 'sampling_probability','fixed_sampling_probability', 'alpha', 'hard_argmax', 'greedy_scheduled_sampling', 'adagrad_init_acc', 'rand_unif_init_mag', 'trunc_norm_init_std', 'max_grad_norm', 'emb_dim', 'batch_size', 'max_dec_steps', 'max_enc_steps', 'dqn_scheduled_sampling', 'dqn_sleep_time', 'E2EBackProp', 'coverage', 'cov_loss_wt', 'pointer_gen', 'partial_rewarding'] hps_dict = {} for key,val in flags.items(): # for each flag if key in hparam_list: # if it's in the list hps_dict[key] = val.value # add it to the dict self.hps = namedtuple("HParams", hps_dict.keys())(**hps_dict) # Create a batcher object that will create minibatches of data self.full_batcher = Batcher(FLAGS.full_data_path, self.vocab, self.hps, single_pass=FLAGS.single_pass, decode_after=FLAGS.decode_after) self.partial_batcher = Batcher(FLAGS.partial_data_path, self.vocab, self.hps, single_pass=FLAGS.single_pass, decode_after=FLAGS.decode_after) tf.set_random_seed(111) # a seed value for randomness if self.hps.mode == 'train': print("creating model...") if FLAGS.rl_training: # merging batches from full and partial datasets self.hps = self.hps._replace(batch_size=2 * self.hps.batch_size) self.model = SummarizationModel(self.hps, self.vocab) self.setup_training() elif self.hps.mode == 'eval': if FLAGS.rl_training: # merging batches from full and partial datasets self.hps = self.hps._replace(batch_size=2 * self.hps.batch_size) self.model = SummarizationModel(self.hps, self.vocab) self.run_eval() elif self.hps.mode == 'decode': decode_model_hps = self.hps decode_model_hps = self.hps._replace(max_dec_steps=1) # The model is configured with max_dec_steps=1 because we only ever run one step of the decoder at a time (to do beam search). Note that the batcher is initialized with max_dec_steps equal to e.g. 100 because the batches need to contain the full summaries print(decode_model_hps) model = SummarizationModel(decode_model_hps, self.vocab) if FLAGS.partial_decoding: decoder = BeamSearchDecoder(model, self.partial_batcher, self.vocab, dqn = None) else: decoder = BeamSearchDecoder(model, self.full_batcher, self.vocab, dqn = None) decoder.decode() # decode indefinitely (unless single_pass=True, in which case deocde the dataset exactly once) else: raise ValueError("The 'mode' flag must be one of train/eval/decode")
def main(unused_argv): # GPU tricks if FLAGS.device == None: index_of_gpu = get_available_gpu() if index_of_gpu < 0: index_of_gpu = '' FLAGS.device = index_of_gpu tf.logging.info(bcolors.OKGREEN + 'using {}'.format(FLAGS.device) + bcolors.ENDC) #终端颜色 else: index_of_gpu = FLAGS.device os.environ["CUDA_VISIBLE_DEVICES"] = str(index_of_gpu) tf.logging.info('try to occupy GPU memory!') placeholder_session = tf.Session() #tf.contrib.memory_stats.BytesLimit():Generates an op that measures the total memory (in bytes) of a device. limit = placeholder_session.run( tf.contrib.memory_stats.BytesLimit()) / 1073741824 tf.logging.info('occupy GPU memory %f GB', limit) if len(unused_argv ) != 1: # prints a message if you've entered flags incorrectly raise Exception("Problem with flags: %s" % unused_argv) tf.logging.info('Starting seq2seq_attention in %s mode...', (FLAGS.mode)) # Change log_root to FLAGS.log_root/FLAGS.exp_name and create the dir if necessary FLAGS.log_root = os.path.join(FLAGS.log_root, FLAGS.exp_name) if not os.path.exists(FLAGS.log_root): if FLAGS.mode == "train": os.makedirs(FLAGS.log_root) else: raise Exception( "Logdir %s doesn't exist. Run in train mode to create it." % (FLAGS.log_root)) tf.logging.info("vocab path is %s ", FLAGS.vocab_path) vocab = Vocab(FLAGS.vocab_path, FLAGS.vocab_size) # create a vocabulary # If in decode mode, set batch_size = beam_size # Reason: in decode mode, we decode one example at a time. # On each step, we have beam_size-many hypotheses in the beam, so we need to make a batch of these hypotheses. if FLAGS.mode == 'decode': FLAGS.batch_size = FLAGS.beam_size # If single_pass=True, check we're in decode mode if FLAGS.single_pass and FLAGS.mode != 'decode': raise Exception( "The single_pass flag should only be True in decode mode") # Make a namedtuple hps, containing the values of the hyperparameters that the model needs hparam_list = [ 'mode', 'lr', 'adagrad_init_acc', 'rand_unif_init_mag', 'trunc_norm_init_std', 'max_grad_norm', 'hidden_dim', 'emb_dim', 'batch_size', 'max_dec_steps', 'max_enc_steps', 'coverage', 'cov_loss_wt', 'pointer_gen' ] hps_dict = {} export_json = {} for key, val in FLAGS.__flags.items(): export_json[key] = val if key in hparam_list: hps_dict[key] = val tf.logging.info('{} {}'.format(key, val)) # hps = namedtuple("HParams", hps_dict.keys())(**hps_dict) ###################### # save parameters and python script ###################### # save parameters tf.logging.info('saving parameters') current_time_str = datetime.now().strftime('%m-%d-%H-%M') json_para_file = open( os.path.join(FLAGS.log_root, 'flags-' + current_time_str + '-' + FLAGS.mode + '.json'), 'w') json_para_file.write(json.dumps(export_json, indent=4) + '\n') json_para_file.close() # save python source code tf.logging.info('saving source code') python_list = glob.glob('./*.py') zip_file = zipfile.ZipFile( os.path.join( FLAGS.log_root, 'source_code_bak-' + current_time_str + '-' + FLAGS.mode + '.zip'), 'w') for d in python_list: zip_file.write(d) zip_file.close() # Create a batcher object that will create minibatches of data batcher = Batcher(FLAGS.data_path, vocab, hps, single_pass=FLAGS.single_pass) tf.set_random_seed(111) # a seed value for randomness if hps.mode == 'train': tf.logging.info("creating model...") model = SummarizationModel(hps, vocab) placeholder_session.close() setup_training(model, batcher) elif hps.mode == 'eval': model = SummarizationModel(hps, vocab) placeholder_session.close() run_eval(model, batcher, vocab) elif hps.mode == 'decode': decode_model_hps = hps # This will be the hyperparameters for the decoder model decode_model_hps = hps._replace( max_dec_steps=1 ) # The model is configured with max_dec_steps=1 because we only ever run one step of the decoder at a time (to do beam search). Note that the batcher is initialized with max_dec_steps equal to e.g. 100 because the batches need to contain the full summaries model = SummarizationModel(decode_model_hps, vocab) decoder = BeamSearchDecoder(model, batcher, vocab) placeholder_session.close() try: decoder.decode( ) # decode indefinitely (unless single_pass=True, in which case deocde the dataset exactly once) except KeyboardInterrupt: tf.logging.info('stop decoding!') else: raise ValueError("The 'mode' flag must be one of train/eval/decode")
def run_training_reinforce(hps, retrain_model_hps, eval_hps, model_train, model_decode, batcher, neg_batcher, vocab): train_dir = os.path.join(FLAGS.log_root, 'train') if not os.path.exists(train_dir): os.makedirs(train_dir) config = util.get_config() default_device = tf.device('/cpu:0') with default_device(): G_d = tf.Graph() G_t = tf.Graph() R = tf.Graph() with G_d.as_default(): model_decode.build_graph() model_dvars = tf.get_collection(tf.GraphKeys.VARIABLES) with G_t.as_default(): model_train.build_grapg() model_tvars = tf.get_collection(tf.GraphKeys.VARIABLES) ranker, rank_sess, _ = MultiFeedForwardClassifier.load( FLAGS.rank_log_root, graph=R, batch_size=FLAGS.batch_size) rank_world_dict, rank_embeddings = ioutils.load_embeddings( FLAGS.rank_embed_size, FLAGS.rank_vocab_file, generate=False, load_extrac_from=FLAGS.rank_log_root, normalize=True) ranker.initialize_embeddings(rank_sess, rank_embeddings) decode_saver = tf.train.Saver(model_dvars) train_saver = tf.train.Saver(model_tvars, max_to_keep=10) model_ckpt_state = tf.train.get_checkpoint_state(train_dir) decode_sess = tf.Session(config=config, graph=G_d) train_sess = tf.Session(config=config, graph=G_t) train_saver = util.restore_model( train_sess, train_saver, model_ckpt_state.model_checkpoint_path, model_tvars, save=True) decode_saver = util.restore_model( decode_sess, decode_saver, model_ckpt_state.model_checkpoint_path, model_dvars) decoder = BeamSearchDecoder(model_decode, None, vocab, sess=decode_sess) train_step = 0 hist_batch = [] while True: batch = batcher.next_batch() neg_batch = neg_batcher.next_batch() pos_tg_len = np.sum(batch.padding_mask, axis=1) neg_tg_len = np.sum(neg_batch.padding_mask, axis=1) model_ckpt_state = train.train.get_checkpoint_state(train_dir) decode_saver.restore(decode_sess, model_ckpt_state.model_checkpoint_path) decoder = BeamSeachDecoder(model_decode, None, vocab, sess=decode_sess) pos_gen_out, pos_gen_out_extended_vocab, pos_all_hyp = decoder.sample_batch_wise( batch, sampling=FLAGS.sampling, preserve_hyp=True, temp_ratio=FLAGS.temp_ratio) neg_gen_out, neg_gen_out_extended_vocab, neg_all_hyp = decoder.sample_batch_wise( neg_batch, sampling=FLAGS.sampling, preserve_hyp=True, temp_ratio=FLAGS.temp_ratio) assert len(pos_gen_out) == hps.batch_size pos_decode_len = util.measure_len(pos_gen_out, vocab) neg_decode_len = util.measure_len(neg_gen_out, vocab) rank_src = util.convert_to_full_vocab(batch.enc_batch_extend_vocab, rank_word_dict, vocab, batch.art_oovs) rank_tg = util.convert_to_full_vocab(pos_gen_out_extended_vocabm rank_word_dict, vocab, batch.art_oovs) pos_sent_reward = ranker.eval(rank_sess, rank_src, rank_tg, batch.enc_lens, np.array(pos_decode_len)-1) rank_src = util.convert_to_full_vocab( neg_batch.enc_batch_extend_vocab, rank_word_dict, vocab, neg_batch.art_oovs) rank_tg = util.convert_to_full_vocab( neg_gen_out_extended_vocab, rank_word_dict, vocab, neg_batch.art_oovs) neg_sent_reward = ranker.eval(rank_sess, rank_src, rank_tg, neg_batch.enc_lens, np.array(neg_decode_len)-1) sent_reward = np.concatenate((pos_sent_reward, neg_sent_reward), axis=0) ################################################################################### # train G pos_decode_reward = cal_ranker_reward( batch, vocab, rank_word_dict, pos_all_hyp, decoder, ranker, rank_sess, pos_tg_len, rank_gt=FLAGS.rank_gt) neg_decode_reward = cal_ranker_reward( neg_batch, vocab, rank_word_dict, neg_all_hyp, decoder, ranker, rank_sess, neg_tg_len) decode_reward = np.concatenate((pos_decode_reward, neg_decode_reward), axis=0) msk = np.zeros_like(decode_reward) decode_len = np.concatenate((pos_decode_len, neg_decode_len), axis=0) for b, l in enumerate(decode_len): msk[b, :l] = 1 rewards = decode_reward * msk / FLAGS.num_mc sent_reward = util.rank_sentence(sent_reward, scale=FLAGS.sent_scale) rewards = util.rescale_reward(rewards, sent_reward, msk, scale=FLAGS.token_scale) rewards = rewards * msk dec_inp, target, padding = util.prepare_retrain_data( hps, pos_gen_out, pos_gen_out_extended_vocab, vocab, pos_decode_len) neg_dec_inp, neg_target, neg_padding = util.prepare_retrain_data( hps, neg_gen_out, neg_gen_out_extended_vocab, vocab, neg_decode_len) dec_inp = np.concatenate((dec_inp, dec_inp, neg_dec_inp), axis=0) target = np.concatenate((target, target, neg_target), axis=0) padding = np.concatenate((padding, padding, neg_padding), axis=0) rewards = np.concatenate(( rewards[:FLAGS.batch_size], np.ones(FLAGS.batch_size), rewards[FLAGS.batch_size:] )) rslts = model_train.run_train_step_with_reward( train_sess, batch, dec_inp, target, padding, rewards, neg_batch=neg_batch, temp_ratio=FLAGS.temp_ratio) train_step = rslts['global_step'] train_saver.save( train_sess, os.path.join(train_dir, 'model.ckpt'), global_step=train_step ) if train_step & 50 == 0: train_saver.save( train_sess, os.path.join(save_dir, 'model.ckpt'), global_step=train_step ) eval_loss = 0 eval_batcher = SimpleBatcher(FLAGS.eval_data_path, vocab, eval_hps) eval_batcher_sz = SimpleBatcher(FLAGS.eval_data_path, vocab, eval_hps) eval_saver.restore(eval_sess, model_ckpt_state.model_checkpoint_path) for _ in range(eval_batcher.num_batch): eval_batch = eval_batcher.next_batch() eval_loss += model_eval.run_eval_step(eval_sess, eval_batch)['loss'] score = 0 sample_score = 0 rouge_score = 0 rouge2_score = 0 rougel_score = 0 bleu_score = 0 for j in range(eval_batcher_sz.num_batch): eval_batch = eval_batcher_sz.next_batch() tg_len = np.sum(eval_batch.padding_mask, axis=1) _, sample_out_extended_vocab = decoder.sample_batch_wise( eval_batch, sampling=FLAGS.rank_sampling, temp_ratio=FLAGS.sample_temp_ratio) sample_len = util.measure_len(sample_out_extended_vocab, vocab) gen_out, gen_out_extended_vocab = decoder.sample_batch_wise
def main(_): tf.gfile.MakeDirs(FLAGS.output_dir) tf.logging.set_verbosity( tf.logging.INFO) # choose what level of logging you want tf.logging.info('Starting seq2seq_attention in %s mode...', (FLAGS.mode)) # create a vocabulary vocab = Vocab(FLAGS.vocab_path, FLAGS.vocab_size) # If in decode mode, set batch_size = beam_size # Reason: in decode mode, we decode one example at a time. # On each step, we have beam_size-many hypotheses in the beam, so we need to make a batch of these hypotheses. if FLAGS.mode == 'decode': FLAGS.batch_size = FLAGS.beam_size # If single_pass=True, check we're in decode mode if FLAGS.single_pass and FLAGS.mode not in ['decode', 'test']: raise Exception( "The single_pass flag should only be True in decode mode") run_config = tf.contrib.tpu.RunConfig( model_dir=FLAGS.output_dir, save_checkpoints_steps=FLAGS.save_checkpoints_steps) # Make a namedtuple hps, containing the values of the hyperparameters that the model needs hparam_list = [ 'init_checkpoint', 'mode', 'learning_rate', 'adagrad_init_acc', 'rand_unif_init_mag', 'trunc_norm_init_std', 'max_grad_norm', 'hidden_dim', 'emb_dim', 'batch_size', 'max_dec_steps', 'max_enc_steps', 'coverage', 'cov_loss_wt', 'pointer_gen', 'num_train_steps', 'use_tpu', 'num_train_steps', 'num_warmup_steps' ] hps_dict = {} for key, val in FLAGS.__flags.items(): # for each flag if key in hparam_list: # if it's in the list hps_dict[key] = val # add it to the dict hps = namedtuple("HParams", hps_dict.keys())(**hps_dict) # Create a batcher object that will create minibatches of data batcher = Batcher(FLAGS.input_file, vocab, hps, single_pass=FLAGS.single_pass) if hps.mode.value == 'train': tf.logging.info("***** Running training *****") tf.logging.info(" Batch size = %d", FLAGS.batch_size) model = SummarizationModel(hps, vocab) setup_training(model, batcher) elif hps.mode.value == 'eval': tf.logging.info("***** Running evaluation *****") tf.logging.info(" Batch size = %d", FLAGS.batch_size) model = SummarizationModel(hps, vocab) run_eval(model, batcher, vocab) elif hps.mode.value == 'decode': decode_model_hps = hps._replace(max_dec_steps=1) model = SummarizationModel(decode_model_hps, vocab) decoder = BeamSearchDecoder(model, batcher, vocab) # When we set single_pass=True (default), decode the dataset exactly once decoder.decode() else: raise ValueError("The 'mode' flag must be one of train/eval/decode")
def main(unused_argv): if len(unused_argv ) != 1: # prints a message if you've entered flags incorrectly raise Exception("Problem with flags: %s" % unused_argv) tf.logging.set_verbosity( tf.logging.INFO) # choose what level of logging you want tf.logging.info('Starting seq2seq_attention in %s mode...', (FLAGS.mode)) # Change log_root to FLAGS.log_root/FLAGS.exp_name and create the dir if necessary FLAGS.log_root = os.path.join(FLAGS.log_root, FLAGS.exp_name) if not os.path.exists(FLAGS.log_root): if FLAGS.mode == "train": os.makedirs(FLAGS.log_root) else: raise Exception( "Logdir %s doesn't exist. Run in train mode to create it." % (FLAGS.log_root)) vocab = Vocab(FLAGS.vocab_path, FLAGS.vocab_size) # create a vocabulary stop_word_ids = get_stop_word_ids( FLAGS.stop_words_path, vocab ) if FLAGS.pointer_gen and ( FLAGS.co_occurrence or FLAGS.prev_relation or FLAGS.co_occurrence_h or FLAGS.co_occurrence_i or (FLAGS.coverage and FLAGS.coverage_weighted) ) or FLAGS.attention_weighted or FLAGS.markov_attention or FLAGS.markov_attention_contribution else None # If in decode mode, set batch_size = beam_size # Reason: in decode mode, we decode one example at a time. # On each step, we have beam_size-many hypotheses in the beam, so we need to make a batch of these hypotheses. if FLAGS.mode == 'decode': FLAGS.batch_size = FLAGS.beam_size # If single_pass=True, check we're in decode mode if FLAGS.single_pass and FLAGS.mode != 'decode': raise Exception( "The single_pass flag should only be True in decode mode") # if FLAGS.prev_relation and not FLAGS.co_occurrence: # raise Exception("The co_occurrence flag should be True when the prev_relation flag is True") # Make a namedtuple hps, containing the values of the hyperparameters that the model needs hparam_list = [ 'top_ten_kept', 'decode_only', 'generation_only', 'copy_only', 'occurrence_window_size', 'max_title_len', 'title_engaged', 'title_guided', 'ref_dir', 'tagger_encoding', 'tagger_attention', 'source_siding_bridge', 'target_siding_bridge', 'language', 'dropout', 'optimizer', 'mode', 'lr', 'adagrad_init_acc', 'rand_unif_init_mag', 'trunc_norm_init_std', 'max_grad_norm', 'hidden_dim', 'emb_dim', 'batch_size', 'beam_depth', 'max_dec_steps', 'max_enc_steps', 'max_keyphrase_num', 'attention_weighted', 'coverage', 'coverage_weighted', 'coverage_weighted_expansion', 'co_occurrence', 'prev_relation', 'co_occurrence_h', 'co_occurrence_i', 'cov_loss_wt', 'pointer_gen', 'cell_type', 'markov_attention', 'markov_attention_contribution', 'markov_attention_contribution_used_x' ] hps_dict = {} for key, val in FLAGS.__flags.items(): # for each flag if key in hparam_list: # if it's in the list hps_dict[key] = val # add it to the dict hps = namedtuple("HParams", hps_dict.keys())(**hps_dict) # Create a batcher object that will create minibatches of data batcher = Batcher(FLAGS.data_path, vocab, hps, single_pass=FLAGS.single_pass, stop_words=stop_word_ids) tf.set_random_seed(111) # a seed value for randomness if hps.mode == 'train': print("creating model...") model = SummarizationModel(hps, vocab) setup_training(model, batcher) elif hps.mode == 'eval': model = SummarizationModel(hps, vocab) run_eval(model, batcher, vocab) elif hps.mode == 'decode': decode_model_hps = hps # This will be the hyperparameters for the decoder model decode_model_hps = hps._replace( max_dec_steps=1 ) # The model is configured with max_dec_steps=1 because we only ever run one step of the decoder at a time (to do beam search). Note that the batcher is initialized with max_dec_steps equal to e.g. 100 because the batches need to contain the full summaries model = SummarizationModel(decode_model_hps, vocab) decoder = BeamSearchDecoder(model, batcher, vocab) decoder.decode( ) # decode indefinitely (unless single_pass=True, in which case deocde the dataset exactly once) else: raise ValueError("The 'mode' flag must be one of train/eval/decode")
def main(self, unused_argv): if len(unused_argv) != 1: # prints a message if you've entered flags incorrectly raise Exception("Problem with flags: %s" % unused_argv) FLAGS.log_root = os.path.join(FLAGS.log_root, FLAGS.exp_name) tf.logging.set_verbosity(tf.logging.INFO) # choose what level of logging you want tf.logging.info('Starting seq2seq_attention in %s mode...', (FLAGS.mode)) # Change log_root to FLAGS.log_root/FLAGS.exp_name and create the dir if necessary flags = getattr(FLAGS,"__flags") if not os.path.exists(FLAGS.log_root): if FLAGS.mode=="train": os.makedirs(FLAGS.log_root) else: raise Exception("Logdir %s doesn't exist. Run in train mode to create it." % (FLAGS.log_root)) fw = open('{}/config.txt'.format(FLAGS.log_root), 'w') for k, v in flags.items(): fw.write('{}\t{}\n'.format(k, v)) fw.close() self.vocab = Vocab(FLAGS.vocab_path, FLAGS.vocab_size) # create a vocabulary # If in decode mode, set batch_size = beam_size # Reason: in decode mode, we decode one example at a time. # On each step, we have beam_size-many hypotheses in the beam, so we need to make a batch of these hypotheses. if FLAGS.mode == 'decode': FLAGS.batch_size = FLAGS.beam_size # If single_pass=True, check we're in decode mode if FLAGS.single_pass and FLAGS.mode!='decode': raise Exception("The single_pass flag should only be True in decode mode") # Make a namedtuple hps, containing the values of the hyperparameters that the model needs hparam_list = ['mode', 'lr', 'gpu_num', #'sampled_greedy_flag', 'gamma', 'eta', 'fixed_eta', 'reward_function', 'intradecoder', 'use_temporal_attention', 'ac_training','rl_training', 'matrix_attention', 'calculate_true_q', 'enc_hidden_dim', 'dec_hidden_dim', 'k', 'scheduled_sampling', 'sampling_probability','fixed_sampling_probability', 'alpha', 'hard_argmax', 'greedy_scheduled_sampling', 'adagrad_init_acc', 'rand_unif_init_mag', 'trunc_norm_init_std', 'max_grad_norm', 'emb_dim', 'batch_size', 'max_dec_steps', 'max_enc_steps', 'dqn_scheduled_sampling', 'dqn_sleep_time', 'E2EBackProp', 'coverage', 'cov_loss_wt', 'pointer_gen'] hps_dict = {} for key,val in flags.items(): # for each flag if key in hparam_list: # if it's in the list hps_dict[key] = val.value # add it to the dict if FLAGS.ac_training: hps_dict.update({'dqn_input_feature_len':(FLAGS.dec_hidden_dim)}) self.hps = namedtuple("HParams", hps_dict.keys())(**hps_dict) # creating all the required parameters for DDQN model. if FLAGS.ac_training: hparam_list = ['lr', 'dqn_gpu_num', 'dqn_layers', 'dqn_replay_buffer_size', 'dqn_batch_size', 'dqn_target_update', 'dueling_net', 'dqn_polyak_averaging', 'dqn_sleep_time', 'dqn_scheduled_sampling', 'max_grad_norm'] hps_dict = {} for key,val in flags.items(): # for each flag if key in hparam_list: # if it's in the list hps_dict[key] = val.value # add it to the dict hps_dict.update({'dqn_input_feature_len':(FLAGS.dec_hidden_dim)}) hps_dict.update({'vocab_size':self.vocab.size()}) self.dqn_hps = namedtuple("HParams", hps_dict.keys())(**hps_dict) # Create a batcher object that will create minibatches of data self.batcher = Batcher(FLAGS.data_path, self.vocab, self.hps, single_pass=FLAGS.single_pass, decode_after=FLAGS.decode_after) tf.set_random_seed(111) # a seed value for randomness if self.hps.mode == 'train': print("creating model...") self.model = SummarizationModel(self.hps, self.vocab) if FLAGS.ac_training: # current DQN with paramters \Psi self.dqn = DQN(self.dqn_hps,'current') # target DQN with paramters \Psi^{\prime} self.dqn_target = DQN(self.dqn_hps,'target') self.setup_training() elif self.hps.mode == 'eval': self.model = SummarizationModel(self.hps, self.vocab) if FLAGS.ac_training: self.dqn = DQN(self.dqn_hps,'current') self.dqn_target = DQN(self.dqn_hps,'target') self.run_eval() elif self.hps.mode == 'decode': decode_model_hps = self.hps # This will be the hyperparameters for the decoder model decode_model_hps = self.hps._replace(max_dec_steps=1) # The model is configured with max_dec_steps=1 because we only ever run one step of the decoder at a time (to do beam search). Note that the batcher is initialized with max_dec_steps equal to e.g. 100 because the batches need to contain the full summaries model = SummarizationModel(decode_model_hps, self.vocab) if FLAGS.ac_training: # We need our target DDQN network for collecting Q-estimation at each decoder step. dqn_target = DQN(self.dqn_hps,'target') else: dqn_target = None decoder = BeamSearchDecoder(model, self.batcher, self.vocab, dqn = dqn_target) decoder.decode() # decode indefinitely (unless single_pass=True, in which case deocde the dataset exactly once) else: raise ValueError("The 'mode' flag must be one of train/eval/decode")