คู่มือฉบับสมบูรณ์สำหรับการติดตั้ง Local LLM: สร้าง Workflow ของ Agent เพื่ออิสระในการใช้งาน Token (เหมาะสำหรับมือใหม่)

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

ปีนี้ โมเดลโอเพนซอร์สขนาดใหญ่ในประเทศมีความคึกคักมาก DeepSeek, Qwen, Kimi, GLM, MiniMax... โมเดลใหม่ๆ ปรากฏขึ้นมาทีละตัว เปิดเผยค่าน้ำหนักอย่างต่อเนื่อง และเริ่มแข่งขันกับโมเดลปิดจากสหรัฐอเมริกา

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

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

ดังนั้น ครั้งนี้ ผมอยากเลือกโมเดลที่มีขนาดท้าทายและเป็นตัวแทนของการปรับใช้บนเครื่องเดียว เพื่อรันกระบวนการปรับใช้ในเครื่องทั้งหมดให้สมบูรณ์

ตัวเอกที่เลือกในที่สุดคือ Ling-3.0-flash ซึ่งเปิดโอเพนซอร์สโดย Ant Bailing ซึ่งเป็นโมเดล Mixture of Experts (MoE) ที่มีจำนวนพารามิเตอร์รวม 124B พอดีผมมี NVIDIA DGX Spark อยู่ในมือ ซึ่งสามารถรันมันได้พอดี

ไม่ต้องพูดมาก เริ่มต้นที่เนื้อหาหลักกันเลย

01 คำศัพท์พื้นฐาน

ก่อนเริ่มต้น เรามาแนะนำคำศัพท์ที่เกี่ยวข้องกับโมเดลกันสักหน่อย เพื่อให้ทุกคนเข้าใจตรงกัน ✌🏻

ความแม่นยำของโมเดล

โมเดลเดียวกันมักจะมีเวอร์ชันความแม่นยำหรือเวอร์ชัน量化ที่แตกต่างกัน ซึ่งส่งผลโดยตรงต่อขนาดโมเดลและเกณฑ์ขั้นต่ำในการรัน

ครั้งนี้เราใช้เวอร์ชัน INT4 อย่างเป็นทางการของ Ling ซึ่งมีขนาดประมาณ 71.75GB

Dense หรือ MoE

โปรดทราบว่า 5.1B เป็นเพียงจำนวนพารามิเตอร์ที่ถูก激活ต่อการอนุมานหนึ่งครั้ง ค่าน้ำหนักเต็ม 124B ทั้งหมดยังคงต้องโหลดเข้าสู่หน่วยความจำ

Inference Engine

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

ครั้งนี้เราเลือก vLLM เพราะการปรับตัวอย่างเป็นทางการในปัจจุบันรองรับค่าน้ำหนัก INT4 ของ Ling-3.0-flash และการถอดรหัสแบบ Speculative Decoding แบบ MTP

02 การติดตั้งและปรับใช้โมเดล

ก่อนอื่น มาทำความรู้จักกับสภาพแวดล้อมการติดตั้งกันก่อน: ผมใช้ NVIDIA DGX Spark ซึ่งมาพร้อมกับชิป GB10 และหน่วยความจำแบบรวม 121.6GB ระบบปฏิบัติการ Ubuntu 24.04 บนสถาปัตยกรรม ARM64 การปรับใช้คือ Ling-3.0-flash-INT4 และการทดสอบปริมาณงานในภายหลังจะใช้ Qwen 3.8-27B ในเครื่องเป็นข้อมูลอ้างอิง

ทางผู้ผลิตมีเวอร์ชันพื้นฐานและเวอร์ชันความแม่นยำต่างๆ เช่น FP8, FP4 และ INT4 ให้เลือก คุณสามารถเลือกตามฮาร์ดแวร์ของคุณได้

นอกจากนี้ยังมี Ling-3.0-tiny ขนาด 8B และเวอร์ชัน FP8, INT4 ของมันอีกด้วย ผู้ใช้ที่มี Mac ทั่วไปหรือการ์ด 4090 ใบเดียวสามารถลองใช้เวอร์ชันความแม่นยำต่ำของ Tiny ก่อนได้

