💡 왼쪽 원문을 읽으면서 오른쪽에 따라 써보세요. Tab 키로 힌트를 받을 수 있습니다.

원문 렌더가 준비되기 전까지 텍스트 가이드로 표시합니다.

프롤로그 — 왜 다시 파인튜닝인가

2025년 초까지만 해도 "이제 파인튜닝은 죽었다"는 말이 한 번씩 돌았다. GPT-4o·Claude 3.5·Gemini 1.5가 컨텍스트 1M을 넘기고, RAG와 few-shot으로 거의 모든 일을 풀 수 있어 보였기 때문이다. 그런데 2025년 하반기부터 분위기가 바뀌었다. DeepSeek R1의 GRPO 논문, Meta의 LLaMA 3.3 / 4 출시, 그리고 작은 7B 모델을 도메인에 맞춰 튜닝하면 GPT-4보다 싸고 빠르게 돌릴 수 있다는 사례가 쌓이면서, "파인튜닝은 다시 1순위 도구"로 돌아왔다.

2026년 5월 현재의 풍경은 이렇다.

- 오픈소스 프레임워크가 **Axolotl·Unsloth·LLaMA-Factory·TRL·PEFT·TorchTune** 6강 구도로 정리됐다.

- 클라우드 파인튜닝 API는 **OpenAI·Anthropic·Cohere·Together·Modal** 5개가 사실상의 표준.

- 알고리즘은 SFT(Supervised Fine-Tuning) 위에 **DPO → GRPO → KTO → IPO**가 차례로 올라왔다.

- 분산 학습은 **QLoRA + FSDP + DeepSpeed Zero**가 사실상 표준.

이 글은 12–14개 챕터로 그 지도를 그린다. 누가 무엇을 잘하고, 우리가 어떤 상황에서 무엇을 골라야 하는지를 정리한다.

1장 · 2026년 LLM 파인튜닝 지도 — 3 진영

도구를 한 줄로 늘어놓으면 비교가 어렵다. 3개 진영으로 나눠보자.

| 진영 | 대표 도구 | 주 사용자 |

| --- | --- | --- |

| **오픈소스 프레임워크** | Axolotl, Unsloth, LLaMA-Factory, TRL, PEFT, TorchTune, LLM Foundry | 학술/스타트업/1인 개발자 |

| **클라우드 파인튜닝 API** | OpenAI, Anthropic, Cohere, Together, Modal, Fireworks | 엔터프라이즈/제품팀 |

| **수직 통합 / 파운데이션 랩** | Upstage, Sakana, Mistral, Cohere Labs, OpenAI Custom Models | 연구소/제조사/스타트업 R AND D |

이 분류는 완벽하지 않다. 예컨대 Together는 클라우드 API이면서도 LoRA 파인튜닝을 오픈소스 스택과 거의 동일하게 노출한다. Modal은 클라우드 GPU만 빌려주는 인프라에 가깝다. 그래도 이 3진영을 기억하면 도구 선택의 축이 보인다.

**오픈소스 프레임워크 진영**은 "GPU만 있으면 우리가 다 한다"는 입장이다. Axolotl·Unsloth·LLaMA-Factory가 YAML/config 파일 하나로 학습 파이프라인을 정의하게 해주고, 그 안에서 PEFT(어댑터)·TRL(RL)·Accelerate(분산)가 라이브러리로 호출된다.

**클라우드 API 진영**은 "데이터만 던지면 우리가 GPU·튜닝·서빙까지 다 한다"는 입장이다. OpenAI·Anthropic·Cohere는 자기네 모델만 튜닝할 수 있고, Together·Modal·Fireworks는 오픈 모델(Llama·Qwen·DeepSeek·Mistral)을 튜닝하게 해준다.

**파운데이션 랩 진영**은 자기네 모델을 만들면서, 그 모델 위에 도메인 파인튜닝을 같이 파는 곳들이다. 한국의 Upstage, 일본의 Sakana·ELYZA·PFN, 미국의 Mistral·Cohere가 이 자리에 있다.

2026년 트렌드는 **이 3진영이 서로의 영역으로 침범하는 중**이라는 것이다. OpenAI가 Reinforcement Fine-Tuning(RFT)을 풀고, Anthropic이 Constitutional Finetuning을 노출하고, Together가 자체 클러스터를 키우고, Upstage가 글로벌 시장에 SaaS로 진출하면서 경계가 흐려진다.

2장 · Why finetune? — RAG vs Finetuning vs Few-shot 결정 표

파인튜닝 도구를 보기 전에, "지금 우리가 파인튜닝을 해야 하는가"를 먼저 물어야 한다. 결정 표는 이렇게 그릴 수 있다.

| 상황 | 추천 | 이유 |

| --- | --- | --- |

| 최신 사실/문서가 자주 바뀜 | **RAG** | 인덱스만 갱신, 모델 재학습 불필요 |

| 출력 포맷/스타일이 일관돼야 함 | **Finetuning (SFT)** | 시스템 프롬프트로는 100% 일관성 안 나옴 |

| 특정 도메인 어휘/약어 | **Finetuning (SFT) + RAG** | 모델은 표현, RAG는 사실 |

| 사람 선호 반영 (정중함·안전성) | **DPO / GRPO / KTO** | 페어/스칼라 선호 데이터로 학습 |

| 입력당 비용·지연을 줄여야 함 | **Finetuning (소형)** | 7B 튜닝이 GPT-4 호출보다 싸짐 |

| 1주일 안에 PoC 끝내야 함 | **Few-shot 프롬프팅** | 학습 안 함, 즉시 검증 |

| 코드/수학 처럼 사고가 길어짐 | **GRPO + RL** | 강화학습으로 추론 능력 깊어짐 |

| 데이터가 100건 미만 | **Few-shot 또는 PEFT 작은 r** | 작은 데이터는 LoRA r=4–8로 충분 |

| 데이터가 100k건 이상 | **Full SFT 또는 LoRA r=64+** | 대용량은 풀튠 또는 큰 어댑터 |

| 회사 IP 모델 만들어야 함 | **셀프호스팅 + Axolotl/LLM Foundry** | 모델 가중치 우리가 소유 |

**핵심 원칙 세 가지.**

1. **사실은 RAG, 행동은 파인튜닝.** 모델이 "무엇을 알아야 하는가"는 RAG, "어떻게 행동해야 하는가"는 파인튜닝.

