Wombat 🐻‍❄️: from RLHF to RRHF, Aligning Human Preferences in a 'Right' Way

Arxiv

License Notices: The dataset is CC BY NC 4.0 (allowing only non-commercial use) and models trained using the dataset should not be used outside of research purposes.

Update:

• 2023/4/13 We have released the weights of Wombat - LLaMA on Hugging Face. One can recover Wombat weights based on it.
• 2023/4/15 We add comparison with Alpaca-7B and ChatGPT based on Vicuna test set.
• 2023/5/23 We update our paper for more discussions and experiments.
• 2023/9/22 Paper accepted by NIPS 2023!

Overview

This is the repository for RRHF (Rank Response to align Human Feedback) and open-sourced language models Wombat. RRHF helps align large language models with human perference easier.

Reinforcement Learning from Human Feedback (RLHF) enables the alignment of large language models with human preference, improving the quality of interactions between humans and language models. Recent practice of RLHF uses PPO to enable the large language model optimization of such alignment. However, implementing PPO is non-trivial (where the training procedure requires interactive between policy, behavior policy, reward, value model) and it is also tedious to tuning many hyper-parameters. Our motivation is to simplify the alignment between language models with human preference, and our proposed paradigm RRHF (Rank Response from Human Feedback) can achieve such alignment as easily as conventional fine-tuning. It is simpler than PPO from the aspects of coding, model counts, and hyperparameters.

In our preliminary experiments, we compare RRHF and PPO using 7B LLaMA [1] and Alpaca [2] models on Anthropic’s Helpful and Harmless (HH) [3] dataset. We evaluate the results by perplexity (PPL) and reward model scores (Reward). With a much simpler training paradigm, we found that RRHF perform comparable result with PPO in terms of generation fluency (PPL) and alignements (Reward).

For details, please refer to our paper on Arxiv. RRHF is still working in progress, and there are still limitations in this preliminary study. Due to the large cost of human evaluation, we experiment on the HH datasets and use a trained reward model Dahoas/gptj-rm-static trained by Dahoas. The reward model plays a role of a synthetic human feedback and the experiments is a proof-of-concept for RRHF. We are open to any suggestions and discussions and feel free to contact us through [email protected], [email protected] or [email protected].

Setting Up Environment

To set up, you can use the following command lines to set up python3.8 and pytorch requirements:

conda create -n rrhf python=3.8
pip install torch==1.13.0+cu116 torchvision==0.14.0+cu116 torchaudio==0.13.0 --extra-index-url https://download.pytorch.org/whl/cu116

Then install Hugging Face's transformers from the github repo for LLaMA models.

git clone https://github.com/huggingface/transformers.git
pip install -e ./transformers

Install other packages:

pip install -r requirements.txt

Train Alpaca with RRHF on Helpful and Harmless dataset

We use Helpful and Harmless dataset to compare PPO and RRHF. We use trained reward function from Dahoas/gptj-rm-static.

Data Generation

RRHF firstly samples responses for each query in the training data from the initial models, and then scores each response (including the 'chosen' and 'rejected' response in original HH labels) using the reward models.

The scripts for data generation are in ./data_generation, you can use throught the command line:

cd ./data_generation/
bash response_gen.sh <path_to_alpaca/hf_llama_directory> <path_to_data_directory>

We also release our generated data for the ease of RRHF training implementation through this link. After download, place it to <path_to_data_directory>.

Training with RRHF

You can train your own model with generated or released datasets using the script train.sh, please note that the training process requires 8*A100 80GB GPUs, bf16 and FSDP. In the future, we will try efficient training methods such as LoRA or Prefix-tuning or Adapter to lower the computational resource requirements.

bash ./train.sh <path_to_alpaca_directory> <save_path_directory> <path_to_data_json>

If you only have one A100, please try

--fsdp "full_shard auto_wrap offload"

Wombat: build your own chatbot

Introduction

To produce a more general purpose language model chatbot, we introduce Wombat to the model zoo of open-resourced language models.

Comparison based on Vicuna test set

Alpaca-7B-ChatGPT is initialized by LLaMA and trained use prompt from Alpaca and responses from ChatGPT.

Math and programming skill are weak for all-LLaMA-7B based models.

Weights

You should obtain LLaMa weights follow link. And you can use our provided scripts recover_wombat_7b.sh to recover origin Wombat weights.

Data and Training

• We reuse the query from Alpaca training data, and sample responses from Alpaca, LLaMA, chatGPT and text-davinci-003. We acquire quality assessments of responses from chatGPT, and train Alpace with RRHF to become a Wombat-7B. You can acquire the data with rewards for Wombat-7B from this link, and start training your own "Wombat". Use the following command lines:

bash ./train_wombat7b.sh <path_to_alpaca_directory> <save_path_directory> <path_to_data_json>

• You can acquire the data with rewards for Wombat-7B-GPT4 from GPT-4-LLM, we direct use their data trained for reward model as our training data. To use it, please first convert the data format by clean_gpt4_compare.py. Use the following command lines to train Wombat-7B-GPT4:

bash ./train_wombat7b_gpt4.sh <path_to_alpaca_directory> <save_path_directory> <path_to_data_json>

Responses generated by Wombat family

Citation

@misc{yuan2023rrhf,
      title={RRHF: Rank Responses to Align Language Models with Human Feedback without tears},
      author={Zheng Yuan and Hongyi Yuan and Chuanqi Tan and Wei Wang and Songfang Huang and Fei Huang},
      year={2023},
      eprint={2304.05302},
      archivePrefix={arXiv},
      primaryClass={cs.CL}
}

Acknowledgements

Our implementation and experiments are based on the codes from Alpaca and trlX, we appreciate their open-resourced codes and LLaMA to promote democratized NLP research, expecially for large lanague models. We thank Tianhang Zhu to help collecting the data and constructive discussions, and we thank Shengxuan Luo and Keming Lu for helping evaluation.

Ref

[1]: LLaMA: Open and Efficient Foundation Language Models. Hugo Touvron, Thibaut Lavril, Gautier Izacard, Xavier Martinet, Marie-Anne Lachaux, Timothée Lacroix, Baptiste Rozière, Naman Goyal, Eric Hambro, Faisal Azhar, Aurelien Rodriguez, Armand Joulin, Edouard Grave, Guillaume Lample. https://arxiv.org/abs/2302.13971v1

[2]: Stanford alpaca: An instruction-following llama model. Rohan Taori, Ishaan Gulrajani, Tianyi Zhang, Yann Dubois, Xuechen Li, Carlos Guestrin, Percy Liang, and Tatsunori B. Hashimoto. https://github.com/tatsu-lab/stanford_alpaca

[3]: HH: Training a helpful and harmless assistant with reinforcement learning from human feedback. Yuntao Bai, Andy Jones, Kamal Ndousse, Amanda Askell, Anna Chen, Nova DasSarma, Dawn Drain, Stanislav Fort, Deep Ganguli, Tom Henighan, et al. https://arxiv.org/abs/2204.05862