Paper Notes

LocateAnything: Fast and High-Quality Vision-Language Grounding with Parallel Box Decoding

作者Shihao Wang, Shilong Liu, Yuanguo Kuang, Xinyu Wei, Yangzhou Liu, Zhiqi Li, Yunze Man, Guo Chen, Andrew Tao, Guilin Liu, Jan Kautz, Lei Zhang, Zhiding Yu
机构NVIDIA and collaborators; paper source uses numeric author superscripts but does not expand all affiliations
发表arXiv preprint · 2026
参考论文: arxiv.org项目: research.nvidia.comGitHub代码: huggingface.co

28分钟阅读

LocateAnything: Fast and High-Quality Vision-Language Grounding with Parallel Box Decoding

Paper: arXiv:2605.27365 Code: nvidia/LocateAnything-3B Project/GitHub: NVlabs/Eagle/Embodied Code reference: HF main @ 7a81d810 (2026-05-27); GitHub project main @ c3c08afe (2026-05-27)

1. Motivation (研究动机)

现有 VLM grounding 的核心问题

当前很多 Vision-Language Model (VLM) 把 visual grounding / detection 写成一个 generative coordinate-token problem：模型先读图像和文本 query，然后像生成普通文本一样逐 token 输出坐标。常见坐标表示有两类：

  • Textual Digits：把坐标值当成字符序列，例如 1024 被拆成 1, 0, 2, 4；
  • Quantized Tokens：把坐标离散到 [0, 1000] 之类的空间，再按 $x_1 \rightarrow y_1 \rightarrow x_2 \rightarrow y_2$ 顺序生成。

这两类方法的共同缺陷是：一个二维几何对象被强行序列化成一维 token stream。bounding box 的四个坐标并不是彼此独立的文本 token；它们共同决定一个空间区域。逐 token decoding 会带来两个直接问题：

  1. 几何耦合被破坏：x_1, y_1, x_2, y_2 本应作为一个 atomic geometric unit 被预测，序列化之后模型可能在局部 token 上高置信，但整体 box 形状、大小、边界不协调，尤其在 high-IoU 阈值下表现差。
  2. 推理延迟高：每个 box 至少需要多个自回归 step；多目标检测时，目标数越多，coordinate token 越长，strictly sequential generation 会成为 inference bottleneck。

Figure 1 解读：上半部分展示 LocateAnything 支持的任务范围，包括 object detection、referring grounding、OCR/text localization、GUI grounding、pointing 等；下半部分对比三种坐标 decoding。Textual digits 和 quantized coordinates 都是逐 token 生成，而 Parallel Box Decoding 把一个 box / point 当成一个几何单元一次性生成，因此目标不是“让语言模型更会写坐标”，而是让输出结构本身更贴近几何对象。

论文要解决的具体目标

本文要解决的不是单一 benchmark 上的检测精度，而是一个更系统的问题：如何让 VLM 在统一 generative 框架内，同时做到高质量 localization 和高吞吐 coordinate decoding。换句话说，作者希望同一个模型既能处理开放词表、多任务、自由文本 query，又不牺牲 detection/grounding 对 box precision 和 inference speed 的要求。

该目标有两个技术约束：

  • 不能退回传统 specialized detector，因为它们虽然快，但 instruction following 和开放语义覆盖不如 VLM；
  • 不能简单套用普通 Multi-Token Prediction (MTP)，因为任意 chunk 的并行 token 预测不理解 box 边界，会产生 irregular / incoherent coordinate pattern。

为什么值得研究

如果 VLM 可以低延迟、高精度地输出 boxes / points，它就能成为 embodied agent、GUI agent、robot perception、document understanding、scene-text localization 的统一 perception interface。对交互系统而言，grounding 不只是“识别物体”，而是把自然语言意图绑定到可执行空间位置：点击按钮、抓取目标、定位文字块、在拥挤场景中区分相邻实例。LocateAnything 的价值在于把这个能力放进一个 generalist VLM，同时用 Parallel Box Decoding 降低 coordinate generation 的成本。

2. Idea (核心思想)

一句话核心洞察

LocateAnything 的核心洞察是：box / point 不是一串普通 token，而是一个固定长度、几何耦合的 atomic block；只要训练目标和 attention mask 都按 block 对齐，MTP 就可以并行生成完整几何单元，而不是破坏坐标结构。

关键创新

