src/llm_train.py

from arguments import Arguments
from teacher_llm import Teacher, TeacherOutput
from student import LLMModel, StudentOutput
from data_utils import LLMDataset, LLMDataCollator

from transformers import AutoTokenizer
from torch import nn
import torch.nn.functional as F
import torch
from torch.utils.data import DataLoader

from torch import optim
from torch.cuda.amp import autocast, GradScaler
from tqdm import tqdm
from transformers import get_scheduler
from evaluator import Evaluator


def load_tokenizer(model_type, path, kwargs):        
    tokenizer = AutoTokenizer.from_pretrained(path, trust_remote_code=True, **kwargs)
    if model_type in ["gpt2", "opt", "llama", "gptj", "llama2", "mistral", "tinyllama", "minicpm"]:
        tokenizer.pad_token_id = tokenizer.eos_token_id
        tokenizer.pad_token = tokenizer.eos_token
    elif model_type == "qwen":
        # tokenizer.pad_token_id = 151646
        tokenizer.eos_token_id = 151643
        tokenizer.pad_token_id = tokenizer.eos_token_id
        tokenizer.pad_token = tokenizer.eos_token
    else:
        print('tokenizer unknow')
    
    return tokenizer

def get_token_mapping(s_tokenizer, t_tokenizer, device):
    t_vocab = t_tokenizer.get_vocab()
    s_vocab = s_tokenizer.get_vocab()
    t_id_mapping = []
    s_id_mapping = []
    for s_token, s_token_id in s_vocab.items():
        if s_token in t_vocab:
            s_id_mapping.append(s_token_id)
            t_id_mapping.append(t_vocab[s_token])

    return torch.tensor(s_id_mapping, device=device), torch.tensor(t_id_mapping, device=device)


