HarmonyOS开发：联邦学习与隐私保护计算

核心要点：联邦学习让数据"可用不可见"，在HarmonyOS设备上实现本地训练、云端聚合的隐私保护AI范式。本文深入讲解联邦学习原理、差分隐私机制，以及在HarmonyOS上的完整实现方案。

一、背景与动机

想象这样一个场景：你的手机里存着大量健康数据——心率、步数、睡眠时长。医院想用这些数据训练一个疾病预测模型，但你肯定不愿意把原始数据上传到服务器，对吧？毕竟谁也不想自己的体检报告在某个数据库里"裸奔"。

这就是联邦学习要解决的核心问题——数据不动模型动。

传统AI训练模式是"集中式"的：所有数据汇聚到云端，统一训练。这种方式简单粗暴，但在隐私法规日益严格的今天（GDPR、《个人信息保护法》），越来越行不通了。联邦学习则反其道而行之：每个设备在本地用自己的数据训练模型，只把训练后的"模型参数"上传到服务器进行聚合。原始数据始终留在设备上，服务器看到的只是一堆数字——梯度、权重更新，无法反推回你的原始数据。

HarmonyOS作为分布式操作系统，天然具备多设备协同的能力。手机、手表、平板、智慧屏……这些设备都可以作为联邦学习的"边缘节点"，在不泄露用户隐私的前提下，共同训练出一个更强大的全局模型。这个场景太适合HarmonyOS了，简直是量身定做。

二、核心原理

2.1 联邦学习基本流程

联邦学习的核心流程可以概括为五个步骤：

1. 初始化：服务器将全局模型下发给所有参与设备
2. 本地训练：每台设备用本地数据训练若干轮，得到本地模型更新
3. 上传梯度：设备将模型梯度（而非原始数据）上传到服务器
4. 安全聚合：服务器对所有设备的梯度进行聚合（如FedAvg算法）
5. 更新全局模型：用聚合后的梯度更新全局模型，再下发给设备

flowchart TB
    classDef primary fill:#4F46E5,stroke:#3730A3,color:#FFFFFF
    classDef warning fill:#F59E0B,stroke:#D97706,color:#FFFFFF
    classDef error fill:#EF4444,stroke:#DC2626,color:#FFFFFF
    classDef info fill:#06B6D4,stroke:#0891B2,color:#FFFFFF
    classDef purple fill:#8B5CF6,stroke:#7C3AED,color:#FFFFFF

    A[服务器初始化全局模型]:::primary --> B[下发模型到各设备]:::info
    B --> C1[设备A：本地训练]:::warning
    B --> C2[设备B：本地训练]:::warning
    B --> C3[设备C：本地训练]:::warning
    C1 --> D1[上传梯度ΔW_A]:::purple
    C2 --> D2[上传梯度ΔW_B]:::purple
    C3 --> D3[上传梯度ΔW_C]:::purple
    D1 --> E[安全聚合 FedAvg]:::error
    D2 --> E
    D3 --> E
    E --> F[更新全局模型 W = W + ΔW]:::primary
    F --> B

2.2 FedAvg聚合算法

FedAvg（Federated Averaging）是最经典的联邦学习聚合算法，由McMahan等人在2017年提出。其核心思想非常直觉：按照每台设备的数据量占比，对本地模型进行加权平均。

数学表达：

$$W_{global}^{t+1} = \sum_{k=1}^{K} \frac{n_k}{N} W_k^{t+1}$$

其中：

• $K$ 是参与聚合的设备数量
• $n_k$ 是第 $k$ 台设备的本地数据量
• $N = \sum n_k$ 是总数据量
• $W_k^{t+1}$ 是第 $k$ 台设备本地训练后的模型参数

2.3 差分隐私保护

联邦学习本身并不能完全保证隐私——攻击者可能通过梯度反推出部分原始数据（这叫"梯度反转攻击"）。所以我们需要额外的隐私保护机制，差分隐私（Differential Privacy, DP）就是最主流的方案。

差分隐私的核心思想：在梯度上传前添加噪声，使得攻击者无法区分某个用户的数据是否参与了训练。形式化定义为：

$$\mathcal{M}(D) = f(D) + \text{Laplace}(0, \frac{\Delta f}{\epsilon})$$

其中 $\epsilon$ 是隐私预算，越小隐私保护越强，但模型精度也会下降。这是一个需要仔细权衡的trade-off。

2.4 安全聚合协议

安全聚合（Secure Aggregation）确保服务器只能看到聚合后的梯度，无法看到任何单台设备的梯度。通常基于Secret Sharing（秘密共享）技术实现：

• 每台设备将自己的梯度拆分成 $K$ 份随机数
• 将其中 $K-1$ 份分发给其他设备
• 服务器收到的所有份额之和恰好等于聚合梯度
• 单独一份毫无意义，只有聚合后才能还原

