Vetor esparso

Os vectores esparsos são um método importante de representação de dados na recuperação de informações e no processamento de linguagem natural. Embora os vectores densos sejam populares pelas suas excelentes capacidades de compreensão semântica, os vectores esparsos fornecem frequentemente resultados mais precisos quando se trata de aplicações que requerem uma correspondência precisa de palavras-chave ou frases.

Visão geral

Um vetor esparso é uma representação especial de vectores de elevada dimensão em que a maioria dos elementos é zero e apenas algumas dimensões têm valores diferentes de zero. Esta caraterística torna os vectores esparsos particularmente eficazes no tratamento de dados de grande escala, de elevada dimensão, mas esparsos. As aplicações mais comuns incluem.

• Análise de texto: Representação de documentos como vectores de saco de palavras, em que cada dimensão corresponde a uma palavra e apenas as palavras que aparecem no documento têm valores diferentes de zero.

• Sistemas de recomendação: Matrizes de interação utilizador-item, em que cada dimensão representa a classificação de um utilizador para um determinado item, com a maioria dos utilizadores a interagir apenas com alguns itens.

• Processamento de imagens: Representação de caraterísticas locais, concentrando-se apenas em pontos-chave da imagem, o que resulta em vectores esparsos de elevada dimensão.

Como mostra o diagrama abaixo, os vectores densos são normalmente representados como matrizes contínuas em que cada posição tem um valor (por exemplo, [0.3, 0.8, 0.2, 0.3, 0.1]). Em contrapartida, os vectores esparsos armazenam apenas elementos não nulos e os seus índices, frequentemente representados como pares chave-valor (por exemplo, [{2: 0.2}, ..., {9997: 0.5}, {9999: 0.7}]). Esta representação reduz significativamente o espaço de armazenamento e aumenta a eficiência computacional, especialmente quando se lida com dados de dimensões extremamente elevadas (por exemplo, 10 000 dimensões).

Representação de vectores esparsos

Os vectores esparsos podem ser gerados utilizando vários métodos, como o TF-IDF (Term Frequency-Inverse Document Frequency) e o BM25 no processamento de texto. Além disso, o Milvus oferece métodos convenientes para ajudar a gerar e processar vectores esparsos. Para mais pormenores, consulte Embeddings.

Para dados de texto, Milvus também fornece capacidades de pesquisa de texto completo, permitindo-lhe realizar pesquisas vectoriais diretamente em dados de texto em bruto sem utilizar modelos de incorporação externos para gerar vectores esparsos. Para obter mais informações, consulte Pesquisa de texto completo.

Após a vectorização, os dados podem ser armazenados no Milvus para gestão e recuperação de vectores. O diagrama abaixo ilustra o processo básico.

Utilizar o vetor esparso em Milvus

Usar vetores esparsos no Milvus

O Milvus suporta a representação de vetores esparsos em qualquer um dos seguintes formatos.

• Matriz esparsa (usando a classe scipy.sparse )

  Python JavaNode.jscURL

  from scipy.sparse import csr_matrix
  
  # Create a sparse matrix
  row = [0, 0, 1, 2, 2, 2]
  col = [0, 2, 2, 0, 1, 2]
  data = [1, 2, 3, 4, 5, 6]
  sparse_matrix = csr_matrix((data, (row, col)), shape=(3, 3))
  
  # Represent sparse vector using the sparse matrix
  sparse_vector = sparse_matrix.getrow(0)
  
  

• Lista de dicionários (formatada como {dimension_index: value, ...})

  Python JavaNode.jscURL

  # Represent sparse vector using a dictionary
  sparse_vector = [{1: 0.5, 100: 0.3, 500: 0.8, 1024: 0.2, 5000: 0.6}]
  
  

  SortedMap<Long, Float> sparseVector = new TreeMap<>();
  sparseVector.put(1L, 0.5f);
  sparseVector.put(100L, 0.3f);
  sparseVector.put(500L, 0.8f);
  sparseVector.put(1024L, 0.2f);
  sparseVector.put(5000L, 0.6f);
  
  

• Lista de Iteradores de Tuple (formatada como [(dimension_index, value)])

  Python JavaNode.jscURL

  # Represent sparse vector using a list of tuples
  sparse_vector = [[(1, 0.5), (100, 0.3), (500, 0.8), (1024, 0.2), (5000, 0.6)]]
  
  

Adicionar campo vetorial

Para utilizar vectores esparsos em Milvus, defina um campo para armazenar vectores esparsos ao criar uma coleção. Este processo inclui.

1. Definir datatype como o tipo de dados de vetor esparso suportado, SPARSE_FLOAT_VECTOR.

2. Não é necessário especificar a dimensão.

