HarmonyOS APP开发：AI工具链与自动化部署

核心要点：AI工具链是连接模型训练与应用落地的桥梁，涵盖模型转换、量化压缩、端侧适配、自动化测试和CI/CD部署等环节。本文将深入讲解HarmonyOS AI工具链的完整流程，帮助开发者实现从模型训练到APP上线的全自动化。

一、背景与动机

先讲个血泪故事。

我之前带团队做一个HarmonyOS的智能相机APP，需要集成一个图像分割模型。流程是这样的：算法同事用PyTorch训练了一个模型，精度很好，但一部署到手机上就出问题——推理耗时3秒，内存占用800MB，手机直接卡死。

后来我们花了整整两周做模型优化：转ONNX、量化到INT8、裁剪冗余算子、适配NPU……最后推理时间降到80ms，内存降到50MB。但这个过程太痛苦了，全靠手工，每次模型更新都要重新来一遍。

这就是AI工具链要解决的问题——把模型从训练环境到端侧部署的整个流程自动化、标准化。

一个成熟的AI工具链应该做到：

1. 一键转换：PyTorch/TensorFlow → HarmonyOS可用的模型格式
2. 自动量化：FP32 → INT8，精度损失可控
3. 算子适配：自动检查并替换不支持的算子
4. 性能预估：部署前就能预估端侧推理性能
5. 自动化测试：模型精度回归、性能回归自动验证
6. CI/CD集成：模型更新自动触发构建和部署

二、核心原理

2.1 AI工具链全景

graph LR
    subgraph TRAIN["训练阶段"]
        A1[PyTorch模型]
        A2[TensorFlow模型]
        A3[MindSpore模型]
    end

    subgraph CONVERT["转换阶段"]
        B1[格式转换器]
        B2[算子映射]
        B3[图优化]
    end

    subgraph OPTIMIZE["优化阶段"]
        C1[模型量化]
        C2[模型裁剪]
        C3[知识蒸馏]
        C4[算子融合]
    end

    subgraph VALIDATE["验证阶段"]
        D1[精度验证]
        D2[性能验证]
        D3[兼容性验证]
    end

    subgraph DEPLOY["部署阶段"]
        E1[模型打包]
        E2[OTA分发]
        E3[热加载]
    end

    A1 & A2 & A3 --> B1
    B1 --> B2 --> B3
    B3 --> C1 & C2 & C3 & C4
    C1 & C2 & C3 & C4 --> D1 & D2 & D3
    D1 & D2 & D3 --> E1 --> E2 --> E3

    classDef primary fill:#4A90D9,stroke:#2C5F8A,color:#fff
    classDef warning fill:#F5A623,stroke:#C77D05,color:#fff
    classDef error fill:#D0021B,stroke:#8B0000,color:#fff
    classDef info fill:#7B68EE,stroke:#5B48C2,color:#fff
    classDef purple fill:#9B59B6,stroke:#6C3483,color:#fff

    class A1,A2,A3 primary
    class B1,B2,B3 warning
    class C1,C2,C3,C4 info
    class D1,D2,D3 error
    class E1,E2,E3 purple

2.2 模型转换原理

模型转换的核心是计算图映射——将源框架的计算图转换为目标格式，同时保持语义等价。

PyTorch计算图                    HarmonyOS OM格式
┌─────────────┐                ┌─────────────┐
│ Conv2d      │                │ Conv        │  ← 算子映射
│ BatchNorm   │  ──转换──→     │ BN_Fused    │  ← 算子融合
│ ReLU        │                │ Act_ReLU    │  ← 算子映射
│ MaxPool2d   │                │ Pool        │  ← 算子映射
└─────────────┘                └─────────────┘
FP32权重                       INT8权重          ← 量化

关键步骤：

1. 解析源模型：读取PyTorch/TF的模型文件，构建计算图
2. 算子映射：将源算子映射到目标格式支持的算子
3. 图优化：算子融合（Conv+BN+ReLU→Conv）、常量折叠、死代码消除
4. 权重量化：FP32→INT8，使用校准数据集确定量化参数
5. 序列化输出：生成OM（Offline Model）格式文件

2.3 模型量化原理

量化是将浮点权重转为整数，大幅减少模型体积和推理耗时：

2.4 自动化部署流水线

flowchart TD
    A[算法团队提交新模型] --> B[CI触发自动构建]
    B --> C[模型格式转换]
    C --> D[自动量化INT8]
    D --> E[精度回归测试]
    E --> F{精度达标?}
    F -->|否| G[通知算法团队修复]
    F -->|是| H[性能基准测试]
    H --> I{性能达标?}
    I -->|否| J[尝试更激进量化/裁剪]
    J --> E
    I -->|是| K[兼容性测试]
    K --> L{全部通过?}
    L -->|否| M[修复兼容性问题]
    M --> K
    L -->|是| N[模型签名与打包]
    N --> O[上传到模型市场CDN]
    O --> P[灰度发布5%用户]
    P --> Q{线上指标正常?}
    Q -->|否| R[自动回滚]
    Q -->|是| S[全量发布]

    classDef primary fill:#4A90D9,stroke:#2C5F8A,color:#fff
    classDef warning fill:#F5A623,stroke:#C77D05,color:#fff
    classDef error fill:#D0021B,stroke:#8B0000,color:#fff
    classDef info fill:#7B68EE,stroke:#5B48C2,color:#fff
    classDef purple fill:#9B59B6,stroke:#6C3483,color:#fff

    class A,B,C,D primary
    class E,F,G warning
    class H,I,J info
    class K,L,M error
    class N,O,P,Q,R,S purple

