Partager via

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

  • Article

Cet article fournit des instructions pas à pas pour configurer et interroger un point de terminaison de modèle externe qui sert les modèles OpenAI pour les achèvements, les conversations et les incorporations à l’aide du Kit de développement logiciel (SDK) MLflow Deployments. En savoir plus sur les modèles externes.

Spécifications

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

Étape 1 : stocker la clé API OpenAI à l’aide de l’interface CLI Databricks Secrets

Vous pouvez stocker la clé API OpenAI à l’aide de l’interface CLI Databricks Secrets (version 0.205 et 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 2 : 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 3 : créer et gérer un point de terminaison de modèle externe

Important

Les exemples de code de cette section démontrent l’utilisation de la préversion publique du Kit de développement logiciel (SDK) CRUD MLflow Deployments.

Vous pouvez créer un point de terminaison de modèle externe pour chaque grand modèle de langage (LLM) que vous souhaitez utiliser avec la méthode create_endpoint() du Kit de développement logiciel (SDK) MLflow Deployments. 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.

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}}"
                }
            }
        }]
    }
)

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 mettre à jour un point de terminaison, utilisez update_endpoint(). L’extrait de code suivant montre comment mettre à jour les limites de débit d’un point de terminaison à 20 appels par minute par utilisateur.

client.update_endpoint(
    endpoint="openai-completions-endpoint",
    config={
        "rate_limits": [
            {
                "key": "user",
                "renewal_period": "minute",
                "calls": 20
            }
        ],
    },
)

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

Important

Les exemples de code de cette section démontrent l’utilisation de la méthode predict() du SDK MLflow Deployments.

Vous pouvez envoyer des demandes de conversation, d’achèvement et d’intégration à un point de terminaison de modèle externe à l’aide de la méthode predict() du SDK MLflow Deployments.

Le code suivant envoie une requête à gpt-3.5-turbo-instruct hébergé par OpenAI.

completions_response = client.predict(
    endpoint="openai-completions-endpoint",
    inputs={
        "prompt": "What is the capital of France?",
        "temperature": 0.1,
        "max_tokens": 10,
        "n": 2
    }
)
completions_response == {
    "id": "cmpl-8QW0hdtUesKmhB3a1Vel6X25j2MDJ",
    "object": "text_completion",
    "created": 1701330267,
    "model": "gpt-3.5-turbo-instruct",
    "choices": [
        {
            "text": "The capital of France is Paris.",
            "index": 0,
            "finish_reason": "stop",
            "logprobs": None
        },
        {
            "text": "Paris is the capital of France",
            "index": 1,
            "finish_reason": "stop",
            "logprobs": None
        },
    ],
    "usage": {
        "prompt_tokens": 7,
        "completion_tokens": 16,
        "total_tokens": 23
    }
}

Étape 5 : 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


openai_response = client.predict(
    endpoint="openai-completions-endpoint",
    inputs={
        "prompt": "How is Pi calculated? Be very concise."
    }
)
anthropic_response = client.predict(
    endpoint="anthropic-completions-endpoint",
    inputs={
        "prompt": "How is Pi calculated? Be very concise."
    }
)
openai_response["choices"] == [
    {
        "text": "Pi is calculated by dividing the circumference of a circle by its diameter."
                " This constant ratio of 3.14159... is then used to represent the relationship"
                " between a circle's circumference and its diameter, regardless of the size of the"
                " circle.",
        "index": 0,
        "finish_reason": "stop",
        "logprobs": None
    }
]
anthropic_response["choices"] == [
    {
        "text": "Pi is calculated by approximating the ratio of a circle's circumference to"
                " its diameter. Common approximation methods include infinite series, infinite"
                " products, and computing the perimeters of polygons with more and more sides"
                " inscribed in or around a circle.",
        "index": 0,
        "finish_reason": "stop",
        "logprobs": None
    }
]

Ressources supplémentaires

Modèles externes dans la mise en service de modèles Databricks.