Skip to content

कंपोजिट स्कोरिंग: जटिल निर्णय को एटमिक स्कोर में तोड़कर वेटेड करें ​

पिछले पाठ की स्मार्ट राउटिंग एक Score से जटिलता आँकती थी, जिसका उत्तर था «क्या इस उत्तर को ऑटोमैटिक चलाने की हिम्मत है»। यह पाठ दूसरे सवाल का उत्तर देता है: आपके सामने एक समूह है, कई मानदंडों पर सर्वश्रेष्ठ X चुनने हैं—रिज़्यूमे स्क्रीनिंग, टिकट ग्रेडिंग, सर्च री-रैंकिंग, सब इसी श्रेणी में आते हैं।

आधिकारिक तौर पर इसका नाम रखा गया: Composite scoring (कंपोजिट स्कोरिंग)। तरीका एक वाक्य में: जटिल निर्णय को स्वतंत्र आयामों में तोड़ें, हर आयाम का अपना Score, फिर आपके कोड में नियंत्रित वेट से मर्ज करें। आधिकारिक पैटर्न पेज का केस इंजीनियरिंग पद की रिज़्यूमे स्क्रीनिंग है: 4 आयाम, एक रिक्वेस्ट, दो वेट सेट, दो रैंकिंग। पूरा 10 मिनट।

असल में आप इसका न्यूनतम संस्करण पहले लिख चुके हैं: Score पाठ के चरण 5 में तीन प्रश्नों से टिकट प्राथमिकता 0.66 निकाली थी। यह पाठ उन तीन वेटेड पंक्तियों को पूर्ण रैंकिंग सिस्टम में विस्तारित करता है—बहु-कैंडिडेट, बहु-रोल, साथ ही «रैंकिंग अपेक्षित न हो तो क्या करें» की डीबगिंग विधि।

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

  • Jev कंपोजिट स्कोरिंग से «यह कैंडिडेट अच्छा है या नहीं» जैसे बहु-आयामी निर्णय को तोड़ें: चार आयामों के लिए एक-एक एटमिक Score, एक ही रिक्वेस्ट में समानांतर स्वतंत्र स्कोर
  • नॉर्मलाइज़्ड वेटेड मर्ज कोड लिखें: हर प्रश्न को उच्चतम स्तर संख्या से भाग देकर 0–1 पर लाएँ, फिर वेट से योग करें—आधिकारिक scoring.py जस का तस उपयोग किया जा सकता है
  • एक ही एटमिक स्कोर सेट से दो रोल संभालें: Senior IC वेट 0.40/0.10/0.40/0.10, Engineering Manager वेट 0.15/0.40/0.20/0.25, एक बार स्कोरिंग से दो रैंकिंग
  • रैंकिंग अपेक्षित न हो तो सिर्फ वेट स्थिरांक बदलकर लोकल में दोबारा गणना करें, पैमाना और prompt न छुएँ; आयाम जोड़ना हो तो प्रश्न शब्दकोश में एक प्रश्न जोड़ें, हर कैंडिडेट की रिक्वेस्ट संख्या नहीं बदलती
  • कंपोजिट स्कोरिंग और पिछले पाठ के गेटिंग का बँटवारा समझाएँ: गेटिंग तय करती है «उपयोग करें या नहीं», कंपोजिट स्कोरिंग तय करती है «कैसे रैंक करें»

आपकी मौजूदा दुविधा ​

  • मैंने बड़े मॉडल से रिज़्यूमे छँटने को कहा, prompt में लिखा «कृपया तकनीकी गहराई, टीम संभालना, आर्किटेक्चर, विस्तार मिलाकर 1–10 स्कोर दें»। उसने एक निबंध और एक 7.5 लौटाया, अगले महीने दोबारा चलाने पर 8.2 हो गया—न वितरण, न आधार। हायरिंग मैनेजर पूछे «यह 7.5 कैसे निकला», मैं बस निबंध पढ़कर सुना सकता था
  • रैंकिंग ग़लत हो तो सिर्फ prompt बदलें: «आर्किटेक्चर क्षमता को ज़्यादा महत्व दें» एक वाक्य जोड़ें, 200 रिज़्यूमे सब दोबारा चलें, तकनीकी गहराई वाले लोगों की रैंकिंग भी बिगड़ जाती है। मैं नहीं बता सकता कि भाषा असर कर रही है या मॉडल की इस बार हालत अलग है
  • Senior IC पद और Engineering Manager पद के लिए दो तरह के लोग चाहिए, मैंने दो prompt लिखकर अलग-अलग चलाए—एक ही कैंडिडेट दोनों रैंकिंग में दर्जनों स्थान अलग, और दोनों स्कोर में कोई तुलनात्मकता नहीं

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

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

  • कई मानदंडों पर एक समूह को रैंक करके शीर्ष X चुनना: रिज़्यूमे स्क्रीनिंग, टिकट प्राथमिकता, कंटेंट गुणवत्ता ग्रेडिंग, सर्च परिणाम री-रैंकिंग
  • रैंकिंग मानदंड बार-बार बदलते हैं, या अलग पदों, अलग परिदृश्यों का अलग ज़ोर है: वेट बदलें तो रैंकिंग बदले, रिक्वेस्ट दोबारा न भेजें
  • कुल स्कोर खोलकर समझाया जा सके: हर आयाम का कितना स्कोर, वेट का कितना हिस्सा, सब कोड में साफ़

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

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

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

  • पढ़ चुके हैं कुशल वर्कफ़्लो: चार आर्किटेक्चर पैटर्न, जानते हैं कंपोजिट स्कोरिंग चार आधिकारिक पैटर्न में कहाँ बैठती है (लाभ अंकन: लागत, विश्वसनीयता, गति)
  • लिख सकते हैं Score स्कोरिंग प्रश्न: यह पाठ पूरा उसी पर टिका है—पैमाना कैसे लिखें, स्कोर दो स्तरों के बीच क्यों गिर सकता है, वह पाठ के चरण 1, 3 में बताया गया; चरण 5 का तीन-प्रश्न प्राथमिकता उदाहरण इस पाठ का न्यूनतम संस्करण है
  • चला चुके हैंपहली रिक्वेस्ट: .venv में typesafe-sdk इंस्टॉल है, TYPESAFE_API_KEY पर्यावरण चर में मौजूद है
  • याद हैसमानांतर प्रश्न का निष्कर्ष: कई प्रश्न एक ही state पर समानांतर, स्वतंत्र मूल्यांकन, प्रश्न जोड़ने से रिस्पॉन्स टाइम लगभग नहीं बढ़ता (इस पाठ के 4 प्रश्न एक बार में लौटना इसी पर टिका है)

