Modely základu dotazů

V tomto článku se dozvíte, jak formátovat požadavky na dotazy na základní modely a odesílat je do koncového bodu obsluhy modelu. Můžete dotazovat základní modely hostované Databricks a základní modely hostované mimo Databricks.

Pro požadavky na dotazy k tradičním modelům ML nebo Pythonu navštivte stránku Obslužné koncové body pro dotazy na vlastní modely.

Mosaic AI Model Serving podporuje rozhraní API základních modelů a externí modely pro přístup k základním modelům. Obsluha modelů používá k dotazování sjednocené rozhraní API kompatibilní s OpenAI a sadou SDK. Díky tomu můžete experimentovat se základními modely pro produkční prostředí napříč podporovanými cloudy a poskytovateli a přizpůsobovat je.

Platforma Mosaic AI Model Serving poskytuje následující možnosti pro odesílání hodnotících žádostí na koncové body, které obsluhují základní modely nebo externí modely.

Metoda	Podrobnosti
Klient OpenAI	Dotazování na model hostovaný koncovým bodem obsluhy modelu Mosaic AI pomocí klienta OpenAI Zadejte název koncového bodu pro obsluhu modelu jako vstup. Podporované jsou chatovací modely, modely pro vkládání a dokončování, které jsou dostupné prostřednictvím rozhraní API základních modelů nebo externích modelů.
Funkce SQL	Vyvolání odvozování modelu přímo z SQL pomocí ai_query funkce SQL Viz Příklad: Dotazování základního modelu.
Obsluha uživatelského rozhraní	Na stránce Koncový bod obsluhy vyberte dotazovací koncový bod. Vložte vstupní data modelu formátu JSON a klikněte na Odeslat požadavek. Pokud má model zaprotokolovaný vstupní příklad, načtěte ho pomocí příkazu Zobrazit příklad .
REST API	Volání a dotazování modelu pomocí rozhraní REST API Podrobnosti najdete v tématu POST /serving-endpoints/{name}/invocations . Pro žádosti o skórování na koncových bodech, které slouží více modelům, viz Dotazování jednotlivých modelů za koncovým bodem.
Sada SDK pro nasazení MLflow	K dotazování modelu použijte funkci predict() ze sady SDK pro nasazení MLflow.
Databricks Python SDK	Sada Databricks Python SDK je vrstva nad rozhraním REST API. Zpracovává podrobnosti nízké úrovně, jako je ověřování, což usnadňuje interakci s modely.

Požadavky

• Model obsluhující koncový bod
• Pracovní prostor Databricks v podporované oblasti
  • Oblasti rozhraní API základního modelu
  • Oblasti externích modelů
• Pokud chcete odeslat žádost o bodování prostřednictvím klienta OpenAI, rozhraní REST API nebo sady SDK pro nasazení MLflow, musíte mít token rozhraní API Databricks.

Důležité

Jako osvědčený postup zabezpečení pro produkční scénáře doporučuje Databricks používat machine-to-machine OAuth tokeny pro ověřování během produkce.

Pro účely testování a vývoje doporučuje Databricks místo uživatelů pracovního prostoru používat osobní přístupový token patřící instančním objektům . Pokud chcete vytvořit tokeny pro instanční objekty, přečtěte si téma Správa tokenů instančního objektu.

Instalace balíčků

Po výběru metody dotazování musíte nejprve nainstalovat příslušný balíček do clusteru.

Klient OpenAI

Pokud chcete použít klienta OpenAI, musí být balíček databricks-sdk[openai] nainstalovaný ve vašem clusteru. Sada Databricks SDK poskytuje obálku pro vytváření klienta OpenAI s autorizací automaticky nakonfigurovanou pro dotazování generovaných modelů AI. V poznámkovém bloku nebo místním terminálu spusťte následující příkaz:

!pip install databricks-sdk[openai]>=0.35.0

Následující informace se vyžadují jenom při instalaci balíčku do poznámkového bloku Databricks.

dbutils.library.restartPython()

REST API

Přístup k REST API pro nasazení je dostupný v databricks runtime pro strojové učení.

Sada SDK pro nasazení MLflow

!pip install mlflow

Toto je potřeba pouze když instalujete balíček do poznámkového bloku Databricks.

dbutils.library.restartPython()

Databricks Python SDK

