विभेदक गोपनीयता: पुस्तकालयों की तुलना करना

• इसे बाईं ओर ले जाएं - उन लोगों की संपूर्ण गोपनीयता रखें, जिनका डेटा डेटासेट में है, लेकिन साथ ही जानकारी में बहुत अधिक शोर जोड़ते हैं, कुल आंकड़ों की सटीकता को कम करते हैं;
• दाईं ओर जाएं - आपको कुल आंकड़ों की सही सटीकता प्राप्त होती है, लेकिन डेटासेट से लोगों के बारे में निजी जानकारी प्रकट होती है।

कैसे डेटा परिवर्तित किया जाता है

डिफरेंशियल प्राइवेसी लाइब्रेरी की तुलना

• आईबीएम / अंतर-गोपनीयता-पुस्तकालय (पायथन)
• Google / अंतर-गोपनीयता (C ++)
• Brubinstein / diffpriv (R भाषा)

डेटासेट का परीक्षण करें

import random

def generate_weight_dataset(dataset_size):
    outpath = f"weights_{dataset_size}.csv"
    mu = 70  # mean
    sigma = 30  # standard deviation
    with open(outpath, "w+") as fout:
        for i in range(dataset_size):
            random_weight = random.normalvariate(mu, sigma)  # normal distribution
            random_weight = abs(random_weight)  # make sure weights are positive
            random_weight = round(random_weight, 1)  # round to 1 decimal digit
            line = f"{random_weight}"
            print(line, file=fout)

पुस्तकालयों का उपयोग करना

import diffprivlib.tools.utils

def dp_mean(weights, epsilon, upper):
    dp_mean = diffprivlib.tools.utils.mean(weights, epsilon=epsilon, range=upper)
    return dp_mean

upper = max(weights)
epsilon = 1.0
dpm = dp_mean(weights, epsilon, upper)

double dp_mean(std::list<double> weights, double epsilon, double lower, double upper) {
    std::unique_ptr<differential_privacy::BoundedMean<double>> mean_algorithm = 
    differential_privacy::BoundedMean<double>::Builder()
    .SetEpsilon(epsilon)
    .SetLower(0.0)
    .SetUpper(upper)
    .Build()
    .ValueOrDie();

    for (auto weight : weights) {
        mean_algorithm->AddEntry(weight);
    }
    double privacy_budget = 1.0;
    auto output = mean_algorithm->PartialResult(privacy_budget).ValueOrDie();
    return differential_privacy::GetValue<double>(output);
}

library(diffpriv)

dp_mean <- function(xs, epsilon) {
  ## a target function we'd like to run on private data X, releasing the result
  target <- function(X) mean(X)

  ## target seeks to release a numeric, so we'll use the Laplace mechanism---a
  ## standard generic mechanism for privatizing numeric responses
  n <- length(xs)
  mech <- DPMechLaplace(target = target, sensitivity = 1/n, dims = 1)

  r <- releaseResponse(mech, privacyParams = DPParamsEps(epsilon = epsilon), X = xs)
  r$response
}

गोपनीयता सटीकता को कैसे प्रभावित करती है

मानक त्रुटि

 //      . 
 //   privacy_budget   .  
  //     (0, 1],        .
  // ,         
  //    ,           0.5 ( 0.4,  0.6  ..).
  virtual double AddNoise(double result, double privacy_budget) {
    if (privacy_budget <= 0) {
      privacy_budget = std::numeric_limits<double>::min();
    }
    //  snapping-,  
    // (2012, "On Significance of the Least Significant Bits For Differential Privacy").
    double noise = distro_->Sample(1.0 / privacy_budget);
    double noised_result =
        Clamp<double>(LowerBound<double>(), UpperBound<double>(), result) +
        noise;
    double nearest_power = GetNextPowerOfTwo(diversity_ / privacy_budget);
    double remainder =
        (nearest_power == 0.0) ? 0.0 : fmod(noised_result, nearest_power);
    double rounded_result = noised_result - remainder;
    return ClampDouble<double>(LowerBound<double>(), UpperBound<double>(),
                               rounded_result);
  }

   //  :    .
    double normalized_sum = sum_mechanism_->AddNoise(
        sum - raw_count_ * midpoint_, remaining_budget);
    double average = normalized_sum / noised_count + midpoint_;
    AddToOutput<double>(&output, Clamp<double>(lower_, upper_, average));
    return output;

मानक विचलन

डेटासेट का आकार सटीकता को कैसे प्रभावित करता है

मानक त्रुटि

मानक विचलन

निष्कर्ष

संदर्भ

• विभेदक गोपनीयता (विकिपीडिया)
• विभेदक गोपनीयता की एल्गोरिथम बुनियादी बातें
• संख्यात्मक डेटा के अंतर गोपनीयता सुनिश्चित करने के लिए लाप्लास शोर जोड़ अनुमान
• :
• :