Boost RankerCompatible with Milvus v2.6.2+

Alih-alih hanya mengandalkan kemiripan semantik yang dihitung berdasarkan jarak vektor, Boost Rangking memungkinkan Anda untuk memengaruhi hasil pencarian dengan cara yang berarti. Ini sangat ideal untuk menyesuaikan hasil pencarian dengan cepat menggunakan pemfilteran metadata.

Ketika permintaan pencarian menyertakan fungsi Boost Ranker, Milvus menggunakan kondisi pemfilteran opsional dalam fungsi untuk menemukan kecocokan di antara kandidat hasil pencarian dan meningkatkan skor kecocokan tersebut dengan menerapkan bobot yang ditentukan, membantu mempromosikan atau menurunkan peringkat entitas yang cocok di hasil akhir.

Kapan menggunakan Boost Ranker

Tidak seperti pemeringkat lain yang mengandalkan model penyandi silang atau algoritme fusi, Boost Ranker secara langsung menyuntikkan aturan berbasis metadata opsional ke dalam proses pemeringkatan, yang membuatnya lebih cocok dalam skenario berikut.

Kasus Penggunaan	Contoh	Mengapa Boost Ranker Bekerja dengan Baik
Penentuan prioritas konten berdasarkan bisnis	Menyoroti produk premium dalam hasil pencarian e-commerce Meningkatkan visibilitas konten dengan metrik keterlibatan pengguna yang tinggi (seperti penayangan, suka, dan berbagi) Mengangkat konten terbaru dalam aplikasi pencarian yang sensitif terhadap waktu Memprioritaskan konten dari sumber yang terverifikasi atau tepercaya Meningkatkan hasil yang sesuai dengan frasa yang tepat atau kata kunci dengan relevansi tinggi	Tanpa perlu membangun ulang indeks atau memodifikasi model penyematan vektor-operasi yang dapat memakan waktu-Anda dapat langsung mempromosikan atau menurunkan item tertentu di hasil penelusuran dengan menerapkan filter metadata opsional secara real-time. Mekanisme ini memungkinkan peringkat pencarian yang fleksibel dan dinamis yang dengan mudah beradaptasi dengan kebutuhan bisnis yang terus berkembang.
Penurunan peringkat konten strategis	Mengurangi keunggulan item dengan inventaris rendah tanpa menghapusnya sepenuhnya Menurunkan peringkat konten dengan istilah yang berpotensi tidak pantas tanpa menyensor Menurunkan dokumentasi yang lebih lama namun tetap dapat diakses dalam pencarian teknis Secara halus mengurangi visibilitas produk pesaing dalam pencarian pasar Mengurangi relevansi konten dengan indikasi kualitas yang lebih rendah (seperti masalah pemformatan, panjang yang lebih pendek, dll.)

Anda juga dapat menggabungkan beberapa Boost Ranker untuk menerapkan strategi peringkat berbasis bobot yang lebih dinamis dan kuat.

Mekanisme Boost Ranker

Diagram berikut ini menggambarkan alur kerja utama Boost Rankers.

Mekanisme Boost Ranker

Ketika Anda memasukkan data, Milvus mendistribusikannya ke seluruh segmen. Selama pencarian, setiap segmen mengembalikan sekumpulan kandidat, dan Milvus memberi peringkat pada kandidat dari semua segmen untuk menghasilkan hasil akhir. Ketika permintaan pencarian menyertakan Boost Ranker, Milvus menerapkannya pada hasil kandidat dari setiap segmen untuk mencegah potensi kehilangan presisi dan meningkatkan recall.

Sebelum menyelesaikan hasil akhir, Milvus memproses kandidat-kandidat ini dengan Boost Ranker sebagai berikut:

1. Menerapkan ekspresi pemfilteran opsional yang ditentukan di Boost Ranker untuk mengidentifikasi entitas yang cocok dengan ekspresi tersebut.

