def evaluate(data, range_max_value, quality_function, quality_promise, approximation, eps, delta, intervals_bounding, max_in_interval, use_exponential=True): """ RecConcave algorithm for the specific case of N=2 :param data: the main data-set :param range_max_value: maximum possible output (the minimum output is 0) :param quality_function: function that gets a domain-elements and returns its quality (in float) :param quality_promise: float, quality value that we can assure that there exist a domain element with at least that quality :param approximation: 0 < float < 1. the approximation level of the result :param eps: float > 0. privacy parameter :param delta: 1 > float > 0. privacy parameter :param intervals_bounding: function L(data,domain_element) :param max_in_interval: function u(data,interval) that returns the maximum of quality_function(data,j) for j in the interval :param use_exponential: the original version uses A_dist mechanism. for utility reasons the exponential-mechanism is the default. turn to False to use A_dist instead :return: an element of domain with approximately maximum value of quality function """ # step 2 # print "step 2" log_of_range = int(math.ceil(math.log(range_max_value, 2))) range_max_value_tag = 2**log_of_range def extended_quality_function(data_base, j): if range_max_value < j <= range_max_value_tag: return min(0, quality_function(data_base, range_max_value)) else: return quality_function(data_base, j) # step 4 # print "step 4" def recursive_quality_function(data_base, j): return min( intervals_bounding(data_base, range_max_value_tag, j) - (1 - approximation) * quality_promise, quality_promise - intervals_bounding(data_base, range_max_value_tag, j + 1)) # step 6 # print "step 6" recursion_returned = basicdp.exponential_mechanism_big( data, range(log_of_range + 1), recursive_quality_function, eps) good_interval = 8 * (2**recursion_returned) # print "good interval: %d" % good_interval # step 7 # print "step 7" first_intervals = __build_intervals_set__(data, good_interval, 0, range_max_value_tag) second_intervals = __build_intervals_set__(data, good_interval, 0, range_max_value_tag, True) max_quality = partial(max_in_interval, interval_length=good_interval) # step 9 ( using 'dist' algorithm ) # print "step 9" # TODO should I add switch for sparse? # TODO make sure it is still generic!!!!!!!!!!!!!! if use_exponential: first_full_domain = xrange(0, range_max_value, good_interval) second_full_domain = xrange(good_interval / 2, range_max_value, good_interval) first_chosen_interval = basicdp.sparse_domain( basicdp.exponential_mechanism_big, data, first_full_domain, first_intervals, max_quality, eps) second_chosen_interval = basicdp.sparse_domain( basicdp.exponential_mechanism_big, data, second_full_domain, second_intervals, max_quality, eps) else: first_chosen_interval = basicdp.a_dist(data, first_intervals, max_quality, eps, delta) second_chosen_interval = basicdp.a_dist(data, second_intervals, max_quality, eps, delta) if type(first_chosen_interval) == str and type( second_chosen_interval) == str: raise ValueError("stability problem, try taking more samples!") # step 10 # print "step 10" if type(first_chosen_interval) == str: first_chosen_interval_as_list = [] else: first_chosen_interval_as_list = range( first_chosen_interval, first_chosen_interval + good_interval) if type(second_chosen_interval) == str: second_chosen_interval_as_list = [] else: second_chosen_interval_as_list = range( second_chosen_interval, second_chosen_interval + good_interval) return basicdp.exponential_mechanism_big( data, first_chosen_interval_as_list + second_chosen_interval_as_list, extended_quality_function, eps)
def evaluate( data, range_max_value, quality_function, quality_promise, approximation, eps, delta, intervals_bounding, max_in_interval, use_exponential=True, ): """ RecConcave algorithm for the specific case of N=2 :param data: the main data-set :param range_max_value: maximum possible output (the minimum output is 0) :param quality_function: function that gets a domain-elements and returns its quality (in float) :param quality_promise: float, quality value that we can assure that there exist a domain element with at least that quality :param approximation: 0 < float < 1. the approximation level of the result :param eps: float > 0. privacy parameter :param delta: 1 > float > 0. privacy parameter :param intervals_bounding: function L(data,domain_element) :param max_in_interval: function u(data,interval) that returns the maximum of quality_function(data,j) for j in the interval :param use_exponential: the original version uses A_dist mechanism. for utility reasons the exponential-mechanism is the default. turn to False to use A_dist instead :return: an element of domain with approximately maximum value of quality function """ # step 2 # print "step 2" log_of_range = int(math.ceil(math.log(range_max_value, 2))) range_max_value_tag = 2 ** log_of_range def extended_quality_function(data_base, j): if range_max_value < j <= range_max_value_tag: return min(0, quality_function(data_base, range_max_value)) else: return quality_function(data_base, j) # step 4 # print "step 4" def recursive_quality_function(data_base, j): return min( intervals_bounding(data_base, range_max_value_tag, j) - (1 - approximation) * quality_promise, quality_promise - intervals_bounding(data_base, range_max_value_tag, j + 1), ) # step 6 # print "step 6" recursion_returned = basicdp.exponential_mechanism_big( data, range(log_of_range + 1), recursive_quality_function, eps ) good_interval = 8 * (2 ** recursion_returned) # print "good interval: %d" % good_interval # step 7 # print "step 7" first_intervals = __build_intervals_set__(data, good_interval, 0, range_max_value_tag) second_intervals = __build_intervals_set__(data, good_interval, 0, range_max_value_tag, True) max_quality = partial(max_in_interval, interval_length=good_interval) # step 9 ( using 'dist' algorithm ) # print "step 9" # TODO should I add switch for sparse? # TODO make sure it is still generic!!!!!!!!!!!!!! if use_exponential: first_full_domain = xrange(0, range_max_value, good_interval) second_full_domain = xrange(good_interval / 2, range_max_value, good_interval) first_chosen_interval = basicdp.sparse_domain( basicdp.exponential_mechanism_big, data, first_full_domain, first_intervals, max_quality, eps ) second_chosen_interval = basicdp.sparse_domain( basicdp.exponential_mechanism_big, data, second_full_domain, second_intervals, max_quality, eps ) else: first_chosen_interval = basicdp.a_dist(data, first_intervals, max_quality, eps, delta) second_chosen_interval = basicdp.a_dist(data, second_intervals, max_quality, eps, delta) if type(first_chosen_interval) == str and type(second_chosen_interval) == str: raise ValueError("stability problem, try taking more samples!") # step 10 # print "step 10" if type(first_chosen_interval) == str: first_chosen_interval_as_list = [] else: first_chosen_interval_as_list = range(first_chosen_interval, first_chosen_interval + good_interval) if type(second_chosen_interval) == str: second_chosen_interval_as_list = [] else: second_chosen_interval_as_list = range(second_chosen_interval, second_chosen_interval + good_interval) return basicdp.exponential_mechanism_big( data, first_chosen_interval_as_list + second_chosen_interval_as_list, extended_quality_function, eps )
def evaluate(data, range_max_value, quality_function, quality_promise, approximation, eps, delta, recursion_bound, bulk=False): # TODO fix so it will work # TODO add docstring # TODO go through variables names if recursion_bound == 1 or range_max_value <= 32: return __rec_concave_basis__(range_max_value, quality_function, eps, data, bulk) else: recursion_bound -= 1 # step 2 print "step 2" log_of_range = int(math.ceil(math.log(range_max_value, 2))) range_max_value_tag = 2 ** log_of_range if bulk: qualities = quality_function(data, range(int(range_max_value)+1)) else: qualities = [quality_function(data, i) for i in range(int(range_max_value)+1)] qualities.extend([min(0, qualities[range_max_value]) for _ in xrange(range_max_value, range_max_value_tag)]) def extended_quality_function(j): return qualities[j] # same but with signature that fits exponential mechanism requirements (used in step 10) def extended_quality_function_for_exponential_mechanism(data_set, j): return qualities[j] # step 3 print "step 3" def intervals_bounding(j): if j == log_of_range+1: return min(0, intervals_bounding(log_of_range)) return max(min(extended_quality_function(e) for e in xrange(a, a+2**j-1)) for a in xrange(0, range_max_value_tag-2**j+1)) # step 4 print "step 4" def recursive_quality_function(data_base, range_element): return min(intervals_bounding(range_element) - (1 - approximation) * quality_promise, quality_promise - intervals_bounding(range_element + 1)) # step 5 print "step 5" recursive_quality_promise = quality_promise * approximation / 2 # step 6 - recursion call print "step 6 - recursive call" recursion_returned = evaluate(data, log_of_range, recursive_quality_function, recursive_quality_promise, 1/4, eps, delta, recursion_bound, True) good_interval = 8 * (2 ** recursion_returned) print "good interval: %d" % good_interval # step 7 print "step 7" first_intervals = [range(range_max_value_tag)[i:i + good_interval] for i in xrange(0, range_max_value_tag, good_interval)] second_intervals = [range(good_interval/2, range_max_value_tag)[i:i + good_interval] for i in xrange(0, range_max_value_tag-good_interval/2, good_interval)] # step 8 print "step 8" def interval_quality(data_base, interval): return max([extended_quality_function(j) for j in interval]) # TODO temp - remove later # plotting for testing fq = [interval_quality(data, i) for i in first_intervals] plt.plot(range(len(fq)), fq, 'bo', range(len(fq)), fq, 'r') lower_bound = max(fq) - math.log(1/delta)/eps plt.axhspan(lower_bound, lower_bound, color='green', alpha=0.5) plt.show() # step 9 ( using 'dist' algorithm) print "step 9" first_chosen_interval = basicdp.a_dist(data, first_intervals, interval_quality, eps, delta) second_chosen_interval = basicdp.a_dist(data, second_intervals, interval_quality, eps, delta) print "first A_dist returned: %s" % str(type(first_chosen_interval)) print "second A_dist returned: %s" % str(type(second_chosen_interval)) if type(first_chosen_interval) != list or type(second_chosen_interval) != list: raise ValueError('stability problem') # step 10 print "step 10" return basicdp.exponential_mechanism(data, first_chosen_interval + second_chosen_interval, extended_quality_function_for_exponential_mechanism, eps, False)
def evaluate(data, range_max_value, quality_function, quality_promise, approximation, eps, delta, recursion_bound, bulk=False): # TODO fix so it will work # TODO add docstring # TODO go through variables names if recursion_bound == 1 or range_max_value <= 32: return __rec_concave_basis__(range_max_value, quality_function, eps, data, bulk) else: recursion_bound -= 1 # step 2 print "step 2" log_of_range = int(math.ceil(math.log(range_max_value, 2))) range_max_value_tag = 2**log_of_range if bulk: qualities = quality_function(data, range(int(range_max_value) + 1)) else: qualities = [ quality_function(data, i) for i in range(int(range_max_value) + 1) ] qualities.extend([ min(0, qualities[range_max_value]) for _ in xrange(range_max_value, range_max_value_tag) ]) def extended_quality_function(j): return qualities[j] # same but with signature that fits exponential mechanism requirements (used in step 10) def extended_quality_function_for_exponential_mechanism(data_set, j): return qualities[j] # step 3 print "step 3" def intervals_bounding(j): if j == log_of_range + 1: return min(0, intervals_bounding(log_of_range)) return max( min(extended_quality_function(e) for e in xrange(a, a + 2**j - 1)) for a in xrange(0, range_max_value_tag - 2**j + 1)) # step 4 print "step 4" def recursive_quality_function(data_base, range_element): return min( intervals_bounding(range_element) - (1 - approximation) * quality_promise, quality_promise - intervals_bounding(range_element + 1)) # step 5 print "step 5" recursive_quality_promise = quality_promise * approximation / 2 # step 6 - recursion call print "step 6 - recursive call" recursion_returned = evaluate(data, log_of_range, recursive_quality_function, recursive_quality_promise, 1 / 4, eps, delta, recursion_bound, True) good_interval = 8 * (2**recursion_returned) print "good interval: %d" % good_interval # step 7 print "step 7" first_intervals = [ range(range_max_value_tag)[i:i + good_interval] for i in xrange(0, range_max_value_tag, good_interval) ] second_intervals = [ range(good_interval / 2, range_max_value_tag)[i:i + good_interval] for i in xrange(0, range_max_value_tag - good_interval / 2, good_interval) ] # step 8 print "step 8" def interval_quality(data_base, interval): return max([extended_quality_function(j) for j in interval]) # TODO temp - remove later # plotting for testing fq = [interval_quality(data, i) for i in first_intervals] plt.plot(range(len(fq)), fq, 'bo', range(len(fq)), fq, 'r') lower_bound = max(fq) - math.log(1 / delta) / eps plt.axhspan(lower_bound, lower_bound, color='green', alpha=0.5) plt.show() # step 9 ( using 'dist' algorithm) print "step 9" first_chosen_interval = basicdp.a_dist(data, first_intervals, interval_quality, eps, delta) second_chosen_interval = basicdp.a_dist(data, second_intervals, interval_quality, eps, delta) print "first A_dist returned: %s" % str(type(first_chosen_interval)) print "second A_dist returned: %s" % str(type(second_chosen_interval)) if type(first_chosen_interval) != list or type( second_chosen_interval) != list: raise ValueError('stability problem') # step 10 print "step 10" return basicdp.exponential_mechanism( data, first_chosen_interval + second_chosen_interval, extended_quality_function_for_exponential_mechanism, eps, False)