Pola penelusuran vektor dan teks lengkap campuran

Halaman ini menjelaskan cara melakukan penelusuran hybrid vektor dan teks lengkap di Spanner. Penelusuran campuran menggabungkan presisi pencocokan kata kunci (penelusuran teks lengkap, FTS) dengan perolehan kembali pencocokan semantik (penelusuran vektor) untuk menghasilkan hasil penelusuran yang sangat relevan.

Spanner mendukung pola penelusuran hibrida berikut, yang dibagi menjadi tiga kategori utama:

Kategori	Deskripsi	Sasaran Utama
Fusion	Fusion mengambil dan memeringkatkan dokumen secara independen menggunakan penelusuran kata kunci dan vektor, lalu menggabungkan (memadukan) hasilnya.	Mencapai perolehan dan relevansi maksimum dengan menggabungkan beberapa sinyal pemberian skor.
Difilter	Kata kunci memfilter atau mempersempit ruang penelusuran.	Pastikan pencocokan kata kunci menjadi persyaratan sekaligus memanfaatkan relevansi semantik.
Peringkatan ulang ML	Model machine learning menyaring kumpulan awal kandidat untuk mendapatkan peringkat akhir yang lebih presisi.	Mencapai presisi setinggi mungkin untuk set hasil akhir kecil.

Penelusuran gabungan

Penelusuran gabungan melibatkan menjalankan FTS dan penelusuran vektor secara independen pada set data yang sama. Kemudian, hasil tersebut digabungkan untuk membuat daftar berperingkat yang tunggal, terpadu, dan sangat relevan.

Meskipun Anda dapat menjalankan kueri independen di sisi klien, penelusuran hybrid di Spanner memberikan keuntungan berikut:

• Menyederhanakan logika aplikasi dengan mengelola permintaan paralel dan penggabungan hasil di server.
• Menghindari transfer kumpulan hasil perantara yang berpotensi besar ke klien.

Anda dapat menggunakan SQL untuk membuat metode penggabungan di Spanner. Bagian ini memberikan contoh penggabungan peringkat timbal balik dan penggabungan skor relatif. Namun, sebaiknya evaluasi berbagai strategi penggabungan untuk menentukan strategi mana yang paling sesuai dengan persyaratan aplikasi Anda.

Penggabungan berbasis peringkat

Gunakan penggabungan berbasis peringkat jika skor relevansi dari berbagai metode pengambilan (seperti skor FTS dan jarak vektor) sulit dibandingkan atau dinormalisasi karena diukur dalam ruang yang berbeda. Metode ini menggunakan posisi peringkat setiap dokumen dari setiap retriever untuk menghasilkan skor dan peringkat akhir.

Penggabungan peringkat timbal balik (RRF) adalah fungsi penggabungan berbasis peringkat. Skor RRF untuk dokumen adalah jumlah kebalikan dari peringkatnya dari beberapa pengambil dihitung sebagai berikut:

\[ score\ (d\epsilon D)\ =\ \sum\limits_{r\epsilon R}^{}(1\ /\ (\ 𝑘\ +\ ran{k}_{r}\ (𝑑)\ )\ )\ \]

Dengan:

• d adalah dokumen.
• R adalah set pengambil (FTS dan penelusuran vektor).
• k adalah konstanta (sering ditetapkan ke 60) yang digunakan untuk memoderasi pengaruh dokumen dengan peringkat sangat tinggi.
• w adalah peringkat dokumen dari retriever r.

Menerapkan RRF dalam kueri Spanner

Metrik vektor (seperti APPROX_DOT_PRODUCT) dan skor penelusuran teks (seperti SCORE_NGRAMS) beroperasi pada skala yang tidak kompatibel. Untuk mengatasi hal ini, contoh berikut menerapkan RRF untuk menormalisasi data berdasarkan posisi peringkat, bukan skor mentah.

Kueri menggunakan UNNEST(ARRAY(...) WITH OFFSET) untuk menetapkan peringkat kepada 100 kandidat teratas dari setiap metode. Kemudian, BigQuery menghitung skor standar menggunakan kebalikan dari peringkat tersebut dan menggabungkan hasilnya untuk menampilkan lima kecocokan teratas.

