Indeks dengan GPU

Panduan ini menguraikan langkah-langkah untuk membuat indeks dengan dukungan GPU di Milvus, yang secara signifikan dapat meningkatkan performa pencarian dalam skenario throughput tinggi dan recall tinggi. Untuk detail tentang jenis indeks GPU yang didukung oleh Milvus, lihat Indeks GPU.

Mengonfigurasi pengaturan Milvus untuk kontrol memori GPU

Milvus menggunakan kumpulan memori grafis global untuk mengalokasikan memori GPU.

Ini mendukung dua parameter initMemSize dan maxMemSize dalam file konfigurasi Milvus. Ukuran pool pada awalnya diatur ke initMemSize, dan akan secara otomatis diperluas ke maxMemSize setelah melebihi batas ini.

Default initMemSize adalah 1/2 dari memori GPU yang tersedia saat Milvus dijalankan, dan default maxMemSize sama dengan semua memori GPU yang tersedia.

Hingga Milvus 2.4.1 (termasuk versi 2.4.1), Milvus menggunakan kumpulan memori GPU terpadu. Untuk versi sebelum 2.4.1 (termasuk versi 2.4.1), direkomendasikan untuk mengatur kedua nilai tersebut ke 0.

gpu:
  initMemSize: 0 #set the initial memory pool size.
  maxMemSize: 0 #maxMemSize sets the maximum memory usage limit. When the memory usage exceed initMemSize, Milvus will attempt to expand the memory pool. 

Mulai Milvus 2.4.1 dan seterusnya, kumpulan memori GPU hanya digunakan untuk data GPU sementara selama pencarian. Oleh karena itu, disarankan untuk mengaturnya ke 2048 dan 4096.

gpu:
  initMemSize: 2048 #set the initial memory pool size.
  maxMemSize: 4096 #maxMemSize sets the maximum memory usage limit. When the memory usage exceed initMemSize, Milvus will attempt to expand the memory pool. 

Membangun indeks

Contoh berikut ini menunjukkan cara membuat indeks GPU dengan tipe yang berbeda.

Menyiapkan parameter indeks

Saat menyiapkan parameter indeks GPU, tentukan index_type, metric_type, dan params:

• index_type(string): Jenis indeks yang digunakan untuk mempercepat pencarian vektor. Pilihan yang valid termasuk GPU_CAGRA, GPU_IVF_FLAT, GPU_IVF_PQ, dan GPU_BRUTE_FORCE.

• metric_type(string): Jenis metrik yang digunakan untuk mengukur kemiripan vektor. Opsi yang valid adalah IP dan L2.

• params(dict): Parameter bangunan khusus indeks. Opsi yang valid untuk parameter ini bergantung pada jenis indeks.

Berikut adalah contoh konfigurasi untuk berbagai jenis indeks:

• IndeksGPU_CAGRA

  index_params = {
      "metric_type": "L2",
      "index_type": "GPU_CAGRA",
      "params": {
          'intermediate_graph_degree': 64,
          'graph_degree': 32
      }
  }
  

  Opsi yang mungkin untuk params meliputi:

  • intermediate_graph_degree(int): Mempengaruhi waktu pemanggilan dan pembuatan dengan menentukan derajat grafik sebelum pemangkasan. Nilai yang disarankan adalah 32 atau 64.

  • graph_degree(int): Mempengaruhi performa pencarian dan pemanggilan dengan mengatur derajat graf setelah pemangkasan. Biasanya, nilai ini adalah setengah dari intermediate_graph_degree. Perbedaan yang lebih besar antara kedua derajat ini menghasilkan waktu pembangunan yang lebih lama. Nilainya harus lebih kecil dari nilai intermediate_graph_degree.

  • build_algo(string): Memilih algoritma pembuatan graf sebelum pemangkasan. Pilihan yang mungkin:

    • IVF_PQ: Menawarkan kualitas yang lebih tinggi tetapi waktu pembuatan yang lebih lambat.

    • NN_DESCENT: Menyediakan pembuatan yang lebih cepat dengan potensi penarikan yang lebih rendah.

  • cache_dataset_on_device(string, "true" | "false"): Memutuskan apakah akan menyimpan dataset asli dalam memori GPU. Mengaturnya ke "true" akan meningkatkan daya ingat dengan menyempurnakan hasil pencarian, sementara mengaturnya ke "false" akan menghemat memori GPU.

• IndeksGPU_IVF_FLAT atau GPU_IVF_PQ

  index_params = {
      "metric_type": "L2",
      "index_type": "GPU_IVF_FLAT", # Or GPU_IVF_PQ
      "params": {
          "nlist": 1024
      }
  }
  

  Opsi parameter identik dengan yang digunakan dalam IVF_FLAT dan IVF_PQ.

• IndeksGPU_BRUTE_FORCE

  index_params = {
      'index_type': 'GPU_BRUTE_FORCE',
      'metric_type': 'L2',
      'params': {}
  }
  

  Tidak ada konfigurasi params tambahan yang diperlukan.

Membangun indeks

Setelah mengonfigurasi parameter indeks di index_params, panggil metode create_index() untuk membangun indeks.

# Get an existing collection
collection = Collection("YOUR_COLLECTION_NAME")

collection.create_index(
    field_name="vector", # Name of the vector field on which an index is built
    index_params=index_params
)

Pencarian