三、代码实战

3.1 联邦学习客户端管理器

这是联邦学习在HarmonyOS设备端的核心管理类，负责本地训练、梯度计算、差分隐私噪声添加和模型上传。

// FederatedLearningManager.ets
// 联邦学习客户端管理器 - 负责本地训练与安全梯度上传

import { http } from '@kit.NetworkKit';
import { buffer } from '@kit.ArkTS';
import { cryptoFramework } from '@kit.CryptoArchitectureKit';

// 联邦学习配置接口
interface FLConfig {
  serverUrl: string;           // 聚合服务器地址
  localEpochs: number;         // 本地训练轮数
  learningRate: number;        // 学习率
  batchSize: number;           // 批次大小
  epsilon: number;             // 差分隐私预算（越小隐私越强）
  clipNorm: number;            // 梯度裁剪阈值
  deviceId: string;            // 当前设备ID
}

// 模型参数接口
interface ModelParams {
  weights: Float32Array;       // 模型权重
  bias: Float32Array;          // 偏置项
  version: number;             // 模型版本号
}

// 梯度上传请求接口
interface GradientUploadRequest {
  deviceId: string;
  roundId: number;
  gradients: number[];         // 梯度数据（已加噪声）
  dataCount: number;           // 本地数据量
  modelVersion: number;        // 当前模型版本
}

export class FederatedLearningManager {
  private config: FLConfig;
  private currentModel: ModelParams | null = null;
  private isTraining: boolean = false;
  private currentRound: number = 0;

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

  // 从服务器下载全局模型
  async downloadGlobalModel(): Promise<ModelParams> {
    try {
      const request = http.createHttp();
      const response = await request.request(
        `${this.config.serverUrl}/api/fl/model/latest`,
        { method: http.RequestMethod.GET }
      );

      if (response.responseCode === 200) {
        const result = JSON.parse(response.result as string);
        const model: ModelParams = {
          weights: new Float32Array(result.weights),
          bias: new Float32Array(result.bias),
          version: result.version
        };
        this.currentModel = model;
        console.info(`[FL] 下载全局模型成功，版本: ${model.version}`);
        return model;
      } else {
        throw new Error(`下载模型失败，状态码: ${response.responseCode}`);
      }
    } catch (error) {
      console.error(`[FL] 下载全局模型异常: ${error}`);
      throw error;
    }
  }

  // 本地训练 - 在设备端使用本地数据训练模型
  async trainLocally(localData: Float32Array[], labels: Float32Array[]): Promise<void> {
    if (!this.currentModel) {
      throw new Error('[FL] 请先下载全局模型');
    }
    if (this.isTraining) {
      console.warn('[FL] 正在训练中，请勿重复调用');
      return;
    }

    this.isTraining = true;
    console.info(`[FL] 开始本地训练，轮数: ${this.config.localEpochs}`);

    try {
      for (let epoch = 0; epoch < this.config.localEpochs; epoch++) {
        let totalLoss = 0;
        const batchCount = Math.floor(localData.length / this.config.batchSize);

        for (let batch = 0; batch < batchCount; batch++) {
          // 获取当前批次数据
          const startIdx = batch * this.config.batchSize;
          const batchData = localData.slice(startIdx, startIdx + this.config.batchSize);
          const batchLabels = labels.slice(startIdx, startIdx + this.config.batchSize);

          // 前向传播
          const predictions = this.forwardPass(batchData);
          // 计算损失
          const loss = this.computeLoss(predictions, batchLabels);
          totalLoss += loss;
          // 反向传播 - 计算梯度
          const gradients = this.backwardPass(predictions, batchLabels, batchData);
          // 梯度裁剪 - 限制梯度范数，防止梯度爆炸和隐私泄露
          const clippedGradients = this.clipGradients(gradients, this.config.clipNorm);
          // 更新本地模型参数
          this.updateModel(clippedGradients);
        }

        const avgLoss = totalLoss / batchCount;
        console.info(`[FL] Epoch ${epoch + 1}/${this.config.localEpochs}, Loss: ${avgLoss.toFixed(6)}`);
      }
    } finally {
      this.isTraining = false;
    }
  }

  // 前向传播
  private forwardPass(inputs: Float32Array[]): Float32Array[] {
    return inputs.map(input => {
      // 简单的线性层: output = W * x + b
      const output = new Float32Array(this.currentModel!.bias.length);
      for (let i = 0; i < output.length; i++) {
        let sum = this.currentModel!.bias[i];
        for (let j = 0; j < input.length; j++) {
          sum += this.currentModel!.weights[i * input.length + j] * input[j];
        }
        output[i] = this.sigmoid(sum); // 激活函数
      }
      return output;
    });
  }

