• Search by Module
• Search by Words
• Search Projects

• Java
• Python
• JavaScript
• TypeScript
• C++
• Scala
• Blog

• differential-privacy-library-master
  • .coveragerc
  • readthedocs.yml
  • diffprivlib
    • models
      • k_means.py
      • linear_regression.py
      • standard_scaler.py
      • __init__.py
      • naive_bayes.py
      • pca.py
      • logistic_regression.py
    • validation.py
    • mechanisms
      • vector.py
      • binary.py
      • geometric.py
      • uniform.py
      • wishart.py
      • exponential.py
      • laplace.py
      • __init__.py
      • staircase.py
      • transforms
        • stringtoint.py
        • __init__.py
        • roundedinteger.py
        • base.py
        • inttostring.py
      • gaussian.py
      • base.py
    • __init__.py
    • utils.py
    • accountant.py
    • tools
      • histograms.py
      • __init__.py
      • utils.py
  • .pylintrc
  • notebooks
    • pipeline_accuracy_500.p
    • logistic_regression.ipynb
    • pipeline.ipynb
    • naive_bayes.ipynb
    • linear_regression.ipynb
    • lr_accuracy_500.p
    • 30seconds.ipynb
    • accountant.ipynb
    • histograms.ipynb
    • exploration.ipynb
  • setup.py
  • LICENSE.md
  • setup.cfg
  • .travis.yml
  • README.md
  • tests
    • test_BudgetAccountant.py
    • models
      • test_KMeans.py
      • test_incremental_mean_and_var.py
      • test_LinearRegression.py
      • test_LogisticRegression.py
      • test_StandardScaler.py
      • test_logistic_regression_path.py
      • __init__.py
      • test_GaussianNB.py
      • test_PCA.py
    • test_Budget.py
    • mechanisms
      • test_GeometricFolded.py
      • test_DPMechanism.py
      • test_GeometricTruncated.py
      • test_LaplaceFolded.py
      • test_Laplace.py
      • test_Staircase.py
      • test_TruncationAndFoldingMixin.py
      • test_ExponentialHierarchical.py
      • test_Binary.py
      • test_DPMachine.py
      • test_Gaussian.py
      • test_Exponential.py
      • test_GaussianAnalytic.py
      • test_LaplaceBoundedDomain.py
      • test_LaplaceTruncated.py
      • __init__.py
      • test_Uniform.py
      • test_LaplaceBoundedNoise.py
      • test_Wishart.py
      • test_Vector.py
      • transforms
        • test_IntToString.py
        • test_StringToInt.py
        • test_DPTransformer.py
        • test_RoundedInteger.py
        • __init__.py
      • test_GaussianDiscrete.py
      • test_Geometric.py
    • test_clip_to_bounds.py
    • test_check_bounds.py
    • __init__.py
    • test_check_epsilon_delta.py
    • tools
      • test_histogram2d.py
      • test_nanmean.py
      • test_var.py
      • test_histogram.py
      • test_histogramdd.py
      • test_count_nonzero.py
      • test_mean.py
      • __init__.py
      • test_nansum.py
      • test_nanvar.py
      • test_sum.py
      • test_nanstd.py
      • test_std.py
    • test_clip_to_norm.py
  • .gitignore
  • docs
    • Makefile
    • make.bat
    • index.rst
    • conf.py
    • modules
      • mechanisms.rst
      • accountant.rst
      • transforms.rst
      • utils.rst
      • tools.rst
      • models.rst
      • validation.rst

from unittest.case import TestCase

import numpy as np
from sklearn.utils.extmath import _incremental_mean_and_var as sk_incremental_mean_and_var

from diffprivlib.models.standard_scaler import _incremental_mean_and_var
from diffprivlib.utils import PrivacyLeakWarning


class TestIncrementalMeanAndVar(TestCase):
    def test_no_range(self):
        X = np.random.rand(5, 10)
        with self.assertWarns(PrivacyLeakWarning):
            _incremental_mean_and_var(X, epsilon=float("inf"), bounds=None, last_mean=0., last_variance=None,
                                      last_sample_count=0)

    def test_inf_epsilon(self):
        X = np.random.rand(5, 10)
        dp_mean, dp_var, dp_count = _incremental_mean_and_var(X, epsilon=float("inf"), bounds=(0, 1), last_mean=0.,
                                                              last_variance=None,
                                                              last_sample_count=np.zeros(X.shape[1], dtype=np.int64))
        sk_mean, sk_var, sk_count = sk_incremental_mean_and_var(X, last_mean=0., last_variance=None,
                                                                last_sample_count=np.zeros(X.shape[1], dtype=np.int64))

        self.assertTrue(np.allclose(dp_mean, sk_mean))
        self.assertIsNone(dp_var)
        self.assertIsNone(sk_var)
        self.assertTrue((dp_count == sk_count).all())

        dp_mean, dp_var, dp_count = _incremental_mean_and_var(X, epsilon=float("inf"), bounds=(0, 1), last_mean=0.,
                                                              last_variance=0.,
                                                              last_sample_count=np.zeros(X.shape[1], dtype=np.int64))
        sk_mean, sk_var, sk_count = sk_incremental_mean_and_var(X, last_mean=0., last_variance=0.,
                                                                last_sample_count=np.zeros(X.shape[1], dtype=np.int64))

        self.assertTrue(np.allclose(dp_mean, sk_mean))
        self.assertTrue(np.allclose(dp_var, sk_var))
        self.assertTrue((dp_count == sk_count).all())

    def test_increment_inf_epsilon(self):
        X = np.ones((5, 1))
        dp_mean, dp_var, dp_count = _incremental_mean_and_var(X, epsilon=float("inf"), bounds=(0, 1), last_mean=0.,
                                                              last_variance=None, last_sample_count=5)
        self.assertAlmostEqual(dp_mean, 0.5, places=5)
        self.assertEqual(dp_count, 10)

    def test_duplicate_dataset(self):
        X = np.random.rand(10, 5)
        mean1, var1, count1 = _incremental_mean_and_var(X, epsilon=float("inf"), bounds=(0, 1), last_mean=0.,
                                                        last_variance=0., last_sample_count=0)

        mean2, var2, count2 = _incremental_mean_and_var(X, epsilon=float("inf"), bounds=(0, 1), last_mean=mean1,
                                                        last_variance=var1, last_sample_count=count1)

        self.assertTrue(np.allclose(mean1, mean2))
        self.assertTrue(np.allclose(var1, var2))
        self.assertTrue(np.all(count1 == 10), "Counts should be 10, got %s" % count1)
        self.assertTrue(np.all(count2 == 20), "Counts should be 20, got %s" % count2)

    def test_different_results(self):
        X = np.random.rand(10, 5)
        mean1, var1, count1 = _incremental_mean_and_var(X, epsilon=1, bounds=(0, 1), last_mean=0., last_variance=0.,
                                                        last_sample_count=0)

        mean2, var2, count2 = _incremental_mean_and_var(X, epsilon=1, bounds=(0, 1), last_mean=0, last_variance=0,
                                                        last_sample_count=0)

        self.assertFalse(np.allclose(mean1, mean2, atol=1e-2))
        self.assertFalse(np.allclose(var1, var2, atol=1e-2))
        self.assertTrue(np.all(count1 == 10), "Counts should be 10, got %s" % count1)
        self.assertTrue(np.all(count2 == 10), "Counts should be 10, got %s" % count2)