Skip to content

Choice प्रश्न: तय विकल्पों में से एक चुनना ​

पिछले पाठ में सामग्री तैयार हो चुकी थी, इस पाठ में प्रश्न पूछना शुरू करेंगे। Jev Choice पाँच प्रश्न पूछने के तरीकों में पहला और सबसे सीधा है: आप विकल्प साफ़-साफ़ सूचीबद्ध करते हैं, Jev उनमें से एक चुनता है, हर विकल्प की प्रायिकता और समग्र विश्वास स्तर के साथ लौटाता है — उत्तर हमेशा आपके विकल्पों में से एक होता है, कोड में टेक्स्ट पार्स करने के लिए एक भी if लिखने की ज़रूरत नहीं।

असल में आप पहले अनुरोध में इसका उपयोग कर चुके हैं: route_ticket.py का department ही एक Choice था, जिसने technical चुना था। इस पाठ में इसे पूरी तरह समझाया जाएगा, कुल 10 मिनट।

सीखने के बाद आप क्या कर सकते हैं ​

  • criteria विकल्प map (विकल्प नाम → एक पंक्ति का विवरण) से एक पूरा Jev Choice प्रश्न लिखना, और जानना कि विकल्प का नाम और विवरण दोनों मॉडल को भेजे जाते हैं
  • लौटाए गए choice, probabilities, confidence तीन फ़ील्ड पढ़ना, और सबसे अधिक प्रायिकता वाले विकल्प को सीधे कोड शाखा में मैप करना
  • एक अनुरोध में समानांतर कई Choice प्रश्न पूछना (एक प्रश्न में अधिकतम 255 विकल्प), अनुमानित प्रश्नों के उत्तर उपयोग न हों तो नज़रअंदाज़ करना
  • सूची अधूरी हो सकती है तो other विकल्प जोड़ना, या आधिकारिक सलाह अनुसार एक साथी Noul फ़ॉलबैक कॉन्फ़िगर करना
  • «विकल्पों को फिर से क्रम में लगाकर दोबारा चलाकर» उत्तर की स्थिरता जाँचना — विकल्पों का क्रम उत्तर को प्रभावित कर सकता है

आपकी मौजूदा समस्या ​

  • GPT से टिकट वर्गीकृत करवाते हैं, लेकिन हर बार श्रेणी का नाम अलग लौटाता है — «रिफ़ंड» «रिटर्न-रिफ़ंड» «पैसे वापसी की माँग», डाउनस्ट्रीम if उसकी खुद की बनाई शब्दावली के पीछे कभी नहीं पहुँच पाता
  • जानना चाहते हैं कि वह कितना निश्चित है, तो सिर्फ़ «आप कितने निश्चित हैं» पूछ सकते हैं, जवाब में «मुझे लगता है काफ़ी संभावना है» जैसा गद्य मिलता है, जिसे कोड में नहीं लिखा जा सकता
  • एक टिकट पर कई बातें तय करनी होती हैं (किस समूह में जाए, क्या कारण है, ग्राहक क्या चाहता है), तीन अनुरोध क्रम से चलाना धीमा और महँगा है; एक prompt में ठूँसकर पूछें तो उत्तर एक-दूसरे में उलझ जाते हैं

यह तरीक़ा कब अपनाएँ ​

जब आपको चाहिए:

  • उत्तर आपके खुद तय किए विकल्पों का सेट हो: किस समूह में राउट करें, उत्पाद किस श्रेणी का है, कोड किस भाषा में लिखा गया है
  • उत्तर सीधे कोड शाखा बने — एक विकल्प एक पाथ, जनरेट किए टेक्स्ट से पार्स नहीं
  • एक ही सामग्री पर लगातार कई Choice प्रश्न पूछने हों, और सिर्फ़ एक अनुरोध भेजना हो

और नहीं चाहते:

  • मॉडल आपकी सूची से बाहर नए उत्तर खुद गढ़ ले
  • «यह टिकट किसका है» जैसे एक सेकंड के निर्णय के लिए लंबा prompt लिखना
  • मॉडल के निश्चित न होने पर भी उसे अपने आप चलने देना

🎒 शुरू करने से पहले की तैयारी ​

  • State स्थिति पूरा किया है: पता है कि सामग्री state में रखी जाती है (स्ट्रिंग, JSON ऑब्जेक्ट, टेक्स्ट ऐरे सब चलेंगे), निर्णय questions में लिखे जाते हैं
  • पहला अनुरोध चला चुके हैं: .venv में typesafe-sdk इंस्टॉल है, पर्यावरण चर TYPESAFE_API_KEY सेट है
  • याद हो कि route_ticket.py में department प्रश्न कैसा था — भूल गए हों तो वापस जाकर देख लें

