def test_grids(data, queryShape, all_queries):
global method_list, exp_name
exp_name = 'grids'
method_list = ['grid-uniform', 'grid-adaptive']
#'grid-pure','grid-uniform','grid-adaptive','grid-adaptive-localness'
res_cube_abs = np.zeros((len(eps_list), len(seed_list), len(method_list)))
res_cube_rel = np.zeros((len(eps_list), len(seed_list), len(method_list)))
for j in range(len(seed_list)):
queryList = all_queries[j]
kexp = GKExp(data, queryList)
p = Params(seed_list[j])
for i in range(len(eps_list)):
p.Eps = eps_list[i]
for k in range(len(method_list)):
if method_list[k] == 'grid-pure':
res_cube_abs[i, j, k], res_cube_rel[i, j, k] = kexp.run_Grid_pure(p)
elif method_list[k] == 'grid-uniform':
res_cube_abs[i, j, k], res_cube_rel[i, j, k] = kexp.run_Grid_uniform(p)
elif method_list[k] == 'grid-adaptive':
res_cube_abs[i, j, k], res_cube_rel[i, j, k] = kexp.run_Grid_adaptive(p)
elif method_list[k] == 'grid-adaptive-localness':
res_cube_abs[i, j, k], res_cube_rel[i, j, k] = kexp.run_Grid_adaptive_localness(p)
else:
logging.error('No such index structure!')
sys.exit(1)
res_abs_summary = np.average(res_cube_abs, axis=1)
res_rel_summary = np.average(res_cube_rel, axis=1)
#np.savetxt(Params.resdir+exp_name+'_abs_'+`int(queryShape[0]*10)`+'_'+`int(queryShape[1]*10)`, res_abs_summary, fmt='%.4f\t')
np.savetxt(Params.resdir + exp_name + '_rel_' + `int(queryShape[0] * 10)` + '_' + `int(queryShape[1] * 10)`,
res_rel_summary, fmt='%.4f\t')
def test_kdTrees(data, queryShape, all_queries):
global method_list, exp_name
exp_name = 'kdTrees'
method_list = ['kd-hybrid']
#'kd-true','kd-true-localness','kd-standard','kd-hybrid','kd-standard-localness','kd-hybrid-localness'
res_cube_abs = np.zeros((len(eps_list), len(seed_list), len(method_list)))
res_cube_rel = np.zeros((len(eps_list), len(seed_list), len(method_list)))
for j in range(len(seed_list)):
queryList = all_queries[j]
kexp = GKExp(data, queryList)
p = Params(seed_list[j])
for i in range(len(eps_list)):
p.Eps = eps_list[i]
for k in range(len(method_list)):
if method_list[k] == 'kd-pure':
res_cube_abs[i, j,
k], res_cube_rel[i, j,
k] = kexp.run_Kd_pure(p)
elif method_list[k] == 'kd-true':
res_cube_abs[i, j,
k], res_cube_rel[i, j,
k] = kexp.run_Kd_true(p)
elif method_list[k] == 'kd-true-localness':
res_cube_abs[i, j, k], res_cube_rel[
i, j, k] = kexp.run_Kd_true_localness(p)
elif method_list[k] == 'kd-standard':
res_cube_abs[i, j,
k], res_cube_rel[i, j,
k] = kexp.run_Kd_standard(p)
elif method_list[k] == 'kd-standard-localness':
res_cube_abs[i, j, k], res_cube_rel[
i, j, k] = kexp.run_Kd_standard_localness(p)
elif method_list[k] == 'kd-hybrid':
res_cube_abs[i, j,
k], res_cube_rel[i, j,
k] = kexp.run_Kd_hybrid(p)
elif method_list[k] == 'kd-hybrid-localness':
res_cube_abs[i, j, k], res_cube_rel[
i, j, k] = kexp.run_Kd_hybrid_localness(p)
else:
logging.error('No such index structure!')
sys.exit(1)
res_abs_summary = np.average(res_cube_abs, axis=1)
res_rel_summary = np.average(res_cube_rel, axis=1)
#np.savetxt(Params.resdir+exp_name+'_abs_'+`int(queryShape[0]*10)`+'_'+`int(queryShape[1]*10)`, res_abs_summary, fmt='%.4f\t')
np.savetxt(Params.resdir + exp_name + '_rel_' +
` int(queryShape[0] * 10) ` + '_' + ` int(queryShape[1] * 10) `,
res_rel_summary,
fmt='%.4f\t')
def test_quadtreeOpt(data, queryShape, all_queries):
global method_list, exp_name
exp_name = 'quadtreeOpt'
method_list = ['quad-geo']
# method_list = ['quad-baseline', 'quad-geo', 'quad-baseline-localness', 'quad-geo-localness']
res_cube_abs = np.zeros((len(eps_list), len(seed_list), len(method_list)))
res_cube_rel = np.zeros((len(eps_list), len(seed_list), len(method_list)))
for j in range(len(seed_list)):
queryList = all_queries[j]
kexp = GKExp(data, queryList)
p = Params(seed_list[j])
for i in range(len(eps_list)):
p.Eps = eps_list[i]
for k in range(len(method_list)):
if method_list[k] == 'quad-baseline':
res_cube_abs[i, j, k], res_cube_rel[i, j, k] = kexp.run_Quad_baseline(p)
elif method_list[k] == 'quad-baseline-localness':
res_cube_abs[i, j, k], res_cube_rel[i, j, k] = kexp.run_Quad_baseline_localness(p)
elif method_list[k] == 'quad-geo':
res_cube_abs[i, j, k], res_cube_rel[i, j, k] = kexp.run_Quad_geo(p)
elif method_list[k] == 'quad-geo-localness':
res_cube_abs[i, j, k], res_cube_rel[i, j, k] = kexp.run_Quad_geo_localness(p)
else:
logging.error('No such index structure!')
sys.exit(1)
res_abs_summary = np.average(res_cube_abs, axis=1)
res_rel_summary = np.average(res_cube_rel, axis=1)
#np.savetxt(Params.resdir+exp_name+'_abs_'+`int(queryShape[0]*10)`+'_'+`int(queryShape[1]*10)`, res_abs_summary, fmt='%.4f\t')
np.savetxt(Params.resdir + exp_name + '_rel_' + `int(queryShape[0] * 10)` + '_' + `int(queryShape[1] * 10)`,
res_rel_summary, fmt='%.4f\t')
def test_kdTrees(data, queryShape, all_queries):
global method_list, exp_name
exp_name = "kdTrees"
method_list = ["kd-hybrid"]
#'kd-true','kd-true-localness','kd-standard','kd-hybrid','kd-standard-localness','kd-hybrid-localness'
res_cube_abs = np.zeros((len(eps_list), len(seed_list), len(method_list)))
res_cube_rel = np.zeros((len(eps_list), len(seed_list), len(method_list)))
for j in range(len(seed_list)):
queryList = all_queries[j]
kexp = GKExp(data, queryList)
p = Params(seed_list[j])
for i in range(len(eps_list)):
p.Eps = eps_list[i]
for k in range(len(method_list)):
if method_list[k] == "kd-pure":
res_cube_abs[i, j, k], res_cube_rel[i, j, k] = kexp.run_Kd_pure(p)
elif method_list[k] == "kd-true":
res_cube_abs[i, j, k], res_cube_rel[i, j, k] = kexp.run_Kd_true(p)
elif method_list[k] == "kd-true-localness":
res_cube_abs[i, j, k], res_cube_rel[i, j, k] = kexp.run_Kd_true_localness(p)
elif method_list[k] == "kd-standard":
res_cube_abs[i, j, k], res_cube_rel[i, j, k] = kexp.run_Kd_standard(p)
elif method_list[k] == "kd-standard-localness":
res_cube_abs[i, j, k], res_cube_rel[i, j, k] = kexp.run_Kd_standard_localness(p)
elif method_list[k] == "kd-hybrid":
res_cube_abs[i, j, k], res_cube_rel[i, j, k] = kexp.run_Kd_hybrid(p)
elif method_list[k] == "kd-hybrid-localness":
res_cube_abs[i, j, k], res_cube_rel[i, j, k] = kexp.run_Kd_hybrid_localness(p)
else:
logging.error("No such index structure!")
sys.exit(1)
res_abs_summary = np.average(res_cube_abs, axis=1)
res_rel_summary = np.average(res_cube_rel, axis=1)
# np.savetxt(Params.resdir+exp_name+'_abs_'+`int(queryShape[0]*10)`+'_'+`int(queryShape[1]*10)`, res_abs_summary, fmt='%.4f\t')
np.savetxt(
Params.resdir + exp_name + "_rel_" + ` int(queryShape[0] * 10) ` + "_" + ` int(queryShape[1] * 10) `,
res_rel_summary,
fmt="%.4f\t",
)
def test_height(data, queryShape, all_queries):
heightList = [5, 6, 7, 8, 9]
method_list = ["grid-uniform", "kd-hybrid", "ht-hybrid", "kd-hybrid-localness"]
# ['grid-uniform','quad-geo','kd-hybrid','ht-composite','ht-hybrid','ht-hybrid-skew','quad-geo-localness','kd-hybrid-localness','ht-composite-localness','ht-hybrid-localness'];
res_cube_abs = np.zeros((len(heightList), len(seed_list), len(method_list)))
res_cube_rel = np.zeros((len(heightList), len(seed_list), len(method_list)))
for j in range(len(seed_list)):
queryList = all_queries[j]
kexp = GKExp(data, queryList)
p = Params(seed_list[j])
for i in range(len(heightList)):
Params.maxHeight = heightList[i]
Params.switchLevel = heightList[i] / 2
Params.maxSplit = [heightList[i], heightList[i]]
Params.switchLevelHTree = [heightList[i] / 2, heightList[i] / 2]
Params.partitions = [2 ** heightList[i], 2 ** heightList[i]]
Params.switchPartitions = [2 ** heightList[i] / 2, 2 ** heightList[i] / 2]
for k in range(len(method_list)):
if method_list[k] == "grid-uniform":
res_cube_abs[i, j, k], res_cube_rel[i, j, k] = kexp.run_Grid_uniform(p)
elif method_list[k] == "quad-geo":
res_cube_abs[i, j, k], res_cube_rel[i, j, k] = kexp.run_Quad_geo(p)
elif method_list[k] == "ht-standard":
res_cube_abs[i, j, k], res_cube_rel[i, j, k] = kexp.run_HT_standard(p)
elif method_list[k] == "kd-standard":
res_cube_abs[i, j, k], res_cube_rel[i, j, k] = kexp.run_Kd_standard(p)
elif method_list[k] == "kd-hybrid":
res_cube_abs[i, j, k], res_cube_rel[i, j, k] = kexp.run_Kd_hybrid(p)
elif method_list[k] == "ht-composite":
res_cube_abs[i, j, k], res_cube_rel[i, j, k] = kexp.run_HT_composite(p)
elif method_list[k] == "ht-hybrid":
res_cube_abs[i, j, k], res_cube_rel[i, j, k] = kexp.run_HT_hybrid(p)
elif method_list[k] == "ht-standard-skew":
res_cube_abs[i, j, k], res_cube_rel[i, j, k] = kexp.run_HT_standard_skew(p)
elif method_list[k] == "ht-hybrid-skew":
res_cube_abs[i, j, k], res_cube_rel[i, j, k] = kexp.run_HT_hybrid_skew(p)
elif method_list[k] == "quad-geo-localness":
res_cube_abs[i, j, k], res_cube_rel[i, j, k] = kexp.run_Quad_geo_localness(p)
elif method_list[k] == "kd-hybrid-localness":
res_cube_abs[i, j, k], res_cube_rel[i, j, k] = kexp.run_Kd_hybrid_localness(p)
elif method_list[k] == "ht-composite-localness":
res_cube_abs[i, j, k], res_cube_rel[i, j, k] = kexp.run_HT_composite_localness(p)
elif method_list[k] == "ht-hybrid-localness":
res_cube_abs[i, j, k], res_cube_rel[i, j, k] = kexp.run_HT_hybrid_localness(p)
else:
logging.error("No such index structure!")
sys.exit(1)
res_abs_summary = np.average(res_cube_abs, axis=1)
res_rel_summary = np.average(res_cube_rel, axis=1)
for str in ["abs", "rel"]:
summary = eval("res_" + str + "_summary")
outName = Params.resdir + "height_" + ` int(queryShape[0] * 10) ` + "_" + ` int(queryShape[1] * 10) ` + str
outFile = open(outName, "w")
outFile.write("#; " + "\t".join(method_list) + "\n")
for i in range(len(heightList)):
outFile.write(` heightList[i] `)
for j in range(len(method_list)):
outFile.write("\t" + ` summary[i, j] `)
outFile.write("\n")
outFile.close()
def test_height(data, queryShape, all_queries):
heightList = [5, 6, 7, 8, 9]
method_list = ['grid-uniform', 'kd-hybrid', 'ht-hybrid', 'kd-hybrid-localness']
#['grid-uniform','quad-geo','kd-hybrid','ht-composite','ht-hybrid','ht-hybrid-skew','quad-geo-localness','kd-hybrid-localness','ht-composite-localness','ht-hybrid-localness'];
res_cube_abs = np.zeros((len(heightList), len(seed_list), len(method_list)))
res_cube_rel = np.zeros((len(heightList), len(seed_list), len(method_list)))
for j in range(len(seed_list)):
queryList = all_queries[j]
kexp = GKExp(data, queryList)
p = Params(seed_list[j])
for i in range(len(heightList)):
Params.maxHeight = heightList[i]
Params.switchLevel = heightList[i] / 2
Params.maxSplit = [heightList[i], heightList[i]]
Params.switchLevelHTree = [heightList[i] / 2, heightList[i] / 2]
Params.partitions = [2 ** heightList[i], 2 ** heightList[i]]
Params.switchPartitions = [2 ** heightList[i] / 2, 2 ** heightList[i] / 2]
for k in range(len(method_list)):
if method_list[k] == 'grid-uniform':
res_cube_abs[i, j, k], res_cube_rel[i, j, k] = kexp.run_Grid_uniform(p)
elif method_list[k] == 'quad-geo':
res_cube_abs[i, j, k], res_cube_rel[i, j, k] = kexp.run_Quad_geo(p)
elif method_list[k] == 'ht-standard':
res_cube_abs[i, j, k], res_cube_rel[i, j, k] = kexp.run_HT_standard(p)
elif method_list[k] == 'kd-standard':
res_cube_abs[i, j, k], res_cube_rel[i, j, k] = kexp.run_Kd_standard(p)
elif method_list[k] == 'kd-hybrid':
res_cube_abs[i, j, k], res_cube_rel[i, j, k] = kexp.run_Kd_hybrid(p)
elif method_list[k] == 'ht-composite':
res_cube_abs[i, j, k], res_cube_rel[i, j, k] = kexp.run_HT_composite(p)
elif method_list[k] == 'ht-hybrid':
res_cube_abs[i, j, k], res_cube_rel[i, j, k] = kexp.run_HT_hybrid(p)
elif method_list[k] == 'ht-standard-skew':
res_cube_abs[i, j, k], res_cube_rel[i, j, k] = kexp.run_HT_standard_skew(p)
elif method_list[k] == 'ht-hybrid-skew':
res_cube_abs[i, j, k], res_cube_rel[i, j, k] = kexp.run_HT_hybrid_skew(p)
elif method_list[k] == 'quad-geo-localness':
res_cube_abs[i, j, k], res_cube_rel[i, j, k] = kexp.run_Quad_geo_localness(p)
elif method_list[k] == 'kd-hybrid-localness':
res_cube_abs[i, j, k], res_cube_rel[i, j, k] = kexp.run_Kd_hybrid_localness(p)
elif method_list[k] == 'ht-composite-localness':
res_cube_abs[i, j, k], res_cube_rel[i, j, k] = kexp.run_HT_composite_localness(p)
elif method_list[k] == 'ht-hybrid-localness':
res_cube_abs[i, j, k], res_cube_rel[i, j, k] = kexp.run_HT_hybrid_localness(p)
else:
logging.error('No such index structure!')
sys.exit(1)
res_abs_summary = np.average(res_cube_abs, axis=1)
res_rel_summary = np.average(res_cube_rel, axis=1)
for str in ['abs', 'rel']:
summary = eval('res_' + str + '_summary')
outName = Params.resdir + 'height_' + `int(queryShape[0] * 10)` + '_' + `int(queryShape[1] * 10)` + str
outFile = open(outName, 'w')
outFile.write('#; ' + '\t'.join(method_list) + '\n')
for i in range(len(heightList)):
outFile.write(`heightList[i]`)
for j in range(len(method_list)):
outFile.write('\t' + `summary[i, j]`)
outFile.write('\n')
outFile.close()
def test_htrees(data, queryShape, all_queries):
global method_list, exp_name
exp_name = 'htrees'
method_list = ['ht-standard']
# method_list = ['ht-standard','ht-composite']
#'ht-pure','ht-true','ht-standard','ht-composite','ht-hybrid','ht-hybrid-skew','ht-composite-localness','ht-hybrid-localness'
res_cube_abs = np.zeros((len(eps_list), len(seed_list), len(method_list)))
res_cube_rel = np.zeros((len(eps_list), len(seed_list), len(method_list)))
for j in range(len(seed_list)):
queryList = all_queries[j]
kexp = GKExp(data, queryList)
p = Params(seed_list[j])
for i in range(len(eps_list)):
p.Eps = eps_list[i]
for k in range(len(method_list)):
if method_list[k] == 'ht-pure':
res_cube_abs[i, j, k], res_cube_rel[i, j, k] = kexp.run_HT_pure(p)
elif method_list[k] == 'ht-true':
res_cube_abs[i, j, k], res_cube_rel[i, j, k] = kexp.run_HT_true(p)
elif method_list[k] == 'ht-standard':
res_cube_abs[i, j, k], res_cube_rel[i, j, k] = kexp.run_HT_standard(p)
elif method_list[k] == 'ht-composite':
res_cube_abs[i, j, k], res_cube_rel[i, j, k] = kexp.run_HT_composite(p)
elif method_list[k] == 'ht-composite-localness':
res_cube_abs[i, j, k], res_cube_rel[i, j, k] = kexp.run_HT_composite_localness(p)
elif method_list[k] == 'ht-hybrid':
res_cube_abs[i, j, k], res_cube_rel[i, j, k] = kexp.run_HT_hybrid(p)
elif method_list[k] == 'ht-standard-skew':
res_cube_abs[i, j, k], res_cube_rel[i, j, k] = kexp.run_HT_standard_skew(p)
elif method_list[k] == 'ht-hybrid-skew':
res_cube_abs[i, j, k], res_cube_rel[i, j, k] = kexp.run_HT_hybrid_skew(p)
elif method_list[k] == 'ht-standard-adaptive':
res_cube_abs[i, j, k], res_cube_rel[i, j, k] = kexp.run_HT_standard_adaptive(p)
elif method_list[k] == 'ht-hybrid-localness':
res_cube_abs[i, j, k], res_cube_rel[i, j, k] = kexp.run_HT_hybrid_localness(p)
else:
logging.error('No such index structure!')
sys.exit(1)
res_abs_summary = np.average(res_cube_abs, axis=1)
res_rel_summary = np.average(res_cube_rel, axis=1)
#np.savetxt(Params.resdir+exp_name+'_abs_'+`int(queryShape[0]*10)`+'_'+`int(queryShape[1]*10)`, res_abs_summary, fmt='%.4f\t')
np.savetxt(Params.resdir + exp_name + '_rel_' + `int(queryShape[0] * 10)` + '_' + `int(queryShape[1] * 10)`,
res_rel_summary, fmt='%.4f\t')
