DiffusionGemma บน DGX Spark - NVFP4 Quantization และโลกที่ Model 26B ลงใน 18GB ได้

June 17, 2026 · 9 min read

Author

สารบัญ

TL;DR
DiffusionGemma คืออะไร
NVFP4 คืออะไร และทำไมถึงสำคัญ
DGX Spark เกี่ยวอะไรกับเรื่องนี้
ลองรันบน Hugging Face
ผ่าน vLLM บน DGX Spark
Benchmark จริงจาก Community
สิ่งที่ยังต้องระวัง
ใครควรสนใจ
สรุป
References

หลังจากรีวิว DGX Spark ไปแล้ว หลายคนถามว่า "แล้วเอาไปทำอะไรได้บ้าง?" - คำตอบหนึ่งที่น่าสนใจคือ DiffusionGemma ตัวล่าสุดจาก Google DeepMind ที่เพิ่ง release บน Hugging Face ไม่กี่วันก่อน

บทความนี้จะเล่าเรื่อง DiffusionGemma คืออะไร ทำไม NVFP4 quantization ถึงสำคัญ และลองรันบน DGX Spark จริงๆ จะเป็นอย่างไร

TL;DR

DiffusionGemma 26B เป็นโมเดล diffusion-based จาก Google DeepMind ที่สร้าง text เป็นบล็อก 256 tokens ต่อ step แทนการทีละ token ทำให้เร็วกว่าสูงสุด 4 เท่าบน GPU ที่รองรับ เมื่อใช้ NVFP4 quantization โมเดลใช้ VRAM เพียง ~18GB จึงรันได้สบายบน DGX Spark หรือ RTX 4090/5090 แต่ software stack ยังอยู่ในช่วง experimental ควรทดลองก่อนนำไป production

DiffusionGemma คืออะไร

LLM ทั่วไปอย่าง GPT, Llama, Qwen สร้าง text แบบ autoregressive - ทำทีละ token ต่อจาก token ก่อนหน้า เหมือนพิมพ์ดีด ต้องรอตัวก่อนถึงจะพิมพ์ตัวต่อไปได้

DiffusionGemma พลิกโลกตรงนี้ - ใช้ diffusion-based denoising สร้างทั้ง block ของ tokens พร้อมกัน โดยสร้าง 256 tokens ต่อ forward pass ผลที่ได้คือ เร็วกว่าสูงสุด 4 เท่า บน GPU ที่รองรับ

Model ตัวนี้สร้างบนพื้นฐานของ Gemma 4 ผสมผสานกับงานวิจัยจาก Gemini Diffusion ที่ Google เปิดตัวไว้ โครงสร้างคือ 26B parameters MoE (Mixture of Experts) แต่ activate เพียง 3.8B parameters ในแต่ละ forward pass ทำให้ขนาดที่ต้องโหลดจริงๆ เล็กกว่าที่คิดมาก ทุกตัวใช้ Apache 2.0 license วางบน Hugging Face แล้ว

NVFP4 คืออะไร และทำไมถึงสำคัญ

ปกติ model weights จะเก็บเป็น FP16 หรือ FP32 - float 16-bit หรือ 32-bit ยิ่ง bit สูง ยิ่ง accurate แต่กิน memory มาก

NVFP4 คือ NVIDIA's 4-bit floating point format ที่ออกแบบมาสำหรับ AI inference โดยเฉพาะ

FP16: 2 bytes ต่อ weight → 26B model = ~52GB
FP32: 4 bytes ต่อ weight → 26B model = ~104GB
NVFP4: 0.5 bytes ต่อ weight → 26B model = ~13GB

Note: NVFP4 ไม่เหมือน INT4 ทั่วไป - INT4 เป็น integer 4-bit, NVFP4 ยังเป็น floating point ทำให้จัดการค่าที่เล็กมากๆ ได้ดีกว่า สำคัญมากสำหรับ normalization layers ใน transformer

ผลคือ DiffusionGemma 26B ที่เดิมต้องการ 52GB+ VRAM กลายเป็น ~18GB (รวม activations ด้วย) - ลงได้ทั้งใน RTX 4090 24GB และ RTX 5090 (แต่ RTX 4090 จะไม่ได้ NVFP4 hardware acceleration เพราะเป็น Ada Lovelace ต้องใช้ quantization อื่นแทน)

DGX Spark เกี่ยวอะไรกับเรื่องนี้

DGX Spark มี GB10 Grace Blackwell Superchip ที่ให้ประสิทธิภาพ FP4 สูงสุดถึง 1 petaFLOP เลยทีเดียว

ตัวเลขสำคัญ:

128GB unified memory (CPU + GPU share)
1 petaFLOP FP4 AI performance
รองรับ model ถึง 200B parameters

