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 représentations vectorielles continues à l'aide d'un modèle, puis enregistrer le point de terminaison du modèle auprès de 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 du modèle.

Avant de commencer

Si le point de terminaison de votre 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'indicateur 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 la section 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 non super-administrateur de gérer les métadonnées de 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.

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 de modèle 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 jetons d'accès 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 votre point de terminaison de modèle utilise des en-têtes HTTP pour transmettre des informations d'authentification ou n'utilise pas du tout l'authentification, ne suivez pas les étapes de cette section.

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

Créez un secret dans Secret Manager. Pour en savoir plus, consultez la section Créer un secret et y accéder.

Le nom et le chemin du secret sont utilisés dans la fonction SQL google_ml.create_sm_secret().
Accordez des autorisations à l'instance Cloud SQL pour qu'elle puisse 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'embeddings de texte avec prise en charge intégrée

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

Modèles d'embedding Vertex AI

La gestion des points de terminaison de modèle est compatible avec toutes les versions du modèle text-embedding-gecko par 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 avec la gestion des points de terminaison de modèle, vous pouvez utiliser l'un d'eux 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'embeddings de texte hébergés en interne

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

L'ajout de points de terminaison de modèle d'encapsulation de texte hébergés par l'utilisateur implique la création de fonctions de transformation et, éventuellement, d'en-têtes HTTP personnalisés. En revanche, l'ajout de points de terminaison de modèle génériques hébergés par l'utilisateur 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'encapsulation 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èle d'embedding textuel hébergé en interne, 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 de secret que vous définissez et qui est ensuite utilisé 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 :Par défaut, Secret Manager génère un en-tête Authorization: Bearer SECRET_VALUE_FROM_SECRET_MANAGER pour l'authentification. Si ce format correspond au format du jeton porteur d'autorisation du point de terminaison de votre modèle, vous n'avez pas besoin de générer d'en-têtes d'autorisation à 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 en savoir plus sur la création de 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'embeddings textuels 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 représentations vectorielles continues ou appeler des prédictions.
- REQUEST_URL : Obligatoire. Point de terminaison spécifique au modèle lorsque vous ajoutez des représentations vectorielles continues de texte personnalisées et des 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 par modèle 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 au cas où 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 Model Garden de Vertex AI, qui n'est pas compatible avec cette fonctionnalité. 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èle disponibles via Vertex AI Model Garden et les points de terminaison de modèle hébergés dans des réseaux de 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, découvrez comment appeler des prédictions pour des points de terminaison de modèle génériques.

Étape suivante

Découvrez la documentation de référence sur la gestion des points de terminaison des modèles.