Index mit GPU

Dieser Leitfaden beschreibt die Schritte zur Erstellung eines Indexes mit GPU-Unterstützung in Milvus, der die Suchleistung in Szenarien mit hohem Durchsatz und hohem Abruf erheblich verbessern kann. Einzelheiten zu den von Milvus unterstützten GPU-Indexen finden Sie unter GPU-Index.

Konfigurieren Sie die Milvus-Einstellungen für die GPU-Speichersteuerung

Milvus verwendet einen globalen Grafikspeicherpool, um GPU-Speicher zuzuweisen.

Es unterstützt zwei Parameter initMemSize und maxMemSize in der Milvus-Konfigurationsdatei. Die Poolgröße ist anfänglich auf initMemSize eingestellt und wird automatisch auf maxMemSize erweitert, wenn diese Grenze überschritten wird.

Der Standardwert initMemSize ist 1/2 des verfügbaren GPU-Speichers, wenn Milvus startet, und der Standardwert maxMemSize ist gleich dem gesamten verfügbaren GPU-Speicher.

Bis zu Milvus 2.4.1 (einschließlich Version 2.4.1) verwendete Milvus einen einheitlichen GPU-Speicherpool. Für Versionen vor 2.4.1 (einschließlich Version 2.4.1) wurde empfohlen, beide Werte auf 0 zu setzen.

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. 

Ab Milvus 2.4.1 wird der GPU-Speicherpool nur noch für temporäre GPU-Daten während der Suche verwendet. Es wird daher empfohlen, ihn auf 2048 und 4096 zu setzen.

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. 

Einen Index erstellen

Die folgenden Beispiele zeigen, wie man GPU-Indizes verschiedener Typen erstellt.

Vorbereiten der Indexparameter

Beim Einrichten von GPU-Indexparametern müssen index_type, metric_type und params definiert werden:

• index_type(string): Der Typ des Index, der zur Beschleunigung der Vektorsuche verwendet wird. Gültige Optionen sind GPU_CAGRA, GPU_IVF_FLAT, GPU_IVF_PQ und GPU_BRUTE_FORCE.

• metric_type(Zeichenfolge): Der Typ der Metrik, die zur Messung der Ähnlichkeit von Vektoren verwendet wird. Gültige Optionen sind IP und L2.

• params(dict): Die indexspezifischen Bauparameter. Die gültigen Optionen für diesen Parameter hängen vom Indextyp ab.

Hier sind Beispielkonfigurationen für verschiedene Indextypen:

• GPU_CAGRA-Index

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

  Mögliche Optionen für params sind:

  • intermediate_graph_degree(int): Beeinflusst den Abruf und die Erstellungszeit, indem der Grad des Graphen vor dem Pruning bestimmt wird. Empfohlene Werte sind 32 oder 64.

  • graph_degree(int): Beeinflusst die Suchleistung und die Wiederauffindbarkeit, indem der Grad des Graphen nach dem Pruning festgelegt wird. Normalerweise beträgt er die Hälfte des intermediate_graph_degree. Ein größerer Unterschied zwischen diesen beiden Graden führt zu einer längeren Erstellungszeit. Sein Wert muss kleiner sein als der Wert von intermediate_graph_degree.

  • build_algo(String): Wählt den Algorithmus zur Graphenerzeugung vor dem Pruning. Mögliche Optionen:

    • IVF_PQ: Bietet eine höhere Qualität, aber eine langsamere Erstellungszeit.

    • NN_DESCENT: Bietet einen schnelleren Aufbau mit potenziell geringerer Wiedererkennung.

  • cache_dataset_on_device(string, "true" | "false"): Legt fest, ob der Originaldatensatz im GPU-Speicher zwischengespeichert werden soll. Die Einstellung "true" erhöht die Wiederauffindbarkeit durch Verfeinerung der Suchergebnisse, während die Einstellung "false" den GPU-Speicher schont.

• GPU_IVF_FLAT oder GPU_IVF_PQ Index

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

  Die params-Optionen sind identisch mit denen, die in IVF_FLAT und IVF_PQ verwendet werden.

• GPU_BRUTE_FORCE index

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

  Es sind keine zusätzlichen Parameterkonfigurationen erforderlich.

Index erstellen

Nach der Konfiguration der Index-Parameter in index_params, rufen Sie die create_index() Methode auf, um den Index zu erstellen.

# 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
)

Suche

Nachdem Sie Ihren GPU-Index erstellt haben, müssen Sie im nächsten Schritt die Suchparameter vorbereiten, bevor Sie eine Suche durchführen können.

Vorbereiten der Suchparameter

Nachfolgend finden Sie Beispielkonfigurationen für verschiedene Indextypen:

• GPU_BRUTE_FORCE-Index

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

  Es sind keine zusätzlichen Parameter-Konfigurationen erforderlich.

