Add files using upload-large-folder tool

.gitattributes

@@ -33,3 +33,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+test.png filter=lfs diff=lfs merge=lfs -text
+LocateAnything-assets/tokenizer.json filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,9 @@
+.DS_Store
+.cache/
+__pycache__/
+*.py[cod]
+.venv/
+venv/
+
+*.coreml.annotated.png
+*.coreml.detections.json

LocateAnything-assets/runtime_config.json

@@ -0,0 +1,35 @@
+{
+  "token_ids": {
+    "image_token_index": 151665,
+    "box_start_token_id": 151668,
+    "box_end_token_id": 151669,
+    "coord_start_token_id": 151677,
+    "coord_end_token_id": 152677,
+    "ref_start_token_id": 151672,
+    "ref_end_token_id": 151673,
+    "none_token_id": 4064,
+    "null_token_id": 152678,
+    "im_end_token_id": 151645,
+    "switch_token_id": 152679,
+    "default_mask_token_id": 151676
+  },
+  "image_token": "<IMG_CONTEXT>",
+  "template_prefix": "<|im_start|>system\nYou are a helpful assistant.\n<|im_end|>\n<|im_start|>user\n<image 1><img>",
+  "template_mid": "</img>",
+  "template_suffix": "<|im_end|>\n<|im_start|>assistant\n",
+  "n_img": 1369,
+  "grid_h": 74,
+  "grid_w": 74,
+  "canvas": 1036,
+  "patch_size": 14,
+  "in_token_limit": 25600,
+  "merge_kernel_size": [
+    2,
+    2
+  ],
+  "block_size": 6,
+  "model_max_length": 16384,
+  "q_max": 1625,
+  "kv_max": 3689,
+  "vocab_size": 152681
+}

LocateAnything-assets/tokenizer.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f56587c1c7b4d69be60b018606b1bf2f90e46ca9d51fb2689090997281df7e40
+size 11606727

LocateAnything-decoder.mlpackage/Data/com.apple.CoreML/model.mlmodel

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d66a462f54742d9d5ef27b99002d8f30de0e49ace9c3e6c48dbf2911ef7c0042
+size 826933

LocateAnything-decoder.mlpackage/Data/com.apple.CoreML/weights/weight.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c1cacb1e198cc3283d62705f7bd09fe30c1ada744c5b2aa237270e7807e09684
+size 6177177298

LocateAnything-decoder.mlpackage/Manifest.json

@@ -0,0 +1,18 @@
+{
+    "fileFormatVersion": "1.0.0",
+    "itemInfoEntries": {
+        "4C82C103-68AD-44D0-8798-23E5CC391315": {
+            "author": "com.apple.CoreML",
+            "description": "CoreML Model Weights",
+            "name": "weights",
+            "path": "com.apple.CoreML/weights"
+        },
+        "659959C3-FA9F-41E4-9C1D-151B3BDE84B3": {
+            "author": "com.apple.CoreML",
+            "description": "CoreML Model Specification",
+            "name": "model.mlmodel",
+            "path": "com.apple.CoreML/model.mlmodel"
+        }
+    },
+    "rootModelIdentifier": "659959C3-FA9F-41E4-9C1D-151B3BDE84B3"
+}

LocateAnything-embed.mlpackage/Data/com.apple.CoreML/model.mlmodel

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:183d28233a90cc8f53e5ab77404f3f74e9a896444147abdeea98565999d264a3
+size 1873

LocateAnything-embed.mlpackage/Data/com.apple.CoreML/weights/weight.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5bfa333b76145ec94504bf3fb8a7f147a28ace43817cd12790fa1d8a7df79615
+size 625381504

LocateAnything-embed.mlpackage/Manifest.json

