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 devi scrivere un server del modello 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.

Crea ed esegui il deployment di un container personalizzato

Questa sezione descrive come utilizzare CPR per creare un container personalizzato con logica di pre-elaborazione e post-elaborazione ed eseguire il deployment su 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)

I gestori personalizzati hanno accesso all'oggetto di richiesta non elaborato e, di conseguenza, sono utili nei rari casi in cui è necessario personalizzare la logica relativa al server web, ad esempio supportando intestazioni aggiuntive di richiesta e risposta o deserializzando le 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 riusabilità del codice, ti consigliamo di implementare la logica del server web nel gestore e la logica ML nel predittore, come mostrato nel gestore predefinito.

Crea un container personalizzato

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

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 esaminare le specifiche del container 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 è obbligatorio solo se vuoi eseguire e testare il container localmente, il che è utile per un'iterazione più rapida. Nell'esempio seguente, esegui il deployment su un endpoint locale e invii una richiesta di previsione (formato per 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 il controllo di integrità e la risposta 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()

Quindi, carica il file 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 eseguire il deployment in un endpoint Vertex AI per ottenere previsioni online.

Esegui il deployment sull'endpoint Vertex AI

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

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

Esempi di blocchi note

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