Vecteur épars

Les vecteurs épars sont une méthode importante pour capturer la correspondance des termes au niveau de la surface dans la recherche d'informations et le traitement du langage naturel. Alors que les vecteurs denses excellent dans la compréhension sémantique, les vecteurs épars fournissent souvent des résultats plus prévisibles, en particulier lors de la recherche de termes spéciaux ou d'identifiants textuels.

Vue d'ensemble

Un vecteur peu dense est un vecteur spécial à haute dimension dans lequel la plupart des éléments sont nuls et seules quelques dimensions ont des valeurs non nulles. Comme le montre le diagramme ci-dessous, les vecteurs denses sont généralement représentés sous la forme de tableaux continus où chaque position a une valeur (par exemple, [0.3, 0.8, 0.2, 0.3, 0.1]). En revanche, les vecteurs épars ne stockent que les éléments non nuls et leurs indices de dimension, souvent représentés sous forme de paires clé-valeur de { index: value} (par exemple, [{2: 0.2}, ..., {9997: 0.5}, {9999: 0.7}]).

Représentation vectorielle éparse

Avec la tokenisation et la notation, les documents peuvent être représentés comme des vecteurs de sacs de mots, où chaque dimension correspond à un mot spécifique du vocabulaire. Seuls les mots présents dans le document ont des valeurs non nulles, ce qui crée une représentation vectorielle éparse. Les vecteurs épars peuvent être générés à l'aide de deux approches :

• Lestechniques statistiques traditionnelles, telles que TF-IDF (Term Frequency-Inverse Document Frequency) et BM25 (Best Matching 25), attribuent des poids aux mots en fonction de leur fréquence et de leur importance dans un corpus. Ces méthodes calculent des statistiques simples sous forme de scores pour chaque dimension, qui représente un jeton. Milvus fournit une recherche plein texte intégrée avec la méthode BM25, qui convertit automatiquement le texte en vecteurs épars, éliminant ainsi la nécessité d'un prétraitement manuel. Cette approche est idéale pour la recherche par mot-clé, où la précision et les correspondances exactes sont importantes. Pour plus d'informations, reportez-vous à la section Recherche en texte intégral.

• Lesmodèles neuronaux d'encastrement clairsemé sont des méthodes d'apprentissage permettant de générer des représentations clairsemées en s'entraînant sur de grands ensembles de données. Il s'agit généralement de modèles d'apprentissage profond dotés d'une architecture Transformer, capables de développer et de pondérer les termes en fonction du contexte sémantique. Milvus prend également en charge les embeddings clairsemés générés de manière externe à partir de modèles tels que SPLADE. Voir Embeddings pour plus de détails.

Les vecteurs épars et le texte original peuvent être stockés dans Milvus pour une récupération efficace. Le diagramme ci-dessous décrit le processus global.

Flux de travail des vecteurs épars

Formats de données

Dans les sections suivantes, nous montrons comment stocker des vecteurs issus de modèles d'intégration épars tels que SPLADE. Si vous cherchez un complément à la recherche sémantique basée sur les vecteurs denses, nous recommandons la recherche en texte intégral avec BM25 plutôt que SPLADE pour des raisons de simplicité. Si vous avez effectué une évaluation de la qualité et décidé d'utiliser SPLADE, vous pouvez vous référer à Embeddings pour savoir comment générer des vecteurs peu denses avec SPLADE.

Milvus prend en charge l'entrée de vecteurs épars dans les formats suivants :

• Liste de dictionnaires (formatée comme {dimension_index: value, ...})

  # Represent each sparse vector using a dictionary
  sparse_vectors = [{27: 0.5, 100: 0.3, 5369: 0.6} , {100: 0.1, 3: 0.8}]
  

