HarmonyOS开发：AI性能优化与推理加速

核心要点：AI推理不是"能跑就行"，而是要"跑得飞快"。本文深入讲解算子融合、内存优化、NPU加速、动态Batch、流水线并行等核心优化技术，以及在HarmonyOS设备上实现毫秒级推理的完整方案。

一、背景与动机

你有没有这样的体验？打开一个拍照APP，点击AI美颜，画面卡了0.5秒才出效果。这0.5秒的卡顿，用户就会觉得这个APP"不够丝滑"。

在移动端AI场景中，性能就是生命线。人脸解锁要50ms内完成，否则用户会觉得"手机坏了"；实时美颜要16ms一帧（60fps），否则画面会卡顿；语音识别要100ms内返回，否则对话就不自然。这些数字不是拍脑袋定的，而是人类感知的极限——超过这些阈值，用户就会"感觉到"延迟。

但现实是，一个未经优化的ResNet-50在手机CPU上推理一次要300-500ms，一个MobileNetV2也要50-100ms。距离"丝滑"还有很长的路要走。

HarmonyOS设备的NPU（神经网络处理单元）是性能优化的"核武器"。麒麟芯片的NPU算力可达几十TOPS（每秒万亿次运算），比CPU快几十倍。但NPU不是万能的——你得把模型"喂"对，把算子"排"对，把内存"管"对，才能榨干NPU的性能。

本文就是教你如何把AI推理从"能跑"优化到"飞起来"。

二、核心原理

2.1 AI推理性能瓶颈分析

推理性能瓶颈通常出现在以下几个环节：

flowchart TB
    classDef primary fill:#4F46E5,stroke:#3730A3,color:#FFFFFF
    classDef warning fill:#F59E0B,stroke:#D97706,color:#FFFFFF
    classDef error fill:#EF4444,stroke:#DC2626,color:#FFFFFF
    classDef info fill:#06B6D4,stroke:#0891B2,color:#FFFFFF
    classDef purple fill:#8B5CF6,stroke:#7C3AED,color:#FFFFFF

    A[AI推理请求]:::primary --> B[数据预处理]:::info
    B --> C[模型推理]:::warning
    C --> D[后处理]:::purple
    D --> E[结果返回]:::primary

    B -.->|GPU加速| F[图像缩放/归一化]:::info
    C -.->|NPU加速| G[卷积/全连接/激活]:::warning
    C -.->|算子融合| H[减少内存搬运]:::error
    C -.->|内存复用| I[减少内存分配]:::purple
    C -.->|量化推理| J[INT8加速]:::info
    D -.->|并行化| K[NMS/解码加速]:::purple

    F --> L[🚀 毫秒级推理]:::primary
    G --> L
    H --> L
    I --> L
    J --> L
    K --> L

2.2 算子融合

算子融合是最有效的推理优化手段之一。核心思想：将多个连续的算子合并为一个，减少中间结果的内存写入和读取。

以最常见的 Conv + BN + ReLU 为例：

融合前（3次内存读写）：

1. Conv计算 → 写入中间缓冲区A
2. 从A读取 → BN计算 → 写入中间缓冲区B
3. 从B读取 → ReLU计算 → 写入输出

融合后（1次内存读写）：

1. Conv + BN + ReLU 一步完成 → 直接写入输出

算子融合不仅减少了内存带宽压力，还让NPU的流水线更高效——数据在寄存器/缓存中直接传递，不需要回写主存。

2.3 内存优化

推理过程中的内存管理是另一个关键瓶颈。主要优化策略：

内存复用：不同算子的中间缓冲区如果生命周期不重叠，可以共享同一块内存。比如算子A的输出在算子B使用完后就没用了，算子C的输出可以覆盖算子A的缓冲区。

内存池：预分配一块大内存作为推理内存池，所有中间结果从池中分配，避免频繁调用系统malloc/free。

数据布局优化：NPU通常使用NHWC布局（通道在最后），而训练框架通常使用NCHW布局（通道在第二维）。在推理前将数据转换为NPU友好的布局，避免推理时反复转置。

2.4 NPU加速

NPU是专门为神经网络计算设计的硬件加速器，相比CPU有数量级的性能优势：

但NPU不是所有算子都支持。不支持的算子会"回退"到CPU执行，产生NPU↔CPU之间的数据搬运开销，反而可能比纯CPU更慢。所以需要仔细检查模型的算子兼容性。

2.5 动态Batch与流水线

动态Batch：将多个推理请求合并成一个Batch，利用NPU的并行计算能力。比如10个用户同时请求人脸识别，可以合并成一个Batch=10的推理请求，NPU一次处理10张图片，比逐个处理快5-8倍。

流水线并行：将推理过程拆成多个阶段，像工厂流水线一样重叠执行。阶段1处理请求N的预处理，同时阶段2处理请求N-1的推理，阶段3处理请求N-2的后处理。这样每个请求的端到端延迟不变，但吞吐量可以提升2-3倍。

三、代码实战

3.1 推理性能分析器

这是优化的第一步——先测量，再优化。没有数据支撑的优化都是"盲猜"。

// InferenceProfiler.ets
// 推理性能分析器 - 精确测量推理各阶段耗时

// 性能指标接口
interface PerformanceMetrics {
  totalLatencyMs: number;          // 总延迟（毫秒）
  preprocessMs: number;            // 预处理耗时
  inferenceMs: number;             // 推理耗时
  postprocessMs: number;           // 后处理耗时
  memoryUsageMB: number;           // 内存占用
  npuUtilization: number;          // NPU利用率
  cpuUtilization: number;          // CPU利用率
  throughputFps: number;           // 吞吐量（帧/秒）
}

// 性能快照
interface PerformanceSnapshot {
  timestamp: number;
  phase: string;                   // 当前阶段
  durationMs: number;              // 持续时间
  memoryDeltaMB: number;           // 内存变化
}

