మీరు 300 పేజీల చట్టపరమైన బ్రీఫ్ లేదా ఒక వార్షిక నివేదికను సాధారణ OCR పైప్లైన్లలోకి పంపితే, ఆ సాఫ్ట్వేర్ దానిని నిశ్శబ్దంగా చిన్న చిన్న భాగాలుగా విడగొడుతుంది. పేజీ ఒకటి, ప్రాసెస్ చేయండి, మెమరీని క్లియర్ చేయండి. పేజీ రెండు, ప్రాసెస్ చేయండి, మెమరీని క్లియర్ చేయండి. సిస్టమ్ చివరన ఉన్న ఎగ్జిబిట్స్ (exhibits) వద్దకు వచ్చేసరికి, పరిచయంలో (introduction) నుండి అది సేకరించిన ఏ సందర్భం (context) కూడా మిగలదు. ఫుట్నోట్లు (Footnotes) విడిపోతాయి. పేజీల మధ్య విడిపోయిన టేబుల్స్ వాటి నిర్మాణాన్ని కోల్పోతాయి. పేజీల గుండా కొనసాగే హెడర్లు తప్పుగా లేబుల్ చేయబడతాయి. ఫలితంగా, ఒక మనిషి మళ్ళీ అమర్చాల్సి వచ్చే ఒక ముక్కలు ముక్కలుగా కలిపిన టెక్స్ట్ ఫైల్ తయారవుతుంది.
ఈ వర్క్ఫ్లో ప్రాథమికంగా లోపభూయిష్టమైనదని Baidu భావిస్తోంది. వారి సమాధానం Unlimited OCR. ఇది సాధారణంగా జరిగే GPU మెమరీ విస్ఫోటనం (memory explosion) లేకుండా, భారీ, బహుళ పేజీల పత్రాలను ఒకే ఫార్వర్డ్ పాస్ (single forward pass) లో గ్రహించడానికి రూపొందించబడిన ఆర్కిటెక్చర్. దీని వెనుక ఉన్న రహస్యం ఒక కొత్త అటెన్షన్ మెకానిజం (attention mechanism). ఇది మెమరీని హార్డ్ డ్రైవ్లా కాకుండా, మానవ వర్కింగ్ మెమరీలా పరిగణిస్తుంది: మూల పదార్థాన్ని మీ ముందు ఉంచుకోండి, మీరు ఇప్పుడే ఏమి రాశారో గుర్తుంచుకోండి, మరియు పాత విషయాలను మసకబారనివ్వండి.
పొడవైన పత్రాలు సాధారణ OCRని ఎందుకు దెబ్బతీస్తాయి
ఈ పరిష్కారాన్ని అర్థం చేసుకోవడానికి, సాంప్రదాయ ఎండ్-టు-ఎండ్ OCR వ్యవస్థలు ఎక్కడ విఫలమవుతాయో చూడటం సహాయపడుతుంది.
చాలా ఆధునిక OCR పైప్లైన్లు వాటి డీకోడర్గా ఒక లార్జ్ లాంగ్వేజ్ మోడల్ను ఉపయోగిస్తాయి. మోడల్ ఒక పేజీని చదివి టెక్స్ట్ను రూపొందించేటప్పుడు, అది KV cache అని పిలువబడే అంతర్గత ప్రతినిధులను (internal representations) నిల్వ చేస్తుంది—ఇది మోడల్ ఇప్పటికే ఏమి చెప్పిందో ట్రాక్ చేయడానికి సహాయపడే కీలు మరియు విలువలు (keys and values) కలిగిన ఒక రన్నింగ్ డైరీ వంటిది. సమస్య ఏమిటంటే, ప్రతి కొత్త అవుట్పుట్ లైన్తో ఈ డైరీ రేఖీయంగా (linearly) పెరుగుతుంది. పది పేజీలను ప్రాసెస్ చేస్తే, క్యాష్ పది పేజీల లోతుకు చేరుతుంది. వంద పేజీలను ప్రాసెస్ చేస్తే, అది లక్షలాది టోకెన్లకు పెరిగిపోయి, VRAMని ఖర్చు చేస్తూ జనరేషన్ వేగాన్ని గణనీయంగా తగ్గిస్తుంది.
ఇంజనీర్లు దీనిని ఎదుర్కోవడానికి కేవలం దానిని పట్టించుకోకుండా ఉండటమే మార్గంగా తీసుకున్నారు. వారు పత్రాలను విడివిడి పేజీలుగా కత్తిరించి, ప్రతి పేజీని మోడల్ ద్వారా స్వతంత్రంగా రన్ చేస్తారు మరియు ప్రతి దశ మధ్య KV cacheని రీసెట్ చేస్తారు. ఇది పనిని కొనసాగించినప్పటికీ, మోడల్లోని నిరంతర సంబంధాన్ని (continuous thread) ఇది కోల్పోయేలా చేస్తుంది. పేజీ మూడులో మొదలై పేజీ నాలుగులో ముగిసే పేరాగ్రాఫ్ రెండుగా విడిపోతుంది. పేజీల మధ్య ఉండే టేబుల్ ఫార్మాటింగ్ దెబ్బతింటుంది. మునుపటి విభాగాలకు సంబంధించిన రిఫరెన్స్లు విచ్ఛిన్నమైన లింకులుగా మారుతాయి, ఎందుకంటే డీకోడర్కు అంతకుముందు ఏమి వచ్చిందో అనే శాశ్వత మెమరీ ఉండదు. మోడల్ నిజంగా పత్రాన్ని చదవడం లేదు; అది కేవలం విడివిడి ఫ్లాష్కార్డ్లను (isolated flashcards) చూస్తున్నట్లుగా ఉంది.
మానవ ట్రిక్: Reference Sliding Window Attention
Baidu పరిశోధకులు మానవ సంజ్ఞానాత్మకత (human cognition) నుండి ఒక పద్ధతిని తీసుకురావడం ద్వారా దీనిని పరిష్కరించారు. ఒక పుస్తకంలోని ఒక భాగాన్ని మీరు మాన్యువల్గా కాపీ చేస్తున్నారని అనుకోండి. మీరు ఇంతకుముందు కాపీ చేసిన ప్రతి వాక్యాన్ని మీ మనస్సులో ఉంచుకోరు. మీరు మూలాన్ని (source) ఒకసారి చూస్తారు, మీరు రాసిన చివరి కొన్ని పదాలను చూస్తారు, మరియు కొనసాగిస్తారు. మీ వర్కింగ్ మెమరీ చాలా తక్కువ, కానీ మూల పాఠ్యం (source text) మీ ముందు తెరిచి ఉండటం వల్ల, ఆ పని సులభంగా జరుగుతుంది.
Reference Sliding Window Attention, లేదా R-SWA, సరిగ్గా ఈ అంతర్ దృష్టిని (intuition) క్రమబద్ధీకరిస్తుంది.
దీని లోపల, KV cache ఒక నిర్ణీత పొడవు గల క్యూ (fixed-length queue) గా మారుతుంది. మోడల్ కొత్త టోకెన్ను రూపొందించినప్పుడు, అది "reference tokens"—అంటే అసలు విజువల్ ఇమేజ్ ఎంబెడ్డింగ్స్ మరియు ప్రారంభ ప్రాంప్ట్—పై పూర్తి దృష్టిని కలిగి ఉంటుంది, కానీ అది వ్యక్తిగతంగా రూపొందించిన చివరి 128 టోకెన్లను మాత్రమే వెనక్కి చూస్తుంది. అంతే. మోడల్ మొదటి పేజీలో ఉన్నా లేదా యాభై పేజీలో ఉన్నా, దాని స్వంత అవుట్పుట్ హిస్టరీ యొక్క మెమరీ ఫుట్ప్రింట్ ఒకే చోట స్థిరంగా ఉంటుంది. క్యాష్ పెరగదు. అది రీసైకిల్ అవుతుంది.
This is a