Consulta de modelos de IA generativa

En este artículo, aprenderá a dar formato a las solicitudes de consulta para los modelos de base y los modelos externos y a enviarlos al punto de conexión de servicio del modelo.

Para las solicitudes de consulta de modelos de ML o Python tradicionales, vea Consulta de puntos de conexión de servicio para modelos personalizados.

El servicio de modelos de Mosaic AI admite las API de modelos básicos y modelos externos para acceder a los modelos de IA generativa. El servicio de modelos usa una API y un SDK unificados compatibles con OpenAI para consultarlos. Esto permite experimentar con y personalizar modelos de IA generativa para producción en nubes y proveedores admitidos.

El servicio de modelos de Mosaic IA proporciona las siguientes opciones para enviar solicitudes de puntuación a puntos de conexión que sirven a modelos básicos o modelos externos:

Requisitos

• Un modelo de que sirve al punto de conexión.
• Un área de trabajo de Databricks en una región admitida.
  • Regiones de las API de Foundation Model
  • Regiones de modelos externos
• Para enviar una solicitud de puntuación a través del cliente de OpenAI, la API de REST o el SDK de implementación de MLflow, debe tener un token de API de Databricks.

Instalar paquetes

Después de seleccionar un método de consulta, primero debe instalar el paquete adecuado en el clúster.

Cliente OpenAI

Para usar el cliente de OpenAI, el paquete databricks-sdk[openai] debe instalarse en el clúster. El SDK de Databricks proporciona un contenedor para construir el cliente openAI con autorización configurada automáticamente para consultar modelos de IA generativos. Ejecute lo siguiente en el cuaderno o en el terminal local:

!pip install databricks-sdk[openai]

Lo siguiente solo es necesario al instalar el paquete en un cuaderno de Databricks

dbutils.library.restartPython()

REST API

El acceso a la API de REST de servicio está disponible en Databricks Runtime para Machine Learning.

SDK de implementaciones de MLflow

!pip install mlflow

Lo siguiente solo es necesario al instalar el paquete en un cuaderno de Databricks

dbutils.library.restartPython()

SDK de Python en Databricks

El SDK de Databricks para Python ya está instalado en todos los clústeres de Azure Databricks que usan Databricks Runtime 13.3 LTS o una versión superior. Para los clústeres de Azure Databricks que usan Databricks Runtime 12.2 LTS y versiones posteriores, primero debe instalar el SDK de Databricks para Python. Consulte SDK de Databricks para Python.

Consultar un modelo de finalización de chat

A continuación se muestran ejemplos para consultar un modelo de chat. El ejemplo se aplica a la consulta de un modelo de chat que está disponible mediante las funcionalidades del servicio de modelos: API de modelos básicos o modelos externos.

Para obtener un ejemplo de inferencia por lotes, consulte Inferencia por lotes mediante el rendimiento aprovisionado de las API de Foundation Model.

Cliente OpenAI

A continuación se muestra una solicitud de chat para el modelo DBRX Instruct que las API de Foundation Model han puesto a disposición del punto de conexión de pago por token, databricks-dbrx-instruct en el área de trabajo.

Para usar el cliente OpenAI, especifique el nombre del punto de conexión de servicio del modelo como la entrada model.

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
)

Para consultar modelos de base fuera del área de trabajo, debe usar directamente el cliente openAI. También necesitará su instancia de área de trabajo de Databricks para conectar el cliente de OpenAI a Databricks. En el ejemplo siguiente se supone que tiene un token de API de Databricks e openai instalado en el proceso.

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

A continuación se muestra una solicitud de chat para el modelo DBRX Instruct que las API de Foundation Model han puesto a disposición del punto de conexión de pago por token, databricks-dbrx-instruct en el área de trabajo.

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 \

SDK de implementaciones de MLflow

A continuación se muestra una solicitud de chat para el modelo DBRX Instruct que las API de Foundation Model han puesto a disposición del punto de conexión de pago por token, databricks-dbrx-instruct en el área de trabajo.

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

SDK de Python en Databricks

A continuación se muestra una solicitud de chat para el modelo DBRX Instruct que las API de Foundation Model han puesto a disposición del punto de conexión de pago por token, databricks-dbrx-instruct en el área de trabajo.

Este código debe ejecutarse en un cuaderno del área de trabajo. Consulte Uso del SDK de Databricks para Python desde un cuaderno de 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

Para consultar un punto de conexión de modelo de base mediante LangChain, puede usar la clase ChatDatabricks ChatModel y especificar endpoint.

En el ejemplo siguiente se usa la clase ChatModel ChatDatabricks en LangChain para consultar el punto de conexión de pago por token de las API de Foundation Model, databricks-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

