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