OpenAI ನ GPT-5.5 Codex ಒಂದು ಸಮಸ್ಯೆಯನ್ನು ಎದುರಿಸುತ್ತಿದೆ. GitHub ಮತ್ತು Hacker News ನಲ್ಲಿನ ಡೆವಲಪರ್ಗಳು ಇತ್ತೀಚಿನ ವಾರಗಳಲ್ಲಿ ವಿಚಿತ್ರ ವರ್ತನೆಯ ಮಾದರಿಯನ್ನು ಗಮನಿಸಲು ಪ್ರಾರಂಭಿಸಿದ್ದಾರೆ. ಸಂಕೀರ್ಣ ಕೋಡಿಂಗ್ ಮತ್ತು ತಾರ್ಕಿಕ ಕಾರ್ಯಗಳನ್ನು ನಿರ್ವಹಿಸಲು ನಿರ್ಮಿಸಲಾದ ಈ ಮಾಡೆಲ್, ಬಳಕೆದಾರರು reasoning-token clustering ಎಂದು ಕರೆಯುತ್ತಿರುವ ವಿಷಯದಲ್ಲಿ ಎಡವುತ್ತಿದೆ. ಇದರ ಪರಿಣಾಮವಾಗಿ ಔಟ್ಪುಟ್ ತುಂಡು ತುಂಡಾಗಿರುವುದು, ತರ್ಕವು ಹಂತಗಳನ್ನು ಬಿಟ್ಟು ಹೋಗುವುದು ಮತ್ತು ಮೇಲ್ನೋಟಕ್ಕೆ ವ್ಯಾಕರಣವು ಪರಿಪೂರ್ಣವಾಗಿ ಕಂಡರೂ ಉತ್ತರಗಳು ಗುರಿಯನ್ನು ತಪ್ಪಿಸುವುದು ಕಂಡುಬರುತ್ತಿದೆ. ಸಾಫ್ಟ್ವೇರ್ ಎಂಜಿನಿಯರಿಂಗ್ಗೆ ಗಂಭೀರ ಸಹಾಯಕನಾಗಿರುವ ಸಾಧನಕ್ಕೆ ಇಂತಹ ತಾಂತ್ರಿಕ ದೋಷವು ಕೇವಲ ಸಣ್ಣ ತೊಂದರೆಯಲ್ಲ.
ಬಳಕೆದಾರರು ವಾಸ್ತವವಾಗಿ ಏನನ್ನು ನೋಡುತ್ತಿದ್ದಾರೆ
ವರದಿಗಳು ಕೇವಲ ಅಸ್ಪಷ್ಟ ದೂರುಗಳಾಗಿ ಬಂದಿಲ್ಲ. ಬಳಕೆದಾರರು ನಿರ್ದಿಷ್ಟ ವೈಫಲ್ಯಗಳನ್ನು ವಿವರಿಸಿದ್ದಾರೆ. ಒಬ್ಬ ಡೆವಲಪರ್ ಮಾಡೆಲ್ ಅನ್ನು ಒಂದು ಫಂಕ್ಷನ್ ಅನ್ನು ರಿಫ್ಯಾಕ್ಟರ್ ಮಾಡಲು, ಹಲವಾರು ಫೈಲ್ಗಳಲ್ಲಿ ಬಗ್ ಅನ್ನು ಪತ್ತೆಹಚ್ಚಲು ಅಥವಾ ಒಂದು ನಿರ್ದಿಷ್ಟ ಡಿಸೈನ್ ಪ್ಯಾಟರ್ನ್ ಅನ್ನು ಅನುಸರಿಸಲು ಕೇಳಬಹುದು, ಆಗ ಮಾಡೆಲ್ ಆರಂಭದಲ್ಲಿ ಬಲವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸಿ ನಂತರ ದಾರಿತಪ್ಪುತ್ತದೆ. ಇದು ಕೇವಲ ತಪ್ಪು ಉತ್ತರಗಳನ್ನು ನೀಡುವುದಲ್ಲ. ಇದು ಬಹು-ಹಂತದ ಆಲೋಚನಾ ಪ್ರಕ್ರಿಯೆಯ ಮಧ್ಯದಲ್ಲಿ ತನ್ನ ಹಾದಿಯನ್ನು ಕಳೆದುಕೊಳ್ಳುವಂತೆ ತೋರುತ್ತಿದೆ. ಐದು ತಾರ್ಕಿಕ ಹಂತಗಳನ್ನು ಹೊಂದಿರಬೇಕಾದ ಒಂದು ಫಂಕ್ಷನ್ ಮೂರನೇ ಹಂತದಲ್ಲೇ ಕುಸಿಯಬಹುದು ಅಥವಾ ರಚನಾತ್ಮಕವಾಗಿ ಸರಿಯಾಗಿ ಕಾಣುವ ಆದರೆ ನಿರ್ಣಾಯಕ edge cases ಗಳನ್ನು ನಿರ್ಲಕ್ಷಿಸುವ ಕೋಡ್ ಅನ್ನು ಸೃಷ್ಟಿಸಬಹುದು. ಈ ಸಮಸ್ಯೆಯ ಒಂದು ವಿಶಿಷ್ಟ ಲಕ್ಷಣವಿದೆ: ಮಾಡೆಲ್ ಭಾಷೆಯಲ್ಲಿ ವಿಫಲವಾಗುತ್ತಿಲ್ಲ; ಅದು ತನ್ನದೇ ಆದ ತರ್ಕವನ್ನು ನಿರ್ವಹಿಸುವಲ್ಲಿ (bookkeeping) ವಿಫಲವಾಗುತ್ತಿದೆ.
reasoning-token clustering ನ ಕಾರ್ಯವಿಧಾನ
ಇದು ಏಕೆ ಮುಖ್ಯ ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು, ದೊಡ್ಡ ಭಾಷಾ ಮಾದರಿಗಳು (large language models) ವಾಸ್ತವವಾಗಿ ಹೇಗೆ ಓದುತ್ತವೆ ಎಂಬುದನ್ನು ಗಮನಿಸುವುದು ಸಹಕಾರಿ. ಅವು ಮನುಷ್ಯರಂತೆ ವಾಕ್ಯಗಳನ್ನು ಸ್ಕ್ಯಾನ್ ಮಾಡುವುದಿಲ್ಲ. ಅವು ಪಠ್ಯವನ್ನು ಟೋಕನ್ಗಳಾಗಿ—ಅಂದರೆ ಅಕ್ಷರಗಳ ತುಣುಕುಗಳು, ಅಕ್ಷರಾಂಶಗಳು ಅಥವಾ ಕೆಲವೊಮ್ಮೆ ಪೂರ್ಣ ಪದಗಳಾಗಿ—ಭಾಗ ಮಾಡುತ್ತವೆ. ಈ ಟೋಕನ್ಗಳು ಯಂತ್ರದ ಕಚ್ಚಾ ವಸ್ತುಗಳಿದ್ದಂತೆ, ಅದು ಪ್ರತಿಕ್ರಿಯೆಗಳನ್ನು ನಿರ್ಮಿಸಲು ಬಳಸುವ Lego bricks ಗಳಿದ್ದಂತೆ.
Reasoning-token clustering ಎಂಬುದು ಮಾಡೆಲ್ ಒಂದು ಪ್ರಮೇಯದಿಂದ (premise) ತೀರ್ಮಾನಕ್ಕೆ (conclusion) ಹೋಗುವಾಗ ಸಂಬಂಧಿತ ಟೋಕನ್ಗಳನ್ನು ಹೇಗೆ ಗುಂಪು ಮಾಡುತ್ತದೆ ಎಂಬುದಾಗಿದೆ. ಸರಿಯಾದ ಪ್ರಕ್ರಿಯೆಯಲ್ಲಿ, ಮಾಡೆಲ್ ಒಂದು ತಾರ್ಕಿಕ ದಾರಿಗೆ ಸಂಬಂಧಿಸಿದ ಟೋಕನ್ಗಳನ್ನು ಒಟ್ಟುಗೂಡಿಸುತ್ತದೆ, ಆ ಆಲೋಚನೆಯನ್ನು ಪರಿಹರಿಸುತ್ತದೆ, ನಂತರ ಮುಂದಿನ ಕ್ಲಸ್ಟರ್ಗೆ ಸುಲಲಿತವಾಗಿ ಬದಲಾಗುತ್ತದೆ. ಕ್ಲಸ್ಟರ್ ಮಾಡುವ ಪ್ರಕ್ರಿಯೆ ತಪ್ಪಾದಾಗ, ವಿಭಿನ್ನ ತಾರ್ಕಿಕ ದಾರಿಯ ಟೋಕನ್ಗಳು ಒಂದಕ್ಕೊಂದು ಬೆರೆತುಹೋಗುತ್ತವೆ. ಒಂದು ತಾರ್ಕಿಕ ವೇರಿಯೇಬಲ್ ಇನ್ನೊಂದರೊಂದಿಗೆ ಬೆರೆತುಹೋಗುತ್ತದೆ. ಸಿಂಟ್ಯಾಕ್ಸ್ (syntax) ಸರಿಯಾಗಿರುತ್ತದೆ, ಆದರೆ ಆಲೋಚನೆಯ ವಾಸ್ತುಶಿಲ್ಪವು (architecture) ಕುಸಿಯುತ್ತದೆ.
ಇದನ್ನು ತರಕಾರಿ ಹೆಚ್ಚುವುದನ್ನು ಮರೆತ ಅಡುಗೆಯವನೊಬ್ಬನಂತೆ ಭಾವಿಸಿ. ಅಡುಗೆಮನೆಯು ಪೂರ್ಣ ಪ್ರಮಾಣದಲ್ಲಿ ಸಾಮಗ್ರಿಗಳಿಂದ ತುಂಬಿದೆ, ರೆಸಿಪಿ ಕೌಂಟರ್ ಮೇಲೆ ತೆರೆದಿದೆ ಮತ್ತು ಅಡುಗೆಯವನಿಗೆ ವರ್ಷಗಳ ತರಬೇತಿಯಿದೆ. ಆದರೆ ಮೂಲಭೂತ ಸಿದ್ಧತೆಯ ಕೆಲಸವು ಗೊಂದಲಮಯವಾಗಿದ್ದರೆ—ಕೆಲಸದ ಸ್ಥಳವು ವ್ಯವಸ್ಥಿತವಾಗಿಲ್ಲದ ಕಾರಣ ಈರುಳ್ಳಿಯನ್ನು ಕೇಕ್ ಹಿಟ್ಟಿನಲ್ಲಿ ಹಾಕಿದರೆ—ಅಡುಗೆಯವನು ಎಷ್ಟೇ ನುರಿತನದವನಾಗಿದ್ದರೂ ಅಂತಿಮ ಫಲಿತಾಂಶವು ಕೆಟ್ಟದಾಗಿರುತ್ತದೆ. GPT-5.5 Codex ಗೆ, ಟೋಕನ್ಗಳು ಪದಾರ್ಥಗಳಿದ್ದಂತೆ ಮತ್ತು reasoning clusters ಎಂಬುದು ಸಿದ್ಧತಾ ಕೇಂದ್ರಗಳಿದ್ದಂತೆ. ಆ ಕೇಂದ್ರಗಳು ಅಸ್ತವ್ಯಸ್ತವಾದಾಗ, ಅಡುಗೆಯ ಫಲಿತಾಂಶವು ಹಾಳಾಗುತ್ತದೆ.
ಒಂದುជាក់ಾತ್ಮಕ ಉದಾಹರಣೆಯು ಇದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ. ಬಳಕೆದಾರರ ದೃಢೀಕರಣವನ್ನು (user authentication) ನಿರ್ವಹಿಸುವ Python ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಡಿಬಗ್ ಮಾಡಲು ಮಾಡೆಲ್ ಅನ್ನು ಕೇಳುತ್ತಿದ್ದೀರಿ ಎಂದು ಕಲ್ಪಿಸಿಕೊಳ್ಳಿ. ಈ ಕಾರ್ಯವು ಏಕಕಾಲದಲ್ಲಿ ಮೂರು ವಿಭಿನ್ನ ವಿಷಯಗಳನ್ನು ಸರಿಯಾಗಿ ನಿರ್ವಹಿಸಬೇಕಾಗುತ್ತದೆ: password hashing, session management, ಮತ್ತು database queries. ಒಂದು ವೇಳೆ reasoning clusters ಪರಸ್ಪರ ಬೆರೆತರೆ, ಮಾಡೆಲ್ session logic ಅನ್ನು hashing routine ಗೆ ಅನ್ವಯಿಸಬಹುದು ಅಥವಾ database variable ಅನ್ನು ಬಳಕೆದಾರರ ಇನ್ಪುಟ್ ಎಂದು ತಪ್ಪಾಗಿ ಭಾವಿಸಬಹುದು. ಸೃಷ್ಟಿಸಲಾದ ಕೋಡ್ ಮೇಲ್ನೋಟಕ್ಕೆ ಸರಿಯಾಗಿ ಕಂಡರೂ, ನೈಜ ಬಳಕೆಯಲ್ಲಿ ವಿಫಲವಾಗಬಹುದು ಅಥವಾ ಭದ್ರತಾ ಲೋಪಕ್ಕೆ (security gap) ಕಾರಣವಾಗಬಹುದು. ಈ ವೈಫಲ್ಯವು ಕೋಡ್ನ ವ್ಯಾಕರಣದಲ್ಲಿಲ್ಲ; ಅದನ್ನು ಸೃಷ್ಟಿಸಿದ ಆಲೋಚನೆಯ ತರ್ಕದಲ್ಲಿವಿದೆ.
ವಾಸ್ತುಶಿಲ್ಪವು ಏಕೆ ಕಷ್ಟಪಡುತ್ತಿದೆ
ಪ್ರಸ್ತುತ ತಲೆಮಾರಿನ ಮಾಡೆಲ್ಗಳನ್ನು ಮನುಷ್ಯರಂತೆ ವರ್ತಿಸುವಂತೆ ಮಾಡಲು ಒತ್ತಡ ಹೇರಲಾಗುತ್ತಿದೆ. ಆ ಮಹತ್ವಾಕಾಂಕ್ಷೆಯು ಸಂಕೀರ್ಣತೆಯನ್ನು ಹೆಚ್ಚಿಸುತ್ತದೆ. ಈ ವ್ಯವಸ್ಥೆಯು ಕೇವಲ ತನ್ನ ತರಬೇತಿ ಡೇಟಾದಿಂದ ಸಿಗುವ ಅಂಕಿಅಂಶಗಳ ಮಾದರಿಗಳ ಆಧಾರದ ಮೇಲೆ ಮುಂದಿನ ಟೋಕನ್ ಅನ್ನು ಊಹಿಸುವುದಿಲ್ಲ. ಬದಲಾಗಿ, ಇದು ನೈಸರ್ಗಿಕವಾಗಿ, ಸಂದರ್ಭೋಚಿತವಾಗಿ ಮತ್ತು ಸಂಭಾಷಣಾತ್ಮಕವಾಗಿ ಕಾಣುವ ತಾರ್ಕಿಕ ಶೈಲಿಯನ್ನು ಅನುಕರಿಸಲು ಪ್ರಯತ್ನಿಸುತ್ತಿದೆ.
ಈ ದ್ವಿಮುಖ ಆದೇಶವು ಘರ್ಷಣೆಯನ್ನು ಉಂಟುಮಾಡುತ್ತದೆ. ಕೇವಲ ಭಾಷೆಯನ್ನು ನಿರ್ವಹಿಸುವುದು—ಧ್ವನಿ, ಶೈಲಿ, ಸೂಕ್ಷ್ಮತೆ, ಸಂಭಾಷಣೆಯ ಹರಿವು—ಇದು ಕಟ್ಟುನಿಟ್ಟಾದ, ರಚನಾತ್ಮಕ ತರ್ಕಕ್ಕಿಂತ ಭಿನ್ನವಾದ ಕಂಪ್ಯೂಟೇಶನಲ್ ಕಾರ್ಯವಾಗಿದೆ. ಎರಡನ್ನೂ ಏಕಕಾಲದಲ್ಲಿ ಮಾಡುವುದು ವಾಸ್ತುಶಿಲ್ಪದ ಮೇಲೆ ಒತ್ತಡವನ್ನು ಉಂಟುಮಾಡುತ್ತದೆ. ಪ್ರಸ್ತುತ ವಿನ್ಯಾಸವು ತರ್ಕ ಮತ್ತು ಭಾಷೆ ಎರಡನ್ನೂ ಏಕಕಾಲದಲ್ಲಿ ನಿರ್ವಹಿಸಲು ಕಷ್ಟಪಡುತ್ತಿದೆ. ಸ್ವಚ್ಛವಾದ, ಅನುಕ್ರಮವಾದ ತಾರ್ಕಿಕ ಸರಪಳಿಗಳ ಬದಲಿಗೆ, ಮಾಡೆಲ್ ಕೆಲವೊಮ್ಮೆ ಅಸ್ತವ್ಯಸ್ತವಾಗಿ ಅಥವಾ ತನ್ನಷ್ಟಕ್ಕೆ ತಾನೇ ಮರಳಿ ಬರುವಂತಹ ತರ್ಕವನ್ನು ನೀಡುತ್ತದೆ; ಇದು ಮನುಷ್ಯರಂತೆ ಕಂಡರೂ ಕಂಪ್ಯೂಟೇಶನಲ್ ದೃಷ್ಟಿಯಿಂದ ಅಸ್ತವ್ಯಸ್ತವಾಗಿರುತ್ತದೆ.
ಒಬ್ಬ ವಕೀಲ ಕಟ್ಟುನಿಟ್ಟಾದ ಒಪ್ಪಂದವನ್ನು ಸಿದ್ಧಪಡಿಸುವ ಜೊತೆಗೆ, ಮಾತಿನ ಮೂಲಕ ಕಾವ್ಯವನ್ನು (spoken-word poetry) ರಚಿಸಲು ಪ್ರಯತ್ನಿಸುತ್ತಿರುವುದನ್ನು ಕಲ್ಪಿಸಿಕೊಳ್ಳಿ. ಇವೆರಡೂ ಭಾಷಾ ಕಾರ್ಯಗಳೇ ಆಗಿದ್ದರೂ, ಇವು ಬೇರೆ ಬೇರೆ ಶಿಸ್ತನ್ನು ಬಯಸುತ್ತವೆ. ಮಾದರಿಯು ಹೆಚ್ಚು ಸಹಜವಾದ, ಮಾನವನಂತಹ ಅಭಿವ್ಯಕ್ತಿಯತ್ತ ವಾಲುವುದೆಂದರೆ, ಅದರ ಕಟ್ಟುನಿಟ್ಟಾದ ತಾರ್ಕಿಕ ಚೌಕಟ್ಟನ್ನು (logical scaffolding) ಕಾಯ್ದುಕೊಳ್ಳುವ ಸಾಮರ್ಥ್ಯ ದುರ್ಬಲಗೊಳ್ಳುತ್ತದೆ. ಸಹಜವಾಗಿ ಕಾಣಿಸಿಕೊಳ್ಳುವ ಪ್ರಯತ್ನವು ಹೆಚ್ಚಿನ ಜ್ಞಾನಾತ್ಮಕ ಹೊರೆಯನ್ನು (cognitive overhead) ಉಂಟುಮಾಡುತ್ತದೆ, ಮತ್ತು ಹೆಚ್ಚಿನ ಸಂಕೀರ್ಣತೆಯು ಯಾವಾಗಲೂ ಉತ್ತಮ ಫಲಿತಾಂಶಕ್ಕೆ ಕಾರಣವಾಗುವುದಿಲ್ಲ. ಮಾದರಿಯನ್ನು ಮೂಲತಃ ಏಕಕಾಲದಲ್ಲಿ ಯೋಚಿಸಲು ಮತ್ತು ಆಕರ್ಷಿಸಲು ಕೇಳಲಾಗುತ್ತಿದೆ, ಮತ್ತು ಅಟೆನ್ಷನ್ ಮೆಕಾನಿಸಮ್ಗಳ (attention mechanisms) ಹಾರ್ಡ್ವೇರ್ ಈ ವಿಭಿನ್ನ ಬೇಡಿಕೆಗಳಿಗೆ ಸಂಪೂರ್ಣವಾಗಿ ಹೊಂದಿಕೊಂಡಿಲ್ಲ.
ಪ್ರಯೋಗಾಲಯದ ಹೊರಗೆ ಇದು ಏಕೆ ಮುಖ್ಯ
ಈ ಘಟನೆಯು ಎರಡು ವಿಭಿನ್ನ ಕಾರಣಗಳಿಂದ ಮಹತ್ವದ್ದಾಗಿದೆ.
ಮೊದಲನೆಯದಾಗಿ, AI ಪರಿಪೂರ್ಣವಲ್ಲ ಎಂಬುದು ಒಂದು ಕಟುವಾದ ನೆನಪೋರಿಸುವಿಕೆಯಾಗಿದೆ. ಅತ್ಯುತ್ತಮ ಮಾದರಿಗಳು ಸಹ ತಮ್ಮ ಮಿತಿಯನ್ನು ತಲುಪಿದಾಗ ತಪ್ಪುಗಳನ್ನು ಮಾಡುತ್ತವೆ. ದೊಡ್ಡ ಭಾಷಾ ಮಾದರಿಗಳ (large language models) ಸುತ್ತಲಿನ ಮಾರುಕಟ್ಟೆ ಚಕ್ರವು ಅವುಗಳನ್ನು ಭವಿಷ್ಯ ನುಡಿಯುವ ವ್ಯವಸ್ಥೆಗಳಂತೆ (oracle-like systems) ಮಾರಾಟ ಮಾಡುತ್ತದೆ, ಆದರೆ ಅವು ಕೇವಲ ಸಂಭವನೀಯ ಇಂಜಿನ್ಗಳಾಗಿವೆ (probabilistic engines). ಅವು ಮುಂದಿನ ಟೋಕನ್ (token) ಯಾವುದು ಎಂದು ಊಹಿಸುತ್ತವೆ, ಮತ್ತು ಕೆಲವೊಮ್ಮೆ ಆ ಊಹೆಗಳು ಸುಸಂಬದ್ಧವಾಗಿ ಕೇಳಿಸುವ ಅರ್ಥಹೀನತೆಗಳಾಗಿ ಬದಲಾಗುತ್ತವೆ. GPT-5.5 Codex ನಂತಹ ಪ್ರಮುಖ ಕೋಡಿಂಗ್ ಮಾದರಿಯು ತನ್ನದೇ ಆದ ತರ್ಕದಲ್ಲಿ ಎಡವುವುದನ್ನು ನೋಡುವುದು ಒಂದು ಆರೋಗ್ಯಕರ ವಾಸ್ತವದ ಪರಿಚಯವಾಗಿದೆ. ಇದು ಪ್ಯಾಟರ್ನ್ ಮ್ಯಾಚಿಂಗ್ (pattern matching) ಮತ್ತು ನೈಜ ತಿಳುವಳಿಕೆಯ ನಡುವಿನ ಗಡಿಯನ್ನು ಗುರುತಿಸುತ್ತದೆ, ಮತ್ತು ಆ ಗಡಿಯು ಇಂದಿಗೂ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ.
ಎರಡನೆಯದಾಗಿ, ವ್ಯವಹಾರಗಳು ಈ ಮಾದರಿಗಳ ಮೇಲೆ ಅವಲಂಬಿತವಾಗಿವೆ. ಕಳಪೆ ಕಾರ್ಯಕ್ಷಮತೆಯು ಉತ್ಪನ್ನ ಅಭಿವೃದ್ಧಿ ಮತ್ತು ಗ್ರಾಹಕ ಸೇವೆಯ ಮೇಲೆ ನೇರವಾದ, ಅಳೆಯಬಹುದಾದ ಪರಿಣಾಮಗಳನ್ನು ಬೀರುತ್ತದೆ. Codex ಅನ್ನು ಬಳಸಿ ಬ್ಯಾಕೆಂಡ್ ಇನ್ಫ್ರಾಸ್ಟ್ರಕ್ಚರ್ (backend infrastructure) ಸಿದ್ಧಪಡಿಸುವ ಸ್ಟಾರ್ಟ್ಅಪ್ ಒಂದು ಭದ್ರತಾ ಲೋಪವನ್ನು (security hole) ಉಂಟುಮಾಡಬಹುದು, ಏಕೆಂದರೆ ಮಾದರಿಯು ಎರಡು ಅಥೆಂಟಿಕೇಶನ್ ಪದರಗಳನ್ನು (authentication layers) ಗೊಂದಲಕ್ಕೀಡು ಮಾಡಿರಬಹುದು. ಇದೇ ರೀತಿಯ ಆರ್ಕಿಟೆಕ್ಚರ್ ಹೊಂದಿರುವ ಗ್ರಾಹಕ ಸೇವಾ ಬಾಟ್ (customer-service bot) ಮರುಪಾವತಿ ಅಥವಾ ಪಾಲಿಸಿ ವಿನಾಯಿತಿಗಳನ್ನು ನೀಡುವ ಭರವಸೆ ನೀಡಬಹುದು, ಆದರೆ ಅದನ್ನು ವಾಸ್ತವದಲ್ಲಿ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು ಸಾಧ್ಯವಾಗದೆ ಕಾನೂನು ಸಂಕಷ್ಟ ಮತ್ತು ಅಸಮಾಧಾನಗೊಂಡ ಬಳಕೆದಾರರನ್ನು ಸೃಷ್ಟಿಸಬಹುದು.
ನೀವು ಸಾಫ್ಟ್ವೇರ್ ಮೀರಿ ನೋಡಿದಾಗ ಅಪಾಯಗಳು ಇನ್ನೂ ಹೆಚ್ಚಾಗುತ್ತವೆ. ಇಂತಹ ಘಟನೆಗಳು ಆರೋಗ್ಯ ರಕ್ಷಣೆ ಅಥವಾ ಕಾರು ಚಾಲನೆ ಮಾಡುವಲ್ಲಿ AI ಬಳಕೆಯ ಬಗ್ಗೆ ಗಂಭೀರ ಪ್ರಶ್ನೆಗಳನ್ನು ಎತ್ತುತ್ತವೆ. ಒಂದು SQL ಕ್ವೇರಿಯನ್ನು ಬರೆಯುವಾಗ ಮಾದರಿಯು ಟೋಕನ್ ಕ್ಲಸ್ಟರ್ಗಳನ್ನು (token clusters) ಗೊಂದಲಕ್ಕೀಡು ಮಾಡಿದರೆ, ಅದು ವೈದ್ಯಕೀಯ ಸ್ಕ್ಯಾನ್ ಅನ್ನು ವಿಶ್ಲೇಷಿಸಿದಾಗ ಅಥವಾ ಸ್ವಯಂಚಾಲಿತ ವಾಹನಕ್ಕಾಗಿ ರಿಯಲ್-ಟೈಮ್ ಸೆನ್ಸರ್ ಡೇಟಾವನ್ನು ವಿಶ್ಲೇಷಿಸಿದಾಗ ಏನಾಗಬಹುದು? ಅಡಿಪಾಯದ ಕಾರ್ಯವಿಧಾನಗಳು—ಅಂದರೆ ಶತಕೋಟಿ ಪ್ಯಾರಾಮೀಟರ್ಗಳ ಮೂಲಕ ಸಾಂಖ್ಯಿಕ ಪ್ಯಾಟರ್ನ್ ಮ್ಯಾಚಿಂಗ್—ಮೂಲತಃ ಒಂದೇ ಆಗಿರುತ್ತವೆ. ಹೆಚ್ಚಿನ ಪರಿಣಾಮ ಬೀರಬಹುದಾದ ಕ್ಷೇತ್ರಗಳಲ್ಲಿ (high-consequence domains) ಈ ವ್ಯವಸ್ಥೆಗಳನ್ನು ನಂಬಬೇಕಾದರೆ, ಟೋಕನ್-ಕ್ಲಸ್ಟರಿಂಗ್ ವೈಫಲ್ಯಗಳು ನೇರವಾಗಿ ಕುಸಿಯುವಂತಹ ತಾರ್ಕಿಕ ವಿಶ್ವಾಸಾರ್ಹತೆಯ ಅಗತ್ಯವಿದೆ.
ಇದು ಕುಸಿತವಲ್ಲ, ಕೇವಲ ಒಂದು ಎಡವುವಿಕೆ
ಇದನ್ನು ವೈಫಲ್ಯ ಎಂದು ಕರೆಯುವುದು ತಪ್ಪಾಗುತ್ತದೆ. ಇಂತಹ ಸಮಸ್ಯೆಗಳು ಹೊಸ ತಂತ್ರಜ್ಞಾನವನ್ನು ನಿರ್ಮಿಸುವ ಪ್ರಕ್ರಿಯೆಯ ಭಾಗವಾಗಿವೆ. AI ಸಾಮರ್ಥ್ಯದಲ್ಲಿನ ಪ್ರತಿಯೊಂದು ಗಮನಾರ್ಹ ಪ್ರಗತಿಯ ನಂತರ ಅಸ್ಥಿರ ನಡವಳಿಕೆಯ ಅವಧಿಯು ಬಂದಿದೆ. ಆರಂಭಿಕ GPT ಮಾದರಿಗಳು ತಪ್ಪು ಮಾಹಿತಿಯನ್ನು ಅತ್ಯಂತ ಆತ್ಮವಿಶ್ವಾಸದಿಂದ ನೀಡುತ್ತಿದ್ದವು. ಇಮೇಜ್ ಜನರೇಟರ್ಗಳು ಒಮ್ಮೆ ಮಾನವನ ಕೈಗಳನ್ನು ವಿರೂಪಗೊಳಿಸುತ್ತಿದ್ದವು. ಕೋಡ್ ಮಾದರಿಗಳು ಅಸ್ಪಷ್ಟ ಸೂಚನೆಗಳನ್ನು ಎದುರಿಸಿದಾಗ ಪದೇ ಪದೇ ಇನ್ಫಿನಿಟ್ ಲೂಪ್ಗಳನ್ನು (infinite loops) ನೀಡುತ್ತಿದ್ದವು. ಪ್ರತಿಯೊಂದು ದೋಷವು ಒಂದು ಗಡಿಯನ್ನು ಎತ್ತಿ ತೋರಿಸಿತು, ಮತ್ತು ಸಂಶೋಧಕರು ಆ ಗಡಿಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಉತ್ತಮ ಮಾರ್ಗಸೂಚಿಗಳನ್ನು ರೂಪಿಸಿದರು.
ಸಂಶೋಧಕರು ಈ ತಪ್ಪುಗಳನ್ನು ಸರಿಪಡಿಸಲು ಮತ್ತು ವ್ಯವಸ್ಥೆಗಳನ್ನು ಸುಧಾರಿಸಲು ಬಳಸುತ್ತಾರೆ. GitHub ಥ್ರೆಡ್ಗಳು ಮತ್ತು Hacker News ಕಾಮೆಂಟ್ ವಿಭಾಗಗಳಿಂದ ಬರುವ ಪ್ರತಿಕ್ರಿಯೆಗಳು ಕೇವಲ ಗದ್ದಲವಲ್ಲ. ಅವು ನೈಜ ಪ್ರಪಂಚದಿಂದ ಬಂದ ಕಚ್ಚಾ ರೋಗನಿರ್ಣಯದ ಡೇಟಾ (raw diagnostic data). ನೂರಾರು ಡೆವಲಪರ್ಗಳು ಸಾವಿರಾರು ವಿಭಿನ್ನ ಕಾರ್ಯಗಳ ಮೂಲಕ ಒಂದು ಮಾದರಿಯನ್ನು ಪರೀಕ್ಷಿಸಿದಾಗ, ಯಾವುದೇ ಆಂತರಿಕ ಗುಣಮಟ್ಟ ಪರಿಶೀಲನಾ ತಂಡವು (internal quality-assurance team) ಸಂಪೂರ್ಣವಾಗಿ ಅನುಕರಿಸಲು ಸಾಧ್ಯವಾಗದ ವೈಫಲ್ಯದ ವಿಧಾನಗಳು (failure modes) ಹೊರಬರುತ್ತವೆ. ಈ ಸಮೂಹದ ಪರಿಶೀಲನೆಯು ಪ್ರತಿಕ್ರಿಯೆಯ ಚಕ್ರವನ್ನು ಬಿಗಿಗೊಳಿಸುತ್ತದೆ ಮತ್ತು ವೇಗವಾದ, ಹೆಚ್ಚು ಗುರಿ ಹೊಂದಿದ ಪರಿಹಾರಗಳನ್ನು (patches) ತರಲು ಒತ್ತಾಯಿಸುತ್ತದೆ.
ಈ ಘಟನೆಯು ಬಹುಶಃ ಮಾದರಿಯ ಉತ್ತಮ ಆವೃತ್ತಿಗೆ ಕಾರಣವಾಗಬಹುದು. ಒಂದು ದೋಷವನ್ನು ಗುರುತಿಸಿ ಅರ್ಥಮಾಡಿಕೊಂಡ ನಂತರ OpenAI ಐತಿಹಾಸಿಕವಾಗಿ ವೇಗವಾಗಿ ಸುಧಾರಣೆಗಳನ್ನು ತರುತ್ತದೆ. ಈ ಪರಿಹಾರವು ಅಟೆನ್ಷನ್ ಮೆಕಾನಿಸಮ್ ಅನ್ನು ಹೊಂದಿಸುವುದಾಗಿರಲಿ, ರೀಸನಿಂಗ್ ಲೇಯರ್ಗಳನ್ನು (reasoning layers) ಭಾಷಾ ಲೇಯರ್ಗಳ ವಿರುದ್ಧ ಹೇಗೆ ತೂಕ ಮಾಡಬೇಕೆಂದು ಸುಧಾರಿಸುವುದಾಗಿರಲಿ, ಅಥವಾ ಬಳಕೆದಾರರಿಗೆ ತಲುಪುವ ಮೊದಲು ಗೊಂದಲಮಯ ಟೋಕನ್ ಕ್ಲಸ್ಟರ್ಗಳನ್ನು ಹಿಡಿಯುವ ಹೊಸ ವ್ಯಾಲಿಡೇಶನ್ ಹಂತಗಳನ್ನು ಪರಿಚಯಿಸುವುದಾಗಿರಲಿ, ಇದರ ಫಲಿತಾಂಶವು ಹೆಚ್ಚು ಸ್ಥಿರವಾದ ವ್ಯವಸ್ಥೆಯಾಗಿರುತ್ತದೆ.
ನಿಜವಾದ ಪಾಠ
ಕೆಲಸ ಮಾಡುವ ಡೆವಲಪರ್ಗಳಿಗೆ, ಈ ಪಾಠವು ಪ್ರಾಯೋಗಿಕವಾಗಿದೆ. AI-ಜನರೇಟೆಡ್ ಕೋಡ್ ಮತ್ತು ತರ್ಕವನ್ನು ಪೂರ್ಣಗೊಂಡ ಉತ್ಪನ್ನವಾಗಿ ನೋಡದೆ, ಕೇವಲ ಮೊದಲ ಕರಡು (first draft) ಎಂದು ಪರಿಗಣಿಸಿ. ನಿಮ್ಮ ಪರೀಕ್ಷೆಗಳನ್ನು (tests) ನಡೆಸಿ. ತರ್ಕವನ್ನು ಹಂತ ಹಂತವಾಗಿ ಸ್ವತಃ ಪರಿಶೀಲಿಸಿ. ಔಟ್ಪುಟ್ ಮೇಲ್ನೋಟಕ್ಕೆ ಸುಂದರವಾಗಿ ಕಂಡರೂ ಸಹ, ಮಾದರಿಯು ತನ್ನ ಆಂತರಿಕ ಟೋಕನ್ ಕ್ಲಸ್ಟರ್ಗಳನ್ನು ಗೊಂದಲಕ್ಕೀಡು ಮಾಡಿರಬಹುದು ಎಂದು ಭಾವಿಸಿ. ಸುಂದರವಾದ ಸಿಂಟ್ಯಾಕ್ಸ್ (syntax) ಒಂದು ಗೊಂದಲಮಯ ಆಲೋಚನೆಯನ್ನು ಮರೆಮಾಚಿರಬಹುದು.
ಇಡೀ ಉದ್ಯಮಕ್ಕೆ, ಕೃತಕ ಬುದ್ಧಿಮತ್ತೆಯಲ್ಲಿನ ಪ್ರಗತಿಯು ನೇರ ರೇಖೆಯಲ್ಲ ಎಂಬುದನ್ನು ಈ ಘಟನೆಯು ಒತ್ತಿಹೇಳುತ್ತದೆ. ಇದು ಬಿಡುಗಡೆ, ವೈಫಲ್ಯ, ರೋಗನಿರ್ಣಯ ಮತ್ತು ದುರಸ್ತಿಯ ಒಂದು ಚಕ್ರವಾಗಿದೆ. GPT-5.5 Codex ಎಡವ可能是, ಆದರೆ ಆ ಎಡವುವಿಕೆಯಿಂದಲೇ ಮುಂದಿನ ಆವೃತ್ತಿಯು ನೇರವಾಗಿ ನಡೆಯುವುದನ್ನು ಕಲಿಯುತ್ತದೆ.
Optional learning community: [