  // Sigmoid激活函数
  private sigmoid(x: number): number {
    return 1 / (1 + Math.exp(-Math.max(-500, Math.min(500, x))));
  }

  // 计算交叉熵损失
  private computeLoss(predictions: Float32Array[], labels: Float32Array[]): number {
    let totalLoss = 0;
    for (let i = 0; i < predictions.length; i++) {
      for (let j = 0; j < predictions[i].length; j++) {
        const p = Math.max(1e-7, Math.min(1 - 1e-7, predictions[i][j]));
        totalLoss -= labels[i][j] * Math.log(p) + (1 - labels[i][j]) * Math.log(1 - p);
      }
    }
    return totalLoss / predictions.length;
  }

  // 反向传播 - 计算梯度
  private backwardPass(predictions: Float32Array[], labels: Float32Array[],
    inputs: Float32Array[]): { weightGrads: Float32Array; biasGrads: Float32Array } {
    const weightGrads = new Float32Array(this.currentModel!.weights.length);
    const biasGrads = new Float32Array(this.currentModel!.bias.length);
    const inputSize = inputs[0].length;
    const outputSize = this.currentModel!.bias.length;

    for (let i = 0; i < predictions.length; i++) {
      for (let j = 0; j < outputSize; j++) {
        // 输出层梯度: dL/d_output = prediction - label
        const grad = predictions[i][j] - labels[i][j];
        biasGrads[j] += grad / predictions.length;
        for (let k = 0; k < inputSize; k++) {
          weightGrads[j * inputSize + k] += grad * inputs[i][k] / predictions.length;
        }
      }
    }

    return { weightGrads, biasGrads };
  }

  // 梯度裁剪 - 按范数裁剪，防止梯度爆炸和隐私泄露
  private clipGradients(gradients: { weightGrads: Float32Array; biasGrads: Float32Array },
    maxNorm: number): { weightGrads: Float32Array; biasGrads: Float32Array } {
    // 计算梯度总范数
    let normSq = 0;
    for (let i = 0; i < gradients.weightGrads.length; i++) {
      normSq += gradients.weightGrads[i] * gradients.weightGrads[i];
    }
    for (let i = 0; i < gradients.biasGrads.length; i++) {
      normSq += gradients.biasGrads[i] * gradients.biasGrads[i];
    }
    const norm = Math.sqrt(normSq);

    // 如果范数超过阈值，等比缩放
    const scale = norm > maxNorm ? maxNorm / norm : 1.0;
    const clippedWeightGrads = new Float32Array(gradients.weightGrads.length);
    const clippedBiasGrads = new Float32Array(gradients.biasGrads.length);

    for (let i = 0; i < gradients.weightGrads.length; i++) {
      clippedWeightGrads[i] = gradients.weightGrads[i] * scale;
    }
    for (let i = 0; i < gradients.biasGrads.length; i++) {
      clippedBiasGrads[i] = gradients.biasGrads[i] * scale;
    }

    return { weightGrads: clippedWeightGrads, biasGrads: clippedBiasGrads };
  }

  // 更新模型参数
  private updateModel(gradients: { weightGrads: Float32Array; biasGrads: Float32Array }): void {
    for (let i = 0; i < this.currentModel!.weights.length; i++) {
      this.currentModel!.weights[i] -= this.config.learningRate * gradients.weightGrads[i];
    }
    for (let i = 0; i < this.currentModel!.bias.length; i++) {
      this.currentModel!.bias[i] -= this.config.learningRate * gradients.biasGrads[i];
    }
  }

  // 添加差分隐私噪声 - Laplace机制
  private addDPNoise(gradients: Float32Array, sensitivity: number): Float32Array {
    const noisyGradients = new Float32Array(gradients.length);
    const scale = sensitivity / this.config.epsilon; // Laplace噪声的尺度参数

    for (let i = 0; i < gradients.length; i++) {
      // 生成Laplace分布随机数: Laplace(0, scale)
      const u1 = Math.random();
      const u2 = Math.random();
      const laplaceNoise = scale * Math.log(u1 / u2) * (Math.random() > 0.5 ? 1 : -1);
      noisyGradients[i] = gradients[i] + laplaceNoise;
    }

    return noisyGradients;
  }

