HarmonyOS开发：AI模型市场与模型管理

核心要点：AI模型市场是HarmonyOS AI生态的核心基础设施，它让开发者可以像下载APP一样下载和使用AI模型。本文将深入讲解HarmonyOS AI模型市场的架构设计、模型生命周期管理、端侧模型部署优化以及模型版本控制等关键技术。

一、背景与动机

你有没有想过，为什么手机上的AI功能越来越强大，但APP的安装包却没有越来越大？

答案就是模型市场——AI模型不再打包在APP里，而是像应用商店一样，按需下载、独立更新、多APP共享。

这带来了几个关键好处：

1. APP瘦身：一个50MB的OCR模型不用再塞进安装包，用户按需下载即可
2. 模型复用：多个APP可以共享同一个模型，不重复占用存储
3. 独立更新：模型可以比APP更频繁地更新，修复精度问题不用发版
4. 个性化：用户可以根据自己的需求选择不同大小/精度的模型

但模型市场也带来了新的挑战：模型怎么管理？怎么版本控制？怎么在端侧高效部署？ 这就是本文要回答的问题。

二、核心原理

2.1 AI模型市场架构

2.2 模型生命周期

一个AI模型从发布到退役，经历完整的生命周期：

2.3 模型分类体系

HarmonyOS AI模型市场的模型按照能力维度分类：

2.4 端侧模型存储与共享机制

HarmonyOS的模型存储采用沙箱隔离+共享池的双重机制：

• 沙箱隔离：每个APP有自己的模型沙箱，确保模型文件不被其他APP直接访问
• 共享池：相同模型ID的模型只存储一份，通过引用计数管理生命周期
• 安全校验：模型下载后进行完整性校验（SHA256），防止篡改

三、代码实战

3.1 示例一：模型市场浏览与下载

实现一个完整的模型市场浏览、搜索、下载功能。

// AI模型市场 - 浏览与下载
import { mlModelMarket } from '@hms.core.ml-kit';
import { BusinessError } from '@kit.BasicServicesKit';

// 模型信息数据模型
interface ModelItem {
  modelId: string;           // 模型唯一标识
  name: string;              // 模型名称
  description: string;       // 模型描述
  category: string;          // 分类：speech/vision/nlp/recommend
  version: string;           // 当前版本
  size: number;              // 模型大小(MB)
  accuracy: number;          // 精度评分 0-100
  downloadCount: number;     // 下载次数
  rating: number;            // 评分 0-5
  isDownloaded: boolean;     // 是否已下载
  isLatest: boolean;         // 是否为最新版本
  thumbnail: string;         // 缩略图URL
  tags: string[];            // 标签
}

// 下载状态
type DownloadStatus = 'idle' | 'downloading' | 'paused' | 'completed' | 'failed';

// 下载进度信息
interface DownloadProgress {
  modelId: string;
  status: DownloadStatus;
  percent: number;           // 0-100
  downloadedBytes: number;
  totalBytes: number;
  speed: number;             // KB/s
}

@Entry
@Component
struct ModelMarketPage {
  @State models: ModelItem[] = [];
  @State filteredModels: ModelItem[] = [];
  @State searchQuery: string = '';
  @State selectedCategory: string = 'all';
  @State downloadProgresses: Map<string, DownloadProgress> = new Map();
  @State isLoading: boolean = false;

  private marketClient: mlModelMarket.MLModelMarket | null = null;

  // 分类选项
  private categories: string[] = ['all', 'speech', 'vision', 'nlp', 'recommend'];
  private categoryLabels: Record<string, string> = {
    'all': '全部',
    'speech': '语音',
    'vision': '视觉',
    'nlp': '自然语言',
    'recommend': '推荐',
  };

  aboutToAppear(): void {
    this.marketClient = mlModelMarket.MLModelMarket.create();
    this.loadModels();
  }

  // 加载模型列表
  private async loadModels(): Promise<void> {
    this.isLoading = true;
    try {
      const request: mlModelMarket.MLModelListRequest = {
        pageNumber: 1,
        pageSize: 50,
        sortBy: mlModelMarket.SortType.POPULARITY, // 按热度排序
      };

      const response = await this.marketClient!.getModelList(request);

      this.models = response.models.map((m) => ({
        modelId: m.modelId,
        name: m.name,
        description: m.description,
        category: m.category,
        version: m.version,
        size: m.size / (1024 * 1024), // 转为MB
        accuracy: m.accuracy || 0,
        downloadCount: m.downloadCount || 0,
        rating: m.rating || 0,
        isDownloaded: m.isDownloaded || false,
        isLatest: m.isLatest || true,
        thumbnail: m.thumbnail || '',
        tags: m.tags || [],
      }));

      this.applyFilter();
      console.info(`[ModelMarket] 加载了${this.models.length}个模型`);
    } catch (error) {
      const err = error as BusinessError;
      console.error(`[ModelMarket] 加载失败: ${err.code} - ${err.message}`);
    } finally {
      this.isLoading = false;
    }
  }

