def cluster_false_hit(DF,
size=100,
limit=1,
ylim=None,
xlim=None,
saveto=None,
xscale='log',
yscale='linear'):
df = DF.copy()
df.gen_ki = (df.gen_ki / float(size)).astype(int)
df['fh_poly'] = df.tot_hit - df.k
xs = {}
ys = {}
algos = []
xs[3], ys[3] = gen_xy(df, 'gen_ki', 'fh_poly', limit=limit)
algos.append(alias['rePolyanya'])
for k in xs.keys():
xs[k] = [v * size for v in xs[k]]
plot_graph('Nodes generated by h$_v$',
'false hit',
list(xs.values()),
list(ys.values()),
algos,
ylim=ylim,
xlim=xlim,
saveto=saveto,
xscale=xscale,
yscale=yscale,
loc='in')
def experiment2_dense_gen(DF, gen_ylim, limit=10):
# dense: gen
saveto = './figs/e2_dense_gen.png'
df = DF.copy()
df = df[(df.polys >= 8000) & (df.k <= 10)]
xs = {}
ys = {}
algos = []
xs[0], ys[0] = gen_xy(df, 'k', 'cost_ffp', limit=limit)
algos.append(alias['rePolyanya'])
xs[1], ys[1] = ut.gen_xy(df, 'k', 'gen_ki', limit=limit)
algos.append(alias['interval heuristic'])
xs[2], ys[2] = ut.gen_xy(df, 'k', 'gen_hi', limit=limit)
algos.append(alias['target heuristic'])
xs[3], ys[3] = ut.gen_xy(df, 'k', 'gen_edbt', limit=limit)
algos.append('LVG')
for k in xs.keys():
xs[k] = [v for v in xs[k]]
# ys[k] = np.log10(ys[k])
ut.plot_graph('k', 'generated (log10)', list(xs.values()), list(ys.values()), algos,
ylim=gen_ylim, saveto=saveto)
def experiment1_dense_time(DF, time_ylim=None, size=50, blimit=10):
saveto = './figs/e1_dense_time.png'
df = DF.copy()
df = df[df.k == 1]
df.dist = (df.dist / size).astype(int)
xs = {}
ys = {}
algos = []
xs[0], ys[0] = gen_xy(df, 'dist', 'cost_ffp', limit=blimit)
algos.append(alias['rePolyanya'])
xs[1], ys[1] = ut.gen_xy(df, 'dist', 'cost_ki', limit=blimit)
algos.append(alias['interval heuristic'])
xs[2], ys[2] = ut.gen_xy(df, 'dist', 'cost_hi', limit=blimit)
algos.append(alias['target heuristic'])
xs[3], ys[3] = ut.gen_xy(df, 'dist', 'cost_edbt', limit=blimit)
algos.append('LVG')
for k in xs.keys():
xs[k] = [v * size for v in xs[k]]
ys[k] = [v / 1000 for v in ys[k]]
# ys[k] = np.log10(ys[k])
ut.plot_graph('dist', 'time(ms) (log10)', list(xs.values()), list(ys.values()), algos,
ylim=time_ylim, saveto=saveto)
def experiment1_sparse_time(DF, time_ylim, size=500, limit=10):
# sparse: time
saveto = './figs/e1_sparse_time.png'
df = DF.copy()
df = df[(df.k == 1) & (df.pts == 10)]
df.dist = (df.dist / size).astype(int)
xs = {}
ys = {}
algos = []
xs[0], ys[0] = gen_xy(df, 'dist', 'cost_ffp', limit=limit)
algos.append(alias['rePolyanya'])
xs[1], ys[1] = ut.gen_xy(df, 'dist', 'cost_ki', limit=limit)
algos.append(alias['interval heuristic'])
xs[2], ys[2] = ut.gen_xy(df, 'dist', 'cost_hi', limit=limit)
algos.append(alias['target heuristic'])
for k in xs.keys():
xs[k] = [v * size for v in xs[k]]
ys[k] = [v / 1000 for v in ys[k]]
ut.plot_graph('dist', 'time(ms) (log10)', list(xs.values()), list(ys.values()), algos,
ylim=time_ylim, saveto=saveto)
def experiment3_gen(DF, gen_ylim, limit=10):
# sparse: expaned
saveto = './figs/e3_gen.png'
df = DF.copy()
df = df[(df.polys >= 8000) & (df.k == 1) & (df.pts <= 10)]
xs = {}
ys = {}
algos = []
# xs[0], ys[0] = gen_xy(df, 'pts', 'gen_ki0', limit=limit)
# algos.append(alias['poly-zero'])
xs[1], ys[1] = gen_xy(df, 'pts', 'gen_ki', limit=limit)
algos.append(alias['interval heuristic'])
xs[2], ys[2] = gen_xy(df, 'pts', 'gen_hi', limit=limit)
algos.append(alias['target heuristic'])
xs[3], ys[3] = gen_xy(df, 'pts', 'gen_ffp', limit=limit)
algos.append(alias['rePolyanya'])
for i in xs.keys():
xs[i] = [v for v in xs[i]]
# ys[i] = np.log10(ys[i])
plot_graph('target', 'generated (log10)', list(xs.values()), list(ys.values()), algos,
ylim=gen_ylim, saveto=saveto)
def experiment3_time(DF, time_ylim=None, limit=10):
# sparse: time
saveto = './figs/e3_time.png'
df = DF.copy()
df = df[(df.polys >= 8000) & (df.k == 1) & (df.pts <= 10)]
xs = {}
ys = {}
algos = []
# xs[0], ys[0] = gen_xy(df, 'pts', 'cost_ki0', limit=limit)
# algos.append(alias['poly-zero'])
xs[1], ys[1] = gen_xy(df, 'pts', 'cost_ki', limit=limit)
algos.append(alias['interval heuristic'])
xs[2], ys[2] = gen_xy(df, 'pts', 'cost_hi', limit=limit)
algos.append(alias['target heuristic'])
xs[3], ys[3] = gen_xy(df, 'pts', 'cost_ffp', limit=limit)
algos.append(alias['rePolyanya'])
for i in xs.keys():
xs[i] = [v for v in xs[i]]
ys[i] = [v / 1000 for v in ys[i]]
plot_graph('target', 'time(ms) (log10)', list(xs.values()), list(ys.values()), algos,
ylim=time_ylim, saveto=saveto)
def experiment2_sparse_time(DF, time_ylim, limit=10):
# sparse: time
saveto = './figs/e2_sparse_time.png'
df = DF.copy()
df = df[(df.polys >= 8000) & (df.pts == 10)]
xs = {}
ys = {}
algos = []
# xs[0], ys[0] = gen_xy(df, 'k', 'cost_ki0', limit=limit)
# algos.append(alias['poly-zero'])
xs[1], ys[1] = ut.gen_xy(df, 'k', 'cost_ki', limit=limit)
algos.append(alias['interval heuristic'])
xs[2], ys[2] = ut.gen_xy(df, 'k', 'cost_hi', limit=limit)
algos.append(alias['target heuristic'])
xs[3], ys[3] = ut.gen_xy(df, 'k', 'cost_ffp', limit=limit)
algos.append(alias['rePolyanya'])
for k in xs.keys():
xs[k] = [v for v in xs[k]]
ys[k] = [v / 1000 for v in ys[k]]
# ys[k] = np.log10(ys[k])
ut.plot_graph('k', 'time(ms) (log10)', list(xs.values()), list(ys.values()), algos, yscale='log',
ylim=time_ylim, saveto=saveto)
def experiment2_dense_time(DF, time_ylim=None, limit=10):
# dense: time
saveto = './figs/e2_dense_time.png'
df = DF.copy()
df = df[(df.polys >= 8000) & (df.k <= 10)]
xs = {}
ys = {}
algos = []
xs[0], ys[0] = gen_xy(df, 'k', 'cost_ffp', limit=limit)
algos.append(alias['rePolyanya'])
xs[1], ys[1] = gen_xy(df, 'k', 'cost_ki', limit=limit)
algos.append(alias['interval heuristic'])
xs[2], ys[2] = gen_xy(df, 'k', 'cost_hi', limit=limit)
algos.append(alias['target heuristic'])
xs[3], ys[3] = gen_xy(df, 'k', 'cost_edbt', limit=limit)
algos.append('LVG')
xs[4], ys[4] = gen_xy(df, 'k', 'cost_fi', limit=limit)
algos.append(alias['fence heuristic'])
for k in xs.keys():
xs[k] = [v for v in xs[k]]
ys[k] = [v / 1000 for v in ys[k]]
ut.plot_graph('k', 'time(ms) (log10)', list(xs.values()), list(ys.values()), algos,
ylim=time_ylim, saveto=saveto)
def nn_time_by_vnum(DF,
ylim=None,
xlim=None,
saveto=None,
limit=10,
size=500,
xscale='log',
yscale='log'):
df = DF.copy()
xs = {}
ys = {}
algos = []
# df.cost_fi = df.cost_ki0 / df.cost_fi
# df.cost_ffp = df.cost_ki0 / df.cost_ffp
# df.cost_ki = df.cost_ki0 / df.cost_ki
# df.cost_hi = df.cost_ki0 / df.cost_hi
# df.gen_ki0 = (df.gen_ki0 / size).astype(int)
# vnum = df.vertices.min()
df.vnum = (df.vnum / size).astype(int)
xs[0], ys[0] = gen_xy(df, 'vnum', 'cost_fc', limit=limit)
algos.append(alias['fence nn'])
xs[1], ys[1] = gen_xy(df, 'vnum', 'cost_ffp', limit=limit)
algos.append(alias['rePolyanya'])
xs[2], ys[2] = gen_xy(df, 'vnum', 'cost_ki', limit=limit)
algos.append(alias['interval heuristic'])
xs[3], ys[3] = gen_xy(df, 'vnum', 'cost_hi', limit=limit)
algos.append(alias['target heuristic'])
xs[4], ys[4] = gen_xy(df, 'vnum', 'cost_fi', limit=limit)
algos.append(alias['fence heuristic'])
xs[5], ys[5] = gen_xy(df, 'pts', 'cost_edbt', limit=limit)
algos.append('LVG')
for i in xs.keys():
xs[i] = [v * size for v in xs[i]]
ys[i] = [v / 1000.0 for v in ys[i]]
# plot_graph('Nodes generated by h0', 'Speedup vs h0', list(xs.values()), list(ys.values()), algos,
# ylim=ylim, saveto=saveto, xscale='log')
plot_graph('vertices on path',
'time(ms) log10',
list(xs.values()),
list(ys.values()),
algos,
ylim=ylim,
xlim=xlim,
saveto=saveto,
xscale=xscale,
yscale=yscale)
def maxrank_by_k(DF, limit=1):
df = DF.copy()
xs = {}
ys = {}
algos = []
xs[0], ys[0] = gen_xy(df, 'k', 'max_rank', limit=limit)
algos.append('max_rank')
plot_graph('k',
'max_rank',
list(xs.values()),
list(ys.values()),
algos,
yscale='linear')
def false_hit_ratio_by_k(DF, limit=1):
df = DF.copy()
xs = {}
ys = {}
algos = []
df['ratio'] = (df.tot_hit - df.k) / df.k
xs[0], ys[0] = gen_xy(df, 'k', 'ratio', limit=limit)
algos.append('ratio')
plot_graph('k',
'ratio',
list(xs.values()),
list(ys.values()),
algos,
yscale='linear')
def false_hit_by_k(DF, limit=1, saveto=None):
df = DF.copy()
xs = {}
ys = {}
algos = []
df['false_hit'] = df.tot_hit - df.k
xs[0], ys[0] = gen_xy(df, 'k', 'false_hit', limit=limit)
algos.append(alias['rePolyanya'])
plot_graph('k',
'false hit',
list(xs.values()),
list(ys.values()),
algos,
yscale='linear',
saveto=saveto)
def fence_time(DF, limit=1, size=1, saveto=None):
xs = {}
ys = {}
algos = []
df = DF.copy()
df.pts = (df.pts / size).astype(int)
for k in xs.keys():
xs[k] = [v * size for v in xs[k]]
xs[0], ys[0] = gen_xy(df, 'pts', 'cost', limit=limit)
algos.append('ratio')
plot_graph('target number',
'time(ms) log10',
list(xs.values()),
list(ys.values()),
algos,
yscale='log')
def nn_time_by_dense(DF,
ylim=None,
xlim=None,
saveto=None,
limit=10,
size=500,
xscale='log',
yscale='log'):
df = DF.copy()
xs = {}
ys = {}
algos = []
vnum = df.vertices.min()
xs[0], ys[0] = gen_xy(df, 'pts', 'cost_fc', limit=limit)
algos.append(alias['fence nn'])
xs[1], ys[1] = gen_xy(df, 'pts', 'cost_ffp', limit=limit)
algos.append(alias['rePolyanya'])
xs[2], ys[2] = gen_xy(df, 'pts', 'cost_hi', limit=limit)
algos.append(alias['target heuristic'])
xs[3], ys[3] = gen_xy(df, 'pts', 'cost_ki', limit=limit)
algos.append(alias['interval heuristic'])
xs[4], ys[4] = gen_xy(df, 'pts', 'cost_fi', limit=limit)
algos.append(alias['fence heuristic'])
for i in xs.keys():
xs[i] = [v / float(vnum) for v in xs[i]]
ys[i] = [v / 1000.0 for v in ys[i]]
# plot_graph('Nodes generated by h0', 'Speedup vs h0', list(xs.values()), list(ys.values()), algos,
# ylim=ylim, saveto=saveto, xscale='log')
xticks = ([0.0001, 0.001, 0.01, 0.1], ["0.01\%", "0.1\%", "1\%", "10\%"])
plot_graph('target density',
'time(ms) log10',
list(xs.values()),
list(ys.values()),
algos,
ylim=ylim,
xlim=xlim,
saveto=saveto,
xscale=xscale,
yscale=yscale,
xticks=xticks)
def vary_k(DF,
saveto=None,
xscale='log',
limit=10,
xlim=None,
yscale=None,
ylim=None):
# dense: time
df = DF.copy()
xs = {}
ys = {}
algos = []
xs[0], ys[0] = gen_xy(df, 'k', 'cost_ffp', limit=limit)
algos.append(alias['rePolyanya'])
print(max(ys[0]) / min(ys[0]))
xs[1], ys[1] = gen_xy(df, 'k', 'cost_ki', limit=limit)
algos.append(alias['interval heuristic'])
xs[2], ys[2] = gen_xy(df, 'k', 'cost_hi', limit=limit)
algos.append(alias['target heuristic'])
df['cost_edbt'] = df.cost_edbt.clip(0, 1e6)
xs[3], ys[3] = gen_xy(df, 'k', 'cost_edbt', limit=limit)
algos.append('LVG')
xs[4], ys[4] = gen_xy(df, 'k', 'cost_fi', limit=limit)
algos.append(alias['fence heuristic'])
for k in xs.keys():
xs[k] = [v for v in xs[k]]
ys[k] = [v / 1000 for v in ys[k]]
plot_graph('k',
'time(ms) (log10)',
list(xs.values()),
list(ys.values()),
algos,
ylim=ylim,
saveto=saveto,
xscale=xscale,
xlim=xlim,
yscale=yscale)
def cluster_improve_gen(DF,
size=100,
limit=1,
ylim=None,
xlim=None,
saveto=None,
xscale='log'):
df = DF.copy()
df['imp_hi'] = df.gen_ki / df.gen_hi
df['imp_poly'] = df.gen_ki / df.gen_ffp
df['imp_fi'] = df.gen_ki / df.gen_fi
df['imp_ki'] = df.gen_ki / df.gen_ki
df.gen_ki = (df.gen_ki / float(size)).astype(int)
xs = {}
ys = {}
algos = []
xs[0], ys[0] = gen_xy(df, 'gen_ki', 'imp_fi', limit=limit)
algos.append(alias['fence heuristic'])
xs[1], ys[1] = gen_xy(df, 'gen_ki', 'imp_ki', limit=limit)
algos.append(alias['interval heuristic'])
xs[2], ys[2] = gen_xy(df, 'gen_ki', 'imp_hi', limit=limit)
algos.append(alias['target heuristic'])
xs[3], ys[3] = gen_xy(df, 'gen_ki', 'imp_poly', limit=limit)
algos.append(alias['rePolyanya'])
for k in xs.keys():
xs[k] = [v * size for v in xs[k]]
plot_graph('Nodes generated by h$_v$',
'Reduced gen vs h$_v$',
list(xs.values()),
list(ys.values()),
algos,
ylim=ylim,
xlim=xlim,
saveto=saveto,
xscale=xscale,
loc='in')
def vary_k_gen(DF,
ylim=None,
saveto=None,
xscale='log',
limit=10,
xlim=None,
yscale=None):
# dense: time
df = DF.copy()
xs = {}
ys = {}
algos = []
xs[0], ys[0] = gen_xy(df, 'k', 'gen_ffp', limit=limit)
algos.append(alias['rePolyanya'])
xs[1], ys[1] = gen_xy(df, 'k', 'gen_ki', limit=limit)
algos.append(alias['interval heuristic'])
xs[2], ys[2] = gen_xy(df, 'k', 'gen_hi', limit=limit)
algos.append(alias['target heuristic'])
if (df.cost_edbt.max() > 0):
xs[3], ys[3] = gen_xy(df, 'k', 'gen_edbt', limit=limit)
algos.append('LVG')
xs[4], ys[4] = gen_xy(df, 'k', 'gen_fi', limit=limit)
algos.append(alias['fence heuristic'])
for k in xs.keys():
xs[k] = [v for v in xs[k]]
plot_graph('k',
'generated (log10)',
list(xs.values()),
list(ys.values()),
algos,
ylim=ylim,
saveto=saveto,
xscale=xscale,
xlim=xlim,
yscale=yscale)
def vary_map_time(DF,
size=100,
limit=1,
ylim=None,
xlim=None,
saveto=None,
xscale='log'):
saveto = './figs/e1_dense_time.png'
df = DF.copy()
# df.dist = (df.dist / size).astype(int)
df.gen_ki = (df.gen_ki / float(size)).astype(int)
xs = {}
ys = {}
algos = []
xs[0], ys[0] = gen_xy(df, 'gen_ki', 'cost_ffp', limit=limit)
algos.append(alias['rePolyanya'])
xs[1], ys[1] = gen_xy(df, 'gen_ki', 'cost_ki', limit=limit)
algos.append(alias['interval heuristic'])
xs[2], ys[2] = gen_xy(df, 'gen_ki', 'cost_hi', limit=limit)
algos.append(alias['target heuristic'])
xs[3], ys[3] = gen_xy(df, 'gen_ki', 'cost_fi', limit=limit)
algos.append(alias['fence heuristic'])
for k in xs.keys():
xs[k] = [v * size for v in xs[k]]
ys[k] = [v / 1000 for v in ys[k]]
# ys[k] = np.log10(ys[k])
plot_graph('Nodes generated by hv',
'time(ms) (log10)',
list(xs.values()),
list(ys.values()),
algos,
ylim=ylim,
saveto=saveto)
def vary_t(DF, ylim=None, saveto=None, limit=10):
# sparse: time
df = DF.copy()
xs = {}
ys = {}
algos = []
df['cost_edbt'] = df.cost_edbt.clip(0, 1e6)
xs[0], ys[0] = gen_xy(df, 'pts', 'cost_fi', limit=limit)
algos.append(alias['fence heuristic'])
xs[1], ys[1] = gen_xy(df, 'pts', 'cost_ki', limit=limit)
algos.append(alias['interval heuristic'])
xs[2], ys[2] = gen_xy(df, 'pts', 'cost_hi', limit=limit)
algos.append(alias['target heuristic'])
xs[3], ys[3] = gen_xy(df, 'pts', 'cost_ffp', limit=limit)
algos.append(alias['rePolyanya'])
xs[4], ys[4] = gen_xy(df, 'pts', 'cost_edbt', limit=limit)
algos.append('LVG')
vnum = df.vertices.min()
for i in xs.keys():
xs[i] = [v / float(vnum) for v in xs[i]]
ys[i] = [v / 1000 for v in ys[i]]
xticks = ([0.0001, 0.001, 0.01, 0.1], ["0.01\%", "0.1\%", "1\%", "10\%"])
plot_graph('target density',
'time(ms) (log10)',
list(xs.values()),
list(ys.values()),
algos,
ylim=ylim,
saveto=saveto,
xscale='log',
xticks=xticks)
fesgp_ddps = error_lr_1.feasibility_gap(np.sum(theta_ddps, axis=1) / size)
theta_DAGP = dopt.ADDOPT(lr_1, ZR, ZC, step_size4, int(depoch), theta_1)
res_F_DAGP = error_lr_1.cost_path(np.sum(theta_DAGP, axis=1) / size)
fesgp_DAGP = error_lr_1.feasibility_gap(np.sum(theta_DAGP, axis=1) / size)
# ------------------------------------------------------------------------------
# ------------------------------------------------------------------------------
plot_figs(res_F_DAGP,
res_F_ddps,
16,
15,
5000,
2,
'Objective Value',
'Iterations', ('ADDOPT', 'DDPS'),
os.path.join(output_path, 'objective'),
Block=False)
plot_figs(fesgp_DAGP,
fesgp_ddps,
16,
15,
5000,
2,
'Feasibility Error',
'Iterations', ('ADDOPT', 'DDPS'),
os.path.join(output_path, 'feasibility'),
Block=False)
#------------------------------------------------------------------------------
plot_graph(pseudo_adj, os.path.join(output_path, 'graph'), Block=False)
#------------------------------------------------------------------------------
