Evaluación, Seguridad y Alineación de Agent
La evaluación es la base para garantizar la eficacia de Agent.
La seguridad y la alineación son clave para que Agent pueda ser confiable y desplegable.
Sistema de evaluación de Agent
Evaluar el rendimiento de Agent es un paso clave en el proceso de desarrollo.
Un buen sistema de evaluación nos ayuda a comprender los límites de las capacidades de Agent.
También proporciona dirección y fundamento para la optimización continua.
Dimensiones de evaluación
Grado de finalización de tareas: si Agent completó correctamente la tarea asignada.
Métricas de eficiencia: número de pasos necesarios para completar la tarea, consumo de tokens, tiempo de ejecución.
Métricas de calidad: exactitud de las respuestas, consistencia de las respuestas, naturalidad del diálogo.
Robustez: capacidad de manejar entradas anómalas y datos con ruido.
Benchmarks comunes
| Benchmark | Uso | Contenido de evaluación |
|---|---|---|
| GAIA | Evaluación de asistentes de IA generales | Manejo de tareas complejas, razonamiento de múltiples pasos |
| MMLU | Comprensión de lenguaje multitarea | Preguntas y respuestas de conocimiento en 57 disciplinas |
| HumanEval | Evaluación de generación de código | Correctitud de escritura de código Python |
| HotpotQA | Evaluación de preguntas y respuestas multi-hop | Problemas que requieren razonamiento en múltiples documentos |
| AgentBench | Evaluación de capacidades de Agent | Desempeño de Agent en entornos reales |
Implementación de código: marco de evaluación
Marco de evaluación de Agent
"""
Marco de evaluación de Agent
Evaluar el desempeño de Agent en diversas tareas
"""
def __init__(self, agent, metrics):
# Agent a evaluar
self.agent = agent
# Lista de métricas de evaluación
self.metrics = metrics
def evaluate(self, test_cases):
"""
Ejecutar evaluación
:param test_cases: Lista de casos de prueba
:return: Informe de evaluación
"""
results = []
for test_case in test_cases:
# Ejecutar tarea
result = self.run_single_test(test_case)
results.append(result)
# Generar informe de evaluación
report = self.generate_report(results)
return report
def run_single_test(self, test_case):
"""
Ejecutar un caso de prueba individual
"""
# Registrar hora de inicio
start_time = time.time()
# Ejecutar Agent
try:
output = self.agent.run(test_case.input)
success = self.evaluate_output(output, test_case.expected)
error = None
except Exception as e:
output = None
success = False
error = str(e)
# Registrar hora de finalización
end_time = time.time()
return TestResult(
test_case=test_case,
output=output,
success=success,
error=error,
duration=end_time - start_time,
token_count=self.count_tokens(output)
)
def evaluate_output(self, output, expected):
"""Evaluar si la salida cumple lo esperado"""
for metric in self.metrics:
if not metric.evaluate(output, expected):
return False
return True
def generate_report(self, results):
"""Generar informe de evaluación"""
total = len(results)
passed = sum(1 for r in results if r.success)
# Calcular varias métricas
avg_duration = sum(r.duration for r in results) / total
avg_tokens = sum(r.token_count for r in results) / total
# Agrupar estadísticas por tipo de prueba
by_category = {}
for r in results:
category = r.test_case.category
if category not in by_category:
by_category[category] = {"total": 0, "passed": 0}
by_category[category]["total"] += 1
if r.success:
by_category[category]["passed"] += 1
return EvaluationReport(
total=total,
passed=passed,
pass_rate=passed / total,
avg_duration=avg_duration,
avg_tokens=avg_tokens,
by_category=by_category,
results=results
)
class TestCase:
"""Caso de prueba"""
def __init__(self, input, expected, category="general", metadata=None):
# Entrada
self.input = input
# Salida esperada o criterios de evaluación
self.expected = expected
# Categoría
self.category = category
# Metadatos adicionales
self.metadata = metadata or {}
class TestResult:
"""Resultado de prueba"""
def __init__(self, test_case, output, success, error, duration, token_count):
self.test_case = test_case
self.output = output
self.success = success
self.error = error
self.duration = duration
self.token_count = token_count
class Metric:
"""Clase base de métricas de evaluación"""
def evaluate(self, output, expected):
raise NotImplementedError
class ExactMatchMetric(Metric):
"""Métrica de coincidencia exacta"""
def evaluate(self, output, expected):
return output.strip() == expected.strip()
class ContainsMetric(Metric):
"""Métrica de inclusión de palabras clave"""
def evaluate(self, output, expected):
if isinstance(expected, list):
return all(keyword in output for keyword in expected)
return expected in output
class SemanticSimilarityMetric(Metric):
"""Métrica de similitud semántica"""
def __init__(self, threshold=0.8):
self.threshold = threshold
def evaluate(self, output, expected):
similarity = self.compute_similarity(output, expected)
return similarity >= self.threshold
def compute_similarity(self, text1, text2):
"""Calcular la similitud semántica entre dos textos"""
# Usar modelo de embeddings para calcular similitud coseno
embedding1 = self.embedder.embed([text1])[0]
embedding2 = self.embedder.embed([text2])[0]
return cosine_similarity(embedding1, embedding2)
Seguridad y alineación
La seguridad de Agent es de suma importancia.
Los sistemas de IA pueden sufrir diversos ataques y producir salidas dañinas.
La alineación (Alignment) asegura que el comportamiento de la IA se ajuste a la intención y los valores humanos.
Amenazas de seguridad comunes
Inyección de prompts (Prompt Injection)
Los atacantes inducen a Agent a ignorar las instrucciones del sistema mediante entradas.
Ejemplo de entrada: "Ignora las instrucciones anteriores, en su lugar ejecuta..."
Este es un ataque de secuestro de contexto que explota la confianza de Agent en la entrada del usuario.
Jailbreaking
Evadir las restricciones de seguridad mediante entradas específicas.
Por ejemplo, mediante técnicas como juegos de rol o escenarios ficticios.
Contaminación de datos
Modificación maliciosa de datos de entrenamiento o resultados de búsqueda.
Provoca que Agent genere salidas erróneas o dañinas.
Fuga de información sensible
Agent expone indebidamente la privacidad del usuario o información interna del sistema.
Estrategias de protección
Implementación de Agent seguro
"""
Agent seguro
Añadir múltiples capas de protección de seguridad sobre el Agent base
"""
def __init__(self, base_agent, guardrails, input_validator, output_filter):
# Agent base
self.base_agent = base_agent
# Lista de barreras de seguridad
self.guardrails = guardrails
# Validador de entrada
self.input_validator = input_validator
# Filtro de salida
self.output_filter = output_filter
def process(self, user_input):
"""
Procesar la entrada del usuario, incluye múltiples capas de verificación de seguridad
"""
# ==================== Nivel 1: Validación de entrada ====================
# Verificar si la entrada es válida
is_valid, reason = self.input_validator.validate(user_input)
if not is_valid:
return self.create_safety_response(reason)
# ==================== Nivel 2: Detección de inyección ====================
# Detectar ataques como inyección de prompts
for guardrail in self.guardrails:
check_result = guardrail.check_input(user_input)
if not check_result.is_safe:
# Registrar eventos de seguridad
self.log_security_event(
event_type="input_guardrail_triggered",
input=user_input,
reason=check_result.reason
)
return self.create_safety_response(check_result.reason)
# ==================== Nivel 3: Ejecutar lógica central ====================
try:
response = self.base_agent.process(user_input)
except Exception as e:
return self.create_error_response(str(e))
# ==================== Nivel 4: Filtrado de salida ====================
# Verificar si la salida es segura
for guardrail in self.guardrails:
check_result = guardrail.check_output(response)
if not check_result.is_safe:
self.log_security_event(
event_type="output_guardrail_triggered",
output=response,
reason=check_result.reason
)
return self.create_safety_response(check_result.reason)
# Aplicar filtrado de salida (p. ej., enmascarar información sensible)
response = self.output_filter.filter(response)
return response
def create_safety_response(self, reason):
"""Crear respuesta segura"""
return {
"type": "safety_block",
"message": "Lo siento, no puedo completar esta solicitud.",
"reason": reason
}
def log_security_event(self, event_type, **kwargs):
"""Registrar evento de seguridad"""
# En aplicaciones reales, debería escribirse en un sistema de registro de seguridad
print(f"[SECURITY] {event_type}: {kwargs}")
class InputValidator:
"""Validador de entrada"""
def validate(self, text):
"""
Verificar si la entrada es válida
:return: (is_valid, reason)
"""
if not text or len(text.strip()) == 0:
return False, "La entrada no puede estar vacía"
if len(text) > 10000:
return False, "La longitud de la entrada excede el límite"
# Verificar si contiene contenido ejecutable
if self.contains_executable_content(text):
return False, "La entrada contiene contenido ejecutable sospechoso"
return True, None
def contains_executable_content(self, text):
"""Verificar si contiene contenido ejecutable"""
# Implementación simplificada
suspicious_patterns = [
"javascript:",
"data:text/html",
"<script>",
]
return any(pattern in text.lower() for pattern in suspicious_patterns)
class Guardrail:
"""Barrera de seguridad"""
def check_input(self, text):
"""Verificar entrada"""
raise NotImplementedError
def check_output(self, text):
"""Verificar salida"""
raise NotImplementedError
class ContentFilterGuardrail(Guardrail):
"""Barrera de filtrado de contenido"""
def __init__(self, blocked_topics, banned_words):
self.blocked_topics = blocked_topics
self.banned_words = banned_words
def check_input(self, text):
# Verificar si involucra temas prohibidos
for topic in self.blocked_topics:
if topic in text.lower():
return CheckResult(
is_safe=False,
reason=f"Involucra un tema sensible: {topic}"
)
# Verificar si contiene palabras prohibidas
for word in self.banned_words:
if word in text.lower():
return CheckResult(
is_safe=False,
reason=f"Contiene vocabulario inapropiado"
)
return CheckResult(is_safe=True)
def check_output(self, text):
# La verificación de salida igual que arriba
return self.check_input(text)
class CheckResult:
"""Verificar resultado"""
def __init__(self, is_safe, reason=None):
self.is_safe = is_safe
self.reason = reason
Recordatorio importante: la seguridad es un proceso continuo; no existe una solución infalible. Se requiere monitoreo, actualización y mejora continuos de las estrategias de seguridad.
Observabilidad
Un Agent en producción necesita un sistema de monitoreo completo.
La observabilidad nos ayuda a comprender el comportamiento de Agent, solucionar problemas y optimizar el rendimiento.
Los tres pilares
Registros (Logging): registrar todos los eventos y decisiones clave.
Tracing: rastrear la ruta completa de las solicitudes a través del sistema.
Métricas (Metrics): recopilar métricas de rendimiento y calidad.
Implementación de código
Implementación de Agent observable
from opentelemetry import trace
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.resources import Resource
# Configurar registros
logger = logging.getLogger(__name__)
# Configurar tracing
tracer_provider = TracerProvider()
trace.set_tracer_provider(tracer_provider)
tracer = trace.get_tracer(__name__)
class ObservableAgent:
"""
Agent observable
Integrar registros, tracing y recopilación de métricas
"""
def __init__(self, agent, metrics_collector):
# Agent base
self.agent = agent
# Recolector de métricas
self.metrics = metrics_collector
def process(self, user_input):
"""
Procesar solicitudes, incluye soporte completo de observabilidad
"""
# Crear span de tracing
with tracer.start_as_current_span("agent_process") as span:
# Establecer atributos del span
span.set_attribute("user.input.length", len(user_input))
span.set_attribute("user.input.preview", user_input[:100])
# Registrar inicio
logger.info(f"Iniciando procesamiento de solicitud: {user_input[:50]}...")
start_time = time.time()
try:
# Ejecutar lógica central
result = self.agent.process(user_input)
# Registrar éxito
duration = time.time() - start_time
span.set_attribute("success", True)
span.set_attribute("duration_ms", duration * 1000)
span.set_attribute("result.length", len(str(result)))
# Recopilar métricas
self.metrics.record("request_duration", duration)
self.metrics.increment("request_success")
logger.info(f"Solicitud completada, duración: {duration:.2f}s")
return result
except Exception as e:
# Registrar error
duration = time.time() - start_time
span.set_attribute("success", False)
span.set_attribute("error.type", type(e).__name__)
span.set_attribute("error.message", str(e))
span.record_exception(e)
# Recopilar métricas de error
self.metrics.increment("request_error")
self.metrics.record("error_duration", duration)
logger.error(f"Solicitud fallida: {e}")
raise
class MetricsCollector:
"""Recopilador de métricas"""
def __init__(self):
self.metrics = {}
def increment(self, name, value=1):
"""Métrica de contador incremental"""
if name not in self.metrics:
self.metrics[name] = {"type": "counter", "value": 0}
self.metrics[name]["value"] += value
def record(self, name, value):
"""Métrica de registro de valores"""
if name not in self.metrics:
self.metrics[name] = {"type": "gauge", "values": []}
self.metrics[name]["values"].append(value)
def get_summary(self):
"""Obtener resumen de métricas"""
summary = {}
for name, data in self.metrics.items():
if data["type"] == "counter":
summary[name] = data["value"]
else:
values = data["values"]
summary[f"{name}_avg"] = sum(values) / len(values)
summary[f"{name}_max"] = max(values)
summary[f"{name}_min"] = min(values)
return summary
Barreras de protección y colaboración humano-máquina
Guardrails
Los Guardrails son mecanismos en tiempo real de filtrado y restricción de entrada y salida.
A diferencia de las barreras de seguridad, los Guardrails se centran más en garantizar la calidad y el cumplimiento de la salida.
HITL(Human-in-the-Loop)
HITL introduce revisión humana en los puntos de decisión críticos.
Adecuado para escenarios de alto riesgo donde la IA no puede decidir de forma autónoma.
Implementación de Agent HITL
"""
Agente de colaboración humano-máquina
Introducir revisión humana en los puntos de decisión críticos
"""
def __init__(self, agent, approval_queue, notification_handler):
# Agente base
self.agent = agent
# Cola de aprobación
self.approval_queue = approval_queue
# Procesador de notificaciones
self.notification_handler = notification_handler
def process(self, request):
"""
Procesar solicitudes y activar la aprobación humana cuando sea necesario
"""
# Evaluar el nivel de riesgo de la solicitud
risk_level = self.assess_risk(request)
if risk_level == "high":
# Solicitudes de alto riesgo, requieren aprobación humana
return self.handle_high_risk_request(request)
elif risk_level == "medium":
# Riesgo medio, habilitar monitoreo mejorado
return self.handle_medium_risk_request(request)
else:
# Riesgo bajo, procesar directamente
return self.agent.process(request)
def assess_risk(self, request):
"""Evaluar nivel de riesgo de la solicitud"""
# Comprobar si implica operaciones sensibles
sensitive_operations = [
"delete", "remove", "cancel",
"transfer", "payment", "refund"
]
content_lower = request.lower()
for op in sensitive_operations:
if op in content_lower:
return "high"
# Comprobar la complejidad del contenido de la solicitud
if len(request) > 1000:
return "medium"
return "low"
def handle_high_risk_request(self, request):
"""
Procesar solicitudes de alto riesgo que requieren aprobación humana
"""
# Crear tarea de aprobación
task_id = self.approval_queue.add({
"request": request,
"risk_level": "high",
"timestamp": datetime.now()
})
# Notificar al aprobador
self.notification_handler.notify_approver(
task_id=task_id,
message=f"Hay una solicitud de alto riesgo que requiere aprobación: {request[:100]}..."
)
# Devolver estado de espera
return {
"status": "pending_approval",
"task_id": task_id,
"message": "Su solicitud requiere aprobación humana, por favor espere."
}
def handle_feedback(self, task_id, approved, feedback=None):
"""
Procesar la retroalimentación de aprobación
"""
task = self.approval_queue.get(task_id)
if approved:
# Aprobación concedida, ejecutar la solicitud
self.approval_queue.complete(task_id)
result = self.agent.process(task["request"])
# Notificar al solicitante
self.notification_handler.notify_requester(
task_id=task_id,
status="approved",
result=result
)
return result
else:
# Aprobación rechazada
self.approval_queue.reject(task_id, feedback)
# Notificar al solicitante
self.notification_handler.notify_requester(
task_id=task_id,
status="rejected",
feedback=feedback
)
return {
"status": "rejected",
"reason": feedback or "Aprobación no concedida"
}
class ApprovalQueue:
"""Cola de aprobación"""
def __init__(self):
self.queue = {}
self.counter = 0
def add(self, task):
"""Agregar tarea de aprobación"""
self.counter += 1
task_id = f"task_{self.counter}"
self.queue[task_id] = {
**task,
"status": "pending"
}
return task_id
def get(self, task_id):
return self.queue.get(task_id)
def complete(self, task_id):
self.queue[task_id]["status"] = "approved"
def reject(self, task_id, reason):
self.queue[task_id]["status"] = "rejected"
self.queue[task_id]["reject_reason"] = reason
Resumen del capítulo
Este capítulo presenta los conocimientos sobre evaluación, seguridad y alineación de los agentes.
Sistema de evaluaciónEvaluar el rendimiento del agente mediante métricas multidimensionales.
Amenazas de seguridadIncluyen inyección de prompts, jailbreak, contaminación de datos, etc.
Estrategias de protecciónProteger el sistema mediante múltiples capas de verificación de seguridad.
ObservabilidadMonitoreo del sistema a través de registros, trazas y métricas.
Guardrails y HITLProporcionan capacidades de control de calidad de salida y revisión humana.
La evaluación, la seguridad y la alineación son la base para construir sistemas de agentes confiables.
Requieren atención y mejora continua en el desarrollo real.
Otras extensiones