Esercitazione: Creare endpoint di modelli esterni per eseguire query sui modelli OpenAI

Questa pagina fornisce istruzioni dettagliate per la configurazione e l'esecuzione di query su un endpoint modello esterno che fornisce modelli OpenAI per completamenti, chat e incorporamenti. Si crea l'endpoint con l'MLflow Deployments SDK e lo si interroga con il client OpenAI. Per altre informazioni, vedere Modelli esterni.

Dopo aver creato un endpoint, Databricks consiglia di configurare Unity AI Gateway per l'aggiunta di funzionalità di governance come il rilevamento dell'utilizzo, la registrazione del payload, le protezioni e i limiti di frequenza. Tutti i modelli esterni serviti tramite la gestione dei modelli vengono sottoposti a query usando l'API compatibile con OpenAI, in modo da poter usare un singolo client tra provider. Vedere Gateway di intelligenza artificiale Unity.

Se si preferisce usare l'interfaccia utente di gestione per eseguire questa attività, vedere Creare un endpoint di gestione di un modello esterno.

Requisiti

  • Databricks Runtime 13.0 ML o versione successiva.
  • MLflow 2.9 o versione successiva.
  • Chiavi API OpenAI.
  • Installare il Databricks CLI versione 0.205 o successiva.

(Facoltativo) Passaggio 0: Archiviare la chiave API OpenAI utilizzando il CLI Databricks Secrets

È possibile specificare le chiavi API come stringhe di testo non crittografato nel passaggio 3 o usando i segreti di Azure Databricks.

Per archiviare la chiave API OpenAI come segreto, è possibile usare l'interfaccia della riga di comando dei segreti di Databricks (versione 0.205 e successive). È anche possibile usare l'API REST per i segreti.

Di seguito viene creato l'ambito del segreto denominato , my_openai_secret_scopee quindi viene creato il segreto openai_api_key in tale ambito.

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

Passaggio 1: Installare MLflow con il supporto di modelli esterni

Usare quanto segue per installare una versione MLflow con il supporto dei modelli esterni:

%pip install mlflow[genai]>=2.9.0

Passaggio 2: Creare e gestire un endpoint del modello esterno

Importante

Gli esempi di codice in questa sezione illustrano l'uso di MLflow Deployments CRUD SDK di anteprima pubblica.

Per creare un endpoint modello esterno per un modello linguistico di grandi dimensioni, usare il create_endpoint() metodo di MLflow Deployments SDK. È anche possibile creare endpoint del modello esterno nell'interfaccia utente di gestione.

Il frammento di codice seguente crea un endpoint di completamento per OpenAI gpt-3.5-turbo-instruct, come specificato nella served_entities sezione della configurazione. Assicurati di popolare il tuo endpoint con name e openai_api_key utilizzando i tuoi valori univoci per ogni campo.

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

Il frammento di codice seguente illustra come specificare la chiave API OpenAI come stringa di testo non crittografato per creare lo stesso endpoint di completamenti riportato in precedenza.

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

Se si usa Azure OpenAI, è anche possibile specificare il nome della distribuzione, l'URL dell'endpoint e la openai_config versione dell'API di Azure OpenAI nella sezione della configurazione.

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

Per configurare limiti di frequenza, rilevamento dell'utilizzo, registrazione del payload o guardrail nell'endpoint, usare Unity AI Gateway. La configurazione dei limiti di frequenza tramite Unity AI Gateway supporta sia limiti basati su query (QPM) sia limiti basati su token (TPM) e consente di impostare limiti per utente, per gruppo e a livello di endpoint.

Vedere Configurare Unity AI Gateway sugli endpoint di serving del modello per un esempio di codice che aggiorna un endpoint per aggiungere limiti di velocità e altre funzionalità di Unity AI Gateway.

Note

Il pattern precedentemente documentato client.update_endpoint() con un campo rate_limits di primo livello è deprecato. Usare invece la configurazione del gateway di intelligenza artificiale Unity nell'endpoint.

Passaggio 3: Inviare richieste a un endpoint del modello esterno

Databricks consiglia di eseguire query sugli endpoint del modello esterno usando il client OpenAI. Model Serving espone un'API unificata compatibile con OpenAI tra provider, quindi lo stesso codice client funziona se il modello sottostante proviene da OpenAI, Anthropic, Cohere, Amazon Bedrock, Google Cloud Vertex AI o un provider personalizzato.

Installa il client OpenAI sul tuo ambiente di calcolo:

%pip install openai

Di seguito viene inviata una richiesta di completamento della chat a un endpoint che serve un modello di chat OpenAI. Sostituire il valore base_url con l'URL dell'area di lavoro Azure Databricks e specificare an Azure Databricks token di accesso personale per api_key. Impostare il model parametro sul nome dell'endpoint di gestione del modello.

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)

Per inviare una richiesta di completamento a un endpoint configurato per l'attività llm/v1/completions , usare 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)

Per inviare una richiesta di incorporamento a un endpoint configurato per l'attività llm/v1/embeddings , usare client.embeddings.create():

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

Se si esegue il client OpenAI dall'interno di un notebook Azure Databricks, è possibile usare l'helper databricks-openai, che configura automaticamente l'autenticazione e l'URL di base dell'area di lavoro. Per informazioni dettagliate, vedere Usare i modelli di base .

Passaggio 4: Confrontare i modelli da un provider diverso

La gestione dei modelli supporta molti provider di modelli esterni, tra cui Open AI, Anthropic, Cohere, Amazon Bedrock, Google Cloud Vertex AI e altro ancora. È possibile confrontare LLM tra provider, consentendo di ottimizzare l'accuratezza, la velocità e i costi delle applicazioni usando AI Playground.

Nell'esempio seguente viene creato un endpoint per Anthropic claude-2 e viene confrontata la risposta a una domanda che usa OpenAI gpt-3.5-turbo-instruct. Entrambe le risposte hanno lo stesso formato standard, che li rende facili da confrontare.

Creare un endpoint per 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}}"
                    },
                },
            }
        ],
    },
)

Confrontare le risposte da ogni endpoint

Poiché tutti gli endpoint del modello esterno espongono un'API compatibile con OpenAI, è possibile eseguire query su entrambi gli endpoint con lo stesso client OpenAI passando il model parametro al nome dell'endpoint corrispondente.

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)

Risorse aggiuntive

  • Last updated on