HarmonyOS开发：模型压缩与端侧部署优化

核心要点：大模型跑在小设备上，靠的就是模型压缩。本文深入讲解量化、剪枝、知识蒸馏、NAS四大压缩技术，以及在HarmonyOS设备上的端侧部署优化策略，让你的AI模型在手机上也能飞起来。

一、背景与动机

先说一个残酷的现实：你的手机内存大概8-12GB，但一个ResNet-50模型就要25MB参数，一个MobileBERT要100MB，更别提那些动辄几GB的大语言模型了。这还只是参数存储——推理时需要的激活值内存往往是参数的2-3倍。

所以问题来了：怎么把一个"臃肿"的模型塞进"苗条"的设备里，还能跑得又快又准？

答案就是模型压缩。

打个比方：模型压缩就像搬家。你原来住200平的大房子（云端GPU），现在要搬进40平的小公寓（手机NPU）。东西不能全带走，你得做取舍——不常用的扔掉（剪枝），大件换成小件（量化），贵重的请师傅教你怎么用少的工具干同样的活（知识蒸馏）。最终目标是：用最小的空间，保留最大的价值。

HarmonyOS设备种类繁多，从手表（几百KB内存）到智慧屏（几GB内存），算力差异巨大。模型压缩不是可选项，而是必选项——你需要为每种设备准备不同大小的模型，或者用一套压缩方案适配所有设备。

二、核心原理

2.1 模型压缩技术全景

模型压缩有四大主流技术，各有侧重：

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[原始大模型 FP32]:::primary --> B{压缩策略选择}:::warning
    B --> C[量化 INT8/INT4]:::info
    B --> D[结构化剪枝]:::purple
    B --> E[知识蒸馏]:::error
    B --> F[NAS搜索]:::warning

    C --> G[量化模型]:::info
    D --> H[稀疏模型]:::purple
    E --> I[蒸馏小模型]:::error
    F --> J[最优小模型]:::warning

    G --> K{端侧部署优化}:::primary
    H --> K
    I --> K
    J --> K

    K --> L[NPU加速]:::info
    K --> M[内存优化]:::purple
    K --> N[算子融合]:::warning
    K --> O[动态Batch]:::error

    L --> P[高性能端侧模型]:::primary
    M --> P
    N --> P
    O --> P

2.2 量化：精度换空间

量化是最实用、性价比最高的压缩技术。核心思想很简单：把模型参数从32位浮点数（FP32）变成8位整数（INT8），甚至4位整数（INT4）。

为什么能这么做？ 因为神经网络对参数精度并不敏感。一个权重从0.12345678变成0.12，对最终推理结果几乎没有影响。但存储空间直接缩小4倍（FP32→INT8），推理速度因为整数运算比浮点快得多，还能利用NPU的INT8加速单元。

量化的数学表达：

$$q = \text{round}\left(\frac{r}{S}\right) + Z$$

其中 $r$ 是原始浮点值，$S$ 是缩放因子（scale），$Z$ 是零点（zero point），$q$ 是量化后的整数值。反量化：

$$r = S \times (q - Z)$$

量化分两种：

• 训练后量化（PTQ）：模型训练完后直接量化，不需要重新训练。简单快速，但精度损失可能较大
• 量化感知训练（QAT）：在训练过程中模拟量化误差，让模型学会适应低精度。精度更好，但需要训练数据和算力

2.3 剪枝：删繁就简

剪枝的核心思想：不是所有参数都同等重要，不重要的可以删掉。

剪枝也分两种：

• 非结构化剪枝：删除单个权重，产生稀疏矩阵。压缩比高，但需要专门的稀疏计算硬件支持
• 结构化剪枝：删除整个通道/层，不产生稀疏矩阵。压缩比略低，但任何硬件都能加速

结构化剪枝更实用。想象你在修剪一棵树——不是随机摘几片叶子（非结构化），而是直接砍掉整根树枝（结构化）。砍完后树的形状依然规整，不需要特殊工具来处理。

