Rutinas de inferencia personalizadas

Las rutinas de inferencia personalizadas te permiten compilar contenedores personalizados con código de procesamiento previo y posterior, sin tener que lidiar con los detalles de la configuración de un servidor HTTP o la compilación de un contenedor desde cero. Puedes usar el procesamiento previo para normalizar y transformar las entradas o hacer llamadas a servicios externos para obtener datos adicionales y usar el procesamiento posterior para dar formato a la inferencia del modelo o ejecutar la lógica empresarial.

En el siguiente diagrama, se muestra el flujo de trabajo del usuario con y sin rutinas de inferencia personalizadas.

A continuación, se mencionan las diferencias principales:

  • No necesitas escribir un servidor de modelo ni un Dockerfile. Se te proporcionará el servidor de modelos, que es el servidor de HTTP que aloja el modelo.

  • Puedes implementar y depurar el modelo de manera local, lo que acelera el ciclo de iteración durante el desarrollo.

Compila e implementa un contenedor personalizado

En esta sección, se describe cómo usar CPR para compilar un contenedor personalizado con lógica de procesamiento previo y posterior y cómo implementar en un extremo local y en línea.

Configuración

Debes tener instalados el SDK de Vertex AI para Python y Docker en tu entorno.

Cómo escribir una interfaz de inferencia Predictor personalizada

Cómo implementar la interfaz Predictor.

Por ejemplo, consulta Implementación de Predictor de Sklearn.

Escribe Handler personalizados (opcional)

Los controladores personalizados tienen acceso al objeto de solicitud sin procesar y, por lo tanto, son útiles en casos excepcionales en los que necesitas personalizar la lógica relacionada con el servidor web, como admitir encabezados de solicitud o respuesta adicionales o deserializar solicitudes de inferencia con formato no JSON.

Este es un notebook de ejemplo que implementa Predictor y Handler.

Aunque no es necesario, para una mejor organización y reutilización de código, te recomendamos que implementes la lógica del servidor web en el controlador y la lógica de AA en el Predictor, como se muestra en el controlador predeterminado.

Compila un contenedor personalizado

Coloca tu código personalizado y un archivo requirements.txt adicional, si necesitas instalar cualquier paquete en tus imágenes, en un directorio.

Usa el SDK de Vertex AI para Python a fin de compilar contenedores personalizados de la siguiente manera:

from google.cloud.aiplatform.prediction import LocalModel

# {import your predictor and handler}

local_model = LocalModel.build_cpr_model(
    {PATH_TO_THE_SOURCE_DIR},
    f"{REGION}-docker.pkg.dev/{PROJECT_ID}/{REPOSITORY}/{IMAGE}",
    predictor={PREDICTOR_CLASS},
    handler={HANDLER_CLASS},
    requirements_path={PATH_TO_REQUIREMENTS_TXT},
)

Puedes inspeccionar la especificación del contenedor para obtener información útil, como el URI de la imagen y las variables de entorno.

local_model.get_serving_container_spec()

Ejecuta el contenedor de forma local (opcional)

Este paso solo es necesario si deseas ejecutar y probar el contenedor de forma local, lo que es útil para una iteración más rápida. En el siguiente ejemplo, implementas en un extremo local y envías una solicitud de inferencia (formato para el cuerpo de la solicitud).

with local_model.deploy_to_local_endpoint(
    artifact_uri={GCS_PATH_TO_MODEL_ARTIFACTS},
    credential_path={PATH_TO_CREDENTIALS},
) as local_endpoint:
    health_check_response = local_endpoint.run_health_check()
    predict_response = local_endpoint.predict(
        request_file={PATH_TO_INPUT_FILE},
        headers={ANY_NEEDED_HEADERS},
    )

Imprime la verificación de estado y la respuesta de inferencia.

print(health_check_response, health_check_response.content)
print(predict_response, predict_response.content)

Imprime todos los registros de contenedores.

local_endpoint.print_container_logs(show_all=True)

Sube al Model Registry de Vertex AI

Tu modelo deberá acceder a los artefactos de tu modelo (los archivos del entrenamiento), así que asegúrate de que los hayas subido a Google Cloud Storage.

Envía la imagen al registro de Artifact Registry.

local_model.push_image()

Luego, súbelo a Model Registry.

from google.cloud import aiplatform

model = aiplatform.Model.upload(
    local_model=local_model,
    display_name={MODEL_DISPLAY_NAME},
    artifact_uri={GCS_PATH_TO_MODEL_ARTIFACTS},
)

Una vez que se suba el modelo a Model Registry, puede usarse para obtener inferencias por lotes o implementarse en un extremo de Vertex AI para obtener inferencias en línea.

Implementa en el extremo de Vertex AI

endpoint = model.deploy(machine_type="n1-standard-4")

Una vez que se implementa tu modelo, puedes obtener inferencias en línea.

Muestras de notebooks

Las muestras muestran las diferentes formas en que puedes implementar un modelo con procesamiento previo y posterior personalizado mediante la inferencia de Vertex AI.