Peluruhan LinierCompatible with Milvus 2.6.x

Peluruhan linier menciptakan penurunan garis lurus yang berakhir pada titik nol absolut dalam hasil pencarian Anda. Seperti hitungan mundur acara yang akan datang di mana relevansi secara bertahap memudar hingga acara tersebut berlalu, peluruhan linier menerapkan pengurangan relevansi yang dapat diprediksi dan stabil saat item menjauh dari titik ideal Anda hingga item tersebut benar-benar hilang. Pendekatan ini sangat ideal ketika Anda menginginkan tingkat peluruhan yang konsisten dengan batas akhir yang jelas, memastikan bahwa item di luar batas tertentu benar-benar dikecualikan dari hasil.

Tidak seperti fungsi peluruhan lainnya:

• Peluruhan Gaussian mengikuti kurva lonceng yang secara bertahap mendekati tetapi tidak pernah mencapai nol

• Peluruhan eksponensial mempertahankan ekor panjang dengan relevansi minimal yang meluas tanpa batas

Peluruhan linier secara unik menciptakan titik akhir yang pasti, sehingga sangat efektif untuk aplikasi dengan batas waktu atau tenggat waktu alami.

Kapan menggunakan peluruhan linier

Peluruhan linier sangat efektif untuk:

Kasus Penggunaan	Contoh	Mengapa Linear Bekerja dengan Baik
Daftar acara	Platform tiket konser	Menciptakan batas waktu yang jelas untuk acara yang terlalu jauh di masa depan
Penawaran waktu terbatas	Penjualan kilat, promosi	Memastikan penawaran yang sudah kedaluwarsa atau akan segera kedaluwarsa tidak muncul
Radius pengiriman	Pengiriman makanan, layanan kurir	Menegakkan batas geografis yang keras
Konten yang dibatasi usia	Platform kencan, layanan media	Menetapkan ambang batas usia yang tegas

Pilih peluruhan linier saat:

• Aplikasi Anda memiliki batas, tenggat waktu, atau ambang batas alami

• Item di luar titik tertentu harus benar-benar dikecualikan dari hasil

• Anda memerlukan tingkat penurunan relevansi yang dapat diprediksi dan konsisten

• Pengguna harus melihat batasan yang jelas antara item yang relevan dan tidak relevan

Prinsip penurunan yang stabil

Peluruhan linier menciptakan penurunan garis lurus yang menurun dengan laju konstan hingga mencapai tepat nol. Pola ini muncul dalam banyak skenario sehari-hari seperti penghitung waktu mundur, penipisan inventaris, dan pendekatan tenggat waktu di mana relevansi memiliki titik kedaluwarsa yang jelas.

Peluruhan Linier

Grafik di atas menunjukkan bagaimana peluruhan linier akan memengaruhi daftar acara pada platform tiket:

• origin (tanggal saat ini): Saat ini, di mana relevansi berada pada titik maksimum (1,0).

• offset (1 hari): "Jendela acara terdekat"-semua acara yang terjadi dalam satu hari ke depan mempertahankan nilai relevansi penuh (1,0), memastikan bahwa acara yang sangat dekat tidak akan dihukum karena perbedaan waktu yang kecil.

• decay (0.5): Skor pada jarak skala-parameter ini mengontrol laju penurunan relevansi.

• scale (10 hari): Periode waktu di mana relevansi turun ke nilai peluruhan-peristiwa yang berjarak 10 hari lagi akan memiliki skor relevansinya berkurang setengahnya (0,5).

Seperti yang Anda lihat dari kurva garis lurus, peristiwa yang berjarak lebih dari 16 hari memiliki relevansi nol dan tidak akan muncul di hasil pencarian sama sekali. Hal ini menciptakan batas yang jelas yang memastikan pengguna hanya melihat acara mendatang yang relevan dalam rentang waktu tertentu.

Perilaku ini mencerminkan cara kerja perencanaan acara pada umumnya-acara yang akan segera berlangsung adalah yang paling relevan, acara dalam beberapa minggu ke depan semakin tidak penting, dan acara yang terlalu jauh di masa depan (atau sudah lewat) tidak akan muncul sama sekali.

Rumus

Rumus matematika untuk menghitung skor peluruhan linier adalah:

$$S(doc) = \max\left( \frac{s - \max(0, |fieldvalue_{doc} - origin| - offset)}{s}, 0 \right)$$