SELECT SUM(1 / (60 + rank)) AS rrf_score, key
FROM (
  (
    SELECT rank, x AS key
    FROM UNNEST(ARRAY(
      SELECT key
      FROM hybrid_search
      WHERE embedding IS NOT NULL
      ORDER BY APPROX_DOT_PRODUCT(@vector, embedding,
        OPTIONS => JSON '{"num_leaves_to_search": 50}') DESC
      LIMIT 100)) AS x WITH OFFSET AS rank
  )
  UNION ALL
  (
    SELECT rank, x AS key
    FROM UNNEST(ARRAY(
      SELECT key
      FROM hybrid_search
      WHERE SEARCH_NGRAMS(text_tokens_ngrams, 'foo')
      ORDER BY SCORE_NGRAMS(text_tokens_ngrams, 'foo') DESC
      LIMIT 100)) AS x WITH OFFSET AS rank
  )
)
GROUP BY key
ORDER BY rrf_score DESC
LIMIT 5;

Penggabungan berbasis skor

Penggabungan berbasis skor efektif jika skor relevansi dari berbagai metode dapat dibandingkan atau Anda dapat menormalisasinya, yang dapat memungkinkan peringkat yang lebih tepat yang menggabungkan bobot relevansi sebenarnya dari setiap metode.

Penggabungan skor relatif (RSF) adalah metode berbasis skor yang menormalisasi skor dari berbagai metode relatif terhadap skor tertinggi dan terendah dalam setiap metode, biasanya menggunakan fungsi MIN() dan MAX(). Skor RSF dokumen yang diambil oleh sekumpulan pengambil dihitung sebagai berikut:

\[ score(d\epsilon D)\ =\ \sum\limits_{r\epsilon R}^{}({w}_{r}*(scor{e}_{r}(d)\ -\ mi{n}_{r})\ /\ (ma{x}_{r\ }-mi{n}_{r})\ ) \]

Dengan:

• d adalah dokumen.
• R adalah set pengambil (FTS dan penelusuran vektor).
• w adalah bobot yang ditetapkan ke retriever tertentu.

Menerapkan RSF dalam kueri Spanner

Untuk menerapkan RSF, Anda harus menormalisasi skor dari vektor dan FTS ke skala umum. Contoh berikut menghitung skor minimum dan maksimum dalam klausa WITH terpisah untuk mendapatkan faktor normalisasi. Kemudian, menggabungkan hasil menggunakan FULL OUTER JOIN, menjumlahkan skor yang dinormalisasi dari penelusuran perkiraan tetangga terdekat (ANN) (dikonversi dari cosine_distance) dan FTS.

WITH ann AS (
  SELECT key, APPROX_COSINE_DISTANCE(@vector, embedding,
    OPTIONS => JSON '{"num_leaves_to_search": 50}') AS cosine_distance,
  FROM hybrid_search
  WHERE embedding IS NOT NULL
  ORDER BY cosine_distance
  LIMIT 100
),
fts AS (
  SELECT key, SCORE_NGRAMS(text_tokens_ngrams, 'Green') AS score,
  FROM hybrid_search
    WHERE SEARCH_NGRAMS(text_tokens_ngrams, 'Green')
    ORDER BY score DESC
    LIMIT 100
),
ann_min AS (
  SELECT MIN(1 - cosine_distance) AS min
  FROM ann
),
ann_max AS (
  SELECT MAX(1 - cosine_distance) AS max
  FROM ann
),
fts_min AS (
  SELECT MIN(score) AS min
  FROM fts
),
fts_max AS (
  SELECT MAX(score) AS max
  FROM fts
)
SELECT IFNULL(ann.key, fts.key),
       IFNULL(((1 - ann.cosine_distance) - ann_min.min) /
               (ann_max.max - ann_min.min), 0) +
       IFNULL((fts.score - fts_min.min) /
               (fts_max.max - fts_min.min), 0) AS score
