AI Engineering Academy · पाठ

न्यायाधीश मॉडलों का मनुष्यों के अनुसार अंशांकन

पाठ 3, कुल 4 में से13 चरण

न्यायाधीश मॉडलों का मनुष्यों के अनुसार अंशांकन, CoddyKit पर AI Engineering Academy का एक निःशुल्क पाठ है। यह 4 में से 3वाँ पाठ है। आप नीचे पूरा पाठ निःशुल्क पढ़ सकते हैं—फिर अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर के साथ ब्राउज़र में इसका व्यावहारिक अभ्यास कर सकते हैं। यह AI Engineering Academy सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। AI Engineering Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

अंशांकन अनिवार्य क्यों है

बिना अंशांकन वाला LLM निर्णायक मॉडल व्यवस्थित रूप से मनुष्यों की तुलना में आउटपुट को अधिक या कम अंक दे सकता है, किसी विशेष लेखन शैली को प्राथमिकता दे सकता है या उन असामान्य मामलों में विफल हो सकता है जिनकी आपके मानदंड में कल्पना नहीं की गई थी। यदि आप ऐसे निर्णायक मॉडल का उपयोग परिनियोजन संबंधी निर्णय लेने के लिए करते हैं, तो आप एक पक्षपाती उपकरण पर भरोसा कर रहे हैं। अंशांकन निर्णायक मॉडल की मानव-आधारित वास्तविक मानकों से पुष्टि करता है और यह मापता है कि उत्पादन में उसके अंकों पर भरोसा करने से पहले आप उस पर कितना विश्वास कर सकते हैं।

अंशांकन डेटासेट बनाना

100-500 उदाहरण उत्तरों का एक अंशांकन समुच्चय बनाएँ जिन्हें मनुष्यों द्वारा अंक दिए गए हों। विविधता का लक्ष्य रखें: उच्च-गुणवत्ता वाले उत्तर (अंक 5), मध्यम गुणवत्ता वाले उत्तर (अंक 3) और स्पष्ट रूप से खराब उत्तर (अंक 1) शामिल करें। प्रत्येक उदाहरण को 3-5 स्वतंत्र मानव मूल्यांकनकर्ताओं से अंक दिलवाएँ, ताकि मूल्यांकनकर्ताओं के बीच सहमति मापी जा सके और औसत या बहुलक लेकर सर्वसम्मत वास्तविक-अंक निकाला जा सके।

# Calibration dataset structure:
# [
#   {
#     'question': 'What causes inflation?',
#     'response': '...',
#     'human_scores': [4, 4, 3, 5, 4],  # 5 raters
#     'human_consensus': 4,              # mean or mode
#     'rater_ids': ['r1', 'r2', 'r3', 'r4', 'r5']
#   },
#   ...
# ]

# Typical calibration set composition:
# 30% excellent responses (score 4-5)
# 40% adequate responses (score 2-4)
# 30% poor responses (score 1-2)
# Include adversarial / edge cases

मूल्यांकनकर्ताओं के बीच सहमति मापना

मानव अंकों को वास्तविक मानक मानने से पहले यह सुनिश्चित करें कि आपके मानव मूल्यांकनकर्ता एक-दूसरे से सहमत हैं। कोहेन का कप्पा संयोग से होने वाली सहमति से अलग, दो मूल्यांकनकर्ताओं के बीच सहमति को मापता है: 0.6 से अधिक स्वीकार्य और 0.8 से अधिक उत्कृष्ट माना जाता है। 5-अंकीय पैमानों के लिए भारित कप्पा निकालें (रैखिक भार)। मूल्यांकनकर्ताओं के बीच कम सहमति का अर्थ है कि कार्य अस्पष्ट रूप से परिभाषित है — अंकों से निर्णायक मॉडल का अंशांकन करने से पहले मूल्यांकनकर्ता दिशानिर्देशों में सुधार करें।

from sklearn.metrics import cohen_kappa_score
import numpy as np

