บทเรียน vLLM D3: รันโมเดลตัดสินใจของ AI ในเครื่องด้วย Python

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

ตระกูลนี้มี 6 โมเดล ตั้งแต่ 600 ล้าน ถึง 27 พันล้านพารามิเตอร์ สามารถทดลองกับโมเดลขนาดเล็กบนฮาร์ดแวร์ทั่วไป และใช้โมเดลขนาดใหญ่สำหรับงานที่ต้องการมากขึ้น D3 Edge มีน้ำหนักเบามากจนสามารถรันบนสมาร์ตโฟนที่รองรับได้

vLLM รองรับ D3 ผ่านเฟรมเวิร์ก Structured Decisions ทำให้สามารถเสิร์ฟโมเดลในเครื่องและเรียกใช้งานผ่านแอปพลิเคชันโปรแกรมมิงอินเทอร์เฟซ (API) ที่เรียบง่าย โครงการ vLLM Semantic Router ในภาพรวมยังเพิ่มความสามารถด้านการกำหนดเส้นทางและการตัดสินใจสำหรับแอปพลิเคชัน AI

ในบทเรียนนี้ จะครอบคลุมการตั้งค่า D3 ในเครื่อง ประเภทการตัดสินใจทั้ง 3 แบบ และการพยากรณ์ครั้งแรก จากนั้นจะสร้างโปรเจกต์ใช้งานจริง 3 โปรเจกต์:

1. เครื่องวิเคราะห์คุณภาพบล็อกด้วย AI: ใช้ TypeSafe Python software development kit (SDK) และ Olostep เพื่อจัดหมวดหมู่และประเมินบทความจริง
2. ความเข้าใจภาพ: วิเคราะห์ภาพสินค้า ระบุกลุ่มสินค้า และประเมินคุณภาพของภาพ
3. ความเข้าใจวิดีโอ: วิเคราะห์วิดีโอสั้นเพื่อจับการเคลื่อนไหวและการเปลี่ยนแปลงทางภาพ

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

สรุปสั้นๆ

• D3 เป็นตระกูลของโมเดลตัดสินใจแบบน้ำหนักเปิดที่ส่งคืนความน่าจะเป็นสำหรับคำถามแบบเลือกคำตอบ แบบใช่/ไม่ใช่ (Noul) และแบบให้คะแนน แทนการสร้างข้อความ
• D3 Mini (4B) รองรับข้อความ ภาพ และวิดีโอ และรันบนกราฟิกการ์ด NVIDIA RTX 3090 เพียงตัวเดียวด้วย vLLM
• เสิร์ฟโมเดลด้วย vllm serve และเรียกผ่าน TypeSafe Python SDK หรือเอ็นด์พอยต์ /v1/systemone
• เราสร้าง 3 โปรเจกต์: เครื่องวิเคราะห์คุณภาพบทความ เครื่องคัดกรองภาพสินค้า และเครื่องวิเคราะห์การเคลื่อนไหวในวิดีโอ
• การตอบสนองในการทดสอบของเรามีตั้งแต่ 87 มิลลิวินาที ถึง 1.11 วินาที

D3 Decision Models คืออะไร?

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

ที่มา: vllm-sr/d3-mini · Hugging Face

รองรับการตัดสินใจ 3 แบบ:

D3 มี 6 ขนาด ตั้งแต่ 600 ล้าน ถึง 27 พันล้านพารามิเตอร์ เหมาะตั้งแต่อุปกรณ์ปลายทางไปจนถึง GPU ระดับสูง คุณสามารถเรียกดูตระกูลนี้ได้ใน ชุด Decision 3.0 บน Hugging Face

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

สำหรับบทเรียนนี้ จะใช้ D3 Mini (4B) เพราะรองรับความเข้าใจข้อความ ภาพ และวิดีโอ ขณะเดียวกันก็มีขนาดเล็กพอที่จะรันบน GPU NVIDIA RTX 3090 ในเครื่อง

วิธีรัน D3 ในเครื่องด้วย vLLM

vLLM Semantic Router (vLLM SR) เป็นโครงการโอเพ่นซอร์สในระบบนิเวศ vLLM ที่ช่วยให้แอปพลิเคชัน AI ตัดสินใจอย่างชาญฉลาด รองรับการกำหนดเส้นทางโมเดล การตรวจสอบความปลอดภัย แคชเชิงความหมาย และโมเดลตัดสินใจเฉพาะทางอย่าง D3 ขณะที่ vLLM จัดการการอนุมานของโมเดล vLLM SR มุ่งเน้นว่าแต่ละคำขอถูกประเมินและกำหนดเส้นทางอย่างไร

