변경 사항 테스트하기

읽는 데 약 45분분 걸린다, 12절에 11개 예제이(가) 있음.

2026.11.10판 예제 통과 2026년 11월 19 132개 예제 중 132개 통과 변경 사항

AI로 번역함. 영어 원문을 사람이 검증함. 우리가 책을 만드는 방식

영어판 2026.11.10판을 번역한 것이다. 원문 읽기

이 장을 마치면 검색에 가한 변경을 배포해야 하는지 판단할 수 있다. 두 랭커의 결과를 질의별로 비교하고, 테스트 질의가 변경을 실제보다 좋아 보이게 만들지 않도록 관리하고, A/B 테스트의 규모를 정하고, 결과를 인터리빙하여 두 랭커를 비교한다.

이 책이 따라가는 가구와 생활용품 온라인 소매점(1장)은 검색창에서 여전히 BM25를 기준선으로 운영하고 있다. 앞선 장들의 오프라인 작업으로 시맨틱 검색은 BM25보다 확고한 우위를 보였다(3장). 전환은 하나의 변경이며, 뒤따르는 모든 조정도 마찬가지이다. 더 저렴한 임베딩, 혼합 가중치, 리랭커가 그 예이다. 변경마다 같은 네 가지 질문이 제기된다. 평균이 노이즈보다 큰 폭으로 올랐는가? 어떤 질의가 나빠졌는가? 판정 데이터로 새 결과의 점수를 매길 수 있는가? 쇼핑객은 판정이 예측하는 대로 행동할 것인가? 이 장은 이 순서대로 답한다. 상점의 테스트 질의 30개는 회귀 테스트 집합, 즉 모든 변경을 시험하는 고정 질의가 되며, 모든 선택은 학습 질의 50개로 내린다. 상점에는 클릭 로그가 없으므로 온라인을 다루는 절에서는 쇼핑객을 시뮬레이션하고, 각 시뮬레이션의 가정을 옆에 밝혀 둔다.

이 장은 테스트 질의에서 하나의 비교를 계획한다. 시맨틱 검색과 BM25의 비교이다. 3장에 따라 계획된 비교가 하나이면 이 책 전체의 0.05를 그대로 쓰므로, 여기서는 차이가 0.05 미만일 때 확립된 것으로 본다. 이 장에서 테스트 질의에 대한 그 밖의 모든 점수는 탐색적이다.

두 실행을 질의별로 비교하기

마지막으로 변경된 판: 2026.11.10판

처음 두 질문, 곧 평균이 올랐는가와 어느 질의가 나빠졌는가는 회귀 집합에서 답한다. 회귀 집합은 판정이 붙은 고정된 질의로, 모든 변경은 배포하기 전에 이 집합에 대해 실행된다. 상점이 현재 운영하는 랭커가 기준선이고, 변경을 적용한 랭커가 후보 랭커다. 각 랭커는 집합의 모든 질의에 대한 순위인 실행을 만든다. 두 실행의 평균만 비교해서는 충분하지 않다. 변경이 평균을 올리면서도 일부 질의를 나쁘게 만들 수 있기 때문이다. 검색 시스템을 공동으로 평가하는 Text REtrieval Conference인 TREC는 2013년 Web 트랙에서 이 위험을 다루는 과제를 만들어, 기준선 대비 각 시스템의 질의별 승패를 채점했다(Collins-Thompson et al., 2014). 따라서 두 실행을 비교한다. 질의마다 한 행을 두고, 기준선의 점수, 후보의 점수, 그 변화량을 적는다. 그런 다음 승, 패, 무승부의 수를 세고 패한 질의를 읽는다.

기준선은 BM25이고 후보는 의미 기반 검색이며, 둘 다 테스트 질의에서 nDCG@10으로 채점한다. 예제는 pandas로 비교 표를 만들고, 검정은 3장에서 직접 만든 lib.significance에서 가져온다. 검정은 순열 검정과 대응 t-검정이다. 그 옆에는 임계값에 대응하는 신뢰 수준의 부트스트랩 구간을 둔다. 부트스트랩과 순열 검정은 무작위로 재표집하므로 lib.significance는 SciPy에 rng를 시드로 지정한다(3장).

diff-semantic-against-bm25.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pandas 3.1.1 · scipy 1.18.1 통과
"""Scores each test query under BM25 and semantic retrieval, then runs the chapter's one planned comparison on the difference. The verdict rests on the 'permutation test p' and 'established' lines, read against 'threshold'."""import pandas as pdfrom lib.lexical import LexicalSearchfrom lib.metrics import evaluatefrom lib.semantic import SemanticSearchfrom lib.significance import comparefrom lib.store import load_products, load_queries, qrelsPLANNED_COMPARISONS = 1                      # this chapter's tests on the test queriesthreshold = 0.05 / PLANNED_COMPARISONS       # Bonferroni: one comparison keeps 0.05products, queries, judgments = load_products(), load_queries("test"), qrels("test")baseline = evaluate(LexicalSearch(products).run(queries, k=100), judgments)      # what the store runscandidate = evaluate(SemanticSearch().run(queries, k=100), judgments)            # the changediff = pd.DataFrame({"query": queries["query"], "bm25": baseline["ndcg@10"], "semantic": candidate["ndcg@10"]})# rounded to 3 decimals, as lib.significance rounds before it counts wins, losses and tiesdiff["change"] = (diff["semantic"] - diff["bm25"]).round(3)        # one row per test queryprint(f"bm25 ndcg@10: {diff['bm25'].mean():.3f}")print(f"semantic ndcg@10: {diff['semantic'].mean():.3f}")result = compare(candidate["ndcg@10"], baseline["ndcg@10"], confidence=1 - threshold)    # chapter 3's comparisonprint(f"mean change: {result['mean difference']:.3f}")print(f"threshold: {threshold:g}")print(f"permutation test p: {result['permutation p']:.3f}")print(f"paired t-test p: {result['t-test p']:.3f}")print(f"{(1 - threshold) * 100:g}% interval: {result['ci low']:.3f} to {result['ci high']:.3f}")print("established:", "yes" if result["permutation p"] < threshold else "no")print("wins:", (diff["change"] > 0).sum())print("losses:", (diff["change"] < 0).sum())print("ties:", (diff["change"] == 0).sum())print(f"largest loss: {diff['change'].min():.3f}")print()print(diff[diff["change"] < 0].sort_values("change").round(3).to_string())
출력python diff-semantic-against-bm25.py
bm25 ndcg@10: 0.725
semantic ndcg@10: 0.830
mean change: 0.105
threshold: 0.05
permutation test p: 0.001
paired t-test p: 0.003
95% interval: 0.055 to 0.185
established: yes
wins: 21
losses: 7
ties: 2
largest loss: -0.092

                                                     query   bm25  semantic  change
query_id
292                                decorative white pillow  0.467     0.375  -0.092
293                               wood floor protector mat  0.653     0.568  -0.084
482                                   48 inch kitchen hood  1.000     0.921  -0.079
63                                        monthly calendar  1.000     0.931  -0.069
285       48" sliding single track , barn door for laundry  0.592     0.555  -0.037
72                                      fold in half table  1.000     0.965  -0.035
94                kohler whitehaven farmhouse kitchen sink  0.694     0.690  -0.004

의미 기반 검색은 평균 nDCG@10을 0.725에서 0.830로 올리며, 변화량은 0.105이다. 임계값 0.05에 대해 순열 검정은 0.001을 준다. 이 변화는 입증되었는가? yes. 대응 t-검정은 0.003를 주고, 95% 구간은 0.055 to 0.185이다.

패한 질의에서 배울 것이 있다. 의미 기반 검색은 21개 질의에서 이기고, 7개에서 지고, 2개에서 비기며, 가장 큰 손실은 -0.092이다. 패한 질의 중 둘은 인치 단위의 크기를 제시한다. 48 inch kitchen hood와 48" sliding single track , barn door for laundry이다. 이는 두 개의 질의일 뿐, 패턴은 아니다. 6장은 숫자가 들어 있는 모든 질의에서 그 패턴을 검증한다.

작업 규칙: 어떤 것도 튜닝에 쓰지 않는, 판정이 붙은 질의의 회귀 집합을 유지하고, 모든 후보를 이 집합에서 기준선과 비교해 실행한다. 계획한 비교를 먼저 목록으로 만들고, 각 비교를 순열 p-값, t-검정, 구간과 함께 보고한다. 승, 패, 무승부를 세고, 배포하기 전에 패한 질의를 모두 읽는다. 패한 질의들이 공통된 패턴을 보이는 듯하면, 그에 따라 행동하기 전에 훈련 질의에서 먼저 확인한다. 그런 다음 그 유형의 질의를 고치거나 기준선으로 보낸다.

URisk로 이득보다 손실에 더 큰 가중치를 둔다

마지막으로 변경된 판: 2026.11.8판

질의별 차이는 손실을 세지만, 평균 변화량은 여전히 0.1 나빠진 질의와 0.1 좋아진 질의가 서로 상쇄된다고 본다. 상점은 그렇게 보지 않을 수 있다. 어제 상품을 찾았던 구매자가 오늘은 찾지 못한다면 회귀를 겪은 것이고, 다른 곳에서 순위가 조금 나아졌다고 해서 그 손해가 보상되지는 않는다. 위험 민감 평가는 손실을 이득보다 더 무겁게 센다.

TREC 2013 Web track의 위험 민감 척도가 URisk이다. 각 질의 q에 대해 Δ(q)를 후보의 점수에서 기준선의 점수를 뺀 값이라고 하자. 개선된 질의의 이득을 모두 더하고, 나빠진 질의의 손실은 α + 1배로 세어 뺀 다음, 질의 수 N으로 나눈다.

URisk = (1 / N) × [ sum of Δ(q) over improved queries  −  (α + 1) × sum of |Δ(q)| over hurt queries ]

이 트랙은 이를 "손실에 성공보다 α + 1배의 가중치를 두는 것"이라고 설명하며, α = 0이면 단순 평균 변화량이 된다(Collins-Thompson et al., 4.3절). 트랙 개요는 손실 항에 Δ(q) 자체를 쓰는데, 이 값은 나빠진 질의에서 음수이다. 여기서는 그 크기인 |Δ(q)|를 쓴다. α = 0일 때 개요가 말하는 대로 평균이 되는 해석은 이것뿐이다. α는 사실이 아니라 선택이다. 여기서는 α = 1을 쓰며, 따라서 각 손실은 두 배로 센다.

