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.
- Con el Predictor personalizado con procesamieto previo o posterior personalizado para Sklearn, compila tu propio contenedor con el SDK de Vertex AI para Python.
- Implementa solo la carga de métodos de métodos de preprocesador, procesamiento previo y posprocesamiento serializados en el Predictor. Hereda la carga de modelos predeterminados y predice el comportamiento de
SklearnPredictor
distribuido por Vertex AI.
- Implementa solo la carga de métodos de métodos de preprocesador, procesamiento previo y posprocesamiento serializados en el Predictor. Hereda la carga de modelos predeterminados y predice el comportamiento de
- Predictor personalizado, compila tu propio contenedor con el SDK de Vertex AI para Python.
- Implementación personalizada de todo el Predictor
- Predictor y Controlador personalizados, compila tu propio contenedor con el SDK de Vertex para Python.
- Implementación personalizada de Predictor y Controlador
- Personalizar el controlador permite que el servidor de modelos maneje las entradas CSV.
- Predictor personalizado, compila tu propio contenedor con el SDK de Vertex AI para Python y PyTorch.
- Implementación personalizada del Predictor
- Imagen existente, prueba de la predicción local e implementa modelos con el SDK de Vertex AI para Python.
- Usa el servidor de inferencia de Triton de NVIDIA para los modelos de PyTorch.