本文提出 Parallel Box Decoding (PBD)：把输出序列重组为 fixed-length box-aligned blocks，每个 block 长度为 $L=6$，可表示 semantic text、box、negative 或 end 状态。训练时同时优化标准 Next-Token Prediction (NTP) 和 block-wise Multi-Token Prediction (MTP)：NTP 保留语言模型的 causal reasoning，MTP 学会一次预测一个 box 内的多个坐标 token。推理时提供 Slow / Fast / Hybrid 三种 mode，其中 Hybrid 默认用 MTP，但在 format irregularity 或 spatial ambiguity 出现时回退到 NTP 重新解码问题 block。

与已有方法的本质区别

与 Rex-Omni / Kosmos / Ferret 等逐 token 坐标生成不同，PBD 不把 $x_1, y_1, x_2, y_2$ 看成四个独立时间步；与普通 MTP / block diffusion 不同，PBD 的 block 边界与 box / point 语义边界对齐。普通 MTP 可能把一个 box 的坐标和结构 token 随机切在同一 chunk 里，产生不规则分布；PBD 则显式定义 Semantic / Box / Negative / End blocks，让并行预测的最小单位就是几何对象。

Figure 2 解读：NTP 是最稳但最慢的方案；普通 MTP 虽然并行，但 block 与几何结构不对齐，因此容易出现不连贯 token pattern；PBD 的关键是把 block 与 box / point 对齐，使并行化不再是任意 token chunking，而是结构化 coordinate unit prediction。

3. Method (方法)

3.1 Overall framework：native-resolution VLM + box-aligned blocks

LocateAnything 构建在 native-resolution VLM 之上。paper source 中的 architecture 描述为：Moon-ViT vision encoder 提取原始分辨率下的视觉 tokens $Z = \mathrm{Encoder}(\mathcal{I})$，MLP projector 连接到 Qwen2.5 language decoder，然后 decoder 直接生成 box-aligned block sequence。HF model card 对应实现为 3B 参数模型：vision encoder 是 MoonViT，language model 是 Qwen2.5-3B-Instruct，multimodal projector 是 MLP。

形式化地，连续坐标先被归一化到 [0, 1000] 并离散为 coordinate tokens。输出不再是普通 token 序列，而是 blocks： 其中 $\mathcal{E}$ 是文本 query。每个 $b_i$ 是长度 $L=6$ 的 atomic unit；空位用 <null> padding，保证 MTP 预测时 tensor shape 固定。

Figure 3 解读：图中最重要的是 block-based output representation。LocateAnything 定义四类 block：Semantic Block 表示目标类别或自然语言片段；Box Block 表示 <box> 加四个量化坐标再加 </box>；Negative Block 表示 query 对应目标不存在；End Block 表示输出终止。这个设计把“检测结果的语义”和“检测结果的几何”放进统一 token grammar，同时让每个 box 的四个坐标在同一并行 block 内被联合预测。

四类 block 的作用

  • Semantic Block：编码 linguistic identity；如果表达式超过一个 block 容量，会拆到多个连续 semantic blocks。
  • Box Block：编码四个 quantized coordinates，代表一个 bounding box；pointing task 中也可用两个坐标加结构 token 表示 point。
  • Negative Block：显式表示 queried object 不存在，避免模型在负样本上 hallucinate boxes。
  • End Block：表示 generation process 结束。

这个 block grammar 的直觉是：模型不应该在“生成到 $x_2$ 时才知道 $x_1$ 是什么”，而应该在一个局部 fully connected block 内同时考虑四个坐标的相互约束。这样做对 high-IoU localization 特别重要，因为 IoU=0.95 对 box 边界误差非常敏感。

3.2 Dual-formulation training：同时保留 NTP 与 MTP

直接把输出改成并行 block 会破坏 language model 原有的 causal generation 习惯。LocateAnything 因此采用 dual-formulation training：同一份 ground truth 被写成两种形式，一种是标准 token-level NTP sequence，另一种是 block-level MTP sequence。

训练输入为： 其中 $x_{\text{vis}}$ 和 $x_{\text{q}}$ 是共享上下文，$x_{\text{ntp}}$ 是标准自回归输出，$x_{\text{blk}}$ 是按照 block rules 构造的 MTP 输入。构造 $x_{\text{blk}}$ 时，作者从左到右遍历 $x_{\text{ntp}}$，按 block 边界 split / pad；每个 block 保留第一个 token 作为 prediction context，其余 token 替换成 [mask]，让模型一次预测同 block 内的所有 masked tokens。若 block size 退化到 1，这个 MTP formulation 就等价于 NTP。

