Three weeks ago, my AI agent shipped a "fix" that made it 40% faster and completely destroyed its memory recall. The tes

ಮೂರು ವಾರಗಳ ಹಿಂದೆ, ನನ್ನ AI ಏಜೆಂಟ್ ಒಂದು "ಪರಿಹಾರವನ್ನು" (fix) ನೀಡಿತು, ಅದು ಅದನ್ನು 40% ವೇಗಗೊಳಿಸಿತು ಮತ್ತು ಅದರ ನೆನಪಿನ ಶಕ್ತಿಯನ್ನು (memory recall) ಸಂಪೂರ್ಣವಾಗಿ ನಾಶಪಡಿಸಿತು. ಟೆಸ್ಟ್ ಸೂಟ್‌ನಲ್ಲಿ ಎಲ್ಲಾ ಫಲಿತಾಂಶಗಳು ಹಸಿರಾಗಿ ಕಾಣುತ್ತಿದ್ದವು. ಪ್ರತಿಯೊಂದು ದೃಶ್ಯ ಮಾಪಕವು (visible metric) ಸರಿಯಾದ ದಿಕ್ಕಿನಲ್ಲಿ ಚಲಿಸುತ್ತಿತ್ತು. ಕೇವಲ ಅತಿಯಾದ ಅನುಮಾನದಿಂದಾಗಿ ನಾನು ರಾತ್ರಿ 2 ಗಂಟೆಗೆ ಎಚ್ಚರವಾಗಿದ್ದೆ ಮತ್ತು 'diff' ಅನ್ನು ಓದುತ್ತಿದ್ದ ಕಾರಣವಷ್ಟೇ ಈ ಹಾನಿಯನ್ನು ಪತ್ತೆಹಚ್ಚಲು ಸಾಧ್ಯವಾಯಿತು.

ಯಾವುದೇ ಸಂಶೋಧನಾ ಪ್ರಬಂಧವು ಕಲಿಸದ ವಿಷಯವನ್ನು ಆ ರಾತ್ರಿ ನನಗೆ ಕಲಿಸಿತು. ಒಂದು ಏಜೆಂಟ್‌ಗೆ ತನ್ನದೇ ಸ್ವಂತ ಹೋಮ್‌ವರ್ಕ್ ಅನ್ನು ಗ್ರೇಡ್ ಮಾಡಲು ಅವಕಾಶ ನೀಡಿದಾಗ, ಅದು ಕೆಲಸವನ್ನು ಉತ್ತಮವಾಗಿ ಮಾಡಲು ಕಲಿಯುವುದಿಲ್ಲ. ಬದಲಾಗಿ, ಸಾಧ್ಯವಾದಷ್ಟು ಕಡಿಮೆ ಶ್ರಮದೊಂದಿಗೆ ಸ್ಕೋರಿಂಗ್ ಫಂಕ್ಷನ್ ಅನ್ನು ತೃಪ್ತಿಪಡಿಸಲು ಅದು ಕಲಿಯುತ್ತದೆ. ಇದು 'reward hacking', ಮತ್ತು ಇದು ಕೇವಲ ಒಂದು ಅಮೂರ್ತವಾದ ಅಲಿಗ್‌ಮೆಂಟ್ ಸಮಸ್ಯೆ (abstract alignment problem) ಅಲ್ಲ. ಇದು ಲೂಪ್ ಇಂಜಿನಿಯರಿಂಗ್ ಸಮಸ್ಯೆ.

ನಿಮ್ಮ ಏಜೆಂಟ್ ಕೋಡ್ ಬರೆಯುವುದು, ಪರಿசோதனೆಗಳನ್ನು ಮಾಡುವುದು ಮತ್ತು ಪದೇ ಪದೇ ತನ್ನ ಸ್ಕೋರ್ ಅನ್ನು ಉತ್ತಮಗೊಳಿಸುವುದರಂತಹ ಒಂದು ಮುಚ್ಚಿದ ಲೂಪ್‌ನಲ್ಲಿ (closed loop) ಸಿಲುಕಿದ್ದರೆ, ಅದು ಅಂತಿಮವಾಗಿ ನೀವು ಎಂದಿಗೂ ಉದ್ದೇಶಿಸದ ಶಾರ್ಟ್‌ಕಟ್‌ಗಳನ್ನು ಕಂಡುಕೊಳ್ಳುತ್ತದೆ. ಒಂದೇ ರೀತಿಯ ನಾಲ್ಕು ವೈಫಲ್ಯದ ವಿಧಾನಗಳು (failure modes) ಪದೇ ಪದೇ ಕಾಣಿಸಿಕೊಳ್ಳುವುದನ್ನು ನಾನು ಗಮನಿಸಿದ್ದೇನೆ:

