Usa Vertex Matching Engine

En esta guía, se explica cómo configurar y usar Vertex Matching Engine para realizar búsquedas de similitud de vectores.

Configura la conexión de intercambio de tráfico entre redes de VPC

A fin de reducir la latencia de red para las consultas en línea de coincidencias de vectores, llama a los extremos del servicio de Vertex AI desde tu VPC a través del acceso privado a servicios. Por cada proyecto de Google Cloud, solo una red de VPC puede intercambiar tráfico con Matching Engine. Si ya tienes una VPC con el acceso privado a servicios configurado, puedes usar esa VPC para intercambiar tráfico con Vertex Match Engine.

Configurar una conexión de intercambio de tráfico entre redes de VPC es una tarea inicial que se requiere solo una vez por proyecto de Google Cloud. Una vez que se establece esta configuración, puedes realizar llamadas al índice de Matching Engine desde cualquier cliente que se ejecute dentro de tu VPC.

La conexión de intercambio de tráfico entre redes de VPC solo es necesaria para consultas en línea que coincidan con los vectores. Las llamadas a la API para crear, implementar y borrar índices no requieren una conexión de intercambio de tráfico entre redes de VPC.

Haz que tu administrador del proyecto de Google Cloud o el administrador de la red completen estos pasos:

  1. Sigue estos pasos para configurar tus proyectos de Google Cloud, habilitar la facturación y habilitar las API.

  2. Antes de crear una conexión privada, debes asignar un rango de direcciones IP que usará el servicio de motor de coincidencias. Esto garantiza que no haya una colisión de direcciones IP entre tu red de VPC y la red de nuestro productor de servicios en la que se implementan los índices de coincidente. Consulta más documentos aquí.

    # NOTE: `prefix-length=16` means a CIDR block with mask /16 will be reserved
    # for use by Google services. Make sure to enable Service Networking API.
    gcloud compute addresses create $PEERING_RANGE_NAME \
      --global \
      --prefix-length=16 \
      --description="peering range for Matching Engine service" \
      --network=$NETWORK_NAME \
      --purpose=VPC_PEERING \
      --project=$PROJECT_ID
    
    # Create the VPC connection.
    gcloud services vpc-peerings connect \
      --service=servicenetworking.googleapis.com \
      --network=$NETWORK_NAME \
      --ranges=$PEERING_RANGE_NAME \
      --project=$PROJECT_ID
    

Ejemplo de bloc de notas

Después de completar la configuración inicial de intercambio de tráfico entre redes de VPC, puedes crear una instancia de Notebooks dentro de esa VPC y emitir comandos desde el notebook.

Inicia el notebook de ejemplo en Notebooks o visualiza el notebook en GitHub.

Control de acceso

Vertex AI usa Identity and Access Management (IAM) para administrar el acceso a los recursos. Para otorgar acceso a un recurso, asigna una o más funciones a un usuario, un grupo o una cuenta de servicio.

Si quieres usar Match Engineer, usa estas funciones predefinidas para otorgar diferentes niveles de acceso a los recursos a nivel de proyecto.

Formato y estructura de los datos de entrada

En esta sección, se describe la estructura y el formato con los que se deben proporcionar vectores a Matching Engine, ya sea para compilar un índice nuevo o actualizar un índice existente.

Almacenamiento de datos de entrada

Almacena los datos de entrada en un bucket de Cloud Storage en el proyecto de Google Cloud.

Estructura del directorio de entrada