ขั้นตอนที่ 1: ดาวน์โหลดโมเดล ครั้งนี้ผมใช้เวอร์ชัน INT4 อย่างเป็นทางการ ลิงก์ดาวน์โหลด 👇🏻

• Hugging Face: Ling-3.0-flash-int4
• ModelScope: Ling-3.0-flash-int4

หากการเข้าถึง Hugging Face ไม่สะดวก คุณสามารถดาวน์โหลดด้วยตนเองจาก ModelScope หลังจากดาวน์โหลดแล้ว จะมีไฟล์ safetensors จำนวน 24 ชิ้น รวมประมาณ 71.75GB คุณต้องเว้นพื้นที่สำหรับ Inference Engine และ KV Cache ระหว่างการทำงานด้วย

ขั้นตอนที่ 2: เตรียมสภาพแวดล้อม สถาปัตยกรรม BailingMoeV3 ของ Ling-3.0-flash ค่อนข้างใหม่ ผมลองใช้ GGUF กับ llama.cpp แต่เกิดข้อผิดพลาด unknown model architecture: 'bailingmoe3' ดังนั้นครั้งนี้ ผมจึงใช้ สาขา vLLM ที่ปรับแต่งอย่างเป็นทางการ โดยตรง:

1pip install uv
2uv venv ~/my_ling_env
3source ~/my_ling_env/bin/activate
4
5git clone -b ling_3_0 https://github.com/inclusionAI/vllm-ling-v3.git
6cd vllm-ling-v3
7VLLM_USE_PRECOMPILED=1 uv pip install --editable . --torch-backend=auto

ขั้นตอนที่ 3: เริ่มบริการ Inference แทนที่พาธโมเดลด้วยพาธของค่าน้ำหนัก INT4 ที่คุณดาวน์โหลดในเครื่อง:

1vllm serve /path/to/Ling-3.0-flash-int4 \
2  --served-model-name ling-int4 \
3  --host 127.0.0.1 \
4  --port 30000 \
5  --trust-remote-code \
6  --max-model-len 16384 \
7  --gpu-memory-utilization 0.8 \
8  --max-num-seqs 8 \
9  --reasoning-parser ling3 \
10  --speculative-config '{"method":"bailing_hybrid_v3_mtp","num_speculative_tokens":1}'

⚠️

โปรดแทนที่พาธในคำสั่งด้วยพาธจริงบนเครื่องของคุณ

ในที่นี้ ตั้งค่าขีดจำกัดบริบทเป็น 16K, ความพร้อมกันเป็น 8, และเปิดใช้งานการถอดรหัสแบบ Speculative Decoding แบบ MTP

หมายเหตุ: MTP (Multi-Token Prediction) ช่วยให้โมเดลสามารถลองทำนายหลาย Token พร้อมกันได้ ส่วนที่ทำนายถูกต้องสามารถนำไปใช้ได้ทันที ลดรอบการคำนวณสำหรับการสร้าง Token ทีละตัว และเพิ่มความเร็วในการส่งออก

ขั้นตอนที่ 4: ตรวจสอบบริการ เมื่อเริ่มต้นแล้ว ให้ส่งคำของ่ายๆ:

1curl -s http://127.0.0.1:30000/v1/chat/completions \
2  -H "Content-Type: application/json" \
3  -d '{"model":"ling-int4",
4       "messages":[{"role":"user","content":"สวัสดี ช่วยแนะนำตัวเองสักหนึ่งประโยค"}],
5       "stream":true}'

เทอร์มินัลเริ่มส่งคืนเนื้อหาแบบสตรีม แสดงว่าโมเดล 124B นี้กำลังทำงานในเครื่องแล้ว

03 การทดสอบประสิทธิภาพและความสามารถของโมเดล

1. ปริมาณงาน Token เมื่อโมเดลเริ่มทำงานครั้งแรก ผมรันการทดสอบหนึ่งรอบโดยใช้ Benchmark ในตัวของ vLLM คำขอทั้งหมด 20 รายการเสร็จสมบูรณ์ โดยมีปริมาณงานส่งออก 84.34 tok/s, ปริมาณงาน Token รวม 133.10 tok/s, และอัตราการยอมรับ MTP 67.35%

