HarmonyOS开发：MindSpore Lite端侧AI推理框架全解析

核心要点：MindSpore Lite是华为面向端侧AI推理的轻量级框架，支持模型转换、推理调度、硬件加速全链路能力。本文从框架架构、模型加载、推理执行到性能调优，全方位解析其在HarmonyOS上的实战应用。

一、背景与动机

你有没有想过，为什么手机拍照时美颜效果能实时呈现？为什么语音助手能在断网的情况下依然听懂你说的话？为什么相册能自动把猫咪的照片归类到一起？

答案就藏在四个字里——端侧推理。

过去，AI推理是个"重活儿"，必须把数据传到云端服务器，让GPU集群跑完再把结果传回来。这个流程有个致命问题：延迟。你对着手机说"帮我定个闹钟"，结果等了3秒才收到回复，这体验谁受得了？更别提隐私问题了——你的语音数据、照片数据全都在网络上裸奔。

MindSpore Lite就是华为给出的答案。它把AI推理的能力"压缩"到了设备端，让你在手机、平板、甚至智能手表上就能直接跑模型。不需要网络，不需要云端，数据不出设备，隐私有保障，延迟低到毫秒级。

但说实话，端侧推理不是把模型往手机上一扔就完事了。模型怎么加载？内存怎么管理？CPU和NPU怎么调度？推理精度和速度怎么平衡？这些问题才是真正让开发者头疼的地方。今天咱们就从头到尾把MindSpore Lite扒个底朝天。

二、核心原理

2.1 MindSpore Lite整体架构

MindSpore Lite的设计哲学可以用一句话概括：轻量、高效、跨平台。它不是简单地把服务端框架"瘦身"移植，而是从端侧场景出发重新设计的推理引擎。

从架构图可以看出，MindSpore Lite的工作流分为三个关键阶段：

1. 模型转换阶段：将训练框架产出的模型（MindIR、ONNX、TFLite等）转换为端侧专用的.ms格式，同时进行图优化和算子融合
2. 模型加载与编译阶段：在设备端加载.ms模型，根据硬件上下文编译生成可执行的计算图
3. 推理执行阶段：输入数据，执行推理，输出结果

2.2 核心概念解析

Model（模型对象）：这是MindSpore Lite最核心的类，负责模型的加载、编译和推理。一个Model实例对应一个推理会话，支持多线程安全调用。

Context（上下文）：定义推理的运行环境，包括设备类型（CPU/GPU/NPU）、线程数、算子偏好等。Context的配置直接决定了推理性能。

Tensor（张量）：数据容器，承载模型的输入和输出。MindSpore Lite的Tensor支持多种数据类型（float32、float16、int8等），并提供了零拷贝的数据传递机制。

Delegate（委托）：硬件加速的适配层。通过Delegate机制，MindSpore Lite可以将部分或全部算子卸载到NPU/GPU上执行，实现硬件加速。

2.3 推理执行流程

完整的推理流程可以概括为：创建上下文 → 加载模型 → 编译模型 → 设置输入 → 执行推理 → 获取输出。每一步都有其内部的优化逻辑，比如编译阶段会进行算子融合、常量折叠、内存预分配等优化。

三、代码实战

3.1 基础推理：加载模型并执行单次推理

这是最基础的用法，展示如何加载一个图像分类模型并执行推理：

// MindSporeLiteDemo.ets
// 功能：MindSpore Lite基础推理示例 - 图像分类

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

export class MindSporeLiteDemo {
  private model: mindsporeLite.Model | null = null;
  private context: common.Context;

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

  /**
   * 初始化模型 - 加载并编译
   * @param modelPath 模型文件路径（.ms格式）
   */
  async initModel(modelPath: string): Promise<boolean> {
    try {
      // 第一步：创建推理上下文
      const context = new mindsporeLite.Context();
      // 设置CPU为默认执行设备
      const cpuDevice = new mindsporeLite.CpuDevice();
      cpuDevice.isEnableFloat16 = true; // 开启FP16推理，提升性能
      context.addDevice(cpuDevice);

      // 第二步：创建Model实例
      this.model = new mindsporeLite.Model();

      // 第三步：加载模型文件
      // 从沙箱路径读取模型
      const modelBuffer = fileIo.readFileSync(modelPath);
      
      // 第四步：编译模型（加载+编译一步完成）
      const result = this.model.build(modelBuffer.buffer, context);
      
      if (result !== mindsporeLite.CompileRetCode.COMPILE_SUCCESS) {
        console.error(`[MindSpore] 模型编译失败，错误码: ${result}`);
        return false;
      }

      console.info('[MindSpore] 模型加载编译成功');
      return true;
    } catch (error) {
      console.error(`[MindSpore] 初始化失败: ${JSON.stringify(error)}`);
      return false;
    }
  }

