MedForge-Reasoner

MedForge-Reasoner (8B)

MedForge-Reasoner is the primary model developed in the main MedForge experimental pipeline. It is an interpretable medical deepfake detection model built on top of Qwen3-VL-8B, and further trained for forgery-aware medical reasoning.

This repository hosts the main experimental checkpoint used in the core study.

Paper: MedForge: Interpretable Medical Deepfake Detection via Forgery-aware Reasoning
Venue: ACL 2026 Main Conference

ArXiv: https://arxiv.org/abs/2603.18577

Model Description

MedForge-Reasoner is designed for medical image forgery detection, especially lesion implantation and lesion removal scenarios. Unlike general-purpose medical vision-language models, it is specifically optimized for interpretable medical deepfake detection rather than diagnosis or open-ended medical assistance.

The model follows a localize-then-analyze paradigm. Given a medical image, it first predicts suspicious manipulated regions and then produces an evidence-grounded reasoning chain and final authenticity verdict.

Key Features

• Built on Qwen3-VL-8B
• Main model in the MedForge framework
• Designed for pre-hoc, visually grounded reasoning
• Predicts suspicious forgery regions before generating a decision
• Optimized with Forgery-aware GSPO to strengthen grounding and reduce hallucination

Intended Use

This model is intended for:

• medical deepfake detection
• medical image forgery localization
• evidence-grounded reasoning for image authenticity analysis
• research on interpretable multimodal medical forensics
• benchmarking and ablation studies in the MedForge project

Out-of-Scope Use

This model is not intended for:

• direct clinical diagnosis
• treatment recommendation
• general-purpose medical consultation
• autonomous medical decision-making
• clinical deployment without rigorous validation and expert oversight

Base Model

• Qwen/Qwen3-VL-8B

Training Data

MedForge-Reasoner is trained on MedForge-90K, a large-scale benchmark introduced in the paper.

According to the paper, MedForge-90K contains:

• 30K real medical images
• 30K lesion implant forgeries
• 30K lesion removal forgeries

The dataset covers three major 2D imaging modalities:

• Chest X-Ray
• Brain MRI
• Fundus Photography

It spans 19 pathology types plus healthy controls, and uses high-fidelity edits produced by 10 state-of-the-art image editing models.

Method Overview

The paper formulates interpretable medical forgery detection as a unified sequence generation problem:

[predicted bbox, reasoning, final label]

This design explicitly enforces grounding before reasoning.

Stage 1: Reasoning Cold Start

The model is first supervised with expert-guided reasoning annotations and bounding box targets using SFT.

Stage 2: Forgery-aware GSPO

The model is then further aligned with Forgery-aware Group Sequence Policy Optimization (GSPO), which introduces reward signals for:

• forgery grounding
• reasoning structure compliance
• classification correctness

This training objective is designed to encourage the model to look at the correct manipulated region before reasoning and concluding, thereby reducing visual hallucination.

Reasoning Format

The paper uses a structured CoT reasoning style in which the model outputs:

• visual description
• suspicious region localization
• evidence grounded in the highlighted region
• final conclusion

This supports clinically inspectable and visually verifiable explanations instead of post-hoc justifications.

Limitations

As discussed in the paper, the current version has several limitations:

• It currently focuses on three common 2D imaging modalities: chest X-ray, brain MRI, and fundus photography
• The released reasoning and explanations are in English only
• Although intended as a trustworthy detector, the model could potentially be misused to improve forgery techniques and therefore should be used responsibly

Ethical and Safety Considerations

This model is provided for research purposes only.

It should not be used as a substitute for professional medical judgment, diagnostic workflows, or safety-critical healthcare systems. Outputs must be interpreted with caution and should be independently verified by qualified experts.

Because the model is related to medical forgery detection, responsible usage is required to avoid misuse in adversarial or harmful scenarios.

Usage

Example loading code:

import torch
from PIL import Image
from transformers import Qwen3VLForConditionalGeneration, AutoProcessor

model_id = "RichardChenZH/MedForge-Reasoner"

model = Qwen3VLForConditionalGeneration.from_pretrained(
    model_id,
    torch_dtype=torch.bfloat16,
    device_map="auto",
    trust_remote_code=True,
)
processor = AutoProcessor.from_pretrained(model_id, trust_remote_code=True)

image = Image.open("example.jpg").convert("RGB").resize((1024, 1024))

system_prompt = (
    "You are an expert in medical image forensics. Analyze the provided image "
    "to determine if it is a deepfake or authentic. First, perform a step-by-step "
    "examination of the image content, looking for artifacts, inconsistencies, or "
    "biological implausibilities. Use <think> tags to articulate your reasoning process. "
    "If you identify manipulated regions, localize them using bounding boxes within your reasoning. "
    "Conclude your analysis with a final classification."
)

user_text = "Is this image deepfake or real?"

messages = [
    {"role": "system", "content": [{"type": "text", "text": system_prompt}]},
    {
        "role": "user",
        "content": [
            {"type": "image", "image": image},
            {"type": "text", "text": user_text},
        ],
    },
]

model_inputs = processor.apply_chat_template(
    messages,
    tokenize=True,
    add_generation_prompt=True,
    return_dict=True,
    return_tensors="pt",
)
model_inputs = {
    k: v.to(model.device) if hasattr(v, "to") else v
    for k, v in model_inputs.items()
}

with torch.inference_mode():
    generated_ids = model.generate(
        **model_inputs,
        max_new_tokens=2048,
        do_sample=False,
    )

generated_ids_trimmed = [
    out_ids[len(in_ids) :]
    for in_ids, out_ids in zip(model_inputs["input_ids"], generated_ids)
]
output_text = processor.batch_decode(
    generated_ids_trimmed,
    skip_special_tokens=False,
    clean_up_tokenization_spaces=False,
)[0]

print(output_text)

If you use this model, please cite the MedForge paper:

@misc{chen2026medforgeinterpretablemedicaldeepfake, title={MedForge: Interpretable Medical Deepfake Detection via Forgery-aware Reasoning}, author={Zhihui Chen and Kai He and Qingyuan Lei and Bin Pu and Jian Zhang and Yuling Xu and Mengling Feng}, year={2026}, eprint={2603.18577}, archivePrefix={arXiv}, primaryClass={cs.AI}, url={https://arxiv.org/abs/2603.18577}, }