Download DSRNet/engine.py from ReflectionEraser/ReflectionEraserApp: direct link, hf CLI and curl.
- Browser
- Download file 5.56 kB
-
https://huggingface.co/spaces/ReflectionEraser/ReflectionEraserApp/resolve/1bf37cc0dbe8b56e2b28656aab54d8fe462a414f/DSRNet/engine.py
- Command line
-
hf download hf://spaces/ReflectionEraser/ReflectionEraserApp@1bf37cc0dbe8b56e2b28656aab54d8fe462a414f/DSRNet/engine.py
-
curl -L -o engine.py https://huggingface.co/spaces/ReflectionEraser/ReflectionEraserApp/resolve/1bf37cc0dbe8b56e2b28656aab54d8fe462a414f/DSRNet/engine.py
5.56 kB
| 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) | |
| def iterations(self): | |
| return self.model.iterations | |
| def iterations(self, i): | |
| self.model.iterations = i | |
| def epoch(self): | |
| return self.model.epoch | |
| def epoch(self, e): | |
| self.model.epoch = e | |