2.4 知识蒸馏：名师出高徒

知识蒸馏让一个"大模型"（教师）教一个"小模型"（学生）。学生不只学习标准答案（硬标签），还学习教师的"思维方式"（软标签/温度缩放后的概率分布）。

蒸馏损失函数：

$$\mathcal{L} = \alpha \cdot \mathcal{L}_{hard}(y, y_s) + (1-\alpha) \cdot \mathcal{L}_{soft}(p_t^\tau, p_s^\tau)$$

其中 $\tau$ 是温度参数，$\alpha$ 是损失权重。温度越高，软标签越"软"（概率分布越平滑），包含的教师知识越丰富。

2.5 NAS：自动搜索最优架构

NAS（Neural Architecture Search）让算法自动搜索最优的模型架构，而不是人工设计。搜索空间包括：每层的通道数、卷积核大小、是否使用残差连接等。

在端侧场景下，NAS的目标函数需要加入延迟约束：

$$\max \text{Accuracy}(A) \quad \text{s.t.} \quad \text{Latency}(A) \leq T_{target}$$

三、代码实战

3.1 模型量化工具

在HarmonyOS设备上实现训练后量化（PTQ），将FP32模型转换为INT8模型。

// ModelQuantizer.ets
// 模型量化工具 - 支持对称量化和非对称量化

// 量化参数接口
interface QuantizationParams {
  scale: number;          // 缩放因子
  zeroPoint: number;      // 零点
  minVal: number;         // 原始值最小值
  maxVal: number;         // 原始值最大值
  bitWidth: number;       // 量化位宽（8或4）
}

// 量化结果接口
interface QuantizationResult {
  quantizedWeights: Int32Array;  // 量化后的权重
  params: QuantizationParams;    // 量化参数
  compressionRatio: number;      // 压缩比
  estimatedAccuracyLoss: number; // 预估精度损失
}

// 量化配置
interface QuantizationConfig {
  bitWidth: 8 | 4;               // 量化位宽
  method: 'symmetric' | 'asymmetric'; // 量化方法
  perChannel: boolean;            // 是否按通道量化
  calibrationSamples: number;     // 校准样本数
}

export class ModelQuantizer {
  private config: QuantizationConfig;
  private calibrationData: Float32Array[] = [];

  constructor(config: QuantizationConfig) {
    this.config = config;
  }

  // 添加校准数据（用于确定量化参数）
  addCalibrationData(data: Float32Array): void {
    this.calibrationData.push(data);
    if (this.calibrationData.length > this.config.calibrationSamples) {
      this.calibrationData.shift(); // 保持校准数据量
    }
  }

  // 对权重进行量化
  quantizeWeights(weights: Float32Array, channelSize?: number): QuantizationResult {
    if (this.config.perChannel && channelSize) {
      return this.quantizePerChannel(weights, channelSize);
    }
    return this.quantizePerTensor(weights);
  }

  // 按张量量化（整个权重矩阵共用一组参数）
  private quantizePerTensor(weights: Float32Array): QuantizationResult {
    // 第一步：确定原始值范围
    let minVal = Infinity;
    let maxVal = -Infinity;
    for (let i = 0; i < weights.length; i++) {
      minVal = Math.min(minVal, weights[i]);
      maxVal = Math.max(maxVal, weights[i]);
    }

    // 第二步：计算量化参数
    const qMin = this.config.bitWidth === 8 ? -128 : -8;
    const qMax = this.config.bitWidth === 8 ? 127 : 7;

    let scale: number;
    let zeroPoint: number;

    if (this.config.method === 'symmetric') {
      // 对称量化：零点固定为0
      const absMax = Math.max(Math.abs(minVal), Math.abs(maxVal));
      scale = absMax / qMax;
      zeroPoint = 0;
    } else {
      // 非对称量化：零点根据范围计算
      scale = (maxVal - minVal) / (qMax - qMin);
      zeroPoint = Math.round(qMin - minVal / scale);
    }

    // 防止scale为0
    scale = Math.max(scale, 1e-8);

    const params: QuantizationParams = {
      scale,
      zeroPoint,
      minVal,
      maxVal,
      bitWidth: this.config.bitWidth
    };

    // 第三步：执行量化
    const quantizedWeights = new Int32Array(weights.length);
    for (let i = 0; i < weights.length; i++) {
      let q = Math.round(weights[i] / scale) + zeroPoint;
      // 裁剪到量化范围
      q = Math.max(qMin, Math.min(qMax, q));
      quantizedWeights[i] = q;
    }

    // 第四步：计算压缩比和预估精度损失
    const compressionRatio = 32 / this.config.bitWidth;
    const accuracyLoss = this.estimateAccuracyLoss(weights, quantizedWeights, params);

    return {
      quantizedWeights,
      params,
      compressionRatio,
      estimatedAccuracyLoss: accuracyLoss
    };
  }

