ಒಂದು ಸ್ತರೀಕೃತ (stratified) ಮೌಲ್ಯಮಾಪನ ಡೇಟಾಸೆಟ್ ನಿರ್ಮಿಸಿ

ಪರಿಚಯ

ನೀವು ಕಚ್ಚಾ ಪರೀಕ್ಷಾ ಪೂಲ್‌ನಿಂದ ಮೌಲ್ಯಮಾಪನ ಪ್ರಕರಣಗಳನ್ನು ಏಕರೂಪವಾಗಿ ಯಾದೃಚ್ಛಿಕವಾಗಿ ಆಯ್ದುಕೊಂಡಾಗ, ಫಲಿತಾಂಶವಾಗಿ ಬರುವ ನಿಖರತೆಯ ಸಂಖ್ಯೆ ಸುಳ್ಳು ಹೇಳುತ್ತದೆ — ಸುಲಭ ಪ್ರಕರಣಗಳು ಮತ್ತು ಅತಿಯಾಗಿ ಪ್ರತಿನಿಧಿಸಲ್ಪಟ್ಟ ಕಾರ್ಯ ವರ್ಗಗಳು ಸಂಕೇತವನ್ನು ಮುಳುಗಿಸುತ್ತವೆ, ಮತ್ತು ಅಪರೂಪದ-ಆದರೆ-ನಿರ್ಣಾಯಕ ಸ್ತರಗಳಲ್ಲಿ ಕೆಟ್ಟದಾಗಿ ವಿಫಲವಾಗುವ ಮಾದರಿಯು ಇನ್ನೂ 90ರ ಮೇಲ್ಭಾಗದಲ್ಲಿ ಅಂಕ ಗಳಿಸುತ್ತದೆ. ಇದರ ಪರಿಣಾಮವೆಂದರೆ, ಡ್ಯಾಶ್‌ಬೋರ್ಡ್‌ನಲ್ಲಿ ಉತ್ಪಾದನೆಗೆ ಸಿದ್ಧವಾದಂತೆ ಕಾಣುವ ಮತ್ತು ನಿಜವಾದ ಬಳಕೆದಾರರಿಗೆ ಹಿಂಜರಿತವನ್ನು ತಲುಪಿಸುವ ಹೋಸ್ಟ್ ಮಾಡಿದ LLM. ಈ ಪಾಠದ ಕೊನೆಯಲ್ಲಿ ನೀವು ಪರೀಕ್ಷಾ-ಪ್ರಕರಣ ಪೂಲ್‌ನ್ನು ಕಾರ್ಯ ವರ್ಗ ಮತ್ತು ಕಷ್ಟದ ಮಟ್ಟದ ಪ್ರಕಾರ ವಿಭಜಿಸಲು, ಆಡಿಟ್ ಮಾಡಬಹುದಾದ ಪ್ರತಿ-ಸ್ತರ ಎಣಿಕೆಗಳೊಂದಿಗೆ ಸಮತೋಲಿತ ಮಾದರಿಯನ್ನು ಆಯ್ದುಕೊಳ್ಳಲು, ಮತ್ತು ಗೋಲ್ಡನ್ ಡೇಟಾಸೆಟ್‌ನ್ನು ಲಾಕ್ ಮಾಡುವ ಮೊದಲು ಕಲುಷಿತ ಪ್ರಕರಣಗಳನ್ನು ಫಿಲ್ಟರ್ ಮಾಡಿ ತೆಗೆದುಹಾಕಲು ಸಮರ್ಥರಾಗುತ್ತೀರಿ.

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

