Zelfstudie: Externe modeleindpunten maken om query's uit te voeren op OpenAI-modellen

Deze pagina bevat stapsgewijze instructies voor het configureren en opvragen van een extern modeleindpunt dat OpenAI-modellen dient voor voltooiingen, chatten en insluiten. U maakt het eindpunt met de MLflow Deployments SDK en doorzoekt het met de OpenAI-client. Zie externe modellen voor meer informatie.

Nadat u een endpoint hebt gemaakt, raadt Databricks aan om er Unity AI Gateway voor te configureren om governancefunctionaliteit toe te voegen, zoals gebruiksregistratie, payloadregistratie, beveiligingsmaatregelen en ratelimieten. Alle externe modellen die worden geleverd via Model Serving, worden opgevraagd met behulp van de OpenAI-compatibele API, zodat u één client kunt gebruiken tussen providers. Zie Unity AI Gateway.

Als u de gebruikersinterface voor het bedienen verkiest voor deze taak, zie Een extern model-serveer-eindpunt maken.

Vereisten

• Databricks Runtime 13.0 ML of hoger.
• MLflow 2.9 of hoger.
• OpenAI API-sleutels.
• Installeer de Databricks CLI versie 0.205 of hoger.

(Optioneel) Stap 0: de OpenAI API-sleutel opslaan met behulp van de Databricks Secrets CLI

U kunt uw API-sleutels opgeven als tekenreeksen zonder opmaak in stap 3 of met behulp van Azure Databricks Secrets.

Als u de OpenAI API-sleutel als geheim wilt opslaan, kunt u de Databricks Secrets CLI (versie 0.205 en hoger) gebruiken. U kunt ook de REST API gebruiken voor geheimen.

Met het volgende maakt u het geheime bereik met de naam my_openai_secret_scopeen maakt u vervolgens het geheim openai_api_key in dat bereik.

databricks secrets create-scope my_openai_secret_scope
databricks secrets put-secret my_openai_secret_scope openai_api_key

Stap 1: MLflow installeren met ondersteuning voor externe modellen

Gebruik het volgende om een MLflow-versie te installeren met ondersteuning voor externe modellen:

%pip install mlflow[genai]>=2.9.0

Stap 2: Een extern modeleindpunt maken en beheren

Als u een extern modeleindpunt voor een LLM (Large Language Model) wilt maken, gebruikt u de create_endpoint() methode van de MLflow Deployments SDK. U kunt ook externe modeleindpunten maken in de serveerinterface.

Met het volgende codefragment wordt een eindpunt voor voltooiing voor OpenAI gpt-3.5-turbo-instructgemaakt, zoals opgegeven in de served_entities sectie van de configuratie. Zorg ervoor dat u voor uw eindpunt zowel name als openai_api_key vult met uw unieke waarden voor elk veld.

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

In het volgende codefragment ziet u hoe u uw OpenAI API-sleutel kunt opgeven als een tekenreeks zonder opmaak voor een alternatieve manier om hetzelfde voltooiingseindpunt te maken als hierboven.

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

Als u Azure OpenAI gebruikt, kunt u ook de azure OpenAI-implementatienaam, eindpunt-URL en API-versie opgeven in de openai_config sectie van de configuratie.

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

Gebruik Unity AI Gateway om frequentielimieten, gebruikstracering, logboekregistratie van nettoladingen of kaders op het eindpunt te configureren. Het configureren van frequentielimieten via Unity AI Gateway ondersteunt zowel op query's gebaseerde (QPM) als TPM-limieten (op basis van tokens) en stelt u in staat om limieten per gebruiker, per groep en eindpuntbrede limieten in te stellen.

Zie Unity AI Gateway configureren op model dat eindpunten bedient voor een programmatisch voorbeeld waarmee een eindpunt wordt bijgewerkt om frequentielimieten en andere Unity AI Gateway-functies toe te voegen.

Stap 3: Aanvragen verzenden naar een eindpunt van een extern model

Databricks raadt aan om query's uit te voeren op eindpunten van externe modellen met behulp van de OpenAI-client. Model Serving biedt een geïntegreerde, openAI-compatibele API voor verschillende providers. Dezelfde clientcode werkt dus of het onderliggende model afkomstig is van OpenAI, Anthropic, Cohere, Amazon Bedrock, Google Cloud Vertex AI of een aangepaste provider.

Installeer de OpenAI-client op uw rekenproces:

%pip install openai

Hieronder wordt een aanvraag voor het voltooien van een chat verzonden naar een eindpunt dat een OpenAI-chatmodel dient. Vervang de base_url-waarde door de URL van uw Azure Databricks werkruimte en geef an Azure Databricks persoonlijk toegangstoken op voor api_key. Stel de parameter model in op de naam van uw modelserving-eindpunt.

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)

Als u een voltooiingsaanvraag wilt verzenden naar een eindpunt dat voor de llm/v1/completions taak is geconfigureerd, gebruikt u 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)

Als u een insluitingsaanvraag wilt verzenden naar een eindpunt dat is geconfigureerd voor de llm/v1/embeddings taak, gebruikt u client.embeddings.create():

response = client.embeddings.create(
    model="openai-embeddings-endpoint",
    input="Databricks is a unified analytics platform.",
)
print(response.data[0].embedding)

Als u de OpenAI-client uitvoert vanuit een Azure Databricks notebook, kunt u de helper databricks-openai gebruiken, waarmee verificatie en de basis-URL van de werkruimte automatisch worden geconfigureerd. Zie Basismodellen gebruiken voor meer informatie.

Stap 4: Modellen van een andere provider vergelijken

Modelservice ondersteunt veel externe modelproviders, waaronder Open AI, Antropic, Cohere, Amazon Bedrock, Google Cloud Vertex AI en meer. U kunt LLM's vergelijken tussen providers, zodat u de nauwkeurigheid, snelheid en kosten van uw toepassingen kunt optimaliseren met behulp van de AI Playground.

In het volgende voorbeeld wordt een eindpunt voor antropisch claude-2 gemaakt en wordt het antwoord ervan vergeleken met een vraag die Gebruikmaakt van OpenAI gpt-3.5-turbo-instruct. Beide antwoorden hebben dezelfde standaardindeling, waardoor ze eenvoudig te vergelijken zijn.

Een eindpunt maken voor Antropische 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}}"
                    },
                },
            }
        ],
    },
)

De antwoorden van elk eindpunt vergelijken

Omdat alle eindpunten van het externe model een openAI-compatibele API beschikbaar maken, kunt u beide eindpunten opvragen met dezelfde OpenAI-client door de model parameter over te schakelen naar de bijbehorende eindpuntnaam.

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)

Aanvullende bronnen

• Externe modellen in Model Serving
• Unity AI Gateway
• Unity AI Gateway configureren op modelserveerende eindpunten
• Basismodellen gebruiken