Amazon Bedrock

Fine-tuning vs RAG: 어떤 방법을 선택해야 하나?

## 핵심 차이 한눈에 보기 | 항목 | Fine-tuning | RAG | |------|-------------|-----| | 지식 저장 방식 | 모델 가중치에 학습 | 외부 DB에 저장 | | 업데이트 방법 | 재학습 필요 | DB만 수정 | | 구축 비용 | 높음 (GPU 필요) | 낮음 | | 운영 비용 | 낮음 (소형 모델 가능) | 중간 (검색 + LLM) | | 특화 스타일/톤 | ★★★★★ | ★★☆☆☆ | | 최신 정보 반영 | ★★☆☆☆ | ★★★★★ | | 출처 추적 | 불가능 | 가능 | | 할루시네이션 | 많음 | 적음 | --- ## Fine -tuning이 정답인 경우 ### 1. 특정 스타일/톤/형식이 핵심일 때 고객 서비스 챗봇이 항상 특정 브랜드 톤으로 답해야 한다면, RAG로는 프롬프트 엔지니어링만으로 한계가 있습니다. Fine-tuning은 이 "캐릭터"를 모델에 학습시킵니다. ### 2. 도메인 전문 용어가 많을 때 의료, 법률, 금융 분야에서 특수 약어나 용어를 기본 LLM이 잘못 해석한다면, Fine-tuning으로 도메인 언어를 학습시키면 효과적입니다. ### 3. 짧고 반응 빠른 서비스가 필요할 때 Fine-tuned 소형 모델(7B~13B)은 GPT-4o보다 응답이 빠르고 비용도 저렴합니다. RAG는 검색 단계가 추가되어 지연이 생깁니다. **실제 사례:** - 코드 스타일 가이드 준수하는 코딩 어시스턴트 - 특정 상담 스크립트를 따르는 고객 서비스 봇 - 사내 약어와 프로세스를 이해하는 내부 도구 --- ## RAG가 정답인 경우 ### 1. 정보가 자주 바뀔 때 뉴스, 제품 재고, 가격 정보처럼 실시간 업데이트가 필요한 경우 Fine-tuning은 매번 재학습이 필요해 비현실적입니다. RAG는 DB만 업데이트하면 됩니다. ### 2. 출처 추적이 필요할 때 "이 정보가 어디서 나왔냐"를 보여줘야 하는 법률, 의료, 금융 서비스에서 RAG는 검색된 문서를 출처로 제시할 수 있습니다. ### 3. 대용량 지식 베이스를 다룰 때 수만 개의 사내 문서, 제품 매뉴얼, FAQ를 모두 Fine-tuning으로 학습시키는 건 데이터 준비부터 비용까지 비현실적입니다. RAG는 벡터 DB에 넣기만 하면 됩니다. ### 4. 빠른 도입이 필요할 때 RAG는 며칠 안에 프로토타입을 만들 수 있습니다. Fine-tuning은 데이터 준비 → 학습 → 평가 → 배포까지 몇 주가 걸립니다. --- ## Fine -tuning 실전 가이드 ### 데이터 요구량 - **최소**: 수백 개 예시 (품질이 양보다 중요) - **권장**: 1,000~10,000개 고품질 예시 - 형식: JSONL (`{"messages": [{"role": "user", ...}, {"role": "assistant", ...}]}`) ### 비용 예시 (OpenAI GPT-4o mini fine-tuning 기준) - 학습 데이터 1,000개, 3 epoch → 약 $3~10 - 추론: 기본 모델 대비 약 1.5배 비용 ### 주의사항 - Fine-tuning은 **행동 패턴을 학습**하는 것이지 **지식을 주입**하는 게 아닙니다 - 잘못된 데이터가 들어가면 오히려 성능이 나빠짐 (Garbage In, Garbage Out) - GPT-4o로 학습 데이터를 먼저 생성한 뒤, 검증 후 Fine-tuning하는 방식 권장 --- ## 현실적인 결론: 대부분은 RAG부터 시작 실무에서 보면, Fine-tuning이 꼭 필요한 경우는 생각보다 적습니다. **일단 RAG로 시작해서 한계가 명확해지면 Fine-tuning을 고려**하는 게 현명합니다. 의사결정 트리: 1. 지식이 자주 바뀌는가? → **RAG** 2. 출처를 보여줘야 하는가? → **RAG** 3. 빠른 도입이 필요한가? → **RAG** 4. 특정 스타일/톤이 핵심인가? → **Fine-tuning 고려** 5. 지연시간이 매우 중요한가? → **Fine-tuning 고려** 6. 비용을 극도로 줄여야 하는가? → **Fine-tuning + 소형 모델** 대부분의 기업용 AI 프로젝트는 **RAG + 좋은 프롬프트 엔지니어링**으로 80~90%의 요구사항을 충족할 수 있습니다.

