def Run(self, W, x, eps, seed): assert len(x.shape) == 2, "Adaptive Grid only works for 2D domain" shape_2d = x.shape x = x.flatten() prng = np.random.RandomState(seed) Ms = [] ys = [] M = selection.UniformGrid(shape_2d, self.data_scale, eps, ag_flag=True, c=self.c).select() if not isinstance(M, np.ndarray): M = M.toarray() y = measurement.Laplace(M, self.alpha*eps).measure(x, prng) x_hat = inference.LeastSquares().infer(M, y) Ms.append(M) ys.append(y) # Prepare parition object for later SplitByParition. # This Partition selection operator is missing from Figure 2, plan 12 in the paper. uniform_mapping = mapper.UGridPartition(shape_2d, self.data_scale, eps, ag_flag=True, c=self.c).mapping() x_sub_list = meta.SplitByPartition(uniform_mapping).transform(x) sub_domains = support.get_subdomain_grid(uniform_mapping, shape_2d) for i in sorted(set(uniform_mapping)): x_i = x_sub_list[i] P_i = support.projection_matrix(uniform_mapping, i) x_hat_i = P_i * x_hat sub_domain_shape = sub_domains[i] M_i = selection.AdaptiveGrid(sub_domain_shape, x_hat_i, (1-self.alpha)*eps, c2=self.c2).select() if not isinstance(M, np.ndarray): M_i = M_i.toarray() y_i = measurement.Laplace(M_i, (1-self.alpha)*eps).measure(x_i, prng) M_i_o = M_i * P_i Ms.append(M_i_o) ys.append(y_i) x_hat = inference.LeastSquares().infer(Ms, ys, [1.0]*len(ys)) return x_hat
def Run(self, W, x, eps, seed): assert len(x.shape) == 2, "Adaptive Grid only works for 2D domain" shape_2d = x.shape x = x.flatten() prng = np.random.RandomState(seed) Ms = [] ys = [] M = selection.UniformGrid(shape_2d, self.data_scale, eps, ag_flag=True, c=self.c).select() y = measurement.Laplace(M, self.alpha*eps).measure(x, prng) x_hat = inference.LeastSquares().infer(M, y) Ms.append(M) ys.append(y) # Prepare parition object for later SplitByParition. # This Partition selection operator is missing from Figure 2, plan 12 in the paper. uniform_mapping = mapper.UGridPartition(shape_2d, self.data_scale, eps, ag_flag=True, c=self.c).mapping() x_sub_list = meta.SplitByPartition(uniform_mapping).transform(x) sub_domains = support.get_subdomain_grid(uniform_mapping, shape_2d) ll, hi =[], [] for i in sorted(set(uniform_mapping)): x_i = x_sub_list[i] P_i = support.projection_matrix(uniform_mapping, i) x_hat_i = P_i * x_hat sub_domain_shape = sub_domains[i] M_i = selection.AdaptiveGrid(sub_domain_shape, x_hat_i, (1-self.alpha)*eps, c2=self.c2).select() y_i = measurement.Laplace(M_i, (1-self.alpha)*eps).measure(x_i, prng) offset = np.unravel_index(P_i.matrix.nonzero()[1][0], shape_2d) ll.extend(M_i._lower + np.array(offset)) hi.extend(M_i._higher + np.array(offset)) ys.append(y_i) Ms.append(workload.RangeQueries(shape_2d, np.array(ll), np.array(hi))) x_hat = inference.LeastSquares().infer(Ms, ys) return x_hat
def Run(self, W, x, eps, seed): x = x.flatten() prng = np.random.RandomState(seed) if len(self.domain_shape) == 2: # apply hilbert transform to convert 2d domain into 1d hilbert_mapping = mapper.HilbertTransform( self.domain_shape).mapping() domain_reducer = transformation.ReduceByPartition(hilbert_mapping) x = domain_reducer.transform(x) W = W.get_matrix() * support.expansion_matrix(hilbert_mapping) dawa = pmapper.Dawa(eps, self.ratio, self.approx) mapping = dawa.mapping(x, prng) elif len(self.domain_shape) == 1: W = W.get_matrix() dawa = pmapper.Dawa(eps, self.ratio, self.approx) mapping = dawa.mapping(x, prng) reducer = transformation.ReduceByPartition(mapping) x_bar = reducer.transform(x) W_bar = W * support.expansion_matrix(mapping) M_bar = selection.GreedyH(x_bar.shape, W_bar).select() y = measurement.Laplace(M_bar, eps * (1 - self.ratio)).measure(x_bar, prng) x_bar_hat = inference.LeastSquares().infer(M_bar, y) x_bar_hat_exp = support.expansion_matrix(mapping) * x_bar_hat if len(self.domain_shape) == 1: return x_bar_hat_exp elif len(self.domain_shape) == 2: return support.expansion_matrix(hilbert_mapping) * x_bar_hat_exp
def Run(self, W, x, eps, seed): x = x.flatten() prng = np.random.RandomState(seed) if self.workload_based: mapping = mapper.WorkloadBased(W).mapping() reducer = transformation.ReduceByPartition(mapping) x = reducer.transform(x) # Reduce workload # W = support.reduce_queries(mapping, W) W = W * support.expansion_matrix(mapping) # Orange AHPparition(PA) operator in paper can be expressed # as the following sequence of simpler opeartors M = selection.Identity(x.shape).select() y = measurement.Laplace(M, self.ratio * eps).measure(x, prng) xest = inference.AHPThresholding(self.eta, self.ratio).infer(M, y, eps) mapping = mapper.AHPCluster(xest, (1 - self.ratio) * eps).mapping() # TR reducer = transformation.ReduceByPartition(mapping) x_bar = reducer.transform(x) # SI LM LS M_bar = selection.Identity(x_bar.shape).select() y_bar = measurement.Laplace(M_bar, eps * (1 - self.ratio)).measure( x_bar, prng) x_bar_hat = inference.LeastSquares().infer(M_bar, y_bar) x_hat = support.expansion_matrix(mapping) * x_bar_hat return x_hat
def Run(self, W, x, eps, seed): x = x.flatten() prng = np.random.RandomState(seed) striped_mapping = mapper.Striped(self.domain, self.stripe_dim).mapping() x_sub_list = meta.SplitByPartition(striped_mapping).transform(x) Ms = [] ys = [] scale_factors = [] group_idx = sorted(set(striped_mapping)) for i in group_idx: x_i = x_sub_list[group_idx.index(i)] P_i = support.projection_matrix(striped_mapping, i) M_bar = selection.HB(x_i.shape).select() y_i = measurement.Laplace(M_bar, eps).measure(x_i, prng) noise_scale_factor = laplace_scale_factor(M_bar, eps) M_i = M_bar * P_i Ms.append(M_i) ys.append(y_i) scale_factors.append(noise_scale_factor) x_hat = inference.LeastSquares().infer(Ms, ys, scale_factors) return x_hat
def Run(self, W, x, eps, seed): prng = np.random.RandomState(seed) M = selection.GreedyH(x.shape, W).select() y = measurement.Laplace(M, eps).measure(x, prng) x_hat = inference.LeastSquares().infer(M, y) return x_hat
def Run(self, W, x, eps, seed): x = x.flatten() prng = np.random.RandomState(seed) M = selection.HD_IHB(self.domain, self.impl, self.stripe_dim).select() y = measurement.Laplace(M, eps).measure(x, prng) x_hat = inference.LeastSquares().infer(M, y) return x_hat
def Run(self, W, x, eps, seed): x = x.flatten() prng = np.random.RandomState(seed) M = selection.Wavelet(self.domain_shape).select() y = measurement.Laplace(M, eps).measure(x, prng) x_hat = inference.LeastSquares().infer(M, y) return x_hat
def Run(self, W, x, eps, seed): x = x.flatten() prng = np.random.RandomState(seed) striped_vectors = mapper.Striped(self.domain, self.stripe_dim).partitions() hd_vector = support.combine_all(striped_vectors) striped_mapping = hd_vector.flatten() x_sub_list = meta.SplitByPartition(striped_mapping).transform(x) Ms = [] ys = [] scale_factors = [] group_idx = sorted(set(striped_mapping)) # Given a group id on the full vector, recover the group id for each partition # put back in loop to save memory self.subgroups = {} for i in group_idx: selected_idx = np.where(hd_vector == i) ans = [p[i[0]] for p, i in zip(striped_vectors, selected_idx)] self.subgroups[i] = ans for i in group_idx: x_i = x_sub_list[group_idx.index(i)] # overwriting standard projection for efficiency W_i = self.project_workload(W, striped_vectors, hd_vector, i) dawa = pmapper.Dawa(eps, self.ratio, self.approx) mapping = dawa.mapping(x_i, prng) reducer = transformation.ReduceByPartition(mapping) x_bar = reducer.transform(x_i) W_bar = W_i * support.expansion_matrix(mapping) M_bar = selection.GreedyH(x_bar.shape, W_bar).select() if not isinstance(M_bar, np.ndarray): M_bar = M_bar.toarray() y_i = measurement.Laplace( M_bar, eps * (1 - self.ratio)).measure(x_bar, prng) noise_scale_factor = laplace_scale_factor( M_bar, eps * (1 - self.ratio)) # convert the measurement back to the original domain for inference P_i = support.projection_matrix(striped_mapping, i) M_i = (M_bar * support.reduction_matrix(mapping)) * P_i Ms.append(M_i) ys.append(y_i) scale_factors.append(noise_scale_factor) x_hat = inference.LeastSquares().infer(Ms, ys, scale_factors) return x_hat
def Run(self, W, x, eps, seed): x = x.flatten() prng = np.random.RandomState(seed) shape_2d = (x.shape[0]//2,2) M = selection.QuadTree(shape_2d).select() y = measurement.Laplace(M, eps).measure(x, prng) x_hat = inference.LeastSquares().infer(M, y) return x_hat
def Run(self, W, relation, eps, seed): prng = np.random.RandomState(seed) M = pselection.PrivBayesSelect(self.theta, self.domain, eps).select(relation, prng) x = transformation.Vectorize( '', reduced_domain=self.domain).transform(relation) y = measurement.Laplace(M, eps).measure(x, prng) x_hat = inference.LeastSquares().infer(M, y) return x_hat
def Run(self, W, x, eps, seed): domain_dimension = len(self.domain_shape) eps_share = util.old_div(float(eps), domain_dimension) x = x.flatten() prng = np.random.RandomState(seed) Ms = [] ys = [] scale_factors = [] for i in range(domain_dimension): # Reducde domain to get marginals marginal_mapping = mapper.MarginalPartition( domain_shape=self.domain_shape, proj_dim=i).mapping() reducer = transformation.ReduceByPartition(marginal_mapping) x_i = reducer.transform(x) if self.domain_shape[i] < 50: # run identity subplan M_i = selection.Identity(x_i.shape).select() y_i = measurement.Laplace(M_i, eps_share).measure(x_i, prng) noise_scale_factor = laplace_scale_factor( M_i, eps_share) else: # run dawa subplan W = get_matrix(W) W_i = W * support.expansion_matrix(marginal_mapping) dawa = pmapper.Dawa(eps_share, self.ratio, self.approx) mapping = dawa.mapping(x_i, prng) reducer = transformation.ReduceByPartition(mapping) x_bar = reducer.transform(x_i) W_bar = W_i * support.expansion_matrix(mapping) M_bar = selection.GreedyH(x_bar.shape, W_bar).select() y_i = measurement.Laplace( M_bar, eps_share * (1 - self.ratio)).measure(x_bar, prng) noise_scale_factor = laplace_scale_factor( M_bar, eps_share * (1 - self.ratio)) # expand the dawa reduction M_i = M_bar * support.reduction_matrix(mapping) MM = M_i * support.reduction_matrix(marginal_mapping) Ms.append(MM) ys.append(y_i) scale_factors.append(noise_scale_factor) x_hat = inference.LeastSquares(method='lsmr').infer(Ms, ys, scale_factors) return x_hat
def Run(self, W, x, eps, seed): prng = np.random.RandomState(seed) W = get_matrix(W) M = selection.GreedyH(x.shape, W).select() if not isinstance(M, np.ndarray): M = M.toarray() y = measurement.Laplace(M, eps).measure(x, prng) x_hat = inference.LeastSquares().infer(M, y) return x_hat
def Run(self, W, x, eps, seed): domain_shape = x.shape x = x.flatten() prng = np.random.RandomState(seed) M = selection.HDMarginal(domain_shape).select() y = measurement.Laplace(M, eps).measure(x, prng) x_hat = inference.LeastSquares(method='lsmr').infer(M, y) return x_hat
def Run(self, W, x, eps, seed): x = x.flatten() prng = np.random.RandomState(seed) M = selection.hd_IHB(self.domain, self.stripe_dim).select() if not isinstance(M, np.ndarray): M = M.toarray() y = measurement.Laplace(M, eps).measure(x, prng) x_hat = inference.LeastSquares().infer(M, y) return x_hat
def Run(self, W, x, eps, seed): assert len(x.shape) == 2, "Uniform Grid only works for 2D domain" shape_2d = x.shape x = x.flatten() prng = np.random.RandomState(seed) M = selection.UniformGrid(shape_2d, self.data_scale, eps).select() y = measurement.Laplace(M, eps).measure(x, prng) x_hat = inference.LeastSquares().infer(M, y) return x_hat
def Run(self, W, x, eps, seed): assert len(x.shape) == 2, "QuadTree only works for 2D domain" prng = np.random.RandomState(seed) shape_2d = x.shape x = x.flatten() M = selection.QuadTree(shape_2d).select() y = measurement.Laplace(M, eps).measure(x, prng) x_hat = inference.LeastSquares().infer(M, y) return x_hat
def Run(self, W, x, eps, seed): x = x.flatten() prng = np.random.RandomState(seed) if self.workload_based: W = get_matrix(W) mapping = mapper.WorkloadBased(W).mapping() reducer = transformation.ReduceByPartition(mapping) x = reducer.transform(x) # Reduce workload # W = support.reduce_queries(mapping, W) W = W * support.expansion_matrix(mapping) self.domain_shape = x.shape if len(self.domain_shape) == 2: # apply hilbert transform to convert 2d domain into 1d hilbert_mapping = mapper.HilbertTransform(self.domain_shape).mapping() domain_reducer = transformation.ReduceByPartition(hilbert_mapping) x = domain_reducer.transform(x) W = get_matrix(W) W = W * support.expansion_matrix(hilbert_mapping) dawa = pmapper.Dawa(eps, self.ratio, self.approx) mapping = dawa.mapping(x, prng) elif len(self.domain_shape) == 1: W = get_matrix(W) dawa = pmapper.Dawa(eps, self.ratio, self.approx) mapping = dawa.mapping(x, prng) reducer = transformation.ReduceByPartition(mapping) x_bar = reducer.transform(x) W_bar = W * support.expansion_matrix(mapping) M_bar = selection.GreedyH(x_bar.shape, W_bar).select() if not isinstance(M_bar, np.ndarray): M_bar = M_bar.toarray() y = measurement.Laplace(M_bar, eps*(1-self.ratio)).measure(x_bar, prng) x_bar_hat = inference.LeastSquares().infer(M_bar, y) x_bar_hat_exp = support.expansion_matrix(mapping) * x_bar_hat if len(self.domain_shape) == 1: return x_bar_hat_exp elif len(self.domain_shape) == 2: return support.expansion_matrix(hilbert_mapping) * x_bar_hat_exp
def expected_error_empirical(W, A, eps=np.sqrt(2), trials=25): prng = np.random.RandomState(9999) x = np.ones(W.shape[1]) # makeup of data vector doesn't matter true_ans = W @ x errors = np.zeros(trials) for i in range(trials): y = measurement.Laplace(A, eps).measure(x, prng) x_hat = inference.LeastSquares().infer(A, y) ans = W @ x_hat total_sqerr_workload = np.sum((ans-true_ans)**2) errors[i] = total_sqerr_workload return np.mean(errors)
def Run(self, W, x, eps, seed): x = x.flatten() prng = np.random.RandomState(seed) if self.workload_based: mapping = mapper.WorkloadBased(W).mapping() reducer = transformation.ReduceByPartition(mapping) x = reducer.transform(x) # Reduce workload # W = support.reduce_queries(mapping, W) W = W * support.expansion_matrix(mapping) M = selection.Identity(x.shape).select() y = measurement.Laplace(M, eps).measure(x, prng) x_hat = inference.LeastSquares().infer(M, y) return x_hat
def Run(self, W, x, eps, seed): x = x.flatten() prng = np.random.RandomState(seed) striped_mapping = mapper.Striped(self.domain, self.stripe_dim).mapping() x_sub_list = meta.SplitByPartition(striped_mapping).transform(x) Ms = [] ys = [] scale_factors = [] group_idx = sorted(set(striped_mapping)) W = get_matrix(W) for i in group_idx: x_i = x_sub_list[group_idx.index(i)] P_i = support.projection_matrix(striped_mapping, i) W_i = W * P_i.T dawa = pmapper.Dawa(eps, self.ratio, self.approx) mapping = dawa.mapping(x_i, prng) reducer = transformation.ReduceByPartition(mapping) x_bar = reducer.transform(x_i) W_bar = W_i * support.expansion_matrix(mapping) M_bar = selection.GreedyH(x_bar.shape, W_bar).select() if not isinstance(M_bar, np.ndarray): M_bar = M_bar.toarray() y_i = measurement.Laplace( M_bar, eps * (1 - self.ratio)).measure(x_bar, prng) noise_scale_factor = laplace_scale_factor( M_bar, eps * (1 - self.ratio)) M_i = (M_bar * support.reduction_matrix(mapping)) * P_i Ms.append(M_i) ys.append(y_i) scale_factors.append(noise_scale_factor) x_hat = inference.LeastSquares().infer(Ms, ys, scale_factors) return x_hat
def Run(self, W, x, eps, seed): x = x.flatten() prng = np.random.RandomState(seed) if self.workload_based: W = get_matrix(W) mapping = mapper.WorkloadBased(W).mapping() reducer = transformation.ReduceByPartition(mapping) x = reducer.transform(x) # Reduce workload # W = support.reduce_queries(mapping, W) W = W * support.expansion_matrix(mapping) self.domain_shape = x.shape M = selection.HB(self.domain_shape).select() if not isinstance(M, np.ndarray): M = M.toarray() y = measurement.Laplace(M, eps).measure(x, prng) x_hat = inference.LeastSquares().infer(M, y) return x_hat