मूल विचार ​

आधिकारिक एक-पंक्ति परिभाषा: उत्तर तय विकल्पों में से एक हो, तो Choice का उपयोग करें। दस्तावेज़ द्वारा दिए गए विशिष्ट प्रश्न: कौन-सी टीम यह टिकट संभाले, यह उत्पाद किस श्रेणी का है, यह कोड किस भाषा में लिखा गया है।

Choice के उपयोगी होने की जड़ एक कड़ी गारंटी है — उत्तर आपके दिए विकल्पों तक सीमित है:

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

एक Choice प्रश्न ऐसा दिखता है:

फ़ील्डक्या लिखेंविवरण
ID (प्रश्न की कुंजी)अपनी मर्ज़ी से, जैसे departmentकेवल आपके कोड में उपयोग होता है, मॉडल को नहीं भेजा जाता; उत्तर इसी से लिया जाता है
typeतय "choice"—
instructionsपूरा प्रश्नप्रश्न का पूरा भाग यहीं लिखें, ID से संदेश पहुँचाने की उम्मीद न रखें
criteriaविकल्प map: विकल्प नाम → विवरणविकल्प का नाम और विवरण दोनों मॉडल को भेजे जाते हैं; एक प्रश्न में अधिकतम 255 विकल्प

तीन प्रश्न-प्रकारों में कौन-सा चुनें (आधिकारिक मानदंड):

प्रश्न-प्रकारक्या उत्तर देता हैकोड में उपयोग
Choice (यह पाठ)तय विकल्पों में से कौन-सा चुनें, विकल्पों में कोई क्रम नहींएक विकल्प एक कोड पाथ
Scoreस्पेक्ट्रम पर किस हद तक, हर स्तर का विवरण आप दे सकते हैंसीमा पार होने पर, क्रमबद्ध करना
Noulसाफ़ हां-ना, प्रायिकता अपने आप में उपयोगीएक if

जवाब स्पेक्ट्रम है (कितना गंभीर, कितना गुस्सा) → Score; साफ़ हां-ना है (रिफंड का ज़िक्र हुआ या नहीं) → Noul। जब दोनों समान लगें, तो आधिकारिक सलाह है वह चुनें जिसका जवाब कोड द्वारा सीधे कार्रवाई किया जा सके: refund / rebook / information तीन विकल्प सीधे तीन कोड पथों पर मैप होते हैं, यही Choice का आकार है।

मेरे साथ करें ​

चरण 1: विकल्प map परिभाषित करें, अपना पहला Jev Choice प्रश्न लिखें ​

क्यों: एक Choice प्रश्न में केवल तीन फ़ील्ड होते हैं: type, instructions, criteria — विकल्प का नाम और विवरण दोनों मॉडल को भेजे जाते हैं, इसलिए विवरण ऐसे लिखें कि विकल्प एक-दूसरे से अलग हो जाएं।

आधिकारिक दस्तावेज़ का उदाहरण: एक ऑनलाइन जूता स्टोर का कस्टमर सपोर्ट टिकट, जिसमें पूछा जाता है कि किस टीम को निपटाना चाहिए। नया choice_first.py बनाएं:

python
# 运行前:export TYPESAFE_API_KEY="<你的API Key>"
from typesafe_sdk import Choice, TypeSafeClient

with TypeSafeClient() as client:
    response = client.system_one(
        state="My running shoes arrived in the wrong size. Can I swap them for a size 10?",
        questions={
            "department": Choice(
                instructions="Which team should handle this?",
                criteria={
                    "returns": "Exchanges, wrong or damaged items",
                    "shipping": "Delivery status, delays, lost packages",
                    "billing": "Charges, invoices, payment problems",
                },
            ),
        },
    )

    print(response.answers["department"].choice)

इसे चलाएं:

bash
.venv/bin/python choice_first.py

आपको यह दिखना चाहिए:

text
returns

जूते का साइज़ गलत, दूसरी जोड़ी चाहते हैं — यह returns टीम का काम है, आधिकारिक उदाहरण रिकॉर्ड करते समय मॉडल ने पूरा returns पर दांव लगाया।

