def train(self, d_model_A, d_model_B, g_model_AtoB, g_model_BtoA,
c_model_AtoB, c_model_BtoA, dataset):
''' tarining step for cyclegan models'''
# define properties of the training run
n_epochs, n_batch, = 50, 1
# determine the output square shape of the discriminator
n_patch = d_model_A.output_shape[1]
# unpack dataset
trainA, trainB = dataset
# prepare image pool for fakes
poolA, poolB = list(), list()
# calculate the number of batches per training epoch
bat_per_epo = int(len(trainA) / n_batch)
# calculate the number of training iterations
n_steps = bat_per_epo * n_epochs
# manually enumerate epochs
for i in range(n_steps):
# select a batch of real samples
X_realA, y_realA = generate_real_samples(trainA, n_batch, n_patch)
X_realB, y_realB = generate_real_samples(trainB, n_batch, n_patch)
# generate a batch of fake samples
X_fakeA, y_fakeA = generate_fake_samples(g_model_BtoA, X_realB,
n_patch)
X_fakeB, y_fakeB = generate_fake_samples(g_model_AtoB, X_realA,
n_patch)
# update fakes from pool
X_fakeA = update_image_pool(poolA, X_fakeA)
X_fakeB = update_image_pool(poolB, X_fakeB)
# update generator B->A via adversarial and cycle los
g_loss2, _, _, _, _ = c_model_BtoA.train_on_batch(
[X_realB, X_realA], [y_realA, X_realA, X_realB, X_realA])
# update discriminator for A -> [real/fake]
dA_loss1 = d_model_A.train_on_batch(X_realA, y_realA)
dA_loss2 = d_model_A.train_on_batch(X_fakeA, y_fakeA)
# update generator A->B via adversarial and cycle loss
g_loss1, _, _, _, _ = c_model_AtoB.train_on_batch(
[X_realA, X_realB], [y_realB, X_realB, X_realA, X_realB])
# update discriminator for B -> [real/fake]
dB_loss1 = d_model_B.train_on_batch(X_realB, y_realB)
dB_loss2 = d_model_B.train_on_batch(X_fakeB, y_fakeB)
# summarize performance
print('>%d, dA[%.3f,%.3f] dB[%.3f,%.3f] g[%.3f,%.3f]' %
(i + 1, dA_loss1, dA_loss2, dB_loss1, dB_loss2, g_loss1,
g_loss2))
# evaluate the model performance every so often
if (i + 1) % (bat_per_epo * 1) == 0:
# plot A->B translation
summarize_performance(i, g_model_AtoB, trainA, 'AtoB')
# plot B->A translation
summarize_performance(i, g_model_BtoA, trainB, 'BtoA')
if (i + 1) % (bat_per_epo * 5) == 0:
# save the models
save_models(i, g_model_AtoB, g_model_BtoA)
def train(g_model,
d_model,
gan_model,
dataset,
latent_dim,
cat,
epochs=100,
batch=64):
batch_per_epoch = int(dataset.shape[0] / batch)
steps = batch_per_epoch * epochs
half_batch = int(batch / 2)
for i in range(steps):
X_real, y_real = generate_real_samples(dataset, half_batch)
d_loss1 = d_model.train_on_batch(X_real, y_real)
X_fake, y_fake = generate_fake_samples(g_model, latent_dim, cat,
half_batch)
d_loss2 = d_model.train_on_batch(X_fake, y_fake)
z_input, cat_codes = generate_latent_points(latent_dim, cat, batch)
y_gan = np.ones((batch, 1))
_, g_1, g_2 = gan_model.train_on_batch(z_input, [y_gan, cat_codes])
print("[INFO] {:d}, d[{:.3f}, {:.3f}], g[{:.3f}], q[{:.3f}]".format(
i + 1, d_loss1, d_loss2, g_1, g_2))
if (i + 1) % (batch_per_epoch * 10) == 0:
summarize_performance(i, g_model, gan_model, latent_dim, cat)
def train(dataset, generator, discriminator, gan_model, latent_dim=100, n_epochs=20, n_batch=25):
bat_per_epo = int(dataset.shape[0] / n_batch)
half_batch = int(n_batch / 2)
for i in range(n_epochs):
# enumerate batches over the training set
for j in range(bat_per_epo):
start_time = time.time()
# get randomly selected 'real' samples
X_real, y_real = utils.generate_real_samples(dataset, half_batch)
# update discriminator model weights
d_loss1, _ = discriminator.train_on_batch(X_real, y_real)
# generate 'fake' examples
X_fake, y_fake = utils.generate_fake_samples(generator, latent_dim, half_batch)
# update discriminator model weights
d_loss2, _ = discriminator.train_on_batch(X_fake, y_fake)
# prepare points in latent space as input for the generator
X_gan = utils.generate_latent_points(latent_dim, n_batch)
# create inverted labels for the fake samples
y_gan = tf.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
time_taken = time.time() - start_time
print('>%d, %d/%d, d1=%.3f, d2=%.3f g=%.3f Time Taken:%.2f seconds' %
(i + 1, j + 1, bat_per_epo, d_loss1, d_loss2, g_loss, time_taken))
# evaluate the model performance, sometimes
if (i + 1) % 10 == 0:
summarize_performance(i, generator, discriminator, dataset, latent_dim)
def train(generator,
discriminator,
gan,
dataset,
latent_dim,
epochs=100,
batch=128):
batch_per_epoch = int(dataset.shape[0] / batch)
half_batch = int(batch / 2)
for i in range(epochs):
for j in range(batch_per_epoch):
X_real, y_real = generate_real_samples(dataset, half_batch)
d_loss1, _ = discriminator.train_on_batch(X_real, y_real)
X_fake, y_fake = generate_fake_samples(generator, latent_dim,
half_batch)
d_loss2, _ = discriminator.train_on_batch(X_fake, y_fake)
Xgan = generate_latent_points(latent_dim, batch)
ygan = np.ones((batch, 1))
g_loss = gan.train_on_batch(Xgan, ygan)
print("{:d}, {:d}/{:d}, d1={:.3f}, d2={:.3f}, g={:.3f}".format(
i + 1, j + 1, batch_per_epoch, d_loss1, d_loss2, g_loss))
generator.save("models/generator.h5")
def train_discriminator(model, dataset, n_iter=20, n_batch=25, latent_dim=100):
half_batch = int(n_batch / 2)
for i in range(n_iter):
X_real, y_real = utils.generate_real_samples(dataset=dataset, num_samples=half_batch)
_, real_acc = model.train_on_batch(X_real, y_real)
X_fake, y_fake = utils.generate_fake_samples(model, latent_dim=latent_dim, num_samples=half_batch)
_, fake_acc = model.train_on_batch(X_fake, y_fake)
print('>%d real=%.0f%% fake=%.0f%%' % (i + 1, real_acc * 100, fake_acc * 100))
def summarize_performance(epoch, g_model, d_model, dataset, latent_dim, n_samples=150):
# prepare real samples
X_real, y_real = utils.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 = utils.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 = 'generator_model_%03d.h5' % (epoch + 1)
g_model.save(filename)
def train(g_model,
d_model,
gan_model,
dataset,
latent_dim,
epochs=20,
batch=64):
batch_per_epoch = int(dataset.shape[0] / batch)
steps = batch_per_epoch * epochs
half_batch = int(batch / 2)
d1_hist, d2_hist, g_hist = list(), list(), list()
for i in range(steps):
X_real, y_real = generate_real_samples(dataset, half_batch)
X_fake, y_fake = generate_fake_samples(g_model, latent_dim, half_batch)
# update discriminator model
d_loss1 = d_model.train_on_batch(X_real, y_real)
d_loss2 = d_model.train_on_batch(X_fake, y_fake)
# update generator via discriminator's loss
z_input = generate_latent_points(latent_dim, batch)
y_real2 = np.ones((batch, 1))
g_loss = gan_model.train_on_batch(z_input, y_real2)
print("{:d}, d1={:.3f}, d2={:.3f}, g={:.3f}".format(
i + 1, d_loss1, d_loss2, g_loss))
d1_hist.append(d_loss1)
d2_hist.append(d_loss2)
g_hist.append(g_loss)
if (i + 1) % (batch_per_epoch * 1) == 0:
summarize_performance(i, g_model, latent_dim)
plot_history(d1_hist, d2_hist, g_hist)