Självstudie: Skapa externa modellslutpunkter för att anropa OpenAI-modeller

Den här sidan innehåller stegvisa instruktioner för att konfigurera och fråga en extern modellslutpunkt som hanterar OpenAI-modeller för slutföranden, chatt och inbäddningar. Du skapar slutpunkten med MLflow Deployments SDK och anropar den med OpenAI-klienten. Mer information finns i externa modeller.

När du har skapat en slutpunkt rekommenderar Databricks att du konfigurerar Unity AI Gateway på den för att lägga till styrningsfunktioner som användningsspårning, nyttolastloggning, skyddsräcken och hastighetsbegränsningar. Alla externa modeller som hanteras via modellservering efterfrågas med hjälp av OpenAI-kompatibelt API, så att du kan använda en enda klient mellan leverantörer. Se Unity AI Gateway.

Om du föredrar att använda användargränssnittet för servering för att utföra den här uppgiften kan du läsa Skapa en extern modell som betjänar slutpunkten.

Krav

• Databricks Runtime 13.0 ML eller senare.
• MLflow 2.9 eller senare.
• OpenAI API-nycklar.
• Installera Databricks CLI version 0.205 eller senare.

(Valfritt) Steg 0: Lagra OpenAI API-nyckeln med hjälp av Databricks Secrets CLI

Du kan ange dina API-nycklar antingen som klartextsträngar i steg 3 eller med hjälp av Azure Databricks-hemligheter.

Om du vill lagra OpenAI API-nyckeln som en hemlighet kan du använda Databricks Secrets CLI (version 0.205 och senare). Du kan också använda REST-API:et för hemligheter.

Följande skapar det hemliga omfånget med my_openai_secret_scopenamnet , och skapar sedan hemligheten openai_api_key i det omfånget.

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

Steg 1: Installera MLflow med stöd för externa modeller

Använd följande för att installera en MLflow-version med stöd för externa modeller:

%pip install mlflow[genai]>=2.9.0

Steg 2: Skapa och hantera en extern modellslutpunkt

Om du vill skapa en extern modellslutpunkt för en stor språkmodell (LLM) använder du create_endpoint() metoden från MLflow Deployments SDK. Du kan också skapa externa modellslutpunkter i användargränssnittet för servering.

Följande kodfragment skapar en slutpunkt för kompletteringar för OpenAI gpt-3.5-turbo-instruct, som anges i avsnittet served_entities i konfigurationen. För slutpunkten måste du fylla i name och openai_api_key med dina unika värden för varje fält.

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

Följande kodfragment visar hur du kan ange din OpenAI API-nyckel som en klartextsträng för ett alternativt sätt att skapa samma slutpunkt för slutföranden som ovan.

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

Om du använder Azure OpenAI kan du också ange Azure OpenAI-distributionsnamnet, slutpunkts-URL:en och API-versionen i avsnittet i openai_config konfigurationen.

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

Om du vill konfigurera hastighetsbegränsningar, användningsspårning, nyttolastloggning eller skyddsräcken på slutpunkten använder du Unity AI Gateway. Om du konfigurerar hastighetsgränser via Unity AI Gateway stöds både frågebaserade gränser (QPM) och tokenbaserade (TPM) och du kan ange gränser per användare, per grupp och slutpunktsomfattande.

Se Konfigurera Unity AI Gateway på modellserverslutpunkter för ett programmatiskt exempel som uppdaterar en slutpunkt för att lägga till hastighetsbegränsningar och andra Unity AI Gateway-funktioner.

Steg 3: Skicka begäranden till en extern modellslutpunkt

Databricks rekommenderar att du frågar efter externa modellslutpunkter med hjälp av OpenAI-klienten. Model Serving exponerar ett enhetligt, OpenAI-kompatibelt API mellan leverantörer, så samma klientkod fungerar oavsett om den underliggande modellen kommer från OpenAI, Anthropic, Cohere, Amazon Bedrock, Google Cloud Vertex AI eller en anpassad provider.

Installera OpenAI-klienten på din beräkning:

%pip install openai

Följande skickar en begäran om att chatten ska slutföras till en slutpunkt som hanterar en OpenAI-chattmodell. Ersätt värdet base_url med url:en för din Azure Databricks arbetsyta och ange an Azure Databricks personlig åtkomsttoken för api_key. Ange parametern model till namnet på din modell som betjänar slutpunkten.

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)

Om du vill skicka en slutförandebegäran till en slutpunkt som konfigurerats för llm/v1/completions uppgiften använder du 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)

Om du vill skicka en inbäddningsbegäran till en slutpunkt som konfigurerats för llm/v1/embeddings uppgiften använder du client.embeddings.create():

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

Om du kör OpenAI-klienten inifrån en Azure Databricks notebook-fil kan du använda hjälpverktyget databricks-openai, som automatiskt konfigurerar autentisering och arbetsytans bas-URL. Mer information finns i Använda grundmodeller .

Steg 4: Jämför modeller från en annan leverantör

Modelltjänster stöder många externa modellleverantörer, inklusive Open AI, Anthropic, Cohere, Amazon Bedrock, Google Cloud Vertex AI med mera. Du kan jämföra LLM:er mellan leverantörer, vilket hjälper dig att optimera noggrannheten, hastigheten och kostnaden för dina program med hjälp av AI Playground.

I följande exempel skapas en slutpunkt för Anthropic claude-2 och dess svar jämförs med en fråga som använder OpenAI gpt-3.5-turbo-instruct. Båda svaren har samma standardformat, vilket gör dem enkla att jämföra.

Skapa en slutpunkt för 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}}"
                    },
                },
            }
        ],
    },
)

Jämför svaren från varje slutpunkt

Eftersom alla externa modellslutpunkter exponerar ett OpenAI-kompatibelt API kan du fråga båda slutpunkterna med samma OpenAI-klient genom att växla parametern model till motsvarande slutpunktsnamn.

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)

Ytterligare resurser

• Externa modeller i Model Serving
• Unity AI Gateway
• Konfigurera Unity AI Gateway på slutpunkter för modellbetjäning
• Använda grundmodeller