criteria लिखने के तीन मुख्य बिंदु:

  • विकल्प का नाम ही उत्तर मान है। कोड में मिलने वाला choice विकल्प नाम की स्ट्रिंग है, स्थिर अंग्रेज़ी पहचानकर्ता इस्तेमाल करें (returns), बदल सकने वाला डिस्प्ले टेक्स्ट नहीं

  • विवरण का काम अलग करना है। आधिकारिक शब्द: विकल्प का नाम और विवरण दोनों मॉडल को भेजे जाते हैं, "इसलिए विवरण ऐसे लिखें कि विकल्प एक-दूसरे से अलग रहें।" जब नाम ही सब साफ़ कर देता है, तो विवरण में null दे सकते हैं (चरण 3 में तैयार उदाहरण है)

  • पूरी सूची दें, छोटी सूची नहीं। एक Choice में अधिकतम 255 विकल्प हो सकते हैं, विकल्प जोड़ने से केवल कुछ token अधिक लगते हैं — पहले छानकर कम करने के बजाय सभी टीमों, श्रेणियों, उत्पादों को मॉडल को दें

  • मैंने returns चलाकर पाया, और मैं जानता हूं कि यह मान criteria के विकल्प नामों से आया है

चरण 2: लौटाए गए choice, probabilities और confidence को समझें ​

क्यों: choice केवल वितरण का शिखर है; वास्तविक प्रोजेक्ट में आप संभवतः probabilities और confidence से शाखाएं लिखेंगे, केवल एक नाम लेने के बजाय।

चरण 1 के उस अनुरोध का पूरा लौटाया गया उत्तर (आधिकारिक उदाहरण):

json
{
  "model": "jev-1.13.0",
  "answers": {
    "department": {
      "type": "choice",
      "choice": "returns",
      "confidence": 1.0,
      "probabilities": {
        "shipping": 0.0,
        "returns": 1.0,
        "billing": 0.0
      }
    }
  },
  "usage": {
    "input_tokens": 328,
    "output_tokens": 34
  }
}

आपको यह दिखना चाहिए: उत्तर ऑब्जेक्ट में type के अलावा तीन और मान हैं, एक-एक करके देखें:

फ़ील्डइस उदाहरण में मानकैसे पढ़ें
choicereturnsसबसे अधिक प्रायिकता वाला विकल्प
probabilitiesreturns 1.0, बाकी 0.0सभी विकल्पों का वितरण, कुल मिलाकर लगभग 1; कुंजियां विकल्प नाम हैं
confidence1.0वितरण के आकार को एक 0–1 की संख्या में संकुचित करता है: सब एक विकल्प पर = 1, समान रूप से बिखरा हुआ = 0

तीन बातें जो याद रखने लायक हैं:

  • उत्तर हमेशा विकल्पों के भीतर होता है। तीन विकल्पों वाले प्रश्न में probabilities में केवल यही तीन कुंजियां होंगी — "मॉडल ने खुद चौथा जोड़ दिया" ऐसा होता ही नहीं
  • confidence केवल सबसे अधिक प्रायिकता देखता है। तीन विकल्पों का सूत्र (3 × 最大概率 − 1) / 2 है, इसलिए (0.6, 0.3, 0.1) और (0.6, 0.2, 0.2) दोनों का confidence 0.4 होता है। वितरण का आकार इस संख्या में कैसे गणना होता है और तीन स्तरों का उपयोग कैसे करें, Confidence विश्वास स्तर पाठ में विस्तार से
  • confidence वितरण का विवरण है, उत्तर सही होने की गारंटी नहीं। यह टिकट सरल था, प्रायिकता पूरी returns पर, तो confidence स्वाभाविक रूप से 1.0; एक ऐसा टिकट जिसमें गलत साइज़ भी हो और दो बार पैसे कटे हों, प्रायिकता returns और billing में बंट जाएगी, confidence गिर जाएगा — चरण 3 में ऐसा ही एक टिकट है

उदाहरण का "model": "jev-1.13.0" आधिकारिक उदाहरण रिकॉर्ड करते समय का संस्करण है; आप अब jev-latest से चलाएंगे, तो यह फ़ील्ड वर्तमान मॉडल संस्करण दिखाएगा।

  • मैं लौटाए गए उत्तर की ओर इशारा करके कह सकता हूं: choice शिखर है, probabilities वितरण है (कुल लगभग 1), confidence वितरण का आकार है

चरण 3: एक अनुरोध में पांच Choice प्रश्न पूछें (समानांतर मूल्यांकन) ​

क्यों: आधिकारिक सलाह है कि जितने Choice प्रश्न उपयोग हो सकते हैं उन्हें एक ही बार में पूछ लें: सभी प्रश्न एक ही state पर समानांतर, स्वतंत्र मूल्यांकन होते हैं — प्रश्न जोड़ने से प्रतिक्रिया समय लगभग नहीं बढ़ता, कोड बस उन उत्तरों को नज़रअंदाज़ कर दे जो काम नहीं आते।

इस बार एक ज़्यादा अस्पष्ट टिकट: दो हफ़्ते देरी, साइज़ गलत, और दो बार पैसे कटे — तीनों टीमें संबंधित लगती हैं, और ग्राहक ने कहा भी नहीं कि चाहिए क्या। आधिकारिक रूप से इस टिकट पर एक ही बार में पांच Choice प्रश्न पूछे गए:

python
# 运行前:export TYPESAFE_API_KEY="<你的API Key>"
from typesafe_sdk import Choice, TypeSafeClient

TRIAGE_QUESTIONS = {
    "department": Choice(
        instructions="Which team should handle this?",
        criteria={
            "returns": "Exchanges, wrong or damaged items",
            "shipping": "Delivery status, delays, lost packages",
            "billing": "Charges, invoices, payment problems",
        },
    ),
    "return_reason": Choice(
        instructions="If the customer wants to return something, why?",
        criteria={
            "wrong_size": "The item doesn't fit",
            "wrong_item": "A different product was delivered",
            "damaged": "The item arrived broken or faulty",
            "changed_mind": "The item is fine, the customer no longer wants it",
            "other": "A return reason that fits none of the above",
        },
    ),
    "shipping_issue": Choice(
        instructions="If this is a shipping problem, which kind is it?",
        criteria={
            "not_delivered": "The package never arrived",
            "delayed": "The package is late but still on the way",
            "wrong_address": "The package went to the wrong place",
            "damaged_in_transit": "The package arrived damaged",
            "other": "A shipping problem that fits none of the above",
        },
    ),
    "requested_resolution": Choice(
        instructions="What does the customer want to happen?",
        criteria={
            "exchange": "Swap the item for a different one",
            "refund": "Money back",
            "replacement": "The same item sent again",
            "information": "Just an answer, no action needed",
        },
    ),
    "tone": Choice(
        instructions="What is the customer's tone?",
        criteria={"calm": None, "frustrated": None, "angry": None},
    ),
}

ticket = "Shoes arrived two weeks late and in the wrong size. Also I see two charges of $120 on my card. What are you going to do about this?"

with TypeSafeClient() as client:
    response = client.system_one(state=ticket, questions=TRIAGE_QUESTIONS)

आपको यह दिखना चाहिए (आधिकारिक उदाहरण का लौटाया उत्तर, पांच उत्तर एक साथ; इस अनुरोध में कुल 589 इनपुट / 212 आउटपुट token):

प्रश्नchoiceconfidenceप्रायिकता मुख्य बिंदु
departmentreturns0.42returns 0.61, billing 0.35, shipping 0.04
return_reasonwrong_size1.0wrong_size 1.0, बाकी 0.0
shipping_issuedelayed0.67delayed 0.74, other 0.26
requested_resolutionrefund0.2refund 0.40, replacement 0.34, exchange 0.24
tonefrustrated0.76frustrated 0.84, angry 0.16

हर जवाब की आधिकारिक व्याख्या, एक-एक करके देखने लायक है:

  • department विभाजित हुआ: returns 0.61, billing 0.35—बार-बार पैसे कटने ने billing को तीस प्रतिशत से ज़्यादा संभावना दी। यह टिकट दो समूहों में फैला हुआ है, और 0.42 की confidence बताती है कि यही बात है
  • return_reason साफ़ है: «गलत साइज़» साफ़-साफ़ लिखा है, पूरा दांव wrong_size पर, confidence 1.0
  • shipping_issue एक speculative प्रश्न है: जवाब delayed और other के बीच बंटा है, लेकिन department बिलकुल भी shipping नहीं है—कोड इसे नज़रअंदाज़ कर देता है (चरण 4 में ऐसा ही किया गया है)
  • requested_resolution कम भरोसा: refund 0.40, replacement 0.34, exchange 0.24—बार-बार पैसे कटना लगता है पैसे वापसी की मांग, गलत साइज़ लगता है अदला-बदली की मांग, ग्राहक ने शुरू से आख़िर तक नहीं कहा कि कौन-सा चाहिए
  • tone का विवरण पूरी तरह null है: calm / frustrated / angry नाम खुद बोलते हैं, विवरण की ज़रूरत नहीं—यही वह मौका है जिसकी बात चरण 1 में कही गई थी: «भेद न लिख पाओ तो null दो»

ध्यान दें कि इन पाँच प्रश्नों में दो speculative प्रश्न (speculative) हैं: return_reason सिर्फ returns समूह में डालने पर काम आता है, shipping_issue सिर्फ shipping में डालने पर। पहले पूछ लो फिर ज़रूरत के हिसाब से इस्तेमाल करो—यही Jev का मानक तरीका है—आधिकारिक 13 प्रश्न बनाम 13 अनुरोधों के वास्तविक परीक्षण में 12.2 गुना सस्ता और 10.0 गुना तेज़, जवाब नहीं बदलते (विस्तार समानांतर प्रश्न पाठ में)। आधिकारिक स्मार्ट-होम demo इससे भी आगे जाता है: हर अनुरोध में लंबी Choice-प्रश्न सूची (श्रेणी, कमरा, डिवाइस, क्रिया) का कुल मिलाकर मूल्यांकन होता है, ज़्यादातर जवाब बेकार होते हैं, कोड सिर्फ ज़रूरी कुछ ही लेता है।

