การค้นหาราการคล้ายคลึงของเวกเตอร์

หัวข้อนี้จะช่วยแนะนำวิธีการทำการค้นหา entity ใน Milvus

การค้นหาราการคล้ายคลึงของเวกเตอร์ใน Milvus คำนวณระยะห่างระหว่างเวกเตอร์คิวรีและเวกเตอร์ในคอลเลกชัน และคืนผลลัพธ์ที่คล้ายคลึงที่สุด คุณยังสามารถทำการค้นหาแบบผสมได้โดยระบุนิพจน์ boolean เพื่อกรองฟิลด์ที่เป็นสเกล่าหรือฟิลด์คีย์หลัก

ตัวอย่างต่อไปนี้โปรแกรมแสดงวิธีการทำการค้นหาราการคล้ายคลึงของเวกเตอร์บนชุดข้อมูลที่มี 2000 แถว ประกอบด้วย book IDs (คีย์หลัก) word frequency (ฟิลด์สเกล่า) และ book descriptions (ฟิลด์เวกเตอร์) นี้จำลองฉากการค้นหาหนังสือที่เฉพาะเจาะจงโดยใช้รายละเอียดที่ถูกเวกเตอร์ไว้ Milvus จะคืนผลลัพธ์ที่คล้ายคลึงที่สุดตามเวกเตอร์คิวรีที่กำหนดและพารามิเตอร์การค้นหา

โหลดคอลเลกชัน

ก่อนการทำการค้นหาราการคล้ายคลึงของเวกเตอร์ Milvus จะดำเนินการทุกการค้นหาและคิวรีในหน่วยความจำ โปรดโหลดคอลเลกชันเข้าสู่หน่วยความจำก่อนทำการค้นหาอย่างเห็นผล

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

เตรียมพารามิเตอร์การค้นหา

เตรียมพารามิเตอร์ที่เหมาะสมสำหรับสถานการณ์การค้นหาของคุณ ตัวอย่างต่อไปนี้กำหนดการใช้ระยะห่าง Euclidean เพื่อคำนวณระยะทางและการเรียกดึงเวกเตอร์จากคลัสเตอร์ที่ใกล้ที่สุดสิบตัวที่สร้างขึ้นโดยดัชนี 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
})
พารามิเตอร์ คำอธิบาย ตัวเลือก
NewIndex*SearchParam func ฟังก์ชันในการสร้าง entity.SearchParam โดยอิงจากประเภทดัชนีต่าง ๆ For Float Vectors: - NewIndexFlatSearchParam() (FLAT) - NewIndexIvfFlatSearchParam(nprobe int) (IVF_FLAT) - NewIndexIvfSQ8SearchParam(nprobe int) (IVF_SQ8) - NewIndexIvfPQSearchParam(nprobe int) (RNSG) - NewIndexHNSWSearchParam(ef int) (HNSW) For Binary Vectors: - NewIndexBinFlatSearchParam(nprobe int) (BIN_FLAT) - NewIndexBinIvfFlatSearchParam(nprobe int) (BIN_IVF_FLAT)
sp พารามิเตอร์การค้นหาที่เฉพาะเจาะของดัชนีที่ส่งคืนโดยฟังก์ชันก่อนหน้า ดูเพิ่มเติมได้ที่ Vector Index
opt ตัวเลือกสำหรับการค้นหา ANN - Limit: ระบุจำนวน entities ที่ต้องการคืน - Offset: ระบุจำนวน entities ที่ต้องการข้ามในการค้นหา จำนวนนี้บวรจะน้อยกว่า 16384 ตัวอย่างเช่น ถ้าคุณต้องการคิวรี entites ที่ 9 และ 10 ที่ใกล้ที่สุดของเวกเตอร์ ตั้งค่า Limit เป็น 2 และ Offset เป็น 8 - ConsistencyLevel: ระบุระดับความสอดคล้องที่นำไปใช้ในการค้นหา - Ignore Growing: บ่งบอกว่าจะไม่สนใจการเพิ่มเซ็กเมนต์ในการค้นหาความคล้ายคลึง ค่าเริ่มต้นคือ False หมายความว่าการค้นหาเกี่ยวข้องกับเซ็กเมนต์ที่เพิ่มขึ้น

การทำค้นหาเวกเตอร์

ทำการค้นหาเวกเตอร์โดยใช้ Milvus สำหรับการค้นหาในพาร์ติชันที่กำหนดโปรดระบุรายชื่อของพาร์ติชัน

