LLM Fine-Tuning 완전 가이드 - 개념부터 엔터프라이즈 적용까지

{
  "instruction": "다음 텍스트를 3줄로 요약하세요.",
  "input": "인공지능(AI)은 1956년 다트머스 회의에서...(긴 텍스트)",
  "output": "1. 인공지능은 1956년에 학문 분야로 시작되었습니다.\n2. 머신러닝과 딥러닝의 발전으로...\n3. 현재 LLM을 통해..."
}

# DPO 학습 데이터 형식
{
    "prompt": "Python에서 리스트를 정렬하는 방법을 알려주세요.",
    "chosen": "Python에서 리스트를 정렬하는 방법은 두 가지입니다.\n\n1. `sort()` 메서드: 원본 리스트를 직접 정렬합니다.\n```python\nmy_list = [3, 1, 4, 1, 5]\nmy_list.sort()\nprint(my_list)  # [1, 1, 3, 4, 5]\n```\n\n2. `sorted()` 함수: 새로운 정렬된 리스트를 반환합니다.\n```python\nmy_list = [3, 1, 4, 1, 5]\nnew_list = sorted(my_list)\n```",
    "rejected": "sort 쓰면 됩니다."
}

from peft import LoraConfig
 
# 권장 LoRA 설정 (7~8B 모델 기준)
lora_config = LoraConfig(
    r=16,
    lora_alpha=32,            # alpha = 2 * r
    target_modules=[          # 가능한 모든 linear 레이어에 적용
        "q_proj", "k_proj", "v_proj", "o_proj",
        "gate_proj", "up_proj", "down_proj"
    ],
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM"
)

[
  {
    "instruction": "다음 SQL 쿼리의 성능을 최적화하세요.",
    "input": "SELECT * FROM orders WHERE customer_id IN (SELECT id FROM customers WHERE region = 'APAC') ORDER BY created_at DESC",
    "output": "```sql\nSELECT o.*\nFROM orders o\nINNER JOIN customers c ON o.customer_id = c.id\nWHERE c.region = 'APAC'\nORDER BY o.created_at DESC;\n```\n\n최적화 포인트:\n1. 서브쿼리를 JOIN으로 변환하여 실행 계획 개선\n2. `SELECT *` 대신 필요한 컬럼만 선택 권장\n3. `customer_id`와 `region` 컬럼에 인덱스 확인"
  }
]

{
  "messages": [
    {"role": "system", "content": "당신은 데이터 엔지니어링 전문가입니다."},
    {"role": "user", "content": "Spark에서 OOM 에러가 발생합니다. 어떻게 해결하나요?"},
    {"role": "assistant", "content": "Spark OOM 에러는 주로 다음 원인으로 발생합니다:\n\n1. **파티션 수 부족**: `spark.sql.shuffle.partitions` 값을 늘려보세요.\n2. **데이터 스큐**: `salting` 기법으로 키 분산을 개선하세요.\n3. **드라이버 메모리 부족**: `spark.driver.memory`를 증가시키세요.\n4. **브로드캐스트 조인**: 작은 테이블은 브로드캐스트 조인을 사용하세요."},
    {"role": "user", "content": "데이터 스큐를 확인하는 방법은?"},
    {"role": "assistant", "content": "데이터 스큐를 진단하는 방법:\n\n```python\n# 키별 레코드 수 분포 확인\ndf.groupBy('key_column').count().orderBy(F.desc('count')).show(20)\n```\n\n상위 키의 레코드 수가 평균 대비 10배 이상이면 스큐가 존재합니다."}
  ]
}

{"prompt": "고객 리뷰: '배송이 빨라서 좋았어요'\n감성:", "completion": " 긍정"}
{"prompt": "고객 리뷰: '제품이 설명과 달라 실망입니다'\n감성:", "completion": " 부정"}

from anthropic import Anthropic
 
client = Anthropic()
 
def generate_training_data(topic: str, n: int = 10):
    """특정 주제에 대한 학습 데이터를 합성 생성"""
    response = client.messages.create(
        model="claude-sonnet-4-6",
        max_tokens=4096,
        system="당신은 데이터 엔지니어링 학습 데이터 생성 전문가입니다.",
        messages=[{
            "role": "user",
            "content": f"""'{topic}' 주제로 Fine-Tuning 학습 데이터를 {n}개 생성하세요.
 
형식:
[
  {{
    "instruction": "구체적이고 실무적인 질문",
    "output": "정확하고 상세한 답변 (코드 예시 포함)"
  }}
]
 
요구사항:
- 초급/중급/고급 난이도 균등 배분
- 실무에서 자주 발생하는 시나리오 포함
- 코드 예시는 실행 가능한 수준으로 작성"""
        }]
    )
    return response.content[0].text
 
# 다양한 주제로 데이터 생성
topics = ["Spark 성능 튜닝", "Kafka 운영 이슈", "Airflow DAG 설계"]
for topic in topics:
    data = generate_training_data(topic, n=20)
    # 생성된 데이터를 검수 후 학습셋에 추가

import torch
from transformers import (
    AutoModelForCausalLM,
    AutoTokenizer,
    TrainingArguments,
    BitsAndBytesConfig
)
from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
from trl import SFTTrainer
from datasets import load_dataset
 
# 1. 모델 로드 (QLoRA: 4비트 양자화)
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.bfloat16,
    bnb_4bit_use_double_quant=True
)
 
model = AutoModelForCausalLM.from_pretrained(
    "meta-llama/Llama-3.1-8B-Instruct",
    quantization_config=bnb_config,
    device_map="auto",
    torch_dtype=torch.bfloat16
)
 
tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-3.1-8B-Instruct")
tokenizer.pad_token = tokenizer.eos_token
 