// 分析报告
interface ProfilingReport {
  metrics: PerformanceMetrics;
  snapshots: PerformanceSnapshot[];
  bottlenecks: string[];           // 瓶颈列表
  recommendations: string[];       // 优化建议
  warmupLatencyMs: number;         // 首次推理延迟（含模型加载）
  steadyLatencyMs: number;         // 稳态推理延迟
  jitterMs: number;                // 延迟抖动
}

export class InferenceProfiler {
  private snapshots: PerformanceSnapshot[] = [];
  private latencies: number[] = [];
  private isProfiling: boolean = false;
  private currentPhaseStart: number = 0;
  private warmupRuns: number = 3;

  // 开始性能分析
  startProfiling(): void {
    this.snapshots = [];
    this.latencies = [];
    this.isProfiling = true;
    console.info('[Profiler] 性能分析开始');
  }

  // 开始一个阶段的计时
  beginPhase(phaseName: string): void {
    if (!this.isProfiling) return;
    this.currentPhaseStart = Date.now();
  }

  // 结束一个阶段的计时
  endPhase(phaseName: string): void {
    if (!this.isProfiling) return;
    const duration = Date.now() - this.currentPhaseStart;

    this.snapshots.push({
      timestamp: Date.now(),
      phase: phaseName,
      durationMs: duration,
      memoryDeltaMB: 0 // 简化：实际应通过系统API获取
    });
  }

  // 记录一次完整推理的延迟
  recordInference(latencyMs: number): void {
    this.latencies.push(latencyMs);
  }

  // 结束性能分析并生成报告
  endProfiling(): ProfilingReport {
    this.isProfiling = false;

    // 计算各阶段平均耗时
    const phaseStats = this.computePhaseStats();

    // 计算稳态延迟（去掉预热轮次）
    const steadyLatencies = this.latencies.slice(this.warmupRuns);
    const steadyLatencyMs = steadyLatencies.length > 0
      ? steadyLatencies.reduce((a, b) => a + b, 0) / steadyLatencies.length
      : 0;

    // 计算首次延迟
    const warmupLatencyMs = this.latencies.length > 0 ? this.latencies[0] : 0;

    // 计算延迟抖动（标准差）
    const jitterMs = this.computeJitter(steadyLatencies);

    // 计算吞吐量
    const throughputFps = steadyLatencyMs > 0 ? 1000 / steadyLatencyMs : 0;

    // 识别瓶颈
    const bottlenecks = this.identifyBottlenecks(phaseStats);

    // 生成优化建议
    const recommendations = this.generateRecommendations(bottlenecks, phaseStats);

    const metrics: PerformanceMetrics = {
      totalLatencyMs: this.latencies.length > 0
        ? this.latencies.reduce((a, b) => a + b, 0) / this.latencies.length
        : 0,
      preprocessMs: phaseStats.get('预处理') || 0,
      inferenceMs: phaseStats.get('推理') || 0,
      postprocessMs: phaseStats.get('后处理') || 0,
      memoryUsageMB: 0,
      npuUtilization: 0,
      cpuUtilization: 0,
      throughputFps
    };

    console.info('[Profiler] 性能分析完成');
    console.info(`[Profiler] 稳态延迟: ${steadyLatencyMs.toFixed(1)}ms, ` +
      `吞吐量: ${throughputFps.toFixed(1)}fps`);

    return {
      metrics,
      snapshots: this.snapshots,
      bottlenecks,
      recommendations,
      warmupLatencyMs,
      steadyLatencyMs,
      jitterMs
    };
  }

  // 计算各阶段平均耗时
  private computePhaseStats(): Map<string, number> {
    const stats = new Map<string, number>();
    const counts = new Map<string, number>();

    for (const snapshot of this.snapshots) {
      const current = stats.get(snapshot.phase) || 0;
      const count = counts.get(snapshot.phase) || 0;
      stats.set(snapshot.phase, current + snapshot.durationMs);
      counts.set(snapshot.phase, count + 1);
    }

    // 计算平均值
    for (const [phase, total] of stats) {
      const count = counts.get(phase) || 1;
      stats.set(phase, total / count);
    }

    return stats;
  }

  // 计算延迟抖动（标准差）
  private computeJitter(latencies: number[]): number {
    if (latencies.length < 2) return 0;
    const mean = latencies.reduce((a, b) => a + b, 0) / latencies.length;
    const variance = latencies.reduce((sum, l) => sum + (l - mean) * (l - mean), 0) /
      latencies.length;
    return Math.sqrt(variance);
  }

  // 识别性能瓶颈
  private identifyBottlenecks(phaseStats: Map<string, number>): string[] {
    const bottlenecks: string[] = [];
    const totalMs = Array.from(phaseStats.values()).reduce((a, b) => a + b, 0);

    for (const [phase, duration] of phaseStats) {
      const ratio = duration / totalMs;
      if (ratio > 0.4) {
        bottlenecks.push(`${phase}占比${(ratio * 100).toFixed(0)}%，是主要瓶颈`);
      }
    }

    // 检查首次延迟异常
    if (this.latencies.length > 1) {
      const warmupRatio = this.latencies[0] / this.latencies[this.latencies.length - 1];
      if (warmupRatio > 3) {
        bottlenecks.push(`首次推理延迟是稳态的${warmupRatio.toFixed(1)}倍，模型加载耗时长`);
      }
    }

    // 检查延迟抖动
    const steadyLatencies = this.latencies.slice(this.warmupRuns);
    const jitter = this.computeJitter(steadyLatencies);
    const mean = steadyLatencies.length > 0
      ? steadyLatencies.reduce((a, b) => a + b, 0) / steadyLatencies.length
      : 0;
    if (mean > 0 && jitter / mean > 0.3) {
      bottlenecks.push(`延迟抖动大(CV=${(jitter / mean).toFixed(2)})，推理不稳定`);
    }

    return bottlenecks;
  }

