Skip to content

75 श्रेणियों का उद्योग वर्गीकरण: विश्वास स्तर पर्याप्त न हो तो बड़ी श्रेणी रिपोर्ट करें ​

💡 एक वाक्य में सारांश: Jev से «अनिश्चित होने पर स्वतः डाउनग्रेड» वाला टेक्स्ट वर्गीकरण पाइपलाइन बनाएं — एक Choice 75 उद्योग समूहों में बांटता है, confidence ≥ 0.9 होने पर उद्योग समूह रिपोर्ट करें, पर्याप्त न हो तो शुद्ध कोड से उसकी बड़ी श्रेणी रिपोर्ट करें।

SEC में वार्षिक रिपोर्ट (10-K) दाखिल करने वाली हर कंपनी, Item 1 «व्यवसाय विवरण» में बताती है कि वह क्या करती है। आधिकारिक cookbook ने इस असली सामग्री से एक क्लासिक Jev टेक्स्ट वर्गीकरण प्रश्न बनाया: प्रत्येक विवरण को मानक उद्योग वर्गीकरण (SIC) के अनुसार 75 उद्योग समूहों में बांटें — प्रत्येक फ़ाइल के लिए एक Choice, पूरी श्रेणी तालिका एक ही अनुरोध में समा जाती है।

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

Jev के Choice उत्तर में confidence (classification confidence, वर्गीकरण विश्वास स्तर) अंतर्निहित आता है — एक संख्या «भरोसेमंद उत्तर» और «अविश्वसनीय उत्तर» को अलग कर देती है। और SIC लेबल स्वाभाविक रूप से पदानुक्रमित हैं: उद्योग समूहों के ऊपर 10 व्यापक बड़ी श्रेणियां (division) हैं। आधिकारिक तरीका यह है: जब मॉडल को उद्योग समूह का भरोसा न हो, तो उसकी बड़ी श्रेणी रिपोर्ट करें — बड़ी श्रेणी समूह संख्या से तालिका देखकर मिलती है, दूसरा कॉल बिल्कुल नहीं।

आधिकारिक रूप से 60 वार्षिक रिपोर्टों पर परीक्षण: 0.9 का confidence थ्रेशोल्ड फ़ाइलों को ठीक आधे-आधे बांटता है। भरोसेमंद आधे में 90% सही; बिना भरोसे वाले आधे में, ज़बरदस्ती उद्योग समूह रिपोर्ट करने पर केवल 40% सही — एक स्तर ऊपर की बड़ी श्रेणी रिपोर्ट करने के बाद उपयोगिता दर 70% हो गई। यह पाठ लगभग 15 मिनट का है, आधिकारिक सार्वजनिक डेटा से इस गेटिंग को पूरी तरह पुनरुत्पादित कराता है (आधिकारिक cookbook में कठिनाई Beginner चिह्नित है)।

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

  • 75 विकल्पों वाले Choice प्रश्न से कंपनी विवरण का Jev टेक्स्ट वर्गीकरण करें, पूरी प्रायिकता वितरण और confidence पाएं
  • «confidence ≥ 0.9 होने पर उद्योग समूह रिपोर्ट करें, कम हो तो उसकी बड़ी श्रेणी रिपोर्ट करें» वाला गेटिंग कोड लिखें — तालिका देखकर पूरा, दूसरा API कॉल बिल्कुल नहीं
  • आधिकारिक सार्वजनिक डेटा से SEC वार्षिक रिपोर्ट वर्गीकरण प्रयोग पुनरुत्पादित करें: 60 वार्षिक रिपोर्टें, ज़बरदस्ती उद्योग समूह रिपोर्ट करने पर 39/60 सही → गेटिंग जोड़ने पर 48/60 उपयोगी
  • «विश्वास स्तर पर्याप्त न हो तो एक स्तर ऊपर रिपोर्ट करें» को अपने श्रेणी-वृक्ष पर ले जाएं: AI उद्योग वर्गीकरण, ई-कॉमर्स श्रेणियां, टिकट सिस्टम — सभी पर लागू

साधारण LLM टेक्स्ट वर्गीकरण के बजाय Jev क्यों? ​

क्षमतासाधारण LLM वर्गीकरणJev
अनिश्चितता«क्या आप निश्चित हैं» पूछने पर एक गद्यांश मिलता है; प्रायिकता को टेक्स्ट में लिखवाने पर एक और पार्सिंग विफलता-बिंदु जुड़ता हैहर उत्तर में confidence अंतर्निहित (0–1), प्रायिकता वितरण से निकलता है, सीधे थ्रेशोल्ड सेट करें
विकल्प नियंत्रणश्रेणी नामों पर खुली छूट, «loan brokerage» «lending intermediary» शब्दावली रोज़ बदलती हैउत्तर हमेशा 75 विकल्पों में से एक, choice यानी सर्वोच्च प्रायिकता वाला विकल्प
बड़ी विकल्प सूचियां75 विकल्प विवरण सहित prompt में भरें, आउटपुट को तालिका से भी सत्यापित करना पड़ता हैChoice में प्रति प्रश्न अधिकतम 255 विकल्प, लगभग 240 तक भरोसेमंद — 75 सुरक्षित क्षेत्र में बहुत दूर
प्रायिकता कैलिब्रेशनटेक्स्ट जनरेशन के लिए अनुकूलित, स्व-रिपोर्टेड प्रायिकताओं की कोई कैलिब्रेशन गारंटी नहींRLCD कैलिब्रेशन ट्रेनिंग, प्रायिकताएं वास्तविक परिणामों से संरेखित
कठिन उदाहरणों का फ़ॉलबैकज़बरदस्ती गलत लेबल रिपोर्ट करें, या मॉडल को फिर से कॉल करके «निश्चित हैं?» पूछेंबड़ी श्रेणी समूह संख्या से तालिका देखकर निकलती है, रिपोर्टिंग शुद्ध कोड मैपिंग है, दूसरा कॉल बिल्कुल नहीं

