Veo 3、Sora 2 与可灵 3：AI 视频选型与评测

{
  "fixture_id": "product-pour-07",
  "semantic_brief_version": "sha256:brief...",
  "required_events": ["打开瓶盖", "液体进入杯中", "标签始终可读"],
  "hard_gates": ["版权", "策略", "事件顺序", "品牌文字"],
  "graded_dimensions": ["画面质量", "运动", "身份", "音频"],
  "provider_request_hash": "sha256:request...",
  "output_hash": "sha256:video...",
  "review_rubric_version": "video-rubric-v4"
}

每条合格成片成本 =
  （生成 + 重试 + 人工审核 + 后期修复 + 存储 + 分发）
  / 通过全部发布门禁的成片数

package main

import (
	"fmt"
	"math"
	"sort"
)

type Observation struct {
	Provider       string
	LatencySeconds float64
	GenerationUSD  float64
	ReviewUSD      float64
	PromptPass     bool
	IdentityPass   bool
	SafetyPass     bool
	HumanScore     float64
}

type Summary struct {
	Provider            string
	Trials              int
	Accepted            int
	AcceptanceRate      float64
	P95LatencySeconds   float64
	CostPerApprovedShot float64
}

func isAccepted(item Observation, minimumHumanScore float64) bool {
	return item.PromptPass &&
		item.IdentityPass &&
		item.SafetyPass &&
		item.HumanScore >= minimumHumanScore
}

func percentile95(values []float64) float64 {
	sorted := append([]float64(nil), values...)
	sort.Float64s(sorted)
	index := int(math.Ceil(0.95*float64(len(sorted)))) - 1
	return sorted[index]
}

func summarize(provider string, items []Observation) (Summary, error) {
	if len(items) == 0 {
		return Summary{}, fmt.Errorf("%s has no observations", provider)
	}

	latencies := make([]float64, 0, len(items))
	totalCost := 0.0
	accepted := 0

	for index, item := range items {
		if item.Provider != provider {
			return Summary{}, fmt.Errorf("row %d belongs to %s, not %s", index, item.Provider, provider)
		}
		if item.LatencySeconds <= 0 || item.GenerationUSD < 0 || item.ReviewUSD < 0 {
			return Summary{}, fmt.Errorf("row %d has invalid latency or cost", index)
		}
		if item.HumanScore < 1 || item.HumanScore > 5 {
			return Summary{}, fmt.Errorf("row %d has a human score outside 1..5", index)
		}

		latencies = append(latencies, item.LatencySeconds)
		totalCost += item.GenerationUSD + item.ReviewUSD
		if isAccepted(item, 4) {
			accepted++
		}
	}

	costPerApproved := math.Inf(1)
	if accepted > 0 {
		costPerApproved = totalCost / float64(accepted)
	}

	return Summary{
		Provider:            provider,
		Trials:              len(items),
		Accepted:            accepted,
		AcceptanceRate:      float64(accepted) / float64(len(items)),
		P95LatencySeconds:   percentile95(latencies),
		CostPerApprovedShot: costPerApproved,
	}, nil
}

func main() {
	data := map[string][]Observation{
		"candidate-a": {
			{Provider: "candidate-a", LatencySeconds: 72, GenerationUSD: 1.2, ReviewUSD: 0.3, PromptPass: true, IdentityPass: true, SafetyPass: true, HumanScore: 4.3},
			{Provider: "candidate-a", LatencySeconds: 95, GenerationUSD: 1.2, ReviewUSD: 0.3, PromptPass: true, IdentityPass: false, SafetyPass: true, HumanScore: 4.4},
			{Provider: "candidate-a", LatencySeconds: 80, GenerationUSD: 1.2, ReviewUSD: 0.3, PromptPass: true, IdentityPass: true, SafetyPass: true, HumanScore: 4.1},
		},
		"candidate-b": {
			{Provider: "candidate-b", LatencySeconds: 60, GenerationUSD: 0.9, ReviewUSD: 0.4, PromptPass: true, IdentityPass: true, SafetyPass: true, HumanScore: 4.0},
			{Provider: "candidate-b", LatencySeconds: 110, GenerationUSD: 0.9, ReviewUSD: 0.4, PromptPass: false, IdentityPass: true, SafetyPass: true, HumanScore: 4.6},
			{Provider: "candidate-b", LatencySeconds: 75, GenerationUSD: 0.9, ReviewUSD: 0.4, PromptPass: true, IdentityPass: true, SafetyPass: false, HumanScore: 4.8},
		},
	}

	providers := make([]string, 0, len(data))
	for provider := range data {
		providers = append(providers, provider)
	}
	sort.Strings(providers)

	for _, provider := range providers {
		summary, err := summarize(provider, data[provider])
		if err != nil {
			panic(err)
		}
		fmt.Printf(
			"%s trials=%d accepted=%d rate=%.1f%% p95=%.0fs cost/approved=$%.2f\n",
			summary.Provider,
			summary.Trials,
			summary.Accepted,
			summary.AcceptanceRate*100,
			summary.P95LatencySeconds,
			summary.CostPerApprovedShot,
		)
	}
}

candidate-a trials=3 accepted=2 rate=66.7% p95=95s cost/approved=$2.25
candidate-b trials=3 accepted=1 rate=33.3% p95=110s cost/approved=$3.90