2장: 학습 데이터 설계와 구축

작업 유형별 권장 데이터 규모:
 
  단순 분류/추출:         500 ~ 2,000개
  지시 따르기 (일반):     1,000 ~ 5,000개
  도메인 특화 대화:       3,000 ~ 10,000개
  복잡한 추론 작업:       5,000 ~ 20,000개
  다국어/다중 작업:       10,000 ~ 50,000개

{
  "instruction": "주어진 SQL 쿼리를 최적화해 주세요.",
  "input": "SELECT * FROM users WHERE created_at > '2025-01-01' AND status = 'active' ORDER BY created_at DESC",
  "output": "최적화된 쿼리:\n\nSELECT id, name, email, created_at\nFROM users\nWHERE status = 'active'\n  AND created_at > '2025-01-01'\nORDER BY created_at DESC\n\n변경 사항:\n1. SELECT *를 필요한 컬럼만 명시하도록 변경했습니다.\n2. WHERE 조건에서 선택도가 높은 status 조건을 먼저 배치했습니다.\n3. (status, created_at) 복합 인덱스 생성을 권장합니다."
}

{
  "messages": [
    {
      "role": "system",
      "content": "당신은 시니어 백엔드 엔지니어입니다. 코드 리뷰를 수행할 때 보안, 성능, 가독성 관점에서 구체적인 개선 사항을 제시합니다."
    },
    {
      "role": "user",
      "content": "이 API 엔드포인트를 리뷰해 주세요.\n\ndef get_user(user_id):\n    query = \"SELECT * FROM users WHERE id = \" + str(user_id)\n    return db.execute(query)"
    },
    {
      "role": "assistant",
      "content": "이 코드에는 심각한 보안 취약점과 몇 가지 개선 사항이 있습니다.\n\n1. SQL 인젝션 취약점: 문자열 연결로 쿼리를 구성하고 있어 SQL 인젝션 공격에 노출됩니다. 파라미터 바인딩을 사용해야 합니다.\n\n2. SELECT * 사용: 필요한 컬럼만 명시적으로 지정하는 것이 성능과 보안 측면에서 바람직합니다.\n\n3. 에러 처리 부재: 사용자가 존재하지 않는 경우의 처리가 없습니다.\n\n개선된 코드를 제안합니다."
    }
  ]
}

{
  "prompt": "Python 딕셔너리에서 특정 키가 존재하는지 확인하는 방법은?",
  "chosen": "Python에서 딕셔너리의 키 존재 여부를 확인하는 가장 권장되는 방법은 in 연산자를 사용하는 것입니다.\n\nif 'key' in my_dict:\n    value = my_dict['key']\n\n또는 .get() 메서드를 사용하면 키가 없을 때 기본값을 반환받을 수 있습니다.\n\nvalue = my_dict.get('key', default_value)\n\n.get()은 KeyError를 방지하면서 코드를 간결하게 작성할 수 있어 실무에서 자주 사용됩니다.",
  "rejected": "has_key 메서드를 사용하면 됩니다. my_dict.has_key('key')로 확인할 수 있습니다."
}

# 기존 고객 상담 로그를 학습 데이터로 변환하는 예시
import json
 
def convert_support_logs(logs):
    training_data = []
    for log in logs:
        if log["resolution_rating"] >= 4:  # 높은 평가를 받은 상담만
            entry = {
                "messages": [
                    {
                        "role": "system",
                        "content": "고객 지원 담당자로서 정확하고 "
                                   "친절한 응답을 제공합니다."
                    },
                    {
                        "role": "user",
                        "content": log["customer_query"]
                    },
                    {
                        "role": "assistant",
                        "content": log["agent_response"]
                    }
                ]
            }
            training_data.append(entry)
    return training_data

# Claude API를 사용한 합성 데이터 생성 예시
import anthropic
 
client = anthropic.Anthropic()
 
def generate_synthetic_data(topic, num_examples):
    prompt = (
        "다음 주제에 대한 고품질 SFT 학습 데이터를 "
        + str(num_examples) + "개 생성해 주세요.\n\n"
        "주제: " + topic + "\n\n"
        "각 예제는 다음 JSON 형식을 따라야 합니다:\n"
        '{"instruction": "...", "input": "...", "output": "..."}\n\n'
        "요구사항:\n"
        "1. instruction은 구체적이고 다양해야 합니다.\n"
        "2. output은 정확하고 상세해야 합니다.\n"
        "3. 난이도를 초급/중급/고급으로 골고루 분포시켜 주세요.\n"
        "4. 각 예제는 JSON 형식으로, 하나씩 줄바꿈으로 구분해 주세요."
    )
 
    response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=4096,
        messages=[{"role": "user", "content": prompt}]
    )
    return response.content[0].text

