Membuat kueri hibrid di Pencarian Azure AI

Pencarian hibrid menggabungkan kueri teks (kata kunci) dan vektor dalam satu permintaan pencarian. Kedua kueri dijalankan secara paralel. Hasilnya digabungkan dan diurutkan ulang oleh skor pencarian baru, menggunakan Reciprocal Rank Fusion (RRF) untuk mengembalikan tataan hasil terpadu. Dalam banyak kasus, sesuai dengan pengujian tolok ukur, kueri hibrid dengan peringkat semantik menyajikan hasil yang paling relevan.

Dalam artikel ini, pelajari cara:

• Menyiapkan permintaan hibrid dasar
• Tambahkan parameter dan filter
• Meningkatkan relevansi menggunakan peringkat semantik atau bobot vektor
• Mengoptimalkan perilaku kueri dengan mengontrol input (maxTextRecallSize)

Pada akhir artikel ini, Anda dapat menjalankan kueri hibrid yang menggabungkan kata kunci dan pencarian vektor dengan peringkat semantik opsional.

Prasyarat

• Langganan Azure. Buat satu secara gratis.

• Layanan Pencarian Azure AI. Buat layanan atau definisikan layanan yang ada.

• Indeks pencarian yang berisi searchable bidang vektor dan nonvektor. Kami merekomendasikan wizard Impor data untuk membuat indeks dengan cepat. Jika tidak, lihat Membuat indeks dan Menambahkan bidang vektor ke indeks pencarian.

• Izin: Anda memerlukan Pembaca Data Indeks Pencarian untuk mengkueri indeks. Untuk membuat atau memperbarui indeks, Anda memerlukan Kontributor Data Indeks Pencarian. Untuk informasi selengkapnya, lihat Menyambungkan menggunakan peran.

• Penginstalan SDK (Opsional):

  • Python: pip install azure-search-documents
  • C#: dotnet add package Azure.Search.Documents

• (Opsional) Jika Anda ingin konversi teks ke vektor bawaan dari string kueri, buat dan tetapkan vektorizer ke bidang vektor dalam indeks pencarian.

Pilih API, alat, dan pola yang dapat digunakan

• Search Explorer di portal Azure (mendukung sintaks pencarian API yang stabil dan pratinjau) memiliki tampilan JSON yang memungkinkan Anda menempelkan permintaan hibrid.

• Paket stabil atau versi pratinjau yang lebih baru dari Azure SDK (lihat catatan perubahan untuk dukungan fitur SDK).

• REST API yang stabil atau versi API pratinjau terbaru jika Anda menggunakan fitur pratinjau seperti maxTextRecallSize dan countAndFacetMode (pratinjau).

  Untuk keterbacaan, kami menggunakan contoh REST untuk menjelaskan cara kerja API. Anda dapat menggunakan klien REST seperti Visual Studio Code dengan ekstensi REST untuk membangun kueri hibrid. Anda juga dapat menggunakan Azure SDK. Untuk informasi selengkapnya, lihat Mulai Cepat: Pencarian vektor.

Pola hibrid yang dapat digunakan

Jika Anda baru menggunakan pencarian hibrid, pilih satu pola dan sesuaikan dalam langkah-langkah kecil. Jangan mulai dengan pengenalan vektor maksimum, pengenalan teks besar, dan reranking semantik dalam permintaan yang sama.

• Hibrid seimbang (default): Gunakan ini terlebih dahulu untuk sebagian besar beban kerja. Mulailah dengan k dalam rentang 30 hingga 50, top dalam rentang 10 hingga 20, dan aktifkan peringkat semantik hanya ketika meningkatkan relevansi terukur.

• Recall-first hybrid: Gunakan ini untuk kueri yang sulit di mana cakupan menjadi tujuan utama. Tingkatkan maxTextRecallSize secara bertahap dan jaga pengaturan vektor tetap moderat. Mengharapkan biaya penggabungan yang lebih tinggi.

• Hibrid prioritas presisi: Gunakan ini untuk latensi rendah pada skala besar. Pertahankan k dan top sederhanakan, terapkan filter selektif, dan hindari fitur semantik yang tidak menambah nilai.