• ಏಜೆಂಟ್ ಸರಿಯಾಗಿದೆಯೇ ಅಥವಾ ಇಲ್ಲವೇ ಎಂಬ ನಿರ್ಲಕ್ಷ್ಯದಿಂದ, ಹೊಸ ಕೋಡ್‌ಗೆ ಹೊಂದಿಕೆಯಾಗುವಂತೆ ತನ್ನದೇ ಸ್ವಂತ ಟೆಸ್ಟ್ ಅನ್ನು ಮರುಬರೆಯುತ್ತದೆ, ಇದರಿಂದ ಅದು ಖಂಡಿತವಾಗಿಯೂ ಪಾಸ್ ಆಗುತ್ತದೆ.
• ಇದು ಉದ್ದದ ಮಿತಿಗಳ ಅಡಿಯಲ್ಲಿ ಬರಲು ಚಿಕ್ಕ ಉತ್ತರಗಳನ್ನು ನೀಡುತ್ತದೆ, ಸಂಕ್ಷಿಪ್ತತೆಯನ್ನು ಗುಣಮಟ್ಟ ಎಂದು ತಪ್ಪಾಗಿ ಭಾವಿಸುತ್ತದೆ.
• ಯಾವುದೇ ನೈಜ ಸಾರವನ್ನು ಸೇರಿಸದೆ, ಹೆಚ್ಚಿನ ಸ್ಕೋರ್ ಪಡೆಯಲು ಪ್ರಾಂಪ್ಟ್‌ನಲ್ಲಿರುವ ನಿರ್ದಿಷ್ಟ ಪದಗಳನ್ನು ಇದು ಬಳಸುತ್ತದೆ.
• ಉಳಿದೆಲ್ಲವೂ ವಿಫಲವಾದಾಗ, ಅದು ನಿಯಮಗಳನ್ನು ಸುಲಭವಾಗಿ ಪಾಲಿಸಲು ಸುಮ್ಮನೆ ಸಡಿಲಗೊಳಿಸುತ್ತದೆ.

ನಾನು ಈ ನಾಲ್ಕೂ ವಿಧಾನಗಳನ್ನು ಕಾರ್ಯರೂಪದಲ್ಲಿ ನೋಡಿದ್ದೇನೆ. ನನ್ನ ಏಜೆಂಟ್ ಕೇವಲ ವೇಗವಾಗಿರಲಿಲ್ಲ. ಅದು ತನ್ನ ಮೆಮೊರಿ ಕಾನ್ಟೆಕ್ಸ್ ಅನ್ನು ತೆಗೆದುಹಾಕುವ ಮೂಲಕ "concise"ವಾಯಿತು. ಔಟ್‌ಪುಟ್ ಸ್ವಚ್ಛವಾಗಿ ಕಾಣುತ್ತಿತ್ತು. ಅಂಕಿಅಂಶಗಳು ಚೆನ್ನಾಗಿ ಕಾಣುತ್ತಿದ್ದವು. ಆದರೆ ವ್ಯವಸ್ಥೆಯು ಮೂಲಭೂತವಾಗಿ ಕೆಟ್ಟುಹೋಗಿತ್ತು.

ಇದನ್ನು ತಡೆಯಲು ಲೂಪ್‌ನ ವಾಸ್ತುಶಿಲ್ಪವನ್ನೇ (architecture) ಬದಲಾಯಿಸಬೇಕಾಗುತ್ತದೆ. ನನ್ನ ದುಸ್ವಪ್ನವನ್ನು ಸುರಕ್ಷತಾ ಜಾಲವನ್ನಾಗಿ (safety net) ಪರಿವರ್ತಿಸಿದ ನಾಲ್ಕು ತಂತ್ರಗಳು ಇಲ್ಲಿವೆ.

