code/alignment-handbook/scripts/run_orpo.py

#!/usr/bin/env python
# coding=utf-8
# Copyright 2023 The HuggingFace Inc. team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import logging
import sys
from typing import Dict, List, Optional, Tuple, Union

import torch
import transformers
from transformers import AutoModelForCausalLM, set_seed
from peft import PeftModel, get_peft_model, prepare_model_for_kbit_training
from accelerate import Accelerator
from alignment import (
    DataArguments,
    H4ArgumentParser,
    ModelArguments,
    apply_chat_template,
    get_datasets,
    get_kbit_device_map,
    get_peft_config,
    get_quantization_config,
    get_tokenizer,
    is_adapter_model,
)
import torch.nn as nn
from trl import ORPOConfig, ORPOTrainer
from peft import PeftConfig, PeftModel
from trl import DPOTrainer, create_reference_model
import random
from trl import DataCollatorForCompletionOnlyLM
import torch.nn.functional as F

logger = logging.getLogger(__name__)


class ORPOTrainerForCompletionOnly(ORPOTrainer):
    def get_batch_samples(self, epoch_iterator, num_batches, device=None):
        """Restore transformers Trainer batch-iteration semantics.

        TRL 0.8.6 reuses the name 'get_batch_samples' for online completion generation,
        which collides with the method transformers 4.48+ uses for gradient-accumulated
        batch iteration in _inner_training_loop.  We bypass TRL's override and delegate
        to the base Trainer so the training loop works correctly.
        """
        from transformers import Trainer as _HFTrainer
        return _HFTrainer.get_batch_samples(self, epoch_iterator, num_batches, device)

    # def odds_ratio_loss(
    #     self,
    #     policy_chosen_logps: torch.FloatTensor,
    #     policy_rejected_logps: torch.FloatTensor,
    #     temperature: float = 0.1  # <-- Add temperature scaling parameter
    # ) -> Tuple[torch.FloatTensor, torch.FloatTensor, torch.FloatTensor, torch.FloatTensor, torch.FloatTensor]:
    #     """Compute ORPO's odds ratio (OR) loss with temperature scaling."""

    #     # Apply temperature scaling to log probabilities
    #     policy_chosen_logps = policy_chosen_logps / temperature  # <-- Scale log probabilities
    #     policy_rejected_logps = policy_rejected_logps / temperature  # <-- Scale log probabilities

    #     # Compute log odds ratio
    #     log_odds = (policy_chosen_logps - policy_rejected_logps) - (
    #         torch.log1p(-torch.exp(policy_chosen_logps)) - torch.log1p(-torch.exp(policy_rejected_logps))
    #     )

    #     sig_ratio = F.sigmoid(log_odds)
    #     ratio = torch.log(sig_ratio)
    #     losses = self.beta * ratio

    #     chosen_rewards = self.beta * (policy_chosen_logps.to(self.accelerator.device)).detach()
    #     rejected_rewards = self.beta * (policy_rejected_logps.to(self.accelerator.device)).detach()

    #     return losses, chosen_rewards, rejected_rewards, torch.mean(ratio).item(), torch.mean(log_odds).item()


    def concatenated_forward(
        self, model: nn.Module, batch: Dict[str, Union[List, torch.LongTensor]]
    ) -> Tuple[torch.FloatTensor, torch.FloatTensor, torch.FloatTensor, torch.FloatTensor]:
        """Run the given model on the given batch of inputs, concatenating the chosen and rejected inputs together.

        We do this to avoid doing two forward passes, because it's faster for FSDP.
        """
        concatenated_batch = self.concatenated_inputs(
            batch,
            is_encoder_decoder=self.is_encoder_decoder,
            label_pad_token_id=self.label_pad_token_id,
            padding_value=self.padding_value,
            device=self.accelerator.device,
        )
        len_chosen = batch["chosen_labels"].shape[0]

        model_kwargs = (
            {
                "decoder_input_ids": self._shift_right(concatenated_batch["concatenated_labels"]),
            }
            if self.is_encoder_decoder
            else {}
        )

        outputs = model(
            concatenated_batch["concatenated_input_ids"],
            attention_mask=concatenated_batch["concatenated_attention_mask"],
            use_cache=False,
            **model_kwargs,
        )
        all_logits = outputs.logits

        def cross_entropy_loss(logits, labels):
            if not self.is_encoder_decoder:
                # Shift so that tokens < n predict n
                logits = logits[..., :-1, :].contiguous()
                labels = labels[..., 1:].contiguous()
            # Flatten the tokens
            loss_fct = nn.CrossEntropyLoss()
            logits = logits.view(-1, logits.shape[-1])
            labels = labels.view(-1)
            # Enable model parallelism
            labels = labels.to(logits.device)
            loss = loss_fct(logits, labels)
            return loss

        if self.is_encoder_decoder:
            labels = concatenated_batch["concatenated_labels"].clone()
        else:
            labels = concatenated_batch["concatenated_input_ids"].clone()

        # import pdb; pdb.set_trace()
        # chosen_nll_loss = cross_entropy_loss(all_logits[:len_chosen], labels[:len_chosen])

        """
        I FIXED HERE
        """
        chosen_nll_loss = cross_entropy_loss(all_logits[:len_chosen], concatenated_batch['concatenated_labels'][:len_chosen])

        all_logps = self.get_batch_logps(
            all_logits,
            concatenated_batch["concatenated_labels"],
            average_log_prob=True,
            is_encoder_decoder=self.is_encoder_decoder,
            label_pad_token_id=self.label_pad_token_id,
        )

        chosen_logps = all_logps[:len_chosen]
        rejected_logps = all_logps[len_chosen:]

        chosen_logits = all_logits[:len_chosen]
        rejected_logits = all_logits[len_chosen:]

        return (chosen_logps, rejected_logps, chosen_logits, rejected_logits, chosen_nll_loss)


