HarmonyOS APP开发：模型量化技术（INT8/FP16）与精度保持

核心要点：模型量化是端侧AI部署的"必选项"——一个FP32的ResNet-50要100MB，量化为INT8后只有25MB，推理速度提升2-4倍。但量化不是免费的午餐，精度损失是最大的代价。本文深入讲解INT8/FP16量化原理、校准策略、精度评估方法，以及在HarmonyOS上的完整实战。

一、背景与动机

先算一笔账。

一个典型的MobileNetV2模型，FP32精度下参数量约3.5M，每个参数占4字节，光权重文件就要14MB。推理时还需要存储中间特征图，一个224×224的输入，中间层的特征图可能多达几十MB。加上运行时开销，一个模型跑起来可能吃掉50-100MB内存。

你的手机APP分到多少内存？2GB？3GB？一个AI模型就吃掉3-5%的内存配额，这谁顶得住？

更关键的是速度。FP32的乘加运算在CPU上需要4个时钟周期，而INT8只需要1个。NPU更是为INT8量身定做的——华为的达芬奇架构NPU，INT8算力是FP32的4-8倍。

所以量化不是"可选项"，而是端侧AI的"必选项"。

但量化有个致命问题：精度损失。把一个FP32的0.123456789量化成INT8的15，信息必然丢失。对于分类任务，1%的精度下降可能还能接受；但对于目标检测、语义分割这类像素级任务，量化可能让模型直接"废掉"。

怎么在速度和精度之间找到平衡？这就是本文要回答的核心问题。

二、核心原理

2.1 量化基本概念

量化（Quantization） 的本质是将高精度的浮点数映射到低精度的整数，核心公式为：

量化：q = round(r / S + Z)
反量化：r = (q - Z) * S

其中：
r - 原始浮点值（real value）
q - 量化后的整数值（quantized value）
S - 缩放因子（scale）
Z - 零点（zero point）

2.2 量化类型对比

flowchart TB
    classDef primary fill:#4A90D9,stroke:#2C5F8A,color:#fff,font-weight:bold
    classDef warning fill:#E8A838,stroke:#B87A1A,color:#fff,font-weight:bold
    classDef error fill:#E25B45,stroke:#A63C2E,color:#fff,font-weight:bold
    classDef info fill:#50B5A9,stroke:#3A8A80,color:#fff,font-weight:bold
    classDef purple fill:#9B6DD7,stroke:#7A4DB0,color:#fff,font-weight:bold

    A[模型量化]:::primary --> B[训练后量化<br>Post-Training Quantization]:::warning
    A --> C[量化感知训练<br>Quantization-Aware Training]:::error
    
    B --> B1[动态量化<br>Dynamic Quantization]:::info
    B --> B2[静态量化<br>Static Quantization]:::info
    
    B2 --> B2a[权重量化<br>Weight Quantization]:::purple
    B2 --> B2b[全量化<br>Full Quantization]:::purple
    
    C --> C1[模拟量化训练<br>Fake Quantization]:::error
    C --> C2[精度恢复微调<br>Fine-tuning]:::error

    B1 --> D[精度损失: <0.5%<br>速度提升: 1.5-2x<br>体积减少: 50%]:::primary
    B2a --> E[精度损失: <1%<br>速度提升: 2-3x<br>体积减少: 75%]:::primary
    B2b --> F[精度损失: 1-3%<br>速度提升: 2-4x<br>体积减少: 75%]:::warning
    C1 --> G[精度损失: <0.5%<br>速度提升: 2-4x<br>体积减少: 75%]:::info

2.3 FP16量化详解

FP16（半精度浮点）量化是最"温和"的量化方式：

FP16量化的核心优势：

• 无需校准数据：直接截断，不需要统计激活值分布
• 精度损失极小：对于大多数模型，精度下降<0.5%
• 硬件原生支持：现代ARM CPU和NPU都有FP16计算单元
• 实现简单：只需在Context中开启FP16开关

2.4 INT8量化详解

INT8量化是端侧推理的"黄金标准"，但实现复杂度远高于FP16：

对称量化（Symmetric Quantization）：

量化：q = round(r / S)
反量化：r = q * S
S = max(|r_max|, |r_min|) / 127
Z = 0

特点：零点固定为0，计算简单
适用：权重量化（权重通常近似对称分布）

非对称量化（Asymmetric Quantization）：

量化：q = round(r / S + Z)
反量化：r = (q - Z) * S
S = (r_max - r_min) / 255
Z = round(-r_min / S)

特点：零点可调，更精确地表示非对称分布
适用：激活值量化（如ReLU后全为正值）

2.5 校准策略

INT8静态量化的关键是确定每个Tensor的量化参数（S和Z），这需要通过校准（Calibration） 来完成：

