Partilhar via

Modelos de base de consulta

  • Artigo

Neste artigo, você aprenderá a formatar solicitações de consulta para modelos de base e enviá-las para seu ponto de extremidade de serviço de modelo.

Para solicitações de consulta de modelos tradicionais de ML ou Python, consulte Pontos de extremidade de serviço de consulta para modelos personalizados.

O Databricks Model Serving suporta APIs de modelos de base e modelos externos para acessar modelos de base e usa uma API e SDK unificadas compatíveis com OpenAI para consultá-los. Isso torna possível experimentar e personalizar modelos básicos para produção em nuvens e provedores suportados.

O Databricks Model Serving fornece as seguintes opções para enviar solicitações de pontuação para modelos de base:

Método Detalhes
Cliente OpenAI Consulte um modelo hospedado por um ponto de extremidade Databricks Model Serving usando o cliente OpenAI. Especifique o modelo que serve o nome do ponto de extremidade como a model entrada. Suportado para modelos de chat, incorporações e conclusão disponibilizados por APIs de Modelo de Base ou modelos externos.
Servindo a interface do usuário Selecione Consultar ponto de extremidade na página Ponto de extremidade de serviço. Insira os dados de entrada do modelo no formato JSON e clique em Enviar solicitação. Se o modelo tiver um exemplo de entrada registrado, use Mostrar exemplo para carregá-lo.
API REST Chame e consulte o modelo usando a API REST. Consulte POST /serving-endpoints/{name}/invocations para obter detalhes. Para marcar solicitações para pontos de extremidade que atendem a vários modelos, consulte Consultar modelos individuais atrás de um ponto de extremidade.
SDK de implantações MLflow Use a função predict() do MLflow Deployments SDK para consultar o modelo.
Databricks GenAI SDK O Databricks GenAI SDK é uma camada sobre a API REST. Ele lida com detalhes de baixo nível, como autenticação e mapeamento de IDs de modelo para URLs de ponto final, facilitando a interação com os modelos. O SDK foi projetado para ser usado de dentro de notebooks Databricks.
Função SQL Invoque a inferência do modelo diretamente do SQL usando a ai_query função SQL. Consulte Consultar um modelo servido com ai_query().

Requerimentos

Importante

Como prática recomendada de segurança para cenários de produção, o Databricks recomenda que você use tokens OAuth máquina a máquina para autenticação durante a produção.

Para teste e desenvolvimento, o Databricks recomenda o uso de um token de acesso pessoal pertencente a entidades de serviço em vez de usuários do espaço de trabalho. Para criar tokens para entidades de serviço, consulte Gerenciar tokens para uma entidade de serviço.

Instalar pacotes

Depois de selecionar um método de consulta, você deve primeiro instalar o pacote apropriado no cluster.

Cliente Openai

Para usar o cliente OpenAI, o openai pacote precisa ser instalado em seu cluster. Execute o seguinte no seu bloco de notas ou no seu terminal local:

!pip install openai

O seguinte só é necessário ao instalar o pacote em um Notebook Databricks

dbutils.library.restartPython()

API de descanso

O acesso à API REST de serviço está disponível no Databricks Runtime for Machine Learning.

Mlflow deployments sdk

!pip install mlflow

O seguinte só é necessário ao instalar o pacote em um Notebook Databricks

dbutils.library.restartPython()

Databricks genai sdk

 !pip install databricks-genai

O seguinte só é necessário ao instalar o pacote em um Notebook Databricks

 dbutils.library.restartPython()

Consultar um modelo de conclusão de chat

Seguem-se exemplos para consultar um modelo de chat.

Para obter um exemplo de inferência em lote, consulte Inferência em lote usando APIs de modelo básico.

Cliente Openai

A seguir está uma solicitação de bate-papo para o modelo DBRX Instruct disponibilizado pelo ponto de extremidade de pagamento por token das APIs do Foundation Model, databricks-dbrx-instruct em seu espaço de trabalho.