En esta sección, se explica cómo estructurar tu directorio de datos de entrada.

  • Directorio raíz por lotes: Crea un directorio raíz para cada lote de archivos de datos de entrada. Debe ser un directorio único de Cloud Storage, que en este ejemplo se llama batch_root.
  • Asignación de nombres de archivo: Coloca archivos de datos individuales directamente en batch_root y asígnales los siguientes sufijos: .csv, .json o .avro según el formato de archivo que uses.

    • Matching Engine interpreta cada archivo de datos como un conjunto de registros

      El formato del registro se determina mediante el sufijo del nombre del archivo y se describe en una de las siguientes secciones.

    • Cada registro debe tener un ID y un vector de atributos, opcionalmente con campos adicionales, como restricciones y multiplicidad.

  • Borrar directorio: Puedes crear un subdirectorio delete en batch_root. Este directorio es opcional.

    • Cada archivo que se encuentra directamente en batch_root/delete es un archivo de texto de ID de registro, con un ID en cada línea. Cada ID debe ser una string UTF-8 válida.
  • Se ignorarán todos los demás directorios y archivos.

  • Todos los registros de todos los archivos de datos, incluidos los de delete, constan de un solo lote de entrada. El orden relativo de los registros dentro de un archivo de datos es inmaterial.

  • Un ID único debe aparecer una sola vez en un lote.

    • Nota: Un ID tampoco puede aparecer en un archivo de datos regulares y en un archivo de datos delete.
  • Todos los ID de un archivo de datos en delete causarán que este se quite de la próxima versión del índice. En la próxima versión, se incluirán los registros de archivos de datos regulares, y es posible que se reemplace un valor en una versión anterior del índice.

Formatos de archivo de datos

En esta sección, se describen los requisitos de formato para cada archivo de datos individual. Los archivos de datos pueden ser archivos CSV, JSON o Avro.

CSV

  • Codifica el archivo mediante UTF-8.
  • Cada línea debe ser un archivo CSV válido y se interpretará como un registro único.
  • El primer valor debe ser el id. Debe ser una string válida con el formato UTF-8.
  • Los siguientes valores N deben ser el vector de atributos. N es la dimensión del vector de atributos y debe configurarse cuando se crea un índice. Cada valor debe ser un literal de punto flotante como se define en las especificaciones del lenguaje Java.

JSON

  • El archivo se debe codificar con UTF-8.
  • Cada línea debe ser un objeto JSON válido, que se interpretará como un registro.
  • Cada registro debe tener un campo llamado id, que es el ID del vector. Debe ser una string válida con el formato UTF-8.
  • Cada registro debe tener un campo llamado embedding y debe ser un array de números. Este es el vector de atributos.

AVRO

  • Debe ser un archivo Avro válido.
  • Los registros de Avro deben tener una estructura similar a la definida en formato JSON. En particular, la estructura debe cumplir con el siguiente esquema:

    {
       "type": "record",
       "name": "FeatureVector",
       "fields": [
          {"name": "id", "type": "string"},
          {"name": "embedding",
           "type": {
              "type": "array",
              "items": "float"
            }
          }
       ]
    }
    

Administra índices

En esta sección, se describe cómo crear, borrar o actualizar índices. Consulta los documentos de la API sobre los índices.

Archivo de metadatos de índice

Antes de crear un índice, debes configurar los parámetros para tu índice.

Por ejemplo, crea un archivo llamado index_metadata.json:

{
  "contentsDeltaUri": "gs://BUCKET_NAME/path",
  "config": {
    "dimensions": 100,
    "approximateNeighborsCount": 150,
    "distanceMeasureType": "DOT_PRODUCT_DISTANCE",
    "algorithm_config": {
      "treeAhConfig": {
        "leafNodeEmbeddingCount": 500,
        "leafNodesToSearchPercent": 7
      }
    }
  }
}

Puedes encontrar la definición de cada uno de estos campos en Configura índices o ver las definiciones en el siguiente esquema:

title: NearestNeighborSearch
type: object
properties:
  contentsDeltaUri:
    type: string
    description: >
      Allows inserting, updating  or deleting the contents of the Matching Engine Index.
      The string must be a valid Cloud Storage directory path. If this
      field is set when calling IndexService.UpdateIndex, then no other
      Index field can be also updated as part of the same call.
      The expected structure and format of the files this URI points to is
      described at https://cloud.google.com/vertex-ai/docs/matching-engine/using-matching-engine#input-data-format
    writeOnly: true
  isCompleteOverwrite:
    type: boolean
    description: >
      If this field is set together with contentsDeltaUri when calling IndexService.UpdateIndex,
      then existing content of the Index will be replaced by the data from the contentsDeltaUri.
    default: false
  config:
    type: object
    description: >
      The configuration of the Matching Engine Index.
    required:
    - dimensions
    - algorithmConfig
    properties:
      dimensions:
        type: integer
        format: int32
        description: >
          The number of dimensions of the input vectors.
      approximateNeighborsCount:
        type: integer
        format: int32
        description: >
          The default number of neighbors to find via approximate search before exact reordering is
          performed. Exact reordering is a procedure where results returned by an
          approximate search algorithm are reordered via a more expensive distance computation.
          Required if tree-AH algorithm is used.
      distanceMeasureType:
        description: >
          The distance measure used in nearest neighbor search.
        oneOf:
        - enum: [SQUARED_L2_DISTANCE]
          description: >
            Euclidean (L_2) Distance
        - enum: [L1_DISTANCE]
          description: >
            Manhattan (L_1) Distance
        - enum: [COSINE_DISTANCE]
          description: >
            Cosine Distance. Defined as 1 - cosine similarity.
        - enum: [DOT_PRODUCT_DISTANCE]
          description: >
            Dot Product Distance. Defined as a negative of the dot product
        default: DOT_PRODUCT_DISTANCE
      featureNormType:
        description: >
          Type of normalization to be carried out on each vector.
        oneOf:
        - enum: [UNIT_L2_NORM]
          description: >
            Unit L2 normalization type.
        - enum: [NONE]
          description: >
            No normalization type is specified.
        default: NONE
      algorithmConfig:
        description: >
          The configuration with regard to the algorithms used for efficient search.
        oneOf:
        - type: object
          description: >
             Configuration options for using the tree-AH algorithm (Shallow tree + Asymmetric Hashing).
             Please refer to this paper for more details: https://arxiv.org/abs/1908.10396
          properties:
            type:
              type: string
              enum: [treeAhConfig]
            leafNodeEmbeddingCount:
              type: integer
              format: int64
              description: >
                 Number of embeddings on each leaf node. The default value is 1000 if not set.
            leafNodesToSearchPercent:
              type: number
              format: int32
              description: >
                 The default percentage of leaf nodes that any query may be searched. Must be in
                 range 1-100, inclusive. The default value is 10 (means 10%) if not set.
        - type: object
          description: >
             Configuration options for using brute force search, which simply implements the
             standard linear search in the database for each query.
          properties:
            type:
              type: string
              enum: [bruteForceConfig]
        discriminator:
          propertyName: type

Este archivo de esquema de metadatos está disponible para descargar desde Cloud Storage.

Crea un índice

Para crear un índice, sigue estos pasos:

  1. Define los metadatos de índices
  2. Envía la solicitud mediante gcloud beta ai indexes create:

    gcloud beta ai indexes create \
      --display-name=INDEX_NAME \
      --description=test \
      --metadata-file=LOCAL_PATH_TO_METADATA_FILE \
      --project=PROJECT_ID \
      --region=us-central1
    

Como alternativa, aquí se muestra un ejemplo de una llamada a la API de curl con los metadatos de índice que se pasaron directamente:

curl -X POST -H "Content-Type: application/json" \
-H "Authorization: Bearer `gcloud auth print-access-token`" \
https://us-central1-aiplatform.googleapis.com/v1/projects/${PROJECT_ID}/locations/us-central1/indexes \
-d '{
    displayName: "'${DISPLAY_NAME}'",
    description: "'${DESCRIPTION}'",
    metadata: {
       contentsDeltaUri: "'${INPUT_DIR}'",
       config: {
          dimensions: 100,
          approximateNeighborsCount: 150,
          distanceMeasureType: "DOT_PRODUCT_DISTANCE",
          algorithm_config: {
          treeAhConfig: {
            leafNodeEmbeddingCount: 500,
            leafNodesToSearchPercent: 7
            }
          }
       }
    }
}'