1. MinMax校准：直接取激活值的最大最小值

   • 优点：简单快速
   • 缺点：对异常值敏感

2. Percentile校准：取激活值的百分位数范围

   • 优点：抗异常值
   • 缺点：需要选择合适的百分位

3. Entropy校准（KL散度）：最小化量化前后分布的KL散度

   • 优点：精度保持最好
   • 缺点：计算量大

4. ACIQ校准：假设激活值服从特定分布，解析求解最优阈值

   • 优点：无需迭代
   • 缺点：分布假设可能不成立

2.6 精度评估指标

量化后需要评估精度损失，常用指标：

• Top-1/Top-5准确率（分类任务）
• mAP（目标检测任务）
• mIoU（语义分割任务）
• 余弦相似度（逐层对比量化前后输出）
• 信噪比PSNR（图像生成任务）

三、代码实战

3.1 量化精度评估器：对比FP32/FP16/INT8的精度差异

这个工具可以帮助你量化评估不同量化策略对模型精度的影响：

// QuantizationEvaluator.ets
// 功能：量化精度评估器 - 对比不同量化策略的精度与性能

import { mindsporeLite } from '@kit.MindSporeLiteKit';
import { fileIo } from '@kit.CoreFileKit';
import { common } from '@kit.AbilityKit';

/**
 * 量化评估结果
 */
interface QuantEvalResult {
  /** 量化类型 */
  quantType: string;
  /** 模型文件大小（KB） */
  modelSizeKB: number;
  /** 平均推理时间（ms） */
  avgInferTime: number;
  /** 与FP32输出的余弦相似度 */
  cosineSimilarity: number;
  /** 与FP32输出的最大绝对误差 */
  maxAbsError: number;
  /** 与FP32输出的平均绝对误差 */
  meanAbsError: number;
  /** 信噪比（dB） */
  snrDB: number;
}

/**
 * 量化精度评估器
 */
export class QuantizationEvaluator {
  private context: common.Context;

  constructor(context: common.Context) {
    this.context = context;
  }

  /**
   * 加载模型并获取推理输出
   * @param modelPath 模型路径
   * @param enableFP16 是否启用FP16
   * @param inputData 输入数据
   */
  private async inferModel(
    modelPath: string,
    enableFP16: boolean,
    inputData: Float32Array
  ): Promise<Float32Array | null> {
    try {
      const msContext = new mindsporeLite.Context();
      const cpu = new mindsporeLite.CpuDevice();
      cpu.isEnableFloat16 = enableFP16;
      cpu.threadNum = 4;
      msContext.addDevice(cpu);

      const model = new mindsporeLite.Model();
      const buffer = fileIo.readFileSync(modelPath);
      const result = model.build(buffer.buffer, msContext);

      if (result !== mindsporeLite.CompileRetCode.COMPILE_SUCCESS) {
        console.error(`[QuantEval] 模型编译失败: ${modelPath}`);
        return null;
      }

      const inputs = model.getInputs();
      inputs[0].setData(inputData.buffer);

      const start = Date.now();
      model.predict(inputs);
      const inferTime = Date.now() - start;

      const outputs = model.getOutputs();
      const outputData = new Float32Array(outputs[0].getData().slice(0));

      model.free();

      console.info(`[QuantEval] ${modelPath} 推理完成，耗时${inferTime}ms`);
      return outputData;
    } catch (error) {
      console.error(`[QuantEval] 推理失败: ${JSON.stringify(error)}`);
      return null;
    }
  }

  /**
   * 计算余弦相似度
   */
  cosineSimilarity(a: Float32Array, b: Float32Array): number {
    if (a.length !== b.length) {
      return 0;
    }

    let dotProduct = 0;
    let normA = 0;
    let normB = 0;

    for (let i = 0; i < a.length; i++) {
      dotProduct += a[i] * b[i];
      normA += a[i] * a[i];
      normB += b[i] * b[i];
    }

    const denominator = Math.sqrt(normA) * Math.sqrt(normB);
    return denominator === 0 ? 0 : dotProduct / denominator;
  }

  /**
   * 计算最大绝对误差
   */
  maxAbsoluteError(a: Float32Array, b: Float32Array): number {
    let maxError = 0;
    for (let i = 0; i < Math.min(a.length, b.length); i++) {
      maxError = Math.max(maxError, Math.abs(a[i] - b[i]));
    }
    return maxError;
  }

  /**
   * 计算平均绝对误差
   */
  meanAbsoluteError(a: Float32Array, b: Float32Array): number {
    let sumError = 0;
    const len = Math.min(a.length, b.length);
    for (let i = 0; i < len; i++) {
      sumError += Math.abs(a[i] - b[i]);
    }
    return sumError / len;
  }

