리서치

LAB / 29번째 글

청크 겹침은 recall을 얼마에 사는가: 문단은 거의 못 사고, 답이 든 조각을 샀다

KorQuAD 문단을 256·512자로 자르며 겹침을 0·10·25·50%로 흔들고 질의 5,774개로 쟀다. 정답 문단을 찾는 R@5는 어느 겹침에서도 구간 밖으로 오르지 않았고, 512자 겹침 50%에서는 오히려 떨어졌다. 오른 것은 1위 조각에 답이 든 비율이었다 — 256자 겹침 50%에서 +3.10%p.

PALDYN Team26 MIN READ

지난 글은 같은 문서가 색인에 여러 벌 들어갈 때 지표가 어떻게 어긋나는지 쟀습니다. 청크를 겹치게 자르는 것은 그 일을 일부러 하는 셈입니다. 앞 조각 끝의 몇 어절을 다음 조각 머리에 다시 넣으니, 같은 문장이 두 조각에 함께 들어갑니다. 이 글은 그 대가로 무엇을 얻는지 잽니다.

겹침(overlap)은 청킹 설정에서 크기 다음으로 자주 보는 손잡이입니다. 「경계에서 잘린 문장을 살린다」는 설명과 함께 10~20%가 흔한 기본값으로 쓰입니다. 청크 크기와 recall 실측은 크기만 흔들고 한계 절에 「겹침은 재지 않았다」고 남겼고, 청크 분할기 실측도 같은 자리를 비워 두었습니다. 그 빈칸을 채웁니다.

결과를 먼저 적습니다. 정답 문단을 상위 5개 안에 찾는 R@5는 어느 겹침에서도 구간 밖으로 오르지 않았습니다. 512자 조각에 겹침 50%를 주면 오히려 0.43%p 떨어졌습니다. 확실히 오른 것은 따로 센 값, 곧 1위 조각 안에 답이 그대로 들어 있는 비율이었습니다. 겹침이 사는 것은 「어느 문단인가」가 아니라 「그 조각에 답이 다 들었는가」였습니다.

겹침이 무엇이고 청킹 전략이 어떻게 갈리는지는 RAG 청킹 전략이 맡습니다. Recall의 정의는 RAG 평가에 있습니다. 여기서는 겹침 비율 하나만 흔듭니다.

실험 설계

겹침 규칙

코퍼스는 CPU만으로 세우는 검색 실험대의 KorQuAD 그대로입니다. 위키백과 문단 960개, 평균 538자이고, 질의는 validation 5,774개 전부를 씁니다. 모델은 intfloat/multilingual-e5-small, 접두사는 학습대로 query: ·passage: 입니다.

자르는 방식은 청크 크기 글과 같은 공백 단위 그리디입니다. 어절을 이어 붙이다 한도를 넘으면 끊습니다. 여기에 겹침 한 줄을 더합니다. 조각 하나를 끊은 뒤, 그 조각 끝에서부터 어절을 거꾸로 세어 겹침 한도(크기 × 비율, 256자에 25%면 64자) 안에 드는 어절까지 되돌아가 다음 조각을 시작합니다. 어절 단위로 되돌아가므로 실제 겹치는 글자 수는 한도보다 조금 짧습니다. 겹침 0%에서는 이 규칙이 청크 크기 글의 분할과 정확히 같아집니다 — 256자 조각 2,469개, 512자 조각 1,384개로 개수가 같고, R@1도 0.8116과 0.7903으로 그 글의 표와 넷째 자리까지 같았습니다.

크기는 256자와 512자 둘입니다. 겹침 0%에서 256자는 문단당 평균 2.57조각, 512자는 1.44조각입니다. 이 차이가 뒤에서 결과를 가릅니다.

세 가지 셈