Sada Databricks SDK pro Python je už nainstalovaná na všech clusterech Azure Databricks, které používají Databricks Runtime 13.3 LTS nebo vyšší. V případě clusterů Azure Databricks, které používají Databricks Runtime 12.2 LTS a níže, musíte nejprve nainstalovat sadu Databricks SDK pro Python. Viz Databricks SDK pro Python.

Dotazování modelu dokončování chatu

Tady jsou příklady pro dotazování modelu chatu. Příklad se vztahuje na dotazování modelu chatu, který je k dispozici pomocí některé z možností nasazení modelu: rozhraní API základního modelu nebo externí modely.

Příklad dávkového odvozování najdete v tématu Provedení dávkového odvozování LLM pomocí funkcí AI.

Klient OpenAI

Následuje žádost o chat pro model DBRX Instruct, který je zpřístupněn přes zpoplatněný za token koncový bod rozhraní API základního modelu ve vašem pracovním prostoru.

Pokud chcete použít klienta OpenAI, zadejte jako vstup model obsluhující název koncového model bodu.

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
)

Pokud chcete dotazovat základní modely mimo váš pracovní prostor, musíte přímo použít klienta OpenAI. K připojení klienta OpenAI k instanci pracovního prostoru Databricks potřebujete také instanci Databricks. Následující příklad předpokládá, že máte token rozhraní API Databricks a openai na vašem výpočetním prostředí nainstalovaný.

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
)

REST API

Důležité

Následující příklad používá parametry rozhraní REST API k dotazování obsluhujících koncové body, které obsluhují základní modely. Tyto parametry jsou v režimu Public Preview a jejich definice se může změnit. Viz POST /serving-endpoints/{name}/invocations.

Následuje žádost o chat pro model DBRX Instruct, který zpřístupnil koncový bod API základního modelu dostupný za platbu za token databricks-dbrx-instruct ve vašem pracovním prostoru.

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 \

Sada SDK pro nasazení MLflow

Důležité

Následující příklad používá predict() API z MLflow Deployments SDK.

Následuje žádost o chat pro model DBRX Instruct zpřístupněná rozhraním API nadace modelu na koncovém bodu s platbou za token databricks-dbrx-instruct ve vašem pracovním prostoru.

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 Python SDK

Následuje žádost o chat pro model DBRX Instruct, který zpřístupnil koncový bod databricks-dbrx-instruct rozhraní API základního modelu s průběžnými platbami za token ve vašem pracovním prostoru.

Tento kód musí být spuštěný v poznámkovém bloku ve vašem pracovním prostoru. Viz též Použití sady Databricks SDK pro Python z poznámkového bloku 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

K dotazování základního modelového endpointu pomocí LangChain můžete použít třídu ChatDatabricks ChatModel a zadat endpoint.

Následující příklad používá třídu ChatModel v LangChain k dotazování koncového bodu API modelu nadace, který je platí za token, databricks-dbrx-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-dbrx-instruct")
llm.invoke(messages)

SQL

Důležité

Následující příklad používá integrovanou funkci SQL ai_query. Tato funkce je ve verzi Public Preview a definice se může změnit.

Následuje žádost o chat pro meta-llama-3-1-70b-instruct, zpřístupněná koncovým bodem rozhraní API Základního modelu s platbou za token databricks-meta-llama-3-1-70b-instruct ve vašem pracovním prostoru.

Poznámka:

Funkce ai_query() nepodporuje koncové body dotazů, které obsluhují dbRX nebo model DBRX Instruct.

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

Například následující formát požadavku pro model chatu při použití rozhraní REST API je očekávaný formát požadavku. U externích modelů můžete zahrnout další parametry platné pro daného poskytovatele a konfiguraci koncového bodu. Viz Další parametry dotazu.

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

Následuje očekávaný formát odpovědi pro požadavek vytvořený pomocí rozhraní REST API:

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

Dotazování modelu vkládání

Následuje žádost o vložení modelu gte-large-en zpřístupněného rozhraními API základního modelu. Příklad se vztahuje na dotazování modelu vkládání, který byl zpřístupněn pomocí některého z funkcí obsluhy modelů: rozhraní API základního modelu nebo externích modelů.

Klient OpenAI

Pokud chcete použít klienta OpenAI, zadejte jako vstup model obsluhující název koncového model bodu.

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

Pokud chcete dotazovat základní modely mimo pracovní prostor, musíte přímo použít klienta OpenAI, jak je znázorněno níže. Následující příklad předpokládá, že máte na výpočetních prostředcích nainstalovaný token rozhraní API Databricks a openai. K připojení klienta OpenAI k Databricks potřebujete také instanci pracovního prostoru 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"
)