BM25를 기준으로 두 후보를 비교한다. 첫째는 Snowflake/snowflake-arctic-embed-m-v1.5의 임베딩을 768개 수치 모두 사용하는 전체 의미 기반 검색이다. 둘째는 앞의 128개 수치만 남겨 메모리를 6분의 1로 줄인 것이다. 이는 모델 카드가 문서화한 256차원보다 작으며, 6장에서는 학습 질의에서의 결과를 근거로 128을 기각했다. 그럼에도 이를 쓰는 이유는 테스트 질의에서 일부 질의의 이득을 다른 질의의 손실과 맞바꾸기 때문이고, 이것이 URisk가 필요한 상황이다. 테스트에서의 동작을 보고 고른 것이므로 계획된 비교가 아니라 탐색적 비교이다. URisk는 몇 줄이면 계산할 수 있다. 두 후보에 대해 실행해 보자.

urisk-of-two-candidates.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pandas 3.1.1 · scipy 1.18.1 통과
"""URisk for full semantic retrieval and for the 128-number version, each against BM25, with every loss counted alpha + 1 times. The prose's point rests on the 'semantic 128 urisk with alpha 1' line, read against its mean change."""from lib.lexical import LexicalSearchfrom lib.metrics import evaluatefrom lib.semantic import SemanticSearchfrom lib.significance import comparefrom lib.store import load_products, load_queries, qrelsALPHA = 1                                   # each loss counts alpha + 1 times: here, doubledef urisk(change, alpha):    """Mean change per query, with every loss counted alpha + 1 times (TREC 2013 Web track)."""    # gains are the positive changes; losses are the negative ones, made positive    wins, losses = change.clip(lower=0).sum(), -change.clip(upper=0).sum()    return (wins - (alpha + 1) * losses) / len(change)products, queries, judgments = load_products(), load_queries("test"), qrels("test")baseline = evaluate(LexicalSearch(products).run(queries, k=100), judgments)candidates = {"semantic": SemanticSearch(), "semantic 128": SemanticSearch(dims=128)}   # all 768 numbers, or the first 128print(f"bm25 judged@10: {baseline['judged@10'].mean():.3f}")evaluated = {name: evaluate(search.run(queries, k=100), judgments) for name, search in candidates.items()}for name, scores in evaluated.items():    # rounded to 3 decimals, so the wins and losses count the printed changes    change = (scores["ndcg@10"] - baseline["ndcg@10"]).round(3)    print(f"{name} judged@10: {scores['judged@10'].mean():.3f}")    print(f"{name} mean change: {change.mean():.3f}")    print(f"{name} wins: {(change > 0).sum()}")    print(f"{name} losses: {(change < 0).sum()}")    print(f"{name} largest loss: {change.min():.3f}")    print(f"{name} urisk with alpha {ALPHA}: {urisk(change, ALPHA):.3f}")# a demonstration, chosen for how it behaves on test: its tests describe it, and it is never establishedresult = compare(evaluated["semantic 128"]["ndcg@10"], baseline["ndcg@10"], confidence=0.95)print(f"semantic 128 permutation test p: {result['permutation p']:.3f}")print(f"semantic 128 paired t-test p: {result['t-test p']:.3f}")print(f"semantic 128 interval: {result['ci low']:.3f} to {result['ci high']:.3f}")
출력python urisk-of-two-candidates.py
bm25 judged@10: 0.927
semantic judged@10: 0.990
semantic mean change: 0.105
semantic wins: 21
semantic losses: 7
semantic largest loss: -0.092
semantic urisk with alpha 1: 0.092
semantic 128 judged@10: 0.920
semantic 128 mean change: 0.017
semantic 128 wins: 15
semantic 128 losses: 13
semantic 128 largest loss: -0.253
semantic 128 urisk with alpha 1: -0.033
semantic 128 permutation test p: 0.592
semantic 128 paired t-test p: 0.597
semantic 128 interval: -0.036 to 0.088

전체 의미 기반 검색의 평균 변화량은 0.105이고 URisk는 0.092이다. 손실 7개는 작고 가장 큰 손실이 -0.092이므로, 이를 두 배로 세어도 비용이 적다.

더 저렴한 랭커의 평균 변화량은 0.017이지만, 손실을 두 배로 세면 URisk는 -0.033이다. 이 랭커는 15개 질의에서 이기고 13개에서 지며, 가장 큰 손실은 -0.253이다. 평균은 이 맞바꿈을 가린다. 일부 질의에서는 결과가 나아지지만, 그 대가로 다른 질의에서는 결과가 나빠진다.

순열 검정은 0.592, 대응 t-검정은 0.597을 주며, 95% 구간은 -0.036 to 0.088에 걸친다.

이 랭커의 손실 일부는 아무도 판정하지 않은 상품일 수 있다. judged@10이 0.920이고, BM25는 0.927, 전체 의미 기반 검색은 0.990이기 때문이다. 다음 절에서 이를 확인한다.

URisk는 위험을 기술할 뿐 검정하지는 않는다. Dinçer et al.은 관련 척도인 TRisk를 정의하는데, 이는 "t 통계량의 선형 변환"이므로 대응 t-검정처럼 검정할 수 있다(Dinçer et al., 2014).

작업 규칙: 모든 후보에 대해 평균 변화량과 함께 α = 1인 URisk를 보고한다. URisk가 음수인 후보는 평균이 어떻든 출시하지 말고, 손실을 읽어 원인을 찾는다. 실패의 비용이 클 때는 α를 높이고, 상점에서 가장 자주 들어오는 질의에 대해서는 URisk를 따로 보고한다. 한 질의의 손실이 다른 질의의 같은 크기 이득보다 나쁘지 않을 때만 α = 0을 쓴다.

새 랭커가 드러내는 상품을 판정하라

마지막으로 변경된 판: 2026.11.10판

URisk 예제에서 더 저렴한 랭커가 보인 손실처럼, 새 랭커의 손실은 판정의 빈틈에서 비롯되었을 수 있다. 판정이 이전 시스템들이 찾아낸 상품만 다루기 때문이다. 이 상점의 판정 출처인 WANDS는 이전 시스템들이 찾아낸 상품만 판정했다(2장). 이전 시스템과 다른 랭커는 아무도 판정하지 않은 상품을 드러내고, 지표는 그런 상품에 각각 등급 0을 준다. 따라서 그 점수는 너무 낮을 수도 있고 정확할 수도 있다. 누군가 판정하기 전에는 어느 쪽인지 알 수 없다. WANDS 저자들은 이런 빈틈이 평가를 약하게 만든다고 경고한다. "incompleteness in Product Search dataset does negatively impact the discriminative power of the evaluation"(Chen et al., 2022).

2장은 judged@10으로 판정되지 않은 상품의 수를 센다. 변경을 시험할 때는 한 단계를 더 두는 것이 도움이 된다. 민감도 점검이다. 이 점검은 양쪽을 각각 유리하게 하는 두 시나리오에서 두 실행을 다시 채점한다. 한 시나리오에서는 기준선의 상위 10개에 있는 판정되지 않은 상품이 모두 정확(exact)이고, 다른 시나리오에서는 후보의 상위 10개에 있는 판정되지 않은 상품이 모두 정확이다. 각 시나리오에서 두 실행은 같은 판정으로 채점된다. nDCG의 이상적 순위는 해당 질의에 대한 모든 판정으로 만들어지기 때문이다. 정확으로 판정된 상품은 이상적 순위를 높이고, 그 상품을 보여 주지 않는 모든 실행의 점수를 낮춘다. 실제 판정은 두 시나리오를 섞은 형태일 수 있으므로, 이 시나리오들이 한계(bound)는 아니다. 두 시나리오 사이에서 선두가 바뀌면 판정만으로는 아직 결론을 낼 수 없다.

URisk 예제의 더 저렴한 시맨틱 검색은 각 임베딩의 768개 숫자 중 128개만 유지하며, 상점의 테스트 질의 중 13개에서 BM25에 졌다. 이 손실에서 무언가를 읽어 내기 전에 점검을 실행한다.

unjudged-score-range.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pandas 3.1.1 · scipy 1.18.1 통과
"""Mean nDCG@10 for BM25, the cheaper ranker and full semantic retrieval, when each run's unjudged top-10 products are judged exact in turn. The prose's point rests on the 'leader changes' line for semantic 128 against BM25, read against the scores printed before it."""import numpy as npfrom lib.lexical import LexicalSearchfrom lib.metrics import ndcg_at_kfrom lib.semantic import SemanticSearchfrom lib.store import load_products, load_queries, qrelsproducts, queries, judgments = load_products(), load_queries("test"), qrels("test")runs = {"bm25": LexicalSearch(products).run(queries, k=100),        "semantic 128": SemanticSearch(dims=128).run(queries, k=100),        "semantic": SemanticSearch().run(queries, k=100)}def unjudged(run):    """(query_id, product_id) pairs in a run's top 10 that nobody judged."""    return {(query_id, product_id) for query_id in judgments for product_id in run[query_id][:10]            if product_id not in judgments[query_id]}def score(run, exact=()):    """Mean nDCG@10 with the given unjudged pairs judged exact, for every run alike: the ideal moves too."""    # a copy of the judgments, so each scenario changes only its own exact pairs    scenario = {query_id: dict(grades) for query_id, grades in judgments.items()}    # grade 2 is exact, the top grade    for query_id, product_id in exact:        scenario[query_id][product_id] = 2    return np.mean([ndcg_at_k(run[query_id], scenario[query_id], 10) for query_id in scenario])for name in ["bm25", "semantic 128"]:    print(f"unjudged pairs in the top 10, {name}: {len(unjudged(runs[name]))}")# the empty set is the judgments as they arescenarios = {"as judged": set(), **{f"{name}'s unjudged exact": unjudged(runs[name]) for name in runs}}scores = {(scenario, name): score(run, exact) for scenario, exact in scenarios.items() for name, run in runs.items()}for scenario, name in [("as judged", "bm25"), ("as judged", "semantic 128"), ("bm25's unjudged exact", "bm25"),                       ("bm25's unjudged exact", "semantic 128"), ("bm25's unjudged exact", "semantic"),                       ("semantic 128's unjudged exact", "bm25"), ("semantic 128's unjudged exact", "semantic 128")]:    print(f"{scenario}, {name}: {scores[scenario, name]:.3f}")for candidate in ["semantic 128", "semantic"]:    # a set holding both True and False means the leader changes between scenarios    leaders = {scores[s, candidate] > scores[s, "bm25"] for s in scenarios}    print(f"leader changes, {candidate} against bm25:", "yes" if len(leaders) > 1 else "no")# | is the union: pairs either run shows, each counted onceprint("pairs to judge, semantic 128 against bm25:", len(unjudged(runs["bm25"]) | unjudged(runs["semantic 128"])))
출력python unjudged-score-range.py
unjudged pairs in the top 10, bm25: 22
unjudged pairs in the top 10, semantic 128: 24
as judged, bm25: 0.725
as judged, semantic 128: 0.742
bm25's unjudged exact, bm25: 0.788
bm25's unjudged exact, semantic 128: 0.738
bm25's unjudged exact, semantic: 0.829
semantic 128's unjudged exact, bm25: 0.718
semantic 128's unjudged exact, semantic 128: 0.807
leader changes, semantic 128 against bm25: yes
leader changes, semantic against bm25: no
pairs to judge, semantic 128 against bm25: 46