  // 生成优化建议
  private generateRecommendations(bottlenecks: string[],
    phaseStats: Map<string, number>): string[] {
    const recommendations: string[] = [];

    const preprocessTime = phaseStats.get('预处理') || 0;
    const inferenceTime = phaseStats.get('推理') || 0;
    const postprocessTime = phaseStats.get('后处理') || 0;

    // 预处理优化建议
    if (preprocessTime > 10) {
      recommendations.push('💡 预处理耗时较长，建议使用GPU进行图像缩放和归一化');
      recommendations.push('💡 考虑使用异步预处理流水线，与推理重叠执行');
    }

    // 推理优化建议
    if (inferenceTime > 30) {
      recommendations.push('💡 推理耗时较长，建议启用NPU加速');
      recommendations.push('💡 考虑使用INT8量化，推理速度可提升2-4倍');
      recommendations.push('💡 检查是否有算子回退到CPU，优化算子兼容性');
    }

    // 后处理优化建议
    if (postprocessTime > 10) {
      recommendations.push('💡 后处理耗时较长，建议优化NMS算法或使用并行化');
    }

    // 首次延迟优化
    if (this.latencies.length > 0 && this.latencies[0] > 100) {
      recommendations.push('💡 首次推理延迟高，建议APP启动时预热模型');
      recommendations.push('💡 考虑使用内存映射(mmap)加载模型，减少IO时间');
    }

    // 抖动优化
    const steadyLatencies = this.latencies.slice(this.warmupRuns);
    const jitter = this.computeJitter(steadyLatencies);
    if (jitter > 5) {
      recommendations.push('💡 延迟抖动大，建议绑定大核CPU或固定NPU频率');
    }

    return recommendations;
  }
}

3.2 推理加速引擎

集成NPU调度、算子融合、内存池、动态Batch等优化策略的高性能推理引擎。

// InferenceAccelerator.ets
// 推理加速引擎 - NPU调度 + 内存池 + 动态Batch + 流水线

// 加速配置接口
interface AcceleratorConfig {
  useNPU: boolean;                   // 启用NPU加速
  useGPU: boolean;                   // 启用GPU预处理
  enableOperatorFusion: boolean;     // 启用算子融合
  enableMemoryPool: boolean;         // 启用内存池
  enableDynamicBatch: boolean;       // 启用动态Batch
  maxBatchSize: number;              // 最大Batch大小
  batchTimeoutMs: number;            // Batch聚合超时（毫秒）
  enablePipeline: boolean;           // 启用流水线
  memoryPoolSizeMB: number;          // 内存池大小
  numComputeThreads: number;         // 计算线程数
}

// 推理请求接口
interface InferenceRequest {
  id: string;
  input: Float32Array;
  priority: 'low' | 'normal' | 'high';
  callback: (result: Float32Array, latencyMs: number) => void;
  timestamp: number;
}

// 内存块接口
interface MemoryBlock {
  ptr: number;                       // 内存地址（模拟）
  size: number;                      // 大小（字节）
  inUse: boolean;                    // 是否正在使用
  lastUsed: number;                  // 最后使用时间
}

export class InferenceAccelerator {
  private config: AcceleratorConfig;
  private memoryPool: MemoryBlock[] = [];
  private pendingRequests: InferenceRequest[] = [];
  private isProcessing: boolean = false;
  private pipelineStages: Map<string, (input: Float32Array) => Float32Array> = new Map();

  constructor(config: AcceleratorConfig) {
    this.config = config;
    this.initializeMemoryPool();
  }

  // 初始化内存池
  private initializeMemoryPool(): void {
    if (!this.config.enableMemoryPool) return;

    const totalBytes = this.config.memoryPoolSizeMB * 1024 * 1024;
    const blockSize = totalBytes / 16; // 分成16块

    for (let i = 0; i < 16; i++) {
      this.memoryPool.push({
        ptr: i, // 模拟地址
        size: blockSize,
        inUse: false,
        lastUsed: 0
      });
    }

    console.info(`[Accelerator] 内存池初始化: ${this.config.memoryPoolSizeMB}MB, 16个块`);
  }

  // 从内存池分配内存
  private allocateFromPool(sizeBytes: number): MemoryBlock | null {
    // 找到足够大且未使用的块
    let bestBlock: MemoryBlock | null = null;
    let bestSizeDiff = Infinity;

    for (const block of this.memoryPool) {
      if (!block.inUse && block.size >= sizeBytes) {
        const sizeDiff = block.size - sizeBytes;
        if (sizeDiff < bestSizeDiff) {
          bestSizeDiff = sizeDiff;
          bestBlock = block;
        }
      }
    }

    if (bestBlock) {
      bestBlock.inUse = true;
      bestBlock.lastUsed = Date.now();
      return bestBlock;
    }

    // 没有合适的块，尝试回收最久未使用的
    let oldestBlock: MemoryBlock | null = null;
    let oldestTime = Infinity;
    for (const block of this.memoryPool) {
      if (!block.inUse && block.lastUsed < oldestTime) {
        oldestTime = block.lastUsed;
        oldestBlock = block;
      }
    }

    if (oldestBlock) {
      oldestBlock.inUse = true;
      oldestBlock.lastUsed = Date.now();
      return oldestBlock;
    }

    console.warn('[Accelerator] 内存池不足，回退到系统分配');
    return null;
  }

  // 释放内存池中的内存
  private releaseToPool(block: MemoryBlock): void {
    block.inUse = false;
  }

  // 提交推理请求
  submitRequest(request: InferenceRequest): void {
    request.timestamp = Date.now();
    this.pendingRequests.push(request);

    if (this.config.enableDynamicBatch) {
      // 动态Batch模式：等待更多请求聚合
      this.tryProcessBatch();
    } else {
      // 逐个处理
      this.processSingleRequest(request);
    }
  }

  // 尝试处理Batch
  private tryProcessBatch(): void {
    if (this.isProcessing) return;
    if (this.pendingRequests.length === 0) return;

    const now = Date.now();
    const oldestRequest = this.pendingRequests[0];

    // 条件1：Batch已满
    if (this.pendingRequests.length >= this.config.maxBatchSize) {
      this.processBatch(this.pendingRequests.splice(0, this.config.maxBatchSize));
      return;
    }

    // 条件2：等待超时
    if (now - oldestRequest.timestamp > this.config.batchTimeoutMs) {
      const batch = this.pendingRequests.splice(0, this.pendingRequests.length);
      this.processBatch(batch);
      return;
    }

    // 条件3：有高优先级请求，立即处理
    const hasHighPriority = this.pendingRequests.some(r => r.priority === 'high');
    if (hasHighPriority && this.pendingRequests.length >= 1) {
      const batch = this.pendingRequests.splice(0, this.pendingRequests.length);
      this.processBatch(batch);
      return;
    }
  }