บันทึกผลลัพธ์ดั้งเดิม 👇🏻

1============ Serving Benchmark Result ============
2Successful requests:                     20
3Failed requests:                         0
4Request rate configured (RPS):           2.00
5Benchmark duration (s):                  60.71
6Total input tokens:                      2960
7Total generated tokens:                  5120
8Request throughput (req/s):              0.33
9Output token throughput (tok/s):         84.34
10Peak output token throughput (tok/s):    61.00
11Peak concurrent requests:                20.00
12Total token throughput (tok/s):          133.10
13---------------Time to First Token----------------
14Mean TTFT (ms):                          19692.98
15Median TTFT (ms):                        18877.99
16P99 TTFT (ms):                           40039.02
17-----Time per Output Token (excl. 1st token)------
18Mean TPOT (ms):                          44.61
19Median TPOT (ms):                        44.09
20P99 TPOT (ms):                           49.68
21---------------Inter-token Latency----------------
22Mean ITL (ms):                           74.09
23Median ITL (ms):                         72.39
24P99 ITL (ms):                            280.71
25---------------Speculative Decoding---------------
26Acceptance rate (%):                     67.35
27Acceptance length:                       1.67
28Drafts:                                  3051
29Draft tokens:                            3051
30Accepted tokens:                         2055
31Per-position acceptance (%):
32  Position 0:                            67.35
33==================================================

หลังจากนั้น ผมทำการทดสอบความพร้อมกันบน Ling และ Qwen 3.8-27B ในเครื่อง ที่ความพร้อมกัน 8, ปริมาณงานรวมของ Ling คือ 141.38 tok/s ในขณะที่ Qwen 3.8 คือ 32.61 tok/s แตกต่างกันประมาณ 4.34 เท่าในรอบนี้

🔥🔥🔥การเปรียบเทียบการทดสอบโหลดระหว่าง Ling-3.0-Flash และ Qwen3.8-27B

Ling-3.0-flash

Qwen 3.8 -27B

บางคนอาจสงสัย: ทำไมความพร้อมกันเดี่ยวของ Ling อยู่ที่ 34.77 tok/s เท่านั้น แต่ที่ความพร้อมกัน 8 กลับกลายเป็น 141.38 tok/s? เพื่อนๆ ที่มีพื้นฐานด้านเทคนิคอาจถามว่าคะแนนความพร้อมกันเดี่ยวนี้ช้าเมื่อเทียบกับข้อมูลทางการหรือไม่

ที่นี่เราต้องอธิบาย วิธีการทดสอบเฉพาะ และ ความแตกต่างของความเร็วที่เกิดจากวิธีการประเมินที่แตกต่างกัน:

1. วิธีการทดสอบและลิงก์ End-to-End จริง: การทดสอบนี้ใช้อินเทอร์เฟซที่เข้ากันได้กับ OpenAI ในเครื่อง โดยทำการทดสอบโหลดผ่านคำขอ HTTP แบบสตรีมมิ่ง ไม่ใช่การทดสอบ Inference แบบออฟไลน์ที่แยกจากกรอบงานบริการ แต่ละคำขอของ Ling ใช้พรอมต์ข้อความยาวประมาณ 150 Token และสร้างสูงสุด 512 Token การจับเวลาเริ่มต้นจากคำขอ HTTP ของไคลเอนต์จนกว่าการตอบกลับแบบสตรีมจะเสร็จสมบูรณ์ ดังนั้นจึงรวมถึงการเรียก HTTP ในเครื่อง การจัดตารางบริการ การประมวลผล Tokenizer, Prefill, การถอดรหัสทีละ Token และการส่งคืนแบบสตรีม
2. อัตราการส่งออกสตรีมเดี่ยว vs. ปริมาณงานรวมของเครื่อง: ความเร็วสตรีมเดี่ยว (ประสบการณ์ผู้ใช้จริง): ที่ $c=1$, อัตราการส่งออกแบบ End-to-End อยู่ที่ประมาณ 35.34 tok/s (การทดสอบการสนทนาเดี่ยวจริงที่ 38+ tok/s) เทียบเท่ากับมากกว่า 35 ตัวอักษรจีนต่อวินาที ซึ่งเร็วมากเมื่อมองเห็น; ปริมาณงานรวม (ผลผลิตรวมภายใต้ความพร้อมกัน): เมื่อความพร้อมกันเพิ่มขึ้น vLLM ใช้ Continuous Batching เพื่อรวมหลายคำขอเข้าสู่การคำนวณ GPU ใช้ประโยชน์จากแบนด์วิดท์หน่วยความจำแบบรวมของ Blackwell อย่างเต็มที่ ที่ความพร้อมกัน 8, ปริมาณงานรวมของเครื่องพุ่งสูงถึง 141.38 tok/s