Self-Instruct 파이프라인:
 
  시드 예제 (수십 개)
       |
  LLM으로 새로운 instruction 생성
       |
  중복/저품질 필터링
       |
  LLM으로 각 instruction에 대한 output 생성
       |
  품질 검증 및 필터링
       |
  최종 학습 데이터셋

다양성 차원:
 
  입력 다양성:
    - 질문/지시의 형태 (명령형, 의문형, 조건부 등)
    - 주제 범위 (도메인 내 다양한 하위 주제)
    - 난이도 분포 (초급 ~ 고급)
    - 입력 길이 분포 (짧은 질문 ~ 긴 문맥)
 
  출력 다양성:
    - 응답 길이 분포 (한 줄 ~ 여러 단락)
    - 응답 형식 (설명, 코드, 목록, 비교표 등)
    - 어조와 격식 수준

from collections import Counter
import numpy as np
 
def measure_diversity(dataset):
    """학습 데이터의 다양성을 측정하는 간단한 방법"""
 
    # 1. 입력 길이 분포
    input_lengths = [len(d["instruction"].split()) for d in dataset]
    print("입력 길이 - 평균: " + str(np.mean(input_lengths))
          + ", 표준편차: " + str(np.std(input_lengths)))
 
    # 2. 출력 길이 분포
    output_lengths = [len(d["output"].split()) for d in dataset]
    print("출력 길이 - 평균: " + str(np.mean(output_lengths))
          + ", 표준편차: " + str(np.std(output_lengths)))
 
    # 3. 시작 단어 다양성 (응답 패턴 편중 감지)
    first_words = [d["output"].split()[0] for d in dataset if d["output"]]
    word_counts = Counter(first_words)
    top_5 = word_counts.most_common(5)
    print("가장 빈번한 시작 단어: " + str(top_5))
 
    # 4. 고유 n-gram 비율
    all_words = " ".join([d["output"] for d in dataset]).split()
    bigrams = list(zip(all_words[:-1], all_words[1:]))
    unique_ratio = len(set(bigrams)) / len(bigrams) if bigrams else 0
    print("고유 바이그램 비율: " + str(round(unique_ratio, 4)))

<|im_start|>system
당신은 숙련된 Python 개발자입니다.<|im_end|>
<|im_start|>user
리스트 컴프리헨션의 사용법을 알려주세요.<|im_end|>
<|im_start|>assistant
리스트 컴프리헨션은 기존 리스트에서 새로운 리스트를 생성하는 간결한 방법입니다...<|im_end|>

<s>[INST] <<SYS>>
당신은 숙련된 Python 개발자입니다.
<</SYS>>
 
리스트 컴프리헨션의 사용법을 알려주세요. [/INST]
 
리스트 컴프리헨션은 기존 리스트에서 새로운 리스트를 생성하는 간결한 방법입니다... </s>

from transformers import AutoTokenizer
 
tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-3.1-8B-Instruct")
 
messages = [
    {"role": "system", "content": "당신은 숙련된 Python 개발자입니다."},
    {"role": "user", "content": "리스트 컴프리헨션의 사용법을 알려주세요."},
]
 
# 토크나이저의 내장 템플릿 적용
formatted = tokenizer.apply_chat_template(
    messages,
    tokenize=False,
    add_generation_prompt=True
)
print(formatted)

from sklearn.model_selection import train_test_split
 
def split_dataset(data, test_size=0.1, val_size=0.1, seed=42):
    """학습 데이터를 train/val/test로 분할"""
 
    # test 세트 분리
    train_val, test = train_test_split(
        data, test_size=test_size, random_state=seed
    )
 
    # validation 세트 분리
    adjusted_val_size = val_size / (1 - test_size)
    train, val = train_test_split(
        train_val, test_size=adjusted_val_size, random_state=seed
    )
 
    print("Train: " + str(len(train))
          + ", Val: " + str(len(val))
          + ", Test: " + str(len(test)))
    return train, val, test