Mengapa kueri yang kelebihan beban mengalami pembatasan

Kueri hibrid menjalankan teks dan pengambilan vektor secara paralel lalu menggabungkan hasil dengan RRF. Jika Anda meningkatkan kontribusi leksikal (misalnya, dengan mengubah pembobotan campuran agar lebih mendukung BM25), Anda akan meningkatkan jumlah kandidat teks yang harus digabungkan dengan kandidat vektor. Jika Anda menggabungkan ini dengan pengaturan vektor yang mahal dan reranking semantik, tekanan CPU dan memori naik dengan cepat.

Pada konfigurasi kapasitas yang lebih kecil, pekerjaan penggabungan dan rerank tambahan ini dapat menyebabkan:

• Latensi yang lebih tinggi dan lonjakan p95/p99
• 429 respons penjatahan
• Permintaan yang gagal atau kedaluwarsa diamati oleh klien ketika perilaku ulang coba tidak dikonfigurasi.

Menyetel urutan sebelum memperluas skala

Sesuaikan pengaturan kueri dan vektor sebelum Anda menambahkan replika:

1. Kurangi pengaturan pencarian vektor yang mahal terlebih dahulu. Misalnya, jika efSearch dan maxConnections diatur secara agresif, turunkan sebelum memperluas skala (misalnya, kurangi efSearch dari sekitar 800 menjadi antara 128 dan 192, dan kurangi maxConnections dari 64 menjadi 32).
2. Batasi cakupan reranking semantik untuk kasus yang bisa mendapatkan manfaat darinya.
3. Uji ulang latensi dan tingkat 429 dengan beban yang representatif.
4. Buat replika berskala hanya jika pembatasan tetap ada setelah penyesuaian.

Gunakan urutan ini untuk meningkatkan stabilitas terlebih dahulu dan mengontrol biaya sebelum Anda menskalakan.

Menyiapkan kueri hibrid

Bagian ini menjelaskan struktur dasar kueri hibrid dan cara menyiapkannya di Search Explorer atau untuk eksekusi di klien REST.

Hasil dikembalikan dalam teks biasa, termasuk vektor dalam bidang yang ditandai sebagai retrievable. Karena vektor numerik tidak berguna dalam hasil pencarian, pilih bidang lain dalam indeks sebagai proksi untuk kecocokan vektor. Misalnya, jika indeks memiliki bidang "descriptionVector" dan "descriptionText", kueri dapat cocok pada "descriptionVector" tetapi hasil pencarian dapat menampilkan "descriptionText". select Gunakan parameter untuk menentukan hanya bidang yang dapat dibaca manusia dalam hasilnya.

POST https://{{search-service-name}}.search.windows.net/indexes/{{index-name}}/docs/search?api-version=2026-04-01
Content-Type: application/json
api-key: {{admin-api-key}}
{
    "vectorQueries": [
        {
            "vector": [
                -0.009154141,
                0.018708462,
                . . . 
                -0.02178128,
                -0.00086512347
            ],
            "fields": "DescriptionVector",
            "kind": "vector",
            "exhaustive": true,
            "k": 10
        },
        {
            "vector": [
                -0.009154141,
                0.018708462,
                . . . 
                -0.02178128,
                -0.00086512347
            ],
            "fields": "DescriptionVector",
            "kind": "vector",
            "exhaustive": true,
            "k": 10
        }
    ],
    "search": "historic hotel walk to restaurants and shopping",
    "select": "HotelName, Description, Address/City",
    "top": 10
}

import os
from azure.identity import DefaultAzureCredential
from azure.search.documents import SearchClient
from azure.search.documents.models import VectorizedQuery

# Set up the client
endpoint = os.environ["AZURE_SEARCH_ENDPOINT"]
index_name = "hotels-sample"
credential = DefaultAzureCredential()

client = SearchClient(endpoint=endpoint, index_name=index_name, credential=credential)

# Define your vector (typically from an embedding model)
query_vector = [-0.009154141, 0.018708462, ...]  # Your embedding values

# Create the vector query
vector_query = VectorizedQuery(
    vector=query_vector,
    k_nearest_neighbors=10,
    fields="DescriptionVector",
    exhaustive=True
)