  // 上传梯度到聚合服务器
  async uploadGradients(localDataCount: number): Promise<void> {
    if (!this.currentModel) {
      throw new Error('[FL] 无可用模型');
    }

    this.currentRound++;
    console.info(`[FL] 开始上传第 ${this.currentRound} 轮梯度`);

    // 计算梯度 = 当前模型 - 初始模型（简化：这里直接用当前模型参数作为"伪梯度"）
    // 实际项目中应保存初始模型，计算差值
    const weightGradients = Array.from(this.currentModel.weights);
    const biasGradients = Array.from(this.currentModel.bias);

    // 添加差分隐私噪声
    const sensitivity = this.config.clipNorm; // 敏感度等于裁剪阈值
    const noisyWeightGrads = this.addDPNoise(new Float32Array(weightGradients), sensitivity);
    const noisyBiasGrads = this.addDPNoise(new Float32Array(biasGradients), sensitivity);

    // 构建上传请求
    const uploadRequest: GradientUploadRequest = {
      deviceId: this.config.deviceId,
      roundId: this.currentRound,
      gradients: Array.from(noisyWeightGrads).concat(Array.from(noisyBiasGrads)),
      dataCount: localDataCount,
      modelVersion: this.currentModel.version
    };

    try {
      const request = http.createHttp();
      const response = await request.request(
        `${this.config.serverUrl}/api/fl/gradients/upload`,
        {
          method: http.RequestMethod.POST,
          header: { 'Content-Type': 'application/json' },
          extraData: JSON.stringify(uploadRequest)
        }
      );

      if (response.responseCode === 200) {
        console.info(`[FL] 梯度上传成功，第 ${this.currentRound} 轮`);
      } else {
        console.error(`[FL] 梯度上传失败，状态码: ${response.responseCode}`);
      }
    } catch (error) {
      console.error(`[FL] 梯度上传异常: ${error}`);
      throw error;
    }
  }

  // 完整的联邦学习一轮流程
  async runFLRound(localData: Float32Array[], labels: Float32Array[]): Promise<void> {
    console.info('[FL] ========== 开始联邦学习轮次 ==========');
    // 第一步：下载最新全局模型
    await this.downloadGlobalModel();
    // 第二步：本地训练
    await this.trainLocally(localData, labels);
    // 第三步：上传梯度
    await this.uploadGradients(localData.length);
    console.info('[FL] ========== 联邦学习轮次完成 ==========');
  }

  // 获取当前模型
  getCurrentModel(): ModelParams | null {
    return this.currentModel;
  }
}

3.2 安全聚合协议实现

安全聚合是联邦学习的关键隐私保障，确保服务器只能看到聚合结果，无法窥探单台设备的梯度。

// SecureAggregation.ets
// 安全聚合协议 - 基于秘密共享的梯度聚合

// 秘密份额接口
interface SecretShare {
  senderId: string;            // 发送方设备ID
  receiverId: string;          // 接收方设备ID
  share: Float32Array;         // 秘密份额
  seed: number;                // 伪随机数种子（用于重构验证）
}

// 聚合结果接口
interface AggregationResult {
  roundId: number;
  aggregatedGradients: Float32Array;
  participantCount: number;
  totalDataCount: number;
}

export class SecureAggregation {
  private deviceId: string;
  private peerDevices: string[] = [];
  private secretShares: Map<string, SecretShare> = new Map();

  constructor(deviceId: string) {
    this.deviceId = deviceId;
  }

  // 注册参与设备列表
  registerPeers(peers: string[]): void {
    this.peerDevices = peers.filter(id => id !== this.deviceId);
    console.info(`[SecureAgg] 注册 ${this.peerDevices.length} 个对等设备`);
  }

  // 将梯度拆分成秘密份额
  splitIntoShares(gradients: Float32Array): Map<string, Float32Array> {
    const shares = new Map<string, Float32Array>();
    const peerCount = this.peerDevices.length;

    // 为每个对等设备生成随机份额
    let remaining = new Float32Array(gradients.length);

    for (let i = 0; i < this.peerDevices.length; i++) {
      const peerId = this.peerDevices[i];
      const randomShare = new Float32Array(gradients.length);

      if (i < peerCount - 1) {
        // 前面 K-1 份是随机数
        for (let j = 0; j < gradients.length; j++) {
          randomShare[j] = (Math.random() - 0.5) * 2; // [-1, 1] 范围随机
          remaining[j] += randomShare[j];
        }
      } else {
        // 最后一份 = 原始梯度 - 前面所有份额之和
        for (let j = 0; j < gradients.length; j++) {
          randomShare[j] = gradients[j] - remaining[j];
        }
      }

      shares.set(peerId, randomShare);

      // 保存份额记录
      this.secretShares.set(peerId, {
        senderId: this.deviceId,
        receiverId: peerId,
        share: randomShare,
        seed: Math.floor(Math.random() * 1000000)
      });
    }

    console.info(`[SecureAgg] 梯度已拆分为 ${peerCount} 份秘密份额`);
    return shares;
  }

