Consultar modelos de IA generativa

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

Para solicitações de consulta de modelos ML ou Python tradicionais, consulte Consulta que serve pontos de extremidade para modelos personalizados.

O Serviço de Modelo de IA do Mosaic dá suporte a APIs de Modelos Base e modelos externos para acessar modelos de IA generativa. O Serviço de Modelo usa uma API e um SDK unificados, compatíveis com o OpenAI para consultá-los. Isso possibilita experimentar e personalizar modelos de IA generativa para produção em nuvens e provedores com suporte.

O Serviço de Modelo de IA do Mosaic traz as seguintes opções para enviar solicitações de pontuação para pontos de extremidade que fornecem modelos base ou modelos externos:

Requisitos

• Um ponto de extremidade de serviço de modelo.
• Um workspace do Databricks em uma região com suporte.
  • regiões de APIs de modelo do Foundation
  • Regiões de modelos externos
• Para enviar uma solicitação de pontuação através do cliente OpenAI, API REST ou SDK de implantação MLflow, deve ter um token API Databricks.

Instalar Pacotes

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

Cliente OpenAI

Para usar o cliente OpenAI, o pacote databricks-sdk[openai] precisa ser instalado em seu cluster. O SDK do Databricks fornece um wrapper para construir o cliente OpenAI com autorização configurada automaticamente para consultar modelos de IA generativos. Execute o seguinte no bloco de anotações ou no terminal local:

!pip install databricks-sdk[openai]

A seguir só é necessário ao instalar o pacote em um Databricks Notebook

dbutils.library.restartPython()

API REST

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

SDK de Implantações do MLflow

!pip install mlflow

A seguir só é necessário ao instalar o pacote em um Databricks Notebook

dbutils.library.restartPython()

SDK do Databricks para Python

O SDK do Databricks para Python já está instalado em todos os clusters do Azure Databricks que usam o Databricks Runtime 13.3 LTS ou superior. Para clusters do Azure Databricks que usam o Databricks Runtime 12.2 LTS e inferior, você precisa instalar primeiro o SDK do Databricks para Python. Confira SDK do Databricks para Python.

Consultar um modelo de preenchimento de chat

A seguir estão exemplos de consulta de um modelo de chat. O exemplo se aplica à consulta de um modelo de chat disponibilizado que usa uma das funcionalidades do Serviço de Modelo: APIs do Modelo Base ou modelos externos.

Para obter um exemplo de inferência em lote, consulte Inferência em lote usando a taxa de transferência provisionada das APIs do Foundation Model.

Cliente OpenAI

A seguir está uma solicitação de chat 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 nome do ponto de extremidade de serviço do modelo 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-dbrx-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 modelos de base fora do seu espaço de trabalho, você deve usar o cliente OpenAI diretamente. Você também precisa da sua instância de espaço de trabalho do Databricks para conectar o cliente OpenAI ao Databricks. O exemplo a seguir pressupõe que você tenha um token de API do Databricks instalado openai em sua computação.

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 REST

A seguir está uma solicitação de chat 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 \

SDK de Implantações do MLflow

A seguir está uma solicitação de chat 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
    }
)

SDK do Databricks para Python

A seguir está uma solicitação de chat 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.

Esse código deve ser executado em um notebook em seu workspace. Consulte Usar o SDK do Databricks para Python de um notebook do Azure Databricks.

from databricks.sdk import WorkspaceClient
from databricks.sdk.service.serving import ChatMessage, ChatMessageRole

w = WorkspaceClient()
response = w.serving_endpoints.query(
    name="databricks-dbrx-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}")

LangChain

Para consultar um ponto de extremidade do modelo de base usando o LangChain, use a classe ChatDatabricks ChatModel e especifique o endpoint.

O exemplo a seguir usa a classe ChatDatabricks ChatModel em LangChain para consultar o ponto de extremidade pay-per-token das APIs do Modelo de Fundação, databricks-dbrx-instruct.

%pip install langchain-databricks

from langchain_core.messages import HumanMessage, SystemMessage
from langchain_databricks import ChatDatabricks

messages = [
    SystemMessage(content="You're a helpful assistant"),
    HumanMessage(content="What is a mixture of experts model?"),
]

llm = ChatDatabricks(endpoint_name="databricks-dbrx-instruct")
llm.invoke(messages)

