def train(meta_files):
if not os.path.exists(config.OUTPUT_DIR):
os.mkdir(config.OUTPUT_DIR)
#recognizer=cv2.face.EigenFaceRecognizer_create()
#recognizer=cv2.face.FisherFaceRecognizer_create()
recognizer = cv2.face.LBPHFaceRecognizer_create()
global_accuracy = 0
print('\nProcessing...')
[list_img, list_label], num_sample = load_batch(meta_files[0])
if num_sample < 1:
return
recognizer.train(list_img, np.array(list_label))
train_accuracy = eval_model(recognizer, meta_files[0])
val_accuracy = eval_model(recognizer, meta_files[1])
test_accuracy = eval_model(recognizer, meta_files[2])
print(
'\nRESULT: Number of images: %d, Train accuracy: %g, Test accuracy: %g'
% (num_sample, train_accuracy, test_accuracy))
recognizer.save(os.path.join(config.OUTPUT_DIR, config.OUTPUT_MODEL_FILE))
def train(meta_files):
if len(meta_files) < 3:
meta_files = idm.init_dataset_meta()
if not os.path.exists(config.OUTPUT_DIR):
os.mkdir(config.OUTPUT_DIR)
recognizer = cv2.face.LBPHFaceRecognizer_create()
#global_accuracy = 0
[list_img, list_label], num_sample = load_batch(meta_files[0])
if num_sample < 1:
print('Err: 0 sample found')
recognizer.train(list_img, np.array(list_label))
#recognizer.update(list_img, np.array(list_label))
train_accuracy = eval_model(recognizer, meta_files[0])
val_accuracy = eval_model(recognizer, meta_files[1])
test_accuracy = eval_model(recognizer, meta_files[2])
print('Train accuracy = %f' % (train_accuracy))
print('Test accuracy = %f' % (test_accuracy))
print('Validate accuracy = %f' % (val_accuracy))
recognizer.write(os.path.join(config.OUTPUT_DIR, config.OUTPUT_MODEL_FILE))
def run(n_epochs):
is_best = np.inf
for epoch in range(n_epochs):
for n, images in enumerate(dataset.train_loader):
niter = epoch * len(dataset.train_loader) + n # count gradient updates
# training
model.train()
images = Variable(images).cuda()
optimizer.zero_grad()
output, mu, log_var = model(images)
loss = helpers.vae_loss(output, images, mu=mu, logvar=log_var, batch_size=batch_size, img_size=img_size, nc=nc)
loss.backward()
optimizer.step()
train_loss = loss.data[0]
writer.add_scalar('Loss/Train', train_loss, niter)
if epoch % log_interval == 0:
# testing
model.eval()
test_loss = 0
for n, images in enumerate(dataset.test_loader):
images = Variable(images).cuda()
output, mu, log_var = model(images)
test_loss += helpers.vae_loss(output, images, mu, log_var, batch_size, img_size, nc).data[0]
test_loss /= len(dataset.test_loader) # average over all iterations
writer.add_scalar('Loss/Test', test_loss, epoch)
if test_loss < is_best:
is_best = test_loss
torch.save(model.state_dict(), '{}/vae.pkl'.format(save_dir))
writer.add_text('best epoch', 'saved model at epoch {}'.format(epoch), 0)
if print_output:
print("Epoch [{}/{}], Gradient Step: {}, Train Loss: {:.4f}, Test Loss: {:.4f}"
.format(epoch, num_epochs, (epoch + 1) * len(dataset.train_loader), train_loss, test_loss))
# inspect reconstruction quality
n_samples = 4
data = dataset.load_batch(n_samples) # Get a batch of test data
input = Variable(data, volatile=True).cuda() # TODO what does volatile do here?
output, _, _ = model(input)
noise = Variable(torch.randn(n_samples, nz, 1, 1).cuda()) # fake_images = generator(noise)
generations = model.generator(noise)
sequence = torch.cat((input.data.cpu(), output.data.cpu(), generations.data.cpu()), 0)
grid = helpers.convert_image_np(torchvision.utils.make_grid(sequence, n_samples))
writer.add_image('Input, Reconstruction, Generation', grid, epoch)
def eval_model(recognizer, meta_file):
[list_img, list_label], num_sample = load_batch(meta_file)
if num_sample < 1:
return 0
check = 0
for i in range(num_sample):
prediction, _ = recognizer.predict(list_img[i])
check += prediction == list_label[i]
return float(check) / num_sample
def eval_model(recognizer, meta_file):
if not os.path.exists(meta_file):
print(meta_file, "doesn't exits!")
[list_img, list_lable], num_sample = load_batch(meta_file)
if num_sample < 1:
return 0
check = 0
for i in range(num_sample):
predection, _ = recognizer.predict(list_img[i])
check += predection == list_lable[i]
return float(check) / num_sample
def train(self, epochs, batch_size=1, sample_interval=50):
gan=CycleGan()
start_time = datetime.datetime.now()
batch_size=1
valid = np.ones((batch_size,16,16,1))
fake = np.zeros((batch_size,16,16,2))
for epoch in tqdm(range(epochs):)
for batch_i, (imgs_A, imgs_B) in enumerate(dataset.load_batch(batch_size)):
fake_B = gan.g_AB.predict(imgs_A)
fake_A = gan.g_BA.predict(imgs_B)
dA_loss_real = gan.d_A.train_on_batch(imgs_A, valid)
dA_loss_fake = gan.d_A.train_on_batch(fake_A, fake)
dA_loss = 0.5 * np.add(dA_loss_real, dA_loss_fake)
dB_loss_real = gan.d_B.train_on_batch(imgs_B, valid)
dB_loss_fake = gan.d_B.train_on_batch(fake_B, fake)
dB_loss = 0.5 * np.add(dB_loss_real, dB_loss_fake)
d_loss = 0.5 * np.add(dA_loss, dB_loss)
g_loss = gan.combined.train_on_batch([imgs_A, imgs_B],
[valid, valid,
imgs_A, imgs_B,
imgs_A, imgs_B])
elapsed_time = datetime.datetime.now() - start_time
print ("[Epoch %d/%d] [Batch %d/%d] [D loss: %f, acc: %3d%%] [G loss: %05f, adv: %05f, recon: %05f, id: %05f] time: %s " \
% ( epoch, epochs,
batch_i, len(dataset.load_batch()),
d_loss[0], 100*d_loss[1],
g_loss[0],
np.mean(g_loss[1:3]),
np.mean(g_loss[3:5]),
np.mean(g_loss[5:6]),
elapsed_time))
writer.add_scalar('Score/Fake', fake_score, niter)
writer.add_scalar('Instance Noise', noise_level, niter)
if epoch % log_interval == 0:
if print_output:
print(
"Epoch [{}/{}], Step [{}/{}], Loss_g: {:.4f}, Loss_d: {:.4f}, Real Score: {:.2f}, Fake Score: {:.2f}"
.format(epoch, num_epochs, n, num_batches, g_loss, d_loss,
real_score, fake_score))
print("VAE loss: {}".format(vae_loss))
n_samples = 4
netE.eval()
netG.eval()
data = Variable(dataset.load_batch(n_samples)).cuda()
reconstructions, _, _ = reconstruct(data)
originals = data.data.cpu()
inputs = inputs = helpers.add_gaussian_noise(data,
noise_level).data.cpu()
fake_input = helpers.add_gaussian_noise(reconstructions,
noise_level).data.cpu()
reconstructions = reconstructions.data.cpu()
generations = sample(n_samples).view(-1, nc, img_size,
img_size).data.cpu()
sequence = torch.cat(
(originals, inputs, fake_input, reconstructions, generations), 0)
grid = helpers.convert_image_np(
torchvision.utils.make_grid(sequence, n_samples))