Drop a 300 page legal brief or a bound annual report into most OCR pipelines, and the software will quietly break it int

300 പേജുള്ള ഒരു നിയമപരമായ രേഖയോ (legal brief) അല്ലെങ്കിൽ ബൈൻഡ് ചെയ്ത ഒരു വാർഷിക റിപ്പോർട്ടോ മിക്ക OCR പൈപ്പ്‌ലൈനുകളിലേക്കും നൽകിയാൽ, ആ സോഫ്റ്റ്‌വെയർ അതിനെ നിശബ്ദമായി ചെറിയ കഷണങ്ങളായി മുറിക്കും. പേജ് ഒന്ന്, പ്രോസസ്സ് ചെയ്യുക, മെമ്മറി ക്ലിയർ ചെയ്യുക. പേജ് രണ്ട്, പ്രോസസ്സ് ചെയ്യുക, മെമ്മറി ക്ലിയർ ചെയ്യുക. സിസ്റ്റം പിൻഭാഗത്തുള്ള അനുബന്ധങ്ങളിൽ (exhibits) എത്തുമ്പോഴേക്കും, ആമുഖത്തിൽ നിന്ന് ലഭിച്ചേക്കാവുന്ന സന്ദർഭങ്ങൾ (context) പൂർണ്ണമായും നഷ്ടപ്പെട്ടിട്ടുണ്ടാകും. ഫുട്നോട്ടുകൾ അനാഥമാകുന്നു. പേജുകൾക്കിടയിൽ വിഭജിക്കപ്പെടുന്ന പട്ടികകൾ അവയുടെ ഘടന നഷ്ടപ്പെടുത്തുന്നു. പേജുകളിലുടനീളം തുടരുന്ന ഹെഡറുകൾ തെറ്റായി അടയാളപ്പെടുത്തപ്പെടുന്നു. ഇതിന്റെ ഫലമായി, ഒരു മനുഷ്യൻ വീണ്ടും കൂട്ടിച്ചേർക്കേണ്ടി വരുന്ന തരത്തിലുള്ള ഒരു ടെക്സ്റ്റ് ഫയൽ മാത്രമാണ് ലഭിക്കുന്നത്.

ഈ പ്രവർത്തനരീതി അടിസ്ഥാനപരമായി തകരാറിലാണെന്ന് Baidu കരുതുന്നു. അവരുടെ പരിഹാരം Unlimited OCR ആണ്; സാധാരണയായി സംഭവിക്കാറുള്ള GPU മെമ്മറി കുതിച്ചുയരുന്നത് (memory explosion) ഒഴിവാക്കി, വലിയതും ബഹുപേജ് ഉള്ളതുമായ രേഖകൾ ഒരൊറ്റ ഫോർവേഡ് പാസ്സിലൂടെ (single forward pass) ഉൾക്കൊള്ളാൻ രൂപകൽപ്പന ചെയ്ത ഒരു ആർക്കിടെക്ചറാണിത്. ഇതിന്റെ രഹസ്യം പുതിയൊരു അറ്റൻഷൻ മെക്കാനിസമാണ് (attention mechanism). ഇത് മെമ്മറിയെ ഒരു ഹാർഡ് ഡ്രൈവിനെപ്പോലെയല്ല, മറിച്ച് മനുഷ്യന്റെ വർക്കിംഗ് മെമ്മറിയെപ്പോലെയാണ് പരിഗണിക്കുന്നത്: സ്രോതസ്സ് വിവരങ്ങൾ നിങ്ങളുടെ മുന്നിൽ തന്നെ നിലനിർത്തുക, നിങ്ങൾ ഇപ്പോൾ എഴുതിയത് ഓർമ്മിക്കുക, എന്നാൽ വിദൂരമായ ഭൂതകാലം മങ്ങാൻ അനുവദിക്കുക.

എന്തുകൊണ്ടാണ് നീളമുള്ള രേഖകൾ സാധാരണ OCR-നെ തകർക്കുന്നത്

ഈ പരിഹാരം മനസ്സിലാക്കാൻ, പരമ്പരാഗത എൻഡ്-ടു-എൻഡ് (end-to-end) OCR സിസ്റ്റങ്ങൾ എവിടെയാണ് പരാജയപ്പെടുന്നത് എന്ന് നോക്കുന്നത് സഹായിക്കും.

മിക്ക ആധുനിക OCR പൈപ്പ്‌ലൈനുകളും ഒരു ലാർജ് ലാംഗ്വേജ് മോഡലിനെ (LLM) അവയുടെ ഡീകോഡറായി ഉപയോഗിക്കുന്നു. മോഡൽ ഒരു പേജ് വായിക്കുകയും ടെക്സ്റ്റ് നിർമ്മിക്കുകയും ചെയ്യുമ്പോൾ, അത് KV cache എന്ന് വിളിക്കപ്പെടുന്ന ആന്തരിക പ്രതിനിധികളെ (internal representations) സംഭരിക്കുന്നു—അതായത്, മോഡൽ ഇതിനകം പറഞ്ഞ കാര്യങ്ങൾ ട്രാക്ക് ചെയ്യാൻ സഹായിക്കുന്ന കീകളുടെയും (keys) വാല്യൂകളുടെയും (values) ഒരു ഡയറി പോലെയാണിത്. പ്രശ്നം എന്തെന്നാൽ, ഓരോ പുതിയ ഔട്ട്പുട്ട് വരി വരുമ്പോഴും ഈ ഡയറി രേഖീയമായി (linearly) വളരുന്നു എന്നതാണ്. പത്ത് പേജുകൾ പ്രോസസ്സ് ചെയ്താൽ, കാഷെ പത്ത് പേജ് ആഴത്തിലാകും. നൂറ് പേജുകൾ പ്രോസസ്സ് ചെയ്താൽ, അത് ലക്ഷക്കണക്കിന് ടോക്കണുകളായി വളരുകയും VRAM ഉപയോഗിച്ച് തീർക്കുകയും ജനറേഷൻ വേഗത വളരെയധികം കുറയ്ക്കുകയും ചെയ്യുന്നു.

