Compaction de la mise en grappe

Le compactage en grappes est conçu pour améliorer les performances de recherche et réduire les coûts dans les grandes collections. Ce guide vous aidera à comprendre le compactage en grappes et la manière dont cette fonctionnalité peut améliorer les performances de recherche.

Vue d'ensemble

Milvus stocke les entités entrantes dans des segments au sein d'une collection et scelle un segment lorsqu'il est plein. Dans ce cas, un nouveau segment est créé pour accueillir les entités supplémentaires. Par conséquent, les entités sont réparties arbitrairement entre les segments. Cette répartition oblige Milvus à rechercher plusieurs segments pour trouver les voisins les plus proches d'un vecteur de requête donné.

Sans compactage de regroupement

Si Milvus peut répartir les entités entre les segments en fonction des valeurs d'un champ spécifique, l'étendue de la recherche peut être limitée à un segment, ce qui améliore les performances de la recherche.

Lecompactage par regroupement est une fonctionnalité de Milvus qui redistribue les entités entre les segments d'une collection en fonction des valeurs d'un champ scalaire. Pour activer cette fonctionnalité, vous devez d'abord sélectionner un champ scalaire comme clé de clustering. Cela permet à Milvus de redistribuer les entités dans un segment lorsque leurs valeurs de clé de clustering se situent dans une plage spécifique. Lorsque vous déclenchez un compactage de clustering, Milvus génère/met à jour un index global appelé PartitionStats, qui enregistre la relation de mappage entre les segments et les valeurs de clé de clustering.

Compaction de clustering

En utilisant PartitionStats comme référence, Milvus peut élaguer les données non pertinentes lors de la réception d'une requête de recherche qui comporte une valeur de clé de clustering et limiter la portée de la recherche aux segments correspondant à la valeur, ce qui améliore les performances de la recherche. Pour plus de détails sur l'amélioration des performances, reportez-vous à la section Tests de référence.

Utiliser le compactage de clustering

La fonction de compactage en grappes de Milvus est hautement configurable. Vous pouvez choisir de la déclencher manuellement ou de la configurer pour qu'elle soit déclenchée automatiquement à intervalles réguliers par Milvus. Pour activer le compactage de clustering, procédez comme suit :

Configuration globale

Vous devez modifier votre fichier de configuration Milvus comme indiqué ci-dessous.

dataCoord:
  compaction:
    clustering:
      enable: true 
      autoEnable: false 
      triggerInterval: 600 
      minInterval: 3600 
      maxInterval: 259200 
      newDataSizeThreshold: 512m 
      timeout: 7200
     
queryNode:
  enableSegmentPrune: true 

datanode:
  clusteringCompaction:
    memoryBufferRatio: 0.1 
    workPoolSize: 8  
common:
  usePartitionKeyAsClusteringKey: true 

