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()
