Pular para o conteúdo principal

Colete feedback de especialistas do domínio

Uma das maneiras mais eficazes de aprimorar seu aplicativo GenAI é fazer com que os especialistas no domínio revisem e rotulem os traços existentes. O aplicativo de revisão do MLflow oferece um processo estruturado para coletar esse feedback de especialistas sobre interações reais com seu aplicativo.

Revise a imagem prévia do herói do aplicativo.

Pré-requisitos​

  • Seu ambiente de desenvolvimento está conectado à ExperiênciaMLflow, onde os traços do aplicativo GenAI são registros.

  • Seus especialistas de domínio devem ter acesso ao site Databricks workspace que contém a Experiência MLflow.

nota

O recurso descrito neste guia requer o site MLflow versão 3.1.0 ou superior.

Execute o seguinte comando para instalar ou atualizar o MLflow SDK, incluindo os extras necessários para a integração do Databricks:

Bash
pip install --upgrade "mlflow[databricks]>=3.1.0" openai

Visão geral​

Etapa 1: criar um aplicativo com o Tracing​

Antes de coletar feedback, o senhor precisa ter registros de rastreamento do seu aplicativo GenAI. Esses rastreamentos capturam as entradas, saídas e etapas intermediárias da execução do seu aplicativo, incluindo qualquer chamada de ferramenta ou ação de recuperação.

abaixo é um exemplo de como o senhor pode log traces. Este exemplo inclui um recuperador falso para que possamos ilustrar como os documentos recuperados nos rastreamentos são renderizados no aplicativo Review. Consulte a visão geral do Review App para obter mais informações sobre como o Review App renderiza traces.

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

# Enable auto instrumentation for OpenAI SDK
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"
)

# Spans of type RETRIEVER are rendered in the Review App as documents.
@mlflow.trace(span_type="RETRIEVER")
def retrieve_docs(query: str) -> List[Document]:
    normalized_query = query.lower()
    if "john doe" in normalized_query:
        return [
            Document(
                id="conversation_123",
                page_content="John Doe mentioned issues with login on July 10th. Expressed interest in feature X.",
                metadata={"doc_uri": "http://domain.com/conversations/123"},
            ),
            Document(
                id="conversation_124",
                page_content="Follow-up call with John Doe on July 12th. Login issue resolved. Discussed pricing for feature X.",
                metadata={"doc_uri": "http://domain.com/conversations/124"},
            ),
        ]
    else:
        return [
            Document(
                id="ticket_987",
                page_content="Acme Corp raised a critical P0 bug regarding their main dashboard on July 15th.",
                metadata={"doc_uri": "http://domain.com/tickets/987"},
            )
        ]

# Sample app that we will review traces from
@mlflow.trace
def my_app(messages: List[Dict[str, str]]):
    # 1. Retrieve conversations based on the last user message
    last_user_message_content = messages[-1]["content"]
    retrieved_documents = retrieve_docs(query=last_user_message_content)
    retrieved_docs_text = "\n".join([doc.page_content for doc in retrieved_documents])

    # 2. Prepare messages for the LLM
    messages_for_llm = [
        {"role": "system", "content": "You are a helpful assistant!"},
        {
            "role": "user",
            "content": f"Additional retrieved context:\n{retrieved_docs_text}\n\nNow, please provide the one-paragraph summary based on the user's request {last_user_message_content} and this retrieved context.",
        },
    ]

    # 3. Call LLM to generate the summary
    return 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=messages_for_llm,
    )

Etapa 2: Definir esquemas de rótulos​

Os esquemas de rótulo definem as perguntas e os tipos de entrada que os especialistas de domínio usarão para fornecer feedback sobre seus traços. O senhor pode usar os esquemas integrados do MLflow ou criar esquemas personalizados adaptados aos seus critérios de avaliação específicos.

Há dois tipos principais de esquemas de rótulos:

  • Tipo de expectativa (type="expectation") : Usado quando o especialista fornece uma verdade básica " " ou uma resposta correta. Por exemplo, fornecer o expected_facts para a resposta de um sistema RAG. Esses rótulos geralmente podem ser usados diretamente no conjunto de dados de avaliação.
  • Tipo de feedback (type="feedback") : usado para avaliações, classificações ou classificações subjetivas. Por exemplo, classificar uma resposta em uma escala de 1 a 5 quanto à polidez, ou classificar se uma resposta atende a determinados critérios.

Consulte a documentação do rótulo Schemas para entender os vários métodos de entrada para seus esquemas, como opções categóricas (botões de opção), escala numérica ou texto de forma livre.

Python

