સ્તરીકૃત (stratified) મૂલ્યાંકન ડેટાસેટ બનાવો

પરિચય

જ્યારે તમે કાચા ટેસ્ટ પૂલમાંથી મૂલ્યાંકન કેસોને એકસમાન રીતે રેન્ડમ ખેંચો છો, ત્યારે પરિણામી ચોકસાઈનો આંકડો જૂઠું બોલે છે — સરળ કેસો અને વધુ પડતી રજૂ થયેલી ટાસ્ક કેટેગરીઓ સિગ્નલને દબાવી દે છે, અને દુર્લભ-પણ-નિર્ણાયક સ્ટ્રેટા પર ખરાબ રીતે નિષ્ફળ જતું મોડેલ હજુ પણ 90ના ઊંચા દાયકામાં સ્કોર કરે છે. પરિણામ એ છે કે હોસ્ટેડ LLM ડેશબોર્ડ પર પ્રોડક્શન-રેડી દેખાય છે અને વાસ્તવિક વપરાશકર્તાઓને રિગ્રેશન પહોંચાડે છે. આ પાઠના અંત સુધીમાં તમે ટેસ્ટ-કેસ પૂલને ટાસ્ક કેટેગરી અને મુશ્કેલી પ્રમાણે વિભાજિત કરી શકશો, ઓડિટ કરી શકાય તેવી પ્રતિ-સ્ટ્રેટમ ગણતરીઓ સાથે સંતુલિત સેમ્પલ ખેંચી શકશો, અને ગોલ્ડન ડેટાસેટને લૉક કરતા પહેલાં દૂષિત કેસોને ફિલ્ટર કરી શકશો.

મુખ્ય પરિભાષા

• સ્ટ્રેટમ (Stratum): (ટાસ્ક કેટેગરી, મુશ્કેલી) જોડી દ્વારા વ્યાખ્યાયિત ટેસ્ટ-કેસ પૂલનું બિન-ઓવરલેપિંગ વિભાજન; પ્રતિ-સેલ ગણતરીઓ નિયંત્રિત કરવા માટે સેમ્પલિંગ દરેક સ્ટ્રેટમમાંથી સ્વતંત્ર રીતે ખેંચે છે.
• ગોલ્ડન ડેટાસેટ: અપરિવર્તનીય, વર્ઝન કરેલું મૂલ્યાંકન બેન્ચમાર્ક જે સ્ટ્રેટિફાઇડ સેમ્પલિંગ અને દૂષણ ફિલ્ટરિંગમાંથી બચે છે, અને દરેક મોડેલ રિલીઝ સામે સ્કોર થાય છે.
• દૂષણ ગુણોત્તર (Contamination ratio): ટેસ્ટ કેસના n-grams નો તે અંશ જે સંદર્ભ ટ્રેનિંગ કોર્પસમાં પણ દેખાય છે; કૉન્ફિગર કરેલી થ્રેશોલ્ડથી ઉપરના કેસો ડેટાસેટ લૉક થતા પહેલાં બાકાત કરવામાં આવે છે.
• પ્રોવેનન્સ (Provenance): પ્રતિ-કેસ લેબલ (દા.ત. "human" અથવા "synthetic") જે નોંધે છે કે કેસ કેવી રીતે લખાયો હતો, જેથી ડેટાસેટ કાર્ડ માનવ-વિરુદ્ધ-સિન્થેટિક રચના રિપોર્ટ કરી શકે.

ખ્યાલો

LLM મૂલ્યાંકન માટે સાદું રેન્ડમ સેમ્પલિંગ શા માટે નિષ્ફળ જાય છે

