Évaluation, sécurité et alignement des agents

L'évaluation est le fondement pour garantir l'efficacité d'un agent.

La sécurité et l'alignement sont déterminants pour qu'un agent puisse être digne de confiance et déployé.


Système d'évaluation des agents

L'évaluation des performances d'un agent est une partie critique du processus de développement.

Un bon système d'évaluation nous aide à comprendre les limites des capacités d'un agent.

Il fournit également une direction et une base pour une optimisation continue.

Dimensions d'évaluation

Achèvement de la tâche: Si l'Agent a correctement accompli la tâche donnée.

Métriques d'efficacité: Nombre d'étapes, consommation de tokens et temps d'exécution nécessaires pour accomplir la tâche.

Métriques de qualité: Exactitude des réponses, cohérence des réponses et naturel du dialogue.

Robustesse: Capacité à gérer les entrées anormales et les données bruitées.

Benchmarks courants

Benchmark Objectif Contenu d'évaluation
GAIA Évaluation générale d'assistant IA Gestion de tâches complexes, raisonnement multi-étapes
MMLU Compréhension du langage multi-tâches Questions-réponses de connaissances sur 57 sujets
HumanEval Évaluation de la génération de code Exactitude de l'écriture de code Python
HotpotQA Évaluation de questions-réponses multi-sauts Questions nécessitant un raisonnement sur plusieurs documents
AgentBench Évaluation des capacités des agents Performance des agents dans des environnements réels

Implémentation de code : cadre d'évaluation

Cadre d'évaluation des agents

class AgentEvaluator:
    """
Cadre d'évaluation des agents
Évaluer les performances d'un Agent sur diverses tâches
    """

   
    def __init__(self, agent, metrics):
        # Agent à évaluer
        self.agent = agent
        # Liste des métriques d'évaluation
        self.metrics = metrics
   
    def evaluate(self, test_cases):
        """
Exécuter l'évaluation
:param test_cases: liste des cas de test
:return: rapport d'évaluation
        """

        results = []
       
        for test_case in test_cases:
            # Exécuter la tâche
            result = self.run_single_test(test_case)
            results.append(result)
       
        # Générer le rapport d'évaluation
        report = self.generate_report(results)
        return report
   
    def run_single_test(self, test_case):
        """
Exécuter un seul cas de test
        """

        # Enregistrer l'heure de début
        start_time = time.time()
       
        # Exécuter l'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)
       
        # Enregistrer l'heure de fin
        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):
        """Évaluer si la sortie répond aux attentes"""
        for metric in self.metrics:
            if not metric.evaluate(output, expected):
                return False
        return True
   
    def generate_report(self, results):
        """Générer le rapport d'évaluation"""
        total = len(results)
        passed = sum(1 for r in results if r.success)
       
        # Calculer diverses métriques
        avg_duration = sum(r.duration for r in results) / total
        avg_tokens = sum(r.token_count for r in results) / total
       
        # Grouper et compter par type de test
        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:
    """Cas de test"""
   
    def __init__(self, input, expected, category="general", metadata=None):
        # Entrée
        self.input = input
        # Sortie attendue ou critères d'évaluation
        self.expected = expected
        # Catégorie
        self.category = category
        # Métadonnées supplémentaires
        self.metadata = metadata or {}


class TestResult:
    """Résultat du test"""
   
    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:
    """Classe de base pour les métriques d'évaluation"""
   
    def evaluate(self, output, expected):
        raise NotImplementedError


class ExactMatchMetric(Metric):
    """Métrique de correspondance exacte"""
   
    def evaluate(self, output, expected):
        return output.strip() == expected.strip()


