Udostępnij za pośrednictwem

Generowanie zapytań dla modeli sztucznej inteligencji

  • Artykuł

Z tego artykułu dowiesz się, jak formatować żądania zapytań dla modeli podstawowych i modeli zewnętrznych oraz 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.

Usługa Mosaic AI Model Serving obsługuje interfejsy API modeli podstawowych i modele zewnętrzne na potrzeby uzyskiwania dostępu do modeli generacyjnych sztucznej inteligencji. Obsługa modelu używa ujednoliconego interfejsu API zgodnego z interfejsem OpenAI i zestawu SDK do wykonywania zapytań. Dzięki temu można eksperymentować z modelami sztucznej inteligencji i dostosowywać je do produkcji w obsługiwanych chmurach i dostawcach.

Obsługa modelu mozaiki sztucznej inteligencji udostępnia następujące opcje wysyłania żądań oceniania do punktów końcowych obsługujących modele podstawowe lub modele zewnętrzne:

Metoda Szczegóły
Klient OpenAI Wykonywanie zapytań względem modelu hostowanego przez punkt końcowy obsługi modelu sztucznej inteligencji mozaiki 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 Python SDK Zestaw SDK języka Python usługi Databricks to warstwa interfejsu API REST. Obsługuje on szczegóły niskiego poziomu, takie jak uwierzytelnianie, co ułatwia interakcję z modelami.
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

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, databricks-sdk[openai] pakiet należy zainstalować w klastrze. Zestaw SDK usługi Databricks udostępnia otokę do konstruowania klienta OpenAI z autoryzacją automatycznie skonfigurowaną do tworzenia zapytań dotyczących modeli sztucznej inteligencji generujących zapytania. Uruchom następujące polecenie w notesie lub w terminalu lokalnym:

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

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

Zestaw SDK usługi Databricks dla języka Python jest już zainstalowany we wszystkich klastrach usługi Azure Databricks korzystających z środowiska Databricks Runtime 13.3 LTS lub nowszego. W przypadku klastrów usługi Azure Databricks korzystających z środowiska Databricks Runtime 12.2 LTS i poniżej należy najpierw zainstalować zestaw SDK usługi Databricks dla języka Python. Zobacz Zestaw SDK usługi Databricks dla języka Python.

Wykonywanie zapytań względem modelu uzupełniania czatu

Poniżej przedstawiono przykłady wykonywania zapytań dotyczących modelu czatu. Przykład dotyczy wykonywania zapytań względem modelu czatu udostępnionego przy użyciu jednej z funkcji obsługi modelu: podstawowe interfejsy API modelu lub modele zewnętrzne.

Aby zapoznać się z przykładem wnioskowania wsadowego, zobacz Wnioskowanie wsadowe przy użyciu aprowizowanych przepływności 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.


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
)

Aby wykonywać zapytania dotyczące modeli podstawowych poza obszarem roboczym, należy bezpośrednio użyć klienta OpenAI. Potrzebujesz również wystąpienia obszaru roboczego usługi Databricks, aby połączyć klienta OpenAI z usługą Databricks. W poniższym przykładzie przyjęto założenie, że masz token interfejsu API usługi Databricks i openai zainstalowano go na obliczeniach.


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

Ten kod musi być uruchamiany w notesie w obszarze roboczym. Zobacz Używanie zestawu SDK usługi Databricks dla języka Python z notesu usługi 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

Aby wykonać zapytanie dotyczące punktu końcowego modelu podstawowego przy użyciu biblioteki LangChain, możesz użyć klasy ChatDatabricks ChatModel i określić wartość endpoint.

W poniższym przykładzie ChatDatabricks użyto klasy ChatModel w usłudze LangChain do wykonywania zapytań względem punktów końcowych modelu modelu foundation pay-per-token. databricks-dbrx-instruct

%pip install databricks-langchain

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

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 meta-llama-3-1-70b-instruct udostępnionego przez interfejsy API modelu foundation w punkcie końcowym databricks-meta-llama-3-1-70b-instruct 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-meta-llama-3-1-70b-instruct",
    "Can you explain AI in ten words?"
  )