चरण 4: choice, probabilities और confidence से रूटिंग शाखाएँ लिखो ​

क्यों: जवाब सब टाइप किए गए मान हैं—choice सीधे कोड पथ पर मैप होता है, कम भरोसा हो तो मानव के पास भेजो, दूसरे नंबर के विकल्प की संभावना सीमा पार करे तो CC करो। एक अनुरोध, पाँच जवाब, बाकी सब साधारण if।

चरण 3 के बाद जुड़ा आधिकारिक पूरा रूटिंग कोड:

python
def triage(ticket: str) -> None:
    with TypeSafeClient() as client:
        response = client.system_one(
            state=ticket,
            questions=TRIAGE_QUESTIONS,
        )
    answers = response.answers

    department = answers["department"]
    if department.confidence < 0.3:
        # Not clear which team to send to. Let a person decide.
        send_to_manual_triage(ticket)
        return

    if department.choice == "returns":
        # return_reason answer is only used here
        assign(ticket, team="returns", issue=answers["return_reason"].choice)
    elif department.choice == "shipping":
        # shipping_issue answer is only used here
        assign(ticket, team="shipping", issue=answers["shipping_issue"].choice)
    else:
        assign(ticket, team="billing")

    # A second team with a real share of the probability gets a copy
    for team, probability in department.probabilities.items():
        if team != department.choice and probability > 0.25:
            notify(ticket, team=team)

    resolution = answers["requested_resolution"]
    if resolution.confidence < 0.5:
        # The customer hasn't said what they want. Ask, don't guess.
        ask_customer_what_they_want(ticket)
    elif resolution.choice == "refund":
        flag_for_refund_approval(ticket)

    if answers["tone"].choice == "angry":
        flag_for_senior_agent(ticket)

(assign / notify / send_to_manual_triage आदि उदाहरण-स्वरूप फ़ंक्शन हैं, अपनी रूटिंग लॉजिक लगा लो।)

तुम्हें यह दिखना चाहिए—चरण 3 वाले टिकट के लिए आधिकारिक तौर पर दिया गया व्यवहार:

text
assigned to returns team with issue wrong_size
billing team notified (0.35 > 0.25)
customer asked what they want (confidence 0.20 < 0.5)

तीनों गेट मान आधिकारिक उदाहरण से हैं: 0.3 (इससे कम पर समूह तक तय नहीं होता, मानव के पास भेजो), 0.25 (दूसरे नंबर के विकल्प की संभावना का हिस्सा, सीमा पार करे तो CC), 0.5 (ग्राहक की मांग पर पकड़, इससे कम पर अंदाज़ा न लगाकर पूछो)। shipping_issue का जवाब शुरू से आख़िर तक नहीं पढ़ा गया—speculative प्रश्न का मतलब यही है।

«इरादे का वर्गीकरण + भरोसे का गेट» से पूरा रूटिंग सिस्टम बनाना (नियत लॉजिक / विशेषज्ञ LLM / मानव—तीन स्तरीय बंटवारा), स्मार्ट रूटिंग पाठ में विस्तार से।

  • मैं इस टिकट के लिए समझा सकता हूँ: billing को CC क्यों किया गया, ग्राहक से क्यों पूछा गया, shipping_issue काम क्यों नहीं आया

चरण 5: सूची अधूरी होने पर दो फ़ॉलबैक: other विकल्प और साथी Noul ​

क्यों: विकल्पों की सूची हर इनपुट को ढक नहीं सकती—ग्राहक ने कोई ऐसी मांग रखी जो तुमने सोची नहीं थी, मॉडल को दिए गए विकल्पों में से किसी एक पर मजबूरन टिक लगाना पड़ेगा। आधिकारिक तौर पर दो फ़ॉलबैक दिए गए हैं।

फ़ॉलबैक एक: other विकल्प। आधिकारिक सलाह: सूची शायद सारे इनपुट न ढक सके, तो एक other या none of the above विकल्प जोड़ो, ताकि मॉडल कह सके «इनमें से कोई नहीं»। चरण 3 के return_reason, shipping_issue दोनों में other विकल्प है, विवरण में लिखा है कि यह «कोई न फबे तो निकास» है।

