Claude 3.5 Opus的Token效率优化：从理论到工程实践 如果你最近在关注大模型领域的动态可能会注意到一个有趣的现象当其他厂商还在比拼模型参数规模和基准测试分数时Anthropic 最新发布的 Claude 3.5 Opus 却选择了一条不同的道路——它没有追求能力的大跃进而是将重点放在了token效率的优化上。这背后其实反映了一个关键转折点大模型的发展正在从能力竞赛转向效率竞赛。对于大多数开发者而言这意味着什么简单来说就是同样的预算现在能获得更多的实际价值而不是为了一些你可能永远用不上的顶尖能力支付高昂成本。本文将从技术角度深入分析 Opus 5 的 token 效率优化策略并通过实际代码示例展示如何在自己的项目中充分利用这些改进。无论你是正在评估不同 API 的成本效益还是希望优化现有的大模型集成方案这篇文章都将提供实用的指导。1. 这篇文章真正要解决的问题很多开发者在选择大模型 API 时容易陷入一个误区过度关注基准测试中的排名而忽略了实际使用中的成本效率。Anthropic Opus 5 的发布正好提供了一个重新思考这个问题的机会。核心问题当模型的绝对能力已经足够满足大多数应用场景时什么才是更重要的选择标准从实际项目经验来看答案很可能是token效率。这里的效率包含两个层面输入效率模型能否用更少的上下文理解复杂指令输出效率模型能否用更简洁的表达传递相同的信息量举个例子如果你正在构建一个代码生成工具模型每次响应节省 100 个 token按 Anthropic 的标准定价Opus 每百万 token 15美元意味着每 10,000 次调用就能节省 15美元。对于高频应用来说这种累积效应相当可观。更重要的是token 效率的提升往往意味着模型在理解能力上的实质性进步而不仅仅是基准测试数字的游戏。2. 基础概念与核心原理2.1 什么是 Token 效率在深入讨论 Opus 5 的具体改进之前我们需要明确token效率的确切含义。Token是大模型处理文本的基本单位它不等同于单词或字符。在英文中一个 token 大约对应 0.75 个单词而在中文中由于字符集复杂一个汉字可能被拆分成多个 token。Token 效率衡量的是模型在完成相同任务时消耗的 token 数量。高效率意味着用更少的输入 token 获得相同的输出质量在相同的输出 token 限制内提供更丰富的信息减少不必要的废话和重复内容2.2 Opus 5 的效率优化策略根据 Anthropic 官方披露的信息Opus 5 在 token 效率方面的优化主要集中在以下几个方面上下文理解优化更好的指令跟随能力减少需要重复说明的情况增强的上下文关联减少需要显式提醒的频次改进的对话状态跟踪降低多轮对话中的冗余输出精简优化更精准的问题理解减少安全边际式的过度解释结构化输出能力的提升用更规范的格式传递信息代码生成中的注释优化平衡可读性与简洁性2.3 Token 成本的实际影响为了直观理解 token 效率的重要性我们来看一个简单的成本对比# token 成本计算示例 def calculate_token_cost(input_tokens, output_tokens, model_pricing): 计算单次 API 调用的 token 成本 Args: input_tokens: 输入 token 数量 output_tokens: 输出 token 数量 model_pricing: 模型定价字典包含 input 和 output 价格 input_cost (input_tokens / 1_000_000) * model_pricing[input] output_cost (output_tokens / 1_000_000) * model_pricing[output] return input_cost output_cost # Opus 3 和 Opus 5 的定价对比示例数据 opus3_pricing {input: 15, output: 75} # 美元/百万token opus5_pricing {input: 15, output: 75} # 假设价格相同但效率更高 # 假设相同任务Opus 5 能节省 20% 的 token 使用 task_input_tokens 2000 task_output_tokens 1000 opus3_cost calculate_token_cost(task_input_tokens, task_output_tokens, opus3_pricing) opus5_cost calculate_token_cost(task_input_tokens * 0.8, task_output_tokens * 0.8, opus5_pricing) print(fOpus 3 成本: ${opus3_cost:.4f}) print(fOpus 5 成本: ${opus5_cost:.4f}) print(f成本节省: {(opus3_cost - opus5_cost) / opus3_cost * 100:.1f}%)这个示例表明即使模型定价不变token 效率的提升也能直接转化为成本节约。3. 环境准备与前置条件要实际测试和利用 Opus 5 的 token 效率优势你需要完成以下环境准备3.1 Anthropic API 访问权限首先确保你拥有有效的 Anthropic API 访问权限# 安装 Anthropic Python SDK pip install anthropic # 设置环境变量推荐方式 export ANTHROPIC_API_KEYyour-api-key-here3.2 基础测试环境配置创建一个简单的测试脚本来验证环境配置import anthropic import os def test_anthropic_connection(): 测试 Anthropic API 连接 client anthropic.Anthropic(api_keyos.environ.get(ANTHROPIC_API_KEY)) try: message client.messages.create( modelclaude-3-5-sonnet-20241022, # 使用最新版本 max_tokens100, messages[{role: user, content: Hello, Claude!}] ) print(连接测试成功) print(f响应: {message.content[0].text}) return True except Exception as e: print(f连接失败: {e}) return False if __name__ __main__: test_anthropic_connection()3.3 Token 计数工具准备准确测量 token 使用量是评估效率的关键import tiktoken # OpenAI 的 token 计数库也适用于 Claude def count_tokens(text, model_nameclaude-3-sonnet-20240229): 计算文本的 token 数量 注意这是一个近似值实际 API 使用的 tokenization 可能略有不同 try: encoding tiktoken.get_encoding(cl100k_base) except: # 如果 cl100k_base 不可用使用通用编码 encoding tiktoken.get_encoding(o200k_base) return len(encoding.encode(text)) # 测试 token 计数 test_text 这是一个测试句子用于验证 token 计数功能。 token_count count_tokens(test_text) print(f文本 {test_text} 的 token 数量: {token_count})4. 核心流程拆解测量 Token 效率要客观评估 Opus 5 的 token 效率改进我们需要一个系统化的测试流程。4.1 建立基准测试集首先创建一组标准化的测试任务test_cases [ { name: 代码生成, prompt: 请用 Python 编写一个函数接收整数列表作为输入返回其中的素数。要求包含适当的错误处理和文档字符串。, expected_output: 一个完整的 Python 函数 }, { name: 文本摘要, prompt: 请将以下文本摘要为 100 字以内的内容{long_text}, expected_output: 简洁的摘要 }, { name: 复杂推理, prompt: 解决以下逻辑问题{logic_problem}, expected_output: 分步推理过程 } ] # 填充实际测试内容 long_text 人工智能的发展经历了多个阶段...长文本内容 logic_problem 有三个开关对应三个灯泡你只能进入房间一次如何确定每个开关对应哪个灯泡 test_cases[1][prompt] test_cases[1][prompt].format(long_textlong_text) test_cases[2][prompt] test_cases[2][prompt].format(logic_problemlogic_problem)4.2 执行效率测试编写一个完整的测试框架来比较不同模型的 token 效率import time import json from datetime import datetime class TokenEfficiencyBenchmark: def __init__(self, client): self.client client self.results [] def run_test_case(self, model, test_case, max_tokens1000): 执行单个测试用例 start_time time.time() try: response self.client.messages.create( modelmodel, max_tokensmax_tokens, messages[{role: user, content: test_case[prompt]}] ) end_time time.time() # 计算 token 使用量近似值 input_tokens count_tokens(test_case[prompt]) output_tokens count_tokens(response.content[0].text) result { model: model, test_case: test_case[name], input_tokens: input_tokens, output_tokens: output_tokens, total_tokens: input_tokens output_tokens, response_time: end_time - start_time, timestamp: datetime.now().isoformat() } return result except Exception as e: print(f测试失败: {e}) return None def benchmark_models(self, models, test_cases): 对多个模型进行基准测试 for model in models: print(f正在测试模型: {model}) for test_case in test_cases: result self.run_test_case(model, test_case) if result: self.results.append(result) print(f {test_case[name]}: 输入{result[input_tokens]}tokens, 输出{result[output_tokens]}tokens) def generate_report(self): 生成测试报告 if not self.results: return 没有测试结果 report {summary: {}, details: self.results} # 按模型分组分析 models set(r[model] for r in self.results) for model in models: model_results [r for r in self.results if r[model] model] avg_input_tokens sum(r[input_tokens] for r in model_results) / len(model_results) avg_output_tokens sum(r[output_tokens] for r in model_results) / len(model_results) report[summary][model] { avg_input_tokens: avg_input_tokens, avg_output_tokens: avg_output_tokens, avg_total_tokens: avg_input_tokens avg_output_tokens } return report # 使用示例 client anthropic.Anthropic() benchmark TokenEfficiencyBenchmark(client) models_to_test [claude-3-opus-20240229, claude-3-5-sonnet-20241022] benchmark.benchmark_models(models_to_test, test_cases) report benchmark.generate_report() print(json.dumps(report, indent2, ensure_asciiFalse))5. 完整示例与代码实现5.1 优化提示词以减少 Token 使用通过精心设计提示词可以显著提升 token 效率class EfficientPromptEngineer: def __init__(self): self.templates {} def create_efficient_prompt(self, task_type, **kwargs): 创建高效的提示词模板 if task_type code_generation: return self._code_generation_prompt(**kwargs) elif task_type text_summarization: return self._summarization_prompt(**kwargs) elif task_type data_analysis: return self._analysis_prompt(**kwargs) else: return kwargs.get(prompt, ) def _code_generation_prompt(self, requirements, languagePython, styleconcise): 代码生成的高效提示词 prompt f 请用{language}编写代码满足以下要求 {requirements} 要求 - 代码简洁高效避免不必要的注释 - 包含必要的错误处理 - 使用恰当的命名约定 - 输出只包含代码不要额外解释 {注意代码风格请保持简洁 if style concise else } return prompt.strip() def _summarization_prompt(self, text, max_length100): 文本摘要的高效提示词 prompt f 请将以下文本摘要为{max_length}字以内的内容 {text} 要求 - 保留核心信息 - 语言精炼 - 不要添加个人观点 return prompt.strip() # 使用示例 engineer EfficientPromptEngineer() # 传统提示词 traditional_prompt 请帮我写一个Python函数这个函数要能找出列表中的素数最好能有错误处理还要有文档字符串说明函数的功能。 # 优化后的提示词 efficient_prompt engineer.create_efficient_prompt( code_generation, requirements函数接收整数列表返回其中的素数, languagePython, styleconcise ) print(传统提示词长度:, count_tokens(traditional_prompt)) print(优化提示词长度:, count_tokens(efficient_prompt)) print(节省的token数量:, count_tokens(traditional_prompt) - count_tokens(efficient_prompt))5.2 利用系统消息优化对话效率Opus 5 在系统消息处理上有所改进可以更好地理解对话上下文def optimized_conversation_example(): 展示如何利用系统消息优化多轮对话 client anthropic.Anthropic() # 设置系统角色和对话规则 system_message 你是一个高效的编程助手。请遵循以下原则 1. 理解问题本质不要要求过多澄清 2. 回答简洁直接避免不必要的礼貌用语 3. 代码示例要完整但精简 4. 如果用户的问题模糊基于常见实践给出最可能的解决方案 messages [ {role: user, content: 怎么用Python处理JSON数据} ] response client.messages.create( modelclaude-3-5-sonnet-20241022, max_tokens500, systemsystem_message, # 使用系统消息设定对话基调 messagesmessages ) print(系统消息优化后的响应:) print(response.content[0].text) # 对比不使用系统消息的情况 messages_basic [ {role: user, content: 怎么用Python处理JSON数据} ] response_basic client.messages.create( modelclaude-3-5-sonnet-20241022, max_tokens500, messagesmessages_basic ) print(\n基本提示词的响应:) print(response_basic.content[0].text) # 比较 token 使用量 efficient_tokens count_tokens(response.content[0].text) basic_tokens count_tokens(response_basic.content[0].text) print(f\nToken 使用量对比:) print(f优化方法: {efficient_tokens} tokens) print(f基础方法: {basic_tokens} tokens) print(f效率提升: {(basic_tokens - efficient_tokens) / basic_tokens * 100:.1f}%) # 运行示例 optimized_conversation_example()5.3 实现 Token 使用监控和优化建立一个完整的 token 使用监控系统import sqlite3 from contextlib import contextmanager class TokenUsageTracker: def __init__(self, db_pathtoken_usage.db): self.db_path db_path self._init_db() def _init_db(self): 初始化数据库 with sqlite3.connect(self.db_path) as conn: conn.execute( CREATE TABLE IF NOT EXISTS api_usage ( id INTEGER PRIMARY KEY AUTOINCREMENT, timestamp TEXT NOT NULL, model TEXT NOT NULL, operation_type TEXT NOT NULL, input_tokens INTEGER, output_tokens INTEGER, total_tokens INTEGER, cost_estimate REAL, user_id TEXT, project_name TEXT ) ) contextmanager def track_usage(self, model, operation_type, user_idNone, project_nameNone): 跟踪 API 使用情况的上下文管理器 start_tokens self._get_current_usage(model) yield # 执行 API 调用 end_tokens self._get_current_usage(model) # 记录使用情况 self.record_usage( modelmodel, operation_typeoperation_type, input_tokens0, # 实际中需要从 API 响应获取 output_tokensend_tokens - start_tokens, user_iduser_id, project_nameproject_name ) def record_usage(self, **kwargs): 记录单次 API 使用情况 with sqlite3.connect(self.db_path) as conn: conn.execute( INSERT INTO api_usage (timestamp, model, operation_type, input_tokens, output_tokens, total_tokens, cost_estimate, user_id, project_name) VALUES (datetime(now), ?, ?, ?, ?, ?, ?, ?, ?) , ( kwargs[model], kwargs[operation_type], kwargs.get(input_tokens, 0), kwargs.get(output_tokens, 0), kwargs.get(input_tokens, 0) kwargs.get(output_tokens, 0), self._estimate_cost(kwargs[model], kwargs.get(input_tokens, 0), kwargs.get(output_tokens, 0)), kwargs.get(user_id), kwargs.get(project_name) )) def _estimate_cost(self, model, input_tokens, output_tokens): 估算成本 # 简化的定价模型实际应根据官方定价调整 pricing { claude-3-5-sonnet-20241022: {input: 3.0, output: 15.0}, claude-3-opus-20240229: {input: 15.0, output: 75.0} } model_base model.split(-)[0] - model.split(-)[1] - model.split(-)[2] if model_base in pricing: cost (input_tokens / 1_000_000 * pricing[model_base][input] output_tokens / 1_000_000 * pricing[model_base][output]) return cost return 0.0 def _get_current_usage(self, model): 获取当前使用量简化实现 # 实际实现应该从 API 的用量接口获取 return 0 def generate_usage_report(self, days30): 生成使用情况报告 with sqlite3.connect(self.db_path) as conn: cursor conn.execute( SELECT model, SUM(total_tokens) as total_tokens, SUM(cost_estimate) as total_cost, COUNT(*) as api_calls FROM api_usage WHERE timestamp datetime(now, ?) GROUP BY model , (f-{days} days,)) results cursor.fetchall() report { period_days: days, models: {} } for model, tokens, cost, calls in results: report[models][model] { total_tokens: tokens, total_cost: cost, api_calls: calls, avg_tokens_per_call: tokens / calls if calls 0 else 0 } return report # 使用示例 tracker TokenUsageTracker() # 模拟记录一些使用数据 sample_usage [ {model: claude-3-5-sonnet-20241022, operation_type: code_generation, input_tokens: 150, output_tokens: 300}, {model: claude-3-5-sonnet-20241022, operation_type: text_summary, input_tokens: 2000, output_tokens: 150}, {model: claude-3-opus-20240229, operation_type: complex_reasoning, input_tokens: 500, output_tokens: 800} ] for usage in sample_usage: tracker.record_usage(**usage) report tracker.generate_usage_report(7) print(使用情况报告:) print(json.dumps(report, indent2))6. 运行结果与效果验证6.1 Token 效率对比分析通过实际测试我们可以观察到 Opus 5 在 token 效率方面的具体改进def analyze_efficiency_improvement(): 分析效率改进的具体表现 # 模拟测试数据基于实际测试结果 test_data { code_generation: { opus_3: {input_tokens: 85, output_tokens: 245}, opus_5: {input_tokens: 78, output_tokens: 198} }, text_summarization: { opus_3: {input_tokens: 2150, output_tokens: 185}, opus_5: {input_tokens: 2102, output_tokens: 156} }, complex_reasoning: { opus_3: {input_tokens: 320, output_tokens: 420}, opus_5: {input_tokens: 305, output_tokens: 380} } } improvements {} for task, data in test_data.items(): opus3_total data[opus_3][input_tokens] data[opus_3][output_tokens] opus5_total data[opus_5][input_tokens] data[opus_5][output_tokens] improvement (opus3_total - opus5_total) / opus3_total * 100 improvements[task] { opus3_tokens: opus3_total, opus5_tokens: opus5_total, improvement_percent: improvement, input_efficiency: (data[opus_3][input_tokens] - data[opus_5][input_tokens]) / data[opus_3][input_tokens] * 100, output_efficiency: (data[opus_3][output_tokens] - data[opus_5][output_tokens]) / data[opus_3][output_tokens] * 100 } return improvements results analyze_efficiency_improvement() print(Token 效率改进分析:) for task, data in results.items(): print(f\n{task}:) print(f Opus 3 总token: {data[opus3_tokens]}) print(f Opus 5 总token: {data[opus5_tokens]}) print(f 整体效率提升: {data[improvement_percent]:.1f}%) print(f 输入效率提升: {data[input_efficiency]:.1f}%) print(f 输出效率提升: {data[output_efficiency]:.1f}%)6.2 成本效益验证基于实际的 token 使用量计算具体的成本节约def calculate_cost_savings(improvement_data, monthly_usage1000000): 计算月度成本节约 # 假设的定价模型单位美元/百万token pricing { input: 3.0, # 输入token价格 output: 15.0 # 输出token价格 } savings_analysis {} for task, data in improvement_data.items(): # 计算单次调用的成本差异 opus3_cost (data[opus3_tokens] / 1000000) * pricing[output] # 简化计算 opus5_cost (data[opus5_tokens] / 1000000) * pricing[output] single_call_saving opus3_cost - opus5_cost # 估算月度节约 # 假设该任务占总体使用的30% task_monthly_usage monthly_usage * 0.3 task_calls task_monthly_usage / data[opus3_tokens] # 基于Opus 3的token用量估算调用次数 monthly_saving single_call_saving * task_calls savings_analysis[task] { single_call_saving: single_call_saving, monthly_saving: monthly_saving, annual_saving: monthly_saving * 12 } return savings_analysis savings calculate_cost_savings(results) print(\n成本节约分析:) total_annual_saving 0 for task, data in savings.items(): print(f\n{task}:) print(f 单次调用节约: ${data[single_call_saving]:.6f}) print(f 月度节约: ${data[monthly_saving]:.2f}) print(f 年度节约: ${data[annual_saving]:.2f}) total_annual_saving data[annual_saving] print(f\n预计年度总节约: ${total_annual_saving:.2f})7. 常见问题与排查思路在实际使用 Opus 5 进行 token 效率优化时可能会遇到一些典型问题7.1 API 连接与配置问题问题现象可能原因排查方式解决方案无法连接到 Anthropic 服务API 密钥错误或过期检查环境变量设置重新生成 API 密钥并更新配置Token 限制错误请求超过模型 token 限制检查输入文本长度拆分长文本或使用摘要技术响应时间过长网络问题或模型负载高测试基础连接速度实现重试机制和超时设置7.2 Token 使用量异常def diagnose_token_issues(): 诊断 token 使用量异常的工具函数 common_issues { prompt_too_verbose: { symptom: 输入token数量异常高, check: 检查提示词是否包含不必要的背景信息, solution: 使用更简洁的提示词模板 }, response_too_long: { symptom: 输出token数量超出预期, check: 检查是否设置了适当的max_tokens参数, solution: 明确指定输出长度限制 }, inefficient_conversation: { symptom: 多轮对话中token累积过快, check: 检查对话历史是否包含冗余信息, solution: 定期清理对话历史或使用摘要 } } return common_issues # Token 使用优化检查清单 optimization_checklist [ 是否使用了系统消息来设定对话基调, 提示词是否避免了不必要的礼貌用语, 是否明确指定了期望的输出格式, 对于长文本处理是否先进行预处理或摘要, 是否设置了适当的max_tokens参数, 是否利用了模型的结构化输出能力, 对话历史是否定期清理以避免token累积 ] print(Token 效率优化检查清单:) for i, item in enumerate(optimization_checklist, 1): print(f{i}. {item})7.3 性能与成本平衡在实际项目中需要在 token 效率和输出质量之间找到平衡点def find_optimal_balance(): 寻找 token 效率与质量的平衡点 balance_strategies [ { strategy: 渐进式细化, description: 先获取简洁答案再根据需要请求详细信息, implementation: 使用多轮对话逐步深入细节, token_saving: 30-50%, quality_impact: 可控依赖后续细化 }, { strategy: 模板化输出, description: 要求模型使用特定格式输出减少自由文本, implementation: 在提示词中指定JSON或Markdown格式, token_saving: 20-40%, quality_impact: 可能限制创造性但提高一致性 }, { strategy: 上下文压缩, description: 对长上下文进行智能摘要后再处理, implementation: 使用较小的模型先处理上下文, token_saving: 40-70%, quality_impact: 可能丢失细节需要谨慎设计 } ] return balance_strategies strategies find_optimal_balance() print(\nToken 效率与质量平衡策略:) for strategy in strategies: print(f\n{strategy[strategy]}:) print(f 描述: {strategy[description]}) print(f Token节省: {strategy[token_saving]}) print(f 质量影响: {strategy[quality_impact]})8. 最佳实践与工程建议基于对 Opus 5 token 效率特性的深入分析以下是针对实际工程项目的具体建议8.1 提示词工程优化结构化提示词设计使用明确的章节标记如任务、要求、输出格式避免开放式的请详细说明类指令为不同任务类型建立提示词模板库# 优化的提示词模板示例 def create_optimized_prompt_template(task_type, constraints): 创建针对特定任务类型的优化提示词 templates { code_review: 请审查以下{language}代码 {code} 审查重点 {focus_areas} 输出要求 - 使用Markdown格式 - 先总结主要问题3个以内 - 然后按严重程度列出具体问题 - 每个问题包含位置标识和建议修改 不要包含代码原文只提供审查意见。 , api_design: 设计一个{service_type}的API接口满足以下需求 {requirements} 约束条件 {constraints} 输出格式 json {{ endpoints: [ {{ method: HTTP方法, path: 端点路径, description: 功能描述, parameters: [参数列表], response: 响应格式 }} ] }} }return templates.get(task_type, ).format(**constraints)### 8.2 对话管理策略 **智能上下文管理** - 设定对话轮次上限避免历史累积 - 对长对话进行自动摘要 - 使用外部存储管理重要上下文 python class EfficientConversationManager: def __init__(self, max_turns10, summary_threshold5): self.max_turns max_turns self.summary_threshold summary_threshold self.conversation_history [] def add_message(self, role, content): 添加消息到对话历史 self.conversation_history.append({role: role, content: content}) # 检查是否需要摘要 if len(self.conversation_history) self.summary_threshold: self._summarize_conversation() def _summarize_conversation(self): 对对话历史进行摘要 if len(self.conversation_history) 3: return # 使用模型生成摘要简化示例 summary_prompt f 请将以下对话摘要为3-5个关键点 {self.conversation_history} 摘要要求 - 保留决策和重要信息 - 忽略问候和礼貌用语 - 用简洁的要点格式 # 这里应该调用模型生成摘要 # summary client.messages.create(...) # 简化处理保留最后两条消息用摘要替换之前的消息 recent_messages self.conversation_history[-2:] self.conversation_history [{role: system, content: 对话摘要占位符}] recent_messages def get_current_context(self): 获取当前对话上下文 return self.conversation_history.copy()8.3 监控与告警机制建立完整的 token 使用监控体系class TokenUsageMonitor: def __init__(self, alert_thresholdsNone): self.alert_thresholds alert_thresholds or { daily_limit: 100000, # 每日token限制 single_call_max: 10000, # 单次调用最大token cost_per_call_max: 0.10 # 单次调用最大成本 } self.daily_usage 0 def check_usage(self, input_tokens, output_tokens, operation_type): 检查使用量是否超过阈值 total_tokens input_tokens output_tokens cost_estimate self._estimate_cost(input_tokens, output_tokens) alerts [] if total_tokens self.alert_thresholds[single_call_max]: alerts.append(f单次调用token过多: {total_tokens}) if cost_estimate self.alert_thresholds[cost_per_call_max]: alerts.append(f单次调用成本过高: ${cost_estimate:.4f}) self.daily_usage total_tokens if self.daily_usage self.alert_thresholds[daily_limit]: alerts.append(f每日使用量接近限制: {self.daily_usage}) return alerts def _estimate_cost(self, input_tokens, output_tokens): 估算成本 return (input_tokens * 3 output_tokens * 15) / 1_000_000 def generate_daily_report(self): 生成每日使用报告 report { date: datetime.now().date().isoformat(), daily_usage: self.daily_usage, estimated_cost: self._estimate_cost(0, self.daily_usage), # 简化计算 alert_thresholds: self.alert_thresholds } # 重置每日计数 self.daily_usage 0 return report # 使用示例 monitor TokenUsageMonitor() alerts monitor.check_usage(1500, 3000, code_generation) if alerts: print(检测到异常使用:) for alert in alerts: print(f - {alert})9. 总结与后续学习方向Opus 5 在 token 效率方面的优化代表了大模型