Na przykład poniżej przedstawiono oczekiwany format żądania dla modelu czatu podczas korzystania z interfejsu API REST. 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 dla żądania wykonanego przy użyciu interfejsu API REST:

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

Wykonywanie zapytań względem modelu osadzania

Poniżej przedstawiono żądanie osadzania dla modelu udostępnionego gte-large-en przez interfejsy API modelu Foundation Model. Przykład dotyczy wykonywania zapytań względem modelu osadzania udostępnionego przy użyciu jednej z funkcji obsługujących model: podstawowe interfejsy API modelu lub modele zewnętrzne.

Klient OpenAI

Aby użyć klienta OpenAI, określ model obsługujący nazwę punktu końcowego model jako dane wejściowe.


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

Aby wykonywać zapytania dotyczące modeli podstawowych poza obszarem roboczym, należy użyć klienta OpenAI bezpośrednio, jak pokazano poniżej. W poniższym przykładzie założono, że masz token interfejsu API usługi Databricks i oprogramowanie openai zainstalowane 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.embeddings.create(
  model="databricks-gte-large-en",
  input="what is databricks"
)

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 lub modele zewnętrzne. Te parametry są publiczną wersją zapoznawcza , a definicja może ulec zmianie. Zobacz 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

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

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

%pip install databricks-langchain

from langchain_databricks import DatabricksEmbeddings

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

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().


SELECT ai_query(
    "databricks-gte-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
  }
}

Sprawdzanie, czy osadzanie jest znormalizowane

Użyj poniższej instrukcji, aby sprawdzić, czy osadzanie wygenerowane przez model jest znormalizowane.


  import numpy as np

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

Wykonywanie zapytań względem modelu uzupełniania tekstu

Klient OpenAI

Ważne

Wykonywanie zapytań dotyczących modeli uzupełniania tekstu udostępnionych przy użyciu interfejsów API modelu foundation pay-per-token przy użyciu klienta OpenAI nie jest obsługiwane. Wykonywanie zapytań dotyczących modeli zewnętrznych przy użyciu klienta OpenAI jest obsługiwane zgodnie z opisem w tej sekcji.

Aby użyć klienta OpenAI, określ model obsługujący nazwę punktu końcowego model jako dane wejściowe. Poniższy przykład wykonuje zapytanie dotyczące claude-2 modelu uzupełniania hostowanego przez platformę Anthropic przy użyciu klienta OpenAI. Aby użyć klienta OpenAI, wypełnij model pole nazwą punktu końcowego obsługującego model, który hostuje model, którego chcesz wykonać zapytanie.

W tym przykładzie użyto wcześniej utworzonego punktu końcowego , anthropic-completions-endpointskonfigurowanego do uzyskiwania dostępu do modeli zewnętrznych od dostawcy modelu antropicznego. Zobacz, jak tworzyć punkty końcowe modelu zewnętrznego.

Zobacz Obsługiwane modele, aby uzyskać dodatkowe modele , dla których można wykonywać zapytania i ich dostawców.


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)

Interfejs API REST

Poniżej przedstawiono żądanie ukończenia zapytania dotyczącego modelu uzupełniania udostępnionego przy użyciu modeli zewnętrznych.

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 zewnętrzne. Te parametry są publiczną wersją zapoznawcza , a definicja może ulec zmianie. Zobacz 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

Zestaw SDK wdrożeń MLflow

Poniżej przedstawiono żądanie ukończenia zapytania dotyczącego modelu uzupełniania udostępnionego przy użyciu modeli zewnętrznych.

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

T Poniżej znajduje się żądanie ukończenia zapytania dotyczącego modelu uzupełniania udostępnionego przy użyciu modeli zewnętrznych.

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

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().

SELECT ai_query(
    "<completions-model-endpoint>",
    "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

Dodatkowe zasoby