from pymilvus import MilvusClient, DataType

client = MilvusClient(uri="http://localhost:19530")

client.drop_collection(collection_name="my_sparse_collection")

schema = client.create_schema(
    auto_id=True,
    enable_dynamic_fields=True,
)

schema.add_field(field_name="pk", datatype=DataType.VARCHAR, is_primary=True, max_length=100)
schema.add_field(field_name="sparse_vector", datatype=DataType.SPARSE_FLOAT_VECTOR)

import io.milvus.v2.client.ConnectConfig;
import io.milvus.v2.client.MilvusClientV2;

import io.milvus.v2.common.DataType;
import io.milvus.v2.service.collection.request.AddFieldReq;
import io.milvus.v2.service.collection.request.CreateCollectionReq;

MilvusClientV2 client = new MilvusClientV2(ConnectConfig.builder()
        .uri("http://localhost:19530")
        .build());
        
CreateCollectionReq.CollectionSchema schema = client.createSchema();
schema.setEnableDynamicField(true);
schema.addField(AddFieldReq.builder()
        .fieldName("pk")
        .dataType(DataType.VarChar)
        .isPrimaryKey(true)
        .autoID(true)
        .maxLength(100)
        .build());

schema.addField(AddFieldReq.builder()
        .fieldName("sparse_vector")
        .dataType(DataType.SparseFloatVector)
        .build());

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

const schema = [
  {
    name: "metadata",
    data_type: DataType.JSON,
  },
  {
    name: "pk",
    data_type: DataType.Int64,
    is_primary_key: true,
  },
  {
    name: "sparse_vector",
    data_type: DataType.SparseFloatVector,
  }
];

export primaryField='{
    "fieldName": "pk",
    "dataType": "VarChar",
    "isPrimary": true,
    "elementTypeParams": {
        "max_length": 100
    }
}'

export vectorField='{
    "fieldName": "sparse_vector",
    "dataType": "SparseFloatVector"
}'

export schema="{
    \"autoID\": true,
    \"fields\": [
        $primaryField,
        $vectorField
    ]
}"

Neste exemplo, é adicionado um campo de vetor chamado sparse_vector para armazenar vectores esparsos. O tipo de dados deste campo é SPARSE_FLOAT_VECTOR.

Definir parâmetros de índice para o campo de vetor

O processo de criação de um índice para vectores esparsos é semelhante ao dos vectores densos, mas com diferenças no tipo de índice especificado (index_type), na métrica de distância (metric_type) e nos parâmetros de índice (params).

index_params = client.prepare_index_params()

index_params.add_index(
    field_name="sparse_vector",
    index_name="sparse_inverted_index",
    index_type="SPARSE_INVERTED_INDEX",
    metric_type="IP",
    params={"drop_ratio_build": 0.2},
)

import io.milvus.v2.common.IndexParam;
import java.util.*;

List<IndexParam> indexes = new ArrayList<>();
Map<String,Object> extraParams = new HashMap<>();
extraParams.put("drop_ratio_build", 0.2);
indexes.add(IndexParam.builder()
        .fieldName("sparse_vector")
        .indexName("sparse_inverted_index")
        .indexType(IndexParam.IndexType.SPARSE_INVERTED_INDEX)
        .metricType(IndexParam.MetricType.IP)
        .extraParams(extraParams)
        .build());

const indexParams = await client.createIndex({
    index_name: 'sparse_inverted_index',
    field_name: 'sparse_vector',
    metric_type: MetricType.IP,
    index_type: IndexType.SPARSE_WAND,
    params: {
      drop_ratio_build: 0.2,
    },
});

export indexParams='[
        {
            "fieldName": "sparse_vector",
            "metricType": "IP",
            "indexName": "sparse_inverted_index",
            "indexType": "SPARSE_INVERTED_INDEX",
            "params":{"drop_ratio_build": 0.2}
        }
    ]'

No exemplo acima.

• Um índice do tipo SPARSE_INVERTED_INDEX é criado para o vetor esparso. Para vectores esparsos, pode especificar SPARSE_INVERTED_INDEX ou SPARSE_WAND. Para obter detalhes, consulte Índices de vetor esparso.

• Para vectores esparsos, metric_type suporta apenas IP (Inner Product), utilizado para medir a semelhança entre dois vectores esparsos. Para obter mais informações sobre similaridade, consulte Tipos de métrica.

• drop_ratio_build é um parâmetro de índice opcional específico para vectores esparsos. Controla a proporção de pequenos valores de vetor excluídos durante a construção do índice. Por exemplo, com {"drop_ratio_build": 0.2}, os 20% mais pequenos dos valores de vetor serão excluídos durante a criação do índice, reduzindo o esforço computacional durante as pesquisas.

