def load_test_model(opt, dummy_opt, model_path=None):
if model_path is None:
model_path = opt.models[0]
checkpoint = torch.load(model_path,
map_location=lambda storage, loc: storage)
vocab = checkpoint['vocab']
if inputters.old_style_vocab(vocab):
fields = inputters.load_fields_from_vocab(vocab, opt.data_type)
else:
fields = vocab
model_opt = checkpoint['opt']
for arg in dummy_opt:
if arg not in model_opt:
model_opt.__dict__[arg] = dummy_opt[arg]
# changed to my_build_base_model by wchen
if 'hr' in model_opt.encoder_type or 'hr' in model_opt.decoder_type or 'CatSeqD' in model_opt.decoder_type:
model = my_build_base_model(model_opt, fields, use_gpu(opt),
checkpoint)
else:
model = build_base_model(model_opt, fields, use_gpu(opt), checkpoint)
model.eval()
model.generator.eval()
return fields, model, model_opt
def load_test_model(opt, model_path=None):
if model_path is None:
model_path = opt.models[0]
checkpoint = torch.load(model_path,
map_location=lambda storage, loc: storage)
model_opt = ArgumentParser.ckpt_model_opts(checkpoint['opt'])
ArgumentParser.update_model_opts(model_opt)
ArgumentParser.validate_model_opts(model_opt)
vocab = checkpoint['vocab']
if inputters.old_style_vocab(vocab):
fields = inputters.load_old_vocab(
vocab, opt.data_type, dynamic_dict=model_opt.copy_attn
)
else:
fields = vocab
arae_model_path = opt.model_arae if opt.arae and checkpoint else None
model = build_base_model(model_opt, fields, use_gpu(opt), checkpoint,
opt.gpu, arae_setting=opt.arae, arae_model_path=arae_model_path)
if opt.arae:
model, gan_g, gan_d = model
gan_g.eval()
gan_d.eval()
if opt.fp32:
model.float()
model.eval()
model.generator.eval()
if opt.arae:
model = model, gan_g, gan_d
return fields, model, model_opt
def build_model(model_opt, opt, fields, checkpoint):
""" Build the Model """
assert model_opt.key_model in ['reranker']
logger.info('Building reRanker model...')
model = build_reranker_model(model_opt, fields, use_gpu(opt), checkpoint)
logger.info(model)
return model
def load_test_model(opt, model_path=None):
if model_path is None:
model_path = opt.models
checkpoint = torch.load(model_path[0],
map_location=lambda storage, loc: storage)
model_opt = ArgumentParser.ckpt_model_opts(checkpoint['opt'])
ArgumentParser.update_model_opts(model_opt)
ArgumentParser.validate_model_opts(model_opt)
vocab = checkpoint['vocab']
teacher_vocab = checkpoint['teacher_vocab']
if inputters.old_style_vocab(vocab):
fields = inputters.load_old_vocab(vocab,
opt.data_type,
dynamic_dict=model_opt.copy_attn)
else:
fields = vocab
teacher_fields = teacher_vocab
fields_opt = {'original': fields, 'teacher': teacher_fields}
# setattr(fields,"true_tgt_vocab",true_tgt_field.vocab)
model = build_base_model(model_opt, fields_opt, use_gpu(opt), checkpoint,
opt.gpu)
if opt.fp32:
model.float()
model.eval()
model.generator.eval()
return fields, model, model_opt
def ltm(opt, model_path=None):
if model_path is None:
model_path = opt.models[0]
checkpoint = torch.load(model_path,
map_location=lambda storage, loc: storage)
model_opt = ArgumentParser.ckpt_model_opts(checkpoint["opt"])
ArgumentParser.update_model_opts(model_opt)
ArgumentParser.validate_model_opts(model_opt)
vocab = checkpoint["vocab"]
if inputters.old_style_vocab(vocab):
fields = inputters.load_old_vocab(vocab,
opt.data_type,
dynamic_dict=model_opt.copy_attn)
else:
fields = vocab
# This will randomly initialize
if settings.RANDOM_WEIGHTS:
checkpoint = None
model = build_base_model(model_opt, fields, use_gpu(opt), checkpoint,
opt.gpu)
if opt.fp32:
model.float()
model.eval()
model.generator.eval()
return fields, model, model_opt
def build_model(model_opt, opt, fields, checkpoint):
""" Build the Model """
logger.info('Building model...')
model = build_base_model(model_opt, fields,
use_gpu(opt), checkpoint)
logger.info(model)
return model
def build_model(model_opt, opt, fields, checkpoint, FeatureValues, FeatureTensors, FeatureTypes, FeaturesList, FeatureNames, FTInfos, FeatureTypesNames, SimulationLanguages):
""" Build the Model """
logger.info('Building model...')
model = build_base_model(model_opt, fields,
use_gpu(opt), FeatureValues, FeatureTensors, FeatureTypes, FeaturesList, FeatureNames, FTInfos, FeatureTypesNames, SimulationLanguages, checkpoint)
logger.info(model)
return model
def load_test_model(opt, model_path=None):
if model_path is None:
model_path = opt.models[0]
checkpoint = torch.load(model_path,
map_location=lambda storage, loc: storage)
model_opt = ArgumentParser.ckpt_model_opts(checkpoint['opt'])
ArgumentParser.update_model_opts(model_opt)
ArgumentParser.validate_model_opts(model_opt)
vocab = checkpoint['vocab']
if inputters.old_style_vocab(vocab):
fields = inputters.load_old_vocab(vocab,
opt.data_type,
dynamic_dict=model_opt.copy_attn)
else:
fields = vocab
model = build_base_model(model_opt, fields, use_gpu(opt), checkpoint,
opt.gpu)
if opt.fp32:
model.float()
model.eval()
model.generator.eval()
# TODO(yida)
if model_opt.pos_gen:
model.pos_generator.eval()
return fields, model, model_opt
def load_test_model(opt, args):
model_path = opt.models[0]
checkpoint = torch.load(model_path,
map_location=lambda storage, loc: storage)
model_opt = ArgumentParser.ckpt_model_opts(checkpoint['opt'])
ArgumentParser.update_model_opts(model_opt)
ArgumentParser.validate_model_opts(model_opt)
vocab = checkpoint['vocab']
if inputters.old_style_vocab(vocab):
fields = inputters.load_old_vocab(vocab,
opt.data_type,
dynamic_dict=model_opt.copy_attn)
else:
fields = vocab
model = build_base_model(model_opt, fields, use_gpu(opt), args, checkpoint,
opt.gpu)
if args.data_type == 'fp32':
model.float()
elif args.data_type == 'fp16':
model.half()
else:
raise ValueError('wrong data_type argument {}'.format(args.data_type))
model.eval()
model.generator.eval()
return fields, model, model_opt
def load_test_multitask_model(opt, model_path=None):
if model_path is None:
model_path = opt.models[0]
checkpoint = torch.load(model_path,
map_location=lambda storage, loc: storage)
model = checkpoint['whole_model']
vocab = checkpoint['vocab']
src_tgtpair = opt.src_lang + '-' + opt.tgt_lang
vocab = vocab if type(vocab) is dict else vocab[src_tgtpair]
if inputters.old_style_vocab(vocab):
fields = inputters.load_old_vocab(vocab,
opt.data_type,
dynamic_dict=model_opt.copy_attn)
else:
fields = vocab
if opt.data_type == 'audio' and not (isinstance(
checkpoint.get('vocab')[src_tgtpair]['src'], AudioSeqField)):
vocab_path = "/home/vazquezj/Documents/iwslt2019/_ready_to_train/onmt_ready/ENaudio_DEtext/data"
fields = torch.load(vocab_path + '.vocab.pt')
model_opt = ArgumentParser.ckpt_model_opts(checkpoint['opt'])
device = torch.device("cuda" if use_gpu(opt) else "cpu")
model.to(device)
model.eval()
return fields, model, model_opt
def load_test_model(opt,
dummy_opt,
FeatureValues,
FeatureTensors,
FeatureTypes,
FeaturesList,
FeatureNames,
FTInfos,
FeatureTypesNames,
SimulationLanguages,
model_path=None):
if model_path is None:
model_path = opt.models[0]
checkpoint = torch.load(model_path,
map_location=lambda storage, loc: storage)
fields = inputters.load_fields_from_vocab(checkpoint['vocab'],
data_type=opt.data_type)
model_opt = checkpoint['opt']
for arg in dummy_opt:
if arg not in model_opt:
model_opt.__dict__[arg] = dummy_opt[arg]
#TODO: delete all parameters related to WALS: FeatureValues, FeatureTensors, FeatureTypes, FeaturesList, FeatureNames, FTInfos, FeatureTypesNames, SimulationLanguages
#TODO: include four numpy arrays (from wals.npz)
model = build_base_model(model_opt, fields, use_gpu(opt), FeatureValues,
FeatureTensors, FeatureTypes, FeaturesList,
FeatureNames, FTInfos, FeatureTypesNames,
SimulationLanguages, checkpoint)
model.eval()
model.generator.eval()
return fields, model, model_opt
def load_test_model(opt, dummy_opt, model_path=None):
if model_path is None:
model_path = opt.models[0]
checkpoint = torch.load(model_path,
map_location=lambda storage, loc: storage)
fields = inputters.load_fields_from_vocab(
checkpoint['vocab'], data_type=opt.data_type)
model_opt = checkpoint['opt']
for arg in dummy_opt:
if arg not in model_opt:
model_opt.__dict__[arg] = dummy_opt[arg]
#if not hasattr(model_opt, 'model_mode'):
model_opt.model_mode = opt.model_mode
model_opt.model_mode2 = opt.model_mode2
model_opt.model_ffn_mode = opt.model_ffn_mode
print(
"[onmt.model_builder.py] model_opt.model_mode: {}, model_opt.model_mode2: {}, model_opt.model_ffn_mode: {}"
.format(model_opt.model_mode, model_opt.model_mode2, model_opt.model_ffn_mode)
)
model = build_base_model(model_opt, fields, use_gpu(opt), checkpoint)
model.eval()
model.generator.eval()
return fields, model, model_opt
def load_lm_bias_test_model(opt, dummy_opt, model_path=None):
if model_path is None:
model_path = opt.models[0]
checkpoint = torch.load(model_path,
map_location=lambda storage, loc: storage)
fields = inputters.load_fields_from_vocab(checkpoint['vocab'],
data_type=opt.data_type)
model_opt = checkpoint['opt']
for arg in dummy_opt:
if arg not in model_opt:
model_opt.__dict__[arg] = dummy_opt[arg]
lm_out_checkpoint = torch.load(opt.lm_out,
map_location=lambda storage, loc: storage)
lm_in_checkpoint = torch.load(opt.lm_in,
map_location=lambda storage, loc: storage)
model = build_lm_bias_base_model(model_opt, fields, use_gpu(opt),
checkpoint, lm_out_checkpoint,
lm_in_checkpoint)
model.eval()
model.generator.eval()
model.lm_out.eval()
model.lm_out.generator.eval()
model.lm_in.eval()
model.lm_in.generator.eval()
return fields, model, model_opt
def load_test_model(opt, model_path=None):
if model_path is None:
model_path = opt.models[0]
checkpoint = torch.load(model_path,
map_location=lambda storage, loc: storage)
model_opt = ArgumentParser.ckpt_model_opts(checkpoint['opt'])
ArgumentParser.update_model_opts(model_opt)
ArgumentParser.validate_model_opts(model_opt)
vocab = checkpoint['vocab']
if inputters.old_style_vocab(vocab):
fields = inputters.load_old_vocab(
vocab, opt.data_type, dynamic_dict=model_opt.copy_attn
)
else:
fields = vocab
# @memray, to make tgt_field be aware of format of targets (multiple phrases)
if opt.data_type == "keyphrase":
fields["tgt"].type = opt.tgt_type
model = build_base_model(model_opt, fields, use_gpu(opt), checkpoint,
opt.gpu)
if opt.fp32:
model.float()
model.eval()
model.generator.eval()
return fields, model, model_opt
def load_test_model(opt, model_path=None):
if model_path is None:
model_path = opt.models[0]
checkpoint = torch.load(model_path,
map_location=lambda storage, loc: storage)
model_opt = ArgumentParser.ckpt_model_opts(checkpoint['opt'])
ArgumentParser.update_model_opts(model_opt)
ArgumentParser.validate_model_opts(model_opt)
fields = checkpoint['vocab']
# Avoid functionality on inference
model_opt.update_vocab = False
model = build_base_model(model_opt, fields, use_gpu(opt), checkpoint,
opt.gpu)
if opt.fp32:
model.float()
elif opt.int8:
if opt.gpu >= 0:
raise ValueError(
"Dynamic 8-bit quantization is not supported on GPU")
torch.quantization.quantize_dynamic(model, inplace=True)
model.eval()
model.generator.eval()
return fields, model, model_opt
def build_model(model_opt, opt, fields, checkpoint):
logger.info('CONFIG:\n%s' %
json.dumps(vars(opt), indent=4, sort_keys=True))
logger.info('Building model...')
model = build_base_model(model_opt, fields, use_gpu(opt), checkpoint)
logger.info(model)
return model
def build_model(model_opt, opt, fields, checkpoint):
""" Build the Model """
print('Building model...')
model = build_base_model(model_opt, fields, use_gpu(opt), checkpoint)
print(model)
return model
def load_test_model(opt, dummy_opt, model_path=None):
if model_path is None:
model_path = opt.models[0]
checkpoint = torch.load(model_path,
map_location=lambda storage, loc: storage)
fields = inputters.load_fields_from_vocab(checkpoint['vocab'],
data_type=opt.data_type)
if opt.data_type == 'text':
if opt.use_port != "":
for (k, f) in fields.items():
if k == "src" or k == "tgt":
f.use_vocab = False
f.dtype = torch.float
f.sequential = False
f.include_lengths = False
model_opt = checkpoint['opt']
if model_opt.rnn_size != -1:
model_opt.enc_rnn_size = model_opt.rnn_size
model_opt.dec_rnn_size = model_opt.rnn_size
if model_opt.model_type == 'text' and \
model_opt.enc_rnn_size != model_opt.dec_rnn_size:
raise AssertionError("""We do not support different encoder and
decoder rnn sizes for translation now.""")
for arg in dummy_opt:
if arg not in model_opt:
model_opt.__dict__[arg] = dummy_opt[arg]
model = build_base_model(model_opt, fields, use_gpu(opt), checkpoint)
model.eval()
if model.generator is not None:
model.generator.eval()
return fields, model, model_opt
def build_model(model_opt, opt, fields, checkpoint):
logger.info('Building model...')
# original
# model = build_base_model(model_opt, fields, use_gpu(opt), checkpoint)
model = my_build_base_model(model_opt, fields, use_gpu(opt), checkpoint)
logger.info(model)
return model
def load_test_model(opt, dummy_opt, model_path=None):
if model_path is None:
model_path = opt.models[0]
checkpoint = torch.load(model_path,
map_location=lambda storage, loc: storage)
fields = inputters.load_fields_from_vocab(checkpoint['vocab'],
data_type=opt.data_type)
model_opt = checkpoint['opt']
for arg in dummy_opt:
if arg not in model_opt:
model_opt.__dict__[arg] = dummy_opt[arg]
model = build_base_model(model_opt, fields, use_gpu(opt), checkpoint)
# now build the generator
alpha_lookup = {'softmax': 1.0, 'tsallis15': 1.5, 'sparsemax': 2.0}
gen_alpha = alpha_lookup.get(model_opt.generator_function,
model_opt.loss_alpha)
assert opt.k == 0 or opt.bisect_iter == 0, \
"Bisection and topk are mutually exclusive ! !"
if gen_alpha == 1.0:
gen_func = nn.LogSoftmax(dim=-1)
elif gen_alpha == 2.0:
if opt.k > 0:
gen_func = onmt.modules.sparse_activations.LogSparsemaxTopK(
dim=-1, k=opt.k)
elif opt.bisect_iter > 0:
gen_func = onmt.modules.sparse_activations.LogSparsemaxBisect(
n_iter=opt.bisect_iter)
else:
gen_func = onmt.modules.sparse_activations.LogSparsemax(dim=-1)
elif gen_alpha == 1.5 and opt.bisect_iter == 0:
if opt.k > 0:
gen_func = onmt.modules.sparse_activations.LogTsallis15TopK(
dim=-1, k=opt.k)
else:
gen_func = onmt.modules.sparse_activations.LogTsallis15(dim=-1)
else:
# generic tsallis with bisection
assert opt.bisect_iter > 0, "Must use bisection with alpha != 1,1.5,2"
gen_func = onmt.modules.sparse_activations.LogTsallisBisect(
alpha=gen_alpha, n_iter=opt.bisect_iter)
# if model.generator is a Sequential, this unpacks the linear layer from
# inside it so it can be combined with the translation-time output
# function.
# In practice model.generator is always an nn.Sequential instance, but
# it should work if you just replace it with a linear layer.
gen_weights = model.generator[0] if \
isinstance(model.generator, nn.Sequential) else model.generator
generator = nn.Sequential(gen_weights, gen_func)
model.generator = generator
print(model.generator)
model.eval()
model.generator.eval()
return fields, model, model_opt
def build_model(model_opt, opt, fields, checkpoint):
logger.info('Building model...')
model = build_base_model(model_opt, fields, use_gpu(opt), checkpoint)
import IPython
IPython.embed()
exit(1)
logger.info(model)
return model
def build_model(model_opt, opt, fields, encoders, decoders, generators,
src_vocabs, tgt_vocabs, checkpoint):
logger.info('Building model...')
model = build_base_multitask_model(model_opt, fields, use_gpu(opt),
encoders, decoders, generators,
src_vocabs, tgt_vocabs, checkpoint)
logger.info(model)
return model
def build_model(model_opt, opt, fields, checkpoint):
""" Build the Model """
logger.info('Building model...')
model = build_base_model(model_opt, fields, use_gpu(opt), checkpoint)
logger.info(model)
#for name, param in model.named_parameters():
#print(name)
return model
def build_model(model_opt, opt, fields, checkpoint):
""" Build the Model """
logger.info('Building model...')
print("opt_d_model", opt.enc_rnn_size)
model = build_base_model(model_opt, fields,
use_gpu(opt), checkpoint)
logger.info(model)
return model
def build_model(model_opt, opt, fields, checkpoint, stn_model):
logger.info('Building model...')
model = build_base_model(model_opt,
fields,
use_gpu(opt),
checkpoint,
stn_model=stn_model)
logger.info(model)
return model
def build_model(model_opt, opt, fields, checkpoint, aux_fields=None):
logger.info('Building model...')
model = build_base_model(model_opt,
fields,
use_gpu(opt),
checkpoint,
aux_fields=aux_fields)
logger.info(model)
return model
def build_model(model_opt, opt, fields, checkpoint):
logger.info('Building model...')
model = build_base_model(model_opt, opt, fields, use_gpu(opt), checkpoint)
# drqa model
drqa_model = None
if opt.enable_rl_after >= 0:
vocab = torch.load(opt.drqa_vocab_path)
json_config = json.load(open(opt.drqa_config_path, 'r'))
args = SimpleNamespace(**json_config)
drqa_model = DrQA(vocab, args)
drqa_model.load(opt.drqa_param_path)
drqa_model.gpu = False
if use_gpu(opt):
drqa_model = drqa_model.cuda()
drqa_model.gpu = True
model.set_drqa_model(drqa_model)
# -----
logger.info(model)
return model
def build_model(model_opt, opt, fields, checkpoint):
logger.info('Building model...')
model = build_base_model(model_opt, fields, use_gpu(opt), checkpoint)
logger.info(model)
# trainable_params = 0
# for p in model.parameters():
# if p.requires_grad:
# trainable_params += np.prod(p.size())
# logger.info(f'trainable parameters in the model (does not include layer_projection): {trainable_params}')
return model
def build_model(model_opt, opt, fields, checkpoint):
""" Build the Model """
print('Building model...')
model = build_base_model(model_opt, fields, use_gpu(opt), checkpoint)
if len(opt.gpuid) > 1:
print('Multi gpu training: ', opt.gpuid)
model = nn.DataParallel(model, device_ids=opt.gpuid, dim=1)
print(model)
return model
def build_model(model_opt, opt, fields, checkpoint):
logger.info('Building model...')
model = build_base_model(model_opt, fields, use_gpu(opt), checkpoint)
# Show which params will be updated
nn.Linear.extra_repr = linear_repr_patch
nn.LayerNorm.extra_repr = ln_repr_patch
nn.Embedding.extra_repr = emb_repr_patch
logger.info(model)
return model
def load_test_model(opt, model_path=None):
if model_path is None:
model_path = opt.models[0]
checkpoint = torch.load(model_path,
map_location=lambda storage, loc: storage)
model_opt = ArgumentParser.ckpt_model_opts(checkpoint['opt'])
ArgumentParser.update_model_opts(model_opt)
ArgumentParser.validate_model_opts(model_opt)
vocab = checkpoint['vocab']
if inputters.old_style_vocab(vocab):
fields = inputters.load_old_vocab(
vocab, opt.data_type, dynamic_dict=model_opt.copy_attn
)
else:
fields = vocab
model = build_base_model(model_opt, fields, use_gpu(opt), checkpoint,
opt.gpu)
if opt.fp32:
model.float()
model.eval()
model.generator.eval()
return fields, model, model_opt
def build_model(model_opt, opt, fields, checkpoint):
logger.info('Building model...')
model = build_base_model(model_opt, fields, use_gpu(opt), checkpoint)
logger.info(model)
return model