• Stratum (ಸ್ತರ): (ಕಾರ್ಯ ವರ್ಗ, ಕಷ್ಟದ ಮಟ್ಟ) ಜೋಡಿಯಿಂದ ವ್ಯಾಖ್ಯಾನಿಸಲಾದ ಪರೀಕ್ಷಾ-ಪ್ರಕರಣ ಪೂಲ್‌ನ ಅತಿಕ್ರಮಿಸದ ವಿಭಜನೆ; ಪ್ರತಿ-ಕೋಶ ಎಣಿಕೆಗಳನ್ನು ನಿಯಂತ್ರಿಸಲು ಸ್ಯಾಂಪ್ಲಿಂಗ್ ಪ್ರತಿ ಸ್ತರದಿಂದ ಸ್ವತಂತ್ರವಾಗಿ ಆಯ್ದುಕೊಳ್ಳುತ್ತದೆ.
• Golden dataset (ಗೋಲ್ಡನ್ ಡೇಟಾಸೆಟ್): stratified sampling ಮತ್ತು ಕಲುಷಿತತೆ ಫಿಲ್ಟರಿಂಗ್‌ನ್ನು ದಾಟಿ ಉಳಿದುಕೊಳ್ಳುವ, ಪ್ರತಿ ಮಾದರಿ ಬಿಡುಗಡೆಯ ವಿರುದ್ಧ ಅಂಕ ನೀಡಲಾಗುವ, ಬದಲಾಯಿಸಲಾಗದ, ಆವೃತ್ತಿಗೊಳಿಸಿದ ಮೌಲ್ಯಮಾಪನ ಬೆಂಚ್‌ಮಾರ್ಕ್.
• Contamination ratio (ಕಲುಷಿತತೆ ಅನುಪಾತ): ಪರೀಕ್ಷಾ ಪ್ರಕರಣದ n-gramಗಳ ಪೈಕಿ ಉಲ್ಲೇಖ ತರಬೇತಿ ಕಾರ್ಪಸ್‌ನಲ್ಲಿಯೂ ಕಾಣಿಸಿಕೊಳ್ಳುವ ಭಾಗ; ಕಾನ್ಫಿಗರ್ ಮಾಡಿದ ಮಿತಿಯನ್ನು ಮೀರಿದ ಪ್ರಕರಣಗಳನ್ನು ಡೇಟಾಸೆಟ್ ಲಾಕ್ ಮಾಡುವ ಮೊದಲು ಹೊರಗಿಡಲಾಗುತ್ತದೆ.
• Provenance (ಮೂಲ): ಪ್ರಕರಣವನ್ನು ಹೇಗೆ ರಚಿಸಲಾಯಿತು ಎಂಬುದನ್ನು ದಾಖಲಿಸುವ ಪ್ರತಿ-ಪ್ರಕರಣ ಲೇಬಲ್ (ಉದಾ. "human" ಅಥವಾ "synthetic"), ಇದರಿಂದ ಡೇಟಾಸೆಟ್ ಕಾರ್ಡ್‌ಗಳು ಮಾನವ-ವಿರುದ್ಧ-ಸಂಶ್ಲೇಷಿತ ಸಂಯೋಜನೆಯನ್ನು ವರದಿ ಮಾಡುತ್ತವೆ.

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

LLM ಮೌಲ್ಯಮಾಪನಕ್ಕೆ ಸರಳ ಯಾದೃಚ್ಛಿಕ ಸ್ಯಾಂಪ್ಲಿಂಗ್ ಏಕೆ ವಿಫಲವಾಗುತ್ತದೆ

ಕಚ್ಚಾ ಪರೀಕ್ಷಾ-ಪ್ರಕರಣ ಪೂಲ್‌ನಿಂದ ಯಾದೃಚ್ಛಿಕ ಸ್ಯಾಂಪ್ಲಿಂಗ್ ಎರಡು ವ್ಯವಸ್ಥಿತ ಅಪಾಯಗಳನ್ನು ಪರಿಚಯಿಸುತ್ತದೆ. ಮೊದಲನೆಯದು, ವರ್ಗ ಅಸಮತೋಲನ: ನಿಮ್ಮ ಪೂಲ್‌ನಲ್ಲಿ 400 ವರ್ಗೀಕರಣ ಉದಾಹರಣೆಗಳಿದ್ದು ಕೇವಲ 30 ಜನರೇಷನ್ ಉದಾಹರಣೆಗಳಿದ್ದರೆ, 200 ಪ್ರಕರಣಗಳ ಯಾದೃಚ್ಛಿಕ ಆಯ್ಕೆಯು ಜನರೇಷನ್ ಸಾಮರ್ಥ್ಯವು ಕಡಿಮೆ-ಪರೀಕ್ಷಿತವಾಗುವುದನ್ನು ಬಹುತೇಕ ಖಾತರಿಪಡಿಸುತ್ತದೆ. ಎರಡನೆಯದು, ಕಷ್ಟದ ಮಟ್ಟದ ಓರೆ: ಟಿಪ್ಪಣಿಕಾರರು ಸರಳ ಪ್ರಕರಣಗಳನ್ನು ವೇಗವಾಗಿ ರಚಿಸುವುದರಿಂದ ಸುಲಭ ಉದಾಹರಣೆಗಳು ಕಠಿಣ ಉದಾಹರಣೆಗಳನ್ನು ಸಂಖ್ಯೆಯಲ್ಲಿ ಮೀರಿಸುತ್ತವೆ, ಹಾಗಾಗಿ ಯಾದೃಚ್ಛಿಕ ಸ್ಯಾಂಪ್ಲಿಂಗ್ ಕೃತಕವಾಗಿ ಉಬ್ಬಿಸಿದ ನಿಖರತೆಯ ಮೆಟ್ರಿಕ್‌ನ್ನು ನೀಡುತ್ತದೆ. Stratified sampling ಪೂಲ್‌ನ್ನು ಸ್ತರಗಳಾಗಿ—ಕಾರ್ಯ ವರ್ಗ ಮತ್ತು ಕಷ್ಟದ ಮಟ್ಟದ ಕ್ರಾಸ್-ಪ್ರಾಡಕ್ಟ್‌ನಿಂದ ವ್ಯಾಖ್ಯಾನಿಸಲಾದ—ವಿಭಜಿಸಿ ಮತ್ತು ಪ್ರತಿ ಸ್ತರದಿಂದ ಸ್ವತಂತ್ರವಾಗಿ ಆಯ್ದುಕೊಳ್ಳುವ ಮೂಲಕ ಎರಡೂ ಅಪಾಯಗಳನ್ನು ನಿವಾರಿಸುತ್ತದೆ. ಫಲಿತಾಂಶವೆಂದರೆ ಪ್ರತಿ (ವರ್ಗ, ಕಷ್ಟದ ಮಟ್ಟ) ಕೋಶವು ನಿಯಂತ್ರಿತ, ಆಡಿಟ್ ಮಾಡಬಹುದಾದ ಎಣಿಕೆಯನ್ನು ಹೊಂದಿರುವ ಡೇಟಾಸೆಟ್.

