Share via

Frågegrundsmodeller

  • Artikel

I den här artikeln får du lära dig hur du formaterar frågeförfrågningar för grundmodeller och skickar dem till din modell som betjänar slutpunkten.

För traditionella ML- eller Python-modellers frågebegäranden, se Frågeserverslutpunkter för anpassade modeller.

Databricks Model Serving har stöd för Foundation Models API:er och externa modeller för åtkomst till grundmodeller och använder ett enhetligt OpenAI-kompatibelt API och SDK för att köra frågor mot dem. Detta gör det möjligt att experimentera med och anpassa grundmodeller för produktion i moln och leverantörer som stöds.

Databricks Model Serving innehåller följande alternativ för att skicka bedömningsbegäranden till grundmodeller:

Metod Details
OpenAI-klient Fråga en modell som hanteras av en Databricks Model Serving-slutpunkt med hjälp av OpenAI-klienten. Ange namnet på den modell som betjänar slutpunkten som model indata. Stöds för chatt-, inbäddnings- och slutförandemodeller som görs tillgängliga av Foundation Model-API:er eller externa modeller.
Serveringsgränssnitt Välj Frågeslutpunkt på sidan Serveringsslutpunkt . Infoga indata för JSON-formatmodellen och klicka på Skicka begäran. Om modellen har ett indataexempel loggat använder du Visa exempel för att läsa in det.
REST-API Anropa och fråga modellen med hjälp av REST-API:et. Mer information finns i POST /serving-endpoints/{name}/invocations . Information om bedömning av begäranden till slutpunkter som betjänar flera modeller finns i Fråga efter enskilda modeller bakom en slutpunkt.
SDK för MLflow-distributioner Använd SDK:s predict()-funktion för MLflow Deployments för att fråga modellen.
Databricks GenAI SDK Databricks GenAI SDK är ett lager ovanpå REST-API:et. Den hanterar information på låg nivå, till exempel autentisering och mappning av modell-ID till slutpunkts-URL:er, vilket gör det enklare att interagera med modellerna. SDK:et är utformat för att användas inifrån Databricks notebook-filer.
SQL-funktion Anropa modellinferens direkt från SQL med hjälp av ai_query SQL-funktionen. Se Fråga en hanterad modell med ai_query().

Krav

Viktigt!

Som bästa säkerhet för produktionsscenarier rekommenderar Databricks att du använder OAuth-token från dator till dator för autentisering under produktion.

För testning och utveckling rekommenderar Databricks att du använder en personlig åtkomsttoken som tillhör tjänstens huvudnamn i stället för arbetsyteanvändare. Information om hur du skapar token för tjänstens huvudnamn finns i Hantera token för tjänstens huvudnamn.

Installera paket

När du har valt en frågemetod måste du först installera rätt paket i klustret.

Openai-klient

Om du vill använda OpenAI-klienten openai måste paketet installeras i klustret. Kör följande i anteckningsboken eller den lokala terminalen:

!pip install openai

Följande krävs endast när du installerar paketet på en Databricks Notebook

dbutils.library.restartPython()

Rest API

Åtkomst till SERVERINGs-REST-API:et finns i Databricks Runtime for Machine Learning.

Mlflow-distributioner sdk

!pip install mlflow

Följande krävs endast när du installerar paketet på en Databricks Notebook

dbutils.library.restartPython()

Databricks genai sdk

 !pip install databricks-genai

Följande krävs endast när du installerar paketet på en Databricks Notebook

 dbutils.library.restartPython()

Fråga efter en modell för chattens slutförande

Följande är exempel på frågor mot en chattmodell.

Ett exempel på batchinferens finns i Batch-slutsatsdragning med foundation model-API:er.

Openai-klient

Följande är en chattbegäran för DBRX Instruct-modellen som görs tillgänglig av Foundation Model-API:erna betala per token-slutpunkt på databricks-dbrx-instruct din arbetsyta.

Om du vill använda OpenAI-klienten anger du den modell som betjänar slutpunktens namn som model indata. I följande exempel förutsätter vi att du har en Databricks API-token och openai är installerad på din beräkning. Du behöver också din Databricks-arbetsyteinstans för att ansluta OpenAI-klienten till 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.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

Viktigt!

I följande exempel används REST API-parametrar för att köra frågor mot serverslutpunkter som hanterar grundmodeller. Dessa parametrar är offentlig förhandsversion och definitionen kan ändras. Se POST /serving-endpoints/{name}/invocations.

Följande är en chattbegäran för DBRX Instruct-modellen som görs tillgänglig av Foundation Model-API:erna betala per token-slutpunkt på databricks-dbrx-instruct din arbetsyta.

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-distributioner sdk

Viktigt!

I följande exempel används API:et predict()från MLflow Deployments SDK.

Följande är en chattbegäran för DBRX Instruct-modellen som görs tillgänglig av Foundation Model-API:erna betala per token-slutpunkt på databricks-dbrx-instruct din arbetsyta.


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

Följande är en chattbegäran för DBRX Instruct-modellen som görs tillgänglig av Foundation Model-API:erna betala per token-slutpunkt på databricks-dbrx-instruct din arbetsyta.

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

