Générer des prédictions de ML à l'aide de SQL

Aperçu — Spanner Vertex AI integration {/10)

Cette fonctionnalité est régie par les Conditions des offres de pré-DG des conditions d'utilisation de Google Cloud. Les fonctionnalités pré-DG risquent de ne pas être compatibles, et les modifications apportées aux fonctionnalités pré-DG risquent de ne pas être compatibles avec d'autres versions pré-DG. Pour en savoir plus, consultez les descriptions des étapes de lancement.

Remarque sur l'interface PostgreSQL: L'intégration de Spanner Vertex AI n'est pas compatible avec les bases de données PostgreSQL.

Remarque :La version preview de l'intégration de Spanner Vertex AI n'est compatible qu'avec les modèles de ML de classification et de régression.

Objectif

Dans ce tutoriel, vous allez apprendre à effectuer les opérations suivantes :

• Enregistrer un modèle hébergé dans le service Vertex AI dans un schéma Cloud Spanner à l'aide d'instructions LDD
• Référencer ce modèle à partir de requêtes SQL pour générer des prédictions à partir de données stockées dans Cloud Spanner

Coûts

Ce tutoriel utilise des composants facturables de Google Cloud, dont :

• Cloud Spanner
• Vertex AI

Pour en savoir plus sur les coûts liés à Cloud Spanner, consultez la page Tarifs de Cloud Spanner.

Pour en savoir plus sur les coûts de Vertex AI, consultez la page Tarification de Vertex AI.

Avant de commencer

Assurez-vous de disposer d'un modèle déjà entraîné et déployé sur un point de terminaison Vertex AI.

Ce tutoriel utilise des modèles de classification et de régression déployés sur Vertex AI en suivant la procédure décrite dans la section Présentation de la classification et de la régression.

Pour obtenir des informations générales sur l'entraînement et le déploiement de modèles de ML, consultez la page Présentation des données tabulaires de Vertex AI. Toutefois, pour être utilisé avec l'intégration de Vertex AI Spanner, un modèle n'a pas besoin d'être entraîné avec Vertex AI, mais il doit être déployé uniquement sur un point de terminaison Vertex AI. Vous pouvez entraîner le modèle en utilisant n'importe quel framework ou service d'entraînement de ML, y compris votre propre infrastructure d'entraînement ML, BigQuery ML ou tout autre service d'entraînement ML tiers. Si vos données sont stockées dans Cloud Spanner, vous pouvez utiliser des requêtes fédérées. Vous pouvez également déployer des modèles de ML déjà pré-entraînés sur des dépôts de modèles publics, tels que TensorFlow Hub.

Configurer l'accès à l'intégration de Vertex AI Spanner aux points de terminaison Vertex AI

Cloud Spanner crée l'agent de service et accorde automatiquement les autorisations nécessaires lorsque Cloud Spanner exécute la première instruction LDD MODEL. Si la base de données Cloud Spanner et le point de terminaison Vertex AI se trouvent dans le même projet, aucune configuration supplémentaire n'est requise.

Si le compte d'agent de service Cloud Spanner n'existe pas pour votre projet Cloud Spanner, créez-le en exécutant la commande suivante:

gcloud beta services identity create --service=spanner.googleapis.com --project={PROJECT}`

Suivez les étapes décrites dans le tutoriel suivant pour accorder le rôle Cloud Spanner API Service Agent au compte d'agent de service Cloud Spanner service-{PROJECT}@gcp-sa-spanner.iam.gserviceaccount.com sur votre projet Vertex AI.

Enregistrer un modèle distant dans un schéma Cloud Spanner

Vous pouvez référencer un modèle à partir de requêtes SQL Cloud Spanner après l'avoir enregistré dans le schéma Cloud Spanner. Pour créer une référence au point de terminaison du modèle de classification Vertex AI entraîné et déployé à l'aide du tutoriel mentionné ci-dessus, exécutez l'instruction LDD suivante:

CREATE MODEL MyClassificationModel
REMOTE
OPTIONS (
  endpoint = '//aiplatform.googleapis.com.googleapis.com/projects/PROJECT/locations/LOCATION/endpoints/ENDPOINT_ID'
)

Ici, PROJECT, LOCATION et ENDPOINT_ID correspondent à l'ID de votre projet, à la région dans laquelle vous utilisez Vertex AI et à l'ID du point de terminaison Vertex AI. Il doit s'agir des mêmes valeurs que celles spécifiées lors du déploiement du modèle.

Colonnes de modèle explicites

Les colonnes d'entrée et de sortie du modèle sont automatiquement découvertes à partir des fichiers d'instance et de schéma de prédiction Vertex AI. La plupart des types de modèle créent automatiquement des fichiers de schéma. Pour les modèles personnalisés, ces fichiers sont facultatifs. Vous devez les fournir. Si votre modèle ne comporte pas de fichiers de schéma, vous pouvez spécifier explicitement des colonnes dans le schéma Cloud Spanner:

CREATE MODEL MyClassificationModel
INPUT (
  length FLOAT64,
  material STRING(MAX),
  tag_array ARRAY<STRING(MAX)>
)
OUTPUT (
  scores ARRAY<FLOAT64>,
  classes ARRAY<STRING(MAX)>
)
REMOTE
OPTIONS (
  endpoint = '//aiplatform.googleapis.com.googleapis.com/projects/PROJECT/locations/LOCATION/endpoints/ENDPOINT_ID'
)

Les colonnes length, material et tag_array correspondent aux colonnes d'entrée (caractéristiques) du modèle de classification utilisé dans le tutoriel. Les colonnes scores et classes sont des colonnes de sortie standards générées pour tous les modèles de classification entraînés à l'aide d'AutoML.

Pour créer une référence au modèle de régression déployé dans le tutoriel, utilisez l'instruction LDD suivante:

CREATE MODEL MyRegressionModel
INPUT (
  age FLOAT64,
  sq_ft INT64,
  code STRING(MAX)
)
OUTPUT (
  value FLOAT64,
  lower_bound FLOAT64,
  upper_bound FLOAT64
)
REMOTE
OPTIONS (
  endpoint = '//aiplatform.googleapis.com.googleapis.com/projects/PROJECT/locations/LOCATION/endpoints/ENDPOINT_ID'
)

Ici, value, lower_bound et upper_bound sont des colonnes standards générées pour tous les modèles de régression entraînés avec AutoML.

Modèles de basculement

Lorsque vous créez un modèle, vous pouvez fournir plusieurs points de terminaison Vertex AI. Cela permet à Cloud Spanner de basculer entre chaque point de terminaison de la liste, ce qui améliore la disponibilité des requêtes de ML.

CREATE MODEL MyClassificationModel
REMOTE
OPTIONS (
  endpoints = [
    '//aiplatform.googleapis.com.googleapis.com/projects/PROJECT/locations/LOCATION/endpoints/ENDPOINT_ID',
    '//aiplatform.googleapis.com.googleapis.com/projects/PROJECT_2/locations/LOCATION_2/endpoints/ENDPOINT_ID_2',
    '//aiplatform.googleapis.com.googleapis.com/projects/PROJECT_3/locations/LOCATION_3/endpoints/ENDPOINT_ID_3'
  ]
)

Nous vous recommandons de placer chaque point de terminaison dans une région distincte afin de limiter les défaillances régionales. Vous devez également placer chaque point de terminaison dans un projet distinct pour atténuer les problèmes de configuration, d'autorisation et de quota du projet.

Les points de terminaison utilisés n'ont pas besoin de déployer le même modèle ni d'utiliser le même schéma. Cloud Spanner bascule dans l'ordre spécifié. Il est donc possible de placer le point de terminaison souhaité en premier dans la liste, puis de le suivre avec un point de terminaison de remplacement simplifié, plus petit et plus évolutif, qui peut absorber les pics de charge.

Utiliser ML.PREDICT pour l'inférence ML

Pour générer des prédictions à l'aide de modèles enregistrés à partir de requêtes DQL/LMD, utilisez la fonction ML.PREDICT.

Par exemple, vous pouvez utiliser la requête SQL suivante pour générer une requête de prédiction de modèle de classification semblable à celle envoyée à l'API Vertex AI dans le tutoriel.

SELECT scores, classes
FROM ML.PREDICT(
  MODEL MyClassificationModel,
  SELECT
    3.6 AS length,
    'cotton' AS material,
    ['abc','def'] AS tag_array
  );

+---------------------------------------------+---------+
| scores                                      | classes |
+---------------------------------------------+---------+
| [0.96771615743637085, 0.032283786684274673] | [0, 1]  |
+---------------------------------------------+---------+

Pour générer une prédiction à partir d'un modèle de régression semblable à la requête API décrite dans le tutoriel sur Vertex AI, utilisez la requête suivante:

SELECT value, lower_bound, upper_bound
FROM ML.PREDICT(
  MODEL MyRegressionModel,
  SELECT
    3.6 AS age,
    5392 AS sq_ft,
    '90331' AS code
  );

+----------+-------------+-------------+
| value    | lower_bound | upper_bound |
+----------+-------------+-------------+
| 65.14233 | 4.6572      | 164.0279    |
+----------+-------------+-------------+

La fonction ML.PREDICT nécessite qu'une relation d'entrée contienne toutes les colonnes d'entrée du modèle cible. En même temps, elle permet à cette relation de contenir d'autres colonnes. Dans ce cas, elles sont transmises à une relation de sortie.

Cela permet d'associer des identifiants personnalisés (qui n'ont aucun sens pour le processus de prédiction lui-même) à des instances de prédiction. Par exemple, dans l'exemple ci-dessous, nous ajoutons une colonne id à la relation d'entrée. La valeur de la colonne id identifie de manière unique une instance de prédiction et peut être utilisée pour associer la ligne de sortie de prédiction générée à la ligne d'entrée de prédiction dans le cas où une relation d'entrée contient plusieurs lignes. En général, vous pouvez inclure toutes les colonnes d'une relation d'entrée avec une relation de sortie, comme indiqué dans la colonne age:

SELECT id, value, age
FROM ML.PREDICT(
  MODEL MyRegressionModel,
  SELECT
    1 AS id,
    3.6 AS age,
    5392 AS sq_ft,
    '90331' AS code
  );

+----+----------+-----+
| id | value    | age |
+----+----------+-----+
| 1  | 65.14233 | 3.6 |
+----+----------+-----+