  // 按通道量化（每个通道独立量化参数）
  private quantizePerChannel(weights: Float32Array, channelSize: number): QuantizationResult {
    const numChannels = weights.length / channelSize;
    const quantizedWeights = new Int32Array(weights.length);
    const scales: number[] = [];
    const zeroPoints: number[] = [];

    for (let ch = 0; ch < numChannels; ch++) {
      // 提取当前通道的权重
      const channelWeights = weights.slice(ch * channelSize, (ch + 1) * channelSize);

      // 对当前通道进行量化
      const channelResult = this.quantizePerTensor(channelWeights);

      // 存储量化结果
      quantizedWeights.set(channelResult.quantizedWeights, ch * channelSize);
      scales.push(channelResult.params.scale);
      zeroPoints.push(channelResult.params.zeroPoint);
    }

    // 使用第一个通道的参数作为代表（简化）
    const representativeParams: QuantizationParams = {
      scale: scales[0],
      zeroPoint: zeroPoints[0],
      minVal: 0,
      maxVal: 0,
      bitWidth: this.config.bitWidth
    };

    return {
      quantizedWeights,
      params: representativeParams,
      compressionRatio: 32 / this.config.bitWidth,
      estimatedAccuracyLoss: 0.01 // 按通道量化通常精度损失更小
    };
  }

  // 反量化（将量化值转回浮点值）
  dequantize(quantizedWeights: Int32Array, params: QuantizationParams): Float32Array {
    const floatWeights = new Float32Array(quantizedWeights.length);
    for (let i = 0; i < quantizedWeights.length; i++) {
      floatWeights[i] = params.scale * (quantizedWeights[i] - params.zeroPoint);
    }
    return floatWeights;
  }

  // 预估量化精度损失（通过反量化后的MSE）
  private estimateAccuracyLoss(original: Float32Array, quantized: Int32Array,
    params: QuantizationParams): number {
    let mse = 0;
    let maxAbs = 0;
    for (let i = 0; i < original.length; i++) {
      const deq = params.scale * (quantized[i] - params.zeroPoint);
      const diff = original[i] - deq;
      mse += diff * diff;
      maxAbs = Math.max(maxAbs, Math.abs(original[i]));
    }
    mse /= original.length;

    // 归一化MSE作为精度损失的近似
    const nmse = maxAbs > 0 ? mse / (maxAbs * maxAbs) : 0;
    return Math.min(1, nmse * 100); // 放大以便观察
  }

  // 校准量化参数（使用校准数据优化量化范围）
  calibrate(): void {
    if (this.calibrationData.length === 0) {
      console.warn('[Quantizer] 无校准数据，将使用默认量化参数');
      return;
    }

    // 合并所有校准数据，统计激活值分布
    let allActivations: number[] = [];
    for (const data of this.calibrationData) {
      for (let i = 0; i < data.length; i++) {
        allActivations.push(data[i]);
      }
    }

    // 使用百分位法确定量化范围（去除极端值）
    allActivations.sort((a, b) => a - b);
    const lowerPercentile = 0.01; // 去掉最低1%
    const upperPercentile = 0.99; // 去掉最高1%
    const lowerIdx = Math.floor(allActivations.length * lowerPercentile);
    const upperIdx = Math.floor(allActivations.length * upperPercentile);

    const calibratedMin = allActivations[lowerIdx];
    const calibratedMax = allActivations[upperIdx];

    console.info(`[Quantizer] 校准完成，范围: [${calibratedMin.toFixed(4)}, ${calibratedMax.toFixed(4)}]`);
  }
}

