Kurz: Vytvoření koncových bodů externího modelu pro dotazování modelů OpenAI

Tato stránka obsahuje podrobné pokyny ke konfiguraci a dotazování koncového bodu externího modelu, který slouží modelům OpenAI k dokončení, chatu a vkládání. Koncový bod vytvoříte pomocí sady SDK pro nasazení MLflow a dotazujete ho pomocí klienta OpenAI. Další informace najdete v externích modelech.

Po vytvoření koncového bodu doporučuje Databricks nakonfigurovat bránu Unity AI, aby přidala funkce zásad správného řízení, jako je sledování využití, protokolování datové části, mantinely a omezení rychlosti. Všechny externí modely obsluhované prostřednictvím obsluhy modelů se dotazují pomocí rozhraní API kompatibilního s OpenAI, takže můžete použít jednoho klienta napříč poskytovateli. Viz zásady správného řízení AI pomocí brány Unity AI.

Tip

Řekněte Genie Code (režim agenta), aby to udělal za vás:

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.

Pokud chcete k provedení této úlohy použít uživatelské rozhraní obsluhy, přečtěte si téma Vytvoření externího modelu obsluhující koncový bod.

Požadavky

(Volitelné) Krok 0: Uložte klíč API OpenAI pomocí CLI pro správu tajných kódů Databricks

Klíče rozhraní API můžete zadat buď jako řetězce prostého textu v kroku 3, nebo pomocí tajných kódů Azure Databricks.

Pokud chcete klíč rozhraní API OpenAI uložit jako tajný klíč, můžete použít Rozhraní příkazového řádku pro tajné kódy Databricks (verze 0.205 a vyšší). Rozhraní REST API můžete také použít pro tajné kódy.

Následující kód vytvoří obor tajného kódu s názvem my_openai_secret_scopea pak v tomto oboru vytvoří tajný klíč openai_api_key .

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

Krok 1: Instalace MLflow s podporou externích modelů

K instalaci verze MLflow s podporou externích modelů použijte následující:

%pip install mlflow[genai]>=2.9.0

Krok 2: Vytvoření a správa koncového bodu externího modelu

Important

Příklady kódu v této části demonstrují použití MLflow Deployments CRUD SDK ve verzi Public Preview.

Pokud chcete vytvořit koncový bod externího modelu pro rozsáhlý jazykový model (LLM), použijte create_endpoint() metodu ze sady SDK pro nasazení MLflow. V uživatelském rozhraní obsluhy můžete také vytvořit koncové body externího modelu.

Následující fragment kódu vytvoří koncový bod dokončení pro OpenAI gpt-3.5-turbo-instruct, jak je uvedeno v served_entities části konfigurace. V případě koncového bodu nezapomeňte vyplnit name a openai_api_key jedinečnými hodnotami pro každé pole.

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

Následující fragment kódu ukazuje, jak můžete zadat klíč rozhraní OpenAI API jako řetězec prostého textu pro alternativní způsob vytvoření stejného koncového bodu dokončení jako výše.

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

Pokud používáte Azure OpenAI, můžete také zadat název nasazení Azure OpenAI, adresu URL koncového bodu a verzi rozhraní API v openai_config části konfigurace.

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

Ke konfiguraci omezení rychlosti, sledování využití, protokolování datové části nebo ochranných pravidel pro koncový bod použijte Unity AI Gateway. Konfigurace omezení rychlosti prostřednictvím služby Unity AI Gateway podporuje limity založené na dotazech (QPM) i čip TPM (tokeny) a umožňuje nastavit limity pro jednotlivé uživatele, skupiny a koncové body.

Viz Konfigurace brány AI na modelu obsluhující koncové body pro programový příklad, který aktualizuje koncový bod, aby přidal limity rychlosti a další funkce brány Unity AI.

Note

Dříve zdokumentovaný client.update_endpoint() vzor s polem nejvyšší úrovně rate_limits je zastaralý. Místo toho použijte konfiguraci Unity AI Gateway na koncovém bodu.

Krok 3: Odeslání požadavků do koncového bodu externího modelu

Databricks doporučuje dotazování koncových bodů externího modelu pomocí klienta OpenAI. Obsluha modelů zpřístupňuje jednotné rozhraní API kompatibilní s OpenAI napříč poskytovateli, takže stejný kód klienta funguje bez ohledu na to, jestli je podkladový model od OpenAI, Anthropic, Cohere, Amazon Bedrock, Google Cloud Vertex AI nebo vlastního poskytovatele.

Nainstalujte do výpočetních prostředků klienta OpenAI:

%pip install openai

Následující příkaz odešle žádost o dokončení chatu do koncového bodu, který obsluhuje model chatu OpenAI. Nahraďte hodnotu base_url adresou URL pracovního prostoru Azure Databricks a zadejte pro api_key. model Nastavte parametr na název koncového bodu obsluhujícího model.

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)

Pokud chcete odeslat žádost o dokončení do koncového bodu nakonfigurovaného pro llm/v1/completions úkol, použijte 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)

Pokud chcete odeslat požadavek na vložení do koncového bodu nakonfigurovaného pro llm/v1/embeddings úlohu, použijte client.embeddings.create():

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

Pokud spustíte klienta OpenAI z poznámkového bloku Azure Databricks, můžete použít pomocníka databricks-openai, který automaticky nakonfiguruje ověřování a základní adresu URL pracovního prostoru. Podrobnosti najdete v tématu Použití základních modelů .

Krok 4: Porovnání modelů od jiného poskytovatele

Obsluha modelů podporuje mnoho externích poskytovatelů modelů, včetně Open AI, Anthropic, Cohere, Amazon Bedrock, Google Cloud Vertex AI a dalších. Pomocí AI Playground můžete porovnat LLM napříč poskytovateli a optimalizovat přesnost, rychlost a náklady na aplikace.

Následující příklad vytvoří koncový bod pro Anthropic claude-2 a porovná jeho odpověď na otázku, která používá OpenAI gpt-3.5-turbo-instruct. Obě odpovědi mají stejný standardní formát, což usnadňuje jejich porovnání.

Vytvoření koncového bodu pro 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}}"
                    },
                },
            }
        ],
    },
)

Porovnání odpovědí z každého koncového bodu

Vzhledem k tomu, že všechny koncové body externího modelu zpřístupňují rozhraní API kompatibilní s OpenAI, můžete oba koncové body dotazovat pomocí stejného klienta OpenAI přepnutím model parametru na odpovídající název koncového bodu.

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)

Dodatečné zdroje

  • Last updated on