அடுக்கு முறை (stratified) மதிப்பீட்டு தரவுத்தொகுப்பை உருவாக்குங்கள்

அறிமுகம்

ஒரு மூலச் சோதனைத் தொகுப்பிலிருந்து மதிப்பீட்டு வழக்குகளை சீரான சீரற்ற முறையில் (uniformly at random) எடுக்கும்போது, கிடைக்கும் துல்லிய எண் பொய் சொல்கிறது — எளிதான வழக்குகளும் அதிகமாகப் பிரதிநிதித்துவம் பெற்ற பணி வகைகளும் சமிக்ஞையை மூழ்கடிக்கின்றன, மேலும் அரிதான-ஆனால்-முக்கியமான அடுக்குகளில் மோசமாகத் தோல்வியடையும் ஒரு மாடல் இன்னும் 90களின் உயர் மதிப்பெண்களைப் பெறுகிறது. இதன் விளைவு, டாஷ்போர்டில் உற்பத்திக்குத் தயாராக இருப்பது போலத் தோன்றும் ஒரு ஹோஸ்ட் செய்யப்பட்ட LLM, உண்மையான பயனர்களுக்கு ஒரு பின்னடைவை (regression) அனுப்புவதாகும். இந்தப் பாடத்தின் முடிவில், ஒரு சோதனை-வழக்குத் தொகுப்பைப் பணி வகை மற்றும் சிரமத்தின் அடிப்படையில் பிரிக்கவும், தணிக்கை செய்யக்கூடிய ஒவ்வொரு-அடுக்கு எண்ணிக்கைகளுடன் ஒரு சமநிலையான மாதிரியை எடுக்கவும், கோல்டன் தரவுத்தொகுப்பைப் பூட்டுவதற்கு முன் மாசுபட்ட வழக்குகளை வடிகட்டி நீக்கவும் உங்களுக்கு இயலும்.

முக்கிய சொற்கள்

• Stratum (அடுக்கு): ஒரு (பணி வகை, சிரமம்) இணையால் வரையறுக்கப்பட்ட, சோதனை-வழக்குத் தொகுப்பின் ஒன்றுடன் ஒன்று மேற்பொருந்தாத ஒரு பிரிவு; ஒவ்வொரு கலத்தின் எண்ணிக்கைகளைக் கட்டுப்படுத்த மாதிரியெடுப்பு ஒவ்வொரு அடுக்கிலிருந்தும் தனித்தனியாக எடுக்கிறது.
• Golden dataset (கோல்டன் தரவுத்தொகுப்பு): அடுக்கு மாதிரியெடுப்பு மற்றும் மாசு வடிகட்டலைக் கடந்து நிலைத்து நிற்கும், மாற்ற முடியாத, பதிப்பிடப்பட்ட மதிப்பீட்டு அளவுகோல்; ஒவ்வொரு மாடல் வெளியீட்டிற்கும் எதிராக மதிப்பெண் இடப்படுகிறது.
• Contamination ratio (மாசு விகிதம்): ஒரு சோதனை வழக்கின் n-gramகளில், ஒரு குறிப்புப் பயிற்சிக் கார்பஸிலும் தோன்றுவற்றின் பங்கு; உள்ளமைக்கப்பட்ட வரம்பை மீறும் வழக்குகள் தரவுத்தொகுப்பு பூட்டப்படுவதற்கு முன் விலக்கப்படுகின்றன.
• Provenance (மூலத்தடம்): வழக்கு எவ்வாறு எழுதப்பட்டது என்பதைப் பதிவு செய்யும் ஒவ்வொரு-வழக்கு லேபிள் (எ.கா. "human" அல்லது "synthetic"), இதனால் தரவுத்தொகுப்பு அட்டைகள் மனித-vs-செயற்கை கலவையைத் தெரிவிக்கின்றன.

கருத்துகள்

LLM மதிப்பீட்டிற்கு எளிய சீரற்ற மாதிரியெடுப்பு ஏன் தோல்வியடைகிறது

