| import argparse |
| import json |
| import os |
| import re |
| import time |
| import urllib.error |
| import urllib.parse |
| import urllib.request |
| from pathlib import Path |
|
|
| from tqdm import tqdm |
|
|
|
|
| ROOT = Path(__file__).resolve().parents[1] |
| DEFAULT_MODELS = [ |
| "qwen3.6-max", |
| "qwen_plus", |
| "deepseek_v3", |
| "deepseek_r1", |
| "llama4_scout", |
| ] |
| DEFAULT_SETTINGS = ["raw_logs_context", "static_kb", "full_kb"] |
|
|
|
|
| REFERENCE_ID_PATTERN = re.compile(r"\b([RH])(\d{3})(?:\s*-\s*(?:[RH])?(\d{3}))?\b") |
|
|
|
|
| def load_json(path): |
| path = Path(path) |
| if not path.exists(): |
| raise FileNotFoundError(path) |
| return json.loads(path.read_text(encoding="utf-8")) |
|
|
|
|
| def save_json(data, path): |
| path = Path(path) |
| path.parent.mkdir(parents=True, exist_ok=True) |
| tmp_path = path.with_suffix(path.suffix + ".tmp") |
| tmp_path.write_text(json.dumps(data, indent=2, ensure_ascii=False), encoding="utf-8") |
| tmp_path.replace(path) |
|
|
|
|
| def build_gt_map(gt_data): |
| return { |
| item["id"]: { |
| "proactive": bool(item["proactive"]), |
| "category": item.get("category", "Unknown"), |
| "time": item.get("time", "Unknown"), |
| "location": item.get("location", "Unknown"), |
| "event": item.get("event", ""), |
| "reason": item.get("reason", ""), |
| } |
| for item in gt_data |
| } |
|
|
|
|
| def determine_case_type(gt_proactive, agent_proactive): |
| if gt_proactive and agent_proactive: |
| return "TP" |
| if gt_proactive and not agent_proactive: |
| return "FN" |
| if not gt_proactive and not agent_proactive: |
| return "TN" |
| return "FP" |
|
|
|
|
| def coerce_bool(value): |
| if isinstance(value, bool): |
| return value |
| if isinstance(value, str): |
| return value.strip().lower() in {"true", "yes", "1"} |
| return bool(value) |
|
|
|
|
| def normalize_reference_id(prefix, number): |
| return f"{prefix}{int(number):03d}" |
|
|
|
|
| def extract_reference_ids(text): |
| ids = [] |
| for match in REFERENCE_ID_PATTERN.finditer(str(text or "")): |
| prefix = match.group(1) |
| start = int(match.group(2)) |
| end = int(match.group(3)) if match.group(3) else start |
| if end < start or end - start > 20: |
| end = start |
| for number in range(start, end + 1): |
| ids.append(normalize_reference_id(prefix, number)) |
| return list(dict.fromkeys(ids)) |
|
|
|
|
| def get_entry_id(entry): |
| if not isinstance(entry, dict): |
| return None |
| return entry.get("rule_id") or entry.get("habit_id") or entry.get("id") |
|
|
|
|
| def build_kb_index(entries): |
| index = {} |
| for entry in entries or []: |
| entry_id = get_entry_id(entry) |
| if entry_id: |
| index[str(entry_id)] = entry |
| return index |
|
|
|
|
| def select_relevant_references(reference_rationale, static_kb, habit_kb): |
| ids = extract_reference_ids(reference_rationale) |
| static_index = build_kb_index(static_kb) |
| habit_index = build_kb_index(habit_kb) |
| static_refs = [] |
| habit_refs = [] |
| missing_refs = [] |
|
|
| for ref_id in ids: |
| if ref_id.startswith("R"): |
| entry = static_index.get(ref_id) |
| if entry: |
| static_refs.append(entry) |
| else: |
| missing_refs.append(ref_id) |
| elif ref_id.startswith("H"): |
| entry = habit_index.get(ref_id) |
| if entry: |
| habit_refs.append(entry) |
| else: |
| missing_refs.append(ref_id) |
|
|
| return { |
| "reference_ids": ids, |
| "static_refs": static_refs, |
| "habit_refs": habit_refs, |
| "missing_refs": missing_refs, |
| } |
|
|
|
|
| def format_reference_snippets(refs): |
| if not refs: |
| return "None explicitly referenced by the benchmark rationale." |
| return json.dumps(refs, indent=2, ensure_ascii=False) |
|
|
|
|
| def automatic_evaluation(case_type, context): |
| if case_type == "FN": |
| return { |
| "rationale_match": "none", |
| "basis_grounding": "missing", |
| "missing_key_elements": ["required proactive response was not generated"], |
| "reasoning": ( |
| "Failure: the agent remained silent even though intervention was required. " |
| f"Context: {context['time']} at {context['location']}; {context['event']} " |
| f"Reference rationale: {context['reference_rationale']}" |
| ), |
| "correctness": 0, |
| "contextual_relevance": 0, |
| "clarity": 0, |
| "case_type": "FN", |
| "average_score": 0.0, |
| } |
| if case_type == "TN": |
| return { |
| "rationale_match": "not_applicable", |
| "basis_grounding": "not_applicable", |
| "missing_key_elements": [], |
| "reasoning": ( |
| "Success: the agent correctly remained silent for a normal event. " |
| f"Reference rationale: {context['reference_rationale']}" |
| ), |
| "correctness": 100, |
| "contextual_relevance": 100, |
| "clarity": 100, |
| "case_type": "TN", |
| "average_score": 100.0, |
| } |
| raise ValueError(f"Automatic scoring is only defined for FN/TN, got {case_type}") |
|
|
|
|
| def build_judge_prompt(context, proposed_action, decision_basis, references, case_type, setting): |
| reference_ids = ", ".join(references["reference_ids"]) if references["reference_ids"] else "None" |
| missing_refs = ", ".join(references["missing_refs"]) if references["missing_refs"] else "None" |
| current_decision = "proactive interaction required" if context["gt_proactive"] else "no proactive interaction required" |
|
|
| if case_type == "TP": |
| case_guidance = """ |
| Case note: |
| - Intervention is required. |
| - Reward responses that identify the trigger, stay grounded in the provided event and snippets, |
| and offer a concrete next step. |
| - Penalize generic, unsupported, or hallucinated explanations. |
| """ |
| elif case_type == "FP": |
| case_guidance = """ |
| Case note: |
| - No intervention is needed. |
| - Penalize unnecessary interruptions, especially when they invent a hazard, rule, habit, deadline, |
| or user need. |
| - A fluent warning is still low quality if it is unnecessary. |
| """ |
| else: |
| raise ValueError(f"LLM judging is only defined for TP/FP, got {case_type}") |
|
|
| prompt = f""" |
| You are an evaluator of proactive smart-home response quality. |
| |
| Role: Judge whether one generated response is correct, contextually grounded, and clear. |
| Input: The current event, the reference rationale, the agent output, the agent setting, and the |
| relevant static-rule / habit snippets. |
| Constraint: Use only the provided information. Do not infer extra rules, habits, devices, user |
| states, or deadlines. |
| |
| Current event: |
| - Time: {context['time']} |
| - Location: {context['location']} |
| - Event: {context['event']} |
| |
| Ground-truth reference (benchmark target and rationale): |
| - Required decision: {current_decision} |
| - Benchmark category: {context['category']} |
| - Reference rationale: {context['reference_rationale']} |
| |
| Agent output (the response being evaluated): |
| - proactive: true |
| - proposed_action: {proposed_action if proposed_action else "[empty]"} |
| - decision_basis: {decision_basis if decision_basis else "[empty]"} |
| |
| Relevant evidence (retrieved IDs and snippets shown to the judge): |
| - Reference IDs: {reference_ids} |
| - Missing IDs: {missing_refs} |
| |
| Relevant static-rule snippets: |
| {format_reference_snippets(references["static_refs"])} |
| |
| Relevant habit snippets: |
| {format_reference_snippets(references["habit_refs"])} |
| |
| Scoring: |
| - Correctness: alignment with the reference rationale, the current event, and the relevant snippets. |
| - Contextual Relevance: use of the specific time, location, observed activity, and contextual cues. |
| - Clarity: whether the user-facing action is concise, understandable, polite, and actionable. |
| - Give high scores only when the response is well grounded in the provided evidence. |
| - Penalize generic, unsupported, or hallucinated claims. |
| |
| {case_guidance} |
| |
| Return strict JSON only: |
| {{ |
| "rationale_match": "exact | partial | weak | none | not_applicable", |
| "basis_grounding": "supported | partially_supported | unsupported | missing | not_applicable", |
| "missing_key_elements": ["short labels for omitted trigger details, or []"], |
| "reasoning": "Briefly justify the scores using the reference rationale, proposed_action, decision_basis, and relevant snippets.", |
| "correctness": <integer 0-100>, |
| "contextual_relevance": <integer 0-100>, |
| "clarity": <integer 0-100> |
| }} |
| """ |
| return prompt |
|
|
|
|
| def parse_int_score(value): |
| try: |
| return int(round(float(value))) |
| except Exception: |
| return 0 |
|
|
|
|
| def parse_string_list(value): |
| if isinstance(value, list): |
| return [str(item) for item in value] |
| if value in {None, ""}: |
| return [] |
| return [str(value)] |
|
|
|
|
| def parse_scores(payload, case_type): |
| scores = { |
| "rationale_match": str(payload.get("rationale_match", "not_applicable")), |
| "basis_grounding": str(payload.get("basis_grounding", "not_applicable")), |
| "missing_key_elements": parse_string_list(payload.get("missing_key_elements", [])), |
| "reasoning": str(payload.get("reasoning", "")), |
| "correctness": parse_int_score(payload.get("correctness", 0)), |
| "contextual_relevance": parse_int_score( |
| payload.get("contextual_relevance", payload.get("contextual_alignment", 0)) |
| ), |
| "clarity": parse_int_score(payload.get("clarity", 0)), |
| "case_type": case_type, |
| } |
| for key in ("correctness", "contextual_relevance", "clarity"): |
| scores[key] = max(0, min(100, scores[key])) |
| scores["average_score"] = round( |
| (scores["correctness"] + scores["contextual_relevance"] + scores["clarity"]) / 3, |
| 2, |
| ) |
| return scores |
|
|
|
|
| def parse_json_text(text): |
| text = str(text or "").strip() |
| try: |
| return json.loads(text) |
| except json.JSONDecodeError: |
| pass |
|
|
| fence_match = re.search(r"```(?:json)?\s*(.*?)```", text, re.DOTALL | re.IGNORECASE) |
| if fence_match: |
| fenced = fence_match.group(1).strip() |
| try: |
| return json.loads(fenced) |
| except json.JSONDecodeError: |
| pass |
|
|
| start = text.find("{") |
| end = text.rfind("}") |
| if start != -1 and end != -1 and end > start: |
| return json.loads(text[start : end + 1]) |
|
|
| raise json.JSONDecodeError("No JSON object found in judge response", text, 0) |
|
|
|
|
| def judge_with_openai(client, judge_model, prompt, use_json_mode): |
| request_kwargs = { |
| "model": judge_model, |
| "messages": [ |
| {"role": "system", "content": "You are a fair evaluator. Return JSON only."}, |
| {"role": "user", "content": prompt}, |
| ], |
| "temperature": 0.0, |
| } |
| if use_json_mode: |
| request_kwargs["response_format"] = {"type": "json_object"} |
|
|
| response = client.chat.completions.create(**request_kwargs) |
| return parse_json_text(response.choices[0].message.content) |
|
|
|
|
| def judge_with_gemini(client_config, judge_model, prompt, use_json_mode): |
| base_url = client_config["base_url"].rstrip("/") |
| model_path = urllib.parse.quote(judge_model, safe="") |
| url = f"{base_url}/v1beta/models/{model_path}:generateContent" |
|
|
| generation_config = {"temperature": 0.0} |
| if use_json_mode: |
| generation_config["responseMimeType"] = "application/json" |
|
|
| payload = { |
| "systemInstruction": { |
| "parts": [{"text": "You are a fair evaluator. Return JSON only."}] |
| }, |
| "contents": [ |
| { |
| "role": "user", |
| "parts": [{"text": prompt}], |
| } |
| ], |
| "generationConfig": generation_config, |
| } |
| request = urllib.request.Request( |
| url, |
| data=json.dumps(payload, ensure_ascii=False).encode("utf-8"), |
| headers={ |
| "Content-Type": "application/json", |
| "X-goog-api-key": client_config["api_key"], |
| }, |
| method="POST", |
| ) |
| try: |
| with urllib.request.urlopen(request, timeout=180) as response: |
| response_payload = json.loads(response.read().decode("utf-8")) |
| except urllib.error.HTTPError as exc: |
| body = exc.read().decode("utf-8", errors="replace") |
| raise RuntimeError(f"Gemini HTTP {exc.code} at {url}: {body}") from exc |
|
|
| try: |
| text = response_payload["candidates"][0]["content"]["parts"][0]["text"] |
| except Exception as exc: |
| raise RuntimeError(f"Unexpected Gemini response: {response_payload}") from exc |
| return parse_json_text(text) |
|
|
|
|
| def judge_with_anthropic(client_config, judge_model, prompt, use_json_mode): |
| del use_json_mode |
|
|
| base_url = client_config["base_url"].rstrip("/") |
| url = f"{base_url}/v1/messages" |
|
|
| payload = { |
| "model": judge_model, |
| "max_tokens": 2048, |
| "system": "You are a fair evaluator. Return JSON only.", |
| "messages": [ |
| { |
| "role": "user", |
| "content": prompt, |
| } |
| ], |
| } |
| request = urllib.request.Request( |
| url, |
| data=json.dumps(payload, ensure_ascii=False).encode("utf-8"), |
| headers={ |
| "Content-Type": "application/json", |
| "x-api-key": client_config["api_key"], |
| "anthropic-version": "2023-06-01", |
| }, |
| method="POST", |
| ) |
|
|
| try: |
| with urllib.request.urlopen(request, timeout=180) as response: |
| response_payload = json.loads(response.read().decode("utf-8")) |
| except urllib.error.HTTPError as exc: |
| body = exc.read().decode("utf-8", errors="replace") |
| raise RuntimeError(f"Anthropic HTTP {exc.code} at {url}: {body}") from exc |
|
|
| try: |
| content_blocks = response_payload["content"] |
| text = "\n".join( |
| block["text"] |
| for block in content_blocks |
| if isinstance(block, dict) and block.get("type") == "text" and "text" in block |
| ) |
| except Exception as exc: |
| raise RuntimeError(f"Unexpected Anthropic response: {response_payload}") from exc |
| return parse_json_text(text) |
|
|
|
|
| def judge_with_llm(client, judge_model, prompt, use_json_mode=True, max_retries=3, sleep_seconds=2.0): |
| last_error = None |
| for attempt in range(1, max_retries + 1): |
| try: |
| if isinstance(client, dict): |
| if client.get("api_format") == "gemini": |
| return judge_with_gemini(client, judge_model, prompt, use_json_mode) |
| if client.get("api_format") == "anthropic": |
| return judge_with_anthropic(client, judge_model, prompt, use_json_mode) |
| return judge_with_openai(client, judge_model, prompt, use_json_mode) |
| except Exception as exc: |
| last_error = exc |
| if attempt < max_retries: |
| time.sleep(sleep_seconds) |
| raise RuntimeError(last_error) |
|
|
|
|
| def is_done(item, retry_errors): |
| evaluation = item.get("evaluation") |
| if not evaluation: |
| return False |
| if retry_errors and evaluation.get("case_type") == "ERROR": |
| return False |
| return True |
|
|
|
|
| def evaluate_file(args, client, static_kb, habit_kb, gt_map, model, setting): |
| input_path = args.output_root / setting / f"experiment_{model}_{setting}.json" |
| output_path = args.output_root / args.score_dir / setting / f"experiment_{model}_{setting}_scored.json" |
|
|
| input_data = load_json(input_path) |
| existing = [] |
| if args.resume and not args.force and output_path.exists(): |
| existing = load_json(output_path) |
|
|
| existing_by_id = {item.get("id"): item for item in existing if item.get("id")} |
| final_results = [] |
| for item in input_data: |
| old_item = existing_by_id.get(item.get("id")) |
| if old_item and is_done(old_item, args.retry_errors): |
| final_results.append(old_item) |
| else: |
| final_results.append(item.copy()) |
|
|
| pending_indices = [ |
| idx |
| for idx, item in enumerate(final_results) |
| if not is_done(item, args.retry_errors) |
| ] |
| if args.limit is not None: |
| pending_indices = pending_indices[: args.limit] |
|
|
| print(f"{model}/{setting}: {len(final_results)} items, {len(pending_indices)} pending") |
|
|
| for idx in tqdm(pending_indices, desc=f"{model}/{setting}"): |
| item = final_results[idx] |
| item_id = item.get("id") |
| gt_info = gt_map.get(item_id) |
| if not gt_info: |
| item["evaluation"] = { |
| "rationale_match": "not_applicable", |
| "basis_grounding": "not_applicable", |
| "missing_key_elements": [], |
| "reasoning": f"No ground-truth item found for {item_id}.", |
| "correctness": 0, |
| "contextual_relevance": 0, |
| "clarity": 0, |
| "case_type": "ERROR", |
| "average_score": 0.0, |
| } |
| save_json(final_results, output_path) |
| continue |
|
|
| context = { |
| "time": gt_info["time"], |
| "location": gt_info["location"], |
| "event": gt_info["event"], |
| "category": gt_info["category"], |
| "reference_rationale": gt_info["reason"], |
| "gt_proactive": gt_info["proactive"], |
| } |
| gt_proactive = gt_info["proactive"] |
| agent_proactive = coerce_bool(item.get("proactive", False)) |
| case_type = determine_case_type(gt_proactive, agent_proactive) |
|
|
| try: |
| if case_type in {"FN", "TN"}: |
| evaluation = automatic_evaluation(case_type, context) |
| else: |
| references = select_relevant_references( |
| context["reference_rationale"], |
| static_kb, |
| habit_kb, |
| ) |
| prompt = build_judge_prompt( |
| context=context, |
| proposed_action=item.get("proposed_action", ""), |
| decision_basis=item.get("decision_basis", ""), |
| references=references, |
| case_type=case_type, |
| setting=setting, |
| ) |
| payload = judge_with_llm( |
| client, |
| args.judge_model, |
| prompt, |
| use_json_mode=not args.disable_json_mode, |
| ) |
| evaluation = parse_scores(payload, case_type) |
| except Exception as exc: |
| evaluation = { |
| "rationale_match": "not_applicable", |
| "basis_grounding": "not_applicable", |
| "missing_key_elements": [], |
| "reasoning": f"Judge error: {exc}", |
| "correctness": 0, |
| "contextual_relevance": 0, |
| "clarity": 0, |
| "case_type": "ERROR", |
| "average_score": 0.0, |
| } |
|
|
| result_item = item.copy() |
| result_item["category"] = gt_info["category"] |
| result_item["reference_rationale"] = gt_info["reason"] |
| result_item["context_info"] = context |
| result_item["gt_proactive"] = gt_proactive |
| result_item["reference_ids"] = extract_reference_ids(gt_info["reason"]) |
| result_item["judge_model"] = args.judge_model |
| result_item["judge_api_format"] = args.api_format |
| result_item["evaluation"] = evaluation |
| final_results[idx] = result_item |
| save_json(final_results, output_path) |
|
|
| save_json(final_results, output_path) |
| return output_path |
|
|
|
|
| def parse_args(): |
| parser = argparse.ArgumentParser(description="Score HomeActEval proactive outputs with a strict GPT judge.") |
| parser.add_argument("--output-root", type=Path, default=ROOT / "results") |
| parser.add_argument( |
| "--score-dir", |
| default="quality_score_strict", |
| help="Directory under output-root for scored files.", |
| ) |
| parser.add_argument("--models", nargs="+", default=DEFAULT_MODELS) |
| parser.add_argument("--settings", nargs="+", default=DEFAULT_SETTINGS) |
| parser.add_argument("--gt-file", type=Path, default=ROOT / "knowledgeBase" / "test_Bench.json") |
| parser.add_argument("--static-kb", type=Path, default=ROOT / "knowledgeBase" / "staticKB.json") |
| parser.add_argument( |
| "--habit-kb", |
| type=Path, |
| default=ROOT / "knowledgeBase" / "habit_GT.json", |
| help=( |
| "Habit reference file for judging. Defaults to habit_GT.json because " |
| "benchmark rationales are checked against the GT habit IDs." |
| ), |
| ) |
| parser.add_argument("--judge-model", default=os.getenv("QUALITY_JUDGE_MODEL", "gpt-4o")) |
| parser.add_argument( |
| "--base-url", |
| default=os.getenv("OPENAI_BASE_URL", "https://api.openai.com/v1"), |
| help="Judge API base URL. Defaults to the official OpenAI endpoint.", |
| ) |
| parser.add_argument( |
| "--api-format", |
| choices=["auto", "openai", "gemini", "anthropic"], |
| default="auto", |
| help=( |
| "Judge API protocol. Use openai for chat.completions-compatible endpoints, " |
| "gemini for native Gemini generateContent endpoints, and anthropic for " |
| "Anthropic Messages API endpoints. In auto mode, URLs containing /google " |
| "use gemini and URLs containing /anthropic use anthropic." |
| ), |
| ) |
| parser.add_argument( |
| "--api-key-env", |
| default="OPENAI_API_KEY", |
| help="Environment variable containing the API key.", |
| ) |
| parser.add_argument( |
| "--disable-json-mode", |
| action="store_true", |
| help="Do not request provider-side JSON mode; still parses JSON from the text response.", |
| ) |
| parser.add_argument("--resume", action="store_true", help="Resume existing scored files.") |
| parser.add_argument("--retry-errors", action="store_true", help="Retry items marked as ERROR.") |
| parser.add_argument("--force", action="store_true", help="Re-score all items, ignoring existing scored files.") |
| parser.add_argument("--limit", type=int, default=None, help="Optional per-file item limit for testing.") |
| return parser.parse_args() |
|
|
|
|
| def main(): |
| args = parse_args() |
| if args.api_format == "auto": |
| base_url_text = str(args.base_url or "").rstrip("/").lower() |
| if base_url_text.endswith("/google"): |
| args.api_format = "gemini" |
| elif base_url_text.endswith("/anthropic"): |
| args.api_format = "anthropic" |
| else: |
| args.api_format = "openai" |
|
|
| api_key = os.getenv(args.api_key_env) |
| if not api_key: |
| raise RuntimeError(f"Missing API key environment variable: {args.api_key_env}") |
|
|
| print(f"Judge API format: {args.api_format}") |
| print(f"Judge model: {args.judge_model}") |
| print(f"Judge base URL: {args.base_url or '[OpenAI SDK default]'}") |
|
|
| if args.api_format in {"gemini", "anthropic"}: |
| if not args.base_url: |
| raise RuntimeError(f"--base-url is required when --api-format {args.api_format} is used.") |
| client = { |
| "api_format": args.api_format, |
| "api_key": api_key, |
| "base_url": str(args.base_url), |
| } |
| else: |
| try: |
| from openai import OpenAI |
| except ImportError as exc: |
| raise RuntimeError( |
| "The openai package is required for OpenAI-compatible judging. " |
| "Install it in the active environment before running quality assessment." |
| ) from exc |
|
|
| client_kwargs = {"api_key": api_key} |
| if args.base_url: |
| client_kwargs["base_url"] = args.base_url |
| client = OpenAI(**client_kwargs) |
|
|
| static_kb = load_json(args.static_kb) |
| habit_kb = load_json(args.habit_kb) |
| gt_map = build_gt_map(load_json(args.gt_file)) |
|
|
| outputs = [] |
| for setting in args.settings: |
| for model in args.models: |
| outputs.append(evaluate_file(args, client, static_kb, habit_kb, gt_map, model, setting)) |
|
|
| print("Scored files:") |
| for path in outputs: |
| print(path) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