2. **SFT 먼저, RL 나중.** 어떤 RL 알고리즘도 시드 SFT 없이는 잘 안 된다. SFT가 안정 영역으로 끌어다 놓은 다음에 DPO/GRPO/KTO를 얹는다.

3. **작은 모델로 빨리 검증.** 7B 모델 LoRA 튜닝 한 번이 1–2시간이면 끝난다. 작게 빨리 돌려보고, 그 다음에 70B로 키운다.

이 원칙을 갖고 도구로 들어가자.

3장 · PEFT — LoRA / QLoRA / AdaLoRA / IA3 기초

PEFT(Parameter-Efficient Fine-Tuning)는 "전체 가중치를 다 학습하지 말고, 작은 어댑터만 끼워 학습하자"는 아이디어의 총칭이다. 2021년 Microsoft의 LoRA 논문에서 시작해서, 2026년 현재 사실상의 표준이 됐다.

**LoRA(Low-Rank Adaptation).** 큰 가중치 행렬 W에 작은 두 행렬 A·B를 더해서, A·B만 학습한다. r=8/16/32 같은 작은 rank로도 풀튠에 가까운 품질이 나온다는 게 핵심이다. 가중치 갱신량이 1/100–1/1000로 줄어 메모리·디스크가 같이 줄어든다.

**QLoRA.** Tim Dettmers의 2023년 논문. 베이스 모델을 4-bit로 양자화한 채 LoRA만 16-bit로 학습한다. 70B 모델을 단일 A100 80GB 하나에 올려서 튜닝할 수 있게 한 결정적 기법이다. NF4(NormalFloat 4) 양자화 + double quantization + paged optimizer가 핵심.

**AdaLoRA.** rank를 학습 중에 동적으로 조절. 중요한 레이어에 더 큰 r을, 덜 중요한 레이어에 더 작은 r을 자동 배정. Microsoft Research 작업.

**IA3 (Infused Adapter by Inhibiting and Amplifying Inner Activations).** LoRA보다 더 작은 파라미터(레이어당 벡터 3개)만 학습. 100개 미만의 매우 작은 데이터셋에서 LoRA보다 안정적이라고 알려져 있다.

**DoRA (Weight-Decomposed Low-Rank Adaptation).** 2024년 NVIDIA가 제안. 가중치를 magnitude와 direction으로 분해해서 direction만 LoRA로 학습. 풀튠에 더 가까운 품질.

2026년 실무 디폴트는 이렇다.

- **GPU 메모리 빠듯함 / 70B 모델** → QLoRA + r=16, alpha=32.

- **GPU 여유 / 7–13B 모델** → LoRA + r=64, alpha=128.

- **풀튠 가능** → DoRA 또는 풀튠.

- **데이터 100건 미만** → IA3 또는 LoRA r=4.

이 PEFT 라이브러리는 Hugging Face가 만들었고, 거의 모든 프레임워크(Axolotl·Unsloth·LLaMA-Factory·TRL·TorchTune)가 안에서 PEFT를 호출한다. 즉 PEFT는 "토대"이고 위에 프레임워크가 올라간다.

4장 · Axolotl — 가장 인기있는 오픈소스

Axolotl은 OpenAccess AI Collective가 만들기 시작해서, 2024년 회사화(Axolotl AI)된 오픈소스 파인튜닝 프레임워크다. 2025년 시드 라운드를 받았고, GitHub 스타 9천 개를 넘겼다. 한 줄로 표현하면 "YAML config 하나로 LLaMA·Mistral·Qwen·DeepSeek 같은 오픈 모델을 풀튠/LoRA/QLoRA/DPO로 학습하게 해주는 래퍼"다.

**왜 Axolotl이 1등이 됐는가.** 세 가지 결정이 결정적이었다.

1. **YAML config 중심.** 데이터셋·모델·하이퍼파라미터·분산 전략을 하나의 YAML로 묶었다. 명령어 한 줄로 학습이 돈다.

2. **모든 알고리즘 지원.** SFT, LoRA, QLoRA, DPO, ORPO, KTO, GRPO, Reinforcement Learning, Continual Pretraining까지 한 도구로. PEFT·TRL·Accelerate·DeepSpeed를 안에서 다 호출한다.

3. **포맷 자동 변환.** ShareGPT·Alpaca·ChatML·OpenAI 같은 데이터셋 포맷을 자동으로 인식해서 변환해준다.

**기본 사용 예제.**

axolotl-llama3-lora.yml

base_model: meta-llama/Llama-3.1-8B-Instruct

load_in_4bit: true

adapter: qlora

lora_r: 16

lora_alpha: 32

lora_dropout: 0.05

lora_target_modules:

- q_proj

- v_proj

- k_proj

- o_proj

datasets:

- path: tatsu-lab/alpaca

type: alpaca

sequence_len: 4096

val_set_size: 0.05

num_epochs: 3

optimizer: adamw_torch

learning_rate: 0.0002

gradient_accumulation_steps: 4

micro_batch_size: 2

flash_attention: true

deepspeed: deepspeed_configs/zero2.json

이 하나로 LLaMA 3.1 8B를 Alpaca 데이터셋으로 QLoRA 학습한다. 실행은 `axolotl train axolotl-llama3-lora.yml` 한 줄.

**Axolotl이 잘하는 것.**

- **유연성.** Llama·Mistral·Qwen·DeepSeek·Phi·Gemma·Mixtral — 거의 모든 오픈 모델 지원.

- **알고리즘 커버리지.** SFT·DPO·GRPO·KTO·ORPO·CPT(Continual Pretraining)까지. 새 논문 알고리즘이 1–2주 안에 들어온다.

- **커뮤니티.** Discord에 수천 명, 매주 새 PR이 머지된다. NousResearch·DeepSeek 같은 큰 팀이 사용 사례를 공유한다.

**약점.**

- **YAML 디버깅 지옥.** 옵션이 너무 많아서, 한 번 잘못 짜면 에러 메시지가 깊은 스택에서 나온다.

- **메모리 최적화는 Unsloth보다 약하다.** 같은 GPU에서 Axolotl이 OOM 나는 설정도 Unsloth는 돌 때가 많다.

**언제 Axolotl인가.**