ಕಡಿಮೆ-ಪ್ರತಿನಿಧಿತ ಸ್ತರಗಳು ಮತ್ತು ಅಂಚಿನ ಪ್ರಕರಣಗಳನ್ನು ನಿರ್ವಹಿಸುವುದು

ಉತ್ಪಾದನಾ ಮೌಲ್ಯಮಾಪನ ಪೂಲ್‌ಗಳಲ್ಲಿ ಬಹುತೇಕ ಯಾವಾಗಲೂ ವಿರಳ ಸ್ತರಗಳಿರುತ್ತವೆ. ಕಠಿಣ-ಮಟ್ಟದ ಜನರೇಷನ್ ಪ್ರಕರಣಗಳು ಕುಖ್ಯಾತವಾಗಿ ವಿರಳ, ಏಕೆಂದರೆ ಅವುಗಳಿಗೆ ಮಾದರಿಯನ್ನು ಸೂಕ್ಷ್ಮ ವೈಫಲ್ಯ ವಿಧಾನಗಳಿಗೆ—ಹ್ಯಾಲ್ಯುಸಿನೇಷನ್, ಸೂಚನಾ ವಿಚಲನೆ, ಅಥವಾ ಶೈಲಿ ಕುಸಿತ—ತಳ್ಳುವ ಪ್ರಾಂಪ್ಟ್‌ಗಳನ್ನು ರಚಿಸಬಲ್ಲ ತಜ್ಞ ಟಿಪ್ಪಣಿಕಾರರು ಬೇಕಾಗುತ್ತಾರೆ. ಈ ಅಂತರವನ್ನು ಮೂರು ತಂತ್ರಗಳು ತುಂಬುತ್ತವೆ:

• ಪ್ರತಿಕೂಲ ಉದಾಹರಣೆ ಇಂಜೆಕ್ಷನ್: ತಿಳಿದಿರುವ ಮಾದರಿ ದೌರ್ಬಲ್ಯಗಳನ್ನು ಗುರಿಯಾಗಿಸುವ ಅಂಚಿನ ಪ್ರಕರಣಗಳನ್ನು ಕೈಯಾರೆ ಅಥವಾ ಪ್ರೋಗ್ರಾಮಾತ್ಮಕವಾಗಿ ರಚಿಸಿ. ಎಕ್ಸ್‌ಟ್ರಾಕ್ಷನ್ ಕಾರ್ಯಗಳಿಗೆ, ಇದರರ್ಥ ಅಸ್ಪಷ್ಟ ಎಂಟಿಟಿ ಗಡಿಗಳು; ರೀಸನಿಂಗ್ ಕಾರ್ಯಗಳಿಗೆ, ಇದರರ್ಥ ತೋರಿಕೆಗೆ ಸರಿಯೆನಿಸುವ ವಿಚಲಿತಕಾರಕಗಳೊಂದಿಗಿನ ಬಹು-ಹಂತದ ಪ್ರಶ್ನೆಗಳು. Patronus Generative Simulators ವೈಫಲ್ಯ ಮೇಲ್ಮೈಗಳನ್ನು ವ್ಯವಸ್ಥಿತವಾಗಿ ಶೋಧಿಸಿ ಮತ್ತು ದೊಡ್ಡ ಪ್ರಮಾಣದಲ್ಲಿ ಪ್ರತಿಕೂಲ ಪ್ರಾಂಪ್ಟ್‌ಗಳನ್ನು ಉತ್ಪಾದಿಸುವ ಮೂಲಕ ಇದನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸುತ್ತದೆ.