LLM 파인튜닝 실전 가이드: QLoRA로 나만의 모델 만들기 (2025)

## 파인튜닝을 해야 하는 경우 파인튜닝은 모든 상황에서 필요하지 않습니다. 먼저 파인튜닝이 진짜 필요한지 판단하세요: ```mermaid flowchart TD Start[커스텀 AI 필요] --> Q1{프롬프트만으로<br/>해결 가능?} Q1 -- Yes --> Prompt[System Prompt + Few-shot<br/>충분함] Q1 -- No --> Q2{지식을 추가해야 하나?} Q2 -- Yes --> RAG[RAG 구축<br/>파인튜닝보다 쉬움] Q2 -- No --> Q3{특정 스타일/형식<br/>일관성이 필요?} Q3 -- Yes --> FT[파인튜닝 고려] Q3 -- No --> Q4{응답 속도/비용<br/>극단적 최적화?} Q4 -- Yes --> FT Q4 -- No --> Prompt ``` **파인튜닝이 진짜 필요한 경우:** - 특정 산업 용어, 말투, 형식을 일관되게 써야 할 때 - API 비용을 대폭 줄이고 싶을 때 (소형 파인튜닝 모델 > 대형 범용 모델) - 지연 시간을 극단적으로 줄여야 할 때 - 인터넷 연결 없는 온프레미스 환경 --- ## QLoRA: 저사양에서 파인튜닝하는 방법 QLoRA(Quantized Low-Rank Adaptation)는 RTX 3090(24GB VRAM) 한 장으로도 70B 모델을 파인튜닝할 수 있게 해주는 기법입니다. ### 핵심 개념 **LoRA의 원리:** 모델의 모든 가중치를 업데이트하는 대신, 저랭크(low-rank) 행렬 2개만 학습합니다. ``` 원본 가중치 W (고정) + 델타 = A × B (A: r×d, B: d×r, r << d) ──────────────── 실제 사용 가중치 = W + A × B ``` 전체 파라미터의 0.1~1%만 학습 → 메모리 90% 이상 절감 **QLoRA 추가:** 기본 모델을 4비트로 양자화해 메모리를 더 줄이고, 그 위에 LoRA 어댑터를 학습합니다. --- ## 실전: Llama 3.1 8B 파인튜닝 ### 환경 설정 ```bash pip install transformers datasets peft trl accelerate bitsandbytes ``` ### 데이터 준비파인튜닝 데이터는 **지시-응답 쌍**입니다: ```python # 데이터 형식 (Alpaca 스타일) training_data = [ { "instruction": "다음 고객 리뷰의 감정을 분석하세요", "input": "배송이 3일이나 걸렸어요. 제품은 괜찮은데 배송이 너무 느려요.", "output": "감정: 혼합 (부정적 배송 경험 + 긍정적 제품 평가) 주요 불만: 배송 속도 만족 요인: 제품 품질" }, # 최소 수백~수천 개 필요 ] # HuggingFace Dataset 형식으로 변환 from datasets import Dataset def format_prompt(example): return { "text": f"# ## 지시: {example['instruction']} ### 입력: {example['input']} ### 응답: {example['output']}" } dataset = Dataset.from_list(training_data).map(format_prompt) ``` ### QLoRA 학습 ```python from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig from peft import LoraConfig, get_peft_model, TaskType from trl import SFTTrainer, SFTConfig import torch # 4비트 양자화 설정 bnb_config = BitsAndBytesConfig( load_in_4bit=True, bnb_4bit_quant_type="nf4", bnb_4bit_compute_dtype=torch.float16, bnb_4bit_use_double_quant=True, ) # 모델 로드 model = AutoModelForCausalLM.from_pretrained( "meta-llama/Llama-3.1-8B-Instruct", quantization_config=bnb_config, device_map="auto", ) tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-3.1-8B-Instruct") # LoRA 설정 lora_config = LoraConfig( r=16, # 랭크 (작을수록 파라미터 적음, 16~64 권장) lora_alpha=32, # 스케일링 파라미터 (r의 2배 권장) target_modules=["q_proj", "v_proj", "k_proj", "o_proj"], lora_dropout=0.05, bias="none", task_type=TaskType.CAUSAL_LM, ) model = get_peft_model(model, lora_config) model.print_trainable_parameters() # trainable params: 6,815,744 || all params: 8,037,986,304 || trainable%: 0.085 # 학습 trainer = SFTTrainer( model=model, train_dataset=dataset, args=SFTConfig( output_dir="./output", num_train_epochs=3, per_device_train_batch_size=4, gradient_accumulation_steps=4, warmup_steps=100, learning_rate=2e-4, fp16=True, logging_steps=10, save_steps=500, ), dataset_text_field="text", max_seq_length=2048, ) trainer.train() trainer.save_model("./my-finetuned-model") ``` --- ## GPU 메모리 요구사항 가이드 | 모델 | 기법 | 최소 VRAM | 권장 VRAM | |------|------|-----------|-----------| | Llama 3.1 8B | QLoRA | 12GB | 16GB | | Llama 3.1 8B | LoRA (fp16) | 20GB | 24GB | | Llama 3.1 70B | QLoRA | 40GB | 80GB | | Qwen 2.5 14B | QLoRA | 20GB | 24GB | | Mistral 7B | QLoRA | 10GB | 16GB | **클라우드 GPU 옵션:** - RunPod: RTX 3090 (24GB) $0.44/시간 - Lambda Labs: A100 (80GB) $1.10/시간 - Google Colab Pro+: A100 (40GB) 월 $50 무제한 --- ## OpenAI 파인튜닝 API (코딩 없는 방법) 직접 학습 환경을 구축하기 어렵다면 OpenAI의 파인튜닝 API를 사용합니다: ```python from openai import OpenAI client = OpenAI() # 1. 데이터 업로드 with open("training_data.jsonl", "rb") as f: file = client.files.create(file=f, purpose="fine-tune") # 2. 파인튜닝 시작 job = client.fine_tuning.jobs.create( training_file=file.id, model="gpt-4o-mini", # 가장 저렴한 옵션 hyperparameters={"n_epochs": 3} ) # 3. 완료 후 사용 response = client.chat.completions.create( model=job.fine_tuned_model, # ft:gpt-4o-mini:org:custom:id messages=[{"role": "user", "content": "..."}] ) ``` **데이터 형식 (JSONL):** ```json {"messages": [{"role": "system", "content": "당신은 고객서비스 직원입니다"}, {"role": "user", "content": "환불 요청합니다"}, {"role": "assistant", "content": "안녕하세요! 불편을 드려 죄송합니다..."}]} ``` --- ## 파인튜닝 vs 프롬프트 엔지니어링 비용 비교 **시나리오: 하루 10만 건 분류 태스크** | 방법 | 모델 | 월 비용 | 레이턴시 | |------|------|---------|---------| | System Prompt | GPT-4o | ~$750 | 1-2초 | | System Prompt | GPT-4o-mini | ~$60 | 0.5초 | | 파인튜닝 | GPT-4o-mini ft | ~$30 | 0.3초 | | 자체 QLoRA | Llama 3.1 8B | GPU 비용만 | 0.1초 | 파인튜닝으로 비용 50~90% 절감 가능합니다. --- ## 결론파인튜닝 시작 전 체크리스트: 1. ✅ 프롬프트 최적화로 충분하지 않은가? 2. ✅ 학습 데이터가 최소 500개 이상 있는가? 3. ✅ 데이터 품질이 일관적인가? 4. ✅ GPU 또는 클라우드 환경이 준비됐는가? 빠르게 시작하고 싶다면: **OpenAI gpt-4o-mini 파인튜닝** → 코드 최소화, 학습 데이터만 준비 성능과 비용 최적화가 목표라면: **QLoRA + Llama 3.1 8B** → 자체 인프라에서 완전 제어