조각마다 원래 문단 번호를 들고 다니고, 세 가지를 셉니다.

  • 접지 않은 값(plain): 상위 k개 조각의 주인 문단 가운데 정답 문단이 있으면 맞힌 것입니다. 청크 크기 글의 R@k가 이것입니다. 같은 문단의 조각 둘이 상위 칸을 나눠 써도 그대로 둡니다.
  • 접은 값(folded): 순위를 위에서부터 훑으며 처음 나온 문단만 남겨 서로 다른 문단 10개를 채운 뒤 셉니다. 지난 글이 중복 문서에서 쓴 셈과 같고, 계획이 기준으로 정한 쪽이 이것입니다. 겹치면 이웃 조각끼리 닮아져 한 문단이 상위 칸을 여럿 차지하기 쉬운데, 접으면 그 낭비가 지워집니다.
  • 답 포함률(ans@1): 1위 조각 안에 KorQuAD 정답 문자열이 통째로 들어 있는 비율입니다. 겹침의 명분이 「경계에서 잘린 문장」이므로 그것을 직접 봅니다. 함께 ans whole도 셉니다 — 정답 문단의 조각 가운데 하나라도 답을 통째로 품은 질의의 비율이고, 1에서 모자란 만큼이 경계에 걸려 잘린 답입니다.

판정은 같은 크기의 겹침 0%와 짝지은 부트스트랩 1,000회입니다. 같은 질의에 두 조건을 다 걸어 빼므로 질의 난이도가 상쇄되고 구간이 좁습니다.

재현과 출력

조각과 검색

pip install torch sentence-transformers datasets numpy

리눅스에서 CUDA 의존을 받고 싶지 않으면 torch만 먼저 CPU 휠로 깝니다: pip install torch --index-url https://download.pytorch.org/whl/cpu

import sys, time, numpy as np
from datasets import load_dataset
from sentence_transformers import SentenceTransformer

N = int(sys.argv[1])
val = load_dataset("KorQuAD/squad_kor_v1")["validation"]
paras = sorted({r["context"] for r in val})
pidx = {p: i for i, p in enumerate(paras)}
gold = np.array([pidx[r["context"]] for r in val])
ans = [r["answers"]["text"][0] for r in val]

def split(text, n, ov):  # 공백 단위 그리디, 다음 조각은 앞 조각 끝의 ov·n자 안쪽 어절에서 다시 시작
    w, out, i = text.split(" "), [], 0
    while i < len(w):
        j, cur = i, w[i]
        while j + 1 < len(w) and len(cur) + 1 + len(w[j + 1]) <= n:
            j += 1; cur += " " + w[j]
        out.append(cur)
        if j + 1 >= len(w):
            break
        k, tail = j + 1, 0
        while k - 1 > i and tail + len(w[k - 1]) + 1 <= ov * n:
            k -= 1; tail += len(w[k]) + 1
        i = k
    return [c[x:x + n] for c in out for x in range(0, len(c), n)]

model = SentenceTransformer("intfloat/multilingual-e5-small")
Q = model.encode(["query: " + r["question"] for r in val], batch_size=64, normalize_embeddings=True, show_progress_bar=False)
sets = {}
for ov in (0, 0.10, 0.25, 0.50):
    cs = [split(p, N, ov) for p in paras]
    sets[ov] = ([c for x in cs for c in x], np.repeat(np.arange(len(paras)), [len(x) for x in cs]))
uniq = sorted({c for ps, _ in sets.values() for c in ps})  # 겹침 조건끼리 같은 조각은 한 번만 인코딩한다
t0 = time.perf_counter()
emb = dict(zip(uniq, model.encode(["passage: " + c for c in uniq], batch_size=32,
                                  normalize_embeddings=True, show_progress_bar=False)))
print(f"size={N} queries={len(gold)} unique pieces encoded={len(uniq)} in {time.perf_counter() - t0:.0f}s")
print(f"{'overlap':>8}{'pieces':>8}{'chars':>7}{'MB':>7}{'ans whole':>11}{'R@1':>8}{'R@5':>8}{'R@10':>8}{'ans@1':>8}{'uniq@10':>9}")
for ov, (pieces, owner) in sets.items():
    C = np.stack([emb[c] for c in pieces])
    top = np.argsort(-(Q @ C.T), axis=1)[:, :100]
    rk, hit = owner[top], owner[top] == gold[:, None]
    whole = np.array([any(a in pieces[t] for t in np.where(owner == g)[0]) for a, g in zip(ans, gold)])
    a1 = np.array([a in pieces[t] for a, t in zip(ans, top[:, 0])])
    np.save(f"ov_{N}_{int(ov * 100)}.npy", rk.astype(np.int32)); np.save(f"ans1_{N}_{int(ov * 100)}.npy", a1)
    print(f"{int(ov * 100):>7}%{len(pieces):>8}{np.mean([len(c) for c in pieces]):>7.0f}{C.nbytes / 2 ** 20:>7.2f}"
          f"{whole.mean():>11.4f}{hit[:, :1].any(1).mean():>8.4f}{hit[:, :5].any(1).mean():>8.4f}"
          f"{hit[:, :10].any(1).mean():>8.4f}{a1.mean():>8.4f}{np.mean([len(set(r)) for r in rk[:, :10]]):>9.2f}")
