def get_plot_data(self, path, sort_by='eta'):
"""
:param sort_by: 'noise_factor' or 'long_range_prob'
"""
# TODO: use experiment path
# Create dictionary:
results_collected = {}
for item in os.listdir(path):
if os.path.isfile(os.path.join(path, item)):
filename = item
if not filename.endswith(".json") or filename.startswith("."):
continue
# ID, sample, agglo_type, _ = filename.split("_")
result_file = os.path.join(path, filename)
with open(result_file, 'rb') as f:
file_dict = json.load(f)
if sort_by == 'eta':
sort_key = file_dict["eta"]
else:
raise ValueError
method = file_dict["method_type"]
if method == "GASP":
method_descriptor = file_dict["linkage_criteria"] + str(
file_dict["add_cannot_link_constraints"])
elif method == "spectral":
method_descriptor = file_dict["spectral_method_name"]
elif method == "multicut":
method_descriptor = file_dict["multicut_solver_type"]
else:
raise ValueError
new_results = {}
new_results[method] = {}
new_results[method][method_descriptor] = {}
new_results[method][method_descriptor][sort_key] = {}
new_results[method][method_descriptor][sort_key][
file_dict["ID"]] = file_dict
try:
results_collected = recursive_dict_update(
new_results, results_collected)
except KeyError:
continue
return results_collected
def build_val_loader(self):
scaling_factors = self.get("stack_scaling_factors_2")
kwargs = recursive_dict_update(self.get('loaders/val'),
deepcopy(self.get('loaders/general')))
kwargs["volume_config"]["scaling_factors"] = scaling_factors
return get_cremi_loader(kwargs)
result_dict = json.load(f)
edge_prob = result_dict["edge_prob"]
non_link = result_dict["non_link"]
new_results = {}
new_results[agglo_type] = {}
new_results[agglo_type][str(non_link)] = {}
new_results[agglo_type][str(non_link)][edge_prob] = {}
new_results[agglo_type][str(non_link)][edge_prob][ID] = {
'energy': result_dict["energy"],
'score': result_dict["score"],
'score_WS': result_dict["score_WS"],
'runtime': result_dict["runtime"]
}
results_collected = recursive_dict_update(new_results,
results_collected)
ncols, nrows = 1, 1
f, ax = plt.subplots(ncols=ncols, nrows=nrows, figsize=(7, 7))
for agglo_type in results_collected:
if agglo_type != "max":
continue
for non_link in results_collected[agglo_type]:
sub_dict = results_collected[agglo_type][non_link]
probs = []
values = []
error_bars = []
for edge_prob in sub_dict:
multiple_values = []
for ID in sub_dict[edge_prob]:
def build_val_loader(self):
return get_cremi_loader(recursive_dict_update(self.get('loaders/val'), self.get('loaders/general')))
def build_val_loader(self):
kwargs = recursive_dict_update(self.get('loaders/val'),
deepcopy(self.get('loaders/general')))
return get_cremi_loader(kwargs)
def build_train_loader(self):
return get_cremi_loader(
recursive_dict_update(self.get('loaders/train'),
deepcopy(self.get('loaders/general'))))
def get_segmentation(inverted_affinities, offsets, post_proc_config):
n_threads = post_proc_config.pop('nb_threads')
invert_affinities = post_proc_config.pop('invert_affinities', False)
segm_pipeline_type = post_proc_config.pop('segm_pipeline_type', 'gen_HC')
segmentation_pipeline = get_segmentation_pipeline(
segm_pipeline_type,
offsets,
nb_threads=n_threads,
invert_affinities=invert_affinities,
return_fragments=False,
**post_proc_config)
if post_proc_config.get('use_final_agglomerater', False):
final_agglomerater = GreedyEdgeContractionAgglomeraterFromSuperpixels(
offsets,
n_threads=n_threads,
invert_affinities=invert_affinities,
**post_proc_config['generalized_HC_kwargs']
['final_agglomeration_kwargs'])
else:
final_agglomerater = None
post_proc_solver = BlockWise(
segmentation_pipeline=segmentation_pipeline,
offsets=offsets,
final_agglomerater=final_agglomerater,
blockwise=post_proc_config.get('blockwise', False),
invert_affinities=invert_affinities,
nb_threads=n_threads,
return_fragments=False,
blockwise_config=post_proc_config.get('blockwise_kwargs', {}))
print("Starting prediction...")
tick = time.time()
outputs = post_proc_solver(affinities)
comp_time = time.time() - tick
print("Post-processing took {} s".format(comp_time))
return outputs
# print("Pred. sahpe: ", pred_segm.shape)
# if not use_test_datasets:
# print("GT shape: ", gt.shape)
# print("Min. GT label: ", gt.min())
# if post_proc_config.get('stacking_2D', False):
# print('2D stacking...')
# stacked_pred_segm = np.empty_like(pred_segm)
# max_label = 0
# for z in range(pred_segm.shape[0]):
# slc = vigra.analysis.labelImage(pred_segm[z].astype(np.uint32))
# stacked_pred_segm[z] = slc + max_label
# max_label += slc.max() + 1
# pred_segm = stacked_pred_segm
# pred_segm_WS = None
# if post_proc_config.get('thresh_segm_size', 0) != 0:
grow = SizeThreshAndGrowWithWS(
post_proc_config['thresh_segm_size'],
offsets,
hmap_kwargs=post_proc_config['prob_map_kwargs'],
apply_WS_growing=True,
)
pred_segm_WS = grow(1 - inverted_affinities, pred_segm)
# SAVING RESULTS:
evals = cremi_score(gt,
pred_segm,
border_threshold=None,
return_all_scores=True)
evals_WS = cremi_score(gt,
pred_segm_WS,
border_threshold=None,
return_all_scores=True)
print("Scores achieved WS: ", evals_WS)
print("Scores achieved: ", evals)
ID = str(np.random.randint(10000000))
extra_agglo = post_proc_config['generalized_HC_kwargs'][
'agglomeration_kwargs']['extra_aggl_kwargs']
agglo_type = extra_agglo['update_rule']
non_link = extra_agglo['add_cannot_link_constraints']
edge_prob = str(
np.asscalar(post_proc_config['generalized_HC_kwargs']
['probability_long_range_edges']))
result_file = os.path.join(
'/home/abailoni_local/',
'generalized_GED_comparison_local_attraction.json')
# result_dict = yaml2dict(result_file)
# result_dict = {} if result_dict is None else result_dict
if os.path.exists(result_file):
with open(result_file, 'rb') as f:
result_dict = json.load(f)
os.remove(result_file)
else:
result_dict = {}
new_results = {}
new_results[agglo_type] = {}
new_results[agglo_type][str(non_link)] = {}
new_results[agglo_type][str(non_link)][edge_prob] = {}
new_results[agglo_type][str(non_link)][edge_prob][ID] = {
'energy': np.asscalar(MC_energy),
'score': evals,
'score_WS': evals_WS,
'runtime': comp_time
}
file_name = "{}_{}_{}".format(ID, agglo_type, edge_prob)
# file_path = os.path.join('/net/hciserver03/storage/abailoni/GEC_comparison', file_name)
file_path = os.path.join(
'/home/abailoni_local/GEC_comparison_local_attraction', file_name)
result_dict = recursive_dict_update(new_results, result_dict)
with open(result_file, 'w') as f:
json.dump(result_dict, f, indent=4, sort_keys=True)
# yaml.dump(result_dict, f)
# Save some kwargs:
vigra.writeHDF5(pred_segm.astype('uint32'), file_path, 'segm')
vigra.writeHDF5(pred_segm_WS.astype('uint32'), file_path, 'segm_WS')
def build_val_loader(self):
kwargs = recursive_dict_update(self.get('loaders/val'), deepcopy(self.get('loaders/general')))
datasets = MultiScaleDataset.from_config(kwargs)
return DataLoader(datasets, **kwargs.get("loader_config", {}))
