Gambaran Umum Pemeringkat PeluruhanCompatible with Milvus 2.6.x

Dalam pencarian vektor tradisional, hasil diberi peringkat murni berdasarkan kemiripan vektor-seberapa dekat vektor cocok dalam ruang matematika. Namun dalam aplikasi dunia nyata, apa yang membuat konten benar-benar relevan sering kali bergantung pada lebih dari sekadar kemiripan semantik.

Pertimbangkan skenario sehari-hari ini:

• Pencarian berita di mana artikel kemarin seharusnya memiliki peringkat lebih tinggi daripada artikel serupa dari tiga tahun yang lalu

• Pencari restoran yang memprioritaskan tempat yang berjarak 5 menit daripada yang membutuhkan waktu 30 menit berkendara

• Platform e-niaga yang meningkatkan produk yang sedang tren meskipun produk tersebut tidak terlalu mirip dengan kueri penelusuran

Semua skenario ini memiliki kebutuhan yang sama: menyeimbangkan kemiripan vektor dengan faktor numerik lain seperti waktu, jarak, atau popularitas.

Pemeringkat pembusukan di Milvus memenuhi kebutuhan ini dengan menyesuaikan peringkat pencarian berdasarkan nilai bidang numerik. Mereka memungkinkan Anda untuk menyeimbangkan kemiripan vektor dengan "kesegaran", "kedekatan", atau properti numerik lain dari data Anda, menciptakan pengalaman pencarian yang lebih intuitif dan relevan secara kontekstual.

Catatan penggunaan

• Peringkat peluruhan tidak dapat digunakan dengan pencarian pengelompokan.

• Bidang yang digunakan untuk pemeringkatan peluruhan harus berupa angka (INT8, INT16, INT32, INT64, FLOAT, atau DOUBLE).

• Setiap pemeringkat peluruhan hanya dapat menggunakan satu bidang numerik.

• Konsistensi unit waktu: Ketika menggunakan peringkat peluruhan berbasis waktu, satuan untuk parameter origin, scale, dan offset harus sesuai dengan satuan yang digunakan dalam data koleksi Anda:

  • Jika koleksi Anda menyimpan stempel waktu dalam satuan detik, gunakan satuan detik untuk semua parameter

  • Jika koleksi Anda menyimpan cap waktu dalam milidetik, gunakan milidetik untuk semua parameter

  • Jika koleksi Anda menyimpan cap waktu dalam mikrodetik, gunakan mikrodetik untuk semua parameter

Bagaimana cara kerjanya

Peringkat peluruhan menyempurnakan pencarian vektor tradisional dengan memasukkan faktor numerik seperti waktu atau jarak geografis ke dalam proses pemeringkatan. Keseluruhan prosesnya mengikuti tahap-tahap berikut ini:

Tahap 1: Menghitung skor kemiripan yang dinormalisasi

Pertama, Milvus menghitung dan menormalkan skor kemiripan vektor untuk memastikan perbandingan yang konsisten:

• Untuk metrik jarak L2 dan JACCARD (di mana nilai yang lebih rendah menunjukkan kemiripan yang lebih tinggi):

  normalized_score = 1.0 - (2 × arctan(score))/π
  

  Ini mengubah jarak menjadi skor kemiripan antara 0-1, di mana lebih tinggi lebih baik.

• Untuk metrik IP, COSINE, dan BM25 (di mana nilai yang lebih tinggi sudah mengindikasikan kecocokan yang lebih baik): Skor digunakan secara langsung tanpa normalisasi.

Tahap 2: Menghitung skor pembusukan

Selanjutnya, Milvus menghitung skor peluruhan berdasarkan nilai bidang numerik (seperti stempel waktu atau jarak) menggunakan pemeringkat peluruhan yang Anda pilih:

• Setiap pemeringkat peluruhan mengubah nilai numerik mentah menjadi skor relevansi yang dinormalisasi antara 0-1

