Replicate 计费模型

Replicate 是一个在云端运行开源机器学习模型的平台，也是 AI 领域最纯粹的按用量计费示例之一。没有月度订阅，也没有每次模型运行的固定费率。大多数模型按照所使用的计算时间计费，以秒为单位，费率取决于硬件。部分模型则按输入和输出计费，例如按图像或 token 计费（Replicate pricing）。按秒计费适合 AI 工作负载，因为运行时间无法预测。一个用户可能运行轻量级模型几秒钟，另一个用户可能运行大型生成式模型数分钟。由于价格取决于所使用的计算资源，而不是模型本身，因此在任何规模下都保持透明。

Replicate 的计费方式

Replicate 的基于时间的定价不取决于模型。无论是使用 SDXL 生成图像，还是运行 Llama 3，账单都取决于硬件层级和运行时间。Replicate 可以托管数千个开源模型，而无需为每个模型单独定价。

硬件	每秒价格	每小时价格
CPU	$0.000100	$0.36
NVIDIA T4 GPU	$0.000225	$0.81
NVIDIA L40S GPU	$0.000975	$3.51
NVIDIA A100 (80GB) GPU	$0.001400	$5.04
NVIDIA H100 GPU	$0.001525	$5.49

下面的实现还使用了 A40 和 A100 (40GB) 层级的示例计量器，而 Replicate 的定价页面已不再列出这些层级。请为你提供的每个硬件层级分别创建一个计量器。每次运行都会根据实际使用的硬件，在对应的计量器上进行计量：

硬件专属费率：每秒价格取决于所使用的计算资源。每个硬件层级都有自己的费率。
纯按用量计费模式：没有月费、包含配额或超额费用。用户只需为准确的计算时间付费，例如“在 A100 上运行 12.4 秒”，而不是按生成次数付费。
按秒计费粒度：按小时或分钟计费的提供商会对短任务未使用的时间收费。按秒计费则能消除这种浪费，既适用于小型实验，也适用于大型生产工作负载。

对于公共模型，Replicate 仅对模型主动处理请求的时间收费。初始化（冷启动）和空闲时间免费。私有模型和部署运行在专用硬件上，因此其实例在线期间的所有时间都需要付费：初始化、空闲和活动时间（Replicate billing docs）。

其独特之处

硬件专属计量： 同一模型在更快的硬件上成本更高，因此用户需要在速度和成本之间进行权衡。T4 GPU 适合对时间不敏感的任务，而 A100 适合实时应用。
按秒计费粒度： 计费精确到秒，因此用户无需为短任务中未使用的时间付费。
无订阅： 用户无需承担任何前期承诺，成本会随用量增长。这适合初创公司和尝试不同模型的开发者。
与模型无关： 相同的计费逻辑适用于图像生成、文本处理、音频转录和视频合成。该平台支持大量模型目录，无需复杂的定价表。

使用 Dodo Payments 构建

你可以使用 Dodo Payments 的按用量计费来构建此模型。为每个硬件层级创建一个计量器，并将所有计量器关联到同一个产品。

Create Usage Meters (One Per Hardware Class)

为每个硬件层级创建单独的计量器。每个层级都有自己的每秒价格，因此单独的计量器可以让 Dodo Payments 为每个层级定价，并在发票中逐项列出费用。

计量器名称	事件名称	聚合方式	属性
CPU Compute	`compute.cpu`	Sum	`execution_seconds`
GPU T4 Compute	`compute.gpu_t4`	Sum	`execution_seconds`
GPU A40 Compute	`compute.gpu_a40`	Sum	`execution_seconds`
GPU A40 Large Compute	`compute.gpu_a40_large`	Sum	`execution_seconds`
GPU A100 40GB Compute	`compute.gpu_a100_40`	Sum	`execution_seconds`
GPU A100 80GB Compute	`compute.gpu_a100_80`	Sum	`execution_seconds`

对 execution_seconds 进行 Sum 聚合，可得计费周期内每个硬件层级的总计算时间。

Create a Usage-Based Product

在 Dodo Payments 控制面板中使用以下设置创建一个产品：

定价类型： 按用量计费
基础价格： $0/月（无订阅费）
计费频率： 每月

为每个计量器添加其每单位价格：

计量器	每单位价格（每秒）
compute.cpu	$0.000100
compute.gpu_t4	$0.000225
compute.gpu_a40	$0.000575
compute.gpu_a40_large	$0.000725
compute.gpu_a100_40	$0.001150
compute.gpu_a100_80	$0.001400

将每个计量器的 Free Threshold 设置为 0，这样每一秒的执行时间都会产生费用。

Send Usage Events

每次模型运行完成后，向 Dodo Payments 发送一个用量事件。为每个预测分配唯一的 event_id，以确保重试的事件不会被重复计数。

import DodoPayments from 'dodopayments';

type HardwareTier = 'cpu' | 'gpu_t4' | 'gpu_a40' | 'gpu_a40_large' | 'gpu_a100_40' | 'gpu_a100_80';

const client = new DodoPayments({
  bearerToken: process.env.DODO_PAYMENTS_API_KEY,
});

async function trackModelExecution(
  customerId: string,
  modelId: string,
  hardware: HardwareTier,
  executionSeconds: number,
  predictionId: string
) {
  const eventName = `compute.${hardware}`;

  await client.usageEvents.ingest({
    events: [{
      event_id: `pred_${predictionId}`,
      customer_id: customerId,
      event_name: eventName,
      timestamp: new Date().toISOString(),
      metadata: {
        execution_seconds: executionSeconds,
        model_id: modelId,
        hardware: hardware
      }
    }]
  });
}

// Example: SDXL image generation on A100
await trackModelExecution(
  'cus_abc123',
  'stability-ai/sdxl',
  'gpu_a100_80',
  8.3,  // 8.3 seconds of A100 time
  'pred_xyz789'
);

Measure Execution Time Precisely

使用 performance.now() 记录每次模型运行的时间，并四舍五入到最接近的十分之一秒后计费。

// executeModel is your application's own function that runs the model.
async function runModelWithMetering(
  customerId: string,
  modelId: string,
  hardware: HardwareTier,
  input: Record<string, unknown>
) {
  const predictionId = `pred_${Date.now()}`;
  const startTime = performance.now();

  try {
    const result = await executeModel(modelId, input, hardware);
    const executionSeconds = (performance.now() - startTime) / 1000;
    const billedSeconds = Math.round(executionSeconds * 10) / 10;

    await trackModelExecution(
      customerId,
      modelId,
      hardware,
      billedSeconds,
      predictionId
    );

    return result;
  } catch (error) {
    // This example bills compute time for failed runs longer than 1 second.
    // Replicate doesn't charge for failed runs on public models; remove this block to match.
    const executionSeconds = (performance.now() - startTime) / 1000;
    if (executionSeconds > 1) {
      await trackModelExecution(
        customerId,
        modelId,
        hardware,
        Math.round(executionSeconds * 10) / 10,
        predictionId
      );
    }
    throw error;
  }
}

Create Checkout

用户注册时，为按用量计费的产品创建结账会话。之后，Dodo Payments 会在每个周期对用量计费并开具发票。

const session = await client.checkoutSessions.create({
  product_cart: [
    { product_id: 'pdt_compute_payg', quantity: 1 }
  ],
  customer: { email: 'ml-engineer@example.com' },
  return_url: 'https://yourplatform.com/dashboard'
});

使用 Time Range Ingestion Blueprint 加速

Time Range Ingestion Blueprint 可以缩短按秒跟踪计算时间的实现过程。为每个硬件层级创建一个 ingestion 实例，并在每次运行后调用 trackTimeRange。

npm install @dodopayments/ingestion-blueprints

import { Ingestion, trackTimeRange } from '@dodopayments/ingestion-blueprints';

// Create one ingestion instance per hardware tier
function createHardwareIngestion(hardware: string) {
  return new Ingestion({
    apiKey: process.env.DODO_PAYMENTS_API_KEY,
    environment: 'live_mode',
    eventName: `compute.${hardware}`,
  });
}

const ingestions: Record<string, Ingestion> = {
  cpu: createHardwareIngestion('cpu'),
  gpu_t4: createHardwareIngestion('gpu_t4'),
  gpu_a40: createHardwareIngestion('gpu_a40'),
  gpu_a40_large: createHardwareIngestion('gpu_a40_large'),
  gpu_a100_40: createHardwareIngestion('gpu_a100_40'),
  gpu_a100_80: createHardwareIngestion('gpu_a100_80'),
};

// executeModel, modelId, input, hardware, and customerId come from your application.
const startTime = performance.now();
const result = await executeModel(modelId, input, hardware);
const durationMs = performance.now() - startTime;

await trackTimeRange(ingestions[hardware], {
  customerId: customerId,
  durationMs: durationMs,
  metadata: {
    model_id: modelId,
    hardware: hardware,
  },
});

该 blueprint 会构建并发送事件，并将持续时间作为元数据中的 durationMs。将每个计量器的 Over Property 设置为 durationMs，或发送 durationSeconds 以保留按秒定价。为每个硬件层级使用一个 ingestion 实例后，即可直接映射到 Replicate 的多层级计量。

对于长时间运行的作业，将 Time Range Blueprint 与基于间隔的 heartbeat 跟踪结合使用，具体示例见 Advanced: Heartbeat Metering。如需了解更多模式，请参阅完整的 blueprint 文档。

面向用户的成本估算

按用量计费的账单可能难以预测，因此应在用户运行模型前显示成本估算。估算可以避免意外账单并建立信任。

成本计算示例

模型	硬件	平均时间	每次运行成本
SDXL（图像）	A100 80GB	~8 秒	~$0.0112
Llama 3（文本）	A100 40GB	~3 秒	~$0.0035
Whisper（音频）	GPU T4	~15 秒	~$0.0034

构建成本计算器

此函数将该层级的每秒费率乘以预计运行时间：

function estimateCost(hardware: HardwareTier, estimatedSeconds: number): number {
  const rates: Record<HardwareTier, number> = {
    'cpu': 0.000100,
    'gpu_t4': 0.000225,
    'gpu_a40': 0.000575,
    'gpu_a40_large': 0.000725,
    'gpu_a100_40': 0.001150,
    'gpu_a100_80': 0.001400
  };

  return Number((rates[hardware] * estimatedSeconds).toFixed(4));
}

// Show the user before running: "This will cost approximately $0.0119"
const estimate = estimateCost('gpu_a100_80', 8.5);

企业版：预留容量

对于需要专用容量且不希望出现冷启动的客户，Replicate 提供 deployments：专用实例会对其在线期间的全部时间计费。要使用 Dodo Payments 模拟预留容量，可将其作为订阅产品销售：

产品类型： 订阅
价格： 固定月费（例如“Reserved A100 Instance - $500/月”）
计费周期： 每月

你仍然可以发送用量事件以进行监控和分析，同时由订阅覆盖成本。随着客户用量增长，预留容量通常比按需付费更经济。

高级：Heartbeat Metering

对于运行数分钟或数小时的任务，仅在结束时发送一个事件存在风险：如果进程崩溃，你将丢失用量数据。相反，应在任务运行期间每 30 到 60 秒发送一个用量事件。

// executeLongTask is your application's own function. trackModelExecution is defined above.
async function runLongTaskWithHeartbeat(
  customerId: string,
  modelId: string,
  hardware: HardwareTier
) {
  const predictionId = `pred_${Date.now()}`;
  let totalSeconds = 0;

  const heartbeatInterval = setInterval(async () => {
    try {
      await trackModelExecution(
        customerId,
        modelId,
        hardware,
        30,
        `${predictionId}_${totalSeconds}`
      );
      totalSeconds += 30;
    } catch (error) {
      console.error('Heartbeat tracking failed:', error, { predictionId, totalSeconds });
    }
  }, 30000);

  try {
    await executeLongTask();
  } finally {
    clearInterval(heartbeatInterval);
  }
}

使用的 Dodo 核心功能

Usage-Based Billing

设置基于消耗量计费的产品。

Meters

定义要跟踪并计费的指标。

Event Ingestion

在用量产生时将数据发送到 Dodo Payments。

Subscriptions

管理预留容量和企业计划的 recurring billing。

Time Range Blueprint

使用 duration helpers 跟踪每秒计算时间。

Integration Guides

Billing Deconstructions

Cookbooks

Replicate 的计费方式

其独特之处

使用 Dodo Payments 构建

使用 Time Range Ingestion Blueprint 加速

面向用户的成本估算

成本计算示例

构建成本计算器

企业版：预留容量

高级：Heartbeat Metering

使用的 Dodo 核心功能

Usage-Based Billing

Meters

Event Ingestion

Subscriptions

Time Range Blueprint

​Replicate 的计费方式

​其独特之处

​使用 Dodo Payments 构建

​使用 Time Range Ingestion Blueprint 加速

​面向用户的成本估算

​成本计算示例

​构建成本计算器

​企业版：预留容量

​高级：Heartbeat Metering

​使用的 Dodo 核心功能

Usage-Based Billing

Meters

Event Ingestion

Subscriptions

Time Range Blueprint

Replicate 的计费方式

其独特之处

使用 Dodo Payments 构建

使用 Time Range Ingestion Blueprint 加速

面向用户的成本估算

成本计算示例

构建成本计算器

企业版：预留容量

高级：Heartbeat Metering

使用的 Dodo 核心功能