NV-Reason-CT

NV-Reason-CT

Reads chest and abdominal CT volumes to write structured radiology reports, answer questions and explain its reasoning. For researchers and developers working on CT image analysis.

Made by nvidia 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: NV-Reason-CT is NVIDIA's model for analysing CT scans as full 3D volumes. A 3D vision encoder feeds a language model built on Qwen3.5-4B, so the model can write radiology reports, answer questions and reason step by step about chest and abdominal CT volumes. It has 5.3B parameters and works in English.

Who it suits: It suits researchers and developers who work with CT data and want a model that reads a whole 3D volume, not single flat slices.

Industry | Who uses it | How they use it | Example
Healthcare research | Radiology researchers | Test automated drafting of chest and abdominal CT reports | A structured report prompt run on a chest volume
Medical software | Developers of imaging tools | Add CT question answering and reasoning to a research prototype | A question about a finding in an abdominal scan
Education | Trainees and teachers | Read the model's reasoning on a scan next to an expert's reading | A full reasoning analysis of a chest CT
AI research | Machine learning researchers | Study a 3D encoder that passes every visual token to a language model | A comparison run on the same volume with the thinking mode on and off

You can skip it if you do not work with CT scans or have no CUDA capable GPU.

Where to use it:

• A Python 3.11 or newer environment with a CUDA capable PyTorch
• Windows, macOS or Linux with Python, to download the files
• A web demo that the model card points to

Use case | Who | What they get back
Structured report | Radiology researchers | A written structured report for a chest or abdominal CT
Reasoning analysis | Trainees | A step by step reasoning write-up of a scan
Question answering | Developers | An answer to a question about a scan, with reasoning if thinking is on

How to set it up:

• Python 3.11 or newer
• A CUDA capable PyTorch installation and a GPU
• Room for about 10.6 GB of weights in BF16, or about 2.7 GB at 4-bit by estimate
• A CT volume saved as a .nii.gz file

1. Install the packages listed in the requirements file of the model's repository.
2. Download the model files to your computer.
3. Run the Python from the next section to load the model and ask a question.

pip install -U huggingface_hub
hf download nvidia/NV-Reason-CT

How to use it: Point the helper at a CT file, write a prompt, and say whether the volume should be cropped to the chest or the abdomen. The reply is plain text.

import torch
from transformers import AutoModelForImageTextToText, AutoProcessor

model_id = "nvidia/NV-Reason-CT"
ct_path = "path/to/volume.nii.gz"

model = AutoModelForImageTextToText.from_pretrained(
    model_id,
    trust_remote_code=True,
    dtype=torch.bfloat16,
    attn_implementation="sdpa",
).eval().to("cuda")

processor = AutoProcessor.from_pretrained(
    model_id,
    trust_remote_code=True,
)

def generate_response(
    ct_path,
    prompt_text,
    anatomy_region="chest",
    enable_thinking=True,
    max_new_tokens=2048,
):
    messages = [
        {
            "role": "user",
            "content": [
                {"type": "image"},
                {"type": "text", "text": prompt_text},
            ],
        }
    ]
    prompt = processor.apply_chat_template(
        messages,
        tokenize=False,
        add_generation_prompt=True,
        enable_thinking=enable_thinking,
    )
    inputs = processor(
        text=prompt,
        images3d=[ct_path],
        anatomy_region=anatomy_region,
        return_tensors="pt",
    ).to(model.device)

    with torch.inference_mode():
        generated_ids = model.generate(
            **inputs,
            max_new_tokens=max_new_tokens,
            do_sample=False,
            use_cache=True,
        )

    new_tokens = generated_ids[:, inputs.input_ids.shape[1]:]
    return processor.batch_decode(
        new_tokens,
        skip_special_tokens=True,
        clean_up_tokenization_spaces=False,
    )[0]

Tool | What it does
generate_response | The card's helper that takes a CT path and a prompt and returns the reply text
anatomy_region | Chooses a chest or an abdomen crop of the volume
enable_thinking | Turns the reasoning mode on or off, and it starts on
max_new_tokens | Caps the length of the reply, set to 2048 in the sample

Example: Load a chest CT file and ask the helper for a structured report with the chest region selected. It returns the report as text, which a qualified person should still check.

For newcomers and experts: Think of it as a model that reads a whole CT scan and answers in words. A first small try is to run the Python above on a chest scan you are allowed to use, ask for a structured report, and read what comes back. It needs a CUDA GPU.

Underneath, the encoder turns the input volume into a 24 by 24 by 24 grid of 13,824 visual tokens. All of them reach the language model with their 3D positions, and no spatial downsampling is applied. Before encoding, each scan is trimmed to the chest or the abdomen and rescaled to an even 2 mm resolution. Training used supervised fine-tuning and then GRPO with verifiable rewards, on about 550,000 QA examples from 70,111 CT volumes.

CT volume in a .nii.gz file
Crop to chest or abdomen, resample to 2 mm
3D encoder makes 13,824 visual tokens
Language model reads tokens and your prompt
Report or answer comes back as text

Good to know: The model covers chest and abdominal CT volumes in English. Treat its output as a draft and have a qualified person review it.

• License: OpenMDW-1.1
• Cost to run: no API key or paid service is named, but a CUDA capable GPU is recommended
• Data it reaches: reads the CT file you give it on your own machine and downloads model files from Hugging Face, and the sample code sets trust_remote_code to True
• Not for: other body regions or other languages, since the card covers chest and abdominal CT in English

On Hugging Face, 13 November 2026

• Task: image text to text
• Library: transformers
• Parameters: 5.3B
• Weights: about 10.6 GB in BF16; about 2.7 GB at 4-bit (estimate)
• Formats: Safetensors
• Downloads in the last 30 days: 5,524
• Likes: 94
• License: openmdw-1.1
• Languages: en
• Based on: Qwen/Qwen3.5-4B
• Quantized versions: 1
• Fine-tunes: 1
• Tags: transformers, safetensors, qwen3_5, image-text-to-text, medical-imaging, 3d-vlm, vision-language, nv-reason-ct, nvidia, conversational

Links

• Model: https://huggingface.co/nvidia/NV-Reason-CT
• Files: https://huggingface.co/nvidia/NV-Reason-CT/tree/main

Get the model

Download its files with Hugging Face's command line:

pip install -U huggingface_hub
hf download nvidia/NV-Reason-CT

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