class Trainer:
    def __init__(self, student: LLMModel, model_type: str,
                 args: Arguments, teacher_model: Teacher = None,
                 hidden_loss_weights = [1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 8, 10]):
        super().__init__()

        self.student = student.train()
        self.teacher_model = teacher_model

        self.mse_loss = nn.MSELoss(reduction='mean')
        
        self.args = args
        self.args.p = max(args.p, 1e-5)

        self.alpha = args.hard_label_loss_weight
        self.temperature = args.temperature

        self.step = 0

        sum_hidden_loss_weights = sum(hidden_loss_weights)
        self.hidden_loss_weights = [w / sum_hidden_loss_weights for w in hidden_loss_weights]

        self.train_loader, self.val_loader, self.test_loader = self.get_data_loader(args, model_type)
        
        self.teacher_lm_head = nn.Linear(self.teacher_model.model.lm_head.in_features,
                                         self.teacher_model.model.lm_head.out_features,
                                         bias=(self.teacher_model.model.lm_head.bias is not None)
                                        ).to(device=self.student.device, 
                                             dtype=self.teacher_model.model.lm_head.weight.dtype)
        self.teacher_lm_head.load_state_dict(self.teacher_model.model.lm_head.state_dict())
        for p in self.teacher_lm_head.parameters():
            p.requires_grad = False

    def get_data_loader(self, args: Arguments, model_type: str):
        self.tokenizer = load_tokenizer(model_type, args.student_tokenizer, 
                                        args.load_student_tokenizer_kwargs)

        train_dataset = LLMDataset(args.train_data, self.tokenizer, args.syntactic_file, args.max_len // 2)

        train_collate = LLMDataCollator(self.tokenizer, model_type, do_train=True, max_len = args.max_len,
                                        pad_to_multiple_of = args.pad_to_multiple_of,
                                        return_tensors = 'pt', padding = True, 
                                        return_offsets_mapping = args.span_loss)

        train_loader = DataLoader(train_dataset, batch_size=args.batch_size,
                                  shuffle=True, collate_fn=train_collate)

        return train_loader, None, None


    def get_teacher_eval(self, inputs):
        outputs = self.teacher_model.decode(inputs)

        outputs.logits = outputs.logits.to(self.student.device, non_blocking=True)
  
        if outputs.hidden_states is not None:
            outputs.hidden_states = outputs.hidden_states.to(self.student.device, non_blocking=True)

        if outputs.span_states is not None:
            outputs.span_states = outputs.span_states.to(self.student.device, non_blocking=True)
            
        if outputs.span_weights is not None:
            outputs.span_weights=outputs.span_weights.to(self.student.device, non_blocking=True)

        return outputs

    def soft_label_distill_loss(self, student_logits, teacher_logits, mask, distill_temperature = 2.0):
        
        student_probs = F.log_softmax(student_logits / distill_temperature, dim=-1)
        teacher_probs = F.softmax(teacher_logits / distill_temperature, dim=-1)

        loss = F.kl_div(student_probs, teacher_probs, reduction='none').sum(dim=-1)
        loss = (loss * mask).sum() / mask.sum()

        return loss

    def fdd_loss(self, student_hidden_states, teacher_hidden_states, attention_mask):
        traj_loss, der_loss = 0, 0
        n_layer = teacher_hidden_states.size(0)

        pre_s_hidden_logs, pre_t_hidden_logs = None, None
        for i in range(n_layer):
            s_hidden = student_hidden_states[i]
            t_hidden = teacher_hidden_states[i]

            s_hidden_logits = self.student.model.lm_head(s_hidden)
            t_hidden_logits = self.teacher_lm_head(t_hidden)
            state_loss = self.soft_label_distill_loss(s_hidden_logits, t_hidden_logits, 
                                                      attention_mask, self.temperature)

            traj_loss += state_loss

            s_hidden_logs = F.log_softmax(s_hidden_logits, dim=-1)
            t_hidden_logs = F.log_softmax(t_hidden_logits, dim=-1)
            if i > 0:
                delta_hidden_student = s_hidden_logs - pre_s_hidden_logs
                delta_hidden_teacher = t_hidden_logs - pre_t_hidden_logs
                cos_sim = F.cosine_similarity(delta_hidden_student, 
                                              delta_hidden_teacher, 
                                              dim=-1, eps=1e-5)
                cos_sim_loss = 1 - cos_sim
                cos_sim_loss = (cos_sim_loss * attention_mask).sum() / attention_mask.sum()

                der_loss += cos_sim_loss

            pre_s_hidden_logs, pre_t_hidden_logs = s_hidden_logs, t_hidden_logs
            
        return traj_loss / n_layer, der_loss / (n_layer - 1)

    def span_fdd_loss(self, student_hidden_states, teacher_hidden_states, span_weights):
        traj_loss, der_loss = 0, 0
        n_layer = teacher_hidden_states.size(0)

        mask = span_weights[-1] != 0.0

        # pair_mask = mask.unsqueeze(1) & mask.unsqueeze(2)

        pre_s_hidden_logs, pre_t_hidden_logs = None, None
        count = 0
        for i in range(max(n_layer - 2, 0), n_layer):
            s_hidden = student_hidden_states[i]
            t_hidden = teacher_hidden_states[i]

            s_hidden_logits = self.student.model.lm_head(s_hidden)
            t_hidden_logits = self.teacher_lm_head(t_hidden)
            state_loss = self.soft_label_distill_loss(s_hidden_logits, t_hidden_logits, 
                                                      mask, self.temperature)

            s_hidden_logs = F.log_softmax(s_hidden_logits, dim=-1)
            t_hidden_logs = F.log_softmax(t_hidden_logits, dim=-1)

            # s_hidden = F.normalize(s_hidden, dim=-1, eps=1e-5)
            # t_hidden = F.normalize(t_hidden, dim=-1, eps=1e-5)
            # student_scores = torch.matmul(s_hidden, s_hidden.transpose(-1, -2))
            # teacher_scores = torch.matmul(t_hidden, t_hidden.transpose(-1, -2))
            # state_loss = F.mse_loss(student_scores, teacher_scores, reduction='none')
            # state_loss = (state_loss * pair_mask).sum() / pair_mask.sum()

            traj_loss += state_loss

            if i > max(n_layer - 2, 0):
                delta_hidden_student = s_hidden_logs - pre_s_hidden_logs
                delta_hidden_teacher = t_hidden_logs - pre_t_hidden_logs
                cos_sim = F.cosine_similarity(delta_hidden_student, 
                                              delta_hidden_teacher, 
                                              dim=-1, eps=1e-5)
                cos_sim_loss = 1 - cos_sim
                cos_sim_loss = (cos_sim_loss * mask).sum() / mask.sum()

                der_loss += cos_sim_loss

            pre_s_hidden_logs, pre_t_hidden_logs = s_hidden_logs, t_hidden_logs
            
            count += 1

        return traj_loss / count, der_loss / (count - 1)

    def knowledge_distillation_loss(self, student_outputs: StudentOutput,
                                    teacher_outputs: TeacherOutput=None, attention_mask=None):
        kd_loss = 0

        if teacher_outputs is not None:
            if teacher_outputs.hidden_states is not None:
                traj_loss, der_loss = self.fdd_loss(student_outputs.hidden_states, 
                                                    teacher_outputs.hidden_states, 
                                                    attention_mask)
                if self.args.span_loss:
                    span_traj_loss, span_der_loss = self.span_fdd_loss(student_outputs.span_states, 
                                                                    teacher_outputs.span_states, 
                                                                    teacher_outputs.span_weights.squeeze(-1))
                else:
                    span_traj_loss, span_der_loss = 0, 0

                kl_loss = self.soft_label_distill_loss(student_outputs.logits, teacher_outputs.logits, 
                                                       attention_mask, self.temperature)

                
                kd_loss = kl_loss + traj_loss + der_loss + span_traj_loss + span_der_loss
                # kd_loss = kl_loss + (traj_loss + der_loss + 50 * span_traj_loss) / 2

        return kd_loss, kl_loss
    
    def skewed_forward_kl(self, logits, teacher_logits, labels, lam=0.1):
        teacher_probs = F.softmax(teacher_logits, dim=-1, dtype=torch.float32)
        student_probs = F.softmax(logits, dim=-1, dtype=torch.float32)
        mixed_probs = lam * teacher_probs + (1-lam) * student_probs
        mixed_logprobs = torch.log(mixed_probs)

        mask = (labels != -100).int()
        inf_mask = torch.isinf(logits) | torch.isinf(teacher_logits)

        prod_probs = torch.masked_fill(teacher_probs * mixed_logprobs, inf_mask, 0)
        x = torch.sum(prod_probs, dim=-1).view(-1)
        distil_loss = -torch.sum(x * mask.view(-1), dim=0) / torch.sum(mask.view(-1), dim=0)
        return distil_loss

    def compute_loss(self, inputs, labels, teacher_outputs = None):
        student_outputs = self.student(inputs)
        attention_mask = inputs['attention_mask'].to(self.student.device, non_blocking=True)

        # kd_loss, kl_loss = self.knowledge_distillation_loss(student_outputs, teacher_outputs,
        #                                                     attention_mask)

        kd_loss = self.skewed_forward_kl(student_outputs.logits, teacher_outputs.logits, labels)
        kl_loss = kd_loss

        return kd_loss, kl_loss
    

def train(args: Arguments, trainer: Trainer, evaluator: Evaluator, grad_accum_steps=1):
    trainer.student.train()

    train_loader = trainer.train_loader

    optimizer = optim.AdamW(trainer.student.parameters(), lr=args.learning_rate)

    num_steps = len(train_loader) // grad_accum_steps + 1
    total_traning_steps = num_steps * args.num_train_epochs

    scaler = GradScaler()

    # scheduler = get_scheduler(
    #     name='cosine_with_min_lr',
    #     optimizer=optimizer,
    #     num_warmup_steps=int(total_traning_steps * args.warmup_ratio),
    #     num_training_steps=total_traning_steps,
    #     scheduler_specific_kwargs={'min_lr': 1e-07}
    # )

    scheduler = optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=total_traning_steps, eta_min=1e-7)

    best_result = 0

    # Training loop
    for epoch in range(args.num_train_epochs):
        print(('\n' + '%8s' + '%14s' + '%17s' * 2) % ('epoch', 'memory', 'loss', 'student_loss'))
        p_bar = tqdm(train_loader, total=len(train_loader))
        loss_total = 0
        student_loss_total = 0
        step = 0

        for batch in p_bar:
            inputs, labels = batch

            teacher_outputs = trainer.get_teacher_eval(inputs)

            labels = labels.to(trainer.student.device)
            with autocast():
                loss, student_loss = trainer.compute_loss(inputs, labels, teacher_outputs)

            scaler.scale(loss / grad_accum_steps).backward()

            if (step + 1) % grad_accum_steps == 0:
                scaler.unscale_(optimizer)
                torch.nn.utils.clip_grad_norm_(trainer.student.parameters(), max_norm=1.0)
                scaler.step(optimizer)
                scaler.update()
        
                scheduler.step()
                optimizer.zero_grad(set_to_none=True)

            loss_total += loss.item()
            student_loss_total += student_loss.item()
            step += 1

            memory = f'{torch.cuda.memory_reserved() / 1E9:.4g}G'  # (GB)
            # s = ('%8s' + '%14s' + '%17.5g' * 2) % (f'{epoch + 1}/{args.num_train_epochs}', memory,
            #                                         loss_total / step, student_loss_total / step)
            s = ('%8s' + '%14s' + '%17.5g' * 2) % (f'{epoch + 1}/{args.num_train_epochs}', memory,
                                                    loss_total / step, student_loss.item())
            
            p_bar.set_description(s)

            if torch.isnan(loss):
                break

        with torch.cuda.amp.autocast(dtype=torch.float16):
            evaluator.model = trainer.student.model
            dolly = evaluator.evaluate_benchmark_dataset(
                dataset_path=args.val_data,
                dataset_name='dolly', batch_size=args.val_batch_size,
                max_seq_length=128, max_new_tokens=256)
        
            # result = evaluator.evaluate_benchmark_dataset(
            #     dataset_path='./data/vicuna/valid.jsonl',
            #     dataset_name='vicuna', batch_size=16,
            #     max_seq_length=256, max_new_tokens=512)

            # result = evaluator.evaluate_benchmark_dataset(
            #     dataset_path='./data/self-inst/valid.jsonl',
            #     dataset_name='self-inst', batch_size=16,
            #     max_seq_length=256, max_new_tokens=512)
            
        if dolly > best_result:
            best_result = dolly
            trainer.student.save(args.output_dir)
            
        trainer.student.save(args.output_dir + f'-epoch{epoch}')