@@ -0,0 +1,18 @@
+{
+    "fileFormatVersion": "1.0.0",
+    "itemInfoEntries": {
+        "308B20E9-8131-4632-8AA7-97B7F0315FDB": {
+            "author": "com.apple.CoreML",
+            "description": "CoreML Model Weights",
+            "name": "weights",
+            "path": "com.apple.CoreML/weights"
+        },
+        "73F1D2AF-2A2F-41F4-A186-F7DD46AA56DD": {
+            "author": "com.apple.CoreML",
+            "description": "CoreML Model Specification",
+            "name": "model.mlmodel",
+            "path": "com.apple.CoreML/model.mlmodel"
+        }
+    },
+    "rootModelIdentifier": "73F1D2AF-2A2F-41F4-A186-F7DD46AA56DD"
+}

LocateAnything-vision.mlpackage/Data/com.apple.CoreML/model.mlmodel

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:346dc831dbfe9182b15b25bee7d1c96bcf122415df923f3498442112bb52e41c
+size 599797

LocateAnything-vision.mlpackage/Data/com.apple.CoreML/weights/weight.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:00c65abd6206ad578579b64561c9aeec0c7c6837275f54d0891246f8b7201dff
+size 865012288

LocateAnything-vision.mlpackage/Manifest.json

@@ -0,0 +1,18 @@
+{
+    "fileFormatVersion": "1.0.0",
+    "itemInfoEntries": {
+        "81DE057D-F4C2-41BC-AAE9-1F3A267CE3A0": {
+            "author": "com.apple.CoreML",
+            "description": "CoreML Model Specification",
+            "name": "model.mlmodel",
+            "path": "com.apple.CoreML/model.mlmodel"
+        },
+        "8870B83E-8C9A-4195-90E8-FAD1EAADED26": {
+            "author": "com.apple.CoreML",
+            "description": "CoreML Model Weights",
+            "name": "weights",
+            "path": "com.apple.CoreML/weights"
+        }
+    },
+    "rootModelIdentifier": "81DE057D-F4C2-41BC-AAE9-1F3A267CE3A0"
+}

README.md

@@ -2,4 +2,49 @@
 license: other
 license_name: nvidia-license
 license_link: https://huggingface.co/nvidia/LocateAnything-3B
+pipeline_tag: object-detection
+tags:
+- coreml
+- vision
+- object-detection
+- image-localization
+- apple-silicon
 ---
+
+# LocateAnything-3B CoreML
+
+CoreML packages and a lightweight Python runner for image localization on Apple hardware.
+
+## Contents
+
+- `LocateAnything-vision.mlpackage` - image encoder package
+- `LocateAnything-embed.mlpackage` - token embedding package
+- `LocateAnything-decoder.mlpackage` - decoder package
+- `LocateAnything-assets/` - tokenizer and runtime configuration
+- `run_locateanything_image_coreml.py` - still-image runner
+- `test.png` - sample input
+
+## Setup
+
+```bash
+pip install -r requirements.txt
+```
+
+## Example
+
+```bash
+python run_locateanything_image_coreml.py \
+  --input test.png \
+  --categories "person,car"
+```
+
+By default, the script writes:
+
+- `test.coreml.annotated.png`
+- `test.coreml.detections.json`
+
+## Notes
+
+The packages are configured for the image grid stored in the vision package metadata. Use the bundled assets directory with these packages so token ids and runtime limits stay aligned.
+
+The license follows the upstream NVIDIA LocateAnything-3B terms linked in the metadata above.

requirements.txt

@@ -0,0 +1,5 @@
+coremltools>=8.0
+numpy>=1.24
+opencv-python>=4.8
+Pillow>=10.0
+tokenizers>=0.15

run_locateanything_image_coreml.py

