• О компании Milvus
  • Начать работу
  • Понятия
  • Руководство пользователя
  • Импорт данных
  • Инструменты искусственного интеллекта
  • Руководство по администрированию
  • Инструменты
  • Интеграции
  • Учебные материалы
  • Часто задаваемые вопросы
  • API Reference

Взвешенный ранжировщик

Weighted Ranker интеллектуально объединяет и ранжирует результаты из нескольких путей поиска, присваивая каждому из них различные веса важности. Подобно тому, как опытный повар гармонично сочетает различные ингредиенты для создания идеального блюда, Weighted Ranker уравновешивает различные результаты поиска, чтобы предоставить наиболее релевантные комбинированные результаты. Этот подход идеально подходит при поиске по нескольким векторным полям или модальностям, когда определенные поля должны вносить более значительный вклад в окончательный рейтинг, чем другие.

Когда использовать «Взвешенный ранжировщик»

Взвешенный ранжировщик специально разработан для гибридных сценариев поиска, в которых необходимо объединить результаты из нескольких векторных путей поиска. Он особенно эффективен в следующих случаях:

Пример использования

Пример

Почему Weighted Ranker работает так хорошо

Поиск в электронной коммерции

Поиск товаров с учетом сходства изображений и текстовых описаний

Позволяет розничным продавцам уделять приоритетное внимание визуальному сходству при поиске модных товаров, одновременно подчеркивая важность текстовых описаний для технических товаров

Поиск медиаконтента

Поиск видео с использованием как визуальных характеристик, так и аудиотранскриптов

Обеспечивает баланс между важностью визуального контента и устного диалога в зависимости от намерения запроса

Поиск документов

Поиск корпоративных документов с использованием нескольких вложений для разных разделов

Присваивает более высокий вес встраиванию заголовков и аннотаций, при этом учитывая встраивание полного текста

Если вашему гибридному поисковому приложению требуется объединять несколько путей поиска с одновременным управлением их относительной значимостью, Weighted Ranker — ваш идеальный выбор.

Механизм работы Weighted Ranker

Основной рабочий процесс стратегии WeightedRanker выглядит следующим образом:

  1. Сбор оценок поиска: сбор результатов и оценок по каждому пути векторного поиска (score_1, score_2).

  2. Нормализация оценок: каждый поиск может использовать разные метрики сходства, что приводит к различному распределению оценок. Например, использование внутреннего произведения (IP) в качестве метрики сходства может привести к оценкам в диапазоне от [−∞,+∞], тогда как использование евклидова расстояния (L2) приводит к оценкам в диапазоне от [0,+∞]. Поскольку диапазоны оценок для разных поисков различаются и их нельзя напрямую сравнивать, необходимо нормализовать оценки по каждому пути поиска. Обычно применяется функция « arctan » для преобразования оценок в диапазон [0, 1] (score_1_normalized, score_2_normalized). Оценки, ближе к 1, указывают на более высокое сходство.

  3. Присвоение весов: на основе важности, присвоенной различным векторным полям, нормализованным оценкам (score_1_normalized, score_2_normalized) присваиваются веса (wi). Веса каждого пути должны находиться в диапазоне [0, 1]. Результирующие взвешенные оценки — это score_1_weighted и score_2_weighted.

  4. Объединение оценок: взвешенные оценки (score_1_weighted, score_2_weighted) ранжируются от наибольшей к наименьшей, чтобы сформировать окончательный набор оценок (score_final).

Weighted Ranker Ранжирование с учетом весов

Пример использования WeightedRanker

В данном примере демонстрируется мультимодальный гибридный поиск (topK=5) с использованием изображений и текста, а также показано, как стратегия WeightedRanker переранжирует результаты двух поисков с использованием нейронных сетей.

  • Результаты поиска с использованием ANN по изображениям (topK=5):

    ID

    Оценка (изображение)

    101

    0,92

    203

    0,88

    150

    0,85

    198

    0,83

    175

    0,8

  • Результаты поиска с помощью нейронной сети по текстам (topK=5):

    ID

    Оценка (текст)

    198

    0,91

    101

    0,87

    110

    0,85

    175

    0,82

    250

    0,78

  • Используйте WeightedRanker для присвоения весов результатам поиска по изображениям и тексту. Предположим, что вес для поиска по изображениям с помощью нейронной сети составляет 0,6, а вес для поиска по тексту — 0,4.

    ID

    Оценка (изображение)

    Оценка (текст)

    Взвешенный балл

    101

    0,92

    0,87

    0,6 × 0,92 + 0,4 × 0,87 = 0,90

    203

    0,88

    Н/Д

    0,6 × 0,88 + 0,4 × 0 = 0,528

    150

    0,85

    Н/Д

    0,6 × 0,85 + 0,4 × 0 = 0,51

    198

    0,83

    0,91

    0,6 × 0,83 + 0,4 × 0,91 = 0,86

    175

    0,80

    0,82

    0,6 × 0,80 + 0,4 × 0,82 = 0,81

    110

    Нет на изображении

    0,85

    0,6 × 0 + 0,4 × 0,85 = 0,34

    250

    Отсутствует на изображении

    0,78

    0,6 × 0 + 0,4 × 0,78 = 0,312

  • Окончательные результаты после переранжирования (topK=5):

    Ранг

    ID

    Итоговый балл

    1

    101

    0,90

    2

    198

    0,86

    3

    175

    0,81

    4

    203

    0,528

    5

    150

    0,51

