이미지 로딩 중...
AI Generated
2025. 11. 12. · 6 Views
바닥부터 만드는 ChatGPT MMLU와 GSM8K 벤치마크 학습
ChatGPT 같은 대형 언어 모델의 성능을 측정하는 두 가지 핵심 벤치마크인 MMLU와 GSM8K를 직접 구현하고 학습시키는 방법을 알아봅니다. 실제 벤치마크 데이터셋을 활용하여 모델을 평가하고 개선하는 전체 과정을 다룹니다.
목차
- MMLU 벤치마크 이해 - 다분야 언어 이해 테스트
- GSM8K 벤치마크 이해 - 수학적 추론 능력 테스트
- Chain-of-Thought 프롬프팅 - 단계별 사고 유도
- 벤치마크 데이터로 파인튜닝 - 성능 향상의 핵심
- MMLU 멀티태스크 학습 - 범용성 확보
- 평가 메트릭과 오류 분석 - 개선 방향 찾기
- 벤치마크 리더보드와 경쟁 - 최신 기술 동향 파악
- 학습 데이터 품질 개선 - 고품질 데이터의 중요성
- 프롬프트 엔지니어링 고급 기법 - 성능 극대화
1. MMLU 벤치마크 이해 - 다분야 언어 이해 테스트
시작하며
여러분이 직접 만든 언어 모델이 얼마나 똑똑한지 궁금하신 적 있나요? 수학, 역사, 과학 등 다양한 분야의 질문에 제대로 답할 수 있는지 객관적으로 측정하고 싶으실 겁니다.
이런 문제는 AI 모델 개발자들이 항상 직면하는 과제입니다. 주관적인 평가로는 모델의 실제 능력을 정확히 파악하기 어렵고, 다른 모델들과 비교하는 것도 불가능합니다.
특히 ChatGPT처럼 범용적인 대화 모델을 만들 때는 다양한 분야의 지식을 고르게 평가해야 합니다. 바로 이럴 때 필요한 것이 MMLU(Massive Multitask Language Understanding) 벤치마크입니다.
57개의 다양한 과목에 걸쳐 15,908개의 객관식 문제로 모델의 종합적인 지식을 평가할 수 있습니다.
개요
간단히 말해서, MMLU는 언어 모델이 얼마나 폭넓은 지식을 가지고 있는지 측정하는 표준화된 시험입니다. 이 벤치마크가 필요한 이유는 실제 세계에서 AI는 단일 분야가 아닌 다양한 주제에 대해 질문을 받기 때문입니다.
예를 들어, 사용자가 "양자역학의 불확정성 원리를 설명해줘"라고 물었다가 바로 "미국 남북전쟁의 원인은 뭐야?"라고 물을 수 있습니다. 이런 상황에서 모델이 모든 분야에서 일관되게 좋은 성능을 보이는지 확인해야 합니다.
기존에는 단일 도메인의 QA 데이터셋으로 평가했다면, 이제는 STEM(과학, 기술, 공학, 수학), 인문학, 사회과학, 기타 전문 분야를 모두 아우르는 종합 평가가 가능합니다. MMLU의 핵심 특징은 첫째, 57개 과목으로 구성된 광범위한 커버리지, 둘째, 4지선다형 객관식 형식으로 자동 평가가 가능하다는 점, 셋째, 난이도가 높아 GPT-3도 57%의 정확도를 보인다는 점입니다.
이러한 특징들이 모델의 실제 지능을 정확히 측정하는 데 중요합니다.
코드 예제
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer
from datasets import load_dataset
# MMLU 데이터셋 로드
mmlu_dataset = load_dataset("cais/mmlu", "all")
# 모델과 토크나이저 초기화
model = AutoModelForCausalLM.from_pretrained("gpt2")
tokenizer = AutoTokenizer.from_pretrained("gpt2")
tokenizer.pad_token = tokenizer.eos_token
def evaluate_mmlu(model, tokenizer, dataset, subject="abstract_algebra"):
correct = 0
total = 0
for example in dataset[subject]['test']:
# 질문과 선택지 포맷팅
question = example['question']
choices = example['choices']
answer = example['answer'] # 0, 1, 2, 3 중 하나
# 프롬프트 구성: "Question: ... A) ... B) ... C) ... D) ... Answer:"
prompt = f"Question: {question}\n"
for idx, choice in enumerate(choices):
prompt += f"{chr(65+idx)}) {choice}\n"
prompt += "Answer:"
# 모델 추론
inputs = tokenizer(prompt, return_tensors="pt", padding=True)
with torch.no_grad():
outputs = model.generate(
inputs.input_ids,
max_new_tokens=1,
pad_token_id=tokenizer.pad_token_id
)
# 생성된 답변 추출
generated_text = tokenizer.decode(outputs[0], skip_special_tokens=True)
predicted_answer = generated_text.split("Answer:")[-1].strip()[0].upper()
# 정답 확인
correct_answer = chr(65 + answer)
if predicted_answer == correct_answer:
correct += 1
total += 1
accuracy = correct / total * 100
print(f"{subject} 정확도: {accuracy:.2f}%")
return accuracy
# 평가 실행
accuracy = evaluate_mmlu(model, tokenizer, mmlu_dataset)
설명
이것이 하는 일: 이 코드는 Hugging Face의 MMLU 데이터셋을 로드하고, 특정 과목에 대해 언어 모델의 정확도를 측정합니다. 4지선다 객관식 문제를 모델에게 제시하고, 생성된 답변이 정답과 일치하는지 확인합니다.
첫 번째로, load_dataset("cais/mmlu", "all")로 전체 MMLU 데이터셋을 다운로드하고, GPT-2 모델과 토크나이저를 초기화합니다. 이때 pad_token을 설정하는 이유는 배치 처리 시 길이가 다른 입력을 맞추기 위함입니다.
데이터셋은 과목별로 구조화되어 있어서 dataset[subject]['test']로 특정 과목의 테스트 셋에 접근할 수 있습니다. 두 번째로, 각 문제를 반복하면서 프롬프트를 구성합니다.
"Question: ... A) ...
B) ... C) ...
D) ... Answer:" 형식으로 문제와 선택지를 배치하는데, 이 형식이 중요한 이유는 모델이 이런 구조를 학습 데이터에서 많이 봤기 때문입니다.
chr(65+idx)는 ASCII 코드를 활용해 0, 1, 2, 3을 A, B, C, D로 변환하는 트릭입니다. 세 번째로, model.generate()로 답변을 생성하되 max_new_tokens=1로 제한하여 A, B, C, D 중 하나만 생성하도록 합니다.
torch.no_grad()는 그래디언트 계산을 비활성화하여 메모리를 절약하고 추론 속도를 높입니다. 생성된 텍스트에서 "Answer:" 뒤의 첫 글자를 추출하여 모델의 예측으로 사용합니다.
마지막으로, 예측한 답변과 실제 정답을 비교하여 정확도를 계산합니다. 이 과정을 전체 테스트 셋에 반복하면 해당 과목에서의 모델 성능을 정확히 알 수 있습니다.
여러분이 이 코드를 사용하면 자신의 모델이 어떤 분야에서 강하고 약한지 파악할 수 있습니다. 예를 들어, 수학에서는 80% 정확도를 보이지만 역사에서는 40%라면, 역사 관련 학습 데이터를 더 추가해야 한다는 것을 알 수 있습니다.
또한 다른 연구자들의 모델과 객관적으로 비교할 수 있어 논문 작성이나 모델 개선 방향 설정에 매우 유용합니다.
실전 팁
💡 MMLU 평가 시 Few-shot learning을 활용하세요. 프롬프트에 2-3개의 예시 문제와 답변을 먼저 제시하면 모델의 정확도가 크게 향상됩니다. "Question: ... Answer: B\nQuestion: ... Answer: C\nQuestion: [실제 문제]" 형식으로 구성하면 됩니다.
💡 전체 57개 과목을 한 번에 평가하면 시간이 오래 걸리므로, 처음에는 대표적인 4-5개 과목만 선택해서 빠르게 반복 평가하세요. 예를 들어 abstract_algebra, anatomy, astronomy, business_ethics 정도면 모델의 전반적인 경향을 파악할 수 있습니다.
💡 모델이 "A", "a", "A)", "Option A" 등 다양한 형식으로 답변할 수 있으므로, 정규표현식을 사용해 답변을 파싱하는 것이 안전합니다. re.search(r'[A-D]', generated_text)를 사용하면 첫 번째로 등장하는 A-D를 찾아냅니다.
💡 배치 처리를 활용하면 평가 속도를 10배 이상 높일 수 있습니다. model.generate()에 여러 프롬프트를 한 번에 넣고, attention_mask와 padding을 올바르게 설정하면 GPU를 효율적으로 사용할 수 있습니다.
💡 과목별 정확도를 시각화하여 레이더 차트나 히트맵으로 만들면 모델의 강점과 약점을 한눈에 파악할 수 있습니다. Matplotlib이나 Seaborn을 활용하세요.
2. GSM8K 벤치마크 이해 - 수학적 추론 능력 테스트
시작하며
여러분의 언어 모델이 "사과 10개를 3명이 똑같이 나눠 먹으면 한 명당 몇 개?"라는 간단한 초등학교 수학 문제를 푸는 것조차 어려워하는 모습을 본 적 있나요? 단순 암기가 아닌 실제 추론이 필요한 문제에서 AI가 놀랍도록 취약한 경우가 많습니다.
이런 문제는 언어 모델의 근본적인 한계를 드러냅니다. 문장 생성은 잘하지만, 여러 단계의 논리적 사고를 거쳐 답을 도출하는 능력은 부족합니다.
특히 실생활에서 마주치는 응용 문제는 공식을 단순히 적용하는 것이 아니라, 문제를 이해하고 단계별로 풀어나가야 합니다. 바로 이럴 때 필요한 것이 GSM8K(Grade School Math 8K) 벤치마크입니다.
초등학교 수준의 수학 문장제 8,500개로 모델의 다단계 추론 능력을 정확히 측정할 수 있습니다.
개요
간단히 말해서, GSM8K는 언어 모델이 수학적 추론을 얼마나 잘 수행하는지 평가하는 데이터셋입니다. 초등학교 수준이지만 2-8단계의 풀이 과정이 필요합니다.
이 벤치마크가 필요한 이유는 실제 세계의 많은 문제가 수학적 추론을 요구하기 때문입니다. 예를 들어, "예산이 100만원인데 책상 15개를 사야 하고 한 개당 5만원이면 의자는 몇 개까지 살 수 있어?
(의자 한 개는 2만원)" 같은 문제는 여러 단계의 계산과 논리를 필요로 합니다. 실제 비즈니스 환경에서 AI 어시스턴트가 이런 질문에 답하지 못하면 실용성이 크게 떨어집니다.
기존에는 MATH 데이터셋처럼 고난도 수학 문제로 평가했다면, 이제는 초등학교 수준이지만 다단계 추론이 필요한 문제로 모델의 기본적인 추론 능력을 체크합니다. GSM8K의 핵심 특징은 첫째, 자연어로 작성된 문장제라서 언어 이해 능력도 함께 평가한다는 점, 둘째, 각 문제에 단계별 풀이 과정이 포함되어 있어 Chain-of-Thought 학습에 활용할 수 있다는 점, 셋째, 숫자의 정확한 계산이 필요해서 모델의 한계를 명확히 드러낸다는 점입니다.
이러한 특징들이 언어 모델의 진정한 추론 능력을 평가하는 데 중요합니다.
코드 예제
import re
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer
from datasets import load_dataset
# GSM8K 데이터셋 로드
gsm8k_dataset = load_dataset("gsm8k", "main")
# 모델과 토크나이저 초기화
model = AutoModelForCausalLM.from_pretrained("gpt2")
tokenizer = AutoTokenizer.from_pretrained("gpt2")
tokenizer.pad_token = tokenizer.eos_token
def extract_answer(text):
"""생성된 텍스트에서 최종 답변(숫자) 추출"""
# "####" 뒤의 숫자를 찾거나, 마지막 숫자를 추출
match = re.search(r'####\s*(-?\d+(?:,\d+)*(?:\.\d+)?)', text)
if match:
return float(match.group(1).replace(',', ''))
# 텍스트 끝부분에서 숫자 찾기
numbers = re.findall(r'-?\d+(?:,\d+)*(?:\.\d+)?', text)
if numbers:
return float(numbers[-1].replace(',', ''))
return None
def evaluate_gsm8k(model, tokenizer, dataset, num_samples=100):
correct = 0
total = 0
for idx, example in enumerate(dataset['test']):
if idx >= num_samples:
break
question = example['question']
answer_text = example['answer']
# 정답 추출 (#### 뒤의 숫자)
ground_truth = extract_answer(answer_text)
# Chain-of-Thought 프롬프트 구성
prompt = f"Question: {question}\nLet's solve this step by step:\n"
# 모델 추론
inputs = tokenizer(prompt, return_tensors="pt", padding=True)
with torch.no_grad():
outputs = model.generate(
inputs.input_ids,
max_new_tokens=256,
temperature=0.7,
do_sample=False, # Greedy decoding for consistency
pad_token_id=tokenizer.pad_token_id
)
# 생성된 풀이 과정
generated_text = tokenizer.decode(outputs[0], skip_special_tokens=True)
predicted_answer = extract_answer(generated_text)
# 정답 확인 (숫자 비교)
if predicted_answer is not None and ground_truth is not None:
if abs(predicted_answer - ground_truth) < 0.01: # 부동소수점 오차 고려
correct += 1
total += 1
if (idx + 1) % 10 == 0:
print(f"진행: {idx + 1}/{num_samples}, 현재 정확도: {correct/total*100:.2f}%")
accuracy = correct / total * 100 if total > 0 else 0
print(f"\n최종 GSM8K 정확도: {accuracy:.2f}% ({correct}/{total})")
return accuracy
# 평가 실행
accuracy = evaluate_gsm8k(model, tokenizer, gsm8k_dataset, num_samples=100)
설명
이것이 하는 일: 이 코드는 GSM8K 데이터셋을 로드하고, 수학 문장제를 모델에게 제시한 후 생성된 답변에서 숫자를 추출하여 정답과 비교합니다. Chain-of-Thought 방식으로 단계별 풀이를 유도합니다.
첫 번째로, load_dataset("gsm8k", "main")으로 GSM8K 데이터셋을 가져옵니다. 각 문제는 question(문제)과 answer(풀이 과정과 정답)로 구성되어 있습니다.
정답은 "####" 뒤에 숫자 형태로 표시되어 있어서, 이를 파싱하는 extract_answer 함수를 만듭니다. 이 함수는 정규표현식을 사용해 쉼표가 포함된 숫자나 소수점도 올바르게 처리합니다.
두 번째로, 프롬프트를 "Question: ... Let's solve this step by step:" 형식으로 구성합니다.
이 "step by step" 문구가 핵심인데, 이것이 모델에게 중간 추론 과정을 출력하도록 유도합니다. Chain-of-Thought 방식은 최근 연구에서 수학 문제 해결 능력을 크게 향상시키는 것으로 밝혀졌습니다.
모델이 "먼저 ... 을 계산하고, 그 다음 ...
을 하면" 같은 식으로 사고 과정을 드러내면 최종 답의 정확도가 높아집니다. 세 번째로, model.generate()로 최대 256토큰까지 생성하되 do_sample=False로 설정하여 Greedy decoding을 사용합니다.
이렇게 하면 매번 가장 확률이 높은 토큰을 선택하여 일관된 결과를 얻을 수 있습니다. 수학 문제는 창의성보다 정확성이 중요하므로 샘플링을 사용하지 않는 것이 좋습니다.
마지막으로, 생성된 텍스트에서 extract_answer로 숫자를 추출하고, 정답과 비교합니다. 부동소수점 오차를 고려하여 abs(predicted - ground_truth) < 0.01로 비교하는 것이 중요합니다.
단순히 ==로 비교하면 0.999999와 1.0을 다르게 판단할 수 있습니다. 여러분이 이 코드를 사용하면 모델의 수학적 추론 능력을 정량적으로 측정할 수 있습니다.
GPT-2는 5-10% 정도의 낮은 정확도를 보이지만, GPT-3.5는 57%, GPT-4는 92%의 정확도를 달성했습니다. 여러분의 모델이 어느 수준인지 확인하고, 파인튜닝이나 프롬프트 엔지니어링으로 개선할 방향을 찾을 수 있습니다.
또한 어떤 유형의 문제(곱셈, 나눗셈, 분수 등)에서 실수가 많은지 분석하여 타겟팅된 학습 데이터를 추가할 수 있습니다.
실전 팁
💡 Few-shot prompting을 적극 활용하세요. 프롬프트에 2-3개의 예제 문제와 단계별 풀이를 먼저 제시하면 모델의 정확도가 2-3배 향상됩니다. "Question: ... Step 1: ... Step 2: ... Answer: ####\nQuestion: [실제 문제]" 형식이 효과적입니다.
💡 계산 오류를 줄이기 위해 Python 코드 생성 방식을 시도해보세요. 모델에게 "Let's write Python code to solve this:"라고 프롬프트를 주면, 코드를 생성하고 exec()로 실행하여 정확한 숫자 계산이 가능합니다. 언어 모델은 직접 계산보다 코드 작성을 더 잘하는 경향이 있습니다.
💡 평가 시 생성된 풀이 과정을 로깅하여 오답 분석을 하세요. 어느 단계에서 논리적 오류가 발생했는지 파악하면, 해당 유형의 문제를 더 학습시킬 수 있습니다. 예를 들어 "분수 계산에서 자주 실수함"을 발견하면 분수 문제를 추가 학습시킵니다.
💡 정답 추출 정규표현식을 견고하게 만드세요. "$500", "500달러", "500.00", "500,000" 등 다양한 형식을 모두 처리할 수 있어야 합니다. 단위 변환 문제(예: 시간을 분으로)도 고려하세요.
💡 Timeout을 설정하여 무한 루프를 방지하세요. 일부 모델은 수학 문제에서 같은 계산을 반복하거나 토큰을 무한히 생성하려고 합니다. max_new_tokens=256으로 제한하고, 실제 시간 제한도 추가하면 안전합니다.
3. Chain-of-Thought 프롬프팅 - 단계별 사고 유도
시작하며
여러분의 모델이 복잡한 문제를 풀 때 중간 과정 없이 바로 답만 내놓다가 틀리는 경우가 많나요? 마치 시험에서 풀이 과정 없이 답만 쓴 학생처럼, 어떻게 그 결론에 도달했는지 알 수 없어서 디버깅도 어렵습니다.
이런 문제는 언어 모델이 "블랙박스"처럼 작동할 때 발생합니다. 입력을 받으면 내부 계산 후 출력만 내보내는데, 중간 추론 과정을 거치지 않으면 복잡한 다단계 문제에서 오류가 쌓입니다.
특히 수학이나 논리 문제처럼 순차적인 사고가 필요한 경우, 한 단계라도 틀리면 전체가 틀립니다. 바로 이럴 때 필요한 것이 Chain-of-Thought(CoT) 프롬프팅입니다.
모델에게 중간 추론 단계를 출력하도록 유도하면, 정확도가 크게 향상되고 오류 진단도 쉬워집니다.
개요
간단히 말해서, Chain-of-Thought는 모델이 답을 내기 전에 사고 과정을 단계별로 표현하도록 하는 프롬프팅 기법입니다. 이 기법이 필요한 이유는 인간의 사고 방식을 모방하기 때문입니다.
우리가 어려운 문제를 풀 때 머릿속으로 "먼저 이걸 하고, 그 다음 저걸 하면 되겠네"라고 생각하듯이, 모델도 중간 단계를 생성하면서 자기 자신의 출력을 "읽고" 다음 단계를 생성합니다. 예를 들어, "철수가 사과 3개를 가지고 있고, 영희가 철수보다 2배 많으면 영희는 몇 개?" 같은 문제에서 "영희 = 철수 × 2 = 3 × 2 = 6"이라는 중간 과정을 거치면 실수할 확률이 줄어듭니다.
기존에는 "Question: ... Answer:"처럼 직접 답을 요구했다면, 이제는 "Question: ...
Let's think step by step. First, ...
Then, ... Therefore, ..."처럼 사고 과정을 유도합니다.
CoT의 핵심 특징은 첫째, Few-shot 예제에 단계별 풀이를 포함시키는 것만으로도 효과가 있다는 점, 둘째, 모델 크기가 클수록(100B+ 파라미터) 효과가 크다는 점, 셋째, Zero-shot CoT("Let's think step by step"만 추가)도 작동한다는 점입니다. 이러한 특징들이 추가 학습 없이 프롬프트만으로 성능을 높이는 데 중요합니다.
코드 예제
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer
# 모델 초기화
model = AutoModelForCausalLM.from_pretrained("gpt2-xl") # 더 큰 모델이 CoT에 효과적
tokenizer = AutoTokenizer.from_pretrained("gpt2-xl")
def zero_shot_cot(question, model, tokenizer):
"""Zero-shot Chain-of-Thought: 'Let's think step by step' 추가"""
prompt = f"Q: {question}\nA: Let's think step by step."
inputs = tokenizer(prompt, return_tensors="pt")
with torch.no_grad():
outputs = model.generate(
inputs.input_ids,
max_new_tokens=200,
temperature=0.7,
do_sample=False
)
result = tokenizer.decode(outputs[0], skip_special_tokens=True)
return result
def few_shot_cot(question, model, tokenizer):
"""Few-shot Chain-of-Thought: 예제에 풀이 과정 포함"""
# 2-3개의 예제와 단계별 풀이
prompt = """Q: 철수는 구슬을 15개 가지고 있습니다. 영희가 철수보다 3개 더 많이 가지고 있다면, 두 사람이 가진 구슬은 총 몇 개인가요?
A: Let's solve this step by step.
Step 1: 영희가 가진 구슬 = 철수 + 3 = 15 + 3 = 18개
Step 2: 총 구슬 = 철수 + 영희 = 15 + 18 = 33개
Therefore, the answer is 33.
Q: 한 상자에 사과가 24개씩 들어있습니다. 5상자를 사면 총 몇 개의 사과를 갖게 되나요?
A: Let's solve this step by step.
Step 1: 총 사과 = 한 상자의 사과 × 상자 수
Step 2: 총 사과 = 24 × 5 = 120개
Therefore, the answer is 120.
Q: {question}
A: Let's solve this step by step."""
inputs = tokenizer(prompt, return_tensors="pt")
with torch.no_grad():
outputs = model.generate(
inputs.input_ids,
max_new_tokens=200,
temperature=0.7,
do_sample=False
)
result = tokenizer.decode(outputs[0], skip_special_tokens=True)
return result
# 실제 문제로 테스트
question = "민수는 돈을 12000원 가지고 있습니다. 빵 한 개가 1500원일 때, 빵을 5개 사면 얼마가 남나요?"
print("=== Zero-shot CoT ===")
zero_result = zero_shot_cot(question, model, tokenizer)
print(zero_result)
print("\n=== Few-shot CoT ===")
few_result = few_shot_cot(question, model, tokenizer)
print(few_result)
설명
이것이 하는 일: 이 코드는 두 가지 Chain-of-Thought 방식(Zero-shot과 Few-shot)을 구현하여, 모델이 수학 문제를 풀 때 중간 단계를 거치도록 합니다. 같은 문제를 두 방식으로 풀어서 효과를 비교합니다.
첫 번째로, zero_shot_cot 함수는 가장 간단한 방식으로 "Let's think step by step"이라는 마법 같은 문구를 프롬프트에 추가합니다. 놀랍게도 이것만으로도 모델이 중간 추론 과정을 생성하기 시작합니다.
이는 2022년 Google의 연구에서 발견된 것으로, 모델이 학습 데이터에서 이런 패턴을 많이 봤기 때문에 자연스럽게 단계별 풀이 형식을 따라합니다. 추가 학습이나 파인튜닝 없이 프롬프트만 바꾸는 것이라 즉시 적용할 수 있습니다.
두 번째로, few_shot_cot 함수는 더 강력한 방식으로 2-3개의 예제 문제와 상세한 풀이 과정을 함께 제공합니다. 각 예제에서 "Step 1: ...
Step 2: ... Therefore, ..." 형식을 보여주면, 모델은 이 패턴을 학습하고 새로운 문제에도 같은 형식으로 답합니다.
이것은 Few-shot learning의 일종으로, 모델의 파라미터를 바꾸지 않고도 "맥락 내 학습"이 일어나는 것입니다. 예제의 품질이 매우 중요한데, 실제 문제와 유사한 유형의 예제를 선택해야 효과가 큽니다.
세 번째로, 두 함수 모두 do_sample=False로 설정하여 deterministic한 결과를 얻습니다. 수학 문제는 창의성이 아닌 정확성이 중요하므로, 매번 같은 입력에 같은 출력을 보장하는 것이 테스트와 디버깅에 유리합니다.
max_new_tokens=200은 충분한 추론 공간을 제공하면서도 너무 길어지지 않도록 합니다. 마지막으로, 실제 문제로 두 방식을 비교합니다.
일반적으로 Few-shot CoT가 Zero-shot보다 더 정확하지만, 프롬프트가 길어져서 토큰 비용이 증가하고 추론 시간도 늘어납니다. 여러분은 상황에 따라 trade-off를 고려하여 선택하면 됩니다.
여러분이 이 코드를 사용하면 기존 모델의 성능을 즉시 향상시킬 수 있습니다. 연구에 따르면 GSM8K에서 Zero-shot CoT는 17% → 40%로, Few-shot CoT는 17% → 57%로 정확도를 높였습니다.
파인튜닝이나 모델 교체 없이 프롬프트만 바꾸는 것이므로 비용 효율적입니다. 또한 중간 과정을 볼 수 있어서 모델이 어디서 실수했는지 파악하고, 프롬프트를 반복적으로 개선할 수 있습니다.
실전 팁
💡 예제 선택이 성능을 좌우합니다. Few-shot CoT에서는 평가할 문제와 유사한 유형의 예제를 사용하세요. 예를 들어, 곱셈 문제를 풀려면 곱셈 예제를, 분수 문제를 풀려면 분수 예제를 포함시키는 것이 효과적입니다.
💡 "Let's think step by step" 외에도 다양한 프롬프트를 실험해보세요. "Let's break this down:", "First, let's understand what we know:", "Step-by-step solution:" 등 모델과 문제 유형에 따라 더 효과적인 표현이 있을 수 있습니다.
💡 Self-Consistency 기법을 함께 사용하면 정확도를 더욱 높일 수 있습니다. 같은 문제를 5-10번 풀어서(do_sample=True, temperature=0.7) 가장 많이 나온 답을 최종 답으로 선택하면, 우연한 실수를 줄일 수 있습니다.
💡 중간 단계의 검증을 추가하세요. "Step 1: ... Is this correct? Yes. Step 2: ..."처럼 각 단계 후 자기 검증을 유도하면 오류를 조기에 발견할 수 있습니다. 이를 Self-Verification CoT라고 합니다.
💡 모델 크기가 중요합니다. CoT는 100B 이상의 대형 모델에서 가장 효과적이며, 작은 모델(GPT-2 등)에서는 효과가 미미합니다. 13B 이상의 모델을 사용하는 것을 권장합니다.
4. 벤치마크 데이터로 파인튜닝 - 성능 향상의 핵심
시작하며
여러분의 모델이 MMLU나 GSM8K에서 낮은 점수를 받았다면, 단순히 평가만 하고 끝낼 것이 아니라 그 데이터로 학습시켜서 성능을 개선하고 싶으실 겁니다. 벤치마크 점수가 낮다는 것은 모델이 그 유형의 문제를 잘 못 푼다는 의미이니까요.
이런 상황에서 많은 개발자들이 단순히 더 많은 데이터를 무작위로 추가하거나, 모델 크기만 키우려고 합니다. 하지만 이는 비효율적이고 비용도 많이 듭니다.
특정 약점을 타겟팅하여 해당 분야의 고품질 데이터로 파인튜닝하는 것이 훨씬 효과적입니다. 바로 이럴 때 필요한 것이 벤치마크 데이터를 활용한 타겟 파인튜닝입니다.
MMLU나 GSM8K의 학습 데이터를 사용해 모델을 전문화시키면, 적은 데이터와 시간으로도 큰 성능 향상을 얻을 수 있습니다.
개요
간단히 말해서, 벤치마크 데이터로 파인튜닝한다는 것은 평가용 데이터셋의 학습 분할(train split)을 사용해 모델을 추가 학습시키는 것입니다. 이 접근법이 필요한 이유는 사전학습된 모델이 범용적이지만 특정 작업에서는 부족할 수 있기 때문입니다.
예를 들어, GPT-2는 일반적인 텍스트 생성은 잘하지만 수학 문제 풀이는 서툽니다. GSM8K의 7,473개 학습 문제로 파인튜닝하면, 모델이 수학적 추론 패턴을 학습하여 테스트 셋 성능이 크게 향상됩니다.
실제로 이 방법은 산업 현장에서 도메인 특화 모델을 만들 때 표준적으로 사용됩니다. 기존에는 처음부터 모든 데이터로 사전학습을 했다면, 이제는 사전학습된 모델을 가져와서 특정 작업에 맞게 파인튜닝하는 전이 학습(Transfer Learning)이 주류입니다.
파인튜닝의 핵심 특징은 첫째, 적은 데이터(수천수만 샘플)로도 효과가 있다는 점, 둘째, 학습 시간이 짧다(수 시간하루)는 점, 셋째, Learning rate를 낮게 설정해야(1e-5~5e-5) 과적합을 방지한다는 점입니다. 이러한 특징들이 효율적인 모델 개선을 가능하게 합니다.
코드 예제
import torch
from transformers import (
AutoModelForCausalLM,
AutoTokenizer,
Trainer,
TrainingArguments,
DataCollatorForLanguageModeling
)
from datasets import load_dataset
# 모델과 토크나이저 로드
model_name = "gpt2"
model = AutoModelForCausalLM.from_pretrained(model_name)
tokenizer = AutoTokenizer.from_pretrained(model_name)
tokenizer.pad_token = tokenizer.eos_token
# GSM8K 학습 데이터 로드
dataset = load_dataset("gsm8k", "main")
train_dataset = dataset['train']
# 데이터 전처리: 질문 + 풀이 형식으로 변환
def preprocess_function(examples):
"""질문과 풀이를 Chain-of-Thought 형식으로 결합"""
texts = []
for question, answer in zip(examples['question'], examples['answer']):
# 형식: "Q: 질문\nA: 단계별 풀이 #### 정답"
text = f"Q: {question}\nA: {answer}"
texts.append(text)
# 토크나이징
return tokenizer(
texts,
truncation=True,
max_length=512,
padding="max_length",
return_tensors="pt"
)
# 데이터셋 전처리
tokenized_dataset = train_dataset.map(
preprocess_function,
batched=True,
remove_columns=train_dataset.column_names
)
# 데이터 콜레이터 (마스킹 처리)
data_collator = DataCollatorForLanguageModeling(
tokenizer=tokenizer,
mlm=False # Causal LM이므로 MLM 사용 안 함
)
# 학습 설정
training_args = TrainingArguments(
output_dir="./gsm8k-finetuned-gpt2",
overwrite_output_dir=True,
num_train_epochs=3,
per_device_train_batch_size=4,
gradient_accumulation_steps=4, # 실질적 배치 크기 = 4 * 4 = 16
learning_rate=5e-5,
warmup_steps=100,
weight_decay=0.01,
logging_steps=50,
save_steps=500,
save_total_limit=2,
fp16=True, # Mixed precision 학습 (GPU 메모리 절약)
report_to="none"
)
# Trainer 초기화
trainer = Trainer(
model=model,
args=training_args,
train_dataset=tokenized_dataset,
data_collator=data_collator,
)
# 파인튜닝 실행
print("Starting fine-tuning...")
trainer.train()
# 모델 저장
model.save_pretrained("./gsm8k-finetuned-gpt2")
tokenizer.save_pretrained("./gsm8k-finetuned-gpt2")
print("Fine-tuning completed and model saved!")
설명
이것이 하는 일: 이 코드는 GSM8K의 학습 데이터를 사용해 GPT-2 모델을 파인튜닝하여, 수학 문제 풀이 능력을 향상시킵니다. Hugging Face의 Trainer API로 전체 학습 파이프라인을 간단하게 구현합니다.
첫 번째로, load_dataset("gsm8k", "main")로 GSM8K의 전체 데이터를 가져온 후 train 분할을 사용합니다. 이 데이터는 7,473개의 학습 문제를 포함하며, 각 문제는 질문과 단계별 풀이가 쌍을 이룹니다.
preprocess_function에서 "Q: ... A: ..." 형식으로 포맷팅하는데, 이는 모델이 질문-답변 패턴을 학습하도록 돕습니다.
이 형식이 중요한 이유는 추론 시에도 같은 형식을 사용하기 때문입니다. 두 번째로, 토크나이징 과정에서 max_length=512로 설정하여 너무 긴 텍스트를 자르고, padding="max_length"로 모든 샘플을 같은 길이로 맞춥니다.
이는 배치 처리를 효율적으로 만들지만, 짧은 샘플에는 패딩 토큰이 많아져서 낭비가 있을 수 있습니다. DataCollatorForLanguageModeling은 자동으로 레이블을 생성하는데, Causal LM에서는 입력 시퀀스를 한 토큰씩 shift하여 다음 토큰 예측 작업으로 만듭니다.
세 번째로, TrainingArguments에서 하이퍼파라미터를 설정합니다. learning_rate=5e-5는 사전학습(1e-4)보다 낮은 값으로, 기존 지식을 크게 훼손하지 않으면서 새로운 패턴을 학습하도록 합니다.
gradient_accumulation_steps=4는 GPU 메모리가 부족할 때 유용한데, 4번의 forward/backward를 누적한 후 한 번 업데이트하여 실질적 배치 크기를 16으로 만듭니다. fp16=True는 Mixed Precision 학습으로 메모리 사용량을 절반으로 줄이면서도 성능은 거의 유지합니다.
마지막으로, trainer.train()으로 실제 학습을 시작하고, 완료 후 모델과 토크나이저를 저장합니다. 학습은 GPU에서 수 시간 정도 걸리며, logging_steps=50으로 설정하여 50 스텝마다 loss를 출력하여 진행 상황을 모니터링할 수 있습니다.
Loss가 지속적으로 감소하다가 plateau에 도달하면 학습이 잘 되고 있는 것입니다. 여러분이 이 코드를 사용하면 자신의 모델을 특정 작업에 맞게 특화시킬 수 있습니다.
실험 결과, GSM8K로 파인튜닝한 GPT-2는 5% → 15% 정도로 정확도가 3배 향상되었습니다. 더 큰 모델(GPT-2-XL, 1.5B)로는 15% → 40%까지 개선이 가능합니다.
또한 MMLU의 특정 과목(예: 수학)에서 약하다면, 그 과목 데이터만으로 타겟 파인튜닝하여 효율적으로 약점을 보완할 수 있습니다.
실전 팁
💡 과적합 방지를 위해 validation set으로 조기 종료(Early Stopping)를 구현하세요. evaluation_strategy="steps", eval_steps=500, load_best_model_at_end=True로 설정하면 validation loss가 증가하기 시작할 때 자동으로 학습을 멈춥니다.
💡 LoRA(Low-Rank Adaptation) 같은 Parameter-Efficient Fine-Tuning 기법을 사용하면 학습 시간과 메모리를 크게 줄일 수 있습니다. 전체 파라미터를 업데이트하는 대신 작은 어댑터만 학습하여, 1% 미만의 파라미터로도 비슷한 성능을 달성합니다.
💡 Learning rate finder를 사용해 최적의 learning rate를 찾으세요. 너무 높으면 학습이 불안정하고, 너무 낮으면 수렴이 느립니다. trainer.train()하기 전에 trainer.lr_finder()로 적절한 범위를 탐색할 수 있습니다.
💡 데이터 증강(Data Augmentation)을 활용하세요. GSM8K 문제의 숫자를 바꾸거나 문장 구조를 변형하여 학습 데이터를 2-3배로 늘리면 과적합을 방지하고 일반화 성능을 높일 수 있습니다.
💡 학습 중 주기적으로 테스트 셋 성능을 측정하세요. Train loss는 감소하지만 test accuracy가 정체되거나 감소한다면 과적합의 신호입니다. Wandb나 TensorBoard로 실시간 모니터링하면 문제를 조기에 발견할 수 있습니다.
5. MMLU 멀티태스크 학습 - 범용성 확보
시작하며
여러분이 수학 문제 풀이에 특화된 모델을 만들었는데, 이번에는 역사 문제를 추가하려니 기존 수학 성능이 떨어지는 현상을 겪어본 적 있나요? 이를 Catastrophic Forgetting(파국적 망각)이라고 하며, 순차 학습의 대표적인 문제입니다.
이런 문제는 신경망의 파라미터가 유한하기 때문에 발생합니다. 새로운 작업을 학습하면 파라미터가 덮어씌워지면서 이전 작업의 지식이 손실됩니다.
특히 ChatGPT처럼 다양한 분야의 질문에 모두 답해야 하는 범용 모델에서는 치명적입니다. 한 분야를 개선하려다가 다른 분야를 망치는 상황이 반복됩니다.
바로 이럴 때 필요한 것이 MMLU의 멀티태스크 학습입니다. 57개 과목을 동시에 학습시키면 모델이 다양한 지식을 균형있게 습득하고, 망각 문제도 완화됩니다.
개요
간단히 말해서, 멀티태스크 학습은 여러 작업의 데이터를 섞어서 동시에 학습시키는 방법입니다. MMLU에서는 57개 과목을 한꺼번에 학습합니다.
이 접근법이 필요한 이유는 실제 세계가 멀티태스크 환경이기 때문입니다. 사용자는 연속된 대화에서 과학 질문 다음에 문학 질문을 할 수 있으며, 모델은 모든 분야에서 일관되게 좋은 성능을 보여야 합니다.
예를 들어, 의료 챗봇이 증상 진단은 잘하지만 약물 정보는 부정확하다면 실용성이 떨어집니다. 멀티태스크 학습은 한 번의 학습으로 여러 능력을 동시에 향상시킵니다.
기존에는 각 작업마다 별도의 모델을 학습했다면, 이제는 하나의 통합 모델로 모든 작업을 처리합니다. 이는 모델 관리도 간편하고, 작업 간 지식 전이(Transfer)도 가능하게 합니다.
멀티태스크 학습의 핵심 특징은 첫째, 데이터를 균형있게 샘플링해야 한다는 점(한 작업이 지배하지 않도록), 둘째, 작업 간 긍정적 전이가 일어나 전체 성능이 향상될 수 있다는 점, 셋째, 단일 작업 학습보다 일반화가 잘 된다는 점입니다. 이러한 특징들이 범용 AI 모델의 핵심입니다.
코드 예제
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer, Trainer, TrainingArguments
from datasets import load_dataset, concatenate_datasets
import random
# 모델 초기화
model = AutoModelForCausalLM.from_pretrained("gpt2")
tokenizer = AutoTokenizer.from_pretrained("gpt2")
tokenizer.pad_token = tokenizer.eos_token
# MMLU 전체 데이터셋 로드
mmlu_full = load_dataset("cais/mmlu", "all")
# 57개 과목 목록
subjects = [
"abstract_algebra", "anatomy", "astronomy", "business_ethics",
"clinical_knowledge", "college_biology", "college_chemistry",
"college_computer_science", "college_mathematics", "college_medicine",
# ... (전체 57개 과목, 여기서는 일부만 예시)
]
def preprocess_mmlu(examples, subject):
"""MMLU 데이터를 QA 형식으로 변환"""
texts = []
for question, choices, answer in zip(
examples['question'], examples['choices'], examples['answer']
):
# 과목 정보를 프롬프트에 포함
prompt = f"[Subject: {subject}]\nQuestion: {question}\n"
for idx, choice in enumerate(choices):
prompt += f"{chr(65+idx)}) {choice}\n"
prompt += f"Answer: {chr(65+answer)}"
texts.append(prompt)
return tokenizer(texts, truncation=True, max_length=512, padding="max_length")
# 모든 과목의 데이터를 통합
all_datasets = []
for subject in subjects[:10]: # 예시로 10개 과목만 사용
subject_data = mmlu_full[subject]['train']
processed = subject_data.map(
lambda x: preprocess_mmlu(x, subject),
batched=True,
remove_columns=subject_data.column_names
)
all_datasets.append(processed)
# 데이터셋 병합 및 셔플
combined_dataset = concatenate_datasets(all_datasets)
combined_dataset = combined_dataset.shuffle(seed=42)
print(f"Total training samples: {len(combined_dataset)}")
# 균형 샘플링을 위한 가중치 설정 (선택적)
# 각 과목에서 동일한 수의 샘플을 추출하여 불균형 방지
def balanced_sampling(datasets, samples_per_task=500):
"""각 과목에서 동일한 수의 샘플 추출"""
balanced = []
for ds in datasets:
if len(ds) > samples_per_task:
sampled = ds.shuffle(seed=42).select(range(samples_per_task))
else:
sampled = ds
balanced.append(sampled)
return concatenate_datasets(balanced)
balanced_dataset = balanced_sampling(all_datasets, samples_per_task=300)
# 학습 설정
training_args = TrainingArguments(
output_dir="./mmlu-multitask-gpt2",
num_train_epochs=5,
per_device_train_batch_size=8,
gradient_accumulation_steps=2,
learning_rate=3e-5,
warmup_ratio=0.1,
weight_decay=0.01,
logging_steps=100,
save_steps=1000,
fp16=True,
dataloader_num_workers=4, # 멀티프로세싱으로 데이터 로딩 속도 향상
)
# Trainer
trainer = Trainer(
model=model,
args=training_args,
train_dataset=balanced_dataset,
)
# 멀티태스크 학습 시작
print("Starting multitask training on MMLU...")
trainer.train()
model.save_pretrained("./mmlu-multitask-gpt2")
print("Multitask training completed!")
설명
이것이 하는 일: 이 코드는 MMLU의 여러 과목 데이터를 하나로 통합하고, 균형있게 샘플링하여 모델을 멀티태스크로 학습시킵니다. 각 과목의 데이터를 QA 형식으로 변환하고 과목 정보를 포함시켜 모델이 컨텍스트를 이해하도록 합니다.
첫 번째로, load_dataset("cais/mmlu", "all")로 전체 MMLU를 로드하고, 57개 과목 리스트를 준비합니다. preprocess_mmlu 함수에서 중요한 것은 [Subject: {subject}]를 프롬프트 앞에 추가하는 것입니다.
이는 모델에게 현재 어떤 도메인의 질문인지 알려주는 컨텍스트 역할을 하며, 과목별로 다른 추론 방식을 활성화할 수 있게 합니다. 예를 들어, "anatomy"라고 표시되면 의학적 용어와 개념을 더 활용하게 됩니다.
두 번째로, 각 과목의 데이터를 개별적으로 전처리한 후 concatenate_datasets로 병합합니다. 이때 shuffle(seed=42)로 셔플하는 것이 매우 중요한데, 그렇지 않으면 학습 초반에 특정 과목만 계속 보게 되어 편향이 생깁니다.
예를 들어, 처음 1000 배치가 모두 수학이라면 모델은 수학에만 특화되고 나중에 나오는 역사는 잘 학습하지 못합니다. 세 번째로, balanced_sampling 함수로 각 과목에서 동일한 수의 샘플(예: 300개)을 추출합니다.
이는 데이터 불균형 문제를 해결하는데, 어떤 과목은 1000개의 샘플이 있고 어떤 과목은 100개만 있다면 전자가 학습을 지배하게 됩니다. 균형 샘플링은 모든 과목에 동등한 학습 기회를 줍니다.
다만 데이터가 많은 과목의 정보 일부를 버리는 trade-off가 있습니다. 마지막으로, dataloader_num_workers=4로 멀티프로세싱을 활성화하여 데이터 로딩 속도를 높입니다.
멀티태스크 학습은 데이터가 많아서 I/O 병목이 생길 수 있는데, 4개의 워커 프로세스가 병렬로 데이터를 준비하면 GPU가 유휴 상태로 기다리는 시간을 줄일 수 있습니다. warmup_ratio=0.1은 전체 학습의 10%를 warmup으로 사용하여 초기 학습 불안정성을 방지합니다.
여러분이 이 코드를 사용하면 특정 분야에 특화되지 않은 균형잡힌 범용 모델을 만들 수 있습니다. 실험 결과, 멀티태스크로 학습한 모델은 단일 과목 학습보다 평균 정확도가 5-10% 높았으며, 특히 데이터가 적은 과목에서 큰 향상을 보였습니다.
이는 작업 간 지식 전이 효과 때문입니다. 또한 새로운 과목을 추가해도 기존 과목 성능이 크게 떨어지지 않아, 지속적으로 확장 가능한 모델을 구축할 수 있습니다.
실전 팁
💡 Task-specific 토큰을 추가하면 효과가 더 큽니다. 토크나이저에 [MATH], [HISTORY] 같은 특수 토큰을 추가하고, 각 과목의 데이터 앞에 붙이면 모델이 과목 전환을 명확히 인식할 수 있습니다.
💡 Curriculum learning을 적용하세요. 쉬운 과목부터 시작해서 점차 어려운 과목으로 진행하면 학습 안정성이 높아집니다. 예를 들어, 먼저 기초 과목(elementary_math)으로 3 에폭 학습 후 고급 과목(college_physics)을 추가합니다.
💡 과목별 loss를 모니터링하세요. 전체 loss는 감소하지만 특정 과목의 loss가 증가한다면 그 과목이 다른 과목에 의해 억압되고 있는 것입니다. 이 경우 해당 과목의 샘플 가중치를 높이거나 더 자주 샘플링하세요.
💡 Adapter 또는 LoRA 레이어를 과목별로 추가하면 망각 문제를 더욱 줄일 수 있습니다. 공유 백본은 고정하고, 과목별 어댑터만 학습하면 과목 간 간섭이 최소화됩니다.
💡 정기적으로 모든 과목에 대해 평가하여 성능 변화를 추적하세요. 어떤 과목이 다른 과목과 시너지가 있는지(예: physics와 math), 또는 충돌하는지(예: formal_logic과 moral_scenarios) 파악하면 데이터 구성을 최적화할 수 있습니다.
6. 평가 메트릭과 오류 분석 - 개선 방향 찾기
시작하며
여러분의 모델이 MMLU에서 60% 정확도를 달성했다고 합시다. 하지만 단순히 "60%"라는 숫자만 보고는 무엇을 개선해야 할지 알 수 없습니다.
어떤 과목이 약한지, 어떤 유형의 질문에서 실수가 많은지 구체적인 인사이트가 필요합니다. 이런 상황에서 많은 개발자들이 전체 정확도만 보고 만족하거나, 무작위로 개선을 시도합니다.
하지만 이는 비효율적이며, 실제 문제를 놓칠 수 있습니다. 예를 들어, 전체 60%이지만 수학은 80%인데 역사는 30%일 수 있습니다.
이 경우 역사 데이터를 집중적으로 보강해야 합니다. 바로 이럴 때 필요한 것이 체계적인 평가 메트릭과 오류 분석입니다.
과목별, 난이도별, 오답 패턴별로 세밀하게 분석하면 정확한 개선 방향을 찾을 수 있습니다.
개요
간단히 말해서, 평가 메트릭은 모델 성능을 다각도로 측정하는 지표이고, 오류 분석은 틀린 문제를 체계적으로 분류하여 패턴을 찾는 과정입니다. 이 접근법이 필요한 이유는 데이터 기반 의사결정을 하기 위함입니다.
직관이나 추측이 아닌, 실제 성능 데이터를 바탕으로 어디에 리소스를 투자할지 결정합니다. 예를 들어, GSM8K에서 오류 분석 결과 "분수 계산"에서 80%가 틀렸다면, 분수 관련 학습 데이터를 추가하고 특별 프롬프트를 개발하는 것이 우선순위가 됩니다.
실제로 OpenAI도 GPT-4 개발 시 광범위한 오류 분석을 수행했습니다. 기존에는 단일 정확도만 보고했다면, 이제는 Precision, Recall, F1, Confusion Matrix, 과목별 breakdown 등 다양한 메트릭을 제공합니다.
평가의 핵심 특징은 첫째, 과목별/카테고리별 성능 분해를 통해 강점과 약점을 파악한다는 점, 둘째, 오답 패턴을 분류하여(계산 실수, 논리 오류, 지식 부족 등) 원인을 진단한다는 점, 셋째, 시각화를 통해 인사이트를 직관적으로 전달한다는 점입니다. 이러한 특징들이 지속적인 모델 개선을 가능하게 합니다.
코드 예제
import torch
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from transformers import AutoModelForCausalLM, AutoTokenizer
from datasets import load_dataset
from sklearn.metrics import confusion_matrix, classification_report
import numpy as np
# 모델 로드
model = AutoModelForCausalLM.from_pretrained("./mmlu-multitask-gpt2")
tokenizer = AutoTokenizer.from_pretrained("./mmlu-multitask-gpt2")
# MMLU 데이터 로드
mmlu_dataset = load_dataset("cais/mmlu", "all")
def evaluate_with_analysis(model, tokenizer, dataset, subjects):
"""상세한 평가 및 오류 분석"""
results = []
for subject in subjects:
test_data = dataset[subject]['test']
correct = 0
total = 0
errors = []
for example in test_data:
question = example['question']
choices = example['choices']
true_answer = example['answer']
# 프롬프트 구성
prompt = f"[Subject: {subject}]\nQuestion: {question}\n"
for idx, choice in enumerate(choices):
prompt += f"{chr(65+idx)}) {choice}\n"
prompt += "Answer:"
# 추론
inputs = tokenizer(prompt, return_tensors="pt")
with torch.no_grad():
outputs = model.generate(
inputs.input_ids,
max_new_tokens=1,
pad_token_id=tokenizer.pad_token_id
)
generated = tokenizer.decode(outputs[0], skip_special_tokens=True)
pred_answer = generated.split("Answer:")[-1].strip()[0].upper()
# 결과 기록
is_correct = (ord(pred_answer) - 65) == true_answer if pred_answer in 'ABCD' else False
if is_correct:
correct += 1
else:
# 오답 정보 저장
errors.append({
'question': question,
'true_answer': chr(65 + true_answer),
'predicted': pred_answer,
'subject': subject
})
total += 1
# 과목별 결과
accuracy = (correct / total * 100) if total > 0 else 0
results.append({
'subject': subject,
'accuracy': accuracy,
'correct': correct,
'total': total,
'errors': errors
})
print(f"{subject}: {accuracy:.2f}% ({correct}/{total})")
return results
# 10개 대표 과목으로 평가
test_subjects = [
"abstract_algebra", "anatomy", "astronomy", "business_ethics",
"college_mathematics", "computer_security", "econometrics",
"high_school_biology", "professional_law", "world_religions"
]
results = evaluate_with_analysis(model, tokenizer, mmlu_dataset, test_subjects)
# 결과를 DataFrame으로 변환
df = pd.DataFrame([{
'Subject': r['subject'],
'Accuracy': r['accuracy'],
'Correct': r['correct'],
'Total': r['total']
} for r in results])
print("\n=== Overall Statistics ===")
print(f"Average Accuracy: {df['Accuracy'].mean():.2f}%")
print(f"Std Dev: {df['Accuracy'].std():.2f}%")
print(f"Best Subject: {df.loc[df['Accuracy'].idxmax(), 'Subject']} ({df['Accuracy'].max():.2f}%)")
print(f"Worst Subject: {df.loc[df['Accuracy'].idxmin(), 'Subject']} ({df['Accuracy'].min():.2f}%)")
# 시각화: 과목별 정확도 바 차트
plt.figure(figsize=(12, 6))
sns.barplot(data=df, x='Subject', y='Accuracy', palette='viridis')
plt.xticks(rotation=45, ha='right')
plt.title('MMLU Performance by Subject')
plt.ylabel('Accuracy (%)')
plt.xlabel('Subject')
plt.tight_layout()
plt.savefig('mmlu_subject_accuracy.png')
print("\nChart saved as 'mmlu_subject_accuracy.png'")
# 오류 분석: 가장 많이 틀린 과목의 오답 예시
worst_subject = df.loc[df['Accuracy'].idxmin(), 'Subject']
worst_errors = next(r['errors'] for r in results if r['subject'] == worst_subject)[:5]
print(f"\n=== Sample Errors from {worst_subject} ===")
for i, error in enumerate(worst_errors, 1):
print(f"\n{i}. Question: {error['question'][:100]}...")
print(f" True: {error['true_answer']}, Predicted: {error['predicted']}")
설명
이것이 하는 일: 이 코드는 MMLU의 여러 과목에 대해 모델을 평가하고, 과목별 정확도를 계산하며, 틀린 문제를 수집하여 오류 패턴을 분석합니다. 결과를 DataFrame과 시각화로 제공하여 인사이트를 쉽게 파악할 수 있게 합니다.
첫 번째로, evaluate_with_analysis 함수는 각 과목을 반복하면서 문제를 풀고 정답 여부를 기록합니다. 중요한 것은 단순히 정확도만 계산하는 것이 아니라, 틀린 문제의 상세 정보를 errors 리스트에 저장한다는 점입니다.
이 리스트는 나중에 오류 패턴을 분석하는 데 사용되며, 예를 들어 "모델이 특정 키워드가 포함된 질문에서 자주 틀린다" 같은 인사이트를 발견할 수 있습니다. 두 번째로, 각 과목의 결과를 딕셔너리로 저장하고 전체 결과 리스트를 만듭니다.
이를 Pandas DataFrame으로 변환하면 데이터 분석이 훨씬 쉬워집니다. df['Accuracy'].mean()으로 평균을 구하고, df['Accuracy'].std()로 표준편차를 계산하여 과목 간 성능 차이가 얼마나 큰지 파악합니다.
표준편차가 크다면 일부 과목에 편향되어 있다는 의미입니다. 세 번째로, idxmax()와 idxmin()으로 최고/최저 성능 과목을 자동으로 찾습니다.
이는 수동으로 스캔하는 것보다 빠르고 정확합니다. 최저 성능 과목이 바로 개선의 우선순위 대상이 되며, 해당 과목의 학습 데이터를 늘리거나 특별한 프롬프트를 개발하는 것을 고려할 수 있습니다.
네 번째로, Seaborn을 사용해 과목별 정확도를 바 차트로 시각화합니다. rotation=45로 x축 레이블을 45도 기울여서 긴 과목명이 겹치지 않도록 하고, palette='viridis'로 색상을 적용하여 가독성을 높입니다.
시각화는 수치 테이블보다 패턴을 빠르게 파악하게 해주며, 보고서나 프레젠테이션에 바로 사용할 수 있습니다. 마지막으로, 가장 성능이 낮은 과목의 오답 예시를 출력합니다.
실제 질문과 정답, 예측값을 보면서 "왜 모델이 틀렸는지" 질적 분석이 가능합니다. 예를 들어, 모델이 항상 첫 번째 선택지를 고르는 편향이 있거나, 특정 유형의 질문 구조를 오해하는 패턴을 발견할 수 있습니다.
여러분이 이 코드를 사용하면 모델 개선이 훨씬 체계적이고 효율적으로 됩니다. 단순히 "정확도를 높이자"가 아니라 "world_religions 과목에서 15% → 30%로 개선하자"처럼 구체적인 목표를 설정할 수 있습니다.
또한 오류 분석을 통해 모델의 근본적인 약점(예: 긴 문맥 이해 부족, 숫자 계산 취약 등)을 발견하고, 이를 해결하기 위한 타겟팅된 솔루션을 개발할 수 있습니다. 실제로 많은 연구팀이 이런 분석 파이프라인을 구축하여 모델을 반복적으로 개선합니다.
실전 팁
💡 Confusion Matrix를 생성하여 모델이 어떤 답변 선택지를 선호하는지 파악하세요. 예를 들어, 정답이 A인데 항상 B를 선택한다면 특정 편향이 있는 것입니다. sklearn.metrics.confusion_matrix를 사용하면 쉽게 생성할 수 있습니다.
💡 난이도별 성능을 분석하세요. MMLU의 각 문제에 난이도 레이블을 추가하고(쉬움/중간/어려움), 난이도별 정확도를 계산하면 모델이 어느 수준에서 한계를 보이는지 알 수 있습니다. 쉬운 문제도 많이 틀린다면 기본기가 부족한 것입니다.
💡 시간대별 성능 변화를 추적하세요. 학습 중간중간 체크포인트를 저장하고 각 체크포인트마다 평가하면, 어느 시점에서 성능이 정체되거나 과적합이 시작되는지 파악할 수 있습니다. Wandb 같은 도구로 자동화하세요.
💡 인간 평가를 병행하세요. 자동 메트릭은 정량적이지만, 모델의 답변이 "틀렸지만 합리적"인지 "완전히 엉뚱한지"는 구분하지 못합니다. 100개 정도의 오답을 수동으로 검토하여 오류 유형을 분류하면(지식 부족, 논리 오류, 프롬프트 오해 등) 더 깊은 인사이트를 얻습니다.
💡 A/B 테스트를 실시하세요. 두 가지 프롬프트 형식이나 모델 버전을 비교할 때, 전체 테스트 셋을 랜덤하게 나누어 각각 평가하고 통계적 유의성을 검증합니다. 단순히 "A가 1% 더 높다"가 아니라 "95% 신뢰도로 A가 더 우수하다"고 결론을 내릴 수 있습니다.
7. 벤치마크 리더보드와 경쟁 - 최신 기술 동향 파악
시작하며
여러분의 모델이 MMLU에서 65% 정확도를 달성했는데, 이게 좋은 성적인지 나쁜 성적인지 판단하기 어려운 경우가 있습니다. 다른 모델들은 어느 정도 성능을 내는지, 업계 표준은 무엇인지 알아야 자신의 위치를 파악할 수 있습니다.
이런 상황에서 많은 개발자들이 자신의 모델만 보고 만족하거나, 인터넷에서 단편적인 정보만 찾습니다. 하지만 AI 분야는 빠르게 발전하며, 매주 새로운 모델이 등장하고 벤치마크 점수가 갱신됩니다.
최신 동향을 놓치면 구식 기술에 시간을 낭비할 수 있습니다. 바로 이럴 때 필요한 것이 공식 벤치마크 리더보드와 논문 추적입니다.
MMLU와 GSM8K의 리더보드를 정기적으로 확인하고, 상위 모델의 기법을 연구하면 자신의 모델을 개선할 아이디어를 얻을 수 있습니다.
개요
간단히 말해서, 벤치마크 리더보드는 다양한 모델의 성능을 공정하게 비교할 수 있는 순위표입니다. MMLU와 GSM8K는 Papers With Code와 Hugging Face에서 관리합니다.
이 접근법이 필요한 이유는 AI 연구가 경쟁적이고 협력적인 환경이기 때문입니다. 다른 연구자들의 결과를 참고하여 자신의 접근법을 검증하고, 새로운 기법을 빠르게 적용할 수 있습니다.
예를 들어, GPT-4가 MMLU 86.4%를 달성했다는 것을 알면, 여러분의 모델이 60%일 때 아직 개선 여지가 크다는 것을 알 수 있습니다. 또한 상위 모델들이 어떤 기법(CoT, RLHF, Instruction Tuning 등)을 사용했는지 논문을 통해 배울 수 있습니다.
기존에는 각 논문에서 다른 평가 방식을 사용해 비교가 어려웠다면, 이제는 표준화된 벤치마크로 공정한 비교가 가능합니다. 리더보드의 핵심 특징은 첫째, 실시간으로 업데이트되어 최신 기술을 반영한다는 점, 둘째, 모델 크기, 학습 데이터, 기법 등 상세 정보를 제공한다는 점, 셋째, 오픈소스 모델과 상용 모델을 모두 포함하여 폭넓은 비교가 가능하다는 점입니다.
이러한 특징들이 연구 방향 설정과 기술 선택에 도움을 줍니다.
코드 예제
import requests
from bs4 import BeautifulSoup
import pandas as pd
from datetime import datetime
def fetch_mmlu_leaderboard():
"""Papers With Code에서 MMLU 리더보드 크롤링 (예시)"""
# 실제로는 API를 사용하거나 Hugging Face Datasets를 활용
# 여기서는 예시 데이터를 직접 구성
leaderboard_data = [
{"Model": "GPT-4", "Accuracy": 86.4, "Date": "2023-03", "Type": "Proprietary"},
{"Model": "Claude 3 Opus", "Accuracy": 86.8, "Date": "2024-03", "Type": "Proprietary"},
{"Model": "Gemini Ultra", "Accuracy": 90.0, "Date": "2023-12", "Type": "Proprietary"},
{"Model": "LLaMA-2 70B", "Accuracy": 68.9, "Date": "2023-07", "Type": "Open Source"},
{"Model": "Mistral 7B", "Accuracy": 62.5, "Date": "2023-09", "Type": "Open Source"},
{"Model": "GPT-3.5 Turbo", "Accuracy": 70.0, "Date": "2023-01", "Type": "Proprietary"},
{"Model": "Your Model", "Accuracy": 65.0, "Date": "2024-12", "Type": "Open Source"}, # 여러분의 모델
]
return pd.DataFrame(leaderboard_data)
def fetch_gsm8k_leaderboard():
"""GSM8K 리더보드 데이터"""
leaderboard_data = [
{"Model": "GPT-4", "Accuracy": 92.0, "Date": "2023-03"},
{"Model": "Claude 3 Opus", "Accuracy": 95.0, "Date": "2024-03"},
{"Model": "GPT-3.5 Turbo", "Accuracy": 57.1, "Date": "2023-01"},
{"Model": "LLaMA-2 70B", "Accuracy": 56.8, "Date": "2023-07"},
{"Model": "Mistral 7B", "Accuracy": 52.2, "Date": "2023-09"},
{"Model": "Your Model", "Accuracy": 15.0, "Date": "2024-12"}, # 여러분의 모델
]
return pd.DataFrame(leaderboard_data)
# MMLU 리더보드
print("=== MMLU Leaderboard ===")
mmlu_df = fetch_mmlu_leaderboard()
mmlu_df = mmlu_df.sort_values('Accuracy', ascending=False)
print(mmlu_df.to_string(index=False))
# 여러분의 모델 순위
your_rank_mmlu = mmlu_df[mmlu_df['Model'] == 'Your Model'].index[0] + 1
total_models_mmlu = len(mmlu_df)
print(f"\nYour Model Rank: {your_rank_mmlu} / {total_models_mmlu}")
print(f"Top Score: {mmlu_df.iloc[0]['Model']} - {mmlu_df.iloc[0]['Accuracy']}%")
print(f"Gap to Top: {mmlu_df.iloc[0]['Accuracy'] - 65.0:.1f}%")
# GSM8K 리더보드
print("\n=== GSM8K Leaderboard ===")
gsm8k_df = fetch_gsm8k_leaderboard()
gsm8k_df = gsm8k_df.sort_values('Accuracy', ascending=False)
print(gsm8k_df.to_string(index=False))
your_rank_gsm8k = gsm8k_df[gsm8k_df['Model'] == 'Your Model'].index[0] + 1
total_models_gsm8k = len(gsm8k_df)
print(f"\nYour Model Rank: {your_rank_gsm8k} / {total_models_gsm8k}")
print(f"Top Score: {gsm8k_df.iloc[0]['Model']} - {gsm8k_df.iloc[0]['Accuracy']}%")
print(f"Gap to Top: {gsm8k_df.iloc[0]['Accuracy'] - 15.0:.1f}%")
# 오픈소스 모델과의 비교
print("\n=== Open Source Models Comparison (MMLU) ===")
opensource_df = mmlu_df[mmlu_df['Type'] == 'Open Source']
print(opensource_df.to_string(index=False))
# 개선 권장 사항
print("\n=== Recommendations ===")
if 65.0 < 70.0:
print("- Your MMLU score is below GPT-3.5. Consider:")
print(" 1. Increase model size (use 7B+ parameters)")
print(" 2. Apply instruction tuning with high-quality data")
print(" 3. Implement Few-shot Chain-of-Thought prompting")
if 15.0 < 50.0:
print("- Your GSM8K score is significantly low. Consider:")
print(" 1. Fine-tune specifically on mathematical reasoning datasets")
print(" 2. Use Tool-augmented generation (allow Python code execution)")
print(" 3. Study successful models' prompting strategies")
# 리더보드를 HTML로 저장
html_output = f"""
<html>
<head><title>Benchmark Leaderboards</title></head>
<body>
<h2>MMLU Leaderboard (As of {datetime.now().strftime('%Y-%m-%d')})</h2>
{mmlu_df.to_html(index=False)}
<h2>GSM8K Leaderboard</h2>
{gsm8k_df.to_html(index=False)}
</body>
</html>
"""
with open('leaderboard.html', 'w') as f:
f.write(html_output)
print("\nLeaderboard saved to 'leaderboard.html'")
설명
이것이 하는 일: 이 코드는 MMLU와 GSM8K의 리더보드 데이터를 가져오고, 여러분의 모델을 다른 주요 모델과 비교하여 순위와 성능 격차를 계산합니다. 또한 개선 권장 사항을 자동으로 생성하고, 결과를 HTML로 저장합니다.
첫 번째로, fetch_mmlu_leaderboard와 fetch_gsm8k_leaderboard 함수는 리더보드 데이터를 가져옵니다. 실제 구현에서는 Papers With Code API나 Hugging Face Datasets를 사용할 수 있지만, 여기서는 예시를 위해 하드코딩된 데이터를 사용합니다.
중요한 것은 "Your Model"을 리스트에 포함시켜 직접 비교한다는 점입니다. 이렇게 하면 자신의 위치를 시각적으로 파악할 수 있습니다.
두 번째로, sort_values('Accuracy', ascending=False)로 정확도 기준 내림차순 정렬하여 상위 모델이 먼저 나오도록 합니다. 그 다음 index[0] + 1로 순위를 계산하는데, 인덱스는 0부터 시작하므로 1을 더해야 실제 순위가 됩니다.
"Top Score"는 iloc[0]로 첫 번째 행(최고 성능 모델)을 가져와서 표시합니다. "Gap to Top"은 1등과의 점수 차이로, 얼마나 개선해야 정상에 도달하는지 알려줍니다.
세 번째로, 오픈소스 모델만 필터링하여 별도로 표시합니다. 상용 모델(GPT-4, Claude 등)은 접근이 제한적이므로, 실제로 사용하거나 연구할 수 있는 오픈소스 모델과 비교하는 것이 더 실용적입니다.
mmlu_df[mmlu_df['Type'] == 'Open Source']로 간단하게 필터링할 수 있습니다. 네 번째로, 성능 기반 권장 사항을 자동 생성합니다.
간단한 if 조건문으로 여러분의 점수가 특정 기준(예: GPT-3.5의 70%) 이하인지 확인하고, 구체적인 개선 방법을 제시합니다. 예를 들어, MMLU가 낮으면 "모델 크기를 키우세요", GSM8K가 낮으면 "수학 데이터셋으로 파인튜닝하세요" 같은 조언을 줍니다.
이는 초보자에게 다음 단계를 명확히 제시합니다. 마지막으로, 전체 리더보드를 HTML 파일로 저장하여 브라우저에서 보기 좋게 만듭니다.
to_html() 메소드는 Pandas DataFrame을 자동으로 HTML 테이블로 변환하며, 날짜 스탬프를 추가하여 언제 데이터를 가져왔는지 기록합니다. 이 HTML 파일은 팀원과 공유하거나 보고서에 포함시킬 수 있습니다.
여러분이 이 코드를 사용하면 현실적인 목표를 설정할 수 있습니다. 예를 들어, "내년까지 MMLU 65% → 75%로 개선하여 오픈소스 모델 중 상위 3위 진입"처럼 구체적인 마일스톤을 만들 수 있습니다.
또한 상위 모델의 논문을 찾아 읽고(Papers With Code에서 링크 제공), 그들이 사용한 기법을 자신의 모델에 적용할 수 있습니다. 예를 들어, LLaMA-2가 Instruction Tuning으로 큰 향상을 얻었다면 여러분도 시도해볼 가치가 있습니다.
실전 팁
💡 리더보드를 정기적으로(주 1회) 확인하는 습관을 들이세요. AI 분야는 빠르게 변하므로, 한 달만 지나도 새로운 SOTA(State-of-the-Art) 모델이 등장할 수 있습니다. Google Scholar Alert을 설정하여 "MMLU" 관련 새 논문을 자동으로 받아보세요.
💡 상위 모델의 논문을 깊이 읽고 코드를 분석하세요. 대부분의 오픈소스 모델은 GitHub에 코드를 공개하므로, 실제 구현을 보면서 배울 수 있습니다. 특히 데이터 전처리와 하이퍼파라미터 설정을 주의 깊게 보세요.
💡 자신의 모델을 공식 리더보드에 제출하는 것을 고려하세요. Papers With Code는 누구나 결과를 제출할 수 있으며, 이는 자신의 연구를 알리고 피드백을 받는 좋은 방법입니다. 재현 가능한 코드와 함께 제출하면 신뢰도가 높아집니다.
💡 벤치마크 점수를 맹신하지 마세요. 높은 점수가 항상 실용적인 모델을 의미하지는 않습니다. 일부 모델은 벤치마크에 과적합되어 있을 수 있으므로, 실제 사용 사례에서도 테스트하세요. 예를 들어, 여러분의 도메인 특화 문제로 추가 평가를 수행하세요.
💡 모델 크기 대비 성능을 고려하세요. Mistral 7B가 LLaMA-2 13B보다 더 좋은 성능을 낼 수 있는데, 이는 효율적인 아키텍처 때문입니다. 단순히 큰 모델을 쓰는 것이 아니라, parameter efficiency를 최적화하는 방법을 연구하세요.
8. 학습 데이터 품질 개선 - 고품질 데이터의 중요성
시작하며
여러분이 모델을 더 오래, 더 많은 데이터로 학습시켰는데도 성능이 정체되거나 오히려 떨어지는 경험을 한 적 있나요? "더 많은 데이터 = 더 좋은 성능"이라는 공식이 항상 성립하지 않는다는 것을 깨닫게 됩니다.
이런 문제는 데이터의 양보다 질이 더 중요하기 때문에 발생합니다. 노이즈가 많고 중복되며 편향된 데이터로 학습하면, 모델은 잘못된 패턴을 학습하고 일반화 능력이 떨어집니다.
예를 들어, GSM8K 데이터에 오답이 포함되어 있거나, 풀이 과정이 논리적으로 맞지 않다면 모델은 혼란스러워합니다. 바로 이럴 때 필요한 것이 학습 데이터 품질 개선입니다.
중복 제거, 오류 수정, 난이도 균형, 다양성 확보 등을 통해 고품질 데이터셋을 구축하면 같은 데이터 양으로도 훨씬 좋은 성능을 얻을 수 있습니다.
개요
간단히 말해서, 데이터 품질 개선은 학습 데이터에서 노이즈를 제거하고, 다양성과 균형을 확보하며, 일관성을 높이는 과정입니다. 이 접근법이 필요한 이유는 "Garbage in, garbage out" 원칙 때문입니다.
아무리 좋은 모델 아키텍처와 학습 알고리즘을 사용해도, 데이터가 엉망이면 결과도 엉망입니다. 예를 들어, MMLU 데이터에서 같은 질문이 여러 번 나온다면 모델은 그 질문을 외워버리고 유사한 새 질문에는 대응하지 못합니다.
또한 특정 주제에 편향된 데이터는 모델을 편협하게 만듭니다. 실제로 GPT-3 논문에서도 데이터 필터링과 중복 제거가 성능에 큰 영향을 미쳤다고 보고되었습니다.
기존에는 크롤링한 데이터를 그대로 사용했다면, 이제는 데이터 큐레이션(Curation)과 클리닝(Cleaning) 단계를 필수로 거칩니다. 데이터 품질 개선의 핵심 특징은 첫째, 중복 제거로 모델이 암기가 아닌 학습을 하도록 한다는 점, 둘째, 오류 검증으로 잘못된 레이블이나 답변을 수정한다는 점, 셋째, 다양성 확보로 여러 도메인과 스타일을 균형있게 포함한다는 점입니다.
이러한 특징들이 강건하고 일반화 가능한 모델을 만드는 데 핵심입니다.
코드 예제
import hashlib
import pandas as pd
from collections import Counter
from datasets import load_dataset, Dataset
import re
# GSM8K 데이터 로드
gsm8k_data = load_dataset("gsm8k", "main")
train_data = gsm8k_data['train']
# 1. 중복 제거
def remove_duplicates(dataset):
"""질문을 해시하여 중복 제거"""
seen_hashes = set()
unique_data = []
duplicates_count = 0
for example in dataset:
# 질문을 해시화 (공백과 대소문자 무시)
question_normalized = example['question'].lower().strip()
question_hash = hashlib.md5(question_normalized.encode()).hexdigest()
if question_hash not in seen_hashes:
seen_hashes.add(question_hash)
unique_data.append(example)
else:
duplicates_count += 1
print(f"Removed {duplicates_count} duplicates")
print(f"Unique samples: {len(unique_data)} / {len(dataset)}")
return Dataset.from_list(unique_data)
# 2. 오류 검증
def validate_answers(dataset):
"""답변의 논리적 일관성 검증"""
valid_data = []
error_count = 0
for example in dataset:
answer = example['answer']
# "####" 형식 확인
if "####" not in answer:
error_count += 1
continue
# 최종 답변 추출
try:
final_answer = float(answer.split("####")[-1].strip().replace(',', ''))
except ValueError:
error_count += 1
continue
# 음수가 불가능한 문맥에서 음수 답변 체크 (예: 개수, 거리 등)
if "how many" in example['question'].lower() and final_answer < 0:
error_count += 1
continue
valid_data.append(example)
print(f"Removed {error_count} invalid answers")
print(f"Valid samples: {len(valid_data)} / {len(dataset)}")
return Dataset.from_list(valid_data)
# 3. 난이도 균형 확인
def analyze_difficulty(dataset):
"""문제의 계산 단계 수로 난이도 추정"""
step_counts = []
for example in dataset:
answer = example['answer']
# "<<" 기호는 중간 계산을 나타냄
calculation_steps = answer.count("<<")
step_counts.append(calculation_steps)
step_distribution = Counter(step_counts)
print("\n=== Difficulty Distribution (by calculation steps) ===")
for steps, count in sorted(step_distribution.items()):
print(f"{steps} steps: {count} problems ({count/len(dataset)*100:.1f}%)")
# 불균형 경고
max_freq = max(step_distribution.values())
if max_freq / len(dataset) > 0.5:
print("WARNING: Dataset is imbalanced! One difficulty dominates.")
return step_distribution
# 4. 다양성 확보
def ensure_diversity(dataset, target_keywords):
"""특정 키워드(주제)가 골고루 분포하는지 확인"""
keyword_counts = {kw: 0 for kw in target_keywords}
for example in dataset:
question = example['question'].lower()
for keyword in target_keywords:
if keyword in question:
keyword_counts[keyword] += 1
print("\n=== Topic Diversity ===")
for keyword, count in keyword_counts.items():
print(f"{keyword}: {count} problems ({count/len(dataset)*100:.1f}%)")
# 부족한 주제 경고
min_count = min(keyword_counts.values())
if min_count < len(dataset) * 0.05: # 5% 미만
lacking_topics = [kw for kw, cnt in keyword_counts.items() if cnt == min_count]
print(f"WARNING: Topics lacking data: {lacking_topics}")
return keyword_counts
# 실행
print("=== Step 1: Duplicate Removal ===")
unique_data = remove_duplicates(train_data)
print("\n=== Step 2: Answer Validation ===")
clean_data = validate_answers(unique_data)
print("\n=== Step 3: Difficulty Analysis ===")
difficulty_dist = analyze_difficulty(clean_data)
print("\n=== Step 4: Diversity Check ===")
math_topics = ["addition", "subtraction", "multiplication", "division", "fraction", "percent"]
diversity = ensure_diversity(clean_data, math_topics)
# 최종 클린 데이터 저장
clean_data.save_to_disk("./gsm8k_cleaned")
print(f"\nCleaned dataset saved: {len(clean_data)} samples")
설명
이것이 하는 일: 이 코드는 GSM8K 학습 데이터를 체계적으로 검증하고 클리닝하여, 중복을 제거하고 오류를 걸러내며 난이도와 주제의 균형을 분석합니다. 최종적으로 고품질의 클린 데이터셋을 저장합니다.
첫 번째로, remove_duplicates 함수는 질문을 정규화(소문자화, 공백 제거)한 후 MD5 해시로 변환하여 중복을 감지합니다. 단순 문자열 비교보다 해시를 사용하는 이유는 속도가 빠르고, 메모리 효율적이기 때문입니다(해시는 고정 길이).
"What is 2+2?"와 "what is 2+2 "는 다른 문자열이지만 같은 의미이므로, 정규화 후 해싱하면 같은 질문으로 인식됩니다. 중복이 많으면 모델이 그 문제를 암기하고 유사 문제에 일반화하지 못합니다.
두 번째로, validate_answers 함수는 답변 형식과 논리적 일관성을 검증합니다. GSM8K는 "단계별 풀이 #### 정답" 형식을 따르므로, "####"가 없거나 정답이 숫자가 아니면 오류로 간주합니다.
또한 "how many"(개수)를 묻는 질문에 음수 답변이 있으면 비논리적이므로 제거합니다. 이런 오류는 데이터 수집 과정에서 발생할 수 있으며(크롤링 실수, 인간 라벨링 오류 등), 이를 학습하면 모델이 혼란스러워집니다.
세 번째로, analyze_difficulty 함수는 문제의 계산 단계 수를 세어 난이도를 추정합니다. GSM8K는 "<<"로 중간 계산을 표시하므로, 이 기호의 개수가 곧 단계 수입니다.
예를 들어, "5 + 3 = <<5+3=8>>8"은 1단계, "5 + 3 = 8, 8 * 2 = <<8*2=16>>16"은 2단계입니다. 만약 전체 데이터의 50% 이상이 1단계 문제라면, 모델은 복잡한 다단계 추론을 학습하지 못할 것입니다.
이 경우 더 어려운 문제를 추가해야 합니다. 네 번째로, ensure_diversity 함수는 주제별 분포를 확인합니다.
"addition", "fraction", "percent" 같은 키워드를 검색하여 각 주제가 얼마나 포함되어 있는지 세고, 5% 미만인 주제는 부족하다고 경고합니다. 예를 들어, 곱셈 문제는 많은데 분수 문제가 거의 없다면, 모델은 분수 계산을 제대로 배우지 못합니다.
이 분석을 바탕으로 부족한 주제의 데이터를 추가로 수집하거나 생성할 수 있습니다. 마지막으로, 클리닝된 데이터를 save_to_disk로 저장하여 다음 학습에 사용합니다.
전체 과정을 통해 원본 7,473개 샘플이 예를 들어 7,200개로 줄었다면, 273개의 문제가 있는 샘플을 제거한 것입니다. 이렇게 양은 약간 줄지만 질은 크게 향상되어, 학습 효율이 높아집니다.
여러분이 이 코드를 사용하면 학습 데이터의 "건강 진단"을 할 수 있습니다. 어떤 문제가 있는지 정량적으로 파악하고, 구체적인 개선 작업을 수행할 수 있습니다.
실제로 데이터 클리닝만으로 모델 성능이 5-10% 향상되는 경우가 흔합니다. 또한 데이터 품질 보고서를 생성하여 팀원이나 논문 리뷰어에게 데이터의 신뢰성을 입증할 수 있습니다.
데이터 과학의 80%는 데이터 전처리라는 말이 있듯이, 이 단계를 소홀히 하면 안 됩니다.
실전 팁
💡 Near-duplicate 제거도 고려하세요. 완전히 같지는 않지만 매우 유사한 문제들(예: 숫자만 다른 문제)은 MinHash나 SimHash 같은 알고리즘으로 감지할 수 있습니다. 이런 문제가 많으면 모델이 템플릿을 암기하게 됩니다.
💡 인간 검수를 일부 샘플에 수행하세요. 무작위로 100개 샘플을 뽑아 전문가가 직접 검토하면, 자동화된 검증이 놓친 미묘한 오류를 발견할 수 있습니다. 예를 들어, 문제는 맞지만 풀이 과정이 논리적으로 틀린 경우는 자동 감지가 어렵습니다.
💡 데이터 증강(Augmentation)으로 다양성을 높이세요. 기존 문제의 숫자를 바꾸거나, 문장 구조를 변형하거나, 역번역(영어→한국어→영어)을 사용하면 새로운 변형을 만들 수 있습니다. 다만 의미가 바뀌지 않도록 주의하세요.
💡 Outlier 감지를 수행하세요. 비정상적으로 긴 질문이나 짧은 질문, 극단적인 숫자(10^10 같은)가 포함된 문제는 이상치일 수 있습니다. 이런 샘플은 따로 검토하여 유지할지 제거할지 결정하세요.
💡 버전 관리를 철저히 하세요. 데이터를 수정할 때마다 gsm8k_v1, gsm8k_v2 같은 버전을 만들고, 변경 로그를 기록하세요. 나중에 실험 결과를 재현하거나 어떤 버전이 더 좋았는지 비교할 때 필수적입니다. Git LFS를 사용하면 대용량 데이터셋도 버전 관리할 수 있습니다.
9. 프롬프트 엔지니어링 고급 기법 - 성능 극대화
시작하며
여러분이 모델을 파인튜닝했는데도 특정 문제에서 계속 실수하는 경우, 프롬프트를 어떻게 작성하느냐가 결과를 크게