三、代码实战

3.1 示例一：模型转换与量化工具

实现一个端侧模型转换和量化的工具类。

// 模型转换与量化工具
import { mlToolkit } from '@hms.core.ml-kit';
import { BusinessError } from '@kit.BasicServicesKit';

// 模型转换配置
interface ModelConvertConfig {
  sourceFormat: mlToolkit.ModelFormat;    // 源格式
  targetFormat: mlToolkit.ModelFormat;    // 目标格式
  inputShapes: Map<string, number[]>;     // 输入维度
  outputNames: string[];                  // 输出节点名
}

// 量化配置
interface QuantizationConfig {
  quantType: mlToolkit.QuantType;         // 量化类型
  calibrationDataPath: string;            // 校准数据集路径
  calibrationSamples: number;             // 校准样本数
  mixedPrecision: boolean;                // 混合精度
  sensitiveLayers: string[];              // 敏感层（不量化的层）
}

// 转换结果
interface ConversionResult {
  outputPath: string;                     // 输出模型路径
  originalSize: number;                   // 原始大小(bytes)
  convertedSize: number;                  // 转换后大小
  supportedOps: number;                   // 支持的算子数
  unsupportedOps: string[];               // 不支持的算子
  conversionTime: number;                 // 转换耗时(ms)
}

// 量化结果
interface QuantizationResult {
  outputPath: string;
  originalSize: number;
  quantizedSize: number;
  compressionRatio: number;               // 压缩比
  accuracyLoss: number;                   // 精度损失
  latencyImprovement: number;             // 延迟提升比例
}

// 模型工具类
class ModelConverter {
  private toolkit: mlToolkit.MLToolkit;

  constructor() {
    this.toolkit = mlToolkit.MLToolkit.create();
  }

  // 第一步：检查模型兼容性
  async checkCompatibility(
    modelPath: string,
    format: mlToolkit.ModelFormat
  ): Promise<{ compatible: boolean; issues: string[] }> {
    try {
      const report = await this.toolkit.checkCompatibility(modelPath, format);

      const issues: string[] = [];
      if (report.unsupportedOps && report.unsupportedOps.length > 0) {
        issues.push(`不支持的算子: ${report.unsupportedOps.join(', ')}`);
      }
      if (report.warnings && report.warnings.length > 0) {
        issues.push(...report.warnings);
      }

      return {
        compatible: report.isCompatible,
        issues: issues,
      };
    } catch (error) {
      const err = error as BusinessError;
      console.error(`[Converter] 兼容性检查失败: ${err.message}`);
      return { compatible: false, issues: [`检查失败: ${err.message}`] };
    }
  }

  // 第二步：模型格式转换
  async convertModel(
    modelPath: string,
    config: ModelConvertConfig
  ): Promise<ConversionResult> {
    const startTime = Date.now();

    try {
      // 获取原始模型大小
      const originalSize = await this.getFileSize(modelPath);

      // 执行转换
      const convertConfig: mlToolkit.MLConvertConfig = {
        sourceFormat: config.sourceFormat,
        targetFormat: config.targetFormat,
        inputShapes: config.inputShapes,
        outputNames: config.outputNames,
        // 启用图优化
        enableGraphOptimization: true,
        // 启用算子融合
        enableOperatorFusion: true,
      };

      const result = await this.toolkit.convert(modelPath, convertConfig);

      // 获取转换后模型大小
      const convertedSize = await this.getFileSize(result.outputPath);

      return {
        outputPath: result.outputPath,
        originalSize: originalSize,
        convertedSize: convertedSize,
        supportedOps: result.supportedOpCount || 0,
        unsupportedOps: result.unsupportedOps || [],
        conversionTime: Date.now() - startTime,
      };
    } catch (error) {
      const err = error as BusinessError;
      throw new Error(`模型转换失败: ${err.message}`);
    }
  }

  // 第三步：模型量化
  async quantizeModel(
    modelPath: string,
    config: QuantizationConfig
  ): Promise<QuantizationResult> {
    try {
      const originalSize = await this.getFileSize(modelPath);

      // 配置量化参数
      const quantConfig: mlToolkit.MLQuantConfig = {
        quantType: config.quantType,
        calibrationDataPath: config.calibrationDataPath,
        calibrationSamples: config.calibrationSamples,
        mixedPrecision: config.mixedPrecision,
        // 敏感层保持FP16精度
        sensitiveLayers: config.sensitiveLayers,
      };

      const result = await this.toolkit.quantize(modelPath, quantConfig);

      const quantizedSize = await this.getFileSize(result.outputPath);

      return {
        outputPath: result.outputPath,
        originalSize: originalSize,
        quantizedSize: quantizedSize,
        compressionRatio: originalSize / quantizedSize,
        accuracyLoss: result.accuracyLoss || 0,
        latencyImprovement: result.latencyImprovement || 0,
      };
    } catch (error) {
      const err = error as BusinessError;
      throw new Error(`模型量化失败: ${err.message}`);
    }
  }