मूल विचार ​

पहले तोड़ें, फिर जोड़ें। Composite scoring की आधिकारिक परिभाषा मूल शब्दों में:

Break a complex judgment into atomic scores, combine with weights you control in code. (एक जटिल निर्णय को एटमिक स्कोर में तोड़ें, और अपने कोड में नियंत्रित वेट से मर्ज करें।)

इसकी ज़रूरत कब पड़ती है? आधिकारिक उद्घाटन: हमें अक्सर कई मानदंडों पर एक समूह को रैंक करना पड़ता है। कंपोजिट स्कोरिंग इसी काम का सबसे सरल विभाजन है—निर्णय को स्वतंत्र आयामों में तोड़ें, हर आयाम अलग स्कोर, कोड में वेटेड मर्ज।

आधिकारिक पैटर्न पेज रिज़्यूमे स्क्रीनिंग से पूरा उदाहरण देता है (इंजीनियरिंग भर्ती, अंत में शीर्ष X मैनुअल दोबारा जाँच के लिए), पूरी पाइपलाइन ऐसी दिखती है:

text
candidate resume (कैंडिडेट रिज़्यूमे)
   │  एक रिक्वेस्ट: रिज़्यूमे + 4 Score प्रश्न
   ▼
┌──────────────────────────────────────┐
│ python_depth    (Python गहराई)      │ ← 4 सवाल समानांतर, स्वतंत्र मूल्यांकन
│ team_leadership (टीम का नेतृत्व का अनुभव)   │
│ system_design   (सिस्टम डिज़ाइन)       │
│ generalist      (बहु-कौशल स्तर)      │
└──────────────────────────────────────┘
   │  एक रिस्पॉन्स में: 4 एटमिक स्कोर, प्रत्येक 0–4 की सीमा में
   ▼
0–1 में नॉर्मलाइज़ करें (प्रत्येक सवाल ÷ 4, यह आपके कोड में किया जाए)
   ├─ Senior IC वेट: 40% Python + 10% टीम का नेतृत्व + 40% डिज़ाइन + 10% बहु-कौशल → ic_score
   └─ EM वेट:       15% Python + 40% टीम का नेतृत्व + 20% डिज़ाइन + 25% बहु-कौशल → em_score
   ▼
कुल स्कोर से रैंक करें, हर रोल के लिए टॉप X चुनें

एक ही बड़े सवाल से LLM से क्यों न पूछें कि «यह व्यक्ति कुल मिलाकर कितना अच्छा है»?

तुलना का आयामLLM prompt से संयुक्त स्कोरिंगJev संयुक्त स्कोरिंग
रिटर्न फ़ॉर्मैटएक छोटा निबंध जिसमें एक 7.5 हो, फ़ॉर्मैट अनिश्चितप्रत्येक आयाम के लिए एक टाइप्ड score (0–4) + probabilities + confidence
कई मानदंडसब एक ही संयुक्त स्कोर में ठूँसे हुएहर मानदंड के लिए एक सवाल, एक स्वतंत्र स्कोर
रैंकिंग मानदंड बदलनाprompt की भाषा बदलें, पूरा दोबारा चलाएँ, पुनरुत्पादन योग्य नहींकोड में वेट कॉन्स्टेंट बदलें, तुरंत दोबारा गणना
बहु-रोल रैंकिंगहर रोल के लिए एक prompt सेट और फिर से चलाएँवही एटमिक स्कोर, वेट बदलते ही नई रैंकिंग
व्याख्या-योग्यता«मॉडल को अच्छा लगा»प्रत्येक आयाम का स्कोर + वेट, सब कोड में दिखाई देते हैं

आधिकारिक how-to मैनुअल «सवाल तोड़ने» को पूरी गाइड का सबसे महत्वपूर्ण कॉन्सेप्ट मानता है: व्यापक सवाल कई निर्णयों को एक ही उत्तर के पीछे छिपा देते हैं; एटमिक सवाल निर्णयों को उजागर करते हैं, तभी आप उन्हें जाँच, ट्यून और कोड में मिला सकते हैं (docs/concepts/how-to-build-with-system-one.md:108)।