class ContainsMetric(Metric):
    """Métrique d'inclusion de mots-clés"""
   
    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étrique de similarité sémantique"""
   
    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):
        """Calculer la similarité sémantique de deux textes"""
        # Utiliser le modèle d'embedding pour calculer la similarité cosinus
        embedding1 = self.embedder.embed([text1])[0]
        embedding2 = self.embedder.embed([text2])[0]
        return cosine_similarity(embedding1, embedding2)

Sécurité et alignement

La sécurité de l'Agent est de la plus haute importance.

Les systèmes d'IA peuvent être sujets à diverses attaques et produire des sorties nuisibles.

L'alignement garantit que le comportement de l'IA est aligné sur les intentions et les valeurs humaines.

Menaces de sécurité courantes

Injection de prompt

Les attaquants utilisent des entrées pour amener l'Agent à ignorer les instructions système.

Exemple d'entrée : "Ignorez les instructions précédentes et exécutez à la place..."

Il s'agit d'une attaque de détournement de contexte qui exploite la confiance de l'Agent dans les entrées utilisateur.

Débridage

Contourner les restrictions de sécurité à l'aide d'entrées spécifiques.

Par exemple, en utilisant des techniques telles que le jeu de rôle ou des scénarios fictifs.

Empoisonnement des données

Modifier malveillamment les données d'entraînement ou les résultats de récupération.

Amener l'Agent à produire des sorties incorrectes ou nuisibles.

Fuite d'informations sensibles

L'Agent expose indûment la confidentialité des utilisateurs ou des informations système internes.

Stratégies de défense

Implémentation de l'agent sécurisé

class SecureAgent:
    """
Agent de sécurité
Ajouter plusieurs couches de protection de sécurité par-dessus l'agent de base
    """

   
    def __init__(self, base_agent, guardrails, input_validator, output_filter):
        # Agent de base
        self.base_agent = base_agent
        # Liste des garde-fous de sécurité
        self.guardrails = guardrails
        # Validateur d'entrée
        self.input_validator = input_validator
        # Filtre de sortie
        self.output_filter = output_filter
   
    def process(self, user_input):
        """
Traiter l'entrée utilisateur, y compris plusieurs couches de contrôles de sécurité
        """

        # ==================== Couche 1 : Validation des entrées ====================
        # Vérifier si l'entrée est valide
        is_valid, reason = self.input_validator.validate(user_input)
        if not is_valid:
            return self.create_safety_response(reason)
       
        # ==================== Couche 2 : Détection d'injection ====================
        # Détecter les attaques telles que l'injection de prompt
        for guardrail in self.guardrails:
            check_result = guardrail.check_input(user_input)
            if not check_result.is_safe:
                # Enregistrer les événements de sécurité
                self.log_security_event(
                    event_type="input_guardrail_triggered",
                    input=user_input,
                    reason=check_result.reason
                )
                return self.create_safety_response(check_result.reason)
       
        # ==================== Couche 3 : Exécuter la logique principale ====================
        try:
            response = self.base_agent.process(user_input)
        except Exception as e:
            return self.create_error_response(str(e))
       
        # ==================== Couche 4 : Filtrage des sorties ====================
        # Vérifier si la sortie est sûre
        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)
       
        # Appliquer le filtrage de sortie (par exemple, la désensibilisation des informations sensibles)
        response = self.output_filter.filter(response)
       
        return response
   
    def create_safety_response(self, reason):
        """Créer une réponse sécurisée"""
        return {
            "type": "safety_block",
            "message": "Désolé, je ne peux pas traiter cette demande.",
            "reason": reason
        }
   
    def log_security_event(self, event_type, **kwargs):
        """Enregistrer les événements de sécurité"""
        # Dans des applications réelles, cela devrait être écrit dans un système de journalisation de sécurité
        print(f"[SECURITY] {event_type}: {kwargs}")


class InputValidator:
    """Validateur d'entrée"""
   
    def validate(self, text):
        """
Vérifier si l'entrée est valide
        :return: (is_valid, reason)
        """

        if not text or len(text.strip()) == 0:
            return False, "L'entrée ne peut pas être vide"
       
        if len(text) > 10000:
            return False, "La longueur de l'entrée dépasse la limite"
       
        # Vérifier s'il contient du contenu exécutable
        if self.contains_executable_content(text):
            return False, "L'entrée contient du contenu exécutable suspect"
       
        return True, None
   
    def contains_executable_content(self, text):
        """Vérifier s'il contient du contenu exécutable"""
        # Implémentation simplifiée
        suspicious_patterns = [
            "javascript:",
            "data:text/html",
            "<script>",
        ]
        return any(pattern in text.lower() for pattern in suspicious_patterns)


class Guardrail:
    """Garde-fou de sécurité"""
   
    def check_input(self, text):
        """Vérifier l'entrée"""
        raise NotImplementedError
   
    def check_output(self, text):
        """Vérifier la sortie"""
        raise NotImplementedError


