Download code/modal/experiment_001d_long_controller_pilot.py from PratikBuilds/modelclinic-experiment-001: direct link, hf CLI and curl.
- Browser
- Download file 10.3 kB
-
https://huggingface.co/datasets/PratikBuilds/modelclinic-experiment-001/resolve/main/code/modal/experiment_001d_long_controller_pilot.py
- Command line
-
hf download hf://datasets/PratikBuilds/modelclinic-experiment-001/code/modal/experiment_001d_long_controller_pilot.py
-
curl -L -o experiment_001d_long_controller_pilot.py https://huggingface.co/datasets/PratikBuilds/modelclinic-experiment-001/resolve/main/code/modal/experiment_001d_long_controller_pilot.py
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") | |
| 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, | |
| } | |
| 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)) | |