def open_file(value, parent): filetype = {} if options['client.filetype']: if isinstance(options['client.filetype'], str): filetype = eval(options['client.filetype']) else: filetype = options['client.filetype'] root, ext = os.path.splitext(value) cmd = False if ext[1:] in filetype: cmd = filetype[ext[1:]] % (value) if not cmd: cmd = file_selection(_('Open with...'), parent=parent) if cmd: cmd = cmd + ' %s' filetype[ext[1:]] = cmd options['client.filetype'] = filetype options.save() cmd = cmd % (value) if cmd: pid = os.fork() if not pid: pid = os.fork() if not pid: prog, args = cmd.split(' ', 1) args = [os.path.basename(prog)] + args.split(' ') try: os.execvp(prog, args) except: pass time.sleep(0.1) sys.exit(0) os.waitpid(pid, 0)
def main(): # options parser = argparse.ArgumentParser() parser.add_argument('-opt', type=str, required=True, help='Path to option JSON file.') opt = option.parse(parser.parse_args().opt, is_train=True) util.mkdir_and_rename( opt['path']['experiments_root']) # rename old experiments if exists util.mkdirs((path for key, path in opt['path'].items() if not key == 'experiments_root' and \ not key == 'pretrain_model_G' and not key == 'pretrain_model_D')) option.save(opt) opt = option.dict_to_nonedict( opt) # Convert to NoneDict, which return None for missing key. # print to file and std_out simultaneously sys.stdout = PrintLogger(opt['path']['log']) # random seed seed = opt['train']['manual_seed'] if seed is None: seed = random.randint(1, 10000) print("Random Seed: ", seed) random.seed(seed) torch.manual_seed(seed) # create train and val dataloader for phase, dataset_opt in opt['datasets'].items(): if phase == 'train': train_set = create_dataset(dataset_opt) train_size = int( math.ceil(len(train_set) / dataset_opt['batch_size'])) print('Number of train images: {:,d}, iters: {:,d}'.format( len(train_set), train_size)) total_iters = int(opt['train']['niter']) total_epoches = int(math.ceil(total_iters / train_size)) print('Total epoches needed: {:d} for iters {:,d}'.format( total_epoches, total_iters)) train_loader = create_dataloader(train_set, dataset_opt) elif phase == 'val': val_dataset_opt = dataset_opt val_set = create_dataset(dataset_opt) val_loader = create_dataloader(val_set, dataset_opt) print('Number of val images in [{:s}]: {:d}'.format( dataset_opt['name'], len(val_set))) else: raise NotImplementedError( 'Phase [{:s}] is not recognized.'.format(phase)) assert train_loader is not None # Create model model = create_model(opt) # create logger logger = Logger(opt) current_step = 0 start_time = time.time() print('---------- Start training -------------') for epoch in range(total_epoches): for i, train_data in enumerate(train_loader): current_step += 1 if current_step > total_iters: break # training model.feed_data(train_data) model.optimize_parameters(current_step) time_elapsed = time.time() - start_time start_time = time.time() # log if current_step % opt['logger']['print_freq'] == 0: logs = model.get_current_log() print_rlt = OrderedDict() print_rlt['model'] = opt['model'] print_rlt['epoch'] = epoch print_rlt['iters'] = current_step print_rlt['time'] = time_elapsed for k, v in logs.items(): print_rlt[k] = v print_rlt['lr'] = model.get_current_learning_rate() logger.print_format_results('train', print_rlt) # save models if current_step % opt['logger']['save_checkpoint_freq'] == 0: print('Saving the model at the end of iter {:d}.'.format( current_step)) model.save(current_step) # validation if current_step % opt['train']['val_freq'] == 0: print('---------- validation -------------') start_time = time.time() avg_psnr = 0.0 idx = 0 for val_data in val_loader: idx += 1 img_name = os.path.splitext( os.path.basename(val_data['LR_path'][0]))[0] img_dir = os.path.join(opt['path']['val_images'], img_name) util.mkdir(img_dir) model.feed_data(val_data) model.test() visuals = model.get_current_visuals() sr_img = util.tensor2img(visuals['SR']) # uint8 gt_img = util.tensor2img(visuals['HR']) # uint8 # Save SR images for reference save_img_path = os.path.join(img_dir, '{:s}_{:d}.png'.format(\ img_name, current_step)) util.save_img(sr_img, save_img_path) # calculate PSNR if opt['crop_scale'] is not None: crop_size = opt['crop_scale'] else: crop_size = opt['scale'] if crop_size <= 0: cropped_sr_img = sr_img.copy() cropped_gt_img = gt_img.copy() else: if len(gt_img.shape) < 3: cropped_sr_img = sr_img[crop_size:-crop_size, crop_size:-crop_size] cropped_gt_img = gt_img[crop_size:-crop_size, crop_size:-crop_size] else: cropped_sr_img = sr_img[crop_size:-crop_size, crop_size:-crop_size, :] cropped_gt_img = gt_img[crop_size:-crop_size, crop_size:-crop_size, :] #avg_psnr += util.psnr(cropped_sr_img, cropped_gt_img) cropped_sr_img_y = bgr2ycbcr(cropped_sr_img, only_y=True) cropped_gt_img_y = bgr2ycbcr(cropped_gt_img, only_y=True) avg_psnr += util.psnr( cropped_sr_img_y, cropped_gt_img_y) ##########only y channel avg_psnr = avg_psnr / idx time_elapsed = time.time() - start_time # Save to log print_rlt = OrderedDict() print_rlt['model'] = opt['model'] print_rlt['epoch'] = epoch print_rlt['iters'] = current_step print_rlt['time'] = time_elapsed print_rlt['psnr'] = avg_psnr logger.print_format_results('val', print_rlt) print('-----------------------------------') # update learning rate model.update_learning_rate() print('Saving the final model.') model.save('latest') print('End of training.')
# options parser = argparse.ArgumentParser() parser.add_argument('-opt', type=str, required=True, help='Path to options JSON file.') args = parser.parse_args() options_path = args.opt opt = option.parse(options_path, is_train=True) util.mkdir_and_rename( opt['path']['experiments_root']) # rename old experiments if exists util.mkdirs((path for key, path in opt['path'].items() if not key == 'experiments_root' and \ not key == 'pretrain_model_G' and not key == 'pretrain_model_D')) option.save(opt) # save option file to the opt['path']['options'] opt = option.dict_to_nonedict( opt) # Convert to NoneDict, which return None for missing key. # print to file and std_out simultaneously class PrintLogger(object): def __init__(self): self.terminal = sys.stdout self.log = open(os.path.join(opt['path']['log'], 'print_log.txt'), "a") def write(self, message): self.terminal.write(message) self.log.write(message) def flush(self):
def terp_survey(): if options['survey.position']==SURVEY_VERSION: return False def color_set(widget, name): colour = widget.get_colormap().alloc_color(common.colors.get(name,'white')) widget.modify_bg(gtk.STATE_ACTIVE, colour) widget.modify_fg(gtk.STATE_NORMAL, gtk.gdk.color_parse("black")) widget.modify_base(gtk.STATE_NORMAL, colour) widget.modify_text(gtk.STATE_NORMAL, gtk.gdk.color_parse("black")) widget.modify_text(gtk.STATE_INSENSITIVE, gtk.gdk.color_parse("black")) widnames = ('country','role','industry','employee','hear','system','opensource') winglade = glade.XML(common.terp_path("dia_survey.glade"), "dia_survey", gettext.textdomain()) win = winglade.get_widget('dia_survey') parent = service.LocalService('gui.main').window win.set_transient_for(parent) win.set_icon(OPENERP_ICON) for widname in widnames: wid = winglade.get_widget('combo_'+widname) wid.child.set_editable(False) email_widget = winglade.get_widget('entry_email') want_ebook_widget = winglade.get_widget('check_button_ebook') def toggled_cb(togglebutton, *args): value = togglebutton.get_active() color_set(email_widget, ('normal', 'required')[value]) want_ebook_widget.connect('toggled', toggled_cb) while True: res = win.run() if res == gtk.RESPONSE_OK: email = email_widget.get_text() want_ebook = want_ebook_widget.get_active() if want_ebook and not len(email): color_set(email_widget, 'invalid') else: company = winglade.get_widget('entry_company').get_text() phone = winglade.get_widget('entry_phone').get_text() name = winglade.get_widget('entry_name').get_text() city = winglade.get_widget('entry_city').get_text() result = "\ncompany: "+str(company) result += "\nname: " + str(name) result += "\nphone: " + str(phone) result += "\ncity: " + str(city) for widname in widnames: wid = winglade.get_widget('combo_'+widname) result += "\n" + widname + ": " + wid.child.get_text() result += "\nplan_use: " + str(winglade.get_widget('check_use').get_active()) result += "\nplan_sell: " + str(winglade.get_widget('check_sell').get_active()) result += "\nwant_ebook: " + str(want_ebook) buffer = winglade.get_widget('textview_comment').get_buffer() iter_start = buffer.get_start_iter() iter_end = buffer.get_end_iter() result += "\nnote: " + buffer.get_text(iter_start, iter_end, False) upload_data(email, result, type='SURVEY '+str(SURVEY_VERSION)) options['survey.position']=SURVEY_VERSION options.save() parent.present() win.destroy() common.message(_('Thank you for the feedback !\n\ Your comments have been sent to OpenERP.\n\ You should now start by creating a new database or\n\ connecting to an existing server through the "File" menu.')) break elif res == gtk.RESPONSE_CANCEL or gtk.RESPONSE_DELETE_EVENT: parent.present() win.destroy() common.message(_('Thank you for testing OpenERP !\n\ You should now start by creating a new database or\n\ connecting to an existing server through the "File" menu.')) break return True
def main(): # os.environ['CUDA_VISIBLE_DEVICES']='1' # You can specify your GPU device here. parser = argparse.ArgumentParser(description='Train Super Resolution Models') parser.add_argument('-opt', type=str, required=True, help='Path to options JSON file.') opt = option.parse(parser.parse_args().opt) if opt['train']['resume'] is False: util.mkdir_and_rename(opt['path']['exp_root']) # rename old experiments if exists util.mkdirs((path for key, path in opt['path'].items() if not key == 'exp_root' and \ not key == 'pretrain_G' and not key == 'pretrain_D')) option.save(opt) opt = option.dict_to_nonedict(opt) # Convert to NoneDict, which return None for missing key. else: opt = option.dict_to_nonedict(opt) if opt['train']['resume_path'] is None: raise ValueError("The 'resume_path' does not declarate") if opt['exec_debug']: NUM_EPOCH = 100 opt['datasets']['train']['dataroot_HR'] = opt['datasets']['train']['dataroot_HR_debug'] opt['datasets']['train']['dataroot_LR'] = opt['datasets']['train']['dataroot_LR_debug'] else: NUM_EPOCH = int(opt['train']['num_epochs']) # random seed seed = opt['train']['manual_seed'] if seed is None: seed = random.randint(1, 10000) print("Random Seed: ", seed) random.seed(seed) torch.manual_seed(seed) # create train and val dataloader for phase, dataset_opt in opt['datasets'].items(): if phase == 'train': train_set = create_dataset(dataset_opt) train_loader = create_dataloader(train_set, dataset_opt) print('Number of train images in [%s]: %d' % (dataset_opt['name'], len(train_set))) elif phase == 'val': val_set = create_dataset(dataset_opt) val_loader = create_dataloader(val_set, dataset_opt) print('Number of val images in [%s]: %d' % (dataset_opt['name'], len(val_set))) elif phase == 'test': pass else: raise NotImplementedError("Phase [%s] is not recognized." % phase) if train_loader is None: raise ValueError("The training data does not exist") if opt['mode'] == 'sr': solver = SRModel(opt) else: assert 'Invalid opt.mode [%s] for SRModel class!' solver.summary(train_set[0]['LR'].size()) solver.net_init() print('[Start Training]') start_time = time.time() start_epoch = 1 if opt['train']['resume']: start_epoch = solver.load() for epoch in range(start_epoch, NUM_EPOCH + 1): # Initialization solver.training_loss = 0.0 epoch_loss_log = 0.0 if opt['mode'] == 'sr' : training_results = {'batch_size': 0, 'training_loss': 0.0} else: pass # TODO train_bar = tqdm(train_loader) # Train model for iter, batch in enumerate(train_bar): solver.feed_data(batch) iter_loss = solver.train_step() epoch_loss_log += iter_loss.item() batch_size = batch['LR'].size(0) training_results['batch_size'] += batch_size if opt['mode'] == 'sr': training_results['training_loss'] += iter_loss * batch_size train_bar.set_description(desc='[%d/%d] Loss: %.4f ' % ( epoch, NUM_EPOCH, iter_loss)) else: pass # TODO solver.last_epoch_loss = epoch_loss_log / (len(train_bar)) train_bar.close() time_elapse = time.time() - start_time start_time = time.time() print('Train Loss: %.4f' % (training_results['training_loss'] / training_results['batch_size'])) # validate val_results = {'batch_size': 0, 'val_loss': 0.0, 'psnr': 0.0, 'ssim': 0.0} if epoch % solver.val_step == 0 and epoch != 0: print('[Validating...]') start_time = time.time() solver.val_loss = 0.0 vis_index = 1 for iter, batch in enumerate(val_loader): visuals_list = [] solver.feed_data(batch) iter_loss = solver.test(opt['chop']) batch_size = batch['LR'].size(0) val_results['batch_size'] += batch_size visuals = solver.get_current_visual() # float cpu tensor sr_img = np.transpose(util.quantize(visuals['SR'], opt['rgb_range']).numpy(), (1,2,0)).astype(np.uint8) gt_img = np.transpose(util.quantize(visuals['HR'], opt['rgb_range']).numpy(), (1,2,0)).astype(np.uint8) # calculate PSNR crop_size = opt['scale'] cropped_sr_img = sr_img[crop_size:-crop_size, crop_size:-crop_size, :] cropped_gt_img = gt_img[crop_size:-crop_size, crop_size:-crop_size, :] val_results['val_loss'] += iter_loss * batch_size val_results['psnr'] += util.calc_psnr(cropped_sr_img, cropped_gt_img) val_results['ssim'] += util.calc_ssim(cropped_sr_img, cropped_gt_img) if opt['mode'] == 'srgan': pass # TODO visuals_list.extend([util.quantize(visuals['HR'].squeeze(0), opt['rgb_range']), util.quantize(visuals['SR'].squeeze(0), opt['rgb_range'])]) images = torch.stack(visuals_list) img = thutil.make_grid(images, nrow=2, padding=5) ndarr = img.byte().permute(1, 2, 0).numpy() misc.imsave(os.path.join(solver.vis_dir, 'epoch_%d_%d.png' % (epoch, vis_index)), ndarr) vis_index += 1 avg_psnr = val_results['psnr']/val_results['batch_size'] avg_ssim = val_results['ssim']/val_results['batch_size'] print('Valid Loss: %.4f | Avg. PSNR: %.4f | Avg. SSIM: %.4f | Learning Rate: %f'%(val_results['val_loss']/val_results['batch_size'], avg_psnr, avg_ssim, solver.current_learning_rate())) time_elapse = start_time - time.time() #if epoch%solver.log_step == 0 and epoch != 0: # tensorboard visualization solver.training_loss = training_results['training_loss'] / training_results['batch_size'] solver.val_loss = val_results['val_loss'] / val_results['batch_size'] solver.tf_log(epoch) # statistics if opt['mode'] == 'sr' : solver.results['training_loss'].append(solver.training_loss.cpu().data.item()) solver.results['val_loss'].append(solver.val_loss.cpu().data.item()) solver.results['psnr'].append(avg_psnr) solver.results['ssim'].append(avg_ssim) else: pass # TODO is_best = False if solver.best_prec < solver.results['psnr'][-1]: solver.best_prec = solver.results['psnr'][-1] is_best = True solver.save(epoch, is_best) # update lr solver.update_learning_rate(epoch) data_frame = pd.DataFrame( data={'training_loss': solver.results['training_loss'] , 'val_loss': solver.results['val_loss'] , 'psnr': solver.results['psnr'] , 'ssim': solver.results['ssim'] }, index=range(1, NUM_EPOCH+1) ) data_frame.to_csv(os.path.join(solver.results_dir, 'train_results.csv'), index_label='Epoch')
def main(): # options parser = argparse.ArgumentParser() parser.add_argument('-opt', type=str, required=True, help='Path to option JSON file.') opt = option.parse(parser.parse_args().opt, is_train=True) util.mkdir_and_rename( opt['path']['experiments_root']) # rename old experiments if exists util.mkdirs((path for key, path in opt['path'].items() if not key == 'experiments_root' and \ not key == 'pretrain_model_G' and not key == 'pretrain_model_D')) option.save(opt) opt = option.dict_to_nonedict( opt) # Convert to NoneDict, which return None for missing key. # print to file and std_out simultaneously sys.stdout = PrintLogger(opt['path']['log']) # random seed seed = opt['train']['manual_seed'] if seed is None: seed = random.randint(1, 10000) print("Random Seed: ", seed) random.seed(seed) torch.manual_seed(seed) # create train and val dataloader for phase, dataset_opt in opt['datasets'].items(): if phase == 'train': train_set = create_dataset(dataset_opt) train_size = int( math.ceil(len(train_set) / dataset_opt['batch_size'])) print('Number of train images: {:,d}, iters: {:,d}'.format( len(train_set), train_size)) total_iters = int(opt['train']['niter']) total_epoches = int(math.ceil(total_iters / train_size)) print('Total epoches needed: {:d} for iters {:,d}'.format( total_epoches, total_iters)) train_loader = create_dataloader(train_set, dataset_opt) batch_size_per_month = dataset_opt['batch_size'] batch_size_per_day = int( opt['datasets']['train']['batch_size_per_day']) num_month = int(opt['train']['num_month']) num_day = int(opt['train']['num_day']) elif phase == 'val': val_dataset_opt = dataset_opt val_set = create_dataset(dataset_opt) val_loader = create_dataloader(val_set, dataset_opt) print('Number of val images in [{:s}]: {:d}'.format( dataset_opt['name'], len(val_set))) else: raise NotImplementedError( 'Phase [{:s}] is not recognized.'.format(phase)) assert train_loader is not None # Create model model = create_model(opt) # create logger logger = Logger(opt) current_step = 0 start_time = time.time() print('---------- Start training -------------') validate(val_loader, opt, model, current_step, 0, logger) for epoch in range(num_month): for i, train_data in enumerate(train_loader): cur_month_code = get_code_for_data_two(model, train_data, opt) for j in range(num_day): current_step += 1 # get the sliced data cur_day_batch_start_idx = ( j * batch_size_per_day) % batch_size_per_month cur_day_batch_end_idx = cur_day_batch_start_idx + batch_size_per_day if cur_day_batch_end_idx > batch_size_per_month: cur_day_batch_idx = np.hstack( (np.arange(cur_day_batch_start_idx, batch_size_per_month), np.arange(cur_day_batch_end_idx - batch_size_per_month))) else: cur_day_batch_idx = slice(cur_day_batch_start_idx, cur_day_batch_end_idx) cur_day_train_data = { 'LR': train_data['LR'][cur_day_batch_idx], 'HR': train_data['HR'][cur_day_batch_idx] } code = [] for gen_code in cur_month_code: code.append(gen_code[cur_day_batch_idx]) # training model.feed_data(cur_day_train_data, code=code) model.optimize_parameters(current_step) time_elapsed = time.time() - start_time start_time = time.time() # log if current_step % opt['logger']['print_freq'] == 0: logs = model.get_current_log() print_rlt = OrderedDict() print_rlt['model'] = opt['model'] print_rlt['epoch'] = epoch print_rlt['iters'] = current_step print_rlt['time'] = time_elapsed for k, v in logs.items(): print_rlt[k] = v print_rlt['lr'] = model.get_current_learning_rate() logger.print_format_results('train', print_rlt) # save models if current_step % opt['logger']['save_checkpoint_freq'] == 0: print('Saving the model at the end of iter {:d}.'.format( current_step)) model.save(current_step) # validation if current_step % opt['train']['val_freq'] == 0: validate(val_loader, opt, model, current_step, epoch, logger) # update learning rate model.update_learning_rate() print('Saving the final model.') model.save('latest') print('End of training.')
def main(): # options parser = argparse.ArgumentParser() parser.add_argument('-opt', type=str, required=True, help='Path to option JSON file.') parser.add_argument('-single_GPU', action='store_true',help='Utilize only one GPU') parser.add_argument('-chroma', action='store_true',help='Training the chroma-channels generator') if parser.parse_args().single_GPU: available_GPUs = util.Assign_GPU(maxMemory=0.66) else: # available_GPUs = util.Assign_GPU(max_GPUs=None,maxMemory=0.8,maxLoad=0.8) available_GPUs = util.Assign_GPU(max_GPUs=None) opt = option.parse(parser.parse_args().opt, is_train=True,batch_size_multiplier=len(available_GPUs),name='JPEG'+('_chroma' if parser.parse_args().chroma else '')) if not opt['train']['resume']: util.mkdir_and_rename(opt['path']['experiments_root']) # Modify experiment name if exists util.mkdirs((path for key, path in opt['path'].items() if not key == 'experiments_root' and \ not key == 'pretrained_model_G' and not key == 'pretrained_model_D')) option.save(opt) opt = option.dict_to_nonedict(opt) # Convert to NoneDict, which return None for missing key. # print to file and std_out simultaneously sys.stdout = PrintLogger(opt['path']['log']) # random seed seed = opt['train']['manual_seed'] if seed is None: seed = random.randint(1, 10000) print("Random Seed: ", seed) random.seed(seed) torch.manual_seed(seed) # create train and val dataloader for phase, dataset_opt in opt['datasets'].items(): if phase == 'train': max_accumulation_steps = max([opt['train']['grad_accumulation_steps_G'], opt['train']['grad_accumulation_steps_D']]) train_set = create_dataset(dataset_opt) train_size = int(math.ceil(len(train_set) / dataset_opt['batch_size'])) print('Number of train images: {:,d}, iters: {:,d}'.format(len(train_set), train_size)) total_iters = int(opt['train']['niter']*max_accumulation_steps)#-current_step total_epoches = int(math.ceil(total_iters / train_size)) print('Total epoches needed: {:d} for iters {:,d}'.format(total_epoches, total_iters)) train_loader = create_dataloader(train_set, dataset_opt) elif phase == 'val': val_dataset_opt = dataset_opt val_set = create_dataset(dataset_opt) val_loader = create_dataloader(val_set, dataset_opt) print('Number of val images in [{:s}]: {:d}'.format(dataset_opt['name'], len(val_set))) else: raise NotImplementedError('Phase [{:s}] is not recognized.'.format(phase)) assert train_loader is not None DEBUG = False # Create model if DEBUG: from models.base_model import BaseModel model = BaseModel model.step = 0 else: model = create_model(opt,max_accumulation_steps,chroma_mode=opt['name'][:len('JPEG/chroma')]=='JPEG/chroma') # create logger logger = Logger(opt) # Save validation set results as image collage: SAVE_IMAGE_COLLAGE = True start_time,start_time_gradient_step = time.time(),model.step // max_accumulation_steps save_GT_Uncomp = True lr_too_low = False print('---------- Start training -------------') last_saving_time = time.time() recently_saved_models = deque(maxlen=4) for epoch in range(int(math.floor(model.step / train_size)),total_epoches): for i, train_data in enumerate(train_loader): model.gradient_step_num = model.step // max_accumulation_steps not_within_batch = model.step % max_accumulation_steps == (max_accumulation_steps - 1) saving_step = ((time.time()-last_saving_time)>60*opt['logger']['save_checkpoint_freq']) and not_within_batch if saving_step: last_saving_time = time.time() # save models if lr_too_low or saving_step: model.save_log() recently_saved_models.append(model.save(model.gradient_step_num)) if len(recently_saved_models)>3: model_2_delete = recently_saved_models.popleft() os.remove(model_2_delete) if model.D_exists: os.remove(model_2_delete.replace('_G.','_D.')) print('{}: Saving the model before iter {:d}.'.format(datetime.now().strftime('%H:%M:%S'),model.gradient_step_num)) if lr_too_low: break if model.step > total_iters: break # time_elapsed = time.time() - start_time # if not_within_batch: start_time = time.time() # log if model.gradient_step_num % opt['logger']['print_freq'] == 0 and not_within_batch: logs = model.get_current_log() print_rlt = OrderedDict() print_rlt['model'] = opt['model'] print_rlt['epoch'] = epoch print_rlt['iters'] = model.gradient_step_num # time_elapsed = time.time() - start_time print_rlt['time'] = (time.time() - start_time)/np.maximum(1,model.gradient_step_num-start_time_gradient_step) start_time, start_time_gradient_step = time.time(), model.gradient_step_num for k, v in logs.items(): print_rlt[k] = v print_rlt['lr'] = model.get_current_learning_rate() logger.print_format_results('train', print_rlt,keys_ignore_list=['avg_est_err']) model.display_log_figure() # validation if (not_within_batch or i==0) and (model.gradient_step_num) % opt['train']['val_freq'] == 0: # and model.gradient_step_num>=opt['train']['D_init_iters']: print_rlt = OrderedDict() if model.generator_changed: print('---------- validation -------------') start_time = time.time() if False and SAVE_IMAGE_COLLAGE and model.gradient_step_num%opt['train']['val_save_freq'] == 0: #Saving training images: # GT_image_collage,quantized_image_collage = [],[] cur_train_results = model.get_current_visuals(entire_batch=True) train_psnrs = [util.calculate_psnr(util.tensor2img(cur_train_results['Decomp'][im_num], out_type=np.uint8,min_max=[0,255]), util.tensor2img(cur_train_results['Uncomp'][im_num], out_type=np.uint8,min_max=[0,255])) for im_num in range(len(cur_train_results['Decomp']))] #Save latest training batch output: save_img_path = os.path.join(os.path.join(opt['path']['val_images']), '{:d}_Tr_PSNR{:.3f}.png'.format(model.gradient_step_num, np.mean(train_psnrs))) util.save_img(np.clip(np.concatenate((np.concatenate([util.tensor2img(cur_train_results['Uncomp'][im_num], out_type=np.uint8,min_max=[0,255]) for im_num in range(len(cur_train_results['Decomp']))],0), np.concatenate( [util.tensor2img(cur_train_results['Decomp'][im_num], out_type=np.uint8,min_max=[0,255]) for im_num in range(len(cur_train_results['Decomp']))], 0)), 1), 0, 255).astype(np.uint8), save_img_path) Z_latent = [0]+([-0.5,0.5] if opt['network_G']['latent_input'] else []) print_rlt['psnr'] = 0 for cur_Z in Z_latent: model.perform_validation(data_loader=val_loader,cur_Z=cur_Z,print_rlt=print_rlt,GT_and_quantized=save_GT_Uncomp, save_images=((model.gradient_step_num) % opt['train']['val_save_freq'] == 0) or save_GT_Uncomp) if save_GT_Uncomp: # Save GT Uncomp images save_GT_Uncomp = False print_rlt['psnr'] /= len(Z_latent) model.log_dict['psnr_val'].append((model.gradient_step_num,print_rlt['psnr'])) else: print('Skipping validation because generator is unchanged') # time_elapsed = time.time() - start_time # Save to log print_rlt['model'] = opt['model'] print_rlt['epoch'] = epoch print_rlt['iters'] = model.gradient_step_num # print_rlt['time'] = time_elapsed print_rlt['time'] = (time.time() - start_time)/np.maximum(1,model.gradient_step_num-start_time_gradient_step) # model.display_log_figure() # model.generator_changed = False logger.print_format_results('val', print_rlt,keys_ignore_list=['avg_est_err']) print('-----------------------------------') model.feed_data(train_data,mixed_Y=True) model.optimize_parameters() # update learning rate if not_within_batch: lr_too_low = model.update_learning_rate(model.gradient_step_num) # current_step += 1 if lr_too_low: print('Stopping training because LR is too low') break print('Saving the final model.') model.save(model.gradient_step_num) model.save_log() print('End of training.')
def main(): # options parser = argparse.ArgumentParser() parser.add_argument('-opt', type=str, required=True, help='Path to option JSON file.') parser.add_argument('-single_GPU', action='store_true', help='Utilize only one GPU') if parser.parse_args().single_GPU: available_GPUs = util.Assign_GPU() else: available_GPUs = util.Assign_GPU(max_GPUs=None) opt = option.parse(parser.parse_args().opt, is_train=True, batch_size_multiplier=len(available_GPUs)) if not opt['train']['resume']: util.mkdir_and_rename( opt['path'] ['experiments_root']) # Modify experiment name if exists util.mkdirs((path for key, path in opt['path'].items() if not key == 'experiments_root' and \ not key == 'pretrained_model_G' and not key == 'pretrained_model_D')) option.save(opt) opt = option.dict_to_nonedict( opt) # Convert to NoneDict, which return None for missing key. # print to file and std_out simultaneously sys.stdout = PrintLogger(opt['path']['log']) # random seed seed = opt['train']['manual_seed'] if seed is None: seed = random.randint(1, 10000) print("Random Seed: ", seed) random.seed(seed) torch.manual_seed(seed) # create train and val dataloader for phase, dataset_opt in opt['datasets'].items(): if phase == 'train': max_accumulation_steps = max([ opt['train']['grad_accumulation_steps_G'], opt['train']['grad_accumulation_steps_D'] ]) train_set = create_dataset(dataset_opt) train_size = int( math.ceil(len(train_set) / dataset_opt['batch_size'])) print('Number of train images: {:,d}, iters: {:,d}'.format( len(train_set), train_size)) total_iters = int(opt['train']['niter'] * max_accumulation_steps) #-current_step total_epoches = int(math.ceil(total_iters / train_size)) print('Total epoches needed: {:d} for iters {:,d}'.format( total_epoches, total_iters)) train_loader = create_dataloader(train_set, dataset_opt) elif phase == 'val': val_dataset_opt = dataset_opt val_set = create_dataset(dataset_opt) val_loader = create_dataloader(val_set, dataset_opt) print('Number of val images in [{:s}]: {:d}'.format( dataset_opt['name'], len(val_set))) else: raise NotImplementedError( 'Phase [{:s}] is not recognized.'.format(phase)) assert train_loader is not None # Create model if max_accumulation_steps != 1: model = create_model(opt, max_accumulation_steps) else: model = create_model(opt) # create logger logger = Logger(opt) # Save validation set results as image collage: SAVE_IMAGE_COLLAGE = True per_image_saved_patch = min( [min(im['HR'].shape[1:]) for im in val_loader.dataset]) - 2 num_val_images = len(val_loader.dataset) val_images_collage_rows = int(np.floor(np.sqrt(num_val_images))) while val_images_collage_rows > 1: if np.round(num_val_images / val_images_collage_rows ) == num_val_images / val_images_collage_rows: break val_images_collage_rows -= 1 start_time = time.time() min_accumulation_steps = min([ opt['train']['grad_accumulation_steps_G'], opt['train']['grad_accumulation_steps_D'] ]) save_GT_HR = True lr_too_low = False print('---------- Start training -------------') last_saving_time = time.time() recently_saved_models = deque(maxlen=4) for epoch in range(int(math.floor(model.step / train_size)), total_epoches): for i, train_data in enumerate(train_loader): gradient_step_num = model.step // max_accumulation_steps not_within_batch = model.step % max_accumulation_steps == ( max_accumulation_steps - 1) saving_step = ( (time.time() - last_saving_time) > 60 * opt['logger']['save_checkpoint_freq']) and not_within_batch if saving_step: last_saving_time = time.time() # save models if lr_too_low or saving_step: recently_saved_models.append(model.save(gradient_step_num)) model.save_log() if len(recently_saved_models) > 3: model_2_delete = recently_saved_models.popleft() os.remove(model_2_delete) if model.D_exists: os.remove(model_2_delete.replace('_G.', '_D.')) print('{}: Saving the model before iter {:d}.'.format( datetime.now().strftime('%H:%M:%S'), gradient_step_num)) if lr_too_low: break if model.step > total_iters: break # training model.feed_data(train_data) model.optimize_parameters() if not model.D_exists: #Avoid using the naive MultiLR scheduler when using adversarial loss for scheduler in model.schedulers: scheduler.step(model.gradient_step_num) time_elapsed = time.time() - start_time if not_within_batch: start_time = time.time() # log if gradient_step_num % opt['logger'][ 'print_freq'] == 0 and not_within_batch: logs = model.get_current_log() print_rlt = OrderedDict() print_rlt['model'] = opt['model'] print_rlt['epoch'] = epoch print_rlt['iters'] = gradient_step_num print_rlt['time'] = time_elapsed for k, v in logs.items(): print_rlt[k] = v print_rlt['lr'] = model.get_current_learning_rate() logger.print_format_results('train', print_rlt, keys_ignore_list=IGNORED_KEYS_LIST) model.display_log_figure() # validation if not_within_batch and (gradient_step_num) % opt['train'][ 'val_freq'] == 0: # and gradient_step_num>=opt['train']['D_init_iters']: print_rlt = OrderedDict() if model.generator_changed: print('---------- validation -------------') start_time = time.time() if False and SAVE_IMAGE_COLLAGE and model.gradient_step_num % opt[ 'train'][ 'val_save_freq'] == 0: #Saving training images: GT_image_collage = [] cur_train_results = model.get_current_visuals( entire_batch=True) train_psnrs = [ util.calculate_psnr( util.tensor2img( cur_train_results['SR'][im_num], out_type=np.float32) * 255, util.tensor2img( cur_train_results['HR'][im_num], out_type=np.float32) * 255) for im_num in range(len(cur_train_results['SR'])) ] #Save latest training batch output: save_img_path = os.path.join( os.path.join(opt['path']['val_images']), '{:d}_Tr_PSNR{:.3f}.png'.format( gradient_step_num, np.mean(train_psnrs))) util.save_img( np.clip( np.concatenate( (np.concatenate([ util.tensor2img( cur_train_results['HR'][im_num], out_type=np.float32) * 255 for im_num in range( len(cur_train_results['SR'])) ], 0), np.concatenate([ util.tensor2img( cur_train_results['SR'][im_num], out_type=np.float32) * 255 for im_num in range( len(cur_train_results['SR'])) ], 0)), 1), 0, 255).astype(np.uint8), save_img_path) Z_latent = [0] + ([-1, 1] if opt['network_G']['latent_input'] else []) print_rlt['psnr'] = 0 for cur_Z in Z_latent: sr_images = model.perform_validation( data_loader=val_loader, cur_Z=cur_Z, print_rlt=print_rlt, save_GT_HR=save_GT_HR, save_images=((model.gradient_step_num) % opt['train']['val_save_freq'] == 0) or save_GT_HR) if logger.use_tb_logger: logger.tb_logger.log_images( 'validation_Z%.2f' % (cur_Z), [im[:, :, [2, 1, 0]] for im in sr_images], model.gradient_step_num) if save_GT_HR: # Save GT Uncomp images save_GT_HR = False model.log_dict['psnr_val'].append( (gradient_step_num, print_rlt['psnr'] / len(Z_latent))) else: print('Skipping validation because generator is unchanged') time_elapsed = time.time() - start_time # Save to log print_rlt['model'] = opt['model'] print_rlt['epoch'] = epoch print_rlt['iters'] = gradient_step_num print_rlt['time'] = time_elapsed model.display_log_figure() logger.print_format_results('val', print_rlt, keys_ignore_list=IGNORED_KEYS_LIST) print('-----------------------------------') # update learning rate if not_within_batch: lr_too_low = model.update_learning_rate(gradient_step_num) if lr_too_low: print('Stopping training because LR is too low') break print('Saving the final model.') model.save(gradient_step_num) print('End of training.')
def main(): parser = argparse.ArgumentParser( description='Train Super Resolution Models') parser.add_argument('-opt', type=str, required=True, help='Path to options JSON file.') opt = option.parse(parser.parse_args().opt) if opt['train']['resume'] is False: util.mkdir_and_rename( opt['path']['exp_root']) # rename old experiments if exists util.mkdirs((path for key, path in opt['path'].items() if not key == 'exp_root' and \ not key == 'pretrain_G' and not key == 'pretrain_D')) option.save(opt) opt = option.dict_to_nonedict( opt) # Convert to NoneDict, which return None for missing key. else: opt = option.dict_to_nonedict(opt) if opt['train']['resume_path'] is None: raise ValueError("The 'resume_path' does not declarate") NUM_EPOCH = int(opt['train']['num_epochs']) # random seed seed = opt['train']['manual_seed'] if seed is None: seed = random.randint(1, 10000) print("Random Seed: ", seed) random.seed(seed) torch.manual_seed(seed) # create train and val dataloader for phase, dataset_opt in opt['datasets'].items(): if phase == 'train': train_set = create_dataset(dataset_opt) train_loader = create_dataloader(train_set, dataset_opt) print('Number of train images in [%s]: %d' % (dataset_opt['name'], len(train_set))) elif phase == 'val': val_set = create_dataset(dataset_opt) val_loader = create_dataloader(val_set, dataset_opt) print('Number of val images in [%s]: %d' % (dataset_opt['name'], len(val_set))) elif phase == 'test': pass else: raise NotImplementedError("Phase [%s] is not recognized." % phase) if train_loader is None: raise ValueError("The training data does not exist") solver = RCGANModel(opt) solver.summary(train_set[0]['CAT'].size(), train_set[0]['IR'].size()) solver.net_init() print('[Start Training]') start_epoch = 1 if opt['train']['resume']: start_epoch = solver.load() for epoch in range(start_epoch, NUM_EPOCH + 1): # Initialization train_loss_g1 = 0.0 train_loss_g2 = 0.0 train_loss_d1 = 0.0 train_loss_d2 = 0.0 train_bar = tqdm(train_loader) # Train model for iter, batch in enumerate(train_bar): solver.feed_data(batch) loss_g_total, loss_d_total = solver.train_step() cur_batch_size = batch['CAT'].size(0) train_loss_g1 += loss_g_total[0] * cur_batch_size train_loss_g2 += loss_g_total[1] * cur_batch_size train_loss_d1 += loss_d_total[0] * cur_batch_size train_loss_d2 += loss_d_total[1] * cur_batch_size train_bar.set_description( desc='[%d/%d] G-Loss: %.4f D-Loss: %.4f' % (epoch, NUM_EPOCH, loss_g_total[0] + loss_g_total[1], loss_d_total[0] + loss_d_total[1])) solver.results['train_G_loss1'].append(train_loss_g1 / len(train_set)) solver.results['train_G_loss2'].append(train_loss_g2 / len(train_set)) solver.results['train_D_loss1'].append(train_loss_d1 / len(train_set)) solver.results['train_D_loss2'].append(train_loss_d2 / len(train_set)) print('Train G-Loss: %.4f' % ((train_loss_g1 + train_loss_g2) / len(train_set))) print('Train D-Loss: %.4f' % ((train_loss_d1 + train_loss_d2) / len(train_set))) train_bar.close() if epoch % solver.val_step == 0 and epoch != 0: print('[Validating...]') vis_index = 1 val_loss = 0.0 for iter, batch in enumerate(val_loader): solver.feed_data(batch) loss_total = solver.test() batch_size = batch['VIS'].size(0) vis_list = solver.get_current_visual_list() images = torch.stack(vis_list) saveimg = thutil.make_grid(images, nrow=3, padding=5) saveimg_nd = saveimg.byte().permute(1, 2, 0).numpy() misc.imsave( os.path.join(solver.vis_dir, 'epoch_%d_%d.png' % (epoch, vis_index)), saveimg_nd) vis_index += 1 val_loss += loss_total * batch_size solver.results['val_G_loss'].append(val_loss / len(val_set)) print('Valid Loss: %.4f' % (val_loss / len(val_set))) # statistics is_best = False if solver.best_prec > solver.results['val_G_loss'][-1]: solver.best_prec = solver.results['val_G_loss'][-1] is_best = True solver.save(epoch, is_best) data_frame = pd.DataFrame(data={ 'train_G_loss1': solver.results['train_G_loss1'], 'train_G_loss2': solver.results['train_G_loss2'], 'train_D_loss1': solver.results['train_D_loss1'], 'train_D_loss2': solver.results['train_D_loss2'], 'val_G_loss': solver.results['val_G_loss'] }, index=range(1, NUM_EPOCH + 1)) data_frame.to_csv(os.path.join(solver.results_dir, 'train_results.csv'), index_label='Epoch')
def main(): # os.environ['CUDA_VISIBLE_DEVICES']="1" # You can specify your GPU device here. I failed to perform it by `torch.cuda.set_device()`. parser = argparse.ArgumentParser( description='Train Super Resolution Models') parser.add_argument('-opt', type=str, required=True, help='Path to options JSON file.') opt = option.parse(parser.parse_args().opt) if opt['train']['resume'] is False: util.mkdir_and_rename( opt['path']['exp_root']) # rename old experiments if exists util.mkdirs((path for key, path in opt['path'].items() if not key == 'exp_root' and \ not key == 'pretrain_G' and not key == 'pretrain_D')) option.save(opt) opt = option.dict_to_nonedict( opt) # Convert to NoneDict, which return None for missing key. else: opt = option.dict_to_nonedict(opt) if opt['train']['resume_path'] is None: raise ValueError("The 'resume_path' does not declarate") if opt['exec_debug']: NUM_EPOCH = 100 opt['datasets']['train']['dataroot_HR'] = opt['datasets']['train'][ 'dataroot_HR_debug'] #"./dataset/TrainData/DIV2K_train_HR_sub", opt['datasets']['train']['dataroot_LR'] = opt['datasets']['train'][ 'dataroot_LR_debug'] #./dataset/TrainData/DIV2K_train_HR_sub_LRx3" else: NUM_EPOCH = int(opt['train']['num_epochs']) # random seed seed = opt['train']['manual_seed'] #0 if seed is None: seed = random.randint(1, 10000) print("Random Seed: ", seed) random.seed(seed) torch.manual_seed(seed) # create train and val dataloader for phase, dataset_opt in opt['datasets'].items(): if phase == 'train': train_set = create_dataset(dataset_opt) train_loader = create_dataloader(train_set, dataset_opt) print('Number of train images in [%s]: %d' % (dataset_opt['name'], len(train_set))) elif phase == 'val': val_set = create_dataset(dataset_opt) val_loader = create_dataloader(val_set, dataset_opt) print('Number of val images in [%s]: %d' % (dataset_opt['name'], len(val_set))) elif phase == 'test': pass else: raise NotImplementedError("Phase [%s] is not recognized." % phase) if train_loader is None: raise ValueError("The training data does not exist") # TODO: design an exp that can obtain the location of the biggest error if opt['mode'] == 'sr': solver = SRModel1(opt) elif opt['mode'] == 'fi': solver = SRModel1(opt) elif opt['mode'] == 'srgan': solver = SRModelGAN(opt) elif opt['mode'] == 'msan': solver = SRModel1(opt) elif opt['mode'] == 'sr_curriculum': solver = SRModelCurriculum(opt) solver.summary(train_set[0]['LR'].size()) solver.net_init() print('[Start Training]') start_time = time.time() start_epoch = 1 if opt['train']['resume']: start_epoch = solver.load() for epoch in range(start_epoch, NUM_EPOCH + 1): # Initialization solver.training_loss = 0.0 epoch_loss_log = 0.0 if opt['mode'] == 'sr' or opt['mode'] == 'srgan' or opt[ 'mode'] == 'sr_curriculum' or opt['mode'] == 'fi' or opt[ 'mode'] == 'msan': training_results = {'batch_size': 0, 'training_loss': 0.0} else: pass # TODO train_bar = tqdm(train_loader) # Train model for iter, batch in enumerate(train_bar): solver.feed_data(batch) iter_loss = solver.train_step() epoch_loss_log += iter_loss.item() batch_size = batch['LR'].size(0) training_results['batch_size'] += batch_size if opt['mode'] == 'sr': training_results['training_loss'] += iter_loss * batch_size train_bar.set_description(desc='[%d/%d] Loss: %.4f ' % (epoch, NUM_EPOCH, iter_loss)) elif opt['mode'] == 'srgan': training_results['training_loss'] += iter_loss * batch_size train_bar.set_description(desc='[%d/%d] Loss: %.4f ' % (epoch, NUM_EPOCH, iter_loss)) elif opt['mode'] == 'fi': training_results['training_loss'] += iter_loss * batch_size train_bar.set_description(desc='[%d/%d] Loss: %.4f ' % (epoch, NUM_EPOCH, iter_loss)) elif opt['mode'] == 'msan': training_results['training_loss'] += iter_loss * batch_size train_bar.set_description(desc='[%d/%d] Loss: %.4f ' % (epoch, NUM_EPOCH, iter_loss)) elif opt['mode'] == 'sr_curriculum': training_results[ 'training_loss'] += iter_loss.data * batch_size train_bar.set_description(desc='[%d/%d] Loss: %.4f ' % (epoch, NUM_EPOCH, iter_loss)) else: pass # TODO solver.last_epoch_loss = epoch_loss_log / (len(train_bar)) train_bar.close() time_elapse = time.time() - start_time start_time = time.time() print('Train Loss: %.4f' % (training_results['training_loss'] / training_results['batch_size'])) # validate val_results = { 'batch_size': 0, 'val_loss': 0.0, 'psnr': 0.0, 'ssim': 0.0 } if epoch % solver.val_step == 0 and epoch != 0: print('[Validating...]') start_time = time.time() solver.val_loss = 0.0 vis_index = 1 for iter, batch in enumerate(val_loader): visuals_list = [] solver.feed_data(batch) iter_loss = solver.test(opt['chop']) batch_size = batch['LR'].size(0) val_results['batch_size'] += batch_size visuals = solver.get_current_visual() # float cpu tensor sr_img = np.transpose( util.quantize(visuals['SR'], opt['rgb_range']).numpy(), (1, 2, 0)).astype(np.uint8) gt_img = np.transpose( util.quantize(visuals['HR'], opt['rgb_range']).numpy(), (1, 2, 0)).astype(np.uint8) # calculate PSNR crop_size = opt['scale'] cropped_sr_img = sr_img[crop_size:-crop_size, crop_size:-crop_size, :] cropped_gt_img = gt_img[crop_size:-crop_size, crop_size:-crop_size, :] cropped_sr_img = cropped_sr_img / 255. cropped_gt_img = cropped_gt_img / 255. cropped_sr_img = rgb2ycbcr(cropped_sr_img).astype(np.float32) cropped_gt_img = rgb2ycbcr(cropped_gt_img).astype(np.float32) ################################################################################## # b, r, g = cv2.split(cropped_sr_img) # # RG = r - g # YB = (r + g) / 2 - b # m, n, o = np.shape(cropped_sr_img) # img为三维 rbg为二维 o并未用到 # K = m * n # alpha_L = 0.1 # alpha_R = 0.1 # 参数α 可调 # T_alpha_L = math.ceil(alpha_L * K) # 向上取整 #表示去除区间 # T_alpha_R = math.floor(alpha_R * K) # 向下取整 # # RG_list = RG.flatten() # 二维数组转一维(方便计算) # RG_list = sorted(RG_list) # 排序 # sum_RG = 0 # 计算平均值 # for i in range(T_alpha_L + 1, K - T_alpha_R): # sum_RG = sum_RG + RG_list[i] # U_RG = sum_RG / (K - T_alpha_R - T_alpha_L) # squ_RG = 0 # 计算方差 # for i in range(K): # squ_RG = squ_RG + np.square(RG_list[i] - U_RG) # sigma2_RG = squ_RG / K # # # YB和RG计算一样 # YB_list = YB.flatten() # YB_list = sorted(YB_list) # sum_YB = 0 # for i in range(T_alpha_L + 1, K - T_alpha_R): # sum_YB = sum_YB + YB_list[i] # U_YB = sum_YB / (K - T_alpha_R - T_alpha_L) # squ_YB = 0 # for i in range(K): # squ_YB = squ_YB + np.square(YB_list[i] - U_YB) # sigma2_YB = squ_YB / K # # uicm = -0.0268 * np.sqrt(np.square(U_RG) + np.square(U_YB)) + 0.1586 * np.sqrt(sigma2_RG + sigma2_RG) ################################################################################## val_results['val_loss'] += iter_loss * batch_size val_results['psnr'] += util.calc_psnr(cropped_sr_img * 255, cropped_gt_img * 255) val_results['ssim'] += util.compute_ssim1( cropped_sr_img * 255, cropped_gt_img * 255) if opt['mode'] == 'srgan': pass # TODO # if opt['save_image']: # visuals_list.extend([util.quantize(visuals['HR'].squeeze(0), opt['rgb_range']), # util.quantize(visuals['SR'].squeeze(0), opt['rgb_range'])]) # # images = torch.stack(visuals_list) # img = thutil.make_grid(images, nrow=2, padding=5) # ndarr = img.byte().permute(1, 2, 0).numpy() # misc.imsave(os.path.join(solver.vis_dir, 'epoch_%d_%d.png' % (epoch, vis_index)), ndarr) # vis_index += 1 avg_psnr = val_results['psnr'] / val_results['batch_size'] avg_ssim = val_results['ssim'] / val_results['batch_size'] print( 'Valid Loss: %.4f | Avg. PSNR: %.4f | Avg. SSIM: %.4f | Learning Rate: %f' % (val_results['val_loss'] / val_results['batch_size'], avg_psnr, avg_ssim, solver.current_learning_rate())) time_elapse = start_time - time.time() #if epoch%solver.log_step == 0 and epoch != 0: # tensorboard visualization solver.training_loss = training_results[ 'training_loss'] / training_results['batch_size'] solver.val_loss = val_results['val_loss'] / val_results[ 'batch_size'] solver.tf_log(epoch) # statistics if opt['mode'] == 'sr' or opt['mode'] == 'srgan' or opt[ 'mode'] == 'sr_curriculum' or opt['mode'] == 'fi' or opt[ 'mode'] == 'msan': solver.results['training_loss'].append( solver.training_loss.cpu().data.item()) solver.results['val_loss'].append( solver.val_loss.cpu().data.item()) solver.results['psnr'].append(avg_psnr) solver.results['ssim'].append(avg_ssim) else: pass # TODO is_best = False if solver.best_prec < solver.results['psnr'][-1]: solver.best_prec = solver.results['psnr'][-1] is_best = True print( '#############################################################' ) print(solver.best_prec) print(solver.results['psnr'][-1]) print( '***************************************************************' ) # print(is_best) # print('+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++') # print('+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++') solver.save(epoch, is_best) # update lr solver.update_learning_rate(epoch) data_frame = pd.DataFrame(data={ 'training_loss': solver.results['training_loss'], 'val_loss': solver.results['val_loss'], 'psnr': solver.results['psnr'], 'ssim': solver.results['ssim'] }, index=range(1, NUM_EPOCH + 1)) data_frame.to_csv(os.path.join(solver.results_dir, 'train_results.csv'), index_label='Epoch')
def main(): # get options parser = argparse.ArgumentParser(description='Train Super Resolution Models') parser.add_argument('-opt', type=str, required=True, help='Path to options JSON file.') opt = option.parse(parser.parse_args().opt, is_train=True) if opt['train']['resume'] is False: util.mkdir_and_rename(opt['path']['exp_root']) # rename old experiments if exists util.mkdirs((path for key, path in opt['path'].items() if not key == 'exp_root' and \ not key == 'pretrain_G' and not key == 'pretrain_D')) option.save(opt) opt = option.dict_to_nonedict(opt) # Convert to NoneDict, which return None for missing key. else: opt = option.dict_to_nonedict(opt) if opt['train']['resume_path'] is None: raise ValueError("The 'resume_path' does not declarate") if opt['exec_debug']: NUM_EPOCH = 50 opt['datasets']['train']['dataroot_HR'] = '/home/ser606/ZhenLi/data/DIV2K/DIV2K_train_HR_debug' opt['datasets']['train']['dataroot_LR'] = '/home/ser606/ZhenLi/data/DIV2K/DIV2K_train_LR_debug' else: NUM_EPOCH = int(opt['train']['num_epochs']) # random seed seed = opt['train']['manual_seed'] if seed is None: seed = random.randint(1, 10000) print("Random Seed: ", seed) random.seed(seed) torch.manual_seed(seed) # create train and val dataloader for phase, dataset_opt in opt['datasets'].items(): if phase == 'train': train_set = create_dataset(dataset_opt) train_loader = create_dataloader(train_set, dataset_opt) print('Number of train images in [%s]: %d' % (dataset_opt['name'], len(train_set))) elif phase == 'val': val_set = create_dataset(dataset_opt) val_loader = create_dataloader(val_set, dataset_opt) print('Number of val images in [%s]: %d' % (dataset_opt['name'], len(val_set))) else: raise NotImplementedError("Phase [%s] is not recognized." % phase) if train_loader is None: raise ValueError("The training data does not exist") if 'coeff' in train_set[0]: opt['networks']['G']['num_coeff'] = len(train_set[0]['coeff']) opt['train']['num_coeff'] = len(train_set[0]['coeff']) # TODO: design an exp that can obtain the location of the biggest error solver = SRModel(opt) solver.summary(train_set[0]['LR'].size()) print('[Start Training]') start_time = time.time() # resume from the latest epoch start_epoch = 1 if opt['train']['resume']: checkpoint_path = os.path.join(solver.checkpoint_dir, 'checkpoint.pth') print('[Loading checkpoint from %s...]' % checkpoint_path) checkpoint = torch.load(checkpoint_path) solver.model.load_state_dict(checkpoint['state_dict'].state_dict()) start_epoch = checkpoint['epoch'] + 1 # Because the last state had been saved solver.optimizer.load_state_dict(checkpoint['optimizer']) solver.best_prec = checkpoint['best_prec'] solver.best_epoch = checkpoint['best_epoch'] solver.results = checkpoint['results'] print('=> Done.') else: solver.net_init() # best_epoch = 0 # start train for epoch in range(start_epoch, NUM_EPOCH + 1): # Initialization solver.training_loss = 0.0 if opt['mode'] == 'sr': training_results = {'batch_size': 0, 'training_loss': 0.0} else: pass # TODO train_bar = tqdm(train_loader) # Train model for iter, batch in enumerate(train_bar): solver.feed_data(batch) iter_loss = solver.train_step() batch_size = batch['LR'].size(0) training_results['batch_size'] += batch_size if opt['mode'] == 'sr': training_results['training_loss'] += iter_loss * batch_size train_bar.set_description(desc='[%d/%d] Train | Loss: %.4f ' % ( epoch, NUM_EPOCH, iter_loss)) else: pass # TODO train_bar.close() time_elapse = time.time() - start_time start_time = time.time() # validate val_results = {'batch_size': 0, 'val_loss': 0.0, 'psnr': 0.0, 'ssim': 0.0} if epoch % solver.val_step == 0 and epoch != 0: start_time = time.time() solver.val_loss = 0.0 val_bar = tqdm(val_loader) for iter, batch in enumerate(val_bar): solver.feed_data(batch) iter_loss = solver.test() batch_size = batch['LR'].size(0) val_results['batch_size'] += batch_size if opt['mode'] == 'sr': val_results['val_loss'] += iter_loss * batch_size val_bar.set_description(desc='[%d/%d] Valid | Loss: %.4f ' % (epoch, NUM_EPOCH, iter_loss)) if opt['mode'] == 'srgan': pass # TODO time_elapse = time.time() - start_time # if epoch%solver.log_step == 0 and epoch != 0: # tensorboard visualization solver.training_loss = training_results['training_loss'] / training_results['batch_size'] solver.val_loss = val_results['val_loss'] / val_results['batch_size'] print('\n Train Loss: %.8f | Valid Loss: %.8f | Learning Rate: %f' % ( solver.training_loss, solver.val_loss, solver.current_learning_rate())) # TODO: I haven't installed tensorflow, because I should install cuda 9.0 first # solver.tf_log(epoch) # statistics if opt['mode'] == 'sr': solver.results['training_loss'].append(float(solver.training_loss.data.cpu().numpy())) solver.results['val_loss'].append(float(solver.val_loss.data.cpu().numpy())) else: pass # TODO is_best = False if solver.best_prec > solver.results['val_loss'][-1]: solver.best_prec = solver.results['val_loss'][-1] is_best = True solver.best_epoch = epoch print('The lowest validation error is in %d' % solver.best_epoch) solver.save(epoch, is_best) # update lr solver.update_learning_rate(epoch) data_frame = pd.DataFrame( data={'training_loss': solver.results['training_loss'] , 'val_loss': solver.results['val_loss'] }, index=range(1, NUM_EPOCH + 1) ) data_frame.to_csv(os.path.join(solver.results_dir, 'train_results.csv'), index_label='Epoch')
def main(): # options parser = argparse.ArgumentParser() parser.add_argument('-opt', type=str, required=True, help='Path to option JSON file.') opt = option.parse(parser.parse_args().opt, is_train=True) util.mkdir_and_rename( opt['path']['experiments_root']) # rename old experiments if exists util.mkdirs((path for key, path in opt['path'].items() if not key == 'experiments_root' and \ not key == 'pretrain_model_G' and not key == 'pretrain_model_D')) option.save(opt) opt = option.dict_to_nonedict( opt) # Convert to NoneDict, which return None for missing key. # print to file and std_out simultaneously sys.stdout = PrintLogger(opt['path']['log']) # random seed seed = opt['train']['manual_seed'] if seed is None: seed = random.randint(1, 10000) print("Random Seed: ", seed) random.seed(seed) torch.manual_seed(seed) # create train and val dataloader val_loaders = [] for phase, dataset_opt in opt['datasets'].items(): if phase == 'train': train_set = create_dataset(dataset_opt) train_size = int( math.ceil(len(train_set) / dataset_opt['batch_size'])) print('Number of train images: {:,d}, iters: {:,d}'.format( len(train_set), train_size)) total_iters = int(opt['train']['niter']) total_epoches = int(math.ceil(total_iters / train_size)) print('Total epoches needed: {:d} for iters {:,d}'.format( total_epoches, total_iters)) train_loader = create_dataloader(train_set, dataset_opt) elif 'val' in phase: val_set = create_dataset(dataset_opt) val_loader = create_dataloader(val_set, dataset_opt) print('Number of val images in [%s]: %d' % (dataset_opt['name'], len(val_set))) val_loaders.append(val_loader) else: raise NotImplementedError("Phase [%s] is not recognized." % phase) assert train_loader is not None # Create model model = create_model(opt) # create logger logger = Logger(opt) current_step = 0 start_time = time.time() print('---------- Start training -------------') for epoch in range(total_epoches): for i, train_data in enumerate(train_loader): current_step += 1 if current_step > total_iters: break # level = random.randint(0, 80) level = random.uniform(0, 80) # train_data = add_Gaussian_noise(train_data, level) train_data = add_dependent_noise(train_data, level) model.feed_data(train_data) # training model.optimize_parameters(current_step) time_elapsed = time.time() - start_time start_time = time.time() # log if current_step % opt['logger']['print_freq'] == 0: logs = model.get_current_log() print_rlt = OrderedDict() print_rlt['model'] = opt['model'] print_rlt['epoch'] = epoch print_rlt['iters'] = current_step print_rlt['time'] = time_elapsed for k, v in logs.items(): print_rlt[k] = v print_rlt['lr'] = model.get_current_learning_rate() logger.print_format_results('train', print_rlt) # save models if current_step % opt['logger']['save_checkpoint_freq'] == 0: print('Saving the model at the end of iter {:d}.'.format( current_step)) model.save(current_step) # validation if current_step % opt['train']['val_freq'] == 0: print('---------- validation -------------') for val_loader in val_loaders: val_set_name = val_loader.dataset.opt['name'] print('validation [%s]...' % val_set_name) print_rlt = OrderedDict() start_time = time.time() avg_l2 = 0.0 idx = 0 sigma_gt = int(val_set_name[-2:]) sigma_pre = [] for val_data in val_loader: idx += 1 val_data = add_dependent_noise(val_data, sigma_gt) model.feed_data(val_data, need_HR=False) sigma = model.test_sigma().squeeze().float().cpu( ).item() sigma_pre.append(sigma) avg_l2 += (sigma - sigma_gt)**2 print('sigma: {}'.format(sigma_pre)) # log the sigma, time for each quality time_elapsed = time.time() - start_time log_val_name = 'l2_noise{}'.format(sigma_gt) print_rlt[log_val_name] = avg_l2 print_rlt['time'] = time_elapsed # Save to log print_rlt['model'] = opt['model'] print_rlt['epoch'] = epoch print_rlt['iters'] = current_step logger.print_format_results('val', print_rlt) print('-----------------------------------') # end of the validation # update learning rate model.update_learning_rate() print('Saving the final model.') model.save('latest') print('End of training.')
def terp_survey(): if options['survey.position'] == SURVEY_VERSION: return False def color_set(widget, name): colour = widget.get_colormap().alloc_color( common.colors.get(name, 'white')) widget.modify_bg(gtk.STATE_ACTIVE, colour) widget.modify_fg(gtk.STATE_NORMAL, gtk.gdk.color_parse("black")) widget.modify_base(gtk.STATE_NORMAL, colour) widget.modify_text(gtk.STATE_NORMAL, gtk.gdk.color_parse("black")) widget.modify_text(gtk.STATE_INSENSITIVE, gtk.gdk.color_parse("black")) widnames = ('country', 'role', 'industry', 'employee', 'hear', 'system', 'opensource') winglade = glade.XML(common.terp_path("dia_survey.glade"), "dia_survey", gettext.textdomain()) win = winglade.get_widget('dia_survey') parent = service.LocalService('gui.main').window win.set_transient_for(parent) win.set_icon(OPENERP_ICON) for widname in widnames: wid = winglade.get_widget('combo_' + widname) wid.child.set_editable(False) email_widget = winglade.get_widget('entry_email') want_ebook_widget = winglade.get_widget('check_button_ebook') def toggled_cb(togglebutton, *args): value = togglebutton.get_active() color_set(email_widget, ('normal', 'required')[value]) want_ebook_widget.connect('toggled', toggled_cb) while True: res = win.run() if res == gtk.RESPONSE_OK: email = email_widget.get_text() want_ebook = want_ebook_widget.get_active() if want_ebook and not len(email): color_set(email_widget, 'invalid') else: company = winglade.get_widget('entry_company').get_text() phone = winglade.get_widget('entry_phone').get_text() name = winglade.get_widget('entry_name').get_text() city = winglade.get_widget('entry_city').get_text() result = "\ncompany: " + str(company) result += "\nname: " + str(name) result += "\nphone: " + str(phone) result += "\ncity: " + str(city) for widname in widnames: wid = winglade.get_widget('combo_' + widname) result += "\n" + widname + ": " + wid.child.get_text() result += "\nplan_use: " + str( winglade.get_widget('check_use').get_active()) result += "\nplan_sell: " + str( winglade.get_widget('check_sell').get_active()) result += "\nwant_ebook: " + str(want_ebook) buffer = winglade.get_widget('textview_comment').get_buffer() iter_start = buffer.get_start_iter() iter_end = buffer.get_end_iter() result += "\nnote: " + buffer.get_text(iter_start, iter_end, False) upload_data(email, result, type='SURVEY ' + str(SURVEY_VERSION)) options['survey.position'] = SURVEY_VERSION options.save() parent.present() win.destroy() common.message( _('Thank you for the feedback !\n\ Your comments have been sent to OpenERP.\n\ You should now start by creating a new database or\n\ connecting to an existing server through the "File" menu.')) break elif res == gtk.RESPONSE_CANCEL or gtk.RESPONSE_DELETE_EVENT: parent.present() win.destroy() common.message( _('Thank you for testing OpenERP !\n\ You should now start by creating a new database or\n\ connecting to an existing server through the "File" menu.')) break return True
def main(): # options parser = argparse.ArgumentParser() parser.add_argument('-opt', type=str, required=True, help='Path to option JSON file.') opt = option.parse(parser.parse_args().opt, is_train=True) util.mkdir_and_rename( opt['path']['experiments_root']) # rename old experiments if exists util.mkdirs((path for key, path in opt['path'].items() if not key == 'experiments_root' and \ not key == 'pretrain_model_G' and not key == 'pretrain_model_D')) option.save(opt) opt = option.dict_to_nonedict( opt) # Convert to NoneDict, which return None for missing key. # print to file and std_out simultaneously sys.stdout = PrintLogger(opt['path']['log']) # random seed seed = opt['train']['manual_seed'] if seed is None: seed = random.randint(1, 10000) print("Random Seed: ", seed) random.seed(seed) torch.manual_seed(seed) # create train and val dataloader for phase, dataset_opt in opt['datasets'].items(): if phase == 'train': train_set = create_dataset(dataset_opt) train_size = int( math.ceil(len(train_set) / dataset_opt['batch_size'])) print('Number of train images: {:,d}, iters: {:,d}'.format( len(train_set), train_size)) total_iters = int(opt['train']['niter']) total_epoches = int(math.ceil(total_iters / train_size)) print('Total epoches needed: {:d} for iters {:,d}'.format( total_epoches, total_iters)) train_loader = create_dataloader(train_set, dataset_opt) batch_size_per_month = dataset_opt['batch_size'] batch_size_per_day = int( opt['datasets']['train']['batch_size_per_day']) num_month = int(opt['train']['num_month']) num_day = int(opt['train']['num_day']) use_dci = false if 'use_dci' not in opt['train'] else opt['train'][ 'use_dci'] elif phase == 'val': val_dataset_opt = dataset_opt val_set = create_dataset(dataset_opt) val_loader = create_dataloader(val_set, dataset_opt) print('Number of val images in [{:s}]: {:d}'.format( dataset_opt['name'], len(val_set))) else: raise NotImplementedError( 'Phase [{:s}] is not recognized.'.format(phase)) assert train_loader is not None # Create model model = create_model(opt) # create logger logger = Logger(opt) current_step = 0 start_time = time.time() print('---------- Start training -------------') for epoch in range(num_month): for i, train_data in enumerate(train_loader): # get the code if use_dci: cur_month_code = get_code_for_data(model, train_data, opt) else: cur_month_code = get_code(model, train_data, opt) for j in range(num_day): current_step += 1 if current_step > total_iters: break # get the sliced data cur_day_batch_start_idx = ( j * batch_size_per_day) % batch_size_per_month cur_day_batch_end_idx = cur_day_batch_start_idx + batch_size_per_day if cur_day_batch_end_idx > batch_size_per_month: cur_day_batch_idx = np.hstack( (np.arange(cur_day_batch_start_idx, batch_size_per_month), np.arange(cur_day_batch_end_idx - batch_size_per_month))) else: cur_day_batch_idx = slice(cur_day_batch_start_idx, cur_day_batch_end_idx) cur_day_train_data = { 'LR': train_data['LR'][cur_day_batch_idx], 'HR': train_data['HR'][cur_day_batch_idx] } code = cur_month_code[cur_day_batch_idx] # training model.feed_data(cur_day_train_data, code=code) model.optimize_parameters(current_step) time_elapsed = time.time() - start_time start_time = time.time() # log if current_step % opt['logger']['print_freq'] == 0: logs = model.get_current_log() print_rlt = OrderedDict() print_rlt['model'] = opt['model'] print_rlt['epoch'] = epoch print_rlt['iters'] = current_step print_rlt['time'] = time_elapsed for k, v in logs.items(): print_rlt[k] = v print_rlt['lr'] = model.get_current_learning_rate() logger.print_format_results('train', print_rlt) # save models if current_step % opt['logger']['save_checkpoint_freq'] == 0: print('Saving the model at the end of iter {:d}.'.format( current_step)) model.save(current_step) # validation if current_step % opt['train']['val_freq'] == 0: print('---------- validation -------------') start_time = time.time() avg_psnr = 0.0 idx = 0 for val_data in val_loader: idx += 1 img_name = os.path.splitext( os.path.basename(val_data['LR_path'][0]))[0] img_dir = os.path.join(opt['path']['val_images'], img_name) util.mkdir(img_dir) if 'zero_code' in opt['train'] and opt['train'][ 'zero_code']: code_val = torch.zeros( val_data['LR'].shape[0], int(opt['network_G']['in_code_nc']), val_data['LR'].shape[2], val_data['LR'].shape[3]) elif 'rand_code' in opt['train'] and opt['train'][ 'rand_code']: code_val = torch.rand( val_data['LR'].shape[0], int(opt['network_G']['in_code_nc']), val_data['LR'].shape[2], val_data['LR'].shape[3]) else: code_val = torch.randn( val_data['LR'].shape[0], int(opt['network_G']['in_code_nc']), val_data['LR'].shape[2], val_data['LR'].shape[3]) model.feed_data(val_data, code=code_val) model.test() visuals = model.get_current_visuals() sr_img = util.tensor2img(visuals['SR']) # uint8 gt_img = util.tensor2img(visuals['HR']) # uint8 # Save SR images for reference run_index = opt['name'].split("_")[2] save_img_path = os.path.join(img_dir, 'srim_{:s}_{:s}_{:d}.png'.format( \ run_index, img_name, current_step)) util.save_img(sr_img, save_img_path) # calculate PSNR crop_size = opt['scale'] cropped_sr_img = sr_img[crop_size:-crop_size, crop_size:-crop_size, :] cropped_gt_img = gt_img[crop_size:-crop_size, crop_size:-crop_size, :] avg_psnr += util.psnr(cropped_sr_img, cropped_gt_img) avg_psnr = avg_psnr / idx time_elapsed = time.time() - start_time # Save to log print_rlt = OrderedDict() print_rlt['model'] = opt['model'] print_rlt['epoch'] = epoch print_rlt['iters'] = current_step print_rlt['time'] = time_elapsed print_rlt['psnr'] = avg_psnr logger.print_format_results('val', print_rlt) print('-----------------------------------') # update learning rate model.update_learning_rate() print('Saving the final model.') model.save('latest') print('End of training.')
def main(): parser = argparse.ArgumentParser( description='Test Super Resolution Models') parser.add_argument('-opt', type=str, required=True, help='Path to options JSON file.') opt = option.parse(parser.parse_args().opt) opt = option.dict_to_nonedict(opt) # initial configure scale = opt['scale'] degrad = opt['degradation'] network_opt = opt['networks'] model_name = network_opt['which_model'].upper() # create folders util.mkdir_and_rename(opt['path']['res_root']) option.save(opt) # create test dataloader bm_names = [] test_loaders = [] for ds_name, dataset_opt in sorted(opt['datasets'].items()): test_set = create_dataset(dataset_opt) test_loader = create_dataloader(test_set, dataset_opt) test_loaders.append(test_loader) print('===> Test Dataset: [%s] Number of images: [%d]' % (dataset_opt['name'], len(test_set))) bm_names.append(dataset_opt['name']) # create solver (and load model) solver = create_solver(opt) # Test phase print('===> Start Test') print("==================================================") print("Method: %s || Scale: %d || Degradation: %s" % (model_name, scale, degrad)) for bm, test_loader in zip(bm_names, test_loaders): print("Test set : [%s]" % bm) sr_list = [] path_list = [] total_psnr = [] total_ssim = [] total_time = [] res_dict = OrderedDict() need_HR = False if test_loader.dataset.__class__.__name__.find( 'HR') < 0 else True for iter, batch in tqdm(enumerate(test_loader), total=len(test_loader)): solver.feed_data(batch, need_HR=need_HR, need_landmark=False) # calculate forward time t0 = time.time() solver.test() t1 = time.time() total_time.append((t1 - t0)) visuals = solver.get_current_visual(need_HR=need_HR) sr_list.append(visuals['SR'][-1]) # calculate PSNR/SSIM metrics on Python if need_HR: psnr, ssim = util.calc_metrics(visuals['SR'][-1], visuals['HR'], crop_border=scale) total_psnr.append(psnr) total_ssim.append(ssim) path_list.append( os.path.basename(batch['HR_path'][0]).replace( 'HR', model_name)) # print( # "[%d/%d] %s || PSNR(dB)/SSIM: %.2f/%.4f || Timer: %.4f sec ." # % (iter + 1, len(test_loader), # os.path.basename(batch['HR_path'][0]), psnr, ssim, # (t1 - t0))) res_dict[path_list[-1]] = { 'psnr': psnr, 'ssim': ssim, 'time': t1 - t0 } else: path_list.append(os.path.basename(batch['LR_path'][0])) # print("[%d/%d] %s || Timer: %.4f sec ." % # (iter + 1, len(test_loader), # os.path.basename(batch['LR_path'][0]), (t1 - t0))) if need_HR: print("---- Average PSNR(dB) /SSIM /Speed(s) for [%s] ----" % bm) average_res_str = "PSNR: %.2f SSIM: %.4f Speed: %.4f" % \ (sum(total_psnr) / len(total_psnr), sum(total_ssim) / len(total_ssim), sum(total_time) / len(total_time)) print(average_res_str) else: print("---- Average Speed(s) for [%s] is %.4f sec ----" % (bm, sum(total_time) / len(total_time))) # save SR results for further evaluation on MATLAB save_img_path = os.path.join(opt['path']['res_root'], bm) print("===> Saving SR images of [%s]... Save Path: [%s]\n" % (bm, save_img_path)) if not os.path.exists(save_img_path): os.makedirs(save_img_path) for img, name in zip(sr_list, path_list): imageio.imwrite(os.path.join(save_img_path, name), img) if need_HR: with open(os.path.join(save_img_path, 'result.json'), 'w') as f: json.dump(res_dict, f, indent=2) with open(os.path.join(save_img_path, 'average_result.txt'), 'w') as f: f.write(average_res_str + '\n') print("==================================================") print("===> Finished !")