Cette page a été traduite par l'API Cloud Translation.

Enregistrer et appeler des modèles d'IA distants à l'aide de la gestion des points de terminaison de modèle

MySQL | PostgreSQL | SQL Server

Cette page explique comment appeler des prédictions ou générer des embeddings à l'aide d'un modèle, puis enregistrer le point de terminaison du modèle avec la gestion des points de terminaison de modèle.

Pour en savoir plus sur la fonction google_ml.create_model(), consultez la documentation de référence sur la gestion des points de terminaison de modèle.

Avant de commencer

Si votre point de terminaison de modèle nécessite une authentification, activez l'extension google_ml_integration.
Configurez l'authentification en fonction du fournisseur de modèles.
Assurez-vous d'utiliser le nom d'utilisateur par défaut postgres pour accéder à votre base de données.

Activer l'extension

Définissez l'option de base de données google_ml_integration.enable_model_support sur on pour votre instance. Pour en savoir plus sur la configuration des options de base de données, consultez Configurer des options de base de données.
Connectez-vous à votre instance principale à l'aide d'un client psql ou de Cloud SQL Studio.
Exécutez la commande suivante pour vous assurer que l'extension google_ml_integration est mise à jour vers la version 1.4.2 :
```
    ALTER EXTENSION google_ml_integration UPDATE TO '1.4.2'
```
Ajoutez l'extension google_ml_integration version 1.4.2 à l'aide de psql :
```
  CREATE EXTENSION google_ml_integration VERSION '1.4.2';
```
Facultatif : accordez l'autorisation à un utilisateur PostgreSQL autre qu'un super-administrateur de gérer les métadonnées du modèle :
```
  GRANT SELECT, INSERT, UPDATE, DELETE ON ALL TABLES IN SCHEMA google_ml TO NON_SUPER_USER;
```
Remplacez NON_SUPER_USER par le nom d'utilisateur PostgreSQL non super-utilisateur.

Configurer l'authentification

Les sections suivantes expliquent comment configurer l'authentification avant d'ajouter un point de terminaison de modèle Vertex AI ou des points de terminaison de modèle hébergés dans Google Cloud.

Configurer l'authentification pour Vertex AI

Pour utiliser les points de terminaison des modèles Google Vertex AI, vous devez ajouter des autorisations Vertex AI au compte de service Cloud SQL basé sur IAM que vous utilisez pour vous connecter à la base de données. Pour en savoir plus sur l'intégration à Vertex AI, consultez Intégrer Cloud SQL à Vertex AI.

Configurer l'authentification pour les modèles hébergés personnalisés

Cette section explique comment configurer l'authentification si vous utilisez Secret Manager. Pour tous les modèles, à l'exception des points de terminaison de modèle Vertex AI, vous pouvez stocker vos clés API ou vos jetons du porteur dans Secret Manager.

Si le point de terminaison de votre modèle ne gère pas l'authentification via Secret Manager, cette section est facultative. Par exemple, si le point de terminaison de votre modèle utilise des en-têtes HTTP pour transmettre des informations d'authentification ou n'utilise pas du tout l'authentification, n'effectuez pas les étapes de cette section.

Pour créer et utiliser une clé API ou un jeton du porteur, procédez comme suit :

Créez un secret dans Secret Manager. Pour en savoir plus, consultez Créer un secret et accéder à une version de secret.

Le nom et le chemin du secret sont utilisés dans la fonction SQL google_ml.create_sm_secret().
Accordez à l'instance Cloud SQL les autorisations nécessaires pour accéder au secret.
```
  gcloud secrets add-iam-policy-binding SECRET_ID \
      --member="serviceAccount:SERVICE_ACCOUNT_EMAIL" \
      --role="roles/secretmanager.secretAccessor"
```
Remplacez les éléments suivants :
- SECRET_ID : ID du secret dans Secret Manager.
- SERVICE_ACCOUNT_EMAIL : adresse e-mail du compte de service Cloud SQL basé sur IAM. Pour trouver cette adresse e-mail, utilisez la commande gcloud sql instances describe INSTANCE_NAME et remplacez INSTANCE_NAME par le nom de l'instance. La valeur qui s'affiche à côté du paramètre serviceAccountEmailAddress est l'adresse e-mail.

