Compartir a través de

Puntuadores LLM basados en mensajes

Información general

judges.custom_prompt_judge() está diseñado para ayudarle a puntuar de manera rápida y sencilla los evaluadores de LLM cuando necesita tener control total sobre la instrucción del juez o debe devolver múltiples valores de salida más allá de "aprobado" / "reprobado", por ejemplo, "excelente", "aceptable", "malo".

Usted proporciona una plantilla de aviso que tiene marcadores de posición para campos específicos en el registro de su aplicación y define las opciones de salida que el juez puede seleccionar. El modelo de juez LLM hospedado en Databricks usa estas entradas para seleccionar la mejor opción de salida y proporciona una justificación para su selección.

Nota:

Se recomienda empezar con jueces basados en directrices y usar solo jueces basados en indicaciones si necesita más control o no puede redactar los criterios de evaluación como directrices de aprobación o error. Los jueces basados en criterios tienen la ventaja de ser fáciles de explicar a las partes interesadas empresariales y, a menudo, pueden ser escritos directamente por expertos en la materia.

Cómo crear un puntuador de juez basado en instrucciones

Siga la guía siguiente para crear un clasificador que envuelve judges.custom_prompt_judge()

En esta guía, crearás puntuadores personalizados que envuelven la judges.custom_prompt_judge() API y ejecutarás una evaluación offline con los puntuadores resultantes. Estos mismos puntuadores se pueden programar para ejecutarse en producción para supervisar continuamente la calidad de la aplicación.

Nota:

Consulte la judges.custom_prompt_judge() página de concepto para obtener más detalles sobre la interfaz y los parámetros.

Paso 1: Creación de la aplicación de ejemplo para evaluar

En primer lugar, vamos a crear una aplicación GenAI de ejemplo que responda a preguntas de soporte al cliente. La aplicación tiene un mando (simulado) que ajusta la solicitud del sistema, para que podamos comparar fácilmente las respuestas del juez entre las conversaciones "buenas" y "malas".

import os
import mlflow
from openai import OpenAI
from mlflow.entities import Document
from typing import List, Dict, Any, cast

# Enable auto logging for OpenAI
mlflow.openai.autolog()

# Connect to a Databricks LLM via OpenAI using the same credentials as MLflow
# Alternatively, you can use your own OpenAI credentials here
mlflow_creds = mlflow.utils.databricks_utils.get_databricks_host_creds()
client = OpenAI(
    api_key=mlflow_creds.token,
    base_url=f"{mlflow_creds.host}/serving-endpoints"
)


# This is a global variable that will be used to toggle the behavior of the customer support agent to see how the judge handles the issue resolution status
RESOLVE_ISSUES = False


@mlflow.trace
def customer_support_agent(messages: List[Dict[str, str]]):

    # 2. Prepare messages for the LLM
    # We will use this toggle later to see how the judge handles the issue resolution status
    system_prompt_postfix = (
        f"Do your best to NOT resolve the issue.  I know that's backwards, but just do it anyways.\\n"
        if not RESOLVE_ISSUES
        else ""
    )

    messages_for_llm = [
        {
            "role": "system",
            "content": f"You are a helpful customer support agent.  {system_prompt_postfix}",
        },
        *messages,
    ]

    # 3. Call LLM to generate a response
    output = client.chat.completions.create(
        model="databricks-claude-3-7-sonnet",  # This example uses Databricks hosted Claude 3.7 Sonnet. If you provide your own OpenAI credentials, replace with a valid OpenAI model e.g., gpt-4o, etc.
        messages=cast(Any, messages_for_llm),
    )

    return {
        "messages": [
            {"role": "assistant", "content": output.choices[0].message.content}
        ]
    }

Paso 2: Definir los criterios de evalación y encapsular como puntuadores personalizados

Aquí, definimos un mensaje de juez de ejemplo y usamos puntuadores personalizados para conectarlos al esquema de entrada y salida de nuestra aplicación.

