端云AI模型结果比对器设计与实现原创

进修的泡芙

发布于 2025-6-16 19:00

浏览

0收藏

端云AI模型结果比对器设计与实现

一、项目概述

基于HarmonyOS 5异构计算调度能力构建的端云AI模型结果比对系统，专门用于验证同一AI模型在端侧和云侧执行的推理结果差异。该系统借鉴《鸿蒙跨端U同步》中游戏场景的多设备数据同步机制，确保AI推理结果在不同计算环境中的一致性，为模型部署提供质量保障。

二、核心架构设计

±--------------------+
模型输入生成器
(Input Generator)

±---------±---------+
±---------v----------+ ±--------------------+

异构计算调度器 <—> 云侧推理服务
(Hetero Scheduler) (Cloud Inference)

±---------±---------+ ±--------------------+
±---------v----------+

结果比对引擎
(Result Comparator)

±--------------------+

三、异构计算调度实现

// 异构计算调度服务
public class HeterogeneousScheduler {
private static final String TAG = “HeteroScheduler”;
private Context context;
private ExecutorService localExecutor;
private CloudInferenceClient cloudClient;

public HeterogeneousScheduler(Context context) {
    this.context = context;
    this.localExecutor = Executors.newSingleThreadExecutor();
    this.cloudClient = new CloudInferenceClient();

// 调度端云并行推理

public void scheduleDualInference(ModelInput input, InferenceCallback callback) {
    // 1. 在端侧设备上启动推理
    CompletableFuture<ModelOutput> localFuture = CompletableFuture.supplyAsync(() -> {
        return runLocalInference(input);
    }, localExecutor);
    
    // 2. 在云侧并行启动推理
    CompletableFuture<ModelOutput> cloudFuture = CompletableFuture.supplyAsync(() -> {
        return runCloudInference(input);
    });
    
    // 3. 合并结果
    CompletableFuture<Void> combinedFuture = CompletableFuture.allOf(localFuture, cloudFuture);
    
    combinedFuture.thenRun(() -> {
        try {
            ModelOutput localOutput = localFuture.get();
            ModelOutput cloudOutput = cloudFuture.get();
            callback.onInferenceComplete(localOutput, cloudOutput);

catch (Exception e) {

            callback.onError(e);

});

// 执行端侧推理

private ModelOutput runLocalInference(ModelInput input) {
    long startTime = System.currentTimeMillis();
    
    // 使用HarmonyOS AI框架执行推理
    AiModel model = new AiModel(context, "model.hdf");
    ModelOutput output = model.run(input);
    
    long endTime = System.currentTimeMillis();
    output.setInferenceTime(endTime - startTime);
    output.setComputeLocation("Device");
    
    return output;

// 执行云侧推理

private ModelOutput runCloudInference(ModelInput input) {
    long startTime = System.currentTimeMillis();
    
    // 调用云端推理服务
    ModelOutput output = cloudClient.infer("model_v1", input);
    
    long endTime = System.currentTimeMillis();
    output.setInferenceTime(endTime - startTime);
    output.setComputeLocation("Cloud");
    
    return output;

public interface InferenceCallback {

    void onInferenceComplete(ModelOutput localOutput, ModelOutput cloudOutput);
    void onError(Exception e);

}

四、结果比对引擎实现

public class ResultComparator {
private static final float FLOAT_TOLERANCE = 0.0001f;

// 比对分类模型结果
public ComparisonResult compareClassificationOutputs(ModelOutput local, ModelOutput cloud) {
    ComparisonResult result = new ComparisonResult();
    
    // 比对top1类别
    String localTop1 = local.getTopClass();
    String cloudTop1 = cloud.getTopClass();
    result.setTopClassMatch(localTop1.equals(cloudTop1));
    
    // 比对top1概率
    float localProb = local.getTopProbability();
    float cloudProb = cloud.getTopProbability();
    result.setProbabilityDiff(Math.abs(localProb - cloudProb));
    
    // 比对类别分布
    Map<String, Float> localProbs = local.getClassProbabilities();
    Map<String, Float> cloudProbs = cloud.getClassProbabilities();
    result.setDistributionSimilarity(
        calculateDistributionSimilarity(localProbs, cloudProbs)
    );
    
    return result;

// 比对目标检测模型结果

public ComparisonResult compareDetectionOutputs(ModelOutput local, ModelOutput cloud) {
    ComparisonResult result = new ComparisonResult();
    
    // 比对检测框数量
    List<BoundingBox> localBoxes = local.getDetectionBoxes();
    List<BoundingBox> cloudBoxes = cloud.getDetectionBoxes();
    result.setDetectionCountDiff(Math.abs(localBoxes.size() - cloudBoxes.size()));
    
    // 比对IOU (Intersection over Union)
    if (!localBoxes.isEmpty() && !cloudBoxes.isEmpty()) {
        result.setAverageIou(calculateAverageIou(localBoxes, cloudBoxes));

return result;

// 计算两个概率分布的相似度

private float calculateDistributionSimilarity(
    Map<String, Float> dist1, Map<String, Float> dist2) {
    
    float similarity = 0f;
    Set<String> allClasses = new HashSet<>();
    allClasses.addAll(dist1.keySet());
    allClasses.addAll(dist2.keySet());
    
    for (String cls : allClasses) {
        float p1 = dist1.getOrDefault(cls, 0f);
        float p2 = dist2.getOrDefault(cls, 0f);
        similarity += Math.min(p1, p2);

return similarity;

// 计算平均IOU

private float calculateAverageIou(List<BoundingBox> boxes1, List<BoundingBox> boxes2) {
    float totalIou = 0f;
    int count = 0;
    
    for (BoundingBox box1 : boxes1) {
        for (BoundingBox box2 : boxes2) {
            if (box1.getClassLabel().equals(box2.getClassLabel())) {
                totalIou += calculateIou(box1, box2);
                count++;

}

return count > 0 ? totalIou / count : 0f;

// 计算两个检测框的IOU

private float calculateIou(BoundingBox box1, BoundingBox box2) {
    // 计算交集区域坐标
    float x1 = Math.max(box1.getLeft(), box2.getLeft());
    float y1 = Math.max(box1.getTop(), box2.getTop());
    float x2 = Math.min(box1.getRight(), box2.getRight());
    float y2 = Math.min(box1.getBottom(), box2.getBottom());
    
    // 计算交集面积
    float interArea = Math.max(0, x2 - x1) * Math.max(0, y2 - y1);
    
    // 计算并集面积
    float box1Area = box1.getWidth() * box1.getHeight();
    float box2Area = box2.getWidth() * box2.getHeight();
    float unionArea = box1Area + box2Area - interArea;
    
    return interArea / unionArea;

// 比对原始张量数据

public boolean compareTensorOutputs(Tensor localTensor, Tensor cloudTensor) {
    if (!Arrays.equals(localTensor.shape(), cloudTensor.shape())) {
        return false;

float[] localData = localTensor.getData();

    float[] cloudData = cloudTensor.getData();
    
    for (int i = 0; i < localData.length; i++) {
        if (Math.abs(localData[i] - cloudData[i]) > FLOAT_TOLERANCE) {
            return false;

}

    return true;

}

五、测试框架实现
模型测试编排器

public class ModelTestOrchestrator {
private HeterogeneousScheduler scheduler;
private ResultComparator comparator;
private TestReportGenerator reportGenerator;

public ModelTestOrchestrator(Context context) {
    this.scheduler = new HeterogeneousScheduler(context);
    this.comparator = new ResultComparator();
    this.reportGenerator = new TestReportGenerator();

// 执行端云一致性测试

public void runConsistencyTest(ModelInput input, TestCallback callback) {
    scheduler.scheduleDualInference(input, new HeterogeneousScheduler.InferenceCallback() {
        @Override
        public void onInferenceComplete(ModelOutput localOutput, ModelOutput cloudOutput) {
            // 比对结果
            ComparisonResult result = comparator.compareClassificationOutputs(
                localOutput, cloudOutput
            );
            
            // 生成测试报告
            TestReport report = reportGenerator.generateReport(
                input, localOutput, cloudOutput, result
            );
            
            callback.onTestComplete(report);

@Override

        public void onError(Exception e) {
            callback.onError(e);

});

// 批量测试

public void runBatchTest(List<ModelInput> inputs, BatchTestCallback callback) {
    List<TestReport> reports = new ArrayList<>();
    AtomicInteger counter = new AtomicInteger(0);
    
    for (ModelInput input : inputs) {
        runConsistencyTest(input, new TestCallback() {
            @Override
            public void onTestComplete(TestReport report) {
                reports.add(report);
                
                if (counter.incrementAndGet() == inputs.size()) {
                    callback.onBatchComplete(reports);

}

            @Override
            public void onError(Exception e) {
                counter.incrementAndGet();
                // 记录错误报告
                reports.add(TestReport.createErrorReport(input, e));
                
                if (counter.get() == inputs.size()) {
                    callback.onBatchComplete(reports);

}

});

}

public interface TestCallback {
    void onTestComplete(TestReport report);
    void onError(Exception e);

public interface BatchTestCallback {

    void onBatchComplete(List<TestReport> reports);

}

测试报告生成器

public class TestReportGenerator {
private static final DecimalFormat df = new DecimalFormat(“0.0000”);

public TestReport generateReport(ModelInput input, 
                               ModelOutput localOutput,
                               ModelOutput cloudOutput,
                               ComparisonResult result) {
    TestReport report = new TestReport();
    
    // 基本信息
    report.setTestTime(new Date());
    report.setInputSummary(input.getSummary());
    
    // 性能数据
    report.setLocalInferenceTime(localOutput.getInferenceTime());
    report.setCloudInferenceTime(cloudOutput.getInferenceTime());
    
    // 比对结果
    report.setTopClassMatch(result.isTopClassMatch());
    report.setProbabilityDiff(result.getProbabilityDiff());
    report.setDistributionSimilarity(result.getDistributionSimilarity());
    
    if (localOutput.getDetectionBoxes() != null) {
        report.setDetectionCountDiff(result.getDetectionCountDiff());
        report.setAverageIou(result.getAverageIou());

// 生成可读结果摘要

    String summary = buildResultSummary(localOutput, cloudOutput, result);
    report.setResultSummary(summary);
    
    return report;

private String buildResultSummary(ModelOutput local, ModelOutput cloud,

                                ComparisonResult result) {
    StringBuilder sb = new StringBuilder();
    
    sb.append("端侧推理时间: ").append(local.getInferenceTime()).append("ms\n");
    sb.append("云侧推理时间: ").append(cloud.getInferenceTime()).append("ms\n\n");
    
    if (local.getTopClass() != null) {
        sb.append("分类结果比对:\n");
        sb.append("  端侧Top1: ").append(local.getTopClass())
          .append(" (").append(df.format(local.getTopProbability())).append(")\n");
        sb.append("  云侧Top1: ").append(cloud.getTopClass())
          .append(" (").append(df.format(cloud.getTopProbability())).append(")\n");
        sb.append("  是否匹配: ").append(result.isTopClassMatch() ? "✓" : "✗").append("\n");
        sb.append("  概率差值: ").append(df.format(result.getProbabilityDiff())).append("\n");
        sb.append("  分布相似度: ").append(df.format(result.getDistributionSimilarity())).append("\n\n");

if (local.getDetectionBoxes() != null && !local.getDetectionBoxes().isEmpty()) {

        sb.append("检测结果比对:\n");
        sb.append("  端侧检测数: ").append(local.getDetectionBoxes().size()).append("\n");
        sb.append("  云侧检测数: ").append(cloud.getDetectionBoxes().size()).append("\n");
        sb.append("  数量差异: ").append(result.getDetectionCountDiff()).append("\n");
        sb.append("  平均IOU: ").append(df.format(result.getAverageIou())).append("\n");

return sb.toString();

}

六、HarmonyOS 5集成示例

public class ModelTestAbilitySlice extends AbilitySlice {
private ModelTestOrchestrator orchestrator;
private Text resultDisplay;

@Override
public void onStart(Intent intent) {
    super.onStart(intent);
    setUIContent(ResourceTable.Layout_model_test_layout);
    
    // 初始化组件
    resultDisplay = (Text) findComponentById(ResourceTable.Id_result_display);
    orchestrator = new ModelTestOrchestrator(this);
    
    // 绑定测试按钮
    Button testButton = (Button) findComponentById(ResourceTable.Id_run_test_button);
    testButton.setClickedListener(listener -> runSampleTest());

private void runSampleTest() {

    // 准备测试输入
    ModelInput input = prepareTestInput();
    
    // 执行测试
    orchestrator.runConsistencyTest(input, new ModelTestOrchestrator.TestCallback() {
        @Override
        public void onTestComplete(TestReport report) {
            getUITaskDispatcher().asyncDispatch(() -> {
                resultDisplay.setText(report.getResultSummary());
            });

@Override

        public void onError(Exception e) {
            getUITaskDispatcher().asyncDispatch(() -> {
                resultDisplay.setText("测试失败: " + e.getMessage());
            });

});

private ModelInput prepareTestInput() {

    // 从资源加载测试图像
    ImageSource imageSource = new ImageSource(
        getResourceManager(), 
        ResourceTable.Media_test_image
    );
    
    // 创建模型输入
    return new ModelInput.Builder()
        .setImage(imageSource)
        .setNormalizeParams(255f, new float[]{0.485f, 0.456f, 0.406f}, 
                           new float[]{0.229f, 0.224f, 0.225f})
        .build();

}

七、技术创新点
异构计算调度：充分利用HarmonyOS 5的异构计算能力

全面比对指标：支持分类、检测等多种模型结果的深度比对

自动化测试：一键执行端云一致性验证

可视化报告：直观展示差异点和性能数据

批量测试：支持大规模测试用例自动执行

八、总结

本端云AI模型结果比对器基于HarmonyOS 5异构计算能力，实现了以下核心价值：
质量保障：确保端云两侧模型推理结果一致

性能对比：直观展示不同计算环境的执行效率差异

部署验证：为模型量化、剪枝等优化手段提供验证工具

持续集成：可与CI/CD流程集成，实现自动化模型测试

系统借鉴了《鸿蒙跨端U同步》中的数据同步验证机制，将经过验证的比对策略应用于AI模型质量保障领域。未来可结合差异分析算法自动定位模型问题层，并与模型训练平台集成，形成完整的模型开发-部署-验证闭环。