--- license: apache-2.0 language: - en library_name: transformers pipeline_tag: image-text-to-text tags: - vision-language-model - multimodal - edge - on-device - efficient - low-latency - flash - nanovlm - vqa - image-text-to-text base_model: - qvac/VisionPsy-Nano-460M - lusxvr/nanoVLM-460M-8k --- # VisionPsy-Nano-460M-Flash **VisionPsy-Nano-460M-Flash** is the **efficiency-optimized** sibling of [VisionPsy-Nano-460M](https://huggingface.co/qvac/VisionPsy-Nano-460M). It keeps the same ~460M parameter nanoVLM architecture but processes each image with **far fewer visual tokens (as few as 64 at its native 512x512, versus 256-1088 for peers)**. The result is a model that responds **an order of magnitude faster** and with a **smaller memory footprint** on real phones, while giving up only a small amount of accuracy. If VisionPsy-Nano-460M is our **best-quality** ~0.5B model, **Flash is our best model for the edge**: when time-to-first-token, battery, and RAM are the binding constraints, Flash is the one you ship. - **Fastest time-to-first-token (TTFT) in its class.** By collapsing the image to as few as 64 visual tokens, Flash reaches the first token **~20-36x faster than nanoVLM-460M and SmolVLM2-500M**, and consistently faster than **LFM2.5-VL-450M** and **Qwen3.5-0.8B** on Pixel 9, Galaxy S23, Galaxy S25, and iPhone 15. - **Small quality trade-off.** Retains **~99% of the full model's quality** (normalized score **61.4 vs 62.3**), and it still **beats the next best competitor (LFM2.5) on 13 of 17 benchmarks** (plus 1 tie). - **Leaner on device.** ~40% lower peak memory than nanoVLM-460M and SmolVLM2-500M, and higher decode throughput than nanoVLM-460M, SmolVLM2-500M, and Qwen3.5-0.8B in most device/backend configurations. - **Built for edge.** ~460M params, native 512x512 processing, deployable as a 4-bit GGUF that fits comfortably on a phone. --- ## Why Flash is fast: the visual-token lever The dominant cost in a small VLM's prefill is the number of **visual tokens** the language model has to attend to. Flash keeps the **same architecture** as the full model but adopts a more efficient **image-processing policy**: it **preserves each image's native resolution** instead of upsampling it before tiling, so smaller images produce fewer tiles and far fewer visual tokens. The savings hold across resolutions — and against models like LFM2.5-VL-450M and Qwen3.5-0.8B, whose token counts balloon on large images, the gap actually **widens** at high resolution. **Visual tokens per image (fewer = faster prefill):** | Input resolution | **Flash** | nanoVLM-460M | LFM2.5-VL-450M | SmolVLM2-500M | Qwen3.5-0.8B | | --- | --- | --- | --- | --- | --- | | 512x512 (native) | **64** | 1088 | 256 | 1088 | 256 | | 512x1024 | **192** | 576 | 242 | 576 | 512 | | 1024x662 | **320** | 832 | 228 | 832 | 672 | | 2048x1024 | 576 | 576 | 2290 | 576 | 2048 | At its native **512x512**, Flash uses **17x fewer** visual tokens than nanoVLM-460M and SmolVLM2-500M, and **4x fewer** than LFM2.5-VL-450M and Qwen3.5-0.8B. At **2048x1024**, LFM2.5-VL-450M and Qwen3.5-0.8B jump to **2,290** and **2,048** tokens while Flash stays at **576** — a ~4x advantage. --- ## On-device efficiency All numbers below are measured **on real devices** — **Pixel 9, Samsung Galaxy S23, Samsung Galaxy S25, and iPhone 15** — using **4-bit (Q4_0) GGUF** builds, reported as `CPU / GPU`. Lower is better for TTFT and memory; higher is better for decode throughput. Bold marks the best value in each cell group where Flash leads. ### Time to first token (TTFT, seconds) — the headline TTFT is what a user actually feels when they point the camera and ask a question. This is where Flash's token reduction pays off most. **At 512x512 (native resolution):** | Model | Vis tokens | Pixel 9 (CPU/GPU) | Galaxy S23 | Galaxy S25 | iPhone 15 | | --- | --- | --- | --- | --- | --- | | **VisionPsy-Nano-460M-Flash** | **64** | **6.1 / 16.4** | **6.1 / 5.9** | **2.7 / 2.6** | 5.9 / **0.3** | | nanoVLM-460M (full) | 1088 | 153.0 / 138.3 | 119.0 / 116.7 | 67.0 / 58.8 | 70.3 / 10.9 | | LFM2.5-VL-450M | 256 | 14.9 / 21.9 | 13.6 / 14.2 | 7.7 / 5.7 | 3.4 / 0.4 | | SmolVLM2-500M | 1088 | 128.2 / 136.1 | 135.5 / 113.7 | 48.7 / 64.3 | 72.1 / 10.7 | | Qwen3.5-0.8B | 256 | 21.4 / 25.7 | 22.0 / 19.9 | 8.4 / 10.4 | 5.0 / 0.7 | **Takeaway:** Picking the best backend per phone, Flash reaches the first token **~19-23x faster than nanoVLM-460M and SmolVLM2-500M** on Pixel 9, Galaxy S23, and Galaxy S25, and **up to ~36x** on iPhone 15. It is also **faster than LFM2.5-VL-450M on all four devices** (\~1.3-2.4x) and faster than Qwen3.5-0.8B across the board (\~2.3-3.5x). (On iPhone 15 CPU alone, LFM is slightly ahead; using the iPhone GPU, Flash wins.) ![Time to first token across devices (512x512)](assets/ttft.png) **At 2048x1024 (high-resolution / document pages):** | Model | Vis tokens | Pixel 9 (CPU/GPU) | Galaxy S23 | Galaxy S25 | iPhone 15 | | --- | --- | --- | --- | --- | --- | | **VisionPsy-Nano-460M-Flash** | 576 | **51.5** / 156.0 | **51.5** / **58.8** | **21.7** / **24.7** | **33.9** / **2.8** | | nanoVLM-460M (full) | 576 | 75.8 / 72.8 | 63.6 / 61.3 | 36.7 / 29.8 | 35.1 / 5.4 | | LFM2.5-VL-450M | 2290 | 140.3 / 103.8 | 98.0 / 91.4 | 70.3 / 43.0 | 38.5 / 4.1 | | SmolVLM2-500M | 576 | 62.1 / 72.5 | 70.9 / 59.9 | 29.2 / 33.8 | 36.7 / 5.4 | | Qwen3.5-0.8B | 2048 | 311.4 / 325.2 | 265.2 / 248.9 | 127.5 / 137.3 | 64.8 / 14.8 | **Takeaway:** At high resolution the token gap widens — LFM2.5-VL-450M and Qwen3.5-0.8B expand to 2,290 and 2,048 visual tokens while Flash holds at 576 — so Flash is the **fastest to first token on 7 of 8 device/backends**, roughly **~1.2-1.9x faster than nanoVLM-460M**, **~1.5-2x faster than LFM2.5-VL-450M**, and **~5-6x faster than Qwen3.5-0.8B**. (The one exception is the Pixel 9 GPU, where Flash's high-resolution prefill regresses.) ### Peak memory (RSS, MiB) **At 512x512 (native resolution):** | Model | Pixel 9 (CPU/GPU) | Galaxy S23 | Galaxy S25 | iPhone 15 | | --- | --- | --- | --- | --- | | **VisionPsy-Nano-460M-Flash** | 750 / 1692 | 746 / 1047 | 763 / 1066 | 292 / 285 | | nanoVLM-460M (full) | 1236 / 2224 | 1232 / 1533 | 1251 / 1552 | 827 / 482 | | LFM2.5-VL-450M | 501 / 1123 | 497 / 588 | 510 / 602 | 238 / 181 | | SmolVLM2-500M | 1236 / 2224 | 1232 / 1534 | 1252 / 1552 | 780 / 482 | | Qwen3.5-0.8B | 866 / 2243 | 853 / 942 | 878 / 972 | 903 / 836 | **At 2048x1024 (high-resolution / document pages):** | Model | Pixel 9 (CPU/GPU) | Galaxy S23 | Galaxy S25 | iPhone 15 | | --- | --- | --- | --- | --- | | **VisionPsy-Nano-460M-Flash** | 964 / 1915 | 960 / 1261 | 979 / 1279 | 567 / 399 | | nanoVLM-460M (full) | 992 / 1949 | 988 / 1290 | 1005 / 1305 | 754 / 420 | | LFM2.5-VL-450M | 535 / 1197 | 530 / 621 | 543 / 636 | 271 / 216 | | SmolVLM2-500M | 993 / 1939 | 989 / 1290 | 1005 / 1306 | 719 / 420 | | Qwen3.5-0.8B | 1080 / 2495 | 1066 / 1160 | 1081 / 1174 | 1153 / 941 | At both resolutions Flash uses less peak memory than nanoVLM-460M and SmolVLM2-500M (~40% less than the full-token models at 512x512), and less than Qwen3.5-0.8B in six of eight device/backend configurations per resolution; Qwen keeps a small edge only on the Galaxy GPUs. LFM2.5-VL-450M remains the lightest of the group. ### Decode throughput (tokens/s) **At 512x512 (native resolution):** | Model | Pixel 9 (CPU/GPU) | Galaxy S23 | Galaxy S25 | iPhone 15 | | --- | --- | --- | --- | --- | | **VisionPsy-Nano-460M-Flash** | 28.1 / 30.7 | 32.7 / 33.8 | 93.5 / 93.7 | 7.6 / 78.9 | | nanoVLM-460M (full) | 15.6 / 27.9 | 23.2 / 17.8 | 47.0 / 51.9 | 8.3 / 52.6 | | LFM2.5-VL-450M | 42.6 / 47.8 | 52.3 / 42.6 | 69.8 / 122.4 | 28.2 / 116.0 | | SmolVLM2-500M | 18.2 / 28.1 | 18.5 / 18.3 | 64.8 / 49.6 | 11.4 / 53.6 | | Qwen3.5-0.8B | 17.9 / 22.9 | 12.8 / 21.1 | 45.2 / 24.6 | 6.9 / 40.5 | **At 2048x1024 (high-resolution / document pages):** | Model | Pixel 9 (CPU/GPU) | Galaxy S23 | Galaxy S25 | iPhone 15 | | --- | --- | --- | --- | --- | | **VisionPsy-Nano-460M-Flash** | 23.3 / 13.3 | 27.7 / 23.3 | 89.7 / 66.2 | 9.8 / 71.7 | | nanoVLM-460M (full) | 17.4 / 31.4 | 25.7 / 20.5 | 56.5 / 63.2 | 10.9 / 53.6 | | LFM2.5-VL-450M | 26.3 / 48.9 | 38.5 / 35.0 | 39.7 / 76.3 | 28.9 / 123.4 | | SmolVLM2-500M | 22.4 / 32.8 | 20.7 / 22.1 | 71.8 / 55.0 | 13.6 / 54.3 | | Qwen3.5-0.8B | 12.6 / 20.6 | 15.3 / 17.0 | 36.8 / 32.5 | 7.0 / 24.4 | Across the 16 device/backend configurations (two resolutions x four devices x CPU/GPU), Flash decodes **faster than nanoVLM-460M and SmolVLM2-500M in 13 of 16**, and **faster than Qwen3.5-0.8B in 15 of 16**. LFM2.5-VL-450M leads on sustained decode thanks to its hybrid backbone — but because Flash's TTFT is so much lower, Flash still wins **end-to-end latency** for the short answers typical of on-device VQA, where prefill dominates. ### Where Flash wins, in one line Holds at both **512x512** and **2048x1024**: - **vs nanoVLM-460M and SmolVLM2-500M:** wins on TTFT (~20-36x at 512x512, ~1.2-1.9x at 2048x1024) and memory across the board, and on decode throughput in **13 of 16** device/backend configurations. - **vs Qwen3.5-0.8B:** wins on TTFT, on memory in **6 of 8** configurations per resolution (Qwen leads only on the Galaxy GPUs), and on decode throughput in **15 of 16** configurations. - **vs LFM2.5-VL-450M:** wins decisively on **TTFT** (and the lead grows at high resolution, where LFM's token count balloons); LFM keeps an edge on **peak memory** and **decode throughput**. *Methodology: latency, memory, and throughput measured on-device with 4-bit (Q4_0) GGUF builds across Pixel 9, Galaxy S23, Galaxy S25, and iPhone 15 (CPU and GPU backends), mean over repeated runs.* --- ## An Efficient Operating Point Flash keeps most of the full model's quality. All scores are computed **in-house with a single [VLMEvalKit](https://github.com/open-compass/VLMEvalKit) harness** so every model is scored identically, using each benchmark's official metric (POPE = F1, MMVet = partial credit, MM-IFEval = instruction-following accuracy, OCRBench = /1000, MME = Perception + Reasoning points). LLM-as-judge scoring uses Qwen3.6-27B. The changes used for these numbers are currently under review in VLMEvalKit: - **VisionPsy model support**: [PR #1613](https://github.com/open-compass/VLMEvalKit/pull/1613) - **Opt-in LLM-judge rescoring for open-ended VQA benchmarks**: [PR #1602](https://github.com/open-compass/VLMEvalKit/pull/1602) - **MM-IFEval bug fix**: [PR #1601](https://github.com/open-compass/VLMEvalKit/pull/1601) - **LLM-judge bug fix**: [PR #1611](https://github.com/open-compass/VLMEvalKit/pull/1611) Until they are merged, you can reproduce the benchmarks by applying these PRs on top of [VLMEvalKit](https://github.com/open-compass/VLMEvalKit). | Benchmark | Metric | **VisionPsy-Nano-460M-Flash** | VisionPsy-Nano-460M | | --- | --- | --- | --- | | MMStar | acc | 45.53 | 47.60 | | MMBench | acc | 60.45 | 61.92 | | RealWorldQA | acc | 58.43 | 60.00 | | MME | P+R | 1619 | 1541 | | SEEDBench | acc | 67.58 | 69.20 | | POPE | F1 | 87.46 | 87.93 | | MMMU | acc | 30.67 | 31.44 | | MathVista | acc | 47.80 | 48.90 | | AI2D | acc | 66.39 | 66.48 | | ScienceQA | acc | 84.04 | 86.47 | | OCRBench \* | /1000 | 738 / 699 | 757 / 726 | | ChartQA \* | acc | 77.40 / 75.12 | 78.68 / 76.84 | | TextVQA \* | acc | 75.58 / 67.44 | 79.34 / 70.98 | | DocVQA \* | acc | 85.12 / 80.75 | 85.74 / 80.63 | | InfoVQA \* | acc | 51.12 / 44.80 | 49.80 / 43.29 | | MM-IFEval | IF-acc | 43.67 | 42.30 | | MMVet | partial-credit | 31.10 | 32.34 | VisionPsy-Nano-460M-Flash demonstrates robust performance on general VQA and reasoning, with gains on MME and InfoVQA, while showing greater sensitivity on high-resolution OCR tasks. - **Flash keeps ~99% of the full model's normalized score (61.4 vs 62.3)** while running an order of magnitude faster, and its normalized score still **edges out LFM2.5-VL-450M (59.6)**. - **Flash still beats LFM2.5-VL-450M on 13 of 17 benchmarks** (plus 1 tie), and stays ahead of SmolVLM2-500M on **16 of 17**. - The trade-off is concentrated in the OCR/document-heavy and fine-grained perception tasks (ChartQA, TextVQA, MMStar), where fewer visual tokens cost the most detail. \* **ChartQA, TextVQA, DocVQA, InfoVQA, and OCRBench** are shown as **LLM-judge / strict**. On these open-ended benchmarks, strict string/heuristic matching lowers every model's score, but an **LLM-as-judge** (Qwen3.6-27B) is a more reliable evaluation of free-form answers (e.g., "12%" vs "12 percent", paraphrases, units, formatting); see the main VisionPsy-Nano-460M card for details. For the full-quality model and its detailed comparisons against larger models (FastVLM-0.5B, Qwen3.5-0.8B, InternVL3.5-1B), see the [VisionPsy-Nano-460M model card](https://huggingface.co/qvac/VisionPsy-Nano-460M). --- ## Model details | Property | Value | | --- | --- | | Developed by | [Tether AI Research](https://tether.io/)* | | Parameters | ~460M total | | Built on | [VisionPsy-Nano-460M](https://huggingface.co/qvac/VisionPsy-Nano-460M) / [nanoVLM](https://github.com/huggingface/nanoVLM) (base: `lusxvr/nanoVLM-460M-8k`) | | Vision encoder | SigLIP2 base, patch16, 512x512 | | Language backbone | SmolLM2-360M (nanoVLM's LM) | | Connector | pixel-shuffle MLP (64 image tokens / tile), same as the full model | | Visual tokens | 64 at native 512x512 (vs 256-1088 for peers) | | Context length | 8,192 tokens | | Image handling | processed at native resolution (only upscaled below 512x512), then tiled | | Precision | float32 (also shipped as GGUF for on-device) | * References to Tether AI Research are references to Tether Data, S.A. de C.V. --- ## Usage VisionPsy-Nano-460M-Flash loads directly with 🤗 Transformers via `trust_remote_code` — no extra repo to clone. Requires Python ≥ 3.10, `transformers>=4.46` (tested with 5.13.1), and PyTorch ≥ 2.4 (CUDA recommended). ```python import torch from PIL import Image from transformers import AutoModelForImageTextToText, AutoProcessor repo = "qvac/VisionPsy-Nano-460M-Flash" device = "cuda" if torch.cuda.is_available() else "cpu" model = AutoModelForImageTextToText.from_pretrained( repo, trust_remote_code=True, dtype="auto" if device == "cuda" else torch.float32, ).to(device).eval() processor = AutoProcessor.from_pretrained(repo, trust_remote_code=True) # apply_deploy_profile() enables torch.compile + CUDA graphs (fastest on GPU); # use apply_eager_profile() for plain eager execution or CPU. if device == "cuda": model.apply_deploy_profile(model.device) else: model.apply_eager_profile() # The processor applies the chat template and inserts image tokens for you — # just pass the raw image(s) and a plain-text prompt. image = Image.open("your_image.jpg").convert("RGB") inputs = processor(images=image, text="What is in this image?", return_tensors="pt") inputs = { k: (v.to(device) if torch.is_tensor(v) else v) for k, v in inputs.items() if v is not None } inputs.pop("pixel_values", None) with torch.inference_mode(): out = model.generate(**inputs, max_new_tokens=128, greedy=True) print(processor.batch_decode(out, skip_special_tokens=True)[0].strip()) ``` For on-device deployment, use the 4-bit (Q4_0) GGUF build with a llama.cpp-based runtime. --- ## Intended use VisionPsy-Nano-460M-Flash is designed for **latency- and memory-constrained, on-device multimodal applications** where responsiveness matters more than squeezing out the last accuracy point: live camera Q&A, quick scene/document understanding, and lightweight visual instruction following on phones and other edge hardware. If you can afford more compute and want maximum quality, use [VisionPsy-Nano-460M](https://huggingface.co/qvac/VisionPsy-Nano-460M) instead. Because of its small size, we recommend fine-tuning on your specific domain to maximize quality. ## Limitations - Single-image by design: the model is trained and optimized for **one image per query**, so we recommend single-image inputs at inference; multi-image prompts are outside its intended use. - As a compact model, it may occasionally hallucinate or miscount and is best suited to focused tasks rather than very dense documents or long multi-step math, where larger models have an edge. - Primarily English; other languages are not officially supported yet. - Not intended for safety-critical or high-stakes automated decisions. - Efficiency numbers are measured with 4-bit GGUF builds on specific phones; absolute latency, memory, and throughput will vary with hardware, runtime, and quantization. Benchmark scores use a fixed in-house harness with an LLM judge (Qwen3.6-27B) and may differ from other reported setups. ## Acknowledgements Built on the excellent open-source work of [nanoVLM](https://github.com/huggingface/nanoVLM), [SmolLM2](https://huggingface.co/HuggingFaceTB/SmolLM2-360M-Instruct), and [SigLIP2](https://huggingface.co/google/siglip2-base-patch16-512). ## Citation ```bibtex @misc{visionpsynanoflash2026, title = {VisionPsy-Nano-460M-Flash: An Efficiency-Optimized Vision-Language Model for On-Device Inference}, author = {Tether AI Research}, year = {2026}, note = {Hugging Face model card} } ``` ## Copyright We will take appropriate actions in response to notices of copyright infringement. If you believe your work has been used or copied in a manner that infringes upon your intellectual property rights, please email data-apps@tether.io identifying and describing both the copyrighted work and alleged infringing content. ## Licensing This model, which was finetuned as described in [the blog post](https://huggingface.co/blog/qvac/visionpsy), is licensed by Tether Data, S.A. de C.V. under the Apache 2.0 license. As described in the blog post, this model is a version of the NanoVLM-460M-8k pre-trained model (https://huggingface.co/lusxvr/nanoVLM-460M-8k), which is made available under the MIT license. The FineVision dataset (https://huggingface.co/datasets/HuggingFaceM4/FineVision) is made available under the CC-BY-4.0 (Creative Commons - Attribution 4.0) license. FineVision is an aggregation of a number of public sources unified into a single corpus. Individual subsets within the collection may inherit specific underlying terms from their original creators. As described in the blog post, a subset of the FineVision dataset was used as a part of finetuning the model. The NVIDIA Nemotron-Image-Training-v3 dataset (https://huggingface.co/datasets/nvidia/Nemotron-Image-Training-v3) is made available under the CC-BY-4.0 (Creative Commons - Attribution 4.0). The mPLUG TinyChartData dataset (https://huggingface.co/datasets/mPLUG/TinyChartData) is made available under the Apache 2.0 license. The TabMWP dataset (https://promptpg.github.io/) is made available under the CC BY-NC-SA 4.0 (Creative-Commons-Attribution-NonCommercial-ShareAlike 4.0). The PopVQA dataset (https://huggingface.co/datasets/idoco/PopVQA) is made available under the MIT license. The InfoSeek dataset (https://github.com/open-vision-language/infoseek) is made available under the Apache 2.0 license. The MMKU-Bench dataset (https://huggingface.co/datasets/baochenfu/MMKU-Bench) is made available under the Apache 2.0 license. The VisionFoundry-10K dataset (https://huggingface.co/datasets/zlab-princeton/VisionFoundry-10K) is made available under the Apache 2.0 license. The PKU-SafeRLHF-V dataset (https://huggingface.co/datasets/PKU-Alignment/PKU-SafeRLHF-V) is made available under the CC-BY-NC 4.0 (Attribution-NonCommercial 4.0 International). As described in the blog post, the NVIDIA Nemotron-Image-Training-v3, mPLUG TinyChartData, TabMWP, PopVQA, InfoSeek, MMKU-Bench, VisionFoundry-10K and PKU-SafeRLHF-V datasets were used as a part of finetuning the model.