Modele podstaw zapytań

Artykuł
06/13/2024

Z tego artykułu dowiesz się, jak formatować żądania zapytań dla modeli podstawowych i wysyłać je do punktu końcowego obsługującego model.

W przypadku tradycyjnych modeli uczenia maszynowego lub języka Python zapytań dotyczących żądań, zobacz Zapytania obsługujące punkty końcowe dla modeli niestandardowych.

Obsługa modeli usługi Databricks obsługuje interfejsy API modeli podstawowych i modele zewnętrzne na potrzeby uzyskiwania dostępu do modeli podstawowych i używa ujednoliconego interfejsu API zgodnego z technologią OpenAI i zestawu SDK do wykonywania zapytań. Dzięki temu można eksperymentować z modelami podstawowymi i dostosowywać je do środowiska produkcyjnego w obsługiwanych chmurach i dostawcach.

Wykonywanie zapytań względem modelu uzupełniania czatu
Wykonywanie zapytań względem modelu osadzania
Wykonywanie zapytań względem modelu uzupełniania tekstu

Obsługa modeli usługi Databricks udostępnia następujące opcje wysyłania żądań oceniania do modeli podstawowych:

Metoda	Szczegóły
Klient OpenAI	Wykonywanie zapytań względem modelu hostowanego przez punkt końcowy obsługujący model usługi Databricks przy użyciu klienta OpenAI. Określ nazwę punktu końcowego obsługującego `model` model jako dane wejściowe. Obsługiwane w przypadku czatów, osadzania i uzupełniania modeli udostępnianych przez interfejsy API modelu foundation lub modele zewnętrzne.
Obsługa interfejsu użytkownika	Wybierz pozycję Punkt końcowy zapytania na stronie Obsługa punktu końcowego . Wstaw dane wejściowe modelu formatu JSON i kliknij pozycję Wyślij żądanie. Jeśli model ma zarejestrowany przykład danych wejściowych, użyj polecenia Pokaż przykład , aby go załadować.
Interfejs API REST	Wywoływanie modelu i wykonywanie zapytań względem tego modelu przy użyciu interfejsu API REST. Aby uzyskać szczegółowe informacje, zobacz POST /serving-endpoints/{name}/invocations . Aby uzyskać informacje na temat oceniania żądań do punktów końcowych obsługujących wiele modeli, zobacz Wykonywanie zapytań o poszczególne modele za punktem końcowym.
Zestaw SDK wdrożeń MLflow	Funkcja predict() zestawu SDK wdrożeń MLflow umożliwia wykonywanie zapytań względem modelu.
Databricks GenAI SDK	Zestaw SDK usługi Databricks GenAI to warstwa interfejsu API REST. Obsługuje on szczegóły niskiego poziomu, takie jak identyfikatory uwierzytelniania i mapowania modelu na adresy URL punktów końcowych, co ułatwia interakcję z modelami. Zestaw SDK jest przeznaczony do użycia z poziomu notesów usługi Databricks.
SQL, funkcja	Wywoływanie wnioskowania modelu bezpośrednio z bazy danych SQL przy użyciu `ai_query` funkcji SQL. Zobacz Wykonywanie zapytań względem obsługiwanego modelu przy użyciu ai_query().

Wymagania

Model obsługujący punkt końcowy.
Obszar roboczy usługi Databricks w obsługiwanym regionie.
- Regiony interfejsów API modelu foundation
- Regiony modeli zewnętrznych
Aby wysłać żądanie oceniania za pośrednictwem klienta OpenAI, interfejsu API REST lub zestawu SDK wdrażania MLflow, musisz mieć token interfejsu API usługi Databricks.

Ważne

Najlepszym rozwiązaniem w zakresie zabezpieczeń w scenariuszach produkcyjnych usługa Databricks zaleca używanie tokenów OAuth maszyny do maszyny podczas uwierzytelniania w środowisku produkcyjnym.

W przypadku testowania i programowania usługa Databricks zaleca używanie osobistego tokenu dostępu należącego do jednostek usługi zamiast użytkowników obszaru roboczego. Aby utworzyć tokeny dla jednostek usługi, zobacz Zarządzanie tokenami dla jednostki usługi.

Instalowanie pakietów

Po wybraniu metody wykonywania zapytań należy najpierw zainstalować odpowiedni pakiet w klastrze.

Klient OpenAI

Aby korzystać z klienta OpenAI, openai pakiet należy zainstalować w klastrze. Uruchom następujące polecenie w notesie lub w terminalu lokalnym:

!pip install openai

Następujące elementy są wymagane tylko podczas instalowania pakietu w notesie usługi Databricks

dbutils.library.restartPython()

Interfejs API REST

