Agent 評価、セキュリティとアライメント

評価はAgentの効果を保証する基盤です。

セキュリティとアライメントは、Agentが信頼されデプロイされるための鍵です。


Agent評価体系

Agentの性能評価は開発プロセスにおける重要な段階です。

優れた評価体系は、Agentの能力の限界を理解するのに役立ちます。

また、継続的な最適化に方向性と根拠を提供します。

評価次元

タスク完了度:Agentが与えられたタスクを正しく完了したか。

効率指標:タスク完了に必要なステップ数、トークン消費、実行時間。

品質指標:回答の正確性、応答の一貫性、対話の自然さ。

ロバスト性:異常な入力やノイズデータへの処理能力。

一般的なBenchmark

Benchmark 用途 評価内容
GAIA 汎用AIアシスタント評価 複雑なタスク処理、マルチステップ推論
MMLU マルチタスク言語理解 57分野の知識Q&A
HumanEval コード生成評価 Pythonコード作成の正確性
HotpotQA マルチホップQA評価 複数ドキュメントの推論を必要とする問題
AgentBench Agent能力評価 実環境でのAgentのパフォーマンス

コード実装:評価フレームワーク

Agent評価フレームワーク

class AgentEvaluator:
    """
Agent評価フレームワーク
さまざまなタスクにおけるAgentの性能を評価する
    """

   
    def __init__(self, agent, metrics):
        # 評価対象のAgent
        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()
       
        # 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)
       
        # 終了時間を記録
        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):
        """2つのテキストの意味的類似度を計算する"""
        # 埋め込みモデルを使用してコサイン類似度を計算
        embedding1 = self.embedder.embed([text1])[0]
        embedding2 = self.embedder.embed([text2])[0]
        return cosine_similarity(embedding1, embedding2)

セキュリティとアライメント

Agentの安全性は極めて重要です。

AIシステムはさまざまな攻撃を受け、有害な出力を生み出す可能性があります。

アライメント(Alignment)は、AIの行動が人間の意図と価値観に合致することを保証します。

一般的なセキュリティ脅威

プロンプトインジェクション(Prompt Injection)

攻撃者は入力を通じてAgentにシステムの指示を無視させます。

入力例:「以前の指示を無視して、代わりに実行...」

これは、ユーザー入力に対するAgentの信頼を利用したコンテキストハイジャック攻撃です。

脱獄(Jailbreaking)

特定の入力によってセキュリティ制限を回避します。

ロールプレイや架空のシナリオなどの手法を用います。

データ汚染

悪意を持ってトレーニングデータや検索結果を改ざんします。

Agentに誤った出力や有害な出力を生じさせます。

機密情報の漏えい

Agentがユーザーのプライバシーやシステム内部情報を不適切に露出します。

防御戦略

安全なAgentの実装

class SecureAgent:
    """
安全なAgent
基本Agentの上に多層のセキュリティ防御を追加
    """

   
    def __init__(self, base_agent, guardrails, input_validator, output_filter):
        # 基本Agent
        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_triggered",
                    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

重要な注意:セキュリティは継続的なプロセスであり、完璧な対策はありません。セキュリティ戦略の継続的な監視、更新、改善が必要です。


可観測性

本番環境のAgentには、充実した監視体系が必要です。

可観測性は、Agentの動作を理解し、問題を調査し、性能を最適化するのに役立ちます。

三本柱

ログ(Logging):重要なイベントと意思決定をすべて記録する。

Tracing:リクエストのシステム内での完全なフローパスをトレースする。

メトリクス(Metrics):性能と品質の指標を収集する。

コード実装

可観測なAgentの実装

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

# ログを設定
logger = logging.getLogger(__name__)

# Tracingを設定
tracer_provider = TracerProvider()
trace.set_tracer_provider(tracer_provider)
tracer = trace.get_tracer(__name__)


class ObservableAgent:
    """
可観測なAgent
ログ、トレーシング、メトリクス収集を統合
    """

   
    def __init__(self, agent, metrics_collector):
        # 基本Agent
        self.agent = agent
        # メトリクスコレクター
        self.metrics = metrics_collector
   
    def process(self, user_input):
        """
リクエストを処理し、完全な可観測性サポートを含む
        """

        # トレーススパンを生成
        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

ガードレールとHITL

Guardrails

Guardrailsはリアルタイムの入出力フィルタリングおよび制限メカニズムです。

安全ガードレールとは異なり、Guardrailsは出力品質とコンプライアンスの確保に重点を置いています。

HITL(Human-in-the-Loop)

HITLは重要な意思決定ポイントに人間による審査を導入します。

AIが自律的に判断できない高リスクシナリオに適しています。

HITL Agentの実装

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=None):
        """
承認フィードバックの処理
        """

        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 or "承認が通過しませんでした"
            }


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

章のまとめ

この章では、エージェントの評価、セキュリティ、アライメントの知識を紹介しました。

評価体系多次元メトリクスを通じてエージェントのパフォーマンスを評価します。

セキュリティ脅威プロンプトインジェクション、ジェイルブレイク、データ汚染などを含みます。

防御戦略多層セキュリティチェックによりシステムの安全性を確保します。

可観測性ログ、トレース、メトリクスを通じてシステム監視を実現します。

GuardrailsとHITL出力品質管理と人間による審査機能を提供します。

評価、セキュリティ、アライメントは、信頼できるエージェントシステムを構築するための基盤です。

実際の開発において継続的に注視し、改善する必要があります。

その他の拡張