Compattazione dei cluster

La compattazione del clustering è progettata per migliorare le prestazioni di ricerca e ridurre i costi di collezioni di grandi dimensioni. Questa guida vi aiuterà a capire la compattazione del clustering e come questa funzione può migliorare le prestazioni di ricerca.

Panoramica

Milvus memorizza le entità in arrivo in segmenti all'interno di una raccolta e chiude un segmento quando è pieno. In tal caso, viene creato un nuovo segmento per accogliere altre entità. Di conseguenza, le entità sono distribuite arbitrariamente tra i segmenti. Questa distribuzione richiede che Milvus cerchi in più segmenti per trovare i vicini più vicini a un determinato vettore di query.

Senza compattazione del clustering

Se Milvus può distribuire le entità tra i segmenti in base ai valori di un campo specifico, l'ambito di ricerca può essere limitato all'interno di un segmento, migliorando così le prestazioni di ricerca.

Clustering Compaction è una funzione di Milvus che ridistribuisce le entità tra i segmenti di una raccolta in base ai valori di un campo scalare. Per attivare questa funzione, è necessario selezionare un campo scalare come chiave di raggruppamento. Questo permette a Milvus di ridistribuire le entità in un segmento quando i valori della chiave di clustering rientrano in un intervallo specifico. Quando si attiva una compattazione di clustering, Milvus genera/aggiorna un indice globale chiamato PartitionStats, che registra la relazione di mappatura tra i segmenti e i valori delle chiavi di clustering.

Compattazione del clustering

Utilizzando PartitionStats come riferimento, Milvus può sfrondare i dati irrilevanti quando riceve una richiesta di ricerca/query che contiene un valore di chiave di clustering e restringe l'ambito di ricerca all'interno dei segmenti che corrispondono al valore, migliorando così le prestazioni di ricerca. Per maggiori dettagli sul miglioramento delle prestazioni, consultare i test di benchmark.

Utilizzare la compattazione del clustering

La funzione Clustering Compaction di Milvus è altamente configurabile. Si può scegliere di attivarla manualmente o di impostarla in modo che venga attivata automaticamente da Milvus a intervalli. Per abilitare la compattazione del clustering, procedere come segue:

Configurazione globale

È necessario modificare il file di configurazione di Milvus come indicato di seguito.

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 

Configurazione Voce	Descrizione	Valore predefinito
dataCoord.compaction.clustering
enable	Specifica se abilitare la compattazione del clustering. Impostare questo valore su true se è necessario abilitare questa funzione per ogni raccolta che ha una chiave di clustering.	falso
autoEnable	Specifica se abilitare la compattazione automatica. L'impostazione di true indica che Milvus compatta le raccolte che hanno una chiave di raggruppamento agli intervalli specificati.	falso
triggerInterval	Specifica l'intervallo in millisecondi in cui Milvus avvia la compattazione del cluster. Si applica solo quando si imposta autoEnable su true.
minInterval	Specifica l'intervallo minimo in millisecondi. Si applica solo quando si imposta autoEnable a true. L'impostazione di un numero intero superiore a triggerInterval consente di evitare compattazioni ripetute in un breve periodo.
maxInterval	Specifica l'intervallo massimo in millisecondi. Si applica solo quando si imposta autoEnable a true. Quando Milvus rileva che una raccolta non è stata compattata con il cluster per un periodo superiore a questo valore, forza una compattazione con il cluster.
newDataSizeThreshold	Specifica la soglia superiore per attivare la compattazione del clustering. Si applica solo quando si imposta autoEnable su true. Quando Milvus rileva che il volume dei dati in una raccolta supera questo valore, avvia un processo di compattazione del clustering.
timeout	Specifica la durata del timeout per la compattazione del clustering. Una compattazione di clustering fallisce se il tempo di esecuzione supera questo valore.
queryNode
enableSegmentPrune	Specifica se Milvus deve effettuare il pruning dei dati facendo riferimento a PartitionStats quando riceve richieste di ricerca/query. Impostate questo valore su true, in modo che Milvus possa eliminare i dati alla ricezione di richieste di ricerca/query facendo riferimento a PartitionStats.
dataNode.clusteringCompaction
memoryBufferRatio	Specifica il rapporto del buffer di memoria per le attività di compattazione del cluster. Milvus elimina i dati quando la dimensione dei dati supera la dimensione del buffer allocato calcolata con questo rapporto.
workPoolSize	Specifica la dimensione del pool di lavoratori per un'attività di compattazione del clustering.
common
usePartitionKeyAsClusteringKey	Specifica se usare la chiave di partizione nelle raccolte come chiave di clustering. Impostando true, Milvus considera le chiavi di partizione delle raccolte come chiave di clustering. È sempre possibile annullare questa impostazione in una raccolta impostando esplicitamente una chiave di clustering.

