É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
"""
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é
"""
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
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
"""
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