La siguiente es una solicitud de chat para meta-llama-3-1-70b-instruct puesta a disposición por el punto de conexión de pago por token de las API de Foundation Model, databricks-meta-llama-3-1-70b-instruct en su área de trabajo.

SELECT ai_query(
    "databricks-meta-llama-3-1-70b-instruct",
    "Can you explain AI in ten words?"
  )

A modo de ejemplo, a continuación se muestra el formato de solicitud esperado para un modelo de chat cuando se usa la API de REST. En el caso de los modelos externos, puede incluir parámetros adicionales válidos para una configuración de punto de conexión y proveedor determinada. Consulte parámetros de consulta adicionales.

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

A continuación se muestra un formato de respuesta esperado para una solicitud realizada mediante la API de 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
}

Consultar un modelo de inserción

A continuación se muestra una solicitud de inserciones para el modelo gte-large-en facilitada por las API de Foundation Model. El ejemplo se aplica a la consulta de un modelo de inserción que está disponible mediante las funcionalidades del servicio de modelos: API de modelos básicos o modelos externos.

Cliente OpenAI

Para usar el cliente OpenAI, especifique el nombre del punto de conexión de servicio del modelo como la entrada model.

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

Para consultar modelos de base fuera del área de trabajo, debe usar directamente el cliente de OpenAI, como se muestra a continuación. En el ejemplo siguiente se supone que tiene un token de API de Databricks y openai instalado en el proceso. También necesitará su instancia de área de trabajo de Databricks para conectar el cliente de OpenAI a 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"
)

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-gte-large-en/invocations

SDK de implementaciones de 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"
    }
)

SDK de Python en Databricks

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

Para usar un modelo de API de Modelo de Databricks Foundation en LangChain como modelo de inserción, importe la clase DatabricksEmbeddings y especifique el parámetro endpoint de la siguiente manera:

%pip install langchain-databricks

from langchain_databricks import DatabricksEmbeddings

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

SQL

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

A continuación se muestra el formato de solicitud esperado para un modelo de inserción. En el caso de los modelos externos, puede incluir parámetros adicionales válidos para una configuración de punto de conexión y proveedor determinada. Consulte parámetros de consulta adicionales.

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

A continuación se muestra el formato de respuesta esperado:

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

Compruebe si las incrustaciones están normalizadas

Use lo siguiente para comprobar si se normalizan las incrustaciones generadas por el modelo.

  import numpy as np

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

Consultar un modelo de finalización de texto

Cliente OpenAI

Para usar el cliente OpenAI, especifique el nombre del punto de conexión de servicio del modelo como la entrada model. En el ejemplo siguiente se consulta el modelo de finalizaciones de claude-2 que hospeda Anthropic mediante el cliente de OpenAI. Para usar el cliente de OpenAI, rellene el campo model con el nombre del punto de conexión de servicio del modelo que hospeda el modelo que quiere consultar.

En este ejemplo se usa un punto de conexión creado anteriormente, anthropic-completions-endpoint, configurado para acceder a modelos externos desde el proveedor de modelos de Anthropic. Vea cómo crear puntos de conexión de modelo externos.

Vea Modelos admitidos para obtener modelos adicionales que pueda consultar y sus proveedores.

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)

REST API

A continuación se muestra una solicitud de finalización para consultar un modelo de finalizaciones que está disponible mediante modelos externos.

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

SDK de implementaciones de MLflow

A continuación se muestra una solicitud de finalización para consultar un modelo de finalizaciones que está disponible mediante modelos externos.

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)

SDK de Python en Databricks

A continuación se muestra una solicitud de finalización para consultar un modelo de finalizaciones que está disponible mediante modelos externos.

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

SELECT ai_query(
    "<completions-model-endpoint>",
    "Can you explain AI in ten words?"
  )

A continuación se muestra el formato de solicitud esperado para un modelo de finalizaciones. En el caso de los modelos externos, puede incluir parámetros adicionales válidos para una configuración de punto de conexión y proveedor determinada. Consulte parámetros de consulta adicionales.

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

A continuación se muestra el formato de respuesta esperado:

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

Chat con los LLM admitidos con AI Playground

Puede interactuar con modelos de lenguaje grandes compatibles mediante AI Playground. AI Playground es un entorno similar al chat en el que puede probar, preguntar y comparar los LLM desde el área de trabajo de Azure Databricks.

Recursos adicionales

• Tablas de inferencia para supervisar y depurar modelos
• Inferencia por lotes mediante el rendimiento aprovisionado de las API de Foundation Model
• API de modelo de Databricks Foundation
• Modelos externos en Servicio de modelos de Mosaic AI
• Tutorial: Creación de puntos de conexión de modelo externos para consultar modelos de OpenAI
• Modelos admitidos para el pago por token
• Referencia de las API REST de Foundation Model