- 여러 알고리즘(SFT → DPO → GRPO)을 한 도구에서 비교하고 싶다 → Axolotl.

- 멀티노드 분산 학습이 필요 → Axolotl + DeepSpeed Zero-3.

- 비전 멀티모달 모델 튜닝 (Llava·Qwen-VL) → Axolotl이 빠르게 지원.

5장 · Unsloth — 2배 빠른 QLoRA

Unsloth는 호주의 두 형제 Daniel와 Michael Han이 만든 파인튜닝 라이브러리다. 2024년 시드 라운드를 받았고, GitHub 스타 1.5만 개를 넘었다. 슬로건은 "2x faster, 50% less memory". 실제로 같은 GPU에서 같은 데이터를 학습할 때 Axolotl보다 1.5–2배 빠르고, 메모리를 30–50% 덜 쓴다.

**어떻게 이렇게 빠른가.** Unsloth는 PyTorch의 일반 autograd를 쓰지 않고, 학습 hot path의 핵심 연산(LoRA forward/backward, RoPE, RMSNorm, SwiGLU 등)을 직접 Triton 커널로 작성했다. 메모리 할당도 PyTorch 디폴트보다 공격적으로 재사용한다. **Unsloth Gradient Checkpointing**이라는 자체 구현은 PyTorch 디폴트보다 30% 메모리 절감을 더 한다.

**기본 사용 예제.**

from unsloth import FastLanguageModel

from trl import SFTTrainer

from transformers import TrainingArguments

model, tokenizer = FastLanguageModel.from_pretrained(

model_name="unsloth/llama-3.1-8b-instruct-bnb-4bit",

max_seq_length=4096,

dtype=None,

load_in_4bit=True,

)

model = FastLanguageModel.get_peft_model(

model,

r=16,

target_modules=["q_proj", "k_proj", "v_proj", "o_proj"],

lora_alpha=32,

use_gradient_checkpointing="unsloth",

)

