AI守护隐私：数据匿名化的智能革命

# 基于差分隐私的AI模型训练示例
# 运行环境：Python 3.8+, pip install tensorflow tensorflow-privacy numpy pandas scikit-learn

import numpy as np
import pandas as pd
import tensorflow as tf
from tensorflow_privacy.privacy.optimizers import dp_optimizer_keras
from tensorflow_privacy.privacy.analysis import compute_dp_sgd_privacy
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler

# 模拟医疗健康数据集生成
def generate_health_data(n_samples=10000, n_features=20, n_sensitive_features=5):
    """
    生成模拟的医疗健康数据集
    包含一般特征和敏感特征（如年龄、性别、种族等）
    """
    # 生成一般特征
    X = np.random.randn(n_samples, n_features)
    
    # 生成敏感特征（0-1之间的随机值）
    sensitive_features = np.random.rand(n_samples, n_sensitive_features)
    
    # 组合特征
    X = np.hstack((X, sensitive_features))
    
    # 生成标签（二元分类：是否患有某种疾病）
    # 敏感特征会影响标签，但不是唯一决定因素
    weights = np.random.rand(n_features + n_sensitive_features)
    logits = X @ weights
    probabilities = 1 / (1 + np.exp(-logits))
    y = (probabilities > 0.5).astype(int)
    
    # 创建特征名称
    feature_names = [f'feature_{i}' for i in range(n_features)]
    sensitive_feature_names = [f'sensitive_feature_{i}' for i in range(n_sensitive_features)]
    all_feature_names = feature_names + sensitive_feature_names
    
    # 创建DataFrame
    df = pd.DataFrame(X, columns=all_feature_names)
    df['label'] = y
    
    return df, all_feature_names, sensitive_feature_names

# 构建基础模型
def create_basic_model(input_dim):
    """
    创建基础的神经网络模型
    """
    model = tf.keras.Sequential([
        tf.keras.layers.Input(shape=(input_dim,)),
        tf.keras.layers.Dense(64, activation='relu'),
        tf.keras.layers.Dense(32, activation='relu'),
        tf.keras.layers.Dense(1, activation='sigmoid')
    ])
    
    return model

# 构建差分隐私模型
def create_dp_model(input_dim, l2_norm_clip=1.0, noise_multiplier=0.5, learning_rate=0.001):
    """
    创建支持差分隐私的神经网络模型
    """
    # 创建基础模型
    model = create_basic_model(input_dim)
    
    # 创建差分隐私优化器
    optimizer = dp_optimizer_keras.DPKerasAdamOptimizer(
        l2_norm_clip=l2_norm_clip,
        noise_multiplier=noise_multiplier,
        num_microbatches=1,  # 微批次大小
        learning_rate=learning_rate
    )
    
    # 编译模型
    model.compile(
        optimizer=optimizer,
        loss='binary_crossentropy',
        metrics=['accuracy']
    )
    
    return model

# 计算隐私预算
def compute_privacy_budget(n_samples, batch_size, noise_multiplier, epochs):
    """
    计算差分隐私预算（ε, δ）
    """
    # 计算每个epoch的采样率
    sample_rate = batch_size / n_samples
    
    # 计算总隐私预算
    eps, delta = compute_dp_sgd_privacy.compute_dp_sgd_privacy(
        n=n_samples,
        batch_size=batch_size,
        noise_multiplier=noise_multiplier,
        epochs=epochs,
        delta=1e-5  # 通常设置为小于1/n_samples
    )
    
    return eps, delta

