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)