पिछले दो पाठों से संबंध: समानांतर प्रश्न ट्रांसपोर्ट लेयर है—4 सवाल एक ही रिक्वेस्ट से वापस मिलते हैं; स्मार्ट राउटिंग का गेटिंग बताता है «क्या इस उत्तर का इस्तेमाल करने की हिम्मत है»; संयुक्त स्कोरिंग बताती है «इस पूरे सेट को कैसे रैंक करें»। आधिकारिक पैटर्न टेबल में इसका लाभ Cost, Reliability, Speed दर्ज है—चार पैटर्न में एकमात्र जो तीनों को एक साथ रखता है (docs/patterns.md:19)।

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

चरण 1: «अच्छा कैंडिडेट» को चार एटमिक Score सवालों में तोड़ें ​

क्यों: «यह कैंडिडेट अच्छा है या नहीं» असल में कई निर्णय एक साथ जुड़े हुए हैं: Python की पकड़, टीम का नेतृत्व, सिस्टम डिज़ाइन, विषयों की चौड़ाई। एक ही सवाल में ठूँसने पर आप नहीं जान सकते कि किस आयाम ने स्कोर गिराया, और आप केवल एक आयाम अकेले भी नहीं बदल सकते। इसे तोड़ना, आगे की हर चीज़ की शर्त है।

ये चार सवालों की परिभाषाएँ आधिकारिक पैटर्न पेज के Playground से ली गई हैं (रेंडर किए पेज से निकाली गईं, instructions और criteria आधिकारिक मूल पाठ हैं):

python
from typesafe_sdk import Score

RESUME_QUESTIONS = {
    "python_depth": Score(
        instructions="How much depth of python experience does this candidate have, based on the supplied resume?",
        criteria=[
            "No Python experience mentioned",
            "Mentioned but no detail",
            "Used in projects, some specifics",
            "Primary language, multiple projects",
            "Deep expertise: architecture, performance, libraries",
        ],
    ),
    "team_leadership": Score(
        instructions="How much experience does this candidate have managing or leading engineering teams?",
        criteria=[
            "No management experience mentioned",
            "Informal mentorship or tech lead role",
            "Led a small team or project",
            "Managed a team with direct reports",
            "Managed multiple teams or an engineering org",
        ],
    ),
    "system_design": Score(
        instructions="How much experience does this candidate have designing large-scale or distributed systems?",
        criteria=[
            "No architecture work mentioned",
            "Contributed to design discussions",
            "Designed components of a larger system",
            "Owned architecture of a significant system",
            "Designed systems at scale across multiple domains",
        ],
    ),
    "generalist": Score(
        instructions="How much evidence is there that this candidate picks up unfamiliar tools, roles, or domains outside their core specialty?",
        criteria=[
            "Only one domain or role mentioned",
            "Some variety but within a narrow field",
            "Worked across a few different areas or tech stacks",
            "Regularly moved between domains, wore many hats",
            "Track record of ramping up in unfamiliar areas and delivering",
        ],
    ),
}

तीन बारीकियाँ:

  • एक सवाल, एक आयाम। «एक सवाल से कई चीज़ें नापना» वह गड्ढा है जिसका Score पाठ ने नाम लिया है: लेवल के विवरण में एक बार «समयनिष्ठ, तेज़, अनुभवी» लिख दिया तो एक आयाम ऊँचा और दूसरा नीचा वाला इनपुट कहीं नहीं रखा जाता, confidence गिरती है, स्कोर का अर्थ धुँधला हो जाता है। चार सवाल साफ़-साफ़ तोड़ें, हर एक सिर्फ़ एक चीज़ देखे
  • हर लेवल एक परिस्थिति है, डिग्री नहीं। «Primary language, multiple projects» को रिज़्यूमे से मिलाया जा सकता है, «अच्छी पकड़» को नहीं—मॉडल सिर्फ़ विवरण से state मिलाता है, लेवल नंबर और पड़ोसी लेवल वह नहीं देखता। Score पाठ में प्रयोग हुआ: प्योर नंबर स्केल पर confidence 0.33 आई, परिस्थिति-विवरण स्केल पर 1.0
  • लेवल संख्या = जितने दर्जे आप साफ़ बता सकते हैं। आधिकारिक रूप से यहाँ प्रति सवाल 5 लेवल हैं; Score पाठ का सिद्धांत है कि जितने लेवल बता सकें उतने ही रखें, अधिकतम 10 लेवल, 3 लेवल भी ठीक है—जिस लेवल का विवरण साफ़ न लिख सकें, उसे न जोड़ें

आपको यह दिखना चाहिए: RESUME_QUESTIONS में चार Score, हर एक सिर्फ़ एक आयाम नापता है, प्रत्येक में 5 लेवल का परिस्थिति-स्केल—Python गहराई, टीम का नेतृत्व, सिस्टम डिज़ाइन, बहु-कौशल, आपस में मिले हुए नहीं। सवालों के ID (python_depth जैसे) आपने खुद रखे हैं, वे मॉडल को नहीं भेजे जाते, उत्तर उसी ID से वापस आते हैं।

  • मेरा हर सवाल सिर्फ़ एक आयाम नापता है, और हर लेवल एक मिलाने-योग्य परिस्थिति-विवरण है

चरण 2: एक रिक्वेस्ट से समानांतर में चार एटमिक स्कोर वापस लें ​