선두가 바뀌는가? yes. 따라서 판정만으로는 아직 비교를 확정할 수 없다. 판정된 그대로 보면 더 저렴한 랭커가 0.742 대 0.725로 앞선다.

BM25의 판정되지 않은 상품이 정확이라면 BM25가 0.788 대 0.738으로 앞선다. 더 저렴한 랭커의 상품이 정확이라면 그 랭커가 0.807 대 0.718로 앞선다.

BM25의 상위 10개에는 판정되지 않은 쌍이 22개 있고, 더 저렴한 랭커의 상위 10개에는 24개 있다. 비교는 46개의 판정을 기다린다. 잘못된 랭커를 배포하는 비용에 비하면 작은 비용이다.

판정자가 무엇이라고 할지 추측하지 마라. 오래된 TREC 컬렉션에서 Voorhees 등은 신경망 실행과 BM25 실행에서 문서의 새 풀을 판정했고, 새 문서 대부분이 관련 없음을 확인했다(Voorhees et al., 2022). 그러나 그 컬렉션은 많은 시스템에서 깊게 풀링되었고, WANDS는 다르게 만들어졌다. 사람의 판정이 기준이다. 대규모 언어 모델(LLM)의 판정은 더 저렴하다. 4장은 진단용으로 이 상점의 판정되지 않은 쌍을 LLM 판정으로 채우고, 채워진 등급이 판정 결과나 두 랭커의 순서를 바꿀 때마다 사람이 그 쌍을 판정하게 한다. Thomas 등은 변경을 시험할 때 중요한 위험을 제기한다. LLM이 만든 레이블은 LLM을 직접 쓰는 랭커에 유리할 수 있다(Thomas et al., 2024).

작업 규칙: 모든 후보에 대해 두 실행의 judged@10을 계산하고 두 시나리오에서 다시 채점한다. 선두가 바뀌면 비교하기 전에 판정되지 않은 쌍을 판정하고, 새 판정을 회귀 집합에 영구히 추가해서 시험한 모든 랭커가 만든 결과를 포괄하게 한다. 두 시나리오 모두에서 선두가 유지되면 판정되지 않은 상품이 비교를 뒤집을 가능성은 낮다.

테스트 쿼리를 모든 선택에서 제외하라

마지막으로 변경된 판: 2026.11.8판

회귀 테스트 집합의 테스트 쿼리는 따로 떼어 둔 것이며, 따로 떼어 둔 쿼리가 정직한 점수를 주려면 그 쿼리를 보고 고른 것이 하나도 없어야 한다. 테스트 쿼리로 학습하는 것은 누구나 알아보는 실수다. 그 쿼리로 선택하는 것은 알아채기 어려운 실수다. 여러 설정을 시도해 그중 테스트 쿼리에서 가장 높은 점수를 얻은 설정을 고르고, 그 점수를 보고하는 방식이다. 이렇게 고른 승자는 일부는 실제로 가장 좋은 설정이고 일부는 그 특정 쿼리에서 운이 가장 좋았던 설정이므로, 점수가 지나치게 높다. Dwork 등은 이 위험을 다음과 같이 서술한다. "홀드아웃 집합을 적응적으로 여러 번 재사용하면 홀드아웃 집합 자체에 과적합되기 쉽다." (Dwork et al., 2015) 피해는 우려한 것보다 작을 수 있다. ImageNet의 테스트 집합을 다시 만들었을 때 분류기의 정확도는 떨어졌지만, Recht 등의 결과는 적응성이 그 하락의 원인이 아님을 시사한다. 새 이미지가 더 어려웠던 것이다(Recht et al., 2019). 우리의 판단으로는 쿼리가 30개인 집합은 여유가 거의 없으며, 들여다보는 것 하나하나가 모두 따져야 할 대상이다.

이번 변경은 BM25와 의미 기반 검색을 하나의 가중치로 섞는 것이며, 이 가중치는 의미 기반 검색에 주는 비중이다. 7장은 이 가중치를 α라 부르는데, URisk의 α와는 다른 α다. 7장은 가중 역순위 결합(weighted reciprocal rank fusion)으로 train 쿼리에서 α를 0, 0.1, … 1 값에 걸쳐 조정한다. 의미 가중치를 두 방식으로 고르자. 올바른 방식은 train 쿼리에서 고르는 것이고, 잘못된 방식은 테스트 쿼리에서 고르는 것이다. 그리고 각 선택을 테스트 쿼리에서 보고한다. 이 테스트 점수는 편향을 보여 주는 것이며, 계획된 비교가 아니라 탐색적인 결과다. 그다음 테스트 쿼리를 다시 건드리지 않고, 보고하는 쿼리에서 선택하는 것이 그 점수를 얼마나 부풀리는지 측정한다. train 쿼리를 무작위로 1,000번 나누어, 30개는 선택에 쓰고 20개는 보고에 쓴다. 가중치를 30개에서 골랐을 때와 보고 대상인 20개 자체에서 골랐을 때, 그 20개 쿼리의 점수를 비교한다.

tuning-on-test-inflates.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pandas 3.1.1 · scipy 1.18.1 통과
"""Chooses the blend's semantic weight on train queries and on test queries, then measures how much choosing on the queries you report inflates their score. The prose's point rests on the 'average inflation' line, read against the two 'test ndcg@10' lines."""import numpy as npfrom lib.blend import best_alpha, scores_by_alpha, weighted_rrffrom lib.lexical import LexicalSearchfrom lib.semantic import SemanticSearchfrom lib.store import load_products, load_queries, qrelsqueries, judgments = load_queries(), qrels()                  # all 80 queries, train and testbm25 = LexicalSearch(load_products()).run(queries, k=100)semantic = SemanticSearch().run(queries, k=100)per_query = scores_by_alpha(lambda weight: weighted_rrf(bm25, semantic, weight), judgments)   # nDCG@10, a column per weighttrain = per_query.loc[load_queries("train").index]test = per_query.loc[load_queries("test").index]# best_alpha breaks ties toward the smaller weightchosen_on_train, chosen_on_test = best_alpha(train), best_alpha(test)print("settings tried:", per_query.shape[1])print(f"semantic alone, test ndcg@10: {test[1.0].mean():.3f}")print("semantic weight chosen on train:", chosen_on_train)print(f"test ndcg@10, weight chosen on train: {test[chosen_on_train].mean():.3f}")print("semantic weight chosen on test:", chosen_on_test)print(f"test ndcg@10, weight chosen on test: {test[chosen_on_test].mean():.3f}")# How much does choosing on the queries you report inflate the score? Split the train queries# at random, 30 to choose on and 20 to report on, and compare the two ways of choosing.# a fixed seed, so the random splits are the same on every runrng = np.random.default_rng(2026)scores = train.to_numpy()inflation = []for _ in range(1000):    order = rng.permutation(len(scores))    # the first 30 of the shuffled queries choose the weight; the other 20 report it    choose, report = scores[order[:30]].mean(axis=0), scores[order[30:]].mean(axis=0)    # argmax takes the first of equal means, the smaller weight, as best_alpha does    inflation.append(report.max() - report[choose.argmax()])print(f"average inflation, 20 reported queries: {np.mean(inflation):.3f}")
출력python tuning-on-test-inflates.py
settings tried: 11
semantic alone, test ndcg@10: 0.830
semantic weight chosen on train: 0.6
test ndcg@10, weight chosen on train: 0.825
semantic weight chosen on test: 0.8
test ndcg@10, weight chosen on test: 0.835
average inflation, 20 reported queries: 0.007

테스트 쿼리에서 가중치를 고르면 혼합 방식이 실제보다 좋아 보인다. 그곳에서 고르면 의미 가중치는 0.8이고, 혼합 방식의 점수는 0.835이다.

train에서 고르면 가중치는 0.6이고, 혼합 방식은 테스트 쿼리에서 0.825을 얻는다. 의미 기반 검색 단독은 0.830이다. 이렇게 train에서 고른 점수만이, 선택에 쓰이지 않은 쿼리에서 혼합 방식이 어떤 성능을 내는지를 공정하게 추정한다. 7장은 train에서 고른 혼합 방식을 의미 기반 검색과 비교 시험하며, 개선이 없음을 확인한다.

무작위 분할은 이 편향을 수치로 보여 준다. 쿼리 20개짜리 보고 집합에서, 보고하는 쿼리로 선택하면 nDCG@10이 평균 0.007만큼 늘어나며, 고를 수 있는 설정은 11개다. 이 상승은 보고서에만 나타나고 다른 곳에서는 나타나지 않는다. 설정을 하나 더 시도할 때마다 운 좋은 승자가 나올 기회가 한 번 더 생긴다.

작업 규칙: 어느 후보를 다음 단계로 가져갈지를 포함해 모든 설정을 train 쿼리에서 고른다. 테스트 쿼리는 결정 하나당 한 번만 보고, 볼 때마다 무엇을 비교했고 무엇을 골랐는지 기록한다. 테스트 집합이 이미 많은 결정을 이끌었다면 그 집합을 train 쪽으로 옮기고, 새로운 테스트 쿼리 집합으로 평가한다.

A/B 테스트 실행하기

마지막으로 변경된 판: 2026.11.10판