Para usar o cliente OpenAI, especifique o modelo que serve o nome do ponto de extremidade como entrada model . O exemplo a seguir pressupõe que você tenha um token de API Databricks instalado openai em sua computação. Você também precisa da instância do espaço de trabalho Databricks para conectar o cliente OpenAI ao Databricks.


import os
import openai
from openai import OpenAI

client = OpenAI(
    api_key="dapi-your-databricks-token",
    base_url="https://example.staging.cloud.databricks.com/serving-endpoints"
)

response = client.chat.completions.create(
    model="databricks-dbrx-instruct",
    messages=[
      {
        "role": "system",
        "content": "You are a helpful assistant."
      },
      {
        "role": "user",
        "content": "What is a mixture of experts model?",
      }
    ],
    max_tokens=256
)

API de descanso

Importante

O exemplo a seguir usa parâmetros de API REST para consultar pontos de extremidade de serviço que servem modelos de base. Esses parâmetros são visualização pública e a definição pode mudar. Consulte POST /serving-endpoints/{name}/invocations.

A seguir está uma solicitação de bate-papo para o modelo DBRX Instruct disponibilizado pelo ponto de extremidade de pagamento por token das APIs do Foundation Model, databricks-dbrx-instruct em seu espaço de trabalho.

curl \
-u token:$DATABRICKS_TOKEN \
-X POST \
-H "Content-Type: application/json" \
-d '{
  "messages": [
    {
      "role": "system",
      "content": "You are a helpful assistant."
    },
    {
      "role": "user",
      "content": " What is a mixture of experts model?"
    }
  ]
}' \
https://<workspace_host>.databricks.com/serving-endpoints/databricks-dbrx-instruct/invocations \

Mlflow deployments sdk

Importante

O exemplo a seguir usa a predict() API do MLflow Deployments SDK.

A seguir está uma solicitação de bate-papo para o modelo DBRX Instruct disponibilizado pelo ponto de extremidade de pagamento por token das APIs do Foundation Model, databricks-dbrx-instruct em seu espaço de trabalho.


import mlflow.deployments

# Only required when running this example outside of a Databricks Notebook
export DATABRICKS_HOST="https://<workspace_host>.databricks.com"
export DATABRICKS_TOKEN="dapi-your-databricks-token"

client = mlflow.deployments.get_deploy_client("databricks")

chat_response = client.predict(
    endpoint="databricks-dbrx-instruct",
    inputs={
        "messages": [
            {
              "role": "user",
              "content": "Hello!"
            },
            {
              "role": "assistant",
              "content": "Hello! How can I assist you today?"
            },
            {
              "role": "user",
              "content": "What is a mixture of experts model??"
            }
        ],
        "temperature": 0.1,
        "max_tokens": 20
    }
)

Databricks genai sdk

A seguir está uma solicitação de bate-papo para o modelo DBRX Instruct disponibilizado pelo ponto de extremidade de pagamento por token das APIs do Foundation Model, databricks-dbrx-instruct em seu espaço de trabalho.

from databricks_genai_inference import ChatCompletion

# Only required when running this example outside of a Databricks Notebook
export DATABRICKS_HOST="https://<workspace_host>.databricks.com"
export DATABRICKS_TOKEN="dapi-your-databricks-token"

response = ChatCompletion.create(model="databricks-dbrx-instruct",
                                messages=[{"role": "system", "content": "You are a helpful assistant."},
                                          {"role": "user","content": "What is a mixture of experts model?"}],
                                max_tokens=128)
print(f"response.message:{response.message}")

Langchain

Para consultar um ponto de extremidade de modelo básico usando LangChain, você pode fazer o seguinte:

  • Importe a Databricks classe LLM e especifique o endpoint_name e transform_input_fn.
  • Importe a ChatDatabricks classe ChatModel e especifique o endpointarquivo .

