புரட்சிகரமான கவன ஈர்ப்பு முறைகள் பற்றி பேசும்போது, எல்லாரும் ஒரு மந்திரவாதியைப் பார்ப்பது போல தலையாட்டுவார்கள், ஆனால் யாரும் அதைப்பற்றி விளக்கச் சொல்லிக் கேட்க மாட்டார்கள் என்று அமைதியாக நம்புவார்கள். DeepSeek Sparse Attention (DSA) அப்படிப்பட்ட ஒரு தந்திரம்—புத்திசாலித்தனமானது, வேகமானது, மேலும் விவரங்களைப் பார்த்தால், நூற்றுக்கணக்கான பக்கங்களில் கணிதத்தைப் படிக்காமல் புரிந்து கொள்ளக்கூடியது. வாக்குறுதி: அறிவை வைத்துக்கொள், கணினி பயன்பாட்டுக் கட்டணத்தைக் குறை. உண்மை நிலை: இது சூழ்நிலையைப் பொறுத்தது, ஆனால் இந்த முறை சமரசங்கள் புதிதாக இருக்கின்றன.
நாம் விஷயத்திற்கு வருவோம்: DSA என்பது பெரிய மொழி மாதிரிகள் முக்கியமான விஷயங்களில் மட்டும் கவனம் செலுத்த ஒரு வழி. அரை குறையாக அல்ல. அல்லது “ஒருவேளை தொடர்புடையதாக இருக்கலாம்” என்று இல்லாமல். இது ஒரு நேர்த்தியான sparse attention திட்டம், இது முழு self-attention மூலம் கிடைக்கும் quadratic பெருக்கத்தைக் குறைக்கிறது—மாடல் இருக்கும் கிளையை வெட்டாமல். பழைய மாடலின் கவனம் ஒரு அறையைப் போல இருந்தால், ஒவ்வொரு வார்த்தையும் மற்ற ஒவ்வொரு வார்த்தையையும் பார்க்க வேண்டும், DSA அதை introverts செழிப்பாக இருக்கும் ஒரு கட்சியாக மாற்றுகிறது: நேரடி வழிகள், அர்த்தமற்ற சிறு பேச்சுக்கள் குறைவு, மற்றும் அதிக சத்தம் இல்லை.
DeepSeek Sparse Attention என்றால் என்ன?
DSA என்பது ஒரு sparse attention முறை, இது self-attention இன் கணக்கீட்டு சிக்கலை O(L²) லிருந்து O(Lk) ஆகக் குறைக்கிறது, இதில் L என்பது sequence நீளம் மற்றும் k என்பது token ஒன்றுக்கு “வைத்திருக்கும்” இணைப்புகளின் எண்ணிக்கை—தேர்ந்தெடுக்கப்பட்ட, தொடர்புடைய neighbors.. இது ஒரு வரியில் உள்ள pitch. குறைவான கணிதம், அதிக அர்த்தம்: ஒவ்வொரு token-ம் மற்ற ஒவ்வொரு token-னையும் ஒப்பிட்டுப் பார்ப்பதற்கு பதிலாக, DSA ஒரு subset-ஐத் தேர்ந்தெடுக்கிறது—neighbors, heads, windows, “anchors,” மாதிரிக்கு மிகவும் பொருத்தமான heuristic அல்லது கற்றல் கொள்கை எதுவோ—எனவே நீங்கள் தேவையற்றவற்றில் நேரத்தை வீணாக்க மாட்டீர்கள்.
இது உங்களுக்குப் பழக்கமாக இருப்பதாக நினைத்தால், அது உண்மைதான்: sparse attention புதிதல்ல. Longformer, BigBird, block-sparse kernels மற்றும் ஒரு டஜன் “local + global” hybrids நம்மிடம் உள்ளன. வழக்கமான பிரச்சனை என்னவென்றால், sparse patterns recall-ஐ கசிய விடுகின்றன (அவை வைக்கோல் போரில் ஊசியை தவற விடுகின்றன), அல்லது அவற்றை திறமையாக செயல்படுத்த மிகவும் கடினமாக உள்ளது, நீங்கள் கோட்பாட்டளவில் சேமிப்பது kernel overhead ஆக மீண்டும் தோன்றும். DSA இன் சிறப்பு என்னவென்றால்: முதலாவதாக, sparse pattern என்பது garden-variety block sparsity ஐ விட மிகவும் நுணுக்கமானது மற்றும் மாற்றியமைக்கக்கூடியது; இரண்டாவதாக, இது உண்மையான inference stacks-இல் வேலை செய்யும் வகையில் end-to-end ஆக செயல்படுத்தப்பட்டுள்ளது—vLLM உட்பட..
உள்ளுணர்வு: Lightning Indexer, Lawn Mower அல்ல
நான் பார்த்ததிலேயே மிகவும் உதவியாக இருந்த ஒப்புமை: DSA ஒரு lightning indexer போல செயல்படுகிறது. அது முழு வயலையும் வெட்டுவதில்லை; அது முக்கியமானவற்றிற்கு விரைந்து செல்கிறது—மூன்று பத்திகளை அடித்துவிட்டு ஒரு வாக்கியத்தை மட்டும் வைத்திருக்கும் ஒரு நல்ல editor போல. இந்த அமைப்பு token ஒன்றுக்கு அதிக சிக்னல் இணைப்புகளைக் கொண்டுள்ளது—சில relevance scoring மூலம் top-k என்று நினைத்துக் கொள்ளுங்கள்—கூடுதலாக நீண்ட தூர coherence சேதமடையாமல் இருக்க ஒரு மெல்லிய முதுகெலும்பு அமைப்பு (local windows, அவ்வப்போது global tokens) உள்ளது..
பொறியாளர்கள் ஒப்புமைக்குப் பிறகு வரும் பகுதியைப் பற்றி கவலைப்படுகிறார்கள்: “Relevance” என்றால் செயல்பாட்டு ரீதியாக என்ன அர்த்தம்? வெவ்வேறு DSA எழுத்துக்கள் அருகாமை மற்றும் முந்தைய முக்கியத்துவம் மூலம் candidate keys ஐத் தேர்ந்தெடுக்கும் heuristics-களைக் குறிக்கின்றன, அதைத் தொடர்ந்து அந்த candidates மத்தியில் சிறிய கவனம் செலுத்துகிறது. இது மந்திரம் அல்ல; இது triage. வெளிப்படையான neighbors-களை நீங்கள் வைத்திருக்கிறீர்கள் (local context கிட்டத்தட்ட எப்போதும் மொழிக்கு பயனுள்ளதாக இருக்கும்), global “landmarks” தூவி, வாக்குறுதியளிக்கும் out-of-window tokens-க்கு கவனத்தைத் தேர்ந்தெடுக்கவும். நிகர விளைவு: recall ஐ முடக்குவதை விட search space ஐ அளவைக் குறைக்கிறீர்கள். சரியாகச் செய்தால், இது pruning செய்வது போல் இல்லாமல் நல்ல பழக்கவழக்கம் போல இருக்கும்.
கணிதம், குறைந்தபட்ச பதிப்பு
- முழு self-attention: O(L²d), இதில் d என்பது head dimension.
- DSA: O(Lkd). நிலையான k க்கு, இது L இல் linear-ish ஆகும். இது நீண்ட contexts-க்கு முக்கியமானது. 128K tokens-ல், உங்கள் GPU பில் உங்களுக்கு நன்றி தெரிவிக்கும்.
- மாடல் token ஒன்றுக்கு dynamic candidate set ஐ பராமரிக்கிறது. candidate selection மற்றும் அவற்றின் மத்தியில் உண்மையான கவனத்திற்கும் நீங்கள் பணம் செலுத்த வேண்டும். candidate selection வெக்டரைஸ் செய்யப்பட்டு cache-aware ஆக இருந்தால், நீங்கள் வெற்றி பெறுவீர்கள்; இல்லையென்றால், நீங்கள் ஒரு பலூனை அழுத்துகிறீர்கள்.
எல்லா sparse முறைகளிலும் இதுதான் டென்ஷன்: asymptotics ஐக் குறைக்கவும், ஆனால் உங்கள் தரவு நகர்வு மற்றும் kernel launch overhead இல் அதை மீண்டும் அறிமுகப்படுத்த வேண்டாம். DSA-வைச் சுற்றியுள்ள செயலாக்கங்கள் kernel-level ஆதரவு மற்றும் scheduler ஒருங்கிணைப்பை வலியுறுத்துகின்றன, மேலும் சமீபத்திய பதிவுகள் vLLM ஆதரவு deployment அமைப்புகளில் இதை உண்மையானதாக மாற்ற சரியாக வந்திறங்குவதைக் காட்டுகின்றன..
ஏன் DSA இப்போது முக்கியமானது?
ஏனெனில் நீண்ட context என்பது புதிய screen size போர். எல்லோரும் 200K tokens மற்றும் அதற்கு மேல் விரும்புகிறார்கள்—scripts, codebases, உங்கள் மனசாட்சி அளவுள்ள PDFs. அந்த நீளங்களில் Quadratic attention என்பது தாமதம், throughput மற்றும் செலவுக்கு ஒரு தொடக்கமாக இருக்க முடியாது. நீங்கள் அதை புத்திசாலித்தனமான chunking மற்றும் retrieval மூலம் போலியாகச் செய்யலாம், ஆனால் உங்கள் trunk நிரம்பி வருவதால் உங்கள் காரில் ஒரு bookshelf ஐ நிறுவுவது போன்றது. DSA வின் வாதம் எளிமையானது: உண்மையான attention step முட்டாள்தனமாக விலை உயர்ந்ததாக ஆக்காதீர்கள்.
ஒரு பக்க நன்மை ஸ்திரத்தன்மை. மிக நீண்ட sequences முழுவதும் முழு கவனம் செலுத்துவது numerically touchy ஆகவும், memory noisy ஆகவும் இருக்கலாம். Sparse attention வேலை செய்யும் தொகுப்பைச் சுருக்கி, பலவீனமான pairwise மதிப்பெண்களில் மூழ்கி மாடல் “மறந்துவிடும்” வாய்ப்புகளைக் குறைக்கிறது. நீங்கள் ஒரு முதுகெலும்பு கட்டமைப்பையும், அதன் மேல் சிறிய அளவிலான adaptivity ஐயும் வைத்திருக்கிறீர்கள். இது ஒரு நடைமுறை சமரசம், ஒரு காகித டெமோவை விட ஒரு பொறியியல் முடிவு போல் இருக்கிறது.
Sparse உயிரியல் பூங்காவில் DSA எங்கே பொருந்துகிறது
- நிலையான patterns (local windows, dilations): வேகமானது, ஆனால் உடையக்கூடியது. உங்கள் அதிர்ஷ்டம் max ஆக இல்லாவிட்டால், நீண்ட தூர cross-references தவறவிடும்.
- Global tokens: anchors சேர்க்கிறது. சிறந்தது, ஆனால் புரியாதது. நீங்கள் எல்லாவற்றிலும் ஒரு “CLS” ஐ ஒட்டி அதை recall என்று அழைக்க முடியாது.
- கற்றல் கொள்கைகள் மூலம் ரூட்டிங்: சாத்தியமான சிறந்த, செயல்பாட்டு ரீதியாக குழப்பமானது. பயிற்சி சிக்கல்கள் மற்றும் உடையக்கூடிய inference.
- DSA வின் நேர்த்தியான hybrid: ஒவ்வொரு token-க்கும் locality, structured globals மற்றும் high-signal picks ஆகியவற்றை கலக்கும் ஒரு சிறிய candidate set ஐக் curate செய்யவும். புத்திசாலியாக இருக்க வேண்டும் என்பது நோக்கமல்ல—உங்கள் தாமதம் மற்றும் தரம் இரண்டும் அளவிடுவதற்கு போதுமானதாக இருக்க வேண்டும் என்பதுதான்.
செயல்திறன்: O(L²) வரி திரும்ப
இதுவரையிலான coverage கணிசமான செலவு குறைப்புகளைக் கூறுகிறது—“பாதி” செலவுகள் மூச்சுத்திணறல் துண்டுகளில் காட்டப்படுகின்றன—ஆனால் சரியான எண்ணிக்கை அல்ல, இது நீண்ட தூண்டுதல்கள் மற்றும் அதிக concurrency க்கான scaling curve மீண்டும் சாத்தியக்கூறுகளாக வளைகிறது.. உங்கள் work loads:
- 100+ பக்கங்களில் RAG மற்றும் ஆவண சாட்,
- Multi-file குறியீடு வழிசெலுத்தல்,
- நீண்ட scratchpads வைத்திருக்கும் கருவி பயன்படுத்தும் ஏஜெண்டுகள்,
…DSA ஒரு token கணக்கீடு மற்றும் நினைவகத்தைக் குறைக்கிறது. windowed hacks அணிவகுப்பை நடத்துவதற்கு பதிலாக, நீங்கள் context ஐ உண்மையில் பயனுள்ள இடத்தில் வைக்கலாம். ஆரம்ப vLLM ஆதரவு இது bench-bling மட்டும் அல்ல என்று கூறுகிறது—மக்கள் மாதிரிகளை எங்கே deploy செய்கிறார்களோ அங்கே இது இயங்குகிறது..
எச்சரிக்கைகள் (அதாவது ஒரு செவ்வாய்க்கிழமை அன்று யாரும் ஏன் வெற்றி என்று அறிவிக்கக் கூடாது)
- Candidate selection இலவசம் அல்ல. selection routine cache lines மீது தடுமாறினால் அல்லது CPU-GPU ping-pong க்குள் உங்களைத் தள்ளினால், உங்கள் sparsity wins ஆவியாகிவிடும்.
- k என்பது ஒரு பட்ஜெட், பிறப்புரிமை அல்ல. மிகவும் சிறியது மற்றும் நீங்கள் முக்கியமான cross-references ஐ கைவிடுகிறீர்கள். மிகவும் பெரியது மற்றும் நீங்கள் மீண்டும் அடர்த்தியை நோக்கி நகர்கிறீர்கள்.
- Training vs. inference பொருந்தவில்லை. உங்கள் மாடல் dense ஆகப் பயிற்சி பெற்றிருந்தால், நீங்கள் அதை inference இல் sparse ஆக இயக்கினால், தரத்தில் மாற்றம் ஏற்படும் என்று எதிர்பார்க்கலாம். DSA வின் வலுவான முடிவுகள் sparsity பயிற்சி உணவின் ஒரு பகுதியாக இருக்கும்போது காட்டப்படுகின்றன,serving-time garnish ஆக மட்டுமல்ல.
- Long-tail வினோதம். Sparse patterns சில நேரங்களில் எங்கிருந்தோ வரும் callback ஐ 30K tokens கழித்து தவற விடுகின்றன. நல்ல hybrids அவ்வப்போது globals அல்லது கற்ற anchors மூலம் hedge செய்கின்றன.
இது ஒரு புத்தகத்திற்கான நல்ல index ஐ உருவாக்குவது போல் இருந்தால், அது அப்படி இருப்பதால் தான். மிகவும் சிறியது மற்றும் நீங்கள் எதையும் கண்டுபிடிக்க முடியாது; மிகவும் நீளமானது மற்றும் அது மீண்டும் புத்தகம் தான்.
எதை வைத்திருக்க வேண்டும் என்பதை DSA எவ்வாறு தேர்வு செய்கிறது
விவரங்கள் செயலாக்கத்தைப் பொறுத்து மாறுபடும், ஆனால் playbook இப்படி இருக்கும்:
- Local window: neighbors-களை ஒரு sliding window-விற்குள் வைத்திருங்கள்—பெரும்பாலான மொழி கட்டமைப்பு local ஆக இருக்கும். 2) Periodic/global tokens: தொடர்ந்து “beacons” ஐ செருகவும், அவை எப்போதும் உலகளவில் இணைக்கப்படும். 3) Salience scoring: முந்தைய layer activations, cached முக்கியத்துவம் அல்லது top-k similarity போன்ற approximations ஆகியவற்றிலிருந்து lightweight சிக்னல்களைப் பயன்படுத்தி கூடுதல் தொலைதூர tokens ஐத் தேர்ந்தெடுக்கவும். 4) Compact attention: union of the kept set இல் மட்டும் கவனத்தை இயக்கவும். 5) ஒவ்வொரு layer-க்கும் மீண்டும் செய்யவும், வெவ்வேறு heads வெவ்வேறு கட்டமைப்புகளை விரும்ப அனுமதிக்கிறது.
இது மரபுவழி அல்ல; இது வேலை செய்யக்கூடிய மிகக் குறைவான ஆச்சரியமான விஷயம். மற்றும் நவீன inference stacks-இல் செயல்படும் ஆதரவு கிடைத்துள்ளதால், இது வேலை செய்கிறது..
DSA vs. Chunking vs. Retrieval: உங்கள் விஷத்தைத் தேர்ந்தெடுங்கள்
- Naive chunking: வேகமானது, ஆனால் முட்டாள்தனமானது—context எல்லைகள் cliffs ஆகின்றன. throughput-க்கு நல்லது, எதையும் நுட்பமாக செய்வதற்கு கெட்டது.
- Retrieval-augmented generation: புத்திசாலித்தனமானது, ஆனால் உடையக்கூடியது—retriever generator-க்கு பின்னர் என்ன தேவை என்பதை நினைவில் வைத்திருப்பதைப் பொறுத்தது.
- DSA-style sparse attention: கணினி எங்கு முக்கியமோ அங்கு கவனம் செலுத்தி, முழு thread ஐயும் context-இல் வைத்திருக்கிறது. இது retrieval ஐ மாற்றாது; இது retrieval ஐ ஒரு crutch ஆகக் குறைவாக ஆக்குகிறது.
நேர்மையான தீர்வு ஒரு கலவையாகும்: தொடர்புடைய ஆவணங்களை இழுக்க retrieval, உருகாமல் நீண்ட sequences மீது reasoning செய்ய sparse attention. உங்கள் cloud பில்லை வெறுக்காமல் இரண்டையும் செய்யலாம்.
தரம்: இது இன்னும் புரிகிறதா?
sparse attention வாக்கியங்களுக்கு இடையே உள்ள அர்த்தத்தை அமைதியாக கைவிடுகிறதா என்பது மில்லியன் டாலர் கேள்வி. DeepSeek மாதிரிகளுக்கான ஆரம்ப அறிக்கைகள், நீண்ட context-இல் தரம் உயர்ந்து பிடிக்கிறது அல்லது மேம்படுகிறது என்று கூறுகின்றன, ஏனெனில் மாடல் அர்த்தமற்ற pairwise மதிப்பெண்களில் நிகழ்தகவு வெகுஜனத்தை வீணாக்கவில்லை. prompt மூலம் ஒரு நம்பகமான முதுகெலும்பை மாடல் வைத்திருக்கும் வகையில் k மற்றும் global கட்டமைப்பை சரிசெய்வதே தந்திரம். மீண்டும், loop இல் sparsity உடன் பயிற்சி செய்வது முக்கியம்—மாடல்கள் மாற்றியமைக்கின்றன. இது manual transmission மூலம் வாகனம் ஓட்ட கற்றுக்கொள்வது போன்றது; நீங்கள் rhythm பெற்றுவிட்டால், நீங்கள் auto ஐ தவறவிட மாட்டீர்கள்.
Deployment உண்மை: Kernels, Caches, Schedulers
vLLM ஆதரவு குறிப்பு அழைப்பதற்கு மதிப்புள்ளது: DSA ஒரு காகித தந்திரம் மட்டுமல்ல; kernel ஆதரவு மற்றும் scheduling இல் உண்மையான வேலை நடந்து கொண்டிருக்கிறது, எனவே இது scatter-gather நாடகத்துடன் GPU வை நிறுத்தாது.. Block-sparse kernels, fused ops மற்றும் கவனமாக KV-cache layout இந்த விஷயத்தை உருவாக்குகின்றன அல்லது உடைக்கின்றன. sparse attention இல் மோசமான விளைவுகள் நினைவக அலைவரிசை மற்றும் launch overhead உடன் சரியாக உணர்வுப்பூர்வமான யோசனைகள் மோதுவதால் ஏற்படுகின்றன. அவை கையாளப்படும்போது, sparsity பாடுகிறது.
DSA எங்கே ஜொலிக்கிறது
- கட்டமைக்கப்பட்ட ஆவணங்களில் நீண்ட context Q&A. local + beacon கலவை கவனத்தை வெள்ளத்தில் மூழ்கடிக்காமல் பிரிவுகள் மற்றும் cross-references ஐக் கண்காணிக்கிறது.
- Codebase reasoning. Local windows intra-file context ஐப் பிடிக்கின்றன; periodic/global இணைப்புகள் கோப்புகள், function calls மற்றும் imports முழுவதும் பயணிக்கின்றன.
- Scratchpads கொண்ட ஏஜெண்டுகள். Sparse attention ஏஜென்ட் ஒரு நீண்ட வேலை நினைவகத்தை வைத்திருக்க உதவுகிறது, ஐந்தாவது பக்கத்திற்குப் பிறகு அர்த்தமற்றதாக மாறாமல்.
DSA எங்கே இல்லை (இன்னும்)
- சிறிய தூண்டுதல்கள். Dense attention நன்றாக இருக்கிறது; sparse overhead amortization செய்யாமல் போகலாம்.
- அதிவேகமாகப் பிணைக்கப்பட்ட கவிதைகள் அல்லது புதிர் தூண்டுதல்கள் வெளிப்படையான கட்டமைப்பு குறிப்புகள் இல்லாமல் வைக்கோல் போரில் ஊசியைத் தேடத் தேவைப்படுகின்றன. நீங்கள் இன்னும் k ஐ tune செய்யலாம், ஆனால் இந்த முறை riddles ஐ விட patterns ஐ விரும்புகிறது.
இந்த நுட்பங்கள் எதுவாக இருந்தாலும் சோதனை இங்கே: அவை பயனர்களை பணம் பெறாத QA பொறியாளர்களாக மாற்றாமல் கருவிகளை சிறப்பாகச் செய்கிறதா? எனது runs-இல், sparse attention ஐ நன்கு ஒருங்கிணைக்கும் கருவிகள்—குறிப்பாக ஆவணம் மற்றும் குறியீடு சாட்—குறைவாக மனநிலையாக உணர்கின்றன. Sider.AI இங்கே உண்மையில் செயல்படுகிறது: நீங்கள் 80 பக்க விவரக்குறிப்புகளை ஒட்டும்போது அல்லது ஒரு repo மூலம் trudging செய்யும்போது, பக்கம் 47 பற்றி ஸ்தம்பிக்காமல் அல்லது hallucinating செய்யாமல் நீண்ட, ஒத்திசைவான thread ஐ வைத்திருக்கும் திறன் முக்கியமானது. சந்தைப்படுத்தல் “fine-grained sparsity” பற்றி பெருமை பேசவில்லை, அது நன்றாக இருக்கிறது. பயனர்கள் இது responsive ஆக இருக்கும், context ஐ நேராக வைத்திருக்கும், மற்றும் Vegas இல் ஒரு வார இறுதி போல் செலவாகாது என்பதில் கவலைப்படுகிறார்கள். நீங்கள் பெரிய, குழப்பமான உள்ளீடுகளுடன் பணிபுரிந்தால், இந்த வகையான கவனம் செலுத்தும் தந்திரம் ஒரு வகையான under-the-hood மாற்றம், இது குறைவான warts ஆகவும் வேகமான பதில்களாகவும் காட்டுகிறது. நடைமுறை வழிகாட்டுதல்: நீங்கள் DSA ஐப் பயன்படுத்தலாமா என்று முடிவு செய்தால்
- உங்கள் context வழக்கமாக >32K tokens: ஆமாம், அதை மதிப்பீடு செய்யுங்கள்.
- உங்கள் deployment stack ஐ (vLLM, Triton kernels, KV-cache tuning) நீங்களே வைத்திருக்கிறீர்கள்: ஆமாம், குறிப்பாக.
- நீங்கள் dense-trained weights உடன் சிக்கிக் கொண்டிருக்கிறீர்கள் மற்றும் மீண்டும் பயிற்சி செய்ய முடியாது: கவனமாக சோதிக்கவும்; partial sparsity அல்லது head-specific sparsity ஐக் கருத்தில் கொள்ளவும்.
- தாமதம்-உணர்திறன், அதிக-QPS work loads: curve bending இங்கே முக்கியமானது. p95 மற்றும் p99 ஐ அளவிடவும்.
மற்றும் தயவுசெய்து, GPU க்காக எல்லாவற்றையும் நேசிக்கும், செயற்கை லோரெம் இப்சம் அல்ல, உண்மையான தூண்டுதல்களுடன் benchmark செய்யுங்கள். sparse முறைகள் உண்மையான relevance distributions இல் வாழ்கின்றன அல்லது இறக்கின்றன.
Meta-புள்ளி: Good Taste ஆக Sparsity
இதற்கு ஒரு அழகியல் உள்ளது. எல்லாவற்றிலும் சமமாக கவனம் செலுத்தும் மாடல்கள் எல்லோரும் பேசும் கூட்டங்கள் போன்றவை. ஜனநாயகமாகத் தெரிகிறது, எதுவும் சாதிக்கவில்லை. DSA வின் உணர்திறன் editorial: சுவாரஸ்யமான பகுதிகளில் கவனம் செலுத்துங்கள், ஒரு முதுகெலும்பை பராமரிக்கவும், ஒரு பட்ஜெட்டை வைத்திருங்கள். நீங்கள் இயந்திர கற்றலை விட பரந்த ஒரு பாடம் விரும்பினால், அது இங்கே உள்ளது. நல்ல அமைப்புகள் எல்லாவற்றையும் செய்யாது. அவை சரியான விஷயங்களை விரைவாகச் செய்கின்றன.
தவிர்க்க முடியாத எதிர்காலம்: Sparse ஆக பயிற்சி செய்யுங்கள், Sparse ஆக வழங்கவும்
sparse patterns உடன் end-to-end ஆக பயிற்சி பெற்ற அதிகமான மாடல்களை நாங்கள் பார்ப்போம். கடைசி 10–15% தரம் மற்றும் ஸ்திரத்தன்மை எங்கிருந்து வருகிறது: மாடலின் inductive biases வழங்கும் பாதையுடன் ஒத்துப்போகட்டும். நீங்கள் sparse ஆக வழங்கி ஆனால் dense ஆக பயிற்சி செய்தால், நீங்கள் freeway இல் கியர்களை மாற்றும்படி மாடலைக் கேட்கிறீர்கள். இது வேலை செய்யலாம், ஆனால் அது தடுமாறும்போது ஆச்சரியப்பட வேண்டாம்.
இதற்கிடையில், frameworks sparse patterns ஐ composable ஆக்கும்: local windows + periodic globals + கற்ற anchors + retrieval-aware tokens. கடைசி பிட்—retriever salience மற்றும் attention salience க்கு இடையில் loop ஐ மூடுவது—அடுத்த வெளிப்படையான படி போல் உணர்கிறது. நீங்கள் என்ன fetch செய்கிறீர்களோ அது நீங்கள் எதில் கவனம் செலுத்துகிறீர்களோ அதைத் தெரிவிக்கும்போது, நீங்கள் இரண்டு அரை-குருட்டு அமைப்புகளுக்கு இடையில் ping-pong செய்ய மாட்டீர்கள்.
DSA எப்படி வேலை செய்கிறது? சுருக்கமான பதில்
- ஒவ்வொரு token-க்கும் அது சாத்தியமான தொடர்புடைய tokens இன் ஒரு சிறிய தொகுப்பைத் தேர்ந்தெடுக்கிறது—பெரும்பாலும் locals, சில globals, சில ஸ்மார்ட் picks.
- இது அந்தக் கணத்தில் மட்டும் கவனத்தை இயக்குகிறது, quadratic லிருந்து தோராயமாக context நீளத்தில் linear ஆக கணக்கீட்டைக் குறைக்கிறது.
- கோட்பாட்டளவில் சேமிப்பு உண்மையான தாமத wins ஆகக் காண்பிக்கப்படுவதற்காக இது கவனமாக kernels மற்றும் cache layout ஐ நம்பியுள்ளது.
- நீண்ட தூர குறிப்புகள் இழக்கப்படாத வகையில் கட்டமைப்பு மற்றும் போதுமான global connectivity ஐப் பாதுகாப்பதன் மூலம் இது தரத்தை வைத்திருக்கிறது.
அவ்வளவுதான். எந்த தூபமும் இல்லை, மந்திரமும் இல்லை. எதில் கவனம் செலுத்த வேண்டும் என்பதில் நல்ல ரசனை மட்டுமே உள்ளது.
திடுக்கிடும் முடிவு (ஏனென்றால் எப்போதும் ஒன்று இருக்கும்)
ஒவ்வொரு AI தந்திரத்திற்கும் இறுதியில் ஏமாற்றத்தின் தருணம் இருக்கும். sparse attention முக்கியமான ஒன்றை தவறவிடும், ஒருவேளை ஒரு புத்திசாலித்தனமான விமர்சகரால் உருவாக்கப்பட்ட ஒரு தூண்டுதலில், மாடல் மூன்று stanza ஐ முப்பத்தி ஏழாவது stanza வுடன் languages முழுவதும் ஒரு function signature ஐ jugging செய்யும் போது இணைக்க வேண்டும் என்று வலியுறுத்துகிறது. பரவாயில்லை. ஆனால் பெரும்பாலான உண்மையான வேலை கவிதை-slash-benchmarks அல்ல—இது உரை, குறியீடு மற்றும் உண்மைகள் மூலம் grinding செய்வது. அதற்கு, DSA ஒரு நல்ல யோசனை மட்டுமல்ல. உங்கள் context ஐப் படிக்க நடிக்கிற மாடலுக்கும் உண்மையில் படிக்கக்கூடிய மாடலுக்கும் இடையே உள்ள வித்தியாசம் இதுதான்.
மேலும் நீங்கள் cloud பட்ஜெட்டில் துளை போடாமல் அதைச் செய்ய முடிந்தால்? அது ஒரு தந்திரம் அல்ல. அது முன்னேற்றம்..
FAQ
Q1:DeepSeek Sparse Attention (DSA) சாதாரண ஆங்கிலத்தில் எப்படி வேலை செய்கிறது?
DSA முக்கியமான tokens-களுக்கு கவனத்தைக் குறைக்கிறது—பெரும்பாலும் அருகிலுள்ள உரை, சில global anchors, மற்றும் high-signal picks ஒரு குறுகிய பட்டியல். O(L²) ஒப்பீடுகளுக்கு பதிலாக, இது O(Lk) ஐ இயக்குகிறது, கணக்கீட்டைக் குறைக்கும்போது கட்டமைப்பைப் பாதுகாப்பதன் மூலம் தரத்தை வைத்திருக்கிறது.
Q2:நீண்ட context க்கு chunking அல்லது retrieval ஐ விட DSA சிறந்ததா?
DSA எல்லாவற்றையும் ஒரே thread இல் வைத்திருக்கும் அதே வேளையில் கணினி எங்கு முக்கியமோ அங்கு கவனம் செலுத்துகிறது; chunking cliffs ஐ உருவாக்குகிறது மற்றும் retrieval மறக்கக்கூடியதாக இருக்கலாம். சிறந்த அமைப்புகள் quadratic வரி இல்லாமல் நீண்ட context முழுவதும் reasoning செய்வதற்கு DSA உடன் fetching செய்வதற்கு retrieval ஐக் கலக்கின்றன.
Q3:dense attention உடன் ஒப்பிடும்போது DSA மாடல் தரத்தை பாதிக்குமா?
நீங்கள் sparsity ஐ மனதில் வைத்து பயிற்சி செய்து வழங்கினால் (மற்றும் k ஐ சரியாக அமைத்தால்), தரம் உயர்ந்து பிடிக்கிறது—அடிக்கடி நீண்ட contexts க்கு சிறந்தது, ஏனெனில் மாடல் குறைந்த மதிப்புள்ள ஜோடிகளில் மூழ்கவில்லை. dense-trained weights இல் Serve-sparse திசை திருப்பலாம், எனவே உண்மையான தூண்டுதல்களுடன் benchmark செய்யவும்.
Q4:எந்த work loads DSA இலிருந்து அதிகம் பயனடைகின்றன?
Long-context ஆவண Q&A, codebase வழிசெலுத்தல், மற்றும் ஏஜென்ட் scratchpads. Sequence நீளம் பலூன் மற்றும் dense attention தாமதம், நினைவக அழுத்தம் மற்றும் அதிகரித்து வரும் செலவுகளாக மாறும் எந்த இடத்திலும்.
Q5:Deployment க்கு vLLM DSA ஐ ஆதரிக்கிறதா?
ஆம்—சமீபத்திய பதிவுகள் DeepSeek இன் fine-grained sparse attention க்கான ஆதரவை vLLM ஒருங்கிணைப்பதைக் காட்டுகின்றன, kernel மற்றும் scheduler வேலை உற்பத்திக் குழாய்களில் நடைமுறைக்குக் கொண்டு வருகின்றன.
