Python Milvus Similarity Search

वेक्टर समानता खोज का प्रदर्शन

इस विषय में यह बताया गया है कि कैसे Milvus का उपयोग इकाइयों को खोजने के लिए किया जाता है।

Milvus में, वेक्टर समानता खोज पूछताछ करता है कि पूछताछ वेक्टर और संग्रह में वेक्टरों के बीच दूरी की गणना करता है (एक निर्दिष्ट समानता माप का उपयोग करके) और सबसे समान परिणाम लौटाता है। आप स्केलर या प्राथमिक कुंजी फ़ील्ड को फ़िल्टर करने के लिए बूलियन अभिव्यक्ति निर्दिष्ट करके मिश्रित खोज को निष्पादित कर सकते हैं।

निम्नलिखित उदाहरण में उस संदर्भ में दिखाया गया है कि डेटा सेट पर वेक्टर समानता खोज कैसे की जाए, जिसमें 2000 पंक्तियाँ होती हैं, जिसमें बुक आईडी (प्राथमिक कुंजी), शब्द गणना (स्केलर फ़ील्ड), और बुक संक्षेप (वेक्टर फ़ील्ड) शामिल है। इससे बुक के वेक्टरीकृत विवरणों के आधार पर विशिष्ट पुस्तकों की खोज को अनुकृत करने का अनुकरण किया जा सकता है। Milvus आपको पूछताछ वेक्टर और आपकी परिभाषित खोज पैरामीटरों के आधार पर सबसे समान परिणाम वापस करेगा।

संग्रह लोड करना

Milvus के भीतर सभी खोज और पूछताछ क्रियाएँ मेमोरी में की जाती हैं। वेक्टर समानता खोज करने से पहले, संग्रह को मेमोरी में लोड करें।

from pymilvus import Collection
collection = Collection("book")      # मौजूदा संग्रह प्राप्त करें।
collection.load()

खोज पैरामीटर तैयार करना

अपने खोज परिदृश्य के लिए संबंधित पैरामीटर तैयार करें। निम्नलिखित उदाहरण में उन पैरामीटरों को परिभाषित किया गया है जो खोज का उपयोग करेंगे दूरी की गणना करने के लिए और IVF_FLAT इंडेक्स द्वारा निर्मित दस सबसे निकटतम क्लस्टर से वेक्टर हासिल करने के लिए।

search_params = {
    "metric_type": "L2",
    "offset": 5,
    "ignore_growing": False,
    "params": {"nprobe": 10}
}

वेक्टर खोज करना

Milvus का उपयोग वेक्टर खोज के लिए करें। किसी विशिष्ट विभाजन के भीतर खोज करने के लिए, विभाजनों की सूची निर्दिष्ट करें।

मिल्वस खोजों के लिए एक सहगतता स्तर सेट करने का समर्थन करता है। इस विषय में दिए गए उदाहरण में, सहगतता स्तर को "मजबूत" पर सेट किया गया है। आप इसे "सीमित", "सत्र", या "आखिरकार" पर सेट कर सकते हैं। मिल्वस में चार सहगतता स्तरों पर अधिक जानकारी के लिए, सहगतता देखें।

results = collection.search(
    data=[[0.1, 0.2]], 
    anns_field="book_intro", 
    param=search_params,
    limit=10,
    expr=None,
    output_fields=['title'],
    consistency_level="Strong"
)

results[0].ids

results[0].distances

hit = results[0][0]
hit.entity.get('title')

सबसे समान वेक्टरों के प्राथमिक कुंजी मानों और दूरियाँ जांचें।

results[0].ids
results[0].distances

जब खोज पूर्ण हो जाए, तो मिल्वस में लोड किए गए संग्रह को मेमोरी खपत को कम करने के लिए रिलीज़ करें।

collection.release()

सीमाएं

विविध खोज करना

विविध खोज मूल रूप से वेक्टर खोज के साथ विशेषता फ़िल्टरिंग है। किसी बूलियन अभिव्यक्ति को निर्दिष्ट करके खोजों को विशेष स्थितियों के तहत सीमित किया जा सकता है।