Configurer Elément	Description de l'élément	Valeur par défaut
dataCoord.compaction.clustering
enable	Spécifie s'il faut activer le compactage de clustering. Définissez cette valeur sur true si vous devez activer cette fonction pour chaque collection ayant une clé de clustering.	faux
autoEnable	Indique s'il faut activer le compactage déclenché automatiquement. La valeur true indique que Milvus compacte les collections ayant une clé de regroupement aux intervalles spécifiés.	false
triggerInterval	Spécifie l'intervalle en millisecondes auquel Milvus démarre le compactage en cluster. Ceci ne s'applique que lorsque vous définissez autoEnable sur true.
minInterval	Spécifie l'intervalle minimum en millisecondes. Ceci s'applique uniquement lorsque vous définissez autoEnable à true. La définition d'un nombre entier supérieur à triggerInterval permet d'éviter des compactages répétés sur une courte période.
maxInterval	Spécifie l'intervalle maximal en millisecondes. Ceci s'applique uniquement lorsque vous définissez autoEnable à true. Lorsque Milvus détecte qu'une collection n'a pas été compactée par clustering pendant une durée supérieure à cette valeur, il force un compactage par clustering.
newDataSizeThreshold	Spécifie le seuil supérieur de déclenchement du compactage en grappes. Ceci s'applique uniquement lorsque vous définissez autoEnable sur true. Lorsque Milvus détecte que le volume de données d'une collection dépasse cette valeur, il lance un processus de compactage en grappes.
timeout	Spécifie la durée du délai d'attente pour un compactage en grappe. Un compactage en grappe échoue si sa durée d'exécution dépasse cette valeur.
queryNode
enableSegmentPrune	Indique si Milvus élague les données en se référant à PartitionStats lors de la réception de requêtes de recherche. Définissez cette valeur sur true pour que Milvus puisse élaguer les données lors de la réception de demandes de recherche/requête en se référant à PartitionStats.
dataNode.clusteringCompaction
memoryBufferRatio	Spécifie le ratio de mémoire tampon pour les tâches de compactage de clustering. Milvus vide les données lorsque la taille des données dépasse la taille de la mémoire tampon allouée calculée à l'aide de ce ratio.
workPoolSize	Spécifie la taille du pool de travailleurs pour une tâche de compactage en grappes.
common
usePartitionKeyAsClusteringKey	Spécifie s'il faut utiliser la clé de partition dans les collections comme clé de regroupement. En définissant ce paramètre sur true, Milvus traite les clés de partition des collections comme la clé de clustering. Vous pouvez toujours remplacer ce paramètre dans une collection en définissant explicitement une clé de regroupement.

Pour appliquer les modifications ci-dessus à votre cluster Milvus, veuillez suivre les étapes des sections Configurer Milvus avec Helm et Configurer Milvus avec Milvus Operators.

Configuration de la collecte

Pour compacter le clustering dans une collection spécifique, vous devez sélectionner un champ scalaire de la collection comme clé de clustering.

from pymilvus import MilvusClient, DataType

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

client = MilvusClient(
    uri=CLUSTER_ENDPOINT,
    token=TOKEN
)

schema = MilvusClient.create_schema()
schema.add_field("id", DataType.INT64, is_primary=True, auto_id=False)
schema.add_field("key", DataType.INT64, is_clustering_key=True)
schema.add_field("var", DataType.VARCHAR, max_length=1000)
schema.add_field("vector", DataType.FLOAT_VECTOR, dim=5)

client.create_collection(
    collection_name="clustering_test",
    schema=schema
)

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")
        .token("root:Milvus")
        .build());
        
CreateCollectionReq.CollectionSchema schema = client.createSchema();

schema.addField(AddFieldReq.builder()
        .fieldName("id")
        .dataType(DataType.Int64)
        .isPrimaryKey(true)
        .autoID(false)
        .build());

schema.addField(AddFieldReq.builder()
        .fieldName("key")
        .dataType(DataType.Int64)
        .isClusteringKey(true)
        .build());

schema.addField(AddFieldReq.builder()
        .fieldName("var")
        .dataType(DataType.VarChar)
        .maxLength(1000)
        .build());

schema.addField(AddFieldReq.builder()
        .fieldName("vector")
        .dataType(DataType.FloatVector)
        .dimension(5)
        .build());

CreateCollectionReq requestCreate = CreateCollectionReq.builder()
        .collectionName("clustering_test")
        .collectionSchema(schema)
        .build();
client.createCollection(requestCreate);

// go

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

const CLUSTER_ENDPOINT = 'http://localhost:19530';
const TOKEN = 'root:Milvus';
const client = new MilvusClient({
  address: CLUSTER_ENDPOINT,
  token: TOKEN,
});
const schema = [
    {
      name: 'id',
      type: DataType.Int64,
      is_primary_key: true,
      autoID: false,
    },
    {
      name: 'key',
      type: DataType.Int64,
      is_clustering_key: true,
    },
    {
      name: 'var',
      type: DataType.VarChar,
      max_length: 1000,
      is_primary_key: false,
    },
    {
      name: 'vector',
      type: DataType.FloatVector,
      dim: 5,
    },
  ];
  
  await client.createCollection({
    collection_name: 'clustering_test',
    schema: schema,
  });

# restful

Déclencher le compactage de la mise en grappe