np.save("gold.npy", gold)
python3 overlap.py 256
python3 overlap.py 512

크기마다 한 번씩 돌립니다. 겹침 네 조건의 조각을 모아 글자까지 같은 조각은 한 번만 인코딩합니다. 문단 첫 조각과 한도보다 짧은 문단은 겹침과 상관없이 같은 글이라, 512자에서는 조각 5,707개 가운데 2,760개만 인코딩하면 됩니다. 같은 글은 같은 벡터를 내므로 결과는 따로 인코딩한 것과 같습니다.

실제 출력

size=256 queries=5774 unique pieces encoded=7966 in 155s
 overlap  pieces  chars     MB  ans whole     R@1     R@5    R@10   ans@1  uniq@10
      0%    2469    209   3.62     0.9943  0.8116  0.9543  0.9756  0.7536     7.89
     10%    2566    215   3.76     1.0000  0.8161  0.9574  0.9784  0.7690     7.63
     25%    2789    225   4.09     1.0000  0.8204  0.9524  0.9773  0.7759     7.18
     50%    3514    238   5.15     1.0000  0.8235  0.9519  0.9738  0.7846     6.20
size=512 queries=5774 unique pieces encoded=2760 in 93s
 overlap  pieces  chars     MB  ans whole     R@1     R@5    R@10   ans@1  uniq@10
      0%    1384    373   2.03     0.9986  0.7903  0.9468  0.9730  0.8102     9.29
     10%    1396    385   2.04     1.0000  0.7918  0.9467  0.9737  0.8164     9.08
     25%    1423    404   2.08     1.0000  0.7910  0.9456  0.9721  0.8161     8.73
     50%    1504    435   2.20     1.0000  0.7896  0.9425  0.9680  0.8135     8.16

짝지은 판정

import numpy as np

rng = np.random.default_rng(0)
gold = np.load("gold.npy")
bs = rng.integers(0, len(gold), (1000, len(gold)))


def fold(r):  # 같은 원문단에서 나온 조각을 하나로 접어 서로 다른 문단 10개를 채운다
    out = np.full((len(r), 10), -1, dtype=np.int32)
    for i, row in enumerate(r):
        _, first = np.unique(row, return_index=True)
        keep = row[np.sort(first)][:10]
        out[i, :len(keep)] = keep
    return out


def ci(d):
    lo, hi = np.percentile(d[bs].mean(1), [2.5, 97.5])
    return f"{d.mean():+.4f} [{lo:+.4f}, {hi:+.4f}] {'tie ' if lo <= 0 <= hi else 'GAIN' if lo > 0 else 'LOSS'}"


print(f"paired bootstrap vs. overlap 0 of the same size, n={len(gold)}, 1000 resamples")
for n in (256, 512):
    base = np.load(f"ov_{n}_0.npy"); fb = fold(base); a0 = np.load(f"ans1_{n}_0.npy").astype(float)
    for ov in (10, 25, 50):
        r = np.load(f"ov_{n}_{ov}.npy"); fr = fold(r)
        print(f"  {n}자 겹침 {ov:>2}%")
        for label, x, y, k in (("plain  R@1 ", base, r, 1), ("plain  R@5 ", base, r, 5), ("plain  R@10", base, r, 10),
                               ("folded R@5 ", fb, fr, 5), ("folded R@10", fb, fr, 10)):
            d = (y[:, :k] == gold[:, None]).any(1).astype(float) - (x[:, :k] == gold[:, None]).any(1)
            print(f"    {label}  {ci(d)}")
        print(f"    ans@1        {ci(np.load(f'ans1_{n}_{ov}.npy') - a0)}")