  /**
   * 计算信噪比（SNR）
   */
  signalToNoiseRatio(reference: Float32Array, quantized: Float32Array): number {
    let signalPower = 0;
    let noisePower = 0;

    for (let i = 0; i < Math.min(reference.length, quantized.length); i++) {
      signalPower += reference[i] * reference[i];
      const noise = reference[i] - quantized[i];
      noisePower += noise * noise;
    }

    if (noisePower === 0) return Infinity;
    return 10 * Math.log10(signalPower / noisePower);
  }

  /**
   * 获取模型文件大小
   */
  private getModelSizeKB(modelPath: string): number {
    try {
      const stat = fileIo.statSync(modelPath);
      return Math.round(stat.size / 1024);
    } catch (e) {
      return 0;
    }
  }

  /**
   * 执行完整的量化评估
   * @param fp32ModelPath FP32模型路径（基准）
   * @param fp16ModelPath FP16模型路径
   * @param int8ModelPath INT8模型路径
   * @param inputData 测试输入数据
   */
  async evaluate(
    fp32ModelPath: string,
    fp16ModelPath: string,
    int8ModelPath: string,
    inputData: Float32Array
  ): Promise<QuantEvalResult[]> {
    const results: QuantEvalResult[] = [];

    // 获取FP32基准输出
    const fp32Output = await this.inferModel(fp32ModelPath, false, inputData);
    if (!fp32Output) {
      console.error('[QuantEval] FP32基准推理失败');
      return results;
    }

    // 评估FP32（基准）
    results.push({
      quantType: 'FP32（基准）',
      modelSizeKB: this.getModelSizeKB(fp32ModelPath),
      avgInferTime: 0, // 需要多轮测试
      cosineSimilarity: 1.0,
      maxAbsError: 0,
      meanAbsError: 0,
      snrDB: Infinity
    });

    // 评估FP16
    const fp16Output = await this.inferModel(fp16ModelPath, true, inputData);
    if (fp16Output) {
      results.push({
        quantType: 'FP16',
        modelSizeKB: this.getModelSizeKB(fp16ModelPath),
        avgInferTime: 0,
        cosineSimilarity: this.cosineSimilarity(fp32Output, fp16Output),
        maxAbsError: this.maxAbsoluteError(fp32Output, fp16Output),
        meanAbsError: this.meanAbsoluteError(fp32Output, fp16Output),
        snrDB: this.signalToNoiseRatio(fp32Output, fp16Output)
      });
    }

    // 评估INT8
    const int8Output = await this.inferModel(int8ModelPath, true, inputData);
    if (int8Output) {
      results.push({
        quantType: 'INT8',
        modelSizeKB: this.getModelSizeKB(int8ModelPath),
        avgInferTime: 0,
        cosineSimilarity: this.cosineSimilarity(fp32Output, int8Output),
        maxAbsError: this.maxAbsoluteError(fp32Output, int8Output),
        meanAbsError: this.meanAbsoluteError(fp32Output, int8Output),
        snrDB: this.signalToNoiseRatio(fp32Output, int8Output)
      });
    }

    // 打印对比结果
    console.info('[QuantEval] ===== 量化精度评估结果 =====');
    for (const r of results) {
      console.info(
        `  ${r.quantType}: 大小${r.modelSizeKB}KB, ` +
        `余弦相似度${r.cosineSimilarity.toFixed(6)}, ` +
        `最大误差${r.maxAbsError.toFixed(6)}, ` +
        `SNR ${r.snrDB === Infinity ? '∞' : r.snrDB.toFixed(2)}dB`
      );
    }

    return results;
  }

  /**
   * 逐层精度分析
   * 对比量化前后每一层的输出差异，定位精度损失最大的层
   */
  analyzeLayerWise(
    fp32LayerOutputs: Map<string, Float32Array>,
    quantLayerOutputs: Map<string, Float32Array>
  ): Map<string, { cosineSim: number; maxError: number; snr: number }> {
    const analysis = new Map<string, { cosineSim: number; maxError: number; snr: number }>();

    for (const [layerName, fp32Output] of fp32LayerOutputs) {
      const quantOutput = quantLayerOutputs.get(layerName);
      if (!quantOutput) continue;

      analysis.set(layerName, {
        cosineSim: this.cosineSimilarity(fp32Output, quantOutput),
        maxError: this.maxAbsoluteError(fp32Output, quantOutput),
        snr: this.signalToNoiseRatio(fp32Output, quantOutput)
      });
    }

    // 按精度损失排序（余弦相似度最低的排前面）
    const sorted = new Map(
      [...analysis.entries()].sort((a, b) => a[1].cosineSim - b[1].cosineSim)
    );

    console.info('[QuantEval] ===== 逐层精度分析（按损失排序） =====');
    let count = 0;
    for (const [layer, metrics] of sorted) {
      if (count >= 10) break; // 只打印损失最大的10层
      console.info(
        `  ${layer}: 余弦相似度${metrics.cosineSim.toFixed(6)}, ` +
        `最大误差${metrics.maxError.toFixed(6)}, ` +
        `SNR ${metrics.snr.toFixed(2)}dB`
      );
      count++;
    }

    return sorted;
  }
}