  /**
   * 执行推理
   * @param inputData 输入数据（图像预处理后的Float32Array）
   * @returns 推理结果
   */
  async predict(inputData: Float32Array): Promise<Float32Array | null> {
    if (!this.model) {
      console.error('[MindSpore] 模型未初始化');
      return null;
    }

    try {
      // 获取输入张量
      const inputs = this.model.getInputs();
      if (inputs.length === 0) {
        console.error('[MindSpore] 获取输入张量失败');
        return null;
      }

      const inputTensor = inputs[0];
      
      // 设置输入数据
      // 注意：输入数据的shape必须与模型期望一致
      inputTensor.setData(inputData.buffer);

      // 执行推理
      const startTime = Date.now();
      this.model.predict(inputs);
      const inferTime = Date.now() - startTime;
      console.info(`[MindSpore] 推理耗时: ${inferTime}ms`);

      // 获取输出张量
      const outputs = this.model.getOutputs();
      if (outputs.length === 0) {
        console.error('[MindSpore] 获取输出张量失败');
        return null;
      }

      const outputTensor = outputs[0];
      const outputData = new Float32Array(outputTensor.getData().slice(0));
      
      return outputData;
    } catch (error) {
      console.error(`[MindSpore] 推理失败: ${JSON.stringify(error)}`);
      return null;
    }
  }

  /**
   * 解析分类结果 - 获取Top-K预测
   * @param outputData 模型输出数据
   * @param labels 标签列表
   * @param topK 返回前K个结果
   */
  parseClassificationResult(
    outputData: Float32Array,
    labels: string[],
    topK: number = 5
  ): Array<{ label: string; confidence: number }> {
    // Softmax归一化（如果模型输出未经过softmax）
    const maxVal = Math.max(...outputData);
    const expValues = Array.from(outputData).map(v => Math.exp(v - maxVal));
    const sumExp = expValues.reduce((a, b) => a + b, 0);
    const probabilities = expValues.map(v => v / sumExp);

    // 按置信度排序，取Top-K
    const indexed = probabilities.map((prob, index) => ({
      label: labels[index] || `class_${index}`,
      confidence: prob
    }));

    indexed.sort((a, b) => b.confidence - a.confidence);
    return indexed.slice(0, topK);
  }

  /**
   * 释放模型资源
   */
  release(): void {
    if (this.model) {
      this.model.free();
      this.model = null;
      console.info('[MindSpore] 模型资源已释放');
    }
  }
}

3.2 NPU加速推理：利用硬件NPU提升性能

当设备支持NPU时，我们可以通过NNAPI Delegate将推理卸载到NPU上，获得数倍的性能提升：

// NpuAccelerateDemo.ets
// 功能：NPU硬件加速推理示例

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

export class NpuAccelerateDemo {
  private model: mindsporeLite.Model | null = null;
  private context: common.Context;

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

  /**
   * 创建支持NPU加速的推理上下文
   * 优先使用NPU，不可用时回退到CPU
   */
  createContextWithNpu(): mindsporeLite.Context {
    const context = new mindsporeLite.Context();

    // 尝试添加NPU设备
    try {
      const npuDevice = new mindsporeLite.NpuDevice();
      // 设置NPU频率模式
      npuDevice.frequency = mindsporeLite.Frequency.FREQ_LEVEL_3; // 中等频率
      context.addDevice(npuDevice);
      console.info('[NPU] NPU设备添加成功，将优先使用NPU推理');
    } catch (error) {
      console.warn(`[NPU] NPU不可用，回退到CPU: ${JSON.stringify(error)}`);
    }

    // 添加CPU设备作为回退
    const cpuDevice = new mindsporeLite.CpuDevice();
    cpuDevice.isEnableFloat16 = true;
    cpuDevice.isEnableParallel = true; // 开启并行推理
    cpuDevice.threadNum = 4; // 设置线程数为4
    cpuDevice.bindMode = mindsporeLite.BindMode.NO_BIND; // 不绑定核心
    context.addDevice(cpuDevice);

    return context;
  }