  // 处理单个请求
  private processSingleRequest(request: InferenceRequest): void {
    const startTime = Date.now();

    // 分配内存
    const inputSize = request.input.byteLength;
    const inputBlock = this.allocateFromPool(inputSize);

    // 执行推理
    const output = this.executeInference(request.input);

    // 释放内存
    if (inputBlock) this.releaseToPool(inputBlock);

    const latency = Date.now() - startTime;
    request.callback(output, latency);
  }

  // 处理Batch请求
  private processBatch(requests: InferenceRequest[]): void {
    this.isProcessing = true;
    const startTime = Date.now();

    console.info(`[Accelerator] 处理Batch: ${requests.length}个请求`);

    // 将多个输入合并为一个Batch
    const batchSize = requests.length;
    const inputSize = requests[0].input.length;
    const batchInput = new Float32Array(batchSize * inputSize);

    for (let i = 0; i < batchSize; i++) {
      batchInput.set(requests[i].input, i * inputSize);
    }

    // 执行Batch推理
    const batchOutput = this.executeInference(batchInput, batchSize);

    // 拆分输出
    const outputSize = batchOutput.length / batchSize;
    for (let i = 0; i < batchSize; i++) {
      const output = batchOutput.slice(i * outputSize, (i + 1) * outputSize);
      const latency = Date.now() - startTime;
      requests[i].callback(output, latency);
    }

    this.isProcessing = false;

    // 继续处理剩余请求
    if (this.pendingRequests.length > 0) {
      setTimeout(() => this.tryProcessBatch(), 0);
    }
  }

  // 执行推理（核心计算）
  private executeInference(input: Float32Array, batchSize: number = 1): Float32Array {
    // 模拟推理过程
    // 实际项目中使用MindSpore Lite或NNAPI执行推理

    const outputSize = 10; // 假设输出10个类别
    const output = new Float32Array(batchSize * outputSize);

    // 模拟计算：简单的全连接层
    for (let b = 0; b < batchSize; b++) {
      for (let i = 0; i < outputSize; i++) {
        let sum = 0;
        const inputOffset = b * (input.length / batchSize);
        for (let j = 0; j < Math.min(input.length / batchSize, 100); j++) {
          sum += input[inputOffset + j] * (Math.random() - 0.5) * 0.1;
        }
        output[b * outputSize + i] = 1 / (1 + Math.exp(-sum));
      }
    }

    return output;
  }

  // 算子融合优化
  optimizeModel(modelGraph: Map<string, string[]>): Map<string, string[]> {
    if (!this.config.enableOperatorFusion) return modelGraph;

    const optimizedGraph = new Map<string, string[]>();
    const fusionPatterns = [
      ['Conv2D', 'BatchNorm', 'ReLU'],           // Conv+BN+ReLU融合
      ['Conv2D', 'BatchNorm', 'ReLU6'],           // Conv+BN+ReLU6融合
      ['MatMul', 'Add', 'ReLU'],                   // 全连接+偏置+激活融合
      ['DepthwiseConv2D', 'BatchNorm', 'ReLU6'],  // 深度卷积+BN+激活融合
    ];

    const nodes = Array.from(modelGraph.keys());
    let i = 0;

    while (i < nodes.length) {
      let fused = false;

      // 尝试匹配融合模式
      for (const pattern of fusionPatterns) {
        if (i + pattern.length <= nodes.length) {
          const match = pattern.every((op, idx) => nodes[i + idx].startsWith(op));
          if (match) {
            // 融合为一个节点
            const fusedName = `Fused_${pattern.join('_')}`;
            optimizedGraph.set(fusedName, modelGraph.get(nodes[i + pattern.length - 1]) || []);
            console.info(`[Accelerator] 算子融合: ${pattern.join(' → ')} → ${fusedName}`);
            i += pattern.length;
            fused = true;
            break;
          }
        }
      }

      if (!fused) {
        optimizedGraph.set(nodes[i], modelGraph.get(nodes[i]) || []);
        i++;
      }
    }

    const originalCount = modelGraph.size;
    const optimizedCount = optimizedGraph.size;
    console.info(`[Accelerator] 算子融合完成: ${originalCount}→${optimizedCount}个节点`);

    return optimizedGraph;
  }

  // 流水线推理
  async pipelineInference(input: Float32Array): Promise<Float32Array> {
    if (!this.config.enablePipeline) {
      return this.executeInference(input);
    }

    // 流水线阶段：预处理 → 推理 → 后处理
    const stage1Output = this.pipelinePreprocess(input);
    const stage2Output = this.executeInference(stage1Output);
    const stage3Output = this.pipelinePostprocess(stage2Output);

    return stage3Output;
  }

  // 流水线预处理阶段
  private pipelinePreprocess(input: Float32Array): Float32Array {
    // 图像归一化：[0,255] → [0,1]
    const normalized = new Float32Array(input.length);
    for (let i = 0; i < input.length; i++) {
      normalized[i] = input[i] / 255.0;
    }
    return normalized;
  }

  // 流水线后处理阶段
  private pipelinePostprocess(output: Float32Array): Float32Array {
    // Softmax归一化
    let maxVal = -Infinity;
    for (let i = 0; i < output.length; i++) {
      maxVal = Math.max(maxVal, output[i]);
    }

    let sumExp = 0;
    const softmax = new Float32Array(output.length);
    for (let i = 0; i < output.length; i++) {
      softmax[i] = Math.exp(output[i] - maxVal);
      sumExp += softmax[i];
    }
    for (let i = 0; i < output.length; i++) {
      softmax[i] /= sumExp;
    }

    return softmax;
  }