python3 overlap_stats.py
paired bootstrap vs. overlap 0 of the same size, n=5774, 1000 resamples
  256자 겹침 10%
    plain  R@1   +0.0045 [-0.0016, +0.0106] tie 
    plain  R@5   +0.0031 [-0.0000, +0.0064] tie 
    plain  R@10  +0.0028 [+0.0009, +0.0047] GAIN
    folded R@5   +0.0057 [+0.0028, +0.0085] GAIN
    folded R@10  +0.0017 [+0.0000, +0.0035] tie 
    ans@1        +0.0154 [+0.0078, +0.0234] GAIN
  256자 겹침 25%
    plain  R@1   +0.0088 [+0.0017, +0.0156] GAIN
    plain  R@5   -0.0019 [-0.0059, +0.0019] tie 
    plain  R@10  +0.0017 [-0.0009, +0.0043] tie 
    folded R@5   +0.0017 [-0.0021, +0.0052] tie 
    folded R@10  +0.0019 [-0.0002, +0.0042] tie 
    ans@1        +0.0223 [+0.0130, +0.0305] GAIN
  256자 겹침 50%
    plain  R@1   +0.0120 [+0.0057, +0.0182] GAIN
    plain  R@5   -0.0024 [-0.0062, +0.0016] tie 
    plain  R@10  -0.0017 [-0.0050, +0.0010] tie 
    folded R@5   +0.0040 [+0.0005, +0.0074] GAIN
    folded R@10  +0.0010 [-0.0010, +0.0033] tie 
    ans@1        +0.0310 [+0.0227, +0.0391] GAIN
  512자 겹침 10%
    plain  R@1   +0.0016 [-0.0023, +0.0050] tie 
    plain  R@5   -0.0002 [-0.0026, +0.0023] tie 
    plain  R@10  +0.0007 [-0.0009, +0.0023] tie 
    folded R@5   +0.0009 [-0.0012, +0.0031] tie 
    folded R@10  +0.0007 [-0.0007, +0.0021] tie 
    ans@1        +0.0062 [+0.0019, +0.0107] GAIN
  512자 겹침 25%
    plain  R@1   +0.0007 [-0.0040, +0.0054] tie 
    plain  R@5   -0.0012 [-0.0040, +0.0017] tie 
    plain  R@10  -0.0009 [-0.0028, +0.0012] tie 
    folded R@5   +0.0007 [-0.0023, +0.0035] tie 
    folded R@10  +0.0007 [-0.0009, +0.0023] tie 
    ans@1        +0.0059 [+0.0009, +0.0114] GAIN
  512자 겹침 50%
    plain  R@1   -0.0007 [-0.0055, +0.0040] tie 
    plain  R@5   -0.0043 [-0.0076, -0.0010] LOSS
    plain  R@10  -0.0050 [-0.0080, -0.0023] LOSS
    folded R@5   +0.0009 [-0.0017, +0.0036] tie 
    folded R@10  +0.0000 [-0.0021, +0.0021] tie 
    ans@1        +0.0033 [-0.0024, +0.0088] tie 

256자 조각

문단 단위 recall

256자에서 겹침이 드는 값은 조각 수로 바로 보입니다. 2,469개가 10%에서 2,566개(+3.9%), 25%에서 2,789개(+13.0%), 50%에서 3,514개(+42.3%)가 됩니다. 인덱스도 3.62MB에서 5.15MB로 같은 비율만큼 늘어납니다. 겹침 50%가 조각을 두 배로 만들지 않는 것은 문단마다 마지막 조각이 원래 짧기 때문입니다. 되돌아가 시작한 조각이 그 짧은 꼬리까지 담으면 끝에서 조각 하나가 덜 생깁니다.

그 값으로 산 문단 recall은 작습니다. 접지 않은 R@5는 세 겹침 모두 구간이 0을 품었고, 25%와 50%에서는 점추정이 오히려 음수입니다(−0.19%p, −0.24%p). 접은 R@5는 10%에서 +0.57%p로 구간 밖이었다가, 조각을 13% 더 쓰는 25%에서 다시 구간 안으로 들어갑니다. 50%에서 다시 +0.40%p로 겨우 구간 밖에 섭니다. 겹침을 늘릴수록 꾸준히 오르는 곡선이 아니라, 0.6%p 안쪽에서 오르내리는 값입니다.

R@1만은 겹침을 따라 올라갑니다. +0.45%p(구간 안), +0.88%p, +1.20%p입니다. 1등 자리 하나에서는 겹침이 듣는다는 뜻인데, 그 몫이 무엇인지는 다음 소절의 답 포함률이 더 분명하게 보여 줍니다.