Criar coleção

Quando as definições do vetor esparso e do índice estiverem concluídas, pode criar uma coleção que contenha vectores esparsos. O exemplo abaixo utiliza o método create_collection para criar uma coleção denominada my_sparse_collection.

client.create_collection(
    collection_name="my_sparse_collection",
    schema=schema,
    index_params=index_params
)

import io.milvus.v2.client.ConnectConfig;
import io.milvus.v2.client.MilvusClientV2;

MilvusClientV2 client = new MilvusClientV2(ConnectConfig.builder()
        .uri("http://localhost:19530")
        .build());
        
CreateCollectionReq requestCreate = CreateCollectionReq.builder()
        .collectionName("my_sparse_collection")
        .collectionSchema(schema)
        .indexParams(indexes)
        .build();
client.createCollection(requestCreate);

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

const client = new MilvusClient({
    address: 'http://localhost:19530'
});

await client.createCollection({
    collection_name: 'my_sparse_collection',
    schema: schema,
    index_params: indexParams
});

curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/collections/create" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
-d "{
    \"collectionName\": \"my_sparse_collection\",
    \"schema\": $schema,
    \"indexParams\": $indexParams
}"

Inserir dados

Depois de criar a coleção, insira os dados que contêm vectores esparsos.

sparse_vectors = [
    {"sparse_vector": {1: 0.5, 100: 0.3, 500: 0.8}},
    {"sparse_vector": {10: 0.1, 200: 0.7, 1000: 0.9}},
]

client.insert(
    collection_name="my_sparse_collection",
    data=sparse_vectors
)

import com.google.gson.Gson;
import com.google.gson.JsonObject;
import io.milvus.v2.service.vector.request.InsertReq;
import io.milvus.v2.service.vector.response.InsertResp;

List<JsonObject> rows = new ArrayList<>();
Gson gson = new Gson();
{
    JsonObject row = new JsonObject();
    SortedMap<Long, Float> sparse = new TreeMap<>();
    sparse.put(1L, 0.5f);
    sparse.put(100L, 0.3f);
    sparse.put(500L, 0.8f);
    row.add("sparse_vector", gson.toJsonTree(sparse));
    rows.add(row);
}
{
    JsonObject row = new JsonObject();
    SortedMap<Long, Float> sparse = new TreeMap<>();
    sparse.put(10L, 0.1f);
    sparse.put(200L, 0.7f);
    sparse.put(1000L, 0.9f);
    row.add("sparse_vector", gson.toJsonTree(sparse));
    rows.add(row);
}

InsertResp insertR = client.insert(InsertReq.builder()
        .collectionName("my_sparse_collection")
        .data(rows)
        .build());

const data = [
  { sparse_vector: { "1": 0.5, "100": 0.3, "500": 0.8 } },
  { sparse_vector: { "10": 0.1, "200": 0.7, "1000": 0.9 } },
];
client.insert({
  collection_name: "my_sparse_collection",
  data: data,
});

curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/entities/insert" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
-d '{
    "data": [
        {"sparse_vector": {"1": 0.5, "100": 0.3, "500": 0.8}},
        {"sparse_vector": {"10": 0.1, "200": 0.7, "1000": 0.9}}        
    ],
    "collectionName": "my_sparse_collection"
}'

## {"code":0,"cost":0,"data":{"insertCount":2,"insertIds":["453577185629572534","453577185629572535"]}}

Efetuar pesquisa de semelhanças

Para efetuar uma pesquisa de semelhanças utilizando vectores esparsos, prepare o vetor de consulta e os parâmetros de pesquisa.

# Prepare search parameters
search_params = {
    "params": {"drop_ratio_search": 0.2},  # Additional optional search parameters
}

# Prepare the query vector
query_vector = [{1: 0.2, 50: 0.4, 1000: 0.7}]

Neste exemplo, drop_ratio_search é um parâmetro opcional especificamente para vectores esparsos, permitindo o ajuste fino de pequenos valores no vetor de consulta durante a pesquisa. Por exemplo, com {"drop_ratio_search": 0.2}, os 20% mais pequenos dos valores no vetor de consulta serão ignorados durante a pesquisa.

Em seguida, execute a pesquisa de similaridade usando o método search.

res = client.search(
    collection_name="my_sparse_collection",
    data=query_vector,
    limit=3,
    output_fields=["pk"],
    search_params=search_params,
)

print(res)

# Output
# data: ["[{'id': '453718927992172266', 'distance': 0.6299999952316284, 'entity': {'pk': '453718927992172266'}}, {'id': '453718927992172265', 'distance': 0.10000000149011612, 'entity': {'pk': '453718927992172265'}}]"]

