| import os |
| import logging |
| import functools |
| import json |
| import time |
| from datetime import datetime |
|
|
| from tensorboardX import SummaryWriter |
| import yaml |
| import cv2 |
| import numpy as np |
|
|
| from concern.config import Configurable, State |
|
|
|
|
| class Logger(Configurable): |
| SUMMARY_DIR_NAME = 'summaries' |
| VISUALIZE_NAME = 'visualize' |
| LOG_FILE_NAME = 'output.log' |
| ARGS_FILE_NAME = 'args.log' |
| METRICS_FILE_NAME = 'metrics.log' |
|
|
| database_dir = State(default='./outputs/') |
| log_dir = State(default='workspace') |
| verbose = State(default=False) |
| level = State(default='info') |
| log_interval = State(default=100) |
|
|
| def __init__(self, **kwargs): |
| self.load_all(**kwargs) |
|
|
| self._make_storage() |
|
|
| cmd = kwargs['cmd'] |
| self.name = cmd['name'] |
| self.log_dir = os.path.join(self.log_dir, self.name) |
| try: |
| self.verbose = cmd['verbose'] |
| except: |
| print('verbose:', self.verbose) |
| if self.verbose: |
| print('Initializing log dir for', self.log_dir) |
|
|
| if not os.path.exists(self.log_dir): |
| os.makedirs(self.log_dir) |
|
|
| self.message_logger = self._init_message_logger() |
|
|
| summary_path = os.path.join(self.log_dir, self.SUMMARY_DIR_NAME) |
| self.tf_board_logger = SummaryWriter(summary_path) |
|
|
| self.metrics_writer = open(os.path.join( |
| self.log_dir, self.METRICS_FILE_NAME), 'at') |
|
|
| self.timestamp = time.time() |
| self.logged = -1 |
| self.speed = None |
| self.eta_time = None |
|
|
| def _make_storage(self): |
| application = os.path.basename(os.getcwd()) |
| storage_dir = os.path.join( |
| self.database_dir, self.log_dir, application) |
| if not os.path.exists(storage_dir): |
| os.makedirs(storage_dir) |
| if not os.path.exists(self.log_dir): |
| os.symlink(storage_dir, self.log_dir) |
|
|
| def save_dir(self, dir_name): |
| return os.path.join(self.log_dir, dir_name) |
|
|
| def _init_message_logger(self): |
| message_logger = logging.getLogger('messages') |
| message_logger.setLevel( |
| logging.DEBUG if self.verbose else logging.INFO) |
| formatter = logging.Formatter( |
| '[%(levelname)s] [%(asctime)s] %(message)s') |
| std_handler = logging.StreamHandler() |
| std_handler.setLevel(message_logger.level) |
| std_handler.setFormatter(formatter) |
|
|
| file_handler = logging.FileHandler( |
| os.path.join(self.log_dir, self.LOG_FILE_NAME)) |
| file_handler.setLevel(message_logger.level) |
| file_handler.setFormatter(formatter) |
|
|
| message_logger.addHandler(std_handler) |
| message_logger.addHandler(file_handler) |
| return message_logger |
|
|
| def report_time(self, name: str): |
| if self.verbose: |
| self.info(name + " time :" + str(time.time() - self.timestamp)) |
| self.timestamp = time.time() |
|
|
| def report_eta(self, steps, total, epoch): |
| self.logged = self.logged % total + 1 |
| steps = steps % total |
| if self.eta_time is None: |
| self.eta_time = time.time() |
| speed = -1 |
| else: |
| eta_time = time.time() |
| speed = eta_time - self.eta_time |
| if self.speed is not None: |
| speed = ((self.logged - 1) * self.speed + speed) / self.logged |
| self.speed = speed |
| self.eta_time = eta_time |
|
|
| seconds = (total - steps) * speed |
| hours = seconds // 3600 |
| minutes = (seconds - (hours * 3600)) // 60 |
| seconds = seconds % 60 |
|
|
| print('%d/%d batches processed in epoch %d, ETA: %2d:%2d:%2d' % |
| (steps, total, epoch, |
| hours, minutes, seconds), end='\r') |
|
|
| def args(self, parameters=None): |
| if parameters is None: |
| with open(os.path.join(self.log_dir, self.ARGS_FILE_NAME), 'rt') as reader: |
| return yaml.load(reader.read()) |
| with open(os.path.join(self.log_dir, self.ARGS_FILE_NAME), 'wt') as writer: |
| yaml.dump(parameters.dump(), writer) |
|
|
| def metrics(self, epoch, steps, metrics_dict): |
| results = {} |
| for name, a in metrics_dict.items(): |
| results[name] = {'count': a.count, 'value': float(a.avg)} |
| self.add_scalar('metrics/' + name, a.avg, steps) |
| result_dict = { |
| str(datetime.now()): { |
| 'epoch': epoch, |
| 'steps': steps, |
| **results |
| } |
| } |
| string_result = yaml.dump(result_dict) |
| self.info(string_result) |
| self.metrics_writer.write(string_result) |
| self.metrics_writer.flush() |
|
|
| def named_number(self, name, num=None, default=0): |
| if num is None: |
| return int(self.has_signal(name)) or default |
| else: |
| with open(os.path.join(self.log_dir, name), 'w') as writer: |
| writer.write(str(num)) |
| return num |
|
|
| epoch = functools.partialmethod(named_number, 'epoch') |
| iter = functools.partialmethod(named_number, 'iter') |
|
|
| def message(self, level, content): |
| self.message_logger.__getattribute__(level)(content) |
|
|
| def images(self, prefix, image_dict, step): |
| for name, image in image_dict.items(): |
| self.add_image(prefix + '/' + name, image, step, dataformats='HWC') |
|
|
| def merge_save_images(self, name, images): |
| for i, image in enumerate(images): |
| if i == 0: |
| result = image |
| else: |
| result = np.concatenate([result, image], 0) |
| cv2.imwrite(os.path.join(self.vis_dir(), name+'.jpg'), result) |
|
|
| def vis_dir(self): |
| vis_dir = os.path.join(self.log_dir, self.VISUALIZE_NAME) |
| if not os.path.exists(vis_dir): |
| os.mkdir(vis_dir) |
| return vis_dir |
|
|
| def save_image_dict(self, images, max_size=1024): |
| for file_name, image in images.items(): |
| height, width = image.shape[:2] |
| if height > width: |
| actual_height = min(height, max_size) |
| actual_width = int(round(actual_height * width / height)) |
| else: |
| actual_width = min(width, max_size) |
| actual_height = int(round(actual_width * height / width)) |
| image = cv2.resize(image, (actual_width, actual_height)) |
| cv2.imwrite(os.path.join(self.vis_dir(), file_name+'.jpg'), image) |
|
|
| def __getattr__(self, name): |
| message_levels = set(['debug', 'info', 'warning', 'error', 'critical']) |
| if name == '__setstate__': |
| raise AttributeError('haha') |
| if name in message_levels: |
| return functools.partial(self.message, name) |
| elif hasattr(self.__dict__.get('tf_board_logger'), name): |
| return self.tf_board_logger.__getattribute__(name) |
| else: |
| super() |
|
|
