File size: 5,830 Bytes
f8f0e4e | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 | import os
import deepspeed
from trl import RewardTrainer, RewardConfig
import torch
from accelerate import Accelerator
from utils import (
ScriptArguments,
DEFINE_PAD_TOKEN,
format_prompt_answer,
maybe_distributed_barrier,
resolve_system_prompt,
)
from transformers import (
AutoTokenizer,
BitsAndBytesConfig,
HfArgumentParser,
AutoModelForSequenceClassification,
)
from data_adapter import load_preference_dataset
os.environ["WANDB_PROJECT"] = "ma-rlhf"
os.environ["WANDB_RUN_NAME"] = "reward_model"
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
deepspeed_config_name = train_args.deepspeed_config_name
seq_length = train_args.seq_length
batch_size = train_args.batch_size
output_name = train_args.output_name
is_peft = train_args.use_QLora
is_use_flash_attention2 = train_args.use_flash_attention_2
num_train_epochs = train_args.num_train_epochs
gradient_accumulation_steps = train_args.gradient_accumulation_steps
learning_rate = train_args.learning_rate
default_system_prompt = resolve_system_prompt(train_args.system_prompt)
def create_model_tokenizer(name):
# 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 = AutoModelForSequenceClassification.from_pretrained(
model_name,
quantization_config=bnb_config,
device_map=device_map, # 70b use auto
num_labels=1,
use_cache=False,
trust_remote_code=True,
)
tokenizer = AutoTokenizer.from_pretrained(model_name, use_fast=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.config.pad_token_id = tokenizer.pad_token_id
model.config.pad_token = tokenizer.pad_token
return model, tokenizer
def create_reward_model_datasets(datasets_name, dataset_sub_name, tokenizer):
train_dataset = load_preference_dataset(
datasets_name,
dataset_sub_name=dataset_sub_name,
split=dataset_split,
default_system_prompt=default_system_prompt,
)
train_dataset = train_dataset.map(
lambda examples: tokenize_reward_batch(examples, tokenizer),
batched=True,
)
maybe_distributed_barrier()
train_dataset = train_dataset.filter(
lambda x: len(x["input_ids_chosen"]) <= seq_length
and len(x["input_ids_rejected"]) <= seq_length
)
maybe_distributed_barrier()
# eval_dataset = eval_dataset.map(
# preprocess_function_hhrlhf,
# batched=True,
# num_proc=8,
# )
# torch.distributed.barrier()
# eval_dataset = eval_dataset.filter(
# lambda x: len(x["input_ids_chosen"]) <= seq_length
# and len(x["input_ids_rejected"]) <= seq_length
# )
# torch.distributed.barrier()
# return train_dataset, eval_dataset
return train_dataset, None
def tokenize_reward_batch(examples, tokenizer):
new_examples = {
"input_ids_chosen": [],
"attention_mask_chosen": [],
"input_ids_rejected": [],
"attention_mask_rejected": [],
}
for system_prompt, prompt, response_chosen, response_rejected in zip(
examples["system"], examples["prompt"], examples["chosen"], examples["rejected"]
):
chosen_text = format_prompt_answer(prompt, response_chosen, system_prompt=system_prompt)
rejected_text = format_prompt_answer(prompt, response_rejected, system_prompt=system_prompt)
tokenized_chosen = tokenizer(chosen_text, truncation=True, padding="longest")
tokenized_rejected = tokenizer(rejected_text, truncation=True, padding="longest")
new_examples["input_ids_chosen"].append(tokenized_chosen["input_ids"])
new_examples["attention_mask_chosen"].append(tokenized_chosen["attention_mask"])
new_examples["input_ids_rejected"].append(tokenized_rejected["input_ids"])
new_examples["attention_mask_rejected"].append(tokenized_rejected["attention_mask"])
return new_examples
def train():
model, tokenizer = create_model_tokenizer(model_name) # model is sequence classification
train_datasets, test_datasets = create_reward_model_datasets(dataset_name, None, tokenizer)
# PEFT
peft_config = create_peft_reward_model(is_peft)
# ZERO stage3 use config like # https://github.com/huggingface/trl/issues/835
reward_config = RewardConfig(
output_dir=output_name,
per_device_train_batch_size=batch_size,
per_device_eval_batch_size=batch_size,
num_train_epochs=num_train_epochs,
gradient_accumulation_steps=gradient_accumulation_steps,
gradient_checkpointing=True,
learning_rate=learning_rate,
report_to="wandb",
warmup_ratio=0.01,
remove_unused_columns=True,
optim="adamw_torch",
logging_steps=1,
max_length=seq_length,
deepspeed=deepspeed_config_name,
bf16=True,
lr_scheduler_type='cosine',
# evaluation_strategy="steps",
# eval_steps=100,
# max_steps=10,
)
trainer = RewardTrainer(
model,
args=reward_config,
train_dataset=train_datasets,
processing_class=tokenizer,
peft_config=peft_config,
)
trainer.train()
trainer.save_model(output_name)
if __name__ == "__main__":
train()
|