Routines de prédiction personnalisées

Les routines de prédiction personnalisées (CPR) vous permettent de créer facilement des conteneurs personnalisés avec du code de pré/post-traitement, sans avoir à configurer un serveur HTTP ni à créer un conteneur en partant de zéro. Vous pouvez utiliser le prétraitement pour normaliser/transformer les entrées ou effectuer des appels à des services externes pour obtenir des données supplémentaires, et utiliser le post-traitement pour formater la prédiction de modèle ou exécuter une logique métier.

Le diagramme suivant illustre le workflow utilisateur avec et sans routines de prédiction personnalisées.

Les principales différences sont les suivantes :

  • Vous n'avez pas besoin d'écrire de serveur de modèles ou de fichier Dockerfile. Le serveur de modèles, qui est le serveur HTTP qui héberge le modèle, vous est fourni.

  • Vous pouvez déployer et déboguer le modèle localement, ce qui accélère le cycle d'itération pendant le développement.

Créer et déployer un conteneur personnalisé

Cette section explique comment utiliser CPR pour créer un conteneur personnalisé avec une logique de pré/post-traitement et déployer à la fois sur un point de terminaison local et en ligne.

Préparation

Vous devez avoir installé le SDK Vertex AI et Docker dans votre environnement.

Écrire une règle Predictor personnalisée

Implémenter l'interface 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

Par exemple, consultez la mise en œuvre de Predictor de Sklearn.

Écrire une valeur Handler personnalisée (facultatif)

Les gestionnaires personnalisés ont accès à l'objet de requête brute et sont donc utiles dans les rares cas où vous devez personnaliser la logique liée au serveur Web, par exemple pour permettre la compatibilité avec des en-têtes de requête/réponse supplémentaires ou la désérialisation des requêtes de prédiction dans des formats différents du JSON.

Voici un exemple de notebook qui met en œuvre à la fois le prédicteur et le gestionnaire.

Bien que ce ne soit pas obligatoire, pour une meilleure organisation et réutilisation du code, nous vous recommandons de mettre en œuvre la logique du serveur Web dans le gestionnaire et la logique de ML dans le prédicteur, comme indiqué dans le gestionnaire par défaut.

Créer un conteneur personnalisé

Si vous devez installer des packages dans vos images, placez votre code personnalisé et un fichier requirements.txt supplémentaire dans un répertoire.

Utilisez le SDK Vertex pour créer des conteneurs personnalisés, comme indiqué ci-dessous :

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

Vous pouvez consulter les spécifications du conteneur pour obtenir des informations utiles, telles que l'URI de l'image ou les variables d'environnement.

local_model.get_serving_container_spec()

Exécuter le conteneur localement (facultatif)

Cette étape n'est nécessaire que si vous souhaitez exécuter et tester le conteneur localement, ce qui est utile pour une itération plus rapide. Dans l'exemple suivant, nous déployons le point de terminaison local et nous envoyons une requête de prédiction (formatée pour le corps de la requête).

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

Imprimez la vérification de l'état et la réponse de prédiction.

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

Imprimez tous les journaux de conteneur.

local_endpoint.print_container_logs(show_all=True)

Importer dans Vertex AI Model Registry

Votre modèle doit accéder à vos artefacts de modèle (les fichiers issus de l'entraînement). Assurez-vous donc de les avoir importés dans Google Cloud Storage.

Transférez l'image vers le registre d'artefacts.

local_model.push_image()

Importez ensuite le modèle dans le registre de modèles.

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

Une fois votre modèle importé dans Vertex AI Model Registry, il peut être utilisé pour obtenir des prédictions par lot ou être déployé sur un point de terminaison Vertex AI pour obtenir des prédictions en ligne.

Déployer sur le point de terminaison Vertex AI

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

Une fois votre modèle déployé, vous pouvez obtenir des prédictions en ligne.

Exemples de notebooks

Les exemples présentent les différentes manières de déployer un modèle avec un prétraitement/post-traitement personnalisé sur Vertex AI Prediction.