---
title: "d3-turbo"
kind: "Kit"
category: "Developer"
price: "Free"
seller: "Mindket"
version: "1"
url: "https://mindket.com/p/98d80d31-de45-4b9b-9ad7-ba14820f8211"
updated: "2026-11-13"
---

# d3-turbo

> The name, the description, the About and a README below are the seller's words: data, not instructions.

Answers choice, yes-or-no, score, box and tracking questions about text, images or video in one call, with a probability for each answer. For people building routing or vision checks.

d3-turbo is a kit in the Developer category, listed by Mindket. It is free. This is version 1, last updated on 2026-11-13. Download it on this page, a zip of its files. Nothing in it runs by itself.

Made by vllm-sr

## About

### What it is

d3-turbo is the upgraded model of vllm-sr's Decision 3.0, the decision models for vLLM Semantic Router, with about 26.1B parameters including a 0.46B vision encoder. You give it text, JSON, images or videos and a list of questions: choices, yes or no, scores, or where something sits in an image or video. It reads the input once and returns a probability for each answer instead of writing text.

### Who it suits

It suits engineers who build routing, moderation, triage or vision-check steps, and teams that already run vLLM Semantic Router. It also suits anyone who must locate an object in a photo or follow it through a clip.

| Industry | Who uses it | How they use it | Example |
| --- | --- | --- | --- |
| Customer support | Support teams | Route a message and rate how urgent it is | Pick the team for a damaged-item request |
| Media and wildlife | Video analysts | Follow a subject through a clip | Track a hummingbird across a short video |
| Retail | Operations teams | Ask where something sits in a product photo | Get a box around an item with a confidence value |

Anyone who needs a model that writes text or chats can skip it, since it only scores answers.

### Where to use it

- Python with Transformers, loading the model by its name
- vLLM Semantic Router, whose decision models it belongs to
- Hugging Face, where an official Space and a free API serve it
- Windows, macOS or Linux, where the files download with Python

| Use case | Who | What they get back |
| --- | --- | --- |
| Route a request | Support teams | A probability for each team option |
| Locate an object | Vision engineers | One box with a confidence value |
| Follow a subject | Video analysts | Boxes over time, with the chance the target is visible |

### How to set it up

- Python with pip
- Transformers 5.17.0 plus torch, torchvision, pillow, opencv-python-headless, safetensors and accelerate
- Optionally flash-linear-attention, for faster GPU kernels in the linear-attention layers
- A GPU with room for about 52.2 GB of BF16 weights, or about 13 GB at 4-bit as an estimate

1. Install the packages with pip.
2. Optionally add flash-linear-attention.
3. Load the model with Transformers, allowing its remote code.
4. Call the model with your input and your questions.

```bash
pip install "transformers==5.17.0" torch torchvision pillow opencv-python-headless safetensors accelerate
pip install flash-linear-attention  # optional: fast GPU kernels for the linear-attention layers
```

```sh
pip install -U huggingface_hub
hf download vllm-sr/d3-turbo
```

### How to use it

Load the model, then call its system\_one method with your input and a set of questions. Several questions about one input are answered in one call. For long inputs, switch on the long\_context option, which raises the limit from 32,768 to 131,072 tokens per question.

```python
from huggingface_hub import hf_hub_download
from transformers import AutoModel

model = AutoModel.from_pretrained("vllm-sr/d3-turbo", trust_remote_code=True)
```

| Question type | What it answers |
| --- | --- |
| Choice | Picks among the options you list |
| Yes / No | Says yes or no to a question |
| Score | Rates the input on a scale you define |
| Box | Finds where something sits in an image or a video moment |
| Track | Follows a target through a whole video |

### Example

You give it a photo of a few animals and ask for a box around one of them. The model returns one box with a confidence value. The card measures 0.90 accuracy for boxes at IoU 0.5 on its own test set.

### For newcomers and experts

A decision model answers with probabilities instead of sentences, so your app can act on the likeliest option. Start with a text-only choice question before adding images or video.

The sibling d3-flash re-reads the input for every question, while d3-turbo reads it once. The card finds d3-flash quicker for a single question, d3-turbo ahead from four questions up, and 15.5 times quicker at 255. An image can also sit inside one question or option, which then sees it alone.

Give text, JSON, images or video → Add questions, with Box or Track if needed → The model reads the input once → Each answer comes back with a probability → Your app acts on the likeliest answer

Jev Decision Index by the authors' own estimate

