जाओ मिल्वस समान खोज

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

इस विषय में बताया गया है कि Milvus में संप्रेषिता खोज कैसे की जाती है।

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

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

संग्रह लोड करें

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

err := milvusClient.LoadCollection(
  context.Background(),   // ctx
  "book",                 // CollectionName
  false                   // async
)
if err != nil {
  log.Fatal("failed to load collection:", err.Error())
}

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

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

sp, _ := entity.NewIndexIvfFlatSearchParam( // NewIndex*SearchParam func
    10,                                  // searchParam
)

opt := client.SearchQueryOptionFunc(func(option *client.SearchQueryOption) {
    option.Limit = 3
    option.Offset = 0
    option.ConsistencyLevel = entity.ClStrong
    option.IgnoreGrowing = false
})

वेक्टर खोज करें

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

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

searchResult, err := milvusClient.Search(
    context.Background(),                    // ctx
    "book",                                  // CollectionName
    []string{},                              // partitionNames
    "",                                      // expr
    []string{"book_id"},                     // outputFields
    []entity.Vector{entity.FloatVector([]float32{0.1, 0.2})}, // vectors
    "book_intro",                            // vectorField
    entity.L2,                               // metricType
    10,                                      // topK
    sp,                                      // sp
    opt,
)
if err != nil {
    log.Fatal("Failed to search collection:", err.Error())
}

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

fmt.Printf("%#v\n", searchResult)
for _, sr := range searchResult {
    fmt.Println(sr.IDs)
    fmt.Println(sr.Scores)
}

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

err := milvusClient.ReleaseCollection(
    context.Background(),                            // ctx
    "book",                                          // CollectionName
)
if err != nil {
    log.Fatal("Failed to release collection:", err.Error())
}

सीमाएँ

मिश्रित खोज करना

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

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

sp, _ := entity.NewIndexFlatSearchParam(
  10,
)

opt := client.SearchQueryOptionFunc(func(option *client.SearchQueryOption) {
    option.Limit = 3
    option.Offset = 0
    option.ConsistencyLevel = entity.ClStrong
    option.IgnoreGrowing = false
})

searchResult, err := milvusClient.Search(
  context.Background(),
  "book",
  []string{},
  "word_count <= 11000",
  []string{"book_id"},
  []entity.Vector{entity.FloatVector([]float32{0.1, 0.2})},
  "book_intro",
  entity.L2,
  2,
  sp,
  opt,
)

if err != nil {
  log.Fatal("Failed to search collection:", err.Error())
}

वापस आए रिजल्ट्स की जाँच करें।

fmt.Printf("%#v\n", searchResult)
for _, sr := range searchResult {
  fmt.Println(sr.IDs)
  fmt.Println(sr.Scores)
}