क्यों: चारों आयाम एक-दूसरे पर निर्भर नहीं हैं—पिछले पाठ में कहा गया, स्वतंत्र सवाल एक ही रिक्वेस्ट में जुड़ने चाहिए: समानांतर मूल्यांकन से रिस्पॉन्स टाइम लगभग नहीं बढ़ता, बस थोड़े सवाल token ज़्यादा लगते हैं। चार सवाल तोड़कर भी चार रिक्वेस्ट की कीमत न देना, संयुक्त स्कोरिंग के «लागत» लाभ का स्रोत है।

resume_screen.py बनाएँ, चरण 1 की सवाल-परिभाषाएँ जोड़ें, और एक रिज़्यूमे भेजकर देखें:

python
from typesafe_sdk import TypeSafeClient

# RESUME_QUESTIONS 的定义见第 1 步,此处省略

resume = """
Jane Doe — Backend Engineer, 8 years
- Primary language Python; built and own the retry and backoff layer
  of a 40-node distributed ingestion pipeline (2M events/day)
- Tech lead of a 4-person payments squad for 2 years; no direct reports
- Contributed to architecture reviews across the org
- Backend infrastructure only; one year on an internal CLI tool
"""

with TypeSafeClient() as client:
    response = client.system_one(
        state=resume,
        questions=RESUME_QUESTIONS,
    )

for qid in ["python_depth", "team_leadership", "system_design", "generalist"]:
    answer = response.answers[qid]
    print(qid, answer.score, answer.confidence)

इसे चलाएँ:

bash
.venv/bin/python resume_screen.py

(आधिकारिक Playground उदाहरण में सिर्फ़ 4 सवाल हैं और रिज़्यूमे state नहीं दिया गया, यह रिज़्यूमे टेक्स्ट इस पाठ के लिए स्वयं बनाया गया टेस्ट इनपुट है।)

आपको यह दिखना चाहिए: चार 0–4 के बीच के नंबर, प्रत्येक के साथ 0–1 की confidence। इस स्वनिर्मित रिज़्यूमे के हिसाब से पढ़ें: Python मुख्य भाषा और कई प्रोजेक्ट → python_depth ऊँचा; tech lead लेकिन direct reports नहीं → team_leadership बीच में; सिर्फ़ आर्किटेक्चर चर्चा में हिस्सा → system_design मध्यम-निम्न; लगभग सिर्फ़ बैकएंड → generalist निम्न। स्कोर दो लेवल के बीच भी आ सकता है (जैसे 1.5)—यह probability-वेटेड औसत स्थिति है, जाँच का तरीका Score पाठ के चरण 3 में। सटीक नंबर आपके वास्तविक रिस्पॉन्स पर निर्भर हैं, Jev वर्शन के साथ बदल सकते हैं।

मुख्य अवलोकन: चारों आयाम स्वतंत्र—एक कैंडिडेट पूरी तरह Python में 3.8 और टीम के नेतृत्व में 0.5 पा सकता है। संयुक्त सवाल में ये दो सिग्नल एक-दूसरे को पतला कर देते, तोड़ने के बाद हर एक साफ़-साफ़ दिखता है।

💡 चीनी रिज़्यूमे भी स्कोर हो सकते हैं, लेकिन पहले कैलिब्रेट करें

आधिकारिक बताता है कि अंग्रेज़ी मुख्य ट्रेनिंग भाषा है और सबसे सटीक, चीनी समेत अन्य भाषाएँ चलती हैं लेकिन कम सटीक हैं (docs/models.md)। चीनी रिज़्यूमे लाइव करने से पहले, मैन्युअली ग्रेड की गई रिज़्यूमे का एक बैच चलाएँ, ध्यान से देखें कि हर आयाम की confidence का वितरण कैसा है—जो लेवल चीनी में अलग नहीं हो पाता, उस लेवल का परिस्थिति-विवरण बढ़ाएँ।

  • साफ़ रिज़्यूमे पर चारों आयामों के स्कोर मिले; फोकस अलग वाला रिज़्यूमे लगाने पर हर आयाम का स्कोर स्वतंत्र रूप से बदला

चरण 3: Jev संयुक्त स्कोरिंग का वेटेड मर्ज कोड लिखें ​

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

आधिकारिक पैटर्न पेज का scoring.py जैसा है वैसा ही नीचे:

python
py      = response.answers["python_depth"].score / 4
lead    = response.answers["team_leadership"].score / 4
arch    = response.answers["system_design"].score / 4
general = response.answers["generalist"].score / 4

# Senior IC
ic_score = (0.40 * py) + (0.10 * lead) + (0.40 * arch) + (0.10 * general)

# Engineering Manager
em_score = (0.15 * py) + (0.40 * lead) + (0.20 * arch) + (0.25 * general)

तीन तरीके से पढ़ें:

  • / 4 नॉर्मलाइज़ेशन है। हर सवाल 5 लेवल का है, सबसे ऊँचा लेवल नंबर 4 है, पूरा भाग देने पर सब कुछ 0–1 में आता है। सामान्य रूप है «सबसे ऊँचे लेवल नंबर len(criteria) - 1 से भाग दें»——Score पाठ के चरण 5 का normalized() यही सामान्य रूप है। इस पाठ के चारों सवाल एक ही लेवल के हैं, देखकर लगता है कि आलस्य करके भाग छोड़ सकते हैं, लेकिन आधिकारिक तौर पर फिर भी भाग दिया जाता है——नॉर्मलाइज़ेशन को एक जैसा लिखने से भविष्य में किसी आयाम का पैमाना लंबा या छोटा होने पर मर्ज कोड को बदलने की ज़रूरत नहीं पड़ती
  • वेट का मतलब ही उत्पाद का रुख है। Senior IC: Python गहराई और सिस्टम डिज़ाइन में से प्रत्येक 0.40, टीम का नेतृत्व केवल 0.10; Engineering Manager: टीम का नेतृत्व 0.40 अकेले सबसे बड़ा। दोनों वेट सेट का योग 1.00 है, इसलिए कुल स्कोर अब भी 0–1 में रहता है, और दोनों रैंकिंग के बीच सीधे तुलना की जा सकती है