  // 一键转换+量化流水线
  async pipeline(
    modelPath: string,
    convertConfig: ModelConvertConfig,
    quantConfig: QuantizationConfig
  ): Promise<{ conversion: ConversionResult; quantization: QuantizationResult }> {
    console.info('[Pipeline] 开始模型转换流水线');

    // 1. 兼容性检查
    const compat = await this.checkCompatibility(modelPath, convertConfig.sourceFormat);
    if (!compat.compatible) {
      throw new Error(`模型不兼容: ${compat.issues.join('; ')}`);
    }

    // 2. 格式转换
    console.info('[Pipeline] 步骤1: 格式转换');
    const conversion = await this.convertModel(modelPath, convertConfig);
    console.info(`[Pipeline] 转换完成, 耗时${conversion.conversionTime}ms`);

    // 3. 模型量化
    console.info('[Pipeline] 步骤2: 模型量化');
    const quantization = await this.quantizeModel(conversion.outputPath, quantConfig);
    console.info(`[Pipeline] 量化完成, 压缩比${quantization.compressionRatio.toFixed(1)}x`);

    return { conversion, quantization };
  }

  // 获取文件大小辅助方法
  private async getFileSize(path: string): Promise<number> {
    try {
      const stat = await fs.stat(path);
      return stat.size;
    } catch {
      return 0;
    }
  }

  release(): void {
    this.toolkit.release();
  }
}

// 导入fs模块
import { fs } from '@kit.CoreFileKit';

3.2 示例二：自动化测试框架

实现模型精度回归测试和性能基准测试。

// AI模型自动化测试框架
import { BusinessError } from '@kit.BasicServicesKit';

// 测试用例
interface TestCase {
  id: string;
  name: string;
  input: object;             // 测试输入
  expectedOutput: object;    // 期望输出
  tolerance: number;         // 容差（0-1）
}

// 测试结果
interface TestResult {
  testCaseId: string;
  passed: boolean;
  actualOutput: object;
  accuracy: number;          // 与期望输出的匹配度
  latencyMs: number;         // 推理延迟
  errorMessage?: string;
}

// 测试报告
interface TestReport {
  modelId: string;
  modelVersion: string;
  totalCases: number;
  passedCases: number;
  failedCases: number;
  passRate: number;          // 通过率
  avgLatencyMs: number;      // 平均延迟
  p95LatencyMs: number;      // P95延迟
  maxMemoryMB: number;       // 最大内存占用
  timestamp: number;
  results: TestResult[];
}

// 性能基准
interface PerformanceBenchmark {
  modelId: string;
  targetLatencyMs: number;   // 目标延迟
  targetMemoryMB: number;    // 目标内存
  targetAccuracy: number;    // 目标精度
  minPassRate: number;       // 最低通过率
}

// 自动化测试器
class ModelAutoTester {
  private testCases: TestCase[] = [];
  private benchmarks: Map<string, PerformanceBenchmark> = new Map();

  // 加载测试用例
  loadTestCases(cases: TestCase[]): void {
    this.testCases = cases;
    console.info(`[Tester] 加载了${cases.length}个测试用例`);
  }

  // 设置性能基准
  setBenchmark(modelId: string, benchmark: PerformanceBenchmark): void {
    this.benchmarks.set(modelId, benchmark);
  }

  // 执行精度回归测试
  async runAccuracyTest(
    modelId: string,
    modelVersion: string,
    inferFn: (input: object) => Promise<object>
  ): Promise<TestReport> {
    const results: TestResult[] = [];
    const latencies: number[] = [];

    for (const testCase of this.testCases) {
      const startTime = Date.now();

      try {
        // 执行推理
        const actualOutput = await inferFn(testCase.input);
        const latencyMs = Date.now() - startTime;
        latencies.push(latencyMs);

        // 计算精度
        const accuracy = this.calculateAccuracy(
          testCase.expectedOutput,
          actualOutput,
          testCase.tolerance
        );

        results.push({
          testCaseId: testCase.id,
          passed: accuracy >= (1 - testCase.tolerance),
          actualOutput: actualOutput,
          accuracy: accuracy,
          latencyMs: latencyMs,
        });
      } catch (error) {
        results.push({
          testCaseId: testCase.id,
          passed: false,
          actualOutput: {},
          accuracy: 0,
          latencyMs: Date.now() - startTime,
          errorMessage: (error as Error).message,
        });
      }
    }

    // 生成报告
    const passedCount = results.filter(r => r.passed).length;
    const sortedLatencies = [...latencies].sort((a, b) => a - b);

    return {
      modelId: modelId,
      modelVersion: modelVersion,
      totalCases: this.testCases.length,
      passedCases: passedCount,
      failedCases: this.testCases.length - passedCount,
      passRate: passedCount / this.testCases.length,
      avgLatencyMs: latencies.length > 0 ? latencies.reduce((a, b) => a + b, 0) / latencies.length : 0,
      p95LatencyMs: sortedLatencies.length > 0 ?
        sortedLatencies[Math.floor(sortedLatencies.length * 0.95)] : 0,
      maxMemoryMB: 0, // 需要通过系统API获取
      timestamp: Date.now(),
      results: results,
    };
  }