import io.milvus.v2.service.vector.request.SearchReq;
import io.milvus.v2.service.vector.request.data.SparseFloatVec;
import io.milvus.v2.service.vector.response.SearchResp;

Map<String,Object> searchParams = new HashMap<>();
searchParams.put("drop_ratio_search", 0.2);

SortedMap<Long, Float> sparse = new TreeMap<>();
sparse.put(10L, 0.1f);
sparse.put(200L, 0.7f);
sparse.put(1000L, 0.9f);

SparseFloatVec queryVector = new SparseFloatVec(sparse);

SearchResp searchR = client.search(SearchReq.builder()
        .collectionName("my_sparse_collection")
        .data(Collections.singletonList(queryVector))
        .annsField("sparse_vector")
        .searchParams(searchParams)
        .topK(3)
        .outputFields(Collections.singletonList("pk"))
        .build());
        
System.out.println(searchR.getSearchResults());

// Output
//
// [[SearchResp.SearchResult(entity={pk=453444327741536759}, score=1.31, id=453444327741536759), SearchResp.SearchResult(entity={pk=453444327741536756}, score=1.31, id=453444327741536756), SearchResp.SearchResult(entity={pk=453444327741536753}, score=1.31, id=453444327741536753)]]

client.search({
    collection_name: 'my_sparse_collection',
    data: {1: 0.2, 50: 0.4, 1000: 0.7},
    limit: 3,
    output_fields: ['pk'],
    params: {
        drop_ratio_search: 0.2
    }
});

curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/entities/search" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
-d '{
    "collectionName": "my_sparse_collection",
    "data": [
        {"1": 0.2, "50": 0.4, "1000": 0.7}
    ],
    "annsField": "sparse_vector",
    "limit": 3,
    "searchParams":{
        "params":{"drop_ratio_search": 0.2}
    },
    "outputFields": ["pk"]
}'

## {"code":0,"cost":0,"data":[{"distance":0.63,"id":"453577185629572535","pk":"453577185629572535"},{"distance":0.1,"id":"453577185629572534","pk":"453577185629572534"}]}

Para obter mais informações sobre os parâmetros de pesquisa de similaridade, consulte Pesquisa ANN básica.

Limites

Ao usar vetores esparsos no Milvus, considere os seguintes limites:

• Atualmente, apenas as métricas de distância IP e BM25 (para pesquisa de texto completo) são suportadas para vetores esparsos. A elevada dimensionalidade dos vectores esparsos torna a distância L2 e cosseno impraticável.

• Para campos de vectores esparsos, apenas são suportados os tipos de índice SPARSE_INVERTED_INDEX e SPARSE_WAND.

• Os tipos de dados suportados para vectores esparsos:

  • A parte da dimensão deve ser um inteiro de 32 bits sem sinal;
  • A parte do valor pode ser um número de ponto flutuante de 32 bits não negativo.

• Os vectores esparsos têm de cumprir os seguintes requisitos para inserção e pesquisa:

  • Pelo menos um valor no vetor é diferente de zero;
  • Os índices do vetor são não-negativos.

PERGUNTAS FREQUENTES

• Pode explicar a diferença entre SPARSE_INVERTED_INDEX e SPARSE_WAND, e como posso escolher entre eles?

  O SPARSE_INVERTED_INDEX é um índice invertido tradicional, enquanto o SPARSE_WAND utiliza o algoritmo Weak-AND para reduzir o número de avaliações de distância IP completas durante a pesquisa. O SPARSE_WAND é normalmente mais rápido, mas o seu desempenho pode diminuir com o aumento da densidade do vetor. Para escolher entre eles, realize experiências e benchmarks com base no seu conjunto de dados e caso de utilização específicos.

• Como devo escolher os parâmetros drop_ratio_build e drop_ratio_search?

  A escolha de drop_ratio_build e drop_ratio_search depende das caraterísticas dos seus dados e dos seus requisitos de latência/rendimento e precisão da pesquisa.

• A dimensão de um embedding esparso pode ser qualquer valor discreto dentro do espaço uint32?

  Sim, com uma exceção. A dimensão de uma incorporação esparsa pode ser qualquer valor no intervalo de [0, maximum of uint32). Isso significa que você não pode usar o valor máximo de uint32.

• As pesquisas em segmentos crescentes são conduzidas através de um índice ou por força bruta?

  As pesquisas em segmentos crescentes são realizadas através de um índice do mesmo tipo que o índice do segmento selado. Para novos segmentos crescentes antes de o índice ser construído, é usada uma pesquisa de força bruta.

• É possível ter vetores esparsos e densos em uma única coleção?

  Sim, com suporte a vários tipos de vetores, é possível criar coleções com colunas de vetores esparsos e densos e executar pesquisas híbridas nelas.