modelclinic-experiment-001 / code /src /experiment_001b_runner.py
PratikBuilds's picture
Publish initial ModelClinic Experiment 001 archive
87cc7f2 verified
Raw History Blame Contribute Delete
27.4 kB
"""Pure planning and split checks for the Modal Experiment 001B runner."""
from __future__ import annotations
import hashlib
import json
import math
from pathlib import Path
from typing import Iterable, Mapping, Sequence
CONDITIONS = (
"base",
"edited",
"published_constant",
"independent_constant",
"norm_matched_random",
"rank1_activation_dependent",
)
EXPLORATORY_PUBLISHED_JOINT_MEAN = "published_constant_joint_signed_mean_exploratory"
EXPLORATORY_CONDITIONS = (EXPLORATORY_PUBLISHED_JOINT_MEAN,)
EXPLORATORY_CANDIDATE_IDS = {
EXPLORATORY_PUBLISHED_JOINT_MEAN: "published_constant__joint_signed_mean",
}
PRIMARY_SAMPLING = {
"temperature": 0.6,
"top_p": 0.95,
"top_k": 20,
"presence_penalty": 1.5,
}
MAX_NEW_TOKENS = 32768
MAX_GENERATION_SECONDS = 1500
FUNCTION_TIMEOUT_SECONDS = 1800
# Conservative blended cap based on prior Modal A10 GPU + CPU + memory usage.
CONSERVATIVE_A10_ALL_IN_USD_PER_HOUR = 2.0
def sha256_bytes(data: bytes) -> str:
return hashlib.sha256(data).hexdigest()
def parse_jsonl_bytes(raw: bytes, *, label: str = "JSONL") -> list[dict]:
rows = []
for line_no, line in enumerate(raw.splitlines(), start=1):
if not line.strip():
continue
try:
item = json.loads(line)
except json.JSONDecodeError as exc:
raise ValueError(f"{label} line {line_no} is invalid JSON: {exc}") from exc
if not isinstance(item, dict):
raise ValueError(f"{label} line {line_no} must be an object")
rows.append(item)
return rows
def validate_manifest(manifest: Mapping) -> None:
"""Validate the frozen split design using manifest metadata only."""
split_rows = manifest.get("split_rows")
previous = manifest.get("excluded_previous_rows")
if not isinstance(split_rows, Mapping) or not isinstance(previous, list):
raise ValueError("split manifest is missing split_rows or excluded_previous_rows")
all_ids: list[int] = []
for split in ("discovery", "calibration", "heldout"):
values = split_rows.get(split)
if not isinstance(values, list) or not values:
raise ValueError(f"split manifest is missing non-empty {split} row IDs")
ids = [int(value) for value in values]
if len(ids) != len(set(ids)):
raise ValueError(f"duplicate row ID in {split} split metadata")
all_ids.extend(ids)
if len(all_ids) != len(set(all_ids)):
raise ValueError("discovery, calibration and heldout split IDs overlap")
if set(all_ids) & {int(value) for value in previous}:
raise ValueError("001B split overlaps rows used by an earlier ModelClinic run")
def validate_split_bytes(split: str, raw: bytes, manifest: Mapping) -> list[dict]:
"""Verify one frozen split's digest, row order and minimal schema."""
if split not in {"discovery", "calibration", "heldout"}:
raise ValueError(f"unknown split: {split}")
validate_manifest(manifest)
filename = f"001b_{split}_{len(manifest['split_rows'][split])}.jsonl"
expected_hash = manifest.get("split_file_sha256", {}).get(filename)
if not expected_hash or sha256_bytes(raw) != expected_hash:
raise ValueError(f"{split} split hash does not match frozen manifest")
rows = parse_jsonl_bytes(raw, label=split)
expected_rows = [int(value) for value in manifest["split_rows"][split]]
actual_rows = [int(item["source_row"]) for item in rows if "source_row" in item]
if actual_rows != expected_rows:
raise ValueError(f"{split} row IDs do not match frozen manifest")
required = {"source_row", "problem", "answer", "unique_id"}
for index, item in enumerate(rows):
missing = required - item.keys()
if missing:
raise ValueError(f"{split} row {index} missing fields: {sorted(missing)}")
return rows
def validate_heldout_rows(questions: Sequence[Mapping], manifest: Mapping) -> None:
"""Reject non-heldout rows even when the Modal function is called directly."""
validate_manifest(manifest)
allowed = {int(value) for value in manifest["split_rows"]["heldout"]}
rows = [int(question["source_row"]) for question in questions]
if not rows or len(rows) != len(set(rows)):
raise ValueError("heldout input must contain unique source rows")
unexpected = set(rows) - allowed
if unexpected:
raise ValueError(f"remote heldout batch contains non-heldout rows: {sorted(unexpected)}")
def validate_heldout_content(
questions: Sequence[Mapping], frozen_questions: Sequence[Mapping]
) -> None:
"""Reject remote heldout payloads whose row content differs from the frozen split."""
expected_by_row = {int(question["source_row"]): dict(question) for question in frozen_questions}
actual_rows = [int(question["source_row"]) for question in questions]
if not actual_rows or len(actual_rows) != len(set(actual_rows)):
raise ValueError("heldout input must contain unique source rows")
for question in questions:
row = int(question["source_row"])
expected = expected_by_row.get(row)
if expected is None:
raise ValueError(f"heldout input contains unexpected source row {row}")
if json.dumps(dict(question), sort_keys=True, ensure_ascii=False, separators=(",", ":")) != json.dumps(
expected, sort_keys=True, ensure_ascii=False, separators=(",", ":")
):
raise ValueError(f"heldout source row {row} content differs from frozen split")
def validate_heldout_calibration(
manifest: Mapping,
artifact: Mapping,
*,
run_id: str,
expected_stage: str,
split_manifest_sha256: str,
calibration_rows: Sequence[int],
heldout_rows: Sequence[int],
expected_candidate_ids: Sequence[str],
expected_model: Mapping,
parent_artifact_sha256: str,
max_new_tokens: int,
generation_seconds: int,
heldout_max_generation_seconds: int,
sampling: Mapping,
) -> None:
"""Require a complete, internally matching long-calibration freeze for heldout."""
if manifest.get("status") != "complete":
raise ValueError("long calibration manifest is incomplete")
if manifest.get("run_id") != run_id or artifact.get("run_id") != run_id:
raise ValueError("long calibration run ID does not match heldout run")
if manifest.get("phase") != "finalists" or artifact.get("phase") != "finalists":
raise ValueError("heldout requires the finalist calibration phase")
if manifest.get("calibration_stage") != expected_stage or artifact.get("calibration_stage") != expected_stage:
raise ValueError("long calibration stage does not match heldout requirements")
artifact_hash = artifact.get("calibration_artifact_sha256")
hash_payload = dict(artifact)
hash_payload.pop("calibration_artifact_sha256", None)
canonical = (json.dumps(hash_payload, ensure_ascii=False, sort_keys=True, separators=(",", ":")) + "\n").encode("utf-8")
if not artifact_hash or artifact_hash != sha256_bytes(canonical):
raise ValueError("long calibration artifact hash does not match its contents")
manifest_artifact_hash = manifest.get("calibration_artifact_sha256")
if manifest_artifact_hash is not None and manifest_artifact_hash != artifact_hash:
raise ValueError("long calibration manifest and artifact hashes do not match")
if not parent_artifact_sha256 or artifact.get("parent_calibration_artifact_sha256") != parent_artifact_sha256:
raise ValueError("long calibration artifact does not match the completed screen parent")
if manifest.get("parent_calibration_artifact_sha256") != parent_artifact_sha256:
raise ValueError("long calibration manifest does not match the completed screen parent")
manifest_model = manifest.get("model")
if artifact.get("model") != dict(expected_model) or (manifest_model is not None and manifest_model != dict(expected_model)):
raise ValueError("long calibration model revisions or precision do not match heldout model")
if manifest.get("split_manifest_sha256") != split_manifest_sha256 or artifact.get("split_manifest_sha256") != split_manifest_sha256:
raise ValueError("long calibration uses a different frozen split manifest")
expected_calibration_rows = [int(row) for row in calibration_rows]
expected_heldout_rows = [int(row) for row in heldout_rows]
if set(expected_calibration_rows) & set(expected_heldout_rows):
raise ValueError("calibration and heldout rows overlap")
if manifest.get("calibration_rows") != expected_calibration_rows:
raise ValueError("long calibration manifest has incorrect calibration row coverage")
if manifest.get("heldout_rows") != expected_heldout_rows:
raise ValueError("long calibration manifest has incorrect heldout row coverage")
if artifact.get("calibration", {}).get("source_rows") != expected_calibration_rows:
raise ValueError("long calibration artifact has incorrect calibration row coverage")
artifact_calibration = artifact.get("calibration", {})
manifest_calibration = manifest.get("calibration")
if (artifact_calibration.get("source_rows") != expected_calibration_rows
or (manifest_calibration is not None and manifest_calibration != artifact_calibration)
or manifest.get("calibration_sha256") != artifact.get("calibration_sha256")
or manifest.get("independent_sha256") != artifact.get("independent_sha256")):
raise ValueError("long calibration manifest and artifact calibration provenance does not match")
if manifest.get("expected_calibration_question_seeds") != [[row, 0] for row in expected_calibration_rows]:
raise ValueError("long calibration manifest has incorrect expected question-seed keys")
expected_ids = [str(candidate_id) for candidate_id in expected_candidate_ids]
if (manifest.get("stage2_candidate_ids") != expected_ids
or artifact.get("stage2_candidate_ids") != expected_ids):
raise ValueError("long calibration finalist candidate IDs are incomplete or out of order")
manifest_candidates = manifest.get("calibration_candidates")
artifact_candidates = artifact.get("grid_candidates")
if not isinstance(manifest_candidates, list) or not isinstance(artifact_candidates, list):
raise ValueError("long calibration manifest or artifact is missing candidate records")
manifest_ids = [str(item.get("candidate_id")) for item in manifest_candidates]
artifact_ids = [str(item.get("candidate_id")) for item in artifact_candidates]
if manifest_ids != expected_ids or artifact_ids != expected_ids:
raise ValueError("long calibration finalist candidate records are incomplete or duplicated")
family_ids: dict[str, list[str]] = {"published_constant": [], "independent_constant": []}
manifest_by_id = {str(item["candidate_id"]): item for item in manifest_candidates}
grid_by_id = {str(item["candidate_id"]): item for item in artifact_candidates}
for config in manifest_candidates:
candidate_id = str(config["candidate_id"])
family = str(config.get("family", ""))
if family not in family_ids:
raise ValueError(f"unknown long calibration candidate family: {family}")
family_ids[family].append(candidate_id)
if (config.get("max_new_tokens") != max_new_tokens
or config.get("max_generation_seconds") != generation_seconds
or config.get("sampling") != dict(sampling)):
raise ValueError(f"long calibration candidate {candidate_id} uses unexpected generation settings")
candidate = grid_by_id.get(candidate_id)
if (candidate is None or candidate.get("family") != family
or candidate.get("coefficients") != config.get("coefficients")
or candidate.get("max_new_tokens") != max_new_tokens
or candidate.get("max_generation_seconds") != generation_seconds
or candidate.get("sampling") != dict(sampling)
or candidate.get("calibration_rows") != expected_calibration_rows):
raise ValueError(f"long calibration artifact configuration differs for {candidate_id}")
if manifest.get("selection_families") != family_ids:
raise ValueError("long calibration selection families do not match its finalist candidates")
expected_keys = sorted((row, 0) for row in expected_calibration_rows)
for candidate_id in expected_ids:
candidate = grid_by_id[candidate_id]
if candidate.get("status") != "complete":
raise ValueError(f"long calibration candidate {candidate_id} is incomplete")
outcomes = candidate.get("prompt_outcomes")
if not isinstance(outcomes, list):
raise ValueError(f"long calibration candidate {candidate_id} is missing prompt outcomes")
keys = sorted((int(item["source_row"]), int(item.get("seed", 0))) for item in outcomes)
if keys != expected_keys or any(
item.get("error") or not isinstance(item.get("score"), Mapping)
or item["score"].get("status") == "error"
for item in outcomes
):
raise ValueError(f"long calibration candidate {candidate_id} has missing or erroneous outcomes")
selected = artifact.get("selected")
if not isinstance(selected, Mapping) or set(selected) != set(family_ids):
raise ValueError("long calibration artifact has missing family selections")
for family, candidate_ids in family_ids.items():
chosen = selected[family]
chosen_id = str(chosen.get("candidate_id", ""))
if chosen_id not in candidate_ids:
raise ValueError(f"long calibration selected an unknown candidate for {family}")
if (manifest_by_id[chosen_id].get("selected") is not True
or grid_by_id[chosen_id].get("coefficients") != chosen.get("coefficients")):
raise ValueError(f"long calibration manifest does not mark the selected {family} candidate")
for candidate_id in candidate_ids:
if manifest_by_id[candidate_id].get("selected") is not (candidate_id == chosen_id):
raise ValueError(f"long calibration manifest has inconsistent selected flags for {family}")
if manifest.get("selected_conditions") != selected:
raise ValueError("long calibration manifest and artifact selections do not match")
if manifest.get("heldout_condition_config_ids") != artifact.get("heldout_condition_config_ids"):
raise ValueError("long calibration manifest and artifact heldout config IDs do not match")
expected_config_ids = {
"base": "base",
"edited": "edited",
"published_constant": selected["published_constant"]["candidate_id"],
"independent_constant": selected["independent_constant"]["candidate_id"],
"norm_matched_random": "norm_matched_random__norm_of_published_constant",
"rank1_activation_dependent": "rank1_activation_dependent__rank_one_delta",
}
if artifact.get("heldout_condition_config_ids") != expected_config_ids:
raise ValueError("long calibration heldout condition mapping is incomplete or inconsistent")
selection = artifact.get("selection", {})
if selection.get("heldout_used") is not False or selection.get("eligible_data") != "calibration prompts only":
raise ValueError("heldout selection metadata does not prove calibration-only selection")
if (manifest.get("heldout_max_new_tokens") != max_new_tokens
or manifest.get("heldout_max_generation_seconds") != heldout_max_generation_seconds
or manifest.get("heldout_sampling") != dict(sampling)):
raise ValueError("long calibration manifest has unexpected heldout generation settings")
if (manifest.get("calibration_max_new_tokens") != max_new_tokens
or manifest.get("calibration_generation_seconds") != generation_seconds):
raise ValueError("long calibration manifest has unexpected finalist generation settings")
def normalize_calibration_manifest_from_artifact(
manifest: Mapping,
artifact: Mapping,
*,
original_manifest_sha256: str,
) -> dict:
"""Bind a legacy stage manifest to the self-hashed artifact and log config drift."""
normalized = dict(manifest)
artifact_hash = artifact.get("calibration_artifact_sha256")
artifact_payload = dict(artifact)
artifact_payload.pop("calibration_artifact_sha256", None)
artifact_canonical = (
json.dumps(artifact_payload, ensure_ascii=False, sort_keys=True, separators=(",", ":")) + "\n"
).encode("utf-8")
if not artifact_hash or sha256_bytes(artifact_canonical) != artifact_hash:
raise ValueError("cannot normalize manifest: calibration artifact self-hash is invalid")
for field in ("calibration_artifact_sha256",):
old = normalized.get(field)
if old is not None and old != artifact_hash:
raise ValueError(f"cannot normalize manifest: {field} disagrees with calibration artifact")
for field in ("model", "calibration"):
old = normalized.get(field)
if old is not None and old != artifact.get(field):
raise ValueError(f"cannot normalize manifest: {field} disagrees with calibration artifact")
expected_ids = [str(value) for value in artifact.get("stage2_candidate_ids", [])]
planned_candidates = normalized.get("calibration_candidates")
actual_candidates = artifact.get("grid_candidates")
if not isinstance(planned_candidates, list) or not isinstance(actual_candidates, list):
raise ValueError("cannot normalize manifest: finalist candidate records are missing")
if ([str(item.get("candidate_id")) for item in planned_candidates] != expected_ids
or [str(item.get("candidate_id")) for item in actual_candidates] != expected_ids):
raise ValueError("cannot normalize manifest: finalist candidate IDs differ from artifact")
selected = artifact.get("selected")
if not isinstance(selected, Mapping):
raise ValueError("cannot normalize manifest: artifact has no selected candidates")
actual_by_id = {str(item["candidate_id"]): item for item in actual_candidates}
normalized_candidates = []
reconciliations = []
config_fields = (
"family", "condition", "heldout_condition", "coefficients",
"max_new_tokens", "max_generation_seconds", "sampling",
)
for planned in planned_candidates:
candidate_id = str(planned["candidate_id"])
actual = actual_by_id[candidate_id]
family = str(actual.get("family", ""))
if planned.get("family") != family:
raise ValueError(f"cannot normalize manifest: family changed for {candidate_id}")
if family not in selected or selected[family].get("candidate_id") not in expected_ids:
raise ValueError(f"cannot normalize manifest: invalid selected candidate for {family}")
selected_flag = selected[family]["candidate_id"] == candidate_id
differences = []
for field in config_fields:
planned_value = planned.get(field)
actual_value = actual.get(field)
if planned_value != actual_value:
differences.append({"field": field, "planned": planned_value, "artifact": actual_value})
planned_selected = planned.get("selected")
if planned_selected is not None and planned_selected is not selected_flag:
differences.append({"field": "selected", "planned": planned_selected, "artifact": selected_flag})
bound_candidate = dict(planned)
for field in config_fields:
if field in actual:
bound_candidate[field] = actual[field]
bound_candidate["selected"] = selected_flag
normalized_candidates.append(bound_candidate)
reconciliations.append({"candidate_id": candidate_id, "differences": differences})
if normalized.get("selected_conditions") != selected:
raise ValueError("cannot normalize manifest: selected candidate mapping differs from artifact")
if normalized.get("heldout_condition_config_ids") != artifact.get("heldout_condition_config_ids"):
raise ValueError("cannot normalize manifest: heldout condition mapping differs from artifact")
missing_fields = [field for field in ("calibration_artifact_sha256", "model", "calibration") if field not in normalized]
normalized["calibration_artifact_sha256"] = artifact_hash
normalized["model"] = artifact["model"]
normalized["calibration"] = artifact["calibration"]
normalized["calibration_candidates"] = normalized_candidates
normalized["manifest_reconciliation"] = {
"source": "self-hashed calibration.json grid_candidates; these hold the executed candidate settings",
"original_manifest_sha256": original_manifest_sha256,
"backfilled_fields": missing_fields,
"candidate_configs": reconciliations,
"raw_manifest_path": "manifest_remote_original.json",
"note": "Planned candidate settings remain preserved in the raw remote manifest; differing executed settings are listed per candidate above.",
}
return normalized
def classify_generation_output(state: Mapping, *, finished: bool, has_outputs: bool) -> str:
"""Classify a vLLM event while keeping already-finalized requests terminal."""
if state.get("done"):
return "ignore"
if not has_outputs:
return "error" if finished else "wait"
return "complete" if finished else "update"
def task_result_failure(task: Mapping, result, source_rows: Sequence[int]) -> dict | None:
"""Return an auditable failure record for an exception or failed task summary."""
if isinstance(result, BaseException):
message = f"{type(result).__name__}: {str(result)}"
elif not isinstance(result, Mapping):
message = f"unexpected task result type: {type(result).__name__}"
elif result.get("batch_error") or result.get("blocked_partial") or result.get("blocked_error") or result.get("error_count"):
message = str(result.get("batch_error") or "blocked or error records returned")
else:
return None
return {
"task": dict(task),
"source_rows": [int(row) for row in source_rows],
"error": message,
}
def parse_seeds(value: str | Iterable[int]) -> list[int]:
if isinstance(value, str):
seeds = [int(part.strip()) for part in value.split(",") if part.strip()]
else:
seeds = [int(part) for part in value]
if not seeds or len(seeds) != len(set(seeds)) or any(seed < 0 for seed in seeds):
raise ValueError("seeds must be a non-empty list of unique non-negative integers")
return seeds
def build_task_plan(
questions: Sequence[Mapping],
conditions: Sequence[str],
seeds: Sequence[int],
) -> list[dict]:
if not questions:
raise ValueError("task plan needs at least one question")
if not conditions or len(set(conditions)) != len(conditions):
raise ValueError("conditions must be a non-empty unique list")
unknown = set(conditions) - (set(CONDITIONS) | set(EXPLORATORY_CONDITIONS))
if unknown:
raise ValueError(f"unknown condition(s): {sorted(unknown)}")
parsed_seeds = parse_seeds(seeds)
rows = [int(question["source_row"]) for question in questions]
if len(rows) != len(set(rows)):
raise ValueError("questions contain duplicate source_row values")
return [
{
"condition": condition,
"seed": seed,
"source_rows": rows,
"batch_size": len(questions),
}
for seed in parsed_seeds
for condition in conditions
]
def resolve_condition_config_id(condition: str, selected_config_ids: Mapping[str, str]) -> str:
"""Resolve the immutable calibration config used by a primary or exploratory arm."""
exploratory_id = EXPLORATORY_CANDIDATE_IDS.get(condition)
if exploratory_id is not None:
return exploratory_id
try:
return str(selected_config_ids[condition])
except KeyError as exc:
raise ValueError(f"condition {condition!r} has no frozen calibration config") from exc
def calibration_candidate_coefficients(calibration: Mapping, candidate_id: str) -> dict[str, float]:
"""Load a frozen finalist's per-layer coefficients without consulting heldout data."""
matches = [
candidate for candidate in calibration.get("grid_candidates", [])
if candidate.get("candidate_id") == candidate_id
]
if len(matches) != 1:
raise ValueError(f"expected exactly one calibration candidate {candidate_id!r}; found {len(matches)}")
coefficients = matches[0].get("coefficients")
layers = calibration.get("layers")
if not isinstance(coefficients, Mapping) or not isinstance(layers, Mapping):
raise ValueError(f"candidate {candidate_id!r} is missing layer coefficients")
if set(coefficients) != set(layers):
raise ValueError(f"candidate {candidate_id!r} layer coefficients do not match calibration layers")
normalized = {str(layer): float(value) for layer, value in coefficients.items()}
if not all(math.isfinite(value) for value in normalized.values()):
raise ValueError(f"candidate {candidate_id!r} has non-finite coefficients")
return normalized
def estimate_worst_case_usd(
task_count: int,
*,
timeout_seconds: int = FUNCTION_TIMEOUT_SECONDS,
blended_usd_per_hour: float = CONSERVATIVE_A10_ALL_IN_USD_PER_HOUR,
) -> float:
if task_count < 0 or timeout_seconds <= 0 or blended_usd_per_hour <= 0:
raise ValueError("invalid cost estimate inputs")
return task_count * timeout_seconds * blended_usd_per_hour / 3600.0
def record_key(source_row: int, condition: str, seed: int) -> str:
return f"{int(source_row)}__{condition}__seed{int(seed)}"
def load_json(path: str | Path) -> dict:
return json.loads(Path(path).read_text(encoding="utf-8"))
__all__ = [
"CONDITIONS",
"EXPLORATORY_CANDIDATE_IDS",
"EXPLORATORY_CONDITIONS",
"EXPLORATORY_PUBLISHED_JOINT_MEAN",
"CONSERVATIVE_A10_ALL_IN_USD_PER_HOUR",
"FUNCTION_TIMEOUT_SECONDS",
"MAX_GENERATION_SECONDS",
"MAX_NEW_TOKENS",
"PRIMARY_SAMPLING",
"build_task_plan",
"calibration_candidate_coefficients",
"estimate_worst_case_usd",
"load_json",
"normalize_calibration_manifest_from_artifact",
"parse_jsonl_bytes",
"parse_seeds",
"resolve_condition_config_id",
"classify_generation_output",
"record_key",
"sha256_bytes",
"validate_manifest",
"validate_heldout_content",
"validate_heldout_rows",
"validate_split_bytes",
"task_result_failure",
]