आयामSenior ICEngineering Manager
python_depth0.400.15
team_leadership0.100.40
system_design0.400.20
generalist0.100.25
  • पहले नॉर्मलाइज़ करें फिर वेट लगाएँ, क्रम उलटा नहीं हो सकता। वेट का अर्थ 0–1 पैमाने पर टिका है: 0.40 का Python ठीक 0.20 सिस्टम डिज़ाइन का दोगुना है——जब स्कोर नॉर्मलाइज़ नहीं होते, यह कथन सही नहीं रहता

आपको दिखना चाहिए: ic_score और em_score में से प्रत्येक 0–1 के बीच की एक संख्या है। चरण 2 वाले रिज़्यूमे के लिए, IC कुल स्कोर EM कुल स्कोर से ऊँचा होना चाहिए——यह रिज़्यूमे Python में मज़बूत है, टीम नेतृत्व में कमज़ोर, और टीम नेतृत्व EM के वेट में अकेले 0.40 है।

  • मेरा मर्ज कोड पहले नॉर्मलाइज़ करता है (÷ सबसे ऊँचा लेवल नंबर) फिर वेट से गुणा करता है, दोनों वेट सेट का योग 1.00 है

चरण 4: एक ही बैच के एटॉमिक स्कोर से, दो वेट सेट से दो रैंकिंग ​

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

python
WEIGHTS = {
    "senior_ic": {
        "python_depth": 0.40, "team_leadership": 0.10,
        "system_design": 0.40, "generalist": 0.10,
    },
    "eng_manager": {
        "python_depth": 0.15, "team_leadership": 0.40,
        "system_design": 0.20, "generalist": 0.25,
    },
}


def composite(answers, weights: dict) -> float:
    """归一化后按权重合并;算式与官方 scoring.py 一致。"""
    total = 0.0
    for question_id, weight in weights.items():
        top_level = len(RESUME_QUESTIONS[question_id].criteria) - 1
        total += weight * answers[question_id].score / top_level
    return total


def fetch_scores(resumes: dict) -> dict:
    """每个候选人一次请求,拿回四个原子分数。"""
    raw = {}
    with TypeSafeClient() as client:
        for name, resume in resumes.items():
            response = client.system_one(state=resume, questions=RESUME_QUESTIONS)
            raw[name] = response.answers
    return raw


CANDIDATES = {
    "jane": resume,  # 第 2 步那份简历;再放两三份不同侧重的简历
    # "li": ...,
    # "sam": ...,
}

raw = fetch_scores(CANDIDATES)

ic_rank = sorted(raw, key=lambda n: composite(raw[n], WEIGHTS["senior_ic"]), reverse=True)
em_rank = sorted(raw, key=lambda n: composite(raw[n], WEIGHTS["eng_manager"]), reverse=True)

print("Senior IC 榜:", ic_rank)
print("EM 榜:", em_rank)

(मर्ज सूत्र आधिकारिक scoring.py से मद-दर-मद मेल खाता है; fetch_scores लूप और सॉर्टिंग इस पाठ में जोड़ा गया साधारण Python है। हर उम्मीदवार एक अनुरोध, 4 सवाल समानांतर——आधिकारिक RAG cookbook के «हर सेगमेंट एक अनुरोध» जैसी ही लय।)

आपको दिखना चाहिए: दोनों रैंकिंग एक ही बैच के एटॉमिक स्कोर से आई हैं——fetch_scores केवल एक बार चला, EM इस दूसरे रोल ने कोई नया API कॉल नहीं किया। अगर कोई उम्मीदवार Python में बहुत गहरा है पर कभी टीम नहीं संभाली, तो वह IC रैंकिंग में आगे और EM रैंकिंग में पीछे दिखेगा; टीम नेतृत्व का अनुभव गहरा रखने वाला उम्मीदवार इसका उलटा है। यही वह है जो दोनों प्रॉम्प्ट को अलग-अलग चलाना कभी नहीं दे सकता: दोनों रैंकिंग एक ही मापन सेट पर आधारित हैं, अंतर केवल वेट से आता है।

  • मेरे दूसरे रोल (EM) ने दूसरा अनुरोध ट्रिगर नहीं किया——स्कोर उसी बैच के रिस्पॉन्स से लिए गए

चरण 5: रैंकिंग अपेक्षा के अनुरूप न हो तो केवल वेट बदलें, प्रॉम्प्ट को नहीं ​

क्यों: आधिकारिक रूप से इस कोड का सारांश दो परतों में है: यह आपको कुल स्कोर से रैंक करने देता है, «लेकिन उससे भी महत्वपूर्ण, यह आपको दिखाता है कि कुल स्कोर आख़िर कैसे निकला»; जब सबसे ऊँचे रैंक वाला उम्मीदवार अपेक्षा से मेल नहीं खाता, «आप सही संतुलन खोजने के लिए वेट एडजस्ट कर सकते हैं»। वेट आपके हैं——यह मूल वाक्य (The weights are yours) आधिकारिक primitives दस्तावेज़ और Score दस्तावेज़ में एक-एक बार आता है: जब संयोजित परिणाम आपकी टीम के मानक से मेल नहीं खाता, कोड में वेट बदलें, दोबारा चलाएँ।