ஒரு மூலச் சோதனை-வழக்குத் தொகுப்பிலிருந்து சீரற்ற மாதிரியெடுப்பு இரண்டு முறைமை சார்ந்த அபாயங்களை அறிமுகப்படுத்துகிறது. முதலாவது, வகை சமநிலையின்மை: உங்கள் தொகுப்பில் 400 வகைப்படுத்தல் உதாரணங்கள் இருந்து, ஆனால் 30 உருவாக்க உதாரணங்கள் மட்டுமே இருந்தால், 200 வழக்குகளின் ஒரு சீரற்ற எடுப்பு, உருவாக்கத் திறன் குறைவாகச் சோதிக்கப்படுவதை ஏறக்குறைய உறுதி செய்யும். இரண்டாவது, சிரமச் சாய்வு: குறிப்பிடுபவர்கள் (annotators) எளிய வழக்குகளை வேகமாக உருவாக்குவதால், எளிதான உதாரணங்கள் கடினமானவற்றை விட அதிக எண்ணிக்கையில் இருக்கும்; எனவே சீரற்ற மாதிரியெடுப்பு செயற்கையாக உயர்த்தப்பட்ட துல்லிய அளவீட்டைத் தருகிறது. அடுக்கு மாதிரியெடுப்பு, தொகுப்பைப் பணி வகை மற்றும் சிரம நிலையின் குறுக்கு-பெருக்கத்தால் (cross-product) வரையறுக்கப்பட்ட அடுக்குகளாகப் பிரித்து, ஒவ்வொரு அடுக்கிலிருந்தும் தனித்தனியாக எடுப்பதன் மூலம் இரண்டு அபாயங்களையும் நீக்குகிறது. இதன் விளைவாக, ஒவ்வொரு (வகை, சிரமம்) கலமும் கட்டுப்படுத்தப்பட்ட, தணிக்கை செய்யக்கூடிய எண்ணிக்கையைக் கொண்ட ஒரு தரவுத்தொகுப்பு கிடைக்கிறது.

குறைவாகப் பிரதிநிதித்துவம் பெற்ற அடுக்குகளையும் விளிம்பு வழக்குகளையும் கையாளுதல்

உற்பத்தி மதிப்பீட்டுத் தொகுப்புகளில் ஏறக்குறைய எப்போதும் அரிதான அடுக்குகள் இருக்கும். கடின-சிரம உருவாக்க வழக்குகள் மிகவும் அரிதானவை என்பது பிரசித்தம், ஏனெனில் மாடலை நுட்பமான தோல்வி முறைகளுக்கு — மாயத்தோற்றம் (hallucination), அறிவுறுத்தல் விலகல் (instruction drift), அல்லது பாணி சரிவு (style collapse) — தள்ளும் ப்ராம்ப்ட்களை வடிவமைக்கக்கூடிய நிபுணக் குறிப்பிடுபவர்கள் இதற்குத் தேவை. மூன்று உத்திகள் இந்த இடைவெளியை நிரப்புகின்றன:

• எதிர்ப்பு உதாரண உட்செலுத்தல் (Adversarial example injection): அறியப்பட்ட மாடல் பலவீனங்களை இலக்காகக் கொண்ட விளிம்பு வழக்குகளைக் கையால் அல்லது நிரல் மூலம் வடிவமைக்கவும். பிரித்தெடுப்புப் பணிகளுக்கு, இது தெளிவற்ற நிறுவன எல்லைகளைக் (ambiguous entity boundaries) குறிக்கிறது; நியாயப்படுத்தல் (reasoning) பணிகளுக்கு, இது நம்பத்தகுந்த கவனச்சிதறல்களுடன் கூடிய பல-படி கேள்விகளைக் குறிக்கிறது. Patronus Generative Simulators தோல்வி மேற்பரப்புகளை முறையாக ஆராய்ந்து, எதிர்ப்பு ப்ராம்ப்ட்களைப் பெரிய அளவில் உருவாக்குவதன் மூலம் இதைத் தானியக்கமாக்குகின்றன.

