LAYA 쇼핑 검색 5 — 이 일에 LAYA 가 맞나: 사전·정규식과 나란히 재 본 결론

"""규칙 파서 — 사전(단어 → 값)과 정규식으로 검색어를 필터로 바꾼다. 모델 없이.

WORDS_V1 은 처음 기획 때 적은 단어, WORDS_V2 는 운영 로그(필터를 고친 검색어)를 보고 더한 단어다.
"""
import re

WORDS_V1 = {
    "item": {"롱패딩": "padding", "패딩": "padding", "코트": "coat", "니트": "knit", "스웨터": "knit",
             "반팔티": "tshirt", "티셔츠": "tshirt", "청바지": "jeans", "슬랙스": "slacks", "운동화": "sneakers",
             "스니커즈": "sneakers", "부츠": "boots", "백팩": "bag", "가방": "bag"},
    "category": {"아우터": "top", "상의": "top", "바지": "bottom", "하의": "bottom", "신발": "shoes"},
    "gender": {"남성": "men", "남자": "men", "여성": "women", "여자": "women"},
    "color": {"갈색": "brown", "브라운": "brown", "검정": "black", "블랙": "black", "흰색": "white", "화이트": "white",
              "회색": "gray", "그레이": "gray", "남색": "navy", "네이비": "navy", "베이지": "beige"},
    "season": {"겨울": True, "여름": False},
}
WORDS_V2 = {   # 운영 로그에서 더한 단어
    "item": {"숏패딩": "padding", "푸퍼": "padding", "니트티": "knit", "반팔": "tshirt", "긴팔티": "tshirt",
             "데님 팬츠": "jeans", "정장 바지": "slacks", "러닝화": "sneakers", "워커": "boots",
             "크로스백": "bag", "숄더백": "bag"},
    "category": {"겉옷": "top", "팬츠": "bottom", "슈즈": "shoes"},
    "gender": {"남친": "men", "남편": "men", "아빠": "men", "여친": "women", "아내": "women", "엄마": "women"},
    "color": {"초코": "brown", "검은": "black", "하얀": "white", "차콜": "gray", "곤색": "navy", "샌드": "beige"},
    "season": {"따뜻한": True, "방한": True, "시원한": False},
}
CATEGORY_OF = {"padding": "top", "coat": "top", "knit": "top", "tshirt": "top", "jeans": "bottom",
               "slacks": "bottom", "sneakers": "shoes", "boots": "shoes", "bag": "bag"}
WINTER_ITEMS = {"padding", "coat", "knit", "boots"}
PRICE_V1 = re.compile(r"(\d+)\s*만\s*원?\s*(?:이하|미만|안쪽)")
PRICE_V2 = re.compile(r"(\d+)\s*만?\s*원?\s*(?:이하|미만|안쪽|아래|까지)|~\s*(\d+)\s*만")


def merged(version):
    words = {k: dict(v) for k, v in WORDS_V1.items()}
    if version == 2:
        for k, v in WORDS_V2.items():
            words[k].update(v)
    return words


def lookup(text, table):
    """긴 단어부터 찾는다("롱패딩" 이 "패딩" 보다 먼저). 띄어쓰기는 빼고도 본다. 못 찾으면 None."""
    for word in sorted(table, key=len, reverse=True):
        if word in text or word.replace(" ", "") in text.replace(" ", ""):
            return table[word]
    return None


def focus(text):
    """v2: "검정 말고 갈색" · "갈색 바지에 어울리는 니트" — 찾는 것은 마지막 "말고"·"어울리는" 뒤에 있다."""
    for mark in ("말고", "어울리는"):
        if mark in text:
            text = text.rsplit(mark, 1)[1]
    return text


def parse(text, version=1):
    """필터 값 dict 와, 규칙이 실제로 근거를 찾은 칸의 집합을 돌려준다."""
    words = merged(version)
    found, out = set(), {}
    m = (PRICE_V2 if version == 2 else PRICE_V1).search(text)
    if m:
        n = int(m.group(1) or m.group(2)) if version == 2 else int(m.group(1))
        out["price"] = next((f"under{b}" for b in (10, 30, 50, 100) if n <= b), "none")
        found.add("price")
    for key in ("item", "gender", "color"):
        v = (lookup(focus(text), words[key]) if version == 2 and key != "gender" else None) or lookup(text, words[key])
        if v:
            out[key] = v
            found.add(key)
    category = CATEGORY_OF.get(out.get("item")) or lookup(focus(text) if version == 2 else text, words["category"])
    if category:
        out["category"] = category
        found.add("category")
    season = lookup(text, words["season"])
    if out.get("item") in WINTER_ITEMS or season is True:
        out["winter"] = True
        found.add("winter")
    elif season is False or "item" in found:
        out["winter"] = False
        found.add("winter")
    defaults = {"price": "none", "category": "none", "item": "none", "winter": False, "gender": "unknown", "color": "none"}
    return {**defaults, **out}, found