• Matrice éparse (à l'aide de la classe scipy.sparse )

  from scipy.sparse import csr_matrix
  
  # First vector: indices [27, 100, 5369] with values [0.5, 0.3, 0.6]
  # Second vector: indices [3, 100] with values [0.8, 0.1]
  indices = [[27, 100, 5369], [3, 100]]
  values = [[0.5, 0.3, 0.6], [0.8, 0.1]]
  sparse_vectors = [csr_matrix((vals, ([0]*len(idx), idx)), shape=(1, 5369+1)) for idx, vals in zip(indices, values)]
  

• Liste d'itérabilités de n-uplets (par exemple [(dimension_index, value)])

  # Represent each sparse vector using a list of iterables (e.g. tuples)
  sparse_vector = [
      [(27, 0.5), (100, 0.3), (5369, 0.6)],
      [(100, 0.1), (3, 0.8)]
      ]
  

Définir le schéma de la collection

Avant de créer une collection, vous devez spécifier le schéma de la collection, qui définit les champs et, éventuellement, une fonction permettant de convertir un champ textuel en une représentation vectorielle éparse correspondante.

Ajouter des champs

Pour utiliser les vecteurs épars dans Milvus, vous devez créer une collection avec un schéma comprenant les champs suivants :

• Un champ SPARSE_FLOAT_VECTOR réservé au stockage des vecteurs épars, généré automatiquement à partir d'un champ VARCHAR ou fourni directement dans les données d'entrée.

• Généralement, le texte brut que le vecteur sparse représente est également stocké dans la collection. Vous pouvez utiliser un champ VARCHAR pour stocker le texte brut.

from pymilvus import MilvusClient, DataType

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

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)
schema.add_field(field_name="text", datatype=DataType.VARCHAR, max_length=65535, enable_analyzer=True)

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());
schema.addField(AddFieldReq.builder()
        .fieldName("text")
        .dataType(DataType.VarChar)
        .maxLength(65535)
        .enableAnalyzer(true)
        .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,
  },
  {
    name: "text",
    data_type: "VarChar",
    enable_analyzer: true,
    enable_match: true,
    max_length: 65535,
  },
];

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 := "localhost:19530"
client, err := milvusclient.New(ctx, &milvusclient.ClientConfig{
    Address: milvusAddr,
})
if err != nil {
    fmt.Println(err.Error())
    // handle error
}
defer client.Close(ctx)

schema := entity.NewSchema()
schema.WithField(entity.NewField().
    WithName("pk").
    WithDataType(entity.FieldTypeVarChar).
    WithIsAutoID(true).
    WithIsPrimaryKey(true).
    WithMaxLength(100),
).WithField(entity.NewField().
    WithName("sparse_vector").
    WithDataType(entity.FieldTypeSparseVector),
).WithField(entity.NewField().
    WithName("text").
    WithDataType(entity.FieldTypeVarChar).
    WithEnableAnalyzer(true).
    WithMaxLength(65535),
)

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

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

export textField='{
    "fieldName": "text",
    "dataType": "VarChar",
    "elementTypeParams": {
        "max_length": 65535,
        "enable_analyzer": true
    }
}'

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

Dans cet exemple, trois champs sont ajoutés :

• pk: Ce champ stocke les clés primaires à l'aide du type de données VARCHAR, qui est généré automatiquement avec une longueur maximale de 100 octets.

• sparse_vector: Ce champ stocke des vecteurs épars à l'aide du type de données SPARSE_FLOAT_VECTOR.

• text: Ce champ stocke des chaînes de texte à l'aide du type de données VARCHAR, d'une longueur maximale de 65535 octets.

Définir les paramètres de l'index

Le processus de création d'un index pour les vecteurs peu denses est similaire à celui des vecteurs denses, mais avec des différences dans le type d'index spécifié (index_type), la métrique de distance (metric_type) et les paramètres d'index (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={"inverted_index_algo": "DAAT_MAXSCORE"}, # or "DAAT_WAND" or "TAAT_NAIVE"
)

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

List<IndexParam> indexes = new ArrayList<>();