from mlflow.genai.label_schemas import create_label_schema, InputCategorical, InputText

# Collect feedback on the summary
summary_quality = create_label_schema(
    name="summary_quality",
    type="feedback",
    title="Is this summary concise and helpful?",
    input=InputCategorical(options=["Yes", "No"]),
    instruction="Please provide a rationale below.",
    enable_comment=True,
    overwrite=True,
)

# Collect a ground truth summary
expected_summary = create_label_schema(
    name="expected_summary",
    type="expectation",
    title="Please provide the correct summary for the user's request.",
    input=InputText(),
    overwrite=True,
)

Etapa 3: Criar uma sessão de rótulo​

Um rótulo Session é um tipo especial de MLflow execução que organiza um conjunto de traços para revisão por especialistas específicos usando esquemas de rótulos selecionados. Ele funciona como uma fila para o processo de revisão.

Consulte a documentação do rótulo Session para obter mais detalhes.

Veja como criar uma sessão de rótulo:

Python
from mlflow.genai.labeling import create_labeling_session

# Create the Labeling Session with the schemas we created in the previous step
label_summaries = create_labeling_session(
    name="label_summaries",
    assigned_users=[],
    label_schemas=[summary_quality.name, expected_summary.name],
)

Etapa 4: Gerar traços e adicionar ao rótulo Session​

Depois que a sessão do rótulo for criada, o senhor precisará adicionar traços a ela. Os rastros são copiados para a sessão de rótulo, portanto, qualquer rótulo ou modificação feita durante o processo de revisão não afeta os rastros originais dos registros.

O senhor pode adicionar qualquer traço em seu experimento MLflow. Consulte a documentação do rótulo Session para obter mais detalhes.

nota

Depois que os traços forem gerados, o senhor também poderá adicioná-los ao rótulo Session selecionando os traços no site Trace tab, clicando em Export Traces e, em seguida, selecionando o rótulo Session que criou acima.

Python
import mlflow

# Use verison tracking to be able to easily query for the traces
tracked_model = mlflow.set_active_model(name="my_app")

# Run the app to generate traces
sample_messages_1 = [
    {"role": "user", "content": "what issues does john doe have?"},
]
summary1_output = my_app(sample_messages_1)

sample_messages_2 = [
    {"role": "user", "content": "what issues does acme corp have?"},
]
summary2_output = my_app(sample_messages_2)

# Query for the traces we just generated
traces = mlflow.search_traces(model_id=tracked_model.model_id)

# Add the traces to the session
label_summaries.add_traces(traces)

# Print the URL to share with your domain experts
print(f"Share this Review App with your team: {label_summaries.url}")

Etapa 5: compartilhe o aplicativo de avaliação com especialistas​

Depois que a sessão de rótulo for preenchida com traços, o senhor poderá compartilhar o URL com os especialistas do domínio. Eles podem usar esse URL para acessar o Review App, view os traços atribuídos a eles (ou escolher entre os não atribuídos) e fornecer feedback usando os esquemas de rótulo que o senhor configurou.

important

Seus especialistas de domínio precisam ter acesso ao Databricks Workspace e WRITE permissões para o MLflow Experiment.

Etapa 6: visualizar e usar o rótulo coletado​

Depois que os especialistas de domínio concluírem suas análises, o feedback coletado será anexado aos traços na sessão de rótulo. O senhor pode recuperar esses rótulos programaticamente para analisá-los ou usá-los para criar um conjunto de dados de avaliação.

rótulo são armazenados como objetos Assessment em cada Trace dentro da rótulo Session.

Usar a interface de usuário do MLflow​

Para analisar os resultados, navegue até o experimento MLflow.

Resultados da coleta de feedback na interface de usuário do MLflow

Use o SDK do MLflow​

O código a seguir busca todos os rastros da execução da sessão do rótulo e extrai as avaliações (rótulo) em um Pandas DataFrame para facilitar a análise.

Python
labeled_traces_df = mlflow.search_traces(run_id=label_summaries.mlflow_run_id)

Exemplo de notebook​

O Notebook a seguir inclui todo o código desta página.

Coletar feedback de especialistas no domínio Notebook

Open notebook in new tab

Próximas etapas​

Conversão para o conjunto de dados de avaliação​

O rótulo do tipo "expectation" (como o expected_summary do nosso exemplo) é particularmente útil para criar o conjunto de dados de avaliação. Esses conjuntos de dados podem ser usados com o site mlflow.genai.evaluate() para testar sistematicamente novas versões do seu aplicativo GenAI em relação à verdade básica definida por especialistas.

Última atualização em