Pemadatan Penggabungan PaksaCompatible with Milvus 3.0.x

Force Merge dirancang untuk menggabungkan segmen-segmen kecil dan terfragmentasi menjadi segmen yang lebih sedikit dan lebih besar untuk meningkatkan kinerja kueri dan efisiensi penyimpanan. Panduan ini menjelaskan cara menggunakan pemadatan penggabungan paksa.

Ikhtisar

Pemadatan standar menjaga ukuran segmen tetap mendekati maxSize yang dikonfigurasi melalui penggabungan banyak-ke-satu, tetapi masih dapat menyisakan fragmen berukuran sedang yang tidak dapat digabungkan lebih lanjut tanpa melebihi batas. Misalnya, seperti yang diilustrasikan di bawah ini, jika koleksi memiliki lima segmen 2 MB dan maxSize berukuran 3 MB, penggabungan dua segmen akan melebihi batas, sehingga pemadatan standar tidak dapat mengurangi jumlah segmen lebih lanjut dan tata letak yang terfragmentasi tetap ada.

Penggabungan paksa menambahkan parameter target_size dan mendukung pengorganisasian ulang segmen ke ukuran yang diinginkan dalam toleransi yang ketat jika memungkinkan. Seperti yang diilustrasikan di bawah ini, jika target_size yang ditentukan adalah 4 MB, lima segmen kecil berukuran 2 MB dapat digabungkan lebih lanjut menjadi lebih sedikit segmen yang lebih besar. Hal ini mengurangi jumlah segmen yang berlebih, mendukung target yang lebih besar dari pengaturan default maxSize, dan, jika targetnya sangat besar, memungkinkan sistem memilih ukuran output dan jumlah segmen yang praktis untuk perangkat keras dan topologi QueryNode saat ini.

Untuk memahami metode pemadatan mana yang digunakan, lihat Pertanyaan Umum.

R8eow3kaqhktokblcmocnvxmnee

Pemadatan penggabungan paksa memperluas API yang sudah ada Compaction API dengan parameter target_size. API ini sepenuhnya kompatibel ke belakang: panggilan pemadatan yang sudah ada tanpa target_size akan tetap berfungsi seperti sebelumnya.

Penggabungan paksa beroperasi secara asinkron. Ia tidak memblokir operasi pencarian atau kueri, meskipun mengkonsumsi sumber daya I/O dan memori selama eksekusi.

Menggunakan Pemadatan Penggabungan Paksa

Prasyarat

• Milvus versi 3.0 atau yang lebih baru

• PyMilvus 3.0 atau yang lebih baru

Konfigurasi Global

Parameter konfigurasi berikut ini mengontrol perilaku Penggabungan Paksa. Aturlah di file konfigurasi Milvus atau melalui variabel lingkungan.

dataCoord:
  segment:
    maxSize: 512         # Default segment max size (MB).
                         # Used when target_size is 0 or omitted.
  compaction:
    maxFullSegmentThreshold: 100
                         # When segment count exceeds this threshold,
                         # a faster greedy algorithm is used instead
                         # of the standard merge algorithm.
    forceMerge:
      datanodeMemoryFactor: 4.0
                         # DataNode memory divided by this factor
                         # determines the the largest segment
                         # size the system can allow.
      querynodeMemoryFactor: 4.0
                         # Minimum QueryNode memory divided by this
                         # factor. Used in automatic size calculation
                         # to ensure merged segments can be loaded.

Parameter	Nilai Default	Deskripsi
dataCoord.segment.maxSize	512	Ukuran maksimum segmen default dalam MB. Digunakan sebagai target ketika target_size adalah 0 atau dihilangkan. Juga berfungsi sebagai nilai minimum yang diizinkan untuk target_size eksplisit.
dataCoord.compaction.maxFullSegmentThreshold	100	Ambang batas jumlah segmen untuk pemilihan algoritma. Ketika jumlah segmen melebihi nilai ini, Milvus menggunakan algoritma greedy yang lebih cepat untuk perencanaan penggabungan. Algoritma standar (digunakan ketika jumlah segmen <= dataCoord.compaction.maxFullSegmentThreshold): menghasilkan hasil penggabungan yang lebih optimal tetapi membutuhkan waktu lebih lama untuk menghitung. Algoritma Greedy (digunakan ketika jumlah segmen > dataCoord.compaction.maxFullSegmentThreshold): menyelesaikan perencanaan dengan lebih cepat dengan mengorbankan pengelompokan segmen yang kurang optimal.
dataCoord.compaction.forceMerge.datanodeMemoryFactor	4.0	Memori DataNode dibagi dengan faktor ini untuk menghitung ukuran segmen terbesar yang dapat diijinkan oleh sistem. Nilai yang lebih besar mengalokasikan lebih sedikit memori untuk penggabungan tetapi menyisakan lebih banyak untuk operasi DataNode lainnya, sehingga meningkatkan stabilitas node. Nilai yang lebih kecil memungkinkan penggabungan yang lebih besar tetapi meningkatkan tekanan memori. Sebagai contoh, dengan faktor default 4.0 dan DataNode dengan memori 16 GB, anggaran penggabungan adalah 4 GB. Ini berarti ukuran total segmen yang digabungkan dalam satu operasi tidak dapat melebihi 4 GB.
dataCoord.compaction.forceMerge.querynodeMemoryFactor	4.0	Memori QueryNode minimum dibagi dengan faktor ini. Digunakan selama perhitungan ukuran otomatis (target_size=max_int64) untuk memastikan bahwa segmen yang digabungkan dapat dimuat oleh QueryNode. Nilai yang lebih besar menghasilkan segmen yang lebih kecil yang lebih mudah dimuat oleh QueryNode. Nilai yang lebih kecil memungkinkan segmen yang lebih besar tetapi dapat menyebabkan kegagalan pemuatan pada QueryNode yang memiliki keterbatasan memori. Sebagai contoh, dengan faktor default 4.0 dan QueryNode terkecil memiliki memori 16 GB, ukuran target yang dihitung secara otomatis tidak akan melebihi 4 GB. Hal ini mencegah Penggabungan Paksa menghasilkan segmen yang sangat besar sehingga QueryNode tidak dapat memuatnya.

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