오프라인 테스트는 판단 기준에 비추어 순위를 측정하지만, 상점은 쇼핑객에게서 수익을 얻는다. A/B 테스트, 즉 통제 실험은 사용자를 무작위로 현재 시스템 또는 변경된 시스템에 배정하고, 테스트가 시작되기 전에 정한 지표를 비교한다(Kohavi et al., 2009). 현재 시스템은 대조군(control)이고, 변경된 시스템은 실험군(treatment)이다.

세 가지 점검이 결과를 신뢰할 수 있게 만든다. 첫째, 두 집단이 같은 시스템을 쓰는 A/A 테스트는 95% 신뢰 수준에서 귀무가설을 약 5%의 확률로 기각해야 한다(Kohavi et al., 2009). 5%를 크게 넘으면 설정이 잘못되었다는 뜻이다. 둘째, 계획한 크기에서 결과를 한 번만 읽는다. 유의해 보이는 순간 테스트를 멈추는 것, 곧 엿보기(peeking)는, 이는 제1종 오류율을 상당히 부풀린다(Kohavi et al., 2022). 셋째, 집단이 계획한 크기대로 구성되었는지 확인한다. 표본 비율 불일치(sample ratio mismatch, SRM)는 한 집단에서 사용자가 누락되었거나 한쪽에 고르지 않게 추가되었음을 뜻하며, "근본 원인을 모른 채 SRM을 무시하면 나쁜 제품 변경이 좋은 것처럼 보일 수 있다"(Fabijan et al., 2019).

전환 지표, 즉 구매하는 쇼핑객의 비율에 대해서는 테스트가 두 비율을 비교한다. 각 집단의 쇼핑객이 n명이고 비율이 p_A와 p_B이며 p̄가 둘의 평균일 때 다음과 같다.

z = (p_B − p_A) / sqrt( p̄ × (1 − p̄) × 2 / n ),   p-value = 2 × P(Z > |z|)

엿보기가 어떤 영향을 주는지 보기 위해, 다음 가정 아래 A/A 테스트 2,000회를 시뮬레이션한다. 각 집단에 하루 2,000명의 쇼핑객이 있고, 5%가 구매하며, 각 테스트는 14일로 계획한다. 각 테스트를 계획된 종료일에 한 번 읽고, 매일 읽으면서 p-값이 처음으로 0.05 아래로 내려가는 시점에 멈추는 경우도 본다. 그런 다음 분할 하나에서 불일치를 확인한다.

aa-tests-with-peeking.py Python 3.12.15 · numpy 2.5.5 · scipy 1.18.1 통과
"""Simulates A/A tests, where both groups get the same search, read at the planned end and every day, and checks one split for a mismatch. The prose's point rests on the 'significant at the planned end' and 'significant on some day' lines, and on the sample ratio mismatch line."""import numpy as npfrom scipy import stats# Assumptions for the simulation, not the store's data: 2,000 shoppers a day in each group,# 5% of them buy, and the test is planned to run 14 days. Both groups get the same search (an A/A test).TESTS, DAYS, SHOPPERS_PER_DAY, CONVERSION = 2000, 14, 2000, 0.05# a fixed seed, so the simulated tests are the same on every runrng = np.random.default_rng(2026)buyers = rng.binomial(SHOPPERS_PER_DAY, CONVERSION, size=(TESTS, DAYS, 2)).cumsum(axis=1)   # running totalsshoppers = SHOPPERS_PER_DAY * np.arange(1, DAYS + 1)[None, :]                               # per group, by dayrate_a, rate_b = buyers[..., 0] / shoppers, buyers[..., 1] / shopperspooled = (rate_a + rate_b) / 2# two-proportion z for each day, using the pooled rate of the two groupsz = (rate_b - rate_a) / np.sqrt(pooled * (1 - pooled) * 2 / shoppers)# two-sided: a gap in either direction countsp_value = 2 * stats.norm.sf(np.abs(z))print(f"simulated A/A tests: {TESTS:,}")# the last day is the planned end, day 14print(f"significant at the planned end: {(p_value[:, -1] < 0.05).mean():.3f}")print(f"significant on some day, checked daily: {(p_value < 0.05).any(axis=1).mean():.3f}")# A sample ratio mismatch: the split was planned 50/50, but the groups came out unequal.control, treatment = 28_000, 27_100# the default expected share is one half, as in a 50/50 splitp = stats.binomtest(treatment, control + treatment).pvalueprint(f"sample ratio mismatch p: {p:.3f}" if p >= 0.001 else "sample ratio mismatch p: below 0.001")
출력python aa-tests-with-peeking.py
simulated A/A tests: 2,000
significant at the planned end: 0.053
significant on some day, checked daily: 0.231
sample ratio mismatch p: below 0.001

매일 확인하면 훨씬 많은 A/A 테스트가 유의해 보인다. 계획된 종료일에 읽으면 유의하게 나오는 비율은 0.053로, 임곗값이 약속하는 0.05에 가깝다. 매일 확인하면 어느 날엔가 유의해 보이는 비율은 0.231로 올라가는데, 어느 집단의 검색도 바뀌지 않았는데도 그렇다. 50/50으로 계획한 분할이 28,000 대 27,100으로 나온 경우, 쇼핑객 55,100명 중 27,100명에 대해 이항 검정으로 절반과 비교하면 p-값은 below 0.001이다. 우연이 그 정도 차이를 만드는 일은 거의 없다.

p-값은 흔히 잘못 해석된다. 0.05는 결과가 거짓 양성일 확률이 5%라는 뜻이 아니며, Kohavi et al. (2022)은 이를 "매우 흔한 오해"라고 부른다. p-값은 변경이 아무 효과도 없을 때 적어도 이만큼 극단적인 데이터가 나올 확률이다.

작업 규칙: 테스트 전에 주요 지표와 나빠져서는 안 되는 가드레일 지표를 정하고, 테스트의 크기를 정한다(검정력 포함). 먼저 같은 설정에서 A/A 테스트를 실행한다. 어떤 결과든 읽기 전에 표본 비율을 확인하고, 계획한 크기에서 결과를 한 번만 읽는다. 테스트가 진행되는 동안 지켜봐야 한다면, 항상 유효한 p-값 같은, 지속적인 모니터링을 위해 만들어진 순차적 방법을 사용한다(Johari et al., 2015).

검정력으로 테스트 규모 정하기

마지막으로 변경된 판: 2026.11.8판

A/B 테스트를 계획한 규모로 한 번만 읽으려면, 먼저 그 규모를 계획해야 하며, 이는 테스트의 검정력(power), 곧 주어진 크기의 실제 변화를 탐지할 확률에서 출발한다. 검정력이 낮은 테스트는 실제 변화를 놓치며, 유의하게 나오더라도 효과를 과장하는 경향이 있다. "검정력이 낮은 상태에서 통계적으로 유의한 결과는 효과의 크기를 크게 과장할 가능성이 높다"(Kohavi et al., 2022). 따라서 테스트를 시작하기 전에 두 가지 수치로 규모를 정한다. 하나는 지표가 사용자 사이에서 얼마나 변동하는가이고, 다른 하나는 탐지할 가치가 있는 가장 작은 변화이다. 분산이 클수록 더 많은 사용자가 필요하다. 변화가 작을수록 훨씬 더 많이 필요한데, 변화가 제곱으로 들어가기 때문이다.

두 그룹, 95% 신뢰도, 80% 검정력일 때 Kohavi et al.은 다음과 같은 경험칙을 제시한다. σ²는 지표의 분산이고 Δ는 탐지할 변화이다(Kohavi et al., 2009).

users per group ≈ 16 × σ² / Δ²

16은 정규분포에서 나온다. 2 × (97.5%에 해당하는 z + 80%에 해당하는 z)²이며, 대략 2 × (1.96 + 0.84)²이다. 검정력 90%에서는 16을 21로 바꾼다. SciPy가 이 계수를 계산하고, 코드는 이들이 제시한 두 가지 풀이 예제로 이 규칙을 검증한다. 하나는 평균 3.75달러, 표준편차 30달러인 사용자당 매출이고, 다른 하나는 5%의 전환율이며, 둘 다 5%의 상대적 변화를 탐지하는 경우이다. 스토어의 데이터는 WANDS에서 가져온 것이어서 판매 수치가 없으므로, 코드는 스토어의 전환율도 5%라고 가정한다.

sample-size-from-power.py Python 3.12.15 · scipy 1.18.1 통과
"""Kohavi et al.'s rule of thumb for users per group, its coefficient, and the users the store would need for smaller changes, assuming its 5% conversion rate. The prose's point rests on the two 'users per group for a change' lines, read against the coefficient line."""from scipy import statsSIGNIFICANCE, POWER = 0.05, 0.80z = stats.norm.ppf(1 - SIGNIFICANCE / 2) + stats.norm.ppf(POWER)    # 1.96 + 0.84print(f"coefficient for two groups: {2 * z ** 2:.1f}")                # rounds to the 16 of the rule of thumbdef users_per_group(variance, change):    """Kohavi et al.'s rule of thumb: about 16 * variance / change**2 users in each group."""    return 16 * variance / change ** 2# Their worked examples: revenue per user (mean $3.75, standard deviation $30), and a 5% conversion rate,# each with a 5% relative change to detect.print(f"users per group, revenue: {users_per_group(30 ** 2, 0.05 * 3.75):,.0f}")# a conversion rate's variance is p times (1 - p), here with p = 5%; the change is 5% of that rateprint(f"users per group, conversion: {users_per_group(0.05 * 0.95, 0.05 * 0.05):,.0f}")# The store, assuming a 5% conversion rate like theirs: smaller changes need far more users.for relative in [0.02, 0.01]:    # the change in conversion, as an absolute rate: a relative change of this size in the 5% rate    print(f"users per group for a {relative:.0%} change: {users_per_group(0.05 * 0.95, 0.05 * relative):,.0f}")
출력python sample-size-from-power.py
coefficient for two groups: 15.7
users per group, revenue: 409,600
users per group, conversion: 121,600
users per group for a 2% change: 760,000
users per group for a 1% change: 3,040,000

변화를 절반으로 줄이면 필요한 사용자는 네 배가 된다. 스토어의 가정된 전환율 5%에서 2% 변화에는 그룹당 760,000명이 필요하고, 1% 변화에는 3,040,000명이 필요하다.

계수는 15.7이고, 매출 예제와 전환 예제는 그룹당 각각 409,600명과 121,600명이 필요하다. 이는 논문이 제시한 409,000명 초과와 122,000명 미만이라는 수치와 일치한다.