Per applicare le modifiche di cui sopra al vostro cluster Milvus, seguite i passaggi in Configurazione di Milvus con Helm e Configurazione di Milvus con Milvus Operators.

Configurazione della raccolta

Per la compattazione del cluster in una raccolta specifica, è necessario selezionare un campo scalare della raccolta come chiave di 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

Attivare la compattazione del clustering

Se è stata attivata la compattazione automatica del clustering, Milvus attiva automaticamente la compattazione all'intervallo specificato. In alternativa, è possibile attivare manualmente la compattazione come segue:

# 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 di benchmark

Il volume dei dati e i modelli di query determinano il miglioramento delle prestazioni che la compattazione del cluster può apportare. Un test di benchmark interno dimostra che la compattazione del clustering produce un miglioramento fino a 25 volte delle query al secondo (QPS).

Il test di benchmark è stato eseguito su una raccolta contenente entità di un dataset LAION da 20 milioni e 768 dimensioni, con il campo key designato come chiave di clustering. Dopo l'attivazione della compattazione del clustering nella raccolta, vengono inviate ricerche simultanee finché l'utilizzo della CPU non raggiunge un livello elevato.

Filtro di ricerca	Rapporto di potatura	Latenza					Richieste/s
		Avg	Min	Massimo	Mediana	TP99
N/D	0%	1685	672	2294	1710	2291	17.75
chiave>200 e chiave < 800	40.2%	1045	47	1828	1085	1617	28.38
chiave>200 e chiave < 600	59.8%	829	45	1483	882	1303	35.78
chiave>200 e chiave < 400	79.5%	550	100	985	584	898	54.00
chiave==1000	99%	68	24	1273	70	246	431.41

Man mano che l'intervallo di ricerca si restringe nei filtri di ricerca, il rapporto di eliminazione aumenta. Ciò significa che un maggior numero di entità viene saltato durante il processo di ricerca. Confrontando le statistiche della prima e dell'ultima riga, si può notare che le ricerche senza compattazione del clustering richiedono la scansione dell'intera collezione. D'altra parte, le ricerche con la compattazione dei cluster utilizzando una chiave specifica possono ottenere un miglioramento fino a 25 volte.

Le migliori pratiche

Ecco alcuni suggerimenti per utilizzare la compattazione del clustering in modo efficiente:

• Abilitare questa funzione per le raccolte con grandi volumi di dati.

  Le prestazioni di ricerca migliorano con volumi di dati più grandi in una raccolta. È una buona scelta abilitare questa funzione per le raccolte con oltre 1 milione di entità.

• Scegliere una chiave di clustering adeguata.

  Come chiave di raggruppamento si possono usare campi scalari comunemente usati come condizioni di filtraggio. Per una raccolta che contiene dati di più tenant, è possibile utilizzare come chiave di clustering il campo che distingue un tenant dall'altro.

• Utilizzare la chiave di partizione come chiave di clustering.

  È possibile impostare common.usePartitionKeyAsClusteringKey su true se si desidera attivare questa funzione per tutte le raccolte nell'istanza Milvus o se si riscontrano ancora problemi di prestazioni in una raccolta di grandi dimensioni con una chiave di partizione. In questo modo, si avrà una chiave di clustering e una chiave di partizione quando si sceglie un campo scalare in una raccolta come chiave di partizione.

  Questa impostazione non impedisce di scegliere un altro campo scalare come chiave di clustering. La chiave di raggruppamento esplicitamente designata ha sempre la precedenza.