Modelos de base de consulta

Neste artigo, o senhor aprenderá a formatar solicitações de consulta para modelos da fundação e enviá-las para o endpoint servindo modelo.

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

O Databricks servindo modelo suporta APIs de modelos de fundação e modelos externos para acessar modelos de fundação e usa uma API e SDK unificados compatíveis com OpenAI para consultá-los. Isso possibilita experimentar e personalizar modelos de fundação para produção em clouds e provedores compatíveis.

Consultar um modelo de conclusão de bate-papo
Consultar um modelo de incorporação
Consultar um modelo de preenchimento de texto

O Databricks servindo modelo fornece as seguintes opções para o envio de solicitações de pontuação aos modelos da fundação:

Método	Detalhes
Cliente OpenAI	Consultar um modelo hospedado por um Databricks servindo modelo endpoint usando o cliente OpenAI. Especifique o nome do endpoint do modelo de serviço como a entrada `model`. Suportado para modelos de bate-papo, incorporações e conclusões disponibilizados pelas APIs do Foundation Model ou por modelos externos.
Servindo a UI	Selecione Query endpoint (Ponto de extremidade de consulta) na página Serving endpoint (Ponto de extremidade de atendimento ). Insira os dados de entrada do modelo no formato JSON e clique em Send Request (Enviar solicitação). Se o modelo tiver um registro de exemplo de entrada, use Show Example para carregá-lo.
API REST	Chame e consulte o modelo usando a API REST. Consulte POST /serving-endpoint/{name}/invocations para obter detalhes. Para solicitações de pontuação para pontos de extremidade que atendem a vários modelos, consulte Consultar modelos individuais em endpoint.
SDK de implantações do MLflow	Use a função predict() do MLflow Deployments SDK para consultar o modelo.
SDK GenAI da Databricks	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 endpoint, facilitando a interação com os modelos. O SDK foi projetado para ser usado a partir do Databricks Notebook.
Função SQL	Invoque a inferência de modelo diretamente do SQL usando a função `ai_query` SQL. Consulte Consultar um modelo atendido com ai_query().

Requisitos

A servindo modelo endpoint.
Um Databricks workspace em uma região com suporte.
- Regiões das APIs do Foundation Model
- Regiões de modelos externos
Para enviar uma solicitação de pontuação por meio do cliente OpenAI, REST API ou MLflow Deployment SDK, o senhor deve ter um token Databricks API .

Importante

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

Para testes e desenvolvimento, o Databricks recomenda o uso de um access token pessoal pertencente à entidade de serviço em vez de usuários do workspace. Para criar o site tokens para uma entidade de serviço, consulte gerenciar tokens para uma entidade de serviço.

Instalar o pacote

Depois de selecionar um método de consulta, o senhor deve primeiro instalar o pacote apropriado em seus clusters.

Para usar o cliente OpenAI, o pacote openai precisa estar instalado em seus clusters. Execute o seguinte em seu site Notebook ou em seu terminal local:

!pip install openai

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

dbutils.library.restartPython()

O acesso à API REST do Serving está disponível no Databricks Runtime for Machine Learning.

!pip install mlflow

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

dbutils.library.restartPython()

 !pip install databricks-genai

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

 dbutils.library.restartPython()

Consultar um modelo de conclusão de bate-papo

A seguir, exemplos de consulta a um modelo de chat.

Para obter um exemplo de inferência de lotes, consulte inferência de lotes usando o Foundation Model APIs.

A seguir, uma solicitação de chat para o modelo DBRX Instruct disponibilizado pela Foundation Model APIs pay-per-tokens endpoint, databricks-dbrx-instruct em seu workspace.

Para usar o cliente OpenAI, especifique o nome do modelo de serviço endpoint como a entrada model. O exemplo a seguir pressupõe que o senhor tenha um Databricks API tokens e openai instalados no seu compute. O senhor também precisa da instância do espaço de trabalho do 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
)

Importante

O exemplo a seguir usa os parâmetros da API REST para consultar o endpoint de serviço que atende aos modelos da fundação. Esses parâmetros são Public Preview e a definição pode mudar. Consulte POST /serving-endpoint/{name}/invocations.

A seguir, uma solicitação de chat para o modelo DBRX Instruct disponibilizado pela Foundation Model APIs pay-per-tokens endpoint, databricks-dbrx-instruct em seu workspace.

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 \

Importante

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

A seguir, uma solicitação de chat para o modelo DBRX Instruct disponibilizado pela Foundation Model APIs pay-per-tokens endpoint, databricks-dbrx-instruct em seu workspace.

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

A seguir, uma solicitação de chat para o modelo DBRX Instruct disponibilizado pela Foundation Model APIs pay-per-tokens endpoint, databricks-dbrx-instruct em seu workspace.

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

Para consultar um endpoint de modelo de fundação usando LangChain, o senhor pode fazer uma das seguintes opções:

Importe a classe Databricks LLM e especifique endpoint_name e transform_input_fn.
Importe a classe ChatDatabricks ChatModel e especifique a endpoint.

O exemplo a seguir usa a classe Databricks LLM em LangChain para consultar o endpoint pay-per-tokens das APIs do Foundation Model, databricks-dbrx-instruct. As APIs do Foundation Model esperam messages no dicionário de solicitações, enquanto o LangChain Databricks LLM by default fornece prompt no dicionário de solicitações. Use a função transform_input para preparar o dicionário de solicitação 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 classe ChatDatabricks ChatModel e especifica a 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)

Importante

O exemplo a seguir usa a função SQL integrada, IA. Essa função é uma visualização pública e a definição pode ser alterada. Consulte Consultar um modelo atendido com ai_query().

A seguir, uma solicitação de chat para llama-2-70b-chat disponibilizada pela Foundation Model APIs pay-per-tokens endpoint, databricks-llama-2-70b-chat em seu workspace.

Observação

A função ai_query() não é compatível com o endpoint de consulta que atende ao DBRX ou ao modelo DBRX Instruct.

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

O formato de solicitação esperado para um modelo de bate-papo é o seguinte. Para modelos externos, o senhor pode incluir parâmetros adicionais que são válidos para um determinado provedor e configuração de endpoint. Consulte Parâmetros de consulta adicionais.

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

O formato de resposta esperado é o seguinte:

{
  "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 bate-papo

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

função	Retorno	Descrição
`reply (string)`		Recebe uma nova mensagem do usuário
`last`	string	Última mensagem do assistente
`history`	lista de ditames	Mensagens no histórico do chat, incluindo funções.
`count`	int	Número de rodadas de bate-papo realizadas até o momento.

Para inicializar ChatSession, o senhor usa o mesmo conjunto de argumentos que ChatCompletion, e esses argumentos são usados em toda a sessão de bate-papo.

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, uma solicitação de incorporação para o modelo bge-large-en disponibilizado pelas APIs do Foundation Model.

Para usar o cliente OpenAI, especifique o nome do endpoint do modelo de serviço como a entrada model. O exemplo a seguir pressupõe que o senhor tenha tokens de API da Databricks e openai instalados em seus clusters.

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

Importante

O exemplo a seguir usa os parâmetros da API REST para consultar o endpoint de serviço que atende aos modelos da fundação. Esses parâmetros são Public Preview e a definição pode mudar. Consulte POST /serving-endpoint/{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

Importante

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

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

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}')

Para usar um modelo Databricks Foundation Model APIs no LangChain como um Embedding Model, importe a classe DatabricksEmbeddings e especifique o parâmetro endpoint da seguinte forma:

from langchain.embeddings import DatabricksEmbeddings

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

Importante

O exemplo a seguir usa a função SQL integrada, IA. Essa função é uma visualização pública e a definição pode ser alterada. Consulte Consultar um modelo atendido com ai_query().

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

A seguir, o formato de solicitação esperado para um modelo de embeddings. Para modelos externos, o senhor pode incluir parâmetros adicionais que são válidos para um determinado provedor e configuração de endpoint. Consulte Parâmetros de consulta adicionais.

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

O formato de resposta esperado é o seguinte:

{
  "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 preenchimento de texto

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

Para usar o cliente OpenAI, especifique o nome do endpoint do modelo de serviço como a entrada model. O exemplo a seguir pressupõe que o senhor tenha tokens de API da Databricks e openai instalados em seus clusters.

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
)

Importante

O exemplo a seguir usa os parâmetros da API REST para consultar o endpoint de serviço que atende aos modelos da fundação. Esses parâmetros são Public Preview e a definição pode mudar. Consulte POST /serving-endpoint/{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

Importante

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

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

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

Importante

O exemplo a seguir usa a função SQL integrada, IA. Essa função é uma visualização pública e a definição pode ser alterada. Consulte Consultar um modelo atendido com ai_query().

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

O formato de solicitação esperado para um modelo de conclusões é o seguinte. Para modelos externos, o senhor pode incluir parâmetros adicionais que são válidos para um determinado provedor e configuração de endpoint. 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 formato de resposta esperado é o seguinte:

{
  "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 apoiados usando o AI Playground

O senhor pode interagir com grandes modelos de linguagem suportados usando o AI Playground. O AI Playground é um ambiente semelhante a um bate-papo no qual o senhor pode testar, solicitar e comparar LLMs do seu Databricks workspace.

Recursos adicionais

Tabelas de inferência para monitoramento e depuração de modelos
[_] (/machine-learning/foundation-models/fmapi-lotes-inference.md)
APIs do modelo da Fundação Databricks
Modelos externos no Databricks servindo modelo
Modelos suportados para pay-per-tokens
Referência da API REST do modelo básico