当你开发了一个AI Agent在演示时表现完美但在真实业务场景中却频繁出错——这可能是每个Agent开发者最头疼的问题。传统的任务成功率指标就像考试分数只能告诉你结果却无法解释为什么失败、在哪里失败、如何改进。真正的生产级Agent评估需要从黑盒测试转向白盒分析不仅要看最终结果更要深入每个决策步骤、工具调用、轨迹路径。本文将带你构建一个立体化的Agent评测体系从基础的任务成功率到细粒度的轨迹评估用代码实现可落地的断言机制。1. 为什么传统Agent评估方法已经不够用在AI Agent开发中最常见的误区就是过度依赖单一的任务完成率指标。一个电商客服Agent可能成功处理了85%的退货申请但这个数字背后隐藏着严重问题隐藏的低效路径Agent可能通过10轮对话才完成本应3轮解决的问题工具调用冗余重复调用库存查询API增加不必要的成本决策逻辑缺陷在复杂场景下做出高风险但技术上正确的决策用户体验问题虽然任务完成但交互过程生硬不自然传统评估就像只看高考总分而现代Agent评估需要像学科能力分析报告拆解到每个能力维度。以金融风控Agent为例批准了92%的贷款申请看起来很成功但如果其中有5%的决策存在合规风险带来的损失可能远超那8%的拒绝率。2. Agent评估的核心指标体系从结果到过程的全方位监控2.1 业务效果指标关注最终价值交付任务完成率Task Completion Rate是最基础的指标但需要明确定义完成的标准def calculate_task_completion_rate(successful_tasks, total_tasks): 计算任务完成率 :param successful_tasks: 成功任务数 :param total_tasks: 总任务数 :return: 完成率百分比 if total_tasks 0: return 0.0 return (successful_tasks / total_tasks) * 100 # 示例电商客服场景 refund_requests 100 successful_refunds 85 completion_rate calculate_task_completion_rate(successful_refunds, refund_requests) print(f退货任务完成率: {completion_rate}%)决策准确率Decision Accuracy对于多步骤任务尤为重要def calculate_decision_accuracy(correct_decisions, total_decisions): 计算决策准确率 - 适用于多步骤推理任务 :param correct_decisions: 正确决策步骤数 :param total_decisions: 总决策步骤数 :return: 准确率百分比 if total_decisions 0: return 0.0 return (correct_decisions / total_decisions) * 100 # 医疗诊断Agent示例 diagnosis_steps 1000 correct_diagnosis_steps 920 accuracy calculate_decision_accuracy(correct_diagnosis_steps, diagnosis_steps) print(f诊断决策准确率: {accuracy}%)2.2 效率指标优化资源利用和响应速度平均交互轮数Average Interaction Turns直接反映Agent的问题解决效率class EfficiencyMetrics: def __init__(self): self.interaction_records [] def add_interaction(self, task_id, turns, success): self.interaction_records.append({ task_id: task_id, turns: turns, success: success }) def calculate_avg_turns(self, success_onlyTrue): 计算平均交互轮数 if success_only: records [r for r in self.interaction_records if r[success]] else: records self.interaction_records if not records: return 0 total_turns sum(r[turns] for r in records) return total_turns / len(records) def calculate_response_time(self): 计算平均响应时间 # 实际实现需要记录时间戳 pass # 使用示例 metrics EfficiencyMetrics() metrics.add_interaction(task_001, 5, True) metrics.add_interaction(task_002, 8, True) metrics.add_interaction(task_003, 12, False) avg_turns metrics.calculate_avg_turns(success_onlyTrue) print(f成功任务平均交互轮数: {avg_turns})2.3 安全与合规指标规避业务风险偏见发生率Bias Rate和规则合规率Rule Compliance Rate是生产环境必须监控的指标class SafetyMetrics: def __init__(self): self.bias_incidents 0 self.total_decisions 0 self.rule_violations 0 def record_decision(self, decision_data, has_biasFalse, violates_ruleFalse): self.total_decisions 1 if has_bias: self.bias_incidents 1 if violates_rule: self.rule_violations 1 def calculate_bias_rate(self): if self.total_decisions 0: return 0.0 return (self.bias_incidents / self.total_decisions) * 100 def calculate_compliance_rate(self): if self.total_decisions 0: return 0.0 compliant_decisions self.total_decisions - self.rule_violations return (compliant_decisions / self.total_decisions) * 100 # 招聘筛选Agent示例 safety_metrics SafetyMetrics() # 模拟1000次简历筛选 for i in range(1000): # 在实际应用中这里会有偏见检测逻辑 has_bias i % 100 0 # 模拟1%的偏见率 violates_rule i % 200 0 # 模拟0.5%的规则违反率 safety_metrics.record_decision({}, has_bias, violates_rule) print(f偏见发生率: {safety_metrics.calculate_bias_rate()}%) print(f规则合规率: {safety_metrics.calculate_compliance_rate()}%)3. 主流Agent评估框架深度解析3.1 AgentBoard细粒度轨迹分析与可视化AgentBoard的核心价值在于将黑盒的Agent决策过程变得可观测、可分析。以下是其核心指标的代码实现class AgentBoardMetrics: def __init__(self, max_steps50): self.max_steps max_steps self.trajectories [] def record_trajectory(self, task_id, steps, success, progress_rates): 记录任务轨迹 :param task_id: 任务标识 :param steps: 总步数 :param success: 是否成功 :param progress_rates: 每步的进度率列表 trajectory { task_id: task_id, steps: steps, success: success, progress_rates: progress_rates, final_progress: progress_rates[-1] if progress_rates else 0 } self.trajectories.append(trajectory) def calculate_success_rate(self): 计算任务成功率 if not self.trajectories: return 0.0 successful sum(1 for t in self.trajectories if t[success]) return successful / len(self.trajectories) def calculate_progress_rate(self): 计算平均进度率 if not self.trajectories: return 0.0 total_progress sum(t[final_progress] for t in self.trajectories) return total_progress / len(self.trajectories) def calculate_grounding_accuracy(self): 计算基础准确率 - 有效动作比例 # 需要记录每个步骤的动作有效性 pass def analyze_difficulty_breakdown(self, difficulty_labels): 难度分层分析 easy_trajectories [] hard_trajectories [] for traj, difficulty in zip(self.trajectories, difficulty_labels): if difficulty easy: easy_trajectories.append(traj) else: hard_trajectories.append(traj) easy_success_rate self._calculate_subset_success_rate(easy_trajectories) hard_success_rate self._calculate_subset_success_rate(hard_trajectories) return { easy_success_rate: easy_success_rate, hard_success_rate: hard_success_rate, performance_gap: easy_success_rate - hard_success_rate } def _calculate_subset_success_rate(self, trajectories): if not trajectories: return 0.0 successful sum(1 for t in trajectories if t[success]) return successful / len(trajectories) # 使用示例 metrics AgentBoardMetrics() # 记录5个任务的轨迹 metrics.record_trajectory(task1, 10, True, [0.1, 0.3, 0.5, 0.7, 0.9, 1.0]) metrics.record_trajectory(task2, 8, True, [0.2, 0.4, 0.6, 0.8, 1.0]) metrics.record_trajectory(task3, 15, False, [0.1, 0.2, 0.3, 0.4, 0.5]) metrics.record_trajectory(task4, 12, True, [0.1, 0.3, 0.5, 0.8, 1.0]) metrics.record_trajectory(task5, 6, False, [0.2, 0.4, 0.6]) print(f成功率: {metrics.calculate_success_rate():.2%}) print(f平均进度率: {metrics.calculate_progress_rate():.2%}) # 难度分析 difficulty_labels [easy, hard, hard, easy, medium] breakdown metrics.analyze_difficulty_breakdown(difficulty_labels) print(f简单任务成功率: {breakdown[easy_success_rate]:.2%}) print(f困难任务成功率: {breakdown[hard_success_rate]:.2%})3.2 AgentBench多环境综合能力评估AgentBench通过8个不同环境全面测试Agent的泛化能力以下是其评估逻辑的核心实现class AgentBenchEvaluator: def __init__(self): self.environments { os: Operating System, db: Database, kg: Knowledge Graph, dcg: Digital Card Game, ltp: Lateral Thinking Puzzles, hh: House-Holding, ws: Web Shopping, wb: Web Browsing } self.results {env: [] for env in self.environments} def evaluate_environment(self, environment, tasks): 在特定环境中评估Agent :param environment: 环境标识 :param tasks: 任务列表 :return: 评估结果 success_count 0 total_reward 0 for task in tasks: result self._execute_task(environment, task) if result[success]: success_count 1 total_reward result[reward] self.results[environment].append(result) success_rate success_count / len(tasks) if tasks else 0 avg_reward total_reward / len(tasks) if tasks else 0 return { environment: environment, success_rate: success_rate, average_reward: avg_reward, total_tasks: len(tasks) } def _execute_task(self, environment, task): 执行单个任务简化版 # 实际实现需要与具体环境交互 if environment db: return self._evaluate_database_task(task) elif environment ws: return self._evaluate_web_shopping_task(task) # 其他环境实现... else: return {success: False, reward: 0, steps: 0} def _evaluate_database_task(self, task): 评估数据库任务 # 模拟SQL查询评估 expected_result task.get(expected_result) agent_sql task.get(agent_sql) # 简化版检查SQL语法和逻辑 success self._validate_sql(agent_sql, expected_result) reward 1.0 if success else 0.0 return {success: success, reward: reward, steps: 1} def _validate_sql(self, sql, expected): 简化版SQL验证 # 实际实现需要执行SQL并比较结果 return True # 简化实现 def generate_comprehensive_report(self): 生成综合评估报告 report {} for env in self.environments: env_results self.results[env] if env_results: success_rate sum(1 for r in env_results if r[success]) / len(env_results) avg_reward sum(r[reward] for r in env_results) / len(env_results) report[env] { success_rate: success_rate, average_reward: avg_reward, sample_size: len(env_results) } return report # 使用示例 evaluator AgentBenchEvaluator() # 模拟数据库环境测试 db_tasks [ {agent_sql: SELECT * FROM users, expected_result: user_list}, {agent_sql: INSERT INTO orders VALUES (...), expected_result: success} ] db_result evaluator.evaluate_environment(db, db_tasks) print(f数据库任务成功率: {db_result[success_rate]:.2%}) # 生成完整报告 report evaluator.generate_comprehensive_report() for env, metrics in report.items(): print(f{env}: 成功率{metrics[success_rate]:.2%}, 平均奖励{metrics[average_reward]:.2f})3.3 τ-bench真实业务场景可靠性测试τ-bench专注于业务场景下的稳定性和规则遵循能力以下是其核心评估逻辑class TauBenchEvaluator: def __init__(self): self.task_results [] self.rule_violations [] def evaluate_reliability(self, tasks, k3): 评估Agent的可靠性pass^k指标 :param tasks: 任务列表 :param k: 重复次数 :return: 可靠性指标 pass_k_results [] for task in tasks: # 对每个任务重复k次 k_results [] for attempt in range(k): result self._execute_single_attempt(task) k_results.append(result[success]) # 计算pass^kk次全部成功才算通过 pass_k all(k_results) pass_k_results.append(pass_k) self.task_results.append({ task_id: task[id], k_results: k_results, pass_k: pass_k, rule_compliance: result[rule_compliance] }) pass_k_rate sum(pass_k_results) / len(pass_k_results) if pass_k_results else 0 return pass_k_rate def _execute_single_attempt(self, task): 执行单次尝试 # 模拟任务执行 success self._simulate_task_execution(task) rule_compliance self._check_rule_compliance(task) return { success: success, rule_compliance: rule_compliance, session_length: task.get(session_length, 0) } def _simulate_task_execution(self, task): 模拟任务执行简化版 # 实际实现需要与真实环境交互 return True # 简化实现 def _check_rule_compliance(self, task): 检查规则合规性 # 模拟规则检查逻辑 return True # 简化实现 def calculate_rule_compliance_rate(self): 计算规则合规率 if not self.task_results: return 0.0 compliant sum(1 for r in self.task_results if r[rule_compliance]) return compliant / len(self.task_results) def analyze_error_breakdown(self): 错误类型分析 error_types {} for result in self.task_results: if not result[pass_k]: # 分析失败原因 error_type self._classify_error(result) error_types[error_type] error_types.get(error_type, 0) 1 return error_types def _classify_error(self, result): 错误分类 # 简化错误分类逻辑 return unknown_error # 使用示例 evaluator TauBenchEvaluator() # 模拟航旅改签任务 travel_tasks [ {id: task1, type: flight_change, rules: [no_direct_change]}, {id: task2, type: refund, rules: [within_24h]} ] reliability evaluator.evaluate_reliability(travel_tasks, k3) print(f3次重复可靠性: {reliability:.2%}) compliance_rate evaluator.calculate_rule_compliance_rate() print(f规则合规率: {compliance_rate:.2%})4. 实战构建自定义Agent评估系统4.1 评估数据准备与测试集构建生产级评估的第一步是构建高质量的测试数据集import json from typing import List, Dict, Any class AgentTestSuite: def __init__(self): self.test_cases [] self.metadata {} def add_test_case(self, case_id: str, input_data: Dict, expected_output: Any, difficulty: str medium, tags: List[str] None): 添加测试用例 test_case { case_id: case_id, input: input_data, expected_output: expected_output, difficulty: difficulty, tags: tags or [], metadata: { created_at: 2024-01-01, version: 1.0 } } self.test_cases.append(test_case) def generate_from_conversations(self, conversation_logs: List[Dict]): 从真实对话记录生成测试用例 for i, conversation in enumerate(conversation_logs): case_id fconv_{i1} input_data { user_query: conversation[user_input], context: conversation.get(context, {}) } expected_output { final_response: conversation[agent_response], tool_calls: conversation.get(tool_calls, []), success: conversation.get(success, True) } self.add_test_case(case_id, input_data, expected_output) def save_test_suite(self, filepath: str): 保存测试套件 suite_data { metadata: self.metadata, test_cases: self.test_cases, version: 1.0, total_cases: len(self.test_cases) } with open(filepath, w, encodingutf-8) as f: json.dump(suite_data, f, indent2, ensure_asciiFalse) def load_test_suite(self, filepath: str): 加载测试套件 with open(filepath, r, encodingutf-8) as f: suite_data json.load(f) self.metadata suite_data.get(metadata, {}) self.test_cases suite_data.get(test_cases, []) def get_cases_by_difficulty(self, difficulty: str) - List[Dict]: 按难度筛选测试用例 return [case for case in self.test_cases if case[difficulty] difficulty] def get_cases_by_tag(self, tag: str) - List[Dict]: 按标签筛选测试用例 return [case for case in self.test_cases if tag in case[tags]] # 使用示例 test_suite AgentTestSuite() # 添加电商客服测试用例 test_suite.add_test_case( case_idrefund_001, input_data{ user_query: 我想退货订单号12345, context: {user_tier: vip, order_age: 3} }, expected_output{ final_response: 已为您处理退货申请, tool_calls: [check_order_status, initiate_refund], success: True }, difficultyeasy, tags[refund, customer_service] ) # 从真实数据生成测试用例 conversation_logs [ { user_input: 查询订单物流, agent_response: 您的订单正在运输中, tool_calls: [query_logistics], success: True } ] test_suite.generate_from_conversations(conversation_logs) test_suite.save_test_suite(agent_test_suite.json) # 按难度获取用例 easy_cases test_suite.get_cases_by_difficulty(easy) print(f简单难度用例数: {len(easy_cases)})4.2 评估执行引擎与指标计算构建完整的评估执行系统import time from datetime import datetime from abc import ABC, abstractmethod class EvaluationEngine(ABC): def __init__(self, test_suite: AgentTestSuite): self.test_suite test_suite self.results [] self.metrics {} abstractmethod def evaluate_agent(self, agent, test_cases: List[Dict]) - Dict: 评估Agent的核心方法 pass def run_full_evaluation(self, agent, include_metrics: List[str] None): 运行完整评估 start_time time.time() # 执行所有测试用例 evaluation_results [] for test_case in self.test_suite.test_cases: result self._evaluate_single_case(agent, test_case) evaluation_results.append(result) # 计算指标 self.results evaluation_results self._calculate_metrics(include_metrics or [success_rate, avg_turns]) execution_time time.time() - start_time return { timestamp: datetime.now().isoformat(), execution_time: execution_time, total_cases: len(evaluation_results), results: evaluation_results, metrics: self.metrics } def _evaluate_single_case(self, agent, test_case: Dict) - Dict: 评估单个测试用例 case_start time.time() try: # 执行Agent agent_response agent.process(test_case[input]) # 验证结果 success self._validate_result(agent_response, test_case[expected_output]) turns len(agent_response.get(interaction_history, [])) result { case_id: test_case[case_id], success: success, turns: turns, response: agent_response, execution_time: time.time() - case_start, error: None } except Exception as e: result { case_id: test_case[case_id], success: False, turns: 0, response: None, execution_time: time.time() - case_start, error: str(e) } return result def _validate_result(self, actual: Dict, expected: Dict) - bool: 验证结果是否符合预期 # 简化验证逻辑 if not actual or not expected: return False # 检查关键字段匹配 if final_response in expected: return expected[final_response] in str(actual.get(response, )) return True def _calculate_metrics(self, metric_names: List[str]): 计算指定指标 self.metrics {} if success_rate in metric_names: successful sum(1 for r in self.results if r[success]) self.metrics[success_rate] successful / len(self.results) if self.results else 0 if avg_turns in metric_names: turns [r[turns] for r in self.results if r[success]] self.metrics[avg_turns] sum(turns) / len(turns) if turns else 0 if avg_execution_time in metric_names: times [r[execution_time] for r in self.results] self.metrics[avg_execution_time] sum(times) / len(times) if times else 0 class ComprehensiveEvaluator(EvaluationEngine): def __init__(self, test_suite: AgentTestSuite): super().__init__(test_suite) self.trajectory_analyzer TrajectoryAnalyzer() def evaluate_agent(self, agent, test_cases: List[Dict]) - Dict: 综合评估Agent性能 base_results super().run_full_evaluation(agent) # 添加轨迹分析 trajectory_metrics self.trajectory_analyzer.analyze_trajectories(self.results) base_results[metrics].update(trajectory_metrics) # 添加难度分层分析 difficulty_analysis self._analyze_by_difficulty() base_results[difficulty_analysis] difficulty_analysis return base_results def _analyze_by_difficulty(self) - Dict: 按难度分层分析 difficulty_groups {} for result in self.results: case_id result[case_id] test_case next((tc for tc in self.test_suite.test_cases if tc[case_id] case_id), None) if test_case: difficulty test_case[difficulty] if difficulty not in difficulty_groups: difficulty_groups[difficulty] [] difficulty_groups[difficulty].append(result) analysis {} for difficulty, results in difficulty_groups.items(): successful sum(1 for r in results if r[success]) analysis[difficulty] { success_rate: successful / len(results), sample_size: len(results) } return analysis class TrajectoryAnalyzer: def analyze_trajectories(self, results: List[Dict]) - Dict: 分析交互轨迹 if not results: return {} # 计算轨迹相关指标 successful_trajectories [r for r in results if r[success]] if not successful_trajectories: return {progress_efficiency: 0, exploration_efficiency: 0} # 简化版轨迹分析 avg_turns sum(r[turns] for r in successful_trajectories) / len(successful_trajectories) min_turns min(r[turns] for r in successful_trajectories) return { progress_efficiency: min_turns / avg_turns if avg_turns 0 else 0, exploration_efficiency: 1.0 / avg_turns if avg_turns 0 else 0, avg_success_turns: avg_turns } # 使用示例 class MockAgent: 模拟Agent实现 def process(self, input_data): # 简化版Agent处理逻辑 return { response: f处理请求: {input_data[user_query]}, interaction_history: [step1, step2], tool_calls: [mock_tool] } # 创建评估引擎 test_suite AgentTestSuite() # ... 添加测试用例 ... evaluator ComprehensiveEvaluator(test_suite) agent MockAgent() # 运行评估 results evaluator.evaluate_agent(agent, test_suite.test_cases) print(评估结果:, json.dumps(results, indent2, ensure_asciiFalse))4.3 LLM as Judge自动化质量评估利用大语言模型进行自动化评估import openai from typing import Dict, List class LLMJudge: def __init__(self, api_key: str, model: str gpt-4): self.client openai.OpenAI(api_keyapi_key) self.model model self.evaluation_prompts self._load_evaluation_prompts() def _load_evaluation_prompts(self) - Dict: 加载评估提示模板 return { response_quality: 请评估以下AI助手的回答质量。考虑以下维度 1. 准确性回答是否准确无误 2. 完整性是否全面回答用户问题 3. 相关性是否与用户查询相关 4. 专业性语言是否专业得体 用户查询{user_query} 助手回答{agent_response} 请给出1-10分的评分并简要说明理由。 , tool_selection: 评估AI助手的工具选择合理性 任务{task_description} 选择的工具{selected_tools} 可用工具{available_tools} 工具选择是否合理请给出评分1-10和理由。 } def evaluate_response_quality(self, user_query: str, agent_response: str) - Dict: 评估回答质量 prompt self.evaluation_prompts[response_quality].format( user_queryuser_query, agent_responseagent_response ) try: response self.client.chat.completions.create( modelself.model, messages[{role: user, content: prompt}], max_tokens500 ) evaluation_text response.choices[0].message.content score, reasoning self._parse_evaluation_response(evaluation_text) return { score: score, reasoning: reasoning, evaluation_text: evaluation_text } except Exception as e: return { score: 0, reasoning: f评估失败: {str(e)}, error: True } def evaluate_tool_selection(self, task_description: str, selected_tools: List[str], available_tools: List[str]) - Dict: 评估工具选择合理性 prompt self.evaluation_prompts[tool_selection].format( task_descriptiontask_description, selected_tools, .join(selected_tools), available_tools, .join(available_tools) ) # 类似实现... return {score: 8, reasoning: 工具选择基本合理} def _parse_evaluation_response(self, text: str) - tuple: 解析评估响应 # 简化解析逻辑 lines text.split(\n) score 0 reasoning for line in lines: if 评分 in line or 分数 in line: # 提取数字 import re numbers re.findall(r\d, line) if numbers: score int(numbers[0]) break reasoning text[:200] # 取前200字符作为理由 return score, reasoning # 使用示例需要实际API密钥 # judge LLMJudge(api_keyyour-api-key) # quality_result judge.evaluate_response_quality( # 如何配置数据库连接, # 要配置数据库连接首先需要安装驱动然后设置连接字符串... # ) # print(f回答质量评分: {quality_result[score]}/10)5. 生产环境最佳实践与持续监控5.1 评估流水线设计与自动化构建自动化的评估流水线import schedule import time from datetime import datetime class EvaluationPipeline: def __init__(self, test_suite_path: str, agent_version: str): self.test_suite_path test_suite_path self.agent_version agent_version self.results_storage ResultsStorage() self.alert_system AlertSystem() def run_daily_evaluation(self): 每日评估任务 print(f开始每日评估 - {datetime.now()}) # 加载测试套件 test_suite AgentTestSuite() test_suite.load_test_suite(self.test_suite_path) # 初始化Agent生产版本 agent self._load_production_agent() # 执行评估 evaluator ComprehensiveEvaluator(test_suite) results evaluator.evaluate_agent(agent, test_suite.test_cases) # 存储结果 self.results_storage.save_evaluation_results( self.agent_version, results ) # 检查指标阈值 self._check_metric_thresholds(results[metrics]) # 生成报告 self._generate_daily_report(results) print(每日评估完成) def _load_production_agent(self): 加载生产环境Agent # 实际实现需要根据版本加载对应Agent return MockAgent() def _check_metric_thresholds(self, metrics: Dict): 检查指标是否超过阈值 thresholds { success_rate: 0.85, # 成功率低于85%触发告警 avg_turns: 10, # 平均轮数高于10触发告警 avg_execution_time: 30.0 # 平均执行时间超过30秒触发告警 } alerts [] for metric, threshold in thresholds.items(): value metrics.get(metric, 0) if metric success_rate and value threshold: alerts.append(f{metric}低于阈值: {value:.2%} {threshold:.2%}) elif metric in [avg_turns, avg_execution_time] and value threshold: alerts.append(f{metric}高于阈值: {value} {threshold}) if alerts: self.alert_system.send_alert(\n.join(alerts)) def _generate_daily_report(self, results: Dict): 生成每日评估报告 report f 每日Agent评估报告 版本: {self.agent_version} 时间: {datetime.now().strftime(%Y-%m-%d %H:%M:%S)} 总体指标: - 任务成功率: {results[metrics].get(success_rate, 0):.2%} - 平均交互轮数: {results[metrics].get(avg_turns, 0):.1f} - 平均执行时间: {results[metrics].get(avg_execution_time, 0):.2f}秒 难度分层分析: for difficulty, analysis in results.get(difficulty_analysis, {}).items(): report f- {difficulty}: 成功率{analysis[success_rate]:.2%} (样本数: {analysis[sample_size]