Partager via

Interroger les modèles de fondation

  • Article

Dans cet article, vous allez découvrir comment mettre en forme les requêtes pour les modèles de fondation et les envoyer à votre point de terminaison de mise en service de modèle.

Pour les requêtes portant sur des modèles Machine Learning ou Python traditionnels, consultez Mise en service de points de terminaison des requêtes pour les modèles personnalisés.

Le Service de modèles Databricks prend en charge les API de modèles de fondation et les modèles externes pour accéder aux modèles de fondation et utilise une API et un Kit de développement logiciel (SDK) unifiés et compatibles avec l’OpenAI pour les interroger. Ceci permet d’expérimenter et de personnaliser des modèles de fondation pour la production pour des clouds et des fournisseurs pris en charge.

Le Service de modèles Databricks propose les options suivantes pour envoyer des requêtes de notation aux modèles de fondation :

Méthode Détails
Client OpenAI Interrogez un modèle hébergé par un point de terminaison de service de modèle Databricks en utilisant le client OpenAI. Spécifiez le nom du point de terminaison de service de modèle comme entrée du model. Pris en charge pour les modèles de conversation, d’incorporation et de complétion rendus disponibles par des API de modèle de fondation ou des modèles externes.
Interface utilisateur de service Dans la page Point de terminaison de service, sélectionnez Interroger le point de terminaison. Insérez les données d’entrée du modèle au format JSON, puis cliquez sur Envoyer la requête. Si le modèle a un exemple d’entrée enregistré, utilisez Afficher l’exemple pour le charger.
API REST Appelez et interrogez le modèle en utilisant l’API REST. Pour plus de détails, consultez POST /serving-endpoints/{name}/invocations. Pour les requêtes de scoring adressées aux points de terminaison servant plusieurs modèles, consultez Interroger des modèles individuels derrière un point de terminaison.
Kit de développement logiciel (SDK) de déploiements MLflow Utilisez la fonction predict() du Kit de développement logiciel (SDK) Déploiements MLflow pour interroger le modèle.
Kit de développement logiciel (SDK) GenAI de Databricks Le Kit de développement logiciel (SDK) GenAI de Databricks est une couche supérieure à l’API REST. Il gère les détails de bas niveau, tels que les ID de modèle d’authentification et de mappage aux URL de point de terminaison, ce qui facilite l’interaction avec les modèles. Le Kit de développement logiciel (SDK) est conçu pour être utilisé à partir de notebooks Databricks.
Fonction SQL Appelez l’inférence de modèle directement à partir de SQL à l’aide de la fonction SQL ai_query. Voir Interroger un modèle servi avec ai_query().

Exigences

Important

À titre de meilleure pratique de sécurité pour les scénarios de production, Databricks vous recommande d’utiliser des jetons OAuth machine à machine pour l’authentification en production.

Pour les tests et le développement, Databricks recommande d’utiliser un jeton d’accès personnel appartenant à des principaux de service et non pas à des utilisateurs de l’espace de travail. Pour créer des jetons d’accès pour des principaux de service, consultez la section Gérer les jetons pour un principal de service.

Installer des packages

Après avoir sélectionné une méthode d’interrogation, vous devez d’abord installer le package approprié sur votre cluster.

Client OpenAI

Pour utiliser le client OpenAI, le package openai doit être installé sur votre cluster. Exécutez la commande suivante dans votre Notebook ou dans votre terminal local :

!pip install openai

Les éléments suivants ne sont nécessaires que lors de l’installation du package sur un Notebook Databricks

dbutils.library.restartPython()

API REST

L’accès à l’API REST de service est disponible dans le Runtime Databricks pour Machine Learning.

Kit SDK de déploiements MLflow

!pip install mlflow

Les éléments suivants ne sont nécessaires que lors de l’installation du package sur un Notebook Databricks

dbutils.library.restartPython()

Kit de développement logiciel (SDK) GenAI de Databricks

 !pip install databricks-genai