एक ईमानदार बात: confidence गेटिंग «गलत लेबल को सही मानने» का अनुपात घटाती है, गलतियां मिटाती नहीं — आधिकारिक परीक्षण में भरोसेमंद आधे में भी 3/30 गलत थे। कैलिब्रेशन का स्रोत और सूत्र विवरण Confidence विश्वास स्तर में देखें।

आपकी वर्तमान दुविधा ​

  • «LLM से 200 ग्राहकों को 75 उद्योगों में बांटवाया, उसने हर उत्तर पूर्ण आत्मविश्वास से दिया — जो कुछ गलत बंटे वे सही बंटे जैसे ही दिखते हैं, नमूना जांच पूरी तरह किस्मत पर»
  • «मानव समीक्षा जोड़नी है, पर 60 सभी देखना वर्गीकरण से भी महंगा है; मॉडल से पूछना चाहते हैं «क्या आप निश्चित हैं», वह हमेशा निश्चित कहता है»
  • «श्रेणियां स्पष्ट रूप से पदानुक्रमित हैं, सबसे सूक्ष्म स्तर तक न बंटे तो मोटा उत्तर भी गलत उत्तर से बेहतर है — पर मॉडल ज़बरदस्ती एक ही चुनता है, «मैं केवल इस स्तर तक जा सकता हूं» नहीं कहता»

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

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

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

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

  • «क्या मॉडल को यकीन है» इसके लिए एक और अनुरोध भेजना, एक और मॉडल कॉल करना
  • मॉडल के थूके टेक्स्ट से श्रेणी का नाम और प्रायिकता पार्स करना
  • मॉडल के अनिश्चित होने पर भी बारीक स्तर ज़बरदस्ती रिपोर्ट करना, और डाउनस्ट्रीम गलत बारीक-स्तर टैग को सही मान ले

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

  • पूरा किया Choice चुनाव-प्रश्न: पता है कि criteria विकल्पों का map है, probabilities सभी विकल्पों का वितरण है, और उत्तर हमेशा विकल्पों में से ही होता है
  • पूरा किया Confidence विश्वास स्तर: पता है कि confidence प्रायिकता वितरण से निकलता है, तीन स्तरों का उपयोग, और सीमा जोखिम के साथ स्केल होती है
  • सफलतापूर्वक चलाया पहला अनुरोध: .venv में typesafe-sdk इंस्टॉल है, और पर्यावरण चर TYPESAFE_API_KEY सेट है

डेटा खुद बनाने की ज़रूरत नहीं: आधिकारिक रूप से SIC उद्योग तालिका और 60 वास्तविक वार्षिक रिपोर्ट typesafe-public-examples रिपॉज़िटरी में सार्वजनिक हैं; चरण 1 में आपको डाउनलोड कराया जाएगा।

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

चरण 1: «उद्योग समूह → बड़ी श्रेणी» मैपिंग तालिका बनाएं (आधिकारिक SIC डेटा डाउनलोड करें) ​

क्यों: रिपोर्टिंग लॉजिक को एक «बारीक स्तर → मोटे स्तर» मैपिंग तालिका चाहिए। SIC का कोड स्वयं पदानुक्रमिक है: चार-अंकीय उद्योग कोड के पहले दो अंक उद्योग समूह (major group, कुल 75) हैं, और निश्चित अंतराल के उद्योग समूह 10 बड़ी श्रेणियों (division) में आते हैं — यह मैपिंग परत शुद्ध कोड से कोडिंग नियमों द्वारा निकाली जाती है, मॉडल की भागीदारी की ज़रूरत नहीं।

प्रोजेक्ट डायरेक्टरी में आधिकारिक डेटा की दोनों फाइलें डाउनलोड करें (2026-11-03 स्थानीय जांच में पहुंच योग्य):

bash
curl -sL -o sic_codes.tsv "https://raw.githubusercontent.com/typesafe-ai/typesafe-public-examples/main/cookbooks/classification_using_confidence/sic_codes.tsv"
curl -sL -o filings.jsonl "https://raw.githubusercontent.com/typesafe-ai/typesafe-public-examples/main/cookbooks/classification_using_confidence/filings.jsonl"

classify_sic.py बनाएं और मैपिंग वाला हिस्सा पेस्ट करें:

python
# classify_sic.py —— 75 类行业分类:置信度不够就上报大类
# 依赖:pip install typesafe-sdk(Python 3.10+),环境变量里已有 TYPESAFE_API_KEY
from collections import defaultdict
from pathlib import Path

# 十个大类:SIC 行业组编码的固定区间(官方 cookbook 原表)
DIVISIONS = [
    (1, 9, "agriculture, forestry and fishing"),
    (10, 14, "mining"),
    (15, 17, "construction"),
    (20, 39, "manufacturing"),
    (40, 49, "transportation, communications and utilities"),
    (50, 51, "wholesale trade"),
    (52, 59, "retail trade"),
    (60, 67, "finance, insurance and real estate"),
    (70, 89, "services"),
    (91, 99, "public administration"),
]

# 444 个四位行业码 -> 75 个行业组(前两位)-> 10 个大类,全程零模型参与
INDUSTRIES: dict[str, str] = {}
for line in Path("sic_codes.tsv").read_text().splitlines()[1:]:
    code, _office, title = line.split("\t")
    INDUSTRIES[code] = title.lower()

GROUPS: dict[str, list[str]] = defaultdict(list)
for code in sorted(INDUSTRIES):
    GROUPS[code[:2]].append(code)