કાચા ટેસ્ટ-કેસ પૂલમાંથી રેન્ડમ સેમ્પલિંગ બે પ્રણાલીગત જોખમો લાવે છે. પહેલું, કેટેગરી અસંતુલન: જો તમારા પૂલમાં 400 ક્લાસિફિકેશન ઉદાહરણો હોય પણ માત્ર 30 જનરેશન ઉદાહરણો હોય, તો 200 કેસોનો રેન્ડમ ડ્રૉ લગભગ ખાતરીપૂર્વક જનરેશન ક્ષમતાને ઓછી ચકાસાયેલી રાખશે. બીજું, મુશ્કેલીનો ઝુકાવ: સરળ ઉદાહરણો અઘરા ઉદાહરણો કરતાં વધુ સંખ્યામાં હોય છે કારણ કે એનોટેટર્સ સરળ કેસો ઝડપથી બનાવે છે, તેથી રેન્ડમ સેમ્પલિંગ કૃત્રિમ રીતે ફૂલેલો ચોકસાઈ મેટ્રિક આપે છે. સ્ટ્રેટિફાઇડ સેમ્પલિંગ પૂલને સ્ટ્રેટામાં વિભાજિત કરીને — ટાસ્ક કેટેગરી અને મુશ્કેલી સ્તરના ક્રોસ-પ્રોડક્ટ દ્વારા વ્યાખ્યાયિત — અને દરેક સ્ટ્રેટમમાંથી સ્વતંત્ર રીતે ખેંચીને બંને જોખમો દૂર કરે છે. પરિણામ એવો ડેટાસેટ છે જ્યાં દરેક (કેટેગરી, મુશ્કેલી) સેલમાં નિયંત્રિત, ઓડિટ કરી શકાય તેવી ગણતરી હોય છે.

ઓછા-રજૂ થયેલા સ્ટ્રેટા અને એજ કેસોનું સંચાલન

પ્રોડક્શન મૂલ્યાંકન પૂલમાં લગભગ હંમેશા વિરલ સ્ટ્રેટા હોય છે. અઘરી-મુશ્કેલીવાળા જનરેશન કેસો કુખ્યાત રીતે દુર્લભ છે કારણ કે તેમને નિષ્ણાત એનોટેટર્સની જરૂર પડે છે જે મોડેલને સૂક્ષ્મ નિષ્ફળતા મોડ્સમાં ધકેલતા પ્રોમ્પ્ટ ઘડી શકે — હેલ્યુસિનેશન, ઇન્સ્ટ્રક્શન ડ્રિફ્ટ, અથવા સ્ટાઇલ કોલેપ્સ. ત્રણ વ્યૂહરચનાઓ આ ખાલીપો ભરે છે:

• એડવર્સેરિયલ ઉદાહરણ ઇન્જેક્શન: જાણીતી મોડેલ નબળાઈઓને લક્ષ્ય બનાવતા એજ કેસો હાથથી અથવા પ્રોગ્રામેટિક રીતે ઘડો. એક્સટ્રેક્શન ટાસ્ક માટે, આનો અર્થ અસ્પષ્ટ એન્ટિટી સીમાઓ છે; રિઝનિંગ ટાસ્ક માટે, આનો અર્થ વિશ્વસનીય ડિસ્ટ્રેક્ટર્સ સાથેના મલ્ટી-હોપ પ્રશ્નો છે. Patronus Generative Simulators નિષ્ફળતા સપાટીઓને વ્યવસ્થિત રીતે ચકાસીને અને મોટા પાયે એડવર્સેરિયલ પ્રોમ્પ્ટ જનરેટ કરીને આને સ્વચાલિત કરે છે.

• સિન્થેટિક ડેટા જનરેશન: NeMo Safe Synthesizer ડિફરન્શિયલ પ્રાઇવસી ગેરંટી સાથે પ્રાઇવસી-અનુરૂપ સિન્થેટિક કેસો ઉત્પન્ન કરે છે, જે તમને તમારી ટ્રેનિંગ અથવા એનોટેશન પાઇપલાઇનમાંથી PII લીક કર્યા વિના વિરલ સ્ટ્રેટાને વધારવા દે છે. સિન્થેટિક કેસોમાં provenance="synthetic" હોવું જરૂરી છે જેથી ડાઉનસ્ટ્રીમ ડેટાસેટ કાર્ડ રચનાને ચોક્કસ રીતે રિપોર્ટ કરે.

