def test_pil(self):
from PIL import Image
pil_image = Image.open('vlogging/tests/lenna.jpg')
s = str(
vlogging.VisualRecord(title="title",
imgs=pil_image,
footnotes="footnotes"))
self.assertTrue("title" in s)
self.assertTrue("footnotes" in s)
self.assertTrue("<pre>" in s)
self.assertTrue("image/png" in s)
self.assertEqual(s.count("<img"), 1)
s = str(
vlogging.VisualRecord(title="title",
imgs=[pil_image],
footnotes="footnotes"))
self.assertEqual(s.count("<img"), 1)
s = str(
vlogging.VisualRecord(title="title",
imgs=[pil_image, pil_image],
footnotes="footnotes",
fmt="jpeg"))
self.assertTrue("image/jpeg" in s)
self.assertEqual(s.count("<img"), 2)
def test_opencv(self):
import cv2
cv_image = cv2.imread('vlogging/tests/lenna.jpg')
s = str(
vlogging.VisualRecord(title="title",
imgs=cv_image,
footnotes="footnotes"))
self.assertTrue("title" in s)
self.assertTrue("footnotes" in s)
self.assertTrue("<pre>" in s)
self.assertEqual(s.count("<img"), 1)
s = str(
vlogging.VisualRecord(title="title",
imgs=[cv_image],
footnotes="footnotes"))
self.assertEqual(s.count("<img"), 1)
s = str(
vlogging.VisualRecord(title="title",
imgs=[cv_image, cv_image],
footnotes="footnotes"))
self.assertEqual(s.count("<img"), 2)
def visualize_training_samples(_context, config_path):
"""
Visualize a few training samples
Args:
_context (invoke.Context): context instance
config_path (str): path to configuration file
"""
import cv2
import tqdm
import vlogging
import net.data
import net.utilities
config = net.utilities.read_yaml(config_path)
samples_data_loader = net.data.CombinedPASCALDatasetsLoader(
voc_data_directory=config["voc_data_directory"],
hariharan_data_directory=config["hariharan_data_directory"],
categories_count=len(config["categories"]),
batch_size=config["batch_size"],
augmentation_pipeline=net.processing.get_augmentation_pipepline())
training_samples_data_loader = net.data.TrainingDataLoader(
samples_data_loader=samples_data_loader,
use_training_mode=True,
size=config["training_image_dimension"],
categories=config["categories"])
logger = net.utilities.get_logger(path="/tmp/log.html")
iterator = iter(training_samples_data_loader)
for _ in tqdm.tqdm(range(10)):
images, segmentations, masks = next(iterator)
logger.info(
vlogging.VisualRecord(
title="images", imgs=[cv2.pyrDown(image) for image in images]))
logger.info(
vlogging.VisualRecord(
title="segmentations",
imgs=[10 * cv2.pyrDown(image) for image in segmentations]))
logger.info(
vlogging.VisualRecord(
title="masks",
imgs=[255 * cv2.pyrDown(image) for image in masks]))
def log_performance_with_annotations_size_analysis(
logger, thresholds_matching_data_map):
"""
Log performance of network across annotations of different sizes
:param logger: logger instance
:param thresholds_matching_data_map: dictionary, each key is a float and value is a dictionary with
info about matched and unmatched annotations and predictions at corresponding threshold
"""
# Only use data at threshold 0
unmatched_annotations = thresholds_matching_data_map[0][
"unmatched_annotations"]
unmatched_annotations_heatmap_figure = get_annotations_sizes_heatmap_figure(
annotations=unmatched_annotations, bin_size=20, max_size=500)
logger.info(
vlogging.VisualRecord("Unmatched annotations heatmap",
unmatched_annotations_heatmap_figure))
small_unmatched_annotations_heatmap_figure = get_annotations_sizes_heatmap_figure(
annotations=unmatched_annotations, bin_size=5, max_size=100)
logger.info(
vlogging.VisualRecord("Small unmatched annotations heatmap",
small_unmatched_annotations_heatmap_figure))
log_unmatched_annotations_sizes(
logger=logger,
unmatched_annotations=unmatched_annotations,
x_range=(100, 600),
y_range=(100, 600),
size_factor=20,
instances_threshold=10)
log_unmatched_annotations_sizes(
logger=logger,
unmatched_annotations=unmatched_annotations,
x_range=(40, 200),
y_range=(40, 200),
size_factor=10,
instances_threshold=10)
log_unmatched_annotations_sizes(
logger=logger,
unmatched_annotations=unmatched_annotations,
x_range=(10, 100),
y_range=(10, 100),
size_factor=5,
instances_threshold=10)
def log_preprocessed_datasets_generator_output(logger):
parent_dir = "../../data/behavioral_cloning/validation/"
paths = [
"track_1_center/driving_log.csv",
"track_2_center/driving_log.csv",
"track_1_curves/driving_log.csv",
"track_2_curves/driving_log.csv",
"track_1_recovery/driving_log.csv",
"track_2_recovery/driving_log.csv"
]
paths = [os.path.join(parent_dir, path) for path in paths]
angles = [0, 0, 0.02, 0.02, 0.1, 0.1]
generator = model.get_multiple_datasets_generator(paths, angles, batch_size=6)
preprocessing_model = model.get_preprocessing_model(image_size=(160, 320, 3))
for _ in range(10):
images, steering_angles = next(generator)
preprocessed_images = preprocessing_model.predict(images)
preprocessed_images = [(255 * image).astype(np.uint8) for image in preprocessed_images]
logger.info(vlogging.VisualRecord(
"Frames", preprocessed_images, "Steering angle: {}".format(steering_angles.tolist())))
def log_all_datasets_generator_output(logger):
parent_dir = "../../data/behavioral_cloning/validation"
paths = [
"track_1_center/driving_log.csv",
"track_2_center/driving_log.csv",
"track_1_curves/driving_log.csv",
"track_2_curves/driving_log.csv",
"track_1_recovery/driving_log.csv",
"track_2_recovery/driving_log.csv"
]
paths = [os.path.join(parent_dir, path) for path in paths]
angles = [0, 0, 0.02, 0.02, 0.1, 0.1]
generator = model.get_multiple_datasets_generator(paths, angles, batch_size=6)
for _ in range(10):
images, steering_angles = next(generator)
# Resize images slightly
images = [cv2.pyrDown(image) for image in images]
logger.info(vlogging.VisualRecord(
"Frames", images, "Steering angle: {}".format(steering_angles.tolist())))
def log_face_detections(image_paths_file, logger):
model = face.models.get_pretrained_vgg_model(face.config.image_shape)
model.load_weights(face.config.model_path)
paths = [
path.strip()
for path in face.utilities.get_file_lines(image_paths_file)
]
random.shuffle(paths)
for path in tqdm.tqdm(paths[:10]):
image = face.utilities.get_image(path)
detections = face.detection.FaceDetector(
image, model,
face.config.face_search_config).get_faces_detections()
for face_detection in detections:
face.geometry.draw_bounding_box(image,
face_detection.bounding_box,
color=(0, 1, 0),
thickness=4)
logger.info(
vlogging.VisualRecord("Detections", image * 255,
"{} - {}".format(path, str(image.shape))))
def log_voc_samples_generator_output_overlays(logger, config):
"""
Logs voc samples generator, overlaying non-background segmentations over original image
"""
indices_to_colors_map, void_color = net.data.get_colors_info(
len(config["categories"]))
colors_to_ignore = [void_color, indices_to_colors_map[0]]
data_segmentation_samples_generator_factory = net.data.VOCSamplesGeneratorFactory(
config["voc"]["data_directory"], config["voc"]["validation_set_path"],
config["size_factor"])
generator = data_segmentation_samples_generator_factory.get_generator()
for _ in tqdm.tqdm(range(10)):
image, segmentation = next(generator)
segmentation_overlaid_image = net.utilities.get_segmentation_overlaid_image(
image, segmentation, colors_to_ignore)
logger.info(
vlogging.VisualRecord(
"Data", [image, segmentation, segmentation_overlaid_image]))
def main():
logger = cars.utilities.get_logger(cars.config.log_path)
with open(cars.config.classifier_path, mode="rb") as file:
data = pickle.load(file)
scaler = data['scaler']
classifier = data['classifier']
paths = glob.glob(os.path.join(cars.config.test_images_directory, "*.jpg"))
for path in paths:
image = cars.utilities.get_image(path)
luv_image = cv2.cvtColor(image, cv2.COLOR_RGB2LUV)
detections = cars.processing.get_detections(
luv_image, classifier, scaler, parameters=cars.config.parameters)
for detection in detections:
cv2.rectangle(image,
detection[0],
detection[1],
thickness=6,
color=(0, 255, 0))
bgr_image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
logger.info(
vlogging.VisualRecord(os.path.basename(path), bgr_image,
fmt='jpg'))
def log_model_analysis(logger, image, segmentation_image, model,
indices_to_colors_map, void_color, colors_to_ignore):
"""
Log analysis of model's prediction on a single image.
Logs input image, ground truth segmentation, predicted segmentation, ground truth segmentation overlaid
over input image, and predicted segmentation overlaid over input image
:param logger: logger instance to which analysis should be logged
:param image: input image for model to predict on
:param segmentation_image: ground truth segmentation for input image
:param model: net.ml.Model instance
:param indices_to_colors_map: dictionary mapping categories ids to segmentation colors
:param void_color: color representing pixels without any category assigned
:param colors_to_ignore: list of colors that should be ignored when constructing overlays
"""
ground_truth_overlay_image = net.utilities.get_segmentation_overlaid_image(
image, segmentation_image, colors_to_ignore)
predicted_segmentation_cube = model.predict(image)
predicted_segmentation_image = net.data.get_segmentation_image(
predicted_segmentation_cube, indices_to_colors_map, void_color)
predicted_overlay_image = net.utilities.get_segmentation_overlaid_image(
image, predicted_segmentation_image, colors_to_ignore)
logger.info(
vlogging.VisualRecord("Data", [
image, segmentation_image, predicted_segmentation_image,
ground_truth_overlay_image, predicted_overlay_image
]))
def log_predictions(logger, model, session, x_data, y_data, header):
"""
Log model predictions along with correct answers
:param logger: logger instance
:param model: model
:param session: tensorflow session
:param x_data: batch of MNIST images
:param y_data: batch of MNIST labels
:param header: header for log entries
"""
data_size = x_data.shape[0]
feed_dictionary = {model.x_placeholder: x_data.reshape(data_size, 784)}
prediction = session.run(model.prediction, feed_dictionary)
for index in range(data_size):
image = cv2.resize(x_data[index], (64, 64))
label = y_data[index]
predicted_label = np.argmax(prediction[index])
message = "True label: {}, predicted label: {}\nRaw predictions:\n{}".format(
label, predicted_label, prediction[index].reshape(10, 1))
logger.info(vlogging.VisualRecord(header, image, message, fmt='jpg'))
def log_heatmaps(image_paths_file, logger):
model = face.models.get_pretrained_vgg_model(face.config.image_shape)
model.load_weights(face.config.model_path)
paths = [
path.strip()
for path in face.utilities.get_file_lines(image_paths_file)
]
random.shuffle(paths)
for path in tqdm.tqdm(paths[:10]):
image = face.utilities.get_image(path)
heatmap = face.detection.HeatmapComputer(
image, model, face.config.face_search_config).get_heatmap()
scaled_images = [255 * image, 255 * heatmap]
scaled_images = [
face.processing.scale_image_keeping_aspect_ratio(image, 200)
for image in scaled_images
]
logger.info(
vlogging.VisualRecord("Heatmap", scaled_images, str(image.shape)))
def log_samples(logger, x_data, y_data):
# Display a few samples
for image, label in zip(x_data, y_data):
image = cv2.resize(image, (64, 64))
logger.info(
vlogging.VisualRecord("Sample", image, str(label), fmt='jpg'))
def log_predictions(
logger: logging.Logger, prediction_model: tf.keras.Model,
images: typing.List[np.ndarray],
ground_truth_segmentations: typing.List[np.ndarray],
categories_indices_to_colors_map: typing.Dict[int, typing.Tuple[int, int,
int]]):
"""
Log a batch of predictions, along with input images and ground truth segmentations
Args:
logger (logging.Logger): logger instance
prediction_model (tf.keras.Model): prediction model
images (typing.List[np.ndarray]): list of images to run predictions on
ground_truth_segmentations (typing.List[np.ndarray]): list of ground truth segmentations
categories_to_colors_map (typing.Dict[int, typing.Tuple[int, int, int]]):
dictionary mapping categories indices to overlay colors to be used in visualizations
"""
ground_truth_overlay_segmentations = [
net.processing.get_segmentation_overlay(
image=image,
segmentation=segmentation,
indices_to_colors_map=categories_indices_to_colors_map)
for image, segmentation in zip(images, ground_truth_segmentations)
]
logger.info(
vlogging.VisualRecord(title="ground truth segmentations",
imgs=ground_truth_overlay_segmentations))
predicted_segmentations = np.array([
np.argmax(prediction, axis=-1)
for prediction in prediction_model.predict(images)
])
predictions_overlays = [
net.processing.get_segmentation_overlay(
image=image,
segmentation=segmentation,
indices_to_colors_map=categories_indices_to_colors_map)
for image, segmentation in zip(images, predicted_segmentations)
]
logger.info(
vlogging.VisualRecord(title="predicted segmentations",
imgs=predictions_overlays))
def log_single_generator_output(logger):
generator = model.get_single_dataset_generator(
"../../data/behavioral_cloning/validation/track_2_curves/driving_log.csv", minimum_angle=0.02)
for _ in range(10):
image, steering_angle = next(generator)
logger.info(vlogging.VisualRecord("Frame", image, "Steering angle: {}".format(steering_angle)))
def test_invalid_images(self):
s = str(
vlogging.VisualRecord(title="title",
imgs="foobar",
footnotes="footnotes"))
self.assertTrue("title" in s)
self.assertTrue("footnotes" in s)
self.assertTrue("<pre>" in s)
self.assertEqual(s.count("<img"), 0)
s = str(
vlogging.VisualRecord(title="title",
imgs=["foobar", 1, 2, dict()],
footnotes="footnotes"))
self.assertTrue("title" in s)
self.assertTrue("footnotes" in s)
self.assertTrue("<pre>" in s)
self.assertEqual(s.count("<img"), 0)
def log_training_data(data_dir, image_shape):
get_batches_fn = helper.gen_batch_function(os.path.join(data_dir, 'data_road/training'), image_shape)
batch_generator = get_batches_fn(4)
logger = get_logger("/tmp/segmentation.html")
for batch_index in range(500):
images, labels = next(batch_generator)
images = [cv2.cvtColor(image, cv2.COLOR_RGB2BGR) for image in images]
labels = 255 * labels.astype(np.uint8)
non_road_labels = [label[:, :, 0] for label in labels]
road_labels = [label[:, :, 1] for label in labels]
logger.info(vlogging.VisualRecord("Image batch {}".format(batch_index), images))
# logger.info(vlogging.VisualRecord("Non-road", non_road_labels))
logger.info(vlogging.VisualRecord("Road batch {}".format(batch_index), road_labels))
def main():
logger = cars.utilities.get_logger(cars.config.log_path)
path = "./project_video.mp4"
clip = moviepy.editor.VideoFileClip(path)
for time in [8, 9, 29, 31]:
frame = clip.get_frame(t=time)
frame = cv2.cvtColor(frame, cv2.COLOR_RGB2BGR)
logger.info(vlogging.VisualRecord(str(time), [frame], fmt="jpg"))
def log_data_batches(data_generator, logger):
for _ in range(8):
images, labels = next(data_generator)
images = [image * 255 for image in images]
images = [
face.processing.scale_image_keeping_aspect_ratio(image, 100)
for image in images
]
logger.info(vlogging.VisualRecord("Images batch", images, str(labels)))
def log_predictions(logger, model, x_data, y_data, header):
# Display a few samples
for image, label in zip(x_data, y_data):
prediction = model.predict(image.reshape(784, 1))
predicted_label = np.argmax(prediction)
message = "True label: {}, predicted label: {}\nRaw predictions:\n{}".format(
label, predicted_label, prediction)
large_image = cv2.resize(image, (64, 64))
logger.info(
vlogging.VisualRecord(header, large_image, message, fmt='jpg'))
def log_default_boxes_matches_for_single_sample(logger, ssd_input_generator,
default_boxes_factory,
categories_to_colors_map,
font_path):
"""
Logs default boxes matches for a single sample. If no default box was matched with any annotation,
nothing is logger.
:param logger: logger instance
:param ssd_input_generator: generator that outputs (image, annotations) tuples
:param default_boxes_factory: net.ssd.DefaultBoxesFactory instance
:param categories_to_colors_map: dictionary mapping categories labels to colors
:param font_path: path to font to be used to annotate images
"""
image, annotations = next(ssd_input_generator)
default_boxes_matrix = default_boxes_factory.get_default_boxes_matrix(
image.shape)
all_matched_default_boxes_indices = []
for annotation in annotations:
matched_default_boxes_indices = net.utilities.get_matched_boxes_indices(
annotation.bounding_box, default_boxes_matrix, threshold=0.5)
all_matched_default_boxes_indices.extend(
matched_default_boxes_indices.tolist())
if len(all_matched_default_boxes_indices) > 0:
annotations_colors = [
categories_to_colors_map[annotation.label]
for annotation in annotations
]
annotated_image = net.plot.get_annotated_image(
image=net.data.ImageProcessor.get_denormalized_image(image),
annotations=annotations,
colors=annotations_colors,
draw_labels=True,
font_path=font_path)
matched_boxes = default_boxes_matrix[all_matched_default_boxes_indices]
matched_boxes_image = net.plot.get_image_with_boxes(
image=net.data.ImageProcessor.get_denormalized_image(image),
boxes=matched_boxes,
color=(0, 255, 0))
logger.info(
vlogging.VisualRecord("Default boxes",
[annotated_image, matched_boxes_image]))
def test_pylab_basic(self):
import matplotlib.pyplot as plt
import numpy as np
t = np.arange(0., 5., 0.2)
plt.plot(t, t, 'r--', t, t**2, 'bs', t, t**3, 'g^')
s = str(
vlogging.VisualRecord(title="title",
imgs=plt,
footnotes="footnotes"))
self.assertTrue("title" in s)
self.assertTrue("footnotes" in s)
self.assertTrue("<pre>" in s)
self.assertEqual(s.count("<img"), 1)
def log_single_prediction(logger, model, default_boxes_factory,
samples_iterator, config):
"""
Log network prediction on a single sample. Draws a single sample from samples_iterator
:param logger: logger instance
:param model: net.ml.VGGishModel instance
:param default_boxes_factory: net.ssd.DefaultBoxesFactory instance
:param samples_iterator: iterator that yields (image, ground truth annotations) tuples
:param config: dictionary with configuration options
"""
image, ground_truth_annotations = next(samples_iterator)
ground_truth_annotations_image = net.plot.get_annotated_image(
image=net.data.ImageProcessor.get_denormalized_image(image),
annotations=ground_truth_annotations,
colors=[(255, 0, 0)] * len(ground_truth_annotations),
font_path=config["font_path"])
softmax_predictions_matrix, offsets_predictions_matrix = model.predict(
image)
default_boxes_matrix = default_boxes_factory.get_default_boxes_matrix(
image.shape)
predictions_with_nms = net.ssd.PredictionsComputer(
categories=config["categories"],
threshold=0.5,
use_non_maximum_suppression=True).get_predictions(
bounding_boxes_matrix=default_boxes_matrix +
offsets_predictions_matrix,
softmax_predictions_matrix=softmax_predictions_matrix)
predicted_annotations_image_with_nms = net.plot.get_annotated_image(
image=net.data.ImageProcessor.get_denormalized_image(image),
annotations=predictions_with_nms,
colors=[(0, 255, 0)] * len(predictions_with_nms),
font_path=config["font_path"])
logger.info(
vlogging.VisualRecord(
"Ground truth vs predictions vs predictions with nms", [
ground_truth_annotations_image,
predicted_annotations_image_with_nms
]))
def log_voc_samples_generator_output(logger, config):
"""
Logs voc samples generator output
"""
voc_config = {
"data_directory": config["voc"]["data_directory"],
"data_set_path": config["voc"]["train_set_path"],
}
hariharan_config = {
"data_directory": config["hariharan"]["data_directory"],
"data_set_path": config["hariharan"]["train_set_path"],
}
generator = net.data.CombinedPASCALDatasetsGeneratorFactory(
voc_config, hariharan_config, config["size_factor"],
len(config["categories"])).get_generator()
ids_to_colors_map, void_color = net.data.get_colors_info(
len(config["categories"]))
ids_to_categories_map = net.utilities.get_ids_to_values_map(
config["categories"])
for _ in tqdm.tqdm(range(20)):
image, segmentation = next(generator)
image, segmentation = net.utilities.DataAugmenter.augment_samples(
image, segmentation, void_color)
segmentation_cube = net.data.get_segmentation_cube(
segmentation, ids_to_colors_map)
categories, segmentation_layers = zip(
*net.utilities.get_categories_segmentations_maps(
segmentation_cube, ids_to_categories_map).items())
images_to_display = \
[image, segmentation, 255 * net.data.get_void_mask(segmentation, void_color)] + \
net.utilities.get_uint8_images(segmentation_layers)
logger.info(
vlogging.VisualRecord("Data",
images_to_display,
footnotes=str(["void"] + list(categories))))
def log_crops_predictions(data_generator, logger):
model = face.models.get_pretrained_vgg_model(face.config.image_shape)
model.load_weights(face.config.model_path)
for _ in range(8):
images, _ = next(data_generator)
predictions = model.predict(images)
images = [image * 255 for image in images]
images = [
face.processing.scale_image_keeping_aspect_ratio(image, 100)
for image in images
]
logger.info(
vlogging.VisualRecord("Crops predictions", images,
str(predictions)))
def get_single_sample_debugging_visual_record(image, ground_truth_annotations,
matched_default_boxes,
predicted_annotations, config):
"""
Get debugging visual record for a single sample
:param image: 3D numpy array, image
:param ground_truth_annotations: list of ground truth Annotation instances
:param matched_default_boxes: 2D numpy array of default boxes matched with ground truth annotations
:param predicted_annotations: list of predicted Annotation instances
:param config: dictionary with configuration parameters
:return: vlogging.VisualRecord instance
"""
ground_truth_annotations_image = net.plot.get_annotated_image(
image=image,
annotations=ground_truth_annotations,
colors=[(255, 0, 0)] * len(ground_truth_annotations),
font_path=config["font_path"])
matched_boxes_image = net.plot.get_image_with_boxes(
image=image, boxes=matched_default_boxes, color=(0, 255, 0))
predicted_annotations_image = net.plot.get_annotated_image(
image=image,
annotations=predicted_annotations,
colors=[(0, 255, 0)] * len(predicted_annotations),
draw_labels=True,
font_path=config["font_path"])
message = "Ground truth annotations count: {}, matched default boxes count: {}, predictions count: {}".format(
len(ground_truth_annotations), len(matched_default_boxes),
len(predicted_annotations))
record = vlogging.VisualRecord(
title=
"Debug info - raw image, ground truth annotations, matched default boxes, predictions",
imgs=[
image, ground_truth_annotations_image, matched_boxes_image,
predicted_annotations_image
],
footnotes=message)
return record
def log_augmentations(logger, config):
"""
Log augmentations
:param logger: logger instance
:param config: dictionary with configuration options
"""
validation_samples_loader = net.data.VOCSamplesDataLoader(
data_directory=config["voc"]["data_directory"],
data_set_path=config["voc"]["train_set_path"],
categories=config["categories"],
size_factor=config["size_factor"])
augmentation_pipeline = net.data.get_image_augmentation_pipeline()
iterator = iter(validation_samples_loader)
for _ in tqdm.tqdm(range(10)):
image, annotations = next(iterator)
image = net.data.ImageProcessor.get_denormalized_image(image)
annotated_image = net.plot.get_annotated_image(image=image,
annotations=annotations,
colors=[(255, 0, 0)] *
len(annotations),
draw_labels=False)
augmented_image, augmented_annotations = net.data.get_augmented_sample(
image=image,
annotations=annotations,
augmentation_pipeline=augmentation_pipeline)
augmented_annotated_image = net.plot.get_annotated_image(
image=augmented_image,
annotations=augmented_annotations,
colors=[(255, 0, 0)] * len(augmented_annotations),
draw_labels=False)
logger.info(
vlogging.VisualRecord(
"sample", [annotated_image, augmented_annotated_image]))
def log_ssd_training_loop_data_loader_outputs(logger, config):
"""
Logger function for visually confirming that net.ssd.SSDTrainingLoopDataLoader outputs correct results
"""
samples_loader = net.data.VOCSamplesDataLoader(
data_directory=config["voc"]["data_directory"],
data_set_path=config["voc"]["validation_set_path"],
categories=config["categories"],
size_factor=config["size_factor"])
ssd_validation_samples_loader = net.ssd.SSDTrainingLoopDataLoader(
voc_samples_data_loader=samples_loader,
ssd_model_configuration=config["vggish_model_configuration"])
default_boxes_factory = net.ssd.DefaultBoxesFactory(
config["vggish_model_configuration"])
iterator = iter(ssd_validation_samples_loader)
for _ in tqdm.tqdm(range(20)):
image, default_boxes_categories_ids_vector, _, _ = next(iterator)
default_boxes_matrix = default_boxes_factory.get_default_boxes_matrix(
image.shape)
matched_boxes = default_boxes_matrix[
default_boxes_categories_ids_vector > 0]
matched_boxes_image = net.plot.get_image_with_boxes(
image=net.data.ImageProcessor.get_denormalized_image(image),
boxes=matched_boxes,
color=(0, 255, 0))
logger.info(
vlogging.VisualRecord("image and default boxes matches", [
net.data.ImageProcessor.get_denormalized_image(image),
matched_boxes_image
]))
def visualize_data(_context, config_path):
"""
Visualize data
:param _context: context
:type _context: invoke.Context
:param config_path: path to configuration file
:type config_path: str
"""
import tqdm
import vlogging
import net.data
import net.processing
import net.utilities
config = net.utilities.read_yaml(config_path)
logger = net.utilities.get_logger(path=config["log_path"])
data_loader = net.data.Cars196TrainingLoopDataLoader(
config=config, dataset_mode=net.constants.DatasetMode.TRAINING)
iterator = iter(data_loader)
for _ in tqdm.tqdm(range(4)):
images_batch, labels_batch = next(iterator)
logger.info(
vlogging.VisualRecord(
title="data",
imgs=[
net.processing.ImageProcessor.get_denormalized_image(image)
for image in images_batch
],
footnotes=str(labels_batch)))
def log_voc_samples_generator_output(logger, config):
"""
Logs voc samples generator output
"""
samples_loader = net.data.VOCSamplesDataLoader(
data_directory=config["voc"]["data_directory"],
data_set_path=config["voc"]["validation_set_path"],
categories=config["categories"],
size_factor=config["size_factor"],
augmentation_pipeline=net.data.get_image_augmentation_pipeline())
generator = iter(samples_loader)
categories_to_colors_map = net.utilities.get_categories_to_colors_map(
config["categories"])
for _ in tqdm.tqdm(range(40)):
image, annotations = next(generator)
colors = [
categories_to_colors_map[annotation.label]
for annotation in annotations
]
image = net.plot.get_annotated_image(
image=net.data.ImageProcessor.get_denormalized_image(image),
annotations=annotations,
colors=colors,
draw_labels=True,
font_path=config["font_path"])
labels = [annotation.label for annotation in annotations]
message = "{} - {}".format(image.shape[:2], labels)
logger.info(vlogging.VisualRecord("Data", [image], message))
