Índice con GPU

Esta guía describe los pasos para construir un índice con soporte GPU en Milvus, que puede mejorar significativamente el rendimiento de la búsqueda en escenarios de alto rendimiento y alta recuperación. Para más detalles sobre los tipos de índices GPU soportados por Milvus, consulte Índice GPU.

Configure los ajustes de Milvus para el control de la memoria de la GPU

Milvus utiliza un pool de memoria gráfica global para asignar memoria GPU.

Admite dos parámetros initMemSize y maxMemSize en el archivo de configuración de Milvus. El tamaño del pool se establece inicialmente en initMemSize, y se ampliará automáticamente a maxMemSize una vez superado este límite.

El valor por defecto initMemSize es 1/2 de la memoria GPU disponible cuando Milvus se inicia, y el valor por defecto maxMemSize es igual a toda la memoria GPU disponible.

Hasta Milvus 2.4.1( incluyendo la versión 2.4.1), Milvus utilizaba un pool de memoria GPU unificado. Para versiones anteriores a la 2.4.1( incluyendo la versión 2.4.1), se recomendaba poner ambos valores a 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. 

A partir de Milvus 2.4.1, el pool de memoria de la GPU sólo se utiliza para datos temporales de la GPU durante las búsquedas. Por lo tanto, se recomienda establecerla en 2048 y 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. 

Construir un índice

Los siguientes ejemplos muestran cómo construir índices GPU de diferentes tipos.

Preparar los parámetros del índice

Al configurar los parámetros de índice de la GPU, defina index_type, metric_type y params:

• index_type(cadena): El tipo de índice utilizado para acelerar la búsqueda vectorial. Las opciones válidas son GPU_CAGRA, GPU_IVF_FLAT, GPU_IVF_PQ y GPU_BRUTE_FORCE.

• metric_type(cadena): El tipo de métrica utilizada para medir la similitud de los vectores. Las opciones válidas son IP y L2.

• params(dict): Los parámetros de construcción específicos del índice. Las opciones válidas para este parámetro dependen del tipo de índice.

A continuación se muestran configuraciones de ejemplo para distintos tipos de índice:

• ÍndiceGPU_CAGRA

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

  Las opciones posibles para params incluyen:

  • intermediate_graph_degree(int): Afecta a la recuperación y al tiempo de construcción al determinar el grado del gráfico antes de la poda. Los valores recomendados son 32 o 64.

  • grado_grafico(int): Afecta al rendimiento de la búsqueda y a la recuperación estableciendo el grado del gráfico después de la poda. Normalmente, es la mitad del grado_grafo_intermedio. Una diferencia mayor entre estos dos grados se traduce en un tiempo de construcción más largo. Su valor debe ser menor que el de grado_grafo_intermedio.

  • build_algo(cadena): Selecciona el algoritmo de generación de grafos antes de la poda. Opciones posibles:

    • IVF_PQ: Ofrece mayor calidad pero un tiempo de construcción más lento.

    • NN_DESCENT: Proporciona una construcción más rápida con una recuperación potencialmente menor.

  • cache_dataset_on_device(cadena, "true" | "false"): Decide si se almacena en caché el conjunto de datos original en la memoria de la GPU. Si se establece en " true" se mejora la recuperación al refinar los resultados de búsqueda, mientras que si se establece en "false" se conserva la memoria de la GPU.

• ÍndiceGPU_IVF_FLAT o GPU_IVF_PQ

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

  Las opciones params son idénticas a las utilizadas en IVF_FLAT e IVF_PQ.

• GPU_BRUTE_FORCE índice

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

  No se requieren configuraciones params adicionales.

Construir índice

Después de configurar los parámetros del índice en index_params, llama al método create_index() para construir el índice.

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

Buscar en

Una vez construido el índice GPU, el siguiente paso es preparar los parámetros de búsqueda antes de realizar una búsqueda.

Preparar los parámetros de búsqueda

A continuación se muestran configuraciones de ejemplo para diferentes tipos de índices:

• ÍndiceGPU_BRUTE_FORCE

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

  No es necesario configurar ningún parámetro adicional.

