Tutoriel : Créez des Endpoint de modèle externes pour query les modèles OpenAI
Cette page fournit des instructions étape par étape pour configurer et interroger un Endpoint de modèle externe qui déploie des modèles OpenAI pour les complétions, le chat et les intégrations. Vous créez l'Endpoint avec le SDK de déploiement MLflow et le query avec le client OpenAI. Pour plus d'information, voir modèles externes.
Après avoir créé un Endpoint, Databricks recommande d’y configurer Unity AI Gateway afin d’ajouter des fonctionnalités de gouvernance telles que le suivi de l’utilisation, la journalisation des charges utiles, les garde-fous et les limites de débit. Tous les modèles externes servis via Model Serving sont interrogés à l'aide de l'API compatible OpenAI, vous pouvez donc utiliser un seul client pour tous les fournisseurs. Voir Gouvernance de l’IA avec Unity AI Gateway.
Demandez à Genie Code (mode Agent) de le faire pour vous :
Create a new notebook that uses the MLflow Deployments SDK to create an external model endpoint named openai-completions-endpoint that serves OpenAI's gpt-3.5-turbo-instruct model for completions, reading my OpenAI API key from a Databricks secret scope. Then send a test completion request to the endpoint and display the response.
Si vous préférez utiliser l'interface utilisateur de service pour accomplir cette tâche, consultez Créer un endpoint de service de modèle externe.
Exigences
- Databricks Runtime 13.0 ML ou version ultérieure.
- MLflow 2.9 ou supérieur.
- Clés OpenAI API.
- Installez la CLI Databricks version 0,205 ou supérieure.
(Facultatif) Étape 0 : Stocker la clé API OpenAI à l'aide de l'interface CLI de Databricks Secrets.
Vous pouvez fournir vos clés API sous forme de chaînes de texte brut à l'étape 3 ou en utilisant les secrets Databricks.
Pour stocker la clé API OpenAI en tant que secret, vous pouvez utiliser la CLI Secrets de Databricks (version 0.205 et supérieure). Vous pouvez également utiliser l'API REST pour les secrets.
La procédure suivante crée le Secret Scope nommé my_openai_secret_scope, puis crée le secret openai_api_key dans ce Secret Scope.
databricks secrets create-scope my_openai_secret_scope
databricks secrets put-secret my_openai_secret_scope openai_api_key
Étape 1 : Installer MLflow avec la prise en charge des modèles externes
Utilisez ce qui suit pour installer une version MLflow avec prise en charge des modèles externes :
%pip install mlflow[genai]>=2.9.0
Étape 2 : Créer et gérer un Endpoint de modèle externe
Les exemples de code de cette section montrent l'utilisation du SDK CRUD des déploiements MLflow en aperçu public.
Pour créer un endpoint de modèle externe pour un grand modèle linguistique (LLM), utilisez la méthode create_endpoint() du SDK MLflow Deployments. Vous pouvez également créer des Endpoint de modèles externes dans l'interface utilisateur de Serving.
L'extrait de code suivant crée un endpoint de complétions pour OpenAI gpt-3.5-turbo-instruct, tel que spécifié dans la section served_entities de la configuration. Pour votre endpoint, assurez-vous de renseigner les champs name et openai_api_key avec vos valeurs uniques pour chaque champ.
import mlflow.deployments
client = mlflow.deployments.get_deploy_client("databricks")
client.create_endpoint(
name="openai-completions-endpoint",
config={
"served_entities": [{
"name": "openai-completions",
"external_model": {
"name": "gpt-3.5-turbo-instruct",
"provider": "openai",
"task": "llm/v1/completions",
"openai_config": {
"openai_api_key": "{{secrets/my_openai_secret_scope/openai_api_key}}"
}
}
}]
}
)
L'extrait de code suivant montre comment vous pouvez fournir votre clé API OpenAI en tant que chaîne de caractères en clair pour une façon alternative de créer le même endpoint de complétions que ci-dessus.
import mlflow.deployments
client = mlflow.deployments.get_deploy_client("databricks")
client.create_endpoint(
name="openai-completions-endpoint",
config={
"served_entities": [{
"name": "openai-completions",
"external_model": {
"name": "gpt-3.5-turbo-instruct",
"provider": "openai",
"task": "llm/v1/completions",
"openai_config": {
"openai_api_key_plaintext": "sk-yourApiKey"
}
}
}]
}
)
Si vous utilisez Azure OpenAI, vous pouvez également spécifier le nom du déploiement Azure OpenAI, l'URL de l'Endpoint et la version de l'API dans la section openai_config de la configuration.
client.create_endpoint(
name="openai-completions-endpoint",
config={
"served_entities": [
{
"name": "openai-completions",
"external_model": {
"name": "gpt-3.5-turbo-instruct",
"provider": "openai",
"task": "llm/v1/completions",
"openai_config": {
"openai_api_type": "azure",
"openai_api_key": "{{secrets/my_openai_secret_scope/openai_api_key}}",
"openai_api_base": "https://my-azure-openai-endpoint.openai.azure.com",
"openai_deployment_name": "my-gpt-35-turbo-deployment",
"openai_api_version": "2023-05-15"
},
},
}
],
},
)
Pour configurer les limites de débit, le suivi de l'utilisation, la journalisation des charges utiles ou les garde-fous sur l'Endpoint, utilisez Unity AI Gateway. La configuration des limites de débit via Unity AI Gateway prend en charge les limites basées sur les query (QPM) et sur les jetons (TPM) et vous permet de définir des limites par utilisateur, par groupe et à l'échelle de l'Endpoint.
Consultez Configurer la passerelle IA sur les Endpoint de service de modèle pour un exemple de programmation qui met à jour un Endpoint afin d'ajouter des limites de taux et d'autres fonctionnalités de la passerelle IA Unity.
Le modèle client.update_endpoint() précédemment documenté avec un champ rate_limits de niveau supérieur est obsolète. Utilisez la configuration de Unity AI Gateway sur l'Endpoint à la place.
Étape 3 : Envoyez des requêtes à un endpoint de modèle externe
Databricks recommande d'interroger les Endpoint de modèle externe à l'aide du client OpenAI. Model Serving expose une API unifiée, compatible avec OpenAI, sur l’ensemble des fournisseurs, de sorte que le même code client fonctionne, que le modèle sous-jacent provienne d'OpenAI, d'Anthropic, de Cohere, d'Amazon Bedrock, de Google Cloud Vertex AI ou d'un fournisseur personnalisé.
Installez le client OpenAI sur votre compute :
%pip install openai
Ce qui suit envoie une demande d'achèvement de chat à un Endpoint qui sert un modèle de chat OpenAI. Remplacez la valeur base_url par l'URL de votre Workspace Databricks, et fournissez un jeton d'accès personnel Databricks pour api_key. Définissez le paramètre model sur le nom de votre Endpoint de service de modèle.
import os
from openai import OpenAI
client = OpenAI(
api_key=os.environ.get("DATABRICKS_TOKEN"),
base_url="https://<workspace-name>.cloud.databricks.com/serving-endpoints"
)
response = client.chat.completions.create(
model="openai-chat-endpoint",
messages=[
{"role": "system", "content": "You are a helpful assistant."},
{"role": "user", "content": "What is the capital of France?"}
],
max_tokens=128,
temperature=0.1,
)
print(response.choices[0].message.content)
Pour envoyer une requête de complétions à un Endpoint configuré pour la tâche llm/v1/completions, utilisez client.completions.create():
response = client.completions.create(
model="openai-completions-endpoint",
prompt="What is the capital of France?",
max_tokens=10,
temperature=0.1,
n=2,
)
print(response)
Pour envoyer une requête d'intégration à un Endpoint configuré pour la tâche llm/v1/embeddings, utilisez client.embeddings.create():
response = client.embeddings.create(
model="openai-embeddings-endpoint",
input="Databricks is a unified analytics platform.",
)
print(response.data[0].embedding)
Si vous exécutez le client OpenAI depuis un notebook Databricks, vous pouvez utiliser l'assistant databricks-openai, qui configure automatiquement l'authentification et l'URL de base du Workspace. Voir Utiliser des modèles de fondation pour plus de détails.
Étape 4 : Comparez les modèles d'un autre fournisseur
Le service de modèles prend en charge de nombreux fournisseurs de modèles externes, notamment Open AI, Anthropic, Cohere, Amazon Bedrock, Google Cloud Vertex AI, et plus encore. Vous pouvez comparer les LLM de différents fournisseurs, vous aidant ainsi à optimiser la précision, la vitesse et le coût de vos applications à l'aide de l'AI Playground.
L'exemple suivant crée un Endpoint pour Anthropic claude-2 et compare sa réponse à une question qui utilise OpenAI gpt-3.5-turbo-instruct. Les deux réponses ont le même format standard, ce qui les rend faciles à comparer.
Créer un endpoint pour Anthropic claude-2
import mlflow.deployments
client = mlflow.deployments.get_deploy_client("databricks")
client.create_endpoint(
name="anthropic-completions-endpoint",
config={
"served_entities": [
{
"name": "claude-completions",
"external_model": {
"name": "claude-2",
"provider": "anthropic",
"task": "llm/v1/completions",
"anthropic_config": {
"anthropic_api_key": "{{secrets/my_anthropic_secret_scope/anthropic_api_key}}"
},
},
}
],
},
)
Comparez les réponses de chaque Endpoint
Étant donné que tous les Endpoint de modèles externes exposent une API compatible avec OpenAI, vous pouvez interroger les deux Endpoint avec le même client OpenAI en remplaçant le model parameter par le nom d'Endpoint correspondant.
import os
from openai import OpenAI
client = OpenAI(
api_key=os.environ.get("DATABRICKS_TOKEN"),
base_url="https://<workspace-name>.cloud.databricks.com/serving-endpoints"
)
prompt = "How is Pi calculated? Be very concise."
openai_response = client.completions.create(
model="openai-completions-endpoint",
prompt=prompt,
)
anthropic_response = client.completions.create(
model="anthropic-completions-endpoint",
prompt=prompt,
)
print("OpenAI:", openai_response.choices[0].text)
print("Anthropic:", anthropic_response.choices[0].text)