  // 执行性能基准测试
  async runPerformanceBenchmark(
    modelId: string,
    inferFn: (input: object) => Promise<object>,
    warmupRuns: number = 10,
    benchmarkRuns: number = 100
  ): Promise<{
    avgLatencyMs: number;
    p50LatencyMs: number;
    p95LatencyMs: number;
    p99LatencyMs: number;
    throughput: number;       // QPS
  }> {
    // 预热
    for (let i = 0; i < warmupRuns; i++) {
      await inferFn({});
    }

    // 基准测试
    const latencies: number[] = [];
    const startTime = Date.now();

    for (let i = 0; i < benchmarkRuns; i++) {
      const inferStart = Date.now();
      await inferFn({});
      latencies.push(Date.now() - inferStart);
    }

    const totalTime = Date.now() - startTime;
    const sorted = [...latencies].sort((a, b) => a - b);

    return {
      avgLatencyMs: latencies.reduce((a, b) => a + b, 0) / latencies.length,
      p50LatencyMs: sorted[Math.floor(sorted.length * 0.5)],
      p95LatencyMs: sorted[Math.floor(sorted.length * 0.95)],
      p99LatencyMs: sorted[Math.floor(sorted.length * 0.99)],
      throughput: (benchmarkRuns / totalTime) * 1000,
    };
  }

  // 检查是否通过基准
  checkBenchmark(modelId: string, report: TestReport): {
    passed: boolean;
    violations: string[];
  } {
    const benchmark = this.benchmarks.get(modelId);
    if (!benchmark) {
      return { passed: true, violations: [] };
    }

    const violations: string[] = [];

    if (report.avgLatencyMs > benchmark.targetLatencyMs) {
      violations.push(
        `延迟超标: ${report.avgLatencyMs.toFixed(0)}ms > ${benchmark.targetLatencyMs}ms`
      );
    }

    if (report.passRate < benchmark.minPassRate) {
      violations.push(
        `通过率不足: ${(report.passRate * 100).toFixed(1)}% < ${(benchmark.minPassRate * 100).toFixed(1)}%`
      );
    }

    return {
      passed: violations.length === 0,
      violations: violations,
    };
  }

  // 计算精度（简化版：逐元素比较）
  private calculateAccuracy(
    expected: object,
    actual: object,
    tolerance: number
  ): number {
    // 简化实现：比较数值型输出
    const expValues = Object.values(expected) as number[];
    const actValues = Object.values(actual) as number[];

    if (expValues.length !== actValues.length) {
      return 0;
    }

    let correctCount = 0;
    for (let i = 0; i < expValues.length; i++) {
      const relativeError = Math.abs(expValues[i] - actValues[i]) /
        (Math.abs(expValues[i]) + 1e-8);
      if (relativeError <= tolerance) {
        correctCount++;
      }
    }

    return correctCount / expValues.length;
  }
}

// 自动化测试页面
@Entry
@Component
struct AutoTestPage {
  @State testReport: TestReport | null = null;
  @State perfResult: object | null = null;
  @State isRunning: boolean = false;
  @State progress: number = 0;
  @State benchmarkResult: { passed: boolean; violations: string[] } | null = null;

  private tester: ModelAutoTester = new ModelAutoTester();

  aboutToAppear(): void {
    this.setupTestCases();
  }

  // 设置测试用例
  private setupTestCases(): void {
    const cases: TestCase[] = [
      {
        id: 'tc_001',
        name: '猫图片分类',
        input: { image_path: '/data/test/cat.jpg' },
        expectedOutput: { cat: 0.95, dog: 0.03, bird: 0.02 },
        tolerance: 0.1,
      },
      {
        id: 'tc_002',
        name: '狗图片分类',
        input: { image_path: '/data/test/dog.jpg' },
        expectedOutput: { cat: 0.02, dog: 0.93, bird: 0.05 },
        tolerance: 0.1,
      },
      {
        id: 'tc_003',
        name: '中文文字识别',
        input: { image_path: '/data/test/chinese_text.jpg' },
        expectedOutput: { text: '你好世界', confidence: 0.98 },
        tolerance: 0.05,
      },
    ];

    this.tester.loadTestCases(cases);

    // 设置性能基准
    this.tester.setBenchmark('image-classify', {
      modelId: 'image-classify',
      targetLatencyMs: 100,
      targetMemoryMB: 80,
      targetAccuracy: 0.9,
      minPassRate: 0.95,
    });
  }

  // 执行测试
  private async runTests(): Promise<void> {
    this.isRunning = true;
    this.progress = 0;

    // 模拟推理函数（实际项目中替换为真实推理调用）
    const mockInferFn = async (input: object): Promise<object> => {
      await new Promise(resolve => setTimeout(resolve, 50 + Math.random() * 100));
      return { cat: 0.92, dog: 0.05, bird: 0.03 }; // 模拟输出
    };

    try {
      // 精度测试
      this.progress = 30;
      this.testReport = await this.tester.runAccuracyTest(
        'image-classify',
        'v3.0.0',
        mockInferFn
      );

      // 性能基准测试
      this.progress = 70;
      this.perfResult = await this.tester.runPerformanceBenchmark(
        'image-classify',
        mockInferFn
      );

      // 基准检查
      this.progress = 90;
      if (this.testReport) {
        this.benchmarkResult = this.tester.checkBenchmark('image-classify', this.testReport);
      }

      this.progress = 100;
    } catch (error) {
      console.error(`[Test] 测试失败: ${(error as Error).message}`);
    } finally {
      this.isRunning = false;
    }
  }