REST API

Důležité

Následující příklad používá parametry rozhraní REST API k dotazování obsluhujících koncové body, které obsluhují základní modely nebo externí modely. Tyto parametry jsou v režimu Public Preview a jejich definice se může změnit. Viz 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-gte-large-en/invocations

Sada SDK pro nasazení MLflow

Důležité

Následující příklad používá predict() rozhraní API z 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-gte-large-en",
    inputs={
        "input": "Here is some text to embed"
    }
)

Databricks Python SDK

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

Pokud chcete jako vložený model použít model rozhraní API Databricks Foundation v LangChain, importujte DatabricksEmbeddings třídu a zadejte parametr endpoint následujícím způsobem:

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

SQL

Důležité

Následující příklad používá integrovanou funkci SQL ai_query. Tato funkce je ve verzi Public Preview a definice se může změnit.

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

Následuje očekávaný formát požadavku pro model vkládání. U externích modelů můžete zahrnout další parametry platné pro daného poskytovatele a konfiguraci koncového bodu. Viz Další parametry dotazu.

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

Následuje očekávaný formát odpovědi:

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

Zkontrolujte, jestli jsou vkládání normalizované.

Pomocí následujícího příkazu zkontrolujte, jestli jsou vložené vygenerované modelem normalizované.

  import numpy as np

  def is_normalized(vector: list[float], tol=1e-3) -> bool:
      magnitude = np.linalg.norm(vector)
      return abs(magnitude - 1) < tol

Dotazování modelu dokončování textu

Klient OpenAI

Důležité

Dotazování se základních modelů dokončování textu, které jsou dostupné pomocí platby za token prostřednictvím klienta OpenAI, není podporováno. Jak je znázorněno v této části, podporuje se pouze dotazování externích modelů pomocí klienta OpenAI.

Pokud chcete použít klienta OpenAI, zadejte jako vstup model obsluhující název koncového model bodu. Následující příklad dotazuje model dokončování claude-2, který je hostován společností Anthropic s pomocí klienta OpenAI. Pokud chcete použít klienta OpenAI, vyplňte model pole názvem koncového bodu obsluhujícího model, který je hostitelem modelu, který chcete dotazovat.

Tento příklad používá dříve vytvořený koncový bod nakonfigurovaný anthropic-completions-endpointpro přístup k externím modelům od poskytovatele modelu Anthropic. Podívejte se, jak vytvořit koncové body externího modelu.

Podporované modely a jejich poskytovatele, které můžete dotazovat, najdete v Supported models.

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)

REST API

Následuje žádost o dokončení pro dotazování modelu dokončení zpřístupněného pomocí externích modelů.

Důležité

Následující příklad používá parametry rozhraní REST API k dotazování obsluhujících koncové body, které obsluhují externí modely. Tyto parametry jsou v režimu Public Preview a jejich definice se může změnit. Viz 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/<completions-model-endpoint>/invocations

Sada SDK pro nasazení MLflow

Následuje žádost o dokončení pro dotazování modelu dokončení zpřístupněného pomocí externích modelů.

Důležité

Následující příklad používá predict() rozhraní API z MLflow Deployments SDK.

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)

Databricks Python SDK

Následuje žádost o dokončení dotazu na model dokončení zpřístupněný pomocí externích modelů.

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

Důležité

Následující příklad používá integrovanou funkci SQL ai_query. Tato funkce je ve verzi Public Preview a definice se může změnit.

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

Následuje očekávaný formát požadavku pro model dokončení. U externích modelů můžete zahrnout další parametry platné pro daného poskytovatele a konfiguraci koncového bodu. Viz Další parametry dotazu.

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

Následuje očekávaný formát odpovědi:

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

Chat s podporovanými LLM pomocí AI Playground

S podporovanými velkými jazykovými modely můžete pracovat pomocí AI Playgroundu. AI Playground je prostředí podobné chatu, ve kterém můžete testovat, zobrazovat výzvy a porovnávat LLM z pracovního prostoru Azure Databricks.

Další materiály

• Monitor obsluhoval modely s využitím odvozovacích tabulek s podporou brány AI
• Provádět dávkové inferování LLM pomocí funkcí AI
• Databricks API pro základní model
• Externí modely v obsluhě modelu AI v systému Mosaic AI
• Kurz: Vytvoření koncových bodů externího modelu pro dotazování modelů OpenAI
• Podporované modely pro platby za token
• Referenční informace k rozhraní REST API základního modelu