फ़ॉलबैक दो: साथी Noul (आधिकारिक तौर पर ज़्यादा पसंदीदा)। आधिकारिक तौर पर संकेत है कि none of the above कई परिदृश्यों मेंज़रूरी नहीं कि अच्छा काम करे; विकल्प यह है कि उसी अनुरोध में एक Noul जोड़ो जो तय करे «कोई विकल्प मेल खाता है या नहीं», जैसे:

text
Choice: यह मांग किस श्रेणी में आती है?
Noul  : क्या `message` में `our_products` में से कोई भी उल्लेख हुआ है?

कोड सिर्फ तब Choice का जवाब पढ़ता है जब Noul yes हो—मेल न खाए तो पूरा समूह छोड़ दो। यही लाइव चैट फ़िल्टर का तरीका है: हर मैसेज पर एक अनुरोध, तीन प्रश्न, न फबे तो सीधे पास कर दो। Noul खुद अगले पाठ में।

तुम्हें यह दिखना चाहिए: दोनों फ़ॉलबैक को नए अनुरोध की ज़रूरत नहीं—other यानी criteria में एक विकल्प ज़्यादा, साथी Noul यानी उसी questions में एक प्रश्न ज़्यादा, दोनों मिलाकर अब भी «एक अनुरोध» की हद में हैं।

  • मैं बता सकता हूँ कि दोनों फ़ॉलबैक कब-कब इस्तेमाल होते हैं: सूची में कभी-कभार कोई छूट जाए तो other जोड़ो; «बिलकुल न फबे तो भी रुक जाए» चाहिए तो साथी Noul लगाओ

चेकपॉइंट ✅ ​

  • मेरा criteria विकल्पों का map है (नाम → विवरण), मुझे पता है कि दोनों मॉडल को भेजे जाते हैं, प्रश्न ID नहीं
  • मुझे पता है कि जवाब दिए गए विकल्पों के भीतर ही होगा, probabilities सारे विकल्पों को ढकता है, कुल लगभग 1
  • मुझे पता है कि एक अनुरोध में कई प्रश्न समानांतर में, आत्मनिर्भर मूल्यांकन; speculative प्रश्न का जवाब कोड इस्तेमाल न करे तो काफ़ी
  • मुझे पता है कि confidence सिर्फ सबसे ऊँची संभावना देखती है (तीन विकल्पों पर (3×最大概率−1)/2), यह बंटवारे का विवरण है, सही होने की गारंटी नहीं
  • मैंने दो सेल्फ़-चेक याद रखे: विकल्प फिर से क्रम में लगाकर संगति जाँचो; बस सबसे अच्छा चुनना हो तो सीधे सबसे ऊँची संभावना लो

सावधानी की याद दिलाना ​

❌ दो विकल्पों के विवरण अलग नहीं हो पाते ​

लक्षण: return_policy / return_status जैसे पर्यायवाची विकल्प—टिकट में return, refund दोनों आते हैं, मॉडल दोनों के बीच झूलता रहता है, confidence ऊपर नहीं चढ़ती।

ग़लती क्यों: विकल्प का नाम और विवरण दोनों मॉडल को भेजे जाते हैं। जब दोनों विवरण एक ही तरह के इनपुट की ओर इशारा करते हैं, तो मॉडल के पास तुलना का आधार नहीं होता, संभावना बंटकर दांव लगनी पड़ती है।

सही तरीका: विवरण में सीमा पक्की लिखो—यह विकल्प क्या संभालता है, क्या नहीं संभालता (पड़ोसी विकल्प का काम)। आधिकारिक तौर पर return_policy / return_status के लिए यही लिखा गया है: हर विवरण साफ़ कहता है «whether and how an item can be returned» की सीमा, तुलनात्मक उदाहरण जोड़ने के बाद आधिकारिक उदाहरण को return_status, confidence 1.0 मिला। और ज़्यादा लिखना हो तो विकल्प का मान सीधे ऑब्जेक्ट रखो (देखो: उन्नत तरीकों का पहला)।

❌ क्रम बदलो, जवाब बदल जाता है ​

लक्षण: criteria के तीन विकल्पों का क्रम बदलो, जवाब साथ में बदल गया।

ग़लती क्यों: यह आधिकारिक सावधानी-पुस्तिका (jev-1.13 पर लागू) में दर्ज जाना हुआ विफलता मोड है—Choice के विकल्पों का क्रम जवाब को प्रभावित करता है, और मॉडल आगे वाले विकल्पों की ओर झुकता है।

सही तरीका: आधिकारिक तौर पर बस एक वाक्य—«विकल्पों का क्रम बदलो, फिर चलाओ, जाँचो कि जवाब संगत हैं»। इसे लॉन्च से पहले का नियत सेल्फ़-चेक मानो, खासकर कम विकल्पों और छोटे विवरणों वाले प्रश्नों पर। पूरी विफलता-मोड सूची के लिए देखो Jev 1.13 सावधानी-पुस्तिका।