  // 获取内存池使用情况
  getMemoryPoolStats(): { totalBlocks: number; usedBlocks: number; freeBlocks: number } {
    const usedBlocks = this.memoryPool.filter(b => b.inUse).length;
    return {
      totalBlocks: this.memoryPool.length,
      usedBlocks,
      freeBlocks: this.memoryPool.length - usedBlocks
    };
  }

  // 获取待处理请求数
  getPendingRequestCount(): number {
    return this.pendingRequests.length;
  }
}

3.3 AI性能监控面板

将性能分析器和加速引擎集成到HarmonyOS应用中，提供实时性能监控和优化建议。

// AIPerformancePage.ets
// AI性能监控面板 - 实时性能分析与优化可视化

import { InferenceProfiler, ProfilingReport } from './InferenceProfiler';
import { InferenceAccelerator, AcceleratorConfig } from './InferenceAccelerator';

@Entry
@Component
struct AIPerformancePage {
  // 性能指标
  @State avgLatency: number = 0;
  @State p99Latency: number = 0;
  @State throughput: number = 0;
  @State memoryUsage: number = 0;
  @State npuUtilization: number = 0;
  @State firstRunLatency: number = 0;
  @State jitterValue: number = 0;

  // 优化开关
  @State useNPU: boolean = true;
  @State useGPU: boolean = true;
  @State enableFusion: boolean = true;
  @State enableMemPool: boolean = true;
  @State enableBatch: boolean = false;
  @State enablePipeline: boolean = true;

  // 延迟分布
  @State latencyHistory: number[] = [];
  @State maxLatencyHistory: number = 30;

  // 优化建议
  @State recommendations: string[] = [];
  @State bottlenecks: string[] = [];

  // 测试状态
  @State isRunning: boolean = false;
  @State runCount: number = 0;

  // 分析器
  private profiler: InferenceProfiler = new InferenceProfiler();

  build() {
    Navigation() {
      Scroll() {
        Column({ space: 16 }) {
          // 核心性能指标
          this.CoreMetricsCard()

          // 延迟趋势图
          this.LatencyTrendCard()

          // 优化配置
          this.OptimizationConfigCard()

          // 测试控制
          this.TestControlCard()

          // 瓶颈与建议
          this.BottleneckCard()
        }
        .width('100%')
        .padding(16)
      }
      .width('100%')
      .height('100%')
    }
    .title('AI性能中心')
    .titleMode(NavigationTitleMode.Mini)
  }

  // 核心性能指标
  @Builder CoreMetricsCard() {
    Column({ space: 12 }) {
      Text('⚡ 核心性能指标')
        .fontSize(18)
        .fontWeight(FontWeight.Bold)
        .fontColor('#1E293B')
        .width('100%')

      // 第一行：延迟指标
      Row({ space: 8 }) {
        this.MetricCard('平均延迟', `${this.avgLatency.toFixed(1)}ms`,
          this.avgLatency < 30 ? '#10B981' : this.avgLatency < 100 ? '#F59E0B' : '#EF4444')
        this.MetricCard('P99延迟', `${this.p99Latency.toFixed(1)}ms`,
          this.p99Latency < 50 ? '#10B981' : this.p99Latency < 200 ? '#F59E0B' : '#EF4444')
        this.MetricCard('首次延迟', `${this.firstRunLatency.toFixed(0)}ms`,
          this.firstRunLatency < 100 ? '#10B981' : '#F59E0B')
      }
      .width('100%')

      // 第二行：吞吐与资源
      Row({ space: 8 }) {
        this.MetricCard('吞吐量', `${this.throughput.toFixed(1)}fps`, '#4F46E5')
        this.MetricCard('内存占用', `${this.memoryUsage.toFixed(0)}MB`, '#8B5CF6')
        this.MetricCard('NPU利用率', `${this.npuUtilization.toFixed(0)}%`, '#06B6D4')
      }
      .width('100%')

      // 第三行：稳定性
      Row({ space: 8 }) {
        this.MetricCard('延迟抖动', `${this.jitterValue.toFixed(1)}ms`,
          this.jitterValue < 5 ? '#10B981' : '#F59E0B')
        this.MetricCard('运行次数', `${this.runCount}`, '#64748B')
        this.MetricCard('性能等级', this.getPerformanceGrade(), this.getGradeColor())
      }
      .width('100%')
    }
    .width('100%')
    .padding(16)
    .borderRadius(16)
    .backgroundColor('#FFFFFF')
    .shadow({ radius: 8, color: 'rgba(0,0,0,0.06)', offsetX: 0, offsetY: 2 })
  }

  // 指标卡片
  @Builder MetricCard(label: string, value: string, color: string) {
    Column({ space: 4 }) {
      Text(value)
        .fontSize(16)
        .fontWeight(FontWeight.Bold)
        .fontColor(color)
      Text(label)
        .fontSize(11)
        .fontColor('#94A3B8')
    }
    .padding(8)
    .borderRadius(8)
    .backgroundColor('#F8FAFC')
    .layoutWeight(1)
    .alignItems(HorizontalAlign.Center)
  }

