Benutzerdefinierte Vorhersageroutinen

Mit benutzerdefinierten Vorhersageroutinen (CPR) können Sie benutzerdefinierte Container mit Vorverarbeitungs- und Nachbearbeitungscode erstellen, ohne sich um die Einrichtung eines HTTP-Servers oder das Erstellen eines Containers von Grund auf kümmern zu müssen. Mithilfe der Vorverarbeitung können Sie die Eingaben normalisieren und transformieren oder Aufrufe an externe Dienste senden, um zusätzliche Daten abzurufen. Mit der Nachbearbeitung können Sie die Modellvorhersage formatieren oder Geschäftslogik ausführen.

Das folgende Diagramm zeigt den Nutzerworkflow mit und ohne benutzerdefinierte Vorhersageroutinen.

Die Hauptunterschiede sind:

  • Sie müssen keinen Modellserver und kein Dockerfile schreiben. Der Modellserver, bei dem es sich um den HTTP-Server handelt, der das Modell hostet, wird für Sie bereitgestellt.

  • Sie können das Modell lokal bereitstellen und lokal Fehler beheben, um den Iterationszyklus während der Entwicklung zu beschleunigen.

Benutzerdefinierten Container erstellen und bereitstellen

In diesem Abschnitt wird beschrieben, wie Sie mithilfe von CPR einen benutzerdefinierten Container mit Vorverarbeitungs- und Nachbearbeitungslogik erstellen und auf einem lokalen und einem Onlineendpunkt bereitstellen.

Einrichtung

Sie müssen in Ihrer Umgebung Vertex AI SDK für Python und Docker installiert haben.

Benutzerdefinierten Predictor schreiben

Predictor-Schnittstelle implementieren.

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

Weitere Informationen finden Sie zum Beispiel in der Predictor-Implementierung von Sklearn.

Benutzerdefinierten Handler schreiben (optional)

Benutzerdefinierte Handler haben Zugriff auf das Rohanfrageobjekt und sind daher in seltenen Fällen nützlich, in denen Sie die Webserverlogik anpassen müssen, z. B. für die Unterstützung zusätzlicher Anfrage-/Antwortheader oder für die Deserialisierung von nicht JSON-formatierten Vorhersageanfragen.

Hier ist ein Beispielnotebook, das sowohl Predictor als auch Handler implementiert.

Obwohl dies nicht erforderlich ist, empfehlen wir zur besseren Codeorganisation und Wiederverwendbarkeit die Implementierung der Webserverlogik im Handler und der ML-Logik im Predictor wie im Standard-Handler gezeigt.

Benutzerdefinierten Container erstellen

Legen Sie Ihren benutzerdefinierten Code und eine zusätzliche requirements.txt-Datei in einem Verzeichnis ab, falls Sie Pakete in Ihren Images installieren müssen.

Verwenden Sie das Vertex AI SDK für Python, um benutzerdefinierte Container so zu erstellen:

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

In der Containerspezifikation finden Sie nützliche Informationen wie den Image-URI und Umgebungsvariablen.

local_model.get_serving_container_spec()

Container lokal ausführen (optional)

Dieser Schritt ist nur erforderlich, wenn Sie den Container lokal ausführen und testen möchten, was für eine schnellere Iteration nützlich ist. Im folgenden Beispiel stellen Sie auf einem lokalen Endpunkt bereit und senden eine Vorhersageanfrage (Format für Anfragetext).

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

Geben Sie die Systemdiagnose- und Vorhersageantwort aus.

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

Geben Sie alle Containerlogs aus.

local_endpoint.print_container_logs(show_all=True)

In Vertex AI Model Registry hochladen

Ihr Modell muss auf Ihre Modellartefakte zugreifen können (die Dateien aus dem Training). Stellen Sie daher sicher, dass Sie sie in Google Cloud Storage hochgeladen haben.

Laden Sie das Image per Push in die Artifact Registry:

local_model.push_image()

Laden Sie es dann in Model Registry hoch.

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

Sobald Ihr Modell in Model Registry hochgeladen wurde, kann es zum Abrufen von Batchvorhersagen verwendet oder auf einem Vertex AI-Endpunkt bereitgestellt werden, um Onlinevorhersagen zu erhalten.

Auf Vertex AI-Endpunkt bereitstellen

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

Sobald Ihr Modell bereitgestellt ist, können Sie Onlinevorhersagen abrufen.

Notebook-Beispiele

Die Beispiele zeigen die verschiedenen Möglichkeiten, ein Modell mit benutzerdefinierter Vorverarbeitung und Nachbearbeitung mithilfe von Vertex AI Prediction bereitzustellen.