def measure_inter_rater_agreement(rater1_scores: list, rater2_scores: list) -> dict:
    kappa = cohen_kappa_score(rater1_scores, rater2_scores, weights='linear')
    exact_agreement = sum(a == b for a, b in zip(rater1_scores, rater2_scores)) / len(rater1_scores)
    adjacent_agreement = sum(abs(a - b) <= 1 for a, b in zip(rater1_scores, rater2_scores)) / len(rater1_scores)
    return {
        'weighted_kappa': round(kappa, 3),
        'exact_agreement': round(exact_agreement, 3),
        'adjacent_agreement': round(adjacent_agreement, 3),
        'acceptable': kappa >= 0.6
    }

अंशांकन डेटा पर निर्णायक मॉडल चलाना

उत्पादन में उपयोग करने की योजना वाले उसी प्रॉम्प्ट का उपयोग करके अंशांकन समुच्चय के प्रत्येक उदाहरण पर अपना LLM निर्णायक मॉडल चलाएँ। प्रत्येक उदाहरण के लिए निर्णायक मॉडल का अंक और मानवों का सर्वसम्मत अंक साथ-साथ एकत्र करें। इन दोनों सूचियों को समान क्रम में रखें, ताकि आप तत्व-दर-तत्व उनकी तुलना कर सकें। यही तुलना व्यवस्थित पूर्वाग्रहों और अंकों की सीमा में अंतर को उजागर करती है।

async def run_judge_on_calibration(calibration_set: list) -> list:
    pairs = []
    for item in calibration_set:
        judge_result = await async_judge(item['question'], item['response'])
        pairs.append({
            'question': item['question'],
            'human': item['human_consensus'],
            'judge': judge_result.correctness,
            'judge_rationale': judge_result.rationale
        })
    return pairs

निर्णायक मॉडल और मानव अंकों का सहसंबंध निकालना

निर्णायक मॉडल के अंकों और मानवों के सर्वसम्मत अंकों के बीच पियर्सन सहसंबंध निकालें। यह रैखिक सहमति को मापता है: 1.0 का सहसंबंध दर्शाता है कि निर्णायक मॉडल मानवों की क्रम-रैंकिंग का पूरी तरह अनुसरण करता है। औसत अंक-अंतर समझने के लिए माध्य निरपेक्ष त्रुटि (MAE) भी निकालें। 5-अंकीय पैमाने पर 0.7 से अधिक सहसंबंध और 0.8 अंक से कम MAE आमतौर पर उत्पादन में उपयोग के लिए पर्याप्त विश्वसनीय निर्णायक मॉडल का संकेत देते हैं।

from scipy.stats import pearsonr, spearmanr
import numpy as np

def calibration_metrics(pairs: list) -> dict:
    humans = [p['human'] for p in pairs]
    judges = [p['judge'] for p in pairs]
    pearson_r, p_val = pearsonr(humans, judges)
    spearman_r, _ = spearmanr(humans, judges)
    mae = np.mean([abs(h - j) for h, j in zip(humans, judges)])
    return {
        'pearson_r': round(pearson_r, 3),
        'spearman_r': round(spearman_r, 3),
        'p_value': round(p_val, 5),
        'mae': round(mae, 3),
        'reliable': pearson_r >= 0.7 and mae <= 0.8
    }

व्यवस्थित पूर्वाग्रहों की पहचान करना

सहसंबंध से आगे बढ़कर व्यवस्थित पूर्वाग्रहों को देखें: क्या निर्णायक मॉडल लगातार अधिक या कम अंक देता है? निर्णायक मॉडल के अंकों को मानव अंकों के विरुद्ध आलेखित करें और देखें कि क्या प्रतिगमन रेखा मूल बिंदु से होकर नहीं गुजरती। यदि मनुष्य औसतन 3 अंक देते हैं और निर्णायक मॉडल 4 अंक देता है, तो उसमें अंक बढ़ाने का पूर्वाग्रह है। मानदंड को समायोजित करके या मूल अंकों पर रैखिक अंशांकन रूपांतरण लागू करके इसे ठीक करें।

import numpy as np
from scipy import stats

def detect_score_bias(pairs: list) -> dict:
    humans = np.array([p['human'] for p in pairs])
    judges = np.array([p['judge'] for p in pairs])
    slope, intercept, r, p, se = stats.linregress(judges, humans)
    bias = np.mean(judges - humans)  # positive = judge over-scores
    return {
        'mean_bias': round(bias, 3),  # > 0 means judge inflates
        'calibration_slope': round(slope, 3),
        'calibration_intercept': round(intercept, 3),
        # Corrected score = slope * judge_score + intercept
        'correction_formula': f'human_score ≈ {slope:.2f} * judge + {intercept:.2f}'
    }