3.2 模型剪枝工具

实现结构化通道剪枝，按重要性评分移除不重要的通道。

// ModelPruner.ets
// 模型剪枝工具 - 结构化通道剪枝

// 剪枝配置接口
interface PruningConfig {
  targetSparsity: number;     // 目标稀疏度（0-1，0.5表示剪掉50%通道）
  pruningMethod: 'l1' | 'l2' | 'geometric_median'; // 重要性评估方法
  minimumChannels: number;    // 每层最少保留通道数
  fineTuneEpochs: number;     // 微调轮数
}

// 通道重要性评分
interface ChannelImportance {
  channelIndex: number;
  score: number;               // 重要性分数（越高越重要）
  l1Norm: number;              // L1范数
  l2Norm: number;              // L2范数
  meanActivation: number;      // 平均激活值
}

// 剪枝结果
interface PruningResult {
  prunedWeights: Float32Array;  // 剪枝后的权重
  prunedChannels: number[];     // 被剪掉的通道索引
  remainingChannels: number[];  // 保留的通道索引
  actualSparsity: number;       // 实际稀疏度
  paramsReduction: number;      // 参数减少比例
}

export class ModelPruner {
  private config: PruningConfig;

  constructor(config: PruningConfig) {
    this.config = config;
  }

  // 对卷积层进行通道剪枝
  pruneConvLayer(weights: Float32Array, inputChannels: number,
    outputChannels: number, kernelSize: number): PruningResult {
    // 计算每个输出通道的重要性
    const importance = this.evaluateChannelImportance(
      weights, inputChannels, outputChannels, kernelSize
    );

    // 按重要性排序
    const sorted = [...importance].sort((a, b) => b.score - a.score);

    // 确定保留的通道数
    const keepCount = Math.max(
      this.config.minimumChannels,
      Math.ceil(outputChannels * (1 - this.config.targetSparsity))
    );

    const remainingIndices = sorted.slice(0, keepCount).map(c => c.channelIndex);
    const prunedIndices = sorted.slice(keepCount).map(c => c.channelIndex);

    // 构建剪枝后的权重
    const kernelElements = inputChannels * kernelSize * kernelSize;
    const newWeights = new Float32Array(keepCount * kernelElements);
    let newIdx = 0;

    for (const chIdx of remainingIndices) {
      const srcStart = chIdx * kernelElements;
      const srcEnd = srcStart + kernelElements;
      newWeights.set(weights.slice(srcStart, srcEnd), newIdx * kernelElements);
      newIdx++;
    }

    const actualSparsity = prunedIndices.length / outputChannels;
    const paramsReduction = prunedIndices.length / outputChannels;

    console.info(`[Pruner] 通道剪枝: ${outputChannels}→${keepCount}, ` +
      `稀疏度: ${(actualSparsity * 100).toFixed(1)}%`);

    return {
      prunedWeights: newWeights,
      prunedChannels: prunedIndices,
      remainingChannels: remainingIndices,
      actualSparsity,
      paramsReduction
    };
  }