uniq@10 열은 겹침의 다른 대가입니다. 상위 10칸에 서로 다른 문단이 7.89개였던 것이 50%에서 6.20개로 줄어듭니다. 이웃 조각이 문장을 나눠 가지니 둘이 함께 상위로 올라오기 쉬워집니다. 접지 않은 R@5가 25%·50%에서 점추정으로 내려간 것이 이 낭비 때문이고, 접으면 그 손해가 지워져 부호가 다시 양수가 됩니다. 지난 글이 중복 문서에서 본 어긋남과 방향이 같지만 크기는 훨씬 작습니다.

답이 든 조각

크게 움직인 것은 ans@1입니다. 1위 조각에 답이 통째로 든 비율이 0.7536에서 10%에 0.7690, 25%에 0.7759, 50%에 0.7846으로 오르고, 판정은 셋 다 구간 밖입니다(+1.54%p, +2.23%p, +3.10%p). 겹침이 사는 것이 문단이 아니라 이것이라는 것이 이 글의 결론입니다.

그런데 이 이득은 「경계에서 잘린 답을 살린다」는 명분보다 큽니다. ans whole을 보면 겹침 0%에서 답이 경계에 걸려 어느 조각에도 통째로 들지 못한 질의가 0.57%(1 − 0.9943)뿐입니다. 이 질의를 전부 구해도 ans@1은 0.57%p밖에 못 오릅니다. 겹침 50%의 +3.10%p 가운데 적어도 2.5%p는 잘린 답의 구제가 아닌 다른 데서 왔습니다.

후보는 두 가지입니다. 겹치면 조각이 길어지고(평균 209자 → 238자), 같은 답을 두 조각이 함께 덮어 질문에 더 맞는 쪽이 1위에 설 기회가 생깁니다. 이 둘을 갈라 재지는 않았습니다. 다만 잘린 답 구제만으로는 숫자가 안 맞는다는 것까지는 출력이 말합니다.

512자 조각

늘지 않는 조각 수

512자에서는 겹침이 조각을 거의 안 늘립니다. 1,384개가 10%에 1,396개, 25%에 1,423개, 50%에 1,504개로 50%에서도 +8.7%입니다. 문단당 평균 1.44조각이라 겹침이 할 수 있는 일은 대개 둘째 조각을 앞으로 당겨 길게 만드는 것이고, 셋째 조각을 만들 일은 드뭅니다. 평균 조각 길이가 373자에서 435자로 느는 것이 그 흔적입니다.

그래서 512자에서 겹침의 비용은 조각 수가 아니라 조각 길이로 나갑니다. 인덱스는 2.03MB에서 2.20MB로 8% 남짓 늘지만, 길어진 조각을 LLM에 넘기는 쪽의 토큰은 그보다 더 늡니다. 이 글은 인덱스만 쟀고 토큰은 재지 않았습니다.

겹친 칸

문단 recall은 어느 겹침에서도 오르지 않았습니다. 10%와 25%는 다섯 셈이 전부 구간 안입니다. 50%에서는 접지 않은 R@5가 −0.43%p, R@10이 −0.50%p로 구간 밖으로 떨어집니다. 같은 50%를 접으면 R@5 +0.09%p, R@10 +0.00%p로 둘 다 구간 안이라, 떨어진 몫은 전부 칸 낭비입니다. uniq@10이 9.29에서 8.16으로 줄어, 상위 10칸 가운데 한 칸 넘게가 이미 위에 나온 문단의 다른 조각입니다. 겹침을 크게 주면 상위 칸을 같은 문단이 나눠 가지면서, 정답 문단이 아닌 다른 문단이 들어올 자리를 밀어냅니다.

ans@1도 512자에서는 작습니다. 10%와 25%에서 +0.62%p, +0.59%p로 구간 밖이지만, 50%에서는 +0.33%p로 구간 안입니다. 겹침 0%에서도 답이 경계에 걸린 질의가 0.14%뿐이라 살릴 것이 처음부터 적었고, 조각이 커서 답이 이미 한 조각 안에 들어 있는 경우가 대부분이었습니다.

꺾이는 지점

판정

계획이 정한 꺾이는 지점은 「조각 수가 늘어난 만큼 R@5가 구간 밖으로 오르지 않는 첫 겹침 비율」입니다. 접지 않은 R@5로 재면 두 크기 모두 첫 칸인 10%입니다 — 256자는 +0.31%p가 구간 하단 −0.00에 걸쳐 있고, 512자는 −0.02%p입니다. 계획이 기준으로 둔 접은 R@5로 재면 256자는 10%에서 +0.57%p로 산 뒤 25%가 첫 지점이고, 512자는 역시 10%부터입니다.

