Peluruhan GaussianCompatible with Milvus 2.6.x

Peluruhan Gaussian, juga dikenal sebagai peluruhan normal, menciptakan penyesuaian yang terasa paling alami pada hasil pencarian Anda. Seperti penglihatan manusia yang secara bertahap mengabur seiring jarak, peluruhan Gaussian menciptakan kurva berbentuk lonceng yang secara perlahan mengurangi relevansi saat item menjauh dari titik ideal Anda. Pendekatan ini sangat ideal jika Anda menginginkan peluruhan yang seimbang yang tidak menghukum item yang berada di luar kisaran yang Anda inginkan, tetapi masih secara signifikan mengurangi relevansi item yang jauh.

Tidak seperti pemeringkat peluruhan lainnya:

• Peluruhan eksponensial turun tajam pada awalnya, menciptakan penalti awal yang lebih kuat

• Peluruhan linier menurun dengan kecepatan konstan hingga mencapai nol, menciptakan batas yang jelas

Peluruhan Gaussian memberikan pendekatan yang lebih seimbang dan intuitif yang terasa alami bagi pengguna.

Kapan menggunakan peluruhan Gaussian

Peluruhan Gaussian sangat efektif untuk:

Kasus Penggunaan	Contoh	Mengapa Gaussian Bekerja dengan Baik
Pencarian berbasis lokasi	Pencari restoran, pencari lokasi toko	Meniru persepsi alami manusia tentang relevansi jarak
Rekomendasi konten	Saran artikel berdasarkan tanggal publikasi	Penurunan relevansi secara bertahap seiring bertambahnya usia konten
Daftar produk	Item dengan harga mendekati target	Penurunan relevansi yang mulus saat harga menyimpang dari target
Pencocokan keahlian	Menemukan profesional dengan pengalaman yang relevan	Penilaian relevansi pengalaman yang seimbang

Jika aplikasi Anda memerlukan perasaan alami penurunan relevansi tanpa hukuman yang keras atau batas waktu yang ketat, peluruhan Gaussian mungkin merupakan pilihan terbaik Anda.

Prinsip kurva lonceng

Peluruhan Gaussian menciptakan kurva berbentuk lonceng yang halus yang secara bertahap mengurangi relevansi seiring bertambahnya jarak dari titik ideal. Dinamai sesuai dengan nama matematikawan Carl Friedrich Gauss, distribusi ini sering muncul di alam dan statistik, yang menjelaskan mengapa distribusi ini terasa sangat intuitif bagi persepsi manusia.

Peluruhan Gaussian

Grafik di atas menunjukkan bagaimana peluruhan Gaussian akan memengaruhi peringkat restoran di aplikasi pencarian seluler:

• origin (0 km): Lokasi Anda saat ini, di mana relevansi berada pada titik maksimum (1,0).

• offset (±300 m): "Zona nilai sempurna" di sekitar Anda-semua restoran dalam jarak 300 meter memiliki nilai relevansi penuh (1,0), sehingga memastikan bahwa pilihan yang sangat dekat tidak akan dihukum karena perbedaan jarak yang kecil.

• scale (±2 km): Jarak di mana relevansi turun ke nilai pembusukan-restoran yang berjarak tepat 2 kilometer memiliki nilai relevansi yang dikurangi setengahnya (0,5).

• decay (0.5): Skor pada jarak skala-parameter ini pada dasarnya mengontrol seberapa cepat skor berkurang seiring dengan jarak.

Seperti yang dapat Anda lihat dari kurva, restoran yang berjarak lebih dari 2 kilometer terus mengalami penurunan relevansi, tetapi tidak pernah mencapai nol. Bahkan restoran yang berjarak 4-5 kilometer pun tetap memiliki relevansi minimal, sehingga restoran yang sangat baik tetapi jauh masih muncul di hasil Anda (meskipun peringkatnya lebih rendah).

Perilaku ini meniru bagaimana orang secara alami berpikir tentang relevansi jarak-tempat yang dekat lebih disukai, tetapi kita bersedia melakukan perjalanan lebih jauh untuk pilihan yang luar biasa.

Rumus

Rumus matematika untuk menghitung skor peluruhan Gaussian adalah:

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

Di mana:

$$\sigma^2 = -\frac{scale^2}{2 \cdot \ln(decay)}$$

Menjabarkannya dalam bahasa yang sederhana:

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

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

3. Kuadratkan jarak yang telah disesuaikan ini: $(jarak_yang_disesuaikan)^2$ 2

4. Bagilah dengan $2σ22\sigma^2$ 2, yang dihitung dari parameter skala dan peluruhan Anda

5. Ambil eksponen negatif, yang memberi Anda nilai antara 0 dan 1: $\exp(-nilai)$

Perhitungan $σ2\sigma^{2}$ 2 mengubah parameter skala dan peluruhan Anda menjadi deviasi standar kuadrat untuk distribusi Gaussian. Inilah yang memberikan bentuk lonceng yang khas pada fungsi ini.

Menggunakan peluruhan Gaussian

Peluruhan Gaussian 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, distance dalam meter dari pengguna), buat pemeringkat peluruhan Gaussian:

from pymilvus import Function, FunctionType

# Create a Gaussian decay ranker for location-based restaurant search
ranker = Function(
    name="restaurant_distance_decay",     # Function identifier
    input_field_names=["distance"],       # Numeric field for distance in meters
    function_type=FunctionType.RERANK,    # Function type. Must be RERANK
    params={
        "reranker": "decay",              # Specify decay reranker
        "function": "gauss",              # Choose Gaussian decay
        "origin": 0,                      # Your current location (0 meters)
        "offset": 300,                    # 300m no-decay zone
        "decay": 0.5,                     # Half score at scale distance
        "scale": 2000                     # 2 km scale (2000 meters)
    }
)

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

DecayRanker ranker = DecayRanker.builder()
        .name("restaurant_distance_decay")
        .inputFieldNames(Collections.singletonList("distance"))
        .function("gauss")
        .origin(0)
        .offset(300)
        .decay(0.5)
        .scale(2000)
        .build();

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

const ranker = {
  name: "restaurant_distance_decay",
  input_field_names: ["distance"],
  function_type: FunctionType.RERANK,
  params: {
    reranker: "decay",
    function: "gauss",
    origin: 0,
    offset: 300,
    decay: 0.5,
    scale: 2000,
  },
};

// go

# restful

Menerapkan ke pencarian vektor standar

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

# Apply decay ranker to restaurant 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=["name", "cuisine", "distance"],  # 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.EmbeddedText;

SearchReq searchReq = SearchReq.builder()
        .collectionName(COLLECTION_NAME)
        .data(Collections.singletonList(new EmbeddedText("italian restaurants")))
        .annsField("vector_field")
        .limit(10)
        .outputFields(Arrays.asList("name", "cuisine", "distance"))
        .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: ["name", "cuisine", "distance"],
  rerank: ranker,
  consistency_level: "Strong",
});

// go

# restful