Spaces:
Build error
Build error
"""Main Logger class for ClearML experiment tracking.""" | |
import glob | |
import re | |
from pathlib import Path | |
import numpy as np | |
import yaml | |
from utils.plots import Annotator, colors | |
try: | |
import clearml | |
from clearml import Dataset, Task | |
assert hasattr(clearml, '__version__') # verify package import not local dir | |
except (ImportError, AssertionError): | |
clearml = None | |
def construct_dataset(clearml_info_string): | |
"""Load in a clearml dataset and fill the internal data_dict with its contents. | |
""" | |
dataset_id = clearml_info_string.replace('clearml://', '') | |
dataset = Dataset.get(dataset_id=dataset_id) | |
dataset_root_path = Path(dataset.get_local_copy()) | |
# We'll search for the yaml file definition in the dataset | |
yaml_filenames = list(glob.glob(str(dataset_root_path / '*.yaml')) + glob.glob(str(dataset_root_path / '*.yml'))) | |
if len(yaml_filenames) > 1: | |
raise ValueError('More than one yaml file was found in the dataset root, cannot determine which one contains ' | |
'the dataset definition this way.') | |
elif len(yaml_filenames) == 0: | |
raise ValueError('No yaml definition found in dataset root path, check that there is a correct yaml file ' | |
'inside the dataset root path.') | |
with open(yaml_filenames[0]) as f: | |
dataset_definition = yaml.safe_load(f) | |
assert set(dataset_definition.keys()).issuperset( | |
{'train', 'test', 'val', 'nc', 'names'} | |
), "The right keys were not found in the yaml file, make sure it at least has the following keys: ('train', 'test', 'val', 'nc', 'names')" | |
data_dict = dict() | |
data_dict['train'] = str( | |
(dataset_root_path / dataset_definition['train']).resolve()) if dataset_definition['train'] else None | |
data_dict['test'] = str( | |
(dataset_root_path / dataset_definition['test']).resolve()) if dataset_definition['test'] else None | |
data_dict['val'] = str( | |
(dataset_root_path / dataset_definition['val']).resolve()) if dataset_definition['val'] else None | |
data_dict['nc'] = dataset_definition['nc'] | |
data_dict['names'] = dataset_definition['names'] | |
return data_dict | |
class ClearmlLogger: | |
"""Log training runs, datasets, models, and predictions to ClearML. | |
This logger sends information to ClearML at app.clear.ml or to your own hosted server. By default, | |
this information includes hyperparameters, system configuration and metrics, model metrics, code information and | |
basic data metrics and analyses. | |
By providing additional command line arguments to train.py, datasets, | |
models and predictions can also be logged. | |
""" | |
def __init__(self, opt, hyp): | |
""" | |
- Initialize ClearML Task, this object will capture the experiment | |
- Upload dataset version to ClearML Data if opt.upload_dataset is True | |
arguments: | |
opt (namespace) -- Commandline arguments for this run | |
hyp (dict) -- Hyperparameters for this run | |
""" | |
self.current_epoch = 0 | |
# Keep tracked of amount of logged images to enforce a limit | |
self.current_epoch_logged_images = set() | |
# Maximum number of images to log to clearML per epoch | |
self.max_imgs_to_log_per_epoch = 16 | |
# Get the interval of epochs when bounding box images should be logged | |
self.bbox_interval = opt.bbox_interval | |
self.clearml = clearml | |
self.task = None | |
self.data_dict = None | |
if self.clearml: | |
self.task = Task.init( | |
project_name=opt.project if opt.project != 'runs/train' else 'YOLOv5', | |
task_name=opt.name if opt.name != 'exp' else 'Training', | |
tags=['YOLOv5'], | |
output_uri=True, | |
reuse_last_task_id=opt.exist_ok, | |
auto_connect_frameworks={'pytorch': False} | |
# We disconnect pytorch auto-detection, because we added manual model save points in the code | |
) | |
# ClearML's hooks will already grab all general parameters | |
# Only the hyperparameters coming from the yaml config file | |
# will have to be added manually! | |
self.task.connect(hyp, name='Hyperparameters') | |
self.task.connect(opt, name='Args') | |
# Make sure the code is easily remotely runnable by setting the docker image to use by the remote agent | |
self.task.set_base_docker('ultralytics/yolov5:latest', | |
docker_arguments='--ipc=host -e="CLEARML_AGENT_SKIP_PYTHON_ENV_INSTALL=1"', | |
docker_setup_bash_script='pip install clearml') | |
# Get ClearML Dataset Version if requested | |
if opt.data.startswith('clearml://'): | |
# data_dict should have the following keys: | |
# names, nc (number of classes), test, train, val (all three relative paths to ../datasets) | |
self.data_dict = construct_dataset(opt.data) | |
# Set data to data_dict because wandb will crash without this information and opt is the best way | |
# to give it to them | |
opt.data = self.data_dict | |
def log_debug_samples(self, files, title='Debug Samples'): | |
""" | |
Log files (images) as debug samples in the ClearML task. | |
arguments: | |
files (List(PosixPath)) a list of file paths in PosixPath format | |
title (str) A title that groups together images with the same values | |
""" | |
for f in files: | |
if f.exists(): | |
it = re.search(r'_batch(\d+)', f.name) | |
iteration = int(it.groups()[0]) if it else 0 | |
self.task.get_logger().report_image(title=title, | |
series=f.name.replace(it.group(), ''), | |
local_path=str(f), | |
iteration=iteration) | |
def log_image_with_boxes(self, image_path, boxes, class_names, image, conf_threshold=0.25): | |
""" | |
Draw the bounding boxes on a single image and report the result as a ClearML debug sample. | |
arguments: | |
image_path (PosixPath) the path the original image file | |
boxes (list): list of scaled predictions in the format - [xmin, ymin, xmax, ymax, confidence, class] | |
class_names (dict): dict containing mapping of class int to class name | |
image (Tensor): A torch tensor containing the actual image data | |
""" | |
if len(self.current_epoch_logged_images) < self.max_imgs_to_log_per_epoch and self.current_epoch >= 0: | |
# Log every bbox_interval times and deduplicate for any intermittend extra eval runs | |
if self.current_epoch % self.bbox_interval == 0 and image_path not in self.current_epoch_logged_images: | |
im = np.ascontiguousarray(np.moveaxis(image.mul(255).clamp(0, 255).byte().cpu().numpy(), 0, 2)) | |
annotator = Annotator(im=im, pil=True) | |
for i, (conf, class_nr, box) in enumerate(zip(boxes[:, 4], boxes[:, 5], boxes[:, :4])): | |
color = colors(i) | |
class_name = class_names[int(class_nr)] | |
confidence_percentage = round(float(conf) * 100, 2) | |
label = f'{class_name}: {confidence_percentage}%' | |
if conf > conf_threshold: | |
annotator.rectangle(box.cpu().numpy(), outline=color) | |
annotator.box_label(box.cpu().numpy(), label=label, color=color) | |
annotated_image = annotator.result() | |
self.task.get_logger().report_image(title='Bounding Boxes', | |
series=image_path.name, | |
iteration=self.current_epoch, | |
image=annotated_image) | |
self.current_epoch_logged_images.add(image_path) | |