• ಸಂಶ್ಲೇಷಿತ ಡೇಟಾ ಉತ್ಪಾದನೆ: NeMo Safe Synthesizer ಡಿಫರೆನ್ಷಿಯಲ್ ಪ್ರೈವಸಿ ಖಾತರಿಗಳೊಂದಿಗೆ ಗೋಪ್ಯತೆ-ಅನುಸರಣೆಯ ಸಂಶ್ಲೇಷಿತ ಪ್ರಕರಣಗಳನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ, ಇದು ನಿಮ್ಮ ತರಬೇತಿ ಅಥವಾ ಟಿಪ್ಪಣಿ ಪೈಪ್‌ಲೈನ್‌ಗಳಿಂದ PII ಸೋರಿಕೆ ಮಾಡದೆ ವಿರಳ ಸ್ತರಗಳನ್ನು ವರ್ಧಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ. ಸಂಶ್ಲೇಷಿತ ಪ್ರಕರಣಗಳು provenance="synthetic" ಹೊಂದಿರಬೇಕು, ಇದರಿಂದ ಡೌನ್‌ಸ್ಟ್ರೀಮ್ ಡೇಟಾಸೆಟ್ ಕಾರ್ಡ್‌ಗಳು ಸಂಯೋಜನೆಯನ್ನು ನಿಖರವಾಗಿ ವರದಿ ಮಾಡುತ್ತವೆ.