El siguiente es el resultado de ejemplo:

{
  "name": "projects/xxx/locations/us-central1/indexes/xxxx/operations/yyyy",
  "metadata": {...}
}

Observa el resultado de la operación y busca la línea que contiene "name": "projects/xxxx/locations/us-central1/indexes/xxx/operations/yyyy". La parte yyyy es el ID de la operación. Sondea el resultado de la operación hasta que se complete correctamente. Espera hasta que "done": true se incluya en la respuesta.

curl -H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json" \
https://us-central1-aiplatform.googleapis.com/v1/projects/${PROJECT_ID}/locations/us-central1/indexes/xxxx/operations/yyyy"

Mostrar lista de índices

Para enumerar índices, ejecuta el siguiente comandogcloud beta ai indexes list:

gcloud beta ai indexes list \
  --project=PROJECT_ID \
  --region=us-central1

Actualiza el contenido del índice

Para actualizar el contenido de un índice existente, usa el método IndexService.UpdateIndex.

Para reemplazar el contenido existente de un Index, haz lo siguiente:

  • Configura Index.metadata.contentsDeltaUri como el URI de Cloud Storage que incluye los vectores que deseas actualizar.
  • Establecer isCompleteOverwrite como verdadero.

Si configuras el campo contentsDeltaUri cuando llamas a IndexService.UpdateIndex, tampoco se puede actualizar ningún otro campo de índice (como displayName, description o userLabels) como parte de la misma llamada.

El siguiente es un ejemplo de una llamada a la API de curl:

curl -X PATCH -H "Content-Type: application/json" \
-H "Authorization: Bearer `gcloud auth print-access-token`" \
https://us-central1-aiplatform.googleapis.com/v1/projects/${PROJECT_ID}/locations/us-central1/indexes/${INDEX_ID} \
-d '{
   metadata: {
       contentsDeltaUri: "'${INPUT_DIR}'",
       isCompleteOverwrite: <true|false>
    },
}'

Igual que en la creación de un índice, sondea el resultado de la operación obtenido de la llamada UpdateIndexUpdateIndex hasta que se complete correctamente.

Si el Index tiene implementaciones asociadas (consulta el campo Index.deployed_indexes), cuando se realicen ciertos cambios en el Index original, DeployedIndex se actualizará automáticamente de forma asíncrona en segundo plano para reflejar estos cambios.

Para verificar si se propagó el cambio, compara la hora de finalización de la operación de actualización del índice y el valor DeployedIndex.index_sync_time.

Borrar índice

No puedes borrar Index hasta que todos sus Index.deployed_indexes se hayan implementado.

curl -X DELETE -H "Content-Type: application/json" \
-H "Authorization: Bearer `gcloud auth print-access-token`" \
https://us-central1-aiplatform.googleapis.com/v1/projects/${PROJECT_ID}/locations/us-central1/indexes/${INDEX_ID}

Implementa y administra índices

La implementación de un índice consiste en las siguientes tres tareas:

  1. Crea un IndexEndpoint, si es necesario, o reutiliza un IndexEndpoint existente.
  2. Obtén el ID de IndexEndpoint.
  3. Implementa el índice en IndexEndpoint.

Crea un IndexEndpoint dentro de tu red de VPC

Antes de usar un índice para entregar consultas de coincidencia de vectores en línea, debes IndexIndexEndpointimplementar dentro de tu red con intercambio de tráfico entre redes de VPC. Por lo tanto, el primer paso es crear un IndexEndpoint. Puedes implementar más de un índice en un IndexEndpoint que comparta la misma red de VPC.

El siguiente es un ejemplo de una llamada a la API de curl:

curl -X POST -H "Content-Type: application/json" \
-H "Authorization: Bearer `gcloud auth print-access-token`" \
https://us-central1-aiplatform.googleapis.com/v1/projects/${PROJECT_ID}/locations/us-central1/indexEndpoints \
-d '{
    display_name: "'${DISPLAY_NAME}'",
    network: "'${VPC_NETWORK_NAME}'",
}'

