Pengelompokan Hasil Pencarian dengan StructArray

Gunakan halaman ini untuk mengelompokkan hasil pencarian tingkat elemen StructArray berdasarkan entitas induknya. Pencarian tingkat elemen dapat menghasilkan beberapa hasil dari entitas yang sama jika beberapa elemen Struct cocok dengan kueri. Pengelompokan ini menggabungkan hasil-hasil elemen tersebut sehingga setiap entitas induk muncul paling banyak satu kali.

Halaman ini menggunakan koleksi tech_articles dari Buat Bidang StructArray. Koleksi tersebut memiliki bidang StructArray bernama chunks. Subbidang vektor chunks[emb] diindeks untuk pencarian tingkat elemen dengan metrik vektor reguler.

Bagaimana pengelompokan diterapkan pada StructArray

Mode pencarian	Perilaku pengelompokan	Perilaku hasil
Pencarian EmbeddingList	Tidak didukung.	Tidak berlaku.
Pencarian tingkat elemen	Didukung dengan pengelompokan berdasarkan kunci utama.	Mengembalikan paling banyak satu hasil per entitas induk. Metadata tingkat elemen dipertahankan, sehingga indeks atau offset elemen yang dipilih dapat dikembalikan saat diekspos oleh API atau SDK.
Pencarian hibrida	Didukung hanya jika semua pencarian anak menargetkan bidang vektor tingkat elemen di bawah bidang StructArray yang sama.	Pencarian sub-tingkat elemen dikelompokkan berdasarkan kunci utama sebelum penanganan hasil akhir.

Sebelum Anda memulai

Siapkan koleksi, data, dan indeks sebelum menjalankan pencarian pengelompokan.

Persyaratan	Rincian
Subbidang vektor tingkat elemen	Gunakan subbidang vektor StructArray seperti chunks[emb], yang diindeks dengan metrik vektor biasa.
Kueri vektor biasa	Gunakan vektor kueri biasa, bukan EmbeddingList.
Pengelompokan berdasarkan kunci utama	Gunakan kunci utama koleksi sebagai group_by_field, seperti doc_id.
Tanpa parameter rentang	Jangan menggabungkan pencarian pengelompokan dengan parameter pencarian rentang seperti radius atau range_filter.

Untuk pengaturan indeks, lihat Bidang StructArray Indeks.

Jalankan pencarian tingkat elemen yang dikelompokkan

Contoh berikut ini terlebih dahulu mencari potongan-potongan individual, kemudian mengelompokkan hasil elemen berdasarkan kunci utama entitas induk.

from pymilvus import MilvusClient

client = MilvusClient(
    uri="http://localhost:19530",
    token="root:Milvus",
)

query_vector = [0.19, 0.24, 0.30, 0.37]

results = client.search(
    collection_name="tech_articles",
    data=[query_vector],
    anns_field="chunks[emb]",
    limit=5,
    group_by_field="doc_id",
    output_fields=[
        "doc_id",
        "title",
        "chunks[text]",
        "chunks[section]",
        "chunks[page]",
        "chunks[quality_score]",
    ],
)

for hits in results:
    for hit in hits:
        print(
            "doc_id:", hit["id"],
            "distance:", hit["distance"],
            "offset:", hit.get("offset"),
            "entity:", hit["entity"],
        )

Tanpa pengelompokan, doc_id yang sama dapat muncul beberapa kali jika beberapa chunk cocok dengan kueri. Dengan group_by_field="doc_id", setiap entitas induk muncul paling banyak sekali. Pengelompokan mempertahankan metadata tingkat elemen, sehingga hasil yang dikelompokkan masih dapat menyertakan indeks atau offset elemen Struct yang dipilih saat API atau SDK menampilkannya.

Tambahkan filter skalar

Anda dapat menggabungkan pencarian pengelompokan dengan penyaringan skalar StructArray. Gunakan ` element_filter ` ketika kondisi skalar harus membatasi elemen Struct mana yang berpartisipasi dalam pencarian vektor tingkat elemen.

filter_expr = (
    'category == "search" && '
    'element_filter(chunks, '
    '$[section] == "index" && '
    '$[quality_score] > 0.9)'
)

results = client.search(
    collection_name="tech_articles",
    data=[query_vector],
    anns_field="chunks[emb]",
    filter=filter_expr,
    limit=5,
    group_by_field="doc_id",
    output_fields=[
        "doc_id",
        "title",
        "category",
        "chunks[text]",
        "chunks[section]",
        "chunks[quality_score]",
    ],
)

Predikat tingkat atas memilih entitas kandidat. Predikat ` element_filter ` membatasi pencarian vektor tingkat elemen hanya pada elemen Struct yang cocok. Pengelompokan kemudian menggabungkan hasil elemen yang cocok berdasarkan kunci utama.