  /**
   * 初始化模型 - 带NPU加速
   */
  async initModelWithNpu(modelPath: string): Promise<boolean> {
    try {
      const context = this.createContextWithNpu();
      this.model = new mindsporeLite.Model();

      const modelBuffer = fileIo.readFileSync(modelPath);
      const result = this.model.build(modelBuffer.buffer, context);

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

      // 检查实际使用的设备
      this.printDeviceInfo();
      return true;
    } catch (error) {
      console.error(`[NPU] 初始化失败: ${JSON.stringify(error)}`);
      return false;
    }
  }

  /**
   * 打印设备信息
   */
  private printDeviceInfo(): void {
    if (!this.model) return;
    
    const inputs = this.model.getInputs();
    if (inputs.length > 0) {
      const tensor = inputs[0];
      console.info(`[NPU] 输入张量名称: ${tensor.name}`);
      console.info(`[NPU] 输入张量形状: [${tensor.shape.join(', ')}]`);
      console.info(`[NPU] 输入数据类型: ${tensor.dataType}`);
    }
  }

  /**
   * 批量推理 - 多帧连续推理场景
   * @param inputBatch 输入数据数组
   * @returns 推理结果数组
   */
  async batchPredict(inputBatch: Float32Array[]): Promise<Float32Array[]> {
    if (!this.model) {
      throw new Error('模型未初始化');
    }

    const results: Float32Array[] = [];
    const inputs = this.model.getInputs();
    const inputTensor = inputs[0];

    for (let i = 0; i < inputBatch.length; i++) {
      inputTensor.setData(inputBatch[i].buffer);
      this.model.predict(inputs);
      
      const outputs = this.model.getOutputs();
      const outputData = new Float32Array(outputs[0].getData().slice(0));
      results.push(outputData);
      
      console.info(`[NPU] 第${i + 1}帧推理完成`);
    }

    return results;
  }

  /**
   * 释放资源
   */
  release(): void {
    if (this.model) {
      this.model.free();
      this.model = null;
    }
  }
}

3.3 完整UI集成：图像分类应用

将MindSpore Lite推理能力集成到ArkUI应用中，实现拍照→预处理→推理→展示结果的完整流程：

// ImageClassificationPage.ets
// 功能：基于MindSpore Lite的图像分类完整应用

import { mindsporeLite } from '@kit.MindSporeLiteKit';
import { fileIo } from '@kit.CoreFileKit';
import { image } from '@kit.ImageKit';
import { camera } from '@kit.CameraKit';
import { common } from '@kit.AbilityKit';

// ImageNet标签（示例，实际使用1000个标签）
const IMAGE_LABELS: string[] = [
  '金鱼', '大白鲨', '老虎', '斑马', '熊猫',
  '金毛犬', '波斯猫', '雄鹰', '鹦鹉', '蝴蝶'
];

@Entry
@Component
struct ImageClassificationPage {
  @State classificationResults: Array<{ label: string; confidence: number }> = [];
  @State isLoading: boolean = false;
  @State inferTime: number = 0;
  @State modelStatus: string = '未加载';
  @State selectedImageUri: string = '';

  private model: mindsporeLite.Model | null = null;
  private readonly MODEL_INPUT_SIZE = 224; // 模型输入尺寸224x224

  // 生命周期：页面即将显示时加载模型
  aboutToAppear(): void {
    this.loadModel();
  }

  // 生命周期：页面即将消失时释放模型
  aboutToDisappear(): void {
    this.releaseModel();
  }

