Pour appeler des prédictions ou générer des représentations vectorielles continues à l'aide d'un modèle, enregistrez le point de terminaison du modèle dans la gestion des points de terminaison du modèle.
Avant de commencer
Avant d'enregistrer un point de terminaison de modèle avec la gestion des points de terminaison de modèle, vous devez activer l'extension google_ml_integration et configurer l'authentification en fonction du fournisseur de modèle, si votre point de terminaison de modèle nécessite une authentification.
Assurez-vous d'accéder à votre base de données avec le nom d'utilisateur par défaut postgres.
Activer l'extension
Vous devez ajouter et activer l'extension google_ml_integration avant de pouvoir utiliser les fonctions associées. La gestion des points de terminaison du modèle nécessite l'installation de l'extension google_ml_integration.
Vérifiez que l'indicateur de base de données
google_ml_integration.enable_model_supportest défini suronpour une instance. Pour en savoir plus sur la configuration des options de base de données, consultez Configurer les options de base de données d'une instance.Connectez-vous à votre base de données à l'aide de
psqlou d'AlloyDB pour PostgreSQL Studio.Facultatif: Si l'extension
google_ml_integrationest déjà installée, modifiez-la pour passer à la dernière version:ALTER EXTENSION google_ml_integration UPDATE;Ajoutez l'extension
google_ml_integrationà l'aide de psql:CREATE EXTENSION IF NOT EXISTS google_ml_integration;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_USERpar le nom d'utilisateur PostgreSQL non super.Assurez-vous que l'adresse IP sortante est activée pour accéder aux modèles hébergés en dehors de votre VPC, tels que les modèles tiers. Pour en savoir plus, consultez Ajouter une connectivité sortante.
Configurer l'authentification
Les sections suivantes expliquent comment configurer l'authentification avant d'enregistrer un point de terminaison de modèle.
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 AlloyDB 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 la section Intégrer à Vertex AI.
Configurer l'authentification à l'aide de Secret Manager
Cette section explique comment configurer l'authentification si vous utilisez Secret Manager pour stocker les informations d'authentification des fournisseurs tiers.
Cette étape est facultative si le point de terminaison de votre modèle ne gère pas l'authentification via Secret Manager (par exemple, si le point de terminaison de votre modèle utilise des en-têtes HTTP pour transmettre des informations d'authentification ou s'il n'utilise pas du tout l'authentification).
Pour créer et utiliser une clé API ou un jeton porteur, procédez comme suit:
Créez le secret dans Secret Manager. Pour en savoir plus, consultez la section Créer un secret et y accéder.
Le chemin d'accès au secret est utilisé dans la fonction SQL
google_ml.create_sm_secret().Accordez des autorisations au cluster AlloyDB pour qu'il puisse accéder au secret.
gcloud secrets add-iam-policy-binding 'SECRET_NAME' \ --member="serviceAccount:SERVICE_ACCOUNT_ID" \ --role="roles/secretmanager.secretAccessor"Remplacez les éléments suivants :
SECRET_NAME: nom du secret dans Secret Manager.SERVICE_ACCOUNT_ID: ID du compte de service basé sur IAM au formatserviceAccount:service-PROJECT_ID@gcp-sa-alloydb.iam.gserviceaccount.com(par exemple,service-212340152456@gcp-sa-alloydb.iam.gserviceaccount.com).Vous pouvez également attribuer ce rôle au compte de service au niveau du projet. Pour en savoir plus, consultez Ajouter une liaison de stratégie Identity and Access Management.
Configurer l'authentification à l'aide d'en-têtes
L'exemple suivant montre comment configurer l'authentification à l'aide d'une fonction. La fonction renvoie un objet JSON contenant les en-têtes requis pour envoyer une requête au modèle d'encapsulation.
CREATE OR REPLACE FUNCTION HEADER_GEN_FUNCTION(
model_id VARCHAR(100),
input_text TEXT
)
RETURNS JSON
LANGUAGE plpgsql
AS $$
#variable_conflict use_variable
DECLARE
api_key VARCHAR(255) := 'API_KEY';
header_json JSON;
BEGIN
header_json := json_build_object(
'Content-Type', 'application/json',
'Authorization', 'Bearer ' || api_key
);
RETURN header_json;
END;
$$;
Remplacez les éléments suivants :
HEADER_GEN_FUNCTION: nom de la fonction de génération d'en-tête que vous pouvez utiliser lors de l'enregistrement d'un modèle.API_KEY: clé API du fournisseur de modèle.
Modèles d'embeddings de texte
Cette section explique comment enregistrer des points de terminaison de modèle avec la gestion des points de terminaison de modèle.
La gestion des points de terminaison de modèle est compatible avec certains modèles d'embeddings textuels et génériques Vertex AI en tant que points de terminaison de modèle préenregistrés. Vous pouvez utiliser directement l'ID du modèle pour générer des représentations vectorielles continues ou appeler des prédictions, en fonction du type de modèle. Pour en savoir plus sur les modèles préenregistrés compatibles, consultez la section Modèles Vertex AI préenregistrés.
Par exemple, pour appeler le modèle textembedding-gecko préenregistré, vous pouvez l'appeler directement à l'aide de la fonction d'encapsulation:
SELECT
google_ml.embedding(
model_id => 'textembedding-gecko',
content => 'AlloyDB is a managed, cloud-hosted SQL database service');
De même, pour appeler le modèle gemini-1.5-pro:generateContent préenregistré, vous pouvez l'appeler directement à l'aide de la fonction de prédiction:
SELECT
json_array_elements(
google_ml.predict_row(
model_id => 'gemini-1.5-pro:generateContent',
request_body => '{
"contents": [
{
"role": "user",
"parts": [
{
"text": "For TPCH database schema as mentioned here https://www.tpc.org/TPC_Documents_Current_Versions/pdf/TPC-H_v3.0.1.pdf , generate a SQL query to find all supplier names which are located in the India nation."
}
]
}
]
}'))-> 'candidates' -> 0 -> 'content' -> 'parts' -> 0 -> 'text';
Pour générer des embeddings, consultez la section Générer des embeddings pour les points de terminaison de modèle préenregistrés. Pour appeler des prédictions, consultez la section Appeler des prédictions pour les points de terminaison de modèle préenregistrés.
Modèles d'embeddings de texte avec prise en charge intégrée
La gestion des points de terminaison de modèle est compatible avec certains modèles de Vertex AI et OpenAI. Pour obtenir la liste des modèles compatibles, consultez Modèles compatibles.
Pour les modèles compatibles avec la prise en charge intégrée, vous pouvez définir le nom qualifié comme nom qualifié du modèle et spécifier l'URL de la requête. La gestion des points de terminaison du modèle identifie automatiquement le modèle et configure les fonctions de transformation par défaut.
Modèles d'embedding Vertex AI
Les étapes suivantes montrent comment enregistrer des modèles Vertex AI avec prise en charge intégrée. Le point de terminaison du modèle text-embedding-005 et text-multilingual-embedding-002 est utilisé à titre d'exemple.
Assurez-vous que le cluster AlloyDB et le modèle Vertex AI que vous interrogez se trouvent dans la même région.
Appelez la fonction de création de modèle pour ajouter le point de terminaison du modèle:
text-embedding-005
CALL google_ml.create_model( model_id => 'text-embedding-005', model_request_url => 'publishers/google/models/text-embedding-005', model_provider => 'google', model_qualified_name => 'text-embedding-005', model_type => 'text_embedding', model_auth_type => 'alloydb_service_agent_iam');text-multilingual-embedding-002
CALL google_ml.create_model( model_id => 'text-multilingual-embedding-002', model_request_url => 'publishers/google/models/text-multilingual-embedding-002', model_provider => 'google', model_qualified_name => 'text-multilingual-embedding-002', model_type => 'text_embedding', model_auth_type => 'alloydb_service_agent_iam' model_in_transform_fn => 'google_ml.vertexai_text_embedding_input_transform', model_out_transform_fn => 'google_ml.vertexai_text_embedding_output_transform');
Si le modèle est stocké dans un autre projet et une autre région que votre cluster AlloyDB, définissez l'URL de la requête sur projects/PROJECT_ID/locations/REGION_ID/publishers/google/models/MODEL_ID, où REGION_ID correspond à la région dans laquelle votre modèle est hébergé et MODEL_ID au nom qualifié du modèle.
En outre, attribuez le rôle Utilisateur Vertex AI (roles/aiplatform.user) au compte de service AlloyDB du projet dans lequel se trouve l'instance AlloyDB afin qu'AlloyDB puisse accéder au modèle hébergé dans l'autre projet.
Modèle d'embedding textuel Open AI
L'extension google_ml_integration configure automatiquement les fonctions de transformation par défaut et appelle les modèles OpenAI distants. Pour obtenir la liste des modèles OpenAI compatibles, consultez Modèles compatibles.
L'exemple suivant ajoute le point de terminaison du modèle OpenAI text-embedding-ada-002.
Vous pouvez enregistrer les points de terminaison de modèle text-embedding-3-small et text-embedding-3-large OpenAI en suivant les mêmes étapes et en définissant les noms qualifiés de modèle spécifiques aux modèles.
- Connectez-vous à votre base de données à l'aide de
psql. - Créez et activez l'extension
google_ml_integration. - Ajoutez la clé API OpenAI en tant que secret à Secret Manager pour l'authentification.
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.
Appelez la fonction de création de modèle pour enregistrer le point de terminaison du modèle
text-embedding-ada-002:CALL google_ml.create_model( model_id => 'MODEL_ID', model_provider => 'open_ai', model_type => 'text_embedding', model_qualified_name => 'text-embedding-ada-002', model_auth_type => 'secret_manager', model_auth_id => 'SECRET_ID');Remplacez les éléments suivants :
MODEL_ID: ID unique du point de terminaison du modèle que vous définissez. 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.SECRET_ID: ID du secret que vous avez utilisé précédemment dans la procéduregoogle_ml.create_sm_secret().
Pour générer des embeddings, découvrez comment générer des embeddings pour les points de terminaison de modèle avec prise en charge intégrée.
Modèle d'embedding de texte hébergé en interne
Cette section explique comment enregistrer un point de terminaison de modèle hébergé par l'utilisateur, ainsi que créer des fonctions de transformation et éventuellement des en-têtes HTTP personnalisés. Tous les points de terminaison de modèle hébergés en mode personnalisé sont compatibles, quel que soit l'emplacement de l'hébergement.
L'exemple suivant ajoute le point de terminaison de modèle personnalisé custom-embedding-model hébergé par Cymbal. 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:
Facultatif: Ajoutez la clé API en tant que secret à Secret Manager pour l'authentification.
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.
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. Identifiant 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 publiques.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éduregoogle_ml.create_sm_secret().
Modèles génériques
Cette section explique comment enregistrer n'importe quel point de terminaison de modèle générique disponible auprès d'un fournisseur de modèles hébergé tel que Hugging Face, OpenAI, Vertex AI, Anthropic ou tout autre fournisseur. Cette section présente des exemples d'enregistrement d'un point de terminaison de modèle générique hébergé sur Hugging Face, d'un modèle gemini-pro générique à partir de Vertex AI Model Garden et du point de terminaison de modèle claude-haiku.
Vous pouvez enregistrer n'importe quel point de terminaison de modèle générique tant que l'entrée et la sortie sont au format JSON. En fonction des métadonnées de votre point de terminaison de modèle, vous devrez peut-être générer des en-têtes HTTP ou définir des URL de requête.
Pour en savoir plus sur les modèles génériques préenregistrés et les modèles compatibles intégrés, consultez la section Modèles compatibles.
Modèle Gemini
Étant donné que certains modèles gemini-pro sont préenregistrés, vous pouvez appeler directement l'ID de modèle pour appeler des prédictions.
L'exemple suivant utilise le point de terminaison du modèle gemini-1.5-pro:generateContent de Vertex AI Model Garden.
- Connectez-vous à votre base de données à l'aide de
psql. - Créez et activez l'extension
google_ml_integration. Appelez des prédictions à l'aide de l'ID de modèle préenregistré:
SELECT json_array_elements( google_ml.predict_row( model_id => 'gemini-1.5-pro:generateContent', request_body => '{ "contents": [ { "role": "user", "parts": [ { "text": "For TPCH database schema as mentioned here https://www.tpc.org/TPC_Documents_Current_Versions/pdf/TPC-H_v3.0.1.pdf , generate a SQL query to find all supplier names which are located in the India nation." } ] } ] }'))-> 'candidates' -> 0 -> 'content' -> 'parts' -> 0 -> 'text';
Modèle générique sur Hugging Face
L'exemple suivant ajoute le point de terminaison du modèle de classification personnalisé facebook/bart-large-mnli hébergé sur Hugging Face.
- Connectez-vous à votre base de données à l'aide de
psql. - Créez et activez l'extension
google_ml_integration. - Ajoutez la clé API OpenAI en tant que secret à Secret Manager pour l'authentification. Si vous avez déjà créé un secret pour un autre modèle OpenAI, vous pouvez le réutiliser.
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 définissez et qui est ensuite utilisé lors de l'enregistrement d'un point de terminaison de modèle.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.
Appelez la fonction de création de modèle pour enregistrer le point de terminaison du modèle
facebook/bart-large-mnli:CALL google_ml.create_model( model_id => 'MODEL_ID', model_provider => 'hugging_face', model_request_url => 'REQUEST_URL', model_qualified_name => 'MODEL_QUALIFIED_NAME', model_auth_type => 'secret_manager', model_auth_id => 'SECRET_ID');Remplacez les éléments suivants :
MODEL_ID: ID unique du point de terminaison du modèle que vous définissez (par exemple,custom-classification-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: point de terminaison spécifique au modèle lorsque vous ajoutez un embedding de texte personnalisé et des points de terminaison de modèle génériques (par exemple,https://api-inference.huggingface.co/models/facebook/bart-large-mnli).MODEL_QUALIFIED_NAME: nom complet de la version du point de terminaison du modèle (par exemple,facebook/bart-large-mnli).SECRET_ID: ID du secret que vous avez utilisé précédemment dans la procéduregoogle_ml.create_sm_secret().
Modèle générique Anthropic
L'exemple suivant ajoute le point de terminaison du modèle claude-3-opus-20240229.
La gestion des points de terminaison du modèle fournit la fonction d'en-tête requise pour enregistrer des modèles anthropiques.
- Connectez-vous à votre base de données à l'aide de
psql. Créez et activez l'extension
google_ml_integration.Secret Manager
- Ajoutez le jeton porteur en tant que secret à Secret Manager pour l'authentification.
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 définissez et qui est ensuite utilisé lors de l'enregistrement d'un point de terminaison de modèle.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.
Appelez la fonction de création de modèle pour enregistrer le point de terminaison du modèle
claude-3-opus-20240229.CALL google_ml.create_model( model_id => 'MODEL_ID', model_provider => 'anthropic', model_request_url => 'REQUEST_URL', model_auth_type => 'secret_manager', model_auth_id => 'SECRET_ID', generate_headers_fn => 'google_ml.anthropic_claude_header_gen_fn');Remplacez les éléments suivants :
MODEL_ID: ID unique du point de terminaison du modèle que vous définissez (par exemple,anthropic-opus). 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: point de terminaison spécifique au modèle lorsque vous ajoutez un embedding de texte personnalisé et des points de terminaison de modèle génériques (par exemple,https://api.anthropic.com/v1/messages).
En-tête d'autorisation
Utilisez la fonction de génération d'en-tête par défaut
google_ml.anthropic_claude_header_gen_fnou créez une fonction de génération d'en-tête.CREATE OR REPLACE FUNCTION anthropic_sample_header_gen_fn(model_id VARCHAR(100), request_body JSON) RETURNS JSON LANGUAGE plpgsql AS $$ #variable_conflict use_variable BEGIN RETURN json_build_object('x-api-key', 'ANTHROPIC_API_KEY', 'anthropic-version', 'ANTHROPIC_VERSION')::JSON; END; $$;Remplacez les éléments suivants :
ANTHROPIC_API_KEY: clé API anthropique.ANTHROPIC_VERSION(facultatif): version de modèle spécifique que vous souhaitez utiliser (par exemple,2023-06-01).
Appelez la fonction de création de modèle pour enregistrer le point de terminaison du modèle
claude-3-opus-20240229.CALL google_ml.create_model( model_id => 'MODEL_ID', model_provider => 'anthropic', model_request_url => 'REQUEST_URL', generate_headers_fn => 'google_ml.anthropic_claude_header_gen_fn');Remplacez les éléments suivants :
MODEL_ID: ID unique du point de terminaison du modèle que vous définissez (par exemple,anthropic-opus). 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: point de terminaison spécifique au modèle lorsque vous ajoutez un embedding de texte personnalisé et des points de terminaison de modèle génériques (par exemple,https://api.anthropic.com/v1/messages).
Pour en savoir plus, découvrez comment appeler des prédictions pour des points de terminaison de modèle génériques.
Étape suivante
- En savoir plus sur la référence de gestion des points de terminaison du modèle
- Utiliser des exemples de modèles pour enregistrer des points de terminaison de modèle