def __init__(self, args, model, evaluation, writer): self.args = args self.model = model self.evaluation = evaluation self.writer = writer self.nepochs = args.nepochs # logging testing self.log_loss = plugins.Logger(args.logs_dir, 'TestLogger.txt', args.save_results) self.params_log = ['ACC', 'STD'] self.log_loss.register(self.params_log) # monitor testing self.monitor = plugins.Monitor() self.params_monitor = {} for param in self.params_log: self.params_monitor.update({param: {'dtype': 'running_mean'}}) self.monitor.register(self.params_monitor) # display training progress self.print_formatter = 'Test [%d/%d]] ' for item in self.params_log: self.print_formatter += item + " %.4f " self.losses = {}
def __init__(self, args, model, criterion): self.args = args self.model = model self.criterion = criterion self.port = args.port self.dir_save = args.save self.cuda = args.cuda self.nepochs = args.nepochs self.nchannels = args.nchannels self.batch_size = args.batch_size self.resolution_high = args.resolution_high self.resolution_wide = args.resolution_wide # for classification self.label = torch.zeros(self.batch_size).long() self.input = torch.zeros(self.batch_size, self.nchannels, self.resolution_high, self.resolution_wide) if args.cuda: self.label = self.label.cuda() self.input = self.input.cuda() self.input = Variable(self.input, volatile=True) self.label = Variable(self.label, volatile=True) # logging testing # self.log_loss_test = plugins.Logger(args.logs, 'TestLogger.txt') self.params_loss_test = ['Loss', 'Accuracy'] # self.log_loss_test.register(self.params_loss_test) # monitor testing self.monitor_test = plugins.Monitor() self.params_monitor_test = ['Loss', 'Accuracy'] self.monitor_test.register(self.params_monitor_test) # visualize testing # self.visualizer_test = plugins.Visualizer(self.port, 'Test') # self.params_visualizer_test = { # 'Loss': {'dtype': 'scalar', 'vtype': 'plot'}, # 'Accuracy': {'dtype': 'scalar', 'vtype': 'plot'}, # 'Image': {'dtype': 'image', 'vtype': 'image'}, # 'Images': {'dtype': 'images', 'vtype': 'images'}, # } # self.visualizer_test.register(self.params_visualizer_test) # display testing progress self.print_test = 'Test [%d/%d][%d/%d] ' for item in self.params_loss_test: self.print_test = self.print_test + item + " %.4f " self.evalmodules = [] self.losses_test = {}
def __init__(self, args, netD, netG, netE): self.netD = netD self.netG = netG self.netE = netE self.args = args self.nchannels = args.nchannels self.resolution_high = args.resolution_high self.resolution_wide = args.resolution_wide self.nz = args.nz self.wcom = args.disc_loss_weight self.cuda = args.cuda self.citers = args.citers self.lr = args.learning_rate_vae self.momentum = args.momentum self.batch_size = args.batch_size self.use_encoder = args.use_encoder self.input = Variable(torch.FloatTensor(self.batch_size, self.nchannels, self.resolution_high, self.resolution_wide), volatile=True).cuda() self.epsilon = Variable(torch.randn(self.batch_size, self.nz), volatile=True).cuda() self.noise = Variable(torch.FloatTensor(self.batch_size, self.nz, 1, 1).normal_(0, 1), volatile=True) if args.cuda: self.input = self.input.cuda() self.epsilon = self.epsilon.cuda() self.noise = self.noise.cuda() self.log_eval_loss = plugins.Logger(args.logs, 'Generation.txt') self.params_eval_loss = [ 'Image', 'SSIM_1', 'SSIM_2', 'SSIM_3', 'SSIM_4', 'PSNR_1', 'PSNR_2', 'PSNR_3', 'PSNR_4', 'DiscScore_1', 'DiscScore_2', 'DiscScore_3', 'DiscScore_4' ] self.log_eval_loss.register(self.params_eval_loss) self.losses = {} self.log_eval_monitor = plugins.Monitor() self.params_eval_monitor = [ 'Image', 'SSIM_1', 'SSIM_2', 'SSIM_3', 'SSIM_4', 'PSNR_1', 'PSNR_2', 'PSNR_3', 'PSNR_4', 'DiscScore_1', 'DiscScore_2', 'DiscScore_3', 'DiscScore_4' ] self.log_eval_monitor.register(self.params_eval_monitor) self.print = '[%d/%d] ' for item in self.params_eval_loss: self.print = self.print + item + " %.4f "
def __init__(self, args, model, criterion, evaluation, optimizer, writer): self.args = args self.model = model self.criterion = criterion self.evaluation = evaluation self.optimizer = optimizer self.writer = writer self.nepochs = args.nepochs self.lr = args.learning_rate self.optim_method = args.optim_method self.optim_options = args.optim_options self.scheduler_method = args.scheduler_method self.att_loss = losses.AttMatrixCov(args.cuda) self.dist_loss = losses.DebiasIntraDist(args.cuda) if self.scheduler_method is not None: if self.scheduler_method != 'Customer': self.scheduler = getattr(optim.lr_scheduler, self.scheduler_method)( self.optimizer, **args.scheduler_options) # logging training self.log_loss = plugins.Logger(args.logs_dir, 'TrainLogger.txt', args.save_results) self.params_loss = ['LearningRate', 'idLoss', 'attLoss'] self.log_loss.register(self.params_loss) # monitor training self.monitor = plugins.Monitor() self.params_monitor = { 'LearningRate': { 'dtype': 'running_mean' }, 'idLoss': { 'dtype': 'running_mean' }, 'attLoss': { 'dtype': 'running_mean' }, } self.monitor.register(self.params_monitor) # display training progress self.print_formatter = 'Train [%d/%d][%d/%d] ' for item in self.params_loss: self.print_formatter += item + " %.4f " # self.print_formatter += "IDLoss %.4f AttLoss %.4f" self.losses = {}
def __init__(self, args, model, criterion, evaluation): self.args = args self.model = model self.criterion = criterion self.evaluation = evaluation self.save_results = args.save_results self.env = args.env self.port = args.port self.dir_save = args.save_dir self.log_type = args.log_type self.device = args.device self.nepochs = args.nepochs self.batch_size = args.batch_size self.resolution_high = args.resolution_high self.resolution_wide = args.resolution_wide self.lr = args.learning_rate self.optim_method = args.optim_method self.optim_options = args.optim_options self.scheduler_method = args.scheduler_method self.scheduler_options = args.scheduler_options self.optimizer = getattr(optim, self.optim_method)(filter( lambda p: p.requires_grad, model.parameters()), lr=self.lr, **self.optim_options) if self.scheduler_method is not None: self.scheduler = getattr(optim.lr_scheduler, self.scheduler_method)( self.optimizer, **self.scheduler_options) # for classification self.labels = torch.zeros(self.batch_size, dtype=torch.long, device=self.device) self.inputs = torch.zeros(self.batch_size, self.resolution_high, self.resolution_wide, device=self.device) # logging training self.log_loss = plugins.Logger(args.logs_dir, 'TrainLogger.txt', self.save_results) self.params_loss = ['Loss', 'Accuracy'] self.log_loss.register(self.params_loss) # monitor training self.monitor = plugins.Monitor() self.params_monitor = { 'Loss': { 'dtype': 'running_mean' }, 'Accuracy': { 'dtype': 'running_mean' } } self.monitor.register(self.params_monitor) # visualize training self.visualizer = plugins.Visualizer(self.port, self.env, 'Train') self.params_visualizer = { 'Loss': { 'dtype': 'scalar', 'vtype': 'plot', 'win': 'loss', 'layout': { 'windows': ['train', 'test'], 'id': 0 } }, 'Accuracy': { 'dtype': 'scalar', 'vtype': 'plot', 'win': 'accuracy', 'layout': { 'windows': ['train', 'test'], 'id': 0 } }, 'Train_Image': { 'dtype': 'image', 'vtype': 'image', 'win': 'train_image' }, 'Train_Images': { 'dtype': 'images', 'vtype': 'images', 'win': 'train_images' }, } self.visualizer.register(self.params_visualizer) if self.log_type == 'traditional': # display training progress self.print_formatter = 'Train [%d/%d][%d/%d] ' for item in self.params_loss: self.print_formatter += item + " %.4f " elif self.log_type == 'progressbar': # progress bar message formatter self.print_formatter = '({}/{})' \ ' Load: {:.6f}s' \ ' | Process: {:.3f}s' \ ' | Total: {:}' \ ' | ETA: {:}' for item in self.params_loss: self.print_formatter += ' | ' + item + ' {:.4f}' self.print_formatter += ' | lr: {:.2e}' self.evalmodules = [] self.losses = {}
def __init__(self, args, model, criterion, evaluation): self.args = args self.model = model self.criterion = criterion self.evaluation = evaluation self.nepochs = args.nepochs self.lr = args.learning_rate self.optim_method = args.optim_method self.optim_options = args.optim_options self.scheduler_method = args.scheduler_method self.optimizer_cnn = getattr(optim, self.optim_method)( model['feat'].parameters(), lr=self.lr, **self.optim_options) module_list = nn.ModuleList([ criterion['id'], criterion['gender'], criterion['age'], criterion['race'], model['discrim'] ]) self.optimizer_cls = getattr(optim, self.optim_method)( module_list.parameters(), lr=self.lr, **self.optim_options) if self.scheduler_method is not None: if self.scheduler_method != 'Customer': self.scheduler = getattr(optim.lr_scheduler, self.scheduler_method)( self.optimizer_cnn, **args.scheduler_options) # for classification self.labels = torch.zeros(args.batch_size).long() self.inputs = torch.zeros(args.batch_size, args.resolution_high, args.resolution_wide) if args.cuda: self.labels = self.labels.cuda() self.inputs = self.inputs.cuda() self.inputs = Variable(self.inputs) self.labels = Variable(self.labels) # logging training self.log_loss = plugins.Logger(args.logs_dir, 'TrainLogger.txt', args.save_results) params_loss = ['LearningRate','Loss_cls_demog', 'Loss_cls_id',\ 'Loss_conf_demog', 'Loss_conf_id', 'Loss_cls_mi', 'Loss_conf_mi'] self.log_loss.register(params_loss) # monitor training self.monitor = plugins.Monitor() self.params_monitor = { 'LearningRate': { 'dtype': 'running_mean' }, 'Loss_cls_demog': { 'dtype': 'running_mean' }, 'Loss_cls_id': { 'dtype': 'running_mean' }, 'Loss_cls_mi': { 'dtype': 'running_mean' }, 'Loss_conf_demog': { 'dtype': 'running_mean' }, 'Loss_conf_id': { 'dtype': 'running_mean' }, 'Loss_conf_mi': { 'dtype': 'running_mean' }, } self.monitor.register(self.params_monitor) # visualize training self.visualizer = plugins.Visualizer(args.port, args.env, 'Train') params_visualizer = { 'LearningRate': { 'dtype': 'scalar', 'vtype': 'plot', 'win': 'learning_rate', 'layout': { 'windows': ['train', 'test'], 'id': 0 } }, 'Loss_cls_demog': { 'dtype': 'scalar', 'vtype': 'plot', 'win': 'loss_cls', 'layout': { 'windows': ['train', 'test'], 'id': 0 } }, 'Loss_cls_id': { 'dtype': 'scalar', 'vtype': 'plot', 'win': 'loss_cls', 'layout': { 'windows': ['train', 'test'], 'id': 0 } }, 'Loss_cls_mi': { 'dtype': 'scalar', 'vtype': 'plot', 'win': 'loss_cls', 'layout': { 'windows': ['train', 'test'], 'id': 0 } }, 'Loss_conf_demog': { 'dtype': 'scalar', 'vtype': 'plot', 'win': 'loss_conf', 'layout': { 'windows': ['train', 'test'], 'id': 0 } }, 'Loss_conf_id': { 'dtype': 'scalar', 'vtype': 'plot', 'win': 'loss_conf', 'layout': { 'windows': ['train', 'test'], 'id': 0 } }, 'Loss_conf_mi': { 'dtype': 'scalar', 'vtype': 'plot', 'win': 'loss_conf', 'layout': { 'windows': ['train', 'test'], 'id': 0 } }, 'Train_Image': { 'dtype': 'image', 'vtype': 'image', 'win': 'train_image' }, 'Train_Images': { 'dtype': 'images', 'vtype': 'images', 'win': 'train_images' }, } self.visualizer.register(params_visualizer) # display training progress self.print_formatter = 'Train [%d/%d][%d/%d] ' for item in params_loss: self.print_formatter += item + " %.4f " # self.print_formatter += "Scale %.4f " self.losses = {} self.binage = torch.Tensor( [10, 22.5, 27.5, 32.5, 37.5, 42.5, 47.5, 55, 75])
def __init__(self, args, modelD, modelG, Encoder, criterion, prevD, prevG): self.args = args self.modelD = [modelD for i in range(2)] self.modelG = [modelG for i in range(2)] self.Encoder = Encoder self.prevD = prevD self.prevG = prevG self.criterion = criterion self.cuda = args.cuda self.device = torch.device("cuda" if ( self.cuda and torch.cuda.is_available()) else "cpu") self.logits_loss = RankOrderLoss(self.device) self.logits_eval = Logits_Classification(threshold=0.5) self.plot_update_interval = args.plot_update_interval self.port = args.port self.env = args.env self.result_path = args.result_path self.save_path = args.save self.log_path = args.logs self.dataset_fraction = args.dataset_fraction self.len_dataset = 0 self.stage_epochs = args.stage_epochs self.start_stage = args.start_stage self.nchannels = args.nchannels self.batch_size = args.batch_size self.resolution_high = args.resolution_high self.resolution_wide = args.resolution_wide self.nz = args.nz self.gp = args.gp self.gp_lambda = args.gp_lambda self.scheduler_patience = args.scheduler_patience self.scheduler_maxlen = args.scheduler_maxlen self.weight_gan_final = args.weight_gan_final self.weight_vae_init = args.weight_vae_init self.weight_kld = args.weight_kld self.margin = args.margin self.num_stages = args.num_stages self.nranks = args.nranks self.lr_vae = args.learning_rate_vae self.lr_dis = args.learning_rate_dis self.lr_gen = args.learning_rate_gen self.lr_decay = args.learning_rate_decay self.momentum = args.momentum self.adam_beta1 = args.adam_beta1 self.adam_beta2 = args.adam_beta2 self.weight_decay = args.weight_decay self.optim_method = args.optim_method self.vae_loss_type = args.vae_loss_type # for classification self.fixed_noise = torch.FloatTensor(self.batch_size, self.nz).normal_( 0, 1).to(self.device) #, volatile=True) self.epsilon = torch.randn(self.batch_size, self.nz).to(self.device) self.target_real = torch.ones(self.batch_size, self.nranks - 1).to(self.device) self.target_fakeD = torch.zeros(self.batch_size, self.nranks - 1).to(self.device) self.target_fakeG = torch.zeros(self.batch_size, self.nranks - 1).to(self.device) self.sigmoid = torch.sigmoid # Initialize optimizer self.optimizerE = self.initialize_optimizer(self.Encoder, lr=self.lr_vae, optim_method='Adam') self.optimizerG = self.initialize_optimizer(self.modelG[0], lr=self.lr_vae, optim_method='Adam') self.optimizerD = self.initialize_optimizer(self.modelD[0], lr=self.lr_dis, optim_method='Adam', weight_decay=0.01 * self.lr_dis) # self.schedulerE = optim.lr_scheduler.ReduceLROnPlateau(self.optimizerE, factor=self.lr_decay, patience=self.scheduler_patience, min_lr=1e-3*self.lr_vae) # self.schedulerG = optim.lr_scheduler.ReduceLROnPlateau(self.optimizerG, factor=self.lr_decay, patience=self.scheduler_patience, min_lr=1e-3*self.lr_vae) # self.schedulerD = optim.lr_scheduler.ReduceLROnPlateau(self.optimizerD, factor=self.lr_decay, patience=self.scheduler_patience, min_lr=1e-3*self.lr_vae) # Automatic scheduler self.schedulerE = plugins.AutomaticLRScheduler( self.optimizerE, maxlen=self.scheduler_maxlen, factor=self.lr_decay, patience=self.scheduler_patience) self.schedulerG = plugins.AutomaticLRScheduler( self.optimizerG, maxlen=self.scheduler_maxlen, factor=self.lr_decay, patience=self.scheduler_patience) self.schedulerD = plugins.AutomaticLRScheduler( self.optimizerD, maxlen=self.scheduler_maxlen, factor=self.lr_decay, patience=self.scheduler_patience) # logging training self.log_loss_train = plugins.Logger(args.logs, 'TrainLogger.txt') self.params_loss_train = ['Loss_D0', 'Loss_G0', 'Acc_Real', 'Acc_Fake'] self.log_loss_train.register(self.params_loss_train) # monitor training self.monitor_train = plugins.Monitor() self.params_monitor_train = [ 'Loss_D0', 'Loss_G0', 'Acc_Real', 'Acc_Fake' ] self.monitor_train.register(self.params_monitor_train) # Define visualizer plot type for given dataset if args.net_type == 'gmm': self.plot_update_interval = 300 if self.args.gmm_dim == 1: output_dtype, output_vtype = 'vector', 'histogram' elif self.args.gmm_dim == 2: output_dtype, output_vtype = 'vector', 'scatter' else: output_dtype, output_vtype = 'images', 'images' self.fixed_noise = self.fixed_noise.unsqueeze(-1).unsqueeze(-1) # visualize training self.visualizer_train = plugins.Visualizer(port=self.port, env=self.env, title='Train') self.params_visualizer_train = { 'Loss_D0': { 'dtype': 'scalar', 'vtype': 'plot', 'win': 'loss_gan', 'layout': { 'windows': ['Loss_D0', 'Loss_G0'], 'id': 0 } }, 'Loss_G0': { 'dtype': 'scalar', 'vtype': 'plot', 'win': 'loss_gan', 'layout': { 'windows': ['Loss_D0', 'Loss_G0'], 'id': 1 } }, 'Acc_Real': { 'dtype': 'scalar', 'vtype': 'plot', 'win': 'acc', 'layout': { 'windows': ['Acc_Real', 'Acc_Fake'], 'id': 0 } }, 'Acc_Fake': { 'dtype': 'scalar', 'vtype': 'plot', 'win': 'acc', 'layout': { 'windows': ['Acc_Real', 'Acc_Fake'], 'id': 1 } }, 'Learning_Rate_G': { 'dtype': 'scalar', 'vtype': 'plot', 'win': 'lr_G' }, 'Learning_Rate_D': { 'dtype': 'scalar', 'vtype': 'plot', 'win': 'lr_D' }, 'Real': { 'dtype': output_dtype, 'vtype': output_vtype, 'win': 'real' }, 'Fake': { 'dtype': output_dtype, 'vtype': output_vtype, 'win': 'fake' }, 'Fakes_Current': { 'dtype': output_dtype, 'vtype': output_vtype, 'win': 'Fakes_Current' }, 'Fakes_Previous': { 'dtype': output_dtype, 'vtype': output_vtype, 'win': 'fakes_prev' }, } self.visualizer_train.register(self.params_visualizer_train) # display training progress self.print_train = '[%d/%d][%d/%d] ' for item in self.params_loss_train: self.print_train = self.print_train + item + " %.3f " self.giterations = 0 self.d_iter_init = args.d_iter self.d_iter = self.d_iter_init self.g_iter_init = args.g_iter self.g_iter = self.g_iter_init print('Discriminator:', self.modelD[0]) print('Generator:', self.modelG[0]) print('Encoder:', self.Encoder) # define a zero tensor self.t_zero = torch.zeros(1) self.add_noise = args.add_noise self.noise_var = args.noise_var
def __init__(self, args, modelD, modelG, Encoder, criterion): self.args = args self.modelD = [modelD for i in range(2)] self.modelG = [modelG for i in range(2)] self.Encoder = Encoder self.criterion = criterion self.port = args.port self.env = args.env self.dir_save = args.save self.dataset_fraction = args.dataset_fraction self.len_dataset = 0 self.cuda = args.cuda self.nepochs = args.nepochs self.stage_epochs = args.stage_epochs self.nchannels = args.nchannels self.batch_size = args.batch_size self.resolution_high = args.resolution_high self.resolution_wide = args.resolution_wide self.nz = args.nz self.gp = args.gp self.gp_lambda = args.gp_lambda self.scheduler_patience = args.scheduler_patience self.weight_gan_final = args.weight_gan_final self.weight_vae_init = args.weight_vae_init self.weight_kld = args.weight_kld self.margin = args.margin self.disc_diff_weight = args.disc_diff_weight self.num_stages = args.num_stages self.lr_vae = args.learning_rate_vae self.lr_dis = args.learning_rate_dis self.lr_gen = args.learning_rate_gen self.lr_decay = args.learning_rate_decay self.momentum = args.momentum self.adam_beta1 = args.adam_beta1 self.adam_beta2 = args.adam_beta2 self.weight_decay = args.weight_decay self.optim_method = args.optim_method self.vae_loss_type = args.vae_loss_type # for classification self.input = Variable(torch.FloatTensor(self.batch_size, self.nchannels, self.resolution_high, self.resolution_wide), requires_grad=True) self.test_input = Variable(torch.FloatTensor(self.batch_size, self.nchannels, self.resolution_high, self.resolution_wide), volatile=True) self.fixed_noise = Variable(torch.FloatTensor(self.batch_size, self.nz).normal_(0, 1), volatile=True) self.epsilon = Variable(torch.randn(self.batch_size, self.nz), requires_grad=False) if args.cuda: self.input = self.input.cuda() self.test_input = self.test_input.cuda() self.fixed_noise = self.fixed_noise.cuda() self.epsilon = self.epsilon.cuda() # Initialize optimizer self.optimizerE = self.initialize_optimizer(self.Encoder, lr=self.lr_vae, optim_method='Adam') self.optimizerG = self.initialize_optimizer(self.modelG[0], lr=self.lr_vae, optim_method='Adam') self.optimizerD = self.initialize_optimizer(self.modelD[0], lr=self.lr_dis, optim_method='Adam', weight_decay=100) self.schedulerE = optim.lr_scheduler.ReduceLROnPlateau( self.optimizerE, factor=self.lr_decay, min_lr=1e-3 * self.lr_vae) self.schedulerG = optim.lr_scheduler.ReduceLROnPlateau( self.optimizerG, factor=self.lr_decay, min_lr=1e-3 * self.lr_vae) self.schedulerD = optim.lr_scheduler.ReduceLROnPlateau( self.optimizerD, factor=self.lr_decay, min_lr=1e-3 * self.lr_vae) # logging training self.log_loss_train = plugins.Logger(args.logs, 'TrainLogger.txt') self.params_loss_train = [ 'Loss_D0', 'Loss_G0', 'MSE', 'KLD', 'Score_D0', 'Score_D1', 'Score_D0_G0', 'Score_D0_G1', 'Score_D1_G1', 'Disc_Difference' ] self.log_loss_train.register(self.params_loss_train) self.log_loss_test = plugins.Logger(args.logs, 'TestLogger.txt') self.params_loss_test = [ 'SSIM', 'PSNR', 'Test_Score_D0', 'Test_Score_D0_G0', 'Test_Score_D0_G1', 'Test_Disc_Accuracy' ] self.log_loss_test.register(self.params_loss_test) # monitor training self.monitor_train = plugins.Monitor() self.params_monitor_train = [ 'Loss_D0', 'Loss_G0', 'MSE', 'KLD', 'Score_D0', 'Score_D1', 'Score_D0_G0', 'Score_D0_G1', 'Score_D1_G1', 'Disc_Difference' ] self.monitor_train.register(self.params_monitor_train) self.monitor_test = plugins.Monitor() self.params_monitor_test = [ 'SSIM', 'PSNR', 'Test_Score_D0', 'Test_Score_D0_G0', 'Test_Score_D0_G1', 'Test_Disc_Accuracy' ] self.monitor_test.register(self.params_monitor_test) # Define visualizer plot type for given dataset if args.net_type == 'gmm': if self.args.gmm_dim == 1: output_dtype, output_vtype = 'vector', 'histogram' elif self.args.gmm_dim == 2: output_dtype, output_vtype = 'heatmap', 'heatmap' else: output_dtype, output_vtype = 'images', 'images' self.fixed_noise = self.fixed_noise.unsqueeze(-1).unsqueeze(-1) # visualize training self.visualizer_train = plugins.HourGlassVisualizer(port=self.port, env=self.env, title='Train') self.params_visualizer_train = { 'Loss_D0': { 'dtype': 'scalar', 'vtype': 'plot', 'win': 'loss_gan', 'layout': { 'windows': ['Loss_D0', 'Loss_G0'], 'id': 0 } }, 'Loss_G0': { 'dtype': 'scalar', 'vtype': 'plot', 'win': 'loss_gan', 'layout': { 'windows': ['Loss_D0', 'Loss_G0'], 'id': 1 } }, 'MSE': { 'dtype': 'scalar', 'vtype': 'plot', 'win': 'enc_losses', 'layout': { 'windows': ['MSE', 'KLD'], 'id': 0 } }, 'KLD': { 'dtype': 'scalar', 'vtype': 'plot', 'win': 'enc_losses', 'layout': { 'windows': ['MSE', 'KLD'], 'id': 1 } }, 'Mean': { 'dtype': 'scalar', 'vtype': 'plot', 'win': 'norm_params', 'layout': { 'windows': ['Mean', 'Sigma'], 'id': 0 } }, 'Sigma': { 'dtype': 'scalar', 'vtype': 'plot', 'win': 'norm_params', 'layout': { 'windows': ['Mean', 'Sigma'], 'id': 1 } }, 'Score_D0': { 'dtype': 'scalar', 'vtype': 'plot', 'win': 'loss_D0', 'layout': { 'windows': ['Score_D0', 'Score_D0_G0', 'Score_D0_G1'], 'id': 0 } }, 'Score_D0_G0': { 'dtype': 'scalar', 'vtype': 'plot', 'win': 'loss_D0', 'layout': { 'windows': ['Score_D0', 'Score_D0_G0', 'Score_D0_G1'], 'id': 1 } }, 'Score_D0_G1': { 'dtype': 'scalar', 'vtype': 'plot', 'win': 'loss_D0', 'layout': { 'windows': ['Score_D0', 'Score_D0_G0', 'Score_D0_G1'], 'id': 2 } }, 'Score_D1': { 'dtype': 'scalar', 'vtype': 'plot', 'win': 'loss_D1', 'layout': { 'windows': ['Score_D1', 'Score_D1_G1'], 'id': 0 } }, 'Score_D1_G1': { 'dtype': 'scalar', 'vtype': 'plot', 'win': 'loss_D1', 'layout': { 'windows': ['Score_D1', 'Score_D1_G1'], 'id': 1 } }, 'netD_norm_w': { 'dtype': 'scalar', 'vtype': 'plot', 'win': 'netd_norm' }, 'LR_E': { 'dtype': 'scalar', 'vtype': 'plot', 'win': 'lr', 'layout': { 'windows': ['LR_E', 'LR_G', 'LR_D'], 'id': 0 } }, 'LR_G': { 'dtype': 'scalar', 'vtype': 'plot', 'win': 'lr', 'layout': { 'windows': ['LR_E', 'LR_G', 'LR_D'], 'id': 1 } }, 'LR_D': { 'dtype': 'scalar', 'vtype': 'plot', 'win': 'lr', 'layout': { 'windows': ['LR_E', 'LR_G', 'LR_D'], 'id': 2 } }, 'Gradient_Penalty': { 'dtype': 'scalar', 'vtype': 'plot', 'win': 'gp' }, 'Disc_Difference': { 'dtype': 'scalar', 'vtype': 'plot', 'win': 'disc_diff' }, 'Disc_Accuracy': { 'dtype': 'scalar', 'vtype': 'plot', 'win': 'disc_acc' }, 'Real': { 'dtype': output_dtype, 'vtype': output_vtype, 'win': 'real' }, 'Fakes_Encoder': { 'dtype': output_dtype, 'vtype': output_vtype, 'win': 'fakes_enc' }, 'Fakes_Normal': { 'dtype': output_dtype, 'vtype': output_vtype, 'win': 'fakes_normal' }, } self.visualizer_train.register(self.params_visualizer_train) self.visualizer_test = plugins.HourGlassVisualizer(port=self.port, env=self.env, title='Test') self.params_visualizer_test = { 'Test_Score_D0': { 'dtype': 'scalar', 'vtype': 'plot', 'win': 'test_disc_scores', 'layout': { 'windows': ['Test_Score_D0', 'Test_Score_D0_G0', 'Test_Score_D0_G1'], 'id': 0 } }, 'Test_Score_D0_G0': { 'dtype': 'scalar', 'vtype': 'plot', 'win': 'test_disc_scores', 'layout': { 'windows': ['Test_Score_D0', 'Test_Score_D0_G0', 'Test_Score_D0_G1'], 'id': 1 } }, 'Test_Score_D0_G1': { 'dtype': 'scalar', 'vtype': 'plot', 'win': 'test_disc_scores', 'layout': { 'windows': ['Test_Score_D0', 'Test_Score_D0_G0', 'Test_Score_D0_G1'], 'id': 2 } }, 'SSIM': { 'dtype': 'scalar', 'vtype': 'plot', 'win': 'ssim_scores' }, 'PSNR': { 'dtype': 'scalar', 'vtype': 'plot', 'win': 'psnr_scores' }, 'Test_Real': { 'dtype': output_dtype, 'vtype': output_vtype, 'win': 'real_test' }, 'Test_Fakes_Encoder': { 'dtype': output_dtype, 'vtype': output_vtype, 'win': 'fakes_enc_test' }, 'Test_Disc_Accuracy': { 'dtype': 'scalar', 'vtype': 'plot', 'win': 'test_disc_acc' }, } self.visualizer_test.register(self.params_visualizer_test) # display training progress self.print_train = '[%d/%d][%d/%d] ' for item in self.params_loss_train: self.print_train = self.print_train + item + " %.3f " self.print_test = '[%d/%d][%d/%d] ' for item in self.params_loss_test: self.print_test = self.print_test + item + " %.3f " self.giterations = 0 self.d_iter = args.d_iter self.g_iter = args.g_iter self.clamp_lower = args.clamp_lower self.clamp_upper = args.clamp_upper print('Discriminator:', self.modelD[0]) print('Generator:', self.modelG[0]) print('Encoder:', self.Encoder) # define a zero tensor self.t_zero = Variable(torch.zeros(1))
<<<<<<< HEAD # self.log_loss_test = plugins.Logger(args.logs, 'TestLogger.txt') self.params_loss_test = ['Loss', 'Accuracy'] # self.log_loss_test.register(self.params_loss_test) ======= self.log_loss = plugins.Logger( args.logs_dir, 'TestLogger.txt', self.save_results ) self.params_loss = ['Loss', 'Accuracy'] self.log_loss.register(self.params_loss) >>>>>>> original/master # monitor testing self.monitor = plugins.Monitor() self.params_monitor = { 'Loss': {'dtype': 'running_mean'}, 'Accuracy': {'dtype': 'running_mean'} } self.monitor.register(self.params_monitor) # visualize testing <<<<<<< HEAD # self.visualizer_test = plugins.Visualizer(self.port, 'Test') # self.params_visualizer_test = { # 'Loss': {'dtype': 'scalar', 'vtype': 'plot'}, # 'Accuracy': {'dtype': 'scalar', 'vtype': 'plot'}, # 'Image': {'dtype': 'image', 'vtype': 'image'}, # 'Images': {'dtype': 'images', 'vtype': 'images'}, # }
def __init__(self, args, model, criterion, evaluation): self.args = args self.model = model self.criterion = criterion self.evaluation = evaluation self.save_results = args.save_results self.env = args.env self.port = args.port self.dir_save = args.save_dir self.log_type = args.log_type self.cuda = args.cuda self.nepochs = args.nepochs self.batch_size = args.batch_size self.resolution_high = args.resolution_high self.resolution_wide = args.resolution_wide # for classification self.labels = torch.zeros(self.batch_size).long() self.inputs = torch.zeros(self.batch_size, self.resolution_high, self.resolution_wide) if args.cuda: self.labels = self.labels.cuda() self.inputs = self.inputs.cuda() self.inputs = Variable(self.inputs, volatile=True) self.labels = Variable(self.labels, volatile=True) # logging testing self.log_loss = plugins.Logger(args.logs_dir, 'TestLogger.txt', self.save_results) self.params_loss = ['Loss', 'Accuracy'] self.log_loss.register(self.params_loss) # monitor testing self.monitor = plugins.Monitor() self.params_monitor = { 'Loss': { 'dtype': 'running_mean' }, 'Accuracy': { 'dtype': 'running_mean' } } self.monitor.register(self.params_monitor) # visualize testing self.visualizer = plugins.Visualizer(self.port, self.env, 'Test') self.params_visualizer = { 'Loss': { 'dtype': 'scalar', 'vtype': 'plot', 'win': 'loss', 'layout': { 'windows': ['train', 'test'], 'id': 1 } }, 'Accuracy': { 'dtype': 'scalar', 'vtype': 'plot', 'win': 'accuracy', 'layout': { 'windows': ['train', 'test'], 'id': 1 } }, 'Test_Image': { 'dtype': 'image', 'vtype': 'image', 'win': 'test_image' }, 'Test_Images': { 'dtype': 'images', 'vtype': 'images', 'win': 'test_images' }, } self.visualizer.register(self.params_visualizer) if self.log_type == 'traditional': # display training progress self.print_formatter = 'Test [%d/%d][%d/%d] ' for item in self.params_loss: self.print_formatter += item + " %.4f " elif self.log_type == 'progressbar': # progress bar message formatter self.print_formatter = '({}/{})' \ ' Load: {:.6f}s' \ ' | Process: {:.3f}s' \ ' | Total: {:}' \ ' | ETA: {:}' for item in self.params_loss: self.print_formatter += ' | ' + item + ' {:.4f}' self.evalmodules = [] self.losses = {}
def __init__(self, args, model, criterion): self.args = args self.model = model self.criterion = criterion self.port = args.port self.dir_save = args.save self.cuda = args.cuda self.ngpu = args.ngpu self.nepochs = args.nepochs self.nchannels = args.nchannels self.batch_size = args.batch_size self.resolution_high = args.resolution_high self.resolution_wide = args.resolution_wide self.lr = args.learning_rate self.momentum = args.momentum self.adam_beta1 = args.adam_beta1 self.adam_beta2 = args.adam_beta2 self.weight_decay = args.weight_decay self.optim_method = args.optim_method if self.optim_method == 'Adam': self.optimizer = optim.Adam( model.parameters(), lr=self.lr, weight_decay=self.weight_decay, betas=(self.adam_beta1, self.adam_beta2), ) elif self.optim_method == 'RMSprop': self.optimizer = optim.RMSprop( model.parameters(), lr=self.lr, weight_decay=self.weight_decay, ) elif self.optim_method == 'SGD': self.optimizer = optim.SGD(model.parameters(), lr=self.lr, weight_decay=self.weight_decay, momentum=self.momentum, nesterov=True) else: raise (Exception("Unknown Optimization Method")) # for classification self.label = torch.zeros(self.batch_size).long() self.input = torch.zeros(self.batch_size, self.nchannels, self.resolution_high, self.resolution_wide) if args.cuda: self.label = self.label.cuda() self.input = self.input.cuda() self.input = Variable(self.input) self.label = Variable(self.label) # logging training self.log_loss_train = plugins.Logger(args.logs, 'TrainLogger.txt') self.params_loss_train = ['Loss', 'Accuracy'] self.log_loss_train.register(self.params_loss_train) # monitor training self.monitor_train = plugins.Monitor() self.params_monitor_train = ['Loss', 'Accuracy'] self.monitor_train.register(self.params_monitor_train) # visualize training self.visualizer_train = plugins.Visualizer(self.port, 'Train') self.params_visualizer_train = { 'Loss': { 'dtype': 'scalar', 'vtype': 'plot' }, 'Accuracy': { 'dtype': 'scalar', 'vtype': 'plot' }, 'Image': { 'dtype': 'image', 'vtype': 'image' }, 'Images': { 'dtype': 'images', 'vtype': 'images' }, } self.visualizer_train.register(self.params_visualizer_train) # display training progress self.print_train = 'Train [%d/%d][%d/%d] ' for item in self.params_loss_train: self.print_train = self.print_train + item + " %.4f " self.evalmodules = [] self.losses_train = {} print(self.model)
def __init__(self, args, model, criterion, evaluation): self.args = args self.model = model self.criterion = criterion self.evaluation = evaluation self.nepochs = args.nepochs # for classification self.labels = torch.zeros(args.batch_size).long() self.inputs = torch.zeros(args.batch_size, args.resolution_high, args.resolution_wide) if args.cuda: self.labels = self.labels.cuda() self.inputs = self.inputs.cuda() self.inputs = Variable(self.inputs) self.labels = Variable(self.labels) # logging testing self.log_loss = plugins.Logger(args.logs_dir, 'TestLogger.txt', args.save_results) params_loss = ['ACC'] self.log_loss.register(params_loss) # monitor testing self.monitor = plugins.Monitor() self.params_monitor = { 'ACC': { 'dtype': 'running_mean' }, } self.monitor.register(self.params_monitor) # visualize testing self.visualizer = plugins.Visualizer(args.port, args.env, 'Test') params_visualizer = { 'ACC': { 'dtype': 'scalar', 'vtype': 'plot', 'win': 'acc', 'layout': { 'windows': ['train', 'test'], 'id': 1 } }, # 'Test_Image': {'dtype': 'image', 'vtype': 'image', # 'win': 'test_image'}, # 'Test_Images': {'dtype': 'images', 'vtype': 'images', # 'win': 'test_images'}, } self.visualizer.register(params_visualizer) # display training progress self.print_formatter = 'Test [%d/%d]] ' for item in ['ACC']: self.print_formatter += item + " %.4f " self.losses = {} # self.binage = torch.Tensor([10,22.5,27.5,32.5,37.5,42.5,47.5,55,75]) # self.binage = torch.Tensor([10,25,35,45,55,75]) self.binage = torch.Tensor([19, 37.5, 52.5, 77])
def __init__(self, args, model, criterion): self.args = args self.model = model self.criterion = criterion self.port = args.port self.dir_save = args.save self.cuda = args.cuda self.nepochs = args.nepochs if args.nepochs is None: self.nepochs = 0 self.nchannels = args.ngchannels self.nechannels = args.nechannels self.batch_size = args.batch_size self.resolution_high = args.resolution_high self.resolution_wide = args.resolution_wide self.nlatent = args.nlatent self.out_steps = args.out_steps self.learning_rate = args.learning_rate self.momentum = args.momentum self.adam_beta1 = args.adam_beta1 self.adam_beta2 = args.adam_beta2 self.weight_decay = args.weight_decay self.optim_method = getattr(optim, args.optim_method) self.optimizer = {} self.optimizer["netG"] = self.optim_method(model["netG"].parameters(), lr=self.learning_rate) self.composition = torch.FloatTensor(self.batch_size, self.nchannels, self.resolution_high, self.resolution_wide) self.metadata = torch.FloatTensor(self.batch_size, self.nechannels, self.resolution_high, self.resolution_wide) if args.out_images is None: self.out_images = self.batch_size + 8 - (self.batch_size % 8) else: self.out_images = args.out_images if args.cuda: self.composition = self.composition.cuda() self.metadata = self.metadata.cuda() self.composition = Variable(self.composition) self.metadata = Variable(self.metadata) self.log_loss_train = plugins.Logger(args.logs, 'TrainLogger.txt') self.params_loss_train = ['L2'] self.log_loss_train.register(self.params_loss_train) self.log_monitor_train = plugins.Monitor(smoothing=False) self.params_monitor_train = ['L2'] self.log_monitor_train.register(self.params_monitor_train) self.log_loss_test = plugins.Logger(args.logs, 'TestLogger.txt') self.params_loss_test = ['L2'] self.log_loss_test.register(self.params_loss_test) self.log_monitor_test = plugins.Monitor(smoothing=False) self.params_monitor_test = ['L2'] self.log_monitor_test.register(self.params_monitor_test) # visualize training self.visualizer_train = plugins.Visualizer(self.port, 'Train', args.images, args.pre_name) self.params_visualizer_train = { 'L2': { 'dtype': 'scalar', 'vtype': 'plot' } } self.visualizer_train.register(self.params_visualizer_train) # visualize testing self.visualizer_test = plugins.Visualizer(self.port, 'Test', args.images, args.pre_name) self.params_visualizer_test = { 'L2': { 'dtype': 'scalar', 'vtype': 'plot' } } self.visualizer_test.register(self.params_visualizer_test) self.imgio_test = plugins.ImageIO(args.images, args.pre_name) # display training progress self.print_train = '[%04d/%04d][%02d/%02d] ' for item in self.params_loss_train: self.print_train = self.print_train + f"{item:4}" + " %8.6f " # display testing progress self.print_test = '[%d/%d][%d/%d] ' for item in self.params_loss_test: self.print_test = self.print_test + f"{item:4}" + " %8.6f " self.giterations = 1 self.losses_train = {} self.losses_test = {} self.mu_sigma = {}
def __init__(self, args, netD, netG, netE): self.netD = netD self.netG = netG self.netE = netE for p in self.netD.parameters(): p.requires_grad = False for p in self.netG.parameters(): p.requires_grad = False self.cuda = args.cuda self.device = torch.device("cuda" if ( self.cuda and torch.cuda.is_available()) else "cpu") self.args = args self.nchannels = args.nchannels self.resolution_high = args.resolution_high self.resolution_wide = args.resolution_wide self.nz = args.nz self.wcom = args.disc_loss_weight self.ssim_weight = args.ssim_weight self.cuda = args.cuda self.citers = args.citers self.lr = args.learning_rate_vae self.momentum = args.momentum self.batch_size = args.batch_size self.use_encoder = args.use_encoder self.start_index = args.start_index self.noise = torch.FloatTensor(self.batch_size, self.nz, 1, 1).normal_(0, 1).to(self.device) self.noise.requires_grad = True self.epsilon = torch.randn(self.batch_size, self.nz).to(self.device) self.optimizerC = optim.RMSprop([self.noise], lr=self.lr) self.scheduler = plugins.AutomaticLRScheduler( self.optimizerC, maxlen=500, factor=0.1, patience=self.args.scheduler_patience) self.log_eval_loss = plugins.Logger(args.logs, 'CompletionLog.txt') self.params_eval_loss = [ 'Image', 'Input_SSIM', 'Input_PSNR', 'SSIM', 'PSNR', 'C_Loss', 'P_Loss' ] self.log_eval_loss.register(self.params_eval_loss) # Create the mask # self.pmask = torch.ones(self.batch_size, self.nchannels, self.resolution_high, self.args.resolution_wide) # if args.mask_type == 'central': # self.l = int(self.resolution_high*self.args.scale) # self.u = int(self.resolution_wide*(1-self.args.scale)) # if self.l != self.u: # self.pmask[:, :, 5+self.l:5+self.u, self.l:self.u] = 0.0 # elif args.mask_type == 'periocular': # self.pmask[:,:,int(0.4*self.resolution_high):,:] = 0.0 # self.pmask[:,:,:,:8] = 0.0 # self.pmask[:,:,:,56:] = 0.0 # self.nmask = torch.add(-self.pmask, 1) self.pmask = torch.ones(self.resolution_high, self.args.resolution_wide).to(self.device) if args.mask_type == 'central': self.l = int(self.resolution_high * self.args.scale) self.u = int(self.resolution_wide * (1 - self.args.scale)) if self.l != self.u: self.pmask[5 + self.l:5 + self.u, self.l:self.u] = 0.0 elif args.mask_type == 'periocular': self.pmask[int(0.4 * self.resolution_high):, :] = 0.0 # self.pmask[int(0.4*self.resolution_high):int(0.9*self.resolution_high),8:56] = 0.0 if self.args.scale == 0.3: self.pmask[:, :8] = 0.0 self.pmask[:, 56:] = 0.0 self.nmask = torch.add(-self.pmask, 1) self.non_mask_pixels = (self.nmask.view(-1) == 0).nonzero().squeeze() # create coefficient matrix self.num_pixels = self.resolution_high * self.resolution_wide A = scipy.sparse.identity(self.num_pixels, format='lil') for y in range(self.resolution_high): for x in range(self.resolution_wide): if self.nmask[y, x]: index = x + y * self.resolution_wide A[index, index] = 4 if index + 1 < self.num_pixels: A[index, index + 1] = -1 if index - 1 >= 0: A[index, index - 1] = -1 if index + self.resolution_wide < self.num_pixels: A[index, index + self.resolution_wide] = -1 if index - self.resolution_wide >= 0: A[index, index - self.resolution_wide] = -1 A = torch.Tensor(A.toarray()) # self.A = Variable(A) self.Ainv = torch.inverse(A).to(self.device) # Construct Poisson Matrix for Blending P = 4 * torch.eye(self.num_pixels) diag = np.arange(0, self.num_pixels - 1) P[diag, diag + 1] = -1 P[diag + 1, diag] = -1 diag = np.arange(self.resolution_high, self.num_pixels) P[diag - self.resolution_high, diag] = -1 P[diag, diag - self.resolution_high] = -1 self.P = P.to(self.device) self.criterion = nn.L1Loss().to(self.device) self.ssim_loss = pytorch_ssim.SSIM() self.blend = args.blend self.losses = {} self.log_eval_monitor = plugins.Monitor() self.params_eval_monitor = [ 'Image', 'Input_SSIM', 'Input_PSNR', 'SSIM', 'PSNR', 'C_Loss', 'P_Loss' ] self.log_eval_monitor.register(self.params_eval_monitor) self.print = '[%d/%d] [%d/%d]' for item in self.params_eval_loss: if item == 'Image': self.print = self.print + item + " %d " else: self.print = self.print + item + " %.4f " # self.visualizer = plugins.Visualizer(port=self.args.port, env=self.args.env, title='Image Completion') # self.visualizer_dict = { # 'Recon_SSIM': {'dtype':'scalar', 'vtype': 'plot', 'win': 'ssim'}, # 'Recon_PSNR': {'dtype':'scalar', 'vtype': 'plot', 'win': 'psnr'}, # 'Z_Norm': {'dtype':'scalar', 'vtype': 'plot', 'win': 'z_norm'}, # 'Contextual_Loss': {'dtype':'scalar', 'vtype': 'plot', 'win': 'Contextual_Loss'}, # 'Perceptual_Loss': {'dtype':'scalar', 'vtype': 'plot', 'win': 'Perceptual_Loss'}, # # 'SSIM_Loss': {'dtype':'scalar', 'vtype': 'plot', 'win': 'SSIM_Loss'}, # 'LR': {'dtype':'scalar', 'vtype': 'plot', 'win': 'lr'}, # 'Original_Image': {'dtype':'images', 'vtype': 'images', 'win': 'input'}, # 'Occluded_Image': {'dtype':'images', 'vtype': 'images', 'win': 'input_real'}, # 'Fake_Image': {'dtype':'images', 'vtype': 'images', 'win': 'fake'}, # 'Completed_Image': {'dtype':'images', 'vtype': 'images', 'win': 'completed'}, # } # self.visualizer.register(self.visualizer_dict) self.c_loss = 0 self.d_loss = 0 self.disc_type = args.disc_type
def __init__(self, args, model, criterion, evaluation): self.args = args self.model = model self.criterion = criterion self.evaluation = evaluation self.save_results = args.save_results self.env = args.env self.port = args.port self.dir_save = args.save_dir self.log_type = args.log_type self.cuda = args.cuda self.nepochs = args.nepochs self.batch_size = args.batch_size self.resolution_high = args.resolution_high self.resolution_wide = args.resolution_wide self.lr = args.learning_rate self.optim_method = args.optim_method self.optim_options = args.optim_options self.scheduler_method = args.scheduler_method self.scheduler_options = args.scheduler_options self.weight_loss = args.weight_loss # setting optimizer for multiple modules self.module_list = nn.ModuleList() for key in list(self.model): self.module_list.append(self.model[key]) self.optimizer = getattr(optim, self.optim_method)( self.module_list.parameters(), lr=self.lr, **self.optim_options) if self.scheduler_method is not None: self.scheduler = getattr(optim.lr_scheduler, self.scheduler_method)( self.optimizer, **self.scheduler_options) # for classification self.labels = torch.zeros(self.batch_size).long() self.inputs = torch.zeros(self.batch_size, self.resolution_high, self.resolution_wide) if args.cuda: self.labels = self.labels.cuda() self.inputs = self.inputs.cuda() self.inputs = Variable(self.inputs) self.labels = Variable(self.labels) # logging training self.log_loss = plugins.Logger(args.logs_dir, 'TrainLogger.txt', self.save_results) self.params_loss = ['LearningRate', 'Loss'] #, 'TAR'] self.log_loss.register(self.params_loss) # monitor training self.monitor = plugins.Monitor() self.params_monitor = { 'LearningRate': { 'dtype': 'running_mean' }, 'Loss': { 'dtype': 'running_mean' }, # 'TAR': {'dtype': 'running_mean'}, } self.monitor.register(self.params_monitor) # visualize training self.visualizer = plugins.Visualizer(self.port, self.env, 'Train') self.params_visualizer = { 'LearningRate': { 'dtype': 'scalar', 'vtype': 'plot', 'win': 'learning_rate', 'layout': { 'windows': ['train', 'test'], 'id': 0 } }, 'Loss': { 'dtype': 'scalar', 'vtype': 'plot', 'win': 'loss', 'layout': { 'windows': ['train', 'test'], 'id': 0 } }, # 'TAR': {'dtype': 'scalar', 'vtype': 'plot', 'win': 'mAP', # 'layout': {'windows': ['train', 'test'], 'id': 0}}, } self.visualizer.register(self.params_visualizer) # display training progress self.print_formatter = 'Train [%d/%d][%d/%d] ' for item in self.params_loss: self.print_formatter += item + " %.4f " self.evalmodules = [] self.losses = {}