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)