  // 延迟趋势图
  @Builder LatencyTrendCard() {
    Column({ space: 8 }) {
      Text('📈 延迟趋势')
        .fontSize(16)
        .fontWeight(FontWeight.Bold)
        .fontColor('#1E293B')
        .width('100%')

      if (this.latencyHistory.length === 0) {
        Text('运行推理测试后显示趋势')
          .fontSize(13)
          .fontColor('#94A3B8')
          .width('100%')
          .textAlign(TextAlign.Center)
          .padding(20)
      } else {
        // 简化的柱状图
        Row({ space: 2 }) {
          ForEach(this.latencyHistory, (latency: number, index: number) => {
            Column() {
              Column()
                .width('100%')
                .height(Math.max(2, Math.min(80, latency / 2)))
                .backgroundColor(latency < 30 ? '#10B981' : latency < 100 ? '#F59E0B' : '#EF4444')
                .borderRadius(2)
            }
            .width('100%')
            .height(80)
            .justifyContent(FlexAlign.End)
          }, (latency: number, index: number) => `${index}`)
        }
        .width('100%')
        .height(80)
        .padding({ left: 4, right: 4 })

        // 图例
        Row({ space: 12 }) {
          Row({ space: 4 }) {
            Circle().width(8).height(8).fill('#10B981')
            Text('<30ms')
              .fontSize(10)
              .fontColor('#94A3B8')
          }
          Row({ space: 4 }) {
            Circle().width(8).height(8).fill('#F59E0B')
            Text('30-100ms')
              .fontSize(10)
              .fontColor('#94A3B8')
          }
          Row({ space: 4 }) {
            Circle().width(8).height(8).fill('#EF4444')
            Text('>100ms')
              .fontSize(10)
              .fontColor('#94A3B8')
          }
        }
      }
    }
    .width('100%')
    .padding(16)
    .borderRadius(16)
    .backgroundColor('#FFFFFF')
    .shadow({ radius: 8, color: 'rgba(0,0,0,0.06)', offsetX: 0, offsetY: 2 })
  }

  // 优化配置卡片
  @Builder OptimizationConfigCard() {
    Column({ space: 12 }) {
      Text('🔧 优化配置')
        .fontSize(16)
        .fontWeight(FontWeight.Bold)
        .fontColor('#1E293B')
        .width('100%')

      this.OptimizationToggle('NPU加速', '利用神经网络处理单元加速推理', this.useNPU,
        (isOn: boolean) => { this.useNPU = isOn; })
      this.OptimizationToggle('GPU预处理', '使用GPU进行图像缩放和归一化', this.useGPU,
        (isOn: boolean) => { this.useGPU = isOn; })
      this.OptimizationToggle('算子融合', '合并连续算子减少内存读写', this.enableFusion,
        (isOn: boolean) => { this.enableFusion = isOn; })
      this.OptimizationToggle('内存池', '预分配内存减少运行时分配开销', this.enableMemPool,
        (isOn: boolean) => { this.enableMemPool = isOn; })
      this.OptimizationToggle('动态Batch', '合并多个请求提高NPU利用率', this.enableBatch,
        (isOn: boolean) => { this.enableBatch = isOn; })
      this.OptimizationToggle('流水线', '预处理/推理/后处理重叠执行', this.enablePipeline,
        (isOn: boolean) => { this.enablePipeline = isOn; })
    }
    .width('100%')
    .padding(16)
    .borderRadius(16)
    .backgroundColor('#FFFFFF')
    .shadow({ radius: 8, color: 'rgba(0,0,0,0.06)', offsetX: 0, offsetY: 2 })
  }

  // 优化开关
  @Builder OptimizationToggle(title: string, desc: string, isOn: boolean,
    onChange: (isOn: boolean) => void) {
    Row() {
      Column({ space: 2 }) {
        Text(title)
          .fontSize(14)
          .fontColor('#1E293B')
          .fontWeight(FontWeight.Medium)
        Text(desc)
          .fontSize(11)
          .fontColor('#94A3B8')
      }
      .layoutWeight(1)
      Toggle({ type: ToggleType.Switch, isOn: isOn })
        .selectedColor('#4F46E5')
        .onChange(onChange)
    }
    .width('100%')
    .padding({ top: 4, bottom: 4 })
  }

  // 测试控制卡片
  @Builder TestControlCard() {
    Column({ space: 12 }) {
      Text('🧪 性能测试')
        .fontSize(16)
        .fontWeight(FontWeight.Bold)
        .fontColor('#1E293B')
        .width('100%')

      Row({ space: 12 }) {
        Button('单次推理')
          .fontSize(14)
          .fontWeight(FontWeight.Bold)
          .fontColor('#FFFFFF')
          .backgroundColor('#4F46E5')
          .borderRadius(10)
          .layoutWeight(1)
          .height(44)
          .enabled(!this.isRunning)
          .onClick(() => this.runSingleTest())

        Button('连续推理 x30')
          .fontSize(14)
          .fontWeight(FontWeight.Bold)
          .fontColor('#FFFFFF')
          .backgroundColor('#8B5CF6')
          .borderRadius(10)
          .layoutWeight(1)
          .height(44)
          .enabled(!this.isRunning)
          .onClick(() => this.runContinuousTest())

        Button('重置')
          .fontSize(14)
          .fontColor('#64748B')
          .backgroundColor('#F1F5F9')
          .borderRadius(10)
          .width(70)
          .height(44)
          .onClick(() => this.resetMetrics())
      }
      .width('100%')
    }
    .width('100%')
    .padding(16)
    .borderRadius(16)
    .backgroundColor('#FFFFFF')
    .shadow({ radius: 8, color: 'rgba(0,0,0,0.06)', offsetX: 0, offsetY: 2 })
  }

  // 瓶颈与建议卡片
  @Builder BottleneckCard() {
    Column({ space: 8 }) {
      Text('🔍 瓶颈分析 & 优化建议')
        .fontSize(16)
        .fontWeight(FontWeight.Bold)
        .fontColor('#1E293B')
        .width('100%')

      if (this.bottlenecks.length > 0) {
        Text('⚠️ 性能瓶颈:')
          .fontSize(13)
          .fontWeight(FontWeight.Bold)
          .fontColor('#EF4444')
          .width('100%')

        ForEach(this.bottlenecks, (bottleneck: string, index: number) => {
          Text(`  • ${bottleneck}`)
            .fontSize(12)
            .fontColor('#64748B')
            .width('100%')
        }, (bottleneck: string, index: number) => `${index}`)
      }

      if (this.recommendations.length > 0) {
        Text('💡 优化建议:')
          .fontSize(13)
          .fontWeight(FontWeight.Bold)
          .fontColor('#4F46E5')
          .width('100%')
          .margin({ top: 8 })

        ForEach(this.recommendations, (rec: string, index: number) => {
          Text(`  ${rec}`)
            .fontSize(12)
            .fontColor('#475569')
            .width('100%')
        }, (rec: string, index: number) => `${index}`)
      }

      if (this.bottlenecks.length === 0 && this.recommendations.length === 0) {
        Text('运行推理测试后显示分析结果')
          .fontSize(13)
          .fontColor('#94A3B8')
          .width('100%')
          .textAlign(TextAlign.Center)
          .padding(16)
      }
    }
    .width('100%')
    .padding(16)
    .borderRadius(16)
    .backgroundColor('#FFFFFF')
    .shadow({ radius: 8, color: 'rgba(0,0,0,0.06)', offsetX: 0, offsetY: 2 })
  }