Map<String,Object> extraParams = new HashMap<>();
extraParams.put("inverted_index_algo": "DAAT_MAXSCORE"); // Algorithm used for building and querying the index

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({
    field_name: 'sparse_vector',
    metric_type: MetricType.IP,
    index_name: 'sparse_inverted_index',
    index_type: IndexType.SPARSE_INVERTED_INDEX,
    params: {
      inverted_index_algo: 'DAAT_MAXSCORE', 
    },
});

idx := index.NewSparseInvertedIndex(entity.IP, 0.2)
indexOption := milvusclient.NewCreateIndexOption("my_collection", "sparse_vector", idx)

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

Cet exemple utilise le type d'index SPARSE_INVERTED_INDEX avec IP comme métrique. Pour plus de détails, voir les ressources suivantes :

• SPARSE_INVERTED_INDEX: Explication de l'index et de ses paramètres

• Types de métriques: Types de métriques pris en charge pour différents types de champs

• Recherche en texte intégral: Un tutoriel détaillé sur la recherche en texte intégral

Créer une collection

Une fois que les paramètres des vecteurs épars et de l'index sont terminés, vous pouvez créer une collection contenant des vecteurs épars. L'exemple ci-dessous utilise la méthode create_collection pour créer une collection nommée my_collection.

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

CreateCollectionReq requestCreate = CreateCollectionReq.builder()
        .collectionName("my_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_collection',
    schema: schema,
    index_params: indexParams
});

err = client.CreateCollection(ctx,
    milvusclient.NewCreateCollectionOption("my_collection", schema).
        WithIndexOptions(indexOption))
if err != nil {
    fmt.Println(err.Error())
    // handle error
}

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
}"

Insérer des données

Vous devez fournir des données pour tous les champs définis lors de la création de la collection, à l'exception des champs générés automatiquement (tels que la clé primaire avec auto_id activé). Si vous utilisez la fonction intégrée BM25 pour générer automatiquement des vecteurs épars, vous devez également omettre le champ "vecteur épars" lors de l'insertion des données.

data = [
    {
        "text": "information retrieval is a field of study.",
        "sparse_vector": {1: 0.5, 100: 0.3, 500: 0.8}
    },
    {
        "text": "information retrieval focuses on finding relevant information in large datasets.",
        "sparse_vector": {10: 0.1, 200: 0.7, 1000: 0.9}
    }
]

client.insert(
    collection_name="my_collection",
    data=data
)

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;

import java.util.ArrayList;
import java.util.List;
import java.util.SortedMap;
import java.util.TreeMap;

Gson gson = new Gson();
List<JsonObject> rows = new ArrayList<>();

{
    JsonObject row = new JsonObject();
    row.addProperty("text", "information retrieval is a field of study.");
    
    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();
    row.addProperty("text", "information retrieval focuses on finding relevant information in large datasets.");
    
    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 insertResp = client.insert(InsertReq.builder()
        .collectionName("my_collection")
        .data(rows)
        .build());

const data = [
    {
        text: 'information retrieval is a field of study.',
        sparse_vector: {1: 0.5, 100: 0.3, 500: 0.8}
    {
        text: 'information retrieval focuses on finding relevant information in large datasets.',
        sparse_vector: {10: 0.1, 200: 0.7, 1000: 0.9}
    },
];

client.insert({
    collection_name: "my_collection",
    data: data
});

texts := []string{
    "information retrieval is a field of study.",
    "information retrieval focuses on finding relevant information in large datasets.",
}
textColumn := entity.NewColumnVarChar("text", texts)

// Prepare sparse vectors
sparseVectors := make([]entity.SparseEmbedding, 0, 2)
sparseVector1, _ := entity.NewSliceSparseEmbedding([]uint32{1, 100, 500}, []float32{0.5, 0.3, 0.8})
sparseVectors = append(sparseVectors, sparseVector1)
sparseVector2, _ := entity.NewSliceSparseEmbedding([]uint32{10, 200, 1000}, []float32{0.1, 0.7, 0.9})
sparseVectors = append(sparseVectors, sparseVector2)
sparseVectorColumn := entity.NewColumnSparseVectors("sparse_vector", sparseVectors)

_, err = client.Insert(ctx, milvusclient.NewColumnBasedInsertOption("my_collection").
    WithColumns(
        sparseVectorColumn,
        textColumn
        
    ))
if err != nil {
    fmt.Println(err.Error())
    // handle err
}

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.",
            "sparse_vector": {"1": 0.5, "100": 0.3, "500": 0.8}
        },
        {
            "text": "information retrieval focuses on finding relevant information in large datasets.",
            "sparse_vector": {"10": 0.1, "200": 0.7, "1000": 0.9}
        }     
    ],
    "collectionName": "my_collection"
}'

