Оценка, безопасность и выравнивание агентов

Оценка — это основа обеспечения эффективности агента.

Безопасность и выравнивание — ключ к тому, можно ли доверять Агенту и развертывать его.


Система оценки Агента

Оценка производительности Агента — критически важная часть процесса разработки.

Хорошая система оценки помогает нам понять границы возможностей Агента.

Она также задаёт направление и основу для непрерывной оптимизации.

Измерения оценки

Завершение задачи: Правильно ли Агент выполнил поставленную задачу.

Метрики эффективности: Количество шагов, расход токенов и время выполнения, необходимое для выполнения задачи.

Метрики качества: Точность ответов, согласованность ответов и естественность диалога.

Устойчивость: Способность обрабатывать аномальные входные данные и зашумлённые данные.

Распространённые бенчмарки

Бенчмарк Назначение Содержание оценки
GAIA Оценка универсального ИИ-ассистента Обработка сложных задач, многошаговое рассуждение
MMLU Многозадачное понимание языка Вопросы и ответы по 57 предметам
HumanEval Оценка генерации кода Правильность написания кода на Python
HotpotQA Оценка ответов на вопросы с многошаговым выводом Вопросы, требующие рассуждений по нескольким документам
AgentBench Оценка возможностей агента Эффективность агента в реальных средах

Реализация кода: фреймворк оценки

Фреймворк оценки агента

class AgentEvaluator:
    """
Фреймворк оценки агента
Оценка эффективности агента в различных задачах
    """

   
    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)

Безопасность и выравнивание

Безопасность Агента имеет первостепенное значение.

Системы ИИ могут подвергаться различным атакам и генерировать вредные выходные данные.

Выравнивание гарантирует, что поведение ИИ соответствует человеческим намерениям и ценностям.

Распространённые угрозы безопасности

Инъекция промпта

Злоумышленники используют ввод, чтобы побудить Агента игнорировать системные инструкции.

Пример ввода: "Игнорируй предыдущие инструкции и вместо этого выполни..."

Это атака с захватом контекста, которая эксплуатирует доверие Агента к пользовательскому вводу.

Джейлбрейкинг

Обход ограничений безопасности с помощью специальных входных данных.

Например, с использованием таких техник, как ролевая игра или вымышленные сценарии.

Отравление данных

Злонамеренно изменять обучающие данные или результаты извлечения.

Приводит к тому, что агент создаёт некорректные или вредоносные выходные данные.

Утечка конфиденциальной информации

Агент ненадлежащим образом раскрывает конфиденциальность пользователя или внутреннюю системную информацию.

Стратегии защиты

Реализация безопасного агента

class SecureAgent:
    """
Агент безопасности
Добавьте несколько уровней защиты безопасности поверх базового агента
    """

   
    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

Важное напоминание: безопасность — это непрерывный процесс, и не существует безотказного решения. Стратегии безопасности требуют постоянного мониторинга, обновления и улучшения.


Наблюдаемость

Агентам в производственных средах нужна комплексная система мониторинга.

Наблюдаемость помогает нам понимать поведение агента, устранять проблемы и оптимизировать производительность.

Три столпа

Логирование: записывайте все ключевые события и решения.

Трассировка: отслеживайте полный путь прохождения запросов через систему.

Метрики: собирайте метрики производительности и качества.

Реализация кода

Реализация наблюдаемого агента

import logging
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-агента

class HITLAgent:
    """
Агент с участием человека
Внедрить проверку человеком в критических точках принятия решений
    """

   
    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Обеспечьте контроль качества выходных данных и возможности ручной проверки.

Оценка, безопасность и выравнивание — это основа для создания заслуживающих доверия агентных систем.

Это требует постоянного внимания и улучшения в реальной разработке.

Другие расширения