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))