  // 评估通道重要性
  private evaluateChannelImportance(weights: Float32Array, inputChannels: number,
    outputChannels: number, kernelSize: number): ChannelImportance[] {
    const kernelElements = inputChannels * kernelSize * kernelSize;
    const importance: ChannelImportance[] = [];

    for (let ch = 0; ch < outputChannels; ch++) {
      const channelWeights = weights.slice(ch * kernelElements, (ch + 1) * kernelElements);

      // 计算L1范数
      let l1Norm = 0;
      let l2NormSq = 0;
      let sum = 0;
      for (let i = 0; i < channelWeights.length; i++) {
        l1Norm += Math.abs(channelWeights[i]);
        l2NormSq += channelWeights[i] * channelWeights[i];
        sum += channelWeights[i];
      }
      const l2Norm = Math.sqrt(l2NormSq);
      const meanActivation = sum / channelWeights.length;

      // 综合重要性评分
      let score: number;
      switch (this.config.pruningMethod) {
        case 'l1':
          score = l1Norm;
          break;
        case 'l2':
          score = l2Norm;
          break;
        case 'geometric_median':
          // 几何中位数法：与中位数的距离越远越重要
          score = l1Norm; // 简化实现
          break;
        default:
          score = l1Norm;
      }

      importance.push({
        channelIndex: ch,
        score,
        l1Norm,
        l2Norm,
        meanActivation
      });
    }

    return importance;
  }

  // 渐进式剪枝 - 逐步增加稀疏度
  progressivePruning(weights: Float32Array, inputChannels: number,
    outputChannels: number, kernelSize: number, steps: number = 5): PruningResult {
    let currentWeights = weights;
    let currentOutputChannels = outputChannels;
    let allPrunedChannels: number[] = [];

    for (let step = 0; step < steps; step++) {
      // 每步剪掉目标稀疏度的一部分
      const stepSparsity = this.config.targetSparsity / steps;
      const stepConfig: PruningConfig = {
        ...this.config,
        targetSparsity: stepSparsity
      };

      const stepPruner = new ModelPruner(stepConfig);
      const result = stepPruner.pruneConvLayer(
        currentWeights, inputChannels, currentOutputChannels, kernelSize
      );

      currentWeights = result.prunedWeights;
      currentOutputChannels -= result.prunedChannels.length;
      allPrunedChannels = allPrunedChannels.concat(result.prunedChannels);

      console.info(`[Pruner] 渐进剪枝步骤 ${step + 1}/${steps}, ` +
        `剩余通道: ${currentOutputChannels}`);
    }

    return {
      prunedWeights: currentWeights,
      prunedChannels: allPrunedChannels,
      remainingChannels: Array.from({ length: currentOutputChannels }, (_, i) => i),
      actualSparsity: allPrunedChannels.length / outputChannels,
      paramsReduction: allPrunedChannels.length / outputChannels
    };
  }

  // 生成剪枝掩码（用于稀疏推理）
  generatePruningMask(outputChannels: number,
    prunedChannels: number[]): Float32Array {
    const mask = new Float32Array(outputChannels);
    mask.fill(1.0); // 默认全部保留
    for (const ch of prunedChannels) {
      mask[ch] = 0.0; // 被剪掉的通道置0
    }
    return mask;
  }
}

3.3 端侧模型部署管理器

将压缩后的模型部署到HarmonyOS设备上，支持模型加载、推理和动态切换。

// EdgeModelDeployer.ets
// 端侧模型部署管理器 - 模型加载、推理与动态切换

import { fileIo } from '@kit.CoreFileKit';
import { resourceManager } from '@kit.LocalizationKit';

// 模型元数据接口
interface ModelMetadata {
  name: string;                 // 模型名称
  version: string;              // 版本号
  inputShape: number[];         // 输入形状 [batch, channels, height, width]
  outputShape: number[];        // 输出形状
  quantization: string;         // 量化类型：fp32/int8/int4
  fileSize: number;             // 文件大小（字节）
  targetDevice: string;         // 目标设备类型
  accuracy: number;             // 精度指标
  avgLatency: number;           // 平均推理延迟（毫秒）
}

// 模型实例接口
interface ModelInstance {
  metadata: ModelMetadata;
  weights: Float32Array | Int32Array;
  isLoaded: boolean;
  lastUsed: number;
}