• செயற்கைத் தரவு உருவாக்கம் (Synthetic data generation): NeMo Safe Synthesizer, வேறுபாட்டுத் தனியுரிமை (differential privacy) உத்தரவாதங்களுடன் தனியுரிமைக்கு இணங்கும் செயற்கை வழக்குகளை உருவாக்குகிறது; இது உங்கள் பயிற்சி அல்லது குறிப்பிடல் பைப்லைன்களிலிருந்து PII கசியாமல் அரிதான அடுக்குகளை மேம்படுத்த உங்களை அனுமதிக்கிறது. செயற்கை வழக்குகள் provenance="synthetic" ஐக் கொண்டிருக்க வேண்டும், இதனால் கீழ்நிலைத் தரவுத்தொகுப்பு அட்டைகள் கலவையைத் துல்லியமாகத் தெரிவிக்கும்.

• குறிப்பிடுபவர்களுக்கிடையேயான உடன்பாட்டின் மறு-அளவுத்திருத்தம் (Inter-annotator agreement re-calibration): சிரம லேபிள்கள் நம்பகமற்றதாக இருக்கும்போது, குறிப்பிடுபவர் உடன்பாட்டு மதிப்பெண்களிலிருந்து அவற்றை மீண்டும் கணக்கிடவும். 0.6 (Fleiss' kappa) க்குக் கீழே உடன்பாடு உள்ள வழக்குகள் கடினமானவையாக உயர்த்தப்படுகின்றன; 0.9 க்கு மேலே உள்ள வழக்குகள் எளிதானவையாகத் தாழ்த்தப்படுகின்றன. இந்த மறு-அளவுத்திருத்தம் பெரும்பாலும் வழக்குகளை அடுக்குகளிடையே மறுபகிர்வு செய்கிறது, மேலும் புதிய தரவை உருவாக்காமலே அருமையைத் (sparsity) தீர்க்க முடியும்.

கோல்டன் தரவுத்தொகுப்பைத் தொகுத்தல்

அடுக்கு மாதிரியெடுப்பும் மாசு வடிகட்டலும் முடிந்தவுடன், எஞ்சிய வழக்குகள் கோல்டன் தரவுத்தொகுப்பை உருவாக்குகின்றன — ஒவ்வொரு மாடல் பதிப்பும் இதற்கு எதிராக மதிப்பெண் இடப்படும் மாற்ற முடியாத குறிப்பு அளவுகோல். கோல்டன் தரவுத்தொகுப்புடன், அடுக்குப் பிரிப்புக் கட்டம் (stratification grid), ஒவ்வொரு-அடுக்கு எண்ணிக்கைகள், மாசு விலக்கல் எண்ணிக்கைகள், மூலத்தடப் பிரிவு (மனித vs. செயற்கை), சிரம லேபிள்களுக்கான குறிப்பிடுபவர்களுக்கிடையேயான உடன்பாட்டுப் புள்ளிவிவரங்கள், மற்றும் ஸ்னாப்ஷாட்டின் Git commit hash ஆகியவற்றை ஆவணப்படுத்தும் ஒரு தரவுத்தொகுப்பு அட்டை (dataset card) இணைந்திருக்க வேண்டும். இந்த மெட்டாடேட்டா, குழுக்களிடையேயும் காலப்போக்கிலும் மீண்டும் உருவாக்கக்கூடிய மதிப்பீட்டைச் சாத்தியமாக்குகிறது — தணிக்கைத் தடங்கள் பேரம் பேச முடியாததாக இருக்கும் ஆளுகைக் கட்டமைப்புகளின் கீழ் இயங்கும் எந்தவொரு நிறுவனத்திற்கும் இது ஒரு தேவை.

நடைமுறைப் பணிப்பாய்வு இதுதான்: சமநிலையான எடுப்பை உருவாக்க StratifiedDatasetBuilder.build ஐ இயக்கவும், முடிவை ContaminationChecker.filter_dataset வழியாகக் கடத்தவும், வடிகட்டலுக்குப் பிறகு எந்த அடுக்கும் குறைந்தபட்ச எண்ணிக்கைக்குக் கீழே இறங்கவில்லை என்பதைச் சரிபார்க்கவும் (தேவைப்பட்டால் NeMo Safe Synthesizer மூலம் மீண்டும் மேம்படுத்தவும்), இறுதிப் பட்டியலைப் பதிப்பிடப்பட்ட JSON கோப்பாக வரிசைப்படுத்தவும் (serialize), அதன் தரவுத்தொகுப்பு அட்டையுடன் சேர்த்து commit செய்யவும். தரவுத்தொகுப்பு அட்டை என்பது, தரவுத்தொகுப்பில் என்ன உள்ளது, அது ஏன் உருவாக்கப்பட்டது, அது எவ்வாறு பயன்படுத்தப்பட வேண்டும் என்பதற்கான ஒற்றை உண்மை ஆதாரமாகச் செயல்படும் ஒரு கட்டமைக்கப்பட்ட markdown அல்லது JSON ஆவணம் — ஒரு மாடல் அட்டைக்கு ஒப்பானது, ஆனால் மதிப்பீட்டுத் தரவுக்கு வரையறுக்கப்பட்டது. தானியங்கி தரவுத்தொகுப்புப் புதுப்பிப்புப் பைப்லைன்கள் பழமையைக் (staleness) கண்டறியும்போது (மற்றொரு இலக்கில் விவரிக்கப்பட்டுள்ளது), அவை இதே பைப்லைன் வழியாக மறு-தொகுப்பைத் தூண்டுகின்றன; இது கோல்டன் தரவுத்தொகுப்பின் ஒவ்வொரு புதிய பதிப்பும் அதே அடுக்குப் பிரிப்பு உத்தரவாதங்களையும் மாசுப் பாதுகாப்புகளையும் பெறுவதை உறுதி செய்கிறது.

குறியீடு விளக்கம்

அடுக்குப் பிரிப்பு அச்சுகளை வரையறுத்தல்

ஹோஸ்ட் செய்யப்பட்ட-LLM மதிப்பீட்டிற்கு, இரண்டு முதன்மை அச்சுகள் அடுக்குப் பிரிப்புக் கட்டத்தை உருவாக்குகின்றன:

• பணி வகை (Task category): சோதிக்கப்படும் செயல்பாட்டுத் திறன். GPT-4o போன்ற ஒரு பொது-நோக்க மாடலுக்கான பொதுவான வகைகளில் வகைப்படுத்தல் (classification), சுருக்கம் (summarization), பிரித்தெடுப்பு (extraction), உருவாக்கம் (generation), மற்றும் நியாயப்படுத்தல் (reasoning) அடங்கும். ஒவ்வொரு வகையும் வேறுபட்ட உள் பாதையைப் பயன்படுத்துகிறது — வகைப்படுத்தல் லேபிள் துல்லியத்தைக் கோருகிறது, அதே நேரத்தில் உருவாக்கம் நீண்ட வெளியீடுகளில் ஒத்திசைவையும் சரளத்தையும் கோருகிறது.

• சிரம நிலை (Difficulty level): ஒரு சோதனை வழக்கின் அறிவாற்றல் அல்லது கணக்கீட்டு சிக்கலைப் பிடிக்கும் ஒரு தனித்த அளவுகோல் (பொதுவாக 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 ஐயும் (இது மாற்றக்கூடிய இயல்புநிலை மதிப்புகளுக்கு ஒரு factory ஐ வழங்குகிறது) கொண்டு வருகின்றன.
• 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 க்கு நீங்கள் உறுதியளிப்பதற்கு முன் இடைவெளிப் பகுப்பாய்வை எளிதாக்குகிறது.
• build என்பது மைய மாதிரியெடுப்பு வழக்கம். இது மீண்டும் உருவாக்கத்தக்க தன்மைக்காக சீரற்ற எண் உருவாக்கியை seed செய்கிறது — தரவுத்தொகுப்புப் பதிப்பிடலுக்கு இது முக்கியம் — மற்றும் ஒவ்வொரு அடுக்கிலிருந்தும் சரியாக target வழக்குகளை எடுக்கிறது. எந்த அடுக்கும் குறைவாக நிரப்பப்பட்டிருந்தால், கவரேஜை அமைதியாகக் குறைப்பதற்குப் பதிலாக, செயற்கை மேம்படுத்தலைப் பரிந்துரைக்கும் செயல்படுத்தக்கூடிய செய்தியுடன் ஒரு ValueError ஐ எழுப்புகிறது.

மாசு-விழிப்புணர்வுடன் கூடிய தரவுத்தொகுப்புப் பிரிவுகள்

மதிப்பீட்டு வழக்குகள் மாடலின் பயிற்சித் தரவில் கசிந்திருந்தால், ஒரு அடுக்கு மாதிரியெடுக்கப்பட்ட தரவுத்தொகுப்பு பயனற்றது. இறுதி கோல்டன் தரவுத்தொகுப்பு பூட்டப்படுவதற்கு முன் மாசுக் கண்டறிதல் நடக்க வேண்டும். நிலையான அணுகுமுறை, ஒவ்வொரு மதிப்பீட்டு ப்ராம்ப்ட்டிற்கும் அறியப்பட்ட பயிற்சி ஆவணங்களின் குறிப்புக் கார்பஸுக்கும் இடையிலான n-gram மேற்பொருந்தலைக் கணக்கிடுகிறது. ஒரு மேற்பொருந்தல் வரம்பை (பொதுவாக 80% க்கு மேல் 8-gram மேற்பொருந்தல்) மீறும் வழக்குகள் கொடியிடப்பட்டு விலக்கப்படுகின்றன.

பின்வரும் குறியீடு ContaminationChecker வகுப்பைப் பயன்படுத்தி ஒரு இலகுரக மாசுச் சரிபார்ப்பியைச் செயல்படுத்துகிறது. check முறை ஒவ்வொரு மதிப்பீட்டு ப்ராம்ப்ட்டிலிருந்தும் எழுத்து-நிலை n-gramகளைப் பிரித்தெடுத்து, முன்-கட்டமைக்கப்பட்ட பயிற்சி n-gramகளின் தொகுப்புடன் ஒப்பிட்டு, ஒரு மாசு விகிதத்தைத் திருப்பித் தருகிறது. விகிதம் உள்ளமைக்கக்கூடிய 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-gramகளின் முழுத் தொகுப்பையும் முன்-கணக்கிடுகிறது. அவற்றை ஒரு set இல் சேமிப்பது சரிபார்ப்புக் கட்டத்தின் போது O(1) உறுப்பினர் சோதனைகளைச் சாத்தியமாக்குகிறது. n அளவுரு இயல்பாக 8 ஆக இருக்கும்; இது உண்மையான மேற்பொருந்தல்களைப் பிடிப்பதற்கும், பொதுவான சொற்றொடர்களிலிருந்து தவறான நேர்மறைகளைத் தவிர்ப்பதற்கும் இடையே சமநிலைப்படுத்துகிறது.
• _extract_ngrams உரையைச் சிறிய எழுத்தாக்கி, வெற்றிடத்தின் அடிப்படையில் டோக்கனாக்கி, அனைத்து தொடர்ச்சியான n-டோக்கன் சாளரங்களையும் உருவாக்குகிறது. உரை n டோக்கன்களுக்குக் குறைவாக இருந்தால், சிதைந்த பகுதி n-gramகளை உருவாக்குவதைத் தவிர்க்க ஒரு வெற்றுத் தொகுப்பைத் திருப்பித் தருகிறது.
• check வழக்கின் n-gramகளுக்கும் பயிற்சித் தொகுப்புக்கும் இடையிலான வெட்டைக் கணக்கிட்டு, பின்னர் மாசு விகிதத்தைக் கணக்கிடுகிறது. விகிதம் வரம்பைச் சந்திக்கும்போது அல்லது மீறும்போது boolean 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) ஒவ்வொரு அடுக்கிற்குள்ளான எடுப்பையும் மீண்டும் உருவாக்கத்தக்கதாக்குகிறது; எனவே அதே தொகுப்பில் அதே builder ஐ இயக்கும் இரண்டு பொறியாளர்கள் ஒரே மாதிரியான கோல்டன் தரவுத்தொகுப்புகளைப் பெறுகிறார்கள், மேலும் மாடல் பதிப்புகளிடையேயான தேர்ச்சி-விகித ஒப்பீடுகள் மாதிரியெடுப்பு மாறுபாட்டை அல்ல, மதிப்பீட்டுத்-தொகுப்பின் ஒருமையைப் பிரதிபலிக்கின்றன.
3. ஒவ்வொரு EvalCase இலும் provenance புலத்தை "human" அல்லது "synthetic" என நிரப்பவும் — தேர்ச்சி-விகிதப் பகுப்பாய்வை மூலத்தடத்தின் அடிப்படையில் பிரிப்பது, மூலத்தடம்-அறியாத மொத்தம் மறைக்கும் பொதுமைப்படுத்தல் இடைவெளிகளை வெளிப்படுத்துகிறது: மனிதரால் எழுதப்பட்ட reasoning வழக்குகளில் 94% ஆனால் செயற்கையாக உருவாக்கப்பட்டவற்றில் 71% மதிப்பெண் பெறும் ஒரு மாடல், ஒட்டுமொத்த எண் ஒருபோதும் வெளிப்படுத்தாத ஒரு வழியில் தோல்வியடைகிறது.

செய்யக்கூடாதவை

1. மூலச் சோதனைத் தொகுப்பிலிருந்து மதிப்பீட்டு வழக்குகளைச் சீரான சீரற்ற முறையில் எடுக்க வேண்டாம் — எளிதான வழக்குகளும் அதிகமாகப் பிரதிநிதித்துவம் பெற்ற பணி வகைகளும் மாதிரியில் ஆதிக்கம் செலுத்துகின்றன; எனவே பெரும்பாலான எடுப்புகள் easy::classification ஆக இருக்கும்போது, hard::reasoning அல்லது hard::extraction அடுக்குகளில் பேரழிவு தோல்வியடையும் ஒரு மாடல் இன்னும் 90களின் உயர் துல்லியத்தைப் பதிவு செய்கிறது; இது உற்பத்திக்குத் தயாராக இருப்பது போலத் தோன்றும் ஒரு டாஷ்போர்டு எண்ணை உருவாக்குகிறது, அதே நேரத்தில் ஒரு பின்னடைவு உண்மையான பயனர்களுக்கு அனுப்பப்படுகிறது.
2. ஒரு அடுக்கு குறைவாக நிரப்பப்பட்டிருக்கும்போது StratifiedDatasetBuilder.build எழுப்பும் ValueError ஐப் பிடிக்கவோ அடக்கவோ வேண்டாம் — ஒரு கலத்தின் வழக்கு எண்ணிக்கை target க்கு (இயல்பாக min_per_stratum) கீழே இறங்கும்போதுதான் இந்தப் பிழை துல்லியமாக எழுகிறது; எந்த வழக்குகள் இருக்கிறதோ அவற்றுடன் அமைதியாகத் தொடர்வது, குறைந்தபட்ச-எண்ணிக்கை வடிவமைப்பு உத்தரவாதம் அளிக்கும் 95% நம்பிக்கையில் ஐந்து-சதவீதப்-புள்ளி பிழை வரம்பிற்குக் கீழே புள்ளிவிவர ஆற்றலைக் குறைக்கிறது.
3. EvalCase இல் field(default_factory=dict) ஐ வெற்று {} இயல்புநிலையால் மாற்ற வேண்டாம் — பகிரப்பட்ட மாற்றக்கூடிய இயல்புநிலை, வெளிப்படையான மெட்டாடேட்டா இல்லாமல் உருவாக்கப்பட்ட ஒவ்வொரு வழக்கும் அதே அகராதிப் பொருளைக் குறிப்பிடக் காரணமாகிறது; எனவே ஒரு வழக்கின் மெட்டாடேட்டா அகராதியை மாற்றுவது மற்ற எல்லாவற்றையும் அமைதியாக நச்சாக்கி, கீழ்நிலை மாசுச் சரிபார்ப்புகளும் தரவுத்தொகுப்புப் பதிப்பிடலும் சார்ந்திருக்கும் மூலத்தட மற்றும் துணைப் புலங்களைச் சிதைக்கிறது.