2. Menerapkan bobot yang ditentukan dalam Boost Ranker untuk meningkatkan skor entitas yang teridentifikasi.

Contoh Boost Ranker

Contoh berikut ini mengilustrasikan penggunaan Boost Ranker dalam pencarian vektor tunggal yang membutuhkan pengembalian lima entitas paling relevan dan menambahkan bobot ke skor entitas dengan tipe dokumen abstrak.

1. Kumpulkan kandidat hasil pencarian dalam segmen-segmen.

   Tabel berikut ini mengasumsikan Milvus mendistribusikan entitas ke dalam dua segmen(0001 dan 0002), dengan masing-masing segmen mengembalikan lima kandidat.

   ID	JenisDokumen	Skor	Peringkat	segmen
   117	abstrak	0.344	1	0001
   89	abstrak	0.456	2	0001
   257	tubuh	0.578	3	0001
   358	judul	0.788	4	0001
   168	tubuh	0.899	5	0001
   46	tubuh	0.189	1	0002
   48	tubuh	0265	2	0002
   561	abstrak	0.366	3	0002
   344	abstrak	0.444	4	0002
   276	abstrak	0.845	5	0002

2. Terapkan ekspresi pemfilteran yang ditentukan dalam Boost Ranker (doctype='abstract').

   Seperti yang dilambangkan dengan bidang DocType pada tabel berikut, Milvus akan menandai semua entitas dengan doctype yang disetel ke abstract untuk diproses lebih lanjut.

   ID	Jenis Dokumen	Skor	Peringkat	segmen
   117	abstrak	0.344	1	0001
   89	abstrak	0.456	2	0001
   257	tubuh	0.578	3	0001
   358	judul	0.788	4	0001
   168	tubuh	0.899	5	0001
   46	tubuh	0.189	1	0002
   48	tubuh	0265	2	0002
   561	abstrak	0.366	3	0002
   344	abstrak	0.444	4	0002
   276	abstrak	0.845	5	0002

3. Terapkan bobot yang ditentukan dalam Boost Ranker (weight=0.5).

   Semua entitas yang teridentifikasi pada langkah sebelumnya akan dikalikan dengan bobot yang ditentukan di Boost Ranker, sehingga menghasilkan perubahan pada peringkat mereka.

   ID	Jenis Dokumen	Skor	Skor Tertimbang (= skor x bobot)	Peringkat	segmen
   117	abstrak	0.344	0.172	1	0001
   89	abstrak	0.456	0.228	2	0001
   257	tubuh	0.578	0.578	3	0001
   358	judul	0.788	0.788	4	0001
   168	tubuh	0.899	0.899	5	0001
   561	abstrak	0.366	0.183	1	0002
   46	tubuh	0.189	0.189	2	0002
   344	abstrak	0.444	0.222	3	0002
   48	tubuh	0.265	0.265	4	0002
   276	abstrak	0.845	0.423	5	0002

   Bobot harus berupa angka floating-point yang Anda pilih. Dalam kasus seperti contoh di atas, di mana skor yang lebih kecil menunjukkan relevansi yang lebih besar, gunakan bobot kurang dari 1. Jika tidak, gunakan bobot yang lebih besar dari 1.

4. Agregasikan kandidat dari semua segmen berdasarkan skor tertimbang untuk menyelesaikan hasilnya.

   ID	Jenis Dokumen	Skor	Skor Tertimbang	Peringkat	segmen
   117	abstrak	0.344	0.172	1	0001
   561	abstrak	0.366	0.183	2	0002
   46	tubuh	0.189	0.189	3	0002
   344	abstrak	0.444	0.222	4	0002
   89	abstrak	0.456	0.228	5	0001

Penggunaan Boost Ranker

Pada bagian ini, Anda akan melihat contoh cara menggunakan Boost Ranker untuk memengaruhi hasil pencarian vektor tunggal.

Membuat Pemeringkat Boost

