import argparse import csv import json from collections import Counter, defaultdict from pathlib import Path ROOT_DIR = Path(__file__).resolve().parent.parent DEFAULT_GT_FILE = ROOT_DIR / "knowledgeBase" / "test_Bench.json" DEFAULT_OUTPUT_ROOT = ROOT_DIR / "results" MODELS = [ "qwen3.6-max", "qwen_plus", "deepseek_v3", "deepseek_r1", "llama4_scout", ] SETTINGS = ["raw_logs_context", "static_kb", "full_kb"] MODEL_DISPLAY = { "qwen3.6-max": "Qwen3.6-Max", "qwen_plus": "Qwen-Plus", "deepseek_v3": "DeepSeek-V3", "deepseek_r1": "DeepSeek-R1", "llama4_scout": "Llama4-scout", } SETTING_DISPLAY = { "raw_logs_context": "w/o KB", "static_kb": "w/ Static KB", "full_kb": "w/ KB", } def load_json(path): with open(path, "r", encoding="utf-8") as f: return json.load(f) def calculate_metrics(tp, fp, tn, fn): precision = tp / (tp + fp) if (tp + fp) > 0 else 0.0 recall = tp / (tp + fn) if (tp + fn) > 0 else 0.0 f1 = 2 * precision * recall / (precision + recall) if (precision + recall) > 0 else 0.0 total = tp + fp + tn + fn accuracy = (tp + tn) / total if total > 0 else 0.0 specificity = tn / (tn + fp) if (tn + fp) > 0 else 0.0 return { "precision": precision, "recall": recall, "f1": f1, "accuracy": accuracy, "specificity": specificity, } def result_path(output_root, setting, model): return output_root / setting / f"experiment_{model}_{setting}.json" def evaluate_file(gt_data, pred_data): gt_map = {item["id"]: item for item in gt_data} expected_ids = [item["id"] for item in gt_data] expected_set = set(expected_ids) stats = Counter({"TP": 0, "FP": 0, "TN": 0, "FN": 0}) cat_stats = defaultdict(lambda: Counter({"TP": 0, "FP": 0, "TN": 0, "FN": 0})) processed_ids = set() errors = [] extra_ids = [] input_mismatches = [] for pred_item in pred_data: pred_id = pred_item.get("id") if pred_id not in gt_map: extra_ids.append(pred_id) continue processed_ids.add(pred_id) gt_item = gt_map[pred_id] if pred_item.get("input_time") != gt_item.get("time"): input_mismatches.append(pred_id) elif pred_item.get("input_location") != gt_item.get("location"): input_mismatches.append(pred_id) elif pred_item.get("input_event") != gt_item.get("event"): input_mismatches.append(pred_id) if "error" in pred_item: errors.append(pred_id) y_pred = False else: y_pred = pred_item.get("proactive") if not isinstance(y_pred, bool): y_pred = False y_true = bool(gt_item.get("proactive")) category = gt_item.get("category", "Unknown") if y_true and y_pred: result = "TP" elif not y_true and y_pred: result = "FP" elif y_true and not y_pred: result = "FN" else: result = "TN" stats[result] += 1 cat_stats[category][result] += 1 missing_ids = [item_id for item_id in expected_ids if item_id not in processed_ids] duplicate_ids = [ item_id for item_id, count in Counter(item.get("id") for item in pred_data).items() if item_id in expected_set and count > 1 ] order_mismatch = sum( 1 for pred_id, expected_id in zip([item.get("id") for item in pred_data], expected_ids) if pred_id != expected_id ) + abs(len(pred_data) - len(expected_ids)) return { "stats": stats, "cat_stats": cat_stats, "n_records": len(pred_data), "n_errors": len(errors), "n_missing": len(missing_ids), "n_extra": len(extra_ids), "n_duplicates": len(duplicate_ids), "order_mismatch": order_mismatch, "n_input_mismatch": len(input_mismatches), "error_ids": errors, "missing_ids": missing_ids, "duplicate_ids": duplicate_ids, "extra_ids": extra_ids, "input_mismatch_ids": input_mismatches, } def write_csv(path, rows, fieldnames): path.parent.mkdir(parents=True, exist_ok=True) with open(path, "w", newline="", encoding="utf-8") as f: writer = csv.DictWriter(f, fieldnames=fieldnames) writer.writeheader() writer.writerows(rows) def evaluate_all(args): gt_data = load_json(args.gt_file) output_root = Path(args.output_root) overall_rows = [] category_rows = [] structure_rows = [] models = args.models or MODELS settings = args.settings or SETTINGS for setting in settings: for model in models: path = result_path(output_root, setting, model) if not path.exists(): structure_rows.append( { "setting": setting, "setting_display": SETTING_DISPLAY.get(setting, setting), "model": model, "model_display": MODEL_DISPLAY.get(model, model), "exists": False, "records": 0, "errors": "", "missing": "", "extra": "", "duplicates": "", "order_mismatch": "", "input_mismatch": "", "path": str(path), } ) continue pred_data = load_json(path) result = evaluate_file(gt_data, pred_data) stats = result["stats"] metrics = calculate_metrics(stats["TP"], stats["FP"], stats["TN"], stats["FN"]) overall_rows.append( { "setting": setting, "setting_display": SETTING_DISPLAY.get(setting, setting), "model": model, "model_display": MODEL_DISPLAY.get(model, model), "TP": stats["TP"], "FP": stats["FP"], "TN": stats["TN"], "FN": stats["FN"], "precision": metrics["precision"], "recall": metrics["recall"], "f1": metrics["f1"], "accuracy": metrics["accuracy"], "specificity": metrics["specificity"], "records": result["n_records"], "errors": result["n_errors"], } ) structure_rows.append( { "setting": setting, "setting_display": SETTING_DISPLAY.get(setting, setting), "model": model, "model_display": MODEL_DISPLAY.get(model, model), "exists": True, "records": result["n_records"], "errors": result["n_errors"], "missing": result["n_missing"], "extra": result["n_extra"], "duplicates": result["n_duplicates"], "order_mismatch": result["order_mismatch"], "input_mismatch": result["n_input_mismatch"], "path": str(path), } ) for category, cat_counter in sorted(result["cat_stats"].items()): cat_metrics = calculate_metrics( cat_counter["TP"], cat_counter["FP"], cat_counter["TN"], cat_counter["FN"], ) category_rows.append( { "setting": setting, "setting_display": SETTING_DISPLAY.get(setting, setting), "model": model, "model_display": MODEL_DISPLAY.get(model, model), "category": category, "TP": cat_counter["TP"], "FP": cat_counter["FP"], "TN": cat_counter["TN"], "FN": cat_counter["FN"], "precision": cat_metrics["precision"], "recall": cat_metrics["recall"], "f1": cat_metrics["f1"], "accuracy": cat_metrics["accuracy"], "specificity": cat_metrics["specificity"], } ) metrics_dir = output_root / "metrics" overall_path = metrics_dir / "overall_metrics.csv" category_path = metrics_dir / "category_metrics.csv" structure_path = metrics_dir / "structure_audit.csv" write_csv( overall_path, overall_rows, [ "setting", "setting_display", "model", "model_display", "TP", "FP", "TN", "FN", "precision", "recall", "f1", "accuracy", "specificity", "records", "errors", ], ) write_csv( category_path, category_rows, [ "setting", "setting_display", "model", "model_display", "category", "TP", "FP", "TN", "FN", "precision", "recall", "f1", "accuracy", "specificity", ], ) write_csv( structure_path, structure_rows, [ "setting", "setting_display", "model", "model_display", "exists", "records", "errors", "missing", "extra", "duplicates", "order_mismatch", "input_mismatch", "path", ], ) print(f"Wrote overall metrics: {overall_path}") print(f"Wrote category metrics: {category_path}") print(f"Wrote structure audit: {structure_path}") print("\nOverall metrics:") for row in overall_rows: print( f"{row['setting']:<16} {row['model']:<14} " f"P={row['precision']:.3f} R={row['recall']:.3f} " f"F1={row['f1']:.3f} Acc={row['accuracy']:.3f} " f"TP={row['TP']} FP={row['FP']} TN={row['TN']} FN={row['FN']}" ) bad_structure = [ row for row in structure_rows if row["exists"] is not True or row["records"] != len(gt_data) or row["errors"] not in {0, ""} or row["missing"] not in {0, ""} or row["extra"] not in {0, ""} or row["duplicates"] not in {0, ""} or row["order_mismatch"] not in {0, ""} or row["input_mismatch"] not in {0, ""} ] if bad_structure: print("\nStructure warnings:") for row in bad_structure: print(row) else: print("\nStructure check: all files are complete, sorted, and error-free.") def parse_args(): parser = argparse.ArgumentParser(description="Evaluate HomeActEval proactive results.") parser.add_argument("--gt-file", default=str(DEFAULT_GT_FILE)) parser.add_argument("--output-root", default=str(DEFAULT_OUTPUT_ROOT)) parser.add_argument("--models", nargs="*", choices=MODELS) parser.add_argument("--settings", nargs="*", choices=SETTINGS) return parser.parse_args() if __name__ == "__main__": evaluate_all(parse_args())