ಹೆಚ್ಚಿನ OCR ಪೈಪ್ಲೈನ್ಗಳಿಗೆ ನೀವು 300 ಪುಟಗಳ ಕಾನೂನು ಸಾರಾಂಶ ಅಥವಾ ಬೌಂಡ್ ವಾರ್ಷಿಕ ವರದಿಯನ್ನು ನೀಡಿದರೆ, ಸಾಫ್ಟ್ವೇರ್ ಅದನ್ನು ಸಣ್ಣ ತುಣುಕುಗಳಾಗಿ ವಿಭಜಿಸುತ್ತದೆ. ಪುಟ ಒಂದು, ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಿ, ಮೆಮೊರಿಯನ್ನು ಖಾಲಿ ಮಾಡಿ. ಪುಟ ಎರಡು, ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಿ, ಮೆಮೊರಿಯನ್ನು ಖಾಲಿ ಮಾಡಿ. ಸಿಸ್ಟಮ್ ಕೊನೆಯಲ್ಲಿರುವ ಪರಿಶಿಷ್ಟಗಳನ್ನು ತಲುಪುವಷ್ಟರಲ್ಲಿ, ಪೀಠಿಕೆಯಿಂದ ಪಡೆದ ಯಾವುದೇ ಸಂದರ್ಭದ ಮಾಹಿತಿ (context) ಬಹಳ ಹಿಂದೆಯೇ ಮಾಯವಾಗಿರುತ್ತದೆ. ಪಾದಟಿಪ್ಪಣಿಗಳು ಅನಾಥಗಳಾಗುತ್ತವೆ. ಪುಟಗಳ ನಡುವೆ ವಿಭಜನೆಯಾದ ಕೋಷ್ಟಕಗಳು ತಮ್ಮ ರಚನೆಯನ್ನು ಕಳೆದುಕೊಳ್ಳುತ್ತವೆ. ಪುಟಗಳ ಉದ್ದಕ್ಕೂ ಮುಂದುವರಿಯುವ ಹೆಡರ್ಗಳಿಗೆ ತಪ್ಪು ಲೇಬಲ್ಗಳು ಅಂಟಿಕೊಳ್ಳುತ್ತವೆ. ಇದರ ಪರಿಣಾಮವಾಗಿ, ಮನುಷ್ಯರು ಮತ್ತೆ ಜೋಡಿಸಬೇಕಾದ ಒಂದು ಕತ್ತರಿಸಿದ ಪಠ್ಯ ಫೈಲ್ ಸಿದ್ಧವಾಗುತ್ತದೆ.
ಈ ಕಾರ್ಯವಿಧಾನವು ಮೂಲಭೂತವಾಗಿ ದೋಷಪೂರಿತವಾಗಿದೆ ಎಂದು Baidu ಭಾವಿಸುತ್ತದೆ. ಅವರ ಉತ್ತರವೇ Unlimited OCR. ಇದು GPU ಮೆಮೊರಿ ಸ್ಫೋಟವಾಗದಂತೆ, ಬೃಹತ್ ಮತ್ತು ಬಹು-ಪುಟಗಳ ದಾಖಲೆಗಳನ್ನು ಒಂದೇ ಫಾರ್ವರ್ಡ್ ಪಾಸ್ನಲ್ಲಿ ಸ್ವೀಕರಿಸಲು ವಿನ್ಯಾಸಗೊಳಿಸಲಾದ ಆರ್ಕಿಟೆಕ್ಚರ್ ಆಗಿದೆ. ಇದರ ರಹಸ್ಯವೆಂದರೆ ಹೊಸ ಅಟೆನ್ಷನ್ ಮೆಕ್ಯಾನಿಸಂ (attention mechanism). ಇದು ಮೆಮೊರಿಯನ್ನು ಹಾರ್ಡ್ ಡ್ರೈವ್ನಂತೆ ನೋಡದೆ, ಮಾನವನ ವರ್ಕಿಂಗ್ ಮೆಮೊರಿಯಂತೆ ಪರಿಗಣಿಸುತ್ತದೆ: ಮೂಲ ಮಾಹಿತಿಯನ್ನು ನಿಮ್ಮ ಎದುರಿಗೆ ಇರಿಸಿ, ನೀವು ಈಗಷ್ಟೇ ಬರೆದದ್ದನ್ನು ನೆನಪಿಟ್ಟುಕೊಳ್ಳಿ ಮತ್ತು ಹಳೆಯದನ್ನು ಮರೆಯಲು ಬಿಡಿ.
ಉದ್ದನೆಯ ದಾಖಲೆಗಳು ಪ್ರಮಾಣಿತ OCR ಅನ್ನು ಏಕೆ ಹಾಳುಮಾಡುತ್ತವೆ
ಈ ಪರಿಹಾರವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು, ಸಾಂಪ್ರದಾಯಿಕ ಎಂಡ್-ಟು-ಎಂಡ್ OCR ಸಿಸ್ಟಮ್ಗಳು ಎಲ್ಲಿ ವಿಫಲವಾಗುತ್ತವೆ ಎಂಬುದನ್ನು ನೋಡುವುದು ಸಹಕಾರಿ.
ಹೆಚ್ಚಿನ ಆಧುನಿಕ OCR ಪೈಪ್ಲೈನ್ಗಳು ತಮ್ಮ ಡಿಕೋಡರ್ ಆಗಿ ದೊಡ್ಡ ಭಾಷಾ ಮಾದರಿಯನ್ನು (large language model) ಬಳಸುತ್ತವೆ. ಮಾದರಿಯು ಪುಟವನ್ನು ಓದಿ ಪಠ್ಯವನ್ನು ಸೃಷ್ಟಿಸುವಾಗ, ಅದು KV cache ಎಂಬ ಆಂತರಿಕ ಪ್ರತಿನಿಧಿಗಳನ್ನು ಸಂಗ್ರಹಿಸುತ್ತದೆ—ಇದು ಮಾದರಿಯು ಈಗಾಗಲೇ ಏನು ಹೇಳಿದೆ ಎಂಬುದನ್ನು ನೆನಪಿಟ್ಟುಕೊಳ್ಳಲು ಸಹಾಯ ಮಾಡುವ ಕೀಗಳು ಮತ್ತು ಮೌಲ್ಯಗಳ (keys and values) ಒಂದು ಚಲನಶೀಲ ಡೈರಿಯಾಗಿದೆ. ಸಮಸ್ಯೆ ಏನೆಂದರೆ, ಪ್ರತಿ ಹೊಸ ಔಟ್ಪುಟ್ ಸಾಲಿನೊಂದಿಗೆ ಈ ಡೈರಿಯು ರೇಖೀಯವಾಗಿ ಬೆಳೆಯುತ್ತದೆ. ಹತ್ತು ಪುಟಗಳನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಿದರೆ, ಕ್ಯಾಶ್ ಹತ್ತು ಪುಟಗಳಷ್ಟು ಆಳವಾಗಿರುತ್ತದೆ. ನೂರು ಪುಟಗಳನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಿದರೆ, ಅದು ಲಕ್ಷಾಂತರ ಟೋಕನ್ಗಳಾಗಿ ಬೆಳೆದು, VRAM ಅನ್ನು ಖಾಲಿ ಮಾಡುತ್ತದೆ ಮತ್ತು ಉತ್ಪಾದನಾ ವೇಗವನ್ನು ಕುಂಠಿತಗೊಳಿಸುತ್ತದೆ.
ಎಂಜಿನಿಯರ್ಗಳು ಇದನ್ನು ಸರಳವಾಗಿ ನಿರ್ಲಕ್ಷಿಸುವ ಮೂಲಕ ಎದುರಿಸಿದ್ದಾರೆ. ಅವರು ದಾಖಲೆಗಳನ್ನು ಪ್ರತ್ಯೇಕ ಪುಟಗಳಾಗಿ ಕತ್ತರಿಸುತ್ತಾರೆ, ಪ್ರತಿ ಪುಟವನ್ನು ಸ್ವತಂತ್ರವಾಗಿ ಮಾದರಿಯ ಮೂಲಕ ರನ್ ಮಾಡುತ್ತಾರೆ ಮತ್ತು ಪ್ರತಿ ಹಂತದ ನಡುವೆ KV cache ಅನ್ನು ಮರುಹೊಂದಿಸುತ್ತಾರೆ. ಇದು ಕೆಲಸ ನಡೆಯುವಂತೆ ಮಾಡುತ್ತದೆ, ಆದರೆ ಇದು ಮಾದರಿಯಿಂದ ಯಾವುದೇ ನಿರಂತರತೆಯನ್ನು ಕಿತ್ತುಕೊಳ್ಳುತ್ತದೆ. ಪುಟ ಮೂರರಲ್ಲಿ ಪ್ರಾರಂಭವಾಗಿ ಪುಟ ನಾಲ್ಕರಲ್ಲಿ ಕೊನೆಗೊಳ್ಳುವ ಪ್ಯಾರಾಗ್ರಾಫ್ ಅರ್ಧಕ್ಕೆ ಕತ್ತರಿಸಲ್ಪಡುತ್ತದೆ. ಪುಟಗಳ ನಡುವಿನ ಕೋಷ್ಟಕ ಫಾರ್ಮ್ಯಾಟಿಂಗ್ ಹದಗೆಡುತ್ತದೆ. ಹಿಂದಿನ ವಿಭಾಗಗಳ ಉಲ್ಲೇಖಗಳು ಕಳಪೆ ಲಿಂಕ್ಗಳಾಗಿ ಬದಲಾಗುತ್ತವೆ ಏಕೆಂದರೆ ಡಿಕೋಡರ್ಗೆ ಮೊದಲು ಬಂದಿದ್ದರ ಬಗ್ಗೆ ಯಾವುದೇ ಸ್ಥಿರ ನೆನಪಿಲ್ಲ. ಮಾದರಿಯು ನಿಜವಾಗಿ ದಾಖಲೆಯನ್ನು ಓದುತ್ತಿಲ್ಲ; ಅದು ಕೇವಲ ಪ್ರತ್ಯೇಕವಾದ ಫ್ಲ್ಯಾಶ್ಕಾರ್ಡ್ಗಳ ಸರಣಿಯನ್ನು ಮಾಡುತ್ತಿದೆ.
ಮಾನವ ತಂತ್ರ: Reference Sliding Window Attention
Baidu ಸಂಶೋಧಕರು ಮಾನವ ಸಂಜ್ಞಾನಶಾಸ್ತ್ರದಿಂದ (human cognition) ಸ್ಫೂರ್ತಿ ಪಡೆದು ಇದನ್ನು ಪರಿಹರಿಸಿದ್ದಾರೆ. ಪುಸ್ತಕದಿಂದ ಒಂದು ಭಾಗವನ್ನು ಕೈಯಿಂದ ನಕಲು ಮಾಡುವುದನ್ನು ನೆನಪಿಸಿಕೊಳ್ಳಿ. ನೀವು ಈ ಮೊದಲು ನಕಲು ಮಾಡಿದ ಪ್ರತಿಯೊಂದು ವಾಕ್ಯವನ್ನು ನಿಮ್ಮ ಮನಸ್ಸಿನಲ್ಲಿ ಇಟ್ಟುಕೊಳ್ಳುವುದಿಲ್ಲ. ನೀವು ಮೂಲವನ್ನು ಒಮ್ಮೆ ನೋಡುತ್ತೀರಿ, ನೀವು ಬರೆದ ಕೊನೆಯ ಕೆಲವು ಪದಗಳನ್ನು ನೋಡುತ್ತೀರಿ ಮತ್ತು ಮುಂದುವರಿಯುತ್ತೀರಿ. ನಿಮ್ಮ ವರ್ಕಿಂಗ್ ಮೆಮೊರಿ ಚಿಕ್ಕದಾಗಿರುತ್ತದೆ, ಆದರೆ ಮೂಲ ಪಠ್ಯವು ನಿಮ್ಮ ಎದುರೇ ತೆರೆದಿದ್ದರಿಂದ, ಕೆಲಸವು ಸುಲಭವಾಗುತ್ತದೆ.
Reference Sliding Window Attention, ಅಥವಾ R-SWA, ಇದೇ ಅಂತಃಪ್ರಜ್ಞೆಯನ್ನು ಔಪಚಾರಿಕಗೊಳಿಸುತ್ತದೆ.
ಇದರ ಕಾರ್ಯವೈಖರಿಯ ಅಡಿಯಲ್ಲಿ, KV cache ಒಂದು ನಿಗದಿತ ಉದ್ದದ ಕ್ಯೂ (queue) ಆಗುತ್ತದೆ. ಮಾದರಿಯು ಹೊಸ ಟೋಕನ್ ಅನ್ನು ಸೃಷ್ಟಿಸಿದಾಗ, ಅದು "ರೆಫರೆನ್ಸ್ ಟೋಕನ್ಗಳನ್ನು" (reference tokens)—ಅಂದರೆ ಮೂಲ ದೃಶ್ಯ ಚಿತ್ರದ ಎಂಬೆಡ್ಡಿಂಗ್ಗಳು ಮತ್ತು ಆರಂಭಿಕ ಪ್ರಾಂಪ್ಟ್—ಪೂರ್ಣವಾಗಿ ನೋಡಬಲ್ಲದು, ಆದರೆ ಅದು ತಾನು ವೈಯಕ್ತಿಕವಾಗಿ ಸೃಷ್ಟಿಸಿದ ಕೊನೆಯ 128 ಟೋಕನ್ಗಳನ್ನು ಮಾತ್ರ ಹಿಂದಕ್ಕೆ ನೋಡುತ್ತದೆ. ಅಷ್ಟೇ. ಮಾದರಿಯು ಮೊದಲ ಪುಟದಲ್ಲಿದ್ದರೂ ಅಥವಾ ಐವತ್ತನೇ ಪುಟದಲ್ಲಿದ್ದರೂ, ಅದರ ಸ್ವಂತ ಔಟ್ಪುಟ್ ಇತಿಹಾಸದ ಮೆಮೊರಿ ಫುಟ್ಪ್ರಿಂಟ್ ಒಂದೇ ಕಡೆ ಸ್ಥಿರವಾಗಿರುತ್ತದೆ. ಕ್ಯಾಶ್ ಬೆಳೆಯುವುದಿಲ್ಲ. ಅದು ಮರುಬಳಕೆ ಮಾಡುತ್ತದೆ.
ಇದು ಒಂದು