निम्नलिखित उदाहरण में दिखाया गया है कि कैसे नियमित वेक्टर खोज पर विविध खोज करते हैं। मान लीजिए आप वर्णनों की वेक्टरीकरण पर आधारित कुछ पुस्तक खोजना चाहते हैं, लेकिन आपको केवल विशिष्ट शब्द संख्या सीमा के भीतर खोजना है। फिर आप खोज पैरामीटर में एक बूलियन अभिव्यक्ति निर्दिष्ट करके शब्द काउंट क्षेत्र को फिल्टर कर सकते हैं। मिल्वस केवल समान वेक्टर्स के लिए खोजेगा जो कि अभिव्यक्ति के साथ मेल खाती हैं।

एक बूलियन अभिव्यक्ति निर्दिष्ट करके, आप वेक्टर खोज के दौरान पदार्थी क्षेत्रों को छान सकते हैं। निम्नलिखित उदाहरण में, खोज दायरे को निर्दिष्ट शब्द काउंट मान सीमा के भीतर सीमित करता है।

फ़िल्टरिंग अभिव्यक्ति में डायनामिक क्षेत्रों और खोज अनुरोध में आउटपुट क्षेत्रों का उपयोग भी किया जा सकता है। उदाहरण के लिए, डायनामिक पैटर्न का हवाला दें।

search_param = {
  "data": [[0.1, 0.2]],
  "anns_field": "book_intro",
  "param": {"metric_type": "L2", "params": {"nprobe": 10}, "offset": 0},
  "limit": 10,
  "expr": "word_count <= 11000",
}
res = collection.search(**search_param)

वापसी परिणामों की जांच करें।

assert len(res) == 1
hits = res[0]
assert len(hits) == 2
print(f"- कुल हिट: {len(hits)}, हिट आईडी: {hits.ids} ")
print(f"- शीर्ष1 हिट आईडी: {hits[0].id}, दूरी: {hits[0].distance}, स्कोर: {hits[0].score} ")

सीमा खोज करना

सीमा खोज एक तरीका है जिसमें क्वेरी वेक्टर और वेक्टर क्षेत्र मानों के बीच की दूरी के आधार पर खोज परिणामों को फ़िल्टर करने का तरीका है। दूरी मेट्रिक्स को मापने के लिए विभिन्न दूरी मेट्रिक्स का उपयोग किया जा सकता है।

सीमा खोज के दौरान, मिल्वस सबसे पहले वेक्टर समानता खोज करता है। फिर, यह निर्दिष्ट दूरी शर्तों के आधार पर वेक्टर फ़िल्टरिंग करता है और उन वेक्टरों को लौटता है जिनकी दूरी एक विशिष्ट दायरे के भीतर आती है।

निम्नलिखित उदाहरण में, नियमित वेक्टर खोज पर आधारित सीमा खोज कैसे करें, इसका दिखावा किया गया है।

संग्रह लोड करना

मिलवस में सभी खोज और प्रश्न आपरेशन मेमोरी में निष्पादित किए जाते हैं। वेक्टर समानता खोज करने से पहले, संग्रह को याद में लोड किया जाना चाहिए।

from pymilvus import Collection
collection = Collection("book")      # मौजूदा संग्रह प्राप्त करें
collection.load()

वेक्टर फ़िल्टरिंग रेंज कॉन्फ़िगर करना

मिलवस में रेगुलर वेक्टर खोज के मुकाबले, रेंज खोज को विशेष खोज रेंज के भीतर चाहे आनुवादित करना होता है। इसके लिए radius और range_filter नामक दो नए पैरामीटर विशिष्ट खोज रेंज के भीतर वांछित खोज परिणाम प्राप्त करने के लिए नियंत्रित करते हैं।

