Free lesson · GenAI Safety & Evaluation Engineering

ಡೇಟಾಸೆಟ್ ಮಾಲಿನ್ಯ (contamination) ಮತ್ತು ಸೋರಿಕೆ (leakage) ಪತ್ತೆಹಚ್ಚುವುದು

ಮೌಲ್ಯಮಾಪನ ಡೇಟಾಸೆಟ್‌ಗಳು LLM ತರಬೇತಿ ಡೇಟಾಗೆ ಸೋರಿಕೆಯಾಗಿಲ್ಲ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ನೀವು ಮಾಲಿನ್ಯ ಪತ್ತೆ (contamination detection) ವ್ಯವಸ್ಥೆಯನ್ನು ನಿರ್ಮಿಸುತ್ತೀರಿ. ಒಂದು ContaminationDetector class ಅನ್ನು ರಚಿಸಿ, ಅದು: (1) ಪ್ರತಿ test case input ಅನ್ನು OpenAI GPT-4o ಮತ್ತು Gemini Pro ಗೆ ಕಳುಹಿಸುತ್ತದೆ, (2) ಮಾದರಿಯು ನಿರೀಕ್ಷಿತ output ಅನ್ನು ಯಥಾವತ್ತಾಗಿ (verbatim) ಪುನರುತ್ಪಾದಿಸಬಹುದೇ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತದೆ (ಮಾಲಿನ್ಯದ ಸಂಕೇತ), (3) ಮಾಲಿನ್ಯ ಸ್ಕೋರ್ (contamination score) ಅನ್ನು ಲೆಕ್ಕಹಾಕುತ್ತದೆ: ಮಾದರಿಯ output ನಿರೀಕ್ಷಿತ ಉತ್ತರದೊಂದಿಗೆ >90% ROUGE-L overlap ಹೊಂದಿರುವ test case ಗಳ ಶೇಕಡಾವಾರು. ಮಾಲಿನ್ಯಗೊಂಡ test case ಗಳನ್ನು ಬದಲಿಸಲು ಫ್ಲ್ಯಾಗ್ ಮಾಡಿ. ಒಂದು quarantine workflow ಅನ್ನು ನಿರ್ಮಿಸಿ: ಮಾಲಿನ್ಯಗೊಂಡ case ಗಳನ್ನು ಮಾಲಿನ್ಯದ ಸಾಕ್ಷ್ಯದೊಂದಿಗೆ quarantine.jsonl ಫೈಲ್‌ಗೆ ಸ್ಥಳಾಂತರಿಸಲಾಗುತ್ತದೆ. ಮಾಲಿನ್ಯ ವರದಿಯನ್ನು (contamination report) ರಚಿಸಿ: ಒಟ್ಟು case ಗಳು, ಮಾಲಿನ್ಯಗೊಂಡ ಸಂಖ್ಯೆ, ಪ್ರತಿ ಮಾದರಿಗೆ ಮಾಲಿನ್ಯ ದರ, ಪ್ರತಿ ವರ್ಗಕ್ಕೆ (category) ಮಾಲಿನ್ಯ ದರ.

Course: GenAI Evaluation, Safety & Governance · Chapter 1 · Evaluation Dataset Curation

Free to read — no subscription required.

Continue with Google

ಪರಿಚಯ

