Browse parent directory

2025-04-10

# एम्बेडिंग खोज को सरल बनाएं

**लंबी कहानी का सार (TLDR):** जटिलता बुरी, ग्राफ-आधारित एल्गोरिथ्म अच्छे, ज्यामितीय (geometric) एल्गोरिथ्म बुरे, बकेट (buckets) अच्छे

## क्यों?
- मैं एक सरल एम्बेडिंग खोज एल्गोरिथ्म ढूंढ रहा हूं क्योंकि राजनीतिक परियोजनाओं को जटिल सॉफ़्टवेयर के बजाय सरल सॉफ़्टवेयर पर भरोसा करना चाहिए।
  - उदाहरण के लिए, टोरेंट (Torrent) कोडबेस एथेरियम (Ethereum) कोडबेस की तुलना में सरल है, इसलिए यह मेरी राय में राजनीतिक नियंत्रण में आने की कम संभावना रखता है।
  - ऐसी राजनीतिक परियोजनाओं के उदाहरण: डिस्ट्रिब्यूटेड सोशल मीडिया के लिए खोज फ़ीचर, डिस्ट्रिब्यूटेड सोशल मीडिया का स्पैम फ़िल्टर, सिक्योरड्रॉप (SecureDrop) सर्वर (जहाँ लीक किए गए दस्तावेज़ जमा होते हैं) के लिए स्पैम फ़िल्टर, प्रकाशित लीक हुए दस्तावेज़ों के लिए खोज सुविधा, इत्यादि।
- 2025 तक, बड़े डेटा सेट पर एलएलएम (LLM) इस्तेमाल करने के लिए एम्बेडिंग खोज लगभग ज़रूरी और काफ़ी है। और एलएलएम मूलतः हर काम में सर्वोत्तम एआई मानक बन चुके हैं।
  - भविष्य में यह बदल सकता है, मुमकिन है एक दिन इतना सस्ता हो जाए कि पूरे इंटरनेट के टोकन (डेटा) बस इनफ़रेंस (inference) के लिए खिला दिए जाएँ और सीधे सबसे प्रासंगिक सामग्री मिल जाए।
  - हमारे पास एम्बेडिंग लेयर के अलावा अन्य लेयर को समझने के लिए अच्छे इंटरप्रिटेबिलिटी टूल (interpretability tools) अभी तक नहीं हैं।
  - इनपुट बहुत महंगा है और अन्य लेयर बहुत मददगार नहीं हैं, इसलिए हम शायद एम्बेडिंग्स पर ही निर्भर रहेंगे।

## एम्बेडिंग खोज क्या है?
किसी डेटा सेट में मौजूद वेक्टरों (vectors) और एक क्वेरी (query) वेक्टर के बीच डॉट-प्रोडक्ट (dot product) को अधिकतम करने वाले टॉप-10 वेक्टर खोजना।  
यदि सभी वेक्टर यूनिट वेक्टर (unit vectors) हैं, तो यह वही है जैसा यूक्लिडियन दूरी (euclidean distance) को न्यूनतम करना।

## प्रचलित एल्गोरिथ्म
- ग्राफ आधारित - HNSW, पाइनकोन (Pinecone) के स्वामित्व वाले (?) एल्गोरिथ्म
- ज्यामिति आधारित - लोकैलिटी सेंसिटिव हैशिंग (LSH), k-मीन्स क्लस्टरिंग, प्रोडक्ट क्वांटाइज़ेशन (subvectors)
- ब्रूट-फ़ोर्स (सीधे गणना द्वारा खोज)

## डेटा सेट का आकार
- सामान्य नियम: 1000 कैरेक्टर (~1 KB) → 1536-डाइमेंशनल float32 वेक्टर (~6 KB)
- 1 TB टेक्स्ट → लगभग 6 TB एम्बेडिंग, 1 PB टेक्स्ट → लगभग 6 PB एम्बेडिंग