radius ने शब्दों में सटीकता से इस बात का पता लगाने के लिए निर्धारित करता है कि क्या वेक्टर्स समान माने जाएं। एक वैकल्पिक range_filter को radius के साथ जोड़ा जा सकता है जो विशिष्ट रेंज के भीतर प्रश्न वेक्टर की तुलना में वेक्टर फ़ील्ड मानों को फ़िल्टर करने के लिए प्रयोग किया जा सकता है। radius और range_filter दोनों पैरामीटर FLOAT डेटा प्रकार होते हैं। इन दोनों पैरामीटरों को सेट करके खोज की सटीकता और कुशलता को प्रभावी रूप से संतुलित किया जा सकता है।

सामान्यत: समानता वेक्टर फ़ील्ड मान और प्रश्न वेक्टर के बीच की दूरी द्वारा मापी जाती है। विभिन्न दूरी मेट्रिक का चयन radius और range_filter के कॉन्फ़िगरेशन पर प्रभाव डालेगा।

उदाहरण के लिए, L2 दूरी के मामले में, खोज परिणामों को radius से कम दूरी वाले वेक्टर फ़ील्ड मानों पर फ़िल्टर किया जाना चाहिए। इसलिए L2 दूरी में, छोटी दूरियां अधिक समानता को दिखाती हैं। इस जानकारी को ध्यान में रखते हुए, अगर आप कुछ सबसे समान वेक्टर्स को फ़िल्टर करना चाहते हैं, तो आप range_filter मूल्य को radius से कम नियंत्रित कर सकते हैं।

search_params = {
    "metric_type": "L2",
    "params": {
        "radius": 10.0,
        "range_filter" : 5.0
    }
}

IP दूरी के मामले में, स्थिति अलग है। IP दूरी के साथ, अधिक दूरी अधिक समानता का संकेत देती है। इसलिए, L2 दूरी के विपरीत, IP दूरी में radius और range_filter के मान उल्टे होते हैं। अन्य शब्दों में, IP दूरी के आधार पर कुछ सबसे समान वेक्टर्स को फ़िल्टर करना चाहते हैं, तो प्रभावी range_filter मान radius से अधिक होना चाहिए, और परिणामी वेक्टर्स की दूरी radius से अधिक लेकिन range_filter से कम या बराबर होनी चाहिए।

search_params = {
    "metric_type": "IP",
    "params": {
        "radius": 0.8,
        "range_filter" : 1.0
    }
}

रेंज खोज का प्रदर्शन

दूरी मापन प्रकार के आधार पर radius और range_filter को निर्धारित करके आप परिणाम वेक्टर्स की रेंज को परत किया जा सकता है।

L2 दूरी परिणामों के भीतर 5.0 और 10.0 के बीच समानता पर रेंज खोज करें:

search_param = {
  "data": [[0.1, 0.2]], # प्रश्न वेक्टर
  "anns_field": "book_intro", # खोज के लिए फ़ील्ड
  "param": { "metric_type": "L2", "params": { "nprobe": 10, "radius": 10.0, "range_filter" : 5.0 }, "offset": 0 },
  "limit": 2,
  "output_fields": ["int64", "float"]  # वापस लौटाई जाने वाली फ़ील्डें
}

res = collection.search(**search_param)

IP दूरी परिणामों के भीतर 1.0 और 0.8 के बीच समानता पर रेंज खोज करें:

search_param = {
  "data": [[0.1, 0.2]], # प्रश्न वेक्टर
  "anns_field": "book_intro", # खोज के लिए फ़ील्ड
  "param": {"metric_type": "IP", "params": { "nprobe": 10, "radius": 0.8, "range_filter" : 1.0 }, "offset": 0 },
  "limit": 2,
  "output_fields": ["int64", "float"]  # वापस लौटाई जाने वाली फ़ील्डें
}

res = collection.search(**search_param)

सारांश

मिलवस में, रेंज खोज विशिष्ट दूरी रेंज के भीतर समान वेक्टर परिणाम वापस कर सकती है। इस सुविधा को खोज पैरामीटर में radius और range_filter की निर्देशित करके सक्रिय किया जाता है। निम्नलिखित तालिका इन दोनों पैरामीटरों के कॉन्फ़िगरेशन को विभिन्न दूरी मापन प्रकारों के लिए संक्षेपित करता है।