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():
# 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 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 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 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 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 __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):
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')
#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(_):
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,
)
# test get changed 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 = '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
assert saved_step > 1, "A trained model is needed to encode the data!"
sampleNum = 2048
for k in range(int(sampleNum / FLAGS.batch_size)):
fixed_x1, fixed_mk1, _ = next(ae.train_iter1)
#print(fixed_x1.shape)
#print(fixed_mk1 )
ae.visualise_reconstruction_path(pathForSave, fixed_x1, fixed_mk1, k)
#print(k)
print('finish encode!')
def main(argv):
TRAIN, NOISE_TYPES, IMAGE_SIZE, FRAME_SIZE, OVERLAY_SIZE, LATENT_CLEAN_SIZE, BATCH_SIZE, EPOCHS, TEST = arguments_parsing(argv)
if TRAIN:
print('model training with parameters:\n'+
'noise types = {}\n'.format(NOISE_TYPES)+
'image size = {}\n'.format(IMAGE_SIZE)+
'frame size = {}\n'.format(FRAME_SIZE)+
'overlay size = {}\n'.format(OVERLAY_SIZE)+
'latent clean size = {}\n'.format(LATENT_CLEAN_SIZE)+
'batch size = {}\n'.format(BATCH_SIZE)+
'number of epochs = {}\n'.format(EPOCHS))
# dataset table creating
make_dataset_table(PATH_TO_DATA, NOISE_TYPES, PATH_TO_DATASET_TABLE)
train_test_split(PATH_TO_DATASET_TABLE, test_size=0.2)
# dataset and dataloader creating
torch.manual_seed(0)
transforms = [Compose([RandomHorizontalFlip(p=1.0), ToTensor()]),
Compose([RandomVerticalFlip(p=1.0), ToTensor()]),
Compose([ColorJitter(brightness=(0.9, 2.0), contrast=(0.9, 2.0)), ToTensor()])]
train_dataset = []
for transform in transforms:
dataset = DenoisingDataset(dataset=pd.read_csv(PATH_TO_DATASET_TABLE),
image_size=IMAGE_SIZE,
frame_size=FRAME_SIZE,
overlay_size=OVERLAY_SIZE,
phase='train',
transform=transform)
train_dataset = ConcatDataset([train_dataset, dataset])
train_loader = DataLoader(dataset=train_dataset,
batch_size=BATCH_SIZE,
shuffle=True, # can be set to True only for train loader
num_workers=0)
# model training
model = AE(1, LATENT_CLEAN_SIZE)
loss = SSIMLoss()
latent_loss = MSELoss()
optimizer = torch.optim.Adam(model.parameters(), lr=1.0e-3)
model = train_model(model, train_loader,
loss, latent_loss,
optimizer,
epochs=EPOCHS,
device=DEVICE)
# model saving
path_to_model = './model' + '_{}'.format('_'.join([str(elem) for elem in NOISE_TYPES])) + '.pth'
torch.save(model, path_to_model)
if TEST:
# model loading
path_to_model = './model' + '_{}'.format('_'.join([str(elem) for elem in NOISE_TYPES])) + '.pth'
print('{} testing...\n'.format(os.path.basename(path_to_model)))
model = torch.load(path_to_model)
dataset=pd.read_csv(PATH_TO_DATASET_TABLE)
test_dataset = dataset[dataset['phase']=='test']
# model testing and results saving
loss = SSIMLoss()
latent_loss = MSELoss()
print('{} evaluation on test images'.format(os.path.basename(path_to_model)))
test_evaluation(model, test_dataset,
loss, latent_loss,
device=DEVICE)
print()
path_to_results = PATH_TO_RESULTS + '_{}'.format('_'.join([str(elem) for elem in NOISE_TYPES]))
if not os.path.exists(path_to_results):
os.makedirs(path_to_results)
print('{} running and results saving'.format(os.path.basename(path_to_model)))
test_model(model, test_dataset, path_to_results)
print('process completed: OK')
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 train(*,
folder=None,
dataset='mnist',
patch_size=8,
resume=False,
log_interval=1,
device='cpu',
objective='vae',
batch_size=64,
nz=100,
lr=0.001,
num_workers=1,
nb_filters=64,
nb_draw_layers=1):
if folder is None:
folder = f'results/{dataset}/{patch_size}x{patch_size}'
try:
os.makedirs(folder)
except Exception:
pass
act = 'sigmoid'
nb_epochs = 3000
dataset = load_dataset(dataset, split='train')
if patch_size is not None:
patch_size = int(patch_size)
dataset = PatchDataset(dataset, patch_size)
x0, _ = dataset[0]
nc = x0.size(0)
dataloader = torch.utils.data.DataLoader(
dataset,
batch_size=batch_size,
shuffle=True,
num_workers=num_workers,
)
if resume:
net = torch.load('{}/net.th'.format(folder))
else:
net = AE(
latent_size=nz,
nc=nc,
w=patch_size,
ndf=nb_filters,
act=act,
objective=objective,
)
opt = optim.Adam(net.parameters(), lr=lr)
net = net.to(device)
niter = 0
for epoch in range(nb_epochs):
for i, (X, _), in enumerate(dataloader):
net.zero_grad()
X = X.to(device)
Xrec, mu, logvar = net(X)
rec, kld = net.loss_function(X, Xrec, mu, logvar)
loss = rec + kld
loss.backward()
opt.step()
if niter % log_interval == 0:
print(
f'Epoch: {epoch:05d}/{nb_epochs:05d} iter: {niter:05d} loss: {loss.item():.2f} rec: {rec.item():.2f} kld:{kld.item():.2f}'
)
if niter % 100 == 0:
Xsamples = net.sample(nb_examples=100)
X = 0.5 * (X + 1) if act == 'tanh' else X
Xrecs = 0.5 * (Xrec + 1) if act == 'tanh' else Xrec
Xsamples = 0.5 * (Xsamples + 1) if act == 'tanh' else Xsamples
X = X.detach().to('cpu').numpy()
Xrecs = Xrecs.detach().to('cpu').numpy()
Xsamples = Xsamples.detach().to('cpu').numpy()
imsave(f'{folder}/real_samples.png', grid_of_images_default(X))
imsave(f'{folder}/rec_samples.png',
grid_of_images_default(Xrecs))
imsave(f'{folder}/fake_samples.png',
grid_of_images_default(Xsamples))
torch.save(net, '{}/net.th'.format(folder))
niter += 1
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")
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(_):
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)))
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!')
for i, (data, label) in enumerate(test_loader):
data = data.to(device).view(-1, 28 * 28)
label = label.to(device).view(-1, 28 * 28)
_, recons_x = model(data)
loss = criterion(recons_x, label)
test_loss += loss.item()
total += label.size(0)
avg_loss = test_loss / total
print('===> Test Average loss: {:.7f}\n'.format(avg_loss))
return avg_loss
ae_model = AE()
ae_model.to(device)
optimizer = optim.Adam(ae_model.parameters(), lr=0.001, betas=(0.9, 0.999))
criterion = nn.MSELoss()
batch_size = 256
train_loader, test_loader = get_customDataLoader(
'./data_for_ae/data_for_autoencoder.pth', batch_size=batch_size)
trainer(ae_model,
train_loader,
test_loader,
optimizer,
criterion,
save_path='./pretrained_models/autoencoder_pretrained_1.pth')
#load_model(ae_model, './autoencoder_pretrained.pth')
#test(ae_model, test_loader)
# 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)
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')
def build_model(self):
# create model, discriminator, optimizers
self.model = cc(AE(self.config))
print(self.model)
self.model.eval()
return
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!")