# Execute hybrid search
results = client.search(
    search_text="historic hotel walk to restaurants and shopping",
    vector_queries=[vector_query],
    select=["HotelName", "Description", "Address/City"],
    top=10
)

for result in results:
    print(f"{result['HotelName']}: {result['Description']}")

using Azure;
using Azure.Identity;
using Azure.Search.Documents;
using Azure.Search.Documents.Models;

// Set up the client
string endpoint = Environment.GetEnvironmentVariable("AZURE_SEARCH_ENDPOINT");
string indexName = "hotels-sample";

SearchClient client = new SearchClient(
    new Uri(endpoint),
    indexName,
    new DefaultAzureCredential());

// Define your vector (typically from an embedding model)
float[] queryVector = new float[] { -0.009154141f, 0.018708462f, /* ... */ };

// Execute hybrid search
SearchResults<SearchDocument> results = client.Search<SearchDocument>(
    "historic hotel walk to restaurants and shopping",
    new SearchOptions
    {
        VectorSearch = new()
        {
            Queries = {
                new VectorizedQuery(queryVector)
                {
                    KNearestNeighborsCount = 10,
                    Fields = { "DescriptionVector" },
                    Exhaustive = true
                }
            }
        },
        Select = { "HotelName", "Description", "Address/City" },
        Size = 10
    });

await foreach (SearchResult<SearchDocument> result in results.GetResultsAsync())
{
    Console.WriteLine($"{result.Document["HotelName"]}: {result.Document["Description"]}");
}

Mengatur maxTextRecallSize dan countAndFacetMode (pratinjau)

Kueri hibrid dapat disetel untuk mengontrol berapa banyak dari setiap subkueri yang berkontribusi pada hasil gabungan. maxTextRecallSize Mengatur parameter (pratinjau) menentukan berapa banyak hasil berperingkat BM25 yang diteruskan ke model peringkat hibrid.

Jika permintaan Anda menyertakan faset, gunakan bidang nonvektor yang ditandai sebagai facetable dalam indeks. Bidang vektor tidak dapat difaset.

Jumlah faset bergantung pada jenis kueri:

• Pada kueri yang hanya berisi teks, faset menghitung dokumen yang sesuai dengan kueri teks.
• Dalam kueri yang hanya menggunakan vektor, faset menghitung jumlah dokumen k yang dikembalikan oleh kueri vektor.
• Dalam kueri hibrid, faset memperhitungkan hasil vektor dan teks. Bagian vektor menyumbang dokumen k terdekat. Bagian teks menyumbangkan dokumen yang diperingkat dengan BM25. Parameter countAndFacetMode (pratinjau) menentukan apakah perhitungan jumlah dan faset menggunakan semua kecocokan teks atau hanya kecocokan teks yang diambil untuk pemeringkatan.

Jika Anda menggunakan maxTextRecallSize, Anda mungkin juga ingin mengatur countAndFacetMode. Parameter ini menentukan apakah count dan facets menyertakan semua dokumen yang cocok dengan kueri teks, atau hanya dokumen yang diambil dalam maxTextRecallSize jendela. Nilai defaultnya adalah countAllResults.

Dengan mode default countAllResults, hitungan dan faset dapat menyertakan dokumen di sisi teks yang tidak diambil kembali untuk pemeringkatan RRF karena berada di luar jendela maxTextRecallSize. Peningkatan maxTextRecallSize meningkatkan jumlah dokumen berpangkat BM25 yang tersedia untuk peringkat, tetapi tidak meningkatkan kontribusi vektor di luar k. Gunakan countRetrievableResults jika Anda ingin perhitungan jumlah dan faset dibatasi pada dokumen yang diambil untuk pemeringkatan hibrid.

Kami merekomendasikan REST API pratinjau terbaru untuk mengatur opsi ini.

1. Gunakan Search - POST (pratinjau) atau Search - GET (pratinjau) untuk menentukan parameter pratinjau.