训练目标是两项交叉熵之和： $\mathcal{L}_{\mathrm{ntp}}$ 保留顺序语言建模能力，$\mathcal{L}_{\mathrm{mtp}}$ 让模型学习 box-aligned parallel prediction。两者不是冗余：只有 MTP 会快但不稳，只有 NTP 会稳但慢；联合训练把“会按语言顺序解释 query”和“会按几何单位输出坐标”绑定在一起。

Figure 4 解读：attention mask 是 dual-formulation training 能成立的关键。shared context 和 NTP stream 使用 causal attention；MTP blocks 之间是 block-causal，即当前 block 只能看之前 blocks；同一 MTP block 内部是 bidirectional attention，使坐标 token 能互相通信。NTP 与 MTP stream 被隔离，避免答案泄漏，但二者都能 attend 到共享视觉和 query context。

3.3 Attention mask 与推理时 KV cache 一致性

PBD 的 attention 不是普通 causal mask。训练时同一 block 内要双向可见，以捕获 $x_1, y_1, x_2, y_2$ 的几何依赖；block 与 block 之间仍保持 causal order，保证第 $i$ 个目标不能偷看未来输出。推理时，每个 MTP decoding step 的 mask 复用训练时的 block-causal pattern：已经 committed 的 prefix 保持标准 causal attention；当前 $n_{\text{future}}$ tokens 彼此双向 attend，并能看历史 blocks。

HF released code 中，modeling_locateanything.py::generate() 的默认 n_future_tokens=6，对应 paper 的 block length $L=6$。代码会把当前最后一个 token、未来 mask tokens 拼到 generated_with_mask，并调整最后 $n_{\text{future}}$ 个 position ids，让同一 decoding window 使用一致位置。每次 MTP forward 后，代码会 truncate KV cache，只保留 committed tokens，移除 mask tokens 和 duplicated anchor，避免 cache 状态与训练时 causal prefix 不一致。

3.4 On-demand inference modes：Slow / Fast / Hybrid

PBD 提供三种推理 mode：

  • Slow Mode：纯 NTP / AR，逐 token 生成。最慢，但复杂场景最稳。
  • Fast Mode：纯 MTP，始终按 box-aligned block 并行生成；吞吐最高，但在密集场景或类别边界处可能出错。
  • Hybrid Mode：默认使用 MTP；一旦检测到 format irregularity 或 spatial ambiguity，就丢弃当前问题 block，回到上一个 verified prefix，用 NTP 重新生成该 block；block 完成后再切回 MTP。

论文中定义的两类失败模式是：

  1. Format Irregularity：复杂场景中存在多个类别和实例时，模型可能在 block 内混入错误结构 token，例如 <box><211></ref><911><887></box>。
  2. Spatial Ambiguity：物体呈网格或密集排列时，MTP 可能在两个相邻物体之间输出中间坐标，导致 IoU 下降。

论文文字给出的 ambiguity trigger 是：top-1 coordinate token probability 低于 0.7，且 top-5 coordinate tokens 的 max-min 差值在 [0,1000] 归一化空间内超过 80。released HF code 与论文有一个实现差异：generate_utils.py::decode_bbox_avg() 中实际使用的是 first_valid_probs < 0.9 且 (valid_max - valid_min) > 60，论文阈值 0.7 / 80 保留在注释里。

论文公式与 released code 实现差异：Hybrid Mode 的 spatial ambiguity 阈值在论文正文中写作 prob < 0.7 且 spread > 80，但 HF snapshot 7a81d810 的 generate_utils.py 实际执行 prob < 0.9 且 spread > 60。因此笔记中的伪代码以 released code 为准，并在实验解释中把论文阈值视为报告描述而非当前代码默认值。

Figure 5 解读：图示的是 Hybrid Mode 的纠错路径。MTP 先预测一个完整 block；若 block syntax 不合法或空间置信度异常，系统不强行提交该 block，而是回退到最近的可靠 prefix，用 NTP 重新解码。这个机制保留了大多数简单目标上的并行速度，同时把错误集中在少数 difficult blocks 上处理。

3.5 LocateAnything-Data：大规模多域 grounding 数据引擎

除了 PBD，论文的第二个重要贡献是 LocateAnything-Data。HF model card 总结为 12M unique images、138M+ queries、785M bounding boxes；paper source 的统计表按六个 domain 给出超过 139M queries 和超过 22M negative samples。数据覆盖 detection、GUI、referring、OCR、layout、pointing 等场景。