Sebelum mengoper Boost Ranker sebagai perangking ulang permintaan pencarian, Anda harus mendefinisikan Boost Ranker dengan benar sebagai fungsi perangkingan ulang sebagai berikut:

from pymilvus import Function, FunctionType

ranker = Function(
    name="boost",
    input_field_names=[], # Must be an empty list
    function_type=FunctionType.RERANK,
    params={
        "reranker": "boost",
        "filter": "doctype == 'abstract'",
        "random_score": { 
            "seed": 126,
            "field": "id"
        },
        "weight": 0.5
    }
)

import io.milvus.v2.service.vector.request.ranker.BoostRanker;

BoostRanker ranker = BoostRanker.builder()
        .name("boost")
        .filter("doctype == \"abstract\"")
        .weight(5.0f)
        .randomScoreField("id")
        .randomScoreSeed(126)
        .build();

// go

import {FunctionType} from '@zilliz/milvus2-sdk-node';

const ranker = {
  name: "boost",
  input_field_names: [],
  type: FunctionType.RERANK,
  params: {
    reranker: "boost",
    filter: "doctype == 'abstract'",
    random_score: {
      seed: 126,
      field: "id",
    },
    weight: 0.5,
  },
};

# restful

Parameter	Diperlukan?	Deskripsi	Nilai/Contoh
name	Ya	Pengenal unik untuk Fungsi ini	"boost"
input_field_names	Ya	Daftar bidang vektor untuk menerapkan fungsi (harus kosong untuk Boost Ranker)	[]
function_type	Ya	Jenis Fungsi yang akan dipanggil; gunakan RERANK untuk menentukan strategi perankingan ulang	FunctionType.RERANK
params.reranker	Ya	Menentukan jenis perangking ulang. Harus diatur ke boost untuk menggunakan Boost Ranker.	"boost"
params.weight	Ya	Menentukan bobot yang akan dikalikan dengan skor entitas yang cocok dalam hasil pencarian mentah. Nilai harus berupa angka floating-point. Untuk menekankan pentingnya pencocokan entitas, tetapkan ke nilai yang meningkatkan skor. Untuk menurunkan entitas yang cocok, tetapkan parameter ini dengan nilai yang menurunkan skornya.	1
params.filter	No	Menentukan ekspresi filter yang akan digunakan untuk mencocokkan entitas di antara entitas hasil pencarian. Dapat berupa ekspresi filter dasar yang valid yang disebutkan dalam Penjelasan Pemfilteran. Catatan: Hanya gunakan operator dasar, seperti ==, >, atau <. Menggunakan operator lanjutan, seperti text_match atau phrase_match, akan menurunkan kinerja pencarian.	"doctype == 'abstract'"
params.random_score	No	Menentukan fungsi acak yang menghasilkan nilai antara 0 dan 1 secara acak. Ini memiliki dua argumen opsional berikut: seed (number) Menentukan nilai awal yang digunakan untuk memulai generator nomor acak semu (PRNG). field (string) Menentukan nama bidang yang nilainya akan digunakan sebagai faktor acak dalam menghasilkan nomor acak. Sebuah field dengan nilai yang unik sudah cukup. Anda disarankan untuk menetapkan seed dan field untuk memastikan konsistensi di seluruh generasi dengan menggunakan nilai seed dan field yang sama.	{"seed": 126, "field": "id"}

Cari dengan satu Boost Ranker

Setelah fungsi Boost Ranker siap, Anda dapat mereferensikannya dalam permintaan penelusuran. Contoh berikut ini mengasumsikan bahwa Anda telah membuat koleksi yang memiliki bidang berikut: id, vektor, dan tipe dokumen.

from pymilvus import MilvusClient

# Connect to the Milvus server
client = MilvusClient(
    uri="http://localhost:19530",
    token="root:Milvus"
)

# Assume you have a collection set up