O exemplo a seguir usa a Databricks classe LLM em LangChain para consultar o ponto de extremidade de pagamento por token das APIs do Modelo de Base, databricks-dbrx-instruct. As APIs do Foundation Model esperam no dicionário de messages solicitações, enquanto o LangChain Databricks LLM por padrão fornece prompt no dicionário de solicitações. Use a transform_input função para preparar o dicionário de solicitações no formato esperado.

from langchain.llms import Databricks
from langchain_core.messages import HumanMessage, SystemMessage

def transform_input(**request):
  request["messages"] = [
    {
      "role": "user",
      "content": request["prompt"]
    }
  ]
  del request["prompt"]
  return request

llm = Databricks(endpoint_name="databricks-dbrx-instruct", transform_input_fn=transform_input)
llm("What is a mixture of experts model?")

O exemplo a seguir usa a ChatDatabricks classe ChatModel e especifica o endpoint.

from langchain.chat_models import ChatDatabricks
from langchain_core.messages import HumanMessage, SystemMessage

messages = [
    SystemMessage(content="You're a helpful assistant"),
    HumanMessage(content="What is a mixture of experts model?"),
]
chat_model = ChatDatabricks(endpoint="databricks-dbrx-instruct", max_tokens=500)
chat_model.invoke(messages)

SQL

Importante

O exemplo a seguir usa a função SQL interna, ai_query. Esta função é Public Preview e a definição pode mudar. Consulte Consultar um modelo servido com ai_query().

A seguir está uma solicitação de bate-papo disponibilizada llama-2-70b-chat pelo ponto de extremidade databricks-llama-2-70b-chat de pagamento por token das APIs do Modelo de Fundação em seu espaço de trabalho.

Nota

A ai_query() função não suporta pontos de extremidade de consulta que servem o modelo DBRX ou DBRX Instruct.

SELECT ai_query(
    "databricks-llama-2-70b-chat",
    "Can you explain AI in ten words?"
  )

A seguir está o formato de solicitação esperado para um modelo de chat. Para modelos externos, você pode incluir parâmetros adicionais que são válidos para um determinado provedor e configuração de ponto final. Consulte Parâmetros de consulta adicionais.

{
  "messages": [
    {
      "role": "user",
      "content": "What is a mixture of experts model?"
    }
  ],
  "max_tokens": 100,
  "temperature": 0.1
}

Segue-se um formato de resposta esperado:

{
  "model": "databricks-dbrx-instruct",
  "choices": [
    {
      "message": {},
      "index": 0,
      "finish_reason": null
    }
  ],
  "usage": {
    "prompt_tokens": 7,
    "completion_tokens": 74,
    "total_tokens": 81
  },
  "object": "chat.completion",
  "id": null,
  "created": 1698824353
}

Sessão de chat

O Databricks GenAI SDK fornece ChatSession classe para gerenciar conversas de bate-papo de várias rodadas. Ele fornece as seguintes funções:

Function Devolver Description
reply (string) Leva uma nova mensagem de usuário
last string Última mensagem do assistente
history Lista de ditames Mensagens no histórico de chat, incluindo funções.
count número inteiro Número de rondas de chat realizadas até à data.

Para inicializar ChatSessiono , use o mesmo conjunto de argumentos que ChatCompletiono , e esses argumentos são usados durante toda a sessão de chat.


from databricks_genai_inference import ChatSession

chat = ChatSession(model="llama-2-70b-chat", system_message="You are a helpful assistant.", max_tokens=128)
chat.reply("Knock, knock!")
chat.last # return "Hello! Who's there?"
chat.reply("Guess who!")
chat.last # return "Okay, I'll play along! Is it a person, a place, or a thing?"

chat.history
# return: [
#     {'role': 'system', 'content': 'You are a helpful assistant.'},
#     {'role': 'user', 'content': 'Knock, knock.'},
#     {'role': 'assistant', 'content': "Hello! Who's there?"},
#     {'role': 'user', 'content': 'Guess who!'},
#     {'role': 'assistant', 'content': "Okay, I'll play along! Is it a person, a place, or a thing?"}
# ]