  /**
   * 加载MindSpore Lite模型
   */
  async loadModel(): Promise<void> {
    try {
      this.modelStatus = '加载中...';

      const context = new mindsporeLite.Context();
      
      // 优先NPU，回退CPU
      try {
        const npuDevice = new mindsporeLite.NpuDevice();
        context.addDevice(npuDevice);
      } catch (e) {
        console.warn('[App] NPU不可用，使用CPU推理');
      }

      const cpuDevice = new mindsporeLite.CpuDevice();
      cpuDevice.isEnableFloat16 = true;
      cpuDevice.threadNum = 4;
      context.addDevice(cpuDevice);

      this.model = new mindsporeLite.Model();

      // 从rawfile加载模型
      const modelPath = this.getContext().resourceDir + '/mobilenetv2.ms';
      const modelBuffer = fileIo.readFileSync(modelPath);
      
      const result = this.model.build(modelBuffer.buffer, context);
      
      if (result === mindsporeLite.CompileRetCode.COMPILE_SUCCESS) {
        this.modelStatus = '已加载 ✓';
        console.info('[App] 模型加载成功');
      } else {
        this.modelStatus = `加载失败 (${result})`;
      }
    } catch (error) {
      this.modelStatus = '加载异常';
      console.error(`[App] 模型加载异常: ${JSON.stringify(error)}`);
    }
  }

  /**
   * 图像预处理 - 将原始图像转换为模型输入格式
   * @param pixelMap 原始图像的PixelMap
   * @returns Float32Array格式的输入数据
   */
  preprocessImage(pixelMap: image.PixelMap): Float32Array {
    const size = this.MODEL_INPUT_SIZE;
    
    // 缩放到模型输入尺寸
    pixelMap.scaleSync(size, size);

    // 读取像素数据
    const pixelBytes = pixelMap.getImageDataSync(0, 0, size, size);
    const pixelData = new Uint8Array(pixelBytes.bytes.buffer);

    // 转换为NCHW格式的Float32数组
    // ImageData格式为RGBA，需要转换为RGB并归一化
    const channelSize = size * size;
    const inputData = new Float32Array(3 * channelSize);

    // ImageNet标准归一化参数
    const mean = [0.485, 0.456, 0.406];
    const std = [0.229, 0.224, 0.225];

    for (let i = 0; i < channelSize; i++) {
      const pixelIndex = i * 4; // RGBA每像素4字节
      
      // R通道
      inputData[i] = (pixelData[pixelIndex] / 255.0 - mean[0]) / std[0];
      // G通道
      inputData[channelSize + i] = (pixelData[pixelIndex + 1] / 255.0 - mean[1]) / std[1];
      // B通道
      inputData[2 * channelSize + i] = (pixelData[pixelIndex + 2] / 255.0 - mean[2]) / std[2];
    }

    return inputData;
  }

  /**
   * 执行分类推理
   */
  async classifyImage(pixelMap: image.PixelMap): Promise<void> {
    if (!this.model) {
      console.error('[App] 模型未加载');
      return;
    }

    this.isLoading = true;

    try {
      // 预处理
      const inputData = this.preprocessImage(pixelMap);

      // 设置输入
      const inputs = this.model.getInputs();
      inputs[0].setData(inputData.buffer);

      // 执行推理
      const startTime = Date.now();
      this.model.predict(inputs);
      this.inferTime = Date.now() - startTime;

      // 获取输出
      const outputs = this.model.getOutputs();
      const outputData = new Float32Array(outputs[0].getData().slice(0));

      // 解析结果
      this.classificationResults = this.parseTopK(outputData, IMAGE_LABELS, 5);
    } catch (error) {
      console.error(`[App] 推理失败: ${JSON.stringify(error)}`);
    } finally {
      this.isLoading = false;
    }
  }

  /**
   * 解析Top-K分类结果
   */
  parseTopK(
    outputData: Float32Array,
    labels: string[],
    topK: number
  ): Array<{ label: string; confidence: number }> {
    const maxVal = Math.max(...outputData);
    const expValues = Array.from(outputData).map(v => Math.exp(v - maxVal));
    const sumExp = expValues.reduce((a, b) => a + b, 0);
    const probabilities = expValues.map(v => v / sumExp);

    const indexed = probabilities.map((prob, index) => ({
      label: labels[index] || `class_${index}`,
      confidence: Math.round(prob * 10000) / 100 // 保留两位小数
    }));

    indexed.sort((a, b) => b.confidence - a.confidence);
    return indexed.slice(0, topK);
  }

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

