def g_train(g_model, d_model, g_optim, loss_function, real_labels, writer,
args, git):
"""
Training loop of generator
"""
Z = generate_z(args).to(args.device)
if not args.unpac:
fake = torch.cat(torch.split(g_model(Z), args.batch_size // 2, dim=0),
1)
else:
fake = g_model(Z)
d_fake = d_model(fake)
if loss_function is None:
g_loss = -torch.mean(d_fake)
else:
g_loss = loss_function(d_fake, real_labels)
writer.add_scalar('g_loss', g_loss, git)
g_optim.zero_grad()
g_loss.backward()
g_optim.step()
summarize_grad(g_model, writer, git, 'g')
return g_loss
def evolve():
'''
Evolve the view using the requested evolutions:
If the evolution is specified as simple, use an 1:1
implementation of the original DeepIE
Else, evolve based on the desired, user specification
Some sort of novelty search is performed if novelty=True
Behaviorla novelty search can be toggle in Constants, but is very slow
The response is 9 Z vectors
'''
evolved, body = [], {}
request_json = request.get_json()
evolution_specifications = request_json['specifications']
novelty = request_json['novelty']
mutation_rate = request_json['mutation']
if 'SIMPLE' in evolution_specifications:
selected_canvases = []
for i in range(int(evolution_specifications[6])):
selected_canvases.append(request_json[f'selected{i}'])
zs = [request_json[f'z{i}'] for i in range(9)]
evolved = simple_evolution(
selected_canvases, zs, G, novelty, BEHAVIORAL, mutation_rate)
else:
evolution_specifications = evolution_specifications.split(',')
for specification in evolution_specifications:
if specification[0] == 'M':
evolved.append(
mutate(request_json[f'z{specification[2]}'], mutation_rate))
elif specification[0] == 'K':
evolved.append(request_json[f'z{specification[2]}'])
elif specification[0] == 'N' and not novelty:
evolved.append(generate_z().tolist())
elif specification[0] == 'C':
evolved.append(crossover(
request_json[f'z{specification[2]}'], request_json[f'z{specification[5]}']))
if novelty:
evolved = behavioral_novelty_search(
evolved, G) if BEHAVIORAL else novelty_search(evolved)
for i in range(len(evolved)):
body[f'z{i}'] = evolved[i]
return jsonify(body)
def initialize_single():
'''
Initialize the view:
Respond with coords of nonzeros, Z vector and camera placement information
'''
model_type = request.get_json()['model_type']
body = {}
z = generate_z()
voxels = G.generate(z, model_type)
coords = create_coords_from_voxels(voxels)
body['z'] = z.tolist()
body['coords'] = coords
body['camera'] = CAMERA_PLANE if model_type == 'Plane' else CAMERA_CHAIR
return jsonify(body)
def train(self):
self.train_hist = {}
self.train_hist['D_loss'] = []
self.train_hist['G_loss'] = []
self.train_hist['E_loss'] = []
self.train_hist['per_epoch_time'] = []
self.train_hist['total_time'] = []
if torch.cuda.is_available():
self.y_real_, self.y_fake_ = Variable(
torch.ones(self.batch_size, 1).cuda()), Variable(
torch.zeros(self.batch_size, 1).cuda())
else:
self.y_real_, self.y_fake_ = Variable(
torch.ones(self.batch_size,
1)), Variable(torch.zeros(self.batch_size, 1))
self.D.train()
print('training start!!')
start_time = time.time()
#check_point =255
#self.load(check_point)
#print("loading " + str(check_point))
for epoch in range(0, self.epoch):
# reset training mode of G and E
# print("Learning rate decay")
self.G_optimizer.param_groups[0]['lr'] = self.args.lrG / np.sqrt(
epoch + 1)
self.D_optimizer.param_groups[0]['lr'] = self.args.lrD / np.sqrt(
epoch + 1)
# self.E_optimizer.param_groups[0]['lr'] = self.args.lrE / np.sqrt(epoch + 1)
epoch_start_time = time.time()
for iter, (X, _) in enumerate(self.train_loader):
X = utils.to_var(X)
"""Discriminator"""
z = utils.generate_z(self.batch_size, self.z_dim, self.prior)
X_hat = self.G(z)
D_real = self.D(self.FC(X))
D_fake = self.D(self.FC(X_hat))
X_hat = self.G(z)
z_mu, z_sigma = self.E(self.FC(X_hat))
# D_loss = self.BCE_loss(D_real, self.y_real_) + self.BCE_loss(D_fake, self.y_fake_)
D_loss = -1.0 * torch.mean(D_real - torch.exp(D_fake - 1.0))
self.train_hist['D_loss'].append(D_loss.data.item())
# Optimize
D_loss.backward()
# gradient clipping
torch.nn.utils.clip_grad_value_(
chain(self.D.parameters(), self.FC.parameters()), 1.0)
self.D_optimizer.step()
self.__reset_grad()
"""Encoder"""
#z = utils.generate_z(self.batch_size, self.z_dim, self.prior)
X_hat = self.G(z)
z_mu, z_sigma = self.E(self.FC(X_hat))
# - loglikehood
E_loss = torch.mean(
torch.mean(
0.5 * (z - z_mu)**2 * torch.exp(-z_sigma) +
0.5 * z_sigma + 0.9189, 1))
self.train_hist['E_loss'].append(E_loss.data.item())
# Optimize
E_loss.backward()
self.E_optimizer.step()
self.__reset_grad()
"""Generator"""
# Use both Discriminator and Encoder to update Generator
#z = utils.generate_z(self.batch_size, self.z_dim, self.prior)
X_hat = self.G(z)
D_fake = self.D(self.FC(X_hat))
z_mu, z_sigma = self.E(self.FC(X_hat))
mode_loss = torch.mean(
torch.mean(
0.5 * (z - z_mu)**2 * torch.exp(-z_sigma) +
0.5 * z_sigma + 0.9189, 1))
# G_loss = self.BCE_loss(D_fake, self.y_real_)
G_loss = -1.0 * torch.mean(
D_fake) # deal with gradient vanish 2
total_loss = G_loss + mode_loss
self.train_hist['G_loss'].append(G_loss.data.item())
# Optimize
total_loss.backward()
# gradient clipping
torch.nn.utils.clip_grad_value_(chain(self.G.parameters()),
1.0)
self.G_optimizer.step()
self.__reset_grad()
"""Plot"""
if (
iter + 1
) == self.train_loader.dataset.__len__() // self.batch_size:
print(
'Epoch-{}; D_loss: {:.4}; G_loss: {:.4}; Mode_loss: {:.4}\n'
.format(epoch, D_loss.data.item(), G_loss.data.item(),
mode_loss.data.item()))
self.visualize_results(epoch + 1)
self.train_hist['per_epoch_time'].append(time.time() -
epoch_start_time)
if (epoch + 1) % 20 == 0:
print("Save Model")
self.save(epoch)
break
# Save model every 5 epochs
self.save(epoch)
self.train_hist['total_time'].append(time.time() - start_time)
#self.save(epoch)
print("Avg one epoch time: %.2f, total %d epochs time: %.2f" %
(np.mean(self.train_hist['per_epoch_time']), self.epoch,
self.train_hist['total_time'][0]))
print("Training finish!... save training results")
def train(self):
self.train_hist = {}
self.train_hist['D_loss'] = []
self.train_hist['G_loss'] = []
self.train_hist['E_loss'] = []
self.train_hist['per_epoch_time'] = []
self.train_hist['total_time'] = []
if torch.cuda.is_available():
self.y_real_, self.y_fake_ = Variable(
torch.ones(self.batch_size, 1).cuda()), Variable(
torch.zeros(self.batch_size, 1).cuda())
else:
self.y_real_, self.y_fake_ = Variable(
torch.ones(self.batch_size,
1)), Variable(torch.zeros(self.batch_size, 1))
self.D.train()
print('training start!!')
start_time = time.time()
for epoch in range(self.epoch):
# reset training mode of G and E
self.G.train()
self.E.train()
self.FC.train()
epoch_start_time = time.time()
E_err = []
D_err = []
G_err = []
for iter, (X, _) in enumerate(self.train_loader):
X = utils.to_var(X)
"""Discriminator"""
z = utils.generate_z(self.batch_size, self.z_dim, self.prior)
X_hat = self.G(z)
D_real = self.D(self.FC(X))
D_fake = self.D(self.FC(X_hat))
D_loss = self.BCE_loss(D_real, self.y_real_) + self.BCE_loss(
D_fake, self.y_fake_)
self.train_hist['D_loss'].append(D_loss.data[0])
D_err.append(D_loss.data[0])
# Optimize
D_loss.backward()
if self.grad_clip:
torch.nn.utils.clip_grad_norm(
chain(self.D.parameters(), self.FC.parameters()),
self.grad_clip_val)
self.D_optimizer.step()
self.__reset_grad()
# """Encoder"""
# z = utils.generate_z(self.batch_size, self.z_dim, self.prior)
# X_hat = self.G(z)
# z_mu, z_sigma = self.E(self.FC(X_hat))
# # - loglikehood
# E_loss = torch.mean(torch.mean(0.5 * (z - z_mu) ** 2 * torch.exp(-z_sigma) + 0.5 * z_sigma + 0.5 * np.log(2*np.pi), 1))
# self.train_hist['E_loss'].append(E_loss.data[0])
# E_err.append(E_loss.data[0])
# # Optimize
# E_loss.backward()
# self.E_optimizer.step()
# self.__reset_grad()
"""Generator"""
# Use both Discriminator and Encoder to update Generator
z = utils.generate_z(self.batch_size, self.z_dim, self.prior)
X_hat = self.G(z)
D_fake = self.D(self.FC(X_hat))
z_mu, z_sigma = self.E(self.FC(X_hat))
E_loss = torch.mean(
torch.mean(
0.5 * (z - z_mu)**2 * torch.exp(-z_sigma) +
0.5 * z_sigma + 0.5 * np.log(2 * np.pi), 1))
G_loss = self.BCE_loss(D_fake, self.y_real_)
total_loss = G_loss + E_loss
self.train_hist['G_loss'].append(G_loss.data[0])
G_err.append(G_loss.data[0])
E_err.append(E_loss.data[0])
# Optimize
total_loss.backward()
if self.grad_clip:
torch.nn.utils.clip_grad_norm(self.G.parameters(),
self.grad_clip_val)
torch.nn.utils.clip_grad_norm(self.E.parameters(),
self.grad_clip_val)
self.G_optimizer.step()
self.E_optimizer.step()
self.__reset_grad()
"""Plot"""
if (
iter + 1
) == self.train_loader.dataset.__len__() // self.batch_size:
print(
'Epoch-{}; D_loss: {:.4}; G_loss: {:.4}; E_loss: {:.4}\n'
.format(epoch + 1, np.mean(D_err), np.mean(G_err),
np.mean(E_err)))
self.visualize_results(epoch + 1)
break
self.train_hist['per_epoch_time'].append(time.time() -
epoch_start_time)
# learning rate decay
if self.lr_decay:
rate = np.sqrt(epoch + 1) / np.sqrt(epoch + 2)
self.G_optimizer.param_groups[0]['lr'] *= rate
self.D_optimizer.param_groups[0]['lr'] *= rate
self.E_optimizer.param_groups[0]['lr'] *= rate
print("learning rate change!")
# Save model
if (epoch + 1) % 20 == 0:
self.save()
self.train_hist['total_time'].append(time.time() - start_time)
print("Avg one epoch time: %.2f, total %d epochs time: %.2f" %
(np.mean(self.train_hist['per_epoch_time']), self.epoch,
self.train_hist['total_time'][0]))
print("Training finish!... save training results")
self.save()
def d_train(d_model, g_model, d_optim, loss_function, batch, writer, args):
"""
Training loop of discriminator
"""
if args.labels == 'noisy':
real_labels = (torch.FloatTensor(args.batch_size //
(1 if args.unpac else 2)).uniform_(
0.85, 1.0)).to(args.device)
fake_labels = (torch.FloatTensor(args.batch_size //
(1 if args.unpac else 2)).uniform_(
0.0, 0.15)).to(args.device)
elif args.labels == 'hard':
real_labels = torch.ones(args.batch_size //
(1 if args.unpac else 2)).to(args.device)
fake_labels = torch.zeros(args.batch_size //
(1 if args.unpac else 2)).to(args.device)
elif args.labels == 'd_hard':
real_labels = torch.FloatTensor([
0.9 for _ in range(args.batch_size // (1 if args.unpac else 2))
]).to(args.device)
fake_labels = torch.zeros(args.batch_size //
(1 if args.unpac else 2)).to(args.device)
if not args.unpac:
X = torch.cat(torch.split(batch, args.batch_size // 2, dim=0),
1).view(-1, 2, args.cube_len, args.cube_len,
args.cube_len).to(args.device)
else:
X = batch.view(-1, 1, args.cube_len, args.cube_len,
args.cube_len).to(args.device)
d_total_acc = 0.0
it = 0
while it < args.d_iter and d_total_acc < args.d_low_thresh:
args.current_iteration = args.current_iteration + 1
Z = generate_z(args).to(args.device)
d_real = d_model(X)
if loss_function is None:
d_real_loss = -torch.mean(d_real)
else:
d_real_loss = loss_function(d_real, real_labels)
if not args.unpac:
fake = torch.cat(
torch.split(g_model(Z), args.batch_size // 2, dim=0), 1)
else:
fake = g_model(Z)
d_fake = d_model(fake)
if loss_function is None:
d_fake_loss = torch.mean(d_fake)
else:
d_fake_loss = loss_function(d_fake, fake_labels)
if args.gan_type in ['wgan_gp']:
grad_pen = calc_gradient_penalty(d_model, X, fake, args)
else:
grad_pen = 0.0
d_loss = (d_fake_loss + d_real_loss) + grad_pen
if args.gan_type in ['wgan_gp']:
writer.add_scalar('grad_pen', grad_pen, args.current_iteration)
if args.gan_type in ['dcgan']:
d_real_acc = torch.ge(d_real.squeeze(), 0.5).float()
d_fake_acc = torch.le(d_fake.squeeze(), 0.5).float()
d_total_acc = torch.mean(torch.cat((d_real_acc, d_fake_acc), 0))
writer.add_scalar('d_total_acc', d_total_acc,
args.current_iteration)
writer.add_scalar('d_real_loss', d_fake_loss, args.current_iteration)
writer.add_scalar('d_fake_loss', d_fake_loss, args.current_iteration)
writer.add_scalar('d_total_loss', d_fake_loss, args.current_iteration)
if not (args.gan_type in ['dcgan']
and d_total_acc > args.d_high_thresh):
d_optim.zero_grad()
d_loss.backward()
d_optim.step()
summarize_grad(d_model, writer, args.current_iteration, 'd')
it += 1
return d_total_acc, real_labels
def train(self):
self.train_hist = {}
self.train_hist['D_loss'] = []
self.train_hist['G_loss'] = []
self.train_hist['E_loss'] = []
self.train_hist['per_epoch_time'] = []
self.train_hist['total_time'] = []
if torch.cuda.is_available():
self.y_real_, self.y_fake_ = Variable(
torch.ones(self.batch_size, 1).cuda()), Variable(
torch.zeros(self.batch_size, 1).cuda())
else:
self.y_real_, self.y_fake_ = Variable(
torch.ones(self.batch_size,
1)), Variable(torch.zeros(self.batch_size, 1))
self.D.train()
print('training start!!')
start_time = time.time()
for epoch in range(self.epoch):
# reset training mode of G and E
self.G.train()
self.E.train()
epoch_start_time = time.time()
for iter, (X, _) in enumerate(self.train_loader):
X = utils.to_var(X)
"""Discriminator"""
z = utils.generate_z(self.batch_size, self.z_dim, self.prior)
x_noise = utils.generate_z(self.batch_size, self.z_dim,
self.prior)
X_hat = self.G(z)
z_hat = self.E(X, x_noise)
D_real = self.D(X, z_hat)
D_fake = self.D(X_hat, z)
D_loss = self.BCE_loss(D_real, self.y_real_) + self.BCE_loss(
D_fake, self.y_fake_)
self.train_hist['D_loss'].append(D_loss.data[0])
# Optimize
D_loss.backward()
self.D_optimizer.step() # update D
self.__reset_grad()
"""Generator and Encoder"""
# Use both Discriminator and Encoder to update Generator
z = utils.generate_z(self.batch_size, self.z_dim, self.prior)
x_noise = utils.generate_z(self.batch_size, self.z_dim,
self.prior)
X_hat = self.G(z)
D_fake = self.D(X_hat, z)
z_hat = self.E(X_hat, x_noise)
E_loss = torch.mean(torch.sum((z - z_hat)**2, 1))
self.train_hist['E_loss'].append(E_loss.data[0])
G_loss = self.BCE_loss(D_fake, self.y_real_)
total_loss = G_loss + E_loss
self.train_hist['G_loss'].append(G_loss.data[0])
# Optimize
total_loss.backward()
self.E_optimizer.step() # update E
self.G_optimizer.step() # update G
self.__reset_grad()
"""Plot"""
if (
iter + 1
) == self.train_loader.dataset.__len__() // self.batch_size:
print(
'Epoch-{}; D_loss: {:.4}; G_loss: {:.4}; E_loss: {:.4}\n'
.format(epoch, D_loss.data[0], G_loss.data[0],
E_loss.data[0]))
self.visualize_results(epoch + 1)
break
self.train_hist['per_epoch_time'].append(time.time() -
epoch_start_time)
# Save model every 5 epochs
if epoch % 5 == 0:
self.save()
self.train_hist['total_time'].append(time.time() - start_time)
print("Avg one epoch time: %.2f, total %d epochs time: %.2f" %
(np.mean(self.train_hist['per_epoch_time']), self.epoch,
self.train_hist['total_time'][0]))
print("Training finish!... save training results")
self.save()
def train(self, config):
d_optim = tf.train.AdamOptimizer(config.learning_rate,
beta1=config.beta1).minimize(
self.d_loss, var_list=self.d_vars)
g_optim = tf.train.AdamOptimizer(config.learning_rate,
beta1=config.beta1).minimize(
self.g_loss, var_list=self.g_vars)
tf.global_variables_initializer().run()
self.g_sum = summarys['merge']([
self.z_sum, self.d__sum, self.G_sum, self.d_loss_fake_sum,
self.g_loss_sum
])
self.d_sum = summarys['merge'](
[self.z_sum, self.d_sum, self.d_loss_real_sum, self.d_loss_sum])
self.writer = summarys['writer']('.logs', self.sess.graph)
counter = 1
start_time = time.time()
could_load, checkpoint_counter = self.load(self.checkpoint_dir)
if could_load:
counter = checkpoint_counter
print "[*] load success"
else:
print "[!] load field !!"
for epoch in tqdm(range(config.epoch)):
batch_idxs = min(len(self.data_x),
config.train_size) // config.batch_size
for idx in range(0, batch_idxs):
batch_images = self.data_x[idx * config.batch_size:(idx + 1) *
config.batch_size]
batch_labels = self.data_y[idx * config.batch_size:(idx + 1) *
config.batch_size]
batch_z = generate_z(self.batch_size, self.z_dim * 4)
# update D network
_, summary_str = self.sess.run(
[d_optim, self.d_sum],
feed_dict={
self.x_set[0]:
batch_images[:, 0:int(self.input_height /
np.sqrt(self.num_patches)),
0:int(self.input_width /
np.sqrt(self.num_patches)), :],
self.x_set[1]:
batch_images[:, 0:int(self.input_height /
np.sqrt(self.num_patches)),
0:int(self.input_width /
np.sqrt(self.num_patches)), :],
self.x_set[2]:
batch_images[:, 0:int(self.input_height /
np.sqrt(self.num_patches)),
0:int(self.input_width /
np.sqrt(self.num_patches)), :],
self.x_set[3]:
batch_images[:, 0:int(self.input_height /
np.sqrt(self.num_patches)),
0:int(self.input_width /
np.sqrt(self.num_patches)), :],
self.z_set[0]:
batch_z[:, 0:self.z_dim],
self.z_set[1]:
batch_z[:, self.z_dim:self.z_dim * 2],
self.z_set[2]:
batch_z[:, self.z_dim * 2:self.z_dim * 3],
self.z_set[3]:
batch_z[:, self.z_dim * 3:self.z_dim * 4],
self.y_set[0]:
np.concatenate([
batch_labels,
np.array([[0, 0]] * self.batch_size).astype(
np.float32)
],
axis=1),
self.y_set[1]:
np.concatenate([
batch_labels,
np.array([[0, 1]] * self.batch_size).astype(
np.float32)
],
axis=1),
self.y_set[2]:
np.concatenate([
batch_labels,
np.array([[1, 0]] * self.batch_size).astype(
np.float32)
],
axis=1),
self.y_set[3]:
np.concatenate([
batch_labels,
np.array([[1, 1]] * self.batch_size).astype(
np.float32)
],
axis=1)
})
self.writer.add_summary(summary_str, counter)
for i in range(config.g_epoch):
# update G network g_epoch times
_, summary_str = self.sess.run(
[g_optim, self.g_sum],
feed_dict={
self.z_set[0]:
batch_z[:, 0:self.z_dim],
self.z_set[1]:
batch_z[:, self.z_dim:self.z_dim * 2],
self.z_set[2]:
batch_z[:, self.z_dim * 2:self.z_dim * 3],
self.z_set[3]:
batch_z[:, self.z_dim * 3:self.z_dim * 4],
self.y_set[0]:
np.concatenate([
batch_labels,
np.array([[0, 0]] * self.batch_size).astype(
np.float32)
],
axis=1),
self.y_set[1]:
np.concatenate([
batch_labels,
np.array([[0, 1]] * self.batch_size).astype(
np.float32)
],
axis=1),
self.y_set[2]:
np.concatenate([
batch_labels,
np.array([[1, 0]] * self.batch_size).astype(
np.float32)
],
axis=1),
self.y_set[3]:
np.concatenate([
batch_labels,
np.array([[1, 1]] * self.batch_size).astype(
np.float32)
],
axis=1)
})
self.writer.add_summary(summary_str, counter)
errD_fake = self.d_loss_fake.eval({
self.z_set[0]:
batch_z[:, 0:self.z_dim],
self.z_set[1]:
batch_z[:, self.z_dim:self.z_dim * 2],
self.z_set[2]:
batch_z[:, self.z_dim * 2:self.z_dim * 3],
self.z_set[3]:
batch_z[:, self.z_dim * 3:self.z_dim * 4],
self.y_set[0]:
np.concatenate([
batch_labels,
np.array([[0, 0]] * self.batch_size).astype(np.float32)
],
axis=1),
self.y_set[1]:
np.concatenate([
batch_labels,
np.array([[0, 1]] * self.batch_size).astype(np.float32)
],
axis=1),
self.y_set[2]:
np.concatenate([
batch_labels,
np.array([[1, 0]] * self.batch_size).astype(np.float32)
],
axis=1),
self.y_set[3]:
np.concatenate([
batch_labels,
np.array([[1, 1]] * self.batch_size).astype(np.float32)
],
axis=1)
})
errD_real = self.d_loss_real.eval({
self.x_set[0]:
batch_images[:, 0:int(self.input_height /
np.sqrt(self.num_patches)),
0:int(self.input_width /
np.sqrt(self.num_patches)), :],
self.x_set[1]:
batch_images[:, 0:int(self.input_height /
np.sqrt(self.num_patches)),
0:int(self.input_width /
np.sqrt(self.num_patches)), :],
self.x_set[2]:
batch_images[:, 0:int(self.input_height /
np.sqrt(self.num_patches)),
0:int(self.input_width /
np.sqrt(self.num_patches)), :],
self.x_set[3]:
batch_images[:, 0:int(self.input_height /
np.sqrt(self.num_patches)),
0:int(self.input_width /
np.sqrt(self.num_patches)), :],
self.y_set[0]:
np.concatenate([
batch_labels,
np.array([[0, 0]] * self.batch_size).astype(np.float32)
],
axis=1),
self.y_set[1]:
np.concatenate([
batch_labels,
np.array([[0, 1]] * self.batch_size).astype(np.float32)
],
axis=1),
self.y_set[2]:
np.concatenate([
batch_labels,
np.array([[1, 0]] * self.batch_size).astype(np.float32)
],
axis=1),
self.y_set[3]:
np.concatenate([
batch_labels,
np.array([[1, 1]] * self.batch_size).astype(np.float32)
],
axis=1)
})
errG = self.g_loss.eval({
self.z_set[0]:
batch_z[:, 0:self.z_dim],
self.z_set[1]:
batch_z[:, self.z_dim:self.z_dim * 2],
self.z_set[2]:
batch_z[:, self.z_dim * 2:self.z_dim * 3],
self.z_set[3]:
batch_z[:, self.z_dim * 3:self.z_dim * 4],
self.y_set[0]:
np.concatenate([
batch_labels,
np.array([[0, 0]] * self.batch_size).astype(np.float32)
],
axis=1),
self.y_set[1]:
np.concatenate([
batch_labels,
np.array([[0, 1]] * self.batch_size).astype(np.float32)
],
axis=1),
self.y_set[2]:
np.concatenate([
batch_labels,
np.array([[1, 0]] * self.batch_size).astype(np.float32)
],
axis=1),
self.y_set[3]:
np.concatenate([
batch_labels,
np.array([[1, 1]] * self.batch_size).astype(np.float32)
],
axis=1)
})
counter += 1
if np.mod(counter, 100) == 1:
samples, d_loss, g_loss = self.sess.run(
[self.sampler, self.d_loss, self.g_loss],
feed_dict={
self.x_set[0]:
batch_images[:, 0:int(self.input_height /
np.sqrt(self.num_patches)),
0:int(self.input_width /
np.sqrt(self.num_patches)), :],
self.x_set[1]:
batch_images[:, 0:int(self.input_height /
np.sqrt(self.num_patches)),
0:int(self.input_width /
np.sqrt(self.num_patches)), :],
self.x_set[2]:
batch_images[:, 0:int(self.input_height /
np.sqrt(self.num_patches)),
0:int(self.input_width /
np.sqrt(self.num_patches)), :],
self.x_set[3]:
batch_images[:, 0:int(self.input_height /
np.sqrt(self.num_patches)),
0:int(self.input_width /
np.sqrt(self.num_patches)), :],
self.z_set[0]:
batch_z[:, 0:self.z_dim],
self.z_set[1]:
batch_z[:, self.z_dim:self.z_dim * 2],
self.z_set[2]:
batch_z[:, self.z_dim * 2:self.z_dim * 3],
self.z_set[3]:
batch_z[:, self.z_dim * 3:self.z_dim * 4],
self.y_set[0]:
np.concatenate([
batch_labels,
np.array([[0, 0]] * self.batch_size).astype(
np.float32)
],
axis=1),
self.y_set[1]:
np.concatenate([
batch_labels,
np.array([[0, 1]] * self.batch_size).astype(
np.float32)
],
axis=1),
self.y_set[2]:
np.concatenate([
batch_labels,
np.array([[1, 0]] * self.batch_size).astype(
np.float32)
],
axis=1),
self.y_set[3]:
np.concatenate([
batch_labels,
np.array([[1, 1]] * self.batch_size).astype(
np.float32)
],
axis=1)
})
save_images(
samples, image_manifold_size(samples.shape[0]),
'./{}/train_{:02d}_{:04d}.png'.format(
config.sample_dir, epoch, idx))
if np.mod(counter, 500) == 2:
self.save(config.checkpoint_dir, counter)
print("Epoch: [%2d] [%4d/%4d] time: %4.4f, d_loss: %.8f, g_loss: %.8f" \
% (epoch, idx, batch_idxs,
time.time() - start_time, errD_fake + errD_real, errG))
from flask import Flask, jsonify, request, send_file
from flask_compress import Compress
from torch import Tensor
from generate import SuperGenerator
from utils import generate_z, create_coords_from_voxels, generate_binvox_file, calculate_camera
from evolution import mutate, crossover, simple_evolution, behavioral_novelty_search, novelty_search
# Constants
COMPRESS = Compress()
BEHAVIORAL = False
APP = Flask(__name__)
G = SuperGenerator()
CAMERA_PLANE = calculate_camera(
[G.generate(generate_z(), 'Plane') for i in range(100)])
CAMERA_CHAIR = calculate_camera(
[G.generate(generate_z(), 'Chair') for i in range(100)])
@APP.after_request
def add_cors(response):
'''
Add CORS header(s) to every response from valid sites
Allow:
- Origin from everywhere
- Content-Type to be shown in headers
- GET, POST and OPTIONS methos
'''
r = request.referrer[:-1]
if r in ['http://localhost:8080', 'localhost:8080', 'https://localhost:8080',