LLMOps 완전 가이드: AI 모델을 프로덕션에서 운영하는 법 (2025)

## LLMOps란? LLMOps(Large Language Model Operations)는 LLM 기반 서비스를 프로덕션에서 안정적으로 운영하기 위한 엔지니어링 실천법입니다. 기존 MLOps와 비슷하지만 LLM 특유의 문제(프롬프트 관리, 비결정적 출력, 비용 폭발)를 다룹니다. --- ## LLMOps 전체 파이프라인 ```mermaid flowchart LR A[요구사항 정의] --> B[모델 선택] B --> C[프롬프트 개발] C --> D[평가 & 테스트] D --> E{품질 기준 통과?} E -- No --> C E -- Yes --> F[배포] F --> G[모니터링] G --> H{이슈 감지?} H -- Yes --> C H -- No --> G ``` --- ## 1단계: 모델 선택 기준 모든 태스크에 GPT-4o가 필요하진 않습니다. 비용 대비 성능으로 모델을 선택합니다. ```mermaid flowchart TD Start[태스크 분석] --> Q1{실시간 응답 필요?} Q1 -- Yes --> Q2{복잡도?} Q1 -- No --> Q3{문서 길이?} Q2 -- 단순 --> Haiku[Claude Haiku / GPT-4o mini] Q2 -- 복잡 --> Sonnet[Claude Sonnet / GPT-4o] Q3 -- 32K 이하 --> Sonnet Q3 -- 32K 이상 --> Long[Claude / Gemini 1.5 Pro] Haiku --> Cost[$0.80~2.50 /1M] Sonnet --> Cost2[$3~10 /1M] Long --> Cost3[$3.50~15 /1M] ``` **실전 팁:** - 분류/추출 같은 단순 태스크 → 소형 모델로 시작, 품질이 부족할 때만 업그레이드 - 첫 달은 비용 로그를 매일 확인, 예상보다 10x 나오는 경우 흔함 --- ## 2단계: 프롬프트 버전 관리 프롬프트는 코드입니다. 코드처럼 관리해야 합니다. ### 프롬프트 레지스트리 구조 ``` prompts/ ├── customer_support/ │ ├── v1.0.0.txt # 최초 버전 │ ├── v1.1.0.txt # 한국어 개선 │ └── v2.0.0.txt # 멀티턴 지원 추가 ├── code_review/ │ └── v1.0.0.txt └── metadata.json # 버전별 평가 점수 기록 ``` ```python # 프롬프트 로더 예시 class PromptRegistry: def __init__(self, base_path: str = "prompts/"): self.base_path = Path(base_path) self.metadata = json.loads((self.base_path / "metadata.json").read_text()) def get(self, name: str, version: str = "latest") -> str: if version == "latest": versions = sorted(self.metadata[name].keys()) version = versions[-1] path = self.base_path / name / f"v{version}.txt" return path.read_text() def get_best(self, name: str) -> str: '''평가 점수 기준 최고 버전 반환''' versions = self.metadata[name] best = max(versions.items(), key=lambda x: x[1].get("score", 0)) return self.get(name, best[0]) ``` --- ## 3단계: 평가 파이프라인 LLM 출력은 비결정적이므로 체계적인 평가가 필수입니다. ```mermaid flowchart LR A[테스트셋 준비] --> B[LLM 실행] B --> C[자동 평가] C --> D[LLM-as-Judge] D --> E[사람 검토] E --> F[점수 기록] F --> G{기준치 이상?} G -- Yes --> H[프로덕션 배포] G -- No --> I[프롬프트 수정] I --> B ``` ### 자동 평가 지표 | 지표 | 측정 방법 | 적합한 태스크 | |------|-----------|---------------| | 정확도 | 정답 대비 일치율 | 분류, 추출 | | ROUGE | 참조 텍스트와 n-gram 겹침 | 요약 | | 레이턴시 | p50/p95/p99 응답 시간 | 모든 태스크 | | 비용 | 토큰 수 × 단가 | 모든 태스크 | | 거부율 | 답변 거부 비율 | 안전 관련 | ### LLM-as-Judge 패턴 ```python JUDGE_PROMPT = '''다음 AI 응답을 평가하세요. [질문]: {question} [AI 응답]: {response} [정답 예시]: {reference} 평가 기준 (각 1-5점): 1. 정확성: 사실적으로 맞는가? 2. 완전성: 질문에 충분히 답했는가? 3. 간결성: 불필요한 내용이 없는가? JSON으로 응답: {{"accuracy": 점수, "completeness": 점수, "conciseness": 점수, "reasoning": "이유"}}''' def evaluate_with_llm(question, response, reference): result = gpt4o.complete( JUDGE_PROMPT.format(question=question, response=response, reference=reference) ) return json.loads(result) ``` --- ## 4단계: 배포 아키텍처 ```mermaid flowchart TB User[사용자] --> LB[Load Balancer] LB --> API[FastAPI / Next.js API] API --> Cache{Redis 캐시<br/>히트?} Cache -- Yes --> Return[캐시 응답 반환] Cache -- No --> Queue[작업 큐<br/>Celery/BullMQ] Queue --> Worker1[Worker 1<br/>GPT-4o] Queue --> Worker2[Worker 2<br/>GPT-4o] Worker1 --> Monitor[LangSmith / Langfuse] Worker2 --> Monitor Monitor --> DB[(PostgreSQL<br/>로그 저장)] ``` ### 캐싱 전략LLM 응답은 비싸므로 캐싱이 핵심입니다. ```python import hashlib import redis r = redis.Redis() CACHE_TTL = 3600 # 1시간 def cached_llm_call(prompt: str, model: str) -> str: # 캐시 키: 프롬프트 + 모델의 해시 key = f"llm:{hashlib.md5(f'{model}:{prompt}'.encode()).hexdigest()}" cached = r.get(key) if cached: return cached.decode() response = call_llm(prompt, model) r.setex(key, CACHE_TTL, response) return response ``` 동일 입력에 반복 호출이 많은 서비스(FAQ 봇, 문서 요약)에서 비용 70~90% 절감 사례가 있습니다. --- ## 5단계: 모니터링 ```mermaid flowchart LR App[앱 서버] --> |로그 스트림| Langfuse[Langfuse<br/>오픈소스 LLM 관찰] Langfuse --> Dashboard[대시보드] Dashboard --> Metrics[지표:<br/>레이턴시/비용/에러율] Dashboard --> Traces[트레이스:<br/>프롬프트/응답 기록] Dashboard --> Evals[평가:<br/>LLM-as-Judge 점수] Metrics --> Alert[임계치 초과 시<br/>알림] ``` ### 필수 모니터링 지표 ```python # Langfuse 연동 예시 from langfuse import Langfuse langfuse = Langfuse() def track_llm_call(user_id: str, prompt: str, response: str, tokens: int, cost: float): langfuse.trace( name="llm-call", user_id=user_id, input=prompt, output=response, metadata={ "tokens": tokens, "cost_usd": cost, "model": "gpt-4o", } ) ``` **모니터링해야 할 핵심 지표:** - **p95 레이턴시**: 95번째 백분위 응답 시간 (SLA 기준) - **일일 비용**: 예산 대비 실제 소비 - **에러율**: 타임아웃, API 에러 비율 - **품질 점수**: LLM-as-Judge 자동 평가 결과 --- ## 도구 추천 | 카테고리 | 오픈소스 | 유료 SaaS | |----------|----------|-----------| | 프롬프트 관리 | PromptLayer | LangSmith | | 관찰/추적 | **Langfuse** | DataDog LLM | | 평가 | **RAGAS** | Braintrust | | 피처 플래그 | Unleash | LaunchDarkly | | 비용 추적 | 자체 구현 | OpenMeter | **Langfuse 강력 추천**: 셀프호스팅 가능, MIT 라이선스, 한국 스타트업 여러 곳에서 사용 중. --- ## 결론LLMOps의 핵심은 **관찰 가능성(Observability)**입니다. 무슨 프롬프트를 보냈고, 어떤 응답을 받았고, 비용이 얼마였는지 항상 추적할 수 있어야 합니다. 처음부터 완벽한 시스템을 구축하려 하지 말고, 로깅부터 시작해서 점진적으로 발전시키세요.