• GPU_CAGRA-Index

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

  Die wichtigsten Suchparameter sind:

  • itopk_size: Bestimmt die Größe der Zwischenergebnisse, die während der Suche gespeichert werden. Ein größerer Wert kann die Wiederauffindbarkeit auf Kosten der Suchleistung verbessern. Er sollte mindestens gleich dem endgültigen Top-k-Wert(Grenzwert) sein und ist in der Regel eine Potenz von 2 (z. B. 16, 32, 64, 128).

  • search_width: Gibt die Anzahl der Einstiegspunkte in den CAGRA-Graphen während der Suche an. Eine Erhöhung dieses Wertes kann die Wiederauffindbarkeit verbessern, kann aber die Suchleistung beeinträchtigen.

  • min_iterations / max_iterations: Diese Parameter steuern den Iterationsprozess der Suche. Standardmäßig sind sie auf 0 gesetzt, und CAGRA bestimmt die Anzahl der Iterationen automatisch anhand von itopk_size und search_width. Eine manuelle Anpassung dieser Werte kann helfen, Leistung und Genauigkeit auszugleichen.

  • team_size: Gibt die Anzahl der CUDA-Threads an, die für die Berechnung des metrischen Abstands auf der GPU verwendet werden. Übliche Werte sind eine Potenz von 2 bis zu 32 (z. B. 2, 4, 8, 16, 32). Er hat einen geringen Einfluss auf die Suchleistung. Der Standardwert ist 0, wobei Milvus die team_size automatisch auf der Grundlage der Vektordimension auswählt.

• GPU_IVF_FLAT- oder GPU_IVF_PQ-Index

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

  Die Suchparameter für diese beiden Indextypen sind ähnlich wie die für IVF_FLAT und IVF_PQ verwendeten. Weitere Informationen finden Sie unter Durchführen einer Vektorähnlichkeitssuche.

Durchführen einer Suche

Verwenden Sie die search() Methode, um eine Vektorähnlichkeitssuche im GPU-Index durchzuführen.

# 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
)

Grenzen

Bei der Verwendung von GPU-Indizes müssen bestimmte Einschränkungen beachtet werden:

• Für GPU_IVF_FLAT beträgt der Höchstwert für limit 1024.

• Für GPU_IVF_PQ und GPU_CAGRA ist der Höchstwert für limit 1024.

• Für GPU_BRUTE_FORCE gibt es zwar keinen festen Grenzwert, es wird jedoch empfohlen, 4096 nicht zu überschreiten, um mögliche Leistungsprobleme zu vermeiden.

• Derzeit unterstützen GPU-Indizes keinen COSINE-Abstand. Wenn der COSINE-Abstand erforderlich ist, sollten die Daten zuerst normalisiert werden, und dann kann der Innenproduktabstand (IP) als Ersatz verwendet werden.

• Das Laden von OOM-Schutz für GPU-Indizes wird nicht vollständig unterstützt, zu viele Daten können zum Absturz von QueryNode führen.

• GPU-Indizes unterstützen keine Suchfunktionen wie Bereichssuche und Gruppierungssuche.

FAQ

• Wann ist es sinnvoll, einen GPU-Index zu verwenden?

  Ein GPU-Index ist besonders vorteilhaft in Situationen, die einen hohen Durchsatz oder eine hohe Wiederauffindung erfordern. Bei großen Stapeln kann der Durchsatz der GPU-Indizierung beispielsweise den der CPU-Indizierung um das 100-fache übertreffen. In Szenarien mit kleineren Stapeln übertrifft die GPU-Indizierung die CPU-Indizierung in Bezug auf die Leistung immer noch deutlich. Darüber hinaus kann der Einsatz eines Grafikprozessors den Prozess der Indexerstellung erheblich beschleunigen, wenn Daten schnell eingefügt werden müssen.

• Für welche Szenarien sind GPU-Indizes wie CAGRA, GPU_IVF_PQ, GPU_IVF_FLAT und GPU_BRUTE_FORCE am besten geeignet?

  CAGRA-Indizes sind ideal für Szenarien, die eine höhere Leistung erfordern, auch wenn dies mit einem höheren Speicherbedarf einhergeht. In Umgebungen, in denen Speicherplatzeinsparung Priorität hat, kann der GPU_IVF_PQ-Index dazu beitragen, die Speicheranforderungen zu minimieren, auch wenn dies mit einem höheren Präzisionsverlust einhergeht. Der GPU_IVF_FLAT-Index stellt eine ausgewogene Option dar, die einen Kompromiss zwischen Leistung und Speicherbedarf bietet. Der GPU_BRUTE_FORCE-Index schließlich ist für erschöpfende Suchvorgänge konzipiert und garantiert durch die Durchführung von Traversalsuchen eine Abrufrate von 1.