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)