한 줄로 줄이면 이렇습니다. 256자 조각에서 겹침 10%까지는 조각 +3.9%에 접은 R@5 +0.57%p와 ans@1 +1.54%p를 사는 거의 공짜 구간이고, 25%부터는 조각을 13~42% 더 쓰고도 R@5를 못 삽니다. 512자 조각에서는 문단 recall을 사는 겹침이 없고, 50%는 접지 않은 R@5를 0.43%p 깎습니다.

한계 효율

위 판정은 겹침마다 0%와 견준 것이라, 한 칸 더 겹칠 때마다 얼마를 더 내고 얼마를 더 받는지는 따로 보이지 않습니다. 256자의 ans@1로 계단을 나눠 보면 이렇습니다.

계단 늘어난 조각 늘어난 ans@1 조각 100개당
0% → 10% +97 +1.54%p 1.59%p
10% → 25% +223 +0.69%p 0.31%p
25% → 50% +725 +0.87%p 0.12%p

첫 계단이 나머지 둘보다 다섯 배에서 열세 배 효율이 좋습니다. 조각 97개로 산 1.54%p가 이 실험에서 가장 싼 이득이고, 그 뒤로는 같은 값을 사는 데 조각이 몇 배씩 더 듭니다. 이 표의 둘째·셋째 계단 차이는 0% 대비 값을 뺀 것이라 계단 하나하나에 구간을 따로 매기지 않았습니다. 효율이 줄어드는 방향만 읽고, 0.31과 0.12의 차이 자체는 근거로 쓰지 않습니다.

512자에는 이 표를 세우지 않았습니다. ans@1 이득이 10%와 25%에서 0.6%p 안팎으로 같고 50%에서는 구간 안이라, 계단마다 나눌 만한 이득이 처음부터 없습니다.

쓸 자리

LLM에 1위 조각 하나만 넘기거나 답의 위치를 조각 안에서 바로 짚어야 하는 파이프라인이라면, 256자급 작은 조각에서 겹침은 값을 합니다. ans@1이 50%까지 꾸준히 오르므로 저장 비용을 어디까지 낼지로 정하면 됩니다.

상위 5~10개를 넘기는 파이프라인이라면 겹침으로 살 것이 거의 없습니다. 정답 문단은 겹침 없이도 들어오고(R@5가 이미 0.95 근처), 겹침은 그 칸을 같은 문단의 다른 조각으로 채웁니다. 겹침을 크게 준다면 상위 칸을 문단 단위로 접는 단계를 뒤에 두어야 손해를 안 봅니다.

조각이 문단과 엇비슷하게 큰 경우, 이 코퍼스의 512자처럼 문단당 1.5조각이 안 되는 경우에는 겹침을 끄는 쪽이 기본값으로 낫습니다. 10%와 25%가 사는 ans@1 0.6%p는 인덱스 0.5~2.5%로 싸긴 하지만, 문단 recall은 다섯 셈 어디서도 움직이지 않았고 50%로 가면 접지 않은 R@5·R@10이 구간 밖으로 떨어집니다. 「경계에서 잘린 문장」이 생길 자리가 문단당 0.44곳밖에 없으니 살릴 것도 그만큼 적습니다.

한계와 측정 환경

한계

  • 코퍼스 하나, 모델 하나입니다. KorQuAD는 질문이 문단을 읽고 만들어졌고 답은 문단 안의 짧은 문자열 하나입니다. 답이 여러 문장에 걸치는 질의라면 경계 구제의 몫이 훨씬 클 수 있는데, 그런 질의는 이 코퍼스에 거의 없습니다.
  • 960문단은 작습니다. R@5가 이미 0.95 근처라 오를 여지가 처음부터 좁았습니다. 코퍼스가 커져 R@5가 내려간 자리에서는 겹침이 문단 recall을 살 수도 있습니다.
  • ans@1의 이득이 어디서 왔는지는 가르지 않았습니다. 조각이 길어진 몫과 두 조각이 같은 답을 덮는 몫을 나누려면, 겹침 없이 조각 길이만 같게 맞춘 대조군이 필요합니다.
  • 문자 수로 잘랐습니다. 토큰 수로 자르면 한국어는 같은 256자가 모델마다 다른 길이가 됩니다. 이 모델의 상한은 512토큰이고, 512자 조각 일부가 그 상한에 닿는지는 이번에 세지 않았습니다(청크 크기 글에서 1024자 조각 1,001개 중 60개가 넘었습니다).
  • 겹침을 어절 단위로 되돌아가 만들었습니다. 글자 단위 미닫이 창이나 문장 단위 겹침은 경계가 다른 곳에 생기므로 숫자가 다를 수 있습니다.
  • 인덱스 바이트만 쟀습니다. 검색 시간과, 길어진 조각이 생성 단계에서 먹는 토큰은 재지 않았습니다.