डिबगिंग परिदृश्य एक बार चलाकर देखें। हायरिंग मैनेजर ने IC रैंकिंग देखी: «टीम संभालने वाले लोग बहुत नीचे रैंक पर हैं।»

python
# 改权重前:python 0.40 / lead 0.10 / arch 0.40 / general 0.10
WEIGHTS["senior_ic"] = {
    "python_depth": 0.35, "team_leadership": 0.20,
    "system_design": 0.35, "generalist": 0.10,
}

# 原子分数已经在 raw 里,直接重算——不用再发任何请求
ic_rank = sorted(raw, key=lambda n: composite(raw[n], WEIGHTS["senior_ic"]), reverse=True)

तीन तरह के एडजस्टमेंट, लागत के क्रम में कम से ज़्यादा आज़माएँ:

एडजस्टमेंटलागतप्रभाव की सीमा
वेट कॉन्स्टेंट बदलेंशून्य API कॉल (स्कोर पहले से हाथ में हैं, लोकल पुनर्गणना)केवल इसी रैंकिंग पर असर
एक आयाम जोड़ें (जैसे संचार क्षमता)हर उम्मीदवार के लिए अनुरोध दोबारा चलाना होगा——लेकिन हर उम्मीदवार फिर भी केवल एक अनुरोध, आधिकारिक मूल वाक्य «The call count stays at one»इस स्कोर सेट का उपयोग करने वाली सभी रैंकिंग नए आयाम को साझा करती हैं
पैमाने की भाषा (criteria) बदलेंसभी उम्मीदवारों के लिए दोबारा चलाना, नए-पुराने स्कोर तुलनीय नहींसभी मौजूदा स्कोर रद्द

आपको दिखना चाहिए: वेट बदलने के बाद, ic_rank तुरंत एक नई रैंकिंग निकालता है——raw में एक भी संख्या नहीं बदली, क्योंकि सवाल में एक शब्द नहीं हिला। यही है «कोएफ़िशिएंट बदलो, प्रॉम्प्ट नहीं»: पुनरुत्पादन योग्य, ऑडिट योग्य, रोलबैक योग्य (वेट वापस करो, रैंकिंग वापस आ जाती है)।

  • मैं «वेट बदलना» को रैंकिंग डिबगिंग का पहला उपाय मानता हूँ, पैमाने की भाषा बदलना आख़िर में

चेकपॉइंट ✅ ​

  • मैं Jev संयोजित स्कोरिंग के दो चरण बता सकता हूँ: हर आयाम का एक एटॉमिक Score, एक अनुरोध समानांतर में स्कोर लेता है; कोड में नॉर्मलाइज़ करने के बाद वेट से मर्ज किया जाता है
  • मैं जानता हूँ कि पहले नॉर्मलाइज़ क्यों: अलग-अलग पैमानों के पूर्ण अंक अलग होते हैं (तीन लेवल का पूर्ण अंक 2, पाँच लेवल का पूर्ण अंक 4), सबसे ऊँचे लेवल नंबर len(criteria) - 1 से भाग देने पर ही एक ही पैमाने पर आते हैं, तभी वेट अपना शाब्दिक अर्थ व्यक्त करते हैं
  • मेरे वेट कोड के कॉन्स्टेंट हैं, योग 1.00; रैंकिंग अपेक्षा के अनुरूप न हो तो पहले वेट बदलकर लोकल पुनर्गणना करें, नया अनुरोध नहीं
  • एक ही बैच के एटॉमिक स्कोर से मैंने IC, EM दो रैंकिंग निकालीं, दूसरे रोल के लिए शून्य अतिरिक्त API कॉल
  • रैंक करते समय मैं हर आयाम का confidence भी देखता हूँ: कम भरोसे वाले उम्मीदवारों को समीक्षा के लिए चिह्नित किया जाता है, ज़बरदस्ती रैंक नहीं

सावधानी सूचना ​

❌ एक ही सवाल में पूछना «कुल मिलाकर अच्छा है या नहीं» ​

प्रॉम्प्ट में लिखा है «कृपया इस उम्मीदवार का समग्र मूल्यांकन करें, 1–10 अंक दें», कई निर्णय एक ही उत्तर में भरे हैं। आधिकारिक how-to मैनुअल इसे पूरी गाइड का सबसे महत्वपूर्ण अवधारणा मानता है:

व्यापक सवाल कई निर्णयों को एक ही उत्तर के पीछे छिपा देते हैं; एटॉमिक सवाल इन निर्णयों को सामने लाते हैं, तभी आप उन्हें जाँच, ट्यून और कोड में मर्ज कर सकते हैं।

एक समग्र सवाल से आप नहीं जान सकते कि किस आयाम ने स्कोर गिराया, और केवल एक आयाम भी नहीं बदल सकते। सही तरीका: एक आयाम के लिए एक Score——इस पाठ के चरण 1 के चार सवाल ही प्रतिमान हैं।

❌ नॉर्मलाइज़ किए बिना सीधे वेट लगाना ​