Использование стратегии «Weighted Ranker»

При использовании стратегии «Взвешенный ранжировщик» необходимо ввести значения весов. Количество вводимых значений весов должно соответствовать количеству базовых запросов поиска ANN в гибридном поиске. Вводимые значения весов должны находиться в диапазоне [0,1], причем значения, ближе к 1, указывают на большую важность.

Создание «Взвешенного ранжера»

Например, предположим, что в гибридном поиске имеется два базовых запроса ANN: текстовый поиск и поиск по изображениям. Если текстовый поиск считается более важным, ему следует присвоить больший вес.

В Milvus версии 2.6.x и более поздних можно настраивать стратегии переранжирования непосредственно через API « Function ». Если вы используете более раннюю версию (до v2.6.0), инструкции по настройке см. в документации по переранжированию.

from pymilvus import Function, FunctionType

rerank = Function(
    name="weight",
    input_field_names=[], # Must be an empty list
    function_type=FunctionType.RERANK,
    params={
        "reranker": "weighted", 
        "weights": [0.1, 0.9],
        "norm_score": True  # Optional
    }
)
import io.milvus.common.clientenum.FunctionType;
import io.milvus.v2.service.collection.request.CreateCollectionReq;

CreateCollectionReq.Function rerank = CreateCollectionReq.Function.builder()
                .name("weight")
                .functionType(FunctionType.RERANK)
                .param("reranker", "weighted")
                .param("weights", "[0.1, 0.9]")
                .param("norm_score", "true")
                .build();
import "github.com/milvus-io/milvus/client/v3/entity"

rerank := entity.NewFunction().
    WithName("weight").
    WithType(entity.FunctionTypeRerank).
    WithInputFields().
    WithParam("reranker", "weighted").
    WithParam("weights", "[0.1, 0.9]").
    WithParam("norm_score", "true")
use milvus::v2::prelude::*;
use std::collections::HashMap;

let rerank = Function::new()
    .name("weight")
    .function_type(FunctionType::Rerank)
    .input_fields(Vec::<String>::new())
    .params(HashMap::from([
        ("reranker".into(), "weighted".into()),
        ("weights".into(), "[0.1, 0.9]".into()),
        ("norm_score".into(), "true".into()),
    ]));
#include <memory>
#include "milvus/MilvusClientV2.h"

auto rerank = std::make_shared<milvus::Function>("weight", milvus::FunctionType::RERANK);
rerank->AddParam("reranker", "weighted");
rerank->AddParam("weights", "[0.1, 0.9]");
rerank->AddParam("norm_score", "true");
import { FunctionType } from '@zilliz/milvus2-sdk-node';

const rerank = {
    name: "weight",
    input_field_names: [],
    type: FunctionType.RERANK,
    params: {
        reranker: "weighted",
        weights: [0.1, 0.9],
        norm_score: true
    }
};
using Milvus.Client.V2;

// Note: defining a weighted rerank function with FunctionSchema params
// (reranker/weights/norm_score) is not yet supported in milvus-sdk-csharp as of v3.0.0
// (FunctionSchema.Params cannot be populated externally). Use WeightedReranker instead.
# Restful
export rerank='{
  "name": "weight",
  "inputFieldNames": [],
  "functionType": "RERANK",
  "params": {
    "reranker": "weighted",
    "weights": "[0.1, 0.9]",
    "norm_score": "true"
  }
}'

Параметр

Обязателен?

Описание

Значение/Пример

name

Да

Уникальный идентификатор данной функции

"weight"

input_field_names

Да

Список векторных полей, к которым будет применена функция (должен быть пустым для Weighted Ranker)

[]

function_type

Да

Тип вызываемой функции; используйте « RERANK » для указания стратегии переранжирования