❌ Choice का उपयोग करके मॉडल से अपना जवाब खुद लिखवाना ​

लक्षण: instructions में लिखा है "इस संदेश में कौन-सी तारीख का उल्लेख है", और उम्मीद है कि मॉडल तारीख भर देगा।

यह गलत क्यों है: Jev कोई जनरेटिव मॉडल नहीं है; टेक्स्ट जनरेट करने के लिए ट्रेन किया गया मॉडल LLM का काम है। ओपन-वैल्यू पूछने का तरीका दोनों तरफ से नुकसान देता है: मॉडल कुछ गढ़ भी नहीं सकता (जवाब विकल्पों तक सीमित है), और आपने उसे चुनने के लिए कोई विकल्प भी नहीं दिए हैं।

सही तरीका: अगर जवाब का स्पेस सीमित है तो उसे विकल्पों के रूप में enumerate करें। तारीख इसका सबसे सटीक उदाहरण है: वर्ष, माह, दिन के लिए अलग-अलग Choice—महीने केवल बारह होते हैं, दिन अधिकतम इकतीस—और हर एक में एक "उल्लेख नहीं है" विकल्प जोड़ें, ताकि गायब हिस्सों की ईमानदारी से रिपोर्ट हो न कि अंदाजा लगाया जाए। कोड इन हिस्सों को असली तारीख में जोड़ता है और सारी तुलना व गणना संभालता है। वैल्यू एक्स्ट्रैक्शन का पूरा तरीका (regex से candidates ढूंढना, Jev से सही वाला चुनना) देखें वैल्यू एक्स्ट्रैक्शन में।

❌ हर जगह confidence थ्रेशोल्ड लगाना ​

लक्षण: हर जवाब पर, हर ब्रांच पर एक confidence थ्रेशोल्ड, जो लगातार बढ़ता जा रहा है और tune नहीं हो पा रहा।

यह गलत क्यों है: आधिकारिक Agent Skill की सामान्य समस्याओं की सूची ने इस आदत को नाम से उठाया है—जब केवल सबसे अच्छा विकल्प चुनने की परवाह हो, तो सीधे सबसे अधिक संभावना वाला ले लें, हर जगह confidence थ्रेशोल्ड लगाने की जरूरत नहीं; जब सच में statistical algorithm की जरूरत हो, तो इस्तेमाल करें probabilities।

सही तरीका: राउटिंग ब्रांच के लिए choice; डिस्ट्रीब्यूशन एनालिसिस के लिए probabilities; confidence थ्रेशोल्ड केवल "अपने आप execute करना चाहिए या नहीं" जैसे महत्वपूर्ण गेट पर लगाएं (चरण 4 का 0.3 / 0.5 ठीक ऐसा ही है), और उसे जोखिम के साथ scale करें—पूरी method Confidence कॉन्फिडेंस पाठ में।

एडवांस्ड तकनीकें (वैकल्पिक) ​

🔧 जब विकल्प एक लाइन में न लिखे जा सकें, object का उपयोग करें। जब दो-तीन विकल्प बार-बार उलझते हों और एक लाइन की description सीमा साफ न कर पाती हो, तो description की जगह object रखें: एक फील्ड बताए कि यह विकल्प क्या कवर करता है, एक बताए कि वह क्या नहीं संभालता, एक में कुछ उदाहरण दें। return_policy / return_status के लिए आधिकारिक तरीका (Playground से सीधे भेजा गया raw request, रिस्पॉन्स है return_status, confidence 1.0):

आधिकारिक structured criteria उदाहरण (raw JSON)
json
{
  "state": "I sent the shoes back a week ago. When do I get my money?",
  "questions": {
    "return_topic": {
      "type": "choice",
      "instructions": {
        "question": "Which returns topic is the customer asking about?",
        "focus": "Classify the information the customer wants."
      },
      "criteria": {
        "return_policy": {
          "what": "Whether and how an item can be returned",
          "not_for": "Progress of a return already sent",
          "examples": [
            "Can I return shoes I've worn once?",
            "How long do I have to return an order?"
          ]
        },
        "return_status": {
          "what": "Progress of a return already sent",
          "not_for": "Whether and how an item can be returned",
          "examples": [
            "Has my return arrived yet?",
            "When will my refund be paid?"
          ]
        }
      }
    }
  }
}

दो बातें: instructions को भी इस तरह structure किया जा सकता है (question + focus); फील्ड नाम what / not_for / examples तीनों API के reserved words नहीं हैं, ये आप खुद रखते हैं—मॉडल फील्ड के नाम और वैल्यू दोनों देखता है, फील्ड का नाम ऐसा छोटा शब्द रखें जो बताता है कि नीचे क्या labeled है।

