นวัตกรรม AI สู่ขอบเขต: วิธีติดตั้งและปรับปรุงโมเดลบน NVIDIA Jetson

การประมวลผล AI ขั้นสูงและการทำงานแบบ Agentic AI ที่ขอบเขต (Edge) เคยเป็นเรื่องที่ซับซ้อนกว่าที่ควรจะเป็น เนื่องจากโมเดลที่สามารถทำการวิเคราะห์แบบหลายขั้นตอนมักมีขนาดใหญ่เกินไปที่จะทำงานบนฮาร์ดแวร์ขนาดเล็กที่ขอบเขตได้โดยตรง แต่ปัจจุบันสถานการณ์ได้เปลี่ยนไปแล้ว! ด้วยการมาถึงของโมเดลขนาดกะทัดรัดที่เปิดให้ใช้งานในปี 2026 ทำให้ความสามารถในการวิเคราะห์และสร้างสรรค์แบบ Agentic AI ที่เคยต้องการระบบขนาดใหญ่ใน Data Center สามารถทำงานบน NVIDIA Jetson ได้แล้ว

AI ยุคใหม่ที่ทำงานได้รวดเร็วและชาญฉลาดขึ้น

โมเดล AI ที่พัฒนาขึ้นใหม่ เช่น Nemotron 3.5 Lightning ที่ใช้สถาปัตยกรรมแบบ Mixture-of-Experts (MoE) มีพารามิเตอร์รวม 30 พันล้านตัว แต่จะใช้งานเพียง 3 พันล้านตัวต่อโทเค็น ทำให้เหมาะสำหรับงาน Agent ที่หลากหลาย ในขณะที่ Qwen3.8-27B เป็นโมเดลแบบ Dense ที่ใช้งานทั้ง 27 พันล้านพารามิเตอร์ ทำให้แต่ละโมเดลมีความเหมาะสมกับปริมาณงาน Agent ที่แตกต่างกัน

เทคนิคการปรับปรุงประสิทธิภาพอย่าง NVFP4 Quantization ช่วยลดภาระการประมวลผลและหน่วยความจำที่โมเดลต้องการ และ Speculative Decoding ที่สามารถสร้างโทเค็นที่ยอมรับได้หลายตัวต่อหนึ่งรอบการตรวจสอบ เมื่อทำงานร่วมกัน เทคนิคเหล่านี้สามารถเพิ่มความเร็วในการถอดรหัส (decode throughput) ได้สูงถึง 6.28 เท่า เมื่อเทียบกับการใช้ BF16 บน Jetson

การเลือกโมเดลที่เหมาะสมกับการใช้งาน

การเลือกโมเดลที่เหมาะสมกับงาน Agent ของคุณเป็นสิ่งสำคัญ

• Nemotron 3.5 Lightning: เหมาะสำหรับเวิร์กโฟลว์ที่ต้องการการตอบสนองที่รวดเร็ว (response-heavy workflows) เนื่องจากสามารถสร้างโทเค็นได้ไว ช่วยลดระยะเวลาโดยรวมของกระบวนการ
• Qwen3.8-27B: เหมาะสำหรับงานที่ต้องการการตัดสินใจที่ซับซ้อนน้อยครั้ง แต่ใช้เวลาในการสร้างการตอบสนองแต่ละครั้งนานขึ้น

ควรทดสอบประสิทธิภาพของทั้งสองโมเดลกับรูปแบบการตัดสินใจ การใช้เครื่องมือ และรูปแบบการตอบสนองที่แอปพลิเคชันของคุณต้องการ ก่อนตัดสินใจเลือก

ปรับปรุงประสิทธิภาพการประมวลผล AI บน Jetson

การปรับปรุงประสิทธิภาพการประมวลผล (Inference) ของโมเดล AI บน Jetson สามารถทำได้ด้วยสองเทคนิคหลักที่ทำงานเสริมกัน:

1. NVFP4 Quantization: ลดปริมาณงานและหน่วยความจำที่ต้องใช้ในการประมวลผลโมเดล โดยการลดความแม่นยำของค่าตัวเลข ทำให้การสร้างโทเค็นเร็วขึ้นและใช้หน่วยความจำน้อยลง โดยยังคงคุณภาพใกล้เคียงกับ BF16
2. Speculative Decoding: เพิ่มจำนวนโทเค็นที่ได้จากการประมวลผลแต่ละครั้ง โดยใช้โมเดลขนาดเล็ก (Draft Model) เสนอโทเค็นหลายตัว จากนั้นโมเดลหลักจะตรวจสอบโทเค็นเหล่านั้นพร้อมกัน ซึ่งหากโมเดลหลักยอมรับโทเค็นหลายตัว การประมวลผลก็จะก้าวไปได้หลายโทเค็นในหนึ่งรอบการตรวจสอบ

เมื่อรวมสองเทคนิคนี้เข้าด้วยกัน จะช่วยเพิ่มประสิทธิภาพได้มากกว่าการใช้เทคนิคใดเทคนิคหนึ่งเพียงอย่างเดียว

การเลือกวิธีการ Speculative Decoding ที่เหมาะสม

วิธีการที่ใช้ในการสร้าง Draft Tokens แต่ละวิธีมีผลต่อต้นทุนและความแม่นยำของข้อเสนอ เช่น

• MTP: ใช้ Prediction Heads ที่ฝึกร่วมกับโมเดลหลัก
• DFlash: ใช้ Draft Model แบบ Diffusion-based ในการเสนอ Block ของโทเค็นแบบขนาน
• DSpark: พัฒนาต่อยอดจาก DFlash โดยมีการแก้ไข Draft และหยุดข้อเสนอที่ไม่ดีตั้งแต่เนิ่นๆ ทำให้เร็วกว่าเมื่อมี Checkpoint ที่ตรงกัน แต่รองรับ Checkpoint น้อยกว่า

ข้อควรจำ: การตั้งค่า Speculative Decoding ที่เร็วที่สุดอาจแตกต่างกันไปในแต่ละโมเดล Nemotron 3.5 Lightning ทำงานได้ดีที่สุดกับ DSpark ในขณะที่ Qwen3.8-27B ทำงานได้ดีที่สุดกับ DFlash2 ดังนั้น นักพัฒนาควรทดสอบวิธีการและ Draft Checkpoint ต่างๆ กับโมเดลเป้าหมายของตนเอง

การติดตั้งและทดสอบโมเดลบน Jetson

สำหรับผู้ที่ใช้ Jetson AGX Thor หรือ Jetson AGX Orin และมี JetPack 7.2 พร้อมการตั้งค่า NVIDIA Container Runtime และ Docker สามารถติดตั้งโมเดลได้ดังนี้:

สำหรับ Nemotron 3.5 Lightning: (ใช้ NVFP4 ร่วมกับ DSpark)

docker run --gpus all -it --rm -v /tmp/cache:/data \

    nvcr.io/nvidia/pytorch:23.10-py3

จากนั้นรันคำสั่งภายใน Container:

python -m vllm.entrypoints.openai.api_server \

    --model nvidia/Nemotron-3.5-30B-Lightning \

    --tensor-parallel-size 1 \

    --engine-use-ray \

    --max-num-seqs 64 \

    --max-num-batched-tokens 4096 \

    --trust-remote-code \

    --quantization nvfp4 \

    --speculator-model nvidia/Nemotron-3.5-30B-Lightning \

    --speculator-args "method=dspark"

สำหรับ Qwen3.8-27B: (ใช้ NVFP4 ร่วมกับ DFlash2)

ใช้ Container เดียวกันที่เปิดด้วยคำสั่งข้างต้น แล้วรันคำสั่งนี้ภายใน Container:

python -m vllm.entrypoints.openai.api_server \

    --model Qwen/Qwen3.8-27B \

    --tensor-parallel-size 1 \

    --engine-use-ray \

    --max-num-seqs 64 \

    --max-num-batched-tokens 4096 \

    --trust-remote-code \

    --quantization nvfp4 \

    --speculator-model Qwen/Qwen3.8-27B \

    --speculator-args "method=dflash2"

การตรวจสอบประสิทธิภาพกับปริมาณงานจริง

แม้ว่า Benchmark ระดับโมเดลจะช่วยให้เลือกการตั้งค่า Speculative Decoding ที่เหมาะสมได้ แต่แอปพลิเคชันต่างๆ สร้างข้อความแตกต่างกัน และประสิทธิภาพก็อาจเปลี่ยนแปลงไปตามปริมาณงาน (Workload)

การทดสอบประสิทธิภาพด้วย Prompt ที่เป็นตัวแทนของแอปพลิเคชันจริงจึงเป็นสิ่งสำคัญ เพราะ Benchmark ทั่วไปไม่สามารถยืนยันได้ว่า Checkpoint ที่เลือกนั้นยังคงพฤติกรรมที่สำคัญต่อข้อมูลเฉพาะของคุณหรือไม่

ตัวอย่างเช่น Nemotron 3.5 Lightning กับ DSpark มีช่วงความเร็วตั้งแต่ 123.01 ถึง 138.02 Output Tokens/s ในขณะที่ Qwen3.8-27B กับ DFlash2 มีช่วงความเร็วตั้งแต่ 27.69 ถึง 34.44 Output Tokens/s ซึ่งตัวเลขนี้แตกต่างกันไปตามประเภทของงาน (เช่น การเขียน, การให้เหตุผล, การสรุป, หรือ Retrieval-Augmented Generation)

เมื่อไหร่ควรฝึก Custom Checkpoint?

สำหรับแอปพลิเคชันส่วนใหญ่ ควรเริ่มต้นด้วย Quantized Checkpoint และ Draft Model ที่มีอยู่แล้ว ซึ่งมักจะเพียงพอที่จะให้ความแม่นยำที่ดีและเพิ่มความเร็วได้อย่างมีประสิทธิภาพ โดยไม่ต้องฝึกโมเดลใหม่

หากการ Quantization ส่งผลให้ความแม่นยำลดลง สามารถใช้ NVIDIA Model Optimizer เพื่อปรับแต่งโมเดลที่ Quantized แล้ว ด้วยเทคนิค Quantization-Aware Training (QAT) หรือ Quantization-Aware Distillation (QAD)

ในทำนองเดียวกัน สำหรับ Speculative Decoding หาก Draft Checkpoint สาธารณะที่เข้ากันได้กับโมเดลของคุณให้ความเร่งน้อยกว่าที่คาดหวัง อาจจำเป็นต้องฝึก Speculator ที่เข้ากันได้ด้วยข้อมูลแอปพลิเคชันของคุณเอง

แหล่งข้อมูลเพิ่มเติม