Memicu Pemadatan Penggabungan Paksa

Anda memicu pemadatan Force Merge dengan memanggil compact() dengan parameter target_size. Untuk detail parameter, lihat Referensi parameter di bawah ini.

Tersedia tiga mode pemadatan penggabungan gaya:

compact("my_collection", target_size=?)
│
├─ Mode 1: target_size = 0 (or omitted)
│  Uses config maxSize (default 512 MB)
│  Equivalent to standard compaction
│
├─ Mode 2: target_size = 2048
│  Merges segments to ~2 GB each
│  Must be >= config maxSize
│
└─ Mode 3: target_size = max_int64
   Auto-calculates optimal size based on
   segment distribution and node memory

Berikut ini adalah contoh untuk menunjukkan cara menggunakan setiap mode pemadatan penggabungan gaya.

Default (pemadatan standar)

from pymilvus import MilvusClient

client = MilvusClient(
    uri="http://localhost:19530",
    token="root:Milvus"
)

# Standard compaction — uses config maxSize (default 512 MB)
job_id = client.compact("target_collection")

Ukuran target eksplisit

# Merge segments to approximately 2 GB each
job_id = client.compact(
    "target_collection",
    target_size="2048"  # The unit is MB
)

Perhitungan ukuran otomatis

# Let Milvus determine the optimal segment size
max_int64 = (1 << 63) - 1
job_id = client.compact(
    "target_collection",
    target_size=max_int64
)

Referensi parameter

Tabel berikut menjelaskan parameter.

Parameter	Jenis	Deskripsi
collection_name	str	Wajib. Nama koleksi yang akan dipadatkan.
target_size	int	Opsional. Ukuran segmen target dalam MB. Ada 3 pilihan nilai parameter: 0 atau dihilangkan: Menggunakan dataCoord.segment.maxSize yang telah dikonfigurasi (default: 512 MB). Setara dengan pemadatan standar. Nilai eksplisit: Menggabungkan segmen menjadi kira-kira ukuran yang ditentukan dalam MB (mis. 2048). Harus lebih besar dari atau sama dengan yang dikonfigurasi dataCoord.segment.maxSize. max_int64 ((1 << 63) - 1): Secara otomatis menghitung ukuran optimal berdasarkan distribusi segmen saat ini dan sumber daya simpul yang tersedia.

Memeriksa Kemajuan Pemadatan

Pemadatan Penggabungan Paksa berjalan secara asinkron. Gunakan ID pekerjaan yang dikembalikan untuk memeriksa kemajuan:

# Check compaction state
state = client.get_compaction_state(job_id)
print(f"State: {state}")

Praktik terbaik

• Jangan gunakan pemadatan penggabungan paksa di lingkungan produksi.

• Gunakan mode penghitungan ukuran otomatis untuk sebagian besar kasus. Mengatur target_size ke max_int64 memungkinkan Milvus menganalisis distribusi segmen dan sumber daya simpul untuk menentukan ukuran terbaik. Ini adalah pendekatan yang direkomendasikan kecuali Anda memiliki persyaratan ukuran tertentu.

• Pertimbangkan pertukaran kinerja. Pemadatan Force Merge adalah operasi yang membutuhkan banyak sumber daya. Operasi ini membaca, menggabungkan, dan menulis ulang data segmen. Jadwalkan selama periode lalu lintas rendah untuk meminimalkan dampak pada latensi kueri.

• Pantau jumlah segmen sebelum dan sesudahnya. Gunakan get_compaction_state() dan list_persistent_segments untuk memverifikasi bahwa pemadatan menghasilkan segmen yang lebih sedikit dan lebih besar seperti yang diharapkan.