• ઇન્ટર-એનોટેટર એગ્રીમેન્ટ પુનઃ-કેલિબ્રેશન: જ્યારે મુશ્કેલી લેબલ અવિશ્વસનીય હોય, ત્યારે તેમને એનોટેટર એગ્રીમેન્ટ સ્કોરમાંથી ફરીથી ગણો. 0.6 (Fleiss' kappa) થી નીચેના એગ્રીમેન્ટવાળા કેસોને hard માં બઢતી આપવામાં આવે છે; 0.9 થી ઉપરના કેસોને easy માં ઉતારવામાં આવે છે. આ પુનઃ-કેલિબ્રેશન ઘણીવાર કેસોને સ્ટ્રેટામાં પુનઃવિતરિત કરે છે અને નવો ડેટા જનરેટ કર્યા વિના વિરલતાનો ઉકેલ લાવી શકે છે.

ગોલ્ડન ડેટાસેટ એસેમ્બલ કરવું

એકવાર સ્ટ્રેટિફાઇડ સેમ્પલિંગ અને દૂષણ ફિલ્ટરિંગ પૂર્ણ થાય, પછી બચેલા કેસો ગોલ્ડન ડેટાસેટ બનાવે છે — અપરિવર્તનીય સંદર્ભ બેન્ચમાર્ક જેની સામે દરેક મોડેલ વર્ઝન સ્કોર થાય છે. ગોલ્ડન ડેટાસેટની સાથે એક ડેટાસેટ કાર્ડ હોવું જોઈએ જે સ્ટ્રેટિફિકેશન ગ્રિડ, પ્રતિ-સ્ટ્રેટમ ગણતરીઓ, દૂષણ બાકાત ગણતરીઓ, પ્રોવેનન્સ વિભાજન (માનવ વિ. સિન્થેટિક), મુશ્કેલી લેબલ માટે ઇન્ટર-એનોટેટર એગ્રીમેન્ટ આંકડા, અને સ્નેપશોટનો Git કમિટ હેશ દસ્તાવેજીકૃત કરે. આ મેટાડેટા ટીમો વચ્ચે અને સમય સાથે પુનઃઉત્પાદનક્ષમ મૂલ્યાંકન સક્ષમ બનાવે છે — ગવર્નન્સ ફ્રેમવર્ક હેઠળ કાર્યરત કોઈપણ સંસ્થા માટે આવશ્યકતા જ્યાં ઓડિટ ટ્રેઇલ અનિવાર્ય છે.

વ્યવહારુ વર્કફ્લો આ છે: સંતુલિત ડ્રૉ બનાવવા માટે StratifiedDatasetBuilder.build ચલાવો, પરિણામને ContaminationChecker.filter_dataset દ્વારા પસાર કરો, ચકાસો કે ફિલ્ટરિંગ પછી કોઈ સ્ટ્રેટમ લઘુત્તમ ગણતરીથી નીચે ન ગયું હોય (જરૂર પડે તો NeMo Safe Synthesizer વડે ફરી વધારો), અંતિમ યાદીને વર્ઝન કરેલી JSON ફાઇલમાં સીરિયલાઇઝ કરો, અને તેને તેના ડેટાસેટ કાર્ડ સાથે કમિટ કરો. ડેટાસેટ કાર્ડ પોતે એક સંરચિત markdown અથવા JSON દસ્તાવેજ છે જે ડેટાસેટમાં શું છે, તે શા માટે બનાવાયું, અને તેનો ઉપયોગ કેવી રીતે કરવો તે માટે સત્યના એકમાત્ર સ્રોત તરીકે કામ કરે છે — મોડેલ કાર્ડ જેવું પણ મૂલ્યાંકન ડેટા પૂરતું મર્યાદિત. જ્યારે સ્વચાલિત ડેટાસેટ રિફ્રેશ પાઇપલાઇન વાસીપણું શોધે છે (બીજા લક્ષ્યમાં આવરી લેવાયું છે), ત્યારે તે આ જ પાઇપલાઇન દ્વારા પુનઃ-ક્યુરેશન ટ્રિગર કરે છે, જે સુનિશ્ચિત કરે છે કે ગોલ્ડન ડેટાસેટનું દરેક નવું વર્ઝન સમાન સ્ટ્રેટિફિકેશન ગેરંટી અને દૂષણ સુરક્ષા વારસામાં મેળવે.

કોડ વૉકથ્રુ

સ્ટ્રેટિફિકેશન અક્ષો વ્યાખ્યાયિત કરવા

હોસ્ટેડ-LLM મૂલ્યાંકન માટે, બે પ્રાથમિક અક્ષો સ્ટ્રેટિફિકેશન ગ્રિડ બનાવે છે:

• ટાસ્ક કેટેગરી: જે કાર્યાત્મક ક્ષમતાની ચકાસણી થઈ રહી છે. GPT-4o જેવા સામાન્ય-હેતુ મોડેલ માટે સામાન્ય કેટેગરીઓમાં classification, summarization, extraction, generation, અને reasoning નો સમાવેશ થાય છે. દરેક કેટેગરી અલગ આંતરિક માર્ગનો ઉપયોગ કરે છે — classification લેબલ ચોકસાઈ માગે છે, જ્યારે generation લાંબા આઉટપુટ પર સુસંગતતા અને પ્રવાહિતા માગે છે.

• મુશ્કેલી સ્તર: એક અલગ-અલગ સ્કેલ (સામાન્ય રીતે easy, medium, hard) જે ટેસ્ટ કેસની જ્ઞાનાત્મક અથવા ગણતરીની જટિલતાને પકડે છે. મુશ્કેલીને ઘણીવાર ઇન્ટર-એનોટેટર એગ્રીમેન્ટ દ્વારા કાર્યરત કરવામાં આવે છે: જ્યાં એનોટેટર્સ સાચા જવાબ પર સર્વસંમતિથી સહમત થાય તે કેસો easy છે, આંશિક અસંમતિવાળા કેસો medium છે, અને જ્યાં નિષ્ણાતો પણ જુદા પડે તે કેસો hard છે.

પાંચ કેટેગરી અને ત્રણ મુશ્કેલી સ્તરનો ક્રોસ-પ્રોડક્ટ પંદર સ્ટ્રેટા આપે છે. સારી રીતે ડિઝાઇન કરેલો ગોલ્ડન ડેટાસેટ પ્રતિ સેલ લઘુત્તમ ગણતરી ફાળવે છે — સામાન્ય રીતે 20 થી 50 કેસો — જે 95% કોન્ફિડન્સ પર પાંચ ટકા-પોઇન્ટથી નીચેના માર્જિન ઑફ એરર સાથે પ્રતિ-સેલ પાસ-રેટ અંદાજ માટે આંકડાકીય શક્તિ સુનિશ્ચિત કરે છે.

ટેસ્ટ-કેસ સ્કીમા ડિઝાઇન કરવી

મૂલ્યાંકન ડેટાસેટના દરેક ટેસ્ટ કેસમાં સ્ટ્રેટિફાઇડ ડ્રૉ, દૂષણ શોધ, અને પુનઃઉત્પાદનક્ષમ ડેટાસેટ વર્ઝનિંગને સપોર્ટ કરવા માટે પૂરતો મેટાડેટા હોવો જોઈએ. લઘુત્તમ વ્યવહારુ સ્કીમામાં સમાવેશ થાય છે: પ્રોમ્પ્ટ ટેક્સ્ટ, અપેક્ષિત સંદર્ભ આઉટપુટ, ટાસ્ક કેટેગરી લેબલ, મુશ્કેલી સ્તર, ટ્રેસેબિલિટી માટે અનન્ય કેસ ઓળખકર્તા, અને પ્રોવેનન્સ ફીલ્ડ જે દર્શાવે કે કેસ માનવ-લિખિત છે કે સિન્થેટિક રીતે જનરેટ થયેલો (જ્યારે તમે પાછળથી પ્રાઇવસી-અનુરૂપ સિન્થેટિક ડેટા માટે NeMo Safe Synthesizer અથવા એડવર્સેરિયલ ઉદાહરણો માટે Patronus Generative Simulators ને એકીકૃત કરો ત્યારે સંબંધિત).

નીચેનો કોડ એક EvalCase dataclass અને એક StratifiedDatasetBuilder ક્લાસ વ્યાખ્યાયિત કરે છે જે કાચા ટેસ્ટ કેસો સ્વીકારે છે, તેમને સ્ટ્રેટામાં બકેટ કરે છે, અને સંતુલિત સેમ્પલ ખેંચે છે. StratifiedDatasetBuilder.build મેથડ સ્ટ્રેટમ-અંદરના ડ્રૉ માટે Python ની random.sample નો ઉપયોગ કરે છે અને જ્યારે કોઈ સ્ટ્રેટમ જરૂરી લઘુત્તમ ગણતરીથી નીચે આવે ત્યારે ValueError ઉઠાવે છે, જે મૌનપણે ઓછી-શક્તિવાળા મૂલ્યાંકનને અટકાવે છે.

Code snippetpython
1import random
2from dataclasses import dataclass, field
3from collections import defaultdict
4from typing import List, Dict, Optional
5
6TASK_CATEGORIES = ["classification", "summarization", "extraction",
7                   "generation", "reasoning"]
8DIFFICULTY_LEVELS = ["easy", "medium", "hard"]
9
10@dataclass
11class EvalCase:
12    case_id: str
13    prompt: str
14    reference_output: str
15    category: str
16    difficulty: str
17    provenance: str = "human"
18    metadata: Dict = field(default_factory=dict)
19
20class StratifiedDatasetBuilder:
21    def __init__(self, min_per_stratum: int = 30):
22        self.min_per_stratum = min_per_stratum
23        self._pool: List[EvalCase] = []
24        self._strata: Dict[str, List[EvalCase]] = defaultdict(list)
25
26    def add_cases(self, cases: List[EvalCase]) -> None:
27        for case in cases:
28            if case.category not in TASK_CATEGORIES:
29                raise ValueError(f"Unknown category: {case.category}")
30            if case.difficulty not in DIFFICULTY_LEVELS:
31                raise ValueError(f"Unknown difficulty: {case.difficulty}")
32            key = f"{case.category}::{case.difficulty}"
33            self._strata[key].append(case)
34            self._pool.append(case)
35
36    def coverage_report(self) -> Dict[str, int]:
37        report = {}
38        for cat in TASK_CATEGORIES:
39            for diff in DIFFICULTY_LEVELS:
40                key = f"{cat}::{diff}"
41                report[key] = len(self._strata.get(key, []))
42        return report
43
44    def build(self, per_stratum: Optional[int] = None,
45              seed: int = 42) -> List[EvalCase]:
46        target = per_stratum or self.min_per_stratum
47        random.seed(seed)
48        dataset = []
49        for cat in TASK_CATEGORIES:
50            for diff in DIFFICULTY_LEVELS:
51                key = f"{cat}::{diff}"
52                stratum = self._strata.get(key, [])
53                if len(stratum) < target:
54                    raise ValueError(
55                        f"Stratum '{key}' has {len(stratum)} cases, "
56                        f"need {target}. Add more cases or use "
57                        f"synthetic augmentation."
58                    )
59                dataset.extend(random.sample(stratum, target))
60        return dataset

• મોડ્યુલ ઇમ્પોર્ટ્સ collections માંથી defaultdict (જે દરેક સ્ટ્રેટમ કી માટે સ્વચાલિત લિસ્ટ ઇનિશિયલાઇઝેશન સક્ષમ કરે છે) અને dataclasses માંથી field (જે મ્યુટેબલ ડિફોલ્ટ મૂલ્યો માટે ફેક્ટરી પૂરી પાડે છે) લાવે છે.
• TASK_CATEGORIES અને DIFFICULTY_LEVELS બે સ્ટ્રેટિફિકેશન અક્ષોને મોડ્યુલ-સ્તરના કોન્સ્ટન્ટ તરીકે વ્યાખ્યાયિત કરે છે. આ યાદીઓને કેન્દ્રિત કરવાથી સુનિશ્ચિત થાય છે કે દરેક ડાઉનસ્ટ્રીમ ઘટક કેટેગરી અને મુશ્કેલી સ્તરના સમાન કેનોનિકલ સેટનો સંદર્ભ લે.
• EvalCase dataclass એક ટેસ્ટ કેસ માટે સંપૂર્ણ મેટાડેટા એન્વેલપ પકડે છે. provenance ફીલ્ડ ડિફોલ્ટ રૂપે "human" છે પણ NeMo Safe Synthesizer જેવા ટૂલ્સ દ્વારા જનરેટ થયેલા કેસો માટે "synthetic" સ્વીકારે છે. metadata ડિક્શનરી મ્યુટેબલ-ડિફોલ્ટ-આર્ગ્યુમેન્ટની મુશ્કેલી ટાળવા માટે field(default_factory=dict) નો ઉપયોગ કરે છે.
• StratifiedDatasetBuilder.__init__ લઘુત્તમ-પ્રતિ-સ્ટ્રેટમ થ્રેશોલ્ડ સેટ કરે છે અને ફ્લેટ પૂલ તથા સ્ટ્રેટમ ડિક્શનરી બંનેને ઇનિશિયલાઇઝ કરે છે. defaultdict(list) સુનિશ્ચિત કરે છે કે નવી સ્ટ્રેટમ કીમાં ઉમેરવાથી ક્યારેય KeyError ન ઉઠે.
• add_cases દરેક કેસને યોગ્ય સ્ટ્રેટમમાં દાખલ કરતા પહેલાં કેનોનિકલ અક્ષો સામે માન્ય કરે છે. અજાણી કેટેગરી પર ValueError ઉઠાવવાથી મૂલ્યાંકન સમયે નહીં પણ ઇન્જેશન સમયે સ્કીમા શિસ્ત લાગુ થાય છે.
• coverage_report કેટેગરી અને મુશ્કેલી સ્તરના સંપૂર્ણ ક્રોસ-પ્રોડક્ટ પર ફરે છે, અને દરેક સેલ માટે ગણતરી પરત કરે છે. શૂન્ય કેસવાળા સ્ટ્રેટા તરત જ સામે આવે છે, જે બિલ્ડ પર કમિટ થતા પહેલાં ગેપ વિશ્લેષણને સરળ બનાવે છે.
• build મુખ્ય સેમ્પલિંગ રૂટિન છે. તે પુનઃઉત્પાદનક્ષમતા માટે રેન્ડમ નંબર જનરેટરને સીડ કરે છે — ડેટાસેટ વર્ઝનિંગ માટે નિર્ણાયક — અને દરેક સ્ટ્રેટમમાંથી બરાબર target કેસો ખેંચે છે. જો કોઈ સ્ટ્રેટમ ઓછી વસ્તીવાળું હોય, તો તે કવરેજને મૌનપણે ઘટાડવાને બદલે સિન્થેટિક ઑગ્મેન્ટેશન સૂચવતા કાર્યક્ષમ સંદેશ સાથે ValueError ઉઠાવે છે.

દૂષણ-જાગૃત ડેટાસેટ સ્પ્લિટ્સ

જો મૂલ્યાંકન કેસો મોડેલના ટ્રેનિંગ ડેટામાં લીક થઈ ગયા હોય તો સ્ટ્રેટિફાઇડ ડેટાસેટ નકામો છે. અંતિમ ગોલ્ડન ડેટાસેટ લૉક થતા પહેલાં દૂષણ શોધ થવી જ જોઈએ. પ્રમાણભૂત અભિગમ દરેક મૂલ્યાંકન પ્રોમ્પ્ટ અને જાણીતા ટ્રેનિંગ દસ્તાવેજોના સંદર્ભ કોર્પસ વચ્ચે n-gram ઓવરલેપની ગણતરી કરે છે. ઓવરલેપ થ્રેશોલ્ડ (સામાન્ય રીતે 80% થી ઉપર 8-gram ઓવરલેપ) ઓળંગતા કેસોને ફ્લેગ કરીને બાકાત કરવામાં આવે છે.

નીચેનો કોડ ContaminationChecker ક્લાસનો ઉપયોગ કરીને હળવું દૂષણ ચેકર અમલમાં મૂકે છે. check મેથડ દરેક મૂલ્યાંકન પ્રોમ્પ્ટમાંથી કેરેક્ટર-સ્તરના n-grams કાઢે છે, તેમને પૂર્વ-નિર્મિત ટ્રેનિંગ n-grams ના સેટ સામે સરખાવે છે, અને દૂષણ ગુણોત્તર પરત કરે છે. જ્યાં ગુણોત્તર કૉન્ફિગર કરી શકાય તેવા threshold પેરામીટરને ઓળંગે તે કેસોને is_contaminated ને True સેટ કરીને ફ્લેગ કરવામાં આવે છે, જે ડેટાસેટને પુનઃઉત્પાદનક્ષમ, Git-ટ્રેક કરેલા સ્નેપશોટમાં અંતિમ બનાવતા પહેલાં ડાઉનસ્ટ્રીમ ફિલ્ટરિંગ સક્ષમ કરે છે.

Code snippetpython
1from typing import Set, Tuple
2
3class ContaminationChecker:
4    def __init__(self, training_corpus: List[str], n: int = 8,
5                 threshold: float = 0.80):
6        self.n = n
7        self.threshold = threshold
8        self.training_ngrams: Set[str] = set()
9        for doc in training_corpus:
10            self.training_ngrams.update(self._extract_ngrams(doc))
11
12    def _extract_ngrams(self, text: str) -> Set[str]:
13        tokens = text.lower().split()
14        if len(tokens) < self.n:
15            return set()
16        return {" ".join(tokens[i:i + self.n])
17                for i in range(len(tokens) - self.n + 1)}
18
19    def check(self, case: EvalCase) -> Tuple[bool, float]:
20        case_ngrams = self._extract_ngrams(case.prompt)
21        if not case_ngrams:
22            return False, 0.0
23        overlap = case_ngrams & self.training_ngrams
24        ratio = len(overlap) / len(case_ngrams)
25        is_contaminated = ratio >= self.threshold
26        return is_contaminated, ratio
27
28    def filter_dataset(self, cases: List[EvalCase]) -> List[EvalCase]:
29        clean = []
30        for case in cases:
31            contaminated, ratio = self.check(case)
32            if not contaminated:
33                clean.append(case)
34            else:
35                case.metadata["contamination_ratio"] = ratio
36        return clean

• typing માંથી Set અને Tuple ઇમ્પોર્ટ્સ સ્પષ્ટ ટાઇપ એનોટેશન પૂરા પાડે છે જે શેર કરેલા કોડબેઝમાં વાંચનક્ષમતા સુધારે છે.
• ContaminationChecker.__init__ ટ્રેનિંગ કોર્પસમાંથી n-grams નો સંપૂર્ણ સેટ પૂર્વ-ગણતરી કરે છે. તેમને set માં સંગ્રહવાથી ચેક તબક્કા દરમિયાન O(1) સભ્યપદ પરીક્ષણ સક્ષમ બને છે. n પેરામીટર ડિફોલ્ટ રૂપે 8 છે, જે સાચા ઓવરલેપ પકડવા અને સામાન્ય શબ્દસમૂહોમાંથી ખોટા પોઝિટિવ ટાળવા વચ્ચે સંતુલન સાધે છે.
• _extract_ngrams ટેક્સ્ટને લોઅરકેસ કરે છે, વ્હાઇટસ્પેસ પર ટોકનાઇઝ કરે છે, અને બધી સળંગ n-ટોકન વિન્ડો જનરેટ કરે છે. જો ટેક્સ્ટ n ટોકન કરતાં ટૂંકો હોય, તો તે ખામીયુક્ત આંશિક n-grams જનરેટ કરવાનું ટાળવા ખાલી સેટ પરત કરે છે.
• check કેસના n-grams અને ટ્રેનિંગ સેટ વચ્ચે ઇન્ટરસેક્શન ગણે છે, પછી દૂષણ ગુણોત્તરની ગણતરી કરે છે. બુલિયન is_contaminated જ્યારે ગુણોત્તર થ્રેશોલ્ડને મળે અથવા ઓળંગે ત્યારે True હોય છે, અન્યથા False.
• filter_dataset બધા કેસો પર ફરે છે અને માત્ર સ્વચ્છ કેસો જાળવી રાખે છે. દૂષિત કેસોને મૌનપણે કાઢી નાખવામાં આવતા નથી — તેમની metadata ડિક્શનરીમાં દૂષણ ગુણોત્તર નોંધવામાં આવે છે, જે ડેટાસેટ કાર્ડ દ્વારા ઓડિટિંગ સક્ષમ કરે છે. ડેટાસેટ વર્ઝનિંગ માટે આ પારદર્શિતા આવશ્યક છે: દરેક બાકાત ટ્રેસ કરી શકાય તેવું હોવું જોઈએ.

શિસ્ત-વિશિષ્ટ ઉપયોગ

શું કરવું અને શું ન કરવું

શું કરવું

1. build() બોલાવતા પહેલાં coverage_report() બોલાવો — તે per_stratum લક્ષ્ય પર કમિટ થતા પહેલાં બધા 15 સ્ટ્રેટા (5 કેટેગરી × 3 મુશ્કેલી સ્તર) માં પ્રતિ-સેલ ગણતરીઓ સામે લાવે છે, જેથી તમને સિન્થેટિક કેસો વડે વિરલ સેલ વધારવાનો સમય મળે, બદલે કે પાઇપલાઇનની મધ્યમાં StratifiedDatasetBuilder.build ની ValueError નો સામનો કરવો પડે જ્યારે દિશા સુધારવામાં ઘણું મોડું થઈ ગયું હોય.
2. StratifiedDatasetBuilder.build ને નિશ્ચિત seed પૂર્ણાંક પાસ કરો — random.sample પહેલાં random.seed(seed) દરેક સ્ટ્રેટમ-અંદરના ડ્રૉને પુનઃઉત્પાદનક્ષમ બનાવે છે, જેથી સમાન પૂલ પર સમાન બિલ્ડર ચલાવતા બે એન્જિનિયરોને સમાન ગોલ્ડન ડેટાસેટ મળે અને મોડેલ વર્ઝન વચ્ચેની પાસ-રેટ સરખામણીઓ સેમ્પલિંગ ભિન્નતા નહીં પણ મૂલ્યાંકન-સેટની ઓળખ દર્શાવે.
3. દરેક EvalCase પર provenance ફીલ્ડને "human" અથવા "synthetic" વડે ભરો — પ્રોવેનન્સ દ્વારા પાસ-રેટ વિશ્લેષણ વિભાજિત કરવાથી એવા જનરલાઇઝેશન ગેપ સામે આવે છે જે પ્રોવેનન્સ-અંધ કુલ આંકડો છુપાવે છે: માનવ-લિખિત reasoning કેસો પર 94% પણ સિન્થેટિક રીતે જનરેટ થયેલા પર 71% સ્કોર કરતું મોડેલ એવી રીતે નિષ્ફળ જઈ રહ્યું છે જે એકંદર આંકડો ક્યારેય પ્રગટ કરતો નથી.

શું ન કરવું

1. કાચા ટેસ્ટ પૂલમાંથી મૂલ્યાંકન કેસોને એકસમાન રીતે રેન્ડમ ન ખેંચો — સરળ કેસો અને વધુ પડતી રજૂ થયેલી ટાસ્ક કેટેગરીઓ સેમ્પલ પર વર્ચસ્વ જમાવે છે, તેથી hard::reasoning અથવા hard::extraction સ્ટ્રેટા પર વિનાશક રીતે નિષ્ફળ જતું મોડેલ હજુ પણ 90ના ઊંચા દાયકાની ચોકસાઈ દર્શાવે છે જ્યારે મોટાભાગના ડ્રૉ easy::classification હોય, જે એવો ડેશબોર્ડ આંકડો બનાવે છે જે પ્રોડક્શન-રેડી દેખાય છે જ્યારે રિગ્રેશન વાસ્તવિક વપરાશકર્તાઓને પહોંચે છે.
2. જ્યારે કોઈ સ્ટ્રેટમ ઓછી વસ્તીવાળું હોય ત્યારે StratifiedDatasetBuilder.build જે ValueError ઉઠાવે છે તેને પકડો કે દબાવો નહીં — ભૂલ બરાબર ત્યારે જ ફાયર થાય છે જ્યારે સેલની કેસ ગણતરી target (ડિફોલ્ટ રૂપે min_per_stratum) થી નીચે આવે, અને જે કેસો અસ્તિત્વમાં છે તેની સાથે મૌનપણે આગળ વધવાથી આંકડાકીય શક્તિ 95% કોન્ફિડન્સ પર પાંચ ટકા-પોઇન્ટના માર્જિન ઑફ એરરથી નીચે આવી જાય છે જે લઘુત્તમ-ગણતરી ડિઝાઇન ગેરંટી આપે છે.
3. EvalCase માં field(default_factory=dict) ને ખાલી {} ડિફોલ્ટથી બદલશો નહીં — શેર કરેલું મ્યુટેબલ ડિફોલ્ટ સ્પષ્ટ મેટાડેટા વિના બનાવેલા દરેક કેસને સમાન ડિક્શનરી ઑબ્જેક્ટનો સંદર્ભ અપાવે છે, તેથી એક કેસની મેટાડેટા ડિક્ટમાં ફેરફાર કરવાથી બીજા બધા મૌનપણે ઝેરી બને છે અને પ્રોવેનન્સ તથા સહાયક ફીલ્ડ્સ દૂષિત થાય છે જેના પર ડાઉનસ્ટ્રીમ દૂષણ ચેક અને ડેટાસેટ વર્ઝનિંગ આધાર રાખે છે.