  // 搜索模型
  private async searchModels(query: string): Promise<void> {
    if (!query.trim()) {
      this.applyFilter();
      return;
    }

    try {
      const request: mlModelMarket.MLModelSearchRequest = {
        keyword: query,
        pageNumber: 1,
        pageSize: 20,
      };

      const response = await this.marketClient!.searchModels(request);
      this.filteredModels = response.models.map((m) => ({
        modelId: m.modelId,
        name: m.name,
        description: m.description,
        category: m.category,
        version: m.version,
        size: m.size / (1024 * 1024),
        accuracy: m.accuracy || 0,
        downloadCount: m.downloadCount || 0,
        rating: m.rating || 0,
        isDownloaded: m.isDownloaded || false,
        isLatest: m.isLatest || true,
        thumbnail: m.thumbnail || '',
        tags: m.tags || [],
      }));
    } catch (error) {
      console.error('[ModelMarket] 搜索失败');
    }
  }

  // 应用筛选条件
  private applyFilter(): void {
    let result = [...this.models];

    // 分类筛选
    if (this.selectedCategory !== 'all') {
      result = result.filter(m => m.category === this.selectedCategory);
    }

    // 搜索筛选
    if (this.searchQuery) {
      const query = this.searchQuery.toLowerCase();
      result = result.filter(m =>
        m.name.toLowerCase().includes(query) ||
        m.description.toLowerCase().includes(query) ||
        m.tags.some(t => t.toLowerCase().includes(query))
      );
    }

    this.filteredModels = result;
  }

  // 下载模型
  private async downloadModel(modelId: string): Promise<void> {
    if (!this.marketClient) return;

    // 初始化下载进度
    this.downloadProgresses.set(modelId, {
      modelId: modelId,
      status: 'downloading',
      percent: 0,
      downloadedBytes: 0,
      totalBytes: 0,
      speed: 0,
    });

    try {
      // 监听下载进度
      this.marketClient.on('downloadProgress', (progress) => {
        if (progress.modelId === modelId) {
          this.downloadProgresses.set(modelId, {
            modelId: modelId,
            status: 'downloading',
            percent: Math.floor(progress.percent * 100),
            downloadedBytes: progress.downloadedBytes,
            totalBytes: progress.totalBytes,
            speed: progress.speed || 0,
          });
        }
      });

      // 执行下载
      await this.marketClient.downloadModel(modelId);

      // 更新下载状态
      this.downloadProgresses.set(modelId, {
        ...this.downloadProgresses.get(modelId)!,
        status: 'completed',
        percent: 100,
      });

      // 更新模型列表中的下载状态
      const idx = this.models.findIndex(m => m.modelId === modelId);
      if (idx >= 0) {
        this.models[idx].isDownloaded = true;
      }

      console.info(`[ModelMarket] 模型${modelId}下载完成`);
    } catch (error) {
      this.downloadProgresses.set(modelId, {
        ...this.downloadProgresses.get(modelId)!,
        status: 'failed',
      });
      console.error(`[ModelMarket] 下载失败: ${(error as Error).message}`);
    }
  }

  // 删除已下载的模型
  private async deleteModel(modelId: string): Promise<void> {
    if (!this.marketClient) return;

    try {
      await this.marketClient.deleteModel(modelId);

      const idx = this.models.findIndex(m => m.modelId === modelId);
      if (idx >= 0) {
        this.models[idx].isDownloaded = false;
      }

      this.downloadProgresses.delete(modelId);
      console.info(`[ModelMarket] 模型${modelId}已删除`);
    } catch (error) {
      console.error(`[ModelMarket] 删除失败: ${(error as Error).message}`);
    }
  }

  aboutToDisappear(): void {
    this.marketClient?.release();
  }