class ContentFilterGuardrail(Guardrail):
    """Garde-fou de filtrage de contenu"""
   
    def __init__(self, blocked_topics, banned_words):
        self.blocked_topics = blocked_topics
        self.banned_words = banned_words
   
    def check_input(self, text):
        # Vérifier s'il implique des sujets interdits
        for topic in self.blocked_topics:
            if topic in text.lower():
                return CheckResult(
                    is_safe=False,
                    reason=f"Implique un sujet sensible : {topic}"
                )
       
        # Vérifier s'il contient des mots interdits
        for word in self.banned_words:
            if word in text.lower():
                return CheckResult(
                    is_safe=False,
                    reason=f"Contient des mots inappropriés"
                )
       
        return CheckResult(is_safe=True)
   
    def check_output(self, text):
        # Vérification de sortie identique à ci-dessus
        return self.check_input(text)


class CheckResult:
    """Résultat de la vérification"""
   
    def __init__(self, is_safe, reason=None):
        self.is_safe = is_safe
        self.reason = reason

Rappel important : la sécurité est un processus continu, et il n'existe pas de solution infaillible. Les stratégies de sécurité nécessitent une surveillance, une mise à jour et une amélioration continues.


Observabilité

Les agents dans les environnements de production ont besoin d'un système de supervision complet.

L'observabilité nous aide à comprendre le comportement des agents, à résoudre les problèmes et à optimiser les performances.

Trois piliers

Journalisation: Enregistrer tous les événements et décisions clés.

Traçage: Suivre le parcours complet des requêtes dans le système.

Métriques: Collecter les métriques de performance et de qualité.

Implémentation du code

Implémentation d'un agent observable

import logging
from opentelemetry import trace
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.resources import Resource

# Configurer la journalisation
logger = logging.getLogger(__name__)

# Configurer le traçage
tracer_provider = TracerProvider()
trace.set_tracer_provider(tracer_provider)
tracer = trace.get_tracer(__name__)


class ObservableAgent:
    """
Agent d'observabilité
Collecte intégrée des logs, traces et métriques
    """

   
    def __init__(self, agent, metrics_collector):
        # Agent de base
        self.agent = agent
        # Collecteur de métriques
        self.metrics = metrics_collector
   
    def process(self, user_input):
        """
Gérer les requêtes avec une prise en charge complète de l'observabilité
        """

        # Créer une span de traçage
        with tracer.start_as_current_span("agent_process") as span:
            # Définir les attributs de span
            span.set_attribute("user.input.length", len(user_input))
            span.set_attribute("user.input.preview", user_input[:100])
           
            # Enregistrer le début
            logger.info(f"Début du traitement de la requête : {user_input[:50]}...")
            start_time = time.time()
           
            try:
                # Exécuter la logique principale
                result = self.agent.process(user_input)
               
                # Enregistrer le succès
                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)))
               
                # Collecter les métriques
                self.metrics.record("request_duration", duration)
                self.metrics.increment("request_success")
               
                logger.info(f"Requête terminée, durée : {duration:.2f}s")
               
                return result
               
            except Exception as e:
                # Enregistrer l'erreur
                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)
               
                # Collecter les métriques d'erreur
                self.metrics.increment("request_error")
                self.metrics.record("error_duration", duration)
               
                logger.error(f"Échec de la requête : {e}")
               
                raise


class MetricsCollector:
    """Collecteur de métriques"""
   
    def __init__(self):
        self.metrics = {}
   
    def increment(self, name, value=1):
        """Incrémenter la métrique de compteur"""
        if name not in self.metrics:
            self.metrics[name] = {"type": "counter", "value": 0}
        self.metrics[name]["value"] += value
   
    def record(self, name, value):
        """Enregistrer une métrique numérique"""
        if name not in self.metrics:
            self.metrics[name] = {"type": "gauge", "values": []}
        self.metrics[name]["values"].append(value)
   
    def get_summary(self):
        """Obtenir le résumé des métriques"""
        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

Garde-fous et humain dans la boucle

Garde-fous

Les garde-fous sont des mécanismes de filtrage et de restriction des entrées/sorties en temps réel.

Contrairement aux garde-fous de sécurité, les garde-fous se concentrent davantage sur la garantie de la qualité et de la conformité des sorties.