• ÍndiceGPU_CAGRA

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

  Los parámetros clave de búsqueda son

  • itopk_size: Determina el tamaño de los resultados intermedios guardados durante la búsqueda. Un valor mayor puede mejorar la recuperación a expensas del rendimiento de la búsqueda. Debe ser al menos igual al valor final top-k(límite) y suele ser una potencia de 2 (por ejemplo, 16, 32, 64, 128).

  • search_width: Especifica el número de puntos de entrada en el gráfico CAGRA durante la búsqueda. Aumentar este valor puede mejorar la recuperación, pero puede afectar al rendimiento de la búsqueda.

  • min_iterations / max_iterations: Estos parámetros controlan el proceso de iteración de la búsqueda. Por defecto, están fijados en 0, y CAGRA determina automáticamente el número de iteraciones en función de itopk_size y search_width. Ajustar estos valores manualmente puede ayudar a equilibrar el rendimiento y la precisión.

  • tamaño_equipo: Especifica el número de subprocesos CUDA utilizados para calcular la distancia métrica en la GPU. Los valores habituales son una potencia de 2 hasta 32 (por ejemplo, 2, 4, 8, 16, 32). Tiene un impacto menor en el rendimiento de la búsqueda. El valor por defecto es 0, donde Milvus selecciona automáticamente el team_size basado en la dimensión del vector.

• Índice GPU_IVF_FLAT o GPU_IVF_PQ

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

  Los parámetros de búsqueda para estos dos tipos de índice son similares a los utilizados en IVF_FLAT e IVF_PQ. Para obtener más información, consulte Realizar una búsqueda de similitud vectorial.

Realizar una búsqueda

Utilice el método search() para realizar una búsqueda de similitud vectorial en el índice 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
)

Límites

Cuando utilice índices GPU, tenga en cuenta ciertas restricciones:

• Para GPU_IVF_FLAT, el valor máximo de límite es 1024.

• Para GPU_IVF_PQ y GPU_CAGRA, el valor máximo de limit es 1024.

• Aunque no hay un límite establecido para GPU_BRUTE_FORCE, se recomienda no superar los 4096 para evitar posibles problemas de rendimiento.

• Actualmente, los índices GPU no soportan la distancia COSINE. Si se requiere la distancia COSINE, los datos deben ser normalizados en primer lugar, y luego la distancia de producto interno (IP) se puede utilizar como sustituto.

• La carga de la protección OOM para los índices de la GPU no está totalmente soportada, demasiados datos pueden provocar fallos en el QueryNode.

• Los índices GPU no soportan funciones de búsqueda como la búsqueda por rango y la búsqueda por agrupación.

PREGUNTAS FRECUENTES

• ¿Cuándo es apropiado utilizar un índice GPU?

  Un índice de GPU es especialmente beneficioso en situaciones que exigen un alto rendimiento o una alta recuperación. Por ejemplo, cuando se trata de grandes lotes, el rendimiento de la indexación en la GPU puede superar hasta 100 veces el de la indexación en la CPU. En situaciones con lotes más pequeños, los índices de la GPU siguen superando significativamente a los de la CPU en términos de rendimiento. Además, si se requiere una rápida inserción de datos, la incorporación de una GPU puede acelerar sustancialmente el proceso de creación de índices.

• ¿En qué escenarios son más adecuados los índices de GPU como CAGRA, GPU_IVF_PQ, GPU_IVF_FLAT y GPU_BRUTE_FORCE?

  Los índices CAGRA son ideales para escenarios que exigen un mayor rendimiento, aunque a costa de consumir más memoria. Para entornos en los que la conservación de la memoria es una prioridad, el índice GPU_IVF_PQ puede ayudar a minimizar los requisitos de almacenamiento, aunque esto viene acompañado de una mayor pérdida de precisión. El índice GPU_IVF_FLAT sirve como opción equilibrada, ofreciendo un compromiso entre rendimiento y consumo de memoria. Por último, el índice GPU_BRUTE_FORCE está diseñado para operaciones de búsqueda exhaustiva, garantizando una tasa de recuperación de 1 mediante la realización de búsquedas transversales.