Consultar um modelo de incorporação

A seguir está uma solicitação de incorporação para o bge-large-en modelo disponibilizado pelas APIs do Foundation Model.

Cliente Openai

Para usar o cliente OpenAI, especifique o modelo que serve o nome do ponto de extremidade como entrada model . O exemplo a seguir pressupõe que você tenha um token de API Databricks instalado openai em seu cluster.


import os
import openai
from openai import OpenAI

client = OpenAI(
    api_key="dapi-your-databricks-token",
    base_url="https://example.staging.cloud.databricks.com/serving-endpoints"
)

response = client.embeddings.create(
  model="databricks-bge-large-en",
  input="what is databricks"
)

API de descanso

Importante

O exemplo a seguir usa parâmetros de API REST para consultar pontos de extremidade de serviço que servem modelos de base. Esses parâmetros são visualização pública e a definição pode mudar. Consulte POST /serving-endpoints/{name}/invocations.


curl \
-u token:$DATABRICKS_TOKEN \
-X POST \
-H "Content-Type: application/json" \
-d  '{ "input": "Embed this sentence!"}' \
https://<workspace_host>.databricks.com/serving-endpoints/databricks-bge-large-en/invocations

Mlflow deployments sdk

Importante

O exemplo a seguir usa a predict() API do MLflow Deployments SDK.


import mlflow.deployments

export DATABRICKS_HOST="https://<workspace_host>.databricks.com"
export DATABRICKS_TOKEN="dapi-your-databricks-token"

client = mlflow.deployments.get_deploy_client("databricks")

embeddings_response = client.predict(
    endpoint="databricks-bge-large-en",
    inputs={
        "input": "Here is some text to embed"
    }
)

Databricks genai sdk


from databricks_genai_inference import Embedding

# Only required when running this example outside of a Databricks Notebook
export DATABRICKS_HOST="https://<workspace_host>.databricks.com"
export DATABRICKS_TOKEN="dapi-your-databricks-token"

response = Embedding.create(
    model="bge-large-en",
    input="3D ActionSLAM: wearable person tracking in multi-floor environments")
print(f'embeddings: {response.embeddings}')

Langchain

Para usar um modelo de APIs do Databricks Foundation Model em LangChain como um modelo de incorporação, importe a DatabricksEmbeddings classe e especifique o endpoint parâmetro da seguinte maneira:

from langchain.embeddings import DatabricksEmbeddings

embeddings = DatabricksEmbeddings(endpoint="databricks-bge-large-en")
embeddings.embed_query("Can you explain AI in ten words?")

SQL

Importante

O exemplo a seguir usa a função SQL interna, ai_query. Esta função é Public Preview e a definição pode mudar. Consulte Consultar um modelo servido com ai_query().


SELECT ai_query(
    "databricks-bge-large-en",
    "Can you explain AI in ten words?"
  )

A seguir está o formato de solicitação esperado para um modelo de incorporação. Para modelos externos, você pode incluir parâmetros adicionais que são válidos para um determinado provedor e configuração de ponto final. Consulte Parâmetros de consulta adicionais.


{
  "input": [
    "embedding text"
  ]
}

O seguinte é o formato de resposta esperado:

{
  "object": "list",
  "data": [
    {
      "object": "embedding",
      "index": 0,
      "embedding": []
    }
  ],
  "model": "text-embedding-ada-002-v2",
  "usage": {
    "prompt_tokens": 2,
    "total_tokens": 2
  }
}

Consultar um modelo de conclusão de texto

A seguir está uma solicitação de conclusão para o databricks-mpt-30b-instruct modelo disponibilizado pelas APIs do Foundation Model. Para obter os parâmetros e a sintaxe, consulte Tarefa de conclusão.

Cliente Openai

Para usar o cliente OpenAI, especifique o modelo que serve o nome do ponto de extremidade como entrada model . O exemplo a seguir pressupõe que você tenha um token de API Databricks instalado openai em seu cluster.