ಮಾಡೆಲ್ ಪ್ರೊವೈಡರ್‌ನ ತರಬೇತಿ ಡೇಟಾದಲ್ಲಿ ಕಾಣಿಸಿಕೊಳ್ಳುವ ಟೆಸ್ಟ್ ಕೇಸ್ ಉಬ್ಬಿದ ಬೆಂಚ್‌ಮಾರ್ಕ್ ಸ್ಕೋರ್‌ಗಳನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ, ಮತ್ತು ಅವು ಪ್ರೊಡಕ್ಷನ್‌ನಲ್ಲಿ ಮಾಯವಾಗುತ್ತವೆ. ಇದೇ ಡೇಟಾಸೆಟ್ ಕಲುಷಿತತೆ (dataset contamination) — ಮತ್ತು ನೀವು ತರಬೇತಿ ಕಾರ್ಪಸ್‌ಗಳನ್ನು ಪರಿಶೀಲಿಸಲು ಸಾಧ್ಯವಿಲ್ಲದ ಹೋಸ್ಟ್ ಮಾಡಿದ LLM‌ಗಳಿಗೆ, ಇದನ್ನು ಕೇವಲ ಸಂಭವನೀಯತೆಯ ಆಧಾರದ ಮೇಲೆ ಮಾತ್ರ ಪತ್ತೆಹಚ್ಚಬಹುದು. ಪ್ರತಿ ಟೆಸ್ಟ್ ಕೇಸ್‌ನ ಒಂದು ಭಾಗದಿಂದ ಮಾಡೆಲ್‌ನ್ನು ಪ್ರೋಬ್ ಮಾಡಿ, ನಿರೀಕ್ಷಿತ ಮುಂದುವರಿಕೆಯ ಎಷ್ಟು ಭಾಗವನ್ನು ಅದು ಅಕ್ಷರಶಃ ಪುನರುತ್ಪಾದಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ಅಳೆಯುವುದು ಪ್ರಮಾಣಿತ ತಂತ್ರ. ಹೆಚ್ಚಿನ ಅಕ್ಷರಶಃ ಓವರ್‌ಲ್ಯಾಪ್ (ROUGE-L 0.85 ಕ್ಕಿಂತ ಹೆಚ್ಚು) ಮಾಡೆಲ್ ಆ ಉದಾಹರಣೆಯನ್ನು ಈ ಮೊದಲೇ ನೋಡಿದೆ ಎಂಬುದಕ್ಕೆ ಬಲವಾದ ಸಾಕ್ಷ್ಯ; ಡೇಟಾಸೆಟ್‌ನ್ನು ನ್ಯಾಯಯುತ ಬೆಂಚ್‌ಮಾರ್ಕ್ ಆಗಿ ಬಳಸುವ ಮೊದಲು ಆ ಕೇಸ್‌ನ್ನು ಕ್ವಾರಂಟೈನ್ ಮಾಡಿ ಹೊಸದೊಂದರಿಂದ ಬದಲಾಯಿಸಬೇಕು.

ಪ್ರಮುಖ ಪರಿಭಾಷೆ

ಕಲುಷಿತತೆ (Contamination): ಮಾಡೆಲ್‌ನ ತರಬೇತಿ ಡೇಟಾದಲ್ಲಿ ಇರುವ ಟೆಸ್ಟ್ ಕೇಸ್, ಇದು ಪಕ್ಷಪಾತದ ಇವಾಲ್ ಸ್ಕೋರ್‌ಗಳನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ.
ROUGE-L: ಎರಡು ಸ್ಟ್ರಿಂಗ್‌ಗಳ ನಡುವಿನ ದೀರ್ಘ ಸಾಮಾನ್ಯ ಉಪಾನುಕ್ರಮ (longest common subsequence) ಓವರ್‌ಲ್ಯಾಪ್, ಉದ್ದವಾದ ಸ್ಟ್ರಿಂಗ್‌ನಿಂದ ಸಾಮಾನ್ಯೀಕರಿಸಲಾಗಿದೆ. ವ್ಯಾಪ್ತಿ 0–1.
ಪ್ರೋಬ್ (Probe): temperature=0.0 ನೊಂದಿಗೆ ಮಾಡೆಲ್‌ಗೆ ಕಳುಹಿಸಲಾದ ಟೆಸ್ಟ್ ಕೇಸ್‌ನ ಕತ್ತರಿಸಿದ ಪ್ರಿಫಿಕ್ಸ್; ಮಾಡೆಲ್‌ನ ಮುಂದುವರಿಕೆಯನ್ನು ನಿರೀಕ್ಷಿತ ಔಟ್‌ಪುಟ್‌ನೊಂದಿಗೆ ಹೋಲಿಸಲಾಗುತ್ತದೆ.
ಕ್ವಾರಂಟೈನ್ (Quarantine): ಕಲುಷಿತ ರೆಕಾರ್ಡ್‌ಗಳನ್ನು ಬದಲಾವಣೆಗಾಗಿ ದಾಖಲಿಸುವ ಅಪೆಂಡ್-ಓನ್ಲಿ ಫೈಲ್ (quarantine.jsonl).
ಬದಲಿ (Replacement): ಕ್ವಾರಂಟೈನ್ ಮಾಡಲಾದ ಕೇಸ್‌ನ ಸ್ಥಾನವನ್ನು ತುಂಬಲು ಉತ್ಪಾದಿಸಲಾದ ಹೊಸ ಟೆಸ್ಟ್ ಕೇಸ್, ಇದು ವರ್ಗ/ಕಷ್ಟತೆಯ ಸಮತೋಲನವನ್ನು ಕಾಪಾಡುತ್ತದೆ.