എഞ്ചിനീയർമാർ ഇതിനെ നേരിടുന്നത് അത് നേരിടാതിരിക്കുമ്പോഴാണ്. അവർ രേഖകളെ ഒറ്റപ്പെട്ട പേജുകളായി മുറിക്കുന്നു, ഓരോ പേജും മോഡലിലൂടെ സ്വതന്ത്രമായി പ്രവർത്തിപ്പിക്കുന്നു, കൂടാതെ ഓരോ ഘട്ടത്തിനും ഇടയിൽ KV cache റീസെറ്റ് ചെയ്യുന്നു. ഇത് പ്രവർത്തനം തടസ്സമില്ലാതെ മുന്നോട്ട് കൊണ്ടുപോകാൻ സഹായിക്കുമെങ്കിലും, മോഡലിന്റെ തുടർച്ചയായ ബന്ധം (continuous thread) ഇത് നഷ്ടപ്പെടുത്തുന്നു. പേജ് മൂന്നിൽ തുടങ്ങി പേജ് നാലിൽ അവസാനിക്കുന്ന ഒരു പാരഗ്രാഫ് പകുതിയായി മുറിക്കപ്പെടുന്നു. പേജുകൾക്കിടയിലുള്ള ടേബിൾ ഫോർമാറ്റിംഗ് തകരുന്നു. മുമ്പത്തെ ഭാഗങ്ങളിലേക്കുള്ള റഫറൻസുകൾ തകരാറിലാകുന്നു, കാരണം ഡീകോഡറിന് മുമ്പ് വന്ന കാര്യങ്ങളെക്കുറിച്ച് സ്ഥിരമായ മെമ്മറി ഇല്ല. മോഡൽ യഥാർത്ഥത്തിൽ രേഖ വായിക്കുകയല്ല; മറിച്ച് അത് ഒറ്റപ്പെട്ട ഫ്ലാഷ് കാർഡുകൾ ഉപയോഗിക്കുന്നതുപോലെയാണ് പ്രവർത്തിക്കുന്നത്.

മനുഷ്യസഹജമായ വിദ്യ: Reference Sliding Window Attention

മനുഷ്യന്റെ ചിന്താശേഷിയിൽ (human cognition) നിന്ന് പ്രചോദനം ഉൾക്കൊണ്ടാണ് Baidu ഗവേഷകർ ഇതിനെ നേരിട്ടത്. ഒരു പുസ്തകത്തിൽ നിന്ന് ഒരു ഭാഗം കൈകൊണ്ട് പകർത്തിയെഴുതുന്നത് സങ്കൽപ്പിക്കുക. മുമ്പ് പകർത്തിയ എല്ലാ വാചകങ്ങളും നിങ്ങളുടെ മനസ്സിൽ സൂക്ഷിച്ചുവെക്കണമെന്നില്ല. നിങ്ങൾ സ്രോതസ്സിലേക്ക് ഒന്ന് നോക്കുന്നു, നിങ്ങൾ എഴുതിയ അവസാനത്തെ ഏതാനും വാക്കുകളിലേക്ക് നോക്കുന്നു, തുടർന്ന് എഴുതുന്നു. നിങ്ങളുടെ വർക്കിംഗ് മെമ്മറി വളരെ ചെറുതാണ്, എന്നാൽ സ്രോതസ്സ് ടെക്സ്റ്റ് നിങ്ങളുടെ മുന്നിൽ തന്നെ തുറന്നു കിടക്കുന്നതിനാൽ, ആ ജോലി എളുപ്പമായി മാറുന്നു.

Reference Sliding Window Attention, അഥവാ R-SWA, ഈ ധാരണയെ കൃത്യമായി രൂപപ്പെടുത്തുന്നു.

ഇതിന്റെ പ്രവർത്തനരീതിയിൽ, KV cache എന്നത് ഒരു നിശ്ചിത ദൈർഘ്യമുള്ള ക്യൂ (fixed-length queue) ആയി മാറുന്നു. മോഡൽ ഒരു പുതിയ ടോക്കൺ നിർമ്മിക്കുമ്പോൾ, അത് "റഫറൻസ് ടോക്കണുകളെ" (reference tokens)—അതായത് യഥാർത്ഥ വിഷ്വൽ ഇമേജ് എംബഡിംഗുകളും (visual image embeddings) പ്രാരംഭ പ്രോംപ്റ്റും—പൂർണ്ണമായി കാണുന്നു, എന്നാൽ അത് സ്വയം നിർമ്മിച്ച അവസാനത്തെ 128 ടോക്കണുകളിലേക്ക് മാത്രമേ തിരിഞ്ഞു നോക്കുന്നുള്ളൂ. അത്രമാത്രം. മോഡൽ ഒന്നാം പേജിലായാലും അമ്പതാം പേജിലായാലും, അതിന്റെ ഔട്ട്പുട്ട് ഹിസ്റ്ററിയുടെ മെമ്മറി ഫൂട്ട്പ്രിന്റ് (memory footprint) മാറ്റമില്ലാതെ തുടരുന്നു. കാഷെ വളരുന്നില്ല. അത് പുനരുപയോഗിക്കുന്നു (recycles).

ഇതൊരു