  build() {
    Column() {
      // 搜索栏
      Row() {
        TextInput({ placeholder: '搜索AI模型...' })
          .layoutWeight(1)
          .height(40)
          .backgroundColor('#1a1a2e')
          .borderRadius(20)
          .fontColor('#e0e0e0')
          .onChange((value: string) => {
            this.searchQuery = value;
            this.searchModels(value);
          })
      }
      .width('100%')
      .padding({ left: 16, right: 16, top: 8, bottom: 8 })

      // 分类标签
      Scroll(ScrollDirection.Horizontal) {
        Row() {
          ForEach(this.categories, (cat: string) => {
            Text(this.categoryLabels[cat])
              .fontSize(14)
              .padding({ left: 16, right: 16, top: 8, bottom: 8 })
              .backgroundColor(this.selectedCategory === cat ? '#4A90D9' : '#1a1a2e')
              .borderRadius(16)
              .fontColor(this.selectedCategory === cat ? '#fff' : '#999')
              .margin({ right: 8 })
              .onClick(() => {
                this.selectedCategory = cat;
                this.applyFilter();
              })
          }, (cat: string) => cat)
        }
      }
      .width('100%')
      .padding({ left: 16, right: 16, bottom: 8 })

      // 模型列表
      if (this.isLoading) {
        LoadingProgress()
          .width(40)
          .height(40)
          .color('#4A90D9')
          .margin({ top: 40 })
      } else {
        List() {
          ForEach(this.filteredModels, (model: ModelItem) => {
            ListItem() {
              this.ModelCard(model)
            }
            .margin({ bottom: 8 })
          }, (model: ModelItem) => model.modelId)
        }
        .layoutWeight(1)
        .width('100%')
        .padding({ left: 16, right: 16 })
      }
    }
    .width('100%')
    .height('100%')
    .backgroundColor('#0d0d1a')
  }

  // 模型卡片组件
  @Builder
  ModelCard(model: ModelItem) {
    Column() {
      // 模型名称和分类
      Row() {
        Text(model.name)
          .fontSize(16)
          .fontWeight(FontWeight.Bold)
          .fontColor('#e0e0e0')
          .layoutWeight(1)

        // 分类标签
        Text(this.categoryLabels[model.category] || model.category)
          .fontSize(12)
          .padding({ left: 8, right: 8, top: 4, bottom: 4 })
          .backgroundColor('#7B68EE')
          .borderRadius(10)
          .fontColor('#fff')
      }
      .width('100%')

      // 模型描述
      Text(model.description)
        .fontSize(13)
        .fontColor('#999')
        .maxLines(2)
        .textOverflow({ overflow: TextOverflow.Ellipsis })
        .margin({ top: 6 })

      // 模型指标
      Row() {
        Text(`${model.size.toFixed(1)}MB`)
          .fontSize(12)
          .fontColor('#4A90D9')
        Text(`⭐ ${model.rating.toFixed(1)}`)
          .fontSize(12)
          .fontColor('#F5A623')
          .margin({ left: 12 })
        Text(`📥 ${model.downloadCount}`)
          .fontSize(12)
          .fontColor('#999')
          .margin({ left: 12 })
        Text(`v${model.version}`)
          .fontSize(12)
          .fontColor('#666')
          .margin({ left: 12 })
      }
      .margin({ top: 8 })

      // 下载进度或操作按钮
      Row() {
        if (model.isDownloaded) {
          // 已下载状态
          Text('✓ 已下载')
            .fontSize(14)
            .fontColor('#4A90D9')
            .layoutWeight(1)

          if (!model.isLatest) {
            Button('更新')
              .height(32)
              .fontSize(13)
              .backgroundColor('#F5A623')
              .borderRadius(16)
              .onClick(() => this.downloadModel(model.modelId))
          }

          Button('删除')
            .height(32)
            .fontSize(13)
            .backgroundColor('#3d1111')
            .fontColor('#D0021B')
            .borderRadius(16)
            .margin({ left: 8 })
            .onClick(() => this.deleteModel(model.modelId))
        } else {
          // 未下载状态
          const progress = this.downloadProgresses.get(model.modelId);
          if (progress && progress.status === 'downloading') {
            // 下载中
            Progress({ value: progress.percent, total: 100, type: ProgressType.Linear })
              .layoutWeight(1)
              .color('#4A90D9')
            Text(`${progress.percent}%`)
              .fontSize(12)
              .fontColor('#4A90D9')
              .width(40)
              .textAlign(TextAlign.End)
          } else {
            // 未开始下载
            Button('下载')
              .height(32)
              .fontSize(13)
              .backgroundColor('#4A90D9')
              .borderRadius(16)
              .onClick(() => this.downloadModel(model.modelId))
          }
        }
      }
      .width('100%')
      .margin({ top: 10 })
    }
    .width('100%')
    .padding(14)
    .backgroundColor('#1a1a2e')
    .borderRadius(12)
  }
}

3.2 示例二：模型版本管理与热更新

实现模型的版本检测、增量更新和热切换。

// 模型版本管理与热更新服务
import { mlModelManager } from '@hms.core.ml-kit';
import { BusinessError } from '@kit.BasicServicesKit';
import { common } from '@kit.AbilityKit';

// 模型版本信息
interface ModelVersionInfo {
  modelId: string;
  currentVersion: string;
  latestVersion: string;
  hasUpdate: boolean;
  updateSize: number;        // 更新包大小(bytes)
  isIncremental: boolean;    // 是否为增量更新
  changelog: string;         // 更新日志
}