अंशांकन सुधार लागू करना

अंशांकन प्रतिगमन (ढलान और अवरोधांक) प्राप्त हो जाने पर, उसे लागू करके निर्णायक मॉडल के मूल अंकों को ऐसे अंशांकित अंकों में बदलें जो मानव निर्णयों से बेहतर मेल खाते हों। यह रैखिक सुधार सरल और प्रभावी है। प्रतिगमन से प्राप्त सीमा-बाह्य मानों को रोकने के लिए सुधारे गए अंक को मान्य सीमा (1-5) में सीमित करें। मूल और सुधारे गए दोनों अंक सहेजें, ताकि अंशांकन डेटा बढ़ने पर बाद में उनकी तुलना की जा सके।

def calibrate_score(raw_judge_score: float, slope: float, intercept: float,
                    min_score: int = 1, max_score: int = 5) -> float:
    corrected = slope * raw_judge_score + intercept
    return max(min_score, min(max_score, round(corrected, 1)))

# Example: if judge inflates by 0.5 points on average
# slope=0.85, intercept=0.3
# raw_score=4 -> corrected = 0.85*4 + 0.3 = 3.7

व्यवस्थित त्रुटि के प्रतिरूप खोजना

प्रतिरूपित विफलताओं को खोजने के लिए अंशांकन त्रुटियों को प्रश्न के प्रकार, उत्तर की लंबाई और विषय क्षेत्र के अनुसार समूहित करें। निर्णायक मॉडल तकनीकी कोडिंग प्रश्नों पर अविश्वसनीय, लेकिन तथ्यात्मक प्रश्नों पर सटीक हो सकता है। वह बहुत लंबे उत्तरों को अधिक अंक दे सकता है, लेकिन छोटे और संक्षिप्त उत्तरों को कम अंक दे सकता है। ये प्रतिरूप उन क्षेत्रों के लिए लक्षित मानदंड सुधार या विषय-विशिष्ट निर्णायक प्रॉम्प्ट तैयार करने में मदद करते हैं जहाँ अंशांकन सबसे कमजोर है।

from collections import defaultdict

def error_by_category(pairs: list) -> dict:
    by_cat = defaultdict(list)
    for p in pairs:
        error = abs(p['judge'] - p['human'])
        by_cat[p.get('category', 'unknown')].append(error)
    return {
        cat: {
            'mean_error': round(sum(errs)/len(errs), 2),
            'max_error': max(errs),
            'n': len(errs)
        }
        for cat, errs in by_cat.items()
    }

डेटा बढ़ने पर पुनः अंशांकन करना

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

def run_calibration_pipeline(calibration_data: list) -> dict:
    # 1. Measure human inter-rater agreement
    ira = measure_inter_rater_agreement(
        [d['rater_1'] for d in calibration_data],
        [d['rater_2'] for d in calibration_data]
    )
    # 2. Run judge on all items
    pairs = run_judge_on_calibration(calibration_data)
    # 3. Compute correlation metrics
    metrics = calibration_metrics(pairs)
    # 4. Detect bias
    bias = detect_score_bias(pairs)
    return {'ira': ira, 'metrics': metrics, 'bias': bias}

अपने निर्णायक मॉडल के विन्यास का दस्तावेज़ीकरण करना

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

# judge_config.yaml
# judge_model: gpt-4o-2025-01-01
# judge_prompt_version: v3.2
# calibration_date: 2026-05-15
# calibration_set_size: 312
# calibration_metrics:
#   pearson_r: 0.81
#   spearman_r: 0.79
#   mae: 0.54
# bias_correction:
#   slope: 0.88
#   intercept: 0.45
# next_recalibration: 2026-08-15

आयाम-विशिष्ट निर्णायक प्रॉम्प्ट