PERTANYAAN UMUM

Apa perbedaan Penggabungan Paksa dengan pemadatan standar?

Kedua jenis operasi pemadatan ini memiliki tujuan yang berbeda.

• Pemadatan standar (targetSize = 0 atau dihilangkan) adalah upaya terbaik, jalur pembersihan tambahan.

• Penggabungan paksa (targetSize>0) adalah jalur pengemasan ulang tingkat koleksi untuk menghasilkan segmen yang lebih sedikit, lebih besar, dan mendekati target.

Perbedaan utamanya adalah bentuk penggabungan: pemadatan standar secara efektif adalah m → 1 per tugas, sedangkan penggabungan paksa adalah m → n di seluruh input yang dikelompokkan. Inilah sebabnya mengapa penggabungan paksa dapat menyelesaikan tata letak segmen yang tidak dapat dilakukan oleh pemadatan standar. Tabel berikut ini membandingkan 2 jenis operasi tersebut.

Dimensi	Pemadatan standar (default)	Penggabungan paksa
Pemicu API	targetSize = 0 (atau tidak disetel), tidak ada flag Major/L0	targetUkuran>0 (MB)
Tujuan utama	Pembersihan tambahan dari fragmen yang jelas; pemeliharaan rutin	Konsolidasi seluruh koleksi untuk pencarian dan keseimbangan
Sumber ukuran segmen	Memperbaiki dataCoord.segment.maxSize (konfigurasi server)	Ukuran target pengguna, kemudian dijepit dengan pengaman oleh maxSafeSize
Validitas parameter	Tidak ada penyetelan ukuran pengguna	TargetSize pengguna harus >= dataCoord.segment.maxSize; jika tidak, ditolak
Batas atas keamanan	Hanya batas konfigurasi	maxSafeSize = min(QueryNode mem, DataNode mem) / memory_factor (mandiri non-pooling: dibagi dua)
Bentuk gabungan	m → 1 per tugas, keluaran <= configMaxSize	m → n, keluaran mendekati targetSize
Perilaku segmen menengah	Dapat macet secara permanen (misalnya, dua segmen 60% tidak dapat secara legal menjadi satu segmen 120%)	Pengemasan ulang + pemisahan berfungsi; tidak ada pola "macet di 60%"
Kemampuan perataan koleksi	Terbatas; proses yang berulang-ulang mungkin masih menyisakan banyak segmen sedang	Kuat; dirancang untuk mengurangi jumlah segmen dan mendorong kepenuhan lebih tinggi
Kesadaran topologi	Tidak ada	Ya; menggunakan tata letak QueryNode/replika/pecahan
Penyetelan paralelisme jalur baca	Tidak ada	Menyesuaikan jumlah keluaran menggunakan queryNodeCount / (replika × pecahan) jika valid
Kasus penggunaan umum	Pembersihan harian dengan tingkat kemelut tinggi setelah penulisan/penghapusan	Persiapan tolok ukur, pengoptimalan pencarian, penyelarasan paralelisme beban
Ekspektasi cakupan	Jangan mengharapkan pengemasan ulang koleksi penuh	Ditujukan untuk hasil pengemasan ulang tingkat koleksi

Panduan pemilihan:

• Pilih pemadatan standar untuk pembersihan bertahap yang berisiko rendah.

• Pilih penggabungan paksa jika Anda secara eksplisit ingin membentuk kembali koleksi menjadi lebih sedikit, segmen yang lebih besar yang selaras dengan perilaku pencarian dan pemuatan.

Apa perbedaan Force Merge dengan pemadatan pengelompokan?

Pemadatan pengelompokan (is_clustering=True) mengatur ulang data dalam segmen berdasarkan kunci pengelompokan untuk meningkatkan pemangkasan pencarian. Force Merge (target_size=N) mengoptimalkan ukuran segmen tanpa mengubah distribusi data. Keduanya memiliki tujuan yang berbeda dan dapat digunakan bersamaan - jalankan pemadatan pengelompokan terlebih dahulu untuk mengatur data, lalu lakukan Penggabungan Paksa untuk menggabungkan segmen yang dihasilkan.

Dapatkah saya menjalankan Penggabungan Paksa pada koleksi yang sedang ditanyakan?

Ya. Force Merge berjalan secara asinkron dan tidak memblokir kueri. Namun, proses ini menghabiskan sumber daya DataNode dan disk I/O, sehingga latensi kueri dapat meningkat selama pemadatan. Jadwalkan Penggabungan Paksa selama periode lalu lintas rendah untuk hasil terbaik.

Apa yang terjadi jika saya menetapkan target_size lebih kecil dari maxSize?

Permintaan akan ditolak dengan kesalahan. Ukuran target harus lebih besar atau sama dengan yang dikonfigurasi dataCoord.segment.maxSize.