def linear_program_solve_gurobi(net, D, p=1, c=0): num_triangles, triangles, nodes = common.triangle_count(net) # Linear Programming Model lpm = grb.Model() lpm.Params.LogFile = "gurobi.log" lpm.Params.LogToConsole = 0 lpm.Params.Threads = 32 x = lpm.addVars(num_triangles, name="x_C") lpm.addConstrs(x[i] >= 0 for i in range(num_triangles)) lpm.addConstrs(x[i] <= 1 for i in range(num_triangles)) # # TODO # # May rewrite this part for faster execution # for node in net.nodes(): # lpm.addConstr(grb.quicksum(x[i] # for i in range(num_triangles) # if node in triangles[i]) <= p * D * (D - 1) / 2) # A node in a D-bounded graph can involve in at most 1/2D(D-1) triangles for node in nodes.keys(): lpm.addConstr( grb.quicksum(x[i] for i in nodes[node]) <= D * (D - 1) / 2 ) # + c * math.log(net.number_of_nodes())) # A node in a D-bounded graph can involve in at most 1/2D(D-1) triangles lpm.setObjective(grb.quicksum(x[i] for i in range(num_triangles)), grb.GRB.MAXIMIZE) lpm.optimize() return lpm.ObjVal
def private_edge_blocki_triangle_count(net, epsilon, k, reps): trim_net = blocki_edge_trim(net, k) triangle_count = common.triangle_count(trim_net)[0] # print(triangle_count) # return np.random.laplace(0, 9 * (k ** 2) / epsilon, reps) + triangle_count return np.random.laplace(0, 3 / 2 * (k**2) / epsilon, reps) + triangle_count
def main(): csvfile = open(result_file, 'a') result_writer = csv.writer(csvfile, delimiter=',', quotechar='|', quoting=csv.QUOTE_MINIMAL) for net_name in network_name: print("Net:", net_name) net = nx.read_edgelist(network_path + net_name + ".txt", create_using=nx.Graph(), nodetype=int) true_triangle_count = common.triangle_count(net)[0] #print("True count:", true_triangle_count) for epsilon in [0.001, 0.005, 0.01, 0.05, 0.1, 0.5, 1]: delta = epsilon #print("Epsilon/Delta:", epsilon, delta) shiva_100_triangle = shiva_differentially_private_triange_count( net, 100, epsilon, method="gurobi", reps=int(sys.argv[1])) for sample in np.nditer(shiva_100_triangle): result_writer.writerow([ time.time(), "node_privacy", "shiva_node_100", net_name, true_triangle_count, sample, epsilon, delta ]) shiva_1000_triangle = shiva_differentially_private_triange_count( net, 1000, epsilon, method="gurobi", reps=int(sys.argv[1])) for sample in np.nditer(shiva_1000_triangle): result_writer.writerow([ time.time(), "node_privacy", "shiva_node_1000", net_name, true_triangle_count, sample, epsilon, delta ]) csvfile.flush()
def main(): csvfile = open(result_file, 'a') result_writer = csv.writer(csvfile, delimiter=',', quotechar='|', quoting=csv.QUOTE_MINIMAL) #net_name = network_name[int(sys.argv[1])] for net_name in network_name: print("Net:", net_name) net = nx.read_edgelist(network_path + net_name + ".txt", create_using=nx.Graph(), nodetype=int) true_triangle_count = common.triangle_count(net)[0] #print("True count:", true_triangle_count) for epsilon in [0.001, 0.005, 0.01, 0.05, 0.1, 0.5, 1]: delta = epsilon #print("Epsilon/Delta:", epsilon, delta) for _ in range(int(sys.argv[1])): basic_edge_triangle = basic_edge.private_basic_edge_triange_count( net, epsilon, delta) result_writer.writerow([ time.time(), "edge_privacy", "basic_edge", net_name, true_triangle_count, basic_edge_triangle, epsilon, delta ]) color_triangle = color.private_color_triange_count( net, epsilon, delta) result_writer.writerow([ time.time(), "edge_privacy", "color", net_name, true_triangle_count, color_triangle, epsilon, delta ])
def run_experiments(net, K, epsilon, delta, workers=4, repeat=10): csvfile = open(network_path[int(sys.argv[1])] + ".csv", 'a') logwriter = csv.writer(csvfile, delimiter=',', quotechar='|', quoting=csv.QUOTE_MINIMAL) executor = ProcessPoolExecutor(max_workers=workers) total_triangles = common.triangle_count(net)[0] runtime_average = runtime(net, [1] + K) # d_bound = shiva.max_degree(net) # max_degree = shiva.max_degree(net) # total_triangles = shiva.total_triangles(net) # Submit Karwa impl karwa_results = executor.submit(karwa_local_sensitivity, net, epsilon, delta, repeat=repeat) # Submit sampling batches sample_results = {} for k in K: p = 1 / (2**(k - 1)) sample_results[k] = experiment(executor, net, p, epsilon, delta, repeat=repeat) # Results for Karwa impl sample_mean = np.average(karwa_results.result()) sample_std = np.std(karwa_results.result()) logwriter.writerow([ total_triangles, 1, epsilon, delta, sample_mean, sample_std, runtime_average[1] ]) # Results for sampling impl for k in K: p = 1 / (2**(k - 1)) if sample_results[k] == -1: sample_mean = -1 sample_std = -1 else: sample_mean = sum(x.result() for x in sample_results[k]) \ / len(sample_results[k]) sample_std = np.std([x.result() for x in sample_results[k]]) logwriter.writerow([ total_triangles, k, epsilon, delta, sample_mean, sample_std, runtime_average[k] ]) executor.shutdown(wait=True)
def triangle_histogram(net, density=True): (count, triangles, nodes) = common.triangle_count(net) triangle_count_per_node = [len(nodes[node]) for node in nodes] # print(triangle_count_per_node) hist = np.histogram(triangle_count_per_node, bins=max(triangle_count_per_node), density=density) return hist[0]
def test_hist(net): (count, triangles, nodes) = common.triangle_count(net) hist = triangle_histogram(net, density=False) sum_hist = 0 for i in range(len(hist)): sum_hist += (i + 1) * hist[i] if count != sum_hist / 3: print("Error hist. Count:", count, "Hist:", sum_hist / 3) else: print("Sum correct")
def karwa_local_sensitivity(net, epsilon, delta, repeat=1): ls = max_common_neighbors(net) beta_arr = np.random.laplace( 0, 1 / epsilon, repeat) + math.log(math.exp(epsilon) + 1 / delta) / epsilon + ls result_arr = [(common.triangle_count(net)[0] + np.random.laplace(0, beta_hat / epsilon)) for beta_hat in beta_arr] if repeat == 1: return result_arr[0] return result_arr
def main(): csvfile = open(result_file, 'a') result_writer = csv.writer(csvfile, delimiter=',', quotechar='|', quoting=csv.QUOTE_MINIMAL) for net_name in network_name: print("Net:", net_name) net = nx.read_edgelist(network_path + net_name + ".txt", create_using=nx.Graph(), nodetype=int) true_triangle_count = common.triangle_count(net)[0] #print("True count:", true_triangle_count) epsilon = [0.001, 0.005, 0.01, 0.05, 0.1, 0.5, 1.0] #print("Epsilon/Delta:", epsilon, delta) blocki_100_triangle = blocki_node_triange_count(net, epsilon, 100, reps=int(sys.argv[1])) blocki_1000_triangle = blocki_node_triange_count(net, epsilon, 1000, reps=int(sys.argv[1])) for eps in epsilon: for sample in np.nditer(blocki_100_triangle[eps]): result_writer.writerow([time.time(), "node_privacy", "blocki_node_100", net_name, true_triangle_count, sample, eps, eps]) for sample in np.nditer(blocki_1000_triangle[eps]): result_writer.writerow([time.time(), "node_privacy", "blocki_node_1000", net_name, true_triangle_count, sample, eps, eps]) csvfile.flush()
def blocki_node_triange_count(net0, epsilon, k, reps): net = renumber_node_ids(net0) num_nodes = nx.number_of_nodes(net) num_edges = nx.number_of_edges(net) # Linear Programming Model lpm = grb.Model() lpm.Params.LogFile = "gurobi.log" lpm.Params.LogToConsole = 0 lpm.Params.Threads = 32 print("Prepare to add vars", num_nodes, num_edges) w = lpm.addVars(2 * num_edges, name="w") x = lpm.addVars(num_nodes, name="x") print("Finish to add vars") print("x", x[5241]) w_map = {} count = 0 for (u, v) in net.edges(): w_map[(u, v)] = w[count] count += 1 w_map[(v, u)] = w[count] count += 1 print("Prepare to add x constraints") lpm.addConstrs(x[i] >= 0 for i in range(num_nodes)) print("Added x constraints") for (u, v) in net.edges(): lpm.addConstr(w_map[(u, v)] >= 0) lpm.addConstr(w_map[(v, u)] >= 0) lpm.addConstr(w_map[(u, v)] >= 1 - x[u] - x[v]) lpm.addConstr(w_map[(v, u)] >= 1 - x[u] - x[v]) lpm.addConstr(w_map[(u, v)] <= 1) lpm.addConstr(w_map[(v, u)] <= 1) for i in range(num_nodes): lpm.addConstr(grb.quicksum(w_map[(i, j)] for j in nx.neighbors(net, i)) <= k) print("Add all constraints") lpm.setObjective(grb.quicksum(x[i] for i in range(num_nodes)), grb.GRB.MINIMIZE) lpm.optimize() # return lpm.ObjVal x_star = {} for v in lpm.getVars(): if "x" in v.varName: index = int(v.varName[2:-1]) x_star[index] = v.x #if "w" in v.varName: # if v.x < 1.0: # print(v.x) trim_net = nx.Graph() for (u, v) in net.edges(): if x_star[u] < 1/4 and x_star[v] < 1/4: trim_net.add_edge(u, v) count = common.triangle_count(trim_net)[0] print("Trim count:", count) result = {} for eps in epsilon: delta = eps if delta == 1.0: delta = 0.999 #to avoid division by 0 result[eps] = count + np.random.laplace(0, S_beta(beta=-eps / 2 * math.log(delta), d_hat=2 * num_edges / num_nodes, k=k, c=4) / eps, reps) return result
def main(): csvfile = open(result_file, 'a') result_writer = csv.writer(csvfile, delimiter=',', quotechar='|', quoting=csv.QUOTE_MINIMAL) true_k_core = {} for net_name in network_name: net = nx.read_edgelist(network_path + net_name + ".txt", create_using=nx.Graph(), nodetype=int) # net.remove_edges_from(nx.selfloop_edges(net)) for i in range(int(sys.argv[1])): print("Repeat:", i) for net_name in network_name: print("Net:", net_name) net = nx.read_edgelist(network_path + net_name + ".txt", create_using=nx.Graph(), nodetype=int) net.remove_edges_from(nx.selfloop_edges(net)) print("Original") start = timeit.default_timer() common.triangle_count(net) end = timeit.default_timer() true_runtime = end - start for epsilon in [1, 0.5, 0.1, 0.05, 0.01, 0.005, 0.001]: result_writer.writerow([ time.time(), "node_privacy", "original", "runtime", net_name, epsilon, epsilon, i, # reserve for index true_runtime ]) print("Sampling") for epsilon in [1, 0.5, 0.1, 0.05, 0.01, 0.005, 0.001]: delta = epsilon start = timeit.default_timer() basic_node.private_basic_node_triangle_count( net, epsilon, delta) end = timeit.default_timer() runtime = end - start result_writer.writerow([ time.time(), "node_privacy", "basic_node", "runtime", net_name, epsilon, delta, i, #reserve for index runtime ]) start = timeit.default_timer() basic_edge.private_basic_edge_triange_count( net, epsilon, delta) end = timeit.default_timer() runtime = end - start result_writer.writerow([ time.time(), "edge_privacy", "basic_edge", "runtime", net_name, epsilon, delta, i, #reserve for index runtime ]) start = timeit.default_timer() color.private_color_triange_count(net, epsilon, delta) end = timeit.default_timer() runtime = end - start result_writer.writerow([ time.time(), "edge_privacy", "color", "runtime", net_name, epsilon, delta, i, #reserve for index runtime ]) csvfile.flush() print("blocki") start = timeit.default_timer() blocki_edge.private_edge_blocki_triangle_count( net, epsilon, 100, 1) end = timeit.default_timer() blocki_edge_100_runtime = end - start print("blocki node") start = timeit.default_timer() blocki_node.blocki_node_triange_count(net, [epsilon], 100, 1) end = timeit.default_timer() blocki_node_100_runtime = end - start print("shiva") start = timeit.default_timer() shiva.shiva_differentially_private_triange_count(net, 100, epsilon, method="gurobi", reps=1) end = timeit.default_timer() shiva_100_runtime = end - start # start = timeit.default_timer() # ding.blocki_node_triangle_count(net, epsilon, 100, 1) # end = timeit.default_timer() # ding_26_runtime = end - start for epsilon in [1, 0.5, 0.1, 0.05, 0.01, 0.005, 0.001]: result_writer.writerow([ time.time(), "edge_privacy", "blocki_edge_100", "runtime", net_name, epsilon, epsilon, i, #reserve for index blocki_edge_100_runtime ]) result_writer.writerow([ time.time(), "node_privacy", "blocki_node_100", "runtime", net_name, epsilon, epsilon, i, #reserve for index blocki_node_100_runtime ]) result_writer.writerow([ time.time(), "node_privacy", "shiva_100", "runtime", net_name, epsilon, epsilon, i, #reserve for index shiva_100_runtime ]) csvfile.flush()
def private_color_triange_count(net, epsilon, delta): p = min(1.0, delta) sampled_net = color_sample(net, p) return common.triangle_count(sampled_net)[0] / (p**2)
def private_basic_edge_triange_count(net, epsilon, delta): p = min(1 - math.exp(-epsilon), delta, 1.0) sampled_net = basic_edge_sample(net, p) return common.triangle_count(sampled_net)[0] / (p**3)