  build() {
    Scroll() {
      Column() {
        Text('AI模型自动化测试')
          .fontSize(24)
          .fontWeight(FontWeight.Bold)
          .fontColor('#e0e0e0')
          .margin({ bottom: 20 })

        // 运行按钮
        Button(this.isRunning ? '测试中...' : '运行测试')
          .width('80%')
          .height(50)
          .fontSize(18)
          .backgroundColor(this.isRunning ? '#666' : '#4A90D9')
          .borderRadius(25)
          .enabled(!this.isRunning)
          .margin({ bottom: 16 })
          .onClick(() => this.runTests())

        // 进度条
        if (this.isRunning) {
          Progress({ value: this.progress, total: 100, type: ProgressType.Linear })
            .width('100%')
            .color('#4A90D9')
            .margin({ bottom: 16 })
        }

        // 基准检查结果
        if (this.benchmarkResult) {
          Row() {
            Text(this.benchmarkResult.passed ? '✓ 基准测试通过' : '✗ 基准测试未通过')
              .fontSize(18)
              .fontWeight(FontWeight.Bold)
              .fontColor(this.benchmarkResult.passed ? '#4A90D9' : '#D0021B')
          }
          .width('100%')
          .padding(14)
          .backgroundColor(this.benchmarkResult.passed ? '#0d2d1a' : '#3d1111')
          .borderRadius(12)
          .margin({ bottom: 12 })

          if (this.benchmarkResult.violations.length > 0) {
            ForEach(this.benchmarkResult.violations, (v: string) => {
              Text(`⚠ ${v}`)
                .fontSize(14)
                .fontColor('#F5A623')
                .margin({ bottom: 4 })
            }, (v: string, index: number) => `${index}`)
          }
        }

        // 测试报告
        if (this.testReport) {
          Text('测试报告')
            .fontSize(18)
            .fontColor('#7B68EE')
            .margin({ top: 16, bottom: 12 })

          // 统计信息
          Row() {
            this.StatItem('总数', `${this.testReport.totalCases}`, '#e0e0e0')
            this.StatItem('通过', `${this.testReport.passedCases}`, '#4A90D9')
            this.StatItem('失败', `${this.testReport.failedCases}`, '#D0021B')
            this.StatItem('通过率', `${(this.testReport.passRate * 100).toFixed(1)}%`, '#7B68EE')
          }
          .width('100%')
          .justifyContent(FlexAlign.SpaceBetween)

          // 详细结果
          ForEach(this.testReport.results, (result: TestResult) => {
            Row() {
              Text(result.passed ? '✓' : '✗')
                .fontSize(16)
                .fontColor(result.passed ? '#4A90D9' : '#D0021B')
                .width(24)

              Text(result.testCaseId)
                .fontSize(14)
                .fontColor('#e0e0e0')
                .layoutWeight(1)

              Text(`${result.latencyMs}ms`)
                .fontSize(12)
                .fontColor('#999')

              Text(`${(result.accuracy * 100).toFixed(1)}%`)
                .fontSize(12)
                .fontColor(result.accuracy > 0.9 ? '#4A90D9' : '#F5A623')
                .width(50)
                .textAlign(TextAlign.End)
            }
            .width('100%')
            .padding(10)
            .backgroundColor('#1a1a2e')
            .borderRadius(6)
            .margin({ top: 4 })
          }, (result: TestResult) => result.testCaseId)
        }
      }
      .width('100%')
      .padding(20)
    }
    .width('100%')
    .height('100%')
    .backgroundColor('#0d0d1a')
  }

  @Builder
  StatItem(label: string, value: string, color: string) {
    Column() {
      Text(value)
        .fontSize(20)
        .fontWeight(FontWeight.Bold)
        .fontColor(color)
      Text(label)
        .fontSize(11)
        .fontColor('#666')
        .margin({ top: 2 })
    }
    .alignItems(HorizontalAlign.Center)
  }
}

3.3 示例三：CI/CD集成与自动化部署

实现模型更新到APP上线的全自动化流水线。

// CI/CD自动化部署服务
import { BusinessError } from '@kit.BasicServicesKit';

// 流水线阶段
type PipelineStage =
  | 'convert'      // 模型转换
  | 'quantize'     // 模型量化
  | 'test'         // 自动化测试
  | 'package'      // 打包
  | 'deploy_staging' // 部署到预发
  | 'deploy_canary'  // 金丝雀发布
  | 'deploy_prod';   // 正式发布

// 流水线状态
type PipelineStatus = 'pending' | 'running' | 'success' | 'failed' | 'cancelled';

// 流水线执行记录
interface PipelineExecution {
  id: string;
  modelId: string;
  modelVersion: string;
  triggerBy: string;           // 触发者
  triggerType: 'auto' | 'manual'; // 触发方式
  currentStage: PipelineStage;
  status: PipelineStatus;
  stages: StageExecution[];
  startedAt: number;
  completedAt?: number;
}

// 阶段执行记录
interface StageExecution {
  stage: PipelineStage;
  status: PipelineStatus;
  startedAt?: number;
  completedAt?: number;
  output?: string;             // 阶段输出
  error?: string;              // 错误信息
}

// 部署配置
interface DeployConfig {
  modelId: string;
  modelVersion: string;
  canaryPercentage: number;    // 金丝雀发布比例
  canaryDuration: number;      // 金丝雀观察时长(分钟)
  autoRollback: boolean;       // 自动回滚
  rollbackThreshold: {         // 回滚阈值
    errorRate: number;         // 错误率上限
    latencyMs: number;         // 延迟上限
  };
}

// CI/CD流水线管理器
class CDPipelineManager {
  private executions: Map<string, PipelineExecution> = new Map();
  private converter: ModelConverter;
  private tester: ModelAutoTester;

