import torch import util.util as util from models import make_model import time import os import sys from os.path import join from util.visualizer import Visualizer class Engine(object): def __init__(self, opt): self.opt = opt self.writer = None self.visualizer = None self.model = None self.best_val_loss = 1e6 self.__setup() def __setup(self):#private methods prefixed with __ self.basedir = join('checkpoints', self.opt.name) #creating directory path for checkpoint files os.makedirs(self.basedir, exist_ok=True) opt = self.opt """(mingcv)Model""" self.model = make_model(self.opt.model)() #(mingcv)models.__dict__[self.opt.model]() self.model.initialize(opt) if not opt.no_log: # setting up logging and visualisation self.writer = util.get_summary_writer(os.path.join(self.basedir, 'logs')) self.visualizer = Visualizer(opt) def train(self, train_loader, **kwargs): print('\nEpoch: %d' % self.epoch) avg_meters = util.AverageMeters()#generating running averga eof metrics opt = self.opt model = self.model epoch = self.epoch epoch_start_time = time.time() for i, data in enumerate(train_loader): iter_start_time = time.time() iterations = self.iterations model.set_input(data, mode='train') model.optimize_parameters(**kwargs) errors = model.get_current_errors() avg_meters.update(errors) util.progress_bar(i, len(train_loader), str(avg_meters)) if not opt.no_log:#update logging and visualisation every iteration of training util.write_loss(self.writer, 'train', avg_meters, iterations) if iterations % opt.display_freq == 0 and opt.display_id != 0: save_result = iterations % opt.update_html_freq == 0 self.visualizer.display_current_results(model.get_current_visuals(), epoch, save_result) if iterations % opt.print_freq == 0 and opt.display_id != 0: t = (time.time() - iter_start_time) self.iterations += 1 self.epoch += 1 if not self.opt.no_log:# if self.epoch % opt.save_epoch_freq == 0: print('saving the model at epoch %d, iters %d' % (self.epoch, self.iterations)) model.save() print('saving the latest model at the end of epoch %d, iters %d' % (self.epoch, self.iterations)) model.save(label='latest') print('Time Taken: %d sec' % (time.time() - epoch_start_time)) # model.update_learning_rate() try: train_loader.reset() except: pass def eval(self, val_loader, dataset_name, savedir='./tmp', loss_key=None, max_save_size=None, **kwargs): #(mingcv)print(dataset_name) if savedir is not None:# create a directory for saving if not exist os.makedirs(savedir, exist_ok=True) self.f = open(os.path.join(savedir, 'metrics.txt'), 'w+') self.f.write(dataset_name + '\n') avg_meters = util.AverageMeters()#get running average metrics model = self.model opt = self.opt with torch.no_grad():#disable gradient calculation to save memory for i, data in enumerate(val_loader): if opt.selected and data['fn'][0].split('.')[0] not in opt.selected: continue if max_save_size is not None and i > max_save_size: index = model.eval(data, savedir=None, **kwargs) else: index = model.eval(data, savedir=savedir, **kwargs) #(mingcv) print(data['fn'][0], index) if savedir is not None: self.f.write(f"{data['fn'][0]} {index['PSNR']} {index['SSIM']}\n") avg_meters.update(index) util.progress_bar(i, len(val_loader), str(avg_meters)) if not opt.no_log: util.write_loss(self.writer, join('eval', dataset_name), avg_meters, self.epoch) if loss_key is not None: val_loss = avg_meters[loss_key] if val_loss < self.best_val_loss: self.best_val_loss = val_loss print('saving the best model at the end of epoch %d, iters %d' % (self.epoch, self.iterations)) model.save(label='best_{}_{}'.format(loss_key, dataset_name)) return avg_meters def test(self, test_loader, savedir=None, **kwargs): model = self.model opt = self.opt with torch.no_grad(): for i, data in enumerate(test_loader): model.test(data, savedir=savedir, **kwargs) util.progress_bar(i, len(test_loader)) def save_model(self): self.model.save() def save_eval(self, label): self.model.save_eval(label) @property def iterations(self): return self.model.iterations @iterations.setter def iterations(self, i): self.model.iterations = i @property def epoch(self): return self.model.epoch @epoch.setter def epoch(self, e): self.model.epoch = e