  build() {
    Column() {
      // 标题栏
      Text('AI图像分类')
        .fontSize(24)
        .fontWeight(FontWeight.Bold)
        .margin({ top: 20, bottom: 16 })

      // 模型状态
      Row() {
        Text('模型状态：')
          .fontSize(14)
          .fontColor('#999999')
        Text(this.modelStatus)
          .fontSize(14)
          .fontWeight(FontWeight.Medium)
          .fontColor(this.modelStatus.includes('✓') ? '#4CAF50' : '#FF5722')
      }
      .margin({ bottom: 16 })

      // 选择图片按钮
      Button('选择图片进行分类')
        .width('80%')
        .height(48)
        .fontSize(16)
        .enabled(!this.isLoading && this.modelStatus.includes('✓'))
        .backgroundColor('#4A90D9')
        .borderRadius(24)
        .onClick(() => {
          // 实际应用中这里调用图片选择器
          // 此处为简化示例
          console.info('[App] 选择图片');
        })

      // 推理耗时
      if (this.inferTime > 0) {
        Text(`推理耗时：${this.inferTime}ms`)
          .fontSize(14)
          .fontColor('#666666')
          .margin({ top: 16 })
      }

      // 分类结果列表
      if (this.classificationResults.length > 0) {
        Column() {
          Text('分类结果')
            .fontSize(18)
            .fontWeight(FontWeight.Bold)
            .margin({ bottom: 12 })

          ForEach(this.classificationResults, (item: { label: string; confidence: number }, index: number) => {
            Row() {
              Text(`${index + 1}. ${item.label}`)
                .fontSize(16)
                .layoutWeight(1)
              
              // 置信度进度条
              Progress({ value: item.confidence, total: 100, type: ProgressType.Linear })
                .width(120)
                .color(index === 0 ? '#4CAF50' : '#4A90D9')
              
              Text(`${item.confidence}%`)
                .fontSize(14)
                .fontColor('#666666')
                .width(60)
                .textAlign(TextAlign.End)
            }
            .width('100%')
            .padding({ left: 16, right: 16, top: 8, bottom: 8 })
          })
        }
        .width('90%')
        .padding(16)
        .backgroundColor('#F5F5F5')
        .borderRadius(12)
        .margin({ top: 20 })
      }

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

四、踩坑与注意事项

4.1 模型文件格式问题

坑位：直接使用.onnx或.mindir文件加载，报错"模型格式不支持"。

原因：MindSpore Lite端侧只支持.ms格式的模型文件，必须先通过converter工具进行转换。

解决方案：

# 使用MindSpore Lite转换工具
./converter --fmk=ONNX --modelFile=model.onnx --outputFile=model --outputType=MINDIR_LITE

转换时可以同时进行量化：

# 带INT8量化的转换
./converter --fmk=ONNX --modelFile=model.onnx --outputFile=model_quant \
  --quantType=WeightQuant --bitNum=8 --weightQuantSize=0

4.2 输入张量Shape不匹配

坑位：推理时抛出"Input tensor shape mismatch"异常。

原因：输入数据的维度与模型期望的Shape不一致。常见于图像预处理时batch维度缺失或通道顺序错误。

解决方案：

// 错误：直接传入HWC格式的数据
// const wrongInput = new Float32Array(224 * 224 * 3); // HWC

// 正确：使用NCHW格式
const correctInput = new Float32Array(1 * 3 * 224 * 224); // NCHW

// 检查模型期望的输入Shape
const inputs = model.getInputs();
console.info(`模型期望输入Shape: [${inputs[0].shape.join(', ')}]`);

4.3 NPU推理兼容性问题

坑位：部分算子不支持NPU执行，导致推理结果异常或直接崩溃。

原因：NPU支持的算子集合是CPU的子集，某些自定义算子或新算子NPU尚未支持。

解决方案：

// 方案1：使用混合精度调度，让不支持的算子回退到CPU
const context = new mindsporeLite.Context();

// 先添加NPU（优先级高）
try {
  const npuDevice = new mindsporeLite.NpuDevice();
  context.addDevice(npuDevice);
} catch (e) {
  // NPU不可用
}

// 再添加CPU作为回退
const cpuDevice = new mindsporeLite.CpuDevice();
context.addDevice(cpuDevice);

// 方案2：编译时检查是否所有算子都能在NPU上执行
// 如果编译失败，尝试纯CPU模式

4.4 内存泄漏问题

坑位：反复加载释放模型后，应用内存持续增长。

原因：未正确释放Tensor数据或Model资源。

解决方案：

// 必须在页面销毁或模型不再使用时调用free()
aboutToDisappear(): void {
  if (this.model) {
    this.model.free(); // 释放模型及关联的所有资源
    this.model = null;
  }
}

// 避免在循环中反复创建Model实例
// 错误做法：
for (const path of modelPaths) {
  const model = new mindsporeLite.Model();
  model.build(buffer, context);
  model.predict(inputs);
  // 忘记释放！
}

// 正确做法：复用Model实例
const model = new mindsporeLite.Model();
for (const path of modelPaths) {
  model.free(); // 先释放上一个
  model.build(buffer, context);
  model.predict(inputs);
}
model.free(); // 最终释放

4.5 并发推理安全

坑位：多线程同时调用同一个Model实例的predict方法，导致推理结果错乱。

原因：Model实例不是线程安全的，同一时刻只能有一个推理任务在执行。

解决方案：使用任务队列或互斥锁保证串行执行：

// 使用异步锁保证推理串行
private inferLock: boolean = false;

async safePredict(inputs: mindsporeLite.MSTensor[]): Promise<mindsporeLite.MSTensor[]> {
  // 等待上一次推理完成
  while (this.inferLock) {
    await new Promise(resolve => setTimeout(resolve, 10));
  }
  
  this.inferLock = true;
  try {
    this.model!.predict(inputs);
    return this.model!.getOutputs();
  } finally {
    this.inferLock = false;
  }
}

五、HarmonyOS 6适配

5.1 API变更

HarmonyOS 6对MindSpore Lite Kit进行了以下重要更新：

5.2 迁移指南

1. 模型加载迁移：

// HarmonyOS 5写法
const buffer = fileIo.readFileSync(modelPath);
model.build(buffer.buffer, context);

// HarmonyOS 6写法（推荐）
model.buildFromFile(modelPath, context);
// 优势：减少内存拷贝，加载速度提升约30%

2. 自动设备选择迁移：

// HarmonyOS 5写法 - 手动添加设备
const context = new mindsporeLite.Context();
try {
  const npuDevice = new mindsporeLite.NpuDevice();
  context.addDevice(npuDevice);
} catch (e) { /* NPU不可用 */ }
const cpuDevice = new mindsporeLite.CpuDevice();
context.addDevice(cpuDevice);

// HarmonyOS 6写法 - 自动选择
const context = new mindsporeLite.Context();
context.autoDeviceSelect = true; // 自动选择最优设备
context.performanceMode = mindsporeLite.PerformanceMode.PRIORITY_PERFORMANCE;

3. 动态Shape迁移：

// HarmonyOS 6新增：支持推理时动态调整输入维度
const inputs = model.getInputs();
// 动态调整batch size从1到4
model.resize(inputs[0], [4, 3, 224, 224]);

六、总结

本文从MindSpore Lite的架构原理到实战代码，全方位解析了HarmonyOS端侧AI推理的核心能力。关键知识点回顾：

MindSpore Lite核心知识图谱
├── 架构层
│   ├── 模型转换：训练模型 → .ms格式（converter工具）
│   ├── 推理上下文：Context配置设备与优化策略
│   └── 硬件加速：CPU / GPU(OpenCL) / NPU(NNAPI)
├── 核心API
│   ├── Model：模型加载、编译、推理、释放
│   ├── Context：设备配置、线程数、FP16开关
│   ├── MSTensor：输入输出数据容器
│   └── Device：CpuDevice / NpuDevice / GpuDevice
├── 推理流程
│   ├── 创建Context → 添加Device → 构建Model
│   ├── 获取Inputs → 设置数据 → 执行Predict
│   └── 获取Outputs → 解析结果 → 释放资源
├── 性能优化
│   ├── FP16推理：速度提升30-50%，精度损失<1%
│   ├── NPU加速：速度提升3-10倍
│   ├── 线程优化：4线程为最佳平衡点
│   └── 模型量化：INT8量化体积减少75%
└── 踩坑要点
    ├── 模型格式必须为.ms
    ├── 输入Shape必须匹配（NCHW格式）
    ├── NPU算子兼容性检查
    ├── 及时释放Model避免内存泄漏
    └── Model实例非线程安全

一句话总结：MindSpore Lite是HarmonyOS端侧AI的基石，掌握它的加载、推理、加速、调优全链路，你就掌握了端侧AI开发的核心能力。记住——端侧推理不是简单的"模型+推理"，而是一个涉及模型转换、硬件调度、内存管理、精度平衡的系统工程。