Si vous avez activé le compactage automatique du clustering, Milvus déclenche automatiquement le compactage à l'intervalle spécifié. Vous pouvez également déclencher manuellement le compactage comme suit :

# trigger a manual compaction
job_id = client.compact(
    collection_name="clustering_test", 
    is_clustering=True
)

# get the compaction state
client.get_compaction_state(
    job_id=job_id,
)

import io.milvus.v2.service.utility.request.CompactReq;
import io.milvus.v2.service.utility.request.GetCompactionStateReq;
import io.milvus.v2.service.utility.response.CompactResp;
import io.milvus.v2.service.utility.response.GetCompactionStateResp;

CompactResp compactResp = client.compact(CompactReq.builder()
        .collectionName("clustering_test")
        .isClustering(true)
        .build());

GetCompactionStateResp stateResp = client.getCompactionState(GetCompactionStateReq.builder()
        .compactionID(compactResp.getCompactionID())
        .build());

System.out.println(stateResp.getState());

// go

// trigger a manual compaction
const {compactionID} = await client.compact({
    collection_name: "clustering_test", 
    is_clustering: true
});

// get the compaction state
await client.getCompactionState({
    compactionID: compactionID,
});

# restful

Test de référence

Le volume de données et les modèles de requêtes combinés déterminent l'amélioration des performances que le compactage en cluster peut apporter. Un test de référence interne démontre que le compactage en grappes permet de multiplier par 25 le nombre de requêtes par seconde (QPS).

Le test de référence porte sur une collection d'entités provenant d'un ensemble de données LAION de 20 millions d'unités et de 768 dimensions, le champ key étant désigné comme clé de regroupement. Après le déclenchement du compactage de la collection, des recherches simultanées sont envoyées jusqu'à ce que l'utilisation de l'unité centrale atteigne un niveau élevé.

Filtre de recherche	Taux d'élagage	Temps de latence					Demandes/s
		Moyenne	Min	Max	Médiane	TP99
SANS OBJET	0%	1685	672	2294	1710	2291	17.75
touche>200 et touche < 800	40.2%	1045	47	1828	1085	1617	28.38
touche>200 et touche < 600	59.8%	829	45	1483	882	1303	35.78
clé>200 et clé < 400	79.5%	550	100	985	584	898	54.00
clé==1000	99%	68	24	1273	70	246	431.41

Au fur et à mesure que la plage de recherche se réduit dans les filtres de recherche, le taux d'élagage augmente. Cela signifie que davantage d'entités sont ignorées au cours du processus de recherche. Si l'on compare les statistiques de la première et de la dernière ligne, on constate que les recherches sans compactage de grappes nécessitent l'analyse de l'ensemble de la collection. En revanche, les recherches avec compactage par grappes utilisant une clé spécifique peuvent être multipliées par 25.

Meilleures pratiques

Voici quelques conseils pour vous aider à utiliser efficacement le compactage en grappes :

• Activez cette option pour les collections contenant de gros volumes de données.

  Les performances de recherche s'améliorent lorsque les volumes de données d'une collection sont plus importants. Il est conseillé d'activer cette fonctionnalité pour les collections comportant plus d'un million d'entités.

• Choisissez une clé de clustering appropriée.

  Vous pouvez utiliser des champs scalaires couramment employés comme conditions de filtrage en tant que clé de regroupement. Pour une collection contenant des données provenant de plusieurs locataires, vous pouvez utiliser le champ qui distingue un locataire d'un autre comme clé de regroupement.

• Utilisez la clé de partition comme clé de regroupement.

  Vous pouvez définir common.usePartitionKeyAsClusteringKey sur true si vous souhaitez activer cette fonctionnalité pour toutes les collections de votre instance Milvus ou si vous rencontrez toujours des problèmes de performance dans une grande collection avec une clé de partition. Ainsi, vous disposerez d'une clé de regroupement et d'une clé de partition lorsque vous choisirez un champ scalaire dans une collection comme clé de partition.

  Notez que ce paramètre ne vous empêche pas de choisir un autre champ scalaire comme clé de clustering. La clé de regroupement explicitement désignée est toujours prioritaire.