def main(): # test(fc_model, test_loader) batch_size = 1 # plese note: For deep fool batch_size MUST be 1 train_loader, test_loader = get_dataloader(batch_size) fc_model = FC_model() # Base model, used for classification, also used for crafting adversarial samples defender = AE() # Defender: input goes through this before going to the base model load_model(fc_model, './pretrained_models/fc_model.pth') load_model(defender, './pretrained_models/autoencoder_pretrained.pth') fc_model.to(device) defender.to(device) criterion = nn.CrossEntropyLoss() # craft adversarial examples for epsilon value in [0,1] at step size of 0.05 ''' acc_list= [] for i in range(21): acc_list.append(adv_attack(fc_model, defender, test_loader, criterion, i*0.05)) print(acc_list) ''' # defender = None # FGSM attack adv_attack(fc_model, defender, test_loader, criterion, attack_type="fgsm") # deep fool attack adv_attack(fc_model, defender, test_loader, criterion, attack_type="deepfool") # universal attack adv_attack(fc_model, defender, test_loader, criterion, attack_type="universal")
def main(): # Get command line arguments args = get_args() # Create the model ae = AE() # Load the trained model weights load_dir = './save' checkpoint_path = os.path.join(load_dir, str(args.epoch) + '.tar') if os.path.isfile(checkpoint_path): print('Loading checkpoint') checkpoint = torch.load(checkpoint_path) model_epoch = checkpoint['epoch'] ae.load_state_dict(checkpoint['state_dict']) print('Loaded checkpoint at {}'.format(model_epoch)) else: print('Checkpoint {} not available'.format(args.epoch)) # Evaluate for path in args.test_images: img, x = utils.load_test(path) print(img.shape, x.shape) start_time = time.clock() enc, dec = ae(x) end_time = time.clock() print('Tested in {} seconds'.format(end_time - start_time)) dec = dec.view(60, 60).data.numpy() plt.subplot(121) plt.imshow(img, cmap='gray') plt.subplot(122) plt.imshow(dec, cmap='gray') plt.show()
def __init__(self, params): self.params = params self.tune_dir = "{}/{}-{}/{}".format(params.exp_id, params.src_lang, params.tgt_lang, params.norm_embeddings) self.tune_best_dir = "{}/best".format(self.tune_dir) self.tune_export_dir = "{}/export".format(self.tune_dir) if self.params.eval_file == 'wiki': self.eval_file = '../data/bilingual_dicts/{}-{}.5000-6500.txt'.format( self.params.src_lang, self.params.tgt_lang) self.eval_file2 = '../data/bilingual_dicts/{}-{}.5000-6500.txt'.format( self.params.tgt_lang, self.params.src_lang) elif self.params.eval_file == 'wacky': self.eval_file = '../data/bilingual_dicts/{}-{}.test.txt'.format( self.params.src_lang, self.params.tgt_lang) self.eval_file2 = '../data/bilingual_dicts/{}-{}.test.txt'.format( self.params.tgt_lang, self.params.src_lang) else: print('Invalid eval file!') # self.seed = random.randint(0, 1000) # self.seed = 41 # self.initialize_exp(self.seed) self.X_AE = AE(params) self.Y_AE = AE(params) self.D_X = Discriminator(input_size=params.d_input_size, hidden_size=params.d_hidden_size, output_size=params.d_output_size) self.D_Y = Discriminator(input_size=params.d_input_size, hidden_size=params.d_hidden_size, output_size=params.d_output_size) self.nets = [self.X_AE, self.Y_AE, self.D_X, self.D_Y] self.loss_fn = torch.nn.BCELoss() self.loss_fn2 = torch.nn.CosineSimilarity(dim=1, eps=1e-6)
def main(_): if FLAGS.exp_name is None: FLAGS.exp_name = "reconstrued_results_unitLength" + str( int(FLAGS.latent_dim / FLAGS.latent_num)) image_shape = [ int(i) for i in FLAGS.image_shape.strip('()[]{}').split(',') ] dirs = init_directories(FLAGS.exp_name, FLAGS.output_dir) dirs['data'] = '../npz_datas' if FLAGS.data_dir is None else FLAGS.data_dir dirs['codes'] = os.path.join(dirs['data'], 'codes/') create_directories(dirs, FLAGS.train, FLAGS.save_codes) output_dim = reduce(mul, image_shape, 1) run_config = tf.ConfigProto(allow_soft_placement=True) run_config.gpu_options.allow_growth = True run_config.gpu_options.per_process_gpu_memory_fraction = 0.9 sess = tf.Session(config=run_config) ae = AE( session=sess, arch=FLAGS.arch, lr=FLAGS.lr, alpha=FLAGS.alpha, beta=FLAGS.beta, latent_dim=FLAGS.latent_dim, latent_num=FLAGS.latent_num, class_net_unit_num=FLAGS.class_net_unit_num, output_dim=output_dim, batch_size=FLAGS.batch_size, image_shape=image_shape, exp_name=FLAGS.exp_name, dirs=dirs, vis_reconst=FLAGS.visualize_reconstruct, ) if FLAGS.train: data1Name = 'SVHN10WithBg_img1_oneguided_N20000x32x32x3_train' data_manager = ShapesDataManager( dirs['data'], data1Name, FLAGS.batch_size, image_shape, shuffle=False, file_ext=FLAGS.file_ext, train_fract=0.8, inf=True, supervised=False) # supervised=True for get label ae.train_iter1, ae.dev_iter1, ae.test_iter1 = data_manager.get_iterators( ) n_iters_per_epoch = data_manager.n_train // data_manager.batch_size FLAGS.stats_interval = int(FLAGS.stats_interval * n_iters_per_epoch) FLAGS.ckpt_interval = int(FLAGS.ckpt_interval * n_iters_per_epoch) n_iters = int(FLAGS.epochs * n_iters_per_epoch) ae.train(n_iters, n_iters_per_epoch, FLAGS.stats_interval, FLAGS.ckpt_interval)
def main(): device = torch.device("cuda:0" if args.cuda else "cpu") print(device) #model = VAE([128,128], lr=args.lr, eps=args.eps) model = AE([128,128]) model_path = '/hdd_c/data/miniWorld/trained_models/AE/dataset_5/AE.pth' data_path = '/hdd_c/data/miniWorld/dataset_5/' all_obs = read_data(data_path, max_num_eps=3000) np.random.shuffle(all_obs) all_obs = np.swapaxes(all_obs,1,3) all_obs = all_obs/255.0 print('Available number of obs: {}'.format(len(all_obs))) print(all_obs.shape) split_point = int(len(all_obs)*0.8) data_train = all_obs[:split_point] data_eval = all_obs[split_point:] #image = np.zeros([32,3,128,128]) #image = make_var(image) #z = model.encode(image) #r = model.decode(z) #dummy_data = np.ones([6400,3,128,128]) print(data_eval.shape) training_instance = trainAE(device, model, lr=args.lr, eps=args.eps, data_train=data_train, data_eval=data_eval, model_path=model_path) training_instance.train() #training_instance.eval(all_obs[-10:]) save_model(training_instance.model, model_path)
def build_model(self): if self.args.model_type == 'AE': self.model = cc(AE(self.config)) elif self.args.model_type == 'VQVAE': speaker_encoder = VoiceEncoder() self.model = cc(VQVAE(self.config, speaker_encoder)) elif self.args.model_type == 'DAE': speaker_encoder = VoiceEncoder() self.model = cc(AE_D(self.config, speaker_encoder)) elif self.args.model_type == 'AutoVC': speaker_encoder = VoiceEncoder() self.model = cc(AutoVC(32, 256, 512, 32, speaker_encoder)) elif self.args.model_type == 'Prosody': speaker_encoder = VoiceEncoder() self.model = cc(VQVAE_Prosody(self.config, speaker_encoder)) elif self.args.model_type == 'MBV': speaker_encoder = VoiceEncoder() self.model = cc(MBV(self.config, speaker_encoder)) elif self.args.model_type == 'NORM': speaker_encoder = VoiceEncoder() self.model = cc(MultipleNorm(self.config, speaker_encoder)) elif self.args.model_type == 'Attn': speaker_encoder = VoiceEncoder() self.model = cc(VQVAE_attn(self.config, speaker_encoder)) self.model.eval() if self.args.use_wavenet: from wavenet import build_model self.vocoder = cc(build_model()) return
def build_model(self): # create model, discriminator, optimizers self.model = cc( AE(c_in=self.config.c_in, c_h=self.config.c_h, c_latent=self.config.c_latent, c_cond=self.config.c_cond, c_out=self.config.c_in, kernel_size=self.config.kernel_size, bank_size=self.config.bank_size, bank_scale=self.config.bank_scale, s_enc_n_conv_blocks=self.config.s_enc_n_conv_blocks, s_enc_n_dense_blocks=self.config.s_enc_n_dense_blocks, d_enc_n_conv_blocks=self.config.d_enc_n_conv_blocks, d_enc_n_dense_blocks=self.config.d_enc_n_dense_blocks, s_subsample=self.config.s_subsample, d_subsample=self.config.d_subsample, dec_n_conv_blocks=self.config.dec_n_conv_blocks, dec_n_dense_blocks=self.config.dec_n_dense_blocks, upsample=self.config.upsample, act=self.config.act, dropout_rate=self.config.dropout_rate)) print(self.model) self.model.eval() self.noise_adder = NoiseAdder(0, self.config.gaussian_std) return
def __init__(self, params): self.params = params self.tune_dir = "{}/{}-{}/{}".format(params.exp_id, params.src_lang, params.tgt_lang, params.norm_embeddings) self.tune_best_dir = "{}/best".format(self.tune_dir) self.X_AE = AE(params) self.Y_AE = AE(params) self.D_X = Discriminator(input_size=params.d_input_size, hidden_size=params.d_hidden_size, output_size=params.d_output_size) self.D_Y = Discriminator(input_size=params.d_input_size, hidden_size=params.d_hidden_size, output_size=params.d_output_size) self.nets = [self.X_AE, self.Y_AE, self.D_X, self.D_Y] self.loss_fn = torch.nn.BCELoss() self.loss_fn2 = torch.nn.CosineSimilarity(dim=1, eps=1e-6)
def build_model(self): # create model, discriminator, optimizers self.model = cc( AE(c_in=self.config.c_in, c_h=self.config.c_h, c_latent=self.config.c_latent, c_cond=self.config.c_cond, c_out=self.config.c_in, kernel_size=self.config.kernel_size, bank_size=self.config.bank_size, bank_scale=self.config.bank_scale, s_enc_n_conv_blocks=self.config.s_enc_n_conv_blocks, s_enc_n_dense_blocks=self.config.s_enc_n_dense_blocks, d_enc_n_conv_blocks=self.config.d_enc_n_conv_blocks, d_enc_n_dense_blocks=self.config.d_enc_n_dense_blocks, s_subsample=self.config.s_subsample, d_subsample=self.config.d_subsample, dec_n_conv_blocks=self.config.dec_n_conv_blocks, dec_n_dense_blocks=self.config.dec_n_dense_blocks, upsample=self.config.upsample, act=self.config.act, dropout_rate=self.config.dropout_rate)) print(self.model) discr_input_size = self.config.segment_size / reduce( lambda x, y: x * y, self.config.d_subsample) self.discr = cc( LatentDiscriminator(input_size=discr_input_size, output_size=1, c_in=self.config.c_latent, c_h=self.config.dis_c_h, kernel_size=self.config.dis_kernel_size, n_conv_layers=self.config.dis_n_conv_layers, n_dense_layers=self.config.dis_n_dense_layers, d_h=self.config.dis_d_h, act=self.config.act, dropout_rate=self.config.dis_dropout_rate)) print(self.discr) self.gen_opt = torch.optim.Adam(self.model.parameters(), lr=self.config.gen_lr, betas=(self.config.beta1, self.config.beta2), amsgrad=self.config.amsgrad) self.dis_opt = torch.optim.Adam(self.discr.parameters(), lr=self.config.dis_lr, betas=(self.config.beta1, self.config.beta2), amsgrad=self.config.amsgrad) print(self.gen_opt) print(self.dis_opt) self.noise_adder = NoiseAdder(0, self.config.gaussian_std) return
def build_model(self): if self.args.model_type == 'AE': self.model = cc(AE(self.config)) elif self.args.model_type == 'VQVAE': self.model = cc(VQVAE(self.config)) elif self.args.model_type == 'DAE': speaker_encoder = VoiceEncoder() self.model = cc(AE_D(self.config, speaker_encoder)) elif self.args.model_type == 'AutoVC': speaker_encoder = VoiceEncoder() self.model = cc(AutoVC(32, 256, 512, 32, speaker_encoder)) self.model.eval() return
def build_model(self): # create model, discriminator, optimizers self.model = cc(AE(self.config)) print(self.model) optimizer = self.config['optimizer'] self.opt = torch.optim.Adam(self.model.parameters(), lr=optimizer['lr'], betas=(optimizer['beta1'], optimizer['beta2']), amsgrad=optimizer['amsgrad'], weight_decay=optimizer['weight_decay']) print(self.opt) return
def build_model(self): # create model, discriminator, optimizers self.model = cc(AE(self.config)) print(self.model) optimizer = self.config["optimizer"] self.opt = flow.optim.Adam( self.model.parameters(), lr=optimizer["lr"], betas=(optimizer["beta1"], optimizer["beta2"]), amsgrad=optimizer["amsgrad"], weight_decay=optimizer["weight_decay"], ) return
else: ltmgFile = args.datasetName + '/T2000_LTMG.txt' regulationMatrix = readLTMGnonsparse(args.LTMGDir, ltmgFile) regulationMatrix = torch.from_numpy(regulationMatrix) if args.precisionModel == 'Double': regulationMatrix = regulationMatrix.type(torch.DoubleTensor) elif args.precisionModel == 'Float': regulationMatrix = regulationMatrix.type(torch.FloatTensor) # Original if args.model == 'VAE': # model = VAE(dim=scData.features.shape[1]).to(device) model = VAE2d(dim=scData.features.shape[1]).to(device) elif args.model == 'AE': model = AE(dim=scData.features.shape[1]).to(device) if args.precisionModel == 'Double': model = model.double() optimizer = optim.Adam(model.parameters(), lr=1e-3) # Benchmark bench_pd = pd.read_csv(args.benchmark, index_col=0) # t1=pd.read_csv('/home/jwang/data/scData/13.Zeisel/Zeisel_cell_label.csv',index_col=0) bench_celltype = bench_pd.iloc[:, 0].to_numpy() # whether to output debuginfo in running time and memory consumption def debuginfoStr(info): if args.debuginfo: print('---' +
def main(_): if FLAGS.exp_name is None: FLAGS.exp_name = "reconstrued_results_unitLength" + str( int(FLAGS.latent_dim / FLAGS.latent_num)) image_shape = [ int(i) for i in FLAGS.image_shape.strip('()[]{}').split(',') ] dirs = init_directories(FLAGS.exp_name, FLAGS.output_dir) dirs[ 'data'] = '../../npz_datas' if FLAGS.data_dir is None else FLAGS.data_dir dirs['codes'] = os.path.join(dirs['data'], 'codes/') create_directories(dirs, FLAGS.train, FLAGS.save_codes) output_dim = reduce(mul, image_shape, 1) run_config = tf.ConfigProto(allow_soft_placement=True) run_config.gpu_options.allow_growth = True run_config.gpu_options.per_process_gpu_memory_fraction = 0.9 sess = tf.Session(config=run_config) ae = AE( session=sess, arch=FLAGS.arch, lr=FLAGS.lr, alpha=FLAGS.alpha, beta=FLAGS.beta, latent_dim=FLAGS.latent_dim, latent_num=FLAGS.latent_num, class_net_unit_num=FLAGS.class_net_unit_num, output_dim=output_dim, batch_size=FLAGS.batch_size, image_shape=image_shape, exp_name=FLAGS.exp_name, dirs=dirs, vis_reconst=FLAGS.visualize_reconstruct, ) if FLAGS.save_codes: sampleNum = 1000 # 50x64 large batch, forward prop only dataVisualName = 'SVHN10_img_N1000x32x32x3_testForModularity' data_manager = ShapesDataManager(dirs['data'], dataVisualName, FLAGS.batch_size, image_shape, shuffle=False, file_ext=FLAGS.file_ext, train_fract=1.0, inf=True) #data_manager.set_divisor_batch_size() ae.train_iter, ae.dev_iter, ae.test_iter = data_manager.get_iterators() ae.session.run(tf.global_variables_initializer()) #saved_step = ae.load() saved_step = ae.load_fixedNum(4000) assert saved_step > 1, "A trained model is needed to encode the data!" pathForSave = 'ValidateEncodedImgs' if not os.path.exists(pathForSave): os.mkdir(pathForSave) codes = [] images = [] for batch_num in range(int(sampleNum / FLAGS.batch_size)): img_batch, _mask1, _ = next(ae.train_iter) #code = ae.encode(img_batch) #[batch_size, reg_latent_dim] code, image = ae.getCodesAndImgs(pathForSave, img_batch, batch_num) codes.append(code) images.append(image) if batch_num < 5 or batch_num % 10 == 0: print(("Batch number {0}".format(batch_num))) codes = np.vstack(codes) images = np.vstack(images) codes_name = 'CIFAR3_codesModularityMetricsCal' filename = os.path.join(pathForSave, "codes_" + codes_name) #np.save(filename, codes) np.savez(filename + '.npz', imagesNorm0_1=images, codes=codes) print(("Images and Codes saved to: {0}".format(filename)))
import torchvision.transforms as transforms from preprocess import preprocess, Image_Dataset2 from model import AE import sys npy_path = sys.argv[1] model_path = sys.argv[2] trainX = np.load(npy_path) trainX_preprocessed, trainX_preprocessed2 = preprocess(trainX) img_dataset = Image_Dataset2(trainX_preprocessed) same_seeds(0) model = AE().cuda() criterion = nn.MSELoss() optimizer = torch.optim.AdamW(model.parameters(), lr=1e-5, weight_decay=1e-5) #optimizer = torch.optim.SGD(model.parameters(), lr=1e-3, weight_decay=1e-5, momentum=0.9) scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer, 'min') # adjust lr model.train() n_epoch = 300 # 準備 dataloader, model, loss criterion 和 optimizer img_dataloader = DataLoader(img_dataset, batch_size=64, shuffle=True) # 主要的訓練過程 for epoch in range(n_epoch):
torch.manual_seed(seed) torch.cuda.manual_seed(seed) torch.cuda.empty_cache() torch.backends.cudnn.benchmark = False torch.backends.cudnn.deterministic = True BATCH = 64 LR = 2e-5 EPOCH = 50 if __name__ == "__main__": train_x = np.load(sys.argv[1]) train_x = preprocess(train_x) train_dataset = ImageDataset(train_x) model = AE().cuda() criterion = nn.MSELoss() optimizer = torch.optim.Adam(model.parameters(), lr=LR) train_dataloader = DataLoader(train_dataset, batch_size=BATCH, shuffle=True) for epoch in range(EPOCH): model.train() for data in train_dataloader: x = data.cuda() latents, reconst_x = model(x) loss = criterion(reconst_x, x)
def main(_): if FLAGS.exp_name is None: FLAGS.exp_name = "separateRep_{}_{}_{}_lr_{}".format( FLAGS.arch, FLAGS.latent_dim, FLAGS.image_wh, FLAGS.lr) image_shape = [int(i) for i in FLAGS.image_shape.strip('()[]{}').split(',')] dirs = init_directories(FLAGS.exp_name, FLAGS.output_dir) dirs['data'] = '../../../npz_datas' if FLAGS.data_dir is None else FLAGS.data_dir dirs['codes'] = os.path.join(dirs['data'], 'codes/') create_directories(dirs, FLAGS.train, FLAGS.save_codes) output_dim = reduce(mul, image_shape, 1) run_config = tf.ConfigProto(allow_soft_placement=True) run_config.gpu_options.allow_growth = True run_config.gpu_options.per_process_gpu_memory_fraction = 0.9 sess = tf.Session(config=run_config) ae = AE( session=sess, arch=FLAGS.arch, lr=FLAGS.lr, alpha=FLAGS.alpha, beta=FLAGS.beta, latent_dim=FLAGS.latent_dim, latent_num=FLAGS.latent_num, class_net_unit_num=FLAGS.class_net_unit_num, output_dim=output_dim, batch_size=FLAGS.batch_size, image_shape=image_shape, exp_name=FLAGS.exp_name, dirs=dirs, vis_reconst=FLAGS.visualize_reconstruct, ) if FLAGS.visualize_reconstruct: sampleNum =1280 # 20x64 large batch, forward prop only dataVisualName1='pattern_(20x64)x64x64x3_unitLength9_test_visualdata1' dataVisualName2='pattern_(20x64)x64x64x3_unitLength9_test_visualdata2' data_manager = TeapotsDataManager(dirs['data'], dataVisualName1,dataVisualName2, FLAGS.batch_size, image_shape, shuffle=False,file_ext=FLAGS.file_ext, train_fract=0.8, inf=True,supervised=False) #data_manager.set_divisor_batch_size() #ae.train_iter, ae.dev_iter, ae.test_iter= data_manager.get_iterators() ae.train_iter1, ae.dev_iter1, ae.test_iter1,ae.train_iter2, ae.dev_iter2, ae.test_iter2= data_manager.get_iterators() ae.session.run(tf.global_variables_initializer()) # change the which iteration ckpt you want to use saved_step = ae.load_fixedNum(inter_num=5750) assert saved_step > 1, "A trained model is needed to encode the data!" pathForSave='VisualImgsResults' try: os.makedirs(pathForSave) except OSError as exc: # Python >2.5 if exc.errno == errno.EEXIST and os.path.isdir(pathForSave): pass else: raise for batch_num in range(int(sampleNum/FLAGS.batch_size)): img_batch1, _mask1, _ = next(ae.train_iter1) img_batch2, _mask2, _ = next(ae.train_iter2) #code = ae.encode(img_batch) #[batch_size, reg_latent_dim] ae.getVisualImgs(pathForSave,img_batch1, _mask1,img_batch2, _mask2,batch_num) if batch_num < 5 or batch_num % 10 == 0: print(("Batch number {0}".format(batch_num))) print("Images and Codes saved to Folder: VisualImgsResults")
from preprocess import * from model import AE checkpoint_path = './data/checkpoints' trainX = np.load('./data/trainX_new.npy') trainX_preprocessed = preprocess(trainX) model_path = f'./{checkpoint_path}/last_checkpoint.pth' model_prefix = '' if len(sys.argv) == 2: model_path = sys.argv[1] model_prefix = os.path.splitext(os.path.basename(model_path))[0] # load model model = AE().cuda() model.load_state_dict(torch.load(model_path)) # 畫出原圖 plt.figure(figsize=(10,4)) indexes = [1,2,3,6,7,9] imgs = trainX[indexes,] for i, img in enumerate(imgs): plt.subplot(2, 6, i+1, xticks=[], yticks=[]) plt.imshow(img) # 畫出 reconstruct 的圖 inp = torch.Tensor(trainX_preprocessed[indexes,]).cuda() latents, recs = model(inp) recs = ((recs+1)/2 ).cpu().detach().numpy() recs = recs.transpose(0, 2, 3, 1)
class BiAAE(object): def __init__(self, params): self.params = params self.tune_dir = "{}/{}-{}/{}".format(params.exp_id, params.src_lang, params.tgt_lang, params.norm_embeddings) self.tune_best_dir = "{}/best".format(self.tune_dir) self.X_AE = AE(params) self.Y_AE = AE(params) self.D_X = Discriminator(input_size=params.d_input_size, hidden_size=params.d_hidden_size, output_size=params.d_output_size) self.D_Y = Discriminator(input_size=params.d_input_size, hidden_size=params.d_hidden_size, output_size=params.d_output_size) self.nets = [self.X_AE, self.Y_AE, self.D_X, self.D_Y] self.loss_fn = torch.nn.BCELoss() self.loss_fn2 = torch.nn.CosineSimilarity(dim=1, eps=1e-6) def weights_init(self, m): # 正交初始化 if isinstance(m, torch.nn.Linear): torch.nn.init.orthogonal(m.weight) if m.bias is not None: torch.nn.init.constant(m.bias, 0.01) def weights_init2(self, m): # xavier_normal 初始化 if isinstance(m, torch.nn.Linear): torch.nn.init.xavier_normal(m.weight) if m.bias is not None: torch.nn.init.constant(m.bias, 0.01) def weights_init3(self, m): # 单位阵初始化 if isinstance(m, torch.nn.Linear): m.weight.data.copy_( torch.diag(torch.ones(self.params.g_input_size))) def freeze(self, m): for p in m.parameters(): p.requires_grad = False def defreeze(self, m): for p in m.parameters(): p.requires_grad = True def init_state(self, seed=-1): if torch.cuda.is_available(): # Move the network and the optimizer to the GPU for net in self.nets: net.cuda() self.loss_fn = self.loss_fn.cuda() self.loss_fn2 = self.loss_fn2.cuda() print('Init3 the model...') self.X_AE.apply(self.weights_init) # 可更改G初始化方式 self.Y_AE.apply(self.weights_init) # 可更改G初始化方式 self.D_X.apply(self.weights_init2) #print(self.D_X.map1.weight) self.D_Y.apply(self.weights_init2) def train(self, src_dico, tgt_dico, src_emb, tgt_emb, seed): # Load data if not os.path.exists(self.params.data_dir): print("Data path doesn't exists: %s" % self.params.data_dir) if not os.path.exists(self.tune_dir): os.makedirs(self.tune_dir) if not os.path.exists(self.tune_best_dir): os.makedirs(self.tune_best_dir) src_word2id = src_dico[1] tgt_word2id = tgt_dico[1] en = src_emb it = tgt_emb #eval = Evaluator(self.params, en,it, torch.cuda.is_available()) AE_optimizer = optim.SGD(filter( lambda p: p.requires_grad, list(self.X_AE.parameters()) + list(self.Y_AE.parameters())), lr=self.params.g_learning_rate) D_optimizer = optim.SGD(list(self.D_X.parameters()) + list(self.D_Y.parameters()), lr=self.params.d_learning_rate) D_A_acc_epochs = [] D_B_acc_epochs = [] D_A_loss_epochs = [] D_B_loss_epochs = [] d_loss_epochs = [] G_AB_loss_epochs = [] G_BA_loss_epochs = [] G_AB_recon_epochs = [] G_BA_recon_epochs = [] g_loss_epochs = [] L_Z_loss_epoches = [] acc_epochs = [] criterion_epochs = [] best_valid_metric = -100 try: for epoch in range(self.params.num_epochs): D_A_losses = [] D_B_losses = [] G_AB_losses = [] G_AB_recon = [] G_BA_losses = [] G_adv_losses = [] G_BA_recon = [] L_Z_losses = [] d_losses = [] g_losses = [] hit_A = 0 hit_B = 0 total = 0 start_time = timer() # lowest_loss = 1e5 label_D = to_variable( torch.FloatTensor(2 * self.params.mini_batch_size).zero_()) label_D[:self.params. mini_batch_size] = 1 - self.params.smoothing label_D[self.params.mini_batch_size:] = self.params.smoothing label_G = to_variable( torch.FloatTensor(self.params.mini_batch_size).zero_()) label_G = label_G + 1 - self.params.smoothing for mini_batch in range( 0, self.params.iters_in_epoch // self.params.mini_batch_size): for d_index in range(self.params.d_steps): D_optimizer.zero_grad() # Reset the gradients self.D_X.train() self.D_Y.train() view_X, view_Y = self.get_batch_data_fast(en, it) # Discriminator X Y_Z = self.Y_AE.encode(view_Y).detach() fake_X = self.X_AE.decode(Y_Z).detach() input = torch.cat([view_X, fake_X], 0) pred_A = self.D_X(input) D_A_loss = self.loss_fn(pred_A, label_D) # Discriminator Y X_Z = self.X_AE.encode(view_X).detach() fake_Y = self.Y_AE.decode(X_Z).detach() input = torch.cat([view_Y, fake_Y], 0) pred_B = self.D_Y(input) D_B_loss = self.loss_fn(pred_B, label_D) D_loss = D_A_loss + self.params.gate * D_B_loss D_loss.backward( ) # compute/store gradients, but don't change params d_losses.append(to_numpy(D_loss.data)) D_A_losses.append(to_numpy(D_A_loss.data)) D_B_losses.append(to_numpy(D_B_loss.data)) discriminator_decision_A = to_numpy(pred_A.data) hit_A += np.sum( discriminator_decision_A[:self.params. mini_batch_size] >= 0.5) hit_A += np.sum( discriminator_decision_A[self.params. mini_batch_size:] < 0.5) discriminator_decision_B = to_numpy(pred_B.data) hit_B += np.sum( discriminator_decision_B[:self.params. mini_batch_size] >= 0.5) hit_B += np.sum( discriminator_decision_B[self.params. mini_batch_size:] < 0.5) D_optimizer.step( ) # Only optimizes D's parameters; changes based on stored gradients from backward() # Clip weights #_clip(self.D_X, self.params.clip_value) #_clip(self.D_Y, self.params.clip_value) sys.stdout.write( "[%d/%d] :: Discriminator Loss: %.3f \r" % (mini_batch, self.params.iters_in_epoch // self.params.mini_batch_size, np.asscalar(np.mean(d_losses)))) sys.stdout.flush() total += 2 * self.params.mini_batch_size * self.params.d_steps for g_index in range(self.params.g_steps): # 2. Train G on D's response (but DO NOT train D on these labels) AE_optimizer.zero_grad() self.D_X.eval() self.D_Y.eval() view_X, view_Y = self.get_batch_data_fast(en, it) # Generator X_AE ## adversarial loss X_Z = self.X_AE.encode(view_X) X_recon = self.X_AE.decode(X_Z) Y_fake = self.Y_AE.decode(X_Z) pred_Y = self.D_Y(Y_fake) L_adv_X = self.loss_fn(pred_Y, label_G) L_recon_X = 1.0 - torch.mean( self.loss_fn2(view_X, X_recon)) # Generator Y_AE # adversarial loss Y_Z = self.Y_AE.encode(view_Y) Y_recon = self.Y_AE.decode(Y_Z) X_fake = self.X_AE.decode(Y_Z) pred_X = self.D_X(X_fake) L_adv_Y = self.loss_fn(pred_X, label_G) ### autoAE Loss L_recon_Y = 1.0 - torch.mean( self.loss_fn2(view_Y, Y_recon)) # cross-lingual Loss L_Z = 1.0 - torch.mean(self.loss_fn2(X_Z, Y_Z)) G_loss = self.params.adv_weight * (self.params.gate*L_adv_X + L_adv_Y) + \ self.params.mono_weight * (L_recon_X+L_recon_Y) + \ self.params.cross_weight * L_Z G_loss.backward() g_losses.append(to_numpy(G_loss.data)) G_AB_losses.append(to_numpy(L_adv_X.data)) G_BA_losses.append(to_numpy(L_adv_Y.data)) G_adv_losses.append( to_numpy(L_adv_Y.data + L_adv_X.data)) G_AB_recon.append(to_numpy(L_recon_X.data)) G_BA_recon.append(to_numpy(L_recon_Y.data)) L_Z_losses.append(to_numpy(L_Z.data)) AE_optimizer.step() # Only optimizes G's parameters sys.stdout.write( "[%d/%d] :: Generator Loss: %.3f \r" % (mini_batch, self.params.iters_in_epoch // self.params.mini_batch_size, np.asscalar(np.mean(g_losses)))) sys.stdout.flush() '''for each epoch''' D_A_acc_epochs.append(hit_A / total) D_B_acc_epochs.append(hit_B / total) G_AB_loss_epochs.append(np.asscalar(np.mean(G_AB_losses))) G_BA_loss_epochs.append(np.asscalar(np.mean(G_BA_losses))) D_A_loss_epochs.append(np.asscalar(np.mean(D_A_losses))) D_B_loss_epochs.append(np.asscalar(np.mean(D_B_losses))) G_AB_recon_epochs.append(np.asscalar(np.mean(G_AB_recon))) G_BA_recon_epochs.append(np.asscalar(np.mean(G_BA_recon))) L_Z_loss_epoches.append(np.asscalar(np.mean(L_Z_losses))) d_loss_epochs.append(np.asscalar(np.mean(d_losses))) g_loss_epochs.append(np.asscalar(np.mean(g_losses))) print( "Epoch {} : Discriminator Loss: {:.3f}, Discriminator Accuracy: {:.3f}, Generator Loss: {:.3f}, Time elapsed {:.2f} mins" .format(epoch, np.asscalar(np.mean(d_losses)), 0.5 * (hit_A + hit_B) / total, np.asscalar(np.mean(g_losses)), (timer() - start_time) / 60)) if (epoch + 1) % self.params.print_every == 0: # No need for discriminator weights X_Z = self.X_AE.encode(Variable(en)).data Y_Z = self.Y_AE.encode(Variable(it)).data mstart_time = timer() for method in [self.params.eval_method]: results = get_word_translation_accuracy( self.params.src_lang, src_word2id, X_Z, self.params.tgt_lang, tgt_word2id, Y_Z, method=method, dico_eval=self.params.eval_file) acc1 = results[0][1] print('{} takes {:.2f}s'.format(method, timer() - mstart_time)) print('Method:{} score:{:.4f}'.format(method, acc1)) csls, size = dist_mean_cosine(self.params, X_Z, Y_Z) criterion = size if criterion > best_valid_metric: print("New criterion value: {}".format(criterion)) best_valid_metric = criterion fp = open( self.tune_best_dir + "/seed_{}_dico_{}_gate_{}_epoch_{}_acc_{:.3f}.tmp". format(seed, self.params.dico_build, self.params.gate, epoch, acc1), 'w') fp.close() torch.save( self.X_AE.state_dict(), self.tune_best_dir + '/seed_{}_dico_{}_gate_{}_best_X.t7'.format( seed, self.params.dico_build, self.params.gate)) torch.save( self.Y_AE.state_dict(), self.tune_best_dir + '/seed_{}_dico_{}_gate_{}_best_Y.t7'.format( seed, self.params.dico_build, self.params.gate)) torch.save( self.D_X.state_dict(), self.tune_best_dir + '/seed_{}_dico_{}_gate_{}_best_Dx.t7'.format( seed, self.params.dico_build, self.params.gate)) torch.save( self.D_Y.state_dict(), self.tune_best_dir + '/seed_{}_dico_{}_gate_{}__best_Dy.t7'.format( seed, self.params.dico_build, self.params.gate)) # Saving generator weights fp = open( self.tune_dir + "/seed_{}_gate_{}_epoch_{}_acc_{:.3f}.tmp".format( seed, self.params.gate, epoch, acc1), 'w') fp.close() acc_epochs.append(acc1) criterion_epochs.append(criterion) criterion_fb, epoch_fb = max([ (score, index) for index, score in enumerate(criterion_epochs) ]) fp = open( self.tune_best_dir + "/seed_{}_dico_{}_gate_{}_epoch_{}_Acc_{:.3f}_{:.4f}.cslsfb". format(seed, self.params.gate, self.params.dico_build, epoch_fb, acc_epochs[epoch_fb], criterion_fb), 'w') fp.close() # Save the plot for discriminator accuracy and generator loss fig = plt.figure() plt.plot(range(0, len(D_A_acc_epochs)), D_A_acc_epochs, color='b', label='D_A') plt.plot(range(0, len(D_B_acc_epochs)), D_B_acc_epochs, color='r', label='D_B') plt.ylabel('D_accuracy') plt.xlabel('epochs') plt.legend() fig.savefig(self.tune_dir + '/seed_{}_D_acc.png'.format(seed)) fig = plt.figure() plt.plot(range(0, len(D_A_loss_epochs)), D_A_loss_epochs, color='b', label='D_A') plt.plot(range(0, len(D_B_loss_epochs)), D_B_loss_epochs, color='r', label='D_B') plt.ylabel('D_losses') plt.xlabel('epochs') plt.legend() fig.savefig(self.tune_dir + '/seed_{}_D_loss.png'.format(seed)) fig = plt.figure() plt.plot(range(0, len(G_AB_loss_epochs)), G_AB_loss_epochs, color='b', label='G_AB') plt.plot(range(0, len(G_BA_loss_epochs)), G_BA_loss_epochs, color='r', label='G_BA') plt.ylabel('G_losses') plt.xlabel('epochs') plt.legend() fig.savefig(self.tune_dir + '/seed_{}_G_loss.png'.format(seed)) fig = plt.figure() plt.plot(range(0, len(G_AB_recon_epochs)), G_AB_recon_epochs, color='b', label='G_AB') plt.plot(range(0, len(G_BA_recon_epochs)), G_BA_recon_epochs, color='r', label='G_BA') plt.ylabel('G_recon_loss') plt.xlabel('epochs') plt.legend() fig.savefig(self.tune_dir + '/seed_{}_G_Recon.png'.format(seed)) # fig = plt.figure() # plt.plot(range(0, len(L_Z_loss_epoches)), L_Z_loss_epoches, color='b', label='L_Z') # plt.ylabel('L_Z_loss') # plt.xlabel('epochs') # plt.legend() # fig.savefig(tune_dir + '/seed_{}_L_Z.png'.format(seed)) fig = plt.figure() plt.plot(range(0, len(acc_epochs)), acc_epochs, color='b', label='trans_acc1') plt.ylabel('trans_acc') plt.xlabel('epochs') plt.legend() fig.savefig(self.tune_dir + '/seed_{}_trans_acc.png'.format(seed)) ''' fig = plt.figure() plt.plot(range(0, len(csls_epochs)), csls_epochs, color='b', label='csls') plt.ylabel('csls') plt.xlabel('epochs') plt.legend() fig.savefig(self.tune_dir + '/seed_{}_csls.png'.format(seed)) ''' fig = plt.figure() plt.plot(range(0, len(g_loss_epochs)), g_loss_epochs, color='b', label='G_loss') plt.ylabel('g_loss') plt.xlabel('epochs') plt.legend() fig.savefig(self.tune_dir + '/seed_{}_g_loss.png'.format(seed)) fig = plt.figure() plt.plot(range(0, len(d_loss_epochs)), d_loss_epochs, color='b', label='csls') plt.ylabel('D_loss') plt.xlabel('epochs') plt.legend() fig.savefig(self.tune_dir + '/seed_{}_d_loss.png'.format(seed)) plt.close('all') except KeyboardInterrupt: print("Interrupted.. saving model !!!") torch.save(self.X_AE.state_dict(), self.tune_dir + '/X_AE_model_interrupt.t7') torch.save(self.Y_AE.state_dict(), self.tune_dir + '/Y_AE_model_interrupt.t7') torch.save(self.D_X.state_dict(), self.tune_dir + '/D_X_model_interrupt.t7') torch.save(self.D_Y.state_dict(), self.tune_dir + '/D_y_model_interrupt.t7') exit() return def get_batch_data_fast(self, emb_en, emb_it): params = self.params random_en_indices = torch.LongTensor(params.mini_batch_size).random_( params.most_frequent_sampling_size) random_it_indices = torch.LongTensor(params.mini_batch_size).random_( params.most_frequent_sampling_size) en_batch = to_variable(emb_en)[random_en_indices.cuda()] it_batch = to_variable(emb_it)[random_it_indices.cuda()] return en_batch, it_batch
flags.DEFINE_boolean("Inference", False, "Training or Inference") flags.DEFINE_string("inf_path", None, "Inference wav directory") flags.DEFINE_string("inf_save_path", None, "Inference save directory") FLAGS = flags.FLAGS FLAGS.c_te_L_F = list(np.int0(np.array(FLAGS.c_te_L_F.split(',')))) FLAGS.d_te_L_F = list(np.int0(np.array(FLAGS.d_te_L_F.split(',')))) FLAGS.c_te_N_F = list(np.int0(np.array(FLAGS.c_te_N_F.split(',')))) FLAGS.c_te_str = list(np.int0(np.array(FLAGS.c_te_str.split(',')))) #### PARAMETERS with tf.compat.v1.Session() as sess: ###### BUILD MODEL #### G_instance = AE(FLAGS, sess) G_instance.build_model() if FLAGS.Inference == False: ###### TRAIN ###### G_instance.train_AE() else: if not os.path.exists(FLAGS.inf_save_path): os.makedirs(FLAGS.inf_save_path) sess.run(tf.global_variables_initializer()) saver = tf.train.Saver() saver.restore(sess, FLAGS.load_path) print('Read ', FLAGS.load_path) # get into test directory and open for loop inf_files = [ os.path.join(FLAGS.inf_path, wav) for wav in os.listdir(FLAGS.inf_path) if wav.endswith('.wav')
#Save directory save_dir = './save' if not os.path.exists(save_dir): os.makedirs(save_dir) #Log directory log_dir = './log' if not os.path.exists(log_dir): os.makedirs(log_dir) log_file = open(os.path.join(log_dir, 'loss.txt'), 'w') #Define model's training parameters lr = 0.0005 num_epochs = 5 ae = AE() criterion = nn.MSELoss() optimizer = torch.optim.Adam(ae.parameters(), lr=lr, weight_decay=1e-5) #Validation Loss def eval_loss(): val_loss = [] for batch_id, (x, label) in enumerate(train_loader): enc, dec = ae(x) loss = criterion(dec, x).item() val_loss.append(loss) avg_loss = sum(val_loss) / len(val_loss) return (avg_loss)
def main(): torch.set_num_threads(1) device = torch.device("cuda:1" if args.cuda else "cpu") ## UID = 'exp_{}'.format( datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")) step_log = [] reward_log = [] ## To be used to selec environment mode = 'normal' # encoder type encoder = 'sym_VAE' if encoder == 'symbolic': embedding_size = (18, ) elif encoder == 'AE': embedding_size = (200, ) elif encoder == 'VAE': embedding_size = (100, ) elif encoder == 'sym_VAE': embedding_size = (118, ) else: raise NotImplementedError('fff') # load pre-trained AE #AE = VAEU([128,128]) #model_path = '/hdd_c/data/miniWorld/trained_models/VAE/dataset_4/VAEU.pth' #AE = torch.load(model_path) #AE.eval() # load pre-trained VAE VAE = VAER([128, 128]) model_path = '/hdd_c/data/miniWorld/trained_models/VAE/dataset_5/VAER.pth' VAE = torch.load(model_path).to(device) VAE.eval() # load pre-trained detector Detector_model = Detector model_path = '/hdd_c/data/miniWorld/trained_models/Detector/dataset_5/Detector_resnet18_e14.pth' Detector_model = torch.load(model_path).to(device) # load pre-trained RNN RNN_model = RNN(200, 128) model_path = '/hdd_c/data/miniWorld/trained_models/RNN/RNN1.pth' RNN_model = torch.load(model_path).to(device) RNN_model.eval() """ if args.vis: from visdom import Visdom viz = Visdom(port=args.port) win = None """ envs = make_vec_envs(args.env_name, args.seed, args.num_processes, args.gamma, args.log_dir, args.add_timestep, device, False) print(envs.observation_space.shape) #actor_critic = Policy(envs.observation_space.shape, envs.action_space, # base_kwargs={'recurrent': args.recurrent_policy}) actor_critic = Policy(embedding_size, envs.action_space, base_kwargs={'recurrent': args.recurrent_policy}) actor_critic.to(device) if args.algo == 'a2c': agent = algo.A2C_ACKTR(actor_critic, args.value_loss_coef, args.entropy_coef, lr=args.lr, eps=args.eps, alpha=args.alpha, max_grad_norm=args.max_grad_norm) elif args.algo == 'ppo': agent = algo.PPO(actor_critic, args.clip_param, args.ppo_epoch, args.num_mini_batch, args.value_loss_coef, args.entropy_coef, lr=args.lr, eps=args.eps, max_grad_norm=args.max_grad_norm) elif args.algo == 'acktr': agent = algo.A2C_ACKTR(actor_critic, args.value_loss_coef, args.entropy_coef, acktr=True) #rollouts = RolloutStorage(args.num_steps, args.num_processes, # envs.observation_space.shape, envs.action_space, # actor_critic.recurrent_hidden_state_size) rollouts = RolloutStorage(args.num_steps, args.num_processes, embedding_size, envs.action_space, actor_critic.recurrent_hidden_state_size) obs = envs.reset() #print(obs.size()) #obs = make_var(obs) print(obs.size()) with torch.no_grad(): if encoder == 'symbolic': z = Detector_model(obs) print(z.size()) z = Detector_to_symbolic(z) rollouts.obs[0].copy_(z) elif encoder == 'AE': z = AE.encode(obs) rollouts.obs[0].copy_(z) elif encoder == 'VAE': z = VAE.encode(obs)[0] rollouts.obs[0].copy_(z) elif encoder == 'sym_VAE': z_vae = VAE.encode(obs)[0] z_sym = Detector_model(obs) z_sym = Detector_to_symbolic(z_sym) z = torch.cat((z_vae, z_sym), dim=1) rollouts.obs[0].copy_(z) else: raise NotImplementedError('fff') #rollouts.obs[0].copy_(obs) rollouts.to(device) episode_rewards = deque(maxlen=100) start = time.time() for j in range(num_updates): #print(j) for step in range(args.num_steps): # Sample actions #print(step) with torch.no_grad(): value, action, action_log_prob, recurrent_hidden_states = actor_critic.act( rollouts.obs[step], rollouts.recurrent_hidden_states[step], rollouts.masks[step]) # Obser reward and next obs #print(action) with torch.no_grad(): obs, reward, done, infos = envs.step(action) if encoder == 'symbolic': #print(obs.size()) np.save( '/hdd_c/data/miniWorld/training_obs_{}.npy'.format( step), obs.detach().cpu().numpy()) z = Detector_model(obs / 255.0) z = Detector_to_symbolic(z) #print(z) np.save( '/hdd_c/data/miniWorld/training_z_{}.npy'.format(step), z.detach().cpu().numpy()) elif encoder == 'AE': z = AE.encode(obs) elif encoder == 'VAE': z = VAE.encode(obs)[0] elif encoder == 'sym_VAE': z_vae = VAE.encode(obs)[0] z_sym = Detector_model(obs) z_sym = Detector_to_symbolic(z_sym) z = torch.cat((z_vae, z_sym), dim=1) else: raise NotImplementedError('fff') #obs = make_var(obs) """ for info in infos: if 'episode' in info.keys(): print(reward) episode_rewards.append(info['episode']['r']) """ # # FIXME: works only for environments with sparse rewards # for idx, eps_done in enumerate(done): # if eps_done: # episode_rewards.append(reward[idx]) # FIXME: works only for environments with sparse rewards for idx, eps_done in enumerate(done): if eps_done: #print('done') episode_rewards.append(infos[idx]['accumulated_reward']) # If done then clean the history of observations. masks = torch.FloatTensor([[0.0] if done_ else [1.0] for done_ in done]) #rollouts.insert(obs, recurrent_hidden_states, action, action_log_prob, value, reward, masks) rollouts.insert(z, recurrent_hidden_states, action, action_log_prob, value, reward, masks) with torch.no_grad(): next_value = actor_critic.get_value( rollouts.obs[-1], rollouts.recurrent_hidden_states[-1], rollouts.masks[-1]).detach() rollouts.compute_returns(next_value, args.use_gae, args.gamma, args.tau) value_loss, action_loss, dist_entropy = agent.update(rollouts) rollouts.after_update() if j % args.save_interval == 0 and args.save_dir != "": print('Saving model') print() save_path = os.path.join(args.save_dir, args.algo) try: os.makedirs(save_path) except OSError: pass # A really ugly way to save a model to CPU save_model = actor_critic if args.cuda: save_model = copy.deepcopy(actor_critic).cpu() save_model = [ save_model, hasattr(envs.venv, 'ob_rms') and envs.venv.ob_rms or None ] torch.save(save_model, os.path.join(save_path, args.env_name + ".pt")) total_num_steps = (j + 1) * args.num_processes * args.num_steps #print(len(episode_rewards)) step_log.append(total_num_steps) reward_log.append(np.mean(episode_rewards)) step_log_np = np.asarray(step_log) reward_log_np = np.asarray(reward_log) np.savez_compressed('/hdd_c/data/miniWorld/log/{}.npz'.format(UID), step=step_log_np, reward=reward_log_np) if j % args.log_interval == 0 and len(episode_rewards) > 1: end = time.time() print( "Updates {}, num timesteps {}, FPS {} \n Last {} training episodes: mean/median reward {:.2f}/{:.2f}, min/max reward {:.2f}/{:.2f}, success rate {:.2f}\n" .format( j, total_num_steps, int(total_num_steps / (end - start)), len(episode_rewards), np.mean(episode_rewards), np.median(episode_rewards), np.min(episode_rewards), np.max(episode_rewards), np.count_nonzero(np.greater(episode_rewards, 0)) / len(episode_rewards))) if args.eval_interval is not None and len( episode_rewards) > 1 and j % args.eval_interval == 0: eval_envs = make_vec_envs(args.env_name, args.seed + args.num_processes, args.num_processes, args.gamma, eval_log_dir, args.add_timestep, device, True) if eval_envs.venv.__class__.__name__ == "VecNormalize": eval_envs.venv.ob_rms = envs.venv.ob_rms # An ugly hack to remove updates def _obfilt(self, obs): if self.ob_rms: obs = np.clip((obs - self.ob_rms.mean) / np.sqrt(self.ob_rms.var + self.epsilon), -self.clipob, self.clipob) return obs else: return obs eval_envs.venv._obfilt = types.MethodType(_obfilt, envs.venv) eval_episode_rewards = [] obs = eval_envs.reset() eval_recurrent_hidden_states = torch.zeros( args.num_processes, actor_critic.recurrent_hidden_state_size, device=device) eval_masks = torch.zeros(args.num_processes, 1, device=device) while len(eval_episode_rewards) < 10: with torch.no_grad(): _, action, _, eval_recurrent_hidden_states = actor_critic.act( obs, eval_recurrent_hidden_states, eval_masks, deterministic=True) # Obser reward and next obs obs, reward, done, infos = eval_envs.step(action) eval_masks = torch.FloatTensor([[0.0] if done_ else [1.0] for done_ in done]) for info in infos: if 'episode' in info.keys(): eval_episode_rewards.append(info['episode']['r']) eval_envs.close() print(" Evaluation using {} episodes: mean reward {:.5f}\n".format( len(eval_episode_rewards), np.mean(eval_episode_rewards))) """ if args.vis and j % args.vis_interval == 0: try: # Sometimes monitor doesn't properly flush the outputs win = visdom_plot(viz, win, args.log_dir, args.env_name, args.algo, args.num_frames) except IOError: pass """ envs.close()
def ae_train(train_dataset, test_dataset, epochs, mode): # reload and freeze model. gan_checkpoint_dir = './gan_training_checkpoints' gan_checkpoint = tf.train.Checkpoint( optimizer=generator_opt, discriminator_optimizer=discriminator_opt, generator=generator, discriminator=discriminator, ) latest = tf.train.latest_checkpoint(gan_checkpoint_dir) gan_checkpoint.restore(latest) frozen_generator = gan_checkpoint.generator frozen_generator.trainable = False # build vae model. vae_opt = tf.keras.optimizers.Adam(1e-3) if mode == TrainMode.AE: print( "*********************** Training naive AE***************************" ) model = AE(frozen_generator) checkpoint_dir = './ae_training_checkpoints' checkpoint_prefix = os.path.join(checkpoint_dir, "ckpt") checkpoint = tf.train.Checkpoint(AE_optimizer=model.optimizer, AE=model) print("generator is trainable: ", model.generator_net.trainable) path = './output/ae_output' if not os.path.exists(path): os.makedirs(path) else: print( "*********************** Training Auxiliary AE***************************" ) model = AAE(gan_checkpoint) model.discriminator.trainable = False model.generator_net.trainable = False # model.build((128, 128)) print(model.discriminator.summary()) print(model.discriminator.get_layer('conv2d_3')) checkpoint_dir = './aae_training_checkpoints' checkpoint_prefix = os.path.join(checkpoint_dir, "ckpt") checkpoint = tf.train.Checkpoint(AE_optimizer=model.optimizer, AE=model) path = './output/aae_output' print("generator is trainable: ", model.generator_net.trainable) if not os.path.exists(path): os.makedirs(path) # train sample_input = next(iter(test_dataset))[:4, ::] ae_generate_and_save_images(model, 0, sample_input, path) for epoch in range(1, epochs + 1): start_time = time.time() for train_x in train_dataset: model.train(train_x) end_time = time.time() if epoch % 1 == 0: loss = tf.keras.metrics.Mean() for test_x in test_dataset: loss(model.compute_loss(test_x)) elbo = -loss.result() print('Epoch: {}, Test set ELBO: {}, ' 'time elapse for current epoch {}'.format( epoch, elbo, end_time - start_time)) ae_generate_and_save_images(model, epoch, sample_input, path) checkpoint.save(file_prefix=checkpoint_prefix + "_epoch_%d" % (epoch + 1)) if epoch == epochs - 1: ae_generate_and_save_images(model, epoch, sample_input, path) checkpoint.save(file_prefix=checkpoint_prefix + "_epoch_%d" % (epoch + 1))
def main(): params = parse_arguments() params.export_dir = "{}/{}-{}/{}/export".format(params.exp_id, params.src_lang, params.tgt_lang, params.norm_embeddings) if params.dataset == 'wiki': params.eval_file = '/data/dictionaries/{}-{}.5000-6500.txt'.format( params.src_lang, params.tgt_lang) elif params.dataset == 'wacky': params.eval_file = '/data/dictionaries/{}-{}.test.txt'.format( params.src_lang, params.tgt_lang) else: print('Invalid dataset value') return src_dico, src_emb = load_embeddings(params, source=True, full_vocab=False) tgt_dico, tgt_emb = load_embeddings(params, source=False, full_vocab=False) if params.norm_embeddings: norms = params.norm_embeddings.strip().split('_') for item in norms: if item == 'unit': src_emb = norm_embeddings(src_emb) tgt_emb = norm_embeddings(tgt_emb) elif item == 'center': src_emb = center_embeddings(src_emb) tgt_emb = center_embeddings(tgt_emb) elif item == 'none': pass else: print('Invalid norm:{}'.format(item)) src_emb = torch.from_numpy(src_emb).float() tgt_emb = torch.from_numpy(tgt_emb).float() #src_emb = torch.randn(200000,300) #tgt_emb = torch.randn(200000,300) #src_emb = src_emb[torch.randperm(src_emb.size(0))] #tgt_emb = tgt_emb[torch.randperm(tgt_emb.size(0))] if torch.cuda.is_available(): torch.cuda.set_device(params.cuda_device) src_emb = src_emb.cuda() tgt_emb = tgt_emb.cuda() if params.mode == 0: # train model init_seed = int(params.seed) t = BiAAE(params) initialize_exp(init_seed) t.init_state(seed=init_seed) t.train(src_dico, tgt_dico, src_emb, tgt_emb, init_seed) elif params.mode == 1: X_AE = AE(params).cuda() Y_AE = AE(params).cuda() X_AE.load_state_dict(torch.load(params.src_pretrain)) Y_AE.load_state_dict(torch.load(params.tgt_pretrain)) X_Z = X_AE.encode(Variable(src_emb)).data Y_Z = Y_AE.encode(Variable(tgt_emb)).data mstart_time = timer() for method in ['nn', 'csls_knn_10']: results = get_word_translation_accuracy(params.src_lang, src_dico[1], X_Z, params.tgt_lang, tgt_dico[1], Y_Z, method=method, dico_eval=params.eval_file, device=params.cuda_device) acc = results[0][1] print('{} takes {:.2f}s'.format(method, timer() - mstart_time)) print('Method:{} score:{:.4f}'.format(method, acc)) params.dico_build = "S2T&T2S" params.dico_method = "csls_knn_10" dico_max_size = 10000 ''' eval = Evaluator(params, src_emb, tgt_emb, torch.cuda.is_available()) X_Z = X_Z / X_Z.norm(2, 1, keepdim=True).expand_as(X_Z) Y_Z = Y_Z / Y_Z.norm(2, 1, keepdim=True).expand_as(Y_Z) dico = build_dictionary(X_Z, Y_Z, params) if dico is None: mean_cosine = -1e9 else: mean_cosine = (X_Z[dico[:dico_max_size, 0]] * Y_Z[dico[:dico_max_size, 1]]).sum(1).mean() print("Mean cosine (%s method, %s build, %i max size): %.5f" % (params.dico_method, params.dico_build, dico_max_size, mean_cosine)) with io.open('dict-wacky/seed-{}-{}-{}-{}.dict'.format(params.seed, params.norm_embeddings ,params.src_lang, params.tgt_lang), 'w', encoding='utf-8', newline='\n') as f: for item in dico: f.write('{} {}\n'.format(src_dico[0][item[0]], tgt_dico[0][item[1]])) ''' export_embeddings(X_Z, Y_Z, src_dico[0], tgt_dico[0], params) else: print("Invalid flag!")
def main(_): if FLAGS.exp_name is None: FLAGS.exp_name = "reconstrued_results" image_shape = [int(i) for i in FLAGS.image_shape.strip('()[]{}').split(',')] dirs = init_directories(FLAGS.exp_name, FLAGS.output_dir) dirs['data'] = '../../../npz_datas' if FLAGS.data_dir is None else FLAGS.data_dir dirs['codes'] = os.path.join(dirs['data'], 'codes/') create_directories(dirs, FLAGS.train, FLAGS.save_codes) output_dim = reduce(mul, image_shape, 1) run_config = tf.ConfigProto(allow_soft_placement=True) run_config.gpu_options.allow_growth=True run_config.gpu_options.per_process_gpu_memory_fraction=0.9 sess = tf.Session(config=run_config) ae = AE( session=sess, arch=FLAGS.arch, lr=FLAGS.lr, alpha=FLAGS.alpha, beta=FLAGS.beta, latent_dim=FLAGS.latent_dim, latent_num=FLAGS.latent_num, class_net_unit_num=FLAGS.class_net_unit_num, output_dim=output_dim, batch_size=FLAGS.batch_size, image_shape=image_shape, exp_name=FLAGS.exp_name, dirs=dirs, vis_reconst=FLAGS.visualize_reconstruct, ) if FLAGS.train: data1Name='FashionMultiAndMask_unitlength1_20000x32x32x1_train' data_manager = ShapesDataManager(dirs['data'], data1Name, FLAGS.batch_size, image_shape, shuffle=False,file_ext=FLAGS.file_ext, train_fract=0.8, inf=True) ae.train_iter1, ae.dev_iter1, ae.test_iter1= data_manager.get_iterators() n_iters_per_epoch = data_manager.n_train // data_manager.batch_size FLAGS.stats_interval = int(FLAGS.stats_interval * n_iters_per_epoch) FLAGS.ckpt_interval = int(FLAGS.ckpt_interval * n_iters_per_epoch) n_iters = int(FLAGS.epochs * n_iters_per_epoch) ae.train(n_iters, n_iters_per_epoch, FLAGS.stats_interval, FLAGS.ckpt_interval) # test get changed images data1Name="FashionMultiAndMask_unitlength1_64x32x32x1_test" data_manager = ShapesDataManager(dirs['data'], data1Name,FLAGS.batch_size, image_shape, shuffle=False,file_ext=FLAGS.file_ext, train_fract=1.0, inf=True) ae.train_iter1, ae.dev_iter1, ae.test_iter1= data_manager.get_iterators() ae.session.run(tf.global_variables_initializer()) saved_step = ae.load() assert saved_step > 1, "A trained model is needed to encode the data!" pathForSave='RecostructedImg64Test' try: os.makedirs(pathForSave) except OSError as exc: # Python >2.5 if exc.errno == errno.EEXIST and os.path.isdir(pathForSave): pass else: raise assert saved_step > 1, "A trained model is needed to encode the data!" for k in range(1): fixed_x1, fixed_mk1 , _ = next(ae.train_iter1) #print(fixed_x1.shape) #print(fixed_mk1) ae.encodeImg(pathForSave,fixed_x1, fixed_mk1,k) #print(k) print('finish encode!')
def main(_): if FLAGS.exp_name is None: FLAGS.exp_name = "reconstrued_results" image_shape = [ int(i) for i in FLAGS.image_shape.strip('()[]{}').split(',') ] dirs = init_directories(FLAGS.exp_name, FLAGS.output_dir) dirs[ 'data'] = '../../../npz_datas_single_test' if FLAGS.data_dir is None else FLAGS.data_dir dirs['codes'] = os.path.join(dirs['data'], 'codes/') create_directories(dirs, FLAGS.train, FLAGS.save_codes) output_dim = reduce(mul, image_shape, 1) run_config = tf.ConfigProto(allow_soft_placement=True) run_config.gpu_options.allow_growth = True run_config.gpu_options.per_process_gpu_memory_fraction = 0.9 sess = tf.Session(config=run_config) ae = AE( session=sess, arch=FLAGS.arch, lr=FLAGS.lr, alpha=FLAGS.alpha, beta=FLAGS.beta, latent_dim=FLAGS.latent_dim, latent_num=FLAGS.latent_num, class_net_unit_num=FLAGS.class_net_unit_num, output_dim=output_dim, batch_size=FLAGS.batch_size, image_shape=image_shape, exp_name=FLAGS.exp_name, dirs=dirs, vis_reconst=FLAGS.visualize_reconstruct, ) # save codes and images data1Name = "mnistOffset1_Imgs_GTimages_mask_GTlabel_(32x64)x32x32x1_unitLength1_CodeImageDataset" data_manager = ShapesDataManager(dirs['data'], data1Name, FLAGS.batch_size, image_shape, shuffle=False, file_ext=FLAGS.file_ext, train_fract=1.0, inf=True) ae.train_iter1, ae.dev_iter1, ae.test_iter1 = data_manager.get_iterators() ae.session.run(tf.global_variables_initializer()) saved_step = ae.load_fixedNum(1875) assert saved_step > 1, "A trained model is needed to encode the data!" pathForSave = 'ValidateEncodedImgs_Offset{}'.format(1) save_name = "reconstrued_results_offset{}".format(1) try: os.makedirs(pathForSave) except OSError as exc: # Python >2.5 if exc.errno == errno.EEXIST and os.path.isdir(pathForSave): pass else: raise codes = [] images = [] sampleNum = 2048 for batch_num in range(int(sampleNum / FLAGS.batch_size)): img_batch, _mask1, _ = next(ae.train_iter1) # code = ae.encode(img_batch) #[batch_size, reg_latent_dim] code, image = ae.getCodesAndImgs(pathForSave, img_batch, _mask1, batch_num) codes.append(code) images.append(image) if batch_num < 5 or batch_num % 10 == 0: print(("Batch number {0}".format(batch_num))) codes = np.vstack(codes) images = np.vstack(images) filename = os.path.join(dirs['codes'], "codes_" + save_name) # np.save(filename, codes) np.savez(filename + '.npz', imagesNorm0_1=images, codes=codes) print(("Images and Codes saved to: {0}".format(filename)))
# gan_checkpoint = tf.train.Checkpoint( # optimizer=generator_opt, # discriminator_optimizer=discriminator_opt, # generator=generator, # discriminator=discriminator, # ) # # latest = tf.train.latest_checkpoint(gan_checkpoint_dir) # gan_checkpoint.restore(latest) # # frozen_generator = gan_checkpoint.generator # frozen_discriminator = gan_checkpoint.discriminator # frozen_generator.trainable = False # load Auto-decoder. model = AE(generator) ae_checkpoint_dir = './ae_training_checkpoints' ae_checkpoint = tf.train.Checkpoint( checkpoint=tf.train.Checkpoint(optimizer=model.optimizer, model=model)) latest = tf.train.latest_checkpoint(ae_checkpoint_dir) status = ae_checkpoint.restore(latest) print(status) print(latest) print(dir(ae_checkpoint)) encoder = ae_checkpoint.model.inference_net test_img = cv2.imread( '/data2/huangps/data_freakie/gx/data/gonet_original/data_test_annotation/negative_L/img_negative_L_99.jpg' ) latent = encoder(test_img) print(latent)
args.LTMGDir+args.datasetName+'/', args.ltmgFile) regulationMatrix = torch.from_numpy(regulationMatrix) if args.precisionModel == 'Double': regulationMatrix = regulationMatrix.type(torch.DoubleTensor) elif args.precisionModel == 'Float': regulationMatrix = regulationMatrix.type(torch.FloatTensor) print('---'+str(datetime.timedelta(seconds=int(time.time()-start_time)) )+'---LTMG has been successfully prepared.') else: regulationMatrix = None # Original if args.model == 'VAE': model = VAE(dim=scData.features.shape[1]).to(device) elif args.model == 'AE': model = AE(dim=scData.features.shape[1]).to(device) if args.precisionModel == 'Double': model = model.double() optimizer = optim.Adam(model.parameters(), lr=1e-3) print('---'+str(datetime.timedelta(seconds=int(time.time()-start_time))) + '---Pytorch model ready.') def train(epoch, train_loader=train_loader, EMFlag=False, taskType='celltype', sparseImputation='nonsparse'): ''' EMFlag indicates whether in EM processes. If in EM, use regulized-type parsed from program entrance, Otherwise, noregu taskType: celltype or imputation ''' model.train() train_loss = 0
def build_model(self): # create model, discriminator, optimizers self.model = cc(AE(self.config)) print(self.model) self.model.eval() return
def make_conversion(root, result_dir, checkpoint, ut_min=91, ut_max=100, sp_min=91, sp_max=100): alpha = 0.42 n_fft = 1024 root = Path(root) result_dir = Path(result_dir) dicts = torch.load(checkpoint, map_location='cpu') model = AE(dicts['config']['model'], train=False) model.load_state_dict(dicts['model']) model = model.eval() for s in range(sp_min, sp_max + 1): sp = f'jvs{s:03}' sp_root = result_dir / sp sp_root.mkdir(parents=True, exist_ok=True) sp_dict_path = sp_root / 'sp_dict.pt' if not sp_dict_path.is_file(): nonparas = list( (root / sp / 'nonpara30/wav24kHz16bit').glob('BASIC5000_*.mcep.npy')) index = max(enumerate(nonparas), key=lambda p: p[1].stat().st_size)[0] ref_mcep = nonparas[index] ref_f0 = ref_mcep.parent / ref_mcep.stem.replace( '.mcep', '.f0.npy') sp_dict = extract_from(model, ref_mcep, ref_f0, sp_dict_path) else: sp_dict = torch.load(sp_dict_path) for s2 in range(sp_min, sp_max + 1): sp2 = f'jvs{s2:03}' sp2_root = result_dir / sp2 sp2_root.mkdir(parents=True, exist_ok=True) target_root = sp_root / sp2 target_root.mkdir(parents=True, exist_ok=True) for u in range(ut_min, ut_max + 1): src_mcep = root / sp2 / 'parallel100/wav24kHz16bit' / f'VOICEACTRESS100_{u:03}.mcep.npy' src_f0 = root / sp2 / 'parallel100/wav24kHz16bit' / f'VOICEACTRESS100_{u:03}.f0.npy' src_c0 = root / sp2 / 'parallel100/wav24kHz16bit' / f'VOICEACTRESS100_{u:03}.c0.npy' src_ap = root / sp2 / 'parallel100/wav24kHz16bit' / f'VOICEACTRESS100_{u:03}.ap.npy' src_dict_path = sp2_root / f'VOICEACTRESS100_{u:03}.pt' if not src_dict_path.is_file(): src_dict = prep_content(model, src_mcep, src_dict_path) else: src_dict = torch.load(src_dict_path) converted_mcep = model.reconstruct_mcep( src_dict['c'], src_dict['q'], sp_dict['k'], sp_dict['v']).squeeze().numpy() tgt_mcep = target_root / f'VOICEACTRESS100_{u:03}.mcep.npy' np.save(tgt_mcep, converted_mcep) f0 = np.load(src_f0).astype(np.float64) f0 = convert_f0(f0, sp_dict) ap = np.load(src_ap).astype(np.float64) ap = reconstruct_ap(ap) c0 = np.load(src_c0).astype(np.float64) assert ( c0.shape[0] <= converted_mcep.shape[-1] ), f'{s}->{s2}/{u}, {c0.shape[0]} <= {converted_mcep.shape[-1]}' mcep = np.hstack( [c0[:, None], converted_mcep[:, :c0.shape[0]].T]).astype(np.float64) sp = pysptk.mc2sp(np.ascontiguousarray(mcep), alpha, n_fft) wav = pyworld.synthesize(f0, sp, ap, 16000) tgt_wav = target_root / f'VOICEACTRESS100_{u:03}.wav' wavfile.write(tgt_wav, 16000, (wav * 32768).astype(np.int16)) print(tgt_wav, flush=True)