import re from glob import glob import os as _early_os # Also import standard os for later usages in this file import os import datetime as _dt # Disable parallelism in HuggingFace tokenizers to avoid fork-related warnings/deadlocks _early_os.environ.setdefault("TOKENIZERS_PARALLELISM", "false") # Enable faster failure and better logs for NCCL collectives _early_os.environ.setdefault("TORCH_NCCL_ASYNC_ERROR_HANDLING", "1") # Remove deprecated var in this process to avoid warnings if present if "NCCL_ASYNC_ERROR_HANDLING" in _early_os.environ: _early_os.environ.pop("NCCL_ASYNC_ERROR_HANDLING", None) _early_os.environ.setdefault("NCCL_DEBUG", "WARN") # change to INFO for deeper debugging _early_os.environ.setdefault("TORCH_NCCL_TRACE_BUFFER_SIZE", "1048576") # enable flight recorder import shutil from functools import partial import torch import torch.nn.functional as F from monet_qwen3_model.modeling_qwen3_vl_monet import Qwen3VLMonetForConditionalGeneration from transformers import Qwen3VLConfig, AutoTokenizer, AutoProcessor from PIL import Image import logging from tqdm import tqdm from trl import SFTTrainer, SFTConfig from qwen_vl_utils import process_vision_info import torch.distributed as dist from src.utils import * from src.task import * from src.trainer import * import random import wandb args=get_args() assert args.save_model_path != "./checkpoints/", "You must specify the save path of the latent embeddings" config = Qwen3VLConfig.from_pretrained(args.load_model_path) model = Qwen3VLMonetForConditionalGeneration.from_pretrained( args.load_model_path, config=config, dtype=torch.bfloat16, attn_implementation="sdpa", ) processor = AutoProcessor.from_pretrained(args.load_model_path, use_fast=False) preprocess_function = task_preporcess_config[args.task] all_train_dataset = [] for data_path in args.data_path: if data_path.endswith('.jsonl'): train_dataset = load_jsonl_dataset(data_path) elif data_path.endswith('.json'): train_dataset = load_json_dataset(data_path) all_train_dataset.extend(train_dataset[:]) if args.shuffle_train: random.seed(42) random.shuffle(all_train_dataset) train_dataset = [] cur_max = -1 for i, sample in tqdm(enumerate(all_train_dataset[:]), desc="Collecting training data and length check...", total=len(all_train_dataset)): processed = preprocess_function(sample, dataset_root=args.dataset_root, allow_no_observation=args.allow_no_observation) if processed is not None: train_dataset.append(processed) # ================= Prepare tokenizer special ids and misc ================= processor.tokenizer.add_tokens("", special_tokens=True) processor.tokenizer.add_tokens("", special_tokens=True) processor.tokenizer.add_tokens("", special_tokens=True) processor.tokenizer.add_tokens("", special_tokens=True) processor.tokenizer.add_tokens("", special_tokens=True) latent_start_idx = processor.tokenizer("", return_tensors="pt")["input_ids"][0] latent_end_idx = processor.tokenizer("", return_tensors="pt")["input_ids"][0] latent_pad_idx = processor.tokenizer("", return_tensors="pt")["input_ids"][0] observation_start_idx = processor.tokenizer("", return_tensors="pt")["input_ids"][0] observation_end_idx = processor.tokenizer("", return_tensors="pt")["input_ids"][0] end_pad_token_idx = processor.tokenizer("<|endoftext|>", return_tensors="pt")["input_ids"][0] answer_start_pattern = processor.tokenizer("<|im_start|>assistant", return_tensors="pt")["input_ids"][0] img_start_idx = processor.tokenizer("<|vision_start|>", return_tensors="pt")["input_ids"][0] img_end_idx = processor.tokenizer("<|vision_end|>", return_tensors="pt")["input_ids"][0] img_pad_idx = processor.tokenizer("<|image_pad|>", return_tensors="pt")["input_ids"][0] SPECIAL_id = { "v_start": img_start_idx, "v_end": img_end_idx, "img_pad": img_pad_idx, "abs_start": latent_start_idx, "abs_end": latent_end_idx, "abs_pad": latent_pad_idx, "obs_start": observation_start_idx, "obs_end": observation_end_idx, } # Resize embeddings to include newly added tokens if needed try: new_vocab_size = len(processor.tokenizer) model.resize_token_embeddings(new_vocab_size) model.config.vocab_size = new_vocab_size except Exception: pass # Configure latent ids on model for downstream logic model.config.latent_token_id = int(latent_pad_idx) model.config.latent_start_id = int(latent_start_idx) model.config.latent_end_id = int(latent_end_idx) model.config.answer_start_pattern = answer_start_pattern.tolist() # Freeze visual to match training behavior and eval-only run for p in model.visual.parameters(): p.requires_grad = False model.eval() try: model.gradient_checkpointing_disable() except Exception: pass def collate_fn_precompute_teacher_rep(examples, alignment="boxed_start"): batch = {} batch['metadata'] = [ex['metadata'] for ex in examples] examples = [ex['data'] for ex in examples] texts = [processor.apply_chat_template(ex, tokenize=False) for ex in examples] # replace with <|vision_start|><|image_pad|><|vision_end|> for each <|im_start|>assistant content texts = [replace_latent_placeholder_with_img_pad(text) for text in texts] ################################################ # teacher ################################################ image_inputs, _ = process_vision_info(examples) if args.image_resize == "global": image_inputs, new_sizes = resize_by_token_budget(image_inputs) elif args.image_resize == "clear_question": image_inputs, new_sizes = resize_diff(image_inputs) # resize_by_token_budget(image_inputs) teacher_texts = texts teacher_batch = processor(text=teacher_texts, images=image_inputs, return_tensors="pt", padding=True) total_image_pads = 0 for txt in texts: total_image_pads += txt.count("<|image_pad|>") assert total_image_pads == len(image_inputs) batch['teacher_pixel_values'] = teacher_batch['pixel_values'] batch['teacher_image_grid_thw'] = teacher_batch['image_grid_thw'] batch['teacher_input_ids'] = teacher_batch['input_ids'] batch['teacher_attention_mask'] = teacher_batch['attention_mask'] if args.allow_no_observation: batch["teacher_aux_image_blocks"] = [ find_aux_image_token_blocks(batch["teacher_input_ids"][b], SPECIAL_id) for b in range(batch["teacher_input_ids"].size(0)) ] elif args.sft_stage2_align_poss == 'obs': observation_start_poss = find_ids_poss(batch["teacher_input_ids"], answer_start_pattern, observation_start_idx) observation_end_poss = find_ids_poss(batch["teacher_input_ids"], answer_start_pattern, observation_end_idx) batch["teacher_observation_poss"] = [] assert len(observation_start_poss) == len(observation_end_poss) for start_poss, end_poss in zip(observation_start_poss, observation_end_poss): poss_of_a_sample = [] if len(start_poss) > 0 and len(end_poss) > 0: assert len(start_poss) == len(end_poss), f"start_poss: {start_poss}, end_poss: {end_poss}" for start, end in zip(start_poss, end_poss): poss_of_a_sample.extend(list(range(start, end))) batch["teacher_observation_poss"].append(poss_of_a_sample) elif args.sft_stage2_align_poss == 'latent_end': batch["latent_end_poss"] = find_ids_poss(batch["teacher_input_ids"], answer_start_pattern, latent_end_idx) return batch def _device() -> torch.device: if torch.cuda.is_available(): local_rank = int(os.environ.get("LOCAL_RANK", os.environ.get("RANK", 0))) try: torch.cuda.set_device(local_rank) except Exception: pass return torch.device(f"cuda:{local_rank}") return torch.device("cpu") def _scan_existing_reps(save_dir: str, align_poss = "obs") -> set[str]: """Scan existing rep_*.pt files and return a set of metadata_info strings. Expected filename pattern: rep_{metadata_info}.pt """ if not os.path.isdir(save_dir): return set() done = set() if align_poss == 'obs': pattern = r"^rep_(.+)\.pt$" elif align_poss == 'latent_end': pattern = r"^rep_latent_end_(.+)\.pt$" for p in glob(os.path.join(save_dir, "rep_*.pt")): fname = os.path.basename(p) m = re.match(pattern, fname) if m: done.add(m.group(1)) return done def _expected_metadata_info(metadata: dict, args) -> str: """Build the expected metadata_info string for a sample metadata dict.""" dataset_name = metadata["dataset_name"] sample_id = metadata["sample_id"] # Match the prefix rule used by the saving code. The no_observation branch is # driven by --alignment_layer; the legacy obs branch by --output_latent_embeds. if getattr(args, "allow_no_observation", False): prefix = getattr(args, "alignment_layer", "all_layers") or "all_layers" elif getattr(args, "output_latent_embeds", False): prefix = "last_layer" else: prefix = "all_layers" return f"{prefix}_{dataset_name}_{sample_id}" def _filter_indices_by_resume(train_dataset: list, args, align_poss = "obs") -> list[int]: """When --resume is on, drop indices that are already computed in save dir.""" save_dir = args.save_model_path done = _scan_existing_reps(save_dir, align_poss = align_poss) # Build a deterministic list of indices to compute keep = [] for idx, ex in enumerate(train_dataset): md = ex["metadata"] info = _expected_metadata_info(md, args) if info not in done: keep.append(idx) return keep def _get_sample_hidden_states(hidden_states, b: int, batch_size: int): """ Return hidden states for sample b as [num_layers, seq_len, dim]. The local model wrapper returns either per-sample tensors or per-layer tensors, depending on whether alignment positions were provided. """ if not hidden_states: raise RuntimeError("Model did not return hidden_states; pass --output_hidden_states.") first = hidden_states[0] if torch.is_tensor(first) and first.dim() == 3 and len(hidden_states) == batch_size: return hidden_states[b] if torch.is_tensor(first) and first.dim() == 3 and first.size(0) == batch_size: return torch.stack([layer[b] for layer in hidden_states], dim=0) raise RuntimeError(f"Unsupported hidden_states format for aux pooling: {type(first)}") def main(): # Initialize distributed if requested world_size = int(os.environ.get("WORLD_SIZE", "1")) is_dist = world_size > 1 if is_dist and not (dist.is_available() and dist.is_initialized()): # Use a generous timeout to avoid false positives on large models dist.init_process_group(backend="nccl", timeout=_dt.timedelta(minutes=30)) try: rank = dist.get_rank() if (dist.is_available() and dist.is_initialized()) else 0 local_rank = int(os.environ.get("LOCAL_RANK", os.environ.get("RANK", 0))) device = _device() model.to(device) # Save dir for latents out_dir = args.save_model_path os.makedirs(out_dir, exist_ok=True) # Iterate data and precompute bs = max(1, int(getattr(args, 'bsz', 1))) total = len(train_dataset) # ===== Resume support: drop finished samples ===== if getattr(args, "resume", False): # Each rank computes the same filtered index list to avoid desync indices_to_process = _filter_indices_by_resume(train_dataset, args, align_poss = args.sft_stage2_align_poss) total = len(indices_to_process) if rank == 0: logging.info(f"[resume] filtered unfinished samples: {total} remain (out of {len(train_dataset)}).") else: indices_to_process = list(range(total)) if is_dist: # Cross-rank consistency check for dataset length; mismatch is a common source of collective hangs try: t = torch.tensor([total], device=device) gathered = [torch.zeros_like(t) for _ in range(world_size)] dist.all_gather(gathered, t) totals = [int(x.item()) for x in gathered] if len(set(totals)) != 1: if rank == 0: logging.error(f"[precompute] dataset length mismatch across ranks: {totals}. " f"This can lead to deadlocks. Exiting.") return except Exception as e: if rank == 0: logging.warning(f"[precompute] total all_gather check failed: {e}") if rank == 0: logging.info(f"[precompute] total samples={total}, batch_size={bs}, saving to {out_dir}; world_size={world_size}") # Build index shards per rank indices = list(range(total)) if is_dist: per = (total + world_size - 1) // world_size start_idx = rank * per end_idx = min(total, (rank + 1) * per) shard = indices_to_process[start_idx:end_idx] else: shard = indices_to_process # Avoid early barriers that can deadlock if any rank errors; not required for independent precompute with torch.inference_mode(): rng = range(0, len(shard), bs) pbar = tqdm(rng, desc=f"[rank {rank}] precompute", disable=False) for i in pbar: cur_ids = shard[i:i+bs] try: examples = [train_dataset[j] for j in cur_ids] batch = collate_fn_precompute_teacher_rep(examples) if args.allow_no_observation: alignment_poss = [[] for _ in range(batch['teacher_input_ids'].size(0))] elif args.sft_stage2_align_poss == 'obs': alignment_poss = batch['teacher_observation_poss'] elif args.sft_stage2_align_poss == 'latent_end': alignment_poss = batch['latent_end_poss'] inputs = { 'latent_mode': False, 'input_ids': batch['teacher_input_ids'].to(device), 'attention_mask': batch['teacher_attention_mask'].to(device), 'pixel_values': batch['teacher_pixel_values'].to(device), 'image_grid_thw': batch['teacher_image_grid_thw'].to(device), 'labels': None, 'alignment_poss': alignment_poss, 'loss_type': [], } if args.output_latent_embeds: inputs['output_latent_embeds'] = True if args.output_hidden_states: inputs['output_hidden_states'] = True outputs = model(**inputs, return_dict=True) if args.allow_no_observation: if not args.output_hidden_states: raise RuntimeError("--allow_no_observation teacher rep precompute requires --output_hidden_states") hidden_states = outputs.hidden_states batch_size = batch['teacher_input_ids'].size(0) # alignment_layer drives both content shape and filename prefix, matching # what load_offline_tensor expects and what the online teacher writes. align_layer = getattr(args, 'alignment_layer', 'all_layers') or 'all_layers' for b in range(batch_size): blocks = batch["teacher_aux_image_blocks"][b] if not blocks: continue hs_sample = _get_sample_hidden_states(hidden_states, b, batch_size) if align_layer == 'last_layer': hs_for_pool = hs_sample[-1:, :, :] # [1, T, D] else: hs_for_pool = hs_sample # [L+1, T, D] pooled_per_aux = [] for idx in blocks: if idx.numel() == 0: continue idx = idx.to(hs_for_pool.device) hs_aux = hs_for_pool[:, idx, :] h = hs_aux.permute(0, 2, 1) h = F.adaptive_avg_pool1d(h, args.latent_size) pooled_per_aux.append(h.permute(0, 2, 1)) if not pooled_per_aux: continue pooled = torch.cat(pooled_per_aux, dim=1) # [layers, N*latent_size, D] if align_layer == 'last_layer': pooled = pooled.squeeze(0) # [N*latent_size, D] metadata = batch['metadata'][b] metadata_info = f"{align_layer}_{metadata['dataset_name']}_{metadata['sample_id']}" save_path = os.path.join(out_dir, f"rep_{metadata_info}.pt") torch.save({'metadata_info': metadata_info, 'latent': pooled.detach().cpu()}, save_path) continue if args.output_latent_embeds: # output latent embeddings only for last layer teacher_reps = outputs.latent_embeds elif args.output_hidden_states: # output hidden states for all layers (can also output hidden states of all layers for latents) teacher_reps = outputs.hidden_states # Save per global sample index to avoid collisions B = len(teacher_reps) for b in range(B): metadata = batch['metadata'][b] dataset_name = metadata['dataset_name'] sample_id = metadata['sample_id'] if args.output_latent_embeds: metadata_info = f"last_layer_{dataset_name}_{sample_id}" elif args.output_hidden_states: metadata_info = f"all_layers_{dataset_name}_{sample_id}" if args.sft_stage2_align_poss == 'obs': metadata_str = f"rep_{metadata_info}.pt" elif args.sft_stage2_align_poss == 'latent_end': metadata_str = f"rep_latent_end_{metadata_info}.pt" save_path = os.path.join(out_dir, metadata_str) torch.save({'metadata_info': metadata_info, 'latent': teacher_reps[b].detach().cpu()}, save_path) except Exception as e: logging.exception(f"[rank {rank}] Failed at batch start={i}, ids={cur_ids}: {e}") # Continue processing other batches instead of crashing and hanging other ranks continue # Avoid a final barrier; log completion per-rank to prevent deadlocks if any rank terminated early logging.info(f"[precompute] rank {rank} done. Latents saved under: {out_dir}") finally: if is_dist and dist.is_available() and dist.is_initialized(): try: dist.destroy_process_group() except Exception as e: logging.warning(f"[precompute] destroy_process_group failed: {e}") if __name__ == "__main__": main()