같은 계산으로 회귀 세트가 탐지할 수 있는 변화도 알 수 있다. 두 랭커가 같은 쿼리를 채점하므로, 테스트는 두 그룹이 아니라 쿼리별 차이의 한 표본을 다루며, 계수는 절반인 7.8가 된다. σ는 가까운 두 랭커, 곧 시맨틱 검색과 이를 BM25와 융합한 하이브리드 실행 사이에서 나타나는 그 차이들의 퍼짐으로 잡는다.

queries-needed-for-power.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pandas 3.1.1 · scipy 1.18.1 통과
"""The smallest change the regression set detects with 80% power, from the spread of per-query changes, and a simulation that checks the power formula. The prose's point rests on the 'smallest change 30 queries detect' line and the simulated power lines."""import numpy as npfrom scipy import statsfrom lib.fusion import reciprocal_rank_fusionfrom lib.lexical import LexicalSearchfrom lib.metrics import evaluatefrom lib.semantic import SemanticSearchfrom lib.store import load_products, load_queries, qrelsSIGNIFICANCE, POWER = 0.05, 0.80queries, judgments = load_queries("test"), qrels("test")bm25 = LexicalSearch(load_products()).run(queries, k=100)semantic = SemanticSearch().run(queries, k=100)hybrid = reciprocal_rank_fusion([bm25, semantic])change = evaluate(hybrid, judgments)["ndcg@10"] - evaluate(semantic, judgments)["ndcg@10"]spread = change.std()                                     # of the per-query differencesz = stats.norm.ppf(1 - SIGNIFICANCE / 2) + stats.norm.ppf(POWER)print(f"spread of per-query changes: {spread:.3f}")print(f"coefficient for paired queries: {z ** 2:.1f}")     # one sample of differences, so half of 16# z standard errors of the mean change: the smallest change the test can detectdetectable = z * spread / np.sqrt(len(change))print(f"smallest change 30 queries detect: {detectable:.3f}")# n = z squared times spread squared, over the change squared, solved for nprint(f"queries needed for a change of 0.01: {z ** 2 * spread ** 2 / 0.01 ** 2:.0f}")# Check the arithmetic by simulation: draw 30 normally distributed changes with that mean and spread,# 10,000 times, and test each. The real differences aren't normal, so this checks the formula, not the data.rng = np.random.default_rng(2026)# ttest_1samp tests each draw against popmean 0, the no-change nullpower = stats.power(stats.ttest_1samp, lambda size: rng.normal(detectable, spread, size=size), (len(change),),                    significance=SIGNIFICANCE, kwargs={"popmean": 0})# .item() takes the single value out of the result, which holds one simulated powerprint(f"simulated power at that change: {power.power.item():.3f}")print("simulated power below the planned 0.8:", "yes" if power.power.item() < POWER else "no")
출력python queries-needed-for-power.py
spread of per-query changes: 0.062
coefficient for paired queries: 7.8
smallest change 30 queries detect: 0.032
queries needed for a change of 0.01: 300
simulated power at that change: 0.779
simulated power below the planned 0.8: yes

쿼리별 변화의 퍼짐은 0.062이므로, 테스트 쿼리가 30개일 때 회귀 세트는 nDCG@10에서 0.032의 변화를 80% 검정력으로 탐지한다. 0.01의 변화를 탐지하려면 쿼리가 300개 필요하다.

scipy.stats.power는 정규분포를 따르는 차이를 뽑는 시뮬레이션으로 이 계산을 검증한다. 그 변화에서 대응표본 t-검정의 시뮬레이션 검정력은 0.779이다. 이것이 계획한 0.8보다 낮은가? yes. 공식은 정규분포를 쓰는 반면, 테스트 쿼리에 대한 t-검정은 더 넓은 t-분포를 쓰기 때문이다. 실제 차이는 정규분포를 따르지 않으므로, 시뮬레이션이 검증하는 대상은 데이터가 아니라 공식이다. 쿼리를 추가할 때는 많이 추가하고 각각을 얕게 판정하라. Webber et al.은 같은 판정 노력이라면 얕게 판정한 많은 쿼리가 깊게 판정한 적은 쿼리보다 더 큰 통계적 검정력을 준다는 것을 발견했다(Webber et al., 2008).

작업 규칙: 모든 A/B 테스트는 시작하기 전에 규모를 정한다. 스토어가 몇 주 동안 확보하는 사용자보다 더 많은 사용자가 필요하다면, 더 큰 변화를 테스트하거나, 변동이 더 적은 지표를 쓰거나, 테스트 이전의 각 사용자 데이터로 지표를 조정한다. Deng et al.은 Bing의 실험에서 이 방법이 "분산을 약 50% 줄일 수 있다"고 보고한다(Deng et al., 2013). 얼마나 줄어드는지는 사용자의 과거 행동이 지표를 얼마나 잘 예측하는가에 달려 있다. 오프라인에서는 회귀 세트가 탐지할 수 있는 가장 작은 변화를 계산하고, 변경의 크기가 그보다 작으면 쿼리를 추가한다. 숫자는 미리 고정한다. 검정력 추정치가 충분하다고 말해 줄 때까지 쿼리를 추가하면 유의성을 찾는 쪽으로 편향된다(Webber et al.).

팀 드래프트로 두 랭킹 섞기

마지막으로 변경된 판: 2026.11.10판

A/B 테스트는 그룹마다 다른 랭킹을 보여 주므로 쇼핑객 사이의 차이가 잡음이 된다. 인터리빙(interleaving)은 각 쇼핑객에게 두 랭커의 결과를 섞은 목록 하나를 보여 준다. Joachims는 "결합된 랭킹은 두 검색 엔진에 (거의) 동등한 표시 편향을 준다"(Joachims, 2003)라고 밝히며 이 방법을 설계했다. 어느 쪽 랭커의 상품도 체계적으로 더 높은 위치에 놓이지 않는다는 뜻이다. 클릭을 더 많이 받은 상품을 낸 랭커가 그 검색에서 이긴다. 인터리빙이 답하는 질문은 A/B 테스트보다 좁다. 두 랭킹 중 사용자가 어느 쪽을 선호하는지는 알려 주지만, 어느 쪽에 대해서도 절대적인 수치는 알려 주지 않는다(Hofmann et al., 2016).

팀 드래프트(team draft)는 경기를 앞두고 팀을 뽑듯이 두 랭커의 목록을 섞는다(Radlinski et al., 2008, 알고리즘 2). 선택 횟수가 더 적은 팀이 다음 차례를 맡고, 두 팀의 횟수가 같으면 동전 던지기로 정한다. 각 팀은 아직 노출되지 않은 상품 중 순위가 가장 높은 것을 고른다. 클릭은 그 상품을 고른 팀의 몫으로 센다. Radlinski 등은 팀 드래프트에서 "무작위로 클릭하는 사용자는 기댓값 기준으로 항상 A와 B에 같은 수의 선호를 만들어 낸다"고 보였다. 이전 방법은 이를 보장하지 못했다.

테스트 질의 clear shower curtain에 대해 스토어의 시맨틱 검색과 BM25를 인터리빙한다. 팀 드래프트는 동전 던지기에 시드가 있는 난수 생성기를 쓰면 몇 줄로 구현할 수 있고, 코드는 lib.experiments가 같은 목록을 반환하는지도 확인한다.

team-draft-one-query.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pandas 3.1.1 · scipy 1.18.1 통과
"""Team draft over one query's semantic and BM25 rankings: the interleaved list, and the team that picked each place. The prose's point rests on the BM25 pick at the bottom of the list, and on the 'same list' line that checks lib.experiments."""import numpy as npfrom lib import experimentsfrom lib.lexical import LexicalSearchfrom lib.semantic import SemanticSearchfrom lib.store import load_products, load_queries, qrelsLABELS = {2: "exact", 1: "partial", 0: "irrelevant"}def team_draft(ranking_a, ranking_b, rng, length=10):    """Like picking teams: the team with fewer picks goes next, a coin flip decides when they're level,    and each team adds its best product that isn't shown yet."""    shown, teams = [], []    while len(shown) < length:        picks_a, picks_b = teams.count("a"), teams.count("b")        # the coin is drawn only when the teams are level        a_picks = picks_a < picks_b or (picks_a == picks_b and rng.random() < 0.5)        ranking, team = (ranking_a, "a") if a_picks else (ranking_b, "b")        # the team's best product that isn't shown yet, from its own ranking        shown.append(next(p for p in ranking if p not in shown))        teams.append(team)    return shown, teamsproducts, queries, judgments = load_products(), load_queries("test"), qrels("test")[246]   # clear shower curtainsemantic = list(SemanticSearch().search(246, k=100).index)bm25 = list(LexicalSearch(products).search(queries.at[246, "query"], k=100).index)shown, teams = team_draft(semantic, bm25, np.random.default_rng(7))# judgments.get returns None for a product nobody judged, and LABELS.get then gives 'unjudged'# names are cut at 45 characters to keep the columns alignedfor position, (product_id, team) in enumerate(zip(shown, teams), start=1):    name = {"a": "semantic", "b": "bm25"}[team]    print(f"{position:>2}  {name:<8}  {LABELS.get(judgments.get(product_id), 'unjudged'):<10}  {products.at[product_id, 'name'][:45]}")# lib.experiments holds the same function, which the simulations useprint("same list from lib.experiments:", "yes" if experiments.team_draft(semantic, bm25, np.random.default_rng(7)) == (shown, teams) else "no")
출력python team-draft-one-query.py
 1  bm25      partial     rodas vinyl shower curtain
 2  semantic  exact       woolley vinyl solid color single shower curta
 3  bm25      exact       woolley vinyl single shower curtain
 4  semantic  partial     newburg check 3d vinyl single shower curtain
 5  bm25      exact       siniard single shower curtain
 6  semantic  partial     71 '' x71 '' 4pcs shower curtain sets beach t
 7  semantic  exact       almazan lightweight single shower curtain
 8  bm25      exact       simmon vinyl single shower curtain liner
 9  semantic  partial     vinyl striped shower curtain set
10  bm25      irrelevant  gilded pineapple shower curtain hooks
same list from lib.experiments: yes