// 部署配置
interface DeployConfig {
  maxMemoryMB: number;          // 最大内存占用（MB）
  preferQuantized: boolean;     // 优先使用量化模型
  enableAutoSwitch: boolean;    // 启用自动模型切换
  cacheSize: number;            // 模型缓存数量
}

export class EdgeModelDeployer {
  private config: DeployConfig;
  private loadedModels: Map<string, ModelInstance> = new Map();
  private modelRegistry: Map<string, ModelMetadata> = new Map();
  private currentModel: string = '';

  constructor(config: DeployConfig) {
    this.config = config;
  }

  // 注册模型到部署仓库
  registerModel(metadata: ModelMetadata): void {
    this.modelRegistry.set(metadata.name, metadata);
    console.info(`[Deployer] 注册模型: ${metadata.name} ` +
      `(${metadata.quantization}, ${(metadata.fileSize / 1024 / 1024).toFixed(1)}MB)`);
  }

  // 加载模型到内存
  async loadModel(modelName: string): Promise<boolean> {
    const metadata = this.modelRegistry.get(modelName);
    if (!metadata) {
      console.error(`[Deployer] 模型未注册: ${modelName}`);
      return false;
    }

    // 检查内存是否足够
    const estimatedMemMB = metadata.fileSize / 1024 / 1024 * 3; // 权重+激活+临时
    if (estimatedMemMB > this.config.maxMemoryMB) {
      console.error(`[Deployer] 内存不足: 需要${estimatedMemMB.toFixed(0)}MB, ` +
        `上限${this.config.maxMemoryMB}MB`);
      return false;
    }

    // 如果缓存已满，卸载最久未使用的模型
    if (this.loadedModels.size >= this.config.cacheSize) {
      this.evictLeastRecentlyUsed();
    }

    try {
      // 模拟模型加载（实际项目中使用MindSpore Lite加载.ms模型）
      const weights = new Float32Array(metadata.fileSize / 4);
      // 初始化为随机值（实际应从文件加载）
      for (let i = 0; i < weights.length; i++) {
        weights[i] = (Math.random() - 0.5) * 0.1;
      }

      const instance: ModelInstance = {
        metadata,
        weights,
        isLoaded: true,
        lastUsed: Date.now()
      };

      this.loadedModels.set(modelName, instance);
      this.currentModel = modelName;
      console.info(`[Deployer] 模型加载成功: ${modelName}`);
      return true;
    } catch (error) {
      console.error(`[Deployer] 模型加载失败: ${error}`);
      return false;
    }
  }

  // 卸载模型释放内存
  unloadModel(modelName: string): void {
    const instance = this.loadedModels.get(modelName);
    if (instance) {
      instance.isLoaded = false;
      this.loadedModels.delete(modelName);
      console.info(`[Deployer] 模型已卸载: ${modelName}`);
    }
  }

  // 执行推理
  async predict(input: Float32Array): Promise<Float32Array> {
    const instance = this.loadedModels.get(this.currentModel);
    if (!instance || !instance.isLoaded) {
      throw new Error(`[Deployer] 当前模型未加载: ${this.currentModel}`);
    }

    instance.lastUsed = Date.now();
    const startTime = Date.now();

    // 模拟推理过程
    const metadata = instance.metadata;
    const outputSize = metadata.outputShape.reduce((a, b) => a * b, 1);
    const output = new Float32Array(outputSize);

    // 简单的模拟推理：全连接层
    const inputSize = metadata.inputShape.reduce((a, b) => a * b, 1);
    for (let i = 0; i < outputSize; i++) {
      let sum = 0;
      for (let j = 0; j < Math.min(inputSize, input.length); j++) {
        const weightIdx = i * inputSize + j;
        if (weightIdx < instance.weights.length) {
          sum += input[j] * instance.weights[weightIdx];
        }
      }
      output[i] = 1 / (1 + Math.exp(-sum)); // sigmoid
    }

    const latency = Date.now() - startTime;
    console.info(`[Deployer] 推理完成, 延迟: ${latency}ms, 模型: ${this.currentModel}`);

    return output;
  }

