In v3.1.0 we added Qwen3-VL and made a promise: thanks to the new FAMILY_GROUPS registry, future model families would appear in the notebooks automatically, with no interface edits at all. Version 3.2.0 is that promise kept. InternVL3.5 — the latest generation of OpenGVLab’s InternVL line, released in August 2025 — is now the fourth family in the registry, and neither notebook changed by a single line to display it.

UVLM integrates the six Transformers-native -HF checkpoints, which run through the standard Transformers stack without any custom remote code. None of them is gated: no Hugging Face token required.

The registry now totals 21 checkpoints across 4 families, from 1B to 110B parameters — and the 1B entry replaces Qwen3-VL 2B as the smallest model UVLM has ever supported.

InternVL3.5 is not a variation on the Qwen conventions — it uses the standard Transformers pattern in which the chat template tokenizes directly (apply_chat_template(tokenize=True)), the generated tokens are sliced off after the prompt, and only the generated portion is decoded. That makes it the third distinct inference path in UVLM, alongside LLaVA’s string-based cleaning and Qwen’s separate vision preprocessing with token trimming. As always, all three converge at the same unified response parser — from the user’s side, InternVL3.5 is simply one more family in the dropdown.

Loading follows the same BF16-aware logic introduced in v3.1.0: BF16 automatically on GPUs with native support (RTX 30-series and newer, L4, A100), FP16 fallback otherwise.

While validating the new backend, we caught a fossil from UVLM’s two-backend era: the notebooks used a hardcoded rule that sent every non-Qwen2.5 model’s results to Score_Analysis_LLaVA.csv. With four families, that meant different models could silently append into the same CSV — and resume mode could not tell them apart. As of v3.2.0, output filenames are derived from the loaded checkpoint (e.g. Score_Analysis_InternVL3_5-8B-HF.csv), so each model writes its own file and resume mode and schema upgrades are per-model by construction. If you benchmark several models on the same image folder, this is the release that keeps your results honest.

Nothing changes in the workflow — install (or upgrade) and the new family is there:

pip install --upgrade --force-reinstall --no-deps
git+https://github.com/perezjoan/UVLM.git

Or open the Colab notebook — it always installs the latest version automatically. The three-block workflow (load → configure tasks → run batch), consensus validation, chain-of-thought mode, and truncation detection all work with InternVL3.5 out of the box. No dependency changes since v3.1.0. Tested locally on Windows 11 with an RTX 5060 laptop GPU, where the 1B model loads in about 15 seconds once cached.

One field note from validation, and a nice illustration of why UVLM separates format reliability from accuracy: under temperature sampling, InternVL3.5 1B answered a counting task with “There are two vehicles in the picture” — correct, but unparseable as an integer, so it was recorded as NA by design. Under greedy decoding with a strict format instruction, the same model returned a clean integer. Small models follow instructions best when you ask firmly and decode greedily.

The third family addition promised in v3.1.0 — the Gemma multimodal line — is coming next, and it will be a bigger step than a minor version: Gemma 4 requires the Transformers v5 line, which means UVLM’s next release will be a major version with a documented migration. Same discipline as always: one backend at a time, validated before released.

Full change log in VERSIONS.txt · Source and releases on GitHub · If you use UVLM in research, please cite our Software paper.

UVLM was built around one idea: compare Vision-Language Models across architectures using identical prompts and evaluation protocols, without writing model-specific code. Until now that meant two families: LLaVA-NeXT and Qwen2.5-VL. Version 3.1.0 adds a third: Qwen3-VL, the successor to the Qwen2.5-VL family that anchored our published benchmark.

Qwen3-VL is the latest vision-language generation from Alibaba’s Qwen team, first released in September 2025 with the 235B-A22B flagship, followed shortly after by the compact dense checkpoints that matter for most research budgets. UVLM v3.1.0 integrates the four dense Instruct sizes:

