Routine di previsione personalizzate

Le routine di previsione personalizzate (CPR) ti consentono di creare container personalizzati con codice di pre-elaborazione e post-elaborazione, senza dover gestire i dettagli della configurazione di un server HTTP o della creazione di un container da zero. Puoi utilizzare la preelaborazione per normalizzare e trasformare gli input o effettuare chiamate a servizi esterni per ottenere dati aggiuntivi e utilizzare la postelaborazione per formattare la previsione del modello o eseguire la logica di business.

Il seguente diagramma mostra il flusso di lavoro dell'utente sia con che senza routine di previsione personalizzate.

Le differenze principali sono:

  • Non è necessario scrivere un server di modelli o un Dockerfile. Il server del modello, ovvero il server HTTP che ospita il modello, viene fornito per te.

  • Puoi eseguire il deployment e il debug del modello in locale, accelerando il ciclo di iterazione durante lo sviluppo.

Creare e implementare un container personalizzato

Questa sezione descrive come utilizzare CPR per creare un contenitore personalizzato con logica di preelaborazione e postelaborazione ed eseguire il deployment in un endpoint locale e online.

Configurazione

Nel tuo ambiente devono essere installati l'SDK Vertex AI per Python e Docker.

Scrivi Predictor personalizzato

Implementa l'interfaccia 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

Ad esempio, consulta l'implementazione di Predictor di Sklearn.

Scrivi Handler personalizzato (facoltativo)

Gli handler personalizzati hanno accesso all'oggetto richiesta non elaborato e sono quindi utili nei rari casi in cui devi personalizzare la logica relativa al server web, ad esempio supportare intestazioni di richiesta e risposta aggiuntive o deserializzare richieste di previsione non in formato JSON.

Ecco un notebook di esempio che implementa sia Predictor che Handler.

Sebbene non sia obbligatorio, per una migliore organizzazione e riutilizzabilità del codice, ti consigliamo di implementare la logica del server web nell'Handler e la logica ML nel Predictor come mostrato nell'handler predefinito.

Crea un container personalizzato

Inserisci il codice personalizzato e un file requirements.txt aggiuntivo, se devi installare pacchetti nelle immagini, in una directory.

Utilizza l'SDK Vertex AI per Python per creare contenitori personalizzati come segue:

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},
)

Puoi ispezionare la specifica del contenitore per ottenere informazioni utili come l'URI dell'immagine e le variabili di ambiente.

local_model.get_serving_container_spec()

(Facoltativo) Esegui il contenitore localmente

Questo passaggio è necessario solo se vuoi eseguire e testare il contenitore in locale, il che è utile per un'iterazione più rapida. Nell'esempio seguente, esegui il deployment in un endpoint locale e invii una richiesta di previsione (formato per il corpo della richiesta).

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},
    )

Stampa la risposta del controllo di integrità e della previsione.

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

Stampa tutti i log del contenitore.

local_endpoint.print_container_logs(show_all=True)

Carica in Vertex AI Model Registry

Il modello dovrà accedere agli elementi del modello (i file dell'addestramento), quindi assicurati di averli caricati su Google Cloud Storage.

Esegui il push dell'immagine in Artifact Registry.

local_model.push_image()

Poi caricalo in 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 volta caricato in Model Registry, il modello può essere utilizzato per ottenere previsioni batch o per essere implementato in un endpoint Vertex AI per ottenere previsioni online.

Esegui il deployment nell'endpoint Vertex AI

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

Una volta eseguito il deployment del modello, puoi ottenere previsioni online.

Esempi di notebook

I sample mostrano i diversi modi in cui puoi eseguire il deployment di un modello con preelaborazione e postelaborazione personalizzate utilizzando Vertex AI Prediction.