// 模型运行状态
interface ModelRuntimeStatus {
  modelId: string;
  isActive: boolean;         // 是否正在使用
  loadedAt: number;          // 加载时间
  inferenceCount: number;    // 推理次数
  avgLatency: number;        // 平均延迟(ms)
}

// 模型管理器
class ModelVersionManager {
  private manager: mlModelManager.MLModelManager;
  private runtimeStatuses: Map<string, ModelRuntimeStatus> = new Map();
  private context: common.UIAbilityContext;

  constructor(context: common.UIAbilityContext) {
    this.context = context;
    this.manager = mlModelManager.MLModelManager.create(context);
  }

  // 检查所有已安装模型的更新
  async checkAllUpdates(): Promise<ModelVersionInfo[]> {
    const updates: ModelVersionInfo[] = [];

    try {
      // 获取已安装模型列表
      const installedModels = await this.manager.getInstalledModels();

      for (const model of installedModels) {
        try {
          const updateInfo = await this.checkUpdate(model.modelId);
          if (updateInfo) {
            updates.push(updateInfo);
          }
        } catch (error) {
          console.warn(`[ModelVersion] 检查${model.modelId}更新失败`);
        }
      }

      console.info(`[ModelVersion] 检查完成，${updates.length}个模型有更新`);
    } catch (error) {
      console.error('[ModelVersion] 获取已安装模型失败');
    }

    return updates;
  }

  // 检查单个模型更新
  async checkUpdate(modelId: string): Promise<ModelVersionInfo | null> {
    try {
      const updateInfo = await this.manager.checkUpdate(modelId);

      // 获取当前模型信息
      const currentModel = await this.manager.getModelInfo(modelId);

      return {
        modelId: modelId,
        currentVersion: currentModel?.version || 'unknown',
        latestVersion: updateInfo.latestVersion,
        hasUpdate: updateInfo.hasUpdate,
        updateSize: updateInfo.updateSize || 0,
        isIncremental: updateInfo.isIncremental || false,
        changelog: updateInfo.changelog || '',
      };
    } catch (error) {
      console.error(`[ModelVersion] 检查${modelId}更新失败`);
      return null;
    }
  }

  // 执行模型更新（支持增量更新）
  async updateModel(
    modelId: string,
    onProgress?: (percent: number) => void
  ): Promise<boolean> {
    try {
      // 监听下载进度
      this.manager.on('downloadProgress', (progress) => {
        if (progress.modelId === modelId && onProgress) {
          onProgress(Math.floor(progress.percent * 100));
        }
      });

      // 执行更新
      await this.manager.updateModel(modelId);

      // 热切换到新版本
      await this.hotSwapModel(modelId);

      console.info(`[ModelVersion] 模型${modelId}更新完成`);
      return true;
    } catch (error) {
      const err = error as BusinessError;
      console.error(`[ModelVersion] 更新失败: ${err.code} - ${err.message}`);
      return false;
    }
  }

  // 模型热切换（不重启APP）
  private async hotSwapModel(modelId: string): Promise<void> {
    // 先卸载旧版本
    const status = this.runtimeStatuses.get(modelId);
    if (status && status.isActive) {
      // 如果模型正在使用，需要先停止推理
      console.info(`[ModelVersion] 热切换模型${modelId}，当前推理次数: ${status.inferenceCount}`);
    }

    // 重新加载新版本
    await this.manager.reloadModel(modelId);

    // 更新运行状态
    this.runtimeStatuses.set(modelId, {
      modelId: modelId,
      isActive: true,
      loadedAt: Date.now(),
      inferenceCount: 0,
      avgLatency: 0,
    });
  }

  // 回滚到上一版本
  async rollbackModel(modelId: string): Promise<boolean> {
    try {
      await this.manager.rollbackModel(modelId);
      console.info(`[ModelVersion] 模型${modelId}已回滚`);
      return true;
    } catch (error) {
      console.error(`[ModelVersion] 回滚失败: ${(error as Error).message}`);
      return false;
    }
  }

  // 获取模型运行状态
  getRuntimeStatus(modelId: string): ModelRuntimeStatus | undefined {
    return this.runtimeStatuses.get(modelId);
  }

  // 记录推理统计
  recordInference(modelId: string, latencyMs: number): void {
    const status = this.runtimeStatuses.get(modelId);
    if (status) {
      status.inferenceCount++;
      // 计算移动平均延迟
      status.avgLatency = (status.avgLatency * (status.inferenceCount - 1) + latencyMs) /
        status.inferenceCount;
    }
  }

  // 释放资源
  release(): void {
    this.manager.release();
    this.runtimeStatuses.clear();
  }
}

// 模型管理页面
@Entry
@Component
struct ModelManagementPage {
  @State updateList: ModelVersionInfo[] = [];
  @State isChecking: boolean = false;
  @State updatingModelId: string = '';
  @State updateProgress: number = 0;
  @State runtimeStatuses: ModelRuntimeStatus[] = [];

