| |
| """Run a bounded ValueCriticModel data/forward/backward/checkpoint smoke. |
| |
| This deliberately uses one local RECAP episode and the tiny ``gemma_1m`` value |
| expert. It validates the wiring and memory envelope; it is not a useful value |
| model training run and its checkpoint must not be used for a paper result. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import gc |
| import json |
| import logging |
| import os |
| from pathlib import Path |
|
|
| os.environ.setdefault("TOKENIZERS_PARALLELISM", "false") |
|
|
| import torch |
| from omegaconf import OmegaConf |
|
|
| from rlinf.data.datasets.recap.value_model import ValueDataset |
| from rlinf.models.embodiment.value_model import get_model |
| from rlinf.models.embodiment.value_model.data_collator import ValueDataCollator |
| from rlinf.models.embodiment.value_model.processing import ValueProcessor |
|
|
|
|
| def _move(value, device): |
| if isinstance(value, torch.Tensor): |
| return value.to(device) |
| if isinstance(value, dict): |
| return {k: _move(v, device) for k, v in value.items()} |
| return value |
|
|
|
|
| def _grad_summary(model: torch.nn.Module) -> tuple[int, float]: |
| count = 0 |
| squared = 0.0 |
| for param in model.parameters(): |
| if param.grad is None: |
| continue |
| count += 1 |
| squared += float(param.grad.detach().float().pow(2).sum().item()) |
| return count, squared**0.5 |
|
|
|
|
| def parse_args() -> argparse.Namespace: |
| root = Path(os.environ.get("PROJECT_ROOT", "/data/myx/RL_post_train")) |
| parser = argparse.ArgumentParser() |
| parser.add_argument( |
| "--dataset", |
| type=Path, |
| default=root / "datasets/recap_value_smoke/libero10_task0_train", |
| ) |
| parser.add_argument( |
| "--siglip", type=Path, default=root / "checkpoints/pretrained/siglip2-so400m-patch14-224" |
| ) |
| parser.add_argument( |
| "--gemma3", type=Path, default=root / "checkpoints/pretrained/gemma-3-270m" |
| ) |
| parser.add_argument( |
| "--tokenizer", |
| type=Path, |
| default=None, |
| help="Tokenizer directory; defaults to --gemma3 (use SigLIP tokenizer for the random smoke fallback).", |
| ) |
| parser.add_argument( |
| "--output", |
| type=Path, |
| default=root / "checkpoints/value/value_smoke_gemma1m", |
| ) |
| parser.add_argument("--critic-expert-variant", default="gemma_1m") |
| parser.add_argument("--max-token-len", type=int, default=64) |
| parser.add_argument("--freeze-vlm", action="store_true") |
| parser.add_argument("--freeze-vision", action="store_true") |
| parser.add_argument("--skip-backward", action="store_true") |
| parser.add_argument( |
| "--steps", |
| type=int, |
| default=10, |
| help="Number of repeated steps on the same micro-batch (wiring smoke only).", |
| ) |
| parser.add_argument("--device", default="cuda") |
| return parser.parse_args() |
|
|
|
|
| def main() -> int: |
| args = parse_args() |
| if args.steps < 1: |
| raise ValueError("--steps must be >= 1") |
| logging.basicConfig(level=logging.INFO) |
| for name, path in (("dataset", args.dataset), ("siglip", args.siglip), ("gemma3", args.gemma3)): |
| if not path.exists(): |
| raise FileNotFoundError(f"{name} path does not exist: {path}") |
| if not torch.cuda.is_available() and args.device.startswith("cuda"): |
| raise RuntimeError("CUDA is required for this preflight; torch.cuda.is_available() is false") |
|
|
| device = torch.device(args.device) |
| torch.manual_seed(0) |
| if device.type == "cuda": |
| torch.cuda.manual_seed_all(0) |
| torch.set_float32_matmul_precision("high") |
|
|
| dataset = ValueDataset( |
| dataset_path=str(args.dataset), |
| robot_type="libero", |
| model_type="pi05", |
| action_horizon=10, |
| action_dim=7, |
| return_min=-779.0, |
| return_max=0.0, |
| normalize_to_minus_one_zero=True, |
| tag="formula_v1", |
| ) |
| processor = ValueProcessor( |
| max_token_len=args.max_token_len, |
| tokenizer_name_or_path=str(args.tokenizer or args.gemma3), |
| do_augment=False, |
| ) |
| collator = ValueDataCollator( |
| processor=processor, |
| max_length=args.max_token_len, |
| train=False, |
| ) |
| batch = collator([dataset[0]]) |
| observation = _move(batch["observation"], device) |
| target_values = _move(batch["target_values"], device) |
| print( |
| "batch=", |
| json.dumps( |
| { |
| "images": {k: list(v.shape) for k, v in observation["images"].items()}, |
| "image_masks": {k: list(v.shape) for k, v in observation["image_masks"].items()}, |
| "tokens": list(observation["tokenized_prompt"].shape), |
| "target_values": target_values.detach().cpu().tolist(), |
| }, |
| sort_keys=True, |
| ), |
| flush=True, |
| ) |
|
|
| cfg = OmegaConf.create( |
| { |
| "precision": "bf16", |
| "critic_expert_variant": args.critic_expert_variant, |
| "num_bins": 201, |
| "v_min": -1.0, |
| "v_max": 0.0, |
| "value_dropout": 0.0, |
| "action_dim": 7, |
| "action_horizon": 10, |
| "max_token_len": args.max_token_len, |
| "siglip_path": str(args.siglip), |
| "gemma3_path": str(args.gemma3), |
| "freeze_vlm": bool(args.freeze_vlm), |
| "freeze_vision_encoder": bool(args.freeze_vision), |
| "train_expert_only": bool(args.freeze_vlm), |
| "forward_mode": "vla", |
| "stop_gradient_to_vlm": bool(args.freeze_vlm), |
| } |
| ) |
| print( |
| "config=", |
| json.dumps(OmegaConf.to_container(cfg, resolve=True), sort_keys=True), |
| flush=True, |
| ) |
|
|
| print("constructing model", flush=True) |
| model = get_model(cfg) |
| total_params = sum(p.numel() for p in model.parameters()) |
| trainable_params = sum(p.numel() for p in model.parameters() if p.requires_grad) |
| print( |
| f"params total={total_params} trainable={trainable_params} " |
| f"cpu_bytes~={sum(p.numel() * p.element_size() for p in model.parameters())}", |
| flush=True, |
| ) |
| model = model.to(device) |
| model.train(not args.skip_backward) |
| if device.type == "cuda": |
| torch.cuda.reset_peak_memory_stats(device) |
|
|
| reference_prediction = None |
| optimizer = None |
| if not args.skip_backward: |
| optimizer = torch.optim.AdamW( |
| [p for p in model.parameters() if p.requires_grad], lr=1e-4 |
| ) |
|
|
| last_grad_count = 0 |
| last_grad_norm = 0.0 |
| print(f"pipeline_steps={args.steps}", flush=True) |
| for step in range(args.steps): |
| if optimizer is not None: |
| optimizer.zero_grad(set_to_none=True) |
| output = model(observation=observation, target_values=target_values) |
| if output.loss is None or not torch.isfinite(output.loss).all(): |
| raise RuntimeError(f"non-finite value loss at step {step}: {output.loss}") |
| if not torch.isfinite(output.predicted_values).all(): |
| raise RuntimeError( |
| f"non-finite predicted values at step {step}: {output.predicted_values}" |
| ) |
| if optimizer is not None: |
| output.loss.backward() |
| last_grad_count, last_grad_norm = _grad_summary(model) |
| if last_grad_count == 0 or not torch.isfinite(torch.tensor(last_grad_norm)): |
| raise RuntimeError( |
| f"no finite gradients at step {step}: " |
| f"count={last_grad_count}, norm={last_grad_norm}" |
| ) |
| optimizer.step() |
| if step in (0, args.steps - 1): |
| print( |
| "step_result=", |
| json.dumps( |
| { |
| "step": step + 1, |
| "loss": float(output.loss.detach().float().cpu()), |
| "predicted_values": output.predicted_values.detach() |
| .float() |
| .cpu() |
| .tolist(), |
| "logits_shape": list(output.logits.shape), |
| "mae": None |
| if output.mae is None |
| else float(output.mae.detach().float().cpu()), |
| }, |
| sort_keys=True, |
| ), |
| flush=True, |
| ) |
|
|
| if optimizer is not None: |
| print( |
| f"backward_result=grad_tensors:{last_grad_count}," |
| f"grad_norm:{last_grad_norm:.6f}", |
| flush=True, |
| ) |
| |
| |
| |
| model.eval() |
| with torch.no_grad(): |
| reference_prediction = model( |
| observation=observation, target_values=None |
| ).predicted_values.detach().cpu() |
| model.train() |
|
|
| |
| |
| if "output" in locals(): |
| del output |
|
|
| args.output.mkdir(parents=True, exist_ok=True) |
| state_dir = args.output / "model_state_dict" |
| state_dir.mkdir(parents=True, exist_ok=True) |
| full_weights = state_dir / "full_weights.pt" |
| state_cpu = {k: v.detach().cpu() for k, v in model.state_dict().items()} |
| torch.save(state_cpu, full_weights) |
| (args.output / "config.json").write_text( |
| json.dumps(OmegaConf.to_container(cfg, resolve=True), indent=2, sort_keys=True) + "\n" |
| ) |
| print(f"saved_checkpoint={full_weights} bytes={full_weights.stat().st_size}", flush=True) |
|
|
| |
| if device.type == "cuda": |
| model = model.cpu() |
| torch.cuda.empty_cache() |
| if not args.skip_backward: |
| del optimizer |
| del model |
| gc.collect() |
| if device.type == "cuda": |
| torch.cuda.empty_cache() |
| print("reloading model", flush=True) |
| reloaded = get_model(cfg) |
| missing, unexpected = reloaded.load_state_dict(torch.load(full_weights, map_location="cpu", weights_only=False), strict=False) |
| if missing or unexpected: |
| raise RuntimeError(f"checkpoint mismatch: missing={missing}, unexpected={unexpected}") |
| reloaded = reloaded.to(device).eval() |
| with torch.no_grad(): |
| reloaded_output = reloaded(observation=observation, target_values=None) |
| if not torch.isfinite(reloaded_output.predicted_values).all(): |
| raise RuntimeError("reloaded model produced non-finite prediction") |
| if reference_prediction is not None: |
| reloaded_cpu = reloaded_output.predicted_values.detach().float().cpu() |
| if not torch.allclose(reloaded_cpu, reference_prediction.float(), atol=1e-5, rtol=1e-4): |
| raise RuntimeError( |
| "checkpoint reload prediction differs from post-update reference: " |
| f"reference={reference_prediction.tolist()} reload={reloaded_cpu.tolist()}" |
| ) |
| print( |
| "reload_result=", |
| json.dumps( |
| {"predicted_values": reloaded_output.predicted_values.detach().float().cpu().tolist()}, |
| sort_keys=True, |
| ), |
| flush=True, |
| ) |
| if device.type == "cuda": |
| print( |
| f"cuda_peak_allocated={torch.cuda.max_memory_allocated(device)} " |
| f"cuda_peak_reserved={torch.cuda.max_memory_reserved(device)}", |
| flush=True, |
| ) |
| print("VALUE_PREFLIGHT_PASS", flush=True) |
| return 0 |
|
|
|
|
| if __name__ == "__main__": |
| raise SystemExit(main()) |
|
|