• ಅಂತರ-ಟಿಪ್ಪಣಿಕಾರ ಒಪ್ಪಂದದ ಮರು-ಮಾಪನಾಂಕನ: ಕಷ್ಟದ ಮಟ್ಟದ ಲೇಬಲ್‌ಗಳು ವಿಶ್ವಾಸಾರ್ಹವಲ್ಲದಿದ್ದಾಗ, ಟಿಪ್ಪಣಿಕಾರ ಒಪ್ಪಂದದ ಅಂಕಗಳಿಂದ ಅವುಗಳನ್ನು ಮರು-ಗಣಿಸಿ. 0.6ಕ್ಕಿಂತ ಕಡಿಮೆ ಒಪ್ಪಂದವಿರುವ (Fleiss' kappa) ಪ್ರಕರಣಗಳನ್ನು ಕಠಿಣಕ್ಕೆ ಬಡ್ತಿ ನೀಡಲಾಗುತ್ತದೆ; 0.9ಕ್ಕಿಂತ ಹೆಚ್ಚು ಇರುವ ಪ್ರಕರಣಗಳನ್ನು ಸುಲಭಕ್ಕೆ ಇಳಿಸಲಾಗುತ್ತದೆ. ಈ ಮರು-ಮಾಪನಾಂಕನವು ಆಗಾಗ್ಗೆ ಪ್ರಕರಣಗಳನ್ನು ಸ್ತರಗಳಾದ್ಯಂತ ಮರುಹಂಚಿಕೆ ಮಾಡುತ್ತದೆ ಮತ್ತು ಹೊಸ ಡೇಟಾವನ್ನು ಉತ್ಪಾದಿಸದೆಯೇ ವಿರಳತೆಯನ್ನು ಪರಿಹರಿಸಬಲ್ಲದು.

ಗೋಲ್ಡನ್ ಡೇಟಾಸೆಟ್‌ನ್ನು ಜೋಡಿಸುವುದು

Stratified sampling ಮತ್ತು ಕಲುಷಿತತೆ ಫಿಲ್ಟರಿಂಗ್ ಪೂರ್ಣಗೊಂಡ ನಂತರ, ಉಳಿದುಕೊಂಡ ಪ್ರಕರಣಗಳು ಗೋಲ್ಡನ್ ಡೇಟಾಸೆಟ್‌ನ್ನು ರೂಪಿಸುತ್ತವೆ—ಪ್ರತಿ ಮಾದರಿ ಆವೃತ್ತಿಗೆ ಅಂಕ ನೀಡಲಾಗುವ ಬದಲಾಯಿಸಲಾಗದ ಉಲ್ಲೇಖ ಬೆಂಚ್‌ಮಾರ್ಕ್. ಗೋಲ್ಡನ್ ಡೇಟಾಸೆಟ್‌ನೊಂದಿಗೆ ಡೇಟಾಸೆಟ್ ಕಾರ್ಡ್ ಇರಬೇಕು, ಅದು ಸ್ತರೀಕರಣ ಗ್ರಿಡ್, ಪ್ರತಿ-ಸ್ತರ ಎಣಿಕೆಗಳು, ಕಲುಷಿತತೆ ಹೊರಗಿಡುವ ಎಣಿಕೆಗಳು, ಮೂಲದ ವಿಭಜನೆ (ಮಾನವ ವಿರುದ್ಧ ಸಂಶ್ಲೇಷಿತ), ಕಷ್ಟದ ಮಟ್ಟದ ಲೇಬಲ್‌ಗಳಿಗೆ ಅಂತರ-ಟಿಪ್ಪಣಿಕಾರ ಒಪ್ಪಂದದ ಅಂಕಿಅಂಶಗಳು, ಮತ್ತು ಸ್ನ್ಯಾಪ್‌ಶಾಟ್‌ನ Git commit hash ಅನ್ನು ದಾಖಲಿಸುತ್ತದೆ. ಈ ಮೆಟಾಡೇಟಾ ತಂಡಗಳಾದ್ಯಂತ ಮತ್ತು ಕಾಲಾಂತರದಲ್ಲಿ ಪುನರುತ್ಪಾದಿಸಬಹುದಾದ ಮೌಲ್ಯಮಾಪನವನ್ನು ಸಾಧ್ಯವಾಗಿಸುತ್ತದೆ—ಆಡಿಟ್ ಟ್ರೇಲ್‌ಗಳು ಅನಿವಾರ್ಯವಾದ ಆಡಳಿತ ಚೌಕಟ್ಟುಗಳ ಅಡಿಯಲ್ಲಿ ಕಾರ್ಯನಿರ್ವಹಿಸುವ ಯಾವುದೇ ಸಂಸ್ಥೆಗೆ ಇದು ಅಗತ್ಯ.

ಪ್ರಾಯೋಗಿಕ ಕಾರ್ಯಪ್ರವಾಹ ಹೀಗಿದೆ: ಸಮತೋಲಿತ ಆಯ್ಕೆಯನ್ನು ಉತ್ಪಾದಿಸಲು StratifiedDatasetBuilder.build ಅನ್ನು ಚಲಾಯಿಸಿ, ಫಲಿತಾಂಶವನ್ನು ContaminationChecker.filter_dataset ಮೂಲಕ ಹಾಯಿಸಿ, ಫಿಲ್ಟರಿಂಗ್ ನಂತರ ಯಾವುದೇ ಸ್ತರವು ಕನಿಷ್ಠ ಎಣಿಕೆಗಿಂತ ಕೆಳಗೆ ಇಳಿದಿಲ್ಲ ಎಂದು ಪರಿಶೀಲಿಸಿ (ಅಗತ್ಯವಿದ್ದರೆ NeMo Safe Synthesizer ಮೂಲಕ ಮರು-ವರ್ಧಿಸಿ), ಅಂತಿಮ ಪಟ್ಟಿಯನ್ನು ಆವೃತ್ತಿಗೊಳಿಸಿದ JSON ಫೈಲ್‌ಗೆ ಸೀರಿಯಲೈಜ್ ಮಾಡಿ, ಮತ್ತು ಅದರ ಡೇಟಾಸೆಟ್ ಕಾರ್ಡ್‌ನೊಂದಿಗೆ commit ಮಾಡಿ. ಡೇಟಾಸೆಟ್ ಕಾರ್ಡ್ ಸ್ವತಃ ಡೇಟಾಸೆಟ್ ಏನನ್ನು ಒಳಗೊಂಡಿದೆ, ಅದನ್ನು ಏಕೆ ನಿರ್ಮಿಸಲಾಯಿತು, ಮತ್ತು ಅದನ್ನು ಹೇಗೆ ಬಳಸಬೇಕು ಎಂಬುದಕ್ಕೆ ಏಕೈಕ ಸತ್ಯದ ಮೂಲವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುವ ರಚನಾತ್ಮಕ markdown ಅಥವಾ JSON ದಾಖಲೆ—ಮಾದರಿ ಕಾರ್ಡ್‌ಗೆ ಸಮಾನವಾದದ್ದು ಆದರೆ ಮೌಲ್ಯಮಾಪನ ಡೇಟಾಕ್ಕೆ ಸೀಮಿತವಾದದ್ದು. ಸ್ವಯಂಚಾಲಿತ ಡೇಟಾಸೆಟ್ ರಿಫ್ರೆಶ್ ಪೈಪ್‌ಲೈನ್‌ಗಳು ಹಳಸಿದ ಸ್ಥಿತಿಯನ್ನು ಪತ್ತೆ ಮಾಡಿದಾಗ (ಮತ್ತೊಂದು ಗುರಿಯಲ್ಲಿ ಚರ್ಚಿಸಲಾಗಿದೆ), ಅವು ಇದೇ ಪೈಪ್‌ಲೈನ್ ಮೂಲಕ ಮರು-ಸಂಗ್ರಹಣೆಯನ್ನು ಪ್ರಚೋದಿಸುತ್ತವೆ, ಇದರಿಂದ ಗೋಲ್ಡನ್ ಡೇಟಾಸೆಟ್‌ನ ಪ್ರತಿ ಹೊಸ ಆವೃತ್ತಿಯು ಅದೇ ಸ್ತರೀಕರಣ ಖಾತರಿಗಳನ್ನು ಮತ್ತು ಕಲುಷಿತತೆ ರಕ್ಷಣೆಗಳನ್ನು ಪಡೆದುಕೊಳ್ಳುತ್ತದೆ.

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

ಸ್ತರೀಕರಣ ಅಕ್ಷಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವುದು

ಹೋಸ್ಟ್ ಮಾಡಿದ-LLM ಮೌಲ್ಯಮಾಪನಕ್ಕೆ, ಎರಡು ಪ್ರಾಥಮಿಕ ಅಕ್ಷಗಳು ಸ್ತರೀಕರಣ ಗ್ರಿಡ್‌ನ್ನು ರೂಪಿಸುತ್ತವೆ:

• ಕಾರ್ಯ ವರ್ಗ: ಪರೀಕ್ಷಿಸಲಾಗುತ್ತಿರುವ ಕಾರ್ಯಾತ್ಮಕ ಸಾಮರ್ಥ್ಯ. GPT-4o ನಂತಹ ಸಾಮಾನ್ಯ-ಉದ್ದೇಶದ ಮಾದರಿಗೆ ಸಾಮಾನ್ಯ ವರ್ಗಗಳಲ್ಲಿ ವರ್ಗೀಕರಣ, ಸಾರಾಂಶೀಕರಣ, ಎಕ್ಸ್‌ಟ್ರಾಕ್ಷನ್, ಜನರೇಷನ್, ಮತ್ತು ರೀಸನಿಂಗ್ ಸೇರಿವೆ. ಪ್ರತಿ ವರ್ಗವು ಬೇರೆ ಆಂತರಿಕ ಮಾರ್ಗವನ್ನು ಪರೀಕ್ಷಿಸುತ್ತದೆ—ವರ್ಗೀಕರಣಕ್ಕೆ ಲೇಬಲ್ ನಿಖರತೆ ಬೇಕು, ಆದರೆ ಜನರೇಷನ್‌ಗೆ ದೀರ್ಘ ಔಟ್‌ಪುಟ್‌ಗಳಾದ್ಯಂತ ಸುಸಂಬದ್ಧತೆ ಮತ್ತು ಸರಾಗತೆ ಬೇಕು.

• ಕಷ್ಟದ ಮಟ್ಟ: ಪರೀಕ್ಷಾ ಪ್ರಕರಣದ ಅರಿವಿನ ಅಥವಾ ಗಣನಾತ್ಮಕ ಸಂಕೀರ್ಣತೆಯನ್ನು ಸೆರೆಹಿಡಿಯುವ ಪ್ರತ್ಯೇಕ ಮಾಪಕ (ಸಾಮಾನ್ಯವಾಗಿ ಸುಲಭ, ಮಧ್ಯಮ, ಕಠಿಣ). ಕಷ್ಟದ ಮಟ್ಟವನ್ನು ಆಗಾಗ್ಗೆ ಅಂತರ-ಟಿಪ್ಪಣಿಕಾರ ಒಪ್ಪಂದದ ಮೂಲಕ ಕಾರ್ಯರೂಪಕ್ಕೆ ತರಲಾಗುತ್ತದೆ: ಟಿಪ್ಪಣಿಕಾರರು ಸರಿಯಾದ ಉತ್ತರದ ಬಗ್ಗೆ ಏಕಮತದಿಂದ ಒಪ್ಪುವ ಪ್ರಕರಣಗಳು ಸುಲಭ, ಭಾಗಶಃ ಅಸಮ್ಮತಿ ಇರುವ ಪ್ರಕರಣಗಳು ಮಧ್ಯಮ, ಮತ್ತು ತಜ್ಞರೂ ಭಿನ್ನಾಭಿಪ್ರಾಯ ಹೊಂದುವ ಪ್ರಕರಣಗಳು ಕಠಿಣ.

ಐದು ವರ್ಗಗಳು ಮತ್ತು ಮೂರು ಕಷ್ಟದ ಮಟ್ಟಗಳ ಕ್ರಾಸ್-ಪ್ರಾಡಕ್ಟ್ ಹದಿನೈದು ಸ್ತರಗಳನ್ನು ನೀಡುತ್ತದೆ. ಉತ್ತಮವಾಗಿ ವಿನ್ಯಾಸಗೊಳಿಸಿದ ಗೋಲ್ಡನ್ ಡೇಟಾಸೆಟ್ ಪ್ರತಿ ಕೋಶಕ್ಕೆ ಕನಿಷ್ಠ ಎಣಿಕೆಯನ್ನು—ಸಾಮಾನ್ಯವಾಗಿ 20 ರಿಂದ 50 ಪ್ರಕರಣಗಳು—ನಿಗದಿಪಡಿಸುತ್ತದೆ, ಇದು 95% ವಿಶ್ವಾಸದಲ್ಲಿ ಐದು ಶೇಕಡಾವಾರು ಅಂಶಗಳಿಗಿಂತ ಕಡಿಮೆ ದೋಷ ಅಂಚಿನೊಂದಿಗೆ ಪ್ರತಿ-ಕೋಶ ಉತ್ತೀರ್ಣ-ದರ ಅಂದಾಜುಗಳಿಗೆ ಸಂಖ್ಯಾಶಾಸ್ತ್ರೀಯ ಶಕ್ತಿಯನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ.

ಪರೀಕ್ಷಾ-ಪ್ರಕರಣ ಸ್ಕೀಮಾವನ್ನು ವಿನ್ಯಾಸಗೊಳಿಸುವುದು

ಮೌಲ್ಯಮಾಪನ ಡೇಟಾಸೆಟ್‌ನಲ್ಲಿರುವ ಪ್ರತಿ ಪರೀಕ್ಷಾ ಪ್ರಕರಣವು stratified ಆಯ್ಕೆಗಳು, ಕಲುಷಿತತೆ ಪತ್ತೆ, ಮತ್ತು ಪುನರುತ್ಪಾದಿಸಬಹುದಾದ ಡೇಟಾಸೆಟ್ ಆವೃತ್ತೀಕರಣವನ್ನು ಬೆಂಬಲಿಸಲು ಸಾಕಷ್ಟು ಮೆಟಾಡೇಟಾವನ್ನು ಹೊಂದಿರಬೇಕು. ಕನಿಷ್ಠ ಕಾರ್ಯಸಾಧ್ಯ ಸ್ಕೀಮಾ ಒಳಗೊಂಡಿರುವುದು: ಪ್ರಾಂಪ್ಟ್ ಪಠ್ಯ, ನಿರೀಕ್ಷಿತ ಉಲ್ಲೇಖ ಔಟ್‌ಪುಟ್, ಕಾರ್ಯ ವರ್ಗ ಲೇಬಲ್, ಕಷ್ಟದ ಮಟ್ಟ, ಪತ್ತೆಹಚ್ಚುವಿಕೆಗಾಗಿ ಅನನ್ಯ ಪ್ರಕರಣ ಗುರುತಿಸುವಿಕೆ, ಮತ್ತು ಪ್ರಕರಣವು ಮಾನವ-ರಚಿತವೋ ಅಥವಾ ಸಂಶ್ಲೇಷಿತವಾಗಿ ಉತ್ಪಾದಿತವೋ ಎಂದು ಸೂಚಿಸುವ ಮೂಲ (provenance) ಕ್ಷೇತ್ರ (ಗೋಪ್ಯತೆ-ಅನುಸರಣೆಯ ಸಂಶ್ಲೇಷಿತ ಡೇಟಾಕ್ಕಾಗಿ 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 ಮುಖ್ಯ ಸ್ಯಾಂಪ್ಲಿಂಗ್ ರೂಟೀನ್. ಇದು ಪುನರುತ್ಪಾದನೆಗಾಗಿ ಯಾದೃಚ್ಛಿಕ ಸಂಖ್ಯಾ ಜನರೇಟರ್‌ಗೆ seed ನೀಡುತ್ತದೆ—ಡೇಟಾಸೆಟ್ ಆವೃತ್ತೀಕರಣಕ್ಕೆ ನಿರ್ಣಾಯಕ—ಮತ್ತು ಪ್ರತಿ ಸ್ತರದಿಂದ ನಿಖರವಾಗಿ target ಪ್ರಕರಣಗಳನ್ನು ಆಯ್ದುಕೊಳ್ಳುತ್ತದೆ. ಯಾವುದೇ ಸ್ತರವು ಕಡಿಮೆ-ಜನಸಂಖ್ಯೆ ಹೊಂದಿದ್ದರೆ, ಇದು ಮೌನವಾಗಿ ವ್ಯಾಪ್ತಿಯನ್ನು ಕುಗ್ಗಿಸುವ ಬದಲು ಸಂಶ್ಲೇಷಿತ ವರ್ಧನೆಯನ್ನು ಸೂಚಿಸುವ ಕ್ರಿಯಾಶೀಲ ಸಂದೇಶದೊಂದಿಗೆ ValueError ಎಸೆಯುತ್ತದೆ.

ಕಲುಷಿತತೆ-ಅರಿವಿನ ಡೇಟಾಸೆಟ್ ವಿಭಜನೆಗಳು

ಮೌಲ್ಯಮಾಪನ ಪ್ರಕರಣಗಳು ಮಾದರಿಯ ತರಬೇತಿ ಡೇಟಾಕ್ಕೆ ಸೋರಿಕೆಯಾಗಿದ್ದರೆ stratified ಡೇಟಾಸೆಟ್ ನಿಷ್ಪ್ರಯೋಜಕ. ಅಂತಿಮ ಗೋಲ್ಡನ್ ಡೇಟಾಸೆಟ್ ಲಾಕ್ ಆಗುವ ಮೊದಲು ಕಲುಷಿತತೆ ಪತ್ತೆ ನಡೆಯಬೇಕು. ಪ್ರಮಾಣಿತ ವಿಧಾನವು ಪ್ರತಿ ಮೌಲ್ಯಮಾಪನ ಪ್ರಾಂಪ್ಟ್ ಮತ್ತು ತಿಳಿದಿರುವ ತರಬೇತಿ ದಾಖಲೆಗಳ ಉಲ್ಲೇಖ ಕಾರ್ಪಸ್ ನಡುವಿನ 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ಗಳು ಮತ್ತು ತರಬೇತಿ ಗುಂಪಿನ ನಡುವಿನ ಛೇದಕವನ್ನು ಗಣಿಸಿ, ನಂತರ ಕಲುಷಿತತೆ ಅನುಪಾತವನ್ನು ಲೆಕ್ಕ ಹಾಕುತ್ತದೆ. ಅನುಪಾತವು ಮಿತಿಯನ್ನು ತಲುಪಿದಾಗ ಅಥವಾ ಮೀರಿದಾಗ ಬೂಲಿಯನ್ 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) ಅನ್ನು ಬರಿಯ {} ಡೀಫಾಲ್ಟ್‌ನೊಂದಿಗೆ ಬದಲಾಯಿಸಬೇಡಿ — ಹಂಚಿಕೊಂಡ ಬದಲಾಯಿಸಬಹುದಾದ ಡೀಫಾಲ್ಟ್ ಸ್ಪಷ್ಟ ಮೆಟಾಡೇಟಾ ಇಲ್ಲದೆ ರಚಿಸಿದ ಪ್ರತಿ ಪ್ರಕರಣವೂ ಅದೇ ಡಿಕ್ಷನರಿ ವಸ್ತುವನ್ನು ಉಲ್ಲೇಖಿಸುವಂತೆ ಮಾಡುತ್ತದೆ, ಹಾಗಾಗಿ ಒಂದು ಪ್ರಕರಣದ ಮೆಟಾಡೇಟಾ ಡಿಕ್ಷನರಿಯನ್ನು ಬದಲಾಯಿಸುವುದು ಮೌನವಾಗಿ ಉಳಿದೆಲ್ಲವನ್ನೂ ಕಲುಷಿತಗೊಳಿಸುತ್ತದೆ ಮತ್ತು ಡೌನ್‌ಸ್ಟ್ರೀಮ್ ಕಲುಷಿತತೆ ಪರಿಶೀಲನೆಗಳು ಹಾಗೂ ಡೇಟಾಸೆಟ್ ಆವೃತ್ತೀಕರಣ ಅವಲಂಬಿಸಿರುವ ಮೂಲ ಮತ್ತು ಸಹಾಯಕ ಕ್ಷೇತ್ರಗಳನ್ನು ಹಾಳುಮಾಡುತ್ತದೆ.