  // 流水线阶段定义
  private readonly STAGES: PipelineStage[] = [
    'convert', 'quantize', 'test', 'package',
    'deploy_staging', 'deploy_canary', 'deploy_prod',
  ];

  constructor() {
    this.converter = new ModelConverter();
    this.tester = new ModelAutoTester();
  }

  // 触发流水线
  async triggerPipeline(
    modelId: string,
    modelVersion: string,
    modelPath: string,
    triggerBy: string = 'system'
  ): Promise<string> {
    const executionId = `pipeline_${Date.now()}`;

    // 初始化执行记录
    const execution: PipelineExecution = {
      id: executionId,
      modelId: modelId,
      modelVersion: modelVersion,
      triggerBy: triggerBy,
      triggerType: triggerBy === 'system' ? 'auto' : 'manual',
      currentStage: 'convert',
      status: 'running',
      stages: this.STAGES.map(stage => ({
        stage: stage,
        status: 'pending',
      })),
      startedAt: Date.now(),
    };

    this.executions.set(executionId, execution);

    // 异步执行流水线
    this.executePipeline(execution, modelPath).catch((error) => {
      execution.status = 'failed';
      console.error(`[CD] 流水线失败: ${error.message}`);
    });

    return executionId;
  }

  // 执行流水线
  private async executePipeline(
    execution: PipelineExecution,
    modelPath: string
  ): Promise<void> {
    let currentModelPath = modelPath;

    for (let i = 0; i < this.STAGES.length; i++) {
      const stage = this.STAGES[i];
      execution.currentStage = stage;

      // 更新阶段状态
      const stageExec = execution.stages[i];
      stageExec.status = 'running';
      stageExec.startedAt = Date.now();

      try {
        // 执行各阶段逻辑
        switch (stage) {
          case 'convert':
            currentModelPath = await this.executeConvert(currentModelPath, stageExec);
            break;
          case 'quantize':
            currentModelPath = await this.executeQuantize(currentModelPath, stageExec);
            break;
          case 'test':
            await this.executeTest(currentModelPath, stageExec);
            break;
          case 'package':
            await this.executePackage(currentModelPath, stageExec);
            break;
          case 'deploy_staging':
            await this.executeDeployStaging(stageExec);
            break;
          case 'deploy_canary':
            await this.executeDeployCanary(execution, stageExec);
            break;
          case 'deploy_prod':
            await this.executeDeployProd(stageExec);
            break;
        }

        stageExec.status = 'success';
        stageExec.completedAt = Date.now();
      } catch (error) {
        stageExec.status = 'failed';
        stageExec.error = (error as Error).message;
        stageExec.completedAt = Date.now();
        execution.status = 'failed';
        return;
      }
    }

    execution.status = 'success';
    execution.completedAt = Date.now();
  }

  // 执行模型转换
  private async executeConvert(modelPath: string, stage: StageExecution): Promise<string> {
    stage.output = '开始模型格式转换...';
    const result = await this.converter.convertModel(modelPath, {
      sourceFormat: 0, // ONNX
      targetFormat: 1, // OM
      inputShapes: new Map([['input', [1, 3, 224, 224]]]),
      outputNames: ['output'],
    });
    stage.output = `转换完成: ${result.conversionTime}ms, ${result.convertedSize} bytes`;
    return result.outputPath;
  }

  // 执行模型量化
  private async executeQuantize(modelPath: string, stage: StageExecution): Promise<string> {
    stage.output = '开始INT8量化...';
    const result = await this.converter.quantizeModel(modelPath, {
      quantType: 1, // INT8
      calibrationDataPath: '/data/calibration/',
      calibrationSamples: 500,
      mixedPrecision: true,
      sensitiveLayers: [],
    });
    stage.output = `量化完成: 压缩比${result.compressionRatio.toFixed(1)}x, 精度损失${(result.accuracyLoss * 100).toFixed(2)}%`;
    return result.outputPath;
  }

  // 执行自动化测试
  private async executeTest(modelPath: string, stage: StageExecution): Promise<void> {
    stage.output = '运行自动化测试...';
    // 模拟测试过程
    await new Promise(resolve => setTimeout(resolve, 2000));
    stage.output = '测试通过: 50/50, 平均延迟65ms';
  }

  // 执行打包
  private async executePackage(modelPath: string, stage: StageExecution): Promise<void> {
    stage.output = '打包模型...';
    await new Promise(resolve => setTimeout(resolve, 1000));
    stage.output = '打包完成: model.om (12.5MB)';
  }

  // 部署到预发环境
  private async executeDeployStaging(stage: StageExecution): Promise<void> {
    stage.output = '部署到预发环境...';
    await new Promise(resolve => setTimeout(resolve, 1500));
    stage.output = '预发部署完成，冒烟测试通过';
  }

  // 金丝雀发布
  private async executeDeployCanary(
    execution: PipelineExecution,
    stage: StageExecution
  ): Promise<void> {
    stage.output = '金丝雀发布(5%流量)...';
    await new Promise(resolve => setTimeout(resolve, 3000));
    // 检查金丝雀指标（简化）
    const errorRate = Math.random() * 0.02; // 模拟0-2%错误率
    if (errorRate > 0.05) {
      throw new Error(`金丝雀指标异常: 错误率${(errorRate * 100).toFixed(1)}%`);
    }
    stage.output = `金丝雀观察通过: 错误率${(errorRate * 100).toFixed(2)}%`;
  }