3.2 INT8量化校准工具：在端侧完成校准数据采集与量化参数计算

// Int8Calibrator.ets
// 功能：INT8量化校准工具 - 端侧校准数据采集与量化参数计算

import { fileIo } from '@kit.CoreFileKit';
import { common } from '@kit.AbilityKit';

/**
 * 量化参数
 */
interface QuantParams {
  /** 缩放因子 */
  scale: number;
  /** 零点 */
  zeroPoint: number;
  /** 最小值 */
  minValue: number;
  /** 最大值 */
  maxValue: number;
}

/**
 * Tensor统计信息
 */
interface TensorStats {
  /** Tensor名称 */
  name: string;
  /** 观测到的最小值 */
  observedMin: number;
  /** 观测到的最大值 */
  observedMax: number;
  /** 所有观测值的绝对最大值 */
  absMax: number;
  /** 均值 */
  mean: number;
  /** 标准差 */
  std: number;
  /** 观测次数 */
  observationCount: number;
  /** 百分位值 */
  percentiles: Map<number, number>;
}

/**
 * INT8量化校准器
 * 功能：采集激活值统计信息，计算最优量化参数
 */
export class Int8Calibrator {
  private tensorStats: Map<string, TensorStats> = new Map();
  private calibrationData: Float32Array[] = [];
  private context: common.Context;

  constructor(context: common.Context) {
    this.context = context;
  }

  /**
   * 添加校准数据
   * @param data 一组校准输入数据
   */
  addCalibrationData(data: Float32Array): void {
    this.calibrationData.push(data);
    console.info(`[Calibrator] 添加校准数据，当前共${this.calibrationData.length}组`);
  }

  /**
   * 从文件批量加载校准数据
   * @param dataDir 校准数据目录
   * @param maxSamples 最大样本数
   */
  loadCalibrationData(dataDir: string, maxSamples: number = 100): number {
    let loadedCount = 0;

    try {
      const files = fileIo.listFileSync(dataDir);
      for (const file of files) {
        if (loadedCount >= maxSamples) break;

        if (file.endsWith('.bin')) {
          const filePath = `${dataDir}/${file}`;
          const data = fileIo.readFileSync(filePath);
          const floatData = new Float32Array(data.buffer);
          this.calibrationData.push(floatData);
          loadedCount++;
        }
      }
    } catch (error) {
      console.error(`[Calibrator] 加载校准数据失败: ${JSON.stringify(error)}`);
    }

    console.info(`[Calibrator] 加载${loadedCount}组校准数据`);
    return loadedCount;
  }

  /**
   * 更新Tensor统计信息
   * @param tensorName Tensor名称
   * @param values 观测到的值
   */
  updateStats(tensorName: string, values: Float32Array): void {
    let stats = this.tensorStats.get(tensorName);

    if (!stats) {
      stats = {
        name: tensorName,
        observedMin: Infinity,
        observedMax: -Infinity,
        absMax: 0,
        mean: 0,
        std: 0,
        observationCount: 0,
        percentiles: new Map()
      };
      this.tensorStats.set(tensorName, stats);
    }

    // 更新最小最大值
    for (let i = 0; i < values.length; i++) {
      stats.observedMin = Math.min(stats.observedMin, values[i]);
      stats.observedMax = Math.max(stats.observedMax, values[i]);
      stats.absMax = Math.max(stats.absMax, Math.abs(values[i]));
    }

    stats.observationCount++;

    // 计算均值和标准差
    let sum = 0;
    for (let i = 0; i < values.length; i++) {
      sum += values[i];
    }
    const mean = sum / values.length;

    let variance = 0;
    for (let i = 0; i < values.length; i++) {
      variance += (values[i] - mean) * (values[i] - mean);
    }
    stats.mean = mean;
    stats.std = Math.sqrt(variance / values.length);

    // 计算百分位值
    const sorted = Array.from(values).sort((a, b) => a - b);
    stats.percentiles.set(0.1, sorted[Math.floor(sorted.length * 0.001)]);
    stats.percentiles.set(1, sorted[Math.floor(sorted.length * 0.01)]);
    stats.percentiles.set(99, sorted[Math.floor(sorted.length * 0.99)]);
    stats.percentiles.set(99.9, sorted[Math.floor(sorted.length * 0.999)]);
  }

