Upload my_tdpo_trainer.py

my_tdpo_trainer.py

@@ -0,0 +1,309 @@
+
+
+from collections import defaultdict
+from contextlib import nullcontext
+from typing import Dict, Literal, Optional, Tuple, Union
+
+import torch
+from transformers import BatchEncoding, Trainer
+from trl import DPOTrainer
+from trl.trainer.utils import disable_dropout_in_model
+from transformers import PreTrainedModel
+from copy import deepcopy
+from accelerate import Accelerator
+from accelerate.state import AcceleratorState
+import deepspeed
+import torch.nn.functional as F
+IGNORE_INDEX = -100
+
+def get_eval_ds_config(deepspeed_states, offload=None, stage=3):
+    deepspeed_states = AcceleratorState().deepspeed_plugin
+
+    device = "cpu" if offload else "none"
+    zero_opt_dict = {
+        "stage": stage,
+        "stage3_param_persistence_threshold": 1e4,
+        "offload_param": {
+            "device": device
+        }
+    }
+    return {
+        "train_micro_batch_size_per_gpu": deepspeed_states.deepspeed_config['train_micro_batch_size_per_gpu'],
+        "steps_per_print": 10,
+        "zero_optimization": zero_opt_dict,
+        "bf16": {
+            "enabled": True
+        },
+        "gradient_clipping": 1.0,
+        "prescale_gradients": False,
+        "wall_clock_breakdown": False
+    }
+
+
+class CustomTDPOTrainer(DPOTrainer):
+    def __init__(
+        self,
+        beta: float,
+        alpha: float,
+        if_tdpo2: bool,
+        model: Union["PreTrainedModel", torch.nn.Module],
+        ref_model: Optional[Union["PreTrainedModel", torch.nn.Module]] = None,
+        disable_dropout: Optional[bool] = True,
+        **kwargs,
+    ):
+        if disable_dropout:
+            disable_dropout_in_model(model)
+            if ref_model is not None:
+                disable_dropout_in_model(ref_model)
+
+        self.use_dpo_data_collator = True  # hack to avoid warning
+        self.generate_during_eval = False  # disable at evaluation
+        self.label_pad_token_id = IGNORE_INDEX
+        self.padding_value = 0
+        self.is_encoder_decoder = model.config.is_encoder_decoder
+        self.precompute_ref_log_probs = False
+        self._precomputed_train_ref_log_probs = False
+        self._precomputed_eval_ref_log_probs = False
+        self._peft_has_been_casted_to_bf16 = False
+        self.reference_free = False
+
+        self.ref_model = ref_model
+        self.label_smoothing = 0
+        self._stored_metrics = defaultdict(lambda: defaultdict(list))
+        
+        self.beta = beta
+        self.alpha = alpha
+        self.if_tdpo2 = if_tdpo2
+
+        Trainer.__init__(self, model=model, **kwargs)
+        
+        if not hasattr(self, "accelerator"):
+            raise AttributeError("Please update `transformers`.")
+
+        print('====prepare ref_model====')
+        if ref_model is not None:
+            if self.is_deepspeed_enabled:
+                if not (
+                    getattr(ref_model, "is_loaded_in_8bit", False) or getattr(ref_model, "is_loaded_in_4bit", False)
+                ):  # quantized models are already set on the correct device
+                    self.ref_model = self.my_prepare_deepspeed(self.ref_model)
+            else:
+                self.ref_model = self.accelerator.prepare_model(self.ref_model, 
+                                                                evaluation_mode=True)
+            # self.ref_model = self.accelerator.prepare_model(self.ref_model, 
+            #                                                     evaluation_mode=True)
+        
+    def my_prepare_deepspeed(self, model):
+        deepspeed_states = self.accelerator.state.deepspeed_plugin
+        config_kwargs = deepspeed_states.deepspeed_config
+        if config_kwargs["zero_optimization"]["stage"] != 3:
+            stage = 0
+        else:
+            stage = 3
+        ds_config = get_eval_ds_config(deepspeed_states, offload=True, stage=stage)
+        model, *_ = deepspeed.initialize(model=model, config=config_kwargs)
+        model.eval()
+        return model
+    
+    def _prepare_deepspeed(self, model):
+        # config_kwargs = get_eval_ds_config(offload=True)
+        # model, *_ = deepspeed.initialize(model=model, config=config_kwargs)
+        # model.eval()
+        deepspeed_plugin = self.accelerator.state.deepspeed_plugin
+        config_kwargs = deepspeed_plugin.deepspeed_config
+        if model is not None:
+            if hasattr(model, "config"):
+                hidden_size = (
+                    max(model.config.hidden_sizes)
+                    if getattr(model.config, "hidden_sizes", None)
+                    else getattr(model.config, "hidden_size", None)
+                )
+                if hidden_size is not None and config_kwargs["zero_optimization"]["stage"] == 3:
+                    # Note that `stage3_prefetch_bucket_size` can produce DeepSpeed messages like: `Invalidate trace cache @ step 0: expected module 1, but got module 0`
+                    # This is expected and is not an error, see: https://github.com/microsoft/DeepSpeed/discussions/4081
+                    config_kwargs.update(
+                        {
+                            "zero_optimization.reduce_bucket_size": hidden_size * hidden_size,
+                            "zero_optimization.stage3_param_persistence_threshold": 10 * hidden_size,
+                            "zero_optimization.stage3_prefetch_bucket_size": 0.9 * hidden_size * hidden_size,
+                        }
+                    )
+
+        # If ZeRO-3 is used, we shard both the active and reference model.
+        # Otherwise, we assume the reference model fits in memory and is initialized on each device with ZeRO disabled (stage 0)
+        if config_kwargs["zero_optimization"]["stage"] != 3:
+            config_kwargs["zero_optimization"]["stage"] = 0
+        model, *_ = deepspeed.initialize(model=model, config=config_kwargs)
+        model.eval()
+        return model
+    
+    def concatenated_forward(
+        self, model: "PreTrainedModel", batch: Dict[str, torch.Tensor],
+        average_log_prob: bool = False
+    ) -> Tuple[torch.FloatTensor, torch.FloatTensor, torch.FloatTensor, torch.FloatTensor]:
+        batch_copied = BatchEncoding({k: v.detach().clone() for k, v in batch.items()})  # avoid error
+
+        all_logits = model(
+            input_ids=batch_copied["input_ids"], attention_mask=batch_copied["attention_mask"], return_dict=True
+        ).logits.to(torch.float32)
+
+        return all_logits
+    
+    def _tdpo_get_batch_logps(self, logits: torch.FloatTensor, 
+                              reference_logits: torch.FloatTensor, 
+                              labels: torch.LongTensor,
+                              average_log_prob: bool = False):
+        """Compute the kl divergence/log probabilities of the given labels under the given logits.
+
+        Args:
+            logits: Logits of the model (unnormalized). Shape: (batch_size, sequence_length, vocab_size)
+            reference_logits: Logits of the reference model (unnormalized). Shape: (batch_size, sequence_length, vocab_size)
+            labels: Labels for which to compute the log probabilities. Label tokens with a value of -100 are ignored. Shape: (batch_size, sequence_length)
+            average_log_prob: If True, return the average log probability per (non-masked) token. Otherwise, return the sum of the log probabilities of the (non-masked) tokens.
+
+        Returns:
+            Several tensors of shape (batch_size,) containing the average/sum kl divergence/log probabilities of the given labels under the given logits.
+        """
+        assert logits.shape[:-1] == labels.shape
+        assert reference_logits.shape[:-1] == labels.shape
+
+        labels = labels[:, 1:].clone()
+        logits = logits[:, :-1, :]
+        reference_logits = reference_logits[:, :-1, :]
+
+        loss_mask = (labels != -100)
+
+        # dummy token; we'll ignore the losses on these tokens later
+        labels[labels == -100] = 0
+
+        vocab_logps = logits.log_softmax(-1)
+
+        reference_vocab_ps = reference_logits.softmax(-1)
+        # reference_vocab_logps = reference_vocab_ps.log()
+        reference_vocab_logps = reference_logits.log_softmax(-1)
+
+        per_position_kl = (reference_vocab_ps * (reference_vocab_logps - vocab_logps)).sum(-1)
+        per_token_logps = torch.gather(vocab_logps, dim=2, index=labels.unsqueeze(2)).squeeze(2)
+        per_reference_token_logps = torch.gather(reference_vocab_logps, dim=2, index=labels.unsqueeze(2)).squeeze(2)
+
+        logps_margin = per_token_logps - per_reference_token_logps
+
+        if average_log_prob:
+            return (logps_margin * loss_mask).sum(-1) / loss_mask.sum(-1), \
+                   (per_position_kl * loss_mask).sum(-1) / loss_mask.sum(-1), \
+                   (per_token_logps * loss_mask).sum(-1) / loss_mask.sum(-1)
+        else:
+            return (logps_margin * loss_mask).sum(-1), \
+                (per_position_kl * loss_mask).sum(-1), \
+                (per_token_logps * loss_mask).sum(-1)
+        
+    def tdpo_loss(self, chosen_logps_margin: torch.FloatTensor,
+              rejected_logps_margin: torch.FloatTensor,
+              chosen_position_kl: torch.FloatTensor,
+              rejected_position_kl: torch.FloatTensor,
+              beta: float, alpha: float = 0.5, if_tdpo2: bool = True) -> Tuple[torch.FloatTensor, torch.FloatTensor, torch.FloatTensor]:
+        """Compute the TDPO loss for a batch of policy and reference model log probabilities.
+
+        Args:
+            chosen_logps_margin: The difference of log probabilities between the policy model and the reference model for the chosen responses. Shape: (batch_size,)
+            rejected_logps_margin: The difference of log probabilities between the policy model and the reference model for the rejected responses. Shape: (batch_size,)
+            chosen_position_kl: The difference of sequential kl divergence between the policy model and the reference model for the chosen responses. Shape: (batch_size,)
+            rejected_position_kl: The difference of sequential kl divergence between the policy model and the reference model for the rejected responses. Shape: (batch_size,)
+            beta: Temperature parameter for the TDPO loss, typically something in the range of 0.1 to 0.5. We ignore the reference model as beta -> 0.
+            alpha: Temperature parameter for the TDPO loss, used to adjust the impact of sequential kl divergence.
+            if_tdpo2: Determine whether to use method TDPO2, default is True; if False, then use method TDPO1.
+
+        Returns:
+            A tuple of two tensors: (losses, rewards).
+            The losses tensor contains the TDPO loss for each example in the batch.
+            The rewards tensors contain the rewards for response pair.
+        """
+
+        chosen_values = chosen_logps_margin + chosen_position_kl
+        rejected_values = rejected_logps_margin + rejected_position_kl
+
+        chosen_rejected_logps_margin = chosen_logps_margin - rejected_logps_margin
+
+        if not if_tdpo2:
+            logits = chosen_rejected_logps_margin - (rejected_position_kl - chosen_position_kl)    # tdpo1
+        else:
+            logits = chosen_rejected_logps_margin - alpha * (rejected_position_kl - chosen_position_kl.detach())  # tdpo2
+        losses = -F.logsigmoid(beta * logits)
+
+        chosen_rewards = beta * chosen_values.detach()
+        rejected_rewards = beta * rejected_values.detach()
+
+        return losses, chosen_rewards, rejected_rewards
+    
+    
+    def get_batch_loss_metrics(
+        self,
+        model: "PreTrainedModel",
+        batch: Dict[str, torch.Tensor],
+        train_eval: Optional[Literal["train", "eval"]] = "train",
+    ) -> Tuple[torch.Tensor, Dict[str, torch.Tensor]]:
+        r"""
+        Computes the DPO loss and other metrics for the given batch of inputs for train or test.
+        """
+        metrics = {}
+        (
+            chosen_logits
+        ) = self.concatenated_forward(model, batch)
+        with torch.no_grad():
+            if self.ref_model is None:
+                ref_model = self.model
+                ref_context = self.accelerator.unwrap_model(self.model).disable_adapter()
+            else:
+                ref_model = self.ref_model
+                ref_context = nullcontext()
+
+            with ref_context:
+                (
+                    reference_logits
+                ) = self.concatenated_forward(ref_model, batch)
+        
+        [all_logps_margin, 
+         all_position_kl, 
+         all_logps] = self._tdpo_get_batch_logps(chosen_logits, 
+                              reference_logits, 
+                              batch['labels'],
+                              average_log_prob=False)
+        
+        batch_size = batch["input_ids"].size(0) // 2
+        
+        chosen_logps_margin = all_logps_margin[:batch_size]
+        rejected_logps_margin = all_logps_margin[batch_size:]
+        chosen_position_kl = all_position_kl[:batch_size]
+        rejected_position_kl = all_position_kl[batch_size:]
+
+        chosen_logps = all_logps[:batch_size].detach()
+        rejected_logps = all_logps[batch_size:].detach()
+
+        losses, chosen_rewards, rejected_rewards = self.tdpo_loss(
+            chosen_logps_margin, rejected_logps_margin,
+            chosen_position_kl, rejected_position_kl,
+            self.beta, self.alpha, self.if_tdpo2
+        )
+        
+        reward_accuracies = (chosen_rewards > rejected_rewards).float()
+        chosen_rewards_accuracies = (chosen_logps_margin > torch.zeros_like(chosen_logps_margin)).float()
+
+        prefix = "eval_" if train_eval == "eval" else ""
+        metrics[f"{prefix}rewards/chosen"] = chosen_rewards.cpu().mean()
+        metrics[f"{prefix}rewards/rejected"] = rejected_rewards.cpu().mean()
+        metrics[f"{prefix}rewards/accuracies"] = reward_accuracies.cpu().mean()
+        metrics[f"{prefix}rewards/margins"] = (chosen_rewards - rejected_rewards).cpu().mean()
+        metrics[f"{prefix}logps/rejected"] = rejected_logps.detach().cpu().mean()
+        metrics[f"{prefix}logps/chosen"] = chosen_logps.detach().cpu().mean()
+        metrics[f"{prefix}logits/logp_chosen>logp_ref_chosen"] = chosen_rewards_accuracies.detach().cpu().mean()
+
+        all_device_chosen_position_kl = chosen_position_kl.detach()
+        all_device_rejected_position_kl = rejected_position_kl.detach()
+
+        metrics[f'{prefix}kl/chosen'] = all_device_chosen_position_kl.cpu().numpy().tolist()
+        metrics[f'{prefix}kl/rejected'] = all_device_rejected_position_kl.cpu().numpy().tolist()
+        metrics[f'{prefix}kl/margin'] = (all_device_chosen_position_kl - all_device_rejected_position_kl).cpu().numpy().tolist()
+
+        return losses.mean(), metrics
+        
+