工程化02：成本控制

大模型应用的成本主要来自 Token 消耗，包括输入 Token 和输出 Token。有效的成本控制需要从多个维度入手：预算管理、缓存策略、模型选择、请求优化等。

Token 预算管理

Token 消耗计算

维度	计算方式	示例
输入 Token	输入文本长度 × 单价	1000 Token × $0.0015 = $0.0015
输出 Token	输出文本长度 × 单价	1000 Token × $0.002 = $0.002
总成本	输入成本 + 输出成本	$0.0015 + $0.002 = $0.0035
每千请求成本	单次成本 × 1000	$0.0035 × 1000 = $3.5

模型定价对比

模型	输入单价($/k)	输出单价($/k)	单次请求(1k输入+1k输出)
GPT-4o	0.0005	0.0015	$0.002
GPT-4	0.003	0.006	$0.009
GPT-3.5 Turbo	0.0001	0.0002	$0.0003
Claude 3 Sonnet	0.0003	0.0015	$0.0018
Claude 3 Haiku	0.000025	0.000125	$0.00015

预算设置策略

策略	说明	示例
每日预算	设置每日最大消耗	$100/天
月度预算	设置月度最大消耗	$3000/月
单次预算	设置单次请求最大消耗	$0.01/次
用户预算	按用户设置消耗上限	1000 Token/用户/天

预算监控实现

@Service
public class BudgetService {
    private final AtomicLong dailyUsage = new AtomicLong(0);
    private final long dailyBudget = 100_000; // 100,000 Token/天
    
    public boolean checkBudget(long tokens) {
        long current = dailyUsage.addAndGet(tokens);
        return current <= dailyBudget;
    }
    
    public void resetDailyUsage() {
        dailyUsage.set(0);
    }
    
    public double getRemainingBudget() {
        return (dailyBudget - dailyUsage.get()) * 0.0001 / 1000; // 转换为美元
    }
}

缓存策略

缓存层次设计

层次	缓存内容	有效期	命中率目标
L1 内存缓存	高频请求结果	5-10分钟	80%+
L2 分布式缓存	中频请求结果	30分钟-1小时	60%+
L3 持久化缓存	低频请求结果	24小时	40%+

缓存实现示例

@Service
public class ModelCacheService {
    private final Cache<String, String> l1Cache = Caffeine.newBuilder()
        .expireAfterWrite(5, TimeUnit.MINUTES)
        .maximumSize(10_000)
        .build();
    
    private final RedisTemplate<String, String> redisTemplate;
    
    public String get(String prompt) {
        String cached = l1Cache.getIfPresent(prompt);
        if (cached != null) {
            return cached;
        }
        
        cached = redisTemplate.opsForValue().get(prompt);
        if (cached != null) {
            l1Cache.put(prompt, cached);
            return cached;
        }
        
        return null;
    }
    
    public void put(String prompt, String response) {
        l1Cache.put(prompt, response);
        redisTemplate.opsForValue().set(prompt, response, 30, TimeUnit.MINUTES);
    }
}

缓存失效策略

策略	说明	适用场景
时间过期	固定时间后失效	内容不频繁变化
主动失效	更新时主动删除	内容需要实时更新
版本控制	基于版本号失效	知识更新场景
LRU 淘汰	最近最少使用淘汰	缓存容量有限

模型分层策略

模型选择依据

因素	说明	选择建议
任务复杂度	简单任务用小模型	分类、摘要用 Haiku
精度要求	高要求用大模型	复杂推理用 GPT-4
成本预算	预算有限用便宜模型	批量处理用 Haiku
响应时间	低延迟用小模型	实时交互用 Haiku
上下文长度	长上下文用大模型	代码分析用 GPT-4

分层调用示例

@Service
public class ModelRoutingService {
    public String route(String prompt, TaskType type) {
        ModelConfig config = switch (type) {
            case SIMPLE -> ModelConfig.HAIKU;
            case NORMAL -> ModelConfig.SONNET;
            case COMPLEX -> ModelConfig.GPT_4O;
            case LONG_CONTEXT -> ModelConfig.GPT_4_TURBO;
        };
        return modelService.generate(prompt, config);
    }
}