def division(group: str) -> str:
    """行业组组号 -> 所属大类,纯查表。"""
    number = int(group)
    return next(name for low, high, name in DIVISIONS if low <= number <= high)


print(f"{len(INDUSTRIES)} industries -> {len(GROUPS)} major groups -> {len(DIVISIONS)} divisions")
print(f"  group 35 = {division('35')} / {', '.join(INDUSTRIES[c] for c in GROUPS['35'][:3])} ...")

चलाएं:

bash
.venv/bin/python classify_sic.py

आपको यह दिखना चाहिए(2026-11-03 स्थानीय जांच में आधिकारिक डेटा से सत्यापित):

text
444 industries -> 75 major groups -> 10 divisions
  group 35 = manufacturing / engines & turbines, farm machinery & equipment, lawn & garden tractors & home lawn & gardens equip ...
  • मुझे 444 → 75 → 10 मिला, group 35 manufacturing में पड़ा

चरण 2: 75 उद्योग समूहों को एक Choice प्रश्न के रूप में लिखें ​

क्यों: विकल्पों में केवल नाम काफी नहीं — 75 उद्योग समूहों में से केवल 42 ही SEC सूची में «छतरी-नाम» (umbrella name) के साथ हैं (जैसे group 20 का food and kindred products), बाकी 33 में केवल समूह संख्या है। आधिकारिक तरीका है कि प्रत्येक विकल्प का वर्णन समूह के भीतर के उद्योग विवरणों से किया जाए — वार्षिक रिपोर्ट पढ़ने वाला व्यक्ति मूल रूप से इन्हीं विवरणों से मिलान करता है। प्रत्येक समूह में अधिकतम 8 विवरण सूचीबद्ध होते हैं: आधिकारिक टिप्पणी कहती है, विशेषताएं दर्शाने के लिए यह काफी है, और टेक्स्ट की दीवार नहीं बनती।

ऊपर वाले कोड के बाद पेस्ट करें:

python
from typesafe_sdk import Choice

MAX_NAMED = 8  # 每组列出的细目数;官方值


def describe(group: str) -> str:
    """选项描述 = 伞名 + 组内细目;没有伞名的组只列细目。"""
    umbrella = INDUSTRIES.get(f"{group}00")
    inside = [INDUSTRIES[c] for c in GROUPS[group] if c != f"{group}00"][:MAX_NAMED]
    listed = "; ".join(inside)
    return (
        f"{umbrella} — includes: {listed}"
        if umbrella and listed
        else (umbrella or listed)
    )


print(f"group 20: {describe('20')[:150]}")
print(f"\ngroup 65: {describe('65')[:150]}")

# 问题原文来自官方 cookbook;完整问题写在 instructions 里
QUESTION = (
    "Which broad industry does this company operate in? Judge the company's own operations "
    "as this filing describes them."
)


def questions() -> dict:
    return {
        "group": Choice(
            instructions=QUESTION,
            criteria={group: describe(group) for group in sorted(GROUPS)},
        )
    }

एक बार फिर चलाएं, आपको यह दिखना चाहिए(नया आउटपुट नीचे है, आधिकारिक रिकॉर्डेड आउटपुट से मेल खाता है; पिछले चरणों के प्रिंट अपरिवर्तित रहते हैं):

text
group 20: food and kindred products — includes: meat packing plants; sausages & other prepared meat products; poultry slaughtering and processing; dairy product

group 65: real estate — includes: real estate operators (no developers) & lessors; operators of nonresidential buildings; operators of apartment buildings; less

75 विकल्प ज़्यादा तो नहीं? नहीं। Choice पाठ में बताया गया था कि एक प्रश्न में अधिकतम 255 विकल्प हो सकते हैं; आधिकारिक cookbook का अनुभव है कि लगभग 240 तक अभी भी विश्वसनीय है, 75 बिल्कुल सुरक्षित क्षेत्र में है — पूरी श्रेणी तालिका एक ही अनुरोध में समा जाती है।

💡 यही Jev का अनूठा मूल्य है

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

  • मैं बता सकता हूं कि group 20 के विकल्प विवरण में «छतरी-नाम» और «विवरण» कौन से हिस्से हैं

चरण 3: एक वार्षिक रिपोर्ट, एक अनुरोध — Jev टेक्स्ट वर्गीकरण सफलतापूर्वक चलाएं ​

क्यों: filings.jsonl में 60 वास्तविक 10-K वार्षिक रिपोर्टें हैं, प्रत्येक में केवल Item 1 «व्यवसाय विवरण» रखा गया है — वह हिस्सा जहां कंपनी अपने व्यवसाय का वर्णन करती है, और वही हिस्सा जिससे उद्योग कोड संबंधित है, औसतन 1438 शब्द। प्रत्येक फाइल के लिए एक अनुरोध, एक Choice प्रश्न: उत्तर में choice (विजेता की समूह संख्या), probabilities (75 विकल्पों के अपने-अपने भार), confidence (वितरण की एकाग्रता की एकल संख्या) लौटते हैं।

चरण 4 और 5 एक ही फाइल से बार-बार उत्तर लेंगे, इसलिए पहले एक छोटा कैश जोड़ें जो परिणाम my_cache.json में सहेजे — स्क्रिप्ट दोबारा चलाने पर दोबारा बिलिंग नहीं होती; ज़बरदस्ती दोबारा चलाना हो तो इसे हटा दें (आधिकारिक notebook वही काम cooksafe के JsonCache से करता है):

python
import json

from typesafe_sdk import TypeSafeClient

client = TypeSafeClient(model="jev-latest")