ในบทเรียนนี้ จะใช้ การรองรับ Structured Decisions แบบใหม่ของ vLLM เพื่อรัน D3 Mini ในเครื่องโดยไม่ต้องติดตั้ง Semantic Router เอง vLLM ให้บริการ D3 ผ่าน System One API ซึ่งตั้งชื่อตามการคิดแบบ "System 1" ที่รวดเร็วและใช้สัญชาตญาณ ตอบคำถามแบบกำหนดชนิดได้ในการผ่านครั้งเดียว และส่งคืนความน่าจะเป็นแทนการสร้างข้อความ

เราจะเชื่อมต่อกับโมเดลด้วย TypeSafe Python SDK และสำรวจวิธีจัดการการจัดหมวดหมู่ การประมาณความน่าจะเป็น และการให้คะแนน

1. ติดตั้ง vLLM และรัน D3 ในเครื่อง

จะใช้ Ubuntu Linux, Python 3.12 และกราฟิกการ์ด NVIDIA RTX 3090 ผู้ใช้ Windows สามารถทำตามได้โดยใช้ Ubuntu ผ่าน Windows Subsystem for Linux 2 (WSL2)

ก่อนอื่น ติดตั้ง uv เมื่อติดตั้งเสร็จแล้วให้รีสตาร์ตเทอร์มินัล เพื่อให้คำสั่ง uv ใช้งานได้

curl -LsSf https://astral.sh/uv/install.sh | shขับเคลื่อนโดย

ตอนนี้ สร้างสภาพแวดล้อม Python 3.12 และเปิดใช้งาน:

uv venv --python 3.12 --seed
source .venv/bin/activateขับเคลื่อนโดย

ถัดไป ติดตั้ง vLLM รุ่น nightly ซึ่งรวมการรองรับ Structured Decisions ใหม่ไว้แล้ว:

uv pip install -U vllm --torch-backend=auto \
  --extra-index-url https://wheels.vllm.ai/nightlyขับเคลื่อนโดย

เริ่มโมเดล D3 Mini ด้วยการตั้งค่าหน่วยความจำ GPU ที่เหมาะสำหรับการทดสอบในเครื่อง:

vllm serve vllm-sr/d3-mini \
  --gpu-memory-utilization 0.75 \
  --max-model-len 4096 \
  --max-num-seqs 4 \
  --enforce-eagerขับเคลื่อนโดย

การเปิดครั้งแรกจะดาวน์โหลดโมเดลจาก Hugging Face เมื่อโหลดเสร็จ vLLM จะเปิดเผย System One API ในเครื่องที่ http://localhost:8000/v1/systemone

ให้เทอร์มินัลนี้ทำงานค้างไว้ เราจะเข้าถึงโมเดลจากสมุดบันทึก Jupyter

2. เชื่อมต่อกับ D3 ด้วย TypeSafe Python SDK

แทนที่จะสร้างคำขอ HTTP ด้วยตนเอง จะใช้ TypeSafe Python SDK เพื่อสื่อสารกับโมเดลที่รันอยู่ในเครื่อง

ติดตั้งไลบรารีที่ต้องใช้:

%pip install typesafe-sdk olostepขับเคลื่อนโดย

นำเข้า 3 ประเภทการตัดสินใจและกำหนดค่ไคลเอนต์ให้เชื่อมต่อกับเซิร์ฟเวอร์ vLLM ในเครื่องของเรา:

from typesafe_sdk import TypeSafeClient, Choice, Noul, Score

client = TypeSafeClient(
    base_url="http://localhost:8000",
    api_key="local",
    model="vllm-sr/d3-mini"
)ขับเคลื่อนโดย

ใช้ API key ชั่วคราวเพราะเซิร์ฟเวอร์ในเครื่องไม่ต้องใช้ข้อมูลรับรองของ TypeSafe ที่โฮสต์อยู่

3. ทำการตัดสินใจด้วย AI ครั้งแรก

เริ่มด้วยตัวอย่างการตรวจจับการฉ้อโกงอย่างง่าย จะป้อนธุรกรรมที่ผิดปกติให้ D3 และถามว่าควรตั้งธงเพื่อตรวจสอบหรือไม่