팀 드래프트는 열 자리 목록에서 두 랭커에게 항상 5자리씩 주며, 어느 자리가 누구 몫인지는 동전 던지기가 정한다. 두 랭커가 모두 높게 올린 상품은 한 번만 나타나고 먼저 고른 팀의 몫이 되므로, 어느 랭커도 같은 상품으로 두 번 점수를 얻지 못한다. 이 질의에서는 BM25가 순위에 올린 샤워 커튼 고리 중 하나(1장)가 BM25의 마지막 선택으로 맨 아래에 들어간다. 쇼핑객이 시맨틱 검색이 고른 상품을 클릭하면 시맨틱 검색의 몫이고, BM25가 고른 상품을 클릭하면 BM25의 몫이며, 클릭이 더 많은 팀이 그 검색에서 이긴다.

작업 규칙: 사용자가 어느 랭커를 선호하는지 알아야 할 때 A/B 테스트보다 적은 검색 횟수로 두 랭커를 온라인에서 비교하려면 팀 드래프트 인터리빙을 쓴다. 매출과 같은 절대적인 수치가 필요하거나 변경이 랭킹에 있지 않을 때는 A/B 테스트를 대신 쓴다. 우리의 추론에 따르면, 인터리빙한 목록으로는 지연 시간, 페이지 레이아웃, 결과 개수 차이의 효과를 확인할 수 없다.

시뮬레이션 쇼핑객으로 인터리빙 예행연습하기

마지막으로 변경된 판: 2026.11.8판

상점 데이터의 출처인 WANDS에는 클릭이 없으므로, 상점은 실제 쇼핑객을 대상으로 팀 드래프트 인터리빙을 실행할 수 없다. 그러나 시뮬레이션한 쇼핑객으로는 예행연습을 할 수 있다. 클릭 모델(click model)은 사용자가 결과 목록을 훑고 클릭하는 방식을 나타내는 확률 모델이며, 지표를 만들 때와 사용자를 시뮬레이션할 때 모두 쓰인다(Chuklin et al., 2015). 캐스케이드 모델(cascade model)은 사용자가 위에서부터 읽다가 "가치 있는 문서를 보자마자 떠난다"고 설명한다(Craswell et al., 2008; 2장 참조). 표준적인 시뮬레이션은 이 모델을 따른다. 질의를 균등하게 무작위로 뽑고, 그 목록을 따라 내려가며, 등급에 따라 정해지는 확률로 각 상품을 클릭하고, 클릭한 뒤에는 역시 등급에 따라 정해지는 또 다른 확률로 떠난다(Oosterhuis and de Rijke, 2018). 인터리빙 연구도 레이블이 붙은 데이터에서 클릭을 시뮬레이션하여 이런 방식으로 방법을 검증한다(Hofmann et al., 2011).

이 확률들은 가정이다. Oosterhuis와 de Rijke의 표 2는 다섯 등급에 대한 "탐색형(navigational)" 사용자, 즉 매우 관련성이 높은 결과 하나를 찾는 사용자를 제시하며, 우리는 이를 탐색형 쇼핑객이라 부른다. 관련 없음, 부분 일치, 정확 일치를 이 사용자의 가장 낮은 등급, 중간 등급, 가장 높은 등급에 대응시키고, 지표와 마찬가지로 판정되지 않은 상품은 관련 없음으로 취급하며, 모든 질의를 같은 빈도로 뽑는다. 이 값들은 한 곳, lib.experiments에 있다.

등급 클릭 클릭 후 중단
정확 일치 0.95 0.9
부분 일치 0.5 0.5
관련 없음 0.05 0.2

clear shower curtain에 대한 팀 드래프트 목록으로 이런 쇼핑객 한 명을 직접 내려보내 보자.

one-simulated-shopper.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pandas 3.1.1 · scipy 1.18.1 통과
"""One simulated navigational shopper walks the team-draft list for clear shower curtain, clicking and leaving by the cascade model. The prose's point rests on the two 'clicks for' lines and the verdict line, and on the 'same clicks' line that checks lib.experiments."""import numpy as npfrom lib.experiments import NAVIGATIONAL, cascade_clicks, team_draftfrom lib.lexical import LexicalSearchfrom lib.semantic import SemanticSearchfrom lib.store import load_products, load_queries, qrelsLABELS = {2: "exact", 1: "partial", 0: "irrelevant"}products, queries, judgments = load_products(), load_queries("test"), qrels("test")[246]   # clear shower curtainsemantic = list(SemanticSearch().search(246, k=100).index)bm25 = list(LexicalSearch(products).search(queries.at[246, "query"], k=100).index)shown, teams = team_draft(semantic, bm25, np.random.default_rng(7))       # the team-draft example's listteam_names = {"a": "semantic", "b": "bm25"}# the same seed as the check at the end, so both draw the same clicksrng = np.random.default_rng(2026)clicks = []for position, product_id in enumerate(shown):    grade = judgments.get(product_id, 0)                                  # unjudged counts as 0    # click and stop probabilities for the grade: 0 irrelevant, 1 partial, 2 exact    clicked = rng.random() < NAVIGATIONAL["click"][grade]    # the second draw happens only after a click, the order cascade_clicks uses    leaves = clicked and rng.random() < NAVIGATIONAL["stop"][grade]        # only a click can end the visit    label = LABELS.get(judgments.get(product_id), "unjudged")    print(f"{position + 1:>2}  {team_names[teams[position]]:<8}  {label:<10}  {'clicks' if clicked else '':<6}  {'leaves' if leaves else ''}")    if clicked:        clicks.append(position)    if leaves:        breakcredited = [team_names[teams[position]] for position in clicks]       # each click counts for the team that picked itfor_semantic, for_bm25 = credited.count("semantic"), credited.count("bm25")print("clicks for semantic:", for_semantic)print("clicks for bm25:", for_bm25)print("this search goes to:", "semantic" if for_semantic > for_bm25 else "bm25" if for_bm25 > for_semantic else "neither, a tie")print("same clicks from lib.experiments:", "yes" if cascade_clicks(shown, judgments, np.random.default_rng(2026)) == clicks else "no")
출력python one-simulated-shopper.py
 1  bm25      partial     clicks
 2  semantic  exact       clicks  leaves
clicks for semantic: 1
clicks for bm25: 1
this search goes to: neither, a tie
same clicks from lib.experiments: yes

이 쇼핑객의 클릭은 시맨틱 검색이 1, BM25가 1이므로, 이 검색의 판정은 neither, a tie이다. 고정된 시드로 두 쌍에 대해 인터리빙 검색 10,000회를 시뮬레이션한다. 한 쌍은 시맨틱 검색 대 BM25이고, 다른 한 쌍은 하이브리드 실행 대 시맨틱 검색이다. 부호 검정은 승리가 패배보다 우연으로 설명되는 수준을 넘어 많은지를 묻는다. Radlinski et al.은 동점을 제외하고 "이항 부호 검정"을 사용한다. 검색 100회, 1,000회, 10,000회에서 판정을 읽어 보자.

simulated-interleaving-verdict.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pandas 3.1.1 · scipy 1.18.1 통과
"""Sign tests on simulated interleaved searches, at 100, 1,000 and 10,000 searches, for two pairs of rankers and a third pair with BM25's ties reversed. The prose's point rests on the 'verdict changes' line and the 100-search lines for the hybrid against semantic retrieval."""import numpy as npfrom scipy import statsfrom lib.experiments import NAVIGATIONAL, simulate_interleavingfrom lib.fusion import reciprocal_rank_fusionfrom lib.lexical import LexicalSearchfrom lib.semantic import SemanticSearchfrom lib.store import load_products, load_queries, qrelsfor grade, label in [(2, "exact"), (1, "partial"), (0, "irrelevant")]:      # the assumptions, from lib.experiments    print(f"{label} click probability: {NAVIGATIONAL['click'][grade]}")    print(f"{label} stop probability: {NAVIGATIONAL['stop'][grade]}")# lexsort's last key sorts first: the score, highest first, then the product_id, highest first among tiesdef ties_reversed(scores):              # BM25's ranking, with equal scores in descending product_id order instead    return scores.index[np.lexsort((-scores.index.to_numpy(), -scores.to_numpy()))].tolist()queries, judgments = load_queries("test"), qrels("test")lexical = LexicalSearch(load_products())bm25 = lexical.run(queries, k=100)                                        # equal scores by product_idsemantic = SemanticSearch().run(queries, k=100)hybrid = reciprocal_rank_fusion([bm25, semantic])bm25_reversed = {q: ties_reversed(lexical.search(query, k=100)) for q, query in queries["query"].items()}pairs = {"semantic against bm25": (semantic, bm25), "hybrid against semantic": (hybrid, semantic),         "hybrid with bm25 ties reversed against semantic": (reciprocal_rank_fusion([bm25_reversed, semantic]), semantic)}below = {}for name, (run_a, run_b) in pairs.items():    # a fresh seed for each pair, so every pair sees the same 10,000 queries    outcomes = simulate_interleaving(run_a, run_b, judgments, 10_000, np.random.default_rng(2026))    for searches in [100, 1_000, 10_000]:        # the first 100, 1,000 or 10,000 of the same searches, so the three verdicts share data        wins, losses = (outcomes[:searches] == 1).sum(), (outcomes[:searches] == -1).sum()        p = stats.binomtest(wins, wins + losses).pvalue                  # sign test; ties left out        below[name, searches] = p < 0.05        shown = f"{p:.3f}" if p >= 0.001 else "below 0.001"        print(f"{name}, {searches:,} searches: {wins} wins, {losses} losses, p {shown}")changes = below["hybrid against semantic", 100] != below["hybrid with bm25 ties reversed against semantic", 100]print("hybrid against semantic, verdict at 100 searches changes with bm25 ties reversed:", "yes" if changes else "no")
출력python simulated-interleaving-verdict.py
exact click probability: 0.95
exact stop probability: 0.9
partial click probability: 0.5
partial stop probability: 0.5
irrelevant click probability: 0.05
irrelevant stop probability: 0.2
semantic against bm25, 100 searches: 51 wins, 36 losses, p 0.133
semantic against bm25, 1,000 searches: 519 wins, 347 losses, p below 0.001
semantic against bm25, 10,000 searches: 5222 wins, 3552 losses, p below 0.001
hybrid against semantic, 100 searches: 32 wins, 51 losses, p 0.048
hybrid against semantic, 1,000 searches: 413 wins, 447 losses, p 0.260
hybrid against semantic, 10,000 searches: 4180 wins, 4593 losses, p below 0.001
hybrid with bm25 ties reversed against semantic, 100 searches: 35 wins, 48 losses, p 0.187
hybrid with bm25 ties reversed against semantic, 1,000 searches: 410 wins, 463 losses, p 0.078
hybrid with bm25 ties reversed against semantic, 10,000 searches: 4174 wins, 4560 losses, p below 0.001
hybrid against semantic, verdict at 100 searches changes with bm25 ties reversed: yes

