def after_epoch(self, epoch):
self.data = {"inputs": self.inputs, "outputs": self.outputs}
out_path = os.path.join(self.root, "data.p")
with open(out_path, "wb") as f:
pickle.dump(self.data, f)
print("Wrote retrieval matrix data in:")
print(out_path)
for k, o in self.outputs.items():
i_out = 0
for i, im_batch in enumerate(o):
if len(im_batch.shape) == 3:
im_batch = np.expand_dims(im_batch, axis=-1)
for im in np.split(im_batch, len(im_batch), 0):
out_path = os.path.join(self.root,
"{}_{:07d}.png".format(k, i_out))
plot_batch(im, out_path)
i_out += 1
for k, o in self.inputs.items():
i_out = 0
for i, im_batch in enumerate(o):
if len(im_batch.shape) == 3:
im_batch = np.expand_dims(im_batch, axis=-1)
for im in np.split(im_batch, len(im_batch), 0):
out_path = os.path.join(self.root,
"{}_{:07d}.png".format(k, i_out))
plot_batch(im, out_path)
i_out += 1
def after_step(self, batch_index, last_results):
if batch_index % self.interval == 0:
step = last_results["global_step"]
# TODO: fix hard-coded font type
# TODO: add option to log overview to tensorboard
batches = []
try:
fnt = ImageFont.truetype("LiberationMono-Regular.ttf", 20)
except OSError:
fnt = ImageFont.load_default()
last_results = last_results["logging"]
for name, im in sorted(last_results["images"].items()):
canvas = batch_to_canvas(im)
canvas = (canvas + 1.0) / 2.0
canvas = np.clip(255 * canvas, 0, 255)
canvas = np.array(canvas, dtype="uint8")
im = Image.fromarray(canvas)
im.thumbnail((512, 512), Image.ANTIALIAS)
d = ImageDraw.Draw(im)
d.text((10, 10), name, fill=(255, 0, 0), font=fnt)
batches.append(im)
im = Image.new("RGB", batches[0].size, color=(0, 0, 0))
try:
fnt = ImageFont.truetype("LiberationMono-Regular.ttf", 50)
except OSError:
fnt = ImageFont.load_default()
d = ImageDraw.Draw(im)
d.text((10, 10), "epoch\n{:07d}".format(step), fill=(255, 0, 0), font=fnt)
batches.append(im)
batch = np.stack(batches, axis=0) / 255.0 * 2 - 1.0
out_path = os.path.join(self.root, "overview_{:07d}.png".format(step))
plot_batch(batch, out_path)
def log_images(self, results, step, path):
for name, image_batch in results.items():
full_name = name + "_{:07}.png".format(step)
save_path = os.path.join(self.root, path, full_name)
try:
plot_batch(image_batch, save_path)
except FileNotFoundError:
os.makedirs(os.path.split(save_path)[0])
plot_batch(image_batch, save_path)
def after_step(self, batch_index, last_results):
if batch_index % self.interval == 0:
step = last_results["global_step"]
last_results = last_results["logging"]
if self._has_summary:
summary = last_results["summaries"]
self.writer.add_summary(summary, step)
logs = last_results["logs"]
for name in sorted(logs.keys()):
self.logger.info("{}: {}".format(name, logs[name]))
if not self.log_images_to_tensorboard:
for name, image_batch in last_results["images"].items():
full_name = name + "_{:07}.png".format(step)
save_path = os.path.join(self.root, full_name)
plot_batch(image_batch, save_path)
self.logger.info("project root: {}".format(self.root))
def after_step(self, batch_index, last_results):
if batch_index % self.interval == 0:
step = last_results["global_step"]
for key in self.scalar_keys:
value = retrieve(key, last_results)
self.tb_logger.add_scalar(key, value, step)
for key in self.histogram_keys:
value = retrieve(key, last_results)
self.tb_logger.add_histogram(key, value, step)
for key in self.image_keys:
value = retrieve(key, last_results)
name = key.split("/")[-1]
full_name = name + "_{:07}.png".format(step)
save_path = os.path.join(self.root, full_name)
plot_batch(value, save_path)
for key in self.log_keys:
value = retrieve(key, last_results)
self.logger.info("{}: {}".format(key, value))
def after_step(self, batch_index, results):
step = retrieve('global_step', results)
for i, key in enumerate(self.keys):
image_batch = retrieve(key, results)
if self.names is not None:
name = self.names[i]
else:
name = key.split('/')[-1]
if self.time_axis is not None:
n = image_batch.shape[self.time_axis]
t_batches = np.split(image_batch, n, axis=self.time_axis)
for ts, sub_batch in enumerate(t_batches):
sub_batch = sub_batch.squeeze(self.time_axis)
savename = name + '_{:0>7d}-{:0>4}-ts{:0>2}.png' \
.format(step, batch_index, ts)
savename = os.path.join(self.root, savename)
plot_batch(sub_batch, savename)
else:
savename = name + '_{:0>7d}-{:0>4}.png'.format(step,
batch_index)
savename = os.path.join(self.root, savename)
plot_batch(image_batch, savename)
def make_figure_1(data: dict, root: str, config: dict, global_step: int):
figure01_options = config.get("figure01_options")
dp_semantic_remap_dict = config.get("dp_semantic_remap_dict")
dp_new_part_list = sorted(list(dp_semantic_remap_dict.keys()))
dp_remap_dict = denseposelib.semantic_remap_dict2remap_dict(
dp_semantic_remap_dict, dp_new_part_list)
inferred_segmentation = (
data["outputs"][figure01_options["inferred_segmentation_key"]] + 1
) # +1 because the visualizer code uses + 1
sampled_segmentation = data["outputs"][
figure01_options["sampled_mask_key"]]
images = data["inputs"][figure01_options["input_view_key"]]
generated = data["outputs"][figure01_options["generated_image_key"]]
groundtruth_segmentation = data["batches"][
figure01_options["gt_segmentation_key"]]
groundtruth_segmentation = denseposelib.resize_labels(
groundtruth_segmentation, (128, 128))
remapped_gt_segmentation = denseposelib.remap_parts(
groundtruth_segmentation, dp_remap_dict)
best_remapping = denseposelib.compute_best_iou_remapping(
inferred_segmentation, remapped_gt_segmentation)
remapped_inferred = denseposelib.remap_parts(inferred_segmentation,
best_remapping)
ncols = 7
n_inferred_parts = config.get("n_inferred_parts", 10)
colors = make_mask_colors(len(set(dp_new_part_list)), background_id=1)
df = pd.DataFrame(columns=["global_step", "batch_idx"] + dp_new_part_list)
for i in range(
len(inferred_segmentation)
): # TODO: maybe replace this amount of plots by parameters in the config file
image_container = []
# remap inferred segmentation
old_inferred = inferred_segmentation[i]
current_sampled_segmentation = np.argmax(sampled_segmentation[i], -1)
old_inferred_colors = make_mask_colors(n_inferred_parts,
background_id=1)
image_container.append(old_inferred_colors[old_inferred - 1])
image_container.append(
old_inferred_colors[current_sampled_segmentation])
new_inferred = remapped_inferred[i]
current_gt_segmentation = remapped_gt_segmentation[i]
# remap GT segmentation
iou, iou_labels = denseposelib.compute_iou(new_inferred,
current_gt_segmentation)
# filter out background
iou_filter = np.ones_like(iou) == 1.0
iou_filter[iou_labels == dp_new_part_list.index("background")] = False
df_update = {p: -1.0 for p in dp_new_part_list}
df_update.update({
p: float(np.squeeze(iou[pi == iou_labels]))
for pi, p in enumerate(dp_new_part_list) if pi in iou_labels
})
df_update.update({"batch_idx": i, "global_step": global_step})
df = df.append(df_update, ignore_index=True)
filtered_iou = iou[iou_filter]
mean_iou = np.mean(filtered_iou)
image_container.append(colors[new_inferred])
image_container.append(colors[current_gt_segmentation])
legend_labels = []
for pi, p in enumerate(dp_new_part_list):
if pi in iou_labels:
p_iou = np.squeeze(iou[np.argwhere(iou_labels == pi)])
else:
p_iou = 0.0
legend_labels.append(p + " - IOU : {:.03f}".format(p_iou))
legend_labels.append("mIOU (no BG) : {:.03f}".format(mean_iou))
colors = np.concatenate([colors, np.reshape([0, 0, 0], (1, 3))],
axis=0)
text_colors = [1, 1, 1] * len(colors)
legend_image = utils.make_legend_image(legend_labels, colors,
text_colors, (128, 128), 1)
image_container.append(legend_image)
current_image = images[i]
current_generated = generated[i]
image_container.append(
imageutils.convert_range(current_image, [-1, 1], [0, 1]))
image_container.append(
imageutils.convert_range(current_generated, [-1, 1], [0, 1]))
# write files
out_path = os.path.join(root, "figure_01")
os.makedirs(out_path, exist_ok=True)
out_image = np.stack(image_container)
out_image = imageutils.convert_range(out_image, [0, 1], [-1, 1])
plot_batch(out_image,
os.path.join(out_path, "{:06d}.png".format(i)),
cols=ncols)
df.to_csv(os.path.join(root, "part_ious.csv"), index=False, header=True)
df_mean = df[df != -1].mean().to_frame().transpose()
with open(os.path.join(root, "mean_part_ios.csv"), "w") as f:
print(
tabulate(df_mean,
headers="keys",
tablefmt="psql",
showindex="never"),
file=f,
)
def log_images(self, results, step):
for name, image_batch in results.items():
full_name = name + "_{:07}.png".format(self._step)
save_path = os.path.join(self.root, full_name)
plot_batch(image_batch, save_path)
from eddata.pennaction import PennAction, PennActionCropped
from edflow.iterators.batches import plot_batch
import numpy as np
if __name__ == "__main__":
d = PennAction()
e = d[0]
print(e)
for k, v in e.items():
print(k, type(v))
print(sorted(set(d.labels["action"])))
d = PennActionCropped()
batch = np.stack([d[10 * i]["image"] for i in range(16)])
plot_batch(batch, "pennaction_examples.png")