Tentang penelusuran campuran

Penelusuran Vektor mendukung penelusuran campuran, pola arsitektur populer dalam pengambilan informasi (IR) yang menggabungkan penelusuran semantik dan penelusuran kata kunci (juga disebut penelusuran berbasis token). Dengan penelusuran campuran, developer dapat memanfaatkan yang terbaik dari kedua pendekatan tersebut, sehingga secara efektif memberikan kualitas penelusuran yang lebih tinggi.

Halaman ini menjelaskan konsep penelusuran campuran, penelusuran semantik, dan penelusuran berbasis token, serta menyertakan contoh cara menyiapkan penelusuran berbasis token dan penelusuran campuran:

Mengapa penelusuran campuran itu penting?

Seperti yang dijelaskan dalam Ringkasan Vector Search, penelusuran semantik dengan Vector Search dapat menemukan item dengan kemiripan semantik menggunakan kueri.

Model penyematan seperti Embedding Vertex AI membuat ruang vektor sebagai peta makna konten. Setiap penyematan teks atau multimodal adalah lokasi di peta yang mewakili makna beberapa konten. Sebagai contoh sederhana, saat model penyematan mengambil teks yang membahas film sebesar 10%, musik sebesar 2%, dan aktor sebesar 30%, model tersebut dapat merepresentasikan teks ini dengan [0.1, 0.02, 0.3] penyematan. Dengan Vector Search, Anda dapat dengan cepat menemukan penyematan lain di sekitarnya. Penelusuran menurut arti konten ini disebut penelusuran semantik.

Ilustrasi istilah penelusuran semantik relatif terhadap satu sama lain dalam peta makna.

Penelusuran semantik dengan penyematan dan penelusuran vektor dapat membantu membuat sistem IT secerdas pustakawan atau staf toko yang berpengalaman. Embedding dapat digunakan untuk menghubungkan berbagai data bisnis dengan maknanya; misalnya, kueri dan hasil penelusuran; teks dan gambar; aktivitas pengguna dan produk yang direkomendasikan; teks bahasa Inggris dan teks bahasa Jepang; atau data sensor dan kondisi pemberitahuan. Dengan kemampuan ini, ada berbagai kasus penggunaan untuk penyematan.

Penelusuran semantik tidak mencakup semua kemungkinan persyaratan untuk aplikasi pengambilan informasi, seperti Retrieval-Augmented Generation (RAG). Penelusuran semantik hanya dapat menemukan data yang dapat dipahami oleh model penyematan. Misalnya, kueri atau set data dengan nomor produk atau SKU arbitrer, nama produk baru yang baru-baru ini ditambahkan, dan nama kode eksklusif perusahaan tidak berfungsi dengan penelusuran semantik karena tidak disertakan dalam set data pelatihan model penyematan. Hal ini disebut data "di luar domain".

Dalam kasus tersebut, Anda harus menggabungkan penelusuran semantik dengan penelusuran berbasis kata kunci (juga disebut berbasis token) untuk membentuk penelusuran campuran. Dengan penelusuran hybrid, Anda dapat memanfaatkan penelusuran semantik dan berbasis token untuk mencapai kualitas penelusuran yang lebih tinggi.

Salah satu sistem penelusuran campuran yang paling populer adalah Google Penelusuran. Layanan ini mengintegrasikan penelusuran semantik pada tahun 2015 dengan model RankBrain, selain algoritma penelusuran kata kunci berbasis token. Dengan diperkenalkannya penelusuran campuran, Google Penelusuran dapat meningkatkan kualitas penelusuran secara signifikan dengan memenuhi dua persyaratan: penelusuran menurut arti dan penelusuran menurut kata kunci.

Sebelumnya, membuat mesin telusur campuran adalah tugas yang kompleks. Sama seperti Google Penelusuran, Anda harus membuat dan mengoperasikan dua jenis mesin telusur yang berbeda (penelusuran semantik dan penelusuran berbasis token) serta menggabungkan dan memberi peringkat pada hasil dari mesin telusur tersebut. Dengan dukungan penelusuran campuran di Vector Search, Anda dapat membuat sistem penelusuran campuran Anda sendiri dengan satu indeks Vector Search, yang disesuaikan dengan persyaratan bisnis Anda.

