JDI-Decision-V1

JDI-Decision-V1

Answers structured questions about text and images with choices and probabilities, as a decision system from JD Industrials built on Qwen3.8-27B with built-in OCR. For teams that route or classify requests.

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-V1 comes from JD Industrials. It is a decision system for text and images that starts from the Qwen3.8-27B model and adds changes in the D3 decision design. It returns structured choices with the probability of each option. Four parts sit inside: a vision encoder, a decision backbone, an FP32 readout and a text reader, PaddleOCR v5, that stays frozen. Baidu's PaddlePaddle team made that reader.

Who it suits: Developers who need a model to pick among set options for a request that mixes text and images, such as a photo of a sign or a form.

Industry | Who uses it | How they use it | Example
Software | Developers | Add a decision step that reads images and text together | Choose between STOP and GO from a photo of a sign
Operations | Workflow teams | Route requests by what an attached image shows | Classify an uploaded image of a document
Research | Evaluation researchers | Reproduce the reported benchmark runs | Rerun the public vision suite from the reproduction guide

If you have no CUDA GPU, you can skip it.

Where to use it:

• Python 3.12 on a machine with a CUDA GPU
• Windows, macOS or Linux, for downloading the files
• Hugging Face AutoModel loading, with remote code enabled

Use case | Who | What they get back
Image question | Developers | A chosen option with its probability
Text plus image decisions | Workflow teams | Structured answers drawn from both inputs
Benchmark reproduction | Researchers | Results to compare with the reported public scores

How to set it up:

• Python 3.12
• A CUDA GPU, since each request runs on one GPU
• The reproduction guide in the repo, which installs the environment and prepares an example image

1. Install the Hugging Face hub package.
2. Download the repository.
3. Follow the reproduction guide to build the environment and the OCR setup.

pip install -U huggingface_hub
hf download JoyIndustrial/JDI-Decision-V1

The setup script downloads the OCR archives from Paddle's own host, and verifies a SHA256 hash before it extracts anything.

How to use it: Run the complete system through the ComboEngine entry point, with a state, a set of questions with their options, and a list of images. The card's own example asks what a sign says, with STOP and GO as the options.

# First follow REPRODUCE.md to install the environment and prepare example.png.
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 | The entry point for the complete system, including OCR
inference.D3Engine | The internal decision model, without the system's OCR step
AutoModel.from_pretrained | Loads the complete system, with remote code enabled

Example: You send a photo of a sign with the question of what it says and the options STOP and GO. The model returns the structured answer with a probability for each option.

For newcomers and experts: If you are new, run the card's example on its sample image first. Do not use remote code loading until you have read what the repo runs.

Images are decoded, converted to RGB and resized to a pixel cap. Two branches then run side by side on one GPU. The vision encoder extracts features while the frozen OCR component reads text, and the OCR text is added to the request state without replacing the image data. The decision backbone then reads everything and an FP32 readout produces the probabilities.

Decode the image, convert to RGB, resize
Vision encoder and OCR run in parallel
OCR text joins the request state
Decision backbone reads all the inputs
FP32 readout gives answers and probabilities

Good to know:

• The card reports 79.7313 on the Decision Index Vision public suite, and calls it a self-reported score, not a confirmed leaderboard rank
• Results on a private test set, and latency checks on an RTX PRO 6000, have not been done yet
• License: Apache 2.0, while the OCR weights and Paddle build headers keep their upstream terms
• Cost to run: none named, you supply the GPU
• Data it reaches: the text and images you send, and the OCR archives the setup script downloads
• Not for: a confirmed leaderboard claim, since the score is self-reported

Title: Request latency on two H200 workers
Mean: 326.0 ms
P50: 263.4 ms
P80: 401.1 ms
P90: 583.0 ms

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

Links

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

Get the model

Download its files with Hugging Face's command line:

pip install -U huggingface_hub
hf download JoyIndustrial/JDI-Decision-V1

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