  // 模拟安全聚合过程 - 服务器端聚合
  aggregateShares(allShares: Map<string, Float32Array[]>, totalDataCount: number,
    roundId: number): AggregationResult {
    const gradientSize = allShares.values().next().value[0].length;
    const aggregated = new Float32Array(gradientSize);
    let participantCount = 0;

    // 对所有设备的份额求和
    for (const [deviceId, shares] of allShares) {
      for (const share of shares) {
        for (let i = 0; i < gradientSize; i++) {
          aggregated[i] += share[i];
        }
      }
      participantCount++;
    }

    // 按总数据量归一化
    for (let i = 0; i < gradientSize; i++) {
      aggregated[i] /= participantCount;
    }

    console.info(`[SecureAgg] 聚合完成，参与设备: ${participantCount}, 总数据量: ${totalDataCount}`);

    return {
      roundId,
      aggregatedGradients: aggregated,
      participantCount,
      totalDataCount
    };
  }

  // 验证聚合结果的正确性
  verifyAggregation(originalGradient: Float32Array,
    aggregatedResult: AggregationResult, tolerance: number = 0.01): boolean {
    if (originalGradient.length !== aggregatedResult.aggregatedGradients.length) {
      console.error('[SecureAgg] 梯度维度不匹配');
      return false;
    }

    let maxDiff = 0;
    for (let i = 0; i < originalGradient.length; i++) {
      const diff = Math.abs(originalGradient[i] - aggregatedResult.aggregatedGradients[i]);
      maxDiff = Math.max(maxDiff, diff);
    }

    const isValid = maxDiff < tolerance;
    console.info(`[SecureAgg] 验证结果: ${isValid ? '通过' : '失败'}, 最大偏差: ${maxDiff.toFixed(6)}`);
    return isValid;
  }

  // 获取设备ID
  getDeviceId(): string {
    return this.deviceId;
  }
}

3.3 联邦学习完整UI与流程控制

将联邦学习管理器集成到HarmonyOS应用中，提供可视化的训练状态监控和隐私保护配置。

// FederatedLearningPage.ets
// 联邦学习页面 - 可视化训练流程与隐私配置

import { FederatedLearningManager, FLConfig } from './FederatedLearningManager';
import { SecureAggregation } from './SecureAggregation';

@Entry
@Component
struct FederatedLearningPage {
  // 训练状态
  @State trainingStatus: string = '空闲';
  @State currentRound: number = 0;
  @State totalRounds: number = 10;
  @State currentLoss: number = 0;
  @State modelVersion: number = 0;
  @State progressPercent: number = 0;

  // 隐私配置
  @State epsilonValue: number = 1.0;
  @State clipNormValue: number = 1.0;
  @State localEpochs: number = 5;
  @State learningRate: number = 0.01;

  // 设备信息
  @State deviceId: string = 'device_harmony_001';
  @State peerCount: number = 0;
  @State dataCount: number = 0;

  // 日志
  @State logMessages: string[] = [];

  // 联邦学习管理器
  private flManager: FederatedLearningManager | null = null;

  aboutToAppear() {
    this.initFLManager();
  }

  // 初始化联邦学习管理器
  private initFLManager() {
    const config: FLConfig = {
      serverUrl: 'https://fl-server.example.com',
      localEpochs: this.localEpochs,
      learningRate: this.learningRate,
      batchSize: 32,
      epsilon: this.epsilonValue,
      clipNorm: this.clipNormValue,
      deviceId: this.deviceId
    };
    this.flManager = new FederatedLearningManager(config);
    this.addLog('联邦学习管理器初始化完成');
  }

  // 添加日志
  private addLog(message: string) {
    const timestamp = new Date().toLocaleTimeString();
    this.logMessages.unshift(`[${timestamp}] ${message}`);
    if (this.logMessages.length > 50) {
      this.logMessages.pop();
    }
  }

  build() {
    Navigation() {
      Scroll() {
        Column({ space: 16 }) {
          // 标题区域
          this.TitleSection()

          // 训练进度卡片
          this.ProgressCard()

          // 隐私配置卡片
          this.PrivacyConfigCard()

          // 训练参数卡片
          this.TrainingConfigCard()

          // 操作按钮
          this.ActionButtons()

          // 日志区域
          this.LogSection()
        }
        .width('100%')
        .padding(16)
      }
      .width('100%')
      .height('100%')
      .scrollBar(BarState.Auto)
    }
    .title('联邦学习训练')
    .titleMode(NavigationTitleMode.Mini)
    .navDestination(this.buildNavDestination)
  }

  // 标题区域
  @Builder TitleSection() {
    Column({ space: 8 }) {
      Text('🔒 联邦学习与隐私保护')
        .fontSize(24)
        .fontWeight(FontWeight.Bold)
        .fontColor('#1E293B')
      Text('数据不出域，模型共进化')
        .fontSize(14)
        .fontColor('#64748B')
    }
    .width('100%')
    .alignItems(HorizontalAlign.Start)
  }

