vLLM D3 ट्यूटोरियल: Python के साथ लोकल AI निर्णय मॉडल चलाएँ

D3 खुले-वज़न वाले निर्णय मॉडलों का एक परिवार है, जो टेक्स्ट जनरेट करने के बजाय हर उत्तर के लिए प्रायिकता लौटाते हैं। आप अपने ही मशीन पर चल रहे मॉडल को एक ही अनुरोध में सपोर्ट टिकट का वर्गीकरण कर सकते हैं, किसी लेख को स्कोर दे सकते हैं, या किसी वीडियो क्लिप की जांच कर सकते हैं—हमारे परीक्षणों में यह सिर्फ 87 मिलीसेकंड तक में संभव था।

इस परिवार में 6 मॉडल शामिल हैं, जिनके पैरामीटर 600 मिलियन से 27 बिलियन तक हैं। आप छोटे मॉडलों पर साधारण हार्डवेयर में प्रयोग कर सकते हैं और अधिक मांग वाले कार्यों के लिए बड़े मॉडल इस्तेमाल कर सकते हैं। D3 Edge इतना हल्का है कि यह संगत स्मार्टफोनों पर भी चल सकता है।

vLLM अपने Structured Decisions फ्रेमवर्क के माध्यम से D3 को सपोर्ट करता है, जिससे आप कोई मॉडल लोकल रूप से सर्व कर सकते हैं और उसे एक सरल एप्लीकेशन प्रोग्रामिंग इंटरफ़ेस (API) के जरिए कॉल कर सकते हैं। व्यापक vLLM Semantic Router प्रोजेक्ट AI एप्लिकेशनों के लिए राउटिंग और निर्णय लेने की सुविधाएँ जोड़ता है।

इस ट्यूटोरियल में, मैं लोकल रूप से D3 सेटअप करना, 3 निर्णय प्रकार, और आपकी पहली प्रेडिक्शंस कवर करूंगा। इसके बाद, हम 3 व्यावहारिक प्रोजेक्ट बनाएंगे:

1. AI ब्लॉग क्वालिटी एनालाइज़र: वास्तविक आर्टिकल्स को वर्गीकृत और मूल्यांकन करने के लिए TypeSafe Python सॉफ्टवेयर डेवलपमेंट किट (SDK) और Olostep का उपयोग करें।
2. इमेज अंडरस्टैंडिंग: प्रोडक्ट इमेज का विश्लेषण करें, श्रेणियाँ पहचानें, और इमेज क्वालिटी का मूल्यांकन करें।
3. वीडियो अंडरस्टैंडिंग: छोटे वीडियो का विश्लेषण करें ताकि मूवमेंट और विज़ुअल बदलाव का पता चल सके।

अंत तक, आप जान लेंगे कि D3 को लोकल रूप से कैसे चलाना है और टेक्स्ट, इमेज और वीडियो में निर्णय लेने वाले एप्लिकेशन कैसे बनाने हैं। आप हमारे ये गाइड भी देख सकते हैं: बड़े भाषा मॉडल्स को लोकल रूप से चलाना और RTX 3090 GPU पर लोकल इन्फेरेंस को तेज़ करना।

संक्षेप में

• D3 खुले-वज़न निर्णय मॉडलों का परिवार है, जो टेक्स्ट बनाने के बजाय choice, yes/no (Noul), और score प्रश्नों के लिए प्रायिकताएँ लौटाते हैं।
• D3 Mini (4B) टेक्स्ट, इमेज और वीडियो संभालता है, और vLLM के साथ एक ही NVIDIA RTX 3090 ग्राफिक्स प्रोसेसिंग यूनिट (GPU) पर चलता है।
• आप vllm serve से मॉडल सर्व करते हैं और TypeSafe Python SDK या /v1/systemone एंडपॉइंट के जरिए कॉल करते हैं।
• हम 3 प्रोजेक्ट बनाते हैं: एक आर्टिकल क्वालिटी एनालाइज़र, एक प्रोडक्ट इमेज स्क्रीनर, और एक वीडियो मोशन एनालाइज़र।
• हमारे परीक्षणों में रिस्पॉंसेज़ 87 मिलीसेकंड से 1.11 सेकंड के बीच थे।

