import math import os import torch import torch.nn as nn from accelerate import Accelerator from tqdm import tqdm from transformers import AutoTokenizer, LlamaForCausalLM, AutoModelForCausalLM from src.model.super_tokenizer import SuperTokenizer DTYPE_DICT = { "bf16": torch.bfloat16, "fp16": torch.float16, "fp32": torch.float32, } class LM(nn.Module): def __init__( self, model_name_or_path: str, super_tokenizer_name_or_path: str, cache_dir: str = None, super_tokenizer_num_hidden_layers: int = 6, use_flash_attention_2: bool = True, is_model_frozen: bool = True, dtype: str = "bf16", device_map=None, accelerator: Accelerator = None, ): super().__init__() # * set dtype if dtype not in DTYPE_DICT: raise ValueError(f"dtype must be one of {DTYPE_DICT.keys()}") dtype = DTYPE_DICT[dtype] # * load model and super_tokenizer self.model = LlamaForCausalLM.from_pretrained( model_name_or_path, cache_dir=cache_dir, local_files_only=True, torch_dtype=dtype, use_flash_attention_2=use_flash_attention_2, device_map=device_map, ) # self.model = AutoModelForCausalLM.from_pretrained( # model_name_or_path, # cache_dir=cache_dir, # local_files_only=True, # torch_dtype=dtype, # trust_remote_code=True, # device_map=device_map, # ) self.super_tokenizer = None if super_tokenizer_name_or_path != "no": self.super_tokenizer = SuperTokenizer.from_pretrained( super_tokenizer_name_or_path, cache_dir=cache_dir, local_files_only=True, torch_dtype=dtype, device_map=device_map, num_hidden_layers=super_tokenizer_num_hidden_layers, ) # * load tokenzier self.tokenizer = AutoTokenizer.from_pretrained( "meta-llama/Llama-2-7b-chat-hf", cache_dir=cache_dir, local_files_only=True, use_fast=False, ) self.tokenizer.pad_token = self.tokenizer.eos_token # * freeze model or not self.is_model_frozen = is_model_frozen if self.is_model_frozen: self.freeze_model() # * set accelerator self.accelerator = accelerator if device_map is None: if self.accelerator is not None: device = self.accelerator.device else: device = torch.device("cpu") self.model.to(device) if self.super_tokenizer is not None: self.super_tokenizer.to(device) def forward( self, input_ids=None, attention_mask=None, super_input_ids=None, super_attention_mask=None, placeholder_indices=None, super_token_indices=None, labels=None, ): inputs_embeds = self.prepare_model_inputs_embeds( input_ids, super_input_ids, super_attention_mask, placeholder_indices, super_token_indices, ) output = self.model( inputs_embeds=inputs_embeds, attention_mask=attention_mask, labels=labels, ) return output def prepare_model_inputs_embeds( self, input_ids=None, super_input_ids=None, super_attention_mask=None, placeholder_indices=None, super_token_indices=None, ): inputs_embeds = self.model.get_input_embeddings()(input_ids) if self.super_tokenizer is not None and len(super_token_indices) != 0: super_inputs_embeds = self.super_tokenizer( super_input_ids, super_attention_mask, super_token_indices, ) inputs_embeds = inputs_embeds.type_as(super_inputs_embeds) cur_idx = 0 for i, idx_lst in enumerate(placeholder_indices): if len(idx_lst) == 0: continue inputs_embeds[i][idx_lst] = super_inputs_embeds[cur_idx:cur_idx + len(idx_lst)] cur_idx += len(idx_lst) return inputs_embeds @torch.no_grad() def generate(self, dataloader, return_new_tokens_only=True, decode=True, **gen_kwargs): self.eval() all_generations = [] for _, inputs in enumerate(tqdm(dataloader, desc='Generate')): inputs = self._move_to_device(inputs) # * move to gpu input_ids = inputs["input_ids"] attention_mask = inputs["attention_mask"] super_input_ids = inputs["super_input_ids"] super_attention_mask = inputs["super_attention_mask"] placeholder_indices = inputs["placeholder_indices"] super_token_indices = inputs["super_token_indices"] inputs_embeds = self.prepare_model_inputs_embeds( input_ids=input_ids, super_input_ids=super_input_ids, super_attention_mask=super_attention_mask, placeholder_indices=placeholder_indices, super_token_indices=super_token_indices, ) # * generate outputs = self.model.generate( input_ids=input_ids, inputs_embeds=inputs_embeds, attention_mask=attention_mask, use_cache=True, **gen_kwargs, ) if return_new_tokens_only: start_idx = input_ids.shape[1] outputs = outputs[:, start_idx:] if self.accelerator is not None: outputs = outputs.contiguous() # must be contiguous # FIXME: dim cannot be -1 outputs = self.accelerator.pad_across_processes(outputs, pad_index=self.tokenizer.pad_token_id, dim=1) outputs = self.accelerator.gather_for_metrics(outputs) outputs = outputs.tolist() if decode: outputs = self.tokenizer.batch_decode(outputs, skip_special_tokens=True) all_generations.extend(outputs) return all_generations @torch.no_grad() def compute_perplexity(self, dataloader): self.eval() all_nlls = [] for inputs in tqdm(dataloader): inputs = self._move_to_device(inputs) outputs = self.forward(**inputs) nll = outputs.loss if self.accelerator is not None: nll = self.accelerator.gather_for_metrics(nll).mean() all_nlls.append(nll.tolist()) perplexity = math.exp(sum(all_nlls) / len(all_nlls)) return perplexity def freeze_model(self): self.is_model_frozen = True for _, param in self.model.named_parameters(): param.requires_grad = False def _move_to_device(self, inputs): for k, v in inputs.items(): if isinstance(v, torch.Tensor): inputs[k] = v.to(self.device) return inputs @property def device(self): if self.accelerator is not None: return self.accelerator.device else: return torch.device("cpu") def gradient_checkpointing_enable(self): self.model.gradient_checkpointing_enable() self.super_tokenizer.gradient_checkpointing_enable() def save(self, output_dir, deepspeed=False): if self.super_tokenizer is not None: self.super_tokenizer.save_pretrained(os.path.join(output_dir, "super_tokenizer")) self.tokenizer.save_pretrained(os.path.join(output_dir, "super_tokenizer")) if not self.is_model_frozen: self.model.save_pretrained( os.path.join(output_dir, "model") ) self.tokenizer.save_pretrained( os.path.join(output_dir, "model") )