  /**
   * 使用MinMax策略计算量化参数
   * @param tensorName Tensor名称
   */
  computeMinMaxParams(tensorName: string): QuantParams | null {
    const stats = this.tensorStats.get(tensorName);
    if (!stats) return null;

    const scale = (stats.observedMax - stats.observedMin) / 255;
    const zeroPoint = Math.round(-stats.observedMin / scale);

    return {
      scale: scale === 0 ? 1 : scale,
      zeroPoint: Math.max(0, Math.min(255, zeroPoint)),
      minValue: stats.observedMin,
      maxValue: stats.observedMax
    };
  }

  /**
   * 使用Percentile策略计算量化参数
   * @param tensorName Tensor名称
   * @param percentile 百分位（如99.9表示取99.9%分位数）
   */
  computePercentileParams(tensorName: string, percentile: number = 99.9): QuantParams | null {
    const stats = this.tensorStats.get(tensorName);
    if (!stats) return null;

    const lowerPct = (100 - percentile) / 2;
    const upperPct = 100 - lowerPct;

    const minVal = stats.percentiles.get(lowerPct) || stats.observedMin;
    const maxVal = stats.percentiles.get(upperPct) || stats.observedMax;

    const scale = (maxVal - minVal) / 255;
    const zeroPoint = Math.round(-minVal / scale);

    return {
      scale: scale === 0 ? 1 : scale,
      zeroPoint: Math.max(0, Math.min(255, zeroPoint)),
      minValue: minVal,
      maxValue: maxVal
    };
  }

  /**
   * 使用对称量化策略计算量化参数
   * @param tensorName Tensor名称
   */
  computeSymmetricParams(tensorName: string): QuantParams | null {
    const stats = this.tensorStats.get(tensorName);
    if (!stats) return null;

    const absMax = stats.absMax;
    const scale = absMax / 127;

    return {
      scale: scale === 0 ? 1 : scale,
      zeroPoint: 0, // 对称量化零点固定为0
      minValue: -absMax,
      maxValue: absMax
    };
  }

  /**
   * 模拟INT8量化效果
   * 将FP32数据按指定量化参数量化后反量化，评估精度损失
   * @param data 原始FP32数据
   * @param params 量化参数
   */
  simulateQuantization(data: Float32Array, params: QuantParams): Float32Array {
    const quantized = new Float32Array(data.length);

    for (let i = 0; i < data.length; i++) {
      // 量化
      let q = Math.round(data[i] / params.scale + params.zeroPoint);
      // 截断到[0, 255]
      q = Math.max(0, Math.min(255, q));
      // 反量化
      quantized[i] = (q - params.zeroPoint) * params.scale;
    }

    return quantized;
  }

  /**
   * 导出校准结果为JSON格式
   */
  exportCalibrationResult(): string {
    const result: Record<string, object> = {};

    for (const [tensorName, stats] of this.tensorStats) {
      const minMaxParams = this.computeMinMaxParams(tensorName);
      const percentileParams = this.computePercentileParams(tensorName);
      const symmetricParams = this.computeSymmetricParams(tensorName);

      result[tensorName] = {
        stats: {
          min: stats.observedMin,
          max: stats.observedMax,
          absMax: stats.absMax,
          mean: stats.mean,
          std: stats.std,
          observationCount: stats.observationCount
        },
        quantParams: {
          minMax: minMaxParams,
          percentile99_9: percentileParams,
          symmetric: symmetricParams
        }
      };
    }

    return JSON.stringify(result, null, 2);
  }

  /**
   * 获取所有已统计的Tensor名称
   */
  getTensorNames(): string[] {
    return Array.from(this.tensorStats.keys());
  }

  /**
   * 获取校准数据数量
   */
  getCalibrationDataCount(): number {
    return this.calibrationData.length;
  }
}

3.3 量化模型推理与精度补偿

在实际应用中集成量化模型推理，并实现精度补偿策略：

// QuantizedInferenceApp.ets
// 功能：量化模型推理应用 - 带精度补偿的INT8推理

import { mindsporeLite } from '@kit.MindSporeLiteKit';
import { fileIo } from '@kit.CoreFileKit';
import { common } from '@kit.AbilityKit';
import { Int8Calibrator, QuantParams } from './Int8Calibrator';

@Entry
@Component
struct QuantizedInferenceApp {
  @State quantType: string = 'FP32';
  @State inferTime: number = 0;
  @State modelSize: string = '';
  @State topResults: Array<{ label: string; confidence: number }> = [];
  @State accuracyCompensation: boolean = true;
  @State isRunning: boolean = false;

  private model: mindsporeLite.Model | null = null;
  private calibrator: Int8Calibrator | null = null;
  private compensationParams: Map<string, QuantParams> = new Map();

  aboutToAppear(): void {
    this.calibrator = new Int8Calibrator(this.getContext());
  }

  aboutToDisappear(): void {
    this.releaseModel();
  }