ಪರಿಕಲ್ಪನೆಗಳು

ಕಾರ್ಯಾಚರಣಾ ಶಿಸ್ತು

ಯಾವಾಗಲೂ temperature 0.0 ನಲ್ಲಿ ಪ್ರೋಬ್ ಮಾಡಿ. ಸ್ಟೊಕ್ಯಾಸ್ಟಿಕ್ ಸ್ಯಾಂಪ್ಲಿಂಗ್ ಪ್ರತಿ ರನ್‌ನಲ್ಲೂ ವಿಭಿನ್ನ ಕಂಪ್ಲೀಷನ್‌ಗಳನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ ಮತ್ತು ಸ್ಕೋರ್‌ಗಳನ್ನು ಅರ್ಥಹೀನವಾಗಿಸುತ್ತದೆ.
ಕ್ವಾರಂಟೈನ್‌ಗೆ ಅಪೆಂಡ್ ಮೋಡ್ (a) ಬಳಸಿ. ಓವರ್‌ರೈಟ್ ಮಾಡುವುದು ಕಲುಷಿತತೆಯ ಇತಿಹಾಸದ ಆಡಿಟ್ ಟ್ರೇಲ್‌ನ್ನು ನಾಶಪಡಿಸುತ್ತದೆ.
ಪ್ರತಿ ಸ್ಕ್ಯಾನ್‌ಗೆ ಕನಿಷ್ಠ ಎರಡು ಪ್ರೊವೈಡರ್‌ಗಳನ್ನು ಪ್ರೋಬ್ ಮಾಡಿ. ಒಂದೇ ಪ್ರೊವೈಡರ್‌ನ ತರಬೇತಿ ಡೇಟಾ ಇತರರು ನೋಡಿದ್ದನ್ನು ಒಳಗೊಂಡಿರದೇ ಇರಬಹುದು; ಕ್ರಾಸ್-ಪ್ರೊವೈಡರ್ ಪ್ರೋಬಿಂಗ್ ಹೆಚ್ಚು ಹಿಡಿಯುತ್ತದೆ.
ತ್ರೈಮಾಸಿಕವಾಗಿ ಮರು-ಸ್ಕ್ಯಾನ್ ಮಾಡಿ. ಪ್ರೊವೈಡರ್ ತರಬೇತಿ ಕಟ್‌ಆಫ್‌ಗಳು ಮುಂದುವರೆಯುತ್ತವೆ; ಹೊಸ ಮಾಡೆಲ್ ಆವೃತ್ತಿಗಳು ಬಿಡುಗಡೆಯಾದಂತೆ ಹೊಸ ಕಲುಷಿತತೆ ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತದೆ.
ROUGE-L > 0.85 ನ್ನು ಬಲವಾದ ಸಂಕೇತವೆಂದು ಪರಿಗಣಿಸಿ, ಆದರೆ ಪುರಾವೆಯಾಗಿ ಅಲ್ಲ. ಕೆಲವು ಟೆಸ್ಟ್ ಕೇಸ್‌ಗಳು ಸ್ವಾಭಾವಿಕವಾಗಿ ಕಡಿಮೆ-ಎಂಟ್ರೊಪಿಯವು (ಉದಾ., "What is 2+2?") ಮತ್ತು ಕಲುಷಿತತೆ ಇಲ್ಲದೆಯೂ ಹೆಚ್ಚಿನ ಓವರ್‌ಲ್ಯಾಪ್ ಉತ್ಪಾದಿಸುತ್ತವೆ. ಕ್ವಾರಂಟೈನ್ ಮಾಡುವ ಮೊದಲು ಸ್ಪಾಟ್-ಚೆಕ್ ಮಾಡಿ.