The registry now totals 15 checkpoints across 3 families, from 2B to 110B parameters — and the 2B entry is the smallest model UVLM has ever supported, which makes it an interesting new baseline for large-scale, low-cost batch analysis.

Technically, Qwen3-VL keeps the Qwen inference conventions (chat template → separate vision preprocessing → generation → token trimming), so it plugs into UVLM’s existing Qwen pipeline. What changes under the hood: the model loads through Transformers’ generic AutoModelForImageTextToText class, requires transformers ≥ 4.57 and qwen-vl-utils ≥ 0.0.14, and resizes images to multiples of 32 pixels rather than 28. All of this is handled inside the package — from the user’s side, it is simply one more family in the dropdown.

With three families and fifteen checkpoints, a single flat dropdown was getting crowded. Both notebooks (Colab and local) now use a two-level selector: choose the family first — LLaVA-NeXT, Qwen2.5-VL, or Qwen3-VL — and the model list refreshes automatically.

The selector is built from a new FAMILY_GROUPS mapping in the registry, which means future families will appear in the widgets automatically, with no notebook edits at all.

Qwen3-VL checkpoints are trained in BF16. On GPUs with native BF16 support (RTX 30-series and newer, L4, A100), the loader now selects BF16 automatically, falling back to FP16 on older cards and FP32 on CPU. If you followed our earlier benchmark work, you may remember the FP16 numerical-overflow crashes we documented with BF16-trained checkpoints on T4 hardware — this release is the first step toward closing that class of problem at the loader level.

Local Jupyter users get a long-overdue improvement: the model-loading progress (download bars, device map, timings) is now displayed in a log area under the Load button. Previously, output emitted inside the widget callback was silently swallowed in local Jupyter — Colab was never affected. The release also silences the torch_dtype deprecation warnings from recent Transformers versions and synchronizes the package version metadata.

Nothing changes in the workflow — install (or upgrade) and the new family is there:

pip install --upgrade --force-reinstall --no-deps git+https://github.com/perezjoan/UVLM.git

Or open the Colab notebook — it always installs the latest version automatically. The three-block workflow (load → configure tasks → run batch), consensus validation, chain-of-thought mode, and truncation detection all work with Qwen3-VL out of the box. Tested locally on Windows 11 with an RTX 5060 laptop GPU, where the 2B model loads in well under a minute once cached.

v3.1.0 is the first of a series of family additions. Next on the roadmap: InternVL3.5 (via the Transformers-native -HF checkpoints) and the Gemma multimodal line. Each family will land as its own validated release — same discipline, one backend at a time.

Full change log in VERSIONS.txt · Source and releases on GitHub · If you use UVLM in research, please cite our Software paper.

Imagine you have thousands of street photographs and you need to answer the same questions about each one: how many cars are parked? Is there a sidewalk? How long is the building frontage? Hiring someone to go through every image manually would take weeks. Training a custom computer vision model would take months. But what if you could simply ask an AI model these questions in plain English — and get structured, usable answers back?

That is exactly what Vision-Language Models do. And today, we are releasing UVLM — an open-source tool that makes it easy to load, test, and compare these models, all from a single notebook in your browser.

Vision-Language Models (VLMs) are AI systems that can look at an image and answer questions about it in natural language. Unlike traditional computer vision, which requires training a separate model for every task (one for counting cars, another for detecting sidewalks, a third for classifying buildings), a VLM handles all of these through text prompts. You write a question, attach a photo, and the model responds.

For example, you can ask a VLM: “Count all motor vehicles visible in this image” and it will answer “3”. You can ask the same model “Is there a sidewalk along the street frontage?” and it will answer “yes”. You can even ask it to estimate the length of a building facade in meters — a task that requires the model to identify reference objects (like parked cars), estimate their size, and reason about perspective. All of this from a single model, with no retraining and no labelled dataset.