数据构造有两条路径：

  1. 已有 detection datasets 有 gt boxes：以 box category 为 prompt，调用 Qwen3-VL 合成更丰富的 object-centric queries，包括属性、空间关系、reasoning cues；再用 Molmo 预测 candidate points，只保留落在 gt boxes 内的 points，作为可靠监督。
  2. 无标注高质量图像：Qwen3-VL 直接根据图像生成 diverse queries；这些 query 可以交给 Molmo 预测 point，再用 SAM 3 生成 boxes，也可以直接交给 Rex-Omni 生成 boxes；最后所有生成 boxes 再由 Qwen3-VL post-verify。

作者还显式构造 negative samples，因为传统 detection / grounding 数据几乎全是 positive samples，会让模型在 query 与图像无关时仍输出 box。负样本的加入对应 Negative Block，目的是让模型学会“没有目标”也是合法输出。

Figure 6 解读：上半部分展示从已有 gt boxes 出发的数据扩展：类别 prompt 经过 Qwen3-VL 变成自然语言 query，再由 Molmo 产生 points 并用 gt boxes 过滤。下半部分展示无标注图像路径：query、point、mask/box、verification 由多个强模型协作产生。这是一个 model-assisted data engine，不只是简单合并公开数据集。

Figure 7 解读：该图给出 LocateAnything-Data 的任务分布。query 维度中 detection 占最大比例，其次是 GUI、referring、OCR、layout 和 pointing；这解释了为什么模型既能做通用 object detection，也能覆盖 GUI / OCR / document layout 等 VLM agent 更常用的 grounding 场景。

数据规模与分布

DomainQueriesNegativeMean targets/queryMean categories/queryMean query lengthMax targets/image
Detection93,351,37321,021,5096.292.4724.193,725
GUI23,009,53501.031.034.078,690
Referring10,141,59793,3962.120.895.486,938
OCR5,052,040011.8910.401.172,337
Layout4,859,9141,384,8044.921.312.20880
Pointing3,148,098353,3663.250.892.631,575

Figure 8 解读：targets per query 是长尾分布。多数 query 对应少量目标，但仍有不可忽略的 query 关联大量实例，这正是 dense detection / multi-target grounding 的难点。PBD 的收益会随目标数增多而变明显，因为逐 token decoding 的时间基本随 box 数线性增长。

Figure 9 解读：query length / category distribution 反映不同 domain 的语言复杂度差异。Detection query 往往包含属性和关系，OCR / layout 更接近短标签，GUI query 则常是 task-oriented instruction。这说明 LocateAnything 不是只学习固定类别检测，而是在多种文本粒度上学习空间对齐。

3.6 伪代码：基于 released HF code 的实现逻辑

下面的伪代码锚定 HF nvidia/LocateAnything-3B snapshot 7a81d810，并结合 paper source 中未公开为代码的数据构造 / 训练描述。released GitHub NVlabs/Eagle/Embodied 当前只含 LocateAnything.pdf，不含 PBD training launch scripts；因此训练超参数只能引用 paper source supp/training_details.tex，不能从 GitHub launch config 反推。

3.6.1 Block-wise generation loop (modeling_locateanything.py::generate)

@torch.no_grad()
def locateanything_generate(model, tokenizer, pixel_values, input_ids,
                            generation_mode="hybrid", n_future_tokens=6,
                            max_new_tokens=2048, use_cache=True):
    assert input_ids.shape[0] == 1
    assert generation_mode in {"fast", "slow", "hybrid"}
    assert use_cache
 
    visual_features = model.extract_feature(pixel_values)
    generated = input_ids.clone()
    use_mtp = generation_mode in {"fast", "hybrid"}
    kv_cache = None
 
    while generated.size(1) < input_ids.size(1) + max_new_tokens:
        if use_mtp:
            # append duplicated anchor + future mask slots; all future slots share a block window
            mtp_inputs = prepare_inputs_in_mtp(
                generated,
                n_future_tokens=n_future_tokens,
                visual_features=visual_features,
                past_key_values=kv_cache,
            )
            outputs = model.language_model(**mtp_inputs, use_cache=True)
            kv_cache = truncate_cache_to_committed_prefix(outputs.past_key_values, generated)
 
            probs, confidence, sampled, _ = sample_tokens(
                outputs.logits[:, -n_future_tokens:, :],
                generated,
                model.token_ids,
                generation_mode=generation_mode,
            )
            pattern = handle_pattern(sampled[0].tolist(), model.token_ids, generation_mode)
            out_type = pattern["type"]
            out_tokens = torch.tensor(pattern["tokens"], device=generated.device)
        else:
            ar_inputs = prepare_inputs_in_ar(generated, visual_features, kv_cache)
            outputs = model.language_model(**ar_inputs, use_cache=True)
            kv_cache = outputs.past_key_values
            out_type, out_tokens = sample_one_ar_token(outputs.logits[:, -1:, :], generated)
 
        generated = torch.cat([generated, out_tokens.unsqueeze(0)], dim=1)
 
        if out_type == "im_end":
            break
        if generation_mode == "hybrid":
            if out_type == "error_box":
                use_mtp = False      # re-decode current block using AR/NTP
            elif out_type == "box_end_ar":
                use_mtp = True       # switch back to MTP after a valid AR box
 
    return tokenizer.batch_decode(generated[:, input_ids.size(1):], skip_special_tokens=False)

