LLM 평가와 안전성: 환각, 편향, 탈옥

LLM이 좋아졌는지 나빠졌는지 숫자로 판단하는 법을 다뤄요. 200문제로 잰 정확도가 얼마나 흔들리는지, 같은 문제로 짝지어 비교하면 왜 차이를 더 잘 잡는지 시뮬레이션으로 확인하고, 찍기를 부추기는 채점 방식이 환각을 키우는 원리, 심판 모델의 위치 편향, 이름만 바꾼 짝으로 편향 재기, 탈옥과 프롬프트 주입의 차이, 안전 필터가 공격 통과와 과잉 거절 사이에서 줄타기하는 이유까지 계산으로 정리해요.

고급강의 8 / 9약 14분

프롬프트를 고쳤더니 답이 좋아진 것 같아요. 새 모델로 바꿨더니 더 똑똑해진 것 같아요. 그런데 정말 좋아졌을까요? 몇 개 질문을 던져 보고 "괜찮네"로 판단하면, 우연히 잘 나온 답에 속거나 다른 곳이 망가진 걸 놓쳐요. 이번 강의는 LLM을 숫자로 평가하는 법과, 평가해야 할 대표적인 위험인 환각, 편향, 탈옥을 다뤄요.

LLM 평가가 어려운 이유

  • 정답이 하나가 아니에요. "이 글을 요약해 줘"에는 좋은 답이 수없이 많아요.
  • 같은 질문에도 답이 바뀌어요. 샘플링 때문에 실행할 때마다 결과가 달라요.
  • 시험 문제가 새어 나가요. 공개된 시험 문제가 인터넷에 퍼지면 사전 학습 데이터에 섞여 들어가요. 모델이 문제를 외워서 점수가 부풀려지는 오염이에요.
  • 시험이 너무 쉬워져요. 최신 모델들이 거의 만점을 받는 시험은 더 이상 실력 차이를 가려내지 못해요.

그래서 공개 시험 점수는 참고만 하고, 실제 서비스에서는 내 사용 사례로 만든 평가 세트가 가장 중요해요. RAG 강의에서 질문 세트를 먼저 만든 것과 같은 원리예요.

채점 방법 고르기

  • 정답이 정해진 문제: 객관식, 숫자 답, 분류는 정확히 맞혔는지로 채점해요.
  • 코드: 테스트를 돌려 통과하면 정답이에요. 같은 문제를 여러 번 풀게 해서 "kk번 시도 중 한 번이라도 통과할 확률"인 pass@k로 재기도 해요.
  • 열린 답: 사람이 채점 기준표를 보고 점수를 매기거나, 다른 LLM에게 기준표를 주고 채점시켜요(LLM 심판). 사람보다 싸고 빠르지만, 뒤에서 볼 편향이 있어요.
  • 둘 중 고르기: 두 모델의 답을 나란히 보여 주고 더 나은 쪽을 고르게 해요. 수많은 사람의 투표를 모아 모델 순위를 매기는 공개 순위표들이 이 방식이고, 점수는 사전 학습과 정렬 강의의 브래들리 테리 모형으로 계산해요.

pass@k는 문제마다 nn번 풀어서 cc번 통과했을 때 이렇게 추정해요. nn개 중 kk개를 뽑았는데 전부 실패일 확률을 1에서 빼는 거예요.

pass@k=1−(n−ck)(nk)\text{pass@}k = 1 - \frac{\binom{n-c}{k}}{\binom{n}{k}}
import math
import numpy as np
from scipy import stats

def pass_at_k(n, c, k):
    if n - c < k:
        return 1.0                                   # 실패만으로는 k개를 채울 수 없어요
    return 1 - math.comb(n - c, k) / math.comb(n, k)

print([round(pass_at_k(10, 3, k), 3) for k in (1, 5, 10)])
[0.3, 0.917, 1.0]

10번 중 3번 통과하는 문제라면, 한 번만 시도할 때 30%, 다섯 번 시도할 기회가 있으면 92% 확률로 통과해요. 어떤 kk로 쟀는지 밝히지 않은 점수는 비교할 수 없어요.

점수도 흔들려요: 평가의 통계

