| """Судья: модель сверяет выдачу системы с эталоном и рубрикой задачи и ищет галлюцинации и искажения.
|
|
|
| Судья слепой: он не знает, какая система ответила, и видит только просьбу человека, сведения о материалах, эталонный
|
| ответ, рубрику, запрещённые утверждения и выдачу системы (ответ на каждое сообщение человека и текст выданных файлов).
|
| Каждый пункт рубрики он отмечает «верно / частично / неверно / нет в ответе»: по этим отметкам отчёт считает точность
|
| (верное среди сказанного по пунктам) и полноту (доля пунктов, закрытых верно). Вердикт он подкрепляет дословной цитатой
|
| из выдачи; галлюцинацию тоже цитатой. Цитаты сверяются кодом: вердикт с цитатой, которой в выдаче нет, как и «частично»
|
| или «неверно» без цитаты, становится «нет в ответе»; галлюцинация без найденной цитаты отбрасывается. Так судья не может
|
| ни засчитать то, чего нет, ни приписать системе то, чего она не писала. «Верно» без цитаты судья ставит только пункту о
|
| том, чего в выдаче быть не должно.
|
|
|
| Галлюцинация — утверждение выдачи, которое противоречит эталону или материалам (искажение), или факт, взятый ниоткуда
|
| (выдумка). Материалов человека целиком судья не видит: их бывают сотни файлов. Поэтому каждая найденная им галлюцинация, кроме
|
| запрещённых утверждений задачи, проходит второй проход: поиск по словам и числам утверждения находит отрывки материалов,
|
| и модель, видя утверждение в его месте выдачи, решает, подтверждают ли они его. Отрывки — первоисточник, эталон — мерило
|
| ответа, а не перечень всего верного. Галлюцинация снимается, только если модель привела дословную цитату из
|
| отрывка или эталона и код нашёл её там; иначе она остаётся. Верное по материалам, но не вошедшее в эталон, так не
|
| становится галлюцинацией, а неподтверждённое не проходит.
|
|
|
| Модель — та же, что у сравниваемых систем (Qwen3.8-27B на vLLM), через OpenAI-совместимый API; ответ — строго по
|
| JSON-схеме (guided decoding), температура 0.
|
|
|
| python judge.py <tasks.jsonl> <папка прогона системы> [--base-url http://host:8000/v1] [--model qwen3.8-27b] [--only <задача> …]
|
|
|
| Подключение к модели без ключей берётся из окружения: JUDGE_BASE_URL, JUDGE_MODEL, JUDGE_API_KEY, а без них из
|
| WORKPERMIT_MODEL_URL, WORKPERMIT_MODEL, WORKPERMIT_MODEL_KEY, общих с прогонщиком DeepSeek Harness: судья — та же модель,
|
| что у систем. Внутри контейнера оценки адрес localhost ведёт на машину, где запущен контейнер (host.docker.internal).
|
| Результат пишется в ``<задача>/judge.json`` рядом с ``record.json``. Весь прогон одной командой оценивает ``evaluate.py``.
|
| """
|
|
|
| from __future__ import annotations
|
|
|
| import argparse
|
| import datetime
|
| import http.client
|
| import json
|
| import math
|
| import os
|
| import re
|
| import sys
|
| import time
|
| import urllib.error
|
| import urllib.request
|
| from pathlib import Path
|
|
|
| sys.path.insert(0, str(Path(__file__).parent))
|
| from checks import Output, normalize, numbers, rubric_items
|
| from extract import extract
|
|
|
| MAX_FILE_CHARS = 40_000
|
| MAX_OUTPUT_CHARS = 100_000
|
| JUDGE_ATTEMPTS = 3
|
|
|
| SCHEMA = {
|
| "type": "object",
|
| "properties": {
|
| "rubric": {
|
| "type": "array",
|
| "items": {
|
| "type": "object",
|
| "properties": {
|
| "item": {"type": "integer"},
|
| "reasoning": {"type": "string"},
|
| "quote": {"type": "string"},
|
| "verdict": {"type": "string", "enum": ["yes", "partial", "wrong", "missing"]},
|
| },
|
| "required": ["item", "reasoning", "quote", "verdict"],
|
| },
|
| },
|
| "fabrications": {
|
| "type": "array",
|
| "items": {
|
| "type": "object",
|
| "properties": {
|
| "quote": {"type": "string"},
|
| "why": {"type": "string"},
|
| "must_not": {"type": "integer"},
|
| },
|
| "required": ["quote", "why", "must_not"],
|
| },
|
| },
|
| },
|
| "required": ["rubric", "fabrications"],
|
| }
|
|
|
| SYSTEM = """Ты — строгий и беспристрастный проверяющий в бенчмарке рабочих задач. Тебе показывают просьбу человека, сведения
|
| о его материалах, вопросы системы с ответами человека, если она спрашивала, эталонный ответ, рубрику, список
|
| запрещённых утверждений и выдачу системы — её ответ (если сообщений несколько, ответ на каждое) и текст выданных
|
| файлов. Какая система ответила, неизвестно и не важно.
|
|
|
| Правила:
|
| 1. Оценивай только выдачу системы. Эталон — мерило, а не образец формулировок: верный ответ другими словами — «yes».
|
| 2. По каждому пункту рубрики: сначала кратко рассуждай, потом приведи дословную цитату из выдачи, на которой основан
|
| вердикт (короткий фрагмент, скопированный символ в символ), потом вердикт:
|
| «yes» — пункт выполнен полностью и верно;
|
| «partial» — выполнен частично или с неточностью;
|
| «wrong» — по пункту сказано неверное: значение, вывод или источник противоречат эталону или материалам;
|
| «missing» — по пункту в выдаче ничего нет, цитата пустая.
|
| Без цитаты «yes», «partial» и «wrong» не ставь. Если пункт требует, чтобы чего-то в выдаче НЕ было: этого нет — «yes»
|
| с пустой цитатой, это есть — «wrong» с цитатой.
|
| 3. Галлюцинации и искажения: перечисли утверждения выдачи, которые противоречат эталону или материалам, или факты (числа,
|
| имена, реквизиты, нормы, источники), взятые ниоткуда. Для каждого — дословная цитата и почему это галлюцинация. Если
|
| оно совпадает с пунктом списка запрещённых утверждений, укажи его номер в must_not, иначе 0. Разумные допущения, прямо
|
| названные допущениями, — не галлюцинация. Не считай галлюцинацией то, что верно по материалам, даже если этого нет в
|
| эталоне.
|
| Ответ — строго JSON по схеме."""
|
|
|
|
|
| def _materials_summary(task: dict) -> str:
|
| lines = []
|
| for i, turn in enumerate(task.get("turns", []), 1):
|
| names = ", ".join(f["name"] for f in turn.get("attachments", []))
|
| lines.append(f"Сообщение {i}: «{turn['text']}»" + (f" Вложения: {names}." if names else ""))
|
| if task.get("corpus"):
|
| lines.append(f"Материалы человека: «{task['corpus']['title']}» ({task['corpus']['placement']}).")
|
| for base in task.get("knowledge_bases", []):
|
| lines.append(f"База знаний «{base['name']}»: {len(base.get('files', []))} файлов.")
|
| if task.get("my_files"):
|
| lines.append(f"Файлы в хранилище: {len(task['my_files'])}.")
|
| if task.get("reply_if_asked"):
|
| lines.append(f"Если система спросит, человек ответит: «{task['reply_if_asked']}».")
|
| return "\n".join(lines)
|
|
|
|
|
| DIALOG_QUESTION_CHARS = 2000
|
|
|
|
|
| def _dialog(record: dict) -> str:
|
| """Вопросы системы и ответы человека в прогоне. Судья видит ответ системы на сообщение, а что человек сказал на её
|
| вопрос (например, что других сведений у него нет), без этого не знает, хотя от сказанного зависит, верно ли система
|
| поступила с недостающим. Вопрос показан концом: длинный ответ с вопросом кончается самим вопросом."""
|
| turns = record.get("turns") or []
|
| lines = []
|
| for previous, turn in zip(turns, turns[1:]):
|
| if not turn.get("reply"):
|
| continue
|
| question = (previous.get("answer") or "").strip()
|
| if len(question) > DIALOG_QUESTION_CHARS:
|
| question = "[… начало ответа опущено …] " + question[-DIALOG_QUESTION_CHARS:]
|
| lines.append(f"Система спросила: «{question}»\nЧеловек ответил: «{turn.get('text', '')}»")
|
| return "\n\n".join(lines)
|
|
|
|
|
| def _delivery(output: Output) -> tuple[str, str]:
|
| """Текст выдачи для судьи и полный текст для сверки цитат. Имя выданного файла — тоже выдача: пункт «выдан документ Word»
|
| судья подкрепляет именем файла, и без имени в тексте сверки верный вердикт становился «нет». У задачи из нескольких
|
| сообщений судья видит ответ на каждое: пункты рубрики говорят о ходах («заметка создана», «найдена», «удалена»), и по
|
| одному последнему ответу их было не засчитать."""
|
| answers = output.messages()
|
| if len(answers) > 1:
|
| parts = [f"## Ответ системы на сообщение {n}\n{answer}" for n, answer in enumerate(answers, 1)]
|
| full = list(answers)
|
| else:
|
| parts = [f"## Ответ системы\n{output.answer}"]
|
| full = [output.answer]
|
| for f in output.files():
|
| text = output.file_text(f)
|
| heading = f"## Выданный файл «{f['name']}»"
|
| full.append(f"{heading}\n{text}")
|
| shown = text if len(text) <= MAX_FILE_CHARS else text[:MAX_FILE_CHARS] + "\n[… файл обрезан для судьи …]"
|
| parts.append(f"{heading}\n{shown}")
|
| joined = "\n\n".join(parts)
|
| if len(joined) > MAX_OUTPUT_CHARS:
|
| joined = joined[:MAX_OUTPUT_CHARS] + "\n[… выдача обрезана для судьи …]"
|
| return joined, "\n".join(full)
|
|
|
|
|
| def _squash(text: str) -> str:
|
| return re.sub(r"[^0-9a-zа-я]+", "", text)
|
|
|
|
|
| def _quote_found(quote: str, full: str) -> bool:
|
| """Цитата есть в тексте дословно. Пропуск, отмеченный многоточием, допустим: каждая часть между многоточиями должна
|
| найтись в тексте дословно, в любом порядке (судья перечисляет места в своём порядке). Части сверяются без знаков
|
| препинания и разметки: цитата могла пересечь границу ячеек или строк."""
|
| parts = [p for p in re.split(r"\s*(?:\[\s*(?:\.\.\.|…)\s*\]|\.\.\.|…)\s*", normalize(quote)) if len(_squash(p)) >= 4]
|
| if not parts:
|
| return False
|
| text = normalize(full)
|
| if len(parts) == 1 and parts[0].strip(" .") in text:
|
| return True
|
| squashed = _squash(text)
|
| return all(_squash(part) in squashed for part in parts) and sum(len(_squash(p)) for p in parts) >= 6
|
|
|
|
|
| VERIFY_SYSTEM = """Ты сверяешь с источниками одно утверждение, которое проверяющий счёл выдумкой в выдаче системы. Тебе даны
|
| утверждение (дословная цитата из выдачи) и место выдачи, где оно стоит (цитата в нём выделена знаками ⟦ ⟧), довод проверяющего, эталонный ответ и отрывки
|
| материалов человека, найденные поиском по словам и числам утверждения; у задачи с подключённой системой (1С, Jira, GitHub)
|
| среди отрывков и то, что система получила из неё своими умениями; среди отрывков и дата, когда человек написал, — «сегодня»
|
| задачи, и календарь — день недели каждой даты, названной в утверждении и доводе: он посчитан кодом и верен.
|
|
|
| Отрывки, дата и календарь — первоисточник. Эталон — мерило ответа, а не перечень всего верного: о многом верном он молчит.
|
| Довод проверяющего — его мнение, и оно может ошибаться. Смысл утверждения бери из его места в выдаче: к чему относится
|
| значение и что о нём сказано.
|
|
|
| Реши:
|
| * «supported» — утверждение прямо следует из отрывков материалов или из эталона: те же значения, и относятся они к тому
|
| же, о чём говорит утверждение в своём месте выдачи. Подтверждения отрывком достаточно, даже когда эталон о нём молчит.
|
| Приведи дословную цитату из отрывка или эталона (символ в символ), которая это подтверждает: место целиком, со словами
|
| вокруг значения, а не одно число.
|
| * «fabrication» — подтверждения нет: утверждение противоречит отрывкам или эталону либо опирается на то, чего в них
|
| нет. Цитата пустая.
|
| Совпадение отдельного числа или слова — ещё не подтверждение. Ответ — строго JSON по схеме."""
|
|
|
| VERIFY_SCHEMA = {
|
| "type": "object",
|
| "properties": {
|
| "reasoning": {"type": "string"},
|
| "verdict": {"type": "string", "enum": ["supported", "fabrication"]},
|
| "quote": {"type": "string"},
|
| },
|
| "required": ["reasoning", "verdict", "quote"],
|
| }
|
|
|
| IDENTIFIER = re.compile(r"\b\d{1,2}\.\d{1,2}\.\d{4}\b|№\s?[\w\-/.]*\d[\w\-/.]*")
|
|
|
| PASSAGE_CHARS = 900
|
| PASSAGES = 8
|
| STEM = 5
|
|
|
| _INDEX: dict[str, list[tuple[str, str, set, set]]] = {}
|
|
|
|
|
| def _stems(text: str) -> set:
|
| return {w[:STEM] for w in normalize(text).replace("-", " ").split() if len(w) >= STEM and w.isalpha()}
|
|
|
|
|
| def _chunks(name: str, text: str) -> list[tuple[str, str, set, set]]:
|
| """Отрывки файла целыми строками: имя файла, текст, числа и основы слов."""
|
| out, current = [], []
|
| size = 0
|
| for line in text.splitlines():
|
| if size + len(line) > PASSAGE_CHARS and current:
|
| out.append("\n".join(current))
|
| current, size = [], 0
|
| current.append(line[:PASSAGE_CHARS * 2])
|
| size += len(line) + 1
|
| if current:
|
| out.append("\n".join(current))
|
| return [(name, chunk, set(numbers(chunk)), _stems(chunk)) for chunk in out if chunk.strip()]
|
|
|
|
|
| def materials_index(task: dict, dataset: Path) -> list[tuple[str, str, set, set]]:
|
| """Отрывки всех материалов задачи: вложений, баз знаний, хранилища и корпуса."""
|
| files = [f for turn in task.get("turns", []) for f in turn.get("attachments", [])]
|
| files += [f for base in task.get("knowledge_bases", []) for f in base.get("files", [])]
|
| files += task.get("my_files", [])
|
| if task.get("corpus"):
|
| manifest = dataset / "corpora" / task["corpus"]["id"] / "manifest.json"
|
| files += json.loads(manifest.read_text(encoding="utf-8")).get("files", [])
|
| index = []
|
| for f in files:
|
| if f["path"] not in _INDEX:
|
| try:
|
|
|
| original = dataset / "originals" / f["path"]
|
| text = extract(original if original.exists() else dataset / f["path"])
|
| except Exception as error:
|
| text = f"[файл не прочитан: {error}]"
|
| _INDEX[f["path"]] = _chunks(f["name"], text)
|
| index += _INDEX[f["path"]]
|
| return index
|
|
|
|
|
| def system_outputs(record: dict) -> list[tuple[str, str, set, set]]:
|
| """Отрывки выдачи умений подключённой системы (1С, Jira, GitHub). Её данных в материалах задачи нет: без выдачи
|
| сверка считала выдумкой то, что система прочла в двойнике (2026-10-22: 8.01 и 8.05 — Д=0 при верном ответе). Выдачу
|
| прогон пишет только у задач с подключённой системой."""
|
| out = []
|
| for action in record.get("actions", []):
|
| if action.get("result"):
|
| out += _chunks(f"выдача подключённой системы: умение {action.get('name', '')}", action["result"])
|
| return out
|
|
|
|
|
| def asked_at(record: dict) -> list[tuple[str, str, set, set]]:
|
| """Дата, когда человек написал, отрывком сверки: ответ «на сегодня» законно называет её, а в материалах задачи её нет
|
| (2026-10-22, 8.01: «остаток на 22.10.2026» засчитан выдумкой)."""
|
| today = started_on(record)
|
| if today is None:
|
| return []
|
| return _chunks("дата сообщения человека", f"Человек написал {today:%d.%m.%Y} ({record['started']}); это «сегодня» задачи.")
|
|
|
|
|
| def started_on(record: dict) -> datetime.date | None:
|
| """День, когда человек написал: начало прогона."""
|
| match = re.match(r"(\d{4})-(\d{2})-(\d{2})", record.get("started") or "")
|
| try:
|
| return datetime.date(*map(int, match.groups())) if match else None
|
| except ValueError:
|
| return None
|
|
|
|
|
| MONTHS = ["января", "февраля", "марта", "апреля", "мая", "июня", "июля", "августа", "сентября", "октября", "ноября", "декабря"]
|
| WEEKDAYS = ["понедельник", "вторник", "среда", "четверг", "пятница", "суббота", "воскресенье"]
|
|
|
| DATES = re.compile(
|
| r"(?<!\d)(?P<d1>\d{1,2})\.(?P<m1>\d{1,2})\.(?P<y1>\d{4})(?!\d)"
|
| r"|(?<!\d)(?P<y2>\d{4})-(?P<m2>\d{2})-(?P<d2>\d{2})(?!\d)"
|
| r"|(?<!\d)(?P<d3>\d{1,2})\s+(?P<m3>" + "|".join(MONTHS) + r")(?![а-яё])(?:\s+(?P<y3>\d{4})(?!\d))?",
|
| re.IGNORECASE)
|
|
|
|
|
| def calendar(claim: str, year: int | None = None) -> list[tuple[str, str]]:
|
| """День недели каждой даты утверждения отрывком сверки. В материалах дня недели обычно нет, а судья — та же модель и
|
| путает его: 2026-10-31, 2.07 — верное «21 октября 2026 года — среда» записано выдумкой с доводом «это вторник», и снять
|
| его было нечем. Дата без года («21 октября») берёт год задачи (``year``); он назван в строке календаря, и сверка видит,
|
| к какому году отнесён день."""
|
| lines = []
|
| for match in DATES.finditer(claim):
|
| if match.group("d1"):
|
| day, month, found_year = match.group("d1"), match.group("m1"), match.group("y1")
|
| elif match.group("y2"):
|
| day, month, found_year = match.group("d2"), match.group("m2"), match.group("y2")
|
| else:
|
| day, month, found_year = match.group("d3"), MONTHS.index(match.group("m3").lower()) + 1, match.group("y3")
|
| if found_year is None and year is None:
|
| continue
|
| try:
|
| date = datetime.date(int(found_year) if found_year else year, int(month), int(day))
|
| except ValueError:
|
| continue
|
| line = f"{date:%d.%m.%Y} ({date.day} {MONTHS[date.month - 1]} {date.year} года) — {WEEKDAYS[date.weekday()]}"
|
| if line not in lines:
|
| lines.append(line)
|
| return [("календарь", "\n".join(lines))] if lines else []
|
|
|
|
|
| def passages(claim: str, index: list[tuple[str, str, set, set]]) -> list[tuple[str, str]]:
|
| """Отрывки, где больше всего чисел и слов утверждения, с весом редкости (IDF); число весит втрое. Дата и номер документа
|
| («29.12.2025», «№ 532-ФЗ») сверяются целиком и весят больше всего: по отдельным числам дата теряется среди сотен
|
| поправок с тем же годом."""
|
| wanted_numbers, wanted_stems = set(numbers(claim)), _stems(claim)
|
| literals = {normalize(m.group(0)) for m in IDENTIFIER.finditer(claim)}
|
| total = len(index) or 1
|
| weight = {}
|
| for key, field in [(n, 2) for n in wanted_numbers] + [(w, 3) for w in wanted_stems]:
|
| frequency = sum(1 for entry in index if key in entry[field])
|
| weight[(field, key)] = math.log((total + 1) / (frequency + 0.5)) * (3 if field == 2 else 1)
|
| for literal in literals:
|
| frequency = sum(1 for entry in index if literal in normalize(entry[1]))
|
| weight[(0, literal)] = math.log((total + 1) / (frequency + 0.5)) * 6
|
| scored = []
|
| for name, chunk, chunk_numbers, chunk_stems in index:
|
| score = sum(weight[(2, n)] for n in wanted_numbers & chunk_numbers) + sum(weight[(3, w)] for w in wanted_stems & chunk_stems)
|
| if literals:
|
| text = normalize(chunk)
|
| score += sum(weight[(0, literal)] for literal in literals if literal in text)
|
| if score > 0:
|
| scored.append((score, name, chunk))
|
| scored.sort(key=lambda x: -x[0])
|
| return [(name, chunk) for _, name, chunk in scored[:PASSAGES]]
|
|
|
|
|
| def _ask(base_url: str, model: str, api_key: str, system: str, user: str, schema: dict, max_tokens: int) -> tuple[dict, dict]:
|
| body = {
|
| "model": model,
|
| "messages": [{"role": "system", "content": system}, {"role": "user", "content": user}],
|
| "temperature": 0,
|
| "seed": 20261020,
|
| "max_tokens": max_tokens,
|
| "response_format": {"type": "json_schema", "json_schema": {"name": "verdict", "schema": schema, "strict": True}},
|
| }
|
| request = urllib.request.Request(f"{base_url.rstrip('/')}/chat/completions", data=json.dumps(body).encode("utf-8"),
|
| headers={"Content-Type": "application/json", "Authorization": f"Bearer {api_key}"})
|
|
|
|
|
|
|
|
|
|
|
| for attempt in range(JUDGE_ATTEMPTS):
|
| choice = {}
|
| try:
|
| with urllib.request.urlopen(request, timeout=900) as response:
|
| reply = json.loads(response.read().decode("utf-8"))
|
| choice = reply["choices"][0]
|
| return json.loads(choice["message"]["content"]), reply.get("usage", {})
|
| except json.JSONDecodeError:
|
| if choice.get("finish_reason") == "length" or attempt == JUDGE_ATTEMPTS - 1:
|
| raise
|
| except urllib.error.HTTPError as error:
|
|
|
|
|
| if (error.code < 500 and error.code not in (408, 429)) or attempt == JUDGE_ATTEMPTS - 1:
|
| raise
|
| except (urllib.error.URLError, http.client.HTTPException, ConnectionError, TimeoutError):
|
| if attempt == JUDGE_ATTEMPTS - 1:
|
| raise
|
| time.sleep(60 * (attempt + 1))
|
|
|
|
|
| BRIEF = ("\n\nПиши кратко: рассуждение по пункту не длиннее двух предложений, цитата не длиннее 200 знаков, у галлюцинации "
|
| "довод в одно предложение. Прошлый ответ не уместился в предел длины.")
|
|
|
|
|
| def _ask_verdict(base_url: str, model: str, api_key: str, user: str) -> tuple[dict, dict]:
|
| """Вердикт судьи; если ответ оборвался на пределе длины, судья отвечает ещё раз короче и с большим пределом."""
|
| try:
|
| return _ask(base_url, model, api_key, SYSTEM, user, SCHEMA, 12000)
|
| except json.JSONDecodeError:
|
| return _ask(base_url, model, api_key, SYSTEM + BRIEF, user, SCHEMA, 16000)
|
|
|
|
|
| CONTEXT_CHARS = 300
|
| CONTEXT_PLACES = 3
|
|
|
|
|
| def claim_context(quote: str, delivery: str) -> str:
|
| """Место выдачи, где стоит утверждение: строки вокруг каждого вхождения начала цитаты, до трёх мест, с цитатой,
|
| выделенной знаками ⟦ ⟧. Без места короткая цитата теряет смысл — к чему относится значение, сверка не видит и сравнивает
|
| его не с тем (2026-11-01, onec-stock: сумма прихода «48 000» записана выдумкой доводом «это приход, а не остаток»); без
|
| выделения она читается соседним значением места (там же «18 000» расхода прочитано строкой остатка «18 единиц на сумму
|
| 15 000»)."""
|
| head = re.split(r"\s*(?:\[\s*(?:\.\.\.|…)\s*\]|\.\.\.|…)\s*", quote.strip())[0].strip(" .")
|
| if len(head) < 2:
|
| return ""
|
| lowered, needle = delivery.lower(), head.lower()
|
| places: list[str] = []
|
| start = 0
|
| while len(places) < CONTEXT_PLACES:
|
| at = lowered.find(needle, start)
|
| if at < 0:
|
| break
|
| begin = max(delivery.rfind("\n", 0, max(0, at - CONTEXT_CHARS)) + 1, at - 2 * CONTEXT_CHARS)
|
| stop = delivery.find("\n", at + len(head) + CONTEXT_CHARS)
|
| end = min(len(delivery) if stop < 0 else stop, at + len(head) + 2 * CONTEXT_CHARS)
|
| place = (delivery[begin:at] + "⟦" + delivery[at:at + len(head)] + "⟧" + delivery[at + len(head):end]).strip()
|
| if place and place not in places:
|
| places.append(place)
|
| start = at + len(head)
|
| return "\n[…]\n".join(places)
|
|
|
|
|
| VERIFY_BRIEF = "\n\nПиши кратко: рассуждение не длиннее трёх предложений. Прошлый ответ не уместился в предел длины."
|
|
|
|
|
| def verify_fabrication(fabrication: dict, task: dict, index: list, base_url: str, model: str, api_key: str,
|
| today: datetime.date | None = None, delivery: str = "") -> tuple[bool, dict, dict]:
|
| """Подтверждают ли материалы или эталон утверждение, которое судья счёл выдумкой: (снять, сверка, расход). Сверка,
|
| которая не дала ответа по форме и короче, выдумку не снимает: снимает только подтверждение."""
|
| claim = fabrication["quote"] + " " + fabrication.get("why", "")
|
| found = passages(claim, index) + calendar(claim, today.year if today else None)
|
| reference = task.get("reference_answer") or "(эталона нет)"
|
| user = (
|
| f"# Утверждение из выдачи\n{fabrication['quote']}\n\n"
|
| f"# Где оно стоит в выдаче\n{claim_context(fabrication['quote'], delivery) or '(место не найдено)'}\n\n"
|
| f"# Довод проверяющего\n{fabrication.get('why', '')}\n\n"
|
| f"# Эталонный ответ\n{reference}\n\n# Отрывки материалов человека и выдачи подключённой системы\n"
|
| + ("\n\n".join(f"## «{name}»\n{chunk}" for name, chunk in found) or "(по словам и числам утверждения ничего не нашлось)")
|
| )
|
| try:
|
| raw, usage = _ask(base_url, model, api_key, VERIFY_SYSTEM, user, VERIFY_SCHEMA, 2000)
|
| except json.JSONDecodeError:
|
| try:
|
| raw, usage = _ask(base_url, model, api_key, VERIFY_SYSTEM + VERIFY_BRIEF, user, VERIFY_SCHEMA, 4000)
|
| except json.JSONDecodeError:
|
| return False, {"verdict": None, "quote": "", "quote_verified": False,
|
| "reasoning": "сверка не дала ответа по форме", "passages": [name for name, _ in found]}, {}
|
| quote = raw.get("quote", "")
|
| sources = reference + "\n" + "\n".join(chunk for _, chunk in found)
|
| confirmed = (raw.get("verdict") == "supported" and len(normalize(quote).strip(" .…")) >= 8 and _quote_found(quote, sources))
|
| return confirmed, {"verdict": raw.get("verdict"), "quote": quote, "quote_verified": confirmed,
|
| "reasoning": raw.get("reasoning", ""), "passages": [name for name, _ in found]}, usage
|
|
|
|
|
| def _add(total: dict, usage: dict) -> None:
|
| for key, value in usage.items():
|
| if isinstance(value, int):
|
| total[key] = total.get(key, 0) + value
|
|
|
|
|
| def judge(task: dict, record: dict, root: Path, base_url: str, model: str, api_key: str = "none", dataset: Path | None = None) -> dict:
|
| output = Output(record, root)
|
| shown, full = _delivery(output)
|
|
|
| rubric = [text for text, _ in rubric_items(task)]
|
| must_not = task.get("must_not", [])
|
| dialog = _dialog(record)
|
| user = (
|
| f"# Просьба и материалы\n{_materials_summary(task)}\n\n"
|
| + (f"# Вопросы системы и ответы человека\n{dialog}\n\n" if dialog else "")
|
| + f"# Эталонный ответ\n{task.get('reference_answer', '(эталона нет — суди по рубрике и материалам)')}\n\n"
|
| "# Рубрика\n" + "\n".join(f"{i}. {item}" for i, item in enumerate(rubric, 1)) + "\n\n"
|
| "# Запрещённые утверждения\n" + ("\n".join(f"{i}. {item}" for i, item in enumerate(must_not, 1)) or "нет") + "\n\n"
|
| f"# Выдача системы\n{shown}"
|
| )
|
| raw, usage = _ask_verdict(base_url, model, api_key, user)
|
| total: dict = {}
|
| _add(total, usage)
|
|
|
| items = []
|
| for i, text in enumerate(rubric, 1):
|
| given = next((r for r in raw.get("rubric", []) if r.get("item") == i), None)
|
| verdict = given["verdict"] if given else "missing"
|
| quote = (given or {}).get("quote", "")
|
| verified = _quote_found(quote, full) if quote else False
|
|
|
|
|
| if (verdict in ("yes", "partial", "wrong") and quote and not verified) or (verdict in ("partial", "wrong") and not quote):
|
| verdict = "missing"
|
| items.append({"item": text, "verdict": verdict, "quote": quote, "quote_verified": verified,
|
| "reasoning": (given or {}).get("reasoning", "")})
|
| quoted = [f for f in raw.get("fabrications", []) if _quote_found(f.get("quote", ""), full)]
|
|
|
|
|
|
|
| fabrications, refuted = [], []
|
| index = (materials_index(task, dataset) + system_outputs(record) + asked_at(record)
|
| if dataset is not None and any(not f.get("must_not") for f in quoted) else [])
|
| for f in quoted:
|
| if f.get("must_not") or dataset is None:
|
| fabrications.append(f)
|
| continue
|
| confirmed, check, usage = verify_fabrication(f, task, index, base_url, model, api_key, started_on(record), full)
|
| _add(total, usage)
|
| (refuted if confirmed else fabrications).append({**f, "verification": check})
|
| return {
|
| "rubric": items,
|
| "fabrications": fabrications,
|
| "refuted_fabrications": refuted,
|
| "discarded_fabrications": [f for f in raw.get("fabrications", []) if f not in quoted],
|
| "usage": total,
|
| }
|
|
|
|
|
| def _env(*names: str) -> str | None:
|
| return next((os.environ[name] for name in names if os.environ.get(name)), None)
|
|
|
|
|
| def model_url(url: str) -> str:
|
| """Адрес модели, достижимый отсюда: в контейнере localhost — сам контейнер, а модель слушает на машине, где он запущен.
|
| Docker Desktop знает её как host.docker.internal, на Linux имя даёт ключ ``--add-host host.docker.internal:host-gateway``."""
|
| if Path("/.dockerenv").exists():
|
| return re.sub(r"^(https?://)(localhost|127\.0\.0\.1|\[::1\])(?=[:/]|$)", r"\1host.docker.internal", url)
|
| return url
|
|
|
|
|
| def add_connection_arguments(parser: argparse.ArgumentParser) -> None:
|
| """Ключи подключения к модели судьи с умолчаниями из окружения (см. начало файла)."""
|
| parser.add_argument("--base-url", default=_env("JUDGE_BASE_URL", "WORKPERMIT_MODEL_URL"),
|
| help="адрес модели, совместимый с OpenAI; по умолчанию JUDGE_BASE_URL или WORKPERMIT_MODEL_URL")
|
| parser.add_argument("--model", default=_env("JUDGE_MODEL", "WORKPERMIT_MODEL"),
|
| help="имя модели; по умолчанию JUDGE_MODEL или WORKPERMIT_MODEL")
|
| parser.add_argument("--api-key", default=_env("JUDGE_API_KEY", "WORKPERMIT_MODEL_KEY") or "none",
|
| help="ключ модели; по умолчанию JUDGE_API_KEY или WORKPERMIT_MODEL_KEY")
|
|
|
|
|
| def check_connection(parser: argparse.ArgumentParser, args: argparse.Namespace) -> None:
|
| if not args.base_url or not args.model:
|
| parser.error("модель судьи не задана: --base-url и --model или переменные WORKPERMIT_MODEL_URL и WORKPERMIT_MODEL")
|
| args.base_url = model_url(args.base_url)
|
|
|
|
|
| def main(argv: list[str]) -> int:
|
| parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
|
| parser.add_argument("tasks")
|
| parser.add_argument("run")
|
| add_connection_arguments(parser)
|
| parser.add_argument("--only", nargs="*", help="имена задач")
|
| args = parser.parse_args(argv[1:])
|
| check_connection(parser, args)
|
|
|
| tasks = {json.loads(line)["id"]: json.loads(line) for line in Path(args.tasks).read_text(encoding="utf-8").splitlines() if line.strip()}
|
| dataset = Path(args.tasks).resolve().parent.parent
|
| failed = []
|
| for task_dir in sorted(p for p in Path(args.run).iterdir() if p.is_dir()):
|
| if args.only is not None and task_dir.name not in args.only:
|
| continue
|
| record_path = task_dir / "record.json"
|
| if not record_path.exists() or task_dir.name not in tasks:
|
| continue
|
| record = json.loads(record_path.read_text(encoding="utf-8"))
|
|
|
| if record.get("status") == "not_run":
|
| continue
|
|
|
| try:
|
| verdict = judge(tasks[task_dir.name], record, task_dir, args.base_url, args.model, args.api_key, dataset)
|
| except Exception as error:
|
| failed.append(task_dir.name)
|
| print(f"{task_dir.name}: СУДЬЯ НЕ ДАЛ ВЕРДИКТА: {type(error).__name__}: {str(error)[:200]}")
|
| continue
|
| (task_dir / "judge.json").write_text(json.dumps(verdict, ensure_ascii=False, indent=1), encoding="utf-8")
|
| verdicts = [r["verdict"] for r in verdict["rubric"]]
|
| print(f"{task_dir.name}: верно {verdicts.count('yes')}/{len(verdicts)}, неверно {verdicts.count('wrong')},"
|
| f" галлюцинаций {len(verdict['fabrications'])} (снято сверкой {len(verdict['refuted_fabrications'])})")
|
| if failed:
|
| print("без вердикта судьи:", ", ".join(failed))
|
| return 1 if failed else 0
|
|
|
|
|
| if __name__ == "__main__":
|
| sys.exit(main(sys.argv))
|
|
|