तीन-स्तरीय स्केल का पूर्णांक 2, पाँच-स्तरीय का 4 — नॉर्मलाइज़ न करें तो जिस आयाम में स्तर ज़्यादा हैं वह स्वाभाविक रूप से फ़ायदा उठाता है, और आपके लिखे 0.40 का वास्तविक प्रभाव 0.40 से कहीं ज़्यादा हो सकता है। अधिकारिक Score दस्तावेज़ में इस पर ख़ास ज़ोर दिया गया है: पहले अधिकतम स्तर संख्या से भाग दें, फिर मिलाएँ, तब "वेट्स अपने शाब्दिक अर्थ में ही अर्थ रखते हैं" (Then the weights mean what they say) — 0.6 का severity ठीक 0.3 के frustration का दोगुना होता है। इस पाठ के चारों प्रश्न एक ही स्तर के हैं, / 4 बेकार लगता है, फिर भी अधिकारिक रूप से यही लिखा है — यह भविष्य में स्केल लंबे या छोटे होने से बचाव के लिए है।

❌ रैंकिंग ग़लत लगे तो स्केल की भाषा बदलने जाएँ ​

स्केल बदलते ही स्कोर का अर्थ बदल जाता है: सभी उम्मीदवारों के पुराने स्कोर बेकार हो जाते हैं, पूरा दोबारा चलाना पड़ता है, और पुरानी-नई रैंकिंग की सीधे तुलना भी नहीं हो सकती। अधिकारिक सुझाया तरीका है "कोड में वेट बदलें, दोबारा चलाएँ" — शून्य लागत, तुरंत जाँच योग्य, केवल एक रैंकिंग प्रभावित (चरण 5 की लागत सारणी)। भाषा बदलना अंतिम उपाय है: केवल जब किसी आयाम का confidence व्यवस्थित रूप से कम हो (स्तर आपके वास्तविक डेटा पर अलग न बन पाते हों) तभी लौटकर स्केल बदलें, और Score पाठ की विधि से ज्ञात नमूनों पर नया स्केल सत्यापित करें।

❌ केवल कुल स्कोर देखना, आयामों का confidence न देखना ​

कुल स्कोर चार आयामों को एक संख्या में समेट देता है, कम-विश्वास वाले आयाम का स्कोर उसमें छिपा रह जाता है। किसी उम्मीदवार के system_design का confidence केवल 0.3 है (स्तर ओवरलैप करते हैं, या रिज़्यूमे में जानकारी कम है), तब भी उसका कुल स्कोर निकल आता है — लेकिन इस कुल स्कोर से यह तय करना कि वह इंटरव्यू में जाएगा या नहीं, अविश्वसनीय आधार है। Confidence के तीन स्तरीय अधिकारिक उपयोग रैंकिंग पर भी लागू होते हैं: उच्च → सीधे अपनाएँ; मध्यम → समीक्षा हेतु चिह्नित करें; निम्न → इस आयाम को निर्णय में शामिल न करें, मानव को भेजें। तीन स्तरों की पूरी व्याख्या Confidence कॉन्फ़िडेंस पाठ में है।

उन्नत तकनीकें (वैकल्पिक) ​

वेटेड मर्ज केवल Score के लिए नहीं है। अधिकारिक how-to मैनुअल के खंड 7 का उदाहरण तीन Noul की संभावनाओं को प्रायिकता-वेट से मिलाकर एक गुणवत्ता स्कोर बनाता है — Noul तो पहले से ही 0–1 की प्रायिकता है, नॉर्मलाइज़ेशन तक की ज़रूरत नहीं पड़ती:

python
answers = response.answers

# Combine independent signals into one application-specific score.
quality = (
    0.4 * answers["answers_request"].noul
    + 0.4 * answers["citations_are_supported"].noul
    + 0.2 * (1 - answers["contradicts_context"].noul)
)

(अधिकारिक कोड जैसा है, docs/concepts/how-to-build-with-system-one.md। ध्यान दें कि तीसरा सिग्नल 1 - noul लेता है: संदर्भ से विरोधाभास की प्रायिकता जितनी कम, गुणवत्ता स्कोर उतना अधिक।)

मशीन से वेट सिखाना। वेट हमेशा हाथ से छाँटने की ज़रूरत नहीं। अधिकारिक दस्तावेज़ के उसी खंड में उन्नत मार्ग दिया गया है: प्रत्येक प्रश्न की probabilities को फ़ीचर मानकर, डाउनस्ट्रीम के क्लासिकल मशीन लर्निंग मॉडल को संयोजन विधि सिखाएँ; लेबल न हों तो महँगे रीज़निंग मॉडलों के एक समूह को ensemble की तरह इस्तेमाल करके लेबल बनाएँ। अधिकारिक AutoResearch cookbook (autoresearch_feature_discovery, अभी अलग पृष्ठ नहीं है) पूरा तरीक़ा दिखाता है: autoresearch लूप TypeSafe प्रश्न सुझाता है, मुक्त पाठ को संख्यात्मक फ़ीचर में बदलता है, एक CatBoost रिग्रेसर प्रशिक्षित करता है, और मॉडल की त्रुटि से वापस प्रश्न सुधारता है।