enum TaskType {
    SIMPLE,      // 分类、提取、简单问答
    NORMAL,      // 普通对话、中等难度问答
    COMPLEX,     // 复杂推理、代码生成
    LONG_CONTEXT // 长文档分析、多文档对比
}

动态降级

触发条件	降级策略	恢复条件
成本超预算	大模型 → 小模型	成本回到预算内
响应超时	大模型 → 小模型	响应时间恢复正常
API 不可用	在线模型 → 本地模型	API 恢复可用
流量突增	全量大模型 → 部分小模型	流量恢复正常

请求合并优化

请求合并场景

场景	问题	优化方案
批量处理	多次请求开销大	合并为单次批量请求
多轮对话	重复发送历史上下文	使用上下文压缩
相似请求	相同请求重复处理	请求去重
并发请求	多个用户请求相似内容	结果共享

批量请求示例

@Service
public class BatchModelService {
    public List<String> generateBatch(List<String> prompts) {
        if (prompts.isEmpty()) {
            return List.of();
        }
        
        // 将多个prompt合并为一个请求
        String combinedPrompt = String.join("\n---\n", prompts);
        
        String response = modelService.generate(combinedPrompt, 
            ModelConfig.builder()
                .model("gpt-4o")
                .temperature(0.1)
                .build());
        
        // 拆分响应
        return Arrays.asList(response.split("\n---\n"));
    }
}

上下文压缩

方法	说明	效果
摘要压缩	对历史对话生成摘要	减少 50%-70% Token
关键信息提取	只保留关键信息	减少 60%-80% Token
语义压缩	使用 Embedding 检索关键片段	减少 70%-90% Token
滚动窗口	只保留最近 N 轮对话	固定 Token 消耗

成本优化最佳实践

成本优化矩阵

优化维度	措施	预期节省
模型选择	使用合适的模型	30%-70%
缓存策略	缓存重复请求	20%-50%
请求优化	压缩上下文	10%-30%
批量处理	合并相似请求	10%-20%
预算控制	设置消费上限	避免超支

成本监控体系

Token 消耗收集 → 实时统计 → 预算告警 → 自动降级
                                    ↓
                              成本分析报告

成本分析指标

指标	说明	计算方式
总 Token 消耗	输入 + 输出 Token	sum(input_tokens + output_tokens)
平均单次消耗	每次请求平均 Token	total / request_count
成本/请求	每次请求平均成本	total_cost / request_count
缓存命中率	缓存命中比例	cache_hits / total_requests
模型分布	各模型使用比例	model_requests / total_requests

常见问题与解决方案

问题1：成本超支

表现：实际消耗超过预算

解决方案：

• 设置严格的预算上限
• 实现自动降级
• 优化模型选择策略
• 增加缓存命中率

问题2：缓存命中率低

表现：缓存没有有效减少请求

解决方案：

• 分析请求模式
• 调整缓存策略
• 增加缓存层次
• 实现请求去重

问题3：模型选择不当

表现：简单任务使用了大模型

解决方案：

• 建立任务分类体系
• 实现智能路由
• 设置模型使用规则
• 定期分析模型使用情况

问题4：上下文过长

表现：历史对话导致 Token 消耗过大

解决方案：

• 实现上下文压缩
• 使用滚动窗口
• 提取关键信息
• 减少不必要的历史

项目判断清单

• 成本超支 → 设置预算上限和告警
• 重复请求多 → 实现多层缓存策略
• 简单任务用大模型 → 建立模型分层路由
• 上下文过长 → 实现上下文压缩
• 需要批量处理 → 实现请求合并
• 缓存命中率低 → 分析请求模式调整策略
• 需要实时监控 → 建立成本监控体系
• 成本波动大 → 实现动态降级策略