Dostęp do interfejsu API REST obsługi jest dostępny w środowisku Databricks Runtime na potrzeby uczenia maszynowego.

Zestaw SDK wdrożeń MLflow

!pip install mlflow

Następujące elementy są wymagane tylko podczas instalowania pakietu w notesie usługi Databricks

dbutils.library.restartPython()

Databricks GenAI SDK

Aby korzystać databricks-genai-inference z obciążeń aprowizowanej przepływności, należy użyć wersji 0.2.2 lub nowszej.

 !pip install databricks-genai-inference

Następujące elementy są wymagane tylko podczas instalowania pakietu w notesie usługi Databricks

 dbutils.library.restartPython()

Wykonywanie zapytań względem modelu uzupełniania czatu

Poniżej przedstawiono przykłady wykonywania zapytań dotyczących modelu czatu.

Aby zapoznać się z przykładem wnioskowania wsadowego, zobacz Batch inference using Foundation Model APIs (Wnioskowanie wsadowe przy użyciu interfejsów API modelu foundation).

Klient OpenAI

Poniżej przedstawiono żądanie czatu dla modelu DBRX Poinstruowanie udostępnionego przez interfejsy databricks-dbrx-instruct API modelu foundation model płatności za token w obszarze roboczym.

Aby użyć klienta OpenAI, określ model obsługujący nazwę punktu końcowego model jako dane wejściowe. W poniższym przykładzie przyjęto założenie, że masz token interfejsu API usługi Databricks i openai zainstalowano go na obliczeniach. Potrzebujesz również wystąpienia obszaru roboczego usługi Databricks, aby połączyć klienta OpenAI z usługą 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
)

Interfejs API REST

Ważne

W poniższym przykładzie użyto parametrów interfejsu API REST do wykonywania zapytań dotyczących punktów końcowych obsługujących modele podstawowe. Te parametry są publiczną wersją zapoznawcza , a definicja może ulec zmianie. Zobacz POST /serving-endpoints/{name}/invocations.

Poniżej przedstawiono żądanie czatu dla modelu DBRX Poinstruowanie udostępnionego przez interfejsy databricks-dbrx-instruct API modelu foundation model płatności za token w obszarze roboczym.

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 \

Zestaw SDK wdrożeń MLflow

Ważne

W poniższym przykładzie użyto interfejsu predict() API z zestawu SDK wdrożeń MLflow.

Poniżej przedstawiono żądanie czatu dla modelu DBRX Poinstruowanie udostępnionego przez interfejsy databricks-dbrx-instruct API modelu foundation model płatności za token w obszarze roboczym.


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

Poniżej przedstawiono żądanie czatu dla modelu DBRX Poinstruowanie udostępnionego przez interfejsy databricks-dbrx-instruct API modelu foundation model płatności za token w obszarze roboczym.

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

Aby wykonać zapytanie dotyczące punktu końcowego modelu podstawowego przy użyciu narzędzia LangChain, możesz wykonać jedną z następujących czynności:

Zaimportuj klasę Databricks LLM i określ wartości endpoint_name i transform_input_fn.
Zaimportuj klasę ChatDatabricks ChatModel i określ wartość endpoint.

W poniższym przykładzie Databricks użyto klasy LLM w języku LangChain do wykonywania zapytań względem punktów końcowych modelu foundation model pay-per-token. databricks-dbrx-instruct Interfejsy API modelu foundation oczekuje messages w słowniku żądań, a program LangChain Databricks LLM domyślnie udostępnia prompt w słowniku żądań. transform_input Użyj funkcji , aby przygotować słownik żądań do oczekiwanego formatu.

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

W poniższym przykładzie użyto ChatDatabricks klasy ChatModel i określono parametr 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

Ważne

W poniższym przykładzie użyto wbudowanej funkcji SQL, ai_query. Ta funkcja jest publiczna wersja zapoznawcza , a definicja może ulec zmianie. Zobacz Wykonywanie zapytań względem obsługiwanego modelu przy użyciu ai_query().

Poniżej przedstawiono żądanie czatu dla llama-2-70b-chat udostępnionego przez interfejsy API modelu foundation w punkcie końcowym databricks-llama-2-70b-chat płatności za token w obszarze roboczym.

Uwaga

Funkcja ai_query() nie obsługuje punktów końcowych zapytań obsługujących model DBRX lub DBRX Instruct.

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

Poniżej przedstawiono oczekiwany format żądania dla modelu czatu. W przypadku modeli zewnętrznych można uwzględnić dodatkowe parametry, które są prawidłowe dla danego dostawcy i konfiguracji punktu końcowego. Zobacz Dodatkowe parametry zapytania.

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

Poniżej przedstawiono oczekiwany format odpowiedzi:

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

Sesja rozmowy

