స్ట్రాటిఫైడ్ మూల్యాంకన డేటాసెట్‌ను నిర్మించండి

పరిచయం

ముడి టెస్ట్ పూల్ నుండి మూల్యాంకన కేసులను ఏకరీతిగా యాదృచ్ఛికంగా తీసుకున్నప్పుడు, వచ్చే ఖచ్చితత్వ సంఖ్య అబద్ధం చెబుతుంది — సులభమైన కేసులు మరియు అధికంగా ప్రాతినిధ్యం ఉన్న టాస్క్ కేటగిరీలు సిగ్నల్‌ను ముంచెత్తుతాయి, మరియు అరుదైన-కానీ-కీలకమైన స్ట్రాటాలపై ఘోరంగా విఫలమయ్యే మోడల్ ఇంకా 90ల పైభాగంలో స్కోరు చేస్తుంది. దీని పర్యవసానం ఏమిటంటే, డాష్‌బోర్డ్‌లో ప్రొడక్షన్-రెడీగా కనిపించే హోస్టెడ్ LLM నిజమైన వినియోగదారులకు రిగ్రెషన్‌ను షిప్ చేస్తుంది. ఈ పాఠం ముగిసే సమయానికి, మీరు టెస్ట్-కేస్ పూల్‌ను టాస్క్ కేటగిరీ మరియు కష్టతా స్థాయి ద్వారా విభజించగలరు, ఆడిట్ చేయగల ప్రతి-స్ట్రాటమ్ కౌంట్‌లతో సమతుల్య శాంపిల్‌ను తీయగలరు, మరియు గోల్డెన్ డేటాసెట్‌ను లాక్ చేయడానికి ముందు కలుషితమైన కేసులను ఫిల్టర్ చేయగలరు.

కీలక పదజాలం

• స్ట్రాటమ్ (Stratum): (టాస్క్ కేటగిరీ, కష్టత) జంట ద్వారా నిర్వచించబడిన టెస్ట్-కేస్ పూల్ యొక్క అతివ్యాప్తి లేని విభజన; ప్రతి-సెల్ కౌంట్‌లను నియంత్రించడానికి శాంప్లింగ్ ప్రతి స్ట్రాటమ్ నుండి స్వతంత్రంగా తీస్తుంది.
• గోల్డెన్ డేటాసెట్ (Golden dataset): స్ట్రాటిఫైడ్ శాంప్లింగ్ మరియు కాలుష్య ఫిల్టరింగ్‌ను దాటి మిగిలిన, మార్పులేని, వెర్షన్ చేయబడిన మూల్యాంకన బెంచ్‌మార్క్, ప్రతి మోడల్ విడుదలకు వ్యతిరేకంగా స్కోరు చేయబడుతుంది.
• కాలుష్య నిష్పత్తి (Contamination ratio): ఒక టెస్ట్ కేసు యొక్క n-గ్రామ్‌లలో రిఫరెన్స్ ట్రెయినింగ్ కార్పస్‌లో కూడా కనిపించే భాగం; కాన్ఫిగర్ చేసిన థ్రెషోల్డ్ పైన ఉన్న కేసులు డేటాసెట్ లాక్ చేయడానికి ముందు మినహాయించబడతాయి.
• ప్రోవెనెన్స్ (Provenance): కేసు ఎలా రచించబడిందో నమోదు చేసే ప్రతి-కేసు లేబుల్ (ఉదా. "human" లేదా "synthetic"), తద్వారా డేటాసెట్ కార్డ్‌లు మానవ-vs-సింథటిక్ కూర్పును నివేదిస్తాయి.

భావనలు

LLM మూల్యాంకనానికి సాధారణ యాదృచ్ఛిక శాంప్లింగ్ ఎందుకు విఫలమవుతుంది

