File size: 4,390 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 | import os
from trl import DPOTrainer, DPOConfig
import torch
from accelerate import Accelerator
from utils import (
ScriptArguments,
DEFINE_PAD_TOKEN,
create_peft,
format_prompt,
resolve_system_prompt,
)
from transformers import (
AutoTokenizer,
BitsAndBytesConfig,
HfArgumentParser,
AutoModelForCausalLM,
)
from data_adapter import load_preference_dataset
os.environ["WANDB_PROJECT"] = "ma-rlhf"
os.environ["WANDB_RUN_NAME"] = "dpo"
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
output_max_length = train_args.output_max_length
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
beta = 0.1 # default
gradient_accumulation_steps = train_args.gradient_accumulation_steps
learning_rate = train_args.learning_rate
use_qlora_double_quant = train_args.use_qlora_double_quant
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=use_qlora_double_quant,
)
device_map = {"": Accelerator().local_process_index}
print('device map: ', device_map)
model = AutoModelForCausalLM.from_pretrained(
model_name,
quantization_config=bnb_config if is_peft else None,
device_map=device_map,
trust_remote_code=True,
use_flash_attention_2=is_use_flash_attention2,
)
tokenizer = AutoTokenizer.from_pretrained(model_name, use_fast=True, model_max_length=seq_length,
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
return model, tokenizer
def create_dpo_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 example: {
"prompt": format_prompt(example["prompt"], system_prompt=example["system"]),
"chosen": example["chosen"],
"rejected": example["rejected"],
},
remove_columns=["system"],
)
return train_dataset, None
def train():
model, tokenizer = create_model_tokenizer(model_name) # model is sequence classification
train_datasets, test_datasets = create_dpo_datasets(
dataset_name, None, tokenizer
)
# PEFT
peft_config = create_peft(is_peft)
training_args = DPOConfig(
output_dir=output_name,
save_strategy='epoch',
logging_steps=1,
num_train_epochs=num_train_epochs,
gradient_checkpointing=True,
bf16=True,
learning_rate=learning_rate,
warmup_ratio=0.05,
per_device_train_batch_size=batch_size,
per_device_eval_batch_size=batch_size,
gradient_accumulation_steps=gradient_accumulation_steps,
deepspeed=deepspeed_config_name,
report_to='wandb',
lr_scheduler_type='cosine',
# max_steps=100,
# loss_type: Literal[
# "sigmoid", "hinge", "ipo", "kto_pair", "bco_pair", "sppo_hard", "nca_pair", "robust"
# ] = "sigmoid"
loss_type='sigmoid', # standard dpo
dataset_num_proc=64,
max_completion_length=output_max_length,
max_prompt_length= output_max_length,
max_length=seq_length,
)
trainer = DPOTrainer(
model,
None,
args=training_args,
train_dataset=train_datasets,
peft_config=peft_config,
processing_class=tokenizer,
)
trainer.train()
trainer.save_model(output_name)
if __name__ == "__main__":
train()
|