def train_full(d_model,
g_model,
gan_model,
latent_space=100,
iter=100,
num_batch=256,
verbose=False):
y_gan = np.ones((num_batch, 1))
for i in range(iter):
x_real, y_real = generate_real_data(num_batch)
x_fake, y_fake = generate_fake_samples(g_model, latent_space,
num_batch)
#print(x_real.shape)
#print(x_fake.shape)
x, y = np.vstack((x_real, x_fake)), np.vstack((y_real, y_fake))
x_gan = generate_latent_space(latent_space, num_batch)
#first, update the discriminator model with real and fake samples
d_loss, _ = d_model.train_on_batch(x, y)
#second, update the generator via the composite model
g_loss = gan_model.train_on_batch(x_gan, y_gan)
if verbose:
print("iter: %d, discriminator loss: %.3f, generator loss: %.3f" %
(i + 1, d_loss, g_loss))
if i % 100 == 0:
summarize_performance(i, g_model, d_model, latent_space)
def train(g_model,
d_model,
gan_model,
dataset,
latent_dim,
n_epochs=60,
n_batch=256):
batch_per_epoch = int(dataset.shape[0] / n_batch) # 195
half_batch = int(n_batch / 2)
# enumerate over epochs
for i in range(n_epochs):
# enumerate over training set
for j in range(batch_per_epoch):
# get real samples
X_real, y_real = util.generate_real_samples(dataset, half_batch)
# update discriminator
d_loss1, d_acc1 = d_model.train_on_batch(X_real, y_real)
# generate fake samples
X_fake, y_fake = generator.generate_fake_samples(
g_model, latent_dim, half_batch)
# update discriminator
d_loss2, d_acc2 = d_model.train_on_batch(X_fake, y_fake)
# points in latent space
X_gan = generator.generate_latent_points(latent_dim, n_batch)
# inverted labels
y_gan = np.ones((n_batch, 1))
# update gan
g_loss = gan_model.train_on_batch(X_gan, y_gan)
# print performance to console
print(
">>Epoch:%d, %d/%d, d_loss_real=%.2f, d_loss_fake=%.3f, gan_loss=%.3f, acc-real=%d, acc-fake=%d"
% (i + 1, j + 1, batch_per_epoch, d_loss1, d_loss2, g_loss,
int(d_acc1 * 100), int(d_acc2 * 100)))
if (i + 1) % 5 == 0:
eval_performance(i, g_model, d_model, dataset, latent_dim)
def summarize_performance(iter, g_model, d_model, latent_dim, n_sample=100):
x_real, y_real = generate_real_data(n_sample)
_, acc_real = d_model.evaluate(x_real, y_real, verbose=0)
x_fake, y_fake = generate_fake_samples(g_model, latent_dim, n_sample)
_, acc_fake = d_model.evaluate(x_fake, y_fake, verbose=0)
print('Accuracy real: %.0f%%, fake: %.0f%%' %
(acc_real * 100, acc_fake * 100))
save_plot(x_fake, iter)
filename = 'generator_model_%03d.h5' % (iter)
g_model.save(filename)
def summarize_performance(epoch,
g_model,
d_model,
dataset,
latent_dim,
n_samples=100):
# prepare real samples
X_real, y_real = generate_real_samples(dataset, n_samples)
# evaluate discriminator on real examples
_, acc_real = d_model.evaluate(X_real, y_real, verbose=0)
# prepare fake examples
x_fake, y_fake = generate_fake_samples(g_model, latent_dim, n_samples)
# evaluate discriminator on fake examples
_, acc_fake = d_model.evaluate(x_fake, y_fake, verbose=0)
# summarize discriminator performance
print('>Accuracy real: %.0f%%, fake: %.0f%%' %
(acc_real * 100, acc_fake * 100))
# save plot
save_plot(x_fake, epoch)
# save the generator model tile file
filename = 'models/generator_model_%03d.h5' % (epoch + 1)
g_model.save(filename)
def eval_performance(epoch,
g_model,
d_model,
dataset,
latent_dim,
n_samples=150):
# real samples
X_real, y_real = util.generate_real_samples(dataset, n_samples)
# evaluate discriminator
_, acc_real = d_model.evaluate(X_real, y_real, verbose=0)
# fake samples
X_fake, y_fake = generator.generate_fake_samples(g_model, latent_dim,
n_samples)
# evaluate
_, acc_fake = d_model.evaluate(X_fake, y_fake, verbose=0)
# print to console
print(">>Accuracy Real: %.0f%%, Fake: %.0f%%" %
(acc_real * 100, acc_fake * 100))
# save plot
save_plot(X_fake, epoch)
# save model
filename = "results_glorot_normal/model_%03d.h5" % (epoch + 1)
g_model.save(filename)
def train(g_model,
d_model,
gan_model,
dataset,
latent_dim,
n_epochs=100,
n_batch=256):
bat_per_epo = int(dataset.shape[0] / n_batch)
half_batch = int(n_batch / 2)
# manually enumerate epochs
for i in range(n_epochs):
# enumerate batches over the training set
for j in range(bat_per_epo):
# get randomly selected 'real' samples
X_real, y_real = generate_real_samples(dataset, half_batch)
# generate 'fake' examples
X_fake, y_fake = generate_fake_samples(g_model, latent_dim,
half_batch)
# create training set for the discriminator
X, y = vstack((X_real, X_fake)), vstack((y_real, y_fake))
# update discriminator model weights
d_loss, _ = d_model.train_on_batch(X, y)
# prepare points in latent space as input for the generator
X_gan = generate_latent_points(latent_dim, n_batch)
# create inverted labels for the fake samples
y_gan = ones((n_batch, 1))
# update the generator via the discriminator's error
g_loss = gan_model.train_on_batch(X_gan, y_gan)
# summarize loss on this batch
print('>%d, %d/%d, d=%.3f, g=%.3f' %
(i + 1, j + 1, bat_per_epo, d_loss, g_loss))
# evaluate the model performance, each 10 epochs
if (i + 1) % 10 == 0:
summarize_performance(i, g_model, d_model, dataset, latent_dim)
# save the generator model tile file
filename = 'generator_model_%03d.h5' % (i + 1)
g_model.save(filename)