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

class AgentEvaluator:
    """
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

class SecureAgent:
    """
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

import logging
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

class HITLAgent:
    """
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