The overview of this paper
๊ฑฐ๋ instruction-tuned LM์ ์๋ก์ด task์ ๋ํด zero-shot์ผ๋ก ์ผ๋ฐํํ๋ ์ข์ ๋ฅ๋ ฅ์ ๋ณด์ฌ์ฃผ๊ณ ์๋ค. ๊ทธ๋ผ์๋ ๋ถ๊ตฌํ๊ณ ์ด๋ค์ ์, ๋ค์์ฑ, ์ฐฝ์์ฑ์ด ํ์ ๋์ด ์๋ human-written instruction data์ ํฌ๊ฒ ์์กดํ๊ณ ์๋ค. ์ด๋ tuned model์ ์ผ๋ฐํ ๋ฅ๋ ฅ์ ๋ฐฉํดํ๋ค. ๋ ผ๋ฌธ์์๋ LM์ ์์ฑ์ ํ์ฉํด์ PLM์ instruction-following ๋ฅ๋ ฅ์ ๊ฐ์ ์์ผ ์ฃผ๋ ํ๋ ์์ํฌ์ธ Self-Instruct๋ฅผ ์๊ฐํ์๋ค.
Self-Instruct์ ํ์ดํ๋ผ์ธ์ LM์ผ๋ก๋ถํฐ instruction, input, output ์ํ์ ์์ฑํ๊ณ , ์ด๋ค์ ์ฌ์ฉํด์ ๊ธฐ์กด ๋ชจ๋ธ์ fine-tune ํ๊ธฐ ์ ์ ๊ธฐ์ค์ ๋ฐ๋ผ ๊ฐ์ง์น๊ธฐ๋ฅผ ์งํํ๋ค. Self-Instruct๋ฅผ vanilla GPT3์ ์ ์ฉํ ๊ฒฐ๊ณผ Super-NatrualInstruction์์์ ๋ชจ๋ธ๋ณด๋ค 33% ์ ๋์ ์ฑ๋ฅ ๊ฐ์ ์ ๋ณด์ฌ์คฌ๋ค. ๊ทธ๋ฆฌ๊ณ InstructGPT-001๊ณผ ๊ฑฐ์ ์ฐจ์ด๊ฐ ๋์ง ์๋ ์ฑ๋ฅ์ ๋ณด์ฌ์คฌ๋ค.
Self-Instruct๋ PLM์ instruction๊ณผ alignํ๊ธฐ ์ํ ๊ฑฐ์ annotation-free ํ method๋ฅผ ์ ๊ณตํ๊ณ , ๋ ผ๋ฌธ์์ ์ฌ์ฉ๋ ๋๊ท๋ชจ ํตํฉ ๋ฐ์ดํฐ์ ์ instruction tuning์ ๋ํ ํฅํ ์ฐ๊ตฌ๋ฅผ ์ฉ์ดํ๊ฒ ํ๊ธฐ ์ํด ๊ณต๊ฐํ์๋ค.
Table of Contents
1. Introduction
2. Method
3. Self-Instruct Data from GPT3
4. Experimental Results
5. Discussion & Limitation
1. Introduction
์ง๊ธ๊น์ง ์์ฐ์ด instruction์ ๋ฐ๋ฅผ ์ ์๋ LM์ ๋ง๋ค๊ธฐ ์ํ ์๋ง์ ๋ ธ๋ ฅ๋ค์ด ์์๋ค. ์ด๋ฅผ ์ํด 2๊ฐ์ง์ ์ค์ํ ์์๊ฐ ํ์ํ์๋ค: large PLM, humna-written instruction data. ํ์ง๋ง ์ด๋ฌํ ํ๋ก์ธ์ค๋ ์๋ค์ํผ ๋์ด ๋ง์ด ๋ค์ด๊ฐ๊ณ ๋๋ถ๋ถ์ ์ฌ๋์ด ์์ฑํ instruction์ ์ ๋ช ํ NLP task์ ๋ํ ๊ฒ์ด ๋ง๊ธฐ ๋๋ฌธ์ ๋ค์์ฑ์ ์ ์ฝ์ ๋ฐ๋๋ค. ์ด๋ฌํ ์ ์ฝ ํด๊ฒฐ์ ์ํด instruction-tuned ๋ชจ๋ธ์ ํ๋ฆฌํฐ๋ฅผ ๊ณ์์ ์ผ๋ก ๊ฐ์ ํ๊ธฐ ์ํด ๋์์ด ๋๋ approach์ ๊ฐ๋ฐ์ด ํ์ํ๋ค.
์ด ๋ ผ๋ฌธ์์๋ ๋ชจ๋ธ ์์ ์ผ๋ก๋ถํฐ ๋์จ instruction signal์ ์ฌ์ฉํด์ PLM์ instruction-tune ํ๊ธฐ ์ํ ๋ฐ์๋ ํ๋ก์ธ์ค์ธ Self-Instruct๋ฅผ ์๊ฐํ์๋ค. ์ ๋ฐ์ ์ธ ํ๋ก์ธ์ค๋ ๋ฐ๋ณต์ bootstrapping ์๊ณ ๋ฆฌ์ฆ์ธ๋ฐ, ์ด ํ๋ก์ธ์ค๋ ์๋์ผ๋ก ์์ฑ๋ instruction์ ํ์ ๋ seed set์์ ์์ํด์ ์ ๋ฐ์ ์ธ ์์ฑ์ ๊ฐ์ด๋ํ๊ธฐ ์ํด ์ฌ์ฉ๋๋ค.
- ์ task์ ๋ํด instruction์ ์์ฑํ๋๋ก ๋ชจ๋ธ์ ์ด์งํ๋ค. ์ด ๋จ๊ณ๋ ๊ธฐ์กด instruction ๋ชจ์์ ํ์ฉํด์ ๋์ฑ ๊ด๋ฒ์ํ instruction์ ์์ฑํ๊ฒ ๋์์ค๋ค.
- ์๋กญ๊ฒ ์์ฑ๋ instruction ์ธํธ๊ฐ ์ฃผ์ด์ง๋ฉด, ํ๋ ์์ํฌ๋ instruction tuning์ ์ง๋ํ๊ธฐ ์ํด ๋์ค์ ์ฌ์ฉ๋๋ ์ด๋ฅผ ์ํ input-output instance๋ฅผ ์์ฑํ๋ค.
- ๋ง์ง๋ง์ผ๋ก low-quality & ๋ฐ๋ณต๋ instruction์ ๊ฐ์ง์น๊ธฐ ์ํ ๋ค์ํ ๋ฐฉ๋ฒ์ด ์ฌ์ฉ๋๋ค.
์ด๋ฌํ ๊ณผ์ ์ด ๋ง์ ์์ task๋ฅผ ์ป๊ฒ ๋ ๋๊น์ง ๋ฐ๋ณต๋๋ค.
์ด ๋ชจ๋ธ์ ๋ํ ๋ฐ๋ณต์ ์ธ Self-Instruct ํ๋ก์ธ์ค๋ ๋ค์๊ณผ ๊ฐ์ ํน์ง์ ๊ฐ๋๋ค.
- 52k instructions + 82k input & target output
- generated data๋ ๋ค์ํ ์ฐฝ์์ task๋ฅผ ํฌํจ
- 50% ์ด์์ instruction์ด seed set์ instruction๊ณผ์ overlap์ด 0.3 ์ดํ์ ROUGE-L ๊ฐ์ ๊ฐ์ง
์ด๋ ๊ฒ ํด์ ๊ฒฐ๊ณผ๋ก ๋์จ ๋ฐ์ดํฐ์ ๋ํด GPT3๋ฅผ fine-tune ํจ์ผ๋ก์จ GPT3(Self-Inst)๋ฅผ ๋ง๋ค ์ ์์๋ค. ๊ทธ๋ฆฌ๊ณ ์ด ๋ชจ๋ธ์ ๊ธฐ์กด์ ๋ชจ๋ธ๋ค๊ณผ ๋น๊ตํด์ ๋ ๋ฐ์ด๋ ์ฑ๋ฅ์ ๋ณด์ฌ์คฌ๋๋ฐ, ์ด ๋ถ๋ถ์ ๊ดํด์๋ ๋์ค์ ์คํ ๋ถ๋ถ์์ ๋์ฑ ์์ธํ๊ฒ ์์๋ณด๋๋ก ํ๊ฒ ๋ค.
์์ฝํด์ ์ด ๋ ผ๋ฌธ์ contribution์ ๋ค์๊ณผ ๊ฐ๋ค.
- ์ต์ํ์ human-labeled data๋ฅผ ์ฌ์ฉํ๋ instruction following ๋ฅ๋ ฅ์ ๋ํ method์ธ Self-Instruct ์ ์
- ๊ด๋ฒ์ํ instruction-tuning ์คํ์ ํตํด Self-Instruct์ ํจ๊ณผ ์ค๋ช
- 52k ๊ฐ์ instruction์ ๊ฐ๋ ๊ฑฐ๋ ํตํฉ ๋ฐ์ดํฐ์ ๊ณต๊ฐ & ํฅํ instruction-following ๋ชจ๋ธ์ ๋ง๋ค๊ณ ํ๊ฐํ๊ธฐ ์ํ ์์ ์์ฑ๋ ์๋ก์ด task set ๊ณต๊ฐ
2. Methods
๋๊ท๋ชจ instruction data๋ฅผ ๊ฒ์ฌํ๋ ๊ฑด ์ฌ๋์๊ฒ ์ด๋ ค์ด ์ผ์ด๋ค. ์๋ํ๋ฉด 1) ์๋ก์ด task์ ๋ํด์ ์ฐฝ์์ฑ์ ๊ฐ์ง๊ณ instruction์ ์ ์, 2) ๊ฐ task์ ๋ํด labeled instance๋ฅผ ์์ฑํ ์ ์๋ ์ ๋ฌธ ์ง์์ด ํ์ํ๊ธฐ ๋๋ฌธ์ด๋ค. ์ด ์น์ ์์๋ Self-Instruct๋ฅผ ์ํ ํ๋ก์ธ์ค์ ๋ํ ์ผ์ ์ค๋ช ํ๋๋ก ํ๊ฒ ๋ค. Self-Instruct๋ vanilla pre-training language model์ ์ฌ์ฉํด์ task๋ฅผ ์์ฑํ๋ ํ์ดํ๋ผ์ธ์ผ๋ก instruction์ ์์ฑํด์ ์ด๋ ๊ฒ ์์ฑ๋ ๋ฐ์ดํฐ๋ก LM์ด instruction์ ๋์ฑ ์ ๋ฐ๋ฅด๋๋ก instruction tuning์ ์ํํ๋ค. ์ด ํ์ดํ๋ผ์ธ์ ๋ค์์ ๊ทธ๋ฆผ 1์ ๋ฌ์ฌ๋์ด ์๋ค.
2-1. Defining Instruction Data
๋ ผ๋ฌธ์์ ์์ฑํ๊ณ ์ ํ๋ instruction data๋ instruction set $\left\{ I_{t}\right\}$๋ก ์ฌ๊ธฐ์ ๊ฐ๊ฐ์ ๊ฐ์ task $t$๋ฅผ ์์ฐ์ด๋ก ์ ์ํ๋ค. ๊ทธ๋ฆฌ๊ณ ๊ฐ๊ฐ์ task๋ ํ๋ ๋๋ ๋ ๋ง์ input-output instances $(X_{t}, Y_{t})$๋ฅผ ๊ฐ์ง๋ค. ๋ชจ๋ธ $M$์ task instruction $I_{t}$์ instance input $x$๊ฐ ์ฃผ์ด์ง๋ฉด, output $y$๋ฅผ ์์ฑํ๋ค: $(x, y) \in (X_{t}, y_{t})$์ ๋ํด $M(I, x) = y$. ๊ทธ๋ ์ง๋ง instruction๊ณผ instance input ๊ฐ์๋ ์๊ฒฉํ ๊ฒฝ๊ณ๊ฐ ์๋ ๊ฒฝ์ฐ๊ฐ ๋ง๋ค. ๋ฐ์ดํฐ ํ์์ ๋ค์์ฑ์ ์ด์งํ๊ธฐ ์ํด ์ถ๊ฐ์ input์ ํ์๋ก ํ์ง ์๋ ์ด๋ฌํ instruction์ ํ๋ฝํด ์ค๋ค.
2-2. Automatic Instruction Data Generation
instruction data๋ฅผ ์์ฑํ๊ธฐ ์ํ ํ์ดํ๋ผ์ธ์ ์ด 4๊ฐ์ ๋จ๊ณ๋ก ๊ตฌ์ฑ๋์ด ์๋ค. ์ด ๋จ๊ณ๋ค์ ์์ธํ๊ฒ ์์๋ณด๋๋ก ํ์.
Instruction Generation. ๋ ผ๋ฌธ์์๋ ๋ค์ํ instruction set๋ฅผ bootstrapping ๋ฐฉ์์ผ๋ก ์์ฑํ๋ ๋ฐฉ๋ฒ์ธ Self-Instruct๋ฅผ ์ ์ํ๋ค. task pool์ author๋ค์ ์ํด ์์ฑ๋ 175๊ฐ์ task๋ก ์ด๊ธฐํํ์๋ค(๊ฐ task์ ๋ํด 1 instruction & 1 instance). ๋ชจ๋ ์คํ ์ ๋ํด ์ด task pool์ in-context example๋ก ํด์ 8๊ฐ์ task instruction์ ์ํ๋งํ๋ค. → ๋ค์์ฑ ์ฆ์ง์ ์ํด 6 human-written tasks + ์ด์ ์คํ ์ 2 model-generated tasks.
Classification Task Identification. ์ด๋ฅผ ์งํํ๋ ์ด์ ๋ classification๊ณผ non-classification task์ ๋ํ 2๊ฐ์ง์ ์๋ก ๋ค๋ฅธ approach๊ฐ ํ์ํ๊ธฐ ๋๋ฌธ์ด๋ค. ์ด ๊ณผ์ ์์๋ ์์ฑ๋ instruction์ด classification์ธ์ง ์๋์ง ํ๋ณํ๋ค. ๊ทธ๋ค์์ 12 classification instruction & 19 non-classification instruction์ ์ฌ์ฉํด์ vanilla GPT3 few-shot์ด ์ด๋ฅผ ๊ฒฐ์ ํ๋๋ก ํ๊ฒ ํ๋ค.
Instance Generation. instruction & task ์ ํ์ด ์ฃผ์ด์ง๋ฉด ๊ฐ instruction์ ๋ํ instance๋ฅผ ๋ ๋ฆฝ์ ์ผ๋ก ์์ฑํ๋ค. ์ด๊ฒ์ด ์ด๋ ค์ด ์ด์ ๋ instruction์ ๊ธฐ๋ฐํด์ ๋ชจ๋ธ์ด ํ๊น task๊ฐ ๋ฌด์์ธ์ง ์ดํดํด์ผ ํ๊ณ , ์ด๋ค ์ถ๊ฐ์ input ํ๋๊ฐ ํ์ํ์ง ์์๋ด์ผ ํ๊ณ , output๋ฅผ ์ถ๋ ฅํจ์ผ๋ก์จ task๋ฅผ ์ต์ข ์ ์ผ๋ก ์๋ฃํ ์ ์์ด์ผ ํ๊ธฐ ๋๋ฌธ์ด๋ค. ๋ ผ๋ฌธ์์๋ PLM์ด ๋ค๋ฅธ task๋ก๋ถํฐ instruction-input-output in-context example๋ก๋ถํฐ prompt ๋ ๋ ์ด๋ฅผ ์ฑ์ทจํ ์ ์๋ค๋ ๊ฒ์ ๋ฐ๊ฒฌํ์๋ค. ์ด๋ฅผ ์ํ ๋ ๊ฐ์ง ๋ฐฉ๋ฒ์ด ์๋๋ฐ ํ๋์ฉ ์ดํด๋ณด๊ฒ ๋ค.
- Input-first Approach: LM์๊ฒ instruction์ ๋ฐ๋ผ ๋จผ์ input ํ๋๋ฅผ ์ ์ํ ๋ค์ ํด๋น ์ถ๋ ฅ์ ์์ฑํ๋๋ก ์์ฒญํ ์ ์๋ค. ์ด ์์ฑ ์์๋ ๋ชจ๋ธ์ด instruction ๋ฐ input์ ์๋ตํ๋ ๋ฐ ์ฌ์ฉ๋๋ ๋ฐฉ์๊ณผ ์ ์ฌํ์ง๋ง ์ฌ๊ธฐ์๋ ๋ค๋ฅธ task์ in-context example์ ์ฌ์ฉํ๋ค. ๊ทธ๋ ์ง๋ง ์ด ๋ฐฉ์์ ํ๋์ ๋ผ๋ฒจ์ ๋ํด ํธํฅ๋ input์ ์์ฑํ ์ ์๋ค. ํนํ ๋ถ๋ฅ task์ ๋ํด์ ๋ง์ด๋ค. ๊ทธ๋์ ๋ถ๋ฅ task๋ฅผ ์ํ ๋ ๋ค๋ฅธ ๋ฐฉ๋ฒ์ด ์ ์๋๋ค.
- Output-first Approach: ๊ฐ๋ฅํ ํด๋์ค ๋ผ๋ฒจ์ ์์ฑํ๊ณ ๊ฐ๊ฐ์ ํด๋์ค ๋ผ๋ฒจ์ input์ ์์ฑ์ ์กฐ์ ํ๋ค.
Input-first Approach์ Output-first Approach๊ฐ ์ฌ์ฉ๋๋ ๊ฒฝ์ฐ๋ฅผ ๊ตฌ๋ถํด ๋ณด๋ฉด ๋ค์๊ณผ ๊ฐ๋ค.
- output-first approach: classification tasks
- input-first approach: non-classification tasks
Filtering & Postprocessing. ๋ค์์ฑ์ ์ํด ROGUE-L์ด ๊ธฐ์กด instruction์ 0.7๋ณด๋ค ์ ์ ๋ ์๋ก์ด instruction์ task pool์ ์ถ๊ฐํ๋ค. ๋ํ LM์ ์ํด ์ฒ๋ฆฌํ ์ ์๋ ๊ตฌ์ฒด์ ์ธ ํค์๋(ex. ์ด๋ฏธ์ง, ๊ทธ๋ํ, ํ)๋ฅผ ํฌํจํ๊ณ ์๋ instruction์ ์ ์ธํ๋ค. ๊ทธ๋ฆฌ๊ณ ๊ฐ instruction์ ๋ํ ์๋ก์ด instance๋ฅผ ์์ฑํ ๋, ์์ ํ ๋๊ฐ์ instance๋ ์ ๋ ฅ์ ๊ฐ์ง๋ง ๋ค๋ฅธ output์ ๊ฐ์ง๋ instance๋ ํํฐ๋งํด์ ๊ฑธ๋ฌ๋ธ๋ค.
2-3. Fine-tuning the LM to Follow Instructions
๋๊ท๋ชจ instruction ๋ฐ์ดํฐ ์์ฑ ํ์ ์ด ๋ฐ์ดํฐ๋ฅผ ๊ธฐ์กด LM์ fine-tune ํ๋ ๋ฐ ์ฌ์ฉํ๋ค. ์ด๋ฅผ ์ํด instruction & instance input์ ์ฐ๊ฒฐํด์ prompt๋ก ๋ง๋ค๊ณ ๋ชจ๋ธ์ด instance output์ ๋ง๋ค๋๋ก ํ์ต์ํจ๋ค. ๊ทธ๋ฆฌ๊ณ ๋ชจ๋ธ์ด ์๋ก ๋ค๋ฅธ ํ์์ ๋ํด robust ํ๊ฒ ๋ง๋ค๊ธฐ ์ํด ๋ค์ํ template์ ์ฌ์ฉํ๋ค.
3. Self-Instruct Data from GPT3
์ด ์น์ ์์๋ Self-Instruct๋ก๋ถํฐ ๋ง๋ค์ด์ง ๋ฐ์ดํฐ์ ๋ํ ๊ฐ์๋ฅผ ๋ณด์ฌ์ค๋ค.
3-1. Statistics
ํ 1์ ์์ฑ๋ ๋ฐ์ดํฐ์ ํต๊ณ๋ฅผ ๋ณด์ฌ์ฃผ๊ณ ์๋ค. ๋ ผ๋ฌธ์์๋ 52k ๊ฐ ์ด์์ instruction์ ์์ฑํ๊ณ , 82k ๊ฐ ์ด์์ instance๋ฅผ ์์ฑํ์๋ค. ์ด ์๋ ํํฐ๋ง์ ๊ฑฐ์น๊ณ ๋จ์ instruction๊ณผ instance์ ์์ด๋ค.
3-2. Diversity
์ด๋ค ์ ํ์ instruction์ด ์์ฑ๋์๋์ง์ ์ผ๋ง๋ ๋ค์ํ ์ง ์ฐ๊ตฌํ๊ธฐ ์ํด ์์ฑ๋ instruction์์ verb-noun ๊ตฌ์กฐ๋ฅผ ํ๋ณํ์๋ค. ๊ฐ์ฅ ํํ๊ฒ ๋ํ๋ 20๊ฐ์ verb root์ ์ด๋ค์ 4๊ฐ์ direct noun object๋ฅผ ๊ทธ๋ฆผ 2์์ ๋ฌ์ฌํ๊ณ ์๋ค. ์ ๋ฐ์ ์ผ๋ก ๋ค์ ๋ค์ํ ์๋์ ํ ์คํธ ํ์์ด instruction์ ๋ํ๋ ์๋ค.
๋ ผ๋ฌธ์์๋ ์ถ๊ฐ์ ์ผ๋ก ์์ฑ๋ instruction์ด seed instruction๊ณผ ์ผ๋ง๋ ๋ค๋ฅธ์ง ์ฐ๊ตฌํ์๋ค. ์ด๋ฅผ ์ํด ์์ฑ๋ ๊ฐ instruction์ ๋ํด 175๊ฐ์ seed instruction์ ๋ํด ๊ฐ์ฅ ์ข์ TOGUE-L ์ค๋ฒ๋ฉ์ ๊ณ์ฐํ์๋ค. ROUGE-L score์ ๋ถํฌ๊ฐ ๊ทธ๋ฆผ 3์ ๋ํ๋ ์๋ค. ์ด ๋ถํฌ๋ฅผ ์ดํด๋ณด๋ฉด ๊ด์ฐฎ์ ์์ ์๋ก์ด instruction์ด seed์ ๋ง์ ์ค๋ฒ๋ฉ์ ๊ฐ์ง์ง ์๊ณ ์์์ ์ ์ ์๋ค. ๋ํ instruction์ ๊ธธ์ด, instance input, instance output์ ๋ํ ๋ค์์ฑ์ ๊ทธ๋ฆผ 4์์ ์ค๋ช ํ๊ณ ์๋ค.
3-3. Quality
generated instruction์ ํ๋ฆฌํฐ๋ฅผ ๊ฒ์ฌํ๊ธฐ ์ํด ์ด 200๊ฐ์ instruction์ ๋๋ค ํ๊ฒ ์ํ๋งํ๊ณ instruction ๋น ํ๋์ instance๋ฅผ ๋๋คํ๊ฒ ์ ํํ๋ค. ๊ทธ๋ค์์ expert annotator์๊ฒ instruction์ ๋ํด ๊ฐ instance๊ฐ ์๋ง์์ง ์๋์ง๋ฅผ ๋ฌผ์ด๋ณธ๋ค. ํ 2์์์ ํ๊ฐ ๊ฒฐ๊ณผ๋ ๋๋ถ๋ถ์ generated instruction์ด ์๋ฏธ๊ฐ ์์ง๋ง, ๋ฐ๋ฉด์ generated instance๋ ๋ ๋ง์ noise๋ฅผ ํจ์ ํ๊ณ ์์ ์๋ ์๋ค๊ณ ๋ณด์ฌ์ค๋ค. ํ์ง๋ง ๋ ผ๋ฌธ์์๋ error๊ฐ ์์ฌ ์์ด๋ ๋๋ถ๋ถ์ ๊ฒ๋ค์ ์๋ง์ ํ์ ๋๋ ๋ถ๋ถ์ ์ผ๋ก ์๋ง์ ํ์์ด๋ผ๊ณ ์ฃผ์ฅํ์๋ค. ์ด๋ ๋ชจ๋ธ์ด instruction ๋ฐ๋ฅด๋๋ก ํ์ต์ํฌ ๋ ์ ์ฉํ ์งํ๋ฅผ ์ ๊ณต ๊ฐ๋ฅํ๊ฒ ํด ์ค๋ค.
4. Experimental Results
๋ค์ํ instruction tuning ์ ์ ์์ ๋ชจ๋ธ์ ํ๋ฆฌํฐ๋ฅผ ๋น๊ตํ๊ณ ์ธก์ ํ๊ธฐ ์ํ ์ฌ๋ฌ ๊ฐ์ง ์คํ์ ์งํํ์๋ค.
4-1. GPT3(Self-Inst): fine-tuning GPT3 on its own instruction data
instruction-generated instruction ๋ฐ์ดํฐ์ ํจ๊ป, ๋ ผ๋ฌธ์์๋ GPT3 ๋ชจ๋ธ ์์ ์ ๋ํด instruction tuning์ ์งํํ์๋ค. 2-3์์ ์ค๋ช ํ๋ ๊ฒ์ฒ๋ผ instruction๊ณผ input์ ์ฐ๊ฒฐํ๊ธฐ ์ํด ๋ค์ํ template์ ์ฌ์ฉํ์๊ณ output์ ์์ฑํ๊ธฐ ์ํด ๋ชจ๋ธ์ ํ์ต์์ผฐ๋ค.
4-2. Baselines
Off-the-shelf language models. ์ด baseline๋ค์ off-the-shelf LM์ด pre-training ์งํ์ instruction์ ๋ฐ๋ฅผ ์ ์๋์ง๋ฅผ ๋ํ๋ผ ๊ฒ์ด๋ค. T5-LM & GPT3๋ฅผ ํ๊ฐํ์๋ค.
Publicly-available instruction-tuned models. T0๊ณผ Tk-Instructe๋ 2๊ฐ์ instruction-tuned model์ด๊ณ , ์ด๋ค์ ๋ง์ NLP task์ ๋ํด instruction์ ๋ฐ๋ฅผ ์ ์๋ค. ์ด ๋ ๋ชจ๋ธ์ T5๋ก๋ถํฐ fine-tune ๋์๊ณ , ๋ ๋ค publicly available ํ๋ค.
Instruction-tuned GPT3 models. InstructGPT๋ ํ๊ฐํ์๋ค. SuperNI ์คํ์ ๋ํด์๋ text-davinci-001๋ง ์ฌ์ฉํ์๋๋ฐ, ์ต์ ๋ฒ์ ๋ค์ ์ต๊ทผ์ ์ ์ ๋ฐ์ดํฐ๋ก ํ์ต๋์ด SuperNI์ ํ๊ฐ ์ธํธ๋ฅผ ์ด๋ฏธ ๋ดค์ ์๋ ์๊ธฐ ๋๋ฌธ์ด๋ค.
์ถ๊ฐ์ ์ผ๋ก Self-Instruct training์ ๋ค๋ฅธ publicly available instruction tuning data์ ๋น๊ตํ๊ธฐ ์ํด PromptSource(T0)์ SuperNI(Tk-Instruct)๋ก๋ถํฐ์ ๋ฐ์ดํฐ๋ฅผ ์ฌ์ฉํ์ฌ GPT3 ๋ชจ๋ธ์ ์ถ๊ฐ์ ์ผ๋ก fine-tune ํ์๋ค.
4-3. Experiment 1: Zero-shot Generalization on SuperNI benchmark
๋ ผ๋ฌธ์์๋ ์ฒ์์ zero-shot ๋ฐฉ์์ผ๋ก ์ ํ์ ์ธ NLP task์ ๋ํ instruction์ ๋ฐ๋ฅด๊ธฐ ์ํ ๋ชจ๋ธ์ ๋ฅ๋ ฅ์ ํ๊ฐํ์๋ค. ์ด๋ฅผ ์ํด ๊ฐ task ๋น 100๊ฐ์ instance๋ก ์ด๋ฃจ์ด์ง 119๊ฐ์ task๋ก ๊ตฌ์ฑ๋์ด ์๋ SuperNI ํ๊ฐ ์ธํธ๋ฅผ ์ฌ์ฉํ์๋ค. ์ด ์คํ์์ ์ฃผ๋ก zero-shot ์ ์ ์ ์ง์คํ์๋๋ฐ, ๋ชจ๋ธ์ ์ค์ง task์ ์ค๋ช ๋ง ์ฃผ์ด์ง๋ค.
Results. ๋ ผ๋ฌธ์์๋ ํ 3์ ๊ฒฐ๊ณผ๋ก๋ถํฐ ๋ค์์ ํด์์ ์ป์ ์ ์์๋ค. Self-Instruct๋ GPT3์ instruction-following ๋ฅ๋ ฅ์ ํฅ์์์ผฐ๋ค. SuperNI์์ ํ์ต๋์ง ์์ ๋ค๋ฅธ ๋ชจ๋ธ๊ณผ ๋น๊ตํด์ GPT3(Self-Inst)๋ ์ข์ ์ฑ๋ฅ์ ๋ณด์ฌ์คฌ๋ค. ๊ทธ๋ฆฌ๊ณ private user data์ human-annotated ๋ผ๋ฒจ์ ์ฌ์ฉํด์ ํ์ต๋ InstructGPT-001๊ณผ ๊ฑฐ์ ๋ง๋จน๋ ์ฑ๋ฅ์ ๋ณด์ฌ์คฌ๋ค.
SuperNI training set์์ ํ์ต๋ ๋ชจ๋ธ์ ํ๊ฐ ์ธํธ์์ ์ข์ ์ฑ๋ฅ์ ๋ณด์ฌ์ฃผ์ง๋ง, Self-Instruct๋ SuperNI training set์ ํจ๊ปํ ๋ ์์ง ์ถ๊ฐ์ ์ธ ์ฑ๋ฅ ํฅ์์ ๊ฐ์ ธ์จ๋ค๋ ๊ฒ์ ๋ณด์ฌ์ฃผ๊ณ ์๋ค.
4-4. Experiment 2: Generalization to User-oriented Instructions on Novel Tasks
SuperNI๊ฐ ๊ด๋ฒ์ํ NLP task๋ฅผ ํฌํจํจ์๋ ๋ถ๊ตฌํ๊ณ ๋๋ถ๋ถ์ NLP task๋ค์ ์ฐ๊ตฌ ๋ชฉ์ ์ผ๋ก ์ ์๋๊ณ classification์ ๋ํด ์๊ณก๋์ด ์๋ค. instruction-following ๋ชจ๋ธ์ ํ์ค์ ์ธ ๊ฐ์ ๋์ฑ ์ ์ ๊ทผํ๊ธฐ ์ํด author์ ์๋ธ์ ์ user-oriented ์์ฉ์ ์ํด ์๊ฐ์ ๋ฐ์ ์๋ก์ด instruction์ ์ธํธ๋ฅผ ์ฒด๊ณํํ๋ค. ๋ ผ๋ฌธ์์๋ ์ฒ์์ LLM์ด ์ ์ฉํ ๊ฒ ๊ฐ์ ๋๋ฉ์ธ์ ๋ํด ๋ธ๋ ์ธ ์คํฐ์ ํ์๊ณ , ๊ทธ๋ค์์ ๊ฐ๊ฐ ๋๋ฉ์ธ๊ณผ ํจ๊ป input-output instance์ ๊ด๋ จ๋ instruction์ ๋ง๋ค์๋ค. ๋ ผ๋ฌธ์์๋ ์ด๋ฌํ task์ ์คํ์ผ๊ณผ ํฌ๋งท์ ๋ค์ํํ๋๋ก ํ์๋ค. ์ข ํฉ์ ์ผ๋ก 252๊ฐ์ instruction์ ์์ฑํ์๊ณ , instruction ๋น ํ๋์ instance๋ฅผ ์์ฑํ์๋ค. ๋ ผ๋ฌธ์์๋ ์ด๊ฒ์ด instruction-based ๋ชจ๋ธ์ด ์ด๋ป๊ฒ ๋ค์ํ๊ณ ์น์ํ์ง ์์ instruction์ ๋ค๋ฃจ๋์ง๋ฅผ ํ๊ฐํ๋ testbed๋ก ์ฌ์ฉ๋๋ค.
Human evaluation setup. ๋ชจ๋ธ์ ์ฑ๋ฅ์ ์ด๋ฌํ ๋ค์ํ task์ ์ธํธ์์ ํ๊ฐํ๋ ๊ฒ์ ์๋ก ๋ค๋ฅธ task์ ๋ํด ์๋ก ๋ค๋ฅธ ์ ๋ฌธ๊ฐ๋ฅผ ํ์๋ก ํ๊ธฐ ๋๋ฌธ์ ์ด๋ ต๊ฒ ์ฌ๊ฒจ์ง๋ค. ์ฌ์ค์ ๋ง์ ์ด๋ฌํ task๋ค์ ์๋ํ๋ metric์ด๋ ์ผ๋ฐ์ ์ธ crowdworker๋ก๋ถํฐ ํ๊ฐ๋ ์ ์๋ค. ๋์ฑ ์ ๋ขฐํ ์ ์๋ ํ๊ฐ๋ฅผ ์ป๊ธฐ ์ํด, ๋ ผ๋ฌธ์์๋ ๋ชจ๋ธ์ ์์ธก์ ํ๋จํ๊ธฐ ์ํด instruction์ author์ ๋ฌผ์ด๋ณด์๋ค. ํ๊ฐ์๋ค์ output์ด task๋ฅผ ์ ํํ๊ณ ํจ๊ณผ์ ์ผ๋ก ์๋ฃํ๋์ง์ ๊ธฐ๋ฐํด์ ํ๊ฐ๋ฅผ ํ๋ค. ๋ ผ๋ฌธ์์๋ ๋ชจ๋ธ์ output์ ํ๋ฆฌํฐ๋ฅผ ํ๊ฐํ๊ธฐ ์ํ 4-๋ ๋ฒจ ํ๊ฐ ์์คํ ์ ๋ง๋ค์๋ค.
- Rating-A: ์๋ต์ด ์ ํจํ๊ณ ๋ง์กฑ์ค๋ฌ์ด์ง ํ๊ฐ
- Rating-B: ์๋ต์ ๋ฐ์๋ค์ฌ์ง์ง๋ง ๊ฐ์ ๋ ์ ์๋ ์ฌ์ํ ๊ฒฐํจ์ ๊ฐ์ง
- Rating-C: ์๋ต์ ์ฐ๊ด๋์ด ์๊ณ instruction์ ์๋ต์ ํ์ง๋ง, ๋ด์ฉ์ ์ฌ๊ฐํ ์ค๋ฅ๋ฅผ ๊ฐ์ง
- Rating-D: ์๋ต์ด ๊ด๋ จ ์๊ฑฐ๋ ์ ํจํ์ง ์์. input์ ๋ฐ๋ณตํ๊ณ ์ข ํฉ์ ์ผ๋ก ๊ด๋ จ ์๋ output
Results. ๊ทธ๋ฆผ 5๋ GPT3 ๋ชจ๋ธ์ ์ฑ๋ฅ๊ณผ ์๋กญ๊ฒ ์ฐ์ธ instruction set์์ instruction-tune ๋ counterpart๋ฅผ ์ ๊ณตํ์๋ค. ์์ํ๋ ๊ฒ์ฒ๋ผ vanilla GPT3 LM์ ์ฃผ๋ก instruction์ ์๋ตํ์ง ๋ฉํ๊ณ , ๋ชจ๋ instruction-tuned ๋ชจ๋ธ์ ๋น๊ต์ ๋์ ์ฑ๋ฅ์ ๋ณด์ฌ์ค๋ค. noise์๋ ๋ถ๊ตฌํ๊ณ ์์ฑ๋ ๋ฐ์ดํฐ์ ๊ฐ์น๋ฅผ ๋ณด์ฌ์ฃผ๋ฉด์, GPT3(Self-Inst)๋ T0 ๋๋ SuperNI์์ ํ์ต๋ counterpart๋ฅผ ํฐ ๋ง์ง์ผ๋ก ๋ฅ๊ฐํ์๋ค. InstructGPT-001๊ณผ ๋น๊ตํด์ GPT3(Self-Inst)๋ ๋งค์ฐ ๊ทผ์ ํ ์ฑ๋ฅ์ ๋ณด์ฌ์คฌ๋ค. ์ด๋ฌํ ์ฑ๊ณต์๋ ๋ค์ํ ์์ธ์ด ์จ์ด์์ง๋ง, ๋ ผ๋ฌธ์์๋ ํฅํ ์ฐ๊ตฌ์์ ๋ชจ๋ธ๋ค์ด generated data๋ฅผ ํ์ฉํด์ ์ฑ๋ฅ์ ๊ฐ์ ์ํค์ง ์์๊น๋ผ๊ณ ์ถ์ธกํ๋ค.
4-5. Example Predictions from GPT3(Self-Inst)
ํ 4์์ user-oriented task์ ์ ํ๊ณผ ์ด์ ํด๋นํ๋ GPT3(Self-Inst)-produced ์๋ต๊ณผ annotator ํ๊ฐ๋ฅผ ๋ํ๋ด์๋ค. ๋ ๋ฒจ 2๋ก ํ๊ฐ๋ ์๋ต์์ ๋ชจ๋ธ์ ์ต์ข output์ด ํ๋ ธ์์๋ ๋ถ๊ตฌํ๊ณ task๋ฅผ ํด๊ฒฐํ๋ ๊ด๋ฒ์ํ ์คํ ์ ์ค๋ช ํ์๋ค.
5. Discussion & Limitation
5-1. Why does Self-Instruct work?
์ต๊ทผ instruction-tuned LM์ ์ฑ๊ณต์ ๊ฐ๋ฅํ๊ฒ ํ๋ ๋ฐ ์์ด ๊ณ ํ์ง์ human feedback์ด ์ํํ๋ ์ญํ ์ ๋ํด ์๊ฐํด ๋ณผ ๊ฐ์น๊ฐ ์๋ค. ์ฌ๊ธฐ์๋ ๋ ๊ฐ์ง ๊ฐ์ค์ด ์๋ค:
- ($H_{1}$) human feedback์ LM์ instruction-tuning ์ธก๋ฉด์์ ํ์์ ์ธ๋ฐ, ์ด๋ pre-training ์ค์ ํ์ต๋์ง ์๋ ์ด์์ ๋ํด ํ์ตํ๊ธฐ ์ํด์์ด๋ค.
- ($H_{2}$) human feedback์ ์ ํ์ ์ธ ํ๋ก์ธ์ค๋ผ ์ด๋ค์ pre-training ๋ถํฌ/objective๋ฅผ align ํ๋ ๊ฒ์ ๋ค๋ฅธ ํ๋ก์ธ์ค๋ก ๋์ฒด๊ฐ ๊ฐ๋ฅํ๋ค.
๋ ผ๋ฌธ์์๋ ์ด ๋ ๊ฐ์ ๊ฐ์ค ์ค์์ ํนํ ํฐ ๋ชจ๋ธ์ ๋ํด $H_{2}$๊ฐ ๋ ๊ฐ๊น๋ค๊ณ ์ถ์ธกํ์๋ค. LM์ด ์ด๋ฏธ language instruction์ ๋ํด ๋ง์ ๊ฒ์ ์๊ณ ์๋ค๋ ์ง๊ฐ์ Self-Instruct๋ฅผ ์ํ ์ค์ํ ๋๊ธฐ์ด๊ณ ์คํ์ ์ฑ๊ณต์ ์ํด ์ง์ง๋ฐ๋๋ค.
5-2. Limitations of Self-Instruct
Tail phenomena. Self-Instruct๋ LM์ ์์กดํ๊ธฐ ๋๋ฌธ์ LM์ด ๊ฐ์ง๋ ๋ชจ๋ ํ๊ณ์ ์ ์์๋ฐ๋๋ค. ํ ๋ง๋๋ก LM์ ํฐ ์ฑ๋ฅ ํฅ์์ ๋ง์ด ์ฌ์ฉํ๋ ์ธ์ด๋ก๋ถํฐ ์ฃผ๋ก ์ค๊ฒ ๋๊ณ , ์์ฃผ ์ฌ์ฉํ์ง ์๋ ์ธ์ด๋ ์ ์ ์ฑ๋ฅ ํฅ์์ ์ป๋๋ค. ์ด์ ์ ์ฌํ๊ฒ ๋๋ถ๋ถ์ ์ฑ๋ฅ ํฅ์์ด Self-Instruct๋ก๋ถํฐ ์ค๋ฉด pre-training corpus์์ ๋์ฑ ์์ฃผ ๋ํ๋๋ instruction์ ์ํฅ์ ๋ฐ๊ฒ ๋๋ค. ๊ฒฐ๊ณผ์ ์ผ๋ก ์ด ๋ฐฉ๋ฒ์ ํํ์ง ์๊ณ ์ฐฝ์์ ์ธ instruction์ ์ทจ์ฝํจ์ ๋ณด์ฌ์ค๋ค.
Dependence on large models. Self-Instruct์ large model์ ๋ํ ์์กด์ฑ ๋๋ฌธ์ ์ ์ computing resource๋ฅผ ๊ฐ๋ ์ฌ๋๋ค์ ์ฌ์ฉ์ ์ฅ๋ฒฝ์ ์์ฑํ ์ ์๋ค.
Reinforcing LM biases. ๋ฐ๋ณต์ ์๊ณ ๋ฆฌ์ฆ์ผ๋ก ์ธํด ์๋์ ๋ค๋ฅด๊ฒ ๋ฌธ์ ๊ฐ ๋๋ social bias๋ฅผ ์ฆ๋์ํค๊ธฐ๋ ํ๋ค. ์ด์ ๊ด๋ จํ์ฌ ์ด ํ๋ก์ธ์ค์์ ๊ด์ฐฐ๋ ๋ฌธ์ ์ค ํ๋๋ ๋ชจ๋ธ์ ์ด์ bias๋ฅผ ๋ฐ์ํ ๊ท ํ ์กํ ๋ผ๋ฒจ์ ์์ฑํ๋ ์๊ณ ๋ฆฌ์ฆ์ ์ด๋ ค์์ด๋ค.
์ถ์ฒ
https://arxiv.org/abs/2212.10560