def main(): input_lang, output_lang, pairs = prepare_data('ques', 'ans', '../debug.json', reverse=False) encoder = EncoderRNN(input_lang.n_words, hidden_size).to(device) attn_decoder = AttnDecoderRNN(hidden_size, output_lang.n_words, dropout_p=0.1, max_length=1000).to(device) rate = 0.9 pairs_train, pairs_test = pairs[0:int(len(pairs) * rate)], pairs[int(len(pairs) * rate):] encoder.load_state_dict(torch.load('model/encoder-0.model')) encoder.eval() attn_decoder.load_state_dict(torch.load('model/decoder-0.model')) attn_decoder.eval() evaluate_all(encoder, attn_decoder, pairs_test, max_length=1000, input_lang=input_lang, output_lang=output_lang, n=len(pairs_test)) # show_plot(loss_history) print('done test')
def load_model(): encoder = EncoderRNN(human_n_chars, hidden_size, n_layers) decoder = AttnDecoderRNN(attn_model, hidden_size, machine_n_chars, n_layers, dropout_p=dropout_p) encoder.load_state_dict(t.load('encoder.pth')) decoder.load_state_dict(t.load('decoder.pth')) return encoder, decoder
def inference(sentence, language, MODEL_DIR, codersum): encoder = EncoderRNN(language.n_words, config.HIDDEN_SIZE, config.NUM_LAYER, max_length=config.MAX_LENGTH + 1) decoder = AttnDecoderRNN(config.ATT_MODEL, config.HIDDEN_SIZE, language.n_words, config.NUM_LAYER, dropout_p=config.DROPOUT) encoder_path = os.path.join(MODEL_DIR, "encoder_" + str(codersum) + ".pth") decoder_path = os.path.join(MODEL_DIR, "decoder_" + str(codersum) + ".pth") encoder.load_state_dict(torch.load(encoder_path, map_location="cpu")) decoder.load_state_dict(torch.load(decoder_path, map_location="cpu")) encoder.eval() decoder.eval() batch_size = 1 input_index = indexes_from_sentence(language, sentence) input_index = pad_sentence(input_index) # 填充 input_variable = torch.LongTensor([input_index]) encoder_hidden, encoder_cell = encoder.init_hidden(batch_size) encoder_outputs, encoder_hidden, encoder_cell = encoder( input_variable, encoder_hidden, encoder_cell) decoder_input = torch.zeros(batch_size, 1).long() decoder_context = torch.zeros(batch_size, decoder.hidden_size) decoder_hidden = encoder_hidden decoder_cell = encoder_cell if config.USE_CUDA: decoder_input = decoder_input.cuda() decoder_context = decoder_context.cuda() decoded_words = [] # Run through decoder for di in range(config.MAX_LENGTH): decoder_output, decoder_context, decoder_hidden, decoder_cell, _ = decoder( decoder_input, decoder_context, decoder_hidden, decoder_cell, encoder_outputs) # Choose top word from output topv, topi = decoder_output.data.topk(1) ni = topi[0][0] if ni == 0: break else: decoded_words.append(language.index2word[ni.item()]) decoder_input = torch.LongTensor([[ni]]) if config.USE_CUDA: decoder_input = decoder_input.cuda() return "".join(decoded_words)
def load_model_param(language, model_dir): encoder = EncoderRNN(language.n_words, config.HIDDEN_SIZE, config.NUM_LAYER, max_length=17 + 1) decoder = AttnDecoderRNN(config.ATT_MODEL, config.HIDDEN_SIZE, language.n_words, config.NUM_LAYER, dropout_p=config.DROPOUT) encoder_path = os.path.join(config.MODEL_DIR, "encoder.pth") decoder_path = os.path.join(config.MODEL_DIR, "decoder.pth") encoder.load_state_dict(torch.load(encoder_path, map_location="cpu")) decoder.load_state_dict(torch.load(decoder_path, map_location="cpu")) encoder.eval() decoder.eval() return encoder, decoder
def main(): nIters = 50000 device = torch.device("cuda" if torch.cuda.is_available() else "cpu") loadFilename = os.path.join('checkpoints', '{}_{}.tar'.format(nIters, 'checkpoint')) checkpoint = torch.load(loadFilename, map_location=device) # input_lang, output_lang, pairs = prepareData('eng', 'fra', True, 'data', filter=False) # If loading a model trained on GPU to CPU encoder_sd = checkpoint['en'] encoder_sd decoder_sd = checkpoint['de'] decoder_sd hidden_size = 512 input_lang = Lang('fra') output_lang = Lang('eng') input_lang.__dict__ = checkpoint['input_lang'] output_lang.__dict__ = checkpoint['output_lang'] encoder = EncoderRNN(input_lang.n_words, hidden_size).to(device) decoder = AttnDecoderRNN(hidden_size, output_lang.n_words, dropout_p=0).to(device) encoder.load_state_dict(encoder_sd) decoder.load_state_dict(decoder_sd) encoder.eval() decoder.eval() # encoder_optimizer_sd = checkpoint['en_opt'] # decoder_optimizer_sd = checkpoint['de_opt'] _, _, test_pairs = prepareData('eng', 'fra', True, dir='test', filter=False) evaluateRandomly(device, test_pairs, encoder, decoder, input_lang, output_lang) decode_batch(device, test_pairs, encoder, decoder, input_lang, output_lang, batch_size=64)
def main(): nIters = 100000 loadFilename = os.path.join('checkpoints', '{}_{}.tar'.format(nIters, 'checkpoint')) checkpoint = torch.load(loadFilename) device = torch.device("cuda" if torch.cuda.is_available() else "cpu") input_lang, output_lang, pairs = prepareData('eng', 'fra', True) # If loading a model trained on GPU to CPU encoder_sd = checkpoint['en'] decoder_sd = checkpoint['de'] hidden_size = 256 encoder = EncoderRNN(input_lang.n_words, hidden_size, device).to(device) decoder = AttnDecoderRNN(hidden_size, output_lang.n_words, device, dropout_p=0.1).to(device) encoder.load_state_dict(encoder_sd) decoder.load_state_dict(decoder_sd) encoder_optimizer_sd = checkpoint['en_opt'] decoder_optimizer_sd = checkpoint['de_opt'] input_lang.__dict__ = checkpoint['input_lang'] output_lang.__dict__ = checkpoint['output_lang'] evaluateRandomly(device, pairs, encoder, decoder, input_lang, output_lang)
def eval_network(fn_in_model): # Input # fn_in_model : filename of saved model # # Create filename for output fn_out_res = fn_in_model fn_out_res = fn_out_res.replace('.tar', '.txt') fn_out_res_test = fn_out_res.replace('/net_', '/res_test_') # Load and evaluate the network in filename 'fn_in_model' assert (os.path.isfile(fn_in_model)) print(' Checkpoint found...') print(' Processing model: ' + fn_in_model) print(' Writing to file: ' + fn_out_res_test) checkpoint = torch.load(fn_in_model, map_location='cpu') # evaluate model on CPU input_lang = checkpoint['input_lang'] output_lang = checkpoint['output_lang'] emb_size = checkpoint['emb_size'] nlayers = checkpoint['nlayers'] dropout_p = checkpoint['dropout'] input_size = input_lang.n_symbols output_size = output_lang.n_symbols samples_val = checkpoint['episodes_validation'] disable_memory = checkpoint['disable_memory'] max_length_eval = checkpoint['max_length_eval'] if 'args' not in checkpoint or 'disable_attention' not in checkpoint[ 'args']: use_attention = True else: args = checkpoint['args'] use_attention = not args.disable_attention if disable_memory: encoder = WrapperEncoderRNN(emb_size, input_size, output_size, nlayers, dropout_p) else: encoder = MetaNetRNN(emb_size, input_size, output_size, nlayers, dropout_p) if use_attention: decoder = AttnDecoderRNN(emb_size, output_size, nlayers, dropout_p) else: decoder = DecoderRNN(emb_size, output_size, nlayers, dropout_p) if USE_CUDA: encoder = encoder.cuda() decoder = decoder.cuda() encoder.load_state_dict(checkpoint['encoder_state_dict']) decoder.load_state_dict(checkpoint['decoder_state_dict']) with open(fn_out_res_test, 'w') as f_test: with redirect_stdout(f_test): if 'episode' in checkpoint: print(' Loading epoch ' + str(checkpoint['episode']) + ' of ' + str(checkpoint['num_episodes'])) describe_model(encoder) describe_model(decoder) if eval_type == 'val': print( 'Evaluating VALIDATION performance on pre-generated validation set' ) acc_val_gen, acc_val_retrieval = evaluation_battery( samples_val, encoder, decoder, input_lang, output_lang, max_length_eval, verbose=True) print('Acc Retrieval (val): ' + str(round(acc_val_retrieval, 1))) print('Acc Generalize (val): ' + str(round(acc_val_gen, 1))) elif eval_type == 'addprim_jump': print('Evaluating TEST performance on SCAN addprim_jump') print(' ...support set is just the isolated primitives') mybatch = scan_evaluation_prim_only('addprim_jump', 'test', input_lang, output_lang) acc_val_gen, acc_val_retrieval = evaluation_battery( [mybatch], encoder, decoder, input_lang, output_lang, max_length_eval, verbose=True) elif eval_type == 'length': print('Evaluating TEST performance on SCAN length') print( ' ...over multiple support sets as contributed by the pre-generated validation set' ) samples_val = scan_evaluation_val_support( 'length', 'test', input_lang, output_lang, samples_val) acc_val_gen, acc_val_retrieval = evaluation_battery( samples_val, encoder, decoder, input_lang, output_lang, max_length_eval, verbose=True) print('Acc Retrieval (val): ' + str(round(acc_val_retrieval, 1))) print('Acc Generalize (val): ' + str(round(acc_val_gen, 1))) elif eval_type == 'template_around_right': print('Evaluating TEST performance on the SCAN around right') print(' ...with just direction mappings as support set') mybatch = scan_evaluation_dir_only('template_around_right', 'test', input_lang, output_lang) acc_val_gen, acc_val_retrieval = evaluation_battery( [mybatch], encoder, decoder, input_lang, output_lang, max_length_eval, verbose=True) else: assert False
# Initialize models encoder = EncoderRNN(chinese.n_words, config.HIDDEN_SIZE, config.NUM_LAYER, max_length=config.MAX_LENGTH + 1) decoder = AttnDecoderRNN(config.ATT_MODEL, config.HIDDEN_SIZE, chinese.n_words, config.NUM_LAYER, dropout_p=config.DROPOUT) if config.RESTORE: encoder_path = os.path.join(config.MODEL_DIR, "encoder.pth") decoder_path = os.path.join(config.MODEL_DIR, "decoder.pth") encoder.load_state_dict(torch.load(encoder_path)) decoder.load_state_dict(torch.load(decoder_path)) # Move models to GPU if config.USE_CUDA: encoder.cuda() decoder.cuda() # Initialize optimizers and criterion encoder_optimizer = optim.Adam(encoder.parameters(), lr=config.LR) decoder_optimizer = optim.Adam(decoder.parameters(), lr=config.LR) criterion = LanguageModelCriterion() #nn.NLLLoss(ignore_index=0) # Keep track of time elapsed and running averages start = time.time() plot_losses = [] print_loss_total = 0
decoder_scheduler = optim.lr_scheduler.ReduceLROnPlateau( optimizer=decoder_optimizer, mode='min', factor=0.1, patience=5, verbose=True, min_lr=0.00001) criterion = nn.NLLLoss(ignore_index=PAD_token) # Resume from checkpoint if args.resume: if os.path.isfile(args.resume): print("=> loading checkpoint '{}'".format(args.resume)) checkpoint = torch.load(args.resume) encoder.load_state_dict(checkpoint['encoder_state_dict']) decoder.load_state_dict(checkpoint['decoder_state_dict']) encoder_optimizer.load_state_dict(checkpoint['encoder_optim_state']) decoder_optimizer.load_state_dict(checkpoint['decoder_optim_state']) print("=> loaded checkpoint '{}' (epoch {})" .format(args.resume, checkpoint['epoch'])) else: print("=> no checkpoint found at '{}'".format(args.resume)) # Train and evalute print("\nStart") # print("Evaluate randomly on training sentences:") # evaluateRandomly(encoder, decoder, train_pairs, lang, lang, args) # print("Evaluate randomly on testing sentences:") # evaluateRandomly(encoder, decoder, test_pairs, lang, lang, args) trainEpochs(encoder, decoder, encoder_optimizer, decoder_optimizer, encoder_scheduler, decoder_scheduler, criterion, train_dataiter, args)
# fastapi main app app = FastAPI() # define color generator related model encoder = EncoderRNN(hidden_size=150, n_layers=1, dropout_p=0) decoder = AttnDecoderRNN(hidden_size=150, n_layers=1, dropout_p=0) sen2vec = Sentence2Vec() encoder.load_state_dict( torch.load("./ckpt/ckpt_666.pt", map_location=lambda storage, loc: storage)[ "encoder" ] ) decoder.load_state_dict( torch.load("./ckpt/ckpt_666.pt", map_location=lambda storage, loc: storage)[ "decoder_state_dict" ] ) encoder.eval() decoder.eval() def lab2rgb_1d(in_lab, clip=True): tmp_rgb = lab2rgb(in_lab[np.newaxis, np.newaxis, :], illuminant="D50").flatten() if clip: tmp_rgb = np.clip(tmp_rgb, 0, 1) return tmp_rgb class InputText(BaseModel): input_text: str = None
decoder_input, decoder_hidden, encoder_outputs) topv, topi = decoder_output.data.topk(1) if topi.item() == config.EOS_token: break else: output_sentence.append(output_lang.index2word[topi.item()]) decoder_input = topi.squeeze().detach() return ' '.join(output_sentence) dataset = DataSet(config.input_lang, config.target_lang, config.path) dataset.prepareData() encoder = EncoderRNN(dataset.input_lang.n_words, config.hidden_size) decoder = AttnDecoderRNN(config.hidden_size, dataset.target_lang.n_words, config.MAX_LENGTH) encoder.load_state_dict( torch.load(config.curPath + 'annotation_encoder.pth', map_location=config.eval_device)) decoder.load_state_dict( torch.load(config.curPath + 'annotation_decoder.pth', map_location=config.eval_device)) code = sys.argv[1] #code = input() input_tensor = dataset.tensorFromSentence(code, dataset.input_lang) output_annotation = evaluate(encoder, decoder, input_tensor, dataset.target_lang) print(output_annotation)