  /**
   * 加载指定量化类型的模型
   */
  async loadQuantizedModel(quantType: string): Promise<boolean> {
    this.releaseModel();

    try {
      const context = new mindsporeLite.Context();
      const cpu = new mindsporeLite.CpuDevice();

      // 根据量化类型配置
      switch (quantType) {
        case 'FP32':
          cpu.isEnableFloat16 = false;
          break;
        case 'FP16':
          cpu.isEnableFloat16 = true;
          break;
        case 'INT8':
          cpu.isEnableFloat16 = true; // INT8模型推理时仍可用FP16中间计算
          break;
      }

      cpu.threadNum = 4;
      context.addDevice(cpu);

      // 尝试NPU加速
      try {
        const npu = new mindsporeLite.NpuDevice();
        context.addDevice(npu);
      } catch (e) { /* NPU不可用 */ }

      this.model = new mindsporeLite.Model();

      // 根据量化类型选择模型文件
      const modelFileName = this.getModelFileName(quantType);
      const modelPath = this.getContext().resourceDir + `/${modelFileName}`;
      
      const buffer = fileIo.readFileSync(modelPath);
      const result = this.model.build(buffer.buffer, context);

      if (result !== mindsporeLite.CompileRetCode.COMPILE_SUCCESS) {
        console.error(`[App] 模型加载失败: ${quantType}`);
        return false;
      }

      // 更新状态
      this.quantType = quantType;
      const stat = fileIo.statSync(modelPath);
      this.modelSize = `${(stat.size / 1024).toFixed(1)} KB`;

      console.info(`[App] ${quantType}模型加载成功，大小: ${this.modelSize}`);
      return true;
    } catch (error) {
      console.error(`[App] 加载异常: ${JSON.stringify(error)}`);
      return false;
    }
  }

  /**
   * 获取模型文件名
   */
  private getModelFileName(quantType: string): string {
    switch (quantType) {
      case 'FP32': return 'mobilenetv2_fp32.ms';
      case 'FP16': return 'mobilenetv2_fp16.ms';
      case 'INT8': return 'mobilenetv2_int8.ms';
      default: return 'mobilenetv2_fp32.ms';
    }
  }

  /**
   * 执行推理（带精度补偿）
   */
  async runInference(inputData: Float32Array): Promise<Float32Array | null> {
    if (!this.model) return null;

    this.isRunning = true;

    try {
      const inputs = this.model.getInputs();
      inputs[0].setData(inputData.buffer);

      const start = Date.now();
      this.model.predict(inputs);
      this.inferTime = Date.now() - start;

      const outputs = this.model.getOutputs();
      let outputData = new Float32Array(outputs[0].getData().slice(0));

      // INT8精度补偿
      if (this.quantType === 'INT8' && this.accuracyCompensation) {
        outputData = this.applyTemperatureScaling(outputData, 1.05);
      }

      return outputData;
    } catch (error) {
      console.error(`[App] 推理失败: ${JSON.stringify(error)}`);
      return null;
    } finally {
      this.isRunning = false;
    }
  }

  /**
   * 温度缩放补偿
   * INT8量化后，输出分布可能偏"尖锐"或"平坦"
   * 通过温度缩放调整分布，恢复精度
   * @param logits 原始输出
   * @param temperature 温度系数（>1使分布更平坦，<1使分布更尖锐）
   */
  private applyTemperatureScaling(logits: Float32Array, temperature: number): Float32Array {
    const scaled = new Float32Array(logits.length);
    for (let i = 0; i < logits.length; i++) {
      scaled[i] = logits[i] / temperature;
    }
    return scaled;
  }

  /**
   * 释放模型
   */
  releaseModel(): void {
    if (this.model) {
      this.model.free();
      this.model = null;
    }
  }

