Rutinas de predicción personalizadas

Las rutinas de predicción personalizadas (CPR) 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 a fin de obtener datos adicionales y usar el procesamiento posterior para dar formato a la predicción 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 predicción 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.

Escribe Predictor personalizados

Cómo implementar la interfaz Predictor.

class Predictor(ABC):
    """Interface of the Predictor class for Custom Prediction Routines.
    The Predictor is responsible for the ML logic for processing a prediction request.
    Specifically, the Predictor must define:
    (1) How to load all model artifacts used during prediction into memory.
    (2) The logic that should be executed at predict time.
    When using the default PredictionHandler, the Predictor will be invoked as follows:
      predictor.postprocess(predictor.predict(predictor.preprocess(prediction_input)))
    """

    @abstractmethod
    def load(self, artifacts_uri: str) -> None:
        """Loads the model artifact.
        Args:
            artifacts_uri (str):
                Required. The value of the environment variable AIP_STORAGE_URI.
        """
        pass

    def preprocess(self, prediction_input: Any) -> Any:
        """Preprocesses the prediction input before doing the prediction.
        Args:
            prediction_input (Any):
                Required. The prediction input that needs to be preprocessed.
        Returns:
            The preprocessed prediction input.
        """
        return prediction_input

    @abstractmethod
    def predict(self, instances: Any) -> Any:
        """Performs prediction.
        Args:
            instances (Any):
                Required. The instance(s) used for performing prediction.
        Returns:
            Prediction results.
        """
        pass

    def postprocess(self, prediction_results: Any) -> Any:
        """Postprocesses the prediction results.
        Args:
            prediction_results (Any):
                Required. The prediction results.
        Returns:
            The postprocessed prediction results.
        """
        return prediction_results

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 predicción 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 predicción (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 predicción.

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 predicciones por lotes o implementarse en un extremo de Vertex AI a fin de obtener predicciones 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 predicciones 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 Vertex AI Prediction.