การที่ DiffusionGemma 26B ใช้แค่ ~18GB VRAM หมายความว่า DGX Spark สามารถ:

รัน DiffusionGemma ได้สบายๆ
ยังเหลือ memory ไว้รัน inference server อื่นๆ พร้อมกัน
ใช้งาน agentic workflows ที่ต้องการ fast text generation

Note: DGX Spark มีตัวเลข official แล้ว - ตาม NVIDIA blog รองรับ DiffusionGemma 26B ที่ ~150 tok/s ด้วย NVFP4 และ community benchmark ยืนยัน ~158 tok/s บน prose และ ~143 tok/s บน code

ลองรันบน Hugging Face

Model หลักอยู่ที่ google/diffusiongemma-26B-A4B-it บน Hugging Face ส่วน NVFP4 quantized version มี 2 ตัวเลือก:

Official NVIDIA: nvidia/diffusiongemma-26B-A4B-it-NVFP4 (18GB on disk, quantized ด้วย NVIDIA Model Optimizer)
Community: RedHatAI/diffusiongemma-26B-A4B-it-NVFP4

ตัวอย่างการโหลดผ่าน Transformers:

from transformers import DiffusionGemmaForBlockDiffusion, AutoProcessor

model_id = "google/diffusiongemma-26B-A4B-it"

processor = AutoProcessor.from_pretrained(model_id)
model = DiffusionGemmaForBlockDiffusion.from_pretrained(
    model_id,
    dtype="auto",       # จะเลือก bf16 ตาม checkpoint
    device_map="auto",  # shard ข้าม GPU ที่มี
)

messages = [
    {"role": "user", "content": "Explain quantum computing in one sentence."}
]

inputs = processor.apply_chat_template(
    messages,
    tokenize=True,
    return_dict=True,
    return_tensors="pt",
    add_generation_prompt=True,
).to(model.device)

input_len = inputs["input_ids"].shape[-1]
output = model.generate(**inputs, max_new_tokens=256)
print(processor.decode(output.sequences[0][input_len:], skip_special_tokens=True))

Note: NVFP4 ยังต้องใช้ Transformers เวอร์ชันล่าสุด - และ GPU ต้องรองรับ FP4 tensor cores (Blackwell อย่าง RTX 50-series / GB10 / RTX PRO, หรือ Hopper อย่าง H100) ถ้า GPU ไม่รองรับ NVFP4 จะ fallback เป็น FP16/BF16 แทน ซึ่งต้องการ VRAM มากกว่า

ผ่าน vLLM บน DGX Spark

ถ้าอยาก serve เป็น API บน DGX Spark ด้วย vLLM:

# ใช้ official prebuilt image สำหรับ GB10 (ARM64 + CUDA 13)
docker run -d --rm --gpus all --name dgemma \
  -v ~/.cache/huggingface:/root/.cache/huggingface \
  -e VLLM_USE_V2_MODEL_RUNNER=1 \
  -p 8000:8000 \
  vllm/vllm-openai:gemma-aarch64-cu130 \
  nvidia/diffusiongemma-26B-A4B-it-NVFP4 \
  --host 0.0.0.0 --port 8000 \
  --trust-remote-code --dtype auto \
  --max-model-len 100000 \
  --gpu-memory-utilization 0.70 \
  --max-num-batched-tokens 8192 \
  --max-num-seqs 4 \
  --diffusion-config '{"canvas_length": 256, "max_denoising_steps": 48}' \
  --attention-backend TRITON_ATTN \
  -tp 1

Note: ตัวเลข canvas_length: 256 คือจำนวน tokens ที่ denoise เป็นบล็อกต่อ step (max_denoising_steps: 48 คือจำนวนรอบ refinement) สองค่านี้คือ diffusion equivalent ของ "batch size" และ "ความลึกของการคิด"

vLLM รองรับ DiffusionGemma แล้วผ่าน official prebuilt image vllm/vllm-openai:gemma โดยเฉพาะ tag gemma-aarch64-cu130 สำหรับ GB10 ไม่ต้อง build เองหรือ cherry-pick PR

Benchmark จริงจาก Community

หลังจากโพสต์ไปบน Reddit มีคนใน community ทดลองรัน DiffusionGemma บน DGX Spark จริงๆ ผ่าน vLLM official image ผลที่เห็นคือ เร็วกว่า autoregressive model ทั่วไปมาก

ตัวเลขที่ verified จากแหล่งต่างๆ:

Hardware	Quantization	Throughput	แหล่งที่มา
NVIDIA H100	BF16	1,000+ tok/s	Google (self-reported)
NVIDIA H200	BF16 (vLLM)	1,288 tok/s	vLLM blog - independently verified
RTX 5090	NVFP4	700+ tok/s	Google (self-reported)
DGX Spark (GB10)	NVFP4	~150 tok/s	NVIDIA blog (official)
DGX Spark (GB10)	NVFP4	~158 tok/s (prose) / ~143 tok/s (code)	Community (ai-muninn.com)
RTX 4090	Q4_K_M (GGUF)	~200-400 tok/s	Community estimate