200문제 평가에서 정확도 70%가 나왔다면, 진짜 실력은 얼마일까요? 확률과 통계 트랙의 표본과 추정 강의에서 본 것처럼, 정확도도 표본에서 잰 평균이라 오차가 있어요.

for n in (100, 200, 500, 1000, 5000):
    half = 1.96 * math.sqrt(0.7 * 0.3 / n)           # 95% 신뢰 구간의 반폭
    print(n, f"±{half * 100:.1f}%p")
100 ±9.0%p
200 ±6.4%p
500 ±4.0%p
1000 ±2.8%p
5000 ±1.3%p

200문제로 잰 70%는 사실 "64%에서 76% 사이 어딘가"예요. 프롬프트를 고친 뒤 72%가 나왔다고 좋아졌다고 말할 수 없어요.

두 모델 비교는 같은 문제로 짝지어서

모델 A와 B를 비교할 때는 같은 문제로 시험 보고, 문제마다 짝지어 비교하는 게 좋아요. 문제마다 난이도가 크게 달라서, 둘 다 맞히는 쉬운 문제와 둘 다 틀리는 어려운 문제는 비교에 아무 정보도 주지 않거든요. 정보는 한쪽만 맞힌 문제에 있어요. B만 맞힌 문제와 A만 맞힌 문제의 수가 반반에서 얼마나 벗어나는지 이항 검정으로 보는 것이, 가설 검정 강의에서 본 맥니마 검정이에요.

B가 실제로 약 5%p 더 나은 상황을 시뮬레이션해서, 차이를 얼마나 자주 잡아내는지 볼게요. 문제 난이도는 넓게 퍼져 있고, 두 모델 모두 같은 난이도의 영향을 받아요.

def compare(seed, n):
    r = np.random.default_rng(seed)
    difficulty = r.normal(0, 2.5, n)                 # 문제마다 다른 난이도
    a = r.random(n) < 1 / (1 + np.exp(-(1.0 - difficulty)))
    b = r.random(n) < 1 / (1 + np.exp(-(1.4 - difficulty)))   # B가 조금 더 잘해요
    gap = b.mean() - a.mean()
    se = math.sqrt(a.mean() * (1 - a.mean()) / n + b.mean() * (1 - b.mean()) / n)
    p_separate = 2 * (1 - stats.norm.cdf(abs(gap) / se))      # 두 점수를 따로 비교
    only_b, only_a = int((b & ~a).sum()), int((a & ~b).sum())
    p_paired = stats.binomtest(only_b, only_b + only_a, 0.5).pvalue   # 한쪽만 맞힌 문제로 비교
    return gap, p_separate < 0.05, p_paired < 0.05

for n in (200, 500, 1000):
    runs = [compare(1000 + s, n) for s in range(300)]
    gap = np.mean([g for g, _, _ in runs])
    sep = np.mean([s for _, s, _ in runs])
    pair = np.mean([p for _, _, p in runs])
    print(n, f"평균 차이 {gap:.3f}, 따로 비교 {sep:.0%}, 짝 비교 {pair:.0%}")
200 평균 차이 0.047, 따로 비교 9%, 짝 비교 24%
500 평균 차이 0.049, 따로 비교 34%, 짝 비교 57%
1000 평균 차이 0.048, 따로 비교 64%, 짝 비교 86%

두 가지가 보여요. 첫째, 5%p는 생각보다 잡기 어려운 차이예요. 500문제로도 따로 비교하면 세 번에 한 번만 "의미 있는 차이"로 나와요. 둘째, 같은 문제로 짝지어 비교하면 검출률이 크게 올라가요. 평가 세트를 키울 수 없다면 짝 비교부터 하세요. 같은 이유로, 두 모델의 공개 시험 점수를 서로 다른 문제 세트에서 잰 것끼리 비교하면 안 돼요.

환각: 그럴듯하게 틀리기

환각은 모델이 사실이 아닌 내용을 자신 있게 말하는 거예요. 없는 논문을 인용하고, 없는 법 조항을 설명하고, 존재하지 않는 함수를 쓰는 코드를 짜요. 사전 학습 강의에서 본 것처럼, 언어 모델은 "그럴듯한 다음 말"을 배우기 때문에 그럴듯함과 사실이 어긋나는 곳에서 환각이 생겨요.

채점 방식이 찍기를 부추겨요