  // 获取性能等级
  private getPerformanceGrade(): string {
    if (this.avgLatency === 0) return '--';
    if (this.avgLatency < 10) return 'S';
    if (this.avgLatency < 30) return 'A';
    if (this.avgLatency < 60) return 'B';
    if (this.avgLatency < 100) return 'C';
    return 'D';
  }

  // 获取等级颜色
  private getGradeColor(): string {
    if (this.avgLatency === 0) return '#94A3B8';
    if (this.avgLatency < 10) return '#10B981';
    if (this.avgLatency < 30) return '#06B6D4';
    if (this.avgLatency < 60) return '#F59E0B';
    return '#EF4444';
  }

  // 运行单次测试
  private async runSingleTest() {
    this.isRunning = true;
    this.profiler.startProfiling();

    // 模拟推理延迟
    const baseLatency = this.useNPU ? 8 : 150;
    const variance = this.enableFusion ? 2 : 10;
    const latency = baseLatency + (Math.random() - 0.5) * variance * 2;

    this.profiler.beginPhase('预处理');
    await this.delay(this.useGPU ? 2 : 8);
    this.profiler.endPhase('预处理');

    this.profiler.beginPhase('推理');
    await this.delay(latency);
    this.profiler.endPhase('推理');

    this.profiler.beginPhase('后处理');
    await this.delay(this.enablePipeline ? 1 : 5);
    this.profiler.endPhase('后处理');

    this.profiler.recordInference(latency + (this.useGPU ? 2 : 8) + (this.enablePipeline ? 1 : 5));

    const report = this.profiler.endProfiling();
    this.updateMetricsFromReport(report);

    this.isRunning = false;
  }

  // 运行连续测试
  private async runContinuousTest() {
    this.isRunning = true;
    this.profiler.startProfiling();

    for (let i = 0; i < 30; i++) {
      const baseLatency = this.useNPU ? 8 : 150;
      const variance = this.enableFusion ? 2 : 10;
      const warmupFactor = i < 3 ? 3 : 1; // 前3次有预热开销
      const latency = (baseLatency + (Math.random() - 0.5) * variance * 2) * warmupFactor;

      this.profiler.beginPhase('预处理');
      await this.delay(this.useGPU ? 2 : 8);
      this.profiler.endPhase('预处理');

      this.profiler.beginPhase('推理');
      await this.delay(Math.max(1, latency));
      this.profiler.endPhase('推理');

      this.profiler.beginPhase('后处理');
      await this.delay(this.enablePipeline ? 1 : 5);
      this.profiler.endPhase('后处理');

      const totalLatency = latency + (this.useGPU ? 2 : 8) + (this.enablePipeline ? 1 : 5);
      this.profiler.recordInference(totalLatency);

      this.latencyHistory.push(Math.round(totalLatency));
      if (this.latencyHistory.length > this.maxLatencyHistory) {
        this.latencyHistory.shift();
      }
      this.runCount++;
    }

    const report = this.profiler.endProfiling();
    this.updateMetricsFromReport(report);

    this.isRunning = false;
  }

  // 从报告更新指标
  private updateMetricsFromReport(report: ProfilingReport): void {
    this.avgLatency = report.metrics.totalLatencyMs;
    this.firstRunLatency = report.warmupLatencyMs;
    this.jitterValue = report.jitterMs;
    this.throughput = report.metrics.throughputFps;
    this.memoryUsage = report.metrics.memoryUsageMB || 128;
    this.npuUtilization = this.useNPU ? 85 : 0;
    this.bottlenecks = report.bottlenecks;
    this.recommendations = report.recommendations;

    // 计算P99延迟
    if (this.latencyHistory.length > 0) {
      const sorted = [...this.latencyHistory].sort((a, b) => a - b);
      const p99Idx = Math.floor(sorted.length * 0.99);
      this.p99Latency = sorted[Math.min(p99Idx, sorted.length - 1)];
    }
  }

  // 重置指标
  private resetMetrics() {
    this.avgLatency = 0;
    this.p99Latency = 0;
    this.throughput = 0;
    this.memoryUsage = 0;
    this.npuUtilization = 0;
    this.firstRunLatency = 0;
    this.jitterValue = 0;
    this.latencyHistory = [];
    this.recommendations = [];
    this.bottlenecks = [];
    this.runCount = 0;
  }

  // 延迟函数
  private delay(ms: number): Promise<void> {
    return new Promise(resolve => setTimeout(resolve, Math.max(1, ms)));
  }
}

四、踩坑与注意事项

坑1：NPU算子回退导致性能更差

问题：模型中有NPU不支持的算子（如某些自定义算子），推理时这部分回退到CPU执行。但NPU↔CPU之间的数据拷贝开销可能比直接在CPU上跑整个模型还大。

解决方案：

• 使用MindSpore Lite的算子兼容性检查工具，提前发现不支持的算子
• 将不支持的算子替换为等价的支持算子
• 如果回退算子太多，考虑整个模型用CPU推理（避免频繁NPU↔CPU切换）

// 算子兼容性检查
class OperatorCompatibilityChecker {
  // NPU支持的算子白名单
  private npuSupportedOps: Set<string> = new Set([
    'Conv2D', 'DepthwiseConv2D', 'MatMul', 'ReLU', 'ReLU6',
    'Sigmoid', 'Tanh', 'Softmax', 'MaxPool2D', 'AvgPool2D',
    'Reshape', 'Concat', 'Add', 'Multiply', 'BatchNorm'
  ]);