3.6.2 Box pattern validation and fallback (generate_utils.py::handle_pattern)

def handle_pattern(tokens, ids, generation_mode="hybrid"):
    if tokens[0] in {ids["null_token_id"], ids["im_end_token_id"]}:
        return {"type": "im_end", "tokens": [ids["im_end_token_id"]]}
 
    if tokens[:2] == [ids["box_start_token_id"], ids["none_token_id"]]:
        return {
            "type": "empty_box",
            "tokens": [ids["box_start_token_id"], ids["none_token_id"], ids["box_end_token_id"]],
        }
 
    if tokens[0] == ids["box_start_token_id"]:
        coord_ix = 1
        for tok in tokens[1:5]:
            if ids["coord_start_token_id"] <= tok <= ids["coord_end_token_id"]:
                coord_ix += 1
            else:
                break
 
        if coord_ix == 5 and tokens[5] == ids["box_end_token_id"]:
            return {"type": "coord_box", "tokens": tokens}
        if coord_ix == 3 and tokens[3] == ids["box_end_token_id"]:
            return {"type": "point_box", "tokens": tokens[:4]}
 
        if generation_mode == "fast":
            return {"type": "coord_box", "tokens": tokens}
        return {"type": "error_box", "tokens": tokens[:coord_ix], "need_switch_to_ar": True}
 
    return {"type": "ref_object", "tokens": trim_after_ref_end(tokens, ids)}

3.6.3 Hybrid spatial ambiguity check (generate_utils.py::decode_bbox_avg)

def decode_bbox_avg(probs, ids, keep_k=5, generation_mode="hybrid"):
    pos_probs, pos_ids = torch.topk(probs[1:5], k=keep_k, dim=-1)
    coord_mask = (pos_ids >= ids["coord_start_token_id"]) & (pos_ids <= ids["coord_end_token_id"])
    if not coord_mask.any(dim=-1).all():
        return None
 
    first_idx = coord_mask.long().argmax(dim=-1, keepdim=True)
    first_valid_probs = pos_probs.gather(-1, first_idx).squeeze(-1)
    first_valid_ids = pos_ids.gather(-1, first_idx).squeeze(-1)
 
    if generation_mode == "hybrid":
        valid_counts = coord_mask.sum(dim=-1)
        valid_max = torch.where(coord_mask, pos_ids, -999999).max(dim=-1).values
        valid_min = torch.where(coord_mask, pos_ids, 999999).min(dim=-1).values
        # released code threshold, not the paper-text 0.7 / 80 threshold
        is_abnormal = (first_valid_probs < 0.9) & (valid_counts > 1) & ((valid_max - valid_min) > 60)
        final_coords = torch.where(is_abnormal, torch.zeros_like(first_valid_ids), first_valid_ids)
    else:
        final_coords = first_valid_ids
 
    return torch.cat([ids.box_start, final_coords, ids.box_end])

3.6.4 Data engine（paper source，未在 released code 中公开）

def build_locateanything_data(images, detection_datasets, unlabeled_images):
    records = []
 
    for image, gt_boxes in detection_datasets:
        for category, boxes in group_by_category(gt_boxes):
            queries = qwen3_vl_generate_object_queries(image, category, boxes)
            for query in queries:
                points = molmo_predict_points(image, query)
                kept = [p for p in points if inside_any_gt_box(p, boxes)]
                if kept:
                    records.append(make_positive_query(image, query, boxes, kept))
                records.extend(make_domain_specific_negative_queries(image, query, boxes))
 
    for image in unlabeled_images:
        queries = qwen3_vl_generate_queries_from_image(image)
        for query in queries:
            points = molmo_predict_points(image, query)
            boxes_from_points = sam3_segment_to_boxes(image, points)
            boxes_from_vlm = rex_omni_predict_boxes(image, query)
            boxes = qwen3_vl_verify_boxes(image, query, boxes_from_points + boxes_from_vlm)
            if boxes:
                records.append(make_positive_query(image, query, boxes))
 
    return deduplicate_and_balance(records)