El siguiente es el resultado de ejemplo:

{
  "name": "projects/xxx/locations/us-central1/indexEndpoints/xxxx/operations/yyyy",
  "metadata": {...}
}

Observa el resultado de la operación y busca la línea que contiene "name": "projects/xxxx/locations/us-central1/indexEndpoints/xxx/operations/yyyy". La parte yyyy es el ID de la operación. Sondea el resultado de la operación hasta que se complete correctamente. Espera hasta que "done": true se incluya en la respuesta.

curl -H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json" \
https://us-central1-aiplatform.googleapis.com/v1/projects/${PROJECT_ID}/locations/us-central1/indexEndpoints/xxxx/operations/yyyy"

Implementa un índice

Para implementar un índice, haz lo siguiente:

curl -H "Content-Type: application/json" \
-H "Authorization: Bearer `gcloud auth print-access-token`" \
https://us-central1-aiplatform.googleapis.com/v1/projects/${PROJECT_ID}/locations/us-central1/indexEndpoints/${INDEX_ENDPOINT_ID}:deployIndex \
-d '{
  deployedIndex: {
    id: "'${DEPLOYED_INDEX_ID}'",
    index: "'${INDEX_RESOURCE_NAME}'",
    displayName: "'${DISPLAY_NAME}'"
  }
}'

Al igual que en el caso de las otras operaciones, obtén el ID de las operación de la respuesta y úsalo para sondear el resultado de la operación hasta que se complete.

Habilitar ajuste de escala automático

Matching Engine admite el ajuste de escala automático, que puede cambiar el tamaño de la cantidad de nodos de forma automática según las demandas de tus cargas de trabajo. Cuando la demanda es alta, se agregan nodos al grupo de nodos (estos no superarán el tamaño máximo que designes). Cuando la demanda es baja, el grupo de nodos reduce su escala hasta el tamaño mínimo que designes. (Puedes verificar los nodos reales en uso y los cambios si supervisas las réplicas actuales).

Para habilitar el ajuste de escala automático, especifica maxReplicaCount y minReplicaCount cuando implementes el índice:

curl -H "Content-Type: application/json" \
-H "Authorization: Bearer `gcloud auth print-access-token`" \
https://us-central1-aiplatform.googleapis.com/v1/projects/${PROJECT_ID}/locations/us-central1/indexEndpoints/${INDEX_ENDPOINT_ID}:deployIndex \
-d '{
  deployedIndex: {
    id: "'${DEPLOYED_INDEX_ID}'",
    index: "'${INDEX_RESOURCE_NAME}'",
    displayName: "'${DISPLAY_NAME}'"
    automaticResources: {
      minReplicaCount: 2,
      maxReplicaCount: 5
    }
  }
}'
  • Si minReplicaCount y maxReplicaCount no están configurados, se establecerán en 1 de forma predeterminada.
  • Si solo se establece maxReplicaCount, minReplicaCount se establecerá como 1 de forma predeterminada.
  • Si solo se establece minReplicaCount, maxReplicaCount se establecerá como una cantidad igual a minReplicaCount.

Enumera IndexEndpoints

Para enumerar tus IndexEndpoints y ver la información de las instancias de DeployedIndex asociadas, ejecuta lo siguiente:

curl -H "Content-Type: application/json" \
-H "Authorization: Bearer `gcloud auth print-access-token`" \
https://us-central1-aiplatform.googleapis.com/v1/projects/${PROJECT_ID}/locations/us-central1/indexEndpoints

A continuación, se muestra la respuesta:

{
  "indexEndpoints": [
    {
      "name": "projects/<ProjectId>/locations/us-central1/indexEndpoints/<IndexEndpoingId>",
      "displayName": "...",
      "deployedIndexes": [
        {
          "id": "<user specified deployed index id>",
          "index": "projects/<ProjectId>/locations/us-central1/indexes/<IndexId>",
          "displayName": "demo",
          "createTime": "2021-06-18T00:19:13.242212Z",
          "privateEndpoints": {
            "matchGrpcAddress": "10.29.2.5"
          },
          "indexSyncTime": "2021-08-13T19:52:48.671205Z",
          "automaticResources": {
            "minReplicaCount": 1,
            "maxReplicaCount": 1
          }
        }
        ...
      ],
      "etag": "AMEw9yP9cMX3cjWFRuyLqI6YbB2UQcb-OU3tMwx9_B2p_MUiMlsMKPWX5KCphr1vbyiv",
      "createTime": "2021-06-18T00:16:59.320793Z",
      "updateTime": "2021-06-18T00:16:59.850034Z",
      "network": "projects/<ProjectId>/global/networks/<NetworkId>"
    },
    ...
  ]
}

Para obtener más información, consulta la documentación de referencia de IndexEndpoint.

Anula la implementación de un índice

Para anular la implementación de un índice, ejecuta lo siguiente:

curl -H "Content-Type: application/json"  \
-H "Authorization: Bearer `gcloud auth print-access-token`" \
https://us-central1-aiplatform.googleapis.com/v1/projects/${PROJECT_ID}/locations/us-central1/indexEndpoints/${INDEX_ENDPOINT_ID}:undeployIndex \
-d '{
  deployed_index_id: "'${DEPLOYED_INDEX_ID}'",
}'

Borra un IndexEndpoint

Antes de borrar un IndexEndpoint, debes anular la implementación de todos los índices asociados.

curl -X DELETE -H "Content-Type: application/json" \
-H "Authorization: Bearer `gcloud auth print-access-token`" \
https://us-central1-aiplatform.googleapis.com/v1/projects/${PROJECT_ID}/locations/us-central1/indexEndpoints/${INDEX_ENDPOINT_ID}

Consulta índices para obtener los vecinos más cercanos

Cada DeployedIndex tiene una DEPLOYED_INDEX_SERVER_IP que puedes recuperar si enumeras IndexEndpoints. Para consultar un objeto DeployedIndex, conéctate a su DEPLOYED_INDEX_SERVER_IP en el puerto 10000 y, luego, invoca los métodos MatchRequest o BatchMatchRequest.

En el siguiente ejemplo, se usa grpc_cli

./grpc_cli call ${DEPLOYED_INDEX_SERVER_IP}:10000 google.cloud.aiplatform.container.v1.MatchService.BatchMatch 'requests: [{deployed_index_id: "<deployed index id 1>", requests: [{deployed_index_id: "<deployed index id 1>", float_val: [-0.1,..<your query input>]}, {deployed_index_id: "<deployed index id 1>", float_val: [-0.1,..<your query input>]}]}]'

Las llamadas a estas API se deben realizar desde un cliente que se ejecute en la misma VPC con la que el servicio realizó el intercambio de tráfico.

Puedes iniciar una notebook de muestra que tenga instrucciones adicionales sobre cómo crear las consultas y ejecutarlas en Notebooks.

Ajusta el índice

En esta sección, se describen los parámetros de configuración que afectan el rendimiento, en especial la recuperación y la latencia, de los índices implementados. Estos parámetros se configuran cuando se crea el índice. También describiremos cómo usar los índices de fuerza bruta para medir la recuperación.

Parámetros de configuración que afectan la recuperación y la latencia:

1) "distanceMeasureType'"

Los valores admitidos son los siguientes:

  • SQUARED_L2_DISTANCEDistancia euclidiana L2
  • L1_DISTANCEDistancia de Manhattan L1
  • COSINE_DISTANCEDistancia de coseno definida como "1: similitud de coseno"
  • DOT_PRODUCT_DISTANCEDistancia del producto de vDot, definida como un valor negativo del producto de VDot. Este es el valor predeterminado.