%%time
result = client.system_one(
    state="""
    A customer usually spends $20-100 in the US.
    A new $2,500 transaction was made from another country.
    """,
    questions={
        "suspicious": Noul(
            instructions="Should this transaction be flagged for fraud review?"
        )
    }
)

print(result.nouls["suspicious"].noul)ขับเคลื่อนโดย

เอาต์พุต:

0.9990723773071258
CPU times: user 1.89 ms, sys: 2.01 ms, total: 3.91 ms
Wall time: 87.4 msขับเคลื่อนโดย

D3 ส่งคืนความน่าจะเป็นประมาณ 99.9% บ่งชี้ว่าควรตั้งธงธุรกรรมนั้นเพื่อตรวจสอบ การอนุมานใช้เวลาประมาณ 87 มิลลิวินาที

ยังสามารถรวมทั้ง 3 ประเภทการตัดสินใจไว้ในคำขอเดียวได้ คราวนี้จะประเมินผู้สมัครงานและให้ D3 ระบุตำแหน่งที่เหมาะสมที่สุด ตรวจสอบคุณสมบัติ และให้คะแนนความเหมาะสม

%%time
result = client.system_one(
    state="""
    Candidate: 4 years of Python experience, 2 years working
    with machine learning, and strong SQL skills.
    No experience with frontend development.
    Available roles: Data Scientist, Backend Developer,
    Frontend Developer.
    """,
    questions={
        "role": Choice(
            instructions="Which role best matches the candidate?",
            criteria={
                "data_scientist": "Python, SQL, and machine learning",
                "backend": "Python, APIs, and backend systems",
                "frontend": "JavaScript, React, and UI development"
            }
        ),
        "qualified": Noul(
            instructions="Does the candidate meet the basic requirements for the best-matching role?"
        ),
        "fit": Score(
            instructions="How well does the candidate match the best-fitting role?",
            criteria=["Low", "Medium", "High"]
        )
    }
)

print("Best Role:", result.choices["role"].choice)
print("Qualified:", result.nouls["qualified"].noul)
print("Candidate Fit:", result.scores["fit"].score)ขับเคลื่อนโดย

เอาต์พุต:

Best Role: data_scientist
Qualified: 0.9446079177060042
Candidate Fit: 1.6421276950866912
CPU times: user 4.18 ms, sys: 3.11 ms, total: 7.29 ms
Wall time: 165 msขับเคลื่อนโดย

โมเดลระบุได้ถูกต้องว่า Data Scientist เหมาะสมที่สุด ให้ความน่าจะเป็นผ่านเกณฑ์ 94.5% และให้คะแนนความเหมาะสม 1.64 บนสเกล 0 ถึง 2 ทั้ง 3 การตัดสินใจส่งคืนภายใน 165 มิลลิวินาที

ตอนนี้เรามี D3 รันในเครื่องแล้ว มาสร้างแอปพลิเคชัน AI ใช้งานจริง 3 ตัวกัน

โปรเจกต์ที่ 1: สร้างเครื่องวิเคราะห์คุณภาพบล็อกด้วย D3 Mini

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

เราจะทดสอบกับบทความจริงคือ บทเรียน KTransformers ของเรา ซึ่งผู้เขียนเป็นคนเขียนเอง

1. ดึงข้อมูลบทเรียน KTransformers ของเรา

ก่อนอื่น จะใช้ Olostep Python SDK เพื่อดึงเนื้อหาบทความเป็น Markdown

from getpass import getpass
from olostep import Olostep

olostep = Olostep(api_key=getpass("Enter your Olostep API key: "))

url = "https://www.datacamp.com/tutorial/ktransformers-tutorial"
page = olostep.scrapes.create(
    url_to_scrape=url,
    formats=["markdown"]
)

content = page.result.markdown_content
print(content[:1000])ขับเคลื่อนโดย

Olostep ดึงบทความเป็น Markdown โดยคงหัวข้อ เนื้อความ และโค้ดตัวอย่างไว้เพื่อการวิเคราะห์

2. จัดหมวดหมู่และให้คะแนนบทความด้วย D3

ต่อไป จะใช้ Choice เพื่อระบุกลุ่มหัวข้อของบทความ และใช้ Score เพื่อประเมินคุณภาพด้านการสอนบนสเกล 5 ระดับ