The catch is that there are many VLM families available (LLaVA, Qwen, InternVL, BLIP-2, and more), and each one works differently under the hood. They use different image encoders, different tokenisation strategies, and different code to run. If you want to know which model is best for your specific task, you normally have to write separate code for each one — a tedious and error-prone process.

UVLM (Universal Vision-Language Model Loader) is a free, open-source tool that lets you load, configure, and compare multiple VLM architectures using the same prompts and the same evaluation protocol — without writing any model-specific code. It runs entirely in Google Colab, which means you do not need to install anything on your computer or own a GPU. A free Google account is all you need.

The idea is simple: you pick a model from a dropdown menu, type your analysis questions into a form, point the tool at a folder of images, and hit run. UVLM handles all the technical details — the processor classes, the tokenisation, the generation settings, the output parsing — and delivers a clean CSV file with one row per image and one column per task. If you want to try a different model, you just switch the dropdown and run again. Same prompts, same images, same output format. Now you can compare.

To demonstrate what UVLM can do, we benchmarked 8 different models on 120 street-level photographs of French urban frontages. Each image was analysed on five tasks: counting vehicles, detecting sidewalks, counting pedestrian entrances, estimating the street frontage length in meters, and classifying the vegetation type. That is 16 model configurations (each model tested in standard and advanced reasoning modes), 120 images, and 5 tasks per image — all processed and compared through UVLM.

The results were revealing. The largest model (LLaVA 34B, with 34 billion parameters) actually ranked last overall. A much smaller model (LLaVA Vicuna 7B) outperformed it significantly and ran on a free Google Colab GPU. The best overall results came from Qwen 32B with chain-of-thought reasoning enabled, which achieved 88% proximity to human expert annotations across all five tasks. Without UVLM, discovering these differences would have required writing and debugging eight separate inference pipelines.

UVLM was designed for anyone who works with images and wants to extract structured information from them at scale — without becoming a machine learning engineer. If you are an urban planner evaluating streetscape quality across a city, UVLM lets you score thousands of street photographs using natural language prompts. If you are an environmental researcher classifying vegetation from field photographs, UVLM lets you test which AI model gives the most reliable results for your specific classification scheme. If you are an infrastructure inspector processing damage assessment photographs, UVLM lets you set up automated counting and scoring tasks and run them across your entire image archive.

The tool is also valuable for AI researchers who need a controlled benchmarking environment. Because UVLM ensures that every model receives exactly the same prompt and is evaluated with the same metrics, it produces fair, reproducible comparisons. The consensus validation feature (running each task multiple times and taking a majority vote) addresses the inherent randomness of AI outputs, and the truncation detection feature flags when a model’s response was cut off before it could finish — a common but often invisible source of errors.

Getting started takes about five minutes. Open the UVLM notebook from GitHub (the link is below), connect to a GPU runtime in Google Colab, and run the first block to load a model. The second block gives you a form where you type your analysis questions — no coding required. The third block processes your images and saves the results as a CSV file on your Google Drive.

The tool currently supports 11 model checkpoints from two major families (LLaVA-NeXT and Qwen2.5-VL), ranging from 3 billion to 110 billion parameters. Models up to 34B can run on a single free-tier Colab GPU with 4-bit quantisation. Advanced features include consensus validation (2–5 runs per task with majority voting), chain-of-thought reasoning for complex tasks, and automatic truncation detection.

UVLM is released under the Apache 2.0 open-source licence. You can use it, modify it, and build on it for any purpose — academic or commercial.

Links

Source code: github.com/perezjoan/UVLM

Paper: arXiv preprint — Perez & Fusco (2026)

UVLM page on this site: urbangeoanalytics.com › Softwares & Algorithms › UVLM

Benchmark dataset: Zenodo — 120 street-view images

Citation

If you use UVLM in your work, please cite:

Perez, J. & Fusco, G. (2026). UVLM: A Universal Vision-Language Model Loader for Reproducible Multimodal Benchmarking. arXiv:2603.13893