def __init__(self, config): self.config = config self.cfg_solver = config['solver'] self.cfg_dataset = config['data'] self.cfg_model = config['model'] self.max_disp = self.cfg_model['max_disp'] self.model = get_model(self.config) self.test_loader = get_loader(self.config) self.imshow = config['imshow']
def main(): parser = argparse.ArgumentParser() parser.add_argument('-mode', default='train') parser.add_argument('-no_cuda', action='store_true') parser.add_argument('-SGDR', action='store_true') parser.add_argument('-epochs', type=int, default=2000) parser.add_argument('-d_model', type=int, default=500) parser.add_argument('-n_layers', type=int, default=6) parser.add_argument('-heads', type=int, default=10) parser.add_argument('-dropout', type=int, default=0.2) parser.add_argument('-printevery', type=int, default=10) parser.add_argument('-lr', type=int, default=0.0001) parser.add_argument('-load_weights') parser.add_argument('-create_valset', action='store_true') parser.add_argument('-max_strlen', type=int, default=80) parser.add_argument('-floyd', action='store_true') parser.add_argument('-checkpoint', type=int, default=0) parser.add_argument('-batch_size', type=int, default=32) parser.add_argument('-vid_feat_size', type=int, default=500) parser.add_argument('-save_freq', type=int, default=2) parser.add_argument('-model_save_dir', default='model') parser.add_argument('-log_frequency', default=20) # DataLoader parser.add_argument('-num_train_set', type=int, default=8000) parser.add_argument('-video_features_file', default='activitynet/anet_v1.3.c3d.hdf5') parser.add_argument('-video_descriptions_file', default='activitynet_descriptions.pkl') parser.add_argument('-vocab_file', default='activitynet_vocab.pkl') parser.add_argument('-video_descriptions_csv', default='data/video_description.csv') parser.add_argument('-target_feature_size', type=int, default=14238) opt = parser.parse_args() opt.device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu') model = get_model(opt, opt.vid_feat_size, opt.target_feature_size) model = nn.DataParallel(model) if opt.mode == 'train': print("Training model for num_epochs - {}, vocab_size - {}...".format(opt.epochs, opt.target_feature_size)) opt.optimizer = torch.optim.Adam(model.parameters(), lr=opt.lr, betas=(0.9, 0.98), eps=1e-9) if opt.SGDR == True: opt.sched = CosineWithRestarts(opt.optimizer, T_max = 10) model.train() trainloader = DataLoader(opt=opt, train=True) evalloader = DataLoader(opt=opt, train=False) train_model(model, trainloader, evalloader, opt) elif opt.mode == 'eval': print("Evaluating model...") model.load_state_dict(torch.load(opt.model_save_dir + '/model_595.pth')) model.eval() print("Transformer model loaded") evalloader = DataLoader(opt=opt, train=False) eval_model(model, evalloader, opt) else: print("Wrong option. Give either 'train' or 'eval' as input to -mode")
def main(): parser = argparse.ArgumentParser() parser.add_argument('-src_data', required=True) parser.add_argument('-trg_data', required=True) parser.add_argument('-src_lang', required=True) parser.add_argument('-trg_lang', required=True) parser.add_argument('-no_cuda', action='store_true') parser.add_argument('-SGDR', action='store_true') parser.add_argument('-epochs', type=int, default=2) parser.add_argument('-d_model', type=int, default=512) parser.add_argument('-n_layers', type=int, default=6) parser.add_argument('-heads', type=int, default=8) parser.add_argument('-dropout', type=int, default=0.1) parser.add_argument('-batchsize', type=int, default=12) parser.add_argument('-printevery', type=int, default=100) parser.add_argument('-lr', type=int, default=0.0001) parser.add_argument('-load_weights') parser.add_argument('-create_valset', action='store_true') parser.add_argument('-max_strlen', type=int, default=80) parser.add_argument('-floyd', action='store_true') parser.add_argument('-checkpoint', type=int, default=0) opt = parser.parse_args() opt.device = 0 if opt.no_cuda is False else -1 if opt.device == 0: assert torch.cuda.is_available() read_data(opt) SRC, TRG = create_fields(opt) opt.train = create_dataset(opt, SRC, TRG) model = get_model(opt, len(SRC.vocab), len(TRG.vocab)) opt.optimizer = torch.optim.Adam(model.parameters(), lr=opt.lr, betas=(0.9, 0.98), eps=1e-9) if opt.SGDR == True: opt.sched = CosineWithRestarts(opt.optimizer, T_max=opt.train_len) if opt.checkpoint > 0: print( "model weights will be saved every %d minutes and at end of epoch to directory weights/" % (opt.checkpoint)) if opt.load_weights is not None and opt.floyd is not None: os.mkdir('weights') pickle.dump(SRC, open('weights/SRC.pkl', 'wb')) pickle.dump(TRG, open('weights/TRG.pkl', 'wb')) train_model(model, opt) if opt.floyd is False: promptNextAction(model, opt, SRC, TRG)
def main(): parser = argparse.ArgumentParser() parser.add_argument('-load_weights') parser.add_argument('-k', type=int, default=3) parser.add_argument('-max_len', type=int, default=80) parser.add_argument('-d_model', type=int, default=512) parser.add_argument('-n_layers', type=int, default=6) parser.add_argument('-heads', type=int, default=8) parser.add_argument('-dropout', type=int, default=0.1) parser.add_argument('-no_cuda', action='store_true') opt = parser.parse_args() opt.device = 0 if opt.no_cuda is False else -1 assert opt.k > 0 assert opt.max_len > 10 opt.src_lang = "en_core_web_sm" opt.trg_lang = "en_core_web_sm" opt.load_weights = "weights" SRC, TRG = create_fields(opt) model = get_model(opt, len(SRC.vocab), len(TRG.vocab)) sentence = [] engine = pyttsx3.init() voices = engine.getProperty('voices') engine.setProperty('voice', voices[0].id) engine.setProperty('rate', 150) #main loop to talk to bot while True: userinput = input(">> ") userinput = userinput.strip() if userinput[-1].isalpha(): userinput += "." if len(sentence) >= 5: sentence.pop(0) sentence.append(userinput) opt.text = ' '.join(sentence) phrase = getSentence(opt, model, SRC, TRG) print('chatbot: ' + phrase) #makes chat bot speak out loud engine.say(phrase) engine.runAndWait()
def main(): parser = argparse.ArgumentParser() parser.add_argument('-load_weights', required=True) parser.add_argument('-k', type=int, default=3) parser.add_argument('-max_len', type=int, default=80) parser.add_argument('-d_model', type=int, default=512) parser.add_argument('-n_layers', type=int, default=6) parser.add_argument('-src_lang', required=True) parser.add_argument('-trg_lang', required=True) parser.add_argument('-heads', type=int, default=8) parser.add_argument('-dropout', type=int, default=0.1) parser.add_argument('-no_cuda', action='store_true') parser.add_argument('-floyd', action='store_true') opt = parser.parse_args() opt.device = 0 if opt.no_cuda is False else -1 assert opt.k > 0 assert opt.max_len > 10 SRC, TRG = create_fields(opt) model = get_model(opt, len(SRC.vocab), len(TRG.vocab)) while True: opt.text = input( "Enter a sentence to translate (type 'f' to load from file, or 'q' to quit):\n" ) if opt.text == "q": break if opt.text == 'f': fpath = input( "Enter a sentence to translate (type 'f' to load from file, or 'q' to quit):\n" ) try: import ipdb ipdb.set_trace() opt.text = ' '.join( open(opt.text, encoding='utf-8').read().split('\n')) except: print("error opening or reading text file") continue phrase = translate(opt, model, SRC, TRG) print('> ' + phrase + '\n')
def main(): parser = argparse.ArgumentParser() parser.add_argument('-src_data', required=True) parser.add_argument('-trg_data', required=True) parser.add_argument('-src_lang', required=True) parser.add_argument('-trg_lang', required=True) parser.add_argument('-no_cuda', action='store_true') parser.add_argument('-SGDR', action='store_true') parser.add_argument('-epochs', type=int, default=2) parser.add_argument('-d_model', type=int, default=512) parser.add_argument('-n_layers', type=int, default=6) parser.add_argument('-heads', type=int, default=8) parser.add_argument('-dropout', type=int, default=0.1) parser.add_argument('-batchsize', type=int, default=1500) parser.add_argument('-printevery', type=int, default=100) parser.add_argument('-lr', type=int, default=0.0001) parser.add_argument('-load_weights') parser.add_argument('-create_valset', action='store_true') parser.add_argument('-max_strlen', type=int, default=80) opt = parser.parse_args() opt.device = 0 if opt.no_cuda is False else -1 if opt.device == 0: assert torch.cuda.is_available() read_data(opt) SRC, TRG = create_fields(opt) opt.train = create_dataset(opt, SRC, TRG) model = get_model(opt, len(SRC.vocab), len(TRG.vocab)) opt.optimizer = torch.optim.Adam(model.parameters(), lr=opt.lr, betas=(0.9, 0.98), eps=1e-9) if opt.SGDR == True: opt.sched = CosineWithRestarts(opt.optimizer, T_max=opt.train_len) train_model(model, opt) promptNextAction(model, opt, SRC, TRG)
def __init__(self, config): self.config = config self.cfg_solver = config['solver'] self.cfg_dataset = config['data'] self.cfg_model = config['model'] self.reloaded = True if self.cfg_solver['resume_iter'] > 0 else False self.max_disp = self.cfg_model['max_disp'] self.loss_name = self.cfg_model['loss'] self.train_loader, self.val_loader = get_loader(self.config) self.model = get_model(self.config) self.crit = get_losses(self.loss_name, max_disp=self.max_disp) if self.cfg_solver['optimizer_type'].lower() == 'rmsprop': self.optimizer = optim.RMSprop(self.model.parameters(), lr=self.cfg_solver['lr_init']) elif self.cfg_solver['optimizer_type'].lower() == 'adam': self.optimizer = optim.Adam(self.model.parameters(), lr=self.cfg_solver['lr_init']) else: raise NotImplementedError('Optimizer type [{:s}] is not supported'.format(self.cfg_solver['optimizer_type'])) self.scheduler = optim.lr_scheduler.MultiStepLR(self.optimizer, milestones=self.cfg_solver['milestones'], gamma=self.cfg_solver['gamma']) self.global_step = 1
def main(): # Add parser to parse in the arguments parser = argparse.ArgumentParser() parser.add_argument('-src_data', required=True) parser.add_argument('-load_weights', required=False) parser.add_argument('-output_name', type=str, required=True) parser.add_argument('-device', type=str, default="cuda:1" if torch.cuda.is_available() else "cpu") parser.add_argument('-k', type=int, default=3) parser.add_argument('-d_model', type=int, default=256) parser.add_argument('-d_ff', type=int, default=1024) parser.add_argument('-n_layers', type=int, default=5) parser.add_argument('-heads', type=int, default=8) parser.add_argument('-dropout', type=float, default=0.1) parser.add_argument('-batchsize', type=int, default=1) parser.add_argument('-max_seq_len', type=int, default=1024) parser.add_argument('-attention_type', type = str, default = 'Baseline') parser.add_argument('-weights_name', type = str, default = 'model_weights') parser.add_argument("-concat_pos_sinusoid", type=str2bool, default=False) parser.add_argument("-relative_time_pitch", type=str2bool, default=False) parser.add_argument("-max_relative_position", type=int, default=512) opt = parser.parse_args() # Generate the vocabulary from the data opt.vocab = GenerateVocab(opt.src_data) opt.pad_token = 1 # Create the model using the arguments and the vocab size model = get_model(opt, len(opt.vocab)) # counter to keep track of how many outputs have been saved opt.save_counter = 0 # Now lets generate some music generated_music = generate(model,opt) # Ask for next action promptNextAction(model, opt, generated_music)
def main(): parser = argparse.ArgumentParser() parser.add_argument('-load_weights', required=True) parser.add_argument('-k', type=int, default=3) parser.add_argument('-max_len', type=int, default=80) parser.add_argument('-d_model', type=int, default=512) parser.add_argument('-n_layers', type=int, default=6) parser.add_argument('-src_lang', required=True) parser.add_argument('-trg_lang', required=True) parser.add_argument('-heads', type=int, default=8) parser.add_argument('-dropout', type=int, default=0.1) parser.add_argument('-no_cuda', action='store_true') parser.add_argument('-floyd', action='store_true') opt = parser.parse_args() opt.device = 0 if opt.no_cuda is False else -1 assert opt.k > 0 assert opt.max_len > 10 SRC, TRG = create_fields(opt) model = get_model(opt, len(SRC.vocab), len(TRG.vocab)) origin = open("data/test_s.txt", encoding='utf-8').read().split('\n') truth = open("data/test_t.txt", encoding='utf-8').read().split('\n') results = open("results/res_15.txt", "w") for i in range(len(origin)): try: o = origin[i] t = truth[i] opt.text = o r = translate(opt, model, SRC, TRG) results.write(o.lower() + "\n" + r + "\n" + t + "\n\n") except: print("error opening or reading text file")
def main(): parser = argparse.ArgumentParser() parser.add_argument('-load_weights', required=True) parser.add_argument('-k', type=int, default=3) parser.add_argument('-max_len', type=int, default=80) parser.add_argument('-d_model', type=int, default=512) parser.add_argument('-n_layers', type=int, default=6) parser.add_argument('-src_lang', required=True) parser.add_argument('-trg_lang', required=True) parser.add_argument('-heads', type=int, default=8) parser.add_argument('-dropout', type=int, default=0.1) parser.add_argument('-no_cuda', action='store_true') parser.add_argument('-floyd', action='store_true') parser.add_argument('-qdir', required=True) parser.add_argument('-qtitle', required=True) parser.add_argument('-qdesc', required=True) parser.add_argument('-approach', type=str, default="baseline") opt = parser.parse_args() opt.device = 0 if opt.no_cuda is False else -1 assert opt.k > 0 assert opt.max_len > 10 #Creating query_dict where title and query against a query id would be available query_file_title = open(os.path.join(opt.qdir, opt.qtitle)) query_dict = {} query_title_len_dict = {} for line in query_file_title: line_splitted = line.split("\t") query_id = line_splitted[0].strip() query_title = line_splitted[1].strip() query_dict.setdefault(query_id, []) query_dict[query_id].append(query_title) query_title_len_dict[query_id] = len(query_title.split()) #print(line) query_file_desc = open(os.path.join(opt.qdir, opt.qdesc)) for line in query_file_desc: line_splitted = line.split("\t") query_id = line_splitted[0].strip() query_title_desc = line_splitted[1].strip() query_dict[query_id].append(query_title_desc) title_len = query_title_len_dict[query_id] query_desc = ' '.join(query_title_desc.split()[title_len: ]) query_dict[query_id].append(query_desc) #Query dict created #Order in which queries are put: title, title_description, description for line in query_file_desc: print(line) print(query_file_desc) translation_file = open(os.path.join(opt.qdir, "nqt", "translation_baseline_epoch5.txt"), "w") SRC, TRG = create_fields(opt) model = get_model(opt, len(SRC.vocab), len(TRG.vocab)) phrase = "query" for query_id in query_dict.keys(): #translate the title first opt.text = query_dict[query_id][0] print("1---------------------------------------------------") print(opt.text) phrase = translate(opt, model, SRC, TRG) query_dict[query_id].append(phrase) print(phrase) print("***************************************************") # now translate the title_description opt.text = query_dict[query_id][1] print("2---------------------------------------------------") print(opt.text) phrase = translate(opt, model, SRC, TRG) query_dict[query_id].append(phrase) # now translate the description only print(phrase) print("***************************************************") opt.text = query_dict[query_id][2] print("3---------------------------------------------------") print(opt.text) phrase = translate(opt, model, SRC, TRG) query_dict[query_id].append(phrase) print(phrase) print("***************************************************") json.dump(query_dict, translation_file)
def main(): parser = argparse.ArgumentParser() parser.add_argument('-translate_file', required=True) parser.add_argument('-output', required=True) parser.add_argument('-load_weights', required=True) parser.add_argument('-k', type=int, default=3) parser.add_argument('-max_len', type=int, default=80) parser.add_argument('-d_model', type=int, default=512) parser.add_argument('-n_layers', type=int, default=6) parser.add_argument('-src_lang', required=True) parser.add_argument('-trg_lang', required=True) parser.add_argument('-heads', type=int, default=8) parser.add_argument('-dropout', type=int, default=0.1) parser.add_argument('-no_cuda', action='store_true') parser.add_argument('-floyd', action='store_true') parser.add_argument('-nmt_model_type', type=str, default='transformer') parser.add_argument('-decoder_extra_layers', type=int, default=0) parser.add_argument('-word_embedding_type', type=str, default=None) opt = parser.parse_args() print(opt) # class InputArgs(): # def __init__(self): # self.translate_file = 'data/port_test.txt' # self.output = 'test_translations.txt' # 'rnn_naive_model_translations.txt' # 'vanilla_transformer.txt' # self.load_weights = 'naive_dmodel512' # 'weights_test' # 'rnn_naive_model' # 'transformer_test' # self.src_lang = 'pt' # self.trg_lang = 'en' # self.no_cuda = True # self.d_model = 512 # 300 # self.heads = 8 # 6 # self.nmt_model_type = 'rnn_naive_model' # 'transformer', 'rnn_naive_model', 'align_and_translate' ... # self.word_embedding_type = None # None, 'glove' or 'fast_text' # self.k = 3 # self.max_len = 100 # self.dropout = 0.1 # self.n_layers = 6 # self.decoder_extra_layers = 0 # self.floyd = False # # self.use_dynamic_batch = None # opt = InputArgs() # print(opt.__dict__) if opt.no_cuda is False: assert torch.cuda.is_available() opt.device = torch.device("cuda") else: opt.device = torch.device("cpu") assert opt.k > 0 assert opt.max_len > 10 i_t = time.time() if opt.word_embedding_type in ['glove', 'fast_text']: if opt.word_embedding_type == 'glove': word_emb = KeyedVectors.load_word2vec_format('word_embeddings/glove_s300.txt') elif opt.word_embedding_type == 'fast_text': word_emb = KeyedVectors.load_word2vec_format('word_embeddings/ftext_skip_s300.txt') now = time.time() minutes = math.floor((now - i_t)/60) print(f'\nWord embeddding of type {str(opt.word_embedding_type)} took {minutes} minutes \ and {now - i_t - minutes*60:.2f} seconds to load.\n') elif opt.word_embedding_type is None: word_emb = opt.word_embedding_type SRC, TRG = create_fields(opt) opt.SRC = SRC; opt.TRG = TRG # important, these are used to input embeddings opt.word_emb = word_emb # just for querying vocabulary model = get_model(opt, len(SRC.vocab), len(TRG.vocab), word_emb) try: opt.text = open(opt.translate_file, encoding='utf-8').read().split('\n') except: print("error opening or reading text file") phrase = translate(opt, model, SRC, TRG) f = open(opt.output, "w+") f.write(phrase) f.close() print('Sample >'+ phrase[:300] + '\n')
def main(): parser = argparse.ArgumentParser() parser.add_argument('-load_weights', required=True) parser.add_argument('-k', type=int, default=3) parser.add_argument('-max_len', type=int, default=80) parser.add_argument('-d_model', type=int, default=512) parser.add_argument('-n_layers', type=int, default=6) parser.add_argument('-heads', type=int, default=8) parser.add_argument('-dropout', type=int, default=0.1) parser.add_argument('-bleu', type=bool, default=False) opt = parser.parse_args() opt.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') print(f'Load Tokenizer and Vocab...') en_sp_tokenizer = Tokenizer(is_train=False, model_prefix='spm_en') ko_sp_tokenizer = Tokenizer(is_train=False, model_prefix='spm_ko') en_sp_vocab = en_sp_tokenizer.vocab ko_sp_vocab = ko_sp_tokenizer.vocab print(f'Load the extended vocab...') en_vocab = Vocabulary.load_vocab('./ko_data/en_vocab') ko_vocab = Vocabulary.load_vocab('./ko_data/ko_vocab') ######################TEST DATA###################### # fitting the test dataset dir test_data_dir = [ './ko_data/test/test_ko_en.en', './ko_data/test/test_ko_en.ko' ] with open(test_data_dir[0], encoding='utf-8') as f: src_corpus = [line.strip().split('\n') for line in f.readlines()] with open(test_data_dir[1], encoding='utf-8') as f: tgt_corpus = [line.strip().split('\n') for line in f.readlines()] #################################################### model = get_model(opt, len(en_vocab), len(ko_vocab)) #opt.text = 'How are you?' if opt.bleu == False: pred = [] refer = [] for batch_idx, (text, tgt) in enumerate(zip(src_corpus, tgt_corpus)): opt.text = text[0] #print(f'length: {len(opt.text)}') phrase = translate(opt, model, en_vocab, ko_vocab, en_sp_tokenizer, ko_sp_tokenizer) pred.append(phrase) refer.append(tgt) #phrase = translate(opt, model, vocab, sp_tokenizer) with open('translation_result1', 'wb') as f: pc.dump(pred, f) with open('reference_result1', 'wb') as f: pc.dump(refer, f) else: with open('translation_result1', 'rb') as f: translation = pc.load(f) with open('reference_result1', 'rb') as f: reference = pc.load(f) compute_metrics(reference, translation)
def main(): parser = argparse.ArgumentParser() parser.add_argument('-load_weights', required=True) parser.add_argument('-k', type=int, default=3) parser.add_argument('-max_len', type=int, default=80) parser.add_argument('-d_model', type=int, default=512) parser.add_argument('-n_layers', type=int, default=6) parser.add_argument('-heads', type=int, default=8) parser.add_argument('-dropout', type=int, default=0.1) opt = parser.parse_args() opt.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') print(f'Load Tokenizer and Vocab...') sp_tokenizer = Tokenizer(is_train=False, model_prefix='spm') sp_vocab = sp_tokenizer.vocab print(f'Load the extended vocab...') vocab = Vocabulary.load_vocab('./data/vocab') ######################TEST DATA###################### # fitting the test dataset dir test_data_dir = [ './data/test/newstest2014_en', './data/test/newstest2014_de' ] test_dataset = Our_Handler(src_path=test_data_dir[0], tgt_path=test_data_dir[1], vocab=vocab, tokenizer=sp_tokenizer, max_len=256, is_test=True) test_dataloader = DataLoader(test_dataset, batch_size=8, shuffle=False, drop_last=True) opt.test = test_dataloader opt.test_len = len(test_dataloader) #################################################### model = get_model(opt, len(vocab), len(vocab)) while True: opt.text = input( "Enter a sentence to translate (type 'f' to load from file, or 'q' to quit):\n" ) if opt.text == "q": break if opt.text == 'f': fpath = input( "Enter a sentence to translate (type 'f' to load from file, or 'q' to quit):\n" ) try: opt.text = ' '.join( open(opt.text, encoding='utf-8').read().split('\n')) except: print("error opening or reading text file") continue phrase = translate(opt, model, SRC, TRG) print('> ' + phrase + '\n')
def main(): parser = argparse.ArgumentParser() parser.add_argument('-no_cuda', action='store_true') parser.add_argument('-SGDR', action='store_true') parser.add_argument('-epochs', type=int, default=50) parser.add_argument('-d_model', type=int, default=512) parser.add_argument('-n_layers', type=int, default=6) parser.add_argument('-heads', type=int, default=8) parser.add_argument('-dropout', type=int, default=0.1) parser.add_argument('-batchsize', type=int, default=1500) parser.add_argument('-printevery', type=int, default=500) parser.add_argument('-lr', type=int, default=0.0001) parser.add_argument('-load_weights') parser.add_argument('-create_valset', action='store_true') parser.add_argument('-max_strlen', type=int, default=80) parser.add_argument('-floyd', action='store_true') parser.add_argument('-checkpoint', type=int, default=0) parser.add_argument('--is_train', type=bool, default=False) parser.add_argument('--is_test', type=bool, default=False) opt = parser.parse_args() opt.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') # baseline code #read_data(opt) #SRC, TRG = create_fields(opt) #opt.train = create_dataset(opt, SRC, TRG) if not os.path.exists('./data'): os.makedirs('./data') # modified version for tokenize, vocab, dataset if opt.is_train: filenames = ['data/europarl-v7.de-en.en', 'data/europarl-v7.de-en.de'] print(f'Build Tokenizer and Vocab...') sp_tokenizer = Tokenizer(is_train=True, filenames=filenames, tokenizer_type='spm', input_file='./data/concat_data.txt', model_prefix='spm', vocab_size=32000, model_type='bpe') sp_vocab = sp_tokenizer.vocab else: print(f'Load Tokenizer and Vocab...') sp_tokenizer = Tokenizer(is_train=False, model_prefix='spm') sp_vocab = sp_tokenizer.vocab if opt.is_train: print(f'Extend Vocab...') vocab = Vocabulary(sp_vocab) vocab.save_vocab('./data/vocab') else: print(f'Load the extended vocab...') vocab = Vocabulary.load_vocab('./data/vocab') train_dataset = Our_Handler(src_path='./data/europarl-v7.de-en.en', tgt_path='./data/europarl-v7.de-en.de', vocab=vocab, tokenizer=sp_tokenizer, max_len=32) # print(train_dataset[0]) # print(train_dataset[0][0].shape, train_dataset[0][1].shape, train_dataset[0][2].shape) train_dataloader = DataLoader(train_dataset, batch_size=128, shuffle=True, pin_memory=True, drop_last=True) opt.train = train_dataloader opt.src_pad = opt.trg_pad = vocab.pad_index opt.train_len = len(train_dataloader) ######################DEV DATA###################### # fitting the dev dataset dir dev_data_dir = ['./data/dev/newstest2013.en', './data/dev/newstest2013.de'] dev_dataset = Our_Handler(src_path=dev_data_dir[0], tgt_path=dev_data_dir[1], vocab=vocab, tokenizer=sp_tokenizer, max_len=32) dev_dataloader = DataLoader(dev_dataset, batch_size=128, shuffle=False, drop_last=True) opt.validation = dev_dataloader opt.val_len = len(dev_dataloader) #################################################### ######################TEST DATA###################### # fitting the test dataset dir test_data_dir = [ './data/test/newstest2014_en', './data/test/newstest2014_de' ] test_dataset = Our_Handler(src_path=test_data_dir[0], tgt_path=test_data_dir[1], vocab=vocab, tokenizer=sp_tokenizer, max_len=32, is_test=True) test_dataloader = DataLoader(test_dataset, batch_size=128, shuffle=False, drop_last=True) opt.test = test_dataloader opt.test_len = len(test_dataloader) #################################################### #model = get_model(opt, len(SRC.vocab), len(TRG.vocab)) model = get_model(opt, len(vocab), len(vocab)) if torch.cuda.device_count() > 1: model = nn.DataParallel(model) print(f'Use {torch.cuda.device_count()} GPUs') model = model.to(opt.device) opt.optimizer = torch.optim.Adam(model.parameters(), lr=opt.lr, betas=(0.9, 0.98), eps=1e-9) if opt.SGDR == True: # opt.sched = CosineWithRestarts(opt.optimizer, T_max=opt.train_len) opt.sched = Triangular(opt.optimizer, num_epochs=opt.epochs, warm_up=opt.epochs // 4, cool_down=opt.epochs // 4) if opt.checkpoint > 0: print( "model weights will be saved every %d minutes and at end of epoch to directory weights/" % (opt.checkpoint)) if opt.load_weights is not None and opt.floyd is not None: os.mkdir('weights') pickle.dump(SRC, open('weights/SRC.pkl', 'wb')) pickle.dump(TRG, open('weights/TRG.pkl', 'wb')) if opt.is_test: test_model(model, opt) else: train_model(model, opt) if opt.floyd is False: promptNextAction(model, opt)
def main(): parser = argparse.ArgumentParser() parser.add_argument('-no_cuda', action='store_true') parser.add_argument('-SGDR', action='store_true') parser.add_argument('-epochs', type=int, default=50) parser.add_argument('-d_model', type=int, default=512) parser.add_argument('-n_layers', type=int, default=6) parser.add_argument('-heads', type=int, default=8) parser.add_argument('-dropout', type=int, default=0.1) parser.add_argument('-batchsize', type=int, default=1500) parser.add_argument('-printevery', type=int, default=500) parser.add_argument('-lr', type=int, default=0.0001) parser.add_argument('-load_weights') parser.add_argument('-create_valset', action='store_true') parser.add_argument('-max_strlen', type=int, default=80) parser.add_argument('-floyd', action='store_true') parser.add_argument('-checkpoint', type=int, default=0) parser.add_argument('--is_train', type=bool, default=False) parser.add_argument('--is_test', type=bool, default=False) opt = parser.parse_args() opt.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') # baseline code #read_data(opt) #SRC, TRG = create_fields(opt) #opt.train = create_dataset(opt, SRC, TRG) if not os.path.exists('./ko_data'): os.makedirs('./ko_data') # modified version for tokenize, vocab, dataset if opt.is_train: source_file_name = 'ko_data/train_ko_en.en' target_file_name = 'ko_data/train_ko_en.ko' print(f'Build Tokenizer and Vocab...') en_sp_tokenizer = Tokenizer(is_train=True, filename=source_file_name, tokenizer_type='spm', model_prefix='spm_en', vocab_size=32000, model_type='bpe') ko_sp_tokenizer = Tokenizer(is_train=True, filename=target_file_name, tokenizer_type='spm', model_prefix='spm_ko', vocab_size=32000, model_type='bpe') en_sp_vocab = en_sp_tokenizer.vocab ko_sp_vocab = ko_sp_tokenizer.vocab else: print(f'Load Tokenizer and Vocab...') en_sp_tokenizer = Tokenizer(is_train=False, model_prefix='spm_en') ko_sp_tokenizer = Tokenizer(is_train=False, model_prefix='spm_ko') en_sp_vocab = en_sp_tokenizer.vocab ko_sp_vocab = ko_sp_tokenizer.vocab if opt.is_train: print(f'Extend Vocab...') en_vocab = Vocabulary(en_sp_vocab) ko_vocab = Vocabulary(ko_sp_vocab) en_vocab.save_vocab('./ko_data/en_vocab') ko_vocab.save_vocab('./ko_data/ko_vocab') else: print(f'Load the extended vocab...') en_vocab = Vocabulary.load_vocab('./ko_data/en_vocab') ko_vocab = Vocabulary.load_vocab('./ko_data/ko_vocab') #En-Ko # train_dataset = Our_Handler(src_path='./ko_data/train_ko_en.en', tgt_path='./ko_data/train_ko_en.ko', # en_vocab=en_vocab, ko_vocab=ko_vocab, en_tokenizer=en_sp_tokenizer, ko_tokenizer=ko_sp_tokenizer, max_len=100) #Ko-En train_dataset = Our_Handler(src_path='./ko_data/train_ko_en.ko', tgt_path='./ko_data/train_ko_en.en', en_vocab=en_vocab, ko_vocab=ko_vocab, en_tokenizer=en_sp_tokenizer, ko_tokenizer=ko_sp_tokenizer, max_len=90) train_dataloader = DataLoader(train_dataset, batch_size=32, shuffle=True, pin_memory=True, drop_last=True) opt.train = train_dataloader #En-Ko opt.src_pad = en_vocab.pad_index opt.trg_pad = ko_vocab.pad_index #Ko-En opt.src_pad = en_vocab.pad_index opt.trg_pad = ko_vocab.pad_index opt.train_len = len(train_dataloader) ######################DEV DATA###################### # fitting the dev dataset dir dev_data_dir = ['./ko_data/dev/dev_ko_en.en', './ko_data/dev/dev_ko_en.ko'] #En-Ko # dev_dataset = Our_Handler(src_path=dev_data_dir[0], # tgt_path=dev_data_dir[1], # en_vocab=en_vocab,ko_vocab=ko_vocab, # en_tokenizer=en_sp_tokenizer, ko_tokenizer=ko_sp_tokenizer, # max_len=100) #Ko-En dev_dataset = Our_Handler(src_path=dev_data_dir[1], tgt_path=dev_data_dir[0], en_vocab=en_vocab, ko_vocab=ko_vocab, en_tokenizer=en_sp_tokenizer, ko_tokenizer=ko_sp_tokenizer, max_len=90) dev_dataloader = DataLoader(dev_dataset, batch_size=32, shuffle=False, drop_last=True) opt.validation = dev_dataloader opt.val_len = len(dev_dataloader) #################################################### ######################TEST DATA###################### # fitting the test dataset dir test_data_dir = [ './ko_data/test/test_ko_en.en', './ko_data/test/test_ko_en.ko' ] #En-Ko # test_dataset = Our_Handler(src_path=test_data_dir[0], # tgt_path=test_data_dir[1], # en_vocab=en_vocab,ko_vocab=ko_vocab, # en_tokenizer=en_sp_tokenizer, ko_tokenizer=ko_sp_tokenizer, # max_len=100, # # is_test=True # is_test=False) #Ko-En test_dataset = Our_Handler( src_path=test_data_dir[1], tgt_path=test_data_dir[0], en_vocab=en_vocab, ko_vocab=ko_vocab, en_tokenizer=en_sp_tokenizer, ko_tokenizer=ko_sp_tokenizer, max_len=90, # is_test=True is_test=False) test_dataloader = DataLoader(test_dataset, batch_size=32, shuffle=False, drop_last=True) opt.test = test_dataloader opt.test_len = len(test_dataloader) #################################################### #En-Ko # model = get_model(opt, len(en_vocab), len(ko_vocab)) #Ko-En model = get_model(opt, len(ko_vocab), len(en_vocab)) if torch.cuda.device_count() > 1: model = nn.DataParallel(model) print(f'Use {torch.cuda.device_count()} GPUs') model = model.to(opt.device) opt.optimizer = torch.optim.Adam(model.parameters(), lr=opt.lr, betas=(0.9, 0.98), eps=1e-9) if opt.SGDR == True: # opt.sched = CosineWithRestarts(opt.optimizer, T_max=opt.train_len) opt.sched = Triangular(opt.optimizer, num_epochs=opt.epochs, warm_up=opt.epochs // 4, cool_down=opt.epochs // 4) if opt.checkpoint > 0: print( "model weights will be saved every %d minutes and at end of epoch to directory weights/" % (opt.checkpoint)) if opt.load_weights is not None and opt.floyd is not None: os.mkdir('weights') pickle.dump(SRC, open('weights/SRC.pkl', 'wb')) pickle.dump(TRG, open('weights/TRG.pkl', 'wb')) if opt.is_test: test_model(model, opt) else: train_model(model, opt)
def main(): parser = argparse.ArgumentParser() parser.add_argument('-src_data', default='data/english.txt') parser.add_argument('-trg_data', default='data/french.txt') parser.add_argument('-src_lang', default='en_core_web_sm') parser.add_argument('-trg_lang', default='fr_core_news_sm') parser.add_argument('-no_cuda', action='store_true') parser.add_argument('-SGDR', action='store_true') parser.add_argument('-epochs', type=int, default=2) parser.add_argument('-d_model', type=int, default=512) parser.add_argument('-n_layers', type=int, default=6) parser.add_argument('-heads', type=int, default=8) parser.add_argument('-dropout', type=int, default=0.1) parser.add_argument('-batchsize', type=int, default=1500) parser.add_argument('-printevery', type=int, default=10) parser.add_argument('-lr', type=int, default=0.0001) parser.add_argument('-load_weights') parser.add_argument('-create_valset', action='store_true') parser.add_argument('-max_strlen', type=int, default=80) parser.add_argument('-floyd', action='store_true') parser.add_argument('-checkpoint', type=int, default=0) parser.add_argument('-output_dir', default='output') opt = parser.parse_args() print(opt) opt.device = "cpu" if opt.no_cuda else "cuda" if opt.device == "cuda": assert torch.cuda.is_available() read_data(opt) SRC, TRG = create_fields(opt) if not os.path.isdir(opt.output_dir): os.makedirs(opt.output_dir) opt.train = create_dataset(opt, SRC, TRG) model = get_model(opt, len(SRC.vocab), len(TRG.vocab)) if opt.device == "cuda": model.cuda() opt.optimizer = torch.optim.Adam(model.parameters(), lr=opt.lr, betas=(0.9, 0.98), eps=1e-9) if opt.SGDR == True: opt.sched = CosineWithRestarts(opt.optimizer, T_max=opt.train_len) if opt.checkpoint > 0: print( "model weights will be saved every %d minutes and at end of epoch to directory weights/" % (opt.checkpoint)) if opt.load_weights is not None and opt.floyd is not None: os.mkdir('weights') pickle.dump(SRC, open('weights/SRC.pkl', 'wb')) pickle.dump(TRG, open('weights/TRG.pkl', 'wb')) print("saving field pickles to " + opt.output_dir + "/...") pickle.dump(SRC, open(f'{opt.output_dir}/SRC.pkl', 'wb')) pickle.dump(TRG, open(f'{opt.output_dir}/TRG.pkl', 'wb')) print("field pickles saved ! ") train_model(model, opt)
def main(): ############################ ### OPTIONAL 4 THe FUTURE ## # DO WEIGHT DECAY BASED ON # # ATTENTION PAPER !!!!! #### ############################ # step_list = [i*500 for i in range(2000)] # for step in step_list: # lrate = (1/np.sqrt(512)) * min(1/np.sqrt(step), step*4000**-1.5 ) # print(f'{step}: lrate {lrate}') parser = argparse.ArgumentParser() parser.add_argument('-src_data', required=True) parser.add_argument('-src_val_data', required=False, default='data/port_dev.txt') parser.add_argument('-trg_data', required=True) parser.add_argument('-trg_val_data', required=False, default='data/eng_dev.txt') parser.add_argument('-src_lang', required=True) parser.add_argument('-trg_lang', required=True) parser.add_argument('-no_cuda', action='store_true') parser.add_argument('-SGDR', action='store_true') parser.add_argument('-epochs', type=int, default=2) parser.add_argument('-d_model', type=int, default=512) # hidden size for models using RNN parser.add_argument('-n_layers', type=int, default=6) parser.add_argument('-heads', type=int, default=8) parser.add_argument('-dropout', type=float, default=0.1) parser.add_argument('-batchsize', type=int, default=1500) parser.add_argument('-printevery', type=int, default=100) parser.add_argument('-lr', type=float, default=0.00015) parser.add_argument('-load_weights') parser.add_argument('-create_valset', action='store_true') parser.add_argument('-max_strlen', type=int, default=100) # max number of spaces per sentence parser.add_argument('-checkpoint', type=int, default=0) parser.add_argument('-decoder_extra_layers', type=int, default=0) parser.add_argument('-nmt_model_type', type=str, default='transformer') parser.add_argument('-word_embedding_type', type=str, default=None) parser.add_argument('-use_dynamic_batch', action='store_true') opt = parser.parse_args() print(opt) # class InputArgs(): # def __init__(self): # self.src_data = 'data/port_train.txt' # self.src_val_data = 'data/port_dev.txt' # self.trg_data = 'data/eng_train.txt' # self.trg_val_data = 'data/eng_dev.txt' # self.src_lang = 'pt' # self.trg_lang = 'en' # self.no_cuda = True # self.SGDR = False # self.epochs = 5 # self.d_model = 300 # self.n_layers = 6 # self.heads = 6 # self.dropout = 0.1 # self.batchsize = 1024 # self.printevery = 100 # self.lr = 0.00015 # self.load_weights = None # self.create_valset = False # self.max_strlen = 100 # self.checkpoint = 1 # self.decoder_extra_layers = 0 # self.nmt_model_type = 'rnn_naive_model' # 'transformer', 'rnn_naive_model', 'align_and_translate' ... # self.word_embedding_type = None # None, 'glove' or 'fast_text' # self.use_dynamic_batch = None # opt = InputArgs() # print(opt.__dict__) # opt.device = 0 if opt.no_cuda is False else torch.device("cpu") if opt.no_cuda is False: assert torch.cuda.is_available() opt.device = torch.device("cuda") else: opt.device = torch.device("cpu") i_t = time.time() if opt.word_embedding_type in ['glove', 'fast_text']: if opt.word_embedding_type == 'glove': word_emb = KeyedVectors.load_word2vec_format( 'word_embeddings/glove_s300.txt') elif opt.word_embedding_type == 'fast_text': word_emb = KeyedVectors.load_word2vec_format( 'word_embeddings/ftext_skip_s300.txt') now = time.time() minutes = math.floor((now - i_t) / 60) print( f'\nWord embeddding of type {str(opt.word_embedding_type)} took {minutes} minutes \ and {now - i_t - minutes*60:.2f} seconds to load.\n') elif opt.word_embedding_type is None: word_emb = opt.word_embedding_type read_data(opt) SRC, TRG = create_fields(opt) opt.SRC = SRC opt.TRG = TRG # important, these are used to input embeddings opt.train, opt.valid, SRC, TRG = create_dataset(opt, SRC, TRG, word_emb) opt.word_emb = word_emb # just for querying vocabulary model = get_model(opt, len(SRC.vocab), len(TRG.vocab), word_emb) opt.optimizer = torch.optim.Adam(model.parameters(), lr=opt.lr, betas=(0.9, 0.98), eps=1e-9) if opt.SGDR == True: opt.sched = CosineWithRestarts(opt.optimizer, T_max=opt.train_len) if opt.checkpoint > 0: print( "model weights will be saved every %d minutes and at end of epoch to directory weights/" % (opt.checkpoint)) if opt.load_weights is not None: os.mkdir('weights') pickle.dump(SRC, open('weights/SRC.pkl', 'wb')) pickle.dump(TRG, open('weights/TRG.pkl', 'wb')) train_model(model, opt) promptNextAction(model, opt, SRC, TRG)
def main(): parser = argparse.ArgumentParser() parser.add_argument('-load_weights', required=True) parser.add_argument('-k', type=int, default=3) parser.add_argument('-max_len', type=int, default=32) parser.add_argument('-d_model', type=int, default=512) parser.add_argument('-n_layers', type=int, default=6) parser.add_argument('-heads', type=int, default=8) parser.add_argument('-dropout', type=int, default=0.1) opt = parser.parse_args() opt.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') print(f'Load Tokenizer and Vocab...') sp_tokenizer = Tokenizer(is_train=False, model_prefix='spm') sp_vocab = sp_tokenizer.vocab print(f'Load the extended vocab...') vocab = Vocabulary.load_vocab('./data/vocab') ######################TEST DATA###################### # fitting the test dataset dir test_data_dir = [ './data/test/newstest2014_en', './data/test/newstest2014_de' ] test_dataset = Our_Handler(src_path=test_data_dir[0], tgt_path=test_data_dir[1], vocab=vocab, tokenizer=sp_tokenizer, max_len=32, is_test=True) test_dataloader = DataLoader(test_dataset, batch_size=64, shuffle=False, drop_last=True) opt.test = test_dataloader opt.test_len = len(test_dataloader) #################################################### model = get_model(opt, len(vocab), len(vocab)) model.eval() opt.src_pad = opt.trg_pad = vocab.pad_index test_loss = 0. test_ppl = 0. for batch_idx, (enc_input, dec_input, dec_output) in enumerate(opt.test): if batch_idx == 1: break enc_input = enc_input.to(opt.device) dec_input = dec_input.to(opt.device) dec_output = dec_output.to(opt.device) src_mask, trg_mask = create_masks(enc_input, dec_input, opt) with torch.no_grad(): preds = model(enc_input, dec_input, src_mask, trg_mask) ys = dec_output.contiguous().view(-1) loss = F.cross_entropy(preds.view(-1, preds.size(-1)), ys, ignore_index=opt.trg_pad) test_loss += loss.item() test_ppl += np.exp(loss.item()) avg_test_loss = test_loss / len(opt.test) avg_ppl = test_ppl / len(opt.test) print(f'Test loss: {avg_test_loss:.3f}, Test perpelxity: {avg_ppl:.3f}')
def main_total(model_Key): history_sum = {} # res_pre={} for key in model_Key.keys(): for model_path in model_Key[key]: parser = argparse.ArgumentParser() parser.add_argument('-premodels', default=True) # 是否加载原来的权重 和 vecab parser.add_argument('-load_weights', default="weights_" + key) # 如果加载预训练的权重,把路径到文件夹,以前的权重和泡菜保存 parser.add_argument('-premodels_path', default="model_weights_" + model_path) # 预训练的模型文件名 parser.add_argument('-k', type=int, default=1) # topK 感觉不需要,设置为1 就OK 或者将其删除 parser.add_argument('-max_len', type=int, default=32) # 最长长度 需加上起始位置 parser.add_argument('-d_model', type=int, default=512) # 嵌入向量和层的维数(默认为512) parser.add_argument('-n_layers', type=int, default=6) # 在Transformer模型中有多少层(默认=6) parser.add_argument('-heads', type=int, default=8) # 需要分割多少个头部以获得多个头部的注意(默认值为8) parser.add_argument('-dropout', type=int, default=0.1) # 决定多大的dropout将(默认=0.1) parser.add_argument('-cuda', default=True, action='store_true') parser.add_argument('-floyd', action='store_true') opt = parser.parse_args() opt.device = 0 if opt.cuda is True else -1 if opt.device == 0: assert torch.cuda.is_available() # assert opt.k > 0 # assert opt.max_len > 10 # 不需要断言最长长度 # print(opt.load_weights,opt.premodels_path) SRC, TRG = create_fields(opt) model = get_model(opt, len(SRC.vocab), len(TRG.vocab)) lis = [ '01 10 07 11 06', '10 08 06 07 03', '07 04 02 11 03', '06 03 08 02 04', '02 04 03 10 08', '10 05 09 07 04', '01 07 10 04 03', '11 03 06 02 04', '03 02 11 06 04', '01 09 05 04 10', '08 05 03 01 10', '11 09 07 06 01', '02 11 05 06 04', '09 05 04 03 11', '07 05 11 09 03', '05 10 03 09 04', '06 03 05 07 02', '05 06 03 10 02', '05 07 09 06 04', '05 09 08 03 07', '07 10 06 08 09', '11 08 09 06 02', '08 06 07 10 04', '09 07 02 05 01', '03 07 08 01 11', '04 02 08 06 01', '07 10 11 04 02', '11 02 07 03 08', '07 06 11 05 09', '05 01 10 04 06', '03 06 02 08 04', '06 10 07 08 03', '03 05 06 08 10', '11 05 01 08 02', '01 11 10 06 08', '10 04 02 08 09', '10 11 02 08 04', '03 02 01 09 05', '05 09 08 04 06', '10 02 11 06 03', '08 03 04 01 06', '11 04 02 09 06', '06 04 11 10 08', '08 11 03 05 04', '11 01 04 02 05', '05 09 01 04 06', '10 07 01 09 06', '10 08 09 01 11', '03 04 06 02 01', '02 10 08 09 04', '11 09 03 02 06', '04 02 06 01 09', '02 11 10 06 09', '10 01 11 09 04', '11 05 06 08 02', '02 07 03 08 11', '11 06 03 09 01', '01 04 11 05 03', '01 06 04 11 02', '03 08 02 09 04', '05 07 03 01 10', '06 08 09 02 05', '09 02 08 06 11', '06 08 02 03 01', '03 10 02 09 11', '11 05 08 06 09', '06 03 07 01 10', '08 04 06 01 07', '05 08 07 03 11', '03 10 05 02 09', '02 03 05 09 04', '07 04 01 03 06', '07 10 09 01 02', '03 01 05 02 09', '07 01 02 11 09', '11 07 01 03 06', '07 11 08 01 09', '11 01 08 07 06', '08 11 04 05 07', '01 09 06 10 07', '02 05 06 01 11', '06 10 11 02 08', '09 06 01 08 05', '06 05 02 10 08', '03 01 06 09 10', '11 09 06 04 07', '07 08 06 11 03', '07 03 11 04 02', '06 05 10 09 02', '08 04 10 05 11', '06 04 08 03 05', '01 07 06 11 04', '04 06 10 02 07', '07 05 04 01 06', '04 09 07 06 05', '01 07 10 09 06', '01 11 05 07 09', '05 04 11 09 07', '11 05 01 10 03', '07 02 11 05 01', '04 05 09 07 08', '03 01 09 10 07', '06 05 08 02 04', '04 09 10 11 05', '08 06 05 09 04', '01 06 10 03 04', '11 09 10 01 08', '01 04 10 03 02', '04 09 10 11 05', '09 03 10 02 07', '08 02 06 11 07', '09 06 10 01 02', '06 11 02 08 03', '10 03 04 09 07', '05 01 02 11 09', '04 10 07 08 11', '08 05 01 04 06', '06 09 10 02 07', '10 07 06 03 01', '10 09 11 07 02', '09 11 04 06 08', '06 04 07 08 10', '07 06 08 10 11', '09 08 03 10 04', '07 02 11 10 06', '04 08 09 05 10', '04 02 08 03 07', '01 02 07 10 09', '01 07 09 03 08', '11 04 01 06 03', '02 08 03 01 11', '02 01 06 04 03', '05 03 09 01 07', '05 03 08 04 07', '01 03 10 09 02', '10 02 05 04 08', '05 02 06 11 07', '01 04 07 09 10', '03 10 05 06 07', '09 03 05 07 10', '01 05 08 04 03', '09 05 08 03 11', '05 08 02 04 01', '03 11 06 01 04', '10 04 06 11 09', '07 05 08 11 10', '08 04 03 07 01', '04 07 10 06 02', '03 07 02 11 09', '03 08 11 07 01', '02 05 10 09 01', '05 06 08 09 11', '07 05 10 09 06', '07 01 10 08 06', '01 11 05 04 10', '09 07 08 06 04', '01 11 08 03 05', '01 07 05 08 04', '07 02 08 04 05' # '07 03 06 10 09', '08 04 03 11 02', '04 07 03 11 09', '03 02 07 01 04', '04 03 09 01 02', # '01 02 05 08 10', '07 10 05 03 01', '08 05 03 10 04', '02 01 06 03 04', '02 04 10 05 11', # '04 06 03 05 10', '06 01 05 02 10', '09 02 06 03 01', '08 09 01 03 07', '03 02 10 05 07', # '10 08 09 06 07', '03 06 08 10 11', '10 08 06 02 01' ] num = config.history for i, line in enumerate(lis): if i >= num - 1: if config.tag: opt.text = " <tag> ".join(lis[i - num + 1:i + 1]) else: opt.text = " ".join(lis[i - num + 1:i + 1]) result_phrase = translate_one_sentence( opt, model, SRC, TRG) # 预测值 if i + 1 not in history_sum.keys(): # 统计第i+1期预测的值 history_sum[i + 1] = [result_phrase] else: history_sum[i + 1] += [result_phrase] # if i != len(lis) - 1: # res_pre[i+1]=lis[i+1] print("history_sum", history_sum) total2 = [] total3 = [] for i in range(3, len(lis)): # history_sum[i] # 预测的第i期 和 lis[i] 实际值 比较 sorting = count_( [word for words in history_sum[i] for word in words.split(" ")]) # similar2=len(list(set(lis[i].split(" ")).intersection(set([a for a,b in sorting[:3]])))) # 获取排列前三的数据 # similar2=len(list(set(lis[i].split(" ")).intersection(set([a for a,b in sorting[-2:]+sorting[:1] ])))) # 获取排列前三的数据 # similar3=len(list(set(lis[i].split(" ")).intersection(set([a for a,b in sorting[-2:]+sorting[:2] ])))) # 获取排列前四的数据 similar2 = len( list( set(lis[i].split(" ")).intersection( set([a for a, b in sorting[:4]])))) # 获取排列前三的数据 similar3 = len( list( set(lis[i].split(" ")).intersection( set([a for a, b in sorting[:5]])))) # 获取排列前四的数据 if similar2 < 2: total2.append(-6) elif similar2 == 2: total2.append(0) elif similar2 == 3: total2.append(12) if similar3 <= 2: total3.append(-8) elif similar3 == 3: total3.append(11) elif similar3 == 4: total3.append(68) print("2", total2) sum2 = 0 for i in total2: sum2 += i print("任二 一共投注 %d 期 最终结果 输赢值 为 %d" % (len(lis) - 1, sum2)) print("3", total3) sum3 = 0 for i in total3: sum3 += i print("任三 一共投注 %d 期 最终结果 输赢值 为 %d" % (len(lis) - 1, sum3)) print("预测最后一期", count_([ word for words in history_sum[len(lis)] for word in words.split(" ") ])) # 预测的最后一期
def main_simple(model_Key): lis = [ '01 10 07 11 06', '10 08 06 07 03', '07 04 02 11 03', '06 03 08 02 04', '02 04 03 10 08', '10 05 09 07 04', '01 07 10 04 03', '11 03 06 02 04', '03 02 11 06 04', '01 09 05 04 10', '08 05 03 01 10', '11 09 07 06 01', '02 11 05 06 04', '09 05 04 03 11', '07 05 11 09 03', '05 10 03 09 04', '06 03 05 07 02', '05 06 03 10 02', '05 07 09 06 04', '05 09 08 03 07', '07 10 06 08 09', '11 08 09 06 02', '08 06 07 10 04', '09 07 02 05 01', '03 07 08 01 11', '04 02 08 06 01', '07 10 11 04 02', '11 02 07 03 08', '07 06 11 05 09', '05 01 10 04 06', '03 06 02 08 04', '06 10 07 08 03', '03 05 06 08 10', '11 05 01 08 02', '01 11 10 06 08', '10 04 02 08 09', '10 11 02 08 04', '03 02 01 09 05', '05 09 08 04 06', '10 02 11 06 03', '08 03 04 01 06', '11 04 02 09 06', '06 04 11 10 08', '08 11 03 05 04', '11 01 04 02 05', '05 09 01 04 06', '10 07 01 09 06', '10 08 09 01 11', '03 04 06 02 01', '02 10 08 09 04', '11 09 03 02 06', '04 02 06 01 09', '02 11 10 06 09', '10 01 11 09 04', '11 05 06 08 02', '02 07 03 08 11', '11 06 03 09 01', '01 04 11 05 03', '01 06 04 11 02', '03 08 02 09 04', '05 07 03 01 10', '06 08 09 02 05', '09 02 08 06 11', '06 08 02 03 01', '03 10 02 09 11', '11 05 08 06 09', '06 03 07 01 10', '08 04 06 01 07', '05 08 07 03 11', '03 10 05 02 09', '02 03 05 09 04', '07 04 01 03 06', '07 10 09 01 02', '03 01 05 02 09', '07 01 02 11 09', '11 07 01 03 06', '07 11 08 01 09', '11 01 08 07 06', '08 11 04 05 07', '01 09 06 10 07', '02 05 06 01 11', '06 10 11 02 08', '09 06 01 08 05', '06 05 02 10 08', '03 01 06 09 10', '11 09 06 04 07', '07 08 06 11 03', '07 03 11 04 02', '06 05 10 09 02', '08 04 10 05 11', '06 04 08 03 05', '01 07 06 11 04', '04 06 10 02 07', '07 05 04 01 06', '04 09 07 06 05', '01 07 10 09 06', '01 11 05 07 09', '05 04 11 09 07', '11 05 01 10 03', '07 02 11 05 01', '04 05 09 07 08', '03 01 09 10 07', '06 05 08 02 04', '04 09 10 11 05', '08 06 05 09 04', '01 06 10 03 04', '11 09 10 01 08', '01 04 10 03 02', '04 09 10 11 05', '09 03 10 02 07', '08 02 06 11 07', '09 06 10 01 02', '06 11 02 08 03', '10 03 04 09 07', '05 01 02 11 09', '04 10 07 08 11', '08 05 01 04 06', '06 09 10 02 07', '10 07 06 03 01', '10 09 11 07 02', '09 11 04 06 08', '06 04 07 08 10', '07 06 08 10 11', '09 08 03 10 04', '07 02 11 10 06', '04 08 09 05 10', '04 02 08 03 07', '01 02 07 10 09', '01 07 09 03 08', '11 04 01 06 03', '02 08 03 01 11', '02 01 06 04 03', '05 03 09 01 07', '05 03 08 04 07', '01 03 10 09 02', '10 02 05 04 08', '05 02 06 11 07', '01 04 07 09 10', '03 10 05 06 07', '09 03 05 07 10', '01 05 08 04 03', '09 05 08 03 11', '05 08 02 04 01', '03 11 06 01 04', '10 04 06 11 09', '07 05 08 11 10', '08 04 03 07 01', '04 07 10 06 02', '03 07 02 11 09', '03 08 11 07 01', '02 05 10 09 01', '05 06 08 09 11', '07 05 10 09 06', '07 01 10 08 06', '01 11 05 04 10', '09 07 08 06 04', '01 11 08 03 05', '01 07 05 08 04', '07 02 08 04 05' ] if config.history == len(lis): pres = [] press = [] for key in model_Key.keys(): for model_path in model_Key[key]: parser = argparse.ArgumentParser() parser.add_argument('-premodels', default=True) # 是否加载原来的权重 和 vecab parser.add_argument('-load_weights', default="weights_" + key) # 如果加载预训练的权重,把路径到文件夹,以前的权重和泡菜保存 parser.add_argument('-premodels_path', default="model_weights_" + model_path) # 预训练的模型文件名 parser.add_argument('-k', type=int, default=1) # topK 感觉不需要,设置为1 就OK 或者将其删除 parser.add_argument('-max_len', type=int, default=32) # 最长长度 需加上起始位置 parser.add_argument('-d_model', type=int, default=512) # 嵌入向量和层的维数(默认为512) parser.add_argument('-n_layers', type=int, default=6) # 在Transformer模型中有多少层(默认=6) parser.add_argument('-heads', type=int, default=8) # 需要分割多少个头部以获得多个头部的注意(默认值为8) parser.add_argument('-dropout', type=int, default=0.1) # 决定多大的dropout将(默认=0.1) parser.add_argument('-cuda', default=True, action='store_true') parser.add_argument('-floyd', action='store_true') opt = parser.parse_args() opt.device = 0 if opt.cuda is True else -1 if opt.device == 0: assert torch.cuda.is_available() # assert opt.k > 0 # assert opt.max_len > 10 # 不需要断言最长长度 # print(opt.load_weights,opt.premodels_path) SRC, TRG = create_fields(opt) model = get_model(opt, len(SRC.vocab), len(TRG.vocab)) if config.tag: opt.text = " <tag> ".join(lis) else: opt.text = " ".join(lis) result_phrase = translate_one_sentence(opt, model, SRC, TRG) # 预测值 pres.append(result_phrase) press += result_phrase.split(" ") print(pres) # print("press",len(press),press) print(count_(press)) else: for key in model_Key.keys(): for model_path in model_Key[key]: parser = argparse.ArgumentParser() parser.add_argument('-premodels', default=True) # 是否加载原来的权重 和 vecab parser.add_argument('-load_weights', default="weights_" + key) # 如果加载预训练的权重,把路径到文件夹,以前的权重和泡菜保存 parser.add_argument('-premodels_path', default="model_weights_" + model_path) # 预训练的模型文件名 parser.add_argument('-k', type=int, default=1) # topK 感觉不需要,设置为1 就OK 或者将其删除 parser.add_argument('-max_len', type=int, default=32) # 最长长度 需加上起始位置 parser.add_argument('-d_model', type=int, default=512) # 嵌入向量和层的维数(默认为512) parser.add_argument('-n_layers', type=int, default=6) # 在Transformer模型中有多少层(默认=6) parser.add_argument('-heads', type=int, default=8) # 需要分割多少个头部以获得多个头部的注意(默认值为8) parser.add_argument('-dropout', type=int, default=0.1) # 决定多大的dropout将(默认=0.1) parser.add_argument('-cuda', default=True, action='store_true') parser.add_argument('-floyd', action='store_true') opt = parser.parse_args() opt.device = 0 if opt.cuda is True else -1 if opt.device == 0: assert torch.cuda.is_available() # assert opt.k > 0 # assert opt.max_len > 10 # 不需要断言最长长度 # print(opt.load_weights,opt.premodels_path) SRC, TRG = create_fields(opt) model = get_model(opt, len(SRC.vocab), len(TRG.vocab)) num = config.history sum = [] pres = [] for i, line in enumerate(lis): if i >= num - 1: if config.tag: opt.text = " <tag> ".join(lis[i - num + 1:i + 1]) else: opt.text = " ".join(lis[i - num + 1:i + 1]) result_phrase = translate_one_sentence( opt, model, SRC, TRG) if i != len(lis) - 1: similar_values = set( result_phrase.split(" ")).intersection( set(lis[i + 1].split(" "))) sum.append(len(similar_values)) pres.append(result_phrase) # press += result_phrase.split(" ") total = 0 for i in sum: total += i print(model_path, len(sum), total, total / len(sum), sum) print(model_path, pres)
def main(): ''' Main function ''' parser = argparse.ArgumentParser() parser.add_argument('-data_train', type=str, default="") parser.add_argument('-data_dev', required=True) parser.add_argument('-data_test', type=str, default="") parser.add_argument('-vocab', required=True) parser.add_argument('-epoch', type=int, default=10000) parser.add_argument('-batch_size', type=int, default=64) #parser.add_argument('-d_word_vec', type=int, default=512) parser.add_argument('-d_model', type=int, default=512) # parser.add_argument('-d_inner_hid', type=int, default=2048) # parser.add_argument('-d_k', type=int, default=64) # parser.add_argument('-d_v', type=int, default=64) parser.add_argument('-n_heads', type=int, default=8) parser.add_argument('-n_layers', type=int, default=6) parser.add_argument('-n_warmup_steps', type=int, default=4000) parser.add_argument('-dropout', type=float, default=0.1) # parser.add_argument('-embs_share_weight', action='store_true') # parser.add_argument('-proj_share_weight', action='store_true') parser.add_argument('-log', default=None) parser.add_argument('-save_model', default=None) parser.add_argument('-save_mode', type=str, choices=['all', 'best'], default='best') parser.add_argument('-no_cuda', action='store_true') parser.add_argument('-label_smoothing', action='store_true') parser.add_argument('-num_workers', type=int, default=1) parser.add_argument('-cnn_name', type=str, default="resnet101") parser.add_argument('-cnn_pretrained_model', type=str, default="") parser.add_argument('-joint_enc_func', type=str, default="element_multiplication") # parser.add_argument('-comparative_module_name', type=str, default="transformer_encoder") parser.add_argument('-lr', type=float, default=0.01) # parser.add_argument('-step_size', type=int, default=1000) # parser.add_argument('-gamma', type=float, default=0.9) parser.add_argument('-crop_size', type=int, default=224) parser.add_argument('-max_seq_len', type=int, default=64) parser.add_argument('-attribute_len', type=int, default=5) parser.add_argument('-pretrained_model', type=str, default="") parser.add_argument('-rank_alpha', type=float, default=1.0) parser.add_argument('-patience', type=int, default=7) parser.add_argument('-bleu_valid_every_n', type=int, default=5) parser.add_argument('-data_dev_combined', required=True) parser.add_argument('-beam_size', type=int, default=5) parser.add_argument('-seed', type=int, default=0) parser.add_argument('-attribute_vocab_size', type=int, default=1000) parser.add_argument('-add_attribute', action='store_true') args = parser.parse_args() args.cuda = not args.no_cuda args.d_word_vec = args.d_model args.load_weights = False if args.pretrained_model: args.load_weights = True np.random.seed(0) torch.manual_seed(0) args.device = torch.device('cuda' if args.cuda else 'cpu') log_path = args.log.split("/") log_path = "/".join(log_path[:-1]) if not os.path.exists(log_path): os.makedirs(log_path) model_path = args.save_model.split("/") model_path = "/".join(model_path[:-1]) if not os.path.exists(model_path): os.makedirs(model_path) print(args) if args.data_train: print("======================================start training======================================") transform = transforms.Compose([ transforms.RandomCrop(args.crop_size), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225))]) transform_dev = transforms.Compose([ transforms.CenterCrop(args.crop_size), transforms.ToTensor(), transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225))]) vocab = Vocabulary() vocab.load(args.vocab) args.vocab_size = len(vocab) # Build data loader data_loader_training = get_loader(args.data_train, vocab, transform, args.batch_size, shuffle=True, num_workers=args.num_workers, \ max_seq_len=args.max_seq_len,\ attribute_len=args.attribute_len ) data_loader_dev = get_loader(args.data_dev, vocab, transform_dev, args.batch_size, shuffle=False, num_workers=args.num_workers, \ max_seq_len=args.max_seq_len,\ attribute_len=args.attribute_len ) data_loader_bleu = get_loader_test(args.data_dev_combined, vocab, transform_dev, 1, shuffle=False, attribute_len=args.attribute_len ) list_of_refs_dev = load_ori_token_data_new(args.data_dev_combined) model = get_model(args, load_weights=False) print(count_parameters(model)) # print(model.get_trainable_parameters()) # init_lr = np.power(args.d_model, -0.5) # optimizer = torch.optim.Adam(model.get_trainable_parameters(), lr=init_lr) optimizer = get_std_opt(model, args) train( model, data_loader_training, data_loader_dev, optimizer ,args, vocab, list_of_refs_dev, data_loader_bleu) if args.data_test: print("======================================start testing==============================") args.pretrained_model = args.save_model test(args)
def main(): parser = argparse.ArgumentParser() parser.add_argument('-src_data', required=True) parser.add_argument('-trg_data', required=True) parser.add_argument('-src_lang', required=True) parser.add_argument('-trg_lang', required=True) parser.add_argument('-no_cuda', action='store_true') parser.add_argument('-SGDR', action='store_true') parser.add_argument('-epochs', type=int, default=2) parser.add_argument('-d_model', type=int, default=512) parser.add_argument('-n_layers', type=int, default=6) parser.add_argument('-heads', type=int, default=8) parser.add_argument('-dropout', type=int, default=0.1) parser.add_argument('-batchsize', type=int, default=1500) parser.add_argument('-printevery', type=int, default=100) parser.add_argument('-lr', type=int, default=0.0001) parser.add_argument('-load_weights') parser.add_argument('-create_valset', action='store_true') parser.add_argument('-max_strlen', type=int, default=80) parser.add_argument('-floyd', action='store_true') parser.add_argument('-checkpoint', type=int, default=0) parser.add_argument('-savetokens', type=int, default=0) opt = parser.parse_args() opt.device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") print(opt.device) read_data(opt) SRC, TRG = create_fields(opt) opt.train = create_dataset(opt, SRC, TRG) # # convert translation dictionary to tokens ditionary # translation_dictionar = pickle.load(open('data/translation_dictionary.p', 'rb')) # new_dict = {} # for en_word, fr_word in translation_dictionar.items(): # new_dict[SRC.vocab.stoi[en_word]] = TRG.vocab.stoi[fr_word.lower()] # pickle.dump(new_dict, open('data/tokenized_translation_dictionary.p', 'wb')) model = get_model(opt, len(SRC.vocab), len(TRG.vocab)) model = model.to(device=opt.device) if opt.savetokens == 1: pickle.dump(SRC.vocab, open('SRC_vocab.p', 'wb')) # saves torchtext Vocab object pickle.dump(TRG.vocab, open('TRG_vocab.p', 'wb')) # saves torchtext Vocab object opt.optimizer = torch.optim.Adam(model.parameters(), lr=opt.lr, betas=(0.9, 0.98), eps=1e-9) if opt.SGDR == True: opt.sched = CosineWithRestarts(opt.optimizer, T_max=opt.train_len) if opt.checkpoint > 0: print( "model weights will be saved every %d minutes and at end of epoch to directory weights/" % (opt.checkpoint)) if opt.load_weights is not None and opt.floyd is not None: os.mkdir('weights') pickle.dump(SRC, open('weights/SRC.pkl', 'wb')) pickle.dump(TRG, open('weights/TRG.pkl', 'wb')) train_model(model, opt) if opt.floyd is False: promptNextAction(model, opt, SRC, TRG)
def main(): parser = argparse.ArgumentParser() parser.add_argument('-fold', default=0) parser.add_argument('-src_lang', default='en') parser.add_argument('-trg_lang', default='en') parser.add_argument('-no_cuda', action='store_true') parser.add_argument('-SGDR', action='store_true') parser.add_argument('-epochs', type=int, default=2) parser.add_argument('-d_model', type=int, default=512) parser.add_argument('-n_layers', type=int, default=1) parser.add_argument('-heads', type=int, default=1) parser.add_argument('-dropout', type=int, default=0.1) parser.add_argument('-batchsize', type=int, default=1500) parser.add_argument('-printevery', type=int, default=100) parser.add_argument('-lr', type=int, default=0.001) parser.add_argument('-load_weights') parser.add_argument('-create_valset', action='store_true') parser.add_argument('-max_strlen', type=int, default=192) parser.add_argument('-floyd', action='store_true') parser.add_argument('-checkpoint', type=int, default=0) parser.add_argument('-savetokens', type=int, default=0) opt = parser.parse_args() opt.device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") print(opt.device) read_data(opt) SRC, TRG = create_fields(opt) opt.train = create_dataset(opt, SRC, TRG) model = get_model(opt, len(SRC.vocab), len(TRG.vocab), model_type='train') model = model.to(device=opt.device) if opt.savetokens == 1: pickle.dump(SRC.vocab, open('SRC_vocab.p', 'wb')) # saves torchtext Vocab object pickle.dump(TRG.vocab, open('TRG_vocab.p', 'wb')) # saves torchtext Vocab object opt.optimizer = torch.optim.Adam(model.parameters(), lr=opt.lr, betas=(0.9, 0.98), eps=1e-9) if opt.SGDR == True: opt.sched = CosineWithRestarts(opt.optimizer, T_max=opt.train_len) if opt.checkpoint > 0: print("model weights will be saved every %d minutes and at end of epoch to directory weights/"%(opt.checkpoint)) if opt.load_weights is not None and opt.floyd is not None: os.mkdir('weights') pickle.dump(SRC, open('weights/SRC.pkl', 'wb')) pickle.dump(TRG, open('weights/TRG.pkl', 'wb')) # train model train_model(model, opt) # save weights dst = '../gdrive/My Drive/tweet-sentiment-extraction' print("saving weights to " + dst + "/...") torch.save(model.state_dict(), f'{dst}/model_weights') pickle.dump(SRC, open(f'{dst}/SRC.pkl', 'wb')) pickle.dump(TRG, open(f'{dst}/TRG.pkl', 'wb')) saved_once = 1 print("weights and field pickles saved to " + dst)
def main(): parser = argparse.ArgumentParser() parser.add_argument('-data_path', required=True) parser.add_argument('-output_dir', required=True) parser.add_argument('-no_cuda', action='store_true') parser.add_argument('-SGDR', action='store_true') parser.add_argument('-val_check_every_n', type=int, default=3) parser.add_argument('-calculate_val_loss', action='store_true') parser.add_argument('-tensorboard_graph', action='store_true') parser.add_argument('-compositional_eval', action='store_true') parser.add_argument('-char_tokenization', action='store_true') parser.add_argument('-alex', action='store_true') parser.add_argument('-n_val', type=int, default=1000) parser.add_argument('-n_test', type=int, default=1000) parser.add_argument('-do_test', action='store_true') parser.add_argument('-epochs', type=int, default=50) parser.add_argument('-d_model', type=int, default=512) parser.add_argument('-n_layers', type=int, default=6) parser.add_argument('-heads', type=int, default=8) parser.add_argument('-dropout', type=int, default=0.1) parser.add_argument('-batchsize', type=int, default=3000) parser.add_argument('-printevery', type=int, default=100) parser.add_argument('-lr', type=int, default=0.00001) parser.add_argument('-load_weights') parser.add_argument('-create_valset', action='store_true') parser.add_argument('-max_strlen', type=int, default=512) parser.add_argument('-floyd', action='store_true') parser.add_argument('-checkpoint', type=int, default=0) opt = parser.parse_args() opt.device = 0 if opt.no_cuda is False else -1 if opt.device == 0: assert torch.cuda.is_available() if opt.alex: torch.cuda.set_device(1) read_data(opt) SRC, TRG = create_fields(opt) opt.train, opt.val = create_dataset(opt, SRC, TRG) model = get_model(opt, len(SRC.vocab), len(TRG.vocab), SRC) if opt.tensorboard_graph: writer = SummaryWriter('runs') for i, batch in enumerate(opt.train): src = batch.src.transpose(0, 1).cuda() trg = batch.trg.transpose(0, 1).cuda() trg_input = trg[:, :-1] src_mask, trg_mask = create_masks(src, trg_input, opt) writer.add_graph(model, (src, trg_input, src_mask, trg_mask)) break writer.close() # beam search parameters opt.k = 1 opt.max_len = opt.max_strlen opt.optimizer = torch.optim.Adam(model.parameters(), lr=opt.lr, betas=(0.9, 0.98), eps=1e-9) opt.scheduler = ReduceLROnPlateau(opt.optimizer, factor=0.2, patience=5, verbose=True) if opt.SGDR: opt.sched = CosineWithRestarts(opt.optimizer, T_max=opt.train_len) if opt.checkpoint > 0: print("model weights will be saved every %d minutes and at end of epoch to directory weights/"%(opt.checkpoint)) train_model(model, opt, SRC, TRG) if opt.floyd is False: promptNextAction(model, opt, SRC, TRG)
def test(opt): transform = transforms.Compose([ transforms.CenterCrop(opt.crop_size), transforms.ToTensor(), transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225)) ]) vocab = Vocabulary() vocab.load(opt.vocab) data_loader = get_loader_test(opt.data_test, vocab, transform, opt.batch_size, shuffle=False, attribute_len=opt.attribute_len) list_of_refs = load_ori_token_data_new(opt.data_test) model = get_model(opt, load_weights=True) count = 0 hypotheses = {} model.eval() for batch in tqdm(data_loader, mininterval=2, desc=' - (Test)', leave=False): image0, image1, image0_attribute, image1_attribute = map( lambda x: x.to(opt.device), batch) hyp = beam_search(image0, image1, model, opt, vocab, image0_attribute, image1_attribute) # hyp = greedy_search(image1.to(device), image2.to(device), model, opt, vocab) hyp = hyp.split("<end>")[0].strip() hypotheses[count] = ["it " + hyp] count += 1 # ================================================= # Set up scorers # ================================================= print('setting up scorers...') scorers = [ (Bleu(4), ["Bleu_1", "Bleu_2", "Bleu_3", "Bleu_4"]), # (Meteor(),"METEOR"), (Rouge(), "ROUGE_L"), # (Cider(), "CIDEr"), (Cider(), "CIDEr"), (CiderD(), "CIDEr-D") # (Spice(), "SPICE") ] for scorer, method in scorers: print('computing %s score...' % (scorer.method())) score, scores = scorer.compute_score(list_of_refs, hypotheses) if type(method) == list: for sc, scs, m in zip(score, scores, method): # self.setEval(sc, m) # self.setImgToEvalImgs(scs, gts.keys(), m) print("%s: %0.3f" % (m, sc)) else: # self.setEval(score, method) # self.setImgToEvalImgs(scores, gts.keys(), method) print("%s: %0.3f" % (method, score)) for i in range(len(hypotheses)): ref = {i: list_of_refs[i]} hyp = {i: hypotheses[i]} print(ref) print(hyp) for scorer, method in scorers: print('computing %s score...' % (scorer.method())) score, scores = scorer.compute_score(ref, hyp) if type(method) == list: for sc, scs, m in zip(score, scores, method): # self.setEval(sc, m) # self.setImgToEvalImgs(scs, gts.keys(), m) print("%s: %0.3f" % (m, sc)) else: # self.setEval(score, method) # self.setImgToEvalImgs(scores, gts.keys(), method) print("%s: %0.3f" % (method, score))