## ब्रूट-फ़ोर्स एल्गोरिथ्म
- कॉमनक्रॉल (Commoncrawl) लगभग 1 PB टेक्स्ट है। यानी क़रीब 10^12 (एक ट्रिलियन) वेक्टर। ~10 PB एम्बेडिंग हो सकते हैं।
- ब्रूट-फ़ोर्स दो तरह से:  
  1. पूरा डेटा एक साथ RAM में लाकर  
  2. डिस्क से पढ़कर, क्वेरी के समय RAM में लोड करके  

  यह 10^6 (एक मिलियन) वेक्टर के लिए ठीक है, मगर 10^12 (एक ट्रिलियन) पर काफ़ी महंगा।
- अगर डिस्क का throughput बहुत तेज़ हो, तो बहुत सारी डिस्क को पैरेलल में जोड़कर ब्रूट-फ़ोर्स किया जा सकता है।  
  10,000 × 8 GB/s की दर वाले 1 TB डिस्क मिलाकर, बैच में क्वेरी ~15 मिनट में सर्च की जा सकती है। लेकिन यह क्लस्टर हार्डवेयर में कम से कम 1 मिलियन डॉलर का होगा।
- आज यह महंगा है, पर संभवत: एक-दो दशकों में सस्ता हो सकता है।

## स्टेट ऑफ द आर्ट (ANN Benchmarks)
ANN (Approximate Nearest Neighbor) बेंचमार्क दिखाते हैं कि ग्राफ आधारित तरीके ज्यामिति आधारित तरीकों से बेहतर हैं।
- मेरा अनुमान है कि यह हाई-डायमेंशनल डेटा में कॉमन है, जहाँ डाटा का क्वांटाइज़ेशन (जैसे 4-बिट, 2-बिट, 1-बिट) सर्च को ज़्यादा प्रभावित नहीं करता।  
- 2D या 3D ज्यामिति वाली अंतर्दृष्टि अक्सर हाई-डायमेंशनल स्पेस में काम नहीं करती।

[पाइनकोन के FAISS पर आर्टिकल](https://www.pinecone.io/learn/series/faiss/composite-indexes/) इंटरनेट पर सबसे अच्छे संसाधन हैं जो मुझे मिले हैं।

## बकेट (Buckets)
- मान लें कि हमारे पास एक ट्रिलियन वेक्टर हैं। अगर हम उन्हें मिलियन (10^6) वेक्टर के छोटे-छोटे बर्तनों में बाँट दें और जल्दी पहचान लें कि क्वेरी का मिलान किस बकेट में हो सकता है, तो हम बस उन बकेट में ब्रूट-फ़ोर्स कर सकते हैं।
- बकेट के अंदर खोज को कुछ मिलीसेकंड कम करने के लिए अगर बहुत ज़्यादा अतिरिक्त जटिलता आती है, तो वह हर प्रोजेक्ट के लिए ज़रूरी नहीं।
- इंडेक्स (Index) बहुत अधिक मेमोरी न खाए, इस पर ध्यान देना चाहिए।  
  - जैसे LSH में, हर वेक्टर के साथ 24-बिट का सिग्नेचर (लगभग 3 बाइट) स्टोर करते हैं।  
  - HNSW में, हर वेक्टर के साथ कम से कम 10 पड़ोसियों के इंडेक्स स्टोर होते हैं, यानी ~100 बाइट प्रति वेक्टर।
- अगर आप बकेट अप्रोच अपनाते हैं, तो सभी वेक्टर को एक शफ़ल्ड ऑर्डर में स्टोर करने के लिए उनके इंडेक्स भी रखने पड़ सकते हैं। 10^12 वेक्टर के लिए लगभग 5 बाइट/वेक्टर लग सकते हैं। या आप बिना किसी नंबरिंग के सीधे कच्चे वेक्टर (raw vectors) शफ़ल्ड ऑर्डर में रख दें, जिससे अतिरिक्त जगह की ज़रूरत कम हो जाती है।

मैंने अभी तक ऐसा कोई स्टेट ऑफ द आर्ट एल्गोरिथ्म नहीं देखा है जो इन सब बातों को पूरी तरह से हल कर दे। अभी तो बस मैं अपने कुछ विचार बाँट रहा हूँ।