ముడి టెస్ట్-కేస్ పూల్ నుండి యాదృచ్ఛిక శాంప్లింగ్ రెండు వ్యవస్థాగత ప్రమాదాలను పరిచయం చేస్తుంది. మొదటిది, కేటగిరీ అసమతుల్యత: మీ పూల్‌లో 400 క్లాసిఫికేషన్ ఉదాహరణలు ఉండి, కేవలం 30 జనరేషన్ ఉదాహరణలు మాత్రమే ఉంటే, 200 కేసుల యాదృచ్ఛిక డ్రా జనరేషన్ సామర్థ్యం తక్కువగా పరీక్షించబడుతుందని దాదాపు హామీ ఇస్తుంది. రెండవది, కష్టతా వక్రత: అనోటేటర్లు సరళమైన కేసులను వేగంగా తయారు చేస్తారు కాబట్టి సులభమైన ఉదాహరణలు కష్టమైన వాటి కంటే ఎక్కువగా ఉంటాయి, అందువల్ల యాదృచ్ఛిక శాంప్లింగ్ కృత్రిమంగా పెంచబడిన ఖచ్చితత్వ మెట్రిక్‌ను ఇస్తుంది. స్ట్రాటిఫైడ్ శాంప్లింగ్ పూల్‌ను స్ట్రాటాలుగా విభజించడం ద్వారా — టాస్క్ కేటగిరీ మరియు కష్టతా స్థాయి యొక్క క్రాస్-ప్రొడక్ట్ ద్వారా నిర్వచించబడినవి — మరియు ప్రతి స్ట్రాటమ్ నుండి స్వతంత్రంగా తీయడం ద్వారా రెండు ప్రమాదాలను తొలగిస్తుంది. ఫలితంగా ప్రతి (కేటగిరీ, కష్టత) సెల్‌కు నియంత్రిత, ఆడిట్ చేయగల కౌంట్ ఉన్న డేటాసెట్ లభిస్తుంది.

తక్కువ ప్రాతినిధ్యం ఉన్న స్ట్రాటాలు మరియు ఎడ్జ్ కేసులను నిర్వహించడం

ప్రొడక్షన్ మూల్యాంకన పూల్‌లలో దాదాపు ఎప్పుడూ విరళమైన స్ట్రాటాలు ఉంటాయి. కష్టమైన-స్థాయి జనరేషన్ కేసులు ప్రసిద్ధంగా అరుదు, ఎందుకంటే వాటికి మోడల్‌ను సూక్ష్మ వైఫల్య రీతుల్లోకి — హాలూసినేషన్, ఇన్‌స్ట్రక్షన్ డ్రిఫ్ట్, లేదా స్టైల్ కొలాప్స్ — నెట్టగల ప్రాంప్ట్‌లను రూపొందించగల నిపుణ అనోటేటర్లు అవసరం. మూడు వ్యూహాలు ఈ ఖాళీని పూరిస్తాయి:

• అడ్వర్సేరియల్ ఉదాహరణ ఇంజెక్షన్: తెలిసిన మోడల్ బలహీనతలను లక్ష్యంగా చేసుకునే ఎడ్జ్ కేసులను మాన్యువల్‌గా లేదా ప్రోగ్రామాటిక్‌గా రూపొందించండి. ఎక్స్‌ట్రాక్షన్ టాస్క్‌ల కోసం, ఇది అస్పష్టమైన ఎంటిటీ సరిహద్దులను సూచిస్తుంది; రీజనింగ్ టాస్క్‌ల కోసం, ఇది నమ్మదగిన డిస్ట్రాక్టర్లతో కూడిన బహుళ-దశల ప్రశ్నలను సూచిస్తుంది. Patronus Generative Simulators వైఫల్య ఉపరితలాలను క్రమబద్ధంగా పరిశీలించి, పెద్ద స్థాయిలో అడ్వర్సేరియల్ ప్రాంప్ట్‌లను ఉత్పత్తి చేయడం ద్వారా దీన్ని ఆటోమేట్ చేస్తాయి.

• సింథటిక్ డేటా జనరేషన్: NeMo Safe Synthesizer డిఫరెన్షియల్ ప్రైవసీ హామీలతో గోప్యత-అనుకూల సింథటిక్ కేసులను ఉత్పత్తి చేస్తుంది, మీ ట్రెయినింగ్ లేదా అనోటేషన్ పైప్‌లైన్‌ల నుండి PII లీక్ కాకుండా విరళమైన స్ట్రాటాలను పెంపొందించడానికి అనుమతిస్తుంది. డౌన్‌స్ట్రీమ్ డేటాసెట్ కార్డ్‌లు కూర్పును ఖచ్చితంగా నివేదించడానికి సింథటిక్ కేసులు provenance="synthetic" ను కలిగి ఉండాలి.