Milvus สนับสนุนการตั้งค่าระดับความสอดคล้องสำหรับการค้นหา ตัวอย่างในหัวข้อนี้ตั้งค่าระดับความสอดคล้องเป็น แข็ง คุณยังสามารถตั้งค่าระดับความสอดคล้องเป็น ถูกครบถูกว่า เซสชั่น หรือ จนกระทั่ง สำหรับข้อมูลเพิ่มเติมเกี่ยวกับระดับความสอดคล้องสี่ระดับใน Milvus ดูที่ 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("การค้นหาคอลเลคชันล้มเหลว:", err.Error())
}
พารามิเตอร์ คำอธิบาย ตัวเลือก
ctx สิ่งที่ใช้ควบคุมกระบวนการเรียกรูปแบบ API ไม่มี
CollectionName ชื่อคอลเลคชันที่จะโหลด ไม่มี
partitionNames รายชื่อชื่อพาร์ติชันที่จะโหลด หากว่างเปล่า ค้นหาทุกพาร์ติชัน ไม่มี
expr สมการตรรกะสำหรับการกรองคุณสมบัติ ดูกฎสมการตรรกะเพื่อข้อมูลที่เพิ่มเติม
output_fields ชื่อของฟิลด์ที่ต้องการที่จะคืน ไม่มี
vectors เวกเตอร์ที่ต้องการค้นหา ไม่มี
vectorField ชื่อของฟิลด์ที่ต้องการค้นหา ไม่มี
metricType ประเภทเมตริกที่ใช้สำหรับการค้นหา พารามิเตอร์นี้ต้องเหมือนกับประเภทเมตริกที่ใช้สำหรับการสร้างดัชนี
topK จำนวนผลที่ต้องการคืน ผลรวมของค่านี้และ offset ใน opts ควรน้อยกว่า 16384 ไม่มี
sp entity.SearchParam ที่เฉพาะเจาะจงสำหรับดัชนี ไม่มี

ตรวจสอบค่าหลักและระยะทางของเวกเตอร์ที่คล้ายกันที่สุด

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

หลังจากค้นหาเสร็จสิ้น ปล่อยคอลเลคชันที่โหลดใน Milvus เพื่อลดการใช้หน่วยความจำ

err := milvusClient.ReleaseCollection(
    context.Background(),                            // ctx
    "book",                                          // CollectionName
)
if err != nil {
    log.Fatal("การปล่อยคอลเลคชันล้มเหลว:", err.Error())
}

ข้อจำกัด

คุณสมบัติ ขีดจำกัดสูงสุด
ความยาวของชื่อคอลเลคชัน 255 ตัวอักษร
จำนวนพาร์ติชันในคอลเลคชัน 4,096
จำนวนฟิลด์ในคอลเลคชัน 256
จำนวนชาร์ดในคอลเลคชัน 256
ขนาดของเวกเตอร์ 32,768
Top K 16,384
จำนวนเวกเตอร์ที่ต้องการค้นหา 16,384

การทำค้นหาผสม

ค้นหาผสมเป็นพื้นฐานที่สำคัญของค้นหาเวกเตอร์พร้อมกับการกรองแอตทริบิวต์ โดยระบุสมการตรรกะเพื่อการกรองฟิลด์สกาลาร์หรือฟิลด์คีย์หลัก คุณสามารถ จำกัดการค้นหาตามเงื่อนไขที่เฉพาะเจาะจง

ตัวอย่างต่อไปนี้จะแสดงวิธีการทำการค้นหาผสมโดยอ้างอิงจากค้นหาเวกเตอร์ปกติ สมมติว่าคุณต้องการค้นหาหนังสือที่เฉพาะเจาะจงที่มีการนำเสนอของหนังสือเข้าสู่เวกเตอร์ แต่เพียงเพียงต้องการดึงข้อมูลหนังสือที่อยู่ในช่วงคำสั่งเฉพาะเจาะจง คุณสามารถกรองฟิลด์ word_count โดยระบุสมการตรรกะในพารามิเตอร์การค้นหา Milvus จะค้นหาเพียงเวกเตอร์ที่คล้ายกันภายในองค์กรที่ตรงตามสมการตรรกะ

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("การค้นหาคอลเลคชันล้มเหลว:", err.Error())
}

ตรวจสอบผลลัพธ์ที่ได้

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