Vertex AI fournit deux options pour projeter les valeurs futures à l'aide de votre modèle de prévision entraîné : les inférences en ligne et les inférences par lot.
Une inférence en ligne est une requête synchrone. Utilisez les inférences en ligne lorsque vous effectuez des requêtes en réponse à une entrée d'une application ou dans d'autres situations nécessitant une inférence rapide.
Une requête d'inférence par lot est une requête asynchrone. Utilisez les inférences par lot lorsque vous n'avez pas besoin d'une réponse immédiate et souhaitez traiter les données accumulées en une seule requête.
Cette page explique comment projeter des valeurs futures à l'aide d'inférences en ligne. Pour apprendre à projeter des valeurs à l'aide d'inférences par lots, consultez Obtenir des inférences par lots pour un modèle de prévision.
Vous devez déployer votre modèle sur un point de terminaison avant de pouvoir l'utiliser pour les inférences. Un point de terminaison est un ensemble de ressources physiques.
Vous pouvez demander une explication au lieu d'une inférence. Les valeurs d'importance des caractéristiques locales de l'explication indiquent dans quelle mesure chaque caractéristique a contribué au résultat de l'inférence. Pour obtenir une présentation des concepts, consultez Attributions de caractéristiques pour la prévision.
Pour en savoir plus sur les tarifs des inférences en ligne, consultez Tarifs des workflows tabulaires.
Avant de commencer
Avant de pouvoir envoyer une requête d'inférence en ligne, vous devez d'abord entraîner un modèle.
Créer ou sélectionner un point de terminaison
Utilisez la fonction aiplatform.Endpoint.create() pour créer un point de terminaison. Si vous en avez déjà un, utilisez la fonction aiplatform.Endpoint() pour le sélectionner.
Le code suivant est un exemple :
# Import required modules
from google.cloud import aiplatform
from google.cloud.aiplatform import models
PROJECT_ID = "PROJECT_ID"
REGION = "REGION"
# Initialize the Vertex SDK for Python for your project.
aiplatform.init(project=PROJECT_ID, location=REGION)
endpoint = aiplatform.Endpoint.create(display_name='ENDPOINT_NAME')
Remplacez les éléments suivants :
- PROJECT_ID : ID de votre projet
- REGION : région dans laquelle vous utilisez Vertex AI.
- ENDPOINT_NAME : nom à afficher du point de terminaison.
Sélectionner un modèle entraîné
Utilisez la fonction aiplatform.Model() pour sélectionner un modèle entraîné :
# Create reference to the model trained ahead of time.
model_obj = models.Model("TRAINED_MODEL_PATH")
Remplacez les éléments suivants :
- TRAINED_MODEL_PATH :
projects/PROJECT_ID/locations/REGION/models/[TRAINED_MODEL_ID], par exemple.
Déployer le modèle sur le point de terminaison
Utilisez la fonction deploy() pour déployer le modèle sur le point de terminaison. Le code suivant est un exemple :
deployed_model = endpoint.deploy(
model_obj,
machine_type='MACHINE_TYPE',
traffic_percentage=100,
min_replica_count='MIN_REPLICA_COUNT',
max_replica_count='MAX_REPLICA_COUNT',
sync=True,
deployed_model_display_name='DEPLOYED_MODEL_NAME',
)
Remplacez les éléments suivants :
- MACHINE_TYPE :
n1-standard-8, par exemple. En savoir plus sur les types de machines. - MIN_REPLICA_COUNT : nombre minimal de nœuds pour ce déploiement.
Vous pouvez augmenter ou diminuer le nombre de nœuds selon les besoins de la charge d'inférence, dans la limite du nombre maximal de nœuds et jamais moins que ce nombre de nœuds. Cette valeur doit être supérieure ou égale à 1. Si vous ne définissez pas la variable
min_replica_count, la valeur par défaut est1. - MAX_REPLICA_COUNT : nombre maximal de nœuds pour ce déploiement.
Vous pouvez augmenter ou diminuer le nombre de nœuds selon les besoins de la charge d'inférence, dans la limite de ce nombre de nœuds et jamais moins que le nombre minimal. Si vous ne définissez pas la variable
max_replica_count, le nombre maximal de nœuds est défini sur la valeur demin_replica_count. - DEPLOYED_MODEL_NAME : nom de l'élément
DeployedModel. Vous pouvez également utiliser le nom à afficher duModelpour leDeployedModel.
Le déploiement du modèle peut prendre environ dix minutes.
Obtenir des inférences en ligne
Pour obtenir des inférences, utilisez la fonction predict() et fournissez une ou plusieurs instances en entrée. Le code suivant est un exemple :
predictions = endpoint.predict(instances=[{...}, {...}])
Chaque instance en entrée est un dictionnaire Python avec le même schéma que celui sur lequel le modèle a été entraîné. Il doit contenir une paire clé-valeur disponible au moment de la prévision correspondant à la colonne Heure et une paire clé-valeur non disponible au moment de la prévision contenant les valeurs historiques de la colonne d'inférence ciblée. Vertex AI s'attend à ce que chaque instance en entrée appartienne à une seule série temporelle. L'ordre des paires clé-valeur dans l'instance n'a pas d'importance.
L'instance en entrée est soumise aux contraintes suivantes :
- Les paires clé-valeur disponibles au moment de la prévision doivent toutes avoir le même nombre de points de données.
- Les paires clé-valeur non disponibles au moment de la prévision doivent toutes avoir le même nombre de points de données.
- Les paires clé-valeur disponibles au moment de la prévision doivent avoir au moins autant de points de données que les paires clé-valeur non disponibles au moment de la prévision.
Pour en savoir plus sur les types de colonnes utilisés dans les prévisions, consultez Type de fonctionnalité et disponibilité au moment de la prévision.
Le code suivant illustre un ensemble de deux instances en entrée.
La colonne Category contient des données d'attribut. La colonne Timestamp contient les données disponibles au moment de la prévision. Trois points correspondent à des données de contexte et deux points à des données d'horizon. La colonne Sales contient des données qui ne sont pas disponibles au moment de la prévision. Les trois points sont des données de contexte. Pour savoir comment le contexte et l'horizon sont utilisés dans les prévisions, consultez Horizon de prévision, fenêtre de contexte et période de prévision.
instances=[
{
# Attribute
"Category": "Electronics",
# Available at forecast: three days of context, two days of horizon
"Timestamp": ['2023-08-03', '2023-08-04', '2023-08-05', '2023-08-06', '2023-08-07'],
# Unavailable at forecast: three days of context
"Sales": [490.50, 325.25, 647.00],
},
{
# Attribute
"Category": "Food",
# Available at forecast: three days of context, two days of horizon
"Timestamp": ['2023-08-03', '2023-08-04', '2023-08-05', '2023-08-06', '2023-08-07'],
# Unavailable at forecast: three days of context
"Sales": [190.50, 395.25, 47.00],
}
])
Pour chaque instance, Vertex AI répond avec deux inférences pour Sales, correspondant aux deux codes temporels d'horizon ("2023-08-06" et "2023-08-07").
Pour des performances optimales, le nombre de points de données de contexte et de points de données d'horizon dans chaque instance en entrée doit correspondre aux longueurs de contexte et d'horizon utilisées pour l'entraînement du modèle. En cas d'incohérence, Vertex AI complète ou tronque l'instance pour qu'elle corresponde à la taille du modèle.
Si le nombre de points de données de contexte dans votre instance en entrée est inférieur ou supérieur au nombre de points de données de contexte utilisés pour l'entraînement du modèle, assurez-vous que ce nombre de points est cohérent entre toutes les paires clé-valeur disponibles au moment de la prévision et toutes les paires clé-valeur non disponibles au moment de la prévision.
Prenons l'exemple d'un modèle qui a été entraîné avec quatre jours de données de contexte et deux jours de données d'horizon. Vous pouvez envoyer une requête d'inférence avec seulement trois jours de données de contexte. Dans ce cas, les paires clé-valeur non disponibles au moment de la prévision contiennent trois valeurs. Les paires clé-valeur disponibles au moment de la prévision doivent contenir cinq valeurs.
Sortie de l'inférence en ligne
Vertex AI fournit le résultat de l'inférence en ligne dans le champ value :
{
'value': [...]
}
La longueur de la réponse d'inférence dépend de l'horizon utilisé pour l'entraînement du modèle et de l'horizon de l'instance en entrée. La longueur de la réponse d'inférence correspond à la plus petite de ces deux valeurs.
Prenons les exemples suivants :
- Vous entraînez un modèle avec
context=15ethorizon=50. Votre instance en entrée dispose de la configuration suivante :context=15ethorizon=20. La réponse d'inférence a une longueur de20. - Vous entraînez un modèle avec
context=15ethorizon=50. Votre instance en entrée dispose de la configuration suivante :context=15ethorizon=100. La réponse d'inférence a une longueur de50.
Résultat des inférences en ligne pour les modèles TFT
Pour les modèles entraînés avec un transformateur de fusion temporelle (TFT), Vertex AI fournit l'interprétabilité TFT tft_feature_importance en plus des inférences dans le champ value :
{
"tft_feature_importance": {
"attribute_weights": [...],
"attribute_columns": [...],
"context_columns": [...],
"context_weights": [...],
"horizon_weights": [...],
"horizon_columns": [...]
},
"value": [...]
}
attribute_columns: caractéristiques de prévision invariantes dans le temps.attribute_weights: pondérations associées à chacune desattribute_columns.context_columns: caractéristiques de prévision dont les valeurs de fenêtre de contexte servent d'entrées dans l'encodeur TFT de type LSTM (Long Short-Term Memory).context_weights: pondérations de l'importance des caractéristiques associées à chacune descontext_columnspour l'instance prédite.horizon_columns: caractéristiques de prévision dont les valeurs de l'horizon de prévision sont utilisées comme entrées pour le décodeur TFT de type LSTM (Long Short-Term Memory).horizon_weights: pondérations de l'importance des caractéristiques associées à chacune deshorizon_columnspour l'instance prédite.
Résultat de l'inférence en ligne pour les modèles optimisés pour la perte de quantiles
Pour les modèles optimisés pour la perte de quantile, Vertex AI fournit la sortie d'inférence en ligne suivante :
{
"value": [...],
"quantile_values": [...],
"quantile_predictions": [...]
}
-
value: si votre ensemble de quantiles inclut la médiane,valueest la valeur d'inférence à la médiane. Sinon,valueest la valeur d'inférence au quantile le plus bas de l'ensemble. Par exemple, si votre ensemble de quantiles est[0.1, 0.5, 0.9],valuecorrespond à l'inférence pour le quantile0.5. Si votre ensemble de quantiles est[0.1, 0.9],valuecorrespond à l'inférence pour le quantile0.1. quantile_values: valeurs des quantiles, qui sont définies lors de l'entraînement du modèle.-
quantile_predictions: valeurs d'inférence associées aux valeurs de quantiles.
Prenons l'exemple d'un modèle dans lequel la colonne cible est la valeur des ventes.
Les valeurs de quantile sont définies comme suit : [0.1, 0.5, 0.9]. Vertex AI renvoie les inférences de quantile suivantes : [4484, 5615, 6853]. Ici, l'ensemble de quantiles inclut la médiane. Par conséquent, value est l'inférence pour le quantile 0.5 (5615). Vous pouvez interpréter les inférences de quantiles comme suit :
P(sales value < 4484)= 10 %P(sales value < 5615)= 50 %P(sales value < 6853)= 90 %
Résultat de l'inférence en ligne pour les modèles avec inférence probabiliste
Si votre modèle utilise une inférence probabiliste, le champ value contient la minimisation de l'objectif d'optimisation. Par exemple, si votre objectif d'optimisation est minimize-rmse, le champ value contient la valeur moyenne. Si la valeur est minimize-mae, le champ value contient la valeur médiane.
Si votre modèle utilise une inférence probabiliste avec des quantiles, Vertex AI fournit des valeurs et des inférences de quantiles en plus de la minimisation de l'objectif d'optimisation. Les valeurs de quantile sont définies lors de l'entraînement du modèle. Les inférences de quantile sont les valeurs d'inférence associées aux valeurs de quantile.
Obtenir des explications en ligne
Pour obtenir des explications, utilisez la fonction explain() et fournissez une ou plusieurs instances en entrée. Le code suivant est un exemple :
explanations = endpoint.explain(instances=[{...}, {...}])
Le format des instances en entrée est le même pour les inférences et les explications en ligne. Pour en savoir plus, consultez Obtenir des inférences en ligne.
Pour obtenir une présentation des concepts liés aux attributions de caractéristiques, consultez Attributions de caractéristiques pour la prévision.
Résultat de l'explication en ligne
Le code suivant montre comment générer les résultats de l'explication :
# Import required modules
import json
from google.protobuf import json_format
def explanation_to_dict(explanation):
"""Converts the explanation proto to a human-friendly json."""
return json.loads(json_format.MessageToJson(explanation._pb))
for response in explanations.explanations:
print(explanation_to_dict(response))
Les résultats de l'explication ont le format suivant :
{
"attributions": [
{
"baselineOutputValue": 1.4194682836532593,
"instanceOutputValue": 2.152980089187622,
"featureAttributions": {
...
"store_id": [
0.007947325706481934
],
...
"dept_id": [
5.960464477539062e-08
],
"item_id": [
0.1100526452064514
],
"date": [
0.8525647521018982
],
...
"sales": [
0.0
]
},
"outputIndex": [
2
],
"approximationError": 0.01433318599207033,
"outputName": "value"
},
...
]
}
Le nombre d'éléments attributions dépend de l'horizon utilisé pour l'entraînement du modèle et de l'horizon de l'instance en entrée. Le nombre d'éléments est la plus petite de ces deux valeurs.
Le champ featureAttributions d'un élément attributions contient une valeur pour chacune des colonnes de l'ensemble de données d'entrée. Vertex AI génère des explications pour tous les types de caractéristiques : attribut, disponible au moment de la prévision et non disponible au moment de la prévision. Pour en savoir plus sur les champs d'un élément attributions, consultez Attribution.
Supprimer le point de terminaison
Utilisez les fonctions undeploy_all() et delete() pour supprimer votre point de terminaison. Le code suivant est un exemple :
endpoint.undeploy_all()
endpoint.delete()
Étapes suivantes
- Découvrez la tarification des inférences en ligne.