Abfragen von Basismodellen und externen Modellen

In diesem Artikel erfahren Sie, wie Sie Abfrageanforderungen für Basismodelle und externe Modelle 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.

Mosaic AI Model Serving unterstützt Basismodell-APIs und externe Modelle für den Zugriff auf Modelle mit generativer KI. Model Serving verwendet eine einheitliche OpenAI-kompatible API und ein SDK für die Abfrage. Dies ermöglicht das Experimentieren mit und Anpassen von generativen KI-Modellen für die Produktion in unterstützten Clouds und Anbietern.

Mosaic AI Model Serving bietet die folgenden Optionen zum Senden von Bewertungsanforderungen an Endpunkte, die Basismodelle oder externe Modelle bereitstellen:

Anforderungen

• Ein Modellbereitstellungsendpunkt.
• Ein Databricks-Arbeitsbereich in einer unterstützten Region.
  • Regionen von Basis-Modell-APIs
  • Regionen von externen Modellen
• Sie müssen über Databricks-API-Token verfügen, um eine Bewertungsanforderung über den OpenAI-Client, die REST-API oder das MLflow Deployment SDK zu senden.

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

Das Databricks-SDK für Python ist auf allen Azure Databricks-Clustern bereits installiert, die Databricks Runtime 13.3 LTS oder höher verwenden. Für Azure Databricks-Cluster, die Databricks Runtime 12.2 LTS und darunter verwenden, müssen Sie zuerst das Databricks-SDK für Python installieren. Weitere Informationen finden Sie unter Schritt 1: Installieren oder Upgraden des Databricks SDK für Python.

Abfragen eines Chatvervollständigungsmodells

Im Folgenden sind Beispiele zum Abfragen eines Chatmodells aufgeführt. Das Beispiel gilt für das Abfragen eines Chatmodells, das mithilfe einer der Model Serving-Funktionen verfügbar gemacht wird: Foundation Model-APIs oder externe Modelle.

Ein Beispiel für einen Batch-Rückschluss finden Sie unter Batch-Rückschluss unter Verwendung des Foundation Model API-Durchsatzes.

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

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

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

Dieser Code muss in einem Notebook in Ihrem Arbeitsbereich ausgeführt werden. Weitere Infromationen unter Verwenden des Databricks SDK für Python in einem Azure Databricks-Notebook.

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

Um einen Foundation-Modell-Endpunkt mit LangChain abzufragen, können Sie die ChatDatabricks ChatModel-Klasse verwenden und die endpoint.

Im folgenden Beispiel wird die ChatDatabricks ChatModel-Klasse in LangChain verwendet, um den Foundation-Modell-APIs pay-per-Token-Endpunkt abzufragendatabricks-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

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

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

Im Folgenden sehen Sie beispielsweise das erwartete Anforderungsformat für ein Chatmodell bei Verwendung der REST-API. 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
}

Es folgt ein erwartbares Antwortformat für eine Anforderung, die mit der REST-API durchgeführt wurde:

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

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: Das Beispiel gilt für das Abfragen eines Einbettungsmodells, das mithilfe einer der Model Serving-Funktionen verfügbar gemacht wird: Foundation Model-APIs oder externe Modelle.

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

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

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

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

w = WorkspaceClient()
response = w.serving_endpoints.query(
    name="databricks-bge-large-en",
    input="Embed this sentence!"
)
print(response.data[0].embedding)

LangChain

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

%pip install langchain-databricks

from langchain_databricks import DatabricksEmbeddings

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

SQL

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-mixtral-8x7b-instruct-Modell, das von Basismodell-APIs verfügbar gemacht wird. Das Beispiel gilt für das Abfragen eines Chatmodells, das mithilfe einer der Model Serving-Funktionen verfügbar gemacht wird: Foundation Model-APIs oder externe Modelle. 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-mixtral-8x7b-instruct",
  prompt="what is databricks",
  temperature=1.0
)

REST-API

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-mixtral-8x7b-instruct/invocations

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="databricks-mixtral-8x7b-instruct",
    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

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

w = WorkspaceClient()
response = w.serving_endpoints.query(
    name="databricks-mixtral-8x7b-instruct",
    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(
    "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.

Zusätzliche Ressourcen

• Rückschlusstabellen für Überwachungs- und Debuggingmodelle
• Batch-Rückschluss mithilfe des von Foundation Model-APIs bereitgestellten Durchsatzes
• Databricks Foundation Model-APIs
• Externe Modelle in Mosaic AI Model Serving
• Unterstützte Modelle für Pay-per-Token
• Foundation Model-REST-API-Referenz