Modèles d'embedding de texte avec prise en charge intégrée

Cette section explique comment enregistrer des points de terminaison de modèle pour la gestion des points de terminaison de modèle.

Modèles d'embedding Vertex AI

La gestion des points de terminaison de modèle offre une compatibilité intégrée pour toutes les versions du modèle text-embedding-gecko de Vertex AI. Utilisez le nom qualifié pour définir la version du modèle sur textembedding-gecko@001 ou textembedding-gecko@002.

Étant donné que les ID de point de terminaison de modèle textembedding-gecko et textembedding-gecko@001 sont préenregistrés auprès de la gestion des points de terminaison de modèle, vous pouvez utiliser l'un ou l'autre directement comme ID de modèle. Pour ces modèles, l'extension configure automatiquement les fonctions de transformation par défaut.

Assurez-vous que l'instance Cloud SQL et le modèle Vertex AI que vous interrogez se trouvent dans la même région.

Pour enregistrer le point de terminaison du modèle textembedding-gecko@002, appelez la fonction create_model :

  CALL
    google_ml.create_model(
      model_id => 'textembedding-gecko@002',
      model_provider => 'google',
      model_qualified_name => 'textembedding-gecko@002',
      model_type => 'text_embedding',
      model_auth_type => 'cloudsql_service_agent_iam');

Modèles d'embedding de texte hébergés sur mesure

Cette section explique comment enregistrer des points de terminaison de modèles personnalisés hébergés dans des réseaux au sein de Google Cloud.

Pour ajouter des points de terminaison de modèles d'embedding de texte hébergés sur mesure, vous devez créer des fonctions de transformation et, éventuellement, des en-têtes HTTP personnalisés. En revanche, l'ajout de points de terminaison de modèles génériques hébergés personnalisés implique de générer éventuellement des en-têtes HTTP personnalisés et de définir l'URL de la requête du modèle.

L'exemple suivant ajoute le point de terminaison du modèle d'embedding de texte custom-embedding-model hébergé par Cymbal, qui est hébergé dans Google Cloud. Les fonctions de transformation cymbal_text_input_transform et cymbal_text_output_transform permettent de transformer le format d'entrée et de sortie du modèle en format d'entrée et de sortie de la fonction de prédiction.

Pour enregistrer des points de terminaison de modèles d'embedding de texte hébergés sur mesure, procédez comme suit :

Appelez le secret stocké dans Secret Manager :
```
CALL
  google_ml.create_sm_secret(
    secret_id => 'SECRET_ID',
    secret_path => 'projects/project-id/secrets/SECRET_MANAGER_SECRET_ID/versions/VERSION_NUMBER');
```
Remplacez les éléments suivants :
- SECRET_ID : ID secret que vous avez défini et qui est utilisé par la suite lors de l'enregistrement d'un point de terminaison de modèle (par exemple, key1).
- SECRET_MANAGER_SECRET_ID : ID du secret défini dans Secret Manager lorsque vous avez créé le secret.
- PROJECT_ID : ID de votre projet Google Cloud .
- VERSION_NUMBER : numéro de version de l'ID du secret.
Remarque : Secret Manager génère par défaut un en-tête Authorization: Bearer SECRET_VALUE_FROM_SECRET_MANAGER pour l'authentification. Si ce format correspond à celui du jeton du porteur d'autorisation du point de terminaison de votre modèle, vous n'avez pas besoin de générer des en-têtes d'authentification à l'aide de la fonction de génération d'en-têtes.

Créez les fonctions de transformation d'entrée et de sortie en fonction de la signature suivante pour la fonction de prédiction des points de terminaison du modèle d'embedding de texte. Pour savoir comment créer des fonctions de transformation, consultez Exemple de fonctions de transformation.

Voici des exemples de fonctions de transformation spécifiques au point de terminaison du modèle d'embedding de texte custom-embedding-model :