ಕೋಡ್ ವಾಕ್‌ಥ್ರೂ

ಪ್ರೋಬ್ ಲೂಪ್

Code snippetpython
1import asyncio, json
2from pathlib import Path
3from openai import AsyncOpenAI
4from rouge_score import rouge_scorer
5
6class ContaminationDetector:
7    def __init__(self, providers: dict[str, AsyncOpenAI], threshold: float = 0.85) -> None:
8        self._providers = providers
9        self._threshold = threshold
10        self._scorer = rouge_scorer.RougeScorer(["rougeL"], use_stemmer=True)
11
12    async def probe(self, model: str, prefix: str) -> str:
13        client = self._providers[model]
14        resp = await client.chat.completions.create(
15            model=model,
16            messages=[{"role": "user", "content": prefix}],
17            temperature=0.0,
18            max_tokens=300,
19        )
20        return resp.choices[0].message.content or ""
21
22    async def score(self, prefix: str, expected: str) -> dict[str, float]:
23        scores: dict[str, float] = {}
24        completions = await asyncio.gather(*[
25            self.probe(m, prefix) for m in self._providers.keys()
26        ])
27        for model, completion in zip(self._providers.keys(), completions):
28            r = self._scorer.score(expected, completion)["rougeL"].fmeasure
29            scores[model] = r
30        return scores
31
32    def is_contaminated(self, scores: dict[str, float]) -> bool:
33        return any(s >= self._threshold for s in scores.values())

ContaminationDetector ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್ ಪ್ರೊವೈಡರ್ ಹೆಸರು → SDK ಕ್ಲೈಂಟ್ ಎಂಬ dict ಮತ್ತು ಕಲುಷಿತತೆಯ ಥ್ರೆಶೋಲ್ಡ್ (ಡೀಫಾಲ್ಟ್ 0.85) ಅನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ.
probe ಒಂದೇ ಮಾಡೆಲ್‌ನ್ನು ಪ್ರಿಫಿಕ್ಸ್‌ನೊಂದಿಗೆ temperature 0.0 ನಲ್ಲಿ ಕರೆಯುತ್ತದೆ — ಡಿಟರ್ಮಿನಿಸ್ಟಿಕ್ ಸೆಟ್ಟಿಂಗ್ ಅತ್ಯಗತ್ಯ, ಏಕೆಂದರೆ ನಾನ್-ಡಿಟರ್ಮಿನಿಸ್ಟಿಕ್ ಡಿಕೋಡಿಂಗ್ ತರಬೇತಿ-ಡೇಟಾ ಓವರ್‌ಲ್ಯಾಪ್‌ನ್ನು ಮರೆಮಾಚುತ್ತದೆ.
score ಎಲ್ಲಾ ಪ್ರೊವೈಡರ್‌ಗಳನ್ನು ಏಕಕಾಲದಲ್ಲಿ ಪ್ರೋಬ್ ಮಾಡಿ, ನಿರೀಕ್ಷಿತ ಮುಂದುವರಿಕೆಗೆ ಹೋಲಿಸಿ ಪ್ರತಿ-ಪ್ರೊವೈಡರ್ ROUGE-L ಸ್ಕೋರ್‌ನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.
is_contaminated ಯಾವುದೇ ಪ್ರೊವೈಡರ್ ಥ್ರೆಶೋಲ್ಡ್‌ಗಿಂತ ಹೆಚ್ಚು ಸ್ಕೋರ್ ಮಾಡಿದರೆ ಟೆಸ್ಟ್ ಕೇಸ್‌ನ್ನು ಫ್ಲ್ಯಾಗ್ ಮಾಡುತ್ತದೆ; ಒಬ್ಬ ಪ್ರೊವೈಡರ್ ಕೇಸ್‌ನ್ನು ಕಂಠಪಾಠ ಮಾಡಿದರೆ ಸಾಕು, ಕ್ರಾಸ್-ಪ್ರೊವೈಡರ್ ಬೆಂಚ್‌ಮಾರ್ಕ್‌ಗಳು ಪಕ್ಷಪಾತಕ್ಕೆ ಒಳಗಾಗುತ್ತವೆ.