시험에서 "모르겠어요"는 0점이고 찍어서 맞히면 1점이라면, 확신이 20%뿐이어도 찍는 게 이득이에요. 2025년에 OpenAI 연구진이 낸 논문은 환각이 계속되는 큰 이유로 바로 이 점을 들었어요. 대부분의 평가가 맞힌 비율만 세니까, 모델이 모를 때도 찍도록 길들여진다는 거예요. 틀린 답에 감점을 주면 계산이 달라져요.

확신맞히면 1, 틀려도 0일 때 찍은 기대 점수맞히면 1, 틀리면 -1일 때
20%0.2 (찍는 게 이득)-0.6 (모른다고 하는 게 이득)
50%0.50
80%0.80.6

틀리면 -1점인 채점에서는 확신이 50%를 넘을 때만 답하는 게 최선이에요. 확신을 잘 아는(보정된) 모델로 1,000문제를 풀어 볼게요.

rng = np.random.default_rng(1)
conf = rng.beta(2, 1.2, 1000)                        # 문제마다 모델의 확신
correct = rng.random(1000) < conf                    # 확신만큼 맞혀요 (잘 보정된 모델)
for t in (0.0, 0.5, 0.75):                           # 확신이 t를 넘을 때만 답해요
    answer = conf > t
    right = int((answer & correct).sum())
    wrong = int((answer & ~correct).sum())
    print(t, f"답한 비율 {answer.mean():.1%}, 답한 것 중 정답 {right / answer.sum():.1%}, "
             f"틀린 답 {wrong}개, 정확도 점수 {right / 1000:.3f}, 감점 점수 {(right - wrong) / 1000:.3f}")
0.0 답한 비율 100.0%, 답한 것 중 정답 60.3%, 틀린 답 397개, 정확도 점수 0.603, 감점 점수 0.206
0.5 답한 비율 68.3%, 답한 것 중 정답 73.4%, 틀린 답 182개, 정확도 점수 0.501, 감점 점수 0.319
0.75 답한 비율 35.7%, 답한 것 중 정답 86.6%, 틀린 답 48개, 정확도 점수 0.309, 감점 점수 0.261

맞힌 비율만 세는 정확도 점수로는 무조건 답하기(0.603)가 1등이에요. 틀린 답이 397개인데도요. 틀린 답에 감점을 주면 확신이 50%를 넘을 때만 답하기(0.319)가 1등이 되고, 틀린 답은 182개로 절반 아래로 줄어요. 평가 방식이 모델과 프롬프트를 어느 쪽으로 다듬을지 정해요. 서비스에서 틀린 답이 모르겠다는 답보다 해롭다면, 평가도 그렇게 매겨야 해요.

환각을 줄이는 방법

  • 자료를 주고 출처를 달게 하기: RAG 강의처럼 근거를 넣고, 문장마다 출처를 달게 하고, 없으면 없다고 말하게 해요.
  • 모른다고 말할 자리 만들기: 프롬프트에 "확실하지 않으면 그렇다고 말하라"고 적고, 평가에서도 그런 답을 감점하지 않아요.
  • 여러 번 물어 일관성 보기: 같은 질문을 여러 번 샘플링했을 때 답이 제각각이면 환각일 가능성이 높아요. 아는 사실은 대체로 일관되게 답하거든요.
  • 도구로 확인하기: 계산은 계산기로, 코드는 실행으로, 사실은 검색으로 확인해요. 에이전트 강의의 "걸음마다 확인하기"와 같은 생각이에요.

LLM 심판의 편향

LLM에게 채점을 맡기면 편리하지만, 심판도 편향이 있어요. 2023년의 한 연구는 LLM 심판이 먼저 나온 답을 선호하는 위치 편향, 긴 답을 선호하는 길이 편향, 자기가 쓴 답을 선호하는 자기 선호를 보인다고 보고했어요. 위치 편향이 얼마나 결과를 비트는지 계산해 볼게요. X가 실제로 조금 더 나은 답이고(품질 차이 0.2), 심판은 먼저 나온 답에 1.0만큼 점수를 더 준다고 해 볼게요.

def sig(x):
    return 1 / (1 + math.exp(-x))