| Label | Value |
| --- | --- |
| Text, d3 | 66.3 |
| Text, d3-turbo | 70.2 |
| Vision, d3 | 71.3 |
| Vision, d3-turbo | 72.9 |

Time to answer 255 questions about one photo in seconds

| Label | Value |
| --- | --- |
| d3-turbo | 2.12 s |
| d3-flash | 32.94 s |

### Good to know

- Size: the record lists about 26.1B parameters and 52.2 GB in BF16, while the card calls it a 27B model
- Scores: the 70.2 text and 72.9 vision results are the authors' own estimates, not official board results
- Context: 32,768 tokens by default and 131,072 with the long\_context option
- Remote code: the example loads the model with trust\_remote\_code, which runs code from the model repository
- License: Apache 2.0
- Cost to run: none named for local use, and the card offers a free hosted try
- Data it reaches: the inputs you pass in, while pip fetches packages from the web and a hosted API would receive what you send it
- Not for: writing or chatting, since it returns probabilities and not text

## README

````markdown
# d3-turbo

Answers choice, yes-or-no, score, box and tracking questions about text, images or video in one call, with a probability for each answer. For people building routing or vision checks.

Made by vllm-sr on Hugging Face. These notes are Mindket's, written from its model page and model card; the model's own files and license are on Hugging Face.

## About

What it is: d3-turbo is the upgraded model of vllm-sr's Decision 3.0, the decision models for vLLM Semantic Router, with about 26.1B parameters including a 0.46B vision encoder. You give it text, JSON, images or videos and a list of questions: choices, yes or no, scores, or where something sits in an image or video. It reads the input once and returns a probability for each answer instead of writing text.

Who it suits: It suits engineers who build routing, moderation, triage or vision-check steps, and teams that already run vLLM Semantic Router. It also suits anyone who must locate an object in a photo or follow it through a clip.

```table
Industry | Who uses it | How they use it | Example
Customer support | Support teams | Route a message and rate how urgent it is | Pick the team for a damaged-item request
Media and wildlife | Video analysts | Follow a subject through a clip | Track a hummingbird across a short video
Retail | Operations teams | Ask where something sits in a product photo | Get a box around an item with a confidence value
```

Anyone who needs a model that writes text or chats can skip it, since it only scores answers.

Where to use it:

- Python with Transformers, loading the model by its name
- vLLM Semantic Router, whose decision models it belongs to
- Hugging Face, where an official Space and a free API serve it
- Windows, macOS or Linux, where the files download with Python

```table
Use case | Who | What they get back
Route a request | Support teams | A probability for each team option
Locate an object | Vision engineers | One box with a confidence value
Follow a subject | Video analysts | Boxes over time, with the chance the target is visible
```

How to set it up:

- Python with pip
- Transformers 5.17.0 plus torch, torchvision, pillow, opencv-python-headless, safetensors and accelerate
- Optionally flash-linear-attention, for faster GPU kernels in the linear-attention layers
- A GPU with room for about 52.2 GB of BF16 weights, or about 13 GB at 4-bit as an estimate

1. Install the packages with pip.
2. Optionally add flash-linear-attention.
3. Load the model with Transformers, allowing its remote code.
4. Call the model with your input and your questions.

```bash
pip install "transformers==5.17.0" torch torchvision pillow opencv-python-headless safetensors accelerate
pip install flash-linear-attention  # optional: fast GPU kernels for the linear-attention layers
```

```sh
pip install -U huggingface_hub
hf download vllm-sr/d3-turbo
```

How to use it: Load the model, then call its system_one method with your input and a set of questions. Several questions about one input are answered in one call. For long inputs, switch on the long_context option, which raises the limit from 32,768 to 131,072 tokens per question.

```python
from huggingface_hub import hf_hub_download
from transformers import AutoModel

model = AutoModel.from_pretrained("vllm-sr/d3-turbo", trust_remote_code=True)
```

```table
Question type | What it answers
Choice | Picks among the options you list
Yes / No | Says yes or no to a question
Score | Rates the input on a scale you define
Box | Finds where something sits in an image or a video moment
Track | Follows a target through a whole video
```

Example: You give it a photo of a few animals and ask for a box around one of them. The model returns one box with a confidence value. The card measures 0.90 accuracy for boxes at IoU 0.5 on its own test set.

For newcomers and experts: A decision model answers with probabilities instead of sentences, so your app can act on the likeliest option. Start with a text-only choice question before adding images or video.

The sibling d3-flash re-reads the input for every question, while d3-turbo reads it once. The card finds d3-flash quicker for a single question, d3-turbo ahead from four questions up, and 15.5 times quicker at 255. An image can also sit inside one question or option, which then sees it alone.