FILINGS = [json.loads(line) for line in Path("filings.jsonl").read_text().splitlines()]
_cache: dict[str, dict] = {}
if Path("my_cache.json").exists():
    _cache.update(json.loads(Path("my_cache.json").read_text()))


def ask(filing_id: str, text: str) -> dict:
    if filing_id not in _cache:
        response = client.system_one(state=text, questions=questions())
        answer = response.answers["group"]
        _cache[filing_id] = {
            "group": answer.choice,
            "confidence": answer.confidence,
            "probabilities": dict(answer.probabilities),
        }
        Path("my_cache.json").write_text(json.dumps(_cache))
    return _cache[filing_id]


# 拿一份好分的文件先跑通:一家人寿保险公司
example = next(f for f in FILINGS if f["id"] == "33416_1998")
print(f"{len(FILINGS)} filings, {sum(f['words'] for f in FILINGS) // len(FILINGS)} words on average")
print(f"\n{example['id']} (filed {example['year']}, accession {example['accession']}):")
print(f"  {example['text'][:230]}...")
print(f"  filer's code: {example['sic']} {INDUSTRIES[example['sic']]}")

answer = ask(example["id"], example["text"])
print(f"\nmodel's answer: group {answer['group']} ({describe(answer['group']).split(' — ')[0][:46]}), conf {answer['confidence']:.2f}")

चलाएं:

bash
.venv/bin/python classify_sic.py

आपको यह दिखना चाहिए(नया आउटपुट नीचे; पंक्तियां 2026-11-03 स्थानीय जांच में सत्यापित, अंतिम पंक्ति आधिकारिक रिकॉर्डेड मान है — jev-1.12 परीक्षण में इस फाइल का conf 1.00 → group 63। आप jev-latest से चलाएं तो इतने स्पष्ट व्यवसाय विवरण वाली फाइल का टैग बड़ी संभावना से वही रहेगा, confidence संख्या में हल्का अंतर हो सकता है):

text
60 filings, 1438 words on average

33416_1998 (filed 1998, accession 0000033416-99-000001):
  ITEM 1. BUSINESS Erie Family Life Insurance Company (hereinafter referred to as "The Company", the "Company" or "Erie Family Life") was incorporated in the Commonwealth of Pennsylvania on May 23, 1967 and commenced business on Sep...
  filer's code: 6311 life insurance

model's answer: group 63 (life insurance; accident & health insurance; h), conf 1.00

जिस कंपनी का स्व-वर्णित व्यवसाय साफ-साफ है, उसकी confidence सीधे शिखर पर पहुंच जाती है। आधिकारिक रूप से रिकॉर्ड किए गए 60 उत्तरों में confidence 0.22 से 1.00 तक मिलती है — वितरण फैला हुआ है, और यही गेटिंग के काम करने की पूर्व शर्त है। लागत अनुस्मारक: पूरे 60 चलाना = 60 अनुरोध, बिलिंग इनपुट token पर, आउटपुट मुफ्त; वर्तमान दरेंमॉडल और मूल्य में देखें।

  • एकल-फाइल अनुरोध ने choice, probabilities, confidence लौटाए, और उत्तर मेरे 75 विकल्पों में से एक था

चरण 4: confidence गेटिंग जोड़ें: ≥ 0.9 पर उद्योग समूह रिपोर्ट करें, < 0.9 पर संबंधित बड़ी श्रेणी रिपोर्ट करें ​

क्यों: यही इस पाठ का मुख्य किरदार है। confidence ≥ 0.9 होने पर उत्तर उद्योग समूह के रूप में रिपोर्ट होता है; 0.9 से कम होने पर वही उत्तर उसकी बड़ी श्रेणी के रूप में रिपोर्ट होता है — division(组号) तालिका देखकर पूरा, दूसरी कॉल बिल्कुल नहीं। हर फाइल उपयोग योग्य टैग के साथ लौटती है: न फेंकना, न ज़बरदस्ती बारीक स्तर रिपोर्ट करना, न पूरे को मैन्युअल हस्तांतरित करना।

इसके बाद पेस्ट करें:

python
CONFIDENT = 0.9  # 高于它报行业组组号;低于它上报所属大类(官方 SEC 场景实验值)


def classify(filing: dict) -> dict:
    answer = ask(filing["id"], filing["text"])
    sure = answer["confidence"] >= CONFIDENT
    return {
        "level": "group" if sure else "division",
        "label": answer["group"] if sure else division(answer["group"]),
        "confidence": answer["confidence"],
        "group": answer["group"],
    }


def show(filing: dict) -> None:
    result = classify(filing)
    named = describe(result["group"]).split(" — ")[0][:46]
    print(
        f"  {filing['id']:>13}  conf {result['confidence']:.2f}  -> {result['level']:<8} "
        f"{result['label']:<14} (group {result['group']}: {named})"
    )


results = [(f, classify(f)) for f in FILINGS]  # 60 份各一次请求,缓存防重复
by_conf = sorted(results, key=lambda fr: fr[1]["confidence"], reverse=True)

print("three filings the model was sure about:")
for f, _ in by_conf[:3]:
    show(f)
print("\nthree it was not:")
for f, _ in by_conf[-3:]:
    show(f)

चलाएं:

bash
.venv/bin/python classify_sic.py

आपको यह दिखना चाहिए(नया आउटपुट नीचे, आधिकारिक रूप से रिकॉर्ड किया गया, jev-1.12, 2026-08-12; आपकी अपनी शीर्ष-अंत सूची और संख्याएं संस्करण और डेटा के साथ बदलेंगी, लेकिन «आसानी से बंटने वाली फाइलों की ऊंची confidence, मुश्किल फाइलों की कम confidence» का स्वरूप समान रहेगा):

