modelclinic-experiment-001 / code /modal /experiment_001d_long_controller_pilot.py
PratikBuilds's picture
Publish complete available Experiment 001 research release (001A–001D)
cb8c6af verified
Raw History Blame Contribute Delete
10.3 kB
"""Full-horizon, discovery-only feasibility pilot for Experiment 001D."""
from __future__ import annotations
import gzip
import hashlib
import json
import time
from pathlib import Path
import modal
CONFIG_PATH = "results/experiment_001d/stage1_fast_v2/controller_long_pilot_config.json"
OUTPUT_DIR = Path("results/experiment_001d/stage1_fast_v2")
BASE_REVISION = "2fc06364715b967f1860aea9cf38778875588b17"
EDITED_REVISION = "d1671a178705bcab7644806d23c535517f35723b"
REMOTE_BASE = f"/cache/modelclinic/base-{BASE_REVISION}"
REMOTE_EDITED = f"/cache/modelclinic/edited-{EDITED_REVISION}"
VOLUME = modal.Volume.from_name("research-cache", create_if_missing=False)
image = (
modal.Image.debian_slim(python_version="3.11")
.pip_install("vllm==0.33.0", "transformers==5.20.2", "safetensors==0.8.0")
.env({"VLLM_USE_FLASHINFER_SAMPLER": "0", "VLLM_ALLOW_INSECURE_SERIALIZATION": "1"})
.add_local_file("src/experiment_001d_runtime.py", "/root/project/experiment_001d_runtime.py")
.add_local_file("src/experiment_001d_behavioral.py", "/root/project/experiment_001d_analysis.py")
.add_local_file("results/experiment_001b/calibration_long/calibration.json", "/root/project/calibration.json")
.add_local_file(CONFIG_PATH, "/root/project/long_pilot_config.json")
)
app = modal.App("modelclinic-experiment-001d-long-controller-pilot")
def _json_bytes(value: object) -> bytes:
return (json.dumps(value, ensure_ascii=False, sort_keys=True, separators=(",", ":")) + "\n").encode("utf-8")
@app.function(
image=image,
gpu="A10",
volumes={"/cache": VOLUME},
cpu=2,
memory=8192,
timeout=1800,
retries=0,
scaledown_window=2,
max_containers=1,
)
def run_long_pilot():
import os
import sys
sys.path.insert(0, "/root/project")
import torch
import vllm
from transformers import AutoTokenizer
from vllm import LLM, SamplingParams
from experiment_001d_analysis import extract_final_number, repetition_metrics, score_completion, is_repetitive_prefix
from experiment_001d_runtime import (
expected_active_positions,
install_controller_hooks,
read_controller_stats,
remove_controller_hooks,
)
if os.environ.get("VLLM_ALLOW_INSECURE_SERIALIZATION") != "1":
raise RuntimeError("trusted apply_model callback serialization is not enabled")
VOLUME.reload()
for required in (REMOTE_BASE, REMOTE_EDITED):
if not Path(required).is_dir():
raise RuntimeError(f"cached checkpoint is missing: {required}")
config = json.loads(Path("/root/project/long_pilot_config.json").read_text(encoding="utf-8"))
calibration = json.loads(Path("/root/project/calibration.json").read_text(encoding="utf-8"))
prefix_ids = [int(x) for x in config["prefix_token_ids"]]
prefix_sha = hashlib.sha256(_json_bytes(prefix_ids)).hexdigest()
if prefix_sha != config["prefix_sha256"]:
raise RuntimeError(f"prefix hash mismatch: computed={prefix_sha} config={config['prefix_sha256']}")
torch.set_grad_enabled(False)
torch.set_num_threads(2)
tokenizer = AutoTokenizer.from_pretrained(REMOTE_BASE, local_files_only=True)
llm = LLM(
model=REMOTE_BASE,
dtype="bfloat16",
gpu_memory_utilization=0.8,
max_model_len=int(config["model_max_len"]),
max_num_seqs=1,
max_num_batched_tokens=int(config["model_max_len"]),
enable_prefix_caching=False,
enforce_eager=True,
seed=20261104,
trust_remote_code=False,
)
constants = calibration["selected"]["published_constant"]["coefficients"]
layer_data = {}
for layer in (15, 19):
key = str(layer)
layer_data[key] = {
"direction": calibration["layers"][key]["direction"],
"gate_vector": calibration["layers"][key]["rank1_gate_vector"],
"constant": float(constants[key]),
"donor_coefficients": config["donor_coefficients"][key],
"donor_scale": float(config["donor_scale"][key]),
"donor_offset": float(config["donor_offset"][key]),
}
sampling = SamplingParams(
n=1,
temperature=0.6,
top_p=0.95,
top_k=20,
presence_penalty=1.5,
max_tokens=int(config["horizon"]),
seed=int(config["sampling"]["seed"]),
)
prefix_text = tokenizer.decode(config["prefix_generated_token_ids"], skip_special_tokens=False)
started = time.monotonic()
results = []
for condition in config["conditions"]:
hook_config = {
"mode": condition,
"prefix_length": len(prefix_ids),
"layers": layer_data,
"edited_checkpoint_path": f"{REMOTE_EDITED}/model.safetensors-00001-of-00001.safetensors",
}
installed = llm.apply_model(lambda worker, _cfg=hook_config: install_controller_hooks(worker, _cfg))
if not installed:
raise RuntimeError(f"controller hooks were not installed for {condition}")
output = llm.generate(
[{"prompt_token_ids": prefix_ids}],
sampling,
use_tqdm=False,
)[0].outputs[0]
stats = llm.apply_model(read_controller_stats)
if not stats or len(stats) != 1:
raise RuntimeError(f"expected one worker stats result for {condition}")
stats = stats[0]
removed = llm.apply_model(remove_controller_hooks)
generated_ids = [int(x) for x in output.token_ids]
expected_positions = expected_active_positions(generated_ids, tokenizer.eos_token_id)
continuation_text = tokenizer.decode(generated_ids, skip_special_tokens=False)
full_assistant_text = prefix_text + continuation_text
finish_reason = str(output.finish_reason or "unknown")
natural_stop = finish_reason == "stop"
combined_ids = [int(x) for x in config["prefix_generated_token_ids"]] + generated_ids
repetition_path = []
for end in range(int(config["prefix_end_generated_tokens"]) + 64, len(combined_ids) + 1, 64):
partial_text = tokenizer.decode(combined_ids[:end], skip_special_tokens=False)
metrics = repetition_metrics(combined_ids[:end], partial_text)
repetition_path.append({"end_token": end, **metrics, "repetitive": is_repetitive_prefix(metrics)})
results.append(
{
"condition": condition,
"mode": condition,
"prefix_token_ids": prefix_ids,
"prefix_sha256": prefix_sha,
"target_source_row": int(config["target_source_row"]),
"donor_source_row": int(config["donor_source_row"]),
"donor_start_position": int(config["donor_start_position"]),
"donor_cyclic_rotation": int(config["donor_cyclic_rotation"]),
"donor_scale": config["donor_scale"],
"generated_token_ids": generated_ids,
"continuation_text": continuation_text,
"full_assistant_text": full_assistant_text,
"prefix_answer": extract_final_number(prefix_text),
"continuation_score": score_completion(continuation_text, str(config["gold_answer"]), finish_reason, natural_stop),
"score": score_completion(full_assistant_text, str(config["gold_answer"]), finish_reason, natural_stop),
"finish_reason": finish_reason,
"stop_reason": output.stop_reason,
"natural_stop": natural_stop,
"eos_token_id": tokenizer.eos_token_id,
"eos_in_output": tokenizer.eos_token_id is not None and int(tokenizer.eos_token_id) in generated_ids,
"expected_active_positions": expected_positions,
"layer_stats": stats,
"hook_position_counts_valid": all(
int(stats[str(layer)]["active_positions"]) == expected_positions
for layer in (15, 19)
),
"hooks_removed": removed[0] if removed else [],
"repetition_path": repetition_path,
}
)
print(
f"long-pilot condition={condition} tokens={len(generated_ids)} "
f"finish={finish_reason} counters_valid={results[-1]['hook_position_counts_valid']}",
flush=True,
)
return {
"run_id": config["run_id"],
"stage": config["stage"],
"source_manifest_sha256": config["source_manifest_sha256"],
"config_sha256": hashlib.sha256(Path("/root/project/long_pilot_config.json").read_bytes()).hexdigest(),
"elapsed_seconds": time.monotonic() - started,
"gpu": torch.cuda.get_device_name(),
"vllm_version": vllm.__version__,
"torch_version": torch.__version__,
"prefix_sha256": prefix_sha,
"all_prefixes_identical": len({x["prefix_sha256"] for x in results}) == 1,
"all_hook_position_counts_valid": all(x["hook_position_counts_valid"] for x in results),
"donor_scale_estimation": config["donor_scale_estimation"],
"sampling": config["sampling"],
"results": results,
}
@app.local_entrypoint()
def main():
output = OUTPUT_DIR / "controller_long_pilot_v1.json.gz"
summary_path = OUTPUT_DIR / "controller_long_pilot_summary.json"
if output.exists() or summary_path.exists():
raise RuntimeError("refusing to overwrite prior full-horizon pilot artifacts")
result = run_long_pilot.remote()
with gzip.open(output, "wt", encoding="utf-8") as handle:
json.dump(result, handle, ensure_ascii=False, separators=(",", ":"))
summary = {
key: result[key]
for key in (
"run_id",
"stage",
"source_manifest_sha256",
"config_sha256",
"elapsed_seconds",
"gpu",
"prefix_sha256",
"all_prefixes_identical",
"all_hook_position_counts_valid",
)
}
summary["conditions"] = [
{"condition": x["condition"], "tokens": len(x["generated_token_ids"]), "finish_reason": x["finish_reason"], "score": x["score"]}
for x in result["results"]
]
summary_path.write_text(json.dumps(summary, indent=2) + "\n", encoding="utf-8")
print(json.dumps(summary, indent=2))