"""Train a non-oracle utility writer and evaluate it on natural packages. This is the deployable-writer diagnostic for OracleMem. Training may use oracle coverage labels on train packages, but test-time selection uses only visible candidate metadata through ``EstimatedUtilityModel.predict``. The reported ratios are still scored against exact finite-package optima. """ from __future__ import annotations import argparse from collections import defaultdict import json import math import sys from pathlib import Path from typing import Any, Mapping, Sequence REPO_ROOT = Path(__file__).resolve().parents[1] if str(REPO_ROOT) not in sys.path: sys.path.insert(0, str(REPO_ROOT)) from oraclemem.evaluate import ( LEARNED_ESTIMATOR_PROFILE, LOCAL_LEARNED_ESTIMATOR_MODEL, OracleMemInstance, aggregate_results, evaluate_instance, generate_named_distribution, objective_value, train_feature_utility_estimator, ) from llm_memory_validation.evaluate_human_style_examples import ( build_instance as build_human_instance, evaluate_human_package, load_examples, parse_tokens, ) from llm_memory_validation.run_mem0_natural_baseline import ( load_package, package_instance, resolved_queries, write_json, ) DEFAULT_METHODS = ( "opt", "oracle_gvt", "estimated_gvt", "estimated_utility", "memgpt_tiered", "amem_graph", "amac_admission", "mem0_extract", "density_only", "greedy", "fact_only", "summary_only", "recency_raw", "no_tombstone_opt", ) def build_parser() -> argparse.ArgumentParser: parser = argparse.ArgumentParser( description=( "Train a visible-feature OracleMem utility estimator on synthetic " "and model-annotated natural packages, then test on a human-edited " "finite package with exact OPT scoring." ) ) parser.add_argument( "--human-examples-jsonl", default="llm_memory_validation/human_style_examples/examples_100.jsonl", help="Human-edited JSONL package used for held-out evaluation.", ) parser.add_argument( "--train-natural-package-dir", action="append", default=["llm_memory_validation/oraclemem_natural_200_gemini_v2/coverage_package"], help=( "Natural coverage package directory to use for train labels. " "Can be supplied multiple times. Defaults to Natural-200." ), ) parser.add_argument( "--train-natural-limit", type=int, default=None, help="Optional per-package cap on natural train queries.", ) parser.add_argument( "--natural-train-weight", type=int, default=1, help=( "Integer replication weight for allowed natural train instances. " "This changes estimator fitting only; manifests report weighted and " "unweighted counts." ), ) parser.add_argument( "--tune-natural-train-weight", action="store_true", help=( "Choose natural-train weight and ridge from train-only validation " "labels before fitting the final estimator." ), ) parser.add_argument( "--candidate-natural-train-weights", default="1,2,3,5,8,10,15,20,30,50", help="Comma or space separated natural weights for train-only tuning.", ) parser.add_argument( "--candidate-ridges", default="0.05,0.25,1.0,2.0", help="Comma or space separated ridge values for train-only tuning.", ) parser.add_argument( "--validation-natural-stride", type=int, default=5, help="Use every Nth allowed natural train instance as train-only validation.", ) parser.add_argument( "--validation-synthetic-fraction", type=float, default=0.20, help="Fraction of synthetic train seeds reserved for train-only validation.", ) parser.add_argument( "--validation-synthetic-budgets", default="4,6", help="Synthetic validation budgets used only for hyperparameter selection.", ) parser.add_argument( "--validation-natural-budgets", default="30,60,100", help="Natural validation budgets used only for hyperparameter selection.", ) parser.add_argument( "--n-synthetic-train-seeds", type=int, default=200, help="Use synthetic train seeds 0..N-1. Set 0 to disable synthetic train data.", ) parser.add_argument( "--synthetic-distributions", default="base,update_chain,temporal_interval,scope_shift_v2,density_trap_v2", help="Comma or space separated synthetic train distributions.", ) parser.add_argument( "--normal-count", type=int, default=3, help="Synthetic normal fact count.", ) parser.add_argument( "--update-count", type=int, default=2, help="Synthetic update/tombstone pair count.", ) parser.add_argument( "--budgets", default="150,300,600,1000", help="Comma or space separated held-out test budgets.", ) parser.add_argument( "--methods", default=",".join(DEFAULT_METHODS), help="Comma or space separated evaluation methods.", ) parser.add_argument( "--eval-coverage-package-dir", action="append", default=["llm_memory_validation/natural_adjudicated_100_gemini_flash/coverage_package"], help=( "Held-out coverage package directory to evaluate with exact package OPT. " "Can be supplied multiple times. Defaults to the adjudicated natural package." ), ) parser.add_argument( "--skip-coverage-eval", action="store_true", help="Evaluate only the human-style examples package.", ) parser.add_argument( "--eval-coverage-limit", type=int, default=None, help="Optional per-held-out coverage-package query cap.", ) parser.add_argument( "--eval-coverage-budgets", default="30,60,100", help="Comma or space separated held-out coverage-package budgets.", ) parser.add_argument( "--eval-coverage-methods", default=( "opt,oracle_gvt,estimated_gvt,estimated_utility,memgpt_tiered," "amem_graph,amac_admission,mem0_extract,density_only,summary_only," "fact_only,recency_raw" ), help="Comma or space separated methods for held-out coverage-package evaluation.", ) parser.add_argument( "--allow-natural-train-overlap", action="store_true", help=( "Do not exclude held-out coverage-package query ids from natural train " "packages. The default is safer and excludes overlaps." ), ) parser.add_argument( "--estimator-ridge", type=float, default=0.25, help="Ridge penalty for the visible-feature linear estimator.", ) parser.add_argument( "--estimated-noise-scale", type=float, default=0.0, help="Optional deterministic noise scale applied to learned predictions.", ) parser.add_argument( "--estimated-noise-seed", type=int, default=0, help="Seed for deterministic learned-estimator prediction noise.", ) parser.add_argument( "--out-dir", default="llm_memory_validation/learned_writer_deployable_noapi", help="Output directory.", ) return parser def synthetic_train_instances( *, n_seeds: int, distributions: Sequence[str], normal_count: int, update_count: int, ) -> list[OracleMemInstance]: if n_seeds <= 0: return [] return [ generate_named_distribution( distribution, seed, normal_count=normal_count, update_count=update_count, ) for distribution in distributions for seed in range(n_seeds) ] def natural_train_instances( package_dirs: Sequence[str], *, limit: int | None, exclude_query_ids: set[str] | None = None, ) -> tuple[list[OracleMemInstance], list[dict[str, Any]]]: instances: list[OracleMemInstance] = [] manifest_rows: list[dict[str, Any]] = [] exclude_query_ids = set(exclude_query_ids or ()) for package_dir_text in package_dirs: package_dir = Path(package_dir_text) data = load_package(package_dir) all_queries = resolved_queries(data, limit) excluded = [ query for query in all_queries if str(query.get("query_id", "")) in exclude_query_ids ] queries = [ query for query in all_queries if str(query.get("query_id", "")) not in exclude_query_ids ] before = len(instances) for query in queries: instance = package_instance(data, query) if instance.candidates and any(weight > 0 for weight in instance.unit_weights.values()): instances.append(instance) manifest_rows.append( { "package_dir": str(package_dir), "resolved_queries_before_exclusion": len(all_queries), "excluded_query_ids": sorted(str(query["query_id"]) for query in excluded), "excluded_query_count": len(excluded), "resolved_queries": len(queries), "usable_instances": len(instances) - before, } ) return instances, manifest_rows def coverage_eval_query_ids(package_dirs: Sequence[str], *, limit: int | None) -> dict[str, list[str]]: query_ids: dict[str, list[str]] = {} for package_dir_text in package_dirs: package_dir = Path(package_dir_text) data = load_package(package_dir) query_ids[str(package_dir)] = [ str(query.get("query_id", "")) for query in resolved_queries(data, limit) ] return query_ids def weighted_train_instances( synthetic_instances: Sequence[OracleMemInstance], natural_instances: Sequence[OracleMemInstance], *, natural_weight: int, ) -> list[OracleMemInstance]: weight = max(0, int(natural_weight)) return [*synthetic_instances, *(list(natural_instances) * weight)] def estimator_coefficients(model: Any, limit: int = 25) -> list[dict[str, float | str]]: rows = [ {"feature": name, "weight": float(weight), "abs_weight": abs(float(weight))} for name, weight in zip(model.feature_names, model.weights) ] rows.sort(key=lambda row: (-float(row["abs_weight"]), str(row["feature"]))) return rows[:limit] def write_transfer_report( out_dir: Path, *, train_manifest: Mapping[str, Any], summary: Mapping[str, Any], ) -> None: lines = [ "# Learned Writer Transfer Report", "", "This run trains a local visible-feature utility estimator on train-only oracle labels and evaluates held-out memory-writing decisions against exact finite-package OPT.", "", "## Train Data", "", f"- Synthetic train instances: {train_manifest['synthetic_train_instances']}", f"- Natural train instances: {train_manifest['natural_train_instances']}", f"- Total train instances: {train_manifest['total_train_instances']}", f"- Train candidates: {train_manifest['train_candidate_count']}", f"- Ridge: {train_manifest['estimator_ridge']}", f"- Test package: `{train_manifest['human_examples_jsonl']}`", "", "## Claim Boundary", "", "- Oracle coverage is used to create train labels only.", "- Held-out estimated-writer decisions use visible candidate metadata only.", "- The human-edited test package is schema-valid and exact-scored, but it is not an inter-annotator agreement study.", "", "## Held-Out Package Ratios", "", ] methods = sorted(summary.get("methods", [])) by_budget = {} for row in summary.get("by_budget_method", []): by_budget.setdefault(int(row["budget"]), {})[str(row["method"])] = row for budget in sorted(by_budget): lines.append(f"### Budget {budget}") for method in methods: row = by_budget[budget].get(method) if row is None: continue lines.append( "- `{method}`: ratio_to_opt={ratio:.3f}, objective={objective:.3f}, cost={cost:.1f}".format( method=method, ratio=float(row.get("mean_ratio_to_opt", 0.0)), objective=float(row.get("mean_objective", 0.0)), cost=float(row.get("mean_selected_cost", 0.0)), ) ) lines.append("") (out_dir / "REPORT.md").write_text("\n".join(lines), encoding="utf-8") def main(argv: Sequence[str] | None = None) -> int: args = build_parser().parse_args(argv) out_dir = Path(args.out_dir) out_dir.mkdir(parents=True, exist_ok=True) synthetic_distributions = parse_tokens(args.synthetic_distributions) synthetic_instances = synthetic_train_instances( n_seeds=args.n_synthetic_train_seeds, distributions=synthetic_distributions, normal_count=args.normal_count, update_count=args.update_count, ) natural_instances, natural_manifest = natural_train_instances( args.train_natural_package_dir, limit=args.train_natural_limit, ) train_instances = [*synthetic_instances, *natural_instances] if not train_instances: raise ValueError("at least one synthetic or natural train instance is required") estimator = train_feature_utility_estimator( train_instances, train_distributions=( *(f"synthetic:{name}" for name in synthetic_distributions), *(f"natural:{Path(path).name}" for path in args.train_natural_package_dir), ), train_seeds=tuple(range(max(0, args.n_synthetic_train_seeds))), estimator_model=LOCAL_LEARNED_ESTIMATOR_MODEL, estimator_profile=LEARNED_ESTIMATOR_PROFILE, ridge=args.estimator_ridge, noise_scale=args.estimated_noise_scale, noise_seed=args.estimated_noise_seed, ) human_examples_path = Path(args.human_examples_jsonl) human_rows = load_examples(human_examples_path) human_instance = build_human_instance(human_rows) budgets = tuple(int(token) for token in parse_tokens(args.budgets)) methods = parse_tokens(args.methods) results = evaluate_human_package( human_instance, budgets, methods, estimator_model=estimator.estimator_model, estimator_profile=estimator.estimator_profile, estimator_state=estimator, ) paths = write_benchmark_outputs(results, out_dir) write_human_report(out_dir, human_examples_path, human_rows, results) train_manifest = { "human_examples_jsonl": str(human_examples_path), "synthetic_train_distributions": list(synthetic_distributions), "synthetic_train_seeds": list(range(max(0, args.n_synthetic_train_seeds))), "synthetic_train_instances": len(synthetic_instances), "natural_train_packages": natural_manifest, "natural_train_instances": len(natural_instances), "total_train_instances": len(train_instances), "train_candidate_count": sum(len(instance.candidates) for instance in train_instances), "estimator_model": estimator.estimator_model, "estimator_profile": estimator.estimator_profile, "estimator_ridge": args.estimator_ridge, "estimated_noise_scale": args.estimated_noise_scale, "estimated_noise_seed": args.estimated_noise_seed, "top_coefficients": estimator_coefficients(estimator), "decision_features": "visible candidate metadata only at held-out test time", "oracle_coverage_used_for_training": True, "oracle_coverage_used_for_test_decision": False, **paths, } write_json(out_dir / "train_manifest.json", train_manifest) summary = json.loads((out_dir / "summary.json").read_text(encoding="utf-8")) write_transfer_report(out_dir, train_manifest=train_manifest, summary=summary) print(json.dumps(train_manifest, indent=2, sort_keys=True)) return 0 if __name__ == "__main__": raise SystemExit(main())