Pesquisa de intervalo

Uma pesquisa de intervalo melhora a relevância dos resultados de pesquisa ao restringir a distância ou a pontuação das entidades devolvidas dentro de um intervalo específico. Esta página ajuda-o a compreender o que é a pesquisa de intervalo e os procedimentos para efetuar uma pesquisa de intervalo.

Visão geral

Ao executar um pedido de Pesquisa de Intervalo, o Milvus utiliza os vectores mais semelhantes ao vetor de consulta dos resultados da Pesquisa ANN como centro, com o raio especificado no pedido de Pesquisa como o raio do círculo exterior e o filtro_de_intervalo como o raio do círculo interior para desenhar dois círculos concêntricos. Todos os vectores com pontuações de similaridade que se enquadram na região anular formada por estes dois círculos concêntricos serão devolvidos. Aqui, o filtro_de_intervalo pode ser definido como 0, indicando que todas as entidades dentro da pontuação de similaridade especificada (raio) serão retornadas.

Pesquisa de intervalo

O diagrama acima mostra que um pedido de pesquisa de intervalo tem dois parâmetros: raio e filtro_de_intervalo. Ao receber um pedido de pesquisa de intervalo, o Milvus faz o seguinte:

• Utiliza o tipo de métrica especificado(COSINE) para encontrar todas as incorporações vectoriais mais semelhantes ao vetor em questão.

• Filtra as incorporações vetoriais cujas distâncias ou pontuações para o vetor de consulta estão dentro do intervalo especificado pelos parâmetros radius e range_filter.

• Devolver as entidades top-K a partir das entidades filtradas.

A forma de definir o raio e o filtro_de_alcance varia com o tipo de métrica da pesquisa. A tabela a seguir lista os requisitos para definir esses dois parâmetros com diferentes tipos de métrica.

Tipo de métrica	Denotações	Requisitos para a definição de radius e range_filter
L2	Uma distância L2 mais pequena indica uma maior semelhança.	Para ignorar as incorporações de vetor mais semelhantes, certifique-se de que range_filter <= distância < radius
IP	Uma distância IP maior indica uma maior similaridade.	Para ignorar as incorporações de vetor mais semelhantes, certifique-se de que radius < distância <= range_filter
COSINE	Uma distância COSINE maior indica uma maior semelhança.	Para ignorar as incorporações vectoriais mais semelhantes, certifique-se de que radius < distância <= range_filter
JACCARD	Uma distância Jaccard menor indica uma maior similaridade.	Para ignorar as incorporações vectoriais mais semelhantes, certifique-se de que range_filter <= distância < radius
HAMMING	Uma distância de Hamming mais pequena indica uma maior semelhança.	Para ignorar as incorporações vectoriais mais semelhantes, certifique-se de que range_filter <= distância < radius

Exemplos

Esta secção demonstra como realizar uma pesquisa de intervalo. As solicitações de pesquisa nos trechos de código a seguir não carregam um tipo de métrica, indicando que o tipo de métrica padrão COSINE se aplica. Nesse caso, certifique-se de que o valor de raio seja menor que o valor de range_filter.

Nos trechos de código a seguir, defina radius como 0.4 e range_filter como 0.6 para que Milvus retorne todas as entidades cujas distâncias ou pontuações para o vetor de consulta estejam entre 0,4 e 0,6.

from pymilvus import MilvusClient

client = MilvusClient(
    uri="http://localhost:19530",
    token="root:Milvus"
)

query_vector = [0.3580376395471989, -0.6023495712049978, 0.18414012509913835, -0.26286205330961354, 0.9029438446296592]

res = client.search(
    collection_name="my_collection",
    data=[query_vector],
    limit=3,
    search_params={
        "params": {
            "radius": 0.4,
            "range_filter": 0.6
        }
    }
)

for hits in res:
    print("TopK results:")
    for hit in hits:
        print(hit)

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

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

FloatVec queryVector = new FloatVec(new float[]{0.3580376395471989f, -0.6023495712049978f, 0.18414012509913835f, -0.26286205330961354f, 0.9029438446296592f});
Map<String,Object> extraParams = new HashMap<>();
extraParams.put("radius", 0.4);
extraParams.put("range_filter", 0.6);
SearchReq searchReq = SearchReq.builder()
        .collectionName("my_collection")
        .data(Collections.singletonList(queryVector))
        .topK(5)
        .searchParams(extraParams)
        .build();

SearchResp searchResp = client.search(searchReq);

List<List<SearchResp.SearchResult>> searchResults = searchResp.getSearchResults();
for (List<SearchResp.SearchResult> results : searchResults) {
    System.out.println("TopK results:");
    for (SearchResp.SearchResult result : results) {
        System.out.println(result);
    }
}

// Output
// TopK results:
// SearchResp.SearchResult(entity={}, score=0.5975797, id=4)
// SearchResp.SearchResult(entity={}, score=0.46704385, id=5)

import (
    "context"
    "fmt"
    
    "github.com/milvus-io/milvus/client/v2/index"
    "github.com/milvus-io/milvus/client/v2/entity"
    "github.com/milvus-io/milvus/client/v2/milvusclient"
)

ctx, cancel := context.WithCancel(context.Background())
defer cancel()

milvusAddr := "localhost:19530"
client, err := milvusclient.New(ctx, &milvusclient.ClientConfig{
    Address: milvusAddr,
})
if err != nil {
    fmt.Println(err.Error())
    // handle error
}
defer client.Close(ctx)

queryVector := []float32{0.3580376395471989, -0.6023495712049978, 0.18414012509913835, -0.26286205330961354, 0.9029438446296592}

annParam := index.NewCustomAnnParam()
annParam.WithRadius(0.4)
annParam.WithRangeFilter(0.6)
resultSets, err := client.Search(ctx, milvusclient.NewSearchOption(
    "my_collection", // collectionName
    5,               // limit
    []entity.Vector{entity.FloatVector(queryVector)},
).WithConsistencyLevel(entity.ClStrong).
    WithANNSField("vector").
    WithAnnParam(annParam))
if err != nil {
    fmt.Println(err.Error())
    // handle error
}

for _, resultSet := range resultSets {
    fmt.Println("IDs: ", resultSet.IDs.FieldData().GetScalars())
    fmt.Println("Scores: ", resultSet.Scores)
}

import { MilvusClient, DataType } from "@zilliz/milvus2-sdk-node";

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

var query_vector = [0.3580376395471989, -0.6023495712049978, 0.18414012509913835, -0.26286205330961354, 0.9029438446296592]

res = await client.search({
    collection_name: "my_collection",
    data: [query_vector],
    limit: 5,
    params: {
        "radius": 0.4,
        "range_filter": 0.6
    }
})

export CLUSTER_ENDPOINT="http://localhost:19530"
export TOKEN="root:Milvus"

curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/entities/search" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
--header "Request-Timeout: 10" \
-d '{
    "collectionName": "my_collection",
    "data": [
        [0.3580376395471989, -0.6023495712049978, 0.18414012509913835, -0.26286205330961354, 0.9029438446296592]
    ],
    "annsField": "vector",
    "limit": 5,
    "searchParams": {
        "params": {
            "radius": 0.4,
            "range_filter": 0.6
        }
    }
}'
# {"code":0,"cost":0,"data":[]}