class Solver(object): """docstring for Solver""" def __init__(self): super(Solver, self).__init__() def initialize(self, opt): self.opt = opt self.visual = Visualizer() self.visual.initialize(self.opt) def run_solver(self): if self.opt.mode == "train": self.train_networks() else: self.test_networks(self.opt) def train_networks(self): # init train setting self.init_train_setting() # for every epoch for epoch in range(self.opt.epoch_count, self.epoch_len + 1): # train network self.train_epoch(epoch) # update learning rate self.cur_lr = self.train_model.update_learning_rate() # save checkpoint if needed if epoch % self.opt.save_epoch_freq == 0: self.train_model.save_ckpt(epoch) # save the last epoch self.train_model.save_ckpt(self.epoch_len) def init_train_setting(self): self.train_dataset = create_dataloader(self.opt) self.train_model = create_model(self.opt) self.train_total_steps = 0 self.epoch_len = self.opt.niter + self.opt.niter_decay self.cur_lr = self.opt.lr def train_epoch(self, epoch): epoch_start_time = time.time() epoch_steps = 0 last_print_step_t = time.time() for idx, batch in enumerate(self.train_dataset): self.train_total_steps += self.opt.batch_size epoch_steps += self.opt.batch_size # train network self.train_model.feed_batch(batch) self.train_model.optimize_paras( train_gen=(idx % self.opt.train_gen_iter == 0)) # print losses if self.train_total_steps % self.opt.print_losses_freq == 0: cur_losses = self.train_model.get_latest_losses() avg_step_t = (time.time() - last_print_step_t) / self.opt.print_losses_freq last_print_step_t = time.time() # print loss info to command line info_dict = { 'epoch': epoch, 'epoch_len': self.epoch_len, 'epoch_steps': idx * self.opt.batch_size, 'epoch_steps_len': len(self.train_dataset), 'step_time': avg_step_t, 'cur_lr': self.cur_lr, 'log_path': os.path.join(self.opt.ckpt_dir, self.opt.log_file), 'losses': cur_losses } self.visual.print_losses_info(info_dict) # plot loss map to visdom if self.train_total_steps % self.opt.plot_losses_freq == 0 and self.visual.display_id > 0: cur_losses = self.train_model.get_latest_losses() epoch_steps = idx * self.opt.batch_size self.visual.display_current_losses( epoch - 1, epoch_steps / len(self.train_dataset), cur_losses) # display image on visdom if self.train_total_steps % self.opt.sample_img_freq == 0 and self.visual.display_id > 0: cur_vis = self.train_model.get_latest_visuals() self.visual.display_online_results(cur_vis, epoch) # latest_aus = model.get_latest_aus() # visual.log_aus(epoch, epoch_steps, latest_aus, opt.ckpt_dir) def test_networks(self, opt): self.init_test_setting(opt) self.test_ops() def init_test_setting(self, opt): self.test_dataset = create_dataloader(opt) self.test_model = create_model(opt) def test_ops(self): for batch_idx, batch in enumerate(self.test_dataset): with torch.no_grad(): # interpolate several times faces_list = [batch['src_img'].float().numpy()] paths_list = [batch['src_path'], batch['tar_path']] for idx in range(self.opt.interpolate_len): cur_alpha = (idx + 1.) / float(self.opt.interpolate_len) cur_tar_aus = cur_alpha * batch['tar_aus'] + ( 1 - cur_alpha) * batch['src_aus'] # print(batch['src_aus']) # print(cur_tar_aus) test_batch = { 'src_img': batch['src_img'], 'tar_aus': cur_tar_aus, 'src_aus': batch['src_aus'], 'tar_img': batch['tar_img'] } self.test_model.feed_batch(test_batch) self.test_model.forward() cur_gen_faces = self.test_model.fake_img.cpu().float( ).numpy() faces_list.append(cur_gen_faces) faces_list.append(batch['tar_img'].float().numpy()) self.test_save_imgs(faces_list, paths_list) def test_save_imgs(self, faces_list, paths_list): for idx in range(len(paths_list[0])): src_name = os.path.splitext(os.path.basename( paths_list[0][idx]))[0] tar_name = os.path.splitext(os.path.basename( paths_list[1][idx]))[0] if self.opt.save_test_gif: import imageio imgs_numpy_list = [] for face_idx in range(len(faces_list) - 1): # remove target image cur_numpy = np.array( self.visual.numpy2im(faces_list[face_idx][idx])) imgs_numpy_list.extend([cur_numpy for _ in range(3)]) saved_path = os.path.join(self.opt.results, "%s_%s.gif" % (src_name, tar_name)) imageio.mimsave(saved_path, imgs_numpy_list) else: # concate src, inters, tar faces concate_img = np.array(self.visual.numpy2im( faces_list[0][idx])) for face_idx in range(1, len(faces_list)): concate_img = np.concatenate( (concate_img, np.array( self.visual.numpy2im(faces_list[face_idx][idx]))), axis=1) concate_img = Image.fromarray(concate_img) # save image saved_path = os.path.join(self.opt.results, "%s_%s.jpg" % (src_name, tar_name)) concate_img.save(saved_path) print("[Success] Saved images to %s" % saved_path)
class Solver(object): """docstring for Solver""" def __init__(self): super(Solver, self).__init__() def initialize(self, opt): self.opt = opt self.visual = Visualizer() self.visual.initialize(self.opt) def run_solver(self): if self.opt.mode == "train": self.train_networks() else: self.test_networks() def train_networks(self): # init train setting self.init_train_setting() # for every epoch for epoch in range(self.opt.epoch_count, self.epoch_len + 1): # train network self.train_epoch(epoch) # update learning rate self.cur_lr = self.train_model.update_learning_rate() # save checkpoint if needed if epoch % self.opt.save_epoch_freq == 0: self.train_model.save_ckpt(epoch) # save the last epoch self.train_model.save_ckpt(self.epoch_len) def init_train_setting(self): self.train_dataset = create_dataloader(self.opt) self.train_model = create_model(self.opt) self.train_total_steps = 0 self.epoch_len = self.opt.niter + self.opt.niter_decay self.cur_lr = self.opt.lr def train_epoch(self, epoch): epoch_start_time = time.time() epoch_steps = 0 last_print_step_t = time.time() for idx, batch in enumerate(self.train_dataset): self.train_total_steps += self.opt.batch_size epoch_steps += self.opt.batch_size # train network self.train_model.feed_batch(batch) self.train_model.optimize_paras(train_recog=(idx % self.opt.train_recog_iter == 0), \ train_dis=(idx % self.opt.train_dis_iter == 0)) # print losses if self.train_total_steps % self.opt.print_losses_freq == 0: cur_losses = self.train_model.get_latest_losses() avg_step_t = (time.time() - last_print_step_t) / self.opt.print_losses_freq last_print_step_t = time.time() # print loss info to command line info_dict = { 'epoch': epoch, 'epoch_len': self.epoch_len, 'epoch_steps': idx * self.opt.batch_size, 'epoch_steps_len': len(self.train_dataset), 'step_time': avg_step_t, 'cur_lr': self.cur_lr, 'log_path': os.path.join(self.opt.ckpt_dir, self.opt.log_file), 'losses': cur_losses } self.visual.print_losses_info(info_dict) # plot loss map to visdom if self.train_total_steps % self.opt.plot_losses_freq == 0 and self.visual.display_id > 0: cur_losses = self.train_model.get_latest_losses() epoch_steps = idx * self.opt.batch_size self.visual.display_current_losses( epoch - 1, epoch_steps / len(self.train_dataset), cur_losses) # display image on visdom if self.train_total_steps % self.opt.sample_img_freq == 0 and self.visual.display_id > 0: cur_vis = self.train_model.get_latest_visuals() self.visual.display_online_results(cur_vis, epoch) def test_networks(self): self.init_test_setting() self.test_ops() self.cal_f1_scores() def init_test_setting(self): self.test_dataset = create_dataloader(self.opt) self.test_model = create_model(self.opt) self.aus_id_list = list( map(lambda x: "AU%02d" % int(x), list(self.opt.aus_id.split(',')))) def test_ops(self): real_aus_list = [] pred_aus_list = [] for batch_idx, batch in enumerate(self.test_dataset): with torch.no_grad(): self.test_model.feed_batch(batch) self.test_model.forward() real_aus_list.extend( list(self.test_model.img_aus.cpu().float().numpy())) pred_aus_list.extend( list(self.test_model.gen_aus.cpu().float().numpy())) print( ">>> %d/%d" % (batch_idx * self.opt.batch_size, len(self.test_dataset))) self.real_aus = np.array(real_aus_list) self.pred_aus = np.array(pred_aus_list) def cal_f1_scores(self): f1_scores_list = [] for idx in range(self.opt.aus_nc): cur_real_aus = self.real_aus[:, idx].flatten().astype(int) cur_pred_aus_raw = self.pred_aus[:, idx].flatten() cur_pred_aus = (cur_pred_aus_raw > 0.5).astype( int ) # convert to binary array, based on threadhold 0.5, sigmoid function print(">>> %s" % self.aus_id_list[idx]) print("cur_real_aus", cur_real_aus.tolist()) # print("cur_pred_aus_raw", cur_pred_aus_raw) print("cur_pred_aus", cur_pred_aus.tolist(), "\n") f1_scores_list.append( f1_score(cur_real_aus, cur_pred_aus, average='micro')) for k, v in zip(self.aus_id_list, f1_scores_list): print("%s: %f" % (k, v)) print("Avg : %f" % (sum(f1_scores_list) / len(f1_scores_list))) # log the result to files with open(os.path.join(self.opt.result_dir, "results.csv"), 'a+') as f: f.write( "%s, %s\n" % (self.opt.ckpt_dir, ", ".join([str(x) for x in f1_scores_list])))