D3 निर्णय मॉडल क्या हैं?

D3 ऐसे खुले-वज़न वाले AI मॉडल्स का परिवार है जो टेक्स्ट जनरेट करने के बजाय निर्णय लेने के लिए बनाए गए हैं। किसी बड़े भाषा मॉडल (LLM) से यह पूछने के बजाय कि कोई ट्रांज़ैक्शन संदिग्ध है या नहीं, D3 सीधे यह प्रायिकता लौटाता है कि उसे रिव्यू की ज़रूरत है।

स्रोत: vllm-sr/d3-mini · Hugging Face

यह 3 निर्णय प्रकारों को सपोर्ट करता है:

D3 6 आकारों में आता है, 600 मिलियन से 27 बिलियन पैरामीटर तक, जो एज़ डिवाइस से लेकर हाई-एंड GPU तक सबके लिए उपयुक्त है। आप इस परिवार को Hugging Face पर Decision 3.0 कलेक्शन में ब्राउज़ कर सकते हैं।

मॉडल्स का मूल्यांकन निर्णय-केंद्रित बेंचमार्क्स पर होता है, जैसे Typed Decisions, जो वर्गीकरण सटीकता और प्रायिकता की गुणवत्ता मापते हैं।

इस ट्यूटोरियल के लिए, हम D3 Mini (4B) का उपयोग करेंगे क्योंकि यह टेक्स्ट, इमेज और वीडियो अंडरस्टैंडिंग सपोर्ट करता है और फिर भी इतना छोटा है कि लोकल NVIDIA RTX 3090 GPU पर चल सके।

vLLM के साथ D3 को लोकल रूप से कैसे चलाएँ

vLLM Semantic Router (vLLM SR) vLLM इकोसिस्टम में एक ओपन-सोर्स प्रोजेक्ट है जो AI एप्लिकेशनों को बुद्धिमान निर्णय लेने में मदद करता है। यह मॉडल राउटिंग, सेफ्टी चेक्स, सेमांटिक कैशिंग, और D3 जैसे विशेष निर्णय मॉडलों को सपोर्ट करता है। जहाँ vLLM मॉडल इन्फेरेंस संभालता है, वहीं vLLM SR फोकस करता है कि रिक्वेस्ट्स का मूल्यांकन और राउटिंग कैसे हो।

इस ट्यूटोरियल में, हम vLLM के नए Structured Decisions सपोर्ट का उपयोग करेंगे ताकि Semantic Router को इंस्टॉल किए बिना D3 Mini को लोकल रूप से चलाया जा सके। vLLM, D3 को System One API के जरिए सर्व करता है, जो तेज़, सहज "System 1" थिंकिंग के नाम पर रखा गया एक एंडपॉइंट है। यह टाइप्ड प्रश्नों का एक ही पास में उत्तर देता है और जनरेटेड टेक्स्ट के बजाय प्रायिकताएँ लौटाता है।

हम TypeSafe Python SDK का उपयोग करके मॉडल से कनेक्ट होंगे और देखेंगे कि यह वर्गीकरण, प्रायिकता अनुमान, और स्कोरिंग को कैसे संभालता है।

1. vLLM इंस्टॉल करें और D3 को लोकल रूप से चलाएँ

हम Ubuntu Linux, Python 3.12, और NVIDIA RTX 3090 GPU का उपयोग करेंगे। Windows उपयोगकर्ता Windows Subsystem for Linux 2 (WSL2) के जरिए Ubuntu इस्तेमाल करके साथ चल सकते हैं।

सबसे पहले, 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 का नाइटली बिल्ड इंस्टॉल करें, जिसमें नया 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. TypeSafe Python SDK से D3 से कनेक्ट करें

