monet_code/src/precompute_teacher_reps.py

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("<abs_vis_token_pad>", special_tokens=True)
processor.tokenizer.add_tokens("<abs_vis_token>", special_tokens=True)
processor.tokenizer.add_tokens("</abs_vis_token>", special_tokens=True)
processor.tokenizer.add_tokens("<observation>", special_tokens=True)
processor.tokenizer.add_tokens("</observation>", special_tokens=True)

latent_start_idx = processor.tokenizer("<abs_vis_token>", return_tensors="pt")["input_ids"][0]
latent_end_idx = processor.tokenizer("</abs_vis_token>", return_tensors="pt")["input_ids"][0]
latent_pad_idx = processor.tokenizer("<abs_vis_token_pad>", return_tensors="pt")["input_ids"][0]
observation_start_idx = processor.tokenizer("<observation>", return_tensors="pt")["input_ids"][0]
observation_end_idx = processor.tokenizer("</observation>", 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 <abs_vis_token></abs_vis_token> 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()