%%time
result = client.system_one(
    state=content[:12000],
    questions={
        "category": Choice(
            instructions="What is the main topic of this article?",
            criteria={
                "ai": "Artificial intelligence and LLMs",
                "data_science": "Data science and analytics",
                "programming": "Software development",
                "other": "Other technical topics"
            }
        ),
        "quality": Score(
            instructions=(
                "Rate the article's educational quality based on "
                "clarity, technical depth, practical examples, "
                "and usefulness to readers."
            ),
            criteria=[
                "Very poor: Confusing and lacks useful information",
                "Poor: Limited depth and unclear explanations",
                "Average: Understandable but missing important details",
                "Good: Clear explanations and useful examples",
                "Excellent: Detailed, practical, and easy to follow"
            ]
        )
    }
)

category = result.choices["category"].choice
quality = result.scores["quality"].score + 1

print("Category:", category)
print(f"Quality: {quality:.1f}/5")ขับเคลื่อนโดย

เอาต์พุต:

Category: ai
Quality: 4.6/5
CPU times: user 3.29 ms, sys: 2.96 ms, total: 6.25 ms
Wall time: 1.11 sขับเคลื่อนโดย

D3 จัดหมวดหมู่บทความเป็น AI ได้ถูกต้อง และให้คะแนนคุณภาพ 4.6/5 โดยใช้เวลาวิเคราะห์ประมาณ 1.11 วินาที

โปรเจกต์ที่ 2: วิเคราะห์ภาพสินค้าด้วย D3 Mini

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

โค้ดด้านล่างใช้ vLLM System One API โดยตรง และอ่านผลลัพธ์จากฟิลด์ answers ที่ถูกต้อง

1. โหลดภาพสินค้า

เริ่มจากดาวน์โหลดภาพสินค้าตัวอย่าง แสดงในสมุดบันทึก และแปลงเป็น base64 เพื่อส่งให้โมเดล

import base64
import requests
from IPython.display import Image, display

image_url = "https://images.unsplash.com/photo-1542291026-7eec264c27ff?w=600"
image_data = requests.get(image_url, timeout=20).content

display(Image(data=image_data))ขับเคลื่อนโดย

image_base64 = base64.b64encode(image_data).decode()
image_input = f"data:image/jpeg;base64,{image_base64}"ขับเคลื่อนโดย

จะได้อินพุตภาพพร้อมส่งที่ D3 Mini วิเคราะห์ได้โดยตรง

2. วิเคราะห์ภาพด้วย D3 Mini

ต่อไป จะถาม D3 Mini พร้อมกัน 3 เรื่อง: สินค้าอยู่ในหมวดใด สินค้าเห็นได้ชัดเจนหรือไม่ และภาพเหมาะสมกับร้านออนไลน์เพียงใด

%%time
result = client.system_one(
    state="Review this product image for an online store.",
    images=[image_input],
    questions={
        "category": Choice(
            instructions="What product category is shown?",
            criteria={
                "footwear": "Shoes, sneakers, or boots",
                "clothing": "Shirts, jackets, or trousers",
                "electronics": "Electronic devices",
                "other": "Other products"
            }
        ),
        "product_visible": Noul(
            instructions="Is a physical product clearly visible?"
        ),
        "quality": Score(
            instructions="Rate the image suitability for an online store.",
            criteria=["Poor", "Average", "Good", "Excellent"]
        )
    }
)

print("Category:", result.choices["category"].choice)
print("Product Visible:", result.nouls["product_visible"].noul)
print("Image Quality:", result.scores["quality"].score)ขับเคลื่อนโดย

เอาต์พุต:

Product Category: footwear
Product Visibility: 97.11%
Image Quality: 2.30/3
CPU times: user 4.91 ms, sys: 952 μs, total: 5.86 ms
Wall time: 282 msขับเคลื่อนโดย

โมเดลระบุรายการเป็น footwear ยืนยันว่าสินค้ามองเห็นได้ชัดเจน และให้คะแนนคุณภาพของภาพที่ดี ภายในเพียง 282 มิลลิวินาที

โปรเจกต์ที่ 3: สร้างเครื่องวิเคราะห์การเคลื่อนไหวในวิดีโอด้วย D3 Mini

โปรเจกต์สุดท้ายจะสร้างเครื่องวิเคราะห์การเคลื่อนไหวย่อยๆ ด้วย D3 Mini แทนที่จะสร้างคำบรรยายวิดีโอที่ยาว เราจะให้โมเดลทำความเข้าใจว่าเกิดอะไรขึ้นในคลิปสั้น ระบุทิศทางการเคลื่อนไหว และตรวจจับการเปลี่ยนแปลงทางภาพ แนวทางนี้มีประโยชน์สำหรับการเฝ้าระวังวิดีโอ การตรวจจับเหตุการณ์ และการวิเคราะห์เนื้อหาอัตโนมัติ

