Freigeben über

Abfragen von Basismodellen

  • Artikel

In diesem Artikel erfahren Sie, wie Sie Abfrageanforderungen für Basismodelle formatieren und an Ihren Modellbereitstellungsendpunkt senden.

Informationen zu Abfrageanforderungen für herkömmliche ML- oder Python-Modelle finden Sie unter Abfragen von Bereitstellungsendpunkten für benutzerdefinierte Modelle.

Databricks Model Serving unterstützt Basismodell-APIs und externe Modelle für den Zugriff auf Basismodelle und verwendet eine einheitliche OpenAI-kompatible API und das SDK zum Abfragen. Dies ermöglicht das Experimentieren mit und Anpassen von Foundation-Modellen für die Produktion in unterstützten Clouds und Anbietern.

Databricks Model Serving bietet die folgenden Optionen zum Senden von Bewertungsanforderungen an Basismodelle:

Methode Details
OpenAI-Client Abfragen eines Modells, das von einem Databricks Modellbereitstellungsendpunkt mithilfe des OpenAI-Clients gehostet wird. Geben Sie das Modell an, das den Endpunktnamen als model-Eingabe angibt. Unterstützt für Chat-, Einbettungs- und Abschlussmodelle, die von Foundation Model-APIs oder externen Modellen zur Verfügung gestellt werden.
Serving-Benutzeroberfläche Wählen Sie auf der Seite Serving-Endpunkt die Option Abfrageendpunkt aus. Fügen Sie Eingabedaten des JSON-Formatmodells ein, und klicken Sie auf Anforderung übermitteln. Wenn das Modell ein Eingabebeispiel protokolliert hat, verwenden Sie Beispiel anzeigen, um es zu laden.
REST-API Rufen Sie das Modell mithilfe der REST-API auf, und fragen Sie es ab. Details finden Sie unter POST /serving-endpoints/{name}/invocations. Informationen zum Bewerten von Anforderungen an Endpunkte, die mehreren Modellen dienen, finden Sie unter Abfragen einzelner Modelle hinter einem Endpunkt.
MLflow Deployments SDK Verwenden Sie die Funktion predict() des MLflow Deployments SDK, um das Modell abzufragen.
Databricks GenAI SDK Das Databricks GenAI SDK ist eine Ebene über der REST-API. Es behandelt Details auf niedriger Ebene, z. B. Authentifizierung und Zuordnung von Modell-IDs zu Endpunkt-URLs, und vereinfacht damit die Interaktion mit den Modellen. Das SDK wurde für die Verwendung in Databricks-Notebooks entwickelt.
SQL-Funktion Rufen Sie den Modellrückschluss direkt aus SQL mithilfe der SQL-Funktion „ai_query“ auf. Siehe Abfragen eines bereitgestellten Modells mit ai_query().

Anforderungen

Wichtig

Als bewährte Sicherheitsmethode für Produktionsszenarien empfiehlt Databricks, Computer-zu-Computer-OAuth-Token für die Authentifizierung während der Produktion zu verwenden.

Für die Test- und Entwicklungsphase empfiehlt Databricks die Verwendung eines persönlichen Zugriffstokens, das Dienstprinzipalen anstelle von Arbeitsbereichsbenutzern gehört. Informationen zum Erstellen von Token für Dienstprinzipale finden Sie unter Verwalten von Token für einen Dienstprinzipal.

Installieren von Paketen

Nachdem Sie eine Abfragemethode ausgewählt haben, müssen Sie zuerst das entsprechende Paket für Ihren Cluster installieren.

OpenAI-Client

Um den OpenAI-Client zu verwenden, muss das openai-Paket für Ihren Cluster installiert sein. Führen Sie den folgenden Befehl in Ihrem Notebook oder lokalen Terminal aus:

!pip install openai

Folgendes ist nur erforderlich, wenn das Paket für ein Databricks-Notebook installiert wird.

dbutils.library.restartPython()

REST-API

Der Zugriff auf die Bereitstellungs-REST-API ist in Databricks Runtime für Machine Learning verfügbar.

MLflow Deployments SDK

!pip install mlflow

Folgendes ist nur erforderlich, wenn das Paket für ein Databricks-Notebook installiert wird.

dbutils.library.restartPython()

Databricks GenAI SDK

 !pip install databricks-genai

Folgendes ist nur erforderlich, wenn das Paket für ein Databricks-Notebook installiert wird.

 dbutils.library.restartPython()