text
three filings the model was sure about:
    310158_1996  conf 1.00  -> group    28             (group 28: chemicals & allied products)
     33416_1998  conf 1.00  -> group    63             (group 63: life insurance; accident & health insurance; h)
    352541_1996  conf 1.00  -> group    49             (group 49: electric, gas & sanitary services)

three it was not:
   1372167_2013  conf 0.22  -> division manufacturing  (group 38: search, detection, navagation, guidance, aeron)
   1398633_2009  conf 0.23  -> division wholesale trade (group 50: wholesale-durable goods)
     46653_1999  conf 0.29  -> division services       (group 87: services-engineering, accounting, research, ma)

दोनों सिरों की तीन-तीन पंक्तियां देखें — confidence और «यह फाइल कितनी मुश्किल से बंटती है» एकदम सटीक मेल खाते हैं:

  • तीन 1.00: दवा निर्माता, जीवन बीमा कंपनी, सार्वजनिक उपयोगिता — कागज़ पर तीनों होल्डिंग कंपनियां हैं, लेकिन हर एक की वार्षिक रिपोर्ट एक प्रमुख व्यवसाय का नाम लेती है।
  • तीन सबसे नीचे वाले: दो विकासशील कंपनियां हैं जो «करने का इरादा रखने वाले» व्यवसाय का वर्णन करती हैं (एक खुद को «intends to operate as a software developer» कहती है, दूसरी «organized to enter into the computer security software industry»); तीसरी में मूल रूप से दो व्यवसाय खंड थे, जमा करने से कुछ हफ्ते पहले ही एक बेच दिया।
  • इसलिए इन तीनों को बारीक स्तर की समूह संख्या नहीं, बल्कि manufacturing / wholesale trade / services तीन बड़ी श्रेणी के टैग लौटे।

💡 चीनी सामग्री के लिए ध्यान दें

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

  • पहली और आख़िरी तीन-तीन पंक्तियों में, जिनमें भरोसा हो वहाँ group रिपोर्ट करें, जिनमें भरोसा न हो वहाँ division रिपोर्ट करें (आधिकारिक रिकॉर्डिंग में सबसे नीचे वाली तीन फ़ाइलों का confidence 0.3 से कम है)

चरण 5: यह मापना कि 「ऊपरी श्रेणी रिपोर्ट करने」 से क्या मिलता है ​

क्यों: गेटिंग की बराबरी अंकों से होती है। आधिकारिक तौर पर 60 रिकॉर्ड किए गए उत्तरों को filer द्वारा स्वयं रिपोर्ट किए गए कोड से तुलना कर, दो रणनीतियों पर अंक दिए गए: रणनीति A हर बार industry group रिपोर्ट करने पर मजबूर करती है; रणनीति B में भरोसा न होने पर (confidence < 0.9) ऊपरी श्रेणी रिपोर्ट की जाती है।

इसके बाद पेस्ट करें:

python
def correct(filing: dict, result: dict) -> bool:
    gold_group = filing["sic"][:2]
    if result["level"] == "group":
        return result["label"] == gold_group
    return result["label"] == division(gold_group)


sure = [(f, r) for f, r in results if r["level"] == "group"]
unsure = [(f, r) for f, r in results if r["level"] == "division"]

forced = sum(r["group"] == f["sic"][:2] for f, r in results)
broadened = sum(correct(f, r) for f, r in results)

print(f"forced to name a group every time      {forced}/{len(results)} right")
print(
    f"  of those, the {len(sure)} it was sure about  "
    f"{sum(r['group'] == f['sic'][:2] for f, r in sure)}/{len(sure)} right"
)
print(
    f"  and the {len(unsure)} it was not           "
    f"{sum(r['group'] == f['sic'][:2] for f, r in unsure)}/{len(unsure)} right"
)
print(f"\nletting it answer coarsely when unsure  {broadened}/{len(results)} useful answers")

चलाने के बाद आपको यह दिखना चाहिए (नया आउटपुट इस प्रकार है, आधिकारिक रिकॉर्डिंग, jev-1.12):

text
forced to name a group every time      39/60 right
  of those, the 30 it was sure about  27/30 right
  and the 30 it was not           12/30 right

letting it answer coarsely when unsure  48/60 useful answers

एक तालिका में तोड़कर स्पष्ट देखें (अनुपात आधिकारिक चार अंकों से निकाले गए हैं):

रणनीतिभरोसे वाली 30 फ़ाइलेंबिना भरोसे वाली 30 फ़ाइलेंकुल 60 फ़ाइलें
हर बार industry group रिपोर्ट करने पर मजबूर27/30 सही (90%)12/30 सही (40%)39/60 (65%)
भरोसा न हो तो ऊपरी श्रेणी रिपोर्ट करें27/30 सही (90%)21/30 उपयोगी (70%)48/60 (80%)

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

  • भरोसे वाला आधा हिस्सा: industry group रिपोर्ट करने पर 90% सही—इन्हें निश्चिंत होकर स्वचालित रूप से स्वीकार किया जा सकता है।
  • बिना भरोसे वाला आधा हिस्सा: ज़बरदस्ती industry group रिपोर्ट करने पर केवल 40% सही; पहली स्तर की ऊपरी श्रेणी रिपोर्ट करने पर 70% उपयोगी। मोटा स्तर स्वाभाविक रूप से अधिक सही होना आसान है—manufacturing एक ही ऊपरी श्रेणी 20–39 बीस industry groups को कवर करती है, विजेता बस सही अंतराल में आ जाए, तो तालिका देखने के बाद का लेबल सही होगा।
  • कीमत: उन 30 फ़ाइलों के लेबल मोटे हो गए। आधिकारिक मूल शब्द: यदि ऊपरी श्रेणी आपके अनुप्रयोग के लिए बहुत मोटी है और उसके आधार पर कोई कार्रवाई नहीं हो सकती, तो यह शाखा उसे मानव को सौंपने की जगह है।