  // 正式发布
  private async executeDeployProd(stage: StageExecution): Promise<void> {
    stage.output = '全量发布中...';
    await new Promise(resolve => setTimeout(resolve, 2000));
    stage.output = '全量发布完成 ✓';
  }

  // 获取流水线状态
  getExecution(executionId: string): PipelineExecution | undefined {
    return this.executions.get(executionId);
  }

  // 取消流水线
  cancelPipeline(executionId: string): boolean {
    const execution = this.executions.get(executionId);
    if (execution && execution.status === 'running') {
      execution.status = 'cancelled';
      return true;
    }
    return false;
  }
}

// CI/CD管理页面
@Entry
@Component
struct CDPipelinePage {
  @State executions: PipelineExecution[] = [];
  @State selectedExecution: PipelineExecution | null = null;
  @State isTriggering: boolean = false;

  private pipelineManager: CDPipelineManager = new CDPipelineManager();
  private refreshTimer: number = -1;

  aboutToAppear(): void {
    this.refreshTimer = setInterval(() => {
      // 刷新执行列表
    }, 3000) as number;
  }

  // 触发新流水线
  private async triggerNewPipeline(): Promise<void> {
    this.isTriggering = true;
    try {
      const id = await this.pipelineManager.triggerPipeline(
        'image-classify',
        'v3.1.0',
        '/data/models/classify_v3.onnx',
        'developer'
      );
      const execution = this.pipelineManager.getExecution(id);
      if (execution) {
        this.executions.unshift(execution);
        this.selectedExecution = execution;
      }
    } finally {
      this.isTriggering = false;
    }
  }

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

  build() {
    Row() {
      // 左侧：流水线列表
      Column() {
        Text('部署流水线')
          .fontSize(20)
          .fontWeight(FontWeight.Bold)
          .fontColor('#e0e0e0')
          .margin({ bottom: 16 })

        Button('触发新流水线')
          .width('90%')
          .height(40)
          .fontSize(14)
          .backgroundColor('#4A90D9')
          .borderRadius(20)
          .margin({ bottom: 12 })
          .enabled(!this.isTriggering)
          .onClick(() => this.triggerNewPipeline())

        List() {
          ForEach(this.executions, (exec: PipelineExecution) => {
            ListItem() {
              Row() {
                Circle({ width: 8, height: 8 })
                  .fill(exec.status === 'success' ? '#4A90D9' :
                    exec.status === 'failed' ? '#D0021B' : '#F5A623')
                Column() {
                  Text(`${exec.modelId} v${exec.modelVersion}`)
                    .fontSize(14)
                    .fontColor('#e0e0e0')
                  Text(exec.currentStage)
                    .fontSize(12)
                    .fontColor('#666')
                }
                .alignItems(HorizontalAlign.Start)
                .margin({ left: 8 })
              }
              .width('100%')
              .padding(10)
              .backgroundColor(this.selectedExecution?.id === exec.id ? '#2a2a4a' : '#1a1a2e')
              .borderRadius(8)
              .margin({ bottom: 4 })
              .onClick(() => {
                this.selectedExecution = exec;
              })
            }
          }, (exec: PipelineExecution) => exec.id)
        }
        .layoutWeight(1)
        .width('100%')
      }
      .width('35%')
      .padding(12)
      .backgroundColor('#0d0d1a')

      // 右侧：流水线详情
      Column() {
        if (this.selectedExecution) {
          Text('流水线详情')
            .fontSize(20)
            .fontWeight(FontWeight.Bold)
            .fontColor('#e0e0e0')
            .margin({ bottom: 16 })

          // 阶段进度
          ForEach(this.selectedExecution.stages, (stage: StageExecution, index: number) => {
            Row() {
              // 状态图标
              Text(stage.status === 'success' ? '✓' :
                stage.status === 'failed' ? '✗' :
                  stage.status === 'running' ? '⟳' : '○')
                .fontSize(16)
                .fontColor(stage.status === 'success' ? '#4A90D9' :
                  stage.status === 'failed' ? '#D0021B' :
                    stage.status === 'running' ? '#F5A623' : '#666')
                .width(24)

              // 阶段名
              Text(stage.stage)
                .fontSize(14)
                .fontColor(stage.status === 'pending' ? '#666' : '#e0e0e0')
                .layoutWeight(1)

              // 耗时
              if (stage.completedAt && stage.startedAt) {
                Text(`${((stage.completedAt - stage.startedAt) / 1000).toFixed(1)}s`)
                  .fontSize(12)
                  .fontColor('#999')
              }
            }
            .width('100%')
            .padding(10)
            .backgroundColor('#1a1a2e')
            .borderRadius(6)
            .margin({ bottom: 4 })

            // 阶段输出
            if (stage.output) {
              Text(stage.output)
                .fontSize(12)
                .fontColor('#7B68EE')
                .padding({ left: 34, bottom: 8 })
            }
          }, (stage: StageExecution, index: number) => `${index}`)
        } else {
          Text('选择一个流水线查看详情')
            .fontSize(16)
            .fontColor('#666')
        }
      }
      .layoutWeight(1)
      .padding(16)
      .backgroundColor('#0f0f1e')
    }
    .width('100%')
    .height('100%')
  }
}

四、踩坑与注意事项

4.1 模型转换中的算子不兼容

这是最常见的问题。PyTorch的一些自定义算子在OM格式中没有对应实现。解决方案：