• Skor peluruhan menunjukkan seberapa relevan sebuah item berdasarkan "jaraknya" dari titik ideal

Rumus perhitungan spesifik bervariasi tergantung pada jenis pemeringkat peluruhan. Untuk detail tentang cara menghitung skor peluruhan, lihat halaman khusus untuk Peluruhan Gaussian, Peluruhan Eksponensial, Peluruhan Linier.

Tahap 3: Menghitung skor akhir

Terakhir, Milvus menggabungkan skor kemiripan yang dinormalisasi dan skor peluruhan untuk menghasilkan skor peringkat akhir:

final_score = normalized_similarity_score × decay_score

Dalam kasus pencarian hibrida (menggabungkan beberapa bidang vektor), Milvus mengambil skor kemiripan ternormalisasi maksimum di antara permintaan pencarian:

final_score = max([normalized_score₁, normalized_score₂, ..., normalized_scoreₙ]) × decay_score

Misalnya, jika sebuah makalah penelitian mendapat skor 0,82 dari kesamaan vektor dan 0,91 dari pencarian teks berbasis BM25 dalam pencarian hibrida, Milvus menggunakan 0,91 sebagai skor kesamaan dasar sebelum menerapkan faktor peluruhan.

Peringkat peluruhan dalam aksi

Mari kita lihat peringkat peluruhan dalam skenario praktis-mencari "makalah penelitian AI" dengan peluruhan berbasis waktu:

Kertas	Kemiripan Vektor	Nilai Kemiripan yang dinormalisasi	Tanggal Publikasi	Skor Peluruhan	Skor Akhir	Peringkat Akhir
Makalah A	Tinggi	0.85 (COSINE)	2 minggu yang lalu	0.80	0.68	2
Kertas B	Sangat Tinggi	0,92 (COSINE)	6 bulan yang lalu	0.45	0.41	3
Kertas C	Sedang	0,75 (COSINE)	1 hari yang lalu	0.98	0.74	1
Kertas D	Sedang-Tinggi	0,76 (COSINE)	3 minggu yang lalu	0.70	0.53	4

Tanpa pemeringkatan ulang peluruhan, makalah B akan menduduki peringkat tertinggi berdasarkan kemiripan vektor murni (0,92). Namun, dengan diterapkannya pemeringkatan ulang peluruhan:

• Makalah C melonjak ke posisi #1 meskipun kemiripannya sedang karena sangat baru (diterbitkan kemarin)

• Makalah B turun ke posisi #3 meskipun memiliki kemiripan yang sangat baik karena relatif tua

• Makalah D menggunakan jarak L2 (di mana lebih rendah lebih baik), sehingga skornya dinormalisasi dari 1,2 menjadi 0,76 sebelum menerapkan peluruhan

Pilih pemeringkat peluruhan yang tepat

Milvus menawarkan pemeringkat peluruhan yang berbeda - gauss, exp, linear, masing-masing dirancang untuk kasus penggunaan tertentu:

Pemeringkat Pembusukan	Karakteristik	Kasus Penggunaan Ideal	Contoh Skenario
Gaussian (gauss)	Penurunan bertahap yang terasa alami yang meluas secara moderat	Pencarian umum yang membutuhkan hasil yang seimbang Aplikasi di mana pengguna memiliki rasa intuitif terhadap jarak Ketika jarak yang moderat seharusnya tidak terlalu mempengaruhi hasil	Dalam pencarian restoran, tempat berkualitas yang berjarak 3 km tetap dapat ditemukan, meskipun peringkatnya lebih rendah dari pilihan terdekat
Eksponensial (exp)	Menurun dengan cepat pada awalnya tetapi mempertahankan ekor yang panjang	Umpan berita di mana kemutakhiran sangat penting Media sosial di mana konten segar harus mendominasi Ketika kedekatan sangat disukai tetapi item yang jauh harus tetap terlihat	Dalam aplikasi berita, berita kemarin memiliki peringkat yang jauh lebih tinggi daripada konten yang sudah berumur satu minggu, tetapi artikel lama yang sangat relevan masih dapat muncul
Linear (linear)	Penurunan yang konsisten dan dapat diprediksi dengan batas yang jelas	Aplikasi dengan batas-batas alami Layanan dengan batas jarak Konten dengan tanggal kedaluwarsa atau ambang batas yang jelas	Dalam pencari peristiwa, peristiwa di luar jendela dua minggu ke depan tidak akan muncul sama sekali