Gunakan pengelompokan dalam pencarian hibrida

Pengelompokan hibrida dengan StructArray merupakan fitur tingkat elemen. Fitur ini hanya didukung jika semua sub-pencarian menargetkan bidang vektor tingkat elemen di bawah bidang StructArray yang sama. Jangan gunakan permintaan tingkat EmbeddingList dalam pencarian hibrida StructArray yang dikelompokkan.

Contoh berikut mengasumsikan bahwa bidang StructArray ` chunks ` memiliki dua subbidang vektor tingkat elemen, ` chunks[emb] ` dan ` chunks[code_emb]`, dan keduanya diindeks dengan metrik vektor reguler.

from pymilvus import AnnSearchRequest, RRFRanker

index_chunk_req = AnnSearchRequest(
    data=[query_vector],
    anns_field="chunks[emb]",
    limit=10,
    expr='element_filter(chunks, $[section] == "index")',
)

code_chunk_req = AnnSearchRequest(
    data=[code_query_vector],
    anns_field="chunks[code_emb]",
    limit=10,
    expr='element_filter(chunks, $[has_code] == true)',
)

results = client.hybrid_search(
    collection_name="tech_articles",
    reqs=[index_chunk_req, code_chunk_req],
    ranker=RRFRanker(),
    limit=5,
    group_by_field="doc_id",
    output_fields=[
        "doc_id",
        "title",
        "chunks[text]",
        "chunks[section]",
    ],
)

Dalam contoh ini, kedua sub-permintaan menargetkan bidang vektor tingkat elemen di bawah bidang StructArray yang sama, yaitu ` chunks`. Pencarian hibrida tidak mendukung pengelompokan tingkat elemen jika mencampurkan bidang vektor biasa, bidang StructArray yang berbeda, atau permintaan tingkat EmbeddingList.

Menafsirkan hasil yang dikelompokkan

Item hasil	Arti
id	Kunci utama dari entitas induk yang dikelompokkan.
distance atau skor	Skor atau jarak elemen Struct yang dipilih untuk entitas induk tersebut.
offset	Posisi berbasis nol dari elemen Struct yang dipilih saat dikembalikan.
Kunci utama yang berulang	Tidak diharapkan saat pengelompokan berdasarkan kunci utama.
limit	Berlaku untuk hasil entitas induk yang dikelompokkan.

Batasan

• Pencarian pengelompokan hanya berlaku untuk pencarian vektor StructArray tingkat elemen. Pencarian EmbeddingList dan pencarian hibrida tingkat EmbeddingList tidak mendukung pengelompokan.

• Gunakan kunci utama sebagai ` group_by_field`. Pengelompokan tingkat elemen StructArray bukanlah pengelompokan serbaguna berdasarkan bidang skalar sembarang.

• Jangan menggabungkan pencarian pengelompokan dengan pencarian rentang.

• Jangan gunakan kueri ` EmbeddingList ` atau metrik ` MAX_SIM* ` untuk pencarian pengelompokan.

• Pengelompokan hibrida hanya didukung jika semua sub-pencarian menargetkan bidang vektor tingkat elemen di bawah bidang StructArray yang sama.

• Pengelompokan hibrida tidak didukung jika pencarian hibrida mencampurkan bidang vektor normal, bidang StructArray yang berbeda, atau permintaan tingkat EmbeddingList.

Kesalahan umum

• Menggunakan pengelompokan dengan ` chunks[emb_list_vector]`, yang dimaksudkan untuk pencarian `EmbeddingList`.

• Pengelompokan berdasarkan bidang skalar non-kunci utama.

• Pengelompokan berdasarkan beberapa bidang. Pengelompokan StructArray tingkat elemen hanya mendukung pengelompokan berdasarkan kunci utama.

• Mengharapkan hasil yang dikelompokkan mewakili setiap elemen Struct yang cocok. Pengelompokan mengembalikan paling banyak satu hasil per entitas induk.

• Mengasumsikan bahwa pencarian tingkat elemen yang dikelompokkan menghitung ulang skor " MAX_SIM* " bergaya EmbeddingList. Pengelompokan menggabungkan hasil pencocokan tingkat elemen; hal ini tidak mengubah model penilaian.

• Menggabungkan " group_by_field " dengan " radius " atau " range_filter".

Langkah selanjutnya

1. Untuk mempelajari pencarian tingkat elemen tanpa pengelompokan terlebih dahulu, baca " Basic Vector Search with StructArray".

2. Untuk menambahkan filter skalar ke pencarian yang dikelompokkan, baca " Pencarian yang Difilter dengan StructArray".

3. Untuk menggunakan batas skor atau jarak sebagai pengganti pengelompokan, baca " Pencarian Rentang dengan StructArray".

4. Untuk memeriksa batasan pencarian StructArray, baca Batasan StructArray.