Warning: diffusion tok/s หลอกตา - DiffusionGemma ทำงานบน canvas ขนาด 256 tokens ต่อ block คำตอบสั้นๆ 2-3 คำ ใช้เวลาเกือบเท่ากับคำตอลยาว 256 tokens เพราะ cost อยู่ที่ "จำนวนรอบ denoise" ไม่ใช่ "จำนวน token" ดังนั้นตัวเลข tok/s ของ diffusion ไม่สามารถเทียบตรงๆ กับ autoregressive model ได้

Note: ทำไม DGX Spark ถึงเร็ว - GB10 มี FP4 tensor cores เฉพาะทางที่เร่ง 4-bit operations โดยตรง ไม่ต้อง dequantize กลับไปเป็น FP16 ก่อน ความต่างจึงเห็นชัดมากในงาน NVFP4 quantization

DiffusionGemma ไม่ได้เร็วเพราะ quantization อย่างเดียว - แต่เพราะ diffusion architecture สร้างหลาย tokens พร้อมกัน ต่างจาก autoregressive ที่ต้องรอ token ก่อนหน้าเสร็จก่อน

สิ่งที่ยังต้องระวัง

เอาจริงๆ - NVFP4 ยังใหม่มาก ยังมีข้อควรระวังหลายอย่าง:

Compatibility จำกัด - NVFP4 ต้องใช้ GPU ที่มี FP4 tensor cores จริงๆ ได้แก่ Blackwell (RTX 50-series, GB10, RTX PRO) หรือ Hopper (H100) — RTX 40-series (Ada Lovelace) ไม่รองรับ NVFP4 แม้จะรัน model ลงได้ด้วย quantization อื่น
Quantization มีทั้ง official และ community - NVIDIA มี official checkpoint ที่ nvidia/diffusiongemma-26B-A4B-it-NVFP4 ส่วน RedHatAI/... เป็น community effort
Accuracy trade-off - NVFP4 ยังมีการลดทอนคุณภาพบางส่วน เทียบกับ FP16 ในงานบางประเภท
Software stack ยังไม่ mature - vLLM support ยัง experimental, Transformers ต้องใช้เวอร์ชันล่าสุดที่ยังไม่ stable

Note: ถ้าต้องการ stability - รอจนกว่า NVFP4 support เข้า official release ของ vLLM/Transformers ก่อนจะเอาไป production น่าจะดีกว่า

ใครควรสนใจ

ควรสนใจถ้า:

ต้องการ fast inference บนเครื่องตัวเอง
ทดลอง agentic AI ที่ต้องการ text generation ความเร็วสูง
มี RTX 4090/5090 หรือ DGX Spark อยู่แล้ว

ข้ามไปก่อนถ้า:

ต้องการ accuracy สูงสุด (ใช้ FP16 หรือ Q8)
งานต้องการ very long context ที่เน้น needle-in-haystack (แม้ DiffusionGemma รองรับ 256K context แต่ long-context accuracy ยังต่ำกว่า Gemma 4 AR ใน benchmark บางตัว เช่น MRCR v2 8 needle 128K)
ต้องการ production-ready stack (รอ official support)

สรุป

DiffusionGemma เป็นตัวอย่างที่ดีว่า hardware ใหม่อย่าง DGX Spark ทำอะไรได้มากกว่าแค่ "รัน model ใหญ่ได้" - มันเปิดโอกาสให้เราเข้าถึง architecture ใหม่ๆ ที่ต้องการ hardware เฉพาะทาง (FP4 tensor cores) ที่ยังไม่มีในเครื่องเก่า

สำหรับคนที่มี DGX Spark อยู่แล้ว DiffusionGemma เป็น experiment ที่คุ้มค่าทดลอง แต่อย่าเพิ่งเอาไป production - software stack ยังต้อง catch up กับ hardware อยู่

References

แชร์บทความ

Facebook X

☕

เนื้อหานี้มีประโยชน์ไหม? ช่วยสนับสนุนค่ากาแฟให้ผู้เขียนสักแก้ว

Buy Me a Coffee

สารบัญ

TL;DR​

DiffusionGemma คืออะไร​

NVFP4 คืออะไร และทำไมถึงสำคัญ​

DGX Spark เกี่ยวอะไรกับเรื่องนี้​

ลองรันบน Hugging Face​

ผ่าน vLLM บน DGX Spark​

Benchmark จริงจาก Community​

สิ่งที่ยังต้องระวัง​

ใครควรสนใจ​

สรุป​

References​