  private versionManager: ModelVersionManager | null = null;

  aboutToAppear(): void {
    this.versionManager = new ModelVersionManager(getContext(this) as common.UIAbilityContext);
    this.checkUpdates();
  }

  // 检查更新
  private async checkUpdates(): Promise<void> {
    if (!this.versionManager) return;

    this.isChecking = true;
    try {
      this.updateList = await this.versionManager.checkAllUpdates();
    } finally {
      this.isChecking = false;
    }
  }

  // 更新模型
  private async doUpdate(modelId: string): Promise<void> {
    if (!this.versionManager) return;

    this.updatingModelId = modelId;
    this.updateProgress = 0;

    const success = await this.versionManager.updateModel(
      modelId,
      (percent: number) => {
        this.updateProgress = percent;
      }
    );

    if (success) {
      // 从更新列表中移除
      this.updateList = this.updateList.filter(u => u.modelId !== modelId);
    }

    this.updatingModelId = '';
    this.updateProgress = 0;
  }

  aboutToDisappear(): void {
    this.versionManager?.release();
  }

  build() {
    Scroll() {
      Column() {
        Text('模型管理')
          .fontSize(24)
          .fontWeight(FontWeight.Bold)
          .fontColor('#e0e0e0')
          .margin({ bottom: 20 })

        // 更新检查按钮
        Button(this.isChecking ? '检查中...' : '检查更新')
          .height(44)
          .fontSize(16)
          .backgroundColor('#4A90D9')
          .borderRadius(22)
          .enabled(!this.isChecking)
          .margin({ bottom: 20 })
          .onClick(() => this.checkUpdates())

        // 更新列表
        if (this.updateList.length > 0) {
          Text('可用更新')
            .fontSize(18)
            .fontColor('#F5A623')
            .margin({ bottom: 12 })

          ForEach(this.updateList, (update: ModelVersionInfo) => {
            Column() {
              Row() {
                Text(update.modelId)
                  .fontSize(16)
                  .fontWeight(FontWeight.Bold)
                  .fontColor('#e0e0e0')
                  .layoutWeight(1)

                if (update.isIncremental) {
                  Text('增量更新')
                    .fontSize(12)
                    .padding({ left: 6, right: 6, top: 2, bottom: 2 })
                    .backgroundColor('#7B68EE')
                    .borderRadius(8)
                    .fontColor('#fff')
                }
              }
              .width('100%')

              Text(`${update.currentVersion} → ${update.latestVersion}`)
                .fontSize(14)
                .fontColor('#4A90D9')
                .margin({ top: 4 })

              if (update.changelog) {
                Text(update.changelog)
                  .fontSize(13)
                  .fontColor('#999')
                  .margin({ top: 4 })
              }

              // 更新进度
              if (this.updatingModelId === update.modelId) {
                Progress({ value: this.updateProgress, total: 100, type: ProgressType.Linear })
                  .width('100%')
                  .color('#4A90D9')
                  .margin({ top: 8 })
              }

              // 操作按钮
              Row() {
                Button('更新')
                  .height(36)
                  .fontSize(14)
                  .backgroundColor('#4A90D9')
                  .borderRadius(18)
                  .enabled(this.updatingModelId !== update.modelId)
                  .onClick(() => this.doUpdate(update.modelId))

                Button('回滚')
                  .height(36)
                  .fontSize(14)
                  .backgroundColor('#3d1111')
                  .fontColor('#D0021B')
                  .borderRadius(18)
                  .margin({ left: 8 })
                  .onClick(async () => {
                    await this.versionManager?.rollbackModel(update.modelId);
                  })
              }
              .margin({ top: 8 })
            }
            .width('100%')
            .padding(14)
            .backgroundColor('#1a1a2e')
            .borderRadius(12)
            .margin({ bottom: 8 })
          }, (update: ModelVersionInfo) => update.modelId)
        } else if (!this.isChecking) {
          Text('所有模型均为最新版本 ✓')
            .fontSize(16)
            .fontColor('#4A90D9')
            .margin({ top: 40 })
        }
      }
      .width('100%')
      .padding(20)
    }
    .width('100%')
    .height('100%')
    .backgroundColor('#0d0d1a')
  }
}

3.3 示例三：模型性能监控与A/B测试

实现模型推理性能监控和A/B版本对比测试。

// 模型性能监控与A/B测试服务
import { BusinessError } from '@kit.BasicServicesKit';

// 推理性能指标
interface InferenceMetrics {
  modelId: string;
  modelVersion: string;
  totalInferences: number;     // 总推理次数
  successCount: number;        // 成功次数
  failureCount: number;        // 失败次数
  avgLatencyMs: number;        // 平均延迟
  p50LatencyMs: number;        // P50延迟
  p95LatencyMs: number;        // P95延迟
  p99LatencyMs: number;        // P99延迟
  avgAccuracy: number;         // 平均精度（需人工标注）
  memoryUsageMB: number;       // 内存占用
  timestamp: number;           // 采集时间
}