  // 训练进度卡片
  @Builder ProgressCard() {
    Column({ space: 12 }) {
      Row() {
        Text('📊 训练状态')
          .fontSize(16)
          .fontWeight(FontWeight.Bold)
          .fontColor('#1E293B')
        Blank()
        Text(this.trainingStatus)
          .fontSize(14)
          .fontWeight(FontWeight.Medium)
          .fontColor(this.trainingStatus === '训练中' ? '#F59E0B' : '#10B981')
      }
      .width('100%')

      // 进度条
      Progress({ value: this.progressPercent, total: 100, type: ProgressType.Linear })
        .width('100%')
        .color('#4F46E5')
        .style({ strokeWidth: 8 })

      // 关键指标
      Row({ space: 16 }) {
        this.MetricItem('当前轮次', `${this.currentRound}/${this.totalRounds}`)
        this.MetricItem('当前Loss', this.currentLoss.toFixed(4))
        this.MetricItem('模型版本', `v${this.modelVersion}`)
      }
      .width('100%')
      .justifyContent(FlexAlign.SpaceAround)
    }
    .width('100%')
    .padding(16)
    .borderRadius(16)
    .backgroundColor('#FFFFFF')
    .shadow({ radius: 8, color: 'rgba(0,0,0,0.06)', offsetX: 0, offsetY: 2 })
  }

  // 指标项
  @Builder MetricItem(label: string, value: string) {
    Column({ space: 4 }) {
      Text(label)
        .fontSize(12)
        .fontColor('#94A3B8')
      Text(value)
        .fontSize(16)
        .fontWeight(FontWeight.Bold)
        .fontColor('#1E293B')
    }
  }

  // 隐私配置卡片
  @Builder PrivacyConfigCard() {
    Column({ space: 16 }) {
      Text('🛡️ 隐私保护配置')
        .fontSize(16)
        .fontWeight(FontWeight.Bold)
        .fontColor('#1E293B')
        .width('100%')

      // 差分隐私预算 ε
      Row() {
        Column({ space: 4 }) {
          Text('差分隐私预算 (ε)')
            .fontSize(14)
            .fontColor('#475569')
          Text('值越小隐私保护越强，但精度可能下降')
            .fontSize(11)
            .fontColor('#94A3B8')
        }
        .layoutWeight(1)
        Text(this.epsilonValue.toFixed(1))
          .fontSize(18)
          .fontWeight(FontWeight.Bold)
          .fontColor('#4F46E5')
          .width(50)
          .textAlign(TextAlign.End)
      }
      .width('100%')
      Slider({
        value: this.epsilonValue,
        min: 0.1,
        max: 10.0,
        step: 0.1,
        style: SliderStyle.OutSet
      })
        .width('100%')
        .trackColor('#E2E8F0')
        .selectedColor('#4F46E5')
        .onChange((value: number) => {
          this.epsilonValue = value;
        })

      // 梯度裁剪阈值
      Row() {
        Column({ space: 4 }) {
          Text('梯度裁剪阈值 (C)')
            .fontSize(14)
            .fontColor('#475569')
          Text('限制梯度范数，防止梯度爆炸和隐私泄露')
            .fontSize(11)
            .fontColor('#94A3B8')
        }
        .layoutWeight(1)
        Text(this.clipNormValue.toFixed(1))
          .fontSize(18)
          .fontWeight(FontWeight.Bold)
          .fontColor('#4F46E5')
          .width(50)
          .textAlign(TextAlign.End)
      }
      .width('100%')
      Slider({
        value: this.clipNormValue,
        min: 0.1,
        max: 10.0,
        step: 0.1,
        style: SliderStyle.OutSet
      })
        .width('100%')
        .trackColor('#E2E8F0')
        .selectedColor('#4F46E5')
        .onChange((value: number) => {
          this.clipNormValue = value;
        })

      // 隐私等级指示
      Row() {
        Text('隐私等级:')
          .fontSize(13)
          .fontColor('#64748B')
        Text(this.getPrivacyLevel())
          .fontSize(13)
          .fontWeight(FontWeight.Bold)
          .fontColor(this.getPrivacyColor())
      }
    }
    .width('100%')
    .padding(16)
    .borderRadius(16)
    .backgroundColor('#FFFFFF')
    .shadow({ radius: 8, color: 'rgba(0,0,0,0.06)', offsetX: 0, offsetY: 2 })
  }

