dpca-b200-source / opd_1gpu_tb.py
codemaivanngu's picture
Upload folder using huggingface_hub
d3bf152 verified
Raw History Blame Contribute Delete
22.5 kB
"""OPD/DPCA optimizer steps on one B200, tracked with TensorBoard instead of W&B.
Why this file exists
--------------------
`reproduction/dpca_2gpu_train.py` (upstream, commit 927a8264) refuses to run when
W&B comes up offline:
if wb_run.offline:
raise RuntimeError("W&B initialized offline; online logging is required")
The company node cannot satisfy that: the egress proxy resets `api.wandb.ai` and
`wandb.ai` (curl rc=56) while `huggingface.co` and `pypi.org` pass. `WANDB_MODE`
does not rescue it either — the same CLI reads `run_id` right after `wandb.init`,
and in `disabled` mode `Run.id` asserts `self._settings.run_id is not None`, so it
dies before writing any summary.
We do not edit that file: it is hash-pinned by its own source manifest. So this
runner is a second launcher, and it is NOT the qualified CLI. What it does reuse,
straight from the pinned module, is every piece that touches the science:
from dpca_2gpu_train import (
_response_logps, _strip_trailing_special_tokens,
_project_advantage_for_metrics, _gpu_metrics, _mean, _sha256,
)
from verl.trainer.ppo.core_algos import compute_policy_loss_opd
from verl.workers.reward_manager.opd import TeacherClient
Those helpers and the two verl functions are imported, never reimplemented, so
the gradient being applied is computed by the same code the canary used. The only
thing this file changes is the sink: TensorBoard event files plus `metrics.jsonl`,
with no network call anywhere in the run.
Evidence class: `implementation_validation`, same as the canary, and the run
records `not_the_upstream_cli: true` so it can never be mistaken for a run of the
hash-pinned CLI.
"""
from __future__ import annotations
import argparse
import hashlib
import json
import os
import random
import sys
import time
from pathlib import Path
from typing import Any
import numpy as np
import torch
from omegaconf import OmegaConf
from torch.utils.tensorboard import SummaryWriter
from transformers import (
AutoModelForCausalLM,
AutoTokenizer,
get_constant_schedule_with_warmup,
)
# The pinned upstream launcher and the verl code it calls. Nothing here re-implements
# the objective: these imports are the whole point of this file.
REPO_ROOT = Path(os.environ.get("DPCA_REPO_ROOT", "/opt/dpca"))
sys.path.insert(0, str(REPO_ROOT / "reproduction"))
sys.path.insert(0, str(REPO_ROOT))
import dpca_2gpu_train as pinned # noqa: E402 (path must exist first)
from verl.trainer.ppo.core_algos import compute_policy_loss_opd # noqa: E402
from verl.workers.reward_manager.opd import TeacherClient # noqa: E402
def verify_pinned_sources(config: dict[str, Any]) -> dict[str, Any]:
"""Re-run the upstream hash guard verbatim, then check the commit matches."""
manifest_path = REPO_ROOT / "reproduction/source_manifest.json"
manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
expected = manifest.get("effective_sha256", manifest["sha256"])
actual = {
relative: pinned._sha256(REPO_ROOT / relative) for relative in expected
}
if actual != expected:
differing = sorted(
key
for key in set(expected) | set(actual)
if expected.get(key) != actual.get(key)
)
raise RuntimeError(f"Pinned effective source hash mismatch: {differing}")
if manifest["commit"] != config["source_commit"]:
raise RuntimeError(
f"Source commit mismatch: {manifest['commit']} != {config['source_commit']}"
)
return {
"git_commit": manifest["commit"],
"source_manifest_sha256": pinned._sha256(manifest_path),
"source_files_verified": len(actual),
}
def weight_fingerprint(model: torch.nn.Module) -> tuple[str, int]:
"""Digest a slice of every named parameter, plus how many carry gradients.
My first version hashed `next(model.parameters())`, which for Llama is
`embed_tokens.weight`. That tensor receives no gradient here — the loss only
covers response tokens — so it never moves and the check reported
"weights unchanged" after ten real optimizer steps. The instrument was wrong,
not the run. Hashing every named parameter in a stable order covers the
transformer body, which does receive gradient.
"""
digest = hashlib.sha256()
params = sorted(model.named_parameters(), key=lambda item: item[0])
with_grad = sum(1 for _, param in params if param.grad is not None)
for name, param in params:
with torch.no_grad():
slice_ = param.detach().float().reshape(-1)[:512].cpu().numpy()
digest.update(name.encode("utf-8"))
digest.update(str(slice_.shape).encode("ascii"))
digest.update(slice_.tobytes())
return digest.hexdigest(), with_grad
def device_records() -> list[dict[str, Any]]:
records = []
for index in range(torch.cuda.device_count()):
props = torch.cuda.get_device_properties(index)
records.append(
{
"index": index,
"name": props.name,
# Same guard the pinned CLI uses, and it earns its keep: the
# torch build in the installed venv has no `major_minor`, while
# the image torch does. Without the hasattr the run dies before
# loading a model, on an attribute difference alone.
"capability": list(props.major_minor)
if hasattr(props, "major_minor")
else list(torch.cuda.get_device_capability(index)),
"total_memory_bytes": props.total_memory,
"uuid": str(props.uuid) if hasattr(props, "uuid") else None,
}
)
return records
def run(config: dict[str, Any], output_dir: Path) -> dict[str, Any]:
execution = config.get("execution", {})
expected_gpus = int(execution.get("gpu_count", 1))
teacher_index = int(execution.get("teacher_device_index", 0))
student_index = int(execution.get("student_device_index", 0))
actual_gpus = torch.cuda.device_count()
if actual_gpus != expected_gpus:
raise RuntimeError(
f"Expected exactly {expected_gpus} CUDA GPU(s); found {actual_gpus}"
)
if not (
0 <= teacher_index < actual_gpus and 0 <= student_index < actual_gpus
):
raise RuntimeError(
f"Invalid placement: teacher={teacher_index} student={student_index} "
f"cuda_device_count={actual_gpus}"
)
records = device_records()
if not all("B200" in record["name"] for record in records):
raise RuntimeError(f"Expected B200 device(s), got {records}")
provenance = verify_pinned_sources(config)
provenance.update(
{
"torch_version": torch.__version__,
"cuda_runtime": torch.version.cuda,
"cuda_device_count": actual_gpus,
"python": sys.version.split()[0],
}
)
seed = int(config["seed"])
random.seed(seed)
np.random.seed(seed)
torch.manual_seed(seed)
torch.cuda.manual_seed_all(seed)
torch.backends.cuda.matmul.allow_tf32 = True
output_dir.mkdir(parents=True, exist_ok=False)
tb_dir = output_dir / "tensorboard"
checkpoint_dir = output_dir / "checkpoint-final"
metrics_path = output_dir / "metrics.jsonl"
prompts = json.loads(
Path(config["prompts_path"]).read_text(encoding="utf-8")
)
steps = int(config["optimizer"]["steps"])
if len(prompts) < steps:
raise RuntimeError(f"Need at least {steps} prompts; found {len(prompts)}")
provenance["prompt_sha256"] = pinned._sha256(Path(config["prompts_path"]))
provenance["prompt_count"] = len(prompts)
effective_config_path = output_dir / "effective_config.json"
effective_config_path.write_text(
json.dumps({"config": config, "provenance": provenance}, indent=2, sort_keys=True),
encoding="utf-8",
)
teacher_device = torch.device(f"cuda:{teacher_index}")
student_device = torch.device(f"cuda:{student_index}")
teacher_tokenizer = AutoTokenizer.from_pretrained(
config["teacher"]["container_path"], local_files_only=True, use_fast=True
)
student_tokenizer = AutoTokenizer.from_pretrained(
config["student"]["container_path"], local_files_only=True, use_fast=True
)
if student_tokenizer.pad_token_id is None:
student_tokenizer.pad_token = student_tokenizer.eos_token
teacher = AutoModelForCausalLM.from_pretrained(
config["teacher"]["container_path"],
local_files_only=True,
dtype=torch.bfloat16,
attn_implementation="sdpa",
).to(teacher_device)
student = AutoModelForCausalLM.from_pretrained(
config["student"]["container_path"],
local_files_only=True,
dtype=torch.bfloat16,
attn_implementation="sdpa",
).to(student_device)
teacher.eval()
for parameter in teacher.parameters():
parameter.requires_grad_(False)
student.train()
student.config.use_cache = False
optimizer = torch.optim.AdamW(
student.parameters(),
lr=float(config["optimizer"]["learning_rate"]),
weight_decay=float(config["optimizer"]["weight_decay"]),
)
scheduler = get_constant_schedule_with_warmup(
optimizer, num_warmup_steps=int(config["optimizer"]["warmup_steps"])
)
loss_config = OmegaConf.create(
{
"clip_ratio": float(config["opd"]["clip_ratio_low"]),
"clip_ratio_low": float(config["opd"]["clip_ratio_low"]),
"clip_ratio_high": float(config["opd"]["clip_ratio_high"]),
"clip_ratio_c": float(config["opd"]["clip_ratio_c"]),
"policy_loss": {
"opd_loss_max_clamp": float(config["opd"]["loss_max_clamp"])
},
"global_batch_info": {},
}
)
writer = SummaryWriter(log_dir=str(tb_dir), flush_secs=5)
fingerprint_before, _ = weight_fingerprint(student)
writer.add_text("run/evidence_class", config["evidence_class"], 0)
writer.add_text("run/source_commit", config["source_commit"], 0)
writer.add_text("run/tracking_backend", "tensorboard", 0)
writer.add_text("run/not_the_upstream_cli", "true", 0)
writer.add_text("run/weight_fingerprint_before", fingerprint_before, 0)
step_metrics: list[dict[str, Any]] = []
run_start = time.perf_counter()
for step_index in range(steps):
optimizer_step = step_index + 1
prompt = prompts[step_index]
student_prompt_text = student_tokenizer.apply_chat_template(
[{"role": "user", "content": prompt}],
tokenize=False,
add_generation_prompt=True,
)
teacher_prompt_text = teacher_tokenizer.apply_chat_template(
[{"role": "user", "content": prompt}],
tokenize=False,
add_generation_prompt=True,
)
student_prompt_ids = student_tokenizer(
student_prompt_text, add_special_tokens=False
)["input_ids"]
teacher_prompt_ids = teacher_tokenizer(
teacher_prompt_text, add_special_tokens=False
)["input_ids"]
student.eval()
generation_start = time.perf_counter()
with torch.no_grad():
prompt_tensor = torch.tensor(
[student_prompt_ids], dtype=torch.long, device=student_device
)
generated = student.generate(
input_ids=prompt_tensor,
attention_mask=torch.ones_like(prompt_tensor),
do_sample=True,
temperature=float(config["rollout"]["temperature"]),
top_p=float(config["rollout"]["top_p"]),
top_k=int(config["rollout"]["top_k"]),
min_new_tokens=int(config["rollout"]["min_new_tokens"]),
max_new_tokens=int(config["rollout"]["max_new_tokens"]),
pad_token_id=student_tokenizer.pad_token_id,
)
torch.cuda.synchronize(student_device)
generation_seconds = time.perf_counter() - generation_start
response_ids = pinned._strip_trailing_special_tokens(
generated[0, len(student_prompt_ids) :].tolist(), student_tokenizer
)
if not response_ids:
raise RuntimeError(f"Step {optimizer_step} produced no response tokens")
response_text = student_tokenizer.decode(
response_ids,
skip_special_tokens=False,
clean_up_tokenization_spaces=False,
)
teacher_response_ids = teacher_tokenizer(
response_text, add_special_tokens=False
)["input_ids"]
if not teacher_response_ids:
raise RuntimeError(
f"Step {optimizer_step} produced no teacher response tokens"
)
score_start = time.perf_counter()
old_logp = pinned._response_logps(
student, student_prompt_ids, response_ids, student_device, grad=False
).detach()
teacher_logp = pinned._response_logps(
teacher, teacher_prompt_ids, teacher_response_ids, teacher_device, grad=False
).detach()
torch.cuda.synchronize(teacher_device)
torch.cuda.synchronize(student_device)
score_seconds = time.perf_counter() - score_start
aligned_cpu, chunk_ids_cpu, chunk_details, teacher_truncated = (
TeacherClient._align_chunks(
response_ids,
teacher_response_ids,
teacher_logp[0].float().cpu(),
student_tokenizer,
teacher_tokenizer,
debug=True,
large_chunk_threshold=int(config["opd"]["large_chunk_threshold"]),
)
)
aligned = aligned_cpu.to(student_device).unsqueeze(0)
chunk_ids = chunk_ids_cpu.to(student_device).unsqueeze(0)
packed_teacher = torch.cat([aligned, chunk_ids], dim=-1)
response_mask = torch.ones_like(old_logp, dtype=torch.float32)
advantage = pinned._project_advantage_for_metrics(
old_logp[0],
aligned[0],
chunk_ids[0],
clamp=float(config["opd"]["loss_max_clamp"]),
)
student.train()
optimizer.zero_grad(set_to_none=True)
update_start = time.perf_counter()
current_logp = pinned._response_logps(
student, student_prompt_ids, response_ids, student_device, grad=True
)
lr_used = float(optimizer.param_groups[0]["lr"])
loss, upstream_metrics = compute_policy_loss_opd(
old_log_prob=old_logp,
log_prob=current_logp,
advantages=packed_teacher,
response_mask=response_mask,
loss_agg_mode=config["opd"]["loss_agg_mode"],
config=loss_config,
)
if not torch.isfinite(loss):
raise RuntimeError(f"Non-finite loss at step {optimizer_step}")
loss.backward()
grad_norm = torch.nn.utils.clip_grad_norm_(
student.parameters(), float(config["optimizer"]["gradient_clip"])
)
if not torch.isfinite(grad_norm):
raise RuntimeError(f"Non-finite grad norm at step {optimizer_step}")
optimizer.step()
scheduler.step()
torch.cuda.synchronize(student_device)
update_seconds = time.perf_counter() - update_start
matched = [detail for detail in chunk_details if detail["type"] == "matched"]
one_to_one = sum(
1 for detail in matched if detail["n_stu"] == 1 and detail["n_tec"] == 1
)
inf_tokens = int(torch.isinf(aligned).sum().item())
valid_tokens = len(response_ids) - inf_tokens
total_seconds = generation_seconds + score_seconds + update_seconds
metrics: dict[str, Any] = {
"optimizer_step": optimizer_step,
"loss/opd_policy": float(loss.detach().item()),
"loss/ppo_kl": float(upstream_metrics["actor/ppo_kl"]),
"loss/clip_fraction": float(upstream_metrics["actor/pg_clipfrac"]),
"loss/clip_fraction_lower": float(
upstream_metrics["actor/pg_clipfrac_lower"]
),
"opd/inf_tokens": inf_tokens,
"opd/inf_ratio": inf_tokens / max(len(response_ids), 1),
"opd/valid_tokens": valid_tokens,
"opd/chunks": len(matched),
"opd/chunks_one_to_one": one_to_one,
"opd/chunks_multi": len(matched) - one_to_one,
"opd/teacher_truncated": int(teacher_truncated),
"logp/student_mean": pinned._mean(old_logp),
"logp/teacher_mean": pinned._mean(teacher_logp),
"logp/student_sum": float(old_logp.detach().sum().item()),
"logp/teacher_sum": float(teacher_logp.detach().sum().item()),
"advantage/mean": pinned._mean(advantage),
"advantage/min": float(advantage.detach().min().item()),
"advantage/max": float(advantage.detach().max().item()),
"advantage/std": float(
advantage.detach().float().std(unbiased=False).item()
),
"tokens/student_prompt": len(student_prompt_ids),
"tokens/student_response": len(response_ids),
"tokens/teacher_prompt": len(teacher_prompt_ids),
"tokens/teacher_response": len(teacher_response_ids),
"timing/generation_seconds": generation_seconds,
"timing/scoring_seconds": score_seconds,
"timing/update_seconds": update_seconds,
"timing/step_seconds": total_seconds,
"throughput/student_response_tokens_per_second": len(response_ids)
/ max(total_seconds, 1e-9),
"optimizer/lr_used": lr_used,
"optimizer/lr_next": float(scheduler.get_last_lr()[0]),
"optimizer/grad_norm_before_clip": float(grad_norm.detach().item()),
**pinned._gpu_metrics("teacher", teacher_index),
**pinned._gpu_metrics("student", student_index),
}
metrics["opd/multi_chunk_ratio"] = metrics["opd/chunks_multi"] / max(
metrics["opd/chunks"], 1
)
metrics["opd/max_student_tokens_per_chunk"] = max(
(detail["n_stu"] for detail in matched), default=0
)
metrics["opd/max_teacher_tokens_per_chunk"] = max(
(detail["n_tec"] for detail in matched), default=0
)
with metrics_path.open("a", encoding="utf-8") as handle:
handle.write(json.dumps(metrics, sort_keys=True) + "\n")
for name, value in metrics.items():
if name != "optimizer_step" and isinstance(value, (int, float)):
if np.isfinite(float(value)):
writer.add_scalar(name, float(value), optimizer_step)
writer.flush()
step_metrics.append(metrics)
print("DPCA_TB_STEP_JSON=" + json.dumps(metrics, sort_keys=True), flush=True)
checkpoint_dir.mkdir(parents=True, exist_ok=False)
student.save_pretrained(checkpoint_dir, safe_serialization=True)
student_tokenizer.save_pretrained(checkpoint_dir)
torch.save(
{
"optimizer": optimizer.state_dict(),
"scheduler": scheduler.state_dict(),
"optimizer_steps": steps,
},
checkpoint_dir / "trainer_state.pt",
)
fingerprint_after, params_with_grad = weight_fingerprint(student)
writer.add_text("run/weight_fingerprint_after", fingerprint_after, steps)
summary = {
"status": "completed",
"evidence_class": config["evidence_class"],
"run_id": config["run_id"],
"optimizer_steps_completed": len(step_metrics),
"not_the_upstream_cli": True,
"tracking_backend": "tensorboard",
"wandb_used": False,
"network_used": False,
"why_not_wandb": (
"company node egress proxy resets api.wandb.ai/wandb.ai (curl rc=56); "
"the pinned CLI raises on offline W&B and Run.id asserts run_id is not "
"None under WANDB_MODE=disabled, so the objective is driven by this "
"launcher with the pinned helpers and verl functions imported unchanged"
),
"reused_pinned_symbols": [
"dpca_2gpu_train._response_logps",
"dpca_2gpu_train._strip_trailing_special_tokens",
"dpca_2gpu_train._project_advantage_for_metrics",
"dpca_2gpu_train._gpu_metrics",
"dpca_2gpu_train._mean",
"dpca_2gpu_train._sha256",
"verl.trainer.ppo.core_algos.compute_policy_loss_opd",
"verl.workers.reward_manager.opd.TeacherClient._align_chunks",
],
"provenance": provenance,
"b200_topology_verified": True,
"gpu_count": expected_gpus,
"device_placement": {
"teacher_device_index": teacher_index,
"student_device_index": student_index,
"shared_device": teacher_index == student_index,
},
"devices": records,
"tensorboard_dir": str(tb_dir),
"checkpoint_dir": str(checkpoint_dir),
"metrics_path": str(metrics_path),
"student_weights_changed": fingerprint_after != fingerprint_before,
"weight_fingerprint_before": fingerprint_before,
"weight_fingerprint_after": fingerprint_after,
"parameters_with_gradients": params_with_grad,
"total_runtime_seconds": time.perf_counter() - run_start,
"final_metrics": step_metrics[-1],
}
(output_dir / "summary.json").write_text(
json.dumps(summary, indent=2, sort_keys=True), encoding="utf-8"
)
writer.close()
print("DPCA_TB_SUMMARY_JSON=" + json.dumps(summary, sort_keys=True), flush=True)
return summary
def main() -> None:
os.environ.setdefault("TOKENIZERS_PARALLELISM", "false")
parser = argparse.ArgumentParser()
parser.add_argument("--config", type=Path, required=True)
parser.add_argument("--output-root", type=Path, default=Path("/runs"))
args = parser.parse_args()
config = json.loads(args.config.read_text(encoding="utf-8"))
summary = run(config, args.output_root / config["run_id"])
expected = int(config["optimizer"]["steps"])
if summary["optimizer_steps_completed"] != expected:
raise RuntimeError(
f"Expected exactly {expected} optimizer steps, "
f"got {summary['optimizer_steps_completed']}"
)
if __name__ == "__main__":
main()