आयाम और Dimensionality का अभिशाप

सब कुछ बराबर दूर हो जाता है

ज़्यादा आयाम मॉडल को ज़्यादा बारीकी रखने देते हैं, पर ज़्यादा memory और खोज समय भी लेते हैं (भंडारण vectors × आयाम × प्रति संख्या bytes है)। बहुत ऊँचे आयामों में कच्ची दूरियाँ सिकुड़ती भी हैं: query के निकटतम और दूरतम बिंदु लगभग बराबर दूर हो जाते हैं, इसलिए random डेटा के लिए सीधी दूरी कम विभेदक बनती है। असली embeddings random नहीं होते, क्योंकि सार्थक डेटा कम-आयामी संरचना पर रहता है, इसीलिए व्यवहार में 384 से 1536 आयाम अच्छा काम करते हैं। व्यावहारिक सबक: ज़्यादा आयाम अपने आप बेहतर नहीं; छोटे मॉडल या आयाम-घटाए vectors परखें; कुछ आधुनिक मॉडल मामूली गुणवत्ता हानि के साथ कम आयामों तक काटना (truncate) समर्थित करते हैं (दस्तावेज़ देखें); और हमेशा अपने डेटा पर retrieval गुणवत्ता मापें।

दूरी का सिकुड़ना, चलाकर

मैंने यह Python virtual environment में numpy 2.5.3, scikit-learn 1.9.1 और faiss-cpu 1.15.1 के साथ चलाया, निश्चित random seeds के साथ ताकि संख्याएँ दोहराई जाएँ। 2,000 random बिंदुओं के लिए निकटतम और दूरतम दूरी का अनुपात 2 आयामों में 0.004 से 10,000 आयामों में 0.965 तक बढ़ता है: ऊँचे आयामों में random बिंदु लगभग सब बराबर दूर होते हैं। यह random डेटा का गुण है, प्रशिक्षित embeddings का नहीं।

import numpy as np
rng = np.random.default_rng(0)
print("dims | nearest vs farthest distance ratio (1.0 means everything is equally far)")
for d in (2, 10, 100, 1000, 10000):
    X = rng.uniform(size=(2000, d)); q = rng.uniform(size=d)
    dist = np.linalg.norm(X - q, axis=1)
    print(f"{d:5d} | {dist.min() / dist.max():.3f}")

Output:

dims | nearest vs farthest distance ratio (1.0 means everything is equally far)
    2 | 0.004
   10 | 0.253
  100 | 0.665
 1000 | 0.894
10000 | 0.965

भंडारण अंकगणित, चलाकर

मैंने यह Python virtual environment में numpy 2.5.3, scikit-learn 1.9.1 और faiss-cpu 1.15.1 के साथ चलाया, निश्चित random seeds के साथ ताकि संख्याएँ दोहराई जाएँ। दस लाख 768-आयाम float32 vectors 3.1 GB लेते हैं; दस करोड़ 307 GB। आयाम आधे करने से आकार आधा होता है, और संख्याएँ float16 या int8 में रखने से 2 या 4 गुना घटता है।

def gb(n_vectors, dims, bytes_per): return n_vectors * dims * bytes_per / 1e9

for n in (1_000_000, 100_000_000):
    print(f"{n:>11,} vectors x 768 dims: float32 {gb(n,768,4):8.1f} GB | float16 {gb(n,768,2):8.1f} GB | int8 {gb(n,768,1):7.1f} GB | 384 dims float32 {gb(n,384,4):8.1f} GB")

Output:

  1,000,000 vectors x 768 dims: float32      3.1 GB | float16      1.5 GB | int8     0.8 GB | 384 dims float32      1.5 GB
100,000,000 vectors x 768 dims: float32    307.2 GB | float16    153.6 GB | int8    76.8 GB | 384 dims float32    153.6 GB

आयाम घटाना: पहले परखें

सिर्फ़ उसके लिए प्रशिक्षित मॉडल पहले N आयाम रखने पर गुणवत्ता बनाए रखते हैं। पहले और बाद recall मापें।

त्वरित जाँच: क्या ऊँचे आयाम वाला embedding model हमेशा बेहतर होता है?

• हाँ, हमेशा
• नहीं: यह ज़्यादा भंडारण और समय लेता है, इसलिए अपने डेटा पर परखें
• सिर्फ़ मुफ़्त हो तो
• आयाम कभी मायने नहीं रखते