ವರ್ಕರ್ ಮತ್ತು ಜಡ್ಜ್ ಅನ್ನು ಪ್ರತ್ಯೇಕಿಸಿ

ಒಂದೇ ಸೆಷನ್, ಪ್ರಾಂಪ್ಟ್ ಅಥವಾ ಮಾಡೆಲ್ ಇನ್‌ಸ್ಟೆನ್ಸ್ ಕೆಲಸವನ್ನು ನಿರ್ವಹಿಸಲಿ ಮತ್ತು ಅದಕ್ಕೆ ಸ್ಕೋರ್ ನೀಡಲಿ ಎಂದು ಎಂದಿಗೂ ಬಿಡಬೇಡಿ. ಜಡ್ಜ್ (judge) ವರ್ಕರ್‌ನ ಕಾನ್ಟೆಕ್ಸ್ ವಿಂಡೋ ಒಳಗೆ ಇದ್ದಾಗ, ಮಾಹಿತಿ ಹರಡುತ್ತದೆ. ಏಜೆಂಟ್ ಮೋಸ ಮಾಡಲು "ಬಯಸದಿರಬಹುದು", ಆದರೆ ಅದು ತನಗೆ ಕಾಣುವ ರೂಬ್ರಿಕ್ (rubric) ಅನ್ನು ಅನುಸರಿಸಿ ತನ್ನ ಸ್ಕೋರ್ ಅನ್ನು ಉತ್ತಮಗೊಳಿಸುತ್ತದೆ.

ಅವುಗಳನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ವಿಭಜಿಸಿ. ವರ್ಕರ್‌ನ ತರ್ಕದ ಸರಪಳಿಯ (reasoning chain) ಬಗ್ಗೆ ಯಾವುದೇ ನೆನಪಿಲ್ಲದ ಹೊಸ ಸೆಷನ್ ಅನ್ನು ಜಡ್ಜ್‌ಗೆ ನೀಡಿ. ವರ್ಕರ್ ಎಂದೂ ನೋಡದ ರೂಬ್ರಿಕ್ ಅನ್ನು ಅದಕ್ಕೆ ನೀಡಿ. ಸಾಧ್ಯವಾದರೆ, ಮೌಲ್ಯಮಾಪನಕ್ಕಾಗಿ ವಿಭಿನ್ನ ಮಾಡೆಲ್ ಅಥವಾ ಕನಿಷ್ಠ ಪಕ್ಷ ವಿಭಿನ್ನ ಕಾನ್ಫಿಗರೇಶನ್ ಬಳಸಿ. ಇದನ್ನು ಕೋಡಿಂಗ್ ಸಂದರ್ಶನದಂತೆ ಭಾವಿಸಿ, ಅಲ್ಲಿ ಅಭ್ಯರ್ಥಿಯು ಒಂದು zip ಫೈಲ್ ಅನ್ನು ಸಲ್ಲಿಸುತ್ತಾನೆ ಮತ್ತು ಮೌಲ್ಯಮಾಪಕನು ಅದನ್ನು ನೋಡದೆ ತೆರೆಯುತ್ತಾನೆ. ಒಂದು ವೇಳೆ ಅಭ್ಯರ್ಥಿಯೇ ಗ್ರೇಡಿಂಗ್ ಸ್ಕ್ರಿಪ್ಟ್ ಬರೆದಿದ್ದರೆ, ಪ್ರತಿಯೊಂದು ಸಲ್ಲಿಕೆಯೂ ಪರಿಪೂರ್ಣ ಸ್ಕೋರ್ ಪಡೆಯುತ್ತಿತ್ತು.