SQL

A seguir está uma solicitação de chat para meta-llama-3-1-70b-instruct disponibilizada pelo ponto de extremidade de pagamento por token das APIs do Foundation Model, databricks-meta-llama-3-1-70b-instruct em seu espaço de trabalho.

SELECT ai_query(
    "databricks-meta-llama-3-1-70b-instruct",
    "Can you explain AI in ten words?"
  )

Por exemplo, o seguinte é o formato de solicitação esperado para um modelo de chat ao usar a API REST. Para modelos externos, você pode incluir parâmetros adicionais que são válidos para um determinado provedor e configuração de ponto de extremidade. Consulte parâmetros de consulta adicionais.

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

Veja a seguir um formato de resposta esperado para uma solicitação feita usando a API REST:

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

Consultar um modelo de inserção

A seguir, uma solicitação de inserção para o modelo gte-large-en disponibilizado pelas APIs do Modelo Base. O exemplo se aplica à consulta de um modelo de inserção disponibilizado que usa uma das funcionalidades do Serviço de Modelo: APIs do Modelo Base ou modelos externos.

Cliente OpenAI

Para usar o cliente OpenAI, especifique o nome do ponto de extremidade de serviço do modelo 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 modelos de base fora do workspace, você deve usar o cliente OpenAI diretamente, conforme demonstrado abaixo. O exemplo a seguir pressupõe que você tenha um token de API do Databricks e o openai instalados em sua computação. Você também precisa da sua instância de 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.embeddings.create(
  model="databricks-gte-large-en",
  input="what is databricks"
)

API REST

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

SDK de Implantações do MLflow

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

SDK do Databricks para Python

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)

LangChain

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

%pip install langchain-databricks

from langchain_databricks import DatabricksEmbeddings

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

SQL

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

A seguir, o formato de solicitação esperado para um modelo de inserções. Para modelos externos, você pode incluir parâmetros adicionais que são válidos para um determinado provedor e configuração de ponto de extremidade. 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
  }
}

Verifique se as incorporações estão normalizadas

Use o seguinte para verificar se as inserções geradas pelo 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

Consultar um modelo de preenchimento de texto

Cliente OpenAI

Para usar o cliente OpenAI, especifique o nome do ponto de extremidade de serviço do modelo como a entrada model. O exemplo a seguir consulta o modelo de conclusões claude-2 hospedado pela Anthropic usando o cliente OpenAI. Para usar o cliente OpenAI, preencha o campo model com o nome do endpoint de atendimento do modelo que hospeda o modelo que você deseja consultar.

Esse exemplo usa um ponto de extremidade criado anteriormente, anthropic-completions-endpoint, configurado para acessar modelos externos do provedor de modelos Antrópico. Veja como criar pontos de extremidade de modelo externo.

Veja Modelos suportados para 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)

API REST

Veja a seguir uma solicitação de conclusões para consultar um modelo de conclusões disponibilizado usando modelos externos.

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

SDK de Implantações do MLflow

Veja a seguir uma solicitação de conclusões para consultar um modelo de conclusões disponibilizado usando modelos externos.

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)

SDK do Databricks para Python

Veja a seguir 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)

SQL

SELECT ai_query(
    "<completions-model-endpoint>",
    "Can you explain AI in ten words?"
  )

A seguir, o formato de solicitação esperado para um modelo de conclusões. Para modelos externos, você pode incluir parâmetros adicionais que são válidos para um determinado provedor e configuração de ponto de extremidade. 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
  }
}

Conversar com LLMs com suporte usando o Playground de IA

Você pode interagir com modelos de linguagem grandes com suporte usando o Playground de IA. O Playground de IA é um ambiente semelhante a um chat onde você pode testar, enviar solicitações e comparar LLMs a partir do seu workspace do Azure Databricks.

Recursos adicionais

• Tabelas de inferência para monitoramento e depuração de modelos
• Inferência em lote usando a taxa de transferência provisionada das APIs do Foundation Model
• APIs de foundation model do Databricks
• Modelos externos no Serviço de Modelo do Mosaic AI
• Tutorial: Criar pontos de extremidade de modelo externo para consultar modelos OpenAI
• Modelos com suporte para pagamento por token
• Referência da API REST de foundation model