Untuk informasi terperinci tentang bagaimana setiap pemeringkat peluruhan menghitung skor dan pola penurunan tertentu, lihat dokumentasi khusus:

• Peluruhan Gaussian

• Peluruhan Eksponensial

• Peluruhan Linier

Contoh implementasi

Pemeringkat peluruhan dapat diterapkan pada pencarian vektor standar dan operasi pencarian hibrida di Milvus. Di bawah ini adalah cuplikan kode utama untuk mengimplementasikan fitur ini.

Membuat pemeringkat peluruhan

Untuk mengimplementasikan pemeringkatan peluruhan, pertama-tama tentukan objek Function dengan konfigurasi yang sesuai:

from pymilvus import Function, FunctionType

# Create a decay function for timestamp-based decay
# Note: All time parameters must use the same unit as your collection data
decay_ranker = Function(
    name="time_decay",                  # Function identifier
    input_field_names=["timestamp"],    # Numeric field to use for decay
    function_type=FunctionType.RERANK,  # Must be set to RERANK for decay rankers
    params={
        "reranker": "decay",            # Specify decay reranker. Must be "decay"
        "function": "gauss",            # Choose decay function type: "gauss", "exp", or "linear"
        "origin": int(datetime.datetime(2025, 1, 15).timestamp()),    # Reference point (seconds)
        "scale": 7 * 24 * 60 * 60,      # 7 days in seconds (must match collection data unit)
        "offset": 24 * 60 * 60,         # 1 day no-decay zone (must match collection data unit)
        "decay": 0.5                    # Half score at scale distance
    }
)

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

import java.time.ZoneId;
import java.time.ZonedDateTime;

ZonedDateTime zdt = ZonedDateTime.of(2025, 1, 25, 0, 0, 0, 0, ZoneId.systemDefault());

DecayRanker ranker = DecayRanker.builder()
        .name("time_decay")
        .inputFieldNames(Collections.singletonList("timestamp"))
        .function("gauss")
        .origin(zdt.toInstant().toEpochMilli())
        .scale(7 * 24 * 60 * 60)
        .offset(24 * 60 * 60)
        .decay(0.5)
        .build();

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

const decayRanker = {
  name: "time_decay",
  input_field_names: ["timestamp"],
  function_type: FunctionType.RERANK,
  params: {
    reranker: "decay",
    function: "gauss",
    origin: new Date(2025, 1, 15).getTime(),
    scale: 7 * 24 * 60 * 60,
    offset: 24 * 60 * 60,
    decay: 0.5,
  },
};

// go

# restful