Om du vill köra frågor mot en grundläggande modellslutpunkt med LangChain kan du göra något av följande:

  • Importera LLM-klassen Databricks och ange endpoint_name och transform_input_fn.
  • ChatDatabricks Importera klassen ChatModel och ange endpoint.

I följande exempel används Databricks LLM-klassen i LangChain för att fråga Foundation Model-API:erna betala per token-slutpunkt, databricks-dbrx-instruct. Foundation Model-API:er förväntar sig messages i begärandeordlistan, medan LangChain Databricks LLM som standard finns prompt i ordlistan för begäran. transform_input Använd funktionen för att förbereda ordlistan för begäran till det förväntade formatet.

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

I följande exempel används ChatDatabricks klassen ChatModel och anger endpoint.

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

Viktigt!

I följande exempel används den inbyggda SQL-funktionen ai_query. Den här funktionen är offentlig förhandsversion och definitionen kan ändras. Se Fråga en hanterad modell med ai_query().

Följande är en chattbegäran som llama-2-70b-chat görs tillgänglig av Foundation Model-API:erna betala per token-slutpunkt databricks-llama-2-70b-chat på din arbetsyta.

Kommentar

Funktionen ai_query() stöder inte frågeslutpunkter som betjänar DBRX- eller DBRX Instruct-modellen.

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

Följande är det förväntade begärandeformatet för en chattmodell. För externa modeller kan du inkludera ytterligare parametrar som är giltiga för en viss provider och slutpunktskonfiguration. Se Ytterligare frågeparametrar.

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

Följande är ett förväntat svarsformat:

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

Chatt-session

Databricks GenAI SDK tillhandahåller ChatSession klass för att hantera chattkonversationer med flera ronder. Den innehåller följande funktioner:

Funktion Returnera beskrivning
reply (string) Tar ett nytt användarmeddelande
last sträng Senaste meddelande från assistenten
history lista över dikta Meddelanden i chatthistorik, inklusive roller.
count heltal Antal chattrundor som genomförts hittills.

Om du vill initiera ChatSessionanvänder du samma uppsättning argument som ChatCompletion, och dessa argument används under hela chattsessionen.


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

Fråga en inbäddningsmodell

Följande är en inbäddningsbegäran för modellen bge-large-en som görs tillgänglig av Foundation Model API:er.

Openai-klient

Om du vill använda OpenAI-klienten anger du den modell som betjänar slutpunktens namn som model indata. I följande exempel förutsätter vi att du har en Databricks API-token och openai är installerad i klustret.


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

Viktigt!

I följande exempel används REST API-parametrar för att köra frågor mot serverslutpunkter som hanterar grundmodeller. Dessa parametrar är offentlig förhandsversion och definitionen kan ändras. Se 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-distributioner sdk

Viktigt!

I följande exempel används API:et predict()från 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 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

Om du vill använda en Databricks Foundation-modell-API:er i LangChain som en inbäddningsmodell importerar DatabricksEmbeddings du klassen och anger parametern endpoint enligt följande:

from langchain.embeddings import DatabricksEmbeddings

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

SQL

Viktigt!

I följande exempel används den inbyggda SQL-funktionen ai_query. Den här funktionen är offentlig förhandsversion och definitionen kan ändras. Se Fråga en hanterad modell med ai_query().


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

Följande är det förväntade begärandeformatet för en inbäddningsmodell. För externa modeller kan du inkludera ytterligare parametrar som är giltiga för en viss provider och slutpunktskonfiguration. Se Ytterligare frågeparametrar.


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

Följande är det förväntade svarsformatet:

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

Fråga efter en modell för textkomplettering

Följande är en slutförandebegäran för modellen databricks-mpt-30b-instruct som görs tillgänglig av Foundation Model-API:er. Parametrarna och syntaxen finns i Slutförandeaktivitet.

Openai-klient

Om du vill använda OpenAI-klienten anger du den modell som betjänar slutpunktens namn som model indata. I följande exempel förutsätter vi att du har en Databricks API-token och openai är installerad i klustret.


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

Viktigt!

I följande exempel används REST API-parametrar för att köra frågor mot serverslutpunkter som hanterar grundmodeller. Dessa parametrar är offentlig förhandsversion och definitionen kan ändras. Se 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-distributioner sdk

Viktigt!

I följande exempel används API:et predict()från MLflow Deployments SDK.


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

Viktigt!

I följande exempel används den inbyggda SQL-funktionen ai_query. Den här funktionen är offentlig förhandsversion och definitionen kan ändras. Se Fråga en hanterad modell med ai_query().

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

Följande är det förväntade begärandeformatet för en slutförandemodell. För externa modeller kan du inkludera ytterligare parametrar som är giltiga för en viss provider och slutpunktskonfiguration. Se Ytterligare frågeparametrar.

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

Följande är det förväntade svarsformatet:

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

Chatta med LLM:er som stöds med AI Playground

Du kan interagera med stora språkmodeller som stöds med hjälp av AI Playground. AI Playground är en chattliknande miljö där du kan testa, fråga och jämföra LLM:er från din Azure Databricks-arbetsyta.

AI-lekplats

Ytterligare resurser