quality_gap, position_bias = 0.2, 1.0
x_first = sig(quality_gap + position_bias)           # X를 먼저 보여 줄 때 X가 이길 확률
x_second = 1 - sig(-quality_gap + position_bias)     # Y를 먼저 보여 줄 때 X가 이길 확률
print(round(x_first, 3), round(x_second, 3), round((x_first + x_second) / 2, 3), round(sig(quality_gap), 3))
0.769 0.31 0.539 0.55

X를 늘 먼저 보여 주면 X의 승률이 77%로 부풀고, 늘 나중에 보여 주면 31%로 쪼그라들어요. 순서만 바꿨는데 결론이 정반대가 되는 거예요. 두 순서로 한 번씩 채점해서 평균하면 54%로, 편향 없는 심판의 55%에 거의 돌아와요. 실무에서는 이렇게 순서를 바꿔 두 번 묻고, 두 판정이 엇갈린 경우는 무승부로 처리하거나 따로 살펴봐요. 그리고 심판을 믿기 전에, 사람이 채점한 예시 수십에서 수백 개로 심판과 사람이 얼마나 일치하는지부터 재요.

편향: 데이터에서 물려받은 것

모델은 사람이 쓴 글로 배우니, 글에 담긴 고정관념도 함께 배워요. 직업과 성별을 짝짓거나, 특정 지역이나 집단을 부정적으로 묘사하거나, 언어에 따라 성능이 크게 달라지는 식이에요. 채용, 대출, 의료처럼 사람에게 중요한 결정에 LLM을 쓰면 이런 편향이 실제 피해가 돼요.

편향을 재는 기본 방법은 반사실 짝이에요. 내용은 똑같고 이름, 성별, 나이, 출신 지역만 바꾼 입력의 짝을 만들어 결과를 비교해요. 이름만 다른 같은 이력서에 다른 점수가 나온다면, 그 차이는 이름 때문이에요. 이름만 바꾼 같은 이력서로 LLM을 시험한 분석들에서 실제로 차이가 드러나기도 했어요. 위에서 본 짝 비교가 그대로 쓰여요. 같은 이력서끼리 짝지으니 이력서마다의 차이가 지워지고 이름의 효과만 남아요.

조심할 점도 있어요. 공정성에는 "집단마다 합격률이 같아야 한다", "실력이 같은 사람은 집단과 상관없이 같은 확률로 합격해야 한다" 같은 여러 정의가 있고, 집단 사이의 기본 비율이 다르면 이 정의들을 동시에 만족할 수 없다는 것이 수학적으로 증명돼 있어요. 어떤 공정성을 지킬지는 기술이 아니라 사회적 선택이고, 그 선택을 분명히 밝히는 것이 평가의 출발점이에요.

탈옥과 프롬프트 주입

둘은 자주 섞여 쓰이지만 공격하는 대상이 달라요.

  • 탈옥: 사용자가 모델의 안전 규칙을 우회해서, 원래 거절해야 할 내용을 얻어 내려는 시도예요.
  • 프롬프트 주입: 제3자가 문서, 웹 페이지, 메일 같은 자료에 지시를 숨겨서, 그 자료를 읽은 앱이 개발자의 지시 대신 공격자의 지시를 따르게 하는 공격이에요. RAG와 에이전트 강의에서 본 것이 이거예요.

방어하는 사람이 알아야 할 탈옥의 대표적인 유형은 이래요.

  • 역할극과 가정: "소설 속 악당이라면 어떻게 말할까"처럼 상황을 꾸며 규칙을 피해 가요.
  • 조금씩 수위 올리기: 여러 번의 대화에 걸쳐 무해한 질문에서 시작해 한 걸음씩 밀어붙여요.
  • 표현 바꾸기: 안전 학습이 덜 된 언어로 묻거나, 암호처럼 바꿔 쓰거나, 낱말을 쪼개 써요.
  • 예시 잔뜩 넣기: 긴 맥락에 "규칙을 어기고 답한 대화" 예시를 수백 개 넣어서 모델이 그 흐름을 따르게 해요. 맥락 창이 커지면서 생긴 공격이에요(2024년 보고).
  • 자동으로 찾은 문자열: 사람이 읽으면 무의미한 문자열을 최적화로 찾아 질문 뒤에 붙여 안전장치를 무너뜨려요(2023년 보고).