2. hybridSearch Tambahkan objek parameter kueri untuk mengatur jumlah maksimum dokumen yang dipanggil kembali melalui hasil kueri hibrid berperingkat BM25. Ini memiliki dua properti:

   • maxTextRecallSize menentukan jumlah hasil berperingkat BM25 yang diberikan kepada pemeringkat Reciprocal Rank Fusion (RRF) yang digunakan dalam kueri hibrid. Defaultnya adalah 1.000. Maksimumnya adalah 10.000.

   • countAndFacetMode menampilkan jumlah dan cakupan faset untuk kueri hibrida. Nilai default, countAllResults, menggunakan keseluruhan kumpulan hasil hibrida, termasuk semua dokumen yang cocok dengan kueri teks, meskipun beberapa kecocokan teks tersebut tidak diambil untuk pemeringkatan RRF karena berada di luar jendela maxTextRecallSize. Gunakan countRetrievableResults untuk membatasi cakupan hitungan dan faset pada dokumen yang diambil untuk pemeringkatan, termasuk maxTextRecallSize dokumen yang diberi peringkat oleh BM25 dan k kecocokan vektor.

3. Atur maxTextRecallSize:

   • Kurangi maxTextRecallSize jika pencarian kesamaan vektor umumnya mengungguli sisi teks kueri hibrid.

   • Tingkatkan maxTextRecallSize jika Anda memiliki indeks besar, dan defaultnya tidak menangkap jumlah hasil yang memadai. Dengan kumpulan hasil berperingkat BM25 yang lebih besar, Anda juga dapat mengatur top, skip, dan next untuk mengambil bagian dari hasil tersebut.

Contoh REST berikut menunjukkan dua kasus penggunaan untuk pengaturan maxTextRecallSize.

Contoh pertama mengurangi maxTextRecallSize menjadi 100, membatasi bagian teks dari kueri hibrida hingga hanya 100 dokumen. Ini juga menetapkan countAndFacetMode agar hanya menyertakan dokumen yang bisa diambil dalam penghitungan jumlah dan faset.

POST https://[service-name].search.windows.net/indexes/[index-name]/docs/search?api-version=2026-08-01-preview

    { 
      "vectorQueries": [ 
        { 
          "kind": "vector", 
          "vector": [1.0, 2.0, 3.0], 
          "fields": "my_vector_field", 
          "k": 10 
        } 
      ], 
      "search": "hello world", 
      "hybridSearch": { 
        "maxTextRecallSize": 100, 
        "countAndFacetMode": "countRetrievableResults" 
      } 
    } 

Contoh kedua menaikkan maxTextRecallSize menjadi 5.000. Ini juga menggunakan top, skip, dan next untuk menarik hasil dari kumpulan hasil yang besar. Dalam hal ini, permintaan menarik hasil berperingkat BM25 mulai dari posisi 1.500 hingga 2.000 sebagai kontribusi kueri teks ke kumpulan hasil komposit RRF.

POST https://[service-name].search.windows.net/indexes/[index-name]/docs/search?api-version=2026-08-01-preview

    { 
      "vectorQueries": [ 
        { 
          "kind": "vector", 
          "vector": [1.0, 2.0, 3.0], 
          "fields": "my_vector_field", 
          "k": 10 
        } 
      ], 
      "search": "hello world",
      "top": 500,
      "skip": 1500,
      "next": 500,
      "hybridSearch": { 
        "maxTextRecallSize": 5000, 
        "countAndFacetMode": "countRetrievableResults" 
      } 
    } 

Referensi: hybridSearch | maxTextRecallSize | countAndFacetMode

Contoh kueri hibrid

Bagian ini memiliki beberapa contoh kueri yang mengilustrasikan pola kueri hibrid.

Contoh: Pencarian hibrid dengan filter

Contoh ini menambahkan filter, yang diterapkan ke filterable bidang nonvektor indeks pencarian.

POST https://{{search-service-name}}.search.windows.net/indexes/{{index-name}}/docs/search?api-version=2026-04-01
Content-Type: application/json
api-key: {{admin-api-key}}
{
    "vectorQueries": [
        {
            "vector": [
                -0.009154141,
                0.018708462,
                . . . 
                -0.02178128,
                -0.00086512347
            ],
            "fields": "DescriptionVector",
            "kind": "vector",
            "k": 10
        }
    ],
    "search": "historic hotel walk to restaurants and shopping",
    "vectorFilterMode": "preFilter",
    "filter": "ParkingIncluded",
    "top": "10"
}