Bagaimana cara kerja penelusuran berbasis token di Vector Search? Setelah membagi teks menjadi token (seperti kata atau sub-kata), Anda dapat menggunakan algoritma penyematan jarang yang populer seperti TF-IDF, BM25, atau SPLADE untuk membuat penyematan jarang untuk teks.

Penjelasan sederhana tentang penyematan jarang adalah bahwa penyematan tersebut merupakan vektor yang mewakili frekuensi kemunculan setiap kata atau sub-kata dalam teks. Penyematan jarang biasa tidak memperhitungkan semantik teks.

Embedding jarang

Mungkin ada ribuan kata yang berbeda yang digunakan dalam teks. Dengan demikian, penyematan ini biasanya memiliki puluhan ribu dimensi, dengan hanya beberapa dimensi di dalamnya yang memiliki nilai non-nol. Itulah sebabnya embeddings ini disebut "renggang". Sebagian besar nilainya adalah nol. Ruang penyematan yang jarang ini berfungsi sebagai peta kata kunci, mirip dengan indeks buku.

Dalam ruang embedding jarang ini, Anda dapat menemukan embedding serupa dengan melihat lingkungan embedding kueri. Penyematan ini serupa dalam hal distribusi kata kunci yang digunakan dalam teksnya.

Ilustrasi kata kunci serupa yang terletak berdekatan dalam peta makna.

Ini adalah mekanisme dasar penelusuran berbasis token dengan penyematan jarang. Dengan penelusuran campuran di Vector Search, Anda dapat menggabungkan embedding rapat dan jarang ke dalam satu indeks vektor dan menjalankan kueri dengan embedding rapat, embedding jarang, atau keduanya. Hasilnya adalah kombinasi penelusuran semantik dan hasil penelusuran berbasis token.

Penelusuran campuran juga memberikan latensi kueri yang lebih rendah dibandingkan dengan mesin telusur berbasis token dengan desain indeks terbalik. Sama seperti penelusuran vektor untuk penelusuran semantik, setiap kueri dengan penyematan padat atau jarang selesai dalam milidetik, bahkan dengan jutaan atau miliaran item.

Untuk menjelaskan cara menggunakan penelusuran berbasis token, bagian berikut menyertakan contoh kode yang menghasilkan penyematan jarang dan membuat indeks dengan penyematan tersebut di Vector Search.

Untuk mencoba kode contoh ini, gunakan notebook: Menggabungkan Penelusuran Semantik & Kata Kunci: Tutorial Penelusuran Hybrid dengan Vertex AI Vector Search

Langkah pertama adalah menyiapkan file data untuk membuat indeks untuk penyematan yang jarang, berdasarkan format data yang dijelaskan dalam Format dan struktur data input.

Dalam JSON, file data akan terlihat seperti ini:

{"id": "3", "sparse_embedding": {"values": [0.1, 0.2], "dimensions": [1, 4]}}
{"id": "4", "sparse_embedding": {"values": [-0.4, 0.2, -1.3], "dimensions": [10, 20, 30]}}

Setiap item harus memiliki properti sparse_embedding yang memiliki properti values dan dimensions. Penyematan jarang memiliki ribuan dimensi dengan beberapa nilai non-nol. Format data ini berfungsi secara efisien karena hanya berisi nilai non-nol dengan posisinya dalam ruang.

Menyiapkan set data contoh

Sebagai set data contoh, kita akan menggunakan set data Google Merch Shop, yang memiliki sekitar 200 baris barang bermerek Google.

0                          Google Sticker
1                    Google Cloud Sticker
2                       Android Black Pen
3                   Google Ombre Lime Pen
4                    For Everyone Eco Pen
                      ...
197        Google Recycled Black Backpack
198    Google Cascades Unisex Zip Sweater
199    Google Cascades Womens Zip Sweater
200         Google Cloud Skyline Backpack
201       Google City Black Tote Backpack

Menyiapkan vektorizer TF-IDF

Dengan set data ini, kita akan melatih vectorizer, model yang menghasilkan embedding yang jarang dari teks. Contoh ini menggunakan TfidfVectorizer di scikit-learn, yang merupakan vectorizer dasar yang menggunakan algoritma TF-IDF.

from sklearn.feature_extraction.text import TfidfVectorizer

# Make a list of the item titles
corpus = df.title.tolist()

# Initialize TfidfVectorizer
vectorizer = TfidfVectorizer()

# Fit and Transform
vectorizer.fit_transform(corpus)

Variabel corpus menyimpan daftar 200 nama item, seperti "Google Sticker" atau "Chrome Dino Pin". Kemudian, kode meneruskannya ke vektorizer dengan memanggil fungsi fit_transform(). Dengan demikian, vektorizer siap untuk membuat penyematan yang jarang.

Vectorizer TF-IDF mencoba memberikan bobot yang lebih tinggi pada kata tanda tangan dalam set data (seperti "Kemeja" atau "Dino") dibandingkan dengan kata-kata biasa (seperti "The", "a", atau "of"), dan menghitung frekuensi penggunaan kata tanda tangan tersebut dalam dokumen yang ditentukan. Setiap nilai penyematan jarang mewakili frekuensi setiap kata berdasarkan jumlah. Untuk informasi selengkapnya tentang TF-IDF, lihat Bagaimana cara kerja TF-IDF dan TfidfVectorizer?.

Dalam contoh ini, kita menggunakan tokenisasi tingkat kata dasar dan vektorisasi TF-IDF untuk memudahkan. Dalam pengembangan produksi, Anda dapat memilih opsi lain untuk tokenisasi dan vektorisasi guna menghasilkan penyematan yang jarang berdasarkan persyaratan Anda. Untuk tokenizer, dalam banyak kasus, tokenizer subword berperforma baik dibandingkan dengan tokenisasi tingkat kata dan merupakan pilihan populer. Untuk vektorizer, BM25 populer sebagai versi yang lebih baik dari TF-IDF. SPLADE adalah algoritma vektorisasi populer lainnya yang menggunakan beberapa semantik untuk penyematan jarang.

Mendapatkan embedding jarang

Agar vektorizer lebih mudah digunakan dengan Penelusuran Vektor, kita akan menentukan fungsi wrapper, get_sparse_embedding():

def get_sparse_embedding(text):

  # Transform Text into TF-IDF Sparse Vector
  tfidf_vector = vectorizer.transform([text])

  # Create Sparse Embedding for the New Text
  values = []
  dims = []
  for i, tfidf_value in enumerate(tfidf_vector.data):
    values.append(float(tfidf_value))
    dims.append(int(tfidf_vector.indices[i]))
  return {"values": values, "dimensions": dims}

Fungsi ini meneruskan parameter "text" ke pengonversi vektor untuk menghasilkan penyematan yang jarang. Kemudian, konversikan ke format {"values": ...., "dimensions": ...} yang disebutkan sebelumnya untuk membuat indeks jarang Vector Search.

Anda dapat menguji fungsi ini:

text_text = "Chrome Dino Pin"
get_sparse_embedding(text_text)

Tindakan ini akan menghasilkan penyematan jarang berikut:

{'values': [0.6756557405747007, 0.5212913389979028, 0.5212913389979028],
 'dimensions': [157, 48, 33]}

Membuat file data input

Untuk contoh ini, kita akan membuat penyematan jarang untuk 200 item.

items = []
for i in range(len(df)):
  id = i
  title = df.title[i]
  sparse_embedding = get_sparse_embedding(title)
  items.append({"id": id, "title": title, "sparse_embedding": sparse_embedding})

Kode ini menghasilkan baris berikut untuk setiap item:

{
  'id': 0,
  'title': 'Google Sticker',
  'sparse_embedding': {
    'values': [0.933008728540452, 0.359853737603667],
    'dimensions': [191, 78]
  }
}

Kemudian, simpan sebagai file JSONL "items.json" dan upload ke bucket Cloud Storage.

# output as a JSONL file and save to bucket
with open("items.json", "w") as f:
  for item in items:
    f.write(f"{item}\n")
! gsutil cp items.json $BUCKET_URI

Membuat indeks penyematan jarang di Vector Search

Selanjutnya, kita akan membuat dan men-deploy indeks embedding jarang di Vector Search. Ini adalah prosedur yang sama dengan yang didokumentasikan dalam panduan memulai Penelusuran Vektor.

# create Index
my_index = aiplatform.MatchingEngineIndex.create_tree_ah_index(
  display_name = f"vs-hybridsearch-index-{UID}",
  contents_delta_uri = BUCKET_URI,
  dimensions = 768,
  approximate_neighbors_count = 10,
)

Untuk menggunakan indeks, Anda harus membuat endpoint indeks. Fungsinya sebagai instance server yang menerima permintaan kueri untuk indeks Anda.

# create IndexEndpoint
my_index_endpoint = aiplatform.MatchingEngineIndexEndpoint.create(
  display_name = f"vs-quickstart-index-endpoint-{UID}",
  public_endpoint_enabled = True
)

Dengan endpoint indeks, deploy indeks dengan menentukan ID indeks yang di-deploy secara unik.

DEPLOYED_INDEX_ID = f"vs_quickstart_deployed_{UID}"

# deploy the Index to the Index Endpoint
my_index_endpoint.deploy_index(
    index = my_index, deployed_index_id = DEPLOYED_INDEX_ID
)

Setelah menunggu deployment, kita siap untuk menjalankan kueri pengujian.

Menjalankan kueri dengan indeks penyematan jarang

Untuk menjalankan kueri dengan indeks penyematan jarang, Anda perlu membuat objek HybridQuery untuk mengenkapsulasi penyematan jarang teks kueri, seperti dalam contoh berikut:

from google.cloud.aiplatform.matching_engine.matching_engine_index_endpoint import HybridQuery

# create HybridQuery
query_text = "Kids"
query_emb = get_sparse_embedding(query_text)
query = HybridQuery(
  sparse_embedding_dimensions=query_emb['dimensions'],
  sparse_embedding_values=query_emb['values'],
)

Contoh kode ini menggunakan teks "Anak-anak" untuk kueri. Sekarang, jalankan kueri dengan objek HybridQuery.

# build a query request
response = my_index_endpoint.find_neighbors(
  deployed_index_id=DEPLOYED_INDEX_ID,
  queries=[query],
  num_neighbors=5,
)

# print results
for idx, neighbor in enumerate(response[0]):
  title = df.title[int(neighbor.id)]
  print(f"{title:<40}")

Tindakan ini akan memberikan output seperti berikut:

Google Blue Kids Sunglasses
Google Red Kids Sunglasses
YouTube Kids Coloring Pencils
YouTube Kids Character Sticker Sheet

Dari 200 item, hasilnya berisi nama item yang memiliki kata kunci "Anak-anak".

Contoh ini menggabungkan penelusuran berbasis token dengan penelusuran semantik untuk membuat penelusuran hibrida di Vector Search.

Cara membuat indeks campuran

Untuk membuat indeks campuran, setiap item harus memiliki "embedding" (untuk penyematan rapat) dan "sparse_embedding":

items = []
for i in range(len(df)):
  id = i
  title = df.title[i]
  dense_embedding = get_dense_embedding(title)
  sparse_embedding = get_sparse_embedding(title)
  items.append(
    {"id": id, "title": title,
      "embedding": dense_embedding,
      "sparse_embedding": sparse_embedding,}
  )
items[0]

Fungsi get_dense_embedding() menggunakan Vertex AI Embedding API untuk membuat penyematan teks dengan 768 dimensi. Tindakan ini akan menghasilkan penyematan yang rapat dan jarang dalam format berikut:

{
  "id": 0,
  "title": "Google Sticker",
  "embedding":
    [0.022880317643284798,
    -0.03315234184265137,
    ...
    -0.03309667482972145,
    0.04621824622154236],
  "sparse_embedding": {
    "values": [0.933008728540452, 0.359853737603667],
    "dimensions": [191, 78]
  }
}

Proses lainnya sama seperti dalam Contoh: Cara menggunakan penelusuran berbasis token: upload file JSONL ke bucket Cloud Storage, buat indeks Penelusuran Vektor dengan file tersebut, dan deploy indeks ke endpoint indeks.

Menjalankan kueri campuran

Setelah men-deploy indeks campuran, Anda dapat menjalankan kueri campuran:

# create HybridQuery
query_text = "Kids"
query_dense_emb = get_dense_embedding(query_text)
query_sparse_emb = get_sparse_embedding(query_text)
query = HybridQuery(
  dense_embedding=query_dense_emb,
  sparse_embedding_dimensions=query_sparse_emb['dimensions'],
  sparse_embedding_values=query_sparse_emb['values'],
  rrf_ranking_alpha=0.5,
)

Untuk teks kueri "Anak-Anak", buat penyematan padat dan jarang untuk kata, lalu gabungkan ke objek HybridQuery. Perbedaan dari HybridQuery sebelumnya adalah dua parameter tambahan: dense_embedding dan rrf_ranking_alpha.

Kali ini, kita akan mencetak jarak untuk setiap item:

# print results
for idx, neighbor in enumerate(response[0]):
  title = df.title[int(neighbor.id)]
  dense_dist = neighbor.distance if neighbor.distance else 0.0
  sparse_dist = neighbor.sparse_distance if neighbor.sparse_distance else 0.0
  print(f"{title:<40}: dense_dist: {dense_dist:.3f}, sparse_dist: {sparse_dist:.3f}")

Di setiap objek neighbor, ada properti distance yang memiliki jarak antara kueri dan item dengan penyematan padat, dan properti sparse_distance yang memiliki jarak dengan penyematan jarang. Nilai ini adalah jarak yang terbalik, sehingga nilai yang lebih tinggi berarti jarak yang lebih pendek.

Dengan menjalankan kueri dengan HybridQuery, Anda akan mendapatkan hasil berikut:

Google Blue Kids Sunglasses             : dense_dist: 0.677, sparse_dist: 0.606
Google Red Kids Sunglasses              : dense_dist: 0.665, sparse_dist: 0.572
YouTube Kids Coloring Pencils           : dense_dist: 0.655, sparse_dist: 0.478
YouTube Kids Character Sticker Sheet    : dense_dist: 0.644, sparse_dist: 0.468
Google White Classic Youth Tee          : dense_dist: 0.645, sparse_dist: 0.000
Google Doogler Youth Tee                : dense_dist: 0.639, sparse_dist: 0.000
Google Indigo Youth Tee                 : dense_dist: 0.637, sparse_dist: 0.000
Google Black Classic Youth Tee          : dense_dist: 0.632, sparse_dist: 0.000
Chrome Dino Glow-in-the-Dark Youth Tee  : dense_dist: 0.632, sparse_dist: 0.000
Google Bike Youth Tee                   : dense_dist: 0.629, sparse_dist: 0.000

Selain hasil penelusuran berbasis token yang memiliki kata kunci "Anak-Anak", ada juga hasil penelusuran semantik yang disertakan. Misalnya, "Google White Classic Youth Tee" disertakan karena model penyematan mengetahui bahwa "Youth" dan "Kids" secara semantik mirip.

Untuk menggabungkan hasil penelusuran berbasis token dan semantik, penelusuran campuran menggunakan Fusi Peringkat Resiprokal (RRF). Untuk mengetahui informasi selengkapnya tentang RRF dan cara menentukan parameter rrf_ranking_alpha, lihat Apa yang dimaksud dengan Penggabungan Rasio Peringkat Resiprokal?.

Pengurutan ulang

RRF menyediakan cara untuk menggabungkan peringkat dari hasil penelusuran semantik dan berbasis token. Dalam banyak sistem rekomendasi atau pengambilan informasi produksi, hasilnya akan melalui algoritma peringkat presisi lebih lanjut — yang disebut pemberian peringkat ulang. Dengan kombinasi pengambilan cepat tingkat milidetik dengan Vector Search dan pemeringkatan ulang presisi pada hasil, Anda dapat membuat sistem multi-tahap yang memberikan kualitas penelusuran atau performa rekomendasi yang lebih tinggi.

Pipeline untuk mengevaluasi jutaan item, lalu mengurutkan ulang ratusan item untuk menghasilkan lebih sedikit rekomendasi.

Vertex AI Ranking API menyediakan cara untuk menerapkan peringkat berdasarkan relevansi umum antara teks kueri dan teks hasil penelusuran dengan model yang telah dilatih sebelumnya. TensorFlow Ranking juga memberikan pengantar tentang cara mendesain dan melatih model learning to rank (LTR) untuk pengurutan ulang lanjutan yang dapat disesuaikan untuk berbagai persyaratan bisnis.

Mulai menggunakan penelusuran campuran

Referensi berikut dapat membantu Anda mulai menggunakan penelusuran campuran di Vector Search.

Resource penelusuran hybrid

Referensi Vector Search

Konsep tambahan

Bagian berikut menjelaskan TF-IDF dan TfidVectorizer, Penggabungan Rasio Resiprokal, dan parameter alfa secara lebih mendetail.

Bagaimana cara kerja TF-IDF dan TfidfVectorizer?

Fungsi fit_transform() menjalankan dua proses penting dari algoritma TF-IDF:

  • Fit: Vectorizer menghitung Frekuensi Dokumen Invers (IDF) untuk setiap istilah dalam kosakata. IDF mencerminkan seberapa penting suatu istilah di seluruh korpus. Istilah langka mendapatkan skor IDF yang lebih tinggi:

    IDF(t) = log_e(Total number of documents / Number of documents containing term t)

  • Transform:

    • Tokenisasi: Memecah dokumen menjadi setiap istilah (kata atau frasa)

    • Penghitungan Frekuensi Istilah (TF): Menghitung seberapa sering setiap istilah muncul dalam setiap dokumen dengan:

      TF(t, d) = (Number of times term t appears in document d) / (Total number of terms in document d)

    • Penghitungan TF-IDF: Menggabungkan TF untuk setiap istilah dengan IDF yang telah dihitung sebelumnya untuk membuat skor TF-IDF. Skor ini mewakili pentingnya istilah dalam dokumen tertentu dibandingkan dengan seluruh korpus.

      TF-IDF(t, d) = TF(t, d) * IDF(t)

      Vectorizer TF-IDF mencoba memberikan bobot yang lebih tinggi pada kata tanda tangan dalam set data, seperti "Kemeja" atau "Dino", dibandingkan dengan kata-kata biasa, seperti "The", "a", atau "of", dan menghitung frekuensi kata tanda tangan tersebut digunakan dalam dokumen yang ditentukan. Setiap nilai penyematan jarang mewakili frekuensi setiap kata berdasarkan jumlah.

Apa yang dimaksud dengan Penggabungan Peringkat Resiprokal?

Untuk menggabungkan hasil penelusuran berbasis token dan semantik, penelusuran campuran menggunakan Fusi Peringkat Resiprokal (RRF). RRF adalah algoritma untuk menggabungkan beberapa daftar item yang diberi peringkat menjadi satu peringkat terpadu. Ini adalah teknik populer untuk menggabungkan hasil penelusuran dari berbagai sumber atau metode pengambilan, terutama dalam sistem penelusuran campuran dan model bahasa besar.

Dalam kasus penelusuran campuran Penelusuran Vektor, jarak padat dan jarak jarang diukur dalam ruang yang berbeda dan tidak dapat dibandingkan secara langsung satu sama lain. Dengan demikian, RRF berfungsi secara efektif untuk menggabungkan dan menentukan peringkat hasil dari dua ruang yang berbeda.

Berikut cara kerja RRF:

  1. Rasio balik: Untuk setiap item dalam daftar yang diberi peringkat, hitung rasio baliknya. Ini berarti mengambil invers posisi item (peringkat) dalam daftar. Misalnya, item yang diberi peringkat nomor satu mendapatkan peringkat timbal balik 1/1 = 1, dan item yang diberi peringkat nomor dua mendapatkan 1/2 = 0,5.
  2. Menjumlahkan peringkat timbal balik: Menjumlahkan peringkat timbal balik untuk setiap item di semua daftar yang diberi peringkat. Hal ini akan memberikan skor akhir untuk setiap item.
  3. Urutkan menurut skor akhir: Urutkan item menurut skor akhirnya dalam urutan menurun. Item dengan skor tertinggi dianggap paling relevan atau penting.

Singkatnya, item dengan peringkat lebih tinggi dalam hasil yang padat dan jarang akan ditarik ke bagian atas daftar. Dengan demikian, item "Google Blue Kids Sunglasses" berada di bagian atas karena memiliki peringkat yang lebih tinggi di hasil penelusuran yang padat dan jarang. Item seperti "Google White Classic Youth Tee" memiliki peringkat rendah karena hanya memiliki peringkat dalam hasil penelusuran yang padat.

Perilaku parameter alfa

Contoh cara menggunakan penelusuran campuran menetapkan parameter rrf_ranking_alpha sebagai 0,5 saat membuat objek HybridQuery. Anda dapat menentukan bobot untuk mengurutkan hasil penelusuran yang padat dan jarang menggunakan nilai berikut untuk rrf_ranking_alpha:

  • 1, atau tidak ditentukan: Penelusuran campuran hanya menggunakan hasil penelusuran yang padat dan mengabaikan hasil penelusuran yang jarang.
  • 0: Penelusuran campuran hanya menggunakan hasil penelusuran yang jarang dan mengabaikan hasil penelusuran yang padat.
  • 0 ke 1: Penelusuran campuran menggabungkan kedua hasil dari padat dan jarang dengan bobot yang ditentukan oleh nilai. 0,5 berarti kedua kolom tersebut akan digabungkan dengan bobot yang sama.