Model Architectures

Datature Vi supports seven vision-language model (VLM) architectures for fine-tuning. Each has different parameter sizes, strengths, and hardware requirements. The right choice depends on your task type, how much accuracy you need, and what GPU resources you have available.

A VLM architecture is the underlying model design: how the model processes images, encodes text, and generates predictions. Larger models (more parameters) can learn more complex patterns but cost more to train and run. Terms like "7B" mean 7 billion parameters. See VLM concepts for background on parameters, tokens, and other terms used on this page.

Modalities and task types

All seven architectures support image and video modalities and the full set of training tasks: phrase grounding, visual question answering (VQA), and freeform text.

Which architecture should I use?

Start here before reading the full details below.

Start with a smaller model (Qwen3.5 4B or Qwen3-VL 4B) to validate your dataset, pipeline, and task setup with fast iteration cycles. Once your approach is working, scale up to Qwen3.5 9B or larger for production-grade accuracy. This way you spend less time and fewer compute credits while experimenting, and only commit to longer training runs when the fundamentals are right.

Which upstream checkpoint does Vi start from?

The sections below compare behavior and benchmarks first. Skip this table unless you need Hugging Face repo IDs and the exact base versus instruct line Vi loads for each architecture.

Fine-tuning always begins from a fixed public weight line per architecture. Qwen2.5-VL and Qwen3-VL are instruction-tuned only: each size uses the matching *-Instruct Hugging Face repo, and base checkpoints (non-Instruct or *-Base VL builds) are not loaded or offered. Qwen3.5 uses the post-trained Qwen/Qwen3.5-{size} release, not Qwen3.5-{size}-Base. NVIDIA and OpenGVLab families use the single Hugging Face checkpoints linked in the sections below.

Qwen3.5

Qwen3.5 is a natively multimodal architecture from Alibaba Cloud. Every model in this family accepts text, images, and video as input, including the 0.8B variant. Unlike Qwen3-VL, which bolts a vision encoder onto a language model, Qwen3.5 is multimodal from the ground up.

The architecture uses a hybrid design that alternates between Gated DeltaNet layers (linear attention with O(n) complexity) and standard Gated Attention layers. This pattern allocates 75% of layers to linear attention and 25% to full attention. The result is lower memory usage on long sequences while keeping quality high at key layers. Qwen3.5 supports 201 languages and a 262K-token native context window (extensible to 1M). It also supports Multi-Token Prediction (MTP), which speeds up inference through speculative decoding.

Available sizes:

Key strengths:

• Every size is natively multimodal (not a separate vision encoder added to a language model)
• Hybrid DeltaNet + Attention architecture reduces memory usage on long contexts
• 201-language support for text and OCR
• 262K native context window, extensible to 1M tokens
• Multi-Token Prediction (MTP) for faster inference via speculative decoding
• Built-in thinking/non-thinking mode toggle across all sizes
• Supports LoRA and full fine-tuning

Qwen3-VL

Qwen3-VL is Alibaba Cloud's latest transformer-based VLM and the direct successor to Qwen2.5-VL. It processes images and videos with three architectural upgrades over its predecessor: Interleaved-MRoPE for better video reasoning, DeepStack multi-level vision feature fusion, and Text-Timestamp Alignment for precise temporal event localization. The model supports a 256K-token native context window, extensible to 1M tokens.

Available sizes:

Key strengths:

• 256K native context window (8x longer than Qwen2.5-VL), extensible to 1M tokens
• OCR support for 32 languages, up from 19 in Qwen2.5-VL
• Interleaved-MRoPE for stronger video temporal reasoning
• DeepStack fuses multi-level vision features for sharper image-text alignment
• Supports LoRA and full fine-tuning
• Optional thinking mode variants available for chain-of-thought (CoT) reasoning

Qwen2.5-VL

Qwen2.5-VL is developed by Alibaba Cloud. It processes images and videos at their native resolution without forced resizing, which preserves fine detail in high-resolution images, dense documents, and video frames. The model supports up to 128K tokens in its context window.

Available sizes:

Key strengths:

• Dynamic resolution processing: images are not resized to a fixed size
• Extended 128K token context window for long documents and multi-image inputs
• Multimodal Rotary Position Embedding (M-RoPE) for strong spatial and temporal understanding
• Supports LoRA and full fine-tuning

