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)
