ppo_multi_adapter.py

'''
this code required trl==0.11.0 and support multi-adapter LoRA training
'''

from codecs import BOM_BE
import re
import torch
import os
from trl import AutoModelForCausalLMWithValueHead, PPOTrainer, PPOConfig
from trl.core import LengthSampler
from transformers import AutoTokenizer, BitsAndBytesConfig, HfArgumentParser
from accelerate import Accelerator
from utils import (
    create_model_tokenizer,
    create_peft,
    is_main_process,
    ScriptArguments,
    DEFINE_EOS_TOKEN,
    DEFINE_PAD_TOKEN,
    format_prompt,
    resolve_system_prompt,
)
import time
from ma_ppo_config import MultiAdapterPPOConfig
from ma_ppo_trainer import MultiAdapterPPOTrainer
from data_adapter import load_prompt_dataset

os.environ["WANDB_PROJECT"] = "ma-rlhf"
os.environ["WANDB_RUN_NAME"] = "ppo"


# class MyPPOTrainer(PPOTrainer):
parser = HfArgumentParser(ScriptArguments)
train_args: ScriptArguments = parser.parse_args_into_dataclasses(return_remaining_strings=True)[0]

dataset_name = train_args.dataset_name
dataset_sub_name = train_args.dataset_sub_name
dataset_split = train_args.dataset_split
model_name = train_args.model_name
rm_model_name = train_args.reward_model_name
deepspeed_config_name = train_args.deepspeed_config_name
batch_size = train_args.batch_size
mini_batch_size = train_args.mini_batch_size
ppo_epochs = train_args.ppo_epochs
output_max_length = train_args.output_max_length
seq_length = train_args.seq_length
output_name = train_args.output_name
is_peft = train_args.use_QLora
is_use_flash_attention2 = train_args.use_flash_attention_2

gradient_accumulation_steps = train_args.gradient_accumulation_steps
default_system_prompt = resolve_system_prompt(train_args.system_prompt)

def create_model_tokenizer(name, rm_model_name, peft_config):
    # QLoRA
    bnb_config = BitsAndBytesConfig(
        load_in_4bit=True, bnb_4bit_quant_type="nf4", bnb_4bit_compute_dtype=torch.bfloat16,
        # bnb_4bit_use_double_quant=True,
    )

    device_map = {"": Accelerator().local_process_index}
    print('device map: ', device_map)

    model = AutoModelForCausalLMWithValueHead.from_pretrained(
        name,
        quantization_config=bnb_config,
        peft_config=peft_config,
        reward_adapter=rm_model_name,
        device_map=device_map,  # 70b use 'auto' would auto shard parameter
        use_flash_attention_2=is_use_flash_attention2,
        trust_remote_code=True,
        # low_cpu_mem_usage=True,
    )

    tokenizer = AutoTokenizer.from_pretrained(
        model_name,
        # use_fast=True,
        trust_remote_code=True,
    )
    tokenizer.add_special_tokens({'pad_token': DEFINE_PAD_TOKEN})
    model.pad_token_id = tokenizer.pad_token_id
    model.pad_token = tokenizer.pad_token
    model.pad_token_id = tokenizer.pad_token_id
    # model.config.pad_token_id = model.config.eos_token_id

    return model, tokenizer


def create_dataset(dataset_name, tokenizer):
    datasets = load_prompt_dataset(
        dataset_name,
        dataset_sub_name=dataset_sub_name,
        split=dataset_split,
        default_system_prompt=default_system_prompt,
    )
    datasets = datasets.map(
        lambda examples: {
            "query": [
                format_prompt(question, system_prompt=system_prompt)
                for system_prompt, question in zip(examples["system"], examples["prompt"])
            ],
            "input_ids": [
                tokenizer(
                    format_prompt(question, system_prompt=system_prompt),
                    return_tensors="pt",
                )["input_ids"][0]
                for system_prompt, question in zip(examples["system"], examples["prompt"])
            ],
        },
        batched=True,
        remove_columns=datasets.column_names,
    )

    datasets = datasets.filter(lambda x: len(x["input_ids"]) < seq_length, batched=False)
    datasets.set_format(type="torch")
    return datasets


def collator(examples):
    batch = {'query': [], 'input_ids': []}
    for example in examples:
        batch['query'].append(example['query'])
        batch['input_ids'].append(torch.tensor(example['input_ids'], dtype=torch.long))
    return batch

def train():
    peft_config = create_peft(is_peft)
    model, tokenizer = create_model_tokenizer(
        model_name, rm_model_name, peft_config
    )  # model is sequence classification

    dataset = create_dataset(dataset_name, tokenizer)
    print(dataset)

    # generation config
    generation_kwargs = {
        "min_length": -1,
        "max_new_tokens": output_max_length,
        "top_k": 0.0,
        "top_p": 1.0,
        "do_sample": True,
        "pad_token_id": tokenizer.pad_token_id,
        "eos_token_id": tokenizer.eos_token_id,
        "forced_eos_token_id": tokenizer.eos_token_id, # class ForcedEOSTokenLogitsProcessor(LogitsProcessor) from transformers
        # "forced_eos_token_id": True,
    }
    output_length_sampler = LengthSampler(128, output_max_length)

    config = MultiAdapterPPOConfig(
        log_with='wandb',
        learning_rate=1e-5,
        batch_size=batch_size,
        mini_batch_size=mini_batch_size,
        gradient_accumulation_steps=gradient_accumulation_steps,
        optimize_cuda_cache=True,
        early_stopping=True,
        target_kl=0.1,
        ppo_epochs=ppo_epochs,
        seed=0,
        init_kl_coef=0.2,
        adap_kl_ctrl=True,
        max_grad_norm=1.0,  # fix generate nan
    )

    trainer = MultiAdapterPPOTrainer(
        config,
        model,
        ref_model=None,  # share parameters
        tokenizer=tokenizer,
        dataset=dataset,
        data_collator=collator,
    )

    reward_baseline = 0.0
    save_freq = 50

    # for epoch, batch in enumerate(trainer.dataloader):
    for epoch, batch in enumerate(trainer.dataloader):
        start_time = time.time()

        if epoch >= config.total_ppo_epochs:
            break

        question_tensors = batch["input_ids"]
        response_tensors = trainer.generate(
            question_tensors,
            return_prompt=False,
            # length_sampler=output_length_sampler,
            **generation_kwargs,
        )
        batch["response"] = tokenizer.batch_decode(response_tensors, skip_special_tokens=True)

        texts = [q + r for q, r in zip(batch["query"], batch["response"])]
        rm_model = trainer.accelerator.unwrap_model(trainer.model)
        raw_rewards = []
        for text in texts:
            inputs = tokenizer(text, return_tensors='pt').to(trainer.accelerator.device)
            score = rm_model.compute_reward_score(**inputs)[0,-1,0] - reward_baseline
            raw_rewards.append(score)
        rewards = raw_rewards

        ## PPO Step
        stats = trainer.step(question_tensors, response_tensors, rewards)
        trainer.log_stats(stats, batch, rewards)

        if is_main_process():
            for text, reward in zip(texts, rewards):
                print('-----------------------------------')
                print(text)
                print(reward.item())
                print('-----------------------------------')
            print(f"step:{epoch}/all:{len(trainer.dataloader)},loss:{stats['ppo/loss/total']},mean_scores:{stats['ppo/mean_scores']}" )

        if save_freq and epoch and epoch % save_freq == 0:
            trainer.save_pretrained(f'{output_name}_{epoch}')
            print(f'{output_name}_{epoch}')
            # break
    trainer.save_pretrained(output_name)

if __name__ == "__main__":
    train()