मिलान न भूलें: भरोसे वाले आधे हिस्से में भी 3/30 ग़लत हैं—गेटिंग घटाती है 「ग़लत लेबल को सही मान लेने」 का अनुपात, ग़लतियाँ मिटाती नहीं।

  • मैं 39/60, 27/30, 12/30, 48/60 चारों अंकों के अलग-अलग अर्थ बता सकता हूँ

📋 जादुई Prompt ​

इस पृष्ठ का 「Prompt」 API के लिए प्रश्न टेम्पलेट है—कॉपी करके 【】 प्लेसहोल्डर बदल दें (? वाले वैकल्पिक हैं) और उपयोग कर सकते हैं।

📝 कॉन्फ़िडेंस गेटिंग वाला दो-स्तरीय वर्गीकरण टेम्पलेट (कोई भी श्रेणी ट्री) ​

अपेक्षित परिणाम: किसी भी पदानुक्रमित लेबल प्रणाली को 「पर्याप्त निश्चित हो तो सूक्ष्म स्तर रिपोर्ट करें, अपर्याप्त निश्चित हो तो मोटा स्तर रिपोर्ट करें」 वाला क्लासिफ़ायर बनाएँ—एक ही अनुरोध, दूसरा कॉल शून्य।

python
from typesafe_sdk import Choice

# 必填项:【】里换成你的类目树
CONFIDENT = 【置信度门槛:官方 SEC 场景用 0.9;从保守值起步,用自己的数据调】
FINE_LABELS = {
    "【细级标签 A】": "【什么内容算 A——写成可对照的情境描述】",
    "【细级标签 B】": "【什么内容算 B】",
    # 细级标签总数 ≤ 255(硬上限),约 240 内可靠
}
COARSE_OF = {
    "【细级标签 A】": "【A 所属的粗级标签】",
    "【细级标签 B】": "【B 所属的粗级标签】",
}

QUESTIONS = {
    "label": Choice(
        instructions="【一句话问题:这条内容最属于哪个标签?只根据给定材料判断】",
        criteria=FINE_LABELS,
    ),
}

# 输出规范:answer.choice / answer.confidence / answer.probabilities
# 门控:confidence >= CONFIDENT 报 answer.choice;否则报 COARSE_OF[answer.choice]
# 约束条件:
# ✅ 粗级映射用纯代码查表——不发第二次请求
# ✅ 每个细级标签写「可对照的情境描述」,光有名字往往不够
# ❌ 不要把「不确定」做成一个选项——门控是代码层的,不是模型标签
# ❌ 单级标签超过约 240 个别硬塞一题——改走逐层分类(见相关教程)

✅ विकल्प विवरण जनरेटर (अपनी श्रेणी फ़ाइल से criteria जोड़ें) ​

अपेक्षित परिणाम: आधिकारिक तौर पर हर विकल्प को 「छत्री नाम + अधिकतम 8 समूह-भीतर की सूक्ष्म मदें」 से वर्णित किया गया—आपका श्रेणी ट्री भी ऐसा ही करे, श्रेणी डेटा से हर विकल्प का विवरण स्वचालित रूप से जोड़ें।

python
# 必填项:【】里换成你的类目数据源(伞名和子项列表)
# 选填项:没有伞名的标签 umbrella 传空串?,函数自动只列子项
def describe_label(umbrella: str, children: list[str], max_named: int = 8) -> str:
    """官方 describe() 的通用版:伞名 + 最多 max_named 个子项。"""
    listed = "; ".join(children[:max_named])
    if umbrella and listed:
        return f"{umbrella} — includes: {listed}"
    return umbrella or listed


# 约束条件:
# ✅ 子项挑最有代表性的(官方按编码顺序取前 8 个)
# ✅ 描述统一大小写风格——官方代码把全部行业标题统一转小写
# ❌ 别堆全部子项——官方注释:足够刻画特征即可,不堆文字墙
# ❌ 没有伞名的标签别硬造——官方 describe() 对 33 个无伞名组只列子项

🔧 थ्रेशोल्ड कैलिब्रेशन स्क्रिप्ट (अपने स्वयं के एनोटेट किए डेटा से CONFIDENT तय करें) ​

अपेक्षित परिणाम: 0.9 आधिकारिक SEC परिदृश्य का jev-1.12 पर प्रयोग मूल्य है। श्रेणी, भाषा या मॉडल संस्करण बदलने पर थ्रेशोल्ड दोबारा कैलिब्रेट करना होगा—यह स्क्रिप्ट उम्मीदवार थ्रेशोल्ड के अनुसार 「स्वचालित स्वीकृति अनुपात × सही दर」 के दो पत्ते निकालती है।

python
# 必填项:【】里换成你的标注样本(挑真实业务里最难判的一批:代表性案例 + 难例 + 反例)
GOLD = [
    ("【文本 1】", "【正确细级标签】"),
    ("【文本 2】", "【正确细级标签】"),
]
THRESHOLDS = [0.5, 0.6, 0.7, 0.8, 0.9, 0.95]

answers = {}
for text, _gold in GOLD:
    response = client.system_one(state=text, questions=QUESTIONS)
    a = response.answers["label"]
    answers[text] = {"choice": a.choice, "confidence": a.confidence}