En la mayoría de los casos, los vectores de incorporación que se usan para la coincidencia de similitud se procesan mediante modelos de aprendizaje de métricas (también llamados “redes siamesas” o “modelos de dos torres”). Estos modelos usan una métrica de distancias para calcular la función de pérdida contrastada. Lo ideal sería que el parámetro distanceMeasureType del índice coincidente coincida con la medida de distancia que usó el modelo que produjo los vectores de incorporación.

2) approximateNeighborsCount

Es la cantidad predeterminada de vecinos que se deben encontrar mediante la búsqueda aproximada antes de realizar el reordenamiento exacto. El reordenamiento exacto es un procedimiento en el que los resultados que muestra un algoritmo de búsqueda aproximada se ordenan a través de un cálculo de distancias más costoso. Si se aumenta este valor, también se incrementará la recuperación, pero también es posible que se genere un aumento proporcional en la latencia.

3) treeAhConfig.leafNodesToSearchPercent

El porcentaje de hojas que se deben buscar para cada consulta. Si se aumenta este valor, también se incrementará la recuperación, pero también es posible que se genere un aumento proporcional en la latencia. El valor predeterminado es 10, lo que significa que se busca el 10% de las hojas.

4) treeAhConfig.leafNodeEmbeddingCount

La cantidad de incorporaciones para cada nodo hoja. El valor predeterminado es de 1,000.

Este parámetro no tiene una correlación lineal que se debe recuperar. Aumentar o disminuir su valor no siempre aumentará o disminuirá la recuperación. Para cada caso de uso, suele haber un punto óptimo para el que se puede requerir cierta experimentación a fin de encontrarlo. Sin embargo, por lo general, el impacto de este parámetro es menor que el de los demás parámetros.

Cómo usar un índice de fuerza bruta para medir la recuperación

Los índices con el algoritmo de fuerza bruta se pueden usar para obtener los vecinos más cercanos, lo que proporciona un 100% de recuperación a costa de una latencia mayor. Por lo general, esto no es una buena opción para la entrega de producción, pero puede ser útil, por ejemplo, a fin de evaluar la recuperación de varias opciones de indexación sin conexión.

Para crear un índice con el algoritmo de fuerza bruta, especifica brute_force_config en los metadatos del índice:

curl -X POST -H "Content-Type: application/json" \
-H "Authorization: Bearer `gcloud auth print-access-token`" \
https://us-central1-aiplatform.googleapis.com/v1/projects/${PROJECT_ID}/locations/us-central1/indexes \
-d '{
    displayName: "'${DISPLAY_NAME}'",
    description: "'${DESCRIPTION}'",
    metadata: {
       contentsDeltaUri: "'${INPUT_DIR}'",
       config: {
          dimensions: 100,
          approximateNeighborsCount: 150,
          distanceMeasureType: "DOT_PRODUCT_DISTANCE",
          featureNormType: "UNIT_L2_NORM",
          algorithmConfig: {
             bruteForceConfig: {}
          }
       },
    },
}'

En el notebook de ejemplo, se muestra cómo usar el índice de “Fuerza bruta” para medir la recuperación.

Supervisa IndexEndpoint

Proporcionamos dos métricas para supervisar el IndexEndpoint:

  • aiplatform.googleapis.com/matching_engine/current_shards

    La cantidad de fragmentos del DeployedIndex. A medida que se agregan y borran datos, el motor de coincidencias vuelve a fragmentar de forma automática el índice para lograr un rendimiento óptimo. Esta métrica indica la cantidad actual de fragmentos del índice implementado.

  • aiplatform.googleapis.com/matching_engine/current_replicas

    Es la cantidad de réplicas activas que usa DeployedIndex. El motor de coincidencias activa y desactiva automáticamente los servidores de réplica (sujetos a la configuración mínima y máxima de réplicas especificadas por el usuario cuando se implementa el índice) para que coincidan con el volumen de consultas. Esta métrica indica la cantidad total de servidores de réplica. Ten en cuenta que, si el índice tiene varios fragmentos, cada fragmento se puede entregar mediante una cantidad diferente de réplicas. Esta métrica es la cantidad total de réplicas en todos los fragmentos del índice determinado.