ಕ್ವಾರಂಟೈನ್ ಹರಿವು

Loading diagram...

ಬದಲಿ ಹಂತ ಮುಖ್ಯ: ಕಲುಷಿತ ಕೇಸ್‌ಗಳನ್ನು ಕೇವಲ ತೆಗೆದುಹಾಕುವುದು ಡೇಟಾಸೆಟ್‌ನ್ನು ಕುಗ್ಗಿಸುತ್ತದೆ ಮತ್ತು ಹೆಚ್ಚಾಗಿ ವರ್ಗ/ಕಷ್ಟತೆಯ ಸಮತೋಲನವನ್ನು ವಿರೂಪಗೊಳಿಸುತ್ತದೆ. ಯಾವಾಗಲೂ ಅದೇ (category, difficulty) ಸೆಲ್‌ನಲ್ಲಿ ಹೊಸ ಕೇಸ್‌ನ್ನು ಉತ್ಪಾದಿಸಿ, ಅದನ್ನು ಮರು-ಪ್ರೋಬ್ ಮಾಡಿ, ಮತ್ತು ಅದು ಥ್ರೆಶೋಲ್ಡ್ ದಾಟಿದ ನಂತರವೇ ಕಮಿಟ್ ಮಾಡಿ.

ಶಿಸ್ತು ಅನ್ವಯ

ಮಾಡಬೇಕಾದವು ಮತ್ತು ಮಾಡಬಾರದವು

ಮಾಡಬೇಕಾದವು