import os
import openai
from openai import OpenAI

client = OpenAI(
    api_key="dapi-your-databricks-token",
    base_url="https://example.staging.cloud.databricks.com/serving-endpoints"
)

completion = client.completions.create(
  model="databricks-mpt-30b-instruct",
  prompt="what is databricks",
  temperature=1.0
)

API de descanso

Importante

O exemplo a seguir usa parâmetros de API REST para consultar pontos de extremidade de serviço que servem modelos de base. Esses parâmetros são visualização pública e a definição pode mudar. Consulte POST /serving-endpoints/{name}/invocations.


curl \
 -u token:$DATABRICKS_TOKEN \
 -X POST \
 -H "Content-Type: application/json" \
 -d '{"prompt": "What is a quoll?", "max_tokens": 64}' \
https://<workspace_host>.databricks.com/serving-endpoints/databricks-mpt-30b-instruct/invocations

Mlflow deployments sdk

Importante

O exemplo a seguir usa a predict() API do MLflow Deployments SDK.


import mlflow.deployments

# Only required when running this example outside of a Databricks Notebook
export DATABRICKS_HOST="https://<workspace_host>.databricks.com"
export DATABRICKS_TOKEN="dapi-your-databricks-token"

client = mlflow.deployments.get_deploy_client("databricks")

completions_response = client.predict(
    endpoint="databricks-mpt-30b-instruct",
    inputs={
        "prompt": "What is the capital of France?",
        "temperature": 0.1,
        "max_tokens": 10,
        "n": 2
    }
)

Databricks genai sdk


from databricks_genai_inference import Completion

# Only required when running this example outside of a Databricks Notebook
export DATABRICKS_HOST="https://<workspace_host>.databricks.com"
export DATABRICKS_TOKEN="dapi-your-databricks-token"

response = Completion.create(
    model="databricks-mpt-30b-instruct",
    prompt="Write 3 reasons why you should train an AI model on domain specific data sets.",
    max_tokens=128)
print(f"response.text:{response.text:}")

SQL

Importante

O exemplo a seguir usa a função SQL interna, ai_query. Esta função é Public Preview e a definição pode mudar. Consulte Consultar um modelo servido com ai_query().

SELECT ai_query(
    "databricks-mpt-30b-instruct",
    "Can you explain AI in ten words?"
  )

A seguir está o formato de solicitação esperado para um modelo de conclusão. Para modelos externos, você pode incluir parâmetros adicionais que são válidos para um determinado provedor e configuração de ponto final. Consulte Parâmetros de consulta adicionais.

{
  "prompt": "What is mlflow?",
  "max_tokens": 100,
  "temperature": 0.1,
  "stop": [
    "Human:"
  ],
  "n": 1,
  "stream": false,
  "extra_params":{
    "top_p": 0.9
  }
}

O seguinte é o formato de resposta esperado:

{
  "id": "cmpl-8FwDGc22M13XMnRuessZ15dG622BH",
  "object": "text_completion",
  "created": 1698809382,
  "model": "gpt-3.5-turbo-instruct",
  "choices": [
    {
    "text": "MLflow is an open-source platform for managing the end-to-end machine learning lifecycle. It provides tools for tracking experiments, managing and deploying models, and collaborating on projects. MLflow also supports various machine learning frameworks and languages, making it easier to work with different tools and environments. It is designed to help data scientists and machine learning engineers streamline their workflows and improve the reproducibility and scalability of their models.",
    "index": 0,
    "logprobs": null,
    "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 5,
    "completion_tokens": 83,
    "total_tokens": 88
  }
}

Converse com LLMs suportados usando o AI Playground

Você pode interagir com modelos de linguagem grandes suportados usando o AI Playground. O AI Playground é um ambiente semelhante a um bate-papo onde você pode testar, solicitar e comparar LLMs do seu espaço de trabalho do Azure Databricks.

Parque infantil AI

Recursos adicionais