Zestaw SDK usługi Databricks GenAI udostępnia ChatSession klasę do zarządzania wielo rundowymi konwersacjami na czacie. Zapewnia ona następujące funkcje:

Function	Powrót	opis
`reply (string)`		Przyjmuje nowy komunikat użytkownika
`last`	string	Ostatnia wiadomość od asystenta
`history`	lista dyktowania	Wiadomości w historii czatów, w tym role.
`count`	int	Liczba rund rozmów przeprowadzonych do tej pory.

Aby zainicjować ChatSessionmetodę , należy użyć tego samego zestawu argumentów co ChatCompletionargumenty , a argumenty te są używane w całej sesji czatu.


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

Wykonywanie zapytań względem modelu osadzania

Poniżej przedstawiono żądanie osadzania dla modelu udostępnionego bge-large-en przez interfejsy API modelu Foundation Model.

Klient OpenAI

Aby użyć klienta OpenAI, określ model obsługujący nazwę punktu końcowego model jako dane wejściowe. W poniższym przykładzie założono, że masz token interfejsu API usługi Databricks i openai zainstalowano go w klastrze.


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

Interfejs API REST

Ważne


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

Zestaw SDK wdrożeń MLflow

Ważne

W poniższym przykładzie użyto interfejsu predict() API z zestawu SDK wdrożeń 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-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

Aby użyć modelu modelu usługi Databricks Foundation w języku LangChain jako modelu osadzania, zaimportuj klasę DatabricksEmbeddings i określ endpoint parametr w następujący sposób:

from langchain.embeddings import DatabricksEmbeddings

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

SQL

Ważne


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

Poniżej przedstawiono oczekiwany format żądania dla modelu osadzania. W przypadku modeli zewnętrznych można uwzględnić dodatkowe parametry, które są prawidłowe dla danego dostawcy i konfiguracji punktu końcowego. Zobacz Dodatkowe parametry zapytania.


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

Poniżej przedstawiono oczekiwany format odpowiedzi:

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

Wykonywanie zapytań względem modelu uzupełniania tekstu

Poniżej przedstawiono żądanie ukończenia dla modelu udostępnionego databricks-mpt-30b-instruct przez interfejsy API modelu foundation. Aby uzyskać parametry i składnię, zobacz Zadanie ukończenia.

Klient OpenAI


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
)

Interfejs API REST

Ważne


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

Zestaw SDK wdrożeń MLflow

Ważne

W poniższym przykładzie użyto interfejsu predict() API z zestawu SDK wdrożeń MLflow.


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-mpt-30b-instruct",
    inputs={
        "prompt": "What is the capital of France?",
        "temperature": 0.1,
        "max_tokens": 10,
        "n": 2
    }
)

# Print the response
print(completions_response)

Databricks GenAI SDK

import os
from databricks_genai_inference import Completion

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

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

Ważne

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

Poniżej przedstawiono oczekiwany format żądania dla modelu uzupełniania. W przypadku modeli zewnętrznych można uwzględnić dodatkowe parametry, które są prawidłowe dla danego dostawcy i konfiguracji punktu końcowego. Zobacz Dodatkowe parametry zapytania.

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

Poniżej przedstawiono oczekiwany format odpowiedzi:

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

Czat z obsługiwanymi maszynami LLM przy użyciu środowiska zabaw sztucznej inteligencji

Możesz wchodzić w interakcje z obsługiwanymi dużymi modelami językowymi przy użyciu narzędzia AI Playground. Plac zabaw dla sztucznej inteligencji to środowisko przypominające czat, w którym można testować, monitować i porównywać maszyny LLM z obszaru roboczego usługi Azure Databricks.

Plac zabaw dla sztucznej inteligencji

Udostępnij za pośrednictwem

Modele podstaw zapytań

Wymagania

Instalowanie pakietów

Klient OpenAI

Interfejs API REST

Zestaw SDK wdrożeń MLflow

Databricks GenAI SDK

Wykonywanie zapytań względem modelu uzupełniania czatu

Klient OpenAI

Interfejs API REST

Zestaw SDK wdrożeń MLflow

Databricks GenAI SDK

LangChain

SQL

Sesja rozmowy

Wykonywanie zapytań względem modelu osadzania

Klient OpenAI

Interfejs API REST

Zestaw SDK wdrożeń MLflow

Databricks GenAI SDK

LangChain

SQL

Wykonywanie zapytań względem modelu uzupełniania tekstu

Klient OpenAI

Interfejs API REST

Zestaw SDK wdrożeń MLflow

Databricks GenAI SDK

SQL

Czat z obsługiwanymi maszynami LLM przy użyciu środowiska zabaw sztucznej inteligencji

Dodatkowe zasoby

Opinia

Opinia

Dodatkowe zasoby