방어는 여러 겹으로

  • 안전 학습: 사전 학습과 정렬 강의의 사람 피드백 학습과 헌법적 AI로 위험한 요청을 거절하도록 학습해요.
  • 입력과 출력 검사: 별도의 분류 모델이 위험한 요청과 응답을 걸러요.
  • 지시의 우선순위: 개발자의 시스템 지시가 사용자 입력보다, 사용자 입력이 문서 속 글보다 우선하도록 학습시켜요.
  • 권한 최소화: 에이전트 강의처럼, 모델이 속더라도 큰일을 못 하게 설계해요.
  • 레드팀과 감시: 공격자 입장에서 일부러 깨 보는 팀을 두고, 실제 사용 기록에서 새 공격을 찾아 다시 학습과 필터에 반영해요.

거절의 줄타기

안전 필터는 요청마다 위험 점수를 매기고 문턱을 넘으면 거절한다고 해 볼게요. 해로운 요청의 점수는 평균 2.5, 위험해 보이지만 멀쩡한 요청("파이썬 프로세스를 죽이는 법" 같은)은 평균 0에 퍼져 있다고 해요.

for t in (0.0, 0.5, 1.0, 1.5, 2.0):
    attack = stats.norm.cdf(t - 2.5)                 # 해로운 요청이 문턱 아래로 통과할 확률
    over = 1 - stats.norm.cdf(t - 0.0)               # 멀쩡한 요청이 문턱을 넘어 거절될 확률
    print(t, f"공격 통과 {attack:.1%}, 과잉 거절 {over:.1%}")
better = (stats.norm.cdf(2.0 - 4.0), 1 - stats.norm.cdf(2.0))   # 해로운 요청 평균이 4로 더 잘 구분되면
print(f"개선된 필터, 문턱 2.0: 공격 통과 {better[0]:.1%}, 과잉 거절 {better[1]:.1%}")
0.0 공격 통과 0.6%, 과잉 거절 50.0%
0.5 공격 통과 2.3%, 과잉 거절 30.9%
1.0 공격 통과 6.7%, 과잉 거절 15.9%
1.5 공격 통과 15.9%, 과잉 거절 6.7%
2.0 공격 통과 30.9%, 과잉 거절 2.3%
개선된 필터, 문턱 2.0: 공격 통과 2.3%, 과잉 거절 2.3%

문턱을 낮추면 공격은 막히지만 멀쩡한 요청의 절반을 거절하는 답답한 모델이 되고, 높이면 친절하지만 공격이 새요. 머신러닝 트랙 평가 강의의 정밀도와 재현율 줄타기와 같은 구조예요. 문턱 조절만으로는 둘 다 줄일 수 없고, 둘을 함께 줄이려면 해로운 요청과 멀쩡한 요청을 더 잘 구분하는 필터가 필요해요(마지막 줄). 그래서 안전성 평가는 늘 두 숫자를 함께 봐요. 공격 시도 모음에서의 공격 성공률과, 멀쩡하지만 위험해 보이는 질문 모음에서의 과잉 거절률이요.

평가를 습관으로 만들기

  1. 평가 세트를 실제 사용에서 뽑아요. 흔한 경우, 어려운 경우, 답이 없는 경우, 거절해야 하는 경우를 골고루 담고, 채점 기준을 글로 적어 둬요.
  2. 바꿀 때마다 돌려요. 프롬프트, 모델, 검색 설정을 바꾸면 전체 평가를 다시 돌려 전후를 짝 비교해요. 코드의 회귀 테스트와 같아요.
  3. 점수만 보지 말고 실패 사례를 읽어요. 숫자는 무엇이 나빠졌는지 알려 주지 않아요.
  4. 평가 세트를 학습이나 예시에 쓰지 않아요. 그 순간 오염이 돼요.
  5. 지표를 맹신하지 않아요. 사전 학습과 정렬 강의의 굿하트 법칙처럼, 점수만 좇으면 점수는 오르고 실제 품질은 떨어질 수 있어요.