ส่วนสาเหตุที่แตกต่างจาก Benchmark ทางการบางตัว ประเด็นสำคัญคือเกณฑ์การทดสอบ ความแม่นยำของโมเดล, Inference Engine, ความยาวบริบท, จำนวน Token อินพุต/เอาต์พุต, ขนาดความพร้อมกัน, และการใช้ Inference แบบออฟไลน์หรือบริการ HTTP ล้วนส่งผลต่อผลลัพธ์สุดท้าย เฉพาะเมื่อเงื่อนไขเหล่านี้สอดคล้องกันโดยพื้นฐานเท่านั้น ตัวเลขจึงจะเหมาะสมสำหรับการเปรียบเทียบโดยตรง

พูดง่ายๆ คือ: ความเร็วแตกต่างกันเนื่องจากวิธีการประเมิน—หากทดสอบในสภาพแวดล้อมที่มีความพร้อมกันสูงมาก (เช่น 32/64) หรือสภาพแวดล้อมการคำนวณบริสุทธิ์ที่ไม่มีโปรโตคอลเครือข่าย ตัวเลขปริมาณงานรวมจะดูสูงขึ้น; ในการโทรสนทนาเดี่ยวหรือการเรียกใช้การเขียนโค้ดในชีวิตประจำวันของเรา ความเร็วสตรีมเดี่ยว 35+ tok/s และเวลาแฝงของ Token แรกที่ต่ำกว่า 220ms ของ Ling ให้ความรู้สึกที่ราบรื่นและไร้สะดุดอย่างยิ่ง

ที่ความพร้อมกันเดี่ยว ความเร็วสตรีมเดี่ยวเฉลี่ยของ Ling อยู่ที่ประมาณ 35.34 tok/s; ที่ความพร้อมกัน 8, ปริมาณงานรวมถึง 141.38 tok/s ปริมาณงานรวมของ Qwen3.8 ที่ความพร้อมกัน 8 คือ 32.61 tok/s ในรอบนี้ ข้อได้เปรียบของ Ling ส่วนใหญ่สะท้อนให้เห็นในความเร็วในการส่งออกและปริมาณงานพร้อมกัน โดยการตอบกลับเร็วขึ้นอย่างเห็นได้ชัดในการใช้งานจริง

2. ความสามารถจริง

Benchmark สะท้อนเพียงส่วนหนึ่งของประสิทธิภาพเท่านั้น ความสามารถในการใช้งานจริงขึ้นอยู่กับประสิทธิภาพของโมเดลกับปัญหาเฉพาะ ผมเลือกสามทิศทางสำหรับการทดสอบอย่างง่าย

(1) การใช้เหตุผลเชิงตรรกะ

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

(2) ขอบเขตความปลอดภัย: ต่อไป ผมทดสอบปฏิกิริยาของมันต่อการดำเนินการที่มีความเสี่ยงสูง: ไม่ว่าจะดำเนินการโดยตรงหรือระบุความเสี่ยง ยืนยันกับผู้ใช้ และให้ทางเลือกที่ปลอดภัยกว่า

(3) ข้อความยาว

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

04 จาก API สู่ TUI แล้วสู่ Tool Calling

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

