def test_fail_groupby(): with sn.Analysis() as analysis: data = sn.Dataset(path=TEST_PUMS_PATH, column_names=TEST_PUMS_NAMES) is_male = sn.to_bool(data['sex'], true_label="1") educ_inc = sn.impute( sn.clamp(sn.to_float(data[['educ', 'income']]), lower=[0., 0.], upper=[15., 200_000.])) partitioned = sn.partition(educ_inc, by=is_male) bounds = { "data_lower": [0., 0.], "data_upper": [15., 200_000.], "data_rows": 500 } union = sn.union({ True: sn.mean(partitioned[True], privacy_usage={"epsilon": 0.1}, **bounds), False: sn.mean(partitioned[False], **bounds), }) sn.laplace_mechanism(union, privacy_usage={"epsilon": 1.0}) print(analysis.privacy_usage)
def analytic_gaussian_similarity(): analytic_gauss_estimates = [] gauss_estimates = [] with sn.Analysis(strict_parameter_checks=False): PUMS = sn.Dataset(path=TEST_PUMS_PATH, column_names=TEST_PUMS_NAMES) age = sn.impute(sn.to_float(PUMS['age']), data_lower=0., data_upper=100., data_rows=1000) for i in range(100): an_gauss_component = sn.dp_mean(age, mechanism="AnalyticGaussian", privacy_usage={ "epsilon": 1.0, "delta": 1E-6 }) gauss_component = sn.dp_mean(age, mechanism="Gaussian", privacy_usage={ "epsilon": 1.0, "delta": 1E-6 }) # this triggers an analysis.release (which also computes gauss_component) analytic_gauss_estimates.append(an_gauss_component.value) gauss_estimates.append(gauss_component.value) print(sum(analytic_gauss_estimates) / len(analytic_gauss_estimates)) print(sum(gauss_estimates) / len(gauss_estimates))
def test_groupby_3(): # now union the released output with sn.Analysis() as analysis: data = sn.Dataset(path=TEST_PUMS_PATH, column_names=TEST_PUMS_NAMES) is_male = sn.to_bool(data['sex'], true_label="1") educ_inc = sn.impute( sn.clamp(sn.to_float(data[['educ', 'income']]), lower=[0., 0.], upper=[15., 200_000.])) partitioned = sn.partition(educ_inc, by=is_male) means = {} for cat in is_male.categories: part = partitioned[cat] part = sn.resize(part, number_rows=500) part = sn.dp_mean(part, privacy_usage={"epsilon": 1.0}) # print("mean: ", part.properties) means[cat] = part union = sn.union(means) # analysis.plot() analysis.release() print(analysis.privacy_usage) print(union.value)
def test_groupby_c_stab(): # use the same partition multiple times in union with sn.Analysis() as analysis: data = sn.Dataset(path=TEST_PUMS_PATH, column_names=TEST_PUMS_NAMES) is_male = sn.to_bool(data['sex'], true_label="1") educ_inc = sn.impute( sn.clamp(sn.to_float(data[['educ', 'income']]), lower=[0., 0.], upper=[15., 200_000.])) partitioned = sn.partition(educ_inc, by=is_male) def analyze(data): return sn.mean(sn.resize(data, number_rows=500)) means = { True: analyze(partitioned[True]), False: analyze(partitioned[False]), "duplicate_that_inflates_c_stab": analyze(partitioned[True]), } union = sn.union(means) noised = sn.laplace_mechanism(union, privacy_usage={"epsilon": 1.0}) # analysis.plot() analysis.release() print(analysis.privacy_usage) print(noised.value)
def test_groupby_4(): # now union private data, and apply mechanism after with sn.Analysis() as analysis: data = sn.Dataset(path=TEST_PUMS_PATH, column_names=TEST_PUMS_NAMES) is_male = sn.to_bool(data['sex'], true_label="1") educ_inc = sn.impute( sn.clamp(sn.to_float(data[['educ', 'income']]), lower=[0., 0.], upper=[15., 200_000.])) partitioned = sn.partition(educ_inc, by=is_male) means = {} for cat in is_male.categories: part = partitioned[cat] part = sn.resize(part, number_rows=500) part = sn.mean(part) means[cat] = part union = sn.union(means) noised = sn.laplace_mechanism(union, privacy_usage={"epsilon": 1.0}) # analysis.plot() analysis.release() print(analysis.privacy_usage) print(noised.value)
def snapping_similarity(): snapping_estimates = [] laplace_estimates = [] with sn.Analysis(strict_parameter_checks=False): PUMS = sn.Dataset(path=TEST_PUMS_PATH, column_names=TEST_PUMS_NAMES) age = sn.impute(sn.to_float(PUMS['age']), data_lower=0., data_upper=100., data_rows=1000) for i in range(100): snapping_component = sn.dp_mean(age, mechanism="snapping", privacy_usage={ "epsilon": 1.0, "delta": 1E-6 }) laplace_component = sn.dp_mean(age, mechanism="laplace", privacy_usage={ "epsilon": 1.0, "delta": 1E-6 }) snapping_estimates.append(snapping_component.value) laplace_estimates.append(laplace_component.value) print(sum(snapping_estimates) / len(snapping_estimates)) print(sum(laplace_estimates) / len(laplace_estimates))
def test_dataframe_partitioning_2(): # dataframe partition with multi-index grouping with sn.Analysis() as analysis: data = sn.Dataset(path=TEST_PUMS_PATH, column_names=TEST_PUMS_NAMES) grouper = sn.clamp(data[['sex', 'educ']], categories=[['0', '1'], [str(i) for i in range(14)]], null_value='-1') partitioned = sn.partition(data, by=grouper) sn.union( { key: sn.dp_count(partitioned[key], privacy_usage={"epsilon": 0.5}) for key in partitioned.partition_keys }, flatten=False) print( sn.union({ key: sn.dp_mean( sn.to_float(partitioned[key]['income']), implementation="plug-in", # data_rows=100, data_lower=0., data_upper=200_000., privacy_usage={"epsilon": 0.5}) for key in partitioned.partition_keys }))
def test_multilayer_partition_1(): # multilayer partition with mechanisms applied inside partitions with sn.Analysis() as analysis: data = sn.Dataset(path=TEST_PUMS_PATH, column_names=TEST_PUMS_NAMES) is_male = sn.to_bool(data['sex'], true_label="1") educ_inc = sn.impute( sn.clamp(sn.to_float(data[['educ', 'income']]), lower=[0., 0.], upper=[15., 200_000.])) partitioned = sn.partition(educ_inc, by=is_male) def analyze(data): educ = sn.clamp(sn.to_int(sn.index(data, indices=0), lower=0, upper=15), categories=list(range(15)), null_value=-1) income = sn.index(data, indices=1) repartitioned = sn.partition(income, by=educ) inner_count = {} inner_means = {} for key in [5, 8, 12]: educ_level_part = repartitioned[key] inner_count[key] = sn.dp_count(educ_level_part, privacy_usage={"epsilon": 0.4}) inner_means[key] = sn.dp_mean(educ_level_part, privacy_usage={"epsilon": 0.6}, data_rows=sn.row_max( 1, inner_count[key])) return sn.union(inner_means, flatten=False), sn.union(inner_count, flatten=False) means = {} counts = {} for key in partitioned.partition_keys: part_means, part_counts = analyze(partitioned[key]) means[key] = part_means counts[key] = part_counts means = sn.union(means, flatten=False) counts = sn.union(counts, flatten=False) # analysis.plot() print("releasing") print(len(analysis.components.items())) analysis.release() print(analysis.privacy_usage) print("Counts:") print(counts.value) print("Means:") print(means.value)
def test_dp_covariance(): # establish data information var_names = ["age", "sex", "educ", "race", "income", "married"] with sn.Analysis() as analysis: wn_data = sn.Dataset(path=TEST_PUMS_PATH, column_names=TEST_PUMS_NAMES) # # get scalar covariance age_income_cov_scalar = sn.dp_covariance( left=sn.to_float(wn_data['age']), right=sn.to_float(wn_data['income']), privacy_usage={'epsilon': 5000}, left_lower=0., left_upper=100., left_rows=1000, right_lower=0., right_upper=500_000., right_rows=1000) data = sn.to_float(wn_data['age', 'income']) # get full covariance matrix age_income_cov_matrix = sn.dp_covariance( data=data, privacy_usage={'epsilon': 5000}, data_lower=[0., 0.], data_upper=[100., 500_000.], data_rows=1000) # get cross-covariance matrix cross_covar = sn.dp_covariance(left=data, right=data, privacy_usage={'epsilon': 5000}, left_lower=[0., 0.], left_upper=[100., 500_000.], left_rows=1_000, right_lower=[0., 0.], right_upper=[100., 500_000.], right_rows=1000) analysis.release() print('scalar covariance:\n{0}\n'.format(age_income_cov_scalar.value)) print('covariance matrix:\n{0}\n'.format(age_income_cov_matrix.value)) print('cross-covariance matrix:\n{0}'.format(cross_covar.value))
def test_private_clamped_sum_helpers(): # Compute the CI with smartnoise with sn.Analysis() as analysis: data = sn.Dataset(path=TEST_DATA_PATH, column_names=TEST_DATA_COLUMNS) D = sn.to_float(data["age"]) D_tilde = sn.resize(sn.clamp(data=D, lower=0.0, upper=100.0), number_rows=1000,) release = sn.dp_sum(data=sn.impute(D_tilde), privacy_usage={"epsilon": 1.0}) smartnoise_ci = release.get_accuracy(0.05) op = PrivateClampedSum(lower_bound=0, upper_bound=100) eeprivacy_ci = op.confidence_interval(epsilon=1, confidence=0.95) assert pytest.approx(smartnoise_ci, abs=0.001) == eeprivacy_ci
def test_reports(): with sn.Analysis() as analysis: # load data data = sn.Dataset(path=TEST_PUMS_PATH, column_names=TEST_PUMS_NAMES) # get mean of age age_mean = sn.dp_mean(data=sn.to_float(data['age']), privacy_usage={'epsilon': .65}, data_lower=0., data_upper=100., data_rows=1000) print("Pre-Release\n") print("DP mean of age: {0}".format(age_mean.value)) print("Privacy usage: {0}\n\n".format(analysis.privacy_usage))
def try_sn(): # establish data information #data_path = 'https://raw.githubusercontent.com/opendp/smartnoise-samples/86-requirements-fix/analysis/data/PUMS_california_demographics_1000/data.csv' data_path = os.path.join('.', 'data', 'PUMS_california_demographics_1000', 'data.csv') data_path = os.path.abspath(data_path) print('data_path', data_path) var_names = ["age", "sex", "educ", "race", "income", "married", "pid"] D = pd.read_csv(data_path)['age'] D_mean_age = np.mean(D) print('D_mean_age', D_mean_age) # establish extra information for this simulation age_lower_bound = 0. age_upper_bound = 100. D_tilde = np.clip(D, age_lower_bound, age_upper_bound) D_tilde_mean_age = np.mean(D_tilde) data_size = 1000 df = pd.read_csv(data_path) df_as_array = [list(row) for row in df.itertuples()] #df.values.tolist() print('D.values', df_as_array) n_sims = 2 releases = [] with sn.Analysis(dynamic=True) as analysis: data = sn.Dataset(path=data_path, column_names=var_names) #data = sn.Dataset(value=df_as_array, column_names=var_names) D = sn.to_float(data['age']) # preprocess data (resize is a no-op because we have the correct data size) D_tilde = sn.resize(sn.clamp(data=D, lower=0., upper=100.), number_rows=data_size) for index in range(n_sims): # get DP mean of age releases.append( sn.dp_mean(data=sn.impute(D_tilde), privacy_usage={'epsilon': 1})) accuracy = releases[0].get_accuracy(0.05) analysis.release() dp_values = [release.value for release in releases] print( 'Accuracy interval (with accuracy value {0}) contains the true mean on D_tilde with probability {1}' .format( round(accuracy, 4), np.mean([(D_tilde_mean_age >= val - accuracy) & (D_tilde_mean_age <= val + accuracy) for val in dp_values])))
def test_raw_dataset(run=True): with sn.Analysis() as analysis: data = sn.to_float(sn.Dataset(value=[1., 2., 3., 4., 5.])) sn.dp_mean(data=data, privacy_usage={'epsilon': 1}, data_lower=0., data_upper=10., data_rows=10, data_columns=1) if run: analysis.release() return analysis
def test_map_3(): # chain multiple maps over an array partition with implicit preprocessing with sn.Analysis() as analysis: data = sn.Dataset(path=TEST_PUMS_PATH, column_names=TEST_PUMS_NAMES) partitioned = sn.partition(sn.to_float(data['age']), by=sn.to_bool(data['sex'], true_label="1")) means = sn.dp_mean(partitioned, privacy_usage={'epsilon': 0.1}, data_rows=500, data_lower=0., data_upper=15.) print(means.value) print(analysis.privacy_usage)
def test_covariance(): import numpy as np import pandas as pd import matplotlib.pyplot as plt data = np.genfromtxt(TEST_PUMS_PATH, delimiter=',', names=True) with sn.Analysis() as analysis: wn_data = sn.Dataset(path=TEST_PUMS_PATH, column_names=TEST_PUMS_NAMES) # get full covariance matrix cov = sn.dp_covariance(data=sn.to_float(wn_data['age', 'sex', 'educ', 'income', 'married']), privacy_usage={'epsilon': 10}, data_lower=[0., 0., 1., 0., 0.], data_upper=[100., 1., 16., 500_000., 1.], data_rows=1000) analysis.release() # store DP covariance and correlation matrix dp_cov = cov.value print(dp_cov) dp_corr = dp_cov / np.outer(np.sqrt(np.diag(dp_cov)), np.sqrt(np.diag(dp_cov))) # get non-DP covariance/correlation matrices age = list(data[:]['age']) sex = list(data[:]['sex']) educ = list(data[:]['educ']) income = list(data[:]['income']) married = list(data[:]['married']) non_dp_cov = np.cov([age, sex, educ, income, married]) non_dp_corr = non_dp_cov / np.outer(np.sqrt(np.diag(non_dp_cov)), np.sqrt(np.diag(non_dp_cov))) print('Non-DP Covariance Matrix:\n{0}\n\n'.format( pd.DataFrame(non_dp_cov))) print('Non-DP Correlation Matrix:\n{0}\n\n'.format( pd.DataFrame(non_dp_corr))) print('DP Correlation Matrix:\n{0}'.format(pd.DataFrame(dp_corr))) # skip plot step if IS_CI_BUILD: return plt.imshow(non_dp_corr - dp_corr, interpolation='nearest') plt.colorbar() plt.show()
def test_median_education(): # import pandas as pd # print(pd.read_csv(data_path)['value'].median()) with sn.Analysis(filter_level="all") as analysis: data = sn.Dataset(path=TEST_EDUC_PATH, column_names=TEST_EDUC_NAMES) candidates = list(map(float, range(1, 200, 2))) median_scores = sn.median(sn.impute(sn.to_float(data['value']), 100., 200.), candidates=candidates) # print(list(zip(candidates, median_scores.value[0]))) dp_median = sn.exponential_mechanism(median_scores, candidates=candidates, privacy_usage={"epsilon": 100.}) print(dp_median.value) analysis.release()
def test_dp_median_raw(): with sn.Analysis() as analysis: # create a literal data vector, and tag it as private data = sn.Component.of([float(i) for i in range(20)], public=False) dp_median = sn.dp_median( sn.to_float(data), privacy_usage={ "epsilon": 1. }, candidates=[-10., -2., 2., 3., 4., 7., 10., 12.], data_lower=0., data_upper=10., data_columns=1).value print(dp_median) # analysis.plot() assert dp_median is not None
def test_dataframe_partitioning_1(): # dataframe partition with sn.Analysis() as analysis: data = sn.Dataset(path=TEST_PUMS_PATH, column_names=TEST_PUMS_NAMES) is_male = sn.to_bool(data['sex'], true_label="1") partitioned = sn.partition(data, by=is_male) print( sn.union({ key: sn.dp_mean(sn.impute( sn.clamp(sn.to_float(partitioned[key]['income']), 0., 200_000.)), implementation="plug-in", privacy_usage={"epsilon": 0.5}) for key in partitioned.partition_keys }).value) print(analysis.privacy_usage)
def test_dp_linear_regression(): with sn.Analysis(): wn_data = sn.Dataset(path=TEST_PUMS_PATH, column_names=TEST_PUMS_NAMES) wn_data = sn.resize(sn.to_float(wn_data[["age", "income"]]), number_rows=1000, lower=[0., 0.], upper=[100., 500_000.]) dp_linear_regression = sn.dp_linear_regression( data_x=sn.index(wn_data, indices=0), data_y=sn.index(wn_data, indices=1), privacy_usage={'epsilon': 10.}, lower_slope=0., upper_slope=1000., lower_intercept=0., upper_intercept=1000.) print(dp_linear_regression.value)
def test_snapping(): with sn.Analysis(): PUMS = sn.Dataset(path=TEST_PUMS_PATH, column_names=TEST_PUMS_NAMES) statistic = sn.mean(sn.to_float(PUMS['age']), data_lower=0., data_upper=100., data_rows=1000) privatized = sn.snapping_mechanism(statistic, lower=30., upper=70., binding_probability=0.4, privacy_usage={"epsilon": 0.1}) print(privatized.value) print(privatized.get_accuracy(0.5)) necessary_usage = privatized.from_accuracy(4., 0.5) print("usage: ", necessary_usage) print("accuracy: ", privatized.get_accuracy(0.5, necessary_usage))
def test_map_4(): # chain multiple mapped releases over a partition with implicit preprocessing with sn.Analysis() as analysis: data = sn.Dataset(path=TEST_PUMS_PATH, column_names=TEST_PUMS_NAMES) partitioned = sn.partition(sn.to_float(data['age']), by=sn.to_bool(data['sex'], true_label="1")) counts = sn.row_max( 1, sn.dp_count(partitioned, privacy_usage={'epsilon': 0.5})) means = sn.dp_mean(partitioned, privacy_usage={'epsilon': 0.7}, data_rows=counts, data_lower=0., data_upper=15.) print("counts:", counts.value) print("means:", means.value) print(analysis.privacy_usage)
def test_dp_mean(): with sn.Analysis(): data = generate_synthetic(float, variants=['Random']) mean = sn.dp_mean(data['F_Random'], privacy_usage={'epsilon': 0.1}, data_lower=0., data_upper=10., data_rows=10) print("accuracy", mean.get_accuracy(0.05)) print(mean.from_accuracy(2.3, .05)) with sn.Analysis(): data = sn.Dataset(path=TEST_PUMS_PATH, column_names=TEST_PUMS_NAMES) print( sn.dp_mean(sn.to_float(data['income']), implementation="plug-in", data_lower=0., data_upper=200_000., privacy_usage={ "epsilon": 0.5 }).value)
def test_mechanism(args, constructor): with sn.Analysis() as analysis: PUMS = sn.Dataset(path=TEST_PUMS_PATH, column_names=TEST_PUMS_NAMES) categorical = sn.resize(sn.clamp(PUMS['sex'], categories=["0", "1"], null_value="0"), number_rows=1000) numeric = sn.impute(sn.to_float(PUMS['age']), data_lower=0., data_upper=100., data_rows=1000) all = constructor(numeric, categorical, args) analysis.release() all_values = {stat: all[stat].value for stat in all} print() pprint(all_values) for value in all_values.values(): assert value is not None
def test_private_clamped_mean_helpers(): # Compute the CI with smartnoise with sn.Analysis() as analysis: data = sn.Dataset(path=TEST_DATA_PATH, column_names=TEST_DATA_COLUMNS) D = sn.to_float(data["age"]) D_tilde = sn.resize(sn.clamp(data=D, lower=0.0, upper=100.0), number_rows=1000,) release = sn.dp_mean(data=sn.impute(D_tilde), privacy_usage={"epsilon": 1.0}) smartnoise_ci = release.get_accuracy(0.05) # Compute the CI with eeprivacy op = PrivateClampedMean(lower_bound=0, upper_bound=100) eeprivacy_ci = op.confidence_interval(epsilon=1, N=1000, confidence=0.95) # Compare computed confidence intervals assert pytest.approx(smartnoise_ci, abs=0.001) == eeprivacy_ci smartnoise_epsilon = release.from_accuracy(value=1, alpha=0.05)[0]["epsilon"] eeprivacy_epsilon = op.epsilon_for_confidence_interval( target_ci=1, N=1000, confidence=0.95 ) # Compare computed epsilons for confidence interval assert pytest.approx(smartnoise_epsilon, abs=0.001) == eeprivacy_epsilon
def test_groupby_2(): with sn.Analysis() as analysis: data = sn.Dataset(path=TEST_PUMS_PATH, column_names=TEST_PUMS_NAMES) is_male = sn.to_bool(data['sex'], true_label="1") partitioned = sn.partition(sn.to_float(data[['educ', 'income']]), by=is_male) counts = { True: sn.dp_count(partitioned[True], privacy_usage={'epsilon': 0.1}), False: sn.dp_mean(partitioned[False], privacy_usage={'epsilon': 0.1}, data_rows=500, data_lower=[0., 0.], data_upper=[15., 200_000.]) } # analysis.plot() analysis.release() print(analysis.privacy_usage) print({cat: counts[cat].value for cat in counts})
def test_histogram(): # generate raw data import numpy as np import pandas as pd import tempfile import os n = 1000 data = np.random.normal(loc=10, scale=25, size=n) mean = np.mean(data) sd = np.std(data) data = pd.DataFrame([(elem - mean) / sd for elem in data]) with sn.Analysis(), tempfile.TemporaryDirectory() as temp_dir: data_path = os.path.join(temp_dir, 'temp_data.csv') data.to_csv(data_path) print( sn.dp_histogram(sn.to_float( sn.Dataset(path=data_path, column_names=['d'])['d']), edges=np.linspace(-3., 3., 1000), privacy_usage={ 'epsilon': 0.1 }).value)
def test_multilayer_analysis(run=True): with sn.Analysis() as analysis: PUMS = sn.Dataset(path=TEST_PUMS_PATH, column_names=TEST_PUMS_NAMES) age = sn.to_float(PUMS['age']) sex = sn.to_bool(PUMS['sex'], true_label="TRUE") age_clamped = sn.clamp(age, lower=0., upper=150.) age_resized = sn.resize(age_clamped, number_rows=1000) race = sn.to_float(PUMS['race']) mean_age = sn.dp_mean(data=race, privacy_usage={'epsilon': .65}, data_lower=0., data_upper=100., data_rows=500) analysis.release() sex_plus_22 = sn.add(sn.to_float(sex), 22., left_rows=1000, left_lower=0., left_upper=1.) sn.dp_mean(age_resized / 2. + sex_plus_22, privacy_usage={'epsilon': .1}, data_lower=mean_age - 5.2, data_upper=102., data_rows=500) + 5. sn.dp_variance(data=sn.to_float(PUMS['educ']), privacy_usage={'epsilon': .15}, data_rows=1000, data_lower=0., data_upper=12.) # sn.dp_raw_moment( # sn.to_float(PUMS['married']), # privacy_usage={'epsilon': .15}, # data_rows=1000000, # data_lower=0., # data_upper=12., # order=3 # ) # # sn.dp_covariance( # left=sn.to_float(PUMS['age']), # right=sn.to_float(PUMS['married']), # privacy_usage={'epsilon': .15}, # left_rows=1000, # right_rows=1000, # left_lower=0., # left_upper=1., # right_lower=0., # right_upper=1. # ) if run: analysis.release() return analysis
def create_dicts(data, non_income_data, plausible_variable_combinations): count_dict = dict() priv_count_dict = dict() mean_income_dict = dict() priv_mean_income_dict = dict() median_income_dict = dict() priv_median_income_dict = dict() min_income_dict = dict() priv_min_income_dict = dict() max_income_dict = dict() priv_max_income_dict = dict() # get number of data elements with each set of variable values for i, combination in enumerate(plausible_variable_combinations): # print('run {0} of {1}'.format(i+1, len(plausible_variable_combinations))) if len(combination) == 1: dt = data[non_income_data[combination[0]] == 1] elif len(combination) == 2: dt = data[(non_income_data[combination[0]] == 1) & (non_income_data[combination[1]] == 1)] elif len(combination) == 3: dt = data[(non_income_data[combination[0]] == 1) & (non_income_data[combination[1]] == 1) & (non_income_data[combination[2]] == 1)] elif len(combination) == 4: dt = data[(non_income_data[combination[0]] == 1) & (non_income_data[combination[1]] == 1) & (non_income_data[combination[2]] == 1) & (non_income_data[combination[3]] == 1)] elif len(combination) == 5: dt = data[(non_income_data[combination[0]] == 1) & (non_income_data[combination[1]] == 1) & (non_income_data[combination[2]] == 1) & (non_income_data[combination[3]] == 1) & (non_income_data[combination[4]] == 1)] count_dict['__'.join(combination)] = dt.shape[0] mean_income_dict['__'.join(combination)] = np.mean(dt['income']) median_income_dict['__'.join(combination)] = np.median(dt['income']) min_income_dict['__'.join(combination)] = np.min(dt['income']) max_income_dict['__'.join(combination)] = np.max(dt['income']) with sn.Analysis() as analysis: # load data priv_data = sn.Dataset(value=dt['income']) # estimate sample size count = sn.dp_count(priv_data, privacy_usage={'epsilon': .05}) # preprocess data priv_data = sn.resize(sn.to_float(priv_data), number_columns=1, number_rows=sn.row_max(1, count), lower=0., upper=100_000.) priv_data = sn.impute(sn.clamp(priv_data, lower=0., upper=100_000.)) # get mean mean = sn.dp_mean(priv_data, privacy_usage={'epsilon': 0.1}) # get median median = sn.dp_median(priv_data, privacy_usage={'epsilon': 0.1}) # get min _min = sn.dp_minimum(priv_data, privacy_usage={'epsilon': 0.1}) # get max _max = sn.dp_maximum(priv_data, privacy_usage={'epsilon': 0.1}) analysis.release() priv_count_dict['__'.join(combination)] = max(0, count.value) priv_mean_income_dict['__'.join(combination)] = min( max(0, mean.value), 100_000) priv_median_income_dict['__'.join(combination)] = min( max(0, median.value), 100_000) priv_min_income_dict['__'.join(combination)] = min( max(0, _min.value), 100_000) priv_max_income_dict['__'.join(combination)] = min( max(0, _max.value), 100_000) return (count_dict, priv_count_dict, mean_income_dict, priv_mean_income_dict, median_income_dict, priv_median_income_dict, min_income_dict, priv_min_income_dict, max_income_dict, priv_max_income_dict)
def test_dp_linear_stats(run=True): with sn.Analysis() as analysis: dataset_pums = sn.Dataset(path=TEST_PUMS_PATH, column_names=TEST_PUMS_NAMES) age = dataset_pums['age'] analysis.release() num_records = sn.dp_count(age, privacy_usage={'epsilon': .5}, lower=0, upper=10000) analysis.release() print("number of records:", num_records.value) vars = sn.to_float(dataset_pums[["age", "income"]]) covariance = sn.dp_covariance(data=vars, privacy_usage={'epsilon': .5}, data_lower=[0., 0.], data_upper=[150., 150000.], data_rows=num_records) print("covariance released") num_means = sn.dp_mean(data=vars, privacy_usage={'epsilon': .5}, data_lower=[0., 0.], data_upper=[150., 150000.], data_rows=num_records) analysis.release() print("covariance:\n", covariance.value) print("means:\n", num_means.value) age = sn.to_float(age) age_variance = sn.dp_variance(age, privacy_usage={'epsilon': .5}, data_lower=0., data_upper=150., data_rows=num_records) analysis.release() print("age variance:", age_variance.value) # If I clamp, impute, resize, then I can reuse their properties for multiple statistics clamped_age = sn.clamp(age, lower=0., upper=100.) imputed_age = sn.impute(clamped_age) preprocessed_age = sn.resize(imputed_age, number_rows=num_records) # properties necessary for mean are statically known mean = sn.dp_mean(preprocessed_age, privacy_usage={'epsilon': .5}) # properties necessary for variance are statically known variance = sn.dp_variance(preprocessed_age, privacy_usage={'epsilon': .5}) # sum doesn't need n, so I pass the data in before resizing age_sum = sn.dp_sum(imputed_age, privacy_usage={'epsilon': .5}) # mean with lower, upper properties propagated up from prior bounds transformed_mean = sn.dp_mean(-(preprocessed_age + 2.), privacy_usage={'epsilon': .5}) analysis.release() print("age transformed mean:", transformed_mean.value) # releases may be pieced together from combinations of smaller components custom_mean = sn.laplace_mechanism(sn.mean(preprocessed_age), privacy_usage={'epsilon': .5}) custom_maximum = sn.laplace_mechanism(sn.maximum(preprocessed_age), privacy_usage={'epsilon': .5}) custom_maximum = sn.laplace_mechanism(sn.maximum(preprocessed_age), privacy_usage={'epsilon': .5}) custom_quantile = sn.laplace_mechanism(sn.quantile(preprocessed_age, alpha=.5), privacy_usage={'epsilon': 500}) income = sn.to_float(dataset_pums['income']) income_max = sn.laplace_mechanism(sn.maximum(income, data_lower=0., data_upper=1000000.), privacy_usage={'epsilon': 10}) # releases may also be postprocessed and reused as arguments to more components age_sum + custom_maximum * 23. analysis.release() print("laplace quantile:", custom_quantile.value) age_histogram = sn.dp_histogram(sn.to_int(age, lower=0, upper=100), edges=list(range(0, 100, 25)), null_value=150, privacy_usage={'epsilon': 2.}) sex_histogram = sn.dp_histogram(sn.to_bool(dataset_pums['sex'], true_label="1"), privacy_usage={'epsilon': 2.}) education_histogram = sn.dp_histogram(dataset_pums['educ'], categories=["5", "7", "10"], null_value="-1", privacy_usage={'epsilon': 2.}) analysis.release() print("age histogram: ", age_histogram.value) print("sex histogram: ", sex_histogram.value) print("education histogram: ", education_histogram.value) if run: analysis.release() # get the mean computed when release() was called print(mean.value) print(variance.value) return analysis
def test_everything(run=True): with sn.Analysis() as analysis: data = sn.Dataset(path=TEST_PUMS_PATH, column_names=TEST_PUMS_NAMES) age_int = sn.to_int(data['age'], 0, 150) sex = sn.to_bool(data['sex'], "1") educ = sn.to_float(data['educ']) race = data['race'] income = sn.to_float(data['income']) married = sn.to_bool(data['married'], "1") numerics = sn.to_float(data[['age', 'income']]) # intentionally busted component # print("invalid component id ", (sex + "a").component_id) # broadcast scalar over 2d, broadcast scalar over 1d, columnar broadcasting, left and right mul numerics * 2. + 2. * educ # add different values for each column numerics + [[1., 2.]] # index into first column age = sn.index(numerics, indices=0) income = sn.index(numerics, mask=[False, True]) # boolean ops and broadcasting mask = sex & married | (~married ^ False) | (age > 50.) | (age_int == 25) # numerical clamping sn.clamp(numerics, 0., [150., 150_000.]) sn.clamp(data['educ'], categories=[str(i) for i in range(8, 10)], null_value="-1") sn.count(mask) sn.covariance(age, income) sn.digitize(educ, edges=[1., 3., 10.], null_value=-1) # checks for safety against division by zero income / 2. income / sn.clamp(educ, 5., 20.) sn.dp_count(data, privacy_usage={"epsilon": 0.5}) sn.dp_count(mask, privacy_usage={"epsilon": 0.5}) sn.dp_histogram(mask, privacy_usage={"epsilon": 0.5}) age = sn.impute(sn.clamp(age, 0., 150.)) sn.dp_maximum(age, privacy_usage={"epsilon": 0.5}) sn.dp_minimum(age, privacy_usage={"epsilon": 0.5}) sn.dp_median(age, privacy_usage={"epsilon": 0.5}) age_n = sn.resize(age, number_rows=800) sn.dp_mean(age_n, privacy_usage={"epsilon": 0.5}) sn.dp_raw_moment(age_n, order=3, privacy_usage={"epsilon": 0.5}) sn.dp_sum(age, privacy_usage={"epsilon": 0.5}) sn.dp_variance(age_n, privacy_usage={"epsilon": 0.5}) sn.filter(income, mask) race_histogram = sn.histogram(race, categories=["1", "2", "3"], null_value="3") sn.histogram(income, edges=[0., 10000., 50000.], null_value=-1) sn.dp_histogram(married, privacy_usage={"epsilon": 0.5}) sn.gaussian_mechanism(race_histogram, privacy_usage={ "epsilon": 0.5, "delta": .000001 }) sn.laplace_mechanism(race_histogram, privacy_usage={ "epsilon": 0.5, "delta": .000001 }) sn.raw_moment(educ, order=3) sn.log(sn.clamp(educ, 0.001, 50.)) sn.maximum(educ) sn.mean(educ) sn.minimum(educ) educ % 2. educ**2. sn.quantile(educ, .32) sn.resize(educ, number_rows=1200, lower=0., upper=50.) sn.resize(race, number_rows=1200, categories=["1", "2"], weights=[1, 2]) sn.resize(data[["age", "sex"]], 1200, categories=[["1", "2"], ["a", "b"]], weights=[1, 2]) sn.resize(data[["age", "sex"]], 1200, categories=[["1", "2"], ["a", "b", "c"]], weights=[[1, 2], [3, 7, 2]]) sn.sum(educ) sn.variance(educ) if run: analysis.release() return analysis