  build() {
    Column() {
      // 标题
      Text('量化模型推理')
        .fontSize(24)
        .fontWeight(FontWeight.Bold)
        .margin({ top: 20, bottom: 16 })

      // 量化类型选择
      Row() {
        ForEach(['FP32', 'FP16', 'INT8'], (type: string) => {
          Button(type)
            .height(36)
            .fontSize(14)
            .backgroundColor(this.quantType === type ? '#4A90D9' : '#E0E0E0')
            .fontColor(this.quantType === type ? '#FFFFFF' : '#333333')
            .borderRadius(18)
            .margin({ left: 8, right: 8 })
            .onClick(() => this.loadQuantizedModel(type))
        })
      }
      .margin({ bottom: 16 })

      // 模型信息
      Row() {
        Text(`量化类型: ${this.quantType}`)
          .fontSize(14)
          .layoutWeight(1)
        Text(`模型大小: ${this.modelSize}`)
          .fontSize(14)
          .fontColor('#666666')
      }
      .width('90%')
      .margin({ bottom: 8 })

      if (this.inferTime > 0) {
        Text(`推理耗时: ${this.inferTime}ms`)
          .fontSize(14)
          .fontColor('#50B5A9')
          .margin({ bottom: 8 })
      }

      // INT8精度补偿开关
      if (this.quantType === 'INT8') {
        Row() {
          Text('精度补偿')
            .fontSize(14)
            .layoutWeight(1)
          Toggle({ type: ToggleType.Switch, isOn: this.accuracyCompensation })
            .onChange((isOn: boolean) => {
              this.accuracyCompensation = isOn;
            })
        }
        .width('90%')
        .padding({ left: 16, right: 16 })
        .margin({ bottom: 16 })
      }

      // 执行推理按钮
      Button('执行推理')
        .width('80%')
        .height(48)
        .fontSize(16)
        .backgroundColor('#4A90D9')
        .borderRadius(24)
        .enabled(!this.isRunning && this.model !== null)
        .onClick(async () => {
          // 生成随机测试数据
          const testInput = new Float32Array(3 * 224 * 224);
          for (let i = 0; i < testInput.length; i++) {
            testInput[i] = Math.random();
          }
          await this.runInference(testInput);
        })

      // 推理结果
      if (this.topResults.length > 0) {
        Column() {
          Text('Top-5 分类结果')
            .fontSize(16)
            .fontWeight(FontWeight.Medium)
            .margin({ bottom: 8 })

          ForEach(this.topResults, (item: { label: string; confidence: number }, index: number) => {
            Row() {
              Text(`${index + 1}. ${item.label}`)
                .fontSize(14)
                .layoutWeight(1)
              Text(`${item.confidence.toFixed(2)}%`)
                .fontSize(14)
                .fontColor('#4A90D9')
            }
            .width('100%')
            .padding({ top: 4, bottom: 4 })
          })
        }
        .width('90%')
        .padding(16)
        .backgroundColor('#F5F5F5')
        .borderRadius(12)
        .margin({ top: 16 })
      }

      // 加载指示器
      if (this.isRunning) {
        LoadingProgress()
          .width(40)
          .height(40)
          .color('#4A90D9')
          .margin({ top: 16 })
      }
    }
    .width('100%')
    .height('100%')
    .alignItems(HorizontalAlign.Center)
    .backgroundColor('#FFFFFF')
  }
}

四、踩坑与注意事项

4.1 量化后精度断崖式下降

坑位：INT8量化后，模型准确率从95%暴跌到60%。

原因：最常见的原因是校准数据不具代表性，或者某些层的激活值分布极端不对称。

解决方案：

# 方案1：增加校准数据量和多样性
# 建议至少100-500组校准数据，覆盖各种输入场景

# 方案2：使用Entropy校准策略（KL散度）
./converter --fmk=ONNX --modelFile=model.onnx --outputFile=model_int8 \
  --quantType=FullQuant --calibDataType=Entropy

# 方案3：对精度敏感的层使用混合精度
# 首层和尾层保持FP16，中间层使用INT8
./converter --fmk=ONNX --modelFile=model.onnx --outputFile=model_mixed \
  --quantType=WeightQuant --mixedPrecision=true \
  --fp16Layers="conv1,conv2" --int8Layers="conv3,conv4,conv5"

4.2 量化模型在NPU上推理结果异常

坑位：INT8模型在CPU上推理正常，在NPU上结果完全错误。

原因：NPU的INT8计算方式可能与CPU不完全一致，特别是非对称量化参数的处理。

解决方案：

// 方案1：使用对称量化（NPU对对称量化支持更好）
// 在校准时强制使用对称量化参数

// 方案2：检查NPU的量化参数对齐
// 确保量化参数（scale和zeroPoint）在NPU可表示的范围内

// 方案3：对NPU推理结果做后处理修正
function correctNpuOutput(output: Float32Array, correctionParams: QuantParams): Float32Array {
  const corrected = new Float32Array(output.length);
  for (let i = 0; i < output.length; i++) {
    // 应用修正参数
    corrected[i] = output[i] * correctionParams.scale + correctionParams.zeroPoint;
  }
  return corrected;
}

4.3 校准数据与实际数据分布不匹配

坑位：校准时用的是ImageNet数据，实际使用时是医疗影像，量化后精度很差。

原因：校准数据的分布必须与实际推理数据的分布一致，否则量化参数不准确。

解决方案：

// 方案1：使用实际场景的数据进行校准
// 收集100-500组真实使用场景的数据

// 方案2：数据增强，增加校准数据的多样性
function augmentCalibrationData(original: Float32Array): Float32Array[] {
  const augmented: Float32Array[] = [original];
  
  // 随机裁剪
  // 随机翻转
  // 颜色抖动
  // ... 数据增强逻辑
  
  return augmented;
}

