| | import os
|
| | import time
|
| | import logging
|
| | from tqdm import tqdm
|
| | import pickle as cPickle
|
| |
|
| | import torch
|
| | import torch.optim as optim
|
| |
|
| | import gorilla
|
| | from gorilla.solver.build import build_optimizer, build_lr_scheduler
|
| | from tensorboardX import SummaryWriter
|
| |
|
| |
|
| | class Solver(gorilla.solver.BaseSolver):
|
| | def __init__(self, model, loss, dataloaders, logger, cfg, coarse_model=None):
|
| | super(Solver, self).__init__(
|
| | model=model,
|
| | dataloaders=dataloaders,
|
| | cfg=cfg,
|
| | )
|
| | self.loss = loss
|
| | self.logger = logger
|
| | self.logger.propagate = 0
|
| |
|
| | self.coarse_model = coarse_model.eval() if coarse_model is not None else coarse_model
|
| |
|
| | tb_writer_ = tools_writer(
|
| | dir_project=cfg.log_dir, num_counter=2, get_sum=False)
|
| | tb_writer_.writer = self.tb_writer
|
| | self.tb_writer = tb_writer_
|
| | self.iters_to_print = cfg.iters_to_print
|
| |
|
| | if cfg.checkpoint_iter != -1:
|
| | logger.info("=> loading checkpoint from iter {} ...".format(cfg.checkpoint_iter))
|
| | checkpoint = os.path.join(cfg.log_dir, 'checkpoint_iter' + str(cfg.checkpoint_iter).zfill(6) + '.pth')
|
| | checkpoint_file = gorilla.solver.resume(model=model, filename=checkpoint, optimizer=self.optimizer, scheduler=self.lr_scheduler)
|
| | start_epoch = checkpoint_file['epoch']+1
|
| | start_iter = checkpoint_file['iter']
|
| | del checkpoint_file
|
| | else:
|
| | start_epoch = 1
|
| | start_iter = 0
|
| | self.epoch = start_epoch
|
| | self.iter = start_iter
|
| |
|
| | if hasattr(cfg, 'warmup_iter') and cfg.warmup_iter > 0:
|
| | self.warmup_optimizer = build_optimizer(model, cfg.warmup_optimizer)
|
| | self.warmup_scheduler = build_lr_scheduler(self.warmup_optimizer, cfg.warmup_lr_scheduler)
|
| |
|
| |
|
| | def solve(self):
|
| | while self.epoch <= self.cfg.training_epoch:
|
| | self.logger.info('\nEpoch {} :'.format(self.epoch))
|
| |
|
| | end = time.time()
|
| | dict_info_train = self.train()
|
| | train_time = time.time()-end
|
| |
|
| | dict_info = {'train_time(min)': train_time/60.0}
|
| | for key, value in dict_info_train.items():
|
| | if 'loss' in key:
|
| | dict_info['train_'+key] = value
|
| |
|
| | ckpt_path = os.path.join(
|
| | self.cfg.log_dir, 'checkpoint_iter'+ str(self.iter).zfill(6) +'.pth')
|
| | gorilla.solver.save_checkpoint(
|
| | model=self.model, filename=ckpt_path, optimizer=self.optimizer, scheduler=self.lr_scheduler, meta={'iter': self.iter, "epoch": self.epoch})
|
| |
|
| | prefix = 'Epoch {} - '.format(self.epoch)
|
| | write_info = self.get_logger_info(prefix, dict_info=dict_info)
|
| | self.logger.warning(write_info)
|
| | self.epoch += 1
|
| |
|
| | def train(self):
|
| | mode = 'train'
|
| | self.model.train()
|
| | end = time.time()
|
| | self.dataloaders["train"].dataset.reset()
|
| |
|
| | for i, data in enumerate(self.dataloaders["train"]):
|
| | torch.cuda.synchronize()
|
| | data_time = time.time()-end
|
| |
|
| | if hasattr(self.cfg, 'warmup_iter') and self.cfg.warmup_iter > 0:
|
| | if self.iter >= self.cfg.warmup_iter:
|
| | optimizer = self.optimizer
|
| | lr_scheduler = self.lr_scheduler
|
| | else:
|
| | optimizer = self.warmup_optimizer
|
| | lr_scheduler = self.warmup_scheduler
|
| | else:
|
| | optimizer = self.optimizer
|
| | lr_scheduler = self.lr_scheduler
|
| |
|
| |
|
| | optimizer.zero_grad()
|
| | loss, dict_info_step = self.step(data, mode)
|
| | dict_info_step['lr'] = lr_scheduler.get_last_lr()[0]
|
| | forward_time = time.time()-end-data_time
|
| |
|
| | loss.backward()
|
| | optimizer.step()
|
| | backward_time = time.time() - end - forward_time-data_time
|
| |
|
| | dict_info_step.update({
|
| | 'T_data': data_time,
|
| | 'T_forward': forward_time,
|
| | 'T_back': backward_time,
|
| | })
|
| | self.log_buffer.update(dict_info_step)
|
| | self.iter += 1
|
| |
|
| | if i % self.iters_to_print == 0:
|
| |
|
| | self.log_buffer.average(self.iters_to_print)
|
| | prefix = 'Iter {} Train - '.format(str(self.iter).zfill(6))
|
| | write_info = self.get_logger_info(
|
| | prefix, dict_info=self.log_buffer._output)
|
| | self.logger.info(write_info)
|
| | self.write_summary(self.log_buffer._output, mode)
|
| | end = time.time()
|
| |
|
| | lr_scheduler.step()
|
| |
|
| | dict_info_epoch = self.log_buffer.avg
|
| | self.log_buffer.clear()
|
| |
|
| | return dict_info_epoch
|
| |
|
| | def evaluate(self):
|
| | mode = 'eval'
|
| | self.model.eval()
|
| |
|
| | for i, data in enumerate(self.dataloaders["eval"]):
|
| | with torch.no_grad():
|
| | _, dict_info_step = self.step(data, mode)
|
| | self.log_buffer.update(dict_info_step)
|
| | if i % self.iters_to_print == 0:
|
| | self.log_buffer.average(self.iters_to_print)
|
| | prefix = '[{}/{}][{}/{}] Test - '.format(
|
| | self.epoch, self.cfg.max_epoch, i, len(self.dataloaders["eval"]))
|
| | write_info = self.get_logger_info(
|
| | prefix, dict_info=self.log_buffer._output)
|
| | self.logger.info(write_info)
|
| | self.write_summary(self.log_buffer._output, mode)
|
| | dict_info_epoch = self.log_buffer.avg
|
| | self.log_buffer.clear()
|
| |
|
| | return dict_info_epoch
|
| |
|
| | def step(self, data, mode):
|
| | torch.cuda.synchronize()
|
| | for key in data:
|
| | data[key] = data[key].cuda()
|
| | if self.coarse_model is not None:
|
| | with torch.no_grad():
|
| | data = self.coarse_model(data)
|
| | end_points = self.model(data)
|
| | dict_info = self.loss(end_points)
|
| | loss_all = dict_info['loss']
|
| |
|
| | for key in dict_info:
|
| | dict_info[key] = float(dict_info[key].item())
|
| |
|
| | return loss_all, dict_info
|
| |
|
| | def get_logger_info(self, prefix, dict_info):
|
| | info = prefix
|
| | for key, value in dict_info.items():
|
| | if 'T_' in key:
|
| | info = info + '{}: {:.3f}\t'.format(key, value)
|
| | elif 'lr' in key:
|
| | info = info + '{}: {:.6f}\t'.format(key, value)
|
| | else:
|
| | info = info + '{}: {:.5f}\t'.format(key, value)
|
| |
|
| | return info
|
| |
|
| | def write_summary(self, dict_info, mode):
|
| | keys = list(dict_info.keys())
|
| | values = list(dict_info.values())
|
| | if mode == "train":
|
| | self.tb_writer.update_scalar(
|
| | list_name=keys, list_value=values, index_counter=0, prefix="train_")
|
| | elif mode == "eval":
|
| | self.tb_writer.update_scalar(
|
| | list_name=keys, list_value=values, index_counter=1, prefix="eval_")
|
| | else:
|
| | assert False
|
| |
|
| |
|
| |
|
| | class tools_writer():
|
| | def __init__(self, dir_project, num_counter, get_sum):
|
| | if not os.path.isdir(dir_project):
|
| | os.makedirs(dir_project)
|
| | if get_sum:
|
| | writer = SummaryWriter(dir_project)
|
| | else:
|
| | writer = None
|
| |
|
| | self.writer = writer
|
| | self.num_counter = num_counter
|
| | self.list_couter = []
|
| | for i in range(num_counter):
|
| | self.list_couter.append(0)
|
| |
|
| | def update_scalar(self, list_name, list_value, index_counter, prefix):
|
| | for name, value in zip(list_name, list_value):
|
| | self.writer.add_scalar(prefix+name, float(value), self.list_couter[index_counter])
|
| |
|
| | self.list_couter[index_counter] += 1
|
| |
|
| | def refresh(self):
|
| | for i in range(self.num_counter):
|
| | self.list_couter[i] = 0
|
| |
|
| |
|
| | def get_logger(level_print, level_save, path_file, name_logger = "logger"):
|
| |
|
| | logger = logging.getLogger(name_logger)
|
| | logger.setLevel(level = logging.DEBUG)
|
| | formatter = logging.Formatter('%(asctime)s - %(message)s')
|
| |
|
| | handler_file = logging.FileHandler(path_file)
|
| | handler_file.setLevel(level_save)
|
| | handler_file.setFormatter(formatter)
|
| | logger.addHandler(handler_file)
|
| |
|
| | handler_view = logging.StreamHandler()
|
| | handler_view.setFormatter(formatter)
|
| | handler_view.setLevel(level_print)
|
| | logger.addHandler(handler_view)
|
| | return logger |