Les éléments suivants ne sont nécessaires que lors de l’installation du package sur un Notebook Databricks

 dbutils.library.restartPython()

Interroger un modèle de saisie semi-automatique de conversation

Voici des exemples d’interrogation d’un modèle de conversation.

Pour obtenir un exemple d’inférence par lots, consultez Inférence par lots en utilisant des API Foundation Model.

Client OpenAI

Voici une demande de conversation pour le modèle DBRX Instruct mis à disposition par le point de terminaison avec paiement par jeton des API Foundation Model, databricks-dbrx-instruct dans votre espace de travail.

Pour utiliser le client OpenAI, spécifiez le nom du point de terminaison de service du modèle comme entrée du model. L’exemple suivant suppose que vous disposez d’un jeton d’API Databricks et que openai est installé sur votre calcul. Vous avez également besoin de votre instance d’espace de travail Databricks pour connecter le client OpenAI à 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
)

API REST

Important

L’exemple suivant utilise des paramètres d’API REST pour interroger des points de terminaison de service qui servent des modèles de base. Ces paramètres sont en préversion publique, et la définition est susceptible de changer. Consultez POST /serving-endpoints/{name}/invocations.

Voici une demande de conversation pour le modèle DBRX Instruct mis à disposition par le point de terminaison avec paiement par jeton des API Foundation Model, databricks-dbrx-instruct dans votre espace de travail.

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 \

Kit SDK de déploiements MLflow

Important

L’exemple suivant utilise l’API predict() à partir du Kit SDK de déploiements MLflow.

Voici une demande de conversation pour le modèle DBRX Instruct mis à disposition par le point de terminaison avec paiement par jeton des API Foundation Model, databricks-dbrx-instruct dans votre espace de travail.


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

Kit de développement logiciel (SDK) GenAI de Databricks

Voici une demande de conversation pour le modèle DBRX Instruct mis à disposition par le point de terminaison avec paiement par jeton des API Foundation Model, databricks-dbrx-instruct dans votre espace de travail.

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

Pour interroger un point de terminaison du modèle de fondation à l’aide de LangChain, vous pouvez procéder de l’une ou l’autre des manières suivantes :

  • Importez la classe LLM Databricks et spécifiez les endpoint_name et les transform_input_fn.
  • Importez la classe ChatModel ChatDatabricks et spécifiez la endpoint.

L’exemple suivant utilise la classe LLM Databricks dans LangChain pour interroger databricks-dbrx-instruct, le point de terminaison de paiement par jeton de l’API Foundation Model. Les API Foundation Model attendent messages dans le dictionnaire de requêtes, tandis que LangChain Databricks LLM fournit par défaut prompt dans le dictionnaire de requêtes. Utilisez la fonction transform_input pour préparer le dictionnaire de requêtes au format attendu.

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

L’exemple suivant utilise la classe ChatModel ChatDatabricks et spécifie la 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

Important

L’exemple suivant utilise la fonction SQL intégrée, ai_query. Cette fonction est en préversion publique et sa définition est susceptible de changer. Voir Interroger un modèle servi avec ai_query().

Voici une demande de conversation pour llama-2-70b-chat, mis à disposition par le point de terminaison avec paiement par jeton des API Foundation Model, databricks-llama-2-70b-chat dans votre espace de travail.

Remarque

La fonction ai_query() ne prend pas en charge les points de terminaison de requête qui servent le modèle DBRX ou DBRX Instruct.

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

Voici le format de requête attendu pour un modèle de conversation. Pour les modèles externes, vous pouvez inclure des paramètres supplémentaires valides pour une configuration de fournisseur et de point de terminaison donnée. Consultez Paramètres de requête supplémentaires.

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

Voici un format de réponse attendu :

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

Session de conversation instantanée

Le Kit de développement logiciel (SDK) GenAI de Databricks fournit une classe ChatSession pour gérer les conversations à plusieurs tours. Il propose les fonctions suivantes :