표본이 작으면 결과가 크게 흔들린다. 오프라인에서 차이가 큰 시맨틱 검색 대 BM25의 경우, 판정은 검색 100회에서 51 wins, 36 losses, p 0.133, 1,000회에서 519 wins, 347 losses, p below 0.001로 나온다. 하이브리드 대 시맨틱 검색의 경우에는 검색 100회에서 32 wins, 51 losses, p 0.048, 1,000회에서 413 wins, 447 losses, p 0.260로 나오는데, 이것이 검정을 시작하기 전에 검색 횟수를 고정해야 하는 이유이다.

검색 10,000회에서 하이브리드의 판정은 4180 wins, 4593 losses, p below 0.001로 나온다. 이것이 차이가 확립되지 않았다는 3장의 발견을 뒤집지는 않는다. 같은 30개 질의에서 시뮬레이션 클릭을 계속 늘리면 부호 검정은 클릭의 잡음만 측정하게 되므로, 어떤 고정된 차이든 유의해진다.

검색 100회에서 하이브리드의 판정은 아무 정보도 담지 않은 세부 사항에도 좌우된다. 하이브리드는 BM25를 융합하는데, lib.lexical은 BM25 점수가 같은 상품을 product_id 순으로 정렬한다. 이를 반대로 정렬해도, 즉 똑같이 임의적인 규칙을 써도, 같은 시드로 검색 100회에서 35 wins, 48 losses, p 0.187이 나온다. 0.05 기준의 판정이 바뀌는가? yes. BM25의 동점 순서를 뒤집으면 하이브리드 목록 일부가 달라지고, 그러면 시뮬레이션 쇼핑객이 다른 상품을 보게 되며, 처음으로 달라진 목록 이후의 모든 난수 추출이 바뀔 수 있다. 동점 규칙 하나로 뒤집힐 수 있는 판정은 랭커에 대한 발견이 아니라 운이다.

세 가지 한계 때문에 이것은 예행연습에 머문다. 첫째, 클릭이 nDCG@10과 같은 등급에서 나오므로 인터리빙은 nDCG@10과 일치하는 경향이 있으며, 랭커에 대한 증거를 더하지 않는다. 둘째, 모든 검색이 같은 30개 질의에서 나오므로 부호 검정은 이 질의들에 대해서만 말해 준다. 셋째, 실제 쇼핑객은 이 모델과 다르다. Deffayet 등은 클릭 로그를 만든 랭커가 바뀔 때 어떤 일이 일어나는지 연구했고, 클릭 모델이 그 변화에 민감하다는 것을 발견했다(Deffayet et al., 2023). 검색 엔진 세 곳의 실제 트래픽에서 인터리빙은 인터리빙과 전문가 판단이 모두 유의했을 때마다 전문가 판단과 일치했고, "절대 지표보다 대략 1~2자릿수 적은 데이터"가 필요했다(Chapelle et al., 2012). 우리의 추론으로는 시뮬레이션의 쇼핑객이 모두 똑같이 행동하므로 시뮬레이션은 이 이점을 보여 줄 수 없다.

작업 규칙: 인터리빙 테스트는 코드와 부호 검정을 점검하기 위해 시뮬레이션으로 예행연습한다. 시뮬레이션이 제안하는 검색 횟수는 가정한 쇼핑객만큼만 믿을 만하다고 보고, 시뮬레이션 판정에서 어떤 의미를 읽어 내기 전에 동점을 반대로 처리하여 다시 실행한다. 시뮬레이션 판정을 랭커에 대한 증거로 보고해서는 안 된다. 실제 트래픽에서는 검색 횟수를 미리 고정하고 부호 검정으로 결정한다.

오프라인과 온라인이 어긋날 때 원인 찾기

마지막으로 변경된 판: 2026.11.8판

시뮬레이션된 쇼핑객은 nDCG@10이 쓰는 것과 같은 등급에 따라 click하므로 이 지표와 일치하는 경향이 있다. 실제 쇼핑객은 꼭 그렇지는 않다. 오프라인 지표가 온라인 결과를 잘 예측하는 경우도 있다. 한 전자상거래 연구에서는 36개의 오프라인 지표 가운데 가장 좋은 지표가, 두 순위 모델 중 어느 쪽이 더 나은지에 대해 비즈니스 지표 기준으로 최대 97%까지 온라인 결과와 일치했다(Wang et al., 2023). 다른 전자상거래 팀은 오프라인 순위 지표가 "온라인 성능과 상당한 불일치를 보일 수 있으며, 심지어 오해를 낳을 수도 있다"고 보고했다(Huzhang et al., 2020). 두 연구는 모두 자체 트래픽을 대상으로 한 업계 연구이므로 외부에서는 재현할 수 없다. 두 시스템의 성능이 거의 같을 때는 지표들끼리도 서로 다른 결론을 내는 경우가 많다(Hofmann et al., 2016).

불일치에는 확인할 수 있는 원인이 있다. 온라인에서 이긴 쪽이 보여 주는 상품을 판정이 놓쳤을 수 있으며, 민감도 점검이 이를 살핀다. 변경이 순위 바깥, 즉 속도나 레이아웃에 작용했을 수도 있다. 또는 온라인 지표가 성공이 아닌 다른 것을 측정하고 있을 수도 있다. Radlinski et al. (2008)은 학술 검색 엔진에서 질의당 click 수가 다른 일곱 가지 절대적 사용 지표와 마찬가지로, 연구한 표본 크기에서는 검색 품질을 안정적으로 반영하지 못한다는 것을 발견했다.

스토어는 인터리빙 리허설의 탐색형 쇼핑객으로 A/B 테스트를 시뮬레이션할 수 있다. 대조군으로 BM25를 쓴 검색 5,000건과 처리군으로 의미 기반 검색을 쓴 검색 5,000건을 모두 테스트 질의에서 실행한다. 검색당 click 수와, 정확히 일치하는 상품을 click한 검색의 비율을 측정한다. 그런 다음 표 2의 "완벽한" 사용자인 완벽한 쇼핑객으로 같은 방식으로 대응시켜 반복한다. 이 쇼핑객은 결과 열 개를 모두 읽고, 정확히 일치하는 상품을 모두 click하며, 중간에 떠나지 않는다. 어느 랭커가 검색당 click을 더 많이 얻으리라고 예상하는가, 그리고 모든 쇼핑객이 같은 결론에 이르겠는가?