ดังนั้น ผมจึงสร้าง TUI ง่ายๆ ก่อน ซึ่งเป็นอินเทอร์เฟซแชทที่ทำงานในเทอร์มินัล ไม่ใช่ซอฟต์แวร์ที่ซับซ้อน ผมให้ AI เขียนสคริปต์ Python เพื่อห่อหุ้มการเรียกอินเทอร์เฟซในเครื่อง, การส่งออกแบบสตรีม, และประวัติการสนทนา จากนั้นเริ่มต้นด้วยคำสั่งเดียว:

1python3 ling-3.0-chat.py

ด้วยวิธีนี้ ผมไม่ต้องเขียน curl ทุกครั้ง เปิดเทอร์มินัลแล้วแชทได้เลย คำตอบจะสตรีมเข้ามา และคุณสามารถดู TPS, TTFT, และจำนวน Token ได้ ผมทำการทดสอบความสามารถก่อนหน้านี้ในอินเทอร์เฟซนี้

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

เพื่อให้มันสามารถเรียกใช้ความสามารถของระบบได้ เราจำเป็นต้องเพิ่ม Tool Calling พูดง่ายๆ คือ การดำเนินการต่างๆ เช่น การรันคำสั่ง, การอ่านไฟล์, และการเขียน จะถูกห่อหุ้มเป็นเครื่องมือ โมเดลจะตัดสินก่อนว่าต้องการข้อมูลใด จากนั้นจึงเริ่ม tool use; สคริปต์ Python จะดำเนินการและส่งผลลัพธ์กลับไปให้โมเดลเพื่อประมวลผลต่อไป

ตัวอย่างเช่น ในตอนแรก เมื่อผมขอให้มันตรวจสอบข้อมูล GPU ของระบบ มันไม่ทราบการใช้งานจริง และสามารถบอกวิธีตรวจสอบเท่านั้น หลังจากเพิ่ม Tool Calling แล้ว มันสามารถรันคำสั่งระบบได้เองและจัดระเบียบผลลัพธ์การค้นหาใน TUI โดยตรง

ตามหลักการเดียวกัน คุณสามารถเชื่อมต่อ Web Search, อินเทอร์เฟซภายในองค์กร, ฐานข้อมูล ฯลฯ ต่อไปได้ เครื่องมือเฉพาะสามารถขยายได้ตามความต้องการทางธุรกิจ

05 การเชื่อมต่อกับอินเทอร์เฟซภาพ

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

ครั้งนี้ผมเลือก DeepSeek Harness ของ Liang Sheng ซึ่งไม่เพียงเพิ่มหน้าแชทเท่านั้น แต่ยังมีการจัดการบริบท, พื้นที่ทำงาน, Tool Calling, การควบคุมสิทธิ์, และการวางแผนงาน พร้อมด้วย Web UI ในตัว มันใช้สถาปัตยกรรม "ทุกอย่างเป็นปลั๊กอิน" ทำให้สามารถขยายฟังก์ชันการทำงานในอนาคตได้

โปรดทราบว่า DeepSeek Harness ยังอยู่ในขั้นตอนการแสดงตัวอย่างสำหรับนักพัฒนาและอัปเดตอย่างรวดเร็ว ซึ่งอาจนำไปสู่การเปลี่ยนแปลงที่ไม่เข้ากันได้ มีกรอบงาน Agent โอเพนซอร์สอื่นๆ อีกมากมาย คุณสามารถเลือกตามความต้องการของคุณได้

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

1llm-pi-ai:
2  providers:
3    ling:
4      displayName: "Ling-3.0-flash (124B)"
5      api: openai-completions
6      baseURL: http://127.0.0.1:30000/v1
7      apiKeyEnv: OPENAI_API_KEY
8      models:
9        - id: ling-int4
10          name: Ling-3.0-flash (124B MoE)

หลังจากเริ่ม Web UI แล้ว ให้เปิดที่อยู่เริ่มต้นในเบราว์เซอร์ของคุณ:

1http://localhost:3080

ด้วยวิธีนี้ การแชทประจำวัน, ประวัติ, และการสลับโมเดลสามารถทำได้ใน DeepSeek Harness Harness เองมีการดำเนินการไฟล์, การรันคำสั่ง, และการวางแผนงาน ซึ่งสามารถขยายเพิ่มเติมผ่านปลั๊กอิน สำหรับการใช้งานเฉพาะและปลั๊กอินของบุคคลที่สาม ผู้ที่สนใจสามารถค้นหาได้