🔧 गहरी कैटेगरी ट्री: एक-एक परत पर पूछें। जब कैटेगरी बहुत गहरी हो (पेटेंट वर्गीकरण, रिटेल कैटलॉग, सोर्स कोड रिपॉजिटरी का डायरेक्टरी ट्री), तो Choice को चेन में जोड़ें: हर परत का जवाब तय करता है कि अगली request में कौन-से विकल्प दिए जाएंगे। आधिकारिक hierarchical classification cookbook इसके ऊपर beam search चलाता है—Choice के probabilities से हर परत के सबसे अच्छे K candidate paths रखते हुए, न कि हर परत पर केवल एक पर दांव लगाते हुए। पूरा तरीका देखें गहरी hierarchical classification में।

🔧 SDK को छोड़कर सीधे API से जुड़ें। POST https://api.typesafe.ai/v1/systemone, request body के top-level तीन फील्ड state / model / questions, department प्रश्न का raw JSON कुछ ऐसा दिखता है:

json
{
  "model": "jev-latest",
  "state": "My running shoes arrived in the wrong size. Can I swap them for a size 10?",
  "questions": {
    "department": {
      "type": "choice",
      "instructions": "Which team should handle this?",
      "criteria": {
        "returns": "Exchanges, wrong or damaged items",
        "shipping": "Delivery status, delays, lost packages",
        "billing": "Charges, invoices, payment problems"
      }
    }
  }
}

फील्ड constraints की पूरी परिभाषा (criteria में कम से कम 1, अधिकतम 255 विकल्प, जवाब के चार फील्ड) देखें API क्विक रेफरेंस में।

इस पाठ का सारांश ​

✅ Jev Choice का तरीका: criteria विकल्पों का map (नाम → एक लाइन की description; अधिकतम 255), जवाब हमेशा आपके विकल्पों में आता है, कोड को टेक्स्ट parse नहीं करना पड़ता।

✅ तीन रिटर्न फील्ड साथ पढ़ें: choice सबसे अधिक संभावना वाला विकल्प है, probabilities सभी विकल्पों का डिस्ट्रीब्यूशन है, confidence डिस्ट्रीब्यूशन के आकार का एक अकेला नंबर है।

✅ एक request में कई प्रश्न parallel, स्वतंत्र मूल्यांकन; speculative प्रश्न पहले पूछें, कोड जरूरत पड़ने पर इस्तेमाल करे—13 प्रश्नों को एक request में मिलाकर परखने पर वास्तव में 12.2 गुना सस्ता और 10.0 गुना तेज।

✅ सूची अधूरी हो सकती है: other exit जोड़ें, या साथ में एक Noul सवाल रखें जो पूछे "कोई मिलता-जुलता है या नहीं"।

मुख्य कॉन्फिगरेशन फील्ड की समीक्षा:

फील्डअनुशंसित तरीकाविवरण
type"choice"निश्चित वैल्यू
instructionsपूरा प्रश्नID मॉडल को नहीं भेजा जाता, प्रश्न पूरा लिखें
criteriaविकल्पों का map: नाम → एक लाइन में distinguish करने वाली descriptionनाम self-explanatory हो तो description null दें; पूरी सूची दें, छोटी shortlist नहीं
जवाब तक पहुंचresponse.answers["id"].choice.probabilities, .confidence के साथ मिलाकर पढ़ें

Choice को असली परिदृश्यों में इस्तेमाल होते देखें: गहरी hierarchical classification (Choice की probabilities से beam search चलाकर कैटेगरी ट्री पार करना), लाइव चैट फ़िल्टर (एक संदेश, एक request, तीन प्रश्न), स्मार्ट राउटिंग (Choice से intent classification, confidence से गेटिंग)।

अगले पाठ की झलक ​

निश्चित विकल्पों के दूसरे छोर पर "किस हद तक" है: Score स्कोरिंग प्रश्न: आपकी परिभाषित स्केल पर अंक देना।

आप सीखेंगे:

  • criteria को विकल्पों के map से बदलकर ordered levels की सूची बनाना, level नंबर ही array index होता है
  • score दो levels के बीच भी आ सकता है (जैसे 1.43), इसे probability distribution के साथ मिलाकर पढ़ना होता है
  • बहु-आयामी निर्णय को कई Score प्रश्नों में तोड़ना, कोड में normalized weighted merge करना
  • कब Choice को Score से बदलना चाहिए
gaodong.aiAboutPrivacyContact

Independent tutorials, not affiliated with any product mentioned. Product names and trademarks belong to their owners. Check official pages for prices and policies.