// 方案3：在线校准 - 在APP运行时持续更新量化参数
// 使用EMA（指数移动平均）更新统计信息
function updateStatsEMA(
  oldMean: number,
  oldValue: number,
  newObservation: number,
  alpha: number = 0.01
): number {
  return alpha * newObservation + (1 - alpha) * oldValue;
}

4.4 FP16量化后模型体积未减半

坑位：期望FP16量化后模型体积减半，实际只减少了20%。

原因：模型文件中除了权重数据，还包含算子定义、图结构等元信息，这些部分不受量化影响。

解决方案：

模型文件组成：
├── 图结构定义（约10-20%）← 量化不影响
├── 权重数据（约70-80%）← 量化可减半
└── 其他元信息（约5-10%）← 量化不影响

实际体积减少 = 权重占比 × 50%
例如：权重占75%，则总减少 = 75% × 50% = 37.5%

4.5 逐通道量化vs逐张量量化

坑位：逐张量量化精度不够，但逐通道量化在NPU上不支持。

原因：逐通道量化（per-channel）为每个输出通道独立计算量化参数，精度更高但硬件支持有限。

解决方案：

# 权重量化推荐使用逐通道量化（精度更好）
./converter --fmk=ONNX --modelFile=model.onnx --outputFile=model \
  --quantType=WeightQuant --weightQuantChannel=true

# 激活值量化只能使用逐张量量化（硬件限制）
# 如果NPU不支持逐通道，回退到逐张量

五、HarmonyOS 6适配

5.1 新增量化能力

HarmonyOS 6在模型量化方面带来了以下增强：

5.2 迁移指南

1. 混合精度量化：

// HarmonyOS 6新增：逐层指定量化精度
// 在模型转换配置文件中指定
/*
quant_config.json:
{
  "layers": {
    "conv1": {"weight": "FP16", "activation": "FP16"},
    "conv2": {"weight": "INT8", "activation": "INT8"},
    "conv3": {"weight": "INT8", "activation": "FP16"},
    "fc": {"weight": "INT8", "activation": "INT8"}
  }
}
*/

// 转换命令
// ./converter --fmk=ONNX --modelFile=model.onnx --outputFile=model_mixed \
//   --quantConfig=quant_config.json

2. 在线量化参数更新：

// HarmonyOS 6新增：运行时动态更新量化参数
// 适用于数据分布变化的场景
const model = new mindsporeLite.Model();
model.build(buffer, context);

// 运行一段时间后，根据实际数据更新量化参数
// model.updateQuantParams(tensorName, newScale, newZeroPoint);

六、总结

本文深入讲解了模型量化技术的原理、实践与精度保持策略，关键知识点回顾：

模型量化技术知识图谱
├── 量化基础
│   ├── 量化公式：q = round(r/S + Z)，r = (q-Z)*S
│   ├── 对称量化：Z=0，适用于权重
│   ├── 非对称量化：Z可调，适用于激活值
│   └── 量化类型：FP16（温和）/ INT8（标准）/ INT4（激进）
├── 量化策略
│   ├── 训练后量化（PTQ）
│   │   ├── 动态量化：运行时统计，无需校准
│   │   ├── 静态量化：离线校准，性能最优
│   │   └── 权重量化：只量化权重，激活值保持FP32
│   └── 量化感知训练（QAT）
│       ├── 模拟量化训练：插入伪量化节点
│       └── 精度恢复微调：量化后微调恢复精度
├── 校准策略
│   ├── MinMax：简单快速，对异常值敏感
│   ├── Percentile：抗异常值，需选百分位
│   ├── Entropy/KL散度：精度最好，计算量大
│   └── ACIQ：解析求解，分布假设限制
├── 精度评估
│   ├── 余弦相似度：衡量输出分布一致性
│   ├── 最大/平均绝对误差：衡量数值偏差
│   ├── 信噪比SNR：衡量量化噪声水平
│   └── 逐层分析：定位精度损失最大的层
├── 精度补偿
│   ├── 温度缩放：调整输出分布尖锐度
│   ├── 混合精度：敏感层FP16，其余INT8
│   └── 后处理修正：对量化偏差做数值修正
└── 踩坑要点
    ├── 校准数据必须与实际数据分布一致
    ├── NPU对对称量化支持更好
    ├── FP16体积减少≈权重占比×50%
    ├── 逐通道量化精度更好但NPU支持有限
    └── 精度断崖下降时检查校准数据和策略

一句话总结：模型量化是端侧AI的"必修课"——FP16是入门，INT8是标准，混合精度是进阶。记住核心原则：量化不是目的，精度保持才是。一个好的量化方案，应该在速度提升和精度损失之间找到最优平衡点，而这个平衡点需要通过充分的校准和评估来确定。