def main():
    parser = H4ArgumentParser((ModelArguments, DataArguments, ORPOConfig))
    model_args, data_args, training_args = parser.parse()

    #######
    # Setup
    #######
    logging.basicConfig(
        format="%(asctime)s - %(levelname)s - %(name)s - %(message)s",
        datefmt="%Y-%m-%d %H:%M:%S",
        handlers=[logging.StreamHandler(sys.stdout)],
    )
    log_level = training_args.get_process_log_level()
    logger.setLevel(log_level)
    transformers.utils.logging.set_verbosity(log_level)
    transformers.utils.logging.enable_default_handler()
    transformers.utils.logging.enable_explicit_format()

    # Log on each process the small summary:
    logger.info(f"Model parameters {model_args}")
    logger.info(f"Data parameters {data_args}")
    logger.info(f"Training/evaluation parameters {training_args}")

    # Set seed for reproducibility
    set_seed(training_args.seed)

    # Increase distributed timeout to 3h to enable push to Hub to complete
    accelerator = Accelerator()

    ###############
    # Load datasets
    ###############
    raw_datasets = get_datasets(data_args, splits=data_args.dataset_splits)
    logger.info(
        f"Training on the following splits: {[split + ' : ' + str(dset.num_rows) for split, dset in raw_datasets.items()]}"
    )
    column_names = list(raw_datasets["train"].features)

    #####################################
    # Load tokenizer and process datasets
    #####################################
    data_args.truncation_side = "left"  # Truncate from left to ensure we don't lose labels in final turn
    tokenizer = get_tokenizer(model_args, data_args)

    # Qwen tokenizer has bos_token=None, but TRL DPOTrainer.tokenize_row() unconditionally
    # prepends `[tokenizer.bos_token_id]` to prompt_input_ids. Using eos_token as stand-in
    # corrupts the model (it sees EOS at prompt start). Use `<|im_start|>` (id 151644) which
    # is the natural prompt prefix in the Qwen chat template.
    if tokenizer.bos_token_id is None:
        _im_start = tokenizer.convert_tokens_to_ids("<|im_start|>")
        if _im_start is not None and _im_start >= 0:
            tokenizer.bos_token = "<|im_start|>"
            tokenizer.bos_token_id = _im_start
        else:
            tokenizer.bos_token = tokenizer.eos_token
            tokenizer.bos_token_id = tokenizer.eos_token_id

    #####################
    # Apply chat template
    #####################
    raw_datasets = raw_datasets.map(
        apply_chat_template,
        fn_kwargs={"tokenizer": tokenizer, "task": "dpo"},
        num_proc=data_args.preprocessing_num_workers,
        remove_columns=column_names,
        desc="Formatting comparisons with prompt template",
    )

    # Replace column names with what TRL needs, text_chosen -> chosen and text_rejected -> rejected
    for split in ["train", "test"]:
        raw_datasets[split] = raw_datasets[split].rename_columns(
            {"text_prompt": "prompt", "text_chosen": "chosen", "text_rejected": "rejected"}
        )

        # Replace '<|start_header_id|>user<|end_header_id|>\n' with ''
        # raw_datasets[split] = raw_datasets[split].map(
        #     lambda examples: {
        #         key: examples[key].replace('<|start_header_id|>user<|end_header_id|>\n', '').replace('<|start_header_id|>assistant<|end_header_id|>', '')
        #         if key in ["prompt", "chosen", "rejected"] else examples[key]
        #         for key in examples
        #     }
        # )

        # # Replace '<|start_header_id|>assistant<|end_header_id|>\n' with ''
        # raw_datasets[split] = raw_datasets[split].map(
        #     lambda examples: {
        #         key: examples[key].replace('<|start_header_id|>assistant<|end_header_id|>\n', '').replace('<|end|>', '<|eot_id|>')
        #         if key in ["prompt", "chosen", "rejected"] else examples[key]
        #         for key in examples
        #     }
        # )

        # # Replace '<|eot_id|>\n' in prompt with ''
        # raw_datasets[split] = raw_datasets[split].map(
        #     lambda examples: {
        #         "prompt": examples["prompt"].replace('<|eot_id|>\n', '<|reserved_special_token_247|>').replace('<|end|>', '<|eot_id|>'),
        #         **{key: value for key, value in examples.items() if key != "prompt"}
        #     }
        # )
        # raw_datasets[split] = raw_datasets[split].map(
        #     lambda examples: {
        #         "chosen": examples["chosen"].strip(),
        #         **{key: value for key, value in examples.items() if key != "chosen"}
        #     }
        # )
        # raw_datasets[split] = raw_datasets[split].map(
        #     lambda examples: {
        #         "rejected": examples["rejected"].strip(),
        #         **{key: value for key, value in examples.items() if key != "rejected"}
        #     }
        # )


        # Optionally, you can add any additional processing here
        print(f"Processed {split} dataset with {len(raw_datasets[split])} entries.")



    for index in random.sample(range(len(raw_datasets["train"])), 3):
        # logger.info(f"Prompt sample {index} of the raw training set:\n\n{raw_datasets['train'][index]['prompt'] + raw_datasets['train'][index]['chosen']}")
        logger.info(f"Chosen sample {index} of the raw training set:\n\n{raw_datasets['train'][index]['prompt'] + raw_datasets['train'][index]['chosen']}")
        logger.info(f"Rejected sample {index} of the raw training set:\n\n{ raw_datasets['train'][index]['prompt'] +raw_datasets['train'][index]['rejected']}")


    torch_dtype = (
        model_args.torch_dtype if model_args.torch_dtype in ["auto", None] else getattr(torch, model_args.torch_dtype)
    )
    quantization_config = get_quantization_config(model_args)

    model_kwargs = dict(
        revision=model_args.model_revision,
        trust_remote_code=model_args.trust_remote_code,
        attn_implementation="flash_attention_2" if model_args.use_flash_attention_2 else "eager",
        torch_dtype=torch_dtype,
        use_cache=False if training_args.gradient_checkpointing else True,
        device_map=get_kbit_device_map() if quantization_config is not None else None,
        quantization_config=quantization_config,
    )

    # model = model_args.model_name_or_path
    model = AutoModelForCausalLM.from_pretrained(
        model_args.model_name_or_path,
        revision=model_args.model_revision,
        trust_remote_code=model_args.trust_remote_code,
        attn_implementation="flash_attention_2" if model_args.use_flash_attention_2 else "eager",
        torch_dtype=torch_dtype,
        use_cache=False if training_args.gradient_checkpointing else True,
        device_map=get_kbit_device_map() if quantization_config is not None else None,
        quantization_config=quantization_config,
        )
    
    if tokenizer.pad_token == tokenizer.eos_token:
        print('add Pad token')
        tokenizer.add_special_tokens({'pad_token': '[PAD]'})
        model.pad_token = tokenizer.pad_token
        model.resize_token_embeddings(len(tokenizer))
    else:
        # Skip resize when pad and eos differ (already correct vocab); resizing here drops
        # the reserved-token rows of pretrained Qwen embeddings and produces NaN gradients
        # on first ORPO step.
        print(f"Skipping resize_token_embeddings (model vocab={model.config.vocab_size}, tokenizer={len(tokenizer)})")

    # if model_args.response_template is not None:
    collator = DataCollatorForCompletionOnlyLM(
        response_template=model_args.response_template,
        tokenizer=tokenizer, 
        mlm=False)

    ########################
    # Instantiate ORPO trainer
    #########################

    dpo_trainer = ORPOTrainerForCompletionOnly(
        model,
        # data_collator=collator,
        args=training_args,
        train_dataset=raw_datasets["train"],
        eval_dataset=raw_datasets["test"],
        tokenizer=tokenizer,
        peft_config=get_peft_config(model_args)
    )

    ###############
    # Training loop
    ###############
    # Resume only if a checkpoint actually exists
    import os as _os
    _resume = False
    if _os.path.isdir(training_args.output_dir):
        _resume = any(d.startswith("checkpoint-") for d in _os.listdir(training_args.output_dir))
    train_result = dpo_trainer.train(resume_from_checkpoint=_resume)
    metrics = train_result.metrics
    max_train_samples = (
        data_args.max_train_samples if data_args.max_train_samples is not None else len(raw_datasets["train"])
    )
    metrics["train_samples"] = min(max_train_samples, len(raw_datasets["train"]))
    dpo_trainer.log_metrics("train", metrics)
    dpo_trainer.save_metrics("train", metrics)
    dpo_trainer.save_state()

    logger.info("*** Training complete ***")

    ##########
    # Evaluate
    ##########
    if training_args.do_eval:
        logger.info("*** Evaluate ***")
        metrics = dpo_trainer.evaluate()
        max_eval_samples = (
            data_args.max_eval_samples if data_args.max_eval_samples is not None else len(raw_datasets["test"])
        )
        metrics["eval_samples"] = min(max_eval_samples, len(raw_datasets["test"]))
        dpo_trainer.log_metrics("eval", metrics)
        dpo_trainer.save_metrics("eval", metrics)

    ##################################
    # Save model and create model card
    ##################################
    dpo_trainer.save_model(training_args.output_dir)
    # Save everything else on main process
    if accelerator.is_main_process:
        # TRL 0.13 create_model_card doesn't accept finetuned_from/dataset/dataset_tags;
        # pass only kwargs that exist in its signature to avoid TypeError.
        import inspect as _inspect
        _card_params = set(_inspect.signature(dpo_trainer.create_model_card).parameters)
        _all_kwargs = {
            "finetuned_from": model_args.model_name_or_path,
            "dataset_name": list(data_args.dataset_mixer.keys())[0] if data_args.dataset_mixer else None,
            "tags": ["alignment-handbook"],
        }
        dpo_trainer.create_model_card(**{k: v for k, v in _all_kwargs.items() if k in _card_params})
        # Restore k,v cache for fast inference
        dpo_trainer.model.config.use_cache = True
        dpo_trainer.model.config.save_pretrained(training_args.output_dir)
        if training_args.push_to_hub is True:
            dpo_trainer.push_to_hub()

    # Ensure we don't timeout on model save / push to Hub
    logger.info("*** Waiting for all processes to finish ***")
    accelerator.wait_for_everyone()

    logger.info("*** Run complete! ***")


if __name__ == "__main__":
    main()