โปรดทราบว่าเครื่องมือที่ผมเขียนใน Python TUI จะไม่ย้ายโดยอัตโนมัติ หากต้องการใช้ใน Harness จะต้องรวมเข้าด้วยกันใหม่ตามกลไกปลั๊กอินของมัน ด้านล่างนี้คือเอฟเฟกต์การรวมจริงที่ผมทำสำหรับ Ling คุณสามารถชมการบันทึกได้

06 การสร้างเวิร์กโฟลว์ AI

ณ จุดนี้ ลิงก์โมเดลเดี่ยวตั้งแต่การปรับใช้ไปจนถึงอินเทอร์เฟซและ Tool Calling สำหรับ Ling-3.0-flash ได้ถูกสร้างขึ้นอย่างสมบูรณ์แล้ว

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

ข้อได้เปรียบของ Ling-3.0-flash คือความเร็วในการประมวลผลข้อความและการสร้าง แต่ไม่รองรับอินพุตแบบ Multimodal ดั้งเดิม หากงานต้องการความเข้าใจรูปภาพหรือวิดีโอ คุณสามารถเชื่อมต่อโมเดล Multimodal เช่น Qwen3.8-27B; หากต้องการสร้างวิดีโอ คุณสามารถเชื่อมต่อ MiniMax H3 ที่เพิ่งเปิดโอเพนซอร์ส แต่ละโมเดลจัดการสิ่งที่ถนัดที่สุด แล้วส่งผลลัพธ์ไปยังโมเดลถัดไป

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

1ความต้องการและวัสดุ
2→ Ling สร้างสคริปต์และ Storyboard
3→ โมเดล Multimodal ตรวจสอบวัสดุและข้อกำหนดทางภาพ
4→ MiniMax H3 สร้างวิดีโอ
5→ โมเดล Multimodal ตรวจสอบภาพและความต่อเนื่อง
6→ Ling ปรับพรอมต์ตามคำติชม
7→ มนุษย์ตรวจสอบขั้นสุดท้าย

วิดีโอด้านล่างแสดงเอฟเฟกต์จริงของพรอมต์ที่สร้างโดย Ling-3.0-flash จากนั้นส่งให้ MiniMax H3 สร้าง

เมื่อกระบวนการนี้ถูกกำหนดไว้แล้ว คุณเพียงแค่เปลี่ยนความต้องการและวัสดุเพื่อใช้ซ้ำ อย่างไรก็ตาม การรันโมเดลขนาดใหญ่หลายตัวในเครื่องพร้อมกันนั้นมีความต้องการ VRAM และหน่วยความจำที่สูงมาก Ling INT4 ประมาณ 72GB, Qwen3.8-27B BF16 ประมาณ 51.77GB, บวกกับ KV Cache และโมเดลวิดีโอ; เป็นการยากที่จะเก็บทั้งหมดไว้ใน Spark เครื่องนี้

ก่อนการปรับใช้จริง ต้องแน่ใจว่าได้คำนวณว่าแต่ละโมเดลต้องการ VRAM หรือหน่วยความจำแบบรวมเท่าใด เมื่อทรัพยากรไม่เพียงพอ คุณสามารถสลับโมเดลทีละขั้นตอน, เลือกเวอร์ชัน量化, หรือแยกโมเดลไปยังอุปกรณ์หลายเครื่อง โมเดลหลายตัวจะไม่ทำงานแยกกันอีกต่อไป แต่จะทำงานร่วมกันรอบงานเดียวกัน—นี่คือเวิร์กโฟลว์ AI แบบหลายโมเดลที่ใช้งานได้จริง

07 ความคิดเห็นสุดท้าย

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

โมเดลโอเพนซอร์สจะยังคงอัปเดตต่อไป ในอนาคต ไม่ว่าคุณจะเปลี่ยนโมเดล, เวอร์ชัน量化, หรือ Inference Engine เส้นทางจากการดาวน์โหลดค่าน้ำหนักและเริ่มบริการไปจนถึงการเชื่อมต่อเครื่องมือและเวิร์กโฟลว์จะไม่เปลี่ยนแปลงมากนัก