ಪ್ರತಿ probe ಕರೆಯಲ್ಲಿ temperature=0.0 ಹೊಂದಿಸಿ — ಡಿಟರ್ಮಿನಿಸ್ಟಿಕ್ ಡಿಕೋಡಿಂಗ್ ಅಗತ್ಯ, ಏಕೆಂದರೆ ಶೂನ್ಯವಲ್ಲದ temperature ಸ್ಯಾಂಪ್ಲಿಂಗ್ ನಾಯ್ಸ್‌ನ್ನು ಪರಿಚಯಿಸುತ್ತದೆ, ಇದು ಅಕ್ಷರಶಃ ತರಬೇತಿ-ಡೇಟಾ ಓವರ್‌ಲ್ಯಾಪ್‌ನ್ನು ಮರೆಮಾಚಿ, ತಪ್ಪು ನೆಗೆಟಿವ್‌ಗಳನ್ನು ಉತ್ಪಾದಿಸಿ, ಕಲುಷಿತ ಕೇಸ್‌ಗಳು ಸಕ್ರಿಯ ಡೇಟಾಸೆಟ್‌ನಲ್ಲಿ ಉಳಿದುಕೊಳ್ಳಲು ಅವಕಾಶ ನೀಡುತ್ತದೆ.
ಯಾವುದೇ ಪ್ರೊವೈಡರ್‌ನ ROUGE-L ಸ್ಕೋರ್ 0.85 ಅನ್ನು ತಲುಪಿದಾಗ ಅಥವಾ ಮೀರಿದಾಗ ಟೆಸ್ಟ್ ಕೇಸ್‌ನ್ನು ಕಲುಷಿತ ಎಂದು ಫ್ಲ್ಯಾಗ್ ಮಾಡಿ — ನಿರೀಕ್ಷಿತ ಮುಂದುವರಿಕೆಯನ್ನು ಕಂಠಪಾಠ ಮಾಡಿದ ಒಬ್ಬ ಪ್ರೊವೈಡರ್ ಸಾಕು ಕ್ರಾಸ್-ಪ್ರೊವೈಡರ್ ಬೆಂಚ್‌ಮಾರ್ಕ್‌ಗಳನ್ನು ಪಕ್ಷಪಾತಗೊಳಿಸಲು, ಆದ್ದರಿಂದ is_contaminated ಪರಿಶೀಲನೆ any() ಬಳಸಬೇಕು, ಬಹುಮತ ಅಥವಾ ಸರಾಸರಿಯನ್ನಲ್ಲ.
ಅದೇ (category, difficulty) ಸೆಲ್‌ನಲ್ಲಿ ಬದಲಿಯನ್ನು ಉತ್ಪಾದಿಸಿ ಮತ್ತು ಕಮಿಟ್ ಮಾಡುವ ಮೊದಲು ಅದನ್ನು ಮರು-ಪ್ರೋಬ್ ಮಾಡಿ — ಕ್ವಾರಂಟೈನ್ ಮಾಡಿದ ಕೇಸ್‌ಗಳನ್ನು ಕೇವಲ ಕೈಬಿಡುವುದು ಡೇಟಾಸೆಟ್‌ನ್ನು ಕುಗ್ಗಿಸುತ್ತದೆ ಮತ್ತು ವರ್ಗ ಹಾಗೂ ಕಷ್ಟತೆಯ ಸಮತೋಲನವನ್ನು ವಿರೂಪಗೊಳಿಸುತ್ತದೆ; ಬದಲಿಯನ್ನು ಸಕ್ರಿಯ ಡೇಟಾಸೆಟ್‌ಗೆ ಬರೆಯುವ ಮೊದಲು ಅದು ಸ್ವತಃ ಥ್ರೆಶೋಲ್ಡ್ ದಾಟಬೇಕು.

ಮಾಡಬಾರದವು