वास्तविक परिदृश्यों में सिग्नल संयोजन। "कई सिग्नल, कोड में मर्ज" का विचार व्यावहारिक पाठों में हर जगह है:

  • RAG अनुच्छेद जाँच: प्रत्येक पुनर्प्राप्त अनुच्छेद पर 4 Noul प्रश्न (प्रासंगिक है क्या, प्रमाण है क्या, प्रस्तावना से विरोधाभास है क्या, इंजेक्शन है क्या), और कोड तय करता है कि कौन-से answering model के संदर्भ में जाएँगे। अधिकारिक रूप से स्पष्ट कहा गया है: चारों में से एक भी प्रश्न "इसे शामिल करें या नहीं" नहीं पूछता — वह निर्णय कोड में है, मानक बदलना एक संख्या बदलना है, प्रश्न फिर से लिखना नहीं
  • खोज और मिलान: रीरैंकिंग शुद्ध रैंकिंग रूप है — प्रत्येक क्वेरी-उम्मीदवार जोड़ी पर एक Noul, प्रायिकता से क्रमबद्ध; अधिकारिक परीक्षण में top-1 हिट 5%→18%; एंटिटी अलाइनमेंट 1 Score और 3 Noul का संयुक्त निर्णय है

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

✅ Jev संयुक्त स्कोरिंग = अधिकारिक Composite scoring पैटर्न: जटिल निर्णय को प्रति आयाम एक परमाणु Score में तोड़ें, एक ही अनुरोध में समानांतर प्राप्त करें, कोड में नॉर्मलाइज़ और वेटेड मर्ज करें — अधिकारिक लाभ अंकन Cost, Reliability, Speed है, चार पैटर्नों में एकमात्र जो तीनों पर खरा उतरता है।

✅ वेट ही उत्पाद निर्णय है: Senior IC 0.40/0.10/0.40/0.10, Engineering Manager 0.15/0.40/0.20/0.25 — वही परमाणु स्कोर, दो वेट सेट, दो रैंकिंग, दूसरी भूमिका के लिए शून्य अतिरिक्त अनुरोध।

✅ व्याख्या-योग्यता सबसे बड़ा लाभ है: कुल स्कोर कैसे बना, हर आयाम का स्कोर और वेट सब कोड में दिखता है; रैंकिंग अपेक्षित न लगे तो पहले वेट बदलकर स्थानीय रूप से पुनर्गणना करें — पुनरुत्पादन योग्य, रोलबैक योग्य।

✅ आयाम जोड़ने से अनुरोध नहीं बढ़ते: प्रश्न शब्दकोश में एक प्रश्न जोड़ें, प्रत्येक उम्मीदवार के लिए कॉल संख्या फिर भी 1 रहती है — अधिकारिक शब्दों में "The call count stays at one"।

मुख्य तथ्यों की त्वरित सूची:

विषयमानस्रोत
पैटर्न एक पंक्ति मेंCombine several dimensions of analysis into a single scoredocs/patterns.md
पैटर्न परिभाषाBreak a complex judgment into atomic scores, combine with weights you control in codedocs/patterns/composite-scoring.md
चार प्रश्नpython_depth / team_leadership / system_design / generalist, प्रत्येक 5-स्तरीय स्केलअधिकारिक Playground (patterns/composite-scoring, रेंडर किए पृष्ठ से निकाला गया)
नॉर्मलाइज़ेशनscore ÷ (len(criteria) − 1), इस उदाहरण में प्रति प्रश्न ÷ 4docs/primitives/score.md
IC वेटPython 0.40 / टीम का नेतृत्व 0.10 / डिज़ाइन 0.40 / सर्वांगीण 0.10docs/patterns/composite-scoring.md (scoring.py)
EM वेटPython 0.15 / टीम संचालन 0.40 / डिज़ाइन 0.20 / सर्वांगीण 0.25ऊपर जैसा
लाभCost, Reliability, Speeddocs/patterns.md

संयुक्त स्कोरिंग "उत्तर का उपयोग कैसे करें" परत का पैटर्न है, लॉन्च से पहले Jev 1.13 ख़ामी मार्गदर्शिका के नौ विफलता पैटर्न भी जाँच लेने चाहिए — विशेषकर "शाब्दिक अर्थ लेना" वाला: स्केल विवरण में सटीक शर्तें लिखें, "अच्छी आर्किटेक्चर क्षमता है" जैसे मात्रात्मक शब्द नहीं।

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

चारों अधिकारिक पैटर्न इस पाठ तक पूरे हो गए (फैन-आउट, इरादा राउटिंग, कॉन्फ़िडेंस गेटिंग, संयुक्त स्कोरिंग), अब आख़िरी सवाल: इन Jev कॉल का कोड कौन लिखेगा। अगला पाठ: Claude Code के साथ मिलकर विकास करें: TypeSafe Agent Skill।

आप सीखेंगे:

  • Jev coding agent का LLM नहीं है: Claude Code / Cursor के पीछे के मॉडल को नहीं बदल सकता, सही तरीक़ा है कि agent से "Jev को कॉल करने वाला कोड" लिखवाएँ
  • दो कमांड में अधिकारिक Agent Skill इंस्टॉल: claude plugin marketplace add typesafe-ai/skills, फिर claude plugin install typesafe@typesafe-ai
  • 3 आधिकारिक उदाहरण prompt: ब्रेनस्टॉर्मिंग, सस्ते प्रयोग चलाना, समान cookbook खोजना
  • 5 सामान्य समस्याओं के समाधान के तरीके: agent skill का उपयोग न करना, routing अपेक्षा के अनुरूप न होना, हर जगह confidence threshold सेट करना, कोड का review करना कठिन होना, agent द्वारा फ़ील्ड बना देना
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.