हाथ से 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"
)संचालित द्वारा

हम एक placeholder API कुंजी का उपयोग करते हैं क्योंकि लोकल सर्वर को होस्टेड 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% योग्यता प्रायिकता असाइन करता है, और 0 से 2 स्केल पर 1.64 का फिट स्कोर देता है। सभी 3 निर्णय सिर्फ 165 मिलीसेकंड में लौटे।

अब जब हमारे पास D3 लोकल रूप से चल रहा है, आइए इसे उपयोग करके 3 व्यावहारिक AI एप्लिकेशन बनाते हैं।

प्रोजेक्ट 1: D3 Mini के साथ AI ब्लॉग क्वालिटी एनालाइज़र बनाएँ

कल्पना करें कि आप एक तकनीकी प्रकाशन का प्रबंधन करते हैं, जहाँ दर्जनों लेख पब्लिश होने से पहले रिव्यू होने चाहिए। हर लेख को मैन्युअली पढ़ने के बजाय, हम एक 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. एक सैंपल वीडियो डाउनलोड करें

हम Hugging Face से आधिकारिक D3 Mini सैंपल वीडियो का उपयोग करेंगे। पहले आवश्यक लाइब्रेरी इंस्टॉल करें:

%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 टेक्स्ट, इमेज और वीडियो में वर्गीकरण, हाँ/ना चेक, और स्कोरिंग को एक ही NVIDIA RTX 3090 GPU पर संभालता है। D3 को लोकल रूप से सेटअप करना आश्चर्यजनक रूप से आसान था। मुझे केवल एक समस्या आई—CUDA out-of-memory त्रुटि—जिसे मैंने GPU मेमोरी खपत घटाकर ठीक किया।

इसके अलावा सब कुछ सुचारू रूप से चला। यदि आप पहले से vLLM से परिचित हैं, तो संभवतः आप सेटअप को और ऑप्टिमाइज़ कर सकते हैं।

जिस चीज़ ने मुझे सबसे अधिक प्रभावित किया, वह थी गति। दीवार समय 87 मिलीसेकंड (छोटे टेक्स्ट निर्णय) से 1.11 सेकंड (पूरा लेख) तक रहा, और वीडियो उदाहरण 723 मिलीसेकंड में समाप्त हुआ। यह सब मेरी अपनी GPU पर चला।

मेरा मानना है कि हम उस बिंदु पर पहुँच रहे हैं जहाँ पूरी टीम के लिए लोकल सर्वर पर निर्णय मॉडल चलाना व्यावहारिक होता जा रहा है। हर रिक्वेस्ट को बड़े रीजनिंग मॉडल की ज़रूरत नहीं होती।

कई दैनिक कार्यों के लिए, जैसे वर्गीकरण, राउटिंग, स्कोरिंग, और कंटेंट फ़िल्टरिंग, कोई छोटा निर्णय मॉडल काम कर सकता है। फिर आप महंगे रीजनिंग मॉडलों को उन्हीं कार्यों के लिए सुरक्षित रख सकते हैं, जिन्हें वास्तव में गहन विश्लेषण या विस्तृत व्याख्या की आवश्यकता होती है।

बेशक, प्रोडक्शन में उपयोग से पहले आप अपनी वर्कलोड्स पर सटीकता और प्रदर्शन का मूल्यांकन करना चाहेंगे। टेक्स्ट, इमेज, और वीडियो में D3 का परीक्षण करने के बाद, मेरा सरल नियम यह है: यदि कार्य वर्गीकरण, हाँ/ना चेक, या रेटिंग है, तो पहले D3 मॉडल आज़माएँ, और केवल तब रीजनिंग मॉडल पर जाएँ जब आपको व्याख्या की ज़रूरत हो।

यदि आप खुले मॉडलों के साथ काम करने के बारे में अधिक सीखने के इच्छुक हैं, तो मैं हमारे Working with Hugging Face कोर्स को देखने की सलाह देता हूँ।