HITL(Humain dans la boucle)

HITL introduit une revue humaine aux points de décision critiques.

Adapté aux scénarios à haut risque où l'IA ne peut pas prendre de décisions autonomes.

Implémentation de l'agent HITL

class HITLAgent:
    """
Agent avec intervention humaine
Introduire une revue humaine aux points de décision critiques
    """

   
    def __init__(self, agent, approval_queue, notification_handler):
        # Agent de base
        self.agent = agent
        # File d'attente d'approbation
        self.approval_queue = approval_queue
        # Gestionnaire de notification
        self.notification_handler = notification_handler
   
    def process(self, request):
        """
Traiter les requêtes, déclencher une approbation humaine lorsque nécessaire
        """

        # Évaluer le niveau de risque de la requête
        risk_level = self.assess_risk(request)
       
        if risk_level == "high":
            # Demande à haut risque, nécessite une validation humaine
            return self.handle_high_risk_request(request)
        elif risk_level == "medium":
            # Risque moyen, activer une surveillance renforcée
            return self.handle_medium_risk_request(request)
        else:
            # Risque faible, traiter directement
            return self.agent.process(request)
   
    def assess_risk(self, request):
        """Évaluer le niveau de risque de la demande"""
        # Vérifier si des opérations sensibles sont impliquées
        sensitive_operations = [
            "delete", "remove", "cancel",
            "transfer", "payment", "refund"
        ]
       
        content_lower = request.lower()
        for op in sensitive_operations:
            if op in content_lower:
                return "high"
       
        # Vérifier la complexité du contenu de la requête
        if len(request) > 1000:
            return "medium"
       
        return "low"
   
    def handle_high_risk_request(self, request):
        """
Traiter les requêtes à haut risque qui nécessitent une approbation humaine
        """

        # Créer une tâche d'approbation
        task_id = self.approval_queue.add({
            "request": request,
            "risk_level": "high",
            "timestamp": datetime.now()
        })
       
        # Notifier l'approbateur
        self.notification_handler.notify_approver(
            task_id=task_id,
            message=f"Une demande à haut risque nécessite une approbation : {request[:100]}..."
        )
       
        # Renvoyer le statut d'attente
        return {
            "status": "pending_approval",
            "task_id": task_id,
            "message": "Votre demande nécessite une approbation humaine, veuillez patienter."
        }
   
    def handle_feedback(self, task_id, approved, feedback=Aucune):
        """
Traiter le retour d'approbation
        """

        task = self.approval_queue.get(task_id)
       
        if approved:
            # Approbation accordée, exécuter la requête
            self.approval_queue.complete(task_id)
            result = self.agent.process(task["request"])
           
            # Notifier le demandeur
            self.notification_handler.notify_requester(
                task_id=task_id,
                status="approved",
                result=result
            )
           
            return result
        else:
            # Approbation rejetée
            self.approval_queue.reject(task_id, feedback)
           
            # Notifier le demandeur
            self.notification_handler.notify_requester(
                task_id=task_id,
                status="rejected",
                feedback=feedback
            )
           
            return {
                "status": "rejected",
                "reason": feedback ou Échec de l'approbation.
            }


class ApprovalQueue:
    File d'attente d'approbation
   
    def __init__(self):
        self.queue = {}
        self.counter = 0
   
    def add(self, task):
        Ajouter une tâche d'approbation
        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

Résumé du chapitre

Ce chapitre présente des connaissances sur l'évaluation, la sécurité et l'alignement des agents.

Système d'évaluationÉvaluer les performances de l'agent à l'aide de métriques multidimensionnelles.

Menace de sécuritéY compris l'injection de prompt, le jailbreaking, l'empoisonnement des données, etc.

Stratégie de protectionAssurer la sécurité du système grâce à des contrôles de sécurité à plusieurs niveaux.

ObservabilitéMettre en œuvre la surveillance du système via des journaux, le traçage et des métriques.

Garde-fous et HITLFournir un contrôle qualité des sorties et des capacités de revue manuelle.

L'évaluation, la sécurité et l'alignement constituent la base pour construire des systèmes d'agents dignes de confiance.

Cela nécessite une attention et une amélioration continues dans le développement réel.

Autres extensions