for t in THRESHOLDS:
    auto = [(gold, answers[text]) for text, gold in GOLD if answers[text]["confidence"] >= t]
    fine = sum(a["choice"] == gold for gold, a in auto)
    coarse = sum(
        COARSE_OF[a["choice"]] == COARSE_OF[gold]
        for gold, a in auto
        if a["choice"] != gold
    )
    print(f"threshold {t:.2f}: 自动采信 {len(auto)}/{len(GOLD)}, 细级正确 {fine}/{len(auto)}, 上报后粗级可用 {fine + coarse}/{len(auto)}")

# 约束条件:
# ✅ 标定样本要覆盖难例——全是好分的样本会把你骗到过低的门槛
# ✅ 门槛和问题定义放同一个文件,方便人审(官方 Agent Skill 建议)
# ❌ 别拿官方 0.9 直接上生产——官方 NOTE:正确阈值取决于你的领域和用例表现
# ❌ 金标先抽检再标定——过期的标签会把门槛带偏(官方实验前先筛样本)

चेकपॉइंट ✅ ​

  • classify_sic.py से 444 → 75 → 10 का मैपिंग चलाएँ, group 35 manufacturing में आता है
  • 60 फ़ाइलें पूरी तरह चल जाएँ, level कॉलम में group और division दोनों आएँ, बिना भरोसे वाले बैच का confidence स्पष्ट रूप से कम हो
  • एकल-फ़ाइल उत्तर में choice, probabilities, confidence तीन फ़ील्ड हों, उत्तर हमेशा 75 विकल्पों में से एक हो
  • मुझे 39/60, 27/30, 12/30, 48/60 के अर्थ पता हैं, और वे आधिकारिक jev-1.12 (2026-08-12) रिकॉर्डिंग से हैं
  • मुझे पता है कि 0.9 SEC परिदृश्य का प्रयोग थ्रेशोल्ड है—श्रेणी, भाषा या संस्करण बदलने पर एनोटेट किए डेटा से दोबारा कैलिब्रेट करना होगा

ख़ामी-चेतावनी ​

❌ 「ऊपरी श्रेणी रिपोर्ट करने」 को दूसरा अनुरोध बनाना ​

लक्षण: confidence थ्रेशोल्ड से नीचे होने पर, एक और अनुरोध भेजकर पूछा जाए 「तो वह किस ऊपरी श्रेणी में आता है?」

क्यों ग़लत: ऊपरी श्रेणी समूह संख्या से अद्वितीय रूप से तय होती है—division(组号) से तालिका देखना काफ़ी है। दूसरा अनुरोध अतिरिक्त ख़र्च कराता है और नई अनिश्चितता भी लाता है। आधिकारिक मूल शब्द: ऊपरी श्रेणी industry group से निकाली जाती है, इसलिए कोई दूसरा कॉल नहीं है।

सही तरीका: गेटिंग शाखा में पूरी तरह कोड से रिपोर्ट पूरी करें। इसी तरह, 「अनिश्चित」 को 76वाँ विकल्प बनाकर मॉडल से चुनवाने की कोशिश न करें—रिपोर्ट करना है या नहीं, यह कोड confidence के आधार पर तय करता है, मॉडल का लेबल नहीं।

❌ विकल्प विवरण में आलस्य, केवल लेबल नाम लिखना ​

लक्षण: criteria में हर विकल्प के लिए केवल "manufacturing", "services" जैसे शब्द लिखे जाएँ, उत्तर की गुणवत्ता ख़राब और confidence सामान्यतः नीचे हो।

क्यों ग़लत: 75 industry groups में से 33 का SEC सूची में कोई छत्री नाम नहीं है, केवल समूह संख्या या शब्द देने पर मॉडल केवल अंदाज़ा लगा सकता है। आधिकारिक तौर पर हर विकल्प को 「छत्री नाम + अधिकतम 8 समूह-भीतर की सूक्ष्म मदें」 से वर्णित किया गया—वार्षिक रिपोर्ट पढ़ने वाला व्यक्ति मूल रूप से इन्हीं सूक्ष्म मदों से मिलान करता है।

सही तरीका: चरण 2 describe() के विचार से हर विकल्प के लिए 「मिलान-योग्य संदर्भ विवरण」 लिखें; लेबल नाम और विवरण दोनों मॉडल को भेजे जाते हैं, विवरण ही विकल्पों को अलग करने की कुंजी है।

❌ confidence को 「उत्तर सही है」 की गारंटी मानना ​

लक्षण: conf 1.00 वाले उत्तर सीधे डेटाबेस में डाल दिए जाएँ, दोबारा जाँच न हो।

क्यों ग़लत: confidence प्रायिकता वितरण की एकाग्रता का वर्णन करता है, उत्तर के सही होने की प्रायिकता का नहीं। आधिकारिक परीक्षण में, भरोसे वाली 30 फ़ाइलों में भी 3 ग़लत थीं (27/30)। विकल्प विवरण अस्पष्ट हो या सामग्री में जानकारी कम हो, तो मॉडल बड़े आत्मविश्वास से ग़लत दांव लगा सकता है।

सही तरीका: confidence को 「स्वचालित रूप से स्वीकार करना है या नहीं」 का गेट मानें; प्रश्न की गुणवत्ता अलग से मापें—कम कॉन्फ़िडेंस की जाँच के तीन दिशाएँ (विकल्प ओवरलैप / प्रश्न ने एक से अधिक बात परखी / state जानकारी अपर्याप्त) देखें Confidence कॉन्फ़िडेंस।

❌ थ्रेशोल्ड 0.9 को जस-का-तस कॉपी करना, संस्करण उपनाम के साथ बहना ​

लक्षण: 0.9 को हार्डकोड करके अपने सिस्टम में डाल दिया जाए, हमेशा jev-latest ही उपयोग हो, और किसी दिन नया संस्करण आने के बाद व्यवहार बदल जाए।