Poin-poin penting:

• Filter diterapkan ke konten bidang yang dapat difilter. Dalam contoh ini, bidang ParkingIncluded adalah boolean dan ditandai sebagai filterable dalam skema indeks.

• Dalam kueri hibrid, filter dapat diterapkan sebelum eksekusi kueri untuk mengurangi permukaan kueri atau setelah eksekusi kueri untuk memangkas hasil. "preFilter" adalah default. Untuk menggunakan postFilter atau strictPostFilter (pratinjau), atur mode pemrosesan filter seperti yang ditunjukkan dalam contoh ini.

• Saat Anda memfilter hasil kueri, jumlah hasil mungkin kurang dari top-n.

Referensi: filter | vectorFilterMode

Contoh: Pencarian hibrid dengan filter yang menargetkan subkueri vektor (pratinjau)

Dengan menggunakan REST API pratinjau terbaru, Anda dapat mengambil alih filter global pada permintaan pencarian dengan menerapkan filter sekunder yang hanya menargetkan subkueri vektor dalam permintaan hibrid.

Fitur ini memberikan kontrol terperinci dengan memastikan bahwa filter hanya memengaruhi hasil pencarian vektor, sehingga hasil pencarian berbasis kata kunci tidak terpengaruh.

Filter yang ditargetkan sepenuhnya mengambil alih filter global, termasuk filter apa pun yang digunakan untuk pemangkasan keamanan atau pencarian geospasial. Dalam kasus di mana filter global diperlukan, seperti pemangkasan keamanan, Anda harus secara eksplisit menyertakan filter ini di filter tingkat atas dan di setiap filter tingkat vektor untuk memastikan keamanan dan batasan lainnya diberlakukan secara konsisten.

Untuk menerapkan filter vektor yang ditargetkan:

• Gunakan pratinjau terbaru Search Documents REST API atau paket beta Azure SDK yang menyediakan fitur tersebut.

• Ubah permintaan kueri, menambahkan parameter baru vectorQueries.filterOverride yang diatur ke ekspresi filter OData.

Berikut adalah contoh kueri hibrid yang menambahkan penggantian filter. Filter global "Peringkat gt 3" diganti pada waktu proses oleh filterOverride.

POST https://{{search-service-name}}.search.windows.net/indexes/{{index-name}}/docs/search?api-version=2026-08-01-preview

{
    "vectorQueries": [
        {
            "vector": [
                -0.009154141,
                0.018708462,
                . . . 
                -0.02178128,
                -0.00086512347
            ],
            "fields": "DescriptionVector",
            "kind": "vector",
            "exhaustive": true,
            "filterOverride": "Address/City eq 'Seattle'",
            "k": 10
        }
    ],
    "search": "historic hotel walk to restaurants and shopping",
    "select": "HotelName, Description, Address/City, Rating",
    "filter": "Rating gt 3",
    "debug": "vector",
    "top": 10
}

Contoh: Pencarian hibrid semantik

Dengan asumsi definisi indeks Anda menyertakan konfigurasi semantik, Anda dapat merumuskan kueri yang menyertakan pencarian vektor dan pencarian kata kunci, dengan peringkat semantik di atas tataan hasil gabungan. Secara opsional, Anda dapat menambahkan keterangan dan jawaban.

Setiap kali Anda menggunakan peringkat semantik dengan vektor, pastikan k diatur ke 50. Ranker semantik menggunakan hingga 50 kecocokan untuk masukan. Menentukan kurang dari 50 mengurangi model peringkat semantik dari input yang diperlukan.

POST https://{{search-service-name}}.search.windows.net/indexes/{{index-name}}/docs/search?api-version=2026-04-01
Content-Type: application/json
api-key: {{admin-api-key}}
{
    "vectorQueries": [
        {
            "vector": [
                -0.009154141,
                0.018708462,
                . . . 
                -0.02178128,
                -0.00086512347
            ],
            "fields": "DescriptionVector",
            "kind": "vector",
            "k": 50
        }
    ],
    "search": "historic hotel walk to restaurants and shopping",
    "select": "HotelName, Description, Tags",
    "queryType": "semantic",
    "semanticConfiguration": "my-semantic-config",
    "captions": "extractive",
    "answers": "extractive",
    "top": "50"
}