Abfragen eines Chatvervollständigungsmodells

Im Folgenden sind Beispiele zum Abfragen eines Chatmodells aufgeführt.

Ein Beispiel für einen Batchrückschluss finden Sie unter Batchrückschluss mithilfe von Foundation Model-APIs.

OpenAI-Client

Nachfolgend sehen Sie eine Chatanforderungen für das DBRX Instruct-Modell, das über den Pay-per-Token-Endpunkt databricks-dbrx-instruct der Foundation Model-APIs in Ihrem Arbeitsbereich verfügbar gemacht wurde.

Um den OpenAI-Client zu verwenden, geben Sie den Endpunktnamen der Modellbereitstellung als model-Eingabe ein. Im folgenden Beispiel wird davon ausgegangen, dass Sie über ein Databricks-API-Token verfügen und openai auf Ihrem Computer installiert haben. Außerdem benötigen Sie Ihre Databricks-Arbeitsbereichsinstanz, um den OpenAI-Client mit Databricks zu verknüpfen.


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

Wichtig

Im folgenden Beispiel werden REST-API-Parameter zum Abfragen von Endpunkten verwendet, die Foundation-Modelle bedienen. Diese Parameter befinden sich in der Public Preview, und die Definition kann sich ändern. Siehe POST /serving-endpoints/{name}/invocations.

Nachfolgend sehen Sie eine Chatanforderungen für das DBRX Instruct-Modell, das über den Pay-per-Token-Endpunkt databricks-dbrx-instruct der Foundation Model-APIs in Ihrem Arbeitsbereich verfügbar gemacht wurde.

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

Wichtig

Im folgenden Beispiel wird die predict()-API aus dem MLflow Deployments SDK verwendet.

Nachfolgend sehen Sie eine Chatanforderungen für das DBRX Instruct-Modell, das über den Pay-per-Token-Endpunkt databricks-dbrx-instruct der Foundation Model-APIs in Ihrem Arbeitsbereich verfügbar gemacht wurde.


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

Nachfolgend sehen Sie eine Chatanforderungen für das DBRX Instruct-Modell, das über den Pay-per-Token-Endpunkt databricks-dbrx-instruct der Foundation Model-APIs in Ihrem Arbeitsbereich verfügbar gemacht wurde.

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

Zum Abfragen eines Endpunkts der Databricks-Basismodell-APIs mit LangChain können Sie eine der folgenden Aktionen ausführen:

  • Importieren Sie die LLM-Klasse Databricks, und geben Sie endpoint_name und transform_input_fn an.
  • Importieren Sie die ChatModel-Klasse ChatDatabricks, und geben Sie endpoint an.

Im folgenden Beispiel wird die Databricks LLM-Klasse in LangChain verwendet, um den Foundation-Modell-APIs pay-per-Token-Endpunkt abzufragendatabricks-dbrx-instruct. Basismodell-APIs von Databricks erwarten messages im Anforderungswörterbuch, während LangChain Databricks LLM standardmäßig prompt im Anforderungswörterbuch bereitstellt. Verwenden Sie die transform_input-Funktion, um das Anforderungswörterbuch im erwarteten Format vorzubereiten.

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

Im folgenden Beispiel wird die ChatModel-Klasse ChatDatabricks verwendet und endpoint wird angegeben.

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

Wichtig

Im folgenden Beispiel wird die integrierte SQL-Funktion ai_query verwendet. Diese Funktion befindet sich in der Public Preview, und die Definition kann sich ändern. Siehe Abfragen eines bereitgestellten Modells mit ai_query().

Im Folgenden finden Sie eine Chatanfrage für llama-2-70b-chat, was über den Pay-per-Token-Endpunkt databricks-llama-2-70b-chat der Foundation Model-APIs in Ihrem Arbeitsbereich verfügbar gemacht wurden

Hinweis

Die ai_query()-Funktion unterstützt keine Abfrageendpunkte, die das DBRX- oder DBRX Instruct-Modell bedienen.

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

Nachfolgend sehen Sie das erwartete Anforderungsformat für ein Chatmodell. Für externe Modelle können Sie zusätzliche Parameter einschließen, die für eine bestimmte Anbieter- und Endpunktkonfiguration gültig sind. Siehe Zusätzliche Abfrageparameter.

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

Hier sehen Sie das erwartete Antwortformat:

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

Chat-Sitzung

Databricks GenAI SDK stellt Klasse ChatSession zum Verwalten von Chatunterhaltungen mit mehreren Runden bereit. WDS bietet die folgenden Funktionen:

Funktion Return Beschreibung
reply (string) Nimmt eine neue Benutzernachricht an
last Zeichenfolge Letzte Nachricht vom Assistenten
history Diktatliste Nachrichten im Chatverlauf, einschließlich Rollen.
count INT Anzahl der bisher durchgeführten Chatrunden.

Zum Initialisieren von ChatSession verwenden Sie dieselben Argumente wie ChatCompletion. Diese Argumente werden während der gesamten Chatsitzung verwendet.


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?"}
# ]

Abfragen eines Einbettungsmodells

Nachfolgend sehen Sie eine Einbettungsanforderung für das bge-large-en-Modell, das von Foundation Model-APIs zur Verfügung gestellt wird:

OpenAI-Client

Um den OpenAI-Client zu verwenden, geben Sie den Endpunktnamen der Modellbereitstellung als model-Eingabe ein. Im folgenden Beispiel wird davon ausgegangen, dass Sie über ein Databricks-API-Token verfügen und openai auf Ihrem Cluster installiert haben.


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

REST-API

Wichtig

Im folgenden Beispiel werden REST-API-Parameter zum Abfragen von Endpunkten verwendet, die Foundation-Modelle bedienen. Diese Parameter befinden sich in der Public Preview, und die Definition kann sich ändern. Siehe 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

Wichtig

Im folgenden Beispiel wird die predict()-API aus dem MLflow Deployments SDK verwendet.


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

Um ein Basismodell-APIs-Modell von Databricks in LangChain als Einbettungsmodell zu verwenden, importieren Sie die Klasse DatabricksEmbeddings, und geben Sie den endpoint Parameter wie folgt an:

from langchain.embeddings import DatabricksEmbeddings

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

SQL

Wichtig

Im folgenden Beispiel wird die integrierte SQL-Funktion ai_query verwendet. Diese Funktion befindet sich in der Public Preview, und die Definition kann sich ändern. Siehe Abfragen eines bereitgestellten Modells mit ai_query().


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

Nachfolgend sehen Sie das erwartete Anforderungsformat für ein Einbettungsmodell. Für externe Modelle können Sie zusätzliche Parameter einschließen, die für eine bestimmte Anbieter- und Endpunktkonfiguration gültig sind. Siehe Zusätzliche Abfrageparameter.


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

Hier sehen Sie das erwartete Antwortformat:

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

Abfragen eines Textvervollständigungsmodells

Nachfolgend sehen Sie eine Einbettungsanforderung für das databricks-mpt-30b-instruct-Modell, das von Basismodell-APIs verfügbar gemacht wird. Parameter und Syntax finden Sie unter Vervollständigungsaufgabe.

OpenAI-Client

Um den OpenAI-Client zu verwenden, geben Sie den Endpunktnamen der Modellbereitstellung als model-Eingabe ein. Im folgenden Beispiel wird davon ausgegangen, dass Sie über ein Databricks-API-Token verfügen und openai auf Ihrem Cluster installiert haben.


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
)

REST-API

Wichtig

Im folgenden Beispiel werden REST-API-Parameter zum Abfragen von Endpunkten verwendet, die Foundation-Modelle bedienen. Diese Parameter befinden sich in der Public Preview, und die Definition kann sich ändern. Siehe 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

Wichtig

Im folgenden Beispiel wird die predict()-API aus dem MLflow Deployments SDK verwendet.


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

Wichtig

Im folgenden Beispiel wird die integrierte SQL-Funktion ai_query verwendet. Diese Funktion befindet sich in der Public Preview, und die Definition kann sich ändern. Siehe Abfragen eines bereitgestellten Modells mit ai_query().

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

Nachfolgend sehen Sie das erwartete Anforderungsformat für ein Vervollständigungsmodell. Für externe Modelle können Sie zusätzliche Parameter einschließen, die für eine bestimmte Anbieter- und Endpunktkonfiguration gültig sind. Siehe Zusätzliche Abfrageparameter.

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

Hier sehen Sie das erwartete Antwortformat:

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

Chatten mit unterstützten LLMs im KI-Playground

Sie können mit unterstützten großen Sprachmodellen interagieren, indem Sie den KI-Playground verwenden. Der KI-Playground ist eine Chat-ähnliche Umgebung, in der Sie LLMs aus Ihrem Azure Databricks-Arbeitsbereich testen, auffordern und vergleichen können.

KI-Playground

Zusätzliche Ressourcen