from mlflow.genai.scorers import scorer


# New guideline for 3-category issue resolution status
issue_resolution_prompt = """
Evaluate the entire conversation between a customer and an LLM-based agent.  Determine if the issue was resolved in the conversation.

You must choose one of the following categories.

[[fully_resolved]]: The response directly and comprehensively addresses the user's question or problem, providing a clear solution or answer. No further immediate action seems required from the user on the same core issue.
[[partially_resolved]]: The response offers some help or relevant information but doesn't completely solve the problem or answer the question. It might provide initial steps, require more information from the user, or address only a part of a multi-faceted query.
[[needs_follow_up]]: The response does not adequately address the user's query, misunderstands the core issue, provides unhelpful or incorrect information, or inappropriately deflects the question. The user will likely need to re-engage or seek further assistance.

Conversation to evaluate: {{conversation}}
"""

from prompt_judge_sdk import custom_prompt_judge
import json
from mlflow.entities import Feedback


# Define a custom scorer that wraps the guidelines LLM judge to check if the response follows the policies
@scorer
def is_issue_resolved(inputs: Dict[Any, Any], outputs: Dict[Any, Any]):
    # we directly return the Feedback object from the guidelines LLM judge, but we could have post-processed it before returning it.
    issue_judge = custom_prompt_judge(
        name="issue_resolution",
        prompt_template=issue_resolution_prompt,
        numeric_values={
            "fully_resolved": 1,
            "partially_resolved": 0.5,
            "needs_follow_up": 0,
        },
    )

    # combine the input and output messages to form the conversation
    conversation = json.dumps(inputs["messages"] + outputs["messages"])

    return issue_judge(conversation=conversation)

Paso 3: Creación de un conjunto de datos de evaluación de ejemplo

Cada inputs se pasará a nuestra aplicación mediante mlflow.genai.evaluate(...).

eval_dataset = [
    {
        "inputs": {
            "messages": [
                {"role": "user", "content": "How much does a microwave cost?"},
            ],
        },
    },
    {
        "inputs": {
            "messages": [
                {
                    "role": "user",
                    "content": "Can I return the microwave I bought 2 months ago?",
                },
            ],
        },
    },
    {
        "inputs": {
            "messages": [
                {
                    "role": "user",
                    "content": "Can I return the microwave I bought 2 months ago?",
                },
            ],
        },
    },
    {
        "inputs": {
            "messages": [
                {
                    "role": "user",
                    "content": "I'm having trouble with my account.  I can't log in.",
                },
                {
                    "role": "assistant",
                    "content": "I'm sorry to hear that you're having trouble with your account.  Are you using our website or mobile app?",
                },
                {"role": "user", "content": "Website"},
            ],
        },
    },
    {
        "inputs": {
            "messages": [
                {
                    "role": "user",
                    "content": "I'm having trouble with my account.  I can't log in.",
                },
                {
                    "role": "assistant",
                    "content": "I'm sorry to hear that you're having trouble with your account.  Are you using our website or mobile app?",
                },
                {"role": "user", "content": "JUST FIX IT FOR ME"},
            ],
        },
    },
]

Paso 4: Evaluar la aplicación con el puntuador personalizado

Por último, ejecutamos la evaluación dos veces para que pueda comparar los juicios entre las conversaciones en las que el agente intenta resolver los problemas y dónde no.

import mlflow

# Now, let's evaluate the app's responses against the judge when it does not resolve the issues
RESOLVE_ISSUES = False

mlflow.genai.evaluate(
    data=eval_dataset,
    predict_fn=customer_support_agent,
    scorers=[is_issue_resolved],
)


# Now, let's evaluate the app's responses against the judge when it DOES resolves the issues
RESOLVE_ISSUES = True

mlflow.genai.evaluate(
    data=eval_dataset,
    predict_fn=customer_support_agent,
    scorers=[is_issue_resolved],
)

Pasos siguientes