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()
for i in range(len(listResult)): clusterIndexList[listResult[i]].append(i) reconNew = np.zeros( (scData.features.shape[0], scData.features.shape[1])) # Convert to Tensor reconNew = torch.from_numpy(reconNew) if args.precisionModel == 'Double': reconNew = reconNew.type(torch.DoubleTensor) elif args.precisionModel == 'Float': reconNew = reconNew.type(torch.FloatTensor) reconNew = reconNew.to(device) # model.load_state_dict(torch.load(ptfile)) model.load_state_dict(ptstatus) for clusterIndex in clusterIndexList: reconUsage = recon[clusterIndex] scDataInter = scDatasetInter(reconUsage) train_loader = DataLoader(scDataInter, batch_size=args.batch_size, shuffle=False, **kwargs) for epoch in range(1, args.cluster_epochs + 1): reconCluster, originalCluster, zCluster = train( epoch, EMFlag=True) #epoch, train_loader=train_loader,EMFlag=True) count = 0 for i in clusterIndex: reconNew[i] = reconCluster[count, :]
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)
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!")
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) for i, img in enumerate(recs):
def export(self, src_dico, tgt_dico, emb_en, emb_it, seed, export_emb=False): params = _get_eval_params(self.params) eval = Evaluator(params, emb_en, emb_it, torch.cuda.is_available()) # Export adversarial dictionaries optim_X_AE = AE(params).cuda() optim_Y_AE = AE(params).cuda() print('Loading pre-trained models...') optim_X_AE.load_state_dict( torch.load(self.tune_dir + '/best/seed_{}_dico_{}_best_X.t7'.format( seed, params.dico_build))) optim_Y_AE.load_state_dict( torch.load(self.tune_dir + '/best/seed_{}_dico_{}_best_Y.t7'.format( seed, params.dico_build))) X_Z = optim_X_AE.encode(Variable(emb_en)).data Y_Z = optim_Y_AE.encode(Variable(emb_it)).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], emb_it, method=method, dico_eval=self.eval_file, device=params.cuda_device) acc1 = results[0][1] results = get_word_translation_accuracy(params.tgt_lang, tgt_dico[1], Y_Z, params.src_lang, src_dico[1], emb_en, method=method, dico_eval=self.eval_file2, device=params.cuda_device) acc2 = results[0][1] # csls = 0 print('{} takes {:.2f}s'.format(method, timer() - mstart_time)) print('Method:{} score:{:.4f}-{:.4f}'.format(method, acc1, acc2)) f_csls = eval.dist_mean_cosine(X_Z, emb_it) b_csls = eval.dist_mean_cosine(Y_Z, emb_en) csls = (f_csls + b_csls) / 2.0 print("Seed:{},ACC:{:.4f}-{:.4f},CSLS_FB:{:.6f}".format( seed, acc1, acc2, csls)) #''' print('Building dictionaries...') params.dico_build = "S2T&T2S" params.dico_method = "csls_knn_10" X_Z = X_Z / X_Z.norm(2, 1, keepdim=True).expand_as(X_Z) emb_it = emb_it / emb_it.norm(2, 1, keepdim=True).expand_as(emb_it) f_dico_induce = build_dictionary(X_Z, emb_it, params) f_dico_induce = f_dico_induce.cpu().numpy() Y_Z = Y_Z / Y_Z.norm(2, 1, keepdim=True).expand_as(Y_Z) emb_en = emb_en / emb_en.norm(2, 1, keepdim=True).expand_as(emb_en) b_dico_induce = build_dictionary(Y_Z, emb_en, params) b_dico_induce = b_dico_induce.cpu().numpy() f_dico_set = set([(a, b) for a, b in f_dico_induce]) b_dico_set = set([(b, a) for a, b in b_dico_induce]) intersect = list(f_dico_set & b_dico_set) union = list(f_dico_set | b_dico_set) with io.open( self.tune_dir + '/export/{}-{}.dict'.format(params.src_lang, params.tgt_lang), 'w', encoding='utf-8', newline='\n') as f: for item in f_dico_induce: f.write('{} {}\n'.format(src_dico[0][item[0]], tgt_dico[0][item[1]])) with io.open( self.tune_dir + '/export/{}-{}.dict'.format(params.tgt_lang, params.src_lang), 'w', encoding='utf-8', newline='\n') as f: for item in b_dico_induce: f.write('{} {}\n'.format(tgt_dico[0][item[0]], src_dico[0][item[1]])) with io.open(self.tune_dir + '/export/{}-{}.intersect'.format( params.src_lang, params.tgt_lang), 'w', encoding='utf-8', newline='\n') as f: for item in intersect: f.write('{} {}\n'.format(src_dico[0][item[0]], tgt_dico[0][item[1]])) with io.open(self.tune_dir + '/export/{}-{}.intersect'.format( params.tgt_lang, params.src_lang), 'w', encoding='utf-8', newline='\n') as f: for item in intersect: f.write('{} {}\n'.format(tgt_dico[0][item[1]], src_dico[0][item[0]])) with io.open( self.tune_dir + '/export/{}-{}.union'.format(params.src_lang, params.tgt_lang), 'w', encoding='utf-8', newline='\n') as f: for item in union: f.write('{} {}\n'.format(src_dico[0][item[0]], tgt_dico[0][item[1]])) with io.open( self.tune_dir + '/export/{}-{}.union'.format(params.tgt_lang, params.src_lang), 'w', encoding='utf-8', newline='\n') as f: for item in union: f.write('{} {}\n'.format(tgt_dico[0][item[1]], src_dico[0][item[0]])) if export_emb: print('Exporting {}-{}.{}'.format(params.src_lang, params.tgt_lang, params.src_lang)) loader.export_embeddings( src_dico[0], X_Z, path=self.tune_dir + '/export/{}-{}.{}'.format( params.src_lang, params.tgt_lang, params.src_lang), eformat='txt') print('Exporting {}-{}.{}'.format(params.src_lang, params.tgt_lang, params.tgt_lang)) loader.export_embeddings( tgt_dico[0], emb_it, path=self.tune_dir + '/export/{}-{}.{}'.format( params.src_lang, params.tgt_lang, params.tgt_lang), eformat='txt') print('Exporting {}-{}.{}'.format(params.tgt_lang, params.src_lang, params.tgt_lang)) loader.export_embeddings( tgt_dico[0], Y_Z, path=self.tune_dir + '/export/{}-{}.{}'.format( params.tgt_lang, params.src_lang, params.tgt_lang), eformat='txt') print('Exporting {}-{}.{}'.format(params.tgt_lang, params.src_lang, params.src_lang)) loader.export_embeddings( src_dico[0], emb_en, path=self.tune_dir + '/export/{}-{}.{}'.format( params.tgt_lang, params.src_lang, params.src_lang), eformat='txt')
torch.cuda.manual_seed(seed) torch.cuda.empty_cache() torch.backends.cudnn.benchmark = False torch.backends.cudnn.deterministic = True BATCH = 256 if __name__ == "__main__": print("Loading data...", flush=True) test_x = np.load(sys.argv[1]) test_x = preprocess(test_x) test_dataset = ImageDataset(test_x) print("Loading model...", flush=True) model = AE().cuda() model.load_state_dict(torch.load(sys.argv[2])) test_dataloader = DataLoader(test_dataset, batch_size=BATCH) print("Making latents...", flush=True) model.eval() latents = [] for i, x in enumerate(test_dataloader): x = torch.FloatTensor(x) vec, img = model(x.cuda()) latents.append(vec.reshape(img.shape[0], -1).cpu().detach()) latents = torch.cat(latents, dim=0).numpy() print("Start inference...", flush=True) reduced_latents, pred_y = inference_best(latents) print("Writing result...", flush=True)