Obtén más información sobre cómo seleccionar, consultar y mostrar estas métricas en el Explorador de métricas.

Cuotas

Obtén más información sobre las cuotas Vertex Matching Engine y cómo solicitar aumentos de cuotas.

Preguntas frecuentes

¿Cuántas direcciones IP debo reservar?

Si no hay restricciones en el rango de IP que puedes asignar, te recomendamos que reserves un rango de IP grande como /16 para evitar un problema de agotamiento de IP en el futuro.

Sin embargo, si no quieres asignar en exceso los rangos de IP, puedes realizar una estimación aproximada según el tamaño de los datos y el tráfico. Cada fragmento puede alojar alrededor de 20 GB de datos en formato Avro, y cada réplica puede entregar alrededor de 800 ~ 1,000 qps. (Los qps exactos que puede entregar cada réplica dependen, por ejemplo, del tamaño de la incorporación, las dimensiones, la configuración del algoritmo. Te recomendamos que realices una prueba de carga para descubrir la cantidad exacta). El total de nodos de índice implementados necesarios es (la cantidad de fragmentos * la cantidad de réplicas por fragmento).

Por ejemplo, si el tamaño de tus datos es de 30 GB y qps es de 1,200, necesitarás al menos 2 fragmentos y 2 réplicas para cada fragmento, lo cual es un total de 4 nodos de índice implementados.

Después de calcular el total de nodos de índice implementado, puedes elegir el prefijo de rango de IP según la siguiente tabla.

Total de nodos de índice implementado Prefijo de IP reservado recomendado
1 - 10 /21
11 - 25 /20
26 - 50 /19
51 - 120 /18

¿Qué puedo hacer si obtengo un error de IP agotada?

Primero, puedes verificar si hay DeployedIndexes sin usar y anular su implementación para liberar algunos espacios de IP.

Además, puedes extender los rangos de IP reservados existentes o asignar más rangos de IP. Consulta las instrucciones detalladas aquí.

¿Por qué no puedo volver a usar el ID de índice implementado cuando se anuló la implementación del anterior DeployedIndex?

Siempre mostramos una operación exitosa para UndeployIndex a fin de que nuestros clientes no tengan que preocuparse por manejar las fallas de anulación de la implementación. Sin embargo, el trabajo de limpieza subyacente demora al menos 10 ~ 20 minutos en completarse. Te recomendamos que esperes 10 ~ 20 minutos antes de reutilizar el mismo ID o usa uno diferente.

Obtén asistencia

Si tienes un problema con Vertex Matching Engine, hay dos formas de obtener asistencia. En cualquier caso, incluye los siguientes detalles en tu comunicación.

  • El ID de tu proyecto
  • El comando o código que ejecutaste y que activó el problema.
  • El entorno en el que ejecutaste el comando o el código. Por ejemplo, ¿lo ejecutaste en una instancia de Compute Engine o en una computadora local?
  • El comportamiento que observaste y cómo difiere de lo que esperabas.

Crea un ticket de asistencia en la nube

Si tienes un paquete de asistencia de Google, puedes enviar un ticket de asistencia. Para obtener información sobre cómo obtener un paquete de asistencia de Google, consulta Asistencia de Google Cloud.

En Cloud Console, ve a Casos en la sección Asistencia y haz clic en Crear caso.

  • Incluye "Matching Engine Serving" en el campo Título.
  • Selecciona "Machine Learing" como Categoría.
  • Selecciona “Vertex: Other” como el Componente.
  • Coloca la frase "Vertex Matching Engine" en la parte superior del campo de descripción.
  • Completa la descripción restante y otros campos lo mejor que puedas.

Enviar un correo electrónico

Si no tienes un paquete de Atención al cliente de Google, puedes enviar un correo electrónico a la siguiente dirección:

gcp-ann-feedback@google.com

¿Qué sigue?