  // 自动选择最优模型
  selectOptimalModel(taskComplexity: number, latencyBudget: number): string {
    let bestModel = '';
    let bestScore = -Infinity;

    for (const [name, metadata] of this.modelRegistry) {
      // 评分 = 精度权重 - 延迟惩罚 - 大小惩罚
      const accuracyScore = metadata.accuracy * 0.5;
      const latencyPenalty = (metadata.avgLatency / latencyBudget) * 0.3;
      const sizePenalty = (metadata.fileSize / this.config.maxMemoryMB / 1024 / 1024) * 0.2;
      const score = accuracyScore - latencyPenalty - sizePenalty;

      if (score > bestScore) {
        bestScore = score;
        bestModel = name;
      }
    }

    console.info(`[Deployer] 自动选择模型: ${bestModel} (得分: ${bestScore.toFixed(3)})`);
    return bestModel;
  }

  // 淘汰最久未使用的模型
  private evictLeastRecentlyUsed(): void {
    let oldestKey = '';
    let oldestTime = Infinity;

    for (const [key, instance] of this.loadedModels) {
      if (instance.lastUsed < oldestTime) {
        oldestTime = instance.lastUsed;
        oldestKey = key;
      }
    }

    if (oldestKey) {
      this.unloadModel(oldestKey);
      console.info(`[Deployer] LRU淘汰模型: ${oldestKey}`);
    }
  }

  // 获取当前模型信息
  getCurrentModelInfo(): ModelMetadata | null {
    const instance = this.loadedModels.get(this.currentModel);
    return instance ? instance.metadata : null;
  }

  // 获取内存使用情况
  getMemoryUsage(): { usedMB: number; maxMB: number; usagePercent: number } {
    let usedBytes = 0;
    for (const instance of this.loadedModels.values()) {
      usedBytes += instance.metadata.fileSize;
    }
    const usedMB = usedBytes / 1024 / 1024;
    return {
      usedMB,
      maxMB: this.config.maxMemoryMB,
      usagePercent: (usedMB / this.config.maxMemoryMB) * 100
    };
  }

  // 获取所有已注册模型列表
  getRegisteredModels(): ModelMetadata[] {
    return Array.from(this.modelRegistry.values());
  }
}

四、踩坑与注意事项

坑1：INT8量化后精度断崖式下降

问题：某些层对量化特别敏感（如注意力机制的Softmax层、第一层卷积、最后一层全连接），直接INT8量化可能导致精度掉10%以上。

解决方案：

• 混合精度量化：敏感层保持FP16/FP32，非敏感层用INT8。通常只有5-10%的层需要保持高精度
• 量化感知训练（QAT）：在训练时模拟量化误差，让模型学会适应
• 逐通道量化：每个通道独立计算scale和zeroPoint，比逐张量量化精度好得多

// 混合精度量化策略
class MixedPrecisionQuantizer {
  // 敏感层列表（保持FP16）
  private sensitiveLayers: Set<string> = new Set([
    'attention_softmax',
    'first_conv',
    'last_fc',
    'layer_norm'
  ]);

  quantizeLayer(layerName: string, weights: Float32Array): QuantizationResult {
    if (this.sensitiveLayers.has(layerName)) {
      // 敏感层：使用FP16（半精度）
      return this.quantizeFP16(weights);
    } else {
      // 非敏感层：使用INT8
      return this.quantizeINT8(weights);
    }
  }

  private quantizeFP16(weights: Float32Array): QuantizationResult {
    // FP16量化：将32位浮点转为16位浮点
    // 压缩比2x，精度损失极小
    return {
      quantizedWeights: new Int32Array(0), // 简化
      params: { scale: 1, zeroPoint: 0, minVal: 0, maxVal: 0, bitWidth: 16 },
      compressionRatio: 2,
      estimatedAccuracyLoss: 0.001
    };
  }