@@ -0,0 +1,505 @@
+#!/usr/bin/env python3
+"""Run LocateAnything-3B CoreML packages on a still image.
+
+The script loads the vision, embedding, and decoder packages, then writes an
+annotated image plus JSON detections for the requested categories.
+
+Dependencies: coremltools, numpy, tokenizers, Pillow, opencv-python.
+"""
+import argparse
+import json
+import math
+import os
+import re
+import time
+import zlib
+
+import cv2
+import numpy as np
+from PIL import Image
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+NEG_MASK = -30000.0
+
+
+def preprocess_image(path, cfg):
+    """Load and patchify an image for the vision package."""
+    patch = cfg["patch_size"]
+    image = Image.open(path).convert("RGB")
+    orig_w, orig_h = image.size
+
+    canvas = cfg.get("canvas")
+    if canvas:
+        image = image.resize((canvas, canvas), Image.Resampling.BICUBIC)
+
+    w, h = image.size
+    if (w // patch) * (h // patch) > cfg["in_token_limit"]:
+        scale = math.sqrt(cfg["in_token_limit"] / ((w // patch) * (h // patch)))
+        w, h = int(w * scale), int(h * scale)
+        image = image.resize((w, h), Image.Resampling.BICUBIC)
+    pad_h = cfg["merge_kernel_size"][0] * patch
+    pad_w = cfg["merge_kernel_size"][1] * patch
+    target_w = math.ceil(w / pad_w) * pad_w
+    target_h = math.ceil(h / pad_h) * pad_h
+    if (target_w, target_h) != (w, h):
+        image = image.resize((target_w, target_h), Image.Resampling.BICUBIC)
+    w, h = image.size
+    if w // patch >= 512 or h // patch >= 512:
+        raise SystemExit("Image exceeds the position-embedding limit (grid >= 512)")
+
+    x = np.asarray(image, dtype=np.float32).transpose(2, 0, 1) / 255.0
+    x = (x - 0.5) / 0.5
+    gh, gw = h // patch, w // patch
+    x = x.reshape(3, gh, patch, gw, patch).transpose(1, 3, 0, 2, 4).reshape(-1, 3, patch, patch)
+    return np.ascontiguousarray(x), (gh, gw), (orig_w, orig_h)
+
+
+def build_prompt_ids(tokenizer, cfg, categories):
+    """Build token ids and locate the image-token block."""
+    prompt = ("Locate all the instances that matches the following description: "
+              + "</c>".join(categories) + ".")
+    text = (cfg["template_prefix"]
+            + cfg["image_token"] * cfg["n_img"]
+            + cfg["template_mid"] + prompt + cfg["template_suffix"])
+    ids = tokenizer.encode(text).ids
+    img_start = ids.index(cfg["token_ids"]["image_token_index"])
+    n_img = sum(1 for t in ids if t == cfg["token_ids"]["image_token_index"])
+    assert n_img == cfg["n_img"], f"image token count {n_img} != expected {cfg['n_img']}"
+    return ids, img_start, n_img
+
+
+def build_mtp_mask(cur, q_len, kv_max, block_size=6):
+    """Causal mask with a bidirectional final window."""
+    kv_len = cur + q_len
+    mask = np.full((q_len, kv_max), NEG_MASK, dtype=np.float32)
+    cols = np.arange(kv_max)[None, :]
+    rows_g = (cur + np.arange(q_len))[:, None]
+    mask[cols <= rows_g] = 0.0
+    mask[:, kv_len:] = NEG_MASK
+    mask[-block_size:, kv_len - block_size:kv_len] = 0.0
+    mask[-block_size:, kv_len - block_size - 1] = NEG_MASK
+    return mask[None, None]
+
+
+def build_ar_mask(cur, q_len, kv_max):
+    """Plain causal mask over the fixed-width KV buffer."""
+    kv_len = cur + q_len
+    mask = np.full((q_len, kv_max), NEG_MASK, dtype=np.float32)
+    cols = np.arange(kv_max)[None, :]
+    rows_g = (cur + np.arange(q_len))[:, None]
+    mask[cols <= rows_g] = 0.0
+    mask[:, kv_len:] = NEG_MASK
+    return mask[None, None]
+
+
+def _softmax(x, axis=-1):
+    x = x - x.max(axis=axis, keepdims=True)
+    e = np.exp(x)
+    return e / e.sum(axis=axis, keepdims=True)
+
+
+def _apply_repetition_penalty(logits, generated_ids, penalty):
+    if penalty == 1.0:
+        return logits
+    logits = logits.copy()
+    seen = np.unique(generated_ids)
+    seen = seen[(seen >= 0) & (seen < logits.shape[-1])]
+    vals = logits[..., seen]
+    logits[..., seen] = np.where(vals > 0, vals / penalty, vals * penalty)
+    return logits
+
+
+def _apply_top_p(logits, top_p):
+    """Per-row top-p filtering."""
+    order = np.argsort(-logits, axis=-1)
+    sorted_logits = np.take_along_axis(logits, order, axis=-1)
+    cum = np.cumsum(_softmax(sorted_logits), axis=-1)
+    remove = cum > top_p
+    remove[..., 1:] = remove[..., :-1].copy()
+    remove[..., 0] = False
+    mask = np.zeros_like(remove)
+    np.put_along_axis(mask, order, remove, axis=-1)
+    return np.where(mask, np.finfo(logits.dtype).min, logits)
+
+
+def _process_logits(logits, generated_ids, *, temperature, top_p, repetition_penalty):
+    logits = _apply_repetition_penalty(logits, generated_ids, repetition_penalty)
+    if temperature > 0:
+        logits = logits / temperature
+    if top_p is not None and top_p < 1:
+        logits = _apply_top_p(logits, top_p)
+    return logits, _softmax(logits)
+
+
+def _sample_rows(probs, temperature, rng):
+    if temperature > 0:
+        cum = np.cumsum(probs, axis=-1)
+        r = rng.random((probs.shape[0], 1)).astype(cum.dtype)
+        x0 = np.minimum((cum < r).sum(axis=-1), probs.shape[-1] - 1)
+    else:
+        x0 = probs.argmax(axis=-1)
+    return x0.astype(np.int64)
+
+
+def _topk(arr, k):
+    """Descending top-k along the last axis."""
+    idx = np.argpartition(-arr, k - 1, axis=-1)[..., :k]
+    vals = np.take_along_axis(arr, idx, axis=-1)
+    order = np.argsort(-vals, axis=-1)
+    return np.take_along_axis(vals, order, axis=-1), np.take_along_axis(idx, order, axis=-1)
+
+
+def is_valid_box_frame(probs, tk, start_thresh=0.7, end_thresh=0.2):
+    if probs[0, tk["box_start_token_id"]] >= start_thresh:
+        if (probs[1, tk["none_token_id"]] > 0.2 and
+                probs[2, tk["box_end_token_id"]] > 0.2 and
+                probs[3, tk["null_token_id"]] > 0.1 and
+                probs[4, tk["null_token_id"]] > 0.1):
+            return "empty_box"
+    end_ids = [tk["box_end_token_id"], tk["null_token_id"], tk["im_end_token_id"]]
+    if probs[5, end_ids].sum() >= end_thresh:
+        return "legal_box"
+    return "illegal_box"
+
+
+def decode_bbox_avg(probs, tk, keep_k=4, generation_mode="hybrid"):
+    box_type = is_valid_box_frame(probs, tk)
+    if box_type == "empty_box":
+        return np.array([tk["box_start_token_id"], tk["none_token_id"], tk["box_end_token_id"],
+                         tk["null_token_id"], tk["null_token_id"], tk["null_token_id"]], dtype=np.int64)
+    if box_type == "illegal_box":
+        return None
+
+    pos_probs, pos_ids = _topk(probs[1:5], keep_k)     # [4, k]
+    mask = (pos_ids >= tk["coord_start_token_id"]) & (pos_ids <= tk["coord_end_token_id"])
+    if not mask.any(axis=-1).all():
+        return None
+    first_valid_idx = mask.argmax(axis=-1)
+    first_valid_probs = np.take_along_axis(pos_probs, first_valid_idx[:, None], -1)[:, 0]
+    first_valid_ids = np.take_along_axis(pos_ids, first_valid_idx[:, None], -1)[:, 0]
+    if generation_mode == "hybrid":
+        valid_counts = mask.sum(axis=-1)
+        valid_max = np.where(mask, pos_ids, -999999).max(axis=-1)
+        valid_min = np.where(mask, pos_ids, 999999).min(axis=-1)
+        is_abnormal = (first_valid_probs < 0.9) & (valid_counts > 1) & ((valid_max - valid_min) > 60)
+        final_coords = np.where(is_abnormal, 0, first_valid_ids)
+    else:
+        final_coords = first_valid_ids
+    return np.concatenate([[tk["box_start_token_id"]], final_coords, [tk["box_end_token_id"]]]).astype(np.int64)
+
+
+def decode_ref(probs, tk, keep_k=5, start_thresh=0.6):
+    if probs[0, tk["ref_start_token_id"]] < start_thresh:
+        return None
+    pos_probs, pos_ids = _topk(probs[1:], keep_k)
+    is_coord = (pos_ids >= tk["coord_start_token_id"]) & (pos_ids <= tk["coord_end_token_id"])
+    is_valid = ~is_coord
+    if not is_valid.any(axis=-1).all():
+        return None
+    first_valid_idx = is_valid.argmax(axis=-1)
+    final_ids = np.take_along_axis(pos_ids, first_valid_idx[:, None], -1)[:, 0]
+    return np.concatenate([[tk["ref_start_token_id"]], final_ids]).astype(np.int64)
+
+
+def sample_tokens_mtp(logits6, generated_ids, tk, rng, *, temperature, top_p,
+                      repetition_penalty, generation_mode):
+    """Sample the six-position window."""
+    logits, probs = _process_logits(logits6, generated_ids, temperature=temperature,
+                                    top_p=top_p, repetition_penalty=repetition_penalty)
+    x0 = _sample_rows(probs, temperature, rng)
+    box = decode_bbox_avg(probs, tk, keep_k=4, generation_mode=generation_mode)
+    if box is None:
+        box = decode_ref(probs, tk)
+    if box is None:
+        box = np.zeros(1, dtype=np.int64)
+    return x0, box
+
+
+def sample_token_ar(logits1, generated_ids, tk, rng, *, temperature, top_p,
+                    repetition_penalty):
+    logits, probs = _process_logits(logits1, generated_ids, temperature=temperature,
+                                    top_p=top_p, repetition_penalty=repetition_penalty)
+    return _sample_rows(probs, temperature, rng)
+
+
+def handle_pattern(x0, tk, generation_mode="hybrid"):
+    """Normalize sampled tokens into an output pattern."""
+    x0 = [int(t) for t in x0]
+    if x0[0] == tk["null_token_id"] or x0[0] == tk["im_end_token_id"]:
+        return {"type": "im_end", "tokens": [tk["im_end_token_id"]], "is_terminal": True,
+                "need_switch_to_ar": False}
+    if x0[:2] == [tk["box_start_token_id"], tk["none_token_id"]]:
+        return {"type": "empty_box",
+                "tokens": [tk["box_start_token_id"], tk["none_token_id"], tk["box_end_token_id"]],
+                "is_terminal": False, "need_switch_to_ar": False}
+    if x0[0] == tk["box_start_token_id"]:
+        coord_ix = 1
+        for coord in x0[1:5]:
+            if tk["coord_start_token_id"] <= coord <= tk["coord_end_token_id"]:
+                coord_ix += 1
+            else:
+                break
+        if coord_ix == 5 and x0[5] == tk["box_end_token_id"]:
+            return {"type": "coord_box", "tokens": x0, "is_terminal": False,
+                    "need_switch_to_ar": False}
+        if coord_ix == 3 and x0[3] == tk["box_end_token_id"]:
+            return {"type": "point_box", "tokens": x0[:4], "is_terminal": False,
+                    "need_switch_to_ar": False}
+        if generation_mode == "fast":
+            return {"type": "coord_box", "tokens": x0, "is_terminal": False,
+                    "need_switch_to_ar": False}
+        return {"type": "error_box", "tokens": x0[:coord_ix], "is_terminal": False,
+                "need_switch_to_ar": True}
+    for i, token in enumerate(x0):
+        if token == tk["null_token_id"]:
+            x0 = x0[:i]
+            break
+    if len(x0) >= 2 and x0[-1] == x0[-2] == tk["ref_end_token_id"]:
+        x0 = x0[:-1]
+    return {"type": "ref_object", "tokens": x0, "is_terminal": False,
+            "need_switch_to_ar": False}
+
+
+class CoreMLDecoder:
+    """Small wrapper around the decoder package and its KV state."""
+
+    def __init__(self, mlmodel, kv_max):
+        self.mlmodel = mlmodel
+        self.kv_max = kv_max
+        self.state = mlmodel.make_state()
+
+    def forward(self, embeds, position_ids, mask, write_begin, out_rows):
+        q = embeds.shape[0]
+        out = self.mlmodel.predict({
+            "inputs_embeds": embeds.astype(np.float16)[None],
+            "position_ids": np.asarray(position_ids, dtype=np.int32)[None],
+            "mask": mask.astype(np.float16),
+            "write_rows": np.arange(write_begin, write_begin + q, dtype=np.int32),
+            "out_rows": np.asarray(out_rows, dtype=np.int32),
+        }, self.state)
+        return np.asarray(out["logits"])[0]
+
+
+def generate(decoder, embed_fn, ids, visual_features, img_start, cfg, rng, *,
+             generation_mode="hybrid", max_new_tokens=2048, temperature=0.7,
+             top_p=0.9, repetition_penalty=1.1, n_future_tokens=6, verbose=False):
+    """Return generated ids after the input prefix."""
+    tk = cfg["token_ids"]
+    kv_max = cfg["kv_max"]
+    mask_id = tk["default_mask_token_id"]
+    generated = list(ids)
+    seq_len = len(ids)
+    total_len = min(cfg["model_max_length"], seq_len + max_new_tokens)
+    use_mtp = generation_mode in ("fast", "hybrid")
+    cur = 0
+    iter_round = 0
+    switch_to_ar = 0
+    t0 = time.time()
+    prefill_time = None
+
+    while len(generated) < total_len:
+        iter_round += 1
+        L = len(generated)
+        if use_mtp:
+            rows = generated[cur:] + [generated[-1]] + [mask_id] * (n_future_tokens - 1)
+            pos = list(range(cur, L)) + [L - 1 + i for i in range(n_future_tokens)]
+            mask = build_mtp_mask(cur, len(rows), kv_max, n_future_tokens)
+            out_rows = list(range(len(rows) - n_future_tokens, len(rows)))
+        else:
+            rows = generated[cur:]
+            pos = list(range(cur, L))
+            mask = build_ar_mask(cur, len(rows), kv_max)
+            out_rows = [len(rows) - 1] * n_future_tokens
+
+        embeds = embed_fn(np.asarray(rows, dtype=np.int32))
+        if iter_round == 1:
+            embeds[img_start:img_start + visual_features.shape[0]] = visual_features
+
+        logits = decoder.forward(embeds, pos, mask, cur, out_rows)
+        cur = L
+
+        gen_arr = np.asarray(generated)
+        if use_mtp:
+            x0, box = sample_tokens_mtp(logits, gen_arr, tk, rng,
+                                        temperature=temperature, top_p=top_p,
+                                        repetition_penalty=repetition_penalty,
+                                        generation_mode=generation_mode)
+            new_tokens = x0 if (box == 0).all() else box
+            pattern = handle_pattern(new_tokens, tk, generation_mode)
+        else:
+            x0 = sample_token_ar(logits[:1], gen_arr, tk, rng, temperature=temperature,
+                                 top_p=top_p, repetition_penalty=repetition_penalty)
+            tok = int(x0[0])
+            if generation_mode == "hybrid":
+                if tok == tk["box_end_token_id"]:
+                    out_type = "box_end_ar"
+                elif (tk["coord_start_token_id"] <= tok <= tk["coord_end_token_id"]
+                      or tok == tk["none_token_id"]):
+                    out_type = "coord_ar"
+                else:
+                    out_type = "im_end"
+            else:
+                out_type = "im_end" if tok == tk["im_end_token_id"] else "continue_ar"
+            pattern = {"type": out_type, "tokens": [tok]}
+
+        generated.extend(int(t) for t in pattern["tokens"])
+
+        if pattern["type"] == "im_end":
+            break
+        if generation_mode == "hybrid":
+            if pattern["type"] == "error_box":
+                use_mtp = False
+                switch_to_ar += 1
+            elif pattern["type"] == "box_end_ar":
+                use_mtp = True
+        if prefill_time is None:
+            prefill_time = time.time() - t0
+
+    if verbose:
+        n_new = len(generated) - seq_len
+        dt = time.time() - t0
+        print(f"\nStatistic Info, num_tokens={n_new}; generate_time(s)={dt:.4f}; "
+              f"tps={n_new / dt:.4f}; forward_step={iter_round}; "
+              f"prefill_time={prefill_time:.4f}; switch_to_ar={switch_to_ar}\n")
+    return generated[seq_len:]
+
+
+_DET_RE = re.compile(r"<ref>(.*?)</ref>|<box>((?:<\d+>)+)</box>", re.S)
+_COORD_RE = re.compile(r"<(\d+)>")
+
+
+def parse_detections(answer, width, height):
+    out = []
+    label = None
+    for m in _DET_RE.finditer(answer):
+        if m.group(1) is not None:
+            label = m.group(1).strip()
+            continue
+        coords = [int(c) for c in _COORD_RE.findall(m.group(2))]
+        if len(coords) == 4:
+            x1, y1, x2, y2 = coords
+            out.append({"label": label, "type": "box",
+                        "x1": x1 / 1000 * width, "y1": y1 / 1000 * height,
+                        "x2": x2 / 1000 * width, "y2": y2 / 1000 * height})
+        elif len(coords) == 2:
+            x, y = coords
+            out.append({"label": label, "type": "point",
+                        "x": x / 1000 * width, "y": y / 1000 * height})
+    return out
+
+
+def _color_for(label):
+    h = zlib.crc32((label or "obj").encode())
+    return (int(50 + h % 180), int(50 + (h // 180) % 180), int(50 + (h // 32400) % 180))
+
+
+def draw_detections(frame_bgr, dets):
+    for d in dets:
+        color = _color_for(d.get("label"))
+        if d["type"] == "box":
+            p1, p2 = (int(d["x1"]), int(d["y1"])), (int(d["x2"]), int(d["y2"]))
+            cv2.rectangle(frame_bgr, p1, p2, color, 2)
+            if d.get("label"):
+                cv2.putText(frame_bgr, d["label"], (p1[0], max(0, p1[1] - 6)),
+                            cv2.FONT_HERSHEY_SIMPLEX, 0.6, color, 2, cv2.LINE_AA)
+        else:
+            c = (int(d["x"]), int(d["y"]))
+            cv2.circle(frame_bgr, c, 6, color, -1)
+            if d.get("label"):
+                cv2.putText(frame_bgr, d["label"], (c[0] + 8, c[1]),
+                            cv2.FONT_HERSHEY_SIMPLEX, 0.6, color, 2, cv2.LINE_AA)
+    return frame_bgr
+
+
+def _load_mlmodel(path, compute_units):
+    import coremltools as ct
+    units = {"cpu_and_gpu": ct.ComputeUnit.CPU_AND_GPU,
+             "cpu_only": ct.ComputeUnit.CPU_ONLY,
+             "all": ct.ComputeUnit.ALL}[compute_units]
+    return ct.models.MLModel(path, compute_units=units)
+
+
+def main():
+    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("--input", default=os.path.join(HERE, "test.png"))
+    ap.add_argument("--vision-mlpackage", default=os.path.join(HERE, "LocateAnything-vision.mlpackage"))
+    ap.add_argument("--embed-mlpackage", default=os.path.join(HERE, "LocateAnything-embed.mlpackage"))
+    ap.add_argument("--decoder-mlpackage", default=os.path.join(HERE, "LocateAnything-decoder.mlpackage"))
+    ap.add_argument("--assets", default=os.path.join(HERE, "LocateAnything-assets"))
+    ap.add_argument("--categories", default="person,car")
+    ap.add_argument("--out-image", default=None)
+    ap.add_argument("--out-json", default=None)
+    ap.add_argument("--compute-units", default="cpu_and_gpu", choices=["cpu_and_gpu", "cpu_only", "all"])
+    ap.add_argument("--generation-mode", default="hybrid", choices=["fast", "slow", "hybrid"])
+    ap.add_argument("--max-new-tokens", type=int, default=2048)
+    ap.add_argument("--temperature", type=float, default=0.7, help="reference 0.7; pass 0 for greedy")
+    ap.add_argument("--top-p", type=float, default=0.9)
+    ap.add_argument("--repetition-penalty", type=float, default=1.1)
+    ap.add_argument("--seed", type=int, default=0)
+    args = ap.parse_args()
+    t_run = time.time()
+
+    from tokenizers import Tokenizer
+    cfg = json.load(open(os.path.join(args.assets, "runtime_config.json")))
+    tokenizer = Tokenizer.from_file(os.path.join(args.assets, "tokenizer.json"))
+    categories = [c.strip() for c in args.categories.split(",") if c.strip()]
+    rng = np.random.default_rng(args.seed)
+
+    stem = os.path.splitext(os.path.basename(args.input))[0]
+    out_image = args.out_image or os.path.join(HERE, f"{stem}.coreml.annotated.png")
+    out_json = args.out_json or os.path.join(HERE, f"{stem}.coreml.detections.json")
+
+    print(f"[info] categories={categories} compute_units={args.compute_units}")
+    t0 = time.time()
+    vision = _load_mlmodel(args.vision_mlpackage, args.compute_units)
+    embed = _load_mlmodel(args.embed_mlpackage, args.compute_units)
+    decoder_ml = _load_mlmodel(args.decoder_mlpackage, args.compute_units)
+    print(f"[info] CoreML models loaded in {time.time() - t0:.1f}s")
+
+    meta = vision.user_defined_metadata
+    pkg_grid = (int(meta["grid_h"]), int(meta["grid_w"]))
+
+    t0 = time.time()
+    pixel_values, grid, (width, height) = preprocess_image(args.input, cfg)
+    if grid != pkg_grid:
+        raise SystemExit(f"Image patch grid {grid} != vision package grid {pkg_grid}. "
+                         "Use a vision package with a matching input grid.")
+    print(f"[info] image {width}x{height} -> grid {grid[0]}x{grid[1]} "
+          f"({pixel_values.shape[0]} patches) in {time.time() - t0:.1f}s")
+
+    t0 = time.time()
+    features = np.asarray(vision.predict({"pixel_values": pixel_values})["features"],
+                          dtype=np.float16)
+    print(f"[vision] features {features.shape} in {time.time() - t0:.1f}s")
+
+    ids, img_start, n_img = build_prompt_ids(tokenizer, cfg, categories)
+    print(f"[info] prompt: {len(ids)} tokens (image block {n_img} @ {img_start})")
+
+    def embed_fn(row_ids):
+        return np.asarray(embed.predict({"input_ids": row_ids[None]})["embeds"],
+                          dtype=np.float16)[0]
+
+    decoder = CoreMLDecoder(decoder_ml, cfg["kv_max"])
+    out_ids = generate(decoder, embed_fn, ids, features, img_start, cfg, rng,
+                       generation_mode=args.generation_mode,
+                       max_new_tokens=args.max_new_tokens, temperature=args.temperature,
+                       top_p=args.top_p, repetition_penalty=args.repetition_penalty,
+                       verbose=True)
+    answer = tokenizer.decode(out_ids, skip_special_tokens=False)
+
+    dets = parse_detections(answer, width, height)
+    frame = cv2.imread(args.input, cv2.IMREAD_COLOR)
+    draw_detections(frame, dets)
+    if not cv2.imwrite(out_image, frame):
+        raise SystemExit(f"Could not write {out_image}")
+    with open(out_json, "w") as f:
+        json.dump({"image": args.input, "backend": "coreml-pure", "categories": categories,
+                   "generation_mode": args.generation_mode,
+                   "frames": [{"frame": 0, "num_dets": len(dets),
+                               "detections": dets, "raw": answer}]}, f, indent=2)
+    print(f"[done] {len(dets)} detections -> {out_image} and {out_json}")
+    print(f"[time] total runtime: {time.time() - t_run:.1f}s (single full run)")
+
+
+if __name__ == "__main__":
+    main()