def test_cwba():
n = 1000
rho = Decimal(str(2.0))
m = Decimal(str(0.0))
censorP = 0.7
avgRuns = 10
increment = Decimal(str(1.0))
spdaccs = []
dsdaccs = []
rdaccs = []
params = []
m += increment
while int(m) < 20:
#A, truth = cg.construct_adj(n,float(p),float(q))
#A, truth = cg.constructWithHubs(n,float(p),float(q),r)
A, truth = cwba.cwba_graph(n, int(m), float(rho))
spdcorr, spdtotal = sim.runsim(truth, censorP,
voting.scipy_weighted_knn,
metrics.spd_mat(A), avgRuns)
dsdcorr, dsdtotal = sim.runsim(truth, censorP,
voting.scipy_weighted_knn,
metrics.dsd_mat(A), avgRuns)
rdcorr, rdtotal = sim.runsim(truth, censorP, voting.scipy_weighted_knn,
metrics.rd_mat(A), avgRuns)
spdaccs.append(spdcorr / spdtotal)
dsdaccs.append(dsdcorr / dsdtotal)
rdaccs.append(rdcorr / rdtotal)
m += increment
params.append(int(m))
plotting.plot_params_vs_accuracy(params, [spdaccs, dsdaccs, rdaccs],
"Minimum vertex degree (m)",
["SPD", "DSD", "RD"],
"CWBA (" + u"\u03C1" + "=2)")
def test_cwba_inv():
n = 1000
rho_inv = Decimal(str(0.0))
m = Decimal(str(300.0))
censorP = 0.7
avgRuns = 10
increment = Decimal(str(0.05))
spdaccs = []
dsdaccs = []
rdaccs = []
params = []
rho_inv += increment
while float(rho_inv) < 1:
#A, truth = cg.construct_adj(n,float(p),float(q))
#A, truth = cg.constructWithHubs(n,float(p),float(q),r)
A, truth = cwba.cwba_graph(n, int(m), 1 / float(rho_inv))
spdcorr, spdtotal = sim.runsim(truth, censorP,
voting.scipy_weighted_knn,
metrics.spd_mat(A), avgRuns)
dsdcorr, dsdtotal = sim.runsim(truth, censorP,
voting.scipy_weighted_knn,
metrics.dsd_mat(A), avgRuns)
rdcorr, rdtotal = sim.runsim(truth, censorP, voting.scipy_weighted_knn,
metrics.rd_mat(A), avgRuns)
spdaccs.append(spdcorr / spdtotal)
dsdaccs.append(dsdcorr / dsdtotal)
rdaccs.append(rdcorr / rdtotal)
rho_inv += increment
params.append(float(rho_inv))
plotting.plot_params_vs_accuracy(params, [spdaccs, dsdaccs, rdaccs],
"1/rho", ["SPD", "DSD", "RD"])
def test_ncch_r():
# Initialize parameters
global n,rp,censorP,avgRuns,vote
p = Decimal(str(0.2)) # p=0.2,0.8
q = Decimal(str(0.5)) # q=0.5
r = 100 # r=(0,20,1), r=(100,400,50)
increment = 50
accs_spd,accs_dsd,accs_rd = [],[],[]
params = []
# Run simulations
while r <= 400:
A, truth = ncch.construct_adj(n,float(p),float(q),r,rp)
correct_spd, total_spd = sim.runsim(truth, censorP,
vote, metrics.spd_mat(A), avgRuns)
correct_dsd, total_dsd = sim.runsim(truth, censorP,
vote, metrics.dsd_mat(A), avgRuns)
correct_rd, total_rd = sim.runsim(truth, censorP,
vote, metrics.rd_mat(A), avgRuns)
accs_spd.append(correct_spd/total_spd)
accs_dsd.append(correct_dsd/total_dsd)
accs_rd.append(correct_rd/total_rd)
print(r)
params.append(r)
r += increment
plotting.plot_params_vs_accuracy(params, [accs_spd, accs_dsd, accs_rd],
"Number of hubs",
["SPD","DSD","RD"],
"NCCH (p="+str(p)+",q="+str(q)+")")
return
def test_ncch_q():
# Initialize parameters
global n,r,rp,censorP,avgRuns,increment,vote
p = Decimal(str(0.5))
q = Decimal(str(0.0))
accs_spd,accs_dsd,accs_rd = [],[],[]
params = []
# Run simulations
while float(q) <= 1:
A, truth = ncch.construct_adj(n,float(p),float(q),r,rp)
correct_spd, total_spd = sim.runsim(truth, censorP,
vote, metrics.spd_mat(A), avgRuns)
correct_dsd, total_dsd = sim.runsim(truth, censorP,
vote, metrics.dsd_mat(A), avgRuns)
correct_rd, total_rd = sim.runsim(truth, censorP,
vote, metrics.rd_mat(A), avgRuns)
accs_spd.append(correct_spd/total_spd)
accs_dsd.append(correct_dsd/total_dsd)
accs_rd.append(correct_rd/total_rd)
print(q)
params.append(float(q))
q += increment
plotting.plot_params_vs_accuracy(params, [accs_spd, accs_dsd, accs_rd],
"Edge deletion probability (q)",
["SPD","DSD","RD"],
"NCCH (p=0.5)")
return
def test_ncch_censor():
# Initialize parameters
global n,r,rp,avgRuns,vote
p = Decimal(str(0.8)) # p=0.8
q = Decimal(str(0.5)) # q=0.5
censorP = Decimal(str(0.1))
increment = Decimal(str(0.1))
accs_spd,accs_dsd,accs_rd = [],[],[]
params = []
# Run simulations
while float(censorP) < 1:
A, truth = ncch.construct_adj(n,float(p),float(q),r,rp)
correct_spd, total_spd = sim.runsim(truth, float(censorP),
vote, metrics.spd_mat(A), avgRuns)
correct_dsd, total_dsd = sim.runsim(truth, float(censorP),
vote, metrics.dsd_mat(A), avgRuns)
correct_rd, total_rd = sim.runsim(truth, float(censorP),
vote, metrics.rd_mat(A), avgRuns)
accs_spd.append(correct_spd/total_spd)
accs_dsd.append(correct_dsd/total_dsd)
accs_rd.append(correct_rd/total_rd)
print(censorP)
params.append(float(censorP))
censorP += increment
plotting.plot_params_vs_accuracy(params, [accs_spd, accs_dsd, accs_rd],
"Vertex label censor proportion",
["SPD","DSD","RD"],
"NCCH (p="+str(p)+",q="+str(q)+")")
return
def test_cwba_rhoinv():
# Initialize parameters
global n, censorP, avgRuns, vote
rho_inv = Decimal(str(0.05))
m = Decimal(str(300.0))
increment = Decimal(str(0.05))
accs_spd, accs_dsd, accs_rd = [], [], []
params = []
# Run simulations
while float(rho_inv) <= 1:
A, truth = cwba.cwba_graph(n, int(m), 1 / float(rho_inv))
correct_spd, total_spd = sim.runsim(truth, censorP, vote,
metrics.spd_mat(A), avgRuns)
correct_dsd, total_dsd = sim.runsim(truth, censorP, vote,
metrics.dsd_mat(A), avgRuns)
correct_rd, total_rd = sim.runsim(truth, censorP, vote,
metrics.rd_mat(A), avgRuns)
accs_spd.append(correct_spd / total_spd)
accs_dsd.append(correct_dsd / total_dsd)
accs_rd.append(correct_rd / total_rd)
print(rho_inv)
params.append(float(rho_inv))
rho_inv += increment
rho_str = u"\u03C1"
plotting.plot_params_vs_accuracy(
params, [accs_spd, accs_dsd, accs_rd],
"Inverse likeliness of clusters (1/" + rho_str + ")",
["SPD", "DSD", "RD"], "CWBA (m=300)")
return
def test_cwba_m():
# Initialize parameters
global n, censorP, avgRuns, vote
rho = Decimal(str(2.0))
m = Decimal(str(1.0))
increment = Decimal(str(1.0))
accs_spd, accs_dsd, accs_rd = [], [], []
params = []
# Run simulations
while int(m) < 20:
A, truth = cwba.cwba_graph(n, int(m), float(rho))
correct_spd, total_spd = sim.runsim(truth, censorP, vote,
metrics.spd_mat(A), avgRuns)
correct_dsd, total_dsd = sim.runsim(truth, censorP, vote,
metrics.dsd_mat(A), avgRuns)
correct_rd, total_rd = sim.runsim(truth, censorP, vote,
metrics.rd_mat(A), avgRuns)
accs_spd.append(correct_spd / total_spd)
accs_dsd.append(correct_dsd / total_dsd)
accs_rd.append(correct_rd / total_rd)
print(m)
params.append(int(m))
m += increment
rho_str = u"\u03C1"
plotting.plot_params_vs_accuracy(params, [accs_spd, accs_dsd, accs_rd],
"New vertex degree (m)",
["SPD", "DSD", "RD"],
"CWBA (" + rho_str + "=2)")
return
def runtest_completeGraphs():
n = 200
q = 0.5
censorP = 0.3
avgRuns = 10
dsdacc, dsdparam = suite_completeGraphs(n, q, test_completeGraphs, censorP,
voting.scipy_weighted_knn,
metrics.dsd_mat, avgRuns)
spdacc, spdparam = suite_completeGraphs(n, q, test_completeGraphs, censorP,
voting.scipy_weighted_knn,
metrics.spd_mat, avgRuns)
rdacc, rdparam = suite_completeGraphs(n, q, test_completeGraphs, censorP,
voting.scipy_weighted_knn,
metrics.rd_mat, avgRuns)
plotting.plot_params_vs_accuracy(spdparam, [spdacc, dsdacc, rdacc], "p",
["SPD", "DSD", "RD"])
return
def test_coauthor():
spdaccs, dsdaccs, rdaccs, params = [], [], [], []
f = open('./coauthor_acc_vs_k.csv', 'r')
for line in f.readlines():
line = line.rstrip()
k, spd, dsd, rd = line.split(',')
if k == "k":
continue
params.append(float(k))
spdaccs.append(float(spd))
dsdaccs.append(float(dsd))
rdaccs.append(float(rd))
plotting.plot_params_vs_accuracy(params, [spdaccs, dsdaccs, rdaccs],
"k nearest neighbors (k)",
["SPD", "DSD", "RD"],
"Coauthorship Citation Network")
f.close()
def test():
n = 250
p = Decimal(str(0.0))
q = Decimal(str(0.0))
censorP = 0.3
avgRuns = 5
increment = Decimal(str(0.05))
spdaccs1 = []
spdaccs2 = []
dsdaccs = []
rdaccs = []
params = []
r = 100
q = Decimal(str(0.5))
while float(p) <= 1:
A, truth = cg.construct_adj(n, float(p), float(q))
#A, truth = cg.constructWithHubs(n,float(p),float(q),r)
#spdcorr1, spdtotal1 = sim.runsim(truth, censorP, voting.scipy_weighted_knn, metrics.spd_mat(A), avgRuns)
spdcorr1, spdtotal1 = sim.runsim(truth, censorP,
voting.sklearn_weighted_knn,
metrics.dsd_mat(A), avgRuns)
spdcorr2, spdtotal2 = sim.runsim(truth, censorP,
voting.knn_weighted_majority_vote,
metrics.dsd_mat(A), avgRuns)
#dsdcorr, dsdtotal = sim.runsim(truth, censorP, voting.scipy_weighted_knn, metrics.dsd_mat(A), avgRuns)
#rdcorr, rdtotal = sim.runsim(truth, censorP, voting.scipy_weighted_knn, metrics.rd_mat(A), avgRuns)
spdaccs1.append(spdcorr1 / spdtotal1)
spdaccs2.append(spdcorr2 / spdtotal2)
#dsdaccs.append(dsdcorr/dsdtotal)
#rdaccs.append(rdcorr/rdtotal)
print(p)
print(spdcorr1 / spdtotal1)
print(spdcorr2 / spdtotal2)
p += increment
params.append(float(p))
#plotting.plot_params_vs_accuracy(params, [spdaccs, dsdaccs, rdaccs], "Edge addition probability (p)", ["SPD","DSD", "RD"], "NCC (q=0.5)")
plotting.plot_params_vs_accuracy(params, [spdaccs1, spdaccs2],
"Edge addition probability (p)",
["SPD Scipy", "SPD Mine"],
"NCC (q=0.5, censorP=0.6)")
return
def test_censor():
n = 250
p = Decimal(str(0.3))
q = Decimal(str(0.5))
censorP = Decimal(str(0.05))
avgRuns = 10
increment = Decimal(str(0.05))
spdaccs = []
dsdaccs = []
rdaccs = []
params = []
r = 100
#p += increment
while float(censorP) < 1:
A, truth = cg.construct_adj(n, float(p), float(q))
#A, truth = cg.constructWithHubs(n,float(p),float(q),r)
spdcorr, spdtotal = sim.runsim(truth, float(censorP),
voting.scipy_weighted_knn,
metrics.spd_mat(A), avgRuns)
dsdcorr, dsdtotal = sim.runsim(truth, float(censorP),
voting.scipy_weighted_knn,
metrics.dsd_mat(A), avgRuns)
rdcorr, rdtotal = sim.runsim(truth, float(censorP),
voting.scipy_weighted_knn,
metrics.rd_mat(A), avgRuns)
spdaccs.append(spdcorr / spdtotal)
dsdaccs.append(dsdcorr / dsdtotal)
rdaccs.append(rdcorr / rdtotal)
print(censorP)
censorP += increment
params.append(float(censorP))
plotting.plot_params_vs_accuracy(params, [spdaccs, dsdaccs, rdaccs],
"Censoring probability (censorP)",
["SPD", "DSD", "RD"], "NCC (q=0.5)")
return
def test_cg():
n = 250
p = Decimal(str(0.0))
q = Decimal(str(0.0))
censorP = 0.6
avgRuns = 10
increment = Decimal(str(0.05))
spdaccs = []
dsdaccs = []
rdaccs = []
params = []
r = 100
#p += increment
while float(p) <= 1:
q = Decimal(str(0.5))
A, truth = cg.construct_adj(n, float(p), float(q))
#A, truth = cg.constructWithHubs(n,float(p),float(q),r)
spdcorr, spdtotal = sim.runsim(truth, censorP,
voting.scipy_weighted_knn,
metrics.spd_mat(A), avgRuns)
dsdcorr, dsdtotal = sim.runsim(truth, censorP,
voting.scipy_weighted_knn,
metrics.dsd_mat(A), avgRuns)
rdcorr, rdtotal = sim.runsim(truth, censorP, voting.scipy_weighted_knn,
metrics.rd_mat(A), avgRuns)
spdaccs.append(spdcorr / spdtotal)
dsdaccs.append(dsdcorr / dsdtotal)
rdaccs.append(rdcorr / rdtotal)
print(p)
p += increment
params.append(float(p))
plotting.plot_params_vs_accuracy(params, [spdaccs, dsdaccs, rdaccs],
"Edge addition probability (p)",
["SPD", "DSD", "RD"], "NCC (q=0.5)")
p = Decimal(str(0.5))
q = Decimal(str(0.0))
spdaccs = []
dsdaccs = []
rdaccs = []
params = []
q += increment
while float(q) <= 1:
A, truth = cg.construct_adj(n, float(p), float(q))
#A, truth = cg.constructWithHubs(n,float(p),float(q),r)
spdcorr, spdtotal = sim.runsim(truth, censorP,
voting.knn_weighted_majority_vote,
metrics.spd_mat(A), avgRuns)
dsdcorr, dsdtotal = sim.runsim(truth, censorP,
voting.knn_weighted_majority_vote,
metrics.dsd_mat(A), avgRuns)
rdcorr, rdtotal = sim.runsim(truth, censorP,
voting.knn_weighted_majority_vote,
metrics.rd_mat(A), avgRuns)
spdaccs.append(spdcorr / spdtotal)
dsdaccs.append(dsdcorr / dsdtotal)
rdaccs.append(rdcorr / rdtotal)
print(q)
q += increment
params.append(float(q))
plotting.plot_params_vs_accuracy(params, [spdaccs, dsdaccs, rdaccs],
"Edge deletion probability (q)",
["SPD", "DSD", "RD"],
"NCCH (p=0.5, number of hubs=100)")
return
def test_cg_h():
n = 250
p = Decimal(str(0.5))
q = Decimal(str(0.5))
censorP = 0.7
avgRuns = 10
increment = Decimal(str(1.0))
spdaccs = []
dsdaccs = []
rdaccs = []
params = []
r = Decimal(str(0.0))
r += increment
while float(r) <= 20:
#A, truth = cg.construct_adj(n,float(p),float(q))
A, truth = cg.constructWithHubs(n, float(p), float(q), int(r))
spdcorr, spdtotal = sim.runsim(truth, censorP,
voting.scipy_weighted_knn,
metrics.spd_mat(A), avgRuns)
dsdcorr, dsdtotal = sim.runsim(truth, censorP,
voting.scipy_weighted_knn,
metrics.dsd_mat(A), avgRuns)
rdcorr, rdtotal = sim.runsim(truth, censorP, voting.scipy_weighted_knn,
metrics.rd_mat(A), avgRuns)
spdaccs.append(spdcorr / spdtotal)
dsdaccs.append(dsdcorr / dsdtotal)
rdaccs.append(rdcorr / rdtotal)
r += increment
params.append(int(r))
plotting.plot_params_vs_accuracy(params, [spdaccs, dsdaccs, rdaccs],
"Number of hubs", ["SPD", "DSD", "RD"])
increment = Decimal(str(50.0))
spdaccs = []
dsdaccs = []
rdaccs = []
params = []
r = Decimal(str(50.0))
r += increment
while float(r) <= 400:
#A, truth = cg.construct_adj(n,float(p),float(q))
A, truth = cg.constructWithHubs(n, float(p), float(q), int(r))
spdcorr, spdtotal = sim.runsim(truth, censorP,
voting.scipy_weighted_knn,
metrics.spd_mat(A), avgRuns)
dsdcorr, dsdtotal = sim.runsim(truth, censorP,
voting.scipy_weighted_knn,
metrics.dsd_mat(A), avgRuns)
rdcorr, rdtotal = sim.runsim(truth, censorP, voting.scipy_weighted_knn,
metrics.rd_mat(A), avgRuns)
spdaccs.append(spdcorr / spdtotal)
dsdaccs.append(dsdcorr / dsdtotal)
rdaccs.append(rdcorr / rdtotal)
r += increment
params.append(int(r))
plotting.plot_params_vs_accuracy(params, [spdaccs, dsdaccs, rdaccs],
"Number of hubs", ["SPD", "DSD", "RD"])
return