// A/B测试配置
interface ABTestConfig {
  testId: string;               // 测试ID
  modelA: { modelId: string; version: string; }; // 对照组
  modelB: { modelId: string; version: string; }; // 实验组
  trafficRatio: number;         // B组流量比例 0-1
  duration: number;             // 测试时长(小时)
  metrics: string[];            // 关注的指标
}

// A/B测试结果
interface ABTestResult {
  testId: string;
  metricsA: InferenceMetrics;
  metricsB: InferenceMetrics;
  winner: 'A' | 'B' | 'tie';
  confidence: number;           // 统计置信度
}

// 性能监控器
class ModelPerformanceMonitor {
  private metricsMap: Map<string, InferenceMetrics> = new Map();
  private latencyHistory: Map<string, number[]> = new Map(); // 延迟历史记录

  // 记录一次推理
  recordInference(
    modelId: string,
    version: string,
    latencyMs: number,
    success: boolean,
    accuracy?: number
  ): void {
    const key = `${modelId}@${version}`;

    // 记录延迟历史
    if (!this.latencyHistory.has(key)) {
      this.latencyHistory.set(key, []);
    }
    const history = this.latencyHistory.get(key)!;
    history.push(latencyMs);

    // 只保留最近1000条
    if (history.length > 1000) {
      history.shift();
    }

    // 更新指标
    const existing = this.metricsMap.get(key);
    if (existing) {
      existing.totalInferences++;
      if (success) {
        existing.successCount++;
      } else {
        existing.failureCount++;
      }
      existing.avgLatencyMs = history.reduce((a, b) => a + b, 0) / history.length;
      existing.p50LatencyMs = this.getPercentile(history, 50);
      existing.p95LatencyMs = this.getPercentile(history, 95);
      existing.p99LatencyMs = this.getPercentile(history, 99);
      if (accuracy !== undefined) {
        existing.avgAccuracy = (existing.avgAccuracy * (existing.totalInferences - 1) + accuracy) /
          existing.totalInferences;
      }
      existing.timestamp = Date.now();
    } else {
      this.metricsMap.set(key, {
        modelId: modelId,
        modelVersion: version,
        totalInferences: 1,
        successCount: success ? 1 : 0,
        failureCount: success ? 0 : 1,
        avgLatencyMs: latencyMs,
        p50LatencyMs: latencyMs,
        p95LatencyMs: latencyMs,
        p99LatencyMs: latencyMs,
        avgAccuracy: accuracy || 0,
        memoryUsageMB: 0,
        timestamp: Date.now(),
      });
    }
  }

  // 计算百分位数
  private getPercentile(sortedData: number[], percentile: number): number {
    const sorted = [...sortedData].sort((a, b) => a - b);
    const index = Math.ceil((percentile / 100) * sorted.length) - 1;
    return sorted[Math.max(0, index)];
  }

  // 获取模型指标
  getMetrics(modelId: string, version: string): InferenceMetrics | undefined {
    return this.metricsMap.get(`${modelId}@${version}`);
  }

  // 获取所有指标
  getAllMetrics(): InferenceMetrics[] {
    return Array.from(this.metricsMap.values());
  }

  // A/B测试分析
  analyzeABTest(config: ABTestConfig): ABTestResult | null {
    const keyA = `${config.modelA.modelId}@${config.modelA.version}`;
    const keyB = `${config.modelB.modelId}@${config.modelB.version}`;

    const metricsA = this.metricsMap.get(keyA);
    const metricsB = this.metricsMap.get(keyB);

    if (!metricsA || !metricsB) {
      return null;
    }

    // 简单的统计检验：比较P95延迟和精度
    const latencyImprovement = (metricsA.p95LatencyMs - metricsB.p95LatencyMs) /
      metricsA.p95LatencyMs;
    const accuracyImprovement = metricsB.avgAccuracy - metricsA.avgAccuracy;

    let winner: 'A' | 'B' | 'tie' = 'tie';
    let confidence = 0;

    // B版本延迟更低且精度更高
    if (latencyImprovement > 0.1 && accuracyImprovement > 0.02) {
      winner = 'B';
      confidence = Math.min(latencyImprovement * 5, 0.95);
    } else if (latencyImprovement < -0.1 && accuracyImprovement < -0.02) {
      winner = 'A';
      confidence = Math.min(Math.abs(latencyImprovement) * 5, 0.95);
    }

    return {
      testId: config.testId,
      metricsA: metricsA,
      metricsB: metricsB,
      winner: winner,
      confidence: confidence,
    };
  }
}