trainer = SFTTrainer(

model=model,

train_dataset=dataset,

tokenizer=tokenizer,

args=TrainingArguments(

per_device_train_batch_size=2,

gradient_accumulation_steps=4,

warmup_steps=10,

num_train_epochs=3,

learning_rate=2e-4,

fp16=not torch.cuda.is_bf16_supported(),

bf16=torch.cuda.is_bf16_supported(),

output_dir="outputs",

)

trainer.train()

Hugging Face TRL의 SFTTrainer를 그대로 쓰는데, 모델 로딩만 Unsloth로 한다. 그래서 기존 TRL 코드와 호환성이 좋다.

**Unsloth가 잘하는 것.**

- **단일 GPU에서 최강.** A100 1장, H100 1장, 심지어 RTX 4090에서도 7–13B 모델 튜닝이 빠르고 안정적.

- **메모리 효율.** 24GB GPU에서 70B QLoRA가 돌아간다. 다른 도구는 OOM 나는 영역.

- **Notebook 친화적.** Colab/Kaggle에서 바로 돌아가는 노트북을 공식으로 제공.

**약점.**

- **멀티 GPU 약함.** 2025년부터 멀티 GPU 지원을 시작했지만 아직 Axolotl만큼 안정적이지 않다. FSDP/DeepSpeed 통합이 부분적이다.

- **모델 커버리지가 좁다.** Llama·Mistral·Qwen·Phi·Gemma·DeepSeek 같은 주류는 다 되는데, 비주류 모델은 직접 패치해야 할 때가 있다.

**언제 Unsloth인가.**

- 1인 개발자, GPU 1장, 노트북/Colab → Unsloth가 사실상 정답.

- 작은 팀, 짧은 사이클(주말 hackathon) → Unsloth가 가장 빠르게 결과를 낸다.

- 멀티노드 학습이 필요 → Axolotl 또는 TorchTune으로.

6장 · LLaMA-Factory — 사용하기 쉬운 중국 발 프레임워크

LLaMA-Factory는 중국 베이항대학(Beihang University) 팀이 시작한 오픈소스 파인튜닝 프레임워크다. 2023년 출시, 2026년 5월 기준 GitHub 스타 4만 5천 개를 넘었다. 영어권에서는 Axolotl보다 덜 알려졌지만, 중국·동아시아 사용자 베이스가 압도적으로 크다.

**왜 LLaMA-Factory인가.** 세 가지 차별점이 있다.

1. **Web UI 제공.** `llamafactory-cli webui` 한 줄이면 브라우저에서 모델·데이터셋·하이퍼파라미터를 선택해서 학습을 시작할 수 있다. CLI/YAML이 부담스러운 사용자에게 가장 친절하다.

2. **방대한 모델 지원.** Llama·Mistral·Qwen·DeepSeek·ChatGLM·Yi·InternLM·Baichuan — 중국 모델 커버리지가 압도적이다.

3. **알고리즘 정합성.** SFT, Reward Model, PPO, DPO, ORPO, KTO, SimPO, BAdam을 한 도구에서. RLHF 풀파이프라인을 가장 간단하게 돌릴 수 있다.

**기본 사용 예제 (CLI).**

llamafactory-cli train \

--stage sft \

--do_train True \

--model_name_or_path meta-llama/Llama-3.1-8B-Instruct \

--dataset alpaca_en \

--template llama3 \

--finetuning_type lora \

--lora_target q_proj,v_proj \

--output_dir saves/llama3-8b/lora/sft \

--overwrite_output_dir True \

--per_device_train_batch_size 2 \

--gradient_accumulation_steps 4 \

--lr_scheduler_type cosine \

--learning_rate 5e-5 \

--num_train_epochs 3.0 \

--warmup_ratio 0.1

이 한 줄이면 LLaMA 3.1 8B를 alpaca로 LoRA SFT 튜닝한다. Web UI에서 같은 옵션을 폼으로 채워도 된다.

**LLaMA-Factory가 잘하는 것.**

- **진입 장벽 최저.** Web UI 덕분에 비개발자도 모델 튜닝을 시도할 수 있다.

- **중국 모델 1순위.** Qwen·DeepSeek·ChatGLM·Yi·InternLM 등은 LLaMA-Factory가 가장 빠르게 지원한다.

- **풀파이프라인 RLHF.** SFT → Reward Model → PPO가 한 도구에서 깔끔하게 흐른다.

**약점.**

- **영어 문서가 얇다.** 코드는 영어인데 issues·discussions가 중국어인 경우가 많다. 영어권 커뮤니티 지원이 Axolotl만큼 두텁지는 않다.

- **새 알고리즘 통합이 보수적.** Axolotl이 1주일 안에 GRPO를 넣었다면, LLaMA-Factory는 보통 2–4주 걸린다.

**언제 LLaMA-Factory인가.**

- 비개발자/연구자가 Web UI로 시작 → LLaMA-Factory.

- Qwen·DeepSeek·ChatGLM 등 중국 모델 튜닝 → LLaMA-Factory.

- 한 번에 SFT + RM + PPO를 학과 과제처럼 비교 → LLaMA-Factory.

7장 · Hugging Face TRL — RL + DPO/GRPO/KTO

TRL(Transformer Reinforcement Learning)은 Hugging Face가 관리하는 RL/선호 최적화 라이브러리다. 2022년 lvwerra의 프로토타입에서 시작해서, 2024년 Hugging Face 메인 라인업으로 들어왔다. 2026년 5월 기준 GitHub 스타 1만 2천 개.

TRL은 "프레임워크"라기보다 "라이브러리"다. Axolotl·Unsloth·LLaMA-Factory가 안에서 TRL을 호출한다. 직접 TRL을 쓰는 건 보통 알고리즘 연구자나 커스텀 학습 루프가 필요한 사람이다.

**TRL이 지원하는 트레이너들.**

| 트레이너 | 알고리즘 | 용도 |

| --- | --- | --- |

| **SFTTrainer** | Supervised Fine-Tuning | 지도학습 (chat/instruction tuning) |

| **RewardTrainer** | Pairwise reward model | RLHF의 RM 단계 |

| **PPOTrainer** | Proximal Policy Optimization | 클래식 RLHF (InstructGPT 스타일) |

| **DPOTrainer** | Direct Preference Optimization | 페어 선호 데이터 직접 학습 |

| **GRPOTrainer** | Group Relative Policy Optimization | DeepSeek R1 스타일 RL |

| **KTOTrainer** | Kahneman-Tversky Optimization | 좋음/나쁨 이진 신호 학습 |

| **ORPOTrainer** | Odds Ratio Preference Optimization | SFT + DPO 합쳐서 한번에 |

| **CPOTrainer** | Contrastive Preference Optimization | DPO 변형, 안정성 강화 |

| **IPOTrainer** | Identity Preference Optimization | DPO의 overfitting 보정 |

**TRL + vLLM의 RL 가속.** 2025년 큰 변화는 TRL에 vLLM 통합이 들어왔다는 점이다. GRPO/PPO는 학습 중에 모델이 응답을 생성해야 하는데(rollout), 기본 transformers 생성은 너무 느리다. vLLM이 그 자리를 채워서 RL 학습이 5–10배 빨라졌다. Axolotl·LLaMA-Factory도 이 통합을 그대로 활용한다.

**기본 사용 예제 (DPO).**

from trl import DPOTrainer, DPOConfig

from transformers import AutoModelForCausalLM, AutoTokenizer

model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-3.1-8B-Instruct")

tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-3.1-8B-Instruct")

trainer = DPOTrainer(

model=model,

args=DPOConfig(

output_dir="dpo-llama",

beta=0.1,

learning_rate=5e-7,

num_train_epochs=1,

per_device_train_batch_size=2,

train_dataset=dataset,

tokenizer=tokenizer,

)

trainer.train()

**언제 TRL을 직접 쓰는가.**

- 새 알고리즘 연구 (자기 논문에 쓰려고) → TRL 직접.

- 커스텀 reward function, 커스텀 rollout → TRL 직접.

- 그냥 LoRA + DPO 학습이 목적 → Axolotl/Unsloth/LLaMA-Factory를 통하면 충분.

8장 · PEFT (HF) — 어댑터 표준

PEFT 라이브러리는 Hugging Face가 관리하는 어댑터 표준이다. LoRA·QLoRA·AdaLoRA·IA3·LoHa·LoKr·OFT·VeRA·DoRA·X-LoRA를 한 인터페이스로 묶었다. 2026년 5월 기준 GitHub 스타 1만 7천 개.

거의 모든 파인튜닝 프레임워크가 안에서 PEFT를 호출한다. Axolotl·Unsloth·LLaMA-Factory·TRL·TorchTune이 자체 LoRA를 따로 구현하지 않고, PEFT를 표준으로 받아쓴다. 즉 어댑터 포맷(`adapter_config.json` + `adapter_model.safetensors`)이 호환되기 때문에, Axolotl로 학습한 LoRA를 vLLM·Unsloth·TGI·Together에서 그대로 로드할 수 있다.

**PEFT의 핵심 추상.**

from peft import LoraConfig, get_peft_model

from transformers import AutoModelForCausalLM

model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-3.1-8B")

config = LoraConfig(

r=16,

lora_alpha=32,

target_modules=["q_proj", "k_proj", "v_proj", "o_proj"],

lora_dropout=0.05,

bias="none",

task_type="CAUSAL_LM",

)

peft_model = get_peft_model(model, config)

peft_model.print_trainable_parameters()

trainable params: 6,815,744 || all params: 8,037,261,312 || trainable%: 0.0848

이 모델을 그대로 TRL의 SFTTrainer/DPOTrainer에 넣으면 LoRA만 학습된다.

**최근 추가.** 2025년 PEFT 0.10대에 들어온 변화는 두 가지다.

1. **VeRA (Vector-based Random Matrix Adaptation).** LoRA보다 10배 적은 파라미터로 비슷한 성능. 다중 task 학습에 적합.

2. **X-LoRA (Mixture-of-Experts LoRA).** 여러 LoRA를 학습해놓고, 입력마다 라우터가 어느 어댑터를 쓸지 결정. 멀티 도메인 모델에 유리.

**디스크/메모리 효율.** 8B 모델 풀튠 가중치는 16GB(bf16)지만, LoRA r=16 어댑터는 30MB 정도. 어댑터 50개를 서버에 올려두고 요청마다 hot swap 하는 패턴이 2025년 본격화됐다. Mistral·Together·Anthropic의 Custom Models가 같은 아이디어를 쓴다.

9장 · TorchTune — PyTorch 공식

TorchTune은 PyTorch 팀이 직접 만드는 공식 파인튜닝 라이브러리다. 2024년 1.0 출시, 2026년 5월 기준 GitHub 스타 5천 개. 다른 프레임워크보다 늦게 나왔지만, "PyTorch 네이티브, 외부 의존성 최소"라는 철학이 명확하다.

**TorchTune의 디자인 철학.**

- **Recipes.** YAML config 대신 Python 파일(recipe)로 학습 루프를 정의. 코드를 직접 수정해서 커스터마이즈하는 게 더 쉬움.

- **No magic.** transformers·PEFT·TRL을 거의 안 쓴다. 자체 모델 구현, 자체 LoRA, 자체 학습 루프. 깊은 곳까지 들여다볼 수 있음.

- **PyTorch 최신 기능 1순위 적용.** FSDP2, torch.compile, Liger Kernels, Triton kernel 같은 최신 PyTorch 스택을 가장 먼저 받음.

**기본 사용 예제.**

사전 빌트인 recipe 사용

tune run lora_finetune_single_device \

--config llama3_2/8B_lora_single_device

또는 자체 recipe 작성

tune ls # 사용 가능한 recipe 목록

tune cp llama3_2/8B_lora_single_device my_recipe.yaml

my_recipe.yaml 수정 후

tune run lora_finetune_single_device --config my_recipe.yaml

**TorchTune이 잘하는 것.**

- **순수 PyTorch.** transformers 추상화 없이 모델을 직접 다루기 때문에, 학습 루프 디버깅이 쉽다.

- **분산 학습.** FSDP2 통합이 가장 매끄럽다. 멀티노드 학습이 안정적.

- **메모리 효율.** Liger Kernels 통합으로 cross-entropy/RMSNorm/SwiGLU가 fused 커널로 돈다.

**약점.**

- **알고리즘 커버리지가 좁다.** SFT·LoRA·QLoRA·DPO·PPO·GRPO는 있지만, KTO·ORPO·SimPO 같은 변형은 아직 없거나 늦게 들어온다.

- **모델 커버리지.** Llama·Mistral·Gemma·Phi·Qwen·DeepSeek 정도. 비주류 모델은 직접 추가해야 함.

**언제 TorchTune인가.**

- 학습 루프를 직접 들여다보면서 디버깅하고 싶다 → TorchTune.

- PyTorch 신기능(FSDP2, torch.compile)을 빨리 쓰고 싶다 → TorchTune.

- 학과 강의/연구실 표준으로 정착시키고 싶다 → TorchTune (PyTorch 공식이라 안정성 보장).

10장 · LLM Foundry (MosaicML → Databricks)

LLM Foundry는 MosaicML이 만들었고, 2023년 Databricks가 13억 달러에 인수했다. 2026년 5월 현재 Databricks Mosaic AI 플랫폼의 핵심 학습 스택이다. GitHub에 공개되어 있고(Apache 2.0), 모든 코드가 오픈이다.

**LLM Foundry의 강점은 "대규모"다.** Axolotl·Unsloth가 단일 머신 또는 작은 클러스터를 노린다면, LLM Foundry는 처음부터 수백–수천 GPU 학습을 가정한다.

- **StreamingDataset.** S3/GCS/Azure Blob에서 페타바이트 규모 데이터를 stream으로 읽으면서 학습. 다운로드 미리 안 함.

- **FSDP/HSDP 최적화.** Composer 라이브러리(MosaicML 자체) 위에서 분산 학습 효율이 매우 높다. MFU(Model FLOPs Utilization) 50–60%까지 끌어올린다.

- **MPT 모델 시리즈.** MosaicML이 학습한 MPT-7B/30B/Foundation의 학습 코드가 그대로 공개. "이 코드로 우리가 진짜 모델 만들었다"는 증거.

**기본 사용 예제 (Databricks Mosaic AI Training API).**

from databricks.mosaic_ai import TrainingClient

client = TrainingClient()

run = client.create_training_run(

model="meta-llama/Llama-3.1-70B",

training_data="s3://my-bucket/sft-data/",

config={

"task": "INSTRUCTION_FINETUNE",

"training_duration": "3ep",

"learning_rate": 5e-7,

)

print(run.status) # PENDING → RUNNING → COMPLETED

Databricks 워크스페이스 안에서는 이 정도면 끝나고, 학습된 모델은 Unity Catalog에 자동 등록되어 Mosaic AI Model Serving으로 바로 서빙된다.

**언제 LLM Foundry인가.**

- 이미 Databricks 고객 → 자연스러운 선택.

- 100B+ 모델 풀튠, 멀티 노드 학습 → MFU 효율과 안정성에서 가장 강함.

- 보안/거버넌스 요건(Unity Catalog) → 다른 도구로는 못 푼다.

**오픈소스로 직접 쓰는 경우는 점점 줄어들고 있다.** 일반 GPU 클러스터에서는 Axolotl/TorchTune이 더 쉽고, Databricks 외부에서 LLM Foundry를 직접 돌리는 건 셋업이 무겁다. 그래서 LLM Foundry는 "Databricks 안에서 자동으로 쓰이는 것"으로 자리 잡아가고 있다.

11장 · 클라우드 — Modal / Together / OpenAI / Anthropic / Cohere

GPU를 사거나 빌리기 싫은 팀을 위한 길이 있다. 클라우드 파인튜닝 API다. 2026년 5월 기준 5개의 진영이 있다.

**Modal.** 서버리스 GPU 인프라. 파인튜닝 전용은 아니지만, GPU를 분 단위로 빌릴 수 있어서 파인튜닝 워크로드의 인기 백엔드가 됐다. Python 데코레이터로 클라우드 GPU 함수를 정의한다.

app = modal.App("finetune-llama")

image = modal.Image.debian_slim().pip_install("axolotl", "unsloth")

@app.function(image=image, gpu="A100-80GB", timeout=3600)

def train(config_path: str):

subprocess.run(["axolotl", "train", config_path])

@app.local_entrypoint()

def main():

train.remote("config.yml")

이 코드를 `modal run finetune.py` 한 줄로 실행. GPU가 자동으로 켜지고, 학습 끝나면 자동으로 꺼진다. 시간당 1.5–4달러(A100/H100).

**Together AI.** Llama·Qwen·Mistral·DeepSeek 같은 오픈 모델의 파인튜닝/서빙 통합 플랫폼. 파인튜닝은 LoRA 또는 풀튠을 선택할 수 있다.

together fine-tuning create \

--training-file file-xxx \

--model meta-llama/Llama-3.1-70B-Instruct-Reference \

--lora \

--lora-r 16

학습 끝나면 학습된 모델이 Together 인퍼런스에 자동 등록된다. 가격은 토큰당 청구, 또는 dedicated endpoint 시간당 청구.

**OpenAI.** GPT-4.1, GPT-4o-mini, o4-mini 같은 자기네 모델 튜닝. 2024년 말부터 Reinforcement Fine-Tuning(RFT)도 풀었다. RFT는 사용자가 grader function을 정의하면, 그 신호로 RL 학습을 돌려준다.

from openai import OpenAI

client = OpenAI()

job = client.fine_tuning.jobs.create(

training_file="file-xxx",

model="gpt-4o-mini-2024-07-18",

method={"type": "supervised"}, # 또는 "dpo", "reinforcement"

)

**Anthropic.** Claude 3.5 Haiku부터 파인튜닝을 풀기 시작했다(2024년 말). 2026년 5월 기준 Claude 4 Sonnet/Haiku의 SFT와 Constitutional Finetuning(헌법적 가치 정렬)을 풀었다. 다만 사용 가능 범위는 직접 영업 라인을 통해야 하는 경우가 많고, 모든 고객이 셀프 서비스로 접근하지는 못한다.

**Cohere.** Command R/R+ 모델의 SFT 파인튜닝. Cohere의 차별점은 RAG와 결합된 파인튜닝(retrieval-aware finetuning)을 명시적으로 지원하는 것이다.

**어느 클라우드를 골라야 하나.**

| 상황 | 추천 |

| --- | --- |

| 오픈 모델 + 우리가 가중치 가져가야 함 | **Modal** 또는 **Together** |

| OpenAI 모델만 써야 함 (생태계 락인) | **OpenAI 파인튜닝** |

| Claude 모델, 엔터프라이즈 영업 라인 있음 | **Anthropic Claude finetuning** |

| RAG 기반 챗봇, Cohere 생태계 | **Cohere finetuning** |

| 자체 코드 그대로 클라우드만 빌리고 싶음 | **Modal** |

12장 · DPO / GRPO / KTO 알고리즘 — 무엇을 골라야 하나

2024–2026년에 선호 최적화 알고리즘이 폭발했다. 이 챕터에서 핵심 4개를 비교한다.

**PPO (Proximal Policy Optimization).** 2022년 InstructGPT 논문이 쓴 클래식 RLHF 알고리즘. Reward Model을 따로 학습하고, RM의 reward 신호로 PPO를 돌려서 정책을 최적화한다. 안정적이지만 RM 학습이 필요하고, 4개 모델(policy, ref, value, reward)을 동시에 띄워야 해서 메모리 부담이 크다.

**DPO (Direct Preference Optimization).** 2023년 Rafailov의 스탠포드 논문. "RM 없이도 페어 선호 데이터로 직접 정책을 학습할 수 있다"는 핵심 아이디어. policy와 ref 모델 2개만 필요해서 메모리 부담이 절반. 2024년에 사실상 표준이 됐다. 약점은 overfitting이 쉽고, 페어 데이터 품질에 매우 민감하다는 것.

**KTO (Kahneman-Tversky Optimization).** 2024년 ContextualAI의 Ethayarajh 논문. 페어 데이터 대신 "이 응답이 좋다/나쁘다"라는 binary 신호만으로 학습할 수 있다. 페어를 못 모으는 상황(고객 thumbs up/down 데이터)에 적합. 행동경제학의 prospect theory(손실 회피)를 모델링.

**GRPO (Group Relative Policy Optimization).** 2024년 DeepSeek의 DeepSeekMath/R1 논문에서 도입. PPO 변형인데 value model을 없앴다. 한 프롬프트에 응답을 K개 생성하고(보통 4–16개), 그 K개의 보상 평균을 baseline으로 써서 advantage를 계산. value head 학습이 빠지니까 메모리·코드 단순. 수학·코드처럼 검증 가능한 reward에서 매우 강하다.

| 알고리즘 | 데이터 | 모델 수 | 강점 | 약점 |

| --- | --- | --- | --- | --- |

**2026년 권장 시퀀스.**

1. **SFT.** 항상 첫 단계. 고품질 instruction 데이터 10k–100k건.

2. **DPO 또는 KTO.** 선호 데이터가 있으면 DPO, binary 신호만 있으면 KTO.

3. **GRPO.** 수학·코드·logic처럼 검증 가능한 reward가 있는 도메인.

이 3단계 위에 Mixture-of-Agents RLHF 같은 더 새로운 기법(여러 에이전트가 서로 평가하면서 학습)이 2025년부터 시도되고 있지만, 아직 실험 단계다.

13장 · FSDP / DeepSpeed Zero / QLoRA — 분산 학습

큰 모델을 학습하려면 한 장의 GPU로는 안 된다. 가중치·옵티마이저 상태·gradient를 GPU 여러 장에 나눠야 한다. 이걸 푸는 핵심 기법 셋을 정리한다.

**FSDP (Fully Sharded Data Parallel).** PyTorch 공식 분산 전략. 데이터 병렬인데, 가중치·gradient·옵티마이저 상태를 GPU 사이에 sharding 한다. forward/backward 시점에 필요한 가중치만 모았다가(all-gather), 끝나면 다시 나눈다. 메모리는 N장 GPU에 1/N로 줄어들지만, 통신 비용이 늘어난다.

from torch.distributed.fsdp import FullyShardedDataParallel as FSDP

from torch.distributed.fsdp import MixedPrecision

model = FSDP(

model,

mixed_precision=MixedPrecision(

param_dtype=torch.bfloat16,

reduce_dtype=torch.bfloat16,

buffer_dtype=torch.bfloat16,

)

**DeepSpeed Zero.** Microsoft의 분산 학습 라이브러리. ZeRO-1/2/3 단계가 있다.

- **ZeRO-1**: 옵티마이저 상태만 sharding.

- **ZeRO-2**: 옵티마이저 + gradient.

- **ZeRO-3**: 옵티마이저 + gradient + 가중치 전부. FSDP와 거의 같은 동작.

DeepSpeed는 ZeRO-Infinity(CPU/NVMe offload)와 ZeRO-Offload(CPU로 옵티마이저 상태 빼기)가 강력해서, GPU 메모리가 정말 빠듯할 때 살린다. 단점은 PyTorch FSDP보다 통합 깊이가 얕고, torch.compile/FSDP2 같은 신기능 통합이 늦는 것.

**QLoRA + FSDP.** Tim Dettmers의 핵심 작품. 4-bit 양자화된 베이스 모델 + LoRA 어댑터 학습 + FSDP 분산. 70B 모델을 2장의 A100 80GB에 올려서 LoRA 학습할 수 있다. Axolotl·Unsloth·TorchTune·HuggingFace TRL 모두 이 조합을 지원한다.

**2026년 디폴트 매트릭스.**

| 모델 크기 | GPU | 권장 분산 전략 |

| --- | --- | --- |

| 7B | 1xA100 40GB | LoRA, 분산 안 함 |

| 7B 풀튠 | 1xH100 80GB | FSDP-1 (옵티마이저만) |

| 13B 풀튠 | 4xA100 80GB | FSDP-2 (옵티마이저 + grad) |

| 70B QLoRA | 2xA100 80GB | QLoRA + FSDP-3 |

| 70B 풀튠 | 8xH100 80GB | FSDP-3 + activation checkpointing |

| 405B QLoRA | 4xH100 80GB | QLoRA + FSDP-3 + CPU offload |

| 405B 풀튠 | 64+xH100 | DeepSpeed ZeRO-3 또는 FSDP-3 + Megatron |

**Liger Kernels.** 2024년 LinkedIn이 공개한 Triton 커널 모음. CrossEntropy/RMSNorm/SwiGLU/RoPE를 fused로 돌려서 메모리 20–30% 절감 + 속도 10–20% 향상. Axolotl·Unsloth·TorchTune이 모두 통합했다. 2026년에는 거의 디폴트로 켜는 옵션이 됐다.

14장 · 한국 / 일본 — Upstage / KT / LG AI / Sakana / Stockmark / ELYZA / PFN

**한국.**

- **Upstage.** Solar 모델 시리즈를 만드는 한국의 LLM 스타트업. 2024년 Solar 10.7B로 Hugging Face 리더보드 1위를 한 적이 있다. 자체 파인튜닝 플랫폼(Upstage AI Stack)이 있고, "DAUS(Depth-Up-Scaling)"라는 자체 모델 확장 기법으로 유명. 2025년 한국 정부의 토종 LLM 과제(K-LLM)의 핵심 파트너로 선정.

- **KT.** Mi:dm 2.0(미듬) 모델을 자체 개발. 한국어·한국 문화 특화에 강점. 2025년 KT 클라우드 GPU 인프라를 본격화하면서 외부에 파인튜닝 서비스도 풀기 시작.

- **LG AI Research.** EXAONE 3.5/4.0 모델 시리즈. 화학·소재·법률 같은 특수 도메인 파인튜닝 사례가 많다. 2024년 EXAONE 3.5를 오픈웨이트로 풀면서 외부 연구자들이 직접 튜닝할 수 있게 됐다.

- **국내 파인튜닝 인프라.** NHN Cloud, 네이버클라우드, KT 클라우드가 H100/H200 GPU를 시간당 4–8천 원 선에서 제공. AWS/GCP 한국 리전보다 30% 정도 싸다.

**일본.**

- **Sakana AI.** 도쿄에 본사를 둔, Google Brain 출신 David Ha와 Llion Jones(트랜스포머 공저자)가 창업한 회사. 2024년 시리즈 A에서 4.5억 달러 valuation을 받았고, "evolutionary model merging"이라는 독특한 접근(여러 모델을 진화 알고리즘으로 섞어서 새 모델을 만듦)으로 유명. 일본어 특화 모델 EvoLLM-JP 시리즈.

- **Stockmark.** 금융·법률 도메인에 특화한 일본 LLM 회사. Stockmark-13B 같은 일본어 LLM을 자체 학습.

- **ELYZA.** 도쿄대 발 스타트업. Llama 2/3을 일본어로 continual pretraining + finetuning 해서 "ELYZA-japanese-Llama" 시리즈를 공개. KDDI가 2024년에 인수.

- **PFN (Preferred Networks).** 일본의 거인. PLaMo 시리즈로 자체 LLM 학습, MN-Core라는 자체 가속기까지 만든다. 산업 도메인(제조·의료) 파인튜닝에 강하다.

- **Sakana의 evolutionary model merging.** 2024년 논문이 화제가 됐다. 두 일본어 모델(Shisa, ELYZA)을 진화 알고리즘으로 섞어서, 각각보다 더 나은 성능의 새 모델을 만들었다. "학습 없이도 모델을 개선할 수 있다"는 가능성을 보여줬다.

**한국·일본 공통 패턴.**

- 영어 베이스 모델(Llama·Mistral)을 한국어/일본어로 continual pretraining → 그 위에 instruction tuning 하는 게 표준 레시피.

- 자체 GPU 클러스터를 구축하는 회사가 늘고 있음. 미국 클라우드 의존이 비용·주권 문제로 걸림.

- Axolotl·LLaMA-Factory가 압도적으로 많이 쓰임. Unsloth는 빠르긴 한데 멀티노드 약점 때문에 큰 회사는 잘 안 씀.

15장 · 누가 무엇을 골라야 하나 — 결정 가이드

지금까지 본 도구·알고리즘·인프라를 페르소나별로 정리한다.

페르소나 A: 1인 개발자, GPU 1장 (RTX 4090 또는 Colab Pro)

- **프레임워크**: Unsloth. 한 GPU에서 최고 효율, Colab 노트북 그대로 돈다.

- **알고리즘**: LoRA SFT → DPO. KTO/GRPO는 데이터 모으기 어려움.

- **모델 크기**: 7–13B. 4-bit QLoRA로 단일 24GB GPU에 올림.

- **데이터셋**: 1k–10k건. 양보다 질이 중요.

페르소나 B: 학술 연구자, 클러스터 4–8장 GPU

- **프레임워크**: TorchTune 또는 Axolotl. 학습 루프를 깊게 파야 함.

- **알고리즘**: 논문 쓰는 거라면 직접 구현이 베스트, TRL의 GRPOTrainer를 base로.

- **모델 크기**: 7B → 70B로 점진 확장.

- **분산**: FSDP-2/3 또는 DeepSpeed Zero-3.

페르소나 C: 시드–시리즈 A 스타트업

- **프레임워크**: Axolotl (가장 빠른 알고리즘 커버리지).

- **인프라**: Modal (서버리스 GPU) 또는 Together (학습 + 서빙 통합).

- **알고리즘**: SFT → DPO. 일관성·스타일 정합이 1순위.

- **모델 크기**: 8–13B. 비용/품질 균형.

- **데이터**: 도메인 데이터 5k–50k건 + 일반 instruction 데이터 mix.

페르소나 D: 엔터프라이즈 / 200명 이상

- **프레임워크**: LLM Foundry (Databricks를 이미 쓴다면) 또는 자체 클러스터 + Axolotl.

- **클라우드**: OpenAI 파인튜닝 (생태계 락인) 또는 Anthropic 영업 라인.

- **알고리즘**: SFT + DPO + 가능하면 GRPO.

- **모델 크기**: 70B+. 자체 70B 튜닝이 GPT-4 호출보다 싸진다.

- **거버넌스**: 모델 weight 자체 보관, audit log, lineage tracking.

페르소나 E: 파운데이션 모델 랩

- **프레임워크**: 자체 구축. Axolotl·TorchTune·LLM Foundry를 fork 해서 자체 패치.

- **인프라**: 수백–수천 GPU 클러스터, RDMA/InfiniBand.

- **알고리즘**: 새 알고리즘 개발, 논문 쓰기.

- **데이터**: 자체 크롤·라벨링 파이프라인.

페르소나 F: 한국 / 일본 도메인 특화

- **베이스 모델**: Llama 3.x, Qwen 2.5/3, 또는 Upstage Solar / EXAONE / Stockmark / ELYZA.

- **레시피**: Continual Pretraining (도메인 텍스트 1B+ tokens) → SFT (instruction 5k–50k) → DPO.

- **인프라**: NHN/네이버/KT 클라우드 (한국), さくらインターネット·GMO·PFN 클러스터 (일본).

- **프레임워크**: LLaMA-Factory(중국 모델 호환성) 또는 Axolotl(영어권 호환성).

마지막 한 줄

2026년 LLM 파인튜닝은 **"GPU 1장만 있어도 시작할 수 있고, 수천 장이 있어도 끝이 안 보이는"** 영역이다. 작게 시작하고, 무엇이 효과 있는지 측정하고, 그다음에 키우는 게 정답이다. 도구는 거들 뿐, 데이터 품질과 평가가 결국 모든 것을 결정한다.

참고 / References

- Axolotl — https://axolotl.ai/

- Axolotl GitHub — https://github.com/axolotl-ai-cloud/axolotl

- Unsloth — https://unsloth.ai/

- Unsloth GitHub — https://github.com/unslothai/unsloth

- LLaMA-Factory GitHub — https://github.com/hiyouga/LLaMA-Factory

- Hugging Face TRL — https://huggingface.co/docs/trl

- TRL GitHub — https://github.com/huggingface/trl

- PEFT — https://huggingface.co/docs/peft

- PEFT GitHub — https://github.com/huggingface/peft

- TorchTune — https://pytorch.org/torchtune/

- TorchTune GitHub — https://github.com/pytorch/torchtune

- LLM Foundry — https://github.com/mosaicml/llm-foundry

- Databricks Mosaic AI — https://www.databricks.com/product/machine-learning/mosaic-ai

- Modal — https://modal.com/

- Together AI Fine-tuning — https://docs.together.ai/docs/fine-tuning-overview

- OpenAI Fine-tuning — https://platform.openai.com/docs/guides/fine-tuning

- OpenAI Reinforcement Fine-Tuning — https://platform.openai.com/docs/guides/reinforcement-fine-tuning

- Anthropic Fine-tuning — https://docs.anthropic.com/en/docs/build-with-claude/fine-tuning

- Cohere Fine-tuning — https://docs.cohere.com/docs/fine-tuning

- LoRA paper (Hu et al., 2021) — https://arxiv.org/abs/2106.09685

- QLoRA paper (Dettmers et al., 2023) — https://arxiv.org/abs/2305.14314

- DoRA paper (Liu et al., 2024) — https://arxiv.org/abs/2402.09353

- DPO paper (Rafailov et al., 2023) — https://arxiv.org/abs/2305.18290

- KTO paper (Ethayarajh et al., 2024) — https://arxiv.org/abs/2402.01306

- GRPO / DeepSeekMath (Shao et al., 2024) — https://arxiv.org/abs/2402.03300

- DeepSeek R1 — https://arxiv.org/abs/2501.12948

- ORPO paper (Hong et al., 2024) — https://arxiv.org/abs/2403.07691

- SimPO paper (Meng et al., 2024) — https://arxiv.org/abs/2405.14734

- IPO paper (Azar et al., 2023) — https://arxiv.org/abs/2310.12036

- IA3 paper (Liu et al., 2022) — https://arxiv.org/abs/2205.05638

- AdaLoRA paper (Zhang et al., 2023) — https://arxiv.org/abs/2303.10512

- VeRA paper (Kopiczko et al., 2023) — https://arxiv.org/abs/2310.11454

- PyTorch FSDP — https://pytorch.org/docs/stable/fsdp.html

- DeepSpeed ZeRO — https://www.deepspeed.ai/tutorials/zero/

- Liger Kernels — https://github.com/linkedin/Liger-Kernel

- vLLM — https://github.com/vllm-project/vllm

- Mixture-of-Agents — https://arxiv.org/abs/2406.04692

- Upstage Solar — https://www.upstage.ai/feed/product/solarmini-introduction

- KT Mi:dm — https://www.kt.com/biz/mi-dm.html

- LG AI EXAONE — https://www.lgresearch.ai/exaone

- Sakana AI — https://sakana.ai/

- Sakana evolutionary model merging — https://sakana.ai/evolutionary-model-merge/

- Stockmark — https://stockmark.co.jp/

- ELYZA — https://elyza.ai/

- Preferred Networks PLaMo — https://www.preferred.jp/en/projects/plamo/

- MosaicML acquisition by Databricks (2023) — https://www.databricks.com/company/newsroom/press-releases/databricks-completes-acquisition-mosaicml