실습

  1. pass_at_k(20, 2, k)를 kk = 1, 5, 10으로 계산해 보세요. 어려운 문제에서 kk가 결과를 얼마나 바꾸나요?
  2. compare에서 두 모델의 실력 차이를 1.0과 1.8로 키우면 200문제로도 차이를 잡을 수 있나요?
  3. 감점 점수를 "틀리면 -2"로 바꾸면 가장 좋은 문턱 tt는 얼마가 될까요? 계산으로 예상하고 시뮬레이션으로 확인해 보세요.
  4. 위치 편향 계산에서 position_bias를 0.3, 2.0으로 바꿔 두 순서 평균이 얼마나 정확한지 보세요.
  5. 안전 필터에서 과잉 거절을 5% 아래로 지키면서 공격 통과를 가장 낮게 하는 문턱은 얼마인가요?

자주 하는 실수

  • 몇 개 질문으로 감을 잡고 판단하기. 200문제의 점수도 ±6%p 흔들려요.
  • 다른 문제 세트에서 잰 점수끼리 비교하기. 같은 문제로 짝지어 비교해요.
  • 맞힌 비율만 세기. 모르는데 찍는 모델이 높은 점수를 받아요.
  • LLM 심판을 그대로 믿기. 순서를 바꿔 두 번 묻고, 사람 채점과의 일치도를 먼저 재요.
  • 안전성을 공격 성공률 하나로만 보기. 과잉 거절률도 함께 봐요.
  • 평가 세트를 프롬프트 예시로 쓰기. 평가가 오염돼요.

점검 문제

  1. 공개 시험 점수만 믿으면 안 되는 이유 두 가지는?
  2. 10번 중 3번 통과하는 문제의 pass@1은 얼마인가요?
  3. 200문제에서 정확도 70%의 95% 신뢰 구간 반폭은 대략 얼마인가요?
  4. 두 모델을 같은 문제로 짝지어 비교하면 차이를 더 잘 잡는 이유는?
  5. 맞힌 비율만 세는 평가가 환각을 부추기는 이유는?
  6. LLM 심판의 위치 편향을 줄이는 간단한 방법은?
  7. 탈옥과 프롬프트 주입의 차이는?
  8. 안전 필터의 문턱 조절만으로는 공격 통과와 과잉 거절을 함께 줄일 수 없는 이유는?

정답

  1. 시험 문제가 학습 데이터에 섞여 점수가 부풀려질 수 있고(오염), 내 사용 사례와 시험 내용이 다르기 때문이에요. 최신 모델끼리는 점수가 다 높아서 차이를 못 가리기도 해요.
  2. 1−(71)/(101)=1−0.7=0.31 - \binom{7}{1} / \binom{10}{1} = 1 - 0.7 = 0.3이에요.
  3. 1.96×0.7×0.3/200≈0.0641.96 \times \sqrt{0.7 \times 0.3 / 200} \approx 0.064, 약 6.4%p예요.
  4. 둘 다 맞히거나 둘 다 틀리는 문제는 비교에 정보가 없고, 문제마다 다른 난이도가 만드는 흔들림이 짝 비교에서는 지워지기 때문이에요. 한쪽만 맞힌 문제에 집중할 수 있어요.
  5. 모른다고 하면 0점이고 찍어서 맞히면 점수를 받으니, 확신이 낮아도 찍는 쪽이 늘 이득이기 때문이에요.
  6. 두 답의 순서를 바꿔 두 번 채점하고 평균하거나, 엇갈린 판정은 무승부로 처리해요.
  7. 탈옥은 사용자가 모델의 안전 규칙을 우회하려는 것이고, 프롬프트 주입은 제3자가 자료 속에 숨긴 지시로 앱이 개발자 대신 공격자의 지시를 따르게 하는 거예요.
  8. 해로운 요청과 멀쩡한 요청의 점수 분포가 겹쳐 있어서, 문턱을 옮기면 한쪽이 줄어드는 만큼 다른 쪽이 늘어나기 때문이에요. 둘을 함께 줄이려면 분포를 더 잘 가르는 필터가 필요해요.

다음 강의

LLM 트랙의 마지막 강의에서는 글이 아니라 그림을 만드는 생성 모델로 넘어가요. 데이터를 압축했다 풀어내는 VAE, 위조범과 감별사가 겨루는 GAN, 그리고 잡음에서 그림을 한 걸음씩 되살려 내는 확산 모델의 원리를 직접 작은 예제로 구현해 봐요.