以下三家公司与全部数字均为教学假设,用于演示商业化计算,不代表任何真实企业。
归因回答的是「谁造成的」
上一节把变动成本拆成了项目,这一节要回答一个更难的问题:这些成本分别由谁造成。
「谁」可以是一个产品、一个客户,也可以是一个功能。三个视角回答不同的问题:
- 产品视角:哪条产品线在消耗共享的模型网关?
- 客户视角:哪个客户贡献了收入,哪个客户在消耗毛利?
- 功能视角:哪个功能在推高 token 用量?
归因的目的不是找一个部门来承担责任,而是找到可以改变行为的杠杆。如果某个成本项归因不到任何对象,它就无法被管理;如果归因错了对象,优化动作就会打偏。
三个归因对象
产品。 当多个产品共用一套模型网关、一套检索集群、一套支付通道时,网关账单是一个共享成本池。产品级归因要把这个池按各产品的调用量或 token 量分开,否则每个产品都以为自己用的是「免费」的共享能力。
客户。 客户级归因回答「这个客户是否赚钱」。它不是看客户付了多少钱,而是看客户收入减去为客户发生的变动成本。LumenDesk 有 320 家付费客户、1,920 个席位,平均值会掩盖客户之间的巨大差异。
功能。 功能级归因回答「哪个功能最贵」。同样是对话,带长文档检索的对话和普通问答的 token 消耗可能差一个数量级。功能级归因要能把成本追到具体的能力开关,而不是停在「整个产品」这一层。
三个对象不是三套独立的账。它们共享同一批计量事件,只是聚合维度不同。一套事件如果能按 product_id、customer_id、feature_id 三个字段打标,就能同时支撑三种归因。
三条归因规则
规则一:单一归属。 同一笔成本只能有一个主归属对象。共享成本可以按驱动量分给多个对象,但分摊之后要能加总回原额,不能在每个对象的报表里都完整出现一次。
规则二:驱动量优先。 分摊依据要选「引起成本变化的量」,而不是「方便计算的量」。按收入分摊看起来简单,但收入高的客户不一定用量大;按席位分摊也不一定对,因为席位多不代表调用多。能用调用量、token 量、案件量,就不要用收入或人数。
规则三:不可归因的单列。 总有一部分成本归因不到具体对象,例如共享的监控、安全扫描、闲置容量。这部分要单独列成「未归因」,不能硬摊到客户头上。硬摊会让每个客户看起来都稍微贵一点,最后没有人对这笔钱负责。
客户级:贡献毛利,而不是毛利率
客户级归因的核心指标是贡献毛利:
客户贡献毛利 = 客户收入 − 客户变动成本
客户贡献毛利率 = 客户贡献毛利 ÷ 客户收入
LumenDesk 的三个分位客户,收入、成本与贡献毛利如下:
| 分位 | 月对话量/席位 | 单次成本 | 单席位月成本 | 单席位月收入 | 贡献毛利 | 贡献毛利率 |
|---|---|---|---|---|---|---|
| P50 | 540 | 0.015 美元 | 8.10 美元 | 50.60 美元 | 42.50 美元 | 84.0% |
| P95 | 1,450 | 0.035 美元 | 50.75 美元 | 87.00 美元 | 36.25 美元 | 41.7% |
| P99 | 2,300 | 0.120 美元 | 276.00 美元 | 121.00 美元 | −155.00 美元 | −128.1% |
计算过程:
P50:540 × 0.015 = 8.10;49 + (540 − 500) × 0.04 = 50.60;50.60 − 8.10 = 42.50
P95:1,450 × 0.035 = 50.75;49 + (1,450 − 500) × 0.04 = 87.00;87.00 − 50.75 = 36.25
P99:2,300 × 0.120 = 276.00;49 + (2,300 − 500) × 0.04 = 121.00;121.00 − 276.00 = −155.00
P99 客户的贡献毛利是负的。它不是「毛利低」,而是每服务一次就多亏一次。原因在上一章已经出现:上下文长度是均值的 16.7 倍,单次成本 0.12 美元,而超额单价只有 0.04 美元。
三个分位的贡献毛利率分别是 42.50 ÷ 50.60 = 84.0%、36.25 ÷ 87.00 = 41.7%、−155.00 ÷ 121.00 = −128.1%。
如果把 320 家客户加总,得到的是正毛利 85,440 美元、毛利率 82.7%。这个数字没有错,但它掩盖了 P99 客户的结构性亏损。客户级归因的价值,就是把这个「平均值背后的负数」找出来。
产品级:共享网关不能重复计入
产品级归因最容易出的错,是共享成本被重复计算。
假设一套模型网关同时服务两个产品,月账单为 C,产品 A 用了 p 的 token,产品 B 用了 1 − p。如果两个产品的报表都把 C 全额计入,成本就会被算两次。
正确做法是先分摊、再汇总:
产品 A 分摊 = C × p
产品 B 分摊 = C × (1 − p)
两个产品合计 = C × p + C × (1 − p) = C
分摊之后必须做一次守恒检查:各产品分摊额之和等于共享成本池总额。如果不等,差额要么是未归因,要么是重复计入,必须查清楚。
产品级归因还要处理「内部转移定价」问题。共享网关向产品收多少钱,会直接影响产品的毛利表现。按成本价分摊最中性;按市场价加成会激励产品自行采购,但也会扭曲产品毛利。无论选哪种,规则要提前写清楚,不能事后按结果调整。
功能级:上下文长度是隐藏驱动量
功能级归因最容易被忽略的驱动量是上下文长度。
LumenDesk 的平均单次上下文是 1,800 token,P99 客户的单次上下文是 30,000 token,相差 16.7 倍。同样的「一次对话」,在功能层面可能是完全不同的成本:
- 普通问答:1,800 token 上下文,单次推理 0.0090 美元;
- 带长文档检索的问答:30,000 token 上下文,单次推理成本按 token 比例上升到 0.15 美元(0.0090 × 30,000 ÷ 1,800);
- 多轮对话:每轮都携带历史上下文,成本随轮数累积。
功能级归因要把「功能开关」和「上下文长度」绑定。只记录「用户调用了一次问答」不够,还要记录这次问答带了多少上下文、触发了几次检索、输出多长。否则功能团队看到的是调用次数,成本团队看到的是 token 账单,两边对不上。
功能级归因的产出通常是一张「单位功能成本表」:
| 功能 | 驱动量 | 单次成本 | 主要成本项 |
|---|---|---|---|
| 普通问答 | 1,800 输入 + 450 输出 token | 0.0150 美元 | 推理 0.0090 |
| 长文档问答 | 30,000 输入 token | 0.120 美元 | 推理与检索 |
| 语音转写 | 1 分钟 | 0.0042 美元 | 推理 0.0035 |
| 合同审查 | 1 个案件 | 65.00 美元 | 人工复核 35.00 |
这张表让产品团队在加功能之前就能估算成本,而不是上线后才发现账单涨了。
共享成本怎么分
共享成本的分摊要满足两个条件:按驱动量分,且分摊后能加总回原额。
按驱动量分摊的公式是:
对象分摊额 = 共享成本池 × 对象驱动量 ÷ 全部驱动量之和
举一个纯算术的例子:成本池 100 美分,三个对象的驱动量分别是 3、1、1。
A = 100 × 3 ÷ 5 = 60 美分
B = 100 × 1 ÷ 5 = 20 美分
C = 100 × 1 ÷ 5 = 20 美分
合计 = 60 + 20 + 20 = 100 美分
整数分摊会遇到除不尽的情况。例如成本池 100 美分、驱动量 1、1、1,每个对象分到 33.33 美分。如果都向下取整,合计只有 99 美分,少 1 美分。常用的处理是最大余数法:先按整数部分分配,再把剩余的 1 美分给余数最大的对象。这样既能保证合计不变,也能保证分配规则可复现。
分摊方法本身不产生因果。按调用量分摊检索成本,只说明「谁用得多」,不说明「谁应该为检索架构的低效负责」。归因结果要配合责任归属一起看,否则容易把「用量大」误判成「浪费」。
归因到团队:owner 而不是 blame
成本归因的最后一步是落到人。落人的目的不是追责,而是让每个成本项都有一个能改变它的人。
一个可操作的归属方式是「成本 owner + 用量 owner」双签:
- 成本 owner 对单价负责,例如平台团队对模型采购价、检索单价、存储单价负责;
- 用量 owner 对驱动量负责,例如产品团队对上下文长度、调用次数、重试率负责。
LumenDesk 的 P99 负毛利,成本 owner 看到的是「单次成本 0.12 美元」,用量 owner 看到的是「上下文 30,000 token」。两边都有杠杆:成本 owner 可以谈供应商折扣、换更便宜的模型;用量 owner 可以做上下文压缩、限制长文档、设计档位升级。只归因给其中一方,问题都解决不了。
归因闭环:事件、账单、报表
归因要能闭环,必须让三个层次对得上:
- 计量事件:每一次调用、每一分钟、每一个案件,都带 event_id、customer_id、product_id、feature_id、units 与 unit_cost。
- 供应商账单:按供应商、按计费项汇总,能对到事件层的总量。
- 管理报表:按客户、产品、功能聚合,能加总回账单总额。
闭环的检查点是「归因差额」:
归因差额 = 账单总额 − 各对象分摊额之和
正常应为 0。如果不为 0,只有三种可能:有事件漏记、有成本重复计入、有未归因的共享成本。三种都要能解释,不能用一个「估算误差」带过。
LumenDesk 的月度变动成本 17,856 美元,可以拆成模型侧 14,284.80 美元与支付第三方 3,571.20 美元。这 17,856 美元再按客户、产品、功能三个维度聚合,每个维度的合计都必须是 17,856 美元。任何一个维度对不上,归因链路就还没有闭环。
代码:把归因算成可复现的函数
下面的代码实现了三件事:按驱动量分摊共享成本并保证守恒、计算客户贡献毛利与客户级毛利率、检查归因差额。金额用美分整数表示,比率用基点表示。
// file: src/ops/01-3-attribution.ts
// tier: L1
// verify: node --test test/ops/01-3-attribution.test.ts
// 成本归因:把共享成本按驱动量分到客户、产品与功能。
import { type Cents } from "../core/money.ts";
import { type Bps } from "../core/rate.ts";
export type AttributionTarget = {
id: string;
driver: number;
};
export type Allocation = {
id: string;
allocatedCents: Cents;
shareBps: Bps;
};
/** 按驱动量分摊共享成本;用最大余数法保证分摊合计等于总额。 */
export function allocateByDriver(
totalCents: Cents,
targets: readonly AttributionTarget[],
): readonly Allocation[] {
const driverSum = targets.reduce((acc, target) => acc + target.driver, 0);
if (driverSum <= 0 || totalCents <= 0) {
return targets.map((target) => ({ id: target.id, allocatedCents: 0, shareBps: 0 }));
}
const exact = targets.map((target) => (totalCents * target.driver) / driverSum);
const allocated = exact.map((value) => Math.floor(value));
let left = totalCents - allocated.reduce((acc, value) => acc + value, 0);
const order = exact
.map((value, index) => ({
index,
remainder: value - Math.floor(value),
driver: targets[index].driver,
}))
.sort((a, b) => b.remainder - a.remainder || b.driver - a.driver);
for (const item of order) {
if (left <= 0) break;
allocated[item.index] += 1;
left -= 1;
}
return targets.map((target, index) => ({
id: target.id,
allocatedCents: allocated[index],
shareBps: Math.round((allocated[index] / totalCents) * 10_000),
}));
}
export type CustomerUsage = {
id: string;
revenueCents: Cents;
usageUnits: number;
unitCostMicros: number;
};
/** 客户贡献毛利 = 收入 − 用量 × 单位变动成本。 */
export function customerContributionCents(customer: CustomerUsage): Cents {
const costCents = Math.round((customer.usageUnits * customer.unitCostMicros) / 10_000);
return customer.revenueCents - costCents;
}
/** 客户级毛利率,单位基点;负毛利返回负数。 */
export function customerMarginBps(customer: CustomerUsage): Bps {
if (customer.revenueCents <= 0) return 0;
return Math.round((customerContributionCents(customer) / customer.revenueCents) * 10_000);
}
/** 归因差额:总额减已分摊金额,正常应为 0。 */
export function unattributedCents(totalCents: Cents, allocations: readonly Allocation[]): Cents {
return totalCents - allocations.reduce((acc, item) => acc + item.allocatedCents, 0);
}
export const LUMENDESK_TIERS: readonly CustomerUsage[] = [
{ id: "P50", revenueCents: 5_060, usageUnits: 540, unitCostMicros: 15_000 },
{ id: "P95", revenueCents: 8_700, usageUnits: 1_450, unitCostMicros: 35_000 },
{ id: "P99", revenueCents: 12_100, usageUnits: 2_300, unitCostMicros: 120_000 },
];
测试固定了四个结论:P50 贡献毛利 4,250 美分(42.50 美元),P95 是 3,625 美分(36.25 美元),P99 是 −15,500 美分(−155.00 美元);P99 的客户级毛利率是 −12,810 个基点,也就是 −128.1%;按 3、1、1 的驱动量分摊 100 美分,得到 60、20、20,归因差额为 0。
归因结果的三种用法
归因结果不是只给财务看的。它至少有三个用途:
定价。 客户级贡献毛利告诉你哪些客户在补贴哪些客户。如果某个分位的贡献毛利长期为负,定价或额度就需要调整,而不是继续用平均值掩盖。
产品设计。 功能级成本告诉你哪个功能最贵。上下文长度、输出长度、检索次数都是产品可以控制的变量,归因到功能之后,产品团队才有优化目标。
资源分配。 产品级归因告诉你哪条产品线在消耗共享能力。共享网关、检索集群、支付通道的容量应该按归因结果分配,而不是按「谁声音大」分配。
三种用法有一个共同前提:归因结果必须能对回账单。对不回去的归因,只是另一种形式的估算。
小结
- 成本归因回答「谁造成了成本」,目的是找到可改变的杠杆,而不是追责。
- 归因对象有三层:产品、客户、功能;它们共享同一批计量事件,只是聚合维度不同。
- 三条规则:单一归属、驱动量优先、不可归因的成本单列。
- LumenDesk 的 P50 贡献毛利 42.50 美元、P95 是 36.25 美元、P99 是 −155.00 美元,均值 82.7% 掩盖了长尾亏损。
- 共享成本按驱动量分摊,用最大余数法保证分摊合计等于成本池总额。
- 归因差额应恒为 0;不为 0 时只有漏记、重复计入、未归因三种解释。
- 成本 owner 对单价负责,用量 owner 对驱动量负责,两者必须同时存在。
阅读导航:上一节:1.2 变动成本清单:token、推理、存储、第三方 · 下一节:2.1 每次调用的成本模型 。
常见错误与边界
- 按收入或席位数分摊共享成本,而不是按真正引起成本变化的驱动量。
- 同一个共享成本池在每个产品的报表里都完整出现一次,导致总成本被重复计算。
- 把 P99 客户的负毛利当成「个别异常」,继续用 82.7% 的平均毛利率做决策。
- 只归因到产品,不归因到功能,导致上下文长度这类可控变量长期无人负责。
- 把不可归因的共享成本硬摊给客户,制造一个所有人都稍微贵一点、却没人负责的账。
- 归因差额用「估算误差」带过,不追查漏记、重复计入与未归因成本。
继续阅读
探索更多技术文章
浏览归档,发现更多关于系统设计、工具链和工程实践的内容。