def plot_input_and_hull_points(self, save, show, plot_img=False):
fig, ax = plot_utils.setup_figure_1ax(shrink_ax=False)
ax.scatter(self.input_points['x'], self.input_points['y'], s=2)
ax.scatter(self.hull_points['x'], self.hull_points['y'], s=10)
if plot_img:
image = cv2.imread(self.input_img_path)
ax.imshow(np.flipud(image), origin='lower', alpha=0.3)
plot_utils.show_and_or_save(save=save,
show=show,
save_file_path=self.save_path)
def plot_time_distributions(self, save=False, show=False, file_name=None):
fig, ax = plot_utils.setup_figure_1ax(size=(15, 9),
x_label='Run time [s]',
y_label='Density')
assert len(self.all_data_dict.keys()) == 1
run_times = self.all_data_dict['0']['run_times']
median = np.median(run_times)
# confidence intervals assuming gaussian distribution
'''
n = len(run_times)
se = scipy.stats.sem(run_times)
confidence = 0.95
h = se * scipy.stats.t.ppf((1+confidence)/2., n-1)
ci_1 = median-h
ci_2 = median+1
ax.errorbar(median, max(n) / 2., xerr=np.array([[ci_1, ci_2]]).T, linewidth=1, color='black', alpha=0.5, capsize=3, fmt='o')
'''
# quantile lines
q5 = np.percentile(run_times, 5)
q95 = np.percentile(run_times, 95)
weights = np.ones_like(run_times) / float(len(run_times))
n, bins, patches = ax.hist(run_times,
bins=2000,
facecolor='cyan',
alpha=0.75,
weights=weights)
ax.plot([q5, q5], [0.001, 0.15], linewidth=3, color='blue', alpha=0.5)
ax.plot([median, median], [0.001, 0.12],
linewidth=3,
color='red',
alpha=0.5)
ax.plot([q95, q95], [0.001, 0.09],
linewidth=3,
color='blue',
alpha=0.5)
# ax.set_xscale('log')
self.evaluate_save_show(save, show, file_name)
def plot_speedup_vs_cores(self, save=False, show=False, file_name=None):
"""
Plots the speedup vs number of cores for all algorithms in the run.
"""
if len(self.run_config['run_params']['n_points']) > 1 or len(self.run_config['run_params']['sub_size']) > 1 \
or len(self.run_config['run_params']['img_files']) > 1:
raise NotImplementedError(
"You can't do that. Only multiple numbers of cores and multiple algos."
)
fig, ax = plot_utils.setup_figure_1ax(size=(15, 9),
x_label='# cores',
y_label='Speedup')
# set up empty data container holding n cores, run times, speedup of max n cores
algo_t_core = {
algorithm: {
'n_cores': [],
'run_times': [],
'time_1core': 0.0,
'last_speedup': 0.0,
'errors': []
}
for algorithm in self.run_config['run_params']['algorithms']
}
# sorting wrt increasing n_cores
for _, data in self.all_data_dict.iteritems():
algo = data['algorithm']
algo_t_core[algo]['n_cores'].append(data['n_cores'])
algo_t_core[algo]['run_times'].append(data['median_run_times'])
algo_t_core[algo]['errors'].append(data['errors'])
if data['n_cores'] == 1:
algo_t_core[algo]['time_1core'] = data['median_run_times']
max_n_core = 1
last_speedups = []
for algorithm, algo_data in algo_t_core.iteritems():
n_cores, run_times = plot_utils.sort_two_lists_wrt_first(
algo_data['n_cores'], algo_data['run_times'])
speedups = [
algo_data['time_1core'] / run_times[n]
for n in range(len(run_times))
]
errors = algo_data['errors']
errors = [[err[0] for err in errors], [err[1] for err in errors]]
if max(n_cores) > max_n_core:
max_n_core = max(n_cores)
last_speedups.append(speedups[-1])
ax.plot(n_cores, speedups, linewidth=3, label=algorithm, alpha=0.5)
ax.plot(n_cores,
speedups,
'o',
linewidth=3,
alpha=0.3,
color='black',
markeredgecolor='none')
ax.errorbar(n_cores,
speedups,
yerr=errors,
fmt='none',
alpha=0.5,
color='black',
capsize=3)
print algorithm
ax.plot([1, max_n_core], [1.0, max_n_core],
'k--',
linewidth=1,
alpha=0.5,
label='linear speedup')
order = np.argsort(last_speedups)[::-1]
plot_utils.ordered_legend(ax, order)
self.evaluate_save_show(save, show, file_name)
def plot_shape_comparison(self, save=False, show=False, file_name=None):
"""
Plots the absolute runtime vs input size for all algorithms in the run.
For now, the runtimes are the median over all iterations for a run configuration.
"""
if len(self.run_config['run_params']['n_cores']) > 1 or len(self.run_config['run_params']['sub_size']) > 1 \
or len(self.run_config['run_params']['n_points']) > 1:
raise NotImplementedError(
"You can't do that. Only multiple input images and multiple algos allowed."
)
fig, ax = plot_utils.setup_figure_1ax(size=(13, 9),
y_label='Run time [s]')
# set up empty data container
algo_runtimes = {
algorithm: {
'input_imgs': [],
'run_times': [],
'errors': []
}
for algorithm in self.run_config['run_params']['algorithms']
}
for key, data in self.all_data_dict.iteritems():
algo_runtimes[data['algorithm']]['input_imgs'].append(data['img'])
algo_runtimes[data['algorithm']]['run_times'].append(
data['median_run_times'])
algo_runtimes[data['algorithm']]['errors'].append(data['errors'])
img_names = self.run_config['run_params']['img_files']
img_names = [img_name.split('.')[0] for img_name in img_names]
n_images = len(img_names)
ind_pos = np.arange(n_images)
width = 0.2
offset = {}
algo_idx = 0
for algorithm in algo_runtimes.keys():
offset[algorithm] = algo_idx * width
algo_idx += 1
# sort wrt to JARVIS algorithm
sort_indices = np.argsort(
np.array(algo_runtimes['jarvis']['run_times']))
for algorithm, algo_data in algo_runtimes.iteritems():
run_times = [algo_data['run_times'][i] for i in sort_indices]
img_names = [algo_data['input_imgs'][i] for i in sort_indices]
errors = [algo_data['errors'][i] for i in sort_indices]
errors = [[err[0] for err in errors], [err[1] for err in errors]]
print ''
print '{:10} {}'.format('--- algo: ', algorithm)
print '{:10} {}'.format('images: ', img_names)
print '{:10} {}'.format('times: ',
[round(t, 3) for t in run_times])
ax.bar(ind_pos + offset[algorithm],
run_times,
width,
label=algorithm,
alpha=0.7)
ax.errorbar(ind_pos + offset[algorithm],
run_times,
yerr=errors,
fmt='.',
capsize=3,
alpha=0.7)
ax.xaxis.set_ticks_position('none')
ax.set_xticks(np.arange(len(img_names)))
ax.set_xticklabels(img_names, rotation=45, ha="right")
ax.set_title("Input size: {n_points} points".format(
n_points=self.run_config['run_params']['n_points'][0]))
plt.xticks(ha='left')
ax.legend(loc='center left', bbox_to_anchor=(1, 0.5), frameon=False)
self.evaluate_save_show(save, show, file_name)
def plot_weak_scaling(self, save=False, show=False, file_name=None):
"""
Plots the speedup vs number of cores for all algorithms in the run.
"""
fig, ax = plot_utils.setup_figure_1ax(size=(15, 9),
x_label='# cores',
y_label='Speedup')
# set up empty data container holding n cores, run times, speedup of max n cores
algo_t_core = {
algorithm: {
'n_cores': [],
'run_times': [],
'time_1core': 0.0,
'last_speedup': 0.0,
'errors': [],
'n_points': 0
}
for algorithm in self.run_config['run_params']['algorithms']
}
# sorting wrt increasing n_cores
for _, data in self.all_data_dict.iteritems():
algo = data['algorithm']
algo_t_core[algo]['n_cores'].append(data['n_cores'])
algo_t_core[algo]['run_times'].append(data['median_run_times'])
algo_t_core[algo]['errors'].append(data['errors'])
algo_t_core[algo]['n_points'] = data['n_points']
if data['n_cores'] == 1:
algo_t_core[algo]['time_1core'] = data['median_run_times']
max_n_core = 1
last_speedups = []
for algorithm, algo_data in algo_t_core.iteritems():
n_cores, run_times = plot_utils.sort_two_lists_wrt_first(
algo_data['n_cores'], algo_data['run_times'])
n_points = algo_data['n_points']
is_weak_scale_combo = (n_points / np.array(n_cores)) == 50000
speedups = [
algo_data['time_1core'] / run_times[n]
for n in range(len(run_times)) if is_weak_scale_combo[n]
]
errors = algo_data['errors']
errors = [[err[0] for err in errors], [err[1] for err in errors]]
if max(n_cores) > max_n_core:
max_n_core = max(n_cores)
last_speedups.append(speedups[-1])
cores_set = list(set(n_cores))
efficiency = [
speedups[i] / cores_set[i] for i in range(len(speedups))
]
ax.plot(cores_set,
efficiency,
linewidth=3,
label=algorithm,
alpha=0.5)
ax.plot(cores_set,
efficiency,
'o',
linewidth=3,
alpha=0.3,
color='black',
markeredgecolor='none')
# ax.errorbar(cores_set, efficiency, yerr=errors, fmt='none', alpha=0.5, color='black', capsize=3)
print algorithm
ax.plot([1, max_n_core], [1.0, 1.0],
'k--',
linewidth=1,
alpha=0.5,
label='efficiency')
order = np.argsort(last_speedups)[::-1]
plot_utils.ordered_legend(ax, order)
self.evaluate_save_show(save, show, file_name)
def plot_runtimes_comparison(self, save=False, show=False, file_name=None):
"""
Plots the absolute runtime vs input size for all algorithms in the run.
For now, the runtimes are the median over all iterations for a run configuration.
"""
if len(self.run_config['run_params']['n_cores']) > 1 or len(self.run_config['run_params']['sub_size']) > 1 \
or len(self.run_config['run_params']['img_files']) > 1:
raise NotImplementedError(
"You can't do that. Only multiple input sizes and multiple algos."
)
fig, ax = plot_utils.setup_figure_1ax(
size=(13, 9),
x_label='Input size [number of points]',
y_label='Run time [s]')
# set up empty data container
algo_runtimes = {
algorithm: {
'input_sizes': [],
'run_times': [],
'errors': []
}
for algorithm in self.run_config['run_params']['algorithms']
}
for key, data in self.all_data_dict.iteritems():
algo_runtimes[data['algorithm']]['input_sizes'].append(
data['n_points'])
algo_runtimes[data['algorithm']]['run_times'].append(
data['median_run_times'])
algo_runtimes[data['algorithm']]['errors'].append(data['errors'])
last_runtimes = []
for algorithm, algo_data in algo_runtimes.iteritems():
sort_indices = np.argsort(np.array(algo_data['input_sizes']))
input_sizes = [algo_data['input_sizes'][i] for i in sort_indices]
run_times = [algo_data['run_times'][i] for i in sort_indices]
errors = [algo_data['errors'][i] for i in sort_indices]
errors = [[err[0] for err in errors], [err[1] for err in errors]]
last_runtimes.append(run_times[-1])
ax.plot(input_sizes,
run_times,
linewidth=3,
label=algorithm,
alpha=0.5)
ax.errorbar(input_sizes,
run_times,
yerr=errors,
fmt='none',
alpha=0.5,
color='black',
capsize=3)
# ax.plot(input_sizes, run_times, 'o', linewidth=3, alpha=0.3, color='black', markeredgecolor='none')
ax.legend(loc='center left', bbox_to_anchor=(1, 0.5), frameon=False)
order = np.argsort(last_runtimes)[::-1]
plot_utils.ordered_legend(ax, order)
self.evaluate_save_show(save, show, file_name)