"""같은 평가 세트로 네 가지를 잰다.

rules vN        사전·정규식만(v1 = 처음 기획 때 단어, v2 = 운영 로그를 보고 더한 단어)
LAYA vN         LAYA 의 답 그대로
LAYA vN + table 품목을 알면 분류·겨울옷은 표(CATEGORY_OF·WINTER_ITEMS)로 정한다
rules + LAYA    규칙이 근거를 찾은 칸은 규칙, 못 찾은 칸은 "LAYA + table"

python compare.py checkpoints/shop-v1 checkpoints/shop-v2
"""
import json
import sys
import time

import laya
from rules import CATEGORY_OF, WINTER_ITEMS, parse

FIELDS = ["price", "category", "item", "winter", "gender", "color"]
cases = [json.loads(line) for line in open("shop-eval.jsonl", encoding="utf-8")]
results = {}   # 이름 → (예측 목록, 검색어당 ms)


def laya_filters(agent, case):
    a = agent.predict(case["state"], case["questions"])["answers"]
    return {f: (a[f]["noul"] >= 0.5 if a[f]["type"] == "noul" else a[f]["choice"]) for f in FIELDS}


def with_table(p):
    t = dict(p)
    if p["item"] != "none":
        t["category"] = CATEGORY_OF[p["item"]]
        t["winter"] = p["winter"] or p["item"] in WINTER_ITEMS
    return t


for version in (1, 2):
    start = time.time()
    results[f"rules v{version}"] = ([parse(c["state"], version)[0] for c in cases], (time.time() - start) / len(cases) * 1000)
for path in sys.argv[1:]:
    v = int(path[-1])
    agent = laya.load(path)
    start = time.time()
    lp = [laya_filters(agent, c) for c in cases]
    ms = (time.time() - start) / len(cases) * 1000
    tabled = [with_table(p) for p in lp]
    mixed = []
    for c, t in zip(cases, tabled):
        r, found = parse(c["state"], v)
        mixed.append({f: (r[f] if f in found else t[f]) for f in FIELDS})
    results[f"LAYA v{v}"] = (lp, ms)
    results[f"LAYA v{v} + table"] = (tabled, ms)
    results[f"rules v{v} + LAYA v{v}"] = (mixed, ms)

SUBSETS = {"train": lambda c: c["pool"] == "train", "ops": lambda c: c["pool"] == "ops",
           "unseen": lambda c: c["pool"] == "unseen", "말고": lambda c: "말고" in c["state"],
           "어울리는": lambda c: "어울리는" in c["state"]}
print("subset sizes:", " · ".join(f"{k} {sum(map(f, cases))}" for k, f in SUBSETS.items()))
print(f"{'method':<22}{'exact':>7}" + "".join(f"{k:>8}" for k in SUBSETS) + f"{'ms/query':>10}")
for name, (preds, ms) in results.items():
    ok = [all(p[f] == c["expected"][f] for f in FIELDS) for c, p in zip(cases, preds)]
    cells = ""
    for f in SUBSETS.values():
        sub = [o for c, o in zip(cases, ok) if f(c)]
        cells += f"{sum(sub) / len(sub):>8.3f}"
    print(f"{name:<22}{sum(ok) / len(ok):>7.3f}{cells}{ms:>10.2f}")

subset sizes: train 70 · ops 70 · unseen 70 · 말고 26 · 어울리는 5
method                  exact   train     ops  unseen      말고    어울리는  ms/query
rules v1                0.276   0.829   0.000   0.000   0.154   0.400      0.01
rules v2                0.619   0.886   0.971   0.000   0.615   0.600      0.02
LAYA v1                 0.305   0.800   0.114   0.000   0.269   0.800     90.15
LAYA v1 + table         0.333   0.886   0.114   0.000   0.308   0.800     90.15
rules v1 + LAYA v1      0.310   0.814   0.114   0.000   0.115   0.400     90.15
LAYA v2                 0.510   0.929   0.543   0.057   0.500   0.600     88.65
LAYA v2 + table         0.529   0.929   0.557   0.100   0.538   0.600     88.65
rules v2 + LAYA v2      0.652   0.914   0.957   0.086   0.654   0.600     88.65