第2495篇：AI系统的绿色工程——降低AI基础设施的能耗和碳排放
2026/4/30大约 6 分钟
第2495篇：AI系统的绿色工程——降低AI基础设施的能耗和碳排放
适读人群：AI工程师、架构师、技术负责人 | 阅读时长：约13分钟 | 核心价值：掌握降低AI系统能耗和碳排放的工程实践，在效果和环境成本之间找到平衡
训练 GPT-3 消耗的电力，相当于 120 多个美国家庭一年的用电量。
推理阶段虽然单次耗电少，但规模上去之后也是惊人的数字。有研究估算，一次 ChatGPT 对话消耗的能量是一次 Google 搜索的 10 倍左右。
这对大多数工程团队来说是个陌生的概念——我们平时关注的是性能、成本、可靠性，很少有人把"碳排放"列入技术决策的考量因素。
但情况在变化。越来越多的企业有 ESG（环境、社会、公司治理）目标，越来越多的客户会问"你们的 AI 系统的碳足迹是多少"。这已经不只是道德选择，是商业考量。
好消息是：降低 AI 系统的能耗，往往也能降低成本。 这两个目标在很大程度上是一致的。
一、AI 系统能耗的来源分析
在优化之前，先搞清楚能耗在哪里。
优化重点应该放在模型推理（占比最大）和Embedding 生成（频繁触发）。
二、模型选择的能耗意识
最大的杠杆在于模型选择。用更小的模型处理简单任务，是降低能耗最直接的方法。
@Service
@Slf4j
public class EnergyAwareModelRouter {
// 按任务复杂度路由到不同规模的模型
public ModelChoice selectModel(AIRequest request) {
TaskComplexity complexity = assessComplexity(request);
return switch (complexity) {
case SIMPLE -> ModelChoice.builder()
.modelName("gpt-4o-mini")
.estimatedTokens(500)
.estimatedCarbonGrams(0.002)
.build();
case MEDIUM -> ModelChoice.builder()
.modelName("gpt-4o")
.estimatedTokens(1500)
.estimatedCarbonGrams(0.015)
.build();
case COMPLEX -> ModelChoice.builder()
.modelName("claude-3-5-sonnet")
.estimatedTokens(4000)
.estimatedCarbonGrams(0.04)
.build();
};
}
private TaskComplexity assessComplexity(AIRequest request) {
String query = request.getUserQuery();
// 简单任务：分类、摘要、简短问答
if (query.length() < 100 && isSimpleQuery(query)) {
return TaskComplexity.SIMPLE;
}
// 复杂任务：多步推理、代码生成、长文档分析
if (requiresMultiStepReasoning(query) || query.length() > 1000) {
return TaskComplexity.COMPLEX;
}
return TaskComplexity.MEDIUM;
}
private boolean isSimpleQuery(String query) {
// 判断是否是简单查询：分类、Yes/No、提取字段等
String[] simplePatterns = {
"分类.*以下", "是否.*是", "提取.*中的", "翻译.*", "总结.*（不超过.+字）"
};
return Arrays.stream(simplePatterns)
.anyMatch(p -> query.matches(".*" + p + ".*"));
}
private boolean requiresMultiStepReasoning(String query) {
String[] complexPatterns = {
"分析.*并给出", "比较.*区别", "设计.*方案", "如果.*会发生", "为什么"
};
return Arrays.stream(complexPatterns)
.filter(p -> query.contains(p.split("\\*")[0]))
.count() >= 2;
}
}三、缓存策略减少重复计算
@Service
@Slf4j
public class EnergyEfficientCacheService {
private final RedisTemplate<String, String> redisTemplate;
private final EnergyMetrics energyMetrics;
// 语义缓存：相似的问题返回缓存结果，不重新推理
public Optional<CachedResponse> findSemanticallySimilar(String query) {
float[] queryEmbedding = embeddingService.embed(query);
// 从缓存向量库中查找相似查询
List<CachedEntry> candidates = cacheVectorStore.search(queryEmbedding, 3);
for (CachedEntry candidate : candidates) {
double similarity = cosineSimilarity(queryEmbedding, candidate.getEmbedding());
if (similarity > 0.95) {
// 相似度 > 0.95，认为是相同问题，直接返回缓存
log.info("语义缓存命中 (相似度 {:.3f})，节省推理能耗", similarity);
energyMetrics.recordCacheHit(estimateEnergySaved());
return Optional.of(candidate.getResponse());
}
}
return Optional.empty();
}
// Embedding 缓存：相同文本不重复计算向量
public float[] getOrComputeEmbedding(String text) {
String cacheKey = "embedding:" + hashText(text);
String cached = redisTemplate.opsForValue().get(cacheKey);
if (cached != null) {
energyMetrics.recordEmbeddingCacheHit();
return deserializeEmbedding(cached);
}
float[] embedding = embeddingService.computeEmbedding(text);
// 缓存7天，Embedding 不会频繁变化
redisTemplate.opsForValue().set(cacheKey, serializeEmbedding(embedding), Duration.ofDays(7));
return embedding;
}
private double estimateEnergySaved() {
// 估算一次 GPT-4o 推理节省的能耗（瓦时）
return 0.015; // 约 0.015 Wh per request
}
private String hashText(String text) {
try {
MessageDigest md = MessageDigest.getInstance("MD5");
byte[] hash = md.digest(text.getBytes(StandardCharsets.UTF_8));
return HexFormat.of().formatHex(hash);
} catch (Exception e) {
return text.hashCode() + "";
}
}
}四、批处理和智能调度
@Service
@Slf4j
public class GreenSchedulingService {
// 将非实时任务调度到碳排放低的时段（可再生能源充足的时段）
public void scheduleNonUrgentBatch(BatchEmbeddingJob job) {
// 查询电网碳强度预测（通过 Electricity Maps API 等）
CarbonIntensityForecast forecast = carbonForecastService.getForecast(24);
// 找到未来24小时内碳强度最低的时段
Optional<TimeSlot> lowCarbonSlot = forecast.getSlots().stream()
.filter(s -> s.getStartTime().isAfter(Instant.now()))
.filter(s -> s.getStartTime().isBefore(Instant.now().plus(Duration.ofHours(24))))
.min(Comparator.comparingDouble(TimeSlot::getCarbonIntensity));
if (lowCarbonSlot.isPresent()
&& lowCarbonSlot.get().getCarbonIntensity() < 200) { // 克CO2/kWh
// 调度到低碳时段执行
Instant scheduledTime = lowCarbonSlot.get().getStartTime();
batchScheduler.scheduleAt(job, scheduledTime);
log.info("批量任务已调度到低碳时段: {} (碳强度: {} gCO2/kWh)",
scheduledTime, lowCarbonSlot.get().getCarbonIntensity());
} else {
// 没有低碳时段，立即执行
batchScheduler.submitNow(job);
}
}
// 批量 Embedding：合并请求，减少 API 调用次数和能耗
public List<float[]> batchEmbed(List<String> texts) {
// 不是每条文本单独调用，而是批量处理
// OpenAI Embedding API 支持批量输入，一次调用处理多条
int batchSize = 100;
List<float[]> allEmbeddings = new ArrayList<>();
for (int i = 0; i < texts.size(); i += batchSize) {
List<String> batch = texts.subList(i, Math.min(i + batchSize, texts.size()));
List<float[]> batchEmbeddings = embeddingService.batchEmbed(batch);
allEmbeddings.addAll(batchEmbeddings);
}
return allEmbeddings;
}
}五、碳排放追踪与报告
@Service
@Slf4j
public class CarbonFootprintTracker {
// 各模型的碳排放系数（克CO2/1000 tokens，估算值）
private static final Map<String, Double> CARBON_FACTORS = Map.of(
"gpt-4o", 0.020,
"gpt-4o-mini", 0.002,
"claude-3-5-sonnet", 0.018,
"claude-3-haiku", 0.001,
"qwen2.5-72b-self-hosted", 0.008, // 自托管，使用量已知
"bge-m3-embedding", 0.0005
);
// 记录每次推理的碳排放
public void recordInference(String model, int inputTokens, int outputTokens) {
double factor = CARBON_FACTORS.getOrDefault(model, 0.015);
double carbonGrams = (inputTokens + outputTokens) / 1000.0 * factor;
metricsRegistry.increment("ai.carbon.grams", carbonGrams,
Tag.of("model", model));
}
// 生成月度碳排放报告
public CarbonReport generateMonthlyReport(YearMonth month) {
Map<String, Double> carbonByModel = new HashMap<>();
double totalCarbon = 0;
for (String model : CARBON_FACTORS.keySet()) {
double modelCarbon = metricsRegistry.getSum(
"ai.carbon.grams", month, Tag.of("model", model));
carbonByModel.put(model, modelCarbon);
totalCarbon += modelCarbon;
}
// 换算为更直观的单位
double treesNeededToOffset = totalCarbon / (1000 * 20.0); // 一棵树每年吸收约20kg CO2
double kmsOfCarDriving = totalCarbon / 192.0; // 平均汽车每公里192g CO2
return CarbonReport.builder()
.month(month)
.totalCarbonGrams(totalCarbon)
.carbonByModel(carbonByModel)
.equivalentTreesOffset(treesNeededToOffset)
.equivalentCarKilometers(kmsOfCarDriving)
.cacheHitRate(calculateCacheHitRate(month))
.estimatedSavingsByCache(calculateCacheSavings(month))
.recommendations(generateRecommendations(carbonByModel, totalCarbon))
.build();
}
private List<String> generateRecommendations(Map<String, Double> byModel, double total) {
List<String> recommendations = new ArrayList<>();
// 找出碳排放最高的模型
String heaviestModel = byModel.entrySet().stream()
.max(Map.Entry.comparingByValue())
.map(Map.Entry::getKey)
.orElse(null);
if (heaviestModel != null) {
double heaviestPct = byModel.get(heaviestModel) / total * 100;
if (heaviestPct > 50) {
recommendations.add(String.format(
"模型 %s 占总碳排放的 %.0f%%，建议评估是否可以将部分请求路由到更小的模型",
heaviestModel, heaviestPct));
}
}
return recommendations;
}
}六、实践中的优先级
不是所有场景都需要做绿色优化，优先级应该这样排：
第一优先：模型选择。从 70B 换成 7B，能耗和成本都降低 90%。这是最大的杠杆。
第二优先：缓存。高频相同查询的缓存命中，直接减少推理次数。
第三优先：批处理。把单次请求合并成批量，减少 GPU 空闲时间。
第四优先：调度优化。非实时任务调度到绿电充足的时段。
绿色和性能经济是一致的。在 AI 系统里，几乎没有"为了绿色牺牲性能"的场景——用更小的模型、减少重复计算、优化批处理，这些同时也是降低成本和提升效率的手段。
这是我见过的技术优化里少有的三赢方向：对业务好、对成本好、对环境好。