  checkCompatibility(modelOps: string[]): {
    compatible: boolean;
    unsupportedOps: string[];
    fallbackCount: number;
    recommendation: string;
  } {
    const unsupportedOps = modelOps.filter(op => !this.npuSupportedOps.has(op));

    if (unsupportedOps.length === 0) {
      return {
        compatible: true,
        unsupportedOps: [],
        fallbackCount: 0,
        recommendation: '所有算子均支持NPU加速，建议启用NPU'
      };
    }

    const fallbackRatio = unsupportedOps.length / modelOps.length;
    let recommendation: string;

    if (fallbackRatio < 0.1) {
      recommendation = `少量算子不支持(${unsupportedOps.join(', ')}), 建议替换后启用NPU`;
    } else if (fallbackRatio < 0.3) {
      recommendation = `较多算子不支持，NPU回退开销可能较大，建议评估后决定`;
    } else {
      recommendation = `大量算子不支持，建议使用CPU推理或重新设计模型`;
    }

    return {
      compatible: unsupportedOps.length === 0,
      unsupportedOps,
      fallbackCount: unsupportedOps.length,
      recommendation
    };
  }
}

坑2：内存泄漏导致APP崩溃

问题：推理过程中频繁分配/释放中间缓冲区，长时间运行后内存碎片化严重，最终OOM。

解决方案：

• 使用内存池（前面已实现），预分配固定大小的内存
• 定期检查内存使用，超过阈值时主动清理
• 使用对象池复用Float32Array等大对象

坑3：首次推理延迟过高

问题：第一次推理时需要加载模型、初始化NPU、编译计算图，延迟可能是稳态的5-10倍。用户第一次点击就遇到卡顿，体验极差。

解决方案：

• 模型预热：APP启动后在后台执行2-3次"空推理"，提前完成初始化
• 内存映射加载：使用mmap加载模型文件，不复制到内存
• 模型缓存：将编译后的计算图缓存到本地，下次直接加载

// 模型预热
async warmupModel(): Promise<void> {
  console.info('[Warmup] 开始模型预热...');

  // 创建虚拟输入
  const dummyInput = new Float32Array(224 * 224 * 3);

  // 执行2-3次空推理
  for (let i = 0; i < 3; i++) {
    try {
      await this.executeInference(dummyInput);
      console.info(`[Warmup] 预热轮次 ${i + 1} 完成`);
    } catch (error) {
      console.warn(`[Warmup] 预热轮次 ${i + 1} 失败: ${error}`);
    }
  }

  console.info('[Warmup] 模型预热完成');
}

坑4：动态Batch延迟不可控

问题：动态Batch需要等待多个请求聚合，如果请求稀疏，单个请求可能等很久才被处理。

解决方案：

• 设置Batch聚合超时（如50ms），超时后即使只有1个请求也立即处理
• 高优先级请求跳过Batch等待，立即处理
• 根据实时请求频率自适应调整超时时间

坑5：多线程竞争导致推理结果错乱

问题：多个线程同时调用推理接口，共享的模型权重和中间缓冲区被并发修改，导致推理结果随机错误。

解决方案：

• 使用互斥锁保护推理过程
• 或者使用Actor模式：推理请求通过消息队列传递给专用推理线程
• 或者使用多实例：每个线程一个模型实例（内存开销大）

五、HarmonyOS 6适配

5.1 API差异

5.2 迁移指南

// HarmonyOS 5.0 - 手动NPU调度
import mindSpore from '@ohos.ai.mindSpore';
const context = await mindSpore.createContext();
context.addTarget(mindSpore.DeviceType.NPU); // 手动指定NPU

// HarmonyOS 6 - 自适应调度
import { inferenceEngine } from '@kit.AiKit';

const model = await inferenceEngine.loadModel({
  uri: '/data/models/resnet50.om', // 预编译格式，加载更快
  accelerator: inferenceEngine.Accelerator.AUTO, // 自动选择最优加速器
  optimization: {
    enableOperatorFusion: true,    // 编译器自动融合
    enableMemoryPool: true,        // 系统级内存池
    enableAutoBatch: true,         // 自动Batch聚合
    enablePipeline: true,          // 自动流水线
    warmupOnLoad: true             // 加载时自动预热
  }
});

// 新增：AI Performance Profiler
import { aiProfiler } from '@kit.AiKit';

const session = aiProfiler.createSession({
  targetLatencyMs: 16,   // 目标延迟16ms（60fps）
  samplingRate: 1.0      // 100%采样
});

// 自动采集推理性能数据
session.start();
// ... 执行推理 ...
const report = session.stop();
// report包含：延迟分布、NPU利用率、内存峰值、算子耗时等

5.3 HarmonyOS 6新增特性

• 自适应加速器调度：系统根据模型特征和设备状态自动选择NPU/GPU/CPU
• 编译器自动算子融合：模型加载时编译器自动识别可融合的算子模式
• 预编译模型格式(.om)：编译好的计算图直接加载，首次推理零延迟
• 系统级推理内存池：跨模型共享内存池，内存利用率提升50%+
• AI Performance Profiler：系统级性能分析工具，可视化推理瓶颈
• 模型调度器：多模型场景自动调度，避免资源冲突

六、总结

AI性能优化是一个系统工程，不是调一个参数就能搞定的。它需要从模型设计（选轻量模型）、模型压缩（量化/剪枝）、推理引擎（算子融合/内存池）、硬件调度（NPU加速）、应用架构（预热/流水线）等多个层面协同优化。

记住一个原则：先测量，再优化，最后验证。没有数据支撑的优化都是"盲猜"，可能花了大力气优化了一个不是瓶颈的环节，真正的瓶颈却没动。用InferenceProfiler先定位瓶颈，再对症下药，才能事半功倍。

HarmonyOS 6的自适应调度和自动算子融合，让很多优化工作从"手动挡"变成了"自动挡"。但理解底层原理依然重要——因为"自动挡"也有失灵的时候，那时候就需要你切回"手动挡"，知道该调什么参数。性能优化的终极目标不是"跑分最高"，而是"用户体验最好"——用户不在乎你用了什么技术，只在乎"够不够快、够不够稳"。