def run_training(num_epoch, batch_size, lr): model_filename = 'cvae_face' model_save_dir = './ckpt/' + model_filename pred_save_dir = './output/' + model_filename if not os.path.exists(model_save_dir): os.makedirs(model_save_dir) if not os.path.exists(pred_save_dir): os.makedirs(pred_save_dir) # load yale face dataset face_size = 64 X, Y = load_faces('yale_face', ['yaleB01', 'yaleB03', 'yaleB05', 'yaleB07', 'yaleB09'], size=face_size) X_norm, Y_norm = X / 255., Y / 255. N = X.shape[0] X_norm = np.reshape(X_norm, [N, -1]) Y_norm = np.reshape(Y_norm, [N, -1]) ipdb.set_trace() # build VAE layers = [face_size * face_size, 512, 256, 4] # layer configuration vae = CVAE(layers, face_size * face_size) train_step = tf.train.AdamOptimizer(lr).minimize(vae.total_loss) # open a training session sess = tf.InteractiveSession() # initialize variables sess.run(tf.global_variables_initializer()) # training num_iter = int(math.ceil(N / batch_size)) print("Start training ... %d iterations per epoch" % num_iter) for i in range(num_epoch): rand_idx = np.random.permutation(N) for it in range(num_iter): idx = rand_idx[it * batch_size:(it + 1) * batch_size] X_batch, Y_batch = X_norm[idx, ::], Y_norm[idx, ::] _, total_loss, recon_loss, kl_loss = \ sess.run([train_step, vae.total_loss, vae.recon_loss, vae.kl_loss], feed_dict={vae.x: X_batch, vae.y:Y_batch}) #if it % 1 == 0: # print("\tIter [%d/%d] total_loss=%.6f, recon_loss=%.6f, kl_loss=%.6f" \ # %(it+1, num_iter, total_loss, recon_loss, kl_loss)) x_hat, total_loss, recon_loss, kl_loss = \ sess.run([vae.x_hat[rand_idx[0]], vae.total_loss, vae.recon_loss, vae.kl_loss], feed_dict={vae.x: X_norm, vae.y:Y_norm}) print("Epoch [%d/%d] total_loss=%.6f, recon_loss=%.6f, kl_loss=%.6f" \ %(i+1, num_epoch, total_loss, recon_loss, kl_loss)) # save reconstructed image x = X[rand_idx[0], :, :, 0] x_hat = np.reshape(x_hat, (face_size, face_size)) * 255 sm.imsave(os.path.join(pred_save_dir, '%07d.jpg' % (i + 1)), montage([x, x_hat], [1, 2])) # save model if (i + 1) % 200 == 0: saver = tf.train.Saver(max_to_keep=10) saver.save(sess, os.path.join(model_save_dir, model_filename))
def get_model(dataset, hps): if dataset == 'mnist' or dataset == 'fashion': model = VAE(hps) elif dataset == 'cifar': # convolutional VAE for CIFAR model = CVAE(hps) return model
def __init__(self, corpus, sig_order, **params): self.corpus = corpus self.order = sig_order # Model parameters n_latent = params.get("n_latent", 8) alpha = params.get("alpha", 0.003) self._build_dataset() self.generator = CVAE(n_latent=n_latent, alpha=alpha)
def start_demo(): model_filename = 'cvae_face' model_save_dir = './ckpt/' + model_filename model_filepath = os.path.join(model_save_dir, 'cvae_face') # load yale face dataset face_size = 64 X, Y = load_faces('yale_face', people, size=face_size) X_norm, Y_norm = X / 255., Y / 255. N = X.shape[0] X_norm = np.reshape(X_norm, [N, -1]) Y_norm = np.reshape(Y_norm, [N, -1]) # build VAE layers = [face_size * face_size, 512, 256, 4] # layer configuration vae = CVAE(layers, face_size * face_size) # open a training session sess = tf.InteractiveSession() # restore model var_list = tf.global_variables() # filter out weights for encoder in the checkpoint var_list = [ var for var in var_list if ('encoder' in var.name or 'decoder' in var.name) ] saver = tf.train.Saver(var_list=var_list) saver.restore(sess, model_filepath) print('[*] Loading success: %s!' % model_filepath) mouse = Controller() x_, y_ = mouse.position[0], mouse.position[1] z = z_ = np.zeros((1, 2)) unit = 200 with Listener(on_press=on_press, on_release=on_release) as listener: # live demo with cursor img = None while True: y = Y_norm[[64 * cond], ::] im = sess.run(vae.x_hat[0], feed_dict={vae.z: z, vae.y: y}) im = np.reshape(im, (face_size, face_size)) if img is None: img = plt.imshow(im, cmap='gray') else: img.set_data(im) plt.pause(.01) plt.draw() x, y = mouse.position[0], mouse.position[1] z = z_ - [(x - x_) / unit, (y - y_) / unit]
def run_training(num_epoch, batch_size, lr): model_filename = 'cvae' model_save_dir = './ckpt/' + model_filename pred_save_dir = './output/' + model_filename if not os.path.exists(model_save_dir): os.makedirs(model_save_dir) if not os.path.exists(pred_save_dir): os.makedirs(pred_save_dir) # load MNIST dataset mnist = input_data.read_data_sets('MNIST_data', one_hot=True) N = mnist.train.num_examples # build VAE layers = [28 * 28, 512, 256, 4] # layer configuration vae = CVAE(layers, 10) train_step = tf.train.AdamOptimizer(lr).minimize(vae.total_loss) # open a training session sess = tf.InteractiveSession() # initialize variables sess.run(tf.global_variables_initializer()) # training num_iter = int(math.ceil(N / batch_size)) print("Start training ... %d iterations per epoch" % num_iter) for i in range(num_epoch): for it in range(num_iter): batch = mnist.train.next_batch(batch_size) _, total_loss, recon_loss, kl_loss = \ sess.run([train_step, vae.total_loss, vae.recon_loss, vae.kl_loss], feed_dict={vae.x: batch[0], vae.y:batch[1]}) #if it % 200 == 0: # print("\tIter [%d/%d] total_loss=%.6f, recon_loss=%.6f, kl_loss=%.6f" \ # %(it+1, num_iter, total_loss, recon_loss, kl_loss)) batch = mnist.train.next_batch(N) x_hat, total_loss, recon_loss, kl_loss = \ sess.run([vae.x_hat[0], vae.total_loss, vae.recon_loss, vae.kl_loss], feed_dict={vae.x: batch[0], vae.y:batch[1]}) print("Epoch [%d/%d] total_loss=%.6f, recon_loss=%.6f, kl_loss=%.6f" \ %(i+1, num_epoch, total_loss, recon_loss, kl_loss)) # save reconstructed image x = np.reshape(batch[0][0], (28, 28)) x_hat = np.reshape(x_hat, (28, 28)) sm.imsave(os.path.join(pred_save_dir, '%07d.jpg' % i), montage([x, x_hat], [1, 2])) # save model saver = tf.train.Saver(max_to_keep=10) saver.save(sess, os.path.join(model_save_dir, model_filename))
def start_demo(): model_filename = 'cvae' model_save_dir = './ckpt/' + model_filename model_filepath = os.path.join(model_save_dir, 'cvae') # load MNIST dataset mnist = input_data.read_data_sets('MNIST_data', one_hot=True) N = mnist.train.num_examples # build VAE layers = [28 * 28, 512, 256, 4] # layer configuration vae = CVAE(layers, 10) # open a training session sess = tf.InteractiveSession() # restore model var_list = tf.global_variables() # filter out weights for encoder in the checkpoint var_list = [ var for var in var_list if ('encoder' in var.name or 'decoder' in var.name) ] saver = tf.train.Saver(var_list=var_list) saver.restore(sess, model_filepath) print('[*] Loading success: %s!' % model_filepath) mouse = Controller() x_, y_ = mouse.position[0], mouse.position[1] z = z_ = np.zeros((1, 2)) unit = 200 with Listener(on_press=on_press, on_release=on_release) as listener: # live demo with cursor img = None while True: y = np.zeros((1, 10)) y[0, cond] = 1 im = sess.run(vae.x_hat[0], feed_dict={vae.z: z, vae.y: y}) im = np.reshape(im, (28, 28)) if img is None: img = plt.imshow(im, cmap='gray') else: img.set_data(im) plt.pause(.01) plt.draw() x, y = mouse.position[0], mouse.position[1] z = z_ + [(x - x_) / unit, (y - y_) / unit]
def main(): parser = argparse.ArgumentParser( description='Train MVAE with VCC2018 dataset', formatter_class=argparse.ArgumentDefaultsHelpFormatter) parser.add_argument('--train-dataset', help='Path of training dataset.', type=str, required=True) parser.add_argument('--val-dataset', help='Path of validation dataset.', type=str, required=True) parser.add_argument('--batch-size', '-b', help='Batch size.', type=int, default=32) parser.add_argument('--epochs', '-e', help='Number of epochs.', type=int, default=800) parser.add_argument('--eval-interval', help='Evaluate every N epochs.', type=int, default=200, metavar='N') parser.add_argument('--gpu', '-g', help='GPU id. (Negative number indicates CPU)', type=int, default=-1) parser.add_argument('--learning-rate', '-l', help='Learning Rate.', type=float, default=1e-3) args = parser.parse_args() if_use_cuda = torch.cuda.is_available() and args.gpu >= 0 device = torch.device('cuda:{}'.format(args.gpu) if if_use_cuda else 'cpu') with open(args.train_dataset, 'rb') as f: train_dataset = pickle.load(f) train_dataloader = torch.utils.data.DataLoader( train_dataset, args.batch_size, shuffle=True) val_dataset = make_eval_set(args.val_dataset) baseline = baseline_ilrma(val_dataset) model = CVAE(n_speakers=train_dataset[0][1].size(0)).to(device) optimizer = torch.optim.Adam(model.parameters(), args.learning_rate) # TensorBoard writer = SummaryWriter() for epoch in range(1, args.epochs + 1): train(model, train_dataloader, optimizer, device, epoch, writer) if epoch % args.eval_interval == 0: validate(model, val_dataset, baseline, device, epoch, writer) writer.close()
def build_cvae(sess, input_files, input_shape, latent_size, batch_size, epochs=100): cvae = CVAE(sess, input_shape, batch_size, latent_size=latent_size) model_filename = "models/%s.cpkt" % cvae.get_name() if os.path.isfile(model_filename): cvae.load(sess, model_filename) else: sess.run(tf.initialize_all_variables()) cvae.train(sess, input_files, batch_size, display_step=1, training_epochs=epochs) cvae.save(sess, model_filename) return cvae
def __init__(self, ticker, start=datetime.date(2000, 1, 1), end=datetime.date(2019, 1, 1), freq="M", sig_order=4, rough_bergomi=None): self.ticker = ticker self.start = start self.end = end self.freq = freq self.order = sig_order if rough_bergomi: self._load_rough_bergomi(rough_bergomi) else: self._load_data() self._build_dataset() self.generator = CVAE(n_latent=8, alpha=0.003)
import torch import cv2 from cvae import Data_Manager,CVAE # -------------------------------------------------------------------------------- if __name__ == '__main__': device_id = '0' device = torch.device('cpu') if torch.cuda.is_available(): device = torch.device('cuda:{}'.format(device_id)) # Data Manager data_manager = Data_Manager() # C-VAE model = CVAE(data_manager, device, epochs=10) model.fit() # Single Sample model.load_model('cvae_state.pt') sample = model.sample(idx=5) cv2.imwrite('sample_test.png', sample)
gaussian_record = open('test/gaussian_record.txt', 'w') for word_list in generate_words: for i, word in enumerate(word_list): if (i + 1) % 4 != 0: word += ', ' else: word += '\n' print(word, file=gaussian_record, end='') print('Gaussian score: ', gaussian_score, file=gaussian_record) gaussian_record.close() test_dataset = WordDataset('test') max_length = test_dataset.max_length dataloader = DataLoader(test_dataset, batch_size=1, shuffle=False) tense_list = dataloader.dataset.tense2idx.values() transformer = WordTransoformer() # Epoch 57 is the best loadmodel = 'model/cycle_500/checkpoint57.pkl' model = CVAE(max_length) model = model.cuda() state_dict = torch.load(loadmodel) model.load_state_dict(state_dict) average_bleu_score, predict_list, gaussian_score, generate_words = evaluate( model, dataloader, tense_list) record_score(average_bleu_score, gaussian_score, predict_list, generate_words, dataloader, transformer)
def printcoords(): File = filedialog.askopenfilename(parent=root, title='Choose an image.') print('changing data...') data_img = [] img = imread(File) img = Image.fromarray(img) img = fit(img, size=(64, 64)) img = transpose(img, (2, 0, 1)) data_img.append(img) np.save(opts.path, np.asarray(data_img)) test_dataset = TestData(label=opts.label, path=opts.path, transform=transforms.ToTensor()) dataloader = torch.utils.data.DataLoader(test_dataset, batch_size=1) cvae = CVAE(200).to(device) cvae.load_params(opts.CVAE_PATH) evaluation_dir = opts.CVAE_PATH + 'evalFolder' try: os.mkdir(evaluation_dir) except: print('file already created') cvae.eval() test_x, test_y = iter(dataloader).next() for i in range(3): test_rec, test_mean, test_log_var, test_predict = cvae(test_x, test_y) save_image(test_x.data, join(evaluation_dir, 'input.png')) save_image(test_rec.data, join(evaluation_dir, 'output_test.png')) x = test_x.data y = test_y mu, logVar, y = cvae.encode(x) z = cvae.reparameterization(mu, logVar) sample1 = cvae.decode( torch.LongTensor(np.ones(y.size(), dtype=int)).type_as(z), z) sample2 = cvae.decode( torch.LongTensor(np.zeros(y.size(), dtype=int)).type_as(z), z) save_image(sample1.cpu().data, join(evaluation_dir, 'sample1.png')) save_image(sample2.cpu().data, join(evaluation_dir, 'sample2.png')) arr = ['input.png', 'sample1.png', 'sample2.png'] toImage = Image.new('RGBA', (584, 128)) for j in range(3): fromImge = Image.open(join(evaluation_dir, arr[j])) fromImge = fromImge.resize((128, 128), Image.ANTIALIAS) loc = (128 * j + 80, 0) toImage.paste(fromImge, loc) toImage.save('merged' + str(i) + '.png') arr = ['merged0.png', 'merged1.png', 'merged2.png'] toImage = Image.new('RGBA', (584, 384)) for j in range(3): fromImge = Image.open(arr[j]) loc = (0, 128 * j) toImage.paste(fromImge, loc) toImage.save('merged.png') filename = ImageTk.PhotoImage(Image.open('merged.png')) canvas.image = filename canvas.create_image(124, 10, anchor='nw', image=filename)
def main(): parser = argparse.ArgumentParser() parser.add_argument('--data_dir', type=str, default='quickdraw_data', help="The input data directory for the program") parser.add_argument('--logs_dir', type=str, default='logs', help="The logs directory for the tensorboard") parser.add_argument('--save_model', type=str, default='models', help="The directory to store the ml5js model") parser.add_argument('--save_checkpoints', type=str, default='checkpoints', help="The directory to store checkpointed models") parser.add_argument('--n_dim', type=int, default=16, help="The dimension of latent z") parser.add_argument( '--image_size', type=int, default=28, help="The input image size, which should be a square image") parser.add_argument( '--num_layers', type=int, default=2, help="The number of CNN layers in the encoder and decoder model") parser.add_argument( '--filters', type=int, default=8, help="The number of the filters in the first CNN layer") parser.add_argument('--learning_rate', type=int, default=0.0005, help="The learning rate of the Adam optimizer") parser.add_argument('--decay_rate', type=int, default=0.0, help="The decay rate of the Adam optimizer") parser.add_argument('--epochs', type=int, default=30, help="The number of epochs when training") parser.add_argument('--batch_size', type=int, default=128, help="The number of batch_size when training") parser.add_argument('--image_depth', type=int, default=1, help="The number of channels in image") args = parser.parse_args() assert (args.image_size / (2 ** args.num_layers)).is_integer() , \ "Make sure that image_size % (2 ** num_layers) == 0 or the encoder and decoder will have different convoluted features!" # (train_features, train_labels), (validataion_features, validataion_labels) = get_files('data') # training, validation = get_data(train_features, train_labels, validataion_features, validataion_labels) (X_train, Y_train), (X_test, Y_test), labels = get_files('data', args) # (X_train, Y_train), (X_test, Y_test) = mnist.load_data() print(X_train.shape) X_train = np.reshape( X_train, [-1, args.image_size, args.image_size, args.image_depth]) X_test = np.reshape( X_test, [-1, args.image_size, args.image_size, args.image_depth]) X_train = X_train.astype('float32') / 255. X_test = X_test.astype('float32') / 255. y_train = to_categorical(Y_train) y_test = to_categorical(Y_test) X_shape = X_train.shape[1] y_shape = y_train.shape[1] cvae = CVAE(args) cvae.forward(X_train, X_test, y_train, y_test) os.system('tensorflowjs_converter --input_format=keras ' + args.save_model + '.h5 ' + args.save_model) manifest = {"model": args.save_model + "/model.json", "labels": labels} with open("manifest.json", 'w') as f: json.dump(manifest, f)
'input': (128, 128, 3), 'latent': 128, 'encode': [ (32, 3, (2, 2)), # out: 64, 64 32 (64, 3, (2, 2)), # out: 32, 32, 64 (128, 3, (2, 2)), # out: 16, 16, 128 (256, 3, (2, 2)), # out: 8, 8, 256 ], 'decode': None, # Mirror enconding for reconstruction 'name': 'face_cvae_3' } model = CVAE(arch_def) model.load_weights('models/face_cvae_3/face_cvae_3.weights') test_root = '/home/martin/dataset/face_test' test_imgs = [str(p) for p in Path(test_root).glob('*.jpg')] batch_size = 8 epochs = 16 loss = [] tb = CVAEToolBox(model) for i in range(len(test_imgs[:5])): inp, outp = tb.load_and_reconstruct_image(test_imgs[i]) plt.subplot(2, 5, 1 + i) plt.imshow(inp) plt.title('Input') plt.axis('off')
input_ = np.array([xs[it], np.nan]) con_cen, con_cov, new_p_k = gmm.cond_dist(input_, centroids, ccov, mc) prob = gmm.gmm_pdf(ys[it], con_cen, con_cov, new_p_k) probs[it] = prob return xs, ys, probs xs, ys, probs = generate_data(TOTAL_SAMPLES) nb_train = int(TOTAL_SAMPLES * N_TRAINS) xs_train, ys_train, probs_train = xs[:nb_train], ys[:nb_train], probs[:nb_train] xs_test, ys_test, probs_test = xs[nb_train:], ys[nb_train:], probs[nb_train:] cvae = CVAE( input_size=INPUT_SIZE, output_size=OUTPUT_SIZE, latent_size=LATENT_SIZE, encoder_layer_sizes=(64, 64), decoder_layer_sizes=(64, 64), dataset_name='gmm', alpha=ALPHA, ) time_st = time.time() os.makedirs('out/gmm', exist_ok=True) save_dir = 'out/gmm/%d_%d_%d_%d_%.2f' % (INPUT_SIZE, OUTPUT_SIZE, LATENT_SIZE, N_INFERENCE, ALPHA) os.makedirs(save_dir, exist_ok=True) file = open(os.path.join(save_dir, 'progress.csv'), 'wt') csv_writer = None for it in range(int(2e4)): inds = np.random.choice(nb_train, BATCH_SIZE, replace=False) x, y, prob = xs_train[inds], ys_train[inds], probs_train[inds]
statistics_location = os.path.join(base_dir, 'statistics') training_data_location = os.path.join(base_dir, 'training_data') vae_location = os.path.join(base_dir, 'cvae') dimension = utils.calculate_binary_maze_size(arguments.dimension) vae_generated_filename = "generated_cvae_mazes_" + str( arguments.dimension) + "x" + str(arguments.dimension) + ".txt" latent_dim = 50 num_examples_to_generate = 1 vae_model_file = os.path.join(vae_location, arguments.model_file) if arguments.load_model: model = utils.load_model_weights(latent_dim, dimension, vae_model_file) else: model = CVAE(latent_dim, dimension) # keeping the random vector constant for generation (prediction) so # it will be easier to see the improvement. random_vector_for_generation = tf.random_normal( shape=[num_examples_to_generate, latent_dim]) if arguments.generate_only: utils.generate_and_save_images(model, 0, random_vector_for_generation, vae_location, vae_generated_filename, arguments.dimension) else: data_location = os.path.join(training_data_location, arguments.training_data) train_input = utils.get_data_from_json(data_location) test_input = train_input
word2index, index2word = build_vocab(vocab_f) start_i, end_i = word2index['<s>'], word2index['</s>'] vocab_size = len(word2index) p = Printer(log_f, index2word) """build graph""" kl_ceiling = 0.48 cvae = CVAE(vocab_size, embed_size, num_unit, latent_dim, emoji_dim, batch_size, kl_ceiling, 1, decoder_layer, start_i, end_i, beam_width, maximum_iterations, max_gradient_norm, lr, dropout, num_gpu, cell_type, is_seq2seq=is_seq2seq) """build data""" train_data = build_data(train_ori_f, train_rep_f, word2index) test_data = build_data(test_ori_f, test_rep_f, word2index) test_batches = batch_generator(test_data, start_i, end_i,
print(Y_tr.shape) print(X_te.shape) print(Y_te.shape) input_tensor = tf.compat.v1.placeholder(dtype=tf.float32, shape=(None, 784)) cond_tensor = tf.compat.v1.placeholder(dtype=tf.float32, shape=(None, 10)) label_tensor = tf.compat.v1.placeholder(dtype=tf.float32, shape=(None, 784)) train_tensor = tf.compat.v1.placeholder(dtype=tf.float32, shape=()) train_ds = tf.data.Dataset.from_tensor_slices((input_tensor, cond_tensor, label_tensor)).shuffle(60000).batch(BATCH).repeat() iterator = train_ds.make_initializable_iterator() dat, c, lab = iterator.get_next() #cvae = CVAE(100, hidden_layers=1, dims=[50, 20]) cvae = CVAE(784, hidden_layers=1, dims=[196, 100]) #cvae.init_model(input_tensor, cond_tensor, label_tensor, train_tensor) cvae.init_model(dat, c, lab, train_tensor) model = cvae.model_ loss = cvae.loss_ train_op = tf.train.AdamOptimizer().minimize(loss) with tf.Session() as sess: sess.run(tf.compat.v1.global_variables_initializer()) sess.run(iterator.initializer, feed_dict={input_tensor: X_tr, cond_tensor: Y_tr, label_tensor: X_tr, train_tensor: 1}) for i in range(EPOCH): tot_loss = 0 for _ in range(X_tr.shape[1]//BATCH): _, loss_value = sess.run([train_op, loss])
return df if __name__ == '__main__': device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") # Dataset datasets, dataloaders, dataset_sizes = get_data(num_quadrant_inputs=1, batch_size=128) baseline_net = BaselineNet(500, 500) baseline_net.load_state_dict( torch.load('/Users/carlossouza/Downloads/baseline_net_q1.pth', map_location='cpu')) baseline_net.eval() cvae_net = CVAE(200, 500, 500, baseline_net) cvae_net.load_state_dict( torch.load('/Users/carlossouza/Downloads/cvae_net_q1.pth', map_location='cpu')) cvae_net.eval() visualize(device=device, num_quadrant_inputs=1, pre_trained_baseline=baseline_net, pre_trained_cvae=cvae_net, num_images=10, num_samples=10) # df = generate_table( # device=device, # num_quadrant_inputs=1,
import numpy as np import matplotlib.pyplot as plt from load_data import load_data,load_content_data,split_rating_dat from cvae import CVAE P = 5 NUM_ITEM = 16980 ITEM_EMB = 8000 if __name__ == "__main__": data_dir = "CVAE\\data\\citeulike-a\\" train_users,test_users,train_items = split_rating_dat(load_data(data_dir + "users.dat"),P) side_info = load_content_data(data_dir + "papers.dat",NUM_ITEM,ITEM_EMB) model = CVAE(num_features=50, max_epoch=50 , max_iter=5, a=1, b=0.01, lambda_u=0.1, lambda_v=10, lambda_r=10,vae_pre_training="CVAE\\data\\vae_0920.pt") model.fit(train_users,test_users,train_items, side_info) # VAE 经过逐层预训练(单独用每一层的小网络训练),得到预训练参数 vae_pre_training.pt # 选择 p=5, 在citeulike-a上实验,在经过约 10 个epoch 后,recall@50 达到0.2,复现了论文中的实验结果数值
def main(): parser = argparse.ArgumentParser( description='Train MVAE with VCC2018 dataset', formatter_class=argparse.ArgumentDefaultsHelpFormatter) parser.add_argument('--train-dataset', help='Path of training dataset.', type=str, required=True) parser.add_argument('--val-dataset', help='Path of validation dataset.', type=str, required=True) parser.add_argument('--batch-size', '-b', help='Batch size.', type=int, default=32) parser.add_argument('--epochs', '-e', help='Number of epochs.', type=int, default=800) parser.add_argument('--eval-interval', help='Evaluate and save model every N epochs.', type=int, default=200, metavar='N') parser.add_argument('--gpu', '-g', help='GPU id. (Negative number indicates CPU)', type=int, default=-1) parser.add_argument('--learning-rate', '-l', help='Learning Rate.', type=float, default=1e-3) parser.add_argument('--output', help='Save model to PATH', type=str, default='./models') args = parser.parse_args() if not os.path.isdir(args.output): os.mkdir(args.output) if_use_cuda = torch.cuda.is_available() and args.gpu >= 0 if if_use_cuda: device = torch.device(f'cuda:{args.gpu}') cp.cuda.Device(args.gpu).use() else: device = torch.device('cpu') train_dataset = torch.load(args.train_dataset) train_dataloader = torch.utils.data.DataLoader( train_dataset, args.batch_size, shuffle=True) val_dataset = make_eval_set(args.val_dataset) baseline = baseline_ilrma(val_dataset, device) model = CVAE(n_speakers=train_dataset[0][1].size(0)).to(device) optimizer = torch.optim.Adam(model.parameters(), args.learning_rate) # TensorBoard writer = SummaryWriter() for epoch in range(1, args.epochs + 1): train(model, train_dataloader, optimizer, device, epoch, writer) if epoch % args.eval_interval == 0: validate(model, val_dataset, baseline, device, epoch, writer) # Save model model.cpu() path = os.path.join(args.output, f'model-{epoch}.pth') torch.save(model.state_dict(), path) model.to(device) writer.close()
FULL_RL_MODEL_PATH = '/dat/breakout_dqn.h5' FULL_RL_MODEL_BLOB_NAME = 'rl-full.h5' # ensure files are downloaded if not os.path.isfile(CVAE_DATA_PATH): download_blob(CVAE_DATA_BLOB_NAME, CVAE_DATA_PATH) if not os.path.isfile(CVAE_MODEL_PATH): download_blob(CVAE_MODEL_BLOB_NAME, CVAE_MODEL_PATH) if not os.path.isfile(FULL_RL_MODEL_PATH): download_blob(FULL_RL_MODEL_BLOB_NAME, FULL_RL_MODEL_PATH) # load files with open(CVAE_DATA_PATH, 'rb') as f: CVAE_DATA = pickle.load(f) CVAE_MODEL = CVAE(data_dim=EMBEDDING_DIM * 2, label_dim=9, model_path=CVAE_MODEL_PATH) FULL_RL_MODEL = DQNAgent(action_size=3, load_model=True, no_op_steps=0) def simple_sample(n_real, n_fake): ''' Generates a mixed dataset of simulated and real embedded samples. Samples are "embedded" because we've used transfer learning. Sampling is "simple" because the GAN is not fit with each simple. ''' ## sample real data real_data = [] if n_real > 0: real_data = __sample_real_data(n_real) ## sample fake data
(x_train, y_train), (x_test, y_test) = mnist.load_data() y_train = keras.utils.to_categorical(y_train) y_test = keras.utils.to_categorical(y_test) x_train = x_train.astype('float32') / 255. x_test = x_test.astype('float32') / 255. x_train = x_train.reshape((len(x_train), np.prod(x_train.shape[1:]))) x_test = x_test.reshape((len(x_test), np.prod(x_test.shape[1:]))) # Train model original_dim = x_train.shape[1] label_dim = 1 vae_obj = CVAE(original_dim, label_dim, layers, activation='relu', optimizer=optimizer, dropout=0.0) vae = vae_obj.compile() vae.summary() vae.fit([x_train, y_train], x_train, shuffle=True, epochs=nr_epochs, batch_size=batch_size, validation_data=([x_test, y_test], x_test), verbose=1) # this loop prints the one-hot decodings
def train_cvae(X_source, X_aux_list, X_target, X_source_t, X_aux_list_t, X_target_t): cvae = CVAE(input_shape=58, hidden_layers=1, dims=[45, 30]) input_tensor = tf.compat.v1.placeholder(dtype=tf.float32, shape=(None, 58)) cond_tensor = tf.compat.v1.placeholder(dtype=tf.float32, shape=(None, 4)) label_tensor = tf.compat.v1.placeholder(dtype=tf.float32, shape=(None, 58)) train_tensor = tf.compat.v1.placeholder(dtype=tf.float32, shape=()) train_ds = tf.data.Dataset.from_tensor_slices( (input_tensor, cond_tensor, label_tensor)).shuffle(100000).batch(BATCH).repeat() iterator = train_ds.make_initializable_iterator() dat, c, lab = iterator.get_next() #cvae = CVAE(100, hidden_layers=1, dims=[50, 20]) #cvae.init_model(input_tensor, cond_tensor, label_tensor, train_tensor) cvae.init_model(dat, c, lab, train_tensor) model = cvae.model_ loss = cvae.loss_ train_op = tf.train.AdamOptimizer().minimize(loss) X_train = np.vstack([X_source] + X_aux_list) X_train_t = np.vstack([X_source_t] + X_aux_list_t) k = len(X_aux_list) + 1 C_train = [k] * X_source.shape[0] for i in range(len(X_aux_list)): k -= 1 C_train += [k] * X_aux_list[i].shape[0] print(len(C_train)) print(X_train.shape) print(C_train) C_train = np.array(C_train) C_train = np.eye(len(X_aux_list) + 1)[C_train - 1] with tf.Session() as sess: sess.run(tf.compat.v1.global_variables_initializer()) sess.run(iterator.initializer, feed_dict={ input_tensor: X_train, cond_tensor: C_train, label_tensor: X_train_t, train_tensor: 1 }) for i in range(EPOCH): tot_loss = 0 for _ in range(X_train.shape[1] // BATCH): _, loss_value = sess.run([train_op, loss]) #feed_dict={input_tensor: X_train, cond_tensor: Y_tr, label_tensor: X_train, train_tensor: 1}) tot_loss += loss_value #if i%100 == 0: print("Iter: {}, Loss: {:.4f}".format( i, tot_loss / (X_train.shape[1] // BATCH))) yy = np.random.random_integers(0, 3, X_target.shape[0]) print(yy) yy = np.eye(len(X_aux_list) + 1)[yy] l = [] sess.run(iterator.initializer, feed_dict={ input_tensor: X_target, cond_tensor: yy, label_tensor: X_target_t, train_tensor: 1 }) for i in range(2000): for img in sess.run(model['op_tensor']): l.append(np.array(img)) l = np.vstack(l) np.savetxt('abc.txt', l)
from cvae import CVAE mnist = input_data.read_data_sets('../../MNIST_data', one_hot=True) INPUT_SIZE = mnist.train.labels.shape[1] OUTPUT_SIZE = mnist.train.images.shape[1] LATENT_SIZE = 100 BATCH_SIZE = 64 cvae = CVAE( input_size=INPUT_SIZE, output_size=OUTPUT_SIZE, latent_size=LATENT_SIZE, encoder_layer_sizes=(200, 200), decoder_layer_sizes=(200, 200), dataset_name='mnist' ) time_st = time.time() for it in range(int(2e4)): y, x = mnist.train.next_batch(BATCH_SIZE) loss = cvae.update(x, y) if it % int(1e3) == 0: print('Iter-{}; Loss: {:.4f}, fps:{}'.format(it, loss.data, (it+1) // (time.time() - time_st))) x = np.zeros(shape=[BATCH_SIZE, INPUT_SIZE], dtype=np.float32) x[:, np.random.randint(0, 10)] = 1.
def load_model_weights(latent_dim, dimension, filename): model = CVAE(latent_dim, dimension) model.load_weights(filename) return model
'encode': [ (16, 3, (2, 2)), # out: 64, 64, 8 (32, 3, (2, 2)), # out: 32, 32, 16 (64, 3, (2, 2)), # out: 16, 16, 32 (128, 3, (2, 2)), # out: 8, 8, 64 (256, 3, (2, 2)), # out: 4, 4, 128 (512, 3, (2, 2)), # out: 2, 2, 256 (1024, 3, (2, 2)) ], # out: 1, 1, 512 'decode': None, # Mirror enconding for reconstruction 'name': 'face_cvae_first_stage' } model = CVAE(arch_def, loss='kl_mse', learning_rate=0.0001) init_model_dirs(model.arch_def['name']) image_root = '/home/martin/dataset/cropped_faces' test_root = '/home/martin/dataset/face_test' batch_size = 4 epochs = 1500 steps_pr_epoch = 100 train_data = get_dataset(image_root, batch_size, model.arch_def['input']) eval_data = get_dataset(test_root, 1, model.arch_def['input']) run_train_loop(model, train_data, epochs, steps_pr_epoch, increase_beta_at=[500, 800, 1000, 1200, 1400],
from branch_code_data import BranchCodeLoader test_data = "C:/Users/Administrator/Desktop/TestVirtualPCNeuron/data" save_dir = "C:/Users/Administrator/Desktop/TestVirtualPCNeuron/vae_save" data_size = 20 * 3 batch_size = 1000 epochs = 100 latent_dim = 50 num_examples_to_generate = 16 # keeping the random vector constant for generation (prediction) so # it will be easier to see the improvement. random_vector_for_generation = tf.random.normal( shape=[num_examples_to_generate, latent_dim]) model = CVAE(latent_dim) optimizer = tf.train.AdamOptimizer(1e-4) def log_normal_pdf(sample, mean, logvar, raxis=1): log2pi = tf.math.log(2. * np.pi) return tf.reduce_sum( -.5 * ((sample - mean)**2. * tf.exp(-logvar) + logvar + log2pi), axis=raxis) def compute_loss(model, x): mean, logvar = model.encode(x) z = model.reparameterize(mean, logvar) x_logit = model.decode(z)