"""KJH-Judge-4B-ko 판정 도우미 — 정해진 보기 중 하나를 골라 보정된 확률과 함께 돌려준다. from transformers import pipeline judge = pipeline(model="coderecode95/KJH-Judge-4B-ko", trust_remote_code=True, device=0, dtype="bfloat16") # 또는: from judge import Judge; judge = Judge() (이 파일을 내려받아 쓸 때) 1) JEV 형식 — 상황(state) 하나에 이름 붙인 질문 여러 개. 보기 ID는 마음대로 정한다. judge.decide( state={"고객 문의": "지난달 요금이 두 번 빠져나갔어요. 오늘 안에 처리해 주세요."}, questions={ "부서": {"instructions": "고객 문의를 담당 부서로 분류한다.", "criteria": {"billing": "결제·환불", "delivery": "배송", "account": "계정·로그인"}}, "긴급": {"instructions": "고객이 즉시 처리를 요구하는지 판단한다.", "criteria": {"urgent": "즉시 처리 요구", "normal": "일반 문의"}}, }, ) # → {'부서': {'choice': 'billing', 'confidence': 0.98, 'probabilities': {...}}, # '긴급': {'choice': 'urgent', 'confidence': 0.91, 'probabilities': {...}}} 2) 자주 쓰는 판정 — 학습 때와 같은 지침·보기를 자동으로 넣는다. judge.sentiment("배송은 느렸지만 물건은 정말 마음에 들어요") # → choice: 긍정 / 부정 judge.nli("보증금은 30일 이내 반환한다.", "보증금은 40일 뒤에 받는다.") # → entailment / contradiction / neutral judge.next_action("택시 불러줘", tools) # → CALL:call_taxi / ASK / RESPOND 3) 한 줄로 — judge(상황, 보기, instruction=…). 결과 형식은 모두 같다. judge("지난달 요금이 두 번 빠져나갔어요", ["결제·환불", "배송", "기타"], instruction="고객 문의를 담당 부서로 분류한다.") 동작: 아래 형식의 프롬프트를 한 번 계산하고, 다음 토큰 자리에서 보기 기호(A, B, …) 토큰의 점수만 꺼내 calibration.json 의 온도로 나눠 softmax 한다. 글을 생성하지 않으므로 빠르다. <|im_start|>user {지침} {항목 이름}: {값} ← state 의 키마다 한 줄 (값이 문자열이 아니면 JSON). 문자열만 주면 "text: {문자열}" 보기: A. {보기 1} B. {보기 2} 정답 보기의 기호 하나만 답하세요.<|im_end|> <|im_start|>assistant """ import json import warnings from pathlib import Path import torch from transformers import AutoModelForCausalLM, AutoTokenizer REPO = "coderecode95/KJH-Judge-4B-ko" HINT = "정답 보기의 기호 하나만 답하세요." DEFAULT_INSTRUCTION = "주어진 내용을 읽고 가장 알맞은 보기를 고른다." # 과제별 지침 — 학습·Korean JEV Benchmark 와 같은 문구 (바꾸면 정확도가 떨어질 수 있다) TASKS = { "sentiment": "문장의 전반적인 감정 극성을 판단한다. 부정 표현과 반어를 고려한다.", "nli": ("전제를 참이라고 할 때 가설을 분류한다. entailment: 전제로부터 가설이 따라온다. contradiction: 전제와 가설이 양립할 수 없다. neutral: 둘 다 아니다. " "정보가 없다는 이유만으로 contradiction을 고르지 않는다. neutral은 정상 정답이며 insufficient_context가 아니다. 통상적인 문장 의미로 판단하며 희박한 가정을 만들어 모호하다고 하지 않는다. " "전제의 열거 대상과 가설의 범위를 빠짐없이 대조한다. 가설의 만/밖에/오직/모두 같은 표현이 전제에 명시된 다른 대상이나 사례를 배제하는지 확인한다. " "전제에 배타 표현이 없다는 사실만으로 중립이라고 하지 않는다. 통상적인 문맥이 명확하면 다른 원인·상황을 임의로 추가하지 않는다."), "topic": "한국어 뉴스 제목의 중심 주제를 고른다. 여러 분야가 언급되어도 기사의 주된 사건을 우선한다.", "hate": ("APEACH 원 논문의 생성 기준을 따른다. 성별·성적 지향/정체성·나이/신분/경력·국적/인종·출신/거주지·외모·질병/장애·식습관·학력/전공 관련 차별·비하·공격을 포함한다. " "보호집단 정체성을 명시해야 한다는 제한은 없다. 불필요하거나 공격적인 외모 평가, 식습관 강요/폄하도 해당한다. 비공격적인 주제 언급이나 차별에 대한 반대 발언은 비혐오다."), "offensive": "BEEP 원 지침에 따른 공격성 수준. hate 대상은 보호 집단에 한정되지 않고 기사 속 인물·작성자 등 개인도 포함한다. 비속어 존재만으로 hate가 되지는 않는다. 뉴스 제목을 문맥으로 사용한다.", "yes_no": "문단에 근거하여 질문에 예/아니오로 답한다.", "same_meaning": "두 문맥에서 표시된 단어의 의미가 같은지 판단한다.", "similar": "두 문장의 의미가 같은지 판단한다. 표현이 달라도 전달하는 내용이 같으면 같은 의미다.", "reading": "지문에 근거하여 질문의 답을 고른다. 부정 질문에 주의한다.", "next_action": ("다음 한 단계의 행동을 선택한다. CALL:: 제공된 도구로 요청을 처리할 수 있고 필요한 필수 인자가 대화에 모두 있다. " "ASK: 관련 도구는 있으나 필수 인자가 부족해 질문이 필요하다. RESPOND: 도구가 불필요한 설명/완료 안내 또는 제공 도구로 지원하지 않는 요청에 대한 안내. " "실제 도구 실행·인자 작성은 하지 않는다. 과거 도구 결과를 활용하고 현재 정답이나 미래 턴을 추측하지 않는다. " "도구 schema가 필수 값의 기본값·문맥 추론·명칭 생성을 명시적으로 허용하면 그 정의를 따른다. 근거 없는 값을 만드는 것과 도구 정의가 허용하는 값을 도출하는 것을 구별한다. " "현재까지의 도구 결과로 요청이 해결됐으면 결과 안내가 다음 행동이며 같은 도구를 반복 호출하지 않는다."), "policy_action": ("명시된 정책과 예외의 조건에 따라 다음 행동을 고른다. 예외는 쓰인 적용 조건을 만족할 때만 기본 규칙을 덮어쓴다. 명시되지 않은 실제 금융 실무 요건을 추가하지 않는다. " "ASK_CLARIFICATION과 ASK_CONFIRMATION을 구별한다. 먼저 기본 규칙의 적용 조건과 예외의 적용 조건을 각각 확인한다. " "조건을 만족하는 명시적 행동 지시를 우선하며, 고객 문장이 질문 형태라는 이유로 이를 무시하지 않는다. 조건이 맞지 않는 예외는 적용하지 않는다. " "정책에 별도 행동 지시가 없으면 주어진 행동 정의와 실제 요청에 맞춰 판단한다. 정책·일반 사실 설명과 외부 계좌 정보 조회를 구별한다. " "명시된 행동을 고르는 추상 과제이므로 실제 도구 스키마나 계좌 인증 절차를 추가로 요구하지 않는다. 단, 원본에 없는 기본 행동이나 정책을 새로 만들지 않는다."), } # 과제별 보기 — {돌려줄 ID: 모델에게 보여 줄 보기 문구} CRITERIA = { "sentiment": {"긍정": "긍정적 감정", "부정": "부정적 감정"}, "nli": {"entailment": "entailment", "contradiction": "contradiction", "neutral": "neutral"}, "topic": {k: k for k in ["사회", "IT과학", "세계", "생활문화", "정치", "스포츠", "경제"]}, "hate": {"비혐오": "비혐오: 비하·공격성이 없는 표현", "혐오": "혐오·비하·공격적 표현"}, "offensive": {"없음": "혐오·모욕·불쾌 표현 없음", "공격적": "무례·공격·비꼼 등 불쾌하지만 강한 혐오/모욕 수준은 아님", "혐오": "개인/집단에 대한 강한 혐오 또는 사회적 지위를 심하게 훼손하는 모욕; 성희롱 포함"}, "yes_no": {"예": "예", "아니오": "아니오"}, "same_meaning": {"같음": "같은 의미", "다름": "서로 다른 의미"}, "similar": {"같음": "같은 의미", "다름": "다른 의미"}, "policy_action": {"ASK_CLARIFICATION": "ASK_CLARIFICATION: 부족한 정보를 고객에게 되묻는다", "ASK_CONFIRMATION": "ASK_CONFIRMATION: 실행 전에 명시적 확인·동의를 받는다", "ANSWER": "ANSWER: 도구 호출이나 실행 없이 정책·사실 정보로 답한다", "CALL_TOOL": "CALL_TOOL: 도구 하나로 실행하거나 조회한다", "CALL_MULTIPLE_TOOLS": "CALL_MULTIPLE_TOOLS: 둘 이상의 도구를 차례로 호출한다", "ESCALATE": "ESCALATE: 자동 처리를 멈추고 사람 상담사에게 넘긴다", "REFUSE": "REFUSE: 요청을 이행하지 않고 사유를 안내한다"}, } ASK = "ASK: 부족한 필수 정보 질문" RESPOND = "RESPOND: 직접 설명·완료·미지원 안내" def render_prompt(instruction, item, choices): if isinstance(item, str): item = {"text": item} lines = [f"{k}: {v if isinstance(v, str) else json.dumps(v, ensure_ascii=False)}" for k, v in item.items()] opts = "\n".join(f"{chr(65 + i)}. {c}" for i, c in enumerate(choices)) return "\n\n".join([(instruction or DEFAULT_INSTRUCTION).strip(), "\n".join(lines), "보기:\n" + opts, HINT]) def chat_prefix(prompt): return f"<|im_start|>user\n{prompt}<|im_end|>\n<|im_start|>assistant\n" def check_choices(choices): choices = [c["text"] if isinstance(c, dict) else str(c) for c in choices] if not 2 <= len(choices) <= 26: raise ValueError(f"보기는 2~26개여야 합니다 (지금 {len(choices)}개)") if len(set(choices)) != len(choices): raise ValueError("보기 문구가 겹칩니다. 보기마다 다른 문구를 써 주세요") return choices def load_temperature(model): p = Path(model) / "calibration.json" if not p.is_file(): try: from huggingface_hub import hf_hub_download p = Path(hf_hub_download(model, "calibration.json")) except Exception: warnings.warn(f"{model} 에서 calibration.json 을 찾지 못해 보정 없이(온도 1.0) 확률을 계산합니다.") return 1.0 return float(json.loads(p.read_text(encoding="utf-8"))["temperature"]) def letter_ids(tokenizer): return [tokenizer.encode(chr(65 + i), add_special_tokens=False)[0] for i in range(26)] def as_result(ids, probs): """보기 순서의 확률 → {'choice', 'confidence', 'probabilities'}""" b = max(range(len(probs)), key=probs.__getitem__) return {"choice": ids[b], "confidence": round(probs[b], 4), "probabilities": {i: round(p, 4) for i, p in zip(ids, probs)}} def _criteria(criteria): """{ID: 설명} 또는 [설명, …] → (ID 목록, 설명 목록). 리스트면 설명이 곧 ID.""" if isinstance(criteria, dict): return [str(k) for k in criteria], check_choices(list(criteria.values())) texts = check_choices(criteria) return texts, texts def _rows(**fields): """값이 모두 문자열이면 항목 하나, 모두 같은 길이의 리스트면 항목 여러 개.""" vals = list(fields.values()) if all(isinstance(v, list) for v in vals): if len({len(v) for v in vals}) != 1: raise ValueError("리스트로 여러 개를 넣을 때는 길이가 같아야 합니다") return [dict(zip(fields, row)) for row in zip(*vals)], True return dict(fields), False def _tool_name(t): return (t.get("function") or t)["name"] if isinstance(t, dict) else str(t) class Tasks: """JEV 형식 decide() 와 자주 쓰는 판정. self(상황, choices=…, instruction=…) 만 있으면 된다 (Judge 와 pipeline 이 함께 쓴다).""" def _choose(self, state, criteria, instructions, many=False): ids, texts = _criteria(criteria) res = self(state, choices=texts, instruction=instructions) def rename(r): return as_result(ids, [r["probabilities"][t] for t in texts]) return [rename(r) for r in res] if many else rename(res) def decide(self, state, questions): """JEV 형식. state: 상황(dict 또는 문장). questions: {질문 이름: {"instructions": 지침, "criteria": {ID: 설명}}}. → {질문 이름: {'choice': ID, 'confidence': 확률, 'probabilities': {ID: 확률}}}""" out = {} for name, q in questions.items(): if q.get("type", "choice") != "choice": raise ValueError(f"'{name}': 지원하는 type 은 'choice' 뿐입니다") out[name] = self._choose(state, q["criteria"], q.get("instructions")) return out def sentiment(self, text): """감정 → 긍정 / 부정. 문장 하나 또는 리스트.""" return self._choose(text, CRITERIA["sentiment"], TASKS["sentiment"], isinstance(text, list)) def topic(self, headline): """뉴스 제목 주제 → 사회 / IT과학 / 세계 / 생활문화 / 정치 / 스포츠 / 경제.""" rows, many = _rows(headline=headline) return self._choose(rows, CRITERIA["topic"], TASKS["topic"], many) def hate(self, text): """혐오·비하 표현 여부 → 비혐오 / 혐오.""" return self._choose(text, CRITERIA["hate"], TASKS["hate"], isinstance(text, list)) def offensive(self, comment, news_title=None): """댓글 공격성 3단계 → 없음 / 공격적 / 혐오. 뉴스 제목이 있으면 문맥으로 쓴다.""" rows, many = _rows(news_title=news_title, comments=comment) if news_title is not None else _rows(comments=comment) return self._choose(rows, CRITERIA["offensive"], TASKS["offensive"], many) def nli(self, premise, hypothesis): """문장 관계 → entailment / contradiction / neutral.""" rows, many = _rows(premise=premise, hypothesis=hypothesis) return self._choose(rows, CRITERIA["nli"], TASKS["nli"], many) def similar(self, sentence1, sentence2): """두 문장이 같은 뜻인지 → 같음 / 다름.""" rows, many = _rows(sentence1=sentence1, sentence2=sentence2) return self._choose(rows, CRITERIA["similar"], TASKS["similar"], many) def yes_no(self, question, passage): """지문에 근거한 예/아니오 → 예 / 아니오.""" rows, many = _rows(paragraph=passage, question=question) return self._choose(rows, CRITERIA["yes_no"], TASKS["yes_no"], many) def same_meaning(self, word, context_1, context_2): """두 문맥에서 단어 뜻이 같은지 → 같음 / 다름. 문맥 안의 단어는 [단어]로 표시하면 좋다.""" rows, many = _rows(word=word, context_1=context_1, context_2=context_2) return self._choose(rows, CRITERIA["same_meaning"], TASKS["same_meaning"], many) def reading(self, passage, question, choices): """지문 독해 객관식 → 보기 중 하나 (리스트면 보기 문구, dict 면 ID).""" return self._choose({"passage": passage, "question": question}, choices, TASKS["reading"]) def next_action(self, messages, tools): """에이전트의 다음 행동 → CALL:<도구 이름> / ASK (필수 정보 부족) / RESPOND (직접 답변). messages: 사용자 문장(str) 또는 [{"role", "content"}, …]. tools: OpenAI 형식 도구 목록 또는 이름 목록.""" if isinstance(messages, str): messages = [{"role": "user", "content": messages}] criteria = {f"CALL:{_tool_name(t)}": f"CALL:{_tool_name(t)}" for t in tools} | {"ASK": ASK, "RESPOND": RESPOND} return self._choose({"messages": messages, "tools": tools}, criteria, TASKS["next_action"]) def policy_action(self, policy, request): """정책에 따른 행동 → ASK_CLARIFICATION / ASK_CONFIRMATION / ANSWER / CALL_TOOL / CALL_MULTIPLE_TOOLS / ESCALATE / REFUSE.""" text = f"정책: {policy}\n\n고객 요청: \"{request}\"\n위 정책에 따라 올바르게 처리하라." return self._choose({"policy_and_request": text}, CRITERIA["policy_action"], TASKS["policy_action"]) class Judge(Tasks): def __init__(self, model=REPO, device=None, dtype=None): device = device or ("cuda" if torch.cuda.is_available() else "cpu") dtype = dtype or (torch.bfloat16 if device != "cpu" else torch.float32) self.tok = AutoTokenizer.from_pretrained(model) self.model = AutoModelForCausalLM.from_pretrained(model, dtype=dtype).to(device).eval() self.device = device self.temperature = load_temperature(model) self.letter_ids = letter_ids(self.tok) def __call__(self, inputs, choices, instruction=None): """inputs: 문장(str) · 상황(dict) · 그 리스트. choices: [설명, …] 또는 {ID: 설명}. 리스트를 주면 결과도 리스트.""" many = isinstance(inputs, list) ids, texts = _criteria(choices) out = self.decide_batch([{"instruction": instruction, "item": x, "choices": texts} for x in (inputs if many else [inputs])]) res = [as_result(ids, [r["probs"][chr(65 + i)] for i in range(len(texts))]) for r in out] return res if many else res[0] @torch.no_grad() def decide_batch(self, requests, batch_size=16, max_tokens=8000): """저수준 묶음 판정 (평가 스크립트용). requests: [{"instruction": str, "item": dict|str, "choices": [str, …]}, …] → 같은 순서의 결과 목록. 결과: {'choice': 'A', 'index': 0, 'text': 보기, 'confidence': 확률, 'probs': {'A': …, 'B': …}} 길이가 비슷한 것끼리 묶어 계산한다 (오른쪽을 채우고 각 문장의 마지막 자리만 읽으므로 결과는 하나씩 계산한 것과 같다).""" seqs = [] for r in requests: ch = check_choices(r["choices"]) ids = self.tok.encode(chat_prefix(render_prompt(r.get("instruction"), r["item"], ch)), add_special_tokens=False) seqs.append((ids, ch)) order = sorted(range(len(seqs)), key=lambda i: len(seqs[i][0])) out = [None] * len(seqs) W = self.model.get_output_embeddings().weight i = 0 while i < len(order): grp = [order[i]] while i + len(grp) < len(order) and len(grp) < batch_size and (len(grp) + 1) * len(seqs[order[i + len(grp)]][0]) <= max_tokens: grp.append(order[i + len(grp)]) i += len(grp) n = max(len(seqs[k][0]) for k in grp) x = torch.zeros(len(grp), n, dtype=torch.long) for r, k in enumerate(grp): x[r, :len(seqs[k][0])] = torch.tensor(seqs[k][0]) h = self.model.model(input_ids=x.to(self.device)).last_hidden_state # 최종 정규화까지 마친 은닉 상태 for r, k in enumerate(grp): ids, ch = seqs[k] rows = torch.tensor(self.letter_ids[:len(ch)], device=self.device) p = torch.softmax((h[r, len(ids) - 1].float() @ W[rows].float().T) / self.temperature, -1).tolist() b = max(range(len(p)), key=p.__getitem__) out[k] = {"choice": chr(65 + b), "index": b, "text": ch[b], "confidence": round(p[b], 4), "probs": {chr(65 + j): round(v, 4) for j, v in enumerate(p)}} return out if __name__ == "__main__": import sys j = Judge(sys.argv[1] if len(sys.argv) > 1 else ".") print(j.sentiment("배송은 느렸지만 물건은 정말 마음에 들어요"))