Função BM25
A função BM25 permite a pesquisa de texto completo, transformando o texto em bruto em vectores esparsos e pontuando os documentos com base na relevância lexical. Aplica a correspondência baseada em termos e a ponderação sensível à frequência para apoiar a recuperação eficiente de documentos de texto que correspondem aos termos da consulta.
Como uma função de texto local, a função BM25 é executada no Milvus e não requer inferência de modelos ou integrações externas. Fornece um mecanismo de recuperação determinístico e transparente para cenários de pesquisa baseados em texto.
Como funciona o BM25
O algoritmo BM25 é um algoritmo de pontuação de relevância baseado em termos, amplamente utilizado na recuperação de textos completos. Em Milvus, o BM25 é implementado como um pipeline de recuperação esparso que converte o texto em representações de peso de termo e recupera os K documentos principais usando índices esparsos distribuídos.
O fluxo de trabalho global consiste em dois caminhos simétricos: ingestão de documentos e processamento de texto de consulta, que partilham a mesma lógica de análise de texto.
Ingestão de documentos: Do texto à representação esparsa
Quando um documento é inserido, o seu texto em bruto é primeiro processado por um analisador, que o converte em termos individuais.
Por exemplo, o documento:
"We are loving Milvus!"
pode ser analisado nos seguintes termos:
["we", "love", "milvus"]
Cada documento é então representado como uma representação de frequência de termos (TF), que regista o número de vezes que cada termo aparece no documento. Por exemplo:
{
"we": 1,
"love": 1,
"milvus": 1
}
Ao mesmo tempo, o Milvus actualiza as estatísticas ao nível do corpus, incluindo:
a frequência de documentos (DF) de cada termo
o comprimento médio do documento
listas de lançamento que mapeiam cada termo para os documentos que o contêm
A representação TF do documento é inserida em embeddings esparsos, onde os lançamentos de termos são particionados entre nós para uma recuperação escalável.
Processo de texto de consulta: Aplicar a ponderação IDF
Quando é emitida uma consulta baseada em texto, esta é processada pelo mesmo analisador utilizado durante a ingestão de documentos, garantindo uma segmentação consistente dos termos.
Por exemplo, a consulta:
"who loves Milvus?"
pode ser analisada em:
["who", "love", "milvus"]
Para cada termo da consulta, o Milvus procura a sua frequência inversa de documentos (IDF) nas estatísticas do corpus. A IDF reflecte o grau de informação de um termo em todo o conjunto de dados: os termos mais raros recebem pesos mais elevados, enquanto os termos comuns recebem pesos mais baixos.
Conceptualmente, isto produz um conjunto de termos de consulta ponderados por IDF, tais como:
{
"who": 0.1,
"love": 0.5,
"milvus": 1.2
}
Pontuação BM25 e recuperação do top K
O BM25 classifica os documentos calculando uma pontuação de relevância com base nos termos de consulta correspondentes. A pontuação é efectuada ao nível do termo e agregada ao nível do documento.
Pontuação ao nível do termo
Para cada termo de consulta que aparece num documento, o BM25 calcula uma pontuação ao nível do termo:
term_score =
IDF(term) ×
TF_boost(term, document, k1) ×
length_normalization(document, b)
Onde:
IDF(termo) reflecte a raridade do termo na coleção
TF_boost(..., k1) aumenta com a frequência do termo mas satura à medida que a frequência aumenta
length_normalization(..., b) ajusta a pontuação com base no comprimento do documento
Pontuação ao nível do documento e recuperação Top-K
A pontuação final do documento é a soma das pontuações ao nível do termo para todos os termos da consulta correspondentes:
document_score =
sum of term_score over all matched query terms
Os documentos são classificados por suas pontuações finais e os K documentos com as pontuações mais altas são retornados.
Antes de começar
Antes de utilizar a função BM25, planeie o esquema da coleção para garantir que suporta a pesquisa lexical de texto integral:
Um campo de texto para conteúdo em bruto
A sua coleção deve incluir um campo
VARCHARpara armazenar texto em bruto. Este campo é a fonte do texto que será processado para a pesquisa de texto integral.Um analisador para o campo de texto
O campo de texto tem de ter um analisador ativado. O analisador define a forma como o texto é tokenizado e normalizado antes de a relevância lexical ser calculada pela função BM25.
Por predefinição, o Milvus fornece um analisador incorporado que tokeniza o texto com base no espaço em branco e na pontuação. Se a sua aplicação requer um comportamento personalizado de tokenização ou normalização, pode definir um analisador personalizado. Consulte Escolha o analisador certo para seu caso de uso para obter detalhes.
Um vetor esparso para a saída do BM25
Sua coleção deve incluir um campo
SPARSE_FLOAT_VECTORpara armazenar as representações esparsas geradas pela função BM25. Esse campo é usado para indexação e recuperação durante a pesquisa de texto completo.
Após estas considerações ao nível do esquema terem sido definidas, proceda à criação da coleção e utilize a função BM25.
Passo 1: Criar uma coleção com uma função BM25
Para utilizar a função BM25, tem de a definir ao criar a coleção. A função torna-se parte do esquema da coleção e é aplicada automaticamente durante a inserção e pesquisa de dados.
Definir campos de esquema
O esquema da coleção deve incluir pelo menos três campos obrigatórios:
Campo primário: Identifica de forma única cada entidade na coleção.
Campo de texto (
VARCHAR): Armazena documentos de texto em bruto. Deve definirenable_analyzer=Truepara que o Milvus possa processar o texto para a classificação de relevância BM25. Por defeito, o Milvus utiliza ostandardpara a análise de texto. Para configurar um analisador diferente, consulte Visão geral do analisador.Campo de vetor esparso (
SPARSE_FLOAT_VECTOR): Armazena embeddings esparsos gerados automaticamente pela função BM25.
from pymilvus import MilvusClient, DataType, Function, FunctionType
client = MilvusClient(
uri="http://localhost:19530",
token="root:Milvus"
)
schema = client.create_schema()
schema.add_field(field_name="id", datatype=DataType.INT64, is_primary=True, auto_id=True) # Primary field
schema.add_field(field_name="text", datatype=DataType.VARCHAR, max_length=1000, enable_analyzer=True) # Text field
schema.add_field(field_name="sparse", datatype=DataType.SPARSE_FLOAT_VECTOR) # Sparse vector field; no dim required for sparse vectors
import io.milvus.v2.common.DataType;
import io.milvus.v2.service.collection.request.AddFieldReq;
import io.milvus.v2.service.collection.request.CreateCollectionReq;
CreateCollectionReq.CollectionSchema schema = CreateCollectionReq.CollectionSchema.builder()
.build();
schema.addField(AddFieldReq.builder()
.fieldName("id")
.dataType(DataType.Int64)
.isPrimaryKey(true)
.autoID(true)
.build());
schema.addField(AddFieldReq.builder()
.fieldName("text")
.dataType(DataType.VarChar)
.maxLength(1000)
.enableAnalyzer(true)
.build());
schema.addField(AddFieldReq.builder()
.fieldName("sparse")
.dataType(DataType.SparseFloatVector)
.build());
import (
"context"
"fmt"
"github.com/milvus-io/milvus/client/v2/column"
"github.com/milvus-io/milvus/client/v2/entity"
"github.com/milvus-io/milvus/client/v2/index"
"github.com/milvus-io/milvus/client/v2/milvusclient"
)
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
milvusAddr := "http://localhost:19530"
token := "root:Milvus"
client, err := milvusclient.New(ctx, &milvusclient.ClientConfig{
Address: milvusAddr,
APIKey: token
})
if err != nil {
fmt.Println(err.Error())
// handle error
}
defer client.Close(ctx)
schema := entity.NewSchema()
schema.WithField(entity.NewField().
WithName("id").
WithDataType(entity.FieldTypeInt64).
WithIsPrimaryKey(true).
WithIsAutoID(true),
).WithField(entity.NewField().
WithName("text").
WithDataType(entity.FieldTypeVarChar).
WithEnableAnalyzer(true).
WithMaxLength(1000),
).WithField(entity.NewField().
WithName("sparse").
WithDataType(entity.FieldTypeSparseVector),
)
import { MilvusClient, DataType } from "@zilliz/milvus2-sdk-node";
const address = "http://localhost:19530";
const token = "root:Milvus";
const client = new MilvusClient({address, token});
const schema = [
{
name: "id",
data_type: DataType.Int64,
is_primary_key: true,
},
{
name: "text",
data_type: "VarChar",
enable_analyzer: true,
enable_match: true,
max_length: 1000,
},
{
name: "sparse",
data_type: DataType.SparseFloatVector,
},
];
console.log(res.results)
export schema='{
"autoId": true,
"enabledDynamicField": false,
"fields": [
{
"fieldName": "id",
"dataType": "Int64",
"isPrimary": true
},
{
"fieldName": "text",
"dataType": "VarChar",
"elementTypeParams": {
"max_length": 1000,
"enable_analyzer": true
}
},
{
"fieldName": "sparse",
"dataType": "SparseFloatVector"
}
]
}'
Definir a função BM25
A função BM25 converte texto tokenizado em vetores esparsos que suportam a pontuação BM25.
Defina a função e adicione-a ao seu esquema:
bm25_function = Function(
name="text_bm25_emb", # Function name
input_field_names=["text"], # Name of the VARCHAR field containing raw text data
output_field_names=["sparse"], # Name of the SPARSE_FLOAT_VECTOR field reserved to store generated embeddings
function_type=FunctionType.BM25, # Set to `BM25`
)
schema.add_function(bm25_function)
import io.milvus.common.clientenum.FunctionType;
import io.milvus.v2.service.collection.request.CreateCollectionReq.Function;
import java.util.*;
schema.addFunction(Function.builder()
.functionType(FunctionType.BM25)
.name("text_bm25_emb")
.inputFieldNames(Collections.singletonList("text"))
.outputFieldNames(Collections.singletonList("sparse"))
.build());
function := entity.NewFunction().
WithName("text_bm25_emb").
WithInputFields("text").
WithOutputFields("sparse").
WithType(entity.FunctionTypeBM25)
schema.WithFunction(function)
const functions = [
{
name: 'text_bm25_emb',
description: 'bm25 function',
type: FunctionType.BM25,
input_field_names: ['text'],
output_field_names: ['sparse'],
params: {},
},
]；
export schema='{
"autoId": true,
"enabledDynamicField": false,
"fields": [
{
"fieldName": "id",
"dataType": "Int64",
"isPrimary": true
},
{
"fieldName": "text",
"dataType": "VarChar",
"elementTypeParams": {
"max_length": 1000,
"enable_analyzer": true
}
},
{
"fieldName": "sparse",
"dataType": "SparseFloatVector"
}
],
"functions": [
{
"name": "text_bm25_emb",
"type": "BM25",
"inputFieldNames": ["text"],
"outputFieldNames": ["sparse"],
"params": {}
}
]
}'
Configurar o índice
Depois de definir o esquema com os campos necessários e a função incorporada, configure o índice para a sua coleção.
index_params = client.prepare_index_params()
index_params.add_index(
field_name="sparse",
index_type="SPARSE_INVERTED_INDEX",
metric_type="BM25",
params={
"inverted_index_algo": "DAAT_MAXSCORE",
"bm25_k1": 1.2,
"bm25_b": 0.75
}
)
import io.milvus.v2.common.IndexParam;
Map<String,Object> params = new HashMap<>();
params.put("inverted_index_algo", "DAAT_MAXSCORE");
params.put("bm25_k1", 1.2);
params.put("bm25_b", 0.75);
List<IndexParam> indexes = new ArrayList<>();
indexes.add(IndexParam.builder()
.fieldName("sparse")
.indexType(IndexParam.IndexType.AUTOINDEX)
.metricType(IndexParam.MetricType.BM25)
.extraParams(params)
.build());
indexOption := milvusclient.NewCreateIndexOption("my_collection", "sparse",
index.NewAutoIndex(entity.MetricType(entity.BM25)))
.WithExtraParam("inverted_index_algo", "DAAT_MAXSCORE")
.WithExtraParam("bm25_k1", 1.2)
.WithExtraParam("bm25_b", 0.75)
const index_params = [
{
field_name: "sparse",
metric_type: "BM25",
index_type: "SPARSE_INVERTED_INDEX",
params: {
"inverted_index_algo": "DAAT_MAXSCORE",
"bm25_k1": 1.2,
"bm25_b": 0.75
}
},
];
export indexParams='[
{
"fieldName": "sparse",
"metricType": "BM25",
"indexType": "AUTOINDEX",
"params":{
"inverted_index_algo": "DAAT_MAXSCORE",
"bm25_k1": 1.2,
"bm25_b": 0.75
}
}
]'
Criar a coleção
Crie agora a coleção utilizando o esquema e os parâmetros de índice definidos:
client.create_collection(
collection_name='my_collection',
schema=schema,
index_params=index_params
)
import io.milvus.v2.service.collection.request.CreateCollectionReq;
CreateCollectionReq requestCreate = CreateCollectionReq.builder()
.collectionName("my_collection")
.collectionSchema(schema)
.indexParams(indexes)
.build();
client.createCollection(requestCreate);
err = client.CreateCollection(ctx,
milvusclient.NewCreateCollectionOption("my_collection", schema).
WithIndexOptions(indexOption))
if err != nil {
fmt.Println(err.Error())
// handle error
}
await client.create_collection(
collection_name: 'my_collection',
schema: schema,
index_params: index_params,
functions: functions
);
export CLUSTER_ENDPOINT="http://localhost:19530"
export TOKEN="root:Milvus"
curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/collections/create" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
--header "Request-Timeout: 10" \
-d "{
\"collectionName\": \"my_collection\",
\"schema\": $schema,
\"indexParams\": $indexParams
}"
Uma vez criada a coleção com uma função BM25, pode inserir texto e efetuar pesquisas lexicais com base na consulta de texto.
Passo 2: Inserir dados de texto na coleção
Depois de configurar a coleção e o índice, está pronto para inserir dados de texto. Neste processo, só precisa de fornecer o texto em bruto. A função BM25 que definimos anteriormente gera automaticamente o vetor esparso para cada entrada de texto.
client.insert('my_collection', [
{'text': 'information retrieval is a field of study.'},
{'text': 'information retrieval focuses on finding relevant information in large datasets.'},
{'text': 'data mining and information retrieval overlap in research.'},
])
import com.google.gson.Gson;
import com.google.gson.JsonObject;
import io.milvus.v2.service.vector.request.InsertReq;
Gson gson = new Gson();
List<JsonObject> rows = Arrays.asList(
gson.fromJson("{\"text\": \"information retrieval is a field of study.\"}", JsonObject.class),
gson.fromJson("{\"text\": \"information retrieval focuses on finding relevant information in large datasets.\"}", JsonObject.class),
gson.fromJson("{\"text\": \"data mining and information retrieval overlap in research.\"}", JsonObject.class)
);
client.insert(InsertReq.builder()
.collectionName("my_collection")
.data(rows)
.build());
// go
await client.insert({
collection_name: 'my_collection',
data: [
{'text': 'information retrieval is a field of study.'},
{'text': 'information retrieval focuses on finding relevant information in large datasets.'},
{'text': 'data mining and information retrieval overlap in research.'},
]);
curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/entities/insert" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
--header "Request-Timeout: 10" \
-d '{
"data": [
{"text": "information retrieval is a field of study."},
{"text": "information retrieval focuses on finding relevant information in large datasets."},
{"text": "data mining and information retrieval overlap in research."}
],
"collectionName": "my_collection"
}'
Passo 3: Pesquisar com consulta de texto
Uma vez inseridos os dados na sua coleção, pode efetuar pesquisas de texto completo utilizando consultas de texto em bruto. Milvus converte automaticamente a sua consulta num vetor esparso e classifica os resultados de pesquisa correspondentes utilizando o algoritmo BM25, e depois devolve os resultados topK (limit).
search_params = {
}
res = client.search(
collection_name='my_collection',
data=['whats the focus of information retrieval?'],
anns_field='sparse',
output_fields=['text'], # Fields to return in search results; sparse field cannot be output
limit=3,
search_params=search_params
)
print(res)
import io.milvus.v2.service.vector.request.SearchReq;
import io.milvus.v2.service.vector.request.data.EmbeddedText;
import io.milvus.v2.service.vector.response.SearchResp;
Map<String,Object> searchParams = new HashMap<>();
SearchResp searchResp = client.search(SearchReq.builder()
.collectionName("my_collection")
.data(Collections.singletonList(new EmbeddedText("whats the focus of information retrieval?")))
.annsField("sparse")
.topK(3)
.searchParams(searchParams)
.outputFields(Collections.singletonList("text"))
.build());
annSearchParams := index.NewCustomAnnParam()
resultSets, err := client.Search(ctx, milvusclient.NewSearchOption(
"my_collection", // collectionName
3, // limit
[]entity.Vector{entity.Text("whats the focus of information retrieval?")},
).WithConsistencyLevel(entity.ClStrong).
WithANNSField("sparse").
WithAnnParam(annSearchParams).
WithOutputFields("text"))
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)
fmt.Println("text: ", resultSet.GetColumn("text").FieldData().GetScalars())
}
await client.search(
collection_name: 'my_collection',
data: ['whats the focus of information retrieval?'],
anns_field: 'sparse',
output_fields: ['text'],
limit: 3,
)
curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/entities/search" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
--header "Request-Timeout: 10" \
--data-raw '{
"collectionName": "my_collection",
"data": [
"whats the focus of information retrieval?"
],
"annsField": "sparse",
"limit": 3,
"outputFields": [
"text"
],
"searchParams":{
"params":{}
}
}'