Оценка, безопасность и выравнивание агентов
Оценка — это основа обеспечения эффективности агента.
Безопасность и выравнивание — ключ к тому, можно ли доверять Агенту и развертывать его.
Система оценки Агента
Оценка производительности Агента — критически важная часть процесса разработки.
Хорошая система оценки помогает нам понять границы возможностей Агента.
Она также задаёт направление и основу для непрерывной оптимизации.
Измерения оценки
Завершение задачи: Правильно ли Агент выполнил поставленную задачу.
Метрики эффективности: Количество шагов, расход токенов и время выполнения, необходимое для выполнения задачи.
Метрики качества: Точность ответов, согласованность ответов и естественность диалога.
Устойчивость: Способность обрабатывать аномальные входные данные и зашумлённые данные.
Распространённые бенчмарки
| Бенчмарк | Назначение | Содержание оценки |
|---|---|---|
| GAIA | Оценка универсального ИИ-ассистента | Обработка сложных задач, многошаговое рассуждение |
| MMLU | Многозадачное понимание языка | Вопросы и ответы по 57 предметам |
| HumanEval | Оценка генерации кода | Правильность написания кода на Python |
| HotpotQA | Оценка ответов на вопросы с многошаговым выводом | Вопросы, требующие рассуждений по нескольким документам |
| AgentBench | Оценка возможностей агента | Эффективность агента в реальных средах |
Реализация кода: фреймворк оценки
Фреймворк оценки агента
"""
Фреймворк оценки агента
Оценка эффективности агента в различных задачах
"""
def __init__(self, agent, metrics):
# Агент для оценки
self.agent = agent
# Список метрик оценки
self.metrics = metrics
def evaluate(self, test_cases):
"""
Выполнить оценку
:param test_cases: список тестовых случаев
:return: отчёт об оценке
"""
results = []
for test_case in test_cases:
# Выполнить задачу
result = self.run_single_test(test_case)
results.append(result)
# Сгенерировать отчёт об оценке
report = self.generate_report(results)
return report
def run_single_test(self, test_case):
"""
Запустить один тестовый пример
"""
# Записать время начала
start_time = time.time()
# Запустить агента
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)
# Записать время окончания
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):
"""Оцените, соответствует ли вывод ожиданиям"""
for metric in self.metrics:
if not metric.evaluate(output, expected):
return False
return True
def generate_report(self, results):
"""Сгенерировать отчёт об оценке"""
total = len(results)
passed = sum(1 for r in results if r.success)
# Вычислить различные метрики
avg_duration = sum(r.duration for r in results) / total
avg_tokens = sum(r.token_count for r in results) / total
# Сгруппировать и подсчитать по типу теста
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:
"""Тест-кейс"""
def __init__(self, input, expected, category="general", metadata=None):
# Ввод
self.input = input
# Ожидаемый вывод или критерии оценки
self.expected = expected
# Категория
self.category = category
# Дополнительные метаданные
self.metadata = metadata or {}
class TestResult:
"""Результат теста"""
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:
"""Базовый класс для метрик оценки"""
def evaluate(self, output, expected):
raise NotImplementedError
class ExactMatchMetric(Metric):
"""Метрика точного совпадения"""
def evaluate(self, output, expected):
return output.strip() == expected.strip()
class ContainsMetric(Metric):
"""Метрика включения ключевых слов"""
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):
"""Метрика семантического сходства"""
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):
"""Вычислить семантическое сходство двух текстов"""
# Использовать модель эмбеддингов для вычисления косинусного сходства
embedding1 = self.embedder.embed([text1])[0]
embedding2 = self.embedder.embed([text2])[0]
return cosine_similarity(embedding1, embedding2)
Безопасность и выравнивание
Безопасность Агента имеет первостепенное значение.
Системы ИИ могут подвергаться различным атакам и генерировать вредные выходные данные.
Выравнивание гарантирует, что поведение ИИ соответствует человеческим намерениям и ценностям.
Распространённые угрозы безопасности
Инъекция промпта
Злоумышленники используют ввод, чтобы побудить Агента игнорировать системные инструкции.
Пример ввода: "Игнорируй предыдущие инструкции и вместо этого выполни..."
Это атака с захватом контекста, которая эксплуатирует доверие Агента к пользовательскому вводу.
Джейлбрейкинг
Обход ограничений безопасности с помощью специальных входных данных.
Например, с использованием таких техник, как ролевая игра или вымышленные сценарии.
Отравление данных
Злонамеренно изменять обучающие данные или результаты извлечения.
Приводит к тому, что агент создаёт некорректные или вредоносные выходные данные.
Утечка конфиденциальной информации
Агент ненадлежащим образом раскрывает конфиденциальность пользователя или внутреннюю системную информацию.
Стратегии защиты
Реализация безопасного агента
"""
Агент безопасности
Добавьте несколько уровней защиты безопасности поверх базового агента
"""
def __init__(self, base_agent, guardrails, input_validator, output_filter):
# Базовый агент
self.base_agent = base_agent
# Список ограничителей безопасности
self.guardrails = guardrails
# Валидатор ввода
self.input_validator = input_validator
# Фильтр вывода
self.output_filter = output_filter
def process(self, user_input):
"""
Обработать ввод пользователя, включая несколько уровней проверок безопасности
"""
# ==================== Уровень 1: Проверка ввода ====================
# Проверить, является ли ввод корректным
is_valid, reason = self.input_validator.validate(user_input)
if not is_valid:
return self.create_safety_response(reason)
# ==================== Уровень 2: Обнаружение инъекций ====================
# Обнаружение атак, таких как промпт-инъекция
for guardrail in self.guardrails:
check_result = guardrail.check_input(user_input)
if not check_result.is_safe:
# Запись событий безопасности
self.log_security_event(
event_type="input_guardrail",
input=user_input,
reason=check_result.reason
)
return self.create_safety_response(check_result.reason)
# ==================== Слой 3: Выполнение основной логики ====================
try:
response = self.base_agent.process(user_input)
except Exception as e:
return self.create_error_response(str(e))
# ==================== Слой 4: Фильтрация вывода ====================
# Проверить, безопасен ли вывод
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)
# Применить фильтрацию вывода (например, обезличивание конфиденциальной информации)
response = self.output_filter.filter(response)
return response
def create_safety_response(self, reason):
"""Создать безопасный ответ"""
return {
"type": "safety_block",
"message": "Извините, я не могу выполнить этот запрос.",
"reason": reason
}
def log_security_event(self, event_type, **kwargs):
"""Записать события безопасности"""
# В реальных приложениях это должно записываться в систему журналирования безопасности
print(f"[SECURITY] {event_type}: {kwargs}")
class InputValidator:
"""Валидатор ввода"""
def validate(self, text):
"""
Проверить, является ли ввод допустимым
:return: (is_valid, reason)
"""
if not text or len(text.strip()) == 0:
return False, "Ввод не может быть пустым"
if len(text) > 10000:
return False, "Длина ввода превышает лимит"
# Проверить, содержит ли он исполняемое содержимое
if self.contains_executable_content(text):
return False, "Ввод содержит подозрительное исполняемое содержимое"
return True, None
def contains_executable_content(self, text):
"""Проверить, содержит ли он исполняемое содержимое"""
# Упрощённая реализация
suspicious_patterns = [
"javascript:",
"data:text/html",
"<script>",
]
return any(pattern in text.lower() for pattern in suspicious_patterns)
class Guardrail:
"""Защитное ограничение безопасности"""
def check_input(self, text):
"""Проверка ввода"""
raise NotImplementedError
def check_output(self, text):
"""Проверить вывод"""
raise NotImplementedError
class ContentFilterGuardrail(Guardrail):
"""Защитный барьер фильтрации контента"""
def __init__(self, blocked_topics, banned_words):
self.blocked_topics = blocked_topics
self.banned_words = banned_words
def check_input(self, text):
# Проверить, затрагивает ли он запрещённые темы
for topic in self.blocked_topics:
if topic in text.lower():
return CheckResult(
is_safe=False,
reason=f"Затрагивает чувствительную тему: {topic}"
)
# Проверить, содержит ли он запрещённые слова
for word in self.banned_words:
if word in text.lower():
return CheckResult(
is_safe=False,
reason=f"Содержит неподобающие слова"
)
return CheckResult(is_safe=True)
def check_output(self, text):
# Проверка вывода такая же, как выше
return self.check_input(text)
class CheckResult:
"""Результат проверки"""
def __init__(self, is_safe, reason=None):
self.is_safe = is_safe
self.reason = reason
Важное напоминание: безопасность — это непрерывный процесс, и не существует безотказного решения. Стратегии безопасности требуют постоянного мониторинга, обновления и улучшения.
Наблюдаемость
Агентам в производственных средах нужна комплексная система мониторинга.
Наблюдаемость помогает нам понимать поведение агента, устранять проблемы и оптимизировать производительность.
Три столпа
Логирование: записывайте все ключевые события и решения.
Трассировка: отслеживайте полный путь прохождения запросов через систему.
Метрики: собирайте метрики производительности и качества.
Реализация кода
Реализация наблюдаемого агента
from opentelemetry import trace
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.resources import Resource
# Настройка логирования
logger = logging.getLogger(__name__)
# Настройка трассировки
tracer_provider = TracerProvider()
trace.set_tracer_provider(tracer_provider)
tracer = trace.get_tracer(__name__)
class ObservableAgent:
"""
Агент наблюдаемости
Интегрированный сбор логов, трассировок и метрик
"""
def __init__(self, agent, metrics_collector):
# Базовый агент
self.agent = agent
# Сборщик метрик
self.metrics = metrics_collector
def process(self, user_input):
"""
Обработка запросов с полной поддержкой наблюдаемости
"""
# Создание span трассировки
with tracer.start_as_current_span("agent_process") as span:
# Установить атрибуты span
span.set_attribute("user.input.length", len(user_input))
span.set_attribute("user.input.preview", user_input[:100])
# Зафиксировать начало
logger.info(f"Начало обработки запроса: {user_input[:50]}...")
start_time = time.time()
try:
# Выполнить основную логику
result = self.agent.process(user_input)
# Зафиксировать успех
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)))
# Сбор метрик
self.metrics.record("request_duration", duration)
self.metrics.increment("request_success")
logger.info(f"Запрос завершён, занял: {duration:.2f}s")
return result
except Exception as e:
# Записать ошибку
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)
# Собрать метрики ошибок
self.metrics.increment("request_error")
self.metrics.record("error_duration", duration)
logger.error(f"Запрос не выполнен: {e}")
raise
class MetricsCollector:
"""Сборщик метрик"""
def __init__(self):
self.metrics = {}
def increment(self, name, value=1):
"""Увеличить счетчик метрики"""
if name not in self.metrics:
self.metrics[name] = {"type": "counter", "value": 0}
self.metrics[name]["value"] += value
def record(self, name, value):
"""Записать числовую метрику"""
if name not in self.metrics:
self.metrics[name] = {"type": "gauge", "values": []}
self.metrics[name]["values"].append(value)
def get_summary(self):
"""Получить сводку метрик"""
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
Ограничители и участие человека
Ограничители
Ограничители — это механизмы фильтрации и ограничения ввода/вывода в реальном времени.
В отличие от защитных ограничителей безопасности, Guardrails в большей степени сосредоточены на обеспечении качества выходных данных и соответствия требованиям.
HITL (Human-in-the-Loop)
HITL вводит проверку человеком в критических точках принятия решений.
Подходит для сценариев с высоким риском, в которых ИИ не может принимать автономные решения.
Реализация HITL-агента
"""
Агент с участием человека
Внедрить проверку человеком в критических точках принятия решений
"""
def __init__(self, agent, approval_queue, notification_handler):
# Базовый агент
self.agent = agent
# Очередь одобрения
self.approval_queue = approval_queue
# Обработчик уведомлений
self.notification_handler = notification_handler
def process(self, request):
"""
Обрабатывать запросы, запускать одобрение человеком при необходимости
"""
# Оценить уровень риска запроса
risk_level = self.assess_risk(request)
if risk_level == "high":
# Запрос с высоким риском, требует одобрения человеком
return self.handle_high_risk_request(request)
elif risk_level == "medium":
# Средний риск, включить усиленный мониторинг
return self.handle_medium_risk_request(request)
else:
# Низкий риск, обрабатывать напрямую
return self.agent.process(request)
def assess_risk(self, request):
"""Оценить уровень риска запроса"""
# Проверить, задействованы ли чувствительные операции
sensitive_operations = [
"delete", "remove", "cancel",
"transfer", "payment", "refund"
]
content_lower = request.lower()
for op in sensitive_operations:
if op in content_lower:
return "high"
# Проверить сложность содержимого запроса
if len(request) > 1000:
return "medium"
return "low"
def handle_high_risk_request(self, request):
"""
Обрабатывать высокорисковые запросы, требующие одобрения человеком
"""
# Создать задачу на утверждение
task_id = self.approval_queue.add({
"request": request,
"risk_level": "high",
"timestamp": datetime.now()
})
# Уведомить утверждающего
self.notification_handler.notify_approver(
task_id=task_id,
message=f"Запрос с высоким риском требует одобрения: {request[:100]}..."
)
# Вернуть статус ожидания
return {
"status": "pending_approval",
"task_id": task_id,
"message": "Ваш запрос требует одобрения человеком, пожалуйста, подождите."
}
def handle_feedback(self, task_id, approved, feedback=Отсутствует):
"""
Обработать обратную связь по одобрению
"""
task = self.approval_queue.get(task_id)
if approved:
# Одобрение получено, выполнить запрос
self.approval_queue.complete(task_id)
result = self.agent.process(task["request"])
# Уведомить заявителя
self.notification_handler.notify_requester(
task_id=task_id,
status="approved",
result=result
)
return result
else:
# Одобрение отклонено
self.approval_queue.reject(task_id, feedback)
# Уведомить заявителя
self.notification_handler.notify_requester(
task_id=task_id,
status="rejected",
feedback=feedback
)
return {
"status": "rejected",
"reason": feedback или Одобрение не удалось.
}
class ApprovalQueue:
Очередь согласования
def __init__(self):
self.queue = {}
self.counter = 0
def add(self, task):
Добавить задачу на согласование
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
Краткое содержание главы
В этой главе представлены сведения об оценке, безопасности и выравнивании агентов.
Система оценкиОцените производительность агента с помощью многомерных метрик.
Угроза безопасностиВключая внедрение промптов, джейлбрейкинг, отравление данных и т. д.
Стратегия защитыОбеспечьте безопасность системы с помощью многоуровневых проверок безопасности.
НаблюдаемостьРеализуйте мониторинг системы с помощью логов, трассировки и метрик.
Защитные механизмы и HITLОбеспечьте контроль качества выходных данных и возможности ручной проверки.
Оценка, безопасность и выравнивание — это основа для создания заслуживающих доверия агентных систем.
Это требует постоянного внимания и улучшения в реальной разработке.
Другие расширения