// 性能监控面板
@Entry
@Component
struct ModelMonitorPage {
  @State metricsList: InferenceMetrics[] = [];
  @State selectedModel: string = '';
  @State abTestResult: ABTestResult | null = null;

  private monitor: ModelPerformanceMonitor = new ModelPerformanceMonitor();
  private refreshTimer: number = -1;

  aboutToAppear(): void {
    // 模拟一些监控数据
    this.simulateData();

    // 定时刷新
    this.refreshTimer = setInterval(() => {
      this.metricsList = this.monitor.getAllMetrics();
    }, 2000) as number;
  }

  // 模拟推理数据（实际项目中由真实推理产生）
  private simulateData(): void {
    const models = [
      { id: 'ocr-general', version: 'v2.1.0' },
      { id: 'image-classify', version: 'v3.0.0' },
      { id: 'speech-asr', version: 'v1.5.0' },
    ];

    for (const model of models) {
      for (let i = 0; i < 50; i++) {
        const latency = 30 + Math.random() * 120; // 30-150ms
        const accuracy = 0.85 + Math.random() * 0.12; // 85%-97%
        this.monitor.recordInference(model.id, model.version, latency, true, accuracy);
      }
    }

    this.metricsList = this.monitor.getAllMetrics();
  }

  aboutToDisappear(): void {
    if (this.refreshTimer !== -1) {
      clearInterval(this.refreshTimer);
    }
  }

  build() {
    Scroll() {
      Column() {
        Text('模型性能监控')
          .fontSize(24)
          .fontWeight(FontWeight.Bold)
          .fontColor('#e0e0e0')
          .margin({ bottom: 20 })

        // 性能指标卡片
        ForEach(this.metricsList, (metrics: InferenceMetrics) => {
          Column() {
            // 模型名称和版本
            Row() {
              Text(`${metrics.modelId}`)
                .fontSize(16)
                .fontWeight(FontWeight.Bold)
                .fontColor('#e0e0e0')
              Text(`v${metrics.modelVersion}`)
                .fontSize(13)
                .fontColor('#7B68EE')
                .margin({ left: 8 })
            }

            // 关键指标网格
            Row() {
              this.MetricItem('推理次数', `${metrics.totalInferences}`, '#4A90D9')
              this.MetricItem('成功率', `${((metrics.successCount / metrics.totalInferences) * 100).toFixed(1)}%`, '#4A90D9')
              this.MetricItem('P95延迟', `${metrics.p95LatencyMs.toFixed(0)}ms`, '#F5A623')
              this.MetricItem('精度', `${(metrics.avgAccuracy * 100).toFixed(1)}%`, '#7B68EE')
            }
            .width('100%')
            .justifyContent(FlexAlign.SpaceBetween)
            .margin({ top: 10 })
          }
          .width('100%')
          .padding(14)
          .backgroundColor('#1a1a2e')
          .borderRadius(12)
          .margin({ bottom: 8 })
        }, (metrics: InferenceMetrics) => `${metrics.modelId}@${metrics.modelVersion}`)
      }
      .width('100%')
      .padding(20)
    }
    .width('100%')
    .height('100%')
    .backgroundColor('#0d0d1a')
  }

  // 指标项组件
  @Builder
  MetricItem(label: string, value: string, color: string) {
    Column() {
      Text(value)
        .fontSize(18)
        .fontWeight(FontWeight.Bold)
        .fontColor(color)
      Text(label)
        .fontSize(11)
        .fontColor('#666')
        .margin({ top: 2 })
    }
    .alignItems(HorizontalAlign.Center)
  }
}

四、踩坑与注意事项

4.1 模型下载的存储空间检查

下载前一定要检查剩余存储空间。一个模型可能几十MB，如果空间不足会导致下载失败，而且部分下载的临时文件可能不会被自动清理。

// 存储空间检查
import { statvfs } from '@kit.CoreFileKit';

async function checkStorageSpace(requiredMB: number): Promise<boolean> {
  try {
    const path = getContext().filesDir;
    const stat = await statvfs.statvfs(path);
    const freeSpaceMB = (stat.bfree * stat.bsize) / (1024 * 1024);

    if (freeSpaceMB < requiredMB * 1.5) { // 留50%余量
      console.warn(`[Storage] 剩余空间不足: ${freeSpaceMB.toFixed(0)}MB < ${requiredMB}MB`);
      return false;
    }
    return true;
  } catch (error) {
    console.error('[Storage] 空间检查失败');
    return true; // 检查失败时允许继续，避免阻断流程
  }
}

4.2 模型校验与完整性

下载完成后，必须校验模型文件的完整性。网络传输中可能发生数据损坏，使用损坏的模型会导致推理结果异常（不会报错，但结果全是错的，这种bug极难排查）。

// 模型完整性校验
import { hash } from '@kit.BasicServicesKit';