clicks-per-search-misleads.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pandas 3.1.1 · scipy 1.18.1 통과
"""Clicks per search and the share of searches with an exact click, for BM25 and semantic retrieval run as simulated A/B arms, for the navigational and the perfect shopper. The prose's point rests on the two 'reverses between shoppers' lines, read with the means and p-values printed before them."""import numpy as npfrom scipy import statsfrom lib.experiments import SHOPPERS, simulate_searchesfrom lib.lexical import LexicalSearchfrom lib.semantic import SemanticSearchfrom lib.store import load_products, load_queries, qrelsqueries, judgments = load_queries("test"), qrels("test")arms = {"bm25": LexicalSearch(load_products()).run(queries, k=100),     # control        "semantic": SemanticSearch().run(queries, k=100)}               # treatmentmetrics = {"clicks per search": "clicks", "share of searches with an exact click": "exact_click"}significant_leaders = {label: set() for label in metrics}      # rankers ahead at p below 0.05for shopper_name, shopper in SHOPPERS.items():                         # navigational, then perfect    # one seed per shopper: the two rankers draw from it in turn, bm25 first    rng = np.random.default_rng(2026)    searches = {name: simulate_searches(run, judgments, 5_000, rng, shopper) for name, run in arms.items()}    for label, column in metrics.items():        means = {name: table[column].mean() for name, table in searches.items()}        for name, mean in means.items():            print(f"{shopper_name} shopper, {name} {label}: {mean:.3f}")        # exact_click holds True and False; as floats they are 1 and 0 for the t-test        p = stats.ttest_ind(searches["semantic"][column].astype(float), searches["bm25"][column].astype(float)).pvalue        print(f"{shopper_name} shopper, {label} p: " + (f"{p:.3f}" if p >= 0.001 else "below 0.001"))        if p < 0.05:            significant_leaders[label].add(max(means, key=means.get))for label in metrics:    print(f"{label} reverses between shoppers:", "yes" if len(significant_leaders[label]) > 1 else "no")
출력python clicks-per-search-misleads.py
navigational shopper, bm25 clicks per search: 1.362
navigational shopper, semantic clicks per search: 1.269
navigational shopper, clicks per search p: below 0.001
navigational shopper, bm25 share of searches with an exact click: 0.695
navigational shopper, semantic share of searches with an exact click: 0.799
navigational shopper, share of searches with an exact click p: below 0.001
perfect shopper, bm25 clicks per search: 6.443
perfect shopper, semantic clicks per search: 7.451
perfect shopper, clicks per search p: below 0.001
perfect shopper, bm25 share of searches with an exact click: 0.898
perfect shopper, semantic share of searches with an exact click: 0.895
perfect shopper, share of searches with an exact click p: 0.646
clicks per search reverses between shoppers: yes
share of searches with an exact click reverses between shoppers: no

검색당 click 수는 쇼핑객에 따라 뒤바뀌는가? yes. 그 부호는 쇼핑객의 행동 방식에 좌우되므로, 그것만으로는 성공을 측정할 수 없다. 탐색형 쇼핑객은 BM25에서 검색당 1.362번, 의미 기반 검색에서 1.269번 click하며 p값은 below 0.001이다. 반면 완벽한 쇼핑객은 의미 기반 검색에서 7.451번, BM25에서 6.443번 click한다. 정확히 일치하는 상품을 상위에서 찾은 쇼핑객은 그것을 click하고 대개 떠나지만, 부분 일치 상품을 본 쇼핑객은 계속 찾으면서 여러 개를 click한다.

정확히 일치하는 상품을 click한 검색의 비율은 쇼핑객에 따라 뒤바뀌는가? no. 탐색형 쇼핑객에게는 의미 기반 검색이 유리하여 0.799 대 0.695이다. 완벽한 쇼핑객에게는 뚜렷한 차이가 없으며 p값은 0.646이다. 이 쇼핑객은 상위 10개에 정확히 일치하는 상품이 있을 때마다 그것을 click하므로, BM25 검색의 0.898와 의미 기반 검색의 0.895에서 정확히 일치하는 상품을 click한다.

모든 쇼핑객에게 같은 답이 나온다면 click은 품질의 척도가 될 것이다. 그러나 click이 측정하는 것은 행동이며, 행동은 제각각이다.

작업 규칙: 오프라인 결과와 온라인 결과가 어긋나면, 어느 쪽이든 믿기 전에 원인을 찾는다. 온라인 지표가 활동이 아니라 구매와 같은 성공을 측정하는지 확인한다. 온라인에서 이긴 쪽의 결과에 대해 judged@10을 확인하고, 빠진 것을 판정한다. 그런 다음 미리 정해 둔 지표의 온라인 결과를 근거로 결정하고, 다음에는 더 잘 예측하도록 회귀 세트에 질의나 판정을 추가한다.

출시 여부 결정

마지막으로 변경된 판: 2026.11.8판

출시 결정은 오프라인 점검과 온라인 점검을 결합한다. 어떤 결과도 보기 전에 점검 목록을 먼저 적어 두어야 하며, 그래야 어떤 단일 수치도 당신을 설득해 변경을 밀어붙이지 못한다. 다음 항목을 권장하며, 각 항목에는 이를 다루는 절을 함께 적는다.

  1. 회귀 세트에서 확립된 오프라인 이득. 계획된 비교 규칙에 따라 t-검정과 구간으로 보이며(질의별 차이), 가진 시스템 중 가장 강한 것을 기준으로 삼는다. Armstrong 등은 TREC 컬렉션에서 10년이 넘도록 발표된 이득을 살펴보고 "기준선은 대체로 약하며, 원래 TREC 시스템의 중앙값보다 낮은 경우가 많다"라고 밝혔다(Armstrong et al., 2009).
  2. 손실 확인, 그리고 α = 1인 URisk가 음수가 아님(URisk).
  3. 두 실행을 모두 포괄하는 판정. 어느 쪽 실행의 미판정 상품을 정답으로 간주해도 선두가 유지되어야 하며, 그렇지 않으면 새 판정이 필요하다(미판정 상품).
  4. LLM 기반 랭커의 대표 점수에 대한 사람의 등급(4장).
  5. 예산 범위 내의 지연 시간과 비용(9장).
  6. 학습 질의에서 선택한 모든 설정. 테스트 질의를 살펴본 횟수는 각각 기록한다(보류 질의).
  7. 사전에 작성한 온라인 계획. 주요 지표와 가드레일, 검정력 계산으로 정한 크기, A/A 테스트, 표본 비율 점검, 중간 확인 금지를 포함한다(A/B 테스트). 인터리빙으로 후보를 먼저 거를 수 있다(팀 드래프트).

상점의 시맨틱 검색 전환에 대해 처음 세 항목을 확인한다. 항목 1은 확립된 이득을 요구하며, 순열 검정의 답은 yes이고 평균 변화는 0.105, 95% 구간은 0.055 to 0.185이다. α = 1인 URisk를 보는 항목 2는 0.092이다.

항목 3은 두 실행을 모두 포괄하는 판정이다. BM25의 미판정 상품이 모두 정답이라면 BM25의 점수는 0.788이고 시맨틱 검색의 점수는 0.829이다. 선두가 바뀌는가? no. 온라인 항목은 트래픽을 기다린다.

작업 규칙: 모든 오프라인 항목이 통과하고, 사전에 크기를 정한 온라인 테스트에서 주요 지표가 유의하게 개선되며 악화된 가드레일이 없을 때 출시한다. 오프라인 항목이 실패하면 온라인으로 가기 전에 고친다. 온라인 테스트는 쇼핑객의 시간을 쓰기 때문이다. 온라인 테스트가 계획한 크기에서 결론을 내지 못하면 기준선을 유지한다.

실제 운영에서 생기는 문제

마지막으로 변경된 판: 2026.11.8판

상점은 시뮬레이션된 구매자 대신 실제 구매자가 오가는 라이브 트래픽에서, 단계마다 같은 회귀 테스트 세트를 사용하여 변경을 하나씩 계속 시험한다.

대시보드는 중간 확인을 부추긴다. 실험 플랫폼은 매일 결과를 보여 준다. 결과가 처음으로 유의해 보이는 시점에 실험을 멈추는 팀은 A/A 시뮬레이션이 보여 주듯이 5%를 훨씬 넘는 거짓 양성을 얻는다. 표본 크기를 미리 고정하거나 순차 방법을 사용한다.

그룹이 계획과 맞지 않는다. Fabijan et al.은 여러 회사에서 나타난 표본 비율 불일치의 원인을 모아 분류 체계로 정리했다. 어떤 결과든 읽기 전에 분할을 먼저 확인하고, 분할이 어긋난 이유를 알기 전에는 결과를 신뢰하지 않는다.

회귀 테스트 세트가 닳는다. 테스트 질의를 보고 내리는 결정은 하나하나가 질의의 독립성을 조금씩 소모한다(Dwork et al., 2015). 확인할 때마다 기록을 남기고, 기록이 길어지면 새 질의와 판정으로 테스트 세트를 갱신한다.

LLM 판정자가 관문이 된다. LLM 판정은 비용이 낮아 모든 후보에 점수를 매길 수 있다. Otero et al.은 LLM 판정에 대한 유의성 검정이 "통계적 차이에 관해 매우 높은 비율의 거짓 양성"을 보였다고 밝혔다(Otero et al., 2025). LLM 판정으로 얻은 개선을 배포하기 전에 사람의 판정으로 확인한다(4장).

동점은 결과를 움직인다. 점수가 같은 상품은 라이브러리의 선택 방식이 남기는 순서대로 반환되므로(3장), 점수를 전혀 건드리지 않는 변경도 결과를 바꿀 수 있다. BM25 동점의 순서를 뒤집으면 상점의 100회 검색 인터리빙 판정이 달라지는가? yes. 모든 랭커에서 ID로 동점을 해소하고, 임계값에 가까운 결과는 조치하기 전에 동점 순서를 뒤집어 다시 실행한다.

인터리빙은 페이지 전체를 보지 못한다. 더 느리거나 표시되는 결과 수를 바꾸는 랭커는 인터리빙 테스트에서 이기고도 구매자를 잃을 수 있다고 본다. 이런 변경에는 A/B 테스트를 실행한다.

작업 규칙: 실험 플랫폼에서 A/A 테스트, 표본 비율 점검, 고정된 테스트 크기를 자동화하고, 테스트 질의를 확인한 모든 기록을 로그로 남기며, ID로 동점을 해소하고, LLM 판정으로 얻은 개선은 사람의 판정으로 확인한다.

이 장에서 내린 결정

마지막으로 변경된 판: 2026.11.8판

각 기본값의 근거는 연결된 절에 있다.

  • 회귀 집합은 판정이 달린 30개의 테스트 질의이며, 모든 선택에는 50개의 훈련 질의를 사용한다 (보류 질의).
  • 테스트 질의에서 계획된 비교는 한 가지이며, 의미 기반 검색과 BM25의 비교다. 순열 p-값이 0.05 미만일 때만 차이가 입증된 것으로 보고, t-검정과 95% 구간을 함께 확인한다 (질의별 차이). 128차원 랭커는 탐색적 대상이며, 테스트에서의 동작을 보고 선택했다 (URisk).
  • 모든 후보에 질의별 차이를 계산하고, 손실 사례는 직접 읽는다.
  • URisk는 α = 1을 사용하므로 각 손실이 두 배로 계산된다. 이는 회귀의 비용을 어떻게 판단하느냐의 문제이며, 실패의 비용이 큰 스토어라면 이 값을 높여야 한다 (URisk).
  • 판정되지 않은 두 시나리오 사이에서 선두가 바뀌면, 비교하기 전에 판정하고 새 판정을 회귀 집합에 보관한다 (판정되지 않은 상품).
  • 테스트 질의는 결정마다 한 번만 보며, 볼 때마다 기록을 남긴다 (보류 질의).
  • A/B 테스트는 시작 전에 16σ²/Δ²로 크기를 정하고, 그 크기에서 한 번만 읽으며, 앞서 A/A 테스트와 표본 비율 검사를 수행한다 (검정력).
  • 인터리빙은 팀 드래프트와 부호 검정을 사용한다 (팀 드래프트).
  • 시뮬레이션 쇼핑객은 세 등급에 대응시킨 탐색형 캐스케이드 모델을 따르며, 질의 빈도는 균등하고, 확률은 lib.experiments에 가정으로 명시하며, 모든 시뮬레이션에는 고정된 시드를 쓴다. 이들의 판정은 방법을 연습하는 용도이며 증거로 계산하지 않는다 (연습).
  • 검색당 클릭 수는 그 자체로 성공 지표가 아니다. 구매와 같은 성공의 척도를 사용한다 (오프라인과 온라인).
  • 이 장이 보여 준 것: 보기 전에 무엇이 생각을 바꿀지 정하고, 그다음에 한 번만 본다.

이 판의 이 장

2026.11.10판예제 통과 2026년 11월 19이 장에서 11개 예제개 중 11개가 통과한다

영어판 2026.11.10판을 번역한 것이다.

이 절 인용

형식

각 형식은 이 번역이 따르는 영문 원서를 출처로 표기한다.

모든 형식은 이 판을 명시한다. 링크는 현재 판을 열며, 여기서 절의 제목은 본문이 마지막으로 바뀐 시점을 알려 준다. 접근 날짜와 검색 날짜는 이 자료를 여는 날짜다.

이 페이지의 내용

11장 중 11장: 변경 사항 테스트하기

  1. 두 실행을 질의별로 비교하기
  2. URisk로 이득보다 손실에 더 큰 가중치를 둔다
  3. 새 랭커가 드러내는 상품을 판정하라
  4. 테스트 쿼리를 모든 선택에서 제외하라
  5. A/B 테스트 실행하기
  6. 검정력으로 테스트 규모 정하기
  7. 팀 드래프트로 두 랭킹 섞기
  8. 시뮬레이션 쇼핑객으로 인터리빙 예행연습하기
  9. 오프라인과 온라인이 어긋날 때 원인 찾기
  10. 출시 여부 결정
  11. 실제 운영에서 생기는 문제
  12. 이 장에서 내린 결정

맨 위로 돌아가기전체 장