# 主函数
def main():
    # 1. 生成模拟医疗健康数据
    print("生成模拟医疗健康数据...")
    df, feature_names, sensitive_feature_names = generate_health_data(
        n_samples=10000,
        n_features=20,
        n_sensitive_features=5
    )
    print(f"数据集大小: {df.shape}")
    print(f"特征数量: {len(feature_names)}")
    print(f"敏感特征: {', '.join(sensitive_feature_names)}")
    
    # 2. 数据预处理
    print("\n数据预处理...")
    # 分离特征和标签
    X = df.drop('label', axis=1).values
    y = df['label'].values
    
    # 数据标准化
    scaler = StandardScaler()
    X_scaled = scaler.fit_transform(X)
    
    # 划分训练集和测试集
    X_train, X_test, y_train, y_test = train_test_split(
        X_scaled, y, test_size=0.2, random_state=42
    )
    print(f"训练集大小: {X_train.shape}, 测试集大小: {X_test.shape}")
    
    # 3. 创建并训练普通模型（用于比较）
    print("\n创建并训练普通模型...")
    basic_model = create_basic_model(X_train.shape[1])
    basic_model.compile(
        optimizer='adam',
        loss='binary_crossentropy',
        metrics=['accuracy']
    )
    
    basic_history = basic_model.fit(
        X_train, y_train,
        epochs=10,
        batch_size=32,
        validation_split=0.2,
        verbose=1
    )
    
    # 评估普通模型
    basic_loss, basic_acc = basic_model.evaluate(X_test, y_test, verbose=0)
    print(f"普通模型 - 测试准确率: {basic_acc:.4f}")
    
    # 4. 创建并训练差分隐私模型
    print("\n创建并训练差分隐私模型...")
    # 设置差分隐私参数
    l2_norm_clip = 1.0  # 梯度裁剪范数
    noise_multiplier = 0.5  # 噪声乘数
    learning_rate = 0.001  # 学习率
    batch_size = 32  # 批次大小
    epochs = 10  # 训练轮数
    
    # 创建差分隐私模型
    dp_model = create_dp_model(
        X_train.shape[1],
        l2_norm_clip=l2_norm_clip,
        noise_multiplier=noise_multiplier,
        learning_rate=learning_rate
    )
    
    # 训练差分隐私模型
    dp_history = dp_model.fit(
        X_train, y_train,
        epochs=epochs,
        batch_size=batch_size,
        validation_split=0.2,
        verbose=1
    )
    
    # 评估差分隐私模型
    dp_loss, dp_acc = dp_model.evaluate(X_test, y_test, verbose=0)
    print(f"差分隐私模型 - 测试准确率: {dp_acc:.4f}")
    print(f"准确率差异: {(basic_acc - dp_acc):.4f}")
    
    # 5. 计算并输出隐私预算
    print("\n计算隐私预算...")
    eps, delta = compute_privacy_budget(
        n_samples=X_train.shape[0],
        batch_size=batch_size,
        noise_multiplier=noise_multiplier,
        epochs=epochs
    )
    print(f"隐私预算 (ε, δ): ({eps:.2f}, {delta:.2e})")
    
    # 6. 敏感特征影响分析
    print("\n敏感特征影响分析...")
    # 创建不包含敏感特征的数据集
    sensitive_indices = [feature_names.index(name) for name in sensitive_feature_names]
    X_train_no_sensitive = np.delete(X_train, sensitive_indices, axis=1)
    X_test_no_sensitive = np.delete(X_test, sensitive_indices, axis=1)
    
    # 创建并训练不含敏感特征的模型
    no_sensitive_model = create_basic_model(X_train_no_sensitive.shape[1])
    no_sensitive_model.compile(
        optimizer='adam',
        loss='binary_crossentropy',
        metrics=['accuracy']
    )
    
    no_sensitive_model.fit(
        X_train_no_sensitive, y_train,
        epochs=10,
        batch_size=32,
        validation_split=0.2,
        verbose=0
    )
    
    # 评估不含敏感特征的模型
    no_sensitive_loss, no_sensitive_acc = no_sensitive_model.evaluate(X_test_no_sensitive, y_test, verbose=0)
    print(f"不含敏感特征的模型 - 测试准确率: {no_sensitive_acc:.4f}")
    
    # 分析敏感特征的影响
    sensitivity_impact = basic_acc - no_sensitive_acc
    print(f"敏感特征对模型性能的影响: {sensitivity_impact:.4f}")
    
    # 7. 模型公平性分析（简单示例）
    print("\n模型公平性分析（简单示例）...")
    # 基于第一个敏感特征将测试集分为两组
    sensitive_feature_idx = feature_names.index(sensitive_feature_names[0])
    sensitive_values = X_test[:, sensitive_feature_idx]
    threshold = np.median(sensitive_values)
    
    # 分组
    group1_mask = sensitive_values <= threshold
    group2_mask = sensitive_values > threshold
    
    # 评估两组的模型性能
    group1_acc = dp_model.evaluate(X_test[group1_mask], y_test[group1_mask], verbose=0)[1]
    group2_acc = dp_model.evaluate(X_test[group2_mask], y_test[group2_mask], verbose=0)[1]
    
    print(f"差分隐私模型在分组1的准确率: {group1_acc:.4f}")
    print(f"差分隐私模型在分组2的准确率: {group2_acc:.4f}")
    print(f"准确率差异: {abs(group1_acc - group2_acc):.4f}")
    
    print("\n训练完成！")

if __name__ == "__main__":
    main()