def generateGraph_for_all_simplified(valueList,xlabel, ylabel, benchmark_name, ax, fig, graph_title="pareto comparison for", name = "various_inputs", post_pone_saving_graph = False, use_prev_ax_fig = False, n_graphs="one", valueList_promised=[]): name_counter = 0 #fig = plt.figure(figsize=plt.figaspect(0.5)) #--- sanity check if not(use_prev_ax_fig): fig, ax = plt.subplots() plt.autoscale(enable=True, axis='both', tight=True) """ if (graph_type == "Q_E_product"): plt.ylabel("Q_E_product") plt.xlabel("mean") else: #plt.xscale('log') plt.xlabel("mean") plt.ylabel("Energy") # plt.ylabel(yName) # plt.xlabel(xName) """ #here #----comment if not proving th s4 pont symbolsToChooseFrom = ['*', 'x', "o", "+","^", '1', '2', "3"] color =['g', 'y', 'r', 'm'] quality_list_sorted_based_on_z, std_list_sorted_based_on_z, energy_list_sorted_based_on_z = sort_values(valueList) quality_list_promised_sorted_based_on_z, std_list_promised_sorted_based_on_z, energy_list_promised_sorted_based_on_z = sort_values(valueList_promised) """ lOf_run_input_list = input_list.lOf_run_input_list number_of_inputs_used = len(lOf_run_input_list) input_results = map(list, [[]]*number_of_inputs_used) base_dir = "/home/local/bulkhead/behzad/usr/local/apx_tool_chain/inputPics/" counter = 0 energy_list_to_be_drawn = [] setup_list_to_be_drawn = [] quality_list_to_be_drawn = [] std_list_to_be_drawn = [] image_list_to_be_drawn = [] z_vals = [] for val in valueList: input_results = map(list, [[]]*number_of_inputs_used) zipped = zip(*val[:-1]) for el in zipped: input_results[el[2]].append(el) for index,res in enumerate(input_results): print counter if len(res) > 0: image_addr = base_dir+lOf_run_input_list[index][0] + ".ppm" mR, mG, mB, stdR, stdG, stdB = cluster_images.calc_image_mean_std(image_addr) if (int(np.mean([mR,mG,mB]))) in z_vals: continue el = map(lambda x: list(x), zip(*res)) quality_values_shifted = map(lambda x: x+1, el[0]) print "mean of image : " + (lOf_run_input_list[index][0]) + " is: " + str(np.mean([mR,mG,mB])) #--- sort based on the quality Q = quality_values_shifted E = el[1] SetUps = el[2] E_index_sorted = sorted(enumerate(E), key=lambda x: x[1]) index_of_E_sorted = map(lambda y: y[0], E_index_sorted) Q_sorted = [Q[i] for i in index_of_E_sorted] E_sorted = [E[i] for i in index_of_E_sorted] SetUp_sorted = [SetUps[i] for i in index_of_E_sorted] quality_list_to_be_drawn.append(Q_sorted) energy_list_to_be_drawn.append(E_sorted) setup_list_to_be_drawn.append(SetUp_sorted) std_list_to_be_drawn.append([int(np.mean([mR,mG,mB]))]*len(E_sorted)) image_list_to_be_drawn.append([lOf_run_input_list[index][0]]*len(E_sorted)) z_vals.append( int(np.mean([mR,mG,mB]))) counter +=1 reminder(True,"the following lines which creates a new image every len(symbolsToChooseFrom) should be commented if we use any flag but various_inputs") #--sorting the data. This is necessary for wire frame zvals_index_sorted = sorted(enumerate(z_vals), key=lambda x: x[1]) index_of_zvals_sorted = map(lambda y: y[0], zvals_index_sorted) quality_list_sorted_based_on_z = [quality_list_to_be_drawn[i] for i in index_of_zvals_sorted] std_list_sorted_based_on_z = [std_list_to_be_drawn[i] for i in index_of_zvals_sorted] energy_list_sorted_based_on_z = [energy_list_to_be_drawn[i] for i in index_of_zvals_sorted] image_list_sorted_based_on_z = [image_list_to_be_drawn[i] for i in index_of_zvals_sorted] SetUp_list_sorted_based_on_z = [setup_list_to_be_drawn[i] for i in index_of_zvals_sorted] print quality_list_sorted_based_on_z print std_list_sorted_based_on_z print energy_list_sorted_based_on_z """ if (post_pone_saving_graph): line_style = ':' else: line_style = '-' #--- generate a spectrum of colors #colors = ['b', 'g'] plt.xscale('log') if (name == "same_Q_vs_input"): plt.xlabel("mean") plt.ylabel("Energy") Qs, Es, stds, QSs = adjust.adjust_vals_2(quality_list_sorted_based_on_z, energy_list_sorted_based_on_z, std_list_sorted_based_on_z) second_axis = Es; third_axis = QSs; third_axis_name = "quality" #---limiting #third_axis= QSs[:10] n_lines = len(third_axis) colors = gen_color_spec.gen_color(max(n_lines,2), 'seismic') #---limiting #--- printing the the Qstates (Q attempted) and the Q found for input_index in range(len(Qs)): print "true Qs for input with mean:" + str(stds[input_index]) + "is:" for x in range(len(third_axis)): print "Q state:" + str(third_axis[x]) + " found Q:" + str(Qs[input_index][x]) + "En is: " + str(Es[input_index][x]) for x in range(len(third_axis)): my_label = third_axis_name +": " + str(float(third_axis[x])) second_axis_as_w_diff_mean = map(lambda y: y[x], second_axis) l_mean = map(lambda y: y[x], stds) ax.plot(l_mean, second_axis_as_w_diff_mean, marker = symbolsToChooseFrom[x%len(symbolsToChooseFrom)], c= colors[x], label=my_label, linestyle=line_style) #finish_up_making_graph(ax, graph_title, graph_title, benchmark_name, 0) elif (name == "same_E_vs_input"): plt.xlabel("mean") plt.ylabel("quality") sys.stdout.flush() third_axis= energy_list_sorted_based_on_z[0]; third_axis_name = "energy" second_axis = quality_list_sorted_based_on_z; n_lines = len(third_axis) colors = gen_color_spec.gen_color(n_lines, 'seismic') for x in range(len(third_axis)): #--- limiting # if x > 10: # break; my_label = third_axis_name +": " + str(float(third_axis[x])) second_axis_as_w_diff_mean = map(lambda y: y[x], second_axis) l_mean = map(lambda y: y[x], std_list_sorted_based_on_z) print "asdf" + str(second_axis_as_w_diff_mean ) ax.plot(l_mean, second_axis_as_w_diff_mean, marker = symbolsToChooseFrom[x%len(symbolsToChooseFrom)], c= colors[x], label=my_label, linestyle=line_style) #finish_up_making_graph(ax, graph_title, graph_title, benchmark_name, 0) elif(name == "E_vs_Q_adjusted"): plt.xlabel("Quality") plt.ylabel("Energy") Qs, Es, stds, QSs = adjust.adjust_vals_2(quality_list_sorted_based_on_z, energy_list_sorted_based_on_z, std_list_sorted_based_on_z) second_axis = Es; third_axis = std_list_sorted_based_on_z; third_axis_name = "input" n_lines = len(std_list_sorted_based_on_z) colors = gen_color_spec.gen_color(n_lines, 'seismic') for x in range(len(third_axis)): my_label = third_axis_name +": " + str(float(third_axis[x][0])) #if (third_axis[x][0] == 97): ax.plot(QSs, Es[x], marker = symbolsToChooseFrom[x%len(symbolsToChooseFrom)], c= colors[x], label=my_label, linestyle=line_style) elif (name == "E_vs_Q"): #---line_style = '' uncomment for all_points plt.xlabel("Quality") plt.ylabel("Energy") third_axis = std_list_sorted_based_on_z; third_axis_name = "input" n_lines = len(std_list_sorted_based_on_z) colors = gen_color_spec.gen_color(n_lines, 'seismic') if (graph_title == "E_vs_Q_all_points"): line_style = "None" #for no lines for x in range(len(third_axis)): my_label = third_axis_name +": " + str(float(third_axis[x][0])) ax.plot(quality_list_sorted_based_on_z[x], energy_list_sorted_based_on_z[x], marker = symbolsToChooseFrom[x%len(symbolsToChooseFrom)], c= colors[x], label=my_label, linestyle=line_style) if (graph_title == "E_vs_Q_all_points"): #.n the counter would be an incremented version of the input #value n. finish_up_making_graph(ax, graph_title, graph_title, benchmark_name, x+1) fig, ax = plt.subplots() plt.xscale('log') plt.xlabel("Quality") plt.ylabel("Energy") elif (name == "Qstd_vs_E_imposed"): plt.ylabel("Quality_std") plt.xlabel("Energy") n_lines = 1 colors = gen_color_spec.gen_color(n_lines, 'seismic') my_label = "nolabel" Q_diff = [] for E_index in range(len(energy_list_sorted_based_on_z[0])): all_Qs_as_w_index = map(lambda x: x[E_index], quality_list_sorted_based_on_z) Q_diff.append(numpy.std(all_Qs_as_w_index)) ax.plot(energy_list_sorted_based_on_z[0], Q_diff, marker = symbolsToChooseFrom[0%len(symbolsToChooseFrom)], c= colors[0], label=my_label, linestyle=line_style) elif (name == "Qmean_normalized_to_Q_promissed"): plt.ylabel("Quality_mean_normalized_to_Q_promised") plt.xlabel("Energy") n_lines = 1 colors = gen_color_spec.gen_color(max(n_lines,2), 'seismic') Q_diff_1 = [] Q_diff_2 = [] for E_index in range(len(energy_list_sorted_based_on_z[0])): all_Qs_as_w_index = map(lambda x: x[E_index], quality_list_sorted_based_on_z) print "all_Qs" + str(all_Qs_as_w_index) Q_diff_1.append(numpy.mean(all_Qs_as_w_index)) print "quality_promiseed" + str(quality_list_promised_sorted_based_on_z[0]) imposed_vs_got_diff = map(operator.sub, [quality_list_promised_sorted_based_on_z[0][E_index]]*len(all_Qs_as_w_index), all_Qs_as_w_index) Q_diff_2.append(numpy.mean(imposed_vs_got_diff)) print "Q_diff_2)" + str(Q_diff_2) #ax.plot(energy_list_sorted_based_on_z[0], Q_diff_1, marker = symbolsToChooseFrom[0%len(symbolsToChooseFrom)], c= colors[0], label="Q_mean", linestyle=line_style) ax.plot(energy_list_sorted_based_on_z[0], Q_diff_2, marker = symbolsToChooseFrom[0%len(symbolsToChooseFrom)], c= colors[1], label="Q_mean_"+"normalized", linestyle=line_style) elif (name == "Q_satisfaction_success_rate"): plt.ylabel("Q_satisfaction_success_rate") plt.xlabel("Energy") n_lines = 1 colors = gen_color_spec.gen_color(max(n_lines,2), 'seismic') my_label = "nolabel" Q_diff_2 = [] for E_index in range(len(energy_list_sorted_based_on_z[0])): all_Qs_as_w_index = map(lambda x: x[E_index], quality_list_sorted_based_on_z) imposed_vs_got_diff = map(operator.sub, all_Qs_as_w_index, [quality_list_promised_sorted_based_on_z[0][E_index]]*len(all_Qs_as_w_index)) print "sub_is2" + str(imposed_vs_got_diff) success_rate = float(len(filter(lambda x: x >= 000, imposed_vs_got_diff)))/float(len(imposed_vs_got_diff)) Q_diff_2.append(success_rate) ax.get_yaxis().get_major_formatter().set_useOffset(False) ax.plot(energy_list_sorted_based_on_z[0], Q_diff_2, marker = symbolsToChooseFrom[0%len(symbolsToChooseFrom)], c= colors[1], label="Q_satisfaction_success_rate", linestyle=line_style) else: print "this name : " + name + " is not defined" sys.exit() if not(post_pone_saving_graph): finish_up_making_graph(ax, graph_title, graph_title, benchmark_name, 0) return ax, fig
def compare_adjusted(points_collected, points_collected_imposed): fig, ax = plt.subplots() symbolsToChooseFrom = ['*', 'x', "o", "+","^", '1', '2', "3"] color =['g', 'y', 'r', 'm'] """ limit = False lower_bound = -100 upper_bound = .001 get_quality_energy_values("various_inputs.PIK", "+", points_collected, limit, lower_bound, upper_bound) """ lOf_run_input_list = input_list.lOf_run_input_list number_of_inputs_used = len(lOf_run_input_list) input_results = map(list, [[]]*number_of_inputs_used) base_dir = "/home/local/bulkhead/behzad/usr/local/apx_tool_chain/inputPics/" counter = 0 energy_list_to_be_drawn = [] setup_list_to_be_drawn = [] quality_list_to_be_drawn = [] std_list_to_be_drawn = [] image_list_to_be_drawn = [] z_vals = [] mR =0 mG =0 mB =0 for val in points_collected: input_results = map(list, [[]]*number_of_inputs_used) zipped = zip(*val[:-1]) for el in zipped: input_results[el[2]].append(el) for index,res in enumerate(input_results): """ if (counter > 50 ): break """ print counter if len(res) > 0: image_addr = base_dir+lOf_run_input_list[index][0] + ".ppm" #mR, mG, mB, stdR, stdG, stdB = cluster_images.calc_image_mean_std(image_addr) mR +=1 mG +=1 mB +=1 stdB = 0 stdR = 0 stdG = 0 if (int(np.mean([mR,mG,mB]))) in z_vals: continue el = map(lambda x: list(x), zip(*res)) quality_values_shifted = map(lambda x: x+1, el[0]) #--- sort based on the quality Q = quality_values_shifted E = el[1] SetUps = el[2] E_index_sorted = sorted(enumerate(E), key=lambda x: x[1]) index_of_E_sorted = map(lambda y: y[0], E_index_sorted) Q_sorted = [Q[i] for i in index_of_E_sorted] E_sorted = [E[i] for i in index_of_E_sorted] SetUp_sorted = [SetUps[i] for i in index_of_E_sorted] quality_list_to_be_drawn.append(Q_sorted) energy_list_to_be_drawn.append(E_sorted) setup_list_to_be_drawn.append(SetUp_sorted) std_list_to_be_drawn.append([int(np.mean([mR,mG,mB]))]*len(E_sorted)) image_list_to_be_drawn.append([lOf_run_input_list[index][0]]*len(E_sorted)) z_vals.append( int(np.mean([mR,mG,mB]))) counter +=1 reminder(True,"the following lines which creates a new image every len(symbolsToChooseFrom) should be commented if we use any flag but various_inputs") #--sorting the data. This is necessary for wire frame zvals_index_sorted = sorted(enumerate(z_vals), key=lambda x: x[1]) index_of_zvals_sorted = map(lambda y: y[0], zvals_index_sorted) quality_list_sorted_based_on_z = [quality_list_to_be_drawn[i] for i in index_of_zvals_sorted] std_list_sorted_based_on_z = [std_list_to_be_drawn[i] for i in index_of_zvals_sorted] energy_list_sorted_based_on_z = [energy_list_to_be_drawn[i] for i in index_of_zvals_sorted] image_list_sorted_based_on_z = [image_list_to_be_drawn[i] for i in index_of_zvals_sorted] SetUp_list_sorted_based_on_z = [setup_list_to_be_drawn[i] for i in index_of_zvals_sorted] Qs_ref, Es_ref, stds_ref, QSs_ref = adjust.adjust_vals_2(quality_list_sorted_based_on_z, energy_list_sorted_based_on_z, std_list_sorted_based_on_z) lOf_run_input_list = input_list.lOf_run_input_list number_of_inputs_used = len(lOf_run_input_list) input_results = map(list, [[]]*number_of_inputs_used) base_dir = "/home/local/bulkhead/behzad/usr/local/apx_tool_chain/inputPics/" counter = 0 energy_list_to_be_drawn = [] setup_list_to_be_drawn = [] quality_list_to_be_drawn = [] std_list_to_be_drawn = [] image_list_to_be_drawn = [] z_vals = [] mR =0 mG =0 mB =0 for val in points_collected_imposed: input_results = map(list, [[]]*number_of_inputs_used) zipped = zip(*val[:-1]) for el in zipped: input_results[el[2]].append(el) for index,res in enumerate(input_results): """ if (counter > 50 ): break """ print counter if len(res) > 0: mR +=1 mG +=1 mB +=1 stdB = 0 stdR = 0 stdG = 0 image_addr = base_dir+lOf_run_input_list[index][0] + ".ppm" #mR, mG, mB, stdR, stdG, stdB = cluster_images.calc_image_mean_std(image_addr) if (int(np.mean([mR,mG,mB]))) in z_vals: continue el = map(lambda x: list(x), zip(*res)) quality_values_shifted = map(lambda x: x+1, el[0]) #--- sort based on the quality Q = quality_values_shifted E = el[1] SetUps = el[2] E_index_sorted = sorted(enumerate(E), key=lambda x: x[1]) index_of_E_sorted = map(lambda y: y[0], E_index_sorted) Q_sorted = [Q[i] for i in index_of_E_sorted] E_sorted = [E[i] for i in index_of_E_sorted] SetUp_sorted = [SetUps[i] for i in index_of_E_sorted] quality_list_to_be_drawn.append(Q_sorted) energy_list_to_be_drawn.append(E_sorted) setup_list_to_be_drawn.append(SetUp_sorted) std_list_to_be_drawn.append([int(np.mean([mR,mG,mB]))]*len(E_sorted)) image_list_to_be_drawn.append([lOf_run_input_list[index][0]]*len(E_sorted)) z_vals.append( int(np.mean([mR,mG,mB]))) counter +=1 reminder(True,"the following lines which creates a new image every len(symbolsToChooseFrom) should be commented if we use any flag but various_inputs") #--sorting the data. This is necessary for wire frame zvals_index_sorted = sorted(enumerate(z_vals), key=lambda x: x[1]) index_of_zvals_sorted = map(lambda y: y[0], zvals_index_sorted) quality_list_sorted_based_on_z = [quality_list_to_be_drawn[i] for i in index_of_zvals_sorted] std_list_sorted_based_on_z = [std_list_to_be_drawn[i] for i in index_of_zvals_sorted] energy_list_sorted_based_on_z = [energy_list_to_be_drawn[i] for i in index_of_zvals_sorted] image_list_sorted_based_on_z = [image_list_to_be_drawn[i] for i in index_of_zvals_sorted] SetUp_list_sorted_based_on_z = [setup_list_to_be_drawn[i] for i in index_of_zvals_sorted] Qs_imposed, Es_imposed, stds_imposed, QSs_imposed = adjust.adjust_vals_2(quality_list_sorted_based_on_z, energy_list_sorted_based_on_z, std_list_sorted_based_on_z) Es_diff = [] for input_index in range(len(Es_imposed)): # Es_diff_el = [] # for el in range(len(Es_imposed[input_index])): # Es_diff_el.append(Es_imposed[input_index][el] - Es_ref[input_index][el]) #Es_diff.append(Es_diff_el) Es_diff.append(map(operator.sub, Es_imposed[input_index], Es_ref[input_index])) line_style = '-' plt.xlabel("Quality") plt.ylabel("Energy") second_axis = Es_diff; third_axis = std_list_sorted_based_on_z; third_axis_name = "input" n_lines = len(std_list_sorted_based_on_z) colors = gen_color_spec.gen_color(n_lines+1, 'seismic') for x in range(len(third_axis)): my_label = third_axis_name +": " + str(int(third_axis[x][0])) #if (int(third_axis[x][0]) == 151): ax.plot(QSs_imposed, Es_diff[x], marker = symbolsToChooseFrom[x%len(symbolsToChooseFrom)], c= colors[x], label=my_label, linestyle=line_style) # # box = ax.get_position() ax.set_position([box.x0, box.y0, box.width*.8 , box.height]) # Put a legend to the right of the current axis (note: prop changes the fontsize) ax.legend(loc='center left', bbox_to_anchor=(1, .9), prop={'size':6}) graph_title = "Ediff_vs_Q" name = graph_title benchmark_name = "jpeg" plt.title(graph_title + str(benchmark_name) + " benchmark") pylab.savefig(name+str(counter)+".png") #saving the figure generated by generateGraph Es_diff_avg_per_quality = [] for x in range(len(QSs_imposed)): Es_diff_avg_per_quality.append(numpy.mean(map(lambda y: y[x], Es_diff))) #if (int(third_axis[x][0]) == 151): my_label = "AVG" ax.plot(QSs_imposed, Es_diff_avg_per_quality, marker = symbolsToChooseFrom[x%len(symbolsToChooseFrom)], c= colors[n_lines], label=my_label, linestyle=line_style) box = ax.get_position() ax.set_position([box.x0, box.y0, box.width*.8 , box.height]) # Put a legend to the right of the current axis (note: prop changes the fontsize) ax.legend(loc='center left', bbox_to_anchor=(1, .9), prop={'size':6}) graph_title = "Ediff_avg_vs_Q" name = graph_title benchmark_name = "jpeg" plt.title(graph_title + str(benchmark_name) + " benchmark") pylab.savefig(name+str(counter)+".png") #saving the figure generated by generateGraph #plt.close() fig, ax = plt.subplots() print "avg of ES_diff" + str(numpy.mean(map(lambda x: numpy.mean(x), Es_diff))) """