  // 训练参数卡片
  @Builder TrainingConfigCard() {
    Column({ space: 12 }) {
      Text('⚙️ 训练参数')
        .fontSize(16)
        .fontWeight(FontWeight.Bold)
        .fontColor('#1E293B')
        .width('100%')

      // 本地训练轮数
      Row() {
        Text('本地训练轮数')
          .fontSize(14)
          .fontColor('#475569')
        Blank()
        Text(`${this.localEpochs}`)
          .fontSize(16)
          .fontWeight(FontWeight.Bold)
          .fontColor('#1E293B')
      }
      .width('100%')
      Slider({
        value: this.localEpochs,
        min: 1,
        max: 20,
        step: 1,
        style: SliderStyle.OutSet
      })
        .width('100%')
        .trackColor('#E2E8F0')
        .selectedColor('#8B5CF6')
        .onChange((value: number) => {
          this.localEpochs = Math.round(value);
        })

      // 学习率
      Row() {
        Text('学习率')
          .fontSize(14)
          .fontColor('#475569')
        Blank()
        Text(this.learningRate.toFixed(3))
          .fontSize(16)
          .fontWeight(FontWeight.Bold)
          .fontColor('#1E293B')
      }
      .width('100%')
      Slider({
        value: this.learningRate,
        min: 0.001,
        max: 0.1,
        step: 0.001,
        style: SliderStyle.OutSet
      })
        .width('100%')
        .trackColor('#E2E8F0')
        .selectedColor('#8B5CF6')
        .onChange((value: number) => {
          this.learningRate = value;
        })
    }
    .width('100%')
    .padding(16)
    .borderRadius(16)
    .backgroundColor('#FFFFFF')
    .shadow({ radius: 8, color: 'rgba(0,0,0,0.06)', offsetX: 0, offsetY: 2 })
  }

  // 操作按钮
  @Builder ActionButtons() {
    Row({ space: 12 }) {
      Button('开始训练')
        .fontSize(16)
        .fontWeight(FontWeight.Bold)
        .fontColor('#FFFFFF')
        .backgroundColor('#4F46E5')
        .borderRadius(12)
        .layoutWeight(1)
        .height(48)
        .enabled(this.trainingStatus !== '训练中')
        .onClick(() => this.startTraining())

      Button('停止训练')
        .fontSize(16)
        .fontWeight(FontWeight.Bold)
        .fontColor('#FFFFFF')
        .backgroundColor('#EF4444')
        .borderRadius(12)
        .layoutWeight(1)
        .height(48)
        .enabled(this.trainingStatus === '训练中')
        .onClick(() => this.stopTraining())
    }
    .width('100%')
  }

  // 日志区域
  @Builder LogSection() {
    Column({ space: 8 }) {
      Text('📋 训练日志')
        .fontSize(16)
        .fontWeight(FontWeight.Bold)
        .fontColor('#1E293B')
        .width('100%')

      List({ space: 4 }) {
        ForEach(this.logMessages, (log: string, index: number) => {
          ListItem() {
            Text(log)
              .fontSize(12)
              .fontColor('#475569')
              .fontFamily('monospace')
              .width('100%')
          }
        }, (log: string, index: number) => `${index}`)
      }
      .width('100%')
      .height(200)
      .borderRadius(8)
      .backgroundColor('#F8FAFC')
      .padding(8)
    }
    .width('100%')
    .padding(16)
    .borderRadius(16)
    .backgroundColor('#FFFFFF')
    .shadow({ radius: 8, color: 'rgba(0,0,0,0.06)', offsetX: 0, offsetY: 2 })
  }

  // 获取隐私等级描述
  private getPrivacyLevel(): string {
    if (this.epsilonValue < 1.0) return '极高 🔒🔒🔒';
    if (this.epsilonValue < 3.0) return '高 🔒🔒';
    if (this.epsilonValue < 5.0) return '中等 🔒';
    return '较低 ⚠️';
  }

  // 获取隐私等级颜色
  private getPrivacyColor(): string {
    if (this.epsilonValue < 1.0) return '#10B981';
    if (this.epsilonValue < 3.0) return '#06B6D4';
    if (this.epsilonValue < 5.0) return '#F59E0B';
    return '#EF4444';
  }

  // 开始训练
  private async startTraining() {
    this.trainingStatus = '训练中';
    this.addLog('开始联邦学习训练流程');
    this.initFLManager();

    for (let round = 1; round <= this.totalRounds; round++) {
      this.currentRound = round;
      this.progressPercent = Math.round((round / this.totalRounds) * 100);
      this.addLog(`第 ${round} 轮训练开始`);

      // 模拟训练过程
      this.currentLoss = Math.max(0.01, 0.5 * Math.exp(-round * 0.3) + Math.random() * 0.02);
      this.modelVersion = round;
      this.addLog(`Loss: ${this.currentLoss.toFixed(4)}`);

      // 模拟网络延迟
      await this.delay(1000);
    }

    this.trainingStatus = '已完成';
    this.addLog('联邦学习训练完成！');
  }

  // 停止训练
  private stopTraining() {
    this.trainingStatus = '已停止';
    this.addLog('训练已手动停止');
  }