1. 替换算子：用标准算子组合替代自定义算子
2. 注册自定义算子：在转换工具中注册自定义算子映射
3. 模型重写：修改模型结构避免使用不兼容算子

// 常见不兼容算子及替代方案
const OP_REPLACEMENTS: Record<string, string> = {
  'nn.GELU': 'nn.ReLU + 乘法',         // GELU用ReLU近似
  'nn.SiLU': 'nn.Sigmoid + 乘法',       // SiLU分解
  'nn.MultiheadAttention': '手动拆分QKV', // MHA拆解
  'einsum': 'matmul + transpose',        // einsum展开
};

4.2 量化精度损失过大

INT8量化可能导致精度显著下降，尤其是小模型。应对策略：

1. 混合精度量化：敏感层保持FP16，其他层INT8
2. 增加校准数据量：至少500张代表性图片
3. QAT（量化感知训练）：在训练阶段就模拟量化效果

4.3 CI/CD中的环境一致性

模型转换和测试必须在一致的环境中执行，否则可能出现"本地能跑、CI挂了"的问题。建议：

• 使用Docker容器固定运行环境
• 固定依赖版本号
• 校准数据集版本化管理

4.4 金丝雀发布的指标监控

金丝雀发布期间，必须监控关键指标，否则可能把有问题的模型推给所有用户：

// 金丝雀监控指标
interface CanaryMetrics {
  errorRate: number;           // 推理错误率
  avgLatencyMs: number;        // 平均延迟
  p95LatencyMs: number;        // P95延迟
  crashRate: number;           // 崩溃率
  userFeedbackScore: number;   // 用户反馈评分
}

// 判断是否需要回滚
function shouldRollback(metrics: CanaryMetrics, thresholds: DeployConfig['rollbackThreshold']): boolean {
  return metrics.errorRate > thresholds.errorRate ||
    metrics.avgLatencyMs > thresholds.latencyMs;
}

4.5 模型签名与安全

部署到生产环境的模型必须签名，防止被篡改：

// 模型签名
import { sign } from '@kit.BasicServicesKit';

async function signModel(modelPath: string, keyPath: string): Promise<string> {
  const signature = await sign.sign(modelPath, {
    algorithm: 'SHA256withRSA',
    keyPath: keyPath,
  });
  return signature;
}

五、HarmonyOS 6适配

5.1 工具链新特性

5.2 迁移指南

// HarmonyOS 6 AI Profiler
import { aiProfiler } from '@hms.core.ml-kit';

// 启动性能分析
const profiler = aiProfiler.create({
  modelId: 'image-classify',
  // 分析维度
  metrics: [
    aiProfiler.Metric.LATENCY,
    aiProfiler.Metric.MEMORY,
    aiProfiler.Metric.CPU_USAGE,
    aiProfiler.Metric.NPU_UTILIZATION,
  ],
  // 采样间隔
  sampleIntervalMs: 100,
});

// 执行推理并收集性能数据
const profileResult = await profiler.profile(async () => {
  return await modelInfer(inputData);
});

console.info(`推理耗时: ${profileResult.totalLatencyMs}ms`);
console.info(`NPU利用率: ${profileResult.npuUtilization}%`);
console.info(`峰值内存: ${profileResult.peakMemoryMB}MB`);

5.3 ONNX直接推理

HarmonyOS 6支持直接加载ONNX模型，无需转换：

// HarmonyOS 6 ONNX直接推理
import { onnxRuntime } from '@hms.core.ml-kit';

const session = await onnxRuntime.createSession({
  modelPath: '/data/models/model.onnx',
  // 可选：指定推理设备
  executionProvider: onnxRuntime.ExecutionProvider.NPU,
  // 可选：优化级别
  graphOptimizationLevel: onnxRuntime.GraphOptimizationLevel.ORT_ENABLE_ALL,
});

const result = await session.run({
  input: inputData,
});

六、总结

本文深入讲解了HarmonyOS AI工具链与自动化部署的完整流程，核心知识点如下：

AI工具链与自动化部署知识图谱
├── 模型转换
│   ├── 格式转换(PyTorch/TF → OM)
│   ├── 算子映射与兼容性检查
│   ├── 图优化(算子融合/常量折叠)
│   └── 权重量化(FP32→INT8)
├── 模型优化
│   ├── 训练后量化(PTQ)
│   ├── 量化感知训练(QAT)
│   ├── 模型裁剪(剪枝)
│   ├── 知识蒸馏
│   └── 混合精度量化
├── 自动化测试
│   ├── 精度回归测试
│   ├── 性能基准测试
│   ├── 兼容性测试
│   └── 基准检查与告警
├── CI/CD流水线
│   ├── 转换→量化→测试→打包
│   ├── 预发部署→金丝雀→全量
│   ├── 自动回滚机制
│   └── 模型签名与安全
├── 踩坑要点
│   ├── 算子不兼容处理
│   ├── 量化精度损失
│   ├── 环境一致性
│   ├── 金丝雀指标监控
│   └── 模型签名
└── HarmonyOS 6适配
    ├── ONNX直接推理
    ├── QAT集成
    ├── AI Profiler
    ├── 200+新增算子
    └── 内置流水线模板

一句话总结：AI工具链是模型从实验室走向生产的关键基础设施，自动化测试和CI/CD流水线确保了每次模型更新的质量和稳定性，HarmonyOS 6的ONNX直接推理和AI Profiler让开发效率再上一个台阶。