NVILA-Lite

NVILA-Lite is part of NVIDIA's NVILA model family. It uses a "scale-then-compress" approach: images are processed at high resolution first, then visual tokens are compressed efficiently. This lets a 2B-parameter model handle high-resolution inputs (up to 4K) with lower memory than comparable models.

Available size:

Key strengths:

• Lowest memory footprint of any available architecture
• Fastest inference latency
• Effective on high-resolution inputs despite compact size
• Suited for edge and real-time deployments

NVIDIA Cosmos-Reason1

Cosmos-Reason1 is a 7B-parameter model from NVIDIA designed for tasks that require logical inference and multi-step analysis. It performs well on cause-and-effect reasoning, contextual understanding, and analytical tasks where the model needs to draw conclusions from visual evidence.

Available size:

Key strengths:

• Optimized attention mechanisms for complex reasoning chains
• Strong at contextual understanding across visual and textual modalities
• Good performance on diagnostic and analytical applications

NVIDIA Cosmos-Reason2

Cosmos-Reason2 is NVIDIA's second-generation physical reasoning VLM, built on the Qwen2.5-VL architecture. It focuses on understanding how the physical world works: spatial relationships, object dynamics, affordances, and cause-and-effect reasoning from visual input. NVIDIA trained these models with a two-stage pipeline of supervised fine-tuning (SFT) followed by Group Relative Policy Optimization (GRPO), which produces structured chain-of-thought (CoT) reasoning traces before final answers.

The 2B variant is based on Qwen2.5-VL-2B-Instruct. The 8B variant builds on Qwen2.5-VL-7B-Instruct and offers stronger multi-step reasoning and finer spatial accuracy.

Available sizes:

Key strengths:

• Purpose-built for physical world understanding: spatial reasoning, object permanence, and causal inference
• Chain-of-thought output provides interpretable reasoning steps (valuable for safety-critical applications)
• GRPO-trained for higher reasoning accuracy compared to SFT alone
• Processes both images and video natively
• Compatible with Qwen2.5-VL tooling and inference infrastructure
• Supports LoRA and full fine-tuning

OpenGVLab InternVL3.5

InternVL3.5 is an 8B-parameter model from OpenGVLab that provides strong performance across diverse multimodal tasks. It is designed for detailed visual understanding: fine-grained object recognition, scene comprehension, and spatial reasoning.

Available size:

Key strengths:

• Fine-grained recognition of small objects and subtle visual details
• Strong spatial awareness and scene understanding
• Supports LoRA and full fine-tuning
• Good balance between accuracy and resource cost at 8B parameters

Coming soon

Three additional architectures are in development:

• Gemma 4: Google's open multimodal model family with strong visual reasoning and instruction following
• DeepSeek OCR: Specialized for text extraction and document understanding, with strong handling of handwritten text and multilingual documents
• LLaVA-NeXT: Advanced multimodal reasoning with improved instruction following

How do model generations compare?

Datature Vi includes three generations of Qwen VLMs. Each generation brings architectural improvements, but the older models remain available and production-tested.

Official references and benchmark sources

Use this table for citations. Numbers in the benchmark section below are copied only where the upstream source publishes them as text; otherwise we link to the figure, leaderboard, or paper table.

Benchmark performance

These scores come from the official model cards and papers published by each architecture's authors. They measure base model performance before fine-tuning. Your fine-tuned model's accuracy depends on your dataset quality, annotation volume, and training configuration.

Frequently asked questions

Do this with the Vi SDK

import vi

client = vi.Client(
    secret_key="your-secret-key",
    organization_id="your-organization-id"
)

flow = client.flows.get("your-flow-id")
blocks = []
for block in flow.spec.blocks:
    settings = dict(block.settings)
    if "model" in block.block:
        settings["architecture"] = {"name": "qwen3vl", "size": "8B"}
    blocks.append({
        "block": block.block,
        "settings": settings,
        "style": block.style,
    })

client.flows.update(flow_id=flow.flow_id, spec={"blocks": blocks})

For more details, see the full SDK reference.

Further reading

• How to Fine-Tune Qwen2.5-VL: A hands-on guide to fine-tuning one of Datature Vi's most popular architectures.
• Containerized VLM Deployment with NVIDIA NIM: Deploy trained VLMs in production using NVIDIA NIM containers.

Related resources