  private quantizeINT8(weights: Float32Array): QuantizationResult {
    // INT8量化实现...
    const quantizer = new ModelQuantizer({
      bitWidth: 8,
      method: 'asymmetric',
      perChannel: true,
      calibrationSamples: 100
    });
    return quantizer.quantizeWeights(weights);
  }
}

坑2：剪枝后模型无法直接加速

问题：非结构化剪枝产生稀疏矩阵，但大多数推理框架和NPU不支持稀疏计算。剪掉了50%的参数，推理速度几乎没变——因为0也要参与计算。

解决方案：使用结构化剪枝（整通道/整层剪掉），或者使用专门的稀疏推理引擎。HarmonyOS的MindSpore Lite支持4:2结构化稀疏。

坑3：知识蒸馏教师模型选择不当

问题：教师模型太大（如GPT-4级别），推理成本高，蒸馏过程本身就变成了性能瓶颈。或者教师和学生架构差异太大，知识难以迁移。

解决方案：

• 选择与学生同架构但更深的教师（如ResNet-101教ResNet-18）
• 使用特征级蒸馏而不仅是输出级蒸馏
• 多教师蒸馏：多个小教师投票，比一个大教师更稳定

坑4：模型文件加载慢

问题：一个100MB的模型文件，从设备存储加载到内存需要1-2秒，用户等不了。

解决方案：

• 模型分片加载：先加载关键层，后续层后台异步加载
• 内存映射（mmap）：不复制文件到内存，直接映射访问
• 模型预热：APP启动时在后台预加载模型

坑5：不同设备需要不同大小的模型

问题：手表、手机、平板算力差异巨大，一个模型无法适配所有设备。

解决方案：使用once-for-all（OFA）技术，训练一个"超网"，从中抽取不同大小的子网络适配不同设备，无需重新训练。

五、HarmonyOS 6适配

5.1 API差异

5.2 迁移指南

// HarmonyOS 5.0 - MindSpore Lite
import mindSpore from '@ohos.ai.mindSpore';
const context = await mindSpore.createContext();
const model = await mindSpore.createModel('/data/models/resnet50.ms');

// HarmonyOS 6 - 统一推理引擎
import { inferenceEngine } from '@kit.AiKit';

// 自动选择最优量化配置
const model = await inferenceEngine.loadModel({
  uri: '/data/models/resnet50.ms',
  accelerator: inferenceEngine.Accelerator.AUTO, // 自动选择NPU/GPU/CPU
  precision: inferenceEngine.Precision.MIXED,    // 混合精度
  optimization: {
    enableQuantization: true,       // 启用量化
    quantizationLevel: 'auto',      // 自动选择量化级别
    enableSparsity: true,           // 启用稀疏推理
    enableOperatorFusion: true,     // 启用算子融合
    memoryBudget: 256               // 内存预算256MB
  }
});

5.3 HarmonyOS 6新增特性

• 自适应量化：系统根据设备NPU能力自动选择最优量化方案（INT8/INT4/混合精度）
• 模型瘦身SDK：@kit.AiKit内置模型压缩工具链，无需外部依赖
• 动态模型切换：运行时根据设备状态（温度/电量）自动切换不同大小的模型
• 模型分片加载：大模型自动分片，首屏推理延迟降低70%
• 端侧NAS：在设备上运行轻量级NAS搜索，为当前设备定制最优模型架构

六、总结

模型压缩不是一锤子买卖，而是一个持续优化的过程。量化、剪枝、蒸馏可以组合使用——先蒸馏得到小模型，再剪枝去掉冗余通道，最后量化降低精度。三管齐下，一个100MB的FP32模型可以压缩到5MB的INT8模型，精度损失控制在2%以内。

但记住，压缩的终极目标不是"越小越好"，而是"够用就好"。一个0.5MB但精度只有60%的模型，远不如一个5MB精度95%的模型有用。在HarmonyOS的多样化设备生态中，你需要为每种设备找到"精度-速度-大小"的最佳平衡点。HarmonyOS 6的自适应量化和动态模型切换，正是帮你自动找到这个平衡点的利器。