3.7 Code-to-paper mapping

Code reference: HF main @ 7a81d810 (2026-05-27) — pseudocode and mapping based on this snapshot. GitHub project NVlabs/Eagle @ c3c08afe (2026-05-27) currently links the paper under Embodied/LocateAnything.pdf; the PBD implementation files are in the Hugging Face model repo.

Paper ConceptSource FileKey Class/Function
LocateAnything VLM wrappermodeling_locateanything.pyLocateAnythingModel, generate()
Fast / Slow / Hybrid generation modesmodeling_locateanything.pygenerate(), _prepare_inputs_in_mtp(), _sample_token_in_mtp(), _sample_token_in_ar()
PBD token sampling and box decodinggenerate_utils.pysample_tokens(), decode_bbox_avg(), handle_pattern()
Box / coordinate / special token IDsconfiguration_locateanything.py, tokenizer JSON filesLocateAnythingConfig, get_token_ids_from_config()
Block / causal / bidirectional attention masksmask_sdpa_utils.py, mask_magi_utils.py, modeling_qwen2.pycreate_block_diff_mask_by_pe_4d(), build_magi_ranges()
Processor and inference worker interfaceprocessing_locateanything.py, README.mdLocateAnythingProcessor, model-card LocateAnythingWorker.predict()
Training data enginepaper source sec/X_0_suppl.tex, supp/data.texreleased HF/GitHub code does not include data-engine implementation
Training hyperparameterspaper source supp/training_details.texreleased HF/GitHub code does not include LocateAnything training launch config

4. Experimental Setup (实验设置)

训练流程与模型配置

模型配置来自 paper source 和 HF model card：LocateAnything-3B 是 native-resolution VLM，vision encoder 为 MoonViT，language decoder 为 Qwen2.5-3B-Instruct，projector 为 MLP。训练分四个 progressive stages；其中前两阶段做 world-knowledge injection，后两阶段做 detection & grounding enhancement。

训练超参数来自 supp/training_details.tex，不是 released code launch script；released HF/GitHub snapshot 未公开 LocateAnything training launch config（released HF/GitHub code does not include LocateAnything training launch config）。

StageObjectiveDatasetLRMax seq lenTrainableGPUsSteps
Stage 1World Knowledge InjectionCaption$2\times10^{-4}$32768MLP642,000
Stage 2World Knowledge InjectionGeneral VQA$4\times10^{-5}$32768All25620,000
Stage 3Detection & Grounding EnhancementDetection & Grounding$4\times10^{-5}$25600All25625,000
Stage 4Detection & Grounding Enhancement20% previous + dense$1\times10^{-5}$25600All2565,000

四个阶段均使用 AdamW，weight decay 为 0.01，LR schedule 为 Cosine。正文还说明：Stage-1 将 138M queries 混入总体训练数据，Stage-2 降低 general data 比例到 20%，并增加 MOT20Det、SKU110K 等 many-objects-per-image 数据，以增强 dense detection。

数据集与任务

训练数据覆盖六个 domain：Detection、GUI、Referring、OCR、Layout、Pointing。HF model card 汇总为 12M unique images、138M+ natural-language queries、785M bounding boxes；paper source 的 query statistics 表给出总计约 139.56M queries 和 22.85M negative samples。

评测集覆盖：

  • Common object detection：LVIS、COCO；
  • Dense object detection：Dense200、VisDrone；
  • GUI grounding：ScreenSpot-Pro 的 Dev / Creative / CAD / Sci. / Office / OS split；
  • OCR / document layout：DocLayNet、M6Doc、TotalText 等；
  • Referring expression comprehension：HumanRef、RefCOCOg val / test；
  • Pointing：COCO、LVIS、Dense200、VisDrone、HumanRef、RefCOCOg。

Baselines

论文比较三类方法：

  • Specialized detectors：DETR、Deformable-DETR、Faster R-CNN、Grounding DINO 等；
  • General / grounding VLMs：Qwen3-VL、SEED1.5-VL、DeepSeek-VL2、Mimo-VL、OVIS2.5、Cosmos-Reason2 等；
  • Coordinate / grounding specialists：Rex-Omni-3B、GUI-Owl、UI-Venus、InfiGUI-R1、GTA1 等。

