def test_generation_from_short_input_same_as_parlai_3B(self): FASTER_GEN_KWARGS = dict(num_beams=1, early_stopping=True, min_length=15, max_length=25) TOK_DECODE_KW = dict(skip_special_tokens=True, clean_up_tokenization_spaces=True) torch.cuda.empty_cache() model = BlenderbotForConditionalGeneration.from_pretrained( self.ckpt).half().to(torch_device) src_text = ["Sam"] model_inputs = self.tokenizer(src_text, return_tensors="pt").to(torch_device) generated_utterances = model.generate(**model_inputs, **FASTER_GEN_KWARGS) tgt_text = 'Sam is a great name. It means "sun" in Gaelic.' generated_txt = self.tokenizer.batch_decode(generated_utterances, **TOK_DECODE_KW) assert generated_txt[0].strip() == tgt_text src_text = "Social anxiety\nWow, I am never shy. Do you have anxiety?\nYes. I end up sweating and blushing and feel like i'm going to throw up.\nand why is that?" model_inputs = self.tokenizer([src_text], return_tensors="pt").to(torch_device) generated_ids = model.generate(**model_inputs, **FASTER_GEN_KWARGS)[0] reply = self.tokenizer.decode(generated_ids, **TOK_DECODE_KW) assert "I think it's because we are so worried about what people think of us." == reply.strip( ) del model
def test_generate_fp16(self): config, input_dict = self.model_tester.prepare_config_and_inputs() input_ids = input_dict["input_ids"] attention_mask = input_ids.ne(1).to(torch_device) model = BlenderbotForConditionalGeneration(config).eval().to(torch_device) if torch_device == "cuda": model.half() model.generate(input_ids, attention_mask=attention_mask) model.generate(num_beams=4, do_sample=True, early_stopping=False, num_return_sequences=3)
def test_embed_pos_shape(self): config, inputs_dict = self.model_tester.prepare_config_and_inputs_for_common( ) model = BlenderbotForConditionalGeneration(config) expected_shape = (config.max_position_embeddings + config.extra_pos_embeddings, config.d_model) assert model.model.encoder.embed_positions.weight.shape == expected_shape model.model.decoder.embed_positions.weight.shape == expected_shape
def convert_parlai_checkpoint(checkpoint_path, pytorch_dump_folder_path, config_json_path): """ Copy/paste/tweak model's weights to our BERT structure. """ model = torch.load(checkpoint_path, map_location="cpu") sd = model["model"] cfg = BlenderbotConfig.from_json_file(config_json_path) m = BlenderbotForConditionalGeneration(cfg) valid_keys = m.model.state_dict().keys() failures = [] mapping = {} for k, v in sd.items(): if k in IGNORE_KEYS: continue new_k = rename_state_dict_key(k) if new_k not in valid_keys: failures.append([k, new_k]) else: mapping[new_k] = v if cfg.normalize_before: # Blenderbot-3B checkpoints. Rename layernorm_embedding -> layer_norm rename_layernorm_keys(sd) m.model.load_state_dict(mapping, strict=True) m.half() m.save_pretrained(pytorch_dump_folder_path)
def __init__(self): # model_name = 'facebook/blenderbot_small-90M' model_name = 'facebook/blenderbot-400M-distill' # model_name = 'facebook/blenderbot-1B-distill' # model_name = 'facebook/blenderbot-3B' print("Creating model") self.model = BlenderbotForConditionalGeneration.from_pretrained(model_name) print("Creating tokenizer") self.tokenizer = BlenderbotTokenizer.from_pretrained(model_name) self.history = []
def test_initialization_module(self): config, inputs_dict = self.model_tester.prepare_config_and_inputs_for_common( ) model = BlenderbotForConditionalGeneration(config).model model.to(torch_device) model.eval() enc_embeds = model.encoder.embed_tokens.weight assert (enc_embeds == model.shared.weight).all().item() self.assertAlmostEqual( torch.std(enc_embeds).item(), config.init_std, 2)
def __init__(self, size, env, device, max_context_length): """ The Blender chatbot model was proposed in Recipes for building an open-domain chatbot Stephen Roller, Emily Dinan, Naman Goyal, Da Ju, Mary Williamson, Yinhan Liu, Jing Xu, Myle Ott, Kurt Shuster, Eric M. Smith, Y-Lan Boureau, Jason Weston on 30 Apr 2020. Args: size (str): model size env (BaseEnv): dialogue environment device (str): device (one of ['CPU', 'CUDA', 'CUDA:N'] max_context_length (int): max history context length (it means that length of input context tokens) """ assert size in ['small', 'medium', 'large', 'xlarge'], \ "model size must be one of ['small', 'medium', 'large', 'xlarge']" if size == "small": super().__init__("facebook/blenderbot_small-90M", env) self.model = BlenderbotSmallForConditionalGeneration.from_pretrained( self.name).to(device) self.tokenizer = BlenderbotSmallTokenizer.from_pretrained( self.name) else: if size == "medium": super().__init__("facebook/blenderbot-400M-distill", env) elif size == "large": super().__init__("facebook/blenderbot-1B-distill", env) elif size == "xlarge": super().__init__("facebook/blenderbot-3B", env) self.model = BlenderbotForConditionalGeneration.from_pretrained( self.name).to(device) self.tokenizer = BlenderbotTokenizer.from_pretrained(self.name) self.size = size self.device = device.lower() self.max_context_length = max_context_length self.eos = "</s> <s>" print('Done!')
from transformers import BlenderbotTokenizer, BlenderbotForConditionalGeneration mname = 'facebook/blenderbot-400M-distill' # mname = 'facebook/blenderbot-3B' # Too big to run on laptop model = BlenderbotForConditionalGeneration.from_pretrained(mname) tokenizer = BlenderbotTokenizer.from_pretrained(mname) UTTERANCE = "My friends are cool but they eat too many carbs." inputs = tokenizer([UTTERANCE], return_tensors='pt') reply_ids = model.generate(**inputs) print(tokenizer.batch_decode(reply_ids))
tokenizer = GPT2Tokenizer.from_pretrained("microsoft/DialoGPT-small") #------dialogpt medium------# model = GPT2LMHeadModel.from_pretrained("microsoft/DialoGPT-medium") tokenizer = GPT2Tokenizer.from_pretrained("microsoft/DialoGPT-medium") print("dialogpt is done!") elif download_type == 'gptneo': #------gptneo small------# model = AutoModelForCausalLM.from_pretrained("EleutherAI/gpt-neo-125M") tokenizer = AutoTokenizer.from_pretrained("EleutherAI/gpt-neo-125M") #------gptneo large------# #model = AutoModelForCausalLM.from_pretrained("EleutherAI/gpt-neo-1.3B") #tokenizer = AutoTokenizer.from_pretrained("EleutherAI/gpt-neo-1.3B") print("gptneo is done!") elif download_type == 'blender': #------blender small------# model = BlenderbotSmallForConditionalGeneration.from_pretrained( "facebook/blenderbot_small-90M") tokenizer = BlenderbotSmallTokenizer.from_pretrained( "facebook/blenderbot_small-90M") #------blender medium------# model = BlenderbotForConditionalGeneration.from_pretrained( "facebook/blenderbot-400M-distill") tokenizer = BlenderbotTokenizer.from_pretrained( "facebook/blenderbot-400M-distill") print("blender is done!")
def load_Blenderbot(Bbot_PATH): BbotModel = BlenderbotForConditionalGeneration.from_pretrained(Bbot_PATH) BbotTokenizer = BlenderbotTokenizer.from_pretrained(Bbot_PATH) return BbotModel, BbotTokenizer
def get_model(): mname = 'facebook/blenderbot-90M' model = BlenderbotForConditionalGeneration.from_pretrained(mname) tokenizer = BlenderbotSmallTokenizer.from_pretrained(mname) return model, tokenizer