Pemadatan Pengelompokan

Pemadatan pengelompokan dirancang untuk meningkatkan kinerja pencarian dan mengurangi biaya dalam koleksi yang besar. Panduan ini akan membantu Anda memahami pemadatan pengelompokan dan bagaimana fitur ini dapat meningkatkan kinerja pencarian.

Ikhtisar

Milvus menyimpan entitas yang masuk dalam segmen di dalam koleksi dan menutup segmen jika sudah penuh. Jika hal ini terjadi, sebuah segmen baru dibuat untuk mengakomodasi entitas tambahan. Akibatnya, entitas didistribusikan secara acak di seluruh segmen. Distribusi ini mengharuskan Milvus untuk mencari beberapa segmen untuk menemukan tetangga terdekat dengan vektor kueri yang diberikan.

Tanpa Pemadatan Clustering

Jika Milvus dapat mendistribusikan entitas di antara segmen berdasarkan nilai di bidang tertentu, cakupan pencarian dapat dibatasi dalam satu segmen, sehingga meningkatkan kinerja pencarian.

Pemadatan Clustering adalah fitur di Milvus yang mendistribusikan kembali entitas di antara segmen dalam koleksi berdasarkan nilai dalam bidang skalar. Untuk mengaktifkan fitur ini, pertama-tama Anda harus memilih sebuah bidang skalar sebagai kunci pengelompokan. Hal ini memungkinkan Milvus untuk mendistribusikan ulang entitas ke dalam segmen ketika nilai kunci pengelompokannya berada dalam rentang tertentu. Ketika Anda memicu pemadatan pengelompokan, Milvus membuat/memperbaharui indeks global yang disebut PartitionStats, yang mencatat hubungan pemetaan antara segmen dan nilai kunci pengelompokan.

Pemadatan Pengelompokan

Dengan menggunakan PartitionStats sebagai referensi, Milvus dapat memangkas data yang tidak relevan setelah menerima permintaan pencarian/kueri yang membawa nilai kunci pengelompokan dan membatasi cakupan pencarian di dalam segmen yang memetakan nilai tersebut, sehingga meningkatkan kinerja pencarian. Untuk detail tentang peningkatan kinerja, lihat Tes tolok ukur.

Gunakan Pemadatan Pengelompokan

Fitur Pemadatan Klaster di Milvus sangat mudah dikonfigurasi. Anda dapat memilih untuk memicunya secara manual atau mengaturnya untuk dipicu secara otomatis pada interval tertentu oleh Milvus. Untuk mengaktifkan pemadatan pengelompokan, lakukan hal berikut:

Konfigurasi Global

Anda perlu memodifikasi file konfigurasi Milvus Anda seperti yang ditunjukkan di bawah ini.

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 

Konfigurasi Item	Deskripsi	Nilai Default
dataCoord.compaction.clustering
enable	Menentukan apakah akan mengaktifkan pemadatan pengelompokan. Setel ini ke true jika Anda perlu mengaktifkan fitur ini untuk setiap koleksi yang memiliki kunci pengelompokan.	false
autoEnable	Menentukan apakah akan mengaktifkan pemadatan yang dipicu secara otomatis. Mengatur ini ke true mengindikasikan bahwa Milvus akan memadatkan koleksi yang memiliki kunci pengelompokan pada interval yang ditentukan.	false
triggerInterval	Menentukan interval dalam milidetik di mana Milvus memulai pemadatan pengelompokan. Ini hanya berlaku jika Anda mengatur autoEnable ke true.
minInterval	Menentukan interval minimum dalam milidetik. Ini hanya berlaku bila Anda mengatur autoEnable ke true. Mengatur ini ke bilangan bulat yang lebih besar dari triggerInterval akan membantu menghindari pemadatan berulang dalam waktu singkat.
maxInterval	Menentukan interval maksimum dalam milidetik. Ini hanya berlaku ketika Anda mengatur autoEnable ke true. Setelah Milvus mendeteksi bahwa sebuah koleksi belum dipadatkan secara pengelompokan untuk durasi yang lebih lama dari nilai ini, ia akan memaksa pemadatan pengelompokan.
newDataSizeThreshold	Menentukan ambang batas atas untuk memicu pemadatan pengelompokan. Ini hanya berlaku jika Anda menetapkan autoEnable ke true. Setelah Milvus mendeteksi bahwa volume data dalam koleksi melebihi nilai ini, Milvus akan memulai proses pemadatan pengelompokan.
timeout	Menentukan durasi batas waktu untuk pemadatan pengelompokan. Pemadatan pengelompokan akan gagal jika waktu eksekusinya melebihi nilai ini.
queryNode
enableSegmentPrune	Menentukan apakah Milvus memangkas data dengan merujuk ke PartitionStats setelah menerima permintaan pencarian/kueri. Atur ini ke true sehingga Milvus dapat memangkas data saat menerima permintaan pencarian/kueri dengan merujuk ke PartitionStats.
dataNode.clusteringCompaction
memoryBufferRatio	Menentukan rasio buffer memori untuk tugas pemadatan pengelompokan. Milvus akan memangkas data ketika ukuran data melebihi ukuran buffer yang dialokasikan yang dihitung menggunakan rasio ini.
workPoolSize	Menentukan ukuran kumpulan pekerja untuk tugas pemadatan pengelompokan.
common
usePartitionKeyAsClusteringKey	Menentukan apakah akan menggunakan kunci partisi dalam koleksi sebagai kunci pengelompokan. Mengatur ini ke true akan membuat Milvus memperlakukan kunci partisi dalam koleksi sebagai kunci pengelompokan. Anda selalu dapat mengganti pengaturan ini dalam koleksi dengan secara eksplisit mengatur kunci pengelompokan.

