def Run(self, W, x, eps): domain_size = np.prod(self.domain_shape) # Start with a unifrom estimation of x x_hat = np.array([self.data_scale / float(domain_size)] * domain_size) W_partial = sparse.csr_matrix(get_matrix(W).shape) M_history = np.empty((0, domain_size)) y_history = [] for i in range(1, self.rounds + 1): eps_round = eps / float(self.rounds) # SW + SH2 W_next = x.worst_approx(sparse.csr_matrix(get_matrix(W)), W_partial, x_hat, eps_round * self.ratio) M = selection.AddEquiWidthIntervals(W_next, i).select() W_partial += W_next y = x.laplace(M, eps_round * (1-self.ratio))\ # default use history M_history = sparse.vstack([M_history, M]) y_history.extend(y) if self.total_noise_scale != 0: total_query = sparse.csr_matrix([1] * domain_size) noise_scale = laplace_scale_factor( M, eps_round * (1 - self.ratio)) x_hat = non_negative_least_squares( [total_query, M_history], [[self.data_scale], y_history], [self.total_noise_scale, noise_scale]) else: x_hat = non_negative_least_squares(M, y) return x_hat
def Run(self, W, x, eps): if self.workload_based: x, W = workload_based(x=x, W=W) W = get_matrix(W) if len(self.domain_shape) == 2: # apply hilbert transform to convert 2d domain_shape into 1d hilbert_mapping = hilbert(self.domain_shape) x = x.reduce_by_partition(hilbert_mapping) W = W * support.expansion_matrix(hilbert_mapping) mapping = x.dawa(self.ratio, self.approx, eps) x_bar = x.reduce_by_partition(mapping) W_bar = get_matrix(W) * support.expansion_matrix(mapping) M_bar = greedyH((len(set(mapping)), ), W_bar) y = x_bar.laplace(M_bar, eps * (1 - self.ratio)) x_bar_hat = least_squares(M_bar, y) x_hat = support.expansion_matrix(mapping) * x_bar_hat if len(self.domain_shape) == 2: return support.expansion_matrix(hilbert_mapping) * x_hat return x_hat
def Run(self, W, x, eps): domain_size = np.prod(self.domain_shape) # Start with a unifrom estimation of x x_hat = np.array([self.data_scale / float(domain_size)] * domain_size) W_partial = sparse.csr_matrix(get_matrix(W).shape) M_history = np.empty((0, domain_size)) y_history = [] for i in range(1, self.rounds + 1): eps_round = eps / float(self.rounds) W_next = x.worst_approx(sparse.csr_matrix(get_matrix(W)), W_partial, x_hat, eps_round * self.ratio, 'EXPONENTIAL') M = support.extract_M(W_next) W_partial += W_next y = x.laplace(M, eps_round * (1 - self.ratio)) M_history = sparse.vstack([M_history, M]) y_history.extend(y) if self.use_history: x_hat = multiplicative_weights( M_history, y_history, x_hat, update_rounds=self.update_rounds) else: x_hat = multiplicative_weights( M, y, x_hat, update_rounds=self.update_rounds) 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 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) # 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): striped_mapping = striped(self.domain_shape, self.stripe_dim) x_sub_list = x.split_by_partition(striped_mapping) 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) W_i = get_matrix(W) * P_i.T M_bar = hb((P_i.shape[0], )) y_i = x_i.laplace(M_bar, eps) M_i = M_bar * P_i Ms.append(M_i) ys.append(y_i) scale_factors.append(laplace_scale_factor(M_bar, eps)) x_hat = least_squares(Ms, ys, scale_factors) return x_hat
def Run(self, W, x, eps): W = get_matrix(W) striped_mapping = striped(self.domain_shape, self.stripe_dim) x_sub_list = x.split_by_partition(striped_mapping) 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) W_i = W * P_i.T mapping = x_i.dawa(self.ratio, self.approx, eps) x_bar = x_i.reduce_by_partition(mapping) W_bar = W_i * support.expansion_matrix(mapping) M_bar = greedyH((len(set(mapping)), ), W_bar) y_i = x_bar.laplace(M_bar, eps * (1 - self.ratio)) W_bar = W_i * support.expansion_matrix(mapping) M_i = (M_bar * support.reduction_matrix(mapping)) * P_i Ms.append(M_i) ys.append(y_i) scale_factors.append(laplace_scale_factor(M_bar, eps)) x_hat = least_squares(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() y = measurement.Laplace(M, eps).measure(x, prng) x_hat = inference.LeastSquares().infer(M, y) return x_hat
def workload_based(x, W=None): '''workload-based domain reduction ''' mapping = mapper.WorkloadBased(W).mapping() x = x.reduce_by_partition(mapping) if W is not None: W = support.get_matrix(W) W = W * support.expansion_matrix(mapping) return x, W
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): x = x.flatten() prng = np.random.RandomState(seed) domain_size = np.prod(self.domain_shape) # Start with a unifrom estimation of x x_hat = np.array([self.data_scale / float(domain_size)] * domain_size) W = get_matrix(W) if not isinstance(W, np.ndarray): W = W.toarray() measuredQueries = [] nnls = inference.NonNegativeLeastSquares(method='new') M_history = np.empty((0, domain_size)) y_history = [] for i in range(1, self.rounds+1): eps_round = eps / float(self.rounds) # SW + SH2 worst_approx = pselection.WorstApprox(W, measuredQueries, x_hat, eps_round * self.ratio) W_next = worst_approx.select(x, prng) measuredQueries.append(W_next.mwem_index) M = selection.AddEquiWidthIntervals(W_next, i).select() if not isinstance(M, np.ndarray): M = M.toarray() laplace = measurement.Laplace(M, eps_round * (1-self.ratio)) y = laplace.measure(x, prng) # default use history M_history = np.vstack([M_history, M]) y_history.extend(y) if self.total_noise_scale != 0: total_query = sparse.csr_matrix([1]*domain_size) noise_scale = laplace_scale_factor(M, eps_round * (1-self.ratio)) x_hat = nnls.infer([total_query, M_history], [[self.data_scale], y_history], [self.total_noise_scale, noise_scale]) else: x_hat = nnls.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) 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): domain_dimension = len(self.domain_shape) eps_share = util.old_div(float(eps), domain_dimension) Ms = [] ys = [] scale_factors = [] for i in range(domain_dimension): # Reducde domain to get marginals marginal_mapping = marginal_partition(self.domain_shape, i) x_i = x.reduce_by_partition(marginal_mapping) if self.domain_shape[i] < 50: # run identity subplan M_i = identity((self.domain_shape[i], )) y_i = x_i.laplace(M_i, eps_share) 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) mapping = x_i.dawa(self.ratio, self.approx, eps_share) x_bar = x_i.reduce_by_partition(mapping) W_bar = W_i * support.expansion_matrix(mapping) M_bar = greedyH((len(set(mapping)), ), W_bar) y_i = x_bar.laplace(M_bar, eps_share * (1 - self.ratio)) 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 = least_squares(Ms, ys, scale_factors) 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) domain_size = np.prod(self.domain_shape) # Start with a uniform estimation of x x_hat = np.array([self.data_scale / float(domain_size)] * domain_size) W = get_matrix(W) if not isinstance(W, np.ndarray): W = W.toarray() measuredQueries = [] mult_weight = inference.MultiplicativeWeights(updateRounds = self.update_rounds) M_history = np.empty((0, domain_size)) y_history = [] for i in range(1, self.rounds+1): eps_round = eps / float(self.rounds) # SW worst_approx = pselection.WorstApprox(W, measuredQueries, x_hat, eps_round * self.ratio, 'EXPONENTIAL') M = worst_approx.select(x, prng) measuredQueries.append(M.mwem_index) if not isinstance(M, np.ndarray): M = M.toarray() # LM laplace = measurement.Laplace(M, eps_round * (1-self.ratio)) y = laplace.measure(x, prng) M_history = np.vstack([M_history, M]) y_history.extend(y) # MW if self.use_history: x_hat = mult_weight.infer(M_history, y_history, x_hat) else: x_hat = mult_weight.infer(M, y, x_hat) return x_hat
def Run(self, W, x, eps, seed): prng = np.random.RandomState(seed) domain_size = np.prod(self.domain_shape) # Start with a unifrom estimation of x x_hat = np.array([self.data_scale / float(domain_size)] * domain_size) W = get_matrix(W) W_partial = sparse.csr_matrix(W.shape) nnls = inference.NonNegativeLeastSquares() M_history = np.empty((0, domain_size)) y_history = [] for i in range(1, self.rounds+1): eps_round = eps / float(self.rounds) # SW + SH2 worst_approx = pselection.WorstApprox(sparse.csr_matrix(W), W_partial, x_hat, eps_round * self.ratio) W_next = worst_approx.select(x, prng) M = selection.AddEquiWidthIntervals(W_next, i).select() W_partial += W_next laplace = measurement.Laplace(M, eps_round * (1-self.ratio)) y = laplace.measure(x, prng) # default use history M_history = sparse.vstack([M_history, M]) y_history.extend(y) if self.total_noise_scale != 0: total_query = sparse.csr_matrix([1]*domain_size) noise_scale = laplace_scale_factor(M, eps_round * (1-self.ratio)) x_hat = nnls.infer([total_query, M_history], [[self.data_scale], y_history], [self.total_noise_scale, noise_scale]) else: x_hat = nnls.infer(M, y) return x_hat
def Run(self, W, x, eps, seed): x = x.flatten() prng = np.random.RandomState(seed) domain_size = np.prod(self.domain_shape) # Start with a unifrom estimation of x x_hat = np.array([self.data_scale / float(domain_size)] * domain_size) W = get_matrix(W) W_partial = sparse.csr_matrix(W.shape) mult_weight = inference.MultiplicativeWeights(updateRounds = self.update_rounds) M_history = np.empty((0, domain_size)) y_history = [] for i in range(1, self.rounds+1): eps_round = eps / float(self.rounds) # SW worst_approx = pselection.WorstApprox(sparse.csr_matrix(W), W_partial, x_hat, eps_round * self.ratio, 'EXPONENTIAL') W_next = worst_approx.select(x, prng) M = support.extract_M(W_next) W_partial += W_next # LM laplace = measurement.Laplace(M, eps_round * (1-self.ratio)) y = laplace.measure(x, prng) M_history = sparse.vstack([M_history, M]) y_history.extend(y) # MW if self.use_history: x_hat = mult_weight.infer(M_history, y_history, x_hat) else: x_hat = mult_weight.infer(M, y, x_hat) return x_hat
def Run(self, W, x, eps, seed): x = x.flatten() prng = np.random.RandomState(seed) domain_size = np.prod(self.domain_shape) # Start with a unifrom estimation of x x_hat = np.array([self.data_scale / float(domain_size)] * domain_size) W = get_matrix(W) measuredQueries = [] mult_weight = inference.MultiplicativeWeights( updateRounds=self.update_rounds) M_history = np.empty((0, domain_size)) y_history = [] for i in range(1, self.rounds + 1): eps_round = eps / float(self.rounds) # SW + SH2 worst_approx = pselection.WorstApprox(W, measuredQueries, x_hat, eps_round * self.ratio) W_next = worst_approx.select(x, prng) measuredQueries.append(W_next.mwem_index) M = selection.AddEquiWidthIntervals(W_next, i).select() # LM laplace = measurement.Laplace(M, eps_round * (1 - self.ratio)) y = laplace.measure(x, prng) M_history = sparse.vstack([M_history, M]) y_history.extend(y) # MW if self.use_history: x_hat = mult_weight.infer(M_history, y_history, x_hat) else: x_hat = mult_weight.infer(M, y, x_hat) return x_hat
def std_project_workload(self, w, mapping, groupID): P_i = support.projection_matrix(mapping, groupID) w = get_matrix(w) return w * P_i.T
def Run(self, W, x, eps): M = greedyH((self.n, ), get_matrix(W)) y = x.laplace(M, eps) x_hat = least_squares(M, y) return x_hat