Effectuer une recherche de similarité

Pour effectuer une recherche de similarité à l'aide de vecteurs épars, préparez à la fois les données de la requête et les paramètres de recherche.

# Prepare search parameters
search_params = {
    "params": {"drop_ratio_search": 0.2},  # A tunable drop ratio parameter with a valid range between 0 and 1
}

# Query with sparse vector
query_data = [{1: 0.2, 50: 0.4, 1000: 0.7}]

import io.milvus.v2.service.vector.request.data.EmbeddedText;
import io.milvus.v2.service.vector.request.data.SparseFloatVec;

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

// Query with the sparse vector
SortedMap<Long, Float> sparse = new TreeMap<>();
sparse.put(1L, 0.2f);
sparse.put(50L, 0.4f);
sparse.put(1000L, 0.7f);
SparseFloatVec queryData = new SparseFloatVec(sparse);

// Prepare search parameters
annSearchParams := index.NewCustomAnnParam()
annSearchParams.WithExtraParam("drop_ratio_search", 0.2)

// Query with the sparse vector
queryData, _ := entity.NewSliceSparseEmbedding([]uint32{1, 50, 1000}, []float32{0.2, 0.4, 0.7})

// Prepare search parameters
const searchParams = {drop_ratio_search: 0.2}

// Query with the sparse vector
const queryData = [{1: 0.2, 50: 0.4, 1000: 0.7}]

# Prepare search parameters
export queryData='["What is information retrieval?"]'

# Query with the sparse vector
export queryData='[{1: 0.2, 50: 0.4, 1000: 0.7}]'

Ensuite, exécutez la recherche de similarité à l'aide de la méthode search:

res = client.search(
    collection_name="my_collection",
    data=query_data,
    limit=3,
    output_fields=["pk"],
    search_params=search_params,
    consistency_level="Strong"
)

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.response.SearchResp;

SparseFloatVec queryVector = new SparseFloatVec(sparse);

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

// Output
//
// [[SearchResp.SearchResult(entity={pk=457270974427187729}, score=0.63, id=457270974427187729), SearchResp.SearchResult(entity={pk=457270974427187728}, score=0.1, id=457270974427187728)]]

await client.search({
    collection_name: 'my_collection',
    data: queryData,
    limit: 3,
    output_fields: ['pk'],
    params: searchParams,
    consistency_level: "Strong"
});

resultSets, err := client.Search(ctx, milvusclient.NewSearchOption(
    "my_collection",
    3, // limit
    []entity.Vector{queryData},
).WithANNSField("sparse_vector").
    WithOutputFields("pk").
    WithAnnParam(annSearchParams))
if err != nil {
    fmt.Println(err.Error())
    // handle err
}

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

// Results:
//   IDs:  string_data:{data:"457270974427187705"  data:"457270974427187704"}
//   Scores:  [0.63 0.1]
//   Pks:  string_data:{data:"457270974427187705"  data:"457270974427187704"}

export params='{
    "consistencyLevel": "Strong"
}'

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": $queryData,
    "annsField": "sparse_vector",
    "limit": 3,
    "searchParams": $searchParams,
    "outputFields": ["pk"],
    "params": $params
}'

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

Pour plus d'informations sur les paramètres de recherche de similarité, reportez-vous à la section Recherche vectorielle de base.