1. ดาวน์โหลดวิดีโอตัวอย่าง

จะใช้วิดีโอตัวอย่างอย่างเป็นทางการของ D3 Mini จาก Hugging Face ก่อนอื่น ติดตั้งไลบรารีที่ต้องใช้:

%pip install huggingface_hubขับเคลื่อนโดย

ถัดไป ดาวน์โหลดวิดีโอตัวอย่างเพื่อวิเคราะห์ในเครื่อง

from huggingface_hub import hf_hub_download
from IPython.display import Video, display

video_path = hf_hub_download(
    repo_id="vllm-sr/d3-mini",
    filename="assets/example-video.mp4"
)ขับเคลื่อนโดย

วิดีโอแสดงกล่องที่เคลื่อนจากซ้ายไปขวา พร้อมเปลี่ยนสีจากน้ำเงินเป็นเขียว

2. วิเคราะห์วิดีโอ

ก่อนอื่น จะแปลงวิดีโอเป็นรูปแบบ base64 เพื่อส่งไปยังเซิร์ฟเวอร์ vLLM ในเครื่อง

import base64
import requests

with open(video_path, "rb") as f:
    video_base64 = base64.b64encode(f.read()).decode()

video_input = f"data:video/mp4;base64,{video_base64}"ขับเคลื่อนโดย

ตอนนี้จะใช้ System One API เพื่อถาม D3 Mini 2 คำถาม: สี่เหลี่ยมเคลื่อนที่ไปทิศทางใด และมันเปลี่ยนสีหรือไม่

%%time
response = requests.post(
    "http://localhost:8000/v1/systemone",
    json={
        "model": "vllm-sr/d3-mini",
        "state": "Analyze the movement of the object in this video.",
        "videos": [video_input],
        "questions": {
            "direction": {
                "type": "choice",
                "instructions": "Which direction does the square move?",
                "criteria": {
                    "left": "From right to left",
                    "right": "From left to right",
                    "still": "The square does not move"
                }
            },
            "color_change": {
                "type": "noul",
                "instructions": "Does the square change color during the video?"
            }
        }
    },
    timeout=120
)
response.raise_for_status()

answers = response.json()["answers"]

print("Movement:", answers["direction"]["choice"])
print(f"Color Change: {answers['color_change']['noul']:.1%}")ขับเคลื่อนโดย

เอาต์พุต:

Movement: right
Color Change: 93.7%
CPU times: user 3.01 ms, sys: 5.04 ms, total: 8.05 ms
Wall time: 723 msขับเคลื่อนโดย

D3 Mini ระบุทิศทางการเคลื่อนที่เป็น right ได้ถูกต้อง และให้ความน่าจะเป็น 93.7% สำหรับการเปลี่ยนสี เสร็จสิ้นการวิเคราะห์ภายในเพียง 723 มิลลิวินาที

ข้อคิดส่งท้าย

D3 Mini จัดการการจัดหมวดหมู่ การตรวจแบบใช่/ไม่ใช่ และการให้คะแนนได้ทั้งข้อความ ภาพ และวิดีโอบน GPU NVIDIA RTX 3090 เพียงตัวเดียว การตั้งค่า D3 ในเครื่องทำได้ง่ายกว่าที่คิด ปัญหาเดียวที่พบคือข้อผิดพลาด CUDA หน่วยความจำไม่พอ ซึ่งแก้ได้ด้วยการลดการใช้หน่วยความจำ GPU

นอกนั้นทุกอย่างทำงานได้ราบรื่น หากคุ้นเคยกับ vLLM อยู่แล้ว ก็น่าจะปรับแต่งการตั้งค่าให้ดียิ่งขึ้นได้

สิ่งที่ประทับใจที่สุดคือความเร็ว เวลาที่ใช้จริงมีตั้งแต่ 87 มิลลิวินาทีสำหรับการตัดสินใจข้อความสั้น ไปจนถึง 1.11 วินาทีสำหรับทั้งบทความ และตัวอย่างวิดีโอเสร็จใน 723 มิลลิวินาที ทั้งหมดนี้รันบน GPU ของตนเอง

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

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

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

หากสนใจเรียนรู้เพิ่มเติมเกี่ยวกับการทำงานกับโมเดลเปิด แนะนำให้ดูคอร์ส Working with Hugging Face ของเรา