FROM ann
FULL OUTER JOIN fts
ON ann.key = fts.key
CROSS JOIN ann_min
CROSS JOIN ann_max
CROSS JOIN fts_min
CROSS JOIN fts_max
ORDER BY score DESC
LIMIT 5;

Penelusuran yang difilter

Penelusuran yang difilter menggunakan FTS untuk membuat filter yang mengurangi set dokumen yang dipertimbangkan untuk penelusuran vektor tetangga k-terdekat (KNN). Anda dapat secara opsional menggunakan pengurutan awal untuk membatasi ukuran kumpulan hasil.

Menerapkan penelusuran yang difilter dalam kueri Spanner

Penelusuran contoh di bagian ini melakukan langkah-langkah berikut untuk mempersempit ruang penelusuran vektor ke subset data yang cocok dengan kata kunci:

• Menggunakan SEARCH (text_tokens, 'Green') untuk menemukan baris tempat kolom text_tokens berisi teks Green. 1.000 baris teratas ditampilkan oleh urutan pengurutan ulang yang ditentukan oleh indeks penelusuran.
• Menggunakan fungsi vektor, DOT_PRODUCT(@vector, embedding) untuk menghitung kemiripan antara vektor kueri (@vector) dan vektor dokumen yang disimpan (embedding). Kemudian, hasil akan diurutkan dan 10 kecocokan teratas akhir akan ditampilkan.

SELECT key
FROM (
  SELECT key, embedding
  FROM hybrid_search
  WHERE SEARCH (text_tokens, 'Green')
  ORDER BY presort
  LIMIT 1000)
ORDER BY DOT_PRODUCT(@vector, embedding) DESC
LIMIT 10;

Peringkatan ulang ML

Pengurutan ulang berbasis ML adalah pendekatan yang intensif secara komputasi, tetapi sangat presisi. Fitur ini menerapkan model machine learning ke set kandidat kecil yang telah diperkecil oleh FTS, penelusuran vektor, atau kombinasi keduanya. Untuk mengetahui informasi selengkapnya tentang integrasi Vertex AI Spanner, lihat Ringkasan integrasi Vertex AI Spanner.

Anda dapat mengintegrasikan penyesuaian peringkat ML menggunakan fungsi ML.PREDICT Spanner dengan model Vertex AI yang di-deploy.

Menerapkan pengurutan ulang berbasis ML

1. Deploy model pengubah peringkat (seperti dari HuggingFace) ke endpoint Vertex AI.

2. Buat objek Spanner MODEL yang mengarah ke endpoint Vertex AI. Misalnya, dalam contoh model Reranker berikut:

   • text ARRAY<string(max)> adalah dokumen.
   • text_pair ARRAY<string(max)> adalah teks kueri dalam contoh.
   • score adalah skor relevansi yang ditetapkan oleh model ML untuk pasangan input teks.

   CREATE MODEL Reranker
   INPUT (text ARRAY<string(max)>, text_pair ARRAY<string(max)>)
   OUTPUT (score FLOAT32)
   REMOTE
   OPTIONS (
   endpoint = '...'
   );
   

3. Gunakan subkueri untuk mengambil kandidat awal (seperti 100 hasil teratas dari penelusuran ANN) dan teruskan ke ML.PREDICT. Fungsi menampilkan kolom skor baru untuk pengurutan akhir.

   SELECT key
   FROM ML.PREDICT(
       MODEL Reranker, (
         SELECT key, text, "gift for 8-year-old" AS text_pair
         FROM hybrid_search
         WHERE embedding IS NOT NULL
         ORDER BY APPROX_DOT_PRODUCT(@vector, embedding, options=>JSON '{"num_leaves_to_search": 50}') DESC
         LIMIT 100)
   )
   ORDER BY score DESC
   LIMIT 3;
   

Langkah berikutnya

• Sesuaikan mesin telusur Anda dengan penelusuran campuran berteknologi AI di Spanner.
• Pelajari lebih lanjut penelusuran teks lengkap.