rótulo Sessões
rótulo As sessões oferecem uma maneira estruturada de obter feedback de especialistas no domínio sobre o comportamento de seus aplicativos GenAI. Um rótulo Session é um tipo especial de MLflow execução que contém um conjunto específico de traços que o senhor deseja que os especialistas de domínio revisem usando o aplicativo MLflow Review.
O objetivo de uma sessão de rótulos é coletar informações geradas por humanos sobre Assessments
(rótulo) em MLflow Traces existentes. Você pode capturar Feedback
ou Expectations
, que podem então ser usados para melhorar seu aplicativo GenAI por meio de uma avaliação sistemática.
Como um rótulo Session é uma execução MLflow, os dados coletados (traços e seus associados Assessments
) podem ser acessados programaticamente usando MLflow SDKs (por exemplo, mlflow.search_runs()
) e visualizados na interface do usuário MLflow - cada rótulo Session aparece em Evaluations tab.
Como funcionam as sessões de rótulo
Ao criar um rótulo Session, o senhor define:
- Nome : Um identificador descritivo para a sessão
- Usuários designados : Especialistas no domínio que fornecerão o rótulo
- Agente : (Opcional) O aplicativo GenAI para gerar respostas, se necessário
- rótulo Schemas : As perguntas e o formato para a coleta de feedback
- Bate-papo com várias voltas : Se o rótulo é compatível com o estilo de conversação
A sessão funciona como um contêiner para traços e seu rótulo associado, permitindo a coleta sistemática de feedback que pode impulsionar a avaliação e o fluxo de trabalho de melhoria.
Criação do rótulo Sessões
Use mlflow.genai.labeling.create_labeling_session()
para criar novas sessões com configurações específicas.
Criação de sessões por meio da interface do usuário
Navegue até o rótulo tab na UI MLflow para criar sessões visualmente. Isso proporciona uma interface intuitiva para definir parâmetros de sessão, atribuir usuários e selecionar esquemas de rótulos sem escrever código.
Visualizando sessões por meio da interface do usuário
Navegue até o rótulo tab na interface do usuário MLflow para view sessões visualmente.
Criando sessões programaticamente
Use o MLflow SDK para criar sessões com controle programático total sobre todas as opções de configuração.
Criação de sessão básica
import mlflow.genai.labeling as labeling
import mlflow.genai.label_schemas as schemas
# Create a simple labeling session with built-in schemas
session = labeling.create_labeling_session(
name="customer_service_review_jan_2024",
assigned_users=["alice@company.com", "bob@company.com"],
label_schemas=[schemas.EXPECTED_FACTS] # Required: at least one schema needed
)
print(f"Created session: {session.name}")
print(f"Session ID: {session.labeling_session_id}")
Os nomes das sessões do rótulo não têm garantia de serem exclusivos. Várias sessões podem ter o mesmo nome. Para obter acesso programático confiável, armazene e faça referência às sessões pelo ID de execução do MLflow (session.mlflow_run_id
) em vez de pelo nome.
Os esquemas de rótulo são necessários ao criar uma sessão de rótulo. O senhor pode usar esquemas integrados (EXPECTED_FACTS
, EXPECTED_RESPONSE
, GUIDELINES
) ou criar esquemas personalizados. Consulte o guia do rótulo Schemas para obter informações detalhadas sobre a criação e o uso de esquemas.
Sessão com esquemas de rótulos personalizados
import mlflow.genai.labeling as labeling
import mlflow.genai.label_schemas as schemas
# Create custom schemas first (see Labeling Schemas guide)
quality_schema = schemas.create_label_schema(
name="response_quality",
type="feedback",
title="Rate the response quality",
input=schemas.InputCategorical(options=["Poor", "Fair", "Good", "Excellent"]),
overwrite=True,
)
# Create session using the schemas
session = labeling.create_labeling_session(
name="quality_assessment_session",
assigned_users=["expert@company.com"],
label_schemas=["response_quality", schemas.EXPECTED_FACTS],
)
Gerenciamento do rótulo Sessões
Como os nomes das sessões de rótulos não são exclusivos, encontrar sessões pelo nome pode retornar várias correspondências ou resultados inesperados. Para o fluxo de trabalho de produção, recomenda-se armazenar e referenciar as sessões pelo ID de execução MLflow.
Recuperando sessões
import mlflow.genai.labeling as labeling
# Get all labeling sessions
all_sessions = labeling.get_labeling_sessions()
print(f"Found {len(all_sessions)} sessions")
for session in all_sessions:
print(f"- {session.name} (ID: {session.labeling_session_id})")
print(f" Assigned users: {session.assigned_users}")
Obtendo uma sessão específica
import mlflow
import mlflow.genai.labeling as labeling
import pandas as pd
# Get all labeling sessions first
all_sessions = labeling.get_labeling_sessions()
# Find session by name (note: names may not be unique)
target_session = None
for session in all_sessions:
if session.name == "customer_service_review_jan_2024":
target_session = session
break
if target_session:
print(f"Session name: {target_session.name}")
print(f"Experiment ID: {target_session.experiment_id}")
print(f"MLflow Run ID: {target_session.mlflow_run_id}")
print(f"Label schemas: {target_session.label_schemas}")
else:
print("Session not found")
# Alternative: Get session by MLflow Run ID (if you know it)
run_id = "your_labeling_session_run_id"
run = mlflow.search_runs(
experiment_ids=["your_experiment_id"],
filter_string=f"tags.mlflow.runName LIKE '%labeling_session%' AND attribute.run_id = '{run_id}'"
).iloc[0]
print(f"Found labeling session run: {run['run_id']}")
print(f"Session name: {run['tags.mlflow.runName']}")
Como não é garantido que os nomes das sessões do rótulo sejam exclusivos, recomenda-se armazenar e referenciar as sessões pelo ID de execução MLflow quando o senhor precisar recuperar sessões específicas programaticamente.
Excluindo sessões
import mlflow.genai.labeling as labeling
# Find the session to delete by name
all_sessions = labeling.get_labeling_sessions()
session_to_delete = None
for session in all_sessions:
if session.name == "customer_service_review_jan_2024":
session_to_delete = session
break
if session_to_delete:
# Delete the session (removes from Review App)
review_app = labeling.delete_labeling_session(session_to_delete)
print(f"Deleted session: {session_to_delete.name}")
else:
print("Session not found")
Adicionando rastreamentos às sessões
Depois de criada, preencha sua sessão com rastreamentos para análise de especialistas usando o método add_traces()
.
Para obter detalhes sobre como os rastreamentos são renderizados e exibidos para os rotuladores na interface do usuário do aplicativo Review, incluindo como os diferentes tipos de dados (dicionários, mensagens OpenAI, chamadas de ferramentas) são apresentados, consulte o guia do aplicativo Review.
Adicionando traços por meio da interface
O senhor também pode adicionar traços diretamente pela interface do usuário MLflow navegando até Traces tab, selecionando os traços que deseja incluir e usando a funcionalidade de exportação para adicioná-los a uma sessão de rótulo.
Adicionando traços dos resultados da pesquisa
import mlflow
import mlflow.genai.labeling as labeling
from openai import OpenAI
# First, let's create some sample traces with a simple app
# 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"
)
@mlflow.trace
def support_app(question: str):
"""Simple support app that generates responses"""
mlflow.update_current_trace(tags={"test_tag": "C001"})
response = client.chat.completions.create(
model="databricks-claude-3-7-sonnet", # This example uses Databricks hosted Claude 3.5 Sonnet. If you provide your own OpenAI credentials, replace with a valid OpenAI model e.g., gpt-4o, etc.
messages=[
{"role": "system", "content": "You are a helpful customer support agent."},
{"role": "user", "content": question},
],
)
return {"response": response.choices[0].message.content}
# Generate some sample traces
with mlflow.start_run():
# Create traces with negative feedback for demonstration
support_app("My order is delayed")
support_app("I can't log into my account")
# Now search for traces to label
traces_df = mlflow.search_traces(
filter_string="tags.test_tag = 'C001'", max_results=50
)
# Create session and add traces
session = labeling.create_labeling_session(
name="negative_feedback_review",
assigned_users=["quality_expert@company.com"],
label_schemas=["response_quality", "expected_facts"]
)
# Add traces from search results
session.add_traces(traces_df)
print(f"Added {len(traces_df)} traces to session")
Adicionando objetos de rastreamento individuais
import mlflow
import mlflow.genai.labeling as labeling
from openai import OpenAI
# Set up the app to generate traces
# 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"
)
@mlflow.trace
def support_app(question: str):
"""Simple support app that generates responses"""
mlflow.update_current_trace(tags={"test_tag": "C001"})
response = client.chat.completions.create(
model="databricks-claude-3-7-sonnet", # This example uses Databricks hosted Claude 3.5 Sonnet. If you provide your own OpenAI credentials, replace with a valid OpenAI model e.g., gpt-4o, etc.
messages=[
{"role": "system", "content": "You are a helpful customer support agent."},
{"role": "user", "content": question},
],
)
return {"response": response.choices[0].message.content}
# Generate specific traces for edge cases
with mlflow.start_run() as run:
# Create traces for specific scenarios
support_app("What's your refund policy?")
trace_id_1 = mlflow.get_last_active_trace_id()
support_app("How do I cancel my subscription?")
trace_id_2 = mlflow.get_last_active_trace_id()
support_app("The website is down")
trace_id_3 = mlflow.get_last_active_trace_id()
# Get the trace objects
trace1 = mlflow.get_trace(trace_id_1)
trace2 = mlflow.get_trace(trace_id_2)
trace3 = mlflow.get_trace(trace_id_3)
# Create session and add traces
session = labeling.create_labeling_session(
name="negative_feedback_review",
assigned_users=["nikhil.thorat@databricks.com"],
label_schemas=["response_quality", schemas.EXPECTED_FACTS],
)
# Add individual traces
session.add_traces([trace1, trace2, trace3])
Gerenciando usuários atribuídos
Requisitos de acesso do usuário
Qualquer usuário em Databricks account pode ser atribuído a uma sessão de rótulo, independentemente de ter acesso a workspace. No entanto, conceder permissão a um usuário para uma sessão de rótulo dará a ele acesso ao experimento MLflow da sessão de rótulo.
Configurar permissões para usuários
- Para usuários que não têm acesso workspace ao, um administrador do account usa accounto SCIM provisionamento de nível para sincronizar usuários e grupos automaticamente do provedor de identidade para o Databricks account. O senhor também pode registrar manualmente esses usuários e grupos para dar-lhes acesso quando configurar identidades em Databricks. Consulte Gerenciamento de usuários e grupos.
- Para os usuários que já têm acesso ao site workspace que contém o aplicativo de revisão, não é necessária nenhuma configuração adicional.
Quando o senhor atribui usuários a uma sessão de rótulo, o sistema concede automaticamente as permissões WRITE
necessárias no MLflow Experiment que contém a sessão de rótulo. Isso permite que os usuários designados acessem o site view e interajam com os dados do experimento.
Adicionando usuários às sessões existentes
import mlflow.genai.labeling as labeling
# Find existing session by name
all_sessions = labeling.get_labeling_sessions()
session = None
for s in all_sessions:
if s.name == "customer_review_session":
session = s
break
if session:
# Add more users to the session
new_users = ["expert2@company.com", "expert3@company.com"]
session.set_assigned_users(session.assigned_users + new_users)
print(f"Session now has users: {session.assigned_users}")
else:
print("Session not found")
Substituindo usuários atribuídos
import mlflow.genai.labeling as labeling
# Find session by name
all_sessions = labeling.get_labeling_sessions()
session = None
for s in all_sessions:
if s.name == "session_name":
session = s
break
if session:
# Replace all assigned users
session.set_assigned_users(["new_expert@company.com", "lead_reviewer@company.com"])
print("Updated assigned users list")
else:
print("Session not found")
Sincronização com o conjunto de dados de avaliação
Um recurso poderoso é a capacidade de sincronizar os dados coletados Expectations
para o conjunto de dados de avaliação.
Como funciona a sincronização de conjuntos de dados
O método sync()
executa uma operação de upsert inteligente:
- Chave exclusiva : As entradas de cada rastreamento servem como um key exclusivo para identificar registros na dataset
- Atualizações de expectativa : Para traços com entradas correspondentes, as expectativas da sessão de rótulo substituem as expectativas existentes no site dataset (se os nomes das expectativas forem os mesmos)
- Novos registros : Os traços da sessão de rótulo que não existem no site dataset (com base na correspondência de entrada) são adicionados como novos registros
- Preservação : Os registros existentes no site dataset com diferentes entradas permanecem inalterados
Essa abordagem permite que o senhor melhore iterativamente sua avaliação dataset adicionando novos exemplos e atualizando a verdade básica para os existentes sem perder o trabalho anterior.
Conjunto de dados Sincronização
import mlflow.genai.labeling as labeling
# Find session with completed labels by name
all_sessions = labeling.get_labeling_sessions()
session = None
for s in all_sessions:
if s.name == "completed_review_session":
session = s
break
if session:
# Sync expectations to dataset
session.sync(dataset_name="customer_service_eval_dataset")
print("Synced expectations to evaluation dataset")
else:
print("Session not found")
Melhores práticas
Organização da sessão
- Nomes descritivos: use nomes claros e marcados com data, como
customer_service_review_march_2024
- Escopo focado : mantenha as sessões focadas em metas ou períodos de avaliação específicos
- Tamanho apropriado : procure 25 a 100 traços por sessão para evitar a fadiga do revisor
Identificação da sessão: como os nomes das sessões não são exclusivos, sempre armazene o session.mlflow_run_id
ao criar uma sessão. Use o ID de execução para acesso programático em vez de depender de nomes de sessão.
import mlflow.genai.labeling as labeling
# Good: Store run ID for later reference
session = labeling.create_labeling_session(name="my_session", ...)
session_run_id = session.mlflow_run_id # Store this!
# Later: Use run ID to find session via mlflow.search_runs()
# rather than searching by name through all sessions
Gerenciamento de usuários
- Atribuições claras : atribua usuários com base na experiência e disponibilidade do domínio
- Carga de trabalho equilibrada : Distribuir o trabalho do rótulo uniformemente entre vários especialistas
- Conhecimento das permissões : Lembre-se de que os usuários precisam de acesso ao Databricks Workspace
Resumo
MLflow rótulo As sessões fornecem uma estrutura estruturada para coletar feedback de especialistas sobre aplicativos GenAI. Ao combinar sessões com esquemas de rótulo e o Review App, o senhor pode reunir sistematicamente avaliações humanas de alta qualidade que impulsionam a avaliação e o fluxo de trabalho de melhoria.
Os principais recursos incluem:
- Criação flexível de sessões com configurações personalizadas
- Gerenciamento de atribuição e permissão de usuários
- sincronização de conjunto de dados para avaliação fluxo de trabalho
Use o rótulo Sessions para transformar a coleta de feedback ad-hoc em processos sistemáticos e repetíveis que melhoram continuamente seus aplicativos GenAI.
Próximas etapas
- rótulo existing traces - Guia passo a passo para usar o rótulo sessions
- Criar esquemas de rótulos personalizados - Definir perguntas de feedback estruturado
- Criar conjunto de dados de avaliação - Converter sessões de rótulo em conjunto de dados de teste