| English | 中文 |

This is the repo for the Chinese-Vicuna project, which aims to build and share an instruction-following Chinese LLaMA model which can run on a single Nvidia RTX-2080TI, that why we named this project Vicuna, small but strong enough !

• Why is it called Vicuna：In view of the successful development of alpaca models such as llama,alpaca,guanaco，We want to train a Chinese small alpaca like Vicuna.

The repo contains:

• code for finetune the model
• code for generation based on trained model
• code for run on CPU (fp16 or int4 is support, in purely C++)
• tools to download/convert original facebook llama.ckpt

• March 23, 2023：Released checkpoint-4000 with 50w data training
• March 23, 2023：Deploy the code for fine-tuning and inferencing in colab
• March 23, 2023：Provides code that can be used for inference in pure c++
• March 24, 2023：Released checkpoint-8000 with 100w data training

• LLaMA paper: https://arxiv.org/abs/2302.13971v1
• Self-Instruct paper: https://arxiv.org/abs/2212.10560
• data generation: https://github.com/LianjiaTech/BELLE and https://guanaco-model.github.io/
• the first work: https://github.com/tatsu-lab/stanford_alpaca

We currently select the combination of BELLE and Guanaco data as our main training dataset. We will also add more chitchat dataset ( e.g. LCCC ) to support casual conversation.

Similar to the explosion of the stable diffusion model, platforms like civitai have emerged, consisting of a base model + various LORA models in an open source community.

The repo hopes to help you to train these LORA models.

what is LORA?：Simply, it's a plugin used to help adapt large models to your dataset, technical details can be found inLoRA: Low-Rank Adaptation of Large Language Models。Its advantage is that the finetune is very fast when it comes to getting a small model, about 30M, and the key is that it supports Plug and Play. As can be expected, this is a very suitable architecture for open source ecology.

Here, we will help you train through a very low-demand environment, with only one 2080 (11G) to achieve certain results.

colab link	Descriptions
	Use the specified lora model to inference and generate a webui
	Finetune with the data we collected

Checkpoint-4000

• This LORA model is the result of 30 hours of training with a 2080Ti (checkpoint-4000), about 50w data

Checkpoint-8000

• We can find that you do not punish him a little, he will mess up, if the generation effect is not good, you can increase the Repetition Penalty, beams, topk.
• If your input is long, we suggest you can turn down the beams
• The current model has some Japanese language skills, but not strong

• code：

  • This code is developed based on alpaca-lora，https://github.com/tloen/alpaca-lora
  • This is a relatively simple set of code, the basic idea is to use PEFT's lora interface + transformer's trainer + instruction data configuration

• data：

  • We have utilized several current high quality open source data and are very grateful for their contributions. Many of these data use chatgpt's interface like alpaca to generate high quality INSTRUCTION data.

    • Belle
    • guanaco

  • The data format is relatively simple, basically as follows, with simple examples such as：./sample/merge_sample.json

    • {
      'instruction': 
      'input': 
      'output'
      }
      

    • That is, an instruction, an input, and an output are required. since the data is processed by directly linking instruction and input, the data can actually require only instruction and output, as

       {
        'instruction': "用一句话描述地球为什么是独一无二的。\\n\n"
        'input': ""
        'output': "地球上有适宜生命存在的条件和多样化的生命形式。"
        }
      

  • The data we currently integrate is available for download on BaiduDownload or Google Drive

    • link: https://pan.baidu.com/s/1WSxuhSAotl14ifaAiz5eKw?pwd=b4kb password: b4kb
    • link: https://drive.google.com/file/d/1tzXVhS74m-EtoFot7hEc005LDeZGPit_/view?usp=sharing

• Large Language Model：

  • LLAMA 7B（Of course, if you have a larger machine(such as 3090Ti) can be replaced with a 13B, LLAMA13B is numerically superior to 175B GPT3）

• LORA model：

  • We provide some lora models trained on the above mixed data,
    • lora models
      • 50w data：https://github.com/Facico/Chinese-Vicuna/tree/master/lora-Vicuna/checkpoint-4000
      • 100w data: https://github.com/Facico/Chinese-Vicuna/tree/master/lora-Vicuna/checkpoint-8000
    • Since the model is relatively small, it is temporarily uploaded on github(about 30M).More lora models will be uploaded later on huggingface or on the BaiduDownload or Google Drive
    • The model uses 8bit+lora+256 tokens

• Device：

  • Training：A 2080Ti is sufficient. Since the data length is within 256, it takes about 9G of video memory.
    • 70w of data, 3 epochs, a 2080Ti about 200h
  • Inference：A 2080Ti is all you need。
  • CPU Inference is also support! please go to see tools

Installation

git clone https://github.com/Facico/Chinese-Vicuna
pip install -r requirements.txt

Local python environment is 3.8, torch is 1.13.1, CUDA is 12

Multi-gpu Training

bash finetune.sh

• The parameters to note here are as follows
  • TOT_CUDA, fill in the GPU number to be used, such as TOT_CUDA="0,1,2,3"
  • PORT, fill in the corresponding port
  • DATA_PATH，fill in the corresponding data location in the format of json
  • OUTPUT_PATH，fill in the relative path to save the model
  • MODEL_PATH，path of LLM
  • wandb：This is a training visualization tool that is not turned on by default in the script, and can be turned on by adding "--wandb" to the script

Single-gpu Training

python finetune.py --data_path merge.json --test_size 2000

• The test_size cannot be larger than the data size

inference and use gradio to generate a web page

bash generate.sh

• The parameters to note here are as follows

  • BASE_MODEL，path of LLM
  • LORA_PATH，The checkpoint folder of the lora model
    • It should be noted here that the config loaded by the lora model must be "adapter_config.json" and the model name must be "adapter_model.bin", but it will be automatically saved as "pytorch_model.bin" during training. pytorch_model.bin" during training, while "adapter_config.json" and "adapter_model.bin" will be saved after all training is finished
      • If you load the lora model in the training checkpoint, the code will automatically copy the local "config-sample/adapter_config.json" to the corresponding directory for you and rename the "pytorch_model.bin" to "adapter_model.bin". and rename "pytorch_model.bin" to "adapter_model.bin".

• When using, "max_tokens" is set according to your computer's video memory, and if the generated content generates a lot of duplicate information, you can turn up the "Repetition Penalty".

Details in tools readme

We also offer:

• ways for faster weight download ( 8MB/s ) : link
• convert tools between the original facebook checkpoint (consolidated.xx.pth) and huggingface format (pytorch_model-000xx-of-000xx.bin): link

• belle+guanaco(1.5 epoch, 8000 step)
• belle+guanaco(100%)
• Add more chitchat-like conversational corpus to enhance free conversation
• Add colab training + lora loading interface
• Add the interaction capabilities
• Add llama c++ inference

If you find this project useful in your research, please consider citing:

@inproceedings{leng2023chinese-vicuna,
  title={Chinese-Vicuna: A Chinese Instruction-following LLaMA-based Model},
  author={Chenghao Fan, Zhenyi Lu and Jie Tian},
  url={https://github.com/Facico/Chinese-Vicuna},
  year={2023}
}