Parameter	Diperlukan?	Deskripsi	Nilai/Contoh
name	Ya	Pengenal untuk fungsi Anda yang digunakan saat menjalankan pencarian. Pilih nama deskriptif yang relevan dengan kasus penggunaan Anda.	"time_decay"
input_field_names	Ya	Bidang numerik untuk penghitungan skor peluruhan. Menentukan atribut data mana yang akan digunakan untuk menghitung peluruhan (misalnya, stempel waktu untuk peluruhan berbasis waktu, koordinat untuk peluruhan berbasis lokasi). Harus berupa bidang dalam koleksi Anda yang berisi nilai numerik yang relevan. Mendukung INT8/16/32/64, FLOAT, DOUBLE.	["timestamp"]
function_type	Ya	Menentukan jenis fungsi yang sedang dibuat. Harus disetel ke RERANK untuk semua pemeringkat peluruhan.	FunctionType.RERANK
params.reranker	Ya	Menentukan metode pemeringkatan ulang yang akan digunakan. Harus diatur ke "decay" untuk mengaktifkan fungsionalitas pemeringkatan peluruhan.	"decay"
params.function	Ya	Menentukan pemeringkat peluruhan matematis mana yang akan diterapkan. Menentukan bentuk kurva penurunan relevansi. Lihat bagian Memilih pemeringkat peluruhan yang tepat untuk panduan dalam memilih fungsi yang sesuai.	"gauss", "exp", atau "linear"
params.origin	Ya	Titik referensi yang digunakan untuk menghitung skor peluruhan. Item pada nilai ini menerima skor relevansi maksimum. Untuk peluruhan berbasis waktu, satuan waktu harus sesuai dengan data koleksi Anda.	Untuk stempel waktu: waktu saat ini (misalnya, int(time.time())) Untuk geolokasi: koordinat pengguna saat ini
params.scale	Ya	Jarak atau waktu saat relevansi turun ke nilai decay. Mengontrol seberapa cepat relevansi menurun. Untuk peluruhan berbasis waktu, unit waktu harus sesuai dengan data koleksi Anda. Nilai yang lebih besar menciptakan penurunan relevansi yang lebih bertahap; nilai yang lebih kecil menciptakan penurunan yang lebih curam.	Untuk waktu: periode dalam detik (misalnya, 7 * 24 * 60 * 60 selama 7 hari) Untuk jarak: meter (misalnya, 5000 untuk 5 km)
params.offset	Tidak	Menciptakan "zona tanpa peluruhan" di sekitar origin di mana item mempertahankan nilai penuh (nilai peluruhan = 1,0). Untuk kerusakan berbasis waktu, unit waktu harus sesuai dengan data koleksi Anda. Item yang berada dalam kisaran origin ini mempertahankan relevansi maksimum.	Untuk waktu: periode dalam detik (misalnya, 24 * 60 * 60 selama 1 hari) Untuk jarak: meter (misalnya, 500 untuk 500m)
params.decay	Tidak	Nilai skor pada jarak scale, mengontrol kecuraman kurva. Nilai yang lebih rendah akan menghasilkan kurva penurunan yang lebih curam; nilai yang lebih tinggi akan menghasilkan kurva penurunan yang lebih bertahap. Harus antara 0 dan 1.	0.5 (default)

Menerapkan ke pencarian vektor standar

Setelah mendefinisikan pemeringkat peluruhan Anda, Anda dapat menerapkannya selama operasi pencarian dengan meneruskannya ke parameter ranker:

# Use the decay function in standard vector search
results = milvus_client.search(
    collection_name,
    data=[your_query_vector], # Replace with your query vector
    anns_field="vector_field",
    limit=10,
    output_fields=["document", "timestamp"],  # Include the decay field in outputs to see values
    ranker=decay_ranker,                      # Apply the decay ranker here
    consistency_level="Strong"
)

import io.milvus.v2.service.vector.request.SearchReq;
import io.milvus.v2.service.vector.response.SearchResp;
import io.milvus.v2.service.vector.request.data.EmbeddedText;

SearchReq searchReq = SearchReq.builder()
        .collectionName(COLLECTION_NAME)
        .data(Collections.singletonList(new EmbeddedText("search query")))
        .annsField("vector_field")
        .limit(10)
        .outputFields(Arrays.asList("document", "timestamp"))
        .functionScore(FunctionScore.builder()
                .addFunction(ranker)
                .build())
        .build();
SearchResp searchResp = client.search(searchReq);

const result = await milvusClient.search({
  collection_name: "collection_name",
  data: [your_query_vector], // Replace with your query vector
  anns_field: "dense",
  limit: 10,
  output_fields: ["document", "timestamp"],
  rerank: ranker,
  consistency_level: "Strong",
});

// go

# restful