Metrics 与吞吐设置

Box-based outputs 使用 F1@IoU：分别报告 IoU=0.5、IoU=0.95 以及 thresholds mean (mIoU)；point-based outputs 以 predicted point 是否落入 ground-truth segmentation mask 或 box 计算 F1@Point。吞吐以 Boxes Per Second (BPS) 报告，在单张 NVIDIA H100、batch size 1 上测量。正文默认报告 Hybrid Mode；Fast / Slow 的完整对比在 supplement 中给出。

5. Experimental Results (实验结果)

5.1 Common object detection：高 IoU 更强，吞吐更高

MethodBPSLVIS F1@0.5LVIS F1@0.95LVIS MeanCOCO F1@0.5COCO F1@0.95COCO Mean
Grounding DINO-Swin-T-47.722.738.869.823.056.6
SEED1.5-VL-65.619.546.771.314.351.4
Rex-Omni-3B5.064.320.746.972.015.952.9
LocateAnything-3B12.762.331.150.770.119.354.7

LocateAnything 的 LVIS mean F1 比 Rex-Omni-3B 高 +3.8，COCO mean F1 高 +1.8，并且 BPS 从 5.0 提升到 12.7。最有信息量的是高 IoU：LVIS F1@0.95 从 Rex-Omni 的 20.7 到 31.1，说明 PBD 对 box boundary precision 有明显帮助。

5.2 Dense object detection：密集场景中的多目标定位

MethodDense200 F1@0.5Dense200 F1@0.95Dense200 MeanVisDrone F1@0.5VisDrone F1@0.95VisDrone Mean
Grounding DINO-Swin-T36.919.733.155.23.938.5
Rex-Omni-3B78.410.358.361.61.535.8
LocateAnything-3B74.018.558.763.03.239.9

在 Dense200 上 LocateAnything mean F1 为 58.7，略高于 Rex-Omni-3B 的 58.3；在 VisDrone 上 mean F1 为 39.9，高于 Rex-Omni-3B 的 35.8。Dense detection 的关键不是 F1@0.5，而是高 IoU 和 crowded instances；LocateAnything 在 Dense200 F1@0.95 上接近 Grounding DINO，并显著高于 Rex-Omni。

Figure 10 解读：Dense Object Detection 例子展示 stacked logs、abacus beads 等密集重复结构。Qwen3-VL 容易漏检，Rex-Omni 的点式 / token-by-token 输出容易边界模糊；LocateAnything 产生的 boxes 更紧凑且分离，说明 block-aligned geometry 对相邻实例有帮助。

5.3 GUI、OCR 与 referring grounding

TaskMain benchmarkStrong baselineLocateAnything-3B
GUI groundingScreenSpot-Pro AvgGUI-Owl-32B 58.0 / UI-Venus 57.760.3
Document layoutDocLayNet MeanRex-Omni 70.776.8
OCR / documentM6Doc MeanRex-Omni 55.670.1
Scene textTotalText MeanRex-Omni 40.643.3
RECRefCOCOg val MeanRex-Omni 73.676.7
RECRefCOCOg test MeanRex-Omni 74.377.6

GUI grounding 上，LocateAnything 在 ScreenSpot-Pro 平均分 60.3，超过 GUI-Owl-32B 的 58.0。OCR / document tasks 上提升更大：DocLayNet mean 76.8，M6Doc mean 70.1，说明大规模 OCR/layout 数据与 block output 对 tight text boxes 有帮助。Referring expression comprehension 中，LocateAnything 在 RefCOCOg val/test mean 分别为 76.7 / 77.6，主要收益来自高 IoU：RefCOCOg test F1@0.95 为 43.4，高于 Rex-Omni 的 36.6。

Figure 11 解读：OCR qualitative comparison 中，LocateAnything 的文字框更贴近文本块边界；baseline 容易把相邻文字合并，或者出现格式不规则。这里 Hybrid Mode 的价值很明显：简单 text boxes 可并行输出，复杂 layout 出错时可回退到 NTP。

Figure 12 解读：REC 例子强调 compositional human intent，例如属性、空间关系和自由表达。LocateAnything 能把细粒度 query 对齐到正确区域，说明它并非只记住类别，而是能把 language grounding 与 box geometry 联动。

5.4 Pointing results：box-aligned training 迁移到 point 输出