एक ही समय में कई आयामों के अंक देने वाला एकल निर्णायक प्रॉम्प्ट अक्सर आपस में संबंधित अंक उत्पन्न करता है — निर्णायक मॉडल स्पष्टता के अंक अधिक देने के कारण शुद्धता के अंक भी अधिक देता है और अपनी पहली धारणा पर टिक जाता है। आयाम-विशिष्ट प्रॉम्प्ट प्रत्येक मानदंड का स्वतंत्र रूप से, अलग API कॉल में मूल्यांकन करते हैं। यह अधिक महँगा है, लेकिन इससे अधिक विश्वसनीय अंक मिलते हैं जो वास्तव में स्वतंत्र माप होते हैं। जिन आयामों के अंकों में स्वतंत्र रूप से भिन्नता की अपेक्षा है, उनके लिए अलग प्रॉम्प्ट का उपयोग करें।

async def multi_dimension_judge(question: str, answer: str) -> dict:
    # Run each dimension as a separate judge call
    correctness, helpfulness, clarity = await asyncio.gather(
        judge_single_dimension(question, answer, 'correctness'),
        judge_single_dimension(question, answer, 'helpfulness'),
        judge_single_dimension(question, answer, 'clarity')
    )
    return {
        'correctness': correctness,
        'helpfulness': helpfulness,
        'clarity': clarity,
        'composite': 0.5 * correctness + 0.3 * helpfulness + 0.2 * clarity
    }

त्वरित जाँच

मानव मूल्यांकनों के आधार पर LLM निर्णायक मॉडलों का अंशांकन करने की अपनी समझ जाँचें।

इंटरैक्टिव पाठ में इसका उत्तर दें

पाठ का पुनरावलोकन

इस पाठ में आपने सीखा: मानवों के सर्वसम्मत अंकों वाले अंशांकन डेटासेट निर्णायक मॉडल की विश्वसनीयता मापने के लिए वास्तविक मानक प्रदान करते हैं, पियर्सन सहसंबंध और MAE यह मापते हैं कि निर्णायक मॉडल मानव निर्णयों का कितनी अच्छी तरह अनुसरण करता है, और रैखिक पूर्वाग्रह सुधार व्यवस्थित रूप से अधिक या कम अंक देने की प्रवृत्ति को ठीक करता है। अगले भाग में हम CI/CD के साथ एकीकृत सतत मूल्यांकन कार्यप्रवाह बनाएँगे।

शुरुआत निःशुल्क

एआई शिक्षक के साथ Python सीखें — निःशुल्क

अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।

पाठ्यक्रम: 30
पाठ: 120

निःशुल्क सीखना शुरू करें पूरा पाठ्यक्रम देखें

अक्सर पूछे जाने वाले प्रश्न

क्या “न्यायाधीश मॉडलों का मनुष्यों के अनुसार अंशांकन” पाठ निःशुल्क है?

हाँ—“न्यायाधीश मॉडलों का मनुष्यों के अनुसार अंशांकन” का पूरा पाठ यहाँ वेब पर निःशुल्क पढ़ा जा सकता है। इंटरैक्टिव अभ्यास (अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर) करने और AI Engineering Academy पाठ्यक्रम का बाकी हिस्सा अनलॉक करने के लिए CoddyKit PRO लें। AI Engineering Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

“न्यायाधीश मॉडलों का मनुष्यों के अनुसार अंशांकन” में मैं क्या सीखूँगा?

मानव वरीयता-निर्णयों का वास्तविक-आधार डेटासेट एकत्र करें, Cohen's Kappa से निर्णायक और मानव के बीच सहमति मापें, और व्यवस्थित पक्षपात कम करने के लिए निर्णायक के प्रॉम्प्ट को बेहतर बनाएँ। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ AI Engineering Academy का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।

क्या AI Engineering Academy शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?

पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर AI Engineering Academy शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 3वाँ पाठ है।

“न्यायाधीश मॉडलों का मनुष्यों के अनुसार अंशांकन” पाठ पूरा करने में कितना समय लगता है?

CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।

क्या मैं इस AI Engineering Academy पाठ में कोड लिख और चला सकता हूँ?

हाँ। हर AI Engineering Academy पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।

इस पाठ्यक्रम के सभी पाठ

LLM-न्यायाधीश पैटर्न
बिंदुवार और युग्मवार मूल्यांकन
न्यायाधीश मॉडलों का मनुष्यों के अनुसार अंशांकन
निरंतर मूल्यांकन पाइपलाइन बनाना

← AI Engineering Academy पर वापस जाएँ