FunctionType.RERANK

params.reranker

Да

Указывает метод переранжирования, который следует использовать.

Для использования Weighted Ranker необходимо установить значение « weighted ».

"weighted"

params.weights

Да

Массив весов, соответствующих каждому пути поиска; значения ∈ [0,1].

Подробности см. в разделе «Механизм работы Weighted Ranker».

[0.1, 0.9]

params.norm_score

Нет

Укажите, следует ли нормализовать исходные оценки (с помощью arctan) перед взвешиванием.

Подробности см. в разделе «Механизм взвешенного ранжера».

True

Weighted Ranker разработан специально для операций гибридного поиска, сочетающих несколько векторных полей. При выполнении гибридного поиска необходимо указать веса для каждого пути поиска:

from pymilvus import MilvusClient, AnnSearchRequest

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

# Assume you have a collection setup

# Define text vector search request
text_search = AnnSearchRequest(
    data=["modern dining table"],
    anns_field="text_vector",
    param={},
    limit=10
)

# Define image vector search request
image_search = AnnSearchRequest(
    data=[image_embedding],  # Image embedding vector
    anns_field="image_vector",
    param={},
    limit=10
)

# Apply Weighted Ranker to product hybrid search
# Text search has 0.8 weight, image search has 0.3 weight
hybrid_results = milvus_client.hybrid_search(
    collection_name,
    [text_search, image_search],  # Multiple search requests
    ranker=rerank,  # Apply the weighted ranker
    limit=10,
    output_fields=["product_name", "price", "category"]
)
import io.milvus.v2.client.ConnectConfig;
import io.milvus.v2.client.MilvusClientV2;
import io.milvus.v2.service.vector.request.AnnSearchReq;
import io.milvus.v2.service.vector.request.HybridSearchReq;
import io.milvus.v2.service.vector.response.SearchResp;
import io.milvus.v2.service.vector.request.data.EmbeddedText;
import io.milvus.v2.service.vector.request.data.FloatVec;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

MilvusClientV2 client = new MilvusClientV2(ConnectConfig.builder()
        .uri("http://localhost:19530")
        .token("root:Milvus")
        .build());

List<AnnSearchReq> searchRequests = new ArrayList<>();
searchRequests.add(AnnSearchReq.builder()
        .vectorFieldName("text_vector")
        .vectors(Collections.singletonList(new EmbeddedText("modern dining table")))
        .limit(10)
        .build());
searchRequests.add(AnnSearchReq.builder()
        .vectorFieldName("image_vector")
        .vectors(Collections.singletonList(new FloatVec(imageEmbedding)))
        .limit(10)
        .build());

HybridSearchReq hybridSearchReq = HybridSearchReq.builder()
                .collectionName(COLLECTION_NAME)
                .searchRequests(searchRequests)
                .ranker(rerank)
                .limit(10)
                .outputFields(Arrays.asList("product_name", "price", "category"))
                .build();
SearchResp searchResp = client.hybridSearch(hybridSearchReq);
import (
    "context"
    "log"

    "github.com/milvus-io/milvus/client/v3/entity"
    "github.com/milvus-io/milvus/client/v3/milvusclient"
)

ctx := context.Background()

// Define two ANN sub-search requests
textSearch := milvusclient.NewAnnRequest("text_vector", 10, []entity.Vector{textEmbedding}...).WithSearchParam("metric_type", "COSINE")
imageSearch := milvusclient.NewAnnRequest("image_vector", 10, []entity.Vector{imageEmbedding}...).WithSearchParam("metric_type", "IP")

// Apply Weighted Ranker: text search has 0.8 weight, image search has 0.3 weight
rerank := milvusclient.NewWeightedReranker([]float64{0.8, 0.3})

hybridResults, err := cli.HybridSearch(ctx, milvusclient.NewHybridSearchOption(collectionName, 10, textSearch, imageSearch).
    WithReranker(rerank).
    WithOutputFields("product_name", "price", "category"))
if err != nil {
    log.Fatal(err)
}
use milvus::v2::prelude::*;

// Define two ANN sub-search requests
let text_search = SubSearchRequest::builder()
    .vector_field("text_vector")
    .vectors(SearchVectors::Float(vec![text_embedding]))
    .metric_type(MetricType::Cosine)
    .limit(10)
    .build()?;
let image_search = SubSearchRequest::builder()
    .vector_field("image_vector")
    .vectors(SearchVectors::Float(vec![image_embedding]))
    .metric_type(MetricType::Ip)
    .limit(10)
    .build()?;