-- Input Transform Function corresponding to the custom model endpoint
CREATE OR REPLACE FUNCTION cymbal_text_input_transform(model_id VARCHAR(100), input_text TEXT)
RETURNS JSON
LANGUAGE plpgsql
AS $$
DECLARE
  transformed_input JSON;
  model_qualified_name TEXT;
BEGIN
  SELECT json_build_object('prompt', json_build_array(input_text))::JSON INTO transformed_input;
  RETURN transformed_input;
END;
$$;
-- Output Transform Function corresponding to the custom model endpoint
CREATE OR REPLACE FUNCTION cymbal_text_output_transform(model_id VARCHAR(100), response_json JSON)
RETURNS REAL[]
LANGUAGE plpgsql
AS $$
DECLARE
  transformed_output REAL[];
BEGIN
  SELECT ARRAY(SELECT json_array_elements_text(response_json->0)) INTO transformed_output;
  RETURN transformed_output;
END;
$$;

Appelez la fonction de création de modèle pour enregistrer le point de terminaison du modèle d'embedding personnalisé :
```
CALL
  google_ml.create_model(
    model_id => 'MODEL_ID',
    model_request_url => 'REQUEST_URL',
    model_provider => 'custom',
    model_type => 'text_embedding',
    model_auth_type => 'secret_manager',
    model_auth_id => 'SECRET_ID',
    model_qualified_name => 'MODEL_QUALIFIED_NAME',
    model_in_transform_fn => 'cymbal_text_input_transform',
    model_out_transform_fn => 'cymbal_text_output_transform');
```
Remplacez les éléments suivants :
- MODEL_ID : Obligatoire. ID unique du point de terminaison du modèle que vous définissez (par exemple, custom-embedding-model). Cet ID de modèle est référencé pour les métadonnées dont le point de terminaison du modèle a besoin pour générer des embeddings ou appeler des prédictions.
- REQUEST_URL : Obligatoire. Point de terminaison spécifique au modèle lors de l'ajout d'embeddings de texte personnalisés et de points de terminaison de modèle génériques (par exemple, https://cymbal.com/models/text/embeddings/v1). Assurez-vous que le point de terminaison du modèle est accessible via une adresse IP interne. La gestion des points de terminaison de modèles n'est pas compatible avec les adresses IP externes.
- MODEL_QUALIFIED_NAME : obligatoire si le point de terminaison de votre modèle utilise un nom qualifié. Nom complet si le point de terminaison du modèle comporte plusieurs versions.
- SECRET_ID : ID du secret que vous avez utilisé précédemment dans la procédure google_ml.create_sm_secret().

Modèles génériques

Cette section explique comment enregistrer un point de terminaison de modèle gemini-pro générique à partir de Vertex AI Model Garden, qui n'est pas compatible par défaut. Vous pouvez enregistrer n'importe quel point de terminaison de modèle générique hébergé dans Google Cloud.

Cloud SQL n'est compatible qu'avec les points de terminaison de modèles disponibles dans Vertex AI Model Garden et les points de terminaison de modèles hébergés dans des réseaux situés dans Google Cloud.

Modèle Gemini

L'exemple suivant ajoute le point de terminaison du modèle gemini-1.0-pro à partir de Vertex AI Model Garden.

Pour enregistrer le point de terminaison du modèle gemini-1.0-pro, appelez la fonction create model :

```sql
CALL
  google_ml.create_model(
    model_id => 'MODEL_ID',
    model_request_url => 'https://us-central1-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/us-central1/publishers/google/models/gemini-1.0-pro:streamGenerateContent',
    model_provider => 'google',
    model_auth_type => 'cloudsql_service_agent_iam');
```

Replace the following:
* <code><var>MODEL_ID</var></code>: a unique ID for the model endpoint that you define (for example,<br> `gemini-1`). This model ID is referenced for metadata that the model endpoint needs to generate embeddings or invoke predictions.
* <code><var>PROJECT_ID</var></code>: the ID of your Google Cloud project.

Pour en savoir plus, consultez Appeler des prédictions pour les points de terminaison de modèles génériques.

Étapes suivantes

En savoir plus sur la documentation de référence sur la gestion des points de terminaison de modèle