Setelah Anda membuat indeks GPU, langkah selanjutnya adalah menyiapkan parameter pencarian sebelum melakukan pencarian.

Menyiapkan parameter pencarian

Di bawah ini adalah contoh konfigurasi untuk berbagai jenis indeks:

• IndeksGPU_BRUTE_FORCE

  search_params = {
      "metric_type": "L2",
      "params": {}
  }
  

  Tidak ada konfigurasi parameter tambahan yang diperlukan.

• IndeksGPU_CAGRA

  search_params = {
      "metric_type": "L2",
      "params": {
          "itopk_size": 128,
          "search_width": 4,
          "min_iterations": 0,
          "max_iterations": 0,
          "team_size": 0
      }
  }
  

  Parameter pencarian utama meliputi:

  • itopk_size: Menentukan ukuran hasil perantara yang disimpan selama pencarian. Nilai yang lebih besar dapat meningkatkan daya ingat dengan mengorbankan kinerja pencarian. Setidaknya harus sama dengan nilai top-k(batas) akhir dan biasanya merupakan pangkat 2 (misalnya, 16, 32, 64, 128).

  • search_width: Menentukan jumlah titik masuk ke dalam grafik CAGRA selama pencarian. Meningkatkan nilai ini dapat meningkatkan daya ingat tetapi dapat mempengaruhi kinerja pencarian.

  • min_iterations / max_iterations: Parameter ini mengontrol proses iterasi pencarian. Secara default, keduanya diatur ke 0, dan CAGRA secara otomatis menentukan jumlah iterasi berdasarkan itopk_size dan search_width. Menyesuaikan nilai-nilai ini secara manual dapat membantu menyeimbangkan kinerja dan akurasi.

  • team_size: Menentukan jumlah thread CUDA yang digunakan untuk menghitung jarak metrik pada GPU. Nilai yang umum adalah pangkat 2 hingga 32 (mis. 2, 4, 8, 16, 32). Ini memiliki dampak kecil pada kinerja pencarian. Nilai defaultnya adalah 0, di mana Milvus secara otomatis memilih team_size berdasarkan dimensi vektor.

• IndeksGPU_IVF_FLAT atau GPU_IVF_PQ

  search_params = {
      "metric_type": "L2", 
      "params": {"nprobe": 10}
  }
  

  Parameter pencarian untuk kedua jenis indeks ini serupa dengan yang digunakan pada IVF_FLAT dan IVF_PQ. Untuk informasi lebih lanjut, lihat Melakukan Pencarian Kemiripan Vektor.

Melakukan pencarian

Gunakan metode search() untuk melakukan pencarian kemiripan vektor pada indeks GPU.

# Load data into memory
collection.load()

collection.search(
    data=[[query_vector]], # Your query vector
    anns_field="vector", # Name of the vector field
    param=search_params,
    limit=100 # Number of the results to return
)

Batas

Saat menggunakan indeks GPU, perhatikan batasan tertentu:

• Untuk GPU_IVF_FLAT, nilai maksimum untuk batas adalah 1024.

• Untuk GPU_IVF_PQ dan GPU_CAGRA, nilai maksimum untuk limit adalah 1024.

• Meskipun tidak ada batas yang ditetapkan untuk limit pada GPU_BRUTE_FORCE, disarankan untuk tidak melebihi 4096 untuk menghindari potensi masalah kinerja.

• Saat ini, indeks GPU tidak mendukung jarak COSINE. Jika jarak COSINE diperlukan, data harus dinormalisasi terlebih dahulu, lalu jarak inner product (IP) dapat digunakan sebagai pengganti.

• Memuat perlindungan OOM untuk indeks GPU tidak sepenuhnya didukung, terlalu banyak data dapat menyebabkan QueryNode macet.

• Indeks GPU tidak mendukung fungsi pencarian seperti pencarian rentang dan pencarian pengelompokan.

PERTANYAAN UMUM

• Kapan waktu yang tepat untuk menggunakan indeks GPU?

  Indeks GPU sangat bermanfaat dalam situasi yang menuntut throughput tinggi atau pemanggilan tinggi. Misalnya, saat menangani batch besar, throughput pengindeksan GPU dapat melampaui throughput pengindeksan CPU sebanyak 100 kali lipat. Dalam skenario dengan batch yang lebih kecil, indeks GPU masih secara signifikan mengungguli indeks CPU dalam hal kinerja. Selain itu, jika ada persyaratan untuk penyisipan data yang cepat, menggabungkan GPU dapat mempercepat proses pembuatan indeks secara substansial.

• Dalam skenario apa indeks GPU seperti CAGRA, GPU_IVF_PQ, GPU_IVF_FLAT, dan GPU_BRUTE_FORCE paling cocok?

  Indeks CAGRA ideal untuk skenario yang menuntut peningkatan performa, meskipun dengan biaya konsumsi memori yang lebih besar. Untuk lingkungan di mana konservasi memori menjadi prioritas, indeks GPU_IVF_PQ dapat membantu meminimalkan kebutuhan penyimpanan, meskipun hal ini disertai dengan kehilangan presisi yang lebih tinggi. Indeks GPU_IVF_FLAT berfungsi sebagai opsi yang seimbang, menawarkan kompromi antara performa dan penggunaan memori. Terakhir, indeks GPU_BRUTE_FORCE dirancang untuk operasi pencarian yang menyeluruh, menjamin tingkat recall 1 dengan melakukan pencarian traversal.