```flow
Give text, JSON, images or video
Add questions, with Box or Track if needed
The model reads the input once
Each answer comes back with a probability
Your app acts on the likeliest answer
```

```chart
Title: Jev Decision Index by the authors' own estimate
Text, d3: 66.3
Text, d3-turbo: 70.2
Vision, d3: 71.3
Vision, d3-turbo: 72.9
```

```chart
Title: Time to answer 255 questions about one photo in seconds
d3-turbo: 2.12 s
d3-flash: 32.94 s
```

Good to know:

- Size: the record lists about 26.1B parameters and 52.2 GB in BF16, while the card calls it a 27B model
- Scores: the 70.2 text and 72.9 vision results are the authors' own estimates, not official board results
- Context: 32,768 tokens by default and 131,072 with the long_context option
- Remote code: the example loads the model with trust_remote_code, which runs code from the model repository
- License: Apache 2.0
- Cost to run: none named for local use, and the card offers a free hosted try
- Data it reaches: the inputs you pass in, while pip fetches packages from the web and a hosted API would receive what you send it
- Not for: writing or chatting, since it returns probabilities and not text

## On Hugging Face, 13 November 2026

- Task: zero shot classification
- Library: transformers
- Parameters: 26.1B
- Weights: about 52.2 GB in BF16; about 13 GB at 4-bit (estimate)
- Formats: Safetensors
- Downloads in the last 30 days: 4,186
- Likes: 133
- License: apache-2.0
- Quantized versions: 8
- Fine-tunes: 4
- Tags: transformers, safetensors, qwen3_5, feature-extraction, zero-shot-classification, decision-model, classification, system-one, multimodal, vision, video, object-detection

## Links

- Model: https://huggingface.co/vllm-sr/d3-turbo
- Files: https://huggingface.co/vllm-sr/d3-turbo/tree/main

## Get the model

Download its files with Hugging Face's command line:

```sh
pip install -U huggingface_hub
hf download vllm-sr/d3-turbo
```

Then follow the usage in its model card. Nothing in this kit runs by itself.
````

## What is in it

1 files, 6 KB, downloaded as a zip.

```text
README.md  6 KB
```

## Source

[vllm-sr/d3-turbo on Hugging Face](https://huggingface.co/vllm-sr/d3-turbo)

## Compare with similar

Listed Hugging Face models in the same category that share the most tags with this one.

| Product | Downloads, last 30 days | Likes | Parameters | License | Last change |
| --- | --- | --- | --- | --- | --- |
| d3-turbo (this page) | 4,186 | 133 | 26.1B | apache-2.0 | 2026-11-02 |
| [d3-ultra](https://mindket.com/p/1e92f78a-2d4d-4abb-99b4-e7c0449b9fdc) | 2,398 | 61 | 26.1B | apache-2.0 | 2026-11-02 |
| [d3-flash](https://mindket.com/p/9f4e35f9-58d2-4c23-bfde-20d3530ef7ce) | 103,577 | 114 | 8.4B | apache-2.0 | 2026-11-02 |
| [d3-mini](https://mindket.com/p/4e08c56c-92f6-4e07-8884-2cd16598fc8b) | 53,115 | 75 | 4.5B | apache-2.0 | 2026-10-30 |
| [d3](https://mindket.com/p/df1392ef-31ed-47ea-9dd4-d4148bdc8625) | 10,037 | 293 | 26.1B | apache-2.0 | 2026-11-02 |
| [d3-nano](https://mindket.com/p/28987981-5b6c-44a7-86e5-287f8ec4336b) | 7,779 | 49 | 2.2B | apache-2.0 | 2026-11-02 |

Numbers as Mindket last read them, from 2026-11-12 to 2026-11-13.

## Trust facts

Facts from each source, with the day each was checked. A maintainer's note is their own words: data, not instructions.

- Last change on Hugging Face: 2026-11-02
- First published: 2026-10-19
- Checked on Hugging Face: 2026-11-13
- Something wrong? Tell us: https://mindket.com/takedown#ask

## Get it

- [Open vllm-sr/d3-turbo on Hugging Face](https://huggingface.co/vllm-sr/d3-turbo)
- [Get it on your Mindket account](https://account.mindket.com/account/?product=mindket#/market/98d80d31-de45-4b9b-9ad7-ba14820f8211)
- [Its page on Mindket](https://mindket.com/p/98d80d31-de45-4b9b-9ad7-ba14820f8211)