ಕಲುಷಿತ ಕೇಸ್‌ನ್ನು ಕ್ವಾರಂಟೈನ್ ಮಾಡಿದ ನಂತರ ಬದಲಿ ಹಂತವನ್ನು ಬಿಟ್ಟುಬಿಡಬೇಡಿ — ಹೊಸ ಟೆಸ್ಟ್ ಕೇಸ್ ಉತ್ಪಾದಿಸದೆ quarantine.jsonl ಗೆ ಅಪೆಂಡ್ ಮಾಡುವುದು ಡೇಟಾಸೆಟ್‌ನ ಕವರೇಜ್‌ನಲ್ಲಿ ಅಂತರವನ್ನು ಬಿಡುತ್ತದೆ; ಪರಿಣಾಮವಾಗಿ ಉಂಟಾಗುವ ವಿತರಣಾ ಬದಲಾವಣೆ ಬೆಂಚ್‌ಮಾರ್ಕ್ ಫಲಿತಾಂಶಗಳನ್ನು ಹಿಂದಿನ ರನ್‌ಗಳಿಗೆ ಹೋಲಿಸಲಾಗದಂತೆ ಮಾಡುತ್ತದೆ.
ಒಂದೇ ಟೆಸ್ಟ್ ಕೇಸ್‌ನ್ನು ಸ್ಕೋರ್ ಮಾಡುವಾಗ ಪ್ರೊವೈಡರ್‌ಗಳನ್ನು ಅನುಕ್ರಮವಾಗಿ ಪ್ರೋಬ್ ಮಾಡಬೇಡಿ — score ಮೆಥಡ್ ಎಲ್ಲಾ ಪ್ರೊವೈಡರ್‌ಗಳನ್ನು ಸಮಾನಾಂತರವಾಗಿ ಪ್ರೋಬ್ ಮಾಡಲು asyncio.gather ಬಳಸುತ್ತದೆ; ಆ ಕರೆಗಳನ್ನು ಸರಣಿಯಾಗಿಸುವುದು ಪ್ರೊವೈಡರ್‌ಗಳ ಸಂಖ್ಯೆಗೆ ಅನುಗುಣವಾಗಿ ಲೇಟೆನ್ಸಿಯನ್ನು ಸೇರಿಸುತ್ತದೆ ಮತ್ತು ದೊಡ್ಡ-ಡೇಟಾಸೆಟ್ ಕಲುಷಿತತೆ ಸ್ಕ್ಯಾನ್‌ಗಳನ್ನು ಅಪ್ರಾಯೋಗಿಕವಾಗಿ ನಿಧಾನಗೊಳಿಸುತ್ತದೆ.
0.85 ಕ್ಕಿಂತ ಕಡಿಮೆ ROUGE-L ಸ್ಕೋರ್‌ನ್ನು ಮಾಡೆಲ್ ಆ ಉದಾಹರಣೆಯನ್ನು ಎಂದಿಗೂ ನೋಡಿಲ್ಲ ಎಂಬುದಕ್ಕೆ ಪುರಾವೆಯಾಗಿ ಪರಿಗಣಿಸಬೇಡಿ — ROUGE-L ಒಂದು ಸಂಭವನೀಯ ಸಂಕೇತ, ಫೋರೆನ್ಸಿಕ್ ಗ್ರೌಂಡ್ ಟ್ರುತ್ ಅಲ್ಲ; ಅಂಚಿನ ಕೇಸ್‌ಗಳನ್ನು ಹಿಡಿಯಲು ಥ್ರೆಶೋಲ್ಡ್‌ನ್ನು ಕಡಿಮೆ ಮಾಡುವುದು ತಪ್ಪು ಪಾಸಿಟಿವ್‌ಗಳನ್ನು ಹೆಚ್ಚಿಸುತ್ತದೆ, ಆದರೆ 0.85 ಕ್ಕಿಂತ ಮೇಲೆ ಏರಿಸುವುದು ಸ್ಕೋರ್‌ಗಳನ್ನು ಉಬ್ಬಿಸುವ ಪ್ಯಾರಾಫ್ರೇಸ್-ಮಟ್ಟದ ಕಂಠಪಾಠವನ್ನು ತಪ್ಪಿಸಿಕೊಳ್ಳುವ ಅಪಾಯ ಹೊಂದಿದೆ.

3 hands-on labs come with this lesson — real code, in a cloud IDE. Create a free account to run them. No card.

Continue with Google Use email or company SSO instead →

Free account · no card · straight to the labs

Or get the full path — from

Listen to this lesson

Audio overviews of this lesson's labs and its chapter, from GenBodha Bytes.

Build ContaminationDetector with LLM probingLab5 min
Implement ROUGE-L overlap scoringLab5 min
Create quarantine workflow and contamination reportLab5 min
Evaluation Dataset CurationChapter overview20 min

More free lessons in GenAI Evaluation, Safety & Governance

Ch 1Build a stratified evaluation dataset
Ch 1Detect dataset contamination and leakageYou are here
Ch 3Implement RAGAS metrics for RAG evaluation
Ch 3Build DeepEval test suites for RAG
Ch 5Score agent tool selection with DeepEval 3.0 and Vertex AI Agent Evaluation
Ch 5Build agent benchmarks with task suites
Ch 7Design A/B experiments for prompt variants

All free lessons in GenAI Safety & Evaluation Engineering →