class Generator: 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 _logsig(self, path): return tosig.stream2logsig(path, self.order) def _build_dataset(self): self.logsigs = np.array([self._logsig(path) for path in tqdm(self.corpus, desc="Computing log-signatures")]) self.scaler = MinMaxScaler(feature_range=(0.00001, 0.99999)) self.logsigs_norm = self.scaler.fit_transform(self.logsigs) def train(self, n_epochs=10000): self.generator.train(self.logsigs_norm, data_cond=None, n_epochs=n_epochs) def generate(self, n_samples=None, normalised=False): generated = self.generator.generate(cond=None, n_samples=n_samples) if normalised: return generated if n_samples is None: return self.scaler.inverse_transform(generated.reshape(1, -1))[0] return self.scaler.inverse_transform(generated)
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 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 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 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 build_Nd_cvae(sess, source, 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, source, batch_size, display_step=1, training_epochs=epochs) cvae.save(sess, model_filename) return cvae
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 __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)
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 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
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()
def load_model_weights(latent_dim, dimension, filename): model = CVAE(latent_dim, dimension) model.load_weights(filename) return model
(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
print(label) if len(label2image[label]) >= 4: continue label2image[label].append(image) for label, images in label2image.items(): for i, image in enumerate(images[:4]): plt.subplot(2, 2, 1 + i) plt.imshow(image) plt.title(f'label {label}') plt.axis('off') plt.show() image_root = '/home/martin/Desktop/data/darknet_data/openimgs_extra_v2' model = CVAE.from_file('models/oi_cvae_5/oi_cvae_5.state', 'models/oi_cvae_5/oi_cvae_5.weights') tb = CVAEToolBox(model) images = ImageFeed(image_root, tb) set_size = 100000 kmeans = Kmeans(49) load = False save = True if load: kmeans.cluster_centers_ = np.load('centroids.npy') else: batch = [] for _ in tqdm(range(set_size), leave=False, desc='loading '): tensor, _ = next(images)
class MarketGenerator: 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) def _load_rough_bergomi(self, params): grid_points_dict = {"M": 28, "W": 5, "Y": 252} grid_points = grid_points_dict[self.freq] params["T"] = grid_points / grid_points_dict["Y"] paths = rough_bergomi(grid_points, **params) self.windows = [leadlag(path) for path in paths] def _load_data(self): try: self.data = pdr.get_data_yahoo(self.ticker, self.start, self.end)["Close"] except: raise RuntimeError( f"Could not download data for {self.ticker} from {self.start} to {self.end}." ) self.windows = [] for _, window in self.data.resample(self.freq): values = window.values # / window.values[0] path = leadlag(values) self.windows.append(path) def _logsig(self, path): return tosig.stream2logsig(path, self.order) def _build_dataset(self): if self.order: self.orig_logsig = np.array([ self._logsig(path) for path in tqdm(self.windows, desc="Computing log-signatures") ]) else: self.orig_logsig = np.array( [np.diff(np.log(path[::2, 1])) for path in self.windows]) self.orig_logsig = np.array( [p for p in self.orig_logsig if len(p) >= 4]) steps = min(map(len, self.orig_logsig)) self.orig_logsig = np.array( [val[:steps] for val in self.orig_logsig]) self.scaler = MinMaxScaler(feature_range=(0.00001, 0.99999)) logsig = self.scaler.fit_transform(self.orig_logsig) self.logsigs = logsig[1:] self.conditions = logsig[:-1] def train(self, n_epochs=10000): self.generator.train(self.logsigs, self.conditions, n_epochs=n_epochs) def generate(self, logsig, n_samples=None, normalised=False): generated = self.generator.generate(logsig, n_samples=n_samples) if normalised: return generated if n_samples is None: return self.scaler.inverse_transform(generated.reshape(1, -1))[0] return self.scaler.inverse_transform(generated)
'encode': [ (32, 3, (2, 2)), # out: 256, 256, 32 (64, 3, (2, 2)), # out: 128, 128, 64 (128, 3, (2, 2)), # out: 64, 64, 128 (256, 3, (2, 2)), # out: 32, 32, 256 (512, 3, (2, 2)), # out: 16, 16, 512 (1024, 3, (2, 2)), # out: 8, 8, 1024 (2048, 3, (2, 2)) ], # out: 4, 4, 2048 'decode': None, # Mirror enconding for reconstruction 'name': 'oi_cvae_7' } model = CVAE(arch_def, loss='kl_mse', learning_rate=0.0001) #model.load_weights('models/oi_cvae_4/oi_cvae_4.weights') init_model_dirs(model.arch_def['name']) image_root = '/home/martin/Desktop/data/darknet_data/openimgs_extra_v2' test_root = '/home/martin/Desktop/data/validation_set' batch_size = 8 total_steps = 15000 epochs = 2000 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,
def getTeacherRatio(epoch): # from 1 to 0 return 1. - (1. / (epochs - 1)) * (epoch) if __name__ == '__main__': train_dataset = WordDataset('train') test_dataset = WordDataset('test') max_length = train_dataset.max_length train_dataloader = DataLoader(train_dataset, batch_size=1, shuffle=True) test_dataloader = DataLoader(test_dataset, batch_size=1, shuffle=False) tense_list = test_dataloader.dataset.tense2idx.values() model = CVAE(max_length) model = model.to(device) if args.load_model != None: state_dict = torch.load(args.loadmodel) model.load_state_dict(state_dict) optimizer = optim.SGD(model.parameters(), lr=lr) transformer = WordTransoformer() trainset_size = len(train_dataloader.dataset) testset_size = len(test_dataloader.dataset) writer = SummaryWriter('logs/' + args.exp_name) start = time.time() best_bleu_score = 0 annealing_rate = 0.01 cycle = 15 # annealing_rate = 1./(args.warmup * len(train_dataloader.dataset))
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,
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]
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)
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
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)
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,
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)
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
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 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)
'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],
word2index, index2word = build_vocab(vocab_f) start_i, end_i = word2index['<s>'], word2index['</s>'] vocab_size = len(word2index) emoji_b2s, emoji_s2b, emoji_sorted = build_emoji_index(vocab_f, emoji_64) p = Printer(log_f, index2word) """build graphs and init params""" config = tf.ConfigProto() config.gpu_options.allow_growth = True graph0 = tf.Graph() with graph0.as_default(): kl_ceiling = 0.48 seq2seq = 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=False) sess0 = tf.Session(graph=graph0, config=config) sess0.run(tf.global_variables_initializer()) seq2seq.set_sess(sess0) train_vars = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES) saver0 = tf.train.Saver(var_list=train_vars, max_to_keep=25) saver0.restore(sess0, "cvae/07-17_15-51-04/breakpoints/at_step_36500.ckpt") graph0.finalize() graph1 = tf.Graph() with graph1.as_default(): classifier = EmojiClassifier(batch_size, vocab_size, emoji_num, embed_size, num_unit, num_gpu, lr=0.001, dropout=0.2, cell_type=tf.nn.rnn_cell.GRUCell) saver1 = tf.train.Saver()