Tutoriel : créer des points de terminaison de modèle externe pour interroger des modèles OpenAI

Cette page fournit des instructions pas à pas pour configurer et interroger un point de terminaison externe qui héberge des modèles OpenAI pour les complétions, le chat et les plongements. Vous créez le point de terminaison avec le Kit de développement logiciel (SDK) MLflow Deployments et interrogez-le avec le client OpenAI. Pour plus d’informations, consultez les modèles externes.

Une fois que vous avez créé un point de terminaison, Databricks recommande de configurer Unity AI Gateway sur celui-ci pour 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 Service sont interrogés à l’aide de l’API compatible OpenAI, ce qui vous permet d’utiliser un seul client entre les fournisseurs. Consultez Unity AI Gateway.

Si vous préférez utiliser l’interface utilisateur de service pour accomplir cette tâche, consultez Créer un point de terminaison externe de mise en service de modèle.

Spécifications

• Databricks Runtime 13.0 ML ou version ultérieure.
• MLflow 2.9 ou version ultérieure.
• Clés API OpenAI.
• Installez Databricks CLI version 0.205 ou ultérieure.

(Facultatif) Étape 0 : Stocker la clé API OpenAI à l’aide de l’interface CLI Databricks Secrets

Vous pouvez fournir vos clés API en tant que chaînes de texte en clair à l’étape 3 ou à l’aide d’Azure Databricks Secrets.

Pour stocker la clé API OpenAI en tant que secret, vous pouvez utiliser l’interface CLI Databricks Secrets (version 0.205 ou ultérieure). Vous pouvez également utiliser l’API REST pour les secrets.

Le code suivant crée l’étendue de secret nommée, my_openai_secret_scope, et crée ensuite le secret openai_api_key dans cette étendue.

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 point de terminaison de modèle externe

Pour créer un point de terminaison de modèle externe pour un grand modèle de langage (LLM), utilisez la méthode create_endpoint() du Kit de développement logiciel (SDK) MLflow Deployments. Vous pouvez également créer des points de terminaison de modèle externe dans l’interface utilisateur de mise en service.

L’extrait de code suivant crée un point de terminaison d’achèvement pour OpenAI gpt-3.5-turbo-instruct, comme spécifié dans la section served_entities de la configuration. Pour votre point de terminaison, veillez à remplir name et openai_api_key par 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 sous forme de chaîne de caractères en clair, comme une méthode alternative pour créer le même point de terminaison d'achèvement qu'indiqué 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 du point de terminaison 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 le point de terminaison, utilisez Unity AI Gateway. La configuration des limites de débit via Unity AI Gateway prend en charge les limites basées sur les requêtes (QPM) et les limites de jeton (TPM) et vous permet de définir des limites par utilisateur, par groupe et à l’échelle du point de terminaison.

Consultez Configurer Unity AI Gateway sur les points de terminaison de diffusion de modèles pour obtenir un exemple de code qui met à jour un point de terminaison afin d’ajouter des limites de débit et d’autres fonctionnalités de Unity AI Gateway.

Étape 3 : Envoyer des requêtes à un point de terminaison de modèle externe

Databricks recommande d’interroger des points de terminaison de modèle externe à l’aide du client OpenAI. Model Service expose une API unifiée compatible OpenAI entre les fournisseurs. Le même code client fonctionne donc si le modèle sous-jacent provient d’OpenAI, de Anthropic, de Cohere, d’Amazon Bedrock, de Google Cloud Vertex AI ou d’un fournisseur personnalisé.

Installez le client OpenAI sur votre calcul :

%pip install openai

Ce qui suit envoie une requête de complétion de chat à un point de terminaison qui expose un modèle de chat OpenAI. Remplacez la valeur base_url par l’URL de votre espace de travail Azure Databricks et fournissez an Azure Databricks jeton d’accès personnel pour api_key. Définissez le model paramètre sur le nom de votre point de terminaison 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étion à un point de terminaison 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 demande d’incorporation à un point de terminaison configuré pour la llm/v1/embeddings tâche, 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 à partir d’un bloc-notes Azure Databricks, vous pouvez utiliser l’assistance databricks-openai, qui configure automatiquement l’authentification et l’URL de base de l’espace de travail. Pour plus d’informations, consultez Utiliser des modèles de base .

Étape 4 : Comparer 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 bien d’autres encore. Vous pouvez comparer les LLM entre les fournisseurs, ce qui vous permet d’optimiser l’exactitude, la vitesse et le coût de vos applications à l’aide du Terrain de jeu IA.

L’exemple suivant crée un point de terminaison 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 point de terminaison 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}}"
                    },
                },
            }
        ],
    },
)

Comparer les réponses de chaque point de terminaison

Étant donné que tous les points de terminaison de modèle externe exposent une API compatible OpenAI, vous pouvez interroger les deux points de terminaison avec le même client OpenAI en basculant le model paramètre vers le nom de point de terminaison 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)

Ressources supplémentaires

• Modèles externes dans Service de modèle
• Unity AI Gateway
• Configurer Unity AI Gateway sur les points de terminaison de service de modèle
• Utiliser des modèles de base