Use modelos de fundação
Neste artigo, o senhor aprenderá a escrever solicitações de consulta para modelos de fundação e enviá-las para o seu modelo de serviço endpoint. O senhor pode consultar modelos de fundação hospedados pela Databricks e modelos de fundação hospedados fora da Databricks.
Para solicitações de consulta de modelos tradicionais ML ou Python, consulte Ponto de extremidade de serviço de consulta para modelos personalizados.
O Mosaic AI Model Serving é compatível com APIs de modelos de fundação e modelos externos para acessar modelos de fundação. A servindo modelo usa um site unificado compatível com OpenAI API e SDK para consultá-los. Isso possibilita experimentar e personalizar modelos básicos para produção em nuvens e fornecedores compatíveis.
Mosaic AI Model Serving fornece as seguintes opções para o envio de solicitações de pontuação ao endpoint que atende a modelos da fundação ou modelos externos:
Método | Detalhes |
---|---|
Cliente OpenAI | Consultar um modelo hospedado por um Mosaic AI Model Serving endpoint usando o cliente OpenAI. Especifique o nome do modelo de serviço endpoint como a entrada |
Função SQL | Invoque a inferência do modelo diretamente do SQL usando a função |
UI de serviço | 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 | Chamar e consultar o modelo usando a API REST. Consulte POST /serving-endpoint/{name}/invocations para obter detalhes. Para solicitações de pontuação para o endpoint que atende 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 Python da Databricks | O Databricks Python SDK é uma camada sobre a API REST. Ele lida com detalhes de baixo nível, como autenticação, facilitando a interação com os modelos. |
Requisitos
-
Um Databricks workspace em uma região com suporte.
-
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 .
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 site Databricks recomenda o uso de tokens de acesso pessoal pertencentes à entidade de serviço em vez de usuários do site workspace. Para criar tokens o site 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 para o seu clustering.
- OpenAI client
- REST API
- MLflow Deployments SDK
- Databricks Python SDK
Para usar o cliente OpenAI, o pacote databricks-sdk[openai]
precisa ser instalado em seu cluster. Databricks SDK fornece um wrapper para a construção do cliente OpenAI com autorização configurada automaticamente para consultar modelos AI generativos. Execute o seguinte em seu Notebook ou em seu terminal local:
!pip install databricks-sdk[openai]>=0.35.0
Os itens a seguir são necessários apenas ao instalar o pacote em um site Databricks Notebook
dbutils.library.restartPython()
O acesso à API REST do Serving está disponível no Databricks Runtime for Machine Learning.
!pip install mlflow
Os itens a seguir são necessários apenas ao instalar o pacote em um site Databricks Notebook
dbutils.library.restartPython()
O Databricks SDK para Python já está instalado em todos os clusters Databricks que usam Databricks Runtime 13.3 LTS ou acima. Para o clustering Databricks que usa Databricks Runtime 12.2 LTS e abaixo, o senhor deve instalar primeiro o Databricks SDK para Python. Consulte Databricks SDK para Python.
Consulta de modelo de preenchimento de texto
- OpenAI client
- SQL
- REST API
- MLflow Deployments SDK
- Databricks Python SDK
Não há suporte para a consulta de modelos de preenchimento de texto disponibilizados usando o Foundation Model APIs pay-per-tokens usando o cliente OpenAI. Somente a consulta de modelos externos usando o cliente OpenAI é suportada, conforme demonstrado nesta seção.
Para usar o cliente OpenAI, especifique o nome do modelo de serviço endpoint como a entrada model
. O exemplo a seguir consulta o modelo de conclusões do claude-2
hospedado pelo Anthropic usando o cliente OpenAI. Para usar o cliente OpenAI, preencha o campo model
com o nome do modelo de serviço endpoint que hospeda o modelo que o senhor deseja consultar.
Este exemplo usa um endpoint, anthropic-completions-endpoint
, criado anteriormente e configurado para acessar modelos externos do provedor de modelos Anthropic. Veja como criar um endpoint de modelo externo.
Consulte Modelos compatíveis para ver modelos adicionais que você pode consultar e seus fornecedores.
from databricks.sdk import WorkspaceClient
w = WorkspaceClient()
openai_client = w.serving_endpoints.get_open_ai_client()
completion = openai_client.completions.create(
model="anthropic-completions-endpoint",
prompt="what is databricks",
temperature=1.0
)
print(completion)
O exemplo a seguir usa a função integrada SQL, ai_query. Essa função é Visualização pública e a definição pode mudar.
SELECT ai_query(
"<completions-model-endpoint>",
"Can you explain AI in ten words?"
)
A seguir está uma solicitação de conclusões para consultar um modelo de conclusões disponibilizado usando modelos externos.
O exemplo a seguir usa os parâmetros REST API para consultar o ponto de extremidade de serviço que atende a modelos externos. Esses parâmetros estão na visualização pública 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/<completions-model-endpoint>/invocations
A seguir está uma solicitação de conclusões para consultar um modelo de conclusões disponibilizado usando modelos externos.
O exemplo a seguir usa a API predict()
do SDK do MLflow Deployments.
import os
import mlflow.deployments
# Only required when running this example outside of a Databricks Notebook
os.environ['DATABRICKS_HOST'] = "https://<workspace_host>.databricks.com"
os.environ['DATABRICKS_TOKEN'] = "dapi-your-databricks-token"
client = mlflow.deployments.get_deploy_client("databricks")
completions_response = client.predict(
endpoint="<completions-model-endpoint>",
inputs={
"prompt": "What is the capital of France?",
"temperature": 0.1,
"max_tokens": 10,
"n": 2
}
)
# Print the response
print(completions_response)
A seguir está uma solicitação de conclusões para consultar um modelo de conclusões disponibilizado usando modelos externos.
from databricks.sdk import WorkspaceClient
from databricks.sdk.service.serving import ChatMessage, ChatMessageRole
w = WorkspaceClient()
response = w.serving_endpoints.query(
name="<completions-model-endpoint>",
prompt="Write 3 reasons why you should train an AI model on domain specific data sets."
)
print(response.choices[0].text)
A seguir está o formato de solicitação esperado para um modelo de conclusão. 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
}
}
Veja a seguir 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
}
}
Consulta do modelo de conclusão de bate-papo
Veja a seguir exemplos de como consultar um modelo de bate-papo. O exemplo se aplica à consulta de um modelo de bate-papo disponibilizado usando qualquer um dos recursos de modelo de serviço: Foundation Model APIs ou External models.
Para obter um exemplo de inferência de lotes, consulte Realizar inferência de lotes LLM usando AI Functions.
- OpenAI client
- SQL
- REST API
- MLflow Deployments SDK
- Databricks Python SDK
- LangChain
A seguir, uma solicitação de bate-papo para o modelo Meta Llama 3.3 70B Instruct disponibilizado pela Foundation Model APIs pay-per-tokens endpoint, databricks-meta-llama-3-3-70b-instruct
em seu workspace.
Para usar o cliente OpenAI, especifique o nome do modelo de serviço endpoint como a entrada model
.
from databricks.sdk import WorkspaceClient
w = WorkspaceClient()
openai_client = w.serving_endpoints.get_open_ai_client()
response = openai_client.chat.completions.create(
model="databricks-meta-llama-3-3-70b-instruct",
messages=[
{
"role": "system",
"content": "You are a helpful assistant."
},
{
"role": "user",
"content": "What is a mixture of experts model?",
}
],
max_tokens=256
)
Para consultar os modelos da fundação fora do site workspace, o senhor deve usar o cliente OpenAI diretamente. O senhor também precisa de sua instância Databricks workspace para conectar o cliente OpenAI a Databricks. O exemplo a seguir pressupõe que o senhor tenha um Databricks API tokens e openai
instalados no seu compute.
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-meta-llama-3-3-70b-instruct",
messages=[
{
"role": "system",
"content": "You are a helpful assistant."
},
{
"role": "user",
"content": "What is a mixture of experts model?",
}
],
max_tokens=256
)
O exemplo a seguir usa a função integrada SQL, ai_query. Essa função é Visualização pública e a definição pode mudar.
A seguir, uma solicitação de bate-papo para meta-llama-3-1-70b-instruct
disponibilizada pela Foundation Model APIs pay-per-tokens endpoint, databricks-meta-llama-3-1-70b-instruct
em seu workspace.
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-meta-llama-3-1-70b-instruct",
"Can you explain AI in ten words?"
)
O exemplo a seguir usa os parâmetros REST API para consultar o ponto de extremidade de serviço que atende aos modelos da fundação. Esses parâmetros estão na visualização pública e a definição pode mudar. Consulte POST /serving-endpoint/{name}/invocations.
A seguir, uma solicitação de bate-papo para o modelo Meta Llama 3.3 70B Instruct disponibilizado pela Foundation Model APIs pay-per-tokens endpoint, databricks-meta-llama-3-3-70b-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-meta-llama-3-3-70b-instruct/invocations \
O exemplo a seguir usa a API predict()
do SDK do MLflow Deployments.
A seguir, uma solicitação de bate-papo para o modelo Meta Llama 3.3 70B Instruct disponibilizado pela Foundation Model APIs pay-per-tokens endpoint, databricks-meta-llama-3-3-70b-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-meta-llama-3-3-70b-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 bate-papo para o modelo Meta Llama 3.3 70B Instruct disponibilizado pela Foundation Model APIs pay-per-tokens endpoint, databricks-meta-llama-3-3-70b-instruct
em seu workspace.
Esse código deve ser executado em um Notebook em seu site workspace. Consulte Usar o Databricks SDK para Python de um notebook Databricks.
from databricks.sdk import WorkspaceClient
from databricks.sdk.service.serving import ChatMessage, ChatMessageRole
w = WorkspaceClient()
response = w.serving_endpoints.query(
name="databricks-meta-llama-3-3-70b-instruct",
messages=[
ChatMessage(
role=ChatMessageRole.SYSTEM, content="You are a helpful assistant."
),
ChatMessage(
role=ChatMessageRole.USER, content="What is a mixture of experts model?"
),
],
max_tokens=128,
)
print(f"RESPONSE:\n{response.choices[0].message.content}")
Para consultar um endpoint de modelo de fundação usando LangChain, o senhor pode usar a classe ChatDatabricks ChatModel e especificar o endereço endpoint
.
O exemplo a seguir usa a classe ChatDatabricks
ChatModel em LangChain para consultar o Foundation Model APIs pay-per-tokens endpoint, databricks-meta-llama-3-3-70b-instruct
.
%pip install databricks-langchain
from langchain_core.messages import HumanMessage, SystemMessage
from databricks_langchain import ChatDatabricks
messages = [
SystemMessage(content="You're a helpful assistant"),
HumanMessage(content="What is a mixture of experts model?"),
]
llm = ChatDatabricks(endpoint_name="databricks-meta-llama-3-3-70b-instruct")
llm.invoke(messages)
Como exemplo, o formato de solicitação esperado para um modelo de chat ao usar a API REST é 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 para uma solicitação feita usando a API REST é o seguinte:
{
"model": "databricks-meta-llama-3-3-70b-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
}
Modelos de raciocínio
O Mosaic AI Model Serving oferece uma API unificada para interagir com modelos de raciocínio. O raciocínio fornece aos modelos básicos recursos aprimorados para lidar com tarefas complexas. Alguns modelos também oferecem transparência ao revelar seu processo de pensamento passo a passo antes de fornecer uma resposta final.
Existem dois tipos de modelos: somente de raciocínio e híbridos. Modelos somente de raciocínio, como a série OpenAI o, sempre usam raciocínio interno em suas respostas. Modelos híbridos, como databricks-claude-3-7-sonnet
, suportam respostas rápidas e instantâneas e raciocínio mais profundo quando necessário.
Para permitir o raciocínio em modelos híbridos, inclua o parâmetro thinking e defina um valor budget_tokens
que controle quantos tokens o modelo pode usar para o pensamento interno. Orçamentos mais altos podem melhorar a qualidade de tarefas complexas, embora o uso acima de 32K possa variar. budget_tokens
deve ser menor que max_tokens
.
Todos os modelos de raciocínio são acessados por meio das conclusões do chat endpoint.
from openai import OpenAI
import base64
import httpx
client = OpenAI(
api_key=os.environ.get('YOUR_DATABRICKS_TOKEN'),
base_url=os.environ.get('YOUR_DATABRICKS_BASE_URL')
)
response = client.chat.completions.create(
model="databricks-claude-3-7-sonnet",
messages=[{"role": "user", "content": "Why is the sky blue?"}],
max_tokens=20480,
extra_body={
"thinking": {
"type": "enabled",
"budget_tokens": 10240
}
}
)
msg = response.choices[0].message
reasoning = msg.content[0]["summary"][0]["text"]
answer = msg.content[1]["text"]
print("Reasoning:", reasoning)
print("Answer:", answer)
A resposta da API inclui blocos de conteúdo de pensamento e de texto:
ChatCompletionMessage(
role="assistant",
content=[
{
"type": "reasoning",
"summary": [
{
"type": "summary_text",
"text": ("The question is asking about the scientific explanation for why the sky appears blue... "),
"signature": ("EqoBCkgIARABGAIiQAhCWRmlaLuPiHaF357JzGmloqLqkeBm3cHG9NFTxKMyC/9bBdBInUsE3IZk6RxWge...")
}
]
},
{
"type": "text",
"text": (
"# Why the Sky Is Blue\n\n"
"The sky appears blue because of a phenomenon called Rayleigh scattering. Here's how it works..."
)
}
],
refusal=None,
annotations=None,
audio=None,
function_call=None,
tool_calls=None
)
Gerenciar o raciocínio em vários turnos
Esta seção é específica para o databricks-claude-3-7-sonnet model
.
Em conversas com vários turnos, apenas os blocos de raciocínio associados ao último turno do assistente ou sessão de uso de ferramentas são visíveis para o modelo e contados como tokens de entrada.
Se não quiser passar tokens de raciocínio de volta para o modelo (por exemplo, não precisa que ele raciocine sobre as etapas anteriores), é possível omitir totalmente o bloco de raciocínio. Por exemplo:
response = client.chat.completions.create(
model="databricks-claude-3-7-sonnet",
messages=[
{"role": "user", "content": "Why is the sky blue?"},
{"role": "assistant", "content": text_content},
{"role": "user", "content": "Can you explain in a way that a 5-year-old child can understand?"}
],
max_tokens=20480,
extra_body={
"thinking": {
"type": "enabled",
"budget_tokens": 10240
}
}
)
answer = response.choices[0].message.content[1]["text"]
print("Answer:", answer)
No entanto, se você precisar que o modelo raciocine sobre seu processo de raciocínio anterior - por exemplo, se estiver criando experiências que revelem seu raciocínio intermediário - você deve incluir a mensagem completa e não modificada do assistente, incluindo o bloco de raciocínio do turno anterior. Veja como continuar um tópico com a mensagem completa do assistente:
assistant_message = response.choices[0].message
response = client.chat.completions.create(
model="databricks-claude-3-7-sonnet",
messages=[
{"role": "user", "content": "Why is the sky blue?"},
{"role": "assistant", "content": text_content},
{"role": "user", "content": "Can you explain in a way that a 5-year-old child can understand?"},
assistant_message,
{"role": "user", "content": "Can you simplify the previous answer?"}
],
max_tokens=20480,
extra_body={
"thinking": {
"type": "enabled",
"budget_tokens": 10240
}
}
)
answer = response.choices[0].message.content[1]["text"]
print("Answer:", answer)
Como funciona um modelo de raciocínio?
Os modelos de raciocínio introduzem tokens de raciocínio especiais, além dos tokens de entrada e saída padrão. Esses tokens permitem que o modelo "reflita" sobre o prompt, analisando-o e considerando diferentes maneiras de responder. Após esse processo de raciocínio interno, o modelo gera sua resposta final como tokens de saída visíveis. Alguns modelos, como o databricks-claude-3-7-sonnet
, exibem esses tokens de raciocínio para os usuários, enquanto outros, como a série OpenAI o, os descartam e não os expõem na saída final.
Modelos compatíveis
API do modelo Foundation (hospedado pela Databricks)
databricks-claude-3-7-sonnet
Modelos externos
- Modelos OpenAI com recursos de raciocínio
- Modelos do Anthropic Claude com recursos de raciocínio
- Modelos do Google Gemini com recursos de raciocínio
Modelos de visão
O Mosaic AI Model Serving oferece uma API unificada para entender e analisar imagens usando uma variedade de modelos de base, desbloqueando recursos multimodais avançados. Essa funcionalidade está disponível por meio de modelos selecionados hospedados no site Databrickscomo parte do Foundation Model APIs e do endpoint de atendimento que atende a modelos externos.
Exemplos de código
from openai import OpenAI
import base64
import httpx
client = OpenAI(
api_key="dapi-your-databricks-token",
base_url="https://example.staging.cloud.databricks.com/serving-endpoints"
)
# encode image
image_url = "https://upload.wikimedia.org/wikipedia/commons/a/a7/Camponotus_flavomarginatus_ant.jpg"
image_data = base64.standard_b64encode(httpx.get(image_url).content).decode("utf-8")
# OpenAI request
completion = client.chat.completions.create(
model="databricks-claude-3-7-sonnet",
messages=[
{
"role": "user",
"content": [
{"type": "text", "text": "what's in this image?"},
{
"type": "image_url",
"image_url": {"url": f"data:image/jpeg;base64,{image_data}"},
},
],
}
],
)
print(completion.choices[0].message.content)
O Chat Completions API suporta várias entradas de imagens, permitindo que o modelo analise cada imagem e sintetize as informações de todas as entradas para gerar uma resposta ao prompt.
from openai import OpenAI
import base64
import httpx
client = OpenAI(
api_key="dapi-your-databricks-token",
base_url="https://example.staging.cloud.databricks.com/serving-endpoints"
)
# Encode multiple images
image1_url = "https://upload.wikimedia.org/wikipedia/commons/thumb/d/dd/Gfp-wisconsin-madison-the-nature-boardwalk.jpg/2560px-Gfp-wisconsin-madison-the-nature-boardwalk.jpg"
image1_data = base64.standard_b64encode(httpx.get(image1_url).content).decode("utf-8")
image2_url = "https://upload.wikimedia.org/wikipedia/commons/thumb/d/dd/Gfp-wisconsin-madison-the-nature-boardwalk.jpg/2560px-Gfp-wisconsin-madison-the-nature-boardwalk.jpg"
image2_data = base64.standard_b64encode(httpx.get(image1_url).content).decode("utf-8")
# OpenAI request
completion = client.chat.completions.create(
model="databricks-claude-3-7-sonnet",
messages=[
{
"role": "user",
"content": [
{"type": "text", "text": "What are in these images? Is there any difference between them?"},
{
"type": "image_url",
"image_url": {"url": f"data:image/jpeg;base64,{image1_data}"},
},
{
"type": "image_url",
"image_url": {"url": f"data:image/jpeg;base64,{image2_data}"},
},
],
}
],
)
print(completion.choices[0].message.content)
Modelos compatíveis
API do modelo Foundation (hospedado pela Databricks)
databricks-claude-3-7-sonnet
Modelos externos
- Modelos OpenAI das séries GPT e o com recursos de visão
- Modelos do Anthropic Claude com recursos de visão
- Modelos do Google Gemini com recursos de visão
- Também há suporte para outros modelos de base externa com recursos de visão compatíveis com a API da OpenAI.
Requisitos de entrada de imagem
Esta seção se aplica somente às APIs do Foundation Model. Para modelos externos, consulte a documentação do fornecedor.
Várias imagens por solicitação
- Até 20 imagens para o Claude.AI
- Até 100 imagens para solicitações de API
- Todas as imagens fornecidas são processadas em uma solicitação, o que é útil para compará-las ou contrastá-las.
Limitações de tamanho
- Imagens maiores que 8000x8000 px serão rejeitadas.
- Se mais de 20 imagens forem enviadas em uma solicitação de API, o tamanho máximo permitido por imagem será de 2000 x 2000 px .
Recomendações de redimensionamento de imagens
- Para otimizar o desempenho, redimensione as imagens antes de fazer o upload, caso sejam muito grandes.
- Se a borda longa de uma imagem exceder 1568 pixels ou seu tamanho exceder ~1.600 tokens , ela será automaticamente reduzida, preservando a proporção.
- Imagens muito pequenas (menos de 200 pixels em qualquer borda ) podem prejudicar o desempenho .
- Para reduzir a latência , mantenha as imagens dentro de 1,15 megapixels e no máximo 1568 pixels em ambas as dimensões.
Considerações sobre a qualidade da imagem
- Formatos suportados: JPEG, PNG, GIF, WebP.
- Claridade: evite imagens borradas ou pixeladas.
- Texto em imagens:
- Certifique-se de que o texto esteja legível e não seja muito pequeno.
- Evite recortar key o contexto visual apenas para ampliar o texto.
Cálculo de custos
Esta seção se aplica somente às APIs do Foundation Model. Para modelos externos, consulte a documentação do fornecedor.
Cada imagem em uma solicitação para o modelo de fundação aumenta o uso de tokens.
Contagens e estimativas de tokens
Se não for necessário redimensionar, estime os tokens com:
tokens = (largura px × altura px) / 750
Contagens aproximadas de tokens para diferentes tamanhos de imagem:
Tamanho da imagem | tokens |
---|---|
200 × 200 px (0,04 MP) | ~54 |
1000 × 1000 px (1 MP) | ~1334 |
1092 × 1092 px (1,19 MP) | ~1590 |
Limitações da compreensão da imagem
Esta seção se aplica somente às APIs do Foundation Model. Para modelos externos, consulte a documentação do fornecedor.
Há limitações para a compreensão avançada da imagem do modelo Claude no Databricks:
- Identificação de pessoas : não é possível identificar ou nomear pessoas nas imagens.
- Precisão : pode interpretar mal imagens de baixa qualidade, giradas ou muito pequenas (\ < 200 px).
- Raciocínio espacial : O senhor tem dificuldades com a disposição precisa, como ler relógios analógicos ou posições de xadrez.
- Contagem : fornece contagens aproximadas, mas pode ser imprecisa para muitos objetos pequenos.
- AI-imagens geradas : Não é possível detectar de forma confiável imagens sintéticas ou falsas.
- Conteúdo impróprio : bloqueia imagens explícitas ou que violam políticas.
- Saúde : Não é adequado para exames médicos complexos (por exemplo, tomografias computadorizadas e ressonâncias magnéticas). Não é uma ferramenta de diagnóstico.
Analise todas as saídas cuidadosamente, especialmente para casos de uso de alto risco. Evite usar o Claude em tarefas que exijam precisão perfeita ou análise sensível sem supervisão humana.
Consulta de modelo de incorporação
A seguir, uma solicitação de incorporação para o modelo gte-large-en
disponibilizado pelas APIs do Foundation Model. O exemplo se aplica à consulta de um modelo de incorporação disponibilizado usando um dos recursos de modelo de serviço: Foundation Model APIs ou modelos externos.
- OpenAI client
- SQL
- REST API
- MLflow Deployments SDK
- Databricks Python SDK
- LangChain
Para usar o cliente OpenAI, especifique o nome do modelo de serviço endpoint como a entrada model
.
from databricks.sdk import WorkspaceClient
w = WorkspaceClient()
openai_client = w.serving_endpoints.get_open_ai_client()
response = openai_client.embeddings.create(
model="databricks-gte-large-en",
input="what is databricks"
)
Para consultar os modelos da fundação fora do seu site workspace, o senhor deve usar o cliente OpenAI diretamente, conforme demonstrado abaixo. 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 de sua instância Databricks workspace para conectar o cliente OpenAI a 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.embeddings.create(
model="databricks-gte-large-en",
input="what is databricks"
)
O exemplo a seguir usa a função integrada SQL, ai_query. Essa função é Visualização pública e a definição pode mudar.
SELECT ai_query(
"databricks-gte-large-en",
"Can you explain AI in ten words?"
)
O exemplo a seguir usa os parâmetros REST API para consultar o ponto de extremidade de serviço que atende a modelos de fundação ou modelos externos. Esses parâmetros estão na visualização pública 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-gte-large-en/invocations
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-gte-large-en",
inputs={
"input": "Here is some text to embed"
}
)
from databricks.sdk import WorkspaceClient
from databricks.sdk.service.serving import ChatMessage, ChatMessageRole
w = WorkspaceClient()
response = w.serving_endpoints.query(
name="databricks-gte-large-en",
input="Embed this sentence!"
)
print(response.data[0].embedding)
Para usar um modelo de APIs do Databricks Foundation Model no LangChain como um modelo de incorporação, importe a classe DatabricksEmbeddings
e especifique o parâmetro endpoint
da seguinte forma:
%pip install databricks-langchain
from databricks_langchain import DatabricksEmbeddings
embeddings = DatabricksEmbeddings(endpoint="databricks-gte-large-en")
embeddings.embed_query("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, 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"
]
}
Veja a seguir 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
}
}
Verifique se as incorporações estão normalizadas
Use o seguinte para verificar se as incorporações geradas pelo seu modelo estão normalizadas.
import numpy as np
def is_normalized(vector: list[float], tol=1e-3) -> bool:
magnitude = np.linalg.norm(vector)
return abs(magnitude - 1) < tol
Chamada de função
Databricks A Chamada de Função é compatível com OpenAI e só está disponível durante o atendimento ao modelo como parte do Foundation Model APIs e atendendo ao endpoint que atende a modelos externos. Para obter detalhes, consulte Chamada de função em Databricks.
Saídas estruturadas
As saídas estruturadas são compatíveis com o OpenAI e só estão disponíveis durante o servindo modelo como parte do Foundation Model APIs. Para obter detalhes, consulte Saídas estruturadas no Databricks.
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 em que o senhor pode testar, solicitar e comparar LLMs do seu Databricks workspace.
Recurso adicional
- Monitorar modelos atendidos usando tabelas de inferência habilitadas para AI Gateway
- Realize a inferência de lotes LLM usando AI Functions
- APIs do Foundation Model do Databricks
- Modelos externos no Mosaic AI Model Serving
- Tutorial: Crie pontos de extremidade de modelo externo para consultar modelos do OpenAI
- Modelos compatíveis com as APIs do Databricks Foundation Models
- Referência da API REST do Foundation Model