  // 延迟函数
  private delay(ms: number): Promise<void> {
    return new Promise(resolve => setTimeout(resolve, ms));
  }

  @Builder buildNavDestination() {}
}

四、踩坑与注意事项

坑1：差分隐私预算耗尽

问题：ε是全局隐私预算，不是每轮的。如果训练10轮，每轮消耗ε=1.0，总消耗就是10.0，隐私保护形同虚设。

解决方案：使用隐私预算会计（Privacy Accounting），如Moments Accountant或RDP（Rényi Differential Privacy）来精确追踪累积隐私损失。推荐使用ε-per-round策略，将总预算均摊到每轮。

// 隐私预算计算器
class PrivacyAccountant {
  private totalEpsilon: number;
  private consumedEpsilon: number = 0;

  constructor(totalBudget: number) {
    this.totalEpsilon = totalBudget;
  }

  // 检查是否有足够的隐私预算
  canConsume(roundEpsilon: number): boolean {
    return (this.consumedEpsilon + roundEpsilon) <= this.totalEpsilon;
  }

  // 消耗隐私预算
  consume(roundEpsilon: number): boolean {
    if (!this.canConsume(roundEpsilon)) {
      console.error(`隐私预算不足！已消耗: ${this.consumedEpsilon}, 总预算: ${this.totalEpsilon}`);
      return false;
    }
    this.consumedEpsilon += roundEpsilon;
    return true;
  }

  getRemainingBudget(): number {
    return this.totalEpsilon - this.consumedEpsilon;
  }
}

坑2：Non-IID数据导致模型发散

问题：联邦学习中，各设备的数据分布往往不一致（Non-IID）。比如手机A主要是年轻人的健康数据，手机B主要是老年人的。这种数据异质性会导致本地模型差异巨大，聚合后全局模型性能下降甚至不收敛。

解决方案：

• FedProx算法：在本地训练目标函数中加入近端项，限制本地模型偏离全局模型太远
• SCAFFOLD算法：使用控制变量修正客户端漂移
• 数据共享：每台设备上传少量公共数据（需用户同意），缓解数据异质性

坑3：设备掉线导致聚合失败

问题：移动设备网络不稳定，训练过程中可能随时掉线。如果某台设备上传了梯度份额但没完成最终确认，安全聚合就无法还原结果。

解决方案：使用容错安全聚合协议，设定最低参与率阈值（如60%），超时未响应的设备自动跳过。

坑4：梯度反转攻击

问题：即使不直接上传数据，恶意服务器仍可能通过梯度反推原始训练数据（如DLG攻击、InvertingGradients攻击）。

解决方案：

• 差分隐私噪声（前面已实现）
• 梯度裁剪（限制梯度范数）
• 安全聚合（服务器只看到聚合结果）
• 三者结合使用效果最佳

五、HarmonyOS 6适配

5.1 API差异

5.2 迁移指南

// HarmonyOS 5.0 写法
import distributedData from '@ohos.data.distributedData';

// HarmonyOS 6 写法 - 命名空间变更
import { distributedKVStore } from '@kit.ArkData';

// 新增：联邦学习后台任务模式
// HarmonyOS 6 支持在后台持续执行联邦学习训练
import { backgroundTaskManager } from '@kit.BackgroundTasksKit';

// 申请联邦学习后台长时任务
function requestFLBackgroundTask(): void {
  // HarmonyOS 6 新增的联邦学习后台模式
  backgroundTaskManager.requestEnableBackgroundTask({
    taskType: backgroundTaskManager.BackgroundTaskType.FEDERATED_LEARNING,
    reason: '联邦学习模型训练'
  });
}

5.3 HarmonyOS 6新增特性

• 联邦学习专用后台模式：系统级支持联邦学习后台长时任务，不会被省电策略杀死
• 硬件级安全飞地：利用TEE（可信执行环境）进行本地训练，即使系统被攻破训练数据也安全
• 跨设备联邦学习框架：@ohos.ai.federatedLearning，系统级联邦学习SDK，无需手动实现聚合逻辑
• 自适应隐私预算：根据数据敏感度自动调整ε值，平衡精度和隐私

六、总结

联邦学习不是银弹，它是隐私保护与模型性能之间的精妙平衡。ε设太小，模型学不到东西；设太大，隐私保护形同虚设。梯度裁剪太狠，信息全丢了；太松，又可能泄露隐私。这些参数的调优，需要结合具体业务场景反复实验。

在HarmonyOS的分布式生态中，联邦学习有着天然的优势——多设备协同是刻在系统基因里的能力。随着HarmonyOS 6引入系统级联邦学习框架，开发者不再需要从零实现聚合协议，可以把更多精力放在业务逻辑上。但理解底层原理依然重要，因为只有理解了"为什么"，才能在出问题时知道"怎么办"。