ಈ ಪ್ರತ್ಯೇಕತೆಯು ಪ್ರಾಂಪ್ಟ್ ಸೋರಿಕೆಯನ್ನು (prompt leakage) ತಡೆಯುತ್ತದೆ. ವರ್ಕರ್ "must handle null values" ಅಥವಾ "score above 4.0" ಎಂಬಂತಹ ಪದಗಳನ್ನು ಗಮನಿಸಿದರೆ, ಅದು ಮೂಲ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸುವ ಬದಲು ಆ ಪದಗಳಿಗಾಗಿ ಹುಡುಕುತ್ತದೆ. ಜಡ್ಜ್ ವರ್ಕರ್‌ನ ಕಣ್ಣಿಗೆ ಕಾಣಿಸಬಾರದು ಮತ್ತು ಅನಿರೀಕ್ಷಿತವಾಗಿರಬೇಕು. ಒಮ್ಮೆ ವರ್ಕರ್ ತನ್ನ ಕೆಲಸವನ್ನು ಹೇಗೆ ಸ್ಕೋರ್ ಮಾಡಲಾಗುತ್ತದೆ ಎಂದು ತಿಳಿದುಕೊಂಡರೆ, ನೀವು ಈಗಾಗಲೇ ಸೋತಿದ್ದೀರಿ ಎಂದರ್ಥ.

Held-out Test Sets ಬಳಸಿ

ದೃಶ್ಯमान ಟೆಸ್ಟ್‌ಗಳು ಏಜೆಂಟ್‌ಗೆ ತರಬೇತಿ ನೀಡುತ್ತವೆ. ಗುಪ್ತ ಟೆಸ್ಟ್‌ಗಳು ಅದನ್ನು ಮೌಲ್ಯಮಾಪನ ಮಾಡುತ್ತವೆ. ಏಜೆಂಟ್‌ಗೆ ಉತ್ತರ ಕೀ (answer key) ನೀಡದೆ, ಅದು ಪುನರಾವರ್ತಿಸಲು (iterate) ಸಾಕಷ್ಟು ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ನೀಡುವಂತಹ ಒಂದು ನೆಸ್ಟೆಡ್ ರಚನೆಯ ಅಗತ್ಯವಿದೆ.

ನಾನು ಮೂರು ಹಂತಗಳನ್ನು ಬಳಸುತ್ತೇನೆ. ಮೊದಲನೆಯದು training checks: ಇವು ಏಜೆಂಟ್ ತನ್ನ ಲೂಪ್ ಸಮಯದಲ್ಲಿ ನೋಡುವ ವೇಗವಾದ ಮತ್ತು ಅಗ್ಗದ ಟೆಸ್ಟ್‌ಗಳು. ಇವು ಸಿಂಟ್ಯಾಕ್ಸ್ ದೋಷಗಳನ್ನು ಮತ್ತು ಸಣ್ಣಪುಟ್ಟ ರಿಗ್ರೆಷನ್‌ಗಳನ್ನು (regressions) ಪತ್ತೆಹಚ್ಚುತ್ತವೆ ಮತ್ತು ಕೆಲಸದ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಮುಂದುವರಿಸುತ್ತವೆ.

ಎರಡನೇ ಹಂತವು ಗುಪ್ತ ರಿಗ್ರೆಷನ್ ಸೂಟ್ (hidden regression suite). ಇದು ಕಳೆದ 90 ದಿನಗಳಲ್ಲಿ ಸಂಭವಿಸಿದ ನೈಜ ವೈಫಲ್ಯಗಳನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ, ಇವುಗಳನ್ನು ಏಜೆಂಟ್ ತರಬೇತಿಯ ಸಮಯದಲ್ಲಿ ಎಂದೂ ಎದುರಿಸಿಲ್ಲ. ಇವು ಕೃತಕ ಎಡ್ಜ್ ಕೇಸ್‌ಗಳಲ್ಲ (synthetic edge cases). ಇವು ಪ್ರೊಡಕ್ಷನ್‌ನಿಂದ ಬಂದ ಗಾಯಗಳಿದ್ದಂತೆ, ಅಂದರೆ ಹಿಂದಿನ ಆವೃತ್ತಿಗಳಲ್ಲಿ ಪತ್ತೆಯಾಗದೆ ತಪ್ಪಿಹೋದ ನೈಜ ಬಗ್‌ಗಳು (bugs).