PHP 怎么差分隐私

wen PHP项目 2026-08-04 222

本文目录导读：

PHP 怎么差分隐私

基础工具：拉普拉斯噪声生成器
完整数值查询实现
指数机制（适用于非数值型输出）
复合查询与隐私预算管理
安全注意事项
多轮查询组合策略
实用建议

在 PHP 中实现差分隐私（Differential Privacy, DP）需要结合统计学原理和编程技巧，以下是核心实现方案，包含拉普拉斯机制和指数机制的完整代码示例及实用建议。

基础工具：拉普拉斯噪声生成器

差分隐私的核心是向查询结果添加受控噪声,拉普拉斯机制是最常用的方法：

<?php
/**
 * 生成拉普拉斯噪声（用于数值型查询）
 * @param float $epsilon 隐私预算（越小隐私保护越强）
 * @param float $sensitivity 敏感度（单条记录最大影响）
 * @return float 噪声值
 */
function laplaceNoise(float $epsilon, float $sensitivity): float {
    // 使用均匀分布生成标准拉普拉斯噪声
    $u = rand() / getrandmax() - 0.5; // [-0.5, 0.5]
    $beta = $sensitivity / $epsilon;
    return -$beta * sign($u) * log(1 - 2 * abs($u));
}
function sign(float $val): float {
    return $val >= 0 ? 1 : -1;
}
?>

完整数值查询实现

<?php
class DifferentialPrivacy {
    private float $epsilon;
    private float $sensitivity;
    public function __construct(float $epsilon = 1.0, float $sensitivity = 1.0) {
        $this->epsilon = $epsilon;
        $this->sensitivity = $sensitivity;
    }
    /**
     * 带噪声的计数查询（统计用户数量）
     */
    public function noisyCount(int $trueCount): int {
        $noise = $this->laplaceNoise();
        return max(0, (int) round($trueCount + $noise));
    }
    /**
     * 拉普拉斯噪声生成
     */
    private function laplaceNoise(): float {
        $u = (rand() / mt_getrandmax() - 0.5);
        $beta = $this->sensitivity / $this->epsilon;
        return -$beta * ($u >= 0 ? 1 : -1) * log(1 - 2 * abs($u));
    }
    /**
     * 数值求和处理（平均值）
     */
    public function noisySum(float $trueSum): float {
        return $trueSum + $this->laplaceNoise();
    }
}
// 使用示例
$dp = new DifferentialPrivacy(epsilon: 0.5, sensitivity: 1);
$realCount = 1000;
$reportedCount = $dp->noisyCount($realCount);
echo "真实值: {$realCount}, 发布值: {$reportedCount}";
?>

指数机制（适用于非数值型输出）

<?php
/**
 * 指数机制：用于选择最佳选项（如调查报告）
 * @param array $scores 每个选项的评分
 * @param float $epsilon 隐私预算
 * @return mixed 返回选择的选项key
 */
function exponentialMechanism(array $scores, float $epsilon): mixed {
    $maxScore = max($scores);
    $sensitivity = 1.0; // 评分函数敏感度
    // 计算每个选项被选择的概率权重
    $weights = [];
    foreach ($scores as $key => $score) {
        $scoreDiff = $maxScore - $score;
        $weights[$key] = exp(($epsilon * $scoreDiff) / (2 * $sensitivity));
    }
    // 按权重随机选择
    $totalWeight = array_sum($weights);
    $randomValue = mt_rand() / mt_getrandmax() * $totalWeight;
    $cumulative = 0;
    foreach ($weights as $key => $weight) {
        $cumulative += $weight;
        if ($randomValue <= $cumulative) {
            return $key;
        }
    }
    return array_key_first($scores);
}
// 使用示例
$options = ['A' => 85, 'B' => 72, 'C' => 67];
$bestOption = exponentialMechanism($options, 0.8);
echo "推荐选项: {$bestOption}";
?>

复合查询与隐私预算管理

<?php
class PrivacyBudgetManager {
    private float $totalEpsilon;
    private float $consumedEpsilon = 0;
    public function __construct(float $totalEpsilon) {
        $this->totalEpsilon = $totalEpsilon;
    }
    /**
     * 获取可用的隐私预算（自动分配）
     */
    public function allocateBudget(): float {
        $remaining = $this->totalEpsilon - $this->consumedEpsilon;
        if ($remaining <= 0) {
            throw new RuntimeException("隐私预算已耗尽");
        }
        // 每次分配总预算的20%
        $allocation = min($remaining, $this->totalEpsilon * 0.2);
        $this->consumedEpsilon += $allocation;
        return $allocation;
    }
    public function getRemaining(): float {
        return $this->totalEpsilon - $this->consumedEpsilon;
    }
}
// 复合查询示例
$budget = new PrivacyBudgetManager(2.0);
$dpCount = new DifferentialPrivacy($budget->allocateBudget(), 1);
$dpAvg = new DifferentialPrivacy($budget->allocateBudget(), 1/100); // 平均值的敏感度
$countResult = $dpCount->noisyCount(10000);
$avgResult = $dpAvg->noisySum(25.7);
echo "剩余预算: {$budget->getRemaining()}\n";
?>

安全注意事项

敏感度计算：

// 计数查询敏感度为1
$sensitivity = 1;
// 求和查询敏感度 = 数据最大可能值
$sensitivity = 10000; // 假设单条记录最大金额
// 平均值敏感度 = 最大最小值之差 / 记录数
$sensitivity = (max($data) - min($data)) / count($data);

噪声截断：

// 防止噪声导致负值
$noiseResult = max(0, min($result, PHP_INT_MAX));

随机数安全性：

// 生产环境使用更安全的随机源
function secureLaplaceNoise(...) {
    $u = random_int(0, PHP_INT_MAX) / PHP_INT_MAX - 0.5;
    // ... 其余逻辑相同
}

多轮查询组合策略

<?php
/**
 * 使用自适应隐私预算分配（顺序组合定理）
 */
function sequentialComposition(array $queries, float $totalEpsilon) {
    $n = count($queries);
    $perQueryEpsilon = $totalEpsilon / $n; // 简单均分
    $results = [];
    foreach ($queries as $index => $query) {
        $dp = new DifferentialPrivacy($perQueryEpsilon, $query['sensitivity']);
        $results[] = $query['type'] === 'count' 
            ? $dp->noisyCount($query['value'])
            : $dp->noisySum($query['value']);
    }
    return $results;
}
// 并行组合（各查询独立）
function parallelComposition(array $queries, float $totalEpsilon) {
    foreach ($queries as &$query) {
        $dp = new DifferentialPrivacy($totalEpsilon, $query['sensitivity']);
        $query['noisy_result'] = $dp->noisyCount($query['value']);
    }
    return $queries;
}
?>