DatasetRex-Omni-3BLocateAnything-3B
COCO80.583.9
LVIS70.876.6
Dense20082.587.6
VisDrone58.960.4
HumanRef83.884.7
RefCOCOg val84.791.3
RefCOCOg test85.191.0

Pointing task 不输出四坐标 box，而是输出点坐标；但它仍受益于 PBD 的几何单元建模。RefCOCOg val/test 上 91.3 / 91.0 的 F1@Point 显示，LocateAnything 的空间对齐能力可从 box 迁移到 point。

5.5 Ablation：PBD 的速度-精度折中

VariantThroughputRecallPrecisionF1
Textual1.345.752.349.1
Quantized3.948.252.250.1
PBD (Slow)3.949.455.252.1
PBD (Fast)16.945.654.649.6
PBD (Hybrid)13.248.754.851.6

对 COCO 的 controlled ablation 显示：PBD Slow 在精度上最好，F1=52.1；PBD Fast 吞吐最高，16.9 BPS，但 F1 降到 49.6；PBD Hybrid 达到 13.2 BPS 和 51.6 F1，是速度与鲁棒性的折中。相比 Quantized，Hybrid 提供约 3.4x throughput，同时 F1 提升 +1.5。

Block / MTP baselineThroughputRecallPrecisionF1
SDLM-B45.245.448.146.5
SDLM-B65.545.147.546.1
SDLM-B86.744.747.245.8
Block Diff-B64.745.144.344.8
PBD (Fast)16.945.254.649.6

这个对比说明“并行 token prediction”本身不够；关键是 block 与 box 语义对齐。普通 SDLM / Block Diff 的 F1 在 44.8–46.5，而 PBD Fast 为 49.6，吞吐也更高。

Figure 13 解读：左侧比较 box ordering 策略对 F1 的影响，右侧展示目标数增长时不同 decoding 表示的 generation time / throughput。PBD 的优势在多目标输出时更明显，因为它减少了每个 box 的 sequential coordinate steps。

5.6 Fast / Hybrid / Slow 模式的补充结果

Supplement 的综合表显示三种 mode 的吞吐为：Fast 15.3 BPS，Hybrid 12.7 BPS，Slow 4.3 BPS。部分关键结果如下：

Dataset / MetricFastHybridSlow
COCO F1@mIoU52.254.755.1
LVIS F1@mIoU47.050.752.6
Dense200 F1@mIoU46.861.361.5
VisDrone F1@mIoU34.439.840.2
ScreenSpot-Pro Acc59.760.360.5
RefCOCOg test F1@mIoU72.574.873.8
COCO F1@Point83.183.984.8

Slow 通常是精度上界，但 Hybrid 已经接近 Slow，同时吞吐接近 Fast。这支持作者的 production recommendation：默认使用 Hybrid，在 latency 和 robustness 之间取得更好的 Pareto point。

Figure 14 解读：qualitative cases 覆盖多目标数量、不同 box scale、属性 query、part query、reasoning query 和 spatial query。图中颜色代表不同 query category；LocateAnything 在任意分辨率和自由文本 query 下仍能输出多实例 boxes，体现数据规模与 block decoding 的互补效果。

5.7 局限与注意点

作者没有在正文中单列 limitations，但从方法和 released code 可以看到几个实际限制：

  • Hybrid 仍依赖 heuristic trigger：format irregularity 和 spatial ambiguity 的检测阈值在论文与 HF code 中不完全一致，说明 fallback policy 仍是工程 heuristic，而非端到端学习出的 uncertainty model。
  • Fast Mode 在复杂密集场景会掉精度：Fast 的 COCO / Dense200 / VisDrone F1@mIoU 均低于 Hybrid 和 Slow，适合低延迟简单场景，不适合作为默认高精度模式。
  • 训练复现信息不完整：paper source 给了四阶段超参数表，但 released GitHub/HF snapshot 未公开 LocateAnything 的训练 launch config、data-engine implementation 和 138M query 数据构造代码。
  • 当前 HF inference code 有 batch-size 限制：modeling_locateanything.py::generate() 断言 batch_size == 1，并要求 use_cache=True；这符合论文 BPS 测试设置，但部署时需要额外 batch/serving 工程。

总体结论：LocateAnything 的贡献不是单纯扩大 grounding 数据，也不是单纯改 decoding speed；它把输出表示、训练目标、attention mask、fallback inference 和大规模数据引擎组合到一起，使 VLM grounding 在 high-IoU precision 与 BPS 上同时前移。