• สำรวจโมเดล, ผลการ Benchmark, สูตรแนะนำ และการเปรียบเทียบประสิทธิภาพบนแพลตฟอร์ม Jetson ต่างๆ ได้ที่ [Jetson AI Lab Models](ขอบคุณ แหล่งข้อมูล
  https://developer.nvidia.com/blog/frontier-reasoning-reaches-the-edge/jetson-ai-lab-models/)
• ศึกษาคู่มือการติดตั้ง LLMs และ VLMs บน Jetson เพื่อดูคำแนะนำในการติดตั้งจริง: [Running LLMs and VLMs on Jetson tutorial](ขอบคุณ แหล่งข้อมูล
  https://developer.nvidia.com/blog/frontier-reasoning-reaches-the-edge/running-llms-and-vlms-on-jetson-tutorial/)
• เจาะลึกการใช้เทคนิคการปรับปรุงประสิทธิภาพด้วยคู่มือ Speculative Decoding: [Getting started with speculative decoding tutorial](ขอบคุณ แหล่งข้อมูล
  https://developer.nvidia.com/blog/frontier-reasoning-reaches-the-edge/getting-started-with-speculative-decoding-tutorial/)

การนำ AI ขั้นสูงมาสู่ขอบเขตเปิดโอกาสใหม่ๆ มากมาย ตั้งแต่ผู้ช่วยในห้องโดยสารรถยนต์ การตรวจจับความผิดปกติแบบเรียลไทม์ ไปจนถึงหุ่นยนต์ที่ทำงานในสภาพแวดล้อมที่ท้าทาย ทำให้ผู้เชี่ยวชาญสามารถทำงานได้อย่างมีประสิทธิภาพมากขึ้น และระบบสำคัญก็ยังคงทำงานได้แม้ในขณะที่การเชื่อมต่ออินเทอร์เน็ตมีจำกัดหรือขาดหายไป

ขอบคุณ แหล่งข้อมูล
https://developer.nvidia.com/blog/frontier-reasoning-reaches-the-edge-how-to-deploy-and-optimize-models-on-nvidia-jetson/

สร้าง Agent ขับเคลื่อนด้วยหน่วยความจำ ด้วย NVIDIA NeMo

ในยุคที่ปัญญาประดิษฐ์ (AI) ก้าวหน้าอย่างรวดเร็ว เราได้เห็นการพัฒนาของโมเดลภาษาขนาดใหญ่ (Large Language Models - LLMs) ที่มีความสามารถในการโต้ตอบและสร้างสรรค์ข้อความได้อย่างน่าทึ่ง อย่างไรก็ตาม LLMs แบบดั้งเดิมยังมีข้อจำกัดในการจดจำบริบทและการรักษาความต่อเนื่องของการสนทนาในระยะยาว

การมาถึงของ NVIDIA NeMo ซึ่งเป็นเฟรมเวิร์กที่ออกแบบมาเพื่อช่วยนักพัฒนาสร้างและปรับแต่ง LLMs ได้เปิดประตูสู่ความเป็นไปได้ใหม่ๆ หนึ่งในนั้นคือการสร้าง "Agent ขับเคลื่อนด้วยหน่วยความจำ" (Memory-Driven Agent) ที่สามารถจดจำข้อมูลจากการสนทนาที่ผ่านมา และนำมาใช้ในการตอบสนองได้อย่างชาญฉลาดและเป็นธรรมชาติมากขึ้น

Agent ขับเคลื่อนด้วยหน่วยความจำ คืออะไร?

Agent ประเภทนี้จะมีความสามารถในการ "จำ" ข้อมูลสำคัญที่เกิดขึ้นระหว่างการสนทนา ไม่ว่าจะเป็นข้อเท็จจริงที่ผู้ใช้ป้อนเข้ามา ความชอบส่วนบุคคล หรือแม้แต่ประวัติการสนทนาทั้งหมด จากนั้น Agent จะใช้ข้อมูลที่จำได้นี้มาประกอบการตัดสินใจและสร้างคำตอบที่เกี่ยวข้องและมีความต่อเนื่องกับบริบทเดิม

ลองนึกภาพว่าคุณกำลังคุยกับผู้ช่วย AI เกี่ยวกับการวางแผนท่องเที่ยว Agent ที่มีหน่วยความจำจะสามารถจดจำได้ว่าคุณเคยบอกว่าชอบทะเลสาบ และจะเสนอตัวเลือกสถานที่ท่องเที่ยวที่เป็นทะเลสาบให้โดยอัตโนมัติ โดยไม่ต้องให้คุณย้ำเตือนอีกครั้ง

ทำไมหน่วยความจำจึงสำคัญสำหรับ Agent?

1. การสนทนาที่ต่อเนื่องและเป็นธรรมชาติ: การที่ Agent จำสิ่งที่คุยกันได้ ทำให้การสนทนาไหลลื่น ไม่ต้องเริ่มต้นใหม่ทุกครั้งที่ถาม
2. การตอบสนองที่ตรงจุด: Agent สามารถอ้างอิงข้อมูลที่ได้รับมาก่อนหน้า ทำให้คำตอบมีความเฉพาะเจาะจงและมีประโยชน์มากขึ้น
3. การสร้างความสัมพันธ์: การที่ Agent จำรายละเอียดเล็กๆ น้อยๆ ได้ ช่วยสร้างความรู้สึกผูกพันและความน่าเชื่อถือให้กับผู้ใช้
4. การทำงานที่ซับซ้อน: Agent สามารถนำข้อมูลที่สะสมมาใช้ในการทำงานที่ต้องอาศัยการวางแผนและการตัดสินใจต่อเนื่อง เช่น การจัดการโปรเจกต์ หรือการให้คำแนะนำส่วนบุคคล

การสร้าง Agent ขับเคลื่อนด้วยหน่วยความจำด้วย NVIDIA NeMo

NVIDIA NeMo เป็นแพลตฟอร์มที่ทรงพลังซึ่งช่วยให้นักพัฒนาสามารถสร้าง LLMs ที่มีความสามารถขั้นสูงได้ การสร้าง Agent ที่มีหน่วยความจำนั้น อาศัยเทคนิคและการออกแบบที่ชาญฉลาด โดยทั่วไปแล้ว อาจเกี่ยวข้องกับ:

• การจัดการหน่วยความจำ (Memory Management): การออกแบบระบบที่สามารถจัดเก็บ ประมวลผล และเรียกใช้ข้อมูลที่จำเป็นจากประวัติการสนทนาได้อย่างมีประสิทธิภาพ
• การดึงข้อมูล (Information Retrieval): การพัฒนากลไกที่ช่วยให้ Agent สามารถค้นหาและดึงข้อมูลที่เกี่ยวข้องจากคลังหน่วยความจำได้อย่างรวดเร็ว
• การรวมบริบท (Context Integration): การนำข้อมูลจากหน่วยความจำมารวมกับข้อมูลใหม่ เพื่อสร้างคำตอบที่สมบูรณ์

NVIDIA NeMo นำเสนอเครื่องมือและ API ที่ช่วยอำนวยความสะดวกในกระบวนการเหล่านี้ ทำให้นักพัฒนาสามารถโฟกัสไปที่การออกแบบพฤติกรรมของ Agent และการสร้างประสบการณ์ผู้ใช้ที่ดีที่สุด

ประโยชน์ของการนำไปใช้

Agent ขับเคลื่อนด้วยหน่วยความจำสามารถนำไปประยุกต์ใช้ได้หลากหลายวงการ เช่น:

• ผู้ช่วยส่วนตัว: จดจำตารางนัดหมาย ความชอบ และให้คำแนะนำที่ปรับให้เหมาะกับแต่ละบุคคล
• บริการลูกค้า: จดจำประวัติการติดต่อ ปัญหาที่เคยแจ้ง และให้ความช่วยเหลือได้อย่างรวดเร็วและตรงจุด
• การศึกษา: สร้างสภาพแวดล้อมการเรียนรู้แบบโต้ตอบที่ปรับเนื้อหาตามความเข้าใจของผู้เรียน
• การพัฒนาเกม: สร้างตัวละคร AI ที่มีบุคลิกและความทรงจำของตัวเอง

สรุป

การพัฒนา Agent ขับเคลื่อนด้วยหน่วยความจำถือเป็นก้าวสำคัญในการทำให้ AI มีความสามารถใกล้เคียงมนุษย์มากขึ้น NVIDIA NeMo เป็นเครื่องมือสำคัญที่ช่วยให้นักพัฒนาสามารถสร้างสรรค์ Agent ที่ชาญฉลาดเหล่านี้ได้อย่างมีประสิทธิภาพ การมีหน่วยความจำจะช่วยยกระดับประสบการณ์การโต้ตอบกับ AI ให้ดียิ่งขึ้นในทุกมิติ

ขอบคุณ แหล่งข้อมูล
https://developer.nvidia.com/blog/building-a-memory-driven-agent-with-nvidia-nemoclaw/

จัดการตัวตนผู้ใช้ข้ามแพลตฟอร์ม Kubernetes และ AI แบบรวมศูนย์

ในยุคที่แพลตฟอร์ม AI ไม่ได้จำกัดอยู่แค่แอปพลิเคชันเดียวที่มีหน้าจอเข้าสู่ระบบเพียงหน้าจอเดียว ผู้ใช้อาจเริ่มต้นจากพอร์ทัลกลาง เข้าถึงชุดข้อมูลที่ควบคุม หรือเปิดใช้งาน Notebook เพื่อทำงานกับข้อมูลเหล่านั้น ซึ่งทั้งหมดนี้ควรให้ประสบการณ์ที่ราบรื่นและเป็นหนึ่งเดียว แต่เมื่อตัวตนของผู้ใช้ต้องข้ามขอบเขตของ Control Plane และ Data Plane ในทุกขั้นตอน การจัดการ Single Sign-On (SSO) แบบเดิมๆ ก็อาจไม่เพียงพออีกต่อไป

สำหรับทีมที่ดูแลแพลตฟอร์มข้อมูลหรือ AI แบบกระจายศูนย์ที่ครอบคลุมหลายคลัสเตอร์ การส่งต่อบริบทของผู้ใช้ไปยังสภาพแวดล้อมการประมวลผลแบบกระจายทำได้ยาก โดยไม่จำเป็นต้องส่ง Token ดิบให้กับทุกแอปพลิเคชัน ทำให้การเพิกถอนสิทธิ์ทำได้ยากขึ้น หรือบังคับให้แต่ละคลัสเตอร์ต้องสร้าง Logic การจัดการ Identity Provider ขึ้นมาใหม่เอง

ความท้าทายนี้ยิ่งทวีความสำคัญสำหรับแพลตฟอร์ม AI และข้อมูล ที่ซึ่งข้อมูลและการประมวลผลมักจะอยู่ใกล้กับแหล่งผลิต จัดเก็บ หรือควบคุม เวิร์กโหลดอาจทำงานในคลัสเตอร์ระดับภูมิภาค บัญชีคลาวด์แยกต่างหาก สภาพแวดล้อม On-premises หรือระนาบการประมวลผลเฉพาะทาง แต่ผู้ใช้ยังคงคาดหวังประสบการณ์แพลตฟอร์มที่เป็นหนึ่งเดียว ครอบคลุมทั้ง Notebook, Catalog, เครื่องมือ Query และผู้ช่วย AI

บทความนี้จะนำเสนอรูปแบบ "Central Identity Gateway Pattern" หรือ "รูปแบบเกตเวย์ตัวตนแบบรวมศูนย์" สำหรับการส่งต่อตัวตนผู้ใช้ข้าม Data Planes ที่กระจายศูนย์ โดยเกตเวย์ส่วนกลางจะเป็นเจ้าของ Session ของแพลตฟอร์ม ในขณะที่เกตเวย์ระดับภูมิภาคจะตรวจสอบ Session ดังกล่าวผ่าน API ที่ใช้ร่วมกัน และแปลงเป็นบริบทตัวตนท้องถิ่นที่เชื่อถือได้สำหรับแอปพลิเคชันปลายทาง รูปแบบนี้ใช้มาตรฐาน OpenID Connect (OIDC), ที่เก็บ Session ที่ใช้ร่วมกัน, เกตเวย์ระดับภูมิภาคแบบ Stateless และ API ตรวจสอบตัวตนขนาดเล็กที่บริการต่างๆ สามารถเชื่อถือได้

ที่ NVIDIA การนำรูปแบบนี้มาใช้ช่วยลดเหตุการณ์การเข้าสู่ระบบซ้ำๆ ลงได้ถึง 55% บนแพลตฟอร์มสำหรับนักพัฒนาภายใน ที่ครอบคลุมคลัสเตอร์ Kubernetes ใน AWS และ OCI ที่สำคัญกว่านั้นคือ การสร้างรากฐานที่นำกลับมาใช้ใหม่ได้สำหรับ Unified Platform Shells, การออกจากระบบที่สอดคล้องกัน, การลดภาระของ Identity Provider ต้นทาง และการทำให้ AI Assistants สามารถทำงานโดยมีตัวตนของผู้ใช้ที่ได้รับมอบหมายข้าม Data Planes ได้

เมื่อ SSO สิ้นสุดลง และตัวตน Data Plane เริ่มต้นขึ้น

รายละเอียดการนำไปใช้งานอาจแตกต่างกันไปในแต่ละองค์กร แต่การออกแบบหลักสามารถนำไปปรับใช้ได้อย่างกว้างขวางสำหรับทีมแพลตฟอร์มที่ใช้งานสภาพแวดล้อม Kubernetes แบบ Federated, แพลตฟอร์มข้อมูล Multi-cloud, Machine Learning Workbench, พอร์ทัลสำหรับนักพัฒนาภายใน หรือสแต็กแอปพลิเคชัน AI ที่มีเครื่องมือที่ผ่านการรับรองความถูกต้องหลายอย่าง

SSO ช่วยให้ผู้ใช้มีจุดเข้าใช้งานเพียงจุดเดียว แต่แพลตฟอร์มข้อมูลแบบ Federated ยังคงต้องการวิธีการส่งต่อตัวตนเข้าไปยังระนาบที่การทำงานเกิดขึ้นจริง ไม่ว่าจะเป็น Notebook ในคลัสเตอร์หนึ่ง, API Catalog ในอีกคลัสเตอร์หนึ่ง, หรือผู้ช่วยที่เรียกใช้ Query Engine ในคลัสเตอร์ที่สาม ทั้งหมดนี้ต้องการคำตอบเดียวกัน: "ใครคือผู้ใช้ และพวกเขาได้รับอนุญาตให้ทำอะไรที่นี่?"

หากไม่มีโมเดลการส่งต่อตัวตนที่ใช้ร่วมกัน ปัญหาหลายอย่างจะปรากฏขึ้น:

• การยืนยันตัวตนที่ Control Plane ไม่ได้กลายเป็นตัวตน Data Plane ที่เชื่อถือได้โดยอัตโนมัติ: การยืนยันตัวตนที่จุดเข้าใช้งานเพียงอย่างเดียว ไม่ได้รับประกันว่าผู้ใช้คนเดียวกันนี้จะถูกจดจำและได้รับสิทธิ์ที่ถูกต้องในทุกส่วนของระบบที่กระจายออกไป
• การส่งต่อ Token ดิบเพิ่มความเสี่ยงด้านข้อมูลประจำตัว: การส่ง Token ที่มีสิทธิ์ของผู้ใช้โดยตรงไปยังทุกบริการ ทำให้ยากต่อการตรวจสอบว่าใครสามารถใช้ Token ใดได้บ้าง และเพิ่มโอกาสในการรั่วไหล
• เกตเวย์ Data Plane แต่ละแห่งอาจผสานรวมกับ Identity Provider แตกต่างกัน: นำไปสู่ความไม่สอดคล้องกันของ Claims, พฤติกรรมการ Refresh Token และบันทึกการตรวจสอบ (Audit Records)
• การออกจากระบบและการเพิกถอนสิทธิ์อาจไม่แพร่กระจายอย่างรวดเร็ว: การออกจากระบบในคลัสเตอร์หนึ่ง อาจยังคงมี Session ที่ทำงานอยู่ในคลัสเตอร์อื่น ทำให้เกิดความสับสนและความเสี่ยงด้านความปลอดภัย
• แอปพลิเคชันใหม่ได้รับสิทธิ์การจัดการตัวตนที่ซ้ำซ้อน: การเพิ่มเครื่องมือใหม่ๆ มักจะหมายถึงการสร้างการรวมระบบการยืนยันตัวตนแบบเดิมๆ ซ้ำอีกครั้ง

สำหรับผู้ใช้ อาการที่สังเกตได้อาจเป็น "การแจ้งให้เข้าสู่ระบบซ้ำๆ" สำหรับวิศวกรแพลตฟอร์ม ปัญหาที่ซ่อนอยู่คือ "การส่งต่อ Token แบบกระจาย" ซึ่งตัวตนที่สร้างขึ้นที่ Control Plane จะต้องถูกแปลงเป็นบริบทที่เชื่อถือได้ มีขอบเขตที่ชัดเจน และตรวจสอบได้ในทุก Data Plane

โมเดลนี้ใช้ได้ดีกับแอปพลิเคชันจำนวนน้อย แต่จะสร้างปัญหาเชิงโครงสร้างเมื่อแพลตฟอร์มขยายตัว:

• Session ถูกจำกัดขอบเขตตามที่สร้างขึ้น: Token ที่ออกโดยเกตเวย์หนึ่ง จะไม่เป็นที่รู้จักของเกตเวย์อื่น ทำให้ผู้ใช้ต้องยืนยันตัวตนสำหรับแต่ละบริการ แทนที่จะเป็นทั้งแพลตฟอร์ม
• การออกจากระบบเป็นแบบ Local: การออกจากระบบเครื่องมือหนึ่ง อาจยังคงมี Session ที่ทำงานอยู่กับเครื่องมืออื่น ทำให้เกิดทั้งความสับสนของผู้ใช้และความเสี่ยงด้านความปลอดภัย
• การ Refresh Token ไม่ได้รับการประสานงาน: แต่ละเกตเวย์จะเจรจาวงจรการ Refresh กับ Identity Provider ต้นทางอย่างอิสระ เพิ่มภาระและสร้างสถานะ Session ที่แตกต่างกัน
• บริบทตัวตนไม่สอดคล้องกัน: บริการปลายทางมักจะแยกวิเคราะห์ Token แตกต่างกัน หรือมีการทำซ้ำ Logic การยืนยันตัวตน
• บริการใหม่ๆ ต้องเผชิญกับความซับซ้อนเดิมๆ: การเพิ่มเครื่องมืออีกชิ้น มักจะหมายถึงการสร้างการรวมระบบการยืนยันตัวตนแบบเดิมๆ ซ้ำอีกครั้ง

สำหรับผู้ใช้แพลตฟอร์ม อาการที่พบคือการแจ้งให้เข้าสู่ระบบซ้ำๆ และพฤติกรรมที่ไม่สอดคล้องกัน สำหรับวิศวกรแพลตฟอร์ม ปัญหาที่ลึกกว่านั้นคือ "การเป็นเจ้าของ Session" ที่กระจายอยู่ในส่วนประกอบต่างๆ ซึ่งควรมีหน้าที่เพียงการบังคับใช้นโยบาย (Access Enforcement) เท่านั้น ไม่ใช่การเป็นเจ้าของสถานะตัวตน

เปรียบเทียบรูปแบบการจัดการตัวตน 2 แบบ

มีสองวิธีทั่วไปในการจัดโครงสร้างการจัดการตัวตนในแพลตฟอร์มแบบ Federated:

1. รูปแบบการเป็นเจ้าของ Session แบบกระจาย (Distributed Session Ownership): เกตเวย์ของแต่ละบริการจะเป็นเจ้าของ Flow การเข้าสู่ระบบ, ที่เก็บ Session, Logic การ Refresh Token และพฤติกรรมการออกจากระบบของตนเอง วิธีนี้ช่วยให้แต่ละคลัสเตอร์เป็นอิสระ แต่ก็หมายความว่าสถานะตัวตนจะไม่สามารถเคลื่อนย้ายข้ามแพลตฟอร์มได้อย่างราบรื่น
2. รูปแบบการเป็นเจ้าของ Session แบบรวมศูนย์ (Centralized Session Ownership): เกตเวย์ตัวตนเฉพาะจะรับผิดชอบการเข้าสู่ระบบ, สถานะ Session, การ Refresh และการออกจากระบบ เกตเวย์ระดับภูมิภาคยังคงมีอยู่ แต่จะมอบหมายการตรวจสอบ Session ให้กับเกตเวย์ส่วนกลาง และเน้นการบังคับใช้นโยบายการเข้าถึง (Request Enforcement)

| คุณสมบัติ | รูปแบบกระจาย (Distributed) | รูปแบบรวมศูนย์ (Centralized) |
| :----------------------- | :--------------------------------------------------------- | :------------------------------------------------------------ |
| การเข้าสู่ระบบ | แต่ละเกตเวย์จัดการ OIDC Flow และ Session ของตนเอง | เกตเวย์ส่วนกลางจัดการ OIDC Flow และสร้าง Session แพลตฟอร์ม |
| การออกจากระบบ | การออกจากระบบเป็นแบบ Local, ไม่ส่งผลต่อบริการอื่น | การออกจากระบบที่เกตเวย์ส่วนกลาง จะส่งผลทันทีทั่วทั้งแพลตฟอร์ม |
| การ Refresh Token | แต่ละเกตเวย์จัดการ Refresh Token ของตนเอง | เกตเวย์ส่วนกลางจัดการ Refresh Token และอัปเดต Session ที่ใช้ร่วมกัน |
| การส่งต่อตัวตน | ต้องส่ง Token ดิบ หรือ Claims จาก Token | เกตเวย์ระดับภูมิภาคสร้าง Header ตัวตนที่เชื่อถือได้จาก Session |
| การปรับขนาดการดำเนินงาน | ภาระ Identity Provider เพิ่มตามจำนวน User-Tool Combinations | ภาระ Identity Provider ปรับตามจำนวน User ที่ใช้งานอยู่ |

การเป็นเจ้าของ Session แบบรวมศูนย์ไม่จำเป็นสำหรับทุกแอปพลิเคชัน แต่จะกลายเป็นสิ่งที่มีคุณค่าเมื่อผู้ใช้ต้องทำงานข้ามเครื่องมือ, คลัสเตอร์, หรือภูมิภาคต่างๆ ใน Workflow เดียวกัน และคาดหวังว่าเครื่องมือเหล่านั้นจะทำงานเสมือนเป็นแพลตฟอร์มเดียว

รูปแบบ Central Identity Gateway

เกตเวย์ตัวตนส่วนกลางรับผิดชอบ 3 ส่วนหลัก:

1. การสร้าง Session: จัดการ OIDC Authorization Code Flow และสร้าง Session ที่ครอบคลุมทั้งแพลตฟอร์ม
2. การตรวจสอบตัวตนต่อคำขอ (Per-request Identity Validation): ตอบคำถาม "ใครคือผู้ใช้นี้?" สำหรับเกตเวย์หรือบริการที่เชื่อถือได้
3. การจัดการวงจรชีวิต Session: ประสานงานการ Refresh Token และการออกจากระบบทั่วทั้งแพลตฟอร์ม

เกตเวย์การยืนยันตัวตนระดับภูมิภาคยังคงมีอยู่ โดยยังคงทำหน้าที่บังคับใช้นโยบายต่อคลัสเตอร์, ปกป้องบริการในพื้นที่, และแทรกตัวตนเข้าไปในคำขอ สิ่งที่เปลี่ยนแปลงคือ "ที่อยู่" ของ Session แทนที่จะเก็บ Session ไว้ในเกตเวย์ระดับภูมิภาคแต่ละแห่ง เกตเวย์ส่วนกลางจะเขียน Session ที่ผ่านการยืนยันตัวตนทั้งหมดไปยังที่เก็บที่ใช้ร่วมกัน เช่น Redis

Session จะถูกคีย์ด้วย Session ID ที่ไม่เปิดเผย และเชื่อมโยงกับ Cookie ของเบราว์เซอร์ที่ปลอดภัยแบบ HTTP-only ซึ่งถูกกำหนดขอบเขต (scoped) ให้กับโดเมนของแพลตฟอร์ม

ในแต่ละคำขอ เกตเวย์ระดับภูมิภาคจะเรียก Endpoint การตรวจสอบตัวตน เช่น /gateway/userinfo เกตเวย์ส่วนกลางจะตรวจสอบที่เก็บ Session และส่งคืน Identity Claims ที่เชื่อถือได้ เกตเวย์ระดับภูมิภาคจะแทรกชุด Header ตัวตนที่เป็นมาตรฐานก่อนส่งต่อคำขอไปยังแอปพลิเคชัน

แอปพลิเคชันไม่จำเป็นต้องแยกวิเคราะห์ Token, Refresh ข้อมูลประจำตัว, หรือผสานรวมโดยตรงกับ Identity Provider อีกต่อไป พวกเขาจะได้รับตัวตนจาก Interface ที่สอดคล้องกัน

รูปแบบนี้มี 3 Flow หลัก: การเข้าสู่ระบบ, การตรวจสอบ, และการออกจากระบบ

Flow การเข้าสู่ระบบ (Login Flow)

เมื่อผู้ใช้เข้ามาโดยไม่มี Session แพลตฟอร์มที่ถูกต้อง เกตเวย์ระดับภูมิภาคจะเปลี่ยนเส้นทางเบราว์เซอร์ไปยังเกตเวย์ส่วนกลาง เกตเวย์ส่วนกลางจะดำเนินการ OIDC Authorization Code Flow กับ Identity Provider ขององค์กร, แลกเปลี่ยน Authorization Code แบบ Server-side, จัดเก็บ Session ที่ได้ใน Redis พร้อมกำหนด Time-to-live (TTL) และตั้งค่า Session Cookie แบบ HTTP-only

Session Cookie นี้จะกลายเป็นข้อมูลประจำตัวแพลตฟอร์มของผู้ใช้สำหรับ Session ที่เหลือ

การตรวจสอบต่อคำขอ (Per-request Validation)

ในการร้องขอครั้งต่อๆ ไป เกตเวย์ระดับภูมิภาคจะส่ง Session Cookie ไปยัง /gateway/userinfo เกตเวย์ส่วนกลางจะทำการค้นหา Session และส่งคืน Identity Claims เช่น User ID, อีเมล, กลุ่ม, บทบาท และ Metadata ของ Session

เกตเวย์ระดับภูมิภาคจะใช้ Claims เหล่านี้เพื่อแทรก Header ตัวตนที่เชื่อถือได้ บริการปลายทางจะอ่าน Header และใช้ Logic การอนุญาต (Authorization Logic) ในระดับท้องถิ่นตามความจำเป็น

สิ่งนี้ทำให้เส้นทางการร้องขอ (Request Path) มีน้ำหนักเบา การร้องขอปกติไม่จำเป็นต้องมีการแลกเปลี่ยน OIDC หรือการเรียก Identity Provider โดยตรง เพียงแค่การค้นหา Session และการเรียกตรวจสอบความถูกต้องระหว่างเกตเวย์ที่เชื่อถือได้

การ Refresh Token และการออกจากระบบ (Token Refresh and Logout)

เมื่อ Access Token ใกล้หมดอายุ เกตเวย์ส่วนกลางจะ Refresh Token โดยใช้ Refresh Token ที่จัดเก็บไว้ และอัปเดตบันทึก Session เนื่องจากสถานะที่ Refresh แล้วถูกเขียนไปยังที่เก็บที่ใช้ร่วมกัน เกตเวย์ระดับภูมิภาคทุกแห่งจึงจะเห็นสถานะ Session เดียวกัน

สำหรับการออกจากระบบ เกตเวย์ส่วนกลางจะล

ขอบคุณ แหล่งข้อมูล
https://developer.nvidia.com/blog/how-to-carry-user-identity-across-federated-kubernetes-and-ai-platforms/

สร้างระบบรักษาความปลอดภัยทางไซเบอร์แบบปรับตัวได้ด้วย NVIDIA Nemotron: ก้าวใหม่ของ AI ในวงการความปลอดภัย

โลกของความปลอดภัยทางไซเบอร์กำลังเผชิญกับการเปลี่ยนแปลงครั้งใหญ่ด้วยพลังของปัญญาประดิษฐ์ (AI) โดยเฉพาะอย่างยิ่งระบบแบบ Agentic ที่มีความสามารถในการประสานงานและบรรลุเป้าหมายที่ซับซ้อนในระยะยาว ทีมรักษาความปลอดภัยเริ่มนำ Agent มาประยุกต์ใช้ในงานปฏิบัติการด้านความปลอดภัยอย่างกว้างขวาง และ NVIDIA Nemotron คือเครื่องมือสำคัญที่จะช่วยให้การพัฒนาระบบเหล่านี้เป็นไปได้อย่างมีประสิทธิภาพ

AI กับความท้าทายใหม่ในโลกไซเบอร์

ภัยคุกคามทางไซเบอร์มีความซับซ้อนและเปลี่ยนแปลงอยู่ตลอดเวลา ทำให้ทีมรักษาความปลอดภัยต้องทำงานหนักขึ้นเพื่อรับมือ การใช้ AI ไม่ใช่แค่ทางเลือก แต่เป็นสิ่งจำเป็นในการยกระดับประสิทธิภาพการทำงาน ตั้งแต่การตรวจจับภัยคุกคาม การวิเคราะห์ข้อมูล ไปจนถึงการตอบสนองต่อเหตุการณ์

ระบบแบบ Agentic หรือระบบที่ทำงานโดยมี "เอเจนต์" (Agent) เป็นตัวขับเคลื่อน มีความโดดเด่นตรงที่เอเจนต์เหล่านี้สามารถทำงานร่วมกัน เรียนรู้ และปรับตัวให้เข้ากับสถานการณ์ที่เปลี่ยนแปลงไปได้ ซึ่งเป็นคุณสมบัติสำคัญในการรับมือกับภัยคุกคามที่คาดเดาได้ยาก

NVIDIA Nemotron: พลังขับเคลื่อน Agentic Cybersecurity

NVIDIA Nemotron เป็นโมเดลภาษาขนาดใหญ่ (Large Language Model - LLM) ที่ออกแบบมาเพื่อรองรับการสร้างระบบ Agentic โดยเฉพาะ ทำให้ทีมพัฒนาสามารถสร้างเอเจนต์ที่ชาญฉลาด สามารถทำความเข้าใจบริบท วิเคราะห์ข้อมูล และตัดสินใจได้อย่างมีประสิทธิภาพ

จุดเด่นของ NVIDIA Nemotron ในงาน Cybersecurity

• ความสามารถในการประมวลผลภาษาธรรมชาติ: Nemotron เข้าใจและสร้างข้อความที่ซับซ้อนได้ ทำให้เอเจนต์สามารถสื่อสาร ตีความคำสั่ง และรายงานผลได้อย่างแม่นยำ
• การทำงานแบบ Agentic: รองรับการสร้างเอเจนต์ที่สามารถทำงานร่วมกัน วางแผน และบรรลุเป้าหมายที่ซับซ้อนได้
• ความยืดหยุ่นและการปรับตัว: สามารถปรับแต่งและฝึกฝนโมเดลให้เหมาะสมกับงานด้านความปลอดภัยเฉพาะทางได้
• การผสานรวมกับระบบนิเวศของ NVIDIA: ทำงานร่วมกับฮาร์ดแวร์และซอฟต์แวร์อื่น ๆ ของ NVIDIA ได้อย่างราบรื่น เพิ่มประสิทธิภาพการประมวลผล

การประยุกต์ใช้ Nemotron ในระบบรักษาความปลอดภัย

NVIDIA Nemotron เปิดโอกาสให้ทีมรักษาความปลอดภัยสามารถสร้างระบบอัตโนมัติที่ทรงพลังในหลากหลายมิติ เช่น:

• การตรวจจับและวิเคราะห์ภัยคุกคามขั้นสูง: เอเจนต์สามารถเฝ้าระวังเครือข่าย วิเคราะห์ Log File และระบุรูปแบบของมัลแวร์หรือการโจมตีที่ซับซ้อนได้อย่างรวดเร็ว
• การตอบสนองต่อเหตุการณ์อัตโนมัติ (Automated Incident Response): เมื่อตรวจพบภัยคุกคาม เอเจนต์สามารถดำเนินการตามแผนรับมือที่กำหนดไว้ล่วงหน้า เช่น การกักกันอุปกรณ์ที่ติดมัลแวร์ หรือการบล็อก IP Address ที่น่าสงสัย
• การบริหารจัดการช่องโหว่ (Vulnerability Management): เอเจนต์สามารถสแกนหาช่องโหว่ในระบบ ประเมินความเสี่ยง และแนะนำแนวทางการแก้ไข
• การจำลองสถานการณ์โจมตี (Threat Simulation): ใช้เอเจนต์จำลองการโจมตีรูปแบบต่างๆ เพื่อทดสอบประสิทธิภาพของระบบรักษาความปลอดภัยที่มีอยู่

ก้าวต่อไปของความปลอดภัยทางไซเบอร์

การนำ NVIDIA Nemotron มาใช้ในการสร้างระบบรักษาความปลอดภัยแบบ Agentic ไม่ใช่แค่การนำเทคโนโลยีใหม่มาใช้ แต่เป็นการเปลี่ยนกระบวนทัศน์ในการรับมือกับภัยคุกคามทางไซเบอร์ ด้วยความสามารถในการเรียนรู้ ปรับตัว และทำงานร่วมกัน เอเจนต์ที่ขับเคลื่อนด้วย Nemotron จะช่วยให้ทีมรักษาความปลอดภัยทำงานได้อย่างมีประสิทธิภาพมากขึ้น ลดภาระงานซ้ำๆ และมุ่งเน้นไปที่การวางกลยุทธ์และการตัดสินใจที่สำคัญ

การลงทุนในการพัฒนาและประยุกต์ใช้ระบบ Agentic Cybersecurity ด้วย NVIDIA Nemotron จึงเป็นการเตรียมความพร้อมเพื่อรับมือกับความท้าทายด้านความปลอดภัยในอนาคตได้อย่างมั่นคงและมีประสิทธิภาพยิ่งขึ้น

#Cybersecurity #AI #NVIDIANemotron #AgenticSystems

ขอบคุณ แหล่งข้อมูล
https://developer.nvidia.com/blog/building-an-adaptive-agentic-cybersecurity-system-with-nvidia-nemotron/

การทำนายโครงสร้างโปรตีนด้วย NVIDIA BioNeMo NIM และ Claude Science: เจาะลึกการทำงานของ AI ในงานวิจัยชีววิทยา

ในยุคที่ปัญญาประดิษฐ์ (AI) เข้ามามีบทบาทสำคัญในทุกวงการ งานวิจัยทางวิทยาศาสตร์ก็เช่นกัน AI กำลังเปลี่ยนแปลงวิธีการทำงานวิจัย โดยเฉพาะในสาขาชีววิทยา ที่ AI สามารถช่วยอ่านงานวิจัย วางสมมติฐาน เรียกใช้โมเดล และตัดสินใจว่าควรทดลองเรื่องใดเป็นลำดับถัดไป

บทความนี้จะพาไปสำรวจการทำงานของ NVIDIA BioNeMo Agent Toolkit ที่ผสานรวมกับ Claude Science และ NVIDIA NIM microservices เพื่อให้ AI สามารถจัดการกระบวนการทำนายโครงสร้างโปรตีนที่ซับซ้อน โดยใช้เทคนิคการจัดเรียงลำดับกรดอะมิโนหลายชนิด (Multiple Sequence Alignment - MSA) และโมเดลการพับตัวของโปรตีนหลายแบบ

AI Agent ในงานวิจัย: ความท้าทายและโอกาส

AI Agent หรือ AI ที่มีความสามารถในการตัดสินใจและดำเนินการด้วยตนเอง กำลังพิสูจน์คุณค่าในหลากหลายสาขา รวมถึงวิศวกรรมซอฟต์แวร์ ที่ AI สามารถเขียน ทดสอบ และส่งมอบโค้ดที่ใช้งานได้จริง

ในงานวิจัยทางวิทยาศาสตร์ ความต้องการอาจมีความซับซ้อนและต้องทำซ้ำมากกว่า นักวิจัยต้องประเมินหลักฐาน ปรับปรุงสมมติฐาน และดำเนินการทดลองที่หล่อหลอมการตัดสินใจในภายหลัง แม้แต่การทดลองที่ล้มเหลวก็สามารถนำไปสู่ข้อมูลเชิงลึกที่ไม่คาดคิดได้

ปัญหาทางวิทยาศาสตร์มักต้องการเครื่องมือเฉพาะทาง เช่น การพับตัวของโปรตีน หรือการจำแนกลักษณะโมเลกุล การจัดการและใช้งานเครื่องมือเหล่านี้อาจเป็นเรื่องท้าทาย เพราะแพ็กเกจที่คล้ายกันอาจมีข้อกำหนดด้านสภาพแวดล้อมหรือ API ที่แตกต่างกันมาก AI Agent ทั่วไปอาจรับรู้ได้ว่างานหนึ่งต้องใช้การพับตัวของโปรตีน แต่ไม่สามารถระบุได้ว่าจะต้องใช้โมเดลใด รูปแบบการส่งคำขอ หรือพารามิเตอร์ใดที่มีความสำคัญ

NVIDIA BioNeMo Agent Toolkit: สะพานเชื่อมสู่ความสำเร็จ

NVIDIA BioNeMo Agent Toolkit ถูกสร้างขึ้นเพื่อปิดช่องว่างนี้ โดยรวบรวมโมเดล ไลบรารี และเวิร์กโฟลว์ด้านวิทยาศาสตร์ชีวภาพจาก NVIDIA BioNeMo ตลอดกว่าทศวรรษ ให้กลายเป็น "ทักษะ" (Skills) ที่ AI Agent สามารถเรียกใช้ได้ สำหรับงานด้านชีววิทยา เคมี จีโนมิกส์ และการค้นคว้ายา

เครื่องมือนี้ถูกออกแบบมาให้ทำงานร่วมกับเฟรมเวิร์ก AI Agent ใดก็ได้ ช่วยให้สามารถสร้างเวิร์กโฟลว์ทางวิทยาศาสตร์ที่ซับซ้อนได้โดยใช้ความเชี่ยวชาญเฉพาะด้าน จากการทดสอบภายใน BioNeMo skills ช่วยเพิ่มความถูกต้องของงานจาก 60% เป็น 100% และเพิ่มประสิทธิภาพการใช้โทเค็นขึ้นประมาณสองเท่า

การทำนายโครงสร้างโปรตีนด้วย Claude Science และ NVIDIA NIM

โพสต์นี้จะสาธิตการใช้ Claude Science ซึ่งเป็น AI Workbench สำหรับงานวิจัยทางวิทยาศาสตร์จาก Anthropic ร่วมกับ NVIDIA BioNeMo Agent Toolkit และ NVIDIA NIM เพื่อทำการทำนายโครงสร้างโปรตีน โดยใช้ MSA และโมเดลการพับตัวหลายแบบ เพื่อเปรียบเทียบผลลัพธ์

NVIDIA และ Anthropic ได้ร่วมมือกันผสานรวม BioNeMo Agent Toolkit เข้ากับ Claude Science ทำให้ AI Agent สามารถค้นหา เปิดใช้งาน และเรียกใช้ NVIDIA NIM microservices ได้โดยตรง

การตั้งค่าสภาพแวดล้อม

Claude Science สามารถทำงานได้ในหลายรูปแบบ ขึ้นอยู่กับตำแหน่งของ GPU และข้อกำหนดด้านความปลอดภัย บทความนี้จะเน้นที่การรันแพลตฟอร์มบนเครื่องที่มี GPU โดยคุณอาจต้องเข้าถึงเวิร์กสเตชันหรือเครื่องบนคลาวด์ที่มี NVIDIA L40S GPU หรือ NVIDIA H100 GPU และติดตั้ง Claude Science แล้ว โดยเครื่องต้องมีพื้นที่จัดเก็บประมาณ 700 GB

โดยปกติ Claude Science จะทำงานในสภาพแวดล้อมแบบ Sandbox การเรียกใช้ BioNeMo NIM microservices จำเป็นต้องมี Compute Endpoints ที่เปิดเผยทรัพยากร GPU ในเครื่องหรือระยะไกล ใน Claude Science ให้เลือก Customize > Compute > NVIDIA BioNeMo NIM > Connect จากนั้นนำเข้า BioNeMo Agent Toolkit skills จาก GitHub เพิ่ม NVIDIA API key และเชื่อมต่อกับ Local Endpoints ซึ่งเป็น Docker containers ที่ใช้ GPU ของโฮสต์

หลังจากนำเข้า Skills, จัดเก็บ API key และกำหนดค่าการเชื่อมต่อแล้ว ให้เริ่มโปรเจกต์และ Session ใหม่ จากนั้นสั่งให้ Claude Science สร้าง NIM microservice endpoints ที่จำเป็น

เมื่อได้รับคำสั่ง ให้เลือก Approve endpoint สำหรับทั้งสองโมเดล การตั้งค่า endpoints เหล่านี้จะต้องดาวน์โหลด containers สำหรับแต่ละ microservice

การวิเคราะห์โปรตีน Seh1 และ Mio-family

เมื่อ NIM endpoints ทั้งสามทำงานแล้ว Claude Science จะจัดการเวิร์กโฟลว์การทำนายโครงสร้าง ในตัวอย่างนี้ เราจะพิจารณาโปรตีน Seh1 และโปรตีนคู่หูที่คาดการณ์ไว้จาก Mio-family ใน Paracoccidioides lutzii ซึ่งเป็นเชื้อราที่ก่อให้เกิดโรค paracoccidioidomycosis ตัวอย่างนี้ได้รับแรงบันดาลใจจาก Figure 4e ของงานวิจัย Han, Tsenkov, Venanzi et al.

โปรตีน Seh1 และ Mio-family มีส่วนร่วมในกลไกการรับรู้สารอาหารที่สืบทอดกันมา และโครงสร้างจากสิ่งมีชีวิตอื่น ๆ บ่งชี้ว่า Mio สามารถเติมเต็มโครงสร้างแบบเปิดของ Seh1 ที่เรียกว่า β-propeller ได้ ทำให้คู่นี้เป็นตัวทดสอบที่ดีสำหรับการทำนายโครงสร้างที่ซับซ้อนโดยใช้ MSA

คำถามเชิงโครงสร้าง

ในการศึกษาครั้งนี้ เราใช้ระบบโปรตีนสองชนิดจาก Paracoccidioides lutzii: โปรตีนนิวเคลียร์พอร์ Seh1 (C1GY11) และคู่หูที่ยังไม่ได้รับการจำแนกประเภท (C1HCX1) คำถามเชิงโครงสร้างคือ: โครงสร้างที่คาดการณ์ของ Seh1 จะแตกต่างกันอย่างไรเมื่อจำลองเพียงลำพัง กับเมื่อจำลองร่วมกับคู่หูที่คาดการณ์ไว้?

เพื่อตอบคำถามนี้ Claude Science จะสร้างบริบททางวิวัฒนาการสำหรับลำดับเป้าหมายโดยใช้ MSA จากนั้นส่งการจัดเรียงเหล่านั้นไปยังโมเดลการพับตัวอิสระสองแบบ โดยเก็บรักษาอินพุตและเอาต์พุตไว้ เพื่อให้สามารถตรวจสอบการทำนายแบบ single-chain และ two-chain ภายในแต่ละโมเดลได้

เวิร์กโฟลว์นี้มี 3 ขั้นตอนหลัก:

1. สร้าง MSA: สร้าง MSA สำหรับลำดับ single-chain และลำดับคู่ของสปีชีส์ โดยใช้ MSA Search NIM ที่เร่งความเร็วด้วย GPU
2. ทำนายโครงสร้างด้วย OpenFold3: ทำนายโครงสร้างสำหรับ single chain และ two-chain complex โดยใช้ OpenFold3 NIM
3. ทำนายโครงสร้างด้วย Boltz-2: ทำซ้ำการทำนายด้วย Boltz-2 NIM และประเมินแต่ละโมเดลแยกกัน

ขั้นตอนที่ 1: การสร้าง MSA

Agent จะดึงลำดับโปรตีนทั้งสองจาก UniProt และสร้างการจัดเรียงสองประเภท:

• การจัดเรียงแบบไม่จับคู่ (Unpaired alignment): สำหรับโปรตีนแต่ละชนิด เพื่อให้ข้อมูลเกี่ยวกับโครงสร้างของแต่ละสาย
• การจัดเรียงแบบจับคู่ (Paired alignment): โดยการจับคู่โปรตีนที่เกี่ยวข้องซึ่งพบในสปีชีส์เดียวกัน หากการเปลี่ยนแปลงในโปรตีนหนึ่งสอดคล้องกับการเปลี่ยนแปลงในอีกโปรตีนหนึ่งอย่างสม่ำเสมอ รูปแบบนั้นสามารถช่วยให้โมเดลทำนายจุดที่โปรตีนอาจมีปฏิสัมพันธ์กันได้

ในการรันนี้ การค้นหาพบ 202 ลำดับสำหรับโปรตีนแต่ละชนิด Agent ได้บันทึกแหล่งที่มาและลำดับสำหรับ Seh1 (384 residues) และ C1HCX1 (976 residues) รวมถึง Checksums เพื่อการยืนยัน โดยไม่ได้ตัดลำดับใด ๆ หรือให้เทมเพลตโครงสร้าง ลิแกนด์ หรือข้อจำกัดอื่น ๆ

ขั้นตอนที่ 2: การทำนายโครงสร้างด้วย OpenFold3

OpenFold3 รับรายการโมเลกุลที่มี msa ต่อสาย (unpaired) และสำหรับ complex จะมี paired_msa Agent ทำการรันสองเงื่อนไขด้วยลำดับ Seh1 เดียวกัน:

• Monomer: (chain A พร้อม MSA ของมัน)
• Heteromer: (chains A และ B พร้อม MSA ของพวกมัน บวกกับ paired_msa)

โดยใช้ผลลัพธ์ mmCIF, ไม่ใช้เทมเพลต และเก็บตัวอย่างที่ส่งคืนทั้งหมด รวมถึงฟิลด์ความมั่นใจที่บริการเปิดเผย

ผลลัพธ์ที่เปิดเผย ได้แก่ confidencescore, complexplddtscore, complexpdescore, ptmscore, iptmscore (พร้อมด้วย format, name, source) runtimemetrics มีอยู่แต่ว่างเปล่า

• iptmscore ของ monomer คือ 0 โดยการออกแบบ และ confidencescore ของ OpenFold3 จะให้น้ำหนักกับ interface เป็นอย่างมาก ซึ่งเป็นเหตุผลว่าทำไม monomer ที่พับตัวได้ดี (pTM 0.82, pLDDT 82) จึงยังมีคะแนน composite ต่ำ ควรพิจารณา confidence_score ภายใน OpenFold3 ไม่ใช่ข้ามโมเดล

ขั้นตอนที่ 3: การทำนายโครงสร้างด้วย Boltz-2

เงื่อนไขสองแบบเดียวกันถูกรันผ่าน Boltz-2 โดยใช้ Chain ID เดิมและนโยบายแบบไม่มีเทมเพลต ความแตกต่างทางสถาปัตยกรรมเพียงอย่างเดียวที่สำคัญคือ: Boltz-2 ไม่มีฟิลด์ pairedmsa แยกต่างหาก มันรับ MSA ต่อสายหนึ่งชุดและจับคู่ภายใน (concatenatemsas ระดับบนสุดเป็นทางเลือก) ดังนั้นแต่ละสายของ Boltz-2 จึงได้รับ A3M ต่อสายของมัน

Boltz-2 สร้างผลลัพธ์ PAE เต็มรูปแบบ (writefullpae=true)

Boltz-2 ส่งคืนชุดความมั่นใจที่หลากหลายกว่า: confidencescores, ptmscores, iptmscores, proteiniptmscores, complexplddtscores, complexiplddtscores, complexpdescores, complexipde_scores พร้อมด้วย arrays ต่อสายและคู่ และเมทริกซ์ PAE/PDE เต็มรูปแบบ (สูงสุด 1360×1360 สำหรับ complex)

ฟิลด์เดียวที่ถูกร้องขอและบริการปล่อยให้ว่างคือข้อมูลเมตาไทม์รัน (runtime_metrics: {})

MSA คือหัวใจสำคัญของการทำนาย

เนื่องจากเวิร์กโฟลว์นี้ยังรันการทำนายแบบ single-sequence (ไม่มี MSA) คุณค่าของขั้นตอนที่ 1 จึงสามารถวัดผลได้โดยตรง สำหรับ heteromer, interface pTM (iPTM) ซึ่งเป็นเมตริกที่รายงานเกี่ยวกับการสัมผัสที่คาดการณ์ระหว่างสองสาย จะลดลงอย่างมากหากไม่มี MSA ในทั้งสองโมเดล:

• เมื่อมี MSA: iPTM สูงถึง 0.85 สำหรับ OpenFold3 และ 0.82 สำหรับ Boltz-2
• เมื่อไม่มี MSA: ลดลงเหลือ 0.14 และ 0.19 ตามลำดับ

การทดสอบความทนทานสองประการสนับสนุนผลลัพธ์นี้:

1. การรันแต่ละเงื่อนไขด้วยงบประมาณการสุ่มตัวอย่างที่มากขึ้น (OpenFold3 diffusion_samples=5; Boltz-2 ห้าตัวอย่างพร้อมการรีไซเคิลหกขั้น และ 200 ขั้นตอนการสุ่มตัวอย่าง) ภาพรวมยังคงเหมือนเดิม interface ที่มี MSA ยังคงสูง และ interface ที่ไม่มี MSA ยังคงลดลง (เหมือนกับค่าตัวอย่างเดียวภายใน 0.01 iPTM) การสุ่มตัวอย่างเพิ่มเติมไม่สามารถทดแทนข้อมูลทางวิวัฒนาการได้
2. ตระกูลโมเดลทั้งสอง (ที่มีสถาปัตยกรรมต่างกัน และสำหรับ Boltz-2 กลไกการจับคู่ MSA ที่แตกต่างกัน) มีคะแนน iPTM อยู่ภายใน 0.03 ซึ่งแสดงถึงความสอดคล้องกันของโมเดล

ผลลัพธ์ของ monomer แสดงให้เห็นถึงความขึ้นอยู่กับ MSA ของแต่ละโมเดล OpenFold3 ต้องการการจัดเรียงแม้แต่จะพับสายเดี่ยว (pLDDT 82 → 36 หากไม่มี) Boltz-2 พับ monomer ได้ค่อนข้างดีจากลำดับเพียงอย่างเดียว (0.79 → 0.73) แต่ก็ยังไม่สามารถวาง interface ได้หากไม่มี MSA ในทั้งสองกรณี ขั้นตอนที่ 1 ถือเป็นมากกว่าแค่ขั้นตอนการประมวลผลล่วงหน้า แต่เป็นรากฐานที่แท้จริงของสมมติฐานเกี่ยวกับ interface

ตรวจสอบโครงสร้างที่เวิร์กโฟลว์สร้างขึ้น

Agent จะตรวจสอบว่าคู่หูที่คาดการณ์ไว้นั้นเปลี่ยนแปลงโครงสร้าง Seh1 ที่ทำนายไว้หรือไม่ สำหรับแต่ละโมเดล จะทำการซ้อนทับ (superpose) Seh1 chain จาก monomer และ heteromer และตรวจสอบบริเวณ WD40 β-propeller

• มุมมอง monomer และ heteromer ใช้ตำแหน่งกล้องเดียวกันหลังจากการจัดเรียงแกนหลักของ Seh1 แสดงให้

ขอบคุณ แหล่งข้อมูล
https://developer.nvidia.com/blog/run-nvidia-bionemo-nim-microservices-for-protein-structure-prediction-in-claude-science/

ทดลอง Qwen3.8-Flash-Next บน NVIDIA GB300 NVL72 เพื่อการเขียนโค้ดแบบ Agentic

การพัฒนาปัญญาประดิษฐ์ (AI) ก้าวหน้าไปอย่างรวดเร็ว โดยเฉพาะในด้านโมเดลภาษาขนาดใหญ่ (LLMs) ที่มีความสามารถในการประมวลผลและสร้างสรรค์ข้อความที่ซับซ้อน ล่าสุด Alibaba ได้ปล่อยโมเดล Qwen3.8-Flash-Next ออกมาให้เหล่านักพัฒนาได้ทดลอง ซึ่งเป็นส่วนหนึ่งของการทดลองก่อนการเปิดตัวสถาปัตยกรรม Qwen4 ที่กำลังจะมาถึง โมเดลนี้มีความโดดเด่นด้วยสถาปัตยกรรมแบบ Multimodal Mixture-of-Experts (MoE) ที่เปิดโอกาสให้นักพัฒนาได้ทดลองและประเมินประสิทธิภาพ

ทำความรู้จัก Qwen3.8-Flash-Next: พลังของ MoE และ Long Context 🧐

Qwen3.8-Flash-Next เป็นโมเดล MoE ที่มีขนาดใหญ่ถึง 125 พันล้านพารามิเตอร์ โดยมีการเปิดใช้งาน 6 พันล้านพารามิเตอร์ต่อโทเค็น มีจุดเด่นที่สำคัญคือ Context Window แบบ Native ที่ยาวถึง 262,144 โทเค็น ซึ่งสามารถขยายได้สูงสุดถึง 1 ล้านโทเค็นด้วยเทคนิค YaRN สิ่งนี้ทำให้โมเดลสามารถประมวลผลข้อมูลที่มีความยาวมหาศาลได้อย่างมีประสิทธิภาพ เหมาะสำหรับงานที่ต้องการความเข้าใจบริบทที่ลึกซึ้ง

สถาปัตยกรรมของโมเดลนี้ผสมผสานระหว่าง Gated DeltaNet (GDN) และ Qwen Sparse Attention (QSA) โดย 3 ใน 4 เลเยอร์จะใช้ GDN ในการบีบอัดบริบทในอดีตให้กลายเป็นสถานะแบบวนซ้ำ (recurrent state) ที่มีขนาดคงที่ ส่วนเลเยอร์ที่เหลือจะใช้ QSA เพื่อการดึงข้อมูลที่แม่นยำจากบริบททั้งหมด

ประสิทธิภาพที่เหนือกว่า: QSA และการทำงานบน NVIDIA GB300 NVL72 🚀

จากการทดสอบของ Alibaba ชี้ให้เห็นว่า QSA สามารถเพิ่มประสิทธิภาพในการทำงานกับบริบท 1 ล้านโทเค็นได้อย่างน่าทึ่ง เมื่อเทียบกับการคำนวณแบบ Full Attention แล้ว QSA ให้ความเร็วในการ Pre-fill สูงสุดถึง 7.6 เท่า และความเร็วในการถอดรหัส (Decoding) สูงสุด 4.9 เท่า นอกจากนี้ ยังมี Throughput ในการ Pre-fill สูงกว่า Qwen3.7-Plus ถึง 8.6 เท่า ที่บริบท 1 ล้านโทเค็น โดยมีอัตราการ Hit Rate ของ Prefix-Cache สูงถึง 90%

เมื่อนำ Qwen3.8-Flash-Next มาทำงานบน NVIDIA GB300 NVL72 ซึ่งเป็นสถาปัตยกรรมแบบ Rack-Scale ที่รวม GPU NVIDIA Blackwell Ultra ถึง 72 ตัวเข้าด้วยกัน ทำให้เกิดการสื่อสารแบบ All-to-All ที่รวดเร็วถึง 130 TB/s ส่งผลให้ประสิทธิภาพสูงขึ้นอย่างมาก โดยสามารถประมวลผลได้ มากกว่า 16,000 โทเค็นต่อวินาทีต่อ GPU และ มากกว่า 200 โทเค็นต่อวินาทีต่อผู้ใช้ ซึ่งเหมาะอย่างยิ่งสำหรับการพัฒนาแอปพลิเคชัน Agentic Coding ที่ต้องการ Throughput สูงและ Latency ต่ำ

การปรับแต่งและใช้งาน: เครื่องมือจาก NVIDIA 🛠️

นักพัฒนาสามารถปรับแต่ง (Fine-tune) โมเดล Qwen3.8-Flash-Next ให้เหมาะกับงานเฉพาะทางได้ง่ายขึ้นด้วย NVIDIA NeMo AutoModel ซึ่งเป็นไลบรารี PyTorch-native ที่รองรับการ Fine-tune โดยตรงจาก Checkpoint ของ Hugging Face ไม่จำเป็นต้องแปลงโมเดล และรองรับทั้งการ Fine-tune แบบเต็มรูปแบบ (Full SFT) หรือแบบประหยัดหน่วยความจำ (LoRA) นอกจากนี้ยังสามารถทำการ Reinforcement Learning (RL) เพิ่มเติมได้ด้วย NVIDIA NeMo RL recipes

สำหรับการนำไปใช้งาน (Inference) NVIDIA มีการสนับสนุน Inference Engine หลากหลายรูปแบบ เช่น SGLang, vLLM, และ TokenSpeed ซึ่งมีสูตร (Recipes) แบบ Open-source สำหรับการ Deploy บนแพลตฟอร์มที่เร่งความเร็วด้วย NVIDIA

เริ่มต้นทดลอง Qwen3.8-Flash-Next ได้ทันที! ✨

• ทดลองใช้งานโมเดล: สามารถลองเล่นโมเดลได้ผ่าน QwenCloud
• ดาวน์โหลดโมเดล: ดาวน์โหลด Model Weights ได้จาก Hugging Face หรือ ModelScope
• สำรวจการ Fine-tune: ศึกษา NVIDIA NeMo AutoModel เพื่อปรับแต่งโมเดลให้เข้ากับ Use Case เฉพาะของคุณ

การมาถึงของ Qwen3.8-Flash-Next พร้อมกับการสนับสนุนจาก NVIDIA GB300 NVL72 และเครื่องมือต่างๆ เป็นก้าวสำคัญที่ช่วยให้นักพัฒนาสามารถสร้างสรรค์แอปพลิเคชัน AI ที่ซับซ้อนและมีประสิทธิภาพสูงขึ้นได้อย่างที่ไม่เคยมีมาก่อน โดยเฉพาะในสายงาน Agentic Coding ที่ต้องการการประมวลผลบริบทที่ยาวนานและแม่นยำ

#Qwen3 #NVIDIA #AI #LLM #AgenticCoding

ขอบคุณ แหล่งข้อมูล
https://developer.nvidia.com/blog/experiment-with-qwen3-8-flash-next-on-nvidia-gb300-nvl72-for-agentic-coding/

ฝึกฝน AI เพื่อนำทางหุ่นยนต์ข้ามรูปแบบด้วยนโยบายเดียว: COMPASS 🤖

การนำทางคือหัวใจสำคัญที่ทำให้หุ่นยนต์สามารถเปลี่ยนข้อมูลจากการรับรู้และคำสั่งการเคลื่อนไหวให้กลายเป็นการทำงานที่เป็นอิสระได้อย่างมีเป้าหมาย ต่างจากการเคลื่อนที่ (locomotion) ที่เน้นการเคลื่อนไหวที่มั่นคง การนำทาง (navigation) จำเป็นต้องมีการระบุตำแหน่งหุ่นยนต์อย่างต่อเนื่อง ตีความสภาพแวดล้อมที่เปลี่ยนแปลง เลือกเส้นทาง และหลีกเลี่ยงสิ่งกีดขวางเพื่อให้บรรลุเป้าหมายได้อย่างปลอดภัย

การนำความสามารถนี้ไปใช้กับหุ่นยนต์หรือสภาพแวดล้อมใหม่ๆ มักต้องใช้ข้อมูลใหม่ ชุดจำลอง อินเทอร์เฟซหุ่นยนต์ การฝึกฝน การวินิจฉัย และการประเมิน ซึ่งการทำงานซ้ำๆ เหล่านี้สำหรับทุกคู่หุ่นยนต์-สภาพแวดล้อมนั้นมีค่าใช้จ่ายสูงและยากต่อการทำซ้ำ

COMPASS: กรอบการทำงานเพื่อการนำทางที่ปรับขนาดได้

COMPASS (Cross-Embodiment Mobility Policy via Residual RL and Skill Synthesis) คือกรอบการทำงานแบบรวมศูนย์ที่ช่วยให้การเคลื่อนที่ข้ามรูปแบบ (cross-embodiment mobility) สามารถปรับขนาดได้ โดยใช้ประโยชน์จากการสาธิตของผู้เชี่ยวชาญจากรูปแบบเดียว COMPASS ใช้พฤติกรรมการนำทางจากนโยบาย NVIDIA X-Mobility ที่ได้รับการฝึกฝนล่วงหน้า และทำการฝึกฝน "ผู้เชี่ยวชาญเฉพาะส่วน" (residual specialist) ซึ่งเป็นนโยบายการเรียนรู้แบบเสริมแรง (reinforcement learning: RL) ที่ปรับแก้การกระทำพื้นฐานสำหรับหุ่นยนต์และสภาพแวดล้อมที่เลือก แทนที่จะต้องเรียนรู้การนำทางใหม่ทั้งหมด

การทำงานแบบอัตโนมัติด้วย AI Agent

COMPASS ใช้เวิร์กโฟลว์ที่ขับเคลื่อนโดย AI Agent พร้อมการอนุมัติจากมนุษย์เพื่อจัดการขั้นตอนต่างๆ โดยอัตโนมัติ ตั้งแต่การตรวจสอบสภาพแวดล้อม การเตรียมฉาก การทดสอบเบื้องต้น (smoke testing) การฝึกฝนเฉพาะส่วน การประเมินจุดตรวจสอบ (checkpoint) ไปจนถึงการจัดแพ็กเกจสำหรับการใช้งานจริง

การใช้งาน COMPASS: กรณีศึกษาหุ่นยนต์ Boston Dynamics Spot

ในบทความนี้ เราจะใช้หุ่นยนต์สี่ขา Boston Dynamics Spot เป็นหุ่นยนต์อ้างอิง โดยจะนำเวิร์กโฟลว์ COMPASS ที่ขับเคลื่อนด้วย AI Agent มาใช้กับสภาพแวดล้อม 3 รูปแบบ:

1. คลังสินค้าในตัว (Built-in Warehouse): เป็นเส้นทางที่ทำซ้ำได้ง่ายที่สุดสำหรับการตรวจสอบการติดตั้งเบื้องต้น
2. ฉาก SAGE-10K ที่สร้างขึ้น: ขยายขอบเขตไปยังฉากภายในอาคารที่สร้างขึ้นโดยอัตโนมัติ
3. สภาพแวดล้อมที่บันทึกด้วย NVIDIA Omniverse NuRec: รองรับการนำเข้าสภาพแวดล้อมจริงที่ถูกจับภาพและสร้างใหม่

ภาพรวมเวิร์กโฟลว์การฝึกฝน

เวิร์กโฟลว์การฝึกฝนจะเริ่มต้นด้วยการเรียกใช้วงจร RL แบบเฉพาะส่วน โดยจะมีการบันทึกจุดตรวจสอบเป็นระยะๆ ติดตามส่วนประกอบของรางวัล (reward components) และตัวชี้วัดความปลอดภัย พร้อมทั้งเก็บหลักฐานสำหรับการประเมินภายใต้เงื่อนไขที่ตรงกัน

การประเมินผล

การประเมินจะเปรียบเทียบนโยบาย X-Mobility พื้นฐานกับนโยบายเฉพาะส่วนที่ได้จากการฝึกฝน ภายใต้เงื่อนไขการตั้งค่าเริ่มต้น (seeds) เป้าหมาย (goals) และการทดลอง (rollout) ที่เหมือนกัน โดยใช้ตัวชี้วัดมาตรฐานของ COMPASS เช่น อัตราการบรรลุเป้าหมาย (goal-reached rate) อัตราการล้ม (fall-down rate) และเวลาเดินทาง (travel time)

การใช้งานจริง (Runtime)

เมื่อนโยบายถูกส่งออก (exported) มันจะรับข้อมูลอินพุตจากกล้อง RGB, ข้อมูลการเคลื่อนที่ (odometry) และจุดเป้าหมาย เพื่อส่งคำสั่งความเร็วไปยัง /cmd_vel โดยสามารถเลือกใช้ NVIDIA cuVSLAM เพื่อให้ข้อมูลการเคลื่อนที่ขณะใช้งานได้ หากหุ่นยนต์ไม่มีระบบประมาณค่าสถานะ (state estimation) ที่เข้ากันได้

การเริ่มต้นใช้งาน COMPASS

1. ติดตั้ง: โคลน Repository ของ COMPASS และทำตามคู่มือ Quick Start เพื่อตั้งค่าสภาพแวดล้อมอ้างอิง
2. ดาวน์โหลด: ยอมรับข้อกำหนดของโมเดลที่ต้องได้รับการอนุมัติ และดาวน์โหลดชุดจำลอง COMPASS รวมถึงจุดตรวจสอบ X-Mobility จาก Hugging Face
3. เรียกใช้งาน: เริ่มต้นเวิร์กโฟลว์ RL แบบเฉพาะส่วนด้วยหุ่นยนต์ที่รองรับและฉากที่ติดตั้งมาพร้อมระบบ โดยต้องได้รับการอนุมัติหลังจากการทดสอบเบื้องต้น

การเตรียมฉากนำทาง 🗺️

COMPASS รองรับการเตรียมฉากนำทาง 3 รูปแบบหลัก:

เส้นทางที่ 1: ใช้คลังสินค้าในตัว

เหมาะสำหรับเริ่มต้นเพื่อตรวจสอบความถูกต้องของการติดตั้ง เนื่องจากหุ่นยนต์ ฉาก และแผนที่ครอบครองพื้นที่ (occupancy map) ถูกลงทะเบียนไว้แล้ว

เส้นทางที่ 2: ใช้ฉาก SAGE-10K

SAGE-10K เป็นชุดข้อมูลฉากภายในอาคารที่สร้างขึ้นกว่า 10,000 ฉาก ช่วยให้สามารถทดสอบในสภาพแวดล้อมที่หลากหลายขึ้น เส้นทางนี้มีจุดอนุมัติจากมนุษย์ 2 จุด คือ การตรวจสอบฉาก USD ที่แปลงแล้ว และการอนุมัติภาพตัวอย่างฉากก่อนการฝึกฝนเต็มรูปแบบ

เส้นทางที่ 3: นำเข้าสภาพแวดล้อมที่บันทึกด้วย NuRec

สำหรับกรณีที่ต้องการปรับแต่งและประเมิน COMPASS ในสภาพแวดล้อมจริงที่ถูกสร้างขึ้นใหม่ด้วย Omniverse NuRec ซึ่งจะแปลงข้อมูลภาพ RGB แบบสเตอริโอให้เป็นฉากที่พร้อมใช้งานใน Isaac Sim

การตรวจสอบการทำงานร่วมกันระหว่างหุ่นยนต์และฉาก ✅

ก่อนที่จะเริ่มการฝึกฝน ควรทำการทดสอบเบื้องต้น (one-environment preview) เพื่อให้แน่ใจว่า Isaac Sim เริ่มทำงานได้ ฉากโหลดถูกต้อง หุ่นยนต์ Spot ถูกวางในตำแหน่งที่เหมาะสม มีข้อมูลภาพจากกล้อง และหุ่นยนต์ตอบสนองต่อคำสั่งจากนโยบายโดยไม่มีข้อผิดพลาด

การฝึกฝนผู้เชี่ยวชาญเฉพาะส่วน 🛠️

เมื่อการทดสอบเบื้องต้นได้รับการอนุมัติแล้ว AI Agent จะเริ่มกระบวนการฝึกฝน RL แบบเฉพาะส่วน โดยใช้หุ่นยนต์และฉากที่เลือก ระบบจะคอยติดตามผลลัพธ์ บันทึกจุดตรวจสอบ และเก็บหลักฐานที่จำเป็นสำหรับการประเมิน

ข้อกำหนดระบบ

• ระบบ Ubuntu 22.04 หรือ 24.04 ที่มี RAM อย่างน้อย 32 GB
• การ์ดจอ NVIDIA RTX ที่มี VRAM อย่างน้อย 16 GB และไดรเวอร์ Linux 580.95.05 (เวอร์ชันที่ทดสอบกับ Isaac Sim 6.0)
• Docker Engine 24 หรือใหม่กว่า พร้อม NVIDIA Container Toolkit
• บัญชี Hugging Face และโทเค็นสำหรับอ่าน (read token) ที่เข้าถึง Repository ที่ต้องได้รับการอนุมัติของ nvidia/COMPASS และ nvidia/X-Mobility
• NVIDIA Isaac Lab 3.0 พร้อม NVIDIA Isaac Sim 6.0

คำถามที่พบบ่อย

COMPASS แตกต่างจากนโยบายนำทางทั่วไปอย่างไร?

COMPASS ใช้ประโยชน์จากนโยบายที่ฝึกฝนไว้แล้ว (X-Mobility) และฝึกฝน "ผู้เชี่ยวชาญเฉพาะส่วน" เพื่อปรับแก้การกระทำสำหรับหุ่นยนต์และสภาพแวดล้อมใหม่ๆ แทนที่จะเรียนรู้ใหม่ทั้งหมด ทำให้ประหยัดเวลาและทรัพยากร

AI Agent ทำงานอย่างไรในเวิร์กโฟลว์นี้?

AI Agent จะช่วยจัดการขั้นตอนต่างๆ เช่น การตรวจสอบความถูกต้องของส่วนประกอบ การเตรียมฉาก การทดสอบ การเปิดใช้งานการฝึกฝน และการวินิจฉัยปัญหา โดยมีจุดอนุมัติจากมนุษย์เพื่อควบคุมกระบวนการ

สภาพแวดล้อมที่บันทึกด้วย NuRec มีประโยชน์อย่างไร?

การใช้ NuRec ช่วยให้สามารถฝึกฝนและประเมิน COMPASS ในสภาพแวดล้อมจริงที่ถูกสร้างขึ้นใหม่จากข้อมูลที่บันทึก ทำให้การนำไปใช้งานมีความแม่นยำมากขึ้น

การทดสอบเบื้องต้น (Smoke Test) สำคัญอย่างไร?

การทดสอบนี้ช่วยยืนยันว่าการตั้งค่าพื้นฐานระหว่างหุ่นยนต์ ฉาก และระบบรับข้อมูลทำงานได้อย่างถูกต้องก่อนที่จะเริ่มกระบวนการฝึกฝนที่ใช้เวลานาน

#AI #RobotNavigation #ReinforcementLearning #NVIDIA

ขอบคุณ แหล่งข้อมูล
https://developer.nvidia.com/blog/how-to-train-a-cross-embodiment-robot-navigation-policy-with-ai-agents/

NVIDIA NVLink Fusion: ยกระดับโครงสร้างพื้นฐาน AI ด้วย NVHBM สู่ยุคใหม่

ในโลกของปัญญาประดิษฐ์ (AI) ที่มีการพัฒนาอย่างไม่หยุดยั้ง โมเดล AI ที่ใหญ่ขึ้นและมีความซับซ้อนในการประมวลผลสูงขึ้นกลายเป็นเรื่องปกติ เหล่าผู้ให้บริการคลาวด์รายใหญ่ (Hyperscalers) และบริษัทที่เน้น AI เป็นหลัก (AI-native companies) กำลังเผชิญกับความต้องการพลังประมวลผลที่สูงลิ่ว จึงต้องมองหาโซลูชันใหม่ๆ เพื่อตอบโจทย์ความท้าทายนี้ หนึ่งในนั้นคือการพัฒนาตัวเร่งความเร็ว AI แบบกำหนดเอง (Custom AI Accelerators หรือ XPUs) ซึ่งจำเป็นต้องอาศัยหน่วยความจำความเร็วสูง (High-Bandwidth Memory - HBM) ที่เพียงพอ พื้นที่ซิลิคอนสำหรับการประมวลผลที่มากขึ้น การจ่ายไฟที่มีประสิทธิภาพ และห่วงโซ่อุปทานที่แข็งแกร่ง รวมถึงสถาปัตยกรรมระดับแร็ค (Rack-scale architecture) สำหรับการติดตั้งในศูนย์ข้อมูล

NVIDIA NVLink Fusion คือเทคโนโลยีและ IP ที่เป็นตัวเชื่อมต่อสำคัญ ซึ่งช่วยให้ผู้ให้บริการคลาวด์และบริษัท AI สามารถนำ XPUs และ CPUs ที่ออกแบบเอง มาผสานรวมเข้ากับแพลตฟอร์ม AI ของ NVIDIA ได้อย่างง่ายดาย โดยใช้ประโยชน์จากสแต็กเทคโนโลยี Scale-up และ Scale-out รวมถึงสถาปัตยกรรม MGX ระดับแร็ค เพื่อลดความซับซ้อนในการพัฒนาและติดตั้ง เพิ่มประสิทธิภาพ และเร่งเวลาในการนำโซลูชัน AI ออกสู่ตลาด

NVHBM: หน่วยความจำประสิทธิภาพสูงเพื่อ AI

ภายในระดับแพ็คเกจ (Package level) นั้น NVHBM (NVIDIA High Bandwidth Memory) เข้ามาเสริมสถาปัตยกรรมแบบรวมศูนย์นี้ NVHBM เป็นเทคโนโลยีฐานหน่วยความจำ HBM แบบกำหนดเอง ที่ได้รับการออกแบบและตรวจสอบร่วมกับผู้ผลิตหน่วยความจำชั้นนำ เพื่อเพิ่มแบนด์วิดท์หน่วยความจำ (Memory bandwidth) ให้สูงขึ้น ประหยัดพื้นที่ และลดการใช้พลังงาน ซึ่งการปรับปรุงเหล่านี้จะช่วยให้ XPUs แบบกำหนดเองสามารถรองรับโมเดลที่ใหญ่ขึ้น อ่านข้อมูล KV cache ได้เร็วขึ้น และปรับปรุงประสิทธิภาพทั้งการฝึก (Training) และการอนุมาน (Inference) ขนาดใหญ่

ทำไมแบนด์วิดท์, พื้นที่ Die และพลังงาน จึงเป็นหัวใจของการออกแบบตัวเร่งความเร็ว AI

การฝึก (Training), การอนุมาน (Inference) และเวิร์กโหลด AI แบบ Agentic ต้องการการเข้าถึงน้ำหนักโมเดล (Model weights), KV cache และข้อมูล Activation อย่างต่อเนื่อง เมื่อระบบ AI ขยายขนาดจากตัวเร่งความเร็วเดี่ยวๆ ไปสู่โดเมนประมวลผลระดับแร็ค แพ็คเกจของตัวเร่งความเร็วต้องสมดุลระหว่าง Logic การประมวลผล, การจ่ายไฟ, การออกแบบระบายความร้อน และหน่วยความจำแบนด์วิดท์สูง

HBM ช่วยให้แบนด์วิดท์หน่วยความจำที่จำเป็นอยู่ใกล้กับตัวเร่งความเร็ว แต่การรับรองเทคโนโลยีหน่วยความจำชั้นนำ การรวมแพ็คเกจ และการตรวจสอบ อาจกลายเป็นคอขวดสำหรับโปรแกรมตัวเร่งความเร็วแบบกำหนดเอง ด้วย NVLink Fusion ลูกค้าจะสามารถเข้าถึงฐาน Die ของ NVHBM ที่ได้รับการตรวจสอบแล้วกับผู้ผลิตหน่วยความจำชั้นนำ ซึ่งช่วยลดปัญหาคอขวดในการรวมระบบและการรับรอง

คอขวดแบนด์วิดท์หน่วยความจำในตัวเร่งความเร็ว AI ยุคใหม่

ประสิทธิภาพของตัวเร่งความเร็ว AI ขึ้นอยู่กับความสม่ำเสมอในการส่งข้อมูลไปยังเอนจิ้นประมวลผล ความเร็ว HBM ที่สูงขึ้นจะเพิ่มแบนด์วิดท์หน่วยความจำที่ใช้งานได้ภายในงบประมาณแพ็คเกจที่กำหนด ปรับปรุงความสามารถในการรองรับส่วนที่ต้องการแบนด์วิดท์สูงของการฝึกและการอนุมาน NVHBM สามารถให้แบนด์วิดท์หน่วยความจำ สูงขึ้นถึง 30% ต่อสแต็ก เมื่อเทียบกับ HBM4e มาตรฐาน สำหรับเวิร์กโหลด AI ที่มีข้อจำกัดด้านหน่วยความจำหรือบางส่วนของหน่วยความจำ นั่นหมายถึงการใช้ประโยชน์จากตัวเร่งความเร็วได้ดีขึ้นและมี Throughput สูงขึ้น ซึ่งสามารถเพิ่ม Throughput ต่อผู้ใช้ในระหว่างการอนุมานโมเดลขนาดใหญ่ได้ โดยการย้ายข้อมูลระหว่าง HBM และคอร์ประมวลผลได้เร็วขึ้น เพื่อให้เอนจิ้นประมวลผลทำงานได้อย่างต่อเนื่อง

ในขณะที่ NVHBM เพิ่มแบนด์วิดท์หน่วยความจำภายในตัวเร่งความเร็วแต่ละตัว NVLink Fusion จะเชื่อมต่อตัวเร่งความเร็วเข้าด้วยกันในโดเมนที่ใหญ่ขึ้น เพื่อให้เวิร์กโหลดสามารถใช้ประโยชน์จากการประมวลผลและหน่วยความจำแบบกระจายได้อย่างมีประสิทธิภาพมากขึ้น

โดเมน Scale-up นี้มีความสำคัญอย่างยิ่งเมื่อใช้เทคนิคการกำหนดเส้นทางขั้นสูง เช่น Expert Parallelism (EP) หรือ WideEP ในสถานการณ์เหล่านี้ ผู้เชี่ยวชาญ (Experts) ที่แตกต่างกันจะอยู่บน GPU คนละตัว และต้องการการซิงโครไนซ์ความเร็วสูงที่ราบรื่นทั่วทั้งแร็ค NVIDIA NVLink ซึ่งเป็นเครือข่าย Scale-up สำหรับโรงงาน AI จะถ่ายโอน Activations และ Hidden States ระหว่างผู้เชี่ยวชาญ และช่วยซิงโครไนซ์แคชแบบกระจายทั่วทั้งเครือข่าย Scale-up NVHBM ช่วยลดปัญหาข้อมูลขาดแคลน (Data starvation) โดยการรักษาเอนจิ้นประมวลผลในเครื่องให้ได้รับข้อมูลอย่างสม่ำเสมอ

พื้นที่แพ็คเกจที่มากขึ้น เพิ่มความยืดหยุ่น

สำหรับซิลิคอน AI แบบกำหนดเอง ทุกตารางมิลลิเมตรมีความสำคัญ นักออกแบบตัวเร่งความเร็วต้องตัดสินใจว่าจะจัดสรรพื้นที่เท่าใดให้กับเอนจิ้นเมทริกซ์ (Matrix engines), หน่วยเวกเตอร์ (Vector units), SRAM บนชิป (On-chip SRAM), ลำดับชั้นแคช (Cache hierarchy), Logic ควบคุม (Control logic), อินเทอร์เฟซหน่วยความจำ (Memory interfaces), เครือข่ายบนชิป (Network-on-chip) และการเชื่อมต่อ Scale-up การใช้งานหน่วยความจำแบบกำหนดเองสามารถช่วยลดภาระการออกแบบและแพ็คเกจที่เกี่ยวข้องกับการเข้าถึง HBM ทำให้มีพื้นที่ว่างสำหรับความสามารถเฉพาะของเวิร์กโหลด

เมื่อเวิร์กโหลด AI มีความหลากหลายมากขึ้น พื้นที่ Die เพิ่มเติมนี้จะช่วยให้ผู้ให้บริการคลาวด์มีความยืดหยุ่นมากขึ้นในการปรับแต่ง XPUs สำหรับการให้บริการ Inference, ระบบแนะนำ (Recommendation systems), ไปป์ไลน์แบบ Multimodal หรือเวิร์กโหลดการฝึกภายใน การลดพื้นที่ที่จำเป็นสำหรับอินเทอร์เฟซหน่วยความจำ NVHBM ช่วยให้นักพัฒนาสามารถจัดสรรพื้นที่ชิปส่วนใหญ่ให้กับประสิทธิภาพได้โดยตรง

การประหยัดพื้นที่ส่วนใหญ่เกิดจากการออกแบบ Physical Memory Interface (PHY) ใหม่ HBM มาตรฐานใช้การเชื่อมต่ออินเทอร์เฟซที่กว้างขึ้น ซึ่งเพิ่มพื้นที่แพ็คเกจโดยรวม NVHBM ใช้ฐาน Die แบบกำหนดเองที่ปรับให้เหมาะสมกับประสิทธิภาพ โดยมีข้อกำหนดพื้นที่ I/O ที่ลดลง ซึ่งทำได้โดยการย้าย Memory Controller เข้าไปใน 3D HBM stack และรวม PHY แบบกำหนดเอง

เมื่อเทียบกับมาตรฐาน JEDEC HBM4e การออกแบบนี้จะ ลดพื้นที่ PHY และส่วนสนับสนุนลงได้ถึง 67% อินเทอร์เฟซที่แคบลงยังช่วยให้การ Routing Interposer ง่ายขึ้น ทำให้มีพื้นที่ซิลิคอนที่ใช้งานได้เพิ่มขึ้นถึง 80% ทั่วทั้ง Layout

ดังที่แสดงในรูปภาพ การลดขนาดการเชื่อมต่ออินเทอร์เฟซหน่วยความจำช่วยให้ AI Compute Die ตรงกลางขยายเข้าไปในพื้นที่ที่ว่างขึ้น การกู้คืนพื้นที่นี้ทำให้มี พื้นที่ซิลิคอนหลักเพิ่มขึ้นถึง 30% สำหรับการประมวลผลหรือคุณสมบัติอื่นๆ พื้นที่ซิลิคอนเพิ่มเติมช่วยให้นักออกแบบ XPU สามารถเพิ่มความสามารถภายในพื้นที่แพ็คเกจที่กำหนดได้

การประหยัดพลังงานเพื่อการขยายขนาดอย่างมีประสิทธิภาพ

พลังงานเป็นหนึ่งในข้อจำกัดที่ยากที่สุดในโครงสร้างพื้นฐาน AI ยุคใหม่ พลังงาน HBM มีส่วนช่วยในงบประมาณพลังงานของตัวเร่งความเร็ว, การออกแบบระบายความร้อนของแพ็คเกจ, ขอบเขตพลังงานของแร็ค และแผนการระบายความร้อนของศูนย์ข้อมูล NVHBM ช่วยให้ การใช้พลังงาน HBM ลดลง 15% เมื่อเทียบกับ HBM4e มาตรฐาน ซึ่งสร้าง Headroom ด้านพลังงานและความร้อนเพิ่มเติมสำหรับการประมวลผล

การประหยัดพลังงานมีความสำคัญในหลายระดับ ที่ระดับ XPU การใช้พลังงาน HBM ที่ต่ำลงสามารถปรับปรุงประสิทธิภาพต่อวัตต์ (Performance per watt) และสร้างพื้นที่สำหรับการประมวลผลที่มากขึ้น หรือการใช้งานที่สูงขึ้นอย่างต่อเนื่อง ที่ระดับแร็ค สามารถช่วยลดแรงกดดันต่อระบบจ่ายไฟและระบบระบายความร้อน ที่ระดับโรงงาน AI การลดพลังงานของระบบหน่วยความจำเพียงเล็กน้อย เมื่อรวมกันในตัวเร่งความเร็วหลายพันตัว สามารถสร้างผลกระทบได้อย่างมาก เมื่อรวมกันทั่วทั้งศูนย์ข้อมูล 1 กิกะวัตต์ ที่ใช้ XPUs ขนาด 2,000 วัตต์ การประหยัดพลังงานสามารถรองรับ XPUs เพิ่มเติมได้ถึง 15,000 ตัว ใน Headroom ของพลังประมวลผล

ประโยชน์นี้มีความสำคัญอย่างยิ่งสำหรับการอนุมานโมเดลขนาดใหญ่ XPUs ต้องอ่านน้ำหนักโมเดลและข้อมูล KV-cache ซ้ำๆ ในขณะที่ให้บริการผู้ใช้ด้วย Latency ต่ำและ Throughput สูง การลดพลังงานที่ใช้ในการย้ายข้อมูลดังกล่าว สามารถช่วยรองรับการอนุมานที่เร็วขึ้นสำหรับโมเดลขนาดใหญ่, ขนาด Batch ที่ใหญ่ขึ้น และการใช้พลังงานที่ติดตั้งได้อย่างมีประสิทธิภาพมากขึ้น

การรวม NVLink Fusion กับ NVHBM ในระดับแร็ค

NVHBM ช่วยเพิ่มประสิทธิภาพและประสิทธิภาพของ XPU ในระดับชิป NVLink Fusion ช่วยให้ผู้ให้บริการคลาวด์และบริษัท AI สามารถเชื่อมต่อ XPU ของตนเข้ากับส่วนที่เหลือของแพลตฟอร์ม AI ของ NVIDIA ด้วยการรวมการเพิ่มแบนด์วิดท์หน่วยความจำ 30%, พื้นที่ Die เพิ่มขึ้น 25% และการประหยัดพลังงาน HBM 15% การปรับปรุงสถาปัตยกรรมที่ออกแบบร่วมกันเหล่านี้ ส่งผลให้ ประสิทธิภาพโดยรวมแบบ End-to-end ต่อ XPU เพิ่มขึ้นถึง 30%

การเชื่อมต่อนี้ทำได้ผ่าน NVLink Fusion chiplet ซึ่งเป็นสะพานเชื่อมระหว่าง XPUs แบบกำหนดเองและ NVLink fabric เชื่อมต่อ XPUs ทั้งหมดในแร็คให้เป็นโดเมน Scale-up เดียว NVLink ซึ่งอยู่ในรุ่นที่หกแล้ว เป็นเครือข่าย Scale-up ที่สร้างขึ้นโดยเฉพาะสำหรับโรงงาน AI เพียงแห่งเดียว ที่นำเสนอประสิทธิภาพชั้นนำและความทนทานอัจฉริยะ ส่วนต้นน้ำ (Upstream) XPUs สามารถเชื่อมต่อกับ CPUs ผ่าน NVLink-C2C ได้

ผู้ที่นำ NVLink Fusion ไปใช้ สามารถรวม XPUs และ CPUs แบบกำหนดเองเข้ากับสแต็กเทคโนโลยี Scale-up และ Scale-out ของ NVIDIA และ Ecosystem เพื่อลดความซับซ้อนในการพัฒนาและติดตั้ง เพิ่มประสิทธิภาพ และเร่งเวลาในการนำโรงงาน AI แบบกึ่งกำหนดเองออกสู่ตลาด และด้วยการสร้างมาตรฐานบนสถาปัตยกรรมแบบรวมศูนย์เดียว NVLink Fusion ช่วยให้การดำเนินงานทั่วทั้งศูนย์ข้อมูลง่ายขึ้น เปิดใช้งานการจัดสรรความจุของศูนย์ข้อมูลได้อย่างยืดหยุ่น และช่วยให้ XPUs AI แบบกำหนดเองสามารถผสานรวมกับ GPUs สำหรับการประมวลผลแบบ Heterogeneous ได้

ระยะต่อไปของซิลิคอน AI แบบกำหนดเอง

NVLink Fusion มอบรากฐาน Scale-up ที่เป็นมาตรฐานสำหรับ GPUs, XPUs และ CPUs แบบกำหนดเอง, เครือข่าย และซอฟต์แวร์ระดับแร็ค NVHBM เสริมรากฐานนั้นด้วยประสิทธิภาพหน่วยความจำที่สูงขึ้น, ความหนาแน่นของการประมวลผล, ประสิทธิภาพพลังงาน HBM และความยืดหยุ่นของห่วงโซ่อุปทานสำหรับตัวเร่งความเร็วรุ่นต่อไป เทคโนโลยีเหล่านี้ช่วยให้พันธมิตรมีเส้นทางที่ตรงยิ่งขึ้นจากการออกแบบตัวเร่งความเร็ว AI แบบกำหนดเอง ไปสู่การติดตั้งระดับแร็คและการผลิตในปริมาณมาก

เรียนรู้เพิ่มเติมเกี่ยวกับ NVLink Fusion และการนำ NVHBM ไปใช้ในอุตสาหกรรม

#NVIDIA #NVLinkFusion #NVHBM #AI #Infrastructure #Technology

ขอบคุณ แหล่งข้อมูล
https://developer.nvidia.com/blog/nvidia-nvlink-fusion-brings-nvhbm-to-next-generation-ai-infrastructure/

ทดลองโมเดล Qwen3.8-Flash-Next 176B บน NVIDIA GB300 NVL72 สำหรับ Agentic Coding

นักพัฒนาที่สนใจด้าน AI กำลังจะได้สัมผัสกับนวัตกรรมใหม่จาก Alibaba ที่ได้ปล่อยโมเดล Qwen3.8-Flash-Next 176B ซึ่งเป็นส่วนหนึ่งของการทดลองก่อนเปิดตัวสถาปัตยกรรม Qwen4 ในอนาคต โมเดลนี้เป็นแบบ Multimodal Mixture-of-Experts (MoE) ที่มาพร้อมความสามารถอันน่าทึ่งในการประมวลผลบริบทขนาดยาว (Long Context) ด้วยสถาปัตยกรรมแบบผสมผสานระหว่าง Gated DeltaNet (GDN) และ Qwen Sparse Attention (QSA) ซึ่งออกแบบมาเพื่อแก้ไขปัญหาคอขวดในการอนุมาน (Inference) เมื่อต้องจัดการกับข้อมูลที่มีความยาวมากๆ

สถาปัตยกรรมที่ก้าวล้ำเพื่อการจัดการบริบทขนาดยาว 🚀

Qwen3.8-Flash-Next ถูกพัฒนาขึ้นเพื่อรองรับแอปพลิเคชันที่ต้องการปริมาณข้อมูลสูงและเน้นการประมวลผลบริบทที่ซับซ้อน เช่น Agentic Coding, การประมวลผลเอกสาร, และเวิร์กโฟลว์ที่ขับเคลื่อนด้วยเครื่องมือ (Tool-driven workflows) ปัญหาหลักที่พบเมื่อบริบทมีความยาวมากขึ้นคือการใช้ทรัพยากรในการคำนวณ Attention และหน่วยความจำ KV Cache ที่สูงมาก โมเดลนี้แก้ไขปัญหานี้ด้วยสถาปัตยกรรมแบบผสมผสาน:

• Gated DeltaNet (GDN): ใน 3 ใน 4 ของเลเยอร์ จะใช้ GDN ในการบีบอัดบริบทในอดีตอย่างต่อเนื่องให้อยู่ในรูปแบบของสถานะที่วนซ้ำ (Recurrent State) ที่มีขนาดคงที่ ทำให้ไม่ต้องกังวลเรื่อง KV Cache ที่จะเพิ่มขึ้นตามความยาวของลำดับข้อมูล
• Qwen Sparse Attention (QSA): เลเยอร์ที่เหลือจะใช้ QSA เพื่อการดึงข้อมูลที่แม่นยำจากบริบททั้งหมด โดย QSA จะรวมลำดับข้อมูลออกเป็น "ไมโครบล็อก" (Micro-blocks) เพื่อประเมินความสำคัญในระดับบล็อก และเลือกเฉพาะส่วนที่เกี่ยวข้องเท่านั้น วิธีนี้ช่วยลดภาระการคำนวณ Attention, การประมวลผล, และการทำดัชนี (Indexing) ในแต่ละเลเยอร์ ทำให้การออกแบบนี้เหมาะอย่างยิ่งสำหรับสถาปัตยกรรมที่สลับระหว่างเลเยอร์ GDN และ QSA

ประสิทธิภาพที่เหนือกว่าด้วย QSA ⚡

จากการทดสอบของ Alibaba พบว่า QSA สามารถเพิ่มประสิทธิภาพของเวิร์กโหลดที่มีบริบท 1 ล้านโทเค็นได้อย่างมาก เมื่อเทียบกับการคำนวณ Attention แบบเต็ม (Full Attention) Kernel ของ QSA สามารถเพิ่มความเร็วในการประมวลผลช่วง Prefill ได้สูงสุดถึง 7.6 เท่า และช่วง Decoding ได้สูงสุด 4.9 เท่า ยิ่งไปกว่านั้น ในการทดสอบการให้บริการแบบออนไลน์ที่ต้องใช้ Cache สูง (Online serving test) ด้วยบริบท 1 ล้านโทเค็น และอัตราการเข้าถึง Cache ในส่วน Prefix (Prefix-cache hit rate) ที่ 90% โมเดล Qwen3.8-Flash-Next สามารถทำ Throughput ในช่วง Prefill ได้สูงกว่า Qwen3.7-Plus ถึง 8.6 เท่า

ประสบการณ์การใช้งานบน NVIDIA GB300 NVL72 🖥️

การรันโมเดล Qwen3.8-Flash-Next บน NVIDIA GB300 NVL72 มอบประสบการณ์ที่เหนือชั้น ด้วยสถาปัตยกรรมแบบ Rack-scale ที่รวม GPU NVIDIA Blackwell Ultra จำนวน 72 ตัวไว้ในแพลตฟอร์มเดียว ทำให้สามารถสื่อสารแบบ All-to-all ได้อย่างมีประสิทธิภาพด้วยแบนด์วิดท์สูงถึง 130 TB/s ขจัดคอขวดที่มักเกิดขึ้นเมื่อข้อมูลของผู้เชี่ยวชาญ (Expert traffic) ต้องวิ่งผ่านเครือข่ายทั่วไป การใช้งานบน NVIDIA GB300 NVL72 สามารถทำความเร็วได้มากกว่า 16,000 โทเค็นต่อวินาทีต่อ GPU และมากกว่า 200 โทเค็นต่อวินาทีต่อผู้ใช้ ทำให้ทีมนักพัฒนาสามารถทดลอง Agentic Coding ได้อย่างเต็มที่ด้วย Throughput สูงและ Latency ต่ำ

นอกจากนี้ Qwen3.8-Flash-Next ยังสามารถทำงานบนฮาร์ดแวร์ NVIDIA ในระดับ Local ได้เช่นกัน ไม่ว่าจะเป็น NVIDIA DGX Station, คลัสเตอร์ NVIDIA DGX Spark, หรือเวิร์กสเตชันที่ติดตั้ง GPU NVIDIA RTX PRO 6000 Blackwell Workstation Edition จำนวน 4 ตัว นักพัฒนาสามารถสร้างต้นแบบและประเมิน Agentic Coding Workflows บนฮาร์ดแวร์ภายในองค์กร และปรับขนาดไปยัง GB300 NVL72 เพื่อการให้บริการจริง (Production serving) ได้

การปรับแต่งและให้บริการโมเดลด้วยเครื่องมือจาก NVIDIA 🛠️

นักพัฒนาสามารถปรับแต่งโมเดล Qwen3.8-Flash-Next ให้เหมาะกับการใช้งานเฉพาะทางได้ง่ายๆ ด้วย NVIDIA NeMo AutoModel ซึ่งเป็นไลบรารีสำหรับ Fine-tuning แบบ Native บน PyTorch ที่รองรับการโหลด Checkpoint จาก Hugging Face ได้ทันที (Day-0 Hugging Face checkpoint support) ทำให้สามารถฝึกฝนโมเดลได้โดยตรงจาก Checkpoint ที่มีอยู่ โดยไม่ต้องแปลงโมเดล และรองรับทั้งการ Fine-tuning แบบเต็ม (Full SFT) หรือแบบประหยัดหน่วยความจำ (LoRA) นอกจากนี้ ยังสามารถต่อยอดไปสู่การทำ Reinforcement Learning ได้ด้วย NVIDIA NeMo RL recipes

NVIDIA ยังรองรับ Inference Stack ที่หลากหลายเพื่อตอบสนองความต้องการของนักพัฒนา SGLang, vLLM, และ TokenSpeed นำเสนอสูตรสำเร็จ (Recipes) สำหรับ Inference แบบ Open-source สำหรับนักพัฒนาที่ต้องการควบคุมประสิทธิภาพบนแพลตฟอร์มที่เร่งความเร็วด้วย NVIDIA ได้อย่างเต็มที่

เริ่มต้นใช้งาน Qwen3.8-Flash-Next ได้แล้ววันนี้! ✅

• ลองสัมผัสโมเดลได้ที่ QwenCloud
• ดาวน์โหลด Model Weights ได้จาก Hugging Face หรือ ModelScope

ขอบคุณ แหล่งข้อมูล
https://developer.nvidia.com/blog/experiment-with-qwen3-8-flash-next-176b-model-on-nvidia-gb300-nvl72-for-agentic-coding/

NVIDIA Vera CPU: ขุมพลังใหม่สำหรับ AI Factories ที่ต้องการประสิทธิภาพสูงสุด

AI Factories หรือโรงงาน AI กำลังกลายเป็นหัวใจสำคัญของระบบนิเวศ AI ในปัจจุบัน ประสิทธิภาพโดยรวมของ AI Factory ขึ้นอยู่กับความสามารถในการแปลงพลังงานและเงินทุนให้กลายเป็นงานที่เสร็จสมบูรณ์ของ Agent ได้อย่างมีประสิทธิภาพสูงสุด แม้ว่า GPU จะทำหน้าที่ประมวลผลโมเดล AI เป็นหลัก แต่ CPU ก็มีบทบาทสำคัญในการจัดการการทำงาน (Orchestration) การเรียกใช้เครื่องมือ (Tool Execution) และการประมวลผลในสภาพแวดล้อมที่แยกออกไป (Sandboxed Computation)

ความท้าทายของ Agentic Workloads ที่คาดเดาได้ยาก

จากการวิเคราะห์ข้อมูลการใช้งานจริงของ Agentic Sessions มากกว่า 163,000 ครั้ง พบว่าลักษณะการทำงานของ Agent นั้นมีความผันผวนและคาดเดาได้ยากอย่างยิ่ง โดยกว่า 97% ของ Session มีรูปแบบการทำงานที่ไม่ซ้ำกัน ทำให้การใช้กลยุทธ์ CPU แบบเดิม ๆ ที่มีหลายดีไซน์สำหรับ AI Factories นั้นไม่เหมาะสมอีกต่อไป

ลักษณะการทำงานของ Agent มักจะเป็นกระบวนการต่อเนื่องยาวนาน (Sequential Chain of Reasoning) สลับกับการทำงานแบบขนานที่เกิดขึ้นเป็นครั้งคราว (Sporadic Bursts of Parallel Work) เส้นทางหลักที่เป็นลำดับต่อเนื่องนี้มีความอ่อนไหวต่อความหน่วงเวลา (Latency-bound) ซึ่งส่งผลโดยตรงต่อเวลาที่ใช้ในการทำงานให้เสร็จสมบูรณ์ ในขณะที่การทำงานแบบขนานที่เกิดขึ้นเป็นช่วง ๆ (Transient Fan-out Bursts) ต้องการการประมวลผลแบบขนานพร้อมกัน (Concurrency) และการประมวลผลต่อเธรดที่รวดเร็ว (Low-latency Per-thread Execution)

NVIDIA Vera CPU: การออกแบบที่สมดุลเพื่อประสิทธิภาพสูงสุด

NVIDIA Vera CPU ถูกออกแบบมาเพื่อตอบโจทย์ความท้าทายเหล่านี้ ด้วยสถาปัตยกรรมที่มุ่งเน้นทั้งประสิทธิภาพต่อเธรดที่แข็งแกร่งสำหรับเส้นทางหลักที่อ่อนไหวต่อความหน่วงเวลา และความสามารถในการประมวลผลแบบขนานจำนวนมากเพื่อรองรับการทำงานที่กระจายออกไปเป็นช่วง ๆ ได้อย่างมีประสิทธิภาพ การออกแบบนี้จึงช่วยเพิ่มจำนวน Session ที่เสร็จสมบูรณ์ทั้งหมดให้สูงสุด แทนที่จะเน้นแค่การเพิ่มจำนวนคอร์ CPU

จุดเด่นของ NVIDIA Vera CPU:

• ประสิทธิภาพต่อคอร์ที่เหนือกว่า: จากการทดสอบภายในเดือนกรกฎาคม 2026 พบว่า NVIDIA Vera CPU ให้ประสิทธิภาพต่อคอร์ในการทำงานของ Agentic Workloads สูงกว่า CPU AMD Venice รุ่นล่าสุดถึง 1.5 เท่า
• สถาปัตยกรรม Monolithic: การออกแบบที่เป็นชิ้นเดียวช่วยลดความหน่วงที่เกิดจาก Topology ของระบบ
• Front End ที่กว้าง: รองรับการประมวลผลคำสั่งได้หลากหลายและรวดเร็ว
• Out-of-Order Execution ที่ลึก: ช่วยให้การจัดการลำดับการทำงานมีประสิทธิภาพ
• Subsystem หน่วยความจำแบนด์วิดท์สูง: ทำให้การรับส่งข้อมูลรวดเร็ว รองรับการทำงานที่ต้องการข้อมูลจำนวนมาก

การออกแบบที่สมดุลนี้ช่วยให้ AI Factories สามารถเพิ่มประสิทธิภาพโดยรวมของระบบ ลดต้นทุน และเพิ่มปริมาณงานที่เสร็จสมบูรณ์ได้อย่างมีนัยสำคัญ

ทำความเข้าใจ Agentic Trajectories

การทำงานของ Agent สามารถวิเคราะห์ได้จาก "ความยาว" (Length) และ "ความกว้าง" (Width) ของเส้นทางการทำงาน (Trajectory)

• ความยาว (Length): จำนวนขั้นตอนการคิด การเรียกใช้เครื่องมือ การลองผิดลองถูก และงานย่อย ๆ ที่ต้องทำก่อนที่ Agent จะตอบสนองต่อผู้ใช้เสร็จสมบูรณ์
• ความกว้าง (Width): ปริมาณงานที่กระจายออกไปในแต่ละขั้นตอน เช่น การเรียกใช้เครื่องมือพร้อมกัน การดำเนินการค้นหา หรือการทำงานของ Sub-agent

แม้ว่าการทำงานบางช่วงอาจมีความกว้างมาก แต่เวลาส่วนใหญ่ที่ใช้ไปอาจหมดไปกับการรอคอยในเส้นทางหลักที่เป็นลำดับต่อเนื่อง เนื่องจากส่วนของการทำงานแบบขนานนั้นเป็นเพียงช่วงสั้น ๆ ในขณะที่สายโซ่ของความเกี่ยวเนื่องยังคงดำเนินต่อไป

ทำไมการเพิ่มจำนวนคอร์เพียงอย่างเดียวจึงไม่เพียงพอ

ระบบที่มีจำนวนคอร์สูง ๆ อาจดูมีประสิทธิภาพบนกระดาษ แต่บ่อยครั้งต้องแลกมาด้วยประสิทธิภาพการทำงานต่อเธรดที่ลดลง ซึ่งจำเป็นอย่างยิ่งสำหรับเส้นทางหลักของ Agent ที่อ่อนไหวต่อความหน่วงเวลา การทำงานของ Agentic Workloads จะช้าลงอย่างมากเมื่อต้องรันงานที่ต้องประมวลผลตามลำดับและอ่อนไหวต่อความหน่วงบนคอร์ที่มีประสิทธิภาพต่ำ หรือเมื่อเผชิญกับ Overhead ในการซิงโครไนซ์ที่สูงในคลัสเตอร์ขนาดใหญ่ที่ทำงานแบบขนานและแตกต่างกัน

CPU ที่สมดุลสำหรับ Agentic Workloads จึงต้องมีจำนวนคอร์เพียงพอที่จะรองรับการเรียกใช้เครื่องมือพร้อมกันและการกระจายงานของ Sub-agent ควบคู่ไปกับประสิทธิภาพต่อเธรดที่แข็งแกร่งเพื่อเร่งความเร็วในขั้นตอนที่เป็นลำดับ ซึ่งส่งผลต่อความหน่วงโดยรวมของ Agent

Vera CPU ทำงานอย่างไรเพื่อสร้างสมดุล

NVIDIA Vera CPU มาพร้อมกับ Olympus Cores ที่ออกแบบมาเพื่อรักษาประสิทธิภาพต่อเธรดที่แข็งแกร่งในขณะที่ CPU ทำงานเต็มที่ สถาปัตยกรรม Front End ที่กว้าง การคาดเดา Branch ที่ทันสมัย การประมวลผลแบบ Out-of-Order ที่ลึก และ Subsystem หน่วยความจำแบนด์วิดท์สูง ช่วยให้แต่ละคอร์สามารถทำงานได้อย่างต่อเนื่อง แม้จะมี Code Footprint ขนาดใหญ่ การควบคุมการไหลของโปรแกรมที่ซับซ้อน Runtime แบบไดนามิก และการประมวลผลที่เกี่ยวเนื่องกัน

ผลการทดสอบ SPEC CPU® 2026 บ่งชี้ว่า NVIDIA Vera CPU สามารถให้ประสิทธิภาพในการทำงานของ Agentic Workloads ได้สูงถึง 1.5 เท่าเมื่อเทียบกับการแข่งขันล่าสุด ซึ่งรวมถึงการทดสอบ Compiler, Static Analysis และ Python

AI Factory ที่มีประสิทธิภาพต้องการ CPU เพียงดีไซน์เดียว

Vera CPU นำเสนอพื้นฐาน CPU ที่มีประสิทธิภาพมากขึ้นสำหรับ AI Factories เนื่องจากถูกสร้างขึ้นมาเพื่อรองรับ Agentic Trajectories ที่หลากหลาย ประสิทธิภาพต่อเธรดที่แข็งแกร่งภายใต้โหลดเต็มที่ช่วยให้เส้นทางหลักที่อ่อนไหวต่อความหน่วงดำเนินไปอย่างรวดเร็ว ขณะที่ความสามารถในการประมวลผลแบบขนานจำนวนมากผ่านคอร์ต่าง ๆ และแบนด์วิดท์หน่วยความจำที่เพียงพอ สามารถรองรับการเรียกใช้เครื่องมือและการกระจายงานของ Sub-agent ได้อย่างราบรื่น สถาปัตยกรรม Monolithic ที่มี Latency ต่ำของ Vera CPU ยังช่วยลดความผันผวนที่เกิดจาก Topology ของระบบในระหว่างเฟสเหล่านี้

การออกแบบที่สมดุลนี้ช่วยหลีกเลี่ยงทรัพยากรที่สูญเปล่า: คอร์ยังคงทำงานได้อย่างมีประสิทธิภาพทั้งในระหว่างการทำงานแบบลำดับและแบบขนาน และหน่วยความจำที่เชื่อมต่อกับคอร์เหล่านั้นก็ถูกใช้งานอย่างมีประสิทธิผล แทนที่จะถูกผูกติดกับ Compute ที่ใช้งานน้อยเกินไป นอกจากนี้ยังช่วยลดความจำเป็นในการแบ่งกลุ่ม CPU ออกเป็นหลายดีไซน์เฉพาะทางเพื่อรองรับรูปแบบการเรียกใช้เครื่องมือที่ไม่แน่นอน

ผลลัพธ์ที่ได้คือแพลตฟอร์ม CPU ที่สามารถแปลง Compute, แบนด์วิดท์หน่วยความจำ และพลังงาน ให้กลายเป็นจำนวน Agent Turns ที่เสร็จสมบูรณ์มากขึ้น ซึ่งช่วยเพิ่มผลผลิตของ AI Factory และปรับปรุงเศรษฐศาสตร์ของ Fleet ในระดับ Scale

หากต้องการทราบข้อมูลเพิ่มเติมเกี่ยวกับสถาปัตยกรรมและประสิทธิภาพของ NVIDIA Vera CPU โปรดศึกษา NVIDIA Vera CPU Whitepaper

NVIDIA Vera SPEC CPU® 2026 ผลลัพธ์จากการวัดภายในเดือนกรกฎาคม 2026 โปรดอ้างอิง NVIDIA Vera CPU Whitepaper สำหรับรายละเอียดเกี่ยวกับการวัดประสิทธิภาพและการกำหนดค่า ผลลัพธ์ของ AMD Venice อ้างอิงจากลิงก์ ประสิทธิภาพของแต่ละ Workload สำหรับ Venice ได้รับการประมาณการจากคะแนน SPECrate®2026intbase 2070 โดยมีการปรับส่วนประกอบตามการวัดภายในของ Turin ผลลัพธ์อาจแตกต่างกันไป

SPEC®, SPEC CPU®, และ SPECrate® เป็นเครื่องหมายการค้าจดทะเบียนของ Standard Performance Evaluation Corporation (www.spec.org)

ขอบคุณ แหล่งข้อมูล
https://developer.nvidia.com/blog/solving-agentic-ai-fleet-challenges-with-nvidia-vera-cpu/

กู้คืนประสิทธิภาพ LLM ในพริบตา ด้วย Shadow Engine Recovery ใน NVIDIA Dynamo

เมื่อโมเดลภาษาขนาดใหญ่ (LLM) ที่ให้บริการเกิดข้อผิดพลาดและหยุดทำงาน การกู้คืนแบบเดิมมักต้องเริ่มต้นใหม่ทั้งหมด ซึ่งกระบวนการนี้อาจใช้เวลานานหลายนาที ทำให้การให้บริการหยุดชะงักและส่งผลกระทบต่อผู้ใช้งานอย่างมาก NVIDIA Dynamo ได้นำเสนอเทคโนโลยี "Shadow Engine Recovery" ที่ช่วยให้การกู้คืนทำได้รวดเร็วขึ้นมาก เพียงไม่กี่วินาทีเท่านั้น!

ปัญหาของการกู้คืน LLM แบบเดิม

โดยปกติแล้ว เมื่อกระบวนการ LLM Engine เกิดข้อผิดพลาด การกู้คืนจะทำได้โดยการ "Cold Restart" ซึ่งหมายถึงการเริ่มต้นใหม่ทั้งหมด กระบวนการนี้เกี่ยวข้องกับการ:

• โหลด Weights: นำข้อมูลโมเดล (Weights) จากที่เก็บข้อมูลมาโหลดเข้าสู่หน่วยความจำ HBM (High Bandwidth Memory) บน GPU ซึ่งสำหรับโมเดลขนาดใหญ่ขั้นตอนนี้อาจใช้เวลานาน
• คอมไพล์ Kernels: สร้างและปรับแต่งโค้ดที่จำเป็นสำหรับการประมวลผล
• จับภาพ NVIDIA CUDA Graphs: บันทึกการทำงานของ GPU เพื่อให้สามารถเรียกใช้งานได้อย่างมีประสิทธิภาพ

สำหรับโมเดลขนาดใหญ่ ขั้นตอนเหล่านี้อาจใช้เวลาหลายนาที ในระหว่างนั้น พนักงานที่ยังทำงานได้ปกติจะต้องรับภาระทราฟฟิกที่เข้ามาทั้งหมด ซึ่งส่งผลให้เวลาในการตอบสนอง (TTFT - Time To First Token) เพิ่มสูงขึ้น อัตราการถอดรหัสลดลง และละเมิดข้อตกลงระดับการให้บริการ (SLA)

Shadow Engine Recovery: ทางออกที่รวดเร็วกว่า

Shadow Engine Recovery เป็นฟีเจอร์ทดลองใน NVIDIA Dynamo ที่ย้ายงานส่วนใหญ่ของการกู้คืนออกจากเส้นทางการให้บริการหลัก โดยมีหลักการทำงานคือ:

• มี Engine สำรองพร้อมใช้งาน: มี "Shadow Engine" ที่ถูกเตรียมพร้อมและโหลดข้อมูลทุกอย่างไว้แล้ว อยู่ใน GPU เดียวกันกับ Active Engine ที่กำลังให้บริการ
• ใช้ GPU Memory Service (GMS): GMS ทำหน้าที่จัดการหน่วยความจำ GPU สำหรับ Weights โดยเฉพาะ ทำให้ Weights ยังคงอยู่ในหน่วยความจำแม้ว่า Engine จะหยุดทำงานไปก็ตาม
• แยกอายุการใช้งาน Weights ออกจาก Process Engine: Weights จะไม่ถูกลบไปพร้อมกับ Process ที่ล้มเหลว ทำให้ Engine ใหม่สามารถเข้าถึง Weights เดิมได้ทันที

หาก Active Engine เกิดล้มเหลว Shadow Engine จะเข้ามาทำหน้าที่แทนภายในเวลาเพียงไม่กี่วินาที โดยการเริ่มต้นใหม่จะเกิดขึ้นเบื้องหลังโดยไม่กระทบต่อการให้บริการ

ผลลัพธ์ที่น่าทึ่ง: เร็วกว่าเดิมเกือบ 39 เท่า!

จากการทดสอบกับโมเดล GLM-5.2 บน NVIDIA B200 Nodes พบว่า Shadow Engine Recovery สามารถลดเวลาการกู้คืนจาก 283 วินาที (ในการทำ Cold Restart) เหลือเพียง 7.3 วินาทีเท่านั้น ซึ่งหมายถึง:

• TTFT ลดลงอย่างมาก: ผู้ใช้ได้รับข้อมูลเร็วขึ้น
• อัตราการถอดรหัสเพิ่มขึ้น: ประสิทธิภาพการให้บริการดีขึ้น
• การปฏิบัติตาม SLA ดีขึ้น: ลดปัญหาการละเมิดข้อตกลง

ทำไมการกู้คืน LLM จึงช้า?

มีปัญหาหลัก 2 ประการที่ทำให้การกู้คืน LLM ใช้เวลานาน:

1. Weights ผูกติดกับ Engine Process: หน่วยความจำ GPU (HBM) ถูกเชื่อมโยงกับ CUDA Context ของ Engine Process เมื่อ Process นั้นจบลง ทรัพยากรทั้งหมด รวมถึง Weights ที่อยู่ใน HBM ก็จะถูกปล่อยไป ทำให้ Engine ใหม่ต้องโหลด Weights ซ้ำอีกครั้ง
2. สถานะการเริ่มต้นบางอย่างไม่สามารถถ่ายทอดได้: ส่วนประกอบบางอย่าง เช่น NCCL, torch.distributed communicators และ CUDA graphs จะผูกติดกับ Process ที่กำลังทำงานอยู่ และต้องสร้างขึ้นใหม่ทุกครั้งที่เริ่มต้น

Shadow Engine Recovery แก้ปัญหาเหล่านี้ด้วยการแยกอายุของ Weights ออกจาก Process Engine และเตรียมพร้อมส่วนประกอบที่ไม่สามารถถ่ายทอดได้ล่วงหน้าก่อนเกิดความล้มเหลว

Shadow Engine Recovery ทำงานอย่างไร?

การทำงานร่วมกันของส่วนประกอบต่างๆ ทำให้ Shadow Engine Recovery สามารถกู้คืนระบบได้อย่างรวดเร็ว:

1. GPU Memory Service (GMS): หน่วยความจำ GPU ถาวรสำหรับ LLM Inference

GMS จัดการหน่วยความจำ GPU เฉพาะส่วน เช่น Weights โดยแยกจาก Engine Process ทำให้ Weights ยังคงอยู่ในหน่วยความจำแม้ Engine จะถูกรีสตาร์ท Engine ใหม่ที่อยู่บน GPU เดียวกันก็สามารถเข้าถึง Weights เดิมได้ทันที

• การทำงาน: GMS เป็น Sidecar Process ที่จัดการหน่วยความจำ GPU โดยจะจัดสรรหน้าหน่วยความจำ (Physical Pages) และให้ Handle แก่ Engine ต่างๆ Engine สามารถเชื่อมต่อ, นำเข้า Handle, และ Map หน้าหน่วยความจำเหล่านั้นเข้ากับ Virtual Address ใน CUDA Context ของตนเอง
• ข้อดี:
• Weights คงอยู่แม้ Engine ล้มเหลว: แม้ CUDA Context ของ Engine ที่ล้มเหลวจะถูกลบไป แต่ GMS จะยังคงรักษาหน้าหน่วยความจำให้คงอยู่ ทำให้ Engine ใหม่สามารถ Map เข้าใช้งานได้ทันที
• แชร์ Weights ระหว่าง Engine: Engine หลายตัวสามารถ Map ใช้ Weights ชุดเดียวกันได้โดยไม่ต้องสร้างสำเนา ทำให้ประหยัดหน่วยความจำ

GMS สามารถผสานรวมกับ Framework การ Inference เช่น vLLM, SGLang, และ NVIDIA TensorRT-LLM ได้ง่าย โดยการเปิดใช้งาน Flag ที่จุดเริ่มต้น

2. Shadow Engines: Engine สำรองที่พร้อมทำงานโดยไม่มีค่าใช้จ่ายเพิ่มเติมด้าน Weights

Shadow Engine คือ Process Engine ที่ถูกเตรียมพร้อมและรอทำงานอยู่บน GPU เดียวกันกับ Active Engine การที่ GMS ช่วยให้แชร์ Weights ได้ ทำให้การมี Shadow Engine ไม่ได้สิ้นเปลืองหน่วยความจำ HBM มากนัก

• การเตรียมพร้อม: Shadow Engine จะผ่านกระบวนการเริ่มต้นเช่นเดียวกับ Active Engine โดยจะเชื่อมต่อกับ GMS, นำเข้า Weight Mappings, สร้าง Communicators (NCCL, NIXL), จับภาพ CUDA Graphs และทำการ Warm-up จนพร้อมให้บริการ
• การพักรอ: เมื่อพร้อมแล้ว Shadow Engine จะเข้าสู่สถานะ "Park" คือปล่อยส่วนที่สามารถเรียกคืนได้ (เช่น KV Cache) และรอสัญญาณให้ทำงาน โดยยังคงมี CUDA Context, Captured Graphs, Communicators และ Weight Mappings อยู่
• Footprint ที่เล็ก: ด้วยการไม่เก็บสำเนา Weights และ KV Cache ทำให้ Shadow Engine มีขนาดเล็กพอที่จะอยู่ร่วมกับ Active Engine บน GPU เดียวกันได้

3. Worker: หน่วยที่ใช้งานได้จริง

ส่วนประกอบทั้งหมดนี้ถูกรวมเข้าด้วยกันใน Pod ของ Worker ซึ่งประกอบด้วย:

• Engine Containers 2 ตัว: ตัวหนึ่งเป็น Active Engine ที่กำลังให้บริการ อีกตัวเป็น Shadow Engine ที่พร้อมทำงาน
• GMS Sidecar: คอยจัดการการเข้าถึงหน่วยความจำ GPU
• Shared Lock: ใช้ในการเลือก Engine ที่จะเป็น Active Engine

เมื่อระบบทำงานปกติ Engine A จะเป็น Active Engine และ Engine B จะอยู่ในสถานะ Dormant รอสัญญาณ หาก Engine A ล้มเหลว (เช่น Crash หรือถูก Kill) Lock จะถูกปล่อย ทำให้ Engine B สามารถเข้ามารับช่วงต่อ, Remap Weights, สร้าง KV Cache และลงทะเบียนกับ Router ใหม่ได้

สรุป

Shadow Engine Recovery ใน NVIDIA Dynamo เป็นนวัตกรรมที่สำคัญในการเพิ่มความทนทานและประสิทธิภาพของระบบ LLM Inference การลดเวลาการกู้คืนจากหลักนาทีเหลือเพียงไม่กี่วินาที ช่วยให้ธุรกิจมั่นใจได้ว่าบริการ LLM จะมีความเสถียรและตอบสนองต่อผู้ใช้งานได้อย่างต่อเนื่อง แม้จะเกิดเหตุขัดข้องที่ไม่คาดคิดก็ตาม

#NVIDIADynamo #LLM #AI #ShadowEngineRecovery #GMS

ขอบคุณ แหล่งข้อมูล
https://developer.nvidia.com/blog/restore-llm-inference-capacity-in-seconds-with-shadow-engine-recovery-in-nvidia-dynamo/

CUDA Python 1.0: ยกระดับการเข้าถึง GPU จาก Python ด้วย API ที่เสถียร

สำหรับนักพัฒนา Python ที่ต้องการใช้พลังของการ์ดจอ (GPU) เพื่อเร่งความเร็วการประมวลผล ข้อมูลล่าสุดเกี่ยวกับ CUDA Python 1.0 ที่มาพร้อมกับ CUDA 13.3 ถือเป็นข่าวดีที่สำคัญ เพราะเป็นการเปิดประตูสู่การเข้าถึงแพลตฟอร์ม CUDA ได้อย่างเต็มรูปแบบโดยตรงจากภาษา Python ด้วย API ที่ได้รับการรับรองความเสถียร

ทำไม CUDA Python 1.0 ถึงมีความสำคัญ

ก่อนหน้านี้ นักพัฒนา Python ที่ต้องการใช้ GPU มักจะพบกับทางเลือกที่จำกัด:

1. เขียนส่วนขยาย CUDA C++ เอง: ต้องเรียนรู้ CUDA C++ อย่างลึกซึ้ง ตั้งค่าระบบบิวด์ และจัดการการเชื่อมต่อกลับไปยัง Python ซึ่งเป็นกระบวนการที่ซับซ้อนและใช้เวลานาน
2. ใช้ไลบรารีที่มีอยู่: พึ่งพาไลบรารีระดับสูง เช่น PyTorch, CuPy หรือ RAPIDS เพื่อใช้งาน GPU ซึ่งมีข้อจำกัดเมื่อต้องการฟังก์ชันที่ไลบรารีเหล่านั้นยังไม่ได้รองรับ

ข้อจำกัดเหล่านี้ทำให้การทำงานร่วมกันระหว่างไลบรารี GPU ต่างๆ เป็นไปได้ยาก เช่น การใช้หน่วยความจำ GPU ร่วมกันระหว่าง CuPy และ cuDF โดยไม่ต้องคัดลอกข้อมูล

CUDA Python 1.0 เข้ามาแก้ปัญหานี้ โดยมอบ API ที่เป็นทางการและได้รับการดูแลโดย NVIDIA ให้เป็นรากฐานเดียว (One Foundation) สำหรับการพัฒนาบนแพลตฟอร์ม CUDA จาก Python

สิ่งที่ CUDA Python 1.0 นำเสนอ

การเปิดตัว CUDA Python 1.0 พร้อมกับ CUDA 13.3 นี้ ได้รวบรวมองค์ประกอบสำคัญที่ช่วยให้นักพัฒนาสามารถทำงานกับ GPU ได้อย่างมีประสิทธิภาพมากขึ้น:

• cuda.core 1.0.0: เปิดให้เข้าถึง Runtime ของ CUDA ได้อย่างเป็น Pythonic โดยจัดการกับ Device, Stream, Buffer และอื่นๆ ในรูปแบบของอ็อบเจกต์ Python ทำให้การทำงานสะดวกขึ้นและลดข้อผิดพลาด
• cuda.compute 1.0.0: นำเสนอ Parallel Algorithms จาก CCCL ที่สามารถเรียกใช้ได้จาก Python ช่วยให้การประมวลผลแบบขนาน เช่น sort, scan, reduce ทำได้ง่ายขึ้น
• cuda.bindings 13.3.0: เป็นการเชื่อมต่อระดับต่ำแบบ 1:1 กับ CUDA C API ที่ตรงกับเวอร์ชันของ CUDA Toolkit ที่ใช้งาน
• cuda-pathfinder: เครื่องมือช่วยค้นหาและจัดการส่วนประกอบของ CUDA ที่ติดตั้งอยู่ในสภาพแวดล้อมการทำงาน
• nvmath-python 1.0: ไลบรารีคณิตศาสตร์ของ NVIDIA ในรูปแบบ Python ที่มาพร้อมกับข้อตกลงด้านความเสถียรของ API เช่นเดียวกับส่วนประกอบหลักอื่นๆ

คำมั่นสัญญาด้านความเสถียร: Semantic Versioning 🚀

หัวใจสำคัญของการเปลี่ยนแปลงใน CUDA Python 1.0 คือ การนำ Semantic Versioning มาใช้ ซึ่งหมายความว่า:

• การเปลี่ยนแปลงที่ส่งผลกระทบต่อ API (Breaking Changes) จะเกิดขึ้นเฉพาะใน Major Release เท่านั้น
• Minor Release จะเป็นการเพิ่มฟีเจอร์ใหม่ๆ
• Patch Release จะเป็นการแก้ไขข้อผิดพลาด (Bug Fixes)
• API สาธารณะที่ถูกกำหนดให้ยกเลิกการใช้งาน จะมีการ แจ้งเตือน (Deprecated) ล่วงหน้าใน Minor Release พร้อมแนวทางการใช้งานแทนที่ที่ชัดเจน

ข้อตกลงนี้ช่วยให้นักพัฒนาสามารถสร้างไลบรารีและแอปพลิเคชันได้อย่างมั่นใจ โดยไม่ต้องกังวลว่า API ที่ใช้อยู่จะเปลี่ยนแปลงไปอย่างกะทันหันในการอัปเกรดครั้งถัดไป

รากฐานเดียวเพื่อการทำงานร่วมกันที่ดียิ่งขึ้น 🤝

ก่อนหน้านี้ การเชื่อมต่อระหว่าง Python กับ CUDA มักจะต้องอาศัย "Binding Layer" ที่หลากหลาย ซึ่งแต่ละอันก็มีวิธีจัดการกับ Device, Stream หรือการจัดสรรหน่วยความจำที่แตกต่างกัน ทำให้การทำงานร่วมกันของไลบรารีต่างๆ เป็นเรื่องท้าทาย

CUDA Python 1.0 แก้ไขปัญหานี้ด้วยการสร้าง "รากฐานเดียว" (One Foundation) ที่เป็นทางการและดูแลโดย NVIDIA ซึ่งหมายความว่า:

• Python กลายเป็นช่องทางที่ได้รับการสนับสนุนอย่างเป็นทางการ ในการใช้งานแพลตฟอร์ม CUDA
• ไลบรารีต่างๆ สามารถทำงานร่วมกันได้ดีขึ้น เช่น Kernel ของ Numba และการเรียกใช้ cuda.compute สามารถทำงานบนบัฟเฟอร์ GPU เดียวกันใน Stream เดียวกันได้อย่างราบรื่น
• การแบ่งปันทรัพยากรทำได้ง่ายขึ้น เนื่องจากอ็อบเจกต์ต่างๆ มีพื้นฐานเดียวกัน

นอกจากนี้ ฟีเจอร์ขั้นสูงของแพลตฟอร์ม เช่น Green Contexts (การแบ่ง Partition ของ Streaming Multiprocessors เพื่อแยก Kernel ที่ต้องการ Latency ต่ำออกจาก Kernel ที่ใช้ Throughput สูง) หรือ Process Checkpointing (การบันทึกและกู้คืนสถานะของ CUDA) จะสามารถเข้าถึงได้ง่ายขึ้นจาก Python

โมเดลการทำงาน: สามระดับบนรากฐานเดียว 🏗️

CUDA Python ประกอบด้วยชุดของไลบรารีที่ครอบคลุมระบบนิเวศของ CUDA จาก Python ตั้งแต่ระดับต่ำไปจนถึงระดับสูง:

1. ระดับ Runtime System (รากฐาน): จัดการ Device, Memory Allocation, Streams, Synchronization, CUDA Graphs และ JIT Compilation
2. ระดับ CUDA Libraries: ส่วนต่อประสานแบบ Pythonic กับไลบรารีที่ปรับแต่งมาอย่างดีของ NVIDIA เช่น cuda.compute (Parallel Algorithms), nvmath-python (Math Libraries), NCCL4Py และ NVSHMEM4P (Communication Libraries)
3. ระดับ Kernel Authoring (การเขียน Kernel): สำหรับผู้ที่ต้องการเขียนโค้ด GPU เอง เช่น Numba (สำหรับ Python Kernels), cutile-python (CUDA Tile Language) และ cuteDSL (CUTLASS Language)

นักพัฒนาสามารถเลือกเข้าถึงได้จากระดับที่ต้องการ โดยไม่จำเป็นต้องเรียนรู้ทั้งหมด

สิ่งที่ควรทราบ:

• แต่ละส่วนประกอบจะมีการอัปเดตและเวอร์ชันแยกกัน
• บางส่วนประกอบ โดยเฉพาะภาษาสำหรับเขียน Kernel ที่ใหม่กว่า อาจยังอยู่ระหว่างการทดลองและยังไม่ครอบคลุมภายใต้การรับประกัน Semantic Versioning 1.0

เลือกใช้ให้ตรงกับความต้องการ 🎯

CUDA Python 1.0 ช่วยตอบโจทย์ความต้องการที่หลากหลาย:

• ต้องการ Algorithm ที่ปรับแต่งมาแล้ว: ใช้ cuda.compute เพื่อเรียกใช้ Parallel Algorithms ที่มีประสิทธิภาพสูง โดยไม่ต้องเขียน Kernel เอง
• ต้องการเขียน Kernel ด้วย Python: ใช้ Numba เพื่อเขียน Kernel ในรูปแบบ CUDA SIMT Model ซึ่งเป็นการย้ายจาก C++ มายัง Python ที่ง่ายกว่ามาก
• ต้องการเข้าถึง Driver และ Runtime API โดยตรง: ใช้ cuda.core เพื่อการจัดการ Device, Stream, Buffer และอื่นๆ ในรูปแบบ Pythonic หรือ cuda.bindings สำหรับการเชื่อมต่อระดับต่ำแบบ 1:1 กับ C API

การมาถึงของ CUDA Python 1.0 ถือเป็นการเปลี่ยนแปลงครั้งสำคัญที่ทำให้นักพัฒนา Python สามารถปลดล็อกศักยภาพของ GPU ได้อย่างเต็มที่ ด้วยเครื่องมือที่ทรงพลัง ใช้งานง่าย และมีความเสถียรในการพัฒนามากขึ้น.

ขอบคุณ แหล่งข้อมูล
https://developer.nvidia.com/blog/cuda-python-1-0-stable-apis-one-foundation-full-platform-access/