Nota
O acesso a esta página requer autorização. Pode tentar iniciar sessão ou alterar os diretórios.
O acesso a esta página requer autorização. Pode tentar alterar os diretórios.
Esta página fornece instruções passo a passo para configurar e consultar um endpoint de modelo externo que serve modelos OpenAI para completamentos, chat e embeddings. Cria o endpoint com o MLflow Deployments SDK e consulta-o com o cliente OpenAI. Para mais informações, consulte modelos externos.
Depois de criar um endpoint, a Databricks recomenda configurar o Unity AI Gateway nele para adicionar funcionalidades de governação como rastreamento de uso, registo de payloads, proteções e limites de taxa. Todos os modelos externos servidos através do Model Serving são consultados através da API compatível com OpenAI, pelo que pode usar um único cliente entre fornecedores. Ver Unity AI Gateway.
Se preferir usar a UI de Serviço para realizar esta tarefa, consulte Criar um endpoint de serviço do modelo externo.
Requisitos
- Databricks Runtime 13.0 ML ou superior.
- MLflow 2.9 ou superior.
- Chaves de API OpenAI.
- Instale o Databricks CLI versão 0.205 ou superior.
(Opcional) Etapa 0: Armazenar a chave da API OpenAI usando a CLI Databricks Secrets
Você pode fornecer suas chaves de API como cadeias de caracteres de texto sem formatação na Etapa 3 ou usando os Segredos do Azure Databricks.
Para armazenar a chave da API OpenAI como um segredo, você pode usar a CLI Databricks Secrets (versão 0.205 e superior). Você também pode usar a API REST para segredos.
O seguinte cria o escopo secreto chamado my_openai_secret_scope e, em seguida, cria o segredo openai_api_key nesse escopo.
databricks secrets create-scope my_openai_secret_scope
databricks secrets put-secret my_openai_secret_scope openai_api_key
Etapa 1: Instalar o MLflow com suporte a modelos externos
Use o seguinte para instalar uma versão MLflow com suporte a modelos externos:
%pip install mlflow[genai]>=2.9.0
Etapa 2: Criar e gerenciar um ponto de extremidade de modelo externo
Importante
Os exemplos de código nesta seção demonstram a utilização do SDK CRUD de implantações MLflow na versão Public Preview.
Para criar um ponto de extremidade de modelo externo para um modelo de linguagem grande (LLM), use o método create_endpoint() do SDK de implementações MLflow. Você também pode criar pontos de extremidade de modelo externos na interface de serviço.
O trecho de código a seguir cria um ponto de extremidade de conclusão para o OpenAI gpt-3.5-turbo-instruct, conforme especificado na served_entities seção da configuração. Para o seu ponto final, assegure-se de preencher o name e openai_api_key com os seus valores exclusivos para cada 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}}"
}
}
}]
}
)
O seguinte trecho de código mostra como podes fornecer a tua chave de API OpenAI como uma string de texto simples para uma forma alternativa de criar o mesmo endpoint de preenchimento como acima.
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 estiver a usar o Azure OpenAI, também poderá especificar o nome da implementação do Azure OpenAI, a URL do ponto de extremidade e a versão da API na seção openai_config da configuração.
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"
},
},
}
],
},
)
Para configurar limites de pedidos, monitorização da utilização, registo de payloads ou proteções no endpoint, use o Unity AI Gateway. Configurar limites de taxa através do Unity AI Gateway suporta tanto limites baseados em consultas (QPM) como baseados em tokens (TPM) e permite-lhe definir limites por utilizador, por grupo e em todo o endpoint.
Consulte Configurar o Unity AI Gateway nos endpoints de disponibilização de modelos para ver um exemplo programático que atualiza um endpoint para adicionar limites de taxa e outras funcionalidades do Unity AI Gateway.
Note
O padrão anteriormente documentado client.update_endpoint() com um campo rate_limits de nível superior foi descontinuado. Use antes a configuração do Unity AI Gateway no endpoint.
Etapa 3: Enviar solicitações para um ponto de extremidade de modelo externo
A Databricks recomenda consultar endpoints de modelos externos usando o cliente OpenAI. O Model Serving expõe uma API unificada e compatível com OpenAI entre os fornecedores, pelo que o mesmo código cliente funciona, quer o modelo subjacente seja da OpenAI, Anthropic, Cohere, Amazon Bedrock, Google Cloud Vertex AI ou um fornecedor personalizado.
Instale o cliente OpenAI no seu computador:
%pip install openai
O seguinte envia um pedido de conclusão de chat para um endpoint que serve um modelo de chat OpenAI. Substitua o valor base_url pelo URL do seu espaço de trabalho do Azure Databricks e forneça um token de acesso pessoal do Azure Databricks para api_key. Defina o parâmetro model como o nome do endpoint de disponibilização do modelo.
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)
Para enviar um pedido de completação para um endpoint configurado para a llm/v1/completions tarefa, utilize 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)
Para enviar um pedido de embeddings para um endpoint configurado para a tarefa llm/v1/embeddings, use client.embeddings.create():
response = client.embeddings.create(
model="openai-embeddings-endpoint",
input="Databricks is a unified analytics platform.",
)
print(response.data[0].embedding)
Se executares o cliente OpenAI a partir de um Azure Databricks notebook, podes usar o helper databricks-openai, que configura automaticamente a autenticação e a URL base do workspace. Consulte Utilizar modelos de fundação para mais detalhes.
Etapa 4: Comparar modelos de um provedor diferente
O serviço de modelos suporta muitos fornecedores de modelos externos, incluindo Open AI, Anthropic, Cohere, Amazon Bedrock, Google Cloud Vertex AI e muito mais. Você pode comparar LLMs entre provedores, ajudando a otimizar a precisão, a velocidade e o custo de seus aplicativos usando o AI Playground.
O exemplo a seguir cria um ponto de extremidade para Anthropic claude-2 e compara sua resposta a uma pergunta que usa OpenAI gpt-3.5-turbo-instruct. Ambas as respostas têm o mesmo formato padrão, o que as torna fáceis de comparar.
Criar um endpoint para 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}}"
},
},
}
],
},
)
Comparar as respostas de cada ponto de extremidade
Como todos os endpoints de modelos externos expõem uma API compatível com OpenAI, pode consultar ambos os endpoints com o mesmo cliente OpenAI mudando o model parâmetro para o nome do endpoint correspondente.
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)