JDI-Decision-V0.9

JDI-Decision-V0.9

Answers multiple-choice style questions about images and text with option probabilities, using a Qwen3.8-27B decision system with built-in OCR. For developers who need structured choices from pictures.

Made by JoyIndustrial 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: JDI-Decision-V0.9 is a decision system from JD Industrials, built on Qwen3.8-27B with changes for a decision architecture. You give it text, images, a question and a set of options, and it returns a structured answer with a probability for each option. The parts are a vision encoder, a frozen PaddleOCR v5 reader for text in images, a decision backbone and a final FP32 layer that reads out the answer.

Who it suits: It suits developers and researchers who want structured, scored choices from images and text, such as sign reading or visual multiple-choice tasks.

Industry | Who uses it | How they use it | Example
Software | Developers | Add scored multiple-choice answers about images to an app | Ask which of two options a sign shows
Industrial supply | Catalog teams | Read text in product pictures and pick from fixed options | Classify an item from its label photo
Research | Evaluation researchers | Reproduce and test the system on public vision suites | Compare latency and scores with the card's report
AI engineering | ML engineers | Use option probabilities in a decision pipeline | Route a request by the most likely option

If you need open-ended chat or image captions, you can skip it, since it returns choices and probabilities.

Where to use it:

• Python 3.12 on a machine with a CUDA GPU
• Linux-style shell scripts, since the setup uses bash
• Your own pipeline that calls the engine class from Python

Use case | Who | What they get back
Visual choice questions | Developers | An answer and probabilities for each option
Text in images | Catalog teams | OCR text added to the model's view of the image
Benchmark runs | Researchers | Scores and latency on the public vision suite

How to set it up: You need Python 3.12 and a CUDA GPU. The setup script downloads the OCR model files and checks their hashes.

• Python 3.12
• A CUDA GPU
• About 52.2 GB of disk for the BF16 weights, or about 13 GB at 4-bit, which is an estimate
• Access to Paddle's hosting for the OCR archives

1. Install the Hugging Face client with pip.
2. Download the repository with the hf command.
3. From the downloaded folder, run the setup script, which builds an OCR environment.
4. Activate that environment and run the sample.

pip install -U huggingface_hub
hf download JoyIndustrial/JDI-Decision-V0.9

How to use it: You create the combined engine, pass a state, a question with options and one or more images, then print the response. The engine runs OCR and vision encoding side by side on one GPU.

bash ocr_inference/setup.sh
source .venv-ocr/bin/activate
CUDA_VISIBLE_DEVICES=0 python - <<'PY'
from ocr_inference import ComboEngine
engine = ComboEngine()
try:
    response, raw = engine(
        state={},
        questions={"answer": {"type": "choice", "instructions": "What does the sign say?",
                              "criteria": {"A": "STOP", "B": "GO"}}},
        images=["example.png"],
    )
    print(response)
finally:
    engine.close()
PY

Tool | What it does
ocr_inference.ComboEngine | Runs the complete system, including OCR, for reproduction
inference.D3Engine | The internal decision model, without the OCR step
ocr_inference/setup.sh | Builds the OCR environment and checks the downloaded archives

Example: You pass a photo of a sign with the question about what it says, and two options, STOP and GO. The engine prints a structured response that picks an option and gives a probability for each one.

For newcomers and experts: Think of it as a model that picks from options you supply. The first small thing to try is the card's sample with your own image and two options.

Images are decoded, converted to RGB and resized, then split into two parallel branches. The vision encoder extracts features, while the frozen OCR reads text and adds it to the state. The decision backbone reads both with your question and options, and the FP32 readout gives the probabilities. Visual features are reused only inside one request.

Image decoded, converted and resized
Vision encoder and OCR run in parallel
Decision backbone reads features and text
FP32 readout gives answers and probabilities

Good to know:

• Score: the card reports 79.3601 on the Decision Index Vision public suite, with all 12,210 requests successful across 11 benchmarks. It calls this self-reported, not a confirmed leaderboard rank.
• Pending: private evaluation and official latency checks on an RTX PRO 6000 were not done yet.

Title: Request latency in milliseconds, two H200 workers
Mean: 345.5 ms
Median (P50): 282.4 ms
P80: 426.8 ms
P90: 604.2 ms

• Newer version: the card says V1 has moved to the JoyIndustrial organization under another page, and this page is V0.9.
• OCR license: the OCR weights and Paddle build headers keep their upstream licensing terms.
• License: Apache 2.0, as the License line says.
• Cost to run: no API key, account or paid service is named. You need a CUDA GPU.
• Data it reaches: your images and questions, the OCR archives the setup script fetches from Paddle's hosting, and Hugging Face for the download.
• Not for: the part of the card shown here names no forbidden uses.

On Hugging Face, 13 November 2026

• Library: pytorch
• 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: 237
• Likes: 2
• License: cc-by-nc-4.0
• Tags: pytorch, safetensors, qwen3_5, decision-model, multimodal, paddleocr

Links

• Model: https://huggingface.co/JoyIndustrial/JDI-Decision-V0.9
• Files: https://huggingface.co/JoyIndustrial/JDI-Decision-V0.9/tree/main

Get the model

Download its files with Hugging Face's command line:

pip install -U huggingface_hub
hf download JoyIndustrial/JDI-Decision-V0.9

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