क्यों ग़लत: 0.9 आधिकारिक SEC परिदृश्य का jev-1.12 पर प्रयोग मूल्य है, आधिकारिक NOTE में साफ़ कहा गया है कि सही थ्रेशोल्ड आपके डोमेन और उपयोग-मामले के प्रदर्शन पर निर्भर करता है; और jev-latest उपनाम नए संस्करणों के साथ खिसकता रहता है, आधिकारिक सलाह है कि थ्रेशोल्ड समायोजित किए अनुरोध संस्करण ID पर लॉक करें।

सही तरीका: अपने annotated डेटा से threshold कैलिब्रेट करें (magic Prompt का 3वाँ template); production requests में version ID lock करें, response.model से लॉग में हर जवाब का version traceable रहे। Jev की और failure modes के लिए Jev 1.13 pitfalls handbook देखें।

❌ gold-standard डेटा की self-check न करना, ऐसे मापी गई «accuracy» अर्थहीन होती है ​

लक्षण: «model answers vs human labels» का एक batch लेकर accuracy निकालते हैं, आंकड़े बहुत खराब आते हैं, और model पर शक होने लगता है।

गलत क्यों है: SEC के industry codes filer खुद चुनते हैं और वे expire हो जाते हैं—company उस business को बेचने के बाद भी code रखती है जिसे वह code दर्शाता था। आधिकारिक प्रयोग से पहले 60 को «text द्वारा समर्थित codes» तक filter किया गया, फिर test किया: test इस method का हुआ, EDGAR metadata की quality का नहीं।

सही तरीका: calibration और evaluation से पहले gold-standard का spot-check करें—expired labels वाले samples या तो ठीक कर दें या अलग archive कर दें, गंदे labels को आपके threshold को pollute न होने दें।

Advanced tips (optional) ​

🔧 Signal बदलकर gating tune करें। confidence के अलावा आधिकारिक रूप से दो alternative metrics बताई गई हैं: top probability p_max (इसका अर्थ options की संख्या के साथ बदलता है, प्रश्न के अनुसार threshold लगाएं) और top-to-second ratio p_max / p_second (दो मजबूत contenders वाले प्रश्नों पर सबसे आसान)।

एक geometric intuition: 75 options पर confidence और p_max के मान लगभग match करते हैं—इसकी value options की संख्या को normalize करने में है, एक ही 0.9 threshold का अर्थ 3 options और 75 options में समान रहता है। Formula और trade-offs के लिए Confidence confidence देखें।

🔧 जब categories एक level में समा न जाएं, तो layer-by-layer classification अपनाएं। एक प्रश्न में 255 options hard limit है, लगभग 240 तक reliable। अगर आपका category tree एक level में इससे बड़ा है, या level-wise labels चाहिए, तो पिछले lesson का Deep hierarchical classification देखें: आधिकारिक रूप से Choice probabilities से parallel beam search करके category tree को layer-by-layer चलते हैं। इस lesson का «flat एक ही प्रश्न + confidence reporting» 75 जैसे single-level में समा जाने वाले scenarios के लिए उपयुक्त है—दोनों routes एक-दूसरे के पूरक हैं।

🔧 Zero-code में पहले आधिकारिक example देखें। आधिकारिक cookbook page पर एक Playground share link छोड़ा गया है—एक annual report + 75 options का पूरा प्रश्न, खोलते ही probability distribution और confidence दिखते हैं, बिना code लिखे। Console Playground console.typesafe.ai/playground पर है।

Lesson summary ​

✅ एक 75-option Choice से Jev text classification: criteria हर option को «umbrella name + अधिकतम 8 sub-items» से describe करें, जवाब हमेशा options में से ही होगा।

✅ Confidence gating: confidence ≥ 0.9 पर industry group report करें, इससे कम पर उसका parent class report करें—lookup table से पूरा, zero दूसरा call; हर data के साथ usable label लौटता है।

✅ आधिकारिक 60 SEC annual reports पर real-world test: forced industry-group reporting 39/60 (65%), gating जोड़ने पर 48/60 (80%)—confident cases का 90% सही, non-confident cases में 40% से बढ़कर 70%।

✅ 0.9 SEC scenario में jev-1.12 पर experimental threshold है: category, language या version बदलने पर अपने annotated डेटा से दोबारा calibrate करें।

मुख्य configuration fields का recap:

Field / constantइस page का valueविवरण
CONFIDENT0.9≥ पर industry group report, < पर parent class; आधिकारिक SEC scenario का experimental value
MAX_NAMED8हर option description में listed sub-items की संख्या की limit
Options की संख्या75Choice की hard limit 255, लगभग 240 तक reliable
Decision inputanswer.choice / .confidence / .probabilitieschoice अर्थात् highest-probability option
division(group)Lookup tableIndustry group number → 10 parent classes, pure code

संबंधित tutorials:

Next lesson preview ​

एक ही प्रश्न एक ही बार पूछकर, पता कैसे लगाएं कि वह «stable» है या नहीं? Next lesson: Self-consistency: review system में «uncertain» exit जोड़ना।

आप सीखेंगे:

  • Self-consistency checkup: एक ही content को नए uid से 15 बार दोहराकर पूछना, वे प्रश्न ढूंढना जो label flip करते हैं
  • Choice प्रश्नों में top probability 0.60 से कम होने पर automatic human handoff, Noul प्रश्नों में 0.30–0.70 का uncertain band
  • आधिकारिक real-world test: exit जोड़ने के बाद decision consistency 90.8% से बढ़कर 99.2%, कीमत 25.8% human handoff
  • इस lesson से संबंध: यह lesson single answer के confidence से तय करता है «coarse report करें या fine», next lesson repeated sampling से तय करता है «कौन-सा प्रश्न बिल्कुल भी automatically run न हो»
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.