Poin-poin penting:

• Pengurut semantik menerima hingga 50 hasil dari respon yang telah digabungkan.

• "queryType" dan "semanticConfiguration" diperlukan.

• "keterangan" dan "jawaban" bersifat opsional. Nilai diekstrak dari teks verbatim dalam hasil. Jawaban hanya dikembalikan jika hasilnya menyertakan konten yang memiliki karakteristik jawaban atas kueri.

Referensi: tipeKueri | semanticConfiguration | keterangan | jawaban

Contoh: Pencarian hibrid semantik dengan filter

Contoh ini menambahkan ParkingIncluded filter ke kueri hibrid semantik.

POST https://{{search-service-name}}.search.windows.net/indexes/{{index-name}}/docs/search?api-version=2026-04-01
Content-Type: application/json
api-key: {{admin-api-key}}
{
    "vectorQueries": [
        {
            "vector": [
                -0.009154141,
                0.018708462,
                . . . 
                -0.02178128,
                -0.00086512347
            ],
            "fields": "DescriptionVector",
            "kind": "vector",
            "k": 50
        }
    ],
    "search": "historic hotel walk to restaurants and shopping",
    "select": "HotelName, Description, Tags",
    "queryType": "semantic",
    "semanticConfiguration": "my-semantic-config",
    "captions": "extractive",
    "answers": "extractive",
    "filter": "ParkingIncluded",
    "vectorFilterMode": "preFilter",
    "top": "50"
}

Poin-poin penting:

• Mode filter dapat memengaruhi jumlah hasil yang tersedia untuk ranker semantik. Sebagai praktik terbaik, berikan jumlah maksimum dokumen (50) kepada pemeringkat semantik. Jika prefilter atau postfilter terlalu selektif, Anda mungkin tidak memberi pemeringkat semantik cukup masukan karena hanya memberinya kurang dari 50 dokumen untuk diproses.

• preFilter diterapkan sebelum eksekusi kueri. Jika prafilter mengurangi area pencarian menjadi 100 dokumen, kueri vektor dijalankan di atas DescriptionVector bidang untuk 100 dokumen tersebut, mengembalikan kecocokan terbaik k=50. 50 dokumen yang cocok tersebut kemudian diteruskan ke RRF untuk hasil penggabungan, lalu ke perangkat lunak pemeringkat semantik.

• postFilter diterapkan setelah eksekusi kueri. Jika k=50 mengembalikan 50 kecocokan di sisi kueri vektor, diikuti dengan pasca-filter yang diterapkan ke 50 kecocokan, hasil Anda dikurangi dengan jumlah dokumen yang memenuhi kriteria filter. Ini membuat Anda memiliki kurang dari 50 dokumen untuk diteruskan ke ranker semantik. Ingatlah hal ini jika Anda menggunakan peringkat semantik. Peringkat semantik berfungsi paling baik jika memiliki 50 dokumen sebagai input.

• strictPostFilter (pratinjau) diterapkan pada hasil teratas yangk tidak difilter setelah eksekusi kueri. Selalu mengembalikan kurang dari atau sama dengan k dokumen. Jika k=50 yang tidak difilter mengembalikan 50 hasil yang tidak difilter, dan filter cocok dengan 30 dokumen, hanya 30 dokumen yang dikembalikan dalam tataan hasil, bahkan jika indeks memiliki lebih dari 30 dokumen yang cocok dengan filter. Karena mode ini memiliki penurunan recall terbesar, kami tidak menyarankan Anda menggunakannya dengan pemeringkat semantik.

Mengonfigurasi jawaban kueri

Saat Anda menyiapkan kueri hibrid, pikirkan tentang struktur respons. Mesin pencari memberi peringkat pada dokumen yang cocok dan mengembalikan hasil yang paling relevan. respons adalah sekumpulan baris yang diratakan. Parameter pada kueri menentukan bidang mana yang ada di setiap baris dan berapa banyak baris dalam respons.

Bidang dalam respons

Hasil pencarian terdiri dari retrievable bidang dari indeks pencarian Anda. Hasilnya adalah salah satu dari berikut:

• Semua retrievable bidang (default REST API).
• Bidang secara eksplisit tercantum dalam select parameter pada kueri.

Contoh dalam artikel ini menggunakan select pernyataan untuk menentukan bidang teks (nonvector) dalam respons.

Jumlah hasil

Kueri mungkin cocok dengan sejumlah dokumen, sebanyak semuanya jika kriteria pencarian lemah (misalnya "search=*" untuk kueri null). Karena jarang praktis untuk mengembalikan hasil yang tidak terbatas, Anda harus menentukan maksimum untuk respons keseluruhan:

• "top": n hasil untuk kueri khusus kata kunci (tanpa vektor)
• "k": n hasil untuk kueri khusus vektor
• "top": n hasil untuk kueri hibrid (dengan atau tanpa semantik) yang menyertakan parameter "pencarian"

Keduanya k dan top bersifat opsional. Jika tidak ditentukan, jumlah hasil default dalam respons adalah 50. Anda dapat mengatur top dan skip ke melihat lebih banyak hasil atau mengubah default.

Hasil pemeringkat semantik

Jika Anda menggunakan ranker semantik dalam pratinjau 2024-05-01 atau yang lebih baru, ini adalah praktik terbaik untuk mengatur k dan maxTextRecallSize menjumlahkan setidaknya 50 total. Anda kemudian dapat membatasi hasil yang dikembalikan kepada pengguna dengan top parameter .

Jika Anda menggunakan semantic ranker pada versi API yang lebih awal dari 2024-05-01-preview, ikuti langkah-langkah berikut:

• Untuk pencarian hanya-kata kunci (tanpa vektor), setel top ke 50
• Untuk pencarian hybrid, setel k ke 50 agar ranker semantik mendapatkan setidaknya 50 hasil.

Peringkat

Beberapa set dibuat untuk kueri hibrid, dengan atau tanpa reranking semantik opsional. Peringkat hasil dihitung oleh Reciprocal Rank Fusion (RRF).

Di bagian ini, bandingkan respons antara pencarian vektor tunggal dan pencarian hibrid sederhana untuk hasil teratas. Algoritma peringkat yang berbeda, metrik kesamaan HNSW dan RRF adalah kasus ini, menghasilkan skor yang memiliki besaran yang berbeda. Perilaku ini dirancang. Skor RRF bisa tampak cukup rendah, bahkan dengan tingkat kesamaan yang tinggi. Skor yang lebih rendah adalah karakteristik algoritma RRF. Dalam kueri hibrid dengan RRF, lebih banyak timbal balik dokumen berperingkat disertakan dalam hasil, mengingat skor dokumen berperingkat RRF yang relatif lebih kecil, dibandingkan dengan pencarian vektor murni.

Pencarian Vektor Tunggal: @search.score untuk hasil yang diurutkan oleh kesamaan kosinus (fungsi jarak kesamaan vektor default).

{
    "@search.score": 0.8399121,
    "HotelId": "49",
    "HotelName": "Swirling Currents Hotel",
    "Description": "Spacious rooms, glamorous suites and residences, rooftop pool, walking access to shopping, dining, entertainment and the city center.",
    "Category": "Luxury",
    "Address": {
    "City": "Arlington"
    }
}

Pencarian Hibrid: @search.score untuk hasil hibrid yang diberi peringkat menggunakan Reciprocal Rank Fusion.

{
    "@search.score": 0.032786883413791656,
    "HotelId": "49",
    "HotelName": "Swirling Currents Hotel",
    "Description": "Spacious rooms, glamorous suites and residences, rooftop pool, walking access to shopping, dining, entertainment and the city center.",
    "Category": "Luxury",
    "Address": {
    "City": "Arlington"
    }
}

Memecahkan masalah kueri hibrid

Gunakan tabel berikut untuk mendiagnosis masalah umum dengan kueri hibrid.

Konten terkait

• Gambaran umum pencarian hibrid
• Peringkat pencarian hibrid dengan RRF
• Panduan pencarian vektor
• Peringkat semantik
• Filter pencarian vektor
• Tinjau kode demo vektor untuk Python, C#, atau JavaScript