• ఇంటర్-అనోటేటర్ అగ్రిమెంట్ రీ-కాలిబ్రేషన్: కష్టతా లేబుల్‌లు నమ్మదగనివిగా ఉన్నప్పుడు, అనోటేటర్ అగ్రిమెంట్ స్కోర్ల నుండి వాటిని తిరిగి గణించండి. 0.6 (Fleiss' kappa) కంటే తక్కువ అగ్రిమెంట్ ఉన్న కేసులు hard కు ప్రమోట్ చేయబడతాయి; 0.9 పైన ఉన్న కేసులు easy కు డీమోట్ చేయబడతాయి. ఈ రీ-కాలిబ్రేషన్ తరచుగా కేసులను స్ట్రాటాల అంతటా పునఃపంపిణీ చేస్తుంది మరియు కొత్త డేటాను ఉత్పత్తి చేయకుండానే విరళతను పరిష్కరించగలదు.

గోల్డెన్ డేటాసెట్‌ను సమీకరించడం

స్ట్రాటిఫైడ్ శాంప్లింగ్ మరియు కాలుష్య ఫిల్టరింగ్ పూర్తయిన తర్వాత, మిగిలిన కేసులు గోల్డెన్ డేటాసెట్‌ను ఏర్పరుస్తాయి — ప్రతి మోడల్ వెర్షన్ స్కోరు చేయబడే మార్పులేని రిఫరెన్స్ బెంచ్‌మార్క్. గోల్డెన్ డేటాసెట్‌తో పాటు స్ట్రాటిఫికేషన్ గ్రిడ్, ప్రతి-స్ట్రాటమ్ కౌంట్‌లు, కాలుష్య మినహాయింపు కౌంట్‌లు, ప్రోవెనెన్స్ విభజన (మానవ vs. సింథటిక్), కష్టతా లేబుల్‌ల కోసం ఇంటర్-అనోటేటర్ అగ్రిమెంట్ గణాంకాలు, మరియు స్నాప్‌షాట్ యొక్క Git కమిట్ హ్యాష్‌ను డాక్యుమెంట్ చేసే డేటాసెట్ కార్డ్ ఉండాలి. ఈ మెటాడేటా జట్ల అంతటా మరియు కాలక్రమేణా పునరుత్పాదక మూల్యాంకనాన్ని సాధ్యం చేస్తుంది — ఆడిట్ ట్రెయిల్స్ చర్చకు అతీతమైన గవర్నెన్స్ ఫ్రేమ్‌వర్క్‌ల కింద పనిచేసే ఏ సంస్థకైనా ఇది అవసరం.

ఆచరణాత్మక వర్క్‌ఫ్లో ఇది: సమతుల్య డ్రాను ఉత్పత్తి చేయడానికి StratifiedDatasetBuilder.build ను రన్ చేయండి, ఫలితాన్ని ContaminationChecker.filter_dataset ద్వారా పంపండి, ఫిల్టరింగ్ తర్వాత ఏ స్ట్రాటమ్ కూడా కనీస కౌంట్ కంటే తగ్గలేదని ధృవీకరించండి (అవసరమైతే NeMo Safe Synthesizer తో తిరిగి పెంపొందించండి), తుది జాబితాను వెర్షన్ చేసిన JSON ఫైల్‌కు సీరియలైజ్ చేయండి, మరియు దాని డేటాసెట్ కార్డ్‌తో పాటు కమిట్ చేయండి. డేటాసెట్ కార్డ్ అనేది డేటాసెట్‌లో ఏమి ఉంది, ఎందుకు నిర్మించబడింది, మరియు ఎలా ఉపయోగించాలి అనే దానికి ఏకైక సత్య మూలంగా పనిచేసే నిర్మాణాత్మక markdown లేదా JSON డాక్యుమెంట్ — మోడల్ కార్డ్‌కు సారూప్యమైనది కానీ మూల్యాంకన డేటాకు పరిమితమైనది. ఆటోమేటెడ్ డేటాసెట్ రిఫ్రెష్ పైప్‌లైన్‌లు పాతబడడాన్ని గుర్తించినప్పుడు (మరొక గోల్‌లో కవర్ చేయబడింది), అవి ఇదే పైప్‌లైన్ ద్వారా రీ-క్యూరేషన్‌ను ట్రిగ్గర్ చేస్తాయి, గోల్డెన్ డేటాసెట్ యొక్క ప్రతి కొత్త వెర్షన్ అదే స్ట్రాటిఫికేషన్ హామీలు మరియు కాలుష్య రక్షణలను వారసత్వంగా పొందుతుందని నిర్ధారిస్తాయి.

కోడ్ వాక్‌త్రూ

స్ట్రాటిఫికేషన్ అక్షాలను నిర్వచించడం

హోస్టెడ్-LLM మూల్యాంకనం కోసం, రెండు ప్రాథమిక అక్షాలు స్ట్రాటిఫికేషన్ గ్రిడ్‌ను ఏర్పరుస్తాయి:

• టాస్క్ కేటగిరీ: పరీక్షించబడుతున్న ఫంక్షనల్ సామర్థ్యం. GPT-4o వంటి సాధారణ-ప్రయోజన మోడల్‌కు సాధారణ కేటగిరీలలో క్లాసిఫికేషన్, సమరైజేషన్, ఎక్స్‌ట్రాక్షన్, జనరేషన్, మరియు రీజనింగ్ ఉంటాయి. ప్రతి కేటగిరీ వేరొక అంతర్గత మార్గాన్ని ఉపయోగిస్తుంది — క్లాసిఫికేషన్ లేబుల్ ఖచ్చితత్వాన్ని కోరుతుంది, జనరేషన్ పొడవైన అవుట్‌పుట్‌లపై సమన్వయం మరియు ప్రవాహాన్ని కోరుతుంది.

• కష్టతా స్థాయి: టెస్ట్ కేసు యొక్క జ్ఞానాత్మక లేదా గణన సంక్లిష్టతను పట్టుకునే వివిక్త స్కేల్ (సాధారణంగా easy, medium, hard). కష్టత తరచుగా ఇంటర్-అనోటేటర్ అగ్రిమెంట్ ద్వారా అమలు చేయబడుతుంది: సరైన సమాధానంపై అనోటేటర్లు ఏకగ్రీవంగా అంగీకరించే కేసులు easy, పాక్షిక అసమ్మతి ఉన్న కేసులు medium, మరియు నిపుణులు కూడా విభేదించే కేసులు hard.

ఐదు కేటగిరీలు మరియు మూడు కష్టతా స్థాయిల క్రాస్-ప్రొడక్ట్ పదిహేను స్ట్రాటాలను ఇస్తుంది. బాగా రూపొందించిన గోల్డెన్ డేటాసెట్ ప్రతి సెల్‌కు కనీస కౌంట్‌ను కేటాయిస్తుంది — సాధారణంగా 20 నుండి 50 కేసులు — 95% విశ్వాసంతో ఐదు శాతం పాయింట్ల కంటే తక్కువ లోప మార్జిన్‌తో ప్రతి-సెల్ పాస్-రేట్ అంచనాలకు గణాంక శక్తిని నిర్ధారిస్తుంది.

టెస్ట్-కేస్ స్కీమాను రూపొందించడం

మూల్యాంకన డేటాసెట్‌లోని ప్రతి టెస్ట్ కేసు స్ట్రాటిఫైడ్ డ్రాలు, కాలుష్య గుర్తింపు, మరియు పునరుత్పాదక డేటాసెట్ వెర్షనింగ్‌కు మద్దతు ఇవ్వడానికి సరిపడా మెటాడేటాను కలిగి ఉండాలి. కనీస ఆచరణీయ స్కీమాలో ఇవి ఉంటాయి: ప్రాంప్ట్ టెక్స్ట్, ఆశించిన రిఫరెన్స్ అవుట్‌పుట్, టాస్క్ కేటగిరీ లేబుల్, కష్టతా స్థాయి, ట్రేసబిలిటీ కోసం ప్రత్యేక కేసు ఐడెంటిఫైయర్, మరియు కేసు మానవ-రచితమా లేదా సింథటిక్‌గా ఉత్పత్తి చేయబడిందా అని సూచించే ప్రోవెనెన్స్ ఫీల్డ్ (గోప్యత-అనుకూల సింథటిక్ డేటా కోసం NeMo Safe Synthesizer ను లేదా అడ్వర్సేరియల్ ఉదాహరణల కోసం Patronus Generative Simulators ను తర్వాత ఇంటిగ్రేట్ చేసినప్పుడు ఇది సంబంధితం).

కింది కోడ్ EvalCase డేటాక్లాస్‌ను మరియు ముడి టెస్ట్ కేసులను స్వీకరించి, వాటిని స్ట్రాటాలుగా బకెట్ చేసి, సమతుల్య శాంపిల్‌ను తీసే 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 డేటాక్లాస్ ఒకే టెస్ట్ కేసు కోసం పూర్తి మెటాడేటా ఎన్వలప్‌ను పట్టుకుంటుంది. 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-గ్రామ్ అతివ్యాప్తిని గణిస్తుంది. అతివ్యాప్తి థ్రెషోల్డ్‌ను మించిన కేసులు (సాధారణంగా 80% పైన 8-గ్రామ్ అతివ్యాప్తి) ఫ్లాగ్ చేయబడి మినహాయించబడతాయి.

కింది కోడ్ ContaminationChecker క్లాస్‌ను ఉపయోగించి తేలికపాటి కాలుష్య చెకర్‌ను అమలు చేస్తుంది. check మెథడ్ ప్రతి మూల్యాంకన ప్రాంప్ట్ నుండి క్యారెక్టర్-స్థాయి n-గ్రామ్‌లను వెలికితీస్తుంది, వాటిని ముందుగా నిర్మించిన ట్రెయినింగ్ n-గ్రామ్‌ల సెట్‌తో పోల్చుతుంది, మరియు కాలుష్య నిష్పత్తిని తిరిగి ఇస్తుంది. నిష్పత్తి కాన్ఫిగర్ చేయగల 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-గ్రామ్‌ల పూర్తి సెట్‌ను ముందుగా గణిస్తుంది. వాటిని set లో నిల్వ చేయడం చెక్ దశలో O(1) మెంబర్‌షిప్ టెస్ట్‌లను సాధ్యం చేస్తుంది. n పారామీటర్ డిఫాల్ట్‌గా 8, ఇది నిజమైన అతివ్యాప్తులను పట్టుకోవడం మరియు సాధారణ పదబంధాల నుండి తప్పుడు పాజిటివ్‌లను నివారించడం మధ్య సమతుల్యతను సాధిస్తుంది.
• _extract_ngrams టెక్స్ట్‌ను లోయర్‌కేస్ చేస్తుంది, వైట్‌స్పేస్‌పై టోకనైజ్ చేస్తుంది, మరియు అన్ని వరుస n-టోకెన్ విండోలను ఉత్పత్తి చేస్తుంది. టెక్స్ట్ n టోకెన్ల కంటే తక్కువగా ఉంటే, క్షీణ పాక్షిక n-గ్రామ్‌లను ఉత్పత్తి చేయకుండా ఖాళీ సెట్‌ను తిరిగి ఇస్తుంది.
• check కేసు n-గ్రామ్‌లు మరియు ట్రెయినింగ్ సెట్ మధ్య ఖండనను గణిస్తుంది, ఆపై కాలుష్య నిష్పత్తిని లెక్కిస్తుంది. నిష్పత్తి థ్రెషోల్డ్‌ను చేరినప్పుడు లేదా మించినప్పుడు బూలియన్ 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 స్ట్రాటాలపై విపత్కరంగా విఫలమయ్యే మోడల్ ఎక్కువ డ్రాలు easy::classification అయినప్పుడు ఇంకా 90ల పైభాగంలో ఖచ్చితత్వాన్ని నమోదు చేస్తుంది, నిజమైన వినియోగదారులకు రిగ్రెషన్ షిప్ అవుతున్నప్పుడు ప్రొడక్షన్-రెడీగా కనిపించే డాష్‌బోర్డ్ సంఖ్యను ఉత్పత్తి చేస్తుంది.
2. స్ట్రాటమ్ తక్కువ-జనాభాతో ఉన్నప్పుడు StratifiedDatasetBuilder.build రైజ్ చేసే ValueError ను పట్టుకోవడం లేదా అణచివేయడం చేయకండి — సెల్ కేసు కౌంట్ target (డిఫాల్ట్‌గా min_per_stratum) కంటే తగ్గినప్పుడు ఖచ్చితంగా ఆ లోపం ఫైర్ అవుతుంది, మరియు ఉన్న కేసులతో నిశ్శబ్దంగా ముందుకు సాగడం కనీస-కౌంట్ డిజైన్ హామీ ఇచ్చే 95% విశ్వాసంతో ఐదు-శాతం-పాయింట్ల లోప మార్జిన్ కంటే గణాంక శక్తిని తగ్గిస్తుంది.
3. EvalCase లో field(default_factory=dict) ను బేర్ {} డిఫాల్ట్‌తో భర్తీ చేయకండి — షేర్డ్ మార్చగల డిఫాల్ట్ స్పష్టమైన మెటాడేటా లేకుండా ఇన్‌స్టాన్షియేట్ చేసిన ప్రతి కేసు అదే డిక్షనరీ ఆబ్జెక్ట్‌ను సూచించడానికి కారణమవుతుంది, అందువల్ల ఒక కేసు మెటాడేటా డిక్ట్‌ను మార్చడం ఇతరులన్నింటినీ నిశ్శబ్దంగా విషపూరితం చేస్తుంది మరియు డౌన్‌స్ట్రీమ్ కాలుష్య చెక్‌లు మరియు డేటాసెట్ వెర్షనింగ్ ఆధారపడే ప్రోవెనెన్స్ మరియు సహాయక ఫీల్డ్‌లను పాడు చేస్తుంది.