// Apply Weighted Ranker: text search has 0.8 weight, image search has 0.3 weight
let rerank = WeightedRerank::new().weights(vec![0.8, 0.3]);

let response = client
    .hybrid_search(
        HybridSearchRequest::builder()
            .collection_name(collection_name)
            .sub_requests(vec![text_search, image_search])
            .rerank(rerank)
            .limit(10)
            .output_fields(["product_name", "price", "category"])
            .build()?,
    )
    .await?;
#include <iostream>
#include <memory>
#include <utility>
#include "milvus/MilvusClientV2.h"

auto text_search = milvus::SubSearchRequest()
                    .WithLimit(10)
                    .WithAnnsField("text_vector")
                    .AddEmbeddedText("modern dining table");

auto image_search = milvus::SubSearchRequest()
                    .WithLimit(10)
                    .WithAnnsField("image_vector")
                    .AddFloatVector(image_embedding);

auto request = milvus::HybridSearchRequest()
                    .WithCollectionName(collection_name)
                    .WithLimit(10)
                    .AddSubRequest(std::make_shared<milvus::SubSearchRequest>(std::move(text_search)))
                    .AddSubRequest(std::make_shared<milvus::SubSearchRequest>(std::move(image_search)))
                    .WithRerank(rerank)
                    .AddOutputField("product_name")
                    .AddOutputField("price")
                    .AddOutputField("category");

milvus::SearchResponse response;
auto status = client->HybridSearch(request, response);
if (!status.IsOk()) {
    std::cout << status.Message() << std::endl;
}
import { MilvusClient } from "@zilliz/milvus2-sdk-node";

const milvusClient = new MilvusClient({
  address: "http://localhost:19530",
  token: "root:Milvus",
});

const text_search = {
  data: ["modern dining table"],
  anns_field: "text_vector",
  params: {},
};

const image_search = {
  data: [image_embedding],
  anns_field: "image_vector",
  params: {},
};

const search = await milvusClient.search({
  collection_name: collection_name,
  limit: 10,
  data: [text_search, image_search],
  rerank: rerank,
  output_fields: ["product_name", "price", "category"],
});
using Milvus.Client.V2;
using Milvus.Client.V2.Requests.Collection;
using Milvus.Client.V2.Requests.Dml;
using Milvus.Client.V2.Requests.Dql;
using Milvus.Client.V2.Requests.Index;
using Milvus.Client.V2.Types;

var client = new MilvusClientV2(new ConnectConfig
{
    Uri = "http://localhost:19530",
    ApiKey = "root:Milvus"
});

// Define text vector search request
var textSearch = new AnnSearchReq
{
    VectorFieldName = "text_vector",
    Texts = new[] { "modern dining table" },
    Limit = 10
};

// Define image vector search request
var imageSearch = new AnnSearchReq
{
    VectorFieldName = "image_vector",
    Vectors = new[] { new ReadOnlyMemory<float>(imageEmbedding) },  // Image embedding vector
    Limit = 10
};

// Apply Weighted Ranker to product hybrid search
// Text search has 0.8 weight, image search has 0.3 weight
var hybridResults = await client.HybridSearchAsync(new HybridSearchReq
{
    CollectionName = collectionName,
    SearchRequests = new[] { textSearch, imageSearch },  // Multiple search requests
    Reranker = rerank,  // Apply the weighted ranker
    Limit = 10,
    Parameters = new SearchParameters { OutputFields = { "product_name", "price", "category" } }
});
# restful
export CLUSTER_ENDPOINT="http://localhost:19530"
export TOKEN="root:Milvus"

curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/entities/hybrid_search" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
--header "Request-Timeout: 10" \
--data "{
    \"collectionName\": \"${COLLECTION_NAME}\",
    \"search\": [
        {
            \"annsField\": \"text_vector\",
            \"data\": [\"modern dining table\"],
            \"params\": { \"metric_type\": \"COSINE\" },
            \"limit\": 10
        },
        {
            \"annsField\": \"image_vector\",
            \"data\": [${IMAGE_EMBEDDING}],
            \"params\": { \"metric_type\": \"IP\" },
            \"limit\": 10
        }
    ],
    \"rerank\": ${rerank},
    \"limit\": 10,
    \"outputFields\": [\"product_name\", \"price\", \"category\"]
}"

Дополнительную информацию о гибридном поиске см. в разделе «Гибридный поиск по нескольким векторам».

ПереведеноDeepL

Попробуйте Managed Milvus бесплатно

Zilliz Cloud работает без проблем, поддерживается Milvus и в 10 раз быстрее.

Начать
Обратная связь

Была ли эта страница полезной?