Fonction Renvoie Description
reply (string) Prend un nouveau message utilisateur
last string Dernier message de l’Assistant
history liste des dicts Messages dans l’historique des conversations, y compris les rôles.
count int Nombre de rondes de conversation effectuées jusqu’à présent.

Pour initialiser ChatSession, vous utilisez le même jeu d’arguments que ChatCompletion, et ces arguments sont utilisés dans la session de conversation.


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

Interroger un modèle d’incorporations

Voici une requête d’incorporation pour le modèle bge-large-en mis à disposition par les API Foundation Model.

Client OpenAI

Pour utiliser le client OpenAI, spécifiez le nom du point de terminaison de service du modèle comme entrée du model. L’exemple suivant suppose que vous disposez d’un jeton d’API Databricks et que openai est installé sur votre cluster.


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

API REST

Important

L’exemple suivant utilise des paramètres d’API REST pour interroger des points de terminaison de service qui servent des modèles de base. Ces paramètres sont en préversion publique, et la définition est susceptible de changer. Consultez 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

Kit SDK de déploiements MLflow

Important

L’exemple suivant utilise l’API predict() à partir du Kit SDK de déploiements 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"
    }
)

Kit de développement logiciel (SDK) GenAI de Databricks


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

Pour utiliser un modèle d’API Databricks Foundation Model dans LangChain en tant que modèle d’intégration, importez la classe DatabricksEmbeddings et spécifiez le paramètre endpoint de la manière suivante :

from langchain.embeddings import DatabricksEmbeddings

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

SQL

Important

L’exemple suivant utilise la fonction SQL intégrée, ai_query. Cette fonction est en préversion publique et sa définition est susceptible de changer. Voir Interroger un modèle servi avec ai_query().


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

Voici le format de requête attendu pour un modèle d’incorporations. Pour les modèles externes, vous pouvez inclure des paramètres supplémentaires valides pour une configuration de fournisseur et de point de terminaison donnée. Consultez Paramètres de requête supplémentaires.


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

Voici le format de réponse attendu :

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

Interroger un modèle de saisie semi-automatique de texte

L'exemple suivant est une requête de complétion pour le modèle databricks-mpt-30b-instructmis à disposition par les API Foundation Model. Pour connaître les paramètres et la syntaxe, consultez Tâche d’achèvement.

Client OpenAI

Pour utiliser le client OpenAI, spécifiez le nom du point de terminaison de service du modèle comme entrée du model. L’exemple suivant suppose que vous disposez d’un jeton d’API Databricks et que openai est installé sur votre cluster.


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
)

API REST

Important

L’exemple suivant utilise des paramètres d’API REST pour interroger des points de terminaison de service qui servent des modèles de base. Ces paramètres sont en préversion publique, et la définition est susceptible de changer. Consultez 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

Kit SDK de déploiements MLflow

Important

L’exemple suivant utilise l’API predict() à partir du Kit SDK de déploiements MLflow.


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

Kit de développement logiciel (SDK) GenAI de Databricks


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

Important

L’exemple suivant utilise la fonction SQL intégrée, ai_query. Cette fonction est en préversion publique et sa définition est susceptible de changer. Voir Interroger un modèle servi avec ai_query().

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

Voici le format de requête attendu pour un modèle d’achèvement. Pour les modèles externes, vous pouvez inclure des paramètres supplémentaires valides pour une configuration de fournisseur et de point de terminaison donnée. Consultez Paramètres de requête supplémentaires.

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

Voici le format de réponse attendu :

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

Conversation avec des LLM pris en charge en utilisant AI Playground

Vous pouvez interagir avec des grands modèles de langage pris en charge en utilisant AI Playground. Le terrain de jeu de l’IA est un environnement de type conversation dans lequel vous pouvez tester, inviter et comparer des LLM à partir de votre espace de travail Azure Databricks.

Terrain de jeu IA

Ressources supplémentaires