Di mana:

$$s = \frac{scale}{(1.0 - decay)}$$

Menjabarkannya dalam bahasa yang sederhana:

1. Hitung seberapa jauh nilai lapangan dari nilai asal: ∣ nilai lapangan - asal∣| nilai $\mathrm{lapangan\_\{doc\}}$ $- asal|$ lapangan doc $-$ $asal|$

2. Kurangi offset (jika ada) tetapi jangan sampai di bawah nol: $\max(0, jarak - offset)$ $offset)$

3. Tentukan parameter $ss$ s dari nilai skala dan peluruhan Anda.

4. Kurangi jarak yang sudah disesuaikan dari $ss$ s dan bagi dengan $ss$ s

5. Pastikan hasilnya tidak pernah di bawah nol: $\max(hasil, 0)$ 0 $)$

Perhitungan $ss$ s mengubah parameter skala dan peluruhan Anda menjadi titik di mana skor mencapai nol. Sebagai contoh, dengan decay=0.5 dan skala=7, skor akan mencapai tepat nol pada jarak=14 (dua kali nilai skala).

Gunakan peluruhan linier

Peluruhan linier dapat diterapkan pada pencarian vektor standar dan operasi pencarian hibrida di Milvus. Di bawah ini adalah cuplikan kode kunci untuk mengimplementasikan fitur ini.

Membuat pemeringkat peluruhan

Setelah koleksi Anda disiapkan dengan bidang numerik (dalam contoh ini, event_date sebagai detik dari sekarang), buatlah pemeringkat peluruhan linier:

from pymilvus import Function, FunctionType
import time

# Calculate current time
current_time = int(time.time())

# Create a linear decay ranker for event listings
# Note: All time parameters must use the same unit as your collection data
ranker = Function(
    name="event_relevance",               # Function identifier
    input_field_names=["event_date"],     # Numeric field to use
    function_type=FunctionType.RERANK,    # Function type. Must be RERANK
    params={
        "reranker": "decay",              # Specify decay reranker
        "function": "linear",             # Choose linear decay
        "origin": current_time,           # Current time (seconds, matching collection data)
        "offset": 12 * 60 * 60,           # 12 hour immediate events window (seconds)
        "decay": 0.5,                     # Half score at scale distance
        "scale": 7 * 24 * 60 * 60         # 7 days (in seconds, matching collection data)
    }
)

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

DecayRanker ranker = DecayRanker.builder()
        .name("event_relevance")
        .inputFieldNames(Collections.singletonList("event_date"))
        .function("linear")
        .origin(System.currentTimeMillis())
        .offset(12 * 60 * 60)
        .decay(0.5)
        .scale(7 * 24 * 60 * 60)
        .build();

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

const ranker = {
  name: "event_relevance",
  input_field_names: ["event_date"],
  type: FunctionType.RERANK,
  params: {
    reranker: "decay",
    function: "linear",
    origin: new Date(2025, 1, 15).getTime(),
    offset: 12 * 60 * 60,
    decay: 0.5,
    scale: 7 * 24 * 60 * 60,
  },
};

// go

# restful

Menerapkan ke pencarian vektor standar

Setelah mendefinisikan perangking peluruhan Anda, Anda dapat menerapkannya selama operasi pencarian dengan mengopernya ke parameter ranker:

# Apply decay ranker to vector search
result = milvus_client.search(
    collection_name,
    data=[your_query_vector],              # Replace with your query vector
    anns_field="dense",                   # Vector field to search
    limit=10,                             # Number of results
    output_fields=["title", "venue", "event_date"], # Fields to return
    ranker=ranker,                        # Apply the decay ranker
    consistency_level="Strong"
)

import io.milvus.v2.common.ConsistencyLevel;
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;

SearchReq searchReq = SearchReq.builder()
        .collectionName(COLLECTION_NAME)
        .data(Collections.singletonList(new FloatVec(embedding)))
        .annsField("dense")
        .limit(10)
        .outputFields(Arrays.asList("title", "venue", "event_date"))
        .functionScore(FunctionScore.builder()
                .addFunction(ranker)
                .build())
        .consistencyLevel(ConsistencyLevel.STRONG)
        .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: ["title", "venue", "event_date"],
  rerank: ranker,
  consistency_level: "Strong",
});

// go

# restful