# 2. LoRA 설정
lora_config = LoraConfig(
    r=16,
    lora_alpha=32,
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj",
                     "gate_proj", "up_proj", "down_proj"],
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM"
)
 
model = prepare_model_for_kbit_training(model)
model = get_peft_model(model, lora_config)
model.print_trainable_parameters()
# trainable params: 6,553,600 || all params: 8,036,487,168 || trainable%: 0.0816
 
# 3. 데이터셋 로드
dataset = load_dataset("json", data_files="training_data.json", split="train")
 
# 4. 학습 설정
training_args = TrainingArguments(
    output_dir="./output",
    num_train_epochs=3,
    per_device_train_batch_size=4,
    gradient_accumulation_steps=4,      # 실효 배치 크기: 4 × 4 = 16
    learning_rate=2e-4,
    warmup_ratio=0.1,
    lr_scheduler_type="cosine",
    logging_steps=10,
    save_strategy="epoch",
    fp16=False,
    bf16=True,
    optim="paged_adamw_8bit",           # 메모리 효율적 옵티마이저
    gradient_checkpointing=True,        # 메모리 절약
    max_grad_norm=0.3,
    report_to="wandb"                   # 학습 모니터링
)
 
# 5. 학습 실행
trainer = SFTTrainer(
    model=model,
    args=training_args,
    train_dataset=dataset,
    tokenizer=tokenizer,
    max_seq_length=2048
)
 
trainer.train()
 
# 6. LoRA 어댑터 저장
model.save_pretrained("./lora_adapter")
tokenizer.save_pretrained("./lora_adapter")

from openai import OpenAI
 
client = OpenAI()
 
# 1. 학습 데이터 준비 (JSONL 형식)
# training_data.jsonl 파일 내용:
# {"messages": [{"role": "system", "content": "..."}, {"role": "user", "content": "..."}, {"role": "assistant", "content": "..."}]}
 
# 2. 파일 업로드
file = client.files.create(
    file=open("training_data.jsonl", "rb"),
    purpose="fine-tune"
)
 
# 3. Fine-Tuning 작업 생성
job = client.fine_tuning.jobs.create(
    training_file=file.id,
    model="gpt-4o-mini-2024-07-18",
    hyperparameters={
        "n_epochs": 3,
        "batch_size": "auto",
        "learning_rate_multiplier": "auto"
    },
    suffix="data-dynamics-assistant"
)
 
# 4. 학습 상태 모니터링
status = client.fine_tuning.jobs.retrieve(job.id)
print(f"Status: {status.status}")
# Status: running → succeeded
 
# 5. Fine-Tuned 모델 사용
response = client.chat.completions.create(
    model="ft:gpt-4o-mini-2024-07-18:data-dynamics::abc123",  # Fine-Tuned 모델 ID
    messages=[
        {"role": "user", "content": "Spark에서 데이터 스큐를 해결하는 방법은?"}
    ]
)

# 1. Gradient Checkpointing: 중간 활성화 값 재계산으로 메모리 절약
model.gradient_checkpointing_enable()
 
# 2. Gradient Accumulation: 작은 배치를 누적하여 큰 실효 배치 크기 구현
training_args = TrainingArguments(
    per_device_train_batch_size=2,     # GPU당 배치 크기
    gradient_accumulation_steps=8,     # 실효 배치: 2 × 8 = 16
)
 
# 3. Mixed Precision: BF16/FP16으로 메모리 절반 사용
training_args = TrainingArguments(bf16=True)
 
# 4. DeepSpeed ZeRO: 멀티 GPU 메모리 분산
training_args = TrainingArguments(deepspeed="ds_config.json")

# lm-evaluation-harness를 이용한 벤치마크 평가
# pip install lm-eval
 
# 커맨드라인 실행
# lm_eval --model hf \
#   --model_args pretrained=./merged_model \
#   --tasks mmlu,hellaswag,arc_easy \
#   --batch_size 8

import random
 
def ab_test(query: str, model_a, model_b, n_trials: int = 100):
    """Fine-Tuning 전후 모델 A/B 테스트"""
    results = {"model_a_wins": 0, "model_b_wins": 0, "tie": 0}
 
    for _ in range(n_trials):
        response_a = model_a.generate(query)
        response_b = model_b.generate(query)
 
        # 블라인드 평가 (평가자에게 어떤 모델인지 숨김)
        if random.random() > 0.5:
            responses = [("A", response_a), ("B", response_b)]
        else:
            responses = [("A", response_b), ("B", response_a)]
 
        # 평가자 판정 (자동 또는 사람)
        winner = evaluate_responses(responses)
        results[f"model_{winner}_wins"] += 1
 
    return results

# vLLM을 이용한 Fine-Tuned 모델 서빙
from vllm import LLM, SamplingParams
 
# LoRA 어댑터가 병합된 모델 또는 어댑터 경로 지정
llm = LLM(
    model="./merged_model",     # 병합된 모델 경로
    # 또는
    # model="meta-llama/Llama-3.1-8B-Instruct",
    # enable_lora=True,
    # lora_modules=[{"name": "my_adapter", "path": "./lora_adapter"}],
    tensor_parallel_size=1,
    gpu_memory_utilization=0.9,
    max_model_len=4096
)
 
sampling_params = SamplingParams(
    temperature=0.7,
    top_p=0.9,
    max_tokens=1024
)
 
# 추론
outputs = llm.generate(["Spark에서 데이터 스큐를 해결하는 방법은?"], sampling_params)
print(outputs[0].outputs[0].text)

# vLLM OpenAI 호환 API 서버 실행
python -m vllm.entrypoints.openai.api_server \
    --model ./merged_model \
    --host 0.0.0.0 \
    --port 8000 \
    --max-model-len 4096