Untuk menerapkan perubahan di atas pada kluster Milvus Anda, silakan ikuti langkah-langkah di Konfigurasi Milvus dengan Helm dan Konfigurasi Milvus dengan Operator Milvus.

Konfigurasi Koleksi

Untuk pemadatan cluster dalam koleksi tertentu, Anda harus memilih bidang skalar dari koleksi sebagai kunci 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

Memicu Pemadatan Pengelompokan

Jika Anda telah mengaktifkan pemadatan pengelompokan otomatis, Milvus secara otomatis memicu pemadatan pada interval yang ditentukan. Sebagai alternatif, Anda dapat memicu pemadatan secara manual sebagai berikut:

# 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

Uji Tolok Ukur

Volume data dan pola kueri yang digabungkan menentukan peningkatan kinerja yang dapat dihasilkan oleh pemadatan klaster. Uji tolok ukur internal menunjukkan bahwa pemadatan klaster menghasilkan peningkatan hingga 25 kali lipat dalam kueri per detik (QPS).

Uji tolok ukur dilakukan pada koleksi yang berisi entitas dari kumpulan data LAION sebanyak 20 juta, 768 dimensi dengan bidang key yang ditetapkan sebagai kunci pengelompokan. Setelah pemadatan klaster dipicu dalam koleksi, pencarian bersamaan dikirim hingga penggunaan CPU mencapai level tertinggi.

Filter pencarian	Rasio pemangkasan	Latensi					Permintaan/s
		Rata-rata	Min	Maks	Median	TP99
N/A	0%	1685	672	2294	1710	2291	17.75
kunci> 200 dan kunci < 800	40.2%	1045	47	1828	1085	1617	28.38
kunci> 200 dan kunci < 600	59.8%	829	45	1483	882	1303	35.78
kunci> 200 dan kunci < 400	79.5%	550	100	985	584	898	54.00
kunci = 1000	99%	68	24	1273	70	246	431.41

Ketika rentang pencarian menyempit dalam filter pencarian, rasio pemangkasan meningkat. Ini berarti lebih banyak entitas yang dilewati selama proses pencarian. Ketika membandingkan statistik di baris pertama dan terakhir, Anda dapat melihat bahwa pencarian tanpa pemadatan pengelompokan memerlukan pemindaian seluruh koleksi. Di sisi lain, pencarian dengan pemadatan pengelompokan menggunakan kunci tertentu dapat mencapai peningkatan hingga 25 kali lipat.

Praktik Terbaik

Berikut ini beberapa kiat agar Anda dapat menggunakan pemadatan pengelompokan secara efisien:

• Aktifkan ini untuk koleksi dengan volume data yang besar.

  Performa pencarian meningkat dengan volume data yang lebih besar dalam koleksi. Ini adalah pilihan yang baik untuk mengaktifkan fitur ini untuk koleksi dengan lebih dari 1 juta entitas.

• Pilih kunci pengelompokan yang tepat.

  Anda dapat menggunakan bidang skalar yang biasa digunakan sebagai kondisi pemfilteran sebagai kunci pengelompokan. Untuk koleksi yang menyimpan data dari beberapa penyewa, Anda dapat menggunakan bidang yang membedakan satu penyewa dengan penyewa lainnya sebagai kunci pengelompokan.

• Gunakan kunci partisi sebagai kunci pengelompokan.

  Anda dapat mengatur common.usePartitionKeyAsClusteringKey ke true jika anda ingin mengaktifkan fitur ini untuk semua koleksi di dalam instance Milvus anda atau jika anda masih menghadapi masalah performa di dalam koleksi yang besar dengan kunci partisi. Dengan demikian, Anda akan memiliki kunci pengelompokan dan kunci partisi ketika Anda memilih sebuah field skalar dalam koleksi sebagai kunci partisi.

  Perhatikan bahwa pengaturan ini tidak menghalangi Anda untuk memilih bidang skalar lain sebagai kunci pengelompokan. Kunci pengelompokan yang ditetapkan secara eksplisit selalu diutamakan.