측정 환경

항목 값
OS Linux 6.18.44 x86_64, glibc 2.39
CPU / RAM Intel Xeon @ 2.10GHz, 4 vCPU / 15GB
Python 3.11.17
패키지 torch 2.14.1, sentence-transformers 6.2.0, transformers 5.21.0, datasets 5.1.0, numpy 2.4.6
모델 intfloat/multilingual-e5-small (614241f, 384차원)
데이터 KorQuAD/squad_kor_v1 (01aad23) validation
실행 시간 256자 3분 13초, 512자 2분 9초, 판정 1.6초
측정일 2026-10-27

torch는 PyPI 휠(2.14.1)을 썼습니다. 이 컨테이너에서 download.pytorch.org의 CPU 휠이 프록시에서 막혀(403) 기본 휠을 받았고, GPU 없이 CPU로만 돌았습니다.

발행 전 자기검사로 가상환경을 새로 만들어 패키지를 처음부터 다시 깔고 세 스크립트를 다시 돌렸습니다. 위에 실은 출력이 그 재실행의 출력입니다. 조각 수, Recall, ans@1, 부트스트랩 구간까지 첫 실행과 전부 같았고 인코딩 시간만 달랐습니다(256자 166초 대 155초). 인코딩 시간은 결론에 쓰지 않습니다.


읽어주셔서 감사합니다. 😊

LATEST

과학·실험의 최신 글

과학·실험2026.11.17

재순위는 헷갈리는 질의에만 걸면 얼마를 아끼는가: 질의 40%에 걸어 이득을 다 냈고, 확신한 질의에는 안 거는 편이 나았다

1차 검색의 1위·2위 점수 차가 작은 질의에만 cross-encoder를 걸고 재순위 비율을 10%씩 올리며 nDCG@10을 쟀다. scifact에서 하위 40%에만 걸면 전부 재순위한 이득의 93.6~102.6%를 지켰고, 60~70%에만 걸면 전부 건 것보다 0.6~0.8%p 높았다. 영어 cross-encoder는 KorQuAD에서 전부 걸면 21~24%p를 잃어 판정에서 뺐다.

26 MIN
과학·실험2026.11.17

사람이 내는 오타로 다시 재면: 의존명사 띄어쓰기는 R@1을 하나도 안 깎았고, 이웃 키 오타는 무작위보다 dense를 더 깎았다

KorQuAD 질의 5,774개에 두벌식 이웃 키 치환·받침 탈락과 덧붙임·의존명사와 보조용언 앞 공백 삭제를 넣고 dense·형태소 BM25·문자 2-gram BM25의 R@1을 무작위 잡음과 짝지어 쟀다. 의존명사 띄어쓰기는 전부 틀려도 손실이 0이었고, 이웃 키 오타는 dense에서 무작위보다 1.96~2.39%p 더 아팠다. 세 검색기의 순위는 끝까지 안 뒤집혔다.

36 MIN
과학·실험2026.10.28

MMR로 다양성을 올리면 정확도를 얼마나 내주는가: 중복이 없으면 λ 0.8부터 내주고, 중복이 있어도 원래 자리로는 못 돌아온다

MMR의 λ를 1.0에서 0.3까지 내리며 scifact 원본·중복 주입 코퍼스 넷과 KorQuAD에서 nDCG@10과 상위 10개의 고유 문서 수·쌍 유사도를 쟀다. 원본 scifact는 λ 0.8에서 nDCG@10을 1.16%p 내줬고, 중복 코퍼스에서는 λ 0.9~0.8이 1.16~2.89%p를 되찾았지만 원본의 0.6451에는 어느 λ에서도 닿지 못했다.

27 MIN