หากเงื่อนไขเอื้ออำนวย ผมยังคงแนะนำให้ทุกคนปรับใช้โมเดลในเครื่องด้วยตนเอง:

1. การควบคุมข้อมูล: ไฟล์, การสนทนา, และข้อมูลทางธุรกิจจะอยู่บนเครื่องของคุณหรือเครือข่ายภายใน โดยมีสิทธิ์ไดเรกทอรีและคำสั่งที่คุณกำหนดเอง
2. เหมาะสำหรับการใช้งานความถี่สูง: ไม่จำเป็นต้องคำนวณต้นทุน Token ทุกครั้งที่ใช้ ลดการพึ่งพาเครือข่ายและบริการของบุคคลที่สาม
3. ปรับแต่งได้ง่าย: โมเดล, ความแม่นยำในการ量化, Inference Engine, และเครื่องมือสามารถปรับเปลี่ยนได้ และสามารถเชื่อมต่ออินเทอร์เฟซภายในและฐานข้อมูลได้

เมื่อโมเดลโอเพนซอร์สแข็งแกร่งขึ้น การปรับใช้ในเครื่องจะกลายเป็นทางเลือกของคนจำนวนมากขึ้น คุณสามารถสร้างเครื่องมือและเวิร์กโฟลว์ตามความต้องการของงาน, สภาพอุปกรณ์, และงบประมาณของคุณ ผมหวังว่าทุกคนจะมี Agent ในเครื่องของตัวเองในอนาคต โดยไม่ต้องจ้องมองการบริโภค Token ทุกครั้ง และบรรลุ "Token Freedom" ของตัวเองอย่างแท้จริง!

แหล่งข้อมูลที่เกี่ยวข้อง

• Hugging Face: ค่าน้ำหนัก Ling-3.0-flash INT4
• ModelScope: ค่าน้ำหนัก Ling-3.0-flash INT4
• พื้นที่เก็บการปรับแต่ง vLLM อย่างเป็นทางการ

📚 สรุปบทความก่อนหน้า

1. คู่มือปฏิบัติ Hermes Agent: จากความกังวลเรื่อง X สู่การสะสมอัตโนมัติ
2. คู่มือป้องกันผมร่วงสำหรับโปรแกรมเมอร์
3. การเชื่อมต่อ Hermes กับ iMessage
4. การเชื่อมต่อ Hermes กับ X Premium
5. คู่มือฉบับสมบูรณ์ของ Hermes Agent
6. คู่มือเบื้องต้นของ Hermes Agent: โมเดลเสริม
7. คู่มือเบื้องต้นของ Hermes Agent
8. คู่มือขั้นสูงของ Hermes Agent
9. คู่มือที่ไม่สมบูรณ์ของ Hermes Agent
10. คู่มือฉบับสมบูรณ์สำหรับการสมัครสมาชิก Claude Pro ในไนจีเรีย
11. บทช่วยสอนการลงทะเบียน Apple ID ในไนจีเรีย
12. สมัครสมาชิก ChatGPT Plus ครึ่งราคาในตุรกี
13. การลงทะเบียน Apple ID สหรัฐอเมริกา
14. สมัครสมาชิก Claude/ChatGPT/Gemini ผ่าน Alipay
15. บทช่วยสอนฉบับสมบูรณ์สำหรับการปรับใช้ LLM ในเครื่องบน Mac
16. ตรวจสอบคุณภาพ IP
17. ทำไม Doubao ถึงไม่แนะนำแบรนด์ของคุณ
18. วิธีอธิบายให้คุณยายฟังว่าสิ่งที่ Doubao พูดนั้นไม่จริง

หากสิ่งนี้มีประโยชน์ โปรดติดตาม + บุ๊กมาร์ก + แชร์ต่อ 👏🏻

ติดตาม @Lonely__MH เพื่อรับบทช่วยสอนที่เป็นมิตรกับมือใหม่และข้อมูลเชิงลึกเกี่ยวกับเครื่องมือ AI อย่างต่อเนื่อง