async function verifyModelIntegrity(
  filePath: string,
  expectedHash: string
): Promise<boolean> {
  try {
    const actualHash = await hash.hash(filePath, 'sha256');
    if (actualHash !== expectedHash) {
      console.error(`[Verify] 模型校验失败: 期望${expectedHash}, 实际${actualHash}`);
      return false;
    }
    return true;
  } catch (error) {
    console.error('[Verify] 校验异常');
    return false;
  }
}

4.3 模型热切换的并发问题

热切换模型时，如果有正在进行的推理请求，必须等待其完成后再切换。否则可能导致推理结果混乱或崩溃。

// 安全的热切换
class SafeModelSwapper {
  private activeInferences: number = 0;
  private swapQueue: string[] = [];

  // 推理开始前调用
  beforeInference(): void {
    this.activeInferences++;
  }

  // 推理结束后调用
  afterInference(): void {
    this.activeInferences--;
    // 没有活跃推理时，执行排队的切换
    if (this.activeInferences === 0 && this.swapQueue.length > 0) {
      const modelId = this.swapQueue.shift()!;
      this.doSwap(modelId);
    }
  }

  // 请求热切换
  requestSwap(modelId: string): void {
    if (this.activeInferences > 0) {
      // 有活跃推理，排队等待
      this.swapQueue.push(modelId);
      console.info(`[Swap] 推理中，模型${modelId}切换已排队`);
    } else {
      this.doSwap(modelId);
    }
  }

  private doSwap(modelId: string): void {
    // 执行实际的热切换逻辑
    console.info(`[Swap] 执行模型${modelId}热切换`);
  }
}

4.4 模型共享的引用计数

多个APP共享同一个模型时，删除模型前必须检查引用计数。否则一个APP删除了模型，另一个APP的推理就会失败。

4.5 WiFi与移动网络策略

大模型下载建议只在WiFi下进行：

// 网络类型检查
import { connection } from '@kit.NetworkKit';

async function isWiFiConnected(): Promise<boolean> {
  const netHandle = await connection.getDefaultNet();
  const capabilities = await connection.getNetCapabilities(netHandle);
  return capabilities.bearerTypes.includes(connection.NetBearType.BEARER_WIFI);
}

五、HarmonyOS 6适配

5.1 模型市场新特性

5.2 迁移指南

// HarmonyOS 6 增量更新配置
const updateConfig: mlModelManager.MLModelUpdateConfig = {
  // 启用增量更新
  enableIncrementalUpdate: true,
  // WiFi下自动更新
  autoUpdateOnWiFi: true,
  // 最大更新包大小限制
  maxUpdateSizeMB: 50,
  // 更新完成后自动热切换
  autoHotSwap: true,
};

await this.manager.updateModel(modelId, updateConfig);

5.3 模型加密

HarmonyOS 6支持对下载的模型进行加密保护，防止模型被提取：

// HarmonyOS 6 模型加密配置
import { modelEncryption } from '@hms.core.ml-kit';

const encryptionConfig: modelEncryption.ModelEncryptionConfig = {
  // 使用设备绑定密钥加密
  keySource: modelEncryption.KeySource.DEVICE_BOUND,
  // 加密算法
  algorithm: modelEncryption.Algorithm.AES_256_GCM,
  // 防止模型被复制到其他设备
  bindToDevice: true,
};

六、总结

本文系统讲解了HarmonyOS AI模型市场与模型管理的核心技术，知识点如下：

AI模型市场与模型管理知识图谱
├── 模型市场架构
│   ├── 云端：仓库→审核→CDN分发
│   ├── 端侧：下载→存储→注册→推理
│   ├── 沙箱隔离+共享池
│   └── 安全校验(SHA256)
├── 模型生命周期
│   ├── 上传→审核→发布→下载→注册
│   ├── 调用→版本检查→更新→热切换
│   └── 回滚→退役
├── 模型版本管理
│   ├── 版本检测
│   ├── 增量更新
│   ├── 热切换（不重启APP）
│   ├── 版本回滚
│   └── 推理统计
├── 性能监控
│   ├── 延迟指标(P50/P95/P99)
│   ├── 成功率统计
│   ├── 精度监控
│   ├── A/B测试框架
│   └── 内存占用
├── 踩坑要点
│   ├── 存储空间检查
│   ├── 完整性校验
│   ├── 热切换并发安全
│   ├── 引用计数管理
│   └── WiFi下载策略
└── HarmonyOS 6适配
    ├── ONNX/TFLite格式
    ├── 增量更新
    ├── 系统级共享沙箱
    ├── 模型加密与DRM
    └── 内置A/B测试框架

一句话总结：AI模型市场让HarmonyOS的AI能力实现了"按需获取、独立更新、多应用共享"的现代化管理，模型版本管理和性能监控是保证线上质量的关键基础设施。