# Conduct a similarity search using the created ranker
client.search(
    collection_name="my_collection",
    data=[[-0.619954382375778, 0.4479436794798608, -0.17493894838751745, -0.4248030059917294, -0.8648452746018911]],
    anns_field="vector",
    params={},
    output_field=["doctype"],
    ranker=ranker
)

import io.milvus.v2.client.ConnectConfig;
import io.milvus.v2.client.MilvusClientV2;
import io.milvus.v2.service.vector.request.SearchReq;
import io.milvus.v2.service.vector.response.SearchResp;
import io.milvus.v2.service.vector.request.data.FloatVec;

MilvusClientV2 client = new MilvusClientV2(ConnectConfig.builder()
        .uri("http://localhost:19530")
        .token("root:Milvus")
        .build());
        
SearchResp searchReq = client.search(SearchReq.builder()
        .collectionName("my_collection")
        .data(Collections.singletonList(new FloatVec(new float[]{-0.619954f, 0.447943f, -0.174938f, -0.424803f, -0.864845f})))
        .annsField("vector")
        .outputFields(Collections.singletonList("doctype"))
        .functionScore(FunctionScore.builder()
                .addFunction(ranker)
                .build())
        .build());
SearchResp searchResp = client.search(searchReq);

// go

import { MilvusClient } from '@zilliz/milvus2-sdk-node';

// Connect to the Milvus server
const client = new MilvusClient({
  address: 'localhost:19530',
  token: 'root:Milvus'
});

// Assume you have a collection set up

// Conduct a similarity search
const searchResults = await client.search({
  collection_name: 'my_collection',
  data: [-0.619954382375778, 0.4479436794798608, -0.17493894838751745, -0.4248030059917294, -0.8648452746018911],
  anns_field: 'vector',
  output_fields: ['doctype'],
  rerank: ranker,
});

console.log('Search results:', searchResults);

# restful

Pencarian dengan beberapa Boost Rankers

Anda dapat menggabungkan beberapa Boost Rankers dalam satu pencarian untuk memengaruhi hasil pencarian. Untuk melakukannya, buat beberapa Boost Rankers, rujuk ke dalam instance FunctionScore, dan gunakan instance FunctionScore sebagai pemeringkat dalam permintaan pencarian.

Contoh berikut ini menunjukkan cara memodifikasi skor semua entitas yang teridentifikasi dengan menerapkan bobot antara 0,8 dan 1,2.

from pymilvus import MilvusClient, Function, FunctionType, FunctionScore

# Create a Boost Ranker with a fixed weight
fix_weight_ranker = Function(
    name="boost",
    input_field_names=[], # Must be an empty list
    function_type=FunctionType.RERANK,
    params={
        "reranker": "boost",
        "weight": 0.8
    }
)

# Create a Boost Ranker with a randomly generated weight between 0 and 0.4
random_weight_ranker = Function(
    name="boost",
    input_field_names=[], # Must be an empty list
    function_type=FunctionType.RERANK,
    params={
        "reranker": "boost",
        "random_score": {
            "seed": 126,
        },
        "weight": 0.4
    }
)

# Create a Function Score
ranker = FunctionScore(
    functions=[
        fix_weight_ranker, 
        random_weight_ranker
    ],
    params={
        "boost_mode": "Multiply",
        "function_mode": "Sum"
    }
)

# Conduct a similarity search using the created Function Score
client.search(
    collection_name="my_collection",
    data=[[-0.619954382375778, 0.4479436794798608, -0.17493894838751745, -0.4248030059917294, -0.8648452746018911]],
    anns_field="vector",
    params={},
    output_field=["doctype"],
    ranker=ranker
)

import io.milvus.common.clientenum.FunctionType;
import io.milvus.v2.service.collection.request.CreateCollectionReq;

CreateCollectionReq.Function fixWeightRanker = CreateCollectionReq.Function.builder()
                 .functionType(FunctionType.RERANK)
                 .name("boost")
                 .param("reranker", "boost")
                 .param("weight", "0.8")
                 .build();
                 
CreateCollectionReq.Function randomWeightRanker = CreateCollectionReq.Function.builder()
                 .functionType(FunctionType.RERANK)
                 .name("boost")
                 .param("reranker", "boost")
                 .param("weight", "0.4")
                 .param("random_score", "{\"seed\": 126}")
                 .build();

Map<String, String> params = new HashMap<>();
params.put("boost_mode","Multiply");
params.put("function_mode","Sum");     
FunctionScore ranker = FunctionScore.builder()
                 .addFunction(fixWeightRanker)
                 .addFunction(randomWeightRanker)
                 .params(params)
                 .build()

SearchResp searchReq = client.search(SearchReq.builder()
                 .collectionName("my_collection")
                 .data(Collections.singletonList(new FloatVec(new float[]{-0.619954f, 0.447943f, -0.174938f, -0.424803f, -0.864845f})))
                 .annsField("vector")
                 .outputFields(Collections.singletonList("doctype"))
                 .addFunction(ranker)
                 .build());
SearchResp searchResp = client.search(searchReq);

// go

import {FunctionType} from '@zilliz/milvus2-sdk-node';

const fix_weight_ranker = {
  name: "boost",
  input_field_names: [],
  type: FunctionType.RERANK,
  params: {
    reranker: "boost",
    weight: 0.8,
  },
};

const random_weight_ranker = {
  name: "boost",
  input_field_names: [],
  type: FunctionType.RERANK,
  params: {
    reranker: "boost",
    random_score: {
      seed: 126,
    },
    weight: 0.4,
  },
};

const ranker = {
  functions: [fix_weight_ranker, random_weight_ranker],
  params: {
    boost_mode: "Multiply",
    function_mode: "Sum",
  },
};

await client.search({
  collection_name: "my_collection",
  data: [[-0.619954382375778, 0.4479436794798608, -0.17493894838751745, -0.4248030059917294, -0.8648452746018911]],
  anns_field: "vector",
  params: {},
  output_field: ["doctype"],
  ranker: ranker
});

# restful

Secara khusus, ada dua Boost Rankers: satu menerapkan bobot tetap untuk semua entitas yang ditemukan, sementara yang lain memberikan bobot acak kepada mereka. Kemudian, kita mereferensikan kedua perangking ini dalam sebuah FunctionScore, yang juga mendefinisikan bagaimana bobot mempengaruhi skor entitas yang ditemukan.

Tabel berikut mencantumkan parameter-parameter yang diperlukan untuk membuat sebuah instance FunctionScore.

Parameter	Diperlukan?	Deskripsi	Nilai/Contoh
functions	Ya	Menentukan nama-nama pemeringkat target dalam daftar.	["fix_weight_ranker", "random_weight_ranker"]
params.boost_mode	Tidak	Menentukan bagaimana bobot yang ditentukan mempengaruhi skor dari setiap entitas yang cocok. Nilai yang mungkin adalah: Multiply Menunjukkan bahwa nilai tertimbang sama dengan skor asli entitas yang cocok dikalikan dengan bobot yang ditentukan. Ini adalah nilai default. Sum Menunjukkan bahwa nilai tertimbang sama dengan jumlah skor asli dari entitas yang cocok dan bobot yang ditentukan	"Sum"
params.function_mode	Tidak	Menentukan bagaimana nilai tertimbang dari berbagai Pemeringkat Boost diproses. Nilai yang mungkin adalah: Multiply Menunjukkan bahwa skor akhir dari entitas yang cocok sama dengan hasil kali nilai tertimbang dari semua Pemeringkat Boost. Ini adalah nilai default. Sum Menunjukkan bahwa skor akhir dari entitas yang cocok sama dengan jumlah nilai tertimbang dari semua Pemeringkat Boost.	"Sum"