Web 应用中的 Edge AI 推理：适合什么，不适合什么

// ❌ 每次请求都加载模型，冷启动必然超时
export default {
  async fetch(request, env) {
    const model = await loadModelFromKV('bert-base')  // 440MB，每次冷启动重新读
    const result = await session.run({ input_ids, attention_mask })
    return Response.json(result)
  }
}

// ✅ 启动时预加载 + 后台保活，避免重复初始化
import { InferenceSession, Tensor } from 'onnxruntime-web'
 
// 模块加载阶段即创建 session，利用 isolate 复用
let sessionPromise = null
function getSession(env) {
  if (!sessionPromise) {
    // MiniLM INT8 量化后约 23MB，从 KV 读取一次
    sessionPromise = env.MODEL_KV.get('minilm-int8', 'arrayBuffer')
      .then(buf => InferenceSession.create(buf, {
        executionProviders: ['wasm'],
        //  intra-op 线程数在边缘环境通常固定为 1
      }))
  }
  return sessionPromise
}
 
// 后台定时器保持 isolate 热状态，减少冷启动概率
const keepAlive = setInterval(() => {
  // 每 5 分钟发一个空操作，防止 V8 isolate 被回收
  void 0
}, 300_000)
 
export default {
  async fetch(request, env) {
    const session = await getSession(env)
    const inputIds = new Tensor('int64', tokenize(text), [1, seqLen])
    const result = await session.run({ input_ids: inputIds })
    return Response.json(classify(result))
  }
}

// ❌ 只检查 navigator.gpu，不够用
if ('gpu' in navigator) {
  // 直接加载 WebGPU 模型
  const adapter = await navigator.gpu.requestAdapter()
  const session = await createSession(modelUrl, { backend: 'webgpu' })
}

// ✅ 多层降级：WebGPU → WASM → 中心 API
async function detectCapability() {
  if (!('gpu' in navigator)) return 'api-fallback'
 
  const adapter = await navigator.gpu?.requestAdapter()
  if (!adapter) return 'api-fallback'
 
  // 检查设备内存（粗略判断）
  const memoryGB = navigator.deviceMemory || 4
  if (memoryGB < 8) return 'wasm-fallback'
 
  // 实际尝试分配 GPU 内存，验证可用性
  try {
    const device = await adapter.requestDevice()
    // 用一个小型 tensor 验证 GPU 计算是否正常
    const buffer = device.createBuffer({ size: 1024, usage: GPUBufferUsage.STORAGE })
    buffer.destroy()
    device.destroy()
    return 'webgpu'
  } catch {
    return 'wasm-fallback'
  }
}
 
async function summarize(text) {
  const capability = await detectCapability()
 
  switch (capability) {
    case 'webgpu':
      return runBrowserSummarize(text, { backend: 'webgpu' })
    case 'wasm-fallback':
      // WASM 后端速度慢，但功能一致
      return runBrowserSummarize(text, { backend: 'wasm' })
    case 'api-fallback':
    default:
      return fetch('/api/summarize', {
        method: 'POST',
        body: JSON.stringify({ text })
      }).then(r => r.json())
  }
}

// ❌ 浏览器端和后端用不同精度模型，输出不一致
// 浏览器端
const browserResult = await browserEngine.run(text, { quantization: 'int4' })
// 后端
const serverResult = await serverModel.run(text)  // FP16
// browserResult !== serverResult，用户感知到结果跳变

// ✅ 统一模型版本 + 一致性校验层
class HybridInference {
  constructor() {
    // 浏览器端用 INT8 量化，后端也用 INT8 部署
    // 精度损失更小，两端输出更接近
    this.browserEngine = new BrowserEngine({
      modelUrl: '/models/classifier-int8.onnx',
      quantization: 'int8',
      // 固定随机种子以保证确定性输出
      seed: 42
    })
    this.apiEndpoint = '/api/classify'
  }
 
  async classify(text) {
    const browserResult = await this.browserEngine.run(text)
 
    if (!this.browserEngine.isReliable()) {
      // 浏览器端不可靠时（WebGPU 不可用、内存不足等），直接走 API
      return this.callApi(text)
    }
 
    // 10% 的请求同时走 API，对比两端结果
    if (Math.random() < 0.1) {
      const apiResult = await this.callApi(text)
      const consistent = this.compareResults(browserResult, apiResult)
      // 记录一致性指标，不一致时触发告警
      this.metrics.recordConsistency(consistent)
      if (!consistent) {
        // 不一致时以后端结果为准
        return apiResult
      }
    }
 
    return browserResult
  }
 
  compareResults(a, b) {
    // 余弦相似度 > 0.95 视为一致
    const similarity = cosineSimilarity(a.embeddings, b.embeddings)
    return similarity > 0.95
  }
 
  async callApi(text) {
    const res = await fetch(this.apiEndpoint, {
      method: 'POST',
      body: JSON.stringify({ text, model: 'classifier-int8' })
    })
    return res.json()
  }
}

// ❌ 在 Worker 里直接跑 LLM 推理，CPU 时间远远不够
export default {
  async fetch(request, env) {
    const session = await InferenceSession.create('/models/llama-13b.onnx')
    // 生成一个 token 就需要 200-500ms，远超 50ms CPU 限制
    const output = await session.run({ input_ids })
    return Response.json(output)
  }
}

// ✅ 用 Workers AI 托管推理，Worker 只做路由和流式传输
export default {
  async fetch(request, env) {
    const { messages } = await request.json()
    // Workers AI 由平台管理 GPU，不受 Worker CPU 时间约束
    const response = await env.AI.run('@cf/meta/llama-2-13b-chat-int8', {
      messages,
      stream: true
    })
    // 流式返回，用户体验接近实时
    return new Response(response, {
      headers: { 'content-type': 'text/event-stream' }
    })
  }
}