-
2023.06.02
- ๐งKoRWKV-6B๐ค 28B tokens ckpt ๊ธฐ๋ฐ ๐งKoAlpaca-KoRWKV-6B๐ค v1.1a๋ฒ์ ํ์ต ๋ฐ ๋ชจ๋ธ ๊ณต๊ฐ
๐งKoAlpaca-KoRWKV-6B ํ๊น ํ์ด์ค ๋ ํฌ๐ค์ ๋ช๊ฐ์ง ์์ฑ ๊ฒฐ๊ณผ ์ํ์ด ์์ต๋๋ค.
- RTX 3090/4090/A5000์ผ๋ก Polyglot-ko 5.8b full finetune ๊ฐ์ด๋ ์ถ๊ฐ
- ๐งKoRWKV-6B๐ค 28B tokens ckpt ๊ธฐ๋ฐ ๐งKoAlpaca-KoRWKV-6B๐ค v1.1a๋ฒ์ ํ์ต ๋ฐ ๋ชจ๋ธ ๊ณต๊ฐ
-
2023.05.30
- ๋ฌด๋ฃ Colab(T4 GPU)์์ ๋์ํ๋ ํ์ต ์์ ์ถ๊ฐ: QLoRA๋ก Polyglot-ko 12.8B ๋ชจ๋ธ KoAlpaca v1.1a ํ์ต with 4bit
- Colab ๋ฌด๋ฃ - T4์์๋ 50sample์ ์ฝ 4๋ถ, 1epoch์ ์ฝ 15์๊ฐ(์ต๋ ์ฌ์ฉ์๊ฐ ์ด๊ณผ)
- Colab Pro - A100์์๋ 50sample์ ์ฝ 44์ด, 1epochs์ ์ฝ 2-3์๊ฐ
- ๋ฌด๋ฃ Colab(T4 GPU)์์ ๋์ํ๋ ํ์ต ์์ ์ถ๊ฐ: QLoRA๋ก Polyglot-ko 12.8B ๋ชจ๋ธ KoAlpaca v1.1a ํ์ต with 4bit
-
2023.05.03
-
2023.04.28
- Logo ์ ๋ฐ์ดํธ ๐
-
2023.04.26
- chat.koalpaca.com ์ Hugging Face ChatUI ์ ์ฉ
-
2023.04.20
-
2023.03.26: ๐คLLAMA 30B ๊ธฐ๋ฐ KoAlpaca ๋ชจ๋ธ์ ๊ณต๊ฐํฉ๋๋ค. (LoRA๋ก ํ์ต)
- LLAMA 30B ํ์ต์ GIST Sundong Kim ๊ต์๋์ A100 ์ง์์ผ๋ก ํ์ต๋์์ต๋๋ค. ๊ฐ์ฌํฉ๋๋ค ๐
-
2023.03.24: ๐คLLAMA 13B ๊ธฐ๋ฐ KoAlpaca ๋ชจ๋ธ์ ๊ณต๊ฐํฉ๋๋ค. (LoRA๋ก ํ์ต)
-
2023.03.23: ๐คLLAMA 65B ๊ธฐ๋ฐ KoAlpaca ๋ชจ๋ธ์ ๊ณต๊ฐํฉ๋๋ค. (LoRA๋ก ํ์ต)
-
2023.03.22: ์นด์นด์คํก์ ํฌํ ๋ KoAlpaca ๋ด์ด ์ถ๊ฐ๋์์ต๋๋ค.
Stanford Alpaca ๋ชจ๋ธ์ ํ์ตํ ๋ฐฉ์๊ณผ ๋์ผํ ๋ฐฉ์์ผ๋ก ํ์ต์ ์งํํ, ํ๊ตญ์ด๋ฅผ ์ดํดํ๋ Alpaca ๋ชจ๋ธ์ ๋๋ค.
๋ฐ๋ก ์จ๋ณด๊ธฐ: ์ฑํ ํ ์น ํ์ด์ง(v1.1b-chat) ํน์ ์นด์นด์คํก ๋ด, Telegram Bot์ผ๋ก ๋ง๋๋ณด์ธ์!
- ์ค์น ์์ด Web์ผ๋ก ๊ณง๋ฐ๋ก ๋ง๋ ์ ์์ต๋๋ค.
- ์ด์ ๋ํ์ ๋งฅ๋ฝ์ ๊ธฐ์ตํด ๋ต๋ณ์ ์์ฑํฉ๋๋ค.
- ์ต๋ 512 ํ ํฐ์ ์๋ต์ ์์ฑํ๋ฉฐ, ์ด์ ๋งฅ๋ฝ์ (์ ๊ท ์์ฑ ๋ต๋ณ์ ํฌํจํด) ์ต๋ 1024 ํ ํฐ์ ๊ธฐ์ตํฉ๋๋ค.
- ๋ฐ๋ชจ์์๋ RTX 3090 24G GPU 1๋๋ก ์๋น์ค์ด๋ฉฐ, 8Bit quantized๋ ๋ชจ๋ธ๋ก ์๋น์ค์ค์ ๋๋ค.
๋งํฌ: https://chat.koalpaca.com
- ์๋ต 5์ด ์ ํ์ผ๋ก ์ธํด 200์ ์ ํ
- ๋งฅ๋ฝ ๊ธฐ์ตํ์ง ์์ต๋๋ค.
๋งํฌ: ์๋ ์ด๋ฏธ์ง ํด๋ฆญ or http://pf.kakao.com/_wdRxcxj
ํ ๋ ๊ทธ๋จ ๋ด: ํ๊ตญ์ด 5.8B v1.1b ๋ชจ๋ธ ๋ฐ LLAMA 7B v1.0 ๋ชจ๋ธ ์ฌ์ฉ๊ฐ๋ฅ, ๋งฅ๋ฝ ๊ธฐ์ต X
- ์ต๋ ์ ๋ ฅ 1024์, ์ต๋ ์ถ๋ ฅ 512ํ ํฐ
- ๋งฅ๋ฝ ๊ธฐ์ตํ์ง ์์ต๋๋ค.
์๋ QR์ฝ๋๋ฅผ ์ฐ๊ฑฐ๋, ํน์ https://t.me/KoAlpacaBot์์ ๋ง๋๋ณด์ธ์!
ํ๊ตญ์ด ๊ธฐ๋ฐ ๋ชจ๋ธ๊ณผ LLAMA ๊ธฐ๋ฐ ๋ชจ๋ธ ๋ชจ๋ ๋ณ๊ฒฝํด๊ฐ๋ฉฐ ์ฒดํํ์ค ์ ์์ต๋๋ค!
๐ฃ ๊ฐ ๋ชจ๋ธ๋ณ ํ ๋์ GPU๋ก ์๋น๋๊ณ ์์ด์, ์์ฑ์ ์๊ฐ์ด ๊ฑธ๋ฆด ์ ์์ต๋๋ค. ์๋๋ฅผ ์ํด ์์ฑ ์ต๋ ํ ํฐ์ ์์ฒญ๋น 128ํ ํฐ์ผ๋ก ์ ํ๋์ด์์ต๋๋ค.
KoAlpaca๋ ๋ฐฑ๋ณธ ๋ชจ๋ธ๋ก ํ๊ตญ์ด ๋ชจ๋ธ์ Polyglot-ko(5.8B)๋ชจ๋ธ์, ์๋ฌธ+ํ๊ตญ์ด ๊ธฐ๋ฐ ๋ชจ๋ธ์ LLAMA๋ฅผ ์ฌ์ฉํ์์ต๋๋ค.
- Polyglot-ko 12.8B ๊ธฐ๋ฐ [Full Finetune v1.1] -> ๐ค beomi/KoAlpaca-Polyglot-12.8B
- ํด๋น ๋ชจ๋ธ์ ChatKoAlpaca์์ ์ฌ์ฉ๋์์ต๋๋ค.
- ํด๋น ๋ชจ๋ธ์ ๐ค 8Bit quantized๋ ๋ชจ๋ธ๋ ์ ๊ณตํฉ๋๋ค.
- Polyglot-ko 5.8B ๊ธฐ๋ฐ [Full Finetune] -> ๐ค beomi/KoAlpaca-Polyglot
- Meta LLAMA 7B ๊ธฐ๋ฐ [Full Finetune] -> ๐ค beomi/KoAlpaca
- Meta LLAMA 13B ๊ธฐ๋ฐ [LoRA] -> ๐ค KoAlpaca-13B-LoRA
- Meta LLAMA 30B ๊ธฐ๋ฐ [LoRA] -> ๐ค KoAlpaca-30B-LoRA
- Meta LLAMA 65B ๊ธฐ๋ฐ [LoRA] -> ๐ค KoAlpaca-65B-LoRA
์ฐธ๊ณ : LLAMA 13B๋ก๋, ์ฐฌ์ฑ๋(@deep-diver)์ด ํ์ตํ์ ๐คchansung/koalpaca-lora-13b๊ฐ ์ถ๊ฐ์ ์ผ๋ก ๊ณต๊ฐ๋์ด์์ต๋๋ค.)
Meta์ LLAMA ๋ชจ๋ธ์ ํ๊ตญ์ด ๋ฐ์ดํฐ์ ์ ์ถฉ๋ถํ ํ์ตํ์ง ์์์, ์ค์ Inference๋ฅผ ๋๋ ค๋ณด์์ ๋ ํ๊ตญ์ด ์ฑ๋ฅ์ด ๋ฎ๊ฒ ๋์ค๋ ์ด์๊ฐ ์์ต๋๋ค.
๋ณด๋ค ํ๊ตญ์ด์ ๋์ ํ๋ฆฌํฐ๋ฅผ ์ป์ด๋ณด๊ณ ์ Polyglot-ko 5.8B, 12.8B ๋ชจ๋ธ์ ๋ฐฑ๋ณธ์ผ๋ก ์ฌ์ฉํ ๋ชจ๋ธ๋ ํ์ต์์ผฐ์ต๋๋ค.
์ดํ v1.1 ๋ฐ์ดํฐ์ ํจ๊ป, ์ด์ ๋ํ์ ๋งฅ๋ฝ๊ณผ ์ฌ์ฉ์์ ์ถ๊ฐ ์ ๋ ฅ์ ๋งฅ๋ฝ์ ์ดํดํ๋ ๋ชจ๋ธ์ธ KoAlpaca v1.1์ ๊ณต๊ฐํฉ๋๋ค.
- ์ต์ ๋ฒ์ torch / HF ๋ผ์ด๋ธ๋ฌ๋ฆฌ ์ค์น
pip install -U torch transformers tokenizers accelerate safetensors
์๋ ์์ ์ฝ๋๋ก ์คํํด๋ณผ ์ ์์ต๋๋ค.
import torch
from transformers import pipeline, AutoModelForCausalLM
MODEL = 'beomi/KoAlpaca-Polyglot-5.8B'
model = AutoModelForCausalLM.from_pretrained(
MODEL,
torch_dtype=torch.float16,
low_cpu_mem_usage=True,
).to(device=f"cuda", non_blocking=True)
model.eval()
pipe = pipeline(
'text-generation',
model=model,
tokenizer=MODEL,
device=0
)
def ask(x, context='', is_input_full=False):
ans = pipe(
f"### ์ง๋ฌธ: {x}\n\n### ๋งฅ๋ฝ: {context}\n\n### ๋ต๋ณ:" if context else f"### ์ง๋ฌธ: {x}\n\n### ๋ต๋ณ:",
do_sample=True,
max_new_tokens=512,
temperature=0.7,
top_p=0.9,
return_full_text=False,
eos_token_id=2,
)
print(ans[0]['generated_text'])
ask("๋ฅ๋ฌ๋์ด ๋ญ์ผ?")
# ๋ฅ๋ฌ๋์ ์ธ๊ณต์ ๊ฒฝ๋ง์ ํตํด ์
๋ ฅ๊ณผ ์ถ๋ ฅ ์ฌ์ด์ ๋ณต์กํ ๊ด๊ณ๋ฅผ ํ์ตํ๋ ๋จธ์ ๋ฌ๋์ ํ ๋ถ์ผ์
๋๋ค. ์ด ๊ธฐ์ ์ ์ปดํจํฐ๊ฐ ์ธ๊ฐ์ ํ์ต ๋ฅ๋ ฅ๊ณผ ์ ์ฌํ ๋ฐฉ์์ผ๋ก ํจํด์ ํ์ตํ๋๋ก ํ๋ฉฐ, ์ธ๊ฐ์ ๊ฐ์
์์ด๋ ๋ฐ์ดํฐ๋ฅผ ์ฒ๋ฆฌํ ์ ์๋ ๊ธฐ์ ์
๋๋ค. ์ต๊ทผ์๋ ๋ฅ๋ฌ๋์ ํ์ฉํ ์ธ๊ณต์ง๋ฅ ์ ํ๋ฆฌ์ผ์ด์
์ด ๋ง์ด ๊ฐ๋ฐ๋๊ณ ์์ต๋๋ค. ์๋ฅผ ๋ค์ด, ์๋ฃ ์ง๋จ ์ ํ๋ฆฌ์ผ์ด์
์์๋ ๋ฅ๋ฌ๋ ๊ธฐ์ ์ ํ์ฉํ์ฌ ํ์์ ํน์ง์ ํ์
ํ๊ณ , ์ด๋ฅผ ํตํด ๋น ๋ฅด๊ณ ์ ํํ ์ง๋จ์ ๋ด๋ฆฌ๋ ๋ฐ ์ฌ์ฉ๋ฉ๋๋ค. ๋ํ, ๊ธ์ต ๋ถ์ผ์์๋ ๋ฅ๋ฌ๋ ๊ธฐ์ ์ ํ์ฉํ์ฌ ์ฃผ๊ฐ ์์ธก ๋ชจํ์ ํ์ตํ๋ ๋ฐ ์ฌ์ฉ๋๊ธฐ๋ ํฉ๋๋ค.
์ด ๋ ํฌ์ webui ํด๋๋ฅผ ์ฐธ๊ณ ํด์ฃผ์ธ์.
์ฐฌ์ฑ๋(@deep-diver)์ deep-diver/Alpaca-LoRA-Serve๋ ํฌ๋ฅผ ์ฐธ๊ณ ํด ์คํํด๋ณด์ธ์.
# ์ Repo์ ๊ฐ์ด๋๋๋ก ์ค์น ํ..
BASE_URL=decapoda-research/llama-13b-hf # 30B๋ชจ๋ธ์ llama-30b-hf 65B๋ชจ๋ธ์ llama-65b-hf ์ฃผ์: 65B ๋ชจ๋ธ์ ๊ธฐ๋ณธ ์ฉ๋์ด 100GB ์ด์์
๋๋ค.
FINETUNED_CKPT_URL=beomi/KoAlpaca-13B-LoRA # 30B๋ชจ๋ธ์ KoAlpaca-30B-LoRA 65B๋ชจ๋ธ์ KoAlpaca-65B-LoRA ์ฃผ์: 65B ๋ชจ๋ธ์ A100 80G๋ฑ Vram์ด ์์ฃผ ํฐ GPU์์๋ง ๋์๊ฐ๋๋ค.
python app.py --base_url $BASE_URL --ft_ckpt_url $FINETUNED_CKPT_URL --port 6006
v1.1 ๋ฐ์ดํฐ์ ์ ๊ธฐ์กด Alpaca๋ชจ๋ธ์ด ๋๋ต์ ์งง๊ฒ ํ๋ ๊ฒฝํฅ, ๊ทธ๋ฆฌ๊ณ ๋งฅ๋ฝ์ ์ดํดํ์ง ๋ชปํ๋ ๊ฒฝํฅ์ ๊ฐ์ ํ๊ธฐ ์ํด ์ ์๋์์ต๋๋ค.
- ๋ฐ์ดํฐ์ ์ ์ ๋ฐ ์์ง
v1.1 ๋ฐ์ดํฐ์ ์ ๋ค์ด๋ฒ ์ง์์ธ์ ํฌ๋กค๋งํ์ฌ ๋ง๋ค์์ต๋๋ค.
๋ค์ด๋ฒ ์ง์์ธ ๋ฒ ์คํธ ์ ์ฒด ์ง๋ฌธ์ ์์งํ์์ต๋๋ค.
- ๋ฐ์ดํฐ ๊ฐ๊ณต
์ค์ ์์ฑ ๋ฐ์ดํฐ๋ ์ง๋ฌธ๊ณผ ์ง๋ฌธ ๋ณธ๋ฌธ, ๊ทธ๋ฆฌ๊ณ ์ฑํ๋ ๋ต๋ณ์ ๋ณธ๋ฌธ์ ๊ธฐ๋ฐ์ผ๋ก ์๋ก ์์ฑ๋์์ต๋๋ค.
๋ฐ์ดํฐ๋ฅผ ChatGPT๋ฅผ ํตํด ์์ฑํ์๊ณ , ์ด๋ Batch Decoding์ ํตํด ์์ฑํ์์ต๋๋ค.
์ฐธ๊ณ : ๊ธฐ์กด ์ง์์ธ ์ง๋ฌธ๊ณผ ๋ต๋ณ์ ChatGPT๊ฐ ์ฐธ์กฐํ ์๋๋ก ์ฌ์ฉ๋์์ต๋๋ค
๋ฐ์ดํฐ์ ์ ๊ธฐ๋ณธ์ ์ผ๋ก Stanford Alpaca์์ ์ ๊ณตํ 5๋ง2์ฒ๊ฐ ๋ฐ์ดํฐ์ ์ ๊ธฐ๋ฐ์ผ๋ก ํฉ๋๋ค.
- ๋ฐ์ดํฐ์ ๋ฒ์ญ
Alpaca ๋ฐ์ดํฐ์ ์ ๋ค์๊ณผ ๊ฐ์ด Instruct ๋ถ๋ถ๊ณผ Input, ๊ทธ๋ฆฌ๊ณ Output ๋ถ๋ถ์ผ๋ก ๊ตฌ์ฑ๋์ด์์ต๋๋ค.
...
{
"instruction": "Describe a time when you had to make a difficult decision.",
"input": "",
"output": "I had to make a difficult decision when I was working as a project manager at a construction company. I was in charge of a project that needed to be completed by a certain date in order to meet the client\u2019s expectations. However, due to unexpected delays, we were not able to meet the deadline and so I had to make a difficult decision. I decided to extend the deadline, but I had to stretch the team\u2019s resources even further and increase the budget. Although it was a risky decision, I ultimately decided to go ahead with it to ensure that the project was completed on time and that the client\u2019s expectations were met. The project was eventually successfully completed and this was seen as a testament to my leadership and decision-making abilities."
},
{
"instruction": "Identify the odd one out.",
"input": "Twitter, Instagram, Telegram",
"output": "Telegram"
},
...
Output์ ๊ฒฝ์ฐ OpenAI์ text-davinci-003
๋ชจ๋ธ์ ์์ฑ ๊ฒฐ๊ณผ์ด๊ธฐ ๋๋ฌธ์, ํด๋น ๋ถ๋ถ์ ๋ฒ์ญํ์ง ์์์ต๋๋ค.
๋ฐ๋ผ์ Instruct์ Input ์ปฌ๋ผ์ ๋ฒ์ญํ๊ณ , ํด๋น Input๋ถ๋ถ์ ์๋ฌ๊ฐ ์๋ ์ผ๋ถ๋ฅผ ์ ์ธํ์์ต๋๋ค.
๋ฒ์ญ์ ํ๊ธฐ ์ํด DeepL API ์๋น์ค๋ฅผ ์ฌ์ฉํ์๊ณ , ๋ฒ์ญ๋ ๋ฐ์ดํฐ๋ ๋ค์๊ณผ ๊ฐ์ ํํ๊ฐ ๋ฉ๋๋ค.
...
{
"instruction": "ํ์ ์ค ํ๋๋ฅผ ๋ฐํ์ธ์.",
"input": "ํธ์ํฐ, ์ธ์คํ๊ทธ๋จ, ํ
๋ ๊ทธ๋จ"
}
...
- Output ๋ฐ์ดํฐ ์์ฑ
์ดํ ํด๋น Instruct์ Input์ ๋ค์๊ณผ ๊ฐ์ด Batch Decoding ๊ธฐ๋ฒ์ ํตํด์ OpenAI ChatGPT API(gpt-3.5-turbo
)๋ฅผ ํตํด ๋ฐ์ดํฐ๋ฅผ ์์ฑํฉ๋๋ค.
Alpaca ์ฐ๊ตฌ์ ๋์ผํ๊ฒ, ํ Instruct/Input ์ ์ ๋ํด์ ๋จ์ผ ์๋ต๋ง์ ์์ฑํด ๋ฐ์ดํฐ์ ์ ๊ตฌ์ฑํ์์ต๋๋ค.
๊ธฐ์กด ์ฐ๊ตฌ์์๋ 20๊ฐ์ ๋ฐ์ดํฐ์ ์ ํ๋ฒ์ ์์ฑํ์ง๋ง, ํ๊ตญ์ด๋ก ์์ฑ์ ์งํํด๋ณด์์ ๋ 10๊ฐ๋ฅผ ๋์์ ์์ฑํ ๋ ์์ ์ ์ผ๋ก ์์ฑ์ด ์งํ๋์ด 10๊ฐ์ฉ ์์ฑํ์์ต๋๋ค.
์๋๋ ๋ต๋ณ์ ์์ฑํ๋๋ฐ ์ฌ์ฉํ Prompt์ ๋๋ค.
PROMPT = """\
๋ค์ํ ์์
์ ๋ํ ๋ต๋ณ์ ์์ฑํด์ฃผ์ธ์. ์ด๋ฌํ ์์
์ง์นจ์ ChatGPT ๋ชจ๋ธ์ ์ฃผ์ด์ง๋ฉฐ, ChatGPT ๋ชจ๋ธ์ด ์ง์นจ์ ์๋ฃํ๋์ง ํ๊ฐํฉ๋๋ค.
์๊ตฌ ์ฌํญ์ ๋ค์๊ณผ ๊ฐ์ต๋๋ค:
1. ๋ค์์ฑ์ ๊ทน๋ํํ๊ธฐ ์ํด ๊ฐ ์ง์์ ๋ํด ๋์ฌ๋ฅผ ๋ฐ๋ณตํ์ง ์๋๋ก ํ์ธ์.
2. ์ง์์ ์ฌ์ฉ๋๋ ์ธ์ด๋ ๋ค์ํด์ผ ํฉ๋๋ค. ์๋ฅผ ๋ค์ด, ์ง๋ฌธ๊ณผ ๋ช
๋ นํ ์ง์๋ฅผ ๊ฒฐํฉํด์ผ ํฉ๋๋ค.
3. ์ง์ ์ฌํญ์ ์ ํ์ด ๋ค์ํด์ผ ํฉ๋๋ค. ๋ชฉ๋ก์๋ ๊ฐ๋ฐฉํ ์์ฑ, ๋ถ๋ฅ, ํธ์ง ๋ฑ๊ณผ ๊ฐ์ ๋ค์ํ ์ ํ์ ์์
์ด ํฌํจ๋์ด์ผ ํฉ๋๋ค.
2. GPT ์ธ์ด ๋ชจ๋ธ์ ์ง์๋ฅผ ์๋ฃํ ์ ์์ด์ผ ํฉ๋๋ค. ์๋ฅผ ๋ค์ด ์ด์์คํดํธ์๊ฒ ์๊ฐ์ ๋๋ ์ค๋์ค ์ถ๋ ฅ์ ์์ฑํ๋๋ก ์์ฒญํ์ง ๋ง์ธ์. ๋ ๋ค๋ฅธ ์๋ก, ์ด์์คํดํธ๊ฐ ์ด๋ค ์์
๋ ์ํํ ์ ์์ผ๋ฏ๋ก ์คํ 5์์ ๊นจ์ฐ๊ฑฐ๋ ๋ฏธ๋ฆฌ ์๋ฆผ์ ์ค์ ํ๋๋ก ์์ฒญํ์ง ๋ง์ธ์.
3. ๋ต๋ณ์ ํ๊ตญ์ด๋ก ์์ฑํด์ผ ํฉ๋๋ค.
4. ๋ต๋ณ์ 1~2๋ฌธ์ฅ์ผ๋ก ์์ฑํ์ธ์. ๋ช
๋ น๋ฌธ์ด๋ ์ง๋ฌธ๋ ํ์ฉ๋ฉ๋๋ค.
5. ์ง์ ์ฌํญ์ ๋ํ ์ ์ ํ ์
๋ ฅ์ ์์ฑํด์ผ ํฉ๋๋ค. ์
๋ ฅ ํ๋์๋ ์ง์์ ๋ํ ๊ตฌ์ฒด์ ์ธ ์๊ฐ ํฌํจ๋์ด์ผ ํฉ๋๋ค. ์ค์ ๋ฐ์ดํฐ๋ฅผ ํฌํจํด์ผ ํ๋ฉฐ ๋จ์ํ ์๋ฆฌ ํ์์๋ฅผ ํฌํจํด์๋ ์ ๋ฉ๋๋ค. ์
๋ ฅ์ ์ง์ ์ฌํญ์ ์ด๋ ต๊ฒ ๋ง๋ค ์ ์๋ ์๋นํ ๋ด์ฉ์ ์ ๊ณตํด์ผ ํ์ง๋ง 100๋จ์ด๋ฅผ ๋์ง ์๋ ๊ฒ์ด ์ด์์ ์
๋๋ค.
6. ์ผ๋ถ ์ง์์ฌํญ์ ์ถ๊ฐ ์
๋ ฅ์ด ์๊ณ , ์ผ๋ถ ์ง์์๋ ์
๋ ฅ ํ๋๊ฐ ๋น์ด์์ต๋๋ค. ์๋ฅผ ๋ค์ด "์ธ๊ณ์์ ๊ฐ์ฅ ๋์ ๋ด์ฐ๋ฆฌ๋ ๋ฌด์์ธ๊ฐ?"๋ผ๋ ์ผ๋ฐ์ ์ธ ์ ๋ณด๋ฅผ ๋ฌป๋ ์ง์์ ๊ฒฝ์ฐ ๊ตฌ์ฒด์ ์ธ ๋งฅ๋ฝ์ ์ ๊ณตํ ํ์๊ฐ ์์ด, ์
๋ ฅ ํ๋๊ฐ ๋น์ด์์ ์ ์์ต๋๋ค.
7. ์ถ๋ ฅ์ ๋ช
๋ น์ด์ ์
๋ ฅ์ ๋ํ ์ ์ ํ ์๋ต์ด์ด์ผ ํฉ๋๋ค.
์๋์ 10๊ฐ์ ๋ช
๋ น์ด์ ์
๋ ฅ(์ต์
)์ ๋ฐ๋ผ ์ ์ ํ ์๋ต์ ์์ฑํ์ธ์.
์๋ต์ ์๋์ ๊ฐ์ ํ์์ผ๋ก 10๊ฐ์ง๋ฅผ 0๋ฒ ๋ถํฐ 9๋ฒ ๊น์ง, ๋ฒํธ์ ๋ฐ๋ผ ํด๋น ๋ฒํธ์ ๋ช
๋ น์ด์ ์
๋ ฅ์ ์๋ง๊ฒ ์์ฑํ์ธ์.
๊ฐ ์๋ต ์ฌ์ด๋ ### ์ผ๋ก ๋ด์ฉ์ ๋ถ๋ฆฌํด์ฃผ์ธ์.
์๋ต0: ์ฒซ ๋ฒ์งธ ์๋ต๋ด์ฉ###
์๋ต1: ๋ ๋ฒ์งธ ์๋ต๋ด์ฉ###
...
์๋ต9: ๋ง์ง๋ง ์๋ต๋ด์ฉ"""
์ถ๊ฐ์ ์ผ๋ก, ์๋์ ๊ฐ์ด ChatGPT API์ system prompt๋ฅผ ์ถ๊ฐํ์์ต๋๋ค.
"content": "์๋๋ ์์
์ ์ค๋ช
ํ๋ ๋ช
๋ น์ด์
๋๋ค. ์
๋ ฅ์ด ์์ผ๋ฉด ์
๋ ฅ์ ์ ์ธํ๊ณ , ๋ช
๋ น์ด์ ๋ฐ๋ฅธ ์์ฒญ์ ์ ์ ํ ์๋ฃํ๋ ์๋ต์ ์์ฑํ์ธ์. ์ถ๊ฐ์ ์
๋ ฅ์ด ์๋ค๋ฉด ์์
์ ์ค๋ช
ํ๋ ๋ช
๋ น์ด์ ์ถ๊ฐ ์ปจํ
์คํธ๋ฅผ ์ ๊ณตํ๋ ์
๋ ฅ์ ๋ฐ๋ผ ์์ฒญ์ ์ ์ ํ ์๋ฃํ๋ ์๋ต์ ์์ฑํ์ธ์.",
ํ๊ตญ์ด๋ก ์์ฑ์ด ์๋ฃ๋ ๋ฐ์ดํฐ์
์ ko_alpaca_data.json
์ ์ ์ฅ๋์ด ์์ต๋๋ค.
- QLoRA๋ก Polyglot-ko 12.8B ๋ชจ๋ธ KoAlpaca v1.1a ํ์ต with 4bit
- 1000๊ฐ ์ํ๋ก๋ง ํ์ตํ ๋ชจ๋ธ ์์ฑ๊ฒฐ๊ณผ ์์
### ์ง๋ฌธ: ํ์ต์
๊ณผ ์ฝ์ต์
์ ์ฐจ์ด, ๊ทธ๋ฆฌ๊ณ ์ผ๋ฐ ๊ฐ๋ฏธ ํฌ์์๊ฐ ์ ํํด์ผ ํ ํฌ์ง์
์?
### ๋ต๋ณ: ํ์ด๋ ์ฃผ์์ ์ฌ๋ ๊ฒ(๊ตฌ๋งค)์ ์๋ฏธํ๊ณ , ์ฝ์ด๋ ์ฃผ์์ ํ๋(ํ๋งค) ๊ฒ์
๋๋ค. ์๋ฅผ ๋ค๋ฉด, ๊ธฐ์
์ ์ฃผ๊ฐ๊ฐ 10๋ง์์ธ๋ฐ, ๊ทธ ํ์ฌ์์ ์ ๊ท ์ฌ์
์ ์งํ ์ค์ด๋ผ, ์์ผ๋ก ๋งค์ถ์ด ์ฆ๋๋์ด ๊ธฐ์
๊ฐ์น๊ฐ ์์นํ ๊ฒ์ผ๋ก ํ๋จํด, ํด๋น ํ์ฌ์ ์ฃผ์์ ์ฌ๋ ๊ฒ์ด ํ์ต์
์
๋๋ค. ์ด๋ ์ฃผ์์ ์ฌ๋ ์์ ๊ณผ ํด๋น ํ์ฌ์ ์ฃผ๊ฐ๊ฐ ํ๋ฝํ ๊ฒฝ์ฐ์๋ ๊ธฐ์
์ ์ฃผ๊ฐ์ ํจ๊ป ์ฃผ๊ฐ๊ฐ ํ๋ฝํ๋ ๋ฆฌ์คํฌ๊ฐ ์์ต๋๋ค. ๋ฐ๋ฉด, ์ฝ์ต์
์ ์ฃผ์์ ํ๋ ๊ฒ์
๋๋ค. ์ด๋ ์ฃผ์์ ํ๋ ์์ ๊ณผ ํด๋น ํ์ฌ์ ์ฃผ๊ฐ๊ฐ ์ฆ๊ฐํด์ ํฅํ ๊ธฐ์
์ ๋ง์ด ๋ฐ์ ๊ฒฝ์ฐ ์ฃผ๊ฐ๊ฐ ์์นํ๋ฉฐ, ํด๋น ์ฃผ์์ ํ๋ฆฌ๋ฏธ์์ ๋ฐ์ ์ ์๋ ์์ ์ ์ธ ํฌ์๋ฒ์
๋๋ค. ์ผ๋ฐ ๊ฐ๋ฏธ ํฌ์์๋ค์ ์ฃผ์์ ๋งค์ํ ๋์ ์ฃผ์์ ๋งค๋ํ ๋ ๋ค์ํ ๋ฆฌ์คํฌ๊ฐ ์กด์ฌํ๋ฏ๋ก, ์ ๋ฌธ๊ฐ์ ์กฐ์ธ๊ณผ ํฌ์ ๊ฒฝํ์ ๋ฐํ์ผ๋ก ์ ์ ํ ํฌ์ ์ ๋ต์ ์๋ฆฝํด์ผ ํฉ๋๋ค. ํฌ์์ ๋ํ ์์ธํ ์ฌํญ์ ์๋์์ ๋ฌด๋ฃ๋ก ์ป์ ์ ์์ต๋๋ค.
### ์ง๋ฌธ: ๋ง์ง์ฝ์ด ๋ฐ์ํ๋ ์ด์ ๊ฐ ๋ญ์ผ? ๊ทธ๋ฆฌ๊ณ ์ด๋ป๊ฒ ํด์ผ ๋ง์ง์ฝ์ ๋ง์ ์ ์์ด?
### ๋ต๋ณ: ๋ง์ง์ฝ์ด๋, ์ ๋ฌผ/์ต์
๋งค๋งค ์ ์ฆ๊ฑฐ๊ธ์ด ๋ถ์กฑํด์ ์ถ๊ฐ์ฆ๊ฑฐ๊ธ ์์น๋ฅผ ์๊ตฌ๋ฐ๋ ๊ฒ์ ๋งํฉ๋๋ค. ์ถ๊ฐ์ฆ๊ฑฐ๊ธ์ ์ ๋ฌผ/์ต์
๊ฑฐ๋ ๊ณ์ฝ์ ๋ฏธ๋ฆฌ ์ ํด์ง ์ฝ์ ์ฆ๊ฑฐ๊ธ์์ ์ถ๊ฐ๋ก ๋ถ๋ดํด์ผ ํ๋ ์ฆ๊ฑฐ๊ธ์ ์๋ฏธํฉ๋๋ค. ํต์์ ์ผ๋ก ๋งค์ ๊ณ์ฝ ์์๋ ๊ณ์ฝ ๊ธ์ก์ 10%๋ฅผ ์ฆ๊ฑฐ๊ธ์ผ๋ก ์์นํ๊ณ , ๋งค๋ ๊ณ์ฝ ์์๋ ํด๋น ๊ธ์ก์ 3%๋ฅผ ์์นํฉ๋๋ค. ๋ฐ๋ผ์, ๋งค์ ๊ณ์ฝ ์์๋ ์ด 20%์ ์ฆ๊ฑฐ๊ธ์ด ํ์ํ๊ณ , ๋งค๋ ๊ณ์ฝ ์์๋ ์ด 9%์ ์ฆ๊ฑฐ๊ธ์ด ํ์ํฉ๋๋ค. ๋ฐ๋ผ์, ์ ๋ฌผ ๋งค๋งค ์ค์๋ ๋งค์ผ ๋งค์ผ์ ์์ธ์ ๋ฐ๋ผ ์ฆ๊ฑฐ๊ธ์ ์์๋ก ํ์ํ๋ฉด ์ถ๊ฐ๋ก ๋ฉ๋ถํด์ผํด์ ์ถ๊ฐ์ฆ๊ฑฐ๊ธ์ด ๋ฐ์ํ๋ฉฐ, ํด๋น ํ์์ก ๋ถ์กฑ์์๋ ๋ง์ง์ฝ์ด ๋ฐ์ํฉ๋๋ค. ๋ฐ๋ผ์, ์ ๋ฌผ ๊ฑฐ๋๋ฅผ ํ๊ธฐ ์ ์๋ ๊ผญ ์ถ๊ฐ์ฆ๊ฑฐ๊ธ์ ์์นํ๋ ๊ฒ์ด ์ค์ํฉ๋๋ค. ์ถ๊ฐ์ฆ๊ฑฐ๊ธ์ '์ ๋ฌผ/์ต์
-> ์ฆ๊ฑฐ๊ธ -> ์ถ๊ฐ์์น/์ฒญ์ฐ' ๋ฐฉ๋ฒ์ผ๋ก ์กฐํ ๊ฐ๋ฅํ๋ฉฐ, ์ธํฐ๋ท์ด๋ ์ ํ๋ก๋ ์กฐํํ ์ ์์ต๋๋ค. ๋, '์ฃผ๋ฌธ/์ฆ๊ฑฐ๊ธ -> ์ถ๊ฐ์ฆ๊ฑฐ๊ธ'์ ํตํด ์ถ๊ฐ์ฆ๊ฑฐ๊ธ์ ์
๊ธํ ์๋ ์์ต๋๋ค. ์ถ๊ฐ์ฆ๊ฑฐ๊ธ์ ์์น
ChatKoAlpaca(KoAlpaca Polyglot-ko-12.8B-v1.1b) ๋ชจ๋ธ์ A100 80GB 4๋๋ก ํ์ต์ ์งํํ์๊ณ , DeepSpeed ZeRO-3์ ํตํด Full Sharding์ผ๋ก ํ์ต์ ์งํํ์์ต๋๋ค.
ํด๋น ์ฝ๋๋ ํ์ฌ ๋ ํฌ์ train_1.1b
ํด๋๋ฅผ ์ฐธ๊ณ ํด์ฃผ์ธ์.
๋ชจ๋ธ ํ์ต์ A100 80GB 1๋๋ก ํ์ต์ ์งํํ์์ต๋๋ค.
LLAMA๊ธฐ๋ฐ ๋ชจ๋ธ ํ์ต์ A100 80GB 4๋๋ก ํ์ต์ ์งํํ์๊ณ , FSDP๋ฅผ ํตํด ํ์ตํ์ต๋๋ค.
ํ์ต์ ์ฌ์ฉํ ์คํฌ๋ฆฝํธ๋ train.py
์ ์ ์ฅ๋์ด ์๊ณ , ํ์ต์ ์ฌ์ฉํ ์คํฌ๋ฆฝํธ๋ train.sh
์ ์ ์ฅ๋์ด ์์ต๋๋ค.
LLAMA ๋ชจ๋ธ์ด Hugginface Transformers 4.28.0 ์ด์ ๋ฒ์ ์ ํฌํจ๋์์ต๋๋ค. ๊ทธ ์ดํ ๋ฒ์ ์ ์ฌ์ฉํ๋ฉด llama
๊ฐ ์๋ค๋ ์๋ฌ๊ฐ ๋ฐ์ํฉ๋๋ค. FSDP ์ฌ์ฉ์ ๊ฐ์ธ์ค ๋ ์ด์ด๋ก๋ LlamaDecoderLayer
๋ฅผ ์ฌ์ฉํฉ๋๋ค.
# train.sh
--fsdp_transformer_layer_cls_to_wrap 'LlamaDecoderLayer'
๐ค Huggingface Repo: https://huggingface.co/beomi/KoAlpaca-13B-LoRA
๋ชจ๋ธ ํ์ต์ RTX 3090 24GB 4๋๋ก ์งํํ์ต๋๋ค. ํ์ต์ ์ฌ์ฉํ ์ฝ๋๋ https://github.com/tloen/alpaca-lora ์ ๊ธฐ๋ฐ์ผ๋ก ์ฌ์ฉํ์์ต๋๋ค.
๋ฐ์ดํฐ์
์ ํด๋น ๋ ํฌ์ alpaca_data_cleaned.json
(์๋ฌธ)๊ณผ ํ์ฌ ๋ ํฌ์ ko_alpaca_data.json
๋ฅผ ํฉ์ณ ํ์ต์ ์ฌ์ฉํ์์ต๋๋ค.
๐ค Huggingface Repo: https://huggingface.co/beomi/KoAlpaca-30B-LoRA
๋ชจ๋ธ ํ์ต์ A100 40GB 2๋๋ก ์งํํ์ต๋๋ค. ํ์ต์ ์ฌ์ฉํ ์ฝ๋๋ https://github.com/tloen/alpaca-lora ์ ๊ธฐ๋ฐ์ผ๋ก ์ฌ์ฉํ์์ต๋๋ค.
- LLAMA 30B ํ์ต์ GIST Sundong Kim ๊ต์๋์ A100 ์ง์์ผ๋ก ํ์ต๋์์ต๋๋ค.
๋ฐ์ดํฐ์
์ ํด๋น ๋ ํฌ์ alpaca_data_cleaned.json
(์๋ฌธ)๊ณผ ํ์ฌ ๋ ํฌ์ ko_alpaca_data.json
๋ฅผ ํฉ์ณ ํ์ต์ ์ฌ์ฉํ์์ต๋๋ค.
๐ค Huggingface Repo: https://huggingface.co/beomi/KoAlpaca-65B-LoRA
๋ชจ๋ธ ํ์ต์ A100 80GB 8๋๋ก ์งํํ์ต๋๋ค. ํ์ต์ ์ฌ์ฉํ ์ฝ๋๋ https://github.com/tloen/alpaca-lora ์ ๊ธฐ๋ฐ์ผ๋ก ์ฌ์ฉํ์์ต๋๋ค.
๋ฐ์ดํฐ์
์ ํด๋น ๋ ํฌ์ alpaca_data_cleaned.json
(์๋ฌธ)๊ณผ ํ์ฌ ๋ ํฌ์ ko_alpaca_data.json
๋ฅผ ํฉ์ณ ํ์ต์ ์ฌ์ฉํ์์ต๋๋ค.
polyglot-ko 5.8b
์KoAlpaca-polyglot
๊ณผ Benchmark ์ฑ๋ฅ ๋น๊ต- Few-shot Learning์ผ๋ก 2 ๊ฐ์ง ํ๋กฌํํธ ์ ํ์ผ๋ก ๊ตฌ๋ถํ์ฌ ํ ์คํธ ์งํ
-
few-shot ๊ตฌ์ฑ
k=10
์ค์ - ํ ์คํธ ํ ํฐ ๊ธธ์ด๊ฐ 25 ์ดํ์ธ ๋ฌธ์ฅ๋ง ๊ตฌ์ฑ
- ๋ฐ์ดํฐ ํ ํฐ ๊ธธ์ด์ ์ฝ 75 ํผ์ผํ์ผ์ ํด๋นํ๋ ๋ฐ์ดํฐ๋ง ํฌํจ
-
NSMC ๋ฐ์ดํฐ ํ ํฐ ๊ธธ์ด ๋ถํฌ
Few shot ์ผ์ด์ค ํ ํฐ ํ๊ท ๊ธธ์ด: 20.229
Few shot ์ผ์ด์ค ํ ํฐ ์ต๋ ๊ธธ์ด: 280
Few shot ์ผ์ด์ค ํ ํฐ ๊ธธ์ด ํ์คํธ์ฐจ: 16.488
Few shot ์ผ์ด์ค ํ ํฐ ๊ธธ์ด 80 ํผ์ผํ์ผ: 27.0
- ํ๋กฌํํธ ์ ํ 1: ๋งค์ฐ ๋จ์ํ ํ๋กฌํํธ ๊ตฌ์ฑ. ๋ถ์ Task์ ๋ํ ๋ด์ฉ์ ๋ช ์์ ์ผ๋ก ํ์ง ์์
def build_prompt_text(sent):
return "๋ฌธ์ฅ: " + sent + '\n๊ฐ์ :'
- ํ๋กฌํํธ ์ ํ 2: ํ๋กฌํํธ ์ ํ 1์ ๋นํด Task ์๋ ๋ด์ฉ์ ํฌํจ. ๋ถ์ Task์ ๋ํ ๋ด์ฉ์ ์๋ฌธํ์ผ๋ก ํํ
def build_prompt_text(sent):
return '๋ค์ ๋ฌธ์ฅ์ ๊ธ์ ์ผ๊น์ ๋ถ์ ์ผ๊น์?\n' + sent + '\n์ ๋ต:'
acc. | ํ๋กฌํํธ ์ ํ 1 | ํ๋กฌํํธ ์ ํ 2 |
---|---|---|
polyglot-ko | 0.5752 | 0.7223 |
koalpaca-polyglot | 0.6939 | 0.7683 |
This is the repo for the Stanford Alpaca project, which aims to build and share an instruction-following LLaMA model. The repo contains:
- A web demo to interact with our Alpaca model
- The 52K data used for fine-tuning the model
- The code for generating the data
- The code for fine-tuning the model
The current Alpaca model is fine-tuned from a 7B LLaMA model [1] on 52K instruction-following data generated by the techniques in the Self-Instruct [2] paper, with some modifications that we discuss in the next section.
In a preliminary human evaluation, we found that the Alpaca 7B model behaves similarly to the text-davinci-003
model on the Self-Instruct instruction-following evaluation suite [2].
Alpaca is still under development, and there are many limitations that have to be addressed. Importantly, we have not yet fine-tuned the Alpaca model to be safe and harmless. We thus encourage users to be cautious when interacting with Alpaca, and to report any concerning behavior to help improve the safety and ethical considerations of the model.
Our initial release contains the data generation procedure, dataset, and training recipe. We intend to release the model weights if we are given permission to do so by the creators of LLaMA. For now, we have chosen to host a live demo to help readers better understand the capabilities and limits of Alpaca, as well as a way to help us better evaluate Alpaca's performance on a broader audience.
Please read our release blog post for more details about the model, our discussion of the potential harm and limitations of Alpaca models, and our thought process for releasing a reproducible model.
[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]: Self-Instruct: Aligning Language Model with Self Generated Instructions. Yizhong Wang, Yeganeh Kordi, Swaroop Mishra, Alisa Liu, Noah A. Smith, Daniel Khashabi, Hannaneh Hajishirzi. https://arxiv.org/abs/2212.10560
alpaca_data.json
contains 52K instruction-following data we used for fine-tuning the Alpaca model.
This JSON file is a list of dictionaries, each dictionary contains the following fields:
instruction
:str
, describes the task the model should perform. Each of the 52K instructions is unique.input
:str
, optional context or input for the task. For example, when the instruction is "Summarize the following article", the input is the article. Around 40% of the examples have an input.output
:str
, the answer to the instruction as generated bytext-davinci-003
.
We used the following prompts for fine-tuning the Alpaca model:
- for examples with a non-empty input field:
Below is an instruction that describes a task, paired with an input that provides further context. Write a response that appropriately completes the request.
### Instruction:
{instruction}
### Input:
{input}
### Response:
- for examples with an empty input field:
Below is an instruction that describes a task. Write a response that appropriately completes the request.
### Instruction:
{instruction}
### Response:
During inference (eg for the web demo), we use the user instruction with an empty input field (second option).
Running the code
- Set environment variables
OPENAI_API_KEY
to your OpenAI API key. - Install the dependencies with
pip install -r requirements.txt
. - Run
python -m generate_instruction generate_instruction_following_data
to generate the data.
We built on the data generation pipeline from self-instruct and made the following modifications:
- We used
text-davinci-003
to generate the instruction data instead ofdavinci
. - We wrote a new prompt (
prompt.txt
) that explicitly gave the requirement of instruction generation totext-davinci-003
. Note: there is a slight error in the prompt we used, and future users should incorporate the edit in tatsu-lab/stanford_alpaca#24 - We adopted much more aggressive batch decoding, i.e., generating 20 instructions at once, which significantly reduced the cost of data generation.
- We simplified the data generation pipeline by discarding the difference between classification and non-classification instructions.
- We only generated a single instance for each instruction, instead of 2 to 3 instances as in [1].
This produced an instruction-following dataset with 52K examples obtained at a much lower cost (less than $500). In a preliminary study, we also find our 52K generated data to be much more diverse than the data released by self-instruct. We plot the below figure (in the style of Figure 2 in the self-instruct paper to demonstrate the diversity of our data. The inner circle of the plot represents the root verb of the instructions, and the outer circle represents the direct objects.
We fine-tune our models using standard Hugging Face training code with the following hyperparameters:
Hyperparameter | Value |
---|---|
Batch size | 128 |
Learning rate | 2e-5 |
Epochs | 3 |
Max length | 512 |
Weight decay | 0 |
Given Hugging Face hasn't officially supported the LLaMA models, we fine-tuned LLaMA with Hugging Face's transformers library by installing it from a particular fork (i.e. this PR to be merged).
The hash of the specific commit we installed was 68d640f7c368bcaaaecfc678f11908ebbd3d6176
.
To reproduce our fine-tuning runs for LLaMA, first install the requirements
pip install -r requirements.txt
Then, install the particular fork of Hugging Face's transformers library.
Below is a command that fine-tunes LLaMA-7B with our dataset on a machine with 4 A100 80G GPUs in FSDP full_shard
mode.
We were able to reproduce a model of similar quality as the one we hosted in our demo with the following command using Python 3.10.
Replace <your_random_port>
with a port of your own, <your_path_to_hf_converted_llama_ckpt_and_tokenizer>
with the
path to your converted checkpoint and tokenizer (following instructions in the PR), and <your_output_dir>
with where you want to store your outputs.
torchrun --nproc_per_node=4 --master_port=<your_random_port> train.py \
--model_name_or_path <your_path_to_hf_converted_llama_ckpt_and_tokenizer> \
--data_path ./alpaca_data.json \
--bf16 True \
--output_dir <your_output_dir> \
--num_train_epochs 3 \
--per_device_train_batch_size 4 \
--per_device_eval_batch_size 4 \
--gradient_accumulation_steps 8 \
--evaluation_strategy "no" \
--save_strategy "steps" \
--save_steps 2000 \
--save_total_limit 1 \
--learning_rate 2e-5 \
--weight_decay 0. \
--warmup_ratio 0.03 \
--lr_scheduler_type "cosine" \
--logging_steps 1 \
--fsdp "full_shard auto_wrap" \
--fsdp_transformer_layer_cls_to_wrap 'LLaMADecoderLayer' \
--tf32 True
fsdp_transformer_layer_cls_to_wrap
must be set to the name of the specific decoder layer.
The LLaMA Hugging Face PR is not stable.
Earlier commits used the name LLaMADecoderLayer
for their decoder layer (the commit hash our code is based on this).
More recent commits use LlamaDecoderLayer
(notice the small case difference).
Not setting fsdp_transformer_layer_cls_to_wrap
to the correct name will lead to drastic slowdowns in training.
The same script also works for OPT fine-tuning. Here's an example for fine-tuning OPT-6.7B
torchrun --nproc_per_node=4 --master_port=<your_random_port> train.py \
--model_name_or_path "facebook/opt-6.7b" \
--data_path ./alpaca_data.json \
--bf16 True \
--output_dir <your_output_dir> \
--num_train_epochs 3 \
--per_device_train_batch_size 4 \
--per_device_eval_batch_size 4 \
--gradient_accumulation_steps 8 \
--evaluation_strategy "no" \
--save_strategy "steps" \
--save_steps 2000 \
--save_total_limit 1 \
--learning_rate 2e-5 \
--weight_decay 0. \
--warmup_ratio 0.03 \
--lr_scheduler_type "cosine" \
--logging_steps 1 \
--fsdp "full_shard auto_wrap" \
--fsdp_transformer_layer_cls_to_wrap 'OPTDecoderLayer' \
--tf32 True
Note the given training script is meant to be simple and easy to use, and is not particularly optimized.
To run on more gpus, you may prefer to turn down gradient_accumulation_steps
to keep a global batch size of 128. Global batch size has not been tested for optimality.
All grad students below contributed equally and the order is determined by random draw.
All advised by Tatsunori B. Hashimoto. Yann is also advised by Percy Liang and Xuechen is also advised by Carlos Guestrin.
Please cite the repo if you use the data or code in this repo.
@misc{alpaca,
author = {Rohan Taori and Ishaan Gulrajani and Tianyi Zhang and Yann Dubois and Xuechen Li and Carlos Guestrin and Percy Liang and Tatsunori B. Hashimoto },
title = {Stanford Alpaca: An Instruction-following LLaMA model},
year = {2023},
publisher = {GitHub},
journal = {GitHub repository},
howpublished = {\url{https://github.com/tatsu-lab/stanford_alpaca}},
}
Naturally, you should also cite the original LLaMA paper [1] and the Self-Instruct paper [2].
We thank Yizhong Wang for his